diff --git a/.agents/criteria-for-adding-quantities-and-units.md b/.agents/criteria-for-adding-quantities-and-units.md
new file mode 100644
index 0000000000..a3ca300b90
--- /dev/null
+++ b/.agents/criteria-for-adding-quantities-and-units.md
@@ -0,0 +1,44 @@
+# Criteria for adding quantities and units
+
+See also: [Docs/adding-a-new-unit.md](../Docs/adding-a-new-unit.md#great-but-before-you-start) for the full contributor guide.
+
+To avoid bloating the library, we want to ensure quantities and units are widely used and well defined.
+Avoid little used units that are obscure or too domain specific.
+Ask for justification and use cases if this is not clear.
+
+### A quantity is a good fit to add, if it
+
+- [x] Is well documented and unambiguous, e.g. has a wiki page and generally easy to find on Google
+- [x] Is widely used, preferably across domains
+- [x] Has multiple units to convert between (e.g. `Length` has kilometer, feet, nanometer etc.)
+- [x] Can convert to other quantities (e.g. `Length x Length = Area`)
+- [x] Can be represented by a `double` numeric value, integer values are not well supported and may suffer from precision errors
+- [x] Is not [dimensionless/unitless](https://en.wikipedia.org/wiki/Dimensionless_quantity) (consider using `Ratio`)
+
+Single-unit quantities are the exception. If a proposed quantity has only one unit, it needs stronger justification: the quantity must be widely used as a typed quantity representation on its own, not just as a unit abbreviation with no conversions.
+
+### A unit is a good fit to add to a quantity, if it
+
+- [x] Is well documented and unambiguous, e.g. has a wiki page or found in online unit converters
+- [x] Is widely used
+- [x] Can be converted to other units of the same quantity
+- [x] The conversion function is well established without ambiguous competing standards
+
+### Review test values for new units
+
+- [x] Test values use literal constants, not expressions that repeat the JSON conversion functions
+- [x] Test values preferably cite a verifiable source, such as an online converter, standard, or reference table
+- [x] Test values have at least 7 significant figures where possible, but no more precision than `double` can usefully represent
+- [x] The expected value independently sanity-checks the conversion function instead of mirroring its implementation
+
+### Review abbreviations for new units
+
+- [x] The primary abbreviation is the technically precise one when there is a clear distinction, such as `lbf`, `ozf`, or `gf` for force-derived compound units
+- [x] Common shorthand variants such as `lb`, `oz`, or `g` are only secondary abbreviations, and only when they are widely used and unambiguous for that quantity
+- [x] Shorthand aliases do not create ambiguity with another unit in the same quantity
+- [x] Common shorthand aliases that fit multiple quantities are mapped to each relevant quantity, e.g. `ft-lb` for torque and energy, or `oz·in` for torque and static unbalance
+- [x] Singular unit symbols such as `lb` and `oz` are preferred over pluralized forms such as `lbs` and `ozs`; pluralized forms should only be secondary aliases when they are strong domain conventions
+
+### Avoid X-per-Y units
+
+There are many variations of unit A over unit B, such as `LengthPerAngle` and we want to avoid adding these unless they are very common.
diff --git a/.claude/criteria-for-adding-quantities-and-units.md b/.claude/criteria-for-adding-quantities-and-units.md
deleted file mode 100644
index ab0766c477..0000000000
--- a/.claude/criteria-for-adding-quantities-and-units.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# Criteria for adding quantities and units
-
-See also: [Docs/adding-a-new-unit.md](../Docs/adding-a-new-unit.md#great-but-before-you-start) for the full contributor guide.
-
-To avoid bloating the library, we want to ensure quantities and units are widely used and well defined.
-Avoid little used units that are obscure or too domain specific.
-Ask for justification and use cases if this is not clear.
-
-### A quantity is a good fit to add, if it
-
-- [x] Is well documented and unambiguous, e.g. has a wiki page and generally easy to find on Google
-- [x] Is widely used, preferably across domains
-- [x] Has multiple units to convert between (e.g. `Length` has kilometer, feet, nanometer etc.)
-- [x] Can convert to other quantities (e.g. `Length x Length = Area`)
-- [x] Can be represented by a `double` numeric value, integer values are not well supported and may suffer from precision errors
-- [x] Is not [dimensionless/unitless](https://en.wikipedia.org/wiki/Dimensionless_quantity) (consider using `Ratio`)
-
-### A unit is a good fit to add to a quantity, if it
-
-- [x] Is well documented and unambiguous, e.g. has a wiki page or found in online unit converters
-- [x] Is widely used
-- [x] Can be converted to other units of the same quantity
-- [x] The conversion function is well established without ambiguous competing standards
-
-### Avoid X-per-Y units
-
-There are many variations of unit A over unit B, such as `LengthPerAngle` and we want to avoid adding these unless they are very common.
\ No newline at end of file
diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json
index e9d3dfb6dc..b328674053 100644
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -2,11 +2,12 @@
   "version": 1,
   "isRoot": true,
   "tools": {
-    "jetbrains.dotcover.globaltool": {
-      "version": "2022.2.3",
+    "jetbrains.dotcover.commandlinetools": {
+      "version": "2025.1.8",
       "commands": [
-        "dotnet-dotcover"
-      ]
+        "dotCover"
+      ],
+      "rollForward": false
     },
     "timeitsharp": {
       "version": "0.0.8",
@@ -15,4 +16,4 @@
       ]
     }
   }
-}
\ No newline at end of file
+}
diff --git a/.devcontainer/unitsnet-modular/devcontainer.json b/.devcontainer/unitsnet-modular/devcontainer.json
new file mode 100644
index 0000000000..9c8c226bd2
--- /dev/null
+++ b/.devcontainer/unitsnet-modular/devcontainer.json
@@ -0,0 +1,22 @@
+{
+  "name": "UnitsNet.Modular samples",
+  "image": "mcr.microsoft.com/devcontainers/dotnet:10.0-noble",
+  "postCreateCommand": "dotnet build UnitsNet.Modular/Samples/UnitsNet.Modular.Samples.slnx -p:Platform=ProjectReferences",
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-dotnettools.csdevkit"
+      ],
+      "settings": {
+        "dotnet.defaultSolution": "UnitsNet.Modular/Samples/UnitsNet.Modular.Samples.slnx",
+        "csharp.debug.console": "integratedTerminal",
+        "terminal.integrated.cwd": "${workspaceFolder}/UnitsNet.Modular/Samples"
+      }
+    },
+    "codespaces": {
+      "openFiles": [
+        "UnitsNet.Modular/Samples/README.md"
+      ]
+    }
+  }
+}
diff --git a/.editorconfig b/.editorconfig
index 1a45a47681..0e7f9de86f 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -8,13 +8,13 @@ root = true
 [*]
 indent_style = space
 trim_trailing_whitespace = true
+charset = utf-8
 # (Please don't specify an indent_size here; that has too many unintended consequences.)
 
 # Code files
 [*.{cs,csx,vb,vbx}]
 indent_size = 4
 insert_final_newline = true
-charset = utf-8-bom
 
 [*.{cmd,bat}]
 indent_size = 2
@@ -25,7 +25,6 @@ insert_final_newline = false
 indent_size = 2
 end_of_line = crlf
 insert_final_newline = true
-charset = utf-8-bom
 
 # Xml project files
 [*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,projitems,shproj}]
diff --git a/.github/actions/run-benchmarks/action.yaml b/.github/actions/run-benchmarks/action.yaml
index c865add65b..f420fa7ac2 100644
--- a/.github/actions/run-benchmarks/action.yaml
+++ b/.github/actions/run-benchmarks/action.yaml
@@ -1,13 +1,13 @@
 name: 'Run benchmark'
 inputs:
   framework:
-    description: 'The runtime version to use (e.g. net5.0)'
+    description: 'The target framework used to host the benchmarks (e.g. net10.0)'
     required: false
-    default: 'net5.0'
+    default: 'net10.0'
   runtimes:
-    description: 'The runtime version to use (e.g. netcoreapp31, net5.0)'
+    description: 'The runtime versions to benchmark (e.g. net10.0, net9.0, net48)'
     required: false
-    default: 'net5.0'
+    default: 'net10.0'
   output-folder:
     description: 'The output folder for the benchmark (a results folder is created inside)'
     required: false
@@ -40,4 +40,4 @@ runs:
         --exporters ${{ inputs.exporters }} 
         --filter '${{ inputs.filter }}' 
         ${{ inputs.categories }} ${{ inputs.execution-options }}
-      shell: bash
\ No newline at end of file
+      shell: bash
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5feb563ec4..1e00d266c5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -7,9 +7,43 @@ on:
       - 'release/**'
       - 'maintenance/**'
     paths-ignore:
-      - '**/*.png'
       - '**/*.md'
+      - '**/*.png'
   workflow_dispatch:
+    inputs:
+      run_tests:
+        description: Run tests
+        required: true
+        default: true
+        type: boolean
+      collect_coverage:
+        description: Collect and upload coverage (requires tests)
+        required: true
+        default: true
+        type: boolean
+      pack_nugets:
+        description: Pack and upload NuGet artifacts
+        required: true
+        default: true
+        type: boolean
+      upload_artifacts:
+        description: Create and upload the full artifact archive
+        required: true
+        default: true
+        type: boolean
+      publish_nuget:
+        description: Publish to nuget.org (master only; forces packing)
+        required: true
+        default: false
+        type: boolean
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  # Never interrupt a master run while it may be publishing an immutable package set.
+  cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 env:
   DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
@@ -17,93 +51,110 @@ env:
 
 jobs:
   build-and-test:
-    name: Build & Test
-    runs-on: windows-latest
+    name: CI Build & Test
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      contents: read
+      id-token: write
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v7
       with:
         fetch-depth: 1
         lfs: true
 
-    - name: Setup .NET SDK
-      uses: actions/setup-dotnet@v4
+    - name: Setup .NET SDKs
+      uses: actions/setup-dotnet@v6
       with:
         dotnet-version: |
-          6.0.x
           8.0.x
+          9.0.x
+          10.0.x
 
-    - name: Setup .NET nanoFramework build components
-      uses: nanoframework/nanobuild@v1
-      with:
-        workload: 'nanoFramework'
-
-    - name: Build, Test and Pack
-      shell: pwsh
-      run: |
-        ./Build/build.ps1 -IncludeNanoFramework
-      working-directory: ${{ github.workspace }}
-
-    - name: Upload to codecov.io
+    - name: Build selected components
       shell: pwsh
       env:
-        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+        RUN_TESTS: ${{ github.event_name != 'workflow_dispatch' || inputs.run_tests }}
+        COLLECT_COVERAGE: ${{ github.event_name != 'workflow_dispatch' || inputs.collect_coverage }}
+        PACK_NUGETS: ${{ github.event_name != 'workflow_dispatch' || inputs.pack_nugets || inputs.publish_nuget }}
+        CREATE_ARCHIVE: ${{ github.event_name != 'workflow_dispatch' || inputs.upload_artifacts }}
       run: |
-        Write-Host -Foreground Green "Downloading codecov binaries..."
-
-        Invoke-WebRequest -Uri https://uploader.codecov.io/verification.gpg -OutFile codecov.asc
-        gpg.exe --import codecov.asc
-
-        Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe -Outfile codecov.exe
-        Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe.SHA256SUM -Outfile codecov.exe.SHA256SUM
-        Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe.SHA256SUM.sig -Outfile codecov.exe.SHA256SUM.sig
-
-        gpg.exe --verify codecov.exe.SHA256SUM.sig codecov.exe.SHA256SUM
-        If ($(Compare-Object -ReferenceObject  $(($(certUtil -hashfile codecov.exe SHA256)[1], "codecov.exe") -join "  ") -DifferenceObject $(Get-Content codecov.exe.SHA256SUM)).length -eq 0) { echo "SHASUM verified" } Else {exit 1}
-
-        Write-Host -Foreground Green "Uploading to codecov..."
-
-        .\codecov.exe --dir "Artifacts/Coverage" -t "$env:CODECOV_TOKEN" --build "${{ github.run_number }}"
-
-        Write-Host -Foreground Green "✅ Uploaded to codecov."
-
-    - name: Upload Artifacts
-      uses: actions/upload-artifact@v4
+        $buildArguments = @()
+        if ($env:RUN_TESTS -ne 'true') { $buildArguments += '-SkipTests' }
+        if ($env:COLLECT_COVERAGE -ne 'true') { $buildArguments += '-SkipCoverage' }
+        if ($env:PACK_NUGETS -ne 'true') { $buildArguments += '-SkipPack' }
+        if ($env:CREATE_ARCHIVE -ne 'true') { $buildArguments += '-SkipArchive' }
+        ./Build/build.ps1 @buildArguments
+
+    # Codecov intermittently fails while importing its verification key from Keybase.
+    # Keep coverage non-blocking until upstream adds reliable retry/error handling:
+    # https://github.com/codecov/codecov-action/issues/1876
+    # https://github.com/codecov/wrapper/pull/66
+    - name: Upload coverage to Codecov
+      if: github.event_name != 'workflow_dispatch' || (inputs.run_tests && inputs.collect_coverage)
+      continue-on-error: true
+      uses: codecov/codecov-action@v6
+      with:
+        directory: Artifacts/Coverage
+        fail_ci_if_error: true
+        plugins: noop
+        use_oidc: true
+
+    - name: Upload artifacts
+      if: github.event_name != 'workflow_dispatch' || inputs.upload_artifacts
+      uses: actions/upload-artifact@v7
       with:
         name: artifacts
         path: Artifacts/
         retention-days: 30
 
     - name: Upload NuGet packages
-      uses: actions/upload-artifact@v4
+      if: github.event_name != 'workflow_dispatch' || inputs.pack_nugets || inputs.publish_nuget
+      uses: actions/upload-artifact@v7
       with:
         name: nuget-packages
         path: |
           Artifacts/**/*.nupkg
           Artifacts/**/*.snupkg
+        if-no-files-found: error
         retention-days: 30
 
   publish-nuget:
-    name: Publish to NuGet
+    name: Publish NuGet packages
     needs: build-and-test
     runs-on: ubuntu-latest
-    if: github.ref == 'refs/heads/master' && github.repository_owner == 'angularsen'
+    timeout-minutes: 10
+    if: >-
+      github.ref == 'refs/heads/master' &&
+      github.repository_owner == 'angularsen' &&
+      (github.event_name == 'push' || inputs.publish_nuget)
     environment: Publish
+    permissions:
+      contents: read
+      id-token: write
 
     steps:
     - name: Download NuGet packages
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v8
       with:
         name: nuget-packages
         path: nugets
 
     - name: Setup .NET SDK
-      uses: actions/setup-dotnet@v4
+      uses: actions/setup-dotnet@v6
+      with:
+        dotnet-version: 10.0.x
+
+    - name: Log in to NuGet with trusted publishing
+      uses: NuGet/login@v1
+      id: nuget-login
       with:
-        dotnet-version: 8.0.x
+        user: angularsen
 
     - name: Push to nuget.org
-      run: |
-        dotnet nuget push "**/*.nupkg" --skip-duplicate --api-key ${{ secrets.NUGET_ORG_APIKEY }} --source https://api.nuget.org/v3/index.json
-      working-directory: nugets
\ No newline at end of file
+      env:
+        NUGET_API_KEY: ${{ steps.nuget-login.outputs.NUGET_API_KEY }}
+      run: dotnet nuget push "**/*.nupkg" --skip-duplicate --api-key "$NUGET_API_KEY" --source https://api.nuget.org/v3/index.json
+      working-directory: nugets
diff --git a/.github/workflows/claude-code-review.yml b/.github/workflows/claude-code-review.yml
index 6914ea916a..7097648876 100644
--- a/.github/workflows/claude-code-review.yml
+++ b/.github/workflows/claude-code-review.yml
@@ -12,6 +12,9 @@ on:
 
 jobs:
   claude-review:
+    # Fork PRs cannot request OIDC tokens and contain untrusted input. A
+    # maintainer can request a review explicitly by commenting `@claude`.
+    if: github.event.pull_request.head.repo.full_name == github.repository
     # Optional: Filter by PR author
     # if: |
     #   github.event.pull_request.user.login == 'external-contributor' ||
@@ -41,7 +44,7 @@ jobs:
             - Breaking changes, if any
             - Style and conventions
             - New quantities or units
-              - See `.claude/pr-review-instructions.md` for guidance and criteria, they should be widely used and well defined
+              - See `.agents/criteria-for-adding-quantities-and-units.md` for guidance and criteria, they should be widely used and well defined
               - If it seems domain specific or obscure we ask for justification and use cases
             - Changes to generated code
               - Focus feedback on changes to code generators
@@ -55,6 +58,22 @@ jobs:
             Use the repository's CLAUDE.md for guidance on style and conventions.
             Be constructive and helpful in your feedback, keep it concise.
 
+            Make the review outcome and every bullet point easy to scan:
+            - Start with exactly one of these headings:
+              - `## ✅ Review: No actionable findings`
+              - `## ⚠️ Review: Non-blocking findings`
+              - `## ❌ Review: Blocking findings`
+            - Prefix every section heading with an emoji that summarizes its most severe bullet,
+              for example `### ✅ Test coverage`, `### ⚠️ Breaking changes`, or `### ❌ Code quality & correctness`.
+            - For both the overall review and each section, use ❌ if it contains any defects or blocking issues,
+              otherwise ⚠️ if it contains any non-blocking concerns, questions, or suggestions, otherwise ✅.
+            - Prefix every feedback bullet with exactly one status emoji:
+              - ✅ for a positive verification or something that is correct as-is
+              - ⚠️ for a non-blocking concern, question, or suggestion
+              - ❌ for a defect or blocking issue that should be fixed
+            - Keep each bullet to one status. If a point contains both positive and negative feedback, split it into separate bullets.
+            - When a section has no findings, either omit it or write `✅ No concerns identified.`
+
             Use `gh pr comment` with your Bash tool to leave your review as a comment on the PR.
 
           # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 95c7ece36b..4fb53e874f 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -40,10 +40,10 @@ jobs:
     - name: Checkout repository
       uses: actions/checkout@v2
     
-    # .NET 6 is used in CodeGen project.
-    - uses: actions/setup-dotnet@v1
+    # CodeGen and the standard build/test toolchain use .NET 10.
+    - uses: actions/setup-dotnet@v6
       with:
-        dotnet-version: '6.0.x'
+        dotnet-version: '10.0.x'
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
diff --git a/.github/workflows/continious-benchmarking.yml b/.github/workflows/continious-benchmarking.yml
index 24b5b7421e..9b4dd65e1c 100644
--- a/.github/workflows/continious-benchmarking.yml
+++ b/.github/workflows/continious-benchmarking.yml
@@ -9,7 +9,7 @@ on:
       - ".github/actions/**"
 
 env:
-  FRAMEWORK: net6.0
+  FRAMEWORK: net10.0
   EXECUTION_OPTIONS: --iterationTime 500 --disableLogFile # see https://benchmarkdotnet.org/articles/guides/console-args.html
   BENCHMARK_PAGES_BRANCH: gh-pages
   BENCHMARK_DATA_FOLDER: benchmarks
@@ -21,25 +21,19 @@ jobs:
     strategy:
       # max-parallel: 1 # is it better to avoid running in parallel?
       matrix:
-        runtime: ["net6.0", "netcoreapp21", "net472"]
+        runtime: ["net10.0", "net9.0", "net48"]
     steps:
       - run: echo Starting benchmarks for ${{ matrix.runtime }}
 
       # checkout the current branch
       - uses: actions/checkout@v2
 
-      # we need all frameworks (even if only running one target at a time)
-      - uses: actions/setup-dotnet@v1
+      # The benchmark host targets net10, with net9 installed for runtime comparisons.
+      - uses: actions/setup-dotnet@v6
         with:
-          dotnet-version: "2.1.x"
-
-      - uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: "3.1.x"
-
-      - uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: "5.0.x"
+          dotnet-version: |
+            9.0.x
+            10.0.x
 
       # executing the benchmark for the current framework, placing the result in a corresponding sub-folder
       - uses: ./.github/actions/run-benchmarks
@@ -62,7 +56,7 @@ jobs:
     strategy:
       max-parallel: 1 # cannot commit on the same branch in parallel
       matrix:
-        runtime: ["net6.0", "netcoreapp21", "net472"]
+        runtime: ["net10.0", "net9.0", "net48"]
     steps:
       - name: Initializing git folder ️
         uses: actions/checkout@v2.3.1
diff --git a/.github/workflows/net48-compatibility.yml b/.github/workflows/net48-compatibility.yml
new file mode 100644
index 0000000000..fc1edadbae
--- /dev/null
+++ b/.github/workflows/net48-compatibility.yml
@@ -0,0 +1,146 @@
+name: net48 Compatibility
+
+on:
+  # Remove `pull_request` for post-merge validation only, or remove `push` for PR validation only.
+  # Test and coverage behavior is identical for every enabled trigger.
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+concurrency:
+  group: net48-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+env:
+  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+
+jobs:
+  test:
+    name: ${{ github.event_name == 'pull_request' && 'PR net48 Build & Test' || 'CI net48 Build & Test' }}
+    runs-on: windows-latest
+    timeout-minutes: 45
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v7
+      with:
+        fetch-depth: 1
+        lfs: true
+
+    - name: Setup .NET SDK
+      uses: actions/setup-dotnet@v6
+      with:
+        dotnet-version: 10.0.x
+
+    - name: Restore .NET tools
+      run: dotnet tool restore
+
+    - name: Generate code
+      run: dotnet run --project CodeGen
+
+    - name: Run the complete net48 test suite with coverage
+      shell: pwsh
+      run: |
+        Import-Module ./Build/test-projects.psm1 -Force
+        $testProjectPaths = @(Get-TestProjectPaths)
+
+        New-Item -ItemType Directory -Force -Path Artifacts/Coverage | Out-Null
+
+        foreach ($testProject in $testProjectPaths) {
+          $projectName = [IO.Path]::GetFileNameWithoutExtension($testProject)
+
+          # Keep compiler servers outside dotCover's process tree. Roslyn's VBCSCompiler has a
+          # 10-minute idle timeout, which can otherwise delay coverage-session finalization.
+          Write-Host "Building $projectName at $([DateTime]::UtcNow.ToString('O'))"
+          dotnet build $testProject `
+            --configuration Release `
+            --framework net48 `
+            -p:ContinuousIntegrationBuild=true
+
+          if ($LASTEXITCODE -ne 0) {
+            exit $LASTEXITCODE
+          }
+
+          $testArguments = @(
+            $testProject,
+            '--configuration', 'Release',
+            '--framework', 'net48',
+            '--no-build',
+            '--no-restore',
+            '--logger', 'trx',
+            '--results-directory', 'Artifacts/TestResults'
+          )
+
+          Write-Host "Testing $projectName with coverage at $([DateTime]::UtcNow.ToString('O'))"
+          dotnet tool run dotCover -- cover-dotnet `
+            --TargetWorkingDir $PWD.Path `
+            --Output "Artifacts/Coverage/$projectName.coverage.xml" `
+            --ReportType DetailedXML `
+            --Filters '+:module=UnitsNet*;-:module=*Tests' `
+            --ProcessFilters '-:VBCSCompiler*' `
+            --LogFile "Artifacts/Coverage/$projectName.dotcover.log" `
+            --ReturnTargetExitCode `
+            -- test @testArguments
+
+          if ($LASTEXITCODE -ne 0) {
+            exit $LASTEXITCODE
+          }
+        }
+
+    - name: Upload test results
+      if: always()
+      uses: actions/upload-artifact@v7
+      with:
+        name: net48-test-results
+        path: Artifacts/TestResults/*.trx
+        if-no-files-found: ignore
+        retention-days: 30
+
+    # publish-net48-test-results.yml defines the "Publish net48 Test Results"
+    # workflow_run workflow that publishes these results with checks: write. Keeping that permission
+    # out of this workflow lets fork PRs execute contributor code with a read-only token.
+    - name: Upload workflow event
+      if: always()
+      uses: actions/upload-artifact@v7
+      with:
+        name: net48-event
+        path: ${{ github.event_path }}
+        retention-days: 30
+
+    - name: Upload coverage to Codecov
+      if: ${{ success() && hashFiles('Artifacts/Coverage/*.coverage.xml') != '' }}
+      uses: codecov/codecov-action@v6
+      with:
+        directory: Artifacts/Coverage
+        fail_ci_if_error: ${{ github.event_name != 'pull_request' }}
+        flags: net48
+        name: net48-clr4
+        plugins: noop
+        use_oidc: true
+
+    - name: Upload coverage reports
+      if: always()
+      uses: actions/upload-artifact@v7
+      with:
+        name: net48-coverage
+        path: Artifacts/Coverage/*.coverage.xml
+        if-no-files-found: ignore
+        retention-days: 30
+
+    - name: Upload dotCover logs
+      if: ${{ failure() || cancelled() }}
+      uses: actions/upload-artifact@v7
+      with:
+        name: net48-dotcover-logs
+        path: Artifacts/Coverage/*.dotcover.log
+        if-no-files-found: ignore
+        retention-days: 30
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index b619c7ae0f..e02d98af61 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -7,9 +7,13 @@ on:
       - 'release/**'
       - 'maintenance/**'
     paths-ignore:
-      - '*.md'
-      - '*.png'
-      - '*.gitignore'
+      - '**/*.gitignore'
+      - '**/*.md'
+      - '**/*.png'
+
+concurrency:
+  group: pr-${{ github.workflow }}-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
 
 env:
   DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
@@ -17,77 +21,61 @@ env:
 
 jobs:
   build-and-test:
-    name: Build & Test
-    runs-on: windows-latest
+    name: PR Build & Test
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      contents: read
+      checks: write
+      id-token: write
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v7
       with:
         fetch-depth: 1
         lfs: true
 
-    - name: Setup .NET SDK
-      uses: actions/setup-dotnet@v4
+    - name: Setup .NET SDKs
+      uses: actions/setup-dotnet@v6
       with:
         dotnet-version: |
-          6.0.x
           8.0.x
+          9.0.x
+          10.0.x
 
-    - name: Setup .NET nanoFramework build components
-      uses: nanoframework/nanobuild@v1
-      with:
-        workload: 'nanoFramework'
-
-    - name: Build, Test and Pack
+    - name: Build, test and pack
       shell: pwsh
-      run: |
-        ./Build/build.ps1 -IncludeNanoFramework
-      working-directory: ${{ github.workspace }}
+      run: ./Build/build.ps1
 
-    - name: Upload Test Results
-      uses: actions/upload-artifact@v4
+    - name: Upload test results
       if: always()
+      uses: actions/upload-artifact@v7
       with:
         name: test-results
         path: Artifacts/TestResults/*.trx
+        if-no-files-found: ignore
         retention-days: 7
 
-    - name: Publish Test Results
-      uses: EnricoMi/publish-unit-test-result-action/windows@v2
-      if: always()
+    - name: Publish test results
+      if: ${{ !cancelled() && github.event.pull_request.head.repo.full_name == github.repository && hashFiles('Artifacts/TestResults/*.trx') != '' }}
+      uses: EnricoMi/publish-unit-test-result-action@v2
       with:
-        files: |
-          Artifacts/TestResults/*.trx
-        check_name: Test Results
+        files: Artifacts/TestResults/*.trx
+        check_name: PR Test Results
         comment_mode: off
 
-    - name: Upload to codecov.io
-      shell: pwsh
-      env:
-        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-      run: |
-        Write-Host -Foreground Green "Downloading codecov binaries..."
-
-        Invoke-WebRequest -Uri https://uploader.codecov.io/verification.gpg -OutFile codecov.asc
-        gpg.exe --import codecov.asc
-
-        Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe -Outfile codecov.exe
-        Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe.SHA256SUM -Outfile codecov.exe.SHA256SUM
-        Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe.SHA256SUM.sig -Outfile codecov.exe.SHA256SUM.sig
-
-        gpg.exe --verify codecov.exe.SHA256SUM.sig codecov.exe.SHA256SUM
-        If ($(Compare-Object -ReferenceObject  $(($(certUtil -hashfile codecov.exe SHA256)[1], "codecov.exe") -join "  ") -DifferenceObject $(Get-Content codecov.exe.SHA256SUM)).length -eq 0) { echo "SHASUM verified" } Else {exit 1}
-
-        Write-Host -Foreground Green "Uploading to codecov..."
-
-        .\codecov.exe --dir "Artifacts/Coverage" -t "$env:CODECOV_TOKEN" --build "${{ github.run_number }}"
-
-        Write-Host -Foreground Green "✅ Uploaded to codecov."
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v6
+      with:
+        directory: Artifacts/Coverage
+        fail_ci_if_error: false
+        plugins: noop
+        use_oidc: true
 
-    - name: Upload Artifacts
-      uses: actions/upload-artifact@v4
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v7
       with:
         name: artifacts
         path: Artifacts/
-        retention-days: 7
\ No newline at end of file
+        retention-days: 7
diff --git a/.github/workflows/publish-net48-test-results.yml b/.github/workflows/publish-net48-test-results.yml
new file mode 100644
index 0000000000..29f03fa507
--- /dev/null
+++ b/.github/workflows/publish-net48-test-results.yml
@@ -0,0 +1,50 @@
+name: Publish net48 Test Results
+
+on:
+  workflow_run:
+    workflows:
+      - net48 Compatibility
+    types:
+      - completed
+
+# This workflow receives write permission because it never checks out or executes contributor
+# code. It only downloads immutable artifacts from the exact workflow run that triggered it.
+permissions: {}
+
+jobs:
+  publish:
+    name: ${{ github.event.workflow_run.event == 'pull_request' && 'Publish PR net48 Test Results' || 'Publish CI net48 Test Results' }}
+    if: ${{ github.event.workflow_run.conclusion == 'success' || github.event.workflow_run.conclusion == 'failure' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      actions: read
+      checks: write
+
+    steps:
+    - name: Download test results
+      uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
+      with:
+        name: net48-test-results
+        path: artifacts/net48-test-results
+        github-token: ${{ github.token }}
+        run-id: ${{ github.event.workflow_run.id }}
+
+    - name: Download workflow event
+      uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
+      with:
+        name: net48-event
+        path: artifacts/net48-event
+        github-token: ${{ github.token }}
+        run-id: ${{ github.event.workflow_run.id }}
+
+    - name: Publish test results
+      if: ${{ hashFiles('artifacts/net48-test-results/*.trx') != '' }}
+      uses: EnricoMi/publish-unit-test-result-action@d0a4676d0e0b938bc201470d88276b7c74c712b3 # v2
+      with:
+        check_name: ${{ github.event.workflow_run.event == 'pull_request' && 'PR net48 Test Results' || 'CI net48 Test Results' }}
+        comment_mode: off
+        commit: ${{ github.event.workflow_run.head_sha }}
+        event_file: artifacts/net48-event/event.json
+        event_name: ${{ github.event.workflow_run.event }}
+        files: artifacts/net48-test-results/*.trx
diff --git a/.github/workflows/run-benchmarks.yml b/.github/workflows/run-benchmarks.yml
index 344d765b6b..2ee4e66997 100644
--- a/.github/workflows/run-benchmarks.yml
+++ b/.github/workflows/run-benchmarks.yml
@@ -7,8 +7,8 @@ on:
         required: false
         default: "UnitsNet Benchmarks"
       runtimes:
-        description: "The runtime version to use (e.g. net472 net48 netcoreapp21 netcoreapp31 net6.0)"
-        default: net472 netcoreapp21 net6.0
+        description: "The runtime versions to use (e.g. net10.0 net9.0 net48)"
+        default: net10.0 net9.0 net48
         required: true
       exporters:
         description: "The exporter(s) used for this run (GitHub/StackOverflow/RPlot/CSV/JSON/HTML/XML)"
@@ -29,7 +29,7 @@ on:
       comparison-baseline:
         description: "Compare against a previous result (expecting a link to *-report-full.json)"
         required: true
-        default: "https://angularsen.github.io/UnitsNet/benchmarks/netcoreapp50/results/UnitsNet.Benchmark.UnitsNetBenchmarks-report-full.json"
+        default: "https://angularsen.github.io/UnitsNet/benchmarks/net10.0/results/UnitsNet.Benchmark.UnitsNetBenchmarks-report-full.json"
       comparison-threshold:
         description: "The (comparison) threshold for Statistical Test. Examples: 5%, 10ms, 100ns, 1s"
         required: false
@@ -39,8 +39,8 @@ on:
         required: false
         default: 10
       framework:
-        description: "The dotnet-version version to use (e.g. net6.0)"
-        default: "net6.0"
+        description: "The target framework used to host the benchmarks"
+        default: "net10.0"
         required: true
 jobs:
   benchmark:
@@ -51,18 +51,12 @@ jobs:
       # checkout the current branch
       - uses: actions/checkout@v2
 
-      # we need all frameworks (even if only running one target at a time)
-      - uses: actions/setup-dotnet@v1
+      # The benchmark host targets net10, with net9 installed for runtime comparisons.
+      - uses: actions/setup-dotnet@v6
         with:
-          dotnet-version: "2.1.x"
-
-      - uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: "3.1.x"
-
-      - uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: "5.0.x"
+          dotnet-version: |
+            9.0.x
+            10.0.x
 
       # executing the benchmark for the current framework(s), placing the result in the output-folder
       - uses: ./.github/actions/run-benchmarks
@@ -110,19 +104,19 @@ jobs:
           repository: dotnet/performance
           path: comparer
 
-      - uses: actions/setup-dotnet@v1
+      - uses: actions/setup-dotnet@v6
         with:
-          dotnet-version: "3.1.x"
+          dotnet-version: "10.0.x"
 
       - run: mkdir -p artifacts
 
       # Executing the comparer, placing the result in a 'comparison' folder (as well as creating a summary from the output)
       - name: Running the ResultsComparer
         env:
-          PERFLAB_TARGET_FRAMEWORKS: net6.0
+          PERFLAB_TARGET_FRAMEWORKS: net10.0
         run: >
           dotnet run --project 'comparer/src/tools/ResultsComparer' -c Release
-          --framework net6.0
+          --framework net10.0
           --base baseline --diff results 
           --csv "artifacts/${{ env.OUPUT_NAME }}.csv"
           --xml "artifacts/${{ env.OUPUT_NAME }}.xml"
diff --git a/.github/workflows/unitsnet-modular-ci.yml b/.github/workflows/unitsnet-modular-ci.yml
new file mode 100644
index 0000000000..6b262610e0
--- /dev/null
+++ b/.github/workflows/unitsnet-modular-ci.yml
@@ -0,0 +1,186 @@
+name: UnitsNet.Modular CI
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - 'UnitsNet.Modular/*'
+    paths:
+      - '.devcontainer/unitsnet-modular/**'
+      - 'UnitsNet.Modular/**'
+      # The compatibility suite compiles the current UnitsNet project to detect source/API drift.
+      - 'UnitsNet/**'
+      - 'Common/UnitDefinitions/**'
+      - 'Common/UnitRelations.json'
+      - 'Common/UnitEnumValues.g.json'
+      - 'UnitsNet.Modular.slnx'
+      - 'Directory.Build.props'
+      - 'Directory.Packages.props'
+      - 'NuGet.Config'
+      - 'NullableAttributes.cs'
+      - 'global.json'
+      - '.github/workflows/unitsnet-modular-ci.yml'
+  pull_request:
+    branches:
+      - master
+    paths:
+      - '.devcontainer/unitsnet-modular/**'
+      - 'UnitsNet.Modular/**'
+      # The compatibility suite compiles the current UnitsNet project to detect source/API drift.
+      - 'UnitsNet/**'
+      - 'Common/UnitDefinitions/**'
+      - 'Common/UnitRelations.json'
+      - 'Common/UnitEnumValues.g.json'
+      - 'UnitsNet.Modular.slnx'
+      - 'Directory.Build.props'
+      - 'Directory.Packages.props'
+      - 'NuGet.Config'
+      - 'NullableAttributes.cs'
+      - 'global.json'
+      - '.github/workflows/unitsnet-modular-ci.yml'
+  workflow_dispatch:
+    inputs:
+      publish_nuget:
+        description: Publish to nuget.org (UnitsNet.Modular/* tag only)
+        required: true
+        default: false
+        type: boolean
+
+permissions:
+  contents: read
+
+concurrency:
+  group: unitsnet-modular-ci-${{ github.ref }}
+  # Never interrupt a release-tag run while it may be publishing immutable packages.
+  cancel-in-progress: ${{ !startsWith(github.ref, 'refs/tags/UnitsNet.Modular/') }}
+
+env:
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+  DOTNET_NOLOGO: true
+  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
+
+jobs:
+  build-test-pack:
+    name: Build, test, and pack
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout full history
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - name: Setup .NET SDK
+        uses: actions/setup-dotnet@v6
+        with:
+          dotnet-version: 10.0.x
+
+      - name: Restore
+        run: dotnet restore UnitsNet.Modular.slnx -p:Platform=ProjectReferences
+
+      - name: Build
+        run: dotnet build UnitsNet.Modular.slnx --configuration Release --no-restore --no-incremental -p:Platform=ProjectReferences
+
+      - name: Test
+        run: dotnet test UnitsNet.Modular.slnx --configuration Release --no-build -p:Platform=ProjectReferences
+
+      - name: Native AOT smoke test
+        run: |
+          dotnet publish UnitsNet.Modular/Samples/QuantitySelectionSample/QuantitySelectionSample.csproj \
+            --configuration Release \
+            --framework net10.0 \
+            --runtime linux-x64 \
+            --self-contained true \
+            -p:PublishAot=true \
+            -p:Platform=ProjectReferences \
+            --output Artifacts/UnitsNet.Modular.AotSmoke
+          ./Artifacts/UnitsNet.Modular.AotSmoke/QuantitySelectionSample
+
+      - name: Run getting-started NuGet consumer
+        shell: pwsh
+        run: ./UnitsNet.Modular/Samples/GettingStartedSample/run.ps1
+
+      - name: Run custom-definition NuGet consumer with isolated cache
+        run: >-
+          dotnet run
+          --project UnitsNet.Modular/Samples/CustomQuantitySample/CustomQuantitySample.csproj
+          --configuration Debug
+          -p:Platform=LocalPackages
+          -p:RestorePackagesPath=${{ runner.temp }}/unitsnet-modular-custom-packages-${{ github.run_id }}-${{ github.run_attempt }}
+
+      - name: Run published-package consumer
+        run: >-
+          dotnet run
+          --project UnitsNet.Modular/Samples/GettingStartedSample/GettingStartedSample.csproj
+          --configuration Release
+          -p:Platform=PublishedPackages
+
+      - name: Pack
+        run: dotnet pack UnitsNet.Modular/UnitsNet.Modular/UnitsNet.Modular.csproj --configuration Release --no-build --output Artifacts/UnitsNet.Modular.CI -p:UnitsNetModularPackForPublish=true
+
+      - name: Verify tagged package versions
+        if: startsWith(github.ref, 'refs/tags/UnitsNet.Modular/')
+        shell: pwsh
+        run: |
+          $tagRefPrefix = 'refs/tags/UnitsNet.Modular/'
+          if (-not $env:GITHUB_REF.StartsWith($tagRefPrefix, [StringComparison]::Ordinal)) {
+            throw "Expected ref '$env:GITHUB_REF' to start with '$tagRefPrefix'."
+          }
+
+          $expectedVersion = $env:GITHUB_REF.Substring($tagRefPrefix.Length)
+          $packageDirectory = 'Artifacts/UnitsNet.Modular.CI'
+          $packagePath = Join-Path $packageDirectory "UnitsNet.Modular.$expectedVersion.nupkg"
+          if (-not (Test-Path -LiteralPath $packagePath -PathType Leaf)) {
+            throw "Expected tagged package was not produced: $packagePath"
+          }
+
+      - name: Upload packages
+        uses: actions/upload-artifact@v7
+        with:
+          name: unitsnet-modular-packages-${{ github.sha }}
+          path: |
+            Artifacts/UnitsNet.Modular.CI/*.nupkg
+            Artifacts/UnitsNet.Modular.CI/*.snupkg
+          if-no-files-found: error
+          retention-days: 14
+
+  publish-nuget:
+    name: Publish NuGet packages
+    needs: build-test-pack
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    if: >-
+      github.repository_owner == 'angularsen' &&
+      startsWith(github.ref, 'refs/tags/UnitsNet.Modular/') &&
+      (github.event_name == 'push' ||
+       (github.event_name == 'workflow_dispatch' && inputs.publish_nuget))
+    environment: Publish
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - name: Download NuGet packages
+        uses: actions/download-artifact@v8
+        with:
+          name: unitsnet-modular-packages-${{ github.sha }}
+          path: nugets
+
+      - name: Setup .NET SDK
+        uses: actions/setup-dotnet@v6
+        with:
+          dotnet-version: 10.0.x
+
+      - name: Log in to NuGet with trusted publishing
+        uses: NuGet/login@v1
+        id: nuget-login
+        with:
+          user: angularsen
+
+      - name: Push to nuget.org
+        env:
+          NUGET_API_KEY: ${{ steps.nuget-login.outputs.NUGET_API_KEY }}
+        run: dotnet nuget push "**/*.nupkg" --skip-duplicate --api-key "$NUGET_API_KEY" --source https://api.nuget.org/v3/index.json
+        working-directory: nugets
diff --git a/.gitignore b/.gitignore
index 9ba97caeb1..2363aca503 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,7 @@
 *.user
 *.userosscache
 *.sln.docstates
+.temp/
 
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
@@ -23,7 +24,8 @@ bld/
 [Ll]og/
 
 # VS Code dir
-.vscode/
+.vscode/*
+!.vscode/launch.json
 
 # Visual Studio 2015 cache/options directory
 .vs/
@@ -262,3 +264,12 @@ Artifacts
 
 # Claude Code assistant
 .claude/settings.local.json
+.claude/worktrees/
+.DS_Store
+
+# Keep the shared repository-local NuGet feed present on clean checkouts.
+!Artifacts/
+Artifacts/*
+!Artifacts/Nugets/
+Artifacts/Nugets/*
+!Artifacts/Nugets/.gitkeep
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000000..4047d68dd6
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,41 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Sample: Getting started",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/UnitsNet.Modular/Samples/GettingStartedSample/GettingStartedSample.csproj"
+    },
+    {
+      "name": "Sample: Quantity selection",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/UnitsNet.Modular/Samples/QuantitySelectionSample/QuantitySelectionSample.csproj"
+    },
+    {
+      "name": "Sample: Custom quantity",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/UnitsNet.Modular/Samples/CustomQuantitySample/CustomQuantitySample.csproj"
+    },
+    {
+      "name": "Sample: All SI profile",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/AllSiProfileSample.csproj"
+    },
+    {
+      "name": "Sample: Modular playground",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/UnitsNet.Modular/Samples/ModularPlayground/ModularPlayground.csproj"
+    },
+    {
+      "name": "Sample: Shared units library",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/SharedUnitsLibrarySample.App.csproj"
+    }
+  ]
+}
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000000..28ff7390e7
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,128 @@
+# AGENTS.md
+
+This file provides shared guidance for AI coding agents when working with code in this repository.
+
+## Project Overview
+
+UnitsNet is a .NET library that provides strongly-typed physical units and quantities, enabling safe and intuitive unit conversions in code. The library uses code generation from JSON definitions to create type-safe APIs for over 130 physical quantities.
+
+## Key Commands
+
+### Build and Test
+- **Build project**: `build.bat` or `dotnet build UnitsNet.slnx`
+- **Run tests**: `test.bat` or `dotnet test UnitsNet.slnx`
+- **Run single test**: `dotnet test UnitsNet.Tests --filter "FullyQualifiedName~TestClassName.TestMethodName"`
+- **Clean artifacts**: `clean.bat`
+
+### Code Generation
+- **Generate code from JSON definitions**: `generate-code.bat` or `dotnet run --project CodeGen`
+  - Always run this after modifying any JSON files in `Common/UnitDefinitions/`
+  - The generator reads 131 JSON definition files and creates C# code
+
+### Development Workflow
+1. Modify unit definitions in `Common/UnitDefinitions/*.json`
+2. Run `generate-code.bat` to regenerate C# code
+3. Run `build.bat` to compile and test
+4. Use `test.bat` for isolated test runs
+
+## Code Architecture
+
+### Project Structure
+- **UnitsNet/**: Main library with quantity types and units
+  - `GeneratedCode/`: Auto-generated from JSON definitions (do not edit manually)
+  - `CustomCode/`: Hand-written code extending generated types
+- **UnitsNet.Tests/**: Comprehensive test suite
+- **CodeGen/**: Code generation tool that creates C# from JSON definitions
+- **Common/UnitDefinitions/**: 131 JSON files defining physical quantities
+- **UnitsNet.NumberExtensions/**: Extension methods for numeric types
+- **UnitsNet.Serialization.*/**: JSON.NET and System.Text.Json serialization support
+
+### Code Generation Process
+The project uses a sophisticated code generation system:
+1. JSON definitions in `Common/UnitDefinitions/` describe units, conversions, and localizations
+2. `CodeGen` project processes these to generate:
+   - Quantity types (e.g., `Length`, `Mass`)
+   - Unit enums (e.g., `LengthUnit`, `MassUnit`)
+   - Conversion logic and unit abbreviations
+3. Generated code goes to `*/GeneratedCode/` folders
+4. Custom code in `*/CustomCode/` extends generated types
+
+### Key Classes and Patterns
+- **IQuantity**: Base interface for all quantity types
+- **Quantity**: Static class for dynamic quantity operations
+- **UnitConverter**: Handles conversions between units
+- **QuantityParser/UnitParser**: Parse strings to quantities/units
+- **UnitsNetSetup**: Configuration singleton
+
+### Adding or Modifying Units
+1. Edit or create JSON file in `Common/UnitDefinitions/`
+2. Follow conversion function guidelines in [Docs/adding-a-new-unit.md](Docs/adding-a-new-unit.md):
+   - Use multiplication for `FromUnitToBaseFunc`
+   - Use division for `FromBaseToUnitFunc`
+   - Prefer scientific notation (1e3, 1e-5)
+   - Use exact constituent constants instead of pre-computed decimals
+3. Run `generate-code.bat`
+4. Add tests if needed
+
+## Important Conventions
+
+### Coding Standards
+- Follow `.editorconfig` specifications
+- Use ReSharper settings in `UnitsNet.sln.DotSettings`
+- Treat warnings as errors (except obsolete warnings)
+- Add file headers to new files
+
+### Unit Definition Rules
+- Base units are chosen for each quantity (e.g., meter for Length)
+- All conversions go through the base unit
+- Use superscript in abbreviations: cm², m³
+- Compound units format: N·m (dot), km/h (slash)
+
+### Testing
+- Test class naming: `<Type>Tests`
+- Test method naming: `<method>_<condition>_<result>`
+- Tests accept error margin of 1E-5 for most units
+
+## Special Considerations
+
+### Performance
+- Conversion functions are compiled to delegates for performance
+- All conversions go through base units (potential for small errors)
+- Precision goal is 1E-5 for most units
+
+### Localization
+- Unit abbreviations support multiple cultures
+- JSON definitions include translations for various languages
+- Default culture: Thread.CurrentCulture, fallback to en-US
+
+## Common Tasks
+
+### Find specific quantity or unit implementation
+- Quantity types: `UnitsNet/GeneratedCode/Quantities/*.g.cs`
+- Unit enums: `UnitsNet/GeneratedCode/Units/*.g.cs`
+- Custom extensions: `UnitsNet/CustomCode/Quantities/*.extra.cs`
+- Unit definitions: `Common/UnitDefinitions/*.json`
+
+### Debug code generation
+- Generator entry: `CodeGen/Program.cs`
+- Generator logic: `CodeGen/Generators/`
+- Enable verbose logging: Check Serilog configuration in Program.cs
+
+### Run performance benchmarks
+- Execute: `dotnet run -c Release --project UnitsNet.Benchmark`
+- Results saved to `Artifacts/` folder
+
+## Documentation
+
+All contributor and user documentation lives in [Docs/](Docs/README.md), including:
+- [Adding a New Unit](Docs/adding-a-new-unit.md) - step-by-step guide with JSON schema conventions
+- [Adding Operator Overloads](Docs/adding-operator-overloads.md)
+- [Precision](Docs/precision.md) - conversion precision and test value guidelines
+- [Serialization](Docs/serialization.md), [String Formatting](Docs/string-formatting.md), [Saving to Database](Docs/saving-to-database.md)
+- [Upgrade Guides](Docs/README.md#upgrade-guides) for major version migrations
+
+## Pull request reviews
+
+### Adding new quantities or units
+
+See `.agents/criteria-for-adding-quantities-and-units.md` for instructions on adding new quantities or units to ensure they are widely used and well defined.
diff --git a/Artifacts/Nugets/.gitkeep b/Artifacts/Nugets/.gitkeep
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/Artifacts/Nugets/.gitkeep
@@ -0,0 +1 @@
+
diff --git a/Build/build-functions.psm1 b/Build/build-functions.psm1
index 66bd3e1c4d..eaa437e7b0 100644
--- a/Build/build-functions.psm1
+++ b/Build/build-functions.psm1
@@ -1,34 +1,27 @@
-$root = (Resolve-Path "$PSScriptRoot\..").Path
-$artifactsDir = "$root\Artifacts"
-$nugetOutDir = "$artifactsDir\NuGet"
-$logsDir = "$artifactsDir\Logs"
-$testReportDir = "$artifactsDir\TestResults"
-$testCoverageDir = "$artifactsDir\Coverage"
-$toolsDir = "$root\.tools"
-
-$nuget = "$toolsDir\NuGet.exe"
-$vswhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
-
-# Check if Visual Studio is installed before trying to find MSBuild
-if (Test-Path $vswhere) {
-  $msbuildPath = & $vswhere -latest -products * -requires Microsoft.Component.MSBuild -property installationPath 2>$null
-
-  if ($msbuildPath) {
-    $msbuildx64 = join-path $msbuildPath 'MSBuild\Current\Bin\amd64\MSBuild.exe'
-  }
-} else {
-  $msbuildPath = $null
-  $msbuildx64 = $null
-}
-
-import-module $PSScriptRoot\build-pack-nano-nugets.psm1
+$root = (Resolve-Path (Join-Path $PSScriptRoot "..")).Path
+$artifactsDir = Join-Path $root "Artifacts"
+$localNuGetFeedDir = Join-Path $artifactsDir "Nugets"
+$nugetOutDir = Join-Path $artifactsDir "NuGet"
+$logsDir = Join-Path $artifactsDir "Logs"
+$testReportDir = Join-Path $artifactsDir "TestResults"
+$testCoverageDir = Join-Path $artifactsDir "Coverage"
+$toolsDir = Join-Path $root ".tools"
+$reportGeneratorName = if ([System.Environment]::OSVersion.Platform -eq [PlatformID]::Win32NT) { "reportgenerator.exe" } else { "reportgenerator" }
+$reportGenerator = Join-Path $toolsDir $reportGeneratorName
+
+Import-Module (Join-Path $PSScriptRoot "test-projects.psm1") -Force
+$testProjectPaths = @(Get-TestProjectPaths)
 
 function Remove-ArtifactsDir {
   if (Test-Path $artifactsDir) {
     write-host -foreground blue "Clean up...`n"
-    rm $artifactsDir -Recurse -Force -ErrorAction Stop
+    Remove-Item -LiteralPath $artifactsDir -Recurse -Force -ErrorAction Stop
     write-host -foreground blue "Clean up...END`n"
   }
+
+  # NuGet.Config always includes this repository-local source, so it must exist before restore.
+  New-Item -ItemType Directory -Force $localNuGetFeedDir 1> $null
+  Set-Content -LiteralPath (Join-Path $localNuGetFeedDir ".gitkeep") -Value ""
 }
 
 function Update-GeneratedCode {
@@ -48,90 +41,69 @@ function Start-Build {
   write-host -foreground blue "Start-Build...END`n"
 }
 
-function Start-BuildNanoFramework {
-  write-host -foreground blue "Start-BuildNanoFramework (MSBuild)...`n---"
-
-  # Check prerequisites
-  if (-not $msbuildx64 -or -not (Test-Path $msbuildx64)) {
-    write-host -foreground red "ERROR: Cannot build .NET nanoFramework - MSBuild not found."
-    write-host -foreground yellow "Install Visual Studio with .NET desktop development workload to build NanoFramework projects."
-    exit 1
-  }
-
-  if (-not (Test-Path $nuget)) {
-    write-host -foreground red "ERROR: NuGet.exe not found at $nuget"
-    write-host -foreground yellow "Run init.ps1 to download required tools."
-    exit 1
-  }
-
-  write-host -foreground green "Building .NET nanoFramework projects..."
-  $fileLoggerArg = "/logger:FileLogger,Microsoft.Build;logfile=$logsDir\UnitsNet.NanoFramework.msbuild.log"
-
-  # msbuild does not auto-restore nugets for this project type
-  write-host "Restoring NuGet packages for NanoFramework..."
-  & "$nuget" restore "$root\UnitsNet.NanoFramework\GeneratedCode\UnitsNet.nanoFramework.sln"
-  if ($lastexitcode -ne 0) {
-    write-host -foreground red "Failed to restore NuGet packages for NanoFramework"
-    exit 1
-  }
-
-  # Build with MSBuild
-  write-host "Building NanoFramework solution..."
-  & "$msbuildx64" "$root\UnitsNet.NanoFramework\GeneratedCode\UnitsNet.nanoFramework.sln" /verbosity:minimal /p:Configuration=Release /p:Platform="Any CPU" /p:ContinuousIntegrationBuild=true $fileLoggerArg
-  if ($lastexitcode -ne 0) {
-    write-host -foreground red "Failed to build NanoFramework solution"
-    exit 1
-  }
-
-  write-host -foreground blue "Start-BuildNanoFramework...END`n"
-}
-
 function Start-Tests {
-  $projectPaths = @(
-    "UnitsNet.Tests\UnitsNet.Tests.csproj",
-    "UnitsNet.NumberExtensions.Tests\UnitsNet.NumberExtensions.Tests.csproj",
-    "UnitsNet.NumberExtensions.CS14.Tests\UnitsNet.NumberExtensions.CS14.Tests.csproj",
-    "UnitsNet.Serialization.JsonNet.Tests\UnitsNet.Serialization.JsonNet.Tests.csproj"
-    )
+  Param(
+    [switch] $SkipCoverage
+  )
 
   # Parent dir must exist before xunit tries to write files to it
   new-item -type directory -force $testReportDir 1> $null
-  new-item -type directory -force $testCoverageDir 1> $null
+  if (-not $SkipCoverage) {
+    new-item -type directory -force $testCoverageDir 1> $null
+  }
 
   write-host -foreground blue "Run tests...`n---"
-  foreach ($projectPath in $projectPaths) {
+  foreach ($projectPath in $testProjectPaths) {
     $projectFileNameNoEx = [System.IO.Path]::GetFileNameWithoutExtension($projectPath)
-    $coverageReportFile = "$testCoverageDir\${projectFileNameNoEx}.coverage.xml"
-    $projectDir = [System.IO.Path]::GetDirectoryName($projectPath)
+    $coverageReportFile = Join-Path $testCoverageDir "${projectFileNameNoEx}.coverage.xml"
+    $projectDir = Join-Path $root ([System.IO.Path]::GetDirectoryName($projectPath))
 
     # dotnet commands (xunit, dotcover) must run in same dir as project
     push-location $projectDir
 
-    # Create coverage report for this test project
-    & dotnet dotcover test `
-      --no-build `
-      --logger trx `
-      --results-directory "$testReportDir" `
-      --dotCoverFilters="+:module=UnitsNet*;-:module=*Tests" `
-      --dotCoverOutput="$coverageReportFile" `
-      --dcReportType=DetailedXML
+    # Build validates every target framework. Run tests only on the latest .NET runtime because
+    # net8.0, net9.0, and net10.0 compile the same code paths. The separate CLR4 workflow tests
+    # the meaningfully different netstandard2.0 assets on .NET Framework.
+    if ($SkipCoverage) {
+      & dotnet test `
+        --no-build `
+        --framework net10.0 `
+        --logger trx `
+        --results-directory "$testReportDir"
+    }
+    else {
+      & dotnet tool run dotCover -- cover-dotnet `
+        --TargetWorkingDir $projectDir `
+        --Output "$coverageReportFile" `
+        --ReportType DetailedXML `
+        --Filters '+:module=UnitsNet*;-:module=*Tests' `
+        --ReturnTargetExitCode `
+        -- test `
+        --no-build `
+        --framework net10.0 `
+        --logger trx `
+        --results-directory "$testReportDir"
+    }
 
     if ($lastexitcode -ne 0) { exit 1 }
     pop-location
   }
 
-  # Generate a summarized code coverage report for all test projects
-  & "$toolsDir/reportgenerator.exe" -reports:"$testCoverageDir/*.coverage.xml" -targetdir:"$testCoverageDir" -reporttypes:HtmlSummary
+  if (-not $SkipCoverage) {
+    # Generate a summarized code coverage report for all test projects
+    & $reportGenerator -reports:"$testCoverageDir/*.coverage.xml" -targetdir:"$testCoverageDir" -reporttypes:HtmlSummary
+  }
 
   write-host -foreground blue "Run tests...END`n"
 }
 
 function Start-PackNugets {
   $projectPaths = @(
-    "UnitsNet\UnitsNet.csproj",
-    "UnitsNet.Serialization.JsonNet\UnitsNet.Serialization.JsonNet.csproj",
-    "UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj",
-    "UnitsNet.NumberExtensions.CS14\UnitsNet.NumberExtensions.CS14.csproj"
+    "UnitsNet/UnitsNet.csproj",
+    "UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj",
+    "UnitsNet.Serialization.SystemTextJson/UnitsNet.Serialization.SystemTextJson.csproj",
+    "UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj",
+    "UnitsNet.NumberExtensions.CS14/UnitsNet.NumberExtensions.CS14.csproj"
     )
 
   write-host -foreground blue "Pack nugets (dotnet CLI)...`n---"
@@ -140,7 +112,7 @@ function Start-PackNugets {
       --no-build `
       --output $nugetOutDir `
       /p:ContinuousIntegrationBuild=true `
-      "$root\$projectPath"
+      (Join-Path $root $projectPath)
 
     if ($lastexitcode -ne 0) { exit 1 }
   }
@@ -148,40 +120,24 @@ function Start-PackNugets {
   write-host -foreground blue "Pack nugets...END`n"
 }
 
-function Start-PackNugetsNanoFramework {
-  write-host -foreground blue "Pack NanoFramework nugets (NuGet.exe)...`n---"
-
-  # Check prerequisites
-  if (-not (Test-Path $nuget)) {
-    write-host -foreground red "ERROR: NuGet.exe not found at $nuget"
-    write-host -foreground yellow "Run init.ps1 to download required tools."
-    exit 1
-  }
-
-  write-host -foreground yellow "nanoFramework project not yet supported by dotnet CLI, using nuget.exe instead"
-  Invoke-BuildNanoNugets
-
-  write-host -foreground blue "Pack NanoFramework nugets...END`n"
-}
-
 function Compress-ArtifactsAsZip {
   write-host -foreground blue "Zip artifacts...`n---"
 
   $zipFileName = "UnitsNet.zip"
-  $tempZipFile = "$root\$zipFileName"
-  $zipFile = "$artifactsDir\$zipFileName"`
+  $tempZipFile = Join-Path $root $zipFileName
+  $zipFile = Join-Path $artifactsDir $zipFileName
 
-  rm $tempZipFile -ErrorAction Ignore
-  rm $zipFile -ErrorAction Ignore
+  Remove-Item -LiteralPath $tempZipFile -ErrorAction Ignore
+  Remove-Item -LiteralPath $zipFile -ErrorAction Ignore
 
   # Create zip file
   add-type -assembly "system.io.compression.filesystem"
   [IO.Compression.ZipFile]::CreateFromDirectory($artifactsDir, $tempZipFile)
 
-  mv $tempZipFile $zipFile
+  Move-Item -LiteralPath $tempZipFile -Destination $zipFile
   if (-not $?) { write-host -foreground red "Failed to move [$tempZipFile] to [$zipFileName]."; exit 1 }
 
   write-host -foreground blue "Zip artifacts...END`n"
 }
 
-export-modulemember -function Remove-ArtifactsDir, Update-GeneratedCode, Start-Build, Start-BuildNanoFramework, Start-Tests, Start-PackNugets, Start-PackNugetsNanoFramework, Compress-ArtifactsAsZip
+export-modulemember -function Remove-ArtifactsDir, Update-GeneratedCode, Start-Build, Start-Tests, Start-PackNugets, Compress-ArtifactsAsZip
diff --git a/Build/build-pack-nano-nugets.psm1 b/Build/build-pack-nano-nugets.psm1
deleted file mode 100644
index b2ed5c3e79..0000000000
--- a/Build/build-pack-nano-nugets.psm1
+++ /dev/null
@@ -1,14 +0,0 @@
-$root = (Resolve-Path "$PSScriptRoot\..").Path
-$nugetOutDir = "$root\Artifacts\NuGet"
-$toolsDir = "$root\.tools"
-$nuget = "$toolsDir\NuGet.exe"
-$nugetsToProcess = (Get-ChildItem -Path "$root\UnitsNet.NanoFramework\GeneratedCode\" -Filter *.nuspec -r | % { echo $_.FullName });
-
-function Invoke-BuildNanoNugets {
-Foreach ($nuspecFile in $nugetsToProcess)
-  {
-    & $nuget pack "$nuspecFile" -Verbosity detailed -OutputDirectory "$nugetOutDir"
-  }
-}
-
-export-modulemember -function Invoke-BuildNanoNugets
diff --git a/Build/build.ps1 b/Build/build.ps1
index 44185aac0c..dc83fd453b 100644
--- a/Build/build.ps1
+++ b/Build/build.ps1
@@ -1,4 +1,4 @@
-<#
+<#
 .SYNOPSIS
     Build, run tests and pack nugets for all Units.NET projects.
 .DESCRIPTION
@@ -9,7 +9,6 @@
     on the master branch.
 .EXAMPLE
   powershell ./build.ps1
-  powershell ./build.ps1 -IncludeNanoFramework
 
 .NOTES
     Author: Andreas Gullberg Larsen
@@ -17,34 +16,33 @@
     #>
 [CmdletBinding()]
 Param(
-    [switch] $IncludeNanoFramework
-  )
+  [switch] $SkipTests,
+  [switch] $SkipCoverage,
+  [switch] $SkipPack,
+  [switch] $SkipArchive
+)
 
 remove-module build-functions -ErrorAction SilentlyContinue
-import-module $PSScriptRoot\build-functions.psm1
+import-module (Join-Path $PSScriptRoot "build-functions.psm1")
 
 try {
-  & "$PSScriptRoot/init.ps1" # Ensure tools are downloaded
+  & "$PSScriptRoot/init.ps1" -SkipCoverageTools:($SkipTests -or $SkipCoverage)
 
   Remove-ArtifactsDir
   Update-GeneratedCode
 
   # Build main projects with dotnet CLI (cross-platform)
   Start-Build
-  Start-Tests
-  Start-PackNugets
-
-  # Build NanoFramework if requested (Windows-only, requires Visual Studio)
-  if ($IncludeNanoFramework) {
-    write-host -foreground cyan "`n===== Building NanoFramework projects (requires Visual Studio) =====`n"
-    Start-BuildNanoFramework
-    Start-PackNugetsNanoFramework
+  if (-not $SkipTests) {
+    Start-Tests -SkipCoverage:$SkipCoverage
   }
-  else {
-    write-host -foreground yellow "`nSkipping NanoFramework build. Use -IncludeNanoFramework flag to build NanoFramework projects.`n"
+  if (-not $SkipPack) {
+    Start-PackNugets
   }
 
-  Compress-ArtifactsAsZip
+  if (-not $SkipArchive) {
+    Compress-ArtifactsAsZip
+  }
 }
 catch {
   $myError = $_.Exception.ToString()
diff --git a/Build/bump-version-UnitsNet.Modular.ps1 b/Build/bump-version-UnitsNet.Modular.ps1
new file mode 100644
index 0000000000..603b2b911f
--- /dev/null
+++ b/Build/bump-version-UnitsNet.Modular.ps1
@@ -0,0 +1,80 @@
+<# .SYNOPSIS
+  Creates an annotated UnitsNet.Modular release tag with a bumped version.
+.DESCRIPTION
+  Finds the nearest reachable UnitsNet.Modular/* tag, bumps its minor, patch, or prerelease suffix,
+  and creates an annotated tag on HEAD. MinVer uses that tag to version UnitsNet.Modular.
+
+  Minor and patch bumps remove any prerelease suffix, matching the existing UnitsNet version scripts.
+  A suffix bump increments the final numeric prerelease identifier, for example alpha.1 to alpha.2.
+  After a stable tag, a suffix bump starts the next patch prerelease at alpha.1, matching MinVer's
+  post-release version range.
+.PARAMETER Bump
+  The semantic version component to bump: minor, patch, or suffix.
+.EXAMPLE
+  ./Build/bump-version-UnitsNet.Modular.ps1 -Bump suffix
+.EXAMPLE
+  ./Build/bump-version-UnitsNet.Modular.ps1 -Bump minor -WhatIf
+#>
+[CmdletBinding(SupportsShouldProcess = $true)]
+Param(
+  [Parameter(Mandatory = $true, Position = 0)]
+  [ValidateSet("minor", "patch", "suffix")]
+  [string] $Bump
+)
+
+$ErrorActionPreference = "Stop"
+$tagPrefix = "UnitsNet.Modular/"
+$repositoryRoot = Resolve-Path "$PSScriptRoot\.."
+
+Remove-Module set-version -ErrorAction Ignore
+Import-Module "$PSScriptRoot\set-version.psm1"
+
+function Invoke-Git([string[]] $Arguments) {
+  $output = & git -C $repositoryRoot @Arguments 2>&1
+  if ($LASTEXITCODE -ne 0) {
+    throw "git $([string]::Join(' ', $Arguments)) failed:`n$([string]::Join([Environment]::NewLine, $output))"
+  }
+
+  return $output
+}
+
+$status = Invoke-Git @("status", "--porcelain", "--untracked-files=normal")
+if ($status) {
+  throw "The working tree must be clean before tagging a release."
+}
+
+$latestTag = [string](Invoke-Git @(
+  "describe",
+  "--tags",
+  "--abbrev=0",
+  "--match",
+  "$tagPrefix*",
+  "HEAD"
+))
+$latestTag = $latestTag.Trim()
+
+if (!$latestTag.StartsWith($tagPrefix, [StringComparison]::OrdinalIgnoreCase)) {
+  throw "Latest tag '$latestTag' does not start with '$tagPrefix'."
+}
+
+$currentVersion = $latestTag.Substring($tagPrefix.Length)
+if ($Bump -eq "suffix" -and !$currentVersion.Contains("-")) {
+  $nextPatchVersion = Get-BumpedSemanticVersion $currentVersion "patch"
+  $newVersion = Get-BumpedSemanticVersion "$nextPatchVersion-alpha.0" "suffix" "alpha.0"
+}
+else {
+  $newVersion = Get-BumpedSemanticVersion $currentVersion $Bump "alpha.0"
+}
+$newTag = "$tagPrefix$newVersion"
+
+& git -C $repositoryRoot rev-parse --verify --quiet "refs/tags/$newTag" *> $null
+if ($LASTEXITCODE -eq 0) {
+  throw "Tag '$newTag' already exists."
+}
+
+$message = "UnitsNet.Modular $newVersion"
+if ($PSCmdlet.ShouldProcess("HEAD", "Create annotated tag '$newTag'")) {
+  Invoke-Git @("tag", "--annotate", $newTag, "--message", $message, "HEAD") | Out-Null
+  Write-Host "Created annotated tag $newTag"
+  Write-Host "Push it with: git push origin $newTag"
+}
diff --git a/Build/bump-version-json.bat b/Build/bump-version-json.bat
index c8062bf7c9..4f5953987b 100644
--- a/Build/bump-version-json.bat
+++ b/Build/bump-version-json.bat
@@ -1,10 +1,10 @@
 @echo off
-rem This scripts increases the version of nugets: UnitsNet.Serialization.JsonNet.
+rem This script increases the version of both UnitsNet serialization packages.
 rem The change is committed and tagged locally, but must be pushed to origin/master to take effect.
 rem Only contributors with write access can perform this directly to master, others must perform via pull request.
 
 SET scriptdir=%~dp0
-echo Bump version UnitsNet.Serialization.JsonNet nuget:
+echo Bump version UnitsNet serialization packages:
 echo.
 echo 1:   minor    4.90.0 to 4.91.0
 echo 2:   patch    4.90.0 to 4.90.1
diff --git a/Build/bump-version-json.sh b/Build/bump-version-json.sh
index 1127db832f..576b6dfa79 100755
--- a/Build/bump-version-json.sh
+++ b/Build/bump-version-json.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# Increments version of nuget UnitNets.Serialization.JsonNet.
+# Increments the version of both UnitsNet serialization packages.
 script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 set_version_script="$script_dir/set-version-UnitsNet.Serialization.JsonNet.ps1"
 
diff --git a/Build/bump-version.bat b/Build/bump-version.bat
index 192f556e77..8a6cf12bb3 100644
--- a/Build/bump-version.bat
+++ b/Build/bump-version.bat
@@ -1,10 +1,10 @@
 @echo off
-rem This scripts increases the version of nugets: UnitsNet, UnitsNet.NumberExtensions.
+rem This script increases the version of UnitsNet and both UnitsNet.NumberExtensions packages.
 rem The change is committed and tagged locally, but must be pushed to origin/master to take effect.
 rem Only contributors with write access can perform this directly to master, others must perform via pull request.
 
 SET scriptdir=%~dp0
-echo Bump version UnitsNet and UnitsNet.NumberExtensions:
+echo Bump version UnitsNet and both UnitsNet.NumberExtensions packages:
 echo.
 echo 1:   minor    4.90.0 to 4.91.0
 echo 2:   patch    4.90.0 to 4.90.1
diff --git a/Build/bump-version.sh b/Build/bump-version.sh
index b94f45e694..8a0b4ca94f 100755
--- a/Build/bump-version.sh
+++ b/Build/bump-version.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# Increments version of nugets UnitNets, UnitsNet.NumberExtensions.
+# Increments version of UnitsNet and both UnitsNet.NumberExtensions packages.
 script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 set_version_script="$script_dir/set-version-UnitsNet.ps1"
 
diff --git a/Build/clean.ps1 b/Build/clean.ps1
index 5136a40f69..f900b18337 100644
--- a/Build/clean.ps1
+++ b/Build/clean.ps1
@@ -3,6 +3,7 @@ Set-Strictmode -version latest
 
 $root = (Resolve-Path "$PSScriptRoot\..").Path
 $artifactsDir = "$root\Artifacts"
+$localNuGetFeedDir = Join-Path $artifactsDir "Nugets"
 $toolsDir = "$root\.tools"
 
 Write-Host -Foreground Blue "Delete .tools"
@@ -11,6 +12,10 @@ Remove-Item -Recurse -Force -ErrorAction Ignore "$toolsDir"
 Write-Host -Foreground Blue "Delete Artifacts"
 Remove-Item -Recurse -Force -ErrorAction Ignore "$artifactsDir"
 
+# NuGet.Config always includes this repository-local source, so it must exist before restore.
+New-Item -ItemType Directory -Force $localNuGetFeedDir 1> $null
+Set-Content -LiteralPath (Join-Path $localNuGetFeedDir ".gitkeep") -Value ""
+
 Write-Host -Foreground Blue "Delete dirs: bin, obj"
 
 [int]$deleteCount = 0
diff --git a/Build/init.ps1 b/Build/init.ps1
index e96fffffc9..dd37d5e538 100644
--- a/Build/init.ps1
+++ b/Build/init.ps1
@@ -1,123 +1,29 @@
-# Don't allow using undeclared variables
+# Don't allow using undeclared variables
+Param(
+  [switch] $SkipCoverageTools
+)
+
 Set-Strictmode -version latest
 
-$root = (Resolve-Path "$PSScriptRoot\..").Path
-$nugetPath = "$root/.tools/NuGet.exe"
+$root = (Resolve-Path (Join-Path $PSScriptRoot "..")).Path
+$toolsDir = Join-Path $root ".tools"
+$reportGeneratorName = if ([System.Environment]::OSVersion.Platform -eq [PlatformID]::Win32NT) { "reportgenerator.exe" } else { "reportgenerator" }
+$reportGenerator = Join-Path $toolsDir $reportGeneratorName
 
 Write-Host -Foreground Blue "Initializing..."
 
-# Ensure temp dir exists
-$tempDir = "$root/.tools/temp_init"
-[system.io.Directory]::CreateDirectory($tempDir) | out-null
-
-# Report generator for unit test coverage reports.
-if (-not (Test-Path "$root/.tools/reportgenerator.exe")) {
-  Write-Host -Foreground Blue "Install dotnet-reportgenerator-globaltool..."
-  dotnet tool install dotnet-reportgenerator-globaltool --tool-path .tools
-  Write-Host -Foreground Green "✅ Installed dotnet-reportgenerator-globaltool"
-}
-
-# NuGet.exe for non-SDK style projects, like UnitsNet.nanoFramework.
-if (-not (Test-Path "$nugetPath")) {
-  Write-Host -Foreground Blue "Downloading NuGet.exe..."
-  Invoke-WebRequest -Uri https://dist.nuget.org/win-x86-commandline/latest/nuget.exe -OutFile $nugetPath
-  Write-Host -Foreground Green "✅ Downloaded NuGet.exe: $nugetPath"
-}
-
-###################################################
-## TODO: OK to remove after moving to AZDO pipeline
-$VsWherePath = "${env:PROGRAMFILES(X86)}\Microsoft Visual Studio\Installer\vswhere.exe"
-
-# Check if Visual Studio is installed
-if (Test-Path $VsWherePath) {
-  $VsPath = $(&$VsWherePath -latest -property installationPath 2>$null)
-  if ($VsPath) {
-    $msbuildPath = Join-Path -Path $VsPath -ChildPath "\MSBuild"
-    Write-Host -Foreground Green "Visual Studio found at: $VsPath"
-  } else {
-    Write-Host -Foreground Yellow "Visual Studio not found via vswhere, NanoFramework builds will be skipped"
-    $VsPath = $null
-    $msbuildPath = $null
-  }
-} else {
-  Write-Host -Foreground Yellow "Visual Studio not installed - NanoFramework builds will be skipped"
-  $VsPath = $null
-  $msbuildPath = $null
-}
-
-# Install dotnet CLI tools declared in /.config/dotnet-tools.json
-pushd $root
-dotnet tool restore
-popd
-
-# Install .NET nanoFramework build components
-if ($msbuildPath -and !(Test-Path "$msbuildPath/nanoFramework")) {
-  Write-Host "Installing .NET nanoFramework VS extension..."
-
-  [System.Net.WebClient]$webClient = New-Object System.Net.WebClient
-  $webClient.Headers.Add("User-Agent", "request")
-  $webClient.Headers.Add("Accept", "application/vnd.github.v3+json")
-
-  $releaseList = $webClient.DownloadString('https://api.github.com/repos/nanoframework/nf-Visual-Studio-extension/releases?per_page=100')
-
-  if($releaseList -match '\"(?<VS2022_version>v2022\.\d+\.\d+\.\d+)\"')
-  {
-      $vs2022Tag =  $Matches.VS2022_version
-  }
-
-  if($releaseList -match '\"(?<VS2019_version>v2019\.\d+\.\d+\.\d+)\"')
-  {
-      $vs2019Tag =  $Matches.VS2019_version
+if (-not $SkipCoverageTools) {
+  # Report generator for unit test coverage reports.
+  if (-not (Test-Path $reportGenerator)) {
+    Write-Host -Foreground Blue "Install dotnet-reportgenerator-globaltool..."
+    dotnet tool install dotnet-reportgenerator-globaltool --tool-path $toolsDir
+    Write-Host -Foreground Green "✅ Installed dotnet-reportgenerator-globaltool"
   }
 
-  # Find which VS version is installed
-  $VsWherePath = "${env:PROGRAMFILES(X86)}\Microsoft Visual Studio\Installer\vswhere.exe"
-
-  Write-Output "VsWherePath is: $VsWherePath"
-
-  $VsInstance = $(&$VSWherePath -latest -property displayName 2>$null)
-
-  Write-Output "Latest VS is: $VsInstance"
-
-  # Get extension details according to VS version, starting from VS2022 down to VS2019
-  # TODO check if the extension for VS2022 is compatible it VS2026
-  if($vsInstance.Contains('2026') -or $vsInstance.Contains('2022'))
-  {
-      $extensionUrl = "https://github.com/nanoframework/nf-Visual-Studio-extension/releases/download/$vs2022Tag/nanoFramework.Tools.VS2022.Extension.vsix"
-      $vsixPath = Join-Path  $tempDir "nanoFramework.Tools.VS2022.Extension.zip"
-      $extensionVersion = $vs2022Tag
-  }
-  elseif($vsInstance.Contains('2019'))
-  {
-      $extensionUrl = "https://github.com/nanoframework/nf-Visual-Studio-extension/releases/download/$vs2019Tag/nanoFramework.Tools.VS2019.Extension.vsix"
-      $vsixPath = Join-Path  $tempDir "nanoFramework.Tools.VS2019.Extension.zip"
-      $extensionVersion = $vs2019Tag
-  }
-
-  Write-Output "Downloading visx..."
-
-  # download VS extension
-  Write-Host "Download VSIX file from $extensionUrl to $vsixPath"
-  $webClient.DownloadFile($extensionUrl, $vsixPath)
-
-  $outputPath = "$tempDir\nf-extension"
-
-  $vsixPath = Join-Path -Path $tempDir -ChildPath "nf-extension.zip"
-  $webClient.DownloadFile($extensionUrl, $vsixPath)
-
-  Write-Host "Extract VSIX file to $outputPath"
-  Expand-Archive -LiteralPath $vsixPath -DestinationPath $outputPath -Force | Write-Host
-
-  $copyFrom = "$outputPath\`$MSBuild\nanoFramework"
-
-  Write-Host "Copy from $copyFrom to $msbuildPath"
-  Copy-Item -Path "$copyFrom" -Destination $msbuildPath -Recurse
-
-  Write-Host "Installed VS extension $extensionVersion"
+  # Install dotnet CLI tools declared in /.config/dotnet-tools.json
+  pushd $root
+  dotnet tool restore
+  popd
 }
-###################################################
-
-# Cleanup
-[system.io.Directory]::Delete($tempDir, $true) | out-null
 
 Write-Host -Foreground Green "Initialized."
diff --git a/Build/set-version-UnitsNet.Serialization.JsonNet.ps1 b/Build/set-version-UnitsNet.Serialization.JsonNet.ps1
index b5f6d3d888..1d6c6583d0 100644
--- a/Build/set-version-UnitsNet.Serialization.JsonNet.ps1
+++ b/Build/set-version-UnitsNet.Serialization.JsonNet.ps1
@@ -1,5 +1,5 @@
 <# .SYNOPSIS
-  Updates the version of all UnitsNet.Serialiation.JsonNet projects.
+  Updates the version of all UnitsNet serialization projects.
 .DESCRIPTION
   Updates the <Version> property of the .csproj project files.
 .PARAMETER set
@@ -48,11 +48,25 @@ Import-Module "$PSScriptRoot\set-version.psm1"
 
 $root = Resolve-Path "$PSScriptRoot\.."
 $paramSet = $PsCmdlet.ParameterSetName
-$projFile = "$root\UnitsNet.Serialization.JsonNet\UnitsNet.Serialization.JsonNet.csproj"
+$projectFiles = @(
+  "$root\UnitsNet.Serialization.JsonNet\UnitsNet.Serialization.JsonNet.csproj",
+  "$root\UnitsNet.Serialization.SystemTextJson\UnitsNet.Serialization.SystemTextJson.csproj"
+)
 
 # Use project version as base when bumping major/minor/patch
-$newVersion = Get-NewProjectVersion $projFile $paramSet $setVersion $bumpVersion
+$newVersion = Get-NewProjectVersion $projectFiles[0] $paramSet $setVersion $bumpVersion
+
+# Reset and stash any other local changes.
+$didStash = Invoke-StashPush
+
+foreach ($projectFile in $projectFiles) {
+  Set-ProjectVersion $projectFile $newVersion
+}
 
-Set-ProjectVersion $projFile $newVersion
 Invoke-CommitVersionBump "JsonNet" $newVersion
 Invoke-TagVersionBump "JsonNet" $newVersion
+
+# Restore any local changes.
+if ($didStash) {
+  Invoke-StashPop
+}
diff --git a/Build/set-version-UnitsNet.ps1 b/Build/set-version-UnitsNet.ps1
index b4c0e10f65..e296ae0d60 100644
--- a/Build/set-version-UnitsNet.ps1
+++ b/Build/set-version-UnitsNet.ps1
@@ -51,31 +51,22 @@ Import-Module "$PSScriptRoot\set-version.psm1"
 
 $root = Resolve-Path "$PSScriptRoot\.."
 $paramSet = $PsCmdlet.ParameterSetName
-$projFile = "$root\UnitsNet\UnitsNet.csproj"
-$numberExtensionsProjFile = "$root\UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj"
-$nanoFrameworkNuspecGeneratorFile = "$root\CodeGen\Generators\NanoFrameworkGen\NuspecGenerator.cs"
-$nanoFrameworkAssemblyInfoFile = "$root\UnitsNet.NanoFramework\GeneratedCode\Properties\AssemblyInfo.cs"
+$projectFiles = @(
+  "$root\UnitsNet\UnitsNet.csproj",
+  "$root\UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj",
+  "$root\UnitsNet.NumberExtensions.CS14\UnitsNet.NumberExtensions.CS14.csproj"
+)
 
-# Use UnitsNet.Common.props version as base if bumping major/minor/patch
-$newVersion = Get-NewProjectVersion $projFile $paramSet $setVersion $bumpVersion
+# Use UnitsNet version as base if bumping major/minor/patch
+$newVersion = Get-NewProjectVersion $projectFiles[0] $paramSet $setVersion $bumpVersion
 
 # Reset and stash any other local changes.
 $didStash = Invoke-StashPush
 
 # Update project files
-Set-ProjectVersion $projFile $newVersion
-Set-ProjectVersion $numberExtensionsProjFile $newVersion
-
-# Update AssemblyInfo.cs file for .NET nanoFramework
-Set-AssemblyInfoVersion $nanoFrameworkAssemblyInfoFile $newVersion
-
-# Update codegen and .nuspec files for nanoFramework
-Set-NuspecVersion $nanoFrameworkNuspecGeneratorFile $newVersion
-Get-ChildItem -Path "$root\UnitsNet.NanoFramework\GeneratedCode" -Include '*.nuspec' -Recurse |
-    Foreach-object {
-        Set-NuspecVersion $_.FullName $newVersion
-        $versionFiles += $_.FullName
-    }
+foreach ($projectFile in $projectFiles) {
+  Set-ProjectVersion $projectFile $newVersion
+}
 
 # Git commit and tag
 Invoke-CommitVersionBump @("UnitsNet") $newVersion
diff --git a/Build/set-version-json.sh b/Build/set-version-json.sh
index 38910ba879..529550e97d 100755
--- a/Build/set-version-json.sh
+++ b/Build/set-version-json.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# Sets version of nuget UnitNets.Serialization.JsonNet.
+# Sets the version of both UnitsNet serialization packages.
 script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 set_version_script="$script_dir/set-version-UnitsNet.Serialization.JsonNet.ps1"
 
diff --git a/Build/set-version.psm1 b/Build/set-version.psm1
index 6b28533c5a..015c5c81d6 100644
--- a/Build/set-version.psm1
+++ b/Build/set-version.psm1
@@ -71,85 +71,86 @@ function Set-NuspecVersion([string] $file, [string] $version) {
 function Get-BumpedProjectVersion([string] $projectPath, [string] $bumpVersion) {
   [xml]$projectXml = Get-Content -Path $projectPath
 
-  $old = Get-ProjectVersionAndSuffix $projectXml
+  $oldSemVer = [string]($projectXml.Project.PropertyGroup.Version)[0]
+
+  return Get-BumpedSemanticVersion $oldSemVer $bumpVersion
+}
+
+function Get-BumpedSemanticVersion(
+  [string] $semanticVersion,
+  [string] $bumpVersion,
+  [string] $defaultPreReleaseIdentifiers = "alpha000") {
+  $match = [regex]::Match(
+    $semanticVersion,
+    '^(?<major>0|[1-9][0-9]*)\.(?<minor>0|[1-9][0-9]*)\.(?<patch>0|[1-9][0-9]*)(?:-(?<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?<metadata>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$')
+
+  if (!$match.Success) {
+    throw "Unable to parse semantic version '$semanticVersion'."
+  }
+
+  $preRelease = $match.Groups["prerelease"].Value
+  foreach ($identifier in $preRelease.Split(".", [StringSplitOptions]::RemoveEmptyEntries)) {
+    if ($identifier -match '^[0-9]+$' -and $identifier.Length -gt 1 -and $identifier.StartsWith("0")) {
+      throw "Numeric prerelease identifier '$identifier' in '$semanticVersion' must not contain leading zeroes."
+    }
+  }
+
+  $major = [long]$match.Groups["major"].Value
+  $minor = [long]$match.Groups["minor"].Value
+  $patch = [long]$match.Groups["patch"].Value
 
   switch ($bumpVersion) {
     "major" {
-      $newVersion = BumpMajor $old.Version
-      $newSuffix = ""
+      return "$($major + 1).0.0"
     }
     "minor" {
-      $newVersion = BumpMinor $old.Version
-      $newSuffix = ""
+      return "$major.$($minor + 1).0"
     }
     "patch" {
-      $newVersion = BumpPatch $old.Version
-      $newSuffix = ""
+      return "$major.$minor.$($patch + 1)"
     }
     "suffix" {
-      $newVersion = $old.Version
-      $newSuffix = BumpSuffix $old.Suffix
+      $newSuffix = BumpSuffix $(if ($preRelease) { "-$preRelease" } else { "" }) $defaultPreReleaseIdentifiers
+      return "$major.$minor.$patch$newSuffix"
     }
     default {
       throw "Unrecognized 'bumpVersion' argument: $bumpVersion"
     }
   }
-
-  $newSemVer = $newVersion.ToString() + $newSuffix
-  return $newSemVer
-}
-
-function BumpMajor ([Version] $oldVersion) {
-  return New-Object System.Version -ArgumentList ($oldVersion.Major+1), 0, 0
-}
-
-function BumpMinor([Version] $oldVersion) {
-  return New-Object System.Version -ArgumentList $oldVersion.Major, ($oldVersion.Minor+1), 0
-}
-
-function BumpPatch([Version] $oldVersion) {
-  return New-Object System.Version -ArgumentList $oldVersion.Major, $oldVersion.Minor, ($oldVersion.Build+1);
 }
 
-function BumpSuffix([string] $oldSuffix) {
+function BumpSuffix(
+  [string] $oldSuffix,
+  [string] $defaultPreReleaseIdentifiers = "alpha000") {
   $oldSuffix = $oldSuffix.Trim()
 
-  # A suffix is a dash '-', then a sequcence of word characters followed by an optional number
-  # Example:
-  # ""      => "-alpha001"
-  # "-beta" => "-beta001"
-  # "-beta1"=> "-beta002"
-  $match = [regex]::Match($oldSuffix, '^-([a-zA-Z]+)(\d+)?$');
-  $oldSuffix = $match.Groups[1].Value
-  if (!$oldSuffix) {
-    $oldSuffix = "alpha"
+  $preRelease = $oldSuffix.TrimStart("-")
+  if (!$preRelease) {
+    $preRelease = $defaultPreReleaseIdentifiers
   }
 
-  $numberGroup = $match.Groups[2]
-
-  $number = if ($numberGroup.Success) { 1+$match.Groups[2].Value } else { 1 }
-
-  # Use 3 digits for the number "-alpha003", for 999 releases lexically sorted.
-  return [string]::Format("-{0}{1:D3}", $oldSuffix, $number)
-}
-
-# Returns object with properties: Version, Suffix
-function Get-ProjectVersionAndSuffix([xml] $projectXml) {
+  $identifiers = [Collections.Generic.List[string]]::new()
+  $identifiers.AddRange([string[]]$preRelease.Split("."))
+  $lastIdentifierIndex = $identifiers.Count - 1
+  $lastIdentifier = $identifiers[$lastIdentifierIndex]
 
-  # Split "1.2.3-alpha" into ["1.2.3", "alpha"]
-  # Split "1.2.3" into ["1.2.3"]
-  $oldSemVer = $($projectXml.Project.PropertyGroup.Version)[0]
-
-  $oldSemVerParts = $oldSemVer.Split('-')
-  $oldVersion = $null
-  if (-not [Version]::TryParse($oldSemVerParts[0], [ref] $oldVersion)) { throw "Unable to parse old version." }
-
-  $oldSuffix = if ($oldSemVerParts.Length -eq 2) { "-" + $oldSemVerParts[1]} else { "" }
-  return [PSCustomObject]@{
-    PSTypeName = "VersionAndSuffix"
-    Version = $oldVersion
-    Suffix = $oldSuffix
+  if ($lastIdentifier -match '^[0-9]+$') {
+    $identifiers[$lastIdentifierIndex] = ([long]$lastIdentifier + 1).ToString()
+  }
+  elseif ($lastIdentifier -match '^(?<prefix>.*?)(?<number>[0-9]+)$') {
+    $numberWidth = $Matches["number"].Length
+    $number = [long]$Matches["number"] + 1
+    $identifiers[$lastIdentifierIndex] = $Matches["prefix"] + $number.ToString("D$numberWidth")
   }
+  elseif ($identifiers.Count -eq 1) {
+    # Preserve the repository's existing alpha001/beta001 suffix convention.
+    $identifiers[0] += "001"
+  }
+  else {
+    $identifiers.Add("1")
+  }
+
+  return "-" + [string]::Join(".", $identifiers)
 }
 
 function Resolve-Error ($ErrorRecord=$Error[0])
@@ -169,6 +170,7 @@ function Resolve-Error ($ErrorRecord=$Error[0])
 }
 
 export-modulemember -function Get-NewProjectVersion,
+  Get-BumpedSemanticVersion,
   Invoke-CommitVersionBump,
   Invoke-TagVersionBump,
   Set-ProjectVersion,
diff --git a/Build/set-version.sh b/Build/set-version.sh
index 78f9ffd372..d45f2fa0bf 100755
--- a/Build/set-version.sh
+++ b/Build/set-version.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-# Increments version of nugets UnitNets, UnitsNet.NumberExtensions.
+# Sets the version of UnitsNet and both UnitsNet.NumberExtensions packages.
 script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 set_version_script="$script_dir/set-version-UnitsNet.ps1"
 
diff --git a/Build/test-projects.psm1 b/Build/test-projects.psm1
new file mode 100644
index 0000000000..04250311ec
--- /dev/null
+++ b/Build/test-projects.psm1
@@ -0,0 +1,13 @@
+function Get-TestProjectPaths {
+  return @(
+    "UnitsNet.Tests/UnitsNet.Tests.csproj",
+    "UnitsNet.GlobalSetup.DefaultFirst.Tests/UnitsNet.GlobalSetup.DefaultFirst.Tests.csproj",
+    "UnitsNet.GlobalSetup.Tests/UnitsNet.GlobalSetup.Tests.csproj",
+    "UnitsNet.NumberExtensions.Tests/UnitsNet.NumberExtensions.Tests.csproj",
+    "UnitsNet.NumberExtensions.CS14.Tests/UnitsNet.NumberExtensions.CS14.Tests.csproj",
+    "UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj",
+    "UnitsNet.Serialization.SystemTextJson.Tests/UnitsNet.Serialization.SystemTextJson.Tests.csproj"
+  )
+}
+
+Export-ModuleMember -Function Get-TestProjectPaths
diff --git a/CLAUDE.md b/CLAUDE.md
index 9d426d0d2f..6cb611ccbe 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,135 +1,5 @@
 # CLAUDE.md
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+@AGENTS.md
 
-## Project Overview
-
-UnitsNet is a .NET library that provides strongly-typed physical units and quantities, enabling safe and intuitive unit conversions in code. The library uses code generation from JSON definitions to create type-safe APIs for over 130 physical quantities.
-
-## Key Commands
-
-### Build and Test
-- **Build project**: `build.bat` or `dotnet build UnitsNet.slnx`
-- **Build all targets** (including nanoFramework): `build-all-targets.bat`
-- **Run tests**: `test.bat` or `dotnet test UnitsNet.slnx`
-- **Run single test**: `dotnet test UnitsNet.Tests --filter "FullyQualifiedName~TestClassName.TestMethodName"`
-- **Clean artifacts**: `clean.bat`
-
-### Code Generation
-- **Generate code from JSON definitions**: `generate-code.bat` or `dotnet run --project CodeGen`
-  - Always run this after modifying any JSON files in `Common/UnitDefinitions/`
-  - The generator reads 131 JSON definition files and creates C# code
-
-### Development Workflow
-1. Modify unit definitions in `Common/UnitDefinitions/*.json`
-2. Run `generate-code.bat` to regenerate C# code
-3. Run `build.bat` to compile and test
-4. Use `test.bat` for isolated test runs
-
-## Code Architecture
-
-### Project Structure
-- **UnitsNet/**: Main library with quantity types and units
-  - `GeneratedCode/`: Auto-generated from JSON definitions (do not edit manually)
-  - `CustomCode/`: Hand-written code extending generated types
-- **UnitsNet.Tests/**: Comprehensive test suite
-- **CodeGen/**: Code generation tool that creates C# from JSON definitions
-- **Common/UnitDefinitions/**: 131 JSON files defining physical quantities
-- **UnitsNet.NumberExtensions/**: Extension methods for numeric types
-- **UnitsNet.Serialization.*/**: JSON.NET and System.Text.Json serialization support
-- **UnitsNet.NanoFramework/**: Support for embedded .NET nanoFramework
-
-### Code Generation Process
-The project uses a sophisticated code generation system:
-1. JSON definitions in `Common/UnitDefinitions/` describe units, conversions, and localizations
-2. `CodeGen` project processes these to generate:
-   - Quantity types (e.g., `Length`, `Mass`)
-   - Unit enums (e.g., `LengthUnit`, `MassUnit`)
-   - Conversion logic and unit abbreviations
-3. Generated code goes to `*/GeneratedCode/` folders
-4. Custom code in `*/CustomCode/` extends generated types
-
-### Key Classes and Patterns
-- **IQuantity**: Base interface for all quantity types
-- **Quantity**: Static class for dynamic quantity operations
-- **UnitConverter**: Handles conversions between units
-- **QuantityParser/UnitParser**: Parse strings to quantities/units
-- **UnitsNetSetup**: Configuration singleton
-
-### Adding or Modifying Units
-1. Edit or create JSON file in `Common/UnitDefinitions/`
-2. Follow conversion function guidelines in [Docs/adding-a-new-unit.md](Docs/adding-a-new-unit.md):
-   - Use multiplication for `FromUnitToBaseFunc`
-   - Use division for `FromBaseToUnitFunc`
-   - Prefer scientific notation (1e3, 1e-5)
-   - Use exact constituent constants instead of pre-computed decimals
-3. Run `generate-code.bat`
-4. Add tests if needed
-
-## Important Conventions
-
-### Coding Standards
-- Follow `.editorconfig` specifications
-- Use ReSharper settings in `UnitsNet.sln.DotSettings`
-- Treat warnings as errors (except obsolete warnings)
-- Add file headers to new files
-
-### Unit Definition Rules
-- Base units are chosen for each quantity (e.g., meter for Length)
-- All conversions go through the base unit
-- Use superscript in abbreviations: cm², m³
-- Compound units format: N·m (dot), km/h (slash)
-
-### Testing
-- Test class naming: `<Type>Tests`
-- Test method naming: `<method>_<condition>_<result>`
-- Tests accept error margin of 1E-5 for most units
-
-## Special Considerations
-
-### .NET nanoFramework Support
-- Separate projects for nanoFramework compatibility
-- Use `build-all-targets.bat` to include nanoFramework builds
-- Limited feature set compared to full .NET
-
-### Performance
-- Conversion functions are compiled to delegates for performance
-- All conversions go through base units (potential for small errors)
-- Precision goal is 1E-5 for most units
-
-### Localization
-- Unit abbreviations support multiple cultures
-- JSON definitions include translations for various languages
-- Default culture: Thread.CurrentCulture, fallback to en-US
-
-## Common Tasks
-
-### Find specific quantity or unit implementation
-- Quantity types: `UnitsNet/GeneratedCode/Quantities/*.g.cs`
-- Unit enums: `UnitsNet/GeneratedCode/Units/*.g.cs`
-- Custom extensions: `UnitsNet/CustomCode/Quantities/*.extra.cs`
-- Unit definitions: `Common/UnitDefinitions/*.json`
-
-### Debug code generation
-- Generator entry: `CodeGen/Program.cs`
-- Generator logic: `CodeGen/Generators/`
-- Enable verbose logging: Check Serilog configuration in Program.cs
-
-### Run performance benchmarks
-- Execute: `dotnet run -c Release --project UnitsNet.Benchmark`
-- Results saved to `Artifacts/` folder
-
-## Documentation
-
-All contributor and user documentation lives in [Docs/](Docs/README.md), including:
-- [Adding a New Unit](Docs/adding-a-new-unit.md) — step-by-step guide with JSON schema conventions
-- [Adding Operator Overloads](Docs/adding-operator-overloads.md)
-- [Precision](Docs/precision.md) — conversion precision and test value guidelines
-- [Serialization](Docs/serialization.md), [String Formatting](Docs/string-formatting.md), [Saving to Database](Docs/saving-to-database.md)
-- [Upgrade Guides](Docs/README.md#upgrade-guides) for major version migrations
-
-## Pull request reviews
-
-### Adding new quantities or units
-
-See `.claude/criteria-for-adding-quantities-and-units.md` for instructions on adding new quantities or units to ensure they are widely used and well defined.
+Follow the shared repository guidance in `AGENTS.md`.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 2645925997..27eabe43ec 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -23,6 +23,7 @@ This is to help grow the number of people that can contribute to the project and
 * Test class: Use `Tests` suffix for the type you are testing, such as `UnitSystemTests`
 * Test method: `<method>_<condition>_<result>` (`Parse_AmbiguousUnits_ThrowsException`)
 * If there are many tests for a single method, you can wrap those in an inner class named the same as the method and then you can skip that part of the test method names
+* Test conversion values should have at least 7 significant digits (`double` supports ~15-17, so anything beyond 16 is not useful)
 
 ## Unit Definitions (.JSON)
 
diff --git a/CodeGen/CodeGen.csproj b/CodeGen/CodeGen.csproj
index da0c0ddb03..c0b882ce31 100644
--- a/CodeGen/CodeGen.csproj
+++ b/CodeGen/CodeGen.csproj
@@ -20,6 +20,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Fractions" />
     <PackageReference Include="Newtonsoft.Json" />
     <PackageReference Include="NuGet.Protocol" />
     <PackageReference Include="Serilog" />
diff --git a/CodeGen/Exceptions/UnitsNetCodeGenException.cs b/CodeGen/Exceptions/UnitsNetCodeGenException.cs
index e25340993a..b3aab05d5d 100644
--- a/CodeGen/Exceptions/UnitsNetCodeGenException.cs
+++ b/CodeGen/Exceptions/UnitsNetCodeGenException.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/CodeGen/Generators/NanoFrameworkGen/NuspecGenerator.cs b/CodeGen/Generators/NanoFrameworkGen/NuspecGenerator.cs
deleted file mode 100644
index c5fbe836a0..0000000000
--- a/CodeGen/Generators/NanoFrameworkGen/NuspecGenerator.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-using System;
-using CodeGen.JsonTypes;
-
-namespace CodeGen.Generators.NanoFrameworkGen
-{
-    class NuspecGenerator : GeneratorBase
-    {
-        private readonly Quantity _quantity;
-        private readonly string _mscorlibNuGetVersion;
-        private readonly string _mathNuGetVersion;
-
-        public NuspecGenerator(
-            Quantity quantity,
-            string mscorlibNuGetVersion,
-            string mathNuGetVersion)
-        {
-            _quantity = quantity ?? throw new ArgumentNullException(nameof(quantity));
-            _mscorlibNuGetVersion = mscorlibNuGetVersion;
-            _mathNuGetVersion = mathNuGetVersion;
-        }
-
-        public string Generate()
-        {
-            Writer.WL($@"<?xml version=""1.0"" encoding=""utf-8""?>
-<package xmlns=""http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd"">
-  <metadata>
-    <id>UnitsNet.nanoFramework.{_quantity.Name}</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET {_quantity.Name} - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type=""expression"">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds {_quantity.Name} units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework {_quantity.Name.ToLower()} unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id=""nanoFramework.CoreLibrary"" version=""{_mscorlibNuGetVersion}"" />");
-
-    if (NanoFrameworkGenerator.ProjectsRequiringMath.Contains(_quantity.Name))
-    {
-                Writer.WL($@"
-      <dependency id=""nanoFramework.System.Math"" version=""{_mathNuGetVersion}"" />");
-    }
-
-            Writer.WL($@"
-    </dependencies>
-  </metadata>
-  <files>
-    <file src=""..\..\..\Artifacts\UnitsNet.NanoFramework\{_quantity.Name}\UnitsNet.*"" target=""lib"" />
-  </files>
-</package>");
-
-            return Writer.ToString();
-        }
-    }
-}
diff --git a/CodeGen/Generators/NanoFrameworkGen/ProjectGenerator.cs b/CodeGen/Generators/NanoFrameworkGen/ProjectGenerator.cs
deleted file mode 100644
index f07787513d..0000000000
--- a/CodeGen/Generators/NanoFrameworkGen/ProjectGenerator.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-using System;
-using CodeGen.Helpers;
-using CodeGen.JsonTypes;
-
-namespace CodeGen.Generators.NanoFrameworkGen
-{
-    class ProjectGenerator: GeneratorBase
-    {
-        private readonly Quantity _quantity;
-        private readonly NanoFrameworkVersions _versions;
-
-        public ProjectGenerator(Quantity quantity, NanoFrameworkVersions versions)
-        {
-            _quantity = quantity ?? throw new ArgumentNullException(nameof(quantity));
-            _versions = versions;
-        }
-
-        public string Generate()
-        {
-            Writer.WL($@"<?xml version=""1.0"" encoding=""utf-8""?>
-<Project ToolsVersion=""15.0"" DefaultTargets=""Build"" xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
-  <PropertyGroup Label=""Globals"">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project=""$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props"" Condition=""Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')"" />
-  <PropertyGroup>
-    <Configuration Condition="" '$(Configuration)' == '' "">Debug</Configuration>
-    <Platform Condition="" '$(Platform)' == '' "">AnyCPU</Platform>
-    <ProjectTypeGuids>{{11A8DD76-328B-46DF-9F39-F559912D0360}};{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}</ProjectTypeGuids>
-    <ProjectGuid>{HashGuid.ToHashGuid(_quantity.Name):B}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.{_quantity.Name}</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project=""$(NanoFrameworkProjectSystemPath)NFProjectSystem.props"" Condition=""Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')"" />
-  <ItemGroup>
-    <Compile Include=""..\Quantities\{_quantity.Name}.g.cs"" />
-    <Compile Include=""..\Units\{_quantity.Name}Unit.g.cs"" />
-    <Compile Include=""..\Properties\AssemblyInfo.cs"" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include=""mscorlib, Version={_versions.MscorlibVersion}, Culture=neutral, PublicKeyToken=c07d481e9758c731"">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.{_versions.MscorlibNugetVersion}\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>");
-
-    if (NanoFrameworkGenerator.ProjectsRequiringMath.Contains(_quantity.Name))
-    {
-                Writer.WL($@"
-    <Reference Include=""System.Math, Version={_versions.MathVersion}, Culture=neutral, PublicKeyToken=c07d481e9758c731"">
-      <HintPath>..\packages\nanoFramework.System.Math.{_versions.MathNugetVersion}\lib\System.Math.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>");
-    }
-
-            Writer.WL(@"
-  </ItemGroup>
-  <ItemGroup>
-    <None Include=""packages.config"" />
-  </ItemGroup>
-  <Import Project=""$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets"" Condition=""Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')"" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>");
-
-            return Writer.ToString();
-        }
-    }
-}
diff --git a/CodeGen/Generators/NanoFrameworkGen/PropertyGenerator.cs b/CodeGen/Generators/NanoFrameworkGen/PropertyGenerator.cs
deleted file mode 100644
index 6973936633..0000000000
--- a/CodeGen/Generators/NanoFrameworkGen/PropertyGenerator.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-namespace CodeGen.Generators.NanoFrameworkGen
-{
-    class PropertyGenerator : GeneratorBase
-    {
-        private readonly string _version;
-
-        public PropertyGenerator(string version)
-        {
-            _version = version;
-        }
-
-        public string Generate()
-        {
-            Writer.WL(GeneratedFileHeader);
-            Writer.W($@"using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle(""UnitsNet"")]
-[assembly: AssemblyDescription(""Get all the common units of measurement and the conversions between them. It is light-weight and thoroughly tested."")]
-[assembly: AssemblyConfiguration("""")]
-[assembly: AssemblyCompany(""Andreas Gullberg Larsen"")]
-[assembly: AssemblyProduct(""nanoFramework UnitsNet"")]
-[assembly: AssemblyCopyright(""Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com)."")]
-[assembly: AssemblyTrademark("""")]
-[assembly: AssemblyCulture("""")]
-
-// Setting ComVisible to false makes the types in this assembly not visible
-// to COM components.  If you need to access a type in this assembly from
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers
-// by using the '*' as shown below:
-[assembly: AssemblyVersion(""{_version}"")]
-[assembly: AssemblyFileVersion(""{_version}"")]
-
-//////////////////////////////////////////////////
-// This assembly doens't require native support //
-[assembly: AssemblyNativeVersion(""0.0.0.0"")]
-//////////////////////////////////////////////////
-");
-            return Writer.ToString();
-        }
-    }
-}
diff --git a/CodeGen/Generators/NanoFrameworkGen/QuantityGenerator.cs b/CodeGen/Generators/NanoFrameworkGen/QuantityGenerator.cs
deleted file mode 100644
index 04d8acad5f..0000000000
--- a/CodeGen/Generators/NanoFrameworkGen/QuantityGenerator.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-using System;
-using CodeGen.Helpers;
-using CodeGen.JsonTypes;
-
-namespace CodeGen.Generators.NanoFrameworkGen
-{
-    internal class QuantityGenerator : GeneratorBase
-    {
-        private readonly Quantity _quantity;
-        private readonly string _unitEnumName;
-
-        public QuantityGenerator(Quantity quantity)
-        {
-            _quantity = quantity ?? throw new ArgumentNullException(nameof(quantity));
-            _unitEnumName = $"{quantity.Name}Unit";
-        }
-
-        public string Generate()
-        {
-            // Auto generated header
-            Writer.WL(GeneratedFileHeader);
-            // Usings, properties
-            Writer.WL($@"using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{{");
-            Writer.WL($@"
-    /// <inheritdoc />
-    /// <summary>
-    ///     {_quantity.XmlDocSummary}
-    /// </summary>");
-
-            Writer.WLCondition(_quantity.XmlDocRemarks.HasText(), $@"
-    /// <remarks>
-    ///     {_quantity.XmlDocRemarks}
-    /// </remarks>");
-            Writer.WLIfText(1, GetObsoleteAttributeOrNull(_quantity));
-
-            Writer.WL($@"
-    public struct  {_quantity.Name}
-    {{
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly {_unitEnumName} _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public {_unitEnumName} Unit => _unit;
-");
-
-            // Constructor and static properties
-            Writer.WL($@"        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name=""value"">The numeric value to construct this quantity with.</param>
-        /// <param name=""unit"">The unit representation to construct this quantity with.</param>
-        public {_quantity.Name}(double value, {_unitEnumName} unit)
-        {{
-            _value = value;
-            _unit = unit;
-        }}
-
-        /// <summary>
-        ///     The base unit of {_quantity.Name}, which is Second. All conversions go via this value.
-        /// </summary>
-        public static {_unitEnumName} BaseUnit {{ get; }} = {_unitEnumName}.{_quantity.BaseUnit};
-
-        /// <summary>
-        /// Represents the largest possible value of {_quantity.Name}.
-        /// </summary>
-        public static {_quantity.Name} MaxValue {{ get; }} = new {_quantity.Name}(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of {_quantity.Name}.
-        /// </summary>
-        public static {_quantity.Name} MinValue {{ get; }} = new {_quantity.Name}(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static {_quantity.Name} Zero {{ get; }} = new {_quantity.Name}(0, BaseUnit);");
-
-            GenerateConversionProperties();
-            GenerateStaticFactoryMethods();
-            GenerateConversionMethods();
-
-            Writer.WL(@"
-    }
-}
-");
-
-            return Writer.ToString();
-        }
-
-        private void GenerateConversionProperties()
-        {
-            Writer.WL(@"
-        #region Conversion Properties
-");
-            foreach (Unit unit in _quantity.Units)
-            {
-                if (unit.SkipConversionGeneration) continue;
-
-                Writer.WL($@"
-        /// <summary>
-        ///     Gets a <see cref=""double""/> value of this quantity converted into <see cref=""{_unitEnumName}.{unit.SingularName}""/>
-        /// </summary>");
-                Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
-                Writer.WL($@"
-        public double {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
-");
-            }
-
-            Writer.WL(@"
-
-        #endregion
-");
-        }
-
-        private void GenerateStaticFactoryMethods()
-        {
-            Writer.WL(@"
-        #region Static Factory Methods
-");
-            foreach (Unit unit in _quantity.Units)
-            {
-                if (unit.SkipConversionGeneration) continue;
-
-                var valueParamName = unit.PluralName.ToLowerInvariant();
-                Writer.WL($@"
-        /// <summary>
-        ///     Creates a <see cref=""{_quantity.Name}""/> from <see cref=""{_unitEnumName}.{unit.SingularName}""/>.
-        /// </summary>");
-                Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
-                Writer.WL($@"
-        public static {_quantity.Name} From{unit.PluralName}(double {valueParamName}) => new {_quantity.Name}({valueParamName}, {_unitEnumName}.{unit.SingularName});
-");
-            }
-
-            Writer.WL($@"
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref=""{_unitEnumName}"" /> to <see cref=""{_quantity.Name}"" />.
-        /// </summary>
-        /// <param name=""value"">Value to convert from.</param>
-        /// <param name=""fromUnit"">Unit to convert from.</param>
-        /// <returns>{_quantity.Name} unit value.</returns>
-        public static {_quantity.Name} From(double value, {_unitEnumName} fromUnit)
-        {{
-            return new {_quantity.Name}(value, fromUnit);
-        }}
-
-        #endregion
-");
-        }
-
-        private void GenerateConversionMethods()
-        {
-            Writer.WL($@"
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name=""unit"" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As({_unitEnumName} unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this {_quantity.Name} to another {_quantity.Name} with the unit representation <paramref name=""unit"" />.
-                /// </summary>
-                /// <returns>A {_quantity.Name} with the specified unit.</returns>
-                public {_quantity.Name} ToUnit({_unitEnumName} unit)
-                {{
-                    var convertedValue = GetValueAs(unit);
-                    return new {_quantity.Name}(convertedValue, unit);
-                }}
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {{
-                    return Unit switch
-                    {{");
-            foreach (Unit unit in _quantity.Units)
-            {
-                var func = unit.FromUnitToBaseFunc.Replace("{x}", "_value");
-                Writer.WL($@"
-                        {_unitEnumName}.{unit.SingularName} => {func},");
-            }
-
-            Writer.WL($@"
-                        _ => throw new NotImplementedException($""Can't convert {{Unit}} to base units."")
-                    }};
-                    }}
-
-                private double GetValueAs({_unitEnumName} unit)
-                {{
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {{");
-            foreach (Unit unit in _quantity.Units)
-            {
-                var func = unit.FromBaseToUnitFunc.Replace("{x}", "baseUnitValue");
-                Writer.WL($@"
-                        {_unitEnumName}.{unit.SingularName} => {func},");
-            }
-
-            Writer.WL(@"
-                        _ => throw new NotImplementedException($""Can't convert {Unit} to {unit}."")
-                    };
-                    }
-
-                #endregion");
-        }
-
-        /// <inheritdoc cref="GetObsoleteAttributeOrNull(string)"/>
-        private static string? GetObsoleteAttributeOrNull(Quantity quantity) => GetObsoleteAttributeOrNull(quantity.ObsoleteText);
-
-        /// <inheritdoc cref="GetObsoleteAttributeOrNull(string)"/>
-        private static string? GetObsoleteAttributeOrNull(Unit unit) => GetObsoleteAttributeOrNull(unit.ObsoleteText);
-
-        /// <summary>
-        /// Returns the Obsolete attribute if ObsoleteText has been defined on the JSON input - otherwise returns empty string
-        /// It is up to the consumer to wrap any padding/new lines in order to keep to correct indentation formats
-        /// </summary>
-        private static string? GetObsoleteAttributeOrNull(string? obsoleteText) => string.IsNullOrWhiteSpace(obsoleteText)
-            ? null
-            : $"[Obsolete(\"{obsoleteText}\")]";
-
-    }
-}
diff --git a/CodeGen/Generators/NanoFrameworkGen/SolutionGenerator.cs b/CodeGen/Generators/NanoFrameworkGen/SolutionGenerator.cs
deleted file mode 100644
index ac919c0574..0000000000
--- a/CodeGen/Generators/NanoFrameworkGen/SolutionGenerator.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-using System;
-using System.Text;
-using CodeGen.Helpers;
-using CodeGen.JsonTypes;
-
-namespace CodeGen.Generators.NanoFrameworkGen
-{
-    class SolutionGenerator:GeneratorBase
-    {
-        private readonly Quantity[] _quantities;
-        private readonly Guid _globalGuid = new("d608a2b1-6ead-4383-a205-ad1ce69d9ef7"); // Randomly generated guids.
-        private readonly Guid _solutionGuid = new("43971d92-3663-4f28-82ac-e63ce06ba1a3");
-
-        public SolutionGenerator(Quantity[] quantities)
-        {
-            _quantities = quantities;
-        }
-
-        public string Generate()
-        {
-            StringBuilder sb = new();
-            Writer.WL($@"Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.30413.136
-MinimumVisualStudioVersion = 10.0.40219.1");
-
-            foreach (var quantity in _quantities)
-            {
-                var projectGuid = HashGuid.ToHashGuid(quantity.Name);
-                Writer.WL($@"
-Project(""{_globalGuid:B}"") = ""{quantity.Name}"", ""{quantity.Name}\{quantity.Name}.nfproj"", ""{projectGuid:B}""
-EndProject");
-                sb.Append($"{{{projectGuid}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU\r\n");
-                sb.Append($"{{{projectGuid}}}.Debug|Any CPU.Build.0 = Debug|Any CPU\r\n");
-                sb.Append($"{{{projectGuid}}}.Debug|Any CPU.Deploy.0 = Debug|Any CPU\r\n");
-                sb.Append($"{{{projectGuid}}}.Release|Any CPU.ActiveCfg = Release|Any CPU\r\n");
-                sb.Append($"{{{projectGuid}}}.Release|Any CPU.Build.0 = Release|Any CPU\r\n");
-                sb.Append($"{{{projectGuid}}}.Release|Any CPU.Deploy.0 = Release|Any CPU\r\n");
-            }
-
-            Writer.WL(@"Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution");
-
-            Writer.WL(sb.ToString());
-
-            Writer.WL($@"	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {_solutionGuid:B}
-	EndGlobalSection
-EndGlobal
-");
-            return Writer.ToString();
-        }
-    }
-}
diff --git a/CodeGen/Generators/NanoFrameworkGen/UnitTypeGenerator.cs b/CodeGen/Generators/NanoFrameworkGen/UnitTypeGenerator.cs
deleted file mode 100644
index 5e485b9cda..0000000000
--- a/CodeGen/Generators/NanoFrameworkGen/UnitTypeGenerator.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-using CodeGen.Helpers;
-using CodeGen.Helpers.UnitEnumValueAllocation;
-using CodeGen.JsonTypes;
-
-namespace CodeGen.Generators.NanoFrameworkGen
-{
-    internal class UnitTypeGenerator : GeneratorBase
-    {
-        private readonly Quantity _quantity;
-        private readonly UnitEnumNameToValue _unitEnumNameToValue;
-        private readonly string _unitEnumName;
-
-        public UnitTypeGenerator(Quantity quantity, UnitEnumNameToValue unitEnumNameToValue)
-        {
-            _quantity = quantity;
-            _unitEnumNameToValue = unitEnumNameToValue;
-            _unitEnumName = $"{quantity.Name}Unit";
-        }
-
-        public string Generate()
-        {
-            Writer.WL(GeneratedFileHeader);
-            Writer.WL($@"
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum {_unitEnumName}
-    {{");
-            foreach (Unit unit in _quantity.Units)
-            {
-                if (unit.XmlDocSummary.HasText())
-                {
-                    Writer.WL();
-                    Writer.WL($@"
-        /// <summary>
-        ///     {unit.XmlDocSummary}
-        /// </summary>");
-                }
-
-                if (unit.XmlDocRemarks.HasText())
-                {
-                    Writer.WL($@"
-        /// <remarks>{unit.XmlDocRemarks}</remarks>");
-                }
-
-                Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText));
-                Writer.WL($@"
-        {unit.SingularName} = {_unitEnumNameToValue[unit.SingularName]},");
-            }
-
-            Writer.WL($@"
-    }}
-
-    #pragma warning restore 1591
-}}");
-            return Writer.ToString();
-        }
-
-        private static string? GetObsoleteAttributeOrNull(string? obsoleteText) =>
-            string.IsNullOrWhiteSpace(obsoleteText) ?
-            null :
-            $"[System.Obsolete(\"{obsoleteText}\")]";
-    }
-}
diff --git a/CodeGen/Generators/NanoFrameworkGenerator.cs b/CodeGen/Generators/NanoFrameworkGenerator.cs
deleted file mode 100644
index 19d8cab43c..0000000000
--- a/CodeGen/Generators/NanoFrameworkGenerator.cs
+++ /dev/null
@@ -1,394 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using CodeGen.Generators.NanoFrameworkGen;
-using CodeGen.Helpers;
-using CodeGen.Helpers.UnitEnumValueAllocation;
-using CodeGen.JsonTypes;
-using NuGet.Common;
-using Serilog;
-using ILogger = NuGet.Common.ILogger;
-
-namespace CodeGen.Generators
-{
-    /// <summary>
-    /// Code generator for nanoFramework
-    /// Will generate 1 nanoFramework project per unit, a common property folder and a common package file
-    /// </summary>
-    internal static class NanoFrameworkGenerator
-    {
-        /// <summary>
-        /// These projects require inclusion of Math NuGet package.
-        /// </summary>
-        internal static readonly List<string> ProjectsRequiringMath = new()
-        {
-            "Angle",
-            "Frequency",
-            "Pressure",
-            "Turbidity",
-            "WarpingMomentOfInertia"
-        };
-
-        /// <summary>
-        /// Create the root folder NanoFramework
-        /// Create all the quantities unit and quantities file
-        /// Create all individual nanoFramework projects
-        /// Create common package file
-        /// Create common properties file
-        /// </summary>
-        /// <param name="rootDir">The root directory</param>
-        /// <param name="quantities">The quantities to create</param>
-        /// <param name="quantityNameToUnitEnumValues"></param>
-        public static void Generate(string rootDir, Quantity[] quantities, QuantityNameToUnitEnumValues quantityNameToUnitEnumValues)
-        {
-            // get latest version of .NET nanoFramework mscorlib
-            ILogger logger = NullLogger.Instance;
-
-            NanoFrameworkVersions versions = ParseCurrentNanoFrameworkVersions(rootDir);
-
-            logger.LogInformation($"Referencing nanoFramework.CoreLibrary {versions.MscorlibNugetVersion}");
-            logger.LogInformation($"Referencing nanoFramework.System.Math {versions.MathNugetVersion}");
-
-            var outputDir = Path.Combine(rootDir, "UnitsNet.NanoFramework", "GeneratedCode");
-            var outputQuantities = Path.Combine(outputDir, "Quantities");
-            var outputUnits = Path.Combine(outputDir, "Units");
-            var outputProperties = Path.Combine(outputDir, "Properties");
-
-            // Ensure output directories exist
-            Directory.CreateDirectory(outputQuantities);
-            Directory.CreateDirectory(outputUnits);
-            Directory.CreateDirectory(outputProperties);
-
-            var lengthNuspecFile = Path.Combine(outputDir, "Length", "UnitsNet.NanoFramework.Length.nuspec");
-            var projectVersion = ParseVersion(File.ReadAllText(lengthNuspecFile),
-                new Regex(@"<version>(?<version>[\d.]+)(?<suffix>-[a-z\d]+)?<\/version>", RegexOptions.IgnoreCase),
-                "projectVersion");
-
-            foreach (Quantity quantity in quantities)
-            {
-                var projectPath = Path.Combine(outputDir, quantity.Name);
-                Directory.CreateDirectory(projectPath);
-
-                GeneratePackageConfig(
-                    projectPath,
-                    quantity.Name,
-                    versions.MscorlibNugetVersion,
-                    versions.MathNugetVersion);
-
-                GenerateNuspec(
-                    projectPath,
-                    quantity,
-                    versions.MscorlibNugetVersion,
-                    versions.MathNugetVersion);
-
-                UnitEnumNameToValue unitEnumValues = quantityNameToUnitEnumValues[quantity.Name];
-
-                GenerateUnitType(quantity, Path.Combine(outputUnits, $"{quantity.Name}Unit.g.cs"), unitEnumValues);
-                GenerateQuantity(quantity, Path.Combine(outputQuantities, $"{quantity.Name}.g.cs"));
-                GenerateProject(quantity, Path.Combine(projectPath, $"{quantity.Name}.nfproj"), versions);
-
-                Log.Information("✅ {Quantity} (nanoFramework)", quantity.Name);
-            }
-            Log.Information("");
-
-            GenerateProperties(Path.Combine(outputProperties, "AssemblyInfo.cs"), projectVersion);
-            GenerateSolution(quantities, outputDir);
-
-            var unitCount = quantities.SelectMany(q => q.Units).Count();
-            Log.Information("");
-            Log.Information("Total of {UnitCount} units and {QuantityCount} quantities (nanoFramework)", unitCount, quantities.Length);
-            Log.Information("");
-        }
-
-        /// <summary>
-        /// Updates existing nanoFramework projects and nuspec files with the latest versions.
-        /// </summary>
-        /// <param name="rootDir">The root directory</param>
-        /// <param name="quantities">The quantities to update nuspec files</param>
-        public static bool UpdateNanoFrameworkDependencies(
-            string rootDir,
-            Quantity[] quantities)
-        {
-            // working path
-            var path = Path.Combine(rootDir, "UnitsNet.NanoFramework\\GeneratedCode");
-
-            Log.Information("");
-            Log.Information("Restoring .NET nanoFramework projects");
-
-            // run nuget CLI
-            using var nugetRestore = new Process
-            {
-                StartInfo = new ProcessStartInfo
-                {
-                    FileName = Path.Combine(rootDir, ".tools/nuget.exe"),
-                    Arguments = $"restore {path}\\UnitsNet.nanoFramework.sln",
-                    UseShellExecute = false,
-                    CreateNoWindow = true,
-                    RedirectStandardError = true
-                }
-            };
-
-            // start nuget CLI and wait for exit
-            if (!nugetRestore.Start())
-            {
-                Log.Information("");
-                Log.Information("Failed to start nuget CLI to restore .NET nanoFramework projects");
-                Log.Information("");
-            }
-            else
-            {
-                // wait for exit, within 2 minutes
-                if (!nugetRestore.WaitForExit((int)TimeSpan.FromMinutes(2).TotalMilliseconds))
-                {
-                    Log.Information("");
-                    Log.Information("Failed to complete execution of nuget CLI to restore .NET nanoFramework projects");
-                    Log.Information("");
-                }
-                else
-                {
-                    if (nugetRestore.ExitCode == 0)
-                    {
-                        Log.Information("Done!");
-                        Log.Information("");
-                    }
-                    else
-                    {
-                        Log.Information("");
-                        Log.Information("nuget CLI executed with {ExitCode} exit code", nugetRestore.ExitCode);
-
-                        Log.Information("{StandardError}", nugetRestore.StandardError.ReadToEnd());
-
-                        return false;
-                    }
-                }
-            }
-
-            Log.Information("");
-            Log.Information("Updating .NET nanoFramework references using nuget CLI");
-
-            // run nuget CLI to perform update
-            using var nugetUpdate = new Process
-            {
-                StartInfo = new ProcessStartInfo
-                {
-                    FileName = Path.Combine(rootDir, ".tools/NuGet.exe"),
-                    Arguments = $"update {path}\\UnitsNet.nanoFramework.sln -PreRelease",
-                    UseShellExecute = false,
-                    CreateNoWindow = true,
-                    RedirectStandardError = true
-                }
-            };
-
-            // start nuget CLI and wait for exit
-            if (!nugetUpdate.Start())
-            {
-                Log.Information("");
-                Log.Information("Failed to start nuget CLI to update .NET nanoFramework projects");
-                Log.Information("");
-            }
-            else
-            {
-                // wait for exit, within 2 minutes
-                if (!nugetUpdate.WaitForExit((int)TimeSpan.FromMinutes(2).TotalMilliseconds))
-                {
-                    Log.Information("");
-                    Log.Information("Failed to complete execution of nuget CLI to update .NET nanoFramework projects");
-                    Log.Information("");
-                }
-                else
-                {
-                    if (nugetUpdate.ExitCode == 0)
-                    {
-                        Log.Information("Done!");
-                        Log.Information("");
-
-                        Log.Information("Updating .NET nanoFramework nuspec files");
-                        Log.Information("");
-
-                        foreach (Quantity quantity in quantities)
-                        {
-                            var projectPath = Path.Combine(path, quantity.Name);
-
-                            // read packages.config content
-                            var packagesConfig = Path.Combine(projectPath, "packages.config");
-                            var packagesConfigText = File.ReadAllText(packagesConfig);
-
-                            var mscorlibVersion = ParseVersion(packagesConfigText,
-                                new Regex("CoreLibrary\\\" version=\\\"(?<version>.+)\\\" targetFramework", RegexOptions.IgnoreCase),
-                                "projectVersion");
-
-                            // don't throw on failure because not all packages have System.Math
-                            var mathVersion = ParseVersion(packagesConfigText,
-                                new Regex("Math\\\" version=\\\"(?<version>.+)\\\" targetFramework", RegexOptions.IgnoreCase),
-                                "projectVersion",
-                                false);
-
-                            // update nuspec
-                            GenerateNuspec(
-                                projectPath,
-                                quantity,
-                                mscorlibVersion,
-                                mathVersion);
-
-                            Log.Information("✅ {Quantity} (nanoFramework)", quantity.Name);
-                        }
-                    }
-                    else
-                    {
-                        Log.Information("");
-                        Log.Information("nuget CLI executed with {ExitCode} exit code", nugetUpdate.ExitCode);
-
-                        Log.Information("{StandardError}", nugetUpdate.StandardError.ReadToEnd());
-
-                        return false;
-                    }
-                }
-
-            }
-
-            Log.Information("");
-
-            return true;
-        }
-
-        private static NanoFrameworkVersions ParseCurrentNanoFrameworkVersions(string rootDir)
-        {
-            // Angle has both mscorlib and System.Math dependency
-            var generatedCodePath = Path.Combine(rootDir, "UnitsNet.NanoFramework", "GeneratedCode");
-            var angleProjectFile = Path.Combine(generatedCodePath, "Angle", "Angle.nfproj");
-            var projectFileContent = File.ReadAllText(angleProjectFile);
-
-            // <Reference Include="mscorlib, Version=1.10.5.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-            var mscorlibVersion = ParseVersion(projectFileContent,
-                new Regex(@"<Reference Include=""mscorlib,\s*Version=(?<version>[\d\.]+),.*"">", RegexOptions.IgnoreCase),
-                "mscorlib assembly version");
-
-            // <HintPath>..\packages\nanoFramework.CoreLibrary.1.10.5-preview.18\lib\mscorlib.dll</HintPath>
-            var mscorlibNuGetVersion = ParseVersion(projectFileContent,
-                new Regex(@"<HintPath>.*[\\\/]nanoFramework\.CoreLibrary\.(?<version>.*?)[\\\/]lib[\\\/]mscorlib.dll<", RegexOptions.IgnoreCase),
-                "nanoFramework.CoreLibrary nuget version");
-
-            // <Reference Include="System.Math, Version=1.4.1.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-            var mathVersion = ParseVersion(projectFileContent,
-                new Regex(@"<Reference Include=""System.Math,\s*Version=(?<version>[\d\.]+),.*"">", RegexOptions.IgnoreCase),
-                "System.Math assembly version");
-
-            //   <HintPath>..\packages\nanoFramework.System.Math.1.4.1-preview.7\lib\System.Math.dll</HintPath>
-            var mathNuGetVersion = ParseVersion(projectFileContent,
-                new Regex(@"<HintPath>.*[\\\/]nanoFramework\.System\.Math\.(?<version>.*?)[\\\/]lib[\\\/]System.Math.dll<", RegexOptions.IgnoreCase),
-                "nanoFramework.System.Math nuget version");
-
-            return new NanoFrameworkVersions(mscorlibVersion, mscorlibNuGetVersion, mathVersion, mathNuGetVersion);
-        }
-
-        private static string ParseVersion(
-            string projectFileContent,
-            Regex versionRegex,
-            string descriptiveName,
-            bool throwOnFailure = true)
-        {
-            Match match = versionRegex.Match(projectFileContent);
-
-            if (!match.Success && throwOnFailure)
-            {
-                throw new InvalidOperationException($"Unable to parse version {descriptiveName} from project file.");
-            }
-
-            return match.Groups["version"].Value;
-        }
-
-        private static void GeneratePackageConfig(
-            string projectPath,
-            string quantityName,
-            string mscorlibNuGetVersion,
-            string mathNuGetVersion)
-        {
-            var filePath = Path.Combine(projectPath, "packages.config");
-            var content = GeneratePackageConfigFile(quantityName, mscorlibNuGetVersion, mathNuGetVersion);
-
-            File.WriteAllText(filePath, content);
-        }
-
-        private static void GenerateNuspec(
-            string projectPath,
-            Quantity quantity,
-            string mscorlibNuGetVersion,
-            string mathNuGetVersion)
-        {
-            var filePath = Path.Combine(projectPath, $"UnitsNet.NanoFramework.{quantity.Name}.nuspec");
-
-            var content = new NuspecGenerator(
-                quantity,
-                mscorlibNuGetVersion,
-                mathNuGetVersion).Generate();
-
-            File.WriteAllText(filePath, content);
-        }
-
-        private static void GenerateProperties(string filePath, string version)
-        {
-            var content = new PropertyGenerator(version).Generate();
-            File.WriteAllText(filePath, content);
-            Log.Information("✅ AssemblyInfo.cs (nanoFramework)");
-        }
-
-        private static void GenerateUnitType(Quantity quantity, string filePath, UnitEnumNameToValue unitEnumValues)
-        {
-            var content = new UnitTypeGenerator(quantity, unitEnumValues).Generate();
-            File.WriteAllText(filePath, content);
-        }
-
-        private static void GenerateQuantity(Quantity quantity, string filePath)
-        {
-            var content = new QuantityGenerator(quantity).Generate();
-            // Replace any Math.PI by the real number 3.1415926535897931
-            content = content.Replace("Math.PI", "3.1415926535897931");
-            // Replace Math.Pow(0.3048, 4) by 0.0086309748412416
-            content = content.Replace("Math.Pow(0.3048, 4)", "0.0086309748412416");
-            // Replace Math.Pow(2.54e-2, 4) by 0.0000004162314256
-            content = content.Replace("Math.Pow(2.54e-2, 4)", "0.0000004162314256");
-            File.WriteAllText(filePath, content);
-        }
-
-        private static void GenerateProject(Quantity quantity, string filePath, NanoFrameworkVersions versions)
-        {
-            var content = new ProjectGenerator(quantity, versions).Generate();
-            File.WriteAllText(filePath, content);
-        }
-
-        private static void GenerateSolution(Quantity[] quantities, string outputDir)
-        {
-            var content = new SolutionGenerator(quantities).Generate();
-            var filePath = Path.Combine(outputDir, "UnitsNet.nanoFramework.sln");
-
-            File.WriteAllText(filePath, content);
-            Log.Information("✅ UnitsNet.nanoFramework.sln (nanoFramework)");
-        }
-
-        private static string GeneratePackageConfigFile(
-            string quantityName,
-            string mscorlibNuGetVersion,
-            string mathNuGetVersion)
-        {
-            MyTextWriter writer = new();
-
-            writer.WL($@"
-<?xml version=""1.0"" encoding=""utf-8""?>
-<packages>
-  <package id=""nanoFramework.CoreLibrary"" version=""{mscorlibNuGetVersion}"" targetFramework=""netnanoframework10"" />");
-
-            if (ProjectsRequiringMath.Contains(quantityName))
-            {
-                writer.WL($@"
-  <package id=""nanoFramework.System.Math"" version=""{mathNuGetVersion}"" targetFramework=""netnanoframework10"" />");
-            }
-
-            writer.WL($@"</packages>");
-
-            return writer.ToString();
-        }
-    }
-}
diff --git a/CodeGen/Generators/NanoFrameworkVersions.cs b/CodeGen/Generators/NanoFrameworkVersions.cs
deleted file mode 100644
index c9da440cf1..0000000000
--- a/CodeGen/Generators/NanoFrameworkVersions.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-namespace CodeGen.Generators
-{
-    /// <summary>
-    /// NanoFramework dependency versions.
-    /// </summary>
-    /// <param name="MscorlibVersion">mscorlib assembly version in nanoFramework.CoreLibrary nuget.</param>
-    /// <param name="MscorlibNugetVersion">Nuget version of nanoFramework.CoreLibrary.</param>
-    /// <param name="MathVersion">System.Math assembly version in nanoFramework.System.Math nuget.</param>
-    /// <param name="MathNugetVersion">Nuget version of nanoFramework.System.Math.</param>
-    public record NanoFrameworkVersions(string MscorlibVersion, string MscorlibNugetVersion, string MathVersion, string MathNugetVersion);
-}
diff --git a/CodeGen/Generators/QuantityJsonFilesParser.cs b/CodeGen/Generators/QuantityJsonFilesParser.cs
index e1d50871a7..d6c503fd5c 100644
--- a/CodeGen/Generators/QuantityJsonFilesParser.cs
+++ b/CodeGen/Generators/QuantityJsonFilesParser.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -6,6 +6,7 @@
 using System.IO;
 using System.Linq;
 using CodeGen.Exceptions;
+using CodeGen.Helpers;
 using CodeGen.Helpers.PrefixBuilder;
 using CodeGen.JsonTypes;
 using Newtonsoft.Json;
@@ -16,7 +17,7 @@ namespace CodeGen.Generators;
 /// <summary>
 ///     Parses JSON files that define quantities and their units.
 ///     This will later be used to generate source code and can be reused for different targets such as .NET framework,
-///     .NET Core, .NET nanoFramework and even other programming languages.
+///     .NET Core and even other programming languages.
 /// </summary>
 internal static class QuantityJsonFilesParser
 {
@@ -54,7 +55,7 @@ private static Quantity ParseQuantity(string jsonFileName)
     {
         try
         {
-            return JsonConvert.DeserializeObject<Quantity>(File.ReadAllText(jsonFileName), JsonSerializerSettings)
+            return JsonConvert.DeserializeObject<Quantity>(CodeGenFile.ReadAllText(jsonFileName), JsonSerializerSettings)
                    ?? throw new UnitsNetCodeGenException($"Unable to parse quantity from JSON file: {jsonFileName}");
         }
         catch (Exception e)
diff --git a/CodeGen/Generators/QuantityRelationsParser.cs b/CodeGen/Generators/QuantityRelationsParser.cs
index 401c7e7b10..658964e2c1 100644
--- a/CodeGen/Generators/QuantityRelationsParser.cs
+++ b/CodeGen/Generators/QuantityRelationsParser.cs
@@ -1,11 +1,13 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
 using CodeGen.Exceptions;
+using CodeGen.Helpers;
 using CodeGen.JsonTypes;
 using Newtonsoft.Json;
 
@@ -24,7 +26,7 @@ internal static class QuantityRelationsParser
         ///     Each defined relation can be applied multiple times to one or two quantities depending on the operator and the operands.
         ///
         ///     The format of a relation definition is "Quantity.Unit operator Quantity.Unit = Quantity.Unit" (See examples below).
-        ///     "double" can be used as a unitless operand.
+        ///     "QuantityValue" can be used as a unitless operand.
         ///     "1" can be used as the result operand to define inverse relations.
         ///
         ///     Division relations are inferred from multiplication relations,
@@ -43,9 +45,9 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities)
         {
             var quantityDictionary = quantities.ToDictionary(q => q.Name, q => q);
 
-            // Add double and 1 as pseudo-quantities to validate relations that use them.
+            // Add QuantityValue and 1 as pseudo-quantities to validate relations that use them.
             var pseudoQuantity = new Quantity { Name = null!, Units = [new Unit { SingularName = null! }] };
-            quantityDictionary["double"] = pseudoQuantity with { Name = "double" };
+            quantityDictionary["QuantityValue"] = pseudoQuantity with { Name = "QuantityValue" };
             quantityDictionary["1"] = pseudoQuantity with { Name = "1" };
 
             var relations = ParseRelations(rootDir, quantityDictionary);
@@ -61,7 +63,7 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities)
                     RightUnit = r.LeftUnit,
                 })
                 .ToList());
-            
+
             // We can infer division relations from multiplication relations.
             relations.AddRange(relations
                 .Where(r => r is { Operator: "*", NoInferredDivision: false })
@@ -91,7 +93,7 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities)
                 var list = string.Join("\n  ", duplicates);
                 throw new UnitsNetCodeGenException($"Duplicate inferred relations:\n  {list}");
             }
-            
+
             var ambiguous = relations
                 .GroupBy(r => $"{r.LeftQuantity.Name} {r.Operator} {r.RightQuantity.Name}")
                 .Where(g => g.Count() > 1)
@@ -115,9 +117,9 @@ public static void ParseAndApplyRelations(string rootDir, Quantity[] quantities)
                         // The left operand of a relation is responsible for generating the operator.
                         quantityRelations.Add(relation);
                     }
-                    else if (relation.RightQuantity == quantity && relation.LeftQuantity.Name is "double")
+                    else if (relation.RightQuantity == quantity && relation.LeftQuantity.Name is "QuantityValue")
                     {
-                        // Because we cannot add operators to double we make the right operand responsible in this case.
+                        // Because we cannot add operators to QuantityValue we make the right operand responsible in this case.
                         quantityRelations.Add(relation);
                     }
                 }
@@ -132,13 +134,16 @@ private static List<QuantityRelation> ParseRelations(string rootDir, IReadOnlyDi
 
             try
             {
-                var text = File.ReadAllText(relationsFileName);
-                var relationStrings = JsonConvert.DeserializeObject<SortedSet<string>>(text) ?? [];
+                var text = CodeGenFile.ReadAllText(relationsFileName);
+
+                // Explicitly sort to keep the file consistent.
+                var relationStrings = JsonConvert.DeserializeObject<List<string>>(text)
+                    ?.ToImmutableSortedSet(StringComparer.OrdinalIgnoreCase) ?? [];
 
                 var parsedRelations = relationStrings.Select(relationString => ParseRelation(relationString, quantities)).ToList();
 
                 // File parsed successfully, save it back to disk in the sorted state.
-                File.WriteAllText(relationsFileName, JsonConvert.SerializeObject(relationStrings, Formatting.Indented));
+                CodeGenFile.WriteAllText(relationsFileName, JsonConvert.SerializeObject(relationStrings, Formatting.Indented));
 
                 return parsedRelations;
             }
@@ -210,4 +215,4 @@ Unit GetUnit(Quantity quantity, string? unitName)
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/CodeGen/Generators/UnitsNetGen/IQuantityTestClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/IQuantityTestClassGenerator.cs
index 43616e03f6..2786525dcb 100644
--- a/CodeGen/Generators/UnitsNetGen/IQuantityTestClassGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/IQuantityTestClassGenerator.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Diagnostics.CodeAnalysis;
diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14Generator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14Generator.cs
index f815158c3a..b7ac802211 100644
--- a/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14Generator.cs
+++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14Generator.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using CodeGen.JsonTypes;
 
 namespace CodeGen.Generators.UnitsNetGen
@@ -53,16 +53,16 @@ public static class NumberTo{_quantityName}Extensions
                     continue;
 
                 Writer.WL(3, $@"
-/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(double)"" />");
+/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(QuantityValue)"" />");
 
                 // Include obsolete text from the quantity per extension method, to make it visible when the class is not explicitly referenced in code.
                 Writer.WLIfText(3, GetObsoleteAttributeOrNull(unit.ObsoleteText ?? _quantity.ObsoleteText));
 
                 Writer.WL(3, $@"public {_quantityName} {unit.PluralName}
 #if NET7_0_OR_GREATER
-                => {_quantityName}.From{unit.PluralName}(double.CreateChecked(value));
+                => {_quantityName}.From{unit.PluralName}(QuantityValue.CreateChecked(value));
 #else
-                => {_quantityName}.From{unit.PluralName}(value.ToDouble(null));
+                => {_quantityName}.From{unit.PluralName}(value.ToQuantityValue());
 #endif
 ");
             }
diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14TestClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14TestClassGenerator.cs
index d3573fcaf5..ead5a22148 100644
--- a/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14TestClassGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14TestClassGenerator.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using CodeGen.JsonTypes;
 
 namespace CodeGen.Generators.UnitsNetGen
diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
index 4765e49d9e..74a57acc1e 100644
--- a/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using CodeGen.JsonTypes;
 
 namespace CodeGen.Generators.UnitsNetGen
@@ -40,7 +40,7 @@ public static class NumberTo{_quantityName}Extensions
                     continue;
 
                 Writer.WL(2, $@"
-/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(double)"" />");
+/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(QuantityValue)"" />");
 
                 // Include obsolete text from the quantity per extension method, to make it visible when the class is not explicitly referenced in code.
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText ?? _quantity.ObsoleteText));
@@ -49,10 +49,10 @@ public static class NumberTo{_quantityName}Extensions
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => {_quantityName}.From{unit.PluralName}(double.CreateChecked(value));
+            => {_quantityName}.From{unit.PluralName}(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => {_quantityName}.From{unit.PluralName}(value.ToDouble(null));
+            => {_quantityName}.From{unit.PluralName}(value.ToQuantityValue());
 #endif
 ");
             }
diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs
index b5cced30fd..6d64a410fc 100644
--- a/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using CodeGen.JsonTypes;
 
 namespace CodeGen.Generators.UnitsNetGen
diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
index dfaa53af3d..985a8f5ebb 100644
--- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
@@ -1,10 +1,13 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
 using System.Linq;
 using CodeGen.Helpers;
+using CodeGen.Helpers.ExpressionAnalyzer;
+using CodeGen.Helpers.ExpressionAnalyzer.Expressions;
 using CodeGen.JsonTypes;
+using Fractions;
 
 namespace CodeGen.Generators.UnitsNetGen
 {
@@ -34,13 +37,10 @@ public string Generate()
         {
             Writer.WL(GeneratedFileHeader);
             Writer.WL(@"
-
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -62,7 +62,8 @@ namespace UnitsNet
             Writer.WLIfText(1, GetObsoleteAttributeOrNull(_quantity));
             Writer.WL(@$"
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct {_quantity.Name} :");
             GenerateInterfaceExtensions();
 
@@ -72,7 +73,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = ""Value"", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -92,7 +93,6 @@ namespace UnitsNet
             GenerateArithmeticOperators();
             GenerateRelationalOperators();
             GenerateEqualityAndComparison();
-            GenerateConversionMethods();
             GenerateToString();
 
             Writer.WL($@"
@@ -103,21 +103,21 @@ namespace UnitsNet
 
         private void GenerateInterfaceExtensions()
         {
-            // generate the base interface (either IVectorQuantity, IAffineQuantity or ILogarithmicQuantity)
+            // generate ILogarithmicQuantity, IAffineQuantity or ILinearQuantity
             if (_quantity.Logarithmic)
             {
-                Writer.WL(@$"
+                Writer.WL($@"
         ILogarithmicQuantity<{_quantity.Name}, {_unitEnumName}>,");
             }
             else if (!string.IsNullOrEmpty(_quantity.AffineOffsetType))
             {
-                Writer.WL(@$"
+                Writer.WL($@"
         IAffineQuantity<{_quantity.Name}, {_unitEnumName}, {_quantity.AffineOffsetType}>,");
             }
-            else // the default quantity type implements the IVectorQuantity interface
+            else // the default quantity type implements the ILinearQuantity interface
             {
-                Writer.WL(@$"
-        IArithmeticQuantity<{_quantity.Name}, {_unitEnumName}>,");
+                Writer.WL($@"
+        ILinearQuantity<{_quantity.Name}, {_unitEnumName}>,");
             }
 
             Writer.WL(@"
@@ -125,7 +125,7 @@ private void GenerateInterfaceExtensions()
             if (!_quantity.IsAffine)
             {
                 Writer.WL($@"
-        IDivisionOperators<{_quantity.Name}, {_quantity.Name}, double>,");
+        IDivisionOperators<{_quantity.Name}, {_quantity.Name}, QuantityValue>,");
             }
 
             if (_quantity.Relations.Any(r => r.Operator is "*" or "/"))
@@ -252,8 +252,35 @@ public sealed class {quantityInfoClassName}: QuantityInfo<{_quantity.Name}, {_un
                         }.Where(str => str != null))})";
                 }
 
-                Writer.WL($@"
+                // the UnitInfo constructor has 3 overloads:
+                // - one for the base unit without conversion expressions
+                // - one for units with only FromBaseToUnit conversion expression (with the FromUnitToBase expression assumed to be the inverse)
+                // - one for units with both FromBaseToUnit and FromUnitToBase conversion expressions (required when the conversion is not a simple inverse, e.g. affine conversions)
+                if (unit.SingularName == _quantity.BaseUnit)
+                {
+                    Writer.WL($@"
                 yield return new ({_unitEnumName}.{unit.SingularName}, ""{unit.SingularName}"", ""{unit.PluralName}"", {baseUnitsFormat});");
+                }
+                else
+                {
+                    CompositeExpression expressionFromBaseToUnit = ExpressionEvaluator.Evaluate(unit.FromBaseToUnitFunc, "{x}");
+                    // Check if FromUnitToBase is simply the inverse of FromBaseToUnit
+                    if (expressionFromBaseToUnit.Terms.Count == 1 && expressionFromBaseToUnit.Degree == Fraction.One)
+                    {
+                        Writer.WL($@"
+                yield return new ({_unitEnumName}.{unit.SingularName}, ""{unit.SingularName}"", ""{unit.PluralName}"", {baseUnitsFormat},
+                     {expressionFromBaseToUnit.GetConversionExpressionFormat()}
+                );");
+                    }
+                    else
+                    {
+                        Writer.WL($@"
+                yield return new ({_unitEnumName}.{unit.SingularName}, ""{unit.SingularName}"", ""{unit.PluralName}"", {baseUnitsFormat},
+                     {expressionFromBaseToUnit.GetConversionExpressionFormat()},
+                     {unit.GetUnitToBaseConversionExpressionFormat()}
+                );");
+                    }
+                }
             }
 
             Writer.WL($@"
@@ -268,9 +295,7 @@ private void GenerateStaticConstructor()
         static {_quantity.Name}()
         {{");
             Writer.WL($@"
-            Info = {_quantity.Name}Info.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo({_quantity.Name}Info.CreateDefault);
         }}
 ");
         }
@@ -283,7 +308,7 @@ private void GenerateInstanceConstructors()
         /// </summary>
         /// <param name=""value"">The numeric value to construct this quantity with.</param>
         /// <param name=""unit"">The unit representation to construct this quantity with.</param>
-        public {_quantity.Name}(double value, {_unitEnumName} unit)
+        public {_quantity.Name}(QuantityValue value, {_unitEnumName} unit)
         {{");
             Writer.WL(@"
             _value = value;");
@@ -302,7 +327,7 @@ private void GenerateInstanceConstructors()
         /// <param name=""unitSystem"">The unit system to create the quantity with.</param>
         /// <exception cref=""ArgumentNullException"">The given <see cref=""UnitSystem""/> is null.</exception>
         /// <exception cref=""ArgumentException"">No unit was found for the given <see cref=""UnitSystem""/>.</exception>
-        public {_quantity.Name}(double value, UnitSystem unitSystem)
+        public {_quantity.Name}(QuantityValue value, UnitSystem unitSystem)
         {{
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -319,7 +344,8 @@ private void GenerateStaticProperties()
         /// <summary>
         ///     The <see cref=""UnitConverter"" /> containing the default generated conversion functions for <see cref=""{_quantity.Name}"" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions {{ get; }}
+        [Obsolete(""Replaced by UnitConverter.Default"")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref=""IQuantity.QuantityInfo""/>
         public static QuantityInfo<{_quantity.Name}, {_unitEnumName}> Info {{ get; }}
@@ -349,7 +375,7 @@ private void GenerateStaticProperties()
             {
                 Writer.WL($@"
         /// <inheritdoc />
-        public static double LogarithmicScalingFactor {{get;}} = {10 * _quantity.LogarithmicScalingFactor};
+        public static QuantityValue LogarithmicScalingFactor {{get;}} = {10 * _quantity.LogarithmicScalingFactor};
 ");
             }
 
@@ -363,10 +389,8 @@ private void GenerateProperties()
             Writer.WL($@"
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public {_unitEnumName} Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -397,7 +421,7 @@ private void GenerateProperties()
             {
                 Writer.WL($@"
 #if NETSTANDARD2_0
-        double ILogarithmicQuantity<{_quantity.Name}>.LogarithmicScalingFactor => LogarithmicScalingFactor;
+        QuantityValue ILogarithmicQuantity<{_quantity.Name}>.LogarithmicScalingFactor => LogarithmicScalingFactor;
 #endif
 ");
             }
@@ -420,11 +444,11 @@ private void GenerateConversionProperties()
 
                 Writer.WL($@"
         /// <summary>
-        ///     Gets a <see cref=""double""/> value of this quantity converted into <see cref=""{_unitEnumName}.{unit.SingularName}""/>
+        ///     Gets a <see cref=""QuantityValue""/> value of this quantity converted into <see cref=""{_unitEnumName}.{unit.SingularName}""/>
         /// </summary>");
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
                 Writer.WL($@"
-        public double {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
+        public QuantityValue {unit.PluralName} => this.As({_unitEnumName}.{unit.SingularName});
 ");
             }
 
@@ -440,41 +464,6 @@ private void GenerateStaticMethods()
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref=""UnitConverter""/> instance.
-        /// </summary>
-        /// <param name=""unitConverter"">The <see cref=""UnitConverter""/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {{
-            // Register in unit converter: {_unitEnumName} -> BaseUnit");
-
-            foreach (Unit unit in _quantity.Units)
-            {
-                if (unit.SingularName == _quantity.BaseUnit) continue;
-
-                Writer.WL($@"
-            unitConverter.SetConversionFunction<{_quantity.Name}>({_unitEnumName}.{unit.SingularName}, {_unitEnumName}.{_quantity.BaseUnit}, quantity => quantity.ToUnit({_unitEnumName}.{_quantity.BaseUnit}));");
-            }
-
-            Writer.WL();
-            Writer.WL($@"
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<{_quantity.Name}>({_unitEnumName}.{_quantity.BaseUnit}, {_unitEnumName}.{_quantity.BaseUnit}, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> {_unitEnumName}");
-
-            foreach (Unit unit in _quantity.Units)
-            {
-                if (unit.SingularName == _quantity.BaseUnit) continue;
-
-                Writer.WL($@"
-            unitConverter.SetConversionFunction<{_quantity.Name}>({_unitEnumName}.{_quantity.BaseUnit}, {_unitEnumName}.{unit.SingularName}, quantity => quantity.ToUnit({_unitEnumName}.{unit.SingularName}));");
-            }
-
-            Writer.WL($@"
-        }}
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -515,7 +504,7 @@ private void GenerateStaticFactoryMethods()
         /// </summary>");
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
                 Writer.WL($@"
-        public static {_quantity.Name} From{unit.PluralName}(double value)
+        public static {_quantity.Name} From{unit.PluralName}(QuantityValue value)
         {{
             return new {_quantity.Name}(value, {_unitEnumName}.{unit.SingularName});
         }}
@@ -529,7 +518,7 @@ private void GenerateStaticFactoryMethods()
         /// <param name=""value"">Value to convert from.</param>
         /// <param name=""fromUnit"">Unit to convert from.</param>
         /// <returns>{_quantity.Name} unit value.</returns>
-        public static {_quantity.Name} From(double value, {_unitEnumName} fromUnit)
+        public static {_quantity.Name} From(QuantityValue value, {_unitEnumName} fromUnit)
         {{
             return new {_quantity.Name}(value, fromUnit);
         }}
@@ -595,10 +584,7 @@ private void GenerateStaticParseMethods()
         /// <param name=""provider"">Format to use when parsing number and unit. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
         public static {_quantity.Name} Parse(string str, IFormatProvider? provider)
         {{
-            return UnitsNetSetup.Default.QuantityParser.Parse<{_quantity.Name}, {_unitEnumName}>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<{_quantity.Name}, {_unitEnumName}>(str, provider, From);
         }}
 
         /// <summary>
@@ -626,11 +612,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out {_quantity.Name}
         /// <param name=""provider"">Format to use when parsing number and unit. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out {_quantity.Name} result)
         {{
-            return UnitsNetSetup.Default.QuantityParser.TryParse<{_quantity.Name}, {_unitEnumName}>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<{_quantity.Name}, {_unitEnumName}>(str, provider, From, out result);
         }}
 
         /// <summary>
@@ -651,7 +633,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? pro
         ///     Parse a unit string.
         /// </summary>
         /// <param name=""str"">String to parse. Typically in the form: {{number}} {{unit}}</param>
-        /// <param name=""provider"">Format to use when parsing number and unit. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
+        /// <param name=""provider"">Format to use when parsing the unit. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit(""m"", CultureInfo.GetCultureInfo(""en-US""));
         /// </example>
@@ -662,7 +644,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }}
 
-        /// <inheritdoc cref=""TryParseUnit(string,IFormatProvider,out UnitsNet.Units.{_unitEnumName})""/>
+        /// <inheritdoc cref=""TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.{_unitEnumName})""/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out {_unitEnumName} unit)
         {{
             return TryParseUnit(str, null, out unit);
@@ -677,7 +659,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out {_unitEnumNa
         /// <example>
         ///     Length.TryParseUnit(""m"", CultureInfo.GetCultureInfo(""en-US""));
         /// </example>
-        /// <param name=""provider"">Format to use when parsing number and unit. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
+        /// <param name=""provider"">Format to use when parsing the unit. Defaults to <see cref=""CultureInfo.CurrentCulture"" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out {_unitEnumName} unit)
         {{
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -715,35 +697,35 @@ private void GenerateArithmeticOperators()
         /// <summary>Get <see cref=""{_quantity.Name}""/> from adding two <see cref=""{_quantity.Name}""/>.</summary>
         public static {_quantity.Name} operator +({_quantity.Name} left, {_quantity.Name} right)
         {{
-            return new {_quantity.Name}(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new {_quantity.Name}(left.Value + right.As(left.Unit), left.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from subtracting two <see cref=""{_quantity.Name}""/>.</summary>
         public static {_quantity.Name} operator -({_quantity.Name} left, {_quantity.Name} right)
         {{
-            return new {_quantity.Name}(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new {_quantity.Name}(left.Value - right.As(left.Unit), left.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from multiplying value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *(double left, {_quantity.Name} right)
+        public static {_quantity.Name} operator *(QuantityValue left, {_quantity.Name} right)
         {{
             return new {_quantity.Name}(left * right.Value, right.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from multiplying value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *({_quantity.Name} left, double right)
+        public static {_quantity.Name} operator *({_quantity.Name} left, QuantityValue right)
         {{
             return new {_quantity.Name}(left.Value * right, left.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from dividing <see cref=""{_quantity.Name}""/> by value.</summary>
-        public static {_quantity.Name} operator /({_quantity.Name} left, double right)
+        public static {_quantity.Name} operator /({_quantity.Name} left, QuantityValue right)
         {{
             return new {_quantity.Name}(left.Value / right, left.Unit);
         }}
 
         /// <summary>Get ratio value from dividing <see cref=""{_quantity.Name}""/> by <see cref=""{_quantity.Name}""/>.</summary>
-        public static double operator /({_quantity.Name} left, {_quantity.Name} right)
+        public static QuantityValue operator /({_quantity.Name} left, {_quantity.Name} right)
         {{
             return left.{_baseUnit.PluralName} / right.{_baseUnit.PluralName};
         }}
@@ -754,60 +736,56 @@ private void GenerateArithmeticOperators()
 
         private void GenerateLogarithmicArithmeticOperators()
         {
-            var scalingFactor = _quantity.LogarithmicScalingFactor;
             // Most logarithmic operators need a simple scaling factor of 10. However, certain units such as voltage ratio need to use 20 instead.
-            var x = (10 * scalingFactor).ToString();
             Writer.WL($@"
         #region Logarithmic Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static {_quantity.Name} operator -({_quantity.Name} right)
+        public static {_quantity.Name} operator -({_quantity.Name} quantity)
         {{
-            return new {_quantity.Name}(-right.Value, right.Unit);
+            return new {_quantity.Name}(-quantity.Value, quantity.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic addition of two <see cref=""{_quantity.Name}""/>.</summary>
+        /// <remarks>This operation involves a conversion of the values to linear space, which is not guaranteed to produce an exact value.
+        /// <para>The final result is rounded to 15 significant digits.</para>
+        /// </remarks>
         public static {_quantity.Name} operator +({_quantity.Name} left, {_quantity.Name} right)
         {{
-            // Logarithmic addition
-            // Formula: {x} * log10(10^(x/{x}) + 10^(y/{x}))
-            return new {_quantity.Name}({x} * Math.Log10(Math.Pow(10, left.Value / {x}) + Math.Pow(10, right.ToUnit(left.Unit).Value / {x})), left.Unit);
+            return new {_quantity.Name}(QuantityValueExtensions.AddWithLogScaling(left.Value, right.As(left.Unit), LogarithmicScalingFactor), left.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic subtraction of two <see cref=""{_quantity.Name}""/>.</summary>
+        /// <remarks>This operation involves a conversion of the values to linear space, which is not guaranteed to produce an exact value.
+        /// <para>The final result is rounded to 15 significant digits.</para>
+        /// </remarks>
         public static {_quantity.Name} operator -({_quantity.Name} left, {_quantity.Name} right)
         {{
-            // Logarithmic subtraction
-            // Formula: {x} * log10(10^(x/{x}) - 10^(y/{x}))
-            return new {_quantity.Name}({x} * Math.Log10(Math.Pow(10, left.Value / {x}) - Math.Pow(10, right.ToUnit(left.Unit).Value / {x})), left.Unit);
+            return new {_quantity.Name}(QuantityValueExtensions.SubtractWithLogScaling(left.Value, right.As(left.Unit), LogarithmicScalingFactor), left.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic multiplication of value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *(double left, {_quantity.Name} right)
+        public static {_quantity.Name} operator *(QuantityValue left, {_quantity.Name} right)
         {{
-            // Logarithmic multiplication = addition
             return new {_quantity.Name}(left + right.Value, right.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic multiplication of value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *({_quantity.Name} left, double right)
+        public static {_quantity.Name} operator *({_quantity.Name} left, QuantityValue right)
         {{
-            // Logarithmic multiplication = addition
             return new {_quantity.Name}(left.Value + right, left.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic division of <see cref=""{_quantity.Name}""/> by value.</summary>
-        public static {_quantity.Name} operator /({_quantity.Name} left, double right)
+        public static {_quantity.Name} operator /({_quantity.Name} left, QuantityValue right)
         {{
-            // Logarithmic division = subtraction
             return new {_quantity.Name}(left.Value - right, left.Unit);
         }}
 
         /// <summary>Get ratio value from logarithmic division of <see cref=""{_quantity.Name}""/> by <see cref=""{_quantity.Name}""/>.</summary>
-        public static double operator /({_quantity.Name} left, {_quantity.Name} right)
+        public static QuantityValue operator /({_quantity.Name} left, {_quantity.Name} right)
         {{
-            // Logarithmic division = subtraction
-            return Convert.ToDouble(left.Value - right.ToUnit(left.Unit).Value);
+            return left.Value - right.As(left.Unit);
         }}
 
         #endregion
@@ -815,11 +793,16 @@ private void GenerateLogarithmicArithmeticOperators()
         }
 
         /// <summary>
-        ///     Generates operators that express relations between quantities as applied by <see cref="QuantityRelationsParser" />.
+        ///     Generates relational operators for quantities based on their defined relations.
         /// </summary>
-        private void GenerateRelationalOperators()
+        /// <param name="inverseWithFixedUnit">
+        ///     Specifies whether inverse relational operators should be generated as implicit conversions or simply using the unit specified in the UnitRelations.
+        ///     If <c>true</c>, the method generates inverse operators that convert to a fixed unit, as specified in the UnitRelations.
+        ///     If <c>false</c>, the method generates inverse operators as implicit conversions that utilize the UnitConverter for conversion.
+        /// </param>
+        private void GenerateRelationalOperators(bool inverseWithFixedUnit = false)
         {
-            if (!_quantity.Relations.Any()) return;
+            if (_quantity.Relations.Length == 0) return;
 
             Writer.WL($@"
         #region Relational Operators
@@ -829,51 +812,64 @@ private void GenerateRelationalOperators()
             {
                 if (relation.Operator == "inverse")
                 {
-                    Writer.WL($@"
+                    if (inverseWithFixedUnit)
+                    {
+                        // this was the original behavior where the inverse always used the fixed unit from the relation
+                        Writer.WL($@"
         /// <summary>Calculates the inverse of this quantity.</summary>
         /// <returns>The corresponding inverse quantity, <see cref=""{relation.RightQuantity.Name}""/>.</returns>
         public {relation.RightQuantity.Name} Inverse()
         {{
-            return {relation.RightQuantity.Name}.From{relation.RightUnit.PluralName}(1 / {relation.LeftUnit.PluralName});
+            return {relation.RightQuantity.Name}.From{relation.RightUnit.PluralName}(QuantityValue.Inverse({relation.LeftUnit.PluralName}));
         }}
 ");
+                    }
+                    else
+                    {
+                        // this is the proposed improvement where the inverse is considered a type of implicit conversion
+                        Writer.WL($@"
+        /// <summary>Calculates the inverse of this quantity.</summary>
+        /// <returns>The corresponding inverse quantity, <see cref=""{relation.RightQuantity.Name}""/>.</returns>
+        public {relation.RightQuantity.Name} Inverse()
+        {{
+            return UnitConverter.Default.ConvertTo(Value, Unit, {relation.RightQuantity.Name}.Info);
+        }}
+");
+                    }
                 }
                 else
                 {
-                    var leftParameter = relation.LeftQuantity.Name.ToCamelCase();
+                    const string valueType = "QuantityValue";
+                    var leftParameterType = relation.LeftQuantity.Name;
                     var leftConversionProperty = relation.LeftUnit.PluralName;
-                    var rightParameter = relation.RightQuantity.Name.ToCamelCase();
+                    var rightParameterType = relation.RightQuantity.Name;
                     var rightConversionProperty = relation.RightUnit.PluralName;
 
-                    if (leftParameter == rightParameter)
+                    string leftParameterName, rightParameterName;
+                    if (leftParameterType == rightParameterType)
                     {
-                        leftParameter = "left";
-                        rightParameter = "right";
+                        leftParameterName = "left";
+                        rightParameterName = "right";
                     }
-
-                    var leftPart = $"{leftParameter}.{leftConversionProperty}";
-                    var rightPart = $"{rightParameter}.{rightConversionProperty}";
-
-                    if (leftParameter is "double")
+                    else
                     {
-                        leftParameter = leftPart = "value";
-                    }
-
-                    if (rightParameter is "double")
-                    {
-                        rightParameter = rightPart = "value";
+                        leftParameterName = leftParameterType is valueType ? "value": leftParameterType.ToCamelCase();
+                        rightParameterName = rightParameterType is valueType ? "value": rightParameterType.ToCamelCase();
                     }
 
+                    var leftPart = leftParameterType is valueType ? leftParameterName : $"{leftParameterName}.{leftConversionProperty}";
+                    var rightPart = rightParameterName is valueType ? rightParameterName : $"{rightParameterName}.{rightConversionProperty}";
                     var expression = $"{leftPart} {relation.Operator} {rightPart}";
 
-                    if (relation.ResultQuantity.Name is not "double")
+                    var resultType = relation.ResultQuantity.Name;
+                    if (resultType is not valueType)
                     {
-                        expression = $"{relation.ResultQuantity.Name}.From{relation.ResultUnit.PluralName}({expression})";
+                        expression = $"{resultType}.From{relation.ResultUnit.PluralName}({expression})";
                     }
 
                     Writer.WL($@"
-        /// <summary>Get <see cref=""{relation.ResultQuantity.Name}""/> from <see cref=""{relation.LeftQuantity.Name}""/> {relation.Operator} <see cref=""{relation.RightQuantity.Name}""/>.</summary>
-        public static {relation.ResultQuantity.Name} operator {relation.Operator}({relation.LeftQuantity.Name} {leftParameter}, {relation.RightQuantity.Name} {rightParameter})
+        /// <summary>Get <see cref=""{resultType}""/> from <see cref=""{leftParameterType}""/> {relation.Operator} <see cref=""{rightParameterType}""/>.</summary>
+        public static {resultType} operator {relation.Operator}({leftParameterType} {leftParameterName}, {rightParameterType} {rightParameterName})
         {{
             return {expression};
         }}
@@ -895,97 +891,111 @@ private void GenerateEqualityAndComparison()
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=({_quantity.Name} left, {_quantity.Name} right)
         {{
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }}
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=({_quantity.Name} left, {_quantity.Name} right)
         {{
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }}
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <({_quantity.Name} left, {_quantity.Name} right)
         {{
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }}
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >({_quantity.Name} left, {_quantity.Name} right)
         {{
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }}
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref=""{_quantity.Name}""/> quantities, where both <see cref=""Value"" /> and <see cref=""Unit"" /> are exactly equal.</summary>
-        [Obsolete(""For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals({_quantity.Name} other, {_quantity.Name} tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units."")]
+        /// <summary>
+        ///     Determines whether two <see cref=""{_quantity.Name}""/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref=""Equals({_quantity.Name})""/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==({_quantity.Name} left, {_quantity.Name} right)
         {{
             return left.Equals(right);
         }}
 
-        /// <summary>Indicates strict inequality of two <see cref=""{_quantity.Name}""/> quantities, where both <see cref=""Value"" /> and <see cref=""Unit"" /> are exactly equal.</summary>
-        [Obsolete(""For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals({_quantity.Name} other, {_quantity.Name} tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units."")]
+        /// <summary>
+        ///     Determines whether two <see cref=""{_quantity.Name}""/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref=""operator ==({_quantity.Name},{_quantity.Name})""/>.
+        ///     See that operator (and <see cref=""Equals({_quantity.Name})""/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=({_quantity.Name} left, {_quantity.Name} right)
         {{
             return !(left == right);
         }}
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref=""{_quantity.Name}""/> quantities, where both <see cref=""Value"" /> and <see cref=""Unit"" /> are exactly equal.</summary>
-        [Obsolete(""Use Equals({_quantity.Name} other, {_quantity.Name} tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units."")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref=""{_quantity.Name}""/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name=""obj""/> is <c>null</c> or not a <see cref=""{_quantity.Name}""/>.
+        ///     When <paramref name=""obj""/> is a <see cref=""{_quantity.Name}""/>, this method delegates to
+        ///     <see cref=""Equals({_quantity.Name})""/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {{
-            if (obj is null || !(obj is {_quantity.Name} otherQuantity))
+            if (obj is not {_quantity.Name} otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }}
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref=""{_quantity.Name}""/> quantities, where both <see cref=""Value"" /> and <see cref=""Unit"" /> are exactly equal.</summary>
-        [Obsolete(""Use Equals({_quantity.Name} other, {_quantity.Name} tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units."")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref=""{_quantity.Name}""/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name=""other""/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals({_quantity.Name} other)
         {{
-            return new {{ Value, Unit }}.Equals(new {{ other.Value, other.Unit }});
+            return _value.Equals(other.As(this.Unit));
         }}
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current {_quantity.Name}.</returns>
         public override int GetHashCode()
         {{
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof({_quantity.Name}), this.As(BaseUnit));
         }}
 
-        /// <summary>Compares the current <see cref=""{_quantity.Name}""/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref=""CompareTo({_quantity.Name})"" />
         /// <param name=""obj"">An object to compare with this instance.</param>
         /// <exception cref=""T:System.ArgumentException"">
         ///    <paramref name=""obj"" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type=""table"">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name=""obj"" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name=""obj"" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name=""obj"" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {{
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is {_quantity.Name} otherQuantity)) throw new ArgumentException(""Expected type {_quantity.Name}."", nameof(obj));
+            if (obj is not {_quantity.Name} otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<{_quantity.Name}>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }}
 
-        /// <summary>Compares the current <see cref=""{_quantity.Name}""/> with another <see cref=""{_quantity.Name}""/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref=""{_quantity.Name}""/> with another <see cref=""{_quantity.Name}""/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name=""other"">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type=""table"">
@@ -997,162 +1007,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo({_quantity.Name} other)
         {{
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }}
-
-        #endregion
-");
-        }
-
-        private void GenerateConversionMethods()
-        {
-            Writer.WL($@"
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name=""unit"" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As({_unitEnumName} unit)
-        {{
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }}
-");
-
-            Writer.WL( $@"
-
-        /// <inheritdoc cref=""IQuantity.As(UnitKey)""/>
-        public double As(UnitKey unitKey)
-        {{
-            return As(unitKey.ToUnit<{_unitEnumName}>());
-        }}
-");
-
-            Writer.WL($@"
-        /// <summary>
-        ///     Converts this {_quantity.Name} to another {_quantity.Name} with the unit representation <paramref name=""unit"" />.
-        /// </summary>
-        /// <param name=""unit"">The unit to convert to.</param>
-        /// <returns>A {_quantity.Name} with the specified unit.</returns>
-        public {_quantity.Name} ToUnit({_unitEnumName} unit)
-        {{
-            return ToUnit(unit, DefaultConversionFunctions);
-        }}
-
-        /// <summary>
-        ///     Converts this <see cref=""{_quantity.Name}""/> to another <see cref=""{_quantity.Name}""/> using the given <paramref name=""unitConverter""/> with the unit representation <paramref name=""unit"" />.
-        /// </summary>
-        /// <param name=""unit"">The unit to convert to.</param>
-        /// <param name=""unitConverter"">The <see cref=""UnitConverter""/> to use for the conversion.</param>
-        /// <returns>A {_quantity.Name} with the specified unit.</returns>
-        public {_quantity.Name} ToUnit({_unitEnumName} unit, UnitConverter unitConverter)
-        {{
-            if (TryToUnit(unit, out var converted))
-            {{
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }}
-            else if (unitConverter.TryGetConversionFunction((typeof({_quantity.Name}), Unit, typeof({_quantity.Name}), unit), out var conversionFunction))
-            {{
-                // See if the unit converter has an extensibility conversion registered.
-                return ({_quantity.Name})conversionFunction(this);
-            }}
-            else if (Unit != BaseUnit)
-            {{
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }}
-            else
-            {{
-                // No possible conversion
-                throw new UnitNotFoundException($""Can't convert {{Unit}} to {{unit}}."");
-            }}
-        }}
-
-        /// <summary>
-        ///     Attempts to convert this <see cref=""{_quantity.Name}""/> to another <see cref=""{_quantity.Name}""/> with the unit representation <paramref name=""unit"" />.
-        /// </summary>
-        /// <param name=""unit"">The unit to convert to.</param>
-        /// <param name=""converted"">The converted <see cref=""{_quantity.Name}""/> in <paramref name=""unit""/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit({_unitEnumName} unit, [NotNullWhen(true)] out {_quantity.Name}? converted)
-        {{
-            if (Unit == unit)
-            {{
-                converted = this;
-                return true;
-            }}
-
-            {_quantity.Name}? convertedOrNull = (Unit, unit) switch
-            {{
-                // {_unitEnumName} -> BaseUnit");
-
-            foreach (Unit unit in _quantity.Units)
-            {
-                if (unit.SingularName == _quantity.BaseUnit) continue;
-
-                var func = unit.FromUnitToBaseFunc.Replace("{x}", "_value");
-                Writer.WL($@"
-                ({_unitEnumName}.{unit.SingularName}, {_unitEnumName}.{_quantity.BaseUnit}) => new {_quantity.Name}({func}, {_unitEnumName}.{_quantity.BaseUnit}),");
-            }
-
-            Writer.WL();
-            Writer.WL($@"
-
-                // BaseUnit -> {_unitEnumName}");
-            foreach(Unit unit in _quantity.Units)
-            {
-                if (unit.SingularName == _quantity.BaseUnit) continue;
-
-                var func = unit.FromBaseToUnitFunc.Replace("{x}", "_value");
-                Writer.WL($@"
-                ({_unitEnumName}.{_quantity.BaseUnit}, {_unitEnumName}.{unit.SingularName}) => new {_quantity.Name}({func}, {_unitEnumName}.{unit.SingularName}),");
-            }
-
-            Writer.WL();
-            Writer.WL($@"
-                _ => null
-            }};
-
-            if (convertedOrNull is null)
-            {{
-                converted = default;
-                return false;
-            }}
-
-            converted = convertedOrNull.Value;
-            return true;
-        }}
-");
-            Writer.WL($@"
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {{
-            if (unit is not {_unitEnumName} typedUnit)
-                throw new ArgumentException($""The given unit is of type {{unit.GetType()}}. Only {{typeof({_unitEnumName})}} is supported."", nameof(unit));
-
-            return As(typedUnit);
-        }}
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {{
-            if (!(unit is {_unitEnumName} typedUnit))
-                throw new ArgumentException($""The given unit is of type {{unit.GetType()}}. Only {{typeof({_unitEnumName})}} is supported."", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }}
 
-        /// <inheritdoc />
-        IQuantity<{_unitEnumName}> IQuantity<{_unitEnumName}>.ToUnit({_unitEnumName} unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 ");
         }
@@ -1171,11 +1028,13 @@ public override string ToString()
             return ToString(null, null);
         }}
 
-        /// <inheritdoc cref=""QuantityFormatter.Format{{TQuantity}}(TQuantity, string?, IFormatProvider?)""/>
+        /// <inheritdoc cref=""QuantityFormatter.Format{{TQuantity}}(TQuantity, string, IFormatProvider)""/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref=""CultureInfo.CurrentCulture"" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {{
             return QuantityFormatter.Default.Format(this, format, provider);
         }}
diff --git a/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs
index 64479dbfa2..b2d565a324 100644
--- a/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs
@@ -1,4 +1,6 @@
-using CodeGen.JsonTypes;
+using System.Collections.Generic;
+using System.Linq;
+using CodeGen.JsonTypes;
 
 namespace CodeGen.Generators.UnitsNetGen
 {
@@ -33,27 +35,46 @@ internal static class DefaultProvider
         /// <summary>
         ///     All QuantityInfo instances that are present in UnitsNet by default.
         /// </summary>
-        internal static IReadOnlyList<QuantityInfo> Quantities { get; } =
-        [");
+        internal static IReadOnlyList<QuantityInfo> Quantities => new QuantityInfo[]
+        {");
             foreach (var quantity in _quantities)
                 Writer.WL($@"
             {quantity.Name}.Info,");
             Writer.WL(@"
-        ];
+        };
 
-        internal static void RegisterUnitConversions(UnitConverter unitConverter)
+        /// <summary>
+        ///     All implicit quantity conversions that exist by default.
+        /// </summary>
+        internal static readonly IReadOnlyList<QuantityConversionMapping> Conversions = new QuantityConversionMapping[]
         {");
-            foreach (Quantity quantity in _quantities)
-            {
+            foreach (var quantityRelation in _quantities.SelectMany(quantity => quantity.Relations.Where(x => x.Operator == "inverse")).Distinct(new CumulativeRelationshipEqualityComparer()).OrderBy(relation => relation.LeftQuantity.Name))
                 Writer.WL($@"
-            {quantity.Name}.RegisterDefaultConversions(unitConverter);");
-            }
-
+            new (typeof({quantityRelation.LeftQuantity.Name}), typeof({quantityRelation.RightQuantity.Name})),");
             Writer.WL(@"
-        }
+        };
     }
 }");
             return Writer.ToString();
         }
     }
+
+    internal class CumulativeRelationshipEqualityComparer: IEqualityComparer<QuantityRelation>{
+        public bool Equals(QuantityRelation? x, QuantityRelation? y)
+        {
+            if (ReferenceEquals(x, y)) return true;
+            if (x is null) return false;
+            if (y is null) return false;
+            if (x.GetType() != y.GetType()) return false;
+            return
+                x.ResultQuantity == y.ResultQuantity && (
+                    (x.LeftQuantity.Equals(y.LeftQuantity) && x.RightQuantity.Equals(y.RightQuantity))
+                    || (x.LeftQuantity.Equals(y.RightQuantity) && x.RightQuantity.Equals(y.LeftQuantity)));
+        }
+
+        public int GetHashCode(QuantityRelation obj)
+        {
+            return obj.LeftQuantity.GetHashCode() ^ obj.RightQuantity.GetHashCode();
+        }
+    }
 }
diff --git a/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
index a5818b07cf..031ac986ab 100644
--- a/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
@@ -59,7 +59,7 @@ internal class UnitTestBaseClassGenerator : GeneratorBase
         /// A dimensionless quantity has all base dimensions (L, M, T, I, Θ, N, J) equal to zero.
         /// </remarks>
         private readonly bool _isDimensionless;
-
+        
         /// <summary>
         ///     Stores a mapping of culture names to their corresponding unique unit abbreviations.
         ///     Each culture maps to a dictionary where the key is the unit abbreviation and the value is the corresponding
@@ -101,7 +101,7 @@ internal class UnitTestBaseClassGenerator : GeneratorBase
         ///     is not available for the defined unit localizations.
         /// </remarks>
         private const string FallbackCultureName = "en-US";
-
+        
         public UnitTestBaseClassGenerator(Quantity quantity)
         {
             _quantity = quantity;
@@ -263,6 +263,7 @@ public abstract partial class {_quantity.Name}TestsBase : QuantityTestsBase
                 Writer.WL($@"
             new object[] {{ {GetUnitFullName(unit)} }},");
             }
+
             Writer.WL($@"
         }};
 
@@ -339,6 +340,20 @@ public void Ctor_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
             Assert.Equal(quantityInfo, ((IQuantity<{_unitEnumName}>)quantity).QuantityInfo);
         }}
 
+        [Fact]
+        public void {_quantity.Name}Info_CreateWithCustomUnitInfos()
+        {{
+            {_unitEnumName}[] expectedUnits = [{_baseUnitFullName}];
+
+            {_quantity.Name}.{_quantity.Name}Info quantityInfo = {_quantity.Name}.{_quantity.Name}Info.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal(""{_quantity.Name}"", quantityInfo.Name);
+            Assert.Equal({_quantity.Name}.Zero, quantityInfo.Zero);
+            Assert.Equal({_quantity.Name}.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }}
+
         [Fact]
         public void {_baseUnit.SingularName}To{_quantity.Name}Units()
         {{
@@ -412,12 +427,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {{
-            var quantity = new {_quantity.Name}(value: 1, unit: {_baseUnitFullName});
+            Assert.Multiple(() =>
+            {{
+                var quantity = new {_quantity.Name}(value: 1, unit: {_baseUnitFullName});
 
-            {_quantity.Name} convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                {_quantity.Name} convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal({_baseUnitFullName}, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal({_baseUnitFullName}, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }}, () =>
+            {{
+                IQuantity<{_unitEnumName}> quantity = new {_quantity.Name}(value: 1, unit: {_baseUnitFullName});
+
+                IQuantity<{_unitEnumName}> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal({_baseUnitFullName}, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }}, () =>
+            {{
+                IQuantity quantity = new {_quantity.Name}(value: 1, unit: {_baseUnitFullName});
+
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal({_baseUnitFullName}, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }});
         }}
 
         [Fact]
@@ -485,26 +519,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = {_quantity.Name}.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            {_quantity.Name} convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {{
+                {_quantity.Name} quantityToConvert = quantity;
+
+                {_quantity.Name} convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }}, () =>
+            {{
+                IQuantity<{_unitEnumName}> quantityToConvert = quantity;
+
+                IQuantity<{_unitEnumName}> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }}, () =>
+            {{
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }});
         }}
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {{
             UnitSystem nullUnitSystem = null!;
-            var quantity = new {_quantity.Name}(value: 1, unit: {_quantity.Name}.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {{
+                var quantity = new {_quantity.Name}(value: 1, unit: {_quantity.Name}.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }}, () =>
+            {{
+                IQuantity<{_unitEnumName}> quantity = new {_quantity.Name}(value: 1, unit: {_quantity.Name}.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }}, () =>
+            {{
+                IQuantity quantity = new {_quantity.Name}(value: 1, unit: {_quantity.Name}.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }});
         }}
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {{
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new {_quantity.Name}(value: 1, unit: {_quantity.Name}.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {{
+                var quantity = new {_quantity.Name}(value: 1, unit: {_quantity.Name}.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }}, () =>
+            {{
+                IQuantity<{_unitEnumName}> quantity = new {_quantity.Name}(value: 1, unit: {_quantity.Name}.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }}, () =>
+            {{
+                IQuantity quantity = new {_quantity.Name}(value: 1, unit: {_quantity.Name}.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }});
         }}
 ");
             }
@@ -522,7 +599,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
             }
 
             Writer.WL($@"
-        public void Parse(string culture, string quantityString, {_unitEnumName} expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, {_unitEnumName} expectedUnit, decimal expectedValue)
         {{
             using var _ = new CultureScope(culture);
             var parsed = {_quantity.Name}.Parse(quantityString);
@@ -567,7 +644,7 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
             }
 
             Writer.WL($@"
-        public void TryParse(string culture, string quantityString, {_unitEnumName} expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, {_unitEnumName} expectedUnit, decimal expectedValue)
         {{
             using var _ = new CultureScope(culture);
             Assert.True({_quantity.Name}.TryParse(quantityString, out {_quantity.Name} parsed));
@@ -825,7 +902,7 @@ public void GetAbbreviationWithDefaultCulture()
             }});
         }}
 ");
-
+            
             Writer.WL($@"
         [Theory]
         [MemberData(nameof(UnitTypes))]
@@ -857,6 +934,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit({_unitEnumName}
                 var quantity = {_quantity.Name}.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             }});
         }}
 
@@ -880,20 +958,22 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity({_unitEnumName} uni
                 IQuantity<{_unitEnumName}> quantityToConvert = quantity;
                 IQuantity<{_unitEnumName}> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }}, () =>
             {{
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }});
         }}
 
         [Fact]
         public void ConversionRoundTrip()
         {{
-            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
+            {_quantity.Name} {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(3);");
             foreach (var unit in _quantity.Units) Writer.WL($@"
-            AssertEx.EqualTolerance(1, {_quantity.Name}.From{unit.PluralName}({baseUnitVariableName}.{unit.PluralName}).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);");
+            Assert.Equal(3, {_quantity.Name}.From{unit.PluralName}({baseUnitVariableName}.{unit.PluralName}).{_baseUnit.PluralName});");
             Writer.WL($@"
         }}
 ");
@@ -905,13 +985,13 @@ public void ConversionRoundTrip()
         public void LogarithmicArithmeticOperators()
         {{
             {_quantity.Name} v = {_quantity.Name}.From{_baseUnit.PluralName}(40);
-            AssertEx.EqualTolerance(-40, -v.{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
+            Assert.Equal(-40, -v.{_baseUnit.PluralName});
             AssertLogarithmicAddition();
             AssertLogarithmicSubtraction();
-            AssertEx.EqualTolerance(50, (v*10).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(50, (10*v).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(35, (v/5).{_baseUnit.PluralName}, {unit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(35, v/{_quantity.Name}.From{_baseUnit.PluralName}(5), {unit.PluralName}Tolerance);
+            Assert.Equal(50, (v * 10).{_baseUnit.PluralName});
+            Assert.Equal(50, (10 * v).{_baseUnit.PluralName});
+            Assert.Equal(35, (v / 5).{_baseUnit.PluralName});
+            Assert.Equal(35, v / {_quantity.Name}.From{_baseUnit.PluralName}(5));
         }}
 
         protected abstract void AssertLogarithmicAddition();
@@ -926,13 +1006,13 @@ public void LogarithmicArithmeticOperators()
         public void ArithmeticOperators()
         {{
             {_quantity.Name} v = {_quantity.Name}.From{_baseUnit.PluralName}(1);
-            AssertEx.EqualTolerance(-1, -v.{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, ({_quantity.Name}.From{_baseUnit.PluralName}(3)-v).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, (v + v).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(10, (v*10).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(10, (10*v).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, ({_quantity.Name}.From{_baseUnit.PluralName}(10)/5).{_baseUnit.PluralName}, {_baseUnit.PluralName}Tolerance);
-            AssertEx.EqualTolerance(2, {_quantity.Name}.From{_baseUnit.PluralName}(10)/{_quantity.Name}.From{_baseUnit.PluralName}(5), {_baseUnit.PluralName}Tolerance);
+            Assert.Equal(-1, -v.{_baseUnit.PluralName});
+            Assert.Equal(2, ({_quantity.Name}.From{_baseUnit.PluralName}(3) - v).{_baseUnit.PluralName});
+            Assert.Equal(2, (v + v).{_baseUnit.PluralName});
+            Assert.Equal(10, (v * 10).{_baseUnit.PluralName});
+            Assert.Equal(10, (10 * v).{_baseUnit.PluralName});
+            Assert.Equal(2, ({_quantity.Name}.From{_baseUnit.PluralName}(10) / 5).{_baseUnit.PluralName});
+            Assert.Equal(2, {_quantity.Name}.From{_baseUnit.PluralName}(10) / {_quantity.Name}.From{_baseUnit.PluralName}(5));
         }}
 ");
             }
@@ -985,13 +1065,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, {_baseUnitFullName}, 1, {_baseUnitFullName}, true)]  // Same value and unit.
         [InlineData(1, {_baseUnitFullName}, 2, {_baseUnitFullName}, false)] // Different value.
-        [InlineData(2, {_baseUnitFullName}, 1, {_otherOrBaseUnitFullName}, false)] // Different value and unit.");
-            if (_baseUnit != _otherOrBaseUnit)
-            {
-                Writer.WL($@"
-        [InlineData(1, {_baseUnitFullName}, 1, {_otherOrBaseUnitFullName}, false)] // Different unit.");
-            }
-            Writer.WL($@"
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, {_unitEnumName} unitA, double valueB, {_unitEnumName} unitB, bool expectEqual)
         {{
             var a = new {_quantity.Name}(valueA, unitA);
@@ -1056,8 +1129,8 @@ public void Equals_Logarithmic_WithTolerance(double firstValue, double secondVal
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(firstValue);
             var otherQuantity = {_quantity.Name}.From{_baseUnit.PluralName}(secondValue);
             {differenceResultType} maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, {differenceResultType}.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, largerTolerance));
@@ -1089,8 +1162,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(firstValue);
             var otherQuantity = {_quantity.Name}.From{_baseUnit.PluralName}(secondValue);
             {differenceResultType} maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, {differenceResultType}.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1131,7 +1204,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {{
-            var units = Enum.GetValues<{_unitEnumName}>();
+            var units = EnumHelper.GetValues<{_unitEnumName}>();
             foreach (var unit in units)
             {{
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1144,6 +1217,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False({_quantity.Name}.BaseDimensions is null);
         }}
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {{
+            Assert.Equal({_quantity.Name}.Info.Units, {_quantity.Name}.Units);
+        }}
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {{
+            Assert.Equal(UnitConverter.Default, {_quantity.Name}.DefaultConversionFunctions);
+        }}
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {{
@@ -1170,26 +1255,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Writer.WL($@"
         }}
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {{
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal(""0.1{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s1""));
-            Assert.Equal(""0.12{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s2""));
-            Assert.Equal(""0.123{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s3""));
-            Assert.Equal(""0.1235{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s4""));
-        }}
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {{
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal(""0.1{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s1"", culture));
-            Assert.Equal(""0.12{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s2"", culture));
-            Assert.Equal(""0.123{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s3"", culture));
-            Assert.Equal(""0.1235{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s4"", culture));
-        }}
-
         [Theory]
         [InlineData(null)]
         [InlineData(""en-US"")]
@@ -1216,7 +1281,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof({_quantity.Name}), quantity.As({_quantity.Name}.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }}
 ");
 
diff --git a/CodeGen/Generators/UnitsNetGenerator.cs b/CodeGen/Generators/UnitsNetGenerator.cs
index 7b69071029..a2d5ed9ce6 100644
--- a/CodeGen/Generators/UnitsNetGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGenerator.cs
@@ -1,10 +1,11 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using CodeGen.Generators.UnitsNetGen;
+using CodeGen.Helpers;
 using CodeGen.Helpers.UnitEnumValueAllocation;
 using CodeGen.JsonTypes;
 using Serilog;
@@ -91,63 +92,63 @@ private static void GenerateQuantityTestClassIfNotExists(Quantity quantity, stri
             if (File.Exists(filePath)) return;
 
             var content = new UnitTestStubGenerator(quantity).Generate();
-            File.WriteAllText(filePath, content);
+            CodeGenFile.WriteAllText(filePath, content);
             Log.Information("✅ {Quantity} initial test stub", quantity.Name);
         }
 
         private static void GenerateQuantity(Quantity quantity, string filePath)
         {
             var content = new QuantityGenerator(quantity).Generate();
-            File.WriteAllText(filePath, content);
+            CodeGenFile.WriteAllText(filePath, content);
         }
 
         private static void GenerateNumberToExtensions(Quantity quantity, string filePath)
         {
             var content = new NumberExtensionsGenerator(quantity).Generate();
-            File.WriteAllText(filePath, content);
+            CodeGenFile.WriteAllText(filePath, content);
         }
 
         private static void GenerateNumberToExtensionsTestClass(Quantity quantity, string filePath)
         {
             var content = new NumberExtensionsTestClassGenerator(quantity).Generate();
-            File.WriteAllText(filePath, content);
+            CodeGenFile.WriteAllText(filePath, content);
         }
 
         private static void GenerateNumberToExtensionsCS14(Quantity quantity, string filePath)
         {
             var content = new NumberExtensionsCS14Generator(quantity).Generate();
-            File.WriteAllText(filePath, content);
+            CodeGenFile.WriteAllText(filePath, content);
         }
 
         private static void GenerateNumberToExtensionsCS14TestClass(Quantity quantity, string filePath)
         {
             var content = new NumberExtensionsCS14TestClassGenerator(quantity).Generate();
-            File.WriteAllText(filePath, content);
+            CodeGenFile.WriteAllText(filePath, content);
         }
 
         private static void GenerateUnitType(Quantity quantity, string filePath, UnitEnumNameToValue unitEnumValues)
         {
             var content = new UnitTypeGenerator(quantity, unitEnumValues).Generate();
-            File.WriteAllText(filePath, content);
+            CodeGenFile.WriteAllText(filePath, content);
         }
 
         private static void GenerateQuantityTestBaseClass(Quantity quantity, string filePath)
         {
             var content = new UnitTestBaseClassGenerator(quantity).Generate();
-            File.WriteAllText(filePath, content);
+            CodeGenFile.WriteAllText(filePath, content);
         }
 
         private static void GenerateIQuantityTests(Quantity[] quantities, string filePath)
         {
             var content = new IQuantityTestClassGenerator(quantities).Generate();
-            File.WriteAllText(filePath, content);
+            CodeGenFile.WriteAllText(filePath, content);
             Log.Information("✅ IQuantityTests.g.cs");
         }
 
         private static void GenerateStaticQuantity(Quantity[] quantities, string filePath)
         {
             var content = new StaticQuantityGenerator(quantities).Generate();
-            File.WriteAllText(filePath, content);
+            CodeGenFile.WriteAllText(filePath, content);
             Log.Information("✅ Quantity.g.cs");
         }
 
@@ -171,10 +172,7 @@ private static void GenerateResourceFiles(Quantity[] quantities, string resource
                         $"{resourcesDirectory}/{quantity.Name}.restext" :
                         $"{resourcesDirectory}/{quantity.Name}.{culture}.restext";
 
-                    // Ensure parent folder exists
-                    Directory.CreateDirectory(resourcesDirectory);
-
-                    using var writer = File.CreateText(fileName);
+                    using var writer = CodeGenFile.CreateText(fileName);
 
                     foreach(Unit unit in quantity.Units)
                     {
diff --git a/CodeGen/Helpers/CodeGenFile.cs b/CodeGen/Helpers/CodeGenFile.cs
new file mode 100644
index 0000000000..54554d979b
--- /dev/null
+++ b/CodeGen/Helpers/CodeGenFile.cs
@@ -0,0 +1,57 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.IO;
+using System.Text;
+
+namespace CodeGen.Helpers
+{
+    /// <summary>
+    ///     Provides file I/O helpers for CodeGen files with explicit UTF-8 encoding behavior.
+    /// </summary>
+    internal static class CodeGenFile
+    {
+        /// <summary>
+        ///     UTF-8 encoding without byte order mark, used for generated and codegen-normalized files.
+        /// </summary>
+        internal static readonly Encoding Utf8NoBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);
+
+        /// <summary>
+        ///     Reads all text from a CodeGen input file as UTF-8.
+        /// </summary>
+        /// <remarks>
+        ///     Existing byte order marks are still detected when present.
+        /// </remarks>
+        public static string ReadAllText(string path)
+        {
+            return File.ReadAllText(path, Utf8NoBom);
+        }
+
+        /// <summary>
+        ///     Writes all text to a generated or codegen-normalized file as UTF-8 without byte order mark.
+        /// </summary>
+        public static void WriteAllText(string path, string contents)
+        {
+            File.WriteAllText(path, contents, Utf8NoBom);
+        }
+
+        /// <summary>
+        ///     Opens a CodeGen input file for text reading as UTF-8.
+        /// </summary>
+        /// <remarks>
+        ///     Existing byte order marks are still detected when present.
+        /// </remarks>
+        public static StreamReader OpenText(string path)
+        {
+            return new StreamReader(path, Utf8NoBom, detectEncodingFromByteOrderMarks: true);
+        }
+
+        /// <summary>
+        ///     Creates or overwrites a generated or codegen-normalized text file as UTF-8 without byte order mark.
+        /// </summary>
+        public static StreamWriter CreateText(string path)
+        {
+            return new StreamWriter(path, append: false, Utf8NoBom);
+        }
+    }
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/ExpressionEvaluationTerm.cs b/CodeGen/Helpers/ExpressionAnalyzer/ExpressionEvaluationTerm.cs
new file mode 100644
index 0000000000..5b17bc933d
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/ExpressionEvaluationTerm.cs
@@ -0,0 +1,14 @@
+using Fractions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer;
+
+/// <summary>
+///     A term of the form "P^n" where P is a term that hasn't been parsed, raised to the given power.
+/// </summary>
+/// <param name="Expression">The actual expression to parse</param>
+/// <param name="Exponent">The exponent to use on the parsed expression (default is 1)</param>
+/// <remarks>
+///     Since we're tokenizing the expressions from top to bottom, the first step is parsing the exponent of the
+///     expression: e.g. Math.Pow(P, 2)
+/// </remarks>
+public record ExpressionEvaluationTerm(string Expression, Fraction Exponent);
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/ExpressionEvaluator.cs b/CodeGen/Helpers/ExpressionAnalyzer/ExpressionEvaluator.cs
new file mode 100644
index 0000000000..379adcd1d0
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/ExpressionEvaluator.cs
@@ -0,0 +1,310 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using CodeGen.Helpers.ExpressionAnalyzer.Expressions;
+using CodeGen.Helpers.ExpressionAnalyzer.Functions;
+using CodeGen.Helpers.ExpressionAnalyzer.Functions.Math;
+using Fractions;
+using static System.Globalization.CultureInfo;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer;
+
+internal partial class ExpressionEvaluator // TODO make public (and move out in a separate project)
+{
+    public static readonly Fraction Pi = Fraction.FromDoubleRounded(Math.PI, 16);
+    private readonly IReadOnlyDictionary<string, Fraction> _constantValues;
+    private readonly Dictionary<string, CompositeExpression> _expressionsEvaluated = [];
+
+    private readonly IReadOnlyDictionary<string, IFunctionEvaluator> _functionEvaluators;
+
+    public ExpressionEvaluator(string parameterName, params IFunctionEvaluator[] functionEvaluators)
+        : this(parameterName, functionEvaluators.ToDictionary(x => x.FunctionName), new Dictionary<string, Fraction>())
+    {
+    }
+
+    public ExpressionEvaluator(string parameterName, IReadOnlyDictionary<string, Fraction> constantValues, params IFunctionEvaluator[] functionEvaluators)
+        : this(parameterName, functionEvaluators.ToDictionary(x => x.FunctionName), constantValues)
+    {
+    }
+
+    public ExpressionEvaluator(string parameterName, IReadOnlyDictionary<string, IFunctionEvaluator> functionEvaluators,
+        IReadOnlyDictionary<string, Fraction> constantValues)
+    {
+        ParameterName = parameterName;
+        _constantValues = constantValues;
+        _functionEvaluators = functionEvaluators;
+    }
+
+    public string ParameterName { get; }
+
+    protected string Add(CompositeExpression expression)
+    {
+        var label = "{" + (char)('a' + _expressionsEvaluated.Count) + "}";
+        _expressionsEvaluated[label] = expression;
+        return label;
+    }
+
+    public CompositeExpression Evaluate(ExpressionEvaluationTerm expressionEvaluationTerm) // TODO either replace by string or add a coefficient
+    {
+        if (TryParseExpressionTerm(expressionEvaluationTerm.Expression, expressionEvaluationTerm.Exponent, out ExpressionTerm? expressionTerm))
+        {
+            return expressionTerm;
+        }
+
+        var expressionToParse = expressionEvaluationTerm.Expression;
+        Fraction exponent = expressionEvaluationTerm.Exponent;
+        string previousExpression;
+        do
+        {
+            previousExpression = expressionToParse;
+            // the regex captures the innermost occurrence of a function group: "Sin(x)", "Pow(x, y)", "(x + 1)" are all valid matches
+            expressionToParse = MathOperationRegex().Replace(expressionToParse, match =>
+            {
+                var functionName = match.Groups[1].Value;
+                var functionBodyToParse = match.Groups[2].Value;
+                var evaluationTerm = new ExpressionEvaluationTerm(functionBodyToParse, exponent);
+                if (string.IsNullOrEmpty(functionName)) // standard grouping (technically this is equivalent to f(x) -> x)
+                {
+                    // all terms within the group are expanded: extract the simplified expression
+                    CompositeExpression expression = ReplaceTokenizedExpressions(evaluationTerm);
+                    return Add(expression);
+                }
+
+                if (_functionEvaluators.TryGetValue(functionName, out IFunctionEvaluator? functionEvaluator))
+                {
+                    // resolve the expression using the custom function evaluator
+                    CompositeExpression expression = functionEvaluator.CreateExpression(evaluationTerm, ReplaceTokenizedExpressions);
+                    return Add(expression);
+                }
+
+                throw new FormatException($"No function evaluator available for {functionName}({functionBodyToParse})");
+            });
+        } while (previousExpression != expressionToParse);
+
+        return ReplaceTokenizedExpressions(expressionEvaluationTerm with { Expression = expressionToParse });
+    }
+
+    private CompositeExpression ReplaceTokenizedExpressions(ExpressionEvaluationTerm tokenizedExpression)
+    {
+        // all groups and function are expanded: we're left with a standard arithmetic expression such as "4 * a + 2 * b * x - c - d + 5"
+        // with a, b, c, d representing the previously evaluated expressions
+        var result = new CompositeExpression();
+        var stringBuilder = new StringBuilder();
+        ArithmeticOperationToken lastToken = ArithmeticOperationToken.Addition;
+        CompositeExpression? runningExpression = null;
+        foreach (var character in tokenizedExpression.Expression)
+        {
+            if (!TryReadToken(character, out ArithmeticOperationToken currentToken)) // TODO use None?
+            {
+                continue;
+            }
+
+            switch (currentToken)
+            {
+                case ArithmeticOperationToken.Addition or ArithmeticOperationToken.Subtraction:
+                {
+                    if (stringBuilder.Length == 0) // ignore the leading sign
+                    {
+                        lastToken = currentToken;
+                        continue;
+                    }
+
+                    // we're at the end of a term expression
+                    CompositeExpression lastTerm = ParseTerm();
+                    if (runningExpression is null)
+                    {
+                        result.AddTerms(lastTerm);
+                    }
+                    else // the last term is part of a running multiplication
+                    {
+                        result.AddTerms(runningExpression * lastTerm);
+                        runningExpression = null;
+                    }
+
+                    lastToken = currentToken;
+                    break;
+                }
+                case ArithmeticOperationToken.Multiplication or ArithmeticOperationToken.Division:
+                {
+                    CompositeExpression previousTerm = ParseTerm();
+                    if (runningExpression is null)
+                    {
+                        runningExpression = previousTerm;
+                    }
+                    else // the previousTerm term is part of a running multiplication (which is going to be followed by at least one more multiplication/division)
+                    {
+                        runningExpression *= previousTerm;
+                    }
+
+                    lastToken = currentToken;
+                    break;
+                }
+            }
+        }
+
+        CompositeExpression finalTerm = ParseTerm();
+        if (runningExpression is null)
+        {
+            result.AddTerms(finalTerm);
+        }
+        else
+        {
+            result.AddTerms(runningExpression * finalTerm);
+        }
+
+        return result;
+
+        bool TryReadToken(char character, out ArithmeticOperationToken token)
+        {
+            switch (character)
+            {
+                case '+':
+                    token = ArithmeticOperationToken.Addition;
+                    return true;
+                case '-':
+                    token = ArithmeticOperationToken.Subtraction;
+                    return true;
+                case '*':
+                    token = ArithmeticOperationToken.Multiplication;
+                    return true;
+                case '/':
+                    token = ArithmeticOperationToken.Division;
+                    return true;
+                case not ' ':
+                    stringBuilder.Append(character);
+                    break;
+            }
+
+            token = default;
+            return false;
+        }
+
+        CompositeExpression ParseTerm()
+        {
+            var previousExpression = stringBuilder.ToString();
+            stringBuilder.Clear();
+            if (_expressionsEvaluated.TryGetValue(previousExpression, out CompositeExpression? expression))
+            {
+                return lastToken switch
+                {
+                    ArithmeticOperationToken.Subtraction => expression.Negate(),
+                    ArithmeticOperationToken.Division => expression.Invert(),
+                    _ => expression
+                };
+            }
+
+            if (TryParseExpressionTerm(previousExpression, tokenizedExpression.Exponent, out ExpressionTerm? expressionTerm))
+            {
+                return lastToken switch
+                {
+                    ArithmeticOperationToken.Subtraction => expressionTerm.Negate(),
+                    ArithmeticOperationToken.Division => expressionTerm.Invert(),
+                    _ => expressionTerm
+                };
+            }
+
+            throw new FormatException($"Failed to parse the previous token: {previousExpression}");
+        }
+    }
+
+
+    private bool TryParseExpressionTerm(string expressionToParse, Fraction exponent, [MaybeNullWhen(false)] out ExpressionTerm expressionTerm)
+    {
+        if (expressionToParse == ParameterName)
+        {
+            expressionTerm = new ExpressionTerm(Fraction.One, exponent);
+            return true;
+        }
+
+        if (_constantValues.TryGetValue(expressionToParse, out Fraction constantExpression) || FractionHelper.TryParseInvariant(expressionToParse, out constantExpression))
+        {
+            expressionTerm = ExpressionTerm.Constant(constantExpression.Pow(exponent));
+            return true;
+        }
+
+        expressionTerm = null;
+        return false;
+    }
+
+    public static string ReplaceDecimalNotations(string expression, Dictionary<string, Fraction> constantValues)
+    {
+        return ScientificNotationRegex().Replace(expression, match =>
+        {
+            var tokens = match.Value.ToLower().Replace("d", "").Split('e');
+            if (tokens.Length != 2 || !FractionHelper.TryParseInvariant(tokens[0], out Fraction mantissa) || !int.TryParse(tokens[1], InvariantCulture, out var exponent))
+            {
+                throw new FormatException($"The expression contains invalid tokens: {expression}");
+            }
+
+            var label = $"{{v{constantValues.Count}}}";
+            constantValues[label] = mantissa * Fraction.Pow(10, exponent);
+            return label;
+        }).Replace("d", string.Empty); // TODO these are force-generated for the BitRate (we should stop doing it)
+    }
+
+    public static string ReplaceMathPi(string expression, Dictionary<string, Fraction> constantValues)
+    {
+        return MathPiRegex().Replace(expression, _ =>
+        {
+            constantValues[nameof(Pi)] = Pi;
+            return nameof(Pi);
+        });
+    }
+
+    public static CompositeExpression Evaluate(string expression, string parameter)
+    {
+        var constantExpressions = new Dictionary<string, Fraction>();
+
+        expression = ReplaceDecimalNotations(expression, constantExpressions); // TODO expose an IPreprocessor (or something)
+        expression = ReplaceMathPi(expression, constantExpressions);
+        expression = expression.Replace("Math.", string.Empty);
+
+        // these are no longer necessary
+        // var expressionEvaluator = new ExpressionEvaluator(parameter, constantExpressions,
+        //     new SqrtFunctionEvaluator(),
+        //     new PowFunctionEvaluator(),
+        //     new SinFunctionEvaluator(),
+        //     new AsinFunctionEvaluator());
+        var expressionEvaluator = new ExpressionEvaluator(parameter, constantExpressions);
+
+        return expressionEvaluator.Evaluate(new ExpressionEvaluationTerm(expression, Fraction.One));
+    }
+
+    private enum ArithmeticOperationToken
+    {
+        Addition,
+        Subtraction,
+        Multiplication,
+        Division
+    }
+
+    /// <summary>
+    /// Matches numbers in scientific notation, optionally with a trailing d or D.
+    /// </summary>
+    /// <example>
+    /// 1.23e4
+    /// 5.67E-8d
+    /// 0.00123e+3D
+    /// </example>
+    [GeneratedRegex(@"\d*(\.\d*)?[eE][-\+]?\d*[dD]?")]
+    private static partial Regex ScientificNotationRegex();
+
+    /// <summary>
+    /// Matches occurrences of "Math.PI".
+    /// </summary>
+    [GeneratedRegex(@"Math\.PI")]
+    private static partial Regex MathPiRegex();
+
+    /// <summary>
+    /// Matches the innermost function call or parenthesized group.
+    /// Group 1: optional function name (e.g. "Sin" or "Pow"); empty for plain parentheses.
+    /// Group 2: the contents of the parentheses (does not allow nested parentheses).
+    /// Examples: Sin(x) -> group1="Sin", group2="x"; Pow(x, y) -> group1="Pow", group2="x, y"; (x + 1) -> group1="", group2="x + 1".
+    /// Use iteratively to find and replace innermost groups first.
+    /// </summary>
+    [GeneratedRegex(@"(\w*)\(([^()]*)\)")]
+    private static partial Regex MathOperationRegex();
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/Expressions/CompositeExpression.cs b/CodeGen/Helpers/ExpressionAnalyzer/Expressions/CompositeExpression.cs
new file mode 100644
index 0000000000..60bbd7c077
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/Expressions/CompositeExpression.cs
@@ -0,0 +1,213 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Fractions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer.Expressions;
+
+/// <summary>
+///     A set of terms, ordered by their degree: "P(x)^2 + P(x) + 1"
+/// </summary>
+internal class CompositeExpression : IEnumerable<ExpressionTerm>
+{
+    private readonly SortedSet<ExpressionTerm> _terms;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="CompositeExpression" /> class.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor creates an empty CompositeExpression with terms sorted in descending order.
+    /// </remarks>
+    public CompositeExpression()
+    {
+        _terms = new SortedSet<ExpressionTerm>(DescendingOrderComparer);
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="CompositeExpression" /> class with a single term.
+    /// </summary>
+    /// <param name="term">The initial term of the composite expression.</param>
+    /// <remarks>
+    ///     This constructor creates a CompositeExpression with a single term, sorted in descending order.
+    /// </remarks>
+    public CompositeExpression(ExpressionTerm term)
+    {
+        _terms = new SortedSet<ExpressionTerm>(DescendingOrderComparer) { term };
+    }
+
+    private CompositeExpression(IEnumerable<ExpressionTerm> terms)
+    {
+        _terms = new SortedSet<ExpressionTerm>(terms, DescendingOrderComparer);
+    }
+
+    public Fraction Degree => _terms.Min?.Exponent ?? Fraction.Zero;
+
+    public bool IsConstant => Degree == Fraction.Zero;
+
+    public IReadOnlyCollection<ExpressionTerm> Terms => _terms;
+
+    public void Add(ExpressionTerm term)
+    {
+        if (_terms.TryGetValue(term, out ExpressionTerm? sameDegreeTerm))
+        {
+            // merge the two terms
+            term = term with { Coefficient = sameDegreeTerm.Coefficient + term.Coefficient };
+            _terms.Remove(sameDegreeTerm);
+        }
+
+        _terms.Add(term);
+    }
+
+    public void AddTerms(IEnumerable<ExpressionTerm> expressionTerms)
+    {
+        foreach (ExpressionTerm term in expressionTerms)
+        {
+            Add(term);
+        }
+    }
+
+
+    public static implicit operator CompositeExpression(ExpressionTerm term)
+    {
+        return new CompositeExpression(term);
+    }
+
+    public static explicit operator ExpressionTerm(CompositeExpression term)
+    {
+        return term._terms.Max!;
+    }
+
+    public CompositeExpression Negate()
+    {
+        return new CompositeExpression(_terms.Select(term => term.Negate()));
+    }
+
+    public CompositeExpression Invert()
+    {
+        return new CompositeExpression(_terms.Select(term => term.Invert()));
+    }
+    
+    public CompositeExpression SolveForY()
+    {
+        if (_terms.Count == 0)
+        {
+            throw new InvalidOperationException("The expression is empty");
+        }
+
+        if (_terms.Count > 2)
+        {
+            throw new NotImplementedException("Solving is only supported for expressions of first degree");
+        }
+
+        ExpressionTerm degreeTerm = _terms.Min!;
+        if (degreeTerm.Exponent == Fraction.One)
+        {
+            return new CompositeExpression(_terms.Where(x => x.IsConstant).Select(x => x with { Coefficient = x.Coefficient.Negate() / degreeTerm.Coefficient })
+                .Prepend(new ExpressionTerm(degreeTerm.Coefficient.Reciprocal(), 1)));
+        }
+
+        if (degreeTerm.Exponent == Fraction.MinusOne)
+        {
+            return new CompositeExpression(_terms.Where(x => x.IsConstant).Select(x => x with { Coefficient = degreeTerm.Coefficient / x.Coefficient.Negate() })
+                .Prepend(new ExpressionTerm(degreeTerm.Coefficient, -1)));
+        }
+
+        throw new NotImplementedException("Solving is only supported for expressions of first degree");
+    }
+
+    public CompositeExpression Multiply(CompositeExpression other)
+    {
+        var result = new CompositeExpression();
+        foreach (ExpressionTerm otherTerm in other)
+        {
+            result.AddTerms(_terms.Select(x => x.Multiply(otherTerm)));
+        }
+
+        return result;
+    }
+
+    public CompositeExpression Divide(CompositeExpression other)
+    {
+        var result = new CompositeExpression();
+        foreach (ExpressionTerm otherTerm in other)
+        {
+            result.AddTerms(_terms.Select(x => x.Divide(otherTerm)));
+        }
+
+        return result;
+    }
+
+    public static CompositeExpression operator *(CompositeExpression left, CompositeExpression right)
+    {
+        return left.Multiply(right);
+    }
+
+    public static CompositeExpression operator /(CompositeExpression left, CompositeExpression right)
+    {
+        return left.Divide(right);
+    }
+
+    public override string ToString()
+    {
+        return string.Join(" + ", _terms);
+    }
+
+    public CompositeExpression Evaluate(Fraction x)
+    {
+        var result = new CompositeExpression();
+        result.AddTerms(_terms.Select(t => t.Evaluate(x)));
+        return result;
+    }
+
+    public CompositeExpression Evaluate(CompositeExpression expression)
+    {
+        var result = new CompositeExpression();
+        foreach (ExpressionTerm expressionTerm in _terms)
+        {
+            if (expressionTerm.IsConstant)
+            {
+                result.Add(expressionTerm);
+            }
+            else
+            {
+                result.AddTerms(expression.Terms.Select(term => expressionTerm.Evaluate(term)));
+            }
+        }
+        
+        return result;
+    }
+
+    #region TermComparer
+
+    private sealed class DescendingOrderTermComparer : IComparer<ExpressionTerm>
+    {
+        public int Compare(ExpressionTerm? y, ExpressionTerm? x)
+        {
+            if (ReferenceEquals(x, y)) return 0;
+            if (ReferenceEquals(null, y)) return 1;
+            if (ReferenceEquals(null, x)) return -1;
+            var nestedFunctionComparison = Comparer<CustomFunction?>.Default.Compare(x.NestedFunction, y.NestedFunction);
+            if (nestedFunctionComparison != 0) return nestedFunctionComparison;
+            return x.Exponent.Abs().CompareTo(y.Exponent.Abs());
+        }
+    }
+
+    public static IComparer<ExpressionTerm> DescendingOrderComparer { get; } = new DescendingOrderTermComparer();
+
+    #endregion
+
+    #region Implementation of IEnumerable
+
+    public IEnumerator<ExpressionTerm> GetEnumerator()
+    {
+        return _terms.GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
+    }
+
+    #endregion
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/Expressions/CustomFunction.cs b/CodeGen/Helpers/ExpressionAnalyzer/Expressions/CustomFunction.cs
new file mode 100644
index 0000000000..0ebee1796e
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/Expressions/CustomFunction.cs
@@ -0,0 +1,43 @@
+using System;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer.Expressions;
+
+/// <summary>
+///     A custom function f(ax^n + bx^m)
+/// </summary>
+/// <param name="Name"></param>
+/// <param name="Namespace"></param>
+/// <param name="Terms"></param>
+/// <param name="AdditionalParameters"></param>
+/// <remarks>These are functions that we don't directly support, such as Sqrt.</remarks>
+internal record CustomFunction(string Namespace, string Name, CompositeExpression Terms, params string[] AdditionalParameters) : IComparable<CustomFunction>, IComparable
+{
+    #region Overrides of Object
+
+    public override string ToString()
+    {
+        if(AdditionalParameters.Length == 0)
+            return $"{Name}({Terms})";
+        return $"{Name}({Terms}, {string.Join(", ", AdditionalParameters)})";
+    }
+
+    #endregion
+
+    #region Relational members
+
+    public int CompareTo(CustomFunction? other)
+    {
+        if (ReferenceEquals(this, other)) return 0;
+        if (ReferenceEquals(null, other)) return 1;
+        return string.Compare(Name, other.Name, StringComparison.Ordinal);
+    }
+
+    public int CompareTo(object? obj)
+    {
+        if (ReferenceEquals(null, obj)) return 1;
+        if (ReferenceEquals(this, obj)) return 0;
+        return obj is CustomFunction other ? CompareTo(other) : throw new ArgumentException($"Object must be of type {nameof(CustomFunction)}");
+    }
+
+    #endregion
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/Expressions/ExpressionTerm.cs b/CodeGen/Helpers/ExpressionAnalyzer/Expressions/ExpressionTerm.cs
new file mode 100644
index 0000000000..c836906a73
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/Expressions/ExpressionTerm.cs
@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using CodeGen.Helpers.ExpressionAnalyzer.Functions.Math;
+using Fractions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer.Expressions;
+
+/// <summary>
+///     A term of the form "a * f(x)^n".
+/// </summary>
+/// <param name="Coefficient">The constant coefficient (a)</param>
+/// <param name="Exponent">The degree of the term (n)</param>
+/// <param name="NestedFunction">f(x) if one is available</param>
+/// <remarks>When there is no nested function f(x) = x</remarks>
+internal record ExpressionTerm(Fraction Coefficient, Fraction Exponent, CustomFunction? NestedFunction = null) : IComparable<ExpressionTerm>, IComparable
+{
+    public bool IsRational => NestedFunction is null && Exponent.Denominator.IsOne;
+
+    public bool IsConstant => NestedFunction is null && Exponent.IsZero;
+
+    public ExpressionTerm Negate()
+    {
+        return this with { Coefficient = Coefficient.Negate() };
+    }
+
+    public ExpressionTerm Invert()
+    {
+        return this with { Exponent = Exponent.Negate(), Coefficient = Coefficient.Reciprocal() };
+    }
+
+    public ExpressionTerm Multiply(ExpressionTerm otherTerm)
+    {
+        if (NestedFunction != null && otherTerm.NestedFunction != null &&
+            NestedFunction != otherTerm.NestedFunction) // there aren't any cases of this in the code-base
+        {
+            throw new NotSupportedException(
+                "Multiplying terms with different functions is currently not supported"); // if we need to, we should use a collection or create some function-composition
+        }
+
+        return new ExpressionTerm(Coefficient * otherTerm.Coefficient, Exponent + otherTerm.Exponent, NestedFunction ?? otherTerm.NestedFunction);
+    }
+
+    public ExpressionTerm Divide(ExpressionTerm otherTerm)
+    {
+        return Multiply(otherTerm.Invert());
+    }
+
+    public static ExpressionTerm Constant(Fraction coefficient)
+    {
+        return new ExpressionTerm(coefficient, Fraction.Zero);
+    }
+
+    #region Overrides of Object
+
+    public override string ToString()
+    {
+        var coefficientFormat = Coefficient == Fraction.One ? "" :
+            Coefficient == Fraction.MinusOne ? "-" : $"{Coefficient.ToDouble()} * ";
+        if (NestedFunction == null)
+        {
+            if (Exponent == Fraction.Zero)
+            {
+                return $"{Coefficient.ToDouble()}";
+            }
+
+            if (Exponent == Fraction.One)
+            {
+                return $"{coefficientFormat}x";
+            }
+
+            return $"{coefficientFormat}x^{Exponent.ToDouble()}";
+        }
+
+        return $"{coefficientFormat}{NestedFunction}";
+    }
+
+    #endregion
+
+    public ExpressionTerm Evaluate(Fraction x)
+    {
+        if (NestedFunction != null || Exponent.IsZero)
+        {
+            return this;
+        }
+
+        return Constant(Coefficient * x.Pow(Exponent));
+    }
+
+    public ExpressionTerm Evaluate(ExpressionTerm term)
+    {
+        if (Exponent.IsZero)
+        {
+            return this;
+        }
+
+        if (NestedFunction == null)
+        {
+            return new ExpressionTerm(Coefficient * term.Coefficient.Pow(Exponent), term.Exponent * Exponent);
+        }
+
+        CompositeExpression nestedTerms = NestedFunction.Terms.Evaluate(term);
+        return this with { NestedFunction = NestedFunction with { Terms = nestedTerms } };
+
+    }
+
+    #region Relational members
+
+    public int CompareTo(ExpressionTerm? other)
+    {
+        if (ReferenceEquals(this, other)) return 0;
+        if (other is null) return 1;
+        var exponentComparison = Exponent.CompareTo(other.Exponent);
+        if (exponentComparison != 0) return exponentComparison;
+        var nestedFunctionComparison = Comparer<CustomFunction?>.Default.Compare(NestedFunction, other.NestedFunction);
+        if (nestedFunctionComparison != 0) return nestedFunctionComparison;
+        return Coefficient.CompareTo(other.Coefficient);
+    }
+
+    public int CompareTo(object? obj)
+    {
+        if (ReferenceEquals(null, obj)) return 1;
+        if (ReferenceEquals(this, obj)) return 0;
+        return obj is ExpressionTerm other ? CompareTo(other) : throw new ArgumentException($"Object must be of type {nameof(ExpressionTerm)}");
+    }
+
+    #endregion
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/Functions/IFunctionEvaluator.cs b/CodeGen/Helpers/ExpressionAnalyzer/Functions/IFunctionEvaluator.cs
new file mode 100644
index 0000000000..fa75d3a0a8
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/Functions/IFunctionEvaluator.cs
@@ -0,0 +1,26 @@
+using System;
+using CodeGen.Helpers.ExpressionAnalyzer.Expressions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer.Functions;
+
+/// <summary>
+///     Defines the contract for a function evaluator that can parse and create expressions.
+/// </summary>
+/// <remarks>
+///     Implementations of this interface are used to evaluate specific mathematical functions.
+/// </remarks>
+internal interface IFunctionEvaluator
+{
+    /// <summary>
+    ///     Gets the name of the function that this evaluator can handle.
+    /// </summary>
+    string FunctionName { get; }
+
+    /// <summary>
+    ///     Parses the given expression and returns a pending term.
+    /// </summary>
+    /// <param name="expressionToParse">The expression to parse.</param>
+    /// <param name="expressionResolver">Can be used to evaluate the function body expression.</param>
+    /// <returns>A <see cref="ExpressionEvaluationTerm" /> that represents the parsed expression.</returns>
+    CompositeExpression CreateExpression(ExpressionEvaluationTerm expressionToParse, Func<ExpressionEvaluationTerm, CompositeExpression> expressionResolver);
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/FractionExtensions.cs b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/FractionExtensions.cs
new file mode 100644
index 0000000000..e4f8b3a736
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/FractionExtensions.cs
@@ -0,0 +1,52 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Numerics;
+using Fractions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer.Functions.Math;
+
+/// <summary>
+///     Adds the Pow(Fraction, Fraction) extension method for the Fraction type, which only supports the integer overload:
+///     Pow(Fraction, int).
+/// </summary>
+internal static class FractionExtensions
+{
+    public static readonly Fraction OneHalf = new(BigInteger.One, new BigInteger(2));
+
+    /// <summary>
+    ///     Raises the specified <paramref name="x" /> to the power of <paramref name="power" />.
+    /// </summary>
+    /// <param name="x">The base <see cref="Fraction" /> to be raised to a power.</param>
+    /// <param name="power">The exponent <see cref="Fraction" /> to which the base is raised.</param>
+    /// <returns>
+    ///     A <see cref="Fraction" /> representing the result of raising <paramref name="x" /> to the power of
+    ///     <paramref name="power" />.
+    /// </returns>
+    /// <remarks>
+    ///     This method supports integer exponents directly. For fractional exponents, it calculates the result using
+    ///     a double-precision approximation, which may lead to a loss of precision.
+    /// </remarks>
+    public static Fraction Pow(this Fraction x, Fraction power)
+    {
+        if (power == Fraction.One)
+        {
+            return x;
+        }
+
+        if (x == Fraction.One)
+        {
+            return x;
+        }
+
+        power = power.Reduce();
+        if (power.Denominator.IsOne)
+        {
+            return Fraction.Pow(x, (int)power);
+        }
+
+        // the only way we could reach this line is if we have a fractional power (e.g. square root), or any other custom expression which does not have an inverse.
+        // there is currently no call that reaches this line, and we should try to keep it this way (avoiding the potential loss of precision)
+        return Fraction.FromDoubleRounded(System.Math.Pow(x.ToDouble(), power.ToDouble()));
+    }
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/MathFunctionEvaluator.cs b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/MathFunctionEvaluator.cs
new file mode 100644
index 0000000000..ec16d1688a
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/MathFunctionEvaluator.cs
@@ -0,0 +1,27 @@
+using System;
+using CodeGen.Helpers.ExpressionAnalyzer.Expressions;
+using Fractions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer.Functions.Math;
+
+internal abstract class MathFunctionEvaluator : IFunctionEvaluator
+{
+    public virtual string Namespace => nameof(System.Math);
+    public abstract string FunctionName { get; }
+
+    public CompositeExpression CreateExpression(ExpressionEvaluationTerm expressionToParse, Func<ExpressionEvaluationTerm, CompositeExpression> expressionResolver)
+    {
+        CompositeExpression functionBody = expressionResolver(expressionToParse with {Exponent = 1});
+        Fraction power = expressionToParse.Exponent;
+        if (functionBody.IsConstant) // constant expression (directly evaluate the function)
+        {
+            var constantTerm = (ExpressionTerm)functionBody;
+            Fraction resultingValue = Evaluate(constantTerm.Coefficient);
+            return ExpressionTerm.Constant(resultingValue.Pow(power));
+        }
+         // we cannot expand a function of x
+        return new ExpressionTerm(1, power, new CustomFunction(Namespace, FunctionName, functionBody));
+    }
+
+    public abstract Fraction Evaluate(Fraction value);
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/PowFunctionEvaluator.cs b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/PowFunctionEvaluator.cs
new file mode 100644
index 0000000000..5c6b9379df
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/PowFunctionEvaluator.cs
@@ -0,0 +1,50 @@
+using System;
+using System.Globalization;
+using CodeGen.Helpers.ExpressionAnalyzer.Expressions;
+using Fractions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer.Functions.Math;
+
+internal class PowFunctionEvaluator : IFunctionEvaluator
+{
+    public string Namespace => nameof(System.Math);
+    public string FunctionName => nameof(System.Math.Pow);
+
+    public bool ExpandNonConstantExpressions { get; set; } = false; // while it's possible to expand the expression (even for non-rational powers)- probably we shouldn't
+
+    public CompositeExpression CreateExpression(ExpressionEvaluationTerm expressionToParse,
+        Func<ExpressionEvaluationTerm, CompositeExpression> expressionResolver)
+    {
+        var functionParams = expressionToParse.Expression.Split(',');
+        if (functionParams.Length != 2 || !FractionHelper.TryParseInvariant(functionParams[1], out Fraction exponentParsed))
+        {
+            throw new FormatException($"The provided string is not in the correct format for the Pow function {expressionToParse}");
+        }
+
+        CompositeExpression functionBody = expressionResolver(new ExpressionEvaluationTerm(functionParams[0], 1));
+        Fraction power = expressionToParse.Exponent * exponentParsed;
+
+        if (functionBody.IsConstant)
+        {
+            var singleTerm = (ExpressionTerm)functionBody;
+            Fraction coefficient = singleTerm.Coefficient.Pow(power);
+            return ExpressionTerm.Constant(coefficient);
+        }
+
+        if (!ExpandNonConstantExpressions)
+        {
+            return new ExpressionTerm(1, 1, new CustomFunction(Namespace, FunctionName, functionBody, power.ToDecimal().ToString(CultureInfo.InvariantCulture)));
+        }
+
+        // while it's possible to expand the expression (even for non-rational powers)- we shouldn't, as the operation would not be reversible: the result of (x^0.5)^2 may be different from x
+        if (functionBody.Terms.Count == 1)
+        {
+            var singleTerm = (ExpressionTerm)functionBody;
+            Fraction coefficient = singleTerm.Coefficient.Pow(power);
+            return singleTerm with { Coefficient = coefficient, Exponent = singleTerm.Exponent * power };
+        }
+
+        // TODO see about handling the multi-term expansion (at least for integer exponents)
+        return new ExpressionTerm(1, 1, new CustomFunction(Namespace, FunctionName, functionBody, power.ToDecimal().ToString(CultureInfo.InvariantCulture)));
+    }
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/SqrtFunctionEvaluator.cs b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/SqrtFunctionEvaluator.cs
new file mode 100644
index 0000000000..152c459dc2
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/SqrtFunctionEvaluator.cs
@@ -0,0 +1,40 @@
+using System;
+using CodeGen.Helpers.ExpressionAnalyzer.Expressions;
+using Fractions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer.Functions.Math;
+
+internal class SqrtFunctionEvaluator : IFunctionEvaluator
+{
+    public string Namespace => nameof(System.Math); // we could switch this to QuantityValue if we decide to add it later
+    public string FunctionName => nameof(System.Math.Sqrt);
+    public bool ExpandNonConstantExpressions { get; set; } = false; // while it's possible to expand the expression (even for non-rational powers)- probably we shouldn't
+    
+    public CompositeExpression CreateExpression(ExpressionEvaluationTerm expressionToParse, Func<ExpressionEvaluationTerm, CompositeExpression> expressionResolver)
+    {
+        CompositeExpression functionBody = expressionResolver(expressionToParse with {Exponent = 1});
+        if (functionBody.IsConstant)
+        {
+            var constantTerm = (ExpressionTerm)functionBody;
+            Fraction coefficient = constantTerm.Coefficient.Pow(expressionToParse.Exponent * FractionExtensions.OneHalf);
+            return ExpressionTerm.Constant(coefficient);
+        }
+        
+        if (!ExpandNonConstantExpressions)
+        {
+            return new ExpressionTerm(1, expressionToParse.Exponent, new CustomFunction(Namespace, FunctionName, functionBody));
+        }
+        
+        // while it's possible to expand the expression (even for non-rational powers)- we shouldn't, as the operation would not be reversible: the result of (x^0.5)^2 may be different from x
+        Fraction power = expressionToParse.Exponent * FractionExtensions.OneHalf;
+        if (functionBody.Terms.Count == 1) 
+        {
+            var constantTerm = (ExpressionTerm)functionBody;
+            Fraction coefficient = constantTerm.Coefficient.Pow(power);
+            return constantTerm with { Coefficient = coefficient, Exponent = constantTerm.Exponent * power };
+        }
+
+        // TODO see about handling the multi-term expansion (at least for integer exponents)
+        return new ExpressionTerm(1, power, new CustomFunction(Namespace, FunctionName, functionBody));
+    }
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/Trigonometry/AsinFunctionEvaluator.cs b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/Trigonometry/AsinFunctionEvaluator.cs
new file mode 100644
index 0000000000..f2110ac629
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/Trigonometry/AsinFunctionEvaluator.cs
@@ -0,0 +1,13 @@
+using Fractions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer.Functions.Math.Trigonometry;
+
+internal class AsinFunctionEvaluator : MathFunctionEvaluator
+{
+    public override string FunctionName => nameof(System.Math.Asin);
+
+    public override Fraction Evaluate(Fraction value)
+    {
+        return Fraction.FromDoubleRounded(System.Math.Asin(value.ToDouble()));
+    }
+}
diff --git a/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/Trigonometry/SinFunctionEvaluator.cs b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/Trigonometry/SinFunctionEvaluator.cs
new file mode 100644
index 0000000000..5bab6b1f96
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionAnalyzer/Functions/Math/Trigonometry/SinFunctionEvaluator.cs
@@ -0,0 +1,13 @@
+using Fractions;
+
+namespace CodeGen.Helpers.ExpressionAnalyzer.Functions.Math.Trigonometry;
+
+internal class SinFunctionEvaluator : MathFunctionEvaluator
+{
+    public override string FunctionName => nameof(System.Math.Sin);
+
+    public override Fraction Evaluate(Fraction value)
+    {
+        return Fraction.FromDoubleRounded(System.Math.Sin(value.ToDouble()));
+    }
+}
diff --git a/CodeGen/Helpers/ExpressionEvaluationHelpers.cs b/CodeGen/Helpers/ExpressionEvaluationHelpers.cs
new file mode 100644
index 0000000000..78b2ad3d36
--- /dev/null
+++ b/CodeGen/Helpers/ExpressionEvaluationHelpers.cs
@@ -0,0 +1,462 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using CodeGen.Helpers.ExpressionAnalyzer;
+using CodeGen.Helpers.ExpressionAnalyzer.Expressions;
+using CodeGen.JsonTypes;
+using Fractions;
+
+namespace CodeGen.Helpers;
+
+internal static class ExpressionEvaluationHelpers
+{
+    private record struct Factor(BigInteger Number, int Power, BigInteger Value)
+    {
+        public static Factor FromNumber(BigInteger number) => new(number, 1, number);
+
+        private sealed class ValueRelationalComparer : IComparer<Factor>
+        {
+            public int Compare(Factor x, Factor y)
+            {
+                return x.Value.CompareTo(y.Value);
+            }
+        }
+
+        public static IComparer<Factor> ValueComparer { get; } = new ValueRelationalComparer();
+    };
+
+    private static List<Factor> ExtractFactors(this BigInteger number)
+    {
+        number = BigInteger.Abs(number);
+        var factors = new List<Factor>();
+        if (number.IsPowerOfTwo)
+        {
+            var exponent = (int)(number.GetBitLength() - 1);
+            var divisor = BigInteger.Pow(2, exponent);
+            factors.Add(new Factor(2, exponent, divisor));
+            return factors;
+        }
+
+        var factorsToTryFirst = new BigInteger[] {10, 2, 3, 5, 7};
+        foreach (BigInteger divisor in factorsToTryFirst)
+        {
+            if (TryGetFactors(number, divisor, out number, out Factor factor))
+            {
+                factors.Add(factor);
+                if (number.IsOne)
+                {
+                    return factors;
+                }
+
+                if (number <= long.MaxValue)
+                {
+                    factors.Add(Factor.FromNumber(number));
+                    return factors;
+                }
+            }
+        }
+
+        BigInteger currentDivisor = 11;
+        do
+        {
+            if (TryGetFactors(number, currentDivisor, out number, out Factor factor))
+            {
+                factors.Add(factor);
+            }
+
+            currentDivisor++;
+        } while (number > long.MaxValue && number > currentDivisor);
+
+        if (!number.IsOne)
+        {
+            factors.Add(Factor.FromNumber(number));
+        }
+
+        return factors;
+    }
+
+    private static bool TryGetFactors(BigInteger number, BigInteger divisor, out BigInteger quotient, out Factor factor)
+    {
+        quotient = number;
+        var power = 0;
+        while (true)
+        {
+            var nextQuotient = BigInteger.DivRem(quotient, divisor, out BigInteger remainder);
+            if (remainder.IsZero)
+            {
+                quotient = nextQuotient;
+                power++;
+            }
+            else
+            {
+                factor = new Factor(divisor, power, BigInteger.Pow(divisor, power));
+                return power > 0;
+            }
+        }
+    }
+
+    private static SortedSet<Factor> MergeFactors(this IEnumerable<Factor> factorsToMerge)
+    {
+        var factors = new SortedSet<Factor>(factorsToMerge, Factor.ValueComparer);
+        while (factors.Count > 1)
+        {
+            // try to merge the next two factors
+            Factor smallestFactor = factors.First();
+            Factor secondSmallestFactor = factors.Skip(1).First();
+            var mergedFactor = Factor.FromNumber(smallestFactor.Value * secondSmallestFactor.Value);
+            if (mergedFactor.Value > long.MaxValue)
+            {
+                return factors; // we've got the smallest possible set
+            }
+
+            // replace the two factors with their merged version
+            factors.Remove(smallestFactor);
+            factors.Remove(secondSmallestFactor);
+            factors.Add(mergedFactor);
+        }
+
+        return factors;
+    }
+
+    private static string GetConstantFormat(this Factor factor)
+    {
+        if (factor.Power == 1)
+        {
+            return $"new BigInteger({factor.Value})";
+        }
+        else if (factor.Number == 10)
+        {
+            return $"QuantityValue.PowerOfTen({factor.Power})";
+        }
+        else
+        {
+            return $"BigInteger.Pow({factor.Number}, {factor.Power})";
+        }
+    }
+
+    private static string GetConstantMultiplicationFormat(this IEnumerable<Factor> factors, bool negate = false)
+    {
+        var expression = string.Join(" * ", factors.Select(x => x.GetConstantFormat()));
+        if (negate)
+        {
+            expression = "-" + expression;
+        }
+
+        return expression;
+    }
+
+    private static string GetConstantFormat(this Fraction coefficient)
+    {
+        if (coefficient == Fraction.One)
+        {
+            return "1";
+        }
+
+        return coefficient.Denominator.IsOne
+            ? coefficient.Numerator.ToString()
+            : $"new QuantityValue({coefficient.Numerator}, {coefficient.Denominator})";
+    }
+
+    private static string GetLongConstantFormat(this Fraction coefficient)
+    {
+        var numeratorExpression = coefficient.Numerator > long.MaxValue || coefficient.Numerator < long.MinValue
+            ? coefficient.Numerator.ExtractFactors().MergeFactors().GetConstantMultiplicationFormat(coefficient.IsNegative)
+            : coefficient.Numerator.ToString();
+        var denominatorExpression = coefficient.Denominator > long.MaxValue
+            ? coefficient.Denominator.ExtractFactors().MergeFactors().GetConstantMultiplicationFormat()
+            : coefficient.Denominator.ToString();
+        var expandedExpression = $"new QuantityValue({numeratorExpression}, {denominatorExpression})";
+        return expandedExpression;
+    }
+
+    private static string GetFractionalConstantFormat(this Fraction coefficient)
+    {
+        coefficient = coefficient.Reduce();
+        // making sure that neither the Numerator nor the Denominator contain a value that cannot be represented as a compiler constant
+        if (coefficient.Numerator >= long.MinValue && coefficient.Numerator <= long.MaxValue && coefficient.Denominator <= long.MaxValue)
+        {
+            return coefficient.GetConstantFormat();
+        }
+
+        // need to represent the fraction in terms of two terms: "a * b"
+        return coefficient.GetLongConstantFormat();
+    }
+
+    private static string GetConstantExpression(this Fraction coefficient, string csharpParameter)
+    {
+        if (coefficient == Fraction.One)
+        {
+            return csharpParameter;
+        }
+
+        if (coefficient.Denominator.IsOne)
+        {
+            return $"{csharpParameter} * {coefficient.Numerator}";
+        }
+
+        if (coefficient.Numerator.IsOne)
+        {
+            return $"{csharpParameter} / {coefficient.Denominator}";
+        }
+
+        if (coefficient.Numerator == BigInteger.MinusOne)
+        {
+            return $"{csharpParameter} / -{coefficient.Denominator}";
+        }
+
+        return $"{csharpParameter} * new QuantityValue({coefficient.Numerator}, {coefficient.Denominator})";
+    }
+
+    private static string GetFractionalExpressionFormat(this Fraction coefficient, string csharpParameter)
+    {
+        coefficient = coefficient.Reduce();
+        // making sure that neither the Numerator nor the Denominator contain a value that cannot be represented as a compiler constant
+        if (coefficient.Numerator >= long.MinValue && coefficient.Numerator <= long.MaxValue && coefficient.Denominator <= long.MaxValue)
+        {
+            return coefficient.GetConstantExpression(csharpParameter);
+        }
+
+        // need to represent the fraction in terms of two (or more) terms: "x * a * b"
+        return $"{csharpParameter} * {coefficient.GetLongConstantFormat()}";
+    }
+
+
+    public static string GetExpressionFormat(this CustomFunction customFunction, string csharpParameter)
+    {
+        // TODO see about redirecting these to a static method in the quantity's class which is responsible for handling the required operations (efficiently)
+        var mainArgument = $"({customFunction.Terms.GetExpressionFormat(csharpParameter)}).ToDouble()";
+        var functionArguments = string.Join(", ", customFunction.AdditionalParameters.Prepend(mainArgument));
+        return $"QuantityValue.FromDoubleRounded({customFunction.Namespace}.{customFunction.Name}({functionArguments}))";
+    }
+
+    public static string GetConstantExpressionFormat(this CustomFunction customFunction)
+    {
+        // TODO see about redirecting these to a static method in the quantity's class which is responsible for handling the required operations (efficiently)
+        var functionArguments = string.Join(", ", customFunction.AdditionalParameters);
+        return $"QuantityValue.FromDoubleRounded({customFunction.Namespace}.{customFunction.Name}({functionArguments}))";
+    }
+
+    public static string GetExponentFormat(this Fraction exponent, string csharpParameter)
+    {
+        if (exponent == Fraction.One)
+        {
+            return csharpParameter;
+        }
+
+        // alternatively this could be an operator: e.g. $"({csharpParameter} ^ {exponent.ToInt32()})"
+        return exponent.Denominator.IsOne
+            ? $"QuantityValue.Pow({csharpParameter}, {exponent.ToInt32()})"
+            : $"QuantityValue.FromDoubleRounded(Math.Pow({csharpParameter}.ToDouble(), {exponent.ToDouble()}))";
+    }
+
+    public static string GetExpressionFormat(this ExpressionTerm term, string csharpParameter)
+    {
+        if (term.IsConstant)
+        {
+            return term.Coefficient.GetFractionalConstantFormat();
+        }
+
+        if (term is { NestedFunction: not null, Exponent.IsZero: true })
+        {
+            return term.NestedFunction.GetConstantExpressionFormat();
+        }
+
+        var expressionFormat = term.NestedFunction is null ? csharpParameter : term.NestedFunction.GetExpressionFormat(csharpParameter);
+        return term.Coefficient.GetFractionalExpressionFormat(term.Exponent.GetExponentFormat(expressionFormat));
+    }
+
+    public static string GetExpressionFormat(this CompositeExpression expression, string csharpParameter)
+    {
+        return string.Join(" + ", expression.Terms.Select(x => x.GetExpressionFormat(csharpParameter)));
+    }
+
+    private static string GetStringExpression(string expression, string csharpParameter, string jsonParameter = "{x}")
+    {
+        CompositeExpression compositeExpression = ExpressionEvaluator.Evaluate(expression, jsonParameter);
+        var expectedFormat = compositeExpression.GetExpressionFormat(csharpParameter);
+        return expectedFormat;
+    }
+
+    public static string GetConversionExpressionFormat(this CompositeExpression expression, string csharpParameter = "value")
+    {
+        string? coefficientTermFormat = null;
+        string? exponentFormat = null;
+        string? customConversionFunctionFormat = null;
+        string? constantTermValue = null;
+
+        foreach (ExpressionTerm expressionTerm in expression.Terms)
+        {
+            if (expressionTerm.IsConstant)
+            {
+                constantTermValue = expressionTerm.Coefficient.GetFractionalConstantFormat();
+            }
+            else if (expressionTerm.Exponent == 0)
+            {
+                throw new InvalidOperationException("The ConversionExpression class does not support custom functions as the constant term.");
+            }
+            else
+            {
+                if (coefficientTermFormat is not null || exponentFormat is not null || customConversionFunctionFormat is not null)
+                {
+                    throw new InvalidOperationException("The ConversionExpression class does not support more than 2 terms");
+                }
+
+                coefficientTermFormat = expressionTerm.Coefficient.GetFractionalConstantFormat();
+
+                if (expressionTerm.NestedFunction is not null)
+                {
+                    customConversionFunctionFormat = expressionTerm.NestedFunction.GetExpressionFormat(csharpParameter);
+                }
+
+                if (expressionTerm.Exponent == Fraction.One)
+                {
+                    continue;
+                }
+
+                if (expressionTerm.Exponent.Denominator.IsOne)
+                {
+                    exponentFormat = expressionTerm.Exponent.Numerator.ToString();
+                }
+                else if (customConversionFunctionFormat is null)
+                {
+                    customConversionFunctionFormat = expressionTerm.Exponent.GetExponentFormat(csharpParameter);
+                }
+                else // create a composition between the two functions
+                {
+                    customConversionFunctionFormat = expressionTerm.Exponent.GetExponentFormat(customConversionFunctionFormat);
+                }
+            }
+        }
+
+        coefficientTermFormat ??= "1";
+
+        if (constantTermValue is not null && exponentFormat is null && customConversionFunctionFormat is null)
+        {
+            return $"new ConversionExpression(coefficient: {coefficientTermFormat}, constantTerm: {constantTermValue})";
+        }
+
+        if (customConversionFunctionFormat is not null)
+        {
+            return $"new ConversionExpression(coefficient: {coefficientTermFormat}, nestedFunction: {csharpParameter} => {customConversionFunctionFormat}, exponent: {exponentFormat ?? "1"}, constantTerm: {constantTermValue ?? "0"})";
+        }
+
+        if (constantTermValue is not null)
+        {
+            return $"new ConversionExpression(coefficient: {coefficientTermFormat}, exponent: {exponentFormat ?? "1"}, constantTerm: {constantTermValue})";
+        }
+
+        if (exponentFormat is not null)
+        {
+            return $"new ConversionExpression(coefficient: {coefficientTermFormat}, exponent: {exponentFormat})";
+        }
+
+        // using the implicit constructor from QuantityValue, which is equivalent to "new ConversionExpression({coefficientTermFormat})"
+        return coefficientTermFormat; 
+    }
+
+    private static string GetConversionExpressionFormat(string expression, string csharpParameter = "value", string jsonParameter = "{x}")
+    {
+        CompositeExpression compositeExpression = ExpressionEvaluator.Evaluate(expression, jsonParameter);
+        var expectedFormat = compositeExpression.GetConversionExpressionFormat(csharpParameter);
+        return expectedFormat;
+    }
+
+    /// <summary>
+    ///     Gets the format of the conversion from the unit to the base unit.
+    /// </summary>
+    /// <param name="unit">The unit for which to get the conversion format.</param>
+    /// <param name="csharpParameter">The C# parameter to be used in the conversion expression.</param>
+    /// <returns>A string representing the format of the conversion from the unit to the base unit.</returns>
+    internal static string GetUnitToBaseConversionFormat(this Unit unit, string csharpParameter = "value")
+    {
+        return GetStringExpression(unit.FromUnitToBaseFunc, csharpParameter);
+    }
+
+    /// <summary>
+    ///     Gets the format of the conversion from the base unit to the specified unit.
+    /// </summary>
+    /// <param name="unit">The unit to which the conversion format is to be obtained.</param>
+    /// <param name="csharpParameter">The C# parameter to be used in the conversion expression.</param>
+    /// <returns>A string representing the format of the conversion from the base unit to the specified unit.</returns>
+    internal static string GetFromBaseToUnitConversionFormat(this Unit unit, string csharpParameter = "value")
+    {
+        return GetStringExpression(unit.FromBaseToUnitFunc, csharpParameter);
+    }
+
+    /// <summary>
+    ///     Gets the format of the conversion from the unit to the base unit using a <c>ConversionExpression</c>.
+    /// </summary>
+    /// <param name="unit">The unit for which to get the conversion format.</param>
+    /// <param name="csharpParameter">The C# parameter to be used in the conversion expression.</param>
+    /// <returns>A string representing the constructor of a <c>ConversionExpression</c> from the unit to the base unit.</returns>
+    internal static string GetUnitToBaseConversionExpressionFormat(this Unit unit, string csharpParameter = "value")
+    {
+        return GetConversionExpressionFormat(unit.FromUnitToBaseFunc, csharpParameter);
+    }
+
+    /// <summary>
+    ///     Gets the format of the conversion from the base unit to the specified unit using a <c>ConversionExpression</c>.
+    /// </summary>
+    /// <param name="unit">The unit to which the conversion format is to be obtained.</param>
+    /// <param name="csharpParameter">The C# parameter to be used in the conversion expression.</param>
+    /// <returns>A string representing the constructor of a <c>ConversionExpression</c> from the base unit to the specified unit.</returns>
+    internal static string GetFromBaseToUnitConversionExpressionFormat(this Unit unit, string csharpParameter = "value")
+    {
+        return GetConversionExpressionFormat(unit.FromBaseToUnitFunc, csharpParameter);
+    }
+
+    /// <summary>
+    ///     Generates a dictionary of conversion expressions for a given quantity, mapping each unit to its conversion
+    ///     expressions with other units.
+    /// </summary>
+    /// <param name="quantity">The quantity for which conversion expressions are generated.</param>
+    /// <param name="jsonParameter">
+    ///     An optional JSON parameter used in the evaluation of conversion expressions. Defaults to
+    ///     "{x}".
+    /// </param>
+    /// <returns>
+    ///     A dictionary where each key is a unit and the value is another dictionary mapping other units to their
+    ///     respective conversion expressions.
+    /// </returns>
+    /// <exception cref="InvalidOperationException">
+    ///     Thrown if the calculated conversion expression does not match the expected
+    ///     conversion expression.
+    /// </exception>
+    internal static Dictionary<Unit, Dictionary<Unit, CompositeExpression>> GetConversionExpressions(this Quantity quantity, string jsonParameter = "{x}")
+    {
+        var conversionsFromBase = new Dictionary<Unit, CompositeExpression>();
+        var conversionsToBase = new Dictionary<Unit, CompositeExpression>();
+        Unit baseUnit = quantity.Units.First(unit => unit.SingularName == quantity.BaseUnit);
+        foreach (Unit unit in quantity.Units)
+        {
+            if (unit == baseUnit) continue;
+            CompositeExpression conversionFromBase = conversionsFromBase[unit] = ExpressionEvaluator.Evaluate(unit.FromBaseToUnitFunc, jsonParameter);
+            if (conversionFromBase.Terms.Count == 1 && conversionFromBase.Degree.Abs() == Fraction.One)
+            {
+                // as long as there aren't any complex functions we can just invert the expression
+                conversionsToBase[unit] = conversionFromBase.SolveForY();
+            }
+            else
+            {
+                // complex conversion functions require an explicit expression in both directions
+                conversionsToBase[unit] = ExpressionEvaluator.Evaluate(unit.FromUnitToBaseFunc, jsonParameter);
+            }
+        }
+
+        var conversionsFrom = new Dictionary<Unit, Dictionary<Unit, CompositeExpression>> { [baseUnit] = conversionsToBase };
+        foreach ((Unit fromUnit, CompositeExpression expressionFromBase) in conversionsFromBase)
+        {
+            Dictionary<Unit, CompositeExpression> fromUnitConversion = conversionsFrom[fromUnit] = new Dictionary<Unit, CompositeExpression>();
+            foreach ((Unit otherUnit, CompositeExpression expressionToBase) in conversionsToBase)
+            {
+                if (fromUnit == otherUnit) continue;
+                fromUnitConversion[otherUnit] = expressionFromBase.Evaluate(expressionToBase);
+            }
+
+            fromUnitConversion[baseUnit] = conversionsFromBase[fromUnit];
+        }
+
+        return conversionsFrom;
+    }
+}
diff --git a/CodeGen/Helpers/FileInfoExtensions.cs b/CodeGen/Helpers/FileInfoExtensions.cs
index a1eeeff9cd..b67cbc895e 100644
--- a/CodeGen/Helpers/FileInfoExtensions.cs
+++ b/CodeGen/Helpers/FileInfoExtensions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -15,8 +15,8 @@ public static void EditFile(
             Dictionary<string, string> replacements)
         {
             var tempFilename = $"{sourceFile.FullName}.edited";
-            using (StreamReader input = sourceFile.OpenText())
-            using (var output = new StreamWriter(tempFilename))
+            using (StreamReader input = CodeGenFile.OpenText(sourceFile.FullName))
+            using (var output = CodeGenFile.CreateText(tempFilename))
             {
                 while (input.ReadLine() is { } line)
                 {
@@ -40,8 +40,6 @@ public static void EditFile(
                     }
 
                     // Make sure all line endings on Windows are CRLF.
-                    // This is important for opening .nfproj flies in Visual Studio,
-                    // and maybe for some other files too.
                     line = line.Replace("\r", "").Replace("\n", Environment.NewLine);
 
                     output.WriteLine(line);
diff --git a/CodeGen/Helpers/FractionHelper.cs b/CodeGen/Helpers/FractionHelper.cs
new file mode 100644
index 0000000000..0573c5b436
--- /dev/null
+++ b/CodeGen/Helpers/FractionHelper.cs
@@ -0,0 +1,37 @@
+using System.Globalization;
+using Fractions;
+
+namespace CodeGen.Helpers;
+
+/// <summary>
+/// Helper methods for parsing Fraction values with culture-invariant formatting.
+/// </summary>
+internal static class FractionHelper
+{
+    /// <summary>
+    /// Attempts to parse a string representation of a number into a normalized Fraction, using invariant culture.<br />
+    /// It supports various number formats including integers, floating point, and scientific notation.
+    /// </summary>
+    /// <param name="value">The string representation of the number to parse.</param>
+    /// <param name="result">When this method returns, contains the Fraction equivalent of the number contained in value, if the conversion succeeded, or default if the conversion failed.</param>
+    /// <returns>true if value was converted successfully; otherwise, false.</returns>
+    /// <remarks>
+    /// The fraction is normalized, e.g. "2/4" is reduced to "1/2".
+    /// <br />
+    /// This method uses NumberStyles.Number | NumberStyles.Float to support:
+    /// - Integers: "42", "-123"
+    /// - Floating point: "3.14", "-2.5"
+    /// - Scientific notation: "1.5e3", "2.5E-4"
+    /// - Leading/trailing whitespace
+    ///
+    /// All parsing uses InvariantCulture to ensure consistent behavior regardless of system culture settings.
+    /// </remarks>
+    public static bool TryParseInvariant(string value, out Fraction result)
+    {
+        return Fraction.TryParse(
+            value,
+            NumberStyles.Number | NumberStyles.Float,
+            CultureInfo.InvariantCulture,
+            out result);
+    }
+}
diff --git a/CodeGen/Helpers/HashGuid.cs b/CodeGen/Helpers/HashGuid.cs
index 841af59878..7e8271e02f 100644
--- a/CodeGen/Helpers/HashGuid.cs
+++ b/CodeGen/Helpers/HashGuid.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/CodeGen/Helpers/PrefixBuilder/BaseUnitPrefix.cs b/CodeGen/Helpers/PrefixBuilder/BaseUnitPrefix.cs
index c73ee0106b..56c63d7fe0 100644
--- a/CodeGen/Helpers/PrefixBuilder/BaseUnitPrefix.cs
+++ b/CodeGen/Helpers/PrefixBuilder/BaseUnitPrefix.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using CodeGen.JsonTypes;
diff --git a/CodeGen/Helpers/PrefixBuilder/BaseUnitPrefixes.cs b/CodeGen/Helpers/PrefixBuilder/BaseUnitPrefixes.cs
index 2822de4fc0..fb908be08f 100644
--- a/CodeGen/Helpers/PrefixBuilder/BaseUnitPrefixes.cs
+++ b/CodeGen/Helpers/PrefixBuilder/BaseUnitPrefixes.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Collections.Generic;
diff --git a/CodeGen/Helpers/PrefixBuilder/PrefixBuilderExtensions.cs b/CodeGen/Helpers/PrefixBuilder/PrefixBuilderExtensions.cs
index a39c526ffa..955dadf546 100644
--- a/CodeGen/Helpers/PrefixBuilder/PrefixBuilderExtensions.cs
+++ b/CodeGen/Helpers/PrefixBuilder/PrefixBuilderExtensions.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/CodeGen/Helpers/PrefixBuilder/UnitPrefixBuilder.cs b/CodeGen/Helpers/PrefixBuilder/UnitPrefixBuilder.cs
index 7ef1a63139..bea51f59d4 100644
--- a/CodeGen/Helpers/PrefixBuilder/UnitPrefixBuilder.cs
+++ b/CodeGen/Helpers/PrefixBuilder/UnitPrefixBuilder.cs
@@ -1,10 +1,12 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Text.RegularExpressions;
+using CodeGen.Exceptions;
 using CodeGen.JsonTypes;
 
 namespace CodeGen.Helpers.PrefixBuilder;
@@ -18,6 +20,21 @@ namespace CodeGen.Helpers.PrefixBuilder;
 /// </remarks>
 internal class UnitPrefixBuilder
 {
+    /// <summary>
+    ///     Matches abbreviations whose leading unit token is raised to the second, third, or fourth power using a
+    ///     superscript or caret, such as <c>m²</c>, <c>ft³/s</c>, or <c>m^4</c>.
+    /// </summary>
+    /// <remarks>
+    ///     This is intentionally not a general unit-expression parser. It does not match a power in a denominator or later
+    ///     compound term (<c>kg/m³</c>, <c>m/s²</c>, or <c>N·m²</c>), a leading numeric scale factor
+    ///     (<c>10³·m³</c>), parenthesized or implicit powers, or powers other than two through four. These cases do not put
+    ///     a metric prefix directly before an explicitly powered leading unit token, or are outside the scope of this
+    ///     heuristic. Unit names starting with <c>Square</c> or <c>Cubic</c> are checked separately.
+    /// </remarks>
+    private static readonly Regex LeadingPoweredUnitAbbreviationRegex = new(
+        @"^[^\s/·*()\-\d]+(?:[²³⁴]|\^[234])",
+        RegexOptions.Compiled | RegexOptions.CultureInvariant);
+
     private readonly BaseUnitPrefixes _prefixes;
 
     /// <summary>
@@ -45,6 +62,9 @@ public UnitPrefixBuilder(BaseUnitPrefixes prefixes)
     /// <exception cref="System.Exception">
     ///     Thrown when an error occurs while processing a prefix for a unit, such as an invalid prefix or unit configuration.
     /// </exception>
+    /// <exception cref="UnitsNetCodeGenException">
+    ///     Thrown when prefixes are configured for a unit that looks like a powered unit.
+    /// </exception>
     /// <remarks>
     ///     This method iterates through the existing units of the specified <see cref="Quantity" /> and applies each defined
     ///     prefix to generate new prefixed units. It ensures that the singular and plural names, conversion functions,
@@ -54,34 +74,86 @@ public List<Unit> GeneratePrefixUnits(Quantity quantity)
     {
         var unitsToAdd = new List<Unit>();
         foreach (Unit unit in quantity.Units)
-        foreach (Prefix prefix in unit.Prefixes)
         {
-            try
+            if (!unit.Prefixes.Any())
             {
-                PrefixInfo prefixInfo = PrefixInfo.Entries[prefix];
-
-                unitsToAdd.Add(new Unit
-                {
-                    SingularName = $"{prefix}{unit.SingularName.ToCamelCase()}", // "Kilo" + "NewtonPerMeter" => "KilonewtonPerMeter"
-                    PluralName = $"{prefix}{unit.PluralName.ToCamelCase()}", // "Kilo" + "NewtonsPerMeter" => "KilonewtonsPerMeter"
-                    BaseUnits = GetPrefixedBaseUnits(quantity.BaseDimensions, unit.BaseUnits, prefixInfo),
-                    FromBaseToUnitFunc = $"({unit.FromBaseToUnitFunc}) / {prefixInfo.Factor}",
-                    FromUnitToBaseFunc = $"({unit.FromUnitToBaseFunc}) * {prefixInfo.Factor}",
-                    Localization = GetLocalizationForPrefixUnit(unit.Localization, prefixInfo),
-                    ObsoleteText = unit.ObsoleteText,
-                    SkipConversionGeneration = unit.SkipConversionGeneration,
-                    AllowAbbreviationLookup = unit.AllowAbbreviationLookup
-                });
+                continue;
             }
-            catch (Exception e)
+
+            ThrowIfPrefixesAreUnsafeForPoweredUnit(quantity, unit);
+
+            foreach (Prefix prefix in unit.Prefixes)
             {
-                throw new Exception($"Error parsing prefix {prefix} for unit {quantity.Name}.{unit.SingularName}.", e);
+                try
+                {
+                    PrefixInfo prefixInfo = PrefixInfo.Entries[prefix];
+
+                    unitsToAdd.Add(new Unit
+                    {
+                        SingularName = $"{prefix}{unit.SingularName.ToCamelCase()}", // "Kilo" + "NewtonPerMeter" => "KilonewtonPerMeter"
+                        PluralName = $"{prefix}{unit.PluralName.ToCamelCase()}", // "Kilo" + "NewtonsPerMeter" => "KilonewtonsPerMeter"
+                        BaseUnits = GetPrefixedBaseUnits(quantity.BaseDimensions, unit.BaseUnits, prefixInfo),
+                        FromBaseToUnitFunc = $"({unit.FromBaseToUnitFunc}) / {prefixInfo.Factor}",
+                        FromUnitToBaseFunc = $"({unit.FromUnitToBaseFunc}) * {prefixInfo.Factor}",
+                        Localization = GetLocalizationForPrefixUnit(unit.Localization, prefixInfo),
+                        ObsoleteText = unit.ObsoleteText,
+                        SkipConversionGeneration = unit.SkipConversionGeneration,
+                        AllowAbbreviationLookup = unit.AllowAbbreviationLookup
+                    });
+                }
+                catch (Exception e)
+                {
+                    throw new Exception($"Error parsing prefix {prefix} for unit {quantity.Name}.{unit.SingularName}.", e);
+                }
             }
         }
 
         return unitsToAdd;
     }
 
+    /// <summary>
+    ///     Prevents automatic prefixes from being applied to units that appear to represent a directly powered unit.
+    /// </summary>
+    /// <param name="quantity">The quantity that defines the unit.</param>
+    /// <param name="unit">The unit configured with one or more automatic prefixes.</param>
+    /// <exception cref="UnitsNetCodeGenException">
+    ///     Thrown when the unit name starts with <c>Square</c> or <c>Cubic</c>, or when one of its abbreviations starts with
+    ///     a unit token raised to the second, third, or fourth power.
+    /// </exception>
+    /// <remarks>
+    ///     Mechanically prefixing a powered unit can produce a misleading abbreviation. For example, prefixing
+    ///     <c>CubicMeter</c> with <c>Kilo</c> produces <c>km³</c>, which means cubic kilometer rather than one thousand
+    ///     cubic meters. This guard uses unit names and <see cref="LeadingPoweredUnitAbbreviationRegex" /> as a focused
+    ///     heuristic. It intentionally does not inspect base dimensions, since valid derived units such as watt and joule
+    ///     have powered dimensions but can safely use automatic prefixes.
+    /// </remarks>
+    private static void ThrowIfPrefixesAreUnsafeForPoweredUnit(Quantity quantity, Unit unit)
+    {
+        if (!LooksLikePoweredUnit(unit))
+        {
+            return;
+        }
+
+        throw new UnitsNetCodeGenException(
+            $"Prefixes cannot be used on {quantity.Name}.{unit.SingularName} because it looks like a powered unit. " +
+            "Define explicit units instead, such as CubicKilometer for km³ or ThousandCubicMeter for 1000 m³.");
+    }
+
+    private static bool LooksLikePoweredUnit(Unit unit)
+    {
+        // This intentionally checks naming conventions rather than dimensions, since derived units such as Watt, Joule,
+        // and Ohm have powered base dimensions and safely support prefixes.
+        if (unit.SingularName.StartsWith("Square", StringComparison.Ordinal) ||
+            unit.SingularName.StartsWith("Cubic", StringComparison.Ordinal))
+        {
+            return true;
+        }
+
+        return unit.Localization
+            .SelectMany(localization => localization.Abbreviations)
+            .Any(abbreviation => LeadingPoweredUnitAbbreviationRegex.IsMatch(abbreviation));
+    }
+
     /// <summary>
     ///     Applies a metric prefix to the specified base units based on the given dimensions and prefix information.
     /// </summary>
diff --git a/CodeGen/Helpers/UnitEnumValueAllocation/QuantityNameToUnitEnumValues.cs b/CodeGen/Helpers/UnitEnumValueAllocation/QuantityNameToUnitEnumValues.cs
index bc5071ebdd..10f84ccb09 100644
--- a/CodeGen/Helpers/UnitEnumValueAllocation/QuantityNameToUnitEnumValues.cs
+++ b/CodeGen/Helpers/UnitEnumValueAllocation/QuantityNameToUnitEnumValues.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Collections.Generic;
diff --git a/CodeGen/Helpers/UnitEnumValueAllocation/UnitEnumValueAllocator.cs b/CodeGen/Helpers/UnitEnumValueAllocation/UnitEnumValueAllocator.cs
index 5fd3f51ef1..e8be991564 100644
--- a/CodeGen/Helpers/UnitEnumValueAllocation/UnitEnumValueAllocator.cs
+++ b/CodeGen/Helpers/UnitEnumValueAllocation/UnitEnumValueAllocator.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -9,6 +9,7 @@
 using System.Text.Json;
 using CodeGen.Exceptions;
 using CodeGen.JsonTypes;
+using CodeGen.Helpers;
 using Serilog;
 
 namespace CodeGen.Helpers.UnitEnumValueAllocation
@@ -150,7 +151,7 @@ private void SaveToFile()
 ");
 
             fileContentStringBuilder.AppendLine(JsonSerializer.Serialize(_quantityNameToUnitEnumValues, JsonOptions));
-            File.WriteAllText(_jsonFile, fileContentStringBuilder.ToString());
+            CodeGenFile.WriteAllText(_jsonFile, fileContentStringBuilder.ToString());
         }
 
         /// <summary>
@@ -162,7 +163,7 @@ private static QuantityNameToUnitEnumValues ReadFromFile(string jsonFile)
         {
             if (File.Exists(jsonFile))
             {
-                return JsonSerializer.Deserialize<QuantityNameToUnitEnumValues>(File.ReadAllText(jsonFile), JsonOptions)
+                return JsonSerializer.Deserialize<QuantityNameToUnitEnumValues>(CodeGenFile.ReadAllText(jsonFile), JsonOptions)
                        ?? throw new InvalidOperationException($"Failed to deserialize file: {jsonFile}");
             }
 
diff --git a/CodeGen/JsonTypes/BaseDimensions.cs b/CodeGen/JsonTypes/BaseDimensions.cs
index 59f9389505..91b4df07a3 100644
--- a/CodeGen/JsonTypes/BaseDimensions.cs
+++ b/CodeGen/JsonTypes/BaseDimensions.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Text;
@@ -54,10 +54,10 @@ private static void AppendDimensionString(StringBuilder sb, string name, int val
                 case 0:
                     return;
                 case 1:
-                    sb.AppendFormat("[{0}]", name);
+                    sb.Append(name);
                     break;
                 default:
-                    sb.AppendFormat("[{0}^{1}]", name, value);
+                    sb.Append($"{name}^{value}");
                     break;
             }
         }
diff --git a/CodeGen/JsonTypes/Quantity.cs b/CodeGen/JsonTypes/Quantity.cs
index 3ac77e59ce..f416859912 100644
--- a/CodeGen/JsonTypes/Quantity.cs
+++ b/CodeGen/JsonTypes/Quantity.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/CodeGen/JsonTypes/QuantityRelation.cs b/CodeGen/JsonTypes/QuantityRelation.cs
index 35e97a6bc0..34e6711ac5 100644
--- a/CodeGen/JsonTypes/QuantityRelation.cs
+++ b/CodeGen/JsonTypes/QuantityRelation.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/CodeGen/JsonTypes/Unit.cs b/CodeGen/JsonTypes/Unit.cs
index 982dd5a887..aef1127ee6 100644
--- a/CodeGen/JsonTypes/Unit.cs
+++ b/CodeGen/JsonTypes/Unit.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/CodeGen/PrefixInfo.cs b/CodeGen/PrefixInfo.cs
index e44c643c48..f63dc03ceb 100644
--- a/CodeGen/PrefixInfo.cs
+++ b/CodeGen/PrefixInfo.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using CodeGen.JsonTypes;
diff --git a/CodeGen/Program.cs b/CodeGen/Program.cs
index 31038895de..b82d3caa60 100644
--- a/CodeGen/Program.cs
+++ b/CodeGen/Program.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
@@ -43,9 +43,7 @@ public class Program
         /// </remarks>
         /// <param name="verbose">Verbose output? Defaults to false.</param>
         /// <param name="repositoryRoot">The repository root directory, defaults to searching parent directories for UnitsNet.sln.</param>
-        /// <param name="skipNanoFramework">Skip generate nanoFramework Units? Defaults to false</param>
-        /// <param name="updateNanoFrameworkDependencies">Update nanoFramework nuget dependencies? Defaults to false.</param>
-        public static int Main(bool verbose = false, DirectoryInfo? repositoryRoot = null, bool skipNanoFramework = false, bool updateNanoFrameworkDependencies = false)
+        public static int Main(bool verbose = false, DirectoryInfo? repositoryRoot = null)
         {
             Log.Logger = new LoggerConfiguration()
                 .WriteTo
@@ -73,22 +71,6 @@ public static int Main(bool verbose = false, DirectoryInfo? repositoryRoot = nul
 
                 UnitsNetGenerator.Generate(rootDir, quantities, quantityNameToUnitEnumValues);
 
-                if (updateNanoFrameworkDependencies)
-                {
-                    if (!NanoFrameworkGenerator.UpdateNanoFrameworkDependencies(
-                        rootDir,
-                        quantities))
-                    {
-                        return 1;
-                    }
-                }
-
-                if (!skipNanoFramework)
-                {
-                    Log.Information("Generate nanoFramework projects\n---");
-                    NanoFrameworkGenerator.Generate(rootDir, quantities, quantityNameToUnitEnumValues);
-                }
-
                 Log.Information("Completed in {ElapsedMs} ms!", sw.ElapsedMilliseconds);
                 return 0;
             }
diff --git a/CodeGen/README.md b/CodeGen/README.md
index ae011f55af..2e25af4925 100644
--- a/CodeGen/README.md
+++ b/CodeGen/README.md
@@ -34,11 +34,3 @@ CodeGen.exe --ver
 
 Hit TAB and it should now suggest `--version` and `--verbose` parameters.
 This should work with any .exe that is compiled with Dragonfruit's app model.
-
-## nanoFramework
-
-.NET [nanoFramework](https://github.com/nanoframework/Home) goal is to be a platform that enables the writing of managed code applications for constrained embedded devices. Developers can harness the familiar IDE Visual Studio and their .NET (C#) knowledge to quickly write applications without having to worry about the low level hardware intricacies of a micro-controller. Examples of supported micro controllers are ESP32, STM32F429I, ST Nuclea64, TI CC3220SF and more! The pleasure of .NET where everyone is usually writing in C/C++.
-
-By default, the code generator will as well generate automatically 1 project per Quantity.
-
-You can load all the projects at once using the automatically generated solution ```UnitsNet.nanoFramework.sln```
diff --git a/Common/UnitDefinitions/AreaDensity.json b/Common/UnitDefinitions/AreaDensity.json
index 4e66410de6..9c70feda53 100644
--- a/Common/UnitDefinitions/AreaDensity.json
+++ b/Common/UnitDefinitions/AreaDensity.json
@@ -56,6 +56,38 @@
           "Abbreviations": [ "mg/m²" ]
         }
       ]
+    },
+    {
+      "SingularName": "PoundPerSquareFoot",
+      "PluralName": "PoundsPerSquareFoot",
+      "BaseUnits": {
+        "L": "Foot",
+        "M": "Pound"
+      },
+      "FromUnitToBaseFunc": "{x} * (0.45359237 / 0.09290304)",
+      "FromBaseToUnitFunc": "{x} / (0.45359237 / 0.09290304)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "lb/ft²", "lbs/ft²", "lb/SF", "lbs/SF" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "PoundPerThousandSquareFeet",
+      "PluralName": "PoundsPerThousandSquareFeet",
+      "BaseUnits": {
+        "L": "Foot",
+        "M": "Pound"
+      },
+      "FromUnitToBaseFunc": "{x} * (0.45359237 / 0.09290304) / 1000",
+      "FromBaseToUnitFunc": "{x} / (0.45359237 / 0.09290304) * 1000",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "lb/MSF", "lbs/MSF", "lb/1000ft²", "lbs/1000ft²", "lbm/MSF" ]
+        }
+      ]
     }
   ]
 }
diff --git a/Common/UnitDefinitions/AreaPerLength.json b/Common/UnitDefinitions/AreaPerLength.json
new file mode 100644
index 0000000000..25960b59c6
--- /dev/null
+++ b/Common/UnitDefinitions/AreaPerLength.json
@@ -0,0 +1,85 @@
+{
+  "Name": "AreaPerLength",
+  "BaseUnit": "SquareMeterPerMeter",
+  "XmlDocSummary": "The magnitude of area per unit length, typically used in structural engineering to specify distributed reinforcement.",
+  "BaseDimensions": {
+    "L": 1
+  },
+  "Units": [
+    {
+      "SingularName": "SquareMeterPerMeter",
+      "PluralName": "SquareMetersPerMeter",
+      "BaseUnits": {
+        "L": "Meter"
+      },
+      "FromUnitToBaseFunc": "{x}",
+      "FromBaseToUnitFunc": "{x}",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "m²/m" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "SquareCentimeterPerMeter",
+      "PluralName": "SquareCentimetersPerMeter",
+      "FromUnitToBaseFunc": "{x} * 1e-4",
+      "FromBaseToUnitFunc": "{x} / 1e-4",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "cm²/m" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "SquareMillimeterPerMeter",
+      "PluralName": "SquareMillimetersPerMeter",
+      "FromUnitToBaseFunc": "{x} * 1e-6",
+      "FromBaseToUnitFunc": "{x} / 1e-6",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "mm²/m" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "SquareInchPerFoot",
+      "PluralName": "SquareInchesPerFoot",
+      "FromUnitToBaseFunc": "{x} * 0.00064516 / 0.3048",
+      "FromBaseToUnitFunc": "{x} * 0.3048 / 0.00064516",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "in²/ft" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "SquareInchPerInch",
+      "PluralName": "SquareInchesPerInch",
+      "FromUnitToBaseFunc": "{x} * 0.00064516 / 0.0254",
+      "FromBaseToUnitFunc": "{x} * 0.0254 / 0.00064516",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "in²/in" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "SquareFootPerFoot",
+      "PluralName": "SquareFeetPerFoot",
+      "FromUnitToBaseFunc": "{x} * 0.09290304 / 0.3048",
+      "FromBaseToUnitFunc": "{x} * 0.3048 / 0.09290304",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "ft²/ft" ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Common/UnitDefinitions/Compressibility.json b/Common/UnitDefinitions/Compressibility.json
index 7d3b14cb30..d8c28fae95 100644
--- a/Common/UnitDefinitions/Compressibility.json
+++ b/Common/UnitDefinitions/Compressibility.json
@@ -28,8 +28,8 @@
     {
       "SingularName": "InverseKilopascal",
       "PluralName": "InverseKilopascals",
-      "FromUnitToBaseFunc": "{x} * 1e3",
-      "FromBaseToUnitFunc": "{x} / 1e3",
+      "FromUnitToBaseFunc": "{x} / 1e3",
+      "FromBaseToUnitFunc": "{x} * 1e3",
       "Localization": [
         {
           "Culture": "en-US",
@@ -40,8 +40,8 @@
     {
       "SingularName": "InverseMegapascal",
       "PluralName": "InverseMegapascals",
-      "FromUnitToBaseFunc": "{x} * 1e6",
-      "FromBaseToUnitFunc": "{x} / 1e6",
+      "FromUnitToBaseFunc": "{x} / 1e6",
+      "FromBaseToUnitFunc": "{x} * 1e6",
       "Localization": [
         {
           "Culture": "en-US",
@@ -52,8 +52,8 @@
     {
       "SingularName": "InverseAtmosphere",
       "PluralName": "InverseAtmospheres",
-      "FromUnitToBaseFunc": "{x} * 101325",
-      "FromBaseToUnitFunc": "{x} / 101325",
+      "FromUnitToBaseFunc": "{x} / 101325",
+      "FromBaseToUnitFunc": "{x} * 101325",
       "Localization": [
         {
           "Culture": "en-US",
@@ -64,8 +64,8 @@
     {
       "SingularName": "InverseMillibar",
       "PluralName": "InverseMillibars",
-      "FromUnitToBaseFunc": "{x} * 100",
-      "FromBaseToUnitFunc": "{x} / 100",
+      "FromUnitToBaseFunc": "{x} / 100",
+      "FromBaseToUnitFunc": "{x} * 100",
       "Localization": [
         {
           "Culture": "en-US",
@@ -76,8 +76,8 @@
     {
       "SingularName": "InverseBar",
       "PluralName": "InverseBars",
-      "FromUnitToBaseFunc": "{x} * 1e5",
-      "FromBaseToUnitFunc": "{x} / 1e5",
+      "FromUnitToBaseFunc": "{x} / 1e5",
+      "FromBaseToUnitFunc": "{x} * 1e5",
       "Localization": [
         {
           "Culture": "en-US",
@@ -88,8 +88,8 @@
     {
       "SingularName": "InversePoundForcePerSquareInch",
       "PluralName": "InversePoundsForcePerSquareInch",
-      "FromUnitToBaseFunc": "{x} * 6.894757293168361e3",
-      "FromBaseToUnitFunc": "{x} / 6.894757293168361e3",
+      "FromUnitToBaseFunc": "{x} / 6.894757293168361e3",
+      "FromBaseToUnitFunc": "{x} * 6.894757293168361e3",
       "Localization": [
         {
           "Culture": "en-US",
diff --git a/Common/UnitDefinitions/ElectricCurrentGradient.json b/Common/UnitDefinitions/ElectricCurrentGradient.json
index 28476d2d0d..32203357e4 100644
--- a/Common/UnitDefinitions/ElectricCurrentGradient.json
+++ b/Common/UnitDefinitions/ElectricCurrentGradient.json
@@ -1,4 +1,4 @@
-{
+{
   "Name": "ElectricCurrentGradient",
   "BaseUnit": "AmperePerSecond",
   "XmlDocSummary": "In electromagnetism, the current gradient describes how the current changes in time.",
diff --git a/Common/UnitDefinitions/FluidResistance.json b/Common/UnitDefinitions/FluidResistance.json
index 6b90951bdc..144d7decee 100644
--- a/Common/UnitDefinitions/FluidResistance.json
+++ b/Common/UnitDefinitions/FluidResistance.json
@@ -1,4 +1,4 @@
-{
+{
   "Name": "FluidResistance",
   "BaseUnit": "PascalSecondPerCubicMeter",
   "XmlDocSummary": "Fluid Resistance is a force acting opposite to the relative motion of any object moving with respect to a surrounding fluid. Fluid Resistance is sometimes referred to as drag or fluid friction.",
diff --git a/Common/UnitDefinitions/Force.json b/Common/UnitDefinitions/Force.json
index 9e1d26292a..88a0ddd929 100644
--- a/Common/UnitDefinitions/Force.json
+++ b/Common/UnitDefinitions/Force.json
@@ -31,6 +31,24 @@
         }
       ]
     },
+    {
+      "SingularName": "GramForce",
+      "PluralName": "GramsForce",
+      "FromUnitToBaseFunc": "{x} * 9.80665e-3",
+      "FromBaseToUnitFunc": "{x} / 9.80665e-3",
+      "XmlDocSummary": "The gram-force is a unit of force equal to the magnitude of force exerted by a gram of mass in standard gravity (9.80665 m/s²). It is equal to 9.80665 × 10⁻³ N.",
+      "XmlDocRemarks": "https://en.wikipedia.org/wiki/Kilogram-force",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "gf" ]
+        },
+        {
+          "Culture": "ru-RU",
+          "Abbreviations": [ "гс" ]
+        }
+      ]
+    },
     {
       "SingularName": "KilogramForce",
       "PluralName": "KilogramsForce",
diff --git a/Common/UnitDefinitions/HeatFlux.json b/Common/UnitDefinitions/HeatFlux.json
index 9d3204a3dd..3c4665a6b3 100644
--- a/Common/UnitDefinitions/HeatFlux.json
+++ b/Common/UnitDefinitions/HeatFlux.json
@@ -24,6 +24,23 @@
         }
       ]
     },
+    {
+      "SingularName": "WattPerSquareMillimeter",
+      "PluralName": "WattsPerSquareMillimeter",
+      "BaseUnits": {
+        "M": "Kilogram",
+        "T": "Second"
+      },
+      "FromUnitToBaseFunc": "{x} / 1e-6",
+      "FromBaseToUnitFunc": "{x} * 1e-6",
+      "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Kilo" ],
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "W/mm²" ]
+        }
+      ]
+    },
     {
       "SingularName": "WattPerSquareInch",
       "PluralName": "WattsPerSquareInch",
diff --git a/Common/UnitDefinitions/HeatTransferCoefficient.json b/Common/UnitDefinitions/HeatTransferCoefficient.json
index f3108375f2..47dd1b4546 100644
--- a/Common/UnitDefinitions/HeatTransferCoefficient.json
+++ b/Common/UnitDefinitions/HeatTransferCoefficient.json
@@ -54,6 +54,18 @@
         }
       ]
     },
+    {
+      "SingularName": "BtuPerSecondSquareInchDegreeFahrenheit",
+      "PluralName": "BtusPerSecondSquareInchDegreeFahrenheit",
+      "FromUnitToBaseFunc": "{x} * ((1055.05585262 / (2.54e-2 * 2.54e-2)) * 1.8)",
+      "FromBaseToUnitFunc": "{x} / ((1055.05585262 / (2.54e-2 * 2.54e-2)) * 1.8)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "Btu/(s·in²·°F)", "Btu/(in²·s·°F)", "Btu/(s*in^2*degF)", "Btu/(in^2*s*degF)" ]
+        }
+      ]
+    },
     {
       "SingularName": "CaloriePerHourSquareMeterDegreeCelsius",
       "PluralName": "CaloriesPerHourSquareMeterDegreeCelsius",
diff --git a/Common/UnitDefinitions/MolarFlow.json b/Common/UnitDefinitions/MolarFlow.json
index e9d90d51e4..af75991ed2 100644
--- a/Common/UnitDefinitions/MolarFlow.json
+++ b/Common/UnitDefinitions/MolarFlow.json
@@ -54,7 +54,7 @@
       "Localization": [
         {
           "Culture": "en-US",
-          "Abbreviations": [ "kmol/h" ]
+          "Abbreviations": [ "mol/h" ]
         }
       ]
     },
diff --git a/Common/UnitDefinitions/MolarMass.json b/Common/UnitDefinitions/MolarMass.json
index edcda34e72..770da97f19 100644
--- a/Common/UnitDefinitions/MolarMass.json
+++ b/Common/UnitDefinitions/MolarMass.json
@@ -47,6 +47,7 @@
     {
       "SingularName": "PoundPerMole",
       "PluralName": "PoundsPerMole",
+      "XmlDocSummary": "Pound mass per SI mole. This is distinct from PoundPerPoundMole, where the denominator is the pound-mole amount of substance unit.",
       "BaseUnits": {
         "M": "Pound",
         "N": "Mole"
@@ -64,6 +65,24 @@
           "Abbreviations": [ "фунт/моль" ]
         }
       ]
+    },
+    {
+      "SingularName": "PoundPerPoundMole",
+      "PluralName": "PoundsPerPoundMole",
+      "XmlDocSummary": "Pound mass per pound-mole. This is numerically equal to kilograms per kilomole and distinct from PoundPerMole, where the denominator is the SI mole.",
+      "XmlDocRemarks": "Sources: https://www.engineeringtoolbox.com/molecular-weight-gas-vapor-d_1156.html, https://www.engineeringtoolbox.com/unit-converter-d_185.html",
+      "BaseUnits": {
+        "M": "Pound",
+        "N": "PoundMole"
+      },
+      "FromUnitToBaseFunc": "{x} / 1e3",
+      "FromBaseToUnitFunc": "{x} * 1e3",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "lb/lbmol", "lbm/lbmol" ]
+        }
+      ]
     }
   ]
 }
diff --git a/Common/UnitDefinitions/PorousMediumPermeability.json b/Common/UnitDefinitions/PorousMediumPermeability.json
index 746e8805ab..2e5e62fe60 100644
--- a/Common/UnitDefinitions/PorousMediumPermeability.json
+++ b/Common/UnitDefinitions/PorousMediumPermeability.json
@@ -1,4 +1,4 @@
-{
+{
   "Name": "PorousMediumPermeability",
   "BaseUnit": "SquareMeter",
   "XmlDoc": "In fluid mechanics, permeability is the measure of the ability of a porous material to allow fluids to pass through it.",
diff --git a/Common/UnitDefinitions/PowerDensity.json b/Common/UnitDefinitions/PowerDensity.json
index 8a4d3fa962..33073faa6f 100644
--- a/Common/UnitDefinitions/PowerDensity.json
+++ b/Common/UnitDefinitions/PowerDensity.json
@@ -64,6 +64,32 @@
           "Abbreviations": [ "W/l" ]
         }
       ]
+    },
+    {
+      "SingularName": "BtuPerSecondCubicInch",
+      "PluralName": "BtusPerSecondCubicInch",
+      "XmlDocRemarks": "Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details.",
+      "FromUnitToBaseFunc": "{x} * 1055.05585262 / (2.54e-2 * 2.54e-2 * 2.54e-2)",
+      "FromBaseToUnitFunc": "{x} / 1055.05585262 * (2.54e-2 * 2.54e-2 * 2.54e-2)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "BTU/(s·in³)" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "BtuPerSecondCubicFoot",
+      "PluralName": "BtusPerSecondCubicFoot",
+      "XmlDocRemarks": "Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details.",
+      "FromUnitToBaseFunc": "{x} * 1055.05585262 / (0.3048 * 0.3048 * 0.3048)",
+      "FromBaseToUnitFunc": "{x} / 1055.05585262 * (0.3048 * 0.3048 * 0.3048)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "BTU/(s·ft³)" ]
+        }
+      ]
     }
   ]
 }
diff --git a/Common/UnitDefinitions/Pressure.json b/Common/UnitDefinitions/Pressure.json
index c5411d1cb9..1bfaf11cea 100644
--- a/Common/UnitDefinitions/Pressure.json
+++ b/Common/UnitDefinitions/Pressure.json
@@ -401,6 +401,34 @@
           "Abbreviations": [ "inH2O", "inch wc", "wc" ]
         }
       ]
+    },
+    {
+      "SingularName": "MilligramForcePerSquareMeter",
+      "PluralName": "MilligramsForcePerSquareMeter",
+      "FromUnitToBaseFunc": "{x} * 9.80665e-6",
+      "FromBaseToUnitFunc": "{x} / 9.80665e-6",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "mgf/m²" ]
+        },
+        {
+          "Culture": "ru-RU",
+          "Abbreviations": [ "мгс/м²" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "MilligramForcePerSquareFoot",
+      "PluralName": "MilligramsForcePerSquareFoot",
+      "FromUnitToBaseFunc": "{x} * 9.80665e-6 / 9.290304e-2",
+      "FromBaseToUnitFunc": "{x} / 9.80665e-6 * 9.290304e-2",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "mgf/ft²" ]
+        }
+      ]
     }
   ]
 }
diff --git a/Common/UnitDefinitions/RadiationEquivalentDose.json b/Common/UnitDefinitions/RadiationEquivalentDose.json
index 85da7bbed3..325601bdc3 100644
--- a/Common/UnitDefinitions/RadiationEquivalentDose.json
+++ b/Common/UnitDefinitions/RadiationEquivalentDose.json
@@ -1,4 +1,4 @@
-{
+{
   "Name": "RadiationEquivalentDose",
   "BaseUnit": "Sievert",
   "XmlDocSummary": "Equivalent dose is a dose quantity representing the stochastic health effects of low levels of ionizing radiation on the human body which represents the probability of radiation-induced cancer and genetic damage.",
diff --git a/Common/UnitDefinitions/RadiationExposure.json b/Common/UnitDefinitions/RadiationExposure.json
index 6684939d72..7385f919f3 100644
--- a/Common/UnitDefinitions/RadiationExposure.json
+++ b/Common/UnitDefinitions/RadiationExposure.json
@@ -1,4 +1,4 @@
-{
+{
   "Name": "RadiationExposure",
   "BaseUnit": "CoulombPerKilogram",
   "XmlDocSummary": "Radiation exposure is a measure of the ionization of air due to ionizing radiation from photons.",
diff --git a/Common/UnitDefinitions/Radioactivity.json b/Common/UnitDefinitions/Radioactivity.json
index 56ccccdef9..08af830748 100644
--- a/Common/UnitDefinitions/Radioactivity.json
+++ b/Common/UnitDefinitions/Radioactivity.json
@@ -1,4 +1,4 @@
-{
+{
   "Name": "Radioactivity",
   "BaseUnit": "Becquerel",
   "XmlDocSummary": "Amount of ionizing radiation released when an element spontaneously emits energy as a result of the radioactive decay of an unstable atom per unit time.",
diff --git a/Common/UnitDefinitions/SpecificVolume.json b/Common/UnitDefinitions/SpecificVolume.json
index aa9939832a..164c7505ce 100644
--- a/Common/UnitDefinitions/SpecificVolume.json
+++ b/Common/UnitDefinitions/SpecificVolume.json
@@ -16,7 +16,6 @@
       },
       "FromUnitToBaseFunc": "{x}",
       "FromBaseToUnitFunc": "{x}",
-      "Prefixes": [ "Milli" ],
       "Localization": [
         {
           "Culture": "en-US",
@@ -24,6 +23,24 @@
         }
       ]
     },
+    {
+      "SingularName": "CubicMillimeterPerKilogram",
+      "PluralName": "CubicMillimetersPerKilogram",
+      "BaseUnits": {
+        "L": "Millimeter",
+        "M": "Kilogram"
+      },
+      "XmlDocSummary": "A specific volume unit of cubic millimeters per kilogram. The millimeter prefix applies before cubing the length unit, so 1 mm³/kg = 1e-9 m³/kg.",
+      "XmlDocRemarks": "Sources: https://www.bipm.org/en/measurement-units/si-prefixes, https://usma.org/wp-content/uploads/2015/06/Practical_Guide_to_the_SI.pdf",
+      "FromUnitToBaseFunc": "{x} / 1e9",
+      "FromBaseToUnitFunc": "{x} * 1e9",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "mm³/kg" ]
+        }
+      ]
+    },
     {
       "SingularName": "CubicFootPerPound",
       "PluralName": "CubicFeetPerPound",
diff --git a/Common/UnitDefinitions/ThermalConductivity.json b/Common/UnitDefinitions/ThermalConductivity.json
index c5f30282b8..284fba5818 100644
--- a/Common/UnitDefinitions/ThermalConductivity.json
+++ b/Common/UnitDefinitions/ThermalConductivity.json
@@ -39,6 +39,18 @@
           "Abbreviations": [ "BTU/(h·ft·°F)" ]
         }
       ]
+    },
+    {
+      "SingularName": "BtuPerSecondInchFahrenheit",
+      "PluralName": "BtusPerSecondInchFahrenheit",
+      "FromUnitToBaseFunc": "{x} * ((1055.05585262 / 2.54e-2) * 1.8)",
+      "FromBaseToUnitFunc": "{x} / ((1055.05585262 / 2.54e-2) * 1.8)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "BTU/(s·in·°F)" ]
+        }
+      ]
     }
   ]
 }
diff --git a/Common/UnitDefinitions/Torque.json b/Common/UnitDefinitions/Torque.json
index d19cebd6ad..d9078ae1a3 100644
--- a/Common/UnitDefinitions/Torque.json
+++ b/Common/UnitDefinitions/Torque.json
@@ -56,6 +56,30 @@
         }
       ]
     },
+    {
+      "SingularName": "OunceForceFoot",
+      "PluralName": "OunceForceFeet",
+      "FromUnitToBaseFunc": "{x} * (4.4482216152605 / 16) * 0.3048",
+      "FromBaseToUnitFunc": "{x} / ((4.4482216152605 / 16) * 0.3048)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "ozf·ft", "oz·ft", "ozf-ft", "oz-ft" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "OunceForceInch",
+      "PluralName": "OunceForceInches",
+      "FromUnitToBaseFunc": "{x} * (4.4482216152605 / 16) * 2.54e-2",
+      "FromBaseToUnitFunc": "{x} / ((4.4482216152605 / 16) * 2.54e-2)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "ozf·in", "oz·in", "ozf-in", "oz-in", "in-oz" ]
+        }
+      ]
+    },
     {
       "SingularName": "PoundalFoot",
       "PluralName": "PoundalFeet",
@@ -77,7 +101,7 @@
       "Localization": [
         {
           "Culture": "en-US",
-          "Abbreviations": [ "lbf·in" ],
+          "Abbreviations": [ "lbf·in", "lb·in", "lbf-in", "lb-in", "in-lb" ],
           "AbbreviationsForPrefixes": { "Kilo": "kipf·in" }
         }
       ]
@@ -91,7 +115,7 @@
       "Localization": [
         {
           "Culture": "en-US",
-          "Abbreviations": [ "lbf·ft" ],
+          "Abbreviations": [ "lbf·ft", "lb·ft", "lbf-ft", "lb-ft", "ft-lb" ],
           "AbbreviationsForPrefixes": { "Kilo": "kipf·ft" }
         }
       ]
diff --git a/Common/UnitDefinitions/Volume.json b/Common/UnitDefinitions/Volume.json
index b744737e5d..f9566e1f56 100644
--- a/Common/UnitDefinitions/Volume.json
+++ b/Common/UnitDefinitions/Volume.json
@@ -31,7 +31,6 @@
       "PluralName": "CubicMeters",
       "FromUnitToBaseFunc": "{x}",
       "FromBaseToUnitFunc": "{x}",
-      "Prefixes": [ "Hecto", "Kilo" ],
       "BaseUnits": {
         "L": "Meter"
       },
@@ -46,6 +45,20 @@
         }
       ]
     },
+    {
+      "SingularName": "ThousandCubicMeter",
+      "PluralName": "ThousandCubicMeters",
+      "XmlDocSummary": "A count-style volume unit equal to 1000 cubic meters. This is distinct from CubicKilometer, which is (1000 m)³ or 1e9 cubic meters.",
+      "XmlDocRemarks": "Sources: https://energystar.my.site.com/PortfolioManager/s/article/Is-there-a-list-of-valid-property-level-water-meter-types-and-unit-of-measure-combinations-1748913622052, https://www.census.gov/foreign-trade/guide/sec4.html, https://www.bipm.org/en/measurement-units/si-prefixes",
+      "FromUnitToBaseFunc": "{x} * 1e3",
+      "FromBaseToUnitFunc": "{x} / 1e3",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "10³·m³", "kcm", "Kcm" ]
+        }
+      ]
+    },
     {
       "SingularName": "CubicKilometer",
       "PluralName": "CubicKilometers",
@@ -212,7 +225,6 @@
       "XmlDocRemarks": "https://en.wikipedia.org/wiki/Cubic_foot",
       "FromUnitToBaseFunc": "{x} * 0.028316846592",
       "FromBaseToUnitFunc": "{x} / 0.028316846592",
-      "Prefixes": [ "Hecto", "Kilo", "Mega" ],
       "Localization": [
         {
           "Culture": "en-US",
@@ -224,6 +236,48 @@
         }
       ]
     },
+    {
+      "SingularName": "HundredCubicFoot",
+      "PluralName": "HundredCubicFeet",
+      "XmlDocSummary": "A count-style volume unit equal to 100 cubic feet, commonly abbreviated Ccf in natural gas and water utility billing.",
+      "XmlDocRemarks": "Sources: https://www.eia.gov/tools/faqs/faq.php?id=45&amp;t=8, https://19january2017snapshot.epa.gov/www3/watersense/our_water/understanding_your_bill.html",
+      "FromUnitToBaseFunc": "{x} * 0.028316846592 * 1e2",
+      "FromBaseToUnitFunc": "{x} / (0.028316846592 * 1e2)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "Ccf", "hft³" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "ThousandCubicFoot",
+      "PluralName": "ThousandCubicFeet",
+      "XmlDocSummary": "A count-style volume unit equal to 1000 cubic feet, commonly abbreviated Mcf in natural gas reporting.",
+      "XmlDocRemarks": "Sources: https://www.eia.gov/tools/faqs/faq.php?id=45&amp;t=8, https://natural-resources.canada.ca/climate-change/conversion-factors-common-units-used-north-american-cooperation-energy-information",
+      "FromUnitToBaseFunc": "{x} * 0.028316846592 * 1e3",
+      "FromBaseToUnitFunc": "{x} / (0.028316846592 * 1e3)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "Mcf", "kcf", "kft³" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "MillionCubicFoot",
+      "PluralName": "MillionCubicFeet",
+      "XmlDocSummary": "A count-style volume unit equal to 1,000,000 cubic feet, commonly abbreviated MMcf in natural gas reporting.",
+      "XmlDocRemarks": "Sources: https://natural-resources.canada.ca/climate-change/conversion-factors-common-units-used-north-american-cooperation-energy-information",
+      "FromUnitToBaseFunc": "{x} * 0.028316846592 * 1e6",
+      "FromBaseToUnitFunc": "{x} / (0.028316846592 * 1e6)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "MMcf", "Mft³" ]
+        }
+      ]
+    },
     {
       "SingularName": "CubicInch",
       "PluralName": "CubicInches",
diff --git a/Common/UnitDefinitions/VolumeFlow.json b/Common/UnitDefinitions/VolumeFlow.json
index 0df447b2b5..3480bfc2e8 100644
--- a/Common/UnitDefinitions/VolumeFlow.json
+++ b/Common/UnitDefinitions/VolumeFlow.json
@@ -99,6 +99,22 @@
         }
       ]
     },
+    {
+      "SingularName": "CubicInchPerSecond",
+      "PluralName": "CubicInchesPerSecond",
+      "BaseUnits": {
+        "L": "Inch",
+        "T": "Second"
+      },
+      "FromUnitToBaseFunc": "{x} * 1.6387064e-5",
+      "FromBaseToUnitFunc": "{x} / 1.6387064e-5",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "in³/s" ]
+        }
+      ]
+    },
     {
       "SingularName": "CubicFootPerMinute",
       "PluralName": "CubicFeetPerMinute",
@@ -115,6 +131,22 @@
         }
       ]
     },
+    {
+      "SingularName": "CubicInchPerMinute",
+      "PluralName": "CubicInchesPerMinute",
+      "BaseUnits": {
+        "L": "Inch",
+        "T": "Minute"
+      },
+      "FromUnitToBaseFunc": "{x} * 1.6387064e-5 / 60",
+      "FromBaseToUnitFunc": "{x} / (1.6387064e-5 / 60)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "in³/min" ]
+        }
+      ]
+    },
     {
       "SingularName": "CubicFootPerHour",
       "PluralName": "CubicFeetPerHour",
@@ -466,6 +498,26 @@
         }
       ]
     },
+    {
+      "SingularName": "CubicMillimeterPerMinute",
+      "PluralName": "CubicMillimetersPerMinute",
+      "BaseUnits": {
+        "L": "Millimeter",
+        "T": "Minute"
+      },
+      "FromUnitToBaseFunc": "{x} * 1e-9 / 60",
+      "FromBaseToUnitFunc": "{x} / (1e-9 / 60)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "mm³/min" ]
+        },
+        {
+          "Culture": "ru-RU",
+          "Abbreviations": [ "мм³/мин" ]
+        }
+      ]
+    },
     {
       "SingularName": "AcreFootPerSecond",
       "PluralName": "AcreFeetPerSecond",
diff --git a/Common/UnitEnumValues.g.json b/Common/UnitEnumValues.g.json
index 3ebdc3d87d..a3ddd96516 100644
--- a/Common/UnitEnumValues.g.json
+++ b/Common/UnitEnumValues.g.json
@@ -86,7 +86,9 @@
   "AreaDensity": {
     "KilogramPerSquareMeter": 1,
     "GramPerSquareMeter": 6,
-    "MilligramPerSquareMeter": 10
+    "MilligramPerSquareMeter": 10,
+    "PoundPerThousandSquareFeet": 3,
+    "PoundPerSquareFoot": 8
   },
   "AreaMomentOfInertia": {
     "CentimeterToTheFourth": 1,
@@ -469,7 +471,8 @@
     "Poundal": 12,
     "PoundForce": 13,
     "ShortTonForce": 14,
-    "TonneForce": 15
+    "TonneForce": 15,
+    "GramForce": 16
   },
   "ForceChangeRate": {
     "CentinewtonPerSecond": 1,
@@ -567,7 +570,14 @@
     "PoundPerSecondCubed": 15,
     "WattPerSquareFoot": 16,
     "WattPerSquareInch": 17,
-    "WattPerSquareMeter": 18
+    "WattPerSquareMeter": 18,
+    "CentiwattPerSquareMillimeter": 22,
+    "DeciwattPerSquareMillimeter": 28,
+    "KilowattPerSquareMillimeter": 24,
+    "MicrowattPerSquareMillimeter": 20,
+    "MilliwattPerSquareMillimeter": 26,
+    "NanowattPerSquareMillimeter": 25,
+    "WattPerSquareMillimeter": 19
   },
   "HeatTransferCoefficient": {
     "BtuPerSquareFootDegreeFahrenheit": 1,
@@ -575,7 +585,8 @@
     "WattPerSquareMeterKelvin": 3,
     "BtuPerHourSquareFootDegreeFahrenheit": 11,
     "KilocaloriePerHourSquareMeterDegreeCelsius": 8,
-    "CaloriePerHourSquareMeterDegreeCelsius": 5
+    "CaloriePerHourSquareMeterDegreeCelsius": 5,
+    "BtuPerSecondSquareInchDegreeFahrenheit": 4
   },
   "Illuminance": {
     "Kilolux": 1,
@@ -1044,7 +1055,8 @@
     "NanogramPerMole": 11,
     "PoundPerMole": 12,
     "KiloGramPerKiloMole": 20,
-    "KilogramPerKilomole": 15
+    "KilogramPerKilomole": 15,
+    "PoundPerPoundMole": 24
   },
   "Permeability": {
     "HenryPerMeter": 1
@@ -1132,7 +1144,9 @@
     "WattPerCubicFoot": 41,
     "WattPerCubicInch": 42,
     "WattPerCubicMeter": 43,
-    "WattPerLiter": 44
+    "WattPerLiter": 44,
+    "BtuPerSecondCubicFoot": 47,
+    "BtuPerSecondCubicInch": 51
   },
   "PowerRatio": {
     "DecibelMilliwatt": 1,
@@ -1188,7 +1202,9 @@
     "Torr": 47,
     "MeterOfWaterColumn": 57,
     "CentimeterOfWaterColumn": 48,
-    "Millitorr": 52
+    "Millitorr": 52,
+    "MilligramForcePerSquareFoot": 59,
+    "MilligramForcePerSquareMeter": 51
   },
   "PressureChangeRate": {
     "AtmospherePerSecond": 1,
@@ -1370,9 +1386,9 @@
     "PoundMassPerPoundForceHour": 4
   },
   "SpecificVolume": {
+    "CubicMillimeterPerKilogram": 3,
     "CubicFootPerPound": 1,
-    "CubicMeterPerKilogram": 2,
-    "MillicubicMeterPerKilogram": 3
+    "CubicMeterPerKilogram": 2
   },
   "SpecificWeight": {
     "KilogramForcePerCubicCentimeter": 1,
@@ -1489,7 +1505,8 @@
   },
   "ThermalConductivity": {
     "BtuPerHourFootFahrenheit": 1,
-    "WattPerMeterKelvin": 2
+    "WattPerMeterKelvin": 2,
+    "BtuPerSecondInchFahrenheit": 6
   },
   "ThermalResistance": {
     "DegreeCelsiusPerWatt": 10,
@@ -1520,7 +1537,9 @@
     "PoundForceInch": 22,
     "TonneForceCentimeter": 23,
     "TonneForceMeter": 24,
-    "TonneForceMillimeter": 25
+    "TonneForceMillimeter": 25,
+    "OunceForceFoot": 26,
+    "OunceForceInch": 27
   },
   "TorquePerLength": {
     "KilogramForceCentimeterPerMeter": 1,
@@ -1571,21 +1590,20 @@
     "DecausGallon": 17,
     "Deciliter": 18,
     "DeciusGallon": 19,
-    "HectocubicFoot": 20,
-    "HectocubicMeter": 21,
+    "HundredCubicFoot": 20,
     "Hectoliter": 22,
     "HectousGallon": 23,
     "ImperialBeerBarrel": 24,
     "ImperialGallon": 25,
     "ImperialOunce": 26,
     "ImperialPint": 27,
-    "KilocubicFoot": 28,
-    "KilocubicMeter": 29,
+    "ThousandCubicFoot": 28,
+    "ThousandCubicMeter": 29,
     "KiloimperialGallon": 30,
     "Kiloliter": 31,
     "KilousGallon": 32,
     "Liter": 33,
-    "MegacubicFoot": 34,
+    "MillionCubicFoot": 34,
     "MegaimperialGallon": 35,
     "Megaliter": 36,
     "MegausGallon": 37,
@@ -1706,7 +1724,10 @@
     "HectoliterPerDay": 74,
     "HectoliterPerHour": 72,
     "HectoliterPerMinute": 75,
-    "HectoliterPerSecond": 69
+    "HectoliterPerSecond": 69,
+    "CubicInchPerMinute": 86,
+    "CubicInchPerSecond": 76,
+    "CubicMillimeterPerMinute": 80
   },
   "VolumeFlowPerArea": {
     "CubicFootPerMinutePerSquareFoot": 1,
@@ -2018,5 +2039,13 @@
     "SquareMeterKelvinPerKilowatt": 5,
     "SquareMeterKelvinPerWatt": 4,
     "SquareMillimeterKelvinPerWatt": 13
+  },
+  "AreaPerLength": {
+    "SquareCentimeterPerMeter": 10,
+    "SquareFootPerFoot": 4,
+    "SquareInchPerFoot": 3,
+    "SquareInchPerInch": 7,
+    "SquareMeterPerMeter": 1,
+    "SquareMillimeterPerMeter": 5
   }
 }
diff --git a/Common/UnitRelations.json b/Common/UnitRelations.json
index bded89653c..9163188cdc 100644
--- a/Common/UnitRelations.json
+++ b/Common/UnitRelations.json
@@ -2,41 +2,66 @@
   "1 = Area.SquareMeter * ReciprocalArea.InverseSquareMeter",
   "1 = Density.KilogramPerCubicMeter * SpecificVolume.CubicMeterPerKilogram",
   "1 = ElectricResistivity.OhmMeter * ElectricConductivity.SiemensPerMeter",
+  "1 = Frequency.PerSecond * Duration.Second",
   "1 = Length.Meter * ReciprocalLength.InverseMeter",
   "Acceleration.MeterPerSecondSquared = Jerk.MeterPerSecondCubed * Duration.Second",
   "AmountOfSubstance.Mole = MolarFlow.MolePerSecond * Duration.Second",
   "AmountOfSubstance.Mole = Molarity.MolePerCubicMeter * Volume.CubicMeter",
   "Angle.Radian = RotationalSpeed.RadianPerSecond * Duration.Second",
+  "Area.SquareMeter = AreaPerLength.SquareMeterPerMeter * Length.Meter -- NoInferredDivision",
   "Area.SquareMeter = KinematicViscosity.SquareMeterPerSecond * Duration.Second -- NoInferredDivision",
   "Area.SquareMeter = Length.Meter * Length.Meter",
   "Area.SquareMeter = Volume.CubicMeter * ReciprocalLength.InverseMeter",
+  "AreaDensity.KilogramPerSquareMeter = Density.KilogramPerCubicMeter * Length.Meter",
+  "AreaMomentOfInertia.MeterToTheFourth = Area.SquareMeter * Area.SquareMeter",
   "AreaMomentOfInertia.MeterToTheFourth = Volume.CubicMeter * Length.Meter",
-  "double = SpecificEnergy.JoulePerKilogram * BrakeSpecificFuelConsumption.KilogramPerJoule",
+  "BitRate.BitPerSecond = Information.Bit * Frequency.PerSecond",
+  "DoseAreaProduct.GraySquareMeter = AbsorbedDoseOfIonizingRadiation.Gray * Area.SquareMeter",
   "DynamicViscosity.NewtonSecondPerMeterSquared = Density.KilogramPerCubicMeter * KinematicViscosity.SquareMeterPerSecond",
+  "ElectricApparentEnergy.VoltampereHour = ElectricApparentPower.Voltampere * Duration.Hour",
   "ElectricCharge.AmpereHour = ElectricCurrent.Ampere * Duration.Hour",
+  "ElectricCharge.Coulomb = ElectricCapacitance.Farad * ElectricPotential.Volt",
+  "ElectricCharge.Coulomb = ElectricChargeDensity.CoulombPerCubicMeter * Volume.CubicMeter",
+  "ElectricCharge.Coulomb = ElectricSurfaceChargeDensity.CoulombPerSquareMeter * Area.SquareMeter",
+  "ElectricCurrent.Ampere = ElectricCurrentDensity.AmperePerSquareMeter * Area.SquareMeter",
   "ElectricCurrent.Ampere = ElectricCurrentGradient.AmperePerSecond * Duration.Second",
+  "ElectricCurrent.Ampere = ElectricPotential.Volt * ElectricConductance.Siemens",
   "ElectricPotential.Volt = ElectricCurrent.Ampere * ElectricResistance.Ohm",
+  "ElectricPotential.Volt = ElectricField.VoltPerMeter * Length.Meter",
+  "ElectricPotential.Volt = ElectricPotentialChangeRate.VoltPerSecond * Duration.Second",
+  "ElectricReactiveEnergy.VoltampereReactiveHour = ElectricReactivePower.VoltampereReactive * Duration.Hour",
   "Energy.Joule = ElectricPotential.Volt * ElectricCharge.Coulomb",
   "Energy.Joule = EnergyDensity.JoulePerCubicMeter * Volume.CubicMeter",
   "Energy.Joule = MolarEnergy.JoulePerMole * AmountOfSubstance.Mole",
   "Energy.Joule = Power.Watt * Duration.Second",
   "Energy.Joule = SpecificEnergy.JoulePerKilogram * Mass.Kilogram",
   "Energy.Joule = TemperatureDelta.Kelvin * Entropy.JoulePerKelvin",
+  "EnergyDensity.JoulePerCubicMeter = VolumetricHeatCapacity.JoulePerCubicMeterKelvin * TemperatureDelta.Kelvin",
   "Entropy.JoulePerKelvin = SpecificEntropy.JoulePerKilogramKelvin * Mass.Kilogram",
   "Force.Newton = ForceChangeRate.NewtonPerSecond * Duration.Second",
   "Force.Newton = ForcePerLength.NewtonPerMeter * Length.Meter",
   "Force.Newton = Mass.Kilogram * Acceleration.MeterPerSecondSquared",
   "Force.Newton = Pressure.Pascal * Area.SquareMeter",
+  "Force.Newton = SpecificWeight.NewtonPerCubicMeter * Volume.CubicMeter",
+  "ForcePerLength.NewtonPerMeter = Acceleration.MeterPerSecondSquared * LinearDensity.KilogramPerMeter",
   "ForcePerLength.NewtonPerMeter = Force.Newton * ReciprocalLength.InverseMeter",
   "ForcePerLength.NewtonPerMeter = Pressure.NewtonPerSquareMeter * Length.Meter",
   "ForcePerLength.NewtonPerMeter = SpecificWeight.NewtonPerCubicMeter * Area.SquareMeter",
+  "HeatFlux.WattPerSquareMeter = HeatTransferCoefficient.WattPerSquareMeterKelvin * TemperatureDelta.Kelvin",
+  "Impulse.NewtonSecond = Force.Newton * Duration.Second",
+  "Information.Bit = BitRate.BitPerSecond * Duration.Second",
+  "Irradiation.JoulePerSquareMeter = Irradiance.WattPerSquareMeter * Duration.Second",
   "KinematicViscosity.SquareMeterPerSecond = Length.Meter * Speed.MeterPerSecond",
+  "LeakRate.PascalCubicMeterPerSecond = Pressure.Pascal * VolumeFlow.CubicMeterPerSecond",
   "Length.Meter = Area.SquareMeter * ReciprocalLength.InverseMeter",
   "Length.Meter = Speed.MeterPerSecond * Duration.Second",
   "Length.Meter = Volume.CubicMeter * ReciprocalArea.InverseSquareMeter",
   "LinearDensity.KilogramPerMeter = Area.SquareMeter * Density.KilogramPerCubicMeter",
+  "LinearDensity.KilogramPerMeter = AreaDensity.KilogramPerSquareMeter * Length.Meter",
   "LuminousFlux.Lumen = Illuminance.Lux * Area.SquareMeter",
+  "LuminousFlux.Lumen = LuminousIntensity.Candela * SolidAngle.Steradian",
   "LuminousIntensity.Candela = Luminance.CandelaPerSquareMeter * Area.SquareMeter",
+  "MagneticFlux.Weber = MagneticField.Tesla * Area.SquareMeter",
   "Mass.Kilogram = AmountOfSubstance.Mole * MolarMass.KilogramPerMole",
   "Mass.Kilogram = AreaDensity.KilogramPerSquareMeter * Area.SquareMeter",
   "Mass.Kilogram = Density.KilogramPerCubicMeter * Volume.CubicMeter",
@@ -57,17 +82,25 @@
   "Power.Watt = Energy.Joule * Frequency.PerSecond",
   "Power.Watt = Force.Newton * Speed.MeterPerSecond",
   "Power.Watt = HeatFlux.WattPerSquareMeter * Area.SquareMeter",
+  "Power.Watt = LinearPowerDensity.WattPerMeter * Length.Meter",
+  "Power.Watt = PowerDensity.WattPerCubicMeter * Volume.CubicMeter",
   "Power.Watt = SpecificEnergy.JoulePerKilogram * MassFlow.KilogramPerSecond",
   "Power.Watt = Torque.NewtonMeter * RotationalSpeed.RadianPerSecond",
   "Pressure.NewtonPerSquareMeter = Force.Newton * ReciprocalArea.InverseSquareMeter",
   "Pressure.NewtonPerSquareMeter = ForcePerLength.NewtonPerMeter * ReciprocalLength.InverseMeter",
+  "Pressure.Pascal = Acceleration.MeterPerSecondSquared * AreaDensity.KilogramPerSquareMeter",
+  "Pressure.Pascal = FluidResistance.PascalSecondPerCubicMeter * VolumeFlow.CubicMeterPerSecond",
   "Pressure.Pascal = PressureChangeRate.PascalPerSecond * Duration.Second",
   "Pressure.Pascal = SpecificWeight.NewtonPerCubicMeter * Length.Meter",
+  "QuantityValue = SpecificEnergy.JoulePerKilogram * BrakeSpecificFuelConsumption.KilogramPerJoule",
   "RadiationEquivalentDose.Sievert = RadiationEquivalentDoseRate.SievertPerHour * Duration.Hour",
   "Ratio.DecimalFraction = Area.SquareMeter * ReciprocalArea.InverseSquareMeter -- NoInferredDivision",
+  "Ratio.DecimalFraction = Compressibility.InversePascal * Pressure.Pascal",
+  "Ratio.DecimalFraction = RatioChangeRate.DecimalFractionPerSecond * Duration.Second",
   "Ratio.DecimalFraction = TemperatureDelta.Kelvin * CoefficientOfThermalExpansion.PerKelvin -- NoInferredDivision",
   "ReciprocalArea.InverseSquareMeter = ReciprocalLength.InverseMeter * ReciprocalLength.InverseMeter",
   "ReciprocalLength.InverseMeter = Length.Meter * ReciprocalArea.InverseSquareMeter",
+  "RotationalSpeed.RadianPerSecond = RotationalAcceleration.RadianPerSecondSquared * Duration.Second",
   "RotationalStiffness.NewtonMeterPerRadian = RotationalStiffnessPerLength.NewtonMeterPerRadianPerMeter * Length.Meter",
   "SpecificEnergy.JoulePerKilogram = SpecificEntropy.JoulePerKilogramKelvin * TemperatureDelta.Kelvin",
   "SpecificEnergy.JoulePerKilogram = Speed.MeterPerSecond * Speed.MeterPerSecond",
@@ -75,11 +108,15 @@
   "Speed.MeterPerSecond = Acceleration.MeterPerSecondSquared * Duration.Second",
   "TemperatureDelta.DegreeCelsius = TemperatureChangeRate.DegreeCelsiusPerSecond * Duration.Second",
   "TemperatureDelta.DegreeCelsius = TemperatureGradient.DegreeCelsiusPerKilometer * Length.Kilometer",
+  "TemperatureDelta.Kelvin = ThermalInsulance.SquareMeterKelvinPerWatt * HeatFlux.WattPerSquareMeter",
+  "TemperatureDelta.Kelvin = ThermalResistance.KelvinPerWatt * Power.Watt",
   "Torque.NewtonMeter = ForcePerLength.NewtonPerMeter * Area.SquareMeter",
   "Torque.NewtonMeter = Length.Meter * Force.Newton",
   "Torque.NewtonMeter = RotationalStiffness.NewtonMeterPerRadian * Angle.Radian",
   "Volume.CubicMeter = Length.Meter * Area.SquareMeter",
   "Volume.CubicMeter = SpecificVolume.CubicMeterPerKilogram * Mass.Kilogram",
   "Volume.CubicMeter = VolumeFlow.CubicMeterPerSecond * Duration.Second",
-  "VolumeFlow.CubicMeterPerSecond = Area.SquareMeter * Speed.MeterPerSecond"
+  "Volume.CubicMeter = VolumePerLength.CubicMeterPerMeter * Length.Meter -- NoInferredDivision",
+  "VolumeFlow.CubicMeterPerSecond = Area.SquareMeter * Speed.MeterPerSecond",
+  "VolumeFlow.CubicMeterPerSecond = VolumeFlowPerArea.CubicMeterPerSecondPerSquareMeter * Area.SquareMeter -- NoInferredDivision"
 ]
\ No newline at end of file
diff --git a/Directory.Build.props b/Directory.Build.props
index d8f549a773..4ead857691 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -3,9 +3,8 @@
   <PropertyGroup>
     <!-- Default to output to Artifacts folder -->
     <OutputPath>$(MSBuildThisFileDirectory)Artifacts/$(MSBuildProjectName)</OutputPath>
-    <!-- Specific output folder for .NET nanoFramework projects -->
-    <OutputPath Condition=" '$(TargetFrameworkIdentifier)' == '.NETnanoFramework'">$(MSBuildThisFileDirectory)Artifacts/UnitsNet.NanoFramework/$(MSBuildProjectName)</OutputPath>
-
+    <!-- Shared repository-local NuGet feed for development packages from any project. -->
+    <RepositoryLocalNuGetFeed>$(MSBuildThisFileDirectory)Artifacts/Nugets</RepositoryLocalNuGetFeed>
   </PropertyGroup>
 
   <!-- Workaround for `dotnet test UnitsNet.sln`: https://dasmulli.blog/2018/01/20/make-dotnet-test-work-on-solution-files/ -->
@@ -32,9 +31,4 @@
     <IncludeSymbols>true</IncludeSymbols>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
   </PropertyGroup>
-
-  <ItemGroup>
-    <Compile Include="$(MSBuildThisFileDirectory)/NullableAttributes.cs" />
-  </ItemGroup>
-
 </Project>
diff --git a/Directory.Build.targets b/Directory.Build.targets
new file mode 100644
index 0000000000..9ded9b351a
--- /dev/null
+++ b/Directory.Build.targets
@@ -0,0 +1,7 @@
+<!-- Licensed under MIT No Attribution, see LICENSE file at the root. -->
+<Project>
+  <!-- Nullable flow-analysis attributes are built in on modern .NET targets. -->
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or '$(TargetFrameworkIdentifier)' == '.NETFramework'">
+    <Compile Include="$(MSBuildThisFileDirectory)NullableAttributes.cs" />
+  </ItemGroup>
+</Project>
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 4a94c2ffd0..34d9dc7b16 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -4,10 +4,14 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageVersion Include="System.Runtime.CompilerServices.Unsafe" Version="6.1.2" />
+    <PackageVersion Include="Fractions" Version="8.3.2" />
+    <PackageVersion Include="MinVer" Version="7.0.0" />
     <PackageVersion Include="BenchmarkDotNet" Version="0.15.8" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.5.1" />
+    <PackageVersion Include="System.Collections.Immutable" Version="9.0.8" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.6.0" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
-    <PackageVersion Include="NuGet.Protocol" Version="7.3.1" />
+    <PackageVersion Include="System.Text.Json" Version="10.0.9" />
+    <PackageVersion Include="NuGet.Protocol" Version="7.6.0" />
     <PackageVersion Include="Serilog" Version="4.3.1" />
     <PackageVersion Include="Serilog.Sinks.Console" Version="6.1.1" />
     <PackageVersion Include="System.CommandLine.DragonFruit" Version="0.4.0-alpha.22272.1" />
@@ -16,5 +20,6 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageVersion>
+    <PackageVersion Include="JetBrains.Annotations" Version="2026.2.0" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/Directory.Solution.targets b/Directory.Solution.targets
new file mode 100644
index 0000000000..966654a49f
--- /dev/null
+++ b/Directory.Solution.targets
@@ -0,0 +1,21 @@
+<!-- Licensed under MIT No Attribution, see LICENSE file at the root. -->
+<Project>
+  <!--
+    This root-level file is imported by both repository solutions. The target is intentionally
+    inert for the main UnitsNet solution, which does not define the LocalPackages platform.
+
+    A solution restore evaluates package-facing samples in parallel. Bootstrap the shared local
+    feed once so their per-project restore hooks observe completed package stamps instead of
+    launching concurrent dotnet pack processes.
+  -->
+  <Target Name="PrepareUnitsNetModularLocalPackagesForSolution"
+          BeforeTargets="_GenerateRestoreGraph;Restore"
+          Condition="'$(Platform)' == 'LocalPackages'">
+    <Message Importance="high" Text="Preparing the repository-local UnitsNet.Modular packages..." />
+    <MSBuild
+        Projects="$(MSBuildThisFileDirectory)UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Units/SharedUnitsLibrarySample.Units.csproj"
+        Targets="_PackLocalUnitsNetModularPackages"
+        BuildInParallel="false"
+        Properties="Configuration=$(Configuration);Platform=LocalPackages;UnitsNetModularSampleUpdateLocalPackagesOnBuild=true" />
+  </Target>
+</Project>
diff --git a/Docs/README.md b/Docs/README.md
index 06b0314dde..520c47e867 100644
--- a/Docs/README.md
+++ b/Docs/README.md
@@ -3,6 +3,7 @@
 ## Contributing
 
 - [Adding a New Quantity or Unit](adding-a-new-unit.md) — step-by-step guide for adding quantities and units
+- [Quantity and Unit Definition Schema](quantity-and-unit-definition-schema.md) — field reference for quantity and unit JSON definitions
 - [Adding Operator Overloads](adding-operator-overloads.md) — how to add strongly-typed arithmetic operators
 - [Precision](precision.md) — how conversions work and their precision limits
 
@@ -15,7 +16,6 @@
 
 ## Platform Support
 
-- [.NET nanoFramework](nanoframework.md) — embedded device support
 - [Experimental: Generic Math](experimental-generic-math.md) — .NET 7+ generic math interfaces
 
 ## Upgrade Guides
diff --git a/Docs/adding-a-new-unit.md b/Docs/adding-a-new-unit.md
index 93534442a2..92decc0005 100644
--- a/Docs/adding-a-new-unit.md
+++ b/Docs/adding-a-new-unit.md
@@ -28,6 +28,8 @@ Sometimes we just have to say no, sorry! We simply want to avoid bloating the li
 - [x] Can be represented by a `double` numeric value, integer values are not well supported and may suffer from precision errors
 - [x] Is not [dimensionless/unitless](https://en.wikipedia.org/wiki/Dimensionless_quantity) (consider using `Ratio`)
 
+Single-unit quantities are the exception. If a proposed quantity has only one unit, it needs stronger justification: the quantity must be widely used as a typed quantity representation on its own, not just as a unit abbreviation with no conversions.
+
 ### A unit is a good fit to add to a quantity, if it
 
 - [x] Is well documented and unambiguous, e.g. has a wiki page or found in online unit converters
@@ -51,6 +53,7 @@ Ok, enough of that. Let's move on!
 ## Quick Summary of Steps
 
 Units.NET uses [CodeGen](https://github.com/angularsen/UnitsNet/tree/master/CodeGen), a C# command line app that reads [JSON files with quantity and unit definitions](https://github.com/angularsen/UnitsNet/tree/master/Common/UnitDefinitions) and generates C# code.
+See the [Quantity and Unit Definition Schema](quantity-and-unit-definition-schema.md) for a field-by-field reference.
 
 To add a quantity or a unit:
 
@@ -66,6 +69,7 @@ Not too difficult. Below are the detailed steps.
 
 * Place in [Common/UnitDefinitions](https://github.com/angularsen/UnitsNet/tree/master/Common/UnitDefinitions)
 * See [Length.json](https://github.com/angularsen/UnitsNet/tree/master/Common/UnitDefinitions/Length.json) as an example.
+* Use the [Quantity and Unit Definition Schema](quantity-and-unit-definition-schema.md) as the reference for supported properties and values.
 * Use reliable references, such as [UN/ECE Recommendation No. 21](https://unece.org/fileadmin/DAM/cefact/recommendations/rec20/rec20_rev3_Annex2e.pdf), Google, Wolfram Alpha or online converters.
 
 #### Conversion function conventions
@@ -86,6 +90,9 @@ Prefer the most widely used abbreviation in the domain, but try to adapt to our
 * Use `/` over `⁻¹`, such as `km/h` and `J/(mol·K)`
 * Use `h` for hours, `min` for minutes and `s` for seconds (`m` is ambiguous with meters)
 * Use abbreviations defined by [SI Unit System](https://en.wikipedia.org/wiki/International_System_of_Units), such as `l` instead of `L` for liters
+* For force-derived compound units, prefer the technically precise force abbreviation as the primary abbreviation: `lbf`, `ozf`, `gf`, etc. Common shorthand variants such as `lb`, `oz`, or `g` may be added as secondary abbreviations when they are widely used and unambiguous for that quantity. For example, `lbf·ft` should be the primary abbreviation for pound-force foot torque, but `lb·ft` can be accepted as a parsing alias. Do not add shorthand aliases if they would be ambiguous within the same quantity.
+* If a common shorthand abbreviation fits multiple quantities, add it to each relevant quantity, e.g. `ft-lb` for torque and energy, or `oz·in` for torque and static unbalance if both are supported. Global parsing should be ambiguous, while quantity-specific parsing still works.
+* Prefer singular unit symbols such as `lb` and `oz`, not pluralized forms such as `lbs` and `ozs`. A pluralized form can be accepted as a secondary abbreviation if it is a strong domain convention, but it should not normally be the primary abbreviation.
 * Use suffixes to distinguish variants of similar units, such as `gal (U.S.)` vs `gal (imp.)` for gallons
   * `(U.S.)` for United States
   * `(imp.)` for imperial / British units
@@ -100,7 +107,7 @@ The [7 SI base units](https://en.wikipedia.org/wiki/SI_base_unit#Seven_SI_base_u
 - `M` - Mass
 - `T` - Time
 - `I` - ElectricCurrent
-- `Theta` - Temperature
+- `Θ` - Temperature
 - `N` - AmountOfSubstance
 - `J` - LuminousIntensity
 
@@ -206,6 +213,7 @@ git push
 ## Logarithmic Units
 
 Units.NET supports logarithmic units by adding `Logarithmic` and `LogarithmicScalingFactor` (optional) properties.
+See [Logarithmic quantities](quantity-and-unit-definition-schema.md#logarithmic-quantities) for the exact conversion model and examples.
 
 * `LogarithmicScalingFactor` is used to provide a scaling factor in the logarithmic conversion. For example, a scaling factor of `2` is required when implementing the ratio of the squares of two field amplitude quantities such as voltage. In most cases `LogarithmicScalingFactor` will be `1`.
 
diff --git a/Docs/adding-operator-overloads.md b/Docs/adding-operator-overloads.md
index 46f453a0a7..3ea8eb80d7 100644
--- a/Docs/adding-operator-overloads.md
+++ b/Docs/adding-operator-overloads.md
@@ -2,6 +2,15 @@
 
 There is a large number of operator overloads, to facilitate strongly typed computations such as `Speed speed = Length.FromMeters(100) / TimeSpan.FromSeconds(9)`.
 
+Operators that can be expressed as a multiplication, division, or inverse relation may be generated from
+`Common/UnitRelations.json`; see [Quantity relations](quantity-and-unit-definition-schema.md#quantity-relations).
+
+For generated relation tests, use the existing relation-test ownership pattern:
+
+- Multiplication tests go in `<LeftQuantity>Tests.cs`, where `LeftQuantity` is the first operand in the explicit `UnitRelations.json` entry. Put the inferred reversed multiplication test there too.
+- Inferred division tests go in `<ResultQuantity>Tests.cs`, because the generated division operators are exposed by the result quantity.
+- Inverse relation tests go in each quantity's own test file, because each side gets its own `Inverse()` method.
+
 1. Put operator overload in `Length.extra.cs` if the **first parameter** is `Length`
 2. Add a short xmldoc summary as per the example below. You can add more descriptions if it is useful.
 3. Add a unit test case and place it in the equivalent file `LengthTests.cs`.
diff --git a/Docs/extending-with-custom-units.md b/Docs/extending-with-custom-units.md
index 0ff86eb36e..cfbba73989 100644
--- a/Docs/extending-with-custom-units.md
+++ b/Docs/extending-with-custom-units.md
@@ -1,15 +1,31 @@
 # Extending with Custom Units
 
+## Recommended prototype: UnitsNet.Modular
+
+[UnitsNet.Modular](../UnitsNet.Modular/README.md) is our prototype for a better way to add
+application-specific quantities and units. It is a proof of concept and currently in pre-release,
+but it generates strongly typed quantity structs, unit enums, conversions, parsing, formatting, and
+metadata from your JSON definitions at compile time.
+
+Start with [Add custom quantities](../UnitsNet.Modular/README.md#add-custom-quantities), or explore the
+[UnitsNet.Modular samples in GitHub Codespaces](https://codespaces.new/angularsen/UnitsNet?devcontainer_path=.devcontainer%2Funitsnet-modular%2Fdevcontainer.json&quickstart=1).
+
+`UnitsNet` and `UnitsNet.Modular` are alternative implementations and cannot be referenced together
+in the same consumer project. If you need to keep using the established `UnitsNet` package, the
+runtime approach below remains available.
+
+## Secondary approach: runtime custom quantities in UnitsNet
+
 This article is for when you want to add your own custom quantities and units at runtime, not included in the UnitsNet nuget.
 
 To add new quantities or units to the `UnitsNet` nuget, please see [Adding a New Unit](adding-a-new-unit.md).
 
-## Disclaimer: This is highly experimental and incomplete
+### Disclaimer: This is highly experimental and incomplete
 
 You miss out on the statically generated code for members like `Length.FromMeters(1)` and `myLength.Meters`.
 Conversion methods like `myLength.As()` and `myLength.ToUnit()` currently only support their respective unit enums, in this case `LengthUnit`.
 
-## Can I add a custom unit to an existing quantity in UnitsNet?
+### Can I add a custom unit to an existing quantity in UnitsNet?
 
 Currently, no.
 
@@ -21,14 +37,14 @@ Since UnitsNet is so statically typed, your options are limited to:
 1. Submit a pull request to [add a new unit](adding-a-new-unit.md) to the UnitsNet nuget
 2. Build your own custom version of UnitsNet
 
-## Why add a custom quantity?
+### Why add a custom quantity?
 
 Good question.
 
 In its current state, the support for custom quantities and units is limited and provides limited integration with the existing units and code.
 We consider it exploratory, to see what is possible, and we welcome ideas on how it can be improved.
 
-### Key benefits
+#### Key benefits
 
 - Reuse functionality that operates on `IQuantity`
   - Dynamically convert to unit with `.As(Enum)`
@@ -38,25 +54,25 @@ We consider it exploratory, to see what is possible, and we welcome ideas on how
   - Also allows you to dynamically convert between your custom units and the built-in units, such as `CustomLengthUnit.ElbowToThumb` to `LengthUnit.Meter`.
 - Reuse `QuantityParser` and `UnitParser` to parse quantity strings like "5 cm" and "cm" for your own quantities and units
 
-### What could be better
+#### What could be better
 
 - Source generators via nuget, if possible [Using source generators #902](https://github.com/angularsen/UnitsNet/issues/902)
 - String-based lookup instead of enum-based for quantity methods like `As()` and `ToUnit()`, required for [XP One nuget per quantity #1181](https://github.com/angularsen/UnitsNet/pull/1181)
 
 Got more ideas? Create a discussion or issue.
 
-## Units.NET structure
+### Units.NET structure
 
 Units.NET roughly consists of these parts:
 * Quantities like `Length` and `Force`
 * Unit enum values like `LengthUnit.Meter` and `ForceUnit.Newton`
 * `UnitAbbreviationsCache`, `UnitParser`, `QuantityParser` and `UnitConverter` for parsing and converting quantities and units
-* JSON files for defining units, conversion functions and abbreviations
+* [JSON files for defining units, conversion functions and abbreviations](quantity-and-unit-definition-schema.md)
 * `CodeGen` console app to generate C# code based on JSON files
 
-## Example: Custom quantity `HowMuch` with units `HowMuchUnit`
+### Example: Custom quantity `HowMuch` with units `HowMuchUnit`
 
-### Sample output
+#### Sample output
 ```
 GetDefaultAbbreviation(): sm, lts, tns
 Parse<HowMuchUnit>(): Some, Lots, Tons
@@ -67,7 +83,7 @@ Convert 10 tons to:
 10 tns
 ```
 
-### Map unit enum values to unit abbreviations
+#### Map unit enum values to unit abbreviations
 
 ```c#
 UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "sm");
@@ -75,7 +91,7 @@ UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation(HowMuchUnit.Lots, "l
 UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation(HowMuchUnit.Tons, "tns");
 ```
 
-### Lookup unit abbreviations from enum values
+#### Lookup unit abbreviations from enum values
 
 ```c#
 Console.WriteLine("GetDefaultAbbreviation(): " + string.Join(", ",
@@ -85,7 +101,7 @@ Console.WriteLine("GetDefaultAbbreviation(): " + string.Join(", ",
 ));
 ```
 
-### Parse unit abbreviations back to enum values
+#### Parse unit abbreviations back to enum values
 
 ```c#
 Console.WriteLine("Parse<HowMuchUnit>(): " + string.Join(", ",
@@ -95,7 +111,7 @@ Console.WriteLine("Parse<HowMuchUnit>(): " + string.Join(", ",
 ));
 ```
 
-### Convert between units of custom quantity
+#### Convert between units of custom quantity
 
 ```c#
 var unitConverter = UnitConverter.Default;
@@ -112,7 +128,7 @@ Console.WriteLine(Convert(HowMuchUnit.Lots)); // 100 lts
 Console.WriteLine(Convert(HowMuchUnit.Tons)); // 10 tns
 ```
 
-### Sample quantity
+#### Sample quantity
 
 See the sample implementation in the test suite:
 - [HowMuchUnit.cs](https://github.com/angularsen/UnitsNet/blob/master/UnitsNet.Tests/CustomQuantities/HowMuchUnit.cs)
diff --git a/Docs/nanoframework.md b/Docs/nanoframework.md
deleted file mode 100644
index d1aca78d8b..0000000000
--- a/Docs/nanoframework.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# .NET nanoFramework
-
-.NET nanoFramework is a free and open-source platform that enables the writing of managed code applications for constrained embedded devices. It is suitable for many types of projects including IoT sensors, wearables, academic proof of concept, robotics, hobbyist/makers creations or even complex industrial equipment.
-
-https://www.nanoframework.net/
-
-## Update nanoFramework dependencies
-
-Units.NET publishes quantities as individual nuget packages, which means there is a large number of projects to maintain.
-To overcome this, the CodeGen project generates the solution file, project files and .nuspec files - in addition to source code.
-
-The dependencies are hard coded in the code generator, so in order to update the dependencies you must specify an extra flag.
-
-```sh
-cd CodeGen
-dotnet run --update-nano-framework-dependencies
-```
-
-As of this writing, `mscorlib` and `System.Math` are the two nuget dependencies to update.
diff --git a/Docs/precision.md b/Docs/precision.md
index 6f929d4798..668b19cccf 100644
--- a/Docs/precision.md
+++ b/Docs/precision.md
@@ -4,13 +4,30 @@ Units.NET was not designed for high-precision, but rather a tool of convenience
 
 - A base unit is chosen for all quantities
   - SI base unit is preferred where available, such as `LengthUnit.Meter` and `VolumeUnit.CubicMeter`.
+  - See the [`BaseUnit` schema reference](quantity-and-unit-definition-schema.md#quantity-object) for how it is declared.
   - `MassUnit.Gram` was chosen to better support SI prefixes like `kilo`, `mega` etc.
 - The value is typically represented by a `double` value (64-bit)
 - Conversions go via the base unit.
   - Centimeter => Meter => Kilometer
   - As a result, most conversions have a rounding error. The error is larger for units that are way larger or way smaller than the base unit.
   - A rounding error of `1e-5` is accepted for round-trip conversion of most units in the library. In many use cases this is sufficient, but for others this may not be acceptable.
-  - There is support for [custom conversion functions](https://github.com/angularsen/UnitsNet#convert-between-units-of-custom-quantity) between unit A to unit B, typically to add 3rd party units. This can also be used to improve the precision for specific conversions since it no longer converts via the base unit.
+  - In v6, unit conversion definitions can be customized before the converter is built. This can be used to override a built-in conversion factor or add conversion functions for custom quantities.
+
+## Overriding built-in unit conversions
+
+Built-in unit definitions can be customized through `UnitsNetSetup.ConfigureDefaults()` before the default setup is used:
+
+```csharp
+UnitsNetSetup.ConfigureDefaults(builder => builder.ConfigureQuantity(() =>
+    Pressure.PressureInfo.CreateDefault(units =>
+        units.Configure(PressureUnit.InchOfWaterColumn, unit =>
+            unit.WithConversionFactorFromBase(999)))));
+
+var pressure = Pressure.FromPascals(1);
+double value = pressure.As(PressureUnit.InchOfWaterColumn); // 999
+```
+
+For isolated conversions, create a custom `QuantityInfo` and pass it to a custom `UnitConverter` instead of changing the global defaults. See `Samples/UnitsNetSetup.Configuration/ConfigureWithCustomConversions.cs` for a complete example.
 
 ## Test precision
 
diff --git a/Docs/quantity-and-unit-definition-schema.md b/Docs/quantity-and-unit-definition-schema.md
new file mode 100644
index 0000000000..9b3752583f
--- /dev/null
+++ b/Docs/quantity-and-unit-definition-schema.md
@@ -0,0 +1,365 @@
+# Quantity and Unit Definition Schema
+
+Units.NET quantity and unit definitions are JSON files in
+[`Common/UnitDefinitions`](../Common/UnitDefinitions). Each file describes one quantity, the units that belong to it,
+their conversions, abbreviations, and optional code-generation behavior.
+
+This is the contributor-facing schema reference for those files. The deserialization types in
+[`CodeGen/JsonTypes`](../CodeGen/JsonTypes) and the code generator are the implementation source of truth.
+
+> [!IMPORTANT]
+> The current JSON deserializer is permissive: unknown properties are ignored and some missing properties are not
+> rejected until generated code is compiled or tested. Treat properties marked as required here as required, and do
+> not rely on unknown properties being accepted.
+
+For the contribution workflow and style conventions, see
+[Adding a New Quantity or Unit](adding-a-new-unit.md).
+
+## Minimal definition
+
+The following is a minimal definition of a linear quantity with one unit:
+
+```json
+{
+  "Name": "Length",
+  "BaseUnit": "Meter",
+  "XmlDocSummary": "Length is a measure of distance.",
+  "BaseDimensions": {
+    "L": 1
+  },
+  "Units": [
+    {
+      "SingularName": "Meter",
+      "PluralName": "Meters",
+      "BaseUnits": {
+        "L": "Meter"
+      },
+      "FromUnitToBaseFunc": "{x}",
+      "FromBaseToUnitFunc": "{x}",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "m" ]
+        }
+      ]
+    }
+  ]
+}
+```
+
+By convention, the filename is `<Name>.json`, such as `Length.json`. Quantity and unit names use PascalCase and must
+be valid C# identifiers because they become generated type and member names.
+
+## UnitsNet.Modular compatibility
+
+UnitsNet.Modular adds the optional `Namespace` field. It defaults to `UnitsNet` and becomes part of the stable
+semantic ID `Namespace.Name`; use a namespace you own for custom and third-party definitions. Repository CodeGen
+ignores this field.
+
+Add a custom definition to a Modular project as a Roslyn `AdditionalFiles` item. See
+[Add custom quantities](../UnitsNet.Modular/README.md#add-custom-quantities) for registration and selection.
+
+## Quantity object
+
+The root JSON object represents a quantity.
+
+| Property | Type | Required/default | Description |
+|---|---|---|---|
+| `Name` | string | Required | PascalCase quantity name used for the generated quantity type and unit enum. Conventionally matches the filename. |
+| `Namespace` | string | `UnitsNet` | UnitsNet.Modular only. Namespace for generated types and part of the stable semantic ID `Namespace.Name`. Ignored by repository CodeGen. |
+| `BaseUnit` | string | Required | `SingularName` of the unit through which conversions are performed. It must identify exactly one entry in `Units`. |
+| `XmlDocSummary` | string | Required | XML documentation summary for the generated quantity type. XML documentation elements such as `<c>` may be used. |
+| `XmlDocRemarks` | string | Optional | Additional XML documentation remarks for the generated quantity type. Often contains a reference URL. |
+| `BaseDimensions` | object | All exponents default to `0` | Exponents of the seven SI base dimensions. See [Base dimensions](#base-dimensions). |
+| `AffineOffsetType` | string | Optional | Marks an affine quantity and names the quantity used to represent differences, such as `TemperatureDelta` for `Temperature`. |
+| `Logarithmic` | boolean-like | `false` | Generates logarithmic arithmetic and implements `ILogarithmicQuantity`. Existing definitions use the legacy string `"True"`; a JSON boolean is also accepted by the current deserializer. |
+| `LogarithmicScalingFactor` | integer-like | `1` | Multiplier applied to the conventional factor of 10 for logarithmic arithmetic. Existing definitions use strings such as `"1"` and `"2"`; JSON integers are also accepted. Only meaningful when `Logarithmic` is true. See [Logarithmic quantities](#logarithmic-quantities). |
+| `ObsoleteText` | string | Optional | Generates an `Obsolete` attribute with this message for the quantity and its generated numeric extension methods. |
+| `Units` | array of unit objects | Required | Units belonging to the quantity. At least one unit is required, and one must match `BaseUnit`. |
+
+`AffineOffsetType` and `Logarithmic` describe different arithmetic models and must not be combined.
+
+### Base dimensions
+
+`BaseDimensions` maps SI dimension symbols to integer exponents. Missing dimensions have exponent zero.
+
+| Key | Dimension | Example |
+|---|---|---|
+| `L` | Length | `Length`: `{ "L": 1 }` |
+| `M` | Mass | `Density`: `{ "M": 1, "L": -3 }` |
+| `T` | Time | `Frequency`: `{ "T": -1 }` |
+| `I` | Electric current | `ElectricCurrent`: `{ "I": 1 }` |
+| `Θ` | Thermodynamic temperature | `Temperature`: `{ "Θ": 1 }` |
+| `N` | Amount of substance | `AmountOfSubstance`: `{ "N": 1 }` |
+| `J` | Luminous intensity | `LuminousIntensity`: `{ "J": 1 }` |
+
+The temperature key is the Greek capital theta `Θ`, not the word `Theta`. Dimensionless quantities may omit
+`BaseDimensions` or use an empty object.
+
+`BaseDimensions` describes the quantity's dimensional exponents. It is distinct from:
+
+- `BaseUnit`, the intermediate unit used for conversions.
+- A unit's `BaseUnits`, the concrete SI base-unit choices used for unit-system selection.
+
+## Unit object
+
+Each entry in `Units` represents one unit.
+
+| Property | Type | Required/default | Description |
+|---|---|---|---|
+| `SingularName` | string | Required | PascalCase singular unit name. Becomes an enum member and part of generated factory and conversion member names. Must be unique within the quantity. |
+| `PluralName` | string | Required | PascalCase plural unit name. Used in generated member names such as `Length.Meters`. |
+| `FromUnitToBaseFunc` | string | Required | C# expression that converts `{x}` from this unit to the quantity's `BaseUnit`. |
+| `FromBaseToUnitFunc` | string | Required | Inverse C# expression that converts `{x}` from the quantity's `BaseUnit` to this unit. |
+| `BaseUnits` | object | Optional | Concrete SI base-unit names used to match this unit to a `UnitSystem`. See [Base units](#base-units). |
+| `Prefixes` | array of strings | Empty | Prefix names for which CodeGen generates additional units. See [Prefixes](#prefixes). |
+| `Localization` | array of localization objects | Required | Culture-specific abbreviations. Every unit should define `en-US`. |
+| `XmlDocSummary` | string | Optional | XML documentation summary for the generated unit enum member. |
+| `XmlDocRemarks` | string | Optional | Additional XML documentation remarks for the generated unit enum member. Often contains a reference URL. |
+| `ObsoleteText` | string | Optional | Generates an `Obsolete` attribute with this message for the unit and its generated numeric extension methods. |
+
+The base-unit entry should use identity conversion expressions:
+
+```json
+"FromUnitToBaseFunc": "{x}",
+"FromBaseToUnitFunc": "{x}"
+```
+
+### Conversion expressions
+
+Conversions always go through the quantity's `BaseUnit`:
+
+```text
+source unit --FromUnitToBaseFunc--> BaseUnit --FromBaseToUnitFunc--> target unit
+```
+
+The conversion properties contain C# numeric expressions. CodeGen replaces every `{x}` placeholder with the input
+value and emits the expression into generated C# code. Expressions may use numeric literals, arithmetic operators,
+parentheses, and available APIs such as `Math.PI`.
+
+The two expressions must be inverses. For example, with meters as the base unit:
+
+```json
+{
+  "SingularName": "Centimeter",
+  "PluralName": "Centimeters",
+  "FromUnitToBaseFunc": "{x} / 100",
+  "FromBaseToUnitFunc": "{x} * 100"
+}
+```
+
+Affine units include an offset:
+
+```json
+{
+  "SingularName": "DegreeCelsius",
+  "PluralName": "DegreesCelsius",
+  "FromUnitToBaseFunc": "{x} + 273.15",
+  "FromBaseToUnitFunc": "{x} - 273.15"
+}
+```
+
+Use `{x}` exactly, preserve exact constituent constants where possible, and follow the
+[conversion function conventions](adding-a-new-unit.md#conversion-function-conventions). Since expressions are C#
+source rather than a language-neutral expression format, other platform generators must translate the supported
+expression syntax.
+
+### Base units
+
+`BaseUnits` maps the same seven dimension keys to singular unit names from the corresponding SI base quantities.
+It allows APIs such as `new Length(1, UnitSystem.SI)` to select a suitable unit.
+
+For example, the newton has:
+
+```json
+"BaseUnits": {
+  "L": "Meter",
+  "M": "Kilogram",
+  "T": "Second"
+}
+```
+
+Only the concrete unit choice is stored; dimensional exponents come from the quantity's `BaseDimensions`. For example,
+an area unit can use `{ "L": "Centimeter" }` even though the length dimension has exponent 2.
+
+`BaseUnits` may be omitted when no meaningful mapping exists, such as for a gallon or a dimensionless ratio.
+
+### Prefixes
+
+`Prefixes` tells CodeGen to derive additional units from the current unit. For example:
+
+```json
+"Prefixes": [ "Milli", "Kilo", "Mega" ]
+```
+
+For each prefix, CodeGen:
+
+- Creates singular and plural names by prepending the prefix.
+- Adjusts both conversion expressions by the prefix factor.
+- Prefixes each localized abbreviation, unless an explicit override is configured.
+- Attempts to infer prefixed `BaseUnits`.
+
+Accepted metric prefixes are:
+
+`Yocto`, `Zepto`, `Atto`, `Femto`, `Pico`, `Nano`, `Micro`, `Milli`, `Centi`, `Deci`, `Deca`, `Hecto`, `Kilo`,
+`Mega`, `Giga`, `Tera`, `Peta`, `Exa`, `Zetta`, and `Yotta`.
+
+Accepted binary prefixes are:
+
+`Kibi`, `Mebi`, `Gibi`, `Tebi`, `Pebi`, and `Exbi`.
+
+Do not also define a generated prefixed unit explicitly.
+
+Do not use `Prefixes` when the prefix would apply to only part of a powered or compound unit and change the meaning,
+or when it would create an abbreviation already used by another unit of the same quantity. Define explicit units
+instead. For example, define `CubicMillimeterPerKilogram` for `mm³/kg` instead of generating
+`MillicubicMeterPerKilogram`, and define `ThousandCubicMeter` with an abbreviation such as `10³·m³` when the intended
+unit is 1000 cubic meters rather than cubic kilometers.
+
+CodeGen fails when `Prefixes` is used on a unit that looks like the powered unit itself, such as a unit name starting
+with `Square` or `Cubic`, or an abbreviation starting with `m²`, `m³`, `ft³`, or similar powered unit symbols. For
+example, generating `Kilo` from `SquareMeter` would produce `km²`, which means one square kilometer (`1e6 m²`), not
+one thousand square meters. Generating it from `CubicMeter` would produce `km³`, which means one cubic kilometer
+(`1e9 m³`), not one thousand cubic meters.
+
+This is a naming and abbreviation heuristic, not a dimensional-analysis check. Derived units such as `Watt`, `Joule`,
+and `Ohm` have powered SI base dimensions, but can safely use `Prefixes` because their own abbreviations are not
+powered unit symbols. They produce unambiguous units such as `MW`, `MJ`, and `MΩ`.
+
+## Localization object
+
+Each `Localization` entry configures abbreviations for one culture.
+
+| Property | Type | Required/default | Description |
+|---|---|---|---|
+| `Culture` | string | Required | .NET culture name, such as `en-US`, `ru-RU`, or `zh-CN`. |
+| `Abbreviations` | array of strings | Empty | Unit symbols and parsing aliases. The first abbreviation is the default used for formatting. Empty is valid for units such as `Ratio.DecimalFraction`. |
+| `AbbreviationsForPrefixes` | object | Optional | Explicit abbreviations for selected generated prefixes. Each key is a configured prefix name and each value is a string or array of strings. |
+
+By default, CodeGen prepends the localized prefix symbol to every abbreviation. Use `AbbreviationsForPrefixes` when
+that would produce the wrong symbol or symbol order:
+
+```json
+{
+  "Culture": "en-US",
+  "Abbreviations": [ "∆°C" ],
+  "AbbreviationsForPrefixes": {
+    "Milli": "∆m°C"
+  }
+}
+```
+
+Follow the [abbreviation naming conventions](adding-a-new-unit.md#abbreviation-naming-conventions). Abbreviation
+ambiguity across different quantities is allowed, but aliases must not make two units of the same quantity
+indistinguishable.
+
+## Specialized quantity models
+
+### Linear quantities
+
+A quantity is linear when both `AffineOffsetType` and `Logarithmic` are omitted. Generated arithmetic operates
+directly on converted values. This is the default and applies to quantities such as `Length`, `Mass`, and `Power`.
+
+### Affine quantities
+
+An affine quantity represents points on a scale where differences use a separate quantity type. Set
+`AffineOffsetType` to that difference quantity:
+
+```json
+"AffineOffsetType": "TemperatureDelta"
+```
+
+[`Temperature.json`](../Common/UnitDefinitions/Temperature.json) is the current example. Its unit conversions include
+scale offsets, while [`TemperatureDelta.json`](../Common/UnitDefinitions/TemperatureDelta.json) defines conversions
+between differences without absolute-scale offsets.
+
+### Logarithmic quantities
+
+Set `Logarithmic` on a quantity to generate logarithmic arithmetic:
+
+```json
+"Logarithmic": "True",
+"LogarithmicScalingFactor": "2"
+```
+
+The string representation above is retained by existing definitions for compatibility. The values deserialize to a
+Boolean and an integer respectively.
+
+Let `n` be the JSON `LogarithmicScalingFactor`. CodeGen exposes and uses the effective scaling factor:
+
+```text
+S = 10 × n
+logarithmic value = S × log10(linear value)
+linear value      = 10^(logarithmic value / S)
+```
+
+Therefore:
+
+| Quantity model | JSON value | Effective factor | Typical relationship |
+|---|---:|---:|---|
+| Power or generic level | `1` | `10` | `10 × log10(P/P₀)` |
+| Field amplitude, such as voltage | `2` | `20` | `20 × log10(V/V₀)` |
+
+The factor is used when generated operators and `LogarithmicQuantityExtensions` convert values to linear space for
+addition, subtraction, sums, and means. It is not automatically applied to `FromUnitToBaseFunc` or
+`FromBaseToUnitFunc`; those expressions still define conversion between the logarithmic units and their reference
+levels. For example, converting dBm to dBW subtracts 30.
+
+Current examples are:
+
+- [`Level.json`](../Common/UnitDefinitions/Level.json) — generic decibels and nepers, factor 1.
+- [`PowerRatio.json`](../Common/UnitDefinitions/PowerRatio.json) — dBW and dBm, factor 1.
+- [`AmplitudeRatio.json`](../Common/UnitDefinitions/AmplitudeRatio.json) — voltage-referenced levels, factor 2.
+
+Logarithmic quantities require custom arithmetic test values; see the
+[contribution workflow](adding-a-new-unit.md#logarithmic-units).
+
+## Quantity relations
+
+Cross-quantity multiplication, division, and inverse relations are not properties of an individual quantity
+definition. They are declared separately in [`Common/UnitRelations.json`](../Common/UnitRelations.json).
+
+Each entry has this form:
+
+```text
+ResultQuantity.ResultUnit = LeftQuantity.LeftUnit * RightQuantity.RightUnit
+```
+
+For example:
+
+```json
+"Force.Newton = Mass.Kilogram * Acceleration.MeterPerSecondSquared"
+```
+
+CodeGen infers commutative multiplication and corresponding division operators. Append `-- NoInferredDivision` when
+the inferred division would be ambiguous. Use `1` as the result for inverse relationships and `double` for a unitless
+numeric operand.
+
+## Internal and reserved properties
+
+The deserialization model contains two unit properties that are not used by normal definitions:
+
+- `SkipConversionGeneration` defaults to `false` and suppresses generated convenience conversion members, numeric
+  extensions, and related tests. No current unit definition uses it.
+- `AllowAbbreviationLookup` defaults to `true`, but the current generators do not consume it. Setting it has no
+  observable effect.
+
+Do not use these properties in contributor definitions without a corresponding CodeGen change and tests.
+`Quantity.Relations` is also internal generated state populated from `Common/UnitRelations.json`, not a property to
+set in a quantity definition.
+
+Some existing definitions contain historical properties such as `XmlDoc`, `XmlDocsRemarks`, `BaseType`, or
+`OmitExtensionMethod`. The current deserialization model does not recognize them, so they have no effect and must not
+be copied into new definitions.
+
+## Validation workflow
+
+After changing a definition:
+
+1. Run `generate-code.bat` or `dotnet run --project CodeGen`.
+2. Inspect the generated changes.
+3. Add or update independently sourced conversion test values.
+4. Run `build.bat` or `dotnet build UnitsNet.slnx`.
+5. Run the relevant tests.
+
+Generated files under `GeneratedCode` must not be edited manually.
diff --git a/Docs/serialization.md b/Docs/serialization.md
index 34e1be5482..eeb2a6f2fd 100644
--- a/Docs/serialization.md
+++ b/Docs/serialization.md
@@ -4,7 +4,7 @@
 - [UnitsNet.Serialization.JsonNet with Json.NET (Newtonsoft)](#unitsnetserializationjsonnet-with-jsonnet-newtonsoft)
 - [DataContractSerializer for XML](#datacontractserializer-for-xml)
 - [DataContractJsonSerializer for JSON (not recommended)](#datacontractjsonserializer-for-json-not-recommended)
-- [System.Text.Json (not yet implemented)](#systemtextjson-not-yet-implemented)
+- [UnitsNet.Serialization.SystemTextJson](#unitsnetserializationsystemtextjson)
 - [Protobuf and other `[DataContract]` compatible serializers](#protobuf-and-other-datacontract-compatible-serializers)
 - [Backwards compatibility](#backwards-compatibility)
 
@@ -81,14 +81,49 @@ If you need to support deserializing into properties/fields of type `IComparable
 jsonSerializerSettings.Converters.Add(new UnitsNetIComparableJsonConverter());
 ```
 
+### Choosing a `QuantityValue` format
+
+`AbbreviatedUnitsConverter` uses `DecimalPrecision` when writing and `ExactNumber` when reading by default. Configure the
+value representation explicitly when exact round-tripping or compatibility with an existing `double`-based payload is
+required:
+
+```c#
+var valueFormats = new QuantityValueFormatOptions(
+    QuantityValueSerializationFormat.RoundTrip,
+    QuantityValueDeserializationFormat.RoundTrip);
+
+jsonSerializerSettings.Converters.Add(new AbbreviatedUnitsConverter(valueFormats));
+```
+
+Available serialization formats are decimal precision (up to 29 significant digits), double precision, exact
+round-tripping and a custom converter. `ExactNumber` reads every digit of a JSON number directly into its numeric
+`QuantityValue`; it does not retain the original spelling of the token. Deserialization can alternatively recover
+conventional rounded `double` values, read the round-trip representation or use a custom converter.
+
 ## DataContractSerializer for XML
 
 All quantities and the `IQuantity` interface have `[DataContract]` annotations and can be serialized by the built-in XML [DataContractSerializer](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.serialization.datacontractserializer).
 
+Because `QuantityValue` is fraction-backed, configure the supplied surrogate provider to avoid exposing the internal
+`BigInteger` representation of its numerator and denominator:
+
+```c#
+using System.Runtime.Serialization;
+using UnitsNet.Serialization;
+
+var serializer = new DataContractSerializer(typeof(Power));
+serializer.SetSerializationSurrogateProvider(QuantityValueSurrogateSerializationProvider.Instance);
+```
+
+The compact representation stores the exact numerator and denominator:
+
 ```xml
 <Power xmlns="http://schemas.datacontract.org/2004/07/UnitsNet"
        xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
-    <Value>1.20</Value>
+    <Value>
+        <N>12</N>
+        <D>10</D>
+    </Value>
     <Unit>Milliwatt</Unit>
 </Power>
 ```
@@ -111,7 +146,10 @@ new Foo { Quantity = new Information(1.20m, InformationUnit.Exabyte) };
 <Foo xmlns="http://schemas.datacontract.org/2004/07/UnitsNet.Tests.Serialization"
                      xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
     <Quantity i:type="a:Information" xmlns:a="http://schemas.datacontract.org/2004/07/UnitsNet">
-        <a:Value>1.20</a:Value>
+        <a:Value>
+            <a:N>12</a:N>
+            <a:D>10</a:D>
+        </a:Value>
         <a:Unit>Exabyte</a:Unit>
     </Quantity>
 </Foo>
@@ -134,11 +172,44 @@ Schema:
 }
 ```
 
-## System.Text.Json (not yet implemented)
+## UnitsNet.Serialization.SystemTextJson
+
+Install the `UnitsNet.Serialization.SystemTextJson` package and register converters for the value, unit and quantity
+representations you want. For concrete quantity types, this example writes readable decimal values and unit
+abbreviations:
+
+```c#
+using System.Text.Json;
+using UnitsNet.Serialization.SystemTextJson;
+using UnitsNet.Serialization.SystemTextJson.Unit;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+var options = new JsonSerializerOptions();
+options.Converters.Add(new QuantityValueDecimalNotationConverter());
+options.Converters.Add(new AbbreviatedUnitConverter());
+options.Converters.Add(new JsonQuantityConverter());
+
+string json = JsonSerializer.Serialize(Mass.FromGrams(4.2), options);
+Mass mass = JsonSerializer.Deserialize<Mass>(json, options);
+// {"Value":4.2,"Unit":"g"}
+```
+
+To serialize properties declared as `IQuantity`, use an interface converter. The payload includes the quantity type so it
+can be reconstructed:
+
+```c#
+var options = new JsonSerializerOptions();
+options.Converters.Add(new QuantityValueDecimalNotationConverter());
+options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+
+string json = JsonSerializer.Serialize<IQuantity>(Length.FromMeters(10), options);
+IQuantity quantity = JsonSerializer.Deserialize<IQuantity>(json, options);
+// {"Value":10,"Unit":"m","Type":"Length"}
+```
 
-See
-- [WIP: Add serialization support for System.Text.Json #905](https://github.com/angularsen/UnitsNet/pull/905)
-- [Add serialization support for System.Text.Json (Attempt #2) #966](https://github.com/angularsen/UnitsNet/pull/966)
+For exact round-tripping, use `QuantityValueMixedNotationConverter`. It emits finite values as decimal numbers and
+non-terminating values such as one third as fractional strings. Other converters provide fractional-object, decimal and
+`double` representations.
 
 ## Protobuf and other `[DataContract]` compatible serializers
 
diff --git a/Docs/string-formatting.md b/Docs/string-formatting.md
index 9f6ce8ec20..2eb940bf29 100644
--- a/Docs/string-formatting.md
+++ b/Docs/string-formatting.md
@@ -1,51 +1,65 @@
-# String Formatting
+# String formatting
 
-## Common examples
+Quantity formatting applies a .NET numeric format string to the value and appends the localized
+abbreviation of the quantity's current unit.
 
-Assuming computer running with US English culture.
-```c#
-var length = Length.FromCentimeters(3.14159265358979);
+```csharp
+Length length = Length.FromCentimeters(Math.PI);
 
-// Typical formats
-length.ToString(); // 3.14 cm
-length.ToString("s4"); // 3.1416 cm
+length.ToString();                                      // 3.141592653589793 cm
+length.ToString("F2", CultureInfo.InvariantCulture);   // 3.14 cm
+$"Length: {length:N3}";                                // Length: 3.142 cm with an en-US current culture
+```
+
+The parameterless overload uses the general (`G`) numeric format. Formatting honors the supplied
+`IFormatProvider`, or `CultureInfo.CurrentCulture` when none is supplied.
 
-// Localized
-length.ToString(new CultureInfo("nb-NO")); // 3,14 cm
-length.ToString(new CultureInfo("ru-RU")); // 3,14 sm (Cyrillic)
+```csharp
+length.ToString(CultureInfo.GetCultureInfo("nb-NO")); // 3,141592653589793 cm
+length.ToString(CultureInfo.GetCultureInfo("ru-RU")); // 3,141592653589793 см
+```
 
-// Converted
-length.As(LengthUnit.Meters).ToString(); // 0.13 m
+Convert the quantity before formatting when a different unit is required:
 
-// Use .NET's built-in formatting methods
-Console.WriteLine("Length is {0:v} {0:a}", l); // "Length is 3.14159265358979 ft"
-string.Format("Length is {0:v} {0:a}", l); // "Length is 3.14159265358979 ft"
-$"Length is {l:v} {l:a}"; // "Length is 3.14159265358979 ft"
+```csharp
+Length meters = length.ToUnit(LengthUnit.Meter);
+string text = meters.ToString("G3", CultureInfo.InvariantCulture); // 0.0314 m
 ```
 
-## Standard Quantity Format Strings
+## Numeric formats
 
-| Format specifier | Description | Examples |
-|------------------|-------------|---------|
-| "g" | General quantity pattern. Equivalent to parameterless `ToString()`. Rounds to 2 significant digits after the radix. | `Length.FromFeet(Math.PI).ToString("g")` -> 3.14 ft |
-| `f`, `f2`, ... `e`, `e3`, ... `r` `#.0` `00000.0` | [Standard numeric formatting](https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings#standard-format-specifiers) of value, with unit appended. | `Length.FromFeet(Math.PI).ToString("f")` -> 3.140 ft, `Length.FromFeet(Math.PI).ToString("f1")` -> 3.1 ft, `Length.FromFeet(Math.PI).ToString("r")` -> 3.141592653589793 ft, `Length.FromFeet(Math.PI).ToString("e2")` -> 3.14e+000 ft, `Length.FromFeet(Math.PI).ToString("#.0")` -> 3.1 ft, `Length.FromFeet(Math.PI).ToString("00.0")` -> 003.1 ft |
-| "aXX" | Unit abbreviation pattern. If more than one abbreviation is defined for the unit, then XX specifies the zero-indexed position in the array of abbreviations. XX defaults to 0. If the position is not found, `System.FormatException` is thrown. | `Length.FromFeet(Math.PI).ToString("a")` -> ft, `Length.FromFeet(Math.PI).ToString("a0")` -> ft, `Length.FromFeet(Math.PI).ToString("a1")` -> ', `Length.FromFeet(Math.PI).ToString("a2")` -> prime symbol, `Length.FromFeet(Math.PI).ToString("a3")` -> System.FormatException |
-| "q" | Quantity name pattern. Outputs the corresponding QuantityType enum name. | `Length.FromFeet(Math.PI).ToString("q")` -> Length, `Mass.FromTonnes(Math.PI).ToString("u")` -> Mass |
-| "u" | Unit name pattern. Each quantity type has a corresponding unit enum, such as `Length` quantity having `LengthUnit` unit enum with values `Meter`, `Centimeter` etc. This pattern outputs the unit enum name. | `Length.FromFeet(Math.PI).ToString("u")` -> Foot, `Mass.FromTonnes(Math.PI).ToString("u")` -> Tonne |
+UnitsNet accepts standard and custom .NET numeric formats, including:
 
-There are three different overloads of the ToString() method to provide a string representation of a value and its units.
+| Intent | Format | Example |
+|---|---|---|
+| General notation with a precision | `G3` | `3.14 cm` |
+| Fixed decimal places | `F2` | `3.14 cm` |
+| Grouped number with fixed decimals | `N2` | `1,234.50 cm` |
+| Scientific notation | `E2` | `3.14E+000 cm` |
+| Up to two decimal places | `0.##` | `3.14 cm` |
+| Grouped with up to two decimal places | `#,##0.##` | `1,234.5 cm` |
 
-## Number Formatting
+Currency (`C`) and percent (`P`) formats are rejected because adding currency or percent symbols to
+a physical quantity is misleading.
 
-For "g" pattern (or if no pattern is specified), the number will be formatted with scientific notation for very small or very large values to increase readability. We did not find .NET's default behavior to work well for this so we created our own rules.
+See [.NET standard numeric format strings](https://learn.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings)
+and [.NET custom numeric format strings](https://learn.microsoft.com/dotnet/standard/base-types/custom-numeric-format-strings)
+for the complete syntax.
 
-| Interval | Format | Examples |
-|-----------|-----------|-------------|
-| `(-inf <= x < 1e-03]` | scientific notation | 1e-04; 2.13e-05 |
-| `[1e-03 <= x < 1e+03]` | fixed point notation | 0.001; 0.01; 100 |
-| `[1e+03 <= x < 1e+06]` | fixed point notation with digit grouping | 1,000; 10,000; 100,000 |
-| `[1e+06 <= x <= +inf)` | scientific notation | 1.1e+06; 3.14e+07 |
+## Unit abbreviations
 
-The symbols used for digit grouping and radix point are culture-sensitive. The above examples use `CultureInfo.InvariantCulture`.
+Use the generated quantity API to get the primary localized abbreviation explicitly:
 
-For more examples, refer to the unit tests in [UnitsNet/UnitFormatter.cs](https://github.com/angularsen/UnitsNet/blob/master/UnitsNet/UnitFormatter.cs).
+```csharp
+string abbreviation = Length.GetAbbreviation(LengthUnit.Foot);
+string localized = Length.GetAbbreviation(LengthUnit.Meter, CultureInfo.GetCultureInfo("ru-RU"));
+```
+
+Use the configured abbreviation cache when every accepted abbreviation is needed. This includes
+runtime customizations made through `UnitsNetSetup`:
+
+```csharp
+IReadOnlyList<string> abbreviations = UnitsNetSetup.Default.UnitAbbreviations
+    .GetUnitAbbreviations(LengthUnit.Foot, CultureInfo.InvariantCulture);
+// "ft", "'", "′"
+```
diff --git a/Docs/upgrading-from-5.x-to-6.x.md b/Docs/upgrading-from-5.x-to-6.x.md
index feef675caf..7d36369790 100644
--- a/Docs/upgrading-from-5.x-to-6.x.md
+++ b/Docs/upgrading-from-5.x-to-6.x.md
@@ -4,31 +4,39 @@ Before upgrading to a new major version, first upgrade to the latest minor versi
 
 ## Summary of changes in v6
 
-The biggest change is removing support for `decimal` quantities and converting `Power`, `Information`, `BitRate` from `decimal` to `double`.
-The value holder type `QuantityValue` is replaced by `double`.
+The main change is that all quantities now use the fraction-backed `QuantityValue` type instead of `double` or `decimal`.
+Unit definitions are also generated as exact conversion expressions. This preserves exact relationships such as inches to
+centimeters and avoids accumulating floating-point error through intermediate conversions.
 
-The motivation was to remove a lot of complexity in the code base. Decimal was initially added for precision issues, but this was later fixed by storing both value and unit. Only `Information` still had any real benefit from `decimal`, to better represent `Bit` as an integer type and avoid rounding errors.
-
-If there is still enough demand for representing bits as an integer or avoiding rounding errors in `Information` and other quantities, then we can approach that in a simpler way like `TimeSpan.Ticks` vs `TimeSpan.TotalSeconds`.
-
-If there is sufficient demand for supporting any number type like `float`, `decimal` or even `Half`, then a more holistic approach is required using generics, which brings its own challenges.
+`QuantityValue` interoperates with the standard numeric types: numeric values convert implicitly to `QuantityValue`, and
+`QuantityValue` converts implicitly to `double`. Code that explicitly declares `double` variables will therefore often
+continue to compile, while code using `var` will now infer `QuantityValue`. Unit conversions and arithmetic remain exact
+while values stay as `QuantityValue`; converting a value to `double` is the boundary where values that cannot be represented
+as binary floating point lose precision.
 
 ## New
 
-- Allow `NaN`, `Inf` values for quantities with `double` value type #1289
+- Allow `NaN` and infinity values in quantities #1289
+- Exact fractional values, arithmetic and generated unit conversions with `QuantityValue` #1544
+- `UnitsNet.Serialization.SystemTextJson`, with configurable quantity, unit and value converters #1544
+- Annotate numeric format-string parameters with `StringSyntaxAttribute.NumericFormat` so supported IDEs can provide
+  syntax assistance
 
 ## Breaking changes
 
 ### Binary incompatible
 
-- Remove `decimal` support in quantities #1359, everything is now `double`
-    - Convert quantities `Power`, `Information`, `BitRate` from `decimal` to `double` #1195, #1353
-    - Remove `QuantityValue`, replaced with `double`
+- Rework `QuantityValue` as a fraction-backed number and use it for every quantity value #1544
+    - `IQuantity.Value`, generated unit properties, `.As()`, ratio methods and related conversion APIs now return `QuantityValue`
+    - Quantity factories and constructors now accept `QuantityValue`; standard numeric arguments continue to work through implicit conversions
+    - `Power`, `Information` and `BitRate` no longer have a separate `decimal` value type
+- Rework `UnitConverter` configuration and conversion APIs around exact generated conversion expressions #1544
 - Remove `TValueType` from interfaces
     - Remove `IQuantity<TUnitType, out TValueType>`
     - Remove `IValueQuantity<out TValueType>`
     - Change `IQuantity<TSelf, TUnitType, out TValueType>` to `IQuantity<TSelf, TUnitType>`
     - Change `IArithmeticQuantity<TSelf, TUnitType, TValueType>` to `IArithmeticQuantity<TSelf, TUnitType>`
+- Move `IQuantity.As()` and `IQuantity.ToUnit()` from the quantity interfaces to `QuantityExtensions` #1696
 - Remove obsolete units #1372
     - `CoefficientOfThermalExpansion.InverseKelvin`, `InverseDegreeCelsius`, `InverseDegreeFahrenheit`
     - `HeatTransferCoefficient.BtuPerSquareFootDegreeFahrenheit`
@@ -39,14 +47,77 @@ If there is sufficient demand for supporting any number type like `float`, `deci
     - `FuelEfficiency.KilometersPerLiter`
     - `Speed.MetersPerMinute`
 - Moved 29 operator overloads for multiply or division to another type ([details](https://github.com/angularsen/UnitsNet/pull/1329#discussion_r1451794868)), e.g. `Energy op_Multiply(Duration, Power)` moved from `Power` to `Duration` #1329
+- Rename or remove ambiguous prefixed cubic units #1617, #1645, #1700
+    - `SpecificVolumeUnit.MillicubicMeterPerKilogram` -> `SpecificVolumeUnit.CubicMillimeterPerKilogram`
+    - Remove `VolumeUnit.HectocubicMeter`; use `VolumeUnit.CubicMeter` for 100 m³ values
+    - `VolumeUnit.KilocubicMeter` -> `VolumeUnit.ThousandCubicMeter`
+    - `VolumeUnit.HectocubicFoot` -> `VolumeUnit.HundredCubicFoot`
+    - `VolumeUnit.KilocubicFoot` -> `VolumeUnit.ThousandCubicFoot`
+    - `VolumeUnit.MegacubicFoot` -> `VolumeUnit.MillionCubicFoot`
 
 ### Source incompatible
 
 - `IQuantity.UnitInfo` is now a interface default member on .NET5+, and may compete with any custom property implemented in third party quantities #1649
+- Custom quantity implementations must expose `QuantityValue` from `IQuantity.Value` and accept it in their quantity factories. #1544
+- Expressions inferred with `var`, such as `var value = quantity.Value` or `var value = quantity.As(unit)`, now have type `QuantityValue`. Cast to `double` when a floating-point result is specifically required. #1544
+- Custom quantities that explicitly implement `IQuantity.As()`, `IQuantity.ToUnit()`, `IQuantity<TUnitType>.As()` or `IQuantity<TUnitType>.ToUnit()` must remove those explicit interface implementations. The methods may remain as ordinary members if they are also part of the custom quantity's public API. #1696
 
 ### Behavioral change
 
-None.
+- Complete the removal of proprietary quantity format strings. Quantity formatting now accepts .NET numeric format
+  strings only; see [String formatting](string-formatting.md).
+    - Replace `A`, `A0`, `A1`, ... with a generated `GetAbbreviation()` method or
+      `UnitAbbreviationsCache.GetUnitAbbreviations()`.
+    - Replace `S`, `S2`, ... with an explicit numeric format such as `G3`, `F2`, `N2`, `E2`, or `0.##`.
+    - Replace `U`, `V`, and `Q` with the `Unit` property, the `Value` property, and static quantity metadata such as
+      `Length.Info.Name`, respectively.
+- Exact rational conversions and arithmetic may produce results that differ from the previous `double` implementation in the least significant digits. Precision can be lost when a `QuantityValue` is converted to `double`; perform that conversion only at boundaries where floating-point behavior is required. #1544
+- Calls to `.As()` and `.ToUnit()` through an `IQuantity` or `IQuantity<TUnitType>` reference now use the `QuantityExtensions` methods and `UnitConverter.Default`. They no longer dispatch to type-specific methods defined by a custom quantity. Custom quantities that need these calls to support conversion must register their conversion functions with `UnitConverter.Default`. #1696
+- Calling these extension methods with an incompatible unit type now throws `UnitNotFoundException` instead of `ArgumentException`. Code that catches `ArgumentException` around interface-based conversions may need to be updated. #1696
+- `SpecificVolume` abbreviation `mm³/kg` now parses as true cubic millimeters per kilogram (`1e-9 m³/kg`) instead of millesimal cubic meters per kilogram.
+- `Volume` abbreviations `hm³` and `km³` now parse unambiguously as true cubic hectometers and cubic kilometers.
+- Thousand cubic meters now formats as `10³·m³`, with `kcm` and `Kcm` as parsing aliases.
+- Count-style cubic-foot volume units now format as `Ccf`, `Mcf`, and `MMcf`.
+
+### Serialization
+
+The serialized form of a quantity can change because its `Value` is now a `QuantityValue`. Review persisted payloads and
+choose an explicit value format when compatibility matters:
+
+- `UnitsNet.Serialization.JsonNet` uses `DecimalPrecision` when writing and `ExactNumber` when reading by default. It also
+  supports double precision, exact round-tripping and custom value converters through `QuantityValueFormatOptions`.
+- The new `UnitsNet.Serialization.SystemTextJson` package provides converters for concrete quantities, `IQuantity`, units
+  and several `QuantityValue` representations.
+- The default `DataContractSerializer` representation exposes the internal `BigInteger` fields of the fraction's
+  numerator and denominator. Use `QuantityValueSurrogateSerializationProvider` for a compact, stable numerator and
+  denominator representation in XML.
+- `DataContractJsonSerializer` cannot apply that surrogate provider to nested `QuantityValue` instances due to
+  [dotnet/runtime#100553](https://github.com/dotnet/runtime/issues/100553). Use the Json.NET or System.Text.Json package
+  instead.
+
+See [Serialization](serialization.md) for examples.
+
+### Ambiguous prefixed cubic units
+
+Previous versions generated some cubic units from metric prefixes where the prefix applied to the generated unit name,
+but users would reasonably read the abbreviation as applying before cubing the length unit. For example, `km³` should
+mean `(1000 m)³`, not `1000 m³`.
+
+In v6, `hm³` and `km³` are reserved for the existing `CubicHectometer` and `CubicKilometer` units. The old
+`HectocubicMeter` API was removed. For 100 cubic meters, use `Volume.FromCubicMeters(100)` or
+`volume.As(VolumeUnit.CubicMeter)` instead.
+
+The old `KilocubicMeter` API represented 1000 cubic meters, which is a real count-style unit in some domains. It was
+renamed to `ThousandCubicMeter` and formats as `10³·m³`. It also accepts `kcm` and `Kcm` as aliases.
+
+For cubic feet, the generated prefix names were renamed to count-style names:
+
+- `HectocubicFoot` -> `HundredCubicFoot`, default abbreviation `Ccf`
+- `KilocubicFoot` -> `ThousandCubicFoot`, default abbreviation `Mcf`
+- `MegacubicFoot` -> `MillionCubicFoot`, default abbreviation `MMcf`
+
+The old generated cubic-foot abbreviations such as `hft³`, `kft³`, and `Mft³` are still accepted as aliases where they
+do not conflict with another unit.
 
 ### Description of different kinds of incompatible changes
 
diff --git a/GITHUB_ACTIONS_MIGRATION_README.md b/GITHUB_ACTIONS_MIGRATION_README.md
deleted file mode 100644
index 9d19216a7a..0000000000
--- a/GITHUB_ACTIONS_MIGRATION_README.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# GitHub Actions Migration
-
-This PR adds GitHub Actions workflows to run alongside the existing Azure Pipelines configuration.
-
-## Files to Move
-
-Due to GitHub App permission restrictions, the workflow files are created in the root directory. Please move these files to `.github/workflows/` after merging:
-
-1. `github-actions-ci.yml` → `.github/workflows/ci.yml`
-2. `github-actions-pr.yml` → `.github/workflows/pr.yml`
-
-## Key Features
-
-### CI Workflow (ci.yml)
-- Triggers on pushes to master, release/*, and maintenance/* branches
-- Builds with .NET nanoFramework support using `nanoframework/nanobuild@v1` action
-- Runs tests and uploads coverage to codecov.io
-- Publishes NuGet packages to nuget.org (only on master branch)
-- Uses Windows runner to match Azure Pipelines configuration
-
-### PR Workflow (pr.yml)
-- Triggers on pull requests to master, release/*, and maintenance/* branches
-- Same build and test process as CI workflow
-- Publishes test results as PR checks
-- Uploads test coverage to codecov.io
-- No NuGet publishing for PRs
-
-## .NET nanoFramework Support
-
-The key challenge mentioned in the issue was .NET nanoFramework support. This is handled using the `nanoframework/nanobuild@v1` GitHub Action, which is the official GitHub Actions equivalent of the Azure Pipelines `InstallNanoMSBuildComponents@1` task.
-
-## Migration Notes
-
-- Both workflows use the existing PowerShell build script (`Build/build.ps1`) with the `-IncludeNanoFramework` flag
-- Secrets needed: `CODECOV_TOKEN` and `NUGET_ORG_APIKEY` (should already be configured)
-- The workflows are designed to run alongside Azure Pipelines for comparison
-- Azure Pipelines configuration files remain unchanged as requested
-
-## Next Steps
-
-1. Move the workflow files to `.github/workflows/`
-2. Test both workflows to ensure they work correctly
-3. Compare results with Azure Pipelines
-4. Make any necessary adjustments based on testing
\ No newline at end of file
diff --git a/NullableAttributes.cs b/NullableAttributes.cs
index 78402f17d0..c1b5542a5f 100644
--- a/NullableAttributes.cs
+++ b/NullableAttributes.cs
@@ -1,4 +1,4 @@
-// Workaround for nullable annotations when multitargeting against netstandard2.0 or .NET versions lower than .NET Core 3.0, which do not support it out of the box.
+// Workaround for nullable annotations when multitargeting against netstandard2.0 or .NET versions lower than .NET Core 3.0, which do not support it out of the box.
 // https://www.meziantou.net/how-to-use-nullable-reference-types-in-dotnet-standard-2-0-and-dotnet-.htm
 
 // https://github.com/dotnet/runtime/blob/527f9ae88a0ee216b44d556f9bdc84037fe0ebda/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/NullableAttributes.cs
diff --git a/PerfTests/PerfTest_Startup/Program.cs b/PerfTests/PerfTest_Startup/Program.cs
index b54c226ab3..3a1c988469 100644
--- a/PerfTests/PerfTest_Startup/Program.cs
+++ b/PerfTests/PerfTest_Startup/Program.cs
@@ -1,4 +1,4 @@
-using UnitsNet;
+using UnitsNet;
 using UnitsNet.Units;
 
 Console.WriteLine(Power.From(5, PowerUnit.Watt));
diff --git a/PerfTests/PerfTest_Startup_Aot/Program.cs b/PerfTests/PerfTest_Startup_Aot/Program.cs
index b54c226ab3..3a1c988469 100644
--- a/PerfTests/PerfTest_Startup_Aot/Program.cs
+++ b/PerfTests/PerfTest_Startup_Aot/Program.cs
@@ -1,4 +1,4 @@
-using UnitsNet;
+using UnitsNet;
 using UnitsNet.Units;
 
 Console.WriteLine(Power.From(5, PowerUnit.Watt));
diff --git a/PerfTests/PerfTest_Startup_v4_144_0/Program.cs b/PerfTests/PerfTest_Startup_v4_144_0/Program.cs
index 8bbbc94c42..7a51a29550 100644
--- a/PerfTests/PerfTest_Startup_v4_144_0/Program.cs
+++ b/PerfTests/PerfTest_Startup_v4_144_0/Program.cs
@@ -1,4 +1,4 @@
-// See https://aka.ms/new-console-template for more information
+// See https://aka.ms/new-console-template for more information
 
 using UnitsNet;
 using UnitsNet.Units;
diff --git a/PerfTests/PerfTest_Startup_v4_72_0/Program.cs b/PerfTests/PerfTest_Startup_v4_72_0/Program.cs
index 8bbbc94c42..7a51a29550 100644
--- a/PerfTests/PerfTest_Startup_v4_72_0/Program.cs
+++ b/PerfTests/PerfTest_Startup_v4_72_0/Program.cs
@@ -1,4 +1,4 @@
-// See https://aka.ms/new-console-template for more information
+// See https://aka.ms/new-console-template for more information
 
 using UnitsNet;
 using UnitsNet.Units;
diff --git a/README.md b/README.md
index ba3deae87d..a3d6689f2c 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,14 @@
-[![Build Status](https://dev.azure.com/unitsnet/Units.NET/_apis/build/status/UnitsNet?branchName=master)](https://dev.azure.com/unitsnet/Units.NET/_build/latest?definitionId=1&branchName=master)
+[![CI Build](https://github.com/angularsen/UnitsNet/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/angularsen/UnitsNet/actions/workflows/ci.yml)
+[![Pull Requests](https://github.com/angularsen/UnitsNet/actions/workflows/pr.yml/badge.svg)](https://github.com/angularsen/UnitsNet/actions/workflows/pr.yml)
+[![.NET Framework 4.8](https://github.com/angularsen/UnitsNet/actions/workflows/net48-compatibility.yml/badge.svg)](https://github.com/angularsen/UnitsNet/actions/workflows/net48-compatibility.yml)
 [![codecov](https://codecov.io/gh/angularsen/UnitsNet/branch/master/graph/badge.svg)](https://codecov.io/gh/angularsen/UnitsNet)
 [![StandWithUkraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/badges/StandWithUkraine.svg)](https://github.com/vshymanskyy/StandWithUkraine/blob/main/docs/README.md)
 
 ## Units.NET
 
-Add strongly typed quantities to your code and get merrily on with your life.
+Add strongly typed quantities and units to your code and get merrily on with your life.
 
-No more magic constants found on Stack Overflow, no more second-guessing the unit of parameters and variables.
+No more magic constants found online or guessing the unit of variables.
 
 ### Changes
 
@@ -16,6 +18,8 @@ New units will be backported to  `maintenance/v5` until v6 becomes stable.
 [Upgrading from 5.x to 6.x](https://github.com/angularsen/UnitsNet/wiki/Upgrading-from-5.x-to-6.x)<br>
 [Upgrading from 4.x to 5.x](https://github.com/angularsen/UnitsNet/wiki/Upgrading-from-4.x-to-5.x)<br>
 
+🧪 **Experimental:** Check out [UnitsNet.Modular](UnitsNet.Modular/README.md), which generates only the quantities and units your application needs.
+
 ### Overview
 
 * [Overview](#overview)
@@ -51,7 +55,6 @@ or go to [NuGet Gallery | UnitsNet](https://www.nuget.org/packages/UnitsNet) for
 * .NET 8.0 (LTS)
 * .NET 9.0 (latest stable)
 * .NET 10.0 (preview)
-* [.NET nanoFramework](https://www.nanoframework.net/)
 
 
 ### Extension Packages
@@ -460,6 +463,7 @@ Read the wiki on [Serializing to JSON, XML and more](https://github.com/angulars
 ### Want To Contribute?
 
 * [Adding a New Unit](https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit) is fairly easy to do and we are happy to help.
+* See the [Quantity and Unit Definition Schema](Docs/quantity-and-unit-definition-schema.md) for a reference to the JSON definition format.
 * Want a new feature or to report a bug? [Create an issue](https://github.com/angularsen/UnitsNet/issues/new/choose) or start a [discussion](https://github.com/angularsen/UnitsNet/discussions).
 
 
@@ -472,16 +476,20 @@ Get the same strongly typed units on other platforms, based on the same [unit de
 | JavaScript /<br>TypeScript | unitsnet-js            | [npm](https://www.npmjs.com/package/unitsnet-js)                             | [github](https://github.com/haimkastner/unitsnet-js)              | @haimkastner |
 | Python                     | unitsnet-py            | [pypi](https://pypi.org/project/unitsnet-py)                                 | [github](https://github.com/haimkastner/unitsnet-py)              | @haimkastner |
 | Golang                     | unitsnet-go            | [pkg.go.dev](https://pkg.go.dev/github.com/haimkastner/unitsnet-go)          | [github](https://github.com/haimkastner/unitsnet-go)              | @haimkastner |
+| C++                        | unitsnet-cpp           | [CPM.cmake](https://github.com/JeroenVandezande/unitsnet-cpp#add-with-cpmcmake) | [github](https://github.com/JeroenVandezande/unitsnet-cpp)      | @JeroenVandezande |
 | .NET nanoFramework         | nanoFramework.UnitsNet | [nuget](https://www.nuget.org/packages/nanoFramework.UnitsNet.Acceleration/) | [github](https://github.com/nanoframework/nanoFramework.UnitsNet) | @josesimoes  |
 
 
 ### Continuous Integration
 
-[Azure DevOps](https://dev.azure.com/unitsnet/Units.NET/) performs the following:
+[GitHub Actions](https://github.com/angularsen/UnitsNet/actions) performs the following for v6 on `master`:
+
+* The [CI workflow](https://github.com/angularsen/UnitsNet/actions/workflows/ci.yml) builds and tests pushes to `master` and publishes packages to [NuGet.org](https://www.nuget.org/packages/UnitsNet)
+* The [pull-request workflow](https://github.com/angularsen/UnitsNet/actions/workflows/pr.yml) builds and tests pull requests, with test results and code coverage
+* Linux CI builds every shipped target and runs the full test suite with coverage on .NET 10
+* The [.NET Framework 4.8 compatibility workflow](https://github.com/angularsen/UnitsNet/actions/workflows/net48-compatibility.yml) runs the complete test suite against the `netstandard2.0` assemblies on CLR4 for pull requests and pushes to `master`
 
-* Build and test all branches
-* Build and test pull requests, notifies on success or error
-* Deploy NuGets on master branch, if nuspec versions changed
+The [`maintenance/v5`](https://github.com/angularsen/UnitsNet/tree/maintenance/v5) branch remains on Azure DevOps because its nanoFramework build requires Visual Studio MSBuild and the nanoFramework MSBuild components.
 
 ### Who are Using UnitsNet?
 
diff --git a/Samples/Directory.Packages.props b/Samples/Directory.Packages.props
index cb16f092ef..7f15b25a21 100644
--- a/Samples/Directory.Packages.props
+++ b/Samples/Directory.Packages.props
@@ -3,11 +3,12 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
   <ItemGroup>
-    <PackageVersion Include="UnitsNet" Version="5.75.0" />
+    <PackageVersion Include="UnitsNet" Version="6.0.0-pre021" />
     <PackageVersion Include="MahApps.Metro" Version="2.4.11" />
-    <PackageVersion Include="Prism.Container.Abstractions" Version="9.0.106" />
     <PackageVersion Include="Prism.Unity" Version="9.0.537" />
     <PackageVersion Include="Prism.Wpf" Version="9.0.537" />
     <PackageVersion Include="Unity.Abstractions" Version="5.11.7" />
+    <PackageVersion Include="System.Collections.Immutable" Version="9.0.0" />
+    <PackageVersion Include="System.Reflection.Metadata" Version="9.0.0" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/App.xaml b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/App.xaml
index db543e2d84..3d95351129 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/App.xaml
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/App.xaml
@@ -1,4 +1,4 @@
-<unity:PrismApplication x:Class="WpfMVVMSample.App"
+<unity:PrismApplication x:Class="WpfMVVMSample.App"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:unity="http://prismlibrary.com/">
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/App.xaml.cs b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/App.xaml.cs
index 9b9bf71e09..5202334f4b 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/App.xaml.cs
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/App.xaml.cs
@@ -1,4 +1,4 @@
-using System.Windows;
+using System.Windows;
 using Prism.Ioc;
 using WpfMVVMSample.Settings;
 
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Converters/EnumBindingSource.cs b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Converters/EnumBindingSource.cs
index db5b223288..0d4a0e5332 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Converters/EnumBindingSource.cs
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Converters/EnumBindingSource.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Windows.Markup;
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Converters/UnitToStringConverter.cs b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Converters/UnitToStringConverter.cs
index f7f2806f73..1b98dadf6e 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Converters/UnitToStringConverter.cs
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Converters/UnitToStringConverter.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.ComponentModel;
 using System.Globalization;
 using System.Linq;
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindow.xaml b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindow.xaml
index ce9546ce7e..a2102779a6 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindow.xaml
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindow.xaml
@@ -1,4 +1,4 @@
-<Window x:Class="WpfMVVMSample.MainWindow"
+<Window x:Class="WpfMVVMSample.MainWindow"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindow.xaml.cs b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindow.xaml.cs
index 2245d7f9cf..32594ae6c4 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindow.xaml.cs
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindow.xaml.cs
@@ -1,4 +1,4 @@
-using System.Windows;
+using System.Windows;
 
 namespace WpfMVVMSample
 {
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindowViewModel.cs b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindowViewModel.cs
index 0019962e88..d14f602857 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindowViewModel.cs
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MainWindowViewModel.cs
@@ -1,4 +1,4 @@
-using Prism.Mvvm;
+using Prism.Mvvm;
 using UnitsNet;
 using WpfMVVMSample.Settings;
 
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MvvmSample.Wpf.csproj b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MvvmSample.Wpf.csproj
index cb757e1ceb..96a245e8ff 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MvvmSample.Wpf.csproj
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/MvvmSample.Wpf.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net48</TargetFramework>
     <OutputType>WinExe</OutputType>
@@ -6,6 +6,8 @@
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <UseWPF>true</UseWPF>
     <ImportWindowsDesktopTargets>true</ImportWindowsDesktopTargets>
+    <Configurations>Debug;Release;Official</Configurations>
+    <Platforms>AnyCPU</Platforms>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Prism.Unity" />
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/AssemblyInfo.cs b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/AssemblyInfo.cs
index 61146f9a9c..9904141bc5 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/AssemblyInfo.cs
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/AssemblyInfo.cs
@@ -1,4 +1,4 @@
-using System.Reflection;
+using System.Reflection;
 using System.Resources;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Resources.Designer.cs b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Resources.Designer.cs
index b95ae2d722..372d50bc6b 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Resources.Designer.cs
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Resources.Designer.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
 //     Runtime Version:4.0.30319.42000
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Resources.resx b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Resources.resx
index af7dbebbac..13b775f1d9 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Resources.resx
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Resources.resx
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!-- 
     Microsoft ResX Schema 
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Settings.Designer.cs b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Settings.Designer.cs
index d51cd3818b..b19a46a2b8 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Settings.Designer.cs
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Settings.Designer.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
 //     Runtime Version:4.0.30319.42000
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Settings.settings b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Settings.settings
index 033d7a5e9e..9010101f83 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Settings.settings
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Properties/Settings.settings
@@ -1,4 +1,4 @@
-<?xml version='1.0' encoding='utf-8'?>
+<?xml version='1.0' encoding='utf-8'?>
 <SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
   <Profiles>
     <Profile Name="(Default)" />
diff --git a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Settings/SettingsManager.cs b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Settings/SettingsManager.cs
index 659865b724..3ad2325ef3 100644
--- a/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Settings/SettingsManager.cs
+++ b/Samples/MvvmSample.Wpf/MvvmSample.Wpf/Settings/SettingsManager.cs
@@ -1,4 +1,4 @@
-using Prism.Mvvm;
+using Prism.Mvvm;
 using System;
 using System.Collections.Generic;
 using UnitsNet.Units;
diff --git a/Samples/MvvmSample.Wpf/Readme.md b/Samples/MvvmSample.Wpf/Readme.md
index ba77dcaffb..cf088dc1fd 100644
--- a/Samples/MvvmSample.Wpf/Readme.md
+++ b/Samples/MvvmSample.Wpf/Readme.md
@@ -1,4 +1,4 @@
-## WPF MVVM Sample
+## WPF MVVM Sample
 
 This is a simple sample showing how UnitsNet can be used to create a WPF MVVM application. I have used this strategy in a few simple engineering apps and thought I would share it as a sample to see if others might offer improvements.
 
diff --git a/Samples/Nuget.config b/Samples/Nuget.config
new file mode 100644
index 0000000000..277a87c2cc
--- /dev/null
+++ b/Samples/Nuget.config
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <config>
+        <add key="globalPackagesFolder" value="packages" />
+    </config>
+    <packageSources>
+        <clear />
+        <add key="NuGet.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+        <add key="LocalBuild" value="../Artifacts" />
+    </packageSources>
+    <packageSourceMapping>
+        <!-- LocalBuild is the preferred source because it has a more specific pattern.
+             NuGet.org is a fallback for other packages such as NUnit. -->
+        <packageSource key="LocalBuild">
+            <package pattern="*" />
+        </packageSource>
+        <packageSource key="NuGet.org">
+            <package pattern="*" />
+        </packageSource>
+    </packageSourceMapping>
+</configuration>
\ No newline at end of file
diff --git a/Samples/Samples.slnx b/Samples/Samples.slnx
index 1fc01829b9..7e83cc458d 100644
--- a/Samples/Samples.slnx
+++ b/Samples/Samples.slnx
@@ -1,20 +1,18 @@
 <Solution>
   <Configurations>
-    <Platform Name="Any CPU" />
-    <Platform Name="ARM" />
-    <Platform Name="x64" />
-    <Platform Name="x86" />
+    <BuildType Name="Debug" />
+    <BuildType Name="Official" />
+    <BuildType Name="Release" />
   </Configurations>
   <Folder Name="/_Files/">
     <File Path="build.bat" />
     <File Path="Directory.Packages.props" />
     <File Path="msbuild.cmd" />
   </Folder>
-  <Project Path="MvvmSample.Wpf/MvvmSample.Wpf/MvvmSample.Wpf.csproj">
-    <Build Solution="*|ARM" Project="false" />
-  </Project>
+  <Project Path="MvvmSample.Wpf/MvvmSample.Wpf/MvvmSample.Wpf.csproj" />
   <Project Path="UnitConverter.Console/UnitConverter.Console.csproj" />
-  <Project Path="UnitConverter.Wpf/UnitConverter.Wpf/UnitConverter.Wpf.csproj">
-    <Build Solution="*|ARM" Project="false" />
+  <Project Path="UnitConverter.Wpf/UnitConverter.Wpf/UnitConverter.Wpf.csproj" />
+  <Project Path="UnitsNetSetup.Configuration/UnitsNetSetup.Configuration.csproj">
+    <Configuration Solution="Official|Any CPU" Project="Official|Any CPU|NoBuild" />
   </Project>
-</Solution>
+</Solution>
\ No newline at end of file
diff --git a/Samples/UnitConverter.Console/Program.cs b/Samples/UnitConverter.Console/Program.cs
index 7ba55aef09..9adfb8e3fd 100644
--- a/Samples/UnitConverter.Console/Program.cs
+++ b/Samples/UnitConverter.Console/Program.cs
@@ -1,4 +1,5 @@
-using UnitsNet;
+using UnitsNet;
+using UnitsNet.Units;
 using static System.Console;
 using static UnitsNet.Units.LengthUnit;
 
diff --git a/Samples/UnitConverter.Console/UnitConverter.Console.csproj b/Samples/UnitConverter.Console/UnitConverter.Console.csproj
index ae8f5130fb..2f3886131f 100644
--- a/Samples/UnitConverter.Console/UnitConverter.Console.csproj
+++ b/Samples/UnitConverter.Console/UnitConverter.Console.csproj
@@ -5,6 +5,8 @@
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <Configurations>Debug;Release;Official</Configurations>
+    <Platforms>AnyCPU</Platforms>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/Samples/UnitConverter.Wpf/README.md b/Samples/UnitConverter.Wpf/README.md
index 4f8fe8034a..228257158c 100644
--- a/Samples/UnitConverter.Wpf/README.md
+++ b/Samples/UnitConverter.Wpf/README.md
@@ -1,4 +1,4 @@
-## Unit Converter WPF Sample App
+## Unit Converter WPF Sample App
 
 This is a simple sample showing how UnitsNet can be used to create a generic unit converter, using all the quantities and units available in the UnitsNet library.
 
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf.sln.DotSettings b/Samples/UnitConverter.Wpf/UnitConverter.Wpf.sln.DotSettings
index 8939b3c194..077a26e618 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf.sln.DotSettings
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf.sln.DotSettings
@@ -1,2 +1,2 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeInspection/CodeAnnotations/NamespacesWithAnnotations/=Wpf_005FGenericUnitConverter_002EAnnotations/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/App.xaml b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/App.xaml
index 86dd63140b..b277545a44 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/App.xaml
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/App.xaml
@@ -1,4 +1,4 @@
-<Application x:Class="UnitsNet.Samples.UnitConverter.Wpf.App"
+<Application x:Class="UnitsNet.Samples.UnitConverter.Wpf.App"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              StartupUri="MainWindow.xaml">
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/App.xaml.cs b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/App.xaml.cs
index 7244904df2..125b5d7779 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/App.xaml.cs
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/App.xaml.cs
@@ -1,4 +1,4 @@
-using System.Windows;
+using System.Windows;
 
 namespace UnitsNet.Samples.UnitConverter.Wpf
 {
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/IMainWindowVm.cs b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/IMainWindowVm.cs
index c2ed86fb67..81817ad7ac 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/IMainWindowVm.cs
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/IMainWindowVm.cs
@@ -1,4 +1,4 @@
-using System.Collections.ObjectModel;
+using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Windows.Input;
 using UnitsNet.Samples.UnitConverter.Wpf.Properties;
@@ -23,8 +23,8 @@ public interface IMainWindowVm : INotifyPropertyChanged
 
         string FromHeader { get; }
         string ToHeader { get; }
-        double FromValue { get; set; }
-        double ToValue { get; }
+        QuantityValue FromValue { get; set; }
+        QuantityValue ToValue { get; }
         ICommand SwapCommand { get; }
     }
 }
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindow.xaml b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindow.xaml
index 81d8491452..fa493adecf 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindow.xaml
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindow.xaml
@@ -1,4 +1,4 @@
-<controls:MetroWindow
+<controls:MetroWindow
     xmlns:controls="http://metro.mahapps.com/winfx/xaml/controls"
     x:Class="UnitsNet.Samples.UnitConverter.Wpf.MainWindow"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
@@ -7,15 +7,12 @@
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
     xmlns:wpf="clr-namespace:UnitsNet.Samples.UnitConverter.Wpf"
     mc:Ignorable="d"
-    WindowStartupLocation="CenterScreen"
-    Title="UnitsNet - WPF unit converter sample app" Height="800" Width="800"
-    d:DesignHeight="600" d:DesignWidth="600"
+    Title="UnitsNet - WPF unit converter sample app" Height="600" Width="800"
     d:DataContext="{d:DesignInstance wpf:MainWindowDesignVm, IsDesignTimeCreatable=True}">
 
     <Grid Margin="10">
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="1*" />
-            <ColumnDefinition Width="10" />
             <ColumnDefinition Width="1*" />
             <ColumnDefinition Width="50" />
             <ColumnDefinition Width="1*" />
@@ -32,7 +29,7 @@
                  SelectionChanged="Selector_OnSelectionChanged" />
         </GroupBox>
 
-        <GroupBox Header="From" Grid.Row="0" Grid.Column="2">
+        <GroupBox Header="From" Grid.Row="0" Grid.Column="1">
             <Grid>
                 <ListBox
                  ItemsSource="{Binding Path=Units}"
@@ -41,7 +38,7 @@
             </Grid>
         </GroupBox>
 
-        <GroupBox Header="To" Grid.Row="0" Grid.Column="4">
+        <GroupBox Header="To" Grid.Row="0" Grid.Column="3">
             <Grid>
                 <ListBox
                  ItemsSource="{Binding Path=Units}"
@@ -50,21 +47,26 @@
             </Grid>
         </GroupBox>
 
-        <GroupBox Header="{Binding FromHeader}" Grid.Row="1" Grid.Column="2">
+
+        <WrapPanel Grid.Row="1" Grid.Column="0" Margin="10">
+            <!--Placeholder-->
+        </WrapPanel>
+
+        <GroupBox Header="{Binding FromHeader}" Grid.Row="1" Grid.Column="1">
             <TextBox FontSize="16" FontWeight="DemiBold" HorizontalContentAlignment="Center" VerticalContentAlignment="Center"
-                     Text="{Binding FromValue, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
+                     Text="{Binding FromValue, StringFormat=G35, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
         </GroupBox>
 
-        <Grid Grid.Row="1" Grid.Column="3">
+        <Grid Grid.Row="1" Grid.Column="2">
             <Button Content="⇄" Style="{StaticResource MahApps.Styles.Button.Circle}"
                     Width="40" Height="40"
-                    FontSize="20" HorizontalAlignment="Center" VerticalAlignment="Center" Padding="0, 0, 0, 4"
+                    FontSize="20" HorizontalAlignment="Center" VerticalAlignment="Center" Padding="0, 0, 0,4"
                     Command="{Binding SwapCommand}"/>
         </Grid>
 
-        <GroupBox Header="{Binding ToHeader}" Grid.Row="1" Grid.Column="4">
+        <GroupBox Header="{Binding ToHeader}" Grid.Row="1" Grid.Column="3">
             <TextBox FontSize="16" FontWeight="DemiBold" HorizontalContentAlignment="Center" VerticalContentAlignment="Center"
-                     Text="{Binding ToValue, Mode=OneWay}" IsReadOnly="true" />
+                     Text="{Binding ToValue, Mode=OneWay, StringFormat=G35}" IsReadOnly="true" />
         </GroupBox>
 
     </Grid>
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindow.xaml.cs b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindow.xaml.cs
index 3ab17bf8be..a795950d97 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindow.xaml.cs
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindow.xaml.cs
@@ -1,4 +1,4 @@
-using System.ComponentModel;
+using System.ComponentModel;
 using System.Linq;
 using System.Windows.Controls;
 
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindowDesignVM.cs b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindowDesignVM.cs
index 89f47de952..2a769e6c28 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindowDesignVM.cs
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindowDesignVM.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Linq;
@@ -30,8 +30,8 @@ public MainWindowDesignVm()
 
         public string FromHeader { get; } = "Value [cm]";
         public string ToHeader { get; } = "Result [dm]";
-        public double FromValue { get; set; } = 14.5;
-        public double ToValue { get; } = 1.45;
+        public QuantityValue FromValue { get; set; } = 14.5m;
+        public QuantityValue ToValue { get; } = 1.45m;
 
         public ICommand SwapCommand { get; } = new RoutedCommand();
 
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindowVM.cs b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindowVM.cs
index a959ab87aa..1518e822a9 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindowVM.cs
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/MainWindowVM.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
@@ -17,7 +17,7 @@ namespace UnitsNet.Samples.UnitConverter.Wpf
     public sealed class MainWindowVm : IMainWindowVm
     {
         private readonly ObservableCollection<UnitListItem> _units;
-        private double _fromValue;
+        private QuantityValue _fromValue;
 
         [CanBeNull] private UnitListItem _selectedFromUnit;
 
@@ -25,7 +25,7 @@ public sealed class MainWindowVm : IMainWindowVm
 
         [CanBeNull] private UnitListItem _selectedToUnit;
 
-        private double _toValue;
+        private QuantityValue _toValue;
 
         public MainWindowVm()
         {
@@ -90,22 +90,24 @@ public UnitListItem SelectedToUnit
 
         public string ToHeader => $"Result [{SelectedToUnit?.Abbreviation}]";
 
-        public double FromValue
+        public QuantityValue FromValue
         {
             get => _fromValue;
             set
             {
+                if (value == _fromValue) return;
                 _fromValue = value;
                 OnPropertyChanged();
                 UpdateResult();
             }
         }
 
-        public double ToValue
+        public QuantityValue ToValue
         {
             get => _toValue;
             private set
             {
+                if (value == _toValue) return;
                 _toValue = value;
                 OnPropertyChanged();
             }
@@ -116,7 +118,7 @@ private set
         private void Swap()
         {
             UnitListItem oldToUnit = SelectedToUnit;
-            var oldToValue = ToValue;
+            QuantityValue oldToValue = ToValue;
 
             // Setting these will change ToValue
             SelectedToUnit = SelectedFromUnit;
@@ -129,6 +131,11 @@ private void UpdateResult()
         {
             if (SelectedFromUnit == null || SelectedToUnit == null) return;
 
+            // note: starting from v6 it is possible to store (and invoke here) a conversion expression
+            // ConvertValueDelegate _convertValueToUnit = UnitsNet.UnitConverter.Default.GetConversionFunction(SelectedFromUnit.UnitEnumValue, SelectedToUnit.UnitEnumValue);
+            // ToValue = _convertValueToUnit(FromValue);
+
+            // note: as of v6 this can be optimized by working directly with the IUntInfo (or it's UnitKey).
             ToValue = UnitsNet.UnitConverter.Convert(FromValue,
                 SelectedFromUnit.UnitEnumValue,
                 SelectedToUnit.UnitEnumValue);
@@ -139,11 +146,12 @@ private void OnSelectedQuantity(string quantityName)
             QuantityInfo quantityInfo = Quantity.ByName[quantityName];
 
             _units.Clear();
+            // note: as of v6 approach this approach is not recommended as the unit info no longer stores the boxed version of the unit (as untyped Enum)
             foreach (Enum unitValue in quantityInfo.UnitInfos.Select(ui => ui.Value))
             {
-                _units.Add(new UnitListItem(unitValue));
+                _units.Add(new UnitListItem(unitValue)); // TODO see about simply passing the UnitInfo (or the UnitKey)
             }
-
+            
             SelectedFromUnit = _units.FirstOrDefault();
             SelectedToUnit = _units.Skip(1).FirstOrDefault() ?? SelectedFromUnit; // Try to pick a different to-unit
         }
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Annotations.cs b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Annotations.cs
index ef3012ef6a..091fdb1968 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Annotations.cs
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Annotations.cs
@@ -1,4 +1,4 @@
-/* MIT License
+/* MIT License
 
 Copyright (c) 2016 JetBrains http://www.jetbrains.com
 
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/AssemblyInfo.cs b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/AssemblyInfo.cs
index 72df2a3a9d..6318c8433f 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/AssemblyInfo.cs
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/AssemblyInfo.cs
@@ -1,4 +1,4 @@
-using System.Reflection;
+using System.Reflection;
 using System.Resources;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Resources.Designer.cs b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Resources.Designer.cs
index 892b08329f..01b53f6c5d 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Resources.Designer.cs
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Resources.Designer.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
 //     Runtime Version:4.0.30319.42000
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Resources.resx b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Resources.resx
index af7dbebbac..13b775f1d9 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Resources.resx
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Resources.resx
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!-- 
     Microsoft ResX Schema 
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Settings.Designer.cs b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Settings.Designer.cs
index 2c2479294a..b8eb20d4da 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Settings.Designer.cs
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Settings.Designer.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
 //     Runtime Version:4.0.30319.42000
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Settings.settings b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Settings.settings
index 033d7a5e9e..9010101f83 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Settings.settings
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/Properties/Settings.settings
@@ -1,4 +1,4 @@
-<?xml version='1.0' encoding='utf-8'?>
+<?xml version='1.0' encoding='utf-8'?>
 <SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
   <Profiles>
     <Profile Name="(Default)" />
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/UnitConverter.Wpf.csproj b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/UnitConverter.Wpf.csproj
index 29bc3a93e2..86ebccfc46 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/UnitConverter.Wpf.csproj
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/UnitConverter.Wpf.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net48</TargetFramework>
     <OutputType>WinExe</OutputType>
@@ -6,6 +6,8 @@
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <UseWPF>true</UseWPF>
     <ImportWindowsDesktopTargets>true</ImportWindowsDesktopTargets>
+    <Configurations>Debug;Release;Official</Configurations>
+    <Platforms>AnyCPU</Platforms>
   </PropertyGroup>
   <PropertyGroup>
     <ApplicationIcon>logo-512.ico</ApplicationIcon>
@@ -22,6 +24,7 @@
   <ItemGroup>
     <PackageReference Include="MahApps.Metro" />
   </ItemGroup>
+  
 
   <ItemGroup>
     <PackageReference Include="UnitsNet" />
diff --git a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/UnitListItem.cs b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/UnitListItem.cs
index 3892c639cb..4893d235a8 100644
--- a/Samples/UnitConverter.Wpf/UnitConverter.Wpf/UnitListItem.cs
+++ b/Samples/UnitConverter.Wpf/UnitConverter.Wpf/UnitListItem.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace UnitsNet.Samples.UnitConverter.Wpf
 {
diff --git a/Samples/UnitsNetSetup.Configuration/ConfigureWithConverterCachingOptions.cs b/Samples/UnitsNetSetup.Configuration/ConfigureWithConverterCachingOptions.cs
new file mode 100644
index 0000000000..b70488a751
--- /dev/null
+++ b/Samples/UnitsNetSetup.Configuration/ConfigureWithConverterCachingOptions.cs
@@ -0,0 +1,135 @@
+using UnitsNet;
+using UnitsNet.Units;
+
+namespace UnitsNetSetup.Configuration;
+
+internal static class ConfigureWithConverterCachingOptions
+{
+    /// <summary>
+    ///     Demonstrates the default caching options for the UnitsNet configuration.
+    /// </summary>
+    /// <remarks>
+    ///     This method sets up the configuration using the same caching options as the ones which are used by default:
+    ///     The configuration uses an empty dynamic cache (backed by a ConcurrentDictionary), with the option to reduce any conversion expression prior to
+    ///     caching.
+    ///     <para>
+    ///         This configuration has a small overhead when it first encounters a particular combination of units, as well
+    ///         as some overhead due to locking.
+    ///     </para>
+    /// </remarks>
+    public static void ConfigureDefault()
+    {
+        UnitsNet.UnitsNetSetup.ConfigureDefaults(builder => builder
+            .WithConverterOptions(new QuantityConverterBuildOptions(freeze: false, defaultCachingMode: ConversionCachingMode.None, reduceConstants: true)));
+    }
+
+    /// <summary>
+    ///     Demonstrates the use of a fully-cached immutable (a.k.a. "frozen") caching configuration.
+    /// </summary>
+    /// <remarks>
+    ///     This method sets up the configuration using an immutable cache (backed by a FrozenDictionary) and loads up the unit
+    ///     conversions for all quantities (~40K).
+    ///     <para>
+    ///         While offering the best performance for all subsequent operations, this configuration comes with increase
+    ///         startup time and memory footprint:
+    ///     </para>
+    ///     <para>On a modern machine this takes up around ~30 ms, and uses ~12 MB of RAM.</para>
+    /// </remarks>
+    public static void ConfigureAsFrozen()
+    {
+        UnitsNet.UnitsNetSetup.ConfigureDefaults(builder => builder
+            .WithConverterOptions(new QuantityConverterBuildOptions(freeze: true, defaultCachingMode: ConversionCachingMode.All, reduceConstants: true)));
+    }
+
+    /// <summary>
+    ///     Demonstrates the use of a no-caching configuration.
+    /// </summary>
+    /// <remarks>
+    ///     This method sets up a configuration which doesn't support caching.
+    ///     <para>While having the smallest memory footprint, this configuration is about 2x slower than the alternatives.</para>
+    /// </remarks>
+    public static void ConfigureWithoutCaching()
+    {
+        UnitsNet.UnitsNetSetup.ConfigureDefaults(builder => builder
+            .WithConverterOptions(new QuantityConverterBuildOptions(freeze: true, defaultCachingMode: ConversionCachingMode.None)));
+    }
+
+    /// <summary>
+    ///     Demonstrates the use of an immutable (a.k.a. "frozen") caching configuration which caches only a specific selection of quantities.
+    /// </summary>
+    /// <remarks>
+    ///     This method sets up the configuration using an immutable cache (backed by a FrozenDictionary) and loads up the unit
+    ///     conversions for the Mass, Volume and Density.
+    ///     <para>
+    ///         The startup time and memory footprint for such a configuration should be fairly very small, while offering the best performance for the selected quantities,
+    ///         while still being able to use the remaining quantities, without caching any of their conversions.
+    ///     </para>
+    /// </remarks>
+    public static void ConfigureAsFrozenWithCustomCachingOptions()
+    {
+        UnitsNet.UnitsNetSetup.ConfigureDefaults(builder => builder
+            .WithConverterOptions(new QuantityConverterBuildOptions(freeze: true, defaultCachingMode: ConversionCachingMode.None)
+                .WithCustomCachingOptions<Mass>(new ConversionCacheOptions(cachingMode: ConversionCachingMode.All, reduceConstants: true))
+                .WithCustomCachingOptions<Volume>(new ConversionCacheOptions(cachingMode: ConversionCachingMode.All, reduceConstants: true))
+                .WithCustomCachingOptions<Density>(new ConversionCacheOptions(cachingMode: ConversionCachingMode.All, reduceConstants: true))));
+    }
+
+    /// <summary>
+    ///     Demonstrates the use of a fully-cached immutable (a.k.a. "frozen") caching configuration with a specific set of
+    ///     quantities.
+    /// </summary>
+    /// <remarks>
+    ///     This method sets up a configuration containing only "Mass", "Volume" and "Density" and loads up all their unit
+    ///     conversions into an immutable cache.
+    ///     <para>
+    ///         This configuration offers the best performance, by skipping the loading of all but the specified quantities,
+    ///         however attempting to use any other quantity is going to result in a <see cref="QuantityNotFoundException" />.
+    ///     </para>
+    /// </remarks>
+    public static void ConfigureWithSpecificQuantitiesAsFrozen()
+    {
+        UnitsNet.UnitsNetSetup.ConfigureDefaults(builder => builder
+            .WithQuantities([Mass.Info, Volume.Info, Density.Info])
+            .WithConverterOptions(new QuantityConverterBuildOptions(freeze: true, defaultCachingMode: ConversionCachingMode.All, reduceConstants: true)));
+    }
+
+    /// <summary>
+    ///     Demonstrates the use of a fully-cached immutable (a.k.a. "frozen") caching configuration with a specific set of
+    ///     quantities and a subset of their units.
+    /// </summary>
+    /// <remarks>
+    ///     This method sets up a configuration containing only "Mass", "Volume" and "Density", each configured with a minimum
+    ///     set of units, loaded into an immutable cache.
+    ///     <para>
+    ///         This configuration offers the absolute best performance (startup, operations and memory), by skipping the
+    ///         loading of all but the specified quantities,
+    ///         configured to contain the minimum set of required units, however attempting to use any other unit or quantity
+    ///         is going to result in a <see cref="UnitNotFoundException" /> or <see cref="QuantityNotFoundException" />.
+    ///     </para>
+    ///     <para>
+    ///         Note that instead of selecting a particular set of units, you can use the
+    ///         <see cref="QuantityInfoBuilderExtensions.ExcludeUnits{TUnitDefinition,TUnit}" />
+    ///         to remove units that you know to be inapplicable for the given application (e.g.
+    ///         <see cref="MassUnit.EarthMass" /> and <see cref="MassUnit.SolarMass" />)
+    ///     </para>
+    /// </remarks>
+    public static void ConfigureWithSpecificQuantitiesAndUnitsAsFrozen()
+    {
+        UnitsNet.UnitsNetSetup.ConfigureDefaults(builder => builder
+            .WithQuantities(() => [
+                Mass.MassInfo.CreateDefault(units => units.SelectUnits(MassUnit.Kilogram, MassUnit.Gram)),
+                Volume.VolumeInfo.CreateDefault(units => units.SelectUnits(VolumeUnit.CubicMeter, VolumeUnit.Milliliter)),
+                Density.DensityInfo.CreateDefault(units => units.SelectUnits(DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerMilliliter))
+            ])
+            .WithConverterOptions(new QuantityConverterBuildOptions(freeze: true, defaultCachingMode: ConversionCachingMode.All, reduceConstants: true)));
+    }
+    
+    public static void OutputDensity()
+    {
+        var mass = Mass.FromGrams(5);
+        var volume = Volume.FromMilliliters(2);
+        Density density = mass / volume;
+        Console.WriteLine($"Density: {density}"); // outputs "2500 kg/m3"
+        Console.WriteLine($"Density: {density.ToUnit(DensityUnit.GramPerMilliliter)}");  // outputs "2.5 g/ml"
+    }
+}
diff --git a/Samples/UnitsNetSetup.Configuration/ConfigureWithCustomConversions.cs b/Samples/UnitsNetSetup.Configuration/ConfigureWithCustomConversions.cs
new file mode 100644
index 0000000000..80c3756033
--- /dev/null
+++ b/Samples/UnitsNetSetup.Configuration/ConfigureWithCustomConversions.cs
@@ -0,0 +1,93 @@
+using UnitsNet;
+using UnitsNet.Units;
+
+namespace UnitsNetSetup.Configuration;
+
+internal static class ConfigureWithCustomConversions
+{
+    public static void Configure()
+    {
+        UnitsNet.UnitsNetSetup.ConfigureDefaults(
+            builder => builder
+                // configure custom conversion coefficients while preserving the default QuantityInfo for the Pressure (which has the "Pascal" as the DefaultBaseUnit)
+                .ConfigureQuantity(() => Pressure.PressureInfo.CreateDefault(ConfigureCustomPressureUnitConversions))
+                // configure a "completely new" configuration for the TemperatureDelta
+                .ConfigureQuantity<TemperatureDelta, TemperatureDeltaUnit>(CreateCustomTemperatureConfiguration)
+        );
+    }
+
+    private static IEnumerable<IUnitDefinition<PressureUnit>> ConfigureCustomPressureUnitConversions(IEnumerable<UnitDefinition<PressureUnit>> unitDefinitions)
+    {
+        // we customize a subset of the existing unit definitions (preserving the rest)
+        return unitDefinitions.Select(definition => definition.Value switch
+        {
+            // since these conversions don't involve a constant term we can only specify the conversionFromBase (with the inverse conversion assumed to be the inverse: e.g. 1/999)
+            PressureUnit.InchOfWaterColumn => new UnitDefinition<PressureUnit>(definition.Value, definition.Name, definition.BaseUnits, conversionFromBase: 999),
+            PressureUnit.MeterOfWaterColumn => definition.WithConversionFactorFromBase(1234.5m),
+            PressureUnit.MillimeterOfWaterColumn => definition.WithConversionFactorFromBase(1.2345),
+            PressureUnit.MillimeterOfMercury => new UnitDefinition<PressureUnit>(definition.Value, definition.Name, definition.BaseUnits, QuantityValue.FromTerms(1, 3)),
+            PressureUnit.Decapascal => new UnitDefinition<PressureUnit>(definition.Value, definition.Name, definition.PluralName, definition.BaseUnits,
+                definition.ConversionFromBase.Coefficient * 1.2m,
+                definition.ConversionToBase.Coefficient / 1.2m
+                ),
+            // all preceding conversions result in something of the form:
+            PressureUnit.InchOfMercury => new UnitDefinition<PressureUnit>(PressureUnit.InchOfMercury, definition.Name, definition.PluralName, definition.BaseUnits,
+                // f(x) = 1/3 * x
+                QuantityValue.FromTerms(1, 3),
+                // f(x) = 3 * g(x)^1 + 0  // with g(x) => x in this case
+                new ConversionExpression(
+                    3,
+                    null, // a delegate of the form QuantityValue -> QuantityValue (when null, g(x) = x)
+                    1,
+                    0)),
+            // we keep all other unit conversions as they are
+            _ => definition
+        });
+    }
+
+    private static QuantityInfo<TemperatureDelta, TemperatureDeltaUnit> CreateCustomTemperatureConfiguration()
+    {
+        // the default BaseUnit for the TemperatureDelta is the Kelvin, but for the purposes of this demo, we can change it to DegreeCelsius
+        // note that changing the base unit would normally require us to modify all the conversion coefficients, which isn't a trivial task (a generic extension method could be added in the future) 
+        return new QuantityInfo<TemperatureDelta, TemperatureDeltaUnit>(
+            "MyTemperature",
+            TemperatureDeltaUnit.DegreeCelsius,
+            // since the conversion coefficient for the new base is the same of the last we don't have to modify anything here
+            TemperatureDelta.TemperatureDeltaInfo.GetDefaultMappings(),
+            // these correspond to the SI dimensions for the quantity: no reason to modify them
+            TemperatureDelta.TemperatureDeltaInfo.DefaultBaseDimensions,
+            // we could provide a custom delegate here ((QuantityValue, TemperatureDeltaUnit) => TemperatureDelta), but this is not particularly useful for the default quantities
+            TemperatureDelta.From // while required on netstandard2.0, this parameter is optional in net7+
+        );
+    }
+
+    public static void OutputPressure()
+    {
+        var pressure = Pressure.FromPascals(100);
+        Console.WriteLine(pressure); // outputs: "100 Pa"
+        Console.WriteLine(pressure.As(PressureUnit.Kilopascal)); // outputs: "0.1"
+        Console.WriteLine(pressure.As(PressureUnit.InchOfWaterColumn)); // outputs: "9990"
+        Console.WriteLine(pressure.As(PressureUnit.MeterOfWaterColumn)); // outputs: "123450"
+        Console.WriteLine(pressure.As(PressureUnit.MillimeterOfWaterColumn)); // outputs: "123.45"
+        Console.WriteLine(pressure.As(PressureUnit.Decapascal)); // outputs: "12"
+        Pressure pressureInInchesOfWaterColumn = pressure.ToUnit(PressureUnit.InchOfMercury);
+        Console.WriteLine(pressureInInchesOfWaterColumn); // outputs: "33.33333333333333 inHg"
+        Console.WriteLine(pressureInInchesOfWaterColumn.Value * 3 == 100); // outputs: "True"
+        Pressure conversionBackToPascals = pressureInInchesOfWaterColumn
+            .ToUnit(PressureUnit.Atmosphere)
+            .ToUnit(PressureUnit.MeterOfWaterColumn)
+            .ToUnit(PressureUnit.MillimeterOfWaterColumn)
+            .ToUnit(PressureUnit.Decapascal)
+            .ToUnit(PressureUnit.Pascal);
+        Console.WriteLine(conversionBackToPascals); // outputs: "100 Pa"
+        Console.WriteLine(conversionBackToPascals == pressure); // outputs: "True"
+        Console.WriteLine(conversionBackToPascals == pressureInInchesOfWaterColumn); // outputs: "True"
+    }
+
+    public static void OutputTemperatureDelta()
+    {
+        TemperatureDelta temperatureDelta = default;
+        Console.WriteLine(temperatureDelta.Unit); // outputs: "DegreeCelsius"
+        Console.WriteLine(temperatureDelta.QuantityInfo.Name); // outputs: "MyTemperature"
+    }
+}
diff --git a/Samples/UnitsNetSetup.Configuration/ConfigureWithCustomQuantities.cs b/Samples/UnitsNetSetup.Configuration/ConfigureWithCustomQuantities.cs
new file mode 100644
index 0000000000..72f70a17f2
--- /dev/null
+++ b/Samples/UnitsNetSetup.Configuration/ConfigureWithCustomQuantities.cs
@@ -0,0 +1,259 @@
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using UnitsNet;
+using UnitsNet.Debug;
+using UnitsNet.Units;
+
+namespace UnitsNetSetup.Configuration;
+
+internal static class ConfigureWithCustomQuantities
+{
+    /// <summary>
+    ///     Example of a custom/third-party quantity implementation, for plugging in quantities and units at runtime.
+    /// </summary>
+    public enum HowMuchUnit
+    {
+        Some,
+        ATon,
+        AShitTon
+    }
+
+    /// <inheritdoc cref="IQuantity" />
+    /// <summary>
+    ///     Example of a custom/third-party quantity implementation, for plugging in quantities and units at runtime.
+    /// </summary>
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
+    public readonly struct HowMuch(QuantityValue value, HowMuchUnit unit) :
+        ILinearQuantity<HowMuch, HowMuchUnit>,
+        IEquatable<HowMuch>, IComparable<HowMuch>, IComparisonOperators<HowMuch, HowMuch, bool>,
+        IParsable<HowMuch>
+    {
+        public HowMuchUnit Unit { get; } = unit;
+
+        public QuantityValue Value { get; } = value;
+
+        public static HowMuch From(QuantityValue value, HowMuchUnit unit)
+        {
+            return new HowMuch(value, unit);
+        }
+
+        public static HowMuch Zero { get; } = new(0, HowMuchUnit.Some);
+
+        public static QuantityInfo<HowMuch, HowMuchUnit> Info { get; } = new(
+            HowMuchUnit.Some,
+            new UnitDefinition<HowMuchUnit>[]
+            {
+                new(HowMuchUnit.Some, "Some", BaseUnits.Undefined),
+                new(HowMuchUnit.ATon, "Tons", new BaseUnits(mass: MassUnit.Tonne), QuantityValue.FromTerms(1, 10)),
+                new(HowMuchUnit.AShitTon, "ShitTons", BaseUnits.Undefined, QuantityValue.FromTerms(1, 100))
+            },
+            new BaseDimensions(0, 1, 0, 0, 0, 0, 0),
+            // providing a resource manager for the unit abbreviations (optional)
+            Properties.CustomQuantities_HowMuch.ResourceManager); 
+
+        #region IQuantity
+        
+        QuantityInfo<HowMuch, HowMuchUnit> IQuantity<HowMuch, HowMuchUnit>.QuantityInfo
+        {
+            get => Info;
+        }
+        
+        public override string ToString()
+        {
+            return ToString("G", null);
+        }
+
+        public string ToString(string? format, IFormatProvider? formatProvider)
+        {
+            return QuantityFormatter.Default.Format(this, format, formatProvider);
+        }
+
+        UnitKey IQuantity.UnitKey
+        {
+            get => UnitKey.ForUnit(Unit);
+        }
+
+        #endregion
+
+        #region Equality members
+
+        public bool Equals(HowMuch other)
+        {
+            return Value.Equals(other.As(Unit));
+        }
+
+        public override bool Equals(object? obj)
+        {
+            return obj is HowMuch other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(typeof(HowMuch), this.As(Info.BaseUnitInfo.Value));
+        }
+
+        public int CompareTo(HowMuch other)
+        {
+            return Value.CompareTo(other.As(Unit));
+        }
+
+        #endregion
+
+        #region Implementation of IEqualityOperators<HowMuch,HowMuch,bool>
+
+        public static bool operator ==(HowMuch left, HowMuch right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(HowMuch left, HowMuch right)
+        {
+            return !left.Equals(right);
+        }
+
+        #endregion
+
+        #region Implementation of IComparisonOperators<HowMuch,HowMuch,bool>
+
+        public static bool operator >(HowMuch left, HowMuch right)
+        {
+            return left.Value > right.As(left.Unit);
+        }
+        
+        public static bool operator >=(HowMuch left, HowMuch right)
+        {
+            return left.Value >= right.As(left.Unit);
+        }
+        
+        public static bool operator <(HowMuch left, HowMuch right)
+        {
+            return left.Value < right.As(left.Unit);
+        }
+        
+        public static bool operator <=(HowMuch left, HowMuch right)
+        {
+            return left.Value <= right.As(left.Unit);
+        }
+
+        #endregion
+
+        #region Implementation of IParsable<HowMuch>
+
+        public static HowMuch Parse(string s, IFormatProvider? provider)
+        {
+            return QuantityParser.Default.Parse<HowMuch, HowMuchUnit>(s, provider, From);
+        }
+        
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, out HowMuch result)
+        {
+            return QuantityParser.Default.TryParse<HowMuch, HowMuchUnit>(s, provider, From, out result);
+        }
+
+        #endregion
+
+        #region Implementation of IAdditionOperators<HowMuch,HowMuch,HowMuch>
+
+        public static HowMuch operator +(HowMuch left, HowMuch right)
+        {
+            return new HowMuch(left.Value + right.As(left.Unit), left.Unit);
+        }
+
+        #endregion
+
+        #region Implementation of ISubtractionOperators<HowMuch,HowMuch,HowMuch>
+
+        public static HowMuch operator -(HowMuch left, HowMuch right)
+        {
+            return new HowMuch(left.Value - right.As(left.Unit), left.Unit);
+        }
+
+        #endregion
+
+        #region Implementation of IMultiplyOperators<HowMuch,QuantityValue,HowMuch>
+
+        public static HowMuch operator *(HowMuch left, QuantityValue right)
+        {
+            return new HowMuch(left.Value * right, left.Unit);
+        }
+
+        #endregion
+
+        #region Implementation of IDivisionOperators<HowMuch,QuantityValue,HowMuch>
+
+        public static HowMuch operator /(HowMuch left, QuantityValue right)
+        {
+            return new HowMuch(left.Value / right, left.Unit);
+        }
+
+        #endregion
+
+        #region Implementation of IUnaryNegationOperators<HowMuch,HowMuch>
+
+        public static HowMuch operator -(HowMuch value)
+        {
+            return new HowMuch(-value.Value, value.Unit);
+        }
+
+        #endregion
+    }
+
+    public static void Configure()
+    {
+        UnitsNet.UnitsNetSetup.ConfigureDefaults(builder =>
+            // selecting only the required quantities (the rest are not needed for this example)
+            builder.WithQuantities([Mass.Info, Length.Info])
+            // adding the list of our custom quantities
+            .WithAdditionalQuantities([HowMuch.Info])
+                // (optionally) configuring custom conversion options (unit-conversion caching, implicit conversion etc.)
+                .WithConverterOptions(new QuantityConverterBuildOptions(defaultCachingMode:ConversionCachingMode.None)
+                    .WithCustomCachingOptions<HowMuch>(new ConversionCacheOptions(ConversionCachingMode.All))
+                    // configuring an "implicit" conversion function between the "HowMuch" and "Mass":
+                    .WithImplicitConversionOptions(options => options.SetCustomConversion<HowMuch, Mass>()
+                        // 1. since the BaseDimensions are compatible the relationship "1 ATon" = "1 Ton" would be inferred automatically (as they both have the same BaseUnits)
+                        // alternatively we could specify it manually (using a conversion coefficient or a "ConversionExpression"):
+                        // .SetCustomConversion(HowMuchUnit.AShitTon, MassUnit.Tonne, conversionCoefficient: 1)
+                        // 2. based on this relationship, all other MassUnit <-> HowMuchUnit conversions can be inferred automatically,
+                        // but if we want to: we can customize the default units to use when converting in either directions:
+                        .SetConversionUnits(MassUnit.ShortHundredweight, HowMuchUnit.Some, mapBothDirections:false)
+                        // .SetConversionUnits(MassUnit.LongHundredweight, HowMuchUnit.Some, mapBothDirections:false)
+                    )));
+    }
+
+    [SuppressMessage("ReSharper", "LocalizableElement")]
+    public static void OutputHowMuch()
+    {
+        var some = new HowMuch(1, HowMuchUnit.Some);
+        var aTon = new HowMuch(1, HowMuchUnit.ATon);
+        var aShitTon = new HowMuch(1, HowMuchUnit.AShitTon);
+
+        Console.WriteLine($"1 Some = {some.As(HowMuchUnit.ATon)} Tons");
+        Console.WriteLine($"1 Some = {some.As(HowMuchUnit.AShitTon)} ShitTons");
+        Console.WriteLine($"1 Ton = {aTon.As(HowMuchUnit.Some)} Some");
+        Console.WriteLine($"1 Ton = {aTon.As(HowMuchUnit.AShitTon)} ShitTons");
+        Console.WriteLine($"1 ShitTon = {aShitTon.As(HowMuchUnit.Some)} Some");
+        Console.WriteLine($"1 ShitTon = {aShitTon.As(HowMuchUnit.ATon)} Tons");
+        Console.WriteLine($"1 ShitTon = {aShitTon.ToUnit(HowMuchUnit.ATon)}"); // the abbreviation ("at") is mapped from the resource dictionary
+
+        HowMuch sameAsATon = (some + (aTon / 3).ToUnit(HowMuchUnit.AShitTon) - some) * 3;
+        Console.WriteLine($"sameAsATon == aTon is {sameAsATon == aTon}"); // outputs "True"
+
+        Mass aTonOfMass = UnitConverter.Default.ConvertTo(aTon.Value, aTon.Unit, Mass.Info);
+        Console.WriteLine($"aTonOfMass = {aTonOfMass}");
+
+        Mass shortHundredWeight = aTonOfMass.ToUnit(MassUnit.ShortHundredweight);
+        HowMuch aToneAsSome = UnitConverter.Default.ConvertTo(shortHundredWeight.Value, shortHundredWeight.Unit, HowMuch.Info);
+        Console.Out.WriteLine($"aToneAsSome = {aToneAsSome}");
+        Console.Out.WriteLine($"aTon == aToneAsSome is {aTon == aToneAsSome}"); // outputs "True"
+        
+        HowMuch[] someItems = [some, aTon, aShitTon];
+        Console.Out.WriteLine("someItems.Min() = {0}", someItems.Min());
+        Console.Out.WriteLine("someItems.Max() = {0}", someItems.Max());
+        Console.Out.WriteLine("someItems.Sum() = {0}", someItems.Sum());
+        Console.Out.WriteLine("someItems.Sum(HowMuchUnit.ATon) = {0}", someItems.Sum(HowMuchUnit.ATon));
+        Console.Out.WriteLine("someItems.Average() = {0}", someItems.Average());
+        Console.Out.WriteLine("someItems.Average(HowMuchUnit.ATon) = {0}", someItems.Average(HowMuchUnit.ATon));
+        Console.Out.WriteLine("someItems.Average(MassUnit.Kilogram) = {0}", UnitConverter.Default.ConvertTo(someItems.Average(), MassUnit.Kilogram));
+    }
+}
diff --git a/Samples/UnitsNetSetup.Configuration/Program.cs b/Samples/UnitsNetSetup.Configuration/Program.cs
new file mode 100644
index 0000000000..324d6a604f
--- /dev/null
+++ b/Samples/UnitsNetSetup.Configuration/Program.cs
@@ -0,0 +1,74 @@
+using System.Diagnostics;
+
+namespace UnitsNetSetup.Configuration;
+
+internal class Program
+{
+    private static void Main(string[] args)
+    {
+        Console.WriteLine("UnitsNet Configuration Samples");
+        var activeScenario = args[0];
+        
+        var startingTimestamp = Stopwatch.GetTimestamp();
+        switch (activeScenario)
+        {
+            case "CachingOptions":
+                StartWithCachingOptions(args.Length == 1 ? null : args[1]);
+                break;
+            case "CustomConversions":
+                StartWithCustomConversions();
+                break;
+            case "CustomQuantities":
+                StartWithCustomQuantities();
+                break;
+            default:
+                Console.WriteLine("\nInvalid scenario specified.");
+                break;
+        }
+
+        Console.WriteLine($"Finished in {Stopwatch.GetElapsedTime(startingTimestamp, Stopwatch.GetTimestamp())}");
+    }
+
+    private static void StartWithCachingOptions(string? configurationToUse)
+    {
+        Console.WriteLine($"Running Caching Options Scenario with configuration: {configurationToUse}");
+        switch (configurationToUse)
+        {
+            case "AsFrozen":
+                ConfigureWithConverterCachingOptions.ConfigureAsFrozen();
+                break;
+            case "WithoutCaching":
+                ConfigureWithConverterCachingOptions.ConfigureWithoutCaching();
+                break;
+            case "AsFrozenWithCustomCachingOptions":
+                ConfigureWithConverterCachingOptions.ConfigureAsFrozenWithCustomCachingOptions();
+                break;
+            case "WithSpecificQuantitiesAsFrozen":
+                ConfigureWithConverterCachingOptions.ConfigureWithSpecificQuantitiesAsFrozen();
+                break;
+            case "WithSpecificQuantitiesAndUnitsAsFrozen":
+                ConfigureWithConverterCachingOptions.ConfigureWithSpecificQuantitiesAndUnitsAsFrozen();
+                break;
+            default:
+                ConfigureWithConverterCachingOptions.ConfigureDefault();
+                break;
+        }
+        ConfigureWithConverterCachingOptions.OutputDensity();
+    }
+
+
+    private static void StartWithCustomConversions()
+    {
+        Console.WriteLine($"{DateTime.Now}: Running the Custom Conversions Scenario");
+        ConfigureWithCustomConversions.Configure();
+        ConfigureWithCustomConversions.OutputPressure();
+        ConfigureWithCustomConversions.OutputTemperatureDelta();
+    }
+
+    private static void StartWithCustomQuantities()
+    {
+        Console.WriteLine("\nRunning the Custom Quantities Scenario");
+        ConfigureWithCustomQuantities.Configure();
+        ConfigureWithCustomQuantities.OutputHowMuch();
+    }
+}
diff --git a/Samples/UnitsNetSetup.Configuration/Properties/CustomQuantities.HowMuch.Designer.cs b/Samples/UnitsNetSetup.Configuration/Properties/CustomQuantities.HowMuch.Designer.cs
new file mode 100644
index 0000000000..7b4daa88b6
--- /dev/null
+++ b/Samples/UnitsNetSetup.Configuration/Properties/CustomQuantities.HowMuch.Designer.cs
@@ -0,0 +1,90 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace UnitsNetSetup.Configuration.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class CustomQuantities_HowMuch {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal CustomQuantities_HowMuch() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("UnitsNetSetup.Configuration.Properties.CustomQuantities.HowMuch", typeof(CustomQuantities_HowMuch).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to ast.
+        /// </summary>
+        internal static string ShitTons {
+            get {
+                return ResourceManager.GetString("ShitTons", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to sm.
+        /// </summary>
+        internal static string Some {
+            get {
+                return ResourceManager.GetString("Some", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to at.
+        /// </summary>
+        internal static string Tons {
+            get {
+                return ResourceManager.GetString("Tons", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/Samples/UnitsNetSetup.Configuration/Properties/CustomQuantities.HowMuch.resx b/Samples/UnitsNetSetup.Configuration/Properties/CustomQuantities.HowMuch.resx
new file mode 100644
index 0000000000..1a51dd643c
--- /dev/null
+++ b/Samples/UnitsNetSetup.Configuration/Properties/CustomQuantities.HowMuch.resx
@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ShitTons" xml:space="preserve">
+    <value>ast</value>
+    <comment>HowMuch.AShitTon</comment>
+  </data>
+  <data name="Tons" xml:space="preserve">
+    <value>at</value>
+    <comment>HowMuch.ATon</comment>
+  </data>
+  <data name="Some" xml:space="preserve">
+    <value>sm</value>
+    <comment>HowMuch.Some</comment>
+  </data>
+</root>
\ No newline at end of file
diff --git a/Samples/UnitsNetSetup.Configuration/Properties/launchSettings.json b/Samples/UnitsNetSetup.Configuration/Properties/launchSettings.json
new file mode 100644
index 0000000000..be0f3d6337
--- /dev/null
+++ b/Samples/UnitsNetSetup.Configuration/Properties/launchSettings.json
@@ -0,0 +1,16 @@
+{
+  "profiles": {
+    "ConfigureCachingOptions": {
+      "commandName": "Project",
+      "commandLineArgs": "CachingOptions WithSpecificQuantitiesAndUnitsAsFrozen"
+    },
+    "ConfigureCustomQuantities": {
+      "commandName": "Project",
+      "commandLineArgs": "CustomQuantities"
+    },
+    "ConfigureCustomConversions": {
+      "commandName": "Project",
+      "commandLineArgs": "CustomConversions"
+    }
+  }
+}
\ No newline at end of file
diff --git a/Samples/UnitsNetSetup.Configuration/UnitsNetSetup.Configuration.csproj b/Samples/UnitsNetSetup.Configuration/UnitsNetSetup.Configuration.csproj
new file mode 100644
index 0000000000..eb6805e369
--- /dev/null
+++ b/Samples/UnitsNetSetup.Configuration/UnitsNetSetup.Configuration.csproj
@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <Configurations>Debug;Release;Official</Configurations>
+    <Platforms>AnyCPU</Platforms>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="UnitsNet" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Properties\CustomQuantities.HowMuch.Designer.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>CustomQuantities.HowMuch.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Update="Properties\CustomQuantities.HowMuch.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>CustomQuantities.HowMuch.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+
+</Project>
diff --git a/UnitsNet.Benchmark/BenchmarkHelpers.cs b/UnitsNet.Benchmark/BenchmarkHelpers.cs
index 477c1c67e3..dc0c599a5a 100644
--- a/UnitsNet.Benchmark/BenchmarkHelpers.cs
+++ b/UnitsNet.Benchmark/BenchmarkHelpers.cs
@@ -1,8 +1,7 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -15,24 +14,39 @@ public static string[] GetRandomAbbreviations<TQuantity>(this Random random, Uni
         return random.GetItems(abbreviations.GetAllUnitAbbreviationsForQuantity(typeof(TQuantity)).ToArray(), nbAbbreviations);
     }
     
-    public static (TQuantity Quantity, TUnit Unit)[] GetRandomConversions<TQuantity, TUnit>(this Random random, double value, TUnit[] options,
+    public static (TUnit FromUnit, TUnit ToUnit)[] GetRandomConversions<TUnit>(this Random random, IEnumerable<TUnit> options, int nbConversions)
+    {
+        var choices = options.ToArray();
+        return random.GetItems(choices, nbConversions).Zip(random.GetItems(choices, nbConversions), (fromUnit, toUnit) => (fromUnit, toUnit)).ToArray();
+    }
+    
+    public static (TQuantity Quantity, TUnit Unit)[] GetRandomConversions<TQuantity, TUnit>(this Random random, QuantityValue value, IEnumerable<TUnit> options,
         int nbConversions)
         where TQuantity : IQuantity<TUnit>
         where TUnit : struct, Enum
     {
-        var quantities = GetRandomQuantities<TQuantity, TUnit>(random, value, options, nbConversions);
+        return GetRandomConversions<TQuantity, TUnit>(random, value, options.ToArray(), nbConversions);
+    }
+    
+    public static (TQuantity Quantity, TUnit Unit)[] GetRandomConversions<TQuantity, TUnit>(this Random random, QuantityValue value, TUnit[] options,
+        int nbConversions)
+        where TQuantity : IQuantity<TUnit>
+        where TUnit : struct, Enum
+    {
+        IEnumerable<TQuantity> quantities = random.GetRandomQuantities<TQuantity, TUnit>(value, options, nbConversions);
         TUnit[] units = random.GetItems(options, nbConversions);
         return quantities.Zip(units, (quantity, unit) => (quantity, unit)).ToArray();
     }
-
-    public static IEnumerable<TQuantity> GetRandomQuantities<TQuantity, TUnit>(this Random random, double value, TUnit[] units, int nbQuantities)
-        where TQuantity : IQuantity<TUnit> where TUnit : struct, Enum
+    
+    public static IEnumerable<TQuantity> GetRandomQuantities<TQuantity, TUnit>(this Random random, QuantityValue value, TUnit[] units, int nbQuantities)
+        where TQuantity : IQuantity<TUnit>
+        where TUnit : struct, Enum
     {
         IEnumerable<TQuantity> quantities = random.GetItems(units, nbQuantities).Select(unit => (TQuantity)Quantity.From(value, unit));
         return quantities;
     }
-
-#if !NET
+    
+    #if !NET
     /// <summary>Creates an array populated with items chosen at random from the provided set of choices.</summary>
     /// <param name="random">The random number generator used to select items.</param>
     /// <param name="choices">The items to use to populate the array.</param>
diff --git a/UnitsNet.Benchmark/Comparisons/ComparisonBenchmarks.cs b/UnitsNet.Benchmark/Comparisons/ComparisonBenchmarks.cs
index 6bbc84741d..f7693e10eb 100644
--- a/UnitsNet.Benchmark/Comparisons/ComparisonBenchmarks.cs
+++ b/UnitsNet.Benchmark/Comparisons/ComparisonBenchmarks.cs
@@ -1,68 +1,79 @@
-using System;
-using System.Collections.Generic;
+using System;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
 
 namespace UnitsNet.Benchmark.Comparisons;
 
 [MemoryDiagnoser]
-[ShortRunJob(RuntimeMoniker.Net48)]
-[ShortRunJob(RuntimeMoniker.Net80)]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net90)]
 public class ComparisonBenchmarks
 {
     private static readonly Mass Tolerance = Mass.FromNanograms(1);
 
-    public static IEnumerable<object[]> Operands()
-    {
-        // equal value and unit
-        yield return [Mass.From(42, Mass.BaseUnit), Mass.From(42, Mass.BaseUnit)];
-        // equal value and unit
-        yield return [Mass.FromGrams(42), Mass.FromGrams(42)];
-        // zero in another unit
-        yield return [Mass.Zero, Mass.FromGrams(0)];
-        // same quantity in another unit
-        yield return [Mass.FromGrams(42), Mass.FromMilligrams(42000)];
-        // same quantity in another unit (in reverse)
-        yield return [Mass.FromMilligrams(42000), Mass.FromGrams(42)];
-        // different value and same unit
-        yield return [Mass.FromGrams(42), Mass.FromGrams(42.1)];
-        // huge values, same unit
-        yield return [Mass.FromGrams(-1e37), Mass.FromGrams(1 / 1e12)];
-        // huge values, different units
-        yield return [Mass.FromGrams(-1e37), Mass.FromMilligrams(1 / 1e12)];
-        // Math.PI, same unit
-        yield return [Mass.FromGrams(Math.PI), Mass.FromGrams(Math.PI)];
-        // Math.PI, different units
-        yield return [Mass.FromGrams(Math.PI), Mass.FromMilligrams(Math.PI)];
-        // very close fractions, same units
-        yield return [Mass.FromGrams(12.3456789987654321), Mass.FromGrams(12.3456789987654322)];
-    }
+    // [Params(true, false, Priority = 3)]
+    [Params(true)]
+    public bool Frozen { get; set; }
 
-    [Benchmark]
-    [ArgumentsSource(nameof(Operands))]
-    public bool Equals(Mass a, Mass b)
+    // [Params(ConversionCachingMode.All, ConversionCachingMode.None, Priority = 2)]
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+    
+
+    // [Params(MassUnit.Milligram, MassUnit.Gram, MassUnit.Kilogram)]
+    [Params(MassUnit.Milligram)]
+    public MassUnit LeftUnit { get; set; }
+    
+    // [Params(MassUnit.Gram, MassUnit.Kilogram)]
+    // [Params(MassUnit.Gram)]
+    [Params(MassUnit.Milligram)]
+    public MassUnit RightUnit { get; set; }
+
+    [ParamsSource(nameof(LeftValues))]
+    public QuantityValue LeftValue { get; set; }
+
+    public QuantityValue[] LeftValues => [95];
+    
+    
+    [ParamsSource(nameof(RightValues))]
+    public QuantityValue RightValue { get; set; }
+
+    public QuantityValue[] RightValues => [95];
+    
+    private Mass _leftQuantity, _rightQuantity;
+    
+    [GlobalSetup]
+    public void GlobalSetup()
     {
-        return a.Equals(b);
+        Console.Out.WriteLine("Preparing the configuration..");
+        UnitsNetSetup.ConfigureDefaults(builder => builder
+            .WithQuantities([Mass.Info])
+            .WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        Console.Out.WriteLine("Default configuration set.");
+        Quantity.From(QuantityValue.Zero, MassUnit.Kilogram);
+        
+        _leftQuantity = new Mass(LeftValue, LeftUnit);
+        _rightQuantity = new Mass(RightValue, RightUnit);
     }
-
+    
     [Benchmark]
-    [ArgumentsSource(nameof(Operands))]
-    public bool EqualsTolerance(Mass a, Mass b)
+    public bool Equals()
     {
-        return a.Equals(b, Tolerance);
+        return _leftQuantity.Equals(_rightQuantity);
     }
-
-    [Benchmark]
-    [ArgumentsSource(nameof(Operands))]
-    public bool GetHashCode(Mass a, Mass b)
+    
+    [Benchmark(Baseline = true)]
+    public bool EqualsTolerance()
     {
-        return a.GetHashCode() == b.GetHashCode();
+        return _leftQuantity.Equals(_rightQuantity, Tolerance);
     }
-
-    [Benchmark]
-    [ArgumentsSource(nameof(Operands))]
-    public int CompareTo(Mass a, Mass b)
+    
+    [Benchmark(Baseline = false)]
+    public bool EqualsToleranceBoxed()
     {
-        return a.CompareTo(b);
+        Mass left = _leftQuantity;
+        IQuantity<Mass, MassUnit> right = _rightQuantity;
+        return left.Equals(right, Tolerance);
     }
 }
diff --git a/UnitsNet.Benchmark/Comparisons/GetHashCodeBenchmarks.cs b/UnitsNet.Benchmark/Comparisons/GetHashCodeBenchmarks.cs
new file mode 100644
index 0000000000..15cd19ba54
--- /dev/null
+++ b/UnitsNet.Benchmark/Comparisons/GetHashCodeBenchmarks.cs
@@ -0,0 +1,77 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+
+namespace UnitsNet.Benchmark.Comparisons;
+
+[MemoryDiagnoser]
+[ShortRunJob(RuntimeMoniker.Net48)]
+[ShortRunJob(RuntimeMoniker.Net80)]
+public class GetHashCodeBenchmarks
+{
+
+    // [Params(true, false)]
+    [Params(true)]
+    public bool Frozen { get; set; }
+
+    // [Params(ConversionCachingMode.All, ConversionCachingMode.None)]
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+    
+    [Params(true, false)]
+    public bool ReduceQuantityValues { get; set; }
+
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder
+            .WithQuantities([Mass.Info])
+            .WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+    }
+
+    private IEnumerable<Mass> GetQuantities() {
+        // equal value and unit
+        yield return Mass.From(42, Mass.BaseUnit);
+        // zero in another unit
+        yield return Mass.FromGrams(0);
+        // equal value and unit
+        yield return Mass.FromGrams(42);
+        // same quantity in another unit
+        yield return Mass.FromMilligrams(42_000);
+        // decimal value 
+        yield return Mass.FromGrams(42.1);
+        // huge values in numerator
+        yield return Mass.FromGrams(BigInteger.Pow(-10, 37));
+        // huge values in denominator
+        yield return Mass.FromGrams(QuantityValue.FromTerms(1, BigInteger.Pow(10, 12)));
+        // Math.PI in base unit
+        yield return Mass.From(QuantityValue.PI, Mass.BaseUnit);
+        // Math.PI, different units
+        yield return Mass.FromGrams(QuantityValue.PI);
+        // very precise decimal
+        yield return Mass.FromGrams(12.3456789987654321m);
+    }
+
+    public IEnumerable<Mass> Operands()
+    {
+        if (ReduceQuantityValues)
+        {
+            return GetQuantities().Select(x => new Mass(QuantityValue.Reduce(x.Value), x.Unit));
+        }
+        
+        return GetQuantities();
+    }
+
+    [Benchmark]
+    [ArgumentsSource(nameof(Operands))]
+    public int GetHashCode(Mass a)
+    {
+        return a.GetHashCode();
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/ConversionExpressionBenchmarks.cs b/UnitsNet.Benchmark/Conversions/ConversionExpressionBenchmarks.cs
new file mode 100644
index 0000000000..6f645c70f7
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/ConversionExpressionBenchmarks.cs
@@ -0,0 +1,68 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Collections.Generic;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+
+namespace UnitsNet.Benchmark.Conversions;
+
+[MemoryDiagnoser]
+public class ConversionExpressionBenchmarks
+{
+    private static readonly QuantityValue Value = 123.456;
+    private static readonly ConversionExpression[] DefaultExpression = Quantity.Infos.SelectMany(GetUnreducedExpressionsForQuantity).ToArray();
+    private static readonly ConversionExpression[] ReducedExpression = Quantity.Infos.SelectMany(GetReducedExpressionsForQuantity).ToArray();
+
+    private static readonly ConvertValueDelegate[] ConversionFunctions = ReducedExpression.Select(x => (ConvertValueDelegate)x).ToArray();
+
+    private static IEnumerable<ConversionExpression> GetUnreducedExpressionsForQuantity(QuantityInfo quantityInfo)
+    {
+        return from fromUnit in quantityInfo.UnitInfos
+            from toUnit in quantityInfo.UnitInfos
+            select fromUnit.ConversionToBase.Evaluate(toUnit.ConversionFromBase);
+    }
+
+    private static IEnumerable<ConversionExpression> GetReducedExpressionsForQuantity(QuantityInfo quantityInfo)
+    {
+        return from fromUnit in quantityInfo.UnitInfos
+            from toUnit in quantityInfo.UnitInfos
+            select fromUnit.ConversionToBase.Evaluate(toUnit.ConversionFromBase, true);
+    }
+
+    [Benchmark(Baseline = true)]
+    public QuantityValue ConvertWithDefaultExpression()
+    {
+        QuantityValue result = QuantityValue.Zero;
+        foreach (ConversionExpression expression in DefaultExpression)
+        {
+            result = expression.Evaluate(Value);
+        }
+
+        return result;
+    }
+
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWithReducedExpression()
+    {
+        QuantityValue result = QuantityValue.Zero;
+        foreach (ConversionExpression expression in ReducedExpression)
+        {
+            result = expression.Evaluate(Value);
+        }
+
+        return result;
+    }
+
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWithFunctions()
+    {
+        QuantityValue result = QuantityValue.Zero;
+        foreach (ConvertValueDelegate function in ConversionFunctions)
+        {
+            result = function(Value);
+        }
+
+        return result;
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/FromString/ParseUnitBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/ParseUnitBenchmarks.cs
index 5cd182185c..43d7ef0a21 100644
--- a/UnitsNet.Benchmark/Conversions/FromString/ParseUnitBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/FromString/ParseUnitBenchmarks.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Globalization;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
@@ -12,7 +12,7 @@ namespace UnitsNet.Benchmark.Conversions.FromString;
 public class ParseUnitBenchmarks
 {
     private const int NbAbbreviations = 1000;
-    
+
     private static readonly CultureInfo Culture = CultureInfo.InvariantCulture;
     private readonly Random _random = new(42);
     private string[] _densityUnits;
@@ -57,8 +57,7 @@ public void PreparePressureUnits()
     public void PrepareVolumeFlowUnits()
     {
         _volumeFlowUnits = _random.GetRandomAbbreviations<VolumeFlowUnit>(UnitsNetSetup.Default.UnitAbbreviations, NbAbbreviations);
-        // initializes the QuantityInfoLookup and the abbreviations cache
-        VolumeFlow.TryParseUnit("_invalid", Culture, out _);
+        VolumeFlow.ParseUnit(_volumeFlowUnits[0], Culture);
     }
 
     [Benchmark(Baseline = true)]
diff --git a/UnitsNet.Benchmark/Conversions/FromString/QuantityFromConfiguredUnitAbbreviationBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/QuantityFromConfiguredUnitAbbreviationBenchmarks.cs
new file mode 100644
index 0000000000..b22b42bfa2
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/FromString/QuantityFromConfiguredUnitAbbreviationBenchmarks.cs
@@ -0,0 +1,128 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Globalization;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Conversions.FromString;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class QuantityFromConfiguredUnitAbbreviationBenchmarks
+{
+    private static readonly CultureInfo Culture = CultureInfo.InvariantCulture;
+    private readonly Random _random = new(42);
+    private string[] _densityUnits;
+    private string[] _massUnits;
+    private string[] _pressureUnits;
+    private string[] _volumeFlowUnits;
+    private string[] _volumeUnits = [];
+
+    [Params(1000)]
+    public int NbAbbreviations { get; set; }
+
+    [GlobalSetup]
+    public void PrepareQuantities()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithQuantities([Mass.Info, Volume.Info, Density.Info, Pressure.Info, VolumeFlow.Info]));
+    }
+
+    [GlobalSetup(Target = nameof(FromMassUnitAbbreviation))]
+    public void PrepareMassUnits()
+    {
+        PrepareQuantities();
+        _massUnits = _random.GetItems(["mg", "g", "kg", "lbs", "Mlbs"], NbAbbreviations);
+    }
+
+    [GlobalSetup(Target = nameof(FromVolumeUnitAbbreviation))]
+    public void PrepareVolumeUnits()
+    {
+        PrepareQuantities();
+        _volumeUnits = _random.GetItems(["ml", "l", "cm³", "m³"], NbAbbreviations);
+    }
+
+    [GlobalSetup(Target = nameof(FromDensityUnitAbbreviation))]
+    public void PrepareDensityUnits()
+    {
+        PrepareQuantities();
+        _densityUnits = _random.GetRandomAbbreviations<DensityUnit>(UnitsNetSetup.Default.UnitAbbreviations, NbAbbreviations);
+    }
+
+    [GlobalSetup(Target = nameof(FromPressureUnitAbbreviation))]
+    public void PreparePressureUnits()
+    {
+        PrepareQuantities();
+        _pressureUnits = _random.GetRandomAbbreviations<PressureUnit>(UnitsNetSetup.Default.UnitAbbreviations, NbAbbreviations);
+    }
+
+    [GlobalSetup(Target = nameof(FromVolumeFlowUnitAbbreviation))]
+    public void PrepareVolumeFlowUnits()
+    {
+        PrepareQuantities();
+        _volumeFlowUnits = _random.GetRandomAbbreviations<VolumeFlowUnit>(UnitsNetSetup.Default.UnitAbbreviations, NbAbbreviations);
+    }
+
+    [Benchmark(Baseline = true)]
+    public IQuantity FromMassUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var unitToParse in _massUnits)
+        {
+            quantity = Quantity.FromUnitAbbreviation(Culture, 1, unitToParse);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromVolumeUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var unitToParse in _volumeUnits)
+        {
+            quantity = Quantity.FromUnitAbbreviation(Culture, 1, unitToParse);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromDensityUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var unitToParse in _densityUnits)
+        {
+            quantity = Quantity.FromUnitAbbreviation(Culture, 1, unitToParse);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromPressureUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var unitToParse in _pressureUnits)
+        {
+            quantity = Quantity.FromUnitAbbreviation(Culture, 1, unitToParse);
+        }
+
+        return quantity;
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity FromVolumeFlowUnitAbbreviation()
+    {
+        IQuantity quantity = null;
+        foreach (var unitToParse in _volumeFlowUnits)
+        {
+            quantity = Quantity.FromUnitAbbreviation(Culture, 1, unitToParse);
+        }
+
+        return quantity;
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/FromString/QuantityFromStringBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/QuantityFromStringBenchmarks.cs
index 9c7b03f1d1..81eaeade4f 100644
--- a/UnitsNet.Benchmark/Conversions/FromString/QuantityFromStringBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/FromString/QuantityFromStringBenchmarks.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Globalization;
 using System.Linq;
 using BenchmarkDotNet.Attributes;
@@ -10,6 +10,7 @@ namespace UnitsNet.Benchmark.Conversions.FromString;
 [MemoryDiagnoser]
 [SimpleJob(RuntimeMoniker.Net48)]
 [SimpleJob(RuntimeMoniker.Net90)]
+[SimpleJob(RuntimeMoniker.Net10_0)]
 public class QuantityFromStringBenchmarks
 {
     private static readonly CultureInfo Culture = CultureInfo.InvariantCulture;
diff --git a/UnitsNet.Benchmark/Conversions/FromString/QuantityFromUnitAbbreviationBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/QuantityFromUnitAbbreviationBenchmarks.cs
index a46e137560..770e9c7a3b 100644
--- a/UnitsNet.Benchmark/Conversions/FromString/QuantityFromUnitAbbreviationBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/FromString/QuantityFromUnitAbbreviationBenchmarks.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Globalization;
 using System.Linq;
 using BenchmarkDotNet.Attributes;
diff --git a/UnitsNet.Benchmark/Conversions/FromString/QuantityFromUnitNameBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/QuantityFromUnitNameBenchmarks.cs
index f337295e9d..a7609dfd24 100644
--- a/UnitsNet.Benchmark/Conversions/FromString/QuantityFromUnitNameBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/FromString/QuantityFromUnitNameBenchmarks.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
@@ -14,30 +14,30 @@ public class QuantityFromUnitNameBenchmarks
     private string[] _unitNames;
 
     [Params(1000)]
-    public int NbAbbreviations { get; set; }
+    public int NbIterations { get; set; }
 
     [GlobalSetup(Target = nameof(FromMassUnitName))]
     public void PrepareMassUnits()
     {
-        _unitNames = _random.GetItems(Mass.Info.UnitInfos.Select(x => x.Name).ToArray(), NbAbbreviations);
+        _unitNames = _random.GetItems(Mass.Info.UnitInfos.Select(x => x.Name).ToArray(), NbIterations);
     }
 
     [GlobalSetup(Target = nameof(FromVolumeUnitName))]
     public void PrepareVolumeUnits()
     {
-        _unitNames = _random.GetItems(Volume.Info.UnitInfos.Select(x => x.Name).ToArray(), NbAbbreviations);
+        _unitNames = _random.GetItems(Volume.Info.UnitInfos.Select(x => x.Name).ToArray(), NbIterations);
     }
 
     [GlobalSetup(Target = nameof(FromPressureUnitName))]
     public void PreparePressureUnits()
     {
-        _unitNames = _random.GetItems(Pressure.Info.UnitInfos.Select(x => x.Name).ToArray(), NbAbbreviations);
+        _unitNames = _random.GetItems(Pressure.Info.UnitInfos.Select(x => x.Name).ToArray(), NbIterations);
     }
 
     [GlobalSetup(Target = nameof(FromVolumeFlowUnitName))]
     public void PrepareVolumeFlowUnits()
     {
-        _unitNames = _random.GetItems(VolumeFlow.Info.UnitInfos.Select(x => x.Name).ToArray(), NbAbbreviations);
+        _unitNames = _random.GetItems(VolumeFlow.Info.UnitInfos.Select(x => x.Name).ToArray(), NbIterations);
     }
 
     [Benchmark(Baseline = true)]
@@ -46,7 +46,7 @@ public IQuantity FromMassUnitName()
         IQuantity quantity = null;
         foreach (var unitName in _unitNames)
         {
-            quantity = Quantity.From(1, nameof(Mass), unitName);
+            quantity = Quantity.From(QuantityValue.One, nameof(Mass), unitName);
         }
 
         return quantity;
@@ -58,7 +58,7 @@ public IQuantity FromVolumeUnitName()
         IQuantity quantity = null;
         foreach (var unitName in _unitNames)
         {
-            quantity = Quantity.From(1, nameof(Volume), unitName);
+            quantity = Quantity.From(QuantityValue.One, nameof(Volume), unitName);
         }
 
         return quantity;
@@ -70,7 +70,7 @@ public IQuantity FromPressureUnitName()
         IQuantity quantity = null;
         foreach (var unitName in _unitNames)
         {
-            quantity = Quantity.From(1, nameof(Pressure), unitName);
+            quantity = Quantity.From(QuantityValue.One, nameof(Pressure), unitName);
         }
 
         return quantity;
@@ -82,7 +82,7 @@ public IQuantity FromVolumeFlowUnitName()
         IQuantity quantity = null;
         foreach (var unitName in _unitNames)
         {
-            quantity = Quantity.From(1, nameof(VolumeFlow), unitName);
+            quantity = Quantity.From(QuantityValue.One, nameof(VolumeFlow), unitName);
         }
 
         return quantity;
diff --git a/UnitsNet.Benchmark/Conversions/FromString/SerializationBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/SerializationBenchmarks.cs
new file mode 100644
index 0000000000..b4fa5da181
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/FromString/SerializationBenchmarks.cs
@@ -0,0 +1,289 @@
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Serialization.SystemTextJson;
+using UnitsNet.Serialization.SystemTextJson.Unit;
+using UnitsNet.Serialization.SystemTextJson.Value;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Conversions.FromString;
+
+[JsonSourceGenerationOptions(Converters = [typeof(JsonQuantityConverter), typeof(QuantityValueFractionalNotationConverter)])]
+[JsonSerializable(typeof(Mass))]
+public partial class DefaultEnumConverterJsonContext : JsonSerializerContext
+{
+}
+
+[JsonSourceGenerationOptions(Converters = [typeof(JsonQuantityConverter), typeof(UnitTypeAndNameConverter), typeof(QuantityValueFractionalNotationConverter)])]
+[JsonSerializable(typeof(Mass))]
+public partial class UnitTypeAndNameJsonContext : JsonSerializerContext
+{
+}
+
+[JsonSourceGenerationOptions(Converters = [typeof(JsonQuantityConverter), typeof(AbbreviatedUnitConverter), typeof(QuantityValueFractionalNotationConverter)])]
+[JsonSerializable(typeof(Mass))]
+public partial class AbbreviatedUnitJsonContext : JsonSerializerContext
+{
+}
+
+// [JsonSourceGenerationOptions(Converters = [typeof(AbbreviatedQuantityConverter<Mass, MassUnit>)])]
+[JsonSourceGenerationOptions(Converters = [typeof(AbbreviatedQuantityConverter)])]
+[JsonSerializable(typeof(Mass))]
+public partial class AbbreviatedQuantityJsonContext : JsonSerializerContext
+{
+}
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net90)]
+// [DryJob(RuntimeMoniker.Net80)]
+public class MassSerializationBenchmarks
+{
+    
+    public const int NbIterations = 1000;
+    // public const int NbIterations = 1;
+
+    private static Mass[] TestMasses =
+    [
+        Mass.Zero, new Mass(0, MassUnit.Gram), new Mass(42, MassUnit.Gram), new Mass(42, MassUnit.Kilogram), new Mass(123.45m, MassUnit.Milligram)
+    ];
+    // private static Volume[] TestVolumes =
+    // [
+    //     Volume.Zero, new Volume(0, VolumeUnit.Milliliter), new Volume(42, VolumeUnit.Milliliter), new Volume(42, VolumeUnit.CubicMeter), new Volume(123.45m, VolumeUnit.Microliter)
+    // ];
+    //
+    // public record TestObject(Mass[] Masses, Volume[] Volumes);
+    //
+    // private static TestObject Values = new(TestMasses, TestVolumes);
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        var _ = Mass.Zero.ToString("G", CultureInfo.InvariantCulture);
+    }
+    
+    [Benchmark(Baseline = true)]
+    public void RoundTripWithDefaultEnumConverterJsonContext()
+    {
+        for (int i = 0; i < NbIterations; i++)
+        {
+            foreach (var mass in TestMasses)
+            {
+                var json = System.Text.Json.JsonSerializer.Serialize(mass, DefaultEnumConverterJsonContext.Default.Mass);
+                var deserializedMass = System.Text.Json.JsonSerializer.Deserialize<Mass>(json, DefaultEnumConverterJsonContext.Default.Mass);
+                // Console.Out.WriteLine("json = {0}", json);
+                if (mass != deserializedMass)
+                {
+                    throw new InvalidDataException();
+                }
+            }
+        }
+    }
+
+    [Benchmark(Baseline = false)]
+    public void RoundTripWithUnitTypeAndNameJsonContext()
+    {
+        for (int i = 0; i < NbIterations; i++)
+        {
+            foreach (var mass in TestMasses)
+            {
+                var json = System.Text.Json.JsonSerializer.Serialize(mass, UnitTypeAndNameJsonContext.Default.Mass);
+                var deserializedMass = System.Text.Json.JsonSerializer.Deserialize<Mass>(json, UnitTypeAndNameJsonContext.Default.Mass);
+                // Console.Out.WriteLine("json = {0}", json);
+                if (mass != deserializedMass)
+                {
+                    throw new InvalidDataException();
+                }
+            }
+        }
+    }
+
+    [Benchmark(Baseline = false)]
+    public void RoundTripWithAbbreviatedUnitJsonContext()
+    {
+        for (int i = 0; i < NbIterations; i++)
+        {
+            foreach (var mass in TestMasses)
+            {
+                var json = System.Text.Json.JsonSerializer.Serialize(mass, AbbreviatedUnitJsonContext.Default.Mass);
+                // Console.Out.WriteLine("json = {0}", json);
+                var deserializedMass = System.Text.Json.JsonSerializer.Deserialize<Mass>(json, AbbreviatedUnitJsonContext.Default.Mass);
+                if (mass != deserializedMass)
+                {
+                    throw new InvalidDataException();
+                }
+            }
+        }
+    }
+    
+    [Benchmark(Baseline = false)]
+    public void RoundTripWithAbbreviatedQuantityJsonContext()
+    {
+        for (int i = 0; i < NbIterations; i++)
+        {
+            foreach (var mass in TestMasses)
+            {
+                var json = System.Text.Json.JsonSerializer.Serialize(mass, AbbreviatedUnitJsonContext.Default.Mass);
+                // Console.Out.WriteLine("json = {0}", json);
+                var deserializedMass = System.Text.Json.JsonSerializer.Deserialize<Mass>(json, AbbreviatedUnitJsonContext.Default.Mass);
+                if (mass != deserializedMass)
+                {
+                    throw new InvalidDataException();
+                }
+            }
+        }
+    }
+    
+    [Benchmark(Baseline = false)]
+    public void RoundTripWithJsonConverterWithUnitTypeAndNameConverter()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new JsonQuantityConverter());
+        options.Converters.Add(new UnitTypeAndNameConverter());
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Default);
+        
+        for (int i = 0; i < NbIterations; i++)
+        {
+            foreach (var mass in TestMasses)
+            {
+                var json = System.Text.Json.JsonSerializer.Serialize(mass, options);
+                var deserializedMass = System.Text.Json.JsonSerializer.Deserialize<Mass>(json, options);
+                if (mass != deserializedMass)
+                {
+                    throw new InvalidDataException();
+                }
+            }
+        }
+    }
+    
+    [Benchmark(Baseline = false)]
+    public void RoundTripWithJsonQuantityConverterAndAbbreviatedUnitConverter()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new JsonQuantityConverter());
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Default);
+        
+        for (int i = 0; i < NbIterations; i++)
+        {
+            foreach (var mass in TestMasses)
+            {
+                var json = System.Text.Json.JsonSerializer.Serialize(mass, options);
+                var deserializedMass = System.Text.Json.JsonSerializer.Deserialize<Mass>(json, options);
+                if (mass != deserializedMass)
+                {
+                    throw new InvalidDataException();
+                }
+            }
+        }
+    }
+
+    [Benchmark(Baseline = false)]
+    public void RoundTripWithAbbreviatedQuantityConverter()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedQuantityConverter());
+        
+        for (int i = 0; i < NbIterations; i++)
+        {
+            foreach (var mass in TestMasses)
+            {
+                var json = System.Text.Json.JsonSerializer.Serialize(mass, options);
+                var deserializedMass = System.Text.Json.JsonSerializer.Deserialize<Mass>(json, options);
+                if (mass != deserializedMass)
+                {
+                    throw new InvalidDataException();
+                }
+            }
+        }
+    }
+
+}
+
+
+[JsonSourceGenerationOptions(Converters = [typeof(QuantityValueMixedNotationConverter), typeof(AbbreviatedInterfaceQuantityWithAvailableValueConverter)])]
+[JsonSerializable(typeof(Mass))]
+public partial class AbbreviatedInterfaceQuantityJsonContext : JsonSerializerContext
+{
+}
+
+[MemoryDiagnoser]
+[MediumRunJob(RuntimeMoniker.Net90)]
+[MediumRunJob(RuntimeMoniker.Net48)]
+// [DryJob(RuntimeMoniker.Net48)]
+// [SimpleJob(RuntimeMoniker.Net90)]
+// [DryJob(RuntimeMoniker.Net80)]
+public class InterfaceQuantitySerializationBenchmarks
+{
+
+    public const int NbIterations = 1000;
+    // public const int NbIterations = 1;
+
+    private static IQuantity[] TestMasses =
+    [
+        Mass.Zero, new Mass(0, MassUnit.Gram), new Mass(42, MassUnit.Gram), new Mass(42, MassUnit.Kilogram), new Mass(123.45m, MassUnit.Milligram)
+    ];
+
+    [Benchmark(Baseline = false)]
+    public void RoundTripWithAbbreviatedInterfaceQuantityConverter()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(QuantityValueMixedNotationConverter.Default);
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+        
+        for (int i = 0; i < NbIterations; i++)
+        {
+            foreach (var mass in TestMasses)
+            {
+                var json = System.Text.Json.JsonSerializer.Serialize(mass, options);
+                var deserializedMass = System.Text.Json.JsonSerializer.Deserialize<IQuantity>(json, options);
+                // if (!Equals(mass, deserializedMass))
+                // {
+                //     throw new InvalidDataException();
+                // }
+            }
+        }
+    }
+
+    [Benchmark(Baseline = true)]
+    public void RoundTripWithAbbreviatedInterfaceQuantityConverterWithValueConverter()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+        
+        for (int i = 0; i < NbIterations; i++)
+        {
+            foreach (var mass in TestMasses)
+            {
+                var json = System.Text.Json.JsonSerializer.Serialize(mass, options);
+                var deserializedMass = System.Text.Json.JsonSerializer.Deserialize<IQuantity>(json, options);
+                // if (!Equals(mass, deserializedMass))
+                // {
+                //     throw new InvalidDataException();
+                // }
+            }
+        }
+    }
+
+    [Benchmark(Baseline = false)]
+    public void RoundTripWithAbbreviatedUnitJsonContext()
+    {
+        for (int i = 0; i < NbIterations; i++)
+        {
+            foreach (var mass in TestMasses)
+            {
+                var json = System.Text.Json.JsonSerializer.Serialize(mass, AbbreviatedInterfaceQuantityJsonContext.Default.IQuantity);
+                // Console.Out.WriteLine("json = {0}", json);
+                var deserializedMass = System.Text.Json.JsonSerializer.Deserialize<IQuantity>(json, AbbreviatedInterfaceQuantityJsonContext.Default.IQuantity);
+                // if (!Equals(mass, deserializedMass))
+                // {
+                //     throw new InvalidDataException();
+                // }
+            }
+        }
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/FromString/TryParseInvalidUnitBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/TryParseInvalidUnitBenchmarks.cs
index bd24c1c579..c3998fe2ad 100644
--- a/UnitsNet.Benchmark/Conversions/FromString/TryParseInvalidUnitBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/FromString/TryParseInvalidUnitBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -20,7 +20,7 @@ public class TryParseInvalidUnitBenchmarks
     private static readonly CultureInfo Culture = CultureInfo.InvariantCulture;
     private readonly Random _random = new(42);
     private string[] _invalidUnits = [];
-
+    
     [GlobalSetup]
     public void Setup()
     {
diff --git a/UnitsNet.Benchmark/Conversions/FromString/Value/BigIntegerSerializationBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/Value/BigIntegerSerializationBenchmarks.cs
new file mode 100644
index 0000000000..c46d222698
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/FromString/Value/BigIntegerSerializationBenchmarks.cs
@@ -0,0 +1,98 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Globalization;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Benchmark.Conversions.FromString.Value;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class BigIntegerSerializationBenchmarks
+{
+    private static readonly JsonSerializerOptions SpanOptions = CreateSpanOptions();
+
+    // private static BigInteger Value = BigInteger.Parse("123456789012345678901234567890", CultureInfo.InvariantCulture);
+    // [Params("\"42\"", "\"123456789012345678901234567890\"", "\"12345\\u0034\\u0035\"")]
+    [Params("42", "123456789012345678901234567890")]
+    public string Value { get; set; }
+
+    private static JsonSerializerOptions CreateSpanOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new BigIntegerConverter());
+        return options;
+    }
+
+    [Benchmark(Baseline = true)]
+    public BigInteger DeserializeFromSpan()
+    {
+        return JsonSerializer.Deserialize<BigInteger>(Value, SpanOptions);
+    }
+}
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net90)]
+[SimpleJob(RuntimeMoniker.Net80)]
+[SimpleJob(RuntimeMoniker.Net48)]
+public class StringInterpolationBenchmarks
+{
+    // private readonly BigInteger Numerator = BigInteger.Parse("123456789012345678901234567890");
+    // private readonly BigInteger Denominator = 5678901234567890;
+    private readonly BigInteger Denominator = 1;
+    private readonly BigInteger Numerator = 3;
+
+
+    [Benchmark(Baseline = true)]
+    public int StringInterpolation()
+    {
+        var stringValue = $"{Numerator}/{Denominator}";
+        return stringValue.Length;
+    }
+
+    [Benchmark]
+    public int CharacterAddition()
+    {
+        var stringValue = Numerator.ToString() + '/' + Denominator;
+        return stringValue.Length;
+    }
+
+    [Benchmark]
+    public int SpanConcatenation()
+    {
+#if NET
+        Span<char> charBuffer = stackalloc char[512];
+        int numeratorCharsWritten;
+        while (!Numerator.TryFormat(charBuffer, out numeratorCharsWritten, provider: NumberFormatInfo.InvariantInfo))
+        {
+            charBuffer = new char[charBuffer.Length * 2];
+        }
+
+        charBuffer[numeratorCharsWritten] = '.';
+
+        int denominatorCharsWritten;
+        while (!Denominator.TryFormat(charBuffer[(numeratorCharsWritten + 1)..], out denominatorCharsWritten, provider: NumberFormatInfo.InvariantInfo))
+        {
+            var extendedBuffer = new char[charBuffer.Length * 2];
+            charBuffer.CopyTo(extendedBuffer);
+            charBuffer = extendedBuffer;
+        }
+        
+        return numeratorCharsWritten + denominatorCharsWritten + 1;
+#else
+        var numeratorString = Numerator.ToString();
+        var denominatorString = Denominator.ToString();
+        Span<char> charBuffer = stackalloc char[numeratorString.Length + denominatorString.Length + 1];
+        numeratorString.AsSpan().CopyTo(charBuffer);
+        charBuffer[numeratorString.Length] = '.';
+        denominatorString.AsSpan().CopyTo(charBuffer.Slice(numeratorString.Length + 1));
+        return numeratorString.Length + denominatorString.Length + 1;
+#endif
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/FromString/Value/QuantityValueDecimalJsonConvertersBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/Value/QuantityValueDecimalJsonConvertersBenchmarks.cs
new file mode 100644
index 0000000000..c83a1c1792
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/FromString/Value/QuantityValueDecimalJsonConvertersBenchmarks.cs
@@ -0,0 +1,75 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Collections.Generic;
+using System.Text.Json;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Benchmark.Conversions.FromString.Value;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net90)]
+[SimpleJob(RuntimeMoniker.Net48)]
+public class QuantityValueDecimalJsonConvertersBenchmarks
+{
+    public static IEnumerable<QuantityValue> TestValues => [
+        42,
+        123456789,
+        12.345m,
+        9187654321.23m,
+        0.42m,
+        0.000012345m,
+        QuantityValue.FromTerms(3_450_000, 100_000),
+        QuantityValue.FromTerms(50, 600),
+    ];
+    
+    private static readonly JsonSerializerOptions QuantityValueDecimalNotationG29ConverterOptions= CreateQuantityValueDecimalNotationG29ConverterOptions();
+    private static JsonSerializerOptions CreateQuantityValueDecimalNotationG29ConverterOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter(29));
+        return options;
+    }
+
+    private static readonly JsonSerializerOptions QuantityValueMixedNotationConverterOptions= CreateQuantityValueMixedNotationConverterOptions();
+    private static JsonSerializerOptions CreateQuantityValueMixedNotationConverterOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueMixedNotationConverter());
+        return options;
+    }
+
+    private static readonly JsonSerializerOptions QuantityValueDecimalConverterOptions= CreateQuantityValueValueDecimalConverterOptions();
+    private static JsonSerializerOptions CreateQuantityValueValueDecimalConverterOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalConverter());
+        return options;
+    }
+    
+    [Benchmark(Baseline = false)]
+    [ArgumentsSource(nameof(TestValues))]
+    public QuantityValue RoundTripWithQuantityValueDecimalNotationG29Converter(QuantityValue value)
+    {
+        var json = JsonSerializer.Serialize(value, QuantityValueDecimalNotationG29ConverterOptions);
+        return JsonSerializer.Deserialize<QuantityValue>(json, QuantityValueDecimalNotationG29ConverterOptions);
+    }
+    
+    [Benchmark(Baseline = true)]
+    [ArgumentsSource(nameof(TestValues))]
+    public QuantityValue RoundTripWithQuantityValueDecimalConverter(QuantityValue value)
+    {
+        var json = JsonSerializer.Serialize(value, QuantityValueDecimalConverterOptions);
+        return JsonSerializer.Deserialize<QuantityValue>(json, QuantityValueDecimalConverterOptions);
+    }
+    
+    [Benchmark(Baseline = false)]
+    [ArgumentsSource(nameof(TestValues))]
+    public QuantityValue RoundTripWithQuantityValueMixedNotationConverter(QuantityValue value)
+    {
+        var json = JsonSerializer.Serialize(value, QuantityValueMixedNotationConverterOptions);
+        return JsonSerializer.Deserialize<QuantityValue>(json, QuantityValueMixedNotationConverterOptions);
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/FromString/Value/QuantityValueDoubleJsonConverterBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/Value/QuantityValueDoubleJsonConverterBenchmarks.cs
new file mode 100644
index 0000000000..0e13ddf757
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/FromString/Value/QuantityValueDoubleJsonConverterBenchmarks.cs
@@ -0,0 +1,72 @@
+using System.Collections.Generic;
+using System.Text.Json;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Benchmark.Conversions.FromString.Value;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net90)]
+[SimpleJob(RuntimeMoniker.Net48)]
+public class QuantityValueDoubleJsonConverterBenchmarks
+{
+    public static IEnumerable<QuantityValue> TestValues => [
+        42,
+        123456789,
+        12.345m,
+        9187654321.23m,
+        0.42m,
+        0.000012345m,
+        QuantityValue.FromTerms(3_450_000, 100_000),
+        QuantityValue.FromTerms(50, 600),
+    ];
+
+    private static readonly JsonSerializerOptions QuantityValueDecimalNotationG17ConverterOptions= CreateQuantityValueDecimalNotationG17ConverterOptions();
+    private static JsonSerializerOptions CreateQuantityValueDecimalNotationG17ConverterOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        return options;
+    }
+
+    private static readonly JsonSerializerOptions QuantityValueMixedNotationConverterOptions= CreateQuantityValueMixedNotationConverterOptions();
+    private static JsonSerializerOptions CreateQuantityValueMixedNotationConverterOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueMixedNotationConverter());
+        return options;
+    }
+
+    private static readonly JsonSerializerOptions QuantityValueDoubleConverterOptions= CreateQuantityValueValueDoubleConverterOptions();
+    private static JsonSerializerOptions CreateQuantityValueValueDoubleConverterOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDoubleConverter());
+        return options;
+    }
+    
+    [Benchmark(Baseline = false)]
+    [ArgumentsSource(nameof(TestValues))]
+    public QuantityValue RoundTripWithQuantityValueDecimalNotationG17Converter(QuantityValue value)
+    {
+        var json = JsonSerializer.Serialize(value, QuantityValueDecimalNotationG17ConverterOptions);
+        return JsonSerializer.Deserialize<QuantityValue>(json, QuantityValueDecimalNotationG17ConverterOptions);
+    }
+    
+    [Benchmark(Baseline = true)]
+    [ArgumentsSource(nameof(TestValues))]
+    public QuantityValue RoundTripWithQuantityValueDoubleConverter(QuantityValue value)
+    {
+        var json = JsonSerializer.Serialize(value, QuantityValueDoubleConverterOptions);
+        return JsonSerializer.Deserialize<QuantityValue>(json, QuantityValueDoubleConverterOptions);
+    }
+    
+    [Benchmark(Baseline = false)]
+    [ArgumentsSource(nameof(TestValues))]
+    public QuantityValue RoundTripWithQuantityValueMixedNotationConverter(QuantityValue value)
+    {
+        var json = JsonSerializer.Serialize(value, QuantityValueMixedNotationConverterOptions);
+        return JsonSerializer.Deserialize<QuantityValue>(json, QuantityValueMixedNotationConverterOptions);
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/FromString/Value/QuantityValueFractionalNotationConverterBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromString/Value/QuantityValueFractionalNotationConverterBenchmarks.cs
new file mode 100644
index 0000000000..50361c5d84
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/FromString/Value/QuantityValueFractionalNotationConverterBenchmarks.cs
@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.Text.Json;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Benchmark.Conversions.FromString.Value;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net90)]
+[SimpleJob(RuntimeMoniker.Net48)]
+public class QuantityValueFractionalNotationConverterBenchmarksPi
+{
+    public static IEnumerable<QuantityValue> TestValues => [
+        42,
+        123456789,
+        12.345m,
+        9187654321.23m,
+        0.42m,
+        0.000012345m,
+        QuantityValue.FromTerms(3_450_000, 100_000),
+        QuantityValue.FromTerms(50, 600),
+        QuantityValue.PI,
+    ];
+
+    private static readonly JsonSerializerOptions QuantityValueFractionalNotationConverterOptions = CreateQuantityValueFractionalNotationConverterOptions();
+    private static JsonSerializerOptions CreateQuantityValueFractionalNotationConverterOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Default);
+        return options;
+    }
+
+    private static readonly JsonSerializerOptions QuantityValueFractionalNotationReducingConverterOptions = CreateQuantityValueFractionalNotationReducingConverterOptions();
+    private static JsonSerializerOptions CreateQuantityValueFractionalNotationReducingConverterOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Reducing);
+        return options;
+    }
+
+    private static readonly JsonSerializerOptions QuantityValueMixedNotationConverterOptions= CreateQuantityValueMixedNotationConverterOptions();
+    private static JsonSerializerOptions CreateQuantityValueMixedNotationConverterOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(QuantityValueMixedNotationConverter.Default);
+        return options;
+    }
+    
+    // // private static BigInteger Value = BigInteger.Parse("123456789012345678901234567890", CultureInfo.InvariantCulture);
+    // // [Params("\"42\"", "\"123456789012345678901234567890\"", "\"12345\\u0034\\u0035\"")]
+    // [Params("""{"N":42,"D":10}""", """{"N":12345678901234567890123456789,"D":10000000}""")]
+    // public string Value { get; set; }
+    //
+    // private static readonly JsonSerializerOptions ConverterOptions = CreateConverterOptions();
+    // private static JsonSerializerOptions CreateConverterOptions()
+    // {
+    //     var options = new JsonSerializerOptions();
+    //     options.Converters.Add(new QuantityValueFractionalNotationConverter());
+    //     return options;
+    // }
+    //
+    // [Benchmark(Baseline = true)]
+    // public QuantityValue DeserializeWithConverter()
+    // {
+    //     return System.Text.Json.JsonSerializer.Deserialize<QuantityValue>(Value, ConverterOptions);
+    // }
+    
+    [Benchmark(Baseline = true)]
+    [ArgumentsSource(nameof(TestValues))]
+    public QuantityValue RoundTripWithQuantityValueFractionalNotationConverter(QuantityValue value)
+    {
+        var json = JsonSerializer.Serialize(value, QuantityValueFractionalNotationConverterOptions);
+        return JsonSerializer.Deserialize<QuantityValue>(json, QuantityValueFractionalNotationConverterOptions);
+    }
+    
+    [Benchmark(Baseline = false)]
+    [ArgumentsSource(nameof(TestValues))]
+    public QuantityValue RoundTripWithQuantityValueFractionalNotationReducingConverter(QuantityValue value)
+    {
+        var json = JsonSerializer.Serialize(value, QuantityValueFractionalNotationReducingConverterOptions);
+        return JsonSerializer.Deserialize<QuantityValue>(json, QuantityValueFractionalNotationReducingConverterOptions);
+    }
+    
+    [Benchmark(Baseline = false)]
+    [ArgumentsSource(nameof(TestValues))]
+    public QuantityValue RoundTripWithQuantityValueMixedNotationConverter(QuantityValue value)
+    {
+        var json = JsonSerializer.Serialize(value, QuantityValueMixedNotationConverterOptions);
+        return JsonSerializer.Deserialize<QuantityValue>(json, QuantityValueMixedNotationConverterOptions);
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/FromUnit/QuantityFromUnitBenchmarks.cs b/UnitsNet.Benchmark/Conversions/FromUnit/QuantityFromUnitBenchmarks.cs
index a7226e9f0a..86fba0663d 100644
--- a/UnitsNet.Benchmark/Conversions/FromUnit/QuantityFromUnitBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/FromUnit/QuantityFromUnitBenchmarks.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
@@ -11,13 +11,30 @@ namespace UnitsNet.Benchmark.Conversions.FromUnit;
 public class QuantityFromUnitBenchmarks
 {
     private static readonly Enum[] BaseUnits = Quantity.Infos.Select(x => x.BaseUnitInfo.Value).ToArray();
+    
+    private static readonly UnitKey[] BaseUnitKeys = Quantity.Infos.Select(x => x.BaseUnitInfo.UnitKey).ToArray();
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        Quantity.From(1, Mass.BaseUnit);
+    }
 
     [Benchmark(Baseline = true)]
     public void QuantityFromUnit()
     {
         foreach (Enum baseUnit in BaseUnits)
         {
-            IQuantity quantity = Quantity.From(1, baseUnit);
+            IQuantity quantity = Quantity.From(QuantityValue.One, baseUnit);
+        }
+    }
+
+    [Benchmark]
+    public void QuantityFromUnitKey()
+    {
+        foreach (UnitKey baseUnit in BaseUnitKeys)
+        {
+            IQuantity quantity = Quantity.From(QuantityValue.One, baseUnit);
         }
     }
 
@@ -26,7 +43,7 @@ public void QuantityTryFromUnit()
     {
         foreach (Enum baseUnit in BaseUnits)
         {
-            var success = Quantity.TryFrom(1, baseUnit, out _);
+            var success = Quantity.TryFrom(QuantityValue.One, baseUnit, out _);
         }
     }
 }
diff --git a/UnitsNet.Benchmark/Conversions/Relations/ConvertValueToAnotherUnitBenchmarks.cs b/UnitsNet.Benchmark/Conversions/Relations/ConvertValueToAnotherUnitBenchmarks.cs
new file mode 100644
index 0000000000..d35a08d594
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/Relations/ConvertValueToAnotherUnitBenchmarks.cs
@@ -0,0 +1,183 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Conversions.Relations;
+
+[MemoryDiagnoser]
+[ShortRunJob(RuntimeMoniker.Net48)]
+[ShortRunJob(RuntimeMoniker.Net80)]
+public class ConvertValueToAnotherQuantityUnitBenchmarks
+{
+    private static readonly QuantityValue Value = 123.456;
+
+    // these are the currently supported options
+    // (typeof(Area), typeof(ReciprocalArea)),
+    // (typeof(Density), typeof(SpecificVolume)),
+    // (typeof(ElectricConductivity), typeof(ElectricResistivity)),
+    // (typeof(Length), typeof(ReciprocalLength))
+    [Params(typeof(Area), typeof(Density), typeof(Length))]
+    public Type TypeToTest { get; set; }
+    
+    private UnitConverter _quantityConverter;
+    
+    #region Benchmarks
+
+    [Benchmark(Baseline = true)]
+    public QuantityValue ConvertWith_FullyCachedFrozenDictionary()
+    {
+        return ConvertWithConverter();
+    }
+
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWith_FullyCachedDynamicDictionary()
+    {
+        return ConvertWithConverter();
+    }
+
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWith_SemiCachedFrozenDictionary()
+    {
+        return ConvertWithConverter();
+    }
+    
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWith_TargetCachedFrozenDictionary()
+    {
+        return ConvertWithConverter();
+    }
+    
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWith_EmptyFrozenDictionary()
+    {
+        return ConvertWithConverter();
+    }
+    
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWithoutCaching()
+    {
+        return ConvertWithConverter();
+    }
+    
+    private QuantityValue ConvertWithConverter()
+    {
+        // return ConvertWithBaseUnits();
+        return ConvertWithAllUnits();
+        // return ConvertAllOnce();
+    }
+    
+    private QuantityValue ConvertWithAllUnits()
+    {
+        QuantityValue result = default;
+        if (TypeToTest == typeof(Density))
+        {
+            foreach (DensityUnit fromUnit in Density.Units)
+            {
+                foreach (SpecificVolumeUnit toUnit in SpecificVolume.Units)
+                {
+                    result = _quantityConverter.ConvertValue(Value, fromUnit, toUnit);
+                }
+            }
+            
+            foreach (SpecificVolumeUnit fromUnit in SpecificVolume.Units)
+            {
+                foreach (DensityUnit toUnit in Density.Units)
+                {
+                    result = _quantityConverter.ConvertValue(Value, fromUnit, toUnit);
+                }
+            }
+        }
+        else if (TypeToTest == typeof(Area))
+        {
+            foreach (AreaUnit fromUnit in Area.Units)
+            {
+                foreach (ReciprocalAreaUnit toUnit in ReciprocalArea.Units)
+                {
+                    result = _quantityConverter.ConvertValue(Value, fromUnit, toUnit);
+                }
+            }
+            
+            foreach (ReciprocalAreaUnit fromUnit in ReciprocalArea.Units)
+            {
+                foreach (AreaUnit toUnit in Area.Units)
+                {
+                    result = _quantityConverter.ConvertValue(Value, fromUnit, toUnit);
+                }
+            }
+        }
+        else if (TypeToTest == typeof(Length))
+        {
+            foreach (LengthUnit fromUnit in Length.Units)
+            {
+                foreach (ReciprocalLengthUnit toUnit in ReciprocalLength.Units)
+                {
+                    result = _quantityConverter.ConvertValue(Value, fromUnit, toUnit);
+                }
+            }
+            
+            foreach (ReciprocalLengthUnit fromUnit in ReciprocalLength.Units)
+            {
+                foreach (LengthUnit toUnit in Length.Units)
+                {
+                    result = _quantityConverter.ConvertValue(Value, fromUnit, toUnit);
+                }
+            }
+        }
+
+        return result;
+    }
+    
+    
+    #endregion
+
+    #region Setup
+
+    [GlobalSetup(Target = nameof(ConvertWith_FullyCachedFrozenDictionary))]
+    public void PrepareTo_ConvertWith_FullyCachedFrozenDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.All, true));
+    }
+    
+    [GlobalSetup(Target = nameof(ConvertWith_FullyCachedDynamicDictionary))]
+    public void PrepareTo_ConvertWith_FullyCachedDynamicDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(false, ConversionCachingMode.All, true));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWith_SemiCachedFrozenDictionary))]
+    public void PrepareTo_ConvertWith_SemiCachedFrozenDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.BaseOnly, true));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWith_TargetCachedFrozenDictionary))]
+    public void PrepareTo_ConvertWith_TargetCachedFrozenDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.None, true)
+            .WithCustomCachingOptions<Area>(new ConversionCacheOptions(ConversionCachingMode.All, true))
+            .WithCustomCachingOptions<ReciprocalArea>(new ConversionCacheOptions(ConversionCachingMode.All, true))
+            .WithCustomCachingOptions<Density>(new ConversionCacheOptions(ConversionCachingMode.All, true))
+            .WithCustomCachingOptions<SpecificVolume>(new ConversionCacheOptions(ConversionCachingMode.All, true))
+            .WithCustomCachingOptions<Length>(new ConversionCacheOptions(ConversionCachingMode.All, true))
+            .WithCustomCachingOptions<ReciprocalLength>(new ConversionCacheOptions(ConversionCachingMode.All, true)));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWith_EmptyFrozenDictionary))]
+    public void PrepareTo_ConvertWith_EmptyFrozenDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.None, true));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWithoutCaching))]
+    public void PrepareTo_ConvertWithoutCaching()
+    {
+        _quantityConverter = new UnitConverter(UnitParser.Default);
+    }
+
+    #endregion
+
+}
diff --git a/UnitsNet.Benchmark/Conversions/Relations/InverseDensityConversionBenchmarks.cs b/UnitsNet.Benchmark/Conversions/Relations/InverseDensityConversionBenchmarks.cs
new file mode 100644
index 0000000000..35b093d752
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/Relations/InverseDensityConversionBenchmarks.cs
@@ -0,0 +1,37 @@
+using BenchmarkDotNet.Attributes;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Conversions.Relations;
+
+[MemoryDiagnoser]
+[ShortRunJob]
+public class InverseDensityConversionBenchmarks
+{
+    private static readonly QuantityValue Value = 123.456;
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [ParamsAllValues]
+    public DensityUnit Unit { get; set; }
+
+    private Density TestQuantity
+    {
+        get => new(Value, Unit);
+    }
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+    }
+
+    [Benchmark(Baseline = true)]
+    public SpecificVolume Inverse()
+    {
+        return TestQuantity.Inverse();
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/Relations/InverseElectricConductivityBenchmarks.cs b/UnitsNet.Benchmark/Conversions/Relations/InverseElectricConductivityBenchmarks.cs
index 58f4d60c46..e1a4450797 100644
--- a/UnitsNet.Benchmark/Conversions/Relations/InverseElectricConductivityBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/Relations/InverseElectricConductivityBenchmarks.cs
@@ -1,20 +1,34 @@
-using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Attributes;
 using UnitsNet.Units;
 
 namespace UnitsNet.Benchmark.Conversions.Relations;
 
 [MemoryDiagnoser]
 [ShortRunJob]
-// [DryJob]
 public class InverseElectricConductivityBenchmarks
 {
-    private static readonly double Value = 123.456;
-    
+    private static readonly QuantityValue Value = 123.456;
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
     [ParamsAllValues]
     public ElectricConductivityUnit Unit { get; set; }
-    private ElectricConductivity TestQuantity => new(Value, Unit);
-    
-    
+
+    private ElectricConductivity TestQuantity
+    {
+        get => new(Value, Unit);
+    }
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+    }
+
     [Benchmark(Baseline = true)]
     public ElectricResistivity Inverse()
     {
diff --git a/UnitsNet.Benchmark/Conversions/Relations/InverseElectricResistivityBenchmarks.cs b/UnitsNet.Benchmark/Conversions/Relations/InverseElectricResistivityBenchmarks.cs
index 2d238a8ae7..f919368bce 100644
--- a/UnitsNet.Benchmark/Conversions/Relations/InverseElectricResistivityBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/Relations/InverseElectricResistivityBenchmarks.cs
@@ -1,19 +1,36 @@
-using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Attributes;
 using UnitsNet.Units;
 
 namespace UnitsNet.Benchmark.Conversions.Relations;
 
+// [ShortRunJob(RuntimeMoniker.Net48)]
+// [ShortRunJob(RuntimeMoniker.Net90)]
 [MemoryDiagnoser]
 [ShortRunJob]
 public class InverseElectricResistivityBenchmarks
 {
-    private static readonly double Value = 123.456;
-    
+    private static readonly QuantityValue Value = 123.456;
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
     [ParamsAllValues]
     public ElectricResistivityUnit Unit { get; set; }
-    private ElectricResistivity TestQuantity => new(Value, Unit);
-    
-    
+
+    private ElectricResistivity TestQuantity
+    {
+        get => new(Value, Unit);
+    }
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+    }
+
     [Benchmark(Baseline = true)]
     public ElectricConductivity Inverse()
     {
diff --git a/UnitsNet.Benchmark/Conversions/Relations/InverseOperationBenchmarks.cs b/UnitsNet.Benchmark/Conversions/Relations/InverseOperationBenchmarks.cs
index 7d19981c05..e194ab22c1 100644
--- a/UnitsNet.Benchmark/Conversions/Relations/InverseOperationBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/Relations/InverseOperationBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -11,24 +11,79 @@ namespace UnitsNet.Benchmark.Conversions.Relations;
 [MemoryDiagnoser]
 [ShortRunJob(RuntimeMoniker.Net48)]
 [ShortRunJob(RuntimeMoniker.Net80)]
+// [ShortRunJob]
 public class InverseOperationBenchmarks
 {
-    private static readonly double Value = 123.456;
+    private static readonly QuantityValue Value = 123.456;
 
+    
     // new (typeof(Area), typeof(ReciprocalArea)),
     // new (typeof(Density), typeof(SpecificVolume)),
     // new (typeof(ElectricConductivity), typeof(ElectricResistivity)),
     // new (typeof(Length), typeof(ReciprocalLength)),
     
-    [Params(typeof(Area), typeof(Length))]
+    [Params(typeof(Area), typeof(Density), typeof(Length))]
     public Type TypeToTest { get; set; }
     
+    private UnitConverter _quantityConverter;
     
+    #region Benchmarks
+
     [Benchmark(Baseline = true)]
-    public IQuantity ConvertWithoutInverse()
+    public IQuantity ConvertWith_FullyCachedFrozenDictionary()
+    {
+        return ConvertWithConverter();
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity ConvertWith_FullyCachedDynamicDictionary()
+    {
+        return ConvertWithConverter();
+    }
+
+    [Benchmark(Baseline = false)]
+    public IQuantity ConvertWith_SemiCachedFrozenDictionary()
+    {
+        return ConvertWithConverter();
+    }
+    
+    [Benchmark(Baseline = false)]
+    public IQuantity ConvertWith_TargetCachedFrozenDictionary()
+    {
+        return ConvertWithConverter();
+    }
+    
+    [Benchmark(Baseline = false)]
+    public IQuantity ConvertWith_EmptyFrozenDictionary()
+    {
+        return ConvertWithConverter();
+    }
+    
+    [Benchmark(Baseline = false)]
+    public IQuantity ConvertWithoutCaching()
+    {
+        return ConvertWithConverter();
+    }
+    
+    [Benchmark(Baseline = false)]
+    public IQuantity ConvertWithInverse()
     {
         IQuantity result = default;
-        if (TypeToTest == typeof(Area))
+        if (TypeToTest == typeof(Density))
+        {
+            foreach (DensityUnit fromUnit in Density.Units)
+            {
+                var quantity = Density.From(Value, fromUnit);
+                result = quantity.Inverse();
+            }
+            
+            foreach (SpecificVolumeUnit fromUnit in SpecificVolume.Units)
+            {
+                var quantity = SpecificVolume.From(Value, fromUnit);
+                result = quantity.Inverse();
+            }
+        }
+        else if (TypeToTest == typeof(Area))
         {
             foreach (AreaUnit fromUnit in Area.Units)
             {
@@ -59,5 +114,116 @@ public IQuantity ConvertWithoutInverse()
 
         return result;
     }
+    
+    private IQuantity ConvertWithConverter()
+    {
+        // return ConvertWithBaseUnits();
+        return ConvertWithAllUnits();
+        // return ConvertAllOnce();
+    }
+    
+    private IQuantity ConvertWithAllUnits()
+    {
+        IQuantity result = default;
+        if (TypeToTest == typeof(Density))
+        {
+            foreach (DensityUnit fromUnit in Density.Units)
+            {
+                var quantity = Density.From(Value, fromUnit);
+                result = _quantityConverter.ConvertTo(quantity.Value, quantity.Unit, SpecificVolume.Info);
+            }
+            
+            foreach (SpecificVolumeUnit fromUnit in SpecificVolume.Units)
+            {
+                var quantity = SpecificVolume.From(Value, fromUnit);
+                result = _quantityConverter.ConvertTo(quantity.Value, quantity.Unit, Density.Info);
+            }
+        }
+        else if (TypeToTest == typeof(Area))
+        {
+            foreach (AreaUnit fromUnit in Area.Units)
+            {
+                var quantity = Area.From(Value, fromUnit);
+                result = _quantityConverter.ConvertTo(quantity.Value, quantity.Unit, ReciprocalArea.Info);
+            }
+            
+            foreach (ReciprocalAreaUnit fromUnit in ReciprocalArea.Units)
+            {
+                var quantity = ReciprocalArea.From(Value, fromUnit);
+                result = _quantityConverter.ConvertTo(quantity.Value, quantity.Unit, Area.Info);
+            }
+        }
+        else if (TypeToTest == typeof(Length))
+        {
+            foreach (LengthUnit fromUnit in Length.Units)
+            {
+                var quantity = Length.From(Value, fromUnit);
+                result = _quantityConverter.ConvertTo(quantity.Value, quantity.Unit, ReciprocalLength.Info);
+            }
+            
+            foreach (ReciprocalLengthUnit fromUnit in ReciprocalLength.Units)
+            {
+                var quantity = ReciprocalLength.From(Value, fromUnit);
+                result = _quantityConverter.ConvertTo(quantity.Value, quantity.Unit, Length.Info);
+            }
+        }
+
+        return result;
+    }
+    
+    
+    #endregion
+
+    #region Setup
+
+    [GlobalSetup(Target = nameof(ConvertWith_FullyCachedFrozenDictionary))]
+    public void PrepareTo_ConvertWith_FullyCachedFrozenDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.All, true));
+    }
+    
+    [GlobalSetup(Target = nameof(ConvertWith_FullyCachedDynamicDictionary))]
+    public void PrepareTo_ConvertWith_FullyCachedDynamicDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(false, ConversionCachingMode.All, true));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWith_SemiCachedFrozenDictionary))]
+    public void PrepareTo_ConvertWith_SemiCachedFrozenDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.BaseOnly, true));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWith_TargetCachedFrozenDictionary))]
+    public void PrepareTo_ConvertWith_TargetCachedFrozenDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.None, true)
+            .WithCustomCachingOptions<Area>(new ConversionCacheOptions(ConversionCachingMode.All, true))
+            .WithCustomCachingOptions<ReciprocalArea>(new ConversionCacheOptions(ConversionCachingMode.All, true))
+            .WithCustomCachingOptions<Density>(new ConversionCacheOptions(ConversionCachingMode.All, true))
+            .WithCustomCachingOptions<SpecificVolume>(new ConversionCacheOptions(ConversionCachingMode.All, true))
+            .WithCustomCachingOptions<Length>(new ConversionCacheOptions(ConversionCachingMode.All, true))
+            .WithCustomCachingOptions<ReciprocalLength>(new ConversionCacheOptions(ConversionCachingMode.All, true)));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWith_EmptyFrozenDictionary))]
+    public void PrepareTo_ConvertWith_EmptyFrozenDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.None, true));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWithoutCaching))]
+    public void PrepareTo_ConvertWithoutCaching()
+    {
+        _quantityConverter = new UnitConverter(UnitParser.Default);
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWithInverse))]
+    public void PrepareTo_ConvertWithInverse()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(true, ConversionCachingMode.All)));
+    }
+
+    #endregion
 
 }
diff --git a/UnitsNet.Benchmark/Conversions/Relations/InverseSpecificVolumeConversionBenchmarks.cs b/UnitsNet.Benchmark/Conversions/Relations/InverseSpecificVolumeConversionBenchmarks.cs
new file mode 100644
index 0000000000..3bc30ae092
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/Relations/InverseSpecificVolumeConversionBenchmarks.cs
@@ -0,0 +1,37 @@
+using BenchmarkDotNet.Attributes;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Conversions.Relations;
+
+[MemoryDiagnoser]
+[ShortRunJob]
+public class InverseSpecificVolumeConversionBenchmarks
+{
+    private static readonly QuantityValue Value = 123.456;
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [ParamsAllValues]
+    public SpecificVolumeUnit Unit { get; set; }
+
+    private SpecificVolume TestQuantity
+    {
+        get => new(Value, Unit);
+    }
+    
+    [GlobalSetup]
+    public void Setup()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+    }
+
+    [Benchmark(Baseline = true)]
+    public Density Inverse()
+    {
+        return TestQuantity.Inverse();
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/ToString/ToStringWithDefaultPrecisionBenchmarks.cs b/UnitsNet.Benchmark/Conversions/ToString/ToStringWithDefaultPrecisionBenchmarks.cs
index c26521c225..f5033ebe1f 100644
--- a/UnitsNet.Benchmark/Conversions/ToString/ToStringWithDefaultPrecisionBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/ToString/ToStringWithDefaultPrecisionBenchmarks.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Globalization;
 using System.Linq;
 using BenchmarkDotNet.Attributes;
@@ -10,9 +10,10 @@ namespace UnitsNet.Benchmark.Conversions.ToString;
 [MemoryDiagnoser]
 [SimpleJob(RuntimeMoniker.Net48)]
 [SimpleJob(RuntimeMoniker.Net90)]
+[SimpleJob(RuntimeMoniker.Net10_0)]
 public class ToStringWithDefaultPrecisionBenchmarks
 {
-    private static readonly double Value = 123.456;
+    private static readonly QuantityValue Value = 123.456m;
     private readonly Random _random = new(42);
 
     private Mass[] _masses = [];
diff --git a/UnitsNet.Benchmark/Conversions/ToUnit/MassQuantityConversionBenchmarks.cs b/UnitsNet.Benchmark/Conversions/ToUnit/MassQuantityConversionBenchmarks.cs
deleted file mode 100644
index 9dedce791a..0000000000
--- a/UnitsNet.Benchmark/Conversions/ToUnit/MassQuantityConversionBenchmarks.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using System;
-using System.Collections.Generic;
-using BenchmarkDotNet.Attributes;
-using UnitsNet.Units;
-
-namespace UnitsNet.Benchmark.Conversions.ToUnit;
-
-[MemoryDiagnoser]
-public class MassQuantityConversionBenchmarks
-{
-    private static readonly Mass FromMass = new(12345.67, MassUnit.Milligram);
-    private static readonly Dictionary<(MassUnit, MassUnit), Func<Mass, Mass>> ConversionFunctions = GetConversionsFunctions();
-
-    private static Dictionary<(MassUnit, MassUnit), Func<Mass, Mass>> GetConversionsFunctions()
-    {
-        var functions = new Dictionary<(MassUnit, MassUnit), Func<Mass, Mass>>();
-        foreach (MassUnit unit in Mass.Units)
-        {
-            foreach (MassUnit otherUnit in Mass.Units)
-            {
-                functions.Add((unit, otherUnit), mass => mass.ToUnit(otherUnit));
-            }
-        }
-
-        // functions[(MassUnit.Milligram, MassUnit.Gram)] = mass => new Mass(mass.Value * new QuantityValue(1, 1000), MassUnit.Gram);
-        functions[(MassUnit.Milligram, MassUnit.Gram)] = mass => new Mass(mass.Value / 1000, MassUnit.Gram);
-
-        return functions;
-    }
-
-    [Benchmark(Baseline = true)]
-    public Mass ConvertFromMilligramToGram() => FromMass.ToUnit(MassUnit.Gram);
-
-    [Benchmark]
-    public Mass ConvertFromMilligramToGramWithDictionary() => ConversionFunctions[(MassUnit.Milligram, MassUnit.Gram)](FromMass);
-}
diff --git a/UnitsNet.Benchmark/Conversions/ToUnit/QuantityConversionBenchmarks.cs b/UnitsNet.Benchmark/Conversions/ToUnit/QuantityConversionBenchmarks.cs
deleted file mode 100644
index 926ca0f2d3..0000000000
--- a/UnitsNet.Benchmark/Conversions/ToUnit/QuantityConversionBenchmarks.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Jobs;
-
-namespace UnitsNet.Benchmark.Conversions.ToUnit;
-
-[MemoryDiagnoser]
-[ShortRunJob(RuntimeMoniker.Net48)]
-[ShortRunJob(RuntimeMoniker.Net80)]
-public class QuantityConversionBenchmarks
-{
-    private static readonly IReadOnlyCollection<IQuantity> Quantities =
-        Quantity.Infos.SelectMany(x => x.UnitInfos).Select(u => Quantity.From(123.456, u.Value)).ToList();
-
-    [Benchmark(Baseline = true)]
-    public double ConvertOnce()
-    {
-        double result = 0;
-        foreach (IQuantity quantity in Quantities)
-        {
-            foreach (UnitInfo unitInfo in quantity.QuantityInfo.UnitInfos)
-            {
-                result = quantity.As(unitInfo.Value);
-            }
-        }
-
-        return result;
-    }
-}
diff --git a/UnitsNet.Benchmark/Conversions/ToUnit/QuantityToUnitBenchmarks.cs b/UnitsNet.Benchmark/Conversions/ToUnit/QuantityToUnitBenchmarks.cs
index 6ced1efc3e..25316de942 100644
--- a/UnitsNet.Benchmark/Conversions/ToUnit/QuantityToUnitBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/ToUnit/QuantityToUnitBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -14,7 +14,7 @@ namespace UnitsNet.Benchmark.Conversions.ToUnit;
 [SimpleJob(RuntimeMoniker.Net80)]
 public class QuantityToUnitBenchmarks
 {
-    private static readonly double Value = 123.456;
+    private static readonly QuantityValue Value = 123.456;
     private readonly Random _random = new(42);
 
     private (Mass Quantity, MassUnit Unit)[] _massConversions = [];
@@ -23,16 +23,30 @@ public class QuantityToUnitBenchmarks
     [Params(1000)]
     public int NbConversions { get; set; }
 
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
+    [GlobalSetup]
+    public void ConfigureCaching()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+    }
+
     [GlobalSetup(Target = nameof(MassToUnit))]
     public void PrepareMassConversionsToTest()
     {
-        _massConversions = _random.GetRandomConversions<Mass, MassUnit>(Value, Mass.Units.ToArray(), NbConversions);
+        ConfigureCaching();
+        _massConversions = _random.GetRandomConversions<Mass, MassUnit>(Value, Mass.Units, NbConversions);
     }
 
     [GlobalSetup(Target = nameof(VolumeFlowToUnit))]
     public void PrepareVolumeFlowConversionsToTest()
     {
-        _volumeFlowConversions = _random.GetRandomConversions<VolumeFlow, VolumeFlowUnit>(Value, VolumeFlow.Units.ToArray(), NbConversions);
+        ConfigureCaching();
+        _volumeFlowConversions = _random.GetRandomConversions<VolumeFlow, VolumeFlowUnit>(Value, VolumeFlow.Units, NbConversions);
     }
 
     [Benchmark(Baseline = true)]
diff --git a/UnitsNet.Benchmark/Conversions/ToValue/ConvertValueBenchmarks.cs b/UnitsNet.Benchmark/Conversions/ToValue/ConvertValueBenchmarks.cs
index ff02b0a189..09bc41751c 100644
--- a/UnitsNet.Benchmark/Conversions/ToValue/ConvertValueBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/ToValue/ConvertValueBenchmarks.cs
@@ -1,57 +1,86 @@
-using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 
 namespace UnitsNet.Benchmark.Conversions.ToValue;
 
 [MemoryDiagnoser]
-[SimpleJob(RuntimeMoniker.Net48)]
-[SimpleJob(RuntimeMoniker.Net80)]
+[ShortRunJob(RuntimeMoniker.Net48)]
+[ShortRunJob(RuntimeMoniker.Net80)]
 public class ConvertValueBenchmarks
 {
-    private static readonly double Value = 123.456;
-    
+    private static readonly QuantityValue Value = 123.456;
     
+    #region Benchmarks
+
     [Benchmark(Baseline = true)]
-    public double ConvertWithConverter()
+    public QuantityValue ConvertWith_FullyCachedFrozenDictionary()
     {
-        double result = default;
-        foreach (QuantityInfo quantityInfo in Quantity.Infos)
-        {
-            foreach (UnitInfo fromUnitInfo in quantityInfo.UnitInfos)
-            {
-                foreach (UnitInfo toUnitInfo in quantityInfo.UnitInfos)
-                {
-                    result = UnitConverter.Convert(Value, fromUnitInfo.Value, toUnitInfo.Value);
-                }
-            }
-        }
+        return ConvertAll();
+    }
 
-        return result;
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWith_FullyCachedDynamicDictionary()
+    {
+        return ConvertAll();
     }
-    
+
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWith_SemiCachedFrozenDictionary()
+    {
+        return ConvertAll();
+    }
+
     [Benchmark(Baseline = false)]
-    public double ConvertFromQuantity()
+    public QuantityValue ConvertWithoutCaching()
     {
-        double result = default;
+        return ConvertAll();
+    }
+    
+    private QuantityValue ConvertAll()
+    {
+        UnitConverter converter = UnitConverter.Default;
+        QuantityValue result = default;
         foreach (QuantityInfo quantityInfo in Quantity.Infos)
         {
             foreach (UnitInfo fromUnitInfo in quantityInfo.UnitInfos)
             {
                 foreach (UnitInfo toUnitInfo in quantityInfo.UnitInfos)
                 {
-                    result = Quantity.From(Value, fromUnitInfo.Value).As(toUnitInfo.Value);
+                    result = converter.ConvertValue(Value, fromUnitInfo.UnitKey, toUnitInfo.UnitKey);
                 }
             }
         }
 
         return result;
     }
-    
 
-    [GlobalSetup]
+    #endregion
+
+    #region Setup
+
+    [GlobalSetup(Target = nameof(ConvertWith_FullyCachedFrozenDictionary))]
     public void PrepareTo_ConvertWith_FullyCachedFrozenDictionary()
     {
-        var nbQuantities = Quantity.Infos.Count;
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(true, ConversionCachingMode.All, true)));
     }
     
+    [GlobalSetup(Target = nameof(ConvertWith_FullyCachedDynamicDictionary))]
+    public void PrepareTo_ConvertWith_FullyCachedDynamicDictionary()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(false, ConversionCachingMode.All, true)));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWith_SemiCachedFrozenDictionary))]
+    public void PrepareTo_ConvertWith_SemiCachedFrozenDictionary()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(true, ConversionCachingMode.BaseOnly, true)));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWithoutCaching))]
+    public void PrepareTo_ConvertWithoutCaching()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(true, ConversionCachingMode.None)));
+    }
+
+    #endregion
 }
diff --git a/UnitsNet.Benchmark/Conversions/ToValue/ConvertValueToBaseBenchmarks.cs b/UnitsNet.Benchmark/Conversions/ToValue/ConvertValueToBaseBenchmarks.cs
new file mode 100644
index 0000000000..51ebd1437a
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/ToValue/ConvertValueToBaseBenchmarks.cs
@@ -0,0 +1,89 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+
+namespace UnitsNet.Benchmark.Conversions.ToValue;
+
+[MemoryDiagnoser]
+[ShortRunJob(RuntimeMoniker.Net48)]
+[ShortRunJob(RuntimeMoniker.Net80)]
+public class ConvertValueToBaseBenchmarks
+{
+    private static readonly QuantityValue Value = 123.456;
+    
+    #region Benchmarks
+
+    [Benchmark(Baseline = true)]
+    public QuantityValue ConvertWith_FullyCachedFrozenDictionary()
+    {
+        return ConvertWithBase();
+    }
+
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWith_FullyCachedDynamicDictionary()
+    {
+        return ConvertWithBase();
+    }
+
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWith_SemiCachedFrozenDictionary()
+    {
+        return ConvertWithBase();
+    }
+
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWithoutCaching()
+    {
+        return ConvertWithBase();
+    }
+
+    private QuantityValue ConvertWithBase()
+    {
+        UnitConverter converter = UnitConverter.Default;
+        QuantityValue result = default;
+        foreach (QuantityInfo quantityInfo in Quantity.Infos)
+        {
+            UnitKey baseUnitKey = quantityInfo.BaseUnitInfo.UnitKey;
+            foreach (UnitInfo unitInfo in quantityInfo.UnitInfos)
+            {
+                UnitKey unitKey = unitInfo.UnitKey;
+                result = converter.ConvertValue(Value, unitKey, baseUnitKey);
+                result = converter.ConvertValue(Value, baseUnitKey, unitKey);
+            }
+        }
+
+        return result;
+    }
+    
+    #endregion
+
+    #region Setup
+
+    [GlobalSetup(Target = nameof(ConvertWith_FullyCachedFrozenDictionary))]
+    public void PrepareTo_ConvertWith_FullyCachedFrozenDictionary()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(true, ConversionCachingMode.All, true)));
+    }
+    
+    [GlobalSetup(Target = nameof(ConvertWith_FullyCachedDynamicDictionary))]
+    public void PrepareTo_ConvertWith_FullyCachedDynamicDictionary()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(false, ConversionCachingMode.All, true)));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWith_SemiCachedFrozenDictionary))]
+    public void PrepareTo_ConvertWith_SemiCachedFrozenDictionary()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(true, ConversionCachingMode.BaseOnly, true)));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWithoutCaching))]
+    public void PrepareTo_ConvertWithoutCaching()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(true, ConversionCachingMode.None)));
+    }
+
+    #endregion
+}
diff --git a/UnitsNet.Benchmark/Conversions/ToValue/QuantityAsBenchmarks.cs b/UnitsNet.Benchmark/Conversions/ToValue/QuantityAsBenchmarks.cs
index 0dc28a0694..1bc2a644c8 100644
--- a/UnitsNet.Benchmark/Conversions/ToValue/QuantityAsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Conversions/ToValue/QuantityAsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -14,11 +14,8 @@ namespace UnitsNet.Benchmark.Conversions.ToValue;
 [SimpleJob(RuntimeMoniker.Net90)]
 public class QuantityAsBenchmarks
 {
-    private readonly Random _random = new Random(42);
-    private static readonly double Value = 123.456;
-
-    [Params(1000)]
-    public int NbConversions { get; set; }
+    private static readonly QuantityValue Value = 123.456;
+    private readonly Random _random = new(42);
 
     private (Mass Quantity, MassUnit Unit)[] _massConversions = [];
     private (Volume Quantity, VolumeUnit Unit)[] _volumeConversions = [];
@@ -26,79 +23,100 @@ public class QuantityAsBenchmarks
     private (Pressure Quantity, PressureUnit Unit)[] _pressureConversions = [];
     private (VolumeFlow Quantity, VolumeFlowUnit Unit)[] _volumeFlowConversions = [];
 
+    [Params(1000)]
+    public int NbConversions { get; set; }
+
+    // [Params(false)]
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
+    [GlobalSetup]
+    public void ConfigureCaching()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+    }
 
     [GlobalSetup(Target = nameof(MassAs))]
     public void PrepareMassConversionsToTest()
     {
-        _massConversions = _random.GetRandomConversions<Mass, MassUnit>(Value, Mass.Units.ToArray(), NbConversions);
+        ConfigureCaching();
+        // _massConversions = _random.GetRandomConversions<Mass, MassUnit>(Value, [MassUnit.Milligram, MassUnit.Microgram], NbConversions);
+        _massConversions = _random.GetRandomConversions<Mass, MassUnit>(Value, Mass.Units, NbConversions);
     }
 
     [GlobalSetup(Target = nameof(VolumeAs))]
     public void PrepareVolumeConversionsToTest()
     {
-        _volumeConversions = _random.GetRandomConversions<Volume, VolumeUnit>(Value, Volume.Units.ToArray(), NbConversions);
+        ConfigureCaching();
+        _volumeConversions = _random.GetRandomConversions<Volume, VolumeUnit>(Value, Volume.Units, NbConversions);
     }
 
     [GlobalSetup(Target = nameof(DensityAs))]
     public void PrepareDensityConversionsToTest()
     {
-        _densityConversions = _random.GetRandomConversions<Density, DensityUnit>(Value, Density.Units.ToArray(), NbConversions);
+        ConfigureCaching();
+        _densityConversions = _random.GetRandomConversions<Density, DensityUnit>(Value, Density.Units, NbConversions);
     }
-    
+
     [GlobalSetup(Target = nameof(PressureAs))]
     public void PreparePressureConversionsToTest()
     {
-        _pressureConversions = _random.GetRandomConversions<Pressure, PressureUnit>(Value, Pressure.Units.ToArray(), NbConversions);
+        ConfigureCaching();
+        _pressureConversions = _random.GetRandomConversions<Pressure, PressureUnit>(Value, Pressure.Units, NbConversions);
     }
-    
+
     [GlobalSetup(Target = nameof(VolumeFlowAs))]
     public void PrepareVolumeFlowConversionsToTest()
     {
-        _volumeFlowConversions = _random.GetRandomConversions<VolumeFlow, VolumeFlowUnit>(Value, VolumeFlow.Units.ToArray(), NbConversions);
+        ConfigureCaching();
+        _volumeFlowConversions = _random.GetRandomConversions<VolumeFlow, VolumeFlowUnit>(Value, VolumeFlow.Units, NbConversions);
     }
 
     [Benchmark(Baseline = true)]
     public void MassAs()
     {
-        foreach (var conversion in _massConversions)
+        foreach ((Mass quantity, MassUnit unit) in _massConversions)
         {
-            conversion.Quantity.As(conversion.Unit);
+            quantity.As(unit);
         }
     }
 
     [Benchmark]
     public void VolumeAs()
     {
-        foreach (var conversion in _volumeConversions)
+        foreach ((Volume quantity, VolumeUnit unit) in _volumeConversions)
         {
-            conversion.Quantity.As(conversion.Unit);
+            quantity.As(unit);
         }
     }
 
     [Benchmark]
     public void DensityAs()
     {
-        foreach (var conversion in _densityConversions)
+        foreach ((Density quantity, DensityUnit unit) in _densityConversions)
         {
-            conversion.Quantity.As(conversion.Unit);
+            quantity.As(unit);
         }
     }
 
     [Benchmark]
     public void PressureAs()
     {
-        foreach (var conversion in _pressureConversions)
+        foreach ((Pressure quantity, PressureUnit unit) in _pressureConversions)
         {
-            conversion.Quantity.As(conversion.Unit);
+            quantity.As(unit);
         }
     }
 
     [Benchmark]
     public void VolumeFlowAs()
     {
-        foreach (var conversion in _volumeFlowConversions)
+        foreach ((VolumeFlow quantity, VolumeFlowUnit unit) in _volumeFlowConversions)
         {
-            conversion.Quantity.As(conversion.Unit);
+            quantity.As(unit);
         }
     }
 }
diff --git a/UnitsNet.Benchmark/Conversions/ToValue/QuantityAsConfiguredBenchmarks.cs b/UnitsNet.Benchmark/Conversions/ToValue/QuantityAsConfiguredBenchmarks.cs
new file mode 100644
index 0000000000..9c86efb33a
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/ToValue/QuantityAsConfiguredBenchmarks.cs
@@ -0,0 +1,79 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Conversions.ToValue;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class QuantityAsConfiguredBenchmarks
+{
+    private static readonly QuantityValue Value = 123.456;
+    private readonly Random _random = new(42);
+
+    private (Mass Quantity, MassUnit Unit)[] _massConversions = [];
+    private (VolumeFlow Quantity, VolumeFlowUnit Unit)[] _volumeFlowConversions = [];
+
+    [Params(1000)]
+    public int NbConversions { get; set; }
+
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [ParamsAllValues]
+    public ConversionCachingMode CachingMode { get; set; }
+
+    [Params(true, false)]
+    public bool CacheSpecific { get; set; }
+
+    [GlobalSetup]
+    public void ConfigureCaching()
+    {
+        var converterOptions = new QuantityConverterBuildOptions(Frozen, CachingMode);
+        if (CacheSpecific)
+        {
+            converterOptions = converterOptions
+                .WithCustomCachingOptions<Mass>(new ConversionCacheOptions())
+                .WithCustomCachingOptions<VolumeFlow>(new ConversionCacheOptions());
+        }
+
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(converterOptions));
+    }
+
+    [GlobalSetup(Target = nameof(MassAs))]
+    public void PrepareMassConversionsToTest()
+    {
+        ConfigureCaching();
+        _massConversions = _random.GetRandomConversions<Mass, MassUnit>(Value, Mass.Units, NbConversions);
+    }
+
+    [GlobalSetup(Target = nameof(VolumeFlowAs))]
+    public void PrepareVolumeFlowConversionsToTest()
+    {
+        ConfigureCaching();
+        _volumeFlowConversions = _random.GetRandomConversions<VolumeFlow, VolumeFlowUnit>(Value, VolumeFlow.Units, NbConversions);
+    }
+
+    [Benchmark(Baseline = true)]
+    public void MassAs()
+    {
+        foreach ((Mass quantity, MassUnit unit) in _massConversions)
+        {
+            quantity.As(unit);
+        }
+    }
+
+    [Benchmark]
+    public void VolumeFlowAs()
+    {
+        foreach ((VolumeFlow quantity, VolumeFlowUnit unit) in _volumeFlowConversions)
+        {
+            quantity.As(unit);
+        }
+    }
+}
diff --git a/UnitsNet.Benchmark/Conversions/ToValue/QuantityConverterColdStartBenchmarks.cs b/UnitsNet.Benchmark/Conversions/ToValue/QuantityConverterColdStartBenchmarks.cs
new file mode 100644
index 0000000000..b6775ca843
--- /dev/null
+++ b/UnitsNet.Benchmark/Conversions/ToValue/QuantityConverterColdStartBenchmarks.cs
@@ -0,0 +1,128 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Engines;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Conversions.ToValue;
+
+[MemoryDiagnoser]
+// [DryJob]
+// [ShortRunJob]
+[SimpleJob(RunStrategy.ColdStart, launchCount:10)]
+public class QuantityConverterColdStartBenchmarks
+{
+    private static readonly QuantityValue Value = 123.456;
+
+    [Params(typeof(Volume), typeof(Mass), typeof(Density), typeof(Pressure))]
+    public Type TypesToTest { get; set; }
+    
+    private UnitConverter _quantityConverter;
+    
+    #region Benchmarks
+
+    [Benchmark(Baseline = true)]
+    public QuantityValue ConvertWith_FullyCachedFrozenDictionary()
+    {
+        return ConvertWithConverter();
+    }
+    
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWith_EmptyFrozenDictionary()
+    {
+        return ConvertWithConverter();
+    }
+
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWith_EmptyDynamicDictionary()
+    {
+        return ConvertWithConverter();
+    }
+
+    [Benchmark(Baseline = false)]
+    public QuantityValue ConvertWithTheNoCachingConverter()
+    {
+        return ConvertWithConverter();
+    }
+    
+    private QuantityValue ConvertWithConverter()
+    {
+        QuantityValue result = default;
+        if (TypesToTest == typeof(Volume))
+        {
+            foreach (VolumeUnit fromUnit in Volume.Units)
+            {
+                foreach (VolumeUnit toUnit in Volume.Units)
+                {
+                    result = _quantityConverter.ConvertValue(Value, fromUnit, toUnit);
+                }
+            }
+        }
+        else if (TypesToTest == typeof(Mass))
+        {
+            foreach (MassUnit fromUnit in Mass.Units)
+            {
+                foreach (MassUnit toUnit in Mass.Units)
+                {
+                    result = _quantityConverter.ConvertValue(Value, fromUnit, toUnit);
+                }
+            }
+        }
+        else if (TypesToTest == typeof(Density))
+        {
+            foreach (DensityUnit fromUnit in Density.Units)
+            {
+                foreach (DensityUnit toUnit in Density.Units)
+                {
+                    result = _quantityConverter.ConvertValue(Value, fromUnit, toUnit);
+                }
+            }
+        }
+        else if (TypesToTest == typeof(Pressure))
+        {
+            foreach (PressureUnit fromUnit in Pressure.Units)
+            {
+                foreach (PressureUnit toUnit in Pressure.Units)
+                {
+                    result = _quantityConverter.ConvertValue(Value, fromUnit, toUnit);
+                }
+            }
+        }
+
+        return result;
+    }
+    
+    #endregion
+
+    #region Setup
+
+    [GlobalSetup(Target = nameof(ConvertWith_FullyCachedFrozenDictionary))]
+    public void PrepareTo_ConvertWith_FullyCachedFrozenDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.All, true));
+    }
+    
+    [GlobalSetup(Target = nameof(ConvertWith_EmptyFrozenDictionary))]
+    public void PrepareTo_ConvertWith_EmptyFrozenDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.None, true));
+    }
+
+    [IterationSetup(Target = nameof(ConvertWith_EmptyDynamicDictionary))]
+    public void PrepareTo_ConvertWith_EmptyStandardDictionary()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(false, ConversionCachingMode.None, true));
+    }
+
+    [GlobalSetup(Target = nameof(ConvertWithTheNoCachingConverter))]
+    public void PrepareTo_ConvertWithTheNoCachingConverter()
+    {
+        _quantityConverter = UnitConverter.Create(UnitParser.Default, new QuantityConverterBuildOptions(true, ConversionCachingMode.None, true));
+    }
+
+    #endregion
+
+}
diff --git a/UnitsNet.Benchmark/Enums/BoxedEnumToIntegerBenchmarks.cs b/UnitsNet.Benchmark/Enums/BoxedEnumToIntegerBenchmarks.cs
index 18cd6f3432..6310e7d1ad 100644
--- a/UnitsNet.Benchmark/Enums/BoxedEnumToIntegerBenchmarks.cs
+++ b/UnitsNet.Benchmark/Enums/BoxedEnumToIntegerBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Benchmark/Enums/EnumEqualityBenchmarks.cs b/UnitsNet.Benchmark/Enums/EnumEqualityBenchmarks.cs
new file mode 100644
index 0000000000..87d60d8558
--- /dev/null
+++ b/UnitsNet.Benchmark/Enums/EnumEqualityBenchmarks.cs
@@ -0,0 +1,123 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Enums;
+
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class EnumEqualityBenchmarks
+{
+    private const int NbIterations = 1000;
+    
+    private const MassUnit Unit = MassUnit.Gram;
+
+    [Benchmark(Baseline = true)]
+    public bool IsEqualWithComparer()
+    {
+        const MassUnit targetUnit = MassUnit.Gram;
+        var result = false;
+        for (var i = 0; i < NbIterations; i++)
+        {
+            result = EqualityComparer<MassUnit>.Default.Equals(Unit, targetUnit);
+        }
+
+        return result;
+    }
+
+    [Benchmark(Baseline = false)]
+    public bool IsNotEqualWithComparer()
+    {
+        const MassUnit targetUnit = MassUnit.Milligram;
+        var result = false;
+        for (var i = 0; i < NbIterations; i++)
+        {
+            result = EqualityComparer<MassUnit>.Default.Equals(Unit, targetUnit);
+        }
+
+        return result;
+    }
+
+    [Benchmark(Baseline = false)]
+    public bool IsEqualWithUnsafe()
+    {
+        const MassUnit targetUnit = MassUnit.Gram;
+        var result = false;
+        for (var i = 0; i < NbIterations; i++)
+        {
+            result = UnitEqualityComparer<MassUnit>.Default.Equals(Unit, targetUnit);
+        }
+
+        return result;
+    }
+
+    [Benchmark(Baseline = false)]
+    public bool IsNotEqualWithUnsafe()
+    {
+        const MassUnit targetUnit = MassUnit.Milligram;
+        var result = false;
+        for (var i = 0; i < NbIterations; i++)
+        {
+            result = UnitEqualityComparer<MassUnit>.Default.Equals(Unit, targetUnit);
+        }
+
+        return result;
+    }
+
+    [Benchmark(Baseline = false)]
+    public bool IsEqualWithOperator()
+    {
+        const MassUnit targetUnit = MassUnit.Gram;
+        var result = false;
+        for (var i = 0; i < NbIterations; i++)
+        {
+            result = Unit == targetUnit;
+        }
+
+        return result;
+    }
+
+    [Benchmark(Baseline = false)]
+    public bool IsNotEqualWithOperator()
+    {
+        const MassUnit targetUnit = MassUnit.Milligram;
+        var result = true;
+        for (var i = 0; i < NbIterations; i++)
+        {
+            result = Unit == targetUnit;
+        }
+
+        return result;
+    }
+
+    public class UnitEqualityComparer<TUnit> : IEqualityComparer<TUnit> where TUnit : struct, Enum
+    {
+        // Singleton instance of the comparer
+        public static readonly UnitEqualityComparer<TUnit> Default = new();
+
+        private UnitEqualityComparer()
+        {
+        }
+
+        public bool Equals(TUnit x, TUnit y)
+        {
+            // Use Unsafe.As to convert enums to integers for comparison
+            var xInt = Unsafe.As<TUnit, int>(ref x);
+            var yInt = Unsafe.As<TUnit, int>(ref y);
+            return xInt == yInt;
+        }
+
+        public int GetHashCode(TUnit obj)
+        {
+            // Use Unsafe.As to convert enum to integer for hash code calculation
+            var objInt = Unsafe.As<TUnit, int>(ref obj);
+            return objInt.GetHashCode();
+        }
+    }
+}
diff --git a/UnitsNet.Benchmark/Enums/EnumFromNameBenchmarks.cs b/UnitsNet.Benchmark/Enums/EnumFromNameBenchmarks.cs
new file mode 100644
index 0000000000..37ae76dc70
--- /dev/null
+++ b/UnitsNet.Benchmark/Enums/EnumFromNameBenchmarks.cs
@@ -0,0 +1,100 @@
+#if NET
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Enums;
+
+[SimpleJob(RuntimeMoniker.Net80)]
+public class EnumFromNameBenchmarks
+{
+    private const int NbIterations = 1000;
+
+    private const string Unit = "Gram";
+    private static readonly QuantityInfo<Mass, MassUnit> MassInfo = Mass.Info;
+
+    [Benchmark(Baseline = true)]
+    public void GetUnitFromEnum()
+    {
+        for (var i = 0; i < NbIterations; i++)
+        {
+            MassUnit _ = GetUnitFromEnum<MassUnit>(Unit, false);
+        }
+    }
+
+    [Benchmark(Baseline = false)]
+    public void GetUnitFromEnumIgnoreCase()
+    {
+        for (var i = 0; i < NbIterations; i++)
+        {
+            MassUnit _ = GetUnitFromEnum<MassUnit>(Unit, true);
+        }
+    }
+
+    [Benchmark(Baseline = false)]
+    public void GetUnitFromInfo()
+    {
+        for (var i = 0; i < NbIterations; i++)
+        {
+            MassUnit _ = GetUnitFromInfo(MassInfo, Unit);
+        }
+    }
+
+    [Benchmark(Baseline = false)]
+    public void GetUnitFromInfoIgnoreCase()
+    {
+        for (var i = 0; i < NbIterations; i++)
+        {
+            MassUnit _ = GetUnitFromInfoIgnoreCase(MassInfo, Unit);
+        }
+    }
+
+    private static TUnit GetUnitFromEnum<TUnit>(ReadOnlySpan<char> unitNamePart, bool ignoreCase) where TUnit : struct, Enum
+    {
+        if (Enum.TryParse(unitNamePart, ignoreCase, out TUnit unit))
+        {
+            return unit;
+        }
+
+        throw new UnitNotFoundException();
+    }
+
+    private static TUnit GetUnitFromInfo<TUnit>(QuantityInfo<TUnit> quantityInfo, ReadOnlySpan<char> unitNamePart) where TUnit : struct, Enum
+    {
+        IReadOnlyList<UnitInfo<TUnit>> unitInfos = quantityInfo.UnitInfos;
+        var nbUnits = unitInfos.Count;
+        for (var i = 0; i < nbUnits; i++)
+        {
+            UnitInfo<TUnit> unitInfo = unitInfos[i];
+            if (unitNamePart.Equals(unitInfo.Name, StringComparison.Ordinal))
+            {
+                return unitInfo.Value;
+            }
+        }
+
+        throw new UnitNotFoundException();
+    }
+
+    private static TUnit GetUnitFromInfoIgnoreCase<TUnit>(QuantityInfo<TUnit> quantityInfo, ReadOnlySpan<char> unitNamePart) where TUnit : struct, Enum
+    {
+        IReadOnlyList<UnitInfo<TUnit>> unitInfos = quantityInfo.UnitInfos;
+        var nbUnits = unitInfos.Count;
+        for (var i = 0; i < nbUnits; i++)
+        {
+            UnitInfo<TUnit> unitInfo = unitInfos[i];
+            if (unitNamePart.Equals(unitInfo.Name, StringComparison.OrdinalIgnoreCase))
+            {
+                return unitInfo.Value;
+            }
+        }
+
+        throw new UnitNotFoundException();
+    }
+}
+#endif
diff --git a/UnitsNet.Benchmark/Enums/EnumToIntegerBenchmarks.cs b/UnitsNet.Benchmark/Enums/EnumToIntegerBenchmarks.cs
index 75fc0b2fc3..47a57de8f2 100644
--- a/UnitsNet.Benchmark/Enums/EnumToIntegerBenchmarks.cs
+++ b/UnitsNet.Benchmark/Enums/EnumToIntegerBenchmarks.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
diff --git a/UnitsNet.Benchmark/Enums/EnumToNameBenchmarks.cs b/UnitsNet.Benchmark/Enums/EnumToNameBenchmarks.cs
new file mode 100644
index 0000000000..deab101ed5
--- /dev/null
+++ b/UnitsNet.Benchmark/Enums/EnumToNameBenchmarks.cs
@@ -0,0 +1,50 @@
+#if NET
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Enums;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class EnumToNameBenchmarks
+{
+    private const int NbIterations = 1000;
+
+    private const MassUnit Unit = MassUnit.Gram;
+    private static readonly QuantityInfo<Mass, MassUnit> MassInfo = Mass.Info;
+
+    [Benchmark(Baseline = true)]
+    public void GetNameFromEnum()
+    {
+        for (var i = 0; i < NbIterations; i++)
+        {
+            var _ = GetNameFromEnum(Unit);
+        }
+    }
+
+    [Benchmark(Baseline = false)]
+    public void GetNameFromInfo()
+    {
+        for (var i = 0; i < NbIterations; i++)
+        {
+            var _ = GetNameFromInfo(MassInfo, Unit);
+        }
+    }
+
+    private static string GetNameFromEnum<TUnit>(TUnit unit) where TUnit : struct, Enum
+    {
+        return unit.ToString();
+    }
+
+    private static string GetNameFromInfo<TUnit>(QuantityInfo<TUnit> quantityInfo, TUnit unit) where TUnit : struct, Enum
+    {
+        return quantityInfo[unit].Name;
+    }
+}
+#endif
diff --git a/UnitsNet.Benchmark/Enums/GetBoxedEnumValuesBenchmarks.cs b/UnitsNet.Benchmark/Enums/GetBoxedEnumValuesBenchmarks.cs
new file mode 100644
index 0000000000..a8ec396e00
--- /dev/null
+++ b/UnitsNet.Benchmark/Enums/GetBoxedEnumValuesBenchmarks.cs
@@ -0,0 +1,48 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+
+namespace UnitsNet.Benchmark.Enums;
+
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class GetBoxedEnumValuesBenchmarks
+{
+    private readonly Dictionary<Type, QuantityInfo> _quantityInfos = Quantity.Infos.ToDictionary(x => x.UnitType);
+
+    [Benchmark(Baseline = true)]
+    public int GetEnumValues()
+    {
+        var total = 0;
+        foreach (Type unitType in _quantityInfos.Keys)
+        {
+            foreach (Enum unitValue in Enum.GetValues(unitType).Cast<Enum>())
+            {
+                var unitKey = (UnitKey)unitValue;
+                total += unitKey.UnitEnumValue;
+            }
+        }
+
+        return total;
+    }
+
+    [Benchmark(Baseline = false)]
+    public int GetEnumValuesWithDictionary()
+    {
+        var total = 0;
+        foreach (Type unitType in _quantityInfos.Keys)
+        {
+            foreach (UnitInfo unitInfo in _quantityInfos[unitType].UnitInfos)
+            {
+                total += unitInfo.UnitKey.UnitEnumValue;
+            }
+        }
+
+        return total;
+    }
+}
diff --git a/UnitsNet.Benchmark/Enums/TypeHashCodeBenchmarks.cs b/UnitsNet.Benchmark/Enums/TypeHashCodeBenchmarks.cs
new file mode 100644
index 0000000000..2f6d811200
--- /dev/null
+++ b/UnitsNet.Benchmark/Enums/TypeHashCodeBenchmarks.cs
@@ -0,0 +1,68 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Enums;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class TypeHashcodeBenchmarks
+{
+    private const int NbIterations = 1000;
+
+    private static readonly Type TestType = typeof(VolumeUnit);
+    private static readonly string TestTypeFullName = typeof(VolumeUnit).FullName!;
+
+    [Benchmark(Baseline = true)]
+    public int TypeHashcode()
+    {
+        var hash = 0;
+        for (var i = 0; i < NbIterations; i++)
+        {
+            hash += TestType.GetHashCode();
+        }
+
+        return hash;
+    }
+
+    [Benchmark(Baseline = false)]
+    public int TypeFullNameHashcode()
+    {
+        var hash = 0;
+        for (var i = 0; i < NbIterations; i++)
+        {
+            hash += TestType.FullName!.GetHashCode();
+        }
+
+        return hash;
+    }
+
+    [Benchmark(Baseline = false)]
+    public int FullNameHashcode()
+    {
+        var hash = 0;
+        for (var i = 0; i < NbIterations; i++)
+        {
+            hash += TestTypeFullName.GetHashCode();
+        }
+
+        return hash;
+    }
+
+    [Benchmark(Baseline = false)]
+    public int TestTypeName()
+    {
+        var hash = 0;
+        for (var i = 0; i < NbIterations; i++)
+        {
+            hash += TestType.Name!.GetHashCode();
+        }
+
+        return hash;
+    }
+}
diff --git a/UnitsNet.Benchmark/Enums/UnitKeyEqualsBenchmarks.cs b/UnitsNet.Benchmark/Enums/UnitKeyEqualsBenchmarks.cs
index 6cbd33683f..b0cae7c43b 100644
--- a/UnitsNet.Benchmark/Enums/UnitKeyEqualsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Enums/UnitKeyEqualsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Benchmark/Enums/UnitKeyHashCodeBenchmarks.cs b/UnitsNet.Benchmark/Enums/UnitKeyHashCodeBenchmarks.cs
index 66c707f8be..218f518fdd 100644
--- a/UnitsNet.Benchmark/Enums/UnitKeyHashCodeBenchmarks.cs
+++ b/UnitsNet.Benchmark/Enums/UnitKeyHashCodeBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -54,11 +54,7 @@ public int GetCustomHashCodeUnchecked()
         int hashCode = 0;
         for (var i = 0; i < NbIterations; i++)
         {
-            if (UnitType == null)
-            {
-                hashCode += UnitValue;
-            }
-            else
+            if (UnitType != null)
             {
                 unchecked
                 {
diff --git a/UnitsNet.Benchmark/Enums/UnitKeyToEnumBenchmarks.cs b/UnitsNet.Benchmark/Enums/UnitKeyToEnumBenchmarks.cs
index 719f81b3ce..6b1c9162e3 100644
--- a/UnitsNet.Benchmark/Enums/UnitKeyToEnumBenchmarks.cs
+++ b/UnitsNet.Benchmark/Enums/UnitKeyToEnumBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Benchmark/Initializations/QuantityConverterInitializationBenchmarks.cs b/UnitsNet.Benchmark/Initializations/QuantityConverterInitializationBenchmarks.cs
new file mode 100644
index 0000000000..3a6158b9f6
--- /dev/null
+++ b/UnitsNet.Benchmark/Initializations/QuantityConverterInitializationBenchmarks.cs
@@ -0,0 +1,34 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+
+namespace UnitsNet.Benchmark.Initializations;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net90)]
+[SimpleJob(RuntimeMoniker.Net10_0)]
+public class QuantityConverterInitializationBenchmarks
+{
+    private readonly UnitParser _unitParser = UnitParser.Default;
+
+    [Params(ConversionCachingMode.BaseOnly, ConversionCachingMode.All)]
+    public ConversionCachingMode ConversionCachingMode { get; set; }
+
+    [Params(true, false)]
+    public bool ReduceConstants { get; set; }
+
+    [Benchmark(Baseline = false)]
+    public UnitConverter CreateDynamic()
+    {
+        return UnitConverter.Create(_unitParser, new QuantityConverterBuildOptions(false, ConversionCachingMode, ReduceConstants));
+    }
+
+    [Benchmark(Baseline = false)]
+    public UnitConverter CreateFrozen()
+    {
+        return UnitConverter.Create(_unitParser, new QuantityConverterBuildOptions(true, ConversionCachingMode, ReduceConstants));
+    }
+}
diff --git a/UnitsNet.Benchmark/Initializations/QuantityDisplayBenchmarks.cs b/UnitsNet.Benchmark/Initializations/QuantityDisplayBenchmarks.cs
new file mode 100644
index 0000000000..6587bed4b0
--- /dev/null
+++ b/UnitsNet.Benchmark/Initializations/QuantityDisplayBenchmarks.cs
@@ -0,0 +1,106 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Debug;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Initializations;
+
+[MemoryDiagnoser]
+// [SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net80)]
+public class QuantityDisplayBenchmarksConversions
+{
+    // [Params(1000)]
+    [Params(1)]
+    public int NbIterations { get; set; }
+
+    public VolumeFlow Quantity { get; set; }
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithQuantities([VolumeFlow.Info]));
+        Quantity = VolumeFlow.From(42, VolumeFlowUnit.LiterPerHour);
+    }
+    
+    [Benchmark(Baseline = false)]
+    public void CreateWithIQuantity()
+    {
+        for (var i = 0; i < NbIterations; i++)
+        {
+            var quantityInfo = new QuantityDebugProxy(Quantity);
+            var name = quantityInfo.Quantity.ToString();
+            var unit = quantityInfo.Unit.ToString();
+            var unitAbbreviation = quantityInfo.UnitAbbreviation.ToString();
+            var value = quantityInfo.Value.ToString("G");
+            var format = quantityInfo.ValueFormats.ToString();
+            
+            foreach (var quantityUnitConversion in quantityInfo.Quantity.UnitConversions)
+            {
+                foreach (var unitConversion in quantityUnitConversion.Unit.UnitConversions)
+                {
+                    var quantityDisplay = unitConversion.Quantity;  
+                    // name = quantityDisplay.Quantity.ToString();
+                    // unit = quantityDisplay.Unit.ToString();
+                    // unitAbbreviation = quantityDisplay.UnitAbbreviation.ToString();
+                    // value = quantityDisplay.Value.ToString("G");
+                    // format = quantityDisplay.ValueFormats.ToString();
+                }
+                // foreach (var unitConversion in quantityUnitConversion.UnitAbbreviation.DefaultAbbreviations)
+                // {
+                //     var quantityDisplay = unitConversion.Quantity;
+                //     // name = quantityDisplay.Quantity.ToString();
+                //     // unit = quantityDisplay.Unit.ToString();
+                //     // unitAbbreviation = quantityDisplay.UnitAbbreviation.ToString();
+                //     // value = quantityDisplay.Value.ToString("G");
+                //     // format = quantityDisplay.ValueFormats.ToString();
+                // }
+            }
+            
+            foreach (var quantityUnitConversion in quantityInfo.Unit.UnitConversions)
+            {
+                foreach (var unitConversion in quantityUnitConversion.Quantity.Unit.UnitConversions)
+                {
+                    var quantityDisplay = unitConversion.Quantity;
+                    // name = quantityDisplay.Quantity.ToString();
+                    // unit = quantityDisplay.Unit.ToString();
+                    // unitAbbreviation = quantityDisplay.UnitAbbreviation.ToString();
+                    // value = quantityDisplay.Value.ToString("G");
+                    // format = quantityDisplay.ValueFormats.ToString();
+                }
+                // foreach (var unitConversion in quantityUnitConversion.Quantity.UnitAbbreviation.DefaultAbbreviations)
+                // {
+                //     var quantityDisplay = unitConversion.Quantity;
+                //     // name = quantityDisplay.Quantity.ToString();
+                //     // unit = quantityDisplay.Unit.ToString();
+                //     // unitAbbreviation = quantityDisplay.UnitAbbreviation.ToString();
+                //     // value = quantityDisplay.Value.ToString("G");
+                //     // format = quantityDisplay.ValueFormats.ToString();
+                // }
+            }
+            
+            // foreach (var quantityUnitConversion in quantityInfo.UnitAbbreviation.DefaultAbbreviations)
+            // {
+            //     foreach (var unitConversion in quantityUnitConversion.Quantity.Unit.UnitConversions)
+            //     {
+            //         var quantityDisplay = unitConversion.Quantity;
+            //         // name = quantityDisplay.Quantity.ToString();
+            //         // unit = quantityDisplay.Unit.ToString();
+            //         // unitAbbreviation = quantityDisplay.UnitAbbreviation.ToString();
+            //         // value = quantityDisplay.Value.ToString("G");
+            //         // format = quantityDisplay.ValueFormats.ToString();
+            //     }
+            //     foreach (var unitConversion in quantityUnitConversion.Quantity.UnitAbbreviation.DefaultAbbreviations)
+            //     {
+            //         var quantityDisplay = unitConversion.Quantity;
+            //         // name = quantityDisplay.Quantity.ToString();
+            //         // unit = quantityDisplay.Unit.ToString();
+            //         // unitAbbreviation = quantityDisplay.UnitAbbreviation.ToString();
+            //         // value = quantityDisplay.Value.ToString("G");
+            //         // format = quantityDisplay.ValueFormats.ToString();
+            //     }
+            // }
+
+        }
+    }
+}
diff --git a/UnitsNet.Benchmark/Initializations/QuantityInfoInitializationBenchmarks.cs b/UnitsNet.Benchmark/Initializations/QuantityInfoInitializationBenchmarks.cs
index 11f0241673..2289aff2af 100644
--- a/UnitsNet.Benchmark/Initializations/QuantityInfoInitializationBenchmarks.cs
+++ b/UnitsNet.Benchmark/Initializations/QuantityInfoInitializationBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using BenchmarkDotNet.Attributes;
diff --git a/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs b/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs
index ccd99f7d44..184a238c69 100644
--- a/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs
+++ b/UnitsNet.Benchmark/Initializations/UnitAbbreviationsCacheInitializationBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using BenchmarkDotNet.Attributes;
@@ -47,4 +47,25 @@ public string WithSpecificQuantityAndCustomMapping()
         cache.MapUnitToDefaultAbbreviation(MassUnit.Gram, "zz");
         return cache.GetDefaultAbbreviation(MassUnit.Gram);
     }
+
+    [Benchmark]
+    public string DefaultWithoutLookup()
+    {
+        var cache = UnitAbbreviationsCache.CreateDefault();
+        return Mass.GetAbbreviation(Mass.BaseUnit);
+    }
+
+    [Benchmark]
+    public string EmptyWithoutLookup()
+    {
+        var cache = new UnitAbbreviationsCache();
+        return Mass.GetAbbreviation(Mass.BaseUnit);
+    }
+
+    [Benchmark]
+    public string WithSpecificQuantityWithoutLookup()
+    {
+        var cache = new UnitAbbreviationsCache([Mass.Info]);
+        return Mass.GetAbbreviation(Mass.BaseUnit);
+    }
 }
diff --git a/UnitsNet.Benchmark/Operators/Additions/AddToTemperatureWithRandomUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/AddToTemperatureWithRandomUnitsBenchmarks.cs
index 596e17a990..e42d24b5ab 100644
--- a/UnitsNet.Benchmark/Operators/Additions/AddToTemperatureWithRandomUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/AddToTemperatureWithRandomUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -14,18 +14,26 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 [SimpleJob(RuntimeMoniker.Net90)]
 public class AddToTemperatureWithRandomUnitsBenchmarks
 {
-    private static readonly double LeftValue = 1.23;
-    private static readonly double RightValue = 4.56;
+    private static readonly QuantityValue LeftValue = 1.23;
+    private static readonly QuantityValue RightValue = 4.56;
 
     private readonly Random _random = new(42);
     private (Temperature left, TemperatureDelta right)[] _operands;
 
     [Params(1_000)]
     public int NbOperations { get; set; }
+    
+    [Params(true)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
 
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        
         _operands = _random.GetRandomQuantities<Temperature, TemperatureUnit>(LeftValue, Temperature.Units.ToArray(), NbOperations)
             .Zip(_random.GetRandomQuantities<TemperatureDelta, TemperatureDeltaUnit>(RightValue, TemperatureDelta.Units.ToArray(), NbOperations),
                 (left, right) => (left, right))
diff --git a/UnitsNet.Benchmark/Operators/Additions/AddTwoMassesWithRandomUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/AddTwoMassesWithRandomUnitsBenchmarks.cs
index e7a921104a..315f5831bb 100644
--- a/UnitsNet.Benchmark/Operators/Additions/AddTwoMassesWithRandomUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/AddTwoMassesWithRandomUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -14,18 +14,26 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 [SimpleJob(RuntimeMoniker.Net80)]
 public class AddTwoMassesWithRandomUnitsBenchmarks
 {
-    private static readonly double LeftValue = 1.23;
-    private static readonly double RightValue = 4.56;
+    private static readonly QuantityValue LeftValue = 1.23;
+    private static readonly QuantityValue RightValue = 4.56;
 
     private readonly Random _random = new(42);
     private (Mass left, Mass right)[] _operands;
 
-    [Params(1_000)]
+    [Params(1000)]
     public int NbOperations { get; set; }
 
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [ParamsAllValues]
+    public ConversionCachingMode CachingMode { get; set; }
+
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        
         _operands = _random.GetRandomQuantities<Mass, MassUnit>(LeftValue, Mass.Units.ToArray(), NbOperations)
             .Zip(_random.GetRandomQuantities<Mass, MassUnit>(RightValue, Mass.Units.ToArray(), NbOperations),
                 (left, right) => (left, right))
diff --git a/UnitsNet.Benchmark/Operators/Additions/AddTwoMassesWithSameUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/AddTwoMassesWithSameUnitsBenchmarks.cs
index b0b73bf36d..94851fd0e6 100644
--- a/UnitsNet.Benchmark/Operators/Additions/AddTwoMassesWithSameUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/AddTwoMassesWithSameUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Linq;
@@ -13,20 +13,28 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 [SimpleJob(RuntimeMoniker.Net80)]
 public class AddTwoMassesWithSameUnitsBenchmarks
 {
-    private static readonly double LeftValue = 1.23;
-    private static readonly double RightValue = 4.56;
+    private static readonly QuantityValue LeftValue = 1.23;
+    private static readonly QuantityValue RightValue = 4.56;
 
     private (Mass left, Mass right)[] _operands;
 
-    [Params(1_000)]
+    [Params(1000)]
     public int NbOperations { get; set; }
 
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
     [Params(MassUnit.Kilogram, MassUnit.Gram, MassUnit.Milligram)]
     public MassUnit Unit { get; set; }
 
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        
         _operands = Enumerable.Range(0, NbOperations).Select(_ => (Mass.From(LeftValue, Unit), Mass.From(RightValue, Unit))).ToArray();
     }
 
diff --git a/UnitsNet.Benchmark/Operators/Additions/AddTwoTemperatureDeltasWithRandomUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/AddTwoTemperatureDeltasWithRandomUnitsBenchmarks.cs
index 3f61a4973d..0aa2e33386 100644
--- a/UnitsNet.Benchmark/Operators/Additions/AddTwoTemperatureDeltasWithRandomUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/AddTwoTemperatureDeltasWithRandomUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -14,18 +14,26 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 [SimpleJob(RuntimeMoniker.Net80)]
 public class AddTwoTemperatureDeltasWithRandomUnitsBenchmarks
 {
-    private static readonly double LeftValue = 1.23;
-    private static readonly double RightValue = 4.56;
+    private static readonly QuantityValue LeftValue = 1.23;
+    private static readonly QuantityValue RightValue = 4.56;
 
     private readonly Random _random = new(42);
     private (TemperatureDelta left, TemperatureDelta right)[] _operands;
 
-    [Params(1_000)]
+    [Params(1000)]
     public int NbOperations { get; set; }
+    
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [ParamsAllValues]
+    public ConversionCachingMode CachingMode { get; set; }
 
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        
         _operands = _random.GetRandomQuantities<TemperatureDelta, TemperatureDeltaUnit>(LeftValue, TemperatureDelta.Units.ToArray(), NbOperations)
             .Zip(_random.GetRandomQuantities<TemperatureDelta, TemperatureDeltaUnit>(RightValue, TemperatureDelta.Units.ToArray(), NbOperations),
                 (left, right) => (left, right))
diff --git a/UnitsNet.Benchmark/Operators/Additions/AddTwoTemperatureDeltasWithSameUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/AddTwoTemperatureDeltasWithSameUnitsBenchmarks.cs
index 963bc588dd..76780b5f9b 100644
--- a/UnitsNet.Benchmark/Operators/Additions/AddTwoTemperatureDeltasWithSameUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/AddTwoTemperatureDeltasWithSameUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -14,8 +14,8 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 [SimpleJob(RuntimeMoniker.Net80)]
 public class AddTwoTemperatureDeltasWithSameUnitsBenchmarks
 {
-    private static readonly double LeftValue = 1.23;
-    private static readonly double RightValue = 4.56;
+    private static readonly QuantityValue LeftValue = 1.23;
+    private static readonly QuantityValue RightValue = 4.56;
 
     private readonly Random _random = new(42);
     private (TemperatureDelta left, TemperatureDelta right)[] _operands;
@@ -23,12 +23,20 @@ public class AddTwoTemperatureDeltasWithSameUnitsBenchmarks
     [Params(1_000)]
     public int NbOperations { get; set; }
 
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
     [Params(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeCelsius, TemperatureDeltaUnit.DegreeFahrenheit)]
     public TemperatureDeltaUnit Unit { get; set; }
 
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        
         _operands = _random.GetRandomQuantities<TemperatureDelta, TemperatureDeltaUnit>(LeftValue, TemperatureDelta.Units.ToArray(), NbOperations)
             .Zip(_random.GetRandomQuantities<TemperatureDelta, TemperatureDeltaUnit>(RightValue, TemperatureDelta.Units.ToArray(), NbOperations),
                 (left, right) => (left, right))
diff --git a/UnitsNet.Benchmark/Operators/Additions/AddTwoVolumesWithRandomUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/AddTwoVolumesWithRandomUnitsBenchmarks.cs
index b0cde2daa1..40c968f081 100644
--- a/UnitsNet.Benchmark/Operators/Additions/AddTwoVolumesWithRandomUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/AddTwoVolumesWithRandomUnitsBenchmarks.cs
@@ -1,6 +1,3 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
 using System;
 using System.Linq;
 using BenchmarkDotNet.Attributes;
@@ -14,25 +11,33 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 [SimpleJob(RuntimeMoniker.Net80)]
 public class AddTwoVolumesWithRandomUnitsBenchmarks
 {
-    private static readonly double LeftValue = 1.23;
-    private static readonly double RightValue = 4.56;
+    private static readonly QuantityValue LeftValue = 1.23;
+    private static readonly QuantityValue RightValue = 4.56;
 
     private readonly Random _random = new(42);
     private (Volume left, Volume right)[] _operands;
 
-    [Params(1_000)]
+    [Params(1000)]
     public int NbOperations { get; set; }
 
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [ParamsAllValues]
+    public ConversionCachingMode CachingMode { get; set; }
+
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+
         _operands = _random.GetRandomQuantities<Volume, VolumeUnit>(LeftValue, Volume.Units.ToArray(), NbOperations)
             .Zip(_random.GetRandomQuantities<Volume, VolumeUnit>(RightValue, Volume.Units.ToArray(), NbOperations),
                 (left, right) => (left, right))
             .ToArray();
     }
 
-    [Benchmark]
+    [Benchmark(Baseline = true)]
     public Volume AddTwoVolumes()
     {
         Volume sum = default;
diff --git a/UnitsNet.Benchmark/Operators/Additions/AddTwoVolumesWithSameUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/AddTwoVolumesWithSameUnitsBenchmarks.cs
index a55151199a..9864edf5e5 100644
--- a/UnitsNet.Benchmark/Operators/Additions/AddTwoVolumesWithSameUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/AddTwoVolumesWithSameUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Linq;
@@ -13,24 +13,32 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 [SimpleJob(RuntimeMoniker.Net80)]
 public class AddTwoVolumesWithSameUnitsBenchmarks
 {
-    private static readonly double LeftValue = 1.23;
-    private static readonly double RightValue = 4.56;
+    private static readonly QuantityValue LeftValue = 1.23;
+    private static readonly QuantityValue RightValue = 4.56;
 
     private (Volume left, Volume right)[] _operands;
 
-    [Params(1_000)]
+    [Params(1000)]
     public int NbOperations { get; set; }
 
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+    
     [Params(VolumeUnit.CubicMeter, VolumeUnit.Liter, VolumeUnit.Milliliter)]
     public VolumeUnit Unit { get; set; }
 
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        
         _operands = Enumerable.Range(0, NbOperations).Select(_ => (Volume.From(LeftValue, Unit), Volume.From(RightValue, Unit))).ToArray();
     }
 
-    [Benchmark]
+    [Benchmark(Baseline = true)]
     public Volume AddTwoVolumes()
     {
         Volume sum = default;
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfMassesWithRandomUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfMassesWithRandomUnitsBenchmarks.cs
index 03271079ff..8918335a8f 100644
--- a/UnitsNet.Benchmark/Operators/Additions/SumOfMassesWithRandomUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/SumOfMassesWithRandomUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -11,10 +11,11 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 
 [MemoryDiagnoser]
 [SimpleJob(RuntimeMoniker.Net48)]
-[SimpleJob(RuntimeMoniker.Net80)]
+[SimpleJob(RuntimeMoniker.Net90)]
+[SimpleJob(RuntimeMoniker.Net10_0)]
 public class SumOfMassesWithRandomUnitsBenchmarks
 {
-    private static readonly double Value = 1.23;
+    private static readonly QuantityValue Value = 1.23;
 
     private readonly Random _random = new(42);
     private Mass[] _quantities;
@@ -22,9 +23,18 @@ public class SumOfMassesWithRandomUnitsBenchmarks
     [Params(1000)]
     public int NbOperations { get; set; }
 
+    [Params(true)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        Quantity.From(Value, Mass.BaseUnit); // TODO we need a better way to "disable" the lazy loading of the _quantitiesByUnitType (QuantityInfoLookup)
+        
         _quantities = _random.GetRandomQuantities<Mass, MassUnit>(Value, Mass.Units.ToArray(), NbOperations).ToArray();
     }
     
@@ -33,16 +43,24 @@ public Mass SumOfMasses()
     {
         return _quantities.Sum();
     }
+    
+// #if NET
+//     [Benchmark(Baseline = false)]
+//     public Mass SumOfMassesWithGenericExtension()
+//     {
+//         return UnitsNet.GenericMath.GenericMathExtensions.Sum(_quantities);
+//     }
+// #endif
 
-    [Benchmark(Baseline = false)]
-    public Mass SumOfMassesWithBaseUnit()
-    {
-        return _quantities.Sum(Mass.BaseUnit);
-    }
-
-    [Benchmark(Baseline = false)]
-    public Mass SumOfMassesWithInMilligrams()
-    {
-        return _quantities.Sum(MassUnit.Milligram);
-    }
+    // [Benchmark(Baseline = false)]
+    // public Mass SumOfMassesWithBaseUnit()
+    // {
+    //     return _quantities.Sum(Mass.BaseUnit);
+    // }
+    //
+    // [Benchmark(Baseline = false)]
+    // public Mass SumOfMassesWithNonBaseUnit()
+    // {
+    //     return _quantities.Sum(MassUnit.Milligram);
+    // }
 }
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfMassesWithSameUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfMassesWithSameUnitsBenchmarks.cs
index 1a151e88e0..65cda3341e 100644
--- a/UnitsNet.Benchmark/Operators/Additions/SumOfMassesWithSameUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/SumOfMassesWithSameUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Linq;
@@ -10,15 +10,22 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 
 [MemoryDiagnoser]
 [SimpleJob(RuntimeMoniker.Net48)]
-[SimpleJob(RuntimeMoniker.Net80)]
+[SimpleJob(RuntimeMoniker.Net90)]
+[SimpleJob(RuntimeMoniker.Net10_0)]
 public class SumOfMassesWithSameUnitsBenchmarks
 {
-    private static readonly double Value = 1.23;
+    private static readonly QuantityValue Value = 1.23;
     
     private Mass[] _quantities;
 
     [Params(1000)]
     public int NbOperations { get; set; }
+    
+    [Params(true)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
 
     [Params(MassUnit.Kilogram, MassUnit.Gram, MassUnit.Milligram)]
     public MassUnit Unit { get; set; }
@@ -26,6 +33,10 @@ public class SumOfMassesWithSameUnitsBenchmarks
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        Quantity.From(Value, Mass.BaseUnit); // TODO we need a better way to "disable" the lazy loading of the _quantitiesByUnitType (QuantityInfoLookup)
+
+        
         _quantities = Enumerable.Range(0, NbOperations).Select(_ => Mass.From(Value, Unit)).ToArray();
     }
 
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfTemperatureDeltasWithRandomUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfTemperatureDeltasWithRandomUnitsBenchmarks.cs
index 1927f8b70f..b13ea87276 100644
--- a/UnitsNet.Benchmark/Operators/Additions/SumOfTemperatureDeltasWithRandomUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/SumOfTemperatureDeltasWithRandomUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -14,7 +14,7 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 [SimpleJob(RuntimeMoniker.Net90)]
 public class SumOfTemperatureDeltasWithRandomUnitsBenchmarks
 {
-    private static readonly double Value = 1.23;
+    private static readonly QuantityValue Value = 1.23;
 
     private readonly Random _random = new(42);
     private TemperatureDelta[] _quantities;
@@ -22,12 +22,20 @@ public class SumOfTemperatureDeltasWithRandomUnitsBenchmarks
     [Params(10, 1000)]
     public int NbOperations { get; set; }
 
+    [Params(true)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        
         _quantities = _random.GetRandomQuantities<TemperatureDelta, TemperatureDeltaUnit>(Value, TemperatureDelta.Units.ToArray(), NbOperations).ToArray();
     }
-
+    
     [Benchmark(Baseline = true)]
     public TemperatureDelta SumOfTemperatureDeltas()
     {
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfTemperatureDeltasWithSameUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfTemperatureDeltasWithSameUnitsBenchmarks.cs
index e87bc37506..c54b26a287 100644
--- a/UnitsNet.Benchmark/Operators/Additions/SumOfTemperatureDeltasWithSameUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/SumOfTemperatureDeltasWithSameUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Linq;
@@ -19,6 +19,12 @@ public class SumOfTemperatureDeltasWithSameUnitsBenchmarks
 
     [Params(10, 1000)]
     public int NbOperations { get; set; }
+    
+    [Params(true)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
 
     [Params(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeCelsius, TemperatureDeltaUnit.DegreeFahrenheit)]
     public TemperatureDeltaUnit Unit { get; set; }
@@ -26,6 +32,8 @@ public class SumOfTemperatureDeltasWithSameUnitsBenchmarks
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+
         _quantities = Enumerable.Range(0, NbOperations).Select(_ => TemperatureDelta.From(Value, Unit)).ToArray();
     }
 
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithRandomAndUnitsConfigurationBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithRandomAndUnitsConfigurationBenchmarks.cs
new file mode 100644
index 0000000000..59dda32d74
--- /dev/null
+++ b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithRandomAndUnitsConfigurationBenchmarks.cs
@@ -0,0 +1,60 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Operators.Additions;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net90)]
+public class SumOfVolumesWithRandomAndUnitsConfigurationBenchmarksNet9
+{
+    private static readonly QuantityValue Value = 1.23;
+
+    private readonly Random _random = new(42);
+    private Volume[] _quantities;
+
+    [Params(1000)]
+    public int NbOperations { get; set; }
+    
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+
+    [Params(true, false)]
+    public bool ReducedConstants { get; set; }
+
+    [Params(ConversionCachingMode.None, ConversionCachingMode.BaseOnly, ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
+    [GlobalSetup]
+    public void PrepareQuantities()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode, ReducedConstants)));
+        Quantity.From(Value, Volume.BaseUnit); // TODO we need a better way to "disable" the lazy loading of the _quantitiesByUnitType (QuantityInfoLookup)
+        
+        _quantities = _random.GetRandomQuantities<Volume, VolumeUnit>(Value, Volume.Units.ToArray(), NbOperations).ToArray();
+        Console.Out.WriteLine("Quantities prepared: starting unit = {0} ({1})", _quantities[0].Unit, _quantities[0].QuantityInfo[_quantities[0].Unit].ConversionToBase);
+    }
+    
+    [Benchmark(Baseline = true)]
+    public Volume SumOfVolumes()
+    {
+        return _quantities.Sum();
+    }
+
+    [Benchmark(Baseline = false)]
+    public Volume SumOfVolumesInBaseUnit()
+    {
+        return _quantities.Sum(Volume.BaseUnit);
+    }
+    
+    [Benchmark(Baseline = false)]
+    public Volume SumOfVolumesInMilliliter()
+    {
+        return _quantities.Sum(VolumeUnit.Milliliter);
+    }
+}
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithRandomUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithRandomUnitsBenchmarks.cs
index a1b78a6852..75dd4b2fe9 100644
--- a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithRandomUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithRandomUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -14,20 +14,28 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 [SimpleJob(RuntimeMoniker.Net90)]
 public class SumOfVolumesWithRandomUnitsBenchmarks
 {
-    private static readonly double Value = 1.23;
+    private static readonly QuantityValue Value = 1.23;
 
-    private readonly Random _random = new(41);
+    private readonly Random _random = new(42);
     private Volume[] _quantities;
 
     [Params(10, 100, 1000)]
     public int NbOperations { get; set; }
+    
+    [Params(true)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
 
     [GlobalSetup]
     public void PrepareQuantities()
     {
-        _quantities = _random.GetRandomQuantities<Volume, VolumeUnit>(Value, Volume.Units.ToArray(), NbOperations).ToArray();
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
         Quantity.From(Value, Volume.BaseUnit); // TODO we need a better way to "disable" the lazy loading of the _quantitiesByUnitType (QuantityInfoLookup)
-        Console.Out.WriteLine("Quantities prepared: starting unit = {0}", _quantities[0].Unit);
+        
+        _quantities = _random.GetRandomQuantities<Volume, VolumeUnit>(Value, Volume.Units.ToArray(), NbOperations).ToArray();
+        Console.Out.WriteLine("Quantities prepared: starting unit = {0} ({1})", _quantities[0].Unit, _quantities[0].QuantityInfo[_quantities[0].Unit].ConversionToBase);
     }
     
     [Benchmark(Baseline = true)]
@@ -35,7 +43,7 @@ public Volume SumOfVolumes()
     {
         return _quantities.Sum();
     }
-    
+
     [Benchmark(Baseline = false)]
     public Volume SumOfVolumesInBaseUnit()
     {
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithRandomUnitsWithIteratorBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithRandomUnitsWithIteratorBenchmarks.cs
deleted file mode 100644
index 9daf113943..0000000000
--- a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithRandomUnitsWithIteratorBenchmarks.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using System.Linq;
-using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Jobs;
-using UnitsNet.Units;
-
-namespace UnitsNet.Benchmark.Operators.Additions;
-
-[MemoryDiagnoser]
-[SimpleJob(RuntimeMoniker.Net80)]
-public class SumOfVolumesWithRandomUnitsWithIteratorBenchmarks
-{
-    private static readonly double Value = 1.23;
-
-    private readonly Random _random = new(41);
-    private Volume[] _quantities;
-
-    [Params(10, 100, 1000)]
-    public int NbOperations { get; set; }
-
-    [GlobalSetup]
-    public void PrepareQuantities()
-    {
-        _quantities = _random.GetRandomQuantities<Volume, VolumeUnit>(Value, Volume.Units.ToArray(), NbOperations).ToArray();
-        Quantity.From(Value, Volume.BaseUnit); // TODO we need a better way to "disable" the lazy loading of the _quantitiesByUnitType (QuantityInfoLookup)
-        Console.Out.WriteLine("Quantities prepared: starting unit = {0}", _quantities[0].Unit);
-    }
-    
-    [Benchmark(Baseline = true)]
-    public Volume SumOfVolumes()
-    {
-        return _quantities.Sum();
-    }
-}
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSameUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSameUnitsBenchmarks.cs
index 6f28c0e0c5..e707c7c59d 100644
--- a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSameUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSameUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Linq;
@@ -13,12 +13,18 @@ namespace UnitsNet.Benchmark.Operators.Additions;
 [SimpleJob(RuntimeMoniker.Net80)]
 public class SumOfVolumesWithSameUnitsBenchmarks
 {
-    private static readonly double Value = 1.23;
+    private static readonly QuantityValue Value = 1.23;
     
     private Volume[] _quantities;
 
     [Params(10, 1000)]
     public int NbOperations { get; set; }
+    
+    [Params(true)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
 
     [Params(VolumeUnit.CubicMeter, VolumeUnit.Liter, VolumeUnit.Milliliter)]
     public VolumeUnit Unit { get; set; }
@@ -26,6 +32,9 @@ public class SumOfVolumesWithSameUnitsBenchmarks
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        Quantity.From(Value, Volume.BaseUnit); // TODO we need a better way to "disable" the lazy loading of the _quantitiesByUnitType (QuantityInfoLookup)
+        
         _quantities = Enumerable.Range(0, NbOperations).Select(_ => Volume.From(Value, Unit)).ToArray();
     }
 
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSimilarImperialUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSimilarImperialUnitsBenchmarks.cs
deleted file mode 100644
index 224ffdb61f..0000000000
--- a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSimilarImperialUnitsBenchmarks.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using System.Linq;
-using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Jobs;
-using UnitsNet.Units;
-
-namespace UnitsNet.Benchmark.Operators.Additions;
-
-[MemoryDiagnoser]
-[SimpleJob(RuntimeMoniker.Net48)]
-[SimpleJob(RuntimeMoniker.Net90)]
-public class SumOfVolumesWithSimilarImperialUnitsBenchmarks
-{
-    private static readonly double Value = 1.23;
-
-    private readonly Random _random = new(42);
-    private Volume[] _quantities;
-
-    [Params(1000)]
-    public int NbOperations { get; set; }
-
-    [Params(VolumeUnit.ImperialOunce, VolumeUnit.ImperialGallon)]
-    public VolumeUnit StartingUnit { get; set; }
-
-    [GlobalSetup]
-    public void PrepareQuantities()
-    {
-        Quantity.From(Value, Volume.BaseUnit); // TODO we need a better way to "disable" the lazy loading of the _quantitiesByUnitType (QuantityInfoLookup)
-
-        _quantities = _random.GetRandomQuantities<Volume, VolumeUnit>(Value, [VolumeUnit.ImperialOunce, VolumeUnit.ImperialQuart, VolumeUnit.ImperialGallon], NbOperations - 1)
-            .Prepend(Volume.From(Value, StartingUnit)).ToArray();
-        Volume firstQuantity = _quantities[0];
-        Console.Out.WriteLine("Quantities prepared: starting unit = {0}", firstQuantity.Unit);
-    }
-    
-    [Benchmark(Baseline = true)]
-    public Volume SumOfVolumes()
-    {
-        return _quantities.Sum();
-    }
-
-    [Benchmark(Baseline = false)]
-    public Volume SumOfVolumesInBaseUnit()
-    {
-        return _quantities.Sum(Volume.BaseUnit);
-    }
-
-    [Benchmark(Baseline = false)]
-    public Volume SumOfVolumesInStartingUnit()
-    {
-        return _quantities.Sum(StartingUnit);
-    }
-}
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSimilarSIUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSimilarSIUnitsBenchmarks.cs
deleted file mode 100644
index e499491c78..0000000000
--- a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSimilarSIUnitsBenchmarks.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using System.Linq;
-using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Jobs;
-using UnitsNet.Units;
-
-namespace UnitsNet.Benchmark.Operators.Additions;
-
-[MemoryDiagnoser]
-[SimpleJob(RuntimeMoniker.Net48)]
-[SimpleJob(RuntimeMoniker.Net90)]
-public class SumOfVolumesWithSimilarSIUnitsBenchmarks
-{
-    private static readonly double Value = 1.23;
-
-    private readonly Random _random = new(42);
-    private Volume[] _quantities;
-
-    [Params(1000)]
-    public int NbOperations { get; set; }
-
-    [Params(VolumeUnit.Milliliter, VolumeUnit.Liter)]
-    public VolumeUnit StartingUnit { get; set; }
-
-    [GlobalSetup]
-    public void PrepareQuantities()
-    {
-        Quantity.From(Value, Volume.BaseUnit); // TODO we need a better way to "disable" the lazy loading of the _quantitiesByUnitType (QuantityInfoLookup)
-
-        _quantities = _random.GetRandomQuantities<Volume, VolumeUnit>(Value, [VolumeUnit.Microliter, VolumeUnit.Milliliter, VolumeUnit.Liter], NbOperations - 1)
-            .Prepend(Volume.From(Value, StartingUnit)).ToArray();
-        Volume firstQuantity = _quantities[0];
-        Console.Out.WriteLine("Quantities prepared: starting unit = {0}", firstQuantity.Unit);
-    }
-    
-    [Benchmark(Baseline = true)]
-    public Volume SumOfVolumes()
-    {
-        return _quantities.Sum();
-    }
-
-    [Benchmark(Baseline = false)]
-    public Volume SumOfVolumesInBaseUnit()
-    {
-        return _quantities.Sum(Volume.BaseUnit);
-    }
-
-    [Benchmark(Baseline = false)]
-    public Volume SumOfVolumesInMilliliter()
-    {
-        return _quantities.Sum(VolumeUnit.Milliliter);
-    }
-}
diff --git a/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSimilarUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSimilarUnitsBenchmarks.cs
new file mode 100644
index 0000000000..558a4e4a32
--- /dev/null
+++ b/UnitsNet.Benchmark/Operators/Additions/SumOfVolumesWithSimilarUnitsBenchmarks.cs
@@ -0,0 +1,116 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UnitsNet.Units;
+
+namespace UnitsNet.Benchmark.Operators.Additions;
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net90)]
+public class SumOfVolumesWithSimilarSIUnitsBenchmarks
+{
+    private static readonly QuantityValue Value = 1.23;
+
+    private readonly Random _random = new(42);
+    private Volume[] _quantities;
+
+    [Params(1000)]
+    public int NbOperations { get; set; }
+    
+    [Params(true)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
+    [Params(VolumeUnit.Milliliter, VolumeUnit.Liter)]
+    public VolumeUnit StartingUnit { get; set; }
+
+    [GlobalSetup]
+    public void PrepareQuantities()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        Quantity.From(Value, Volume.BaseUnit); // TODO we need a better way to "disable" the lazy loading of the _quantitiesByUnitType (QuantityInfoLookup)
+
+        _quantities = _random.GetRandomQuantities<Volume, VolumeUnit>(Value, [VolumeUnit.Microliter, VolumeUnit.Milliliter, VolumeUnit.Liter], NbOperations - 1)
+            .Prepend(Volume.From(Value, StartingUnit)).ToArray();
+        Volume firstQuantity = _quantities[0];
+        Console.Out.WriteLine("Quantities prepared: starting unit = {0} ({1})", firstQuantity.Unit, firstQuantity.QuantityInfo[firstQuantity.Unit].ConversionToBase);
+    }
+    
+    [Benchmark(Baseline = true)]
+    public Volume SumOfVolumes()
+    {
+        return _quantities.Sum();
+    }
+
+    [Benchmark(Baseline = false)]
+    public Volume SumOfVolumesInBaseUnit()
+    {
+        return _quantities.Sum(Volume.BaseUnit);
+    }
+
+    [Benchmark(Baseline = false)]
+    public Volume SumOfVolumesInMilliliter()
+    {
+        return _quantities.Sum(VolumeUnit.Milliliter);
+    }
+}
+
+[MemoryDiagnoser]
+[SimpleJob(RuntimeMoniker.Net48)]
+[SimpleJob(RuntimeMoniker.Net90)]
+public class SumOfVolumesWithSimilarImperialUnitsBenchmarks
+{
+    private static readonly QuantityValue Value = 1.23;
+
+    private readonly Random _random = new(42);
+    private Volume[] _quantities;
+
+    [Params(1000)]
+    public int NbOperations { get; set; }
+    
+    [Params(true)]
+    public bool Frozen { get; set; }
+
+    [Params(ConversionCachingMode.All)]
+    public ConversionCachingMode CachingMode { get; set; }
+
+    [Params(VolumeUnit.ImperialOunce, VolumeUnit.ImperialGallon)]
+    public VolumeUnit StartingUnit { get; set; }
+
+    [GlobalSetup]
+    public void PrepareQuantities()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        Quantity.From(Value, Volume.BaseUnit); // TODO we need a better way to "disable" the lazy loading of the _quantitiesByUnitType (QuantityInfoLookup)
+
+        _quantities = _random.GetRandomQuantities<Volume, VolumeUnit>(Value, [VolumeUnit.ImperialOunce, VolumeUnit.ImperialQuart, VolumeUnit.ImperialGallon], NbOperations - 1)
+            .Prepend(Volume.From(Value, StartingUnit)).ToArray();
+        Volume firstQuantity = _quantities[0];
+        Console.Out.WriteLine("Quantities prepared: starting unit = {0} ({1})", firstQuantity.Unit, firstQuantity.QuantityInfo[firstQuantity.Unit].ConversionToBase);
+    }
+    
+    [Benchmark(Baseline = true)]
+    public Volume SumOfVolumes()
+    {
+        return _quantities.Sum();
+    }
+
+    [Benchmark(Baseline = false)]
+    public Volume SumOfVolumesInBaseUnit()
+    {
+        return _quantities.Sum(Volume.BaseUnit);
+    }
+
+    [Benchmark(Baseline = false)]
+    public Volume SumOfVolumesInStartingUnit()
+    {
+        return _quantities.Sum(StartingUnit);
+    }
+}
diff --git a/UnitsNet.Benchmark/Operators/Divisions/MassDividedByVolumeBenchmarks.cs b/UnitsNet.Benchmark/Operators/Divisions/MassDividedByVolumeBenchmarks.cs
index ff28e8b517..89ae445b35 100644
--- a/UnitsNet.Benchmark/Operators/Divisions/MassDividedByVolumeBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Divisions/MassDividedByVolumeBenchmarks.cs
@@ -1,4 +1,4 @@
-using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using UnitsNet.Units;
 
@@ -9,8 +9,8 @@ namespace UnitsNet.Benchmark.Operators.Divisions;
 [SimpleJob(RuntimeMoniker.Net80)]
 public class MassDividedByVolumeBenchmarks
 {
-    private static readonly double MassValue = 1.23;
-    private static readonly double VolumeValue = 9.42;
+    private static readonly QuantityValue MassValue = 1.23;
+    private static readonly QuantityValue VolumeValue = 9.42;
 
     [Benchmark]
     public Density MassByVolume()
diff --git a/UnitsNet.Benchmark/Operators/Divisions/MassDividedByVolumeWithRandomUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Divisions/MassDividedByVolumeWithRandomUnitsBenchmarks.cs
index 581a282700..dbe38b5de0 100644
--- a/UnitsNet.Benchmark/Operators/Divisions/MassDividedByVolumeWithRandomUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Divisions/MassDividedByVolumeWithRandomUnitsBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -14,18 +14,26 @@ namespace UnitsNet.Benchmark.Operators.Divisions;
 [SimpleJob(RuntimeMoniker.Net80)]
 public class MassDividedByVolumeWithRandomUnitsBenchmarks
 {
-    private static readonly double MassValue = 1.23;
-    private static readonly double VolumeValue = 9.42;
+    private static readonly QuantityValue MassValue = 1.23;
+    private static readonly QuantityValue VolumeValue = 9.42;
 
     private readonly Random _random = new(42);
     private (Mass left, Volume right)[] _operands;
 
     [Params(1000)]
     public int NbOperations { get; set; }
+    
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+    
+    [ParamsAllValues]
+    public ConversionCachingMode CachingMode { get; set; }
 
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        
         _operands = _random.GetRandomQuantities<Mass, MassUnit>(MassValue, Mass.Units.ToArray(), NbOperations)
             .Zip(_random.GetRandomQuantities<Volume, VolumeUnit>(VolumeValue, Volume.Units.ToArray(), NbOperations), (mass, volume) => (volume: mass, density: volume))
             .ToArray();
diff --git a/UnitsNet.Benchmark/Operators/Multiplications/VolumeTimesDensityBenchmarks.cs b/UnitsNet.Benchmark/Operators/Multiplications/VolumeTimesDensityBenchmarks.cs
deleted file mode 100644
index 63faa458c8..0000000000
--- a/UnitsNet.Benchmark/Operators/Multiplications/VolumeTimesDensityBenchmarks.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Jobs;
-using UnitsNet.Units;
-
-namespace UnitsNet.Benchmark.Operators.Multiplications;
-
-[MemoryDiagnoser]
-[SimpleJob(RuntimeMoniker.Net48)]
-[SimpleJob(RuntimeMoniker.Net80)]
-public class VolumeTimesDensityBenchmarks
-{
-    private static readonly double DensityValue = 1.23;
-    private static readonly double VolumeValue = 9.42;
-
-    [Benchmark(Baseline = true)]
-    public Mass VolumeTimesDensity()
-    {
-        Mass result = default;
-        foreach (VolumeUnit volumeUnit in Volume.Units)
-        {
-            var volume = new Volume(VolumeValue, volumeUnit);
-            foreach (DensityUnit densityUnit in Density.Units)
-            {
-                var density = new Density(DensityValue, densityUnit);
-
-                result = volume * density;
-            }
-        }
-
-        return result;
-    }
-    
-    [Benchmark(Baseline = false)]
-    public Mass DensityTimesVolume()
-    {
-        Mass result = default;
-        foreach (VolumeUnit volumeUnit in Volume.Units)
-        {
-            var volume = new Volume(VolumeValue, volumeUnit);
-            foreach (DensityUnit densityUnit in Density.Units)
-            {
-                var density = new Density(DensityValue, densityUnit);
-
-                result = density * volume;
-            }
-        }
-
-        return result;
-    }
-}
diff --git a/UnitsNet.Benchmark/Operators/Multiplications/VolumeTimesDensityWithRandomUnitsBenchmarks.cs b/UnitsNet.Benchmark/Operators/Multiplications/VolumeTimesDensityWithRandomUnitsBenchmarks.cs
index b9e4c2f56b..92eb798e75 100644
--- a/UnitsNet.Benchmark/Operators/Multiplications/VolumeTimesDensityWithRandomUnitsBenchmarks.cs
+++ b/UnitsNet.Benchmark/Operators/Multiplications/VolumeTimesDensityWithRandomUnitsBenchmarks.cs
@@ -1,6 +1,5 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
 using System;
 using System.Linq;
 using BenchmarkDotNet.Attributes;
@@ -11,11 +10,11 @@ namespace UnitsNet.Benchmark.Operators.Multiplications;
 
 [MemoryDiagnoser]
 [SimpleJob(RuntimeMoniker.Net48)]
-[SimpleJob(RuntimeMoniker.Net80)]
+[SimpleJob(RuntimeMoniker.Net90)]
 public class VolumeTimesDensityWithRandomUnitsBenchmarks
 {
-    private static readonly double DensityValue = 1.23;
-    private static readonly double VolumeValue = 9.42;
+    private static readonly QuantityValue DensityValue = 1.23;
+    private static readonly QuantityValue VolumeValue = 9.42;
 
     private readonly Random _random = new Random(42);
     private (Volume volume, Density density)[] _operands;
@@ -23,9 +22,18 @@ public class VolumeTimesDensityWithRandomUnitsBenchmarks
     [Params(1000)]
     public int NbOperations { get; set; }
 
+    [Params(true, false)]
+    public bool Frozen { get; set; }
+    
+    [ParamsAllValues]
+    public ConversionCachingMode CachingMode { get; set; }
+
+
     [GlobalSetup]
     public void PrepareQuantities()
     {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(Frozen, CachingMode)));
+        
         _operands = _random.GetRandomQuantities<Volume, VolumeUnit>(VolumeValue, Volume.Units.ToArray(), NbOperations)
             .Zip(_random.GetRandomQuantities<Density, DensityUnit>(DensityValue, Density.Units.ToArray(), NbOperations),
                 (volume, density) => (volume, density))
diff --git a/UnitsNet.Benchmark/Operators/Powers/SqrtBenchmarks.cs b/UnitsNet.Benchmark/Operators/Powers/SqrtBenchmarks.cs
new file mode 100644
index 0000000000..28928fb793
--- /dev/null
+++ b/UnitsNet.Benchmark/Operators/Powers/SqrtBenchmarks.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using BenchmarkDotNet.Attributes;
+
+namespace UnitsNet.Benchmark.Operators.Powers;
+
+[MemoryDiagnoser]
+// [ShortRunJob]
+// [DryJob]
+public class SqrtBenchmarks {
+    public static IEnumerable<QuantityValue> FractionsToTest => [
+        2,
+        3,
+        QuantityValue.FromTerms(4, 6),
+        12.345m,
+        9187.45m,
+        1024
+    ];
+
+    [Params(15, 30, 45, 90)]
+    public int Accuracy { get; set; }
+    
+    [ParamsSource(nameof(FractionsToTest))]
+    public QuantityValue Fraction { get; set; }
+
+
+    [Benchmark(Baseline = true)]
+    public QuantityValue Sqrt() {
+        return QuantityValue.Sqrt(Accuracy);
+    }
+}
+
diff --git a/UnitsNet.Benchmark/Program.cs b/UnitsNet.Benchmark/Program.cs
index 27e66760b3..6d08fc483a 100644
--- a/UnitsNet.Benchmark/Program.cs
+++ b/UnitsNet.Benchmark/Program.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Reflection;
 using BenchmarkDotNet.Configs;
diff --git a/UnitsNet.Benchmark/UnitsNet.Benchmark.csproj b/UnitsNet.Benchmark/UnitsNet.Benchmark.csproj
index fb5c897b04..a83f15d923 100644
--- a/UnitsNet.Benchmark/UnitsNet.Benchmark.csproj
+++ b/UnitsNet.Benchmark/UnitsNet.Benchmark.csproj
@@ -1,7 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFrameworks>net10.0;net9.0;net48</TargetFrameworks>
+    <TargetFrameworks>net10.0;net9.0</TargetFrameworks>
+    <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(TargetFrameworks);net48</TargetFrameworks>
     <LangVersion>preview</LangVersion>
     <Version>6.0.0.0</Version>
     <AssemblyVersion>6.0.0.0</AssemblyVersion>
@@ -15,6 +16,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\UnitsNet.Serialization.SystemTextJson\UnitsNet.Serialization.SystemTextJson.csproj" />
     <ProjectReference Include="..\UnitsNet\UnitsNet.csproj" />
   </ItemGroup>
 </Project>
diff --git a/UnitsNet.Benchmark/UnitsNetBenchmarks.cs b/UnitsNet.Benchmark/UnitsNetBenchmarks.cs
index 3b34d38ac9..3f07cc6e8b 100644
--- a/UnitsNet.Benchmark/UnitsNetBenchmarks.cs
+++ b/UnitsNet.Benchmark/UnitsNetBenchmarks.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using BenchmarkDotNet.Attributes;
@@ -9,74 +9,130 @@ namespace UnitsNet.Benchmark;
 [MemoryDiagnoser]
 public class UnitsNetBenchmarks
 {
-    private readonly Length _length = Length.FromMeters(3.0);
-    private readonly IQuantity _lengthIQuantity = Length.FromMeters(3.0);
+    private readonly Length _length = Length.FromMeters(3);
+    private readonly IQuantity _lengthIQuantity = Length.FromMeters(3);
+
+    static UnitsNetBenchmarks()
+    {
+        UnitsNetSetup.ConfigureDefaults(builder => builder.WithConverterOptions(new QuantityConverterBuildOptions(true, ConversionCachingMode.All)));
+    }
 
     [Benchmark]
     [BenchmarkCategory("Construction")]
-    public Length Constructor() => new Length(3.0, LengthUnit.Meter);
+    public Length Constructor()
+    {
+        return new Length(3, LengthUnit.Meter);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Construction")]
-    public Length Constructor_SI() => new Length(3.0, UnitSystem.SI);
+    public Length Constructor_SI()
+    {
+        return new Length(3, UnitSystem.SI);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Construction")]
-    public Length FromMethod() => Length.FromMeters(3.0);
+    public Length FromMethod()
+    {
+        return Length.FromMeters(3);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Transformation")]
-    public double ToProperty() => _length.Centimeters;
+    public QuantityValue ToProperty()
+    {
+        return _length.Centimeters;
+    }
 
     [Benchmark]
     [BenchmarkCategory("Transformation, Value")]
-    public double As() => _length.As(LengthUnit.Centimeter);
+    public QuantityValue As()
+    {
+        return _length.As(LengthUnit.Centimeter);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Transformation, Value")]
-    public double As_SI() => _length.As(UnitSystem.SI);
+    public QuantityValue As_SI()
+    {
+        return _length.As(UnitSystem.SI);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Transformation, Quantity")]
-    public Length ToUnit() => _length.ToUnit(LengthUnit.Centimeter);
+    public Length ToUnit()
+    {
+        return _length.ToUnit(LengthUnit.Centimeter);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Transformation, Quantity")]
-    public Length ToUnit_SI() => _length.ToUnit(UnitSystem.SI);
+    public Length ToUnit_SI()
+    {
+        return _length.ToUnit(UnitSystem.SI);
+    }
 
     [Benchmark]
     [BenchmarkCategory("ToString")]
-    public string ToStringTest() => _length.ToString();
+    public string ToStringTest()
+    {
+        return _length.ToString();
+    }
 
     [Benchmark]
     [BenchmarkCategory("Parsing")]
-    public Length Parse() => Length.Parse("3.0 m");
+    public Length Parse()
+    {
+        return Length.Parse("3.0 m");
+    }
 
     [Benchmark]
     [BenchmarkCategory("Parsing")]
-    public bool TryParseValid() => Length.TryParse("3.0 m", out _);
+    public bool TryParseValid()
+    {
+        return Length.TryParse("3.0 m", out _);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Parsing")]
-    public bool TryParseInvalid() => Length.TryParse("3.0 zoom", out _);
+    public bool TryParseInvalid()
+    {
+        return Length.TryParse("3.0 zoom", out _);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Construction")]
-    public IQuantity QuantityFrom() => Quantity.From(3.0, LengthUnit.Meter);
+    public IQuantity QuantityFrom()
+    {
+        return Quantity.From(3, LengthUnit.Meter);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Transformation, Value")]
-    public double IQuantity_As() => _lengthIQuantity.As(LengthUnit.Centimeter);
+    public QuantityValue IQuantity_As()
+    {
+        return _lengthIQuantity.As(LengthUnit.Centimeter);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Transformation, Value")]
-    public double IQuantity_As_SI() => _lengthIQuantity.As(UnitSystem.SI);
+    public QuantityValue IQuantity_As_SI()
+    {
+        return _lengthIQuantity.As(UnitSystem.SI);
+    }
 
     [Benchmark]
     [BenchmarkCategory("Transformation, Quantity")]
-    public IQuantity IQuantity_ToUnit() => _lengthIQuantity.ToUnit(LengthUnit.Centimeter);
+    public IQuantity IQuantity_ToUnit()
+    {
+        return _lengthIQuantity.ToUnit(LengthUnit.Centimeter);
+    }
 
     [Benchmark]
     [BenchmarkCategory("ToString")]
-    public string IQuantity_ToStringTest() => _lengthIQuantity.ToString();
+    public string IQuantity_ToStringTest()
+    {
+        return _lengthIQuantity.ToString();
+    }
 }
diff --git a/UnitsNet.GlobalSetup.DefaultFirst.Tests/UnitsNet.GlobalSetup.DefaultFirst.Tests.csproj b/UnitsNet.GlobalSetup.DefaultFirst.Tests/UnitsNet.GlobalSetup.DefaultFirst.Tests.csproj
new file mode 100644
index 0000000000..d4b2b5d35d
--- /dev/null
+++ b/UnitsNet.GlobalSetup.DefaultFirst.Tests/UnitsNet.GlobalSetup.DefaultFirst.Tests.csproj
@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(TargetFrameworks);net48</TargetFrameworks>
+    <LangVersion>latest</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsTestProject>true</IsTestProject>
+    <Nullable>enable</Nullable>
+    <TestFramework>xunit</TestFramework>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>../UnitsNet.snk</AssemblyOriginatorKeyFile>
+    <DelaySign>false</DelaySign>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../UnitsNet/UnitsNet.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/UnitsNet.GlobalSetup.DefaultFirst.Tests/UnitsNetSetupDefaultFirstTests.cs b/UnitsNet.GlobalSetup.DefaultFirst.Tests/UnitsNetSetupDefaultFirstTests.cs
new file mode 100644
index 0000000000..252f55db61
--- /dev/null
+++ b/UnitsNet.GlobalSetup.DefaultFirst.Tests/UnitsNetSetupDefaultFirstTests.cs
@@ -0,0 +1,27 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using Xunit;
+
+namespace UnitsNet.GlobalSetup.DefaultFirst.Tests;
+
+/// <summary>
+///     Tests configuring the process-wide default setup after first use.
+/// </summary>
+/// <remarks>
+///     This assembly intentionally contains a single test because <see cref="UnitsNetSetup.Default" /> cannot be reset.
+/// </remarks>
+public class UnitsNetSetupDefaultFirstTests
+{
+    [Fact]
+    public void ConfigureDefaults_AfterDefaultIsCreated_ThrowsInvalidOperationException()
+    {
+        UnitsNetSetup originalDefault = UnitsNetSetup.Default;
+        bool configurationInvoked = false;
+
+        Assert.Throws<InvalidOperationException>(() => UnitsNetSetup.ConfigureDefaults(_ => configurationInvoked = true));
+
+        Assert.False(configurationInvoked);
+        Assert.Same(originalDefault, UnitsNetSetup.Default);
+    }
+}
diff --git a/UnitsNet.GlobalSetup.Tests/UnitsNet.GlobalSetup.Tests.csproj b/UnitsNet.GlobalSetup.Tests/UnitsNet.GlobalSetup.Tests.csproj
new file mode 100644
index 0000000000..d4b2b5d35d
--- /dev/null
+++ b/UnitsNet.GlobalSetup.Tests/UnitsNet.GlobalSetup.Tests.csproj
@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(TargetFrameworks);net48</TargetFrameworks>
+    <LangVersion>latest</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsTestProject>true</IsTestProject>
+    <Nullable>enable</Nullable>
+    <TestFramework>xunit</TestFramework>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>../UnitsNet.snk</AssemblyOriginatorKeyFile>
+    <DelaySign>false</DelaySign>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../UnitsNet/UnitsNet.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/UnitsNet.GlobalSetup.Tests/UnitsNetSetupGlobalConfigurationTests.cs b/UnitsNet.GlobalSetup.Tests/UnitsNetSetupGlobalConfigurationTests.cs
new file mode 100644
index 0000000000..961acb2bdf
--- /dev/null
+++ b/UnitsNet.GlobalSetup.Tests/UnitsNetSetupGlobalConfigurationTests.cs
@@ -0,0 +1,33 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.GlobalSetup.Tests;
+
+/// <summary>
+///     Tests configuring the process-wide default setup before first use.
+/// </summary>
+/// <remarks>
+///     This assembly intentionally contains a single test because <see cref="UnitsNetSetup.Default" /> cannot be reset.
+///     Keep additional global-configuration scenarios isolated in separate test processes.
+/// </remarks>
+public class UnitsNetSetupGlobalConfigurationTests
+{
+    [Fact]
+    public void ConfigureDefaults_BeforeFirstUse_ConfiguresAndFreezesDefaultSetup()
+    {
+        Assert.Equal("configuration",
+            Assert.Throws<ArgumentNullException>(() => UnitsNetSetup.ConfigureDefaults(null!)).ParamName);
+
+        UnitsNetSetup configured = UnitsNetSetup.ConfigureDefaults(builder => builder.WithQuantities([Mass.Info]));
+
+        Assert.Same(configured, UnitsNetSetup.Default);
+        Assert.Same(configured.UnitAbbreviations, UnitAbbreviationsCache.Default);
+        Assert.Same(configured.UnitParser, UnitParser.Default);
+        Assert.Equal([Mass.Info], configured.Quantities.Infos);
+        Assert.Throws<UnitNotFoundException>(() => configured.UnitParser.Parse<LengthUnit>("m"));
+        Assert.Throws<InvalidOperationException>(() => UnitsNetSetup.ConfigureDefaults(_ => { }));
+    }
+}
diff --git a/UnitsNet.Modular.slnx b/UnitsNet.Modular.slnx
new file mode 100644
index 0000000000..d3befa1b67
--- /dev/null
+++ b/UnitsNet.Modular.slnx
@@ -0,0 +1,82 @@
+<Solution>
+  <Configurations>
+    <Platform Name="ProjectReferences" />
+    <Platform Name="LocalPackages" />
+    <Platform Name="PublishedPackages" />
+  </Configurations>
+  <!-- Core and test projects remain AnyCPU; only samples map dependency-mode platforms. -->
+  <Project Path="UnitsNet.Modular/UnitsNet.Modular/UnitsNet.Modular.csproj" />
+  <Project Path="UnitsNet.Modular/UnitsNet.Modular.Generator/UnitsNet.Modular.Generator.csproj" />
+  <Project Path="UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/UnitsNet.Modular.Generator.Tests.csproj" />
+  <Project Path="UnitsNet.Modular/UnitsNet.Modular.Tests/UnitsNet.Modular.Tests.csproj" />
+  <Folder Name="/_Files/">
+    <File Path="UnitsNet.Modular/ARCHITECTURE.md" />
+    <File Path="UnitsNet.Modular/Directory.Build.props" />
+    <File Path="UnitsNet.Modular/Directory.Build.targets" />
+    <File Path="UnitsNet.Modular/Directory.Packages.props" />
+    <File Path="UnitsNet.Modular/MIGRATION.md" />
+    <File Path="UnitsNet.Modular/README.md" />
+    <File Path="UnitsNet.Modular/THIRD-PARTY-NOTICES.md" />
+    <File Path="UnitsNet.Modular/UnitsNet.Modular.Versioning.props" />
+  </Folder>
+  <Project Path="UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/UnitsNet.Modular.Compatibility.Tests.csproj" />
+  <Folder Name="/Samples/">
+    <File Path="UnitsNet.Modular/Samples/README.md" />
+    <File Path="UnitsNet.Modular/Samples/refresh-local-packages.ps1" />
+    <Project Path="UnitsNet.Modular/Samples/GettingStartedSample/GettingStartedSample.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+    <Project Path="UnitsNet.Modular/Samples/QuantitySelectionSample/QuantitySelectionSample.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+    <Project Path="UnitsNet.Modular/Samples/CustomQuantitySample/CustomQuantitySample.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+    <Project Path="UnitsNet.Modular/Samples/ModularPlayground/ModularPlayground.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+  </Folder>
+  <Folder Name="/Samples/Profiles/">
+    <Project Path="UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/AllSiProfileSample.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+  </Folder>
+  <Folder Name="/Samples/Shared Units Library/">
+    <Project Path="UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Units/SharedUnitsLibrarySample.Units.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+    <Project Path="UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Domain/SharedUnitsLibrarySample.Domain.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+    <Project Path="UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/SharedUnitsLibrarySample.App.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+    <Project Path="UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Fictional.Measurements.Definitions.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+    <File Path="UnitsNet.Modular/Samples/SharedUnitsLibrarySample/README.md" />
+  </Folder>
+  <Folder Name="/Tests/" />
+  <Folder Name="/Tests/Compatibility fixtures/">
+    <Project Path="UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Generated/UnitsNet.Modular.Compatibility.GeneratedFixture.csproj" />
+    <Project Path="UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Legacy/UnitsNet.Modular.Compatibility.LegacyFixture.csproj" />
+  </Folder>
+</Solution>
diff --git a/UnitsNet.Modular/ARCHITECTURE.md b/UnitsNet.Modular/ARCHITECTURE.md
new file mode 100644
index 0000000000..49aab465e7
--- /dev/null
+++ b/UnitsNet.Modular/ARCHITECTURE.md
@@ -0,0 +1,600 @@
+# UnitsNet Modular proof-of-concept architecture
+
+## Goal
+
+UnitsNet.Modular explores a compile-time composition model for a future UnitsNet architecture. A module
+author selects only the quantities and units that belong in an assembly, while generated quantity
+structs keep the strongly typed API and share a small runtime for conversion, parsing, and
+formatting.
+
+The generator, runtime, and generated types do not reuse the existing UnitsNet runtime or
+code-generation model. The small runtime and its clean-slate quantity contracts live together in
+the `UnitsNet.Modular` assembly. A future investigation may identify contracts worth sharing with
+UnitsNet, but the proof of concept does not introduce a separate abstraction package before that
+boundary has demonstrated value.
+
+The experiment is inspired by
+[the modular-package experiment](https://github.com/angularsen/UnitsNet/pull/1181),
+[the source-generator discussion](https://github.com/angularsen/UnitsNet/issues/902), and
+the current
+[Roslyn source-generator model](https://github.com/dotnet/roslyn/blob/main/docs/features/source-generators.cookbook.md).
+
+## Feasibility conclusions
+
+The idea is viable if the unit of composition is a **consumer-owned module assembly**:
+
+1. A module declares an interface that selects quantity specs.
+2. One incremental generator resolves the selection and emits only the selected quantity and unit
+   types into that module.
+3. The application's domain, persistence, UI, and service projects reference that assembly normally.
+
+The module boundary is important because a generated public type has the identity of the assembly
+into which it is generated. If two unrelated assemblies both generate `Length`, those are distinct
+CLR types. An application should therefore generate its quantities once in a shared internal
+library, then reference that library everywhere else in the application.
+
+Third parties publish **definition packages**, not compiled quantity structs. A definition package
+contains JSON definitions, localizations, relationships, and small public quantity specs. The
+consumer remains responsible for selecting and compiling those definitions into its module.
+
+Roslyn generators are additive and unordered; a generator cannot consume another generator's output
+in the same compilation. Consequently, UnitsNet.Modular uses one generator for built-in and custom
+definitions. Stable public authoring contracts live in the UnitsNet.Modular runtime so definition-package
+assemblies can reference one identity. Built-in catalog specs and profiles are internal bootstrap
+source emitted during post-initialization.
+
+## Namespace ownership
+
+The package and assembly retain the `UnitsNet.Modular` name, while the runtime project's default
+namespace is `UnitsNet`. Namespace ownership follows the role of each type:
+
+- general quantity contracts, metadata, unit-system policy, and quantity math use `UnitsNet`;
+- built-in unit enums use `UnitsNet.Units`;
+- module authoring contracts use `UnitsNet.Modular`;
+- built-in specs and reusable profiles use `UnitsNet.Modular.BuiltIns` and
+  `UnitsNet.Modular.Profiles`;
+- the immutable registry and generated module singleton use `UnitsNet`; and
+- public implementation types referenced only by emitted code use
+  `UnitsNet.Modular.SourceGen` and are hidden from IntelliSense.
+
+This keeps ordinary quantity source close to legacy UnitsNet while making modular composition and
+generator plumbing explicit. It does not provide binary compatibility: the legacy and Modular
+contracts come from different assemblies. Referencing the `UnitsNet` and `UnitsNet.Modular`
+packages together in one consumer project is unsupported.
+
+## Developer experience
+
+Authoring types use role-specific suffixes: quantity specifications are `*Spec`, reusable unit
+filters are `*UnitSet`, and reusable selection groups are `*Profile`. This keeps an input such as
+`LengthSpec` visually distinct from the generated `Length` quantity and `LengthUnit` enum. Each
+built-in or custom spec identifies its definition through `[QuantitySpec]`; the generator does not infer
+identity from the spec's namespace or type name.
+
+Select every unit for a built-in quantity by inheriting `IInclude<TQuantitySpec>`:
+
+```csharp
+using UnitsNet.Modular.BuiltIns;
+using UnitsNet.Modular;
+
+[UnitsNetModule]
+internal interface EngineeringUnits :
+    IInclude<LengthSpec>,
+    IInclude<TemperatureSpec>,
+    IInclude<TemperatureDeltaSpec>,
+    IInclude<InformationSpec>
+{
+}
+```
+
+Built-in specs generate a source-compatible concrete surface by default: quantities use
+`UnitsNet` and unit enums use `UnitsNet.Units`:
+
+```csharp
+[UnitsNetModule]
+internal interface CompatibilityUnits :
+    IInclude<LengthSpec>,
+    IInclude<TemperatureSpec>,
+    IInclude<TemperatureDeltaSpec>;
+```
+
+An explicit module target namespace remains available for side-by-side experiments or applications
+that want every selected built-in and custom definition under one namespace.
+
+Select units with a regular expression by defining a named unit set:
+
+```csharp
+[UnitSet("regex:.*Meter$")]
+internal interface MeterUnitSet;
+
+[UnitsNetModule]
+internal interface LeanUnits :
+    IInclude<LengthSpec, MeterUnitSet>
+{
+}
+```
+
+Patterns prefixed with `regex:` use case-insensitive, culture-invariant regular expressions with a
+timeout. Patterns prefixed with `glob:` support `*`, and bare patterns retain glob behavior for
+convenience. The generator always includes the base unit so every selected quantity remains
+convertible. It reports compile-time diagnostics for invalid expressions and patterns that match no
+units.
+
+Quantity profiles compose reusable catalog selections:
+
+```csharp
+using UnitsNet.Modular.Profiles;
+
+[UnitsNetModule]
+internal interface ApplicationUnits :
+    IIncludeProfile<AllQuantitiesProfile>,
+    IInclude<HowMuchSpec>;
+```
+
+`AllQuantitiesProfile` contains the built-in catalog, while `AllSiProfile` selects the SI
+relationship sample.
+Consumers can define profiles from
+`IInclude<TQuantitySpec>` and nest them through `IIncludeProfile<TProfile>`. Profile selections are
+defaults: direct selections on the module override a profile's unit selection for the same quantity.
+The recommended application architecture has one module marker in its shared units project. Profiles
+and direct includes compose the complete generated surface at that boundary.
+
+Custom quantities use JSON definition files. Consumers should include them with Roslyn's native
+`AdditionalFiles` item:
+
+```xml
+<ItemGroup>
+  <AdditionalFiles Include="HowMuch.unitsnet.json"
+                   UnitsNetDefinition="true" />
+</ItemGroup>
+```
+
+The metadata identifies ordinary filenames such as `Length.json` that cannot be recognized by
+extension alone. Files named `*.unitsnet.json` are also recognized by convention, but explicit
+metadata documents their role and works for either naming scheme.
+
+Package assets under `buildTransitive/` retain `UnitsNetDefinition` and `UnitsNetRelation` as
+convenience aliases. A `.targets` file maps those custom items to compiler `AdditionalFiles`, while
+a `.props` file makes their metadata compiler-visible. They work with command-line MSBuild, but
+native `AdditionalFiles` is the portable public syntax because some IDE project models, including
+Rider, ignore custom build actions before running their design-time Roslyn host.
+
+The JSON shape follows the existing UnitsNet quantity definitions and adds an optional `Namespace`
+for stable third-party identity; it defaults to `UnitsNet`, allowing files such as the existing
+`Length.json` to be consumed unchanged. It supports localized abbreviations, prefix expansion, and
+`FromUnitToBaseFunc`/`FromBaseToUnitFunc` expressions. A minimal quantity spec binds type-safe module
+selection to the JSON's logical `Namespace.Name` ID:
+
+```csharp
+namespace Fictional;
+
+using UnitsNet.Modular;
+
+[QuantitySpec("Fictional.Measurements.HowMuch")]
+public interface HowMuchSpec;
+
+[UnitsNetModule]
+internal interface FictionalUnits : IInclude<HowMuchSpec>;
+```
+
+Definitions are read with `System.Text.Json`. Its .NET Standard support assemblies are bundled
+privately beside the analyzer, while the generated/runtime library has no JSON-library dependency.
+Conversion expressions are parsed as C# expressions and restricted to numeric literals, `x`,
+arithmetic operators, parentheses, `Math.PI`, `Math.E`, and an allowlist of numeric `Math`
+functions.
+The generator emits the validated expressions directly into conversion switches; it does not compile
+expressions or use reflection at runtime. A definition package contains public quantity specs and JSON
+definitions while the module that selects them owns the generated runtime types. Its package-local
+`build/*.props` file exposes the JSON as compiler `AdditionalFiles` only to the project that
+directly references it.
+
+## Projects
+
+- `UnitsNet.Modular`: modern quantity contracts, immutable metadata, conversion, parsing,
+  formatting, module discovery, registry behavior, serialization integration, and source-generator
+  packaging.
+- `UnitsNet.Modular.Generator`: the incremental generator, spec bootstrap source, built-in catalog,
+  diagnostics, and emitters.
+- `UnitsNet.Modular.Generator.Tests`: generator-driver coverage for diagnostics, stable output,
+  incrementality, and all relationship shapes.
+- `UnitsNet.Modular.Tests`: generated API and runtime behavior tests.
+- `UnitsNet.Modular.Compatibility.Tests`: linked-output, full-catalog public API, enum, conversion,
+  parsing, formatting, behavior, and registry comparisons against unchanged UnitsNet. Private
+  fixture projects compile the same compatibility scenario against each implementation.
+- `Samples/GettingStartedSample`: the two-file quick start with
+  Length, Duration, Speed, and their generated relationship.
+- `Samples/QuantitySelectionSample`: filtered Length and Information unit sets.
+- `Samples/CustomQuantitySample`: a fictional `HowMuch` quantity in its own namespace.
+- `Samples/Profiles/AllSiProfileSample`: the `AllSiProfile` relationship chain from Length and
+  Duration through Speed, Acceleration, Force, Pressure, Energy, and Power.
+- `Samples/ModularPlayground`: a broad interactive scenario covering parsing, metadata,
+  serialization, relationships, and an application-specific definition.
+- `Samples/SharedUnitsLibrarySample`: one generated quantity library shared by domain and app
+  projects, plus a packable definition provider containing specs, JSON, localization, and
+  structured relationships.
+
+Every sample uses the solution platform as its dependency mode. `ProjectReferences` exercises the
+current runtime and generator projects, `LocalPackages` crosses the repository-local NuGet boundary,
+and `PublishedPackages` consumes the pinned public package. This keeps dependency source separate
+from the normal Debug and Release configurations without duplicating scenario projects.
+
+The compatibility test project uses aliased references to compare both implementations' selected
+public API and unit names without introducing concrete-type ambiguity. It compares against the
+unchanged UnitsNet project. Whether any contracts can genuinely be shared with UnitsNet remains a
+separate investigation. The fixtures participate only in the Modular compatibility test graph and
+do not participate in the existing UnitsNet solution.
+
+## Compatibility boundaries
+
+The linked-source test fixtures establish source compatibility for factories, properties, unit enums,
+conversions, parsing, formatting, collection extensions, and operators. Catalog-wide compatibility
+tests compare all 129 generated quantities and their unit enums with the unchanged UnitsNet source.
+They exercise every unit's conversion through its base unit, base-unit formatting and parsing,
+default and strict equality behavior, affine and logarithmic arithmetic, and representative
+exceptions.
+
+The declared-public-surface gate compares constructors, properties, methods, and operators. Every
+accepted difference is categorized in the test: legacy mutable metadata and setup APIs that are not
+part of the clean architecture, or a remaining quantity-specific handwritten UnitsNet API.
+`Duration`/`TimeSpan` interoperability, `Area` circle construction, relation-backed mechanics and
+chemistry helpers, concentration conversions, apparent-power division, and combustion energy are
+represented as explicit built-in API augmentations rather than silent exceptions. This also
+covers immutable dBV/dBW reference conversions, scalar compound-unit construction, and the
+`FeetInches`, `StonePounds`, and `ReferencePressure` companion types. The generator reads
+augmentation and companion kinds plus quantity and unit dependencies from immutable embedded data;
+dependent APIs are emitted only when all participating quantities and constituent units are
+selected. Companion types remain an explicit opt-in with a dedicated emitter; their presence
+is never inferred from a quantity or its units. This inventory is a migration tool, not a claim that
+every legacy API belongs in the final architecture.
+
+Two handwritten APIs remain intentionally excluded. `Length.ParseFeetInches` and
+`TryParseFeetInches` depend on a specialized text grammar, while `Pressure.FromElevation` and
+`ToElevation` implement an empirical atmosphere model rather than unit conversion. The
+compatibility suite requires every exclusion to identify an existing UnitsNet member and provide a
+non-empty rationale, so stale exclusions fail the test.
+
+`UnitsNet.IQuantity<TValue>` exposes the stored numeric value and a type-erased enum unit.
+`UnitsNet.IQuantity<TSelf, TUnit, TValue>` adds only the static construction and conversion
+primitives needed to implement reusable `As()` and `ToUnit()` behavior, while refining the stored
+unit to its concrete enum type. The `double`-based `IQuantity<TSelf, TUnit>` composite adds the
+static canonical `Info` metadata required from every generated quantity. This follows the familiar
+UnitsNet self-type/unit shape without putting metadata on each quantity instance. A generic library
+can therefore consume, create, convert, or inspect generated implementations through one Modular
+contract.
+
+The capability hierarchy adapts UnitsNet's proven modern generic design without carrying over
+`UnitKey`, mutable quantity metadata, setup registries, or obsolete compatibility members:
+
+- `ILinearQuantity<TSelf, TUnit>` advertises conventional arithmetic and additive zero;
+- `IAffineQuantity<TSelf, TUnit, TOffset>` identifies offset conversions and expresses differences
+  through a linear offset quantity without claiming conventional same-quantity arithmetic;
+- `ILogarithmicQuantity<TSelf, TUnit>` identifies logarithmic arithmetic and scaling without
+  claiming conventional generic-math semantics.
+
+`QuantityMath.Sum` and `QuantityMath.Average` use those contracts for reusable mixed-unit linear
+algorithms over generated quantities. `AffineQuantityMath.Average` averages affine values in an
+explicit target unit. `LogarithmicQuantityMath` supplies logarithmic sum and mean semantics.
+Generated concrete extension methods expose these algorithms as `Sum`, `Average`,
+`ArithmeticMean`, `GeometricMean`, `Abs`, and tolerance-aware `Equals`, so normal application code
+does not need generic call syntax. A separate integration branch validates these algorithms with
+UnitsNet v6. The capability layer remains `double`-based while numeric storage abstraction is
+evaluated separately.
+
+`QuantityId` belongs to the canonical `Info` object rather than each value instance. Base-unit
+conversion is derived behavior and is intentionally not stored on each
+instance. Generated relationships and equality use internal conversion helpers; reusable public
+conversion behavior belongs in the self-typed quantity contract and is backed by immutable
+definition metadata. There is no global conversion registry: compile-time specs and definition
+metadata generate the selected converters directly into the consumer-owned assembly. Internal base
+values are sufficient for relationships because all participating quantities are generated into
+that assembly; independently compiled modules cannot acquire cross-module operators.
+
+Semantic IDs are namespace-qualified (`Namespace.Name`) and definition-package authors should use
+a namespace they own. This makes IDs stable and globally meaningful at registry and serialization
+boundaries without adding vendor state to each quantity value.
+
+Each module does have an immutable generated **discovery registry**. It describes only that
+module's selected quantities and supports lookup by semantic ID, quantity name, or generated CLR
+type. Each generated quantity exposes its canonical strongly typed
+`QuantityInfo<TQuantity, TUnit>` through static `Info`; quantity instances do not duplicate or carry
+metadata. `Info` owns the stable ID, name, base-unit metadata, generated unit metadata, and base
+dimensions. `Info.BaseUnit` and every item in `Info.Units` are `UnitInfo<TUnit>` objects, whose
+`Value` property returns the actual enum value. This avoids parallel raw-enum and metadata
+collections. Common value behavior such as `Value`, `Unit`, `Zero`, `From`, `Convert`, `As`,
+`ToUnit`, parsing, and formatting remains on the quantity type.
+
+The same `Info` object implements the type-erased `IQuantityDescriptor` contract used by the
+registry, so there is no parallel quantity-metadata graph. The descriptor exists for heterogeneous
+runtime workflows where the quantity type is not statically known; it exposes units,
+abbreviations, base dimensions, construction, conversion, parsing, formatting data, and stored
+value/unit access. Frozen dictionaries make lookup immutable after module initialization. This
+registry is not a source of conversion policy and is not a replacement for the old mutable
+`UnitsNetSetup` model.
+
+`BaseDimensions` and the base unit are deliberately available through `Info` only: both are central
+to generated conversion and discovery but uncommon in ordinary strongly typed application code.
+`BaseUnitInfo` and `UnitInfos` are hidden source-compatibility aliases on `QuantityInfo`; new code
+uses `BaseUnit` and `Units`. Public contracts needed only so generated code can call the runtime,
+such as `UnitsNet.Modular.SourceGen.IQuantityMetadata<TUnit>` and
+`UnitsNet.Modular.SourceGen.QuantityOperations`, live in the clearly separated `SourceGen`
+namespace, are hidden from IntelliSense, and are documented as generator infrastructure. Consumer
+code should use the generated quantity API instead.
+
+The same descriptors back a generated System.Text.Json converter factory. Its quantity dispatch is
+emitted as direct type checks and generic converter construction, with no runtime
+`MakeGenericType`, assembly scan, or mutable registration. It is therefore suitable for trimming
+and Native AOT. Serialized data still forms an application-owned compatibility boundary; the
+registry does not make independently generated CLR types binary compatible.
+
+UnitsNet.Modular deliberately exposes its clean-slate contracts under the familiar `UnitsNet`
+namespace. This improves source compatibility but does not reproduce legacy interface identity:
+the contracts come from a different assembly and have deliberately slimmer shapes. Exact binary
+identity would require a canonical shared assembly coordinated with UnitsNet itself.
+
+The legacy compatibility review concluded that common read-only dynamic workflows belong on the
+immutable module registry, with a thin owner-scoped `Quantity` facade for familiar static call
+shapes. The facade returns `UnitsNet.IQuantity<double>` and delegates to its exposed
+`Quantity.Registry`; it does not introduce a second catalog. Construction, type-directed parsing,
+metadata discovery, and non-throwing input paths are tested against their UnitsNet counterparts.
+
+The review rejected mutable legacy behavior, not static convenience. `UnitsNetSetup`, mutable
+conversion registration, abbreviation-cache mutation, and mutable global defaults express
+process-wide runtime policy that conflicts with consumer-owned compile-time definitions.
+The Modular runtime instead provides immutable, owner-neutral `UnitsNet.UnitSystem` and
+`UnitsNet.BaseUnits` values that are passed explicitly to generated constructors, `From`, `As`,
+and `ToUnit`, or to the facade,
+descriptors, and registry. Resolution is restricted to selected units. Generated constituent
+metadata and SI selection are checked catalog-wide against UnitsNet, including exponent-aware
+prefix metadata and legacy first-match ordering. `UnitKey` is unnecessary in strongly typed code;
+dynamic and serialized boundaries use semantic quantity IDs plus invariant unit names. The
+complete workflow matrix is in `MIGRATION.md`.
+
+The experiment does not provide binary compatibility between concrete quantity structs. CLR type
+identity includes the defining assembly, so `UnitsNet.Length` from `UnitsNet.dll` and a type with
+the same full name generated into an application assembly are not assignment-compatible.
+Projects inside one application share its consumer-owned module. Independent applications exchange
+shared contracts or explicit serialized data instead of assuming their generated structs have the
+same identity.
+
+The runtime, contracts, metadata, and bundled generator ship as one signed `UnitsNet.Modular`
+assembly/package boundary. This keeps installation and local development simple while the
+architecture is still being evaluated. A separate contracts package should be extracted only if a
+future legacy/modular integration finds a genuinely shared interface set or another independently
+versioned consumer of the runtime contracts.
+
+Samples built with the `LocalPackages` platform import one repository-only MSBuild target that
+incrementally packs changed UnitsNet.Modular or generator sources before restore, then refreshes
+their floating `6.0.0-local.dev.*` dependencies before compilation. The shared-units library
+registers its fictional definition provider as an additional package, so the automation packs the
+runtime first and the definition package second with the same unique version. Restore is restricted
+to the shared `Artifacts/Nugets` development feed and cannot fall back to a published package.
+
+The dependency can also be invoked explicitly:
+
+```powershell
+dotnet msbuild `
+  UnitsNet.Modular/Samples/CustomQuantitySample/CustomQuantitySample.csproj `
+  -p:Platform=LocalPackages `
+  -t:UpdateLocalUnitsNetModularPackages
+```
+
+This repository-only automation defaults on whenever `LocalPackages` is selected. Set
+`UnitsNetModularSampleUpdateLocalPackagesOnBuild=false` to use packages already present in the local
+feed. The older singular property and target names remain aliases for existing local commands.
+
+`RepositoryLocalNuGetFeed` in the root `Directory.Build.props` gives every repository project the
+shared `Artifacts/Nugets` path. The repository-level `NuGet.Config` exposes it to solution-wide IDE
+package tooling, and generated packages remain gitignored. The UnitsNet.Modular package project supports
+a plain `dotnet pack UnitsNet.Modular/UnitsNet.Modular/UnitsNet.Modular.csproj`, which creates a unique
+`6.0.0-local.dev.*` package in that feed for the real-consumer samples. The dedicated `dev`
+identifier prevents another local prerelease label from shadowing the floating dependency. Local
+development versions are prereleases, so enable prerelease packages and refresh the feed in the IDE
+after packing. Pass
+`-p:UnitsNetModularPackForPublish=true` to create the MinVer-derived publish version instead; CI sets
+this explicitly.
+
+Run the minimal package-facing sample from the repository root:
+
+```powershell
+pwsh UnitsNet.Modular/Samples/GettingStartedSample/run.ps1
+```
+
+The script selects `Debug | LocalPackages`, provides an isolated package cache, and lets the sample
+build dependency pack and restore before executing the consumer.
+
+## Versioning and CI
+
+The `UnitsNet.Modular` package has one MinVer release stream with the tag prefix
+`UnitsNet.Modular/`, a minimum version of `6.0`, and `alpha.0` as the default prerelease identifiers.
+Existing `UnitsNet/*`, `JsonNet/*`, and unprefixed tags are ignored. A release tag such as
+`UnitsNet.Modular/6.0.0-alpha.1` or `UnitsNet.Modular/6.0.0` becomes the exact package version.
+Untagged builds receive a MinVer-generated alpha version with commit height.
+`UnitsNet.Modular.Generator` remains an internal, non-packable project because the analyzer and its
+private dependencies are bundled into the Modular package.
+
+UnitsNet and UnitsNet.Modular share major version 6 to communicate the catalog generation they
+belong to. UnitsNet retains its existing explicitly controlled version, while UnitsNet.Modular
+advances independently. Third-party definition packages have independent versions; the fictional
+sample remains at 1.x when packed directly.
+
+Create an annotated release tag on a green `master` commit with the Modular bump script, then push
+the tag:
+
+```powershell
+pwsh Build/bump-version-UnitsNet.Modular.ps1 -Bump suffix
+git push origin UnitsNet.Modular/6.0.0-alpha.2
+```
+
+Use `minor` or `patch` instead of `suffix` to bump that numeric component and remove the prerelease
+suffix, matching the existing UnitsNet release scripts. After a stable release, `suffix` starts the
+next patch prerelease at `alpha.1`, matching MinVer's post-release version range. Pass `-WhatIf` to
+preview the tag without creating it.
+
+This tag versions and publishes the UnitsNet.Modular package.
+
+The local package automation passes a timestamped `MinVerVersionOverride` so repeated packages
+containing uncommitted changes remain unique. The package includes complete NuGet metadata,
+including its README, icon, XML API documentation, repository commit metadata, and portable PDBs
+in an `.snupkg`.
+GitHub Actions enables `ContinuousIntegrationBuild`, producing deterministic CI packages with
+stable source paths
+and Source Link metadata for the matching commit. Local development packages retain developer source
+paths and may therefore be reported as non-deterministic by NuGet Package Explorer; they are not
+publishing artifacts.
+
+The separate `UnitsNet.Modular CI` workflow uses full Git history, builds and tests `UnitsNet.Modular.slnx`,
+runs the minimal NuGet consumer with an isolated package cache, packs the combined package with its
+MinVer version, and uploads it as a workflow artifact. Upstream pushes to `master` stop there.
+`UnitsNet.Modular/*` tag pushes additionally publish the exact tagged version to NuGet.org, and a
+manual run from such a tag can opt into publishing for recovery. Before uploading or publishing, CI
+verifies that the package filename contains the exact version declared by the tag. NuGet.org trusted
+publishing must authorize the `angularsen/UnitsNet` repository, the `unitsnet-modular-ci.yml`
+workflow, and the `Publish` environment.
+
+## Analyzer dependency plumbing
+
+`UnitsNet.Modular/Directory.Packages.props` and `UnitsNet.Modular/Directory.Build.targets` support development
+with an analyzer `ProjectReference`; they are not copied into the shipped package. Project
+references do not automatically expose private analyzer dependencies. The local target therefore
+points Roslyn at the restored `System.Text.Json` support assemblies.
+
+Packaged consumers do not configure any of this. The support assemblies are private files beside
+`UnitsNet.Modular.Generator.dll` under `analyzers/dotnet/cs`, and the package declares no runtime
+dependency on them. `_UnitsNetModularAnalyzerDependencyDirectory` is evaluated only while packing to
+locate those
+files; it is not a consumer-facing MSBuild property or API.
+
+## Framework targets
+
+The `UnitsNet.Modular` runtime supplies assets for .NET 8, 9, and 10. The standalone prototype does
+not modify any UnitsNet target or make UnitsNet reference the Modular contracts. Possible modern
+UnitsNet v6 adoption remains a separate integration investigation.
+
+The generator remains a `netstandard2.0` analyzer solely so current compiler and IDE hosts can load
+it regardless of the consumer target. That analyzer target is an implementation constraint, not
+runtime support for generated quantity modules.
+
+On all supported runtime targets, generated quantities implement `IParsable<TSelf>` and applicable
+Modular capability and generic-math interfaces. Linear quantities support conventional arithmetic and
+shared aggregation; affine quantities add or subtract linear offsets and produce an offset when
+subtracted from one another; logarithmic quantities keep their explicit logarithmic behavior. All
+generated quantities support generic comparison.
+
+The Modular runtime project enables the .NET AOT compatibility analyzers. CI publishes and runs
+the lean sample with Native AOT on Linux. The generator remains a managed build-time analyzer and
+explicitly does not inherit an application's publish, runtime identifier, trimming, or
+self-contained settings. The lean generated consumer targets .NET 8, 9, and 10 so the normal build
+also compiles emitted source against every supported runtime target.
+
+Further modern-target opportunities include allocation-free
+`ISpanParsable<TSelf>`/`ISpanFormattable` paths, UTF-8 parsing and formatting, and optionally
+abstracting the numeric storage type through generic math. Those require deliberate API and
+performance design beyond this POC.
+
+## Generated surface
+
+For each selected definition, the generator emits:
+
+- a unit enum containing only selected units;
+- an immutable strongly typed quantity struct;
+- typed `FromXxx()` factories, a generic `From(value, unit)` factory, and `.Xxx` conversion
+  properties;
+- static canonical `Info` metadata through the Modular self-typed contract, including semantic
+  identity and base-unit information;
+- `As()`, `ToUnit()`, `Parse()`, `TryParse()`, and `ToString()`;
+- default values normalized to zero in the base unit, matching UnitsNet;
+- arithmetic selected by the definition's linear, affine, or logarithmic semantics;
+- affine arithmetic generated with a selected linear offset companion, with `UNM015` reporting a
+  missing companion before emission;
+- modern .NET generic parsing, comparison, and capability contracts;
+- localized unit metadata that delegates shared behavior to the runtime;
+- direct, validated conversion switches for affine and nonlinear conversions;
+- a module-wide immutable discovery registry and AOT-safe System.Text.Json converter factory.
+
+When all operands and results are selected, the generator emits relationships such as:
+
+- `Length * Length -> Area`
+- `Length / Duration -> Speed`
+- `Speed / Duration -> Acceleration`
+- `Mass * Acceleration -> Force`
+- `Force / Area -> Pressure`
+- `Force * Speed -> Power`
+- `Power * Duration -> Energy`
+- `Energy / Duration -> Power`
+
+Relationship operators convert through the anchor units named by each equation. Selecting the
+participating quantities controls whether an operator exists; anchor units do not need to be exposed
+in the generated public unit enums. The generator uses the full immutable definitions to inline the
+necessary private conversions and constructs the result in its selected base unit.
+
+The built-in inventory comes from `Common/UnitRelations.json` rather than hardcoded quantity names.
+The relation pipeline resolves endpoints globally by semantic quantity ID, generates both operand
+orders for commutative multiplication, infers division, and honors `NoInferredDivision`. Generated
+types may remain in different CLR namespaces because emitted signatures use fully qualified names.
+
+Third-party packages and applications can add structured semantic relationships through
+`AdditionalFiles` items marked with `UnitsNetRelation="true"`:
+
+```json
+[
+  {
+    "result": { "quantity": "Fictional.HowMuchDistance", "unit": "SomeMeter" },
+    "left": { "quantity": "Fictional.HowMuch", "unit": "Some" },
+    "operator": "*",
+    "right": { "quantity": "UnitsNet.Length", "unit": "Meter" }
+  }
+]
+```
+
+The existing UnitsNet string equations remain supported and are normalized to the same semantic
+model. Structured relations are preferred for third-party packages because semantic IDs remain
+unambiguous across namespaces.
+
+## Catalog
+
+The catalog model is designed for all UnitsNet quantity and unit definitions. Definitions come from
+the UnitsNet JSON catalog and cover linear, affine, and logarithmic behavior; SI, non-SI,
+decimal-prefix, and binary-prefix units; localized abbreviations; and cross-quantity relationships.
+
+`AllQuantitiesProfile` selects all 129 built-in definitions directly from the repository catalog,
+without a second handwritten name inventory. `AllSiProfile` exercises the complete SI
+relationship chain in a focused sample, while the representative sample provides a faster varied
+selection for day-to-day generator iteration. JSON-backed third-party definitions participate in
+the same
+selection, profile, conversion, localization, and relationship model as built-ins.
+
+The full-catalog generator gate emits 132 source files (129 quantities plus module sources) and
+about 3.16 million source characters in roughly 0.63 seconds on the development machine used for
+this POC. The budgets in the test are intentionally generous to catch accidental order-of-magnitude
+regressions rather than benchmark noise. Running the identical input twice also verifies stable
+generated text, while the incremental generator test verifies cached output for an unchanged full
+catalog request.
+
+## Deliberate limitations
+
+- This is a design probe for a future architecture, not yet a committed replacement for UnitsNet v6.
+- Quantity values use `double` only.
+- Generic numeric storage, explicit culture-selection policy, and rich parse ambiguity handling are
+  deferred.
+- System.Text.Json has an immutable-registry proof of concept; long-term serialized-contract
+  versioning and compatibility adapters remain application concerns.
+- Regex/glob patterns filter expanded unit names, not abbreviations.
+- Prefix expansion uses a common SI/binary prefix table; it does not yet reproduce every
+  culture-specific prefix convention from UnitsNet v6.
+- Definition packages contain specs, not quantity structs. Independently generated application
+  modules intentionally have distinct CLR type identities.
+- The supported application pattern uses one module marker in one consumer-owned units project;
+  `UNM014` reports additional module markers before they can emit colliding types.
+- Canonical precompiled third-party modules and operators between independently compiled modules are
+  outside this prototype's scope.
+- Legacy mutable setup, runtime registration, global defaults, and exact legacy interface identity
+  remain deliberately unsupported.
+- Referencing legacy `UnitsNet.dll` in a project that declares a Modular module is unsupported and
+  reported as `UNM016`; migrate the generation boundary to one implementation at a time.
+
+## What this POC should prove
+
+1. Omitting a quantity prevents its type and metadata from entering the consumer assembly.
+2. Unit patterns reduce the generated enum and typed API.
+3. Built-in and custom quantities share the same runtime behavior and strongly typed surface.
+4. Cross-quantity APIs can be conditional rather than forcing a monolithic dependency graph.
+5. No runtime reflection or assembly scanning is required.
diff --git a/UnitsNet.Modular/Directory.Build.props b/UnitsNet.Modular/Directory.Build.props
new file mode 100644
index 0000000000..7def4d3b70
--- /dev/null
+++ b/UnitsNet.Modular/Directory.Build.props
@@ -0,0 +1,23 @@
+<Project>
+  <!-- Preserve repository-wide build settings when this nearer props file is discovered. -->
+  <Import Project="../Directory.Build.props" />
+
+  <!-- Register analyzer-config metadata before IDE design-time builds capture the project model. -->
+  <Import Project="UnitsNet.Modular.Generator/buildTransitive/UnitsNet.Modular.Generator.props" />
+
+  <!-- Shared versioning policy for the Modular runtime and bundled generator. -->
+  <Import Project="UnitsNet.Modular.Versioning.props" />
+
+  <!-- Reproducible portable symbols with Source Link are part of the package quality contract. -->
+  <PropertyGroup>
+    <!-- Sample projects declare dependency-mode platforms in their nearer build props. -->
+    <PlatformTarget>AnyCPU</PlatformTarget>
+
+    <DebugType>portable</DebugType>
+    <Deterministic>true</Deterministic>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <ContinuousIntegrationBuild Condition="'$(GITHUB_ACTIONS)' == 'true'">true</ContinuousIntegrationBuild>
+    <!-- Only the combined runtime + generator project is a public package. -->
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+</Project>
diff --git a/UnitsNet.Modular/Directory.Build.targets b/UnitsNet.Modular/Directory.Build.targets
new file mode 100644
index 0000000000..2a8faf3d65
--- /dev/null
+++ b/UnitsNet.Modular/Directory.Build.targets
@@ -0,0 +1,20 @@
+<Project>
+  <!-- Preserve repository-wide build settings when this nearer targets file is discovered. -->
+  <Import Project="../Directory.Build.targets" />
+
+  <!-- ProjectReference-based POC equivalent of the target packed under buildTransitive/. -->
+  <Import Project="$(MSBuildThisFileDirectory)UnitsNet.Modular.Generator/buildTransitive/UnitsNet.Modular.Generator.targets" />
+
+  <!-- Local ProjectReference-only workaround; this file is not packed. NuGet dependencies ship beside the analyzer. -->
+  <ItemGroup Condition="'$(UnitsNetModularSampleUsePackagedAnalyzer)' != 'true' and '$(MSBuildProjectName)' != 'UnitsNet.Modular' and '$(MSBuildProjectName)' != 'UnitsNet.Modular.Generator'">
+    <Analyzer Include="$(NuGetPackageRoot)/microsoft.bcl.asyncinterfaces/$(MicrosoftBclAsyncInterfacesVersion)/lib/netstandard2.0/Microsoft.Bcl.AsyncInterfaces.dll" />
+    <Analyzer Include="$(NuGetPackageRoot)/system.buffers/$(SystemBuffersVersion)/lib/netstandard2.0/System.Buffers.dll" />
+    <Analyzer Include="$(NuGetPackageRoot)/system.io.pipelines/$(SystemIoPipelinesVersion)/lib/netstandard2.0/System.IO.Pipelines.dll" />
+    <Analyzer Include="$(NuGetPackageRoot)/system.memory/$(SystemMemoryVersion)/lib/netstandard2.0/System.Memory.dll" />
+    <Analyzer Include="$(NuGetPackageRoot)/system.numerics.vectors/$(SystemNumericsVectorsVersion)/lib/netstandard2.0/System.Numerics.Vectors.dll" />
+    <Analyzer Include="$(NuGetPackageRoot)/system.runtime.compilerservices.unsafe/$(SystemRuntimeCompilerServicesUnsafeVersion)/lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.dll" />
+    <Analyzer Include="$(NuGetPackageRoot)/system.text.encodings.web/$(SystemTextEncodingsWebVersion)/lib/netstandard2.0/System.Text.Encodings.Web.dll" />
+    <Analyzer Include="$(NuGetPackageRoot)/system.text.json/$(SystemTextJsonVersion)/lib/netstandard2.0/System.Text.Json.dll" />
+    <Analyzer Include="$(NuGetPackageRoot)/system.threading.tasks.extensions/$(SystemThreadingTasksExtensionsVersion)/lib/netstandard2.0/System.Threading.Tasks.Extensions.dll" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/Directory.Packages.props b/UnitsNet.Modular/Directory.Packages.props
new file mode 100644
index 0000000000..d7791266f8
--- /dev/null
+++ b/UnitsNet.Modular/Directory.Packages.props
@@ -0,0 +1,26 @@
+<Project>
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+    <!-- Build-only paths below mirror System.Text.Json's netstandard2.0 dependency versions. -->
+    <MicrosoftBclAsyncInterfacesVersion>10.0.0</MicrosoftBclAsyncInterfacesVersion>
+    <SystemBuffersVersion>4.6.1</SystemBuffersVersion>
+    <SystemIoPipelinesVersion>10.0.0</SystemIoPipelinesVersion>
+    <SystemMemoryVersion>4.6.3</SystemMemoryVersion>
+    <SystemNumericsVectorsVersion>4.6.1</SystemNumericsVectorsVersion>
+    <SystemRuntimeCompilerServicesUnsafeVersion>6.1.2</SystemRuntimeCompilerServicesUnsafeVersion>
+    <SystemTextEncodingsWebVersion>10.0.0</SystemTextEncodingsWebVersion>
+    <SystemTextJsonVersion>10.0.0</SystemTextJsonVersion>
+    <SystemThreadingTasksExtensionsVersion>4.6.3</SystemThreadingTasksExtensionsVersion>
+    <UnitsNetModularPublishedVersion
+        Condition="'$(UnitsNetModularPublishedVersion)' == ''">6.0.0-alpha.2</UnitsNetModularPublishedVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageVersion Include="MinVer" Version="7.0.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.5.1" />
+    <PackageVersion Include="System.Text.Json" Version="$(SystemTextJsonVersion)" />
+    <PackageVersion Include="UnitsNet.Modular" Version="$(UnitsNetModularPublishedVersion)" />
+    <PackageVersion Include="xunit" Version="2.9.3" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/MIGRATION.md b/UnitsNet.Modular/MIGRATION.md
new file mode 100644
index 0000000000..9f5ae6dd11
--- /dev/null
+++ b/UnitsNet.Modular/MIGRATION.md
@@ -0,0 +1,381 @@
+# Migrate from UnitsNet to UnitsNet.Modular
+
+UnitsNet.Modular preserves the familiar strongly typed UnitsNet programming model, but changes
+where quantities come from and who owns them. UnitsNet provides a precompiled catalog in
+`UnitsNet.dll`. UnitsNet.Modular generates the selected catalog into an assembly owned by the
+consumer.
+
+That distinction enables smaller, application-specific catalogs, custom quantities in the same
+type system, and trimming and Native AOT-friendly discovery without assembly scanning. It also
+means that UnitsNet.Modular is not a drop-in binary replacement for UnitsNet and that some dynamic,
+metadata, and runtime-configuration APIs require migration.
+
+> **Experimental:** UnitsNet.Modular is an alpha proof of concept. Its API, package structure, and
+> compatibility guarantees may change as the architecture is evaluated.
+
+## How the two packages differ
+
+| Concern | UnitsNet | UnitsNet.Modular |
+|---|---|---|
+| Quantity implementation | Precompiled types supplied by `UnitsNet.dll` | Source-generated types compiled into a consumer-owned assembly |
+| Catalog | The complete UnitsNet catalog | Only the quantities and units selected by the module |
+| Namespaces | `UnitsNet` and `UnitsNet.Units` | The same by default for built-ins, or an application namespace selected by the module |
+| Custom quantities | Separate from the built-in generated catalog | Built-in, application, and third-party definitions generate together |
+| Configuration | Runtime setup and mutable global registrations | Compile-time selection and immutable generated metadata |
+| Dynamic discovery | Process-wide UnitsNet catalog | One immutable registry for the selected module |
+| Unit-system policy | `UnitsNet.UnitSystem` stores constituent unit enums | `UnitsNet.UnitSystem` keeps the familiar source name but stores invariant names so it is neutral to the generated assembly |
+| Deployment | Consumers share the types in `UnitsNet.dll` | Consumers must reference the same assembly containing the generated types |
+| Compatibility | Established UnitsNet API and binary identity | Common strongly typed APIs target source compatibility; binary compatibility is not a goal |
+
+## Why use UnitsNet.Modular?
+
+UnitsNet.Modular is a good fit when an application wants one or more of these properties:
+
+- generate only the quantities and units it uses;
+- combine UnitsNet definitions with application-specific or third-party definitions;
+- generate relationships and operators across built-in and custom quantities;
+- own a single units assembly shared by the application's domain, persistence, API, and UI projects;
+- avoid runtime assembly scanning and mutable global registration;
+- use generated, trimming and Native AOT-friendly discovery and System.Text.Json integration.
+
+UnitsNet remains the simpler choice when an application needs binary compatibility with libraries
+compiled against `UnitsNet.dll`, depends heavily on runtime mutation, or cannot establish one
+generation boundary shared by all consumers. UnitsNet.Modular is currently a design probe, not a
+committed replacement for UnitsNet.
+
+## Migration steps
+
+### 1. Choose the assembly that owns the generated types
+
+A generated public type belongs to the assembly into which it is generated. For a multi-project
+application, create or choose one units project, generate the module there, and reference that
+project everywhere else:
+
+```text
+MyApplication.Units       -> UnitsNet.Modular + module declaration
+MyApplication.Domain      -> MyApplication.Units
+MyApplication.Persistence -> MyApplication.Units
+MyApplication.Api         -> MyApplication.Units
+```
+
+Do not generate the same quantity independently in several projects. Two generated types named
+`UnitsNet.Length` in two assemblies are different CLR types.
+
+### 2. Replace the package in the owning project
+
+Remove the `UnitsNet` package reference and add the prerelease `UnitsNet.Modular` package:
+
+```shell
+dotnet remove package UnitsNet
+dotnet add package UnitsNet.Modular --prerelease
+```
+
+Remove direct `UnitsNet` references from the other application projects and reference the owning
+units project instead. A project cannot use the precompiled and generated `UnitsNet.Length` types
+as though they were the same type.
+
+### 3. Declare the module
+
+For the lowest-friction migration, generate all built-in quantities:
+
+```csharp
+using UnitsNet.Modular;
+using UnitsNet.Modular.Profiles;
+
+[UnitsNetModule]
+internal interface ApplicationUnits : IIncludeProfile<AllQuantitiesProfile>;
+```
+
+Built-in definitions use `UnitsNet` and `UnitsNet.Units` by default, so existing imports such as
+these remain valid:
+
+```csharp
+using UnitsNet;
+using UnitsNet.Units;
+```
+
+To generate a smaller catalog, replace the profile with explicit selections:
+
+```csharp
+using UnitsNet.Modular;
+using Catalog = UnitsNet.Modular.BuiltIns;
+
+[UnitsNetModule]
+internal interface ApplicationUnits :
+    IInclude<Catalog.LengthSpec>,
+    IInclude<Catalog.DurationSpec>,
+    IInclude<Catalog.SpeedSpec>;
+```
+
+Select every quantity participating in an operator or relationship. Affine quantities such as
+`Temperature` also require their offset quantity; generator diagnostics identify missing inputs.
+See [Configure generation](README.md#configure-generation) for profiles and unit filters.
+
+### 4. Build and fix source-incompatible APIs
+
+Build before changing ordinary quantity code. Construction, conversion, parsing, formatting,
+arithmetic, and many quantity-specific helpers should continue to compile. Use the two quick
+reference tables below to identify code that needs an adapter or API change.
+
+### 5. Migrate dynamic and serialized boundaries
+
+Resolve dynamic quantities through the generated module registry, and use semantic quantity IDs
+plus invariant unit names at persistence, message, plugin, or service boundaries. Register the
+module's generated System.Text.Json converter instead of relying on runtime discovery:
+
+```csharp
+using System.Text.Json;
+using UnitsNet;
+
+var options = new JsonSerializerOptions();
+options.Converters.Add(GeneratedQuantityRegistry.JsonConverter);
+```
+
+Existing assemblies compiled against `UnitsNet.dll` must keep UnitsNet at that boundary. Translate
+to the application's generated quantities explicitly by numeric value and invariant unit name.
+
+### 6. Verify behavior, then reduce the catalog
+
+Run application tests with particular attention to persisted payloads, culture-sensitive parsing
+and formatting, unit-system selection, dynamic lookup, and plugin or reflection boundaries. After
+the full-catalog migration is stable, replace `AllQuantitiesProfile` with the quantities and unit
+sets the application actually needs.
+
+## Quick reference: source-compatible APIs
+
+Here, **source-compatible** means the same consumer source compiles against UnitsNet.Modular when:
+
+- built-ins use their default `UnitsNet` and `UnitsNet.Units` namespaces;
+- every referenced quantity and unit is selected; and
+- all projects reference the same assembly containing the generated types.
+
+| API area | Examples that remain source-compatible | Notes |
+|---|---|---|
+| Quantity and unit names | `Length`, `Mass`, `LengthUnit.Meter` | The full built-in catalog preserves quantity names, unit enum names, and enum values. |
+| Construction | `new Length(1, LengthUnit.Meter)`, `Length.From(1, unit)`, `Length.FromMeters(1)` | Generated quantity values currently use `double`. |
+| Value access | `length.Value`, `length.Unit`, `length.Meters`, `Length.Zero` | Code that explicitly names UnitsNet's `QuantityValue` type must change to `double`. |
+| Conversion | `length.As(unit)`, `length.ToUnit(unit)` | Conversion behavior is generated from the selected definitions. Modular also adds `Length.Convert(value, from, to)` for raw values. |
+| Parsing | `Length.Parse(text)`, `Length.TryParse(...)`, `Length.ParseUnit(...)` | Selected units and localization determine accepted input. |
+| Formatting | `length.ToString(...)`, `Length.GetAbbreviation(unit, provider)` | Culture-aware built-in abbreviations and formatting are generated. |
+| Arithmetic and comparison | `a + b`, `a - b`, `a * 2`, `a / b`, comparisons and equality | Quantity semantics remain linear, affine, or logarithmic as appropriate. |
+| Cross-quantity relationships | `Length / Duration`, `Mass * Acceleration`, `Force / Area` | Emitted only when all participating quantities are selected. |
+| Aggregation | `values.Sum()`, `values.Average()`, logarithmic aggregation helpers | Generated extensions delegate to reusable `UnitsNet` algorithms. |
+| Built-in companion APIs | `FeetInches`, `StonePounds`, `ReferencePressure`, `Duration`/`TimeSpan` helpers | Included when their owning built-in quantities are selected. |
+
+## Quick reference: incompatible or changed APIs
+
+These APIs are not source-compatible even when the full catalog is generated.
+
+| UnitsNet API or assumption | UnitsNet.Modular replacement | Migration action |
+|---|---|---|
+| Types come from `UnitsNet.dll` | Types are generated into a consumer-owned assembly | Recompile consumers and make them reference one shared generated assembly; keep an adapter at binary boundaries. |
+| `UnitsNet.IQuantity` and legacy generic quantity contracts | `UnitsNet.IQuantity<double>` and the generated-runtime capability contracts | Change generic constraints and declared dynamic types, or keep concrete quantity types where possible. The namespace is source-compatible, but the assembly identity and interface shapes differ. |
+| Explicit `QuantityValue` usage | `double` | Change explicitly declared values, parameters, and generic arguments to `double`. |
+| Legacy metadata shapes and `Length.QuantityInfo` | Typed `Length.Info`, or `IQuantityDescriptor` and `UnitDescriptor` from the registry | Read `Length.Info.BaseUnit`, `Length.Info.Units`, and `Length.Info.BaseDimensions` when the quantity is known; use the registry for type-erased workflows. |
+| `Quantity.Names`, `Quantity.Infos`, and `Quantity.ByName` imply the complete process-wide catalog | The same facade names describe only the selected module | Audit code that assumes every UnitsNet quantity is present. Use the registry when dependency injection or explicit ownership is clearer. |
+| `Quantity.From`, `TryFrom`, `Parse`, and `TryParse` return legacy `UnitsNet.IQuantity` | The familiar call shapes return `UnitsNet.IQuantity<double>` from the Modular runtime | Change the receiving interface shape or use `var`; concrete typed parsing remains unchanged. |
+| `UnitConverter` and runtime conversion registration | Generated `QuantityType.Convert(...)` or `QuantityRegistry.Convert(...)` | Move conversions into definitions and use typed conversion when the quantity is known. |
+| `UnitsNetSetup` quantity selection and runtime registration | Module interfaces, profiles, unit sets, JSON definitions, and relation definitions | Move configuration to compile time. Rebuild when the catalog changes. |
+| Runtime abbreviation mutation | Localization in definition metadata | Add abbreviations to a definition; runtime mutation is unsupported. |
+| Global `Quantity.FromUnitAbbreviation(...)` | Parse through a known quantity or inspect its descriptor | Carry quantity identity at the boundary instead of inferring it from a potentially ambiguous abbreviation. |
+| `UnitKey` as a stable boundary identifier | Semantic `QuantityId` plus invariant unit name | Persist or transmit both values; unit enums are suitable only inside one generated module. |
+| Mutable or enum-backed assumptions about `UnitsNet.UnitSystem` and `UnitsNet.BaseUnits` | Immutable Modular implementations under the same `UnitsNet` namespace | Calls such as `UnitSystem.SI` remain source-compatible; construct custom policies with invariant constituent unit names. |
+| Legacy `BaseDimensions` shape in generic/dynamic code | Modular `UnitsNet.BaseDimensions` | The namespace remains the same; adapt shape-dependent code and access it through `Length.Info.BaseDimensions` or an `IQuantityDescriptor`. |
+| Polymorphic JSON inferred from runtime type discovery | `GeneratedQuantityRegistry.JsonConverter` for selected concrete quantities | Register the generated converter. Resolve polymorphic interfaces by semantic quantity ID at the boundary. |
+| `Length.ParseFeetInches` and `Length.TryParseFeetInches` | No specialized compound parser | Keep a presentation-layer parser or translate the input into ordinary `Length` operations. |
+| `Pressure.FromElevation` and `Pressure.ToElevation` | No generated elevation model | Keep the empirical atmosphere model in application code and return/accept `Pressure`. |
+| Runtime additions to a catalog | New or changed definition inputs | Update the module or definition package and rebuild. |
+
+## Common fixes
+
+### Dynamic quantity contracts
+
+Change code that explicitly receives a UnitsNet interface:
+
+```csharp
+// UnitsNet
+IQuantity distance = Quantity.From(1.5, "Length", "Kilometer");
+
+// UnitsNet.Modular package
+UnitsNet.IQuantity<double> distance =
+    Quantity.From(1.5, "Length", "Kilometer");
+```
+
+The namespace remains `UnitsNet`, but the Modular interface has a deliberately slimmer shape:
+
+```csharp
+UnitsNet.IQuantity<double> distance = Length.FromMeters(1);
+```
+
+### Global conversion
+
+Replace dynamic conversion by name with the registry:
+
+```csharp
+// UnitsNet
+QuantityValue meters = UnitConverter.ConvertByName(
+    1.5, "Length", "Kilometer", "Meter");
+
+// UnitsNet.Modular package
+using UnitsNet;
+
+var registry = GeneratedQuantityRegistry.Instance;
+double meters = registry.Convert(
+    1.5,
+    "Length",
+    "Kilometer",
+    "Meter");
+```
+
+When the quantity is known, prefer the generated typed API:
+
+```csharp
+double meters = Length.Convert(
+    1.5,
+    LengthUnit.Kilometer,
+    LengthUnit.Meter);
+```
+
+The registry also supports enum-based conversion when both units belong to one selected quantity.
+
+### Metadata and unit pickers
+
+Replace mutable/global metadata assumptions with a descriptor from the selected module:
+
+```csharp
+using UnitsNet;
+
+IQuantityDescriptor descriptor =
+    GeneratedQuantityRegistry.Instance.Get("Length");
+
+foreach (UnitDescriptor unit in descriptor.Units)
+{
+    Console.WriteLine(unit.Name);
+}
+```
+
+| UnitsNet workflow | UnitsNet.Modular equivalent | Status |
+|---|---|---|
+| `Quantity.Names` | `Quantity.Names` or `registry.Names` | Supported, selected module only |
+| `Quantity.Infos` | `Quantity.Infos` or `registry.Quantities` | Supported with immutable descriptors |
+| `Quantity.ByName[name]` | `Quantity.ByName[name]` or `registry.Get(name)` | Supported, case-insensitive name |
+| Lookup by quantity type | `registry.Get(typeof(Length))` | Supported |
+| Stable cross-boundary identity | `registry.Get(new QuantityId("UnitsNet.Length"))` | Supported; use namespace-qualified IDs |
+| Lookup from a unit enum type | `registry.GetByUnitType(typeof(LengthUnit))` | Supported |
+| `Quantity.From(value, quantityName, unitName)` | Same facade call | Returns Modular quantity contract |
+| `Quantity.From(value, unitEnum)` | Same facade call | Returns Modular quantity contract |
+| `Quantity.TryFrom(...)` | Same facade call | Returns Modular quantity contract |
+| `UnitConverter.ConvertByName(...)` | `registry.Convert(value, quantityName, fromName, toName)` | Supported |
+| `UnitConverter.Convert(value, fromEnum, toEnum)` | `registry.Convert(value, fromEnum, toEnum)` | Supported for one quantity |
+| `UnitConverter.TryConvert...` | `registry.TryConvert(...)` | Supported for one quantity |
+| `Quantity.Parse(type, text)` | Same facade call | Returns Modular quantity contract |
+| `Quantity.TryParse(...)` | Same facade call | Returns Modular quantity contract |
+| `Quantity.GetQuantitiesWithBaseDimensions(...)` | Same facade call or `registry.FindByBaseDimensions(...)` | Supported, selected module only |
+| `QuantityInfo` / `UnitInfo` metadata | `QuantityInfo<TQuantity, TUnit>` / `UnitInfo<TUnit>`; `IQuantityDescriptor` / `UnitDescriptor` when type-erased | Supported as immutable metadata |
+| Dynamic formatting through `IQuantity` | `descriptor.Format(value, format, provider)` | Supported with concrete-type validation |
+| System.Text.Json converters | `GeneratedQuantityRegistry.JsonConverter` | Supported without assembly scanning |
+| Generic quantity algorithms | `UnitsNet.IQuantity<...>` capability contracts | Supported by generated quantities; the familiar namespace does not imply binary identity with legacy UnitsNet contracts |
+| `UnitKey` | A unit enum in-process; semantic quantity ID plus invariant unit name across boundaries | Deliberately changed |
+| `UnitSystem` / `BaseUnits` | `UnitsNet.UnitSystem` / `UnitsNet.BaseUnits` | Supported as immutable selected-module policy |
+| `UnitsNetSetup` quantity selection | Module interfaces, profiles, and definition packages | Compile-time replacement |
+| Runtime abbreviation mutation | Localization in definition metadata | Runtime mutation unsupported |
+| Runtime conversion registration | Definition conversion expressions and relation definitions | Runtime mutation unsupported |
+| Global `Quantity.FromUnitAbbreviation(...)` | Parse through a known quantity or present units from its descriptor | Deliberately unsupported |
+| Legacy `UnitsNet.IQuantity` identity | Modular `UnitsNet.IQuantity<double>` | Namespace preserved; assembly identity and interface shape deliberately changed |
+
+Persist `descriptor.Id` and `unit.Name`, not a localized abbreviation. Abbreviations are for parsing
+and display and may be shared by unrelated quantities.
+
+### Unit-system policy
+
+The two packages expose intentionally different `UnitSystem` implementations under the same
+source-compatible namespace. Since the packages cannot be referenced together, ordinary calls do
+not need Modular-specific qualification:
+
+```csharp
+Length distance = Length.From(1.5, UnitSystem.SI);
+double meters = Length.FromKilometers(1.5).As(UnitSystem.SI);
+Length normalized = Length.FromFeet(3).ToUnit(UnitSystem.SI);
+```
+
+To define an application policy, use invariant constituent unit names:
+
+```csharp
+var imperial = new UnitSystem(
+    new BaseUnits(length: "Foot"));
+
+Length distance = new Length(3, imperial);
+```
+
+Resolution considers only units selected into the module.
+
+### Dynamic creation, parsing, and formatting
+
+The generated static `Quantity` facade is useful while preserving familiar call shapes:
+
+```csharp
+UnitsNet.IQuantity<double> byName =
+    Quantity.From(1.5, "Length", "Kilometer");
+UnitsNet.IQuantity<double> byUnit =
+    Quantity.From(1.5, LengthUnit.Kilometer);
+UnitsNet.IQuantity<double> parsed =
+    Quantity.Parse(typeof(Length), "1.5 km");
+```
+
+For injected services and type-erased operations, depend on the registry:
+
+```csharp
+QuantityRegistry registry = GeneratedQuantityRegistry.Instance;
+IQuantityDescriptor length = registry.Get(typeof(Length));
+UnitsNet.IQuantity<double> parsed = registry.Parse(
+    typeof(Length),
+    "1.5 km",
+    System.Globalization.CultureInfo.InvariantCulture);
+
+string display = length.Format(
+    parsed,
+    "0.00",
+    System.Globalization.CultureInfo.InvariantCulture);
+```
+
+`Try*` registry methods return `false` for unselected quantities, unselected or undefined units,
+cross-quantity enum conversion, and invalid parse input.
+
+## Migration checklist
+
+- One assembly owns each generated quantity type used by the application.
+- Built-ins use the default namespaces unless a deliberate application namespace is desired.
+- All quantities, units, affine companions, and relationship participants are selected.
+- No migrated project accidentally depends on both precompiled and generated types with the same
+  full name.
+- Dynamic code uses Modular contracts and the generated module registry.
+- Runtime setup and registrations have moved to definitions and module selection.
+- Persisted and external boundaries use semantic quantity IDs and invariant unit names.
+- JSON, localization, parsing, formatting, conversion, and unit-system behavior have application
+  tests.
+- Binary consumers of `UnitsNet.dll` remain behind an explicit adapter.
+
+```csharp
+IReadOnlyList<IQuantityDescriptor> distances =
+    registry.FindByBaseDimensions(Length.Info.BaseDimensions);
+```
+
+## Why the facade stays thin
+
+`UnitsNetSetup`, mutable `UnitConverter` registrations, abbreviation-cache mutation, and mutable
+global unit-system defaults are process-wide runtime policy. UnitsNet.Modular instead accepts an
+immutable `UnitSystem` explicitly at each typed or dynamic operation. Selected definitions, units,
+conversions, relationships, and localization remain compile-time inputs owned by the application.
+
+The generated `Quantity` facade delegates to `Quantity.Registry` and returns
+`UnitsNet.IQuantity<double>`. It does not own another catalog, conversion registry, or mutable
+configuration. APIs that would pretend to mutate generated code remain absent.
+
+Use an application adapter when a boundary genuinely needs runtime policy. Keep that adapter outside
+`UnitsNet.Modular` and the generated quantities, and identify values by semantic quantity ID plus
+invariant unit name. Existing plugins or assemblies compiled against `UnitsNet.dll` must retain
+UnitsNet at that binary boundary and translate explicitly; matching generated full names do not
+make the CLR types assignment-compatible.
+
+For module configuration, custom definitions, diagnostics, and current limitations, continue with
+the [UnitsNet.Modular README](README.md).
diff --git a/UnitsNet.Modular/README.md b/UnitsNet.Modular/README.md
new file mode 100644
index 0000000000..6674603296
--- /dev/null
+++ b/UnitsNet.Modular/README.md
@@ -0,0 +1,834 @@
+# Units.NET Modular
+
+[![Open the samples in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/angularsen/UnitsNet?devcontainer_path=.devcontainer%2Funitsnet-modular%2Fdevcontainer.json&quickstart=1)
+
+[![UnitsNet.Modular CI](https://github.com/angularsen/UnitsNet/actions/workflows/unitsnet-modular-ci.yml/badge.svg)](https://github.com/angularsen/UnitsNet/actions/workflows/unitsnet-modular-ci.yml)
+
+Generate only the strongly typed quantities and units your application needs.
+
+You can select quantities and units from the UnitsNet catalog and add your own custom quantities and
+units with JSON definitions. A source generator emits the types directly into your project.
+
+The result keeps the familiar UnitsNet API without requiring the complete catalog:
+
+- Generate only the quantities and units you use
+- Combine built-in and custom definitions in one strongly typed model
+- Get unit conversions, quantity relations, arithmetic, parsing, and formatting
+- Catch definition and relationship errors at compile time
+- Get trimming and Native AOT-friendly code
+
+> **Experimental:** UnitsNet.Modular is a proof of concept and currently in pre-release. Its API,
+> package structure, and compatibility guarantees may change as the architecture is evaluated.
+
+Try the [UnitsNet.Modular samples in GitHub Codespaces](https://codespaces.new/angularsen/UnitsNet?devcontainer_path=.devcontainer%2Funitsnet-modular%2Fdevcontainer.json&quickstart=1)
+without installing anything.
+
+## Contents
+
+- [Quick start](#quick-start)
+- [How it differs from UnitsNet](#how-it-differs-from-unitsnet)
+- [Choose a project structure](#choose-a-project-structure)
+- [Use generated quantities](#use-generated-quantities)
+- [Configure generation](#configure-generation)
+- [Add custom quantities](#add-custom-quantities)
+- [Add quantity relationships](#add-quantity-relationships)
+- [Publish a definition package](#publish-a-definition-package)
+- [Dynamic lookup and serialization](#dynamic-lookup-and-serialization)
+- [Diagnostics](#diagnostics)
+- [Troubleshooting](#troubleshooting)
+- [Samples and design documents](#samples-and-design-documents)
+
+## Quick start
+
+UnitsNet.Modular supports .NET 8, .NET 9, and .NET 10. It replaces `UnitsNet` in a project; the two
+packages cannot be referenced together. Remove `UnitsNet` if it is installed, then add the
+prerelease package:
+
+```shell
+dotnet remove package UnitsNet
+dotnet add package UnitsNet.Modular --prerelease
+```
+
+Generated built-in quantities use the `UnitsNet` namespace and unit enums use `UnitsNet.Units` by
+default. Pass a namespace to `[UnitsNetModule("MyApplication.Units")]` to change it.
+
+Add these two files to the project that references `UnitsNet.Modular`.
+
+`ApplicationUnits.cs` declares the generation boundary and selects the built-in quantities:
+
+```csharp
+using UnitsNet.Modular;
+using Catalog = UnitsNet.Modular.BuiltIns;
+
+namespace MyApplication.Units;
+
+[UnitsNetModule]
+internal interface ApplicationUnits :
+    IInclude<Catalog.LengthSpec>,
+    IInclude<Catalog.DurationSpec>,
+    IInclude<Catalog.SpeedSpec>;
+```
+
+`Program.cs` uses the generated API:
+
+```csharp
+using UnitsNet;
+using UnitsNet.Units;
+
+Length route = Length.FromKilometers(1.2);
+Length remaining = Length.Parse("500 m");
+Length total = route + remaining;
+Speed pace = total / Duration.FromMinutes(2);
+
+Console.WriteLine($"Total: {total.ToUnit(LengthUnit.Meter):F0}");
+Console.WriteLine($"Pace: {pace:F1}");
+```
+
+Build the project. The source generator sees `ApplicationUnits`, then emits `Length`, `Duration`,
+`Speed`, and their unit enums into your project. Because every participant is selected, it also
+emits the `Length / Duration = Speed` relationship used above.
+
+The `*Spec` interfaces are compile-time selections, not the generated quantities themselves. Each
+selected quantity includes all its units unless a unit set filters them. The project containing the
+module owns the generated CLR types, so other projects should reference that project rather than
+declare another module.
+
+## How it differs from UnitsNet
+
+`UnitsNet` ships the complete catalog as precompiled types and supports runtime configuration.
+UnitsNet.Modular source-generates your selected catalog at compile time and uses immutable generated
+metadata instead of mutable global registrations.
+
+### New in UnitsNet.Modular
+
+- Select only the quantities and units your application needs
+- Generate custom quantities and units from JSON alongside the built-in catalog
+- Generate relationships and operators across built-in and custom quantities
+- Put the generated types in a namespace and assembly you control
+- Use generated discovery and serialization without runtime assembly scanning
+- Produce trimming and Native AOT-friendly code
+
+### Tradeoffs and missing features
+
+- UnitsNet.Modular is a pre-release proof of concept, so its API and package structure may change
+- It is not binary-compatible with `UnitsNet`; libraries compiled against `UnitsNet.dll` need a
+  migration boundary
+- Quantity selection and configuration happen at compile time; runtime mutation of conversions,
+  abbreviations, and global defaults is not supported
+- Each generated assembly owns distinct CLR types, so multi-project applications should share one
+  generated units project
+- Generated quantity values currently use `double`
+- `Length.ParseFeetInches` and `Pressure` elevation modeling are not yet supported
+- The System.Text.Json integration is still a proof of concept, and applications own serialized
+  contract versioning
+
+See the [migration guide](MIGRATION.md) for a detailed API comparison and migration options.
+
+## Choose a project structure
+
+### One application project
+
+For a small application, place the module interface in the application project itself. The
+generated types become part of that application's assembly.
+
+```text
+MyTool
+├── MyTool.csproj       -> UnitsNet.Modular
+├── ApplicationUnits.cs
+└── Program.cs
+```
+
+### Shared units project
+
+For a multi-project application, generate quantities once in a dedicated units project and
+reference that project everywhere else:
+
+```text
+MyApplication.slnx
+└── src
+    ├── MyApplication.Units
+    │   ├── MyApplication.Units.csproj -> UnitsNet.Modular + definition packages
+    │   └── ApplicationUnits.cs
+    ├── MyApplication.Domain           -> MyApplication.Units
+    ├── MyApplication.Persistence      -> MyApplication.Units
+    ├── MyApplication.Api              -> MyApplication.Units
+    └── MyApplication.Cli              -> MyApplication.Units
+```
+
+```mermaid
+flowchart LR
+    BuiltIns["UnitsNet.Modular built-in specs"]
+    ThirdParty["Third-party definition packages"]
+    Units["MyApplication.Units<br/>selection + generation"]
+    Assembly["MyApplication.Units.dll<br/>generated quantity types"]
+    Apps["Domain, API, UI, persistence, services"]
+
+    BuiltIns --> Units
+    ThirdParty --> Units
+    Units --> Assembly
+    Assembly --> Apps
+```
+
+This is the recommended setup. A generated public type belongs to the assembly into which it is
+generated. Generating `Length` independently in two assemblies creates two different CLR types,
+even when both came from the same spec. One application-owned generation boundary gives all
+application projects the same type identity.
+
+### Full catalog with UnitsNet-style namespaces
+
+Generate the complete catalog into the established `UnitsNet` and `UnitsNet.Units` namespaces when
+source compatibility is more important than assembly size:
+
+```csharp
+using UnitsNet.Modular;
+using UnitsNet.Modular.Profiles;
+
+[UnitsNetModule]
+internal interface CompatibilityUnits : IIncludeProfile<AllQuantitiesProfile>;
+```
+
+This targets source compatibility for common construction, conversion, parsing, formatting,
+arithmetic, and aggregation code. It does not make the generated structs binary-compatible with
+types from `UnitsNet.dll`.
+
+### Third-party quantities and units
+
+A third-party definition package supplies specs rather than precompiled quantity structs. Reference
+the package from your units project, select its public quantity specs, and generate the third-party
+and built-in quantities together:
+
+```csharp
+using Acme.Measurements.Definitions;
+using UnitsNet.Modular;
+using Catalog = UnitsNet.Modular.BuiltIns;
+
+[UnitsNetModule]
+internal interface ApplicationUnits :
+    IInclude<Catalog.LengthSpec>,
+    IInclude<WidgetCountSpec>,
+    IInclude<WidgetDistanceSpec>;
+```
+
+This lets the generator emit operators between custom and built-in quantities and avoids type
+identity conflicts between independently compiled quantity packages.
+
+## Use generated quantities
+
+### Construct and convert
+
+```csharp
+Length a = Length.FromKilometers(1.5);
+Length b = new(500, LengthUnit.Meter);
+Length c = Length.From(2, LengthUnit.Mile);
+
+double meters = a.As(LengthUnit.Meter);
+Length inMeters = a.ToUnit(LengthUnit.Meter);
+double converted = Length.Convert(1.5, LengthUnit.Kilometer, LengthUnit.Meter);
+```
+
+`As()` returns the numeric value in another unit. `ToUnit()` returns a quantity storing that unit.
+The static `Convert()` method converts a raw numeric value without constructing a quantity.
+
+### Arithmetic and relationships
+
+Linear quantities support ordinary arithmetic:
+
+```csharp
+Length total = Length.FromMeters(2) + Length.FromCentimeters(50);
+Length scaled = total * 3;
+double ratio = total / Length.FromMeters(1);
+```
+
+Cross-quantity operators are emitted when all participating quantities are selected:
+
+```csharp
+Area area = Length.FromMeters(2) * Length.FromMeters(3);
+Speed speed = Length.FromKilometers(10) / Duration.FromHours(1);
+Force force = Mass.FromKilograms(5) * Acceleration.FromMetersPerSecondSquared(9.81);
+Pressure pressure = force / Area.FromSquareMeters(2);
+```
+
+Multiplication relationships are generated in both operand orders when commutative. Division is
+inferred unless the relation explicitly disables it.
+
+Affine quantities use a selected linear offset quantity:
+
+```csharp
+Temperature freezing = Temperature.FromDegreesCelsius(0);
+Temperature boiling = Temperature.FromDegreesCelsius(100);
+TemperatureDelta range = boiling - freezing;
+Temperature adjusted = freezing + TemperatureDelta.FromDegreesCelsius(2);
+```
+
+Selecting an affine quantity without its offset quantity produces diagnostic `UNM015`.
+Logarithmic quantities retain logarithmic arithmetic instead of being treated as linear values.
+
+### Parse, format, and localize
+
+```csharp
+using System.Globalization;
+
+Length distance = Length.Parse("1.5 km", CultureInfo.InvariantCulture);
+bool parsed = Length.TryParse("500 m", CultureInfo.InvariantCulture, out Length result);
+LengthUnit unit = Length.ParseUnit("km", CultureInfo.InvariantCulture);
+string abbreviation = Length.GetAbbreviation(LengthUnit.Kilometer, CultureInfo.InvariantCulture);
+
+string text = distance.ToString("F2", CultureInfo.InvariantCulture); // 1.50 km
+```
+
+Unit singular names and plural names parse case-insensitively. Configured abbreviations are
+case-sensitive. The requested culture is used first, with the definition's localization fallback
+behavior supplying the default abbreviation.
+
+### Aggregate
+
+Generated extension methods delegate reusable algorithms to the `UnitsNet` runtime:
+
+```csharp
+Length sum = new[]
+{
+    Length.FromKilometers(1),
+    Length.FromMeters(500),
+}.Sum();
+
+Length average = new[]
+{
+    Length.FromMeters(1),
+    Length.FromCentimeters(300),
+}.Average(LengthUnit.Meter);
+```
+
+Linear quantities provide `Sum()` and `Average()` overloads, including selector and target-unit
+forms. Affine quantities provide meaningful averages. Logarithmic quantities provide `Sum()`,
+`ArithmeticMean()`, and `GeometricMean()` with logarithmic semantics.
+
+### Inspect immutable metadata
+
+Each generated quantity exposes one strongly typed, immutable metadata object. Less-common
+discovery data lives there instead of being duplicated across the quantity API, and the generated
+registry stores that exact same instance:
+
+```csharp
+QuantityInfo<Length, LengthUnit> info = Length.Info;
+UnitInfo<LengthUnit> kilometer = info[LengthUnit.Kilometer];
+
+Length value = Length.From(1.5, kilometer.Value);
+string abbreviation = kilometer.GetDefaultAbbreviation(CultureInfo.InvariantCulture);
+
+Debug.Assert(info.BaseUnit.Value == LengthUnit.Meter);
+Debug.Assert(info.Units.Contains(kilometer));
+Debug.Assert(ReferenceEquals(info, Quantity.Registry.Get(typeof(Length))));
+```
+
+The quantity type owns common value behavior (`Value`, `Unit`, `Zero`, `From`, `Convert`, `As`,
+`ToUnit`, parsing, and formatting). `Info` owns identity, base-unit metadata, the immutable `Units`
+collection, and base dimensions. `UnitInfo<TUnit>.Value` is the represented enum value;
+`SingularName` and `PluralName` describe it. `BaseUnitInfo`, `UnitInfos`, and `UnitInfo.Name` are
+hidden source-compatibility aliases. Unlike the legacy mutable metadata model, generated metadata
+does not expose configurable conversion expressions or global registration.
+
+### Use an immutable unit system
+
+`UnitSystem` and `BaseUnits` describe a preferred set of constituent units without changing global
+state:
+
+```csharp
+using UnitsNet;
+
+Length length = Length.From(1.5, UnitSystem.SI);
+double meters = Length.FromKilometers(1.5).As(UnitSystem.SI);
+Length normalized = length.ToUnit(UnitSystem.SI);
+```
+
+Resolution considers only units selected into the current module.
+
+## Configure generation
+
+### Authoring naming convention
+
+Authoring types describe generation inputs, so their names distinguish them from the concrete types
+they produce:
+
+| Suffix | Purpose | Example |
+|---|---|---|
+| `Spec` | Identifies one built-in or custom quantity specification | `LengthSpec`, `HowMuchSpec` |
+| `UnitSet` | Selects a reusable subset of a spec's units | `MetricLengthUnitSet` |
+| `Profile` | Composes several specs and unit sets | `MechanicsProfile` |
+
+The module interface names the generation boundary and can use an application-oriented name such as
+`ApplicationUnits`. The `*Spec` suffix is the authoring convention for the corresponding generated
+quantity and unit enum: `LengthSpec` specifies the `Length` quantity and its `LengthUnit` enum.
+
+### Module declaration
+
+`[UnitsNetModule]` marks the single generation boundary in a compilation:
+
+```csharp
+[UnitsNetModule]
+internal interface ApplicationUnits :
+    IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>;
+```
+
+A compilation can contain one module marker. Compose a larger selection with profiles rather than
+declaring multiple modules. `UNM014` reports multiple module markers before they emit colliding
+types.
+
+Without a target namespace, each definition keeps its declared namespace:
+
+- built-in definitions generate quantities into `UnitsNet` and unit enums into `UnitsNet.Units`;
+- custom definitions generate into their JSON `Namespace`;
+- the generated `Quantity` facade is placed in `UnitsNet` when the module includes built-ins, or in
+  the module interface's namespace for a custom-only module.
+
+Pass a target namespace to override every selected definition and emit it into one namespace:
+
+```csharp
+[UnitsNetModule("Contoso.Measurements")]
+internal interface ApplicationUnits :
+    IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>;
+```
+
+Targeting `UnitsNet` explicitly has the same compatibility behavior as the built-in default:
+quantity types use `UnitsNet` and unit enums use `UnitsNet.Units`.
+
+### Select quantities
+
+Include every unit of a definition:
+
+```csharp
+IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>
+```
+
+Include a filtered unit set:
+
+```csharp
+IInclude<UnitsNet.Modular.BuiltIns.LengthSpec, MetricLengthUnitSet>
+```
+
+Built-in spec names add the `Spec` suffix to quantity definition names in the UnitsNet catalog, so
+the `Length` specification is selected with `UnitsNet.Modular.BuiltIns.LengthSpec`. The specs are generated
+by the analyzer in `UnitsNet.Modular.BuiltIns`; generated quantities retain their familiar names,
+such as `Length` and `LengthUnit`. Built-in and custom specs both declare their stable semantic ID
+with `[QuantitySpec]`; the namespace and `Spec` suffix are naming conventions, not lookup
+rules.
+
+### Use profiles
+
+UnitsNet.Modular currently supplies two profiles:
+
+| Profile | Selection |
+|---|---|
+| `UnitsNet.Modular.Profiles.AllQuantitiesProfile` | Every built-in catalog quantity and unit |
+| `UnitsNet.Modular.Profiles.AllSiProfile` | Focused SI mechanics chain used by the POC sample |
+
+Include a profile and add individual definitions:
+
+```csharp
+[UnitsNetModule]
+internal interface ApplicationUnits :
+    IIncludeProfile<UnitsNet.Modular.Profiles.AllQuantitiesProfile>,
+    IInclude<MyCustomSpec>;
+```
+
+Create reusable application profiles from the same authoring interfaces:
+
+```csharp
+internal interface MechanicsProfile :
+    IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>,
+    IInclude<UnitsNet.Modular.BuiltIns.DurationSpec>,
+    IInclude<UnitsNet.Modular.BuiltIns.SpeedSpec>;
+
+internal interface ProductProfile :
+    IIncludeProfile<MechanicsProfile>,
+    IInclude<WidgetCountSpec>;
+
+[UnitsNetModule]
+internal interface ApplicationUnits :
+    IIncludeProfile<ProductProfile>;
+```
+
+Profiles can be nested. A direct `IInclude<TQuantitySpec, TUnitSet>` on the module overrides profile
+unit selections for that quantity. Direct `IInclude<TQuantitySpec>` selects every unit.
+
+### Filter units
+
+Declare a reusable unit set with `[UnitSet]`:
+
+```csharp
+[UnitSet("Meter", "Millimeter", "Kilometer")]
+internal interface CommonLengthUnitSet;
+
+[UnitSet("glob:*Meter")]
+internal interface MeterUnitSet;
+
+[UnitSet("regex:^(Meter|Centi.*|Kilo.*)$")]
+internal interface MetricUnitSet;
+```
+
+Pattern behavior:
+
+| Syntax | Behavior |
+|---|---|
+| `Meter` | Bare glob; exact name when it contains no `*` |
+| `glob:*Meter` | Case-insensitive glob where `*` matches any characters |
+| `regex:.*Meter$` | Case-insensitive, culture-invariant regular expression with a timeout |
+
+Patterns match expanded singular unit names, not abbreviations. Prefix expansion happens before
+filtering, so `.*Meter$` can match `Meter`, `Millimeter`, and `Kilometer`. The base unit is always
+included to keep the quantity convertible. Invalid patterns and patterns matching no unit are
+compile-time errors.
+
+### Select files with MSBuild
+
+Use Roslyn's native `AdditionalFiles` item for custom quantity and relation files:
+
+```xml
+<ItemGroup>
+  <AdditionalFiles Include="Definitions/*.unitsnet.json"
+                   UnitsNetDefinition="true" />
+  <AdditionalFiles Include="Definitions/*.unitsnet.relations.json"
+                   UnitsNetRelation="true" />
+</ItemGroup>
+```
+
+The metadata is optional when the files use the conventional suffixes:
+
+- `*.unitsnet.json`;
+- `*.unitsnet.relations.json`.
+
+Metadata is useful for ordinary names such as `Length.json`.
+
+The package also supports the custom item aliases below:
+
+```xml
+<ItemGroup>
+  <UnitsNetDefinition Include="Definitions/Length.json" />
+  <UnitsNetRelation Include="Definitions/Relations.json" />
+</ItemGroup>
+```
+
+The packaged MSBuild targets map these aliases to `AdditionalFiles`. Native `AdditionalFiles` is
+recommended because some IDE project models, including current Rider versions, do not reliably pass
+custom build actions to the design-time Roslyn host.
+
+### Inspect generated source
+
+Generated files normally stay in Roslyn's in-memory compilation. To write them beneath `obj` for
+debugging or review, add:
+
+```xml
+<PropertyGroup>
+  <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+  <CompilerGeneratedFilesOutputPath>
+    $(BaseIntermediateOutputPath)Generated
+  </CompilerGeneratedFilesOutputPath>
+</PropertyGroup>
+```
+
+Do not compile that output directory explicitly; the compiler already receives the generated
+sources from Roslyn.
+
+## Add custom quantities
+
+### Register a definition
+
+Add a JSON file to the units project:
+
+```xml
+<ItemGroup>
+  <AdditionalFiles Include="HowMuch.unitsnet.json"
+                   UnitsNetDefinition="true" />
+</ItemGroup>
+```
+
+Bind a public or internal quantity spec interface to the definition's stable semantic ID:
+
+```csharp
+using UnitsNet.Modular;
+
+namespace Fictional.Measurements.Definitions;
+
+[QuantitySpec("Fictional.Measurements.HowMuch")]
+public interface HowMuchSpec;
+```
+
+Select the spec in the module:
+
+```csharp
+[UnitsNetModule]
+internal interface ApplicationUnits : IInclude<HowMuchSpec>;
+```
+
+The spec ID must match `Namespace.Name` in the JSON definition. If `Namespace` is omitted, it
+defaults to `UnitsNet`. Treat this semantic ID as a package-boundary identifier: use a namespace
+you own so independently authored definition packages cannot describe unrelated quantities with
+the same identity.
+
+### Define the quantity in JSON
+
+Define the quantity, its units, abbreviations, and conversions in the `MyQuantity.unitsnet.json`
+file. Each unit provides one expression for converting to the quantity's base unit and another for
+converting back. The two expressions should round-trip every supported value.
+
+See [HowMuch.unitsnet.json](Samples/CustomQuantitySample/HowMuch.unitsnet.json) for a complete example and the
+[Quantity and Unit Definition Schema](../Docs/quantity-and-unit-definition-schema.md#unitsnetmodular-compatibility)
+for the full field reference.
+
+## Add quantity relationships
+
+Add a relation file as an `AdditionalFiles` item:
+
+```xml
+<AdditionalFiles Include="Fictional.unitsnet.relations.json"
+                 UnitsNetRelation="true" />
+```
+
+Structured relations use stable semantic quantity IDs and invariant unit names:
+
+```json
+[
+  {
+    "result": {
+      "quantity": "Fictional.Measurements.HowMuchDistance",
+      "unit": "SomeMeter"
+    },
+    "left": {
+      "quantity": "Fictional.Measurements.HowMuch",
+      "unit": "Some"
+    },
+    "operator": "*",
+    "right": {
+      "quantity": "UnitsNet.Length",
+      "unit": "Meter"
+    },
+    "noInferredDivision": false
+  }
+]
+```
+
+Only multiplication relations are declared. The generator:
+
+- emits both operand orders when the operands are different;
+- infers the corresponding division operator;
+- skips inferred division when `noInferredDivision` is true;
+- emits operators only when every participating quantity is selected;
+- uses the relation's anchor units internally even when a unit filter omits those units publicly.
+
+The special endpoint quantities `"double"` and `"1"` describe scalar and reciprocal relationships.
+The older UnitsNet string form is also accepted:
+
+```json
+[
+  "Area.SquareMeter = Length.Meter * Length.Meter",
+  "Speed.MeterPerSecond = Length.Meter * Frequency.Hertz -- NoInferredDivision"
+]
+```
+
+Structured relations are recommended for third-party definitions because fully qualified semantic
+IDs remain unambiguous across namespaces.
+
+## Publish a definition package
+
+A definition package distributes public quantity specs, JSON definitions, relationships, and an
+MSBuild props file, but does not generate or ship the resulting quantity structs.
+
+```text
+Acme.Measurements.Definitions
+├── DefinitionMarkers.cs
+├── Definitions
+│   ├── WidgetCount.unitsnet.json
+│   └── Acme.unitsnet.relations.json
+├── build
+│   └── Acme.Measurements.Definitions.props
+└── Acme.Measurements.Definitions.csproj
+```
+
+Pack the definition files and props:
+
+```xml
+<ItemGroup>
+  <None Include="Definitions/*.unitsnet.json"
+        Pack="true"
+        PackagePath="build/definitions" />
+  <None Include="Definitions/*.unitsnet.relations.json"
+        Pack="true"
+        PackagePath="build/definitions" />
+  <None Include="build/Acme.Measurements.Definitions.props"
+        Pack="true"
+        PackagePath="build/Acme.Measurements.Definitions.props" />
+</ItemGroup>
+```
+
+The props file contributes those files directly to the referencing project's compilation:
+
+```xml
+<Project>
+  <ItemGroup>
+    <AdditionalFiles Include="$(MSBuildThisFileDirectory)definitions/*.unitsnet.json"
+                     UnitsNetDefinition="true" />
+    <AdditionalFiles Include="$(MSBuildThisFileDirectory)definitions/*.unitsnet.relations.json"
+                     UnitsNetRelation="true" />
+  </ItemGroup>
+</Project>
+```
+
+Quantity specs should be public so projects can select them. Keep their `[QuantitySpec]` semantic
+IDs stable once published.
+
+An organization can instead publish one canonical compiled units assembly for several controlled
+applications. That is a deployment choice, not the primary composition model. Independently
+compiled modules do not share type identity or automatically gain cross-module operators.
+
+## Dynamic lookup and serialization
+
+Every module receives one immutable registry containing only its selected quantities:
+
+```csharp
+using UnitsNet;
+
+var registry = GeneratedQuantityRegistry.Instance;
+
+IQuantityDescriptor length = registry.Get("Length");
+IQuantity<double> parsed = length.Parse("1.5 km");
+double meters = length.Convert(1.5, "Kilometer", "Meter");
+
+IQuantity<double> created = registry.Create(
+    500,
+    "Length",
+    "Meter");
+```
+
+The registry supports lookup by semantic `QuantityId`, definition name, quantity CLR type, and unit
+enum CLR type. Descriptors expose selected units, abbreviations, base dimensions, creation,
+conversion, parsing, formatting, and stored value/unit access. `TryGet`, `TryCreate`, `TryConvert`,
+and `TryParse` variants are available for non-throwing workflows.
+
+When a module includes built-ins, the generator emits the source-compatible `Quantity` facade into
+`UnitsNet`:
+
+```csharp
+using UnitsNet;
+
+IQuantity<double> value =
+    UnitsNet.Quantity.From(1.5, "Length", "Kilometer");
+
+IQuantity<double> parsed =
+    UnitsNet.Quantity.Parse(typeof(Length), "1.5 km");
+```
+
+A custom-only module places its facade in the module interface's namespace unless the
+`UnitsNetModule` attribute specifies an explicit target namespace.
+
+### System.Text.Json
+
+Register the generated, AOT-safe converter factory:
+
+```csharp
+using System.Text.Json;
+using UnitsNet;
+
+var options = new JsonSerializerOptions();
+options.Converters.Add(GeneratedQuantityRegistry.JsonConverter);
+
+string json = JsonSerializer.Serialize(Length.FromKilometers(1.5), options);
+Length restored = JsonSerializer.Deserialize<Length>(json, options);
+```
+
+The shape is:
+
+```json
+{
+  "Value": 1.5,
+  "Unit": "Kilometer"
+}
+```
+
+Applications own the compatibility and versioning of serialized contracts. Semantic quantity IDs
+and invariant unit names are the recommended boundary between independently compiled modules. The
+generated converter handles selected concrete quantity types. Deserializing a polymorphic
+`IQuantity<double>` directly is deliberately unsupported because the serialized shape does not
+carry a CLR type or semantic quantity ID; resolve a descriptor by semantic ID at that boundary
+instead.
+
+## Diagnostics
+
+UnitsNet.Modular reports authoring problems at compile time:
+
+| ID | Meaning |
+|---|---|
+| `UNM001` | A selected quantity spec has no built-in or JSON definition |
+| `UNM002` | A unit pattern matched no unit |
+| `UNM003` | A definition does not contain its declared base unit |
+| `UNM004` | A JSON quantity definition is invalid |
+| `UNM005` | Multiple JSON files provide the same semantic quantity ID |
+| `UNM006` | A glob or regular expression is invalid |
+| `UNM010` | A relation file is invalid |
+| `UNM011` | Selected relations are ambiguous or cannot be resolved |
+| `UNM012` | A selected unit set has no patterns |
+| `UNM013` | Definitions collide after applying the target namespace |
+| `UNM014` | A compilation declares more than one module |
+| `UNM015` | An affine quantity's offset quantity is not selected |
+| `UNM016` | The module project also references the incompatible legacy `UnitsNet` assembly |
+
+Each diagnostic links to the relevant configuration documentation from IDEs that display analyzer
+help links.
+
+## Troubleshooting
+
+### A generated quantity type is not found
+
+Confirm that the project either declares a single `[UnitsNetModule]` or references the shared units
+project that does. Select the quantity with `IInclude<TSpec>` or a profile, then build the module
+project. Check the build output for `UNM` diagnostics; the generator does not emit a quantity that
+was not selected.
+
+If the build succeeds but editor completion remains stale, inspect the IDE's source-generator node
+to confirm that quantity sources were emitted. Rebuild and reload the project or solution to refresh
+the design-time Roslyn host. This can be necessary after changing analyzer packages or
+`AdditionalFiles` inputs even though command-line builds already see the generated code.
+
+### A custom JSON definition is ignored
+
+Use Roslyn's native `AdditionalFiles` item so command-line and design-time builds receive the same
+input:
+
+```xml
+<ItemGroup>
+  <AdditionalFiles Include="Definitions/*.unitsnet.json" />
+</ItemGroup>
+```
+
+The definition's `Namespace.Name` must match the semantic ID on `[QuantitySpec]`, and the spec must
+also be selected by the module. See [Add custom quantities](#add-custom-quantities).
+
+### A relationship operator is missing
+
+Relationships are emitted only when every participating quantity is selected. For example,
+`Length / Duration` requires `LengthSpec`, `DurationSpec`, and `SpeedSpec`. Add the missing result or
+operand quantity and rebuild.
+
+### A filtered base unit is still generated
+
+This is intentional. Every selected quantity keeps its base unit as a conversion anchor even when a
+unit-set pattern does not match it.
+
+### The project reports `UNM016`
+
+`UnitsNet` and `UnitsNet.Modular` are alternative implementations and cannot be referenced together
+in the module project. Remove the legacy package reference or move the generated quantities behind a
+separate assembly boundary. See the [migration guide](MIGRATION.md) for compatibility options.
+
+## Samples and design documents
+
+| Start here | Scenario |
+|---|---|
+| [Samples overview](Samples) | Choose a focused scenario and switch between project references, local packages, and published packages |
+| [Getting started](Samples/GettingStartedSample) | Minimal `Length`, `Duration`, and `Speed` application matching the quick start |
+| [Quantity selection](Samples/QuantitySelectionSample) | Select individual quantities and filter their units |
+| [Custom quantity](Samples/CustomQuantitySample) | Generate an application-owned quantity from JSON |
+| [All SI profile](Samples/Profiles/AllSiProfileSample) | Exercise the quantities and relationships selected by `AllSiProfile` |
+| [Playground](Samples/ModularPlayground) | Explore relationships, aggregation, metadata, serialization, and custom definitions |
+| [Shared units library](Samples/SharedUnitsLibrarySample) | Share one generated quantity assembly across several projects |
+
+For design rationale and compatibility details, continue with
+[Architecture](ARCHITECTURE.md) and [Migration notes](MIGRATION.md).
diff --git a/UnitsNet.Modular/Samples/.vscode/launch.json b/UnitsNet.Modular/Samples/.vscode/launch.json
new file mode 100644
index 0000000000..6a34ab53a4
--- /dev/null
+++ b/UnitsNet.Modular/Samples/.vscode/launch.json
@@ -0,0 +1,46 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Sample: Getting started",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/GettingStartedSample/GettingStartedSample.csproj"
+    },
+    {
+      "name": "Sample: Quantity selection",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/QuantitySelectionSample/QuantitySelectionSample.csproj"
+    },
+    {
+      "name": "Sample: Custom quantity",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/CustomQuantitySample/CustomQuantitySample.csproj"
+    },
+    {
+      "name": "Sample: All SI profile",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/Profiles/AllSiProfileSample/AllSiProfileSample.csproj"
+    },
+    {
+      "name": "Sample: Modular playground",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/ModularPlayground/ModularPlayground.csproj"
+    },
+    {
+      "name": "Sample: Shared units library",
+      "type": "dotnet",
+      "request": "launch",
+      "projectPath": "${workspaceFolder}/SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/SharedUnitsLibrarySample.App.csproj"
+    },
+    {
+      "name": ".NET: Attach",
+      "type": "coreclr",
+      "request": "attach"
+    }
+  ]
+}
diff --git a/UnitsNet.Modular/Samples/.vscode/settings.json b/UnitsNet.Modular/Samples/.vscode/settings.json
new file mode 100644
index 0000000000..6ea34a17ba
--- /dev/null
+++ b/UnitsNet.Modular/Samples/.vscode/settings.json
@@ -0,0 +1,5 @@
+{
+  "dotnet.defaultSolution": "UnitsNet.Modular.Samples.slnx",
+  "csharp.debug.console": "integratedTerminal",
+  "terminal.integrated.cwd": "${workspaceFolder}"
+}
diff --git a/UnitsNet.Modular/Samples/.vscode/tasks.json b/UnitsNet.Modular/Samples/.vscode/tasks.json
new file mode 100644
index 0000000000..b610b3de4e
--- /dev/null
+++ b/UnitsNet.Modular/Samples/.vscode/tasks.json
@@ -0,0 +1,35 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Samples: build",
+      "command": "dotnet",
+      "type": "process",
+      "args": [
+        "build",
+        "${workspaceFolder}/UnitsNet.Modular.Samples.slnx",
+        "--configuration",
+        "Debug",
+        "-p:Platform=ProjectReferences",
+        "/property:GenerateFullPaths=true",
+        "/consoleloggerparameters:NoSummary;ForceNoAlign"
+      ],
+      "problemMatcher": "$msCompile",
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      }
+    },
+    {
+      "label": "Samples: refresh local packages",
+      "command": "pwsh",
+      "type": "process",
+      "args": [
+        "-NoProfile",
+        "-File",
+        "${workspaceFolder}/refresh-local-packages.ps1"
+      ],
+      "problemMatcher": "$msCompile"
+    }
+  ]
+}
diff --git a/UnitsNet.Modular/Samples/CustomQuantitySample/CustomQuantitySample.csproj b/UnitsNet.Modular/Samples/CustomQuantitySample/CustomQuantitySample.csproj
new file mode 100644
index 0000000000..f8b3248a96
--- /dev/null
+++ b/UnitsNet.Modular/Samples/CustomQuantitySample/CustomQuantitySample.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UsesUnitsNetModular>true</UsesUnitsNetModular>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+  </PropertyGroup>
+  <ItemGroup>
+    <AdditionalFiles Include="HowMuch.unitsnet.json"
+                     UnitsNetDefinition="true" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/CustomQuantitySample/HowMuch.unitsnet.json b/UnitsNet.Modular/Samples/CustomQuantitySample/HowMuch.unitsnet.json
new file mode 100644
index 0000000000..345ba092b9
--- /dev/null
+++ b/UnitsNet.Modular/Samples/CustomQuantitySample/HowMuch.unitsnet.json
@@ -0,0 +1,71 @@
+{
+  "Name": "HowMuch",
+  "Namespace": "Fictional.Measurements",
+  "BaseUnit": "Some",
+  "Units": [
+    {
+      "SingularName": "Some",
+      "PluralName": "Some",
+      "FromUnitToBaseFunc": "{x}",
+      "FromBaseToUnitFunc": "{x}",
+      "Prefixes": [ "Kilo" ],
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "sm" ]
+        },
+        {
+          "Culture": "nb-NO",
+          "Abbreviations": [ "noe" ],
+          "AbbreviationsForPrefixes": {
+            "Kilo": "knoe"
+          }
+        }
+      ]
+    },
+    {
+      "SingularName": "Lots",
+      "PluralName": "Lots",
+      "FromUnitToBaseFunc": "{x} * 2",
+      "FromBaseToUnitFunc": "{x} / 2",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "lots", "lts" ]
+        },
+        {
+          "Culture": "nb-NO",
+          "Abbreviations": [ "mye" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "Tons",
+      "PluralName": "Tons",
+      "FromUnitToBaseFunc": "({x} * 4) * 5",
+      "FromBaseToUnitFunc": "{x} / (4 * 5)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "tons" ]
+        },
+        {
+          "Culture": "nb-NO",
+          "Abbreviations": [ "tonnevis" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "Magnitude",
+      "PluralName": "Magnitudes",
+      "FromUnitToBaseFunc": "Math.Pow({x}, 2)",
+      "FromBaseToUnitFunc": "Math.Sqrt({x})",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "mag" ]
+        }
+      ]
+    }
+  ]
+}
diff --git a/UnitsNet.Modular/Samples/CustomQuantitySample/Program.cs b/UnitsNet.Modular/Samples/CustomQuantitySample/Program.cs
new file mode 100644
index 0000000000..41ff77e74a
--- /dev/null
+++ b/UnitsNet.Modular/Samples/CustomQuantitySample/Program.cs
@@ -0,0 +1,28 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using UnitsNet.Modular;
+
+namespace Fictional.Measurements;
+
+[QuantitySpec("Fictional.Measurements.HowMuch")]
+public interface HowMuchSpec
+{
+}
+
+[UnitsNetModule]
+internal interface FictionalUnits : IInclude<HowMuchSpec>
+{
+}
+
+internal static class Program
+{
+    public static void Main()
+    {
+        HowMuch amount = HowMuch.Parse("10 tons");
+        HowMuch magnitude = HowMuch.FromMagnitudes(3);
+
+        Console.WriteLine($"{amount} = {amount.ToUnit(HowMuchUnit.Lots)} = {amount.ToUnit(HowMuchUnit.Some)}");
+        Console.WriteLine($"{magnitude} = {magnitude.ToUnit(HowMuchUnit.Some)}");
+        Console.WriteLine($"Generated in custom namespace: {typeof(HowMuch).FullName}");
+    }
+}
diff --git a/UnitsNet.Modular/Samples/CustomQuantitySample/README.md b/UnitsNet.Modular/Samples/CustomQuantitySample/README.md
new file mode 100644
index 0000000000..b26cc75eb0
--- /dev/null
+++ b/UnitsNet.Modular/Samples/CustomQuantitySample/README.md
@@ -0,0 +1,9 @@
+# Custom quantity sample
+
+This focused sample generates the application-owned `Fictional.Measurements.HowMuch` quantity from
+`HowMuch.unitsnet.json`. It demonstrates custom namespaces, linear and nonlinear conversions,
+localization, parsing, and generated factory methods.
+
+Choose the dependency source with the solution platform described in the
+[samples overview](../README.md). The former separate local-NuGet custom-quantity sample is now this
+same project built with the `LocalPackages` platform.
diff --git a/UnitsNet.Modular/Samples/Directory.Build.props b/UnitsNet.Modular/Samples/Directory.Build.props
new file mode 100644
index 0000000000..9096220f90
--- /dev/null
+++ b/UnitsNet.Modular/Samples/Directory.Build.props
@@ -0,0 +1,40 @@
+<!-- Licensed under MIT No Attribution, see LICENSE file at the root. -->
+<Project>
+  <!-- Continue the repository and UnitsNet.Modular build settings from the nearest parent file. -->
+  <Import Project="../Directory.Build.props" />
+
+  <PropertyGroup>
+    <!-- Rider and Visual Studio show these beside the ordinary Debug and Release configurations. -->
+    <Platforms>ProjectReferences;LocalPackages;PublishedPackages</Platforms>
+
+    <!-- Direct project builds without a solution platform retain the contributor-friendly mode. -->
+    <UnitsNetModularSampleDependencyMode
+        Condition="'$(Platform)' == '' or '$(Platform)' == 'AnyCPU'">ProjectReferences</UnitsNetModularSampleDependencyMode>
+    <UnitsNetModularSampleDependencyMode
+        Condition="'$(UnitsNetModularSampleDependencyMode)' == ''">$(Platform)</UnitsNetModularSampleDependencyMode>
+
+    <!-- PackageReference versions are intentionally controlled by this sample infrastructure. -->
+    <CentralPackageFloatingVersionsEnabled>true</CentralPackageFloatingVersionsEnabled>
+    <UnitsNetModularSampleUsePackagedAnalyzer
+        Condition="'$(UnitsNetModularSampleDependencyMode)' != 'ProjectReferences'">true</UnitsNetModularSampleUsePackagedAnalyzer>
+
+    <RestoreSources
+        Condition="'$(UnitsNetModularSampleDependencyMode)' == 'LocalPackages'">$(RepositoryLocalNuGetFeed)</RestoreSources>
+    <RestoreSources
+        Condition="'$(UnitsNetModularSampleDependencyMode)' == 'PublishedPackages'">https://api.nuget.org/v3/index.json</RestoreSources>
+
+    <!--
+      Keep the conventional obj root excluded from source globs. The SDK appends the custom
+      platform to intermediate paths, while NuGet restore and final outputs are isolated here.
+    -->
+    <BaseIntermediateOutputPath>obj/</BaseIntermediateOutputPath>
+    <MSBuildProjectExtensionsPath>obj/$(UnitsNetModularSampleDependencyMode)/</MSBuildProjectExtensionsPath>
+    <OutputPath>$(MSBuildThisFileDirectory)..\..\Artifacts\$(MSBuildProjectName)\$(UnitsNetModularSampleDependencyMode)</OutputPath>
+  </PropertyGroup>
+
+  <!-- Keep the shared package-refresh command visible and runnable from every sample project. -->
+  <ItemGroup>
+    <None Include="$(MSBuildThisFileDirectory)refresh-local-packages.ps1"
+          Link="refresh-local-packages.ps1" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/Directory.Build.targets b/UnitsNet.Modular/Samples/Directory.Build.targets
new file mode 100644
index 0000000000..7a80a377b1
--- /dev/null
+++ b/UnitsNet.Modular/Samples/Directory.Build.targets
@@ -0,0 +1,36 @@
+<!-- Licensed under MIT No Attribution, see LICENSE file at the root. -->
+<Project>
+  <!-- Continue the analyzer dependency plumbing from UnitsNet.Modular. -->
+  <Import Project="../Directory.Build.targets" />
+
+  <PropertyGroup Condition="'$(EmitCompilerGeneratedFiles)' == 'true'">
+    <CompilerGeneratedFilesOutputPath>$(MSBuildProjectDirectory)/obj/$(UnitsNetModularSampleDependencyMode)/$(Configuration)/$(TargetFramework)/Generated</CompilerGeneratedFilesOutputPath>
+  </PropertyGroup>
+
+  <Import Project="UnitsNet.Modular.LocalPackages.targets"
+          Condition="'$(UsesUnitsNetModular)' == 'true' and '$(UnitsNetModularSampleDependencyMode)' == 'LocalPackages'" />
+
+  <ItemGroup Condition="'$(UsesUnitsNetModular)' == 'true' and '$(UnitsNetModularSampleDependencyMode)' == 'ProjectReferences'">
+    <ProjectReference Include="$(MSBuildThisFileDirectory)..\UnitsNet.Modular\UnitsNet.Modular.csproj" />
+    <ProjectReference Include="$(MSBuildThisFileDirectory)..\UnitsNet.Modular.Generator\UnitsNet.Modular.Generator.csproj"
+                      OutputItemType="Analyzer"
+                      ReferenceOutputAssembly="false" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(UsesUnitsNetModular)' == 'true' and '$(UnitsNetModularSampleDependencyMode)' == 'LocalPackages'">
+    <PackageVersion Update="UnitsNet.Modular" Version="$(UnitsNetModularSampleLocalVersion)" />
+    <PackageReference Include="UnitsNet.Modular" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(UsesUnitsNetModular)' == 'true' and '$(UnitsNetModularSampleDependencyMode)' == 'PublishedPackages'">
+    <PackageReference Include="UnitsNet.Modular" />
+  </ItemGroup>
+
+  <Target Name="ValidateUnitsNetModularSampleDependencyMode"
+          BeforeTargets="PrepareForBuild;CollectPackageReferences;AssignProjectConfiguration"
+          Condition="'$(UnitsNetModularSampleDependencyMode)' != 'ProjectReferences' and
+                     '$(UnitsNetModularSampleDependencyMode)' != 'LocalPackages' and
+                     '$(UnitsNetModularSampleDependencyMode)' != 'PublishedPackages'">
+    <Error Text="Unsupported UnitsNet.Modular sample platform '$(Platform)'. Choose ProjectReferences, LocalPackages, or PublishedPackages." />
+  </Target>
+</Project>
diff --git a/UnitsNet.Modular/Samples/GettingStartedSample/ApplicationUnits.cs b/UnitsNet.Modular/Samples/GettingStartedSample/ApplicationUnits.cs
new file mode 100644
index 0000000000..2179611795
--- /dev/null
+++ b/UnitsNet.Modular/Samples/GettingStartedSample/ApplicationUnits.cs
@@ -0,0 +1,12 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using UnitsNet.Modular;
+using Catalog = UnitsNet.Modular.BuiltIns;
+
+namespace MyApplication.Units;
+
+[UnitsNetModule]
+internal interface ApplicationUnits :
+    IInclude<Catalog.LengthSpec>,
+    IInclude<Catalog.DurationSpec>,
+    IInclude<Catalog.SpeedSpec>;
diff --git a/UnitsNet.Modular/Samples/GettingStartedSample/GettingStartedSample.csproj b/UnitsNet.Modular/Samples/GettingStartedSample/GettingStartedSample.csproj
new file mode 100644
index 0000000000..289c5644a1
--- /dev/null
+++ b/UnitsNet.Modular/Samples/GettingStartedSample/GettingStartedSample.csproj
@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UsesUnitsNetModular>true</UsesUnitsNetModular>
+  </PropertyGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/GettingStartedSample/Program.cs b/UnitsNet.Modular/Samples/GettingStartedSample/Program.cs
new file mode 100644
index 0000000000..4389cada25
--- /dev/null
+++ b/UnitsNet.Modular/Samples/GettingStartedSample/Program.cs
@@ -0,0 +1,12 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using UnitsNet;
+using UnitsNet.Units;
+
+Length route = Length.FromKilometers(1.2);
+Length remaining = Length.Parse("500 m");
+Length total = route + remaining;
+Speed pace = total / Duration.FromMinutes(2);
+
+Console.WriteLine($"Total: {total.ToUnit(LengthUnit.Meter):F0}");
+Console.WriteLine($"Pace: {pace:F1}");
diff --git a/UnitsNet.Modular/Samples/GettingStartedSample/README.md b/UnitsNet.Modular/Samples/GettingStartedSample/README.md
new file mode 100644
index 0000000000..bc5f5943d1
--- /dev/null
+++ b/UnitsNet.Modular/Samples/GettingStartedSample/README.md
@@ -0,0 +1,24 @@
+# UnitsNet.Modular getting started
+
+This minimal console app matches the two-file quick start in the main
+[UnitsNet.Modular documentation](../../README.md). It selects `Length`, `Duration`, and `Speed`,
+then constructs, parses, converts, and combines the generated quantities.
+
+In an ordinary application, install the package and copy `ApplicationUnits.cs` and `Program.cs`:
+
+```shell
+dotnet add package UnitsNet.Modular --prerelease
+dotnet run
+```
+
+In this repository the same project supports all three dependency platforms described in the
+[samples overview](../README.md). Choose `PublishedPackages` to mirror the ordinary application,
+`LocalPackages` to test a package built from this checkout, or `ProjectReferences` while developing.
+
+Run the repository scenario from its root with:
+
+```powershell
+pwsh UnitsNet.Modular/Samples/GettingStartedSample/run.ps1
+```
+
+The script selects `Debug | LocalPackages` and uses an isolated package cache.
diff --git a/UnitsNet.Modular/Samples/GettingStartedSample/run.ps1 b/UnitsNet.Modular/Samples/GettingStartedSample/run.ps1
new file mode 100644
index 0000000000..2296f201eb
--- /dev/null
+++ b/UnitsNet.Modular/Samples/GettingStartedSample/run.ps1
@@ -0,0 +1,18 @@
+# Licensed under MIT No Attribution, see LICENSE file at the root.
+
+$ErrorActionPreference = 'Stop'
+
+$repositoryRoot = (Resolve-Path (Join-Path $PSScriptRoot '..\..\..')).Path
+$sampleProject = Join-Path $PSScriptRoot 'GettingStartedSample.csproj'
+$restoreId = [DateTime]::UtcNow.ToString('yyyyMMddHHmmssfff')
+$restorePackages = Join-Path $repositoryRoot "Artifacts\GettingStartedSample\packages\$restoreId"
+
+# The sample's local build dependency packs and restores the latest package before compilation.
+& dotnet run `
+    --project $sampleProject `
+    --configuration Debug `
+    -p:Platform=LocalPackages `
+    "-p:RestorePackagesPath=$restorePackages"
+if ($LASTEXITCODE -ne 0) {
+    throw "Running the getting-started sample failed."
+}
diff --git a/UnitsNet.Modular/Samples/ModularPlayground/ApplicationUnits.cs b/UnitsNet.Modular/Samples/ModularPlayground/ApplicationUnits.cs
new file mode 100644
index 0000000000..ff6c130bbf
--- /dev/null
+++ b/UnitsNet.Modular/Samples/ModularPlayground/ApplicationUnits.cs
@@ -0,0 +1,36 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using UnitsNet.Modular;
+using Catalog = UnitsNet.Modular.BuiltIns;
+
+namespace ModularPlayground;
+
+// Change these lists and rebuild to control exactly which unit enum members are generated.
+[UnitSet("Meter", "Kilometer", "Mile")]
+internal interface PlaygroundLengthUnits;
+
+[UnitSet("Second", "Minute", "Hour")]
+internal interface PlaygroundDurationUnits;
+
+[UnitSet("MeterPerSecond", "KilometerPerHour", "MilePerHour")]
+internal interface PlaygroundSpeedUnits;
+
+[UnitSet("Joule", "KilowattHour")]
+internal interface PlaygroundEnergyUnits;
+
+[UnitSet("Watt", "Kilowatt")]
+internal interface PlaygroundPowerUnits;
+
+// The semantic ID connects this authoring type to ParcelCount.unitsnet.json.
+[QuantitySpec("ModularPlayground.ParcelCount")]
+internal interface ParcelCountSpec;
+
+// Add or remove selections here, then rebuild. Only these quantities are generated.
+[UnitsNetModule]
+internal interface PlaygroundUnits :
+    IInclude<Catalog.LengthSpec, PlaygroundLengthUnits>,
+    IInclude<Catalog.DurationSpec, PlaygroundDurationUnits>,
+    IInclude<Catalog.SpeedSpec, PlaygroundSpeedUnits>,
+    IInclude<Catalog.EnergySpec, PlaygroundEnergyUnits>,
+    IInclude<Catalog.PowerSpec, PlaygroundPowerUnits>,
+    IInclude<ParcelCountSpec>;
diff --git a/UnitsNet.Modular/Samples/ModularPlayground/ModularPlayground.csproj b/UnitsNet.Modular/Samples/ModularPlayground/ModularPlayground.csproj
new file mode 100644
index 0000000000..18203a0b32
--- /dev/null
+++ b/UnitsNet.Modular/Samples/ModularPlayground/ModularPlayground.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UsesUnitsNetModular>true</UsesUnitsNetModular>
+
+    <!-- Keep the generated C# visible so it can be explored in the playground. -->
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+  </PropertyGroup>
+  <ItemGroup>
+    <AdditionalFiles Include="ParcelCount.unitsnet.json"
+                     UnitsNetDefinition="true" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/ModularPlayground/ModularPlayground.slnx b/UnitsNet.Modular/Samples/ModularPlayground/ModularPlayground.slnx
new file mode 100644
index 0000000000..0b6f114a39
--- /dev/null
+++ b/UnitsNet.Modular/Samples/ModularPlayground/ModularPlayground.slnx
@@ -0,0 +1,14 @@
+<Solution>
+  <Configurations>
+    <BuildType Name="Debug" />
+    <BuildType Name="Release" />
+    <Platform Name="ProjectReferences" />
+    <Platform Name="LocalPackages" />
+    <Platform Name="PublishedPackages" />
+  </Configurations>
+  <Project Path="ModularPlayground.csproj">
+    <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+    <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+    <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+  </Project>
+</Solution>
diff --git a/UnitsNet.Modular/Samples/ModularPlayground/ParcelCount.unitsnet.json b/UnitsNet.Modular/Samples/ModularPlayground/ParcelCount.unitsnet.json
new file mode 100644
index 0000000000..9d3c5666f7
--- /dev/null
+++ b/UnitsNet.Modular/Samples/ModularPlayground/ParcelCount.unitsnet.json
@@ -0,0 +1,44 @@
+{
+  "Name": "ParcelCount",
+  "Namespace": "ModularPlayground",
+  "BaseUnit": "Parcel",
+  "BaseDimensions": {},
+  "Units": [
+    {
+      "SingularName": "Parcel",
+      "PluralName": "Parcels",
+      "FromUnitToBaseFunc": "{x}",
+      "FromBaseToUnitFunc": "{x}",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "pkg" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "Dozen",
+      "PluralName": "Dozens",
+      "FromUnitToBaseFunc": "{x} * 12",
+      "FromBaseToUnitFunc": "{x} / 12",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "doz" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "Gross",
+      "PluralName": "Gross",
+      "FromUnitToBaseFunc": "{x} * 144",
+      "FromBaseToUnitFunc": "{x} / 144",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "gr" ]
+        }
+      ]
+    }
+  ]
+}
diff --git a/UnitsNet.Modular/Samples/ModularPlayground/Program.cs b/UnitsNet.Modular/Samples/ModularPlayground/Program.cs
new file mode 100644
index 0000000000..439b6e56d2
--- /dev/null
+++ b/UnitsNet.Modular/Samples/ModularPlayground/Program.cs
@@ -0,0 +1,140 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Globalization;
+using System.Text.Json;
+using UnitsNet;
+using UnitsNet.Units;
+
+namespace ModularPlayground;
+
+internal static class Program
+{
+    private static readonly CultureInfo Invariant = CultureInfo.InvariantCulture;
+
+    public static void Main()
+    {
+        Console.WriteLine("Electric delivery-day planner");
+        Console.WriteLine("Mixed-unit route inputs, parcel manifest, driving time, and charging plan.");
+
+        // This sample intentionally uses several APIs side by side to illustrate their capabilities.
+        // Production code would normally choose the shortest, most natural API for each task instead
+        // of exercising every available alternative in one workflow.
+
+        // APIs illustrated: Parse(), TryParse(), Sum(), Average(), As(), GetAbbreviation(), and static Convert().
+        // Parse() handles required localized input, while TryParse() avoids exceptions for optional input.
+        // Sum() and Average() aggregate mixed units; As() returns only a converted number. Static
+        // Convert() is useful when neither the source nor result needs to be a quantity object.
+        PrintSection("Read and normalize the route manifest");
+        string[] routeInputs = ["48 km", "31 mi", "72 km"];
+        Length[] routeLegs = routeInputs
+            .Select(text => Length.Parse(text, Invariant))
+            .ToArray();
+
+        Length depotDetour = Length.TryParse("12 km", Invariant, out Length parsedDetour)
+            ? parsedDetour
+            : Length.Zero;
+        Length totalRoute = routeLegs
+            .Append(depotDetour)
+            .Sum(LengthUnit.Kilometer);
+        Length averageLeg = routeLegs.Average(LengthUnit.Kilometer);
+        double totalRouteMiles = totalRoute.As(LengthUnit.Mile);
+        string mileAbbreviation = Length.GetAbbreviation(LengthUnit.Mile, Invariant);
+
+        Console.WriteLine($"Route legs: {string.Join(", ", routeLegs.Select(FormatStoredValue))}");
+        Console.WriteLine(
+            $"Total:      {totalRoute.ToString("0.0", Invariant)} / " +
+            $"{totalRouteMiles.ToString("0.0", Invariant)} {mileAbbreviation}");
+        Console.WriteLine($"Average:    {averageLeg.ToString("0.0", Invariant)} per scheduled leg");
+
+        double localSpeedLimitMph = Speed.Convert(
+            80,
+            SpeedUnit.KilometerPerHour,
+            SpeedUnit.MilePerHour);
+        Console.WriteLine($"80 km/h local limit = {localSpeedLimitMph.ToString("F1", Invariant)} mph");
+
+        // APIs illustrated: same-quantity addition, cross-quantity division, ToUnit(), and ToString().
+        // Ordinary arithmetic preserves the quantity type. Cross-quantity operators produce a different
+        // type and are generated only when every participant is selected in ApplicationUnits.cs.
+        // ToUnit() retains a strongly typed quantity for subsequent formatting or calculations.
+        PrintSection("Estimate the driving day");
+        Duration drivingTime = Duration.Parse("4 h", Invariant) + Duration.FromMinutes(25);
+        Speed averageSpeed = totalRoute / drivingTime;
+        Speed displaySpeed = averageSpeed.ToUnit(SpeedUnit.KilometerPerHour);
+
+        Console.WriteLine($"Driving time:  {drivingTime.ToString("0.0", Invariant)}");
+        Console.WriteLine($"Average speed: {displaySpeed.ToString("0.0", Invariant)}");
+
+        // APIs illustrated: cross-quantity multiplication and its inferred division operator.
+        // The Power * Duration = Energy relationship handles anchor-unit conversions, so multiplying
+        // kW by minutes works directly; dividing Energy by Power yields the corresponding Duration.
+        PrintSection("Plan the charging stop");
+        Power charger = Power.Parse("150 kW", Invariant);
+        Duration chargingWindow = Duration.FromMinutes(22);
+        Energy deliveredEnergy = charger * chargingWindow;
+        Energy requestedEnergy = Energy.Parse("42 kWh", Invariant);
+        Duration timeToAddRequestedEnergy = requestedEnergy / charger;
+        Energy displayEnergy = deliveredEnergy.ToUnit(EnergyUnit.KilowattHour);
+        Duration displayChargeTime = timeToAddRequestedEnergy.ToUnit(DurationUnit.Minute);
+
+        Console.WriteLine($"Charger:       {charger.ToString("0", Invariant)}");
+        Console.WriteLine($"Energy in 22m: {displayEnergy.ToString("0.0", Invariant)}");
+        Console.WriteLine($"Time for 42kWh: {displayChargeTime.ToString("0.0", Invariant)}");
+
+        // APIs illustrated: a custom JSON-defined quantity using the same generated API as a built-in.
+        // ParcelCount comes from ParcelCount.unitsnet.json and receives parsing, construction,
+        // conversion, formatting, and arithmetic without hand-written quantity code.
+        PrintSection("Count the cargo with a custom quantity");
+        ParcelCount manifest = ParcelCount.Parse("2 doz", Invariant) + ParcelCount.FromParcels(6);
+        ParcelCount parcelManifest = manifest.ToUnit(ParcelCountUnit.Parcel);
+        ParcelCount dozenManifest = manifest.ToUnit(ParcelCountUnit.Dozen);
+        Console.WriteLine(
+            $"Manifest: {parcelManifest.ToString("0", Invariant)} " +
+            $"({dozenManifest.ToString("0.00", Invariant)})");
+
+        // APIs illustrated: the legacy-shaped Quantity facade, modular registry, and UnitSystem policy.
+        // Quantity.From(...) keeps a familiar call shape for configuration-driven code. Unlike legacy
+        // UnitsNet, the facade is scoped to the selected module and returns UnitsNet.IQuantity<double>.
+        // The modular registry exposes that selected catalog without global mutation.
+        PrintSection("Use the modular dynamic API");
+        IQuantity<double> configuredDistance = Quantity.From(15, "Length", "Mile");
+        var registry = GeneratedQuantityRegistry.Instance;
+        IQuantityDescriptor lengthDescriptor = registry.Get("Length");
+        double configuredKilometers = registry.Convert(15, "Length", "Mile", "Kilometer");
+
+        string formattedConfiguredDistance = lengthDescriptor.Format(configuredDistance, "0.0", Invariant);
+        Console.WriteLine(
+            $"Configured leg: {formattedConfiguredDistance} = " +
+            $"{configuredKilometers.ToString("F1", Invariant)} km");
+        Console.WriteLine($"Selected types: {string.Join(", ", registry.Names.Order())}");
+
+        // Modular unit-system policy is immutable and explicit. It resolves only among units selected
+        // by this module instead of changing process-wide UnitsNetSetup defaults at runtime.
+        Length siRoute = totalRoute.ToUnit(UnitSystem.SI);
+        Console.WriteLine($"SI policy:     {siRoute.ToString("0", Invariant)}");
+
+        // API illustrated: the System.Text.Json converter exposed by the generated registry.
+        // It knows the selected concrete types without assembly scanning, keeping serialization
+        // friendly to trimming and Native AOT.
+        PrintSection("Persist a strongly typed result");
+        var jsonOptions = new JsonSerializerOptions { WriteIndented = false };
+        jsonOptions.Converters.Add(GeneratedQuantityRegistry.JsonConverter);
+        string json = JsonSerializer.Serialize(displayEnergy, jsonOptions);
+        Energy restoredEnergy = JsonSerializer.Deserialize<Energy>(json, jsonOptions);
+
+        Console.WriteLine($"JSON:      {json}");
+        Console.WriteLine($"Round trip:{restoredEnergy.ToString("0.0", Invariant),10}");
+
+        Console.WriteLine();
+        Console.WriteLine("Try editing ApplicationUnits.cs, ParcelCount.unitsnet.json, or this file, then run:");
+        Console.WriteLine("  dotnet run");
+    }
+
+    private static string FormatStoredValue(Length length) => length.ToString("0.#", Invariant);
+
+    private static void PrintSection(string title)
+    {
+        Console.WriteLine();
+        Console.WriteLine(title);
+        Console.WriteLine(new string('-', title.Length));
+    }
+}
diff --git a/UnitsNet.Modular/Samples/ModularPlayground/Properties/launchSettings.json b/UnitsNet.Modular/Samples/ModularPlayground/Properties/launchSettings.json
new file mode 100644
index 0000000000..fac10307a4
--- /dev/null
+++ b/UnitsNet.Modular/Samples/ModularPlayground/Properties/launchSettings.json
@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "Modular playground": {
+      "commandName": "Project"
+    }
+  }
+}
diff --git a/UnitsNet.Modular/Samples/ModularPlayground/README.md b/UnitsNet.Modular/Samples/ModularPlayground/README.md
new file mode 100644
index 0000000000..86d55afbc1
--- /dev/null
+++ b/UnitsNet.Modular/Samples/ModularPlayground/README.md
@@ -0,0 +1,58 @@
+# Modular playground
+
+This console app plans a day for an electric delivery van using mixed-unit route inputs, a parcel
+manifest, driving estimates, and a charging stop. The generated quantity structs and unit enums
+become part of this app at build time; no generated C# is checked in. Choose its dependency source
+with the solution platform described in the [samples overview](../README.md).
+
+The scenario is split into readable sections that exercise:
+
+- parsing and defensive `TryParse` at input boundaries;
+- numeric conversion, `As`, `ToUnit`, and formatted `ToString` output;
+- arithmetic and collection aggregation across mixed units;
+- generated `Length / Duration = Speed` and `Power * Duration = Energy` relationships;
+- an application-specific `ParcelCount` generated from JSON;
+- the selected-module registry and the legacy-shaped `Quantity` facade;
+- explicit immutable `UnitSystem` policy and generated System.Text.Json support.
+
+## Run it from VS Code
+
+Open the samples workspace as described in the [samples overview](../README.md), choose
+**Sample: Modular playground** in **Run and Debug**, then press `F5` to debug or `Ctrl+F5` to run
+without the debugger. Output appears in the integrated terminal.
+
+You can also open a terminal and run:
+
+```shell
+dotnet run
+```
+
+Every edit uses the usual .NET feedback loop: save a file and run `dotnet run` again.
+
+## Refresh the local package
+
+When using `Debug | LocalPackages` in an IDE, run the sample refresh script to create uniquely
+versioned packages from the current checkout and force every sample to restore that exact version:
+
+```powershell
+pwsh ../refresh-local-packages.ps1
+```
+
+The unique version avoids reusing older packages from NuGet's global package cache. The script
+packs the library and sample definition package in `Release`, then restores all samples for
+`Debug | LocalPackages`; pass `-Configuration Release` to restore the release configuration instead.
+
+## Experiment
+
+Start with any of these:
+
+1. In `ApplicationUnits.cs`, add or remove a built-in `IInclude<...>` quantity selection.
+2. Change a `[UnitSet]` list and see which enum members remain available after rebuilding.
+3. In `ParcelCount.unitsnet.json`, add a unit or change a conversion expression.
+4. In `Program.cs`, use the generated types, conversions, parsing, formatting, or operators.
+
+The project enables `EmitCompilerGeneratedFiles`, so after a build you can also inspect the emitted
+C# under `obj/<dependency-platform>/<configuration>/<framework>/Generated/UnitsNet.Modular.Generator/UnitsNet.Modular.Generator.UnitsNetModularGenerator/`.
+Delete or ignore that folder when you are done; it is build output and is not part of the project.
+
+For the complete authoring model, see the [UnitsNet.Modular documentation](../../README.md).
diff --git a/UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/AllSiProfileSample.csproj b/UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/AllSiProfileSample.csproj
new file mode 100644
index 0000000000..ad254eeade
--- /dev/null
+++ b/UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/AllSiProfileSample.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UsesUnitsNetModular>true</UsesUnitsNetModular>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+  </PropertyGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/Program.cs b/UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/Program.cs
new file mode 100644
index 0000000000..2e175df4da
--- /dev/null
+++ b/UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/Program.cs
@@ -0,0 +1,35 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using UnitsNet;
+using UnitsNet.Modular;
+using UnitsNet.Modular.Profiles;
+using UnitsNet.Units;
+
+namespace AllSiProfileSample;
+
+[UnitsNetModule]
+internal interface AllSiUnits : IIncludeProfile<AllSiProfile>
+{
+}
+
+internal static class Program
+{
+    public static void Main()
+    {
+        Length distance = Length.FromKilometers(1.2);
+        Duration duration = Duration.FromMinutes(1);
+        Speed speed = distance / duration;
+        Acceleration acceleration = speed / Duration.FromSeconds(10);
+        Force force = Mass.FromKilograms(1500) * acceleration;
+        Pressure pressure = force / (Length.FromMeters(2) * Length.FromMeters(3));
+        Power power = force * speed;
+        Energy energy = power * Duration.FromSeconds(30);
+
+        Console.WriteLine($"Distance: {distance}");
+        Console.WriteLine($"Speed: {speed.ToUnit(SpeedUnit.KilometerPerHour)}");
+        Console.WriteLine($"Force: {force}");
+        Console.WriteLine($"Pressure: {pressure.ToUnit(PressureUnit.Kilopascal)}");
+        Console.WriteLine($"Energy: {energy.ToUnit(EnergyUnit.Kilojoule)}");
+        Console.WriteLine($"Power: {power.ToUnit(PowerUnit.Kilowatt)}");
+    }
+}
diff --git a/UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/README.md b/UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/README.md
new file mode 100644
index 0000000000..8a3c152e2c
--- /dev/null
+++ b/UnitsNet.Modular/Samples/Profiles/AllSiProfileSample/README.md
@@ -0,0 +1,7 @@
+# All SI profile sample
+
+This sample includes `AllSiProfile` and exercises its generated relationship chain from `Length`
+and `Duration` through `Speed`, `Acceleration`, `Force`, `Pressure`, `Power`, and `Energy`.
+
+Choose the dependency source with the solution platform described in the
+[samples overview](../../README.md).
diff --git a/UnitsNet.Modular/Samples/QuantitySelectionSample/Program.cs b/UnitsNet.Modular/Samples/QuantitySelectionSample/Program.cs
new file mode 100644
index 0000000000..2234d3e6b5
--- /dev/null
+++ b/UnitsNet.Modular/Samples/QuantitySelectionSample/Program.cs
@@ -0,0 +1,39 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using UnitsNet;
+using UnitsNet.Modular;
+using UnitsNet.Units;
+using Catalog = UnitsNet.Modular.BuiltIns;
+
+namespace QuantitySelectionSample;
+
+[UnitSet("regex:.*Meter$")]
+internal interface MeterUnitSet
+{
+}
+
+[UnitSet("regex:.*Byte$")]
+internal interface ByteUnitSet
+{
+}
+
+[UnitsNetModule]
+internal interface SelectedUnits :
+    IInclude<Catalog.LengthSpec, MeterUnitSet>,
+    IInclude<Catalog.InformationSpec, ByteUnitSet>
+{
+}
+
+internal static class Program
+{
+    public static void Main()
+    {
+        Length parsed = Length.Parse("2.5 km");
+        Information payload = Information.FromKibibytes(2);
+
+        Console.WriteLine($"{parsed} = {parsed.ToUnit(LengthUnit.Meter)}");
+        Console.WriteLine($"{payload} = {payload.ToUnit(InformationUnit.Bit)}");
+        Console.WriteLine($"Generated quantities: {nameof(Length)}, {nameof(Information)}");
+        Console.WriteLine($"Generated length units: {string.Join(", ", Enum.GetNames<LengthUnit>())}");
+    }
+}
diff --git a/UnitsNet.Modular/Samples/QuantitySelectionSample/QuantitySelectionSample.csproj b/UnitsNet.Modular/Samples/QuantitySelectionSample/QuantitySelectionSample.csproj
new file mode 100644
index 0000000000..02ac62d792
--- /dev/null
+++ b/UnitsNet.Modular/Samples/QuantitySelectionSample/QuantitySelectionSample.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UsesUnitsNetModular>true</UsesUnitsNetModular>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+  </PropertyGroup>
+  <ItemGroup>
+    <AdditionalFiles Include="../../../Common/UnitDefinitions/Length.json"
+                     UnitsNetDefinition="true" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/QuantitySelectionSample/README.md b/UnitsNet.Modular/Samples/QuantitySelectionSample/README.md
new file mode 100644
index 0000000000..5693120829
--- /dev/null
+++ b/UnitsNet.Modular/Samples/QuantitySelectionSample/README.md
@@ -0,0 +1,8 @@
+# Quantity selection sample
+
+This focused sample includes only `Length` and `Information`, then uses `[UnitSet]` filters to keep
+meter- and byte-based units. It demonstrates how a consumer controls both the generated quantity
+catalog and the API surface of each unit enum.
+
+Choose the dependency source with the solution platform described in the
+[samples overview](../README.md).
diff --git a/UnitsNet.Modular/Samples/README.md b/UnitsNet.Modular/Samples/README.md
new file mode 100644
index 0000000000..62e3800950
--- /dev/null
+++ b/UnitsNet.Modular/Samples/README.md
@@ -0,0 +1,73 @@
+# UnitsNet.Modular samples
+
+Each sample has one distinct purpose. In Rider or Visual Studio, choose the normal `Debug` or
+`Release` configuration together with the dependency platform that you want to exercise.
+
+| Sample | Code | Purpose |
+|---|---|---|
+| [Getting started](GettingStartedSample/README.md) | [Program.cs](GettingStartedSample/Program.cs) | Minimal built-in `Length`, `Duration`, and `Speed` application matching the main quick start |
+| [Quantity selection](QuantitySelectionSample/README.md) | [Program.cs](QuantitySelectionSample/Program.cs) | Select individual quantities and filter their generated unit sets |
+| [Custom quantity](CustomQuantitySample/README.md) | [Program.cs](CustomQuantitySample/Program.cs) | Generate an application-owned quantity from a JSON definition |
+| [All SI profile](Profiles/AllSiProfileSample/README.md) | [Program.cs](Profiles/AllSiProfileSample/Program.cs) | Include `AllSiProfile` and exercise its SI relationship chain |
+| [Modular playground](ModularPlayground/README.md) | [Program.cs](ModularPlayground/Program.cs) | Explore parsing, arithmetic, metadata, serialization, relationships, and custom definitions |
+| [Shared units library](SharedUnitsLibrarySample/README.md) | [Program.cs](SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/Program.cs) | Generate quantities once in a class library and share their CLR types across multiple projects |
+
+The broader playground complements the focused samples: it is intended for experimentation, while
+the other projects keep one concept easy to find and copy.
+
+## Run and debug in VS Code
+
+Open the samples as the VS Code workspace:
+
+```powershell
+code UnitsNet.Modular/Samples
+```
+
+The workspace loads the samples-only solution automatically. In **Run and Debug**, choose any
+`Sample: ...` configuration, then press `F5` to debug or `Ctrl+F5` to run without the debugger.
+There is one launch configuration for each runnable sample; the shared-units configuration starts
+its console application. These launches use `Debug | ProjectReferences`, so they build directly
+from the current checkout without preparing packages.
+
+Use **Terminal > Run Task > Samples: build** (or `Ctrl+Shift+B`) to build every sample. To prepare
+fresh local packages for all samples, run the **Samples: refresh local packages** task.
+
+## Choose the dependency source
+
+The solution platform controls where every sample gets `UnitsNet.Modular`:
+
+| Platform | Dependency source |
+|---|---|
+| `ProjectReferences` | Runtime and generator projects from the current checkout |
+| `LocalPackages` | Fresh packages built into `Artifacts/Nugets` from the current checkout |
+| `PublishedPackages` | The published `UnitsNet.Modular` package from NuGet.org |
+
+`Debug | ProjectReferences` is the contributor-friendly default. The output and NuGet restore
+state for each dependency platform are isolated, so switching the IDE selector cannot reuse stale
+assets from another mode.
+
+The same modes are available from the command line:
+
+```powershell
+dotnet build UnitsNet.Modular.slnx --configuration Debug -p:Platform=ProjectReferences
+dotnet build UnitsNet.Modular.slnx --configuration Debug -p:Platform=LocalPackages
+dotnet build UnitsNet.Modular.slnx --configuration Debug -p:Platform=PublishedPackages
+```
+
+Direct sample-project builds that do not specify `Platform` default to `ProjectReferences`.
+`LocalPackages` builds update the packages automatically; pass
+`-p:UnitsNetModularSampleUpdateLocalPackagesOnBuild=false` to use packages already in the local
+feed. Override `UnitsNetModularPublishedVersion` to test a different published version.
+
+If an IDE build bypasses the local-package build target, explicitly pack fresh, uniquely versioned
+packages and force every sample project to restore them:
+
+```powershell
+pwsh UnitsNet.Modular/Samples/refresh-local-packages.ps1
+```
+
+Pass `-Configuration Release` to restore the samples for `Release | LocalPackages` instead.
+
+The shared-units sample also contains an intentionally fictional definition package. In
+`LocalPackages` mode both packages cross the local NuGet boundary. In the other modes the fictional
+definitions remain source-local while `UnitsNet.Modular` comes from the selected dependency source.
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Definitions/Fictional.Measurements.unitsnet.relations.json b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Definitions/Fictional.Measurements.unitsnet.relations.json
new file mode 100644
index 0000000000..8cfbc98677
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Definitions/Fictional.Measurements.unitsnet.relations.json
@@ -0,0 +1,17 @@
+[
+  {
+    "result": {
+      "quantity": "Fictional.Measurements.HowMuchDistance",
+      "unit": "SomeMeter"
+    },
+    "left": {
+      "quantity": "Fictional.Measurements.HowMuch",
+      "unit": "Some"
+    },
+    "operator": "*",
+    "right": {
+      "quantity": "UnitsNet.Length",
+      "unit": "Meter"
+    }
+  }
+]
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Definitions/HowMuch.unitsnet.json b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Definitions/HowMuch.unitsnet.json
new file mode 100644
index 0000000000..8975209c45
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Definitions/HowMuch.unitsnet.json
@@ -0,0 +1,42 @@
+{
+  "Name": "HowMuch",
+  "Namespace": "Fictional.Measurements",
+  "BaseUnit": "Some",
+  "Units": [
+    {
+      "SingularName": "Some",
+      "PluralName": "Some",
+      "FromUnitToBaseFunc": "{x}",
+      "FromBaseToUnitFunc": "{x}",
+      "Prefixes": [ "Kilo" ],
+      "Localization": [
+        { "Culture": "en-US", "Abbreviations": [ "sm" ] },
+        {
+          "Culture": "nb-NO",
+          "Abbreviations": [ "noe" ],
+          "AbbreviationsForPrefixes": { "Kilo": [ "knoe", "kn" ] }
+        }
+      ]
+    },
+    {
+      "SingularName": "Lots",
+      "PluralName": "Lots",
+      "FromUnitToBaseFunc": "{x} * 2",
+      "FromBaseToUnitFunc": "{x} / 2",
+      "Localization": [
+        { "Culture": "en-US", "Abbreviations": [ "lots", "lts" ] },
+        { "Culture": "nb-NO", "Abbreviations": [ "mye" ] }
+      ]
+    },
+    {
+      "SingularName": "Tons",
+      "PluralName": "Tons",
+      "FromUnitToBaseFunc": "({x} * 4) * 5",
+      "FromBaseToUnitFunc": "{x} / (4 * 5)",
+      "Localization": [
+        { "Culture": "en-US", "Abbreviations": [ "tons" ] },
+        { "Culture": "nb-NO", "Abbreviations": [ "tonnevis" ] }
+      ]
+    }
+  ]
+}
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Definitions/HowMuchDistance.unitsnet.json b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Definitions/HowMuchDistance.unitsnet.json
new file mode 100644
index 0000000000..e0c645a5d5
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Definitions/HowMuchDistance.unitsnet.json
@@ -0,0 +1,16 @@
+{
+  "Name": "HowMuchDistance",
+  "Namespace": "Fictional.Measurements",
+  "BaseUnit": "SomeMeter",
+  "Units": [
+    {
+      "SingularName": "SomeMeter",
+      "PluralName": "SomeMeters",
+      "FromUnitToBaseFunc": "{x}",
+      "FromBaseToUnitFunc": "{x}",
+      "Localization": [
+        { "Culture": "en-US", "Abbreviations": [ "sm·m" ] }
+      ]
+    }
+  ]
+}
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Fictional.Measurements.Definitions.csproj b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Fictional.Measurements.Definitions.csproj
new file mode 100644
index 0000000000..e305a16336
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Fictional.Measurements.Definitions.csproj
@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UsesUnitsNetModular>true</UsesUnitsNetModular>
+    <IsPackable>true</IsPackable>
+    <PackageId>Fictional.Measurements.Definitions</PackageId>
+    <PackageVersion>1.0.0-alpha.1</PackageVersion>
+    <Authors>UnitsNet.Modular sample</Authors>
+    <Description>Definition-only sample package for UnitsNet.Modular quantities and relationships.</Description>
+    <PackageLicenseExpression>MIT-0</PackageLicenseExpression>
+    <PackageProjectUrl>https://github.com/angularsen/UnitsNet/tree/master/UnitsNet.Modular</PackageProjectUrl>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageTags>unitsnet-modular definitions quantities units sample</PackageTags>
+  </PropertyGroup>
+  <ItemGroup>
+    <None Include="Definitions/*.unitsnet.json"
+          Pack="true"
+          PackagePath="build/definitions" />
+    <None Include="Definitions/*.unitsnet.relations.json"
+          Pack="true"
+          PackagePath="build/definitions" />
+    <None Include="build/Fictional.Measurements.Definitions.props"
+          Pack="true"
+          PackagePath="build/Fictional.Measurements.Definitions.props" />
+    <None Include="README.md" Pack="true" PackagePath="README.md" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/QuantitySpecs.cs b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/QuantitySpecs.cs
new file mode 100644
index 0000000000..889083aa23
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/QuantitySpecs.cs
@@ -0,0 +1,13 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using UnitsNet.Modular;
+
+namespace Fictional.Measurements.Definitions;
+
+/// <summary>Represents the fictional HowMuch spec from this definition package.</summary>
+[QuantitySpec("Fictional.Measurements.HowMuch")]
+public interface HowMuchSpec;
+
+/// <summary>Represents the fictional HowMuchDistance spec from this definition package.</summary>
+[QuantitySpec("Fictional.Measurements.HowMuchDistance")]
+public interface HowMuchDistanceSpec;
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/README.md b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/README.md
new file mode 100644
index 0000000000..e0d168efa3
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/README.md
@@ -0,0 +1,8 @@
+# Fictional.Measurements.Definitions
+
+This sample package contributes fictional quantity definitions and relationships to the project
+that references it. It intentionally contains no compiled quantity structs. The consuming
+application's UnitsNet.Modular module chooses the definitions and generates the concrete types.
+
+It belongs to the [shared units library sample](../README.md), which demonstrates both direct
+project consumption and local NuGet package consumption.
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/build/Fictional.Measurements.Definitions.props b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/build/Fictional.Measurements.Definitions.props
new file mode 100644
index 0000000000..9120370116
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/Fictional.Measurements.Definitions/build/Fictional.Measurements.Definitions.props
@@ -0,0 +1,9 @@
+<Project>
+  <!-- Definition packages contribute compile-time data only to the project that references them. -->
+  <ItemGroup>
+    <AdditionalFiles Include="$(MSBuildThisFileDirectory)definitions/*.unitsnet.json"
+                     UnitsNetDefinition="true" />
+    <AdditionalFiles Include="$(MSBuildThisFileDirectory)definitions/*.unitsnet.relations.json"
+                     UnitsNetRelation="true" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/README.md b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/README.md
new file mode 100644
index 0000000000..c4ac461bc5
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/README.md
@@ -0,0 +1,37 @@
+# Shared units library sample
+
+This multi-project sample generates quantities once in `SharedUnitsLibrarySample.Units` and shares
+those exact CLR types with a domain library and console application. It demonstrates the assembly
+boundary an application can use when several projects need the same generated quantities.
+
+The projects have deliberately separate responsibilities:
+
+- `Fictional.Measurements.Definitions` supplies reusable quantity specifications, JSON definitions,
+  localization, and relationships. It contains no generated quantity structs.
+- `SharedUnitsLibrarySample.Units` selects the built-in and fictional definitions and owns the
+  generated types.
+- `SharedUnitsLibrarySample.Domain` consumes those types in domain logic.
+- `SharedUnitsLibrarySample.App` references both libraries and proves that the generated types have
+  one shared assembly identity.
+
+## Dependency modes
+
+Choose `ProjectReferences`, `LocalPackages`, or `PublishedPackages` in the solution platform
+selector. See the [samples overview](../README.md) for the complete mode matrix.
+
+In `LocalPackages` mode, both `UnitsNet.Modular` and the fictional definition provider are packed
+and consumed through `PackageReference`. This validates that the definition package contributes its
+`build/*.props` files like an external package.
+
+In `ProjectReferences` and `PublishedPackages` modes, the fictional provider remains a project
+reference and its JSON files are included explicitly because project references do not import NuGet
+`build/*.props`. `UnitsNet.Modular` still comes from the selected source.
+
+Run the complete scenario from the repository root:
+
+```powershell
+dotnet run `
+  --project UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/SharedUnitsLibrarySample.App.csproj `
+  --configuration Debug `
+  -p:Platform=ProjectReferences
+```
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/Program.cs b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/Program.cs
new file mode 100644
index 0000000000..832dcc3643
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/Program.cs
@@ -0,0 +1,9 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using SharedUnitsLibrarySample.Domain;
+using Fictional.Measurements;
+
+HowMuchDistance allocation = MeasurementService.MeasureAllocation();
+
+Console.WriteLine(allocation.ToUnit(HowMuchDistanceUnit.SomeMeter));
+Console.WriteLine($"Shared quantity assembly: {typeof(HowMuchDistance).Assembly.GetName().Name}");
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/SharedUnitsLibrarySample.App.csproj b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/SharedUnitsLibrarySample.App.csproj
new file mode 100644
index 0000000000..54fc66de0e
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/SharedUnitsLibrarySample.App.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../SharedUnitsLibrarySample.Domain/SharedUnitsLibrarySample.Domain.csproj" />
+    <ProjectReference Include="../SharedUnitsLibrarySample.Units/SharedUnitsLibrarySample.Units.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Domain/MeasurementService.cs b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Domain/MeasurementService.cs
new file mode 100644
index 0000000000..b2f10e4abd
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Domain/MeasurementService.cs
@@ -0,0 +1,16 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using Fictional.Measurements;
+using UnitsNet;
+
+namespace SharedUnitsLibrarySample.Domain;
+
+public static class MeasurementService
+{
+    public static HowMuchDistance MeasureAllocation()
+    {
+        HowMuch amount = HowMuch.FromLots(3);
+        Length distance = Length.FromMeters(4);
+        return amount * distance;
+    }
+}
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Domain/SharedUnitsLibrarySample.Domain.csproj b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Domain/SharedUnitsLibrarySample.Domain.csproj
new file mode 100644
index 0000000000..0cf92367fd
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Domain/SharedUnitsLibrarySample.Domain.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../SharedUnitsLibrarySample.Units/SharedUnitsLibrarySample.Units.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Units/ApplicationUnits.cs b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Units/ApplicationUnits.cs
new file mode 100644
index 0000000000..774ddbeca7
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Units/ApplicationUnits.cs
@@ -0,0 +1,12 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using Fictional.Measurements.Definitions;
+using UnitsNet.Modular;
+
+namespace SharedUnitsLibrarySample.Units;
+
+[UnitsNetModule]
+internal interface ApplicationUnits :
+    IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>,
+    IInclude<HowMuchSpec>,
+    IInclude<HowMuchDistanceSpec>;
diff --git a/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Units/SharedUnitsLibrarySample.Units.csproj b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Units/SharedUnitsLibrarySample.Units.csproj
new file mode 100644
index 0000000000..9c6444ad2e
--- /dev/null
+++ b/UnitsNet.Modular/Samples/SharedUnitsLibrarySample/SharedUnitsLibrarySample.Units/SharedUnitsLibrarySample.Units.csproj
@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UsesUnitsNetModular>true</UsesUnitsNetModular>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(UnitsNetModularSampleDependencyMode)' == 'LocalPackages'">
+    <PackageVersion Include="Fictional.Measurements.Definitions"
+                    Version="$(UnitsNetModularSampleLocalVersion)" />
+    <PackageReference Include="Fictional.Measurements.Definitions" />
+    <UnitsNetModularSampleAdditionalLocalPackageProject
+        Include="../Fictional.Measurements.Definitions/Fictional.Measurements.Definitions.csproj" />
+    <UnitsNetModularSampleAdditionalLocalPackageInput
+        Include="../Fictional.Measurements.Definitions/**/*"
+        Exclude="../Fictional.Measurements.Definitions/bin/**/*;../Fictional.Measurements.Definitions/obj/**/*" />
+  </ItemGroup>
+
+  <!-- Project references do not import a definition package's build/*.props content. -->
+  <ItemGroup Condition="'$(UnitsNetModularSampleDependencyMode)' != 'LocalPackages'">
+    <ProjectReference Include="../Fictional.Measurements.Definitions/Fictional.Measurements.Definitions.csproj" />
+    <AdditionalFiles Include="../Fictional.Measurements.Definitions/Definitions/*.unitsnet.json"
+                     UnitsNetDefinition="true" />
+    <AdditionalFiles Include="../Fictional.Measurements.Definitions/Definitions/*.unitsnet.relations.json"
+                     UnitsNetRelation="true" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/Samples/UnitsNet.Modular.LocalPackages.targets b/UnitsNet.Modular/Samples/UnitsNet.Modular.LocalPackages.targets
new file mode 100644
index 0000000000..289049d907
--- /dev/null
+++ b/UnitsNet.Modular/Samples/UnitsNet.Modular.LocalPackages.targets
@@ -0,0 +1,98 @@
+<Project>
+  <PropertyGroup>
+    <!--
+      Repository-only sample settings. These are custom UnitsNet.Modular properties, not built-in
+      MSBuild properties. Package-facing samples always restore from the repository-local feed.
+    -->
+    <RepositoryLocalNuGetFeed
+        Condition="'$(RepositoryLocalNuGetFeed)' == ''">$(MSBuildThisFileDirectory)..\..\Artifacts\Nugets</RepositoryLocalNuGetFeed>
+    <UnitsNetModularSampleLocalFeed
+        Condition="'$(UnitsNetModularSampleLocalFeed)' == ''">$(RepositoryLocalNuGetFeed)</UnitsNetModularSampleLocalFeed>
+    <UnitsNetModularSampleLocalVersion
+        Condition="'$(UnitsNetModularSampleLocalVersion)' == ''">6.0.0-local.dev.*</UnitsNetModularSampleLocalVersion>
+
+    <!-- Retain the original singular switch as a compatibility alias for existing commands. -->
+    <UnitsNetModularSampleUpdateLocalPackagesOnBuild
+        Condition="'$(UnitsNetModularSampleUpdateLocalPackagesOnBuild)' == '' and '$(UnitsNetModularSampleUpdateLocalPackageOnBuild)' != ''">$(UnitsNetModularSampleUpdateLocalPackageOnBuild)</UnitsNetModularSampleUpdateLocalPackagesOnBuild>
+    <UnitsNetModularSampleUpdateLocalPackagesOnBuild
+        Condition="'$(UnitsNetModularSampleUpdateLocalPackagesOnBuild)' == ''">true</UnitsNetModularSampleUpdateLocalPackagesOnBuild>
+    <!-- Leading underscores follow the MSBuild convention for implementation-private properties. -->
+    <_UnitsNetModularSourceRoot>$(MSBuildThisFileDirectory)..\</_UnitsNetModularSourceRoot>
+    <_UnitsNetModularSourceProject>$(_UnitsNetModularSourceRoot)UnitsNet.Modular\UnitsNet.Modular.csproj</_UnitsNetModularSourceProject>
+    <_UnitsNetModularSampleLocalPackStamp>$(UnitsNetModularSampleLocalFeed)\.UnitsNet.Modular.local-pack.stamp</_UnitsNetModularSampleLocalPackStamp>
+    <_UnitsNetModularSampleAdditionalLocalPackStamp>$(UnitsNetModularSampleLocalFeed)\.$(MSBuildProjectName).additional-local-pack.stamp</_UnitsNetModularSampleAdditionalLocalPackStamp>
+    <!-- MinVer cannot distinguish uncommitted edits, so local packages use a unique override. -->
+    <_UnitsNetModularSampleLocalPackageVersion>6.0.0-local.dev.$([System.DateTime]::UtcNow.ToString('yyyyMMddHHmmssfff'))</_UnitsNetModularSampleLocalPackageVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <_UnitsNetModularLocalPackageInput Include="$(_UnitsNetModularSourceRoot)UnitsNet.Modular\**\*"
+                                   Exclude="$(_UnitsNetModularSourceRoot)UnitsNet.Modular\bin\**;$(_UnitsNetModularSourceRoot)UnitsNet.Modular\obj\**" />
+    <_UnitsNetModularLocalPackageInput Include="$(_UnitsNetModularSourceRoot)UnitsNet.Modular.Generator\**\*"
+                                   Exclude="$(_UnitsNetModularSourceRoot)UnitsNet.Modular.Generator\bin\**;$(_UnitsNetModularSourceRoot)UnitsNet.Modular.Generator\obj\**" />
+    <_UnitsNetModularLocalPackageInput Include="$(MSBuildThisFileFullPath)" />
+    <_UnitsNetModularLocalPackageInput Include="$(_UnitsNetModularSourceRoot)ARCHITECTURE.md" />
+    <_UnitsNetModularLocalPackageInput Include="$(_UnitsNetModularSourceRoot)README.md" />
+    <_UnitsNetModularLocalPackageInput Include="$(_UnitsNetModularSourceRoot)THIRD-PARTY-NOTICES.md" />
+    <_UnitsNetModularLocalPackageInput Include="$(_UnitsNetModularSourceRoot)Directory.Build.props" />
+    <_UnitsNetModularLocalPackageInput Include="$(_UnitsNetModularSourceRoot)Directory.Build.targets" />
+    <_UnitsNetModularLocalPackageInput Include="$(_UnitsNetModularSourceRoot)Directory.Packages.props" />
+    <_UnitsNetModularLocalPackageInput Include="$(_UnitsNetModularSourceRoot)..\Docs\Images\logo-32.png" />
+  </ItemGroup>
+
+  <Target Name="_PackLocalUnitsNetModularPackage"
+          Condition="'$(UnitsNetModularSampleUpdateLocalPackagesOnBuild)' == 'true'"
+          Inputs="@(_UnitsNetModularLocalPackageInput)"
+          Outputs="$(_UnitsNetModularSampleLocalPackStamp)">
+    <Message Importance="high" Text="Packing the latest local UnitsNet.Modular package..." />
+    <Exec Command="dotnet pack &quot;$(_UnitsNetModularSourceProject)&quot; --configuration Release --output &quot;$(UnitsNetModularSampleLocalFeed)&quot; -p:Platform=ProjectReferences -p:MinVerVersionOverride=$(_UnitsNetModularSampleLocalPackageVersion)" />
+
+    <PropertyGroup>
+      <_UnitsNetModularSamplePackagesUpdated>true</_UnitsNetModularSamplePackagesUpdated>
+    </PropertyGroup>
+    <Touch Files="$(_UnitsNetModularSampleLocalPackStamp)" AlwaysCreate="true" />
+  </Target>
+
+  <Target Name="_PackAdditionalLocalUnitsNetModularPackages"
+          DependsOnTargets="_PackLocalUnitsNetModularPackage"
+          Condition="'$(UnitsNetModularSampleUpdateLocalPackagesOnBuild)' == 'true' and '@(UnitsNetModularSampleAdditionalLocalPackageProject)' != ''"
+          Inputs="@(UnitsNetModularSampleAdditionalLocalPackageInput)"
+          Outputs="$(_UnitsNetModularSampleAdditionalLocalPackStamp)">
+    <Message
+             Importance="high"
+             Text="Packing local definition package %(UnitsNetModularSampleAdditionalLocalPackageProject.Identity)..." />
+    <Exec Command="dotnet pack &quot;%(UnitsNetModularSampleAdditionalLocalPackageProject.Identity)&quot; --configuration Release --output &quot;$(UnitsNetModularSampleLocalFeed)&quot; -p:Platform=ProjectReferences -p:MinVerVersionOverride=$(_UnitsNetModularSampleLocalPackageVersion) -p:PackageVersion=$(_UnitsNetModularSampleLocalPackageVersion)" />
+    <PropertyGroup>
+      <_UnitsNetModularSamplePackagesUpdated>true</_UnitsNetModularSamplePackagesUpdated>
+    </PropertyGroup>
+    <Touch Files="$(_UnitsNetModularSampleAdditionalLocalPackStamp)" AlwaysCreate="true" />
+  </Target>
+
+  <Target Name="_PackLocalUnitsNetModularPackages"
+          DependsOnTargets="_PackLocalUnitsNetModularPackage;_PackAdditionalLocalUnitsNetModularPackages"
+          Condition="'$(UnitsNetModularSampleUpdateLocalPackagesOnBuild)' == 'true'">
+  </Target>
+
+  <!-- Bootstrap the feed before NuGet tries to resolve a floating PackageReference. -->
+  <Target Name="_PackLocalUnitsNetModularPackagesBeforeRestore"
+          BeforeTargets="Restore;_GenerateRestoreGraphProjectEntry"
+          DependsOnTargets="_PackLocalUnitsNetModularPackages"
+          Condition="'$(UnitsNetModularSampleUpdateLocalPackagesOnBuild)' == 'true'" />
+
+  <!-- Rider can build without a separate restore, so refresh assets before references are resolved. -->
+  <Target Name="UpdateLocalUnitsNetModularPackages"
+          BeforeTargets="PrepareForBuild"
+          DependsOnTargets="_PackLocalUnitsNetModularPackages"
+          Condition="'$(UnitsNetModularSampleUpdateLocalPackagesOnBuild)' == 'true' and '$(_UnitsNetModularSamplePackagesUpdated)' == 'true' and '$(DesignTimeBuild)' != 'true' and '$(GITHUB_ACTIONS)' != 'true'">
+    <Message Importance="high" Text="Resolving the latest local UnitsNet.Modular packages..." />
+    <MSBuild Projects="$(MSBuildProjectFullPath)"
+             Targets="Restore"
+             BuildInParallel="false"
+             Properties="UnitsNetModularSampleUpdateLocalPackagesOnBuild=false;RestoreForceEvaluate=true"
+             RemoveProperties="TargetFramework;RuntimeIdentifier;SelfContained" />
+  </Target>
+
+  <!-- Compatibility alias for the original sample target name. -->
+  <Target Name="UpdateLocalUnitsNetModularPackage"
+          DependsOnTargets="UpdateLocalUnitsNetModularPackages" />
+</Project>
diff --git a/UnitsNet.Modular/Samples/UnitsNet.Modular.Samples.slnx b/UnitsNet.Modular/Samples/UnitsNet.Modular.Samples.slnx
new file mode 100644
index 0000000000..2fa6a8d706
--- /dev/null
+++ b/UnitsNet.Modular/Samples/UnitsNet.Modular.Samples.slnx
@@ -0,0 +1,55 @@
+<Solution>
+  <Configurations>
+    <Platform Name="ProjectReferences" />
+    <Platform Name="LocalPackages" />
+    <Platform Name="PublishedPackages" />
+  </Configurations>
+  <File Path="refresh-local-packages.ps1" />
+  <Project Path="GettingStartedSample/GettingStartedSample.csproj">
+    <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+    <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+    <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+  </Project>
+  <Project Path="QuantitySelectionSample/QuantitySelectionSample.csproj">
+    <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+    <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+    <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+  </Project>
+  <Project Path="CustomQuantitySample/CustomQuantitySample.csproj">
+    <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+    <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+    <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+  </Project>
+  <Project Path="Profiles/AllSiProfileSample/AllSiProfileSample.csproj">
+    <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+    <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+    <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+  </Project>
+  <Project Path="ModularPlayground/ModularPlayground.csproj">
+    <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+    <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+    <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+  </Project>
+  <Folder Name="/Shared units library/">
+    <Project Path="SharedUnitsLibrarySample/Fictional.Measurements.Definitions/Fictional.Measurements.Definitions.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+    <Project Path="SharedUnitsLibrarySample/SharedUnitsLibrarySample.Units/SharedUnitsLibrarySample.Units.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+    <Project Path="SharedUnitsLibrarySample/SharedUnitsLibrarySample.Domain/SharedUnitsLibrarySample.Domain.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+    <Project Path="SharedUnitsLibrarySample/SharedUnitsLibrarySample.App/SharedUnitsLibrarySample.App.csproj">
+      <Platform Solution="*|ProjectReferences" Project="ProjectReferences" />
+      <Platform Solution="*|LocalPackages" Project="LocalPackages" />
+      <Platform Solution="*|PublishedPackages" Project="PublishedPackages" />
+    </Project>
+  </Folder>
+</Solution>
diff --git a/UnitsNet.Modular/Samples/refresh-local-packages.ps1 b/UnitsNet.Modular/Samples/refresh-local-packages.ps1
new file mode 100644
index 0000000000..aa1d1d87c8
--- /dev/null
+++ b/UnitsNet.Modular/Samples/refresh-local-packages.ps1
@@ -0,0 +1,67 @@
+# Licensed under MIT No Attribution, see LICENSE file at the root.
+
+<#
+.SYNOPSIS
+Packs the current UnitsNet.Modular checkout and force-restores every sample from the local feed.
+
+.DESCRIPTION
+Creates uniquely versioned UnitsNet.Modular and sample-definition packages so NuGet cannot reuse
+stale global-cache entries, then restores every sample project to that exact version. Use this when
+an IDE's optimized build path bypasses the repository's automatic LocalPackages preparation target.
+#>
+
+param(
+  [ValidateSet('Debug', 'Release')]
+  [string] $Configuration = 'Debug'
+)
+
+$ErrorActionPreference = 'Stop'
+
+$repositoryRoot = (Resolve-Path (Join-Path $PSScriptRoot '..\..')).Path
+$packageProject = Join-Path $repositoryRoot 'UnitsNet.Modular\UnitsNet.Modular\UnitsNet.Modular.csproj'
+$definitionPackageProject = Join-Path $PSScriptRoot 'SharedUnitsLibrarySample\Fictional.Measurements.Definitions\Fictional.Measurements.Definitions.csproj'
+$localFeed = Join-Path $repositoryRoot 'Artifacts\Nugets'
+$packageVersion = "6.0.0-local.dev.$([DateTime]::UtcNow.ToString('yyyyMMddHHmmssfff'))"
+
+Write-Host "Packing UnitsNet.Modular $packageVersion from the current checkout..."
+& dotnet pack `
+    $packageProject `
+    --configuration Release `
+    --output $localFeed `
+    -p:Platform=ProjectReferences `
+    "-p:MinVerVersionOverride=$packageVersion"
+if ($LASTEXITCODE -ne 0) {
+  throw "Packing UnitsNet.Modular failed."
+}
+
+Write-Host "Packing the sample definition package $packageVersion..."
+& dotnet pack `
+    $definitionPackageProject `
+    --configuration Release `
+    --output $localFeed `
+    -p:Platform=ProjectReferences `
+    "-p:MinVerVersionOverride=$packageVersion" `
+    "-p:PackageVersion=$packageVersion"
+if ($LASTEXITCODE -ne 0) {
+  throw "Packing the sample definition package failed."
+}
+
+$sampleProjects = Get-ChildItem -Path $PSScriptRoot -Recurse -Filter '*.csproj' |
+    Sort-Object FullName
+
+foreach ($sampleProject in $sampleProjects) {
+  Write-Host "Force-restoring $($sampleProject.BaseName) from $localFeed..."
+  & dotnet restore `
+      $sampleProject.FullName `
+      --force-evaluate `
+      --no-cache `
+      "-p:Configuration=$Configuration" `
+      -p:Platform=LocalPackages `
+      -p:UnitsNetModularSampleUpdateLocalPackagesOnBuild=false `
+      "-p:UnitsNetModularSampleLocalVersion=$packageVersion"
+  if ($LASTEXITCODE -ne 0) {
+    throw "Restoring $($sampleProject.BaseName) failed."
+  }
+}
+
+Write-Host "All UnitsNet.Modular samples now resolve local package version $packageVersion."
diff --git a/UnitsNet.Modular/THIRD-PARTY-NOTICES.md b/UnitsNet.Modular/THIRD-PARTY-NOTICES.md
new file mode 100644
index 0000000000..1d22b47a97
--- /dev/null
+++ b/UnitsNet.Modular/THIRD-PARTY-NOTICES.md
@@ -0,0 +1,25 @@
+# Third-party notices
+
+The UnitsNet.Modular source generator redistributes the following .NET Runtime components so Roslyn can load its private `System.Text.Json` dependency without consumer configuration:
+
+- Microsoft.Bcl.AsyncInterfaces
+- System.Buffers
+- System.IO.Pipelines
+- System.Memory
+- System.Numerics.Vectors
+- System.Runtime.CompilerServices.Unsafe
+- System.Text.Encodings.Web
+- System.Text.Json
+- System.Threading.Tasks.Extensions
+
+These components are distributed under the MIT License:
+
+Copyright (c) .NET Foundation and Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+The upstream .NET Runtime third-party notices are included separately as `DOTNET-THIRD-PARTY-NOTICES.TXT` in the package.
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/CompatibilityTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/CompatibilityTests.cs
new file mode 100644
index 0000000000..a96aa95813
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/CompatibilityTests.cs
@@ -0,0 +1,1156 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+extern alias Generated;
+extern alias Legacy;
+extern alias LegacyScenario;
+
+using System.Reflection;
+using Xunit;
+
+namespace UnitsNet.Modular.Compatibility.Tests;
+
+public sealed class CompatibilityTests
+{
+    private static readonly Assembly LegacyAssembly = typeof(Legacy::UnitsNet.Length).Assembly;
+    private static readonly Assembly GeneratedAssembly = typeof(Generated::UnitsNet.Length).Assembly;
+
+    public static IEnumerable<object[]> QuantityApis()
+    {
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Length),
+            typeof(Generated::UnitsNet.Length),
+            "Meters",
+            "Kilometers",
+            "FromMeters",
+            "FromKilometers",
+            "op_Multiply");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Mass),
+            typeof(Generated::UnitsNet.Mass),
+            "Kilograms",
+            "FromKilograms");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Duration),
+            typeof(Generated::UnitsNet.Duration),
+            "Seconds",
+            "FromSeconds");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Area),
+            typeof(Generated::UnitsNet.Area),
+            "SquareMeters",
+            "FromSquareMeters");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Speed),
+            typeof(Generated::UnitsNet.Speed),
+            "MetersPerSecond",
+            "FromMetersPerSecond");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Acceleration),
+            typeof(Generated::UnitsNet.Acceleration),
+            "MetersPerSecondSquared",
+            "FromMetersPerSecondSquared");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Force),
+            typeof(Generated::UnitsNet.Force),
+            "Newtons",
+            "FromNewtons");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Pressure),
+            typeof(Generated::UnitsNet.Pressure),
+            "Pascals",
+            "FromPascals");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Energy),
+            typeof(Generated::UnitsNet.Energy),
+            "Joules",
+            "FromJoules");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Power),
+            typeof(Generated::UnitsNet.Power),
+            "Watts",
+            "FromWatts");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Temperature),
+            typeof(Generated::UnitsNet.Temperature),
+            "DegreesCelsius",
+            "DegreesFahrenheit",
+            "FromDegreesCelsius",
+            "FromDegreesFahrenheit",
+            "op_Addition",
+            "op_Subtraction");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.TemperatureDelta),
+            typeof(Generated::UnitsNet.TemperatureDelta),
+            "DegreesCelsius",
+            "DegreesFahrenheit",
+            "FromDegreesCelsius",
+            "FromDegreesFahrenheit",
+            "op_Addition",
+            "op_Subtraction");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Level),
+            typeof(Generated::UnitsNet.Level),
+            "Decibels",
+            "FromDecibels",
+            "op_Addition");
+        yield return QuantityApi(
+            typeof(Legacy::UnitsNet.Information),
+            typeof(Generated::UnitsNet.Information),
+            "Bits",
+            "Kibibytes",
+            "FromBits",
+            "FromKibibytes");
+    }
+
+    public static IEnumerable<object[]> UnitEnums()
+    {
+        yield return new object[]
+        {
+            typeof(Legacy::UnitsNet.Units.LengthUnit),
+            typeof(Generated::UnitsNet.Units.LengthUnit),
+        };
+        yield return UnitEnum<Legacy::UnitsNet.Units.MassUnit, Generated::UnitsNet.Units.MassUnit>();
+        yield return UnitEnum<Legacy::UnitsNet.Units.DurationUnit, Generated::UnitsNet.Units.DurationUnit>();
+        yield return new object[]
+        {
+            typeof(Legacy::UnitsNet.Units.AreaUnit),
+            typeof(Generated::UnitsNet.Units.AreaUnit),
+        };
+        yield return UnitEnum<Legacy::UnitsNet.Units.SpeedUnit, Generated::UnitsNet.Units.SpeedUnit>();
+        yield return UnitEnum<Legacy::UnitsNet.Units.AccelerationUnit, Generated::UnitsNet.Units.AccelerationUnit>();
+        yield return UnitEnum<Legacy::UnitsNet.Units.ForceUnit, Generated::UnitsNet.Units.ForceUnit>();
+        yield return UnitEnum<Legacy::UnitsNet.Units.PressureUnit, Generated::UnitsNet.Units.PressureUnit>();
+        yield return UnitEnum<Legacy::UnitsNet.Units.EnergyUnit, Generated::UnitsNet.Units.EnergyUnit>();
+        yield return UnitEnum<Legacy::UnitsNet.Units.PowerUnit, Generated::UnitsNet.Units.PowerUnit>();
+        yield return new object[]
+        {
+            typeof(Legacy::UnitsNet.Units.TemperatureUnit),
+            typeof(Generated::UnitsNet.Units.TemperatureUnit),
+        };
+        yield return UnitEnum<
+            Legacy::UnitsNet.Units.TemperatureDeltaUnit,
+            Generated::UnitsNet.Units.TemperatureDeltaUnit>();
+        yield return new object[]
+        {
+            typeof(Legacy::UnitsNet.Units.LevelUnit),
+            typeof(Generated::UnitsNet.Units.LevelUnit),
+        };
+        yield return new object[]
+        {
+            typeof(Legacy::UnitsNet.Units.InformationUnit),
+            typeof(Generated::UnitsNet.Units.InformationUnit),
+        };
+    }
+
+    [Fact]
+    public void LinkedConsumer_ProducesSameOutput()
+    {
+        string legacy = LegacyScenario::UnitsNet.Modular.Compatibility.CompatibilityScenario.Run();
+        string generated = Generated::UnitsNet.Modular.Compatibility.CompatibilityScenario.Run();
+
+        Assert.Equal(legacy, generated);
+    }
+
+    [Fact]
+    public void GeneratedCatalog_ContainsEveryUnitsNetQuantity()
+    {
+        string[] legacy = GetQuantityTypes(LegacyAssembly).Select(type => type.FullName!).ToArray();
+        string[] generated = GetQuantityTypes(GeneratedAssembly).Select(type => type.FullName!).ToArray();
+
+        Assert.Equal(129, legacy.Length);
+        Assert.Equal(legacy, generated);
+    }
+
+    [Fact]
+    public void GeneratedCatalog_UnitEnumsMatchUnitsNet()
+    {
+        foreach (Type legacyQuantity in GetQuantityTypes(LegacyAssembly))
+        {
+            Type generatedQuantity = GeneratedAssembly.GetType(legacyQuantity.FullName!, throwOnError: true)!;
+            Type legacyUnit = LegacyAssembly.GetType($"UnitsNet.Units.{legacyQuantity.Name}Unit", throwOnError: true)!;
+            Type generatedUnit = GeneratedAssembly.GetType(
+                $"UnitsNet.Units.{generatedQuantity.Name}Unit",
+                throwOnError: true)!;
+
+            string[] names = Enum.GetNames(legacyUnit).OrderBy(name => name, StringComparer.Ordinal).ToArray();
+            Assert.Equal(names, Enum.GetNames(generatedUnit).OrderBy(name => name, StringComparer.Ordinal));
+            Assert.All(
+                names,
+                name => Assert.Equal(
+                    Convert.ToInt32(Enum.Parse(legacyUnit, name)),
+                    Convert.ToInt32(Enum.Parse(generatedUnit, name))));
+        }
+    }
+
+    [Fact]
+    public void GeneratedCatalog_SiUnitSystemSelectionMatchesUnitsNet()
+    {
+        object legacySi = Legacy::UnitsNet.UnitSystem.SI;
+        Type generatedUnitSystemType = GeneratedAssembly
+            .GetReferencedAssemblies()
+            .Select(Assembly.Load)
+            .Select(assembly => assembly.GetType("UnitsNet.UnitSystem"))
+            .First(type => type is not null)!;
+        object generatedSi = generatedUnitSystemType.GetProperty("SI")!.GetValue(null)!;
+
+        foreach (Type legacyQuantity in GetQuantityTypes(LegacyAssembly))
+        {
+            Type generatedQuantity = GeneratedAssembly.GetType(legacyQuantity.FullName!, throwOnError: true)!;
+            ConstructorInfo? legacyConstructor = legacyQuantity.GetConstructors()
+                .SingleOrDefault(constructor =>
+                {
+                    ParameterInfo[] parameters = constructor.GetParameters();
+                    return parameters.Length == 2 &&
+                           parameters[1].ParameterType == typeof(Legacy::UnitsNet.UnitSystem);
+                });
+            if (legacyConstructor is null)
+            {
+                continue;
+            }
+
+            ConstructorInfo generatedConstructor = generatedQuantity.GetConstructor(
+                new[] { typeof(double), generatedUnitSystemType })!;
+            (object? legacyValue, Exception? legacyError) =
+                InvokeUnitSystemConstructor(legacyConstructor, legacySi);
+            (object? generatedValue, Exception? generatedError) =
+                InvokeUnitSystemConstructor(generatedConstructor, generatedSi);
+
+            Assert.Equal(legacyError?.GetType(), generatedError?.GetType());
+            if (legacyError is not null)
+            {
+                continue;
+            }
+
+            Assert.Equal(
+                legacyQuantity.GetProperty("Unit")!.GetValue(legacyValue)!.ToString(),
+                generatedQuantity.GetProperty("Unit")!.GetValue(generatedValue)!.ToString());
+        }
+    }
+
+    [Fact]
+    public void GeneratedCatalog_BaseUnitMetadataMatchesUnitsNet()
+    {
+        foreach (Type legacyQuantity in GetQuantityTypes(LegacyAssembly))
+        {
+            Type generatedQuantity = GeneratedAssembly.GetType(legacyQuantity.FullName!, throwOnError: true)!;
+            object legacyInfo = legacyQuantity.GetProperty("Info")!.GetValue(null)!;
+            var legacyUnits = ((System.Collections.IEnumerable)typeof(Legacy::UnitsNet.QuantityInfo)
+                    .GetProperty("UnitInfos")!
+                    .GetValue(legacyInfo)!)
+                .Cast<object>()
+                .ToDictionary(
+                    unit => (string)unit.GetType().GetProperty("Name")!.GetValue(unit)!,
+                    unit => unit.GetType().GetProperty("BaseUnits")!.GetValue(unit)!.ToString()!,
+                    StringComparer.Ordinal);
+            object generatedInfo = generatedQuantity.GetProperty("Info")!.GetValue(null)!;
+            var generatedUnits = ((System.Collections.IEnumerable)generatedInfo
+                    .GetType()
+                    .GetProperty("Units")!
+                    .GetValue(generatedInfo)!)
+                .Cast<object>()
+                .ToDictionary(
+                    unit => (string)unit.GetType().GetProperty("SingularName")!.GetValue(unit)!,
+                    unit => unit.GetType().GetProperty("BaseUnits")!.GetValue(unit)!.ToString()!,
+                    StringComparer.Ordinal);
+
+            Assert.Equal(
+                legacyUnits.OrderBy(pair => pair.Key, StringComparer.Ordinal),
+                generatedUnits.OrderBy(pair => pair.Key, StringComparer.Ordinal));
+        }
+    }
+
+    [Fact]
+    public void GeneratedCatalog_PublicSurfaceHasOnlyDocumentedCompatibilityDifferences()
+    {
+        var unknownDifferences = new List<string>();
+        foreach (Type legacyType in GetQuantityTypes(LegacyAssembly))
+        {
+            Type generatedType = GeneratedAssembly.GetType(legacyType.FullName!, throwOnError: true)!;
+            HashSet<string> generatedSurface = GetCompleteSurface(generatedType);
+            unknownDifferences.AddRange(
+                GetCompleteSurface(legacyType)
+                    .Except(generatedSurface)
+                    .Where(signature => !IsDocumentedCompatibilityDifference(legacyType.Name, signature))
+                    .Select(signature => $"{legacyType.Name}: {signature}"));
+        }
+
+        Assert.True(
+            unknownDifferences.Count == 0,
+            $"Undocumented compatibility differences:{Environment.NewLine}" +
+            string.Join(Environment.NewLine, unknownDifferences.OrderBy(item => item, StringComparer.Ordinal)));
+    }
+
+    [Fact]
+    public void GeneratedCatalog_IntentionalQuantityApiExclusionsAreCurrentAndReasoned()
+    {
+        foreach ((string quantityName, QuantityApiExclusion exclusion) in IntentionalQuantityApiExclusions)
+        {
+            Assert.False(string.IsNullOrWhiteSpace(exclusion.Reason));
+            Type legacyType = LegacyAssembly.GetType($"UnitsNet.{quantityName}", throwOnError: true)!;
+            Type generatedType = GeneratedAssembly.GetType($"UnitsNet.{quantityName}", throwOnError: true)!;
+            HashSet<string> legacySurface = GetCompleteSurface(legacyType);
+            HashSet<string> generatedSurface = GetCompleteSurface(generatedType);
+
+            foreach (string memberName in exclusion.MemberNames)
+            {
+                Assert.Contains(legacySurface, signature => IsNamedMember(signature, memberName));
+                Assert.DoesNotContain(generatedSurface, signature => IsNamedMember(signature, memberName));
+            }
+        }
+    }
+
+    [Fact]
+    public void GeneratedCatalog_CompanionWrapperSurfacesMatchUnitsNet()
+    {
+        Assert.Equal(
+            GetCompanionSurface(typeof(Legacy::UnitsNet.FeetInches)),
+            GetCompanionSurface(typeof(Generated::UnitsNet.FeetInches)));
+        Assert.Equal(
+            GetCompanionSurface(typeof(Legacy::UnitsNet.StonePounds)),
+            GetCompanionSurface(typeof(Generated::UnitsNet.StonePounds)));
+        Assert.Equal(
+            GetCompanionSurface(typeof(Legacy::UnitsNet.Wrappers.ReferencePressure)),
+            GetCompanionSurface(typeof(Generated::UnitsNet.Wrappers.ReferencePressure)));
+        Assert.Equal(
+            Enum.GetNames<Legacy::UnitsNet.CustomCode.Units.PressureReference>(),
+            Enum.GetNames<Generated::UnitsNet.CustomCode.Units.PressureReference>());
+    }
+
+    [Fact]
+    public void GeneratedCatalog_ConversionsMatchUnitsNet()
+    {
+        const double value = 12.3456789;
+        foreach (Type legacyQuantity in GetQuantityTypes(LegacyAssembly))
+        {
+            Type generatedQuantity = GeneratedAssembly.GetType(legacyQuantity.FullName!, throwOnError: true)!;
+            Type legacyUnitType = LegacyAssembly.GetType(
+                $"UnitsNet.Units.{legacyQuantity.Name}Unit",
+                throwOnError: true)!;
+            Type generatedUnitType = GeneratedAssembly.GetType(
+                $"UnitsNet.Units.{generatedQuantity.Name}Unit",
+                throwOnError: true)!;
+            object legacyBaseUnit = legacyQuantity.GetProperty("BaseUnit")!.GetValue(null)!;
+            object generatedBaseUnit = GetGeneratedBaseUnit(generatedQuantity);
+            MethodInfo legacyAs = LegacyAssembly.GetType("UnitsNet.QuantityExtensions", throwOnError: true)!
+                .GetMethods(BindingFlags.Public | BindingFlags.Static)
+                .Single(method =>
+                    method.Name == "As" &&
+                    method.IsGenericMethodDefinition &&
+                    method.GetGenericArguments().Length == 2 &&
+                    method.GetParameters().Length == 2)
+                .MakeGenericMethod(legacyQuantity, legacyUnitType);
+            MethodInfo generatedAs = generatedQuantity.GetMethod("As", new[] { generatedUnitType })!;
+
+            foreach (string unitName in Enum.GetNames(legacyUnitType))
+            {
+                object legacyUnit = Enum.Parse(legacyUnitType, unitName);
+                object generatedUnit = Enum.Parse(generatedUnitType, unitName);
+                object legacyValue = CreateQuantity(legacyQuantity, value, legacyUnit);
+                object generatedValue = CreateQuantity(generatedQuantity, value, generatedUnit);
+                AssertNearlyEqual(
+                    NumericValue(legacyAs.Invoke(null, new[] { legacyValue, legacyBaseUnit })!),
+                    NumericValue(generatedAs.Invoke(generatedValue, new[] { generatedBaseUnit })!),
+                    $"{legacyQuantity.Name}.{unitName} to base");
+
+                object legacyBaseValue = CreateQuantity(legacyQuantity, value, legacyBaseUnit);
+                object generatedBaseValue = CreateQuantity(generatedQuantity, value, generatedBaseUnit);
+                AssertNearlyEqual(
+                    NumericValue(legacyAs.Invoke(null, new[] { legacyBaseValue, legacyUnit })!),
+                    NumericValue(generatedAs.Invoke(generatedBaseValue, new[] { generatedUnit })!),
+                    $"{legacyQuantity.Name}.{unitName} from base");
+            }
+        }
+    }
+
+    [Fact]
+    public void GeneratedCatalog_BaseUnitFormattingAndParsingMatchUnitsNet()
+    {
+        const double value = 12.3456789;
+        var invariant = System.Globalization.CultureInfo.InvariantCulture;
+        foreach (Type legacyQuantity in GetQuantityTypes(LegacyAssembly))
+        {
+            Type generatedQuantity = GeneratedAssembly.GetType(legacyQuantity.FullName!, throwOnError: true)!;
+            Type legacyUnitType = LegacyAssembly.GetType(
+                $"UnitsNet.Units.{legacyQuantity.Name}Unit",
+                throwOnError: true)!;
+            Type generatedUnitType = GeneratedAssembly.GetType(
+                $"UnitsNet.Units.{generatedQuantity.Name}Unit",
+                throwOnError: true)!;
+            object legacyBaseUnit = legacyQuantity.GetProperty("BaseUnit")!.GetValue(null)!;
+            object generatedBaseUnit = GetGeneratedBaseUnit(generatedQuantity);
+            object legacyValue = CreateQuantity(legacyQuantity, value, legacyBaseUnit);
+            object generatedValue = CreateQuantity(generatedQuantity, value, generatedBaseUnit);
+            string legacyText = ((IFormattable)legacyValue).ToString(null, invariant);
+            string generatedText = ((IFormattable)generatedValue).ToString(null, invariant);
+            Assert.Equal(legacyText, generatedText);
+
+            MethodInfo generatedParse = generatedQuantity.GetMethod(
+                "Parse",
+                new[] { typeof(string), typeof(IFormatProvider) })!;
+            object parsed = generatedParse.Invoke(null, new object?[] { legacyText, invariant })!;
+            MethodInfo generatedAs = generatedQuantity.GetMethod("As", new[] { generatedUnitType })!;
+            AssertNearlyEqual(
+                value,
+                (double)generatedAs.Invoke(parsed, new[] { generatedBaseUnit })!,
+                $"{legacyQuantity.Name} formatted round trip");
+
+            MethodInfo legacyAbbreviation = legacyQuantity.GetMethod(
+                "GetAbbreviation",
+                new[] { legacyUnitType, typeof(IFormatProvider) })!;
+            MethodInfo generatedAbbreviation = generatedQuantity.GetMethod(
+                "GetAbbreviation",
+                new[] { generatedUnitType, typeof(IFormatProvider) })!;
+            string expectedAbbreviation =
+                (string)legacyAbbreviation.Invoke(null, new[] { legacyBaseUnit, invariant })!;
+            string actualAbbreviation =
+                (string)generatedAbbreviation.Invoke(null, new[] { generatedBaseUnit, invariant })!;
+            Assert.Equal(expectedAbbreviation, actualAbbreviation);
+
+            MethodInfo generatedParseUnit = generatedQuantity.GetMethod(
+                "ParseUnit",
+                new[] { typeof(string), typeof(IFormatProvider) })!;
+            Assert.Equal(
+                generatedBaseUnit,
+                generatedParseUnit.Invoke(null, new object?[] { actualAbbreviation, invariant }));
+        }
+    }
+
+    [Fact]
+    public void GeneratedQuantity_LocalizedCustomFormattingMatchesUnitsNet()
+    {
+        var culture = System.Globalization.CultureInfo.GetCultureInfo("nb-NO");
+        Legacy::UnitsNet.Length legacy = Legacy::UnitsNet.Length.FromMeters(1234.5);
+        Generated::UnitsNet.Length generated = Generated::UnitsNet.Length.FromMeters(1234.5);
+
+        string legacyText = legacy.ToString("F2", culture);
+        string generatedText = generated.ToString("F2", culture);
+
+        Assert.Equal(legacyText, generatedText);
+        Assert.Equal(
+            legacy.Meters.ToDouble(),
+            Generated::UnitsNet.Length.Parse(generatedText, culture).Meters,
+            12);
+    }
+
+    [Fact]
+    public void GeneratedRegistry_DescribesAndOperatesOnTheSelectedCatalog()
+    {
+        QuantityRegistry registry = Generated::UnitsNet.GeneratedQuantityRegistry.Instance;
+
+        Assert.Equal(129, registry.Quantities.Count);
+        IQuantityDescriptor length = registry.Get(new QuantityId("UnitsNet.Length"));
+        Assert.Same(length, registry.Get("length"));
+        Assert.Same(length, registry.Get(typeof(Generated::UnitsNet.Length)));
+        Assert.Equal("Meter", length.BaseUnitName);
+        Assert.Equal(1, length.BaseDimensions.Length);
+        Assert.Equal(1000, length.Convert(1, "Kilometer", "Meter"), 12);
+
+        var created = Assert.IsType<Generated::UnitsNet.Length>(length.Create(1.5, "Kilometer"));
+        var parsed = Assert.IsType<Generated::UnitsNet.Length>(
+            length.Parse("1500 m", System.Globalization.CultureInfo.InvariantCulture));
+        Assert.Equal(created.Meters, parsed.Meters, 12);
+
+        foreach (Type generatedType in GetQuantityTypes(GeneratedAssembly))
+        {
+            IQuantityDescriptor descriptor = registry.Get(generatedType);
+            Type legacyType = LegacyAssembly.GetType(generatedType.FullName!, throwOnError: true)!;
+            object legacyDimensions = legacyType.GetProperty("BaseDimensions")!.GetValue(null)!;
+            Assert.Equal(
+                ReadDimensions(legacyDimensions),
+                new[]
+                {
+                    descriptor.BaseDimensions.Length,
+                    descriptor.BaseDimensions.Mass,
+                    descriptor.BaseDimensions.Time,
+                    descriptor.BaseDimensions.Current,
+                    descriptor.BaseDimensions.Temperature,
+                    descriptor.BaseDimensions.Amount,
+                    descriptor.BaseDimensions.LuminousIntensity,
+                });
+            Assert.Equal(
+                Enum.GetNames(generatedType.Assembly.GetType($"UnitsNet.Units.{generatedType.Name}Unit")!).Length,
+                descriptor.Units.Count);
+        }
+    }
+
+    [Fact]
+    public void GeneratedRegistry_ReplacesCommonLegacyDynamicWorkflows()
+    {
+        QuantityRegistry registry = Generated::UnitsNet.GeneratedQuantityRegistry.Instance;
+        var invariant = System.Globalization.CultureInfo.InvariantCulture;
+
+        var legacyCreated = Assert.IsType<Legacy::UnitsNet.Length>(
+            Legacy::UnitsNet.Quantity.From(1.5, "Length", "Kilometer"));
+        var generatedCreated = Assert.IsType<Generated::UnitsNet.Length>(
+            registry.Create(1.5, "Length", "Kilometer"));
+        var generatedFromUnit = Assert.IsType<Generated::UnitsNet.Length>(
+            registry.Create(1.5, Generated::UnitsNet.Units.LengthUnit.Kilometer));
+
+        double legacyConverted = Legacy::UnitsNet.UnitConverter.ConvertByName(
+            1.5,
+            "Length",
+            "Kilometer",
+            "Meter");
+        double generatedConverted = registry.Convert(
+            1.5,
+            "Length",
+            "Kilometer",
+            "Meter");
+        double generatedConvertedFromUnits = registry.Convert(
+            1.5,
+            Generated::UnitsNet.Units.LengthUnit.Kilometer,
+            Generated::UnitsNet.Units.LengthUnit.Meter);
+
+        var legacyParsed = Assert.IsType<Legacy::UnitsNet.Length>(
+            Legacy::UnitsNet.Quantity.Parse(invariant, typeof(Legacy::UnitsNet.Length), "1.5 km"));
+        var generatedParsed = Assert.IsType<Generated::UnitsNet.Length>(
+            registry.Parse(typeof(Generated::UnitsNet.Length), "1.5 km", invariant));
+
+        Assert.Equal(legacyCreated.Meters, generatedCreated.Meters, 12);
+        Assert.Equal(legacyCreated.Meters, generatedFromUnit.Meters, 12);
+        Assert.Equal(legacyConverted, generatedConverted, 12);
+        Assert.Equal(legacyConverted, generatedConvertedFromUnits, 12);
+        Assert.Equal(legacyParsed.Meters, generatedParsed.Meters, 12);
+        Assert.Equal(
+            legacyCreated.ToString(null, invariant),
+            registry.Get("Length").Format(generatedCreated, null, invariant));
+        Assert.Same(
+            registry.Get("Length"),
+            registry.GetByUnitType(typeof(Generated::UnitsNet.Units.LengthUnit)));
+
+        string[] legacyDimensionMatches = Legacy::UnitsNet.Quantity
+            .GetQuantitiesWithBaseDimensions(Legacy::UnitsNet.Length.BaseDimensions)
+            .Select(quantity => quantity.Name)
+            .OrderBy(name => name, StringComparer.Ordinal)
+            .ToArray();
+        string[] generatedDimensionMatches = registry
+            .FindByBaseDimensions(Generated::UnitsNet.Length.Info.BaseDimensions)
+            .Select(quantity => quantity.Name)
+            .OrderBy(name => name, StringComparer.Ordinal)
+            .ToArray();
+        Assert.Equal(legacyDimensionMatches, generatedDimensionMatches);
+    }
+
+    [Fact]
+    public void GeneratedQuantityFacade_PreservesCommonLegacyCallShapes()
+    {
+        var invariant = System.Globalization.CultureInfo.InvariantCulture;
+
+        Legacy::UnitsNet.IQuantity legacyByName =
+            Legacy::UnitsNet.Quantity.From(1.5, "Length", "Kilometer");
+        IQuantity<double> generatedByName =
+            Generated::UnitsNet.Quantity.From(1.5, "Length", "Kilometer");
+        Legacy::UnitsNet.IQuantity legacyByUnit =
+            Legacy::UnitsNet.Quantity.From(1.5, Legacy::UnitsNet.Units.LengthUnit.Kilometer);
+        IQuantity<double> generatedByUnit =
+            Generated::UnitsNet.Quantity.From(
+                1.5,
+                Generated::UnitsNet.Units.LengthUnit.Kilometer);
+        Legacy::UnitsNet.IQuantity legacyParsed =
+            Legacy::UnitsNet.Quantity.Parse(invariant, typeof(Legacy::UnitsNet.Length), "1.5 km");
+        IQuantity<double> generatedParsed =
+            Generated::UnitsNet.Quantity.Parse(
+                invariant,
+                typeof(Generated::UnitsNet.Length),
+                "1.5 km");
+
+        Assert.Equal(
+            Assert.IsType<Legacy::UnitsNet.Length>(legacyByName).Meters,
+            Assert.IsType<Generated::UnitsNet.Length>(generatedByName).Meters,
+            12);
+        Assert.Equal(
+            Assert.IsType<Legacy::UnitsNet.Length>(legacyByUnit).Meters,
+            Assert.IsType<Generated::UnitsNet.Length>(generatedByUnit).Meters,
+            12);
+        Assert.Equal(
+            Assert.IsType<Legacy::UnitsNet.Length>(legacyParsed).Meters,
+            Assert.IsType<Generated::UnitsNet.Length>(generatedParsed).Meters,
+            12);
+        Assert.Equal(
+            Legacy::UnitsNet.Quantity.Names.OrderBy(name => name, StringComparer.Ordinal),
+            Generated::UnitsNet.Quantity.Names.OrderBy(name => name, StringComparer.Ordinal));
+        Assert.Equal(
+            Legacy::UnitsNet.Quantity.Infos.Select(info => info.Name).OrderBy(name => name, StringComparer.Ordinal),
+            Generated::UnitsNet.Quantity.Infos.Select(info => info.Name).OrderBy(name => name, StringComparer.Ordinal));
+        Assert.True(
+            Generated::UnitsNet.Quantity.TryFrom(
+                2,
+                "Length",
+                "Meter",
+                out IQuantity<double>? generated));
+        Assert.IsType<Generated::UnitsNet.Length>(generated);
+    }
+
+    [Fact]
+    public void RepresentativeBehavior_MatchesUnitsNet()
+    {
+        var invariant = System.Globalization.CultureInfo.InvariantCulture;
+        Legacy::UnitsNet.Length legacyLength = Legacy::UnitsNet.Length.Parse("1.5 km", invariant);
+        Generated::UnitsNet.Length generatedLength = Generated::UnitsNet.Length.Parse("1.5 km", invariant);
+
+        Assert.Equal(legacyLength.Meters, generatedLength.Meters, 12);
+        Assert.Equal(legacyLength.ToString(null, invariant), generatedLength.ToString(null, invariant));
+#pragma warning disable CS0618 // Deliberately compare UnitsNet's strict legacy equality semantics.
+        Assert.Equal(
+            Legacy::UnitsNet.Length.FromMeters(1500).Equals(Legacy::UnitsNet.Length.FromKilometers(1.5)),
+            Generated::UnitsNet.Length.FromMeters(1500).Equals(Generated::UnitsNet.Length.FromKilometers(1.5)));
+#pragma warning restore CS0618
+
+        Legacy::UnitsNet.Temperature legacyFreezing = Legacy::UnitsNet.Temperature.FromDegreesCelsius(0);
+        Legacy::UnitsNet.Temperature legacyBoiling = Legacy::UnitsNet.Temperature.FromDegreesFahrenheit(212);
+        Generated::UnitsNet.Temperature generatedFreezing = Generated::UnitsNet.Temperature.FromDegreesCelsius(0);
+        Generated::UnitsNet.Temperature generatedBoiling = Generated::UnitsNet.Temperature.FromDegreesFahrenheit(212);
+        Assert.Equal(
+            (legacyBoiling - legacyFreezing).DegreesCelsius,
+            (generatedBoiling - generatedFreezing).DegreesCelsius,
+            12);
+
+        Legacy::UnitsNet.Level legacyLevel =
+            Legacy::UnitsNet.Level.FromDecibels(10) + Legacy::UnitsNet.Level.FromDecibels(10);
+        Generated::UnitsNet.Level generatedLevel =
+            Generated::UnitsNet.Level.FromDecibels(10) + Generated::UnitsNet.Level.FromDecibels(10);
+        Assert.Equal(legacyLevel.Decibels, generatedLevel.Decibels, 12);
+
+        Legacy::UnitsNet.Area legacyCircle =
+            Legacy::UnitsNet.Area.FromCircleDiameter(Legacy::UnitsNet.Length.FromMeters(4));
+        Generated::UnitsNet.Area generatedCircle =
+            Generated::UnitsNet.Area.FromCircleDiameter(Generated::UnitsNet.Length.FromMeters(4));
+        Assert.Equal(legacyCircle.SquareMeters, generatedCircle.SquareMeters, 12);
+
+        Legacy::UnitsNet.MassFraction legacyFraction =
+            Legacy::UnitsNet.MassFraction.FromMasses(
+                Legacy::UnitsNet.Mass.FromKilograms(2),
+                Legacy::UnitsNet.Mass.FromPounds(10));
+        Generated::UnitsNet.MassFraction generatedFraction =
+            Generated::UnitsNet.MassFraction.FromMasses(
+                Generated::UnitsNet.Mass.FromKilograms(2),
+                Generated::UnitsNet.Mass.FromPounds(10));
+        Assert.Equal(legacyFraction.DecimalFractions, generatedFraction.DecimalFractions, 12);
+        Assert.Equal(
+            legacyFraction.GetComponentMass(Legacy::UnitsNet.Mass.FromPounds(10)).Kilograms,
+            generatedFraction.GetComponentMass(Generated::UnitsNet.Mass.FromPounds(10)).Kilograms,
+            12);
+        Assert.Equal(
+            legacyFraction.GetTotalMass(Legacy::UnitsNet.Mass.FromKilograms(2)).Pounds,
+            generatedFraction.GetTotalMass(Generated::UnitsNet.Mass.FromKilograms(2)).Pounds,
+            12);
+
+        Legacy::UnitsNet.Force legacyForce =
+            Legacy::UnitsNet.Force.FromPressureByArea(
+                Legacy::UnitsNet.Pressure.FromPascals(5),
+                Legacy::UnitsNet.Area.FromSquareMeters(7));
+        Generated::UnitsNet.Force generatedForce =
+            Generated::UnitsNet.Force.FromPressureByArea(
+                Generated::UnitsNet.Pressure.FromPascals(5),
+                Generated::UnitsNet.Area.FromSquareMeters(7));
+        Assert.Equal(legacyForce.Newtons, generatedForce.Newtons, 12);
+        Assert.Equal(
+            Legacy::UnitsNet.Mass.FromGravitationalForce(legacyForce).Kilograms,
+            Generated::UnitsNet.Mass.FromGravitationalForce(generatedForce).Kilograms,
+            12);
+
+        Legacy::UnitsNet.AmountOfSubstance legacyAmount =
+            Legacy::UnitsNet.AmountOfSubstance.FromMass(
+                Legacy::UnitsNet.Mass.FromKilograms(2),
+                Legacy::UnitsNet.MolarMass.FromKilogramsPerMole(0.5));
+        Generated::UnitsNet.AmountOfSubstance generatedAmount =
+            Generated::UnitsNet.AmountOfSubstance.FromMass(
+                Generated::UnitsNet.Mass.FromKilograms(2),
+                Generated::UnitsNet.MolarMass.FromKilogramsPerMole(0.5));
+        Assert.Equal(legacyAmount.Moles, generatedAmount.Moles, 12);
+        AssertNearlyEqual(
+            legacyAmount.NumberOfParticles().ToDouble(),
+            generatedAmount.NumberOfParticles(),
+            "AmountOfSubstance.NumberOfParticles");
+
+        Legacy::UnitsNet.Molarity legacyMolarity = Legacy::UnitsNet.Molarity.FromMolesPerCubicMeter(2);
+        Generated::UnitsNet.Molarity generatedMolarity = Generated::UnitsNet.Molarity.FromMolesPerCubicMeter(2);
+        Legacy::UnitsNet.MolarMass legacyMolarMass = Legacy::UnitsNet.MolarMass.FromKilogramsPerMole(0.018);
+        Generated::UnitsNet.MolarMass generatedMolarMass =
+            Generated::UnitsNet.MolarMass.FromKilogramsPerMole(0.018);
+        Legacy::UnitsNet.Density legacyDensity = Legacy::UnitsNet.Density.FromKilogramsPerCubicMeter(1000);
+        Generated::UnitsNet.Density generatedDensity =
+            Generated::UnitsNet.Density.FromKilogramsPerCubicMeter(1000);
+        Legacy::UnitsNet.MassConcentration legacyMassConcentration =
+            Legacy::UnitsNet.MassConcentration.FromMolarity(legacyMolarity, legacyMolarMass);
+        Generated::UnitsNet.MassConcentration generatedMassConcentration =
+            Generated::UnitsNet.MassConcentration.FromMolarity(generatedMolarity, generatedMolarMass);
+        Assert.Equal(
+            legacyMassConcentration.KilogramsPerCubicMeter,
+            generatedMassConcentration.KilogramsPerCubicMeter,
+            12);
+        Assert.Equal(
+            legacyMassConcentration.ToMolarity(legacyMolarMass).MolesPerCubicMeter,
+            generatedMassConcentration.ToMolarity(generatedMolarMass).MolesPerCubicMeter,
+            12);
+        Assert.Equal(
+            legacyMolarity.ToMassConcentration(legacyMolarMass).KilogramsPerCubicMeter,
+            generatedMolarity.ToMassConcentration(generatedMolarMass).KilogramsPerCubicMeter,
+            12);
+
+        Legacy::UnitsNet.VolumeConcentration legacyVolumeConcentration =
+            legacyMassConcentration.ToVolumeConcentration(legacyDensity);
+        Generated::UnitsNet.VolumeConcentration generatedVolumeConcentration =
+            generatedMassConcentration.ToVolumeConcentration(generatedDensity);
+        Assert.Equal(
+            legacyVolumeConcentration.DecimalFractions,
+            generatedVolumeConcentration.DecimalFractions,
+            12);
+        Assert.Equal(
+            legacyVolumeConcentration.ToMassConcentration(legacyDensity).KilogramsPerCubicMeter,
+            generatedVolumeConcentration.ToMassConcentration(generatedDensity).KilogramsPerCubicMeter,
+            12);
+        Assert.Equal(
+            legacyVolumeConcentration.ToMolarity(legacyDensity, legacyMolarMass).MolesPerCubicMeter,
+            generatedVolumeConcentration.ToMolarity(generatedDensity, generatedMolarMass).MolesPerCubicMeter,
+            12);
+        Assert.Equal(
+            Legacy::UnitsNet.VolumeConcentration.FromVolumes(
+                Legacy::UnitsNet.Volume.FromLiters(1),
+                Legacy::UnitsNet.Volume.FromCubicMeters(1)).DecimalFractions,
+            Generated::UnitsNet.VolumeConcentration.FromVolumes(
+                Generated::UnitsNet.Volume.FromLiters(1),
+                Generated::UnitsNet.Volume.FromCubicMeters(1)).DecimalFractions,
+            12);
+        Assert.Equal(
+            Legacy::UnitsNet.Molarity.FromVolumeConcentration(
+                legacyVolumeConcentration,
+                legacyDensity,
+                legacyMolarMass).MolesPerCubicMeter,
+            Generated::UnitsNet.Molarity.FromVolumeConcentration(
+                generatedVolumeConcentration,
+                generatedDensity,
+                generatedMolarMass).MolesPerCubicMeter,
+            12);
+        Assert.Equal(
+            Legacy::UnitsNet.VolumeConcentration.FromMolarity(
+                legacyMolarity,
+                legacyDensity,
+                legacyMolarMass).DecimalFractions,
+            Generated::UnitsNet.VolumeConcentration.FromMolarity(
+                generatedMolarity,
+                generatedDensity,
+                generatedMolarMass).DecimalFractions,
+            12);
+
+        Legacy::UnitsNet.ElectricApparentPower legacyApparentPower =
+            Legacy::UnitsNet.ElectricApparentPower.FromVoltamperes(120);
+        Generated::UnitsNet.ElectricApparentPower generatedApparentPower =
+            Generated::UnitsNet.ElectricApparentPower.FromVoltamperes(120);
+        Assert.Equal(
+            (legacyApparentPower / Legacy::UnitsNet.ElectricPotential.FromVolts(12)).Amperes,
+            (generatedApparentPower / Generated::UnitsNet.ElectricPotential.FromVolts(12)).Amperes,
+            12);
+        Assert.Equal(
+            (legacyApparentPower / Legacy::UnitsNet.ElectricCurrent.FromAmperes(10)).Volts,
+            (generatedApparentPower / Generated::UnitsNet.ElectricCurrent.FromAmperes(10)).Volts,
+            12);
+
+        Legacy::UnitsNet.Energy legacyCombustionEnergy =
+            Legacy::UnitsNet.EnergyDensity.CombustionEnergy(
+                Legacy::UnitsNet.EnergyDensity.FromJoulesPerCubicMeter(10),
+                Legacy::UnitsNet.Volume.FromCubicMeters(3),
+                Legacy::UnitsNet.Ratio.FromPercent(80));
+        Generated::UnitsNet.Energy generatedCombustionEnergy =
+            Generated::UnitsNet.EnergyDensity.CombustionEnergy(
+                Generated::UnitsNet.EnergyDensity.FromJoulesPerCubicMeter(10),
+                Generated::UnitsNet.Volume.FromCubicMeters(3),
+                Generated::UnitsNet.Ratio.FromPercent(80));
+        Assert.Equal(legacyCombustionEnergy.Joules, generatedCombustionEnergy.Joules, 12);
+
+        Legacy::UnitsNet.ElectricPotential legacyPotential = Legacy::UnitsNet.ElectricPotential.FromVolts(2);
+        Generated::UnitsNet.ElectricPotential generatedPotential =
+            Generated::UnitsNet.ElectricPotential.FromVolts(2);
+        Legacy::UnitsNet.AmplitudeRatio legacyAmplitude =
+            Legacy::UnitsNet.AmplitudeRatio.FromElectricPotential(legacyPotential);
+        Generated::UnitsNet.AmplitudeRatio generatedAmplitude =
+            Generated::UnitsNet.AmplitudeRatio.FromElectricPotential(generatedPotential);
+        Assert.Equal(legacyAmplitude.DecibelVolts, generatedAmplitude.DecibelVolts, 12);
+        Assert.Equal(legacyAmplitude.ToElectricPotential().Volts, generatedAmplitude.ToElectricPotential().Volts, 12);
+        Assert.Equal(
+            legacyPotential.ToAmplitudeRatio().DecibelVolts,
+            generatedPotential.ToAmplitudeRatio().DecibelVolts,
+            12);
+
+        Legacy::UnitsNet.Power legacyPower = Legacy::UnitsNet.Power.FromWatts(2);
+        Generated::UnitsNet.Power generatedPower = Generated::UnitsNet.Power.FromWatts(2);
+        Legacy::UnitsNet.PowerRatio legacyPowerRatio = Legacy::UnitsNet.PowerRatio.FromPower(legacyPower);
+        Generated::UnitsNet.PowerRatio generatedPowerRatio = Generated::UnitsNet.PowerRatio.FromPower(generatedPower);
+        Assert.Equal(legacyPowerRatio.DecibelWatts, generatedPowerRatio.DecibelWatts, 12);
+        Assert.Equal(legacyPowerRatio.ToPower().Watts, generatedPowerRatio.ToPower().Watts, 12);
+        Assert.Equal(legacyPower.ToPowerRatio().DecibelWatts, generatedPower.ToPowerRatio().DecibelWatts, 12);
+
+        Legacy::UnitsNet.ElectricResistance legacyImpedance =
+            Legacy::UnitsNet.ElectricResistance.FromOhms(50);
+        Generated::UnitsNet.ElectricResistance generatedImpedance =
+            Generated::UnitsNet.ElectricResistance.FromOhms(50);
+        Assert.Equal(
+            legacyAmplitude.ToPowerRatio(legacyImpedance).DecibelWatts,
+            generatedAmplitude.ToPowerRatio(generatedImpedance).DecibelWatts,
+            12);
+        Assert.Equal(
+            legacyPowerRatio.ToAmplitudeRatio(legacyImpedance).DecibelVolts,
+            generatedPowerRatio.ToAmplitudeRatio(generatedImpedance).DecibelVolts,
+            12);
+
+        Assert.Equal(
+            new Legacy::UnitsNet.Level(100, 1).Decibels,
+            new Generated::UnitsNet.Level(100, 1).Decibels,
+            12);
+        Assert.Throws<ArgumentOutOfRangeException>(
+            () => new Generated::UnitsNet.AmplitudeRatio(Generated::UnitsNet.ElectricPotential.Zero));
+        Assert.Throws<ArgumentOutOfRangeException>(
+            () => new Generated::UnitsNet.PowerRatio(Generated::UnitsNet.Power.Zero));
+
+        Assert.Equal(
+            Legacy::UnitsNet.Length.FromFeetInches(5, 6).Meters,
+            Generated::UnitsNet.Length.FromFeetInches(5, 6).Meters,
+            12);
+        Assert.Equal(
+            Legacy::UnitsNet.Mass.FromStonePounds(11, 4).Kilograms,
+            Generated::UnitsNet.Mass.FromStonePounds(11, 4).Kilograms,
+            12);
+
+        Legacy::UnitsNet.FeetInches legacyFeetInches =
+            Legacy::UnitsNet.Length.FromFeetInches(5, 6.625).FeetInches;
+        Generated::UnitsNet.FeetInches generatedFeetInches =
+            Generated::UnitsNet.Length.FromFeetInches(5, 6.625).FeetInches;
+        Assert.Equal(
+            legacyFeetInches.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            generatedFeetInches.ToString(System.Globalization.CultureInfo.InvariantCulture));
+        Assert.Equal(
+            legacyFeetInches.ToArchitecturalString(8),
+            generatedFeetInches.ToArchitecturalString(8));
+
+        Legacy::UnitsNet.StonePounds legacyStonePounds =
+            Legacy::UnitsNet.Mass.FromStonePounds(11, 4).StonePounds;
+        Generated::UnitsNet.StonePounds generatedStonePounds =
+            Generated::UnitsNet.Mass.FromStonePounds(11, 4).StonePounds;
+        Assert.Equal(
+            legacyStonePounds.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            generatedStonePounds.ToString(System.Globalization.CultureInfo.InvariantCulture));
+
+        var legacyReferencePressure = new Legacy::UnitsNet.Wrappers.ReferencePressure(
+            Legacy::UnitsNet.Pressure.FromAtmospheres(3),
+            Legacy::UnitsNet.CustomCode.Units.PressureReference.Gauge);
+        var generatedReferencePressure = new Generated::UnitsNet.Wrappers.ReferencePressure(
+            Generated::UnitsNet.Pressure.FromAtmospheres(3),
+            Generated::UnitsNet.CustomCode.Units.PressureReference.Gauge);
+        Assert.Equal(
+            legacyReferencePressure.Absolute.Atmospheres,
+            generatedReferencePressure.Absolute.Atmospheres,
+            12);
+        Assert.Equal(
+            legacyReferencePressure.Vacuum.Atmospheres,
+            generatedReferencePressure.Vacuum.Atmospheres,
+            12);
+
+        TimeSpan timeSpan = TimeSpan.FromMinutes(90);
+        Legacy::UnitsNet.Duration legacyDuration = timeSpan;
+        Generated::UnitsNet.Duration generatedDuration = timeSpan;
+        Assert.Equal(legacyDuration.ToTimeSpan(), generatedDuration.ToTimeSpan());
+        Assert.Equal(
+            new DateTime(2026, 1, 1) + legacyDuration,
+            new DateTime(2026, 1, 1) + generatedDuration);
+        Assert.Equal(legacyDuration > TimeSpan.FromHours(1), generatedDuration > TimeSpan.FromHours(1));
+
+        Assert.Equal(
+            default(Legacy::UnitsNet.Length).Meters.ToDouble(),
+            default(Generated::UnitsNet.Length).Meters);
+        Assert.Throws<FormatException>(() => Legacy::UnitsNet.Length.Parse("not a length", invariant));
+        Assert.Throws<FormatException>(() => Generated::UnitsNet.Length.Parse("not a length", invariant));
+    }
+
+    [Theory]
+    [MemberData(nameof(QuantityApis))]
+    public void GeneratedQuantity_ExposesCompatibleApiSubset(
+        Type legacyType,
+        Type generatedType,
+        string[] quantitySpecificMembers)
+    {
+        string[] commonMembers =
+        {
+            "Value",
+            "Unit",
+            "Zero",
+            "From",
+            "As",
+            "ToUnit",
+            "Parse",
+            "TryParse",
+            "ToString",
+        };
+        var selectedNames = new HashSet<string>(commonMembers.Concat(quantitySpecificMembers));
+        HashSet<string> legacySurface = GetSurface(legacyType, selectedNames);
+        HashSet<string> generatedSurface = GetSurface(generatedType, selectedNames);
+
+        Assert.NotEmpty(generatedSurface);
+        string[] unexpected = generatedSurface
+            .Except(legacySurface)
+            .Where(member =>
+                member != "M:ToString:System.String(System.IFormatProvider)" &&
+                member != "M:ToString:System.String(System.String)" &&
+                !member.StartsWith("M:As:", StringComparison.Ordinal) &&
+                !member.StartsWith("M:ToUnit:", StringComparison.Ordinal) &&
+                !member.Contains("UnitsNet.UnitSystem", StringComparison.Ordinal))
+            .OrderBy(member => member, StringComparer.Ordinal)
+            .ToArray();
+        Assert.True(
+            unexpected.Length == 0,
+            $"Generated surface has incompatible members:{Environment.NewLine}{string.Join(Environment.NewLine, unexpected)}");
+    }
+
+    [Theory]
+    [MemberData(nameof(UnitEnums))]
+    public void GeneratedUnitEnum_MatchesUnitsNet(Type legacyType, Type generatedType)
+    {
+        string[] names = Enum.GetNames(legacyType).OrderBy(name => name, StringComparer.Ordinal).ToArray();
+        Assert.Equal(names, Enum.GetNames(generatedType).OrderBy(name => name, StringComparer.Ordinal));
+        Assert.All(
+            names,
+            name => Assert.Equal(
+                Convert.ToInt32(Enum.Parse(legacyType, name)),
+                Convert.ToInt32(Enum.Parse(generatedType, name))));
+    }
+
+    private static object[] QuantityApi(Type legacyType, Type generatedType, params string[] members) =>
+        new object[] { legacyType, generatedType, members };
+
+    private static object[] UnitEnum<TLegacy, TGenerated>() => new object[] { typeof(TLegacy), typeof(TGenerated) };
+
+    private static HashSet<string> GetSurface(Type type, ISet<string> selectedNames)
+    {
+        const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static |
+                                   BindingFlags.DeclaredOnly;
+        IEnumerable<string> properties = type.GetProperties(flags)
+            .Where(property => selectedNames.Contains(property.Name))
+            .Select(property => $"P:{property.Name}:{TypeName(property.PropertyType)}");
+        IEnumerable<string> methods = type.GetMethods(flags)
+            .Where(method => selectedNames.Contains(method.Name))
+            .Select(MethodSignature);
+        return properties.Concat(methods).ToHashSet(StringComparer.Ordinal);
+    }
+
+    private static string MethodSignature(MethodInfo method)
+    {
+        string parameters = string.Join(",", method.GetParameters().Select(parameter => TypeName(parameter.ParameterType)));
+        return $"M:{method.Name}:{TypeName(method.ReturnType)}({parameters})";
+    }
+
+    private static (object? Value, Exception? Error) InvokeUnitSystemConstructor(
+        ConstructorInfo constructor,
+        object unitSystem)
+    {
+        try
+        {
+            ParameterInfo numericParameter = constructor.GetParameters()[0];
+            return (constructor.Invoke(new[] { ConvertNumeric(1d, numericParameter.ParameterType), unitSystem }), null);
+        }
+        catch (TargetInvocationException exception)
+        {
+            return (null, exception.InnerException ?? exception);
+        }
+    }
+
+    private static string TypeName(Type type) =>
+        IsLegacyQuantityValue(type) ? typeof(double).FullName! : type.FullName ?? type.Name;
+
+    private static HashSet<string> GetCompleteSurface(Type type)
+    {
+        const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static |
+                                   BindingFlags.DeclaredOnly;
+        IEnumerable<string> constructors = type.GetConstructors(flags)
+            .Select(constructor =>
+                $"C:.ctor({string.Join(",", constructor.GetParameters().Select(parameter => StableTypeName(parameter.ParameterType)))})");
+        IEnumerable<string> properties = type.GetProperties(flags)
+            .Select(property => $"P:{property.Name}:{StableTypeName(property.PropertyType)}");
+        IEnumerable<string> methods = type.GetMethods(flags)
+            .Where(method => !method.IsSpecialName || method.Name.StartsWith("op_", StringComparison.Ordinal))
+            .Select(method =>
+                $"M:{method.Name}:{StableTypeName(method.ReturnType)}" +
+                $"({string.Join(",", method.GetParameters().Select(parameter => StableTypeName(parameter.ParameterType)))})");
+        return constructors.Concat(properties).Concat(methods).ToHashSet(StringComparer.Ordinal);
+    }
+
+    private static string[] GetCompanionSurface(Type type)
+    {
+        const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static |
+                                   BindingFlags.DeclaredOnly;
+        IEnumerable<string> fields = type.GetFields(flags)
+            .Select(field => $"F:{field.Name}:{StableTypeName(field.FieldType)}");
+        return GetCompleteSurface(type)
+            .Concat(fields)
+            .OrderBy(signature => signature, StringComparer.Ordinal)
+            .ToArray();
+    }
+
+    private static bool IsDocumentedCompatibilityDifference(string quantityName, string signature)
+    {
+        if (signature.StartsWith("P:DefaultConversionFunctions:", StringComparison.Ordinal) ||
+            signature.StartsWith("P:BaseDimensions:", StringComparison.Ordinal) ||
+            signature.StartsWith("P:BaseUnit:", StringComparison.Ordinal) ||
+            signature.StartsWith("P:QuantityInfo:", StringComparison.Ordinal) ||
+            signature.StartsWith("P:Units:", StringComparison.Ordinal) ||
+            signature.Contains("(UnitsNet.UnitKey)", StringComparison.Ordinal) ||
+            signature.Contains("UnitsNet.UnitConverter", StringComparison.Ordinal) ||
+            signature.Contains("UnitsNet.UnitSystem", StringComparison.Ordinal))
+        {
+            return true;
+        }
+
+        if (quantityName is "AmplitudeRatio" or "PowerRatio" or "Level" &&
+            signature.Contains("System.Byte", StringComparison.Ordinal))
+        {
+            return true;
+        }
+
+        return IntentionalQuantityApiExclusions.TryGetValue(quantityName, out QuantityApiExclusion? exclusion) &&
+               exclusion.MemberNames.Any(member => IsNamedMember(signature, member));
+    }
+
+    private static bool IsNamedMember(string signature, string memberName) =>
+        signature.StartsWith($"P:{memberName}:", StringComparison.Ordinal) ||
+        signature.StartsWith($"M:{memberName}:", StringComparison.Ordinal) ||
+        signature.StartsWith($"C:{memberName}", StringComparison.Ordinal);
+
+    private static string StableTypeName(Type type)
+    {
+        if (type.IsByRef)
+        {
+            return StableTypeName(type.GetElementType()!) + "&";
+        }
+
+        if (type.IsArray)
+        {
+            return StableTypeName(type.GetElementType()!) + "[]";
+        }
+
+        if (IsLegacyQuantityValue(type) || type == typeof(System.Numerics.BigInteger))
+        {
+            return typeof(double).FullName!;
+        }
+
+        if (!type.IsGenericType)
+        {
+            return type.FullName ?? type.Name;
+        }
+
+        string name = type.GetGenericTypeDefinition().FullName ?? type.Name;
+        int arity = name.IndexOf('`');
+        if (arity >= 0)
+        {
+            name = name.Substring(0, arity);
+        }
+
+        return $"{name}<{string.Join(",", type.GetGenericArguments().Select(StableTypeName))}>";
+    }
+
+    private static object CreateQuantity(Type quantityType, double value, object unit)
+    {
+        ConstructorInfo constructor = quantityType.GetConstructors()
+            .Single(candidate =>
+            {
+                ParameterInfo[] parameters = candidate.GetParameters();
+                return parameters.Length == 2 && parameters[1].ParameterType == unit.GetType();
+            });
+        return constructor.Invoke(new[] { ConvertNumeric(value, constructor.GetParameters()[0].ParameterType), unit });
+    }
+
+    private static object GetGeneratedBaseUnit(Type quantityType)
+    {
+        object info = quantityType.GetProperty("Info")!.GetValue(null)!;
+        object baseUnit = info.GetType().GetProperty("BaseUnit")!.GetValue(info)!;
+        return baseUnit.GetType().GetProperty("Value")!.GetValue(baseUnit)!;
+    }
+
+    private static object ConvertNumeric(double value, Type targetType)
+    {
+        if (targetType == typeof(double))
+        {
+            return value;
+        }
+
+        MethodInfo conversion = targetType.GetMethod(
+            "op_Implicit",
+            BindingFlags.Public | BindingFlags.Static,
+            binder: null,
+            new[] { typeof(double) },
+            modifiers: null)
+            ?? throw new InvalidOperationException($"No implicit double conversion exists for {targetType}.");
+        return conversion.Invoke(null, new object[] { value })!;
+    }
+
+    private static double NumericValue(object value) =>
+        value is double number ? number : Convert.ToDouble(value, System.Globalization.CultureInfo.InvariantCulture);
+
+    private static bool IsLegacyQuantityValue(Type type) =>
+        type.Assembly == LegacyAssembly &&
+        string.Equals(type.FullName, "UnitsNet.QuantityValue", StringComparison.Ordinal);
+
+    private static void AssertNearlyEqual(double expected, double actual, string operation)
+    {
+        if (double.IsNaN(expected) || double.IsInfinity(expected))
+        {
+            Assert.Equal(expected, actual);
+            return;
+        }
+
+        double tolerance = Math.Max(1e-11, Math.Abs(expected) * 1e-11);
+        Assert.True(
+            Math.Abs(expected - actual) <= tolerance,
+            $"{operation}: expected {expected:R}, actual {actual:R}, tolerance {tolerance:R}");
+    }
+
+    private static IReadOnlyDictionary<string, QuantityApiExclusion> IntentionalQuantityApiExclusions { get; } =
+        new Dictionary<string, QuantityApiExclusion>(StringComparer.Ordinal)
+        {
+            ["Length"] = new(
+                "The specialized compound parser depends on presentation-specific grammar outside ordinary quantity parsing.",
+                "ParseFeetInches",
+                "TryParseFeetInches"),
+            ["Pressure"] = new(
+                "Elevation conversion is an empirical atmosphere model, not immutable unit-conversion metadata.",
+                "FromElevation",
+                "ToElevation"),
+        };
+
+    private sealed class QuantityApiExclusion
+    {
+        public QuantityApiExclusion(string reason, params string[] memberNames)
+        {
+            Reason = reason;
+            MemberNames = memberNames.ToHashSet(StringComparer.Ordinal);
+        }
+
+        public string Reason { get; }
+
+        public IReadOnlySet<string> MemberNames { get; }
+    }
+
+    private static int[] ReadDimensions(object dimensions)
+    {
+        string[] names =
+        {
+            "Length",
+            "Mass",
+            "Time",
+            "Current",
+            "Temperature",
+            "Amount",
+            "LuminousIntensity",
+        };
+        return names
+            .Select(name => (int)dimensions.GetType().GetProperty(name)!.GetValue(dimensions)!)
+            .ToArray();
+    }
+
+    private static Type[] GetQuantityTypes(Assembly assembly) =>
+        assembly.GetTypes()
+            .Where(type =>
+                type.Namespace == "UnitsNet" &&
+                type.IsValueType &&
+                !type.IsEnum &&
+                assembly.GetType($"UnitsNet.Units.{type.Name}Unit") is not null)
+            .OrderBy(type => type.FullName, StringComparer.Ordinal)
+            .ToArray();
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Generated/GeneratedModule.cs b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Generated/GeneratedModule.cs
new file mode 100644
index 0000000000..ca8c3456ee
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Generated/GeneratedModule.cs
@@ -0,0 +1,11 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using UnitsNet.Modular;
+using UnitsNet.Modular.Profiles;
+
+namespace UnitsNet.Modular.Compatibility;
+
+[UnitsNetModule]
+internal interface CompatibilityUnits : IIncludeProfile<AllQuantitiesProfile>
+{
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Generated/UnitsNet.Modular.Compatibility.GeneratedFixture.csproj b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Generated/UnitsNet.Modular.Compatibility.GeneratedFixture.csproj
new file mode 100644
index 0000000000..67cc651806
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Generated/UnitsNet.Modular.Compatibility.GeneratedFixture.csproj
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+    <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)Generated</CompilerGeneratedFilesOutputPath>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="../Shared/CompatibilityScenario.cs" Link="CompatibilityScenario.cs" />
+    <ProjectReference Include="../../../UnitsNet.Modular/UnitsNet.Modular.csproj" />
+    <ProjectReference Include="../../../UnitsNet.Modular.Generator/UnitsNet.Modular.Generator.csproj"
+                      OutputItemType="Analyzer"
+                      ReferenceOutputAssembly="false" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Legacy/UnitsNet.Modular.Compatibility.LegacyFixture.csproj b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Legacy/UnitsNet.Modular.Compatibility.LegacyFixture.csproj
new file mode 100644
index 0000000000..e90ab931c7
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Legacy/UnitsNet.Modular.Compatibility.LegacyFixture.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="../Shared/CompatibilityScenario.cs" Link="CompatibilityScenario.cs" />
+    <ProjectReference Include="../../../../UnitsNet/UnitsNet.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Shared/CompatibilityScenario.cs b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Shared/CompatibilityScenario.cs
new file mode 100644
index 0000000000..920a56e084
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/Fixtures/Shared/CompatibilityScenario.cs
@@ -0,0 +1,53 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Globalization;
+using UnitsNet;
+using UnitsNet.Units;
+
+namespace UnitsNet.Modular.Compatibility;
+
+public static class CompatibilityScenario
+{
+    public static string Run()
+    {
+        Length distance = Length.FromKilometers(1.5).ToUnit(LengthUnit.Meter);
+        Area area = Length.FromMeters(2) * Length.FromMeters(3);
+        Temperature temperature = Temperature.FromDegreesCelsius(21.5)
+            .ToUnit(TemperatureUnit.DegreeFahrenheit);
+        Temperature freezing = Temperature.FromDegreesCelsius(0);
+        Temperature boiling = Temperature.FromDegreesFahrenheit(212);
+        TemperatureDelta temperatureRange = boiling - freezing;
+        Temperature midpoint = new[] { freezing, boiling }.Average(TemperatureUnit.DegreeCelsius);
+        Level combinedLevel = Level.FromDecibels(10) + Level.FromDecibels(10);
+        Information payload = Information.FromKibibytes(2).ToUnit(InformationUnit.Bit);
+        Length total = new[]
+        {
+            Length.FromKilometers(1),
+            Length.FromMeters(500),
+        }.Sum();
+        Length average = new[]
+        {
+            Length.FromMeters(1),
+            Length.FromCentimeters(300),
+        }.Average();
+        var kilometerInfo = Length.Info[LengthUnit.Kilometer];
+        Length metadataDistance = Length.From(1.5, kilometerInfo.Value);
+
+        return string.Join(
+            Environment.NewLine,
+            FormattableString.Invariant($"Length: {distance.Value:G15} {distance.Unit}"),
+            FormattableString.Invariant($"Area: {area.Value:G15} {area.Unit}"),
+            FormattableString.Invariant($"Temperature: {temperature.Value:G15} {temperature.Unit}"),
+            FormattableString.Invariant($"Temperature range: {temperatureRange.Value:G15} {temperatureRange.Unit}"),
+            FormattableString.Invariant($"Temperature midpoint: {midpoint.Value:G15} {midpoint.Unit}"),
+            FormattableString.Invariant($"Level: {combinedLevel.Value:G15} {combinedLevel.Unit}"),
+            FormattableString.Invariant($"Information: {payload.Value:G15} {payload.Unit}"),
+            FormattableString.Invariant($"Sum: {total.Value:G15} {total.Unit}"),
+            FormattableString.Invariant($"Average: {average.Value:G15} {average.Unit}"),
+            FormattableString.Invariant(
+                $"Metadata: {metadataDistance.Value:G15} {kilometerInfo.Name}"));
+    }
+
+    public static Length ParseLength(string text) =>
+        Length.Parse(text, CultureInfo.InvariantCulture);
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/UnitsNet.Modular.Compatibility.Tests.csproj b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/UnitsNet.Modular.Compatibility.Tests.csproj
new file mode 100644
index 0000000000..884277a7de
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Compatibility.Tests/UnitsNet.Modular.Compatibility.Tests.csproj
@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio" PrivateAssets="all" />
+  </ItemGroup>
+  <ItemGroup>
+    <!-- Fixture sources compile only into their aliased legacy and generated assemblies. -->
+    <Compile Remove="Fixtures/**/*.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="Fixtures/Generated/UnitsNet.Modular.Compatibility.GeneratedFixture.csproj">
+      <Aliases>Generated</Aliases>
+    </ProjectReference>
+    <ProjectReference Include="Fixtures/Legacy/UnitsNet.Modular.Compatibility.LegacyFixture.csproj">
+      <Aliases>LegacyScenario</Aliases>
+    </ProjectReference>
+    <ProjectReference Include="../../UnitsNet/UnitsNet.csproj">
+      <Aliases>Legacy</Aliases>
+    </ProjectReference>
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/AugmentationGeneratorTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/AugmentationGeneratorTests.cs
new file mode 100644
index 0000000000..328b71a296
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/AugmentationGeneratorTests.cs
@@ -0,0 +1,238 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using Microsoft.CodeAnalysis;
+using Xunit;
+
+namespace UnitsNet.Modular.Generator.Tests;
+
+public sealed class AugmentationGeneratorTests
+{
+    [Fact]
+    public void AreaAndLengthSelection_EmitsCircleAugmentation()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module :
+                IInclude<UnitsNet.Modular.BuiltIns.AreaSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>;
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        string areaSource = Assert.Single(
+            run.Result.Results
+                .SelectMany(result => result.GeneratedSources),
+            source => source.HintName.EndsWith("_Area.g.cs", StringComparison.Ordinal))
+            .SourceText
+            .ToString();
+        Assert.Contains("FromCircleDiameter(global::UnitsNet.Length diameter)", areaSource, StringComparison.Ordinal);
+        Assert.Contains("FromCircleRadius(global::UnitsNet.Length radius)", areaSource, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void AreaWithoutLengthSelection_OmitsDependentAugmentation()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<UnitsNet.Modular.BuiltIns.AreaSpec>;
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(
+            run.Result.Results.SelectMany(result => result.GeneratedSources),
+            source => source.SourceText.ToString().Contains("FromCircleRadius", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void MechanicalSelections_EmitCompatibleAugmentations()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module :
+                IInclude<UnitsNet.Modular.BuiltIns.AccelerationSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.AreaSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.ForceSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.MassSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.MassFractionSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.PressureSpec>;
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        string generated = string.Join(
+            Environment.NewLine,
+            run.Result.Results.SelectMany(result => result.GeneratedSources).Select(source => source.SourceText));
+        Assert.Contains("GetComponentMass(global::UnitsNet.Mass totalMass)", generated, StringComparison.Ordinal);
+        Assert.Contains("FromPressureByArea(global::UnitsNet.Pressure pressure", generated, StringComparison.Ordinal);
+        Assert.Contains("FromMassByAcceleration(global::UnitsNet.Mass mass", generated, StringComparison.Ordinal);
+        Assert.Contains("FromGravitationalForce(global::UnitsNet.Force force)", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ChemistrySelections_EmitCompatibleAugmentations()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module :
+                IInclude<UnitsNet.Modular.BuiltIns.AmountOfSubstanceSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.DensitySpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.MassSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.MassConcentrationSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.MolaritySpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.MolarMassSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.VolumeSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.VolumeConcentrationSpec>;
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        string generated = string.Join(
+            Environment.NewLine,
+            run.Result.Results.SelectMany(result => result.GeneratedSources).Select(source => source.SourceText));
+        Assert.Contains("double AvogadroConstant", generated, StringComparison.Ordinal);
+        Assert.Contains("FromMass(global::UnitsNet.Mass mass", generated, StringComparison.Ordinal);
+        Assert.Contains("ToMolarity(global::UnitsNet.MolarMass molecularWeight)", generated, StringComparison.Ordinal);
+        Assert.Contains("ToVolumeConcentration(global::UnitsNet.Density componentDensity", generated, StringComparison.Ordinal);
+        Assert.Contains("FromVolumes(global::UnitsNet.Volume componentVolume", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void EnergySelections_EmitCompatibleAugmentations()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module :
+                IInclude<UnitsNet.Modular.BuiltIns.ElectricApparentPowerSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.ElectricCurrentSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.ElectricPotentialSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.EnergySpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.EnergyDensitySpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.RatioSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.VolumeSpec>;
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        string generated = string.Join(
+            Environment.NewLine,
+            run.Result.Results.SelectMany(result => result.GeneratedSources).Select(source => source.SourceText));
+        Assert.Contains("ElectricCurrent operator /(ElectricApparentPower power", generated, StringComparison.Ordinal);
+        Assert.Contains("ElectricPotential operator /(ElectricApparentPower power", generated, StringComparison.Ordinal);
+        Assert.Contains("CombustionEnergy(EnergyDensity energyDensity", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void LogarithmicSelections_EmitCompatibleAugmentations()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module :
+                IInclude<UnitsNet.Modular.BuiltIns.AmplitudeRatioSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.ElectricPotentialSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.ElectricResistanceSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.LevelSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.PowerSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.PowerRatioSpec>;
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        string generated = string.Join(
+            Environment.NewLine,
+            run.Result.Results.SelectMany(result => result.GeneratedSources).Select(source => source.SourceText));
+        Assert.Contains("AmplitudeRatio(global::UnitsNet.ElectricPotential voltage)", generated, StringComparison.Ordinal);
+        Assert.Contains("ToPowerRatio(global::UnitsNet.ElectricResistance impedance)", generated, StringComparison.Ordinal);
+        Assert.Contains("Level(double quantity, double reference)", generated, StringComparison.Ordinal);
+        Assert.Contains("PowerRatio(global::UnitsNet.Power power)", generated, StringComparison.Ordinal);
+        Assert.Contains("ToAmplitudeRatio(global::UnitsNet.ElectricResistance impedance)", generated, StringComparison.Ordinal);
+        Assert.Contains(
+            "Performs logarithmic multiplication by adding the scalar to the stored logarithmic value.",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "Performs commutative logarithmic multiplication by adding the scalar to the stored logarithmic value.",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "Performs logarithmic division by subtracting the scalar from the stored logarithmic value.",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "Returns the logarithmic difference between two quantities expressed in the left operand's unit.",
+            generated,
+            StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void CompanionSelections_EmitFactoriesAndWrappers()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module :
+                IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.MassSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.PressureSpec>;
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        string generated = string.Join(
+            Environment.NewLine,
+            run.Result.Results.SelectMany(result => result.GeneratedSources).Select(source => source.SourceText));
+        Assert.Contains("FromFeetInches(double feet, double inches)", generated, StringComparison.Ordinal);
+        Assert.Contains("FromStonePounds(double stone, double pounds)", generated, StringComparison.Ordinal);
+        Assert.Contains("sealed class FeetInches", generated, StringComparison.Ordinal);
+        Assert.Contains("sealed class StonePounds", generated, StringComparison.Ordinal);
+        Assert.Contains("struct ReferencePressure", generated, StringComparison.Ordinal);
+        Assert.Contains("enum PressureReference", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void FilteredCompoundUnits_OmitFactoriesThatReintroduceExcludedUnits()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitSet("regex:^Meter$")]
+            internal interface MeterOnlyUnitSet;
+
+            [UnitSet("regex:^Kilogram$")]
+            internal interface KilogramOnlyUnitSet;
+
+            [UnitsNetModule]
+            internal interface Module :
+                IInclude<UnitsNet.Modular.BuiltIns.LengthSpec, MeterOnlyUnitSet>,
+                IInclude<UnitsNet.Modular.BuiltIns.MassSpec, KilogramOnlyUnitSet>;
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(
+            run.Result.Results.SelectMany(result => result.GeneratedSources),
+            source => source.SourceText.ToString().Contains("FromFeetInches", StringComparison.Ordinal));
+        Assert.DoesNotContain(
+            run.Result.Results.SelectMany(result => result.GeneratedSources),
+            source => source.SourceText.ToString().Contains("FromStonePounds", StringComparison.Ordinal));
+        Assert.DoesNotContain(
+            run.Result.Results.SelectMany(result => result.GeneratedSources),
+            source => source.SourceText.ToString().Contains("sealed class FeetInches", StringComparison.Ordinal));
+        Assert.DoesNotContain(
+            run.Result.Results.SelectMany(result => result.GeneratedSources),
+            source => source.SourceText.ToString().Contains("sealed class StonePounds", StringComparison.Ordinal));
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/DiagnosticDocumentationTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/DiagnosticDocumentationTests.cs
new file mode 100644
index 0000000000..763e2ab39a
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/DiagnosticDocumentationTests.cs
@@ -0,0 +1,28 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Reflection;
+using Microsoft.CodeAnalysis;
+using Xunit;
+
+namespace UnitsNet.Modular.Generator.Tests;
+
+public sealed class DiagnosticDocumentationTests
+{
+    [Fact]
+    public void EveryDiagnosticLinksToRelevantDocumentation()
+    {
+        DiagnosticDescriptor[] descriptors = typeof(UnitsNetModularGenerator)
+            .GetFields(BindingFlags.NonPublic | BindingFlags.Static)
+            .Where(field => field.FieldType == typeof(DiagnosticDescriptor))
+            .Select(field => (DiagnosticDescriptor)field.GetValue(null)!)
+            .ToArray();
+
+        Assert.Equal(13, descriptors.Length);
+        Assert.All(
+            descriptors,
+            descriptor => Assert.StartsWith(
+                "https://github.com/angularsen/UnitsNet/tree/master/UnitsNet.Modular#",
+                descriptor.HelpLinkUri,
+                StringComparison.Ordinal));
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/DiagnosticGeneratorTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/DiagnosticGeneratorTests.cs
new file mode 100644
index 0000000000..d31d3e4cdd
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/DiagnosticGeneratorTests.cs
@@ -0,0 +1,256 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Xunit;
+
+namespace UnitsNet.Modular.Generator.Tests;
+
+public sealed class DiagnosticGeneratorTests
+{
+    [Fact]
+    public void LegacyUnitsNetReference_ReportsUnsupportedCombination()
+    {
+        CSharpCompilation legacyCompilation = GeneratorTestHost.CreateCompilation(
+                "namespace UnitsNet; public sealed class LegacyRuntimeMarker;")
+            .WithAssemblyName("UnitsNet");
+        using var stream = new MemoryStream();
+        Assert.True(legacyCompilation.Emit(stream).Success);
+
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>;
+            """,
+            new[] { MetadataReference.CreateFromImage(stream.ToArray()) });
+
+        Diagnostic diagnostic = Assert.Single(run.Result.Diagnostics, item => item.Id == "UNM016");
+        Assert.Contains("Remove the legacy UnitsNet package reference", diagnostic.GetMessage(), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void MultipleModules_ReportActionableDiagnosticWithoutCollidingGeneratedTypes()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface FirstModule : IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>;
+
+            [UnitsNetModule]
+            internal interface SecondModule : IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>;
+            """);
+
+        Diagnostic diagnostic = Assert.Single(run.Result.Diagnostics, item => item.Id == "UNM014");
+        Assert.Contains("FirstModule", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.Contains("SecondModule", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.Contains("one module", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.Equal("Test.cs", diagnostic.Location.GetLineSpan().Path);
+        Assert.DoesNotContain(
+            run.Compilation.GetDiagnostics(),
+            item => item.Id is "CS0101" or "CS0102");
+        Assert.DoesNotContain(
+            run.Result.Results.SelectMany(result => result.GeneratedSources),
+            source => source.SourceText.ToString().Contains("partial struct Length", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void AffineQuantityWithoutOffsetSelection_ReportsRequiredQuantity()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<UnitsNet.Modular.BuiltIns.TemperatureSpec>;
+            """);
+
+        Diagnostic diagnostic = Assert.Single(run.Result.Diagnostics, item => item.Id == "UNM015");
+        Assert.Contains("UnitsNet.Temperature", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.Contains("UnitsNet.TemperatureDelta", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.Equal("Test.cs", diagnostic.Location.GetLineSpan().Path);
+        Assert.DoesNotContain(
+            run.Compilation.GetDiagnostics(),
+            item => item.Id is "CS0246" or "CS0101" or "CS0102");
+        Assert.DoesNotContain(
+            run.Result.Results.SelectMany(result => result.GeneratedSources),
+            source => source.SourceText.ToString().Contains("partial struct Temperature", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void UnitSetWithoutAttribute_ReportsAtModuleDeclaration()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            internal interface MissingUnitSet;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<UnitsNet.Modular.BuiltIns.LengthSpec, MissingUnitSet>;
+            """);
+
+        Diagnostic diagnostic = Assert.Single(run.Result.Diagnostics, item => item.Id == "UNM012");
+        Assert.Equal(LocationKind.ExternalFile, diagnostic.Location.Kind);
+        Assert.Equal("Test.cs", diagnostic.Location.GetLineSpan().Path);
+        Assert.Equal(5, diagnostic.Location.GetLineSpan().StartLinePosition.Line);
+    }
+
+    [Fact]
+    public void DifferentDefinitionsWithSameGeneratedType_ReportCollision()
+    {
+        const string unit = """
+            "BaseUnit": "Value",
+            "Units": [
+              { "SingularName": "Value", "PluralName": "Values", "FromUnitToBaseFunc": "{x}", "FromBaseToUnitFunc": "{x}" }
+            ]
+            """;
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [QuantitySpec("First.Widget")]
+            internal interface FirstWidgetSpec;
+
+            [QuantitySpec("Second.Widget")]
+            internal interface SecondWidgetSpec;
+
+            [UnitsNetModule("Application.Units")]
+            internal interface Module : IInclude<FirstWidgetSpec>, IInclude<SecondWidgetSpec>;
+            """,
+            ("First.unitsnet.json", "{ \"Name\": \"Widget\", \"Namespace\": \"First\", " + unit + " }"),
+            ("Second.unitsnet.json", "{ \"Name\": \"Widget\", \"Namespace\": \"Second\", " + unit + " }"));
+
+        Diagnostic diagnostic = Assert.Single(run.Result.Diagnostics, item => item.Id == "UNM013");
+        Assert.Contains("Application.Units.Widget", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.Equal(LocationKind.ExternalFile, diagnostic.Location.Kind);
+        Assert.Equal("Test.cs", diagnostic.Location.GetLineSpan().Path);
+    }
+
+    [Fact]
+    public void MalformedJson_ReportsTheJsonErrorLocation()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [QuantitySpec("Sample.Widget")]
+            internal interface WidgetSpec;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<WidgetSpec>;
+            """,
+            ("Widget.unitsnet.json", """
+                {
+                  "Name": "Widget",
+                  "Namespace": "Sample",
+                  "BaseUnit": "Value",
+                  "Units": [
+                    invalid
+                  ]
+                }
+                """));
+
+        Diagnostic diagnostic = Assert.Single(run.Result.Diagnostics, item => item.Id == "UNM004");
+        FileLinePositionSpan span = diagnostic.Location.GetLineSpan();
+        Assert.Equal("Widget.unitsnet.json", span.Path);
+        Assert.Equal(5, span.StartLinePosition.Line);
+        Assert.True(span.StartLinePosition.Character > 0);
+    }
+
+    [Fact]
+    public void UnknownPrefix_ReportsInvalidDefinitionInsteadOfCrashingGenerator()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [QuantitySpec("Sample.Widget")]
+            internal interface WidgetSpec;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<WidgetSpec>;
+            """,
+            ("Widget.unitsnet.json", """
+                {
+                  "Name": "Widget",
+                  "Namespace": "Sample",
+                  "BaseUnit": "Value",
+                  "Units": [
+                    {
+                      "SingularName": "Value",
+                      "PluralName": "Values",
+                      "FromUnitToBaseFunc": "{x}",
+                      "FromBaseToUnitFunc": "{x}",
+                      "Prefixes": [ "Imaginary" ]
+                    }
+                  ]
+                }
+                """));
+
+        Diagnostic diagnostic = Assert.Single(run.Result.Diagnostics, item => item.Id == "UNM004");
+        Assert.Contains("Unknown prefix 'Imaginary'", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.DoesNotContain(run.Result.Diagnostics, item => item.Id == "CS8785");
+    }
+
+    [Fact]
+    public void DuplicateUnitName_ReportsDefinitionDiagnosticWithoutCompilerCollision()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [QuantitySpec("Sample.Widget")]
+            internal interface WidgetSpec;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<WidgetSpec>;
+            """,
+            ("Widget.unitsnet.json", """
+                {
+                  "Name": "Widget",
+                  "Namespace": "Sample",
+                  "BaseUnit": "Value",
+                  "Units": [
+                    { "SingularName": "Value", "PluralName": "Values", "FromUnitToBaseFunc": "{x}", "FromBaseToUnitFunc": "{x}" },
+                    { "SingularName": "Value", "PluralName": "OtherValues", "FromUnitToBaseFunc": "{x}", "FromBaseToUnitFunc": "{x}" }
+                  ]
+                }
+                """));
+
+        Diagnostic diagnostic = Assert.Single(run.Result.Diagnostics, item => item.Id == "UNM004");
+        Assert.Contains("SingularName 'Value' is duplicated", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.DoesNotContain(
+            run.Compilation.GetDiagnostics(),
+            item => item.Id is "CS0101" or "CS0102" or "CS0111");
+    }
+
+    [Fact]
+    public void InvalidCSharpIdentifier_ReportsDefinitionDiagnostic()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [QuantitySpec("Sample.Bad-Widget")]
+            internal interface WidgetSpec;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<WidgetSpec>;
+            """,
+            ("Widget.unitsnet.json", """
+                {
+                  "Name": "Bad-Widget",
+                  "Namespace": "Sample",
+                  "BaseUnit": "Value",
+                  "Units": [
+                    { "SingularName": "Value", "PluralName": "Values", "FromUnitToBaseFunc": "{x}", "FromBaseToUnitFunc": "{x}" }
+                  ]
+                }
+                """));
+
+        Diagnostic diagnostic = Assert.Single(run.Result.Diagnostics, item => item.Id == "UNM004");
+        Assert.Contains("not a valid C# identifier", diagnostic.GetMessage(), StringComparison.Ordinal);
+        Assert.DoesNotContain(run.Result.Diagnostics, item => item.Id == "CS8785");
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/FullCatalogGeneratorTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/FullCatalogGeneratorTests.cs
new file mode 100644
index 0000000000..86b05115c2
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/FullCatalogGeneratorTests.cs
@@ -0,0 +1,63 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Diagnostics;
+using Microsoft.CodeAnalysis;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace UnitsNet.Modular.Generator.Tests;
+
+public sealed class FullCatalogGeneratorTests
+{
+    private const string Source = """
+        using UnitsNet.Modular;
+        using UnitsNet.Modular.Profiles;
+
+        [UnitsNetModule]
+        internal interface FullCatalogModule : IIncludeProfile<AllQuantitiesProfile>;
+        """;
+
+    private readonly ITestOutputHelper _output;
+
+    public FullCatalogGeneratorTests(ITestOutputHelper output)
+    {
+        _output = output;
+    }
+
+    [Fact]
+    public void FullCatalog_GeneratesDeterministicallyWithinPrototypeBudgets()
+    {
+        var stopwatch = Stopwatch.StartNew();
+        GeneratorTestHost.TestRun first = GeneratorTestHost.Run(Source);
+        stopwatch.Stop();
+
+        Assert.DoesNotContain(first.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(
+            first.Compilation.GetDiagnostics(),
+            diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        GeneratedSourceResult[] firstSources = first.Result.Results
+            .SelectMany(result => result.GeneratedSources)
+            .OrderBy(source => source.HintName, StringComparer.Ordinal)
+            .ToArray();
+        Assert.Equal(
+            129,
+            firstSources.Count(source =>
+                source.SourceText.ToString().Contains("public readonly partial struct", StringComparison.Ordinal)));
+        Assert.Contains(firstSources, source => source.HintName.EndsWith("_Registry.g.cs", StringComparison.Ordinal));
+        Assert.Contains(firstSources, source => source.HintName.EndsWith("_Extensions.g.cs", StringComparison.Ordinal));
+
+        long sourceCharacters = firstSources.Sum(source => (long)source.SourceText.Length);
+        _output.WriteLine($"Full catalog generated {firstSources.Length} sources and {sourceCharacters:N0} characters in {stopwatch.Elapsed}.");
+        Assert.InRange(sourceCharacters, 1, 20_000_000);
+        Assert.True(stopwatch.Elapsed < TimeSpan.FromSeconds(30), $"Full catalog generation took {stopwatch.Elapsed}.");
+
+        GeneratorTestHost.TestRun second = GeneratorTestHost.Run(Source);
+        GeneratedSourceResult[] secondSources = second.Result.Results
+            .SelectMany(result => result.GeneratedSources)
+            .OrderBy(source => source.HintName, StringComparer.Ordinal)
+            .ToArray();
+        Assert.Equal(
+            firstSources.Select(source => (source.HintName, source.SourceText.ToString())),
+            secondSources.Select(source => (source.HintName, source.SourceText.ToString())));
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/GeneratorTestHost.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/GeneratorTestHost.cs
new file mode 100644
index 0000000000..5a52851af0
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/GeneratorTestHost.cs
@@ -0,0 +1,92 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Collections.Immutable;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using UnitsNet.Modular.SourceGen;
+
+namespace UnitsNet.Modular.Generator.Tests;
+
+internal static class GeneratorTestHost
+{
+    public static TestRun Run(string source, params (string Path, string Text)[] additionalFiles)
+        => Run(source, Array.Empty<MetadataReference>(), additionalFiles);
+
+    public static TestRun Run(
+        string source,
+        IEnumerable<MetadataReference> additionalReferences,
+        params (string Path, string Text)[] additionalFiles)
+    {
+        CSharpCompilation compilation = CreateCompilation(source, additionalReferences);
+        GeneratorDriver driver = CreateDriver(additionalFiles)
+            .RunGeneratorsAndUpdateCompilation(compilation, out Compilation output, out _);
+        return new TestRun(driver.GetRunResult(), output);
+    }
+
+    public static CSharpCompilation CreateCompilation(
+        string source,
+        IEnumerable<MetadataReference>? additionalReferences = null)
+    {
+        string[] trustedAssemblies = ((string?)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES"))!
+            .Split(Path.PathSeparator);
+        var references = trustedAssemblies
+            .Select(path => MetadataReference.CreateFromFile(path))
+            .Concat(new[]
+            {
+                MetadataReference.CreateFromFile(typeof(QuantityOperations).Assembly.Location),
+            })
+            .Concat(additionalReferences ?? Array.Empty<MetadataReference>())
+            .GroupBy(reference => reference.Display, StringComparer.OrdinalIgnoreCase)
+            .Select(group => group.First())
+            .ToArray();
+        return CSharpCompilation.Create(
+            "GeneratorTest",
+            new[] { CSharpSyntaxTree.ParseText(source, ParseOptions, path: "Test.cs") },
+            references,
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+    }
+
+    public static GeneratorDriver CreateDriver(params (string Path, string Text)[] additionalFiles)
+        => CreateDriver(CreateAdditionalTexts(additionalFiles));
+
+    public static GeneratorDriver CreateDriver(ImmutableArray<AdditionalText> additionalTexts)
+    {
+        return CSharpGeneratorDriver.Create(
+            new[] { new UnitsNetModularGenerator().AsSourceGenerator() },
+            additionalTexts,
+            ParseOptions,
+            optionsProvider: null,
+            new GeneratorDriverOptions(IncrementalGeneratorOutputKind.None, trackIncrementalGeneratorSteps: true));
+    }
+
+    public static ImmutableArray<AdditionalText> CreateAdditionalTexts(
+        params (string Path, string Text)[] additionalFiles)
+    {
+        return additionalFiles
+            .Select(file => (AdditionalText)new InMemoryAdditionalText(file.Path, file.Text))
+            .ToImmutableArray();
+    }
+
+    private static CSharpParseOptions ParseOptions { get; } =
+        new(LanguageVersion.Latest, preprocessorSymbols: new[] { "NET8_0_OR_GREATER" });
+
+    internal sealed record TestRun(GeneratorDriverRunResult Result, Compilation Compilation);
+
+    private sealed class InMemoryAdditionalText : AdditionalText
+    {
+        private readonly SourceText _text;
+
+        public InMemoryAdditionalText(string path, string text)
+        {
+            Path = path;
+            _text = SourceText.From(text, Encoding.UTF8);
+        }
+
+        public override string Path { get; }
+
+        public override SourceText GetText(CancellationToken cancellationToken = default) => _text;
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/IncrementalityGeneratorTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/IncrementalityGeneratorTests.cs
new file mode 100644
index 0000000000..48b3dbaae0
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/IncrementalityGeneratorTests.cs
@@ -0,0 +1,137 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Xunit;
+
+namespace UnitsNet.Modular.Generator.Tests;
+
+public sealed class IncrementalityGeneratorTests
+{
+    private const string CustomModule = """
+        using UnitsNet.Modular;
+
+        [QuantitySpec("Sample.Distance")]
+        internal interface DistanceSpec;
+
+        [QuantitySpec("Sample.Weight")]
+        internal interface WeightSpec;
+
+        [UnitsNetModule]
+        internal interface Module : IInclude<DistanceSpec>, IInclude<WeightSpec>;
+        """;
+
+    private const string DistanceSpec = """
+        {
+          "Name": "Distance",
+          "Namespace": "Sample",
+          "BaseUnit": "Meter",
+          "Units": [
+            {
+              "SingularName": "Meter",
+              "PluralName": "Meters",
+              "FromUnitToBaseFunc": "{x}",
+              "FromBaseToUnitFunc": "{x}"
+            }
+          ]
+        }
+        """;
+
+    private const string WeightSpec = """
+        {
+          "Name": "Weight",
+          "Namespace": "Sample",
+          "BaseUnit": "Gram",
+          "Units": [
+            {
+              "SingularName": "Gram",
+              "PluralName": "Grams",
+              "FromUnitToBaseFunc": "{x}",
+              "FromBaseToUnitFunc": "{x}"
+            }
+          ]
+        }
+        """;
+
+    [Fact]
+    public void UnchangedModule_IsCachedAcrossEquivalentCompilations()
+    {
+        const string source = """
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module : IIncludeProfile<UnitsNet.Modular.Profiles.AllQuantitiesProfile>;
+            """;
+        CSharpCompilation first = GeneratorTestHost.CreateCompilation(source);
+        GeneratorDriver driver = GeneratorTestHost.CreateDriver().RunGenerators(first);
+        CSharpCompilation second = GeneratorTestHost.CreateCompilation(source);
+        driver = driver.RunGenerators(second);
+
+        GeneratorDriverRunResult result = driver.GetRunResult();
+        IncrementalGeneratorRunStep[] moduleSteps = result.Results
+            .SelectMany(generator => generator.TrackedSteps["Modules"])
+            .ToArray();
+        IncrementalGeneratorRunStep[] generationSteps = result.Results
+            .SelectMany(generator => generator.TrackedSteps["GenerationInputs"])
+            .ToArray();
+
+        Assert.NotEmpty(moduleSteps);
+        Assert.All(
+            moduleSteps.SelectMany(step => step.Outputs),
+            output => Assert.Equal(IncrementalStepRunReason.Unchanged, output.Reason));
+        Assert.NotEmpty(generationSteps);
+        Assert.All(
+            generationSteps.SelectMany(step => step.Outputs),
+            output => Assert.Equal(IncrementalStepRunReason.Cached, output.Reason));
+    }
+
+    [Fact]
+    public void EquivalentAdditionalTextInstances_AreUnchangedByContent()
+    {
+        ImmutableArray<AdditionalText> firstFiles = GeneratorTestHost.CreateAdditionalTexts(
+            ("Distance.unitsnet.json", DistanceSpec),
+            ("Weight.unitsnet.json", WeightSpec));
+        GeneratorDriver driver = GeneratorTestHost.CreateDriver(firstFiles)
+            .RunGenerators(GeneratorTestHost.CreateCompilation(CustomModule));
+        ImmutableArray<AdditionalText> equivalentFiles = GeneratorTestHost.CreateAdditionalTexts(
+            ("Distance.unitsnet.json", DistanceSpec),
+            ("Weight.unitsnet.json", WeightSpec));
+
+        driver = driver
+            .ReplaceAdditionalTexts(equivalentFiles)
+            .RunGenerators(GeneratorTestHost.CreateCompilation(CustomModule));
+
+        Assert.All(
+            DefinitionOutputs(driver),
+            output => Assert.Equal(IncrementalStepRunReason.Unchanged, output.Reason));
+    }
+
+    [Fact]
+    public void ChangedDefinition_DoesNotInvalidateUnchangedDefinitionParsing()
+    {
+        ImmutableArray<AdditionalText> firstFiles = GeneratorTestHost.CreateAdditionalTexts(
+            ("Distance.unitsnet.json", DistanceSpec),
+            ("Weight.unitsnet.json", WeightSpec));
+        GeneratorDriver driver = GeneratorTestHost.CreateDriver(firstFiles)
+            .RunGenerators(GeneratorTestHost.CreateCompilation(CustomModule));
+        ImmutableArray<AdditionalText> changedFiles = GeneratorTestHost.CreateAdditionalTexts(
+            ("Distance.unitsnet.json", DistanceSpec.Replace("\"Meters\"", "\"Metres\"", StringComparison.Ordinal)),
+            ("Weight.unitsnet.json", WeightSpec));
+
+        driver = driver
+            .ReplaceAdditionalTexts(changedFiles)
+            .RunGenerators(GeneratorTestHost.CreateCompilation(CustomModule));
+
+        Assert.Collection(
+            DefinitionOutputs(driver),
+            output => Assert.Equal(IncrementalStepRunReason.Modified, output.Reason),
+            output => Assert.Equal(IncrementalStepRunReason.Unchanged, output.Reason));
+    }
+
+    private static (object Value, IncrementalStepRunReason Reason)[] DefinitionOutputs(GeneratorDriver driver) =>
+        driver.GetRunResult().Results
+            .SelectMany(generator => generator.TrackedSteps["Definitions"])
+            .SelectMany(step => step.Outputs)
+            .ToArray();
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/PrefixGeneratorTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/PrefixGeneratorTests.cs
new file mode 100644
index 0000000000..1f0fd58f83
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/PrefixGeneratorTests.cs
@@ -0,0 +1,49 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using Microsoft.CodeAnalysis;
+using Xunit;
+
+namespace UnitsNet.Modular.Generator.Tests;
+
+public sealed class PrefixGeneratorTests
+{
+    [Fact]
+    public void AffinePrefixedUnit_ScalesInputBeforeApplyingConversion()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [QuantitySpec("Sample.Widget")]
+            internal interface WidgetSpec;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<WidgetSpec>;
+            """,
+            ("Widget.unitsnet.json", """
+                {
+                  "Name": "Widget",
+                  "Namespace": "Sample",
+                  "BaseUnit": "Value",
+                  "Units": [
+                    {
+                      "SingularName": "Value",
+                      "PluralName": "Values",
+                      "FromUnitToBaseFunc": "{x} + 10",
+                      "FromBaseToUnitFunc": "{x} - 10",
+                      "Prefixes": [ "Kilo" ]
+                    }
+                  ]
+                }
+                """));
+
+        Assert.DoesNotContain(
+            run.Compilation.GetDiagnostics(),
+            diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        string generated = Assert.Single(
+            run.Result.GeneratedTrees,
+            tree => tree.FilePath.EndsWith("Sample_Widget.g.cs", StringComparison.Ordinal)).ToString();
+        Assert.Contains("(x * 1000) + 10", generated, StringComparison.Ordinal);
+        Assert.Contains("(x - 10) / 1000", generated, StringComparison.Ordinal);
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/QuantityFacadeGeneratorTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/QuantityFacadeGeneratorTests.cs
new file mode 100644
index 0000000000..d55ee87fac
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/QuantityFacadeGeneratorTests.cs
@@ -0,0 +1,139 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using Microsoft.CodeAnalysis;
+using Xunit;
+
+namespace UnitsNet.Modular.Generator.Tests;
+
+public sealed class QuantityFacadeGeneratorTests
+{
+    [Fact]
+    public void DefaultBuiltInModule_EmitsSourceCompatibleQuantityFacade()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            namespace Application.Units;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>;
+
+            internal static class Consumer
+            {
+                public static void Use(global::UnitsNet.UnitSystem unitSystem)
+                {
+                    var length = new global::UnitsNet.Length(1, unitSystem);
+                    _ = global::UnitsNet.Length.From(1, unitSystem);
+                    _ = length.As(unitSystem);
+                    _ = length.ToUnit(unitSystem);
+                    global::UnitsNet.QuantityInfo<global::UnitsNet.Length, global::UnitsNet.Units.LengthUnit> info =
+                        global::UnitsNet.Length.Info;
+                    global::UnitsNet.UnitInfo<global::UnitsNet.Units.LengthUnit> meter =
+                        info[global::UnitsNet.Units.LengthUnit.Meter];
+                    _ = meter.Value;
+                    _ = meter.Name;
+                    _ = info.BaseUnit.Value;
+                    _ = info.Units;
+                    _ = global::UnitsNet.Quantity.From(1, "Length", unitSystem);
+                    _ = global::UnitsNet.Quantity.TryFrom(1, "Length", unitSystem, out _);
+                }
+            }
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        string facade = GetFacade(run);
+        Assert.Contains("namespace UnitsNet", facade, StringComparison.Ordinal);
+        Assert.DoesNotContain("namespace Application.Units", facade, StringComparison.Ordinal);
+        Assert.Contains("public static partial class Quantity", facade, StringComparison.Ordinal);
+        Assert.Contains("global::UnitsNet.IQuantity<double> From(", facade, StringComparison.Ordinal);
+        Assert.Contains("global::UnitsNet.UnitSystem unitSystem", facade, StringComparison.Ordinal);
+        Assert.Contains("global::UnitsNet.QuantityRegistry Registry", facade, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void AttributedSpecOutsideBuiltInNamespace_ResolvesBuiltInBySemanticId()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            namespace Application.Units;
+
+            [QuantitySpec("UnitsNet.Length")]
+            internal interface DistanceSpec;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<DistanceSpec>;
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.Contains(
+            run.Result.Results.SelectMany(result => result.GeneratedSources),
+            source => source.HintName.EndsWith("_Length.g.cs", StringComparison.Ordinal));
+        Assert.Contains("namespace UnitsNet", GetFacade(run), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void NamespaceOverride_EmitsQuantityFacadeInRequestedNamespace()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            namespace Application.Units;
+
+            [UnitsNetModule("Application.Generated")]
+            internal interface Module : IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>;
+            """);
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        string facade = GetFacade(run);
+        Assert.Contains("namespace Application.Generated", facade, StringComparison.Ordinal);
+        Assert.DoesNotContain("namespace Application.Units", facade, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void DefaultCustomOnlyModule_EmitsQuantityFacadeInOwnerNamespace()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            namespace Application.Units;
+
+            [QuantitySpec("Fictional.Widget")]
+            internal interface WidgetSpec;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<WidgetSpec>;
+            """,
+            ("Widget.unitsnet.json", """
+                {
+                  "Name": "Widget",
+                  "Namespace": "Fictional",
+                  "BaseUnit": "Piece",
+                  "Units": [
+                    {
+                      "SingularName": "Piece",
+                      "PluralName": "Pieces",
+                      "FromUnitToBaseFunc": "{x}",
+                      "FromBaseToUnitFunc": "{x}"
+                    }
+                  ]
+                }
+                """));
+
+        Assert.DoesNotContain(run.Result.Diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        Assert.DoesNotContain(run.Compilation.GetDiagnostics(), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error);
+        string facade = GetFacade(run);
+        Assert.Contains("namespace Application.Units", facade, StringComparison.Ordinal);
+    }
+
+    private static string GetFacade(GeneratorTestHost.TestRun run) =>
+        run.Result.Results
+            .SelectMany(result => result.GeneratedSources)
+            .Single(source => source.HintName.EndsWith("_Quantity.g.cs", StringComparison.Ordinal))
+            .SourceText
+            .ToString();
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/RelationshipGeneratorTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/RelationshipGeneratorTests.cs
new file mode 100644
index 0000000000..457a811e27
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/RelationshipGeneratorTests.cs
@@ -0,0 +1,175 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using Microsoft.CodeAnalysis;
+using Xunit;
+
+namespace UnitsNet.Modular.Generator.Tests;
+
+public sealed class RelationshipGeneratorTests
+{
+    [Fact]
+    public void ReciprocalPair_GeneratesCompilableInverseMembers()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [QuantitySpec("UnitsNet.ReciprocalLength")]
+            internal interface ReciprocalLengthSpec;
+
+            [UnitsNetModule("UnitsNet.Modular")]
+            internal interface Module :
+                IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>,
+                IInclude<ReciprocalLengthSpec>;
+            """,
+            ("ReciprocalLength.unitsnet.json", """
+                {
+                  "Name": "ReciprocalLength",
+                  "Namespace": "UnitsNet",
+                  "BaseUnit": "InverseMeter",
+                  "Units": [
+                    {
+                      "SingularName": "InverseMeter",
+                      "PluralName": "InverseMeters",
+                      "FromUnitToBaseFunc": "{x}",
+                      "FromBaseToUnitFunc": "{x}",
+                      "Localization": [
+                        { "Culture": "en-US", "Abbreviations": [ "1/m" ] }
+                      ]
+                    }
+                  ]
+                }
+                """));
+
+        Diagnostic[] errors = run.Compilation.GetDiagnostics()
+            .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)
+            .ToArray();
+
+        Assert.Empty(errors);
+        Assert.Contains(
+            run.Result.GeneratedTrees,
+            tree => tree.ToString().Contains(
+                "global::UnitsNet.Modular.ReciprocalLength Inverse() => new global::UnitsNet.Modular.ReciprocalLength",
+                StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void BuiltInRelation_GeneratesMultiplicationAndInferredDivision()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module :
+                IInclude<UnitsNet.Modular.BuiltIns.MassSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.AccelerationSpec>,
+                IInclude<UnitsNet.Modular.BuiltIns.ForceSpec>;
+            """);
+
+        string generated = string.Join("\n", run.Result.GeneratedTrees.Select(tree => tree.ToString()));
+        Assert.Contains(
+            "operator *(global::UnitsNet.Mass left, global::UnitsNet.Acceleration right)",
+            generated,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "operator /(global::UnitsNet.Force left, global::UnitsNet.Acceleration right)",
+            generated,
+            StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void StructuredRelation_CrossesNamespacesAndUsesUnselectedAnchorUnits()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [QuantitySpec("Fictional.Width")]
+            internal interface WidthSpec;
+
+            [QuantitySpec("Fictional.AreaLike")]
+            internal interface AreaLikeSpec;
+
+            [UnitSet("Meter")]
+            internal interface MeterOnlyUnitSet;
+
+            [UnitSet("SquareMeter")]
+            internal interface SquareMeterOnlyUnitSet;
+
+            [UnitsNetModule]
+            internal interface Module :
+                IInclude<UnitsNet.Modular.BuiltIns.LengthSpec, MeterOnlyUnitSet>,
+                IInclude<WidthSpec, MeterOnlyUnitSet>,
+                IInclude<AreaLikeSpec, SquareMeterOnlyUnitSet>;
+            """,
+            ("Width.unitsnet.json", """
+                {
+                  "Name": "Width",
+                  "Namespace": "Fictional",
+                  "BaseUnit": "Meter",
+                  "Units": [
+                    { "SingularName": "Meter", "PluralName": "Meters", "FromUnitToBaseFunc": "{x}", "FromBaseToUnitFunc": "{x}" },
+                    { "SingularName": "Foot", "PluralName": "Feet", "FromUnitToBaseFunc": "{x} * 0.3048", "FromBaseToUnitFunc": "{x} / 0.3048" }
+                  ]
+                }
+                """),
+            ("AreaLike.unitsnet.json", """
+                {
+                  "Name": "AreaLike",
+                  "Namespace": "Fictional",
+                  "BaseUnit": "SquareMeter",
+                  "Units": [
+                    { "SingularName": "SquareMeter", "PluralName": "SquareMeters", "FromUnitToBaseFunc": "{x}", "FromBaseToUnitFunc": "{x}" },
+                    { "SingularName": "SquareFoot", "PluralName": "SquareFeet", "FromUnitToBaseFunc": "{x} * 0.09290304", "FromBaseToUnitFunc": "{x} / 0.09290304" }
+                  ]
+                }
+                """),
+            ("Fictional.unitsnet.relations.json", """
+                [
+                  {
+                    "result": { "quantity": "Fictional.AreaLike", "unit": "SquareFoot" },
+                    "left": { "quantity": "Fictional.Width", "unit": "Foot" },
+                    "operator": "*",
+                    "right": { "quantity": "UnitsNet.Length", "unit": "Foot" }
+                  }
+                ]
+                """));
+
+        Assert.Empty(run.Compilation.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error));
+        string width = Assert.Single(
+            run.Result.GeneratedTrees,
+            tree => tree.FilePath.EndsWith("Fictional_Width.g.cs", StringComparison.Ordinal)).ToString();
+        Assert.Contains(
+            "operator *(global::Fictional.Width left, global::UnitsNet.Length right)",
+            width,
+            StringComparison.Ordinal);
+        Assert.DoesNotContain("WidthUnit.Foot", width, StringComparison.Ordinal);
+        Assert.DoesNotContain("LengthUnit.Foot", width, StringComparison.Ordinal);
+        Assert.DoesNotContain("AreaLikeUnit.SquareFoot", width, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void UnknownRelationQuantity_ReportsDiagnosticInsteadOfSilentlyDroppingRelation()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<UnitsNet.Modular.BuiltIns.LengthSpec>;
+            """,
+            ("Unknown.unitsnet.relations.json", """
+                [
+                  {
+                    "result": { "quantity": "UnitsNet.Length", "unit": "Meter" },
+                    "left": { "quantity": "ThirdParty.DoesNotExist", "unit": "Value" },
+                    "operator": "*",
+                    "right": { "quantity": "UnitsNet.Length", "unit": "Meter" }
+                  }
+                ]
+                """));
+
+        Diagnostic diagnostic = Assert.Single(run.Result.Diagnostics, item => item.Id == "UNM011");
+        Assert.Contains("Quantity ID 'ThirdParty.DoesNotExist' is unknown", diagnostic.GetMessage(), StringComparison.Ordinal);
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/StableEnumGeneratorTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/StableEnumGeneratorTests.cs
new file mode 100644
index 0000000000..7bb8055793
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/StableEnumGeneratorTests.cs
@@ -0,0 +1,66 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using Xunit;
+
+namespace UnitsNet.Modular.Generator.Tests;
+
+public sealed class StableEnumGeneratorTests
+{
+    [Fact]
+    public void FilteredBuiltIn_UsesUnitsNetEnumValues()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run("""
+            using UnitsNet.Modular;
+
+            [UnitSet("Meter", "Millimeter", "Megameter")]
+            internal interface SelectedUnitSet;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<UnitsNet.Modular.BuiltIns.LengthSpec, SelectedUnitSet>;
+            """);
+
+        string generated = Assert.Single(
+            run.Result.GeneratedTrees,
+            tree => tree.FilePath.EndsWith("UnitsNet_Length.g.cs", StringComparison.Ordinal)).ToString();
+        Assert.Contains("Meter = 21", generated, StringComparison.Ordinal);
+        Assert.Contains("Millimeter = 26", generated, StringComparison.Ordinal);
+        Assert.Contains("Megameter = 41", generated, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void FilteredCustomDefinition_UsesFullDefinitionOrdinals()
+    {
+        GeneratorTestHost.TestRun run = GeneratorTestHost.Run(
+            """
+            using UnitsNet.Modular;
+
+            [QuantitySpec("Example.Widget")]
+            internal interface WidgetSpec;
+
+            [UnitSet("Base", "Third")]
+            internal interface SelectedUnitSet;
+
+            [UnitsNetModule]
+            internal interface Module : IInclude<WidgetSpec, SelectedUnitSet>;
+            """,
+            ("Widget.unitsnet.json", """
+                {
+                  "Name": "Widget",
+                  "Namespace": "Example",
+                  "BaseUnit": "Base",
+                  "Units": [
+                    { "SingularName": "Base", "PluralName": "Bases", "FromUnitToBaseFunc": "{x}", "FromBaseToUnitFunc": "{x}" },
+                    { "SingularName": "Second", "PluralName": "Seconds", "FromUnitToBaseFunc": "{x} * 2", "FromBaseToUnitFunc": "{x} / 2" },
+                    { "SingularName": "Third", "PluralName": "Thirds", "FromUnitToBaseFunc": "{x} * 3", "FromBaseToUnitFunc": "{x} / 3" }
+                  ]
+                }
+                """));
+
+        string generated = Assert.Single(
+            run.Result.GeneratedTrees,
+            tree => tree.FilePath.EndsWith("Example_Widget.g.cs", StringComparison.Ordinal)).ToString();
+        Assert.Contains("Base = 1", generated, StringComparison.Ordinal);
+        Assert.Contains("Third = 3", generated, StringComparison.Ordinal);
+        Assert.DoesNotContain("Second =", generated, StringComparison.Ordinal);
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/UnitsNet.Modular.Generator.Tests.csproj b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/UnitsNet.Modular.Generator.Tests.csproj
new file mode 100644
index 0000000000..e7fe4fc537
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator.Tests/UnitsNet.Modular.Generator.Tests.csproj
@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsTestProject>true</IsTestProject>
+    <TestFramework>xunit</TestFramework>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="../UnitsNet.Modular/UnitsNet.Modular.csproj" />
+    <ProjectReference Include="../UnitsNet.Modular.Generator/UnitsNet.Modular.Generator.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/BootstrapSource.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/BootstrapSource.cs
new file mode 100644
index 0000000000..fe8c45c98a
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/BootstrapSource.cs
@@ -0,0 +1,67 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Text;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class BootstrapSource
+{
+    private static readonly string[] AllSiQuantities =
+    {
+        "Length",
+        "Mass",
+        "Duration",
+        "Area",
+        "Speed",
+        "Acceleration",
+        "Force",
+        "Pressure",
+        "Energy",
+        "Power",
+    };
+
+    public static string Text { get; } = Create();
+
+    private static string Create()
+    {
+        var writer = new StringBuilder();
+        writer.AppendLine("// <auto-generated />");
+        writer.AppendLine("#nullable enable");
+        writer.AppendLine();
+        writer.AppendLine("namespace UnitsNet.Modular.BuiltIns");
+        writer.AppendLine("{");
+        foreach (string quantityName in BuiltInCatalog.Names)
+        {
+            writer.Append("    [global::UnitsNet.Modular.QuantitySpec(\"UnitsNet.")
+                .Append(quantityName)
+                .AppendLine("\")]");
+            writer.Append("    internal interface ").Append(quantityName).AppendLine("Spec { }");
+        }
+
+        writer.AppendLine("}");
+        writer.AppendLine();
+        writer.AppendLine("namespace UnitsNet.Modular.Profiles");
+        writer.AppendLine("{");
+        EmitProfile(writer, "AllSiProfile", AllSiQuantities);
+        writer.AppendLine();
+        EmitProfile(writer, "AllQuantitiesProfile", BuiltInCatalog.Names);
+        writer.AppendLine("}");
+        return writer.ToString();
+    }
+
+    private static void EmitProfile(StringBuilder writer, string name, IReadOnlyList<string> quantityNames)
+    {
+        writer.Append("    internal interface ").Append(name).AppendLine(" :");
+        for (var index = 0; index < quantityNames.Count; index++)
+        {
+            writer.Append("        global::UnitsNet.Modular.IInclude<global::UnitsNet.Modular.BuiltIns.")
+                .Append(quantityNames[index])
+                .Append("Spec")
+                .Append('>');
+            writer.AppendLine(index == quantityNames.Count - 1 ? string.Empty : ",");
+        }
+
+        writer.AppendLine("    {");
+        writer.AppendLine("    }");
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInAugmentationCatalog.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInAugmentationCatalog.cs
new file mode 100644
index 0000000000..c5d6bf7926
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInAugmentationCatalog.cs
@@ -0,0 +1,56 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class BuiltInAugmentationCatalog
+{
+    private const string ResourceName = "UnitsNet.Modular.Generator.BuiltIns.Augmentations.json";
+
+    private static readonly IReadOnlyDictionary<string, IReadOnlyList<QuantityAugmentationDefinition>> Augmentations =
+        LoadAugmentations();
+
+    public static IReadOnlyList<QuantityAugmentationDefinition> Get(string semanticId) =>
+        Augmentations.TryGetValue(semanticId, out IReadOnlyList<QuantityAugmentationDefinition>? augmentations)
+            ? augmentations
+            : Array.Empty<QuantityAugmentationDefinition>();
+
+    private static IReadOnlyDictionary<string, IReadOnlyList<QuantityAugmentationDefinition>> LoadAugmentations()
+    {
+        Assembly assembly = typeof(BuiltInAugmentationCatalog).Assembly;
+        using Stream stream = assembly.GetManifestResourceStream(ResourceName)
+            ?? throw new InvalidOperationException($"Missing embedded built-in augmentation catalog '{ResourceName}'.");
+        var options = new JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true,
+            Converters = { new JsonStringEnumConverter() },
+        };
+        Dictionary<string, JsonAugmentation[]> parsed =
+            JsonSerializer.Deserialize<Dictionary<string, JsonAugmentation[]>>(stream, options)
+            ?? throw new InvalidOperationException("The built-in augmentation catalog is empty.");
+        return parsed.ToDictionary(
+            pair => pair.Key,
+            pair => (IReadOnlyList<QuantityAugmentationDefinition>)pair.Value
+                .Select(augmentation => new QuantityAugmentationDefinition(
+                    augmentation.Kind,
+                    augmentation.RequiredQuantities,
+                    augmentation.RequiredUnits))
+                .ToArray(),
+            StringComparer.Ordinal);
+    }
+
+    private sealed class JsonAugmentation
+    {
+        public QuantityAugmentationKind Kind { get; set; }
+
+        public string[]? RequiredQuantities { get; set; }
+
+        public string[]? RequiredUnits { get; set; }
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInAugmentationEmitter.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInAugmentationEmitter.cs
new file mode 100644
index 0000000000..eff2e655ce
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInAugmentationEmitter.cs
@@ -0,0 +1,645 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class BuiltInAugmentationEmitter
+{
+    public static void Emit(
+        StringBuilder writer,
+        QuantitySelection selection,
+        string unitType,
+        IReadOnlyDictionary<string, QuantitySelection> selectionsBySemanticId)
+    {
+        QuantityDefinition quantity = selection.Definition;
+        foreach (QuantityAugmentationDefinition augmentation in quantity.Augmentations)
+        {
+            if (augmentation.RequiredQuantities.Any(required => !selectionsBySemanticId.ContainsKey(required)))
+            {
+                continue;
+            }
+
+            if (augmentation.RequiredUnits.Any(required =>
+                    !selection.Units.Any(unit => string.Equals(unit.SingularName, required, StringComparison.Ordinal))))
+            {
+                continue;
+            }
+
+            switch (augmentation.Kind)
+            {
+                case QuantityAugmentationKind.DurationTimeSpan:
+                    EmitDurationTimeSpan(writer, quantity, unitType);
+                    break;
+                case QuantityAugmentationKind.AreaCircle:
+                    EmitAreaCircle(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities.Single()]);
+                    break;
+                case QuantityAugmentationKind.MassFractionMass:
+                    EmitMassFractionMass(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities.Single()]);
+                    break;
+                case QuantityAugmentationKind.ForcePressureArea:
+                    EmitForcePressureArea(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]]);
+                    break;
+                case QuantityAugmentationKind.ForceMassAcceleration:
+                    EmitForceMassAcceleration(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]]);
+                    break;
+                case QuantityAugmentationKind.MassGravitationalForce:
+                    EmitMassGravitationalForce(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities.Single()]);
+                    break;
+                case QuantityAugmentationKind.AmountOfSubstanceParticles:
+                    EmitAmountOfSubstanceParticles(writer);
+                    break;
+                case QuantityAugmentationKind.AmountOfSubstanceMass:
+                    EmitAmountOfSubstanceMass(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]]);
+                    break;
+                case QuantityAugmentationKind.MassConcentrationMolarity:
+                    EmitMassConcentrationMolarity(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]]);
+                    break;
+                case QuantityAugmentationKind.MassConcentrationVolumeConcentration:
+                    EmitMassConcentrationVolumeConcentration(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]]);
+                    break;
+                case QuantityAugmentationKind.MolarityMassConcentration:
+                    EmitMolarityMassConcentration(
+                        writer,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]]);
+                    break;
+                case QuantityAugmentationKind.MolarityVolumeConcentration:
+                    EmitMolarityVolumeConcentration(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[2]]);
+                    break;
+                case QuantityAugmentationKind.VolumeConcentrationMassConcentration:
+                    EmitVolumeConcentrationMassConcentration(
+                        writer,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]]);
+                    break;
+                case QuantityAugmentationKind.VolumeConcentrationMolarity:
+                    EmitVolumeConcentrationMolarity(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[2]]);
+                    break;
+                case QuantityAugmentationKind.VolumeConcentrationVolumes:
+                    EmitVolumeConcentrationVolumes(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities.Single()]);
+                    break;
+                case QuantityAugmentationKind.ElectricApparentPowerDivision:
+                    EmitElectricApparentPowerDivision(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]]);
+                    break;
+                case QuantityAugmentationKind.EnergyDensityCombustionEnergy:
+                    EmitEnergyDensityCombustionEnergy(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[2]]);
+                    break;
+                case QuantityAugmentationKind.AmplitudeRatioElectricPotential:
+                    EmitAmplitudeRatioElectricPotential(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities.Single()]);
+                    break;
+                case QuantityAugmentationKind.AmplitudeRatioPowerRatio:
+                    EmitAmplitudeRatioPowerRatio(
+                        writer,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]]);
+                    break;
+                case QuantityAugmentationKind.ElectricPotentialAmplitudeRatio:
+                    EmitElectricPotentialAmplitudeRatio(
+                        writer,
+                        selectionsBySemanticId[augmentation.RequiredQuantities.Single()]);
+                    break;
+                case QuantityAugmentationKind.LevelRatio:
+                    EmitLevelRatio(writer, quantity);
+                    break;
+                case QuantityAugmentationKind.PowerPowerRatio:
+                    EmitPowerPowerRatio(
+                        writer,
+                        selectionsBySemanticId[augmentation.RequiredQuantities.Single()]);
+                    break;
+                case QuantityAugmentationKind.PowerRatioPower:
+                    EmitPowerRatioPower(
+                        writer,
+                        quantity,
+                        selectionsBySemanticId[augmentation.RequiredQuantities.Single()]);
+                    break;
+                case QuantityAugmentationKind.PowerRatioAmplitudeRatio:
+                    EmitPowerRatioAmplitudeRatio(
+                        writer,
+                        selectionsBySemanticId[augmentation.RequiredQuantities[0]],
+                        selectionsBySemanticId[augmentation.RequiredQuantities[1]]);
+                    break;
+                case QuantityAugmentationKind.LengthFeetInches:
+                    EmitLengthFeetInches(writer, quantity);
+                    break;
+                case QuantityAugmentationKind.MassStonePounds:
+                    EmitMassStonePounds(writer, quantity);
+                    break;
+                default:
+                    throw new InvalidOperationException($"Unsupported quantity augmentation '{augmentation.Kind}'.");
+            }
+        }
+    }
+
+    private static void EmitDurationTimeSpan(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        string unitType)
+    {
+        string quantityType = quantity.Name;
+        writer.AppendLine();
+        writer.AppendLine("    public global::System.TimeSpan ToTimeSpan()");
+        writer.AppendLine("    {");
+        writer.Append("        double seconds = As(").Append(unitType).AppendLine(".Second);");
+        writer.AppendLine("        if (seconds > global::System.TimeSpan.MaxValue.TotalSeconds)");
+        writer.AppendLine("            throw new global::System.ArgumentOutOfRangeException(nameof(seconds), \"The duration is too large for a TimeSpan.\");");
+        writer.AppendLine("        if (seconds < global::System.TimeSpan.MinValue.TotalSeconds)");
+        writer.AppendLine("            throw new global::System.ArgumentOutOfRangeException(nameof(seconds), \"The duration is too small for a TimeSpan.\");");
+        writer.AppendLine("        return global::System.TimeSpan.FromTicks((long)(seconds * global::System.TimeSpan.TicksPerSecond));");
+        writer.AppendLine("    }");
+        writer.Append("    public static global::System.DateTime operator +(global::System.DateTime time, ")
+            .Append(quantityType).AppendLine(" duration) => time.AddSeconds(duration.As(" + unitType + ".Second));");
+        writer.Append("    public static global::System.DateTime operator -(global::System.DateTime time, ")
+            .Append(quantityType).AppendLine(" duration) => time.AddSeconds(-duration.As(" + unitType + ".Second));");
+        writer.Append("    public static implicit operator global::System.TimeSpan(").Append(quantityType)
+            .AppendLine(" duration) => duration.ToTimeSpan();");
+        writer.Append("    public static implicit operator ").Append(quantityType)
+            .AppendLine("(global::System.TimeSpan duration) => FromSeconds(duration.TotalSeconds);");
+        foreach (string comparison in new[] { "<", ">", "<=", ">=" })
+        {
+            writer.Append("    public static bool operator ").Append(comparison).Append('(').Append(quantityType)
+                .Append(" duration, global::System.TimeSpan timeSpan) => duration.As(").Append(unitType)
+                .Append(".Second) ").Append(comparison).AppendLine(" timeSpan.TotalSeconds;");
+            writer.Append("    public static bool operator ").Append(comparison)
+                .Append("(global::System.TimeSpan timeSpan, ").Append(quantityType)
+                .Append(" duration) => timeSpan.TotalSeconds ").Append(comparison)
+                .Append(" duration.As(").Append(unitType).AppendLine(".Second);");
+        }
+    }
+
+    private static void EmitAreaCircle(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection length)
+    {
+        string lengthType = QuantityType(length.Definition);
+        writer.AppendLine();
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromCircleDiameter(")
+            .Append(lengthType).AppendLine(" diameter) =>");
+        writer.Append("        FromCircleRadius(").Append(lengthType)
+            .AppendLine(".FromMeters(diameter.Meters / 2d));");
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromCircleRadius(")
+            .Append(lengthType).AppendLine(" radius) =>");
+        writer.AppendLine("        FromSquareMeters(global::System.Math.PI * radius.Meters * radius.Meters);");
+    }
+
+    private static void EmitMassFractionMass(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection mass)
+    {
+        string massType = QuantityType(mass.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(massType).Append(" GetComponentMass(").Append(massType)
+            .AppendLine(" totalMass) =>");
+        writer.Append("        ").Append(massType)
+            .AppendLine(".From(totalMass.Value * DecimalFractions, totalMass.Unit);");
+        writer.Append("    public ").Append(massType).Append(" GetTotalMass(").Append(massType)
+            .AppendLine(" componentMass) =>");
+        writer.Append("        ").Append(massType)
+            .AppendLine(".From(componentMass.Value / DecimalFractions, componentMass.Unit);");
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromMasses(").Append(massType)
+            .Append(" componentMass, ").Append(massType).AppendLine(" mixtureMass) =>");
+        writer.AppendLine("        FromDecimalFractions(componentMass.Value / mixtureMass.As(componentMass.Unit));");
+    }
+
+    private static void EmitForcePressureArea(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection pressure,
+        QuantitySelection area)
+    {
+        writer.AppendLine();
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromPressureByArea(")
+            .Append(QuantityType(pressure.Definition)).Append(" pressure, ")
+            .Append(QuantityType(area.Definition)).AppendLine(" area) =>");
+        writer.AppendLine("        FromNewtons(pressure.Pascals * area.SquareMeters);");
+    }
+
+    private static void EmitForceMassAcceleration(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection mass,
+        QuantitySelection acceleration)
+    {
+        writer.AppendLine();
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromMassByAcceleration(")
+            .Append(QuantityType(mass.Definition)).Append(" mass, ")
+            .Append(QuantityType(acceleration.Definition)).AppendLine(" acceleration) =>");
+        writer.AppendLine("        FromNewtons(mass.Kilograms * acceleration.MetersPerSecondSquared);");
+    }
+
+    private static void EmitMassGravitationalForce(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection force)
+    {
+        writer.AppendLine();
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromGravitationalForce(")
+            .Append(QuantityType(force.Definition)).AppendLine(" force) =>");
+        writer.AppendLine("        FromKilograms(force.Newtons / 9.80665);");
+    }
+
+    private static void EmitAmountOfSubstanceParticles(StringBuilder writer)
+    {
+        writer.AppendLine();
+        writer.AppendLine("    public static double AvogadroConstant { get; } = 6.02214076e23;");
+        writer.AppendLine("    public double NumberOfParticles() => AvogadroConstant * As(BaseUnit);");
+    }
+
+    private static void EmitAmountOfSubstanceMass(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection mass,
+        QuantitySelection molarMass)
+    {
+        string massType = QuantityType(mass.Definition);
+        string molarMassType = QuantityType(molarMass.Definition);
+        writer.AppendLine();
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromMass(")
+            .Append(massType).Append(" mass, ").Append(molarMassType).AppendLine(" molarMass) =>");
+        writer.Append("        From(mass.As(").Append(massType).Append(".BaseUnit) / molarMass.As(")
+            .Append(molarMassType).AppendLine(".BaseUnit), BaseUnit);");
+    }
+
+    private static void EmitMassConcentrationMolarity(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection molarity,
+        QuantitySelection molarMass)
+    {
+        string molarityType = QuantityType(molarity.Definition);
+        string molarMassType = QuantityType(molarMass.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(molarityType).Append(" ToMolarity(").Append(molarMassType)
+            .AppendLine(" molecularWeight) =>");
+        writer.Append("        ").Append(molarityType).Append(".From(As(BaseUnit) / molecularWeight.As(")
+            .Append(molarMassType).Append(".BaseUnit), ").Append(molarityType).AppendLine(".BaseUnit);");
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromMolarity(")
+            .Append(molarityType).Append(" molarity, ").Append(molarMassType).AppendLine(" mass) =>");
+        writer.Append("        From(molarity.As(").Append(molarityType).Append(".BaseUnit) * mass.As(")
+            .Append(molarMassType).AppendLine(".BaseUnit), BaseUnit);");
+    }
+
+    private static void EmitMassConcentrationVolumeConcentration(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection volumeConcentration,
+        QuantitySelection density)
+    {
+        string volumeConcentrationType = QuantityType(volumeConcentration.Definition);
+        string densityType = QuantityType(density.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(volumeConcentrationType).Append(" ToVolumeConcentration(")
+            .Append(densityType).AppendLine(" componentDensity) =>");
+        writer.Append("        ").Append(volumeConcentrationType)
+            .Append(".From(As(BaseUnit) / componentDensity.As(").Append(densityType).Append(".BaseUnit), ")
+            .Append(volumeConcentrationType).AppendLine(".BaseUnit);");
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromVolumeConcentration(")
+            .Append(volumeConcentrationType).Append(" volumeConcentration, ").Append(densityType)
+            .AppendLine(" componentDensity) =>");
+        writer.Append("        From(volumeConcentration.As(").Append(volumeConcentrationType)
+            .Append(".BaseUnit) * componentDensity.As(").Append(densityType).AppendLine(".BaseUnit), BaseUnit);");
+    }
+
+    private static void EmitMolarityMassConcentration(
+        StringBuilder writer,
+        QuantitySelection massConcentration,
+        QuantitySelection molarMass)
+    {
+        string massConcentrationType = QuantityType(massConcentration.Definition);
+        string molarMassType = QuantityType(molarMass.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(massConcentrationType).Append(" ToMassConcentration(")
+            .Append(molarMassType).AppendLine(" molecularWeight) =>");
+        writer.Append("        ").Append(massConcentrationType).Append(".From(As(BaseUnit) * molecularWeight.As(")
+            .Append(molarMassType).Append(".BaseUnit), ").Append(massConcentrationType).AppendLine(".BaseUnit);");
+    }
+
+    private static void EmitMolarityVolumeConcentration(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection volumeConcentration,
+        QuantitySelection density,
+        QuantitySelection molarMass)
+    {
+        string volumeConcentrationType = QuantityType(volumeConcentration.Definition);
+        string densityType = QuantityType(density.Definition);
+        string molarMassType = QuantityType(molarMass.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(volumeConcentrationType).Append(" ToVolumeConcentration(")
+            .Append(densityType).Append(" componentDensity, ").Append(molarMassType)
+            .AppendLine(" componentMass) =>");
+        writer.Append("        ").Append(volumeConcentrationType).Append(".From(As(BaseUnit) * componentMass.As(")
+            .Append(molarMassType).Append(".BaseUnit) / componentDensity.As(").Append(densityType)
+            .Append(".BaseUnit), ").Append(volumeConcentrationType).AppendLine(".BaseUnit);");
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromVolumeConcentration(")
+            .Append(volumeConcentrationType).Append(" volumeConcentration, ").Append(densityType)
+            .Append(" componentDensity, ").Append(molarMassType).AppendLine(" componentMass) =>");
+        writer.Append("        From(volumeConcentration.As(").Append(volumeConcentrationType)
+            .Append(".BaseUnit) * componentDensity.As(").Append(densityType)
+            .Append(".BaseUnit) / componentMass.As(").Append(molarMassType).AppendLine(".BaseUnit), BaseUnit);");
+    }
+
+    private static void EmitVolumeConcentrationMassConcentration(
+        StringBuilder writer,
+        QuantitySelection massConcentration,
+        QuantitySelection density)
+    {
+        string massConcentrationType = QuantityType(massConcentration.Definition);
+        string densityType = QuantityType(density.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(massConcentrationType).Append(" ToMassConcentration(")
+            .Append(densityType).AppendLine(" componentDensity) =>");
+        writer.Append("        ").Append(massConcentrationType).Append(".From(As(BaseUnit) * componentDensity.As(")
+            .Append(densityType).Append(".BaseUnit), ").Append(massConcentrationType).AppendLine(".BaseUnit);");
+    }
+
+    private static void EmitVolumeConcentrationMolarity(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection molarity,
+        QuantitySelection density,
+        QuantitySelection molarMass)
+    {
+        string molarityType = QuantityType(molarity.Definition);
+        string densityType = QuantityType(density.Definition);
+        string molarMassType = QuantityType(molarMass.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(molarityType).Append(" ToMolarity(").Append(densityType)
+            .Append(" componentDensity, ").Append(molarMassType).AppendLine(" compontMolarMass) =>");
+        writer.Append("        ").Append(molarityType).Append(".From(As(BaseUnit) * componentDensity.As(")
+            .Append(densityType).Append(".BaseUnit) / compontMolarMass.As(").Append(molarMassType)
+            .Append(".BaseUnit), ").Append(molarityType).AppendLine(".BaseUnit);");
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromMolarity(")
+            .Append(molarityType).Append(" molarity, ").Append(densityType).Append(" componentDensity, ")
+            .Append(molarMassType).AppendLine(" componentMolarMass) =>");
+        writer.Append("        From(molarity.As(").Append(molarityType).Append(".BaseUnit) * componentMolarMass.As(")
+            .Append(molarMassType).Append(".BaseUnit) / componentDensity.As(").Append(densityType)
+            .AppendLine(".BaseUnit), BaseUnit);");
+    }
+
+    private static void EmitVolumeConcentrationVolumes(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection volume)
+    {
+        string volumeType = QuantityType(volume.Definition);
+        writer.AppendLine();
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromVolumes(").Append(volumeType)
+            .Append(" componentVolume, ").Append(volumeType).AppendLine(" mixtureMass) =>");
+        writer.AppendLine("        From(componentVolume.Value / mixtureMass.As(componentVolume.Unit), BaseUnit);");
+    }
+
+    private static void EmitElectricApparentPowerDivision(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection electricPotential,
+        QuantitySelection electricCurrent)
+    {
+        string potentialType = QuantityType(electricPotential.Definition);
+        string currentType = QuantityType(electricCurrent.Definition);
+        writer.AppendLine();
+        writer.Append("    public static ").Append(currentType).Append(" operator /(").Append(quantity.Name)
+            .Append(" power, ").Append(potentialType).AppendLine(" potential) =>");
+        writer.Append("        ").Append(currentType).Append(".From(power.As(BaseUnit) / potential.As(")
+            .Append(potentialType).Append(".BaseUnit), ").Append(currentType).AppendLine(".BaseUnit);");
+        writer.Append("    public static ").Append(potentialType).Append(" operator /(").Append(quantity.Name)
+            .Append(" power, ").Append(currentType).AppendLine(" current) =>");
+        writer.Append("        ").Append(potentialType).Append(".From(power.As(BaseUnit) / current.As(")
+            .Append(currentType).Append(".BaseUnit), ").Append(potentialType).AppendLine(".BaseUnit);");
+    }
+
+    private static void EmitEnergyDensityCombustionEnergy(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection energy,
+        QuantitySelection volume,
+        QuantitySelection ratio)
+    {
+        string energyType = QuantityType(energy.Definition);
+        string volumeType = QuantityType(volume.Definition);
+        string ratioType = QuantityType(ratio.Definition);
+        writer.AppendLine();
+        writer.Append("    public static ").Append(energyType).Append(" CombustionEnergy(")
+            .Append(quantity.Name).Append(" energyDensity, ").Append(volumeType).Append(" volume, ")
+            .Append(ratioType).AppendLine(" conversionFactor) =>");
+        writer.Append("        ").Append(energyType).Append(".From(energyDensity.As(BaseUnit) * volume.As(")
+            .Append(volumeType).Append(".BaseUnit) * conversionFactor.As(").Append(ratioType)
+            .Append(".BaseUnit), ").Append(energyType).AppendLine(".BaseUnit);");
+    }
+
+    private static void EmitAmplitudeRatioElectricPotential(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection electricPotential)
+    {
+        string electricPotentialType = QuantityType(electricPotential.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(quantity.Name).Append('(').Append(electricPotentialType)
+            .AppendLine(" voltage)");
+        writer.AppendLine("    {");
+        writer.Append("        double volts = voltage.As(").Append(electricPotentialType).AppendLine(".BaseUnit);");
+        writer.AppendLine("        if (volts <= 0)");
+        writer.AppendLine("            throw new global::System.ArgumentOutOfRangeException(nameof(voltage), \"The base-10 logarithm of a number ≤ 0 is undefined. Voltage must be greater than 0 V.\");");
+        writer.AppendLine("        _value = 20 * global::System.Math.Log10(volts);");
+        writer.AppendLine("        _unit = BaseUnit;");
+        writer.AppendLine("    }");
+        writer.Append("    public ").Append(electricPotentialType).AppendLine(" ToElectricPotential() =>");
+        writer.Append("        ").Append(electricPotentialType)
+            .AppendLine(".From(global::System.Math.Pow(10, As(BaseUnit) / 20), " + electricPotentialType + ".BaseUnit);");
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromElectricPotential(")
+            .Append(electricPotentialType).AppendLine(" voltage) => new(voltage);");
+    }
+
+    private static void EmitAmplitudeRatioPowerRatio(
+        StringBuilder writer,
+        QuantitySelection powerRatio,
+        QuantitySelection electricResistance)
+    {
+        string powerRatioType = QuantityType(powerRatio.Definition);
+        string resistanceType = QuantityType(electricResistance.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(powerRatioType).Append(" ToPowerRatio(").Append(resistanceType)
+            .AppendLine(" impedance) =>");
+        writer.Append("        ").Append(powerRatioType).Append(".From(As(BaseUnit) - 10 * global::System.Math.Log10(impedance.As(")
+            .Append(resistanceType).Append(".BaseUnit)), ").Append(powerRatioType).AppendLine(".BaseUnit);");
+    }
+
+    private static void EmitElectricPotentialAmplitudeRatio(
+        StringBuilder writer,
+        QuantitySelection amplitudeRatio)
+    {
+        string amplitudeRatioType = QuantityType(amplitudeRatio.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(amplitudeRatioType).AppendLine(" ToAmplitudeRatio() =>");
+        writer.Append("        ").Append(amplitudeRatioType).AppendLine(".FromElectricPotential(this);");
+    }
+
+    private static void EmitLevelRatio(StringBuilder writer, QuantityDefinition quantity)
+    {
+        writer.AppendLine();
+        writer.Append("    public ").Append(quantity.Name).AppendLine("(double quantity, double reference)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        string errorMessage = $\"The base-10 logarithm of a number ≤ 0 is undefined ({quantity}/{reference}).\";");
+        writer.AppendLine("        if (quantity == 0 || quantity < 0 && reference > 0)");
+        writer.AppendLine("            throw new global::System.ArgumentOutOfRangeException(nameof(quantity), errorMessage);");
+        writer.AppendLine("        if (reference == 0 || quantity > 0 && reference < 0)");
+        writer.AppendLine("            throw new global::System.ArgumentOutOfRangeException(nameof(reference), errorMessage);");
+        writer.AppendLine("        _value = 10 * global::System.Math.Log10(quantity / reference);");
+        writer.AppendLine("        _unit = BaseUnit;");
+        writer.AppendLine("    }");
+    }
+
+    private static void EmitPowerPowerRatio(
+        StringBuilder writer,
+        QuantitySelection powerRatio)
+    {
+        string powerRatioType = QuantityType(powerRatio.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(powerRatioType).AppendLine(" ToPowerRatio() =>");
+        writer.Append("        ").Append(powerRatioType).AppendLine(".FromPower(this);");
+    }
+
+    private static void EmitPowerRatioPower(
+        StringBuilder writer,
+        QuantityDefinition quantity,
+        QuantitySelection power)
+    {
+        string powerType = QuantityType(power.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(quantity.Name).Append('(').Append(powerType).AppendLine(" power)");
+        writer.AppendLine("    {");
+        writer.Append("        double watts = power.As(").Append(powerType).AppendLine(".BaseUnit);");
+        writer.AppendLine("        if (watts <= 0)");
+        writer.AppendLine("            throw new global::System.ArgumentOutOfRangeException(nameof(power), \"The base-10 logarithm of a number ≤ 0 is undefined. Power must be greater than 0 W.\");");
+        writer.AppendLine("        _value = 10 * global::System.Math.Log10(watts);");
+        writer.AppendLine("        _unit = BaseUnit;");
+        writer.AppendLine("    }");
+        writer.Append("    public ").Append(powerType).AppendLine(" ToPower() =>");
+        writer.Append("        ").Append(powerType)
+            .AppendLine(".From(global::System.Math.Pow(10, As(BaseUnit) / 10), " + powerType + ".BaseUnit);");
+        writer.Append("    public static ").Append(quantity.Name).Append(" FromPower(").Append(powerType)
+            .AppendLine(" power) => new(power);");
+    }
+
+    private static void EmitPowerRatioAmplitudeRatio(
+        StringBuilder writer,
+        QuantitySelection amplitudeRatio,
+        QuantitySelection electricResistance)
+    {
+        string amplitudeRatioType = QuantityType(amplitudeRatio.Definition);
+        string resistanceType = QuantityType(electricResistance.Definition);
+        writer.AppendLine();
+        writer.Append("    public ").Append(amplitudeRatioType).Append(" ToAmplitudeRatio(")
+            .Append(resistanceType).AppendLine(" impedance) =>");
+        writer.Append("        ").Append(amplitudeRatioType).Append(".From(10 * global::System.Math.Log10(impedance.As(")
+            .Append(resistanceType).Append(".BaseUnit)) + As(BaseUnit), ")
+            .Append(amplitudeRatioType).AppendLine(".BaseUnit);");
+    }
+
+    private static void EmitLengthFeetInches(StringBuilder writer, QuantityDefinition quantity)
+    {
+        string companionType = "global::" + quantity.TargetNamespace + ".FeetInches";
+        string unitType = UnitType(quantity);
+        writer.AppendLine();
+        writer.Append("    public ").Append(companionType).AppendLine(" FeetInches");
+        writer.AppendLine("    {");
+        writer.AppendLine("        get");
+        writer.AppendLine("        {");
+        writer.Append("            double totalInches = As(").Append(unitType).AppendLine(".Inch);");
+        writer.AppendLine("            double feet = global::System.Math.Truncate(totalInches / 12);");
+        writer.AppendLine("            double inches = totalInches % 12;");
+        writer.Append("            return new ").Append(companionType).AppendLine("(feet, inches);");
+        writer.AppendLine("        }");
+        writer.AppendLine("    }");
+        writer.Append("    public static ").Append(quantity.Name)
+            .AppendLine(" FromFeetInches(double feet, double inches) =>");
+        writer.AppendLine("        From(feet * 0.3048 + inches * 0.0254, BaseUnit);");
+    }
+
+    private static void EmitMassStonePounds(StringBuilder writer, QuantityDefinition quantity)
+    {
+        string companionType = "global::" + quantity.TargetNamespace + ".StonePounds";
+        string unitType = UnitType(quantity);
+        writer.AppendLine();
+        writer.Append("    public ").Append(companionType).AppendLine(" StonePounds");
+        writer.AppendLine("    {");
+        writer.AppendLine("        get");
+        writer.AppendLine("        {");
+        writer.Append("            double totalPounds = As(").Append(unitType).AppendLine(".Pound);");
+        writer.AppendLine("            double stone = global::System.Math.Truncate(totalPounds / 14);");
+        writer.AppendLine("            double pounds = totalPounds % 14;");
+        writer.Append("            return new ").Append(companionType).AppendLine("(stone, pounds);");
+        writer.AppendLine("        }");
+        writer.AppendLine("    }");
+        writer.Append("    public static ").Append(quantity.Name)
+            .AppendLine(" FromStonePounds(double stone, double pounds) =>");
+        writer.AppendLine("        From((stone * 14 + pounds) * 0.45359237, BaseUnit);");
+    }
+
+    private static string QuantityType(QuantityDefinition definition) =>
+        "global::" + definition.TargetNamespace + "." + definition.Name;
+
+    private static string UnitType(QuantityDefinition definition) =>
+        definition.TargetNamespace == "UnitsNet"
+            ? "global::UnitsNet.Units." + definition.Name + "Unit"
+            : "global::" + definition.TargetNamespace + "." + definition.Name + "Unit";
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInAugmentations.json b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInAugmentations.json
new file mode 100644
index 0000000000..cdc0e106b3
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInAugmentations.json
@@ -0,0 +1,137 @@
+{
+  "UnitsNet.AmplitudeRatio": [
+    {
+      "Kind": "AmplitudeRatioElectricPotential",
+      "RequiredQuantities": [ "UnitsNet.ElectricPotential" ]
+    },
+    {
+      "Kind": "AmplitudeRatioPowerRatio",
+      "RequiredQuantities": [ "UnitsNet.PowerRatio", "UnitsNet.ElectricResistance" ]
+    }
+  ],
+  "UnitsNet.AmountOfSubstance": [
+    {
+      "Kind": "AmountOfSubstanceParticles"
+    },
+    {
+      "Kind": "AmountOfSubstanceMass",
+      "RequiredQuantities": [ "UnitsNet.Mass", "UnitsNet.MolarMass" ]
+    }
+  ],
+  "UnitsNet.Area": [
+    {
+      "Kind": "AreaCircle",
+      "RequiredQuantities": [ "UnitsNet.Length" ]
+    }
+  ],
+  "UnitsNet.Duration": [
+    {
+      "Kind": "DurationTimeSpan"
+    }
+  ],
+  "UnitsNet.ElectricApparentPower": [
+    {
+      "Kind": "ElectricApparentPowerDivision",
+      "RequiredQuantities": [ "UnitsNet.ElectricPotential", "UnitsNet.ElectricCurrent" ]
+    }
+  ],
+  "UnitsNet.ElectricPotential": [
+    {
+      "Kind": "ElectricPotentialAmplitudeRatio",
+      "RequiredQuantities": [ "UnitsNet.AmplitudeRatio" ]
+    }
+  ],
+  "UnitsNet.EnergyDensity": [
+    {
+      "Kind": "EnergyDensityCombustionEnergy",
+      "RequiredQuantities": [ "UnitsNet.Energy", "UnitsNet.Volume", "UnitsNet.Ratio" ]
+    }
+  ],
+  "UnitsNet.Force": [
+    {
+      "Kind": "ForcePressureArea",
+      "RequiredQuantities": [ "UnitsNet.Pressure", "UnitsNet.Area" ]
+    },
+    {
+      "Kind": "ForceMassAcceleration",
+      "RequiredQuantities": [ "UnitsNet.Mass", "UnitsNet.Acceleration" ]
+    }
+  ],
+  "UnitsNet.Level": [
+    {
+      "Kind": "LevelRatio"
+    }
+  ],
+  "UnitsNet.Length": [
+    {
+      "Kind": "LengthFeetInches",
+      "RequiredUnits": [ "Foot", "Inch" ]
+    }
+  ],
+  "UnitsNet.Mass": [
+    {
+      "Kind": "MassGravitationalForce",
+      "RequiredQuantities": [ "UnitsNet.Force" ]
+    },
+    {
+      "Kind": "MassStonePounds",
+      "RequiredUnits": [ "Stone", "Pound" ]
+    }
+  ],
+  "UnitsNet.MassFraction": [
+    {
+      "Kind": "MassFractionMass",
+      "RequiredQuantities": [ "UnitsNet.Mass" ]
+    }
+  ],
+  "UnitsNet.MassConcentration": [
+    {
+      "Kind": "MassConcentrationMolarity",
+      "RequiredQuantities": [ "UnitsNet.Molarity", "UnitsNet.MolarMass" ]
+    },
+    {
+      "Kind": "MassConcentrationVolumeConcentration",
+      "RequiredQuantities": [ "UnitsNet.VolumeConcentration", "UnitsNet.Density" ]
+    }
+  ],
+  "UnitsNet.Molarity": [
+    {
+      "Kind": "MolarityMassConcentration",
+      "RequiredQuantities": [ "UnitsNet.MassConcentration", "UnitsNet.MolarMass" ]
+    },
+    {
+      "Kind": "MolarityVolumeConcentration",
+      "RequiredQuantities": [ "UnitsNet.VolumeConcentration", "UnitsNet.Density", "UnitsNet.MolarMass" ]
+    }
+  ],
+  "UnitsNet.Power": [
+    {
+      "Kind": "PowerPowerRatio",
+      "RequiredQuantities": [ "UnitsNet.PowerRatio" ]
+    }
+  ],
+  "UnitsNet.PowerRatio": [
+    {
+      "Kind": "PowerRatioPower",
+      "RequiredQuantities": [ "UnitsNet.Power" ]
+    },
+    {
+      "Kind": "PowerRatioAmplitudeRatio",
+      "RequiredQuantities": [ "UnitsNet.AmplitudeRatio", "UnitsNet.ElectricResistance" ]
+    }
+  ],
+  "UnitsNet.VolumeConcentration": [
+    {
+      "Kind": "VolumeConcentrationMassConcentration",
+      "RequiredQuantities": [ "UnitsNet.MassConcentration", "UnitsNet.Density" ]
+    },
+    {
+      "Kind": "VolumeConcentrationMolarity",
+      "RequiredQuantities": [ "UnitsNet.Molarity", "UnitsNet.Density", "UnitsNet.MolarMass" ]
+    },
+    {
+      "Kind": "VolumeConcentrationVolumes",
+      "RequiredQuantities": [ "UnitsNet.Volume" ]
+    }
+  ]
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCatalog.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCatalog.cs
new file mode 100644
index 0000000000..aeb543e266
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCatalog.cs
@@ -0,0 +1,72 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class BuiltInCatalog
+{
+    private const string ResourcePrefix = "UnitsNet.Modular.Generator.BuiltIns.Quantities.";
+    private const string ResourceSuffix = ".json";
+
+    private static readonly IReadOnlyDictionary<string, QuantityDefinition> ParsedDefinitions = LoadDefinitions();
+    internal static readonly PrefixExpander.BaseUnitPrefixCatalog BaseUnitPrefixes =
+        PrefixExpander.BaseUnitPrefixCatalog.Create(ParsedDefinitions.Values);
+    private static readonly IReadOnlyDictionary<string, QuantityDefinition> Definitions =
+        ParsedDefinitions.ToDictionary(
+            pair => pair.Key,
+            pair => PrefixExpander.Expand(pair.Value, BaseUnitPrefixes),
+            StringComparer.Ordinal);
+    private static readonly IReadOnlyDictionary<string, QuantityDefinition> DefinitionsBySemanticId =
+        Definitions.Values.ToDictionary(
+            definition => definition.SemanticId,
+            StringComparer.Ordinal);
+
+    public static IReadOnlyList<string> Names { get; } =
+        Definitions.Keys.OrderBy(name => name, StringComparer.Ordinal).ToArray();
+
+    public static bool TryGetByName(string name, out QuantityDefinition definition)
+        => Definitions.TryGetValue(name, out definition!);
+
+    public static bool TryGetBySemanticId(string semanticId, out QuantityDefinition definition)
+        => DefinitionsBySemanticId.TryGetValue(semanticId, out definition!);
+
+    public static PrefixExpander.BaseUnitPrefixCatalog CreateBaseUnitPrefixes(
+        IEnumerable<QuantityDefinition> additionalDefinitions) =>
+        PrefixExpander.BaseUnitPrefixCatalog.Create(
+            ParsedDefinitions.Values.Concat(additionalDefinitions));
+
+    private static IReadOnlyDictionary<string, QuantityDefinition> LoadDefinitions()
+    {
+        var definitions = new Dictionary<string, QuantityDefinition>(StringComparer.Ordinal);
+        Assembly assembly = typeof(BuiltInCatalog).Assembly;
+        string[] resourceNames = assembly.GetManifestResourceNames()
+            .Where(name => name.StartsWith(ResourcePrefix, StringComparison.Ordinal) &&
+                           name.EndsWith(ResourceSuffix, StringComparison.Ordinal))
+            .OrderBy(name => name, StringComparer.Ordinal)
+            .ToArray();
+        foreach (string resourceName in resourceNames)
+        {
+            using Stream stream = assembly.GetManifestResourceStream(resourceName)
+                ?? throw new InvalidOperationException($"Missing embedded built-in definition '{resourceName}'.");
+            using var reader = new StreamReader(stream);
+            JsonDefinitionResult result = JsonDefinitionParser.Parse(reader.ReadToEnd(), resourceName);
+            if (result.Error is not null)
+            {
+                throw new InvalidOperationException(
+                    $"Embedded built-in definition '{resourceName}' is invalid: {result.Error}");
+            }
+
+            string semanticId = "UnitsNet." + result.Definition!.Name;
+            QuantityDefinition definition = result.Definition
+                .WithSemanticId(semanticId)
+                .WithAugmentations(BuiltInAugmentationCatalog.Get(semanticId));
+            definitions.Add(definition.Name, definition);
+        }
+
+        return definitions;
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCompanionCatalog.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCompanionCatalog.cs
new file mode 100644
index 0000000000..dd7816ffc9
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCompanionCatalog.cs
@@ -0,0 +1,56 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class BuiltInCompanionCatalog
+{
+    private const string ResourceName = "UnitsNet.Modular.Generator.BuiltIns.Companions.json";
+
+    private static readonly IReadOnlyDictionary<string, IReadOnlyList<CompanionTypeDefinition>> Companions =
+        LoadCompanions();
+
+    public static IReadOnlyList<CompanionTypeDefinition> Get(string semanticId) =>
+        Companions.TryGetValue(semanticId, out IReadOnlyList<CompanionTypeDefinition>? companions)
+            ? companions
+            : Array.Empty<CompanionTypeDefinition>();
+
+    private static IReadOnlyDictionary<string, IReadOnlyList<CompanionTypeDefinition>> LoadCompanions()
+    {
+        Assembly assembly = typeof(BuiltInCompanionCatalog).Assembly;
+        using Stream stream = assembly.GetManifestResourceStream(ResourceName)
+            ?? throw new InvalidOperationException($"Missing embedded built-in companion catalog '{ResourceName}'.");
+        var options = new JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true,
+            Converters = { new JsonStringEnumConverter() },
+        };
+        Dictionary<string, JsonCompanion[]> parsed =
+            JsonSerializer.Deserialize<Dictionary<string, JsonCompanion[]>>(stream, options)
+            ?? throw new InvalidOperationException("The built-in companion catalog is empty.");
+        return parsed.ToDictionary(
+            pair => pair.Key,
+            pair => (IReadOnlyList<CompanionTypeDefinition>)pair.Value
+                .Select(companion => new CompanionTypeDefinition(
+                    companion.Kind,
+                    companion.RequiredQuantities,
+                    companion.RequiredUnits))
+                .ToArray(),
+            StringComparer.Ordinal);
+    }
+
+    private sealed class JsonCompanion
+    {
+        public CompanionTypeKind Kind { get; set; }
+
+        public string[]? RequiredQuantities { get; set; }
+
+        public string[]? RequiredUnits { get; set; }
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCompanionEmitter.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCompanionEmitter.cs
new file mode 100644
index 0000000000..6f0d6a14e7
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCompanionEmitter.cs
@@ -0,0 +1,269 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class BuiltInCompanionEmitter
+{
+    public static bool CanEmit(
+        CompanionTypeDefinition companion,
+        QuantitySelection owner,
+        IReadOnlyDictionary<string, QuantitySelection> selectionsBySemanticId) =>
+        companion.RequiredQuantities.All(selectionsBySemanticId.ContainsKey) &&
+        companion.RequiredUnits.All(required =>
+            owner.Units.Any(unit => string.Equals(unit.SingularName, required, StringComparison.Ordinal)));
+
+    public static string Emit(QuantitySelection owner, CompanionTypeDefinition companion) =>
+        companion.Kind switch
+        {
+            CompanionTypeKind.FeetInches => EmitFeetInches(owner.Definition),
+            CompanionTypeKind.StonePounds => EmitStonePounds(owner.Definition),
+            CompanionTypeKind.ReferencePressure => EmitReferencePressure(owner.Definition),
+            _ => throw new InvalidOperationException($"Unsupported companion type '{companion.Kind}'."),
+        };
+
+    private static string EmitFeetInches(QuantityDefinition length)
+    {
+        string quantityType = QuantityType(length);
+        string unitType = UnitType(length);
+        var writer = BeginNamespace(length.TargetNamespace);
+        writer.AppendLine("public sealed class FeetInches");
+        writer.AppendLine("{");
+        writer.AppendLine("    public FeetInches(double feet, double inches)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        Feet = feet;");
+        writer.AppendLine("        Inches = inches;");
+        writer.AppendLine("    }");
+        writer.AppendLine();
+        writer.AppendLine("    public double Feet { get; }");
+        writer.AppendLine("    public double Inches { get; }");
+        writer.AppendLine();
+        writer.AppendLine("    public override string ToString() => ToString(null);");
+        writer.AppendLine();
+        writer.AppendLine("    public string ToString(global::System.IFormatProvider? cultureInfo)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        cultureInfo ??= global::System.Globalization.CultureInfo.CurrentCulture;");
+        writer.Append("        string footUnit = ").Append(quantityType).Append(".GetAbbreviation(")
+            .Append(unitType).AppendLine(".Foot, cultureInfo);");
+        writer.Append("        string inchUnit = ").Append(quantityType).Append(".GetAbbreviation(")
+            .Append(unitType).AppendLine(".Inch, cultureInfo);");
+        writer.AppendLine("        return global::System.String.Format(");
+        writer.AppendLine("            cultureInfo,");
+        writer.AppendLine("            \"{0:n0} {1} {2:n0} {3}\",");
+        writer.AppendLine("            Feet,");
+        writer.AppendLine("            footUnit,");
+        writer.AppendLine("            global::System.Math.Round(Inches),");
+        writer.AppendLine("            inchUnit);");
+        writer.AppendLine("    }");
+        writer.AppendLine();
+        writer.AppendLine("    public string ToArchitecturalString(int fractionDenominator)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        if (fractionDenominator < 1)");
+        writer.AppendLine("            throw new global::System.ArgumentOutOfRangeException(nameof(fractionDenominator), \"Denominator for fractional inch must be greater than zero.\");");
+        writer.AppendLine();
+        writer.AppendLine("        int inchTrunc = (int)global::System.Math.Truncate(Inches);");
+        writer.AppendLine("        int numerator = (int)global::System.Math.Round((Inches - inchTrunc) * fractionDenominator);");
+        writer.AppendLine("        if (numerator == fractionDenominator)");
+        writer.AppendLine("        {");
+        writer.AppendLine("            inchTrunc++;");
+        writer.AppendLine("            numerator = 0;");
+        writer.AppendLine("        }");
+        writer.AppendLine();
+        writer.AppendLine("        var inchPart = new global::System.Text.StringBuilder();");
+        writer.AppendLine("        if (inchTrunc != 0 || numerator == 0)");
+        writer.AppendLine("            inchPart.Append(inchTrunc);");
+        writer.AppendLine("        if (numerator > 0)");
+        writer.AppendLine("        {");
+        writer.AppendLine("            int GreatestCommonDivisor(int a, int b)");
+        writer.AppendLine("            {");
+        writer.AppendLine("                while (a != 0 && b != 0)");
+        writer.AppendLine("                {");
+        writer.AppendLine("                    if (a > b) a %= b;");
+        writer.AppendLine("                    else b %= a;");
+        writer.AppendLine("                }");
+        writer.AppendLine("                return a | b;");
+        writer.AppendLine("            }");
+        writer.AppendLine();
+        writer.AppendLine("            int divisor = GreatestCommonDivisor(numerator, fractionDenominator);");
+        writer.AppendLine("            if (inchPart.Length > 0) inchPart.Append(' ');");
+        writer.AppendLine("            inchPart.Append($\"{numerator / divisor}/{fractionDenominator / divisor}\");");
+        writer.AppendLine("        }");
+        writer.AppendLine();
+        writer.AppendLine("        inchPart.Append('\"');");
+        writer.AppendLine("        return Feet == 0 ? inchPart.ToString() : $\"{Feet}' - {inchPart}\";");
+        writer.AppendLine("    }");
+        writer.AppendLine("}");
+        EndNamespace(writer);
+        return writer.ToString();
+    }
+
+    private static string EmitStonePounds(QuantityDefinition mass)
+    {
+        string quantityType = QuantityType(mass);
+        string unitType = UnitType(mass);
+        var writer = BeginNamespace(mass.TargetNamespace);
+        writer.AppendLine("public sealed class StonePounds");
+        writer.AppendLine("{");
+        writer.AppendLine("    public StonePounds(double stone, double pounds)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        Stone = stone;");
+        writer.AppendLine("        Pounds = pounds;");
+        writer.AppendLine("    }");
+        writer.AppendLine();
+        writer.AppendLine("    public double Stone { get; }");
+        writer.AppendLine("    public double Pounds { get; }");
+        writer.AppendLine();
+        writer.AppendLine("    public override string ToString() => ToString(null);");
+        writer.AppendLine();
+        writer.AppendLine("    public string ToString(global::System.IFormatProvider? cultureInfo)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        cultureInfo ??= global::System.Globalization.CultureInfo.CurrentCulture;");
+        writer.Append("        string stoneUnit = ").Append(quantityType).Append(".GetAbbreviation(")
+            .Append(unitType).AppendLine(".Stone, cultureInfo);");
+        writer.Append("        string poundUnit = ").Append(quantityType).Append(".GetAbbreviation(")
+            .Append(unitType).AppendLine(".Pound, cultureInfo);");
+        writer.AppendLine("        return global::System.String.Format(");
+        writer.AppendLine("            cultureInfo,");
+        writer.AppendLine("            \"{0:n0} {1} {2:n0} {3}\",");
+        writer.AppendLine("            Stone,");
+        writer.AppendLine("            stoneUnit,");
+        writer.AppendLine("            global::System.Math.Round(Pounds),");
+        writer.AppendLine("            poundUnit);");
+        writer.AppendLine("    }");
+        writer.AppendLine("}");
+        EndNamespace(writer);
+        return writer.ToString();
+    }
+
+    private static string EmitReferencePressure(QuantityDefinition pressure)
+    {
+        bool compatibilityMode = pressure.TargetNamespace == "UnitsNet";
+        string pressureType = QuantityType(pressure);
+        string enumNamespace = compatibilityMode
+            ? "UnitsNet.CustomCode.Units"
+            : pressure.TargetNamespace + ".Wrappers";
+        string wrapperNamespace = compatibilityMode
+            ? "UnitsNet.Wrappers"
+            : pressure.TargetNamespace + ".Wrappers";
+        string referenceType = "global::" + enumNamespace + ".PressureReference";
+        var writer = new StringBuilder();
+        writer.AppendLine("// <auto-generated />");
+        writer.AppendLine("#nullable enable");
+        writer.AppendLine();
+        writer.Append("namespace ").Append(enumNamespace).AppendLine();
+        writer.AppendLine("{");
+        writer.AppendLine("    public enum PressureReference");
+        writer.AppendLine("    {");
+        writer.AppendLine("        Absolute,");
+        writer.AppendLine("        Gauge,");
+        writer.AppendLine("        Vacuum,");
+        writer.AppendLine("    }");
+        writer.AppendLine("}");
+        writer.AppendLine();
+        writer.Append("namespace ").Append(wrapperNamespace).AppendLine();
+        writer.AppendLine("{");
+        writer.AppendLine("    public struct ReferencePressure");
+        writer.AppendLine("    {");
+        writer.Append("        private static readonly ").Append(pressureType)
+            .Append(" DefaultAtmosphericPressure = ").Append(pressureType)
+            .Append(".From(101325, ").Append(pressureType).AppendLine(".BaseUnit);");
+        writer.AppendLine();
+        writer.Append("        public static ").Append(referenceType).AppendLine("[] References { get; } = new[]");
+        writer.AppendLine("        {");
+        writer.Append("            ").Append(referenceType).AppendLine(".Absolute,");
+        writer.Append("            ").Append(referenceType).AppendLine(".Gauge,");
+        writer.Append("            ").Append(referenceType).AppendLine(".Vacuum,");
+        writer.AppendLine("        };");
+        writer.AppendLine();
+        writer.Append("        public const ").Append(referenceType).Append(" BaseReference = ")
+            .Append(referenceType).AppendLine(".Absolute;");
+        writer.AppendLine();
+        writer.Append("        public ReferencePressure(").Append(pressureType)
+            .AppendLine(" pressure) : this(pressure, BaseReference) { }");
+        writer.Append("        public ReferencePressure(").Append(pressureType).Append(" pressure, ")
+            .Append(referenceType).AppendLine(" reference) :");
+        writer.AppendLine("            this(pressure, reference, DefaultAtmosphericPressure) { }");
+        writer.Append("        public ReferencePressure(").Append(pressureType).Append(" pressure, ")
+            .Append(referenceType).Append(" reference, ").Append(pressureType).AppendLine(" atmosphericPressure)");
+        writer.AppendLine("        {");
+        writer.AppendLine("            Reference = reference;");
+        writer.AppendLine("            Pressure = pressure;");
+        writer.AppendLine("            AtmosphericPressure = atmosphericPressure;");
+        writer.AppendLine("        }");
+        writer.AppendLine();
+        writer.Append("        public ").Append(pressureType).AppendLine(" AtmosphericPressure { get; set; }");
+        writer.Append("        public ").Append(referenceType).AppendLine(" Reference { get; }");
+        writer.Append("        public ").Append(pressureType).AppendLine(" Pressure { get; }");
+        writer.Append("        public ").Append(pressureType).Append(" Gauge => As(").Append(referenceType)
+            .AppendLine(".Gauge);");
+        writer.Append("        public ").Append(pressureType).Append(" Absolute => As(").Append(referenceType)
+            .AppendLine(".Absolute);");
+        writer.Append("        public ").Append(pressureType).Append(" Vacuum => As(").Append(referenceType)
+            .AppendLine(".Vacuum);");
+        writer.AppendLine();
+        writer.Append("        private ").Append(pressureType).Append(" As(").Append(referenceType)
+            .AppendLine(" reference) =>");
+        writer.AppendLine("            " + pressureType + ".From(AsNumeric(reference), Pressure.Unit);");
+        writer.AppendLine();
+        writer.Append("        private double AsNumeric(").Append(referenceType).AppendLine(" reference)");
+        writer.AppendLine("        {");
+        writer.AppendLine("            double absoluteValue = AsAbsolute();");
+        writer.AppendLine("            if (Reference == reference) return Pressure.Value;");
+        writer.Append("            double atmosphericValue = AtmosphericPressure.As(Pressure.Unit);").AppendLine();
+        writer.Append("            int sign = Reference == ").Append(referenceType).AppendLine(".Vacuum ? -1 : 1;");
+        writer.AppendLine("            return reference switch");
+        writer.AppendLine("            {");
+        writer.Append("                ").Append(referenceType).AppendLine(".Absolute => absoluteValue,");
+        writer.Append("                ").Append(referenceType).AppendLine(".Gauge => absoluteValue - atmosphericValue,");
+        writer.Append("                ").Append(referenceType).AppendLine(".Vacuum => atmosphericValue - sign * absoluteValue,");
+        writer.AppendLine("                _ => throw new global::System.NotImplementedException($\"Can't convert {Reference} to {reference}.\"),");
+        writer.AppendLine("            };");
+        writer.AppendLine("        }");
+        writer.AppendLine();
+        writer.AppendLine("        private double AsAbsolute()");
+        writer.AppendLine("        {");
+        writer.AppendLine("            double atmosphericValue = AtmosphericPressure.As(Pressure.Unit);");
+        writer.AppendLine("            return Reference switch");
+        writer.AppendLine("            {");
+        writer.Append("                ").Append(referenceType)
+            .AppendLine(".Absolute when Pressure.Value >= 0 => Pressure.Value,");
+        writer.Append("                ").Append(referenceType)
+            .AppendLine(".Gauge when -Pressure.Value <= atmosphericValue => atmosphericValue + Pressure.Value,");
+        writer.Append("                ").Append(referenceType)
+            .AppendLine(".Vacuum when Pressure.Value <= atmosphericValue => atmosphericValue - Pressure.Value,");
+        writer.Append("                ").Append(referenceType).Append(".Absolute or ").Append(referenceType)
+            .Append(".Gauge or ").Append(referenceType).AppendLine(".Vacuum =>");
+        writer.AppendLine("                    throw new global::System.ArgumentOutOfRangeException(nameof(Pressure), \"Absolute pressure cannot be less than zero.\"),");
+        writer.AppendLine("                _ => throw new global::System.NotImplementedException($\"Can't convert {Reference} to base reference.\"),");
+        writer.AppendLine("            };");
+        writer.AppendLine("        }");
+        writer.AppendLine("    }");
+        writer.AppendLine("}");
+        return writer.ToString();
+    }
+
+    private static StringBuilder BeginNamespace(string targetNamespace)
+    {
+        var writer = new StringBuilder();
+        writer.AppendLine("// <auto-generated />");
+        writer.AppendLine("#nullable enable");
+        writer.AppendLine();
+        writer.Append("namespace ").Append(targetNamespace).AppendLine();
+        writer.AppendLine("{");
+        return writer;
+    }
+
+    private static void EndNamespace(StringBuilder writer) => writer.AppendLine("}");
+
+    private static string QuantityType(QuantityDefinition definition) =>
+        "global::" + definition.TargetNamespace + "." + definition.Name;
+
+    private static string UnitType(QuantityDefinition definition) =>
+        definition.TargetNamespace == "UnitsNet"
+            ? "global::UnitsNet.Units." + definition.Name + "Unit"
+            : "global::" + definition.TargetNamespace + "." + definition.Name + "Unit";
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCompanions.json b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCompanions.json
new file mode 100644
index 0000000000..5402a95615
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInCompanions.json
@@ -0,0 +1,19 @@
+{
+  "UnitsNet.Length": [
+    {
+      "Kind": "FeetInches",
+      "RequiredUnits": [ "Foot", "Inch" ]
+    }
+  ],
+  "UnitsNet.Mass": [
+    {
+      "Kind": "StonePounds",
+      "RequiredUnits": [ "Stone", "Pound" ]
+    }
+  ],
+  "UnitsNet.Pressure": [
+    {
+      "Kind": "ReferencePressure"
+    }
+  ]
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInRelationCatalog.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInRelationCatalog.cs
new file mode 100644
index 0000000000..be33279374
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInRelationCatalog.cs
@@ -0,0 +1,30 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class BuiltInRelationCatalog
+{
+    private const string ResourceName = "UnitsNet.Modular.Generator.BuiltIns.UnitRelations.json";
+
+    public static IReadOnlyList<QuantityRelationDefinition> Definitions { get; } = LoadDefinitions();
+
+    private static IReadOnlyList<QuantityRelationDefinition> LoadDefinitions()
+    {
+        Assembly assembly = typeof(BuiltInRelationCatalog).Assembly;
+        using Stream stream = assembly.GetManifestResourceStream(ResourceName)
+            ?? throw new InvalidOperationException($"Missing embedded built-in relation catalog '{ResourceName}'.");
+        using var reader = new StreamReader(stream);
+        RelationDefinitionResult result = QuantityRelationParser.Parse(reader.ReadToEnd(), ResourceName);
+        if (result.Error is not null)
+        {
+            throw new InvalidOperationException($"Embedded built-in relation catalog is invalid: {result.Error}");
+        }
+
+        return QuantityRelationParser.QualifyQuantityIds(result.Definitions!, "UnitsNet");
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInUnitEnumValues.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInUnitEnumValues.cs
new file mode 100644
index 0000000000..d513ac2cd7
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/BuiltInUnitEnumValues.cs
@@ -0,0 +1,43 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Reflection;
+using System.Text.Json;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class BuiltInUnitEnumValues
+{
+    private const string ResourceName = "UnitsNet.Modular.Generator.BuiltIns.UnitEnumValues.json";
+
+    private static readonly IReadOnlyDictionary<string, Dictionary<string, int>> Values = Load();
+
+    public static bool TryGet(string semanticId, string unitName, out int value)
+    {
+        const string prefix = "UnitsNet.";
+        if (!semanticId.StartsWith(prefix, StringComparison.Ordinal))
+        {
+            value = default;
+            return false;
+        }
+
+        string quantityName = semanticId.Substring(prefix.Length);
+        value = default;
+        return Values.TryGetValue(quantityName, out Dictionary<string, int>? units) &&
+               units.TryGetValue(unitName, out value);
+    }
+
+    private static IReadOnlyDictionary<string, Dictionary<string, int>> Load()
+    {
+        Assembly assembly = typeof(BuiltInUnitEnumValues).Assembly;
+        using Stream stream = assembly.GetManifestResourceStream(ResourceName)
+            ?? throw new InvalidOperationException($"Missing embedded unit enum values '{ResourceName}'.");
+        return JsonSerializer.Deserialize<Dictionary<string, Dictionary<string, int>>>(
+                   stream,
+                   new JsonSerializerOptions
+                   {
+                       AllowTrailingCommas = true,
+                       ReadCommentHandling = JsonCommentHandling.Skip,
+                   })
+               ?? throw new InvalidOperationException("The embedded unit enum value map was empty.");
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/ConversionExpression.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/ConversionExpression.cs
new file mode 100644
index 0000000000..72d10aa28e
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/ConversionExpression.cs
@@ -0,0 +1,159 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class ConversionExpression
+{
+    private static readonly ISet<string> AllowedMathMembers = new HashSet<string>(StringComparer.Ordinal)
+    {
+        "PI",
+        "E",
+    };
+
+    private static readonly ISet<string> AllowedMathMethods = new HashSet<string>(StringComparer.Ordinal)
+    {
+        "Abs",
+        "Exp",
+        "Log",
+        "Log10",
+        "Pow",
+        "Sqrt",
+    };
+
+    public static bool TryNormalize(string? source, out string expression, out string error)
+    {
+        expression = string.Empty;
+        error = string.Empty;
+
+        if (string.IsNullOrWhiteSpace(source))
+        {
+            error = "Conversion expression is required.";
+            return false;
+        }
+
+        string candidate = source!.Replace("{x}", "x");
+        ExpressionSyntax syntax = SyntaxFactory.ParseExpression(candidate);
+        if (syntax.ContainsDiagnostics)
+        {
+            error = string.Join("; ", syntax.GetDiagnostics().Select(diagnostic => diagnostic.GetMessage()));
+            return false;
+        }
+
+        if (!IsAllowed(syntax, out error))
+        {
+            return false;
+        }
+
+        expression = syntax.NormalizeWhitespace().ToFullString().Replace("Math.", "global::System.Math.");
+        return true;
+    }
+
+    public static string Substitute(string expression, string replacement)
+    {
+        ExpressionSyntax syntax = SyntaxFactory.ParseExpression(expression);
+        ExpressionSyntax replacementSyntax = SyntaxFactory.ParenthesizedExpression(
+            SyntaxFactory.ParseExpression(replacement));
+        return new ValueRewriter(replacementSyntax)
+            .Visit(syntax)!
+            .NormalizeWhitespace()
+            .ToFullString();
+    }
+
+    private static bool IsAllowed(ExpressionSyntax expression, out string error)
+    {
+        switch (expression)
+        {
+            case LiteralExpressionSyntax literal when literal.IsKind(SyntaxKind.NumericLiteralExpression):
+                error = string.Empty;
+                return true;
+            case IdentifierNameSyntax identifier when identifier.Identifier.ValueText == "x":
+                error = string.Empty;
+                return true;
+            case ParenthesizedExpressionSyntax parenthesized:
+                return IsAllowed(parenthesized.Expression, out error);
+            case PrefixUnaryExpressionSyntax unary when unary.IsKind(SyntaxKind.UnaryMinusExpression) || unary.IsKind(SyntaxKind.UnaryPlusExpression):
+                return IsAllowed(unary.Operand, out error);
+            case BinaryExpressionSyntax binary when IsAllowedBinary(binary.Kind()):
+                if (!IsAllowed(binary.Left, out error))
+                {
+                    return false;
+                }
+
+                return IsAllowed(binary.Right, out error);
+            case MemberAccessExpressionSyntax memberAccess:
+                return IsAllowedMathMember(memberAccess, out error);
+            case InvocationExpressionSyntax invocation:
+                return IsAllowedMathInvocation(invocation, out error);
+            default:
+                error = $"Expression syntax '{expression.Kind()}' is not allowed.";
+                return false;
+        }
+    }
+
+    private static bool IsAllowedMathMember(MemberAccessExpressionSyntax memberAccess, out string error)
+    {
+        if (memberAccess.Expression is IdentifierNameSyntax identifier &&
+            identifier.Identifier.ValueText == "Math" &&
+            AllowedMathMembers.Contains(memberAccess.Name.Identifier.ValueText))
+        {
+            error = string.Empty;
+            return true;
+        }
+
+        error = $"Member access '{memberAccess}' is not allowed.";
+        return false;
+    }
+
+    private static bool IsAllowedMathInvocation(InvocationExpressionSyntax invocation, out string error)
+    {
+        if (invocation.Expression is not MemberAccessExpressionSyntax memberAccess ||
+            memberAccess.Expression is not IdentifierNameSyntax identifier ||
+            identifier.Identifier.ValueText != "Math" ||
+            !AllowedMathMethods.Contains(memberAccess.Name.Identifier.ValueText))
+        {
+            error = $"Method invocation '{invocation.Expression}' is not allowed.";
+            return false;
+        }
+
+        foreach (ArgumentSyntax argument in invocation.ArgumentList.Arguments)
+        {
+            if (argument.NameColon is not null || !argument.RefKindKeyword.IsKind(SyntaxKind.None))
+            {
+                error = "Named, ref, in, and out arguments are not allowed.";
+                return false;
+            }
+
+            if (!IsAllowed(argument.Expression, out error))
+            {
+                return false;
+            }
+        }
+
+        error = string.Empty;
+        return true;
+    }
+
+    private static bool IsAllowedBinary(SyntaxKind kind)
+        => kind is SyntaxKind.AddExpression or
+            SyntaxKind.SubtractExpression or
+            SyntaxKind.MultiplyExpression or
+            SyntaxKind.DivideExpression or
+            SyntaxKind.ModuloExpression;
+
+    private sealed class ValueRewriter : CSharpSyntaxRewriter
+    {
+        private readonly ExpressionSyntax _replacement;
+
+        public ValueRewriter(ExpressionSyntax replacement) => _replacement = replacement;
+
+        public override SyntaxNode? VisitIdentifierName(IdentifierNameSyntax node) =>
+            node.Identifier.ValueText == "x" ? _replacement : base.VisitIdentifierName(node);
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/JsonDefinitionParser.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/JsonDefinitionParser.cs
new file mode 100644
index 0000000000..b95c53e69d
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/JsonDefinitionParser.cs
@@ -0,0 +1,264 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text.Json;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class JsonDefinitionParser
+{
+    private static readonly JsonSerializerOptions SerializerOptions = new JsonSerializerOptions
+    {
+        AllowTrailingCommas = true,
+        PropertyNameCaseInsensitive = true,
+        ReadCommentHandling = JsonCommentHandling.Skip,
+    };
+
+    public static JsonDefinitionResult Parse(AdditionalText file, System.Threading.CancellationToken cancellationToken)
+    {
+        string json = file.GetText(cancellationToken)?.ToString() ?? string.Empty;
+        return Parse(json, file.Path);
+    }
+
+    public static JsonDefinitionResult Parse(string json, string path)
+    {
+        try
+        {
+            JsonQuantity? parsed = JsonSerializer.Deserialize<JsonQuantity>(json, SerializerOptions);
+            if (parsed is null)
+            {
+                return Error(path, json, "The file did not contain a quantity definition.");
+            }
+
+            if (string.IsNullOrWhiteSpace(parsed.Name) || string.IsNullOrWhiteSpace(parsed.BaseUnit))
+            {
+                return Error(path, json, "Name and BaseUnit are required.");
+            }
+
+            if (!IsIdentifier(parsed.Name!))
+            {
+                return Error(path, json, $"Quantity name '{parsed.Name}' is not a valid C# identifier.");
+            }
+
+            string targetNamespace = string.IsNullOrWhiteSpace(parsed.Namespace) ? "UnitsNet" : parsed.Namespace!;
+            if (!targetNamespace.Split('.').All(IsIdentifier))
+            {
+                return Error(path, json, $"Namespace '{targetNamespace}' is not a valid C# namespace.");
+            }
+
+            var units = new List<UnitDefinition>();
+            foreach (JsonUnit unit in parsed.Units ?? Array.Empty<JsonUnit>())
+            {
+                if (string.IsNullOrWhiteSpace(unit.SingularName) || string.IsNullOrWhiteSpace(unit.PluralName))
+                {
+                    return Error(path, json, "Every unit requires SingularName and PluralName.");
+                }
+
+                if (!IsIdentifier(unit.SingularName!) || !IsIdentifier(unit.PluralName!))
+                {
+                    return Error(
+                        path,
+                        json,
+                        $"Unit names '{unit.SingularName}' and '{unit.PluralName}' must be valid C# identifiers.");
+                }
+
+                if (!ConversionExpression.TryNormalize(unit.FromUnitToBaseFunc, out string toBase, out string toBaseError))
+                {
+                    return Error(path, json, $"{unit.SingularName}.FromUnitToBaseFunc: {toBaseError}");
+                }
+
+                if (!ConversionExpression.TryNormalize(unit.FromBaseToUnitFunc, out string fromBase, out string fromBaseError))
+                {
+                    return Error(path, json, $"{unit.SingularName}.FromBaseToUnitFunc: {fromBaseError}");
+                }
+
+                UnitLocalizationDefinition[] localizations = (unit.Localization ?? Array.Empty<JsonLocalization>())
+                    .Select(localization => new UnitLocalizationDefinition(
+                        localization.Culture ?? string.Empty,
+                        localization.Abbreviations ?? Array.Empty<string>(),
+                        ParsePrefixAbbreviations(localization.AbbreviationsForPrefixes)))
+                    .ToArray();
+
+                units.Add(new UnitDefinition(
+                    unit.SingularName!,
+                    unit.PluralName!,
+                    toBase,
+                    fromBase,
+                    ParseBaseUnits(unit.BaseUnits),
+                    localizations,
+                    unit.Prefixes ?? Array.Empty<string>()));
+            }
+
+            string? duplicateSingularName = units
+                .GroupBy(unit => unit.SingularName, StringComparer.Ordinal)
+                .FirstOrDefault(group => group.Count() > 1)
+                ?.Key;
+            if (duplicateSingularName is not null)
+            {
+                return Error(path, json, $"Unit SingularName '{duplicateSingularName}' is duplicated.");
+            }
+
+            string? duplicatePluralName = units
+                .GroupBy(unit => unit.PluralName, StringComparer.Ordinal)
+                .FirstOrDefault(group => group.Count() > 1)
+                ?.Key;
+            if (duplicatePluralName is not null)
+            {
+                return Error(path, json, $"Unit PluralName '{duplicatePluralName}' is duplicated.");
+            }
+
+            if (!IsIdentifier(parsed.BaseUnit!))
+            {
+                return Error(path, json, $"BaseUnit '{parsed.BaseUnit}' is not a valid C# identifier.");
+            }
+
+            bool isLogarithmic = bool.TryParse(parsed.Logarithmic, out bool logarithmic) && logarithmic;
+            double logarithmicScalingFactor = double.TryParse(
+                parsed.LogarithmicScalingFactor,
+                NumberStyles.Float,
+                CultureInfo.InvariantCulture,
+                out double scalingFactor)
+                    ? scalingFactor
+                    : 1;
+            var definition = new QuantityDefinition(
+                parsed.Name!,
+                targetNamespace,
+                parsed.BaseUnit!,
+                units,
+                path,
+                isLogarithmic,
+                logarithmicScalingFactor,
+                affineOffsetType: parsed.AffineOffsetType,
+                baseDimensions: ParseBaseDimensions(parsed.BaseDimensions));
+            return new JsonDefinitionResult(path, definition, null, json);
+        }
+        catch (JsonException exception)
+        {
+            int line = checked((int)exception.LineNumber.GetValueOrDefault());
+            int position = checked((int)exception.BytePositionInLine.GetValueOrDefault());
+            return Error(
+                path,
+                json,
+                $"JSON line {line + 1}, byte position {position}: {exception.Message}",
+                line,
+                position);
+        }
+        catch (Exception exception)
+        {
+            return Error(path, json, exception.Message);
+        }
+    }
+
+    private static bool IsIdentifier(string value) =>
+        SyntaxFacts.IsValidIdentifier(value) &&
+        SyntaxFacts.GetKeywordKind(value) == SyntaxKind.None &&
+        SyntaxFacts.GetContextualKeywordKind(value) == SyntaxKind.None;
+
+    private static IReadOnlyDictionary<string, IReadOnlyList<string>> ParsePrefixAbbreviations(
+        IDictionary<string, JsonElement>? values)
+    {
+        var result = new Dictionary<string, IReadOnlyList<string>>(StringComparer.Ordinal);
+        if (values is null)
+        {
+            return result;
+        }
+
+        foreach (KeyValuePair<string, JsonElement> value in values)
+        {
+            string[] abbreviations;
+            if (value.Value.ValueKind == JsonValueKind.Array)
+            {
+                abbreviations = value.Value.EnumerateArray().Select(ReadAbbreviation).ToArray();
+            }
+            else
+            {
+                abbreviations = new[] { ReadAbbreviation(value.Value) };
+            }
+
+            result[value.Key] = abbreviations;
+        }
+
+        return result;
+    }
+
+    private static string ReadAbbreviation(JsonElement value)
+    {
+        if (value.ValueKind != JsonValueKind.String)
+        {
+            throw new JsonException("Prefix abbreviations must be strings or arrays of strings.");
+        }
+
+        return value.GetString() ?? string.Empty;
+    }
+
+    private static BaseDimensionsDefinition ParseBaseDimensions(IReadOnlyDictionary<string, int>? dimensions)
+    {
+        int Get(string symbol) =>
+            dimensions is not null && dimensions.TryGetValue(symbol, out int value) ? value : 0;
+        return new BaseDimensionsDefinition(
+            Get("L"),
+            Get("M"),
+            Get("T"),
+            Get("I"),
+            Get("Θ"),
+            Get("N"),
+            Get("J"));
+    }
+
+    private static BaseUnitsDefinition ParseBaseUnits(IReadOnlyDictionary<string, string>? units)
+    {
+        string? Get(string symbol) =>
+            units is not null && units.TryGetValue(symbol, out string? value) ? value : null;
+        return new BaseUnitsDefinition(
+            Get("L"),
+            Get("M"),
+            Get("T"),
+            Get("I"),
+            Get("Θ"),
+            Get("N"),
+            Get("J"));
+    }
+
+    private static JsonDefinitionResult Error(
+        string path,
+        string json,
+        string error,
+        int errorLine = 0,
+        int errorColumn = 0) =>
+        new JsonDefinitionResult(path, null, error, json, errorLine, errorColumn);
+
+    private sealed class JsonQuantity
+    {
+        public string? Name { get; set; }
+        public string? Namespace { get; set; }
+        public string? BaseUnit { get; set; }
+        public string? Logarithmic { get; set; }
+        public string? LogarithmicScalingFactor { get; set; }
+        public string? AffineOffsetType { get; set; }
+        public Dictionary<string, int>? BaseDimensions { get; set; }
+        public JsonUnit[]? Units { get; set; }
+    }
+
+    private sealed class JsonUnit
+    {
+        public string? SingularName { get; set; }
+        public string? PluralName { get; set; }
+        public string? FromUnitToBaseFunc { get; set; }
+        public string? FromBaseToUnitFunc { get; set; }
+        public Dictionary<string, string>? BaseUnits { get; set; }
+        public string[]? Prefixes { get; set; }
+        public JsonLocalization[]? Localization { get; set; }
+    }
+
+    private sealed class JsonLocalization
+    {
+        public string? Culture { get; set; }
+        public string[]? Abbreviations { get; set; }
+        public Dictionary<string, JsonElement>? AbbreviationsForPrefixes { get; set; }
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/Models.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/Models.cs
new file mode 100644
index 0000000000..932a14d63a
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/Models.cs
@@ -0,0 +1,574 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Collections.Generic;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace UnitsNet.Modular.Generator;
+
+internal sealed class QuantityDefinition
+{
+    public QuantityDefinition(
+        string name,
+        string targetNamespace,
+        string baseUnit,
+        IReadOnlyList<UnitDefinition> units,
+        string? sourcePath = null,
+        bool isLogarithmic = false,
+        double logarithmicScalingFactor = 1,
+        string? semanticId = null,
+        string? affineOffsetType = null,
+        BaseDimensionsDefinition? baseDimensions = null,
+        IReadOnlyList<QuantityAugmentationDefinition>? augmentations = null)
+    {
+        Name = name;
+        TargetNamespace = targetNamespace;
+        BaseUnit = baseUnit;
+        Units = units;
+        SourcePath = sourcePath;
+        IsLogarithmic = isLogarithmic;
+        LogarithmicScalingFactor = logarithmicScalingFactor;
+        SemanticId = semanticId ?? targetNamespace + "." + name;
+        AffineOffsetType = affineOffsetType;
+        BaseDimensions = baseDimensions ?? BaseDimensionsDefinition.Dimensionless;
+        Augmentations = augmentations ?? Array.Empty<QuantityAugmentationDefinition>();
+    }
+
+    public string Name { get; }
+
+    public string TargetNamespace { get; }
+
+    public string BaseUnit { get; }
+
+    public IReadOnlyList<UnitDefinition> Units { get; }
+
+    public string? SourcePath { get; }
+
+    public bool IsLogarithmic { get; }
+
+    public double LogarithmicScalingFactor { get; }
+
+    public string? AffineOffsetType { get; }
+
+    public bool IsAffine => !string.IsNullOrWhiteSpace(AffineOffsetType);
+
+    public BaseDimensionsDefinition BaseDimensions { get; }
+
+    public IReadOnlyList<QuantityAugmentationDefinition> Augmentations { get; }
+
+    public string Id => SemanticId;
+
+    public string SemanticId { get; }
+
+    public QuantityDefinition WithTargetNamespace(string targetNamespace)
+        => new QuantityDefinition(
+            Name,
+            targetNamespace,
+            BaseUnit,
+            Units,
+            SourcePath,
+            IsLogarithmic,
+            LogarithmicScalingFactor,
+            SemanticId,
+            AffineOffsetType,
+            BaseDimensions,
+            Augmentations);
+
+    public QuantityDefinition WithSemanticId(string semanticId)
+        => new QuantityDefinition(
+            Name,
+            TargetNamespace,
+            BaseUnit,
+            Units,
+            SourcePath,
+            IsLogarithmic,
+            LogarithmicScalingFactor,
+            semanticId,
+            AffineOffsetType,
+            BaseDimensions,
+            Augmentations);
+
+    public QuantityDefinition WithAugmentations(IReadOnlyList<QuantityAugmentationDefinition> augmentations)
+        => new QuantityDefinition(
+            Name,
+            TargetNamespace,
+            BaseUnit,
+            Units,
+            SourcePath,
+            IsLogarithmic,
+            LogarithmicScalingFactor,
+            SemanticId,
+            AffineOffsetType,
+            BaseDimensions,
+            augmentations);
+}
+
+internal sealed class QuantityAugmentationDefinition
+{
+    public QuantityAugmentationDefinition(
+        QuantityAugmentationKind kind,
+        IReadOnlyList<string>? requiredQuantities = null,
+        IReadOnlyList<string>? requiredUnits = null)
+    {
+        Kind = kind;
+        RequiredQuantities = requiredQuantities ?? Array.Empty<string>();
+        RequiredUnits = requiredUnits ?? Array.Empty<string>();
+    }
+
+    public QuantityAugmentationKind Kind { get; }
+
+    public IReadOnlyList<string> RequiredQuantities { get; }
+
+    public IReadOnlyList<string> RequiredUnits { get; }
+}
+
+internal enum QuantityAugmentationKind
+{
+    DurationTimeSpan,
+    AreaCircle,
+    MassFractionMass,
+    ForcePressureArea,
+    ForceMassAcceleration,
+    MassGravitationalForce,
+    AmountOfSubstanceParticles,
+    AmountOfSubstanceMass,
+    MassConcentrationMolarity,
+    MassConcentrationVolumeConcentration,
+    MolarityMassConcentration,
+    MolarityVolumeConcentration,
+    VolumeConcentrationMassConcentration,
+    VolumeConcentrationMolarity,
+    VolumeConcentrationVolumes,
+    ElectricApparentPowerDivision,
+    EnergyDensityCombustionEnergy,
+    AmplitudeRatioElectricPotential,
+    AmplitudeRatioPowerRatio,
+    ElectricPotentialAmplitudeRatio,
+    LevelRatio,
+    PowerPowerRatio,
+    PowerRatioPower,
+    PowerRatioAmplitudeRatio,
+    LengthFeetInches,
+    MassStonePounds,
+}
+
+internal sealed class CompanionTypeDefinition
+{
+    public CompanionTypeDefinition(
+        CompanionTypeKind kind,
+        IReadOnlyList<string>? requiredQuantities = null,
+        IReadOnlyList<string>? requiredUnits = null)
+    {
+        Kind = kind;
+        RequiredQuantities = requiredQuantities ?? Array.Empty<string>();
+        RequiredUnits = requiredUnits ?? Array.Empty<string>();
+    }
+
+    public CompanionTypeKind Kind { get; }
+
+    public IReadOnlyList<string> RequiredQuantities { get; }
+
+    public IReadOnlyList<string> RequiredUnits { get; }
+}
+
+internal enum CompanionTypeKind
+{
+    FeetInches,
+    StonePounds,
+    ReferencePressure,
+}
+
+internal sealed class BaseDimensionsDefinition
+{
+    public static BaseDimensionsDefinition Dimensionless { get; } = new BaseDimensionsDefinition(0, 0, 0, 0, 0, 0, 0);
+
+    public BaseDimensionsDefinition(
+        int length,
+        int mass,
+        int time,
+        int current,
+        int temperature,
+        int amount,
+        int luminousIntensity)
+    {
+        Length = length;
+        Mass = mass;
+        Time = time;
+        Current = current;
+        Temperature = temperature;
+        Amount = amount;
+        LuminousIntensity = luminousIntensity;
+    }
+
+    public int Length { get; }
+
+    public int Mass { get; }
+
+    public int Time { get; }
+
+    public int Current { get; }
+
+    public int Temperature { get; }
+
+    public int Amount { get; }
+
+    public int LuminousIntensity { get; }
+}
+
+internal sealed class UnitDefinition
+{
+    public UnitDefinition(
+        string singularName,
+        string pluralName,
+        string fromUnitToBaseExpression,
+        string fromBaseToUnitExpression,
+        BaseUnitsDefinition baseUnits,
+        IReadOnlyList<UnitLocalizationDefinition> localizations,
+        IReadOnlyList<string>? prefixes = null)
+    {
+        SingularName = singularName;
+        PluralName = pluralName;
+        FromUnitToBaseExpression = fromUnitToBaseExpression;
+        FromBaseToUnitExpression = fromBaseToUnitExpression;
+        BaseUnits = baseUnits;
+        Localizations = localizations;
+        Prefixes = prefixes ?? Array.Empty<string>();
+    }
+
+    public string SingularName { get; }
+
+    public string PluralName { get; }
+
+    public string FromUnitToBaseExpression { get; }
+
+    public string FromBaseToUnitExpression { get; }
+
+    public BaseUnitsDefinition BaseUnits { get; }
+
+    public IReadOnlyList<UnitLocalizationDefinition> Localizations { get; }
+
+    public IReadOnlyList<string> Prefixes { get; }
+}
+
+internal sealed class BaseUnitsDefinition
+{
+    public static BaseUnitsDefinition Undefined { get; } =
+        new BaseUnitsDefinition(null, null, null, null, null, null, null);
+
+    public BaseUnitsDefinition(
+        string? length,
+        string? mass,
+        string? time,
+        string? current,
+        string? temperature,
+        string? amount,
+        string? luminousIntensity)
+    {
+        Length = length;
+        Mass = mass;
+        Time = time;
+        Current = current;
+        Temperature = temperature;
+        Amount = amount;
+        LuminousIntensity = luminousIntensity;
+    }
+
+    public string? Length { get; }
+
+    public string? Mass { get; }
+
+    public string? Time { get; }
+
+    public string? Current { get; }
+
+    public string? Temperature { get; }
+
+    public string? Amount { get; }
+
+    public string? LuminousIntensity { get; }
+
+    public bool IsUndefined =>
+        Length is null &&
+        Mass is null &&
+        Time is null &&
+        Current is null &&
+        Temperature is null &&
+        Amount is null &&
+        LuminousIntensity is null;
+
+    public BaseUnitsDefinition Rename(string fromUnitName, string toUnitName) =>
+        new BaseUnitsDefinition(
+            Rename(Length, fromUnitName, toUnitName),
+            Rename(Mass, fromUnitName, toUnitName),
+            Rename(Time, fromUnitName, toUnitName),
+            Rename(Current, fromUnitName, toUnitName),
+            Rename(Temperature, fromUnitName, toUnitName),
+            Rename(Amount, fromUnitName, toUnitName),
+            Rename(LuminousIntensity, fromUnitName, toUnitName));
+
+    private static string? Rename(string? value, string fromUnitName, string toUnitName) =>
+        string.Equals(value, fromUnitName, StringComparison.Ordinal) ? toUnitName : value;
+}
+
+internal sealed class UnitLocalizationDefinition
+{
+    public UnitLocalizationDefinition(
+        string culture,
+        IReadOnlyList<string> abbreviations,
+        IReadOnlyDictionary<string, IReadOnlyList<string>>? abbreviationsForPrefixes = null)
+    {
+        Culture = culture;
+        Abbreviations = abbreviations;
+        AbbreviationsForPrefixes = abbreviationsForPrefixes ?? new Dictionary<string, IReadOnlyList<string>>();
+    }
+
+    public string Culture { get; }
+
+    public IReadOnlyList<string> Abbreviations { get; }
+
+    public IReadOnlyDictionary<string, IReadOnlyList<string>> AbbreviationsForPrefixes { get; }
+}
+
+internal sealed class QuantitySelection
+{
+    public QuantitySelection(QuantityDefinition definition, IReadOnlyList<UnitDefinition> units)
+    {
+        Definition = definition;
+        Units = units;
+    }
+
+    public QuantityDefinition Definition { get; }
+
+    public IReadOnlyList<UnitDefinition> Units { get; }
+}
+
+internal sealed class JsonDefinitionResult
+{
+    public JsonDefinitionResult(
+        string path,
+        QuantityDefinition? definition,
+        string? error,
+        string content,
+        int errorLine = 0,
+        int errorColumn = 0)
+    {
+        Path = path;
+        Definition = definition;
+        Error = error;
+        ContentFingerprint = AdditionalFileFingerprint.Create(content);
+        ErrorLine = errorLine;
+        ErrorColumn = errorColumn;
+    }
+
+    public string Path { get; }
+
+    public QuantityDefinition? Definition { get; }
+
+    public string? Error { get; }
+
+    public string ContentFingerprint { get; }
+
+    public int ErrorLine { get; }
+
+    public int ErrorColumn { get; }
+}
+
+internal sealed class JsonDefinitionResultComparer : IEqualityComparer<JsonDefinitionResult>
+{
+    public static JsonDefinitionResultComparer Instance { get; } = new JsonDefinitionResultComparer();
+
+    public bool Equals(JsonDefinitionResult? x, JsonDefinitionResult? y) =>
+        ReferenceEquals(x, y) ||
+        (x is not null &&
+         y is not null &&
+         string.Equals(x.Path, y.Path, StringComparison.Ordinal) &&
+         string.Equals(x.ContentFingerprint, y.ContentFingerprint, StringComparison.Ordinal));
+
+    public int GetHashCode(JsonDefinitionResult obj)
+    {
+        unchecked
+        {
+            return (StringComparer.Ordinal.GetHashCode(obj.Path) * 397) ^
+                   StringComparer.Ordinal.GetHashCode(obj.ContentFingerprint);
+        }
+    }
+}
+
+internal sealed class QuantityRelationDefinition
+{
+    public QuantityRelationDefinition(
+        RelationEndpoint result,
+        RelationEndpoint left,
+        RelationEndpoint right,
+        bool noInferredDivision,
+        string source)
+    {
+        Result = result;
+        Left = left;
+        Right = right;
+        NoInferredDivision = noInferredDivision;
+        Source = source;
+    }
+
+    public RelationEndpoint Result { get; }
+
+    public RelationEndpoint Left { get; }
+
+    public RelationEndpoint Right { get; }
+
+    public bool NoInferredDivision { get; }
+
+    public string Source { get; }
+}
+
+internal sealed class RelationEndpoint
+{
+    public RelationEndpoint(string quantity, string? unit)
+    {
+        Quantity = quantity;
+        Unit = unit;
+    }
+
+    public string Quantity { get; }
+
+    public string? Unit { get; }
+}
+
+internal sealed class QuantityRelation
+{
+    public QuantityRelation(
+        string @operator,
+        RelationEndpoint result,
+        RelationEndpoint left,
+        RelationEndpoint right,
+        bool noInferredDivision,
+        string source)
+    {
+        Operator = @operator;
+        Result = result;
+        Left = left;
+        Right = right;
+        NoInferredDivision = noInferredDivision;
+        Source = source;
+    }
+
+    public string Operator { get; }
+
+    public RelationEndpoint Result { get; }
+
+    public RelationEndpoint Left { get; }
+
+    public RelationEndpoint Right { get; }
+
+    public bool NoInferredDivision { get; }
+
+    public string Source { get; }
+
+    public string Key => Result.Quantity + "." + Result.Unit + " = " +
+                         Left.Quantity + "." + Left.Unit + " " + Operator + " " +
+                         Right.Quantity + "." + Right.Unit;
+}
+
+internal sealed class RelationDefinitionResult
+{
+    public RelationDefinitionResult(
+        string path,
+        IReadOnlyList<QuantityRelationDefinition>? definitions,
+        string? error,
+        string content,
+        int errorLine = 0,
+        int errorColumn = 0)
+    {
+        Path = path;
+        Definitions = definitions;
+        Error = error;
+        ContentFingerprint = AdditionalFileFingerprint.Create(content);
+        ErrorLine = errorLine;
+        ErrorColumn = errorColumn;
+    }
+
+    public string Path { get; }
+
+    public IReadOnlyList<QuantityRelationDefinition>? Definitions { get; }
+
+    public string? Error { get; }
+
+    public string ContentFingerprint { get; }
+
+    public int ErrorLine { get; }
+
+    public int ErrorColumn { get; }
+}
+
+internal sealed class RelationDefinitionResultComparer : IEqualityComparer<RelationDefinitionResult>
+{
+    public static RelationDefinitionResultComparer Instance { get; } = new RelationDefinitionResultComparer();
+
+    public bool Equals(RelationDefinitionResult? x, RelationDefinitionResult? y) =>
+        ReferenceEquals(x, y) ||
+        (x is not null &&
+         y is not null &&
+         string.Equals(x.Path, y.Path, StringComparison.Ordinal) &&
+         string.Equals(x.ContentFingerprint, y.ContentFingerprint, StringComparison.Ordinal));
+
+    public int GetHashCode(RelationDefinitionResult obj)
+    {
+        unchecked
+        {
+            return (StringComparer.Ordinal.GetHashCode(obj.Path) * 397) ^
+                   StringComparer.Ordinal.GetHashCode(obj.ContentFingerprint);
+        }
+    }
+}
+
+internal static class AdditionalFileFingerprint
+{
+    public static string Create(string content)
+    {
+        using SHA256 algorithm = SHA256.Create();
+        return Convert.ToBase64String(algorithm.ComputeHash(Encoding.UTF8.GetBytes(content)));
+    }
+}
+
+internal sealed class EmittedQuantityRelation
+{
+    public EmittedQuantityRelation(
+        string @operator,
+        QuantitySelection? result,
+        UnitDefinition? resultUnit,
+        QuantitySelection? left,
+        UnitDefinition? leftUnit,
+        QuantitySelection? right,
+        UnitDefinition? rightUnit,
+        string source)
+    {
+        Operator = @operator;
+        Result = result;
+        ResultUnit = resultUnit;
+        Left = left;
+        LeftUnit = leftUnit;
+        Right = right;
+        RightUnit = rightUnit;
+        Source = source;
+    }
+
+    public string Operator { get; }
+
+    public QuantitySelection? Result { get; }
+
+    public UnitDefinition? ResultUnit { get; }
+
+    public QuantitySelection? Left { get; }
+
+    public UnitDefinition? LeftUnit { get; }
+
+    public QuantitySelection? Right { get; }
+
+    public UnitDefinition? RightUnit { get; }
+
+    public string Source { get; }
+
+    public string Key => Result?.Definition.SemanticId + "." + ResultUnit?.SingularName + " = " +
+                         (Left?.Definition.SemanticId ?? "double") + "." + LeftUnit?.SingularName + " " + Operator + " " +
+                         (Right?.Definition.SemanticId ?? "double") + "." + RightUnit?.SingularName;
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/ModuleEmitter.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/ModuleEmitter.cs
new file mode 100644
index 0000000000..434a9991e5
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/ModuleEmitter.cs
@@ -0,0 +1,316 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Text;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class ModuleEmitter
+{
+    public static string EmitRegistry(IReadOnlyList<QuantitySelection> selections)
+    {
+        var writer = new StringBuilder();
+        writer.AppendLine("// <auto-generated />");
+        writer.AppendLine("#nullable enable");
+        writer.AppendLine();
+        writer.AppendLine("namespace UnitsNet");
+        writer.AppendLine("{");
+        writer.AppendLine("    public static class GeneratedQuantityRegistry");
+        writer.AppendLine("    {");
+        writer.AppendLine("        public static global::UnitsNet.QuantityRegistry Instance { get; } = new(");
+        writer.AppendLine("            new global::UnitsNet.IQuantityDescriptor[]");
+        writer.AppendLine("            {");
+        foreach (QuantitySelection selection in selections)
+        {
+            QuantityDefinition quantity = selection.Definition;
+            string quantityType = QuantityType(quantity);
+            writer.Append("                ").Append(quantityType).AppendLine(".Info,");
+        }
+
+        writer.AppendLine("            });");
+        writer.AppendLine();
+        writer.AppendLine("        public static global::System.Text.Json.Serialization.JsonConverterFactory JsonConverter { get; } =");
+        writer.AppendLine("            new GeneratedQuantityJsonConverterFactory();");
+        writer.AppendLine("    }");
+        writer.AppendLine();
+        writer.AppendLine("    internal sealed class GeneratedQuantityJsonConverterFactory : global::System.Text.Json.Serialization.JsonConverterFactory");
+        writer.AppendLine("    {");
+        writer.AppendLine("        public override bool CanConvert(global::System.Type typeToConvert) =>");
+        writer.AppendLine("            GeneratedQuantityRegistry.Instance.TryGet(typeToConvert, out _);");
+        writer.AppendLine();
+        writer.AppendLine("        public override global::System.Text.Json.Serialization.JsonConverter CreateConverter(");
+        writer.AppendLine("            global::System.Type typeToConvert,");
+        writer.AppendLine("            global::System.Text.Json.JsonSerializerOptions options)");
+        writer.AppendLine("        {");
+        foreach (QuantitySelection selection in selections)
+        {
+            string quantityType = QuantityType(selection.Definition);
+            writer.Append("            if (typeToConvert == typeof(").Append(quantityType).AppendLine("))");
+            writer.AppendLine("            {");
+            writer.Append("                return new global::UnitsNet.Modular.SourceGen.QuantityJsonConverter<")
+                .Append(quantityType).Append(">(GeneratedQuantityRegistry.Instance.Get(typeof(")
+                .Append(quantityType).AppendLine(")));");
+            writer.AppendLine("            }");
+        }
+
+        writer.AppendLine();
+        writer.AppendLine("            throw new global::System.NotSupportedException($\"Quantity type '{typeToConvert.FullName}' is not selected.\");");
+        writer.AppendLine("        }");
+        writer.AppendLine("    }");
+        writer.AppendLine("}");
+        return writer.ToString();
+    }
+
+    public static string EmitQuantityFacade(string facadeNamespace)
+    {
+        var writer = new StringBuilder();
+        writer.AppendLine("// <auto-generated />");
+        writer.AppendLine("#nullable enable");
+        writer.AppendLine();
+        if (facadeNamespace.Length > 0)
+        {
+            writer.Append("namespace ").Append(facadeNamespace).AppendLine();
+            writer.AppendLine("{");
+        }
+
+        string indent = facadeNamespace.Length > 0 ? "    " : string.Empty;
+        writer.Append(indent).AppendLine("public static partial class Quantity");
+        writer.Append(indent).AppendLine("{");
+        writer.Append(indent).AppendLine("    public static global::UnitsNet.QuantityRegistry Registry =>");
+        writer.Append(indent).AppendLine("        global::UnitsNet.GeneratedQuantityRegistry.Instance;");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static global::System.Collections.Generic.IReadOnlyCollection<string> Names =>");
+        writer.Append(indent).AppendLine("        Registry.Names;");
+        writer.Append(indent).AppendLine("    public static global::System.Collections.Generic.IReadOnlyList<global::UnitsNet.IQuantityDescriptor> Infos =>");
+        writer.Append(indent).AppendLine("        Registry.Quantities;");
+        writer.Append(indent).AppendLine("    public static global::System.Collections.Generic.IReadOnlyDictionary<string, global::UnitsNet.IQuantityDescriptor> ByName =>");
+        writer.Append(indent).AppendLine("        Registry.ByName;");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static global::UnitsNet.IQuantity<double> From(");
+        writer.Append(indent).AppendLine("        double value,");
+        writer.Append(indent).AppendLine("        string quantityName,");
+        writer.Append(indent).AppendLine("        string unitName) =>");
+        writer.Append(indent).AppendLine("        Registry.Create(value, quantityName, unitName);");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static global::UnitsNet.IQuantity<double> From(");
+        writer.Append(indent).AppendLine("        double value,");
+        writer.Append(indent).AppendLine("        string quantityName,");
+        writer.Append(indent).AppendLine("        global::UnitsNet.UnitSystem unitSystem) =>");
+        writer.Append(indent).AppendLine("        Registry.Create(value, quantityName, unitSystem);");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static global::UnitsNet.IQuantity<double> From(double value, global::System.Enum unit) =>");
+        writer.Append(indent).AppendLine("        Registry.Create(value, unit);");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static bool TryFrom(");
+        writer.Append(indent).AppendLine("        double value,");
+        writer.Append(indent).AppendLine("        string quantityName,");
+        writer.Append(indent).AppendLine("        string unitName,");
+        writer.Append(indent).AppendLine("        [global::System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out global::UnitsNet.IQuantity<double>? quantity) =>");
+        writer.Append(indent).AppendLine("        Registry.TryCreate(value, quantityName, unitName, out quantity);");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static bool TryFrom(");
+        writer.Append(indent).AppendLine("        double value,");
+        writer.Append(indent).AppendLine("        string quantityName,");
+        writer.Append(indent).AppendLine("        global::UnitsNet.UnitSystem? unitSystem,");
+        writer.Append(indent).AppendLine("        [global::System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out global::UnitsNet.IQuantity<double>? quantity) =>");
+        writer.Append(indent).AppendLine("        Registry.TryCreate(value, quantityName, unitSystem, out quantity);");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static bool TryFrom(");
+        writer.Append(indent).AppendLine("        double value,");
+        writer.Append(indent).AppendLine("        global::System.Enum? unit,");
+        writer.Append(indent).AppendLine("        [global::System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out global::UnitsNet.IQuantity<double>? quantity) =>");
+        writer.Append(indent).AppendLine("        Registry.TryCreate(value, unit, out quantity);");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static global::UnitsNet.IQuantity<double> Parse(");
+        writer.Append(indent).AppendLine("        global::System.Type quantityType,");
+        writer.Append(indent).AppendLine("        string quantityString) =>");
+        writer.Append(indent).AppendLine("        Parse(null, quantityType, quantityString);");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static global::UnitsNet.IQuantity<double> Parse(");
+        writer.Append(indent).AppendLine("        global::System.IFormatProvider? formatProvider,");
+        writer.Append(indent).AppendLine("        global::System.Type quantityType,");
+        writer.Append(indent).AppendLine("        string quantityString) =>");
+        writer.Append(indent).AppendLine("        Registry.Parse(quantityType, quantityString, formatProvider);");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static bool TryParse(");
+        writer.Append(indent).AppendLine("        global::System.Type quantityType,");
+        writer.Append(indent).AppendLine("        string? quantityString,");
+        writer.Append(indent).AppendLine("        [global::System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out global::UnitsNet.IQuantity<double>? quantity) =>");
+        writer.Append(indent).AppendLine("        TryParse(null, quantityType, quantityString, out quantity);");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static bool TryParse(");
+        writer.Append(indent).AppendLine("        global::System.IFormatProvider? formatProvider,");
+        writer.Append(indent).AppendLine("        global::System.Type quantityType,");
+        writer.Append(indent).AppendLine("        string? quantityString,");
+        writer.Append(indent).AppendLine("        [global::System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out global::UnitsNet.IQuantity<double>? quantity) =>");
+        writer.Append(indent).AppendLine("        Registry.TryParse(quantityType, quantityString, formatProvider, out quantity);");
+        writer.AppendLine();
+        writer.Append(indent).AppendLine("    public static global::System.Collections.Generic.IReadOnlyList<global::UnitsNet.IQuantityDescriptor> GetQuantitiesWithBaseDimensions(");
+        writer.Append(indent).AppendLine("        global::UnitsNet.BaseDimensions baseDimensions) =>");
+        writer.Append(indent).AppendLine("        Registry.FindByBaseDimensions(baseDimensions);");
+        writer.Append(indent).AppendLine("}");
+        if (facadeNamespace.Length > 0)
+        {
+            writer.AppendLine("}");
+        }
+
+        return writer.ToString();
+    }
+
+    public static string EmitExtensions(IReadOnlyList<QuantitySelection> selections)
+    {
+        var writer = new StringBuilder();
+        IReadOnlyDictionary<string, QuantitySelection> selectionsBySemanticId = selections
+            .GroupBy(selection => selection.Definition.SemanticId, StringComparer.Ordinal)
+            .ToDictionary(group => group.Key, group => group.First(), StringComparer.Ordinal);
+        writer.AppendLine("// <auto-generated />");
+        writer.AppendLine("#nullable enable");
+        foreach (IGrouping<string, QuantitySelection> namespaceGroup in selections
+                     .GroupBy(selection => selection.Definition.TargetNamespace, StringComparer.Ordinal)
+                     .OrderBy(group => group.Key, StringComparer.Ordinal))
+        {
+            writer.AppendLine();
+            writer.Append("namespace ").Append(namespaceGroup.Key).AppendLine();
+            writer.AppendLine("{");
+            writer.AppendLine("    public static class UnitsNetModularQuantityExtensions");
+            writer.AppendLine("    {");
+            foreach (QuantitySelection selection in namespaceGroup.OrderBy(
+                         item => item.Definition.Name,
+                         StringComparer.Ordinal))
+            {
+                QuantitySelection? affineOffset = selection.Definition.IsAffine
+                    ? selectionsBySemanticId[AffineOffsetSemanticId(selection.Definition)]
+                    : null;
+                EmitQuantityExtensions(writer, selection, affineOffset);
+            }
+
+            writer.AppendLine("    }");
+            writer.AppendLine("}");
+        }
+
+        return writer.ToString();
+    }
+
+    private static void EmitQuantityExtensions(
+        StringBuilder writer,
+        QuantitySelection selection,
+        QuantitySelection? affineOffset)
+    {
+        QuantityDefinition quantity = selection.Definition;
+        string quantityType = QuantityType(quantity);
+        string unitType = UnitType(quantity);
+        if (quantity.IsAffine)
+        {
+            writer.Append("        public static ").Append(quantityType).Append(" Average(this global::System.Collections.Generic.IEnumerable<")
+                .Append(quantityType).AppendLine("> quantities) =>");
+            writer.Append("            global::UnitsNet.AffineQuantityMath.Average<")
+                .Append(quantityType).Append(", ").Append(unitType).AppendLine(">(quantities);");
+            writer.Append("        public static ").Append(quantityType).Append(" Average(this global::System.Collections.Generic.IEnumerable<")
+                .Append(quantityType).Append("> quantities, ").Append(unitType).AppendLine(" unit) =>");
+            writer.AppendLine("            global::UnitsNet.AffineQuantityMath.Average(quantities, unit);");
+            string offsetType = QuantityType(affineOffset!.Definition);
+            writer.Append("        public static bool Equals(this ").Append(quantityType).Append(" quantity, ")
+                .Append(quantityType).Append(" other, ").Append(offsetType).AppendLine(" tolerance)");
+            writer.AppendLine("        {");
+            writer.AppendLine("            if (tolerance.Value < 0) throw new global::System.ArgumentOutOfRangeException(nameof(tolerance));");
+            writer.AppendLine("            return global::System.Math.Abs((quantity - other).As(tolerance.Unit)) <= tolerance.Value;");
+            writer.AppendLine("        }");
+            return;
+        }
+
+        if (quantity.IsLogarithmic)
+        {
+            EmitLogarithmicExtensions(writer, quantityType, unitType);
+            return;
+        }
+
+        writer.Append("        public static ").Append(quantityType).Append(" Sum(this global::System.Collections.Generic.IEnumerable<")
+            .Append(quantityType).AppendLine("> quantities) =>");
+        writer.AppendLine("            global::UnitsNet.QuantityMath.Sum(quantities);");
+        writer.Append("        public static ").Append(quantityType).Append(" Sum(this global::System.Collections.Generic.IEnumerable<")
+            .Append(quantityType).Append("> quantities, ").Append(unitType).AppendLine(" unit) =>");
+        writer.AppendLine("            global::UnitsNet.QuantityMath.Sum(quantities, unit);");
+        writer.Append("        public static ").Append(quantityType).Append(" Sum<TSource>(this global::System.Collections.Generic.IEnumerable<TSource> source, global::System.Func<TSource, ")
+            .Append(quantityType).AppendLine("> selector) =>");
+        writer.AppendLine("            global::UnitsNet.QuantityMath.Sum(global::System.Linq.Enumerable.Select(source, selector));");
+        writer.Append("        public static ").Append(quantityType).Append(" Sum<TSource>(this global::System.Collections.Generic.IEnumerable<TSource> source, global::System.Func<TSource, ")
+            .Append(quantityType).Append("> selector, ").Append(unitType).AppendLine(" unit) =>");
+        writer.AppendLine("            global::UnitsNet.QuantityMath.Sum(global::System.Linq.Enumerable.Select(source, selector), unit);");
+        writer.Append("        public static ").Append(quantityType).Append(" Average(this global::System.Collections.Generic.IEnumerable<")
+            .Append(quantityType).AppendLine("> quantities) =>");
+        writer.AppendLine("            global::UnitsNet.QuantityMath.Average(quantities);");
+        writer.Append("        public static ").Append(quantityType).Append(" Average(this global::System.Collections.Generic.IEnumerable<")
+            .Append(quantityType).Append("> quantities, ").Append(unitType).AppendLine(" unit) =>");
+        writer.AppendLine("            global::UnitsNet.QuantityMath.Average(quantities, unit);");
+        writer.Append("        public static ").Append(quantityType).Append(" Average<TSource>(this global::System.Collections.Generic.IEnumerable<TSource> source, global::System.Func<TSource, ")
+            .Append(quantityType).AppendLine("> selector) =>");
+        writer.AppendLine("            global::UnitsNet.QuantityMath.Average(global::System.Linq.Enumerable.Select(source, selector));");
+        writer.Append("        public static ").Append(quantityType).Append(" Average<TSource>(this global::System.Collections.Generic.IEnumerable<TSource> source, global::System.Func<TSource, ")
+            .Append(quantityType).Append("> selector, ").Append(unitType).AppendLine(" unit) =>");
+        writer.AppendLine("            global::UnitsNet.QuantityMath.Average(global::System.Linq.Enumerable.Select(source, selector), unit);");
+        writer.Append("        public static ").Append(quantityType).Append(" Abs(this ").Append(quantityType).AppendLine(" value) =>");
+        writer.Append("            ").Append(quantityType).AppendLine(".From(global::System.Math.Abs(value.Value), value.Unit);");
+        writer.Append("        public static bool Equals(this ").Append(quantityType).Append(" quantity, ").Append(quantityType)
+            .Append(" other, ").Append(quantityType).AppendLine(" tolerance)");
+        writer.AppendLine("        {");
+        writer.AppendLine("            if (tolerance.Value < 0) throw new global::System.ArgumentOutOfRangeException(nameof(tolerance));");
+        writer.AppendLine("            return global::System.Math.Abs(quantity.Value - other.As(quantity.Unit)) <= tolerance.As(quantity.Unit);");
+        writer.AppendLine("        }");
+    }
+
+    private static void EmitLogarithmicExtensions(StringBuilder writer, string quantityType, string unitType)
+    {
+        foreach (string operation in new[] { "Sum", "ArithmeticMean", "GeometricMean" })
+        {
+            writer.Append("        public static ").Append(quantityType).Append(' ').Append(operation)
+                .Append("(this global::System.Collections.Generic.IEnumerable<").Append(quantityType).AppendLine("> quantities) =>");
+            writer.Append("            global::UnitsNet.LogarithmicQuantityMath.").Append(operation).Append('<')
+                .Append(quantityType).Append(", ").Append(unitType).AppendLine(">(quantities);");
+            writer.Append("        public static ").Append(quantityType).Append(' ').Append(operation)
+                .Append("(this global::System.Collections.Generic.IEnumerable<").Append(quantityType).Append("> quantities, ")
+                .Append(unitType).AppendLine(" unit) =>");
+            writer.Append("            global::UnitsNet.LogarithmicQuantityMath.").Append(operation).Append('<')
+                .Append(quantityType).Append(", ").Append(unitType).AppendLine(">(quantities, unit);");
+            writer.Append("        public static ").Append(quantityType).Append(' ').Append(operation)
+                .Append("<TSource>(this global::System.Collections.Generic.IEnumerable<TSource> source, global::System.Func<TSource, ")
+                .Append(quantityType).AppendLine("> selector) =>");
+            writer.Append("            global::UnitsNet.LogarithmicQuantityMath.").Append(operation).Append('<')
+                .Append(quantityType).Append(", ").Append(unitType)
+                .AppendLine(">(global::System.Linq.Enumerable.Select(source, selector));");
+            writer.Append("        public static ").Append(quantityType).Append(' ').Append(operation)
+                .Append("<TSource>(this global::System.Collections.Generic.IEnumerable<TSource> source, global::System.Func<TSource, ")
+                .Append(quantityType).Append("> selector, ").Append(unitType).AppendLine(" unit) =>");
+            writer.Append("            global::UnitsNet.LogarithmicQuantityMath.").Append(operation).Append('<')
+                .Append(quantityType).Append(", ").Append(unitType)
+                .AppendLine(">(global::System.Linq.Enumerable.Select(source, selector), unit);");
+        }
+
+        writer.Append("        public static bool Equals(this ").Append(quantityType).Append(" quantity, ")
+            .Append(quantityType).Append(" other, ").Append(quantityType).AppendLine(" tolerance) =>");
+        writer.Append("            global::UnitsNet.LogarithmicQuantityMath.Equals<").Append(quantityType)
+            .Append(", ").Append(unitType).AppendLine(">(quantity, other, tolerance);");
+    }
+
+    private static string QuantityType(QuantityDefinition definition) =>
+        "global::" + definition.TargetNamespace + "." + definition.Name;
+
+    private static string UnitType(QuantityDefinition definition) =>
+        definition.TargetNamespace == "UnitsNet"
+            ? "global::UnitsNet.Units." + definition.Name + "Unit"
+            : "global::" + definition.TargetNamespace + "." + definition.Name + "Unit";
+
+    private static string Escape(string value) => value.Replace("\\", "\\\\").Replace("\"", "\\\"");
+
+    private static string AffineOffsetSemanticId(QuantityDefinition definition)
+    {
+        string offsetType = definition.AffineOffsetType!;
+        if (offsetType.Contains("."))
+        {
+            return offsetType;
+        }
+
+        int separator = definition.SemanticId.LastIndexOf('.');
+        return separator < 0
+            ? offsetType
+            : definition.SemanticId.Substring(0, separator + 1) + offsetType;
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/ModuleRequest.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/ModuleRequest.cs
new file mode 100644
index 0000000000..33c5d389a2
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/ModuleRequest.cs
@@ -0,0 +1,142 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+
+namespace UnitsNet.Modular.Generator;
+
+internal sealed class ModuleRequest
+{
+    public ModuleRequest(
+        string name,
+        string ownerNamespace,
+        string? targetNamespace,
+        ImmutableArray<ModuleSelection> selections,
+        bool referencesLegacyUnitsNet,
+        SourceLocation location)
+    {
+        Name = name;
+        OwnerNamespace = ownerNamespace;
+        TargetNamespace = targetNamespace;
+        Selections = selections;
+        ReferencesLegacyUnitsNet = referencesLegacyUnitsNet;
+        Location = location;
+        Fingerprint = string.Join(
+            "\n",
+            new[] { name, ownerNamespace, targetNamespace ?? string.Empty, referencesLegacyUnitsNet.ToString() }
+                .Concat(selections.Select(selection => selection.Fingerprint)));
+    }
+
+    public string Name { get; }
+
+    public string OwnerNamespace { get; }
+
+    public string? TargetNamespace { get; }
+
+    public string FacadeNamespace =>
+        !string.IsNullOrWhiteSpace(TargetNamespace)
+            ? TargetNamespace!
+            : Selections.Any(
+                selection => selection.SemanticId is not null &&
+                             BuiltInCatalog.TryGetBySemanticId(selection.SemanticId, out _))
+                ? "UnitsNet"
+                : OwnerNamespace;
+
+    public ImmutableArray<ModuleSelection> Selections { get; }
+
+    public bool ReferencesLegacyUnitsNet { get; }
+
+    public SourceLocation Location { get; }
+
+    public string Fingerprint { get; }
+}
+
+internal sealed class ModuleSelection
+{
+    public ModuleSelection(
+        string specName,
+        string? semanticId,
+        ImmutableArray<string> patterns,
+        bool hasUnitSet,
+        bool isDirect)
+    {
+        SpecName = specName;
+        SemanticId = semanticId;
+        Patterns = patterns;
+        HasUnitSet = hasUnitSet;
+        IsDirect = isDirect;
+        Fingerprint = string.Join(
+            "|",
+            specName,
+            semanticId ?? string.Empty,
+            hasUnitSet,
+            isDirect,
+            string.Join("\u001f", patterns));
+    }
+
+    public string SpecName { get; }
+
+    public string? SemanticId { get; }
+
+    public ImmutableArray<string> Patterns { get; }
+
+    public bool HasUnitSet { get; }
+
+    public bool IsDirect { get; }
+
+    public string Fingerprint { get; }
+}
+
+internal readonly struct SourceLocation
+{
+    public SourceLocation(string path, TextSpan sourceSpan, LinePositionSpan lineSpan)
+    {
+        Path = path;
+        SourceSpan = sourceSpan;
+        LineSpan = lineSpan;
+    }
+
+    public string Path { get; }
+
+    public TextSpan SourceSpan { get; }
+
+    public LinePositionSpan LineSpan { get; }
+
+    public Location ToLocation() => string.IsNullOrEmpty(Path)
+        ? Location.None
+        : Location.Create(Path, SourceSpan, LineSpan);
+
+    public static SourceLocation From(Location? location)
+    {
+        if (location is null || !location.IsInSource)
+        {
+            return default;
+        }
+
+        FileLinePositionSpan lineSpan = location.GetLineSpan();
+        return new SourceLocation(lineSpan.Path, location.SourceSpan, lineSpan.Span);
+    }
+}
+
+internal sealed class ModuleRequestComparer : IEqualityComparer<ModuleRequest>
+{
+    public static ModuleRequestComparer Instance { get; } = new();
+
+    public bool Equals(ModuleRequest? x, ModuleRequest? y) =>
+        ReferenceEquals(x, y) ||
+        x is not null && y is not null &&
+        string.Equals(x.Fingerprint, y.Fingerprint, StringComparison.Ordinal) &&
+        string.Equals(x.Location.Path, y.Location.Path, StringComparison.Ordinal) &&
+        x.Location.SourceSpan.Equals(y.Location.SourceSpan);
+
+    public int GetHashCode(ModuleRequest obj)
+    {
+        unchecked
+        {
+            int hash = StringComparer.Ordinal.GetHashCode(obj.Fingerprint);
+            hash = (hash * 397) ^ StringComparer.Ordinal.GetHashCode(obj.Location.Path ?? string.Empty);
+            return (hash * 397) ^ obj.Location.SourceSpan.GetHashCode();
+        }
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/PrefixExpander.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/PrefixExpander.cs
new file mode 100644
index 0000000000..0af83c7866
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/PrefixExpander.cs
@@ -0,0 +1,368 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class PrefixExpander
+{
+    private static readonly IReadOnlyDictionary<string, PrefixInfo> Prefixes = new Dictionary<string, PrefixInfo>(StringComparer.Ordinal)
+    {
+        ["Femto"] = new PrefixInfo("Femto", "f", 1e-15),
+        ["Pico"] = new PrefixInfo("Pico", "p", 1e-12),
+        ["Nano"] = new PrefixInfo("Nano", "n", 1e-9),
+        ["Micro"] = new PrefixInfo("Micro", "μ", 1e-6),
+        ["Milli"] = new PrefixInfo("Milli", "m", 1e-3),
+        ["Centi"] = new PrefixInfo("Centi", "c", 1e-2),
+        ["Deci"] = new PrefixInfo("Deci", "d", 1e-1),
+        ["Deca"] = new PrefixInfo("Deca", "da", 1e1),
+        ["Hecto"] = new PrefixInfo("Hecto", "h", 1e2),
+        ["Kilo"] = new PrefixInfo("Kilo", "k", 1e3),
+        ["Mega"] = new PrefixInfo("Mega", "M", 1e6),
+        ["Giga"] = new PrefixInfo("Giga", "G", 1e9),
+        ["Tera"] = new PrefixInfo("Tera", "T", 1e12),
+        ["Peta"] = new PrefixInfo("Peta", "P", 1e15),
+        ["Exa"] = new PrefixInfo("Exa", "E", 1e18),
+        ["Kibi"] = new PrefixInfo("Kibi", "Ki", 1024),
+        ["Mebi"] = new PrefixInfo("Mebi", "Mi", 1048576),
+        ["Gibi"] = new PrefixInfo("Gibi", "Gi", 1073741824),
+        ["Tebi"] = new PrefixInfo("Tebi", "Ti", 1099511627776),
+        ["Pebi"] = new PrefixInfo("Pebi", "Pi", 1125899906842624),
+        ["Exbi"] = new PrefixInfo("Exbi", "Ei", 1152921504606846976),
+    };
+
+    public static QuantityDefinition Expand(
+        QuantityDefinition quantity,
+        BaseUnitPrefixCatalog? baseUnitPrefixes = null)
+    {
+        if (TryExpand(quantity, baseUnitPrefixes, out QuantityDefinition? expanded, out string? error))
+        {
+            return expanded!;
+        }
+
+        throw new InvalidOperationException(error);
+    }
+
+    public static bool TryExpand(
+        QuantityDefinition quantity,
+        BaseUnitPrefixCatalog? baseUnitPrefixes,
+        out QuantityDefinition? expanded,
+        out string? error)
+    {
+        var units = new List<UnitDefinition>(quantity.Units);
+        foreach (UnitDefinition unit in quantity.Units)
+        {
+            foreach (string prefixName in unit.Prefixes)
+            {
+                if (!Prefixes.TryGetValue(prefixName, out PrefixInfo? prefix))
+                {
+                    expanded = null;
+                    error = $"Unknown prefix '{prefixName}' in {quantity.Id}.{unit.SingularName}.";
+                    return false;
+                }
+
+                string factor = prefix.Factor.ToString("R", CultureInfo.InvariantCulture);
+                UnitLocalizationDefinition[] localizations = unit.Localizations.Select(localization =>
+                {
+                    IReadOnlyList<string> abbreviations = localization.AbbreviationsForPrefixes.TryGetValue(prefixName, out IReadOnlyList<string>? configured)
+                        ? configured
+                        : localization.Abbreviations.Select(abbreviation => prefix.Symbol + abbreviation).ToArray();
+                    return new UnitLocalizationDefinition(localization.Culture, abbreviations);
+                }).ToArray();
+
+                BaseUnitsDefinition baseUnits = baseUnitPrefixes is null
+                    ? unit.BaseUnits.Rename(
+                        unit.SingularName,
+                        prefix.Name + LowerFirst(unit.SingularName))
+                    : GetPrefixedBaseUnits(
+                        quantity.BaseDimensions,
+                        unit.BaseUnits,
+                        prefixName,
+                        baseUnitPrefixes);
+                units.Add(new UnitDefinition(
+                    prefix.Name + LowerFirst(unit.SingularName),
+                    prefix.Name + LowerFirst(unit.PluralName),
+                    ConversionExpression.Substitute(
+                        unit.FromUnitToBaseExpression,
+                        $"x * {factor}"),
+                    $"({unit.FromBaseToUnitExpression}) / {factor}",
+                    baseUnits,
+                    localizations));
+            }
+        }
+
+        UnitDefinition[] distinct = units
+            .GroupBy(unit => unit.SingularName, StringComparer.Ordinal)
+            .Select(group => group.Last())
+            .ToArray();
+        expanded = new QuantityDefinition(
+            quantity.Name,
+            quantity.TargetNamespace,
+            quantity.BaseUnit,
+            distinct,
+            quantity.SourcePath,
+            quantity.IsLogarithmic,
+            quantity.LogarithmicScalingFactor,
+            quantity.SemanticId,
+            quantity.AffineOffsetType,
+            quantity.BaseDimensions,
+            quantity.Augmentations);
+        error = null;
+        return true;
+    }
+
+    private static string LowerFirst(string value)
+        => value.Length == 0 ? value : char.ToLowerInvariant(value[0]) + value.Substring(1);
+
+    private static BaseUnitsDefinition GetPrefixedBaseUnits(
+        BaseDimensionsDefinition dimensions,
+        BaseUnitsDefinition baseUnits,
+        string prefixName,
+        BaseUnitPrefixCatalog catalog)
+    {
+        if (baseUnits.IsUndefined)
+        {
+            return BaseUnitsDefinition.Undefined;
+        }
+
+        int[] exponents =
+        {
+            dimensions.Length,
+            dimensions.Mass,
+            dimensions.Time,
+            dimensions.Current,
+            dimensions.Temperature,
+            dimensions.Amount,
+            dimensions.LuminousIntensity,
+        };
+        foreach (int exponent in exponents
+                     .Where(value => value != 0)
+                     .Distinct()
+                     .OrderBy(Math.Abs)
+                     .ThenByDescending(value => value))
+        {
+            if (dimensions.Amount == exponent &&
+                catalog.TryApply(baseUnits.Amount, exponent, prefixName, out string? amount))
+            {
+                return Replace(baseUnits, amount: amount);
+            }
+
+            if (dimensions.Current == exponent &&
+                catalog.TryApply(baseUnits.Current, exponent, prefixName, out string? current))
+            {
+                return Replace(baseUnits, current: current);
+            }
+
+            if (dimensions.Length == exponent &&
+                catalog.TryApply(baseUnits.Length, exponent, prefixName, out string? length))
+            {
+                return Replace(baseUnits, length: length);
+            }
+
+            if (dimensions.LuminousIntensity == exponent &&
+                catalog.TryApply(
+                    baseUnits.LuminousIntensity,
+                    exponent,
+                    prefixName,
+                    out string? luminousIntensity))
+            {
+                return Replace(baseUnits, luminousIntensity: luminousIntensity);
+            }
+
+            if (dimensions.Mass == exponent &&
+                catalog.TryApply(baseUnits.Mass, exponent, prefixName, out string? mass))
+            {
+                return Replace(baseUnits, mass: mass);
+            }
+
+            if (dimensions.Temperature == exponent &&
+                catalog.TryApply(
+                    baseUnits.Temperature,
+                    exponent,
+                    prefixName,
+                    out string? temperature))
+            {
+                return Replace(baseUnits, temperature: temperature);
+            }
+
+            if (dimensions.Time == exponent &&
+                catalog.TryApply(baseUnits.Time, exponent, prefixName, out string? time))
+            {
+                return Replace(baseUnits, time: time);
+            }
+        }
+
+        return BaseUnitsDefinition.Undefined;
+    }
+
+    private static BaseUnitsDefinition Replace(
+        BaseUnitsDefinition source,
+        string? length = null,
+        string? mass = null,
+        string? time = null,
+        string? current = null,
+        string? temperature = null,
+        string? amount = null,
+        string? luminousIntensity = null) =>
+        new BaseUnitsDefinition(
+            length ?? source.Length,
+            mass ?? source.Mass,
+            time ?? source.Time,
+            current ?? source.Current,
+            temperature ?? source.Temperature,
+            amount ?? source.Amount,
+            luminousIntensity ?? source.LuminousIntensity);
+
+    private sealed class PrefixInfo
+    {
+        public PrefixInfo(string name, string symbol, double factor)
+        {
+            Name = name;
+            Symbol = symbol;
+            Factor = factor;
+        }
+
+        public string Name { get; }
+
+        public string Symbol { get; }
+
+        public double Factor { get; }
+    }
+
+    internal sealed class BaseUnitPrefixCatalog
+    {
+        private static readonly IReadOnlyDictionary<string, int> MetricExponents =
+            new Dictionary<string, int>(StringComparer.Ordinal)
+            {
+                ["Femto"] = -15,
+                ["Pico"] = -12,
+                ["Nano"] = -9,
+                ["Micro"] = -6,
+                ["Milli"] = -3,
+                ["Centi"] = -2,
+                ["Deci"] = -1,
+                ["Deca"] = 1,
+                ["Hecto"] = 2,
+                ["Kilo"] = 3,
+                ["Mega"] = 6,
+                ["Giga"] = 9,
+                ["Tera"] = 12,
+                ["Peta"] = 15,
+                ["Exa"] = 18,
+            };
+
+        private readonly IReadOnlyDictionary<string, PrefixScale> _scalesByUnit;
+        private readonly IReadOnlyDictionary<PrefixScale, string> _unitsByScale;
+
+        private BaseUnitPrefixCatalog(
+            IReadOnlyDictionary<string, PrefixScale> scalesByUnit,
+            IReadOnlyDictionary<PrefixScale, string> unitsByScale)
+        {
+            _scalesByUnit = scalesByUnit;
+            _unitsByScale = unitsByScale;
+        }
+
+        public static BaseUnitPrefixCatalog Create(IEnumerable<QuantityDefinition> definitions)
+        {
+            var scalesByUnit = new Dictionary<string, PrefixScale>(StringComparer.Ordinal);
+            var unitsByScale = new Dictionary<PrefixScale, string>();
+            foreach (QuantityDefinition definition in definitions.Where(IsBaseQuantity))
+            {
+                var generatedNames = new HashSet<string>(
+                    definition.Units
+                        .Where(unit => unit.Prefixes.Count > 0)
+                        .SelectMany(unit => unit.Prefixes.Select(
+                            prefix => prefix + LowerFirst(unit.SingularName))),
+                    StringComparer.Ordinal);
+                foreach (UnitDefinition unit in definition.Units.Where(
+                             unit => !generatedNames.Contains(unit.SingularName)))
+                {
+                    var unprefixed = new PrefixScale(unit.SingularName, 0);
+                    scalesByUnit[unit.SingularName] = unprefixed;
+                    unitsByScale[unprefixed] = unit.SingularName;
+                    foreach (string prefixName in unit.Prefixes)
+                    {
+                        if (!MetricExponents.TryGetValue(prefixName, out int exponent))
+                        {
+                            continue;
+                        }
+
+                        string prefixedName = prefixName + LowerFirst(unit.SingularName);
+                        var prefixed = new PrefixScale(unit.SingularName, exponent);
+                        scalesByUnit[prefixedName] = prefixed;
+                        unitsByScale[prefixed] = prefixedName;
+                    }
+                }
+            }
+
+            return new BaseUnitPrefixCatalog(scalesByUnit, unitsByScale);
+        }
+
+        public bool TryApply(
+            string? unitName,
+            int dimensionExponent,
+            string prefixName,
+            out string? prefixedUnitName)
+        {
+            if (unitName is not null &&
+                dimensionExponent != 0 &&
+                MetricExponents.TryGetValue(prefixName, out int prefixExponent) &&
+                prefixExponent % dimensionExponent == 0 &&
+                _scalesByUnit.TryGetValue(unitName, out PrefixScale current) &&
+                _unitsByScale.TryGetValue(
+                    new PrefixScale(
+                        current.BaseUnit,
+                        current.Exponent + (prefixExponent / dimensionExponent)),
+                    out string? selected))
+            {
+                prefixedUnitName = selected;
+                return true;
+            }
+
+            prefixedUnitName = null;
+            return false;
+        }
+
+        private static bool IsBaseQuantity(QuantityDefinition definition)
+        {
+            return definition.SemanticId == "UnitsNet.Length" ||
+                   definition.SemanticId == "UnitsNet.Mass" ||
+                   definition.SemanticId == "UnitsNet.Duration" ||
+                   definition.SemanticId == "UnitsNet.ElectricCurrent" ||
+                   definition.SemanticId == "UnitsNet.Temperature" ||
+                   definition.SemanticId == "UnitsNet.AmountOfSubstance" ||
+                   definition.SemanticId == "UnitsNet.LuminousIntensity";
+        }
+
+        private sealed class PrefixScale : IEquatable<PrefixScale>
+        {
+            public PrefixScale(string baseUnit, int exponent)
+            {
+                BaseUnit = baseUnit;
+                Exponent = exponent;
+            }
+
+            public string BaseUnit { get; }
+
+            public int Exponent { get; }
+
+            public bool Equals(PrefixScale? other) =>
+                other is not null &&
+                Exponent == other.Exponent &&
+                string.Equals(BaseUnit, other.BaseUnit, StringComparison.Ordinal);
+
+            public override bool Equals(object? obj) => Equals(obj as PrefixScale);
+
+            public override int GetHashCode()
+            {
+                unchecked
+                {
+                    return (StringComparer.Ordinal.GetHashCode(BaseUnit) * 397) ^ Exponent;
+                }
+            }
+        }
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/QuantityEmitter.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/QuantityEmitter.cs
new file mode 100644
index 0000000000..809c7428f0
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/QuantityEmitter.cs
@@ -0,0 +1,537 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class QuantityEmitter
+{
+    private const string NumericFormatStringSyntaxAttribute =
+        "global::System.Diagnostics.CodeAnalysis.StringSyntax(" +
+        "global::System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.NumericFormat)";
+
+    public static string Emit(
+        QuantitySelection selection,
+        IReadOnlyList<EmittedQuantityRelation> relationships,
+        QuantitySelection? affineOffset,
+        IReadOnlyDictionary<string, QuantitySelection> selectionsBySemanticId)
+    {
+        QuantityDefinition quantity = selection.Definition;
+        string unitTypeName = quantity.Name + "Unit";
+        bool unitsNetCompatibility = quantity.TargetNamespace == "UnitsNet";
+        string unitType = unitsNetCompatibility
+            ? "global::UnitsNet.Units." + unitTypeName
+            : unitTypeName;
+        var writer = new StringBuilder();
+
+        writer.AppendLine("// <auto-generated />");
+        writer.AppendLine("#nullable enable");
+        writer.AppendLine();
+        if (unitsNetCompatibility)
+        {
+            writer.AppendLine("namespace UnitsNet.Units");
+            writer.AppendLine("{");
+        }
+        else
+        {
+            writer.Append("namespace ").Append(quantity.TargetNamespace).AppendLine(";");
+            writer.AppendLine();
+        }
+
+        writer.Append("public enum ").Append(unitTypeName).AppendLine();
+        writer.AppendLine("{");
+        IReadOnlyDictionary<string, int> definitionIndexes = quantity.Units
+            .Select((unit, index) => new { unit.SingularName, Index = index })
+            .ToDictionary(item => item.SingularName, item => item.Index, StringComparer.Ordinal);
+        foreach (UnitDefinition unit in selection.Units)
+        {
+            int definitionIndex = definitionIndexes[unit.SingularName];
+            int enumValue = BuiltInUnitEnumValues.TryGet(quantity.SemanticId, unit.SingularName, out int stableValue)
+                ? stableValue
+                : definitionIndex + 1;
+            writer.Append("    ").Append(unit.SingularName).Append(" = ")
+                .Append(enumValue.ToString(CultureInfo.InvariantCulture)).AppendLine(",");
+        }
+
+        writer.AppendLine("}");
+        writer.AppendLine();
+        if (unitsNetCompatibility)
+        {
+            writer.AppendLine("}");
+            writer.AppendLine();
+            writer.AppendLine("namespace UnitsNet");
+            writer.AppendLine("{");
+        }
+
+        writer.Append("public readonly partial struct ").Append(quantity.Name).Append(" : ");
+        if (quantity.IsAffine)
+        {
+            writer.Append("global::UnitsNet.IAffineQuantity<").Append(quantity.Name).Append(", ")
+                .Append(unitType).Append(", ").Append(QuantityType(affineOffset!.Definition)).Append(">, ");
+        }
+        else
+        {
+            string capabilityInterface = quantity.IsLogarithmic
+                ? "global::UnitsNet.ILogarithmicQuantity<"
+                : "global::UnitsNet.ILinearQuantity<";
+            writer.Append(capabilityInterface).Append(quantity.Name).Append(", ").Append(unitType).Append(">, ");
+        }
+        writer
+            .Append("global::System.IEquatable<").Append(quantity.Name).Append(">, ")
+            .Append("global::System.IComparable<").Append(quantity.Name).Append(">, ")
+            .AppendLine("global::System.IComparable");
+        writer.AppendLine("#if NET8_0_OR_GREATER");
+        writer.Append("    , global::System.IParsable<").Append(quantity.Name).AppendLine(">");
+        writer.Append("    , global::System.Numerics.IComparisonOperators<").Append(quantity.Name).Append(", ").Append(quantity.Name).AppendLine(", bool>");
+        if (!quantity.IsAffine)
+        {
+            writer.Append("    , global::System.Numerics.IDivisionOperators<").Append(quantity.Name).Append(", ")
+                .Append(quantity.Name).AppendLine(", double>");
+        }
+        writer.AppendLine("#endif");
+        writer.AppendLine("{");
+        writer.Append("    private static readonly QuantityMetadata Metadata = new QuantityMetadata();").AppendLine();
+        writer.AppendLine("    private readonly double _value;");
+        writer.Append("    private readonly ").Append(unitType).AppendLine(" _unit;");
+        writer.AppendLine();
+        writer.Append("    public ").Append(quantity.Name).Append("(double value, ").Append(unitType).AppendLine(" unit)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        _value = value;");
+        writer.AppendLine("        _unit = unit;");
+        writer.AppendLine("        _ = global::UnitsNet.Modular.SourceGen.QuantityOperations.GetBaseValue(value, unit, Metadata);");
+        writer.AppendLine("    }");
+        writer.Append("    public ").Append(quantity.Name)
+            .AppendLine("(double value, global::UnitsNet.UnitSystem unitSystem)");
+        writer.AppendLine("        : this(value, global::UnitsNet.Modular.SourceGen.QuantityOperations.GetUnit(unitSystem, Metadata))");
+        writer.AppendLine("    {");
+        writer.AppendLine("    }");
+        writer.AppendLine();
+        writer.Append("    public static ").Append(quantity.Name).Append(" From(double value, ")
+            .Append(unitType).AppendLine(" unit) => new(value, unit);");
+        writer.Append("    public static ").Append(quantity.Name)
+            .AppendLine(" From(double value, global::UnitsNet.UnitSystem unitSystem) => new(value, unitSystem);");
+        writer.Append("    public static double Convert(double value, ").Append(unitType).Append(" fromUnit, ")
+            .Append(unitType).AppendLine(" toUnit) =>");
+        writer.AppendLine("        global::UnitsNet.Modular.SourceGen.QuantityOperations.Convert(value, fromUnit, toUnit, Metadata);");
+        writer.AppendLine();
+        writer.AppendLine("    public double Value => _value;");
+        writer.Append("    public ").Append(unitType).AppendLine(" Unit => _unit == default ? Info.BaseUnit.Value : _unit;");
+        writer.Append("    public static global::UnitsNet.QuantityInfo<").Append(quantity.Name).Append(", ")
+            .Append(unitType).Append("> Info { get; } = new(")
+            .Append("new global::UnitsNet.QuantityId(\"").Append(Escape(quantity.SemanticId))
+            .AppendLine("\"), Metadata);");
+        writer.Append("    internal static ").Append(unitType).AppendLine(" BaseUnit => Info.BaseUnit.Value;");
+        writer.Append("    public static ").Append(quantity.Name).AppendLine(" Zero => From(0, Info.BaseUnit.Value);");
+        if (quantity.IsLogarithmic)
+        {
+            writer.Append("    public static double LogarithmicScalingFactor => ")
+                .Append((10 * quantity.LogarithmicScalingFactor).ToString("R", CultureInfo.InvariantCulture))
+                .AppendLine(";");
+        }
+
+        writer.AppendLine("    internal double BaseValue => global::UnitsNet.Modular.SourceGen.QuantityOperations.GetBaseValue(_value, Unit, Metadata);");
+        writer.AppendLine();
+
+        foreach (UnitDefinition unit in selection.Units)
+        {
+            writer.Append("    public static ").Append(quantity.Name).Append(" From").Append(unit.PluralName).Append("(double value) => new ")
+                .Append(quantity.Name).Append("(value, ").Append(unitType).Append('.').Append(unit.SingularName).AppendLine(");");
+            writer.Append("    public double ").Append(unit.PluralName).Append(" => As(").Append(unitType).Append('.').Append(unit.SingularName).AppendLine(");");
+        }
+
+        writer.AppendLine();
+        writer.Append("    public double As(").Append(unitType).AppendLine(" unit) =>");
+        writer.AppendLine("        Convert(_value, Unit, unit);");
+        writer.AppendLine("    public double As(global::UnitsNet.UnitSystem unitSystem) =>");
+        writer.AppendLine("        As(global::UnitsNet.Modular.SourceGen.QuantityOperations.GetUnit(unitSystem, Metadata));");
+        writer.AppendLine();
+        writer.Append("    public ").Append(quantity.Name).Append(" ToUnit(").Append(unitType).AppendLine(" unit) => new(As(unit), unit);");
+        writer.Append("    public ").Append(quantity.Name)
+            .AppendLine(" ToUnit(global::UnitsNet.UnitSystem unitSystem)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        var unit = global::UnitsNet.Modular.SourceGen.QuantityOperations.GetUnit(unitSystem, Metadata);");
+        writer.Append("        return new ").Append(quantity.Name).AppendLine("(As(unit), unit);");
+        writer.AppendLine("    }");
+        writer.AppendLine();
+        writer.Append("    public static string GetAbbreviation(").Append(unitType).AppendLine(" unit) =>");
+        writer.AppendLine("        GetAbbreviation(unit, null);");
+        writer.Append("    public static string GetAbbreviation(").Append(unitType)
+            .AppendLine(" unit, global::System.IFormatProvider? formatProvider) =>");
+        writer.AppendLine("        global::UnitsNet.Modular.SourceGen.QuantityOperations.GetAbbreviation(unit, formatProvider, Metadata);");
+        writer.AppendLine();
+        writer.Append("    public static ").Append(quantity.Name).AppendLine(" Parse(string text) => Parse(text, null);");
+        writer.Append("    public static ").Append(quantity.Name).AppendLine(" Parse(string text, global::System.IFormatProvider? formatProvider)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        if (!global::UnitsNet.Modular.SourceGen.QuantityOperations.TryParse(text, formatProvider, Metadata, out double value, out var unit))");
+        writer.AppendLine("        {");
+        writer.Append("            throw new global::System.FormatException(\"Could not parse ").Append(Escape(quantity.Name)).AppendLine(".\");");
+        writer.AppendLine("        }");
+        writer.AppendLine();
+        writer.Append("        return new ").Append(quantity.Name).AppendLine("(value, unit);");
+        writer.AppendLine("    }");
+        writer.AppendLine();
+        writer.Append("    public static bool TryParse(string? text, out ").Append(quantity.Name).AppendLine(" quantity)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        if (global::UnitsNet.Modular.SourceGen.QuantityOperations.TryParse(text, null, Metadata, out double value, out var unit))");
+        writer.AppendLine("        {");
+        writer.Append("            quantity = new ").Append(quantity.Name).AppendLine("(value, unit);");
+        writer.AppendLine("            return true;");
+        writer.AppendLine("        }");
+        writer.AppendLine();
+        writer.AppendLine("        quantity = default;");
+        writer.AppendLine("        return false;");
+        writer.AppendLine("    }");
+        writer.AppendLine("#if NET8_0_OR_GREATER");
+        writer.Append("    public static bool TryParse(string? text, global::System.IFormatProvider? formatProvider, out ").Append(quantity.Name).AppendLine(" quantity)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        if (global::UnitsNet.Modular.SourceGen.QuantityOperations.TryParse(text, formatProvider, Metadata, out double value, out var unit))");
+        writer.AppendLine("        {");
+        writer.Append("            quantity = new ").Append(quantity.Name).AppendLine("(value, unit);");
+        writer.AppendLine("            return true;");
+        writer.AppendLine("        }");
+        writer.AppendLine();
+        writer.AppendLine("        quantity = default;");
+        writer.AppendLine("        return false;");
+        writer.AppendLine("    }");
+        writer.AppendLine("#endif");
+        writer.AppendLine();
+        writer.Append("    public static ").Append(unitType).AppendLine(" ParseUnit(string text) => ParseUnit(text, null);");
+        writer.Append("    public static ").Append(unitType)
+            .AppendLine(" ParseUnit(string text, global::System.IFormatProvider? formatProvider)");
+        writer.AppendLine("    {");
+        writer.AppendLine("        if (TryParseUnit(text, formatProvider, out var unit))");
+        writer.AppendLine("        {");
+        writer.AppendLine("            return unit;");
+        writer.AppendLine("        }");
+        writer.AppendLine();
+        writer.Append("        throw new global::System.FormatException(\"Could not parse ").Append(Escape(unitTypeName))
+            .AppendLine(".\");");
+        writer.AppendLine("    }");
+        writer.Append("    public static bool TryParseUnit(string? text, out ").Append(unitType)
+            .AppendLine(" unit) => TryParseUnit(text, null, out unit);");
+        writer.Append("    public static bool TryParseUnit(string? text, global::System.IFormatProvider? formatProvider, out ")
+            .Append(unitType).AppendLine(" unit) =>");
+        writer.AppendLine("        global::UnitsNet.Modular.SourceGen.QuantityOperations.TryParseUnit(text, formatProvider, Metadata, out unit);");
+        writer.AppendLine();
+        writer.Append("    public int CompareTo(").Append(quantity.Name).AppendLine(" other) => BaseValue.CompareTo(other.BaseValue);");
+        writer.Append("    public int CompareTo(object? obj) => obj is ").Append(quantity.Name)
+            .AppendLine(" other ? CompareTo(other) : throw new global::System.ArgumentException(\"Object must be the same quantity type.\", nameof(obj));");
+        writer.Append("    public bool Equals(").Append(quantity.Name)
+            .AppendLine(" other) => BaseValue.Equals(other.BaseValue);");
+        writer.Append("    public override bool Equals(object? obj) => obj is ").Append(quantity.Name).AppendLine(" other && Equals(other);");
+        writer.AppendLine("    public override int GetHashCode() => BaseValue.GetHashCode();");
+        writer.AppendLine("    public override string ToString() => ToString(null, null);");
+        writer.AppendLine("    public string ToString(global::System.IFormatProvider? formatProvider) => ToString(null, formatProvider);");
+        writer.AppendLine("    public string ToString(");
+        writer.Append("        [").Append(NumericFormatStringSyntaxAttribute).AppendLine("]");
+        writer.AppendLine("        string? format) => ToString(format, null);");
+        writer.AppendLine("    public string ToString(");
+        writer.Append("        [").Append(NumericFormatStringSyntaxAttribute).AppendLine("]");
+        writer.AppendLine("        string? format,");
+        writer.AppendLine("        global::System.IFormatProvider? formatProvider) =>");
+        writer.AppendLine("        global::UnitsNet.Modular.SourceGen.QuantityOperations.Format(_value, Unit, format, formatProvider, Metadata);");
+        writer.AppendLine();
+        if (quantity.IsLogarithmic)
+        {
+            EmitLogarithmicOperators(writer, quantity.Name, quantity.LogarithmicScalingFactor);
+        }
+        else if (quantity.IsAffine)
+        {
+            EmitAffineOperators(writer, selection, affineOffset!);
+        }
+        else
+        {
+            writer.Append("    public static ").Append(quantity.Name).Append(" operator -(").Append(quantity.Name)
+                .AppendLine(" quantity) => new(-quantity.Value, quantity.Unit);");
+            writer.Append("    public static ").Append(quantity.Name).Append(" operator +(").Append(quantity.Name).Append(" left, ").Append(quantity.Name)
+                .AppendLine(" right) => new(left.Value + right.As(left.Unit), left.Unit);");
+            writer.Append("    public static ").Append(quantity.Name).Append(" operator -(").Append(quantity.Name).Append(" left, ").Append(quantity.Name)
+                .AppendLine(" right) => new(left.Value - right.As(left.Unit), left.Unit);");
+            writer.Append("    public static ").Append(quantity.Name).Append(" operator *(").Append(quantity.Name)
+                .AppendLine(" quantity, double scalar) => new(quantity.Value * scalar, quantity.Unit);");
+            writer.Append("    public static ").Append(quantity.Name).Append(" operator *(double scalar, ").Append(quantity.Name)
+                .AppendLine(" quantity) => quantity * scalar;");
+            writer.Append("    public static ").Append(quantity.Name).Append(" operator /(").Append(quantity.Name)
+                .AppendLine(" quantity, double scalar) => new(quantity.Value / scalar, quantity.Unit);");
+            writer.Append("    public static double operator /(").Append(quantity.Name).Append(" left, ")
+                .Append(quantity.Name).AppendLine(" right) => left.Value / right.As(left.Unit);");
+        }
+
+        writer.Append("    public static bool operator ==(").Append(quantity.Name).Append(" left, ").Append(quantity.Name).AppendLine(" right) => left.Equals(right);");
+        writer.Append("    public static bool operator !=(").Append(quantity.Name).Append(" left, ").Append(quantity.Name).AppendLine(" right) => !left.Equals(right);");
+        writer.Append("    public static bool operator <(").Append(quantity.Name).Append(" left, ").Append(quantity.Name).AppendLine(" right) => left.CompareTo(right) < 0;");
+        writer.Append("    public static bool operator >(").Append(quantity.Name).Append(" left, ").Append(quantity.Name).AppendLine(" right) => left.CompareTo(right) > 0;");
+        writer.Append("    public static bool operator <=(").Append(quantity.Name).Append(" left, ").Append(quantity.Name).AppendLine(" right) => left.CompareTo(right) <= 0;");
+        writer.Append("    public static bool operator >=(").Append(quantity.Name).Append(" left, ").Append(quantity.Name).AppendLine(" right) => left.CompareTo(right) >= 0;");
+
+        BuiltInAugmentationEmitter.Emit(writer, selection, unitType, selectionsBySemanticId);
+        EmitRelationships(writer, relationships);
+
+        writer.AppendLine();
+        writer.Append("    private sealed class QuantityMetadata : global::UnitsNet.Modular.SourceGen.IQuantityMetadata<")
+            .Append(quantity.Name).Append(", ").Append(unitType).AppendLine(">");
+        writer.AppendLine("    {");
+        writer.Append("        private static readonly global::UnitsNet.UnitInfo<").Append(unitType).AppendLine(">[] AllUnits =");
+        writer.AppendLine("        {");
+        foreach (UnitDefinition unit in selection.Units)
+        {
+            writer.Append("            new global::UnitsNet.UnitInfo<").Append(unitType).Append(">(")
+                .Append(unitType).Append('.').Append(unit.SingularName).Append(", \"").Append(Escape(unit.SingularName))
+                .Append("\", \"").Append(Escape(unit.PluralName)).Append("\", ");
+            EmitBaseUnits(writer, unit.BaseUnits);
+            foreach (UnitLocalizationDefinition localization in unit.Localizations)
+            {
+                writer.Append(", new global::UnitsNet.UnitLocalization(\"").Append(Escape(localization.Culture)).Append('"');
+                foreach (string abbreviation in localization.Abbreviations)
+                {
+                    writer.Append(", \"").Append(Escape(abbreviation)).Append('"');
+                }
+
+                writer.Append(')');
+            }
+
+            writer.AppendLine("),");
+        }
+
+        writer.AppendLine("        };");
+        writer.AppendLine();
+        writer.Append("        public string Name => \"").Append(Escape(quantity.Name)).AppendLine("\";");
+        writer.Append("        public ").Append(unitType).Append(" BaseUnit => ").Append(unitType).Append('.').Append(quantity.BaseUnit).AppendLine(";");
+        writer.Append("        public global::System.Collections.Generic.IReadOnlyList<global::UnitsNet.UnitInfo<")
+            .Append(unitType).AppendLine(">> Units => AllUnits;");
+        BaseDimensionsDefinition dimensions = quantity.BaseDimensions;
+        writer.AppendLine("        public global::UnitsNet.BaseDimensions BaseDimensions { get; } = new(");
+        writer.Append("            ").Append(dimensions.Length.ToString(CultureInfo.InvariantCulture)).Append(", ")
+            .Append(dimensions.Mass.ToString(CultureInfo.InvariantCulture)).Append(", ")
+            .Append(dimensions.Time.ToString(CultureInfo.InvariantCulture)).Append(", ")
+            .Append(dimensions.Current.ToString(CultureInfo.InvariantCulture)).Append(", ")
+            .Append(dimensions.Temperature.ToString(CultureInfo.InvariantCulture)).Append(", ")
+            .Append(dimensions.Amount.ToString(CultureInfo.InvariantCulture)).Append(", ")
+            .Append(dimensions.LuminousIntensity.ToString(CultureInfo.InvariantCulture)).AppendLine(");");
+        writer.AppendLine();
+        writer.Append("        public double ToBase(double x, ").Append(unitType).AppendLine(" unit) => unit switch");
+        writer.AppendLine("        {");
+        foreach (UnitDefinition unit in selection.Units)
+        {
+            writer.Append("            ").Append(unitType).Append('.').Append(unit.SingularName).Append(" => ")
+                .Append(unit.FromUnitToBaseExpression).AppendLine(",");
+        }
+
+        writer.Append("            _ => throw new global::System.ArgumentOutOfRangeException(nameof(unit), unit, \"Unit is not generated for ")
+            .Append(Escape(quantity.Name)).AppendLine(".\"),");
+        writer.AppendLine("        };");
+        writer.AppendLine();
+        writer.Append("        public double FromBase(double x, ").Append(unitType).AppendLine(" unit) => unit switch");
+        writer.AppendLine("        {");
+        foreach (UnitDefinition unit in selection.Units)
+        {
+            writer.Append("            ").Append(unitType).Append('.').Append(unit.SingularName).Append(" => ")
+                .Append(unit.FromBaseToUnitExpression).AppendLine(",");
+        }
+
+        writer.Append("            _ => throw new global::System.ArgumentOutOfRangeException(nameof(unit), unit, \"Unit is not generated for ")
+            .Append(Escape(quantity.Name)).AppendLine(".\"),");
+        writer.AppendLine("        };");
+        writer.AppendLine();
+        writer.Append("        public ").Append(quantity.Name)
+            .AppendLine(" Parse(string text, global::System.IFormatProvider? formatProvider) =>");
+        writer.Append("            ").Append(quantity.Name).AppendLine(".Parse(text, formatProvider);");
+        writer.Append("        public bool TryParse(string? text, global::System.IFormatProvider? formatProvider, out ")
+            .Append(quantity.Name).AppendLine(" quantity) =>");
+        writer.Append("            ").Append(quantity.Name).AppendLine(".TryParse(text, formatProvider, out quantity);");
+        writer.AppendLine("    }");
+        writer.AppendLine("}");
+        if (unitsNetCompatibility)
+        {
+            writer.AppendLine("}");
+        }
+
+        return writer.ToString();
+    }
+
+    private static void EmitRelationships(
+        StringBuilder writer,
+        IReadOnlyList<EmittedQuantityRelation> relationships)
+    {
+        foreach (EmittedQuantityRelation relationship in relationships)
+        {
+            if (relationship.Operator is "*" or "/" &&
+                relationship.Result is null &&
+                relationship.Left is not null &&
+                relationship.Right is not null)
+            {
+                string scalarLeftValue = ConversionExpression.Substitute(
+                    relationship.LeftUnit!.FromBaseToUnitExpression,
+                    "left.BaseValue");
+                string scalarRightValue = ConversionExpression.Substitute(
+                    relationship.RightUnit!.FromBaseToUnitExpression,
+                    "right.BaseValue");
+                writer.Append("    public static double operator *(")
+                    .Append(QuantityType(relationship.Left.Definition)).Append(" left, ")
+                    .Append(QuantityType(relationship.Right.Definition)).Append(" right) => (")
+                    .Append(scalarLeftValue).Append(") ").Append(relationship.Operator).Append(" (")
+                    .Append(scalarRightValue).AppendLine(");");
+                continue;
+            }
+
+            if (relationship.Operator == "/" &&
+                relationship.Left is null &&
+                relationship.Result is not null &&
+                relationship.Right is not null)
+            {
+                string scalarRightValue = ConversionExpression.Substitute(
+                    relationship.RightUnit!.FromBaseToUnitExpression,
+                    "right.BaseValue");
+                string scalarResultValue = "left / (" + scalarRightValue + ")";
+                writer.Append("    public static ").Append(QuantityType(relationship.Result.Definition))
+                    .Append(" operator /(double left, ")
+                    .Append(QuantityType(relationship.Right.Definition)).Append(" right) => ")
+                    .Append(ConstructFromRelationUnit(
+                        relationship.Result,
+                        relationship.ResultUnit!,
+                        scalarResultValue))
+                    .AppendLine(";");
+                continue;
+            }
+
+            QuantitySelection left = relationship.Left!;
+            QuantitySelection right = relationship.Right!;
+            UnitDefinition leftUnit = relationship.LeftUnit!;
+            UnitDefinition rightUnit = relationship.RightUnit!;
+            string leftType = QuantityType(left.Definition);
+            string rightType = QuantityType(right.Definition);
+            string leftValue = ConversionExpression.Substitute(
+                leftUnit.FromBaseToUnitExpression,
+                relationship.Operator == "inverse" ? "BaseValue" : "left.BaseValue");
+            string rightValue = ConversionExpression.Substitute(
+                rightUnit.FromBaseToUnitExpression,
+                "right.BaseValue");
+            if (relationship.Operator == "inverse")
+            {
+                string inverseValue = "1 / (" + leftValue + ")";
+                writer.Append("    public ").Append(rightType).Append(" Inverse() => ")
+                    .Append(ConstructFromRelationUnit(
+                        right,
+                        rightUnit,
+                        inverseValue))
+                    .AppendLine(";");
+                continue;
+            }
+
+            QuantitySelection result = relationship.Result!;
+            string relationValue = "(" + leftValue + ") " + relationship.Operator + " (" + rightValue + ")";
+            writer.Append("    public static ").Append(QuantityType(result.Definition)).Append(" operator ")
+                .Append(relationship.Operator).Append('(').Append(leftType).Append(" left, ")
+                .Append(rightType).Append(" right) => ")
+                .Append(ConstructFromRelationUnit(result, relationship.ResultUnit!, relationValue))
+                .AppendLine(";");
+        }
+    }
+
+    private static string ConstructFromRelationUnit(
+        QuantitySelection result,
+        UnitDefinition relationUnit,
+        string value)
+    {
+        string baseValue = ConversionExpression.Substitute(relationUnit.FromUnitToBaseExpression, value);
+        return "new " + QuantityType(result.Definition) + "(" + baseValue + ", " +
+               UnitType(result.Definition) + "." + result.Definition.BaseUnit + ")";
+    }
+
+    private static string QuantityType(QuantityDefinition definition) =>
+        "global::" + definition.TargetNamespace + "." + definition.Name;
+
+    private static string UnitType(QuantityDefinition definition) =>
+        definition.TargetNamespace == "UnitsNet"
+            ? "global::UnitsNet.Units." + definition.Name + "Unit"
+            : "global::" + definition.TargetNamespace + "." + definition.Name + "Unit";
+
+    private static void EmitBaseUnits(StringBuilder writer, BaseUnitsDefinition baseUnits)
+    {
+        if (baseUnits.IsUndefined)
+        {
+            writer.Append("global::UnitsNet.BaseUnits.Undefined");
+            return;
+        }
+
+        writer.Append("new global::UnitsNet.BaseUnits(");
+        AppendBaseUnit(writer, "length", baseUnits.Length);
+        AppendBaseUnit(writer, "mass", baseUnits.Mass);
+        AppendBaseUnit(writer, "time", baseUnits.Time);
+        AppendBaseUnit(writer, "current", baseUnits.Current);
+        AppendBaseUnit(writer, "temperature", baseUnits.Temperature);
+        AppendBaseUnit(writer, "amount", baseUnits.Amount);
+        AppendBaseUnit(writer, "luminousIntensity", baseUnits.LuminousIntensity);
+        writer.Length -= 2;
+        writer.Append(')');
+    }
+
+    private static void AppendBaseUnit(StringBuilder writer, string parameterName, string? unitName)
+    {
+        if (unitName is not null)
+        {
+            writer.Append(parameterName).Append(": \"").Append(Escape(unitName)).Append("\", ");
+        }
+    }
+
+    private static void EmitLogarithmicOperators(
+        StringBuilder writer,
+        string quantityName,
+        double logarithmicScalingFactor)
+    {
+        string scalingFactor = (10 * logarithmicScalingFactor).ToString("R", CultureInfo.InvariantCulture);
+        writer.Append("    public static ").Append(quantityName).Append(" operator -(").Append(quantityName)
+            .AppendLine(" quantity) => new(-quantity.Value, quantity.Unit);");
+        writer.Append("    public static ").Append(quantityName).Append(" operator +(").Append(quantityName).Append(" left, ")
+            .Append(quantityName).Append(" right) => new(").Append(scalingFactor)
+            .Append(" * global::System.Math.Log10(global::System.Math.Pow(10, left.Value / ")
+            .Append(scalingFactor)
+            .Append(") + global::System.Math.Pow(10, right.As(left.Unit) / ")
+            .Append(scalingFactor).AppendLine(")), left.Unit);");
+        writer.Append("    public static ").Append(quantityName).Append(" operator -(").Append(quantityName).Append(" left, ")
+            .Append(quantityName).Append(" right) => new(").Append(scalingFactor)
+            .Append(" * global::System.Math.Log10(global::System.Math.Pow(10, left.Value / ")
+            .Append(scalingFactor)
+            .Append(") - global::System.Math.Pow(10, right.As(left.Unit) / ")
+            .Append(scalingFactor).AppendLine(")), left.Unit);");
+        writer.AppendLine("    /// <summary>Performs logarithmic multiplication by adding the scalar to the stored logarithmic value.</summary>");
+        writer.Append("    public static ").Append(quantityName).Append(" operator *(").Append(quantityName)
+            .AppendLine(" quantity, double scalar) => new(quantity.Value + scalar, quantity.Unit);");
+        writer.AppendLine("    /// <summary>Performs commutative logarithmic multiplication by adding the scalar to the stored logarithmic value.</summary>");
+        writer.Append("    public static ").Append(quantityName).Append(" operator *(").Append("double scalar, ")
+            .Append(quantityName).AppendLine(" quantity) => quantity * scalar;");
+        writer.AppendLine("    /// <summary>Performs logarithmic division by subtracting the scalar from the stored logarithmic value.</summary>");
+        writer.Append("    public static ").Append(quantityName).Append(" operator /(").Append(quantityName)
+            .AppendLine(" quantity, double scalar) => new(quantity.Value - scalar, quantity.Unit);");
+        writer.AppendLine("    /// <summary>Returns the logarithmic difference between two quantities expressed in the left operand's unit.</summary>");
+        writer.Append("    public static double operator /(").Append(quantityName).Append(" left, ").Append(quantityName)
+            .AppendLine(" right) => left.Value - right.As(left.Unit);");
+    }
+
+    private static void EmitAffineOperators(
+        StringBuilder writer,
+        QuantitySelection quantity,
+        QuantitySelection offset)
+    {
+        string quantityType = quantity.Definition.Name;
+        string offsetType = QuantityType(offset.Definition);
+        string offsetBaseUnit = UnitType(offset.Definition) + "." + offset.Definition.BaseUnit;
+        writer.Append("    public static ").Append(quantityType).Append(" operator +(").Append(quantityType)
+            .Append(" left, ").Append(offsetType).AppendLine(" right) =>")
+            .Append("        new(left.BaseValue + right.BaseValue, Info.BaseUnit.Value);").AppendLine();
+        writer.Append("    public static ").Append(quantityType).Append(" operator +(").Append(offsetType)
+            .Append(" left, ").Append(quantityType).AppendLine(" right) => right + left;");
+        writer.Append("    public static ").Append(quantityType).Append(" operator -(").Append(quantityType)
+            .Append(" left, ").Append(offsetType).AppendLine(" right) =>")
+            .Append("        new(left.BaseValue - right.BaseValue, Info.BaseUnit.Value);").AppendLine();
+        writer.Append("    public static ").Append(offsetType).Append(" operator -(").Append(quantityType)
+            .Append(" left, ").Append(quantityType).AppendLine(" right) =>")
+            .Append("        new(left.BaseValue - right.BaseValue, ").Append(offsetBaseUnit).AppendLine(");");
+    }
+
+    private static string Escape(string value) => value.Replace("\\", "\\\\").Replace("\"", "\\\"");
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/QuantityRelationParser.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/QuantityRelationParser.cs
new file mode 100644
index 0000000000..5bee181618
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/QuantityRelationParser.cs
@@ -0,0 +1,262 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using Microsoft.CodeAnalysis;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class QuantityRelationParser
+{
+    private const string NoInferredDivision = "NoInferredDivision";
+    private const string Scalar = "double";
+    private const string CatalogScalar = "QuantityValue";
+
+    private static readonly JsonSerializerOptions SerializerOptions = new JsonSerializerOptions
+    {
+        AllowTrailingCommas = true,
+        PropertyNameCaseInsensitive = true,
+        ReadCommentHandling = JsonCommentHandling.Skip,
+    };
+
+    public static RelationDefinitionResult Parse(
+        AdditionalText file,
+        System.Threading.CancellationToken cancellationToken)
+    {
+        string json = file.GetText(cancellationToken)?.ToString() ?? string.Empty;
+        return Parse(json, file.Path);
+    }
+
+    public static RelationDefinitionResult Parse(string json, string path)
+    {
+        try
+        {
+            using JsonDocument document = JsonDocument.Parse(
+                json,
+                new JsonDocumentOptions
+                {
+                    AllowTrailingCommas = true,
+                    CommentHandling = JsonCommentHandling.Skip,
+                });
+            if (document.RootElement.ValueKind != JsonValueKind.Array)
+            {
+                return Error(path, json, "The file did not contain a relation array.");
+            }
+
+            var definitions = new List<QuantityRelationDefinition>();
+            int index = 0;
+            foreach (JsonElement element in document.RootElement.EnumerateArray())
+            {
+                if (element.ValueKind == JsonValueKind.String)
+                {
+                    definitions.Add(ParseRelation(element.GetString()!));
+                }
+                else if (element.ValueKind == JsonValueKind.Object)
+                {
+                    definitions.Add(ParseStructuredRelation(element, path, index));
+                }
+                else
+                {
+                    throw new FormatException(
+                        $"Relation at index {index} must be a string or structured relation object.");
+                }
+
+                index++;
+            }
+
+            return new RelationDefinitionResult(path, definitions, null, json);
+        }
+        catch (JsonException exception)
+        {
+            int line = checked((int)exception.LineNumber.GetValueOrDefault());
+            int position = checked((int)exception.BytePositionInLine.GetValueOrDefault());
+            return Error(
+                path,
+                json,
+                $"JSON line {line + 1}, byte position {position}: {exception.Message}",
+                line,
+                position);
+        }
+        catch (Exception exception)
+        {
+            return Error(path, json, exception.Message);
+        }
+    }
+
+    public static IReadOnlyList<QuantityRelation> Expand(
+        IEnumerable<QuantityRelationDefinition> definitions)
+    {
+        var relations = definitions
+            .Select(definition => new QuantityRelation(
+                definition.Result.Quantity == "1" ? "inverse" : "*",
+                definition.Result,
+                definition.Left,
+                definition.Right,
+                definition.NoInferredDivision,
+                definition.Source))
+            .ToList();
+
+        relations.AddRange(relations
+            .Where(relation =>
+                (relation.Operator == "*" || relation.Operator == "inverse") &&
+                relation.Left.Quantity != relation.Right.Quantity)
+            .Select(relation => new QuantityRelation(
+                relation.Operator,
+                relation.Result,
+                relation.Right,
+                relation.Left,
+                relation.NoInferredDivision,
+                relation.Source))
+            .ToArray());
+
+        relations.AddRange(relations
+            .Where(relation =>
+                relation.Operator == "*" &&
+                !relation.NoInferredDivision)
+            .Select(relation => new QuantityRelation(
+                "/",
+                relation.Left,
+                relation.Result,
+                relation.Right,
+                false,
+                relation.Source))
+            .Where(relation => relation.Left.Quantity != relation.Right.Quantity)
+            .ToArray());
+
+        return relations
+            .OrderBy(relation => relation.Key, StringComparer.Ordinal)
+            .ToArray();
+    }
+
+    public static IReadOnlyList<QuantityRelationDefinition> QualifyQuantityIds(
+        IEnumerable<QuantityRelationDefinition> definitions,
+        string quantityNamespace) => definitions
+        .Select(definition => new QuantityRelationDefinition(
+            Qualify(definition.Result, quantityNamespace),
+            Qualify(definition.Left, quantityNamespace),
+            Qualify(definition.Right, quantityNamespace),
+            definition.NoInferredDivision,
+            definition.Source))
+        .ToArray();
+
+    private static QuantityRelationDefinition ParseRelation(string relationString)
+    {
+        string[] segments = relationString.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
+        if (segments.Length < 5 || segments[1] != "=" || segments[3] != "*")
+        {
+            throw new FormatException($"Invalid relation '{relationString}'. Expected 'Result.Unit = Left.Unit * Right.Unit'.");
+        }
+
+        bool noInferredDivision = segments.Skip(5).Contains(NoInferredDivision, StringComparer.Ordinal);
+        if (segments.Length > 5 &&
+            !(segments.Length == 7 && segments[5] == "--" && noInferredDivision))
+        {
+            throw new FormatException($"Invalid relation suffix in '{relationString}'.");
+        }
+
+        return new QuantityRelationDefinition(
+            ParseEndpoint(segments[0], relationString),
+            ParseEndpoint(segments[2], relationString),
+            ParseEndpoint(segments[4], relationString),
+            noInferredDivision,
+            relationString);
+    }
+
+    private static RelationEndpoint ParseEndpoint(string text, string relationString)
+    {
+        if (text == "1")
+        {
+            return new RelationEndpoint(text, null);
+        }
+
+        if (text is Scalar or CatalogScalar)
+        {
+            return new RelationEndpoint(Scalar, null);
+        }
+
+        string[] segments = text.Split('.');
+        if (segments.Length != 2 || segments.Any(string.IsNullOrWhiteSpace))
+        {
+            throw new FormatException($"Invalid endpoint '{text}' in relation '{relationString}'.");
+        }
+
+        return new RelationEndpoint(segments[0], segments[1]);
+    }
+
+    private static QuantityRelationDefinition ParseStructuredRelation(
+        JsonElement element,
+        string path,
+        int index)
+    {
+        var relation = element.Deserialize<StructuredRelation>(SerializerOptions)
+            ?? throw new FormatException($"Relation at index {index} was empty.");
+        if (!string.IsNullOrWhiteSpace(relation.Operator) && relation.Operator != "*")
+        {
+            throw new FormatException(
+                $"Relation at index {index} uses unsupported operator '{relation.Operator}'. Expected '*'.");
+        }
+
+        return new QuantityRelationDefinition(
+            StructuredEndpoint(relation.Result, "result", index),
+            StructuredEndpoint(relation.Left, "left", index),
+            StructuredEndpoint(relation.Right, "right", index),
+            relation.NoInferredDivision,
+            $"{path} relation {index + 1}");
+    }
+
+    private static RelationEndpoint StructuredEndpoint(
+        StructuredRelationEndpoint? endpoint,
+        string role,
+        int index)
+    {
+        if (endpoint is null || string.IsNullOrWhiteSpace(endpoint.Quantity))
+        {
+            throw new FormatException($"Relation at index {index} has no {role} quantity ID.");
+        }
+
+        if (endpoint.Quantity is not ("1" or Scalar or CatalogScalar) &&
+            string.IsNullOrWhiteSpace(endpoint.Unit))
+        {
+            throw new FormatException($"Relation at index {index} has no {role} unit.");
+        }
+
+        return new RelationEndpoint(
+            endpoint.Quantity == CatalogScalar ? Scalar : endpoint.Quantity!,
+            endpoint.Unit);
+    }
+
+    private static RelationEndpoint Qualify(RelationEndpoint endpoint, string quantityNamespace) =>
+        endpoint.Quantity is "1" or Scalar || endpoint.Quantity.Contains('.')
+            ? endpoint
+            : new RelationEndpoint(quantityNamespace + "." + endpoint.Quantity, endpoint.Unit);
+
+    private sealed class StructuredRelation
+    {
+        public StructuredRelationEndpoint? Result { get; set; }
+
+        public StructuredRelationEndpoint? Left { get; set; }
+
+        public StructuredRelationEndpoint? Right { get; set; }
+
+        public string? Operator { get; set; }
+
+        public bool NoInferredDivision { get; set; }
+    }
+
+    private sealed class StructuredRelationEndpoint
+    {
+        public string? Quantity { get; set; }
+
+        public string? Unit { get; set; }
+    }
+
+    private static RelationDefinitionResult Error(
+        string path,
+        string json,
+        string error,
+        int errorLine = 0,
+        int errorColumn = 0) =>
+        new RelationDefinitionResult(path, null, error, json, errorLine, errorColumn);
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/QuantityRelationPlanner.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/QuantityRelationPlanner.cs
new file mode 100644
index 0000000000..89ad3822c1
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/QuantityRelationPlanner.cs
@@ -0,0 +1,241 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnitsNet.Modular.Generator;
+
+internal static class QuantityRelationPlanner
+{
+    public static IReadOnlyDictionary<string, IReadOnlyList<EmittedQuantityRelation>> Plan(
+        IReadOnlyList<QuantitySelection> selections,
+        IReadOnlyList<QuantityRelation> relations,
+        ISet<string> knownSemanticIds,
+        IReadOnlyDictionary<string, int> knownNameCounts,
+        out IReadOnlyList<string> errors)
+    {
+        var bySemanticId = selections.ToDictionary(
+            selection => selection.Definition.SemanticId,
+            StringComparer.Ordinal);
+        IReadOnlyDictionary<string, QuantitySelection[]> byName = selections
+            .GroupBy(selection => selection.Definition.Name, StringComparer.Ordinal)
+            .ToDictionary(group => group.Key, group => group.ToArray(), StringComparer.Ordinal);
+        var applicable = new List<EmittedQuantityRelation>();
+        var planningErrors = new List<string>();
+
+        foreach (QuantityRelation relation in relations)
+        {
+            bool hasLeft = TryResolve(
+                relation.Left,
+                bySemanticId,
+                byName,
+                knownSemanticIds,
+                knownNameCounts,
+                out QuantitySelection? left,
+                out UnitDefinition? leftUnit,
+                out string? leftError);
+            bool hasRight = TryResolve(
+                relation.Right,
+                bySemanticId,
+                byName,
+                knownSemanticIds,
+                knownNameCounts,
+                out QuantitySelection? right,
+                out UnitDefinition? rightUnit,
+                out string? rightError);
+            if (!hasLeft || !hasRight)
+            {
+                AddError(planningErrors, relation, leftError ?? rightError);
+                continue;
+            }
+
+            QuantitySelection? result = null;
+            UnitDefinition? resultUnit = null;
+            if (relation.Result.Quantity is not ("1" or "double") &&
+                !TryResolve(
+                    relation.Result,
+                    bySemanticId,
+                    byName,
+                    knownSemanticIds,
+                    knownNameCounts,
+                    out result,
+                    out resultUnit,
+                    out string? resultError))
+            {
+                AddError(planningErrors, relation, resultError);
+                continue;
+            }
+
+            bool isSupportedShape =
+                result is null &&
+                left is not null &&
+                right is not null &&
+                relation.Operator is "*" or "/" or "inverse" ||
+                result is not null &&
+                left is not null &&
+                right is not null ||
+                result is not null &&
+                left is null &&
+                right is not null &&
+                relation.Operator == "/";
+            if (!isSupportedShape)
+            {
+                planningErrors.Add($"Relation '{relation.Source}' has an unsupported scalar shape.");
+                continue;
+            }
+
+            applicable.Add(new EmittedQuantityRelation(
+                relation.Operator,
+                result,
+                resultUnit,
+                left,
+                leftUnit,
+                right,
+                rightUnit,
+                relation.Source));
+        }
+
+        var rejectedKeys = new HashSet<string>(StringComparer.Ordinal);
+        foreach (IGrouping<string, EmittedQuantityRelation> duplicate in applicable.GroupBy(
+                     relation => relation.Key,
+                     StringComparer.Ordinal))
+        {
+            if (duplicate.Count() > 1)
+            {
+                planningErrors.Add($"Duplicate relation '{duplicate.Key}'.");
+            }
+        }
+
+        foreach (IGrouping<string, EmittedQuantityRelation> ambiguous in applicable.GroupBy(
+                     OperatorSignature,
+                     StringComparer.Ordinal))
+        {
+            if (ambiguous.Select(relation => relation.Key).Distinct(StringComparer.Ordinal).Count() > 1)
+            {
+                planningErrors.Add($"Ambiguous relation operator '{ambiguous.Key}'.");
+                rejectedKeys.UnionWith(ambiguous.Select(relation => relation.Key));
+            }
+        }
+
+        foreach (IGrouping<string, EmittedQuantityRelation> inverseMembers in applicable
+                     .Where(relation => relation.Operator == "inverse" && relation.Left is not null)
+                     .GroupBy(relation => relation.Left!.Definition.SemanticId, StringComparer.Ordinal))
+        {
+            if (inverseMembers.Select(relation => relation.Right!.Definition.SemanticId)
+                .Distinct(StringComparer.Ordinal)
+                .Count() > 1)
+            {
+                planningErrors.Add(
+                    $"Quantity '{inverseMembers.Key}' has more than one relation that would generate Inverse().");
+                rejectedKeys.UnionWith(inverseMembers.Select(relation => relation.Key));
+            }
+        }
+
+        var planned = new Dictionary<string, List<EmittedQuantityRelation>>(StringComparer.Ordinal);
+        foreach (EmittedQuantityRelation relation in applicable
+                     .Where(relation => !rejectedKeys.Contains(relation.Key))
+                     .GroupBy(relation => relation.Key, StringComparer.Ordinal)
+                     .Select(group => group.First())
+                     .OrderBy(relation => relation.Key, StringComparer.Ordinal))
+        {
+            string ownerKey = TargetKey((relation.Left ?? relation.Right)!.Definition);
+            if (!planned.TryGetValue(ownerKey, out List<EmittedQuantityRelation>? ownedRelations))
+            {
+                ownedRelations = new List<EmittedQuantityRelation>();
+                planned.Add(ownerKey, ownedRelations);
+            }
+
+            ownedRelations.Add(relation);
+        }
+
+        errors = planningErrors.Distinct(StringComparer.Ordinal).ToArray();
+        return planned.ToDictionary(
+            item => item.Key,
+            item => (IReadOnlyList<EmittedQuantityRelation>)item.Value,
+            StringComparer.Ordinal);
+    }
+
+    private static bool TryResolve(
+        RelationEndpoint endpoint,
+        IReadOnlyDictionary<string, QuantitySelection> bySemanticId,
+        IReadOnlyDictionary<string, QuantitySelection[]> byName,
+        ISet<string> knownSemanticIds,
+        IReadOnlyDictionary<string, int> knownNameCounts,
+        out QuantitySelection? selection,
+        out UnitDefinition? unit,
+        out string? error)
+    {
+        selection = null;
+        unit = null;
+        error = null;
+        if (endpoint.Quantity is "1" or "double")
+        {
+            return true;
+        }
+
+        if (endpoint.Quantity.Contains('.'))
+        {
+            if (!bySemanticId.TryGetValue(endpoint.Quantity, out selection))
+            {
+                if (!knownSemanticIds.Contains(endpoint.Quantity))
+                {
+                    error = $"Quantity ID '{endpoint.Quantity}' is unknown.";
+                }
+
+                return false;
+            }
+        }
+        else
+        {
+            if (!byName.TryGetValue(endpoint.Quantity, out QuantitySelection[]? matches))
+            {
+                if (!knownNameCounts.TryGetValue(endpoint.Quantity, out int count))
+                {
+                    error = $"Quantity name '{endpoint.Quantity}' is unknown.";
+                }
+                else if (count != 1)
+                {
+                    error = $"Quantity name '{endpoint.Quantity}' is ambiguous; use its semantic ID.";
+                }
+
+                return false;
+            }
+
+            if (matches.Length != 1)
+            {
+                error = $"Quantity name '{endpoint.Quantity}' is ambiguous; use its semantic ID.";
+                return false;
+            }
+
+            selection = matches[0];
+        }
+
+        unit = selection.Definition.Units.FirstOrDefault(candidate => candidate.SingularName == endpoint.Unit);
+        if (unit is null)
+        {
+            error = $"Quantity '{selection.Definition.SemanticId}' has no relation unit '{endpoint.Unit}'.";
+            return false;
+        }
+
+        return true;
+    }
+
+    private static void AddError(
+        ICollection<string> errors,
+        QuantityRelation relation,
+        string? error)
+    {
+        if (error is not null)
+        {
+            errors.Add($"Relation '{relation.Source}' is invalid: {error}");
+        }
+    }
+
+    private static string OperatorSignature(EmittedQuantityRelation relation) =>
+        (relation.Left?.Definition.SemanticId ?? "double") + " " + relation.Operator + " " +
+        (relation.Right?.Definition.SemanticId ?? "double");
+
+    private static string TargetKey(QuantityDefinition definition) =>
+        definition.TargetNamespace + "." + definition.Name;
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/UnitsNet.Modular.Generator.csproj b/UnitsNet.Modular/UnitsNet.Modular.Generator/UnitsNet.Modular.Generator.csproj
new file mode 100644
index 0000000000..3d2bf8c17f
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/UnitsNet.Modular.Generator.csproj
@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk"
+         TreatAsLocalProperty="PublishAot;PublishTrimmed;SelfContained;RuntimeIdentifier">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <RootNamespace>UnitsNet.Modular.Generator</RootNamespace>
+    <IsRoslynComponent>true</IsRoslynComponent>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+    <NoWarn>$(NoWarn);RS1036;RS2008</NoWarn>
+    <!-- Analyzer assemblies are build-time inputs and are never part of an application's native publish. -->
+    <PublishAot>false</PublishAot>
+    <PublishTrimmed>false</PublishTrimmed>
+    <SelfContained>false</SelfContained>
+    <RuntimeIdentifier />
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="MinVer" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" PrivateAssets="all" />
+    <PackageReference Include="System.Text.Json" PrivateAssets="all" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="../../Common/UnitDefinitions/*.json"
+                      LogicalName="UnitsNet.Modular.Generator.BuiltIns.Quantities.%(Filename).json" />
+    <EmbeddedResource Include="../../Common/UnitRelations.json"
+                      LogicalName="UnitsNet.Modular.Generator.BuiltIns.UnitRelations.json" />
+    <EmbeddedResource Include="../../Common/UnitEnumValues.g.json"
+                      LogicalName="UnitsNet.Modular.Generator.BuiltIns.UnitEnumValues.json" />
+    <EmbeddedResource Include="BuiltInAugmentations.json"
+                      LogicalName="UnitsNet.Modular.Generator.BuiltIns.Augmentations.json" />
+    <EmbeddedResource Include="BuiltInCompanions.json"
+                      LogicalName="UnitsNet.Modular.Generator.BuiltIns.Companions.json" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/UnitsNetModularGenerator.cs b/UnitsNet.Modular/UnitsNet.Modular.Generator/UnitsNetModularGenerator.cs
new file mode 100644
index 0000000000..4fbf3379ed
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/UnitsNetModularGenerator.cs
@@ -0,0 +1,755 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text.RegularExpressions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+
+namespace UnitsNet.Modular.Generator;
+
+[Generator]
+public sealed class UnitsNetModularGenerator : IIncrementalGenerator
+{
+    private const string ModuleAttribute = "UnitsNet.Modular.UnitsNetModuleAttribute";
+    private const string UnitSetAttribute = "UnitsNet.Modular.UnitSetAttribute";
+    private const string QuantitySpecAttribute = "UnitsNet.Modular.QuantitySpecAttribute";
+    private const string GenerationNamespace = "UnitsNet.Modular";
+    private const string IncludeName = "IInclude";
+    private const string IncludeProfileName = "IIncludeProfile";
+    private const string DocumentationUrl =
+        "https://github.com/angularsen/UnitsNet/tree/master/UnitsNet.Modular";
+
+    private static readonly DiagnosticDescriptor MissingDefinition = new DiagnosticDescriptor(
+        "UNM001",
+        "Quantity definition is missing",
+        "Type '{0}' is selected as a quantity but has no UnitsNet.Modular quantity definition",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#select-quantities");
+
+    private static readonly DiagnosticDescriptor EmptyUnitSet = new DiagnosticDescriptor(
+        "UNM002",
+        "Unit pattern matched no units",
+        "Pattern '{0}' matched no units in quantity '{1}'",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#filter-units");
+
+    private static readonly DiagnosticDescriptor InvalidDefinition = new DiagnosticDescriptor(
+        "UNM003",
+        "Quantity definition is invalid",
+        "Quantity '{0}' must define its base unit '{1}'",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#quantity-definition-json");
+
+    private static readonly DiagnosticDescriptor InvalidJsonDefinition = new DiagnosticDescriptor(
+        "UNM004",
+        "JSON quantity definition is invalid",
+        "Definition file '{0}' is invalid: {1}",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#quantity-definition-json");
+
+    private static readonly DiagnosticDescriptor DuplicateDefinition = new DiagnosticDescriptor(
+        "UNM005",
+        "Quantity definition ID is duplicated",
+        "Quantity definition ID '{0}' is provided by more than one JSON file",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#register-a-definition");
+
+    private static readonly DiagnosticDescriptor InvalidPattern = new DiagnosticDescriptor(
+        "UNM006",
+        "Unit selection pattern is invalid",
+        "Pattern '{0}' for quantity '{1}' is invalid: {2}",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#filter-units");
+
+    private static readonly DiagnosticDescriptor InvalidRelationDefinition = new DiagnosticDescriptor(
+        "UNM010",
+        "Quantity relation definition is invalid",
+        "Relation file '{0}' is invalid: {1}",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#add-quantity-relationships");
+
+    private static readonly DiagnosticDescriptor InvalidRelationSet = new DiagnosticDescriptor(
+        "UNM011",
+        "Selected quantity relations are invalid",
+        "{0}",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#add-quantity-relationships");
+
+    private static readonly DiagnosticDescriptor MissingUnitSet = new DiagnosticDescriptor(
+        "UNM012",
+        "Unit set is invalid",
+        "Unit-set type selected for quantity '{0}' has no UnitSet attribute or no patterns",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#filter-units");
+
+    private static readonly DiagnosticDescriptor ConflictingTargetDefinition = new DiagnosticDescriptor(
+        "UNM013",
+        "Generated quantity target is ambiguous",
+        "Definitions '{0}' and '{1}' both generate '{2}'",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#module-declaration");
+
+    private static readonly DiagnosticDescriptor MultipleModules = new DiagnosticDescriptor(
+        "UNM014",
+        "Multiple UnitsNet.Modular modules are not supported",
+        "Compilation defines multiple UnitsNet.Modular modules ({0}); compose selections into one module using include profiles",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#module-declaration");
+
+    private static readonly DiagnosticDescriptor MissingAffineOffset = new DiagnosticDescriptor(
+        "UNM015",
+        "Affine offset quantity is not selected",
+        "Affine quantity '{0}' requires offset quantity '{1}'; include both quantities in the module",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#arithmetic-and-relationships");
+
+    private static readonly DiagnosticDescriptor LegacyUnitsNetReference = new DiagnosticDescriptor(
+        "UNM016",
+        "UnitsNet and UnitsNet.Modular cannot be referenced together",
+        "Remove the legacy UnitsNet package reference; a UnitsNet.Modular module generates its own UnitsNet quantity types and contracts",
+        "UnitsNet.Modular",
+        DiagnosticSeverity.Error,
+        true,
+        helpLinkUri: DocumentationUrl + "#namespaces");
+
+    public void Initialize(IncrementalGeneratorInitializationContext context)
+    {
+        context.RegisterPostInitializationOutput(static output =>
+            output.AddSource("UnitsNet.Modular.Specs.g.cs", SourceText.From(BootstrapSource.Text, System.Text.Encoding.UTF8)));
+
+        IncrementalValuesProvider<ModuleRequest> modules = context.SyntaxProvider
+            .ForAttributeWithMetadataName(
+                ModuleAttribute,
+                static (node, _) => node is Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax,
+                static (attributeContext, _) => CreateModuleRequest(
+                    (INamedTypeSymbol)attributeContext.TargetSymbol,
+                    attributeContext.SemanticModel.Compilation))
+            .WithComparer(ModuleRequestComparer.Instance)
+            .WithTrackingName("Modules");
+
+        IncrementalValuesProvider<JsonDefinitionResult> jsonDefinitions = context.AdditionalTextsProvider
+            .Combine(context.AnalyzerConfigOptionsProvider)
+            .Where(static input => IsJsonDefinition(input.Left, input.Right))
+            .Select(static (input, cancellationToken) => JsonDefinitionParser.Parse(input.Left, cancellationToken))
+            .WithComparer(JsonDefinitionResultComparer.Instance)
+            .WithTrackingName("Definitions");
+
+        IncrementalValuesProvider<RelationDefinitionResult> relationDefinitions = context.AdditionalTextsProvider
+            .Combine(context.AnalyzerConfigOptionsProvider)
+            .Where(static input => IsRelationDefinition(input.Left, input.Right))
+            .Select(static (input, cancellationToken) => QuantityRelationParser.Parse(input.Left, cancellationToken))
+            .WithComparer(RelationDefinitionResultComparer.Instance)
+            .WithTrackingName("Relations");
+
+        IncrementalValueProvider<((ImmutableArray<ModuleRequest> Left, ImmutableArray<JsonDefinitionResult> Right) Left, ImmutableArray<RelationDefinitionResult> Right)> generationInputs =
+            modules.Collect().Combine(jsonDefinitions.Collect())
+                .Combine(relationDefinitions.Collect())
+                .WithTrackingName("GenerationInputs");
+        context.RegisterSourceOutput(
+            generationInputs,
+            static (productionContext, input) => EmitModules(
+                productionContext,
+                input.Left.Left,
+                input.Left.Right,
+                input.Right));
+    }
+
+    private static void EmitModules(
+        SourceProductionContext context,
+        ImmutableArray<ModuleRequest> modules,
+        ImmutableArray<JsonDefinitionResult> jsonDefinitionResults,
+        ImmutableArray<RelationDefinitionResult> relationDefinitionResults)
+    {
+        if (modules.Length == 0)
+        {
+            return;
+        }
+
+        if (modules.Length > 1)
+        {
+            ModuleRequest[] ordered = modules.OrderBy(module => module.Name, StringComparer.Ordinal).ToArray();
+            context.ReportDiagnostic(Diagnostic.Create(
+                MultipleModules,
+                ordered[0].Location.ToLocation(),
+                string.Join(", ", ordered.Select(module => "'" + module.Name + "'"))));
+            return;
+        }
+
+        if (modules[0].ReferencesLegacyUnitsNet)
+        {
+            context.ReportDiagnostic(Diagnostic.Create(
+                LegacyUnitsNetReference,
+                modules[0].Location.ToLocation()));
+            return;
+        }
+
+        EmitModule(context, modules[0], jsonDefinitionResults, relationDefinitionResults);
+    }
+
+    private static void EmitModule(
+        SourceProductionContext context,
+        ModuleRequest module,
+        ImmutableArray<JsonDefinitionResult> jsonDefinitionResults,
+        ImmutableArray<RelationDefinitionResult> relationDefinitionResults)
+    {
+        var jsonDefinitions = new Dictionary<string, QuantityDefinition>(StringComparer.Ordinal);
+        foreach (JsonDefinitionResult result in jsonDefinitionResults)
+        {
+            if (result.Error is not null)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    InvalidJsonDefinition,
+                    FileLocation(result.Path, result.ErrorLine, result.ErrorColumn),
+                    result.Path,
+                    result.Error));
+                continue;
+            }
+
+            QuantityDefinition definition = result.Definition!;
+            if (jsonDefinitions.ContainsKey(definition.Id))
+            {
+                context.ReportDiagnostic(Diagnostic.Create(DuplicateDefinition, FileLocation(result.Path), definition.Id));
+            }
+            else
+            {
+                jsonDefinitions.Add(definition.Id, definition);
+            }
+        }
+
+        PrefixExpander.BaseUnitPrefixCatalog baseUnitPrefixes =
+            BuiltInCatalog.CreateBaseUnitPrefixes(jsonDefinitions.Values);
+        foreach (string definitionId in jsonDefinitions.Keys.ToArray())
+        {
+            QuantityDefinition definition = jsonDefinitions[definitionId];
+            if (PrefixExpander.TryExpand(
+                    definition,
+                    baseUnitPrefixes,
+                    out QuantityDefinition? expanded,
+                    out string? error))
+            {
+                jsonDefinitions[definitionId] = expanded!;
+                continue;
+            }
+
+            context.ReportDiagnostic(Diagnostic.Create(
+                InvalidJsonDefinition,
+                FileLocation(definition.SourcePath ?? string.Empty),
+                definition.SourcePath ?? string.Empty,
+                error));
+            jsonDefinitions.Remove(definitionId);
+        }
+
+        var requests = new Dictionary<string, SelectionRequest>(StringComparer.Ordinal);
+        Location moduleLocation = module.Location.ToLocation();
+        foreach (ModuleSelection selection in module.Selections)
+        {
+            QuantityDefinition? definition = ResolveDefinition(selection, jsonDefinitions);
+            if (definition is null)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(MissingDefinition, moduleLocation, selection.SpecName));
+                continue;
+            }
+
+            if (!string.IsNullOrWhiteSpace(module.TargetNamespace))
+            {
+                definition = definition.WithTargetNamespace(module.TargetNamespace!);
+            }
+
+            string key = definition.TargetNamespace + "." + definition.Name;
+            if (!requests.TryGetValue(key, out SelectionRequest? request))
+            {
+                request = new SelectionRequest(definition);
+                requests.Add(key, request);
+            }
+            else if (!SameDefinition(request.Definition, definition))
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    ConflictingTargetDefinition,
+                    moduleLocation,
+                    request.Definition.SemanticId,
+                    definition.SemanticId,
+                    key));
+                continue;
+            }
+
+            if (selection.IsDirect && !request.HasDirectSelection)
+            {
+                request.IncludeAll = false;
+                request.Patterns.Clear();
+                request.HasDirectSelection = true;
+            }
+
+            if (selection.Patterns.Length == 0)
+            {
+                if (!selection.HasUnitSet)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(MissingUnitSet, moduleLocation, definition.Name));
+                    continue;
+                }
+
+                request.IncludeAll = true;
+                continue;
+            }
+
+            request.Patterns.UnionWith(selection.Patterns);
+        }
+
+        var selections = new List<QuantitySelection>();
+        foreach (SelectionRequest request in requests.Values.OrderBy(x => x.Definition.TargetNamespace, StringComparer.Ordinal).ThenBy(x => x.Definition.Name, StringComparer.Ordinal))
+        {
+            if (!request.Definition.Units.Any(unit => unit.SingularName == request.Definition.BaseUnit))
+            {
+                context.ReportDiagnostic(Diagnostic.Create(InvalidDefinition, moduleLocation, request.Definition.Name, request.Definition.BaseUnit));
+                continue;
+            }
+
+            var selectedUnits = new List<UnitDefinition>();
+            if (request.IncludeAll)
+            {
+                selectedUnits.AddRange(request.Definition.Units);
+            }
+            else
+            {
+                foreach (string pattern in request.Patterns)
+                {
+                    if (!TryCreateMatcher(pattern, out Func<string, bool>? matcher, out string patternError))
+                    {
+                        context.ReportDiagnostic(Diagnostic.Create(InvalidPattern, moduleLocation, pattern, request.Definition.Name, patternError));
+                        continue;
+                    }
+
+                    UnitDefinition[] matches = request.Definition.Units.Where(unit => matcher(unit.SingularName)).ToArray();
+                    if (matches.Length == 0)
+                    {
+                        context.ReportDiagnostic(Diagnostic.Create(EmptyUnitSet, moduleLocation, pattern, request.Definition.Name));
+                    }
+
+                    selectedUnits.AddRange(matches);
+                }
+            }
+
+            selectedUnits.Add(request.Definition.Units.First(unit => unit.SingularName == request.Definition.BaseUnit));
+            var selectedNames = new HashSet<string>(
+                selectedUnits.Select(unit => unit.SingularName),
+                StringComparer.Ordinal);
+            UnitDefinition[] distinctUnits = request.Definition.Units
+                .Where(unit => selectedNames.Contains(unit.SingularName))
+                .ToArray();
+            selections.Add(new QuantitySelection(request.Definition, distinctUnits));
+        }
+
+        IReadOnlyDictionary<string, QuantitySelection> selectionsBySemanticId = selections
+            .GroupBy(selection => selection.Definition.SemanticId, StringComparer.Ordinal)
+            .ToDictionary(group => group.Key, group => group.First(), StringComparer.Ordinal);
+        var hasMissingAffineOffset = false;
+        foreach (QuantitySelection selection in selections.Where(selection => selection.Definition.IsAffine))
+        {
+            string offsetId = AffineOffsetSemanticId(selection.Definition);
+            if (!selectionsBySemanticId.ContainsKey(offsetId))
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    MissingAffineOffset,
+                    moduleLocation,
+                    selection.Definition.SemanticId,
+                    offsetId));
+                hasMissingAffineOffset = true;
+            }
+        }
+
+        if (hasMissingAffineOffset)
+        {
+            return;
+        }
+
+        var relationDefinitions = new List<QuantityRelationDefinition>(BuiltInRelationCatalog.Definitions);
+        foreach (RelationDefinitionResult result in relationDefinitionResults)
+        {
+            if (result.Error is not null)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    InvalidRelationDefinition,
+                    FileLocation(result.Path, result.ErrorLine, result.ErrorColumn),
+                    result.Path,
+                    result.Error));
+                continue;
+            }
+
+            relationDefinitions.AddRange(result.Definitions!);
+        }
+
+        IReadOnlyList<QuantityRelation> expandedRelations = QuantityRelationParser.Expand(relationDefinitions);
+        QuantityDefinition[] knownDefinitions = BuiltInCatalog.Names
+            .Select(name =>
+            {
+                BuiltInCatalog.TryGetByName(name, out QuantityDefinition definition);
+                return definition;
+            })
+            .Concat(jsonDefinitions.Values)
+            .GroupBy(definition => definition.SemanticId, StringComparer.Ordinal)
+            .Select(group => group.First())
+            .ToArray();
+        ISet<string> knownSemanticIds = new HashSet<string>(
+            knownDefinitions.Select(definition => definition.SemanticId),
+            StringComparer.Ordinal);
+        IReadOnlyDictionary<string, int> knownNameCounts = knownDefinitions
+            .GroupBy(definition => definition.Name, StringComparer.Ordinal)
+            .ToDictionary(group => group.Key, group => group.Count(), StringComparer.Ordinal);
+        IReadOnlyDictionary<string, IReadOnlyList<EmittedQuantityRelation>> relationshipsByOwner =
+            QuantityRelationPlanner.Plan(
+                selections,
+                expandedRelations,
+                knownSemanticIds,
+                knownNameCounts,
+                out IReadOnlyList<string> relationErrors);
+        foreach (string error in relationErrors)
+        {
+            context.ReportDiagnostic(Diagnostic.Create(InvalidRelationSet, moduleLocation, error));
+        }
+
+        string modulePrefix = Regex.Replace(module.Name, "[^A-Za-z0-9_]", "_");
+        foreach (QuantitySelection selection in selections)
+        {
+            string ownerKey = selection.Definition.TargetNamespace + "." + selection.Definition.Name;
+            IReadOnlyList<EmittedQuantityRelation> relationships =
+                relationshipsByOwner.TryGetValue(ownerKey, out IReadOnlyList<EmittedQuantityRelation>? owned)
+                    ? owned
+                    : Array.Empty<EmittedQuantityRelation>();
+            string hintName = modulePrefix + "_" + selection.Definition.TargetNamespace.Replace('.', '_') + "_" +
+                              selection.Definition.Name + ".g.cs";
+            QuantitySelection? affineOffset = selection.Definition.IsAffine
+                ? selectionsBySemanticId[AffineOffsetSemanticId(selection.Definition)]
+                : null;
+            context.AddSource(
+                hintName,
+                SourceText.From(
+                    QuantityEmitter.Emit(selection, relationships, affineOffset, selectionsBySemanticId),
+                    System.Text.Encoding.UTF8));
+
+            foreach (CompanionTypeDefinition companion in BuiltInCompanionCatalog.Get(selection.Definition.SemanticId))
+            {
+                if (!BuiltInCompanionEmitter.CanEmit(companion, selection, selectionsBySemanticId))
+                {
+                    continue;
+                }
+
+                string companionHintName = modulePrefix + "_" +
+                                           selection.Definition.TargetNamespace.Replace('.', '_') + "_" +
+                                           companion.Kind + ".g.cs";
+                context.AddSource(
+                    companionHintName,
+                    SourceText.From(
+                        BuiltInCompanionEmitter.Emit(selection, companion),
+                        System.Text.Encoding.UTF8));
+            }
+        }
+
+        context.AddSource(
+            modulePrefix + "_Registry.g.cs",
+            SourceText.From(ModuleEmitter.EmitRegistry(selections), System.Text.Encoding.UTF8));
+        context.AddSource(
+            modulePrefix + "_Quantity.g.cs",
+            SourceText.From(
+                ModuleEmitter.EmitQuantityFacade(module.FacadeNamespace),
+                System.Text.Encoding.UTF8));
+        context.AddSource(
+            modulePrefix + "_Extensions.g.cs",
+            SourceText.From(ModuleEmitter.EmitExtensions(selections), System.Text.Encoding.UTF8));
+    }
+
+    private static string AffineOffsetSemanticId(QuantityDefinition definition)
+    {
+        string offsetType = definition.AffineOffsetType!;
+        if (offsetType.Contains("."))
+        {
+            return offsetType;
+        }
+
+        int separator = definition.SemanticId.LastIndexOf('.');
+        return separator < 0
+            ? offsetType
+            : definition.SemanticId.Substring(0, separator + 1) + offsetType;
+    }
+
+    private static bool IsInclude(INamedTypeSymbol candidate)
+    {
+        INamedTypeSymbol definition = candidate.OriginalDefinition;
+        return definition.Name == IncludeName &&
+               definition.ContainingNamespace.ToDisplayString() == GenerationNamespace;
+    }
+
+    private static bool IsIncludeProfile(INamedTypeSymbol candidate)
+    {
+        INamedTypeSymbol definition = candidate.OriginalDefinition;
+        return definition.Name == IncludeProfileName &&
+               definition.ContainingNamespace.ToDisplayString() == GenerationNamespace;
+    }
+
+    private static ModuleRequest CreateModuleRequest(INamedTypeSymbol module, Compilation compilation)
+    {
+        string? targetNamespace = GetModuleTargetNamespace(module);
+        ModuleSelection[] direct = module.Interfaces
+            .Where(IsInclude)
+            .Select(include => CreateModuleSelection(include, true))
+            .Where(selection => selection is not null)
+            .Cast<ModuleSelection>()
+            .ToArray();
+        var directIds = new HashSet<string>(
+            direct.Select(SelectionIdentity),
+            StringComparer.Ordinal);
+        IEnumerable<ModuleSelection> profiles = GetProfileIncludes(module)
+            .Select(include => CreateModuleSelection(include, false))
+            .Where(selection => selection is not null)
+            .Cast<ModuleSelection>()
+            .Where(selection => !directIds.Contains(SelectionIdentity(selection)));
+        ImmutableArray<ModuleSelection> selections = profiles
+            .Concat(direct)
+            .OrderBy(selection => selection.IsDirect)
+            .ThenBy(SelectionIdentity, StringComparer.Ordinal)
+            .ThenBy(selection => string.Join("\u001f", selection.Patterns), StringComparer.Ordinal)
+            .ToImmutableArray();
+        return new ModuleRequest(
+            module.ToDisplayString(),
+            module.ContainingNamespace.IsGlobalNamespace
+                ? string.Empty
+                : module.ContainingNamespace.ToDisplayString(),
+            targetNamespace,
+            selections,
+            compilation.ReferencedAssemblyNames.Any(
+                identity => string.Equals(identity.Name, "UnitsNet", StringComparison.OrdinalIgnoreCase)),
+            SourceLocation.From(module.Locations.FirstOrDefault()));
+    }
+
+    private static ModuleSelection? CreateModuleSelection(INamedTypeSymbol include, bool isDirect)
+    {
+        ImmutableArray<ITypeSymbol> arguments = include.TypeArguments;
+        if (arguments.Length is < 1 or > 2 || arguments[0] is not INamedTypeSymbol spec)
+        {
+            return null;
+        }
+
+        AttributeData? specAttribute = spec.GetAttributes()
+            .FirstOrDefault(attribute => AttributeName(attribute) == QuantitySpecAttribute);
+        string? semanticId = specAttribute?.ConstructorArguments.Length == 1
+            ? specAttribute.ConstructorArguments[0].Value as string
+            : null;
+        IReadOnlyList<string>? patterns = arguments.Length == 2
+            ? GetUnitSetPatterns(arguments[1])
+            : Array.Empty<string>();
+        return new ModuleSelection(
+            spec.ToDisplayString(),
+            semanticId,
+            (patterns ?? Array.Empty<string>()).OrderBy(value => value, StringComparer.Ordinal).ToImmutableArray(),
+            arguments.Length == 1 || patterns is not null,
+            isDirect);
+    }
+
+    private static string SelectionIdentity(ModuleSelection selection) =>
+        selection.SemanticId ?? selection.SpecName;
+
+    private static IEnumerable<INamedTypeSymbol> GetProfileIncludes(INamedTypeSymbol module)
+    {
+        var includes = new List<INamedTypeSymbol>();
+        var pending = new Queue<INamedTypeSymbol>();
+        var visited = new HashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default);
+
+        foreach (INamedTypeSymbol profileSelection in module.AllInterfaces.Where(IsIncludeProfile))
+        {
+            if (profileSelection.TypeArguments.Length == 1 &&
+                profileSelection.TypeArguments[0] is INamedTypeSymbol profile)
+            {
+                pending.Enqueue(profile);
+            }
+        }
+
+        while (pending.Count > 0)
+        {
+            INamedTypeSymbol profile = pending.Dequeue();
+            if (!visited.Add(profile))
+            {
+                continue;
+            }
+
+            includes.AddRange(profile.AllInterfaces.Where(IsInclude));
+            foreach (INamedTypeSymbol nestedSelection in profile.AllInterfaces.Where(IsIncludeProfile))
+            {
+                if (nestedSelection.TypeArguments.Length == 1 &&
+                    nestedSelection.TypeArguments[0] is INamedTypeSymbol nestedProfile)
+                {
+                    pending.Enqueue(nestedProfile);
+                }
+            }
+        }
+
+        return includes;
+    }
+
+    private static string? GetModuleTargetNamespace(INamedTypeSymbol module)
+    {
+        AttributeData? moduleAttribute = module.GetAttributes()
+            .FirstOrDefault(attribute => AttributeName(attribute) == ModuleAttribute);
+        if (moduleAttribute?.ConstructorArguments.Length != 1)
+        {
+            return null;
+        }
+
+        return moduleAttribute.ConstructorArguments[0].Value as string;
+    }
+
+    private static QuantityDefinition? ResolveDefinition(
+        ModuleSelection selection,
+        IReadOnlyDictionary<string, QuantityDefinition> jsonDefinitions)
+    {
+        if (selection.SemanticId is not null &&
+            BuiltInCatalog.TryGetBySemanticId(selection.SemanticId, out QuantityDefinition builtIn))
+        {
+            return builtIn;
+        }
+
+        return selection.SemanticId is not null &&
+               jsonDefinitions.TryGetValue(selection.SemanticId, out QuantityDefinition definition)
+            ? definition
+            : null;
+    }
+
+    private static IReadOnlyList<string>? GetUnitSetPatterns(ITypeSymbol unitSet)
+    {
+        AttributeData? attribute = unitSet.GetAttributes().FirstOrDefault(candidate => AttributeName(candidate) == UnitSetAttribute);
+        if (attribute?.ConstructorArguments.Length != 1)
+        {
+            return null;
+        }
+
+        TypedConstant argument = attribute.ConstructorArguments[0];
+        return argument.Kind == TypedConstantKind.Array
+            ? argument.Values.Select(value => value.Value as string).Where(value => value is not null).Cast<string>().ToArray()
+            : argument.Value is string value ? new[] { value } : null;
+    }
+
+    private static bool TryCreateMatcher(string pattern, out Func<string, bool> matcher, out string error)
+    {
+        try
+        {
+            bool isRegex = pattern.StartsWith("regex:", StringComparison.OrdinalIgnoreCase);
+            string expression = isRegex ? pattern.Substring("regex:".Length) : pattern;
+            if (!isRegex && expression.StartsWith("glob:", StringComparison.OrdinalIgnoreCase))
+            {
+                expression = expression.Substring("glob:".Length);
+            }
+
+            if (!isRegex)
+            {
+                expression = "^" + Regex.Escape(expression).Replace("\\*", ".*") + "$";
+            }
+
+            var regex = new Regex(
+                expression,
+                RegexOptions.CultureInvariant | RegexOptions.IgnoreCase,
+                TimeSpan.FromMilliseconds(100));
+            matcher = value =>
+            {
+                try
+                {
+                    return regex.IsMatch(value);
+                }
+                catch (RegexMatchTimeoutException)
+                {
+                    return false;
+                }
+            };
+            error = string.Empty;
+            return true;
+        }
+        catch (ArgumentException exception)
+        {
+            matcher = _ => false;
+            error = exception.Message;
+            return false;
+        }
+    }
+
+    private static string? AttributeName(AttributeData attribute)
+        => attribute.AttributeClass?.ToDisplayString();
+
+    private static bool SameDefinition(QuantityDefinition left, QuantityDefinition right) =>
+        string.Equals(left.SemanticId, right.SemanticId, StringComparison.Ordinal) &&
+        string.Equals(left.SourcePath, right.SourcePath, StringComparison.Ordinal);
+
+    private static Location FileLocation(string path, int line = 0, int column = 0) => string.IsNullOrWhiteSpace(path)
+        ? Location.None
+        : Location.Create(
+            path,
+            new TextSpan(0, 0),
+            new LinePositionSpan(
+                new LinePosition(Math.Max(0, line), Math.Max(0, column)),
+                new LinePosition(Math.Max(0, line), Math.Max(0, column))));
+
+    private static bool IsJsonDefinition(AdditionalText file, AnalyzerConfigOptionsProvider optionsProvider)
+    {
+        if (file.Path.EndsWith(".unitsnet.json", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        return optionsProvider.GetOptions(file).TryGetValue(
+                   "build_metadata.AdditionalFiles.UnitsNetDefinition",
+                   out string? value) &&
+               string.Equals(value, "true", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static bool IsRelationDefinition(AdditionalText file, AnalyzerConfigOptionsProvider optionsProvider)
+    {
+        if (file.Path.EndsWith(".unitsnet.relations.json", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        return optionsProvider.GetOptions(file).TryGetValue(
+                   "build_metadata.AdditionalFiles.UnitsNetRelation",
+                   out string? value) &&
+               string.Equals(value, "true", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private sealed class SelectionRequest
+    {
+        public SelectionRequest(QuantityDefinition definition)
+        {
+            Definition = definition;
+        }
+
+        public QuantityDefinition Definition { get; }
+
+        public bool IncludeAll { get; set; }
+
+        public bool HasDirectSelection { get; set; }
+
+        public HashSet<string> Patterns { get; } = new HashSet<string>(StringComparer.Ordinal);
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/buildTransitive/UnitsNet.Modular.Generator.props b/UnitsNet.Modular/UnitsNet.Modular.Generator/buildTransitive/UnitsNet.Modular.Generator.props
new file mode 100644
index 0000000000..19d9ed620c
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/buildTransitive/UnitsNet.Modular.Generator.props
@@ -0,0 +1,6 @@
+<Project>
+  <ItemGroup>
+    <CompilerVisibleItemMetadata Include="AdditionalFiles" MetadataName="UnitsNetDefinition" />
+    <CompilerVisibleItemMetadata Include="AdditionalFiles" MetadataName="UnitsNetRelation" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Generator/buildTransitive/UnitsNet.Modular.Generator.targets b/UnitsNet.Modular/UnitsNet.Modular.Generator/buildTransitive/UnitsNet.Modular.Generator.targets
new file mode 100644
index 0000000000..d6814b4c36
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Generator/buildTransitive/UnitsNet.Modular.Generator.targets
@@ -0,0 +1,11 @@
+<Project>
+  <!--
+    Compatibility aliases for consumers that prefer domain-specific item names.
+    Native AdditionalFiles items are recommended because some IDE project models do not pass
+    custom build actions to their design-time Roslyn host.
+  -->
+  <ItemGroup>
+    <AdditionalFiles Include="@(UnitsNetDefinition)" UnitsNetDefinition="true" />
+    <AdditionalFiles Include="@(UnitsNetRelation)" UnitsNetRelation="true" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Tests/GeneratedQuantityTests.cs b/UnitsNet.Modular/UnitsNet.Modular.Tests/GeneratedQuantityTests.cs
new file mode 100644
index 0000000000..bece36f27e
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Tests/GeneratedQuantityTests.cs
@@ -0,0 +1,776 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Text.Json;
+using Fictional.Measurements;
+using UnitsNet;
+using UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.Modular.Tests;
+
+public sealed class GeneratedQuantityTests
+{
+    [Fact]
+    public void FormattingApis_IdentifyNumericFormatSyntax()
+    {
+        MethodInfo quantityToString = typeof(Length).GetMethod(nameof(Length.ToString), [typeof(string)])!;
+        StringSyntaxAttribute? quantitySyntax = quantityToString
+            .GetParameters()[0]
+            .GetCustomAttribute<StringSyntaxAttribute>();
+
+        MethodInfo descriptorFormat = typeof(IQuantityDescriptor).GetMethod(nameof(IQuantityDescriptor.Format))!;
+        StringSyntaxAttribute? descriptorSyntax = descriptorFormat
+            .GetParameters()[1]
+            .GetCustomAttribute<StringSyntaxAttribute>();
+
+        Assert.Equal(StringSyntaxAttribute.NumericFormat, quantitySyntax?.Syntax);
+        Assert.Equal(StringSyntaxAttribute.NumericFormat, descriptorSyntax?.Syntax);
+    }
+
+    [Fact]
+    public void GeneratedRegistry_SystemTextJsonRoundTripsBuiltInAndCustomQuantities()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(GeneratedQuantityRegistry.JsonConverter);
+
+        Length length = Length.FromKilometers(1.5);
+        HowMuch amount = HowMuch.FromLots(2);
+
+        Assert.Equal(length, JsonSerializer.Deserialize<Length>(JsonSerializer.Serialize(length, options), options));
+        Assert.Equal(amount, JsonSerializer.Deserialize<HowMuch>(JsonSerializer.Serialize(amount, options), options));
+    }
+
+    [Theory]
+    [InlineData("null")]
+    [InlineData("{}")]
+    [InlineData("""{"Value":1.5}""")]
+    [InlineData("""{"Value":1.5,"Unit":"Missing"}""")]
+    public void GeneratedRegistry_SystemTextJsonRejectsInvalidQuantityShapes(string json)
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(GeneratedQuantityRegistry.JsonConverter);
+
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Length>(json, options));
+    }
+
+    [Fact]
+    public void GeneratedRegistry_SystemTextJsonDoesNotGuessPolymorphicQuantityTypes()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(GeneratedQuantityRegistry.JsonConverter);
+
+        Assert.Throws<NotSupportedException>(
+            () => JsonSerializer.Deserialize<IQuantity<double>>(
+                """{"Value":1.5,"Unit":"Kilometer"}""",
+                options));
+    }
+
+    [Fact]
+    public void SystemTextJsonWithoutGeneratedConverterDoesNotUseTheStableStringUnitShape()
+    {
+        string json = JsonSerializer.Serialize(Length.FromKilometers(1.5));
+        using JsonDocument document = JsonDocument.Parse(json);
+
+        Assert.Equal(JsonValueKind.Number, document.RootElement.GetProperty("Unit").ValueKind);
+    }
+
+    [Fact]
+    public void GeneratedRegistry_SupportsCommonDynamicMigrationWorkflows()
+    {
+        QuantityRegistry registry = GeneratedQuantityRegistry.Instance;
+        var invariant = System.Globalization.CultureInfo.InvariantCulture;
+
+        Assert.Same(registry.Get("Length"), registry.Get(typeof(Length)));
+        Assert.Same(registry.Get("Length"), registry.Get(Length.Info.Id));
+        Assert.Same(registry.Get("Length"), registry.GetByUnitType(typeof(LengthUnit)));
+
+        var byName = Assert.IsType<Length>(registry.Create(3, "Length", "Centimeter"));
+        var byUnit = Assert.IsType<Length>(registry.Create(1.5, LengthUnit.Kilometer));
+        var parsed = Assert.IsType<Length>(registry.Parse(typeof(Length), "2 km", invariant));
+
+        Assert.Equal(3, byName.Centimeters, 10);
+        Assert.Equal(1500, byUnit.Meters, 10);
+        Assert.Equal(2000, parsed.Meters, 10);
+        Assert.Equal(1500, registry.Convert(1.5, "Length", "Kilometer", "Meter"), 10);
+        Assert.Equal(1500, registry.Convert(1.5, LengthUnit.Kilometer, LengthUnit.Meter), 10);
+        Assert.Equal(
+            "1.5 km",
+            registry.Get("Length").Format(byUnit, null, invariant));
+
+        Assert.True(
+            registry.TryCreate(
+                2,
+                "Length",
+                "Meter",
+                out IQuantity<double>? created));
+        Assert.IsType<Length>(created);
+        Assert.True(registry.TryCreate(2, LengthUnit.Meter, out created));
+        Assert.IsType<Length>(created);
+        Assert.True(registry.TryConvert(2, "Length", "Kilometer", "Meter", out double converted));
+        Assert.Equal(2000, converted, 10);
+        Assert.True(registry.TryConvert(2, LengthUnit.Kilometer, LengthUnit.Meter, out converted));
+        Assert.Equal(2000, converted, 10);
+        Assert.True(
+            registry.TryParse(
+                typeof(Length),
+                "2 km",
+                invariant,
+                out IQuantity<double>? parsedValue));
+        Assert.IsType<Length>(parsedValue);
+
+        Assert.False(registry.TryCreate(2, "Missing", "Meter", out _));
+        Assert.False(registry.TryCreate(2, "Length", "Missing", out _));
+        Assert.False(registry.TryCreate(2, (LengthUnit)(-1), out _));
+        Assert.False(registry.TryConvert(2, "Length", "Missing", "Meter", out _));
+        Assert.False(registry.TryConvert(2, LengthUnit.Meter, MassUnit.Kilogram, out _));
+        Assert.False(registry.TryParse(typeof(DateTime), "2 km", invariant, out _));
+    }
+
+    [Fact]
+    public void GeneratedRegistry_FindsOnlySelectedQuantitiesWithMatchingDimensions()
+    {
+        QuantityRegistry registry = GeneratedQuantityRegistry.Instance;
+
+        IReadOnlyList<IQuantityDescriptor> matches =
+            registry.FindByBaseDimensions(Length.Info.BaseDimensions);
+
+        Assert.Contains(matches, descriptor => descriptor.QuantityType == typeof(Length));
+        Assert.DoesNotContain(matches, descriptor => descriptor.QuantityType == typeof(Area));
+        Assert.All(matches, descriptor => Assert.Equal(Length.Info.BaseDimensions, descriptor.BaseDimensions));
+        Assert.Throws<NotSupportedException>(
+            () => ((IList<IQuantityDescriptor>)matches).Add(registry.Get("Area")));
+    }
+
+    [Fact]
+    public void GeneratedQuantityFacade_ProvidesOwnerScopedDynamicApi()
+    {
+        var invariant = System.Globalization.CultureInfo.InvariantCulture;
+
+        Assert.Same(GeneratedQuantityRegistry.Instance, Quantity.Registry);
+        Assert.Contains("Length", Quantity.Names);
+        Assert.Same(Quantity.Registry.Get("Length"), Quantity.ByName["length"]);
+        Assert.Contains(Quantity.Infos, descriptor => descriptor.QuantityType == typeof(Length));
+
+        IQuantity<double> byName = Quantity.From(1.5, "Length", "Kilometer");
+        IQuantity<double> bySystem =
+            Quantity.From(1.5, "Length", UnitSystem.SI);
+        IQuantity<double> byUnit = Quantity.From(1.5, LengthUnit.Kilometer);
+        IQuantity<double> parsed = Quantity.Parse(invariant, typeof(Length), "1.5 km");
+
+        Assert.Equal(1500, Assert.IsType<Length>(byName).Meters, 10);
+        Assert.Equal(1.5, Assert.IsType<Length>(bySystem).Meters, 10);
+        Assert.Equal(1500, Assert.IsType<Length>(byUnit).Meters, 10);
+        Assert.Equal(1500, Assert.IsType<Length>(parsed).Meters, 10);
+        Assert.True(Quantity.TryFrom(2, "Length", "Meter", out IQuantity<double>? created));
+        Assert.IsType<Length>(created);
+        Assert.True(Quantity.TryFrom(2, "Length", UnitSystem.SI, out created));
+        Assert.IsType<Length>(created);
+        Assert.True(Quantity.TryFrom(2, LengthUnit.Meter, out created));
+        Assert.IsType<Length>(created);
+        Assert.True(Quantity.TryParse(typeof(Length), "2 km", out IQuantity<double>? parsedValue));
+        Assert.IsType<Length>(parsedValue);
+        Assert.False(Quantity.TryFrom(2, "Missing", "Meter", out _));
+        Assert.False(Quantity.TryParse(typeof(DateTime), "2 km", out _));
+        Assert.Contains(
+            Quantity.GetQuantitiesWithBaseDimensions(Length.Info.BaseDimensions),
+            descriptor => descriptor.QuantityType == typeof(Length));
+    }
+
+    [Fact]
+    public void DynamicQuantityContracts_DoNotExposeObjectValues()
+    {
+        Type[] contractTypes =
+        {
+            typeof(IQuantityDescriptor),
+            typeof(QuantityInfo<Length, LengthUnit>),
+            typeof(QuantityRegistry),
+            typeof(Quantity),
+        };
+        string[] objectContracts = contractTypes
+            .SelectMany(GetObjectContracts)
+            .OrderBy(member => member, StringComparer.Ordinal)
+            .ToArray();
+
+        Assert.Empty(objectContracts);
+
+        static IEnumerable<string> GetObjectContracts(Type type)
+        {
+            const System.Reflection.BindingFlags flags =
+                System.Reflection.BindingFlags.Public |
+                System.Reflection.BindingFlags.Instance |
+                System.Reflection.BindingFlags.Static |
+                System.Reflection.BindingFlags.DeclaredOnly;
+            IEnumerable<string> methods = type
+                .GetMethods(flags)
+                .Where(method =>
+                    IsObject(method.ReturnType) ||
+                    method.GetParameters().Any(parameter => IsObject(parameter.ParameterType)))
+                .Select(method => $"{type.FullName}.{method}");
+            IEnumerable<string> constructors = type
+                .GetConstructors(flags)
+                .Where(constructor =>
+                    constructor.GetParameters().Any(parameter => IsObject(parameter.ParameterType)))
+                .Select(constructor => $"{type.FullName}.{constructor}");
+            IEnumerable<string> properties = type
+                .GetProperties(flags)
+                .Where(property => IsObject(property.PropertyType))
+                .Select(property => $"{type.FullName}.{property}");
+            return methods.Concat(constructors).Concat(properties);
+        }
+
+        static bool IsObject(Type type) =>
+            (type.IsByRef ? type.GetElementType() : type) == typeof(object);
+    }
+
+    [Fact]
+    public void GeneratedQuantity_InfoIsCanonicalAndImmutable()
+    {
+        IQuantityDescriptor descriptor =
+            GeneratedQuantityRegistry.Instance.Get(typeof(Length));
+        Length value = Length.FromKilometers(1.5);
+        UnitInfo<LengthUnit> kilometer = Length.Info[LengthUnit.Kilometer];
+
+        Assert.Same(Length.Info, descriptor);
+        Assert.Same(Length.Info.Units, Length.Info.UnitInfos);
+        Assert.Same(Length.Info.BaseUnit, Length.Info.BaseUnitInfo);
+        Assert.Equal(LengthUnit.Meter, Length.Info.BaseUnit.Value);
+        Assert.Equal(LengthUnit.Kilometer, kilometer.Value);
+        Assert.Equal(kilometer.SingularName, kilometer.Name);
+        Assert.Equal(kilometer.SingularName, kilometer.ToString());
+        Assert.Equal(value, Length.From(1.5, kilometer.Value));
+        Assert.True(Length.Info.TryGetUnitInfo(LengthUnit.Kilometer, out UnitInfo<LengthUnit>? found));
+        Assert.Same(kilometer, found);
+        Assert.Same(
+            kilometer,
+            Length.Info.GetUnitInfoFor(new BaseUnits(length: "Kilometer")));
+        Assert.Same(Length.Info.BaseUnit, Length.Info.GetUnit(UnitSystem.SI));
+        Assert.Throws<NotSupportedException>(
+            () => ((IList<UnitInfo<LengthUnit>>)Length.Info.Units).Add(kilometer));
+
+        Assert.Equal(
+            System.ComponentModel.EditorBrowsableState.Never,
+            typeof(UnitInfo<LengthUnit>)
+                .GetProperty(nameof(UnitInfo<LengthUnit>.Name))!
+                .GetCustomAttributes(typeof(System.ComponentModel.EditorBrowsableAttribute), inherit: false)
+                .Cast<System.ComponentModel.EditorBrowsableAttribute>()
+                .Single()
+                .State);
+    }
+
+    [Fact]
+    public void GeneratedQuantity_DoesNotDuplicateDescriptiveMetadata()
+    {
+        const System.Reflection.BindingFlags publicMembers =
+            System.Reflection.BindingFlags.Public |
+            System.Reflection.BindingFlags.Instance |
+            System.Reflection.BindingFlags.Static;
+
+        Assert.NotNull(typeof(Length).GetProperty(nameof(Length.Info), publicMembers));
+        Assert.Null(typeof(Length).GetProperty("QuantityId", publicMembers));
+        Assert.Null(typeof(Length).GetProperty("BaseUnit", publicMembers));
+        Assert.Null(typeof(Length).GetProperty("BaseDimensions", publicMembers));
+        Assert.Null(typeof(Length).GetProperty("Units", publicMembers));
+        Assert.Null(typeof(Length).GetProperty("UnitInfos", publicMembers));
+        Assert.Null(typeof(Length).GetProperty("QuantityInfo", publicMembers));
+
+        AssertHidden(typeof(global::UnitsNet.Modular.SourceGen.IQuantityMetadata<>));
+        AssertHidden(typeof(global::UnitsNet.Modular.SourceGen.QuantityOperations));
+        AssertHidden(typeof(global::UnitsNet.Modular.SourceGen.QuantityJsonConverter<>));
+        AssertHidden(typeof(QuantityInfo<Length, LengthUnit>).GetConstructors().Single());
+        AssertHidden(typeof(QuantityInfo<Length, LengthUnit>).GetProperty("BaseUnitInfo")!);
+        AssertHidden(typeof(QuantityInfo<Length, LengthUnit>).GetProperty("UnitInfos")!);
+
+        static void AssertHidden(System.Reflection.MemberInfo member) =>
+            Assert.Equal(
+                System.ComponentModel.EditorBrowsableState.Never,
+                member.GetCustomAttributes(typeof(System.ComponentModel.EditorBrowsableAttribute), inherit: false)
+                    .Cast<System.ComponentModel.EditorBrowsableAttribute>()
+                    .Single()
+                    .State);
+    }
+
+    [Fact]
+    public void RuntimeNamespaces_SeparateQuantityConceptsFromModuleInfrastructure()
+    {
+        Assert.Equal("UnitsNet", typeof(IQuantity<>).Namespace);
+        Assert.Equal("UnitsNet", typeof(QuantityId).Namespace);
+        Assert.Equal("UnitsNet", typeof(QuantityInfo<,>).Namespace);
+        Assert.Equal("UnitsNet", typeof(UnitSystem).Namespace);
+        Assert.Equal("UnitsNet", typeof(GeneratedQuantityRegistry).Namespace);
+        Assert.Equal("UnitsNet.Modular", typeof(UnitsNetModuleAttribute).Namespace);
+        Assert.Equal("UnitsNet", typeof(QuantityRegistry).Namespace);
+        Assert.Equal(
+            "UnitsNet.Modular.SourceGen",
+            typeof(global::UnitsNet.Modular.SourceGen.IQuantityMetadata<>).Namespace);
+        Assert.Equal(
+            "UnitsNet.Modular.SourceGen",
+            typeof(global::UnitsNet.Modular.SourceGen.QuantityOperations).Namespace);
+    }
+
+    [Fact]
+    public void GeneratedRegistry_RetainsBaseUnitsAndResolvesImmutableUnitSystems()
+    {
+        QuantityRegistry registry = GeneratedQuantityRegistry.Instance;
+        IQuantityDescriptor length = registry.Get("Length");
+        IQuantityDescriptor force = registry.Get("Force");
+        IQuantityDescriptor density = registry.Get("Density");
+        IQuantityDescriptor information = registry.Get("Information");
+
+        Assert.Equal(
+            new BaseUnits(length: "Meter"),
+            length.Units.Single(unit => unit.Name == "Meter").BaseUnits);
+        Assert.Equal(
+            new BaseUnits(length: "Kilometer"),
+            length.Units.Single(unit => unit.Name == "Kilometer").BaseUnits);
+        Assert.Equal(
+            new BaseUnits(length: "Meter", mass: "Kilogram", time: "Second"),
+            force.Units.Single(unit => unit.Name == "Newton").BaseUnits);
+        Assert.Equal(
+            new BaseUnits(length: "Meter", mass: "Kilogram"),
+            density.Units.Single(unit => unit.Name == "KilogramPerCubicMeter").BaseUnits);
+
+        Assert.Equal("Meter", length.GetUnit(UnitSystem.SI).Name);
+        Assert.Equal("Newton", force.GetUnit(UnitSystem.SI).Name);
+        Assert.Equal("KilogramPerCubicMeter", density.GetUnit(UnitSystem.SI).Name);
+        Assert.Equal(information.BaseUnitName, information.GetUnit(UnitSystem.SI).Name);
+
+        var imperialLength = new UnitSystem(
+            new BaseUnits(length: "Foot"));
+        Assert.Equal("Foot", length.GetUnit(imperialLength).Name);
+        Assert.True(length.TryGetUnit(imperialLength, out UnitDescriptor? selected));
+        Assert.Equal("Foot", selected!.Name);
+        Assert.Equal(LengthUnit.Meter, new Length(2, UnitSystem.SI).Unit);
+        Assert.Equal(LengthUnit.Meter, Length.From(2, UnitSystem.SI).Unit);
+        Assert.Equal(ForceUnit.Newton, new Force(2, UnitSystem.SI).Unit);
+        Assert.Equal(Information.Info.BaseUnit.Value, new Information(2, UnitSystem.SI).Unit);
+        Assert.Equal(LengthUnit.Foot, new Length(2, imperialLength).Unit);
+        Assert.Equal(1000, Length.FromKilometers(1).As(UnitSystem.SI), 10);
+        Assert.Equal(LengthUnit.Meter, Length.FromKilometers(1).ToUnit(UnitSystem.SI).Unit);
+
+        var registryValue = Assert.IsType<Length>(
+            registry.Create(2, "Length", UnitSystem.SI));
+        Assert.Equal(LengthUnit.Meter, registryValue.Unit);
+        Assert.Equal(
+            1000,
+            registry.Convert(1, "Length", "Kilometer", UnitSystem.SI),
+            10);
+        Assert.True(
+            registry.TryCreate(
+                2,
+                "Length",
+                UnitSystem.SI,
+                out IQuantity<double>? created));
+        Assert.IsType<Length>(created);
+        Assert.True(
+            registry.TryConvert(
+                1,
+                "Length",
+                "Kilometer",
+                UnitSystem.SI,
+                out double converted));
+        Assert.Equal(1000, converted, 10);
+
+        var unavailable = new UnitSystem(
+            new BaseUnits(length: "Smoot"));
+        Assert.False(length.TryGetUnit(unavailable, out _));
+        Assert.Throws<ArgumentException>(() => length.GetUnit(unavailable));
+        Assert.Throws<ArgumentException>(() => new Length(2, unavailable));
+        Assert.Throws<ArgumentException>(() => Length.FromMeters(2).As(unavailable));
+        Assert.False(registry.TryCreate(2, "Length", unavailable, out _));
+        Assert.False(registry.TryConvert(2, "Length", "Meter", unavailable, out _));
+        Assert.False(Quantity.TryFrom(2, "Length", unavailable, out _));
+        Assert.Throws<ArgumentException>(() => new UnitSystem(BaseUnits.Undefined));
+        Assert.True(
+            new BaseUnits(length: "Meter", time: "Second")
+                .IsSubsetOf(UnitSystem.SI.BaseUnits));
+        Assert.False(
+            new BaseUnits(length: "Foot")
+                .IsSubsetOf(UnitSystem.SI.BaseUnits));
+    }
+
+    [Fact]
+    public void ConversionAndParsing_ReuseRuntimeBehavior()
+    {
+        Length distance = Length.Parse("1.5 km");
+
+        Assert.Equal(1500, distance.Meters, 10);
+        Assert.Equal(150_000, distance.Centimeters, 10);
+        Assert.Equal("1.5 km", distance.ToString(null, System.Globalization.CultureInfo.InvariantCulture));
+    }
+
+    [Fact]
+    public void GeneratedConversion_InvalidUnitsRetainFriendlyExceptionsWithoutMetadataPrevalidation()
+    {
+        var invalidUnit = (LengthUnit)999;
+        Length distance = Length.FromMeters(1);
+
+        AssertInvalidUnit(() => { _ = new Length(1, invalidUnit); });
+        AssertInvalidUnit(() => { _ = distance.As(invalidUnit); });
+        AssertInvalidUnit(() => { _ = Length.Convert(1, invalidUnit, LengthUnit.Meter); });
+        AssertInvalidUnit(() => { _ = Length.Convert(1, LengthUnit.Meter, invalidUnit); });
+
+        void AssertInvalidUnit(Action action)
+        {
+            ArgumentOutOfRangeException exception = Assert.Throws<ArgumentOutOfRangeException>(action);
+
+            Assert.Equal("unit", exception.ParamName);
+            Assert.Equal(invalidUnit, Assert.IsType<LengthUnit>(exception.ActualValue));
+            Assert.Contains("Unit is not generated for Length.", exception.Message, StringComparison.Ordinal);
+        }
+    }
+
+    [Fact]
+    public void UnitPattern_ExcludesNonMatchingUnit()
+    {
+        string[] names = Enum.GetNames<InformationUnit>();
+
+        Assert.Contains("Bit", names);
+        Assert.Contains("Byte", names);
+        Assert.Contains("Kilobyte", names);
+        Assert.Contains("Kibibyte", names);
+        Assert.DoesNotContain("Octet", names);
+        Assert.DoesNotContain("Kibioctet", names);
+    }
+
+    [Fact]
+    public void DerivedOperators_AppearWhenAllQuantitiesAreSelected()
+    {
+        Area area = Length.FromMeters(2) * Length.FromMeters(4);
+
+        Assert.Equal(8, area.SquareMeters, 10);
+    }
+
+    [Fact]
+    public void BuiltInAugmentation_CalculatesCircleAreaFromLength()
+    {
+        Area fromDiameter = Area.FromCircleDiameter(Length.FromMeters(4));
+        Area fromRadius = Area.FromCircleRadius(Length.FromCentimeters(200));
+
+        Assert.Equal(4 * Math.PI, fromDiameter.SquareMeters, 12);
+        Assert.Equal(fromDiameter, fromRadius);
+    }
+
+    [Fact]
+    public void BuiltInRelations_GenerateCommutativeAndInferredOperators()
+    {
+        Mass mass = Mass.FromKilograms(3);
+        Acceleration acceleration = Acceleration.FromMetersPerSecondSquared(4);
+
+        Force forward = mass * acceleration;
+        Force reversed = acceleration * mass;
+
+        Assert.Equal(12, forward.Newtons, 10);
+        Assert.Equal(forward, reversed);
+        Assert.Equal(mass, forward / acceleration);
+        Assert.Equal(acceleration, forward / mass);
+    }
+
+    [Fact]
+    public void RepresentativeCatalog_SupportsAffineLogarithmicAndBinaryConversions()
+    {
+        Temperature boiling = Temperature.FromDegreesCelsius(100);
+        Level combined = Level.FromDecibels(10) + Level.FromDecibels(10);
+        Information data = Information.FromKibibytes(2);
+
+        Assert.Equal(373.15, boiling.Kelvins, 10);
+        Assert.Equal(212, boiling.DegreesFahrenheit, 10);
+        Assert.Equal(13.010299956639813, combined.Decibels, 10);
+        Assert.Equal(16_384, data.Bits, 10);
+    }
+
+    [Fact]
+    public void BuiltInDefinition_PreservesLocalizedAbbreviations()
+    {
+        var russian = System.Globalization.CultureInfo.GetCultureInfo("ru-RU");
+
+        Length length = Length.Parse("2 м", russian);
+
+        Assert.Equal(2, length.Meters, 10);
+        Assert.Equal("2 м", length.ToString(null, russian));
+    }
+
+    [Fact]
+    public void Parsing_DistinguishesCaseSensitiveSiPrefixes()
+    {
+        Length millimeters = Length.Parse("2 mm", System.Globalization.CultureInfo.InvariantCulture);
+        Length megameters = Length.Parse("2 Mm", System.Globalization.CultureInfo.InvariantCulture);
+
+        Assert.Equal(0.002, millimeters.Meters, 10);
+        Assert.Equal(2_000_000, megameters.Meters, 10);
+    }
+
+    [Fact]
+    public void CustomQuantity_GetsSameGeneratedSurfaceInOwnNamespace()
+    {
+        HowMuch amount = HowMuch.Parse("10 tons");
+
+        Assert.Equal(200, amount.Some, 10);
+        Assert.Equal(100, amount.Lots, 10);
+        Assert.Equal("Fictional.Measurements.HowMuch", typeof(HowMuch).FullName);
+    }
+
+    [Fact]
+    public void CustomRelationFile_GeneratesRelationshipOperator()
+    {
+        HowMuch product = HowMuch.FromSome(2) * HowMuch.FromSome(3);
+
+        Assert.Equal(6, product.Lots, 10);
+        Assert.Equal(12, product.Some, 10);
+    }
+
+    [Fact]
+    public void JsonDefinition_SupportsPrefixesLocalizationAndNonlinearConversions()
+    {
+        var norwegian = System.Globalization.CultureInfo.GetCultureInfo("nb-NO");
+
+        HowMuch localized = HowMuch.Parse("10 tonnevis", norwegian);
+        HowMuch nonlinear = HowMuch.FromMagnitudes(3);
+        HowMuch prefixed = HowMuch.FromKilosome(2);
+        HowMuch alternatePrefixed = HowMuch.Parse("2 kn", norwegian);
+
+        Assert.Equal(200, localized.Some, 10);
+        Assert.Equal("10 tonnevis", localized.ToString(null, norwegian));
+        Assert.Equal(9, nonlinear.Some, 10);
+        Assert.Equal(3, nonlinear.Magnitudes, 10);
+        Assert.Equal(2000, prefixed.Some, 10);
+        Assert.Equal(2000, alternatePrefixed.Some, 10);
+        Assert.Equal("2 knoe", prefixed.ToString(null, norwegian));
+    }
+
+    [Fact]
+    public void Net10GeneratedQuantities_SupportGenericParsingAndMath()
+    {
+        Length parsed = Parse<Length>("1.5 km");
+        Length total = Add(parsed, Length.FromMeters(500));
+
+        Assert.Equal(2, total.Kilometers, 10);
+    }
+
+    [Fact]
+    public void GeneratedQuantity_ImplementsMinimalSelfTypedModularContract()
+    {
+        Assert.Equal(new QuantityId("UnitsNet.Length"), Length.Info.Id);
+        Assert.Equal(LengthUnit.Meter, Length.Info.BaseUnit.Value);
+
+        Length length = Create<Length, LengthUnit>(2, LengthUnit.Meter);
+        IQuantity<Length, LengthUnit> stored = length;
+        IQuantity<double> erased = length;
+        Assert.Equal(2d, stored.Value);
+        Assert.Equal(LengthUnit.Meter, stored.Unit);
+        Assert.Equal(LengthUnit.Meter, erased.Unit);
+        Assert.Equal(1000, ConvertValue<Length, LengthUnit>(1, LengthUnit.Kilometer, LengthUnit.Meter), 10);
+        Assert.Equal(1000, Length.FromKilometers(1).As(LengthUnit.Meter), 10);
+
+        const System.Reflection.BindingFlags publicMembers =
+            System.Reflection.BindingFlags.Public |
+            System.Reflection.BindingFlags.Instance |
+            System.Reflection.BindingFlags.Static;
+        Assert.Null(typeof(Length).GetProperty("BaseValue", publicMembers));
+        Assert.Null(typeof(Length).GetProperty("UnitName", publicMembers));
+    }
+
+    [Fact]
+    public void QuantityId_RequiresANonEmptyValue()
+    {
+        Assert.Throws<ArgumentNullException>(() => new QuantityId(null!));
+        Assert.Throws<ArgumentException>(() => new QuantityId(" "));
+        Assert.Equal("Sample.Distance", new QuantityId("Sample.Distance").Value);
+    }
+
+    [Fact]
+    public void GeneratedQuantities_AdvertiseTheirArithmeticCapabilities()
+    {
+        AssertLinearCapability<Length, LengthUnit>();
+        AssertLinearCapability<TemperatureDelta, TemperatureDeltaUnit>();
+        AssertAffineCapability<Temperature, TemperatureUnit, TemperatureDelta>();
+        AssertLogarithmicCapability<Level, LevelUnit>();
+        Assert.DoesNotContain(
+            typeof(Temperature).GetInterfaces(),
+            type => type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ILinearQuantity<>));
+        Assert.DoesNotContain(
+            typeof(Level).GetInterfaces(),
+            type => type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ILinearQuantity<>));
+    }
+
+    [Theory]
+    [InlineData(0d)]
+    [InlineData(double.NaN)]
+    [InlineData(double.PositiveInfinity)]
+    [InlineData(double.NegativeInfinity)]
+    public void LinearQuantity_ConversionPreservesZeroAndNonFiniteValues(double meters)
+    {
+        double kilometers = Length.FromMeters(meters).Kilometers;
+        double roundTrip = Length.FromKilometers(kilometers).Meters;
+
+        if (double.IsNaN(meters))
+        {
+            Assert.True(double.IsNaN(kilometers));
+            Assert.True(double.IsNaN(roundTrip));
+            return;
+        }
+
+        Assert.Equal(meters / 1000d, kilometers);
+        Assert.Equal(meters, roundTrip);
+    }
+
+    [Fact]
+    public void AffineQuantity_UsesLinearOffsetsAndSupportsGenericAverage()
+    {
+        Temperature freezing = Temperature.FromDegreesCelsius(0);
+        Temperature boiling = Temperature.FromDegreesFahrenheit(212);
+
+        TemperatureDelta interval = Difference<Temperature, TemperatureUnit, TemperatureDelta>(boiling, freezing);
+        Temperature raised = AddOffset<Temperature, TemperatureUnit, TemperatureDelta>(freezing, interval);
+        Temperature commutative = interval + freezing;
+        Temperature lowered = boiling - interval;
+        Temperature average = new[] { freezing, boiling }.Average(TemperatureUnit.DegreeCelsius);
+
+        Assert.Equal(100, interval.DegreesCelsius, 10);
+        Assert.Equal(100, raised.DegreesCelsius, 10);
+        Assert.Equal(100, commutative.DegreesCelsius, 10);
+        Assert.Equal(0, lowered.DegreesCelsius, 10);
+        Assert.Equal(50, average.DegreesCelsius, 10);
+        Assert.True(freezing.Equals(
+            Temperature.FromDegreesCelsius(0.05),
+            TemperatureDelta.FromDegreesCelsius(0.1)));
+        Assert.False(freezing.Equals(
+            Temperature.FromDegreesCelsius(0.2),
+            TemperatureDelta.FromDegreesCelsius(0.1)));
+        Assert.Throws<InvalidOperationException>(() =>
+            Array.Empty<Temperature>().Average(TemperatureUnit.Kelvin));
+    }
+
+    [Fact]
+    public void FirstUnitAggregations_DoNotMaterializeInputSequences()
+    {
+        var temperatures = new NonMaterializableCollection<Temperature>(
+            Temperature.FromDegreesCelsius(10),
+            Temperature.FromDegreesCelsius(30));
+        var levels = new NonMaterializableCollection<Level>(
+            Level.FromDecibels(10),
+            Level.FromDecibels(20));
+
+        Temperature temperatureAverage = temperatures.Average();
+        Level levelSum = levels.Sum();
+        Level arithmeticMean = levels.ArithmeticMean();
+        Level geometricMean = levels.GeometricMean();
+
+        Assert.Equal(TemperatureUnit.DegreeCelsius, temperatureAverage.Unit);
+        Assert.Equal(LevelUnit.Decibel, levelSum.Unit);
+        Assert.Equal(LevelUnit.Decibel, arithmeticMean.Unit);
+        Assert.Equal(LevelUnit.Decibel, geometricMean.Unit);
+        Assert.Throws<InvalidOperationException>(() => Array.Empty<Temperature>().Average());
+        Assert.Throws<InvalidOperationException>(() => Array.Empty<Level>().Sum());
+    }
+
+    [Fact]
+    public void QuantityMath_SumsAndAveragesMixedUnits()
+    {
+        Length sum = QuantityMath.Sum(new[]
+        {
+            Length.FromKilometers(1),
+            Length.FromMeters(500),
+        });
+        Length targetedSum = QuantityMath.Sum(
+            new[] { Length.FromKilometers(1), Length.FromMeters(500) },
+            LengthUnit.Meter);
+        Length average = QuantityMath.Average(new[]
+        {
+            Length.FromMeters(1),
+            Length.FromCentimeters(300),
+        });
+        Length targetedAverage = QuantityMath.Average(
+            new[] { Length.FromMeters(1), Length.FromCentimeters(300) },
+            LengthUnit.Centimeter);
+
+        Assert.Equal(1.5, sum.Kilometers, 10);
+        Assert.Equal(1500, targetedSum.Meters, 10);
+        Assert.Equal(2, average.Meters, 10);
+        Assert.Equal(200, targetedAverage.Centimeters, 10);
+        Assert.Equal(Length.Zero, QuantityMath.Sum(Array.Empty<Length>()));
+    }
+
+    [Fact]
+    public void DefaultQuantity_UsesBaseUnitLikeUnitsNet()
+    {
+        Length value = default;
+
+        Assert.Equal(LengthUnit.Meter, value.Unit);
+        Assert.Equal(0, value.Meters);
+        Assert.Equal(Length.Zero, value);
+        Assert.Equal(Length.Zero.GetHashCode(), value.GetHashCode());
+        Assert.Equal("0 m", value.ToString(null, System.Globalization.CultureInfo.InvariantCulture));
+    }
+
+    private static T Parse<T>(string text)
+        where T : IParsable<T>
+        => T.Parse(text, System.Globalization.CultureInfo.InvariantCulture);
+
+    private static T Add<T>(T left, T right)
+        where T : System.Numerics.IAdditionOperators<T, T, T>
+        => left + right;
+
+    private static TQuantity Create<TQuantity, TUnit>(double value, TUnit unit)
+        where TQuantity : IQuantity<TQuantity, TUnit, double>
+        where TUnit : struct, Enum
+        => TQuantity.From(value, unit);
+
+    private static double ConvertValue<TQuantity, TUnit>(double value, TUnit fromUnit, TUnit toUnit)
+        where TQuantity : IQuantity<TQuantity, TUnit, double>
+        where TUnit : struct, Enum
+        => TQuantity.Convert(value, fromUnit, toUnit);
+
+    private static void AssertLinearCapability<TQuantity, TUnit>()
+        where TQuantity : ILinearQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+        => Assert.Equal(TQuantity.Info.BaseUnit.Value, TQuantity.Zero.Unit);
+
+    private static void AssertAffineCapability<TQuantity, TUnit, TOffset>()
+        where TQuantity : IAffineQuantity<TQuantity, TUnit, TOffset>
+        where TUnit : struct, Enum
+        where TOffset : ILinearQuantity<TOffset>
+        => Assert.Contains(
+            typeof(IAffineQuantity<TQuantity, TUnit, TOffset>),
+            typeof(TQuantity).GetInterfaces());
+
+    private static TQuantity AddOffset<TQuantity, TUnit, TOffset>(TQuantity quantity, TOffset offset)
+        where TQuantity : IAffineQuantity<TQuantity, TUnit, TOffset>
+        where TUnit : struct, Enum
+        where TOffset : ILinearQuantity<TOffset>
+        => quantity + offset;
+
+    private static TOffset Difference<TQuantity, TUnit, TOffset>(TQuantity left, TQuantity right)
+        where TQuantity : IAffineQuantity<TQuantity, TUnit, TOffset>
+        where TUnit : struct, Enum
+        where TOffset : ILinearQuantity<TOffset>
+        => left - right;
+
+    private static void AssertLogarithmicCapability<TQuantity, TUnit>()
+        where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+        => Assert.Equal(TQuantity.Info.BaseUnit.Value, TQuantity.Zero.Unit);
+
+    private sealed class NonMaterializableCollection<T>(params T[] values) : ICollection<T>
+    {
+        public int Count => values.Length;
+
+        public bool IsReadOnly => true;
+
+        public IEnumerator<T> GetEnumerator() => ((IEnumerable<T>)values).GetEnumerator();
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public bool Contains(T item) => values.Contains(item);
+
+        public void CopyTo(T[] array, int arrayIndex) =>
+            throw new InvalidOperationException("The aggregation attempted to materialize its input.");
+
+        public void Add(T item) => throw new NotSupportedException();
+
+        public void Clear() => throw new NotSupportedException();
+
+        public bool Remove(T item) => throw new NotSupportedException();
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Tests/HowMuch.unitsnet.json b/UnitsNet.Modular/UnitsNet.Modular.Tests/HowMuch.unitsnet.json
new file mode 100644
index 0000000000..53b980f0ae
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Tests/HowMuch.unitsnet.json
@@ -0,0 +1,71 @@
+{
+  "Name": "HowMuch",
+  "Namespace": "Fictional.Measurements",
+  "BaseUnit": "Some",
+  "Units": [
+    {
+      "SingularName": "Some",
+      "PluralName": "Some",
+      "FromUnitToBaseFunc": "{x}",
+      "FromBaseToUnitFunc": "{x}",
+      "Prefixes": [ "Kilo" ],
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "sm" ]
+        },
+        {
+          "Culture": "nb-NO",
+          "Abbreviations": [ "noe" ],
+          "AbbreviationsForPrefixes": {
+            "Kilo": [ "knoe", "kn" ]
+          }
+        }
+      ]
+    },
+    {
+      "SingularName": "Lots",
+      "PluralName": "Lots",
+      "FromUnitToBaseFunc": "{x} * 2",
+      "FromBaseToUnitFunc": "{x} / 2",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "lots", "lts" ]
+        },
+        {
+          "Culture": "nb-NO",
+          "Abbreviations": [ "mye" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "Tons",
+      "PluralName": "Tons",
+      "FromUnitToBaseFunc": "({x} * 4) * 5",
+      "FromBaseToUnitFunc": "{x} / (4 * 5)",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "tons" ]
+        },
+        {
+          "Culture": "nb-NO",
+          "Abbreviations": [ "tonnevis" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "Magnitude",
+      "PluralName": "Magnitudes",
+      "FromUnitToBaseFunc": "Math.Pow({x}, 2)",
+      "FromBaseToUnitFunc": "Math.Sqrt({x})",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "mag" ]
+        }
+      ]
+    }
+  ]
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Tests/HowMuch.unitsnet.relations.json b/UnitsNet.Modular/UnitsNet.Modular.Tests/HowMuch.unitsnet.relations.json
new file mode 100644
index 0000000000..f21f375d23
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Tests/HowMuch.unitsnet.relations.json
@@ -0,0 +1,3 @@
+[
+  "HowMuch.Lots = HowMuch.Some * HowMuch.Some -- NoInferredDivision"
+]
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Tests/TestModule.cs b/UnitsNet.Modular/UnitsNet.Modular.Tests/TestModule.cs
new file mode 100644
index 0000000000..b0cf6033c5
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Tests/TestModule.cs
@@ -0,0 +1,38 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using UnitsNet.Modular;
+using Catalog = UnitsNet.Modular.BuiltIns;
+
+namespace UnitsNet.Modular.Tests;
+
+[UnitSet("regex:.*Byte$")]
+internal interface ByteUnitSet
+{
+}
+
+[QuantitySpec("Fictional.Measurements.HowMuch")]
+internal interface HowMuchSpec
+{
+}
+
+internal interface RepresentativeProfile :
+    IInclude<Catalog.LengthSpec>,
+    IInclude<Catalog.AreaSpec>,
+    IInclude<Catalog.TemperatureSpec>,
+    IInclude<Catalog.TemperatureDeltaSpec>,
+    IInclude<Catalog.LevelSpec>,
+    IInclude<Catalog.InformationSpec>
+{
+}
+
+[UnitsNetModule]
+internal interface TestUnits :
+    IIncludeProfile<RepresentativeProfile>,
+    IInclude<Catalog.MassSpec>,
+    IInclude<Catalog.DensitySpec>,
+    IInclude<Catalog.AccelerationSpec>,
+    IInclude<Catalog.ForceSpec>,
+    IInclude<Catalog.InformationSpec, ByteUnitSet>,
+    IInclude<HowMuchSpec>
+{
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Tests/UnitsNet.Modular.Tests.csproj b/UnitsNet.Modular/UnitsNet.Modular.Tests/UnitsNet.Modular.Tests.csproj
new file mode 100644
index 0000000000..e1f454c7e9
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Tests/UnitsNet.Modular.Tests.csproj
@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsTestProject>true</IsTestProject>
+    <TestFramework>xunit</TestFramework>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+    <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)Generated</CompilerGeneratedFilesOutputPath>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup>
+    <AdditionalFiles Include="HowMuch.unitsnet.json"
+                     UnitsNetDefinition="true" />
+    <AdditionalFiles Include="HowMuch.unitsnet.relations.json"
+                     UnitsNetRelation="true" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\UnitsNet.Modular\UnitsNet.Modular.csproj" />
+    <ProjectReference Include="..\UnitsNet.Modular.Generator\UnitsNet.Modular.Generator.csproj"
+                      OutputItemType="Analyzer"
+                      ReferenceOutputAssembly="false" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.Modular/UnitsNet.Modular.Versioning.props b/UnitsNet.Modular/UnitsNet.Modular.Versioning.props
new file mode 100644
index 0000000000..b17bb593cb
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular.Versioning.props
@@ -0,0 +1,27 @@
+<!-- Licensed under MIT No Attribution, see LICENSE file at the root. -->
+<Project>
+  <!--
+    Shared versioning policy for the Modular runtime and bundled generator.
+    Keep ordinary local builds incremental and avoid spawning MinVer once per target framework.
+    The local-package target passes a unique override explicitly when it packs, while CI/release
+    builds continue to let MinVer derive the version. A timestamp here would change generated
+    assembly metadata on every evaluation and force all downstream samples to compile again.
+  -->
+  <PropertyGroup Condition="'$(MSBuildProjectName)' == 'UnitsNet.Modular' or
+                            '$(MSBuildProjectName)' == 'UnitsNet.Modular.Generator'">
+    <UnitsNetModularPackForPublish
+        Condition="'$(UnitsNetModularPackForPublish)' == '' and '$(GITHUB_ACTIONS)' == 'true'">true</UnitsNetModularPackForPublish>
+    <UnitsNetModularPackForPublish
+        Condition="'$(UnitsNetModularPackForPublish)' == ''">false</UnitsNetModularPackForPublish>
+    <MinVerTagPrefix>UnitsNet.Modular/</MinVerTagPrefix>
+    <MinVerMinimumMajorMinor>6.0</MinVerMinimumMajorMinor>
+    <MinVerDefaultPreReleaseIdentifiers>alpha.0</MinVerDefaultPreReleaseIdentifiers>
+    <MinVerSkip
+        Condition="'$(UnitsNetModularPackForPublish)' != 'true' and '$(MinVerVersionOverride)' == ''">true</MinVerSkip>
+    <Version Condition="'$(MinVerSkip)' == 'true'">6.0.0-local.dev</Version>
+    <PackageVersion Condition="'$(MinVerSkip)' == 'true'">$(Version)</PackageVersion>
+    <AssemblyVersion>6.0.0.0</AssemblyVersion>
+    <FileVersion Condition="'$(MinVerSkip)' == 'true'">6.0.0.0</FileVersion>
+    <InformationalVersion Condition="'$(MinVerSkip)' == 'true'">$(Version)</InformationalVersion>
+  </PropertyGroup>
+</Project>
diff --git a/UnitsNet.Modular/UnitsNet.Modular/AssemblyInfo.cs b/UnitsNet.Modular/UnitsNet.Modular/AssemblyInfo.cs
new file mode 100644
index 0000000000..29002fad10
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+[assembly: System.CLSCompliant(true)]
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Math/AffineQuantityMath.cs b/UnitsNet.Modular/UnitsNet.Modular/Math/AffineQuantityMath.cs
new file mode 100644
index 0000000000..2e4f514b5a
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Math/AffineQuantityMath.cs
@@ -0,0 +1,53 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet;
+
+/// <summary>Reusable algorithms for quantities with affine conversion semantics.</summary>
+public static class AffineQuantityMath
+{
+    /// <summary>Calculates the arithmetic average of affine quantities in the first value's unit.</summary>
+    public static TQuantity Average<TQuantity, TUnit>(IEnumerable<TQuantity> quantities)
+        where TQuantity : IQuantity<TQuantity, TUnit, double>, IAffineQuantity<TQuantity>
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+        using IEnumerator<TQuantity> enumerator = quantities.GetEnumerator();
+        if (!enumerator.MoveNext())
+        {
+            throw new InvalidOperationException("Sequence contains no quantities.");
+        }
+
+        TQuantity first = enumerator.Current;
+        TUnit unit = first.Unit;
+        double result = first.Value;
+        var count = 1;
+        while (enumerator.MoveNext())
+        {
+            TQuantity quantity = enumerator.Current;
+            result += TQuantity.Convert(quantity.Value, quantity.Unit, unit);
+            count++;
+        }
+
+        return TQuantity.From(result / count, unit);
+    }
+
+    /// <summary>Calculates the arithmetic average of affine quantities in the requested unit.</summary>
+    public static TQuantity Average<TQuantity, TUnit>(IEnumerable<TQuantity> quantities, TUnit unit)
+        where TQuantity : IQuantity<TQuantity, TUnit, double>, IAffineQuantity<TQuantity>
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+
+        double result = 0;
+        var count = 0;
+        foreach (TQuantity quantity in quantities)
+        {
+            result += TQuantity.Convert(quantity.Value, quantity.Unit, unit);
+            count++;
+        }
+
+        return count == 0
+            ? throw new InvalidOperationException("Sequence contains no quantities.")
+            : TQuantity.From(result / count, unit);
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Math/LogarithmicQuantityMath.cs b/UnitsNet.Modular/UnitsNet.Modular/Math/LogarithmicQuantityMath.cs
new file mode 100644
index 0000000000..f1d0cab9ec
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Math/LogarithmicQuantityMath.cs
@@ -0,0 +1,168 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet;
+
+/// <summary>Reusable algorithms for quantities with logarithmic arithmetic semantics.</summary>
+public static class LogarithmicQuantityMath
+{
+    /// <summary>Sums logarithmic quantities in linear space and preserves the first value's unit.</summary>
+    public static TQuantity Sum<TQuantity, TUnit>(IEnumerable<TQuantity> quantities)
+        where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+        using IEnumerator<TQuantity> enumerator = quantities.GetEnumerator();
+        if (!enumerator.MoveNext())
+        {
+            throw new InvalidOperationException("Sequence contains no quantities.");
+        }
+
+        TQuantity first = enumerator.Current;
+        TUnit unit = first.Unit;
+        double scalingFactor = TQuantity.LogarithmicScalingFactor;
+        double sum = ToLinear(first.Value, scalingFactor);
+        while (enumerator.MoveNext())
+        {
+            TQuantity quantity = enumerator.Current;
+            sum += ToLinear(TQuantity.Convert(quantity.Value, quantity.Unit, unit), scalingFactor);
+        }
+
+        return TQuantity.From(ToLogarithmic(sum, scalingFactor), unit);
+    }
+
+    /// <summary>Sums logarithmic quantities in linear space and expresses the result in a target unit.</summary>
+    public static TQuantity Sum<TQuantity, TUnit>(IEnumerable<TQuantity> quantities, TUnit unit)
+        where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+        var hasValue = false;
+        var sum = 0d;
+        foreach (TQuantity quantity in quantities)
+        {
+            sum += ToLinear(TQuantity.Convert(quantity.Value, quantity.Unit, unit), TQuantity.LogarithmicScalingFactor);
+            hasValue = true;
+        }
+
+        return hasValue
+            ? TQuantity.From(ToLogarithmic(sum, TQuantity.LogarithmicScalingFactor), unit)
+            : throw new InvalidOperationException("Sequence contains no quantities.");
+    }
+
+    /// <summary>Calculates the arithmetic mean in linear space and preserves the first value's unit.</summary>
+    public static TQuantity ArithmeticMean<TQuantity, TUnit>(IEnumerable<TQuantity> quantities)
+        where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+        using IEnumerator<TQuantity> enumerator = quantities.GetEnumerator();
+        if (!enumerator.MoveNext())
+        {
+            throw new InvalidOperationException("Sequence contains no quantities.");
+        }
+
+        TQuantity first = enumerator.Current;
+        TUnit unit = first.Unit;
+        double scalingFactor = TQuantity.LogarithmicScalingFactor;
+        double sum = ToLinear(first.Value, scalingFactor);
+        var count = 1;
+        while (enumerator.MoveNext())
+        {
+            TQuantity quantity = enumerator.Current;
+            sum += ToLinear(TQuantity.Convert(quantity.Value, quantity.Unit, unit), scalingFactor);
+            count++;
+        }
+
+        return TQuantity.From(ToLogarithmic(sum / count, scalingFactor), unit);
+    }
+
+    /// <summary>Calculates the arithmetic mean in linear space in a target unit.</summary>
+    public static TQuantity ArithmeticMean<TQuantity, TUnit>(IEnumerable<TQuantity> quantities, TUnit unit)
+        where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+        var count = 0;
+        var sum = 0d;
+        foreach (TQuantity quantity in quantities)
+        {
+            sum += ToLinear(TQuantity.Convert(quantity.Value, quantity.Unit, unit), TQuantity.LogarithmicScalingFactor);
+            count++;
+        }
+
+        return count == 0
+            ? throw new InvalidOperationException("Sequence contains no quantities.")
+            : TQuantity.From(ToLogarithmic(sum / count, TQuantity.LogarithmicScalingFactor), unit);
+    }
+
+    /// <summary>Calculates UnitsNet-compatible geometric mean semantics in the first value's unit.</summary>
+    public static TQuantity GeometricMean<TQuantity, TUnit>(IEnumerable<TQuantity> quantities)
+        where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+        using IEnumerator<TQuantity> enumerator = quantities.GetEnumerator();
+        if (!enumerator.MoveNext())
+        {
+            throw new InvalidOperationException("Sequence contains no quantities.");
+        }
+
+        TQuantity first = enumerator.Current;
+        TUnit unit = first.Unit;
+        double sum = first.Value;
+        var count = 1;
+        while (enumerator.MoveNext())
+        {
+            TQuantity quantity = enumerator.Current;
+            sum += TQuantity.Convert(quantity.Value, quantity.Unit, unit);
+            count++;
+        }
+
+        return TQuantity.From(double.RootN(sum, count), unit);
+    }
+
+    /// <summary>Calculates UnitsNet-compatible geometric mean semantics in a target unit.</summary>
+    public static TQuantity GeometricMean<TQuantity, TUnit>(IEnumerable<TQuantity> quantities, TUnit unit)
+        where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+        var count = 0;
+        var sum = 0d;
+        foreach (TQuantity quantity in quantities)
+        {
+            sum += TQuantity.Convert(quantity.Value, quantity.Unit, unit);
+            count++;
+        }
+
+        return count == 0
+            ? throw new InvalidOperationException("Sequence contains no quantities.")
+            : TQuantity.From(double.RootN(sum, count), unit);
+    }
+
+    /// <summary>Compares logarithmic quantities with a logarithmic absolute tolerance.</summary>
+    /// <remarks>
+    /// The comparison converts all values to linear space and is therefore approximate. Avoid a
+    /// zero logarithmic tolerance: it maps to one in linear space rather than to zero. Prefer the
+    /// quantity's normal equality operation when no tolerance is required.
+    /// </remarks>
+    public static bool Equals<TQuantity, TUnit>(
+        TQuantity quantity,
+        TQuantity other,
+        TQuantity tolerance)
+        where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        double scalingFactor = TQuantity.LogarithmicScalingFactor;
+        double value = ToLinear(quantity.Value, scalingFactor);
+        double otherValue = ToLinear(TQuantity.Convert(other.Value, other.Unit, quantity.Unit), scalingFactor);
+        double toleranceValue = Math.Abs(
+            ToLinear(TQuantity.Convert(tolerance.Value, tolerance.Unit, quantity.Unit), scalingFactor));
+        return Math.Abs(value - otherValue) <= toleranceValue;
+    }
+
+    private static double ToLinear(double value, double scalingFactor) => Math.Pow(10, value / scalingFactor);
+
+    private static double ToLogarithmic(double value, double scalingFactor) =>
+        scalingFactor * Math.Log10(value);
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Math/QuantityMath.cs b/UnitsNet.Modular/UnitsNet.Modular/Math/QuantityMath.cs
new file mode 100644
index 0000000000..ad78c2b026
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Math/QuantityMath.cs
@@ -0,0 +1,90 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet;
+
+/// <summary>Reusable algorithms over quantities that advertise compatible arithmetic semantics.</summary>
+public static class QuantityMath
+{
+    /// <summary>
+    /// Sums linear quantities, returning zero in the base unit for an empty sequence and otherwise
+    /// preserving the first value's unit.
+    /// </summary>
+    public static TQuantity Sum<TQuantity>(IEnumerable<TQuantity> quantities)
+        where TQuantity : ILinearQuantity<TQuantity>
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+
+        using IEnumerator<TQuantity> enumerator = quantities.GetEnumerator();
+        if (!enumerator.MoveNext())
+        {
+            return TQuantity.Zero;
+        }
+
+        TQuantity result = enumerator.Current;
+        while (enumerator.MoveNext())
+        {
+            result += enumerator.Current;
+        }
+
+        return result;
+    }
+
+    /// <summary>Sums linear quantities and expresses the result in the requested unit.</summary>
+    public static TQuantity Sum<TQuantity, TUnit>(IEnumerable<TQuantity> quantities, TUnit unit)
+        where TQuantity : ILinearQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+
+        double result = 0;
+        foreach (TQuantity quantity in quantities)
+        {
+            result += TQuantity.Convert(quantity.Value, quantity.Unit, unit);
+        }
+
+        return TQuantity.From(result, unit);
+    }
+
+    /// <summary>Calculates the arithmetic average of linear quantities in the first value's unit.</summary>
+    public static TQuantity Average<TQuantity>(IEnumerable<TQuantity> quantities)
+        where TQuantity : ILinearQuantity<TQuantity>
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+
+        using IEnumerator<TQuantity> enumerator = quantities.GetEnumerator();
+        if (!enumerator.MoveNext())
+        {
+            throw new InvalidOperationException("Sequence contains no quantities.");
+        }
+
+        TQuantity result = enumerator.Current;
+        var count = 1;
+        while (enumerator.MoveNext())
+        {
+            result += enumerator.Current;
+            count++;
+        }
+
+        return result / count;
+    }
+
+    /// <summary>Calculates the arithmetic average of linear quantities in the requested unit.</summary>
+    public static TQuantity Average<TQuantity, TUnit>(IEnumerable<TQuantity> quantities, TUnit unit)
+        where TQuantity : ILinearQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+
+        double result = 0;
+        var count = 0;
+        foreach (TQuantity quantity in quantities)
+        {
+            result += TQuantity.Convert(quantity.Value, quantity.Unit, unit);
+            count++;
+        }
+
+        return count == 0
+            ? throw new InvalidOperationException("Sequence contains no quantities.")
+            : TQuantity.From(result / count, unit);
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Metadata/QuantityDescriptor.cs b/UnitsNet.Modular/UnitsNet.Modular/Metadata/QuantityDescriptor.cs
new file mode 100644
index 0000000000..88c24ad51b
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Metadata/QuantityDescriptor.cs
@@ -0,0 +1,104 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet;
+
+/// <summary>Non-generic metadata and operations for one quantity in a generated module.</summary>
+/// <remarks>
+/// This type-erased contract supports registry workflows where the concrete generated quantity is
+/// not known statically. Strongly typed code should prefer the quantity type and its static
+/// <c>Info</c> property.
+/// </remarks>
+public interface IQuantityDescriptor
+{
+    /// <summary>Gets the stable semantic quantity identity.</summary>
+    QuantityId Id { get; }
+
+    /// <summary>Gets the quantity's source definition name.</summary>
+    string Name { get; }
+
+    /// <summary>Gets the generated quantity CLR type.</summary>
+    Type QuantityType { get; }
+
+    /// <summary>Gets the generated unit-enum CLR type.</summary>
+    Type UnitType { get; }
+
+    /// <summary>Gets the generated base unit name.</summary>
+    string BaseUnitName { get; }
+
+    /// <summary>Gets the quantity's SI base dimensions.</summary>
+    BaseDimensions BaseDimensions { get; }
+
+    /// <summary>Gets immutable metadata for the selected units.</summary>
+    IReadOnlyList<UnitDescriptor> Units { get; }
+
+    /// <summary>Gets the selected unit for an immutable unit-system policy.</summary>
+    UnitDescriptor GetUnit(UnitSystem unitSystem);
+
+    /// <summary>Attempts to get the selected unit for an immutable unit-system policy.</summary>
+    bool TryGetUnit(UnitSystem? unitSystem, out UnitDescriptor? unit);
+
+    /// <summary>Creates the generated quantity from a numeric value and unit name.</summary>
+    IQuantity<double> Create(double value, string unitName);
+
+    /// <summary>Creates the generated quantity using an immutable unit-system policy.</summary>
+    IQuantity<double> Create(double value, UnitSystem unitSystem);
+
+    /// <summary>Attempts to create the generated quantity from a numeric value and unit name.</summary>
+    bool TryCreate(
+        double value,
+        string unitName,
+        [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out IQuantity<double>? quantity);
+
+    /// <summary>Attempts to create the generated quantity using an immutable unit-system policy.</summary>
+    bool TryCreate(
+        double value,
+        UnitSystem? unitSystem,
+        [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out IQuantity<double>? quantity);
+
+    /// <summary>Converts a numeric value between two selected unit names.</summary>
+    double Convert(double value, string fromUnitName, string toUnitName);
+
+    /// <summary>Attempts to convert a numeric value between two selected unit names.</summary>
+    bool TryConvert(double value, string fromUnitName, string toUnitName, out double convertedValue);
+
+    /// <summary>Converts a numeric value from a selected unit into an immutable unit system.</summary>
+    double Convert(double value, string fromUnitName, UnitSystem unitSystem);
+
+    /// <summary>Attempts to convert a numeric value from a selected unit into an immutable unit system.</summary>
+    bool TryConvert(
+        double value,
+        string fromUnitName,
+        UnitSystem? unitSystem,
+        out double convertedValue);
+
+    /// <summary>Parses a generated quantity.</summary>
+    IQuantity<double> Parse(string text, IFormatProvider? formatProvider = null);
+
+    /// <summary>Attempts to parse a generated quantity.</summary>
+    bool TryParse(
+        string? text,
+        IFormatProvider? formatProvider,
+        [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out IQuantity<double>? quantity);
+
+    /// <summary>Gets the stored numeric value from a generated quantity.</summary>
+    double GetValue(IQuantity<double> quantity);
+
+    /// <summary>Gets the stored unit name from a generated quantity.</summary>
+    string GetUnitName(IQuantity<double> quantity);
+
+    /// <summary>Formats a generated quantity after validating its concrete type.</summary>
+    string Format(
+        IQuantity<double> quantity,
+        [System.Diagnostics.CodeAnalysis.StringSyntax(System.Diagnostics.CodeAnalysis.StringSyntaxAttribute.NumericFormat)]
+        string? format = null,
+        IFormatProvider? formatProvider = null);
+}
+
+/// <summary>Type-erased immutable metadata for one selected unit.</summary>
+public sealed record UnitDescriptor(
+    string Name,
+    int Value,
+    string SingularName,
+    string PluralName,
+    BaseUnits BaseUnits,
+    IReadOnlyList<UnitLocalization> Localizations);
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Metadata/QuantityId.cs b/UnitsNet.Modular/UnitsNet.Modular/Metadata/QuantityId.cs
new file mode 100644
index 0000000000..c6e14d3cbf
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Metadata/QuantityId.cs
@@ -0,0 +1,41 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet;
+
+/// <summary>
+/// Identifies a quantity independently of its concrete generated CLR type.
+/// Use a globally unique, namespace-qualified value for identities shared across package boundaries.
+/// </summary>
+public readonly struct QuantityId : IEquatable<QuantityId>
+{
+    private readonly string? _value;
+
+    /// <summary>Initializes a semantic quantity identifier.</summary>
+    public QuantityId(string value)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(value);
+
+        _value = value;
+    }
+
+    /// <summary>Gets the stable textual identifier.</summary>
+    public string Value => _value ?? string.Empty;
+
+    /// <inheritdoc />
+    public bool Equals(QuantityId other) => string.Equals(Value, other.Value, StringComparison.Ordinal);
+
+    /// <inheritdoc />
+    public override bool Equals(object? obj) => obj is QuantityId other && Equals(other);
+
+    /// <inheritdoc />
+    public override int GetHashCode() => StringComparer.Ordinal.GetHashCode(Value);
+
+    /// <inheritdoc />
+    public override string ToString() => Value;
+
+    /// <summary>Determines whether two quantity identifiers are equal.</summary>
+    public static bool operator ==(QuantityId left, QuantityId right) => left.Equals(right);
+
+    /// <summary>Determines whether two quantity identifiers are different.</summary>
+    public static bool operator !=(QuantityId left, QuantityId right) => !left.Equals(right);
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Metadata/QuantityInfo.cs b/UnitsNet.Modular/UnitsNet.Modular/Metadata/QuantityInfo.cs
new file mode 100644
index 0000000000..0d57ebbbd6
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Metadata/QuantityInfo.cs
@@ -0,0 +1,305 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Collections.Frozen;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using UnitsNet.Modular.SourceGen;
+
+namespace UnitsNet;
+
+/// <summary>
+/// Provides the canonical immutable runtime description of one generated quantity.
+/// </summary>
+/// <remarks>
+/// Generated quantity types expose one instance through their static <c>Info</c> property, and the
+/// generated discovery registry stores that same instance. Value operations remain on the quantity
+/// type; this object describes its identity, units, dimensions, and unit-system selection.
+/// </remarks>
+/// <typeparam name="TQuantity">The generated quantity type.</typeparam>
+/// <typeparam name="TUnit">The generated unit enum type.</typeparam>
+public sealed class QuantityInfo<TQuantity, TUnit> : IQuantityDescriptor
+    where TQuantity : IQuantity<TQuantity, TUnit, double>
+    where TUnit : struct, Enum
+{
+    private readonly IQuantityMetadata<TQuantity, TUnit> _metadata;
+    private readonly FrozenDictionary<TUnit, UnitInfo<TUnit>> _unitInfosByValue;
+    private readonly FrozenDictionary<TUnit, UnitDescriptor> _unitDescriptorsByValue;
+    private readonly IReadOnlyList<UnitDescriptor> _unitDescriptors;
+
+    /// <summary>Creates immutable metadata from generated quantity metadata.</summary>
+    /// <remarks>This constructor is public only so generated code can initialize its static <c>Info</c>.</remarks>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public QuantityInfo(QuantityId id, IQuantityMetadata<TQuantity, TUnit> metadata)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(id.Value, nameof(id));
+        ArgumentNullException.ThrowIfNull(metadata);
+        ArgumentException.ThrowIfNullOrWhiteSpace(metadata.Name);
+        ArgumentNullException.ThrowIfNull(metadata.BaseDimensions);
+        ArgumentNullException.ThrowIfNull(metadata.Units);
+
+        UnitInfo<TUnit>[] unitInfos = metadata.Units.ToArray();
+        if (unitInfos.Any(unit => unit is null))
+        {
+            throw new ArgumentException("Unit metadata cannot contain null values.", nameof(metadata));
+        }
+
+        _metadata = metadata;
+        Id = id;
+        Name = metadata.Name;
+        BaseDimensions = metadata.BaseDimensions;
+        Units = Array.AsReadOnly(unitInfos);
+        _unitInfosByValue = unitInfos.ToFrozenDictionary(unit => unit.Value);
+
+        if (!_unitInfosByValue.TryGetValue(metadata.BaseUnit, out UnitInfo<TUnit>? baseUnitInfo))
+        {
+            throw new ArgumentException(
+                $"No unit metadata was supplied for the base unit '{metadata.BaseUnit}'.",
+                nameof(metadata));
+        }
+
+        BaseUnit = baseUnitInfo;
+        UnitDescriptor[] descriptors = unitInfos
+            .Select(unit => new UnitDescriptor(
+                unit.Value.ToString(),
+                System.Convert.ToInt32(unit.Value),
+                unit.SingularName,
+                unit.PluralName,
+                unit.BaseUnits,
+                unit.Localizations))
+            .ToArray();
+        _unitDescriptors = Array.AsReadOnly(descriptors);
+        _unitDescriptorsByValue = unitInfos
+            .Select((unit, index) => (unit.Value, Descriptor: descriptors[index]))
+            .ToFrozenDictionary(pair => pair.Value, pair => pair.Descriptor);
+    }
+
+    /// <summary>Gets the stable semantic quantity identity.</summary>
+    public QuantityId Id { get; }
+
+    /// <summary>Gets the quantity's invariant name.</summary>
+    public string Name { get; }
+
+    /// <summary>Gets the generated quantity CLR type.</summary>
+    public Type QuantityType => typeof(TQuantity);
+
+    /// <summary>Gets the generated unit-enum CLR type.</summary>
+    public Type UnitType => typeof(TUnit);
+
+    /// <summary>Gets metadata for the unit through which conversions are performed.</summary>
+    public UnitInfo<TUnit> BaseUnit { get; }
+
+    /// <summary>
+    /// Gets metadata for the unit through which conversions are performed.
+    /// This is a source-compatibility alias for <see cref="BaseUnit" />.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public UnitInfo<TUnit> BaseUnitInfo => BaseUnit;
+
+    /// <summary>Gets the quantity's SI base dimensions.</summary>
+    public BaseDimensions BaseDimensions { get; }
+
+    /// <summary>Gets immutable metadata for all generated units of this quantity.</summary>
+    public IReadOnlyList<UnitInfo<TUnit>> Units { get; }
+
+    /// <summary>
+    /// Gets immutable metadata for all generated units of this quantity.
+    /// This is a source-compatibility alias for <see cref="Units" />.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public IReadOnlyList<UnitInfo<TUnit>> UnitInfos => Units;
+
+    /// <summary>Gets metadata for a generated unit.</summary>
+    public UnitInfo<TUnit> this[TUnit unit] =>
+        _unitInfosByValue.TryGetValue(unit, out UnitInfo<TUnit>? info)
+            ? info
+            : throw new KeyNotFoundException($"Unit '{unit}' is not generated for {Name}.");
+
+    /// <summary>Attempts to get metadata for a generated unit.</summary>
+    public bool TryGetUnitInfo(TUnit unit, [NotNullWhen(true)] out UnitInfo<TUnit>? unitInfo) =>
+        _unitInfosByValue.TryGetValue(unit, out unitInfo);
+
+    /// <summary>Gets the single generated unit compatible with the supplied base units.</summary>
+    public UnitInfo<TUnit> GetUnitInfoFor(BaseUnits baseUnits)
+    {
+        ArgumentNullException.ThrowIfNull(baseUnits);
+        using IEnumerator<UnitInfo<TUnit>> matches = GetUnitInfosFor(baseUnits).GetEnumerator();
+        if (!matches.MoveNext())
+        {
+            throw new InvalidOperationException($"No unit for {Name} is compatible with {baseUnits}.");
+        }
+
+        UnitInfo<TUnit> match = matches.Current;
+        if (matches.MoveNext())
+        {
+            throw new InvalidOperationException($"More than one unit for {Name} is compatible with {baseUnits}.");
+        }
+
+        return match;
+    }
+
+    /// <summary>Gets generated units compatible with the supplied base units.</summary>
+    public IEnumerable<UnitInfo<TUnit>> GetUnitInfosFor(BaseUnits baseUnits)
+    {
+        ArgumentNullException.ThrowIfNull(baseUnits);
+        return Units.Where(unit => unit.BaseUnits.IsSubsetOf(baseUnits));
+    }
+
+    /// <summary>Gets the generated unit selected by an immutable unit-system policy.</summary>
+    public UnitInfo<TUnit> GetUnit(UnitSystem unitSystem) =>
+        this[QuantityOperations.GetUnit(unitSystem, _metadata)];
+
+    /// <summary>Attempts to get the generated unit selected by an immutable unit-system policy.</summary>
+    public bool TryGetUnit(UnitSystem? unitSystem, [NotNullWhen(true)] out UnitInfo<TUnit>? unitInfo)
+    {
+        if (QuantityOperations.TryGetUnit(unitSystem, _metadata, out TUnit unit))
+        {
+            return TryGetUnitInfo(unit, out unitInfo);
+        }
+
+        unitInfo = null;
+        return false;
+    }
+
+    string IQuantityDescriptor.BaseUnitName => BaseUnit.Value.ToString();
+
+    IReadOnlyList<UnitDescriptor> IQuantityDescriptor.Units => _unitDescriptors;
+
+    UnitDescriptor IQuantityDescriptor.GetUnit(UnitSystem unitSystem) =>
+        _unitDescriptorsByValue[GetUnit(unitSystem).Value];
+
+    bool IQuantityDescriptor.TryGetUnit(UnitSystem? unitSystem, out UnitDescriptor? unit)
+    {
+        if (TryGetUnit(unitSystem, out UnitInfo<TUnit>? selected))
+        {
+            unit = _unitDescriptorsByValue[selected.Value];
+            return true;
+        }
+
+        unit = null;
+        return false;
+    }
+
+    IQuantity<double> IQuantityDescriptor.Create(double value, string unitName) =>
+        TQuantity.From(value, ParseUnit(unitName));
+
+    IQuantity<double> IQuantityDescriptor.Create(double value, UnitSystem unitSystem) =>
+        TQuantity.From(value, GetUnit(unitSystem).Value);
+
+    bool IQuantityDescriptor.TryCreate(
+        double value,
+        string unitName,
+        [NotNullWhen(true)] out IQuantity<double>? quantity)
+    {
+        if (TryParseUnit(unitName, out TUnit unit))
+        {
+            quantity = TQuantity.From(value, unit);
+            return true;
+        }
+
+        quantity = null;
+        return false;
+    }
+
+    bool IQuantityDescriptor.TryCreate(
+        double value,
+        UnitSystem? unitSystem,
+        [NotNullWhen(true)] out IQuantity<double>? quantity)
+    {
+        if (TryGetUnit(unitSystem, out UnitInfo<TUnit>? unit))
+        {
+            quantity = TQuantity.From(value, unit.Value);
+            return true;
+        }
+
+        quantity = null;
+        return false;
+    }
+
+    double IQuantityDescriptor.Convert(double value, string fromUnitName, string toUnitName) =>
+        TQuantity.Convert(value, ParseUnit(fromUnitName), ParseUnit(toUnitName));
+
+    bool IQuantityDescriptor.TryConvert(
+        double value,
+        string fromUnitName,
+        string toUnitName,
+        out double convertedValue)
+    {
+        if (TryParseUnit(fromUnitName, out TUnit fromUnit) &&
+            TryParseUnit(toUnitName, out TUnit toUnit))
+        {
+            convertedValue = TQuantity.Convert(value, fromUnit, toUnit);
+            return true;
+        }
+
+        convertedValue = default;
+        return false;
+    }
+
+    double IQuantityDescriptor.Convert(double value, string fromUnitName, UnitSystem unitSystem) =>
+        TQuantity.Convert(value, ParseUnit(fromUnitName), GetUnit(unitSystem).Value);
+
+    bool IQuantityDescriptor.TryConvert(
+        double value,
+        string fromUnitName,
+        UnitSystem? unitSystem,
+        out double convertedValue)
+    {
+        if (TryParseUnit(fromUnitName, out TUnit fromUnit) &&
+            TryGetUnit(unitSystem, out UnitInfo<TUnit>? toUnit))
+        {
+            convertedValue = TQuantity.Convert(value, fromUnit, toUnit.Value);
+            return true;
+        }
+
+        convertedValue = default;
+        return false;
+    }
+
+    IQuantity<double> IQuantityDescriptor.Parse(string text, IFormatProvider? formatProvider) =>
+        _metadata.Parse(text, formatProvider);
+
+    bool IQuantityDescriptor.TryParse(
+        string? text,
+        IFormatProvider? formatProvider,
+        [NotNullWhen(true)] out IQuantity<double>? quantity)
+    {
+        if (_metadata.TryParse(text, formatProvider, out TQuantity parsed))
+        {
+            quantity = parsed;
+            return true;
+        }
+
+        quantity = null;
+        return false;
+    }
+
+    double IQuantityDescriptor.GetValue(IQuantity<double> quantity) => RequireQuantity(quantity).Value;
+
+    string IQuantityDescriptor.GetUnitName(IQuantity<double> quantity) => RequireQuantity(quantity).Unit.ToString();
+
+    string IQuantityDescriptor.Format(
+        IQuantity<double> quantity,
+        string? format,
+        IFormatProvider? formatProvider) =>
+        RequireQuantity(quantity).ToString(format, formatProvider);
+
+    private TUnit ParseUnit(string name)
+    {
+        if (TryParseUnit(name, out TUnit unit))
+        {
+            return unit;
+        }
+
+        throw new ArgumentException($"Unit '{name}' is not selected for {Name}.", nameof(name));
+    }
+
+    private bool TryParseUnit(string? name, out TUnit unit) =>
+        QuantityOperations.TryParseUnit(name, null, _metadata, out unit);
+
+    private static TQuantity RequireQuantity(IQuantity<double> quantity) =>
+        quantity is TQuantity typed
+            ? typed
+            : throw new ArgumentException(
+                $"Expected a quantity of type {typeof(TQuantity).FullName}.",
+                nameof(quantity));
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Metadata/UnitInfo.cs b/UnitsNet.Modular/UnitsNet.Modular/Metadata/UnitInfo.cs
new file mode 100644
index 0000000000..30760cee6b
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Metadata/UnitInfo.cs
@@ -0,0 +1,89 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.ComponentModel;
+
+namespace UnitsNet;
+
+/// <summary>Immutable runtime metadata for one generated unit.</summary>
+/// <remarks>
+/// Use <see cref="Value" /> when a generated API requires the strongly typed enum value. Names,
+/// constituent base units, and localized abbreviations remain descriptive metadata on this object.
+/// </remarks>
+public sealed class UnitInfo<TUnit>
+    where TUnit : struct, Enum
+{
+    /// <summary>Initializes runtime metadata for a generated unit.</summary>
+    public UnitInfo(
+        TUnit unit,
+        string singularName,
+        string pluralName,
+        BaseUnits baseUnits,
+        params UnitLocalization[] localizations)
+    {
+        ArgumentNullException.ThrowIfNull(singularName);
+        ArgumentNullException.ThrowIfNull(pluralName);
+        ArgumentNullException.ThrowIfNull(baseUnits);
+        ArgumentNullException.ThrowIfNull(localizations);
+        Value = unit;
+        SingularName = singularName;
+        PluralName = pluralName;
+        BaseUnits = baseUnits;
+        Localizations = Array.AsReadOnly((UnitLocalization[])localizations.Clone());
+    }
+
+    /// <summary>Gets the generated unit enum value represented by this metadata.</summary>
+    public TUnit Value { get; }
+
+    /// <summary>Gets the singular English name.</summary>
+    public string SingularName { get; }
+
+    /// <summary>
+    /// Gets the singular English name.
+    /// This is a source-compatibility alias for <see cref="SingularName"/>.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public string Name => SingularName;
+
+    /// <summary>Gets the plural English name.</summary>
+    public string PluralName { get; }
+
+    /// <summary>Gets the constituent base units represented by this unit.</summary>
+    public BaseUnits BaseUnits { get; }
+
+    /// <summary>Gets the localized abbreviations.</summary>
+    public IReadOnlyList<UnitLocalization> Localizations { get; }
+
+    /// <summary>Gets abbreviations using the requested culture and fallback rules.</summary>
+    public IReadOnlyList<string> GetAbbreviations(System.Globalization.CultureInfo? culture)
+    {
+        string cultureName = (culture ?? System.Globalization.CultureInfo.CurrentCulture).Name;
+        while (cultureName.Length > 0)
+        {
+            UnitLocalization? exact = Localizations.FirstOrDefault(localization =>
+                string.Equals(localization.Culture, cultureName, StringComparison.OrdinalIgnoreCase));
+            if (exact is not null)
+            {
+                return exact.Abbreviations;
+            }
+
+            int separator = cultureName.LastIndexOf('-');
+            cultureName = separator < 0 ? string.Empty : cultureName.Substring(0, separator);
+        }
+
+        UnitLocalization? english = Localizations.FirstOrDefault(localization =>
+            string.Equals(localization.Culture, "en-US", StringComparison.OrdinalIgnoreCase));
+        if (english is not null)
+        {
+            return english.Abbreviations;
+        }
+
+        return Localizations.FirstOrDefault()?.Abbreviations ?? Array.Empty<string>();
+    }
+
+    /// <summary>Gets the preferred abbreviation using the requested culture and fallback rules.</summary>
+    public string GetDefaultAbbreviation(System.Globalization.CultureInfo? culture)
+        => GetAbbreviations(culture).FirstOrDefault() ?? string.Empty;
+
+    /// <inheritdoc />
+    public override string ToString() => SingularName;
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Metadata/UnitLocalization.cs b/UnitsNet.Modular/UnitsNet.Modular/Metadata/UnitLocalization.cs
new file mode 100644
index 0000000000..c9dc36342d
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Metadata/UnitLocalization.cs
@@ -0,0 +1,22 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet;
+
+/// <summary>Localized abbreviations for one generated unit.</summary>
+public sealed class UnitLocalization
+{
+    /// <summary>Initializes abbreviations for a culture name.</summary>
+    public UnitLocalization(string culture, params string[] abbreviations)
+    {
+        ArgumentNullException.ThrowIfNull(culture);
+        ArgumentNullException.ThrowIfNull(abbreviations);
+        Culture = culture;
+        Abbreviations = Array.AsReadOnly((string[])abbreviations.Clone());
+    }
+
+    /// <summary>Gets the culture name.</summary>
+    public string Culture { get; }
+
+    /// <summary>Gets the accepted abbreviations ordered by preference.</summary>
+    public IReadOnlyList<string> Abbreviations { get; }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Modular/AuthoringContracts.cs b/UnitsNet.Modular/UnitsNet.Modular/Modular/AuthoringContracts.cs
new file mode 100644
index 0000000000..3aee4f1ab4
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Modular/AuthoringContracts.cs
@@ -0,0 +1,217 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet.Modular;
+
+/// <summary>
+/// Marks the single interface that selects the quantities and units generated into a consumer-owned
+/// assembly.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Apply this attribute to one declarative interface in the project that will own the generated
+/// quantity structs and unit enums. The interface is never instantiated or implemented. Instead,
+/// inherit <see cref="IInclude{TQuantitySpec}" />, <see cref="IInclude{TQuantitySpec,TUnitSet}" />,
+/// or <see cref="IIncludeProfile{TProfile}" /> to describe the generated API, then build the project.
+/// </para>
+/// <para>
+/// A compilation can declare one module. Built-in quantities retain the familiar <c>UnitsNet</c>
+/// namespace and their unit enums use <c>UnitsNet.Units</c> unless a target namespace is supplied.
+/// Relationships such as <c>Length / Duration = Speed</c> are generated when every participating
+/// quantity is selected. Do not reference the legacy <c>UnitsNet</c> package in the same project.
+/// </para>
+/// </remarks>
+/// <example>
+/// Select <c>Length</c>, <c>Duration</c>, and <c>Speed</c>, including all their units:
+/// <code>
+/// using UnitsNet.Modular;
+/// using Catalog = UnitsNet.Modular.BuiltIns;
+///
+/// [UnitsNetModule]
+/// internal interface ApplicationUnits :
+///     IInclude&lt;Catalog.LengthSpec&gt;,
+///     IInclude&lt;Catalog.DurationSpec&gt;,
+///     IInclude&lt;Catalog.SpeedSpec&gt;;
+/// </code>
+/// After building, ordinary application code can use <c>UnitsNet.Length</c>,
+/// <c>UnitsNet.Duration</c>, <c>UnitsNet.Speed</c>, and their unit enums.
+/// </example>
+/// <seealso href="https://github.com/angularsen/UnitsNet/tree/master/UnitsNet.Modular#quick-start">
+/// UnitsNet.Modular quick start
+/// </seealso>
+/// <seealso href="https://github.com/angularsen/UnitsNet/tree/master/UnitsNet.Modular#configure-generation">
+/// Complete module configuration
+/// </seealso>
+[AttributeUsage(AttributeTargets.Interface)]
+public sealed class UnitsNetModuleAttribute : Attribute
+{
+    /// <summary>
+    /// Creates a module that preserves each selected definition's declared namespace.
+    /// </summary>
+    public UnitsNetModuleAttribute()
+    {
+    }
+
+    /// <summary>
+    /// Creates a module that emits all selected quantities into <paramref name="targetNamespace" />.
+    /// </summary>
+    /// <param name="targetNamespace">
+    /// The CLR namespace for generated quantity and unit-enum types. The compatibility namespace
+    /// <c>UnitsNet</c> is special-cased so its unit enums use <c>UnitsNet.Units</c>.
+    /// </param>
+    public UnitsNetModuleAttribute(string targetNamespace) => TargetNamespace = targetNamespace;
+
+    /// <summary>
+    /// Gets the optional CLR namespace override applied to every selected quantity definition.
+    /// </summary>
+    public string? TargetNamespace { get; }
+}
+
+/// <summary>
+/// Declares exact, glob, or regular-expression patterns used to select units from a quantity spec.
+/// </summary>
+/// <remarks>
+/// Patterns match expanded invariant unit names, not abbreviations. Bare patterns use convenient
+/// glob matching; prefix a pattern with <c>glob:</c> or <c>regex:</c> to select the matching mode
+/// explicitly. The quantity's base unit is always included so every generated quantity remains
+/// convertible. A unit set is selected through <see cref="IInclude{TQuantitySpec,TUnitSet}" />.
+/// </remarks>
+/// <example>
+/// <code>
+/// [UnitSet("Meter", "Millimeter", "Kilometer")]
+/// internal interface CommonLengthUnits;
+///
+/// [UnitSet("regex:.*Meter$")]
+/// internal interface MeterUnits;
+/// </code>
+/// </example>
+/// <seealso href="https://github.com/angularsen/UnitsNet/tree/master/UnitsNet.Modular#filter-units">
+/// Unit filtering documentation
+/// </seealso>
+[AttributeUsage(AttributeTargets.Interface)]
+[CLSCompliant(false)]
+public sealed class UnitSetAttribute : Attribute
+{
+    /// <summary>Creates a reusable unit selection from one or more unit-name patterns.</summary>
+    /// <param name="patterns">
+    /// Exact, glob, or <c>regex:</c>-prefixed patterns matched against invariant unit names.
+    /// </param>
+    public UnitSetAttribute(params string[] patterns) => Patterns = patterns;
+
+    /// <summary>Gets the unit-name patterns used by this selection.</summary>
+    public string[] Patterns { get; }
+}
+
+/// <summary>Binds a quantity spec interface to a stable semantic quantity ID.</summary>
+/// <remarks>
+/// Use this attribute when authoring a custom quantity or a definition package. The semantic ID
+/// connects the spec to a <c>*.unitsnet.json</c> definition supplied as an
+/// <c>AdditionalFiles</c> item. The recommended type name is the generated quantity name followed
+/// by <c>Spec</c>. Published definition packages should expose public specs and keep their semantic
+/// IDs stable; the package contributes definitions, while the consuming application owns the
+/// generated quantity types.
+/// </remarks>
+/// <example>
+/// <code>
+/// [QuantitySpec("Contoso.Measurements.WidgetCount")]
+/// public interface WidgetCountSpec;
+///
+/// [UnitsNetModule]
+/// internal interface ApplicationUnits : IInclude&lt;WidgetCountSpec&gt;;
+/// </code>
+/// </example>
+/// <seealso href="https://github.com/angularsen/UnitsNet/tree/master/UnitsNet.Modular#add-custom-quantities">
+/// Custom quantity documentation
+/// </seealso>
+/// <seealso href="https://github.com/angularsen/UnitsNet/tree/master/UnitsNet.Modular#publish-a-definition-package">
+/// Definition package documentation
+/// </seealso>
+[AttributeUsage(AttributeTargets.Interface)]
+public sealed class QuantitySpecAttribute : Attribute
+{
+    /// <summary>Creates a binding to the semantic quantity ID <paramref name="semanticId" />.</summary>
+    /// <param name="semanticId">
+    /// The definition's stable namespace-qualified ID, such as
+    /// <c>Contoso.Measurements.WidgetCount</c>.
+    /// </param>
+    public QuantitySpecAttribute(string semanticId) => SemanticId = semanticId;
+
+    /// <summary>Gets the stable semantic quantity ID.</summary>
+    public string SemanticId { get; }
+}
+
+/// <summary>Selects a quantity spec and all of its units for generation.</summary>
+/// <typeparam name="TQuantitySpec">
+/// A built-in spec from <c>UnitsNet.Modular.BuiltIns</c> or a custom interface marked with
+/// <see cref="QuantitySpecAttribute" />.
+/// </typeparam>
+/// <remarks>
+/// Inherit this interface from a <see cref="UnitsNetModuleAttribute" /> module or a reusable profile.
+/// The spec type is an authoring input; the generator emits the corresponding quantity struct and
+/// unit enum, not a concrete implementation of the spec interface.
+/// </remarks>
+/// <example>
+/// <code>
+/// [UnitsNetModule]
+/// internal interface ApplicationUnits :
+///     IInclude&lt;UnitsNet.Modular.BuiltIns.LengthSpec&gt;;
+/// </code>
+/// </example>
+public interface IInclude<TQuantitySpec>
+{
+}
+
+/// <summary>
+/// Selects a quantity spec and the units matching <typeparamref name="TUnitSet" /> for generation.
+/// </summary>
+/// <typeparam name="TQuantitySpec">
+/// A built-in or custom quantity spec.
+/// </typeparam>
+/// <typeparam name="TUnitSet">
+/// An interface marked with <see cref="UnitSetAttribute" />.
+/// </typeparam>
+/// <remarks>
+/// The base unit is generated even when none of the unit-set patterns select it, preserving a valid
+/// conversion anchor. A direct filtered include on the module overrides a profile's selection for
+/// the same quantity.
+/// </remarks>
+/// <example>
+/// <code>
+/// [UnitSet("Meter", "Kilometer")]
+/// internal interface ApplicationLengthUnits;
+///
+/// [UnitsNetModule]
+/// internal interface ApplicationUnits :
+///     IInclude&lt;UnitsNet.Modular.BuiltIns.LengthSpec, ApplicationLengthUnits&gt;;
+/// </code>
+/// </example>
+public interface IInclude<TQuantitySpec, TUnitSet>
+{
+}
+
+/// <summary>Composes a reusable quantity-selection profile into a module or another profile.</summary>
+/// <typeparam name="TProfile">
+/// An interface that composes quantity specs, unit sets, or other profiles.
+/// </typeparam>
+/// <remarks>
+/// Profiles provide reusable defaults. Direct quantity selections on the module override a profile's
+/// unit selection for that quantity. Use
+/// <c>UnitsNet.Modular.Profiles.AllQuantitiesProfile</c> when source compatibility with the complete
+/// built-in catalog is preferred over a lean selection.
+/// </remarks>
+/// <example>
+/// <code>
+/// internal interface MechanicsProfile :
+///     IInclude&lt;UnitsNet.Modular.BuiltIns.LengthSpec&gt;,
+///     IInclude&lt;UnitsNet.Modular.BuiltIns.DurationSpec&gt;,
+///     IInclude&lt;UnitsNet.Modular.BuiltIns.SpeedSpec&gt;;
+///
+/// [UnitsNetModule]
+/// internal interface ApplicationUnits : IIncludeProfile&lt;MechanicsProfile&gt;;
+/// </code>
+/// </example>
+/// <seealso href="https://github.com/angularsen/UnitsNet/tree/master/UnitsNet.Modular#use-profiles">
+/// Profile documentation
+/// </seealso>
+public interface IIncludeProfile<TProfile>
+{
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Modular/SourceGen/IQuantityMetadata.cs b/UnitsNet.Modular/UnitsNet.Modular/Modular/SourceGen/IQuantityMetadata.cs
new file mode 100644
index 0000000000..a00519e229
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Modular/SourceGen/IQuantityMetadata.cs
@@ -0,0 +1,51 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.ComponentModel;
+using UnitsNet;
+
+namespace UnitsNet.Modular.SourceGen;
+
+/// <summary>Metadata supplied by generated code to shared quantity operations.</summary>
+/// <remarks>
+/// This contract is public so emitted code can call the runtime from a consumer assembly. It is
+/// source-generator infrastructure and is not intended to be implemented or consumed directly by
+/// applications.
+/// </remarks>
+[EditorBrowsable(EditorBrowsableState.Never)]
+public interface IQuantityMetadata<TUnit>
+    where TUnit : struct, Enum
+{
+    /// <summary>Gets the logical quantity name.</summary>
+    string Name { get; }
+
+    /// <summary>Gets the unit through which conversions are performed.</summary>
+    TUnit BaseUnit { get; }
+
+    /// <summary>Gets the units generated for this quantity.</summary>
+    IReadOnlyList<UnitInfo<TUnit>> Units { get; }
+
+    /// <summary>Gets the quantity's SI base dimensions.</summary>
+    BaseDimensions BaseDimensions { get; }
+
+    /// <summary>Converts a value from the specified unit to the base unit.</summary>
+    double ToBase(double value, TUnit unit);
+
+    /// <summary>Converts a value from the base unit to the specified unit.</summary>
+    double FromBase(double value, TUnit unit);
+}
+
+/// <summary>Generated parsing operations supplied to immutable quantity metadata.</summary>
+/// <remarks>
+/// This contract is public so emitted code can call the runtime from a consumer assembly. It is
+/// source-generator infrastructure and is not intended for direct application use.
+/// </remarks>
+[EditorBrowsable(EditorBrowsableState.Never)]
+public interface IQuantityMetadata<TQuantity, TUnit> : IQuantityMetadata<TUnit>
+    where TUnit : struct, Enum
+{
+    /// <summary>Parses a generated quantity.</summary>
+    TQuantity Parse(string text, IFormatProvider? formatProvider);
+
+    /// <summary>Attempts to parse a generated quantity.</summary>
+    bool TryParse(string? text, IFormatProvider? formatProvider, out TQuantity quantity);
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Modular/SourceGen/QuantityJsonConverter.cs b/UnitsNet.Modular/UnitsNet.Modular/Modular/SourceGen/QuantityJsonConverter.cs
new file mode 100644
index 0000000000..dfcae96a4f
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Modular/SourceGen/QuantityJsonConverter.cs
@@ -0,0 +1,94 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.ComponentModel;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using UnitsNet;
+
+namespace UnitsNet.Modular.SourceGen;
+
+/// <summary>Serializes one generated quantity using its immutable module descriptor.</summary>
+/// <remarks>
+/// This type is public so generated code can reuse it across consumer assemblies. Applications
+/// should configure serialization through the generated module API instead.
+/// </remarks>
+[EditorBrowsable(EditorBrowsableState.Never)]
+public sealed class QuantityJsonConverter<TQuantity> : JsonConverter<TQuantity>
+    where TQuantity : struct, IQuantity<double>
+{
+    private readonly IQuantityDescriptor _descriptor;
+
+    /// <summary>Creates a converter for one generated concrete quantity type.</summary>
+    public QuantityJsonConverter(IQuantityDescriptor descriptor)
+    {
+        ArgumentNullException.ThrowIfNull(descriptor);
+        _descriptor = descriptor;
+    }
+
+    /// <inheritdoc />
+    public override TQuantity Read(
+        ref Utf8JsonReader reader,
+        Type typeToConvert,
+        JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.StartObject)
+        {
+            throw new JsonException("Expected a quantity object.");
+        }
+
+        double? value = null;
+        string? unit = null;
+        while (reader.Read() && reader.TokenType != JsonTokenType.EndObject)
+        {
+            if (reader.TokenType != JsonTokenType.PropertyName)
+            {
+                throw new JsonException("Expected a quantity property.");
+            }
+
+            string propertyName = reader.GetString()!;
+            if (!reader.Read())
+            {
+                throw new JsonException("Unexpected end of quantity object.");
+            }
+
+            if (propertyName.Equals("Value", StringComparison.OrdinalIgnoreCase))
+            {
+                value = reader.GetDouble();
+            }
+            else if (propertyName.Equals("Unit", StringComparison.OrdinalIgnoreCase))
+            {
+                unit = reader.GetString();
+            }
+            else
+            {
+                reader.Skip();
+            }
+        }
+
+        if (value is null || unit is null)
+        {
+            throw new JsonException("A quantity requires Value and Unit properties.");
+        }
+
+        try
+        {
+            return (TQuantity)_descriptor.Create(value.Value, unit);
+        }
+        catch (ArgumentException exception)
+        {
+            throw new JsonException(exception.Message, exception);
+        }
+    }
+
+    /// <inheritdoc />
+    public override void Write(
+        Utf8JsonWriter writer,
+        TQuantity value,
+        JsonSerializerOptions options)
+    {
+        writer.WriteStartObject();
+        writer.WriteNumber("Value", _descriptor.GetValue(value));
+        writer.WriteString("Unit", _descriptor.GetUnitName(value));
+        writer.WriteEndObject();
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Modular/SourceGen/QuantityOperations.cs b/UnitsNet.Modular/UnitsNet.Modular/Modular/SourceGen/QuantityOperations.cs
new file mode 100644
index 0000000000..b8d6634516
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Modular/SourceGen/QuantityOperations.cs
@@ -0,0 +1,273 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Collections.Concurrent;
+using System.ComponentModel;
+using System.Globalization;
+using UnitsNet;
+
+namespace UnitsNet.Modular.SourceGen;
+
+/// <summary>Shared conversion, parsing, and formatting behavior for generated quantities.</summary>
+/// <remarks>
+/// This type is public so generated code can reuse the implementation across consumer assemblies.
+/// It is generator infrastructure; applications should use the generated quantity APIs instead.
+/// </remarks>
+[EditorBrowsable(EditorBrowsableState.Never)]
+public static class QuantityOperations
+{
+    /// <summary>Converts a value between two generated units.</summary>
+    public static double Convert<TUnit>(double value, TUnit fromUnit, TUnit toUnit, IQuantityMetadata<TUnit> metadata)
+        where TUnit : struct, Enum
+        => metadata.FromBase(metadata.ToBase(value, fromUnit), toUnit);
+
+    /// <summary>Attempts to parse a numeric value and generated unit name or abbreviation.</summary>
+    public static bool TryParse<TUnit>(
+        string? text,
+        IFormatProvider? formatProvider,
+        IQuantityMetadata<TUnit> metadata,
+        out double value,
+        out TUnit unit)
+        where TUnit : struct, Enum
+    {
+        value = default;
+        unit = metadata.BaseUnit;
+
+        if (string.IsNullOrWhiteSpace(text))
+        {
+            return false;
+        }
+
+        string trimmed = text!.Trim();
+        var culture = formatProvider as CultureInfo ?? CultureInfo.CurrentCulture;
+        foreach (SuffixCandidate<TUnit> candidate in SuffixCache<TUnit>.Get(metadata, culture))
+        {
+            if (TryReadValue(
+                    trimmed,
+                    candidate.Suffix,
+                    candidate.CaseSensitive,
+                    formatProvider,
+                    out value))
+            {
+                unit = candidate.Unit;
+                return true;
+            }
+        }
+
+        return GetUnitInfo(metadata.BaseUnit, metadata).GetAbbreviations(culture).Contains(string.Empty) &&
+               TryReadValue(trimmed, string.Empty, true, formatProvider, out value);
+    }
+
+    /// <summary>Formats a value followed by the localized abbreviation for its unit.</summary>
+    public static string Format<TUnit>(
+        double value,
+        TUnit unit,
+        string? format,
+        IFormatProvider? formatProvider,
+        IQuantityMetadata<TUnit> metadata)
+        where TUnit : struct, Enum
+    {
+        UnitInfo<TUnit> info = GetUnitInfo(unit, metadata);
+        var culture = formatProvider as CultureInfo ?? CultureInfo.CurrentCulture;
+        return $"{value.ToString(format, formatProvider ?? culture)} {info.GetDefaultAbbreviation(culture)}".TrimEnd();
+    }
+
+    /// <summary>Converts a value to the quantity's base unit.</summary>
+    public static double GetBaseValue<TUnit>(double value, TUnit unit, IQuantityMetadata<TUnit> metadata)
+        where TUnit : struct, Enum
+        => metadata.ToBase(value, unit);
+
+    /// <summary>Gets metadata for a generated unit.</summary>
+    public static UnitInfo<TUnit> GetUnitInfo<TUnit>(TUnit unit, IQuantityMetadata<TUnit> metadata)
+        where TUnit : struct, Enum
+    {
+        foreach (UnitInfo<TUnit> candidate in metadata.Units)
+        {
+            if (EqualityComparer<TUnit>.Default.Equals(candidate.Value, unit))
+            {
+                return candidate;
+            }
+        }
+
+        throw new ArgumentOutOfRangeException(nameof(unit), unit, $"Unit is not generated for {metadata.Name}.");
+    }
+
+    /// <summary>Gets the first selected unit compatible with an immutable unit-system policy.</summary>
+    public static TUnit GetUnit<TUnit>(UnitSystem unitSystem, IQuantityMetadata<TUnit> metadata)
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(unitSystem);
+        if (TryGetUnit(unitSystem, metadata, out TUnit unit))
+        {
+            return unit;
+        }
+
+        throw new ArgumentException(
+            $"No selected unit for {metadata.Name} is compatible with {unitSystem.BaseUnits}.",
+            nameof(unitSystem));
+    }
+
+    /// <summary>Attempts to get the first selected unit compatible with an immutable unit-system policy.</summary>
+    public static bool TryGetUnit<TUnit>(
+        UnitSystem? unitSystem,
+        IQuantityMetadata<TUnit> metadata,
+        out TUnit unit)
+        where TUnit : struct, Enum
+    {
+        ArgumentNullException.ThrowIfNull(metadata);
+        unit = metadata.BaseUnit;
+        if (unitSystem is null)
+        {
+            return false;
+        }
+
+        if (metadata.BaseDimensions.IsDimensionless())
+        {
+            return true;
+        }
+
+        foreach (UnitInfo<TUnit> candidate in UnitSystemCandidateCache<TUnit>.Get(metadata))
+        {
+            if (candidate.BaseUnits.IsSubsetOf(unitSystem.BaseUnits))
+            {
+                unit = candidate.Value;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>Gets the preferred localized abbreviation for a generated unit.</summary>
+    public static string GetAbbreviation<TUnit>(
+        TUnit unit,
+        IFormatProvider? formatProvider,
+        IQuantityMetadata<TUnit> metadata)
+        where TUnit : struct, Enum =>
+        GetUnitInfo(unit, metadata).GetDefaultAbbreviation(formatProvider as CultureInfo);
+
+    /// <summary>Attempts to parse a generated unit name or localized abbreviation.</summary>
+    public static bool TryParseUnit<TUnit>(
+        string? text,
+        IFormatProvider? formatProvider,
+        IQuantityMetadata<TUnit> metadata,
+        out TUnit unit)
+        where TUnit : struct, Enum
+    {
+        unit = metadata.BaseUnit;
+        if (text is null)
+        {
+            return false;
+        }
+
+        string value = text.Trim();
+        var culture = formatProvider as CultureInfo ?? CultureInfo.CurrentCulture;
+        if (value.Length == 0 &&
+            GetUnitInfo(metadata.BaseUnit, metadata).GetAbbreviations(culture).Contains(string.Empty))
+        {
+            return true;
+        }
+
+        foreach (SuffixCandidate<TUnit> candidate in SuffixCache<TUnit>.Get(metadata, culture))
+        {
+            StringComparison comparison = candidate.CaseSensitive
+                ? StringComparison.Ordinal
+                : StringComparison.OrdinalIgnoreCase;
+            if (string.Equals(value, candidate.Suffix, comparison))
+            {
+                unit = candidate.Unit;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static bool TryReadValue(
+        string text,
+        string suffix,
+        bool caseSensitive,
+        IFormatProvider? formatProvider,
+        out double value)
+    {
+        value = default;
+        StringComparison comparison = caseSensitive
+            ? StringComparison.Ordinal
+            : StringComparison.OrdinalIgnoreCase;
+        if (!text.EndsWith(suffix, comparison))
+        {
+            return false;
+        }
+
+        string number = text.Substring(0, text.Length - suffix.Length).TrimEnd();
+        if (number.Length == 0)
+        {
+            return false;
+        }
+
+        const NumberStyles styles = NumberStyles.Float | NumberStyles.AllowThousands;
+        if (double.TryParse(number, styles, formatProvider ?? CultureInfo.CurrentCulture, out value))
+        {
+            return true;
+        }
+
+        return formatProvider is null && double.TryParse(number, styles, CultureInfo.InvariantCulture, out value);
+    }
+
+    private sealed class SuffixCandidate<TUnit>
+        where TUnit : struct, Enum
+    {
+        public SuffixCandidate(string suffix, TUnit unit, bool caseSensitive)
+        {
+            Suffix = suffix;
+            Unit = unit;
+            CaseSensitive = caseSensitive;
+        }
+
+        public string Suffix { get; }
+
+        public TUnit Unit { get; }
+
+        public bool CaseSensitive { get; }
+    }
+
+    private static class SuffixCache<TUnit>
+        where TUnit : struct, Enum
+    {
+        private static readonly ConcurrentDictionary<(IQuantityMetadata<TUnit>, string), SuffixCandidate<TUnit>[]> Cache = new();
+
+        public static IReadOnlyList<SuffixCandidate<TUnit>> Get(
+            IQuantityMetadata<TUnit> metadata,
+            CultureInfo culture) =>
+            Cache.GetOrAdd((metadata, culture.Name), key => Create(key.Item1, culture));
+
+        private static SuffixCandidate<TUnit>[] Create(
+            IQuantityMetadata<TUnit> metadata,
+            CultureInfo culture) =>
+            metadata.Units
+                .SelectMany(unit =>
+                    unit.GetAbbreviations(culture)
+                        .Select(abbreviation => new SuffixCandidate<TUnit>(abbreviation, unit.Value, true))
+                        .Concat(new[]
+                        {
+                            new SuffixCandidate<TUnit>(unit.SingularName, unit.Value, false),
+                            new SuffixCandidate<TUnit>(unit.PluralName, unit.Value, false),
+                        }))
+                .Where(candidate => candidate.Suffix.Length > 0)
+                .OrderByDescending(candidate => candidate.Suffix.Length)
+                .ThenBy(candidate => candidate.Suffix, StringComparer.Ordinal)
+                .ToArray();
+    }
+
+    private static class UnitSystemCandidateCache<TUnit>
+        where TUnit : struct, Enum
+    {
+        private static readonly ConcurrentDictionary<IQuantityMetadata<TUnit>, UnitInfo<TUnit>[]> Cache = new();
+
+        public static UnitInfo<TUnit>[] Get(IQuantityMetadata<TUnit> metadata) =>
+            Cache.GetOrAdd(
+                metadata,
+                static current => current.Units
+                    .OrderBy(candidate => candidate.SingularName, StringComparer.Ordinal)
+                    .ToArray());
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Quantities/IAffineQuantity.cs b/UnitsNet.Modular/UnitsNet.Modular/Quantities/IAffineQuantity.cs
new file mode 100644
index 0000000000..7128ded6b4
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Quantities/IAffineQuantity.cs
@@ -0,0 +1,40 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Numerics;
+
+namespace UnitsNet;
+
+/// <summary>
+/// A quantity whose unit conversions may include an offset and therefore do not have conventional
+/// same-quantity arithmetic semantics.
+/// </summary>
+/// <typeparam name="TSelf">The concrete quantity type.</typeparam>
+public interface IAffineQuantity<TSelf> : IQuantity<double>
+    where TSelf : IAffineQuantity<TSelf>
+{
+}
+
+/// <summary>An affine quantity whose arithmetic is expressed through a linear offset quantity.</summary>
+/// <typeparam name="TSelf">The concrete quantity type.</typeparam>
+/// <typeparam name="TOffset">The linear quantity type representing differences.</typeparam>
+public interface IAffineQuantity<TSelf, TOffset> :
+    IAffineQuantity<TSelf>,
+    IAdditionOperators<TSelf, TOffset, TSelf>,
+    ISubtractionOperators<TSelf, TSelf, TOffset>
+    where TSelf : IAffineQuantity<TSelf, TOffset>
+    where TOffset : ILinearQuantity<TOffset>
+{
+}
+
+/// <summary>A strongly typed affine quantity with a linear offset quantity.</summary>
+/// <typeparam name="TSelf">The concrete quantity type.</typeparam>
+/// <typeparam name="TUnit">The unit enum type.</typeparam>
+/// <typeparam name="TOffset">The linear quantity type representing differences.</typeparam>
+public interface IAffineQuantity<TSelf, TUnit, TOffset> :
+    IQuantity<TSelf, TUnit>,
+    IAffineQuantity<TSelf, TOffset>
+    where TSelf : IAffineQuantity<TSelf, TUnit, TOffset>
+    where TUnit : struct, Enum
+    where TOffset : ILinearQuantity<TOffset>
+{
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Quantities/IArithmeticQuantity.cs b/UnitsNet.Modular/UnitsNet.Modular/Quantities/IArithmeticQuantity.cs
new file mode 100644
index 0000000000..8a37d2e824
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Quantities/IArithmeticQuantity.cs
@@ -0,0 +1,53 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Numerics;
+
+namespace UnitsNet;
+
+/// <summary>A quantity that supports same-quantity arithmetic with a <see cref="double" /> scalar.</summary>
+/// <typeparam name="TSelf">The concrete quantity type.</typeparam>
+public interface IArithmeticQuantity<TSelf> :
+    IQuantity<double>,
+    IAdditionOperators<TSelf, TSelf, TSelf>,
+    ISubtractionOperators<TSelf, TSelf, TSelf>,
+    IMultiplyOperators<TSelf, double, TSelf>,
+    IDivisionOperators<TSelf, double, TSelf>,
+    IUnaryNegationOperators<TSelf, TSelf>
+    where TSelf : IArithmeticQuantity<TSelf>
+{
+}
+
+/// <summary>A strongly typed arithmetic quantity.</summary>
+/// <typeparam name="TSelf">The concrete quantity type.</typeparam>
+/// <typeparam name="TUnit">The unit enum type.</typeparam>
+public interface IArithmeticQuantity<TSelf, TUnit> :
+    IQuantity<TSelf, TUnit>,
+    IArithmeticQuantity<TSelf>
+    where TSelf : IArithmeticQuantity<TSelf, TUnit>
+    where TUnit : struct, Enum
+{
+}
+
+/// <summary>A linear quantity with an additive zero and conventional arithmetic semantics.</summary>
+/// <typeparam name="TSelf">The concrete quantity type.</typeparam>
+public interface ILinearQuantity<TSelf> :
+    IArithmeticQuantity<TSelf>,
+    IAdditiveIdentity<TSelf, TSelf>
+    where TSelf : ILinearQuantity<TSelf>
+{
+    /// <summary>Gets zero expressed in the quantity's base unit.</summary>
+    static abstract TSelf Zero { get; }
+
+    static TSelf IAdditiveIdentity<TSelf, TSelf>.AdditiveIdentity => TSelf.Zero;
+}
+
+/// <summary>A strongly typed linear quantity.</summary>
+/// <typeparam name="TSelf">The concrete quantity type.</typeparam>
+/// <typeparam name="TUnit">The unit enum type.</typeparam>
+public interface ILinearQuantity<TSelf, TUnit> :
+    IArithmeticQuantity<TSelf, TUnit>,
+    ILinearQuantity<TSelf>
+    where TSelf : ILinearQuantity<TSelf, TUnit>
+    where TUnit : struct, Enum
+{
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Quantities/ILogarithmicQuantity.cs b/UnitsNet.Modular/UnitsNet.Modular/Quantities/ILogarithmicQuantity.cs
new file mode 100644
index 0000000000..82a8f9ceed
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Quantities/ILogarithmicQuantity.cs
@@ -0,0 +1,26 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet;
+
+/// <summary>A logarithmic quantity with logarithmic arithmetic semantics.</summary>
+/// <typeparam name="TSelf">The concrete quantity type.</typeparam>
+public interface ILogarithmicQuantity<TSelf> : IArithmeticQuantity<TSelf>
+    where TSelf : ILogarithmicQuantity<TSelf>
+{
+    /// <summary>Gets the factor used to map between logarithmic and linear space.</summary>
+    static abstract double LogarithmicScalingFactor { get; }
+
+    /// <summary>Gets zero expressed in the quantity's base unit.</summary>
+    static abstract TSelf Zero { get; }
+}
+
+/// <summary>A strongly typed logarithmic quantity.</summary>
+/// <typeparam name="TSelf">The concrete quantity type.</typeparam>
+/// <typeparam name="TUnit">The unit enum type.</typeparam>
+public interface ILogarithmicQuantity<TSelf, TUnit> :
+    IQuantity<TSelf, TUnit>,
+    ILogarithmicQuantity<TSelf>
+    where TSelf : ILogarithmicQuantity<TSelf, TUnit>
+    where TUnit : struct, Enum
+{
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Quantities/IQuantity.cs b/UnitsNet.Modular/UnitsNet.Modular/Quantities/IQuantity.cs
new file mode 100644
index 0000000000..466c5a4a38
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Quantities/IQuantity.cs
@@ -0,0 +1,60 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using UnitsNet;
+
+namespace UnitsNet;
+
+/// <summary>A minimal, type-erased quantity value contract.</summary>
+/// <typeparam name="TValue">The numeric storage type.</typeparam>
+public interface IQuantity<out TValue> : IFormattable
+{
+    /// <summary>Gets the stored numeric value.</summary>
+    TValue Value { get; }
+
+    /// <summary>
+    /// Gets the unit in which <see cref="Value" /> is expressed.
+    /// Use a strongly typed quantity contract when the unit enum type is known.
+    /// </summary>
+    Enum Unit { get; }
+}
+
+/// <summary>
+/// A self-typed quantity contract with construction and conversion primitives.
+/// </summary>
+/// <typeparam name="TSelf">The concrete quantity type.</typeparam>
+/// <typeparam name="TUnit">The unit enum type.</typeparam>
+/// <typeparam name="TValue">The numeric storage type.</typeparam>
+public interface IQuantity<TSelf, TUnit, TValue> : IQuantity<TValue>
+    where TSelf : IQuantity<TSelf, TUnit, TValue>
+    where TUnit : struct, Enum
+{
+    /// <summary>Gets the unit in which <see cref="IQuantity{TValue}.Value" /> is expressed.</summary>
+    new TUnit Unit { get; }
+
+    Enum IQuantity<TValue>.Unit => Unit;
+
+    /// <summary>Creates a quantity with a value expressed in the specified unit.</summary>
+    static abstract TSelf From(TValue value, TUnit unit);
+
+    /// <summary>Converts a numeric value between two units of this quantity.</summary>
+    static abstract TValue Convert(TValue value, TUnit fromUnit, TUnit toUnit);
+
+    /// <summary>Gets this quantity's value expressed in the specified unit.</summary>
+    TValue As(TUnit unit) => TSelf.Convert(Value, Unit, unit);
+
+    /// <summary>Converts this quantity to the specified unit.</summary>
+    TSelf ToUnit(TUnit unit) => TSelf.From(As(unit), unit);
+}
+
+/// <summary>
+/// A self-typed generated quantity with immutable metadata, construction, and conversion primitives.
+/// </summary>
+/// <typeparam name="TSelf">The concrete generated quantity type.</typeparam>
+/// <typeparam name="TUnit">The generated unit enum type.</typeparam>
+public interface IQuantity<TSelf, TUnit> : IQuantity<TSelf, TUnit, double>
+    where TSelf : IQuantity<TSelf, TUnit>
+    where TUnit : struct, Enum
+{
+    /// <summary>Gets the canonical immutable description of this generated quantity type.</summary>
+    static abstract QuantityInfo<TSelf, TUnit> Info { get; }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/Registry/QuantityRegistry.cs b/UnitsNet.Modular/UnitsNet.Modular/Registry/QuantityRegistry.cs
new file mode 100644
index 0000000000..22981032d1
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/Registry/QuantityRegistry.cs
@@ -0,0 +1,269 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+using System.Collections.Frozen;
+
+namespace UnitsNet;
+
+/// <summary>An immutable registry of the quantities selected into one consumer-owned module.</summary>
+public sealed class QuantityRegistry
+{
+    private readonly FrozenDictionary<QuantityId, IQuantityDescriptor> _byId;
+    private readonly FrozenDictionary<string, IQuantityDescriptor> _byName;
+    private readonly FrozenDictionary<Type, IQuantityDescriptor> _byType;
+    private readonly FrozenDictionary<Type, IQuantityDescriptor> _byUnitType;
+
+    /// <summary>Creates a registry from generated descriptors.</summary>
+    public QuantityRegistry(IEnumerable<IQuantityDescriptor> quantities)
+    {
+        ArgumentNullException.ThrowIfNull(quantities);
+        IQuantityDescriptor[] entries = quantities.ToArray();
+        Quantities = Array.AsReadOnly(entries);
+        Names = Array.AsReadOnly(entries.Select(quantity => quantity.Name).ToArray());
+        _byId = entries.ToFrozenDictionary(quantity => quantity.Id);
+        _byName = entries.ToFrozenDictionary(quantity => quantity.Name, StringComparer.OrdinalIgnoreCase);
+        _byType = entries.ToFrozenDictionary(quantity => quantity.QuantityType);
+        _byUnitType = entries.ToFrozenDictionary(quantity => quantity.UnitType);
+    }
+
+    /// <summary>Gets all quantities selected into the generated module.</summary>
+    public IReadOnlyList<IQuantityDescriptor> Quantities { get; }
+
+    /// <summary>Gets all invariant quantity names selected into the generated module.</summary>
+    public IReadOnlyCollection<string> Names { get; }
+
+    /// <summary>Gets selected quantity descriptors by invariant name.</summary>
+    public IReadOnlyDictionary<string, IQuantityDescriptor> ByName => _byName;
+
+    /// <summary>Gets a descriptor by stable semantic identity.</summary>
+    public IQuantityDescriptor Get(QuantityId id) =>
+        _byId.TryGetValue(id, out IQuantityDescriptor? quantity)
+            ? quantity
+            : throw new KeyNotFoundException($"Quantity '{id}' is not selected into this module.");
+
+    /// <summary>Gets a descriptor by definition name.</summary>
+    public IQuantityDescriptor Get(string name) =>
+        _byName.TryGetValue(name, out IQuantityDescriptor? quantity)
+            ? quantity
+            : throw new KeyNotFoundException($"Quantity '{name}' is not selected into this module.");
+
+    /// <summary>Gets a descriptor by generated CLR type.</summary>
+    public IQuantityDescriptor Get(Type type) =>
+        _byType.TryGetValue(type, out IQuantityDescriptor? quantity)
+            ? quantity
+            : throw new KeyNotFoundException($"Quantity type '{type.FullName}' is not selected into this module.");
+
+    /// <summary>Gets a descriptor by generated unit-enum CLR type.</summary>
+    public IQuantityDescriptor GetByUnitType(Type unitType) =>
+        _byUnitType.TryGetValue(unitType, out IQuantityDescriptor? quantity)
+            ? quantity
+            : throw new KeyNotFoundException($"Unit type '{unitType.FullName}' is not selected into this module.");
+
+    /// <summary>Attempts to get a descriptor by stable semantic identity.</summary>
+    public bool TryGet(QuantityId id, out IQuantityDescriptor? quantity) => _byId.TryGetValue(id, out quantity);
+
+    /// <summary>Attempts to get a descriptor by definition name.</summary>
+    public bool TryGet(string name, out IQuantityDescriptor? quantity) => _byName.TryGetValue(name, out quantity);
+
+    /// <summary>Attempts to get a descriptor by generated CLR type.</summary>
+    public bool TryGet(Type type, out IQuantityDescriptor? quantity) => _byType.TryGetValue(type, out quantity);
+
+    /// <summary>Attempts to get a descriptor by generated unit-enum CLR type.</summary>
+    public bool TryGetByUnitType(Type unitType, out IQuantityDescriptor? quantity) =>
+        _byUnitType.TryGetValue(unitType, out quantity);
+
+    /// <summary>Creates a selected quantity from invariant quantity and unit names.</summary>
+    public IQuantity<double> Create(double value, string quantityName, string unitName) =>
+        Get(quantityName).Create(value, unitName);
+
+    /// <summary>Attempts to create a selected quantity from invariant quantity and unit names.</summary>
+    public bool TryCreate(
+        double value,
+        string quantityName,
+        string unitName,
+        [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out IQuantity<double>? quantity)
+    {
+        if (TryGet(quantityName, out IQuantityDescriptor? descriptor))
+        {
+            return descriptor!.TryCreate(value, unitName, out quantity);
+        }
+
+        quantity = null;
+        return false;
+    }
+
+    /// <summary>Creates a selected quantity using an immutable unit-system policy.</summary>
+    public IQuantity<double> Create(double value, string quantityName, UnitSystem unitSystem) =>
+        Get(quantityName).Create(value, unitSystem);
+
+    /// <summary>Attempts to create a selected quantity using an immutable unit-system policy.</summary>
+    public bool TryCreate(
+        double value,
+        string quantityName,
+        UnitSystem? unitSystem,
+        [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out IQuantity<double>? quantity)
+    {
+        if (TryGet(quantityName, out IQuantityDescriptor? descriptor))
+        {
+            return descriptor!.TryCreate(value, unitSystem, out quantity);
+        }
+
+        quantity = null;
+        return false;
+    }
+
+    /// <summary>Creates a selected quantity from a generated unit-enum value.</summary>
+    public IQuantity<double> Create(double value, Enum unit)
+    {
+        ArgumentNullException.ThrowIfNull(unit);
+        IQuantityDescriptor descriptor = GetByUnitType(unit.GetType());
+        return descriptor.Create(value, GetUnitName(unit));
+    }
+
+    /// <summary>Attempts to create a selected quantity from a generated unit-enum value.</summary>
+    public bool TryCreate(
+        double value,
+        Enum? unit,
+        [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out IQuantity<double>? quantity)
+    {
+        if (TryResolveUnit(unit, out IQuantityDescriptor descriptor, out string unitName))
+        {
+            return descriptor.TryCreate(value, unitName, out quantity);
+        }
+
+        quantity = null;
+        return false;
+    }
+
+    /// <summary>Converts a value between selected units identified by invariant names.</summary>
+    public double Convert(double value, string quantityName, string fromUnitName, string toUnitName) =>
+        Get(quantityName).Convert(value, fromUnitName, toUnitName);
+
+    /// <summary>Attempts to convert a value between selected units identified by invariant names.</summary>
+    public bool TryConvert(
+        double value,
+        string quantityName,
+        string fromUnitName,
+        string toUnitName,
+        out double convertedValue)
+    {
+        if (TryGet(quantityName, out IQuantityDescriptor? descriptor))
+        {
+            return descriptor!.TryConvert(value, fromUnitName, toUnitName, out convertedValue);
+        }
+
+        convertedValue = default;
+        return false;
+    }
+
+    /// <summary>Converts a value from a selected unit name into an immutable unit system.</summary>
+    public double Convert(
+        double value,
+        string quantityName,
+        string fromUnitName,
+        UnitSystem unitSystem) =>
+        Get(quantityName).Convert(value, fromUnitName, unitSystem);
+
+    /// <summary>Attempts to convert a value from a selected unit name into an immutable unit system.</summary>
+    public bool TryConvert(
+        double value,
+        string quantityName,
+        string fromUnitName,
+        UnitSystem? unitSystem,
+        out double convertedValue)
+    {
+        if (TryGet(quantityName, out IQuantityDescriptor? descriptor))
+        {
+            return descriptor!.TryConvert(
+                value,
+                fromUnitName,
+                unitSystem,
+                out convertedValue);
+        }
+
+        convertedValue = default;
+        return false;
+    }
+
+    /// <summary>Converts a value between two values of the same selected unit-enum type.</summary>
+    public double Convert(double value, Enum fromUnit, Enum toUnit)
+    {
+        ArgumentNullException.ThrowIfNull(fromUnit);
+        ArgumentNullException.ThrowIfNull(toUnit);
+        if (fromUnit.GetType() != toUnit.GetType())
+        {
+            throw new ArgumentException("Source and target units must belong to the same quantity.", nameof(toUnit));
+        }
+
+        IQuantityDescriptor descriptor = GetByUnitType(fromUnit.GetType());
+        return descriptor.Convert(value, GetUnitName(fromUnit), GetUnitName(toUnit));
+    }
+
+    /// <summary>Attempts to convert a value between two values of the same selected unit-enum type.</summary>
+    public bool TryConvert(double value, Enum? fromUnit, Enum? toUnit, out double convertedValue)
+    {
+        if (TryResolveUnit(fromUnit, out IQuantityDescriptor fromDescriptor, out string fromUnitName) &&
+            TryResolveUnit(toUnit, out IQuantityDescriptor toDescriptor, out string toUnitName) &&
+            ReferenceEquals(fromDescriptor, toDescriptor))
+        {
+            return fromDescriptor.TryConvert(value, fromUnitName, toUnitName, out convertedValue);
+        }
+
+        convertedValue = default;
+        return false;
+    }
+
+    /// <summary>Parses a selected quantity identified by its generated CLR type.</summary>
+    public IQuantity<double> Parse(
+        Type quantityType,
+        string text,
+        IFormatProvider? formatProvider = null) =>
+        Get(quantityType).Parse(text, formatProvider);
+
+    /// <summary>Attempts to parse a selected quantity identified by its generated CLR type.</summary>
+    public bool TryParse(
+        Type quantityType,
+        string? text,
+        IFormatProvider? formatProvider,
+        [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out IQuantity<double>? quantity)
+    {
+        if (TryGet(quantityType, out IQuantityDescriptor? descriptor))
+        {
+            return descriptor!.TryParse(text, formatProvider, out quantity);
+        }
+
+        quantity = null;
+        return false;
+    }
+
+    /// <summary>Finds selected quantities with exactly matching SI base dimensions.</summary>
+    public IReadOnlyList<IQuantityDescriptor> FindByBaseDimensions(BaseDimensions baseDimensions)
+    {
+        ArgumentNullException.ThrowIfNull(baseDimensions);
+        return Array.AsReadOnly(
+            Quantities.Where(quantity => quantity.BaseDimensions == baseDimensions).ToArray());
+    }
+
+    private static string GetUnitName(Enum unit) =>
+        Enum.GetName(unit.GetType(), unit)
+        ?? throw new ArgumentOutOfRangeException(nameof(unit), unit, "The unit value has no defined name.");
+
+    private bool TryResolveUnit(
+        Enum? unit,
+        out IQuantityDescriptor descriptor,
+        out string unitName)
+    {
+        if (unit is not null &&
+            _byUnitType.TryGetValue(unit.GetType(), out IQuantityDescriptor? resolved) &&
+            resolved is not null &&
+            Enum.GetName(unit.GetType(), unit) is { } definedName)
+        {
+            descriptor = resolved;
+            unitName = definedName;
+            return true;
+        }
+
+        descriptor = null!;
+        unitName = null!;
+        return false;
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/UnitSystems/BaseDimensions.cs b/UnitsNet.Modular/UnitsNet.Modular/UnitSystems/BaseDimensions.cs
new file mode 100644
index 0000000000..26f8acc7ae
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/UnitSystems/BaseDimensions.cs
@@ -0,0 +1,76 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet;
+
+/// <summary>Describes a quantity in terms of the seven SI base dimensions.</summary>
+public sealed record BaseDimensions(
+    int Length,
+    int Mass,
+    int Time,
+    int Current,
+    int Temperature,
+    int Amount,
+    int LuminousIntensity)
+{
+    /// <summary>Gets dimensionless dimensions.</summary>
+    public static BaseDimensions Dimensionless { get; } = new(0, 0, 0, 0, 0, 0, 0);
+
+    /// <summary>Returns whether exactly one base dimension has exponent one.</summary>
+    public bool IsBaseQuantity()
+    {
+        int count = 0;
+        ReadOnlySpan<int> exponents =
+            [Length, Mass, Time, Current, Temperature, Amount, LuminousIntensity];
+        foreach (int exponent in exponents)
+        {
+            if (exponent is not (0 or 1))
+            {
+                return false;
+            }
+
+            count += exponent;
+        }
+
+        return count == 1;
+    }
+
+    /// <summary>Returns whether all base-dimension exponents are zero.</summary>
+    public bool IsDimensionless() => this == Dimensionless;
+
+    /// <summary>Returns whether these dimensions represent a derived quantity.</summary>
+    public bool IsDerivedQuantity() => !IsBaseQuantity() && !IsDimensionless();
+
+    /// <summary>Combines dimensions for multiplication.</summary>
+    public BaseDimensions Multiply(BaseDimensions right)
+    {
+        ArgumentNullException.ThrowIfNull(right);
+        return new BaseDimensions(
+            Length + right.Length,
+            Mass + right.Mass,
+            Time + right.Time,
+            Current + right.Current,
+            Temperature + right.Temperature,
+            Amount + right.Amount,
+            LuminousIntensity + right.LuminousIntensity);
+    }
+
+    /// <summary>Combines dimensions for division.</summary>
+    public BaseDimensions Divide(BaseDimensions right)
+    {
+        ArgumentNullException.ThrowIfNull(right);
+        return new BaseDimensions(
+            Length - right.Length,
+            Mass - right.Mass,
+            Time - right.Time,
+            Current - right.Current,
+            Temperature - right.Temperature,
+            Amount - right.Amount,
+            LuminousIntensity - right.LuminousIntensity);
+    }
+
+    /// <summary>Combines dimensions for multiplication.</summary>
+    public static BaseDimensions operator *(BaseDimensions left, BaseDimensions right) => left.Multiply(right);
+
+    /// <summary>Combines dimensions for division.</summary>
+    public static BaseDimensions operator /(BaseDimensions left, BaseDimensions right) => left.Divide(right);
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/UnitSystems/BaseUnits.cs b/UnitsNet.Modular/UnitsNet.Modular/UnitSystems/BaseUnits.cs
new file mode 100644
index 0000000000..dfd0718098
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/UnitSystems/BaseUnits.cs
@@ -0,0 +1,133 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet;
+
+/// <summary>
+/// Identifies the invariant unit names chosen for the seven SI base dimensions.
+/// </summary>
+public sealed record BaseUnits
+{
+    /// <summary>Gets an instance with no base units defined.</summary>
+    public static BaseUnits Undefined { get; } = new();
+
+    /// <summary>Creates an immutable base-unit selection.</summary>
+    public BaseUnits(
+        string? length = null,
+        string? mass = null,
+        string? time = null,
+        string? current = null,
+        string? temperature = null,
+        string? amount = null,
+        string? luminousIntensity = null)
+    {
+        Length = Validate(length, nameof(length));
+        Mass = Validate(mass, nameof(mass));
+        Time = Validate(time, nameof(time));
+        Current = Validate(current, nameof(current));
+        Temperature = Validate(temperature, nameof(temperature));
+        Amount = Validate(amount, nameof(amount));
+        LuminousIntensity = Validate(luminousIntensity, nameof(luminousIntensity));
+    }
+
+    /// <summary>Gets the selected length unit name.</summary>
+    public string? Length { get; }
+
+    /// <summary>Gets the selected mass unit name.</summary>
+    public string? Mass { get; }
+
+    /// <summary>Gets the selected time unit name.</summary>
+    public string? Time { get; }
+
+    /// <summary>Gets the selected electric-current unit name.</summary>
+    public string? Current { get; }
+
+    /// <summary>Gets the selected temperature unit name.</summary>
+    public string? Temperature { get; }
+
+    /// <summary>Gets the selected amount-of-substance unit name.</summary>
+    public string? Amount { get; }
+
+    /// <summary>Gets the selected luminous-intensity unit name.</summary>
+    public string? LuminousIntensity { get; }
+
+    /// <summary>Gets whether all seven base units are defined.</summary>
+    public bool IsFullyDefined =>
+        Length is not null &&
+        Mass is not null &&
+        Time is not null &&
+        Current is not null &&
+        Temperature is not null &&
+        Amount is not null &&
+        LuminousIntensity is not null;
+
+    /// <summary>Gets whether no base units are defined.</summary>
+    public bool IsUndefined =>
+        Length is null &&
+        Mass is null &&
+        Time is null &&
+        Current is null &&
+        Temperature is null &&
+        Amount is null &&
+        LuminousIntensity is null;
+
+    /// <summary>
+    /// Returns whether every unit defined by this instance matches the corresponding unit in
+    /// <paramref name="other"/>.
+    /// </summary>
+    public bool IsSubsetOf(BaseUnits other)
+    {
+        ArgumentNullException.ThrowIfNull(other);
+        if (IsUndefined)
+        {
+            return other.IsUndefined;
+        }
+
+        return Matches(Length, other.Length) &&
+               Matches(Mass, other.Mass) &&
+               Matches(Time, other.Time) &&
+               Matches(Current, other.Current) &&
+               Matches(Temperature, other.Temperature) &&
+               Matches(Amount, other.Amount) &&
+               Matches(LuminousIntensity, other.LuminousIntensity);
+    }
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        if (IsUndefined)
+        {
+            return "Undefined";
+        }
+
+        var units = new List<string>(7);
+        Add(units, "L", Length);
+        Add(units, "M", Mass);
+        Add(units, "T", Time);
+        Add(units, "I", Current);
+        Add(units, "Θ", Temperature);
+        Add(units, "N", Amount);
+        Add(units, "J", LuminousIntensity);
+        return string.Join(", ", units);
+    }
+
+    private static string? Validate(string? value, string parameterName)
+    {
+        if (value is not null && string.IsNullOrWhiteSpace(value))
+        {
+            throw new ArgumentException("A defined base-unit name cannot be empty.", parameterName);
+        }
+
+        return value;
+    }
+
+    private static bool Matches(string? required, string? selected) =>
+        required is null || string.Equals(required, selected, StringComparison.Ordinal);
+
+    private static void Add(ICollection<string> target, string symbol, string? value)
+    {
+        if (value is not null)
+        {
+            target.Add($"{symbol}={value}");
+        }
+    }
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/UnitSystems/UnitSystem.cs b/UnitsNet.Modular/UnitsNet.Modular/UnitSystems/UnitSystem.cs
new file mode 100644
index 0000000000..fc1525fe7a
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/UnitSystems/UnitSystem.cs
@@ -0,0 +1,35 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet;
+
+/// <summary>
+/// An immutable caller-owned policy for selecting quantity units from constituent base units.
+/// </summary>
+public sealed record UnitSystem
+{
+    /// <summary>Creates a unit system from an explicit base-unit selection.</summary>
+    public UnitSystem(BaseUnits baseUnits)
+    {
+        ArgumentNullException.ThrowIfNull(baseUnits);
+        if (baseUnits.IsUndefined)
+        {
+            throw new ArgumentException("A unit system must define at least one base unit.", nameof(baseUnits));
+        }
+
+        BaseUnits = baseUnits;
+    }
+
+    /// <summary>Gets the unit system's selected base units.</summary>
+    public BaseUnits BaseUnits { get; }
+
+    /// <summary>Gets the International System of Units base-unit policy.</summary>
+    public static UnitSystem SI { get; } = new(
+        new BaseUnits(
+            length: "Meter",
+            mass: "Kilogram",
+            time: "Second",
+            current: "Ampere",
+            temperature: "Kelvin",
+            amount: "Mole",
+            luminousIntensity: "Candela"));
+}
diff --git a/UnitsNet.Modular/UnitsNet.Modular/UnitsNet.Modular.csproj b/UnitsNet.Modular/UnitsNet.Modular/UnitsNet.Modular.csproj
new file mode 100644
index 0000000000..ec4e8b0819
--- /dev/null
+++ b/UnitsNet.Modular/UnitsNet.Modular/UnitsNet.Modular.csproj
@@ -0,0 +1,69 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <RootNamespace>UnitsNet</RootNamespace>
+    <IsPackable>true</IsPackable>
+    <IsAotCompatible>true</IsAotCompatible>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>../../UnitsNet.snk</AssemblyOriginatorKeyFile>
+
+    <!--
+      The repository's local-package workflow passes a unique development version explicitly.
+      Ordinary local builds use the stable version from the shared versioning props, while CI and
+      release preparation opt into the MinVer-derived publish version.
+    -->
+    <UnitsNetModularLocalFeed Condition="'$(UnitsNetModularLocalFeed)' == ''">$(RepositoryLocalNuGetFeed)</UnitsNetModularLocalFeed>
+    <PackageOutputPath Condition="'$(UnitsNetModularPackForPublish)' != 'true' and '$(PackageOutputPath)' == ''">$(UnitsNetModularLocalFeed)</PackageOutputPath>
+
+    <PackageId>UnitsNet.Modular</PackageId>
+    <Title>UnitsNet Modular</Title>
+    <Description>Generate lean, strongly typed quantities and units at compile time from built-in or custom definitions.</Description>
+    <Authors>Andreas Gullberg Larsen</Authors>
+    <Copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</Copyright>
+    <PackageProjectUrl>https://github.com/angularsen/UnitsNet/tree/master/UnitsNet.Modular</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/angularsen/UnitsNet</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <PackageLicenseExpression>MIT-0</PackageLicenseExpression>
+    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
+    <PackageIcon>logo-32.png</PackageIcon>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageTags>unitsnet unit units quantity quantities measurement source-generator code-generation modular conversion parsing</PackageTags>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    <EnablePackageValidation>true</EnablePackageValidation>
+    <!-- Build-only source directory for analyzer dependency files copied into the combined NuGet package. -->
+    <_UnitsNetModularAnalyzerDependencyDirectory>$(MSBuildThisFileDirectory)../../Artifacts/UnitsNet.Modular.Generator/netstandard2.0/</_UnitsNetModularAnalyzerDependencyDirectory>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="MinVer" PrivateAssets="all" />
+    <ProjectReference Include="..\UnitsNet.Modular.Generator\UnitsNet.Modular.Generator.csproj"
+                      PrivateAssets="all"
+                      ReferenceOutputAssembly="false" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="../../Artifacts/UnitsNet.Modular.Generator/netstandard2.0/UnitsNet.Modular.Generator.dll"
+          Pack="true"
+          PackagePath="analyzers/dotnet/cs" />
+    <None Include="$(_UnitsNetModularAnalyzerDependencyDirectory)Microsoft.Bcl.AsyncInterfaces.dll;$(_UnitsNetModularAnalyzerDependencyDirectory)System.Buffers.dll;$(_UnitsNetModularAnalyzerDependencyDirectory)System.IO.Pipelines.dll;$(_UnitsNetModularAnalyzerDependencyDirectory)System.Memory.dll;$(_UnitsNetModularAnalyzerDependencyDirectory)System.Numerics.Vectors.dll;$(_UnitsNetModularAnalyzerDependencyDirectory)System.Runtime.CompilerServices.Unsafe.dll;$(_UnitsNetModularAnalyzerDependencyDirectory)System.Text.Encodings.Web.dll;$(_UnitsNetModularAnalyzerDependencyDirectory)System.Text.Json.dll;$(_UnitsNetModularAnalyzerDependencyDirectory)System.Threading.Tasks.Extensions.dll"
+          Pack="true"
+          PackagePath="analyzers/dotnet/cs"
+          Visible="false" />
+    <None Include="../UnitsNet.Modular.Generator/buildTransitive/UnitsNet.Modular.Generator.props"
+          Pack="true"
+          PackagePath="buildTransitive/UnitsNet.Modular.props" />
+    <None Include="../UnitsNet.Modular.Generator/buildTransitive/UnitsNet.Modular.Generator.targets"
+          Pack="true"
+          PackagePath="buildTransitive/UnitsNet.Modular.targets" />
+    <None Include="../README.md" Pack="true" PackagePath="README.md" />
+    <None Include="../THIRD-PARTY-NOTICES.md" Pack="true" PackagePath="THIRD-PARTY-NOTICES.md" />
+    <None Include="$(NuGetPackageRoot)/system.text.json/$(SystemTextJsonVersion)/THIRD-PARTY-NOTICES.TXT"
+          Pack="true"
+          PackagePath="DOTNET-THIRD-PARTY-NOTICES.TXT" />
+    <None Include="../../Docs/Images/logo-32.png" Pack="true" PackagePath="logo-32.png" />
+  </ItemGroup>
+</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AbsorbedDoseOfIonizingRadiation/AbsorbedDoseOfIonizingRadiation.nfproj b/UnitsNet.NanoFramework/GeneratedCode/AbsorbedDoseOfIonizingRadiation/AbsorbedDoseOfIonizingRadiation.nfproj
deleted file mode 100644
index f6a4dcd7bb..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AbsorbedDoseOfIonizingRadiation/AbsorbedDoseOfIonizingRadiation.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{3d39134e-c97d-cba4-a559-fdb3a0da5e54}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.AbsorbedDoseOfIonizingRadiation</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\AbsorbedDoseOfIonizingRadiation.g.cs" />
-    <Compile Include="..\Units\AbsorbedDoseOfIonizingRadiationUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AbsorbedDoseOfIonizingRadiation/UnitsNet.NanoFramework.AbsorbedDoseOfIonizingRadiation.nuspec b/UnitsNet.NanoFramework/GeneratedCode/AbsorbedDoseOfIonizingRadiation/UnitsNet.NanoFramework.AbsorbedDoseOfIonizingRadiation.nuspec
deleted file mode 100644
index 7bc494fd95..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AbsorbedDoseOfIonizingRadiation/UnitsNet.NanoFramework.AbsorbedDoseOfIonizingRadiation.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.AbsorbedDoseOfIonizingRadiation</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET AbsorbedDoseOfIonizingRadiation - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds AbsorbedDoseOfIonizingRadiation units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework absorbeddoseofionizingradiation unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\AbsorbedDoseOfIonizingRadiation\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AbsorbedDoseOfIonizingRadiation/packages.config b/UnitsNet.NanoFramework/GeneratedCode/AbsorbedDoseOfIonizingRadiation/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AbsorbedDoseOfIonizingRadiation/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Acceleration/Acceleration.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Acceleration/Acceleration.nfproj
deleted file mode 100644
index df1a10492d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Acceleration/Acceleration.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{8e3a6691-a05f-d71c-f12a-f537c0807f85}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Acceleration</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Acceleration.g.cs" />
-    <Compile Include="..\Units\AccelerationUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Acceleration/UnitsNet.NanoFramework.Acceleration.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Acceleration/UnitsNet.NanoFramework.Acceleration.nuspec
deleted file mode 100644
index c247ea9e1c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Acceleration/UnitsNet.NanoFramework.Acceleration.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Acceleration</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Acceleration - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Acceleration units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework acceleration unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Acceleration\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Acceleration/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Acceleration/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Acceleration/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AmountOfSubstance/AmountOfSubstance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/AmountOfSubstance/AmountOfSubstance.nfproj
deleted file mode 100644
index c0f1b2fbf2..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AmountOfSubstance/AmountOfSubstance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{1cd282f3-3bdc-bc00-a63a-03a11a9b5c4d}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.AmountOfSubstance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\AmountOfSubstance.g.cs" />
-    <Compile Include="..\Units\AmountOfSubstanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AmountOfSubstance/UnitsNet.NanoFramework.AmountOfSubstance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/AmountOfSubstance/UnitsNet.NanoFramework.AmountOfSubstance.nuspec
deleted file mode 100644
index d0daa4760d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AmountOfSubstance/UnitsNet.NanoFramework.AmountOfSubstance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.AmountOfSubstance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET AmountOfSubstance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds AmountOfSubstance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework amountofsubstance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\AmountOfSubstance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AmountOfSubstance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/AmountOfSubstance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AmountOfSubstance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AmplitudeRatio/AmplitudeRatio.nfproj b/UnitsNet.NanoFramework/GeneratedCode/AmplitudeRatio/AmplitudeRatio.nfproj
deleted file mode 100644
index e22c293100..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AmplitudeRatio/AmplitudeRatio.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{59c09a1b-eff0-e367-6372-d16c4c984916}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.AmplitudeRatio</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\AmplitudeRatio.g.cs" />
-    <Compile Include="..\Units\AmplitudeRatioUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AmplitudeRatio/UnitsNet.NanoFramework.AmplitudeRatio.nuspec b/UnitsNet.NanoFramework/GeneratedCode/AmplitudeRatio/UnitsNet.NanoFramework.AmplitudeRatio.nuspec
deleted file mode 100644
index bf937ac6d5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AmplitudeRatio/UnitsNet.NanoFramework.AmplitudeRatio.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.AmplitudeRatio</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET AmplitudeRatio - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds AmplitudeRatio units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework amplituderatio unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\AmplitudeRatio\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AmplitudeRatio/packages.config b/UnitsNet.NanoFramework/GeneratedCode/AmplitudeRatio/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AmplitudeRatio/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Angle/Angle.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Angle/Angle.nfproj
deleted file mode 100644
index 23e17a96b4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Angle/Angle.nfproj
+++ /dev/null
@@ -1,47 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{4b036819-f813-0c4d-3e44-1fcc8b5f3ec7}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Angle</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Angle.g.cs" />
-    <Compile Include="..\Units\AngleUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-    <Reference Include="System.Math, Version=1.5.43.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.System.Math.1.5.43\lib\System.Math.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Angle/UnitsNet.NanoFramework.Angle.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Angle/UnitsNet.NanoFramework.Angle.nuspec
deleted file mode 100644
index 2c47c4cc7e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Angle/UnitsNet.NanoFramework.Angle.nuspec
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Angle</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Angle - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Angle units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework angle unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-      <dependency id="nanoFramework.System.Math" version="1.5.43" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Angle\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Angle/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Angle/packages.config
deleted file mode 100644
index ac11548cd6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Angle/packages.config
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-  <package id="nanoFramework.System.Math" version="1.5.43" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Area/Area.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Area/Area.nfproj
deleted file mode 100644
index a5635a4a6e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Area/Area.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{04c24d02-bad7-a877-ff9b-a36a886c9633}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Area</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Area.g.cs" />
-    <Compile Include="..\Units\AreaUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Area/UnitsNet.NanoFramework.Area.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Area/UnitsNet.NanoFramework.Area.nuspec
deleted file mode 100644
index 0180e3fd6f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Area/UnitsNet.NanoFramework.Area.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Area</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Area - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Area units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework area unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Area\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Area/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Area/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Area/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AreaDensity/AreaDensity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/AreaDensity/AreaDensity.nfproj
deleted file mode 100644
index 37a1fe8e9d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AreaDensity/AreaDensity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{92ff1332-bf34-943e-a58d-8a76746d879e}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.AreaDensity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\AreaDensity.g.cs" />
-    <Compile Include="..\Units\AreaDensityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AreaDensity/UnitsNet.NanoFramework.AreaDensity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/AreaDensity/UnitsNet.NanoFramework.AreaDensity.nuspec
deleted file mode 100644
index da7d247c1b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AreaDensity/UnitsNet.NanoFramework.AreaDensity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.AreaDensity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET AreaDensity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds AreaDensity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework areadensity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\AreaDensity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AreaDensity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/AreaDensity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AreaDensity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AreaMomentOfInertia/AreaMomentOfInertia.nfproj b/UnitsNet.NanoFramework/GeneratedCode/AreaMomentOfInertia/AreaMomentOfInertia.nfproj
deleted file mode 100644
index 1ca5b17bd1..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AreaMomentOfInertia/AreaMomentOfInertia.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{566ef13c-0d17-e465-d35f-1bd9c65559bf}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.AreaMomentOfInertia</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\AreaMomentOfInertia.g.cs" />
-    <Compile Include="..\Units\AreaMomentOfInertiaUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AreaMomentOfInertia/UnitsNet.NanoFramework.AreaMomentOfInertia.nuspec b/UnitsNet.NanoFramework/GeneratedCode/AreaMomentOfInertia/UnitsNet.NanoFramework.AreaMomentOfInertia.nuspec
deleted file mode 100644
index 99302a9e59..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AreaMomentOfInertia/UnitsNet.NanoFramework.AreaMomentOfInertia.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.AreaMomentOfInertia</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET AreaMomentOfInertia - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds AreaMomentOfInertia units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework areamomentofinertia unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\AreaMomentOfInertia\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/AreaMomentOfInertia/packages.config b/UnitsNet.NanoFramework/GeneratedCode/AreaMomentOfInertia/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/AreaMomentOfInertia/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/BitRate/BitRate.nfproj b/UnitsNet.NanoFramework/GeneratedCode/BitRate/BitRate.nfproj
deleted file mode 100644
index e7649658be..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/BitRate/BitRate.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{b5fdf997-829f-5281-e624-ee4eee5aa26c}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.BitRate</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\BitRate.g.cs" />
-    <Compile Include="..\Units\BitRateUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/BitRate/UnitsNet.NanoFramework.BitRate.nuspec b/UnitsNet.NanoFramework/GeneratedCode/BitRate/UnitsNet.NanoFramework.BitRate.nuspec
deleted file mode 100644
index f4bff46143..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/BitRate/UnitsNet.NanoFramework.BitRate.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.BitRate</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET BitRate - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds BitRate units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework bitrate unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\BitRate\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/BitRate/packages.config b/UnitsNet.NanoFramework/GeneratedCode/BitRate/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/BitRate/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/BrakeSpecificFuelConsumption/BrakeSpecificFuelConsumption.nfproj b/UnitsNet.NanoFramework/GeneratedCode/BrakeSpecificFuelConsumption/BrakeSpecificFuelConsumption.nfproj
deleted file mode 100644
index 5fa730a735..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/BrakeSpecificFuelConsumption/BrakeSpecificFuelConsumption.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{085145f2-2b8f-4d09-5290-c14cdcd452bf}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.BrakeSpecificFuelConsumption</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\BrakeSpecificFuelConsumption.g.cs" />
-    <Compile Include="..\Units\BrakeSpecificFuelConsumptionUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/BrakeSpecificFuelConsumption/UnitsNet.NanoFramework.BrakeSpecificFuelConsumption.nuspec b/UnitsNet.NanoFramework/GeneratedCode/BrakeSpecificFuelConsumption/UnitsNet.NanoFramework.BrakeSpecificFuelConsumption.nuspec
deleted file mode 100644
index 864aa62a3d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/BrakeSpecificFuelConsumption/UnitsNet.NanoFramework.BrakeSpecificFuelConsumption.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.BrakeSpecificFuelConsumption</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET BrakeSpecificFuelConsumption - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds BrakeSpecificFuelConsumption units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework brakespecificfuelconsumption unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\BrakeSpecificFuelConsumption\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/BrakeSpecificFuelConsumption/packages.config b/UnitsNet.NanoFramework/GeneratedCode/BrakeSpecificFuelConsumption/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/BrakeSpecificFuelConsumption/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/CoefficientOfThermalExpansion/CoefficientOfThermalExpansion.nfproj b/UnitsNet.NanoFramework/GeneratedCode/CoefficientOfThermalExpansion/CoefficientOfThermalExpansion.nfproj
deleted file mode 100644
index 79a008978a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/CoefficientOfThermalExpansion/CoefficientOfThermalExpansion.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{a9514ce6-d4e7-88ca-051e-e9e53610c519}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.CoefficientOfThermalExpansion</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\CoefficientOfThermalExpansion.g.cs" />
-    <Compile Include="..\Units\CoefficientOfThermalExpansionUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/CoefficientOfThermalExpansion/UnitsNet.NanoFramework.CoefficientOfThermalExpansion.nuspec b/UnitsNet.NanoFramework/GeneratedCode/CoefficientOfThermalExpansion/UnitsNet.NanoFramework.CoefficientOfThermalExpansion.nuspec
deleted file mode 100644
index fd5669364e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/CoefficientOfThermalExpansion/UnitsNet.NanoFramework.CoefficientOfThermalExpansion.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.CoefficientOfThermalExpansion</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET CoefficientOfThermalExpansion - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds CoefficientOfThermalExpansion units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework coefficientofthermalexpansion unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\CoefficientOfThermalExpansion\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/CoefficientOfThermalExpansion/packages.config b/UnitsNet.NanoFramework/GeneratedCode/CoefficientOfThermalExpansion/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/CoefficientOfThermalExpansion/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Compressibility/Compressibility.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Compressibility/Compressibility.nfproj
deleted file mode 100644
index ebb1c5d80a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Compressibility/Compressibility.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{daf647be-be87-88b9-ee92-dece21fe0dff}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Compressibility</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Compressibility.g.cs" />
-    <Compile Include="..\Units\CompressibilityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Compressibility/UnitsNet.NanoFramework.Compressibility.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Compressibility/UnitsNet.NanoFramework.Compressibility.nuspec
deleted file mode 100644
index 2b4bcfac77..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Compressibility/UnitsNet.NanoFramework.Compressibility.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Compressibility</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Compressibility - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Compressibility units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework compressibility unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Compressibility\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Compressibility/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Compressibility/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Compressibility/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Density/Density.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Density/Density.nfproj
deleted file mode 100644
index 6504ae163a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Density/Density.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{d683a277-5892-aec2-985d-c2343725d0af}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Density</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Density.g.cs" />
-    <Compile Include="..\Units\DensityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Density/UnitsNet.NanoFramework.Density.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Density/UnitsNet.NanoFramework.Density.nuspec
deleted file mode 100644
index 7bd03fdc9b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Density/UnitsNet.NanoFramework.Density.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Density</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Density - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Density units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework density unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Density\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Density/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Density/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Density/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/DoseAreaProduct/DoseAreaProduct.nfproj b/UnitsNet.NanoFramework/GeneratedCode/DoseAreaProduct/DoseAreaProduct.nfproj
deleted file mode 100644
index a7fc062361..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/DoseAreaProduct/DoseAreaProduct.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{e074adae-f19a-6b69-67b0-b4fb425b39ce}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.DoseAreaProduct</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\DoseAreaProduct.g.cs" />
-    <Compile Include="..\Units\DoseAreaProductUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/DoseAreaProduct/UnitsNet.NanoFramework.DoseAreaProduct.nuspec b/UnitsNet.NanoFramework/GeneratedCode/DoseAreaProduct/UnitsNet.NanoFramework.DoseAreaProduct.nuspec
deleted file mode 100644
index 34d1d619bf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/DoseAreaProduct/UnitsNet.NanoFramework.DoseAreaProduct.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.DoseAreaProduct</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET DoseAreaProduct - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds DoseAreaProduct units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework doseareaproduct unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\DoseAreaProduct\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/DoseAreaProduct/packages.config b/UnitsNet.NanoFramework/GeneratedCode/DoseAreaProduct/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/DoseAreaProduct/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Duration/Duration.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Duration/Duration.nfproj
deleted file mode 100644
index 136d72670a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Duration/Duration.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{3c2ac54f-554c-518b-7c46-3b22d86d0e3b}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Duration</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Duration.g.cs" />
-    <Compile Include="..\Units\DurationUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Duration/UnitsNet.NanoFramework.Duration.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Duration/UnitsNet.NanoFramework.Duration.nuspec
deleted file mode 100644
index 5dba751301..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Duration/UnitsNet.NanoFramework.Duration.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Duration</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Duration - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Duration units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework duration unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Duration\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Duration/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Duration/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Duration/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/DynamicViscosity/DynamicViscosity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/DynamicViscosity/DynamicViscosity.nfproj
deleted file mode 100644
index 53a2b83c1a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/DynamicViscosity/DynamicViscosity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{5dde57f4-3f98-c4b7-47e5-65229faf1f0f}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.DynamicViscosity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\DynamicViscosity.g.cs" />
-    <Compile Include="..\Units\DynamicViscosityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/DynamicViscosity/UnitsNet.NanoFramework.DynamicViscosity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/DynamicViscosity/UnitsNet.NanoFramework.DynamicViscosity.nuspec
deleted file mode 100644
index 7c2c62cac3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/DynamicViscosity/UnitsNet.NanoFramework.DynamicViscosity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.DynamicViscosity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET DynamicViscosity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds DynamicViscosity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework dynamicviscosity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\DynamicViscosity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/DynamicViscosity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/DynamicViscosity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/DynamicViscosity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricAdmittance/ElectricAdmittance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricAdmittance/ElectricAdmittance.nfproj
deleted file mode 100644
index 40a40885d9..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricAdmittance/ElectricAdmittance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{2ee55c63-d077-25dd-f076-857adfe08080}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricAdmittance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricAdmittance.g.cs" />
-    <Compile Include="..\Units\ElectricAdmittanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricAdmittance/UnitsNet.NanoFramework.ElectricAdmittance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricAdmittance/UnitsNet.NanoFramework.ElectricAdmittance.nuspec
deleted file mode 100644
index 479273643c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricAdmittance/UnitsNet.NanoFramework.ElectricAdmittance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricAdmittance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricAdmittance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricAdmittance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricadmittance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricAdmittance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricAdmittance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricAdmittance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricAdmittance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentEnergy/ElectricApparentEnergy.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentEnergy/ElectricApparentEnergy.nfproj
deleted file mode 100644
index ea49fc048a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentEnergy/ElectricApparentEnergy.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{f22b7bcc-5a8d-3a02-d81c-caf6c9c44d61}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricApparentEnergy</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricApparentEnergy.g.cs" />
-    <Compile Include="..\Units\ElectricApparentEnergyUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentEnergy/UnitsNet.NanoFramework.ElectricApparentEnergy.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentEnergy/UnitsNet.NanoFramework.ElectricApparentEnergy.nuspec
deleted file mode 100644
index 48ea050094..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentEnergy/UnitsNet.NanoFramework.ElectricApparentEnergy.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricApparentEnergy</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricApparentEnergy - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricApparentEnergy units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricapparentenergy unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricApparentEnergy\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentEnergy/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentEnergy/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentEnergy/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentPower/ElectricApparentPower.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentPower/ElectricApparentPower.nfproj
deleted file mode 100644
index fef4baa953..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentPower/ElectricApparentPower.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{b7a9eb2a-4b0e-548c-2370-a33ee63b21cc}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricApparentPower</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricApparentPower.g.cs" />
-    <Compile Include="..\Units\ElectricApparentPowerUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentPower/UnitsNet.NanoFramework.ElectricApparentPower.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentPower/UnitsNet.NanoFramework.ElectricApparentPower.nuspec
deleted file mode 100644
index 9c32b2704a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentPower/UnitsNet.NanoFramework.ElectricApparentPower.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricApparentPower</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricApparentPower - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricApparentPower units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricapparentpower unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricApparentPower\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentPower/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentPower/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricApparentPower/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCapacitance/ElectricCapacitance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricCapacitance/ElectricCapacitance.nfproj
deleted file mode 100644
index 61417e0504..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCapacitance/ElectricCapacitance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{10e8cf6b-7fec-911f-770d-e3641296ac89}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricCapacitance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricCapacitance.g.cs" />
-    <Compile Include="..\Units\ElectricCapacitanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCapacitance/UnitsNet.NanoFramework.ElectricCapacitance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricCapacitance/UnitsNet.NanoFramework.ElectricCapacitance.nuspec
deleted file mode 100644
index 4da82bf776..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCapacitance/UnitsNet.NanoFramework.ElectricCapacitance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricCapacitance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricCapacitance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricCapacitance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electriccapacitance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricCapacitance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCapacitance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricCapacitance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCapacitance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCharge/ElectricCharge.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricCharge/ElectricCharge.nfproj
deleted file mode 100644
index bd0c8832b0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCharge/ElectricCharge.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{f4286cfc-484b-8466-8efa-1111696babb9}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricCharge</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricCharge.g.cs" />
-    <Compile Include="..\Units\ElectricChargeUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCharge/UnitsNet.NanoFramework.ElectricCharge.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricCharge/UnitsNet.NanoFramework.ElectricCharge.nuspec
deleted file mode 100644
index e0d66da5f1..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCharge/UnitsNet.NanoFramework.ElectricCharge.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricCharge</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricCharge - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricCharge units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electriccharge unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricCharge\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCharge/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricCharge/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCharge/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricChargeDensity/ElectricChargeDensity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricChargeDensity/ElectricChargeDensity.nfproj
deleted file mode 100644
index 71ce0c440a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricChargeDensity/ElectricChargeDensity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{b1567c85-ad77-c283-9165-777ad0e9a2eb}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricChargeDensity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricChargeDensity.g.cs" />
-    <Compile Include="..\Units\ElectricChargeDensityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricChargeDensity/UnitsNet.NanoFramework.ElectricChargeDensity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricChargeDensity/UnitsNet.NanoFramework.ElectricChargeDensity.nuspec
deleted file mode 100644
index ff3ad6713e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricChargeDensity/UnitsNet.NanoFramework.ElectricChargeDensity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricChargeDensity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricChargeDensity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricChargeDensity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricchargedensity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricChargeDensity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricChargeDensity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricChargeDensity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricChargeDensity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductance/ElectricConductance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricConductance/ElectricConductance.nfproj
deleted file mode 100644
index cbfbd2043d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductance/ElectricConductance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{fcd3dfb2-9ee2-ad22-0e1f-4cddd575792a}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricConductance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricConductance.g.cs" />
-    <Compile Include="..\Units\ElectricConductanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductance/UnitsNet.NanoFramework.ElectricConductance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricConductance/UnitsNet.NanoFramework.ElectricConductance.nuspec
deleted file mode 100644
index 9d2136ac79..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductance/UnitsNet.NanoFramework.ElectricConductance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricConductance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricConductance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricConductance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricconductance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricConductance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricConductance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductivity/ElectricConductivity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricConductivity/ElectricConductivity.nfproj
deleted file mode 100644
index 6587be2ba4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductivity/ElectricConductivity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{f420eccc-b12d-72e4-2ad2-f93054eeec30}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricConductivity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricConductivity.g.cs" />
-    <Compile Include="..\Units\ElectricConductivityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductivity/UnitsNet.NanoFramework.ElectricConductivity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricConductivity/UnitsNet.NanoFramework.ElectricConductivity.nuspec
deleted file mode 100644
index 90de95922b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductivity/UnitsNet.NanoFramework.ElectricConductivity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricConductivity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricConductivity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricConductivity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricconductivity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricConductivity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductivity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricConductivity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricConductivity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrent/ElectricCurrent.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrent/ElectricCurrent.nfproj
deleted file mode 100644
index d1f437921d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrent/ElectricCurrent.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{55160a70-69b2-4144-b974-b64d78bd50e0}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricCurrent</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricCurrent.g.cs" />
-    <Compile Include="..\Units\ElectricCurrentUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrent/UnitsNet.NanoFramework.ElectricCurrent.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrent/UnitsNet.NanoFramework.ElectricCurrent.nuspec
deleted file mode 100644
index f1dd30ef96..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrent/UnitsNet.NanoFramework.ElectricCurrent.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricCurrent</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricCurrent - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricCurrent units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electriccurrent unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricCurrent\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrent/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrent/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrent/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentDensity/ElectricCurrentDensity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentDensity/ElectricCurrentDensity.nfproj
deleted file mode 100644
index 6a9d434df8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentDensity/ElectricCurrentDensity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{8beda85e-3d20-5926-c060-f92913f1192e}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricCurrentDensity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricCurrentDensity.g.cs" />
-    <Compile Include="..\Units\ElectricCurrentDensityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentDensity/UnitsNet.NanoFramework.ElectricCurrentDensity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentDensity/UnitsNet.NanoFramework.ElectricCurrentDensity.nuspec
deleted file mode 100644
index fc7d8c8aeb..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentDensity/UnitsNet.NanoFramework.ElectricCurrentDensity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricCurrentDensity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricCurrentDensity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricCurrentDensity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electriccurrentdensity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricCurrentDensity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentDensity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentDensity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentDensity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentGradient/ElectricCurrentGradient.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentGradient/ElectricCurrentGradient.nfproj
deleted file mode 100644
index eb6cce87c4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentGradient/ElectricCurrentGradient.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{29df066c-c160-cd60-b10f-23a0c3bb8457}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricCurrentGradient</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricCurrentGradient.g.cs" />
-    <Compile Include="..\Units\ElectricCurrentGradientUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentGradient/UnitsNet.NanoFramework.ElectricCurrentGradient.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentGradient/UnitsNet.NanoFramework.ElectricCurrentGradient.nuspec
deleted file mode 100644
index 2b1196bfe1..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentGradient/UnitsNet.NanoFramework.ElectricCurrentGradient.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricCurrentGradient</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricCurrentGradient - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricCurrentGradient units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electriccurrentgradient unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricCurrentGradient\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentGradient/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentGradient/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricCurrentGradient/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricField/ElectricField.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricField/ElectricField.nfproj
deleted file mode 100644
index 1c29c5ce03..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricField/ElectricField.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{635581a6-f954-d0e4-9c68-02c1725e49d2}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricField</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricField.g.cs" />
-    <Compile Include="..\Units\ElectricFieldUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricField/UnitsNet.NanoFramework.ElectricField.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricField/UnitsNet.NanoFramework.ElectricField.nuspec
deleted file mode 100644
index 0a6fab1b8b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricField/UnitsNet.NanoFramework.ElectricField.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricField</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricField - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricField units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricfield unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricField\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricField/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricField/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricField/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricImpedance/ElectricImpedance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricImpedance/ElectricImpedance.nfproj
deleted file mode 100644
index e2416e308f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricImpedance/ElectricImpedance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{23a79010-5c1a-9120-0992-a69c8dd80015}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricImpedance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricImpedance.g.cs" />
-    <Compile Include="..\Units\ElectricImpedanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricImpedance/UnitsNet.NanoFramework.ElectricImpedance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricImpedance/UnitsNet.NanoFramework.ElectricImpedance.nuspec
deleted file mode 100644
index fd2c7df483..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricImpedance/UnitsNet.NanoFramework.ElectricImpedance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricImpedance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricImpedance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricImpedance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricimpedance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricImpedance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricImpedance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricImpedance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricImpedance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricInductance/ElectricInductance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricInductance/ElectricInductance.nfproj
deleted file mode 100644
index c6619bfc35..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricInductance/ElectricInductance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{76bf8a97-e573-a5b5-286f-04ca7e00f8e9}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricInductance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricInductance.g.cs" />
-    <Compile Include="..\Units\ElectricInductanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricInductance/UnitsNet.NanoFramework.ElectricInductance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricInductance/UnitsNet.NanoFramework.ElectricInductance.nuspec
deleted file mode 100644
index 0179c50409..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricInductance/UnitsNet.NanoFramework.ElectricInductance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricInductance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricInductance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricInductance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricinductance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricInductance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricInductance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricInductance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricInductance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotential/ElectricPotential.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricPotential/ElectricPotential.nfproj
deleted file mode 100644
index 5589dc359d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotential/ElectricPotential.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{66c94dc2-e546-9737-a45b-4bc60fe0e536}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricPotential</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricPotential.g.cs" />
-    <Compile Include="..\Units\ElectricPotentialUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotential/UnitsNet.NanoFramework.ElectricPotential.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricPotential/UnitsNet.NanoFramework.ElectricPotential.nuspec
deleted file mode 100644
index b9787881d9..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotential/UnitsNet.NanoFramework.ElectricPotential.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricPotential</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricPotential - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricPotential units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricpotential unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricPotential\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotential/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricPotential/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotential/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotentialChangeRate/ElectricPotentialChangeRate.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricPotentialChangeRate/ElectricPotentialChangeRate.nfproj
deleted file mode 100644
index 7cf75a41be..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotentialChangeRate/ElectricPotentialChangeRate.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{679517ca-9d0b-0ec2-35ae-95230281cfba}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricPotentialChangeRate</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricPotentialChangeRate.g.cs" />
-    <Compile Include="..\Units\ElectricPotentialChangeRateUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotentialChangeRate/UnitsNet.NanoFramework.ElectricPotentialChangeRate.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricPotentialChangeRate/UnitsNet.NanoFramework.ElectricPotentialChangeRate.nuspec
deleted file mode 100644
index 5c5dd4b3f8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotentialChangeRate/UnitsNet.NanoFramework.ElectricPotentialChangeRate.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricPotentialChangeRate</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricPotentialChangeRate - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricPotentialChangeRate units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricpotentialchangerate unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricPotentialChangeRate\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotentialChangeRate/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricPotentialChangeRate/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricPotentialChangeRate/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactance/ElectricReactance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricReactance/ElectricReactance.nfproj
deleted file mode 100644
index 137639125f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactance/ElectricReactance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{e3d3c1e3-aaa3-5d40-472e-ae837457cf73}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricReactance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricReactance.g.cs" />
-    <Compile Include="..\Units\ElectricReactanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactance/UnitsNet.NanoFramework.ElectricReactance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricReactance/UnitsNet.NanoFramework.ElectricReactance.nuspec
deleted file mode 100644
index 7fea99f11f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactance/UnitsNet.NanoFramework.ElectricReactance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricReactance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricReactance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricReactance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricreactance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricReactance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricReactance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactiveEnergy/ElectricReactiveEnergy.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricReactiveEnergy/ElectricReactiveEnergy.nfproj
deleted file mode 100644
index c159133d3b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactiveEnergy/ElectricReactiveEnergy.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{9f892c4e-26c2-1420-a73c-08138c8f6ca2}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricReactiveEnergy</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricReactiveEnergy.g.cs" />
-    <Compile Include="..\Units\ElectricReactiveEnergyUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactiveEnergy/UnitsNet.NanoFramework.ElectricReactiveEnergy.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricReactiveEnergy/UnitsNet.NanoFramework.ElectricReactiveEnergy.nuspec
deleted file mode 100644
index 15f4e17249..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactiveEnergy/UnitsNet.NanoFramework.ElectricReactiveEnergy.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricReactiveEnergy</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricReactiveEnergy - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricReactiveEnergy units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricreactiveenergy unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricReactiveEnergy\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactiveEnergy/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricReactiveEnergy/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactiveEnergy/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactivePower/ElectricReactivePower.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricReactivePower/ElectricReactivePower.nfproj
deleted file mode 100644
index f8385b3418..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactivePower/ElectricReactivePower.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{6e5b2ba2-7712-0f4f-d2bf-2624bb877dbe}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricReactivePower</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricReactivePower.g.cs" />
-    <Compile Include="..\Units\ElectricReactivePowerUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactivePower/UnitsNet.NanoFramework.ElectricReactivePower.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricReactivePower/UnitsNet.NanoFramework.ElectricReactivePower.nuspec
deleted file mode 100644
index f326d52c70..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactivePower/UnitsNet.NanoFramework.ElectricReactivePower.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricReactivePower</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricReactivePower - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricReactivePower units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricreactivepower unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricReactivePower\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactivePower/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricReactivePower/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricReactivePower/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistance/ElectricResistance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricResistance/ElectricResistance.nfproj
deleted file mode 100644
index 76f6a402bb..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistance/ElectricResistance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{78d59e90-3339-54d6-3803-f68623b72eff}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricResistance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricResistance.g.cs" />
-    <Compile Include="..\Units\ElectricResistanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistance/UnitsNet.NanoFramework.ElectricResistance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricResistance/UnitsNet.NanoFramework.ElectricResistance.nuspec
deleted file mode 100644
index 66cd833352..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistance/UnitsNet.NanoFramework.ElectricResistance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricResistance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricResistance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricResistance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricresistance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricResistance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricResistance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistivity/ElectricResistivity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricResistivity/ElectricResistivity.nfproj
deleted file mode 100644
index cd32dec60c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistivity/ElectricResistivity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{6a4a0f45-c2b4-6be4-e44a-e78d3282359f}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricResistivity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricResistivity.g.cs" />
-    <Compile Include="..\Units\ElectricResistivityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistivity/UnitsNet.NanoFramework.ElectricResistivity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricResistivity/UnitsNet.NanoFramework.ElectricResistivity.nuspec
deleted file mode 100644
index 832ac0689d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistivity/UnitsNet.NanoFramework.ElectricResistivity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricResistivity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricResistivity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricResistivity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricresistivity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricResistivity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistivity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricResistivity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricResistivity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricSurfaceChargeDensity/ElectricSurfaceChargeDensity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricSurfaceChargeDensity/ElectricSurfaceChargeDensity.nfproj
deleted file mode 100644
index 3c92cdc31d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricSurfaceChargeDensity/ElectricSurfaceChargeDensity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{006e161d-aae1-2dd1-5b94-ebd45d31f50a}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricSurfaceChargeDensity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricSurfaceChargeDensity.g.cs" />
-    <Compile Include="..\Units\ElectricSurfaceChargeDensityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricSurfaceChargeDensity/UnitsNet.NanoFramework.ElectricSurfaceChargeDensity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricSurfaceChargeDensity/UnitsNet.NanoFramework.ElectricSurfaceChargeDensity.nuspec
deleted file mode 100644
index 8c5f699bde..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricSurfaceChargeDensity/UnitsNet.NanoFramework.ElectricSurfaceChargeDensity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricSurfaceChargeDensity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricSurfaceChargeDensity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricSurfaceChargeDensity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricsurfacechargedensity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricSurfaceChargeDensity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricSurfaceChargeDensity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricSurfaceChargeDensity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricSurfaceChargeDensity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricSusceptance/ElectricSusceptance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ElectricSusceptance/ElectricSusceptance.nfproj
deleted file mode 100644
index 09618e3e01..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricSusceptance/ElectricSusceptance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{544c006b-f7de-21a9-a1b4-8df710e184c8}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ElectricSusceptance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ElectricSusceptance.g.cs" />
-    <Compile Include="..\Units\ElectricSusceptanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricSusceptance/UnitsNet.NanoFramework.ElectricSusceptance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ElectricSusceptance/UnitsNet.NanoFramework.ElectricSusceptance.nuspec
deleted file mode 100644
index fdc65ddcf1..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricSusceptance/UnitsNet.NanoFramework.ElectricSusceptance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ElectricSusceptance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ElectricSusceptance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ElectricSusceptance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework electricsusceptance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ElectricSusceptance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ElectricSusceptance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ElectricSusceptance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ElectricSusceptance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Energy/Energy.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Energy/Energy.nfproj
deleted file mode 100644
index e69dea0a99..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Energy/Energy.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{f7d3fcf2-cadc-19dd-4c4c-5a54a5102c95}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Energy</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Energy.g.cs" />
-    <Compile Include="..\Units\EnergyUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Energy/UnitsNet.NanoFramework.Energy.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Energy/UnitsNet.NanoFramework.Energy.nuspec
deleted file mode 100644
index 975243134e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Energy/UnitsNet.NanoFramework.Energy.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Energy</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Energy - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Energy units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework energy unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Energy\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Energy/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Energy/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Energy/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/EnergyDensity/EnergyDensity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/EnergyDensity/EnergyDensity.nfproj
deleted file mode 100644
index b3cd35bc0f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/EnergyDensity/EnergyDensity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{c5025916-5039-97c2-b450-af1420f5fb08}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.EnergyDensity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\EnergyDensity.g.cs" />
-    <Compile Include="..\Units\EnergyDensityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/EnergyDensity/UnitsNet.NanoFramework.EnergyDensity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/EnergyDensity/UnitsNet.NanoFramework.EnergyDensity.nuspec
deleted file mode 100644
index f7d9aaa2d3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/EnergyDensity/UnitsNet.NanoFramework.EnergyDensity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.EnergyDensity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET EnergyDensity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds EnergyDensity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework energydensity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\EnergyDensity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/EnergyDensity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/EnergyDensity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/EnergyDensity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Entropy/Entropy.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Entropy/Entropy.nfproj
deleted file mode 100644
index 56edc687f8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Entropy/Entropy.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{816884bb-a5f6-5c07-967b-bb8f21d724b7}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Entropy</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Entropy.g.cs" />
-    <Compile Include="..\Units\EntropyUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Entropy/UnitsNet.NanoFramework.Entropy.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Entropy/UnitsNet.NanoFramework.Entropy.nuspec
deleted file mode 100644
index 139de8f0c3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Entropy/UnitsNet.NanoFramework.Entropy.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Entropy</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Entropy - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Entropy units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework entropy unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Entropy\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Entropy/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Entropy/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Entropy/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/FluidResistance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/FluidResistance.nfproj
deleted file mode 100644
index 6fae96c9b0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/FluidResistance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{d19281dc-72f6-62a9-18d5-b845d6fd8d99}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.FluidResistance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\FluidResistance.g.cs" />
-    <Compile Include="..\Units\FluidResistanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/UnitsNet.NanoFramework.FluidResistance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/UnitsNet.NanoFramework.FluidResistance.nuspec
deleted file mode 100644
index 3ef997b15a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/UnitsNet.NanoFramework.FluidResistance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.FluidResistance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET FluidResistance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds FluidResistance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework fluidresistance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\FluidResistance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Force/Force.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Force/Force.nfproj
deleted file mode 100644
index c946bc8867..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Force/Force.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{5517dacf-b1ff-6515-e5b6-b5081f92f407}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Force</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Force.g.cs" />
-    <Compile Include="..\Units\ForceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Force/UnitsNet.NanoFramework.Force.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Force/UnitsNet.NanoFramework.Force.nuspec
deleted file mode 100644
index f6e61e2283..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Force/UnitsNet.NanoFramework.Force.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Force</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Force - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Force units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework force unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Force\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Force/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Force/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Force/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ForceChangeRate/ForceChangeRate.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ForceChangeRate/ForceChangeRate.nfproj
deleted file mode 100644
index 77415e3855..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ForceChangeRate/ForceChangeRate.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{97ad732d-4ce5-2027-aabc-844002d29c23}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ForceChangeRate</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ForceChangeRate.g.cs" />
-    <Compile Include="..\Units\ForceChangeRateUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ForceChangeRate/UnitsNet.NanoFramework.ForceChangeRate.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ForceChangeRate/UnitsNet.NanoFramework.ForceChangeRate.nuspec
deleted file mode 100644
index 34b35116c4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ForceChangeRate/UnitsNet.NanoFramework.ForceChangeRate.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ForceChangeRate</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ForceChangeRate - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ForceChangeRate units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework forcechangerate unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ForceChangeRate\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ForceChangeRate/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ForceChangeRate/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ForceChangeRate/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ForcePerLength/ForcePerLength.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ForcePerLength/ForcePerLength.nfproj
deleted file mode 100644
index cfff78dff5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ForcePerLength/ForcePerLength.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{6b975d30-c5dd-f1fd-9d0c-4d56ecdf9b25}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ForcePerLength</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ForcePerLength.g.cs" />
-    <Compile Include="..\Units\ForcePerLengthUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ForcePerLength/UnitsNet.NanoFramework.ForcePerLength.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ForcePerLength/UnitsNet.NanoFramework.ForcePerLength.nuspec
deleted file mode 100644
index c2f0ff0c08..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ForcePerLength/UnitsNet.NanoFramework.ForcePerLength.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ForcePerLength</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ForcePerLength - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ForcePerLength units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework forceperlength unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ForcePerLength\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ForcePerLength/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ForcePerLength/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ForcePerLength/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Frequency/Frequency.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Frequency/Frequency.nfproj
deleted file mode 100644
index 7bcf739711..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Frequency/Frequency.nfproj
+++ /dev/null
@@ -1,47 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{8d66b616-3198-b8a1-d2d0-03496db6a62b}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Frequency</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Frequency.g.cs" />
-    <Compile Include="..\Units\FrequencyUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-    <Reference Include="System.Math, Version=1.5.43.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.System.Math.1.5.43\lib\System.Math.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Frequency/UnitsNet.NanoFramework.Frequency.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Frequency/UnitsNet.NanoFramework.Frequency.nuspec
deleted file mode 100644
index 4e1191a636..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Frequency/UnitsNet.NanoFramework.Frequency.nuspec
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Frequency</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Frequency - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Frequency units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework frequency unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-      <dependency id="nanoFramework.System.Math" version="1.5.43" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Frequency\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Frequency/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Frequency/packages.config
deleted file mode 100644
index ac11548cd6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Frequency/packages.config
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-  <package id="nanoFramework.System.Math" version="1.5.43" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/FuelEfficiency/FuelEfficiency.nfproj b/UnitsNet.NanoFramework/GeneratedCode/FuelEfficiency/FuelEfficiency.nfproj
deleted file mode 100644
index c40c99e01c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/FuelEfficiency/FuelEfficiency.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{6e68ff9b-3947-d706-3ad7-f9237a67c874}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.FuelEfficiency</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\FuelEfficiency.g.cs" />
-    <Compile Include="..\Units\FuelEfficiencyUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/FuelEfficiency/UnitsNet.NanoFramework.FuelEfficiency.nuspec b/UnitsNet.NanoFramework/GeneratedCode/FuelEfficiency/UnitsNet.NanoFramework.FuelEfficiency.nuspec
deleted file mode 100644
index f1775076bb..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/FuelEfficiency/UnitsNet.NanoFramework.FuelEfficiency.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.FuelEfficiency</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET FuelEfficiency - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds FuelEfficiency units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework fuelefficiency unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\FuelEfficiency\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/FuelEfficiency/packages.config b/UnitsNet.NanoFramework/GeneratedCode/FuelEfficiency/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/FuelEfficiency/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/HeatFlux/HeatFlux.nfproj b/UnitsNet.NanoFramework/GeneratedCode/HeatFlux/HeatFlux.nfproj
deleted file mode 100644
index a0bedc7a33..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/HeatFlux/HeatFlux.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{2b132458-96e5-72bf-673f-dda4a7fd514b}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.HeatFlux</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\HeatFlux.g.cs" />
-    <Compile Include="..\Units\HeatFluxUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/HeatFlux/UnitsNet.NanoFramework.HeatFlux.nuspec b/UnitsNet.NanoFramework/GeneratedCode/HeatFlux/UnitsNet.NanoFramework.HeatFlux.nuspec
deleted file mode 100644
index 7741a47c62..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/HeatFlux/UnitsNet.NanoFramework.HeatFlux.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.HeatFlux</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET HeatFlux - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds HeatFlux units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework heatflux unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\HeatFlux\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/HeatFlux/packages.config b/UnitsNet.NanoFramework/GeneratedCode/HeatFlux/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/HeatFlux/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/HeatTransferCoefficient/HeatTransferCoefficient.nfproj b/UnitsNet.NanoFramework/GeneratedCode/HeatTransferCoefficient/HeatTransferCoefficient.nfproj
deleted file mode 100644
index 845c91293c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/HeatTransferCoefficient/HeatTransferCoefficient.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{3ede821e-ee76-967e-94d7-5b1d1239c8dd}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.HeatTransferCoefficient</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\HeatTransferCoefficient.g.cs" />
-    <Compile Include="..\Units\HeatTransferCoefficientUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/HeatTransferCoefficient/UnitsNet.NanoFramework.HeatTransferCoefficient.nuspec b/UnitsNet.NanoFramework/GeneratedCode/HeatTransferCoefficient/UnitsNet.NanoFramework.HeatTransferCoefficient.nuspec
deleted file mode 100644
index 969a889436..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/HeatTransferCoefficient/UnitsNet.NanoFramework.HeatTransferCoefficient.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.HeatTransferCoefficient</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET HeatTransferCoefficient - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds HeatTransferCoefficient units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework heattransfercoefficient unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\HeatTransferCoefficient\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/HeatTransferCoefficient/packages.config b/UnitsNet.NanoFramework/GeneratedCode/HeatTransferCoefficient/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/HeatTransferCoefficient/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Illuminance/Illuminance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Illuminance/Illuminance.nfproj
deleted file mode 100644
index f0a6385fdd..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Illuminance/Illuminance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{d846582b-8ae3-9779-01ea-7210b5330cfd}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Illuminance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Illuminance.g.cs" />
-    <Compile Include="..\Units\IlluminanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Illuminance/UnitsNet.NanoFramework.Illuminance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Illuminance/UnitsNet.NanoFramework.Illuminance.nuspec
deleted file mode 100644
index fb5e461167..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Illuminance/UnitsNet.NanoFramework.Illuminance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Illuminance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Illuminance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Illuminance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework illuminance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Illuminance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Illuminance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Illuminance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Illuminance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Impulse/Impulse.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Impulse/Impulse.nfproj
deleted file mode 100644
index d07e0a0535..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Impulse/Impulse.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{d8d4e4e8-1dc8-0170-5e3c-18610853bd87}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Impulse</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Impulse.g.cs" />
-    <Compile Include="..\Units\ImpulseUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Impulse/UnitsNet.NanoFramework.Impulse.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Impulse/UnitsNet.NanoFramework.Impulse.nuspec
deleted file mode 100644
index 2587bf34f6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Impulse/UnitsNet.NanoFramework.Impulse.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Impulse</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Impulse - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Impulse units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework impulse unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Impulse\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Impulse/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Impulse/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Impulse/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Information/Information.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Information/Information.nfproj
deleted file mode 100644
index 78af2c9fed..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Information/Information.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{12bab01c-845f-82c9-b00b-a3639cdfb2ce}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Information</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Information.g.cs" />
-    <Compile Include="..\Units\InformationUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Information/UnitsNet.NanoFramework.Information.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Information/UnitsNet.NanoFramework.Information.nuspec
deleted file mode 100644
index 20094bcc3b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Information/UnitsNet.NanoFramework.Information.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Information</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Information - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Information units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework information unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Information\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Information/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Information/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Information/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Irradiance/Irradiance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Irradiance/Irradiance.nfproj
deleted file mode 100644
index ce02ea1bbf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Irradiance/Irradiance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{5f9c09c7-9e32-8927-7a5d-90001ceffc69}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Irradiance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Irradiance.g.cs" />
-    <Compile Include="..\Units\IrradianceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Irradiance/UnitsNet.NanoFramework.Irradiance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Irradiance/UnitsNet.NanoFramework.Irradiance.nuspec
deleted file mode 100644
index dff4ecf0c0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Irradiance/UnitsNet.NanoFramework.Irradiance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Irradiance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Irradiance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Irradiance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework irradiance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Irradiance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Irradiance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Irradiance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Irradiance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Irradiation/Irradiation.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Irradiation/Irradiation.nfproj
deleted file mode 100644
index 117c66f673..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Irradiation/Irradiation.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{b545726f-7a83-3c78-2b55-6a709c5a6d00}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Irradiation</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Irradiation.g.cs" />
-    <Compile Include="..\Units\IrradiationUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Irradiation/UnitsNet.NanoFramework.Irradiation.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Irradiation/UnitsNet.NanoFramework.Irradiation.nuspec
deleted file mode 100644
index f37f0e8cb5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Irradiation/UnitsNet.NanoFramework.Irradiation.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Irradiation</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Irradiation - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Irradiation units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework irradiation unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Irradiation\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Irradiation/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Irradiation/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Irradiation/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Jerk/Jerk.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Jerk/Jerk.nfproj
deleted file mode 100644
index ea42f6f028..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Jerk/Jerk.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{8540cfb1-fe4a-dcc3-a70e-840262803cfc}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Jerk</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Jerk.g.cs" />
-    <Compile Include="..\Units\JerkUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Jerk/UnitsNet.NanoFramework.Jerk.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Jerk/UnitsNet.NanoFramework.Jerk.nuspec
deleted file mode 100644
index 25cdda13da..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Jerk/UnitsNet.NanoFramework.Jerk.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Jerk</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Jerk - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Jerk units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework jerk unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Jerk\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Jerk/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Jerk/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Jerk/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/KinematicViscosity/KinematicViscosity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/KinematicViscosity/KinematicViscosity.nfproj
deleted file mode 100644
index 35fa23bf26..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/KinematicViscosity/KinematicViscosity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{733e533d-9ff2-4c72-3da9-200f758dc6e3}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.KinematicViscosity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\KinematicViscosity.g.cs" />
-    <Compile Include="..\Units\KinematicViscosityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/KinematicViscosity/UnitsNet.NanoFramework.KinematicViscosity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/KinematicViscosity/UnitsNet.NanoFramework.KinematicViscosity.nuspec
deleted file mode 100644
index d93a1dc4a7..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/KinematicViscosity/UnitsNet.NanoFramework.KinematicViscosity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.KinematicViscosity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET KinematicViscosity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds KinematicViscosity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework kinematicviscosity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\KinematicViscosity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/KinematicViscosity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/KinematicViscosity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/KinematicViscosity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LeakRate/LeakRate.nfproj b/UnitsNet.NanoFramework/GeneratedCode/LeakRate/LeakRate.nfproj
deleted file mode 100644
index 08304711aa..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LeakRate/LeakRate.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{ff162d83-3229-2000-71ed-08999160dca3}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.LeakRate</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\LeakRate.g.cs" />
-    <Compile Include="..\Units\LeakRateUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LeakRate/UnitsNet.NanoFramework.LeakRate.nuspec b/UnitsNet.NanoFramework/GeneratedCode/LeakRate/UnitsNet.NanoFramework.LeakRate.nuspec
deleted file mode 100644
index 14f6ac3dfd..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LeakRate/UnitsNet.NanoFramework.LeakRate.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.LeakRate</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET LeakRate - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds LeakRate units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework leakrate unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\LeakRate\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LeakRate/packages.config b/UnitsNet.NanoFramework/GeneratedCode/LeakRate/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LeakRate/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Length/Length.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Length/Length.nfproj
deleted file mode 100644
index 6c8cc1f31e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Length/Length.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{0556c9ad-b3a1-730c-959f-baf21e60f972}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Length</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Length.g.cs" />
-    <Compile Include="..\Units\LengthUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Length/UnitsNet.NanoFramework.Length.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Length/UnitsNet.NanoFramework.Length.nuspec
deleted file mode 100644
index a476fcd6e3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Length/UnitsNet.NanoFramework.Length.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Length</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Length - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Length units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework length unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Length\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Length/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Length/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Length/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Level/Level.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Level/Level.nfproj
deleted file mode 100644
index 8dde41ee0e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Level/Level.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{5c300917-a99f-d166-4f56-f0da3c3614bb}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Level</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Level.g.cs" />
-    <Compile Include="..\Units\LevelUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Level/UnitsNet.NanoFramework.Level.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Level/UnitsNet.NanoFramework.Level.nuspec
deleted file mode 100644
index 09ebf33d17..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Level/UnitsNet.NanoFramework.Level.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Level</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Level - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Level units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework level unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Level\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Level/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Level/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Level/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LinearDensity/LinearDensity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/LinearDensity/LinearDensity.nfproj
deleted file mode 100644
index ee9ffc2cf3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LinearDensity/LinearDensity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{ab414094-9582-3357-d0e9-20b153a1b54c}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.LinearDensity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\LinearDensity.g.cs" />
-    <Compile Include="..\Units\LinearDensityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LinearDensity/UnitsNet.NanoFramework.LinearDensity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/LinearDensity/UnitsNet.NanoFramework.LinearDensity.nuspec
deleted file mode 100644
index 3405e3d049..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LinearDensity/UnitsNet.NanoFramework.LinearDensity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.LinearDensity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET LinearDensity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds LinearDensity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework lineardensity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\LinearDensity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LinearDensity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/LinearDensity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LinearDensity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LinearPowerDensity/LinearPowerDensity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/LinearPowerDensity/LinearPowerDensity.nfproj
deleted file mode 100644
index 78306a5cd9..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LinearPowerDensity/LinearPowerDensity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{8823a9ee-673a-e7d4-3c0a-bae61a262388}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.LinearPowerDensity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\LinearPowerDensity.g.cs" />
-    <Compile Include="..\Units\LinearPowerDensityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LinearPowerDensity/UnitsNet.NanoFramework.LinearPowerDensity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/LinearPowerDensity/UnitsNet.NanoFramework.LinearPowerDensity.nuspec
deleted file mode 100644
index 8f5a29c692..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LinearPowerDensity/UnitsNet.NanoFramework.LinearPowerDensity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.LinearPowerDensity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET LinearPowerDensity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds LinearPowerDensity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework linearpowerdensity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\LinearPowerDensity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LinearPowerDensity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/LinearPowerDensity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LinearPowerDensity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Luminance/Luminance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Luminance/Luminance.nfproj
deleted file mode 100644
index 8c9e3eb890..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Luminance/Luminance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{cbded274-6b9b-a113-d56f-00b38006cc84}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Luminance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Luminance.g.cs" />
-    <Compile Include="..\Units\LuminanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Luminance/UnitsNet.NanoFramework.Luminance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Luminance/UnitsNet.NanoFramework.Luminance.nuspec
deleted file mode 100644
index f8056b97fe..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Luminance/UnitsNet.NanoFramework.Luminance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Luminance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Luminance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Luminance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework luminance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Luminance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Luminance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Luminance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Luminance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Luminosity/Luminosity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Luminosity/Luminosity.nfproj
deleted file mode 100644
index bb88ca9e48..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Luminosity/Luminosity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{fe30ed04-094f-5005-b0aa-1b3623db60b2}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Luminosity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Luminosity.g.cs" />
-    <Compile Include="..\Units\LuminosityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Luminosity/UnitsNet.NanoFramework.Luminosity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Luminosity/UnitsNet.NanoFramework.Luminosity.nuspec
deleted file mode 100644
index 8057f8b4c4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Luminosity/UnitsNet.NanoFramework.Luminosity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Luminosity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Luminosity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Luminosity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework luminosity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Luminosity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Luminosity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Luminosity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Luminosity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LuminousFlux/LuminousFlux.nfproj b/UnitsNet.NanoFramework/GeneratedCode/LuminousFlux/LuminousFlux.nfproj
deleted file mode 100644
index 09471e380f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LuminousFlux/LuminousFlux.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{a38e4da2-f05f-aa6f-82f1-56cd2e062d96}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.LuminousFlux</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\LuminousFlux.g.cs" />
-    <Compile Include="..\Units\LuminousFluxUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LuminousFlux/UnitsNet.NanoFramework.LuminousFlux.nuspec b/UnitsNet.NanoFramework/GeneratedCode/LuminousFlux/UnitsNet.NanoFramework.LuminousFlux.nuspec
deleted file mode 100644
index 1fa68db612..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LuminousFlux/UnitsNet.NanoFramework.LuminousFlux.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.LuminousFlux</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET LuminousFlux - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds LuminousFlux units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework luminousflux unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\LuminousFlux\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LuminousFlux/packages.config b/UnitsNet.NanoFramework/GeneratedCode/LuminousFlux/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LuminousFlux/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LuminousIntensity/LuminousIntensity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/LuminousIntensity/LuminousIntensity.nfproj
deleted file mode 100644
index c154d235b2..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LuminousIntensity/LuminousIntensity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{733f9598-101b-936b-b081-2805dd793091}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.LuminousIntensity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\LuminousIntensity.g.cs" />
-    <Compile Include="..\Units\LuminousIntensityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LuminousIntensity/UnitsNet.NanoFramework.LuminousIntensity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/LuminousIntensity/UnitsNet.NanoFramework.LuminousIntensity.nuspec
deleted file mode 100644
index f1ccd5e7a5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LuminousIntensity/UnitsNet.NanoFramework.LuminousIntensity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.LuminousIntensity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET LuminousIntensity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds LuminousIntensity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework luminousintensity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\LuminousIntensity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/LuminousIntensity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/LuminousIntensity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/LuminousIntensity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MagneticField/MagneticField.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MagneticField/MagneticField.nfproj
deleted file mode 100644
index afa5742359..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MagneticField/MagneticField.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{809c4afa-d014-471b-518b-4fd01cb7c808}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MagneticField</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MagneticField.g.cs" />
-    <Compile Include="..\Units\MagneticFieldUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MagneticField/UnitsNet.NanoFramework.MagneticField.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MagneticField/UnitsNet.NanoFramework.MagneticField.nuspec
deleted file mode 100644
index cfbb4fccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MagneticField/UnitsNet.NanoFramework.MagneticField.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MagneticField</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MagneticField - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MagneticField units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework magneticfield unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MagneticField\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MagneticField/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MagneticField/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MagneticField/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MagneticFlux/MagneticFlux.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MagneticFlux/MagneticFlux.nfproj
deleted file mode 100644
index df2191383d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MagneticFlux/MagneticFlux.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{f0c5342b-fb95-48a4-029f-7aa631ce06f1}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MagneticFlux</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MagneticFlux.g.cs" />
-    <Compile Include="..\Units\MagneticFluxUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MagneticFlux/UnitsNet.NanoFramework.MagneticFlux.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MagneticFlux/UnitsNet.NanoFramework.MagneticFlux.nuspec
deleted file mode 100644
index 4efcb0c206..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MagneticFlux/UnitsNet.NanoFramework.MagneticFlux.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MagneticFlux</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MagneticFlux - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MagneticFlux units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework magneticflux unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MagneticFlux\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MagneticFlux/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MagneticFlux/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MagneticFlux/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Magnetization/Magnetization.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Magnetization/Magnetization.nfproj
deleted file mode 100644
index 8d43ca4a84..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Magnetization/Magnetization.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{3ea3301e-d3de-6979-f1d7-58352998951c}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Magnetization</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Magnetization.g.cs" />
-    <Compile Include="..\Units\MagnetizationUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Magnetization/UnitsNet.NanoFramework.Magnetization.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Magnetization/UnitsNet.NanoFramework.Magnetization.nuspec
deleted file mode 100644
index 97a30315ad..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Magnetization/UnitsNet.NanoFramework.Magnetization.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Magnetization</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Magnetization - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Magnetization units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework magnetization unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Magnetization\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Magnetization/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Magnetization/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Magnetization/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Mass/Mass.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Mass/Mass.nfproj
deleted file mode 100644
index 48eee658c6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Mass/Mass.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{f8c5a010-c353-31da-cadc-b56186be374f}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Mass</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Mass.g.cs" />
-    <Compile Include="..\Units\MassUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Mass/UnitsNet.NanoFramework.Mass.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Mass/UnitsNet.NanoFramework.Mass.nuspec
deleted file mode 100644
index e70607658f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Mass/UnitsNet.NanoFramework.Mass.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Mass</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Mass - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Mass units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework mass unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Mass\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Mass/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Mass/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Mass/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassConcentration/MassConcentration.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MassConcentration/MassConcentration.nfproj
deleted file mode 100644
index dc87caea11..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassConcentration/MassConcentration.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{0b1482c2-a3b1-6207-b73f-a07f46718b65}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MassConcentration</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MassConcentration.g.cs" />
-    <Compile Include="..\Units\MassConcentrationUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassConcentration/UnitsNet.NanoFramework.MassConcentration.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MassConcentration/UnitsNet.NanoFramework.MassConcentration.nuspec
deleted file mode 100644
index ff25c23b61..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassConcentration/UnitsNet.NanoFramework.MassConcentration.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MassConcentration</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MassConcentration - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MassConcentration units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework massconcentration unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MassConcentration\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassConcentration/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MassConcentration/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassConcentration/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassFlow/MassFlow.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MassFlow/MassFlow.nfproj
deleted file mode 100644
index 7c7373e41a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassFlow/MassFlow.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{a0821347-be46-c587-b61d-5152c578048d}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MassFlow</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MassFlow.g.cs" />
-    <Compile Include="..\Units\MassFlowUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassFlow/UnitsNet.NanoFramework.MassFlow.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MassFlow/UnitsNet.NanoFramework.MassFlow.nuspec
deleted file mode 100644
index 0802b96cb3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassFlow/UnitsNet.NanoFramework.MassFlow.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MassFlow</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MassFlow - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MassFlow units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework massflow unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MassFlow\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassFlow/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MassFlow/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassFlow/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassFlux/MassFlux.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MassFlux/MassFlux.nfproj
deleted file mode 100644
index d957a14c66..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassFlux/MassFlux.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{15622f39-b4c5-7e66-57bc-31900b6065c8}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MassFlux</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MassFlux.g.cs" />
-    <Compile Include="..\Units\MassFluxUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassFlux/UnitsNet.NanoFramework.MassFlux.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MassFlux/UnitsNet.NanoFramework.MassFlux.nuspec
deleted file mode 100644
index 666819f5d4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassFlux/UnitsNet.NanoFramework.MassFlux.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MassFlux</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MassFlux - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MassFlux units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework massflux unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MassFlux\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassFlux/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MassFlux/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassFlux/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassFraction/MassFraction.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MassFraction/MassFraction.nfproj
deleted file mode 100644
index 400e772446..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassFraction/MassFraction.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{db140d08-4769-dc51-8809-a9222b830ef4}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MassFraction</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MassFraction.g.cs" />
-    <Compile Include="..\Units\MassFractionUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassFraction/UnitsNet.NanoFramework.MassFraction.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MassFraction/UnitsNet.NanoFramework.MassFraction.nuspec
deleted file mode 100644
index 396693476f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassFraction/UnitsNet.NanoFramework.MassFraction.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MassFraction</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MassFraction - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MassFraction units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework massfraction unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MassFraction\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassFraction/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MassFraction/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassFraction/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassMomentOfInertia/MassMomentOfInertia.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MassMomentOfInertia/MassMomentOfInertia.nfproj
deleted file mode 100644
index acc7dab6b2..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassMomentOfInertia/MassMomentOfInertia.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{6218c061-3905-79b2-d3bc-bb7b8fc77a69}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MassMomentOfInertia</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MassMomentOfInertia.g.cs" />
-    <Compile Include="..\Units\MassMomentOfInertiaUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassMomentOfInertia/UnitsNet.NanoFramework.MassMomentOfInertia.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MassMomentOfInertia/UnitsNet.NanoFramework.MassMomentOfInertia.nuspec
deleted file mode 100644
index 5a5a038833..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassMomentOfInertia/UnitsNet.NanoFramework.MassMomentOfInertia.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MassMomentOfInertia</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MassMomentOfInertia - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MassMomentOfInertia units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework massmomentofinertia unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MassMomentOfInertia\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MassMomentOfInertia/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MassMomentOfInertia/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MassMomentOfInertia/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Molality/Molality.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Molality/Molality.nfproj
deleted file mode 100644
index 0a503cfec7..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Molality/Molality.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{589b202c-e638-5c93-fefe-e1e3bab4a493}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Molality</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Molality.g.cs" />
-    <Compile Include="..\Units\MolalityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Molality/UnitsNet.NanoFramework.Molality.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Molality/UnitsNet.NanoFramework.Molality.nuspec
deleted file mode 100644
index f188c19926..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Molality/UnitsNet.NanoFramework.Molality.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Molality</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Molality - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Molality units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework molality unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Molality\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Molality/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Molality/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Molality/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarEnergy/MolarEnergy.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MolarEnergy/MolarEnergy.nfproj
deleted file mode 100644
index 232a3e819b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarEnergy/MolarEnergy.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{9b77d4e0-863d-4a74-c30a-56f7b2bb7cb7}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MolarEnergy</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MolarEnergy.g.cs" />
-    <Compile Include="..\Units\MolarEnergyUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarEnergy/UnitsNet.NanoFramework.MolarEnergy.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MolarEnergy/UnitsNet.NanoFramework.MolarEnergy.nuspec
deleted file mode 100644
index ca9950505a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarEnergy/UnitsNet.NanoFramework.MolarEnergy.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MolarEnergy</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MolarEnergy - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MolarEnergy units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework molarenergy unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MolarEnergy\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarEnergy/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MolarEnergy/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarEnergy/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarEntropy/MolarEntropy.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MolarEntropy/MolarEntropy.nfproj
deleted file mode 100644
index 19cd8579e3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarEntropy/MolarEntropy.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{2053731b-90f5-5141-d15e-8d7be8c2662f}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MolarEntropy</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MolarEntropy.g.cs" />
-    <Compile Include="..\Units\MolarEntropyUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarEntropy/UnitsNet.NanoFramework.MolarEntropy.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MolarEntropy/UnitsNet.NanoFramework.MolarEntropy.nuspec
deleted file mode 100644
index ea963d6178..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarEntropy/UnitsNet.NanoFramework.MolarEntropy.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MolarEntropy</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MolarEntropy - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MolarEntropy units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework molarentropy unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MolarEntropy\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarEntropy/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MolarEntropy/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarEntropy/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarFlow/MolarFlow.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MolarFlow/MolarFlow.nfproj
deleted file mode 100644
index fad8c7ab6e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarFlow/MolarFlow.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{49cc942b-d836-a48b-0429-25bf95247759}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MolarFlow</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MolarFlow.g.cs" />
-    <Compile Include="..\Units\MolarFlowUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarFlow/UnitsNet.NanoFramework.MolarFlow.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MolarFlow/UnitsNet.NanoFramework.MolarFlow.nuspec
deleted file mode 100644
index c5e2a69338..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarFlow/UnitsNet.NanoFramework.MolarFlow.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MolarFlow</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MolarFlow - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MolarFlow units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework molarflow unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MolarFlow\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarFlow/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MolarFlow/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarFlow/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarMass/MolarMass.nfproj b/UnitsNet.NanoFramework/GeneratedCode/MolarMass/MolarMass.nfproj
deleted file mode 100644
index e00ae77df6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarMass/MolarMass.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{fe51bbda-2039-23fd-f29a-39c14adcb1f6}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.MolarMass</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\MolarMass.g.cs" />
-    <Compile Include="..\Units\MolarMassUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarMass/UnitsNet.NanoFramework.MolarMass.nuspec b/UnitsNet.NanoFramework/GeneratedCode/MolarMass/UnitsNet.NanoFramework.MolarMass.nuspec
deleted file mode 100644
index 14efbfe624..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarMass/UnitsNet.NanoFramework.MolarMass.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.MolarMass</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET MolarMass - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds MolarMass units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework molarmass unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\MolarMass\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/MolarMass/packages.config b/UnitsNet.NanoFramework/GeneratedCode/MolarMass/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/MolarMass/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Molarity/Molarity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Molarity/Molarity.nfproj
deleted file mode 100644
index 66cfe427b2..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Molarity/Molarity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{0d21f127-8c25-9b3a-9612-ce2eea6e7ac1}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Molarity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Molarity.g.cs" />
-    <Compile Include="..\Units\MolarityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Molarity/UnitsNet.NanoFramework.Molarity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Molarity/UnitsNet.NanoFramework.Molarity.nuspec
deleted file mode 100644
index 699d3418fd..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Molarity/UnitsNet.NanoFramework.Molarity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Molarity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Molarity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Molarity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework molarity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Molarity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Molarity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Molarity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Molarity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Permeability/Permeability.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Permeability/Permeability.nfproj
deleted file mode 100644
index b8b4752e0a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Permeability/Permeability.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{34a31e0b-15ec-829c-6f0b-74f5acfd97e2}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Permeability</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Permeability.g.cs" />
-    <Compile Include="..\Units\PermeabilityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Permeability/UnitsNet.NanoFramework.Permeability.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Permeability/UnitsNet.NanoFramework.Permeability.nuspec
deleted file mode 100644
index 2a9f4c3339..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Permeability/UnitsNet.NanoFramework.Permeability.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Permeability</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Permeability - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Permeability units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework permeability unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Permeability\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Permeability/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Permeability/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Permeability/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Permittivity/Permittivity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Permittivity/Permittivity.nfproj
deleted file mode 100644
index 9ab3a135b8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Permittivity/Permittivity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{9b381685-8129-acba-66f0-7068fe43a6c3}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Permittivity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Permittivity.g.cs" />
-    <Compile Include="..\Units\PermittivityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Permittivity/UnitsNet.NanoFramework.Permittivity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Permittivity/UnitsNet.NanoFramework.Permittivity.nuspec
deleted file mode 100644
index 3271ff4fae..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Permittivity/UnitsNet.NanoFramework.Permittivity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Permittivity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Permittivity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Permittivity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework permittivity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Permittivity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Permittivity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Permittivity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Permittivity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PorousMediumPermeability/PorousMediumPermeability.nfproj b/UnitsNet.NanoFramework/GeneratedCode/PorousMediumPermeability/PorousMediumPermeability.nfproj
deleted file mode 100644
index 3cadb26e91..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PorousMediumPermeability/PorousMediumPermeability.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{493d1e8e-51c6-da82-9289-25bd26fab4a4}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.PorousMediumPermeability</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\PorousMediumPermeability.g.cs" />
-    <Compile Include="..\Units\PorousMediumPermeabilityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PorousMediumPermeability/UnitsNet.NanoFramework.PorousMediumPermeability.nuspec b/UnitsNet.NanoFramework/GeneratedCode/PorousMediumPermeability/UnitsNet.NanoFramework.PorousMediumPermeability.nuspec
deleted file mode 100644
index f2f4d9cc4d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PorousMediumPermeability/UnitsNet.NanoFramework.PorousMediumPermeability.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.PorousMediumPermeability</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET PorousMediumPermeability - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds PorousMediumPermeability units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework porousmediumpermeability unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\PorousMediumPermeability\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PorousMediumPermeability/packages.config b/UnitsNet.NanoFramework/GeneratedCode/PorousMediumPermeability/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PorousMediumPermeability/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Power/Power.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Power/Power.nfproj
deleted file mode 100644
index 026113ba1d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Power/Power.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{56968e84-6b7d-d548-4c0b-53017bd6123c}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Power</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Power.g.cs" />
-    <Compile Include="..\Units\PowerUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Power/UnitsNet.NanoFramework.Power.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Power/UnitsNet.NanoFramework.Power.nuspec
deleted file mode 100644
index ad193494ca..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Power/UnitsNet.NanoFramework.Power.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Power</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Power - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Power units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework power unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Power\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Power/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Power/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Power/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PowerDensity/PowerDensity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/PowerDensity/PowerDensity.nfproj
deleted file mode 100644
index 3a77007078..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PowerDensity/PowerDensity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{5e741dd9-690a-de16-e7a1-85e6239aa70d}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.PowerDensity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\PowerDensity.g.cs" />
-    <Compile Include="..\Units\PowerDensityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PowerDensity/UnitsNet.NanoFramework.PowerDensity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/PowerDensity/UnitsNet.NanoFramework.PowerDensity.nuspec
deleted file mode 100644
index c427282ab7..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PowerDensity/UnitsNet.NanoFramework.PowerDensity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.PowerDensity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET PowerDensity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds PowerDensity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework powerdensity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\PowerDensity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PowerDensity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/PowerDensity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PowerDensity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PowerRatio/PowerRatio.nfproj b/UnitsNet.NanoFramework/GeneratedCode/PowerRatio/PowerRatio.nfproj
deleted file mode 100644
index 1b10b7e724..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PowerRatio/PowerRatio.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{94317d9a-d614-b098-6175-76ee84262c05}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.PowerRatio</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\PowerRatio.g.cs" />
-    <Compile Include="..\Units\PowerRatioUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PowerRatio/UnitsNet.NanoFramework.PowerRatio.nuspec b/UnitsNet.NanoFramework/GeneratedCode/PowerRatio/UnitsNet.NanoFramework.PowerRatio.nuspec
deleted file mode 100644
index 0e223cbb32..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PowerRatio/UnitsNet.NanoFramework.PowerRatio.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.PowerRatio</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET PowerRatio - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds PowerRatio units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework powerratio unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\PowerRatio\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PowerRatio/packages.config b/UnitsNet.NanoFramework/GeneratedCode/PowerRatio/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PowerRatio/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Pressure/Pressure.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Pressure/Pressure.nfproj
deleted file mode 100644
index fd6578c3cd..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Pressure/Pressure.nfproj
+++ /dev/null
@@ -1,47 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{f907841f-b1ee-9b12-580e-cfe2324bed03}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Pressure</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Pressure.g.cs" />
-    <Compile Include="..\Units\PressureUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-    <Reference Include="System.Math, Version=1.5.43.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.System.Math.1.5.43\lib\System.Math.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Pressure/UnitsNet.NanoFramework.Pressure.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Pressure/UnitsNet.NanoFramework.Pressure.nuspec
deleted file mode 100644
index a1592a677f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Pressure/UnitsNet.NanoFramework.Pressure.nuspec
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Pressure</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Pressure - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Pressure units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework pressure unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-      <dependency id="nanoFramework.System.Math" version="1.5.43" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Pressure\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Pressure/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Pressure/packages.config
deleted file mode 100644
index ac11548cd6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Pressure/packages.config
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-  <package id="nanoFramework.System.Math" version="1.5.43" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PressureChangeRate/PressureChangeRate.nfproj b/UnitsNet.NanoFramework/GeneratedCode/PressureChangeRate/PressureChangeRate.nfproj
deleted file mode 100644
index 33bd6a8461..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PressureChangeRate/PressureChangeRate.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{c9e4cfa9-c5d3-5e9d-243c-106ba4b6a447}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.PressureChangeRate</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\PressureChangeRate.g.cs" />
-    <Compile Include="..\Units\PressureChangeRateUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PressureChangeRate/UnitsNet.NanoFramework.PressureChangeRate.nuspec b/UnitsNet.NanoFramework/GeneratedCode/PressureChangeRate/UnitsNet.NanoFramework.PressureChangeRate.nuspec
deleted file mode 100644
index b3eeaaadae..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PressureChangeRate/UnitsNet.NanoFramework.PressureChangeRate.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.PressureChangeRate</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET PressureChangeRate - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds PressureChangeRate units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework pressurechangerate unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\PressureChangeRate\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/PressureChangeRate/packages.config b/UnitsNet.NanoFramework/GeneratedCode/PressureChangeRate/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/PressureChangeRate/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Properties/AssemblyInfo.cs b/UnitsNet.NanoFramework/GeneratedCode/Properties/AssemblyInfo.cs
deleted file mode 100644
index afb97626fd..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("UnitsNet")]
-[assembly: AssemblyDescription("Get all the common units of measurement and the conversions between them. It is light-weight and thoroughly tested.")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("Andreas Gullberg Larsen")]
-[assembly: AssemblyProduct("nanoFramework UnitsNet")]
-[assembly: AssemblyCopyright("Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible
-// to COM components.  If you need to access a type in this assembly from
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers
-// by using the '*' as shown below:
-[assembly: AssemblyVersion("6.0.0")]
-[assembly: AssemblyFileVersion("6.0.0")]
-
-//////////////////////////////////////////////////
-// This assembly doens't require native support //
-[assembly: AssemblyNativeVersion("0.0.0.0")]
-//////////////////////////////////////////////////
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
deleted file mode 100644
index a4d71717ff..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
+++ /dev/null
@@ -1,352 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Absorbed dose is a dose quantity which is the measure of the energy deposited in matter by ionizing radiation per unit mass.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Absorbed_dose
-    /// </remarks>
-    public struct  AbsorbedDoseOfIonizingRadiation
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly AbsorbedDoseOfIonizingRadiationUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public AbsorbedDoseOfIonizingRadiationUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public AbsorbedDoseOfIonizingRadiation(double value, AbsorbedDoseOfIonizingRadiationUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of AbsorbedDoseOfIonizingRadiation, which is Second. All conversions go via this value.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiationUnit BaseUnit { get; } = AbsorbedDoseOfIonizingRadiationUnit.Gray;
-
-        /// <summary>
-        /// Represents the largest possible value of AbsorbedDoseOfIonizingRadiation.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation MaxValue { get; } = new AbsorbedDoseOfIonizingRadiation(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of AbsorbedDoseOfIonizingRadiation.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation MinValue { get; } = new AbsorbedDoseOfIonizingRadiation(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation Zero { get; } = new AbsorbedDoseOfIonizingRadiation(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Centigray"/>
-        /// </summary>
-        public double Centigrays => As(AbsorbedDoseOfIonizingRadiationUnit.Centigray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Decigray"/>
-        /// </summary>
-        public double Decigrays => As(AbsorbedDoseOfIonizingRadiationUnit.Decigray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Femtogray"/>
-        /// </summary>
-        public double Femtograys => As(AbsorbedDoseOfIonizingRadiationUnit.Femtogray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gigagray"/>
-        /// </summary>
-        public double Gigagrays => As(AbsorbedDoseOfIonizingRadiationUnit.Gigagray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gray"/>
-        /// </summary>
-        public double Grays => As(AbsorbedDoseOfIonizingRadiationUnit.Gray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilogray"/>
-        /// </summary>
-        public double Kilograys => As(AbsorbedDoseOfIonizingRadiationUnit.Kilogray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilorad"/>
-        /// </summary>
-        public double Kilorads => As(AbsorbedDoseOfIonizingRadiationUnit.Kilorad);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megagray"/>
-        /// </summary>
-        public double Megagrays => As(AbsorbedDoseOfIonizingRadiationUnit.Megagray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megarad"/>
-        /// </summary>
-        public double Megarads => As(AbsorbedDoseOfIonizingRadiationUnit.Megarad);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Microgray"/>
-        /// </summary>
-        public double Micrograys => As(AbsorbedDoseOfIonizingRadiationUnit.Microgray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Milligray"/>
-        /// </summary>
-        public double Milligrays => As(AbsorbedDoseOfIonizingRadiationUnit.Milligray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Millirad"/>
-        /// </summary>
-        public double Millirads => As(AbsorbedDoseOfIonizingRadiationUnit.Millirad);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Nanogray"/>
-        /// </summary>
-        public double Nanograys => As(AbsorbedDoseOfIonizingRadiationUnit.Nanogray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Petagray"/>
-        /// </summary>
-        public double Petagrays => As(AbsorbedDoseOfIonizingRadiationUnit.Petagray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Picogray"/>
-        /// </summary>
-        public double Picograys => As(AbsorbedDoseOfIonizingRadiationUnit.Picogray);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Rad"/>
-        /// </summary>
-        public double Rads => As(AbsorbedDoseOfIonizingRadiationUnit.Rad);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Teragray"/>
-        /// </summary>
-        public double Teragrays => As(AbsorbedDoseOfIonizingRadiationUnit.Teragray);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Centigray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromCentigrays(double centigrays) => new AbsorbedDoseOfIonizingRadiation(centigrays, AbsorbedDoseOfIonizingRadiationUnit.Centigray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Decigray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromDecigrays(double decigrays) => new AbsorbedDoseOfIonizingRadiation(decigrays, AbsorbedDoseOfIonizingRadiationUnit.Decigray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Femtogray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromFemtograys(double femtograys) => new AbsorbedDoseOfIonizingRadiation(femtograys, AbsorbedDoseOfIonizingRadiationUnit.Femtogray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gigagray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromGigagrays(double gigagrays) => new AbsorbedDoseOfIonizingRadiation(gigagrays, AbsorbedDoseOfIonizingRadiationUnit.Gigagray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromGrays(double grays) => new AbsorbedDoseOfIonizingRadiation(grays, AbsorbedDoseOfIonizingRadiationUnit.Gray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilogray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromKilograys(double kilograys) => new AbsorbedDoseOfIonizingRadiation(kilograys, AbsorbedDoseOfIonizingRadiationUnit.Kilogray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilorad"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromKilorads(double kilorads) => new AbsorbedDoseOfIonizingRadiation(kilorads, AbsorbedDoseOfIonizingRadiationUnit.Kilorad);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megagray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromMegagrays(double megagrays) => new AbsorbedDoseOfIonizingRadiation(megagrays, AbsorbedDoseOfIonizingRadiationUnit.Megagray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megarad"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromMegarads(double megarads) => new AbsorbedDoseOfIonizingRadiation(megarads, AbsorbedDoseOfIonizingRadiationUnit.Megarad);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Microgray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromMicrograys(double micrograys) => new AbsorbedDoseOfIonizingRadiation(micrograys, AbsorbedDoseOfIonizingRadiationUnit.Microgray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Milligray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromMilligrays(double milligrays) => new AbsorbedDoseOfIonizingRadiation(milligrays, AbsorbedDoseOfIonizingRadiationUnit.Milligray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Millirad"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromMillirads(double millirads) => new AbsorbedDoseOfIonizingRadiation(millirads, AbsorbedDoseOfIonizingRadiationUnit.Millirad);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Nanogray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromNanograys(double nanograys) => new AbsorbedDoseOfIonizingRadiation(nanograys, AbsorbedDoseOfIonizingRadiationUnit.Nanogray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Petagray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromPetagrays(double petagrays) => new AbsorbedDoseOfIonizingRadiation(petagrays, AbsorbedDoseOfIonizingRadiationUnit.Petagray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Picogray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromPicograys(double picograys) => new AbsorbedDoseOfIonizingRadiation(picograys, AbsorbedDoseOfIonizingRadiationUnit.Picogray);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Rad"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromRads(double rads) => new AbsorbedDoseOfIonizingRadiation(rads, AbsorbedDoseOfIonizingRadiationUnit.Rad);
-
-        /// <summary>
-        ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Teragray"/>.
-        /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromTeragrays(double teragrays) => new AbsorbedDoseOfIonizingRadiation(teragrays, AbsorbedDoseOfIonizingRadiationUnit.Teragray);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AbsorbedDoseOfIonizingRadiationUnit" /> to <see cref="AbsorbedDoseOfIonizingRadiation" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>AbsorbedDoseOfIonizingRadiation unit value.</returns>
-        public static AbsorbedDoseOfIonizingRadiation From(double value, AbsorbedDoseOfIonizingRadiationUnit fromUnit)
-        {
-            return new AbsorbedDoseOfIonizingRadiation(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(AbsorbedDoseOfIonizingRadiationUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this AbsorbedDoseOfIonizingRadiation to another AbsorbedDoseOfIonizingRadiation with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A AbsorbedDoseOfIonizingRadiation with the specified unit.</returns>
-                public AbsorbedDoseOfIonizingRadiation ToUnit(AbsorbedDoseOfIonizingRadiationUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new AbsorbedDoseOfIonizingRadiation(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        AbsorbedDoseOfIonizingRadiationUnit.Centigray => (_value) * 1e-2d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Decigray => (_value) * 1e-1d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Femtogray => (_value) * 1e-15d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Gigagray => (_value) * 1e9d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Gray => _value,
-                        AbsorbedDoseOfIonizingRadiationUnit.Kilogray => (_value) * 1e3d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Kilorad => (_value / 100) * 1e3d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Megagray => (_value) * 1e6d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Megarad => (_value / 100) * 1e6d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Microgray => (_value) * 1e-6d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Milligray => (_value) * 1e-3d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Millirad => (_value / 100) * 1e-3d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Nanogray => (_value) * 1e-9d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Petagray => (_value) * 1e15d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Picogray => (_value) * 1e-12d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Rad => _value / 100,
-                        AbsorbedDoseOfIonizingRadiationUnit.Teragray => (_value) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(AbsorbedDoseOfIonizingRadiationUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        AbsorbedDoseOfIonizingRadiationUnit.Centigray => (baseUnitValue) / 1e-2d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Decigray => (baseUnitValue) / 1e-1d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Femtogray => (baseUnitValue) / 1e-15d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Gigagray => (baseUnitValue) / 1e9d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Gray => baseUnitValue,
-                        AbsorbedDoseOfIonizingRadiationUnit.Kilogray => (baseUnitValue) / 1e3d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Kilorad => (baseUnitValue * 100) / 1e3d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Megagray => (baseUnitValue) / 1e6d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Megarad => (baseUnitValue * 100) / 1e6d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Microgray => (baseUnitValue) / 1e-6d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Milligray => (baseUnitValue) / 1e-3d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Millirad => (baseUnitValue * 100) / 1e-3d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Nanogray => (baseUnitValue) / 1e-9d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Petagray => (baseUnitValue) / 1e15d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Picogray => (baseUnitValue) / 1e-12d,
-                        AbsorbedDoseOfIonizingRadiationUnit.Rad => baseUnitValue * 100,
-                        AbsorbedDoseOfIonizingRadiationUnit.Teragray => (baseUnitValue) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Acceleration.g.cs
deleted file mode 100644
index 6554701aea..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Acceleration.g.cs
+++ /dev/null
@@ -1,313 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Acceleration, in physics, is the rate at which the velocity of an object changes over time. An object's acceleration is the net result of any and all forces acting on the object, as described by Newton's Second Law. The SI unit for acceleration is the Meter per second squared (m/s²). Accelerations are vector quantities (they have magnitude and direction) and add according to the parallelogram law. As a vector, the calculated net force is equal to the product of the object's mass (a scalar quantity) and the acceleration.
-    /// </summary>
-    public struct  Acceleration
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly AccelerationUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public AccelerationUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Acceleration(double value, AccelerationUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Acceleration, which is Second. All conversions go via this value.
-        /// </summary>
-        public static AccelerationUnit BaseUnit { get; } = AccelerationUnit.MeterPerSecondSquared;
-
-        /// <summary>
-        /// Represents the largest possible value of Acceleration.
-        /// </summary>
-        public static Acceleration MaxValue { get; } = new Acceleration(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Acceleration.
-        /// </summary>
-        public static Acceleration MinValue { get; } = new Acceleration(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Acceleration Zero { get; } = new Acceleration(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.CentimeterPerSecondSquared"/>
-        /// </summary>
-        public double CentimetersPerSecondSquared => As(AccelerationUnit.CentimeterPerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.DecimeterPerSecondSquared"/>
-        /// </summary>
-        public double DecimetersPerSecondSquared => As(AccelerationUnit.DecimeterPerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.FootPerSecondSquared"/>
-        /// </summary>
-        public double FeetPerSecondSquared => As(AccelerationUnit.FootPerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.InchPerSecondSquared"/>
-        /// </summary>
-        public double InchesPerSecondSquared => As(AccelerationUnit.InchPerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.KilometerPerSecondSquared"/>
-        /// </summary>
-        public double KilometersPerSecondSquared => As(AccelerationUnit.KilometerPerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.KnotPerHour"/>
-        /// </summary>
-        public double KnotsPerHour => As(AccelerationUnit.KnotPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.KnotPerMinute"/>
-        /// </summary>
-        public double KnotsPerMinute => As(AccelerationUnit.KnotPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.KnotPerSecond"/>
-        /// </summary>
-        public double KnotsPerSecond => As(AccelerationUnit.KnotPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.MeterPerSecondSquared"/>
-        /// </summary>
-        public double MetersPerSecondSquared => As(AccelerationUnit.MeterPerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.MicrometerPerSecondSquared"/>
-        /// </summary>
-        public double MicrometersPerSecondSquared => As(AccelerationUnit.MicrometerPerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.MillimeterPerSecondSquared"/>
-        /// </summary>
-        public double MillimetersPerSecondSquared => As(AccelerationUnit.MillimeterPerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.MillistandardGravity"/>
-        /// </summary>
-        public double MillistandardGravity => As(AccelerationUnit.MillistandardGravity);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.NanometerPerSecondSquared"/>
-        /// </summary>
-        public double NanometersPerSecondSquared => As(AccelerationUnit.NanometerPerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.StandardGravity"/>
-        /// </summary>
-        public double StandardGravity => As(AccelerationUnit.StandardGravity);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.CentimeterPerSecondSquared"/>.
-        /// </summary>
-        public static Acceleration FromCentimetersPerSecondSquared(double centimeterspersecondsquared) => new Acceleration(centimeterspersecondsquared, AccelerationUnit.CentimeterPerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.DecimeterPerSecondSquared"/>.
-        /// </summary>
-        public static Acceleration FromDecimetersPerSecondSquared(double decimeterspersecondsquared) => new Acceleration(decimeterspersecondsquared, AccelerationUnit.DecimeterPerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.FootPerSecondSquared"/>.
-        /// </summary>
-        public static Acceleration FromFeetPerSecondSquared(double feetpersecondsquared) => new Acceleration(feetpersecondsquared, AccelerationUnit.FootPerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.InchPerSecondSquared"/>.
-        /// </summary>
-        public static Acceleration FromInchesPerSecondSquared(double inchespersecondsquared) => new Acceleration(inchespersecondsquared, AccelerationUnit.InchPerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KilometerPerSecondSquared"/>.
-        /// </summary>
-        public static Acceleration FromKilometersPerSecondSquared(double kilometerspersecondsquared) => new Acceleration(kilometerspersecondsquared, AccelerationUnit.KilometerPerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerHour"/>.
-        /// </summary>
-        public static Acceleration FromKnotsPerHour(double knotsperhour) => new Acceleration(knotsperhour, AccelerationUnit.KnotPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerMinute"/>.
-        /// </summary>
-        public static Acceleration FromKnotsPerMinute(double knotsperminute) => new Acceleration(knotsperminute, AccelerationUnit.KnotPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerSecond"/>.
-        /// </summary>
-        public static Acceleration FromKnotsPerSecond(double knotspersecond) => new Acceleration(knotspersecond, AccelerationUnit.KnotPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MeterPerSecondSquared"/>.
-        /// </summary>
-        public static Acceleration FromMetersPerSecondSquared(double meterspersecondsquared) => new Acceleration(meterspersecondsquared, AccelerationUnit.MeterPerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MicrometerPerSecondSquared"/>.
-        /// </summary>
-        public static Acceleration FromMicrometersPerSecondSquared(double micrometerspersecondsquared) => new Acceleration(micrometerspersecondsquared, AccelerationUnit.MicrometerPerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MillimeterPerSecondSquared"/>.
-        /// </summary>
-        public static Acceleration FromMillimetersPerSecondSquared(double millimeterspersecondsquared) => new Acceleration(millimeterspersecondsquared, AccelerationUnit.MillimeterPerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MillistandardGravity"/>.
-        /// </summary>
-        public static Acceleration FromMillistandardGravity(double millistandardgravity) => new Acceleration(millistandardgravity, AccelerationUnit.MillistandardGravity);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.NanometerPerSecondSquared"/>.
-        /// </summary>
-        public static Acceleration FromNanometersPerSecondSquared(double nanometerspersecondsquared) => new Acceleration(nanometerspersecondsquared, AccelerationUnit.NanometerPerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.StandardGravity"/>.
-        /// </summary>
-        public static Acceleration FromStandardGravity(double standardgravity) => new Acceleration(standardgravity, AccelerationUnit.StandardGravity);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AccelerationUnit" /> to <see cref="Acceleration" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Acceleration unit value.</returns>
-        public static Acceleration From(double value, AccelerationUnit fromUnit)
-        {
-            return new Acceleration(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(AccelerationUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Acceleration to another Acceleration with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Acceleration with the specified unit.</returns>
-                public Acceleration ToUnit(AccelerationUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Acceleration(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        AccelerationUnit.CentimeterPerSecondSquared => (_value) * 1e-2d,
-                        AccelerationUnit.DecimeterPerSecondSquared => (_value) * 1e-1d,
-                        AccelerationUnit.FootPerSecondSquared => _value * 0.304800,
-                        AccelerationUnit.InchPerSecondSquared => _value * 0.0254,
-                        AccelerationUnit.KilometerPerSecondSquared => (_value) * 1e3d,
-                        AccelerationUnit.KnotPerHour => _value * (1852.0 / 3600.0) / 3600,
-                        AccelerationUnit.KnotPerMinute => _value * (1852.0 / 3600.0) / 60,
-                        AccelerationUnit.KnotPerSecond => _value * (1852.0 / 3600.0),
-                        AccelerationUnit.MeterPerSecondSquared => _value,
-                        AccelerationUnit.MicrometerPerSecondSquared => (_value) * 1e-6d,
-                        AccelerationUnit.MillimeterPerSecondSquared => (_value) * 1e-3d,
-                        AccelerationUnit.MillistandardGravity => (_value * 9.80665) * 1e-3d,
-                        AccelerationUnit.NanometerPerSecondSquared => (_value) * 1e-9d,
-                        AccelerationUnit.StandardGravity => _value * 9.80665,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(AccelerationUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        AccelerationUnit.CentimeterPerSecondSquared => (baseUnitValue) / 1e-2d,
-                        AccelerationUnit.DecimeterPerSecondSquared => (baseUnitValue) / 1e-1d,
-                        AccelerationUnit.FootPerSecondSquared => baseUnitValue / 0.304800,
-                        AccelerationUnit.InchPerSecondSquared => baseUnitValue / 0.0254,
-                        AccelerationUnit.KilometerPerSecondSquared => (baseUnitValue) / 1e3d,
-                        AccelerationUnit.KnotPerHour => baseUnitValue * 3600 / (1852.0 / 3600.0),
-                        AccelerationUnit.KnotPerMinute => baseUnitValue * 60 / (1852.0 / 3600.0),
-                        AccelerationUnit.KnotPerSecond => baseUnitValue / (1852.0 / 3600.0),
-                        AccelerationUnit.MeterPerSecondSquared => baseUnitValue,
-                        AccelerationUnit.MicrometerPerSecondSquared => (baseUnitValue) / 1e-6d,
-                        AccelerationUnit.MillimeterPerSecondSquared => (baseUnitValue) / 1e-3d,
-                        AccelerationUnit.MillistandardGravity => (baseUnitValue / 9.80665) / 1e-3d,
-                        AccelerationUnit.NanometerPerSecondSquared => (baseUnitValue) / 1e-9d,
-                        AccelerationUnit.StandardGravity => baseUnitValue / 9.80665,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/AmountOfSubstance.g.cs
deleted file mode 100644
index 938727458b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/AmountOfSubstance.g.cs
+++ /dev/null
@@ -1,349 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Mole is the amount of substance containing Avagadro's Number (6.02 x 10 ^ 23) of real particles such as molecules,atoms, ions or radicals.
-    /// </summary>
-    public struct  AmountOfSubstance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly AmountOfSubstanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public AmountOfSubstanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public AmountOfSubstance(double value, AmountOfSubstanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of AmountOfSubstance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static AmountOfSubstanceUnit BaseUnit { get; } = AmountOfSubstanceUnit.Mole;
-
-        /// <summary>
-        /// Represents the largest possible value of AmountOfSubstance.
-        /// </summary>
-        public static AmountOfSubstance MaxValue { get; } = new AmountOfSubstance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of AmountOfSubstance.
-        /// </summary>
-        public static AmountOfSubstance MinValue { get; } = new AmountOfSubstance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static AmountOfSubstance Zero { get; } = new AmountOfSubstance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Centimole"/>
-        /// </summary>
-        public double Centimoles => As(AmountOfSubstanceUnit.Centimole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.CentipoundMole"/>
-        /// </summary>
-        public double CentipoundMoles => As(AmountOfSubstanceUnit.CentipoundMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Decimole"/>
-        /// </summary>
-        public double Decimoles => As(AmountOfSubstanceUnit.Decimole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.DecipoundMole"/>
-        /// </summary>
-        public double DecipoundMoles => As(AmountOfSubstanceUnit.DecipoundMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Femtomole"/>
-        /// </summary>
-        public double Femtomoles => As(AmountOfSubstanceUnit.Femtomole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Kilomole"/>
-        /// </summary>
-        public double Kilomoles => As(AmountOfSubstanceUnit.Kilomole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.KilopoundMole"/>
-        /// </summary>
-        public double KilopoundMoles => As(AmountOfSubstanceUnit.KilopoundMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Megamole"/>
-        /// </summary>
-        public double Megamoles => As(AmountOfSubstanceUnit.Megamole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Micromole"/>
-        /// </summary>
-        public double Micromoles => As(AmountOfSubstanceUnit.Micromole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.MicropoundMole"/>
-        /// </summary>
-        public double MicropoundMoles => As(AmountOfSubstanceUnit.MicropoundMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Millimole"/>
-        /// </summary>
-        public double Millimoles => As(AmountOfSubstanceUnit.Millimole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.MillipoundMole"/>
-        /// </summary>
-        public double MillipoundMoles => As(AmountOfSubstanceUnit.MillipoundMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Mole"/>
-        /// </summary>
-        public double Moles => As(AmountOfSubstanceUnit.Mole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Nanomole"/>
-        /// </summary>
-        public double Nanomoles => As(AmountOfSubstanceUnit.Nanomole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.NanopoundMole"/>
-        /// </summary>
-        public double NanopoundMoles => As(AmountOfSubstanceUnit.NanopoundMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Picomole"/>
-        /// </summary>
-        public double Picomoles => As(AmountOfSubstanceUnit.Picomole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.PoundMole"/>
-        /// </summary>
-        public double PoundMoles => As(AmountOfSubstanceUnit.PoundMole);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Centimole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromCentimoles(double centimoles) => new AmountOfSubstance(centimoles, AmountOfSubstanceUnit.Centimole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.CentipoundMole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromCentipoundMoles(double centipoundmoles) => new AmountOfSubstance(centipoundmoles, AmountOfSubstanceUnit.CentipoundMole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Decimole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromDecimoles(double decimoles) => new AmountOfSubstance(decimoles, AmountOfSubstanceUnit.Decimole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.DecipoundMole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromDecipoundMoles(double decipoundmoles) => new AmountOfSubstance(decipoundmoles, AmountOfSubstanceUnit.DecipoundMole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Femtomole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromFemtomoles(double femtomoles) => new AmountOfSubstance(femtomoles, AmountOfSubstanceUnit.Femtomole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Kilomole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromKilomoles(double kilomoles) => new AmountOfSubstance(kilomoles, AmountOfSubstanceUnit.Kilomole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.KilopoundMole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromKilopoundMoles(double kilopoundmoles) => new AmountOfSubstance(kilopoundmoles, AmountOfSubstanceUnit.KilopoundMole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Megamole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromMegamoles(double megamoles) => new AmountOfSubstance(megamoles, AmountOfSubstanceUnit.Megamole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Micromole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromMicromoles(double micromoles) => new AmountOfSubstance(micromoles, AmountOfSubstanceUnit.Micromole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.MicropoundMole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromMicropoundMoles(double micropoundmoles) => new AmountOfSubstance(micropoundmoles, AmountOfSubstanceUnit.MicropoundMole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Millimole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromMillimoles(double millimoles) => new AmountOfSubstance(millimoles, AmountOfSubstanceUnit.Millimole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.MillipoundMole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromMillipoundMoles(double millipoundmoles) => new AmountOfSubstance(millipoundmoles, AmountOfSubstanceUnit.MillipoundMole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Mole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromMoles(double moles) => new AmountOfSubstance(moles, AmountOfSubstanceUnit.Mole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Nanomole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromNanomoles(double nanomoles) => new AmountOfSubstance(nanomoles, AmountOfSubstanceUnit.Nanomole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.NanopoundMole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromNanopoundMoles(double nanopoundmoles) => new AmountOfSubstance(nanopoundmoles, AmountOfSubstanceUnit.NanopoundMole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Picomole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromPicomoles(double picomoles) => new AmountOfSubstance(picomoles, AmountOfSubstanceUnit.Picomole);
-
-        /// <summary>
-        ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.PoundMole"/>.
-        /// </summary>
-        public static AmountOfSubstance FromPoundMoles(double poundmoles) => new AmountOfSubstance(poundmoles, AmountOfSubstanceUnit.PoundMole);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AmountOfSubstanceUnit" /> to <see cref="AmountOfSubstance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>AmountOfSubstance unit value.</returns>
-        public static AmountOfSubstance From(double value, AmountOfSubstanceUnit fromUnit)
-        {
-            return new AmountOfSubstance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(AmountOfSubstanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this AmountOfSubstance to another AmountOfSubstance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A AmountOfSubstance with the specified unit.</returns>
-                public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new AmountOfSubstance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        AmountOfSubstanceUnit.Centimole => (_value) * 1e-2d,
-                        AmountOfSubstanceUnit.CentipoundMole => (_value * 453.59237) * 1e-2d,
-                        AmountOfSubstanceUnit.Decimole => (_value) * 1e-1d,
-                        AmountOfSubstanceUnit.DecipoundMole => (_value * 453.59237) * 1e-1d,
-                        AmountOfSubstanceUnit.Femtomole => (_value) * 1e-15d,
-                        AmountOfSubstanceUnit.Kilomole => (_value) * 1e3d,
-                        AmountOfSubstanceUnit.KilopoundMole => (_value * 453.59237) * 1e3d,
-                        AmountOfSubstanceUnit.Megamole => (_value) * 1e6d,
-                        AmountOfSubstanceUnit.Micromole => (_value) * 1e-6d,
-                        AmountOfSubstanceUnit.MicropoundMole => (_value * 453.59237) * 1e-6d,
-                        AmountOfSubstanceUnit.Millimole => (_value) * 1e-3d,
-                        AmountOfSubstanceUnit.MillipoundMole => (_value * 453.59237) * 1e-3d,
-                        AmountOfSubstanceUnit.Mole => _value,
-                        AmountOfSubstanceUnit.Nanomole => (_value) * 1e-9d,
-                        AmountOfSubstanceUnit.NanopoundMole => (_value * 453.59237) * 1e-9d,
-                        AmountOfSubstanceUnit.Picomole => (_value) * 1e-12d,
-                        AmountOfSubstanceUnit.PoundMole => _value * 453.59237,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(AmountOfSubstanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        AmountOfSubstanceUnit.Centimole => (baseUnitValue) / 1e-2d,
-                        AmountOfSubstanceUnit.CentipoundMole => (baseUnitValue / 453.59237) / 1e-2d,
-                        AmountOfSubstanceUnit.Decimole => (baseUnitValue) / 1e-1d,
-                        AmountOfSubstanceUnit.DecipoundMole => (baseUnitValue / 453.59237) / 1e-1d,
-                        AmountOfSubstanceUnit.Femtomole => (baseUnitValue) / 1e-15d,
-                        AmountOfSubstanceUnit.Kilomole => (baseUnitValue) / 1e3d,
-                        AmountOfSubstanceUnit.KilopoundMole => (baseUnitValue / 453.59237) / 1e3d,
-                        AmountOfSubstanceUnit.Megamole => (baseUnitValue) / 1e6d,
-                        AmountOfSubstanceUnit.Micromole => (baseUnitValue) / 1e-6d,
-                        AmountOfSubstanceUnit.MicropoundMole => (baseUnitValue / 453.59237) / 1e-6d,
-                        AmountOfSubstanceUnit.Millimole => (baseUnitValue) / 1e-3d,
-                        AmountOfSubstanceUnit.MillipoundMole => (baseUnitValue / 453.59237) / 1e-3d,
-                        AmountOfSubstanceUnit.Mole => baseUnitValue,
-                        AmountOfSubstanceUnit.Nanomole => (baseUnitValue) / 1e-9d,
-                        AmountOfSubstanceUnit.NanopoundMole => (baseUnitValue / 453.59237) / 1e-9d,
-                        AmountOfSubstanceUnit.Picomole => (baseUnitValue) / 1e-12d,
-                        AmountOfSubstanceUnit.PoundMole => baseUnitValue / 453.59237,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/AmplitudeRatio.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/AmplitudeRatio.g.cs
deleted file mode 100644
index ed64c7755c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/AmplitudeRatio.g.cs
+++ /dev/null
@@ -1,193 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The strength of a signal expressed in decibels (dB) relative to one volt RMS.
-    /// </summary>
-    public struct  AmplitudeRatio
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly AmplitudeRatioUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public AmplitudeRatioUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public AmplitudeRatio(double value, AmplitudeRatioUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of AmplitudeRatio, which is Second. All conversions go via this value.
-        /// </summary>
-        public static AmplitudeRatioUnit BaseUnit { get; } = AmplitudeRatioUnit.DecibelVolt;
-
-        /// <summary>
-        /// Represents the largest possible value of AmplitudeRatio.
-        /// </summary>
-        public static AmplitudeRatio MaxValue { get; } = new AmplitudeRatio(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of AmplitudeRatio.
-        /// </summary>
-        public static AmplitudeRatio MinValue { get; } = new AmplitudeRatio(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static AmplitudeRatio Zero { get; } = new AmplitudeRatio(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelMicrovolt"/>
-        /// </summary>
-        public double DecibelMicrovolts => As(AmplitudeRatioUnit.DecibelMicrovolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelMillivolt"/>
-        /// </summary>
-        public double DecibelMillivolts => As(AmplitudeRatioUnit.DecibelMillivolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelUnloaded"/>
-        /// </summary>
-        public double DecibelsUnloaded => As(AmplitudeRatioUnit.DecibelUnloaded);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelVolt"/>
-        /// </summary>
-        public double DecibelVolts => As(AmplitudeRatioUnit.DecibelVolt);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelMicrovolt"/>.
-        /// </summary>
-        public static AmplitudeRatio FromDecibelMicrovolts(double decibelmicrovolts) => new AmplitudeRatio(decibelmicrovolts, AmplitudeRatioUnit.DecibelMicrovolt);
-
-        /// <summary>
-        ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelMillivolt"/>.
-        /// </summary>
-        public static AmplitudeRatio FromDecibelMillivolts(double decibelmillivolts) => new AmplitudeRatio(decibelmillivolts, AmplitudeRatioUnit.DecibelMillivolt);
-
-        /// <summary>
-        ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelUnloaded"/>.
-        /// </summary>
-        public static AmplitudeRatio FromDecibelsUnloaded(double decibelsunloaded) => new AmplitudeRatio(decibelsunloaded, AmplitudeRatioUnit.DecibelUnloaded);
-
-        /// <summary>
-        ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelVolt"/>.
-        /// </summary>
-        public static AmplitudeRatio FromDecibelVolts(double decibelvolts) => new AmplitudeRatio(decibelvolts, AmplitudeRatioUnit.DecibelVolt);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AmplitudeRatioUnit" /> to <see cref="AmplitudeRatio" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>AmplitudeRatio unit value.</returns>
-        public static AmplitudeRatio From(double value, AmplitudeRatioUnit fromUnit)
-        {
-            return new AmplitudeRatio(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(AmplitudeRatioUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this AmplitudeRatio to another AmplitudeRatio with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A AmplitudeRatio with the specified unit.</returns>
-                public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new AmplitudeRatio(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        AmplitudeRatioUnit.DecibelMicrovolt => _value - 120,
-                        AmplitudeRatioUnit.DecibelMillivolt => _value - 60,
-                        AmplitudeRatioUnit.DecibelUnloaded => _value - 2.218487499,
-                        AmplitudeRatioUnit.DecibelVolt => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(AmplitudeRatioUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        AmplitudeRatioUnit.DecibelMicrovolt => baseUnitValue + 120,
-                        AmplitudeRatioUnit.DecibelMillivolt => baseUnitValue + 60,
-                        AmplitudeRatioUnit.DecibelUnloaded => baseUnitValue + 2.218487499,
-                        AmplitudeRatioUnit.DecibelVolt => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Angle.g.cs
deleted file mode 100644
index dbe2db2d93..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Angle.g.cs
+++ /dev/null
@@ -1,325 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In geometry, an angle is the figure formed by two rays, called the sides of the angle, sharing a common endpoint, called the vertex of the angle.
-    /// </summary>
-    public struct  Angle
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly AngleUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public AngleUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Angle(double value, AngleUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Angle, which is Second. All conversions go via this value.
-        /// </summary>
-        public static AngleUnit BaseUnit { get; } = AngleUnit.Radian;
-
-        /// <summary>
-        /// Represents the largest possible value of Angle.
-        /// </summary>
-        public static Angle MaxValue { get; } = new Angle(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Angle.
-        /// </summary>
-        public static Angle MinValue { get; } = new Angle(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Angle Zero { get; } = new Angle(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Arcminute"/>
-        /// </summary>
-        public double Arcminutes => As(AngleUnit.Arcminute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Arcsecond"/>
-        /// </summary>
-        public double Arcseconds => As(AngleUnit.Arcsecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Centiradian"/>
-        /// </summary>
-        public double Centiradians => As(AngleUnit.Centiradian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Deciradian"/>
-        /// </summary>
-        public double Deciradians => As(AngleUnit.Deciradian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Degree"/>
-        /// </summary>
-        public double Degrees => As(AngleUnit.Degree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Gradian"/>
-        /// </summary>
-        public double Gradians => As(AngleUnit.Gradian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Microdegree"/>
-        /// </summary>
-        public double Microdegrees => As(AngleUnit.Microdegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Microradian"/>
-        /// </summary>
-        public double Microradians => As(AngleUnit.Microradian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Millidegree"/>
-        /// </summary>
-        public double Millidegrees => As(AngleUnit.Millidegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Milliradian"/>
-        /// </summary>
-        public double Milliradians => As(AngleUnit.Milliradian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Nanodegree"/>
-        /// </summary>
-        public double Nanodegrees => As(AngleUnit.Nanodegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Nanoradian"/>
-        /// </summary>
-        public double Nanoradians => As(AngleUnit.Nanoradian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.NatoMil"/>
-        /// </summary>
-        public double NatoMils => As(AngleUnit.NatoMil);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Radian"/>
-        /// </summary>
-        public double Radians => As(AngleUnit.Radian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Revolution"/>
-        /// </summary>
-        public double Revolutions => As(AngleUnit.Revolution);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Arcminute"/>.
-        /// </summary>
-        public static Angle FromArcminutes(double arcminutes) => new Angle(arcminutes, AngleUnit.Arcminute);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Arcsecond"/>.
-        /// </summary>
-        public static Angle FromArcseconds(double arcseconds) => new Angle(arcseconds, AngleUnit.Arcsecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Centiradian"/>.
-        /// </summary>
-        public static Angle FromCentiradians(double centiradians) => new Angle(centiradians, AngleUnit.Centiradian);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Deciradian"/>.
-        /// </summary>
-        public static Angle FromDeciradians(double deciradians) => new Angle(deciradians, AngleUnit.Deciradian);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Degree"/>.
-        /// </summary>
-        public static Angle FromDegrees(double degrees) => new Angle(degrees, AngleUnit.Degree);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Gradian"/>.
-        /// </summary>
-        public static Angle FromGradians(double gradians) => new Angle(gradians, AngleUnit.Gradian);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Microdegree"/>.
-        /// </summary>
-        public static Angle FromMicrodegrees(double microdegrees) => new Angle(microdegrees, AngleUnit.Microdegree);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Microradian"/>.
-        /// </summary>
-        public static Angle FromMicroradians(double microradians) => new Angle(microradians, AngleUnit.Microradian);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Millidegree"/>.
-        /// </summary>
-        public static Angle FromMillidegrees(double millidegrees) => new Angle(millidegrees, AngleUnit.Millidegree);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Milliradian"/>.
-        /// </summary>
-        public static Angle FromMilliradians(double milliradians) => new Angle(milliradians, AngleUnit.Milliradian);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Nanodegree"/>.
-        /// </summary>
-        public static Angle FromNanodegrees(double nanodegrees) => new Angle(nanodegrees, AngleUnit.Nanodegree);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Nanoradian"/>.
-        /// </summary>
-        public static Angle FromNanoradians(double nanoradians) => new Angle(nanoradians, AngleUnit.Nanoradian);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.NatoMil"/>.
-        /// </summary>
-        public static Angle FromNatoMils(double natomils) => new Angle(natomils, AngleUnit.NatoMil);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Radian"/>.
-        /// </summary>
-        public static Angle FromRadians(double radians) => new Angle(radians, AngleUnit.Radian);
-
-        /// <summary>
-        ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Revolution"/>.
-        /// </summary>
-        public static Angle FromRevolutions(double revolutions) => new Angle(revolutions, AngleUnit.Revolution);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AngleUnit" /> to <see cref="Angle" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Angle unit value.</returns>
-        public static Angle From(double value, AngleUnit fromUnit)
-        {
-            return new Angle(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(AngleUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Angle to another Angle with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Angle with the specified unit.</returns>
-                public Angle ToUnit(AngleUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Angle(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        AngleUnit.Arcminute => _value * 3.1415926535897931 / (60 * 180),
-                        AngleUnit.Arcsecond => _value * 3.1415926535897931 / (3600 * 180),
-                        AngleUnit.Centiradian => (_value) * 1e-2d,
-                        AngleUnit.Deciradian => (_value) * 1e-1d,
-                        AngleUnit.Degree => _value * 3.1415926535897931 / 180,
-                        AngleUnit.Gradian => _value * 3.1415926535897931 / 200,
-                        AngleUnit.Microdegree => (_value * 3.1415926535897931 / 180) * 1e-6d,
-                        AngleUnit.Microradian => (_value) * 1e-6d,
-                        AngleUnit.Millidegree => (_value * 3.1415926535897931 / 180) * 1e-3d,
-                        AngleUnit.Milliradian => (_value) * 1e-3d,
-                        AngleUnit.Nanodegree => (_value * 3.1415926535897931 / 180) * 1e-9d,
-                        AngleUnit.Nanoradian => (_value) * 1e-9d,
-                        AngleUnit.NatoMil => _value * 3.1415926535897931 / 3200,
-                        AngleUnit.Radian => _value,
-                        AngleUnit.Revolution => _value * 2 * 3.1415926535897931,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(AngleUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        AngleUnit.Arcminute => baseUnitValue * 60 * 180 / 3.1415926535897931,
-                        AngleUnit.Arcsecond => baseUnitValue * 3600 * 180 / 3.1415926535897931,
-                        AngleUnit.Centiradian => (baseUnitValue) / 1e-2d,
-                        AngleUnit.Deciradian => (baseUnitValue) / 1e-1d,
-                        AngleUnit.Degree => baseUnitValue * 180 / 3.1415926535897931,
-                        AngleUnit.Gradian => baseUnitValue * 200 / 3.1415926535897931,
-                        AngleUnit.Microdegree => (baseUnitValue * 180 / 3.1415926535897931) / 1e-6d,
-                        AngleUnit.Microradian => (baseUnitValue) / 1e-6d,
-                        AngleUnit.Millidegree => (baseUnitValue * 180 / 3.1415926535897931) / 1e-3d,
-                        AngleUnit.Milliradian => (baseUnitValue) / 1e-3d,
-                        AngleUnit.Nanodegree => (baseUnitValue * 180 / 3.1415926535897931) / 1e-9d,
-                        AngleUnit.Nanoradian => (baseUnitValue) / 1e-9d,
-                        AngleUnit.NatoMil => baseUnitValue * 3200 / 3.1415926535897931,
-                        AngleUnit.Radian => baseUnitValue,
-                        AngleUnit.Revolution => baseUnitValue / (2 * 3.1415926535897931),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Area.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Area.g.cs
deleted file mode 100644
index 36d759bc12..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Area.g.cs
+++ /dev/null
@@ -1,313 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Area is a quantity that expresses the extent of a two-dimensional surface or shape, or planar lamina, in the plane. Area can be understood as the amount of material with a given thickness that would be necessary to fashion a model of the shape, or the amount of paint necessary to cover the surface with a single coat.[1] It is the two-dimensional analog of the length of a curve (a one-dimensional concept) or the volume of a solid (a three-dimensional concept).
-    /// </summary>
-    public struct  Area
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly AreaUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public AreaUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Area(double value, AreaUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Area, which is Second. All conversions go via this value.
-        /// </summary>
-        public static AreaUnit BaseUnit { get; } = AreaUnit.SquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Area.
-        /// </summary>
-        public static Area MaxValue { get; } = new Area(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Area.
-        /// </summary>
-        public static Area MinValue { get; } = new Area(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Area Zero { get; } = new Area(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.Acre"/>
-        /// </summary>
-        public double Acres => As(AreaUnit.Acre);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.Hectare"/>
-        /// </summary>
-        public double Hectares => As(AreaUnit.Hectare);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareCentimeter"/>
-        /// </summary>
-        public double SquareCentimeters => As(AreaUnit.SquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareDecimeter"/>
-        /// </summary>
-        public double SquareDecimeters => As(AreaUnit.SquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareFoot"/>
-        /// </summary>
-        public double SquareFeet => As(AreaUnit.SquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareInch"/>
-        /// </summary>
-        public double SquareInches => As(AreaUnit.SquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareKilometer"/>
-        /// </summary>
-        public double SquareKilometers => As(AreaUnit.SquareKilometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareMeter"/>
-        /// </summary>
-        public double SquareMeters => As(AreaUnit.SquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareMicrometer"/>
-        /// </summary>
-        public double SquareMicrometers => As(AreaUnit.SquareMicrometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareMile"/>
-        /// </summary>
-        public double SquareMiles => As(AreaUnit.SquareMile);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareMillimeter"/>
-        /// </summary>
-        public double SquareMillimeters => As(AreaUnit.SquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareNauticalMile"/>
-        /// </summary>
-        public double SquareNauticalMiles => As(AreaUnit.SquareNauticalMile);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareYard"/>
-        /// </summary>
-        public double SquareYards => As(AreaUnit.SquareYard);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.UsSurveySquareFoot"/>
-        /// </summary>
-        public double UsSurveySquareFeet => As(AreaUnit.UsSurveySquareFoot);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.Acre"/>.
-        /// </summary>
-        public static Area FromAcres(double acres) => new Area(acres, AreaUnit.Acre);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.Hectare"/>.
-        /// </summary>
-        public static Area FromHectares(double hectares) => new Area(hectares, AreaUnit.Hectare);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareCentimeter"/>.
-        /// </summary>
-        public static Area FromSquareCentimeters(double squarecentimeters) => new Area(squarecentimeters, AreaUnit.SquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareDecimeter"/>.
-        /// </summary>
-        public static Area FromSquareDecimeters(double squaredecimeters) => new Area(squaredecimeters, AreaUnit.SquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareFoot"/>.
-        /// </summary>
-        public static Area FromSquareFeet(double squarefeet) => new Area(squarefeet, AreaUnit.SquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareInch"/>.
-        /// </summary>
-        public static Area FromSquareInches(double squareinches) => new Area(squareinches, AreaUnit.SquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareKilometer"/>.
-        /// </summary>
-        public static Area FromSquareKilometers(double squarekilometers) => new Area(squarekilometers, AreaUnit.SquareKilometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMeter"/>.
-        /// </summary>
-        public static Area FromSquareMeters(double squaremeters) => new Area(squaremeters, AreaUnit.SquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMicrometer"/>.
-        /// </summary>
-        public static Area FromSquareMicrometers(double squaremicrometers) => new Area(squaremicrometers, AreaUnit.SquareMicrometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMile"/>.
-        /// </summary>
-        public static Area FromSquareMiles(double squaremiles) => new Area(squaremiles, AreaUnit.SquareMile);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMillimeter"/>.
-        /// </summary>
-        public static Area FromSquareMillimeters(double squaremillimeters) => new Area(squaremillimeters, AreaUnit.SquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareNauticalMile"/>.
-        /// </summary>
-        public static Area FromSquareNauticalMiles(double squarenauticalmiles) => new Area(squarenauticalmiles, AreaUnit.SquareNauticalMile);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareYard"/>.
-        /// </summary>
-        public static Area FromSquareYards(double squareyards) => new Area(squareyards, AreaUnit.SquareYard);
-
-        /// <summary>
-        ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.UsSurveySquareFoot"/>.
-        /// </summary>
-        public static Area FromUsSurveySquareFeet(double ussurveysquarefeet) => new Area(ussurveysquarefeet, AreaUnit.UsSurveySquareFoot);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AreaUnit" /> to <see cref="Area" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Area unit value.</returns>
-        public static Area From(double value, AreaUnit fromUnit)
-        {
-            return new Area(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(AreaUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Area to another Area with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Area with the specified unit.</returns>
-                public Area ToUnit(AreaUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Area(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        AreaUnit.Acre => _value * 4046.8564224,
-                        AreaUnit.Hectare => _value * 1e4,
-                        AreaUnit.SquareCentimeter => _value * 1e-4,
-                        AreaUnit.SquareDecimeter => _value * 1e-2,
-                        AreaUnit.SquareFoot => _value * 9.290304e-2,
-                        AreaUnit.SquareInch => _value * 0.00064516,
-                        AreaUnit.SquareKilometer => _value * 1e6,
-                        AreaUnit.SquareMeter => _value,
-                        AreaUnit.SquareMicrometer => _value * 1e-12,
-                        AreaUnit.SquareMile => _value * 1609.344 * 1609.344,
-                        AreaUnit.SquareMillimeter => _value * 1e-6,
-                        AreaUnit.SquareNauticalMile => _value * 3429904,
-                        AreaUnit.SquareYard => _value * 0.9144 * 0.9144,
-                        AreaUnit.UsSurveySquareFoot => _value * (1200.0 / 3937.0) * (1200.0 / 3937.0),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(AreaUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        AreaUnit.Acre => baseUnitValue / 4046.8564224,
-                        AreaUnit.Hectare => baseUnitValue / 1e4,
-                        AreaUnit.SquareCentimeter => baseUnitValue / 1e-4,
-                        AreaUnit.SquareDecimeter => baseUnitValue / 1e-2,
-                        AreaUnit.SquareFoot => baseUnitValue / 9.290304e-2,
-                        AreaUnit.SquareInch => baseUnitValue / 0.00064516,
-                        AreaUnit.SquareKilometer => baseUnitValue / 1e6,
-                        AreaUnit.SquareMeter => baseUnitValue,
-                        AreaUnit.SquareMicrometer => baseUnitValue / 1e-12,
-                        AreaUnit.SquareMile => baseUnitValue / 1609.344 / 1609.344,
-                        AreaUnit.SquareMillimeter => baseUnitValue / 1e-6,
-                        AreaUnit.SquareNauticalMile => baseUnitValue / 3429904,
-                        AreaUnit.SquareYard => baseUnitValue / 0.9144 / 0.9144,
-                        AreaUnit.UsSurveySquareFoot => baseUnitValue / (1200.0 / 3937.0) / (1200.0 / 3937.0),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/AreaDensity.g.cs
deleted file mode 100644
index 5ba01d91a1..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/AreaDensity.g.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The area density of a two-dimensional object is calculated as the mass per unit area. For paper this is also called grammage.
-    /// </summary>
-    public struct  AreaDensity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly AreaDensityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public AreaDensityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public AreaDensity(double value, AreaDensityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of AreaDensity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static AreaDensityUnit BaseUnit { get; } = AreaDensityUnit.KilogramPerSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of AreaDensity.
-        /// </summary>
-        public static AreaDensity MaxValue { get; } = new AreaDensity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of AreaDensity.
-        /// </summary>
-        public static AreaDensity MinValue { get; } = new AreaDensity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static AreaDensity Zero { get; } = new AreaDensity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaDensityUnit.GramPerSquareMeter"/>
-        /// </summary>
-        public double GramsPerSquareMeter => As(AreaDensityUnit.GramPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaDensityUnit.KilogramPerSquareMeter"/>
-        /// </summary>
-        public double KilogramsPerSquareMeter => As(AreaDensityUnit.KilogramPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaDensityUnit.MilligramPerSquareMeter"/>
-        /// </summary>
-        public double MilligramsPerSquareMeter => As(AreaDensityUnit.MilligramPerSquareMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.GramPerSquareMeter"/>.
-        /// </summary>
-        public static AreaDensity FromGramsPerSquareMeter(double gramspersquaremeter) => new AreaDensity(gramspersquaremeter, AreaDensityUnit.GramPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.KilogramPerSquareMeter"/>.
-        /// </summary>
-        public static AreaDensity FromKilogramsPerSquareMeter(double kilogramspersquaremeter) => new AreaDensity(kilogramspersquaremeter, AreaDensityUnit.KilogramPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.MilligramPerSquareMeter"/>.
-        /// </summary>
-        public static AreaDensity FromMilligramsPerSquareMeter(double milligramspersquaremeter) => new AreaDensity(milligramspersquaremeter, AreaDensityUnit.MilligramPerSquareMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AreaDensityUnit" /> to <see cref="AreaDensity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>AreaDensity unit value.</returns>
-        public static AreaDensity From(double value, AreaDensityUnit fromUnit)
-        {
-            return new AreaDensity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(AreaDensityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this AreaDensity to another AreaDensity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A AreaDensity with the specified unit.</returns>
-                public AreaDensity ToUnit(AreaDensityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new AreaDensity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        AreaDensityUnit.GramPerSquareMeter => _value / 1000,
-                        AreaDensityUnit.KilogramPerSquareMeter => _value,
-                        AreaDensityUnit.MilligramPerSquareMeter => _value / 1000000,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(AreaDensityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        AreaDensityUnit.GramPerSquareMeter => baseUnitValue * 1000,
-                        AreaDensityUnit.KilogramPerSquareMeter => baseUnitValue,
-                        AreaDensityUnit.MilligramPerSquareMeter => baseUnitValue * 1000000,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
deleted file mode 100644
index 6ab4662f32..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
+++ /dev/null
@@ -1,217 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     A geometric property of an area that reflects how its points are distributed with regard to an axis.
-    /// </summary>
-    public struct  AreaMomentOfInertia
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly AreaMomentOfInertiaUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public AreaMomentOfInertiaUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public AreaMomentOfInertia(double value, AreaMomentOfInertiaUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of AreaMomentOfInertia, which is Second. All conversions go via this value.
-        /// </summary>
-        public static AreaMomentOfInertiaUnit BaseUnit { get; } = AreaMomentOfInertiaUnit.MeterToTheFourth;
-
-        /// <summary>
-        /// Represents the largest possible value of AreaMomentOfInertia.
-        /// </summary>
-        public static AreaMomentOfInertia MaxValue { get; } = new AreaMomentOfInertia(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of AreaMomentOfInertia.
-        /// </summary>
-        public static AreaMomentOfInertia MinValue { get; } = new AreaMomentOfInertia(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static AreaMomentOfInertia Zero { get; } = new AreaMomentOfInertia(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.CentimeterToTheFourth"/>
-        /// </summary>
-        public double CentimetersToTheFourth => As(AreaMomentOfInertiaUnit.CentimeterToTheFourth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.DecimeterToTheFourth"/>
-        /// </summary>
-        public double DecimetersToTheFourth => As(AreaMomentOfInertiaUnit.DecimeterToTheFourth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.FootToTheFourth"/>
-        /// </summary>
-        public double FeetToTheFourth => As(AreaMomentOfInertiaUnit.FootToTheFourth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.InchToTheFourth"/>
-        /// </summary>
-        public double InchesToTheFourth => As(AreaMomentOfInertiaUnit.InchToTheFourth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.MeterToTheFourth"/>
-        /// </summary>
-        public double MetersToTheFourth => As(AreaMomentOfInertiaUnit.MeterToTheFourth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.MillimeterToTheFourth"/>
-        /// </summary>
-        public double MillimetersToTheFourth => As(AreaMomentOfInertiaUnit.MillimeterToTheFourth);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.CentimeterToTheFourth"/>.
-        /// </summary>
-        public static AreaMomentOfInertia FromCentimetersToTheFourth(double centimeterstothefourth) => new AreaMomentOfInertia(centimeterstothefourth, AreaMomentOfInertiaUnit.CentimeterToTheFourth);
-
-        /// <summary>
-        ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.DecimeterToTheFourth"/>.
-        /// </summary>
-        public static AreaMomentOfInertia FromDecimetersToTheFourth(double decimeterstothefourth) => new AreaMomentOfInertia(decimeterstothefourth, AreaMomentOfInertiaUnit.DecimeterToTheFourth);
-
-        /// <summary>
-        ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.FootToTheFourth"/>.
-        /// </summary>
-        public static AreaMomentOfInertia FromFeetToTheFourth(double feettothefourth) => new AreaMomentOfInertia(feettothefourth, AreaMomentOfInertiaUnit.FootToTheFourth);
-
-        /// <summary>
-        ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.InchToTheFourth"/>.
-        /// </summary>
-        public static AreaMomentOfInertia FromInchesToTheFourth(double inchestothefourth) => new AreaMomentOfInertia(inchestothefourth, AreaMomentOfInertiaUnit.InchToTheFourth);
-
-        /// <summary>
-        ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.MeterToTheFourth"/>.
-        /// </summary>
-        public static AreaMomentOfInertia FromMetersToTheFourth(double meterstothefourth) => new AreaMomentOfInertia(meterstothefourth, AreaMomentOfInertiaUnit.MeterToTheFourth);
-
-        /// <summary>
-        ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.MillimeterToTheFourth"/>.
-        /// </summary>
-        public static AreaMomentOfInertia FromMillimetersToTheFourth(double millimeterstothefourth) => new AreaMomentOfInertia(millimeterstothefourth, AreaMomentOfInertiaUnit.MillimeterToTheFourth);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="AreaMomentOfInertiaUnit" /> to <see cref="AreaMomentOfInertia" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>AreaMomentOfInertia unit value.</returns>
-        public static AreaMomentOfInertia From(double value, AreaMomentOfInertiaUnit fromUnit)
-        {
-            return new AreaMomentOfInertia(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(AreaMomentOfInertiaUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this AreaMomentOfInertia to another AreaMomentOfInertia with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A AreaMomentOfInertia with the specified unit.</returns>
-                public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new AreaMomentOfInertia(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        AreaMomentOfInertiaUnit.CentimeterToTheFourth => _value / 1e8,
-                        AreaMomentOfInertiaUnit.DecimeterToTheFourth => _value / 1e4,
-                        AreaMomentOfInertiaUnit.FootToTheFourth => _value * 0.0086309748412416,
-                        AreaMomentOfInertiaUnit.InchToTheFourth => _value * 0.0000004162314256,
-                        AreaMomentOfInertiaUnit.MeterToTheFourth => _value,
-                        AreaMomentOfInertiaUnit.MillimeterToTheFourth => _value / 1e12,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(AreaMomentOfInertiaUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        AreaMomentOfInertiaUnit.CentimeterToTheFourth => baseUnitValue * 1e8,
-                        AreaMomentOfInertiaUnit.DecimeterToTheFourth => baseUnitValue * 1e4,
-                        AreaMomentOfInertiaUnit.FootToTheFourth => baseUnitValue / 0.0086309748412416,
-                        AreaMomentOfInertiaUnit.InchToTheFourth => baseUnitValue / 0.0000004162314256,
-                        AreaMomentOfInertiaUnit.MeterToTheFourth => baseUnitValue,
-                        AreaMomentOfInertiaUnit.MillimeterToTheFourth => baseUnitValue * 1e12,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/BitRate.g.cs
deleted file mode 100644
index 1e0227f51f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/BitRate.g.cs
+++ /dev/null
@@ -1,616 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In telecommunications and computing, bit rate is the number of bits that are conveyed or processed per unit of time.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Bit_rate
-    /// </remarks>
-    public struct  BitRate
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly BitRateUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public BitRateUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public BitRate(double value, BitRateUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of BitRate, which is Second. All conversions go via this value.
-        /// </summary>
-        public static BitRateUnit BaseUnit { get; } = BitRateUnit.BitPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of BitRate.
-        /// </summary>
-        public static BitRate MaxValue { get; } = new BitRate(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of BitRate.
-        /// </summary>
-        public static BitRate MinValue { get; } = new BitRate(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static BitRate Zero { get; } = new BitRate(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.BitPerSecond"/>
-        /// </summary>
-        public double BitsPerSecond => As(BitRateUnit.BitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.BytePerSecond"/>
-        /// </summary>
-        public double BytesPerSecond => As(BitRateUnit.BytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExabitPerSecond"/>
-        /// </summary>
-        public double ExabitsPerSecond => As(BitRateUnit.ExabitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExabytePerSecond"/>
-        /// </summary>
-        public double ExabytesPerSecond => As(BitRateUnit.ExabytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExaoctetPerSecond"/>
-        /// </summary>
-        public double ExaoctetsPerSecond => As(BitRateUnit.ExaoctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExbibitPerSecond"/>
-        /// </summary>
-        public double ExbibitsPerSecond => As(BitRateUnit.ExbibitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExbibytePerSecond"/>
-        /// </summary>
-        public double ExbibytesPerSecond => As(BitRateUnit.ExbibytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExbioctetPerSecond"/>
-        /// </summary>
-        public double ExbioctetsPerSecond => As(BitRateUnit.ExbioctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GibibitPerSecond"/>
-        /// </summary>
-        public double GibibitsPerSecond => As(BitRateUnit.GibibitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GibibytePerSecond"/>
-        /// </summary>
-        public double GibibytesPerSecond => As(BitRateUnit.GibibytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GibioctetPerSecond"/>
-        /// </summary>
-        public double GibioctetsPerSecond => As(BitRateUnit.GibioctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GigabitPerSecond"/>
-        /// </summary>
-        public double GigabitsPerSecond => As(BitRateUnit.GigabitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GigabytePerSecond"/>
-        /// </summary>
-        public double GigabytesPerSecond => As(BitRateUnit.GigabytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GigaoctetPerSecond"/>
-        /// </summary>
-        public double GigaoctetsPerSecond => As(BitRateUnit.GigaoctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KibibitPerSecond"/>
-        /// </summary>
-        public double KibibitsPerSecond => As(BitRateUnit.KibibitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KibibytePerSecond"/>
-        /// </summary>
-        public double KibibytesPerSecond => As(BitRateUnit.KibibytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KibioctetPerSecond"/>
-        /// </summary>
-        public double KibioctetsPerSecond => As(BitRateUnit.KibioctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KilobitPerSecond"/>
-        /// </summary>
-        public double KilobitsPerSecond => As(BitRateUnit.KilobitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KilobytePerSecond"/>
-        /// </summary>
-        public double KilobytesPerSecond => As(BitRateUnit.KilobytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KilooctetPerSecond"/>
-        /// </summary>
-        public double KilooctetsPerSecond => As(BitRateUnit.KilooctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MebibitPerSecond"/>
-        /// </summary>
-        public double MebibitsPerSecond => As(BitRateUnit.MebibitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MebibytePerSecond"/>
-        /// </summary>
-        public double MebibytesPerSecond => As(BitRateUnit.MebibytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MebioctetPerSecond"/>
-        /// </summary>
-        public double MebioctetsPerSecond => As(BitRateUnit.MebioctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MegabitPerSecond"/>
-        /// </summary>
-        public double MegabitsPerSecond => As(BitRateUnit.MegabitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MegabytePerSecond"/>
-        /// </summary>
-        public double MegabytesPerSecond => As(BitRateUnit.MegabytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MegaoctetPerSecond"/>
-        /// </summary>
-        public double MegaoctetsPerSecond => As(BitRateUnit.MegaoctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.OctetPerSecond"/>
-        /// </summary>
-        public double OctetsPerSecond => As(BitRateUnit.OctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PebibitPerSecond"/>
-        /// </summary>
-        public double PebibitsPerSecond => As(BitRateUnit.PebibitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PebibytePerSecond"/>
-        /// </summary>
-        public double PebibytesPerSecond => As(BitRateUnit.PebibytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PebioctetPerSecond"/>
-        /// </summary>
-        public double PebioctetsPerSecond => As(BitRateUnit.PebioctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PetabitPerSecond"/>
-        /// </summary>
-        public double PetabitsPerSecond => As(BitRateUnit.PetabitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PetabytePerSecond"/>
-        /// </summary>
-        public double PetabytesPerSecond => As(BitRateUnit.PetabytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PetaoctetPerSecond"/>
-        /// </summary>
-        public double PetaoctetsPerSecond => As(BitRateUnit.PetaoctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TebibitPerSecond"/>
-        /// </summary>
-        public double TebibitsPerSecond => As(BitRateUnit.TebibitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TebibytePerSecond"/>
-        /// </summary>
-        public double TebibytesPerSecond => As(BitRateUnit.TebibytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TebioctetPerSecond"/>
-        /// </summary>
-        public double TebioctetsPerSecond => As(BitRateUnit.TebioctetPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TerabitPerSecond"/>
-        /// </summary>
-        public double TerabitsPerSecond => As(BitRateUnit.TerabitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TerabytePerSecond"/>
-        /// </summary>
-        public double TerabytesPerSecond => As(BitRateUnit.TerabytePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TeraoctetPerSecond"/>
-        /// </summary>
-        public double TeraoctetsPerSecond => As(BitRateUnit.TeraoctetPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.BitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromBitsPerSecond(double bitspersecond) => new BitRate(bitspersecond, BitRateUnit.BitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.BytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromBytesPerSecond(double bytespersecond) => new BitRate(bytespersecond, BitRateUnit.BytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExabitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromExabitsPerSecond(double exabitspersecond) => new BitRate(exabitspersecond, BitRateUnit.ExabitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExabytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromExabytesPerSecond(double exabytespersecond) => new BitRate(exabytespersecond, BitRateUnit.ExabytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExaoctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromExaoctetsPerSecond(double exaoctetspersecond) => new BitRate(exaoctetspersecond, BitRateUnit.ExaoctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExbibitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromExbibitsPerSecond(double exbibitspersecond) => new BitRate(exbibitspersecond, BitRateUnit.ExbibitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExbibytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromExbibytesPerSecond(double exbibytespersecond) => new BitRate(exbibytespersecond, BitRateUnit.ExbibytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExbioctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromExbioctetsPerSecond(double exbioctetspersecond) => new BitRate(exbioctetspersecond, BitRateUnit.ExbioctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GibibitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromGibibitsPerSecond(double gibibitspersecond) => new BitRate(gibibitspersecond, BitRateUnit.GibibitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GibibytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromGibibytesPerSecond(double gibibytespersecond) => new BitRate(gibibytespersecond, BitRateUnit.GibibytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GibioctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromGibioctetsPerSecond(double gibioctetspersecond) => new BitRate(gibioctetspersecond, BitRateUnit.GibioctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GigabitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromGigabitsPerSecond(double gigabitspersecond) => new BitRate(gigabitspersecond, BitRateUnit.GigabitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GigabytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromGigabytesPerSecond(double gigabytespersecond) => new BitRate(gigabytespersecond, BitRateUnit.GigabytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GigaoctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromGigaoctetsPerSecond(double gigaoctetspersecond) => new BitRate(gigaoctetspersecond, BitRateUnit.GigaoctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KibibitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromKibibitsPerSecond(double kibibitspersecond) => new BitRate(kibibitspersecond, BitRateUnit.KibibitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KibibytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromKibibytesPerSecond(double kibibytespersecond) => new BitRate(kibibytespersecond, BitRateUnit.KibibytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KibioctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromKibioctetsPerSecond(double kibioctetspersecond) => new BitRate(kibioctetspersecond, BitRateUnit.KibioctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KilobitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromKilobitsPerSecond(double kilobitspersecond) => new BitRate(kilobitspersecond, BitRateUnit.KilobitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KilobytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromKilobytesPerSecond(double kilobytespersecond) => new BitRate(kilobytespersecond, BitRateUnit.KilobytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KilooctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromKilooctetsPerSecond(double kilooctetspersecond) => new BitRate(kilooctetspersecond, BitRateUnit.KilooctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MebibitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromMebibitsPerSecond(double mebibitspersecond) => new BitRate(mebibitspersecond, BitRateUnit.MebibitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MebibytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromMebibytesPerSecond(double mebibytespersecond) => new BitRate(mebibytespersecond, BitRateUnit.MebibytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MebioctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromMebioctetsPerSecond(double mebioctetspersecond) => new BitRate(mebioctetspersecond, BitRateUnit.MebioctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MegabitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromMegabitsPerSecond(double megabitspersecond) => new BitRate(megabitspersecond, BitRateUnit.MegabitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MegabytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromMegabytesPerSecond(double megabytespersecond) => new BitRate(megabytespersecond, BitRateUnit.MegabytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MegaoctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromMegaoctetsPerSecond(double megaoctetspersecond) => new BitRate(megaoctetspersecond, BitRateUnit.MegaoctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.OctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromOctetsPerSecond(double octetspersecond) => new BitRate(octetspersecond, BitRateUnit.OctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PebibitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromPebibitsPerSecond(double pebibitspersecond) => new BitRate(pebibitspersecond, BitRateUnit.PebibitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PebibytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromPebibytesPerSecond(double pebibytespersecond) => new BitRate(pebibytespersecond, BitRateUnit.PebibytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PebioctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromPebioctetsPerSecond(double pebioctetspersecond) => new BitRate(pebioctetspersecond, BitRateUnit.PebioctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PetabitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromPetabitsPerSecond(double petabitspersecond) => new BitRate(petabitspersecond, BitRateUnit.PetabitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PetabytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromPetabytesPerSecond(double petabytespersecond) => new BitRate(petabytespersecond, BitRateUnit.PetabytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PetaoctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromPetaoctetsPerSecond(double petaoctetspersecond) => new BitRate(petaoctetspersecond, BitRateUnit.PetaoctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TebibitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromTebibitsPerSecond(double tebibitspersecond) => new BitRate(tebibitspersecond, BitRateUnit.TebibitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TebibytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromTebibytesPerSecond(double tebibytespersecond) => new BitRate(tebibytespersecond, BitRateUnit.TebibytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TebioctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromTebioctetsPerSecond(double tebioctetspersecond) => new BitRate(tebioctetspersecond, BitRateUnit.TebioctetPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TerabitPerSecond"/>.
-        /// </summary>
-        public static BitRate FromTerabitsPerSecond(double terabitspersecond) => new BitRate(terabitspersecond, BitRateUnit.TerabitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TerabytePerSecond"/>.
-        /// </summary>
-        public static BitRate FromTerabytesPerSecond(double terabytespersecond) => new BitRate(terabytespersecond, BitRateUnit.TerabytePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TeraoctetPerSecond"/>.
-        /// </summary>
-        public static BitRate FromTeraoctetsPerSecond(double teraoctetspersecond) => new BitRate(teraoctetspersecond, BitRateUnit.TeraoctetPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="BitRateUnit" /> to <see cref="BitRate" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>BitRate unit value.</returns>
-        public static BitRate From(double value, BitRateUnit fromUnit)
-        {
-            return new BitRate(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(BitRateUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this BitRate to another BitRate with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A BitRate with the specified unit.</returns>
-                public BitRate ToUnit(BitRateUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new BitRate(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        BitRateUnit.BitPerSecond => _value,
-                        BitRateUnit.BytePerSecond => _value * 8,
-                        BitRateUnit.ExabitPerSecond => (_value) * 1e18d,
-                        BitRateUnit.ExabytePerSecond => (_value * 8) * 1e18d,
-                        BitRateUnit.ExaoctetPerSecond => (_value * 8) * 1e18d,
-                        BitRateUnit.ExbibitPerSecond => (_value) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.ExbibytePerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.ExbioctetPerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.GibibitPerSecond => (_value) * (1024d * 1024 * 1024),
-                        BitRateUnit.GibibytePerSecond => (_value * 8) * (1024d * 1024 * 1024),
-                        BitRateUnit.GibioctetPerSecond => (_value * 8) * (1024d * 1024 * 1024),
-                        BitRateUnit.GigabitPerSecond => (_value) * 1e9d,
-                        BitRateUnit.GigabytePerSecond => (_value * 8) * 1e9d,
-                        BitRateUnit.GigaoctetPerSecond => (_value * 8) * 1e9d,
-                        BitRateUnit.KibibitPerSecond => (_value) * 1024d,
-                        BitRateUnit.KibibytePerSecond => (_value * 8) * 1024d,
-                        BitRateUnit.KibioctetPerSecond => (_value * 8) * 1024d,
-                        BitRateUnit.KilobitPerSecond => (_value) * 1e3d,
-                        BitRateUnit.KilobytePerSecond => (_value * 8) * 1e3d,
-                        BitRateUnit.KilooctetPerSecond => (_value * 8) * 1e3d,
-                        BitRateUnit.MebibitPerSecond => (_value) * (1024d * 1024),
-                        BitRateUnit.MebibytePerSecond => (_value * 8) * (1024d * 1024),
-                        BitRateUnit.MebioctetPerSecond => (_value * 8) * (1024d * 1024),
-                        BitRateUnit.MegabitPerSecond => (_value) * 1e6d,
-                        BitRateUnit.MegabytePerSecond => (_value * 8) * 1e6d,
-                        BitRateUnit.MegaoctetPerSecond => (_value * 8) * 1e6d,
-                        BitRateUnit.OctetPerSecond => _value * 8,
-                        BitRateUnit.PebibitPerSecond => (_value) * (1024d * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.PebibytePerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.PebioctetPerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.PetabitPerSecond => (_value) * 1e15d,
-                        BitRateUnit.PetabytePerSecond => (_value * 8) * 1e15d,
-                        BitRateUnit.PetaoctetPerSecond => (_value * 8) * 1e15d,
-                        BitRateUnit.TebibitPerSecond => (_value) * (1024d * 1024 * 1024 * 1024),
-                        BitRateUnit.TebibytePerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024),
-                        BitRateUnit.TebioctetPerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024),
-                        BitRateUnit.TerabitPerSecond => (_value) * 1e12d,
-                        BitRateUnit.TerabytePerSecond => (_value * 8) * 1e12d,
-                        BitRateUnit.TeraoctetPerSecond => (_value * 8) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(BitRateUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        BitRateUnit.BitPerSecond => baseUnitValue,
-                        BitRateUnit.BytePerSecond => baseUnitValue / 8,
-                        BitRateUnit.ExabitPerSecond => (baseUnitValue) / 1e18d,
-                        BitRateUnit.ExabytePerSecond => (baseUnitValue / 8) / 1e18d,
-                        BitRateUnit.ExaoctetPerSecond => (baseUnitValue / 8) / 1e18d,
-                        BitRateUnit.ExbibitPerSecond => (baseUnitValue) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.ExbibytePerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.ExbioctetPerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.GibibitPerSecond => (baseUnitValue) / (1024d * 1024 * 1024),
-                        BitRateUnit.GibibytePerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024),
-                        BitRateUnit.GibioctetPerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024),
-                        BitRateUnit.GigabitPerSecond => (baseUnitValue) / 1e9d,
-                        BitRateUnit.GigabytePerSecond => (baseUnitValue / 8) / 1e9d,
-                        BitRateUnit.GigaoctetPerSecond => (baseUnitValue / 8) / 1e9d,
-                        BitRateUnit.KibibitPerSecond => (baseUnitValue) / 1024d,
-                        BitRateUnit.KibibytePerSecond => (baseUnitValue / 8) / 1024d,
-                        BitRateUnit.KibioctetPerSecond => (baseUnitValue / 8) / 1024d,
-                        BitRateUnit.KilobitPerSecond => (baseUnitValue) / 1e3d,
-                        BitRateUnit.KilobytePerSecond => (baseUnitValue / 8) / 1e3d,
-                        BitRateUnit.KilooctetPerSecond => (baseUnitValue / 8) / 1e3d,
-                        BitRateUnit.MebibitPerSecond => (baseUnitValue) / (1024d * 1024),
-                        BitRateUnit.MebibytePerSecond => (baseUnitValue / 8) / (1024d * 1024),
-                        BitRateUnit.MebioctetPerSecond => (baseUnitValue / 8) / (1024d * 1024),
-                        BitRateUnit.MegabitPerSecond => (baseUnitValue) / 1e6d,
-                        BitRateUnit.MegabytePerSecond => (baseUnitValue / 8) / 1e6d,
-                        BitRateUnit.MegaoctetPerSecond => (baseUnitValue / 8) / 1e6d,
-                        BitRateUnit.OctetPerSecond => baseUnitValue / 8,
-                        BitRateUnit.PebibitPerSecond => (baseUnitValue) / (1024d * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.PebibytePerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.PebioctetPerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024),
-                        BitRateUnit.PetabitPerSecond => (baseUnitValue) / 1e15d,
-                        BitRateUnit.PetabytePerSecond => (baseUnitValue / 8) / 1e15d,
-                        BitRateUnit.PetaoctetPerSecond => (baseUnitValue / 8) / 1e15d,
-                        BitRateUnit.TebibitPerSecond => (baseUnitValue) / (1024d * 1024 * 1024 * 1024),
-                        BitRateUnit.TebibytePerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024),
-                        BitRateUnit.TebioctetPerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024),
-                        BitRateUnit.TerabitPerSecond => (baseUnitValue) / 1e12d,
-                        BitRateUnit.TerabytePerSecond => (baseUnitValue / 8) / 1e12d,
-                        BitRateUnit.TeraoctetPerSecond => (baseUnitValue / 8) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
deleted file mode 100644
index 8b57427c8d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Brake specific fuel consumption (BSFC) is a measure of the fuel efficiency of any prime mover that burns fuel and produces rotational, or shaft, power. It is typically used for comparing the efficiency of internal combustion engines with a shaft output.
-    /// </summary>
-    public struct  BrakeSpecificFuelConsumption
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly BrakeSpecificFuelConsumptionUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public BrakeSpecificFuelConsumptionUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public BrakeSpecificFuelConsumption(double value, BrakeSpecificFuelConsumptionUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of BrakeSpecificFuelConsumption, which is Second. All conversions go via this value.
-        /// </summary>
-        public static BrakeSpecificFuelConsumptionUnit BaseUnit { get; } = BrakeSpecificFuelConsumptionUnit.KilogramPerJoule;
-
-        /// <summary>
-        /// Represents the largest possible value of BrakeSpecificFuelConsumption.
-        /// </summary>
-        public static BrakeSpecificFuelConsumption MaxValue { get; } = new BrakeSpecificFuelConsumption(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of BrakeSpecificFuelConsumption.
-        /// </summary>
-        public static BrakeSpecificFuelConsumption MinValue { get; } = new BrakeSpecificFuelConsumption(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static BrakeSpecificFuelConsumption Zero { get; } = new BrakeSpecificFuelConsumption(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour"/>
-        /// </summary>
-        public double GramsPerKiloWattHour => As(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BrakeSpecificFuelConsumptionUnit.KilogramPerJoule"/>
-        /// </summary>
-        public double KilogramsPerJoule => As(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour"/>
-        /// </summary>
-        public double PoundsPerMechanicalHorsepowerHour => As(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour"/>.
-        /// </summary>
-        public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(double gramsperkilowatthour) => new BrakeSpecificFuelConsumption(gramsperkilowatthour, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
-
-        /// <summary>
-        ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.KilogramPerJoule"/>.
-        /// </summary>
-        public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(double kilogramsperjoule) => new BrakeSpecificFuelConsumption(kilogramsperjoule, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
-
-        /// <summary>
-        ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour"/>.
-        /// </summary>
-        public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour(double poundspermechanicalhorsepowerhour) => new BrakeSpecificFuelConsumption(poundspermechanicalhorsepowerhour, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="BrakeSpecificFuelConsumptionUnit" /> to <see cref="BrakeSpecificFuelConsumption" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>BrakeSpecificFuelConsumption unit value.</returns>
-        public static BrakeSpecificFuelConsumption From(double value, BrakeSpecificFuelConsumptionUnit fromUnit)
-        {
-            return new BrakeSpecificFuelConsumption(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(BrakeSpecificFuelConsumptionUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this BrakeSpecificFuelConsumption to another BrakeSpecificFuelConsumption with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A BrakeSpecificFuelConsumption with the specified unit.</returns>
-                public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new BrakeSpecificFuelConsumption(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour => _value / 3.6e9,
-                        BrakeSpecificFuelConsumptionUnit.KilogramPerJoule => _value,
-                        BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour => _value * (0.45359237 / (76.0402249 * 9.80665))/3600,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(BrakeSpecificFuelConsumptionUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour => baseUnitValue * 3.6e9,
-                        BrakeSpecificFuelConsumptionUnit.KilogramPerJoule => baseUnitValue,
-                        BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour => baseUnitValue * 3600 / (0.45359237 / (76.0402249 * 9.80665)),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
deleted file mode 100644
index 473f9bf1cd..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
+++ /dev/null
@@ -1,217 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     A unit that represents a fractional change in size in response to a change in temperature.
-    /// </summary>
-    public struct  CoefficientOfThermalExpansion
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly CoefficientOfThermalExpansionUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public CoefficientOfThermalExpansionUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public CoefficientOfThermalExpansion(double value, CoefficientOfThermalExpansionUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of CoefficientOfThermalExpansion, which is Second. All conversions go via this value.
-        /// </summary>
-        public static CoefficientOfThermalExpansionUnit BaseUnit { get; } = CoefficientOfThermalExpansionUnit.PerKelvin;
-
-        /// <summary>
-        /// Represents the largest possible value of CoefficientOfThermalExpansion.
-        /// </summary>
-        public static CoefficientOfThermalExpansion MaxValue { get; } = new CoefficientOfThermalExpansion(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of CoefficientOfThermalExpansion.
-        /// </summary>
-        public static CoefficientOfThermalExpansion MinValue { get; } = new CoefficientOfThermalExpansion(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static CoefficientOfThermalExpansion Zero { get; } = new CoefficientOfThermalExpansion(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PerDegreeCelsius"/>
-        /// </summary>
-        public double PerDegreeCelsius => As(CoefficientOfThermalExpansionUnit.PerDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit"/>
-        /// </summary>
-        public double PerDegreeFahrenheit => As(CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PerKelvin"/>
-        /// </summary>
-        public double PerKelvin => As(CoefficientOfThermalExpansionUnit.PerKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius"/>
-        /// </summary>
-        public double PpmPerDegreeCelsius => As(CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit"/>
-        /// </summary>
-        public double PpmPerDegreeFahrenheit => As(CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PpmPerKelvin"/>
-        /// </summary>
-        public double PpmPerKelvin => As(CoefficientOfThermalExpansionUnit.PpmPerKelvin);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerDegreeCelsius"/>.
-        /// </summary>
-        public static CoefficientOfThermalExpansion FromPerDegreeCelsius(double perdegreecelsius) => new CoefficientOfThermalExpansion(perdegreecelsius, CoefficientOfThermalExpansionUnit.PerDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit"/>.
-        /// </summary>
-        public static CoefficientOfThermalExpansion FromPerDegreeFahrenheit(double perdegreefahrenheit) => new CoefficientOfThermalExpansion(perdegreefahrenheit, CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit);
-
-        /// <summary>
-        ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerKelvin"/>.
-        /// </summary>
-        public static CoefficientOfThermalExpansion FromPerKelvin(double perkelvin) => new CoefficientOfThermalExpansion(perkelvin, CoefficientOfThermalExpansionUnit.PerKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius"/>.
-        /// </summary>
-        public static CoefficientOfThermalExpansion FromPpmPerDegreeCelsius(double ppmperdegreecelsius) => new CoefficientOfThermalExpansion(ppmperdegreecelsius, CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit"/>.
-        /// </summary>
-        public static CoefficientOfThermalExpansion FromPpmPerDegreeFahrenheit(double ppmperdegreefahrenheit) => new CoefficientOfThermalExpansion(ppmperdegreefahrenheit, CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit);
-
-        /// <summary>
-        ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerKelvin"/>.
-        /// </summary>
-        public static CoefficientOfThermalExpansion FromPpmPerKelvin(double ppmperkelvin) => new CoefficientOfThermalExpansion(ppmperkelvin, CoefficientOfThermalExpansionUnit.PpmPerKelvin);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="CoefficientOfThermalExpansionUnit" /> to <see cref="CoefficientOfThermalExpansion" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>CoefficientOfThermalExpansion unit value.</returns>
-        public static CoefficientOfThermalExpansion From(double value, CoefficientOfThermalExpansionUnit fromUnit)
-        {
-            return new CoefficientOfThermalExpansion(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(CoefficientOfThermalExpansionUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this CoefficientOfThermalExpansion to another CoefficientOfThermalExpansion with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A CoefficientOfThermalExpansion with the specified unit.</returns>
-                public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new CoefficientOfThermalExpansion(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        CoefficientOfThermalExpansionUnit.PerDegreeCelsius => _value,
-                        CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit => _value * 9 / 5,
-                        CoefficientOfThermalExpansionUnit.PerKelvin => _value,
-                        CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius => _value / 1e6,
-                        CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit => _value * 9 / 5e6,
-                        CoefficientOfThermalExpansionUnit.PpmPerKelvin => _value / 1e6,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(CoefficientOfThermalExpansionUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        CoefficientOfThermalExpansionUnit.PerDegreeCelsius => baseUnitValue,
-                        CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit => baseUnitValue * 5 / 9,
-                        CoefficientOfThermalExpansionUnit.PerKelvin => baseUnitValue,
-                        CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius => baseUnitValue * 1e6,
-                        CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit => baseUnitValue * 5e6 / 9,
-                        CoefficientOfThermalExpansionUnit.PpmPerKelvin => baseUnitValue * 1e6,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs
deleted file mode 100644
index 03298e9331..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs
+++ /dev/null
@@ -1,229 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     
-    /// </summary>
-    public struct  Compressibility
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly CompressibilityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public CompressibilityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Compressibility(double value, CompressibilityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Compressibility, which is Second. All conversions go via this value.
-        /// </summary>
-        public static CompressibilityUnit BaseUnit { get; } = CompressibilityUnit.InversePascal;
-
-        /// <summary>
-        /// Represents the largest possible value of Compressibility.
-        /// </summary>
-        public static Compressibility MaxValue { get; } = new Compressibility(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Compressibility.
-        /// </summary>
-        public static Compressibility MinValue { get; } = new Compressibility(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Compressibility Zero { get; } = new Compressibility(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseAtmosphere"/>
-        /// </summary>
-        public double InverseAtmospheres => As(CompressibilityUnit.InverseAtmosphere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseBar"/>
-        /// </summary>
-        public double InverseBars => As(CompressibilityUnit.InverseBar);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseKilopascal"/>
-        /// </summary>
-        public double InverseKilopascals => As(CompressibilityUnit.InverseKilopascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseMegapascal"/>
-        /// </summary>
-        public double InverseMegapascals => As(CompressibilityUnit.InverseMegapascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseMillibar"/>
-        /// </summary>
-        public double InverseMillibars => As(CompressibilityUnit.InverseMillibar);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InversePascal"/>
-        /// </summary>
-        public double InversePascals => As(CompressibilityUnit.InversePascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InversePoundForcePerSquareInch"/>
-        /// </summary>
-        public double InversePoundsForcePerSquareInch => As(CompressibilityUnit.InversePoundForcePerSquareInch);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseAtmosphere"/>.
-        /// </summary>
-        public static Compressibility FromInverseAtmospheres(double inverseatmospheres) => new Compressibility(inverseatmospheres, CompressibilityUnit.InverseAtmosphere);
-
-        /// <summary>
-        ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseBar"/>.
-        /// </summary>
-        public static Compressibility FromInverseBars(double inversebars) => new Compressibility(inversebars, CompressibilityUnit.InverseBar);
-
-        /// <summary>
-        ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseKilopascal"/>.
-        /// </summary>
-        public static Compressibility FromInverseKilopascals(double inversekilopascals) => new Compressibility(inversekilopascals, CompressibilityUnit.InverseKilopascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseMegapascal"/>.
-        /// </summary>
-        public static Compressibility FromInverseMegapascals(double inversemegapascals) => new Compressibility(inversemegapascals, CompressibilityUnit.InverseMegapascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseMillibar"/>.
-        /// </summary>
-        public static Compressibility FromInverseMillibars(double inversemillibars) => new Compressibility(inversemillibars, CompressibilityUnit.InverseMillibar);
-
-        /// <summary>
-        ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InversePascal"/>.
-        /// </summary>
-        public static Compressibility FromInversePascals(double inversepascals) => new Compressibility(inversepascals, CompressibilityUnit.InversePascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InversePoundForcePerSquareInch"/>.
-        /// </summary>
-        public static Compressibility FromInversePoundsForcePerSquareInch(double inversepoundsforcepersquareinch) => new Compressibility(inversepoundsforcepersquareinch, CompressibilityUnit.InversePoundForcePerSquareInch);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="CompressibilityUnit" /> to <see cref="Compressibility" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Compressibility unit value.</returns>
-        public static Compressibility From(double value, CompressibilityUnit fromUnit)
-        {
-            return new Compressibility(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(CompressibilityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Compressibility to another Compressibility with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Compressibility with the specified unit.</returns>
-                public Compressibility ToUnit(CompressibilityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Compressibility(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        CompressibilityUnit.InverseAtmosphere => _value * 101325,
-                        CompressibilityUnit.InverseBar => _value * 1e5,
-                        CompressibilityUnit.InverseKilopascal => _value * 1e3,
-                        CompressibilityUnit.InverseMegapascal => _value * 1e6,
-                        CompressibilityUnit.InverseMillibar => _value * 100,
-                        CompressibilityUnit.InversePascal => _value,
-                        CompressibilityUnit.InversePoundForcePerSquareInch => _value * 6.894757293168361e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(CompressibilityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        CompressibilityUnit.InverseAtmosphere => baseUnitValue / 101325,
-                        CompressibilityUnit.InverseBar => baseUnitValue / 1e5,
-                        CompressibilityUnit.InverseKilopascal => baseUnitValue / 1e3,
-                        CompressibilityUnit.InverseMegapascal => baseUnitValue / 1e6,
-                        CompressibilityUnit.InverseMillibar => baseUnitValue / 100,
-                        CompressibilityUnit.InversePascal => baseUnitValue,
-                        CompressibilityUnit.InversePoundForcePerSquareInch => baseUnitValue / 6.894757293168361e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Density.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Density.g.cs
deleted file mode 100644
index 069b1d250f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Density.g.cs
+++ /dev/null
@@ -1,820 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The density, or more precisely, the volumetric mass density, of a substance is its mass per unit volume.
-    /// </summary>
-    /// <remarks>
-    ///     http://en.wikipedia.org/wiki/Density
-    /// </remarks>
-    public struct  Density
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly DensityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public DensityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Density(double value, DensityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Density, which is Second. All conversions go via this value.
-        /// </summary>
-        public static DensityUnit BaseUnit { get; } = DensityUnit.KilogramPerCubicMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Density.
-        /// </summary>
-        public static Density MaxValue { get; } = new Density(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Density.
-        /// </summary>
-        public static Density MinValue { get; } = new Density(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Density Zero { get; } = new Density(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.CentigramPerDeciliter"/>
-        /// </summary>
-        public double CentigramsPerDeciliter => As(DensityUnit.CentigramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.CentigramPerLiter"/>
-        /// </summary>
-        public double CentigramsPerLiter => As(DensityUnit.CentigramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.CentigramPerMilliliter"/>
-        /// </summary>
-        public double CentigramsPerMilliliter => As(DensityUnit.CentigramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.DecigramPerDeciliter"/>
-        /// </summary>
-        public double DecigramsPerDeciliter => As(DensityUnit.DecigramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.DecigramPerLiter"/>
-        /// </summary>
-        public double DecigramsPerLiter => As(DensityUnit.DecigramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.DecigramPerMilliliter"/>
-        /// </summary>
-        public double DecigramsPerMilliliter => As(DensityUnit.DecigramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.FemtogramPerDeciliter"/>
-        /// </summary>
-        public double FemtogramsPerDeciliter => As(DensityUnit.FemtogramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.FemtogramPerLiter"/>
-        /// </summary>
-        public double FemtogramsPerLiter => As(DensityUnit.FemtogramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.FemtogramPerMilliliter"/>
-        /// </summary>
-        public double FemtogramsPerMilliliter => As(DensityUnit.FemtogramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicCentimeter"/>
-        /// </summary>
-        public double GramsPerCubicCentimeter => As(DensityUnit.GramPerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicFoot"/>
-        /// </summary>
-        public double GramsPerCubicFoot => As(DensityUnit.GramPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicInch"/>
-        /// </summary>
-        public double GramsPerCubicInch => As(DensityUnit.GramPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicMeter"/>
-        /// </summary>
-        public double GramsPerCubicMeter => As(DensityUnit.GramPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicMillimeter"/>
-        /// </summary>
-        public double GramsPerCubicMillimeter => As(DensityUnit.GramPerCubicMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerDeciliter"/>
-        /// </summary>
-        public double GramsPerDeciliter => As(DensityUnit.GramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerLiter"/>
-        /// </summary>
-        public double GramsPerLiter => As(DensityUnit.GramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerMilliliter"/>
-        /// </summary>
-        public double GramsPerMilliliter => As(DensityUnit.GramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerCubicCentimeter"/>
-        /// </summary>
-        public double KilogramsPerCubicCentimeter => As(DensityUnit.KilogramPerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerCubicMeter"/>
-        /// </summary>
-        public double KilogramsPerCubicMeter => As(DensityUnit.KilogramPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerCubicMillimeter"/>
-        /// </summary>
-        public double KilogramsPerCubicMillimeter => As(DensityUnit.KilogramPerCubicMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerLiter"/>
-        /// </summary>
-        public double KilogramsPerLiter => As(DensityUnit.KilogramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilopoundPerCubicFoot"/>
-        /// </summary>
-        public double KilopoundsPerCubicFoot => As(DensityUnit.KilopoundPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilopoundPerCubicInch"/>
-        /// </summary>
-        public double KilopoundsPerCubicInch => As(DensityUnit.KilopoundPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilopoundPerCubicYard"/>
-        /// </summary>
-        public double KilopoundsPerCubicYard => As(DensityUnit.KilopoundPerCubicYard);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerCubicMeter"/>
-        /// </summary>
-        public double MicrogramsPerCubicMeter => As(DensityUnit.MicrogramPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerDeciliter"/>
-        /// </summary>
-        public double MicrogramsPerDeciliter => As(DensityUnit.MicrogramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerLiter"/>
-        /// </summary>
-        public double MicrogramsPerLiter => As(DensityUnit.MicrogramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerMilliliter"/>
-        /// </summary>
-        public double MicrogramsPerMilliliter => As(DensityUnit.MicrogramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerCubicMeter"/>
-        /// </summary>
-        public double MilligramsPerCubicMeter => As(DensityUnit.MilligramPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerDeciliter"/>
-        /// </summary>
-        public double MilligramsPerDeciliter => As(DensityUnit.MilligramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerLiter"/>
-        /// </summary>
-        public double MilligramsPerLiter => As(DensityUnit.MilligramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerMilliliter"/>
-        /// </summary>
-        public double MilligramsPerMilliliter => As(DensityUnit.MilligramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.NanogramPerDeciliter"/>
-        /// </summary>
-        public double NanogramsPerDeciliter => As(DensityUnit.NanogramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.NanogramPerLiter"/>
-        /// </summary>
-        public double NanogramsPerLiter => As(DensityUnit.NanogramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.NanogramPerMilliliter"/>
-        /// </summary>
-        public double NanogramsPerMilliliter => As(DensityUnit.NanogramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PicogramPerDeciliter"/>
-        /// </summary>
-        public double PicogramsPerDeciliter => As(DensityUnit.PicogramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PicogramPerLiter"/>
-        /// </summary>
-        public double PicogramsPerLiter => As(DensityUnit.PicogramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PicogramPerMilliliter"/>
-        /// </summary>
-        public double PicogramsPerMilliliter => As(DensityUnit.PicogramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicCentimeter"/>
-        /// </summary>
-        public double PoundsPerCubicCentimeter => As(DensityUnit.PoundPerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicFoot"/>
-        /// </summary>
-        public double PoundsPerCubicFoot => As(DensityUnit.PoundPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicInch"/>
-        /// </summary>
-        public double PoundsPerCubicInch => As(DensityUnit.PoundPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicMeter"/>
-        /// </summary>
-        public double PoundsPerCubicMeter => As(DensityUnit.PoundPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicMillimeter"/>
-        /// </summary>
-        public double PoundsPerCubicMillimeter => As(DensityUnit.PoundPerCubicMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicYard"/>
-        /// </summary>
-        public double PoundsPerCubicYard => As(DensityUnit.PoundPerCubicYard);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerImperialGallon"/>
-        /// </summary>
-        public double PoundsPerImperialGallon => As(DensityUnit.PoundPerImperialGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerUSGallon"/>
-        /// </summary>
-        public double PoundsPerUSGallon => As(DensityUnit.PoundPerUSGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicCentimeter"/>
-        /// </summary>
-        public double SlugsPerCubicCentimeter => As(DensityUnit.SlugPerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicFoot"/>
-        /// </summary>
-        public double SlugsPerCubicFoot => As(DensityUnit.SlugPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicInch"/>
-        /// </summary>
-        public double SlugsPerCubicInch => As(DensityUnit.SlugPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicMeter"/>
-        /// </summary>
-        public double SlugsPerCubicMeter => As(DensityUnit.SlugPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicMillimeter"/>
-        /// </summary>
-        public double SlugsPerCubicMillimeter => As(DensityUnit.SlugPerCubicMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicCentimeter"/>
-        /// </summary>
-        public double TonnesPerCubicCentimeter => As(DensityUnit.TonnePerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicFoot"/>
-        /// </summary>
-        public double TonnesPerCubicFoot => As(DensityUnit.TonnePerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicInch"/>
-        /// </summary>
-        public double TonnesPerCubicInch => As(DensityUnit.TonnePerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicMeter"/>
-        /// </summary>
-        public double TonnesPerCubicMeter => As(DensityUnit.TonnePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicMillimeter"/>
-        /// </summary>
-        public double TonnesPerCubicMillimeter => As(DensityUnit.TonnePerCubicMillimeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerDeciliter"/>.
-        /// </summary>
-        public static Density FromCentigramsPerDeciliter(double centigramsperdeciliter) => new Density(centigramsperdeciliter, DensityUnit.CentigramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerLiter"/>.
-        /// </summary>
-        public static Density FromCentigramsPerLiter(double centigramsperliter) => new Density(centigramsperliter, DensityUnit.CentigramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerMilliliter"/>.
-        /// </summary>
-        public static Density FromCentigramsPerMilliliter(double centigramspermilliliter) => new Density(centigramspermilliliter, DensityUnit.CentigramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerDeciliter"/>.
-        /// </summary>
-        public static Density FromDecigramsPerDeciliter(double decigramsperdeciliter) => new Density(decigramsperdeciliter, DensityUnit.DecigramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerLiter"/>.
-        /// </summary>
-        public static Density FromDecigramsPerLiter(double decigramsperliter) => new Density(decigramsperliter, DensityUnit.DecigramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerMilliliter"/>.
-        /// </summary>
-        public static Density FromDecigramsPerMilliliter(double decigramspermilliliter) => new Density(decigramspermilliliter, DensityUnit.DecigramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerDeciliter"/>.
-        /// </summary>
-        public static Density FromFemtogramsPerDeciliter(double femtogramsperdeciliter) => new Density(femtogramsperdeciliter, DensityUnit.FemtogramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerLiter"/>.
-        /// </summary>
-        public static Density FromFemtogramsPerLiter(double femtogramsperliter) => new Density(femtogramsperliter, DensityUnit.FemtogramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerMilliliter"/>.
-        /// </summary>
-        public static Density FromFemtogramsPerMilliliter(double femtogramspermilliliter) => new Density(femtogramspermilliliter, DensityUnit.FemtogramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicCentimeter"/>.
-        /// </summary>
-        public static Density FromGramsPerCubicCentimeter(double gramspercubiccentimeter) => new Density(gramspercubiccentimeter, DensityUnit.GramPerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicFoot"/>.
-        /// </summary>
-        public static Density FromGramsPerCubicFoot(double gramspercubicfoot) => new Density(gramspercubicfoot, DensityUnit.GramPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicInch"/>.
-        /// </summary>
-        public static Density FromGramsPerCubicInch(double gramspercubicinch) => new Density(gramspercubicinch, DensityUnit.GramPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicMeter"/>.
-        /// </summary>
-        public static Density FromGramsPerCubicMeter(double gramspercubicmeter) => new Density(gramspercubicmeter, DensityUnit.GramPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicMillimeter"/>.
-        /// </summary>
-        public static Density FromGramsPerCubicMillimeter(double gramspercubicmillimeter) => new Density(gramspercubicmillimeter, DensityUnit.GramPerCubicMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerDeciliter"/>.
-        /// </summary>
-        public static Density FromGramsPerDeciliter(double gramsperdeciliter) => new Density(gramsperdeciliter, DensityUnit.GramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerLiter"/>.
-        /// </summary>
-        public static Density FromGramsPerLiter(double gramsperliter) => new Density(gramsperliter, DensityUnit.GramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerMilliliter"/>.
-        /// </summary>
-        public static Density FromGramsPerMilliliter(double gramspermilliliter) => new Density(gramspermilliliter, DensityUnit.GramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicCentimeter"/>.
-        /// </summary>
-        public static Density FromKilogramsPerCubicCentimeter(double kilogramspercubiccentimeter) => new Density(kilogramspercubiccentimeter, DensityUnit.KilogramPerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicMeter"/>.
-        /// </summary>
-        public static Density FromKilogramsPerCubicMeter(double kilogramspercubicmeter) => new Density(kilogramspercubicmeter, DensityUnit.KilogramPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicMillimeter"/>.
-        /// </summary>
-        public static Density FromKilogramsPerCubicMillimeter(double kilogramspercubicmillimeter) => new Density(kilogramspercubicmillimeter, DensityUnit.KilogramPerCubicMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerLiter"/>.
-        /// </summary>
-        public static Density FromKilogramsPerLiter(double kilogramsperliter) => new Density(kilogramsperliter, DensityUnit.KilogramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicFoot"/>.
-        /// </summary>
-        public static Density FromKilopoundsPerCubicFoot(double kilopoundspercubicfoot) => new Density(kilopoundspercubicfoot, DensityUnit.KilopoundPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicInch"/>.
-        /// </summary>
-        public static Density FromKilopoundsPerCubicInch(double kilopoundspercubicinch) => new Density(kilopoundspercubicinch, DensityUnit.KilopoundPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicYard"/>.
-        /// </summary>
-        public static Density FromKilopoundsPerCubicYard(double kilopoundspercubicyard) => new Density(kilopoundspercubicyard, DensityUnit.KilopoundPerCubicYard);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerCubicMeter"/>.
-        /// </summary>
-        public static Density FromMicrogramsPerCubicMeter(double microgramspercubicmeter) => new Density(microgramspercubicmeter, DensityUnit.MicrogramPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerDeciliter"/>.
-        /// </summary>
-        public static Density FromMicrogramsPerDeciliter(double microgramsperdeciliter) => new Density(microgramsperdeciliter, DensityUnit.MicrogramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerLiter"/>.
-        /// </summary>
-        public static Density FromMicrogramsPerLiter(double microgramsperliter) => new Density(microgramsperliter, DensityUnit.MicrogramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerMilliliter"/>.
-        /// </summary>
-        public static Density FromMicrogramsPerMilliliter(double microgramspermilliliter) => new Density(microgramspermilliliter, DensityUnit.MicrogramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerCubicMeter"/>.
-        /// </summary>
-        public static Density FromMilligramsPerCubicMeter(double milligramspercubicmeter) => new Density(milligramspercubicmeter, DensityUnit.MilligramPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerDeciliter"/>.
-        /// </summary>
-        public static Density FromMilligramsPerDeciliter(double milligramsperdeciliter) => new Density(milligramsperdeciliter, DensityUnit.MilligramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerLiter"/>.
-        /// </summary>
-        public static Density FromMilligramsPerLiter(double milligramsperliter) => new Density(milligramsperliter, DensityUnit.MilligramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerMilliliter"/>.
-        /// </summary>
-        public static Density FromMilligramsPerMilliliter(double milligramspermilliliter) => new Density(milligramspermilliliter, DensityUnit.MilligramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerDeciliter"/>.
-        /// </summary>
-        public static Density FromNanogramsPerDeciliter(double nanogramsperdeciliter) => new Density(nanogramsperdeciliter, DensityUnit.NanogramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerLiter"/>.
-        /// </summary>
-        public static Density FromNanogramsPerLiter(double nanogramsperliter) => new Density(nanogramsperliter, DensityUnit.NanogramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerMilliliter"/>.
-        /// </summary>
-        public static Density FromNanogramsPerMilliliter(double nanogramspermilliliter) => new Density(nanogramspermilliliter, DensityUnit.NanogramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerDeciliter"/>.
-        /// </summary>
-        public static Density FromPicogramsPerDeciliter(double picogramsperdeciliter) => new Density(picogramsperdeciliter, DensityUnit.PicogramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerLiter"/>.
-        /// </summary>
-        public static Density FromPicogramsPerLiter(double picogramsperliter) => new Density(picogramsperliter, DensityUnit.PicogramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerMilliliter"/>.
-        /// </summary>
-        public static Density FromPicogramsPerMilliliter(double picogramspermilliliter) => new Density(picogramspermilliliter, DensityUnit.PicogramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicCentimeter"/>.
-        /// </summary>
-        public static Density FromPoundsPerCubicCentimeter(double poundspercubiccentimeter) => new Density(poundspercubiccentimeter, DensityUnit.PoundPerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicFoot"/>.
-        /// </summary>
-        public static Density FromPoundsPerCubicFoot(double poundspercubicfoot) => new Density(poundspercubicfoot, DensityUnit.PoundPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicInch"/>.
-        /// </summary>
-        public static Density FromPoundsPerCubicInch(double poundspercubicinch) => new Density(poundspercubicinch, DensityUnit.PoundPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicMeter"/>.
-        /// </summary>
-        public static Density FromPoundsPerCubicMeter(double poundspercubicmeter) => new Density(poundspercubicmeter, DensityUnit.PoundPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicMillimeter"/>.
-        /// </summary>
-        public static Density FromPoundsPerCubicMillimeter(double poundspercubicmillimeter) => new Density(poundspercubicmillimeter, DensityUnit.PoundPerCubicMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicYard"/>.
-        /// </summary>
-        public static Density FromPoundsPerCubicYard(double poundspercubicyard) => new Density(poundspercubicyard, DensityUnit.PoundPerCubicYard);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerImperialGallon"/>.
-        /// </summary>
-        public static Density FromPoundsPerImperialGallon(double poundsperimperialgallon) => new Density(poundsperimperialgallon, DensityUnit.PoundPerImperialGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerUSGallon"/>.
-        /// </summary>
-        public static Density FromPoundsPerUSGallon(double poundsperusgallon) => new Density(poundsperusgallon, DensityUnit.PoundPerUSGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicCentimeter"/>.
-        /// </summary>
-        public static Density FromSlugsPerCubicCentimeter(double slugspercubiccentimeter) => new Density(slugspercubiccentimeter, DensityUnit.SlugPerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicFoot"/>.
-        /// </summary>
-        public static Density FromSlugsPerCubicFoot(double slugspercubicfoot) => new Density(slugspercubicfoot, DensityUnit.SlugPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicInch"/>.
-        /// </summary>
-        public static Density FromSlugsPerCubicInch(double slugspercubicinch) => new Density(slugspercubicinch, DensityUnit.SlugPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicMeter"/>.
-        /// </summary>
-        public static Density FromSlugsPerCubicMeter(double slugspercubicmeter) => new Density(slugspercubicmeter, DensityUnit.SlugPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicMillimeter"/>.
-        /// </summary>
-        public static Density FromSlugsPerCubicMillimeter(double slugspercubicmillimeter) => new Density(slugspercubicmillimeter, DensityUnit.SlugPerCubicMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicCentimeter"/>.
-        /// </summary>
-        public static Density FromTonnesPerCubicCentimeter(double tonnespercubiccentimeter) => new Density(tonnespercubiccentimeter, DensityUnit.TonnePerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicFoot"/>.
-        /// </summary>
-        public static Density FromTonnesPerCubicFoot(double tonnespercubicfoot) => new Density(tonnespercubicfoot, DensityUnit.TonnePerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicInch"/>.
-        /// </summary>
-        public static Density FromTonnesPerCubicInch(double tonnespercubicinch) => new Density(tonnespercubicinch, DensityUnit.TonnePerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicMeter"/>.
-        /// </summary>
-        public static Density FromTonnesPerCubicMeter(double tonnespercubicmeter) => new Density(tonnespercubicmeter, DensityUnit.TonnePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicMillimeter"/>.
-        /// </summary>
-        public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimeter) => new Density(tonnespercubicmillimeter, DensityUnit.TonnePerCubicMillimeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="DensityUnit" /> to <see cref="Density" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Density unit value.</returns>
-        public static Density From(double value, DensityUnit fromUnit)
-        {
-            return new Density(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(DensityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Density to another Density with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Density with the specified unit.</returns>
-                public Density ToUnit(DensityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Density(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        DensityUnit.CentigramPerDeciliter => (_value / 1e-1) * 1e-2d,
-                        DensityUnit.CentigramPerLiter => (_value / 1) * 1e-2d,
-                        DensityUnit.CentigramPerMilliliter => (_value / 1e-3) * 1e-2d,
-                        DensityUnit.DecigramPerDeciliter => (_value / 1e-1) * 1e-1d,
-                        DensityUnit.DecigramPerLiter => (_value / 1) * 1e-1d,
-                        DensityUnit.DecigramPerMilliliter => (_value / 1e-3) * 1e-1d,
-                        DensityUnit.FemtogramPerDeciliter => (_value / 1e-1) * 1e-15d,
-                        DensityUnit.FemtogramPerLiter => (_value / 1) * 1e-15d,
-                        DensityUnit.FemtogramPerMilliliter => (_value / 1e-3) * 1e-15d,
-                        DensityUnit.GramPerCubicCentimeter => _value / 1e-3,
-                        DensityUnit.GramPerCubicFoot => _value * 0.001 / 0.028316846592,
-                        DensityUnit.GramPerCubicInch => _value * 0.001 / 1.6387064e-5,
-                        DensityUnit.GramPerCubicMeter => _value / 1e3,
-                        DensityUnit.GramPerCubicMillimeter => _value / 1e-6,
-                        DensityUnit.GramPerDeciliter => _value / 1e-1,
-                        DensityUnit.GramPerLiter => _value / 1,
-                        DensityUnit.GramPerMilliliter => _value / 1e-3,
-                        DensityUnit.KilogramPerCubicCentimeter => (_value / 1e-3) * 1e3d,
-                        DensityUnit.KilogramPerCubicMeter => (_value / 1e3) * 1e3d,
-                        DensityUnit.KilogramPerCubicMillimeter => (_value / 1e-6) * 1e3d,
-                        DensityUnit.KilogramPerLiter => _value * 1e3,
-                        DensityUnit.KilopoundPerCubicFoot => (_value * 0.45359237 / 0.028316846592) * 1e3d,
-                        DensityUnit.KilopoundPerCubicInch => (_value * 0.45359237 / 1.6387064e-5) * 1e3d,
-                        DensityUnit.KilopoundPerCubicYard => (_value * 0.45359237 / 0.764554857984) * 1e3d,
-                        DensityUnit.MicrogramPerCubicMeter => (_value / 1e3) * 1e-6d,
-                        DensityUnit.MicrogramPerDeciliter => (_value / 1e-1) * 1e-6d,
-                        DensityUnit.MicrogramPerLiter => (_value / 1) * 1e-6d,
-                        DensityUnit.MicrogramPerMilliliter => (_value / 1e-3) * 1e-6d,
-                        DensityUnit.MilligramPerCubicMeter => (_value / 1e3) * 1e-3d,
-                        DensityUnit.MilligramPerDeciliter => (_value / 1e-1) * 1e-3d,
-                        DensityUnit.MilligramPerLiter => (_value / 1) * 1e-3d,
-                        DensityUnit.MilligramPerMilliliter => (_value / 1e-3) * 1e-3d,
-                        DensityUnit.NanogramPerDeciliter => (_value / 1e-1) * 1e-9d,
-                        DensityUnit.NanogramPerLiter => (_value / 1) * 1e-9d,
-                        DensityUnit.NanogramPerMilliliter => (_value / 1e-3) * 1e-9d,
-                        DensityUnit.PicogramPerDeciliter => (_value / 1e-1) * 1e-12d,
-                        DensityUnit.PicogramPerLiter => (_value / 1) * 1e-12d,
-                        DensityUnit.PicogramPerMilliliter => (_value / 1e-3) * 1e-12d,
-                        DensityUnit.PoundPerCubicCentimeter => _value * 0.45359237e6,
-                        DensityUnit.PoundPerCubicFoot => _value * 0.45359237 / 0.028316846592,
-                        DensityUnit.PoundPerCubicInch => _value * 0.45359237 / 1.6387064e-5,
-                        DensityUnit.PoundPerCubicMeter => _value * 0.45359237,
-                        DensityUnit.PoundPerCubicMillimeter => _value * 0.45359237e9,
-                        DensityUnit.PoundPerCubicYard => _value * 0.45359237 / 0.764554857984,
-                        DensityUnit.PoundPerImperialGallon => _value * 0.45359237 / 0.00454609,
-                        DensityUnit.PoundPerUSGallon => _value * 0.45359237 / 0.003785411784,
-                        DensityUnit.SlugPerCubicCentimeter => _value * 0.45359237e6 * 9.80665 / 0.3048,
-                        DensityUnit.SlugPerCubicFoot => _value * (0.45359237 * 9.80665) / (0.3048 * 0.028316846592),
-                        DensityUnit.SlugPerCubicInch => _value * (0.45359237 * 9.80665) / (0.3048 * 1.6387064e-5),
-                        DensityUnit.SlugPerCubicMeter => _value * 0.45359237 * 9.80665 / 0.3048,
-                        DensityUnit.SlugPerCubicMillimeter => _value * 0.45359237e9 * 9.80665 / 0.3048,
-                        DensityUnit.TonnePerCubicCentimeter => _value / 1e-9,
-                        DensityUnit.TonnePerCubicFoot => _value * 1000 / 0.028316846592,
-                        DensityUnit.TonnePerCubicInch => _value * 1000 / 1.6387064e-5,
-                        DensityUnit.TonnePerCubicMeter => _value / 0.001,
-                        DensityUnit.TonnePerCubicMillimeter => _value / 1e-12,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(DensityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        DensityUnit.CentigramPerDeciliter => (baseUnitValue * 1e-1) / 1e-2d,
-                        DensityUnit.CentigramPerLiter => (baseUnitValue * 1) / 1e-2d,
-                        DensityUnit.CentigramPerMilliliter => (baseUnitValue * 1e-3) / 1e-2d,
-                        DensityUnit.DecigramPerDeciliter => (baseUnitValue * 1e-1) / 1e-1d,
-                        DensityUnit.DecigramPerLiter => (baseUnitValue * 1) / 1e-1d,
-                        DensityUnit.DecigramPerMilliliter => (baseUnitValue * 1e-3) / 1e-1d,
-                        DensityUnit.FemtogramPerDeciliter => (baseUnitValue * 1e-1) / 1e-15d,
-                        DensityUnit.FemtogramPerLiter => (baseUnitValue * 1) / 1e-15d,
-                        DensityUnit.FemtogramPerMilliliter => (baseUnitValue * 1e-3) / 1e-15d,
-                        DensityUnit.GramPerCubicCentimeter => baseUnitValue * 1e-3,
-                        DensityUnit.GramPerCubicFoot => baseUnitValue * 0.028316846592 / 0.001,
-                        DensityUnit.GramPerCubicInch => baseUnitValue * 1.6387064e-5 / 0.001,
-                        DensityUnit.GramPerCubicMeter => baseUnitValue * 1e3,
-                        DensityUnit.GramPerCubicMillimeter => baseUnitValue * 1e-6,
-                        DensityUnit.GramPerDeciliter => baseUnitValue * 1e-1,
-                        DensityUnit.GramPerLiter => baseUnitValue * 1,
-                        DensityUnit.GramPerMilliliter => baseUnitValue * 1e-3,
-                        DensityUnit.KilogramPerCubicCentimeter => (baseUnitValue * 1e-3) / 1e3d,
-                        DensityUnit.KilogramPerCubicMeter => (baseUnitValue * 1e3) / 1e3d,
-                        DensityUnit.KilogramPerCubicMillimeter => (baseUnitValue * 1e-6) / 1e3d,
-                        DensityUnit.KilogramPerLiter => baseUnitValue / 1e3,
-                        DensityUnit.KilopoundPerCubicFoot => (baseUnitValue * 0.028316846592 / 0.45359237) / 1e3d,
-                        DensityUnit.KilopoundPerCubicInch => (baseUnitValue * 1.6387064e-5 / 0.45359237) / 1e3d,
-                        DensityUnit.KilopoundPerCubicYard => (baseUnitValue * 0.764554857984 / 0.45359237) / 1e3d,
-                        DensityUnit.MicrogramPerCubicMeter => (baseUnitValue * 1e3) / 1e-6d,
-                        DensityUnit.MicrogramPerDeciliter => (baseUnitValue * 1e-1) / 1e-6d,
-                        DensityUnit.MicrogramPerLiter => (baseUnitValue * 1) / 1e-6d,
-                        DensityUnit.MicrogramPerMilliliter => (baseUnitValue * 1e-3) / 1e-6d,
-                        DensityUnit.MilligramPerCubicMeter => (baseUnitValue * 1e3) / 1e-3d,
-                        DensityUnit.MilligramPerDeciliter => (baseUnitValue * 1e-1) / 1e-3d,
-                        DensityUnit.MilligramPerLiter => (baseUnitValue * 1) / 1e-3d,
-                        DensityUnit.MilligramPerMilliliter => (baseUnitValue * 1e-3) / 1e-3d,
-                        DensityUnit.NanogramPerDeciliter => (baseUnitValue * 1e-1) / 1e-9d,
-                        DensityUnit.NanogramPerLiter => (baseUnitValue * 1) / 1e-9d,
-                        DensityUnit.NanogramPerMilliliter => (baseUnitValue * 1e-3) / 1e-9d,
-                        DensityUnit.PicogramPerDeciliter => (baseUnitValue * 1e-1) / 1e-12d,
-                        DensityUnit.PicogramPerLiter => (baseUnitValue * 1) / 1e-12d,
-                        DensityUnit.PicogramPerMilliliter => (baseUnitValue * 1e-3) / 1e-12d,
-                        DensityUnit.PoundPerCubicCentimeter => baseUnitValue / 0.45359237e6,
-                        DensityUnit.PoundPerCubicFoot => baseUnitValue * 0.028316846592 / 0.45359237,
-                        DensityUnit.PoundPerCubicInch => baseUnitValue * 1.6387064e-5 / 0.45359237,
-                        DensityUnit.PoundPerCubicMeter => baseUnitValue / 0.45359237,
-                        DensityUnit.PoundPerCubicMillimeter => baseUnitValue / 0.45359237e9,
-                        DensityUnit.PoundPerCubicYard => baseUnitValue * 0.764554857984 / 0.45359237,
-                        DensityUnit.PoundPerImperialGallon => baseUnitValue * 0.00454609 / 0.45359237,
-                        DensityUnit.PoundPerUSGallon => baseUnitValue * 0.003785411784 / 0.45359237,
-                        DensityUnit.SlugPerCubicCentimeter => baseUnitValue * 0.3048 / (0.45359237e6 * 9.80665),
-                        DensityUnit.SlugPerCubicFoot => baseUnitValue * (0.3048 * 0.028316846592) / (0.45359237 * 9.80665),
-                        DensityUnit.SlugPerCubicInch => baseUnitValue * (0.3048 * 1.6387064e-5) / (0.45359237 * 9.80665),
-                        DensityUnit.SlugPerCubicMeter => baseUnitValue * 0.3048 / (0.45359237 * 9.80665),
-                        DensityUnit.SlugPerCubicMillimeter => baseUnitValue * 0.3048 / (0.45359237e9 * 9.80665),
-                        DensityUnit.TonnePerCubicCentimeter => baseUnitValue * 1e-9,
-                        DensityUnit.TonnePerCubicFoot => baseUnitValue * 0.028316846592 / 1000,
-                        DensityUnit.TonnePerCubicInch => baseUnitValue * 1.6387064e-5 / 1000,
-                        DensityUnit.TonnePerCubicMeter => baseUnitValue * 0.001,
-                        DensityUnit.TonnePerCubicMillimeter => baseUnitValue * 1e-12,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/DoseAreaProduct.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/DoseAreaProduct.g.cs
deleted file mode 100644
index 60ad5a2b80..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/DoseAreaProduct.g.cs
+++ /dev/null
@@ -1,448 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     It is defined as the absorbed dose multiplied by the area irradiated.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Dose_area_product
-    /// </remarks>
-    public struct  DoseAreaProduct
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly DoseAreaProductUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public DoseAreaProductUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public DoseAreaProduct(double value, DoseAreaProductUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of DoseAreaProduct, which is Second. All conversions go via this value.
-        /// </summary>
-        public static DoseAreaProductUnit BaseUnit { get; } = DoseAreaProductUnit.GraySquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of DoseAreaProduct.
-        /// </summary>
-        public static DoseAreaProduct MaxValue { get; } = new DoseAreaProduct(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of DoseAreaProduct.
-        /// </summary>
-        public static DoseAreaProduct MinValue { get; } = new DoseAreaProduct(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static DoseAreaProduct Zero { get; } = new DoseAreaProduct(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareCentimeter"/>
-        /// </summary>
-        public double CentigraySquareCentimeters => As(DoseAreaProductUnit.CentigraySquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareDecimeter"/>
-        /// </summary>
-        public double CentigraySquareDecimeters => As(DoseAreaProductUnit.CentigraySquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareMeter"/>
-        /// </summary>
-        public double CentigraySquareMeters => As(DoseAreaProductUnit.CentigraySquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareMicrometer"/>
-        /// </summary>
-        public double CentigraySquareMicrometers => As(DoseAreaProductUnit.CentigraySquareMicrometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareMillimeter"/>
-        /// </summary>
-        public double CentigraySquareMillimeters => As(DoseAreaProductUnit.CentigraySquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareCentimeter"/>
-        /// </summary>
-        public double DecigraySquareCentimeters => As(DoseAreaProductUnit.DecigraySquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareDecimeter"/>
-        /// </summary>
-        public double DecigraySquareDecimeters => As(DoseAreaProductUnit.DecigraySquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareMeter"/>
-        /// </summary>
-        public double DecigraySquareMeters => As(DoseAreaProductUnit.DecigraySquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareMicrometer"/>
-        /// </summary>
-        public double DecigraySquareMicrometers => As(DoseAreaProductUnit.DecigraySquareMicrometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareMillimeter"/>
-        /// </summary>
-        public double DecigraySquareMillimeters => As(DoseAreaProductUnit.DecigraySquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareCentimeter"/>
-        /// </summary>
-        public double GraySquareCentimeters => As(DoseAreaProductUnit.GraySquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareDecimeter"/>
-        /// </summary>
-        public double GraySquareDecimeters => As(DoseAreaProductUnit.GraySquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareMeter"/>
-        /// </summary>
-        public double GraySquareMeters => As(DoseAreaProductUnit.GraySquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareMicrometer"/>
-        /// </summary>
-        public double GraySquareMicrometers => As(DoseAreaProductUnit.GraySquareMicrometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareMillimeter"/>
-        /// </summary>
-        public double GraySquareMillimeters => As(DoseAreaProductUnit.GraySquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareCentimeter"/>
-        /// </summary>
-        public double MicrograySquareCentimeters => As(DoseAreaProductUnit.MicrograySquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareDecimeter"/>
-        /// </summary>
-        public double MicrograySquareDecimeters => As(DoseAreaProductUnit.MicrograySquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareMeter"/>
-        /// </summary>
-        public double MicrograySquareMeters => As(DoseAreaProductUnit.MicrograySquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareMicrometer"/>
-        /// </summary>
-        public double MicrograySquareMicrometers => As(DoseAreaProductUnit.MicrograySquareMicrometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareMillimeter"/>
-        /// </summary>
-        public double MicrograySquareMillimeters => As(DoseAreaProductUnit.MicrograySquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareCentimeter"/>
-        /// </summary>
-        public double MilligraySquareCentimeters => As(DoseAreaProductUnit.MilligraySquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareDecimeter"/>
-        /// </summary>
-        public double MilligraySquareDecimeters => As(DoseAreaProductUnit.MilligraySquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareMeter"/>
-        /// </summary>
-        public double MilligraySquareMeters => As(DoseAreaProductUnit.MilligraySquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareMicrometer"/>
-        /// </summary>
-        public double MilligraySquareMicrometers => As(DoseAreaProductUnit.MilligraySquareMicrometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareMillimeter"/>
-        /// </summary>
-        public double MilligraySquareMillimeters => As(DoseAreaProductUnit.MilligraySquareMillimeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.CentigraySquareCentimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromCentigraySquareCentimeters(double centigraysquarecentimeters) => new DoseAreaProduct(centigraysquarecentimeters, DoseAreaProductUnit.CentigraySquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.CentigraySquareDecimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromCentigraySquareDecimeters(double centigraysquaredecimeters) => new DoseAreaProduct(centigraysquaredecimeters, DoseAreaProductUnit.CentigraySquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.CentigraySquareMeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromCentigraySquareMeters(double centigraysquaremeters) => new DoseAreaProduct(centigraysquaremeters, DoseAreaProductUnit.CentigraySquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.CentigraySquareMicrometer"/>.
-        /// </summary>
-        public static DoseAreaProduct FromCentigraySquareMicrometers(double centigraysquaremicrometers) => new DoseAreaProduct(centigraysquaremicrometers, DoseAreaProductUnit.CentigraySquareMicrometer);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.CentigraySquareMillimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromCentigraySquareMillimeters(double centigraysquaremillimeters) => new DoseAreaProduct(centigraysquaremillimeters, DoseAreaProductUnit.CentigraySquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.DecigraySquareCentimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromDecigraySquareCentimeters(double decigraysquarecentimeters) => new DoseAreaProduct(decigraysquarecentimeters, DoseAreaProductUnit.DecigraySquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.DecigraySquareDecimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromDecigraySquareDecimeters(double decigraysquaredecimeters) => new DoseAreaProduct(decigraysquaredecimeters, DoseAreaProductUnit.DecigraySquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.DecigraySquareMeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromDecigraySquareMeters(double decigraysquaremeters) => new DoseAreaProduct(decigraysquaremeters, DoseAreaProductUnit.DecigraySquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.DecigraySquareMicrometer"/>.
-        /// </summary>
-        public static DoseAreaProduct FromDecigraySquareMicrometers(double decigraysquaremicrometers) => new DoseAreaProduct(decigraysquaremicrometers, DoseAreaProductUnit.DecigraySquareMicrometer);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.DecigraySquareMillimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromDecigraySquareMillimeters(double decigraysquaremillimeters) => new DoseAreaProduct(decigraysquaremillimeters, DoseAreaProductUnit.DecigraySquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.GraySquareCentimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromGraySquareCentimeters(double graysquarecentimeters) => new DoseAreaProduct(graysquarecentimeters, DoseAreaProductUnit.GraySquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.GraySquareDecimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromGraySquareDecimeters(double graysquaredecimeters) => new DoseAreaProduct(graysquaredecimeters, DoseAreaProductUnit.GraySquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.GraySquareMeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromGraySquareMeters(double graysquaremeters) => new DoseAreaProduct(graysquaremeters, DoseAreaProductUnit.GraySquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.GraySquareMicrometer"/>.
-        /// </summary>
-        public static DoseAreaProduct FromGraySquareMicrometers(double graysquaremicrometers) => new DoseAreaProduct(graysquaremicrometers, DoseAreaProductUnit.GraySquareMicrometer);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.GraySquareMillimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromGraySquareMillimeters(double graysquaremillimeters) => new DoseAreaProduct(graysquaremillimeters, DoseAreaProductUnit.GraySquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MicrograySquareCentimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromMicrograySquareCentimeters(double micrograysquarecentimeters) => new DoseAreaProduct(micrograysquarecentimeters, DoseAreaProductUnit.MicrograySquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MicrograySquareDecimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromMicrograySquareDecimeters(double micrograysquaredecimeters) => new DoseAreaProduct(micrograysquaredecimeters, DoseAreaProductUnit.MicrograySquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MicrograySquareMeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromMicrograySquareMeters(double micrograysquaremeters) => new DoseAreaProduct(micrograysquaremeters, DoseAreaProductUnit.MicrograySquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MicrograySquareMicrometer"/>.
-        /// </summary>
-        public static DoseAreaProduct FromMicrograySquareMicrometers(double micrograysquaremicrometers) => new DoseAreaProduct(micrograysquaremicrometers, DoseAreaProductUnit.MicrograySquareMicrometer);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MicrograySquareMillimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromMicrograySquareMillimeters(double micrograysquaremillimeters) => new DoseAreaProduct(micrograysquaremillimeters, DoseAreaProductUnit.MicrograySquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MilligraySquareCentimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromMilligraySquareCentimeters(double milligraysquarecentimeters) => new DoseAreaProduct(milligraysquarecentimeters, DoseAreaProductUnit.MilligraySquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MilligraySquareDecimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromMilligraySquareDecimeters(double milligraysquaredecimeters) => new DoseAreaProduct(milligraysquaredecimeters, DoseAreaProductUnit.MilligraySquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MilligraySquareMeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromMilligraySquareMeters(double milligraysquaremeters) => new DoseAreaProduct(milligraysquaremeters, DoseAreaProductUnit.MilligraySquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MilligraySquareMicrometer"/>.
-        /// </summary>
-        public static DoseAreaProduct FromMilligraySquareMicrometers(double milligraysquaremicrometers) => new DoseAreaProduct(milligraysquaremicrometers, DoseAreaProductUnit.MilligraySquareMicrometer);
-
-        /// <summary>
-        ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MilligraySquareMillimeter"/>.
-        /// </summary>
-        public static DoseAreaProduct FromMilligraySquareMillimeters(double milligraysquaremillimeters) => new DoseAreaProduct(milligraysquaremillimeters, DoseAreaProductUnit.MilligraySquareMillimeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="DoseAreaProductUnit" /> to <see cref="DoseAreaProduct" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>DoseAreaProduct unit value.</returns>
-        public static DoseAreaProduct From(double value, DoseAreaProductUnit fromUnit)
-        {
-            return new DoseAreaProduct(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(DoseAreaProductUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this DoseAreaProduct to another DoseAreaProduct with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A DoseAreaProduct with the specified unit.</returns>
-                public DoseAreaProduct ToUnit(DoseAreaProductUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new DoseAreaProduct(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        DoseAreaProductUnit.CentigraySquareCentimeter => (_value / 10000) * 1e-2d,
-                        DoseAreaProductUnit.CentigraySquareDecimeter => (_value / 100) * 1e-2d,
-                        DoseAreaProductUnit.CentigraySquareMeter => (_value) * 1e-2d,
-                        DoseAreaProductUnit.CentigraySquareMicrometer => (_value / 1000000000000) * 1e-2d,
-                        DoseAreaProductUnit.CentigraySquareMillimeter => (_value / 1000000) * 1e-2d,
-                        DoseAreaProductUnit.DecigraySquareCentimeter => (_value / 10000) * 1e-1d,
-                        DoseAreaProductUnit.DecigraySquareDecimeter => (_value / 100) * 1e-1d,
-                        DoseAreaProductUnit.DecigraySquareMeter => (_value) * 1e-1d,
-                        DoseAreaProductUnit.DecigraySquareMicrometer => (_value / 1000000000000) * 1e-1d,
-                        DoseAreaProductUnit.DecigraySquareMillimeter => (_value / 1000000) * 1e-1d,
-                        DoseAreaProductUnit.GraySquareCentimeter => _value / 10000,
-                        DoseAreaProductUnit.GraySquareDecimeter => _value / 100,
-                        DoseAreaProductUnit.GraySquareMeter => _value,
-                        DoseAreaProductUnit.GraySquareMicrometer => _value / 1000000000000,
-                        DoseAreaProductUnit.GraySquareMillimeter => _value / 1000000,
-                        DoseAreaProductUnit.MicrograySquareCentimeter => (_value / 10000) * 1e-6d,
-                        DoseAreaProductUnit.MicrograySquareDecimeter => (_value / 100) * 1e-6d,
-                        DoseAreaProductUnit.MicrograySquareMeter => (_value) * 1e-6d,
-                        DoseAreaProductUnit.MicrograySquareMicrometer => (_value / 1000000000000) * 1e-6d,
-                        DoseAreaProductUnit.MicrograySquareMillimeter => (_value / 1000000) * 1e-6d,
-                        DoseAreaProductUnit.MilligraySquareCentimeter => (_value / 10000) * 1e-3d,
-                        DoseAreaProductUnit.MilligraySquareDecimeter => (_value / 100) * 1e-3d,
-                        DoseAreaProductUnit.MilligraySquareMeter => (_value) * 1e-3d,
-                        DoseAreaProductUnit.MilligraySquareMicrometer => (_value / 1000000000000) * 1e-3d,
-                        DoseAreaProductUnit.MilligraySquareMillimeter => (_value / 1000000) * 1e-3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(DoseAreaProductUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        DoseAreaProductUnit.CentigraySquareCentimeter => (baseUnitValue * 10000) / 1e-2d,
-                        DoseAreaProductUnit.CentigraySquareDecimeter => (baseUnitValue * 100) / 1e-2d,
-                        DoseAreaProductUnit.CentigraySquareMeter => (baseUnitValue) / 1e-2d,
-                        DoseAreaProductUnit.CentigraySquareMicrometer => (baseUnitValue * 1000000000000) / 1e-2d,
-                        DoseAreaProductUnit.CentigraySquareMillimeter => (baseUnitValue * 1000000) / 1e-2d,
-                        DoseAreaProductUnit.DecigraySquareCentimeter => (baseUnitValue * 10000) / 1e-1d,
-                        DoseAreaProductUnit.DecigraySquareDecimeter => (baseUnitValue * 100) / 1e-1d,
-                        DoseAreaProductUnit.DecigraySquareMeter => (baseUnitValue) / 1e-1d,
-                        DoseAreaProductUnit.DecigraySquareMicrometer => (baseUnitValue * 1000000000000) / 1e-1d,
-                        DoseAreaProductUnit.DecigraySquareMillimeter => (baseUnitValue * 1000000) / 1e-1d,
-                        DoseAreaProductUnit.GraySquareCentimeter => baseUnitValue * 10000,
-                        DoseAreaProductUnit.GraySquareDecimeter => baseUnitValue * 100,
-                        DoseAreaProductUnit.GraySquareMeter => baseUnitValue,
-                        DoseAreaProductUnit.GraySquareMicrometer => baseUnitValue * 1000000000000,
-                        DoseAreaProductUnit.GraySquareMillimeter => baseUnitValue * 1000000,
-                        DoseAreaProductUnit.MicrograySquareCentimeter => (baseUnitValue * 10000) / 1e-6d,
-                        DoseAreaProductUnit.MicrograySquareDecimeter => (baseUnitValue * 100) / 1e-6d,
-                        DoseAreaProductUnit.MicrograySquareMeter => (baseUnitValue) / 1e-6d,
-                        DoseAreaProductUnit.MicrograySquareMicrometer => (baseUnitValue * 1000000000000) / 1e-6d,
-                        DoseAreaProductUnit.MicrograySquareMillimeter => (baseUnitValue * 1000000) / 1e-6d,
-                        DoseAreaProductUnit.MilligraySquareCentimeter => (baseUnitValue * 10000) / 1e-3d,
-                        DoseAreaProductUnit.MilligraySquareDecimeter => (baseUnitValue * 100) / 1e-3d,
-                        DoseAreaProductUnit.MilligraySquareMeter => (baseUnitValue) / 1e-3d,
-                        DoseAreaProductUnit.MilligraySquareMicrometer => (baseUnitValue * 1000000000000) / 1e-3d,
-                        DoseAreaProductUnit.MilligraySquareMillimeter => (baseUnitValue * 1000000) / 1e-3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Duration.g.cs
deleted file mode 100644
index c67c4749af..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Duration.g.cs
+++ /dev/null
@@ -1,301 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Time is a dimension in which events can be ordered from the past through the present into the future, and also the measure of durations of events and the intervals between them.
-    /// </summary>
-    public struct  Duration
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly DurationUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public DurationUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Duration(double value, DurationUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Duration, which is Second. All conversions go via this value.
-        /// </summary>
-        public static DurationUnit BaseUnit { get; } = DurationUnit.Second;
-
-        /// <summary>
-        /// Represents the largest possible value of Duration.
-        /// </summary>
-        public static Duration MaxValue { get; } = new Duration(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Duration.
-        /// </summary>
-        public static Duration MinValue { get; } = new Duration(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Duration Zero { get; } = new Duration(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Day"/>
-        /// </summary>
-        public double Days => As(DurationUnit.Day);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Hour"/>
-        /// </summary>
-        public double Hours => As(DurationUnit.Hour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.JulianYear"/>
-        /// </summary>
-        public double JulianYears => As(DurationUnit.JulianYear);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Microsecond"/>
-        /// </summary>
-        public double Microseconds => As(DurationUnit.Microsecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Millisecond"/>
-        /// </summary>
-        public double Milliseconds => As(DurationUnit.Millisecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Minute"/>
-        /// </summary>
-        public double Minutes => As(DurationUnit.Minute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Month30"/>
-        /// </summary>
-        public double Months30 => As(DurationUnit.Month30);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Nanosecond"/>
-        /// </summary>
-        public double Nanoseconds => As(DurationUnit.Nanosecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Picosecond"/>
-        /// </summary>
-        public double Picoseconds => As(DurationUnit.Picosecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Second"/>
-        /// </summary>
-        public double Seconds => As(DurationUnit.Second);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Sol"/>
-        /// </summary>
-        public double Sols => As(DurationUnit.Sol);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Week"/>
-        /// </summary>
-        public double Weeks => As(DurationUnit.Week);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Year365"/>
-        /// </summary>
-        public double Years365 => As(DurationUnit.Year365);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Day"/>.
-        /// </summary>
-        public static Duration FromDays(double days) => new Duration(days, DurationUnit.Day);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Hour"/>.
-        /// </summary>
-        public static Duration FromHours(double hours) => new Duration(hours, DurationUnit.Hour);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.JulianYear"/>.
-        /// </summary>
-        public static Duration FromJulianYears(double julianyears) => new Duration(julianyears, DurationUnit.JulianYear);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Microsecond"/>.
-        /// </summary>
-        public static Duration FromMicroseconds(double microseconds) => new Duration(microseconds, DurationUnit.Microsecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Millisecond"/>.
-        /// </summary>
-        public static Duration FromMilliseconds(double milliseconds) => new Duration(milliseconds, DurationUnit.Millisecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Minute"/>.
-        /// </summary>
-        public static Duration FromMinutes(double minutes) => new Duration(minutes, DurationUnit.Minute);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Month30"/>.
-        /// </summary>
-        public static Duration FromMonths30(double months30) => new Duration(months30, DurationUnit.Month30);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Nanosecond"/>.
-        /// </summary>
-        public static Duration FromNanoseconds(double nanoseconds) => new Duration(nanoseconds, DurationUnit.Nanosecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Picosecond"/>.
-        /// </summary>
-        public static Duration FromPicoseconds(double picoseconds) => new Duration(picoseconds, DurationUnit.Picosecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Second"/>.
-        /// </summary>
-        public static Duration FromSeconds(double seconds) => new Duration(seconds, DurationUnit.Second);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Sol"/>.
-        /// </summary>
-        public static Duration FromSols(double sols) => new Duration(sols, DurationUnit.Sol);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Week"/>.
-        /// </summary>
-        public static Duration FromWeeks(double weeks) => new Duration(weeks, DurationUnit.Week);
-
-        /// <summary>
-        ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Year365"/>.
-        /// </summary>
-        public static Duration FromYears365(double years365) => new Duration(years365, DurationUnit.Year365);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="DurationUnit" /> to <see cref="Duration" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Duration unit value.</returns>
-        public static Duration From(double value, DurationUnit fromUnit)
-        {
-            return new Duration(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(DurationUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Duration to another Duration with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Duration with the specified unit.</returns>
-                public Duration ToUnit(DurationUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Duration(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        DurationUnit.Day => _value * 24 * 3600,
-                        DurationUnit.Hour => _value * 3600,
-                        DurationUnit.JulianYear => _value * 365.25 * 24 * 3600,
-                        DurationUnit.Microsecond => (_value) * 1e-6d,
-                        DurationUnit.Millisecond => (_value) * 1e-3d,
-                        DurationUnit.Minute => _value * 60,
-                        DurationUnit.Month30 => _value * 30 * 24 * 3600,
-                        DurationUnit.Nanosecond => (_value) * 1e-9d,
-                        DurationUnit.Picosecond => (_value) * 1e-12d,
-                        DurationUnit.Second => _value,
-                        DurationUnit.Sol => _value * 88775.244,
-                        DurationUnit.Week => _value * 7 * 24 * 3600,
-                        DurationUnit.Year365 => _value * 365 * 24 * 3600,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(DurationUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        DurationUnit.Day => baseUnitValue / (24 * 3600),
-                        DurationUnit.Hour => baseUnitValue / 3600,
-                        DurationUnit.JulianYear => baseUnitValue / (365.25 * 24 * 3600),
-                        DurationUnit.Microsecond => (baseUnitValue) / 1e-6d,
-                        DurationUnit.Millisecond => (baseUnitValue) / 1e-3d,
-                        DurationUnit.Minute => baseUnitValue / 60,
-                        DurationUnit.Month30 => baseUnitValue / (30 * 24 * 3600),
-                        DurationUnit.Nanosecond => (baseUnitValue) / 1e-9d,
-                        DurationUnit.Picosecond => (baseUnitValue) / 1e-12d,
-                        DurationUnit.Second => baseUnitValue,
-                        DurationUnit.Sol => baseUnitValue / 88775.244,
-                        DurationUnit.Week => baseUnitValue / (7 * 24 * 3600),
-                        DurationUnit.Year365 => baseUnitValue / (365 * 24 * 3600),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/DynamicViscosity.g.cs
deleted file mode 100644
index 20f3f8abda..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/DynamicViscosity.g.cs
+++ /dev/null
@@ -1,268 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The dynamic (shear) viscosity of a fluid expresses its resistance to shearing flows, where adjacent layers move parallel to each other with different speeds
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Viscosity#Dynamic_.28shear.29_viscosity
-    /// </remarks>
-    public struct  DynamicViscosity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly DynamicViscosityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public DynamicViscosityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public DynamicViscosity(double value, DynamicViscosityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of DynamicViscosity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static DynamicViscosityUnit BaseUnit { get; } = DynamicViscosityUnit.NewtonSecondPerMeterSquared;
-
-        /// <summary>
-        /// Represents the largest possible value of DynamicViscosity.
-        /// </summary>
-        public static DynamicViscosity MaxValue { get; } = new DynamicViscosity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of DynamicViscosity.
-        /// </summary>
-        public static DynamicViscosity MinValue { get; } = new DynamicViscosity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static DynamicViscosity Zero { get; } = new DynamicViscosity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.Centipoise"/>
-        /// </summary>
-        public double Centipoise => As(DynamicViscosityUnit.Centipoise);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.MicropascalSecond"/>
-        /// </summary>
-        public double MicropascalSeconds => As(DynamicViscosityUnit.MicropascalSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.MillipascalSecond"/>
-        /// </summary>
-        public double MillipascalSeconds => As(DynamicViscosityUnit.MillipascalSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.NewtonSecondPerMeterSquared"/>
-        /// </summary>
-        public double NewtonSecondsPerMeterSquared => As(DynamicViscosityUnit.NewtonSecondPerMeterSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PascalSecond"/>
-        /// </summary>
-        public double PascalSeconds => As(DynamicViscosityUnit.PascalSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.Poise"/>
-        /// </summary>
-        public double Poise => As(DynamicViscosityUnit.Poise);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareFoot"/>
-        /// </summary>
-        public double PoundsForceSecondPerSquareFoot => As(DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareInch"/>
-        /// </summary>
-        public double PoundsForceSecondPerSquareInch => As(DynamicViscosityUnit.PoundForceSecondPerSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PoundPerFootSecond"/>
-        /// </summary>
-        public double PoundsPerFootSecond => As(DynamicViscosityUnit.PoundPerFootSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.Reyn"/>
-        /// </summary>
-        public double Reyns => As(DynamicViscosityUnit.Reyn);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Centipoise"/>.
-        /// </summary>
-        public static DynamicViscosity FromCentipoise(double centipoise) => new DynamicViscosity(centipoise, DynamicViscosityUnit.Centipoise);
-
-        /// <summary>
-        ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.MicropascalSecond"/>.
-        /// </summary>
-        public static DynamicViscosity FromMicropascalSeconds(double micropascalseconds) => new DynamicViscosity(micropascalseconds, DynamicViscosityUnit.MicropascalSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.MillipascalSecond"/>.
-        /// </summary>
-        public static DynamicViscosity FromMillipascalSeconds(double millipascalseconds) => new DynamicViscosity(millipascalseconds, DynamicViscosityUnit.MillipascalSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.NewtonSecondPerMeterSquared"/>.
-        /// </summary>
-        public static DynamicViscosity FromNewtonSecondsPerMeterSquared(double newtonsecondspermetersquared) => new DynamicViscosity(newtonsecondspermetersquared, DynamicViscosityUnit.NewtonSecondPerMeterSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PascalSecond"/>.
-        /// </summary>
-        public static DynamicViscosity FromPascalSeconds(double pascalseconds) => new DynamicViscosity(pascalseconds, DynamicViscosityUnit.PascalSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Poise"/>.
-        /// </summary>
-        public static DynamicViscosity FromPoise(double poise) => new DynamicViscosity(poise, DynamicViscosityUnit.Poise);
-
-        /// <summary>
-        ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareFoot"/>.
-        /// </summary>
-        public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(double poundsforcesecondpersquarefoot) => new DynamicViscosity(poundsforcesecondpersquarefoot, DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareInch"/>.
-        /// </summary>
-        public static DynamicViscosity FromPoundsForceSecondPerSquareInch(double poundsforcesecondpersquareinch) => new DynamicViscosity(poundsforcesecondpersquareinch, DynamicViscosityUnit.PoundForceSecondPerSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundPerFootSecond"/>.
-        /// </summary>
-        public static DynamicViscosity FromPoundsPerFootSecond(double poundsperfootsecond) => new DynamicViscosity(poundsperfootsecond, DynamicViscosityUnit.PoundPerFootSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Reyn"/>.
-        /// </summary>
-        public static DynamicViscosity FromReyns(double reyns) => new DynamicViscosity(reyns, DynamicViscosityUnit.Reyn);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="DynamicViscosityUnit" /> to <see cref="DynamicViscosity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>DynamicViscosity unit value.</returns>
-        public static DynamicViscosity From(double value, DynamicViscosityUnit fromUnit)
-        {
-            return new DynamicViscosity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(DynamicViscosityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this DynamicViscosity to another DynamicViscosity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A DynamicViscosity with the specified unit.</returns>
-                public DynamicViscosity ToUnit(DynamicViscosityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new DynamicViscosity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        DynamicViscosityUnit.Centipoise => (_value / 10) * 1e-2d,
-                        DynamicViscosityUnit.MicropascalSecond => (_value) * 1e-6d,
-                        DynamicViscosityUnit.MillipascalSecond => (_value) * 1e-3d,
-                        DynamicViscosityUnit.NewtonSecondPerMeterSquared => _value,
-                        DynamicViscosityUnit.PascalSecond => _value,
-                        DynamicViscosityUnit.Poise => _value / 10,
-                        DynamicViscosityUnit.PoundForceSecondPerSquareFoot => _value * 4.4482216152605 / 9.290304e-2,
-                        DynamicViscosityUnit.PoundForceSecondPerSquareInch => _value * 4.4482216152605 / 0.00064516,
-                        DynamicViscosityUnit.PoundPerFootSecond => _value * 0.45359237 / 0.3048,
-                        DynamicViscosityUnit.Reyn => _value * 4.4482216152605 / 0.00064516,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(DynamicViscosityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        DynamicViscosityUnit.Centipoise => (baseUnitValue * 10) / 1e-2d,
-                        DynamicViscosityUnit.MicropascalSecond => (baseUnitValue) / 1e-6d,
-                        DynamicViscosityUnit.MillipascalSecond => (baseUnitValue) / 1e-3d,
-                        DynamicViscosityUnit.NewtonSecondPerMeterSquared => baseUnitValue,
-                        DynamicViscosityUnit.PascalSecond => baseUnitValue,
-                        DynamicViscosityUnit.Poise => baseUnitValue * 10,
-                        DynamicViscosityUnit.PoundForceSecondPerSquareFoot => baseUnitValue * 9.290304e-2 / 4.4482216152605,
-                        DynamicViscosityUnit.PoundForceSecondPerSquareInch => baseUnitValue * 0.00064516 / 4.4482216152605,
-                        DynamicViscosityUnit.PoundPerFootSecond => baseUnitValue * 0.3048 / 0.45359237,
-                        DynamicViscosityUnit.Reyn => baseUnitValue * 0.00064516 / 4.4482216152605,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricAdmittance.g.cs
deleted file mode 100644
index b943463a95..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricAdmittance.g.cs
+++ /dev/null
@@ -1,341 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Electric admittance is a measure of how easily a circuit or device will allow a current to flow by the combined effect of conductance and susceptance in a circuit. It is defined as the inverse of impedance. The SI unit of admittance is the siemens (symbol S).
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Electrical_admittance
-    /// </remarks>
-    [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
-    public struct  ElectricAdmittance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricAdmittanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricAdmittanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricAdmittance(double value, ElectricAdmittanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricAdmittance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricAdmittanceUnit BaseUnit { get; } = ElectricAdmittanceUnit.Siemens;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricAdmittance.
-        /// </summary>
-        public static ElectricAdmittance MaxValue { get; } = new ElectricAdmittance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricAdmittance.
-        /// </summary>
-        public static ElectricAdmittance MinValue { get; } = new ElectricAdmittance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricAdmittance Zero { get; } = new ElectricAdmittance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Gigamho"/>
-        /// </summary>
-        public double Gigamhos => As(ElectricAdmittanceUnit.Gigamho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Gigasiemens"/>
-        /// </summary>
-        public double Gigasiemens => As(ElectricAdmittanceUnit.Gigasiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Kilomho"/>
-        /// </summary>
-        public double Kilomhos => As(ElectricAdmittanceUnit.Kilomho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Kilosiemens"/>
-        /// </summary>
-        public double Kilosiemens => As(ElectricAdmittanceUnit.Kilosiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Megamho"/>
-        /// </summary>
-        public double Megamhos => As(ElectricAdmittanceUnit.Megamho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Megasiemens"/>
-        /// </summary>
-        public double Megasiemens => As(ElectricAdmittanceUnit.Megasiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Mho"/>
-        /// </summary>
-        public double Mhos => As(ElectricAdmittanceUnit.Mho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Micromho"/>
-        /// </summary>
-        public double Micromhos => As(ElectricAdmittanceUnit.Micromho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Microsiemens"/>
-        /// </summary>
-        public double Microsiemens => As(ElectricAdmittanceUnit.Microsiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Millimho"/>
-        /// </summary>
-        public double Millimhos => As(ElectricAdmittanceUnit.Millimho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Millisiemens"/>
-        /// </summary>
-        public double Millisiemens => As(ElectricAdmittanceUnit.Millisiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Nanomho"/>
-        /// </summary>
-        public double Nanomhos => As(ElectricAdmittanceUnit.Nanomho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Nanosiemens"/>
-        /// </summary>
-        public double Nanosiemens => As(ElectricAdmittanceUnit.Nanosiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Siemens"/>
-        /// </summary>
-        public double Siemens => As(ElectricAdmittanceUnit.Siemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Teramho"/>
-        /// </summary>
-        public double Teramhos => As(ElectricAdmittanceUnit.Teramho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Terasiemens"/>
-        /// </summary>
-        public double Terasiemens => As(ElectricAdmittanceUnit.Terasiemens);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Gigamho"/>.
-        /// </summary>
-        public static ElectricAdmittance FromGigamhos(double gigamhos) => new ElectricAdmittance(gigamhos, ElectricAdmittanceUnit.Gigamho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Gigasiemens"/>.
-        /// </summary>
-        public static ElectricAdmittance FromGigasiemens(double gigasiemens) => new ElectricAdmittance(gigasiemens, ElectricAdmittanceUnit.Gigasiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Kilomho"/>.
-        /// </summary>
-        public static ElectricAdmittance FromKilomhos(double kilomhos) => new ElectricAdmittance(kilomhos, ElectricAdmittanceUnit.Kilomho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Kilosiemens"/>.
-        /// </summary>
-        public static ElectricAdmittance FromKilosiemens(double kilosiemens) => new ElectricAdmittance(kilosiemens, ElectricAdmittanceUnit.Kilosiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Megamho"/>.
-        /// </summary>
-        public static ElectricAdmittance FromMegamhos(double megamhos) => new ElectricAdmittance(megamhos, ElectricAdmittanceUnit.Megamho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Megasiemens"/>.
-        /// </summary>
-        public static ElectricAdmittance FromMegasiemens(double megasiemens) => new ElectricAdmittance(megasiemens, ElectricAdmittanceUnit.Megasiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Mho"/>.
-        /// </summary>
-        public static ElectricAdmittance FromMhos(double mhos) => new ElectricAdmittance(mhos, ElectricAdmittanceUnit.Mho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Micromho"/>.
-        /// </summary>
-        public static ElectricAdmittance FromMicromhos(double micromhos) => new ElectricAdmittance(micromhos, ElectricAdmittanceUnit.Micromho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Microsiemens"/>.
-        /// </summary>
-        public static ElectricAdmittance FromMicrosiemens(double microsiemens) => new ElectricAdmittance(microsiemens, ElectricAdmittanceUnit.Microsiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Millimho"/>.
-        /// </summary>
-        public static ElectricAdmittance FromMillimhos(double millimhos) => new ElectricAdmittance(millimhos, ElectricAdmittanceUnit.Millimho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Millisiemens"/>.
-        /// </summary>
-        public static ElectricAdmittance FromMillisiemens(double millisiemens) => new ElectricAdmittance(millisiemens, ElectricAdmittanceUnit.Millisiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Nanomho"/>.
-        /// </summary>
-        public static ElectricAdmittance FromNanomhos(double nanomhos) => new ElectricAdmittance(nanomhos, ElectricAdmittanceUnit.Nanomho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Nanosiemens"/>.
-        /// </summary>
-        public static ElectricAdmittance FromNanosiemens(double nanosiemens) => new ElectricAdmittance(nanosiemens, ElectricAdmittanceUnit.Nanosiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Siemens"/>.
-        /// </summary>
-        public static ElectricAdmittance FromSiemens(double siemens) => new ElectricAdmittance(siemens, ElectricAdmittanceUnit.Siemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Teramho"/>.
-        /// </summary>
-        public static ElectricAdmittance FromTeramhos(double teramhos) => new ElectricAdmittance(teramhos, ElectricAdmittanceUnit.Teramho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Terasiemens"/>.
-        /// </summary>
-        public static ElectricAdmittance FromTerasiemens(double terasiemens) => new ElectricAdmittance(terasiemens, ElectricAdmittanceUnit.Terasiemens);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricAdmittanceUnit" /> to <see cref="ElectricAdmittance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricAdmittance unit value.</returns>
-        public static ElectricAdmittance From(double value, ElectricAdmittanceUnit fromUnit)
-        {
-            return new ElectricAdmittance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricAdmittanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricAdmittance to another ElectricAdmittance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricAdmittance with the specified unit.</returns>
-                public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricAdmittance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricAdmittanceUnit.Gigamho => (_value) * 1e9d,
-                        ElectricAdmittanceUnit.Gigasiemens => (_value) * 1e9d,
-                        ElectricAdmittanceUnit.Kilomho => (_value) * 1e3d,
-                        ElectricAdmittanceUnit.Kilosiemens => (_value) * 1e3d,
-                        ElectricAdmittanceUnit.Megamho => (_value) * 1e6d,
-                        ElectricAdmittanceUnit.Megasiemens => (_value) * 1e6d,
-                        ElectricAdmittanceUnit.Mho => _value,
-                        ElectricAdmittanceUnit.Micromho => (_value) * 1e-6d,
-                        ElectricAdmittanceUnit.Microsiemens => (_value) * 1e-6d,
-                        ElectricAdmittanceUnit.Millimho => (_value) * 1e-3d,
-                        ElectricAdmittanceUnit.Millisiemens => (_value) * 1e-3d,
-                        ElectricAdmittanceUnit.Nanomho => (_value) * 1e-9d,
-                        ElectricAdmittanceUnit.Nanosiemens => (_value) * 1e-9d,
-                        ElectricAdmittanceUnit.Siemens => _value,
-                        ElectricAdmittanceUnit.Teramho => (_value) * 1e12d,
-                        ElectricAdmittanceUnit.Terasiemens => (_value) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricAdmittanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricAdmittanceUnit.Gigamho => (baseUnitValue) / 1e9d,
-                        ElectricAdmittanceUnit.Gigasiemens => (baseUnitValue) / 1e9d,
-                        ElectricAdmittanceUnit.Kilomho => (baseUnitValue) / 1e3d,
-                        ElectricAdmittanceUnit.Kilosiemens => (baseUnitValue) / 1e3d,
-                        ElectricAdmittanceUnit.Megamho => (baseUnitValue) / 1e6d,
-                        ElectricAdmittanceUnit.Megasiemens => (baseUnitValue) / 1e6d,
-                        ElectricAdmittanceUnit.Mho => baseUnitValue,
-                        ElectricAdmittanceUnit.Micromho => (baseUnitValue) / 1e-6d,
-                        ElectricAdmittanceUnit.Microsiemens => (baseUnitValue) / 1e-6d,
-                        ElectricAdmittanceUnit.Millimho => (baseUnitValue) / 1e-3d,
-                        ElectricAdmittanceUnit.Millisiemens => (baseUnitValue) / 1e-3d,
-                        ElectricAdmittanceUnit.Nanomho => (baseUnitValue) / 1e-9d,
-                        ElectricAdmittanceUnit.Nanosiemens => (baseUnitValue) / 1e-9d,
-                        ElectricAdmittanceUnit.Siemens => baseUnitValue,
-                        ElectricAdmittanceUnit.Teramho => (baseUnitValue) / 1e12d,
-                        ElectricAdmittanceUnit.Terasiemens => (baseUnitValue) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs
deleted file mode 100644
index d6aaee81c4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     A unit for expressing the integral of apparent power over time, equal to the product of 1 volt-ampere and 1 hour, or to 3600 joules.
-    /// </summary>
-    public struct  ElectricApparentEnergy
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricApparentEnergyUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricApparentEnergyUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricApparentEnergy(double value, ElectricApparentEnergyUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricApparentEnergy, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricApparentEnergyUnit BaseUnit { get; } = ElectricApparentEnergyUnit.VoltampereHour;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricApparentEnergy.
-        /// </summary>
-        public static ElectricApparentEnergy MaxValue { get; } = new ElectricApparentEnergy(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricApparentEnergy.
-        /// </summary>
-        public static ElectricApparentEnergy MinValue { get; } = new ElectricApparentEnergy(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricApparentEnergy Zero { get; } = new ElectricApparentEnergy(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentEnergyUnit.KilovoltampereHour"/>
-        /// </summary>
-        public double KilovoltampereHours => As(ElectricApparentEnergyUnit.KilovoltampereHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentEnergyUnit.MegavoltampereHour"/>
-        /// </summary>
-        public double MegavoltampereHours => As(ElectricApparentEnergyUnit.MegavoltampereHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentEnergyUnit.VoltampereHour"/>
-        /// </summary>
-        public double VoltampereHours => As(ElectricApparentEnergyUnit.VoltampereHour);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricApparentEnergy"/> from <see cref="ElectricApparentEnergyUnit.KilovoltampereHour"/>.
-        /// </summary>
-        public static ElectricApparentEnergy FromKilovoltampereHours(double kilovoltamperehours) => new ElectricApparentEnergy(kilovoltamperehours, ElectricApparentEnergyUnit.KilovoltampereHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricApparentEnergy"/> from <see cref="ElectricApparentEnergyUnit.MegavoltampereHour"/>.
-        /// </summary>
-        public static ElectricApparentEnergy FromMegavoltampereHours(double megavoltamperehours) => new ElectricApparentEnergy(megavoltamperehours, ElectricApparentEnergyUnit.MegavoltampereHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricApparentEnergy"/> from <see cref="ElectricApparentEnergyUnit.VoltampereHour"/>.
-        /// </summary>
-        public static ElectricApparentEnergy FromVoltampereHours(double voltamperehours) => new ElectricApparentEnergy(voltamperehours, ElectricApparentEnergyUnit.VoltampereHour);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricApparentEnergyUnit" /> to <see cref="ElectricApparentEnergy" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricApparentEnergy unit value.</returns>
-        public static ElectricApparentEnergy From(double value, ElectricApparentEnergyUnit fromUnit)
-        {
-            return new ElectricApparentEnergy(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricApparentEnergyUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricApparentEnergy to another ElectricApparentEnergy with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricApparentEnergy with the specified unit.</returns>
-                public ElectricApparentEnergy ToUnit(ElectricApparentEnergyUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricApparentEnergy(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricApparentEnergyUnit.KilovoltampereHour => (_value) * 1e3d,
-                        ElectricApparentEnergyUnit.MegavoltampereHour => (_value) * 1e6d,
-                        ElectricApparentEnergyUnit.VoltampereHour => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricApparentEnergyUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricApparentEnergyUnit.KilovoltampereHour => (baseUnitValue) / 1e3d,
-                        ElectricApparentEnergyUnit.MegavoltampereHour => (baseUnitValue) / 1e6d,
-                        ElectricApparentEnergyUnit.VoltampereHour => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricApparentPower.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricApparentPower.g.cs
deleted file mode 100644
index 664e6e2d5f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricApparentPower.g.cs
+++ /dev/null
@@ -1,220 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Power engineers measure apparent power as the magnitude of the vector sum of active and reactive power. It is the product of the root mean square voltage (in volts) and the root mean square current (in amperes).
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/AC_power#Active,_reactive,_apparent,_and_complex_power_in_sinusoidal_steady-state
-    /// </remarks>
-    public struct  ElectricApparentPower
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricApparentPowerUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricApparentPowerUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricApparentPower(double value, ElectricApparentPowerUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricApparentPower, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricApparentPowerUnit BaseUnit { get; } = ElectricApparentPowerUnit.Voltampere;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricApparentPower.
-        /// </summary>
-        public static ElectricApparentPower MaxValue { get; } = new ElectricApparentPower(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricApparentPower.
-        /// </summary>
-        public static ElectricApparentPower MinValue { get; } = new ElectricApparentPower(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricApparentPower Zero { get; } = new ElectricApparentPower(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Gigavoltampere"/>
-        /// </summary>
-        public double Gigavoltamperes => As(ElectricApparentPowerUnit.Gigavoltampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Kilovoltampere"/>
-        /// </summary>
-        public double Kilovoltamperes => As(ElectricApparentPowerUnit.Kilovoltampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Megavoltampere"/>
-        /// </summary>
-        public double Megavoltamperes => As(ElectricApparentPowerUnit.Megavoltampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Microvoltampere"/>
-        /// </summary>
-        public double Microvoltamperes => As(ElectricApparentPowerUnit.Microvoltampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Millivoltampere"/>
-        /// </summary>
-        public double Millivoltamperes => As(ElectricApparentPowerUnit.Millivoltampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Voltampere"/>
-        /// </summary>
-        public double Voltamperes => As(ElectricApparentPowerUnit.Voltampere);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Gigavoltampere"/>.
-        /// </summary>
-        public static ElectricApparentPower FromGigavoltamperes(double gigavoltamperes) => new ElectricApparentPower(gigavoltamperes, ElectricApparentPowerUnit.Gigavoltampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Kilovoltampere"/>.
-        /// </summary>
-        public static ElectricApparentPower FromKilovoltamperes(double kilovoltamperes) => new ElectricApparentPower(kilovoltamperes, ElectricApparentPowerUnit.Kilovoltampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Megavoltampere"/>.
-        /// </summary>
-        public static ElectricApparentPower FromMegavoltamperes(double megavoltamperes) => new ElectricApparentPower(megavoltamperes, ElectricApparentPowerUnit.Megavoltampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Microvoltampere"/>.
-        /// </summary>
-        public static ElectricApparentPower FromMicrovoltamperes(double microvoltamperes) => new ElectricApparentPower(microvoltamperes, ElectricApparentPowerUnit.Microvoltampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Millivoltampere"/>.
-        /// </summary>
-        public static ElectricApparentPower FromMillivoltamperes(double millivoltamperes) => new ElectricApparentPower(millivoltamperes, ElectricApparentPowerUnit.Millivoltampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Voltampere"/>.
-        /// </summary>
-        public static ElectricApparentPower FromVoltamperes(double voltamperes) => new ElectricApparentPower(voltamperes, ElectricApparentPowerUnit.Voltampere);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricApparentPowerUnit" /> to <see cref="ElectricApparentPower" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricApparentPower unit value.</returns>
-        public static ElectricApparentPower From(double value, ElectricApparentPowerUnit fromUnit)
-        {
-            return new ElectricApparentPower(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricApparentPowerUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricApparentPower to another ElectricApparentPower with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricApparentPower with the specified unit.</returns>
-                public ElectricApparentPower ToUnit(ElectricApparentPowerUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricApparentPower(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricApparentPowerUnit.Gigavoltampere => (_value) * 1e9d,
-                        ElectricApparentPowerUnit.Kilovoltampere => (_value) * 1e3d,
-                        ElectricApparentPowerUnit.Megavoltampere => (_value) * 1e6d,
-                        ElectricApparentPowerUnit.Microvoltampere => (_value) * 1e-6d,
-                        ElectricApparentPowerUnit.Millivoltampere => (_value) * 1e-3d,
-                        ElectricApparentPowerUnit.Voltampere => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricApparentPowerUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricApparentPowerUnit.Gigavoltampere => (baseUnitValue) / 1e9d,
-                        ElectricApparentPowerUnit.Kilovoltampere => (baseUnitValue) / 1e3d,
-                        ElectricApparentPowerUnit.Megavoltampere => (baseUnitValue) / 1e6d,
-                        ElectricApparentPowerUnit.Microvoltampere => (baseUnitValue) / 1e-6d,
-                        ElectricApparentPowerUnit.Millivoltampere => (baseUnitValue) / 1e-3d,
-                        ElectricApparentPowerUnit.Voltampere => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCapacitance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCapacitance.g.cs
deleted file mode 100644
index 0baa8898bf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCapacitance.g.cs
+++ /dev/null
@@ -1,232 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Capacitance is the capacity of a material object or device to store electric charge.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Capacitance
-    /// </remarks>
-    public struct  ElectricCapacitance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricCapacitanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricCapacitanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricCapacitance(double value, ElectricCapacitanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricCapacitance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricCapacitanceUnit BaseUnit { get; } = ElectricCapacitanceUnit.Farad;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricCapacitance.
-        /// </summary>
-        public static ElectricCapacitance MaxValue { get; } = new ElectricCapacitance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricCapacitance.
-        /// </summary>
-        public static ElectricCapacitance MinValue { get; } = new ElectricCapacitance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricCapacitance Zero { get; } = new ElectricCapacitance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Farad"/>
-        /// </summary>
-        public double Farads => As(ElectricCapacitanceUnit.Farad);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Kilofarad"/>
-        /// </summary>
-        public double Kilofarads => As(ElectricCapacitanceUnit.Kilofarad);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Megafarad"/>
-        /// </summary>
-        public double Megafarads => As(ElectricCapacitanceUnit.Megafarad);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Microfarad"/>
-        /// </summary>
-        public double Microfarads => As(ElectricCapacitanceUnit.Microfarad);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Millifarad"/>
-        /// </summary>
-        public double Millifarads => As(ElectricCapacitanceUnit.Millifarad);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Nanofarad"/>
-        /// </summary>
-        public double Nanofarads => As(ElectricCapacitanceUnit.Nanofarad);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Picofarad"/>
-        /// </summary>
-        public double Picofarads => As(ElectricCapacitanceUnit.Picofarad);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Farad"/>.
-        /// </summary>
-        public static ElectricCapacitance FromFarads(double farads) => new ElectricCapacitance(farads, ElectricCapacitanceUnit.Farad);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Kilofarad"/>.
-        /// </summary>
-        public static ElectricCapacitance FromKilofarads(double kilofarads) => new ElectricCapacitance(kilofarads, ElectricCapacitanceUnit.Kilofarad);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Megafarad"/>.
-        /// </summary>
-        public static ElectricCapacitance FromMegafarads(double megafarads) => new ElectricCapacitance(megafarads, ElectricCapacitanceUnit.Megafarad);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Microfarad"/>.
-        /// </summary>
-        public static ElectricCapacitance FromMicrofarads(double microfarads) => new ElectricCapacitance(microfarads, ElectricCapacitanceUnit.Microfarad);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Millifarad"/>.
-        /// </summary>
-        public static ElectricCapacitance FromMillifarads(double millifarads) => new ElectricCapacitance(millifarads, ElectricCapacitanceUnit.Millifarad);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Nanofarad"/>.
-        /// </summary>
-        public static ElectricCapacitance FromNanofarads(double nanofarads) => new ElectricCapacitance(nanofarads, ElectricCapacitanceUnit.Nanofarad);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Picofarad"/>.
-        /// </summary>
-        public static ElectricCapacitance FromPicofarads(double picofarads) => new ElectricCapacitance(picofarads, ElectricCapacitanceUnit.Picofarad);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricCapacitanceUnit" /> to <see cref="ElectricCapacitance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricCapacitance unit value.</returns>
-        public static ElectricCapacitance From(double value, ElectricCapacitanceUnit fromUnit)
-        {
-            return new ElectricCapacitance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricCapacitanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricCapacitance to another ElectricCapacitance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricCapacitance with the specified unit.</returns>
-                public ElectricCapacitance ToUnit(ElectricCapacitanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricCapacitance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricCapacitanceUnit.Farad => _value,
-                        ElectricCapacitanceUnit.Kilofarad => (_value) * 1e3d,
-                        ElectricCapacitanceUnit.Megafarad => (_value) * 1e6d,
-                        ElectricCapacitanceUnit.Microfarad => (_value) * 1e-6d,
-                        ElectricCapacitanceUnit.Millifarad => (_value) * 1e-3d,
-                        ElectricCapacitanceUnit.Nanofarad => (_value) * 1e-9d,
-                        ElectricCapacitanceUnit.Picofarad => (_value) * 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricCapacitanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricCapacitanceUnit.Farad => baseUnitValue,
-                        ElectricCapacitanceUnit.Kilofarad => (baseUnitValue) / 1e3d,
-                        ElectricCapacitanceUnit.Megafarad => (baseUnitValue) / 1e6d,
-                        ElectricCapacitanceUnit.Microfarad => (baseUnitValue) / 1e-6d,
-                        ElectricCapacitanceUnit.Millifarad => (baseUnitValue) / 1e-3d,
-                        ElectricCapacitanceUnit.Nanofarad => (baseUnitValue) / 1e-9d,
-                        ElectricCapacitanceUnit.Picofarad => (baseUnitValue) / 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCharge.g.cs
deleted file mode 100644
index 0945446f39..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCharge.g.cs
+++ /dev/null
@@ -1,280 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Electric charge is the physical property of matter that causes it to experience a force when placed in an electromagnetic field.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Electric_charge
-    /// </remarks>
-    public struct  ElectricCharge
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricChargeUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricChargeUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricCharge(double value, ElectricChargeUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricCharge, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricChargeUnit BaseUnit { get; } = ElectricChargeUnit.Coulomb;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricCharge.
-        /// </summary>
-        public static ElectricCharge MaxValue { get; } = new ElectricCharge(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricCharge.
-        /// </summary>
-        public static ElectricCharge MinValue { get; } = new ElectricCharge(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricCharge Zero { get; } = new ElectricCharge(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.AmpereHour"/>
-        /// </summary>
-        public double AmpereHours => As(ElectricChargeUnit.AmpereHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Coulomb"/>
-        /// </summary>
-        public double Coulombs => As(ElectricChargeUnit.Coulomb);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.KiloampereHour"/>
-        /// </summary>
-        public double KiloampereHours => As(ElectricChargeUnit.KiloampereHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Kilocoulomb"/>
-        /// </summary>
-        public double Kilocoulombs => As(ElectricChargeUnit.Kilocoulomb);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.MegaampereHour"/>
-        /// </summary>
-        public double MegaampereHours => As(ElectricChargeUnit.MegaampereHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Megacoulomb"/>
-        /// </summary>
-        public double Megacoulombs => As(ElectricChargeUnit.Megacoulomb);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Microcoulomb"/>
-        /// </summary>
-        public double Microcoulombs => As(ElectricChargeUnit.Microcoulomb);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.MilliampereHour"/>
-        /// </summary>
-        public double MilliampereHours => As(ElectricChargeUnit.MilliampereHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Millicoulomb"/>
-        /// </summary>
-        public double Millicoulombs => As(ElectricChargeUnit.Millicoulomb);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Nanocoulomb"/>
-        /// </summary>
-        public double Nanocoulombs => As(ElectricChargeUnit.Nanocoulomb);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Picocoulomb"/>
-        /// </summary>
-        public double Picocoulombs => As(ElectricChargeUnit.Picocoulomb);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.AmpereHour"/>.
-        /// </summary>
-        public static ElectricCharge FromAmpereHours(double amperehours) => new ElectricCharge(amperehours, ElectricChargeUnit.AmpereHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Coulomb"/>.
-        /// </summary>
-        public static ElectricCharge FromCoulombs(double coulombs) => new ElectricCharge(coulombs, ElectricChargeUnit.Coulomb);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.KiloampereHour"/>.
-        /// </summary>
-        public static ElectricCharge FromKiloampereHours(double kiloamperehours) => new ElectricCharge(kiloamperehours, ElectricChargeUnit.KiloampereHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Kilocoulomb"/>.
-        /// </summary>
-        public static ElectricCharge FromKilocoulombs(double kilocoulombs) => new ElectricCharge(kilocoulombs, ElectricChargeUnit.Kilocoulomb);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.MegaampereHour"/>.
-        /// </summary>
-        public static ElectricCharge FromMegaampereHours(double megaamperehours) => new ElectricCharge(megaamperehours, ElectricChargeUnit.MegaampereHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Megacoulomb"/>.
-        /// </summary>
-        public static ElectricCharge FromMegacoulombs(double megacoulombs) => new ElectricCharge(megacoulombs, ElectricChargeUnit.Megacoulomb);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Microcoulomb"/>.
-        /// </summary>
-        public static ElectricCharge FromMicrocoulombs(double microcoulombs) => new ElectricCharge(microcoulombs, ElectricChargeUnit.Microcoulomb);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.MilliampereHour"/>.
-        /// </summary>
-        public static ElectricCharge FromMilliampereHours(double milliamperehours) => new ElectricCharge(milliamperehours, ElectricChargeUnit.MilliampereHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Millicoulomb"/>.
-        /// </summary>
-        public static ElectricCharge FromMillicoulombs(double millicoulombs) => new ElectricCharge(millicoulombs, ElectricChargeUnit.Millicoulomb);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Nanocoulomb"/>.
-        /// </summary>
-        public static ElectricCharge FromNanocoulombs(double nanocoulombs) => new ElectricCharge(nanocoulombs, ElectricChargeUnit.Nanocoulomb);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Picocoulomb"/>.
-        /// </summary>
-        public static ElectricCharge FromPicocoulombs(double picocoulombs) => new ElectricCharge(picocoulombs, ElectricChargeUnit.Picocoulomb);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricChargeUnit" /> to <see cref="ElectricCharge" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricCharge unit value.</returns>
-        public static ElectricCharge From(double value, ElectricChargeUnit fromUnit)
-        {
-            return new ElectricCharge(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricChargeUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricCharge to another ElectricCharge with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricCharge with the specified unit.</returns>
-                public ElectricCharge ToUnit(ElectricChargeUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricCharge(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricChargeUnit.AmpereHour => _value * 3600,
-                        ElectricChargeUnit.Coulomb => _value,
-                        ElectricChargeUnit.KiloampereHour => (_value * 3600) * 1e3d,
-                        ElectricChargeUnit.Kilocoulomb => (_value) * 1e3d,
-                        ElectricChargeUnit.MegaampereHour => (_value * 3600) * 1e6d,
-                        ElectricChargeUnit.Megacoulomb => (_value) * 1e6d,
-                        ElectricChargeUnit.Microcoulomb => (_value) * 1e-6d,
-                        ElectricChargeUnit.MilliampereHour => (_value * 3600) * 1e-3d,
-                        ElectricChargeUnit.Millicoulomb => (_value) * 1e-3d,
-                        ElectricChargeUnit.Nanocoulomb => (_value) * 1e-9d,
-                        ElectricChargeUnit.Picocoulomb => (_value) * 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricChargeUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricChargeUnit.AmpereHour => baseUnitValue / 3600,
-                        ElectricChargeUnit.Coulomb => baseUnitValue,
-                        ElectricChargeUnit.KiloampereHour => (baseUnitValue / 3600) / 1e3d,
-                        ElectricChargeUnit.Kilocoulomb => (baseUnitValue) / 1e3d,
-                        ElectricChargeUnit.MegaampereHour => (baseUnitValue / 3600) / 1e6d,
-                        ElectricChargeUnit.Megacoulomb => (baseUnitValue) / 1e6d,
-                        ElectricChargeUnit.Microcoulomb => (baseUnitValue) / 1e-6d,
-                        ElectricChargeUnit.MilliampereHour => (baseUnitValue / 3600) / 1e-3d,
-                        ElectricChargeUnit.Millicoulomb => (baseUnitValue) / 1e-3d,
-                        ElectricChargeUnit.Nanocoulomb => (baseUnitValue) / 1e-9d,
-                        ElectricChargeUnit.Picocoulomb => (baseUnitValue) / 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
deleted file mode 100644
index d6756615c0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In electromagnetism, charge density is a measure of the amount of electric charge per volume.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Charge_density
-    /// </remarks>
-    public struct  ElectricChargeDensity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricChargeDensityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricChargeDensityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricChargeDensity(double value, ElectricChargeDensityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricChargeDensity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricChargeDensityUnit BaseUnit { get; } = ElectricChargeDensityUnit.CoulombPerCubicMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricChargeDensity.
-        /// </summary>
-        public static ElectricChargeDensity MaxValue { get; } = new ElectricChargeDensity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricChargeDensity.
-        /// </summary>
-        public static ElectricChargeDensity MinValue { get; } = new ElectricChargeDensity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricChargeDensity Zero { get; } = new ElectricChargeDensity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeDensityUnit.CoulombPerCubicMeter"/>
-        /// </summary>
-        public double CoulombsPerCubicMeter => As(ElectricChargeDensityUnit.CoulombPerCubicMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricChargeDensity"/> from <see cref="ElectricChargeDensityUnit.CoulombPerCubicMeter"/>.
-        /// </summary>
-        public static ElectricChargeDensity FromCoulombsPerCubicMeter(double coulombspercubicmeter) => new ElectricChargeDensity(coulombspercubicmeter, ElectricChargeDensityUnit.CoulombPerCubicMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricChargeDensityUnit" /> to <see cref="ElectricChargeDensity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricChargeDensity unit value.</returns>
-        public static ElectricChargeDensity From(double value, ElectricChargeDensityUnit fromUnit)
-        {
-            return new ElectricChargeDensity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricChargeDensityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricChargeDensity to another ElectricChargeDensity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricChargeDensity with the specified unit.</returns>
-                public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricChargeDensity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricChargeDensityUnit.CoulombPerCubicMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricChargeDensityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricChargeDensityUnit.CoulombPerCubicMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricConductance.g.cs
deleted file mode 100644
index ba5038103d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricConductance.g.cs
+++ /dev/null
@@ -1,340 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The electrical conductance of an object is a measure of the ease with which an electric current passes. Along with susceptance, it is one of two elements of admittance. Its reciprocal quantity is electrical resistance.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Electrical_resistance_and_conductance
-    /// </remarks>
-    public struct  ElectricConductance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricConductanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricConductanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricConductance(double value, ElectricConductanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricConductance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricConductanceUnit BaseUnit { get; } = ElectricConductanceUnit.Siemens;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricConductance.
-        /// </summary>
-        public static ElectricConductance MaxValue { get; } = new ElectricConductance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricConductance.
-        /// </summary>
-        public static ElectricConductance MinValue { get; } = new ElectricConductance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricConductance Zero { get; } = new ElectricConductance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Gigamho"/>
-        /// </summary>
-        public double Gigamhos => As(ElectricConductanceUnit.Gigamho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Gigasiemens"/>
-        /// </summary>
-        public double Gigasiemens => As(ElectricConductanceUnit.Gigasiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Kilomho"/>
-        /// </summary>
-        public double Kilomhos => As(ElectricConductanceUnit.Kilomho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Kilosiemens"/>
-        /// </summary>
-        public double Kilosiemens => As(ElectricConductanceUnit.Kilosiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Megamho"/>
-        /// </summary>
-        public double Megamhos => As(ElectricConductanceUnit.Megamho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Megasiemens"/>
-        /// </summary>
-        public double Megasiemens => As(ElectricConductanceUnit.Megasiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Mho"/>
-        /// </summary>
-        public double Mhos => As(ElectricConductanceUnit.Mho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Micromho"/>
-        /// </summary>
-        public double Micromhos => As(ElectricConductanceUnit.Micromho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Microsiemens"/>
-        /// </summary>
-        public double Microsiemens => As(ElectricConductanceUnit.Microsiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Millimho"/>
-        /// </summary>
-        public double Millimhos => As(ElectricConductanceUnit.Millimho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Millisiemens"/>
-        /// </summary>
-        public double Millisiemens => As(ElectricConductanceUnit.Millisiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Nanomho"/>
-        /// </summary>
-        public double Nanomhos => As(ElectricConductanceUnit.Nanomho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Nanosiemens"/>
-        /// </summary>
-        public double Nanosiemens => As(ElectricConductanceUnit.Nanosiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Siemens"/>
-        /// </summary>
-        public double Siemens => As(ElectricConductanceUnit.Siemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Teramho"/>
-        /// </summary>
-        public double Teramhos => As(ElectricConductanceUnit.Teramho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Terasiemens"/>
-        /// </summary>
-        public double Terasiemens => As(ElectricConductanceUnit.Terasiemens);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Gigamho"/>.
-        /// </summary>
-        public static ElectricConductance FromGigamhos(double gigamhos) => new ElectricConductance(gigamhos, ElectricConductanceUnit.Gigamho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Gigasiemens"/>.
-        /// </summary>
-        public static ElectricConductance FromGigasiemens(double gigasiemens) => new ElectricConductance(gigasiemens, ElectricConductanceUnit.Gigasiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Kilomho"/>.
-        /// </summary>
-        public static ElectricConductance FromKilomhos(double kilomhos) => new ElectricConductance(kilomhos, ElectricConductanceUnit.Kilomho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Kilosiemens"/>.
-        /// </summary>
-        public static ElectricConductance FromKilosiemens(double kilosiemens) => new ElectricConductance(kilosiemens, ElectricConductanceUnit.Kilosiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Megamho"/>.
-        /// </summary>
-        public static ElectricConductance FromMegamhos(double megamhos) => new ElectricConductance(megamhos, ElectricConductanceUnit.Megamho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Megasiemens"/>.
-        /// </summary>
-        public static ElectricConductance FromMegasiemens(double megasiemens) => new ElectricConductance(megasiemens, ElectricConductanceUnit.Megasiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Mho"/>.
-        /// </summary>
-        public static ElectricConductance FromMhos(double mhos) => new ElectricConductance(mhos, ElectricConductanceUnit.Mho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Micromho"/>.
-        /// </summary>
-        public static ElectricConductance FromMicromhos(double micromhos) => new ElectricConductance(micromhos, ElectricConductanceUnit.Micromho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Microsiemens"/>.
-        /// </summary>
-        public static ElectricConductance FromMicrosiemens(double microsiemens) => new ElectricConductance(microsiemens, ElectricConductanceUnit.Microsiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Millimho"/>.
-        /// </summary>
-        public static ElectricConductance FromMillimhos(double millimhos) => new ElectricConductance(millimhos, ElectricConductanceUnit.Millimho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Millisiemens"/>.
-        /// </summary>
-        public static ElectricConductance FromMillisiemens(double millisiemens) => new ElectricConductance(millisiemens, ElectricConductanceUnit.Millisiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Nanomho"/>.
-        /// </summary>
-        public static ElectricConductance FromNanomhos(double nanomhos) => new ElectricConductance(nanomhos, ElectricConductanceUnit.Nanomho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Nanosiemens"/>.
-        /// </summary>
-        public static ElectricConductance FromNanosiemens(double nanosiemens) => new ElectricConductance(nanosiemens, ElectricConductanceUnit.Nanosiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Siemens"/>.
-        /// </summary>
-        public static ElectricConductance FromSiemens(double siemens) => new ElectricConductance(siemens, ElectricConductanceUnit.Siemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Teramho"/>.
-        /// </summary>
-        public static ElectricConductance FromTeramhos(double teramhos) => new ElectricConductance(teramhos, ElectricConductanceUnit.Teramho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Terasiemens"/>.
-        /// </summary>
-        public static ElectricConductance FromTerasiemens(double terasiemens) => new ElectricConductance(terasiemens, ElectricConductanceUnit.Terasiemens);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricConductanceUnit" /> to <see cref="ElectricConductance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricConductance unit value.</returns>
-        public static ElectricConductance From(double value, ElectricConductanceUnit fromUnit)
-        {
-            return new ElectricConductance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricConductanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricConductance to another ElectricConductance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricConductance with the specified unit.</returns>
-                public ElectricConductance ToUnit(ElectricConductanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricConductance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricConductanceUnit.Gigamho => (_value) * 1e9d,
-                        ElectricConductanceUnit.Gigasiemens => (_value) * 1e9d,
-                        ElectricConductanceUnit.Kilomho => (_value) * 1e3d,
-                        ElectricConductanceUnit.Kilosiemens => (_value) * 1e3d,
-                        ElectricConductanceUnit.Megamho => (_value) * 1e6d,
-                        ElectricConductanceUnit.Megasiemens => (_value) * 1e6d,
-                        ElectricConductanceUnit.Mho => _value,
-                        ElectricConductanceUnit.Micromho => (_value) * 1e-6d,
-                        ElectricConductanceUnit.Microsiemens => (_value) * 1e-6d,
-                        ElectricConductanceUnit.Millimho => (_value) * 1e-3d,
-                        ElectricConductanceUnit.Millisiemens => (_value) * 1e-3d,
-                        ElectricConductanceUnit.Nanomho => (_value) * 1e-9d,
-                        ElectricConductanceUnit.Nanosiemens => (_value) * 1e-9d,
-                        ElectricConductanceUnit.Siemens => _value,
-                        ElectricConductanceUnit.Teramho => (_value) * 1e12d,
-                        ElectricConductanceUnit.Terasiemens => (_value) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricConductanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricConductanceUnit.Gigamho => (baseUnitValue) / 1e9d,
-                        ElectricConductanceUnit.Gigasiemens => (baseUnitValue) / 1e9d,
-                        ElectricConductanceUnit.Kilomho => (baseUnitValue) / 1e3d,
-                        ElectricConductanceUnit.Kilosiemens => (baseUnitValue) / 1e3d,
-                        ElectricConductanceUnit.Megamho => (baseUnitValue) / 1e6d,
-                        ElectricConductanceUnit.Megasiemens => (baseUnitValue) / 1e6d,
-                        ElectricConductanceUnit.Mho => baseUnitValue,
-                        ElectricConductanceUnit.Micromho => (baseUnitValue) / 1e-6d,
-                        ElectricConductanceUnit.Microsiemens => (baseUnitValue) / 1e-6d,
-                        ElectricConductanceUnit.Millimho => (baseUnitValue) / 1e-3d,
-                        ElectricConductanceUnit.Millisiemens => (baseUnitValue) / 1e-3d,
-                        ElectricConductanceUnit.Nanomho => (baseUnitValue) / 1e-9d,
-                        ElectricConductanceUnit.Nanosiemens => (baseUnitValue) / 1e-9d,
-                        ElectricConductanceUnit.Siemens => baseUnitValue,
-                        ElectricConductanceUnit.Teramho => (baseUnitValue) / 1e12d,
-                        ElectricConductanceUnit.Terasiemens => (baseUnitValue) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricConductivity.g.cs
deleted file mode 100644
index dcc2d1a6ef..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricConductivity.g.cs
+++ /dev/null
@@ -1,220 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Electrical conductivity or specific conductance is the reciprocal of electrical resistivity, and measures a material's ability to conduct an electric current.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Electrical_resistivity_and_conductivity
-    /// </remarks>
-    public struct  ElectricConductivity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricConductivityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricConductivityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricConductivity(double value, ElectricConductivityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricConductivity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricConductivityUnit BaseUnit { get; } = ElectricConductivityUnit.SiemensPerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricConductivity.
-        /// </summary>
-        public static ElectricConductivity MaxValue { get; } = new ElectricConductivity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricConductivity.
-        /// </summary>
-        public static ElectricConductivity MinValue { get; } = new ElectricConductivity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricConductivity Zero { get; } = new ElectricConductivity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.MicrosiemensPerCentimeter"/>
-        /// </summary>
-        public double MicrosiemensPerCentimeter => As(ElectricConductivityUnit.MicrosiemensPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.MillisiemensPerCentimeter"/>
-        /// </summary>
-        public double MillisiemensPerCentimeter => As(ElectricConductivityUnit.MillisiemensPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerCentimeter"/>
-        /// </summary>
-        public double SiemensPerCentimeter => As(ElectricConductivityUnit.SiemensPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerFoot"/>
-        /// </summary>
-        public double SiemensPerFoot => As(ElectricConductivityUnit.SiemensPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerInch"/>
-        /// </summary>
-        public double SiemensPerInch => As(ElectricConductivityUnit.SiemensPerInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerMeter"/>
-        /// </summary>
-        public double SiemensPerMeter => As(ElectricConductivityUnit.SiemensPerMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.MicrosiemensPerCentimeter"/>.
-        /// </summary>
-        public static ElectricConductivity FromMicrosiemensPerCentimeter(double microsiemenspercentimeter) => new ElectricConductivity(microsiemenspercentimeter, ElectricConductivityUnit.MicrosiemensPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.MillisiemensPerCentimeter"/>.
-        /// </summary>
-        public static ElectricConductivity FromMillisiemensPerCentimeter(double millisiemenspercentimeter) => new ElectricConductivity(millisiemenspercentimeter, ElectricConductivityUnit.MillisiemensPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerCentimeter"/>.
-        /// </summary>
-        public static ElectricConductivity FromSiemensPerCentimeter(double siemenspercentimeter) => new ElectricConductivity(siemenspercentimeter, ElectricConductivityUnit.SiemensPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerFoot"/>.
-        /// </summary>
-        public static ElectricConductivity FromSiemensPerFoot(double siemensperfoot) => new ElectricConductivity(siemensperfoot, ElectricConductivityUnit.SiemensPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerInch"/>.
-        /// </summary>
-        public static ElectricConductivity FromSiemensPerInch(double siemensperinch) => new ElectricConductivity(siemensperinch, ElectricConductivityUnit.SiemensPerInch);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerMeter"/>.
-        /// </summary>
-        public static ElectricConductivity FromSiemensPerMeter(double siemenspermeter) => new ElectricConductivity(siemenspermeter, ElectricConductivityUnit.SiemensPerMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricConductivityUnit" /> to <see cref="ElectricConductivity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricConductivity unit value.</returns>
-        public static ElectricConductivity From(double value, ElectricConductivityUnit fromUnit)
-        {
-            return new ElectricConductivity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricConductivityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricConductivity to another ElectricConductivity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricConductivity with the specified unit.</returns>
-                public ElectricConductivity ToUnit(ElectricConductivityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricConductivity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricConductivityUnit.MicrosiemensPerCentimeter => (_value * 1e2) * 1e-6d,
-                        ElectricConductivityUnit.MillisiemensPerCentimeter => (_value * 1e2) * 1e-3d,
-                        ElectricConductivityUnit.SiemensPerCentimeter => _value * 1e2,
-                        ElectricConductivityUnit.SiemensPerFoot => _value / 0.3048,
-                        ElectricConductivityUnit.SiemensPerInch => _value / 2.54e-2,
-                        ElectricConductivityUnit.SiemensPerMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricConductivityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricConductivityUnit.MicrosiemensPerCentimeter => (baseUnitValue / 1e2) / 1e-6d,
-                        ElectricConductivityUnit.MillisiemensPerCentimeter => (baseUnitValue / 1e2) / 1e-3d,
-                        ElectricConductivityUnit.SiemensPerCentimeter => baseUnitValue / 1e2,
-                        ElectricConductivityUnit.SiemensPerFoot => baseUnitValue * 0.3048,
-                        ElectricConductivityUnit.SiemensPerInch => baseUnitValue * 2.54e-2,
-                        ElectricConductivityUnit.SiemensPerMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrent.g.cs
deleted file mode 100644
index b72fdf8595..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrent.g.cs
+++ /dev/null
@@ -1,256 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     An electric current is a flow of electric charge. In electric circuits this charge is often carried by moving electrons in a wire. It can also be carried by ions in an electrolyte, or by both ions and electrons such as in a plasma.
-    /// </summary>
-    /// <remarks>
-    ///     If you want to map more parameters into the <c>ElectricCurrent</c> class (amps RMS, phase angle, etc.), create your own wrapper type such as a record or named tuple.
-    /// </remarks>
-    public struct  ElectricCurrent
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricCurrentUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricCurrentUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricCurrent(double value, ElectricCurrentUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricCurrent, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricCurrentUnit BaseUnit { get; } = ElectricCurrentUnit.Ampere;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricCurrent.
-        /// </summary>
-        public static ElectricCurrent MaxValue { get; } = new ElectricCurrent(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricCurrent.
-        /// </summary>
-        public static ElectricCurrent MinValue { get; } = new ElectricCurrent(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricCurrent Zero { get; } = new ElectricCurrent(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Ampere"/>
-        /// </summary>
-        public double Amperes => As(ElectricCurrentUnit.Ampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Centiampere"/>
-        /// </summary>
-        public double Centiamperes => As(ElectricCurrentUnit.Centiampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Femtoampere"/>
-        /// </summary>
-        public double Femtoamperes => As(ElectricCurrentUnit.Femtoampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Kiloampere"/>
-        /// </summary>
-        public double Kiloamperes => As(ElectricCurrentUnit.Kiloampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Megaampere"/>
-        /// </summary>
-        public double Megaamperes => As(ElectricCurrentUnit.Megaampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Microampere"/>
-        /// </summary>
-        public double Microamperes => As(ElectricCurrentUnit.Microampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Milliampere"/>
-        /// </summary>
-        public double Milliamperes => As(ElectricCurrentUnit.Milliampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Nanoampere"/>
-        /// </summary>
-        public double Nanoamperes => As(ElectricCurrentUnit.Nanoampere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Picoampere"/>
-        /// </summary>
-        public double Picoamperes => As(ElectricCurrentUnit.Picoampere);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Ampere"/>.
-        /// </summary>
-        public static ElectricCurrent FromAmperes(double amperes) => new ElectricCurrent(amperes, ElectricCurrentUnit.Ampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Centiampere"/>.
-        /// </summary>
-        public static ElectricCurrent FromCentiamperes(double centiamperes) => new ElectricCurrent(centiamperes, ElectricCurrentUnit.Centiampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Femtoampere"/>.
-        /// </summary>
-        public static ElectricCurrent FromFemtoamperes(double femtoamperes) => new ElectricCurrent(femtoamperes, ElectricCurrentUnit.Femtoampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Kiloampere"/>.
-        /// </summary>
-        public static ElectricCurrent FromKiloamperes(double kiloamperes) => new ElectricCurrent(kiloamperes, ElectricCurrentUnit.Kiloampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Megaampere"/>.
-        /// </summary>
-        public static ElectricCurrent FromMegaamperes(double megaamperes) => new ElectricCurrent(megaamperes, ElectricCurrentUnit.Megaampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Microampere"/>.
-        /// </summary>
-        public static ElectricCurrent FromMicroamperes(double microamperes) => new ElectricCurrent(microamperes, ElectricCurrentUnit.Microampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Milliampere"/>.
-        /// </summary>
-        public static ElectricCurrent FromMilliamperes(double milliamperes) => new ElectricCurrent(milliamperes, ElectricCurrentUnit.Milliampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Nanoampere"/>.
-        /// </summary>
-        public static ElectricCurrent FromNanoamperes(double nanoamperes) => new ElectricCurrent(nanoamperes, ElectricCurrentUnit.Nanoampere);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Picoampere"/>.
-        /// </summary>
-        public static ElectricCurrent FromPicoamperes(double picoamperes) => new ElectricCurrent(picoamperes, ElectricCurrentUnit.Picoampere);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricCurrentUnit" /> to <see cref="ElectricCurrent" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricCurrent unit value.</returns>
-        public static ElectricCurrent From(double value, ElectricCurrentUnit fromUnit)
-        {
-            return new ElectricCurrent(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricCurrentUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricCurrent to another ElectricCurrent with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricCurrent with the specified unit.</returns>
-                public ElectricCurrent ToUnit(ElectricCurrentUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricCurrent(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricCurrentUnit.Ampere => _value,
-                        ElectricCurrentUnit.Centiampere => (_value) * 1e-2d,
-                        ElectricCurrentUnit.Femtoampere => (_value) * 1e-15d,
-                        ElectricCurrentUnit.Kiloampere => (_value) * 1e3d,
-                        ElectricCurrentUnit.Megaampere => (_value) * 1e6d,
-                        ElectricCurrentUnit.Microampere => (_value) * 1e-6d,
-                        ElectricCurrentUnit.Milliampere => (_value) * 1e-3d,
-                        ElectricCurrentUnit.Nanoampere => (_value) * 1e-9d,
-                        ElectricCurrentUnit.Picoampere => (_value) * 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricCurrentUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricCurrentUnit.Ampere => baseUnitValue,
-                        ElectricCurrentUnit.Centiampere => (baseUnitValue) / 1e-2d,
-                        ElectricCurrentUnit.Femtoampere => (baseUnitValue) / 1e-15d,
-                        ElectricCurrentUnit.Kiloampere => (baseUnitValue) / 1e3d,
-                        ElectricCurrentUnit.Megaampere => (baseUnitValue) / 1e6d,
-                        ElectricCurrentUnit.Microampere => (baseUnitValue) / 1e-6d,
-                        ElectricCurrentUnit.Milliampere => (baseUnitValue) / 1e-3d,
-                        ElectricCurrentUnit.Nanoampere => (baseUnitValue) / 1e-9d,
-                        ElectricCurrentUnit.Picoampere => (baseUnitValue) / 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
deleted file mode 100644
index ab7ba48bdc..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
+++ /dev/null
@@ -1,184 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In electromagnetism, current density is the electric current per unit area of cross section.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Current_density
-    /// </remarks>
-    public struct  ElectricCurrentDensity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricCurrentDensityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricCurrentDensityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricCurrentDensity(double value, ElectricCurrentDensityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricCurrentDensity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricCurrentDensityUnit BaseUnit { get; } = ElectricCurrentDensityUnit.AmperePerSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricCurrentDensity.
-        /// </summary>
-        public static ElectricCurrentDensity MaxValue { get; } = new ElectricCurrentDensity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricCurrentDensity.
-        /// </summary>
-        public static ElectricCurrentDensity MinValue { get; } = new ElectricCurrentDensity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricCurrentDensity Zero { get; } = new ElectricCurrentDensity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentDensityUnit.AmperePerSquareFoot"/>
-        /// </summary>
-        public double AmperesPerSquareFoot => As(ElectricCurrentDensityUnit.AmperePerSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentDensityUnit.AmperePerSquareInch"/>
-        /// </summary>
-        public double AmperesPerSquareInch => As(ElectricCurrentDensityUnit.AmperePerSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentDensityUnit.AmperePerSquareMeter"/>
-        /// </summary>
-        public double AmperesPerSquareMeter => As(ElectricCurrentDensityUnit.AmperePerSquareMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareFoot"/>.
-        /// </summary>
-        public static ElectricCurrentDensity FromAmperesPerSquareFoot(double amperespersquarefoot) => new ElectricCurrentDensity(amperespersquarefoot, ElectricCurrentDensityUnit.AmperePerSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareInch"/>.
-        /// </summary>
-        public static ElectricCurrentDensity FromAmperesPerSquareInch(double amperespersquareinch) => new ElectricCurrentDensity(amperespersquareinch, ElectricCurrentDensityUnit.AmperePerSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareMeter"/>.
-        /// </summary>
-        public static ElectricCurrentDensity FromAmperesPerSquareMeter(double amperespersquaremeter) => new ElectricCurrentDensity(amperespersquaremeter, ElectricCurrentDensityUnit.AmperePerSquareMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricCurrentDensityUnit" /> to <see cref="ElectricCurrentDensity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricCurrentDensity unit value.</returns>
-        public static ElectricCurrentDensity From(double value, ElectricCurrentDensityUnit fromUnit)
-        {
-            return new ElectricCurrentDensity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricCurrentDensityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricCurrentDensity to another ElectricCurrentDensity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricCurrentDensity with the specified unit.</returns>
-                public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricCurrentDensity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricCurrentDensityUnit.AmperePerSquareFoot => _value / 9.290304e-2,
-                        ElectricCurrentDensityUnit.AmperePerSquareInch => _value / 0.00064516,
-                        ElectricCurrentDensityUnit.AmperePerSquareMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricCurrentDensityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricCurrentDensityUnit.AmperePerSquareFoot => baseUnitValue * 9.290304e-2,
-                        ElectricCurrentDensityUnit.AmperePerSquareInch => baseUnitValue * 0.00064516,
-                        ElectricCurrentDensityUnit.AmperePerSquareMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
deleted file mode 100644
index cddbfbcef7..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
+++ /dev/null
@@ -1,229 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In electromagnetism, the current gradient describes how the current changes in time.
-    /// </summary>
-    public struct  ElectricCurrentGradient
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricCurrentGradientUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricCurrentGradientUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricCurrentGradient(double value, ElectricCurrentGradientUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricCurrentGradient, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricCurrentGradientUnit BaseUnit { get; } = ElectricCurrentGradientUnit.AmperePerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricCurrentGradient.
-        /// </summary>
-        public static ElectricCurrentGradient MaxValue { get; } = new ElectricCurrentGradient(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricCurrentGradient.
-        /// </summary>
-        public static ElectricCurrentGradient MinValue { get; } = new ElectricCurrentGradient(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricCurrentGradient Zero { get; } = new ElectricCurrentGradient(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerMicrosecond"/>
-        /// </summary>
-        public double AmperesPerMicrosecond => As(ElectricCurrentGradientUnit.AmperePerMicrosecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerMillisecond"/>
-        /// </summary>
-        public double AmperesPerMillisecond => As(ElectricCurrentGradientUnit.AmperePerMillisecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerMinute"/>
-        /// </summary>
-        public double AmperesPerMinute => As(ElectricCurrentGradientUnit.AmperePerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerNanosecond"/>
-        /// </summary>
-        public double AmperesPerNanosecond => As(ElectricCurrentGradientUnit.AmperePerNanosecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerSecond"/>
-        /// </summary>
-        public double AmperesPerSecond => As(ElectricCurrentGradientUnit.AmperePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.MilliamperePerMinute"/>
-        /// </summary>
-        public double MilliamperesPerMinute => As(ElectricCurrentGradientUnit.MilliamperePerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.MilliamperePerSecond"/>
-        /// </summary>
-        public double MilliamperesPerSecond => As(ElectricCurrentGradientUnit.MilliamperePerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMicrosecond"/>.
-        /// </summary>
-        public static ElectricCurrentGradient FromAmperesPerMicrosecond(double amperespermicrosecond) => new ElectricCurrentGradient(amperespermicrosecond, ElectricCurrentGradientUnit.AmperePerMicrosecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMillisecond"/>.
-        /// </summary>
-        public static ElectricCurrentGradient FromAmperesPerMillisecond(double amperespermillisecond) => new ElectricCurrentGradient(amperespermillisecond, ElectricCurrentGradientUnit.AmperePerMillisecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMinute"/>.
-        /// </summary>
-        public static ElectricCurrentGradient FromAmperesPerMinute(double amperesperminute) => new ElectricCurrentGradient(amperesperminute, ElectricCurrentGradientUnit.AmperePerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerNanosecond"/>.
-        /// </summary>
-        public static ElectricCurrentGradient FromAmperesPerNanosecond(double amperespernanosecond) => new ElectricCurrentGradient(amperespernanosecond, ElectricCurrentGradientUnit.AmperePerNanosecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerSecond"/>.
-        /// </summary>
-        public static ElectricCurrentGradient FromAmperesPerSecond(double amperespersecond) => new ElectricCurrentGradient(amperespersecond, ElectricCurrentGradientUnit.AmperePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.MilliamperePerMinute"/>.
-        /// </summary>
-        public static ElectricCurrentGradient FromMilliamperesPerMinute(double milliamperesperminute) => new ElectricCurrentGradient(milliamperesperminute, ElectricCurrentGradientUnit.MilliamperePerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.MilliamperePerSecond"/>.
-        /// </summary>
-        public static ElectricCurrentGradient FromMilliamperesPerSecond(double milliamperespersecond) => new ElectricCurrentGradient(milliamperespersecond, ElectricCurrentGradientUnit.MilliamperePerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricCurrentGradientUnit" /> to <see cref="ElectricCurrentGradient" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricCurrentGradient unit value.</returns>
-        public static ElectricCurrentGradient From(double value, ElectricCurrentGradientUnit fromUnit)
-        {
-            return new ElectricCurrentGradient(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricCurrentGradientUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricCurrentGradient to another ElectricCurrentGradient with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricCurrentGradient with the specified unit.</returns>
-                public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricCurrentGradient(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricCurrentGradientUnit.AmperePerMicrosecond => _value * 1E6,
-                        ElectricCurrentGradientUnit.AmperePerMillisecond => _value * 1E3,
-                        ElectricCurrentGradientUnit.AmperePerMinute => _value / 60,
-                        ElectricCurrentGradientUnit.AmperePerNanosecond => _value * 1E9,
-                        ElectricCurrentGradientUnit.AmperePerSecond => _value,
-                        ElectricCurrentGradientUnit.MilliamperePerMinute => (_value / 60) * 1e-3d,
-                        ElectricCurrentGradientUnit.MilliamperePerSecond => (_value) * 1e-3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricCurrentGradientUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricCurrentGradientUnit.AmperePerMicrosecond => baseUnitValue / 1E6,
-                        ElectricCurrentGradientUnit.AmperePerMillisecond => baseUnitValue / 1E3,
-                        ElectricCurrentGradientUnit.AmperePerMinute => baseUnitValue * 60,
-                        ElectricCurrentGradientUnit.AmperePerNanosecond => baseUnitValue / 1E9,
-                        ElectricCurrentGradientUnit.AmperePerSecond => baseUnitValue,
-                        ElectricCurrentGradientUnit.MilliamperePerMinute => (baseUnitValue * 60) / 1e-3d,
-                        ElectricCurrentGradientUnit.MilliamperePerSecond => (baseUnitValue) / 1e-3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricField.g.cs
deleted file mode 100644
index 0d5c1ae132..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricField.g.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     An electric field is a force field that surrounds electric charges that attracts or repels other electric charges.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Electric_field
-    /// </remarks>
-    public struct  ElectricField
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricFieldUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricFieldUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricField(double value, ElectricFieldUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricField, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricFieldUnit BaseUnit { get; } = ElectricFieldUnit.VoltPerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricField.
-        /// </summary>
-        public static ElectricField MaxValue { get; } = new ElectricField(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricField.
-        /// </summary>
-        public static ElectricField MinValue { get; } = new ElectricField(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricField Zero { get; } = new ElectricField(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricFieldUnit.VoltPerMeter"/>
-        /// </summary>
-        public double VoltsPerMeter => As(ElectricFieldUnit.VoltPerMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricField"/> from <see cref="ElectricFieldUnit.VoltPerMeter"/>.
-        /// </summary>
-        public static ElectricField FromVoltsPerMeter(double voltspermeter) => new ElectricField(voltspermeter, ElectricFieldUnit.VoltPerMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricFieldUnit" /> to <see cref="ElectricField" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricField unit value.</returns>
-        public static ElectricField From(double value, ElectricFieldUnit fromUnit)
-        {
-            return new ElectricField(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricFieldUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricField to another ElectricField with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricField with the specified unit.</returns>
-                public ElectricField ToUnit(ElectricFieldUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricField(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricFieldUnit.VoltPerMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricFieldUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricFieldUnit.VoltPerMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricImpedance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricImpedance.g.cs
deleted file mode 100644
index e6629ce635..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricImpedance.g.cs
+++ /dev/null
@@ -1,245 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Electric impedance is the opposition to alternating current presented by the combined effect of resistance and reactance in a circuit. It is defined as the inverse of admittance. The SI unit of impedance is the ohm (symbol Ω).
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Electrical_impedance
-    /// </remarks>
-    [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
-    public struct  ElectricImpedance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricImpedanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricImpedanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricImpedance(double value, ElectricImpedanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricImpedance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricImpedanceUnit BaseUnit { get; } = ElectricImpedanceUnit.Ohm;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricImpedance.
-        /// </summary>
-        public static ElectricImpedance MaxValue { get; } = new ElectricImpedance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricImpedance.
-        /// </summary>
-        public static ElectricImpedance MinValue { get; } = new ElectricImpedance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricImpedance Zero { get; } = new ElectricImpedance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Gigaohm"/>
-        /// </summary>
-        public double Gigaohms => As(ElectricImpedanceUnit.Gigaohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Kiloohm"/>
-        /// </summary>
-        public double Kiloohms => As(ElectricImpedanceUnit.Kiloohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Megaohm"/>
-        /// </summary>
-        public double Megaohms => As(ElectricImpedanceUnit.Megaohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Microohm"/>
-        /// </summary>
-        public double Microohms => As(ElectricImpedanceUnit.Microohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Milliohm"/>
-        /// </summary>
-        public double Milliohms => As(ElectricImpedanceUnit.Milliohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Nanoohm"/>
-        /// </summary>
-        public double Nanoohms => As(ElectricImpedanceUnit.Nanoohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Ohm"/>
-        /// </summary>
-        public double Ohms => As(ElectricImpedanceUnit.Ohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Teraohm"/>
-        /// </summary>
-        public double Teraohms => As(ElectricImpedanceUnit.Teraohm);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Gigaohm"/>.
-        /// </summary>
-        public static ElectricImpedance FromGigaohms(double gigaohms) => new ElectricImpedance(gigaohms, ElectricImpedanceUnit.Gigaohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Kiloohm"/>.
-        /// </summary>
-        public static ElectricImpedance FromKiloohms(double kiloohms) => new ElectricImpedance(kiloohms, ElectricImpedanceUnit.Kiloohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Megaohm"/>.
-        /// </summary>
-        public static ElectricImpedance FromMegaohms(double megaohms) => new ElectricImpedance(megaohms, ElectricImpedanceUnit.Megaohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Microohm"/>.
-        /// </summary>
-        public static ElectricImpedance FromMicroohms(double microohms) => new ElectricImpedance(microohms, ElectricImpedanceUnit.Microohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Milliohm"/>.
-        /// </summary>
-        public static ElectricImpedance FromMilliohms(double milliohms) => new ElectricImpedance(milliohms, ElectricImpedanceUnit.Milliohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Nanoohm"/>.
-        /// </summary>
-        public static ElectricImpedance FromNanoohms(double nanoohms) => new ElectricImpedance(nanoohms, ElectricImpedanceUnit.Nanoohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Ohm"/>.
-        /// </summary>
-        public static ElectricImpedance FromOhms(double ohms) => new ElectricImpedance(ohms, ElectricImpedanceUnit.Ohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Teraohm"/>.
-        /// </summary>
-        public static ElectricImpedance FromTeraohms(double teraohms) => new ElectricImpedance(teraohms, ElectricImpedanceUnit.Teraohm);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricImpedanceUnit" /> to <see cref="ElectricImpedance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricImpedance unit value.</returns>
-        public static ElectricImpedance From(double value, ElectricImpedanceUnit fromUnit)
-        {
-            return new ElectricImpedance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricImpedanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricImpedance to another ElectricImpedance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricImpedance with the specified unit.</returns>
-                public ElectricImpedance ToUnit(ElectricImpedanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricImpedance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricImpedanceUnit.Gigaohm => (_value) * 1e9d,
-                        ElectricImpedanceUnit.Kiloohm => (_value) * 1e3d,
-                        ElectricImpedanceUnit.Megaohm => (_value) * 1e6d,
-                        ElectricImpedanceUnit.Microohm => (_value) * 1e-6d,
-                        ElectricImpedanceUnit.Milliohm => (_value) * 1e-3d,
-                        ElectricImpedanceUnit.Nanoohm => (_value) * 1e-9d,
-                        ElectricImpedanceUnit.Ohm => _value,
-                        ElectricImpedanceUnit.Teraohm => (_value) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricImpedanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricImpedanceUnit.Gigaohm => (baseUnitValue) / 1e9d,
-                        ElectricImpedanceUnit.Kiloohm => (baseUnitValue) / 1e3d,
-                        ElectricImpedanceUnit.Megaohm => (baseUnitValue) / 1e6d,
-                        ElectricImpedanceUnit.Microohm => (baseUnitValue) / 1e-6d,
-                        ElectricImpedanceUnit.Milliohm => (baseUnitValue) / 1e-3d,
-                        ElectricImpedanceUnit.Nanoohm => (baseUnitValue) / 1e-9d,
-                        ElectricImpedanceUnit.Ohm => baseUnitValue,
-                        ElectricImpedanceUnit.Teraohm => (baseUnitValue) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricInductance.g.cs
deleted file mode 100644
index 0d7654d801..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricInductance.g.cs
+++ /dev/null
@@ -1,208 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Inductance is a property of an electrical conductor which opposes a change in current.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Inductance
-    /// </remarks>
-    public struct  ElectricInductance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricInductanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricInductanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricInductance(double value, ElectricInductanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricInductance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricInductanceUnit BaseUnit { get; } = ElectricInductanceUnit.Henry;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricInductance.
-        /// </summary>
-        public static ElectricInductance MaxValue { get; } = new ElectricInductance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricInductance.
-        /// </summary>
-        public static ElectricInductance MinValue { get; } = new ElectricInductance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricInductance Zero { get; } = new ElectricInductance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Henry"/>
-        /// </summary>
-        public double Henries => As(ElectricInductanceUnit.Henry);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Microhenry"/>
-        /// </summary>
-        public double Microhenries => As(ElectricInductanceUnit.Microhenry);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Millihenry"/>
-        /// </summary>
-        public double Millihenries => As(ElectricInductanceUnit.Millihenry);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Nanohenry"/>
-        /// </summary>
-        public double Nanohenries => As(ElectricInductanceUnit.Nanohenry);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Picohenry"/>
-        /// </summary>
-        public double Picohenries => As(ElectricInductanceUnit.Picohenry);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Henry"/>.
-        /// </summary>
-        public static ElectricInductance FromHenries(double henries) => new ElectricInductance(henries, ElectricInductanceUnit.Henry);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Microhenry"/>.
-        /// </summary>
-        public static ElectricInductance FromMicrohenries(double microhenries) => new ElectricInductance(microhenries, ElectricInductanceUnit.Microhenry);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Millihenry"/>.
-        /// </summary>
-        public static ElectricInductance FromMillihenries(double millihenries) => new ElectricInductance(millihenries, ElectricInductanceUnit.Millihenry);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Nanohenry"/>.
-        /// </summary>
-        public static ElectricInductance FromNanohenries(double nanohenries) => new ElectricInductance(nanohenries, ElectricInductanceUnit.Nanohenry);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Picohenry"/>.
-        /// </summary>
-        public static ElectricInductance FromPicohenries(double picohenries) => new ElectricInductance(picohenries, ElectricInductanceUnit.Picohenry);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricInductanceUnit" /> to <see cref="ElectricInductance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricInductance unit value.</returns>
-        public static ElectricInductance From(double value, ElectricInductanceUnit fromUnit)
-        {
-            return new ElectricInductance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricInductanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricInductance to another ElectricInductance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricInductance with the specified unit.</returns>
-                public ElectricInductance ToUnit(ElectricInductanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricInductance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricInductanceUnit.Henry => _value,
-                        ElectricInductanceUnit.Microhenry => (_value) * 1e-6d,
-                        ElectricInductanceUnit.Millihenry => (_value) * 1e-3d,
-                        ElectricInductanceUnit.Nanohenry => (_value) * 1e-9d,
-                        ElectricInductanceUnit.Picohenry => (_value) * 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricInductanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricInductanceUnit.Henry => baseUnitValue,
-                        ElectricInductanceUnit.Microhenry => (baseUnitValue) / 1e-6d,
-                        ElectricInductanceUnit.Millihenry => (baseUnitValue) / 1e-3d,
-                        ElectricInductanceUnit.Nanohenry => (baseUnitValue) / 1e-9d,
-                        ElectricInductanceUnit.Picohenry => (baseUnitValue) / 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricPotential.g.cs
deleted file mode 100644
index ed4f945693..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricPotential.g.cs
+++ /dev/null
@@ -1,220 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In classical electromagnetism, the electric potential (a scalar quantity denoted by Φ, ΦE or V and also called the electric field potential or the electrostatic potential) at a point is the amount of electric potential energy that a unitary point charge would have when located at that point.
-    /// </summary>
-    /// <remarks>
-    ///     If you want to map more parameters into the <c>ElectricPotential</c> class (volts RMS, phase angle, etc.), create your own wrapper type such as a record or named tuple.
-    /// </remarks>
-    public struct  ElectricPotential
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricPotentialUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricPotentialUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricPotential(double value, ElectricPotentialUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricPotential, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricPotentialUnit BaseUnit { get; } = ElectricPotentialUnit.Volt;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricPotential.
-        /// </summary>
-        public static ElectricPotential MaxValue { get; } = new ElectricPotential(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricPotential.
-        /// </summary>
-        public static ElectricPotential MinValue { get; } = new ElectricPotential(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricPotential Zero { get; } = new ElectricPotential(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Kilovolt"/>
-        /// </summary>
-        public double Kilovolts => As(ElectricPotentialUnit.Kilovolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Megavolt"/>
-        /// </summary>
-        public double Megavolts => As(ElectricPotentialUnit.Megavolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Microvolt"/>
-        /// </summary>
-        public double Microvolts => As(ElectricPotentialUnit.Microvolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Millivolt"/>
-        /// </summary>
-        public double Millivolts => As(ElectricPotentialUnit.Millivolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Nanovolt"/>
-        /// </summary>
-        public double Nanovolts => As(ElectricPotentialUnit.Nanovolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Volt"/>
-        /// </summary>
-        public double Volts => As(ElectricPotentialUnit.Volt);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Kilovolt"/>.
-        /// </summary>
-        public static ElectricPotential FromKilovolts(double kilovolts) => new ElectricPotential(kilovolts, ElectricPotentialUnit.Kilovolt);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Megavolt"/>.
-        /// </summary>
-        public static ElectricPotential FromMegavolts(double megavolts) => new ElectricPotential(megavolts, ElectricPotentialUnit.Megavolt);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Microvolt"/>.
-        /// </summary>
-        public static ElectricPotential FromMicrovolts(double microvolts) => new ElectricPotential(microvolts, ElectricPotentialUnit.Microvolt);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Millivolt"/>.
-        /// </summary>
-        public static ElectricPotential FromMillivolts(double millivolts) => new ElectricPotential(millivolts, ElectricPotentialUnit.Millivolt);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Nanovolt"/>.
-        /// </summary>
-        public static ElectricPotential FromNanovolts(double nanovolts) => new ElectricPotential(nanovolts, ElectricPotentialUnit.Nanovolt);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Volt"/>.
-        /// </summary>
-        public static ElectricPotential FromVolts(double volts) => new ElectricPotential(volts, ElectricPotentialUnit.Volt);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricPotentialUnit" /> to <see cref="ElectricPotential" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricPotential unit value.</returns>
-        public static ElectricPotential From(double value, ElectricPotentialUnit fromUnit)
-        {
-            return new ElectricPotential(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricPotentialUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricPotential to another ElectricPotential with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricPotential with the specified unit.</returns>
-                public ElectricPotential ToUnit(ElectricPotentialUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricPotential(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricPotentialUnit.Kilovolt => (_value) * 1e3d,
-                        ElectricPotentialUnit.Megavolt => (_value) * 1e6d,
-                        ElectricPotentialUnit.Microvolt => (_value) * 1e-6d,
-                        ElectricPotentialUnit.Millivolt => (_value) * 1e-3d,
-                        ElectricPotentialUnit.Nanovolt => (_value) * 1e-9d,
-                        ElectricPotentialUnit.Volt => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricPotentialUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricPotentialUnit.Kilovolt => (baseUnitValue) / 1e3d,
-                        ElectricPotentialUnit.Megavolt => (baseUnitValue) / 1e6d,
-                        ElectricPotentialUnit.Microvolt => (baseUnitValue) / 1e-6d,
-                        ElectricPotentialUnit.Millivolt => (baseUnitValue) / 1e-3d,
-                        ElectricPotentialUnit.Nanovolt => (baseUnitValue) / 1e-9d,
-                        ElectricPotentialUnit.Volt => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
deleted file mode 100644
index 4840493913..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
+++ /dev/null
@@ -1,385 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     ElectricPotential change rate is the ratio of the electric potential change to the time during which the change occurred (value of electric potential changes per unit time).
-    /// </summary>
-    public struct  ElectricPotentialChangeRate
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricPotentialChangeRateUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricPotentialChangeRateUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricPotentialChangeRate(double value, ElectricPotentialChangeRateUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricPotentialChangeRate, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricPotentialChangeRateUnit BaseUnit { get; } = ElectricPotentialChangeRateUnit.VoltPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricPotentialChangeRate.
-        /// </summary>
-        public static ElectricPotentialChangeRate MaxValue { get; } = new ElectricPotentialChangeRate(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricPotentialChangeRate.
-        /// </summary>
-        public static ElectricPotentialChangeRate MinValue { get; } = new ElectricPotentialChangeRate(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricPotentialChangeRate Zero { get; } = new ElectricPotentialChangeRate(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerHour"/>
-        /// </summary>
-        public double KilovoltsPerHour => As(ElectricPotentialChangeRateUnit.KilovoltPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond"/>
-        /// </summary>
-        public double KilovoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMinute"/>
-        /// </summary>
-        public double KilovoltsPerMinute => As(ElectricPotentialChangeRateUnit.KilovoltPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerSecond"/>
-        /// </summary>
-        public double KilovoltsPerSecond => As(ElectricPotentialChangeRateUnit.KilovoltPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerHour"/>
-        /// </summary>
-        public double MegavoltsPerHour => As(ElectricPotentialChangeRateUnit.MegavoltPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond"/>
-        /// </summary>
-        public double MegavoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMinute"/>
-        /// </summary>
-        public double MegavoltsPerMinute => As(ElectricPotentialChangeRateUnit.MegavoltPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerSecond"/>
-        /// </summary>
-        public double MegavoltsPerSecond => As(ElectricPotentialChangeRateUnit.MegavoltPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerHour"/>
-        /// </summary>
-        public double MicrovoltsPerHour => As(ElectricPotentialChangeRateUnit.MicrovoltPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond"/>
-        /// </summary>
-        public double MicrovoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMinute"/>
-        /// </summary>
-        public double MicrovoltsPerMinute => As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerSecond"/>
-        /// </summary>
-        public double MicrovoltsPerSecond => As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerHour"/>
-        /// </summary>
-        public double MillivoltsPerHour => As(ElectricPotentialChangeRateUnit.MillivoltPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond"/>
-        /// </summary>
-        public double MillivoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMinute"/>
-        /// </summary>
-        public double MillivoltsPerMinute => As(ElectricPotentialChangeRateUnit.MillivoltPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerSecond"/>
-        /// </summary>
-        public double MillivoltsPerSecond => As(ElectricPotentialChangeRateUnit.MillivoltPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerHour"/>
-        /// </summary>
-        public double VoltsPerHour => As(ElectricPotentialChangeRateUnit.VoltPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerMicrosecond"/>
-        /// </summary>
-        public double VoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerMinute"/>
-        /// </summary>
-        public double VoltsPerMinute => As(ElectricPotentialChangeRateUnit.VoltPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerSecond"/>
-        /// </summary>
-        public double VoltsPerSecond => As(ElectricPotentialChangeRateUnit.VoltPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerHour"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromKilovoltsPerHour(double kilovoltsperhour) => new ElectricPotentialChangeRate(kilovoltsperhour, ElectricPotentialChangeRateUnit.KilovoltPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromKilovoltsPerMicrosecond(double kilovoltspermicrosecond) => new ElectricPotentialChangeRate(kilovoltspermicrosecond, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMinute"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromKilovoltsPerMinute(double kilovoltsperminute) => new ElectricPotentialChangeRate(kilovoltsperminute, ElectricPotentialChangeRateUnit.KilovoltPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerSecond"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromKilovoltsPerSecond(double kilovoltspersecond) => new ElectricPotentialChangeRate(kilovoltspersecond, ElectricPotentialChangeRateUnit.KilovoltPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerHour"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMegavoltsPerHour(double megavoltsperhour) => new ElectricPotentialChangeRate(megavoltsperhour, ElectricPotentialChangeRateUnit.MegavoltPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMegavoltsPerMicrosecond(double megavoltspermicrosecond) => new ElectricPotentialChangeRate(megavoltspermicrosecond, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMinute"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMegavoltsPerMinute(double megavoltsperminute) => new ElectricPotentialChangeRate(megavoltsperminute, ElectricPotentialChangeRateUnit.MegavoltPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerSecond"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMegavoltsPerSecond(double megavoltspersecond) => new ElectricPotentialChangeRate(megavoltspersecond, ElectricPotentialChangeRateUnit.MegavoltPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerHour"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerHour(double microvoltsperhour) => new ElectricPotentialChangeRate(microvoltsperhour, ElectricPotentialChangeRateUnit.MicrovoltPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerMicrosecond(double microvoltspermicrosecond) => new ElectricPotentialChangeRate(microvoltspermicrosecond, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMinute"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerMinute(double microvoltsperminute) => new ElectricPotentialChangeRate(microvoltsperminute, ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerSecond"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerSecond(double microvoltspersecond) => new ElectricPotentialChangeRate(microvoltspersecond, ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerHour"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMillivoltsPerHour(double millivoltsperhour) => new ElectricPotentialChangeRate(millivoltsperhour, ElectricPotentialChangeRateUnit.MillivoltPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMillivoltsPerMicrosecond(double millivoltspermicrosecond) => new ElectricPotentialChangeRate(millivoltspermicrosecond, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMinute"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMillivoltsPerMinute(double millivoltsperminute) => new ElectricPotentialChangeRate(millivoltsperminute, ElectricPotentialChangeRateUnit.MillivoltPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerSecond"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromMillivoltsPerSecond(double millivoltspersecond) => new ElectricPotentialChangeRate(millivoltspersecond, ElectricPotentialChangeRateUnit.MillivoltPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerHour"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromVoltsPerHour(double voltsperhour) => new ElectricPotentialChangeRate(voltsperhour, ElectricPotentialChangeRateUnit.VoltPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerMicrosecond"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromVoltsPerMicrosecond(double voltspermicrosecond) => new ElectricPotentialChangeRate(voltspermicrosecond, ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerMinute"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromVoltsPerMinute(double voltsperminute) => new ElectricPotentialChangeRate(voltsperminute, ElectricPotentialChangeRateUnit.VoltPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerSecond"/>.
-        /// </summary>
-        public static ElectricPotentialChangeRate FromVoltsPerSecond(double voltspersecond) => new ElectricPotentialChangeRate(voltspersecond, ElectricPotentialChangeRateUnit.VoltPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricPotentialChangeRateUnit" /> to <see cref="ElectricPotentialChangeRate" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricPotentialChangeRate unit value.</returns>
-        public static ElectricPotentialChangeRate From(double value, ElectricPotentialChangeRateUnit fromUnit)
-        {
-            return new ElectricPotentialChangeRate(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricPotentialChangeRateUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricPotentialChangeRate to another ElectricPotentialChangeRate with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricPotentialChangeRate with the specified unit.</returns>
-                public ElectricPotentialChangeRate ToUnit(ElectricPotentialChangeRateUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricPotentialChangeRate(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricPotentialChangeRateUnit.KilovoltPerHour => (_value / 3600) * 1e3d,
-                        ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond => (_value * 1E6) * 1e3d,
-                        ElectricPotentialChangeRateUnit.KilovoltPerMinute => (_value / 60) * 1e3d,
-                        ElectricPotentialChangeRateUnit.KilovoltPerSecond => (_value) * 1e3d,
-                        ElectricPotentialChangeRateUnit.MegavoltPerHour => (_value / 3600) * 1e6d,
-                        ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond => (_value * 1E6) * 1e6d,
-                        ElectricPotentialChangeRateUnit.MegavoltPerMinute => (_value / 60) * 1e6d,
-                        ElectricPotentialChangeRateUnit.MegavoltPerSecond => (_value) * 1e6d,
-                        ElectricPotentialChangeRateUnit.MicrovoltPerHour => (_value / 3600) * 1e-6d,
-                        ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond => (_value * 1E6) * 1e-6d,
-                        ElectricPotentialChangeRateUnit.MicrovoltPerMinute => (_value / 60) * 1e-6d,
-                        ElectricPotentialChangeRateUnit.MicrovoltPerSecond => (_value) * 1e-6d,
-                        ElectricPotentialChangeRateUnit.MillivoltPerHour => (_value / 3600) * 1e-3d,
-                        ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond => (_value * 1E6) * 1e-3d,
-                        ElectricPotentialChangeRateUnit.MillivoltPerMinute => (_value / 60) * 1e-3d,
-                        ElectricPotentialChangeRateUnit.MillivoltPerSecond => (_value) * 1e-3d,
-                        ElectricPotentialChangeRateUnit.VoltPerHour => _value / 3600,
-                        ElectricPotentialChangeRateUnit.VoltPerMicrosecond => _value * 1E6,
-                        ElectricPotentialChangeRateUnit.VoltPerMinute => _value / 60,
-                        ElectricPotentialChangeRateUnit.VoltPerSecond => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricPotentialChangeRateUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricPotentialChangeRateUnit.KilovoltPerHour => (baseUnitValue * 3600) / 1e3d,
-                        ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond => (baseUnitValue / 1E6) / 1e3d,
-                        ElectricPotentialChangeRateUnit.KilovoltPerMinute => (baseUnitValue * 60) / 1e3d,
-                        ElectricPotentialChangeRateUnit.KilovoltPerSecond => (baseUnitValue) / 1e3d,
-                        ElectricPotentialChangeRateUnit.MegavoltPerHour => (baseUnitValue * 3600) / 1e6d,
-                        ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond => (baseUnitValue / 1E6) / 1e6d,
-                        ElectricPotentialChangeRateUnit.MegavoltPerMinute => (baseUnitValue * 60) / 1e6d,
-                        ElectricPotentialChangeRateUnit.MegavoltPerSecond => (baseUnitValue) / 1e6d,
-                        ElectricPotentialChangeRateUnit.MicrovoltPerHour => (baseUnitValue * 3600) / 1e-6d,
-                        ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond => (baseUnitValue / 1E6) / 1e-6d,
-                        ElectricPotentialChangeRateUnit.MicrovoltPerMinute => (baseUnitValue * 60) / 1e-6d,
-                        ElectricPotentialChangeRateUnit.MicrovoltPerSecond => (baseUnitValue) / 1e-6d,
-                        ElectricPotentialChangeRateUnit.MillivoltPerHour => (baseUnitValue * 3600) / 1e-3d,
-                        ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond => (baseUnitValue / 1E6) / 1e-3d,
-                        ElectricPotentialChangeRateUnit.MillivoltPerMinute => (baseUnitValue * 60) / 1e-3d,
-                        ElectricPotentialChangeRateUnit.MillivoltPerSecond => (baseUnitValue) / 1e-3d,
-                        ElectricPotentialChangeRateUnit.VoltPerHour => baseUnitValue * 3600,
-                        ElectricPotentialChangeRateUnit.VoltPerMicrosecond => baseUnitValue / 1E6,
-                        ElectricPotentialChangeRateUnit.VoltPerMinute => baseUnitValue * 60,
-                        ElectricPotentialChangeRateUnit.VoltPerSecond => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricReactance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricReactance.g.cs
deleted file mode 100644
index df246179fc..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricReactance.g.cs
+++ /dev/null
@@ -1,244 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In electrical circuits, reactance is the opposition presented to alternating current by inductance and capacitance. Along with resistance, it is one of two elements of impedance.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Electrical_reactance
-    /// </remarks>
-    public struct  ElectricReactance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricReactanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricReactanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricReactance(double value, ElectricReactanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricReactance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricReactanceUnit BaseUnit { get; } = ElectricReactanceUnit.Ohm;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricReactance.
-        /// </summary>
-        public static ElectricReactance MaxValue { get; } = new ElectricReactance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricReactance.
-        /// </summary>
-        public static ElectricReactance MinValue { get; } = new ElectricReactance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricReactance Zero { get; } = new ElectricReactance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Gigaohm"/>
-        /// </summary>
-        public double Gigaohms => As(ElectricReactanceUnit.Gigaohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Kiloohm"/>
-        /// </summary>
-        public double Kiloohms => As(ElectricReactanceUnit.Kiloohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Megaohm"/>
-        /// </summary>
-        public double Megaohms => As(ElectricReactanceUnit.Megaohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Microohm"/>
-        /// </summary>
-        public double Microohms => As(ElectricReactanceUnit.Microohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Milliohm"/>
-        /// </summary>
-        public double Milliohms => As(ElectricReactanceUnit.Milliohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Nanoohm"/>
-        /// </summary>
-        public double Nanoohms => As(ElectricReactanceUnit.Nanoohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Ohm"/>
-        /// </summary>
-        public double Ohms => As(ElectricReactanceUnit.Ohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Teraohm"/>
-        /// </summary>
-        public double Teraohms => As(ElectricReactanceUnit.Teraohm);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Gigaohm"/>.
-        /// </summary>
-        public static ElectricReactance FromGigaohms(double gigaohms) => new ElectricReactance(gigaohms, ElectricReactanceUnit.Gigaohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Kiloohm"/>.
-        /// </summary>
-        public static ElectricReactance FromKiloohms(double kiloohms) => new ElectricReactance(kiloohms, ElectricReactanceUnit.Kiloohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Megaohm"/>.
-        /// </summary>
-        public static ElectricReactance FromMegaohms(double megaohms) => new ElectricReactance(megaohms, ElectricReactanceUnit.Megaohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Microohm"/>.
-        /// </summary>
-        public static ElectricReactance FromMicroohms(double microohms) => new ElectricReactance(microohms, ElectricReactanceUnit.Microohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Milliohm"/>.
-        /// </summary>
-        public static ElectricReactance FromMilliohms(double milliohms) => new ElectricReactance(milliohms, ElectricReactanceUnit.Milliohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Nanoohm"/>.
-        /// </summary>
-        public static ElectricReactance FromNanoohms(double nanoohms) => new ElectricReactance(nanoohms, ElectricReactanceUnit.Nanoohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Ohm"/>.
-        /// </summary>
-        public static ElectricReactance FromOhms(double ohms) => new ElectricReactance(ohms, ElectricReactanceUnit.Ohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Teraohm"/>.
-        /// </summary>
-        public static ElectricReactance FromTeraohms(double teraohms) => new ElectricReactance(teraohms, ElectricReactanceUnit.Teraohm);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricReactanceUnit" /> to <see cref="ElectricReactance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricReactance unit value.</returns>
-        public static ElectricReactance From(double value, ElectricReactanceUnit fromUnit)
-        {
-            return new ElectricReactance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricReactanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricReactance to another ElectricReactance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricReactance with the specified unit.</returns>
-                public ElectricReactance ToUnit(ElectricReactanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricReactance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricReactanceUnit.Gigaohm => (_value) * 1e9d,
-                        ElectricReactanceUnit.Kiloohm => (_value) * 1e3d,
-                        ElectricReactanceUnit.Megaohm => (_value) * 1e6d,
-                        ElectricReactanceUnit.Microohm => (_value) * 1e-6d,
-                        ElectricReactanceUnit.Milliohm => (_value) * 1e-3d,
-                        ElectricReactanceUnit.Nanoohm => (_value) * 1e-9d,
-                        ElectricReactanceUnit.Ohm => _value,
-                        ElectricReactanceUnit.Teraohm => (_value) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricReactanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricReactanceUnit.Gigaohm => (baseUnitValue) / 1e9d,
-                        ElectricReactanceUnit.Kiloohm => (baseUnitValue) / 1e3d,
-                        ElectricReactanceUnit.Megaohm => (baseUnitValue) / 1e6d,
-                        ElectricReactanceUnit.Microohm => (baseUnitValue) / 1e-6d,
-                        ElectricReactanceUnit.Milliohm => (baseUnitValue) / 1e-3d,
-                        ElectricReactanceUnit.Nanoohm => (baseUnitValue) / 1e-9d,
-                        ElectricReactanceUnit.Ohm => baseUnitValue,
-                        ElectricReactanceUnit.Teraohm => (baseUnitValue) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs
deleted file mode 100644
index 3bb96eec8c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The volt-ampere reactive hour (expressed as varh) is the reactive power of one Volt-ampere reactive produced in one hour.
-    /// </summary>
-    public struct  ElectricReactiveEnergy
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricReactiveEnergyUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricReactiveEnergyUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricReactiveEnergy(double value, ElectricReactiveEnergyUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricReactiveEnergy, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricReactiveEnergyUnit BaseUnit { get; } = ElectricReactiveEnergyUnit.VoltampereReactiveHour;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricReactiveEnergy.
-        /// </summary>
-        public static ElectricReactiveEnergy MaxValue { get; } = new ElectricReactiveEnergy(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricReactiveEnergy.
-        /// </summary>
-        public static ElectricReactiveEnergy MinValue { get; } = new ElectricReactiveEnergy(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricReactiveEnergy Zero { get; } = new ElectricReactiveEnergy(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactiveEnergyUnit.KilovoltampereReactiveHour"/>
-        /// </summary>
-        public double KilovoltampereReactiveHours => As(ElectricReactiveEnergyUnit.KilovoltampereReactiveHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactiveEnergyUnit.MegavoltampereReactiveHour"/>
-        /// </summary>
-        public double MegavoltampereReactiveHours => As(ElectricReactiveEnergyUnit.MegavoltampereReactiveHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactiveEnergyUnit.VoltampereReactiveHour"/>
-        /// </summary>
-        public double VoltampereReactiveHours => As(ElectricReactiveEnergyUnit.VoltampereReactiveHour);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactiveEnergy"/> from <see cref="ElectricReactiveEnergyUnit.KilovoltampereReactiveHour"/>.
-        /// </summary>
-        public static ElectricReactiveEnergy FromKilovoltampereReactiveHours(double kilovoltamperereactivehours) => new ElectricReactiveEnergy(kilovoltamperereactivehours, ElectricReactiveEnergyUnit.KilovoltampereReactiveHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactiveEnergy"/> from <see cref="ElectricReactiveEnergyUnit.MegavoltampereReactiveHour"/>.
-        /// </summary>
-        public static ElectricReactiveEnergy FromMegavoltampereReactiveHours(double megavoltamperereactivehours) => new ElectricReactiveEnergy(megavoltamperereactivehours, ElectricReactiveEnergyUnit.MegavoltampereReactiveHour);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactiveEnergy"/> from <see cref="ElectricReactiveEnergyUnit.VoltampereReactiveHour"/>.
-        /// </summary>
-        public static ElectricReactiveEnergy FromVoltampereReactiveHours(double voltamperereactivehours) => new ElectricReactiveEnergy(voltamperereactivehours, ElectricReactiveEnergyUnit.VoltampereReactiveHour);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricReactiveEnergyUnit" /> to <see cref="ElectricReactiveEnergy" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricReactiveEnergy unit value.</returns>
-        public static ElectricReactiveEnergy From(double value, ElectricReactiveEnergyUnit fromUnit)
-        {
-            return new ElectricReactiveEnergy(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricReactiveEnergyUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricReactiveEnergy to another ElectricReactiveEnergy with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricReactiveEnergy with the specified unit.</returns>
-                public ElectricReactiveEnergy ToUnit(ElectricReactiveEnergyUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricReactiveEnergy(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricReactiveEnergyUnit.KilovoltampereReactiveHour => (_value) * 1e3d,
-                        ElectricReactiveEnergyUnit.MegavoltampereReactiveHour => (_value) * 1e6d,
-                        ElectricReactiveEnergyUnit.VoltampereReactiveHour => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricReactiveEnergyUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricReactiveEnergyUnit.KilovoltampereReactiveHour => (baseUnitValue) / 1e3d,
-                        ElectricReactiveEnergyUnit.MegavoltampereReactiveHour => (baseUnitValue) / 1e6d,
-                        ElectricReactiveEnergyUnit.VoltampereReactiveHour => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricReactivePower.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricReactivePower.g.cs
deleted file mode 100644
index e9206453d5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricReactivePower.g.cs
+++ /dev/null
@@ -1,196 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In electric power transmission and distribution, volt-ampere reactive (var) is a unit of measurement of reactive power. Reactive power exists in an AC circuit when the current and voltage are not in phase.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/AC_power#Active,_reactive,_apparent,_and_complex_power_in_sinusoidal_steady-state
-    /// </remarks>
-    public struct  ElectricReactivePower
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricReactivePowerUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricReactivePowerUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricReactivePower(double value, ElectricReactivePowerUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricReactivePower, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricReactivePowerUnit BaseUnit { get; } = ElectricReactivePowerUnit.VoltampereReactive;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricReactivePower.
-        /// </summary>
-        public static ElectricReactivePower MaxValue { get; } = new ElectricReactivePower(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricReactivePower.
-        /// </summary>
-        public static ElectricReactivePower MinValue { get; } = new ElectricReactivePower(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricReactivePower Zero { get; } = new ElectricReactivePower(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.GigavoltampereReactive"/>
-        /// </summary>
-        public double GigavoltamperesReactive => As(ElectricReactivePowerUnit.GigavoltampereReactive);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.KilovoltampereReactive"/>
-        /// </summary>
-        public double KilovoltamperesReactive => As(ElectricReactivePowerUnit.KilovoltampereReactive);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.MegavoltampereReactive"/>
-        /// </summary>
-        public double MegavoltamperesReactive => As(ElectricReactivePowerUnit.MegavoltampereReactive);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.VoltampereReactive"/>
-        /// </summary>
-        public double VoltamperesReactive => As(ElectricReactivePowerUnit.VoltampereReactive);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactivePower"/> from <see cref="ElectricReactivePowerUnit.GigavoltampereReactive"/>.
-        /// </summary>
-        public static ElectricReactivePower FromGigavoltamperesReactive(double gigavoltamperesreactive) => new ElectricReactivePower(gigavoltamperesreactive, ElectricReactivePowerUnit.GigavoltampereReactive);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactivePower"/> from <see cref="ElectricReactivePowerUnit.KilovoltampereReactive"/>.
-        /// </summary>
-        public static ElectricReactivePower FromKilovoltamperesReactive(double kilovoltamperesreactive) => new ElectricReactivePower(kilovoltamperesreactive, ElectricReactivePowerUnit.KilovoltampereReactive);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactivePower"/> from <see cref="ElectricReactivePowerUnit.MegavoltampereReactive"/>.
-        /// </summary>
-        public static ElectricReactivePower FromMegavoltamperesReactive(double megavoltamperesreactive) => new ElectricReactivePower(megavoltamperesreactive, ElectricReactivePowerUnit.MegavoltampereReactive);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricReactivePower"/> from <see cref="ElectricReactivePowerUnit.VoltampereReactive"/>.
-        /// </summary>
-        public static ElectricReactivePower FromVoltamperesReactive(double voltamperesreactive) => new ElectricReactivePower(voltamperesreactive, ElectricReactivePowerUnit.VoltampereReactive);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricReactivePowerUnit" /> to <see cref="ElectricReactivePower" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricReactivePower unit value.</returns>
-        public static ElectricReactivePower From(double value, ElectricReactivePowerUnit fromUnit)
-        {
-            return new ElectricReactivePower(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricReactivePowerUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricReactivePower to another ElectricReactivePower with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricReactivePower with the specified unit.</returns>
-                public ElectricReactivePower ToUnit(ElectricReactivePowerUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricReactivePower(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricReactivePowerUnit.GigavoltampereReactive => (_value) * 1e9d,
-                        ElectricReactivePowerUnit.KilovoltampereReactive => (_value) * 1e3d,
-                        ElectricReactivePowerUnit.MegavoltampereReactive => (_value) * 1e6d,
-                        ElectricReactivePowerUnit.VoltampereReactive => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricReactivePowerUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricReactivePowerUnit.GigavoltampereReactive => (baseUnitValue) / 1e9d,
-                        ElectricReactivePowerUnit.KilovoltampereReactive => (baseUnitValue) / 1e3d,
-                        ElectricReactivePowerUnit.MegavoltampereReactive => (baseUnitValue) / 1e6d,
-                        ElectricReactivePowerUnit.VoltampereReactive => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricResistance.g.cs
deleted file mode 100644
index 42e2b3bf6d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricResistance.g.cs
+++ /dev/null
@@ -1,244 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The electrical resistance of an object is a measure of its opposition to the flow of electric current. Along with reactance, it is one of two elements of impedance. Its reciprocal quantity is electrical conductance.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Electrical_resistance_and_conductance
-    /// </remarks>
-    public struct  ElectricResistance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricResistanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricResistanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricResistance(double value, ElectricResistanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricResistance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricResistanceUnit BaseUnit { get; } = ElectricResistanceUnit.Ohm;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricResistance.
-        /// </summary>
-        public static ElectricResistance MaxValue { get; } = new ElectricResistance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricResistance.
-        /// </summary>
-        public static ElectricResistance MinValue { get; } = new ElectricResistance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricResistance Zero { get; } = new ElectricResistance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Gigaohm"/>
-        /// </summary>
-        public double Gigaohms => As(ElectricResistanceUnit.Gigaohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Kiloohm"/>
-        /// </summary>
-        public double Kiloohms => As(ElectricResistanceUnit.Kiloohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Megaohm"/>
-        /// </summary>
-        public double Megaohms => As(ElectricResistanceUnit.Megaohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Microohm"/>
-        /// </summary>
-        public double Microohms => As(ElectricResistanceUnit.Microohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Milliohm"/>
-        /// </summary>
-        public double Milliohms => As(ElectricResistanceUnit.Milliohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Nanoohm"/>
-        /// </summary>
-        public double Nanoohms => As(ElectricResistanceUnit.Nanoohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Ohm"/>
-        /// </summary>
-        public double Ohms => As(ElectricResistanceUnit.Ohm);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Teraohm"/>
-        /// </summary>
-        public double Teraohms => As(ElectricResistanceUnit.Teraohm);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Gigaohm"/>.
-        /// </summary>
-        public static ElectricResistance FromGigaohms(double gigaohms) => new ElectricResistance(gigaohms, ElectricResistanceUnit.Gigaohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Kiloohm"/>.
-        /// </summary>
-        public static ElectricResistance FromKiloohms(double kiloohms) => new ElectricResistance(kiloohms, ElectricResistanceUnit.Kiloohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Megaohm"/>.
-        /// </summary>
-        public static ElectricResistance FromMegaohms(double megaohms) => new ElectricResistance(megaohms, ElectricResistanceUnit.Megaohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Microohm"/>.
-        /// </summary>
-        public static ElectricResistance FromMicroohms(double microohms) => new ElectricResistance(microohms, ElectricResistanceUnit.Microohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Milliohm"/>.
-        /// </summary>
-        public static ElectricResistance FromMilliohms(double milliohms) => new ElectricResistance(milliohms, ElectricResistanceUnit.Milliohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Nanoohm"/>.
-        /// </summary>
-        public static ElectricResistance FromNanoohms(double nanoohms) => new ElectricResistance(nanoohms, ElectricResistanceUnit.Nanoohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Ohm"/>.
-        /// </summary>
-        public static ElectricResistance FromOhms(double ohms) => new ElectricResistance(ohms, ElectricResistanceUnit.Ohm);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Teraohm"/>.
-        /// </summary>
-        public static ElectricResistance FromTeraohms(double teraohms) => new ElectricResistance(teraohms, ElectricResistanceUnit.Teraohm);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricResistanceUnit" /> to <see cref="ElectricResistance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricResistance unit value.</returns>
-        public static ElectricResistance From(double value, ElectricResistanceUnit fromUnit)
-        {
-            return new ElectricResistance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricResistanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricResistance to another ElectricResistance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricResistance with the specified unit.</returns>
-                public ElectricResistance ToUnit(ElectricResistanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricResistance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricResistanceUnit.Gigaohm => (_value) * 1e9d,
-                        ElectricResistanceUnit.Kiloohm => (_value) * 1e3d,
-                        ElectricResistanceUnit.Megaohm => (_value) * 1e6d,
-                        ElectricResistanceUnit.Microohm => (_value) * 1e-6d,
-                        ElectricResistanceUnit.Milliohm => (_value) * 1e-3d,
-                        ElectricResistanceUnit.Nanoohm => (_value) * 1e-9d,
-                        ElectricResistanceUnit.Ohm => _value,
-                        ElectricResistanceUnit.Teraohm => (_value) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricResistanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricResistanceUnit.Gigaohm => (baseUnitValue) / 1e9d,
-                        ElectricResistanceUnit.Kiloohm => (baseUnitValue) / 1e3d,
-                        ElectricResistanceUnit.Megaohm => (baseUnitValue) / 1e6d,
-                        ElectricResistanceUnit.Microohm => (baseUnitValue) / 1e-6d,
-                        ElectricResistanceUnit.Milliohm => (baseUnitValue) / 1e-3d,
-                        ElectricResistanceUnit.Nanoohm => (baseUnitValue) / 1e-9d,
-                        ElectricResistanceUnit.Ohm => baseUnitValue,
-                        ElectricResistanceUnit.Teraohm => (baseUnitValue) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricResistivity.g.cs
deleted file mode 100644
index f8c5f1b7c5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricResistivity.g.cs
+++ /dev/null
@@ -1,316 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Electrical resistivity (also known as resistivity, specific electrical resistance, or volume resistivity) is a fundamental property that quantifies how strongly a given material opposes the flow of electric current.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Electrical_resistivity_and_conductivity
-    /// </remarks>
-    public struct  ElectricResistivity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricResistivityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricResistivityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricResistivity(double value, ElectricResistivityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricResistivity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricResistivityUnit BaseUnit { get; } = ElectricResistivityUnit.OhmMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricResistivity.
-        /// </summary>
-        public static ElectricResistivity MaxValue { get; } = new ElectricResistivity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricResistivity.
-        /// </summary>
-        public static ElectricResistivity MinValue { get; } = new ElectricResistivity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricResistivity Zero { get; } = new ElectricResistivity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.KiloohmCentimeter"/>
-        /// </summary>
-        public double KiloohmsCentimeter => As(ElectricResistivityUnit.KiloohmCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.KiloohmMeter"/>
-        /// </summary>
-        public double KiloohmMeters => As(ElectricResistivityUnit.KiloohmMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MegaohmCentimeter"/>
-        /// </summary>
-        public double MegaohmsCentimeter => As(ElectricResistivityUnit.MegaohmCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MegaohmMeter"/>
-        /// </summary>
-        public double MegaohmMeters => As(ElectricResistivityUnit.MegaohmMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MicroohmCentimeter"/>
-        /// </summary>
-        public double MicroohmsCentimeter => As(ElectricResistivityUnit.MicroohmCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MicroohmMeter"/>
-        /// </summary>
-        public double MicroohmMeters => As(ElectricResistivityUnit.MicroohmMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MilliohmCentimeter"/>
-        /// </summary>
-        public double MilliohmsCentimeter => As(ElectricResistivityUnit.MilliohmCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MilliohmMeter"/>
-        /// </summary>
-        public double MilliohmMeters => As(ElectricResistivityUnit.MilliohmMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.NanoohmCentimeter"/>
-        /// </summary>
-        public double NanoohmsCentimeter => As(ElectricResistivityUnit.NanoohmCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.NanoohmMeter"/>
-        /// </summary>
-        public double NanoohmMeters => As(ElectricResistivityUnit.NanoohmMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.OhmCentimeter"/>
-        /// </summary>
-        public double OhmsCentimeter => As(ElectricResistivityUnit.OhmCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.OhmMeter"/>
-        /// </summary>
-        public double OhmMeters => As(ElectricResistivityUnit.OhmMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.PicoohmCentimeter"/>
-        /// </summary>
-        public double PicoohmsCentimeter => As(ElectricResistivityUnit.PicoohmCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.PicoohmMeter"/>
-        /// </summary>
-        public double PicoohmMeters => As(ElectricResistivityUnit.PicoohmMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.KiloohmCentimeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromKiloohmsCentimeter(double kiloohmscentimeter) => new ElectricResistivity(kiloohmscentimeter, ElectricResistivityUnit.KiloohmCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.KiloohmMeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromKiloohmMeters(double kiloohmmeters) => new ElectricResistivity(kiloohmmeters, ElectricResistivityUnit.KiloohmMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MegaohmCentimeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromMegaohmsCentimeter(double megaohmscentimeter) => new ElectricResistivity(megaohmscentimeter, ElectricResistivityUnit.MegaohmCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MegaohmMeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromMegaohmMeters(double megaohmmeters) => new ElectricResistivity(megaohmmeters, ElectricResistivityUnit.MegaohmMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MicroohmCentimeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromMicroohmsCentimeter(double microohmscentimeter) => new ElectricResistivity(microohmscentimeter, ElectricResistivityUnit.MicroohmCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MicroohmMeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromMicroohmMeters(double microohmmeters) => new ElectricResistivity(microohmmeters, ElectricResistivityUnit.MicroohmMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MilliohmCentimeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromMilliohmsCentimeter(double milliohmscentimeter) => new ElectricResistivity(milliohmscentimeter, ElectricResistivityUnit.MilliohmCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MilliohmMeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromMilliohmMeters(double milliohmmeters) => new ElectricResistivity(milliohmmeters, ElectricResistivityUnit.MilliohmMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.NanoohmCentimeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromNanoohmsCentimeter(double nanoohmscentimeter) => new ElectricResistivity(nanoohmscentimeter, ElectricResistivityUnit.NanoohmCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.NanoohmMeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromNanoohmMeters(double nanoohmmeters) => new ElectricResistivity(nanoohmmeters, ElectricResistivityUnit.NanoohmMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.OhmCentimeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromOhmsCentimeter(double ohmscentimeter) => new ElectricResistivity(ohmscentimeter, ElectricResistivityUnit.OhmCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.OhmMeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromOhmMeters(double ohmmeters) => new ElectricResistivity(ohmmeters, ElectricResistivityUnit.OhmMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.PicoohmCentimeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromPicoohmsCentimeter(double picoohmscentimeter) => new ElectricResistivity(picoohmscentimeter, ElectricResistivityUnit.PicoohmCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.PicoohmMeter"/>.
-        /// </summary>
-        public static ElectricResistivity FromPicoohmMeters(double picoohmmeters) => new ElectricResistivity(picoohmmeters, ElectricResistivityUnit.PicoohmMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricResistivityUnit" /> to <see cref="ElectricResistivity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricResistivity unit value.</returns>
-        public static ElectricResistivity From(double value, ElectricResistivityUnit fromUnit)
-        {
-            return new ElectricResistivity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricResistivityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricResistivity to another ElectricResistivity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricResistivity with the specified unit.</returns>
-                public ElectricResistivity ToUnit(ElectricResistivityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricResistivity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricResistivityUnit.KiloohmCentimeter => (_value / 100) * 1e3d,
-                        ElectricResistivityUnit.KiloohmMeter => (_value) * 1e3d,
-                        ElectricResistivityUnit.MegaohmCentimeter => (_value / 100) * 1e6d,
-                        ElectricResistivityUnit.MegaohmMeter => (_value) * 1e6d,
-                        ElectricResistivityUnit.MicroohmCentimeter => (_value / 100) * 1e-6d,
-                        ElectricResistivityUnit.MicroohmMeter => (_value) * 1e-6d,
-                        ElectricResistivityUnit.MilliohmCentimeter => (_value / 100) * 1e-3d,
-                        ElectricResistivityUnit.MilliohmMeter => (_value) * 1e-3d,
-                        ElectricResistivityUnit.NanoohmCentimeter => (_value / 100) * 1e-9d,
-                        ElectricResistivityUnit.NanoohmMeter => (_value) * 1e-9d,
-                        ElectricResistivityUnit.OhmCentimeter => _value / 100,
-                        ElectricResistivityUnit.OhmMeter => _value,
-                        ElectricResistivityUnit.PicoohmCentimeter => (_value / 100) * 1e-12d,
-                        ElectricResistivityUnit.PicoohmMeter => (_value) * 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricResistivityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricResistivityUnit.KiloohmCentimeter => (baseUnitValue * 100) / 1e3d,
-                        ElectricResistivityUnit.KiloohmMeter => (baseUnitValue) / 1e3d,
-                        ElectricResistivityUnit.MegaohmCentimeter => (baseUnitValue * 100) / 1e6d,
-                        ElectricResistivityUnit.MegaohmMeter => (baseUnitValue) / 1e6d,
-                        ElectricResistivityUnit.MicroohmCentimeter => (baseUnitValue * 100) / 1e-6d,
-                        ElectricResistivityUnit.MicroohmMeter => (baseUnitValue) / 1e-6d,
-                        ElectricResistivityUnit.MilliohmCentimeter => (baseUnitValue * 100) / 1e-3d,
-                        ElectricResistivityUnit.MilliohmMeter => (baseUnitValue) / 1e-3d,
-                        ElectricResistivityUnit.NanoohmCentimeter => (baseUnitValue * 100) / 1e-9d,
-                        ElectricResistivityUnit.NanoohmMeter => (baseUnitValue) / 1e-9d,
-                        ElectricResistivityUnit.OhmCentimeter => baseUnitValue * 100,
-                        ElectricResistivityUnit.OhmMeter => baseUnitValue,
-                        ElectricResistivityUnit.PicoohmCentimeter => (baseUnitValue * 100) / 1e-12d,
-                        ElectricResistivityUnit.PicoohmMeter => (baseUnitValue) / 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
deleted file mode 100644
index 4ef70185c5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
+++ /dev/null
@@ -1,184 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In electromagnetism, surface charge density is a measure of the amount of electric charge per surface area.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Charge_density
-    /// </remarks>
-    public struct  ElectricSurfaceChargeDensity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricSurfaceChargeDensityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricSurfaceChargeDensityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricSurfaceChargeDensity(double value, ElectricSurfaceChargeDensityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricSurfaceChargeDensity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricSurfaceChargeDensityUnit BaseUnit { get; } = ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricSurfaceChargeDensity.
-        /// </summary>
-        public static ElectricSurfaceChargeDensity MaxValue { get; } = new ElectricSurfaceChargeDensity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricSurfaceChargeDensity.
-        /// </summary>
-        public static ElectricSurfaceChargeDensity MinValue { get; } = new ElectricSurfaceChargeDensity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricSurfaceChargeDensity Zero { get; } = new ElectricSurfaceChargeDensity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter"/>
-        /// </summary>
-        public double CoulombsPerSquareCentimeter => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch"/>
-        /// </summary>
-        public double CoulombsPerSquareInch => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter"/>
-        /// </summary>
-        public double CoulombsPerSquareMeter => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter"/>.
-        /// </summary>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(double coulombspersquarecentimeter) => new ElectricSurfaceChargeDensity(coulombspersquarecentimeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch"/>.
-        /// </summary>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(double coulombspersquareinch) => new ElectricSurfaceChargeDensity(coulombspersquareinch, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter"/>.
-        /// </summary>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(double coulombspersquaremeter) => new ElectricSurfaceChargeDensity(coulombspersquaremeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricSurfaceChargeDensityUnit" /> to <see cref="ElectricSurfaceChargeDensity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricSurfaceChargeDensity unit value.</returns>
-        public static ElectricSurfaceChargeDensity From(double value, ElectricSurfaceChargeDensityUnit fromUnit)
-        {
-            return new ElectricSurfaceChargeDensity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricSurfaceChargeDensityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricSurfaceChargeDensity to another ElectricSurfaceChargeDensity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricSurfaceChargeDensity with the specified unit.</returns>
-                public ElectricSurfaceChargeDensity ToUnit(ElectricSurfaceChargeDensityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricSurfaceChargeDensity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter => _value * 1.0e4,
-                        ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch => _value / 0.00064516,
-                        ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricSurfaceChargeDensityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter => baseUnitValue / 1.0e4,
-                        ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch => baseUnitValue * 0.00064516,
-                        ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricSusceptance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricSusceptance.g.cs
deleted file mode 100644
index 3c157cc5c3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricSusceptance.g.cs
+++ /dev/null
@@ -1,340 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Electrical susceptance is the imaginary part of admittance, where the real part is conductance.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Electrical_susceptance
-    /// </remarks>
-    public struct  ElectricSusceptance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ElectricSusceptanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ElectricSusceptanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricSusceptance(double value, ElectricSusceptanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ElectricSusceptance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ElectricSusceptanceUnit BaseUnit { get; } = ElectricSusceptanceUnit.Siemens;
-
-        /// <summary>
-        /// Represents the largest possible value of ElectricSusceptance.
-        /// </summary>
-        public static ElectricSusceptance MaxValue { get; } = new ElectricSusceptance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ElectricSusceptance.
-        /// </summary>
-        public static ElectricSusceptance MinValue { get; } = new ElectricSusceptance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ElectricSusceptance Zero { get; } = new ElectricSusceptance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Gigamho"/>
-        /// </summary>
-        public double Gigamhos => As(ElectricSusceptanceUnit.Gigamho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Gigasiemens"/>
-        /// </summary>
-        public double Gigasiemens => As(ElectricSusceptanceUnit.Gigasiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Kilomho"/>
-        /// </summary>
-        public double Kilomhos => As(ElectricSusceptanceUnit.Kilomho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Kilosiemens"/>
-        /// </summary>
-        public double Kilosiemens => As(ElectricSusceptanceUnit.Kilosiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Megamho"/>
-        /// </summary>
-        public double Megamhos => As(ElectricSusceptanceUnit.Megamho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Megasiemens"/>
-        /// </summary>
-        public double Megasiemens => As(ElectricSusceptanceUnit.Megasiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Mho"/>
-        /// </summary>
-        public double Mhos => As(ElectricSusceptanceUnit.Mho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Micromho"/>
-        /// </summary>
-        public double Micromhos => As(ElectricSusceptanceUnit.Micromho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Microsiemens"/>
-        /// </summary>
-        public double Microsiemens => As(ElectricSusceptanceUnit.Microsiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Millimho"/>
-        /// </summary>
-        public double Millimhos => As(ElectricSusceptanceUnit.Millimho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Millisiemens"/>
-        /// </summary>
-        public double Millisiemens => As(ElectricSusceptanceUnit.Millisiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Nanomho"/>
-        /// </summary>
-        public double Nanomhos => As(ElectricSusceptanceUnit.Nanomho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Nanosiemens"/>
-        /// </summary>
-        public double Nanosiemens => As(ElectricSusceptanceUnit.Nanosiemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Siemens"/>
-        /// </summary>
-        public double Siemens => As(ElectricSusceptanceUnit.Siemens);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Teramho"/>
-        /// </summary>
-        public double Teramhos => As(ElectricSusceptanceUnit.Teramho);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Terasiemens"/>
-        /// </summary>
-        public double Terasiemens => As(ElectricSusceptanceUnit.Terasiemens);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Gigamho"/>.
-        /// </summary>
-        public static ElectricSusceptance FromGigamhos(double gigamhos) => new ElectricSusceptance(gigamhos, ElectricSusceptanceUnit.Gigamho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Gigasiemens"/>.
-        /// </summary>
-        public static ElectricSusceptance FromGigasiemens(double gigasiemens) => new ElectricSusceptance(gigasiemens, ElectricSusceptanceUnit.Gigasiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Kilomho"/>.
-        /// </summary>
-        public static ElectricSusceptance FromKilomhos(double kilomhos) => new ElectricSusceptance(kilomhos, ElectricSusceptanceUnit.Kilomho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Kilosiemens"/>.
-        /// </summary>
-        public static ElectricSusceptance FromKilosiemens(double kilosiemens) => new ElectricSusceptance(kilosiemens, ElectricSusceptanceUnit.Kilosiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Megamho"/>.
-        /// </summary>
-        public static ElectricSusceptance FromMegamhos(double megamhos) => new ElectricSusceptance(megamhos, ElectricSusceptanceUnit.Megamho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Megasiemens"/>.
-        /// </summary>
-        public static ElectricSusceptance FromMegasiemens(double megasiemens) => new ElectricSusceptance(megasiemens, ElectricSusceptanceUnit.Megasiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Mho"/>.
-        /// </summary>
-        public static ElectricSusceptance FromMhos(double mhos) => new ElectricSusceptance(mhos, ElectricSusceptanceUnit.Mho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Micromho"/>.
-        /// </summary>
-        public static ElectricSusceptance FromMicromhos(double micromhos) => new ElectricSusceptance(micromhos, ElectricSusceptanceUnit.Micromho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Microsiemens"/>.
-        /// </summary>
-        public static ElectricSusceptance FromMicrosiemens(double microsiemens) => new ElectricSusceptance(microsiemens, ElectricSusceptanceUnit.Microsiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Millimho"/>.
-        /// </summary>
-        public static ElectricSusceptance FromMillimhos(double millimhos) => new ElectricSusceptance(millimhos, ElectricSusceptanceUnit.Millimho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Millisiemens"/>.
-        /// </summary>
-        public static ElectricSusceptance FromMillisiemens(double millisiemens) => new ElectricSusceptance(millisiemens, ElectricSusceptanceUnit.Millisiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Nanomho"/>.
-        /// </summary>
-        public static ElectricSusceptance FromNanomhos(double nanomhos) => new ElectricSusceptance(nanomhos, ElectricSusceptanceUnit.Nanomho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Nanosiemens"/>.
-        /// </summary>
-        public static ElectricSusceptance FromNanosiemens(double nanosiemens) => new ElectricSusceptance(nanosiemens, ElectricSusceptanceUnit.Nanosiemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Siemens"/>.
-        /// </summary>
-        public static ElectricSusceptance FromSiemens(double siemens) => new ElectricSusceptance(siemens, ElectricSusceptanceUnit.Siemens);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Teramho"/>.
-        /// </summary>
-        public static ElectricSusceptance FromTeramhos(double teramhos) => new ElectricSusceptance(teramhos, ElectricSusceptanceUnit.Teramho);
-
-        /// <summary>
-        ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Terasiemens"/>.
-        /// </summary>
-        public static ElectricSusceptance FromTerasiemens(double terasiemens) => new ElectricSusceptance(terasiemens, ElectricSusceptanceUnit.Terasiemens);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ElectricSusceptanceUnit" /> to <see cref="ElectricSusceptance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ElectricSusceptance unit value.</returns>
-        public static ElectricSusceptance From(double value, ElectricSusceptanceUnit fromUnit)
-        {
-            return new ElectricSusceptance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ElectricSusceptanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ElectricSusceptance to another ElectricSusceptance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ElectricSusceptance with the specified unit.</returns>
-                public ElectricSusceptance ToUnit(ElectricSusceptanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ElectricSusceptance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ElectricSusceptanceUnit.Gigamho => (_value) * 1e9d,
-                        ElectricSusceptanceUnit.Gigasiemens => (_value) * 1e9d,
-                        ElectricSusceptanceUnit.Kilomho => (_value) * 1e3d,
-                        ElectricSusceptanceUnit.Kilosiemens => (_value) * 1e3d,
-                        ElectricSusceptanceUnit.Megamho => (_value) * 1e6d,
-                        ElectricSusceptanceUnit.Megasiemens => (_value) * 1e6d,
-                        ElectricSusceptanceUnit.Mho => _value,
-                        ElectricSusceptanceUnit.Micromho => (_value) * 1e-6d,
-                        ElectricSusceptanceUnit.Microsiemens => (_value) * 1e-6d,
-                        ElectricSusceptanceUnit.Millimho => (_value) * 1e-3d,
-                        ElectricSusceptanceUnit.Millisiemens => (_value) * 1e-3d,
-                        ElectricSusceptanceUnit.Nanomho => (_value) * 1e-9d,
-                        ElectricSusceptanceUnit.Nanosiemens => (_value) * 1e-9d,
-                        ElectricSusceptanceUnit.Siemens => _value,
-                        ElectricSusceptanceUnit.Teramho => (_value) * 1e12d,
-                        ElectricSusceptanceUnit.Terasiemens => (_value) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ElectricSusceptanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ElectricSusceptanceUnit.Gigamho => (baseUnitValue) / 1e9d,
-                        ElectricSusceptanceUnit.Gigasiemens => (baseUnitValue) / 1e9d,
-                        ElectricSusceptanceUnit.Kilomho => (baseUnitValue) / 1e3d,
-                        ElectricSusceptanceUnit.Kilosiemens => (baseUnitValue) / 1e3d,
-                        ElectricSusceptanceUnit.Megamho => (baseUnitValue) / 1e6d,
-                        ElectricSusceptanceUnit.Megasiemens => (baseUnitValue) / 1e6d,
-                        ElectricSusceptanceUnit.Mho => baseUnitValue,
-                        ElectricSusceptanceUnit.Micromho => (baseUnitValue) / 1e-6d,
-                        ElectricSusceptanceUnit.Microsiemens => (baseUnitValue) / 1e-6d,
-                        ElectricSusceptanceUnit.Millimho => (baseUnitValue) / 1e-3d,
-                        ElectricSusceptanceUnit.Millisiemens => (baseUnitValue) / 1e-3d,
-                        ElectricSusceptanceUnit.Nanomho => (baseUnitValue) / 1e-9d,
-                        ElectricSusceptanceUnit.Nanosiemens => (baseUnitValue) / 1e-9d,
-                        ElectricSusceptanceUnit.Siemens => baseUnitValue,
-                        ElectricSusceptanceUnit.Teramho => (baseUnitValue) / 1e12d,
-                        ElectricSusceptanceUnit.Terasiemens => (baseUnitValue) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Energy.g.cs
deleted file mode 100644
index 3b6e4ce23a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Energy.g.cs
+++ /dev/null
@@ -1,625 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The joule, symbol J, is a derived unit of energy, work, or amount of heat in the International System of Units. It is equal to the energy transferred (or work done) when applying a force of one newton through a distance of one metre (1 newton metre or N·m), or in passing an electric current of one ampere through a resistance of one ohm for one second. Many other units of energy are included. Please do not confuse this definition of the calorie with the one colloquially used by the food industry, the large calorie, which is equivalent to 1 kcal. Thermochemical definition of the calorie is used. For BTU, the IT definition is used.
-    /// </summary>
-    public struct  Energy
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly EnergyUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public EnergyUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Energy(double value, EnergyUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Energy, which is Second. All conversions go via this value.
-        /// </summary>
-        public static EnergyUnit BaseUnit { get; } = EnergyUnit.Joule;
-
-        /// <summary>
-        /// Represents the largest possible value of Energy.
-        /// </summary>
-        public static Energy MaxValue { get; } = new Energy(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Energy.
-        /// </summary>
-        public static Energy MinValue { get; } = new Energy(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Energy Zero { get; } = new Energy(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.BritishThermalUnit"/>
-        /// </summary>
-        public double BritishThermalUnits => As(EnergyUnit.BritishThermalUnit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Calorie"/>
-        /// </summary>
-        public double Calories => As(EnergyUnit.Calorie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.DecathermEc"/>
-        /// </summary>
-        public double DecathermsEc => As(EnergyUnit.DecathermEc);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.DecathermImperial"/>
-        /// </summary>
-        public double DecathermsImperial => As(EnergyUnit.DecathermImperial);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.DecathermUs"/>
-        /// </summary>
-        public double DecathermsUs => As(EnergyUnit.DecathermUs);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.ElectronVolt"/>
-        /// </summary>
-        public double ElectronVolts => As(EnergyUnit.ElectronVolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Erg"/>
-        /// </summary>
-        public double Ergs => As(EnergyUnit.Erg);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.FootPound"/>
-        /// </summary>
-        public double FootPounds => As(EnergyUnit.FootPound);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.GigabritishThermalUnit"/>
-        /// </summary>
-        public double GigabritishThermalUnits => As(EnergyUnit.GigabritishThermalUnit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.GigaelectronVolt"/>
-        /// </summary>
-        public double GigaelectronVolts => As(EnergyUnit.GigaelectronVolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Gigajoule"/>
-        /// </summary>
-        public double Gigajoules => As(EnergyUnit.Gigajoule);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.GigawattDay"/>
-        /// </summary>
-        public double GigawattDays => As(EnergyUnit.GigawattDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.GigawattHour"/>
-        /// </summary>
-        public double GigawattHours => As(EnergyUnit.GigawattHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.HorsepowerHour"/>
-        /// </summary>
-        public double HorsepowerHours => As(EnergyUnit.HorsepowerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Joule"/>
-        /// </summary>
-        public double Joules => As(EnergyUnit.Joule);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.KilobritishThermalUnit"/>
-        /// </summary>
-        public double KilobritishThermalUnits => As(EnergyUnit.KilobritishThermalUnit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Kilocalorie"/>
-        /// </summary>
-        public double Kilocalories => As(EnergyUnit.Kilocalorie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.KiloelectronVolt"/>
-        /// </summary>
-        public double KiloelectronVolts => As(EnergyUnit.KiloelectronVolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Kilojoule"/>
-        /// </summary>
-        public double Kilojoules => As(EnergyUnit.Kilojoule);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.KilowattDay"/>
-        /// </summary>
-        public double KilowattDays => As(EnergyUnit.KilowattDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.KilowattHour"/>
-        /// </summary>
-        public double KilowattHours => As(EnergyUnit.KilowattHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.MegabritishThermalUnit"/>
-        /// </summary>
-        public double MegabritishThermalUnits => As(EnergyUnit.MegabritishThermalUnit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Megacalorie"/>
-        /// </summary>
-        public double Megacalories => As(EnergyUnit.Megacalorie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.MegaelectronVolt"/>
-        /// </summary>
-        public double MegaelectronVolts => As(EnergyUnit.MegaelectronVolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Megajoule"/>
-        /// </summary>
-        public double Megajoules => As(EnergyUnit.Megajoule);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.MegawattDay"/>
-        /// </summary>
-        public double MegawattDays => As(EnergyUnit.MegawattDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.MegawattHour"/>
-        /// </summary>
-        public double MegawattHours => As(EnergyUnit.MegawattHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Microjoule"/>
-        /// </summary>
-        public double Microjoules => As(EnergyUnit.Microjoule);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Millijoule"/>
-        /// </summary>
-        public double Millijoules => As(EnergyUnit.Millijoule);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Nanojoule"/>
-        /// </summary>
-        public double Nanojoules => As(EnergyUnit.Nanojoule);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Petajoule"/>
-        /// </summary>
-        public double Petajoules => As(EnergyUnit.Petajoule);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.TeraelectronVolt"/>
-        /// </summary>
-        public double TeraelectronVolts => As(EnergyUnit.TeraelectronVolt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Terajoule"/>
-        /// </summary>
-        public double Terajoules => As(EnergyUnit.Terajoule);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.TerawattDay"/>
-        /// </summary>
-        public double TerawattDays => As(EnergyUnit.TerawattDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.TerawattHour"/>
-        /// </summary>
-        public double TerawattHours => As(EnergyUnit.TerawattHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.ThermEc"/>
-        /// </summary>
-        public double ThermsEc => As(EnergyUnit.ThermEc);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.ThermImperial"/>
-        /// </summary>
-        public double ThermsImperial => As(EnergyUnit.ThermImperial);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.ThermUs"/>
-        /// </summary>
-        public double ThermsUs => As(EnergyUnit.ThermUs);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.WattDay"/>
-        /// </summary>
-        public double WattDays => As(EnergyUnit.WattDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.WattHour"/>
-        /// </summary>
-        public double WattHours => As(EnergyUnit.WattHour);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.BritishThermalUnit"/>.
-        /// </summary>
-        public static Energy FromBritishThermalUnits(double britishthermalunits) => new Energy(britishthermalunits, EnergyUnit.BritishThermalUnit);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Calorie"/>.
-        /// </summary>
-        public static Energy FromCalories(double calories) => new Energy(calories, EnergyUnit.Calorie);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermEc"/>.
-        /// </summary>
-        public static Energy FromDecathermsEc(double decathermsec) => new Energy(decathermsec, EnergyUnit.DecathermEc);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermImperial"/>.
-        /// </summary>
-        public static Energy FromDecathermsImperial(double decathermsimperial) => new Energy(decathermsimperial, EnergyUnit.DecathermImperial);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermUs"/>.
-        /// </summary>
-        public static Energy FromDecathermsUs(double decathermsus) => new Energy(decathermsus, EnergyUnit.DecathermUs);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ElectronVolt"/>.
-        /// </summary>
-        public static Energy FromElectronVolts(double electronvolts) => new Energy(electronvolts, EnergyUnit.ElectronVolt);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Erg"/>.
-        /// </summary>
-        public static Energy FromErgs(double ergs) => new Energy(ergs, EnergyUnit.Erg);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.FootPound"/>.
-        /// </summary>
-        public static Energy FromFootPounds(double footpounds) => new Energy(footpounds, EnergyUnit.FootPound);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigabritishThermalUnit"/>.
-        /// </summary>
-        public static Energy FromGigabritishThermalUnits(double gigabritishthermalunits) => new Energy(gigabritishthermalunits, EnergyUnit.GigabritishThermalUnit);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigaelectronVolt"/>.
-        /// </summary>
-        public static Energy FromGigaelectronVolts(double gigaelectronvolts) => new Energy(gigaelectronvolts, EnergyUnit.GigaelectronVolt);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Gigajoule"/>.
-        /// </summary>
-        public static Energy FromGigajoules(double gigajoules) => new Energy(gigajoules, EnergyUnit.Gigajoule);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigawattDay"/>.
-        /// </summary>
-        public static Energy FromGigawattDays(double gigawattdays) => new Energy(gigawattdays, EnergyUnit.GigawattDay);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigawattHour"/>.
-        /// </summary>
-        public static Energy FromGigawattHours(double gigawatthours) => new Energy(gigawatthours, EnergyUnit.GigawattHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.HorsepowerHour"/>.
-        /// </summary>
-        public static Energy FromHorsepowerHours(double horsepowerhours) => new Energy(horsepowerhours, EnergyUnit.HorsepowerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Joule"/>.
-        /// </summary>
-        public static Energy FromJoules(double joules) => new Energy(joules, EnergyUnit.Joule);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilobritishThermalUnit"/>.
-        /// </summary>
-        public static Energy FromKilobritishThermalUnits(double kilobritishthermalunits) => new Energy(kilobritishthermalunits, EnergyUnit.KilobritishThermalUnit);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Kilocalorie"/>.
-        /// </summary>
-        public static Energy FromKilocalories(double kilocalories) => new Energy(kilocalories, EnergyUnit.Kilocalorie);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KiloelectronVolt"/>.
-        /// </summary>
-        public static Energy FromKiloelectronVolts(double kiloelectronvolts) => new Energy(kiloelectronvolts, EnergyUnit.KiloelectronVolt);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Kilojoule"/>.
-        /// </summary>
-        public static Energy FromKilojoules(double kilojoules) => new Energy(kilojoules, EnergyUnit.Kilojoule);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilowattDay"/>.
-        /// </summary>
-        public static Energy FromKilowattDays(double kilowattdays) => new Energy(kilowattdays, EnergyUnit.KilowattDay);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilowattHour"/>.
-        /// </summary>
-        public static Energy FromKilowattHours(double kilowatthours) => new Energy(kilowatthours, EnergyUnit.KilowattHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegabritishThermalUnit"/>.
-        /// </summary>
-        public static Energy FromMegabritishThermalUnits(double megabritishthermalunits) => new Energy(megabritishthermalunits, EnergyUnit.MegabritishThermalUnit);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Megacalorie"/>.
-        /// </summary>
-        public static Energy FromMegacalories(double megacalories) => new Energy(megacalories, EnergyUnit.Megacalorie);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegaelectronVolt"/>.
-        /// </summary>
-        public static Energy FromMegaelectronVolts(double megaelectronvolts) => new Energy(megaelectronvolts, EnergyUnit.MegaelectronVolt);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Megajoule"/>.
-        /// </summary>
-        public static Energy FromMegajoules(double megajoules) => new Energy(megajoules, EnergyUnit.Megajoule);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegawattDay"/>.
-        /// </summary>
-        public static Energy FromMegawattDays(double megawattdays) => new Energy(megawattdays, EnergyUnit.MegawattDay);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegawattHour"/>.
-        /// </summary>
-        public static Energy FromMegawattHours(double megawatthours) => new Energy(megawatthours, EnergyUnit.MegawattHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Microjoule"/>.
-        /// </summary>
-        public static Energy FromMicrojoules(double microjoules) => new Energy(microjoules, EnergyUnit.Microjoule);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Millijoule"/>.
-        /// </summary>
-        public static Energy FromMillijoules(double millijoules) => new Energy(millijoules, EnergyUnit.Millijoule);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Nanojoule"/>.
-        /// </summary>
-        public static Energy FromNanojoules(double nanojoules) => new Energy(nanojoules, EnergyUnit.Nanojoule);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Petajoule"/>.
-        /// </summary>
-        public static Energy FromPetajoules(double petajoules) => new Energy(petajoules, EnergyUnit.Petajoule);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TeraelectronVolt"/>.
-        /// </summary>
-        public static Energy FromTeraelectronVolts(double teraelectronvolts) => new Energy(teraelectronvolts, EnergyUnit.TeraelectronVolt);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Terajoule"/>.
-        /// </summary>
-        public static Energy FromTerajoules(double terajoules) => new Energy(terajoules, EnergyUnit.Terajoule);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TerawattDay"/>.
-        /// </summary>
-        public static Energy FromTerawattDays(double terawattdays) => new Energy(terawattdays, EnergyUnit.TerawattDay);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TerawattHour"/>.
-        /// </summary>
-        public static Energy FromTerawattHours(double terawatthours) => new Energy(terawatthours, EnergyUnit.TerawattHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermEc"/>.
-        /// </summary>
-        public static Energy FromThermsEc(double thermsec) => new Energy(thermsec, EnergyUnit.ThermEc);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermImperial"/>.
-        /// </summary>
-        public static Energy FromThermsImperial(double thermsimperial) => new Energy(thermsimperial, EnergyUnit.ThermImperial);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermUs"/>.
-        /// </summary>
-        public static Energy FromThermsUs(double thermsus) => new Energy(thermsus, EnergyUnit.ThermUs);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.WattDay"/>.
-        /// </summary>
-        public static Energy FromWattDays(double wattdays) => new Energy(wattdays, EnergyUnit.WattDay);
-
-        /// <summary>
-        ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.WattHour"/>.
-        /// </summary>
-        public static Energy FromWattHours(double watthours) => new Energy(watthours, EnergyUnit.WattHour);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="EnergyUnit" /> to <see cref="Energy" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Energy unit value.</returns>
-        public static Energy From(double value, EnergyUnit fromUnit)
-        {
-            return new Energy(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(EnergyUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Energy to another Energy with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Energy with the specified unit.</returns>
-                public Energy ToUnit(EnergyUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Energy(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        EnergyUnit.BritishThermalUnit => _value * 1055.05585262,
-                        EnergyUnit.Calorie => _value * 4.184,
-                        EnergyUnit.DecathermEc => (_value * 1.05505585262e8) * 1e1d,
-                        EnergyUnit.DecathermImperial => (_value * 1.05505585257348e8) * 1e1d,
-                        EnergyUnit.DecathermUs => (_value * 1.054804e8) * 1e1d,
-                        EnergyUnit.ElectronVolt => _value * 1.602176634e-19,
-                        EnergyUnit.Erg => _value * 1e-7,
-                        EnergyUnit.FootPound => _value * 1.3558179483314004,
-                        EnergyUnit.GigabritishThermalUnit => (_value * 1055.05585262) * 1e9d,
-                        EnergyUnit.GigaelectronVolt => (_value * 1.602176634e-19) * 1e9d,
-                        EnergyUnit.Gigajoule => (_value) * 1e9d,
-                        EnergyUnit.GigawattDay => (_value * 24 * 3600d) * 1e9d,
-                        EnergyUnit.GigawattHour => (_value * 3600d) * 1e9d,
-                        EnergyUnit.HorsepowerHour => _value * 76.0402249 * 9.80665 * 3600,
-                        EnergyUnit.Joule => _value,
-                        EnergyUnit.KilobritishThermalUnit => (_value * 1055.05585262) * 1e3d,
-                        EnergyUnit.Kilocalorie => (_value * 4.184) * 1e3d,
-                        EnergyUnit.KiloelectronVolt => (_value * 1.602176634e-19) * 1e3d,
-                        EnergyUnit.Kilojoule => (_value) * 1e3d,
-                        EnergyUnit.KilowattDay => (_value * 24 * 3600d) * 1e3d,
-                        EnergyUnit.KilowattHour => (_value * 3600d) * 1e3d,
-                        EnergyUnit.MegabritishThermalUnit => (_value * 1055.05585262) * 1e6d,
-                        EnergyUnit.Megacalorie => (_value * 4.184) * 1e6d,
-                        EnergyUnit.MegaelectronVolt => (_value * 1.602176634e-19) * 1e6d,
-                        EnergyUnit.Megajoule => (_value) * 1e6d,
-                        EnergyUnit.MegawattDay => (_value * 24 * 3600d) * 1e6d,
-                        EnergyUnit.MegawattHour => (_value * 3600d) * 1e6d,
-                        EnergyUnit.Microjoule => (_value) * 1e-6d,
-                        EnergyUnit.Millijoule => (_value) * 1e-3d,
-                        EnergyUnit.Nanojoule => (_value) * 1e-9d,
-                        EnergyUnit.Petajoule => (_value) * 1e15d,
-                        EnergyUnit.TeraelectronVolt => (_value * 1.602176634e-19) * 1e12d,
-                        EnergyUnit.Terajoule => (_value) * 1e12d,
-                        EnergyUnit.TerawattDay => (_value * 24 * 3600d) * 1e12d,
-                        EnergyUnit.TerawattHour => (_value * 3600d) * 1e12d,
-                        EnergyUnit.ThermEc => _value * 1.05505585262e8,
-                        EnergyUnit.ThermImperial => _value * 1.05505585257348e8,
-                        EnergyUnit.ThermUs => _value * 1.054804e8,
-                        EnergyUnit.WattDay => _value * 24 * 3600d,
-                        EnergyUnit.WattHour => _value * 3600d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(EnergyUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        EnergyUnit.BritishThermalUnit => baseUnitValue / 1055.05585262,
-                        EnergyUnit.Calorie => baseUnitValue / 4.184,
-                        EnergyUnit.DecathermEc => (baseUnitValue / 1.05505585262e8) / 1e1d,
-                        EnergyUnit.DecathermImperial => (baseUnitValue / 1.05505585257348e8) / 1e1d,
-                        EnergyUnit.DecathermUs => (baseUnitValue / 1.054804e8) / 1e1d,
-                        EnergyUnit.ElectronVolt => baseUnitValue / 1.602176634e-19,
-                        EnergyUnit.Erg => baseUnitValue / 1e-7,
-                        EnergyUnit.FootPound => baseUnitValue / 1.3558179483314004,
-                        EnergyUnit.GigabritishThermalUnit => (baseUnitValue / 1055.05585262) / 1e9d,
-                        EnergyUnit.GigaelectronVolt => (baseUnitValue / 1.602176634e-19) / 1e9d,
-                        EnergyUnit.Gigajoule => (baseUnitValue) / 1e9d,
-                        EnergyUnit.GigawattDay => (baseUnitValue / (24 * 3600d)) / 1e9d,
-                        EnergyUnit.GigawattHour => (baseUnitValue / 3600d) / 1e9d,
-                        EnergyUnit.HorsepowerHour => baseUnitValue / (76.0402249 * 9.80665 * 3600),
-                        EnergyUnit.Joule => baseUnitValue,
-                        EnergyUnit.KilobritishThermalUnit => (baseUnitValue / 1055.05585262) / 1e3d,
-                        EnergyUnit.Kilocalorie => (baseUnitValue / 4.184) / 1e3d,
-                        EnergyUnit.KiloelectronVolt => (baseUnitValue / 1.602176634e-19) / 1e3d,
-                        EnergyUnit.Kilojoule => (baseUnitValue) / 1e3d,
-                        EnergyUnit.KilowattDay => (baseUnitValue / (24 * 3600d)) / 1e3d,
-                        EnergyUnit.KilowattHour => (baseUnitValue / 3600d) / 1e3d,
-                        EnergyUnit.MegabritishThermalUnit => (baseUnitValue / 1055.05585262) / 1e6d,
-                        EnergyUnit.Megacalorie => (baseUnitValue / 4.184) / 1e6d,
-                        EnergyUnit.MegaelectronVolt => (baseUnitValue / 1.602176634e-19) / 1e6d,
-                        EnergyUnit.Megajoule => (baseUnitValue) / 1e6d,
-                        EnergyUnit.MegawattDay => (baseUnitValue / (24 * 3600d)) / 1e6d,
-                        EnergyUnit.MegawattHour => (baseUnitValue / 3600d) / 1e6d,
-                        EnergyUnit.Microjoule => (baseUnitValue) / 1e-6d,
-                        EnergyUnit.Millijoule => (baseUnitValue) / 1e-3d,
-                        EnergyUnit.Nanojoule => (baseUnitValue) / 1e-9d,
-                        EnergyUnit.Petajoule => (baseUnitValue) / 1e15d,
-                        EnergyUnit.TeraelectronVolt => (baseUnitValue / 1.602176634e-19) / 1e12d,
-                        EnergyUnit.Terajoule => (baseUnitValue) / 1e12d,
-                        EnergyUnit.TerawattDay => (baseUnitValue / (24 * 3600d)) / 1e12d,
-                        EnergyUnit.TerawattHour => (baseUnitValue / 3600d) / 1e12d,
-                        EnergyUnit.ThermEc => baseUnitValue / 1.05505585262e8,
-                        EnergyUnit.ThermImperial => baseUnitValue / 1.05505585257348e8,
-                        EnergyUnit.ThermUs => baseUnitValue / 1.054804e8,
-                        EnergyUnit.WattDay => baseUnitValue / (24 * 3600d),
-                        EnergyUnit.WattHour => baseUnitValue / 3600d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/EnergyDensity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/EnergyDensity.g.cs
deleted file mode 100644
index c9d7341693..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/EnergyDensity.g.cs
+++ /dev/null
@@ -1,289 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     
-    /// </summary>
-    public struct  EnergyDensity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly EnergyDensityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public EnergyDensityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public EnergyDensity(double value, EnergyDensityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of EnergyDensity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static EnergyDensityUnit BaseUnit { get; } = EnergyDensityUnit.JoulePerCubicMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of EnergyDensity.
-        /// </summary>
-        public static EnergyDensity MaxValue { get; } = new EnergyDensity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of EnergyDensity.
-        /// </summary>
-        public static EnergyDensity MinValue { get; } = new EnergyDensity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static EnergyDensity Zero { get; } = new EnergyDensity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.GigajoulePerCubicMeter"/>
-        /// </summary>
-        public double GigajoulesPerCubicMeter => As(EnergyDensityUnit.GigajoulePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.GigawattHourPerCubicMeter"/>
-        /// </summary>
-        public double GigawattHoursPerCubicMeter => As(EnergyDensityUnit.GigawattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.JoulePerCubicMeter"/>
-        /// </summary>
-        public double JoulesPerCubicMeter => As(EnergyDensityUnit.JoulePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.KilojoulePerCubicMeter"/>
-        /// </summary>
-        public double KilojoulesPerCubicMeter => As(EnergyDensityUnit.KilojoulePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.KilowattHourPerCubicMeter"/>
-        /// </summary>
-        public double KilowattHoursPerCubicMeter => As(EnergyDensityUnit.KilowattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.MegajoulePerCubicMeter"/>
-        /// </summary>
-        public double MegajoulesPerCubicMeter => As(EnergyDensityUnit.MegajoulePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.MegawattHourPerCubicMeter"/>
-        /// </summary>
-        public double MegawattHoursPerCubicMeter => As(EnergyDensityUnit.MegawattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.PetajoulePerCubicMeter"/>
-        /// </summary>
-        public double PetajoulesPerCubicMeter => As(EnergyDensityUnit.PetajoulePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.PetawattHourPerCubicMeter"/>
-        /// </summary>
-        public double PetawattHoursPerCubicMeter => As(EnergyDensityUnit.PetawattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.TerajoulePerCubicMeter"/>
-        /// </summary>
-        public double TerajoulesPerCubicMeter => As(EnergyDensityUnit.TerajoulePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.TerawattHourPerCubicMeter"/>
-        /// </summary>
-        public double TerawattHoursPerCubicMeter => As(EnergyDensityUnit.TerawattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.WattHourPerCubicMeter"/>
-        /// </summary>
-        public double WattHoursPerCubicMeter => As(EnergyDensityUnit.WattHourPerCubicMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.GigajoulePerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromGigajoulesPerCubicMeter(double gigajoulespercubicmeter) => new EnergyDensity(gigajoulespercubicmeter, EnergyDensityUnit.GigajoulePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.GigawattHourPerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromGigawattHoursPerCubicMeter(double gigawatthourspercubicmeter) => new EnergyDensity(gigawatthourspercubicmeter, EnergyDensityUnit.GigawattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.JoulePerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromJoulesPerCubicMeter(double joulespercubicmeter) => new EnergyDensity(joulespercubicmeter, EnergyDensityUnit.JoulePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.KilojoulePerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromKilojoulesPerCubicMeter(double kilojoulespercubicmeter) => new EnergyDensity(kilojoulespercubicmeter, EnergyDensityUnit.KilojoulePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.KilowattHourPerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromKilowattHoursPerCubicMeter(double kilowatthourspercubicmeter) => new EnergyDensity(kilowatthourspercubicmeter, EnergyDensityUnit.KilowattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.MegajoulePerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromMegajoulesPerCubicMeter(double megajoulespercubicmeter) => new EnergyDensity(megajoulespercubicmeter, EnergyDensityUnit.MegajoulePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.MegawattHourPerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromMegawattHoursPerCubicMeter(double megawatthourspercubicmeter) => new EnergyDensity(megawatthourspercubicmeter, EnergyDensityUnit.MegawattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.PetajoulePerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromPetajoulesPerCubicMeter(double petajoulespercubicmeter) => new EnergyDensity(petajoulespercubicmeter, EnergyDensityUnit.PetajoulePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.PetawattHourPerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromPetawattHoursPerCubicMeter(double petawatthourspercubicmeter) => new EnergyDensity(petawatthourspercubicmeter, EnergyDensityUnit.PetawattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.TerajoulePerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromTerajoulesPerCubicMeter(double terajoulespercubicmeter) => new EnergyDensity(terajoulespercubicmeter, EnergyDensityUnit.TerajoulePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.TerawattHourPerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromTerawattHoursPerCubicMeter(double terawatthourspercubicmeter) => new EnergyDensity(terawatthourspercubicmeter, EnergyDensityUnit.TerawattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.WattHourPerCubicMeter"/>.
-        /// </summary>
-        public static EnergyDensity FromWattHoursPerCubicMeter(double watthourspercubicmeter) => new EnergyDensity(watthourspercubicmeter, EnergyDensityUnit.WattHourPerCubicMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="EnergyDensityUnit" /> to <see cref="EnergyDensity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>EnergyDensity unit value.</returns>
-        public static EnergyDensity From(double value, EnergyDensityUnit fromUnit)
-        {
-            return new EnergyDensity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(EnergyDensityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this EnergyDensity to another EnergyDensity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A EnergyDensity with the specified unit.</returns>
-                public EnergyDensity ToUnit(EnergyDensityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new EnergyDensity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        EnergyDensityUnit.GigajoulePerCubicMeter => (_value) * 1e9d,
-                        EnergyDensityUnit.GigawattHourPerCubicMeter => (_value * 3.6e+3) * 1e9d,
-                        EnergyDensityUnit.JoulePerCubicMeter => _value,
-                        EnergyDensityUnit.KilojoulePerCubicMeter => (_value) * 1e3d,
-                        EnergyDensityUnit.KilowattHourPerCubicMeter => (_value * 3.6e+3) * 1e3d,
-                        EnergyDensityUnit.MegajoulePerCubicMeter => (_value) * 1e6d,
-                        EnergyDensityUnit.MegawattHourPerCubicMeter => (_value * 3.6e+3) * 1e6d,
-                        EnergyDensityUnit.PetajoulePerCubicMeter => (_value) * 1e15d,
-                        EnergyDensityUnit.PetawattHourPerCubicMeter => (_value * 3.6e+3) * 1e15d,
-                        EnergyDensityUnit.TerajoulePerCubicMeter => (_value) * 1e12d,
-                        EnergyDensityUnit.TerawattHourPerCubicMeter => (_value * 3.6e+3) * 1e12d,
-                        EnergyDensityUnit.WattHourPerCubicMeter => _value * 3.6e+3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(EnergyDensityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        EnergyDensityUnit.GigajoulePerCubicMeter => (baseUnitValue) / 1e9d,
-                        EnergyDensityUnit.GigawattHourPerCubicMeter => (baseUnitValue / 3.6e+3) / 1e9d,
-                        EnergyDensityUnit.JoulePerCubicMeter => baseUnitValue,
-                        EnergyDensityUnit.KilojoulePerCubicMeter => (baseUnitValue) / 1e3d,
-                        EnergyDensityUnit.KilowattHourPerCubicMeter => (baseUnitValue / 3.6e+3) / 1e3d,
-                        EnergyDensityUnit.MegajoulePerCubicMeter => (baseUnitValue) / 1e6d,
-                        EnergyDensityUnit.MegawattHourPerCubicMeter => (baseUnitValue / 3.6e+3) / 1e6d,
-                        EnergyDensityUnit.PetajoulePerCubicMeter => (baseUnitValue) / 1e15d,
-                        EnergyDensityUnit.PetawattHourPerCubicMeter => (baseUnitValue / 3.6e+3) / 1e15d,
-                        EnergyDensityUnit.TerajoulePerCubicMeter => (baseUnitValue) / 1e12d,
-                        EnergyDensityUnit.TerawattHourPerCubicMeter => (baseUnitValue / 3.6e+3) / 1e12d,
-                        EnergyDensityUnit.WattHourPerCubicMeter => baseUnitValue / 3.6e+3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Entropy.g.cs
deleted file mode 100644
index 69d68558db..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Entropy.g.cs
+++ /dev/null
@@ -1,229 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Entropy is an important concept in the branch of science known as thermodynamics. The idea of "irreversibility" is central to the understanding of entropy.  It is often said that entropy is an expression of the disorder, or randomness of a system, or of our lack of information about it. Entropy is an extensive property. It has the dimension of energy divided by temperature, which has a unit of joules per kelvin (J/K) in the International System of Units
-    /// </summary>
-    public struct  Entropy
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly EntropyUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public EntropyUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Entropy(double value, EntropyUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Entropy, which is Second. All conversions go via this value.
-        /// </summary>
-        public static EntropyUnit BaseUnit { get; } = EntropyUnit.JoulePerKelvin;
-
-        /// <summary>
-        /// Represents the largest possible value of Entropy.
-        /// </summary>
-        public static Entropy MaxValue { get; } = new Entropy(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Entropy.
-        /// </summary>
-        public static Entropy MinValue { get; } = new Entropy(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Entropy Zero { get; } = new Entropy(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.CaloriePerKelvin"/>
-        /// </summary>
-        public double CaloriesPerKelvin => As(EntropyUnit.CaloriePerKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.JoulePerDegreeCelsius"/>
-        /// </summary>
-        public double JoulesPerDegreeCelsius => As(EntropyUnit.JoulePerDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.JoulePerKelvin"/>
-        /// </summary>
-        public double JoulesPerKelvin => As(EntropyUnit.JoulePerKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.KilocaloriePerKelvin"/>
-        /// </summary>
-        public double KilocaloriesPerKelvin => As(EntropyUnit.KilocaloriePerKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.KilojoulePerDegreeCelsius"/>
-        /// </summary>
-        public double KilojoulesPerDegreeCelsius => As(EntropyUnit.KilojoulePerDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.KilojoulePerKelvin"/>
-        /// </summary>
-        public double KilojoulesPerKelvin => As(EntropyUnit.KilojoulePerKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.MegajoulePerKelvin"/>
-        /// </summary>
-        public double MegajoulesPerKelvin => As(EntropyUnit.MegajoulePerKelvin);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.CaloriePerKelvin"/>.
-        /// </summary>
-        public static Entropy FromCaloriesPerKelvin(double caloriesperkelvin) => new Entropy(caloriesperkelvin, EntropyUnit.CaloriePerKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.JoulePerDegreeCelsius"/>.
-        /// </summary>
-        public static Entropy FromJoulesPerDegreeCelsius(double joulesperdegreecelsius) => new Entropy(joulesperdegreecelsius, EntropyUnit.JoulePerDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.JoulePerKelvin"/>.
-        /// </summary>
-        public static Entropy FromJoulesPerKelvin(double joulesperkelvin) => new Entropy(joulesperkelvin, EntropyUnit.JoulePerKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilocaloriePerKelvin"/>.
-        /// </summary>
-        public static Entropy FromKilocaloriesPerKelvin(double kilocaloriesperkelvin) => new Entropy(kilocaloriesperkelvin, EntropyUnit.KilocaloriePerKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilojoulePerDegreeCelsius"/>.
-        /// </summary>
-        public static Entropy FromKilojoulesPerDegreeCelsius(double kilojoulesperdegreecelsius) => new Entropy(kilojoulesperdegreecelsius, EntropyUnit.KilojoulePerDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilojoulePerKelvin"/>.
-        /// </summary>
-        public static Entropy FromKilojoulesPerKelvin(double kilojoulesperkelvin) => new Entropy(kilojoulesperkelvin, EntropyUnit.KilojoulePerKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.MegajoulePerKelvin"/>.
-        /// </summary>
-        public static Entropy FromMegajoulesPerKelvin(double megajoulesperkelvin) => new Entropy(megajoulesperkelvin, EntropyUnit.MegajoulePerKelvin);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="EntropyUnit" /> to <see cref="Entropy" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Entropy unit value.</returns>
-        public static Entropy From(double value, EntropyUnit fromUnit)
-        {
-            return new Entropy(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(EntropyUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Entropy to another Entropy with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Entropy with the specified unit.</returns>
-                public Entropy ToUnit(EntropyUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Entropy(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        EntropyUnit.CaloriePerKelvin => _value * 4.184,
-                        EntropyUnit.JoulePerDegreeCelsius => _value,
-                        EntropyUnit.JoulePerKelvin => _value,
-                        EntropyUnit.KilocaloriePerKelvin => (_value * 4.184) * 1e3d,
-                        EntropyUnit.KilojoulePerDegreeCelsius => (_value) * 1e3d,
-                        EntropyUnit.KilojoulePerKelvin => (_value) * 1e3d,
-                        EntropyUnit.MegajoulePerKelvin => (_value) * 1e6d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(EntropyUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        EntropyUnit.CaloriePerKelvin => baseUnitValue / 4.184,
-                        EntropyUnit.JoulePerDegreeCelsius => baseUnitValue,
-                        EntropyUnit.JoulePerKelvin => baseUnitValue,
-                        EntropyUnit.KilocaloriePerKelvin => (baseUnitValue / 4.184) / 1e3d,
-                        EntropyUnit.KilojoulePerDegreeCelsius => (baseUnitValue) / 1e3d,
-                        EntropyUnit.KilojoulePerKelvin => (baseUnitValue) / 1e3d,
-                        EntropyUnit.MegajoulePerKelvin => (baseUnitValue) / 1e6d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/FluidResistance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/FluidResistance.g.cs
deleted file mode 100644
index 75aa49382e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/FluidResistance.g.cs
+++ /dev/null
@@ -1,376 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Fluid Resistance is a force acting opposite to the relative motion of any object moving with respect to a surrounding fluid. Fluid Resistance is sometimes referred to as drag or fluid friction.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Friction#Fluid
-    /// </remarks>
-    public struct  FluidResistance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly FluidResistanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public FluidResistanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public FluidResistance(double value, FluidResistanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of FluidResistance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static FluidResistanceUnit BaseUnit { get; } = FluidResistanceUnit.PascalSecondPerCubicMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of FluidResistance.
-        /// </summary>
-        public static FluidResistance MaxValue { get; } = new FluidResistance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of FluidResistance.
-        /// </summary>
-        public static FluidResistance MinValue { get; } = new FluidResistance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static FluidResistance Zero { get; } = new FluidResistance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth"/>
-        /// </summary>
-        public double DyneSecondsPerCentimeterToTheFifth => As(FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MegapascalSecondPerCubicMeter"/>
-        /// </summary>
-        public double MegapascalSecondsPerCubicMeter => As(FluidResistanceUnit.MegapascalSecondPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter"/>
-        /// </summary>
-        public double MillimeterMercuryMinutesPerCubicCentimeter => As(FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter"/>
-        /// </summary>
-        public double MillimeterMercuryMinutesPerCubicMeter => As(FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerLiter"/>
-        /// </summary>
-        public double MillimeterMercuryMinutesPerLiter => As(FluidResistanceUnit.MillimeterMercuryMinutePerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter"/>
-        /// </summary>
-        public double MillimeterMercuryMinutesPerMilliliter => As(FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter"/>
-        /// </summary>
-        public double MillimeterMercurySecondsPerCubicCentimeter => As(FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter"/>
-        /// </summary>
-        public double MillimeterMercurySecondsPerCubicMeter => As(FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerLiter"/>
-        /// </summary>
-        public double MillimeterMercurySecondsPerLiter => As(FluidResistanceUnit.MillimeterMercurySecondPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerMilliliter"/>
-        /// </summary>
-        public double MillimeterMercurySecondsPerMilliliter => As(FluidResistanceUnit.MillimeterMercurySecondPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerCubicCentimeter"/>
-        /// </summary>
-        public double PascalMinutesPerCubicCentimeter => As(FluidResistanceUnit.PascalMinutePerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerCubicMeter"/>
-        /// </summary>
-        public double PascalMinutesPerCubicMeter => As(FluidResistanceUnit.PascalMinutePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerLiter"/>
-        /// </summary>
-        public double PascalMinutesPerLiter => As(FluidResistanceUnit.PascalMinutePerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerMilliliter"/>
-        /// </summary>
-        public double PascalMinutesPerMilliliter => As(FluidResistanceUnit.PascalMinutePerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerCubicCentimeter"/>
-        /// </summary>
-        public double PascalSecondsPerCubicCentimeter => As(FluidResistanceUnit.PascalSecondPerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerCubicMeter"/>
-        /// </summary>
-        public double PascalSecondsPerCubicMeter => As(FluidResistanceUnit.PascalSecondPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerLiter"/>
-        /// </summary>
-        public double PascalSecondsPerLiter => As(FluidResistanceUnit.PascalSecondPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerMilliliter"/>
-        /// </summary>
-        public double PascalSecondsPerMilliliter => As(FluidResistanceUnit.PascalSecondPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.WoodUnit"/>
-        /// </summary>
-        public double WoodUnits => As(FluidResistanceUnit.WoodUnit);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth"/>.
-        /// </summary>
-        public static FluidResistance FromDyneSecondsPerCentimeterToTheFifth(double dynesecondspercentimetertothefifth) => new FluidResistance(dynesecondspercentimetertothefifth, FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MegapascalSecondPerCubicMeter"/>.
-        /// </summary>
-        public static FluidResistance FromMegapascalSecondsPerCubicMeter(double megapascalsecondspercubicmeter) => new FluidResistance(megapascalsecondspercubicmeter, FluidResistanceUnit.MegapascalSecondPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter"/>.
-        /// </summary>
-        public static FluidResistance FromMillimeterMercuryMinutesPerCubicCentimeter(double millimetermercuryminutespercubiccentimeter) => new FluidResistance(millimetermercuryminutespercubiccentimeter, FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter"/>.
-        /// </summary>
-        public static FluidResistance FromMillimeterMercuryMinutesPerCubicMeter(double millimetermercuryminutespercubicmeter) => new FluidResistance(millimetermercuryminutespercubicmeter, FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerLiter"/>.
-        /// </summary>
-        public static FluidResistance FromMillimeterMercuryMinutesPerLiter(double millimetermercuryminutesperliter) => new FluidResistance(millimetermercuryminutesperliter, FluidResistanceUnit.MillimeterMercuryMinutePerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter"/>.
-        /// </summary>
-        public static FluidResistance FromMillimeterMercuryMinutesPerMilliliter(double millimetermercuryminutespermilliliter) => new FluidResistance(millimetermercuryminutespermilliliter, FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter"/>.
-        /// </summary>
-        public static FluidResistance FromMillimeterMercurySecondsPerCubicCentimeter(double millimetermercurysecondspercubiccentimeter) => new FluidResistance(millimetermercurysecondspercubiccentimeter, FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter"/>.
-        /// </summary>
-        public static FluidResistance FromMillimeterMercurySecondsPerCubicMeter(double millimetermercurysecondspercubicmeter) => new FluidResistance(millimetermercurysecondspercubicmeter, FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercurySecondPerLiter"/>.
-        /// </summary>
-        public static FluidResistance FromMillimeterMercurySecondsPerLiter(double millimetermercurysecondsperliter) => new FluidResistance(millimetermercurysecondsperliter, FluidResistanceUnit.MillimeterMercurySecondPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercurySecondPerMilliliter"/>.
-        /// </summary>
-        public static FluidResistance FromMillimeterMercurySecondsPerMilliliter(double millimetermercurysecondspermilliliter) => new FluidResistance(millimetermercurysecondspermilliliter, FluidResistanceUnit.MillimeterMercurySecondPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalMinutePerCubicCentimeter"/>.
-        /// </summary>
-        public static FluidResistance FromPascalMinutesPerCubicCentimeter(double pascalminutespercubiccentimeter) => new FluidResistance(pascalminutespercubiccentimeter, FluidResistanceUnit.PascalMinutePerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalMinutePerCubicMeter"/>.
-        /// </summary>
-        public static FluidResistance FromPascalMinutesPerCubicMeter(double pascalminutespercubicmeter) => new FluidResistance(pascalminutespercubicmeter, FluidResistanceUnit.PascalMinutePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalMinutePerLiter"/>.
-        /// </summary>
-        public static FluidResistance FromPascalMinutesPerLiter(double pascalminutesperliter) => new FluidResistance(pascalminutesperliter, FluidResistanceUnit.PascalMinutePerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalMinutePerMilliliter"/>.
-        /// </summary>
-        public static FluidResistance FromPascalMinutesPerMilliliter(double pascalminutespermilliliter) => new FluidResistance(pascalminutespermilliliter, FluidResistanceUnit.PascalMinutePerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalSecondPerCubicCentimeter"/>.
-        /// </summary>
-        public static FluidResistance FromPascalSecondsPerCubicCentimeter(double pascalsecondspercubiccentimeter) => new FluidResistance(pascalsecondspercubiccentimeter, FluidResistanceUnit.PascalSecondPerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalSecondPerCubicMeter"/>.
-        /// </summary>
-        public static FluidResistance FromPascalSecondsPerCubicMeter(double pascalsecondspercubicmeter) => new FluidResistance(pascalsecondspercubicmeter, FluidResistanceUnit.PascalSecondPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalSecondPerLiter"/>.
-        /// </summary>
-        public static FluidResistance FromPascalSecondsPerLiter(double pascalsecondsperliter) => new FluidResistance(pascalsecondsperliter, FluidResistanceUnit.PascalSecondPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalSecondPerMilliliter"/>.
-        /// </summary>
-        public static FluidResistance FromPascalSecondsPerMilliliter(double pascalsecondspermilliliter) => new FluidResistance(pascalsecondspermilliliter, FluidResistanceUnit.PascalSecondPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.WoodUnit"/>.
-        /// </summary>
-        public static FluidResistance FromWoodUnits(double woodunits) => new FluidResistance(woodunits, FluidResistanceUnit.WoodUnit);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="FluidResistanceUnit" /> to <see cref="FluidResistance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>FluidResistance unit value.</returns>
-        public static FluidResistance From(double value, FluidResistanceUnit fromUnit)
-        {
-            return new FluidResistance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(FluidResistanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this FluidResistance to another FluidResistance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A FluidResistance with the specified unit.</returns>
-                public FluidResistance ToUnit(FluidResistanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new FluidResistance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth => _value * 1e5,
-                        FluidResistanceUnit.MegapascalSecondPerCubicMeter => (_value) * 1e6d,
-                        FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter => _value * 7.99934208e9,
-                        FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter => _value * 7.99934208e3,
-                        FluidResistanceUnit.MillimeterMercuryMinutePerLiter => _value * 7.99934208e6,
-                        FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter => _value * 7.99934208e9,
-                        FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter => _value * 1.33322368e8,
-                        FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter => _value * 133.322368,
-                        FluidResistanceUnit.MillimeterMercurySecondPerLiter => _value * 1.33322368e5,
-                        FluidResistanceUnit.MillimeterMercurySecondPerMilliliter => _value * 1.33322368e8,
-                        FluidResistanceUnit.PascalMinutePerCubicCentimeter => _value * 6e7,
-                        FluidResistanceUnit.PascalMinutePerCubicMeter => _value * 60,
-                        FluidResistanceUnit.PascalMinutePerLiter => _value * 6e4,
-                        FluidResistanceUnit.PascalMinutePerMilliliter => _value * 6e7,
-                        FluidResistanceUnit.PascalSecondPerCubicCentimeter => _value * 1e6,
-                        FluidResistanceUnit.PascalSecondPerCubicMeter => _value,
-                        FluidResistanceUnit.PascalSecondPerLiter => _value * 1e3,
-                        FluidResistanceUnit.PascalSecondPerMilliliter => _value * 1e6,
-                        FluidResistanceUnit.WoodUnit => _value * 7.99934208e6,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(FluidResistanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth => baseUnitValue / 1e5,
-                        FluidResistanceUnit.MegapascalSecondPerCubicMeter => (baseUnitValue) / 1e6d,
-                        FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter => baseUnitValue / 7.99934208e9,
-                        FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter => baseUnitValue / 7.99934208e3,
-                        FluidResistanceUnit.MillimeterMercuryMinutePerLiter => baseUnitValue / 7.99934208e6,
-                        FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter => baseUnitValue / 7.99934208e9,
-                        FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter => baseUnitValue / 1.33322368e8,
-                        FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter => baseUnitValue / 133.322368,
-                        FluidResistanceUnit.MillimeterMercurySecondPerLiter => baseUnitValue / 1.33322368e5,
-                        FluidResistanceUnit.MillimeterMercurySecondPerMilliliter => baseUnitValue / 1.33322368e8,
-                        FluidResistanceUnit.PascalMinutePerCubicCentimeter => baseUnitValue / 6e7,
-                        FluidResistanceUnit.PascalMinutePerCubicMeter => baseUnitValue / 60,
-                        FluidResistanceUnit.PascalMinutePerLiter => baseUnitValue / 6e4,
-                        FluidResistanceUnit.PascalMinutePerMilliliter => baseUnitValue / 6e7,
-                        FluidResistanceUnit.PascalSecondPerCubicCentimeter => baseUnitValue / 1e6,
-                        FluidResistanceUnit.PascalSecondPerCubicMeter => baseUnitValue,
-                        FluidResistanceUnit.PascalSecondPerLiter => baseUnitValue / 1e3,
-                        FluidResistanceUnit.PascalSecondPerMilliliter => baseUnitValue / 1e6,
-                        FluidResistanceUnit.WoodUnit => baseUnitValue / 7.99934208e6,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Force.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Force.g.cs
deleted file mode 100644
index 9f28f8f8d7..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Force.g.cs
+++ /dev/null
@@ -1,325 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In physics, a force is any influence that causes an object to undergo a certain change, either concerning its movement, direction, or geometrical construction. In other words, a force can cause an object with mass to change its velocity (which includes to begin moving from a state of rest), i.e., to accelerate, or a flexible object to deform, or both. Force can also be described by intuitive concepts such as a push or a pull. A force has both magnitude and direction, making it a vector quantity. It is measured in the SI unit of newtons and represented by the symbol F.
-    /// </summary>
-    public struct  Force
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ForceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ForceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Force(double value, ForceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Force, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ForceUnit BaseUnit { get; } = ForceUnit.Newton;
-
-        /// <summary>
-        /// Represents the largest possible value of Force.
-        /// </summary>
-        public static Force MaxValue { get; } = new Force(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Force.
-        /// </summary>
-        public static Force MinValue { get; } = new Force(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Force Zero { get; } = new Force(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Decanewton"/>
-        /// </summary>
-        public double Decanewtons => As(ForceUnit.Decanewton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Dyn"/>
-        /// </summary>
-        public double Dyne => As(ForceUnit.Dyn);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.KilogramForce"/>
-        /// </summary>
-        public double KilogramsForce => As(ForceUnit.KilogramForce);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Kilonewton"/>
-        /// </summary>
-        public double Kilonewtons => As(ForceUnit.Kilonewton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Kilopond"/>
-        /// </summary>
-        public double Kiloponds => As(ForceUnit.Kilopond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.KilopoundForce"/>
-        /// </summary>
-        public double KilopoundsForce => As(ForceUnit.KilopoundForce);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Meganewton"/>
-        /// </summary>
-        public double Meganewtons => As(ForceUnit.Meganewton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Micronewton"/>
-        /// </summary>
-        public double Micronewtons => As(ForceUnit.Micronewton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Millinewton"/>
-        /// </summary>
-        public double Millinewtons => As(ForceUnit.Millinewton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Newton"/>
-        /// </summary>
-        public double Newtons => As(ForceUnit.Newton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.OunceForce"/>
-        /// </summary>
-        public double OunceForce => As(ForceUnit.OunceForce);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Poundal"/>
-        /// </summary>
-        public double Poundals => As(ForceUnit.Poundal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.PoundForce"/>
-        /// </summary>
-        public double PoundsForce => As(ForceUnit.PoundForce);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.ShortTonForce"/>
-        /// </summary>
-        public double ShortTonsForce => As(ForceUnit.ShortTonForce);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.TonneForce"/>
-        /// </summary>
-        public double TonnesForce => As(ForceUnit.TonneForce);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Decanewton"/>.
-        /// </summary>
-        public static Force FromDecanewtons(double decanewtons) => new Force(decanewtons, ForceUnit.Decanewton);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Dyn"/>.
-        /// </summary>
-        public static Force FromDyne(double dyne) => new Force(dyne, ForceUnit.Dyn);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.KilogramForce"/>.
-        /// </summary>
-        public static Force FromKilogramsForce(double kilogramsforce) => new Force(kilogramsforce, ForceUnit.KilogramForce);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Kilonewton"/>.
-        /// </summary>
-        public static Force FromKilonewtons(double kilonewtons) => new Force(kilonewtons, ForceUnit.Kilonewton);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Kilopond"/>.
-        /// </summary>
-        public static Force FromKiloponds(double kiloponds) => new Force(kiloponds, ForceUnit.Kilopond);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.KilopoundForce"/>.
-        /// </summary>
-        public static Force FromKilopoundsForce(double kilopoundsforce) => new Force(kilopoundsforce, ForceUnit.KilopoundForce);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Meganewton"/>.
-        /// </summary>
-        public static Force FromMeganewtons(double meganewtons) => new Force(meganewtons, ForceUnit.Meganewton);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Micronewton"/>.
-        /// </summary>
-        public static Force FromMicronewtons(double micronewtons) => new Force(micronewtons, ForceUnit.Micronewton);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Millinewton"/>.
-        /// </summary>
-        public static Force FromMillinewtons(double millinewtons) => new Force(millinewtons, ForceUnit.Millinewton);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Newton"/>.
-        /// </summary>
-        public static Force FromNewtons(double newtons) => new Force(newtons, ForceUnit.Newton);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.OunceForce"/>.
-        /// </summary>
-        public static Force FromOunceForce(double ounceforce) => new Force(ounceforce, ForceUnit.OunceForce);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Poundal"/>.
-        /// </summary>
-        public static Force FromPoundals(double poundals) => new Force(poundals, ForceUnit.Poundal);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.PoundForce"/>.
-        /// </summary>
-        public static Force FromPoundsForce(double poundsforce) => new Force(poundsforce, ForceUnit.PoundForce);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.ShortTonForce"/>.
-        /// </summary>
-        public static Force FromShortTonsForce(double shorttonsforce) => new Force(shorttonsforce, ForceUnit.ShortTonForce);
-
-        /// <summary>
-        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.TonneForce"/>.
-        /// </summary>
-        public static Force FromTonnesForce(double tonnesforce) => new Force(tonnesforce, ForceUnit.TonneForce);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ForceUnit" /> to <see cref="Force" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Force unit value.</returns>
-        public static Force From(double value, ForceUnit fromUnit)
-        {
-            return new Force(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ForceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Force to another Force with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Force with the specified unit.</returns>
-                public Force ToUnit(ForceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Force(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ForceUnit.Decanewton => (_value) * 1e1d,
-                        ForceUnit.Dyn => _value / 1e5,
-                        ForceUnit.KilogramForce => _value * 9.80665,
-                        ForceUnit.Kilonewton => (_value) * 1e3d,
-                        ForceUnit.Kilopond => _value * 9.80665,
-                        ForceUnit.KilopoundForce => (_value * 4.4482216152605) * 1e3d,
-                        ForceUnit.Meganewton => (_value) * 1e6d,
-                        ForceUnit.Micronewton => (_value) * 1e-6d,
-                        ForceUnit.Millinewton => (_value) * 1e-3d,
-                        ForceUnit.Newton => _value,
-                        ForceUnit.OunceForce => _value * (4.4482216152605 / 16),
-                        ForceUnit.Poundal => _value * 0.138254954376,
-                        ForceUnit.PoundForce => _value * 4.4482216152605,
-                        ForceUnit.ShortTonForce => _value * (4.4482216152605 * 2000),
-                        ForceUnit.TonneForce => _value * (9.80665 * 1000),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ForceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ForceUnit.Decanewton => (baseUnitValue) / 1e1d,
-                        ForceUnit.Dyn => baseUnitValue * 1e5,
-                        ForceUnit.KilogramForce => baseUnitValue / 9.80665,
-                        ForceUnit.Kilonewton => (baseUnitValue) / 1e3d,
-                        ForceUnit.Kilopond => baseUnitValue / 9.80665,
-                        ForceUnit.KilopoundForce => (baseUnitValue / 4.4482216152605) / 1e3d,
-                        ForceUnit.Meganewton => (baseUnitValue) / 1e6d,
-                        ForceUnit.Micronewton => (baseUnitValue) / 1e-6d,
-                        ForceUnit.Millinewton => (baseUnitValue) / 1e-3d,
-                        ForceUnit.Newton => baseUnitValue,
-                        ForceUnit.OunceForce => baseUnitValue / (4.4482216152605 / 16),
-                        ForceUnit.Poundal => baseUnitValue / 0.138254954376,
-                        ForceUnit.PoundForce => baseUnitValue / 4.4482216152605,
-                        ForceUnit.ShortTonForce => baseUnitValue / (4.4482216152605 * 2000),
-                        ForceUnit.TonneForce => baseUnitValue / (9.80665 * 1000),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ForceChangeRate.g.cs
deleted file mode 100644
index 9f1a761c3c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ForceChangeRate.g.cs
+++ /dev/null
@@ -1,325 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Force change rate is the ratio of the force change to the time during which the change occurred (value of force changes per unit time).
-    /// </summary>
-    public struct  ForceChangeRate
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ForceChangeRateUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ForceChangeRateUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ForceChangeRate(double value, ForceChangeRateUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ForceChangeRate, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ForceChangeRateUnit BaseUnit { get; } = ForceChangeRateUnit.NewtonPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of ForceChangeRate.
-        /// </summary>
-        public static ForceChangeRate MaxValue { get; } = new ForceChangeRate(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ForceChangeRate.
-        /// </summary>
-        public static ForceChangeRate MinValue { get; } = new ForceChangeRate(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ForceChangeRate Zero { get; } = new ForceChangeRate(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.CentinewtonPerSecond"/>
-        /// </summary>
-        public double CentinewtonsPerSecond => As(ForceChangeRateUnit.CentinewtonPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.DecanewtonPerMinute"/>
-        /// </summary>
-        public double DecanewtonsPerMinute => As(ForceChangeRateUnit.DecanewtonPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.DecanewtonPerSecond"/>
-        /// </summary>
-        public double DecanewtonsPerSecond => As(ForceChangeRateUnit.DecanewtonPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.DecinewtonPerSecond"/>
-        /// </summary>
-        public double DecinewtonsPerSecond => As(ForceChangeRateUnit.DecinewtonPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilonewtonPerMinute"/>
-        /// </summary>
-        public double KilonewtonsPerMinute => As(ForceChangeRateUnit.KilonewtonPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilonewtonPerSecond"/>
-        /// </summary>
-        public double KilonewtonsPerSecond => As(ForceChangeRateUnit.KilonewtonPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilopoundForcePerMinute"/>
-        /// </summary>
-        public double KilopoundsForcePerMinute => As(ForceChangeRateUnit.KilopoundForcePerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilopoundForcePerSecond"/>
-        /// </summary>
-        public double KilopoundsForcePerSecond => As(ForceChangeRateUnit.KilopoundForcePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.MicronewtonPerSecond"/>
-        /// </summary>
-        public double MicronewtonsPerSecond => As(ForceChangeRateUnit.MicronewtonPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.MillinewtonPerSecond"/>
-        /// </summary>
-        public double MillinewtonsPerSecond => As(ForceChangeRateUnit.MillinewtonPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.NanonewtonPerSecond"/>
-        /// </summary>
-        public double NanonewtonsPerSecond => As(ForceChangeRateUnit.NanonewtonPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.NewtonPerMinute"/>
-        /// </summary>
-        public double NewtonsPerMinute => As(ForceChangeRateUnit.NewtonPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.NewtonPerSecond"/>
-        /// </summary>
-        public double NewtonsPerSecond => As(ForceChangeRateUnit.NewtonPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.PoundForcePerMinute"/>
-        /// </summary>
-        public double PoundsForcePerMinute => As(ForceChangeRateUnit.PoundForcePerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.PoundForcePerSecond"/>
-        /// </summary>
-        public double PoundsForcePerSecond => As(ForceChangeRateUnit.PoundForcePerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.CentinewtonPerSecond"/>.
-        /// </summary>
-        public static ForceChangeRate FromCentinewtonsPerSecond(double centinewtonspersecond) => new ForceChangeRate(centinewtonspersecond, ForceChangeRateUnit.CentinewtonPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecanewtonPerMinute"/>.
-        /// </summary>
-        public static ForceChangeRate FromDecanewtonsPerMinute(double decanewtonsperminute) => new ForceChangeRate(decanewtonsperminute, ForceChangeRateUnit.DecanewtonPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecanewtonPerSecond"/>.
-        /// </summary>
-        public static ForceChangeRate FromDecanewtonsPerSecond(double decanewtonspersecond) => new ForceChangeRate(decanewtonspersecond, ForceChangeRateUnit.DecanewtonPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecinewtonPerSecond"/>.
-        /// </summary>
-        public static ForceChangeRate FromDecinewtonsPerSecond(double decinewtonspersecond) => new ForceChangeRate(decinewtonspersecond, ForceChangeRateUnit.DecinewtonPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilonewtonPerMinute"/>.
-        /// </summary>
-        public static ForceChangeRate FromKilonewtonsPerMinute(double kilonewtonsperminute) => new ForceChangeRate(kilonewtonsperminute, ForceChangeRateUnit.KilonewtonPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilonewtonPerSecond"/>.
-        /// </summary>
-        public static ForceChangeRate FromKilonewtonsPerSecond(double kilonewtonspersecond) => new ForceChangeRate(kilonewtonspersecond, ForceChangeRateUnit.KilonewtonPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilopoundForcePerMinute"/>.
-        /// </summary>
-        public static ForceChangeRate FromKilopoundsForcePerMinute(double kilopoundsforceperminute) => new ForceChangeRate(kilopoundsforceperminute, ForceChangeRateUnit.KilopoundForcePerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilopoundForcePerSecond"/>.
-        /// </summary>
-        public static ForceChangeRate FromKilopoundsForcePerSecond(double kilopoundsforcepersecond) => new ForceChangeRate(kilopoundsforcepersecond, ForceChangeRateUnit.KilopoundForcePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.MicronewtonPerSecond"/>.
-        /// </summary>
-        public static ForceChangeRate FromMicronewtonsPerSecond(double micronewtonspersecond) => new ForceChangeRate(micronewtonspersecond, ForceChangeRateUnit.MicronewtonPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.MillinewtonPerSecond"/>.
-        /// </summary>
-        public static ForceChangeRate FromMillinewtonsPerSecond(double millinewtonspersecond) => new ForceChangeRate(millinewtonspersecond, ForceChangeRateUnit.MillinewtonPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NanonewtonPerSecond"/>.
-        /// </summary>
-        public static ForceChangeRate FromNanonewtonsPerSecond(double nanonewtonspersecond) => new ForceChangeRate(nanonewtonspersecond, ForceChangeRateUnit.NanonewtonPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NewtonPerMinute"/>.
-        /// </summary>
-        public static ForceChangeRate FromNewtonsPerMinute(double newtonsperminute) => new ForceChangeRate(newtonsperminute, ForceChangeRateUnit.NewtonPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NewtonPerSecond"/>.
-        /// </summary>
-        public static ForceChangeRate FromNewtonsPerSecond(double newtonspersecond) => new ForceChangeRate(newtonspersecond, ForceChangeRateUnit.NewtonPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.PoundForcePerMinute"/>.
-        /// </summary>
-        public static ForceChangeRate FromPoundsForcePerMinute(double poundsforceperminute) => new ForceChangeRate(poundsforceperminute, ForceChangeRateUnit.PoundForcePerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.PoundForcePerSecond"/>.
-        /// </summary>
-        public static ForceChangeRate FromPoundsForcePerSecond(double poundsforcepersecond) => new ForceChangeRate(poundsforcepersecond, ForceChangeRateUnit.PoundForcePerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ForceChangeRateUnit" /> to <see cref="ForceChangeRate" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ForceChangeRate unit value.</returns>
-        public static ForceChangeRate From(double value, ForceChangeRateUnit fromUnit)
-        {
-            return new ForceChangeRate(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ForceChangeRateUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ForceChangeRate to another ForceChangeRate with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ForceChangeRate with the specified unit.</returns>
-                public ForceChangeRate ToUnit(ForceChangeRateUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ForceChangeRate(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ForceChangeRateUnit.CentinewtonPerSecond => (_value) * 1e-2d,
-                        ForceChangeRateUnit.DecanewtonPerMinute => (_value / 60) * 1e1d,
-                        ForceChangeRateUnit.DecanewtonPerSecond => (_value) * 1e1d,
-                        ForceChangeRateUnit.DecinewtonPerSecond => (_value) * 1e-1d,
-                        ForceChangeRateUnit.KilonewtonPerMinute => (_value / 60) * 1e3d,
-                        ForceChangeRateUnit.KilonewtonPerSecond => (_value) * 1e3d,
-                        ForceChangeRateUnit.KilopoundForcePerMinute => (_value * 4.4482216152605 / 60) * 1e3d,
-                        ForceChangeRateUnit.KilopoundForcePerSecond => (_value * 4.4482216152605) * 1e3d,
-                        ForceChangeRateUnit.MicronewtonPerSecond => (_value) * 1e-6d,
-                        ForceChangeRateUnit.MillinewtonPerSecond => (_value) * 1e-3d,
-                        ForceChangeRateUnit.NanonewtonPerSecond => (_value) * 1e-9d,
-                        ForceChangeRateUnit.NewtonPerMinute => _value / 60,
-                        ForceChangeRateUnit.NewtonPerSecond => _value,
-                        ForceChangeRateUnit.PoundForcePerMinute => _value * 4.4482216152605 / 60,
-                        ForceChangeRateUnit.PoundForcePerSecond => _value * 4.4482216152605,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ForceChangeRateUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ForceChangeRateUnit.CentinewtonPerSecond => (baseUnitValue) / 1e-2d,
-                        ForceChangeRateUnit.DecanewtonPerMinute => (baseUnitValue * 60) / 1e1d,
-                        ForceChangeRateUnit.DecanewtonPerSecond => (baseUnitValue) / 1e1d,
-                        ForceChangeRateUnit.DecinewtonPerSecond => (baseUnitValue) / 1e-1d,
-                        ForceChangeRateUnit.KilonewtonPerMinute => (baseUnitValue * 60) / 1e3d,
-                        ForceChangeRateUnit.KilonewtonPerSecond => (baseUnitValue) / 1e3d,
-                        ForceChangeRateUnit.KilopoundForcePerMinute => (baseUnitValue / 4.4482216152605 * 60) / 1e3d,
-                        ForceChangeRateUnit.KilopoundForcePerSecond => (baseUnitValue / 4.4482216152605) / 1e3d,
-                        ForceChangeRateUnit.MicronewtonPerSecond => (baseUnitValue) / 1e-6d,
-                        ForceChangeRateUnit.MillinewtonPerSecond => (baseUnitValue) / 1e-3d,
-                        ForceChangeRateUnit.NanonewtonPerSecond => (baseUnitValue) / 1e-9d,
-                        ForceChangeRateUnit.NewtonPerMinute => baseUnitValue * 60,
-                        ForceChangeRateUnit.NewtonPerSecond => baseUnitValue,
-                        ForceChangeRateUnit.PoundForcePerMinute => baseUnitValue / 4.4482216152605 * 60,
-                        ForceChangeRateUnit.PoundForcePerSecond => baseUnitValue / 4.4482216152605,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ForcePerLength.g.cs
deleted file mode 100644
index f5994eafb7..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ForcePerLength.g.cs
+++ /dev/null
@@ -1,601 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The magnitude of force per unit length.
-    /// </summary>
-    public struct  ForcePerLength
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ForcePerLengthUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ForcePerLengthUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ForcePerLength(double value, ForcePerLengthUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ForcePerLength, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ForcePerLengthUnit BaseUnit { get; } = ForcePerLengthUnit.NewtonPerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of ForcePerLength.
-        /// </summary>
-        public static ForcePerLength MaxValue { get; } = new ForcePerLength(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ForcePerLength.
-        /// </summary>
-        public static ForcePerLength MinValue { get; } = new ForcePerLength(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ForcePerLength Zero { get; } = new ForcePerLength(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.CentinewtonPerCentimeter"/>
-        /// </summary>
-        public double CentinewtonsPerCentimeter => As(ForcePerLengthUnit.CentinewtonPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.CentinewtonPerMeter"/>
-        /// </summary>
-        public double CentinewtonsPerMeter => As(ForcePerLengthUnit.CentinewtonPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.CentinewtonPerMillimeter"/>
-        /// </summary>
-        public double CentinewtonsPerMillimeter => As(ForcePerLengthUnit.CentinewtonPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecanewtonPerCentimeter"/>
-        /// </summary>
-        public double DecanewtonsPerCentimeter => As(ForcePerLengthUnit.DecanewtonPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecanewtonPerMeter"/>
-        /// </summary>
-        public double DecanewtonsPerMeter => As(ForcePerLengthUnit.DecanewtonPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecanewtonPerMillimeter"/>
-        /// </summary>
-        public double DecanewtonsPerMillimeter => As(ForcePerLengthUnit.DecanewtonPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecinewtonPerCentimeter"/>
-        /// </summary>
-        public double DecinewtonsPerCentimeter => As(ForcePerLengthUnit.DecinewtonPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecinewtonPerMeter"/>
-        /// </summary>
-        public double DecinewtonsPerMeter => As(ForcePerLengthUnit.DecinewtonPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecinewtonPerMillimeter"/>
-        /// </summary>
-        public double DecinewtonsPerMillimeter => As(ForcePerLengthUnit.DecinewtonPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilogramForcePerCentimeter"/>
-        /// </summary>
-        public double KilogramsForcePerCentimeter => As(ForcePerLengthUnit.KilogramForcePerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilogramForcePerMeter"/>
-        /// </summary>
-        public double KilogramsForcePerMeter => As(ForcePerLengthUnit.KilogramForcePerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilogramForcePerMillimeter"/>
-        /// </summary>
-        public double KilogramsForcePerMillimeter => As(ForcePerLengthUnit.KilogramForcePerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilonewtonPerCentimeter"/>
-        /// </summary>
-        public double KilonewtonsPerCentimeter => As(ForcePerLengthUnit.KilonewtonPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilonewtonPerMeter"/>
-        /// </summary>
-        public double KilonewtonsPerMeter => As(ForcePerLengthUnit.KilonewtonPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilonewtonPerMillimeter"/>
-        /// </summary>
-        public double KilonewtonsPerMillimeter => As(ForcePerLengthUnit.KilonewtonPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilopoundForcePerFoot"/>
-        /// </summary>
-        public double KilopoundsForcePerFoot => As(ForcePerLengthUnit.KilopoundForcePerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilopoundForcePerInch"/>
-        /// </summary>
-        public double KilopoundsForcePerInch => As(ForcePerLengthUnit.KilopoundForcePerInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MeganewtonPerCentimeter"/>
-        /// </summary>
-        public double MeganewtonsPerCentimeter => As(ForcePerLengthUnit.MeganewtonPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MeganewtonPerMeter"/>
-        /// </summary>
-        public double MeganewtonsPerMeter => As(ForcePerLengthUnit.MeganewtonPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MeganewtonPerMillimeter"/>
-        /// </summary>
-        public double MeganewtonsPerMillimeter => As(ForcePerLengthUnit.MeganewtonPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MicronewtonPerCentimeter"/>
-        /// </summary>
-        public double MicronewtonsPerCentimeter => As(ForcePerLengthUnit.MicronewtonPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MicronewtonPerMeter"/>
-        /// </summary>
-        public double MicronewtonsPerMeter => As(ForcePerLengthUnit.MicronewtonPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MicronewtonPerMillimeter"/>
-        /// </summary>
-        public double MicronewtonsPerMillimeter => As(ForcePerLengthUnit.MicronewtonPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MillinewtonPerCentimeter"/>
-        /// </summary>
-        public double MillinewtonsPerCentimeter => As(ForcePerLengthUnit.MillinewtonPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MillinewtonPerMeter"/>
-        /// </summary>
-        public double MillinewtonsPerMeter => As(ForcePerLengthUnit.MillinewtonPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MillinewtonPerMillimeter"/>
-        /// </summary>
-        public double MillinewtonsPerMillimeter => As(ForcePerLengthUnit.MillinewtonPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NanonewtonPerCentimeter"/>
-        /// </summary>
-        public double NanonewtonsPerCentimeter => As(ForcePerLengthUnit.NanonewtonPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NanonewtonPerMeter"/>
-        /// </summary>
-        public double NanonewtonsPerMeter => As(ForcePerLengthUnit.NanonewtonPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NanonewtonPerMillimeter"/>
-        /// </summary>
-        public double NanonewtonsPerMillimeter => As(ForcePerLengthUnit.NanonewtonPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NewtonPerCentimeter"/>
-        /// </summary>
-        public double NewtonsPerCentimeter => As(ForcePerLengthUnit.NewtonPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NewtonPerMeter"/>
-        /// </summary>
-        public double NewtonsPerMeter => As(ForcePerLengthUnit.NewtonPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NewtonPerMillimeter"/>
-        /// </summary>
-        public double NewtonsPerMillimeter => As(ForcePerLengthUnit.NewtonPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.PoundForcePerFoot"/>
-        /// </summary>
-        public double PoundsForcePerFoot => As(ForcePerLengthUnit.PoundForcePerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.PoundForcePerInch"/>
-        /// </summary>
-        public double PoundsForcePerInch => As(ForcePerLengthUnit.PoundForcePerInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.PoundForcePerYard"/>
-        /// </summary>
-        public double PoundsForcePerYard => As(ForcePerLengthUnit.PoundForcePerYard);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.TonneForcePerCentimeter"/>
-        /// </summary>
-        public double TonnesForcePerCentimeter => As(ForcePerLengthUnit.TonneForcePerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.TonneForcePerMeter"/>
-        /// </summary>
-        public double TonnesForcePerMeter => As(ForcePerLengthUnit.TonneForcePerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.TonneForcePerMillimeter"/>
-        /// </summary>
-        public double TonnesForcePerMillimeter => As(ForcePerLengthUnit.TonneForcePerMillimeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromCentinewtonsPerCentimeter(double centinewtonspercentimeter) => new ForcePerLength(centinewtonspercentimeter, ForcePerLengthUnit.CentinewtonPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromCentinewtonsPerMeter(double centinewtonspermeter) => new ForcePerLength(centinewtonspermeter, ForcePerLengthUnit.CentinewtonPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromCentinewtonsPerMillimeter(double centinewtonspermillimeter) => new ForcePerLength(centinewtonspermillimeter, ForcePerLengthUnit.CentinewtonPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromDecanewtonsPerCentimeter(double decanewtonspercentimeter) => new ForcePerLength(decanewtonspercentimeter, ForcePerLengthUnit.DecanewtonPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromDecanewtonsPerMeter(double decanewtonspermeter) => new ForcePerLength(decanewtonspermeter, ForcePerLengthUnit.DecanewtonPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromDecanewtonsPerMillimeter(double decanewtonspermillimeter) => new ForcePerLength(decanewtonspermillimeter, ForcePerLengthUnit.DecanewtonPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromDecinewtonsPerCentimeter(double decinewtonspercentimeter) => new ForcePerLength(decinewtonspercentimeter, ForcePerLengthUnit.DecinewtonPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromDecinewtonsPerMeter(double decinewtonspermeter) => new ForcePerLength(decinewtonspermeter, ForcePerLengthUnit.DecinewtonPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromDecinewtonsPerMillimeter(double decinewtonspermillimeter) => new ForcePerLength(decinewtonspermillimeter, ForcePerLengthUnit.DecinewtonPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromKilogramsForcePerCentimeter(double kilogramsforcepercentimeter) => new ForcePerLength(kilogramsforcepercentimeter, ForcePerLengthUnit.KilogramForcePerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromKilogramsForcePerMeter(double kilogramsforcepermeter) => new ForcePerLength(kilogramsforcepermeter, ForcePerLengthUnit.KilogramForcePerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromKilogramsForcePerMillimeter(double kilogramsforcepermillimeter) => new ForcePerLength(kilogramsforcepermillimeter, ForcePerLengthUnit.KilogramForcePerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromKilonewtonsPerCentimeter(double kilonewtonspercentimeter) => new ForcePerLength(kilonewtonspercentimeter, ForcePerLengthUnit.KilonewtonPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromKilonewtonsPerMeter(double kilonewtonspermeter) => new ForcePerLength(kilonewtonspermeter, ForcePerLengthUnit.KilonewtonPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromKilonewtonsPerMillimeter(double kilonewtonspermillimeter) => new ForcePerLength(kilonewtonspermillimeter, ForcePerLengthUnit.KilonewtonPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilopoundForcePerFoot"/>.
-        /// </summary>
-        public static ForcePerLength FromKilopoundsForcePerFoot(double kilopoundsforceperfoot) => new ForcePerLength(kilopoundsforceperfoot, ForcePerLengthUnit.KilopoundForcePerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilopoundForcePerInch"/>.
-        /// </summary>
-        public static ForcePerLength FromKilopoundsForcePerInch(double kilopoundsforceperinch) => new ForcePerLength(kilopoundsforceperinch, ForcePerLengthUnit.KilopoundForcePerInch);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromMeganewtonsPerCentimeter(double meganewtonspercentimeter) => new ForcePerLength(meganewtonspercentimeter, ForcePerLengthUnit.MeganewtonPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromMeganewtonsPerMeter(double meganewtonspermeter) => new ForcePerLength(meganewtonspermeter, ForcePerLengthUnit.MeganewtonPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromMeganewtonsPerMillimeter(double meganewtonspermillimeter) => new ForcePerLength(meganewtonspermillimeter, ForcePerLengthUnit.MeganewtonPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromMicronewtonsPerCentimeter(double micronewtonspercentimeter) => new ForcePerLength(micronewtonspercentimeter, ForcePerLengthUnit.MicronewtonPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromMicronewtonsPerMeter(double micronewtonspermeter) => new ForcePerLength(micronewtonspermeter, ForcePerLengthUnit.MicronewtonPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromMicronewtonsPerMillimeter(double micronewtonspermillimeter) => new ForcePerLength(micronewtonspermillimeter, ForcePerLengthUnit.MicronewtonPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromMillinewtonsPerCentimeter(double millinewtonspercentimeter) => new ForcePerLength(millinewtonspercentimeter, ForcePerLengthUnit.MillinewtonPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromMillinewtonsPerMeter(double millinewtonspermeter) => new ForcePerLength(millinewtonspermeter, ForcePerLengthUnit.MillinewtonPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromMillinewtonsPerMillimeter(double millinewtonspermillimeter) => new ForcePerLength(millinewtonspermillimeter, ForcePerLengthUnit.MillinewtonPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromNanonewtonsPerCentimeter(double nanonewtonspercentimeter) => new ForcePerLength(nanonewtonspercentimeter, ForcePerLengthUnit.NanonewtonPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromNanonewtonsPerMeter(double nanonewtonspermeter) => new ForcePerLength(nanonewtonspermeter, ForcePerLengthUnit.NanonewtonPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromNanonewtonsPerMillimeter(double nanonewtonspermillimeter) => new ForcePerLength(nanonewtonspermillimeter, ForcePerLengthUnit.NanonewtonPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromNewtonsPerCentimeter(double newtonspercentimeter) => new ForcePerLength(newtonspercentimeter, ForcePerLengthUnit.NewtonPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromNewtonsPerMeter(double newtonspermeter) => new ForcePerLength(newtonspermeter, ForcePerLengthUnit.NewtonPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromNewtonsPerMillimeter(double newtonspermillimeter) => new ForcePerLength(newtonspermillimeter, ForcePerLengthUnit.NewtonPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerFoot"/>.
-        /// </summary>
-        public static ForcePerLength FromPoundsForcePerFoot(double poundsforceperfoot) => new ForcePerLength(poundsforceperfoot, ForcePerLengthUnit.PoundForcePerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerInch"/>.
-        /// </summary>
-        public static ForcePerLength FromPoundsForcePerInch(double poundsforceperinch) => new ForcePerLength(poundsforceperinch, ForcePerLengthUnit.PoundForcePerInch);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerYard"/>.
-        /// </summary>
-        public static ForcePerLength FromPoundsForcePerYard(double poundsforceperyard) => new ForcePerLength(poundsforceperyard, ForcePerLengthUnit.PoundForcePerYard);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerCentimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromTonnesForcePerCentimeter(double tonnesforcepercentimeter) => new ForcePerLength(tonnesforcepercentimeter, ForcePerLengthUnit.TonneForcePerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerMeter"/>.
-        /// </summary>
-        public static ForcePerLength FromTonnesForcePerMeter(double tonnesforcepermeter) => new ForcePerLength(tonnesforcepermeter, ForcePerLengthUnit.TonneForcePerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerMillimeter"/>.
-        /// </summary>
-        public static ForcePerLength FromTonnesForcePerMillimeter(double tonnesforcepermillimeter) => new ForcePerLength(tonnesforcepermillimeter, ForcePerLengthUnit.TonneForcePerMillimeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ForcePerLengthUnit" /> to <see cref="ForcePerLength" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ForcePerLength unit value.</returns>
-        public static ForcePerLength From(double value, ForcePerLengthUnit fromUnit)
-        {
-            return new ForcePerLength(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ForcePerLengthUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ForcePerLength to another ForcePerLength with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ForcePerLength with the specified unit.</returns>
-                public ForcePerLength ToUnit(ForcePerLengthUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ForcePerLength(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ForcePerLengthUnit.CentinewtonPerCentimeter => (_value * 1e2) * 1e-2d,
-                        ForcePerLengthUnit.CentinewtonPerMeter => (_value) * 1e-2d,
-                        ForcePerLengthUnit.CentinewtonPerMillimeter => (_value * 1e3) * 1e-2d,
-                        ForcePerLengthUnit.DecanewtonPerCentimeter => (_value * 1e2) * 1e1d,
-                        ForcePerLengthUnit.DecanewtonPerMeter => (_value) * 1e1d,
-                        ForcePerLengthUnit.DecanewtonPerMillimeter => (_value * 1e3) * 1e1d,
-                        ForcePerLengthUnit.DecinewtonPerCentimeter => (_value * 1e2) * 1e-1d,
-                        ForcePerLengthUnit.DecinewtonPerMeter => (_value) * 1e-1d,
-                        ForcePerLengthUnit.DecinewtonPerMillimeter => (_value * 1e3) * 1e-1d,
-                        ForcePerLengthUnit.KilogramForcePerCentimeter => _value * 980.665,
-                        ForcePerLengthUnit.KilogramForcePerMeter => _value * 9.80665,
-                        ForcePerLengthUnit.KilogramForcePerMillimeter => _value * 9.80665e3,
-                        ForcePerLengthUnit.KilonewtonPerCentimeter => (_value * 1e2) * 1e3d,
-                        ForcePerLengthUnit.KilonewtonPerMeter => (_value) * 1e3d,
-                        ForcePerLengthUnit.KilonewtonPerMillimeter => (_value * 1e3) * 1e3d,
-                        ForcePerLengthUnit.KilopoundForcePerFoot => _value * 4.4482216152605 / 0.3048e-3,
-                        ForcePerLengthUnit.KilopoundForcePerInch => _value * 4.4482216152605 / 2.54e-5,
-                        ForcePerLengthUnit.MeganewtonPerCentimeter => (_value * 1e2) * 1e6d,
-                        ForcePerLengthUnit.MeganewtonPerMeter => (_value) * 1e6d,
-                        ForcePerLengthUnit.MeganewtonPerMillimeter => (_value * 1e3) * 1e6d,
-                        ForcePerLengthUnit.MicronewtonPerCentimeter => (_value * 1e2) * 1e-6d,
-                        ForcePerLengthUnit.MicronewtonPerMeter => (_value) * 1e-6d,
-                        ForcePerLengthUnit.MicronewtonPerMillimeter => (_value * 1e3) * 1e-6d,
-                        ForcePerLengthUnit.MillinewtonPerCentimeter => (_value * 1e2) * 1e-3d,
-                        ForcePerLengthUnit.MillinewtonPerMeter => (_value) * 1e-3d,
-                        ForcePerLengthUnit.MillinewtonPerMillimeter => (_value * 1e3) * 1e-3d,
-                        ForcePerLengthUnit.NanonewtonPerCentimeter => (_value * 1e2) * 1e-9d,
-                        ForcePerLengthUnit.NanonewtonPerMeter => (_value) * 1e-9d,
-                        ForcePerLengthUnit.NanonewtonPerMillimeter => (_value * 1e3) * 1e-9d,
-                        ForcePerLengthUnit.NewtonPerCentimeter => _value * 1e2,
-                        ForcePerLengthUnit.NewtonPerMeter => _value,
-                        ForcePerLengthUnit.NewtonPerMillimeter => _value * 1e3,
-                        ForcePerLengthUnit.PoundForcePerFoot => _value * 4.4482216152605 / 0.3048,
-                        ForcePerLengthUnit.PoundForcePerInch => _value * 4.4482216152605 / 2.54e-2,
-                        ForcePerLengthUnit.PoundForcePerYard => _value * 4.4482216152605 / 0.9144,
-                        ForcePerLengthUnit.TonneForcePerCentimeter => _value * 9.80665e5,
-                        ForcePerLengthUnit.TonneForcePerMeter => _value * 9.80665e3,
-                        ForcePerLengthUnit.TonneForcePerMillimeter => _value * 9.80665e6,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ForcePerLengthUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ForcePerLengthUnit.CentinewtonPerCentimeter => (baseUnitValue / 1e2) / 1e-2d,
-                        ForcePerLengthUnit.CentinewtonPerMeter => (baseUnitValue) / 1e-2d,
-                        ForcePerLengthUnit.CentinewtonPerMillimeter => (baseUnitValue / 1e3) / 1e-2d,
-                        ForcePerLengthUnit.DecanewtonPerCentimeter => (baseUnitValue / 1e2) / 1e1d,
-                        ForcePerLengthUnit.DecanewtonPerMeter => (baseUnitValue) / 1e1d,
-                        ForcePerLengthUnit.DecanewtonPerMillimeter => (baseUnitValue / 1e3) / 1e1d,
-                        ForcePerLengthUnit.DecinewtonPerCentimeter => (baseUnitValue / 1e2) / 1e-1d,
-                        ForcePerLengthUnit.DecinewtonPerMeter => (baseUnitValue) / 1e-1d,
-                        ForcePerLengthUnit.DecinewtonPerMillimeter => (baseUnitValue / 1e3) / 1e-1d,
-                        ForcePerLengthUnit.KilogramForcePerCentimeter => baseUnitValue / 980.665,
-                        ForcePerLengthUnit.KilogramForcePerMeter => baseUnitValue / 9.80665,
-                        ForcePerLengthUnit.KilogramForcePerMillimeter => baseUnitValue / 9.80665e3,
-                        ForcePerLengthUnit.KilonewtonPerCentimeter => (baseUnitValue / 1e2) / 1e3d,
-                        ForcePerLengthUnit.KilonewtonPerMeter => (baseUnitValue) / 1e3d,
-                        ForcePerLengthUnit.KilonewtonPerMillimeter => (baseUnitValue / 1e3) / 1e3d,
-                        ForcePerLengthUnit.KilopoundForcePerFoot => baseUnitValue * 0.3048e-3 / 4.4482216152605,
-                        ForcePerLengthUnit.KilopoundForcePerInch => baseUnitValue * 2.54e-5 / 4.4482216152605,
-                        ForcePerLengthUnit.MeganewtonPerCentimeter => (baseUnitValue / 1e2) / 1e6d,
-                        ForcePerLengthUnit.MeganewtonPerMeter => (baseUnitValue) / 1e6d,
-                        ForcePerLengthUnit.MeganewtonPerMillimeter => (baseUnitValue / 1e3) / 1e6d,
-                        ForcePerLengthUnit.MicronewtonPerCentimeter => (baseUnitValue / 1e2) / 1e-6d,
-                        ForcePerLengthUnit.MicronewtonPerMeter => (baseUnitValue) / 1e-6d,
-                        ForcePerLengthUnit.MicronewtonPerMillimeter => (baseUnitValue / 1e3) / 1e-6d,
-                        ForcePerLengthUnit.MillinewtonPerCentimeter => (baseUnitValue / 1e2) / 1e-3d,
-                        ForcePerLengthUnit.MillinewtonPerMeter => (baseUnitValue) / 1e-3d,
-                        ForcePerLengthUnit.MillinewtonPerMillimeter => (baseUnitValue / 1e3) / 1e-3d,
-                        ForcePerLengthUnit.NanonewtonPerCentimeter => (baseUnitValue / 1e2) / 1e-9d,
-                        ForcePerLengthUnit.NanonewtonPerMeter => (baseUnitValue) / 1e-9d,
-                        ForcePerLengthUnit.NanonewtonPerMillimeter => (baseUnitValue / 1e3) / 1e-9d,
-                        ForcePerLengthUnit.NewtonPerCentimeter => baseUnitValue / 1e2,
-                        ForcePerLengthUnit.NewtonPerMeter => baseUnitValue,
-                        ForcePerLengthUnit.NewtonPerMillimeter => baseUnitValue / 1e3,
-                        ForcePerLengthUnit.PoundForcePerFoot => baseUnitValue * 0.3048 / 4.4482216152605,
-                        ForcePerLengthUnit.PoundForcePerInch => baseUnitValue * 2.54e-2 / 4.4482216152605,
-                        ForcePerLengthUnit.PoundForcePerYard => baseUnitValue * 0.9144 / 4.4482216152605,
-                        ForcePerLengthUnit.TonneForcePerCentimeter => baseUnitValue / 9.80665e5,
-                        ForcePerLengthUnit.TonneForcePerMeter => baseUnitValue / 9.80665e3,
-                        ForcePerLengthUnit.TonneForcePerMillimeter => baseUnitValue / 9.80665e6,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Frequency.g.cs
deleted file mode 100644
index 10ab65d3b0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Frequency.g.cs
+++ /dev/null
@@ -1,289 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The number of occurrences of a repeating event per unit time.
-    /// </summary>
-    public struct  Frequency
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly FrequencyUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public FrequencyUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Frequency(double value, FrequencyUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Frequency, which is Second. All conversions go via this value.
-        /// </summary>
-        public static FrequencyUnit BaseUnit { get; } = FrequencyUnit.Hertz;
-
-        /// <summary>
-        /// Represents the largest possible value of Frequency.
-        /// </summary>
-        public static Frequency MaxValue { get; } = new Frequency(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Frequency.
-        /// </summary>
-        public static Frequency MinValue { get; } = new Frequency(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Frequency Zero { get; } = new Frequency(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.BeatPerMinute"/>
-        /// </summary>
-        public double BeatsPerMinute => As(FrequencyUnit.BeatPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.CyclePerHour"/>
-        /// </summary>
-        public double CyclesPerHour => As(FrequencyUnit.CyclePerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.CyclePerMinute"/>
-        /// </summary>
-        public double CyclesPerMinute => As(FrequencyUnit.CyclePerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Gigahertz"/>
-        /// </summary>
-        public double Gigahertz => As(FrequencyUnit.Gigahertz);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Hertz"/>
-        /// </summary>
-        public double Hertz => As(FrequencyUnit.Hertz);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Kilohertz"/>
-        /// </summary>
-        public double Kilohertz => As(FrequencyUnit.Kilohertz);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Megahertz"/>
-        /// </summary>
-        public double Megahertz => As(FrequencyUnit.Megahertz);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Microhertz"/>
-        /// </summary>
-        public double Microhertz => As(FrequencyUnit.Microhertz);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Millihertz"/>
-        /// </summary>
-        public double Millihertz => As(FrequencyUnit.Millihertz);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.PerSecond"/>
-        /// </summary>
-        public double PerSecond => As(FrequencyUnit.PerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.RadianPerSecond"/>
-        /// </summary>
-        public double RadiansPerSecond => As(FrequencyUnit.RadianPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Terahertz"/>
-        /// </summary>
-        public double Terahertz => As(FrequencyUnit.Terahertz);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.BeatPerMinute"/>.
-        /// </summary>
-        public static Frequency FromBeatsPerMinute(double beatsperminute) => new Frequency(beatsperminute, FrequencyUnit.BeatPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.CyclePerHour"/>.
-        /// </summary>
-        public static Frequency FromCyclesPerHour(double cyclesperhour) => new Frequency(cyclesperhour, FrequencyUnit.CyclePerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.CyclePerMinute"/>.
-        /// </summary>
-        public static Frequency FromCyclesPerMinute(double cyclesperminute) => new Frequency(cyclesperminute, FrequencyUnit.CyclePerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Gigahertz"/>.
-        /// </summary>
-        public static Frequency FromGigahertz(double gigahertz) => new Frequency(gigahertz, FrequencyUnit.Gigahertz);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Hertz"/>.
-        /// </summary>
-        public static Frequency FromHertz(double hertz) => new Frequency(hertz, FrequencyUnit.Hertz);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Kilohertz"/>.
-        /// </summary>
-        public static Frequency FromKilohertz(double kilohertz) => new Frequency(kilohertz, FrequencyUnit.Kilohertz);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Megahertz"/>.
-        /// </summary>
-        public static Frequency FromMegahertz(double megahertz) => new Frequency(megahertz, FrequencyUnit.Megahertz);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Microhertz"/>.
-        /// </summary>
-        public static Frequency FromMicrohertz(double microhertz) => new Frequency(microhertz, FrequencyUnit.Microhertz);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Millihertz"/>.
-        /// </summary>
-        public static Frequency FromMillihertz(double millihertz) => new Frequency(millihertz, FrequencyUnit.Millihertz);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.PerSecond"/>.
-        /// </summary>
-        public static Frequency FromPerSecond(double persecond) => new Frequency(persecond, FrequencyUnit.PerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.RadianPerSecond"/>.
-        /// </summary>
-        public static Frequency FromRadiansPerSecond(double radianspersecond) => new Frequency(radianspersecond, FrequencyUnit.RadianPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Terahertz"/>.
-        /// </summary>
-        public static Frequency FromTerahertz(double terahertz) => new Frequency(terahertz, FrequencyUnit.Terahertz);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="FrequencyUnit" /> to <see cref="Frequency" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Frequency unit value.</returns>
-        public static Frequency From(double value, FrequencyUnit fromUnit)
-        {
-            return new Frequency(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(FrequencyUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Frequency to another Frequency with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Frequency with the specified unit.</returns>
-                public Frequency ToUnit(FrequencyUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Frequency(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        FrequencyUnit.BeatPerMinute => _value / 60,
-                        FrequencyUnit.CyclePerHour => _value / 3600,
-                        FrequencyUnit.CyclePerMinute => _value / 60,
-                        FrequencyUnit.Gigahertz => (_value) * 1e9d,
-                        FrequencyUnit.Hertz => _value,
-                        FrequencyUnit.Kilohertz => (_value) * 1e3d,
-                        FrequencyUnit.Megahertz => (_value) * 1e6d,
-                        FrequencyUnit.Microhertz => (_value) * 1e-6d,
-                        FrequencyUnit.Millihertz => (_value) * 1e-3d,
-                        FrequencyUnit.PerSecond => _value,
-                        FrequencyUnit.RadianPerSecond => _value / (2 * 3.1415926535897931),
-                        FrequencyUnit.Terahertz => (_value) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(FrequencyUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        FrequencyUnit.BeatPerMinute => baseUnitValue * 60,
-                        FrequencyUnit.CyclePerHour => baseUnitValue * 3600,
-                        FrequencyUnit.CyclePerMinute => baseUnitValue * 60,
-                        FrequencyUnit.Gigahertz => (baseUnitValue) / 1e9d,
-                        FrequencyUnit.Hertz => baseUnitValue,
-                        FrequencyUnit.Kilohertz => (baseUnitValue) / 1e3d,
-                        FrequencyUnit.Megahertz => (baseUnitValue) / 1e6d,
-                        FrequencyUnit.Microhertz => (baseUnitValue) / 1e-6d,
-                        FrequencyUnit.Millihertz => (baseUnitValue) / 1e-3d,
-                        FrequencyUnit.PerSecond => baseUnitValue,
-                        FrequencyUnit.RadianPerSecond => baseUnitValue * (2 * 3.1415926535897931),
-                        FrequencyUnit.Terahertz => (baseUnitValue) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/FuelEfficiency.g.cs
deleted file mode 100644
index e6932b94c0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/FuelEfficiency.g.cs
+++ /dev/null
@@ -1,196 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In the context of transport, fuel economy is the energy efficiency of a particular vehicle, given as a ratio of distance traveled per unit of fuel consumed. In most countries, using the metric system, fuel economy is stated as "fuel consumption" in liters per 100 kilometers (L/100 km) or kilometers per liter (km/L or kmpl). In countries using non-metric system, fuel economy is expressed in miles per gallon (mpg) (imperial galon or US galon).
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Fuel_efficiency
-    /// </remarks>
-    public struct  FuelEfficiency
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly FuelEfficiencyUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public FuelEfficiencyUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public FuelEfficiency(double value, FuelEfficiencyUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of FuelEfficiency, which is Second. All conversions go via this value.
-        /// </summary>
-        public static FuelEfficiencyUnit BaseUnit { get; } = FuelEfficiencyUnit.KilometerPerLiter;
-
-        /// <summary>
-        /// Represents the largest possible value of FuelEfficiency.
-        /// </summary>
-        public static FuelEfficiency MaxValue { get; } = new FuelEfficiency(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of FuelEfficiency.
-        /// </summary>
-        public static FuelEfficiency MinValue { get; } = new FuelEfficiency(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static FuelEfficiency Zero { get; } = new FuelEfficiency(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.KilometerPerLiter"/>
-        /// </summary>
-        public double KilometersPerLiter => As(FuelEfficiencyUnit.KilometerPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.LiterPer100Kilometers"/>
-        /// </summary>
-        public double LitersPer100Kilometers => As(FuelEfficiencyUnit.LiterPer100Kilometers);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.MilePerUkGallon"/>
-        /// </summary>
-        public double MilesPerUkGallon => As(FuelEfficiencyUnit.MilePerUkGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.MilePerUsGallon"/>
-        /// </summary>
-        public double MilesPerUsGallon => As(FuelEfficiencyUnit.MilePerUsGallon);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.KilometerPerLiter"/>.
-        /// </summary>
-        public static FuelEfficiency FromKilometersPerLiter(double kilometersperliter) => new FuelEfficiency(kilometersperliter, FuelEfficiencyUnit.KilometerPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.LiterPer100Kilometers"/>.
-        /// </summary>
-        public static FuelEfficiency FromLitersPer100Kilometers(double litersper100kilometers) => new FuelEfficiency(litersper100kilometers, FuelEfficiencyUnit.LiterPer100Kilometers);
-
-        /// <summary>
-        ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.MilePerUkGallon"/>.
-        /// </summary>
-        public static FuelEfficiency FromMilesPerUkGallon(double milesperukgallon) => new FuelEfficiency(milesperukgallon, FuelEfficiencyUnit.MilePerUkGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.MilePerUsGallon"/>.
-        /// </summary>
-        public static FuelEfficiency FromMilesPerUsGallon(double milesperusgallon) => new FuelEfficiency(milesperusgallon, FuelEfficiencyUnit.MilePerUsGallon);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="FuelEfficiencyUnit" /> to <see cref="FuelEfficiency" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>FuelEfficiency unit value.</returns>
-        public static FuelEfficiency From(double value, FuelEfficiencyUnit fromUnit)
-        {
-            return new FuelEfficiency(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(FuelEfficiencyUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this FuelEfficiency to another FuelEfficiency with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A FuelEfficiency with the specified unit.</returns>
-                public FuelEfficiency ToUnit(FuelEfficiencyUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new FuelEfficiency(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        FuelEfficiencyUnit.KilometerPerLiter => _value,
-                        FuelEfficiencyUnit.LiterPer100Kilometers => 100 / _value,
-                        FuelEfficiencyUnit.MilePerUkGallon => _value * 1.609344 / 4.54609,
-                        FuelEfficiencyUnit.MilePerUsGallon => _value * 1.609344 / 3.785411784,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(FuelEfficiencyUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        FuelEfficiencyUnit.KilometerPerLiter => baseUnitValue,
-                        FuelEfficiencyUnit.LiterPer100Kilometers => 100 / baseUnitValue,
-                        FuelEfficiencyUnit.MilePerUkGallon => baseUnitValue * 4.54609 / 1.609344,
-                        FuelEfficiencyUnit.MilePerUsGallon => baseUnitValue * 3.785411784 / 1.609344,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/HeatFlux.g.cs
deleted file mode 100644
index d1027cafde..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/HeatFlux.g.cs
+++ /dev/null
@@ -1,361 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Heat flux is the flow of energy per unit of area per unit of time
-    /// </summary>
-    public struct  HeatFlux
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly HeatFluxUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public HeatFluxUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public HeatFlux(double value, HeatFluxUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of HeatFlux, which is Second. All conversions go via this value.
-        /// </summary>
-        public static HeatFluxUnit BaseUnit { get; } = HeatFluxUnit.WattPerSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of HeatFlux.
-        /// </summary>
-        public static HeatFlux MaxValue { get; } = new HeatFlux(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of HeatFlux.
-        /// </summary>
-        public static HeatFlux MinValue { get; } = new HeatFlux(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static HeatFlux Zero { get; } = new HeatFlux(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerHourSquareFoot"/>
-        /// </summary>
-        public double BtusPerHourSquareFoot => As(HeatFluxUnit.BtuPerHourSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerMinuteSquareFoot"/>
-        /// </summary>
-        public double BtusPerMinuteSquareFoot => As(HeatFluxUnit.BtuPerMinuteSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerSecondSquareFoot"/>
-        /// </summary>
-        public double BtusPerSecondSquareFoot => As(HeatFluxUnit.BtuPerSecondSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerSecondSquareInch"/>
-        /// </summary>
-        public double BtusPerSecondSquareInch => As(HeatFluxUnit.BtuPerSecondSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.CaloriePerSecondSquareCentimeter"/>
-        /// </summary>
-        public double CaloriesPerSecondSquareCentimeter => As(HeatFluxUnit.CaloriePerSecondSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.CentiwattPerSquareMeter"/>
-        /// </summary>
-        public double CentiwattsPerSquareMeter => As(HeatFluxUnit.CentiwattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.DeciwattPerSquareMeter"/>
-        /// </summary>
-        public double DeciwattsPerSquareMeter => As(HeatFluxUnit.DeciwattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.KilocaloriePerHourSquareMeter"/>
-        /// </summary>
-        public double KilocaloriesPerHourSquareMeter => As(HeatFluxUnit.KilocaloriePerHourSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.KilocaloriePerSecondSquareCentimeter"/>
-        /// </summary>
-        public double KilocaloriesPerSecondSquareCentimeter => As(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.KilowattPerSquareMeter"/>
-        /// </summary>
-        public double KilowattsPerSquareMeter => As(HeatFluxUnit.KilowattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.MicrowattPerSquareMeter"/>
-        /// </summary>
-        public double MicrowattsPerSquareMeter => As(HeatFluxUnit.MicrowattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.MilliwattPerSquareMeter"/>
-        /// </summary>
-        public double MilliwattsPerSquareMeter => As(HeatFluxUnit.MilliwattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.NanowattPerSquareMeter"/>
-        /// </summary>
-        public double NanowattsPerSquareMeter => As(HeatFluxUnit.NanowattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.PoundForcePerFootSecond"/>
-        /// </summary>
-        public double PoundsForcePerFootSecond => As(HeatFluxUnit.PoundForcePerFootSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.PoundPerSecondCubed"/>
-        /// </summary>
-        public double PoundsPerSecondCubed => As(HeatFluxUnit.PoundPerSecondCubed);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.WattPerSquareFoot"/>
-        /// </summary>
-        public double WattsPerSquareFoot => As(HeatFluxUnit.WattPerSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.WattPerSquareInch"/>
-        /// </summary>
-        public double WattsPerSquareInch => As(HeatFluxUnit.WattPerSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.WattPerSquareMeter"/>
-        /// </summary>
-        public double WattsPerSquareMeter => As(HeatFluxUnit.WattPerSquareMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerHourSquareFoot"/>.
-        /// </summary>
-        public static HeatFlux FromBtusPerHourSquareFoot(double btusperhoursquarefoot) => new HeatFlux(btusperhoursquarefoot, HeatFluxUnit.BtuPerHourSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerMinuteSquareFoot"/>.
-        /// </summary>
-        public static HeatFlux FromBtusPerMinuteSquareFoot(double btusperminutesquarefoot) => new HeatFlux(btusperminutesquarefoot, HeatFluxUnit.BtuPerMinuteSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerSecondSquareFoot"/>.
-        /// </summary>
-        public static HeatFlux FromBtusPerSecondSquareFoot(double btuspersecondsquarefoot) => new HeatFlux(btuspersecondsquarefoot, HeatFluxUnit.BtuPerSecondSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerSecondSquareInch"/>.
-        /// </summary>
-        public static HeatFlux FromBtusPerSecondSquareInch(double btuspersecondsquareinch) => new HeatFlux(btuspersecondsquareinch, HeatFluxUnit.BtuPerSecondSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.CaloriePerSecondSquareCentimeter"/>.
-        /// </summary>
-        public static HeatFlux FromCaloriesPerSecondSquareCentimeter(double caloriespersecondsquarecentimeter) => new HeatFlux(caloriespersecondsquarecentimeter, HeatFluxUnit.CaloriePerSecondSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.CentiwattPerSquareMeter"/>.
-        /// </summary>
-        public static HeatFlux FromCentiwattsPerSquareMeter(double centiwattspersquaremeter) => new HeatFlux(centiwattspersquaremeter, HeatFluxUnit.CentiwattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.DeciwattPerSquareMeter"/>.
-        /// </summary>
-        public static HeatFlux FromDeciwattsPerSquareMeter(double deciwattspersquaremeter) => new HeatFlux(deciwattspersquaremeter, HeatFluxUnit.DeciwattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilocaloriePerHourSquareMeter"/>.
-        /// </summary>
-        public static HeatFlux FromKilocaloriesPerHourSquareMeter(double kilocaloriesperhoursquaremeter) => new HeatFlux(kilocaloriesperhoursquaremeter, HeatFluxUnit.KilocaloriePerHourSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilocaloriePerSecondSquareCentimeter"/>.
-        /// </summary>
-        public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(double kilocaloriespersecondsquarecentimeter) => new HeatFlux(kilocaloriespersecondsquarecentimeter, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilowattPerSquareMeter"/>.
-        /// </summary>
-        public static HeatFlux FromKilowattsPerSquareMeter(double kilowattspersquaremeter) => new HeatFlux(kilowattspersquaremeter, HeatFluxUnit.KilowattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.MicrowattPerSquareMeter"/>.
-        /// </summary>
-        public static HeatFlux FromMicrowattsPerSquareMeter(double microwattspersquaremeter) => new HeatFlux(microwattspersquaremeter, HeatFluxUnit.MicrowattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.MilliwattPerSquareMeter"/>.
-        /// </summary>
-        public static HeatFlux FromMilliwattsPerSquareMeter(double milliwattspersquaremeter) => new HeatFlux(milliwattspersquaremeter, HeatFluxUnit.MilliwattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.NanowattPerSquareMeter"/>.
-        /// </summary>
-        public static HeatFlux FromNanowattsPerSquareMeter(double nanowattspersquaremeter) => new HeatFlux(nanowattspersquaremeter, HeatFluxUnit.NanowattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.PoundForcePerFootSecond"/>.
-        /// </summary>
-        public static HeatFlux FromPoundsForcePerFootSecond(double poundsforceperfootsecond) => new HeatFlux(poundsforceperfootsecond, HeatFluxUnit.PoundForcePerFootSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.PoundPerSecondCubed"/>.
-        /// </summary>
-        public static HeatFlux FromPoundsPerSecondCubed(double poundspersecondcubed) => new HeatFlux(poundspersecondcubed, HeatFluxUnit.PoundPerSecondCubed);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareFoot"/>.
-        /// </summary>
-        public static HeatFlux FromWattsPerSquareFoot(double wattspersquarefoot) => new HeatFlux(wattspersquarefoot, HeatFluxUnit.WattPerSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareInch"/>.
-        /// </summary>
-        public static HeatFlux FromWattsPerSquareInch(double wattspersquareinch) => new HeatFlux(wattspersquareinch, HeatFluxUnit.WattPerSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareMeter"/>.
-        /// </summary>
-        public static HeatFlux FromWattsPerSquareMeter(double wattspersquaremeter) => new HeatFlux(wattspersquaremeter, HeatFluxUnit.WattPerSquareMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="HeatFluxUnit" /> to <see cref="HeatFlux" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>HeatFlux unit value.</returns>
-        public static HeatFlux From(double value, HeatFluxUnit fromUnit)
-        {
-            return new HeatFlux(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(HeatFluxUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this HeatFlux to another HeatFlux with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A HeatFlux with the specified unit.</returns>
-                public HeatFlux ToUnit(HeatFluxUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new HeatFlux(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        HeatFluxUnit.BtuPerHourSquareFoot => _value * 1055.05585262 / (0.3048 * 0.3048 * 3600),
-                        HeatFluxUnit.BtuPerMinuteSquareFoot => _value * 1055.05585262 / (0.3048 * 0.3048 * 60),
-                        HeatFluxUnit.BtuPerSecondSquareFoot => _value * 1055.05585262 / (0.3048 * 0.3048),
-                        HeatFluxUnit.BtuPerSecondSquareInch => _value * 1055.05585262 / (2.54e-2 * 2.54e-2),
-                        HeatFluxUnit.CaloriePerSecondSquareCentimeter => _value * 4.184e4,
-                        HeatFluxUnit.CentiwattPerSquareMeter => (_value) * 1e-2d,
-                        HeatFluxUnit.DeciwattPerSquareMeter => (_value) * 1e-1d,
-                        HeatFluxUnit.KilocaloriePerHourSquareMeter => _value * 4.184e3 / 3600,
-                        HeatFluxUnit.KilocaloriePerSecondSquareCentimeter => (_value * 4.184e4) * 1e3d,
-                        HeatFluxUnit.KilowattPerSquareMeter => (_value) * 1e3d,
-                        HeatFluxUnit.MicrowattPerSquareMeter => (_value) * 1e-6d,
-                        HeatFluxUnit.MilliwattPerSquareMeter => (_value) * 1e-3d,
-                        HeatFluxUnit.NanowattPerSquareMeter => (_value) * 1e-9d,
-                        HeatFluxUnit.PoundForcePerFootSecond => _value * 1.3558179483314004 / 9.290304e-2,
-                        HeatFluxUnit.PoundPerSecondCubed => _value * 4.5359237e-1,
-                        HeatFluxUnit.WattPerSquareFoot => _value / (0.3048 * 0.3048),
-                        HeatFluxUnit.WattPerSquareInch => _value / (2.54e-2 * 2.54e-2),
-                        HeatFluxUnit.WattPerSquareMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(HeatFluxUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        HeatFluxUnit.BtuPerHourSquareFoot => baseUnitValue * (0.3048 * 0.3048 * 3600) / 1055.05585262,
-                        HeatFluxUnit.BtuPerMinuteSquareFoot => baseUnitValue * (0.3048 * 0.3048 * 60) / 1055.05585262,
-                        HeatFluxUnit.BtuPerSecondSquareFoot => baseUnitValue * (0.3048 * 0.3048) / 1055.05585262,
-                        HeatFluxUnit.BtuPerSecondSquareInch => baseUnitValue * (2.54e-2 * 2.54e-2) / 1055.05585262,
-                        HeatFluxUnit.CaloriePerSecondSquareCentimeter => baseUnitValue / 4.184e4,
-                        HeatFluxUnit.CentiwattPerSquareMeter => (baseUnitValue) / 1e-2d,
-                        HeatFluxUnit.DeciwattPerSquareMeter => (baseUnitValue) / 1e-1d,
-                        HeatFluxUnit.KilocaloriePerHourSquareMeter => baseUnitValue * 3600 / 4.184e3,
-                        HeatFluxUnit.KilocaloriePerSecondSquareCentimeter => (baseUnitValue / 4.184e4) / 1e3d,
-                        HeatFluxUnit.KilowattPerSquareMeter => (baseUnitValue) / 1e3d,
-                        HeatFluxUnit.MicrowattPerSquareMeter => (baseUnitValue) / 1e-6d,
-                        HeatFluxUnit.MilliwattPerSquareMeter => (baseUnitValue) / 1e-3d,
-                        HeatFluxUnit.NanowattPerSquareMeter => (baseUnitValue) / 1e-9d,
-                        HeatFluxUnit.PoundForcePerFootSecond => baseUnitValue * 9.290304e-2 / 1.3558179483314004,
-                        HeatFluxUnit.PoundPerSecondCubed => baseUnitValue / 4.5359237e-1,
-                        HeatFluxUnit.WattPerSquareFoot => baseUnitValue * (0.3048 * 0.3048),
-                        HeatFluxUnit.WattPerSquareInch => baseUnitValue * (2.54e-2 * 2.54e-2),
-                        HeatFluxUnit.WattPerSquareMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
deleted file mode 100644
index 274c8b4cec..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
+++ /dev/null
@@ -1,205 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The heat transfer coefficient or film coefficient, or film effectiveness, in thermodynamics and in mechanics is the proportionality constant between the heat flux and the thermodynamic driving force for the flow of heat (i.e., the temperature difference, ΔT)
-    /// </summary>
-    public struct  HeatTransferCoefficient
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly HeatTransferCoefficientUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public HeatTransferCoefficientUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public HeatTransferCoefficient(double value, HeatTransferCoefficientUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of HeatTransferCoefficient, which is Second. All conversions go via this value.
-        /// </summary>
-        public static HeatTransferCoefficientUnit BaseUnit { get; } = HeatTransferCoefficientUnit.WattPerSquareMeterKelvin;
-
-        /// <summary>
-        /// Represents the largest possible value of HeatTransferCoefficient.
-        /// </summary>
-        public static HeatTransferCoefficient MaxValue { get; } = new HeatTransferCoefficient(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of HeatTransferCoefficient.
-        /// </summary>
-        public static HeatTransferCoefficient MinValue { get; } = new HeatTransferCoefficient(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static HeatTransferCoefficient Zero { get; } = new HeatTransferCoefficient(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit"/>
-        /// </summary>
-        public double BtusPerHourSquareFootDegreeFahrenheit => As(HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius"/>
-        /// </summary>
-        public double CaloriesPerHourSquareMeterDegreeCelsius => As(HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius"/>
-        /// </summary>
-        public double KilocaloriesPerHourSquareMeterDegreeCelsius => As(HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterCelsius"/>
-        /// </summary>
-        public double WattsPerSquareMeterCelsius => As(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterKelvin"/>
-        /// </summary>
-        public double WattsPerSquareMeterKelvin => As(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit"/>.
-        /// </summary>
-        public static HeatTransferCoefficient FromBtusPerHourSquareFootDegreeFahrenheit(double btusperhoursquarefootdegreefahrenheit) => new HeatTransferCoefficient(btusperhoursquarefootdegreefahrenheit, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius"/>.
-        /// </summary>
-        public static HeatTransferCoefficient FromCaloriesPerHourSquareMeterDegreeCelsius(double caloriesperhoursquaremeterdegreecelsius) => new HeatTransferCoefficient(caloriesperhoursquaremeterdegreecelsius, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius"/>.
-        /// </summary>
-        public static HeatTransferCoefficient FromKilocaloriesPerHourSquareMeterDegreeCelsius(double kilocaloriesperhoursquaremeterdegreecelsius) => new HeatTransferCoefficient(kilocaloriesperhoursquaremeterdegreecelsius, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterCelsius"/>.
-        /// </summary>
-        public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(double wattspersquaremetercelsius) => new HeatTransferCoefficient(wattspersquaremetercelsius, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterKelvin"/>.
-        /// </summary>
-        public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(double wattspersquaremeterkelvin) => new HeatTransferCoefficient(wattspersquaremeterkelvin, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="HeatTransferCoefficientUnit" /> to <see cref="HeatTransferCoefficient" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>HeatTransferCoefficient unit value.</returns>
-        public static HeatTransferCoefficient From(double value, HeatTransferCoefficientUnit fromUnit)
-        {
-            return new HeatTransferCoefficient(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(HeatTransferCoefficientUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this HeatTransferCoefficient to another HeatTransferCoefficient with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A HeatTransferCoefficient with the specified unit.</returns>
-                public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new HeatTransferCoefficient(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit => _value * ((1055.05585262 / (0.3048 * 0.3048 * 3600)) * 1.8),
-                        HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius => (_value * 4.184) / 3600,
-                        HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius => ((_value * 4.184) / 3600) * 1e3d,
-                        HeatTransferCoefficientUnit.WattPerSquareMeterCelsius => _value,
-                        HeatTransferCoefficientUnit.WattPerSquareMeterKelvin => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(HeatTransferCoefficientUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit => baseUnitValue / ((1055.05585262 / (0.3048 * 0.3048 * 3600)) * 1.8),
-                        HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius => (baseUnitValue / 4.184) * 3600,
-                        HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius => ((baseUnitValue / 4.184) * 3600) / 1e3d,
-                        HeatTransferCoefficientUnit.WattPerSquareMeterCelsius => baseUnitValue,
-                        HeatTransferCoefficientUnit.WattPerSquareMeterKelvin => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Illuminance.g.cs
deleted file mode 100644
index 6fda4ca9d3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Illuminance.g.cs
+++ /dev/null
@@ -1,196 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In photometry, illuminance is the total luminous flux incident on a surface, per unit area.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Illuminance
-    /// </remarks>
-    public struct  Illuminance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly IlluminanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public IlluminanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Illuminance(double value, IlluminanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Illuminance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static IlluminanceUnit BaseUnit { get; } = IlluminanceUnit.Lux;
-
-        /// <summary>
-        /// Represents the largest possible value of Illuminance.
-        /// </summary>
-        public static Illuminance MaxValue { get; } = new Illuminance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Illuminance.
-        /// </summary>
-        public static Illuminance MinValue { get; } = new Illuminance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Illuminance Zero { get; } = new Illuminance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IlluminanceUnit.Kilolux"/>
-        /// </summary>
-        public double Kilolux => As(IlluminanceUnit.Kilolux);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IlluminanceUnit.Lux"/>
-        /// </summary>
-        public double Lux => As(IlluminanceUnit.Lux);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IlluminanceUnit.Megalux"/>
-        /// </summary>
-        public double Megalux => As(IlluminanceUnit.Megalux);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IlluminanceUnit.Millilux"/>
-        /// </summary>
-        public double Millilux => As(IlluminanceUnit.Millilux);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Kilolux"/>.
-        /// </summary>
-        public static Illuminance FromKilolux(double kilolux) => new Illuminance(kilolux, IlluminanceUnit.Kilolux);
-
-        /// <summary>
-        ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Lux"/>.
-        /// </summary>
-        public static Illuminance FromLux(double lux) => new Illuminance(lux, IlluminanceUnit.Lux);
-
-        /// <summary>
-        ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Megalux"/>.
-        /// </summary>
-        public static Illuminance FromMegalux(double megalux) => new Illuminance(megalux, IlluminanceUnit.Megalux);
-
-        /// <summary>
-        ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Millilux"/>.
-        /// </summary>
-        public static Illuminance FromMillilux(double millilux) => new Illuminance(millilux, IlluminanceUnit.Millilux);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="IlluminanceUnit" /> to <see cref="Illuminance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Illuminance unit value.</returns>
-        public static Illuminance From(double value, IlluminanceUnit fromUnit)
-        {
-            return new Illuminance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(IlluminanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Illuminance to another Illuminance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Illuminance with the specified unit.</returns>
-                public Illuminance ToUnit(IlluminanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Illuminance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        IlluminanceUnit.Kilolux => (_value) * 1e3d,
-                        IlluminanceUnit.Lux => _value,
-                        IlluminanceUnit.Megalux => (_value) * 1e6d,
-                        IlluminanceUnit.Millilux => (_value) * 1e-3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(IlluminanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        IlluminanceUnit.Kilolux => (baseUnitValue) / 1e3d,
-                        IlluminanceUnit.Lux => baseUnitValue,
-                        IlluminanceUnit.Megalux => (baseUnitValue) / 1e6d,
-                        IlluminanceUnit.Millilux => (baseUnitValue) / 1e-3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Impulse.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Impulse.g.cs
deleted file mode 100644
index 00b105ccb6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Impulse.g.cs
+++ /dev/null
@@ -1,301 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In classical mechanics, impulse is the integral of a force, F, over the time interval, t, for which it acts. Impulse applied to an object produces an equivalent vector change in its linear momentum, also in the resultant direction.
-    /// </summary>
-    public struct  Impulse
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ImpulseUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ImpulseUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Impulse(double value, ImpulseUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Impulse, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ImpulseUnit BaseUnit { get; } = ImpulseUnit.NewtonSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of Impulse.
-        /// </summary>
-        public static Impulse MaxValue { get; } = new Impulse(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Impulse.
-        /// </summary>
-        public static Impulse MinValue { get; } = new Impulse(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Impulse Zero { get; } = new Impulse(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.CentinewtonSecond"/>
-        /// </summary>
-        public double CentinewtonSeconds => As(ImpulseUnit.CentinewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.DecanewtonSecond"/>
-        /// </summary>
-        public double DecanewtonSeconds => As(ImpulseUnit.DecanewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.DecinewtonSecond"/>
-        /// </summary>
-        public double DecinewtonSeconds => As(ImpulseUnit.DecinewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.KilogramMeterPerSecond"/>
-        /// </summary>
-        public double KilogramMetersPerSecond => As(ImpulseUnit.KilogramMeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.KilonewtonSecond"/>
-        /// </summary>
-        public double KilonewtonSeconds => As(ImpulseUnit.KilonewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.MeganewtonSecond"/>
-        /// </summary>
-        public double MeganewtonSeconds => As(ImpulseUnit.MeganewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.MicronewtonSecond"/>
-        /// </summary>
-        public double MicronewtonSeconds => As(ImpulseUnit.MicronewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.MillinewtonSecond"/>
-        /// </summary>
-        public double MillinewtonSeconds => As(ImpulseUnit.MillinewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.NanonewtonSecond"/>
-        /// </summary>
-        public double NanonewtonSeconds => As(ImpulseUnit.NanonewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.NewtonSecond"/>
-        /// </summary>
-        public double NewtonSeconds => As(ImpulseUnit.NewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.PoundFootPerSecond"/>
-        /// </summary>
-        public double PoundFeetPerSecond => As(ImpulseUnit.PoundFootPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.PoundForceSecond"/>
-        /// </summary>
-        public double PoundForceSeconds => As(ImpulseUnit.PoundForceSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.SlugFootPerSecond"/>
-        /// </summary>
-        public double SlugFeetPerSecond => As(ImpulseUnit.SlugFootPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.CentinewtonSecond"/>.
-        /// </summary>
-        public static Impulse FromCentinewtonSeconds(double centinewtonseconds) => new Impulse(centinewtonseconds, ImpulseUnit.CentinewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.DecanewtonSecond"/>.
-        /// </summary>
-        public static Impulse FromDecanewtonSeconds(double decanewtonseconds) => new Impulse(decanewtonseconds, ImpulseUnit.DecanewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.DecinewtonSecond"/>.
-        /// </summary>
-        public static Impulse FromDecinewtonSeconds(double decinewtonseconds) => new Impulse(decinewtonseconds, ImpulseUnit.DecinewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.KilogramMeterPerSecond"/>.
-        /// </summary>
-        public static Impulse FromKilogramMetersPerSecond(double kilogrammeterspersecond) => new Impulse(kilogrammeterspersecond, ImpulseUnit.KilogramMeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.KilonewtonSecond"/>.
-        /// </summary>
-        public static Impulse FromKilonewtonSeconds(double kilonewtonseconds) => new Impulse(kilonewtonseconds, ImpulseUnit.KilonewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MeganewtonSecond"/>.
-        /// </summary>
-        public static Impulse FromMeganewtonSeconds(double meganewtonseconds) => new Impulse(meganewtonseconds, ImpulseUnit.MeganewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MicronewtonSecond"/>.
-        /// </summary>
-        public static Impulse FromMicronewtonSeconds(double micronewtonseconds) => new Impulse(micronewtonseconds, ImpulseUnit.MicronewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MillinewtonSecond"/>.
-        /// </summary>
-        public static Impulse FromMillinewtonSeconds(double millinewtonseconds) => new Impulse(millinewtonseconds, ImpulseUnit.MillinewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.NanonewtonSecond"/>.
-        /// </summary>
-        public static Impulse FromNanonewtonSeconds(double nanonewtonseconds) => new Impulse(nanonewtonseconds, ImpulseUnit.NanonewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.NewtonSecond"/>.
-        /// </summary>
-        public static Impulse FromNewtonSeconds(double newtonseconds) => new Impulse(newtonseconds, ImpulseUnit.NewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.PoundFootPerSecond"/>.
-        /// </summary>
-        public static Impulse FromPoundFeetPerSecond(double poundfeetpersecond) => new Impulse(poundfeetpersecond, ImpulseUnit.PoundFootPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.PoundForceSecond"/>.
-        /// </summary>
-        public static Impulse FromPoundForceSeconds(double poundforceseconds) => new Impulse(poundforceseconds, ImpulseUnit.PoundForceSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.SlugFootPerSecond"/>.
-        /// </summary>
-        public static Impulse FromSlugFeetPerSecond(double slugfeetpersecond) => new Impulse(slugfeetpersecond, ImpulseUnit.SlugFootPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ImpulseUnit" /> to <see cref="Impulse" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Impulse unit value.</returns>
-        public static Impulse From(double value, ImpulseUnit fromUnit)
-        {
-            return new Impulse(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ImpulseUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Impulse to another Impulse with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Impulse with the specified unit.</returns>
-                public Impulse ToUnit(ImpulseUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Impulse(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ImpulseUnit.CentinewtonSecond => (_value) * 1e-2d,
-                        ImpulseUnit.DecanewtonSecond => (_value) * 1e1d,
-                        ImpulseUnit.DecinewtonSecond => (_value) * 1e-1d,
-                        ImpulseUnit.KilogramMeterPerSecond => _value,
-                        ImpulseUnit.KilonewtonSecond => (_value) * 1e3d,
-                        ImpulseUnit.MeganewtonSecond => (_value) * 1e6d,
-                        ImpulseUnit.MicronewtonSecond => (_value) * 1e-6d,
-                        ImpulseUnit.MillinewtonSecond => (_value) * 1e-3d,
-                        ImpulseUnit.NanonewtonSecond => (_value) * 1e-9d,
-                        ImpulseUnit.NewtonSecond => _value,
-                        ImpulseUnit.PoundFootPerSecond => _value * (0.45359237 * 0.3048),
-                        ImpulseUnit.PoundForceSecond => _value * 0.45359237 * 9.80665,
-                        ImpulseUnit.SlugFootPerSecond => _value * (0.45359237 * 9.80665),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ImpulseUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ImpulseUnit.CentinewtonSecond => (baseUnitValue) / 1e-2d,
-                        ImpulseUnit.DecanewtonSecond => (baseUnitValue) / 1e1d,
-                        ImpulseUnit.DecinewtonSecond => (baseUnitValue) / 1e-1d,
-                        ImpulseUnit.KilogramMeterPerSecond => baseUnitValue,
-                        ImpulseUnit.KilonewtonSecond => (baseUnitValue) / 1e3d,
-                        ImpulseUnit.MeganewtonSecond => (baseUnitValue) / 1e6d,
-                        ImpulseUnit.MicronewtonSecond => (baseUnitValue) / 1e-6d,
-                        ImpulseUnit.MillinewtonSecond => (baseUnitValue) / 1e-3d,
-                        ImpulseUnit.NanonewtonSecond => (baseUnitValue) / 1e-9d,
-                        ImpulseUnit.NewtonSecond => baseUnitValue,
-                        ImpulseUnit.PoundFootPerSecond => baseUnitValue / (0.45359237 * 0.3048),
-                        ImpulseUnit.PoundForceSecond => baseUnitValue / (0.45359237 * 9.80665),
-                        ImpulseUnit.SlugFootPerSecond => baseUnitValue / (0.45359237 * 9.80665),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Information.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Information.g.cs
deleted file mode 100644
index e40569f9e4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Information.g.cs
+++ /dev/null
@@ -1,613 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In computing and telecommunications, a unit of information is the capacity of some standard data storage system or communication channel, used to measure the capacities of other systems and channels. In information theory, units of information are also used to measure the information contents or entropy of random variables.
-    /// </summary>
-    public struct  Information
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly InformationUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public InformationUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Information(double value, InformationUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Information, which is Second. All conversions go via this value.
-        /// </summary>
-        public static InformationUnit BaseUnit { get; } = InformationUnit.Bit;
-
-        /// <summary>
-        /// Represents the largest possible value of Information.
-        /// </summary>
-        public static Information MaxValue { get; } = new Information(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Information.
-        /// </summary>
-        public static Information MinValue { get; } = new Information(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Information Zero { get; } = new Information(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Bit"/>
-        /// </summary>
-        public double Bits => As(InformationUnit.Bit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Byte"/>
-        /// </summary>
-        public double Bytes => As(InformationUnit.Byte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exabit"/>
-        /// </summary>
-        public double Exabits => As(InformationUnit.Exabit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exabyte"/>
-        /// </summary>
-        public double Exabytes => As(InformationUnit.Exabyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exaoctet"/>
-        /// </summary>
-        public double Exaoctets => As(InformationUnit.Exaoctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exbibit"/>
-        /// </summary>
-        public double Exbibits => As(InformationUnit.Exbibit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exbibyte"/>
-        /// </summary>
-        public double Exbibytes => As(InformationUnit.Exbibyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exbioctet"/>
-        /// </summary>
-        public double Exbioctets => As(InformationUnit.Exbioctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gibibit"/>
-        /// </summary>
-        public double Gibibits => As(InformationUnit.Gibibit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gibibyte"/>
-        /// </summary>
-        public double Gibibytes => As(InformationUnit.Gibibyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gibioctet"/>
-        /// </summary>
-        public double Gibioctets => As(InformationUnit.Gibioctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gigabit"/>
-        /// </summary>
-        public double Gigabits => As(InformationUnit.Gigabit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gigabyte"/>
-        /// </summary>
-        public double Gigabytes => As(InformationUnit.Gigabyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gigaoctet"/>
-        /// </summary>
-        public double Gigaoctets => As(InformationUnit.Gigaoctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kibibit"/>
-        /// </summary>
-        public double Kibibits => As(InformationUnit.Kibibit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kibibyte"/>
-        /// </summary>
-        public double Kibibytes => As(InformationUnit.Kibibyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kibioctet"/>
-        /// </summary>
-        public double Kibioctets => As(InformationUnit.Kibioctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kilobit"/>
-        /// </summary>
-        public double Kilobits => As(InformationUnit.Kilobit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kilobyte"/>
-        /// </summary>
-        public double Kilobytes => As(InformationUnit.Kilobyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kilooctet"/>
-        /// </summary>
-        public double Kilooctets => As(InformationUnit.Kilooctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Mebibit"/>
-        /// </summary>
-        public double Mebibits => As(InformationUnit.Mebibit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Mebibyte"/>
-        /// </summary>
-        public double Mebibytes => As(InformationUnit.Mebibyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Mebioctet"/>
-        /// </summary>
-        public double Mebioctets => As(InformationUnit.Mebioctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Megabit"/>
-        /// </summary>
-        public double Megabits => As(InformationUnit.Megabit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Megabyte"/>
-        /// </summary>
-        public double Megabytes => As(InformationUnit.Megabyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Megaoctet"/>
-        /// </summary>
-        public double Megaoctets => As(InformationUnit.Megaoctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Octet"/>
-        /// </summary>
-        public double Octets => As(InformationUnit.Octet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Pebibit"/>
-        /// </summary>
-        public double Pebibits => As(InformationUnit.Pebibit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Pebibyte"/>
-        /// </summary>
-        public double Pebibytes => As(InformationUnit.Pebibyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Pebioctet"/>
-        /// </summary>
-        public double Pebioctets => As(InformationUnit.Pebioctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Petabit"/>
-        /// </summary>
-        public double Petabits => As(InformationUnit.Petabit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Petabyte"/>
-        /// </summary>
-        public double Petabytes => As(InformationUnit.Petabyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Petaoctet"/>
-        /// </summary>
-        public double Petaoctets => As(InformationUnit.Petaoctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Tebibit"/>
-        /// </summary>
-        public double Tebibits => As(InformationUnit.Tebibit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Tebibyte"/>
-        /// </summary>
-        public double Tebibytes => As(InformationUnit.Tebibyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Tebioctet"/>
-        /// </summary>
-        public double Tebioctets => As(InformationUnit.Tebioctet);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Terabit"/>
-        /// </summary>
-        public double Terabits => As(InformationUnit.Terabit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Terabyte"/>
-        /// </summary>
-        public double Terabytes => As(InformationUnit.Terabyte);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Teraoctet"/>
-        /// </summary>
-        public double Teraoctets => As(InformationUnit.Teraoctet);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Bit"/>.
-        /// </summary>
-        public static Information FromBits(double bits) => new Information(bits, InformationUnit.Bit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Byte"/>.
-        /// </summary>
-        public static Information FromBytes(double bytes) => new Information(bytes, InformationUnit.Byte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exabit"/>.
-        /// </summary>
-        public static Information FromExabits(double exabits) => new Information(exabits, InformationUnit.Exabit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exabyte"/>.
-        /// </summary>
-        public static Information FromExabytes(double exabytes) => new Information(exabytes, InformationUnit.Exabyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exaoctet"/>.
-        /// </summary>
-        public static Information FromExaoctets(double exaoctets) => new Information(exaoctets, InformationUnit.Exaoctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exbibit"/>.
-        /// </summary>
-        public static Information FromExbibits(double exbibits) => new Information(exbibits, InformationUnit.Exbibit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exbibyte"/>.
-        /// </summary>
-        public static Information FromExbibytes(double exbibytes) => new Information(exbibytes, InformationUnit.Exbibyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exbioctet"/>.
-        /// </summary>
-        public static Information FromExbioctets(double exbioctets) => new Information(exbioctets, InformationUnit.Exbioctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gibibit"/>.
-        /// </summary>
-        public static Information FromGibibits(double gibibits) => new Information(gibibits, InformationUnit.Gibibit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gibibyte"/>.
-        /// </summary>
-        public static Information FromGibibytes(double gibibytes) => new Information(gibibytes, InformationUnit.Gibibyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gibioctet"/>.
-        /// </summary>
-        public static Information FromGibioctets(double gibioctets) => new Information(gibioctets, InformationUnit.Gibioctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gigabit"/>.
-        /// </summary>
-        public static Information FromGigabits(double gigabits) => new Information(gigabits, InformationUnit.Gigabit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gigabyte"/>.
-        /// </summary>
-        public static Information FromGigabytes(double gigabytes) => new Information(gigabytes, InformationUnit.Gigabyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gigaoctet"/>.
-        /// </summary>
-        public static Information FromGigaoctets(double gigaoctets) => new Information(gigaoctets, InformationUnit.Gigaoctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kibibit"/>.
-        /// </summary>
-        public static Information FromKibibits(double kibibits) => new Information(kibibits, InformationUnit.Kibibit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kibibyte"/>.
-        /// </summary>
-        public static Information FromKibibytes(double kibibytes) => new Information(kibibytes, InformationUnit.Kibibyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kibioctet"/>.
-        /// </summary>
-        public static Information FromKibioctets(double kibioctets) => new Information(kibioctets, InformationUnit.Kibioctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kilobit"/>.
-        /// </summary>
-        public static Information FromKilobits(double kilobits) => new Information(kilobits, InformationUnit.Kilobit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kilobyte"/>.
-        /// </summary>
-        public static Information FromKilobytes(double kilobytes) => new Information(kilobytes, InformationUnit.Kilobyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kilooctet"/>.
-        /// </summary>
-        public static Information FromKilooctets(double kilooctets) => new Information(kilooctets, InformationUnit.Kilooctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Mebibit"/>.
-        /// </summary>
-        public static Information FromMebibits(double mebibits) => new Information(mebibits, InformationUnit.Mebibit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Mebibyte"/>.
-        /// </summary>
-        public static Information FromMebibytes(double mebibytes) => new Information(mebibytes, InformationUnit.Mebibyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Mebioctet"/>.
-        /// </summary>
-        public static Information FromMebioctets(double mebioctets) => new Information(mebioctets, InformationUnit.Mebioctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Megabit"/>.
-        /// </summary>
-        public static Information FromMegabits(double megabits) => new Information(megabits, InformationUnit.Megabit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Megabyte"/>.
-        /// </summary>
-        public static Information FromMegabytes(double megabytes) => new Information(megabytes, InformationUnit.Megabyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Megaoctet"/>.
-        /// </summary>
-        public static Information FromMegaoctets(double megaoctets) => new Information(megaoctets, InformationUnit.Megaoctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Octet"/>.
-        /// </summary>
-        public static Information FromOctets(double octets) => new Information(octets, InformationUnit.Octet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Pebibit"/>.
-        /// </summary>
-        public static Information FromPebibits(double pebibits) => new Information(pebibits, InformationUnit.Pebibit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Pebibyte"/>.
-        /// </summary>
-        public static Information FromPebibytes(double pebibytes) => new Information(pebibytes, InformationUnit.Pebibyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Pebioctet"/>.
-        /// </summary>
-        public static Information FromPebioctets(double pebioctets) => new Information(pebioctets, InformationUnit.Pebioctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Petabit"/>.
-        /// </summary>
-        public static Information FromPetabits(double petabits) => new Information(petabits, InformationUnit.Petabit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Petabyte"/>.
-        /// </summary>
-        public static Information FromPetabytes(double petabytes) => new Information(petabytes, InformationUnit.Petabyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Petaoctet"/>.
-        /// </summary>
-        public static Information FromPetaoctets(double petaoctets) => new Information(petaoctets, InformationUnit.Petaoctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Tebibit"/>.
-        /// </summary>
-        public static Information FromTebibits(double tebibits) => new Information(tebibits, InformationUnit.Tebibit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Tebibyte"/>.
-        /// </summary>
-        public static Information FromTebibytes(double tebibytes) => new Information(tebibytes, InformationUnit.Tebibyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Tebioctet"/>.
-        /// </summary>
-        public static Information FromTebioctets(double tebioctets) => new Information(tebioctets, InformationUnit.Tebioctet);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Terabit"/>.
-        /// </summary>
-        public static Information FromTerabits(double terabits) => new Information(terabits, InformationUnit.Terabit);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Terabyte"/>.
-        /// </summary>
-        public static Information FromTerabytes(double terabytes) => new Information(terabytes, InformationUnit.Terabyte);
-
-        /// <summary>
-        ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Teraoctet"/>.
-        /// </summary>
-        public static Information FromTeraoctets(double teraoctets) => new Information(teraoctets, InformationUnit.Teraoctet);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="InformationUnit" /> to <see cref="Information" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Information unit value.</returns>
-        public static Information From(double value, InformationUnit fromUnit)
-        {
-            return new Information(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(InformationUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Information to another Information with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Information with the specified unit.</returns>
-                public Information ToUnit(InformationUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Information(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        InformationUnit.Bit => _value,
-                        InformationUnit.Byte => _value * 8,
-                        InformationUnit.Exabit => (_value) * 1e18d,
-                        InformationUnit.Exabyte => (_value * 8) * 1e18d,
-                        InformationUnit.Exaoctet => (_value * 8) * 1e18d,
-                        InformationUnit.Exbibit => (_value) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Exbibyte => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Exbioctet => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Gibibit => (_value) * (1024d * 1024 * 1024),
-                        InformationUnit.Gibibyte => (_value * 8) * (1024d * 1024 * 1024),
-                        InformationUnit.Gibioctet => (_value * 8) * (1024d * 1024 * 1024),
-                        InformationUnit.Gigabit => (_value) * 1e9d,
-                        InformationUnit.Gigabyte => (_value * 8) * 1e9d,
-                        InformationUnit.Gigaoctet => (_value * 8) * 1e9d,
-                        InformationUnit.Kibibit => (_value) * 1024d,
-                        InformationUnit.Kibibyte => (_value * 8) * 1024d,
-                        InformationUnit.Kibioctet => (_value * 8) * 1024d,
-                        InformationUnit.Kilobit => (_value) * 1e3d,
-                        InformationUnit.Kilobyte => (_value * 8) * 1e3d,
-                        InformationUnit.Kilooctet => (_value * 8) * 1e3d,
-                        InformationUnit.Mebibit => (_value) * (1024d * 1024),
-                        InformationUnit.Mebibyte => (_value * 8) * (1024d * 1024),
-                        InformationUnit.Mebioctet => (_value * 8) * (1024d * 1024),
-                        InformationUnit.Megabit => (_value) * 1e6d,
-                        InformationUnit.Megabyte => (_value * 8) * 1e6d,
-                        InformationUnit.Megaoctet => (_value * 8) * 1e6d,
-                        InformationUnit.Octet => _value * 8,
-                        InformationUnit.Pebibit => (_value) * (1024d * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Pebibyte => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Pebioctet => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Petabit => (_value) * 1e15d,
-                        InformationUnit.Petabyte => (_value * 8) * 1e15d,
-                        InformationUnit.Petaoctet => (_value * 8) * 1e15d,
-                        InformationUnit.Tebibit => (_value) * (1024d * 1024 * 1024 * 1024),
-                        InformationUnit.Tebibyte => (_value * 8) * (1024d * 1024 * 1024 * 1024),
-                        InformationUnit.Tebioctet => (_value * 8) * (1024d * 1024 * 1024 * 1024),
-                        InformationUnit.Terabit => (_value) * 1e12d,
-                        InformationUnit.Terabyte => (_value * 8) * 1e12d,
-                        InformationUnit.Teraoctet => (_value * 8) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(InformationUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        InformationUnit.Bit => baseUnitValue,
-                        InformationUnit.Byte => baseUnitValue / 8,
-                        InformationUnit.Exabit => (baseUnitValue) / 1e18d,
-                        InformationUnit.Exabyte => (baseUnitValue / 8) / 1e18d,
-                        InformationUnit.Exaoctet => (baseUnitValue / 8) / 1e18d,
-                        InformationUnit.Exbibit => (baseUnitValue) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Exbibyte => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Exbioctet => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Gibibit => (baseUnitValue) / (1024d * 1024 * 1024),
-                        InformationUnit.Gibibyte => (baseUnitValue / 8) / (1024d * 1024 * 1024),
-                        InformationUnit.Gibioctet => (baseUnitValue / 8) / (1024d * 1024 * 1024),
-                        InformationUnit.Gigabit => (baseUnitValue) / 1e9d,
-                        InformationUnit.Gigabyte => (baseUnitValue / 8) / 1e9d,
-                        InformationUnit.Gigaoctet => (baseUnitValue / 8) / 1e9d,
-                        InformationUnit.Kibibit => (baseUnitValue) / 1024d,
-                        InformationUnit.Kibibyte => (baseUnitValue / 8) / 1024d,
-                        InformationUnit.Kibioctet => (baseUnitValue / 8) / 1024d,
-                        InformationUnit.Kilobit => (baseUnitValue) / 1e3d,
-                        InformationUnit.Kilobyte => (baseUnitValue / 8) / 1e3d,
-                        InformationUnit.Kilooctet => (baseUnitValue / 8) / 1e3d,
-                        InformationUnit.Mebibit => (baseUnitValue) / (1024d * 1024),
-                        InformationUnit.Mebibyte => (baseUnitValue / 8) / (1024d * 1024),
-                        InformationUnit.Mebioctet => (baseUnitValue / 8) / (1024d * 1024),
-                        InformationUnit.Megabit => (baseUnitValue) / 1e6d,
-                        InformationUnit.Megabyte => (baseUnitValue / 8) / 1e6d,
-                        InformationUnit.Megaoctet => (baseUnitValue / 8) / 1e6d,
-                        InformationUnit.Octet => baseUnitValue / 8,
-                        InformationUnit.Pebibit => (baseUnitValue) / (1024d * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Pebibyte => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Pebioctet => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024),
-                        InformationUnit.Petabit => (baseUnitValue) / 1e15d,
-                        InformationUnit.Petabyte => (baseUnitValue / 8) / 1e15d,
-                        InformationUnit.Petaoctet => (baseUnitValue / 8) / 1e15d,
-                        InformationUnit.Tebibit => (baseUnitValue) / (1024d * 1024 * 1024 * 1024),
-                        InformationUnit.Tebibyte => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024),
-                        InformationUnit.Tebioctet => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024),
-                        InformationUnit.Terabit => (baseUnitValue) / 1e12d,
-                        InformationUnit.Terabyte => (baseUnitValue / 8) / 1e12d,
-                        InformationUnit.Teraoctet => (baseUnitValue / 8) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Irradiance.g.cs
deleted file mode 100644
index 7675fb9f51..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Irradiance.g.cs
+++ /dev/null
@@ -1,313 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Irradiance is the intensity of ultraviolet (UV) or visible light incident on a surface.
-    /// </summary>
-    public struct  Irradiance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly IrradianceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public IrradianceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Irradiance(double value, IrradianceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Irradiance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static IrradianceUnit BaseUnit { get; } = IrradianceUnit.WattPerSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Irradiance.
-        /// </summary>
-        public static Irradiance MaxValue { get; } = new Irradiance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Irradiance.
-        /// </summary>
-        public static Irradiance MinValue { get; } = new Irradiance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Irradiance Zero { get; } = new Irradiance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.KilowattPerSquareCentimeter"/>
-        /// </summary>
-        public double KilowattsPerSquareCentimeter => As(IrradianceUnit.KilowattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.KilowattPerSquareMeter"/>
-        /// </summary>
-        public double KilowattsPerSquareMeter => As(IrradianceUnit.KilowattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MegawattPerSquareCentimeter"/>
-        /// </summary>
-        public double MegawattsPerSquareCentimeter => As(IrradianceUnit.MegawattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MegawattPerSquareMeter"/>
-        /// </summary>
-        public double MegawattsPerSquareMeter => As(IrradianceUnit.MegawattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MicrowattPerSquareCentimeter"/>
-        /// </summary>
-        public double MicrowattsPerSquareCentimeter => As(IrradianceUnit.MicrowattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MicrowattPerSquareMeter"/>
-        /// </summary>
-        public double MicrowattsPerSquareMeter => As(IrradianceUnit.MicrowattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MilliwattPerSquareCentimeter"/>
-        /// </summary>
-        public double MilliwattsPerSquareCentimeter => As(IrradianceUnit.MilliwattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MilliwattPerSquareMeter"/>
-        /// </summary>
-        public double MilliwattsPerSquareMeter => As(IrradianceUnit.MilliwattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.NanowattPerSquareCentimeter"/>
-        /// </summary>
-        public double NanowattsPerSquareCentimeter => As(IrradianceUnit.NanowattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.NanowattPerSquareMeter"/>
-        /// </summary>
-        public double NanowattsPerSquareMeter => As(IrradianceUnit.NanowattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.PicowattPerSquareCentimeter"/>
-        /// </summary>
-        public double PicowattsPerSquareCentimeter => As(IrradianceUnit.PicowattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.PicowattPerSquareMeter"/>
-        /// </summary>
-        public double PicowattsPerSquareMeter => As(IrradianceUnit.PicowattPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.WattPerSquareCentimeter"/>
-        /// </summary>
-        public double WattsPerSquareCentimeter => As(IrradianceUnit.WattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.WattPerSquareMeter"/>
-        /// </summary>
-        public double WattsPerSquareMeter => As(IrradianceUnit.WattPerSquareMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.KilowattPerSquareCentimeter"/>.
-        /// </summary>
-        public static Irradiance FromKilowattsPerSquareCentimeter(double kilowattspersquarecentimeter) => new Irradiance(kilowattspersquarecentimeter, IrradianceUnit.KilowattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.KilowattPerSquareMeter"/>.
-        /// </summary>
-        public static Irradiance FromKilowattsPerSquareMeter(double kilowattspersquaremeter) => new Irradiance(kilowattspersquaremeter, IrradianceUnit.KilowattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MegawattPerSquareCentimeter"/>.
-        /// </summary>
-        public static Irradiance FromMegawattsPerSquareCentimeter(double megawattspersquarecentimeter) => new Irradiance(megawattspersquarecentimeter, IrradianceUnit.MegawattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MegawattPerSquareMeter"/>.
-        /// </summary>
-        public static Irradiance FromMegawattsPerSquareMeter(double megawattspersquaremeter) => new Irradiance(megawattspersquaremeter, IrradianceUnit.MegawattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MicrowattPerSquareCentimeter"/>.
-        /// </summary>
-        public static Irradiance FromMicrowattsPerSquareCentimeter(double microwattspersquarecentimeter) => new Irradiance(microwattspersquarecentimeter, IrradianceUnit.MicrowattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MicrowattPerSquareMeter"/>.
-        /// </summary>
-        public static Irradiance FromMicrowattsPerSquareMeter(double microwattspersquaremeter) => new Irradiance(microwattspersquaremeter, IrradianceUnit.MicrowattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MilliwattPerSquareCentimeter"/>.
-        /// </summary>
-        public static Irradiance FromMilliwattsPerSquareCentimeter(double milliwattspersquarecentimeter) => new Irradiance(milliwattspersquarecentimeter, IrradianceUnit.MilliwattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MilliwattPerSquareMeter"/>.
-        /// </summary>
-        public static Irradiance FromMilliwattsPerSquareMeter(double milliwattspersquaremeter) => new Irradiance(milliwattspersquaremeter, IrradianceUnit.MilliwattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.NanowattPerSquareCentimeter"/>.
-        /// </summary>
-        public static Irradiance FromNanowattsPerSquareCentimeter(double nanowattspersquarecentimeter) => new Irradiance(nanowattspersquarecentimeter, IrradianceUnit.NanowattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.NanowattPerSquareMeter"/>.
-        /// </summary>
-        public static Irradiance FromNanowattsPerSquareMeter(double nanowattspersquaremeter) => new Irradiance(nanowattspersquaremeter, IrradianceUnit.NanowattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.PicowattPerSquareCentimeter"/>.
-        /// </summary>
-        public static Irradiance FromPicowattsPerSquareCentimeter(double picowattspersquarecentimeter) => new Irradiance(picowattspersquarecentimeter, IrradianceUnit.PicowattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.PicowattPerSquareMeter"/>.
-        /// </summary>
-        public static Irradiance FromPicowattsPerSquareMeter(double picowattspersquaremeter) => new Irradiance(picowattspersquaremeter, IrradianceUnit.PicowattPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.WattPerSquareCentimeter"/>.
-        /// </summary>
-        public static Irradiance FromWattsPerSquareCentimeter(double wattspersquarecentimeter) => new Irradiance(wattspersquarecentimeter, IrradianceUnit.WattPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.WattPerSquareMeter"/>.
-        /// </summary>
-        public static Irradiance FromWattsPerSquareMeter(double wattspersquaremeter) => new Irradiance(wattspersquaremeter, IrradianceUnit.WattPerSquareMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="IrradianceUnit" /> to <see cref="Irradiance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Irradiance unit value.</returns>
-        public static Irradiance From(double value, IrradianceUnit fromUnit)
-        {
-            return new Irradiance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(IrradianceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Irradiance to another Irradiance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Irradiance with the specified unit.</returns>
-                public Irradiance ToUnit(IrradianceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Irradiance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        IrradianceUnit.KilowattPerSquareCentimeter => (_value * 10000) * 1e3d,
-                        IrradianceUnit.KilowattPerSquareMeter => (_value) * 1e3d,
-                        IrradianceUnit.MegawattPerSquareCentimeter => (_value * 10000) * 1e6d,
-                        IrradianceUnit.MegawattPerSquareMeter => (_value) * 1e6d,
-                        IrradianceUnit.MicrowattPerSquareCentimeter => (_value * 10000) * 1e-6d,
-                        IrradianceUnit.MicrowattPerSquareMeter => (_value) * 1e-6d,
-                        IrradianceUnit.MilliwattPerSquareCentimeter => (_value * 10000) * 1e-3d,
-                        IrradianceUnit.MilliwattPerSquareMeter => (_value) * 1e-3d,
-                        IrradianceUnit.NanowattPerSquareCentimeter => (_value * 10000) * 1e-9d,
-                        IrradianceUnit.NanowattPerSquareMeter => (_value) * 1e-9d,
-                        IrradianceUnit.PicowattPerSquareCentimeter => (_value * 10000) * 1e-12d,
-                        IrradianceUnit.PicowattPerSquareMeter => (_value) * 1e-12d,
-                        IrradianceUnit.WattPerSquareCentimeter => _value * 10000,
-                        IrradianceUnit.WattPerSquareMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(IrradianceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        IrradianceUnit.KilowattPerSquareCentimeter => (baseUnitValue * 0.0001) / 1e3d,
-                        IrradianceUnit.KilowattPerSquareMeter => (baseUnitValue) / 1e3d,
-                        IrradianceUnit.MegawattPerSquareCentimeter => (baseUnitValue * 0.0001) / 1e6d,
-                        IrradianceUnit.MegawattPerSquareMeter => (baseUnitValue) / 1e6d,
-                        IrradianceUnit.MicrowattPerSquareCentimeter => (baseUnitValue * 0.0001) / 1e-6d,
-                        IrradianceUnit.MicrowattPerSquareMeter => (baseUnitValue) / 1e-6d,
-                        IrradianceUnit.MilliwattPerSquareCentimeter => (baseUnitValue * 0.0001) / 1e-3d,
-                        IrradianceUnit.MilliwattPerSquareMeter => (baseUnitValue) / 1e-3d,
-                        IrradianceUnit.NanowattPerSquareCentimeter => (baseUnitValue * 0.0001) / 1e-9d,
-                        IrradianceUnit.NanowattPerSquareMeter => (baseUnitValue) / 1e-9d,
-                        IrradianceUnit.PicowattPerSquareCentimeter => (baseUnitValue * 0.0001) / 1e-12d,
-                        IrradianceUnit.PicowattPerSquareMeter => (baseUnitValue) / 1e-12d,
-                        IrradianceUnit.WattPerSquareCentimeter => baseUnitValue * 0.0001,
-                        IrradianceUnit.WattPerSquareMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Irradiation.g.cs
deleted file mode 100644
index 0dadfda90a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Irradiation.g.cs
+++ /dev/null
@@ -1,256 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Irradiation is the process by which an object is exposed to radiation. The exposure can originate from various sources, including natural sources.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Irradiation
-    /// </remarks>
-    public struct  Irradiation
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly IrradiationUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public IrradiationUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Irradiation(double value, IrradiationUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Irradiation, which is Second. All conversions go via this value.
-        /// </summary>
-        public static IrradiationUnit BaseUnit { get; } = IrradiationUnit.JoulePerSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Irradiation.
-        /// </summary>
-        public static Irradiation MaxValue { get; } = new Irradiation(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Irradiation.
-        /// </summary>
-        public static Irradiation MinValue { get; } = new Irradiation(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Irradiation Zero { get; } = new Irradiation(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.BtuPerSquareFoot"/>
-        /// </summary>
-        public double BtusPerSquareFoot => As(IrradiationUnit.BtuPerSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.JoulePerSquareCentimeter"/>
-        /// </summary>
-        public double JoulesPerSquareCentimeter => As(IrradiationUnit.JoulePerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.JoulePerSquareMeter"/>
-        /// </summary>
-        public double JoulesPerSquareMeter => As(IrradiationUnit.JoulePerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.JoulePerSquareMillimeter"/>
-        /// </summary>
-        public double JoulesPerSquareMillimeter => As(IrradiationUnit.JoulePerSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.KilobtuPerSquareFoot"/>
-        /// </summary>
-        public double KilobtusPerSquareFoot => As(IrradiationUnit.KilobtuPerSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.KilojoulePerSquareMeter"/>
-        /// </summary>
-        public double KilojoulesPerSquareMeter => As(IrradiationUnit.KilojoulePerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.KilowattHourPerSquareMeter"/>
-        /// </summary>
-        public double KilowattHoursPerSquareMeter => As(IrradiationUnit.KilowattHourPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.MillijoulePerSquareCentimeter"/>
-        /// </summary>
-        public double MillijoulesPerSquareCentimeter => As(IrradiationUnit.MillijoulePerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.WattHourPerSquareMeter"/>
-        /// </summary>
-        public double WattHoursPerSquareMeter => As(IrradiationUnit.WattHourPerSquareMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.BtuPerSquareFoot"/>.
-        /// </summary>
-        public static Irradiation FromBtusPerSquareFoot(double btuspersquarefoot) => new Irradiation(btuspersquarefoot, IrradiationUnit.BtuPerSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareCentimeter"/>.
-        /// </summary>
-        public static Irradiation FromJoulesPerSquareCentimeter(double joulespersquarecentimeter) => new Irradiation(joulespersquarecentimeter, IrradiationUnit.JoulePerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareMeter"/>.
-        /// </summary>
-        public static Irradiation FromJoulesPerSquareMeter(double joulespersquaremeter) => new Irradiation(joulespersquaremeter, IrradiationUnit.JoulePerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareMillimeter"/>.
-        /// </summary>
-        public static Irradiation FromJoulesPerSquareMillimeter(double joulespersquaremillimeter) => new Irradiation(joulespersquaremillimeter, IrradiationUnit.JoulePerSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.KilobtuPerSquareFoot"/>.
-        /// </summary>
-        public static Irradiation FromKilobtusPerSquareFoot(double kilobtuspersquarefoot) => new Irradiation(kilobtuspersquarefoot, IrradiationUnit.KilobtuPerSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.KilojoulePerSquareMeter"/>.
-        /// </summary>
-        public static Irradiation FromKilojoulesPerSquareMeter(double kilojoulespersquaremeter) => new Irradiation(kilojoulespersquaremeter, IrradiationUnit.KilojoulePerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.KilowattHourPerSquareMeter"/>.
-        /// </summary>
-        public static Irradiation FromKilowattHoursPerSquareMeter(double kilowatthourspersquaremeter) => new Irradiation(kilowatthourspersquaremeter, IrradiationUnit.KilowattHourPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.MillijoulePerSquareCentimeter"/>.
-        /// </summary>
-        public static Irradiation FromMillijoulesPerSquareCentimeter(double millijoulespersquarecentimeter) => new Irradiation(millijoulespersquarecentimeter, IrradiationUnit.MillijoulePerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.WattHourPerSquareMeter"/>.
-        /// </summary>
-        public static Irradiation FromWattHoursPerSquareMeter(double watthourspersquaremeter) => new Irradiation(watthourspersquaremeter, IrradiationUnit.WattHourPerSquareMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="IrradiationUnit" /> to <see cref="Irradiation" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Irradiation unit value.</returns>
-        public static Irradiation From(double value, IrradiationUnit fromUnit)
-        {
-            return new Irradiation(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(IrradiationUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Irradiation to another Irradiation with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Irradiation with the specified unit.</returns>
-                public Irradiation ToUnit(IrradiationUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Irradiation(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        IrradiationUnit.BtuPerSquareFoot => _value * 1055.05585262 / 9.290304e-2,
-                        IrradiationUnit.JoulePerSquareCentimeter => _value * 1e4,
-                        IrradiationUnit.JoulePerSquareMeter => _value,
-                        IrradiationUnit.JoulePerSquareMillimeter => _value * 1e6,
-                        IrradiationUnit.KilobtuPerSquareFoot => (_value * 1055.05585262 / 9.290304e-2) * 1e3d,
-                        IrradiationUnit.KilojoulePerSquareMeter => (_value) * 1e3d,
-                        IrradiationUnit.KilowattHourPerSquareMeter => (_value * 3600d) * 1e3d,
-                        IrradiationUnit.MillijoulePerSquareCentimeter => (_value * 1e4) * 1e-3d,
-                        IrradiationUnit.WattHourPerSquareMeter => _value * 3600d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(IrradiationUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        IrradiationUnit.BtuPerSquareFoot => baseUnitValue * 9.290304e-2 / 1055.05585262,
-                        IrradiationUnit.JoulePerSquareCentimeter => baseUnitValue / 1e4,
-                        IrradiationUnit.JoulePerSquareMeter => baseUnitValue,
-                        IrradiationUnit.JoulePerSquareMillimeter => baseUnitValue / 1e6,
-                        IrradiationUnit.KilobtuPerSquareFoot => (baseUnitValue * 9.290304e-2 / 1055.05585262) / 1e3d,
-                        IrradiationUnit.KilojoulePerSquareMeter => (baseUnitValue) / 1e3d,
-                        IrradiationUnit.KilowattHourPerSquareMeter => (baseUnitValue / 3600d) / 1e3d,
-                        IrradiationUnit.MillijoulePerSquareCentimeter => (baseUnitValue / 1e4) / 1e-3d,
-                        IrradiationUnit.WattHourPerSquareMeter => baseUnitValue / 3600d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Jerk.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Jerk.g.cs
deleted file mode 100644
index f96b0cf1a9..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Jerk.g.cs
+++ /dev/null
@@ -1,277 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     
-    /// </summary>
-    public struct  Jerk
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly JerkUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public JerkUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Jerk(double value, JerkUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Jerk, which is Second. All conversions go via this value.
-        /// </summary>
-        public static JerkUnit BaseUnit { get; } = JerkUnit.MeterPerSecondCubed;
-
-        /// <summary>
-        /// Represents the largest possible value of Jerk.
-        /// </summary>
-        public static Jerk MaxValue { get; } = new Jerk(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Jerk.
-        /// </summary>
-        public static Jerk MinValue { get; } = new Jerk(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Jerk Zero { get; } = new Jerk(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.CentimeterPerSecondCubed"/>
-        /// </summary>
-        public double CentimetersPerSecondCubed => As(JerkUnit.CentimeterPerSecondCubed);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.DecimeterPerSecondCubed"/>
-        /// </summary>
-        public double DecimetersPerSecondCubed => As(JerkUnit.DecimeterPerSecondCubed);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.FootPerSecondCubed"/>
-        /// </summary>
-        public double FeetPerSecondCubed => As(JerkUnit.FootPerSecondCubed);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.InchPerSecondCubed"/>
-        /// </summary>
-        public double InchesPerSecondCubed => As(JerkUnit.InchPerSecondCubed);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.KilometerPerSecondCubed"/>
-        /// </summary>
-        public double KilometersPerSecondCubed => As(JerkUnit.KilometerPerSecondCubed);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.MeterPerSecondCubed"/>
-        /// </summary>
-        public double MetersPerSecondCubed => As(JerkUnit.MeterPerSecondCubed);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.MicrometerPerSecondCubed"/>
-        /// </summary>
-        public double MicrometersPerSecondCubed => As(JerkUnit.MicrometerPerSecondCubed);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.MillimeterPerSecondCubed"/>
-        /// </summary>
-        public double MillimetersPerSecondCubed => As(JerkUnit.MillimeterPerSecondCubed);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.MillistandardGravitiesPerSecond"/>
-        /// </summary>
-        public double MillistandardGravitiesPerSecond => As(JerkUnit.MillistandardGravitiesPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.NanometerPerSecondCubed"/>
-        /// </summary>
-        public double NanometersPerSecondCubed => As(JerkUnit.NanometerPerSecondCubed);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.StandardGravitiesPerSecond"/>
-        /// </summary>
-        public double StandardGravitiesPerSecond => As(JerkUnit.StandardGravitiesPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.CentimeterPerSecondCubed"/>.
-        /// </summary>
-        public static Jerk FromCentimetersPerSecondCubed(double centimeterspersecondcubed) => new Jerk(centimeterspersecondcubed, JerkUnit.CentimeterPerSecondCubed);
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.DecimeterPerSecondCubed"/>.
-        /// </summary>
-        public static Jerk FromDecimetersPerSecondCubed(double decimeterspersecondcubed) => new Jerk(decimeterspersecondcubed, JerkUnit.DecimeterPerSecondCubed);
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.FootPerSecondCubed"/>.
-        /// </summary>
-        public static Jerk FromFeetPerSecondCubed(double feetpersecondcubed) => new Jerk(feetpersecondcubed, JerkUnit.FootPerSecondCubed);
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.InchPerSecondCubed"/>.
-        /// </summary>
-        public static Jerk FromInchesPerSecondCubed(double inchespersecondcubed) => new Jerk(inchespersecondcubed, JerkUnit.InchPerSecondCubed);
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.KilometerPerSecondCubed"/>.
-        /// </summary>
-        public static Jerk FromKilometersPerSecondCubed(double kilometerspersecondcubed) => new Jerk(kilometerspersecondcubed, JerkUnit.KilometerPerSecondCubed);
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MeterPerSecondCubed"/>.
-        /// </summary>
-        public static Jerk FromMetersPerSecondCubed(double meterspersecondcubed) => new Jerk(meterspersecondcubed, JerkUnit.MeterPerSecondCubed);
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MicrometerPerSecondCubed"/>.
-        /// </summary>
-        public static Jerk FromMicrometersPerSecondCubed(double micrometerspersecondcubed) => new Jerk(micrometerspersecondcubed, JerkUnit.MicrometerPerSecondCubed);
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MillimeterPerSecondCubed"/>.
-        /// </summary>
-        public static Jerk FromMillimetersPerSecondCubed(double millimeterspersecondcubed) => new Jerk(millimeterspersecondcubed, JerkUnit.MillimeterPerSecondCubed);
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MillistandardGravitiesPerSecond"/>.
-        /// </summary>
-        public static Jerk FromMillistandardGravitiesPerSecond(double millistandardgravitiespersecond) => new Jerk(millistandardgravitiespersecond, JerkUnit.MillistandardGravitiesPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.NanometerPerSecondCubed"/>.
-        /// </summary>
-        public static Jerk FromNanometersPerSecondCubed(double nanometerspersecondcubed) => new Jerk(nanometerspersecondcubed, JerkUnit.NanometerPerSecondCubed);
-
-        /// <summary>
-        ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.StandardGravitiesPerSecond"/>.
-        /// </summary>
-        public static Jerk FromStandardGravitiesPerSecond(double standardgravitiespersecond) => new Jerk(standardgravitiespersecond, JerkUnit.StandardGravitiesPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="JerkUnit" /> to <see cref="Jerk" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Jerk unit value.</returns>
-        public static Jerk From(double value, JerkUnit fromUnit)
-        {
-            return new Jerk(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(JerkUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Jerk to another Jerk with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Jerk with the specified unit.</returns>
-                public Jerk ToUnit(JerkUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Jerk(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        JerkUnit.CentimeterPerSecondCubed => (_value) * 1e-2d,
-                        JerkUnit.DecimeterPerSecondCubed => (_value) * 1e-1d,
-                        JerkUnit.FootPerSecondCubed => _value * 0.304800,
-                        JerkUnit.InchPerSecondCubed => _value * 0.0254,
-                        JerkUnit.KilometerPerSecondCubed => (_value) * 1e3d,
-                        JerkUnit.MeterPerSecondCubed => _value,
-                        JerkUnit.MicrometerPerSecondCubed => (_value) * 1e-6d,
-                        JerkUnit.MillimeterPerSecondCubed => (_value) * 1e-3d,
-                        JerkUnit.MillistandardGravitiesPerSecond => (_value * 9.80665) * 1e-3d,
-                        JerkUnit.NanometerPerSecondCubed => (_value) * 1e-9d,
-                        JerkUnit.StandardGravitiesPerSecond => _value * 9.80665,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(JerkUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        JerkUnit.CentimeterPerSecondCubed => (baseUnitValue) / 1e-2d,
-                        JerkUnit.DecimeterPerSecondCubed => (baseUnitValue) / 1e-1d,
-                        JerkUnit.FootPerSecondCubed => baseUnitValue / 0.304800,
-                        JerkUnit.InchPerSecondCubed => baseUnitValue / 0.0254,
-                        JerkUnit.KilometerPerSecondCubed => (baseUnitValue) / 1e3d,
-                        JerkUnit.MeterPerSecondCubed => baseUnitValue,
-                        JerkUnit.MicrometerPerSecondCubed => (baseUnitValue) / 1e-6d,
-                        JerkUnit.MillimeterPerSecondCubed => (baseUnitValue) / 1e-3d,
-                        JerkUnit.MillistandardGravitiesPerSecond => (baseUnitValue / 9.80665) / 1e-3d,
-                        JerkUnit.NanometerPerSecondCubed => (baseUnitValue) / 1e-9d,
-                        JerkUnit.StandardGravitiesPerSecond => baseUnitValue / 9.80665,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/KinematicViscosity.g.cs
deleted file mode 100644
index 5f7200be13..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/KinematicViscosity.g.cs
+++ /dev/null
@@ -1,256 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The viscosity of a fluid is a measure of its resistance to gradual deformation by shear stress or tensile stress.
-    /// </summary>
-    /// <remarks>
-    ///     http://en.wikipedia.org/wiki/Viscosity
-    /// </remarks>
-    public struct  KinematicViscosity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly KinematicViscosityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public KinematicViscosityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public KinematicViscosity(double value, KinematicViscosityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of KinematicViscosity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static KinematicViscosityUnit BaseUnit { get; } = KinematicViscosityUnit.SquareMeterPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of KinematicViscosity.
-        /// </summary>
-        public static KinematicViscosity MaxValue { get; } = new KinematicViscosity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of KinematicViscosity.
-        /// </summary>
-        public static KinematicViscosity MinValue { get; } = new KinematicViscosity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static KinematicViscosity Zero { get; } = new KinematicViscosity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Centistokes"/>
-        /// </summary>
-        public double Centistokes => As(KinematicViscosityUnit.Centistokes);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Decistokes"/>
-        /// </summary>
-        public double Decistokes => As(KinematicViscosityUnit.Decistokes);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Kilostokes"/>
-        /// </summary>
-        public double Kilostokes => As(KinematicViscosityUnit.Kilostokes);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Microstokes"/>
-        /// </summary>
-        public double Microstokes => As(KinematicViscosityUnit.Microstokes);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Millistokes"/>
-        /// </summary>
-        public double Millistokes => As(KinematicViscosityUnit.Millistokes);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Nanostokes"/>
-        /// </summary>
-        public double Nanostokes => As(KinematicViscosityUnit.Nanostokes);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.SquareFootPerSecond"/>
-        /// </summary>
-        public double SquareFeetPerSecond => As(KinematicViscosityUnit.SquareFootPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.SquareMeterPerSecond"/>
-        /// </summary>
-        public double SquareMetersPerSecond => As(KinematicViscosityUnit.SquareMeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Stokes"/>
-        /// </summary>
-        public double Stokes => As(KinematicViscosityUnit.Stokes);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Centistokes"/>.
-        /// </summary>
-        public static KinematicViscosity FromCentistokes(double centistokes) => new KinematicViscosity(centistokes, KinematicViscosityUnit.Centistokes);
-
-        /// <summary>
-        ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Decistokes"/>.
-        /// </summary>
-        public static KinematicViscosity FromDecistokes(double decistokes) => new KinematicViscosity(decistokes, KinematicViscosityUnit.Decistokes);
-
-        /// <summary>
-        ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Kilostokes"/>.
-        /// </summary>
-        public static KinematicViscosity FromKilostokes(double kilostokes) => new KinematicViscosity(kilostokes, KinematicViscosityUnit.Kilostokes);
-
-        /// <summary>
-        ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Microstokes"/>.
-        /// </summary>
-        public static KinematicViscosity FromMicrostokes(double microstokes) => new KinematicViscosity(microstokes, KinematicViscosityUnit.Microstokes);
-
-        /// <summary>
-        ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Millistokes"/>.
-        /// </summary>
-        public static KinematicViscosity FromMillistokes(double millistokes) => new KinematicViscosity(millistokes, KinematicViscosityUnit.Millistokes);
-
-        /// <summary>
-        ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Nanostokes"/>.
-        /// </summary>
-        public static KinematicViscosity FromNanostokes(double nanostokes) => new KinematicViscosity(nanostokes, KinematicViscosityUnit.Nanostokes);
-
-        /// <summary>
-        ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.SquareFootPerSecond"/>.
-        /// </summary>
-        public static KinematicViscosity FromSquareFeetPerSecond(double squarefeetpersecond) => new KinematicViscosity(squarefeetpersecond, KinematicViscosityUnit.SquareFootPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.SquareMeterPerSecond"/>.
-        /// </summary>
-        public static KinematicViscosity FromSquareMetersPerSecond(double squaremeterspersecond) => new KinematicViscosity(squaremeterspersecond, KinematicViscosityUnit.SquareMeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Stokes"/>.
-        /// </summary>
-        public static KinematicViscosity FromStokes(double stokes) => new KinematicViscosity(stokes, KinematicViscosityUnit.Stokes);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="KinematicViscosityUnit" /> to <see cref="KinematicViscosity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>KinematicViscosity unit value.</returns>
-        public static KinematicViscosity From(double value, KinematicViscosityUnit fromUnit)
-        {
-            return new KinematicViscosity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(KinematicViscosityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this KinematicViscosity to another KinematicViscosity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A KinematicViscosity with the specified unit.</returns>
-                public KinematicViscosity ToUnit(KinematicViscosityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new KinematicViscosity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        KinematicViscosityUnit.Centistokes => (_value / 1e4) * 1e-2d,
-                        KinematicViscosityUnit.Decistokes => (_value / 1e4) * 1e-1d,
-                        KinematicViscosityUnit.Kilostokes => (_value / 1e4) * 1e3d,
-                        KinematicViscosityUnit.Microstokes => (_value / 1e4) * 1e-6d,
-                        KinematicViscosityUnit.Millistokes => (_value / 1e4) * 1e-3d,
-                        KinematicViscosityUnit.Nanostokes => (_value / 1e4) * 1e-9d,
-                        KinematicViscosityUnit.SquareFootPerSecond => _value * 9.290304e-2,
-                        KinematicViscosityUnit.SquareMeterPerSecond => _value,
-                        KinematicViscosityUnit.Stokes => _value / 1e4,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(KinematicViscosityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        KinematicViscosityUnit.Centistokes => (baseUnitValue * 1e4) / 1e-2d,
-                        KinematicViscosityUnit.Decistokes => (baseUnitValue * 1e4) / 1e-1d,
-                        KinematicViscosityUnit.Kilostokes => (baseUnitValue * 1e4) / 1e3d,
-                        KinematicViscosityUnit.Microstokes => (baseUnitValue * 1e4) / 1e-6d,
-                        KinematicViscosityUnit.Millistokes => (baseUnitValue * 1e4) / 1e-3d,
-                        KinematicViscosityUnit.Nanostokes => (baseUnitValue * 1e4) / 1e-9d,
-                        KinematicViscosityUnit.SquareFootPerSecond => baseUnitValue / 9.290304e-2,
-                        KinematicViscosityUnit.SquareMeterPerSecond => baseUnitValue,
-                        KinematicViscosityUnit.Stokes => baseUnitValue * 1e4,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/LeakRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/LeakRate.g.cs
deleted file mode 100644
index 0ae299985c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/LeakRate.g.cs
+++ /dev/null
@@ -1,196 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     A leakage rate of QL = 1 Pa-m³/s is given when the pressure in a closed, evacuated container with a volume of 1 m³ rises by 1 Pa per second or when the pressure in the container drops by 1 Pa in the event of overpressure.
-    /// </summary>
-    /// <remarks>
-    ///     https://www.leybold.com/en-in/knowledge/vacuum-fundamentals/leak-detection/definition-and-measurement-of-vacuum-leaks
-    /// </remarks>
-    public struct  LeakRate
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly LeakRateUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public LeakRateUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public LeakRate(double value, LeakRateUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of LeakRate, which is Second. All conversions go via this value.
-        /// </summary>
-        public static LeakRateUnit BaseUnit { get; } = LeakRateUnit.PascalCubicMeterPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of LeakRate.
-        /// </summary>
-        public static LeakRate MaxValue { get; } = new LeakRate(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of LeakRate.
-        /// </summary>
-        public static LeakRate MinValue { get; } = new LeakRate(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static LeakRate Zero { get; } = new LeakRate(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LeakRateUnit.AtmCubicCentimeterPerSecond"/>
-        /// </summary>
-        public double AtmCubicCentimetersPerSecond => As(LeakRateUnit.AtmCubicCentimeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LeakRateUnit.MillibarLiterPerSecond"/>
-        /// </summary>
-        public double MillibarLitersPerSecond => As(LeakRateUnit.MillibarLiterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LeakRateUnit.PascalCubicMeterPerSecond"/>
-        /// </summary>
-        public double PascalCubicMetersPerSecond => As(LeakRateUnit.PascalCubicMeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LeakRateUnit.TorrLiterPerSecond"/>
-        /// </summary>
-        public double TorrLitersPerSecond => As(LeakRateUnit.TorrLiterPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.AtmCubicCentimeterPerSecond"/>.
-        /// </summary>
-        public static LeakRate FromAtmCubicCentimetersPerSecond(double atmcubiccentimeterspersecond) => new LeakRate(atmcubiccentimeterspersecond, LeakRateUnit.AtmCubicCentimeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.MillibarLiterPerSecond"/>.
-        /// </summary>
-        public static LeakRate FromMillibarLitersPerSecond(double millibarliterspersecond) => new LeakRate(millibarliterspersecond, LeakRateUnit.MillibarLiterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.PascalCubicMeterPerSecond"/>.
-        /// </summary>
-        public static LeakRate FromPascalCubicMetersPerSecond(double pascalcubicmeterspersecond) => new LeakRate(pascalcubicmeterspersecond, LeakRateUnit.PascalCubicMeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.TorrLiterPerSecond"/>.
-        /// </summary>
-        public static LeakRate FromTorrLitersPerSecond(double torrliterspersecond) => new LeakRate(torrliterspersecond, LeakRateUnit.TorrLiterPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LeakRateUnit" /> to <see cref="LeakRate" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>LeakRate unit value.</returns>
-        public static LeakRate From(double value, LeakRateUnit fromUnit)
-        {
-            return new LeakRate(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(LeakRateUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this LeakRate to another LeakRate with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A LeakRate with the specified unit.</returns>
-                public LeakRate ToUnit(LeakRateUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new LeakRate(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        LeakRateUnit.AtmCubicCentimeterPerSecond => _value / (1e6 / 101325),
-                        LeakRateUnit.MillibarLiterPerSecond => _value / 10,
-                        LeakRateUnit.PascalCubicMeterPerSecond => _value,
-                        LeakRateUnit.TorrLiterPerSecond => _value / 7.5,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(LeakRateUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        LeakRateUnit.AtmCubicCentimeterPerSecond => baseUnitValue * (1e6 / 101325),
-                        LeakRateUnit.MillibarLiterPerSecond => baseUnitValue * 10,
-                        LeakRateUnit.PascalCubicMeterPerSecond => baseUnitValue,
-                        LeakRateUnit.TorrLiterPerSecond => baseUnitValue * 7.5,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Length.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Length.g.cs
deleted file mode 100644
index a8540d56d6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Length.g.cs
+++ /dev/null
@@ -1,649 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Many different units of length have been used around the world. The main units in modern use are U.S. customary units in the United States and the Metric system elsewhere. British Imperial units are still used for some purposes in the United Kingdom and some other countries. The metric system is sub-divided into SI and non-SI units.
-    /// </summary>
-    public struct  Length
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly LengthUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public LengthUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Length(double value, LengthUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Length, which is Second. All conversions go via this value.
-        /// </summary>
-        public static LengthUnit BaseUnit { get; } = LengthUnit.Meter;
-
-        /// <summary>
-        /// Represents the largest possible value of Length.
-        /// </summary>
-        public static Length MaxValue { get; } = new Length(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Length.
-        /// </summary>
-        public static Length MinValue { get; } = new Length(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Length Zero { get; } = new Length(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Angstrom"/>
-        /// </summary>
-        public double Angstroms => As(LengthUnit.Angstrom);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.AstronomicalUnit"/>
-        /// </summary>
-        public double AstronomicalUnits => As(LengthUnit.AstronomicalUnit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Centimeter"/>
-        /// </summary>
-        public double Centimeters => As(LengthUnit.Centimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Chain"/>
-        /// </summary>
-        public double Chains => As(LengthUnit.Chain);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.DataMile"/>
-        /// </summary>
-        public double DataMiles => As(LengthUnit.DataMile);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Decameter"/>
-        /// </summary>
-        public double Decameters => As(LengthUnit.Decameter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Decimeter"/>
-        /// </summary>
-        public double Decimeters => As(LengthUnit.Decimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.DtpPica"/>
-        /// </summary>
-        public double DtpPicas => As(LengthUnit.DtpPica);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.DtpPoint"/>
-        /// </summary>
-        public double DtpPoints => As(LengthUnit.DtpPoint);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Fathom"/>
-        /// </summary>
-        public double Fathoms => As(LengthUnit.Fathom);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Femtometer"/>
-        /// </summary>
-        public double Femtometers => As(LengthUnit.Femtometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Foot"/>
-        /// </summary>
-        public double Feet => As(LengthUnit.Foot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Gigameter"/>
-        /// </summary>
-        public double Gigameters => As(LengthUnit.Gigameter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Hand"/>
-        /// </summary>
-        public double Hands => As(LengthUnit.Hand);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Hectometer"/>
-        /// </summary>
-        public double Hectometers => As(LengthUnit.Hectometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Inch"/>
-        /// </summary>
-        public double Inches => As(LengthUnit.Inch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Kilofoot"/>
-        /// </summary>
-        public double Kilofeet => As(LengthUnit.Kilofoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.KilolightYear"/>
-        /// </summary>
-        public double KilolightYears => As(LengthUnit.KilolightYear);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Kilometer"/>
-        /// </summary>
-        public double Kilometers => As(LengthUnit.Kilometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Kiloparsec"/>
-        /// </summary>
-        public double Kiloparsecs => As(LengthUnit.Kiloparsec);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Kiloyard"/>
-        /// </summary>
-        public double Kiloyards => As(LengthUnit.Kiloyard);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.LightYear"/>
-        /// </summary>
-        public double LightYears => As(LengthUnit.LightYear);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.MegalightYear"/>
-        /// </summary>
-        public double MegalightYears => As(LengthUnit.MegalightYear);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Megameter"/>
-        /// </summary>
-        public double Megameters => As(LengthUnit.Megameter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Megaparsec"/>
-        /// </summary>
-        public double Megaparsecs => As(LengthUnit.Megaparsec);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Meter"/>
-        /// </summary>
-        public double Meters => As(LengthUnit.Meter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Microinch"/>
-        /// </summary>
-        public double Microinches => As(LengthUnit.Microinch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Micrometer"/>
-        /// </summary>
-        public double Micrometers => As(LengthUnit.Micrometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Mil"/>
-        /// </summary>
-        public double Mils => As(LengthUnit.Mil);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Mile"/>
-        /// </summary>
-        public double Miles => As(LengthUnit.Mile);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Millimeter"/>
-        /// </summary>
-        public double Millimeters => As(LengthUnit.Millimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Nanometer"/>
-        /// </summary>
-        public double Nanometers => As(LengthUnit.Nanometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.NauticalMile"/>
-        /// </summary>
-        public double NauticalMiles => As(LengthUnit.NauticalMile);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Parsec"/>
-        /// </summary>
-        public double Parsecs => As(LengthUnit.Parsec);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Picometer"/>
-        /// </summary>
-        public double Picometers => As(LengthUnit.Picometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.PrinterPica"/>
-        /// </summary>
-        public double PrinterPicas => As(LengthUnit.PrinterPica);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.PrinterPoint"/>
-        /// </summary>
-        public double PrinterPoints => As(LengthUnit.PrinterPoint);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Shackle"/>
-        /// </summary>
-        public double Shackles => As(LengthUnit.Shackle);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.SolarRadius"/>
-        /// </summary>
-        public double SolarRadiuses => As(LengthUnit.SolarRadius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Twip"/>
-        /// </summary>
-        public double Twips => As(LengthUnit.Twip);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.UsSurveyFoot"/>
-        /// </summary>
-        public double UsSurveyFeet => As(LengthUnit.UsSurveyFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Yard"/>
-        /// </summary>
-        public double Yards => As(LengthUnit.Yard);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Angstrom"/>.
-        /// </summary>
-        public static Length FromAngstroms(double angstroms) => new Length(angstroms, LengthUnit.Angstrom);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.AstronomicalUnit"/>.
-        /// </summary>
-        public static Length FromAstronomicalUnits(double astronomicalunits) => new Length(astronomicalunits, LengthUnit.AstronomicalUnit);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Centimeter"/>.
-        /// </summary>
-        public static Length FromCentimeters(double centimeters) => new Length(centimeters, LengthUnit.Centimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Chain"/>.
-        /// </summary>
-        public static Length FromChains(double chains) => new Length(chains, LengthUnit.Chain);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DataMile"/>.
-        /// </summary>
-        public static Length FromDataMiles(double datamiles) => new Length(datamiles, LengthUnit.DataMile);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Decameter"/>.
-        /// </summary>
-        public static Length FromDecameters(double decameters) => new Length(decameters, LengthUnit.Decameter);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Decimeter"/>.
-        /// </summary>
-        public static Length FromDecimeters(double decimeters) => new Length(decimeters, LengthUnit.Decimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DtpPica"/>.
-        /// </summary>
-        public static Length FromDtpPicas(double dtppicas) => new Length(dtppicas, LengthUnit.DtpPica);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DtpPoint"/>.
-        /// </summary>
-        public static Length FromDtpPoints(double dtppoints) => new Length(dtppoints, LengthUnit.DtpPoint);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Fathom"/>.
-        /// </summary>
-        public static Length FromFathoms(double fathoms) => new Length(fathoms, LengthUnit.Fathom);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Femtometer"/>.
-        /// </summary>
-        public static Length FromFemtometers(double femtometers) => new Length(femtometers, LengthUnit.Femtometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Foot"/>.
-        /// </summary>
-        public static Length FromFeet(double feet) => new Length(feet, LengthUnit.Foot);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Gigameter"/>.
-        /// </summary>
-        public static Length FromGigameters(double gigameters) => new Length(gigameters, LengthUnit.Gigameter);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Hand"/>.
-        /// </summary>
-        public static Length FromHands(double hands) => new Length(hands, LengthUnit.Hand);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Hectometer"/>.
-        /// </summary>
-        public static Length FromHectometers(double hectometers) => new Length(hectometers, LengthUnit.Hectometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Inch"/>.
-        /// </summary>
-        public static Length FromInches(double inches) => new Length(inches, LengthUnit.Inch);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kilofoot"/>.
-        /// </summary>
-        public static Length FromKilofeet(double kilofeet) => new Length(kilofeet, LengthUnit.Kilofoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.KilolightYear"/>.
-        /// </summary>
-        public static Length FromKilolightYears(double kilolightyears) => new Length(kilolightyears, LengthUnit.KilolightYear);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kilometer"/>.
-        /// </summary>
-        public static Length FromKilometers(double kilometers) => new Length(kilometers, LengthUnit.Kilometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kiloparsec"/>.
-        /// </summary>
-        public static Length FromKiloparsecs(double kiloparsecs) => new Length(kiloparsecs, LengthUnit.Kiloparsec);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kiloyard"/>.
-        /// </summary>
-        public static Length FromKiloyards(double kiloyards) => new Length(kiloyards, LengthUnit.Kiloyard);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.LightYear"/>.
-        /// </summary>
-        public static Length FromLightYears(double lightyears) => new Length(lightyears, LengthUnit.LightYear);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.MegalightYear"/>.
-        /// </summary>
-        public static Length FromMegalightYears(double megalightyears) => new Length(megalightyears, LengthUnit.MegalightYear);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Megameter"/>.
-        /// </summary>
-        public static Length FromMegameters(double megameters) => new Length(megameters, LengthUnit.Megameter);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Megaparsec"/>.
-        /// </summary>
-        public static Length FromMegaparsecs(double megaparsecs) => new Length(megaparsecs, LengthUnit.Megaparsec);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Meter"/>.
-        /// </summary>
-        public static Length FromMeters(double meters) => new Length(meters, LengthUnit.Meter);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Microinch"/>.
-        /// </summary>
-        public static Length FromMicroinches(double microinches) => new Length(microinches, LengthUnit.Microinch);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Micrometer"/>.
-        /// </summary>
-        public static Length FromMicrometers(double micrometers) => new Length(micrometers, LengthUnit.Micrometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Mil"/>.
-        /// </summary>
-        public static Length FromMils(double mils) => new Length(mils, LengthUnit.Mil);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Mile"/>.
-        /// </summary>
-        public static Length FromMiles(double miles) => new Length(miles, LengthUnit.Mile);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Millimeter"/>.
-        /// </summary>
-        public static Length FromMillimeters(double millimeters) => new Length(millimeters, LengthUnit.Millimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Nanometer"/>.
-        /// </summary>
-        public static Length FromNanometers(double nanometers) => new Length(nanometers, LengthUnit.Nanometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.NauticalMile"/>.
-        /// </summary>
-        public static Length FromNauticalMiles(double nauticalmiles) => new Length(nauticalmiles, LengthUnit.NauticalMile);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Parsec"/>.
-        /// </summary>
-        public static Length FromParsecs(double parsecs) => new Length(parsecs, LengthUnit.Parsec);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Picometer"/>.
-        /// </summary>
-        public static Length FromPicometers(double picometers) => new Length(picometers, LengthUnit.Picometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.PrinterPica"/>.
-        /// </summary>
-        public static Length FromPrinterPicas(double printerpicas) => new Length(printerpicas, LengthUnit.PrinterPica);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.PrinterPoint"/>.
-        /// </summary>
-        public static Length FromPrinterPoints(double printerpoints) => new Length(printerpoints, LengthUnit.PrinterPoint);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Shackle"/>.
-        /// </summary>
-        public static Length FromShackles(double shackles) => new Length(shackles, LengthUnit.Shackle);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.SolarRadius"/>.
-        /// </summary>
-        public static Length FromSolarRadiuses(double solarradiuses) => new Length(solarradiuses, LengthUnit.SolarRadius);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Twip"/>.
-        /// </summary>
-        public static Length FromTwips(double twips) => new Length(twips, LengthUnit.Twip);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.UsSurveyFoot"/>.
-        /// </summary>
-        public static Length FromUsSurveyFeet(double ussurveyfeet) => new Length(ussurveyfeet, LengthUnit.UsSurveyFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Yard"/>.
-        /// </summary>
-        public static Length FromYards(double yards) => new Length(yards, LengthUnit.Yard);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LengthUnit" /> to <see cref="Length" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Length unit value.</returns>
-        public static Length From(double value, LengthUnit fromUnit)
-        {
-            return new Length(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(LengthUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Length to another Length with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Length with the specified unit.</returns>
-                public Length ToUnit(LengthUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Length(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        LengthUnit.Angstrom => _value * 1e-10,
-                        LengthUnit.AstronomicalUnit => _value * 1.4959787070e11,
-                        LengthUnit.Centimeter => (_value) * 1e-2d,
-                        LengthUnit.Chain => _value * 20.1168,
-                        LengthUnit.DataMile => _value * 1828.8,
-                        LengthUnit.Decameter => (_value) * 1e1d,
-                        LengthUnit.Decimeter => (_value) * 1e-1d,
-                        LengthUnit.DtpPica => _value * 2.54e-2 / 6,
-                        LengthUnit.DtpPoint => _value * 2.54e-2 / 72,
-                        LengthUnit.Fathom => _value * 1.8288,
-                        LengthUnit.Femtometer => (_value) * 1e-15d,
-                        LengthUnit.Foot => _value * 0.3048,
-                        LengthUnit.Gigameter => (_value) * 1e9d,
-                        LengthUnit.Hand => _value * 1.016e-1,
-                        LengthUnit.Hectometer => (_value) * 1e2d,
-                        LengthUnit.Inch => _value * 2.54e-2,
-                        LengthUnit.Kilofoot => (_value * 0.3048) * 1e3d,
-                        LengthUnit.KilolightYear => (_value * 9.46073047258e15) * 1e3d,
-                        LengthUnit.Kilometer => (_value) * 1e3d,
-                        LengthUnit.Kiloparsec => (_value * 3.08567758128e16) * 1e3d,
-                        LengthUnit.Kiloyard => (_value * 0.9144) * 1e3d,
-                        LengthUnit.LightYear => _value * 9.46073047258e15,
-                        LengthUnit.MegalightYear => (_value * 9.46073047258e15) * 1e6d,
-                        LengthUnit.Megameter => (_value) * 1e6d,
-                        LengthUnit.Megaparsec => (_value * 3.08567758128e16) * 1e6d,
-                        LengthUnit.Meter => _value,
-                        LengthUnit.Microinch => _value * 2.54e-8,
-                        LengthUnit.Micrometer => (_value) * 1e-6d,
-                        LengthUnit.Mil => _value * 2.54e-5,
-                        LengthUnit.Mile => _value * 1609.344,
-                        LengthUnit.Millimeter => (_value) * 1e-3d,
-                        LengthUnit.Nanometer => (_value) * 1e-9d,
-                        LengthUnit.NauticalMile => _value * 1852,
-                        LengthUnit.Parsec => _value * 3.08567758128e16,
-                        LengthUnit.Picometer => (_value) * 1e-12d,
-                        LengthUnit.PrinterPica => _value * 2.54e-2 * 400 / 2409,
-                        LengthUnit.PrinterPoint => _value * 2.54e-2 / 72.27 ,
-                        LengthUnit.Shackle => _value * 27.432,
-                        LengthUnit.SolarRadius => _value * 6.95700e8,
-                        LengthUnit.Twip => _value * 2.54e-2 / 1440,
-                        LengthUnit.UsSurveyFoot => _value * 1200 / 3937,
-                        LengthUnit.Yard => _value * 0.9144,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(LengthUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        LengthUnit.Angstrom => baseUnitValue / 1e-10,
-                        LengthUnit.AstronomicalUnit => baseUnitValue / 1.4959787070e11,
-                        LengthUnit.Centimeter => (baseUnitValue) / 1e-2d,
-                        LengthUnit.Chain => baseUnitValue / 20.1168,
-                        LengthUnit.DataMile => baseUnitValue / 1828.8,
-                        LengthUnit.Decameter => (baseUnitValue) / 1e1d,
-                        LengthUnit.Decimeter => (baseUnitValue) / 1e-1d,
-                        LengthUnit.DtpPica => baseUnitValue * 6 / 2.54e-2,
-                        LengthUnit.DtpPoint => baseUnitValue * 72 / 2.54e-2,
-                        LengthUnit.Fathom => baseUnitValue / 1.8288,
-                        LengthUnit.Femtometer => (baseUnitValue) / 1e-15d,
-                        LengthUnit.Foot => baseUnitValue / 0.3048,
-                        LengthUnit.Gigameter => (baseUnitValue) / 1e9d,
-                        LengthUnit.Hand => baseUnitValue / 1.016e-1,
-                        LengthUnit.Hectometer => (baseUnitValue) / 1e2d,
-                        LengthUnit.Inch => baseUnitValue / 2.54e-2,
-                        LengthUnit.Kilofoot => (baseUnitValue / 0.3048) / 1e3d,
-                        LengthUnit.KilolightYear => (baseUnitValue / 9.46073047258e15) / 1e3d,
-                        LengthUnit.Kilometer => (baseUnitValue) / 1e3d,
-                        LengthUnit.Kiloparsec => (baseUnitValue / 3.08567758128e16) / 1e3d,
-                        LengthUnit.Kiloyard => (baseUnitValue / 0.9144) / 1e3d,
-                        LengthUnit.LightYear => baseUnitValue / 9.46073047258e15,
-                        LengthUnit.MegalightYear => (baseUnitValue / 9.46073047258e15) / 1e6d,
-                        LengthUnit.Megameter => (baseUnitValue) / 1e6d,
-                        LengthUnit.Megaparsec => (baseUnitValue / 3.08567758128e16) / 1e6d,
-                        LengthUnit.Meter => baseUnitValue,
-                        LengthUnit.Microinch => baseUnitValue / 2.54e-8,
-                        LengthUnit.Micrometer => (baseUnitValue) / 1e-6d,
-                        LengthUnit.Mil => baseUnitValue / 2.54e-5,
-                        LengthUnit.Mile => baseUnitValue / 1609.344,
-                        LengthUnit.Millimeter => (baseUnitValue) / 1e-3d,
-                        LengthUnit.Nanometer => (baseUnitValue) / 1e-9d,
-                        LengthUnit.NauticalMile => baseUnitValue / 1852,
-                        LengthUnit.Parsec => baseUnitValue / 3.08567758128e16,
-                        LengthUnit.Picometer => (baseUnitValue) / 1e-12d,
-                        LengthUnit.PrinterPica => baseUnitValue / (2.54e-2 * 400 / 2409),
-                        LengthUnit.PrinterPoint => baseUnitValue * 72.27 / 2.54e-2,
-                        LengthUnit.Shackle => baseUnitValue / 27.432,
-                        LengthUnit.SolarRadius => baseUnitValue / 6.95700e8,
-                        LengthUnit.Twip => baseUnitValue * 1440 / 2.54e-2,
-                        LengthUnit.UsSurveyFoot => baseUnitValue * 3937 / 1200,
-                        LengthUnit.Yard => baseUnitValue / 0.9144,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Level.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Level.g.cs
deleted file mode 100644
index 24cc01e92f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Level.g.cs
+++ /dev/null
@@ -1,169 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Level is the logarithm of the ratio of a quantity Q to a reference value of that quantity, Q₀, expressed in dimensionless units.
-    /// </summary>
-    public struct  Level
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly LevelUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public LevelUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Level(double value, LevelUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Level, which is Second. All conversions go via this value.
-        /// </summary>
-        public static LevelUnit BaseUnit { get; } = LevelUnit.Decibel;
-
-        /// <summary>
-        /// Represents the largest possible value of Level.
-        /// </summary>
-        public static Level MaxValue { get; } = new Level(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Level.
-        /// </summary>
-        public static Level MinValue { get; } = new Level(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Level Zero { get; } = new Level(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LevelUnit.Decibel"/>
-        /// </summary>
-        public double Decibels => As(LevelUnit.Decibel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LevelUnit.Neper"/>
-        /// </summary>
-        public double Nepers => As(LevelUnit.Neper);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Level"/> from <see cref="LevelUnit.Decibel"/>.
-        /// </summary>
-        public static Level FromDecibels(double decibels) => new Level(decibels, LevelUnit.Decibel);
-
-        /// <summary>
-        ///     Creates a <see cref="Level"/> from <see cref="LevelUnit.Neper"/>.
-        /// </summary>
-        public static Level FromNepers(double nepers) => new Level(nepers, LevelUnit.Neper);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LevelUnit" /> to <see cref="Level" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Level unit value.</returns>
-        public static Level From(double value, LevelUnit fromUnit)
-        {
-            return new Level(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(LevelUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Level to another Level with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Level with the specified unit.</returns>
-                public Level ToUnit(LevelUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Level(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        LevelUnit.Decibel => _value,
-                        LevelUnit.Neper => (1 / 0.115129254) * _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(LevelUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        LevelUnit.Decibel => baseUnitValue,
-                        LevelUnit.Neper => 0.115129254 * baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/LinearDensity.g.cs
deleted file mode 100644
index 5c7c965719..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/LinearDensity.g.cs
+++ /dev/null
@@ -1,364 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The Linear Density, or more precisely, the linear mass density, of a substance is its mass per unit length.  The term linear density is most often used when describing the characteristics of one-dimensional objects, although linear density can also be used to describe the density of a three-dimensional quantity along one particular dimension.
-    /// </summary>
-    /// <remarks>
-    ///     http://en.wikipedia.org/wiki/Linear_density
-    /// </remarks>
-    public struct  LinearDensity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly LinearDensityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public LinearDensityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public LinearDensity(double value, LinearDensityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of LinearDensity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static LinearDensityUnit BaseUnit { get; } = LinearDensityUnit.KilogramPerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of LinearDensity.
-        /// </summary>
-        public static LinearDensity MaxValue { get; } = new LinearDensity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of LinearDensity.
-        /// </summary>
-        public static LinearDensity MinValue { get; } = new LinearDensity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static LinearDensity Zero { get; } = new LinearDensity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerCentimeter"/>
-        /// </summary>
-        public double GramsPerCentimeter => As(LinearDensityUnit.GramPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerFoot"/>
-        /// </summary>
-        public double GramsPerFoot => As(LinearDensityUnit.GramPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerMeter"/>
-        /// </summary>
-        public double GramsPerMeter => As(LinearDensityUnit.GramPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerMillimeter"/>
-        /// </summary>
-        public double GramsPerMillimeter => As(LinearDensityUnit.GramPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerCentimeter"/>
-        /// </summary>
-        public double KilogramsPerCentimeter => As(LinearDensityUnit.KilogramPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerFoot"/>
-        /// </summary>
-        public double KilogramsPerFoot => As(LinearDensityUnit.KilogramPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerMeter"/>
-        /// </summary>
-        public double KilogramsPerMeter => As(LinearDensityUnit.KilogramPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerMillimeter"/>
-        /// </summary>
-        public double KilogramsPerMillimeter => As(LinearDensityUnit.KilogramPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerCentimeter"/>
-        /// </summary>
-        public double MicrogramsPerCentimeter => As(LinearDensityUnit.MicrogramPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerFoot"/>
-        /// </summary>
-        public double MicrogramsPerFoot => As(LinearDensityUnit.MicrogramPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerMeter"/>
-        /// </summary>
-        public double MicrogramsPerMeter => As(LinearDensityUnit.MicrogramPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerMillimeter"/>
-        /// </summary>
-        public double MicrogramsPerMillimeter => As(LinearDensityUnit.MicrogramPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerCentimeter"/>
-        /// </summary>
-        public double MilligramsPerCentimeter => As(LinearDensityUnit.MilligramPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerFoot"/>
-        /// </summary>
-        public double MilligramsPerFoot => As(LinearDensityUnit.MilligramPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerMeter"/>
-        /// </summary>
-        public double MilligramsPerMeter => As(LinearDensityUnit.MilligramPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerMillimeter"/>
-        /// </summary>
-        public double MilligramsPerMillimeter => As(LinearDensityUnit.MilligramPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.PoundPerFoot"/>
-        /// </summary>
-        public double PoundsPerFoot => As(LinearDensityUnit.PoundPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.PoundPerInch"/>
-        /// </summary>
-        public double PoundsPerInch => As(LinearDensityUnit.PoundPerInch);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerCentimeter"/>.
-        /// </summary>
-        public static LinearDensity FromGramsPerCentimeter(double gramspercentimeter) => new LinearDensity(gramspercentimeter, LinearDensityUnit.GramPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerFoot"/>.
-        /// </summary>
-        public static LinearDensity FromGramsPerFoot(double gramsperfoot) => new LinearDensity(gramsperfoot, LinearDensityUnit.GramPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerMeter"/>.
-        /// </summary>
-        public static LinearDensity FromGramsPerMeter(double gramspermeter) => new LinearDensity(gramspermeter, LinearDensityUnit.GramPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerMillimeter"/>.
-        /// </summary>
-        public static LinearDensity FromGramsPerMillimeter(double gramspermillimeter) => new LinearDensity(gramspermillimeter, LinearDensityUnit.GramPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerCentimeter"/>.
-        /// </summary>
-        public static LinearDensity FromKilogramsPerCentimeter(double kilogramspercentimeter) => new LinearDensity(kilogramspercentimeter, LinearDensityUnit.KilogramPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerFoot"/>.
-        /// </summary>
-        public static LinearDensity FromKilogramsPerFoot(double kilogramsperfoot) => new LinearDensity(kilogramsperfoot, LinearDensityUnit.KilogramPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerMeter"/>.
-        /// </summary>
-        public static LinearDensity FromKilogramsPerMeter(double kilogramspermeter) => new LinearDensity(kilogramspermeter, LinearDensityUnit.KilogramPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerMillimeter"/>.
-        /// </summary>
-        public static LinearDensity FromKilogramsPerMillimeter(double kilogramspermillimeter) => new LinearDensity(kilogramspermillimeter, LinearDensityUnit.KilogramPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerCentimeter"/>.
-        /// </summary>
-        public static LinearDensity FromMicrogramsPerCentimeter(double microgramspercentimeter) => new LinearDensity(microgramspercentimeter, LinearDensityUnit.MicrogramPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerFoot"/>.
-        /// </summary>
-        public static LinearDensity FromMicrogramsPerFoot(double microgramsperfoot) => new LinearDensity(microgramsperfoot, LinearDensityUnit.MicrogramPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerMeter"/>.
-        /// </summary>
-        public static LinearDensity FromMicrogramsPerMeter(double microgramspermeter) => new LinearDensity(microgramspermeter, LinearDensityUnit.MicrogramPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerMillimeter"/>.
-        /// </summary>
-        public static LinearDensity FromMicrogramsPerMillimeter(double microgramspermillimeter) => new LinearDensity(microgramspermillimeter, LinearDensityUnit.MicrogramPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerCentimeter"/>.
-        /// </summary>
-        public static LinearDensity FromMilligramsPerCentimeter(double milligramspercentimeter) => new LinearDensity(milligramspercentimeter, LinearDensityUnit.MilligramPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerFoot"/>.
-        /// </summary>
-        public static LinearDensity FromMilligramsPerFoot(double milligramsperfoot) => new LinearDensity(milligramsperfoot, LinearDensityUnit.MilligramPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerMeter"/>.
-        /// </summary>
-        public static LinearDensity FromMilligramsPerMeter(double milligramspermeter) => new LinearDensity(milligramspermeter, LinearDensityUnit.MilligramPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerMillimeter"/>.
-        /// </summary>
-        public static LinearDensity FromMilligramsPerMillimeter(double milligramspermillimeter) => new LinearDensity(milligramspermillimeter, LinearDensityUnit.MilligramPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.PoundPerFoot"/>.
-        /// </summary>
-        public static LinearDensity FromPoundsPerFoot(double poundsperfoot) => new LinearDensity(poundsperfoot, LinearDensityUnit.PoundPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.PoundPerInch"/>.
-        /// </summary>
-        public static LinearDensity FromPoundsPerInch(double poundsperinch) => new LinearDensity(poundsperinch, LinearDensityUnit.PoundPerInch);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LinearDensityUnit" /> to <see cref="LinearDensity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>LinearDensity unit value.</returns>
-        public static LinearDensity From(double value, LinearDensityUnit fromUnit)
-        {
-            return new LinearDensity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(LinearDensityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this LinearDensity to another LinearDensity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A LinearDensity with the specified unit.</returns>
-                public LinearDensity ToUnit(LinearDensityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new LinearDensity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        LinearDensityUnit.GramPerCentimeter => _value * 1e-1,
-                        LinearDensityUnit.GramPerFoot => _value * ( 1e-3 / 0.3048 ),
-                        LinearDensityUnit.GramPerMeter => _value * 1e-3,
-                        LinearDensityUnit.GramPerMillimeter => _value,
-                        LinearDensityUnit.KilogramPerCentimeter => (_value * 1e-1) * 1e3d,
-                        LinearDensityUnit.KilogramPerFoot => (_value * ( 1e-3 / 0.3048 )) * 1e3d,
-                        LinearDensityUnit.KilogramPerMeter => (_value * 1e-3) * 1e3d,
-                        LinearDensityUnit.KilogramPerMillimeter => (_value) * 1e3d,
-                        LinearDensityUnit.MicrogramPerCentimeter => (_value * 1e-1) * 1e-6d,
-                        LinearDensityUnit.MicrogramPerFoot => (_value * ( 1e-3 / 0.3048 )) * 1e-6d,
-                        LinearDensityUnit.MicrogramPerMeter => (_value * 1e-3) * 1e-6d,
-                        LinearDensityUnit.MicrogramPerMillimeter => (_value) * 1e-6d,
-                        LinearDensityUnit.MilligramPerCentimeter => (_value * 1e-1) * 1e-3d,
-                        LinearDensityUnit.MilligramPerFoot => (_value * ( 1e-3 / 0.3048 )) * 1e-3d,
-                        LinearDensityUnit.MilligramPerMeter => (_value * 1e-3) * 1e-3d,
-                        LinearDensityUnit.MilligramPerMillimeter => (_value) * 1e-3d,
-                        LinearDensityUnit.PoundPerFoot => _value * 0.45359237 / 0.3048,
-                        LinearDensityUnit.PoundPerInch => _value * 0.45359237 / 2.54e-2,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(LinearDensityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        LinearDensityUnit.GramPerCentimeter => baseUnitValue / 1e-1,
-                        LinearDensityUnit.GramPerFoot => baseUnitValue / ( 1e-3 / 0.3048 ),
-                        LinearDensityUnit.GramPerMeter => baseUnitValue / 1e-3,
-                        LinearDensityUnit.GramPerMillimeter => baseUnitValue,
-                        LinearDensityUnit.KilogramPerCentimeter => (baseUnitValue / 1e-1) / 1e3d,
-                        LinearDensityUnit.KilogramPerFoot => (baseUnitValue / ( 1e-3 / 0.3048 )) / 1e3d,
-                        LinearDensityUnit.KilogramPerMeter => (baseUnitValue / 1e-3) / 1e3d,
-                        LinearDensityUnit.KilogramPerMillimeter => (baseUnitValue) / 1e3d,
-                        LinearDensityUnit.MicrogramPerCentimeter => (baseUnitValue / 1e-1) / 1e-6d,
-                        LinearDensityUnit.MicrogramPerFoot => (baseUnitValue / ( 1e-3 / 0.3048 )) / 1e-6d,
-                        LinearDensityUnit.MicrogramPerMeter => (baseUnitValue / 1e-3) / 1e-6d,
-                        LinearDensityUnit.MicrogramPerMillimeter => (baseUnitValue) / 1e-6d,
-                        LinearDensityUnit.MilligramPerCentimeter => (baseUnitValue / 1e-1) / 1e-3d,
-                        LinearDensityUnit.MilligramPerFoot => (baseUnitValue / ( 1e-3 / 0.3048 )) / 1e-3d,
-                        LinearDensityUnit.MilligramPerMeter => (baseUnitValue / 1e-3) / 1e-3d,
-                        LinearDensityUnit.MilligramPerMillimeter => (baseUnitValue) / 1e-3d,
-                        LinearDensityUnit.PoundPerFoot => baseUnitValue * 0.3048 / 0.45359237,
-                        LinearDensityUnit.PoundPerInch => baseUnitValue * 2.54e-2 / 0.45359237,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/LinearPowerDensity.g.cs
deleted file mode 100644
index 5823bb4713..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/LinearPowerDensity.g.cs
+++ /dev/null
@@ -1,448 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The Linear Power Density of a substance is its power per unit length.  The term linear density is most often used when describing the characteristics of one-dimensional objects, although linear density can also be used to describe the density of a three-dimensional quantity along one particular dimension.
-    /// </summary>
-    /// <remarks>
-    ///     http://en.wikipedia.org/wiki/Linear_density
-    /// </remarks>
-    public struct  LinearPowerDensity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly LinearPowerDensityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public LinearPowerDensityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public LinearPowerDensity(double value, LinearPowerDensityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of LinearPowerDensity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static LinearPowerDensityUnit BaseUnit { get; } = LinearPowerDensityUnit.WattPerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of LinearPowerDensity.
-        /// </summary>
-        public static LinearPowerDensity MaxValue { get; } = new LinearPowerDensity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of LinearPowerDensity.
-        /// </summary>
-        public static LinearPowerDensity MinValue { get; } = new LinearPowerDensity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static LinearPowerDensity Zero { get; } = new LinearPowerDensity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerCentimeter"/>
-        /// </summary>
-        public double GigawattsPerCentimeter => As(LinearPowerDensityUnit.GigawattPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerFoot"/>
-        /// </summary>
-        public double GigawattsPerFoot => As(LinearPowerDensityUnit.GigawattPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerInch"/>
-        /// </summary>
-        public double GigawattsPerInch => As(LinearPowerDensityUnit.GigawattPerInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerMeter"/>
-        /// </summary>
-        public double GigawattsPerMeter => As(LinearPowerDensityUnit.GigawattPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerMillimeter"/>
-        /// </summary>
-        public double GigawattsPerMillimeter => As(LinearPowerDensityUnit.GigawattPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerCentimeter"/>
-        /// </summary>
-        public double KilowattsPerCentimeter => As(LinearPowerDensityUnit.KilowattPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerFoot"/>
-        /// </summary>
-        public double KilowattsPerFoot => As(LinearPowerDensityUnit.KilowattPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerInch"/>
-        /// </summary>
-        public double KilowattsPerInch => As(LinearPowerDensityUnit.KilowattPerInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerMeter"/>
-        /// </summary>
-        public double KilowattsPerMeter => As(LinearPowerDensityUnit.KilowattPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerMillimeter"/>
-        /// </summary>
-        public double KilowattsPerMillimeter => As(LinearPowerDensityUnit.KilowattPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerCentimeter"/>
-        /// </summary>
-        public double MegawattsPerCentimeter => As(LinearPowerDensityUnit.MegawattPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerFoot"/>
-        /// </summary>
-        public double MegawattsPerFoot => As(LinearPowerDensityUnit.MegawattPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerInch"/>
-        /// </summary>
-        public double MegawattsPerInch => As(LinearPowerDensityUnit.MegawattPerInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerMeter"/>
-        /// </summary>
-        public double MegawattsPerMeter => As(LinearPowerDensityUnit.MegawattPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerMillimeter"/>
-        /// </summary>
-        public double MegawattsPerMillimeter => As(LinearPowerDensityUnit.MegawattPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerCentimeter"/>
-        /// </summary>
-        public double MilliwattsPerCentimeter => As(LinearPowerDensityUnit.MilliwattPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerFoot"/>
-        /// </summary>
-        public double MilliwattsPerFoot => As(LinearPowerDensityUnit.MilliwattPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerInch"/>
-        /// </summary>
-        public double MilliwattsPerInch => As(LinearPowerDensityUnit.MilliwattPerInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerMeter"/>
-        /// </summary>
-        public double MilliwattsPerMeter => As(LinearPowerDensityUnit.MilliwattPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerMillimeter"/>
-        /// </summary>
-        public double MilliwattsPerMillimeter => As(LinearPowerDensityUnit.MilliwattPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerCentimeter"/>
-        /// </summary>
-        public double WattsPerCentimeter => As(LinearPowerDensityUnit.WattPerCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerFoot"/>
-        /// </summary>
-        public double WattsPerFoot => As(LinearPowerDensityUnit.WattPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerInch"/>
-        /// </summary>
-        public double WattsPerInch => As(LinearPowerDensityUnit.WattPerInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerMeter"/>
-        /// </summary>
-        public double WattsPerMeter => As(LinearPowerDensityUnit.WattPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerMillimeter"/>
-        /// </summary>
-        public double WattsPerMillimeter => As(LinearPowerDensityUnit.WattPerMillimeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerCentimeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromGigawattsPerCentimeter(double gigawattspercentimeter) => new LinearPowerDensity(gigawattspercentimeter, LinearPowerDensityUnit.GigawattPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerFoot"/>.
-        /// </summary>
-        public static LinearPowerDensity FromGigawattsPerFoot(double gigawattsperfoot) => new LinearPowerDensity(gigawattsperfoot, LinearPowerDensityUnit.GigawattPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerInch"/>.
-        /// </summary>
-        public static LinearPowerDensity FromGigawattsPerInch(double gigawattsperinch) => new LinearPowerDensity(gigawattsperinch, LinearPowerDensityUnit.GigawattPerInch);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerMeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromGigawattsPerMeter(double gigawattspermeter) => new LinearPowerDensity(gigawattspermeter, LinearPowerDensityUnit.GigawattPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerMillimeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromGigawattsPerMillimeter(double gigawattspermillimeter) => new LinearPowerDensity(gigawattspermillimeter, LinearPowerDensityUnit.GigawattPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerCentimeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromKilowattsPerCentimeter(double kilowattspercentimeter) => new LinearPowerDensity(kilowattspercentimeter, LinearPowerDensityUnit.KilowattPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerFoot"/>.
-        /// </summary>
-        public static LinearPowerDensity FromKilowattsPerFoot(double kilowattsperfoot) => new LinearPowerDensity(kilowattsperfoot, LinearPowerDensityUnit.KilowattPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerInch"/>.
-        /// </summary>
-        public static LinearPowerDensity FromKilowattsPerInch(double kilowattsperinch) => new LinearPowerDensity(kilowattsperinch, LinearPowerDensityUnit.KilowattPerInch);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerMeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromKilowattsPerMeter(double kilowattspermeter) => new LinearPowerDensity(kilowattspermeter, LinearPowerDensityUnit.KilowattPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerMillimeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromKilowattsPerMillimeter(double kilowattspermillimeter) => new LinearPowerDensity(kilowattspermillimeter, LinearPowerDensityUnit.KilowattPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerCentimeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromMegawattsPerCentimeter(double megawattspercentimeter) => new LinearPowerDensity(megawattspercentimeter, LinearPowerDensityUnit.MegawattPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerFoot"/>.
-        /// </summary>
-        public static LinearPowerDensity FromMegawattsPerFoot(double megawattsperfoot) => new LinearPowerDensity(megawattsperfoot, LinearPowerDensityUnit.MegawattPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerInch"/>.
-        /// </summary>
-        public static LinearPowerDensity FromMegawattsPerInch(double megawattsperinch) => new LinearPowerDensity(megawattsperinch, LinearPowerDensityUnit.MegawattPerInch);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerMeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromMegawattsPerMeter(double megawattspermeter) => new LinearPowerDensity(megawattspermeter, LinearPowerDensityUnit.MegawattPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerMillimeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromMegawattsPerMillimeter(double megawattspermillimeter) => new LinearPowerDensity(megawattspermillimeter, LinearPowerDensityUnit.MegawattPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerCentimeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromMilliwattsPerCentimeter(double milliwattspercentimeter) => new LinearPowerDensity(milliwattspercentimeter, LinearPowerDensityUnit.MilliwattPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerFoot"/>.
-        /// </summary>
-        public static LinearPowerDensity FromMilliwattsPerFoot(double milliwattsperfoot) => new LinearPowerDensity(milliwattsperfoot, LinearPowerDensityUnit.MilliwattPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerInch"/>.
-        /// </summary>
-        public static LinearPowerDensity FromMilliwattsPerInch(double milliwattsperinch) => new LinearPowerDensity(milliwattsperinch, LinearPowerDensityUnit.MilliwattPerInch);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerMeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromMilliwattsPerMeter(double milliwattspermeter) => new LinearPowerDensity(milliwattspermeter, LinearPowerDensityUnit.MilliwattPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerMillimeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromMilliwattsPerMillimeter(double milliwattspermillimeter) => new LinearPowerDensity(milliwattspermillimeter, LinearPowerDensityUnit.MilliwattPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerCentimeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromWattsPerCentimeter(double wattspercentimeter) => new LinearPowerDensity(wattspercentimeter, LinearPowerDensityUnit.WattPerCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerFoot"/>.
-        /// </summary>
-        public static LinearPowerDensity FromWattsPerFoot(double wattsperfoot) => new LinearPowerDensity(wattsperfoot, LinearPowerDensityUnit.WattPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerInch"/>.
-        /// </summary>
-        public static LinearPowerDensity FromWattsPerInch(double wattsperinch) => new LinearPowerDensity(wattsperinch, LinearPowerDensityUnit.WattPerInch);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerMeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromWattsPerMeter(double wattspermeter) => new LinearPowerDensity(wattspermeter, LinearPowerDensityUnit.WattPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerMillimeter"/>.
-        /// </summary>
-        public static LinearPowerDensity FromWattsPerMillimeter(double wattspermillimeter) => new LinearPowerDensity(wattspermillimeter, LinearPowerDensityUnit.WattPerMillimeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LinearPowerDensityUnit" /> to <see cref="LinearPowerDensity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>LinearPowerDensity unit value.</returns>
-        public static LinearPowerDensity From(double value, LinearPowerDensityUnit fromUnit)
-        {
-            return new LinearPowerDensity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(LinearPowerDensityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this LinearPowerDensity to another LinearPowerDensity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A LinearPowerDensity with the specified unit.</returns>
-                public LinearPowerDensity ToUnit(LinearPowerDensityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new LinearPowerDensity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        LinearPowerDensityUnit.GigawattPerCentimeter => (_value * 1e2) * 1e9d,
-                        LinearPowerDensityUnit.GigawattPerFoot => (_value / 0.3048) * 1e9d,
-                        LinearPowerDensityUnit.GigawattPerInch => (_value / 2.54e-2) * 1e9d,
-                        LinearPowerDensityUnit.GigawattPerMeter => (_value) * 1e9d,
-                        LinearPowerDensityUnit.GigawattPerMillimeter => (_value * 1e3) * 1e9d,
-                        LinearPowerDensityUnit.KilowattPerCentimeter => (_value * 1e2) * 1e3d,
-                        LinearPowerDensityUnit.KilowattPerFoot => (_value / 0.3048) * 1e3d,
-                        LinearPowerDensityUnit.KilowattPerInch => (_value / 2.54e-2) * 1e3d,
-                        LinearPowerDensityUnit.KilowattPerMeter => (_value) * 1e3d,
-                        LinearPowerDensityUnit.KilowattPerMillimeter => (_value * 1e3) * 1e3d,
-                        LinearPowerDensityUnit.MegawattPerCentimeter => (_value * 1e2) * 1e6d,
-                        LinearPowerDensityUnit.MegawattPerFoot => (_value / 0.3048) * 1e6d,
-                        LinearPowerDensityUnit.MegawattPerInch => (_value / 2.54e-2) * 1e6d,
-                        LinearPowerDensityUnit.MegawattPerMeter => (_value) * 1e6d,
-                        LinearPowerDensityUnit.MegawattPerMillimeter => (_value * 1e3) * 1e6d,
-                        LinearPowerDensityUnit.MilliwattPerCentimeter => (_value * 1e2) * 1e-3d,
-                        LinearPowerDensityUnit.MilliwattPerFoot => (_value / 0.3048) * 1e-3d,
-                        LinearPowerDensityUnit.MilliwattPerInch => (_value / 2.54e-2) * 1e-3d,
-                        LinearPowerDensityUnit.MilliwattPerMeter => (_value) * 1e-3d,
-                        LinearPowerDensityUnit.MilliwattPerMillimeter => (_value * 1e3) * 1e-3d,
-                        LinearPowerDensityUnit.WattPerCentimeter => _value * 1e2,
-                        LinearPowerDensityUnit.WattPerFoot => _value / 0.3048,
-                        LinearPowerDensityUnit.WattPerInch => _value / 2.54e-2,
-                        LinearPowerDensityUnit.WattPerMeter => _value,
-                        LinearPowerDensityUnit.WattPerMillimeter => _value * 1e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(LinearPowerDensityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        LinearPowerDensityUnit.GigawattPerCentimeter => (baseUnitValue / 1e2) / 1e9d,
-                        LinearPowerDensityUnit.GigawattPerFoot => (baseUnitValue * 0.3048) / 1e9d,
-                        LinearPowerDensityUnit.GigawattPerInch => (baseUnitValue * 2.54e-2) / 1e9d,
-                        LinearPowerDensityUnit.GigawattPerMeter => (baseUnitValue) / 1e9d,
-                        LinearPowerDensityUnit.GigawattPerMillimeter => (baseUnitValue / 1e3) / 1e9d,
-                        LinearPowerDensityUnit.KilowattPerCentimeter => (baseUnitValue / 1e2) / 1e3d,
-                        LinearPowerDensityUnit.KilowattPerFoot => (baseUnitValue * 0.3048) / 1e3d,
-                        LinearPowerDensityUnit.KilowattPerInch => (baseUnitValue * 2.54e-2) / 1e3d,
-                        LinearPowerDensityUnit.KilowattPerMeter => (baseUnitValue) / 1e3d,
-                        LinearPowerDensityUnit.KilowattPerMillimeter => (baseUnitValue / 1e3) / 1e3d,
-                        LinearPowerDensityUnit.MegawattPerCentimeter => (baseUnitValue / 1e2) / 1e6d,
-                        LinearPowerDensityUnit.MegawattPerFoot => (baseUnitValue * 0.3048) / 1e6d,
-                        LinearPowerDensityUnit.MegawattPerInch => (baseUnitValue * 2.54e-2) / 1e6d,
-                        LinearPowerDensityUnit.MegawattPerMeter => (baseUnitValue) / 1e6d,
-                        LinearPowerDensityUnit.MegawattPerMillimeter => (baseUnitValue / 1e3) / 1e6d,
-                        LinearPowerDensityUnit.MilliwattPerCentimeter => (baseUnitValue / 1e2) / 1e-3d,
-                        LinearPowerDensityUnit.MilliwattPerFoot => (baseUnitValue * 0.3048) / 1e-3d,
-                        LinearPowerDensityUnit.MilliwattPerInch => (baseUnitValue * 2.54e-2) / 1e-3d,
-                        LinearPowerDensityUnit.MilliwattPerMeter => (baseUnitValue) / 1e-3d,
-                        LinearPowerDensityUnit.MilliwattPerMillimeter => (baseUnitValue / 1e3) / 1e-3d,
-                        LinearPowerDensityUnit.WattPerCentimeter => baseUnitValue / 1e2,
-                        LinearPowerDensityUnit.WattPerFoot => baseUnitValue * 0.3048,
-                        LinearPowerDensityUnit.WattPerInch => baseUnitValue * 2.54e-2,
-                        LinearPowerDensityUnit.WattPerMeter => baseUnitValue,
-                        LinearPowerDensityUnit.WattPerMillimeter => baseUnitValue / 1e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Luminance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Luminance.g.cs
deleted file mode 100644
index e891857e2f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Luminance.g.cs
+++ /dev/null
@@ -1,268 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Luminance
-    /// </remarks>
-    public struct  Luminance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly LuminanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public LuminanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Luminance(double value, LuminanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Luminance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static LuminanceUnit BaseUnit { get; } = LuminanceUnit.CandelaPerSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Luminance.
-        /// </summary>
-        public static Luminance MaxValue { get; } = new Luminance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Luminance.
-        /// </summary>
-        public static Luminance MinValue { get; } = new Luminance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Luminance Zero { get; } = new Luminance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.CandelaPerSquareFoot"/>
-        /// </summary>
-        public double CandelasPerSquareFoot => As(LuminanceUnit.CandelaPerSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.CandelaPerSquareInch"/>
-        /// </summary>
-        public double CandelasPerSquareInch => As(LuminanceUnit.CandelaPerSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.CandelaPerSquareMeter"/>
-        /// </summary>
-        public double CandelasPerSquareMeter => As(LuminanceUnit.CandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.CenticandelaPerSquareMeter"/>
-        /// </summary>
-        public double CenticandelasPerSquareMeter => As(LuminanceUnit.CenticandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.DecicandelaPerSquareMeter"/>
-        /// </summary>
-        public double DecicandelasPerSquareMeter => As(LuminanceUnit.DecicandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.KilocandelaPerSquareMeter"/>
-        /// </summary>
-        public double KilocandelasPerSquareMeter => As(LuminanceUnit.KilocandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.MicrocandelaPerSquareMeter"/>
-        /// </summary>
-        public double MicrocandelasPerSquareMeter => As(LuminanceUnit.MicrocandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.MillicandelaPerSquareMeter"/>
-        /// </summary>
-        public double MillicandelasPerSquareMeter => As(LuminanceUnit.MillicandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.NanocandelaPerSquareMeter"/>
-        /// </summary>
-        public double NanocandelasPerSquareMeter => As(LuminanceUnit.NanocandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.Nit"/>
-        /// </summary>
-        public double Nits => As(LuminanceUnit.Nit);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareFoot"/>.
-        /// </summary>
-        public static Luminance FromCandelasPerSquareFoot(double candelaspersquarefoot) => new Luminance(candelaspersquarefoot, LuminanceUnit.CandelaPerSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareInch"/>.
-        /// </summary>
-        public static Luminance FromCandelasPerSquareInch(double candelaspersquareinch) => new Luminance(candelaspersquareinch, LuminanceUnit.CandelaPerSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareMeter"/>.
-        /// </summary>
-        public static Luminance FromCandelasPerSquareMeter(double candelaspersquaremeter) => new Luminance(candelaspersquaremeter, LuminanceUnit.CandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CenticandelaPerSquareMeter"/>.
-        /// </summary>
-        public static Luminance FromCenticandelasPerSquareMeter(double centicandelaspersquaremeter) => new Luminance(centicandelaspersquaremeter, LuminanceUnit.CenticandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.DecicandelaPerSquareMeter"/>.
-        /// </summary>
-        public static Luminance FromDecicandelasPerSquareMeter(double decicandelaspersquaremeter) => new Luminance(decicandelaspersquaremeter, LuminanceUnit.DecicandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.KilocandelaPerSquareMeter"/>.
-        /// </summary>
-        public static Luminance FromKilocandelasPerSquareMeter(double kilocandelaspersquaremeter) => new Luminance(kilocandelaspersquaremeter, LuminanceUnit.KilocandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.MicrocandelaPerSquareMeter"/>.
-        /// </summary>
-        public static Luminance FromMicrocandelasPerSquareMeter(double microcandelaspersquaremeter) => new Luminance(microcandelaspersquaremeter, LuminanceUnit.MicrocandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.MillicandelaPerSquareMeter"/>.
-        /// </summary>
-        public static Luminance FromMillicandelasPerSquareMeter(double millicandelaspersquaremeter) => new Luminance(millicandelaspersquaremeter, LuminanceUnit.MillicandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.NanocandelaPerSquareMeter"/>.
-        /// </summary>
-        public static Luminance FromNanocandelasPerSquareMeter(double nanocandelaspersquaremeter) => new Luminance(nanocandelaspersquaremeter, LuminanceUnit.NanocandelaPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.Nit"/>.
-        /// </summary>
-        public static Luminance FromNits(double nits) => new Luminance(nits, LuminanceUnit.Nit);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LuminanceUnit" /> to <see cref="Luminance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Luminance unit value.</returns>
-        public static Luminance From(double value, LuminanceUnit fromUnit)
-        {
-            return new Luminance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(LuminanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Luminance to another Luminance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Luminance with the specified unit.</returns>
-                public Luminance ToUnit(LuminanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Luminance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        LuminanceUnit.CandelaPerSquareFoot => _value / 9.290304e-2,
-                        LuminanceUnit.CandelaPerSquareInch => _value / 0.00064516,
-                        LuminanceUnit.CandelaPerSquareMeter => _value,
-                        LuminanceUnit.CenticandelaPerSquareMeter => (_value) * 1e-2d,
-                        LuminanceUnit.DecicandelaPerSquareMeter => (_value) * 1e-1d,
-                        LuminanceUnit.KilocandelaPerSquareMeter => (_value) * 1e3d,
-                        LuminanceUnit.MicrocandelaPerSquareMeter => (_value) * 1e-6d,
-                        LuminanceUnit.MillicandelaPerSquareMeter => (_value) * 1e-3d,
-                        LuminanceUnit.NanocandelaPerSquareMeter => (_value) * 1e-9d,
-                        LuminanceUnit.Nit => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(LuminanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        LuminanceUnit.CandelaPerSquareFoot => baseUnitValue * 9.290304e-2,
-                        LuminanceUnit.CandelaPerSquareInch => baseUnitValue * 0.00064516,
-                        LuminanceUnit.CandelaPerSquareMeter => baseUnitValue,
-                        LuminanceUnit.CenticandelaPerSquareMeter => (baseUnitValue) / 1e-2d,
-                        LuminanceUnit.DecicandelaPerSquareMeter => (baseUnitValue) / 1e-1d,
-                        LuminanceUnit.KilocandelaPerSquareMeter => (baseUnitValue) / 1e3d,
-                        LuminanceUnit.MicrocandelaPerSquareMeter => (baseUnitValue) / 1e-6d,
-                        LuminanceUnit.MillicandelaPerSquareMeter => (baseUnitValue) / 1e-3d,
-                        LuminanceUnit.NanocandelaPerSquareMeter => (baseUnitValue) / 1e-9d,
-                        LuminanceUnit.Nit => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Luminosity.g.cs
deleted file mode 100644
index 2f8b1afb41..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Luminosity.g.cs
+++ /dev/null
@@ -1,316 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Luminosity is an absolute measure of radiated electromagnetic power (light), the radiant power emitted by a light-emitting object.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Luminosity
-    /// </remarks>
-    public struct  Luminosity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly LuminosityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public LuminosityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Luminosity(double value, LuminosityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Luminosity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static LuminosityUnit BaseUnit { get; } = LuminosityUnit.Watt;
-
-        /// <summary>
-        /// Represents the largest possible value of Luminosity.
-        /// </summary>
-        public static Luminosity MaxValue { get; } = new Luminosity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Luminosity.
-        /// </summary>
-        public static Luminosity MinValue { get; } = new Luminosity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Luminosity Zero { get; } = new Luminosity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Decawatt"/>
-        /// </summary>
-        public double Decawatts => As(LuminosityUnit.Decawatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Deciwatt"/>
-        /// </summary>
-        public double Deciwatts => As(LuminosityUnit.Deciwatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Femtowatt"/>
-        /// </summary>
-        public double Femtowatts => As(LuminosityUnit.Femtowatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Gigawatt"/>
-        /// </summary>
-        public double Gigawatts => As(LuminosityUnit.Gigawatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Kilowatt"/>
-        /// </summary>
-        public double Kilowatts => As(LuminosityUnit.Kilowatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Megawatt"/>
-        /// </summary>
-        public double Megawatts => As(LuminosityUnit.Megawatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Microwatt"/>
-        /// </summary>
-        public double Microwatts => As(LuminosityUnit.Microwatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Milliwatt"/>
-        /// </summary>
-        public double Milliwatts => As(LuminosityUnit.Milliwatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Nanowatt"/>
-        /// </summary>
-        public double Nanowatts => As(LuminosityUnit.Nanowatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Petawatt"/>
-        /// </summary>
-        public double Petawatts => As(LuminosityUnit.Petawatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Picowatt"/>
-        /// </summary>
-        public double Picowatts => As(LuminosityUnit.Picowatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.SolarLuminosity"/>
-        /// </summary>
-        public double SolarLuminosities => As(LuminosityUnit.SolarLuminosity);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Terawatt"/>
-        /// </summary>
-        public double Terawatts => As(LuminosityUnit.Terawatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Watt"/>
-        /// </summary>
-        public double Watts => As(LuminosityUnit.Watt);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Decawatt"/>.
-        /// </summary>
-        public static Luminosity FromDecawatts(double decawatts) => new Luminosity(decawatts, LuminosityUnit.Decawatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Deciwatt"/>.
-        /// </summary>
-        public static Luminosity FromDeciwatts(double deciwatts) => new Luminosity(deciwatts, LuminosityUnit.Deciwatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Femtowatt"/>.
-        /// </summary>
-        public static Luminosity FromFemtowatts(double femtowatts) => new Luminosity(femtowatts, LuminosityUnit.Femtowatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Gigawatt"/>.
-        /// </summary>
-        public static Luminosity FromGigawatts(double gigawatts) => new Luminosity(gigawatts, LuminosityUnit.Gigawatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Kilowatt"/>.
-        /// </summary>
-        public static Luminosity FromKilowatts(double kilowatts) => new Luminosity(kilowatts, LuminosityUnit.Kilowatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Megawatt"/>.
-        /// </summary>
-        public static Luminosity FromMegawatts(double megawatts) => new Luminosity(megawatts, LuminosityUnit.Megawatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Microwatt"/>.
-        /// </summary>
-        public static Luminosity FromMicrowatts(double microwatts) => new Luminosity(microwatts, LuminosityUnit.Microwatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Milliwatt"/>.
-        /// </summary>
-        public static Luminosity FromMilliwatts(double milliwatts) => new Luminosity(milliwatts, LuminosityUnit.Milliwatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Nanowatt"/>.
-        /// </summary>
-        public static Luminosity FromNanowatts(double nanowatts) => new Luminosity(nanowatts, LuminosityUnit.Nanowatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Petawatt"/>.
-        /// </summary>
-        public static Luminosity FromPetawatts(double petawatts) => new Luminosity(petawatts, LuminosityUnit.Petawatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Picowatt"/>.
-        /// </summary>
-        public static Luminosity FromPicowatts(double picowatts) => new Luminosity(picowatts, LuminosityUnit.Picowatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.SolarLuminosity"/>.
-        /// </summary>
-        public static Luminosity FromSolarLuminosities(double solarluminosities) => new Luminosity(solarluminosities, LuminosityUnit.SolarLuminosity);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Terawatt"/>.
-        /// </summary>
-        public static Luminosity FromTerawatts(double terawatts) => new Luminosity(terawatts, LuminosityUnit.Terawatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Watt"/>.
-        /// </summary>
-        public static Luminosity FromWatts(double watts) => new Luminosity(watts, LuminosityUnit.Watt);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LuminosityUnit" /> to <see cref="Luminosity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Luminosity unit value.</returns>
-        public static Luminosity From(double value, LuminosityUnit fromUnit)
-        {
-            return new Luminosity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(LuminosityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Luminosity to another Luminosity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Luminosity with the specified unit.</returns>
-                public Luminosity ToUnit(LuminosityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Luminosity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        LuminosityUnit.Decawatt => (_value) * 1e1d,
-                        LuminosityUnit.Deciwatt => (_value) * 1e-1d,
-                        LuminosityUnit.Femtowatt => (_value) * 1e-15d,
-                        LuminosityUnit.Gigawatt => (_value) * 1e9d,
-                        LuminosityUnit.Kilowatt => (_value) * 1e3d,
-                        LuminosityUnit.Megawatt => (_value) * 1e6d,
-                        LuminosityUnit.Microwatt => (_value) * 1e-6d,
-                        LuminosityUnit.Milliwatt => (_value) * 1e-3d,
-                        LuminosityUnit.Nanowatt => (_value) * 1e-9d,
-                        LuminosityUnit.Petawatt => (_value) * 1e15d,
-                        LuminosityUnit.Picowatt => (_value) * 1e-12d,
-                        LuminosityUnit.SolarLuminosity => _value * 3.828e26,
-                        LuminosityUnit.Terawatt => (_value) * 1e12d,
-                        LuminosityUnit.Watt => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(LuminosityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        LuminosityUnit.Decawatt => (baseUnitValue) / 1e1d,
-                        LuminosityUnit.Deciwatt => (baseUnitValue) / 1e-1d,
-                        LuminosityUnit.Femtowatt => (baseUnitValue) / 1e-15d,
-                        LuminosityUnit.Gigawatt => (baseUnitValue) / 1e9d,
-                        LuminosityUnit.Kilowatt => (baseUnitValue) / 1e3d,
-                        LuminosityUnit.Megawatt => (baseUnitValue) / 1e6d,
-                        LuminosityUnit.Microwatt => (baseUnitValue) / 1e-6d,
-                        LuminosityUnit.Milliwatt => (baseUnitValue) / 1e-3d,
-                        LuminosityUnit.Nanowatt => (baseUnitValue) / 1e-9d,
-                        LuminosityUnit.Petawatt => (baseUnitValue) / 1e15d,
-                        LuminosityUnit.Picowatt => (baseUnitValue) / 1e-12d,
-                        LuminosityUnit.SolarLuminosity => baseUnitValue / 3.828e26,
-                        LuminosityUnit.Terawatt => (baseUnitValue) / 1e12d,
-                        LuminosityUnit.Watt => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/LuminousFlux.g.cs
deleted file mode 100644
index 22fcdd609f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/LuminousFlux.g.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In photometry, luminous flux or luminous power is the measure of the perceived power of light.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Luminous_flux
-    /// </remarks>
-    public struct  LuminousFlux
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly LuminousFluxUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public LuminousFluxUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public LuminousFlux(double value, LuminousFluxUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of LuminousFlux, which is Second. All conversions go via this value.
-        /// </summary>
-        public static LuminousFluxUnit BaseUnit { get; } = LuminousFluxUnit.Lumen;
-
-        /// <summary>
-        /// Represents the largest possible value of LuminousFlux.
-        /// </summary>
-        public static LuminousFlux MaxValue { get; } = new LuminousFlux(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of LuminousFlux.
-        /// </summary>
-        public static LuminousFlux MinValue { get; } = new LuminousFlux(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static LuminousFlux Zero { get; } = new LuminousFlux(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminousFluxUnit.Lumen"/>
-        /// </summary>
-        public double Lumens => As(LuminousFluxUnit.Lumen);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="LuminousFlux"/> from <see cref="LuminousFluxUnit.Lumen"/>.
-        /// </summary>
-        public static LuminousFlux FromLumens(double lumens) => new LuminousFlux(lumens, LuminousFluxUnit.Lumen);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LuminousFluxUnit" /> to <see cref="LuminousFlux" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>LuminousFlux unit value.</returns>
-        public static LuminousFlux From(double value, LuminousFluxUnit fromUnit)
-        {
-            return new LuminousFlux(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(LuminousFluxUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this LuminousFlux to another LuminousFlux with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A LuminousFlux with the specified unit.</returns>
-                public LuminousFlux ToUnit(LuminousFluxUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new LuminousFlux(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        LuminousFluxUnit.Lumen => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(LuminousFluxUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        LuminousFluxUnit.Lumen => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/LuminousIntensity.g.cs
deleted file mode 100644
index c60f66ac21..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/LuminousIntensity.g.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In photometry, luminous intensity is a measure of the wavelength-weighted power emitted by a light source in a particular direction per unit solid angle, based on the luminosity function, a standardized model of the sensitivity of the human eye.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Luminous_intensity
-    /// </remarks>
-    public struct  LuminousIntensity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly LuminousIntensityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public LuminousIntensityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public LuminousIntensity(double value, LuminousIntensityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of LuminousIntensity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static LuminousIntensityUnit BaseUnit { get; } = LuminousIntensityUnit.Candela;
-
-        /// <summary>
-        /// Represents the largest possible value of LuminousIntensity.
-        /// </summary>
-        public static LuminousIntensity MaxValue { get; } = new LuminousIntensity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of LuminousIntensity.
-        /// </summary>
-        public static LuminousIntensity MinValue { get; } = new LuminousIntensity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static LuminousIntensity Zero { get; } = new LuminousIntensity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminousIntensityUnit.Candela"/>
-        /// </summary>
-        public double Candela => As(LuminousIntensityUnit.Candela);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="LuminousIntensity"/> from <see cref="LuminousIntensityUnit.Candela"/>.
-        /// </summary>
-        public static LuminousIntensity FromCandela(double candela) => new LuminousIntensity(candela, LuminousIntensityUnit.Candela);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="LuminousIntensityUnit" /> to <see cref="LuminousIntensity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>LuminousIntensity unit value.</returns>
-        public static LuminousIntensity From(double value, LuminousIntensityUnit fromUnit)
-        {
-            return new LuminousIntensity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(LuminousIntensityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this LuminousIntensity to another LuminousIntensity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A LuminousIntensity with the specified unit.</returns>
-                public LuminousIntensity ToUnit(LuminousIntensityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new LuminousIntensity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        LuminousIntensityUnit.Candela => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(LuminousIntensityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        LuminousIntensityUnit.Candela => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MagneticField.g.cs
deleted file mode 100644
index 3548210139..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MagneticField.g.cs
+++ /dev/null
@@ -1,220 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     A magnetic field is a force field that is created by moving electric charges (electric currents) and magnetic dipoles, and exerts a force on other nearby moving charges and magnetic dipoles.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Magnetic_field
-    /// </remarks>
-    public struct  MagneticField
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MagneticFieldUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MagneticFieldUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MagneticField(double value, MagneticFieldUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MagneticField, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MagneticFieldUnit BaseUnit { get; } = MagneticFieldUnit.Tesla;
-
-        /// <summary>
-        /// Represents the largest possible value of MagneticField.
-        /// </summary>
-        public static MagneticField MaxValue { get; } = new MagneticField(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MagneticField.
-        /// </summary>
-        public static MagneticField MinValue { get; } = new MagneticField(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MagneticField Zero { get; } = new MagneticField(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Gauss"/>
-        /// </summary>
-        public double Gausses => As(MagneticFieldUnit.Gauss);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Microtesla"/>
-        /// </summary>
-        public double Microteslas => As(MagneticFieldUnit.Microtesla);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Milligauss"/>
-        /// </summary>
-        public double Milligausses => As(MagneticFieldUnit.Milligauss);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Millitesla"/>
-        /// </summary>
-        public double Milliteslas => As(MagneticFieldUnit.Millitesla);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Nanotesla"/>
-        /// </summary>
-        public double Nanoteslas => As(MagneticFieldUnit.Nanotesla);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Tesla"/>
-        /// </summary>
-        public double Teslas => As(MagneticFieldUnit.Tesla);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Gauss"/>.
-        /// </summary>
-        public static MagneticField FromGausses(double gausses) => new MagneticField(gausses, MagneticFieldUnit.Gauss);
-
-        /// <summary>
-        ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Microtesla"/>.
-        /// </summary>
-        public static MagneticField FromMicroteslas(double microteslas) => new MagneticField(microteslas, MagneticFieldUnit.Microtesla);
-
-        /// <summary>
-        ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Milligauss"/>.
-        /// </summary>
-        public static MagneticField FromMilligausses(double milligausses) => new MagneticField(milligausses, MagneticFieldUnit.Milligauss);
-
-        /// <summary>
-        ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Millitesla"/>.
-        /// </summary>
-        public static MagneticField FromMilliteslas(double milliteslas) => new MagneticField(milliteslas, MagneticFieldUnit.Millitesla);
-
-        /// <summary>
-        ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Nanotesla"/>.
-        /// </summary>
-        public static MagneticField FromNanoteslas(double nanoteslas) => new MagneticField(nanoteslas, MagneticFieldUnit.Nanotesla);
-
-        /// <summary>
-        ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Tesla"/>.
-        /// </summary>
-        public static MagneticField FromTeslas(double teslas) => new MagneticField(teslas, MagneticFieldUnit.Tesla);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MagneticFieldUnit" /> to <see cref="MagneticField" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MagneticField unit value.</returns>
-        public static MagneticField From(double value, MagneticFieldUnit fromUnit)
-        {
-            return new MagneticField(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MagneticFieldUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MagneticField to another MagneticField with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MagneticField with the specified unit.</returns>
-                public MagneticField ToUnit(MagneticFieldUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MagneticField(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MagneticFieldUnit.Gauss => _value / 1e4,
-                        MagneticFieldUnit.Microtesla => (_value) * 1e-6d,
-                        MagneticFieldUnit.Milligauss => (_value / 1e4) * 1e-3d,
-                        MagneticFieldUnit.Millitesla => (_value) * 1e-3d,
-                        MagneticFieldUnit.Nanotesla => (_value) * 1e-9d,
-                        MagneticFieldUnit.Tesla => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MagneticFieldUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MagneticFieldUnit.Gauss => baseUnitValue * 1e4,
-                        MagneticFieldUnit.Microtesla => (baseUnitValue) / 1e-6d,
-                        MagneticFieldUnit.Milligauss => (baseUnitValue * 1e4) / 1e-3d,
-                        MagneticFieldUnit.Millitesla => (baseUnitValue) / 1e-3d,
-                        MagneticFieldUnit.Nanotesla => (baseUnitValue) / 1e-9d,
-                        MagneticFieldUnit.Tesla => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MagneticFlux.g.cs
deleted file mode 100644
index 03a5b66cd0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MagneticFlux.g.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In physics, specifically electromagnetism, the magnetic flux through a surface is the surface integral of the normal component of the magnetic field B passing through that surface.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Magnetic_flux
-    /// </remarks>
-    public struct  MagneticFlux
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MagneticFluxUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MagneticFluxUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MagneticFlux(double value, MagneticFluxUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MagneticFlux, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MagneticFluxUnit BaseUnit { get; } = MagneticFluxUnit.Weber;
-
-        /// <summary>
-        /// Represents the largest possible value of MagneticFlux.
-        /// </summary>
-        public static MagneticFlux MaxValue { get; } = new MagneticFlux(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MagneticFlux.
-        /// </summary>
-        public static MagneticFlux MinValue { get; } = new MagneticFlux(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MagneticFlux Zero { get; } = new MagneticFlux(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFluxUnit.Weber"/>
-        /// </summary>
-        public double Webers => As(MagneticFluxUnit.Weber);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MagneticFlux"/> from <see cref="MagneticFluxUnit.Weber"/>.
-        /// </summary>
-        public static MagneticFlux FromWebers(double webers) => new MagneticFlux(webers, MagneticFluxUnit.Weber);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MagneticFluxUnit" /> to <see cref="MagneticFlux" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MagneticFlux unit value.</returns>
-        public static MagneticFlux From(double value, MagneticFluxUnit fromUnit)
-        {
-            return new MagneticFlux(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MagneticFluxUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MagneticFlux to another MagneticFlux with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MagneticFlux with the specified unit.</returns>
-                public MagneticFlux ToUnit(MagneticFluxUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MagneticFlux(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MagneticFluxUnit.Weber => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MagneticFluxUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MagneticFluxUnit.Weber => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Magnetization.g.cs
deleted file mode 100644
index 225c4b3b4f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Magnetization.g.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In classical electromagnetism, magnetization is the vector field that expresses the density of permanent or induced magnetic dipole moments in a magnetic material.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Magnetization
-    /// </remarks>
-    public struct  Magnetization
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MagnetizationUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MagnetizationUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Magnetization(double value, MagnetizationUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Magnetization, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MagnetizationUnit BaseUnit { get; } = MagnetizationUnit.AmperePerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Magnetization.
-        /// </summary>
-        public static Magnetization MaxValue { get; } = new Magnetization(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Magnetization.
-        /// </summary>
-        public static Magnetization MinValue { get; } = new Magnetization(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Magnetization Zero { get; } = new Magnetization(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagnetizationUnit.AmperePerMeter"/>
-        /// </summary>
-        public double AmperesPerMeter => As(MagnetizationUnit.AmperePerMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Magnetization"/> from <see cref="MagnetizationUnit.AmperePerMeter"/>.
-        /// </summary>
-        public static Magnetization FromAmperesPerMeter(double amperespermeter) => new Magnetization(amperespermeter, MagnetizationUnit.AmperePerMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MagnetizationUnit" /> to <see cref="Magnetization" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Magnetization unit value.</returns>
-        public static Magnetization From(double value, MagnetizationUnit fromUnit)
-        {
-            return new Magnetization(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MagnetizationUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Magnetization to another Magnetization with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Magnetization with the specified unit.</returns>
-                public Magnetization ToUnit(MagnetizationUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Magnetization(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MagnetizationUnit.AmperePerMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MagnetizationUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MagnetizationUnit.AmperePerMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Mass.g.cs
deleted file mode 100644
index 1da423950f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Mass.g.cs
+++ /dev/null
@@ -1,517 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In physics, mass (from Greek μᾶζα "barley cake, lump [of dough]") is a property of a physical system or body, giving rise to the phenomena of the body's resistance to being accelerated by a force and the strength of its mutual gravitational attraction with other bodies. Instruments such as mass balances or scales use those phenomena to measure mass. The SI unit of mass is the kilogram (kg).
-    /// </summary>
-    public struct  Mass
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MassUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MassUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Mass(double value, MassUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Mass, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MassUnit BaseUnit { get; } = MassUnit.Kilogram;
-
-        /// <summary>
-        /// Represents the largest possible value of Mass.
-        /// </summary>
-        public static Mass MaxValue { get; } = new Mass(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Mass.
-        /// </summary>
-        public static Mass MinValue { get; } = new Mass(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Mass Zero { get; } = new Mass(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Centigram"/>
-        /// </summary>
-        public double Centigrams => As(MassUnit.Centigram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Dalton"/>
-        /// </summary>
-        public double Daltons => As(MassUnit.Dalton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Decagram"/>
-        /// </summary>
-        public double Decagrams => As(MassUnit.Decagram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Decigram"/>
-        /// </summary>
-        public double Decigrams => As(MassUnit.Decigram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.EarthMass"/>
-        /// </summary>
-        public double EarthMasses => As(MassUnit.EarthMass);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Femtogram"/>
-        /// </summary>
-        public double Femtograms => As(MassUnit.Femtogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Gigadalton"/>
-        /// </summary>
-        public double Gigadaltons => As(MassUnit.Gigadalton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Grain"/>
-        /// </summary>
-        public double Grains => As(MassUnit.Grain);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Gram"/>
-        /// </summary>
-        public double Grams => As(MassUnit.Gram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Hectogram"/>
-        /// </summary>
-        public double Hectograms => As(MassUnit.Hectogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Kilodalton"/>
-        /// </summary>
-        public double Kilodaltons => As(MassUnit.Kilodalton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Kilogram"/>
-        /// </summary>
-        public double Kilograms => As(MassUnit.Kilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Kilopound"/>
-        /// </summary>
-        public double Kilopounds => As(MassUnit.Kilopound);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Kilotonne"/>
-        /// </summary>
-        public double Kilotonnes => As(MassUnit.Kilotonne);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.LongHundredweight"/>
-        /// </summary>
-        public double LongHundredweight => As(MassUnit.LongHundredweight);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.LongTon"/>
-        /// </summary>
-        public double LongTons => As(MassUnit.LongTon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Megadalton"/>
-        /// </summary>
-        public double Megadaltons => As(MassUnit.Megadalton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Megapound"/>
-        /// </summary>
-        public double Megapounds => As(MassUnit.Megapound);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Megatonne"/>
-        /// </summary>
-        public double Megatonnes => As(MassUnit.Megatonne);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Microgram"/>
-        /// </summary>
-        public double Micrograms => As(MassUnit.Microgram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Milligram"/>
-        /// </summary>
-        public double Milligrams => As(MassUnit.Milligram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Nanogram"/>
-        /// </summary>
-        public double Nanograms => As(MassUnit.Nanogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Ounce"/>
-        /// </summary>
-        public double Ounces => As(MassUnit.Ounce);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Picogram"/>
-        /// </summary>
-        public double Picograms => As(MassUnit.Picogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Pound"/>
-        /// </summary>
-        public double Pounds => As(MassUnit.Pound);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.ShortHundredweight"/>
-        /// </summary>
-        public double ShortHundredweight => As(MassUnit.ShortHundredweight);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.ShortTon"/>
-        /// </summary>
-        public double ShortTons => As(MassUnit.ShortTon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Slug"/>
-        /// </summary>
-        public double Slugs => As(MassUnit.Slug);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.SolarMass"/>
-        /// </summary>
-        public double SolarMasses => As(MassUnit.SolarMass);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Stone"/>
-        /// </summary>
-        public double Stone => As(MassUnit.Stone);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Tonne"/>
-        /// </summary>
-        public double Tonnes => As(MassUnit.Tonne);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Centigram"/>.
-        /// </summary>
-        public static Mass FromCentigrams(double centigrams) => new Mass(centigrams, MassUnit.Centigram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Dalton"/>.
-        /// </summary>
-        public static Mass FromDaltons(double daltons) => new Mass(daltons, MassUnit.Dalton);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Decagram"/>.
-        /// </summary>
-        public static Mass FromDecagrams(double decagrams) => new Mass(decagrams, MassUnit.Decagram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Decigram"/>.
-        /// </summary>
-        public static Mass FromDecigrams(double decigrams) => new Mass(decigrams, MassUnit.Decigram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.EarthMass"/>.
-        /// </summary>
-        public static Mass FromEarthMasses(double earthmasses) => new Mass(earthmasses, MassUnit.EarthMass);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Femtogram"/>.
-        /// </summary>
-        public static Mass FromFemtograms(double femtograms) => new Mass(femtograms, MassUnit.Femtogram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Gigadalton"/>.
-        /// </summary>
-        public static Mass FromGigadaltons(double gigadaltons) => new Mass(gigadaltons, MassUnit.Gigadalton);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Grain"/>.
-        /// </summary>
-        public static Mass FromGrains(double grains) => new Mass(grains, MassUnit.Grain);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Gram"/>.
-        /// </summary>
-        public static Mass FromGrams(double grams) => new Mass(grams, MassUnit.Gram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Hectogram"/>.
-        /// </summary>
-        public static Mass FromHectograms(double hectograms) => new Mass(hectograms, MassUnit.Hectogram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilodalton"/>.
-        /// </summary>
-        public static Mass FromKilodaltons(double kilodaltons) => new Mass(kilodaltons, MassUnit.Kilodalton);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilogram"/>.
-        /// </summary>
-        public static Mass FromKilograms(double kilograms) => new Mass(kilograms, MassUnit.Kilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilopound"/>.
-        /// </summary>
-        public static Mass FromKilopounds(double kilopounds) => new Mass(kilopounds, MassUnit.Kilopound);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilotonne"/>.
-        /// </summary>
-        public static Mass FromKilotonnes(double kilotonnes) => new Mass(kilotonnes, MassUnit.Kilotonne);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.LongHundredweight"/>.
-        /// </summary>
-        public static Mass FromLongHundredweight(double longhundredweight) => new Mass(longhundredweight, MassUnit.LongHundredweight);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.LongTon"/>.
-        /// </summary>
-        public static Mass FromLongTons(double longtons) => new Mass(longtons, MassUnit.LongTon);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Megadalton"/>.
-        /// </summary>
-        public static Mass FromMegadaltons(double megadaltons) => new Mass(megadaltons, MassUnit.Megadalton);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Megapound"/>.
-        /// </summary>
-        public static Mass FromMegapounds(double megapounds) => new Mass(megapounds, MassUnit.Megapound);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Megatonne"/>.
-        /// </summary>
-        public static Mass FromMegatonnes(double megatonnes) => new Mass(megatonnes, MassUnit.Megatonne);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Microgram"/>.
-        /// </summary>
-        public static Mass FromMicrograms(double micrograms) => new Mass(micrograms, MassUnit.Microgram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Milligram"/>.
-        /// </summary>
-        public static Mass FromMilligrams(double milligrams) => new Mass(milligrams, MassUnit.Milligram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Nanogram"/>.
-        /// </summary>
-        public static Mass FromNanograms(double nanograms) => new Mass(nanograms, MassUnit.Nanogram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Ounce"/>.
-        /// </summary>
-        public static Mass FromOunces(double ounces) => new Mass(ounces, MassUnit.Ounce);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Picogram"/>.
-        /// </summary>
-        public static Mass FromPicograms(double picograms) => new Mass(picograms, MassUnit.Picogram);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Pound"/>.
-        /// </summary>
-        public static Mass FromPounds(double pounds) => new Mass(pounds, MassUnit.Pound);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.ShortHundredweight"/>.
-        /// </summary>
-        public static Mass FromShortHundredweight(double shorthundredweight) => new Mass(shorthundredweight, MassUnit.ShortHundredweight);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.ShortTon"/>.
-        /// </summary>
-        public static Mass FromShortTons(double shorttons) => new Mass(shorttons, MassUnit.ShortTon);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Slug"/>.
-        /// </summary>
-        public static Mass FromSlugs(double slugs) => new Mass(slugs, MassUnit.Slug);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.SolarMass"/>.
-        /// </summary>
-        public static Mass FromSolarMasses(double solarmasses) => new Mass(solarmasses, MassUnit.SolarMass);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Stone"/>.
-        /// </summary>
-        public static Mass FromStone(double stone) => new Mass(stone, MassUnit.Stone);
-
-        /// <summary>
-        ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Tonne"/>.
-        /// </summary>
-        public static Mass FromTonnes(double tonnes) => new Mass(tonnes, MassUnit.Tonne);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassUnit" /> to <see cref="Mass" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Mass unit value.</returns>
-        public static Mass From(double value, MassUnit fromUnit)
-        {
-            return new Mass(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MassUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Mass to another Mass with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Mass with the specified unit.</returns>
-                public Mass ToUnit(MassUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Mass(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MassUnit.Centigram => (_value / 1e3) * 1e-2d,
-                        MassUnit.Dalton => _value *  1.66053906660e-27,
-                        MassUnit.Decagram => (_value / 1e3) * 1e1d,
-                        MassUnit.Decigram => (_value / 1e3) * 1e-1d,
-                        MassUnit.EarthMass => _value * 5.9722E+24,
-                        MassUnit.Femtogram => (_value / 1e3) * 1e-15d,
-                        MassUnit.Gigadalton => (_value *  1.66053906660e-27) * 1e9d,
-                        MassUnit.Grain => _value * 64.79891e-6,
-                        MassUnit.Gram => _value / 1e3,
-                        MassUnit.Hectogram => (_value / 1e3) * 1e2d,
-                        MassUnit.Kilodalton => (_value *  1.66053906660e-27) * 1e3d,
-                        MassUnit.Kilogram => (_value / 1e3) * 1e3d,
-                        MassUnit.Kilopound => (_value * 0.45359237) * 1e3d,
-                        MassUnit.Kilotonne => (_value * 1e3) * 1e3d,
-                        MassUnit.LongHundredweight => _value * 50.80234544,
-                        MassUnit.LongTon => _value * 1016.0469088,
-                        MassUnit.Megadalton => (_value *  1.66053906660e-27) * 1e6d,
-                        MassUnit.Megapound => (_value * 0.45359237) * 1e6d,
-                        MassUnit.Megatonne => (_value * 1e3) * 1e6d,
-                        MassUnit.Microgram => (_value / 1e3) * 1e-6d,
-                        MassUnit.Milligram => (_value / 1e3) * 1e-3d,
-                        MassUnit.Nanogram => (_value / 1e3) * 1e-9d,
-                        MassUnit.Ounce => _value * 0.028349523125,
-                        MassUnit.Picogram => (_value / 1e3) * 1e-12d,
-                        MassUnit.Pound => _value * 0.45359237,
-                        MassUnit.ShortHundredweight => _value * 45.359237,
-                        MassUnit.ShortTon => _value * 907.18474,
-                        MassUnit.Slug => _value * 0.45359237 * 9.80665 / 0.3048,
-                        MassUnit.SolarMass => _value * 1.98947e30,
-                        MassUnit.Stone => _value * 6.35029318,
-                        MassUnit.Tonne => _value * 1e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MassUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MassUnit.Centigram => (baseUnitValue * 1e3) / 1e-2d,
-                        MassUnit.Dalton => baseUnitValue /  1.66053906660e-27,
-                        MassUnit.Decagram => (baseUnitValue * 1e3) / 1e1d,
-                        MassUnit.Decigram => (baseUnitValue * 1e3) / 1e-1d,
-                        MassUnit.EarthMass => baseUnitValue / 5.9722E+24,
-                        MassUnit.Femtogram => (baseUnitValue * 1e3) / 1e-15d,
-                        MassUnit.Gigadalton => (baseUnitValue /  1.66053906660e-27) / 1e9d,
-                        MassUnit.Grain => baseUnitValue / 64.79891e-6,
-                        MassUnit.Gram => baseUnitValue * 1e3,
-                        MassUnit.Hectogram => (baseUnitValue * 1e3) / 1e2d,
-                        MassUnit.Kilodalton => (baseUnitValue /  1.66053906660e-27) / 1e3d,
-                        MassUnit.Kilogram => (baseUnitValue * 1e3) / 1e3d,
-                        MassUnit.Kilopound => (baseUnitValue / 0.45359237) / 1e3d,
-                        MassUnit.Kilotonne => (baseUnitValue / 1e3) / 1e3d,
-                        MassUnit.LongHundredweight => baseUnitValue / 50.80234544,
-                        MassUnit.LongTon => baseUnitValue / 1016.0469088,
-                        MassUnit.Megadalton => (baseUnitValue /  1.66053906660e-27) / 1e6d,
-                        MassUnit.Megapound => (baseUnitValue / 0.45359237) / 1e6d,
-                        MassUnit.Megatonne => (baseUnitValue / 1e3) / 1e6d,
-                        MassUnit.Microgram => (baseUnitValue * 1e3) / 1e-6d,
-                        MassUnit.Milligram => (baseUnitValue * 1e3) / 1e-3d,
-                        MassUnit.Nanogram => (baseUnitValue * 1e3) / 1e-9d,
-                        MassUnit.Ounce => baseUnitValue / 0.028349523125,
-                        MassUnit.Picogram => (baseUnitValue * 1e3) / 1e-12d,
-                        MassUnit.Pound => baseUnitValue / 0.45359237,
-                        MassUnit.ShortHundredweight => baseUnitValue / 45.359237,
-                        MassUnit.ShortTon => baseUnitValue / 907.18474,
-                        MassUnit.Slug => baseUnitValue * 0.3048 / (0.45359237 * 9.80665),
-                        MassUnit.SolarMass => baseUnitValue / 1.98947e30,
-                        MassUnit.Stone => baseUnitValue / 6.35029318,
-                        MassUnit.Tonne => baseUnitValue / 1e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassConcentration.g.cs
deleted file mode 100644
index 3ef7bf6e66..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassConcentration.g.cs
+++ /dev/null
@@ -1,736 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In chemistry, the mass concentration ρi (or γi) is defined as the mass of a constituent mi divided by the volume of the mixture V
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Mass_concentration_(chemistry)
-    /// </remarks>
-    public struct  MassConcentration
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MassConcentrationUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MassConcentrationUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MassConcentration(double value, MassConcentrationUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MassConcentration, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MassConcentrationUnit BaseUnit { get; } = MassConcentrationUnit.KilogramPerCubicMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of MassConcentration.
-        /// </summary>
-        public static MassConcentration MaxValue { get; } = new MassConcentration(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MassConcentration.
-        /// </summary>
-        public static MassConcentration MinValue { get; } = new MassConcentration(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MassConcentration Zero { get; } = new MassConcentration(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerDeciliter"/>
-        /// </summary>
-        public double CentigramsPerDeciliter => As(MassConcentrationUnit.CentigramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerLiter"/>
-        /// </summary>
-        public double CentigramsPerLiter => As(MassConcentrationUnit.CentigramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerMicroliter"/>
-        /// </summary>
-        public double CentigramsPerMicroliter => As(MassConcentrationUnit.CentigramPerMicroliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerMilliliter"/>
-        /// </summary>
-        public double CentigramsPerMilliliter => As(MassConcentrationUnit.CentigramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerDeciliter"/>
-        /// </summary>
-        public double DecigramsPerDeciliter => As(MassConcentrationUnit.DecigramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerLiter"/>
-        /// </summary>
-        public double DecigramsPerLiter => As(MassConcentrationUnit.DecigramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerMicroliter"/>
-        /// </summary>
-        public double DecigramsPerMicroliter => As(MassConcentrationUnit.DecigramPerMicroliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerMilliliter"/>
-        /// </summary>
-        public double DecigramsPerMilliliter => As(MassConcentrationUnit.DecigramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerCubicCentimeter"/>
-        /// </summary>
-        public double GramsPerCubicCentimeter => As(MassConcentrationUnit.GramPerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerCubicMeter"/>
-        /// </summary>
-        public double GramsPerCubicMeter => As(MassConcentrationUnit.GramPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerCubicMillimeter"/>
-        /// </summary>
-        public double GramsPerCubicMillimeter => As(MassConcentrationUnit.GramPerCubicMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerDeciliter"/>
-        /// </summary>
-        public double GramsPerDeciliter => As(MassConcentrationUnit.GramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerLiter"/>
-        /// </summary>
-        public double GramsPerLiter => As(MassConcentrationUnit.GramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerMicroliter"/>
-        /// </summary>
-        public double GramsPerMicroliter => As(MassConcentrationUnit.GramPerMicroliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerMilliliter"/>
-        /// </summary>
-        public double GramsPerMilliliter => As(MassConcentrationUnit.GramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerCubicCentimeter"/>
-        /// </summary>
-        public double KilogramsPerCubicCentimeter => As(MassConcentrationUnit.KilogramPerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerCubicMeter"/>
-        /// </summary>
-        public double KilogramsPerCubicMeter => As(MassConcentrationUnit.KilogramPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerCubicMillimeter"/>
-        /// </summary>
-        public double KilogramsPerCubicMillimeter => As(MassConcentrationUnit.KilogramPerCubicMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerLiter"/>
-        /// </summary>
-        public double KilogramsPerLiter => As(MassConcentrationUnit.KilogramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilopoundPerCubicFoot"/>
-        /// </summary>
-        public double KilopoundsPerCubicFoot => As(MassConcentrationUnit.KilopoundPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilopoundPerCubicInch"/>
-        /// </summary>
-        public double KilopoundsPerCubicInch => As(MassConcentrationUnit.KilopoundPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerCubicMeter"/>
-        /// </summary>
-        public double MicrogramsPerCubicMeter => As(MassConcentrationUnit.MicrogramPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerDeciliter"/>
-        /// </summary>
-        public double MicrogramsPerDeciliter => As(MassConcentrationUnit.MicrogramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerLiter"/>
-        /// </summary>
-        public double MicrogramsPerLiter => As(MassConcentrationUnit.MicrogramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerMicroliter"/>
-        /// </summary>
-        public double MicrogramsPerMicroliter => As(MassConcentrationUnit.MicrogramPerMicroliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerMilliliter"/>
-        /// </summary>
-        public double MicrogramsPerMilliliter => As(MassConcentrationUnit.MicrogramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerCubicMeter"/>
-        /// </summary>
-        public double MilligramsPerCubicMeter => As(MassConcentrationUnit.MilligramPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerDeciliter"/>
-        /// </summary>
-        public double MilligramsPerDeciliter => As(MassConcentrationUnit.MilligramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerLiter"/>
-        /// </summary>
-        public double MilligramsPerLiter => As(MassConcentrationUnit.MilligramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerMicroliter"/>
-        /// </summary>
-        public double MilligramsPerMicroliter => As(MassConcentrationUnit.MilligramPerMicroliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerMilliliter"/>
-        /// </summary>
-        public double MilligramsPerMilliliter => As(MassConcentrationUnit.MilligramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerDeciliter"/>
-        /// </summary>
-        public double NanogramsPerDeciliter => As(MassConcentrationUnit.NanogramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerLiter"/>
-        /// </summary>
-        public double NanogramsPerLiter => As(MassConcentrationUnit.NanogramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerMicroliter"/>
-        /// </summary>
-        public double NanogramsPerMicroliter => As(MassConcentrationUnit.NanogramPerMicroliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerMilliliter"/>
-        /// </summary>
-        public double NanogramsPerMilliliter => As(MassConcentrationUnit.NanogramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.OuncePerImperialGallon"/>
-        /// </summary>
-        public double OuncesPerImperialGallon => As(MassConcentrationUnit.OuncePerImperialGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.OuncePerUSGallon"/>
-        /// </summary>
-        public double OuncesPerUSGallon => As(MassConcentrationUnit.OuncePerUSGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerDeciliter"/>
-        /// </summary>
-        public double PicogramsPerDeciliter => As(MassConcentrationUnit.PicogramPerDeciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerLiter"/>
-        /// </summary>
-        public double PicogramsPerLiter => As(MassConcentrationUnit.PicogramPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerMicroliter"/>
-        /// </summary>
-        public double PicogramsPerMicroliter => As(MassConcentrationUnit.PicogramPerMicroliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerMilliliter"/>
-        /// </summary>
-        public double PicogramsPerMilliliter => As(MassConcentrationUnit.PicogramPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerCubicFoot"/>
-        /// </summary>
-        public double PoundsPerCubicFoot => As(MassConcentrationUnit.PoundPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerCubicInch"/>
-        /// </summary>
-        public double PoundsPerCubicInch => As(MassConcentrationUnit.PoundPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerImperialGallon"/>
-        /// </summary>
-        public double PoundsPerImperialGallon => As(MassConcentrationUnit.PoundPerImperialGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerUSGallon"/>
-        /// </summary>
-        public double PoundsPerUSGallon => As(MassConcentrationUnit.PoundPerUSGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.SlugPerCubicFoot"/>
-        /// </summary>
-        public double SlugsPerCubicFoot => As(MassConcentrationUnit.SlugPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.TonnePerCubicCentimeter"/>
-        /// </summary>
-        public double TonnesPerCubicCentimeter => As(MassConcentrationUnit.TonnePerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.TonnePerCubicMeter"/>
-        /// </summary>
-        public double TonnesPerCubicMeter => As(MassConcentrationUnit.TonnePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.TonnePerCubicMillimeter"/>
-        /// </summary>
-        public double TonnesPerCubicMillimeter => As(MassConcentrationUnit.TonnePerCubicMillimeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerDeciliter"/>.
-        /// </summary>
-        public static MassConcentration FromCentigramsPerDeciliter(double centigramsperdeciliter) => new MassConcentration(centigramsperdeciliter, MassConcentrationUnit.CentigramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerLiter"/>.
-        /// </summary>
-        public static MassConcentration FromCentigramsPerLiter(double centigramsperliter) => new MassConcentration(centigramsperliter, MassConcentrationUnit.CentigramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerMicroliter"/>.
-        /// </summary>
-        public static MassConcentration FromCentigramsPerMicroliter(double centigramspermicroliter) => new MassConcentration(centigramspermicroliter, MassConcentrationUnit.CentigramPerMicroliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerMilliliter"/>.
-        /// </summary>
-        public static MassConcentration FromCentigramsPerMilliliter(double centigramspermilliliter) => new MassConcentration(centigramspermilliliter, MassConcentrationUnit.CentigramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerDeciliter"/>.
-        /// </summary>
-        public static MassConcentration FromDecigramsPerDeciliter(double decigramsperdeciliter) => new MassConcentration(decigramsperdeciliter, MassConcentrationUnit.DecigramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerLiter"/>.
-        /// </summary>
-        public static MassConcentration FromDecigramsPerLiter(double decigramsperliter) => new MassConcentration(decigramsperliter, MassConcentrationUnit.DecigramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerMicroliter"/>.
-        /// </summary>
-        public static MassConcentration FromDecigramsPerMicroliter(double decigramspermicroliter) => new MassConcentration(decigramspermicroliter, MassConcentrationUnit.DecigramPerMicroliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerMilliliter"/>.
-        /// </summary>
-        public static MassConcentration FromDecigramsPerMilliliter(double decigramspermilliliter) => new MassConcentration(decigramspermilliliter, MassConcentrationUnit.DecigramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicCentimeter"/>.
-        /// </summary>
-        public static MassConcentration FromGramsPerCubicCentimeter(double gramspercubiccentimeter) => new MassConcentration(gramspercubiccentimeter, MassConcentrationUnit.GramPerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicMeter"/>.
-        /// </summary>
-        public static MassConcentration FromGramsPerCubicMeter(double gramspercubicmeter) => new MassConcentration(gramspercubicmeter, MassConcentrationUnit.GramPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicMillimeter"/>.
-        /// </summary>
-        public static MassConcentration FromGramsPerCubicMillimeter(double gramspercubicmillimeter) => new MassConcentration(gramspercubicmillimeter, MassConcentrationUnit.GramPerCubicMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerDeciliter"/>.
-        /// </summary>
-        public static MassConcentration FromGramsPerDeciliter(double gramsperdeciliter) => new MassConcentration(gramsperdeciliter, MassConcentrationUnit.GramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerLiter"/>.
-        /// </summary>
-        public static MassConcentration FromGramsPerLiter(double gramsperliter) => new MassConcentration(gramsperliter, MassConcentrationUnit.GramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerMicroliter"/>.
-        /// </summary>
-        public static MassConcentration FromGramsPerMicroliter(double gramspermicroliter) => new MassConcentration(gramspermicroliter, MassConcentrationUnit.GramPerMicroliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerMilliliter"/>.
-        /// </summary>
-        public static MassConcentration FromGramsPerMilliliter(double gramspermilliliter) => new MassConcentration(gramspermilliliter, MassConcentrationUnit.GramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicCentimeter"/>.
-        /// </summary>
-        public static MassConcentration FromKilogramsPerCubicCentimeter(double kilogramspercubiccentimeter) => new MassConcentration(kilogramspercubiccentimeter, MassConcentrationUnit.KilogramPerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicMeter"/>.
-        /// </summary>
-        public static MassConcentration FromKilogramsPerCubicMeter(double kilogramspercubicmeter) => new MassConcentration(kilogramspercubicmeter, MassConcentrationUnit.KilogramPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicMillimeter"/>.
-        /// </summary>
-        public static MassConcentration FromKilogramsPerCubicMillimeter(double kilogramspercubicmillimeter) => new MassConcentration(kilogramspercubicmillimeter, MassConcentrationUnit.KilogramPerCubicMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerLiter"/>.
-        /// </summary>
-        public static MassConcentration FromKilogramsPerLiter(double kilogramsperliter) => new MassConcentration(kilogramsperliter, MassConcentrationUnit.KilogramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilopoundPerCubicFoot"/>.
-        /// </summary>
-        public static MassConcentration FromKilopoundsPerCubicFoot(double kilopoundspercubicfoot) => new MassConcentration(kilopoundspercubicfoot, MassConcentrationUnit.KilopoundPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilopoundPerCubicInch"/>.
-        /// </summary>
-        public static MassConcentration FromKilopoundsPerCubicInch(double kilopoundspercubicinch) => new MassConcentration(kilopoundspercubicinch, MassConcentrationUnit.KilopoundPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerCubicMeter"/>.
-        /// </summary>
-        public static MassConcentration FromMicrogramsPerCubicMeter(double microgramspercubicmeter) => new MassConcentration(microgramspercubicmeter, MassConcentrationUnit.MicrogramPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerDeciliter"/>.
-        /// </summary>
-        public static MassConcentration FromMicrogramsPerDeciliter(double microgramsperdeciliter) => new MassConcentration(microgramsperdeciliter, MassConcentrationUnit.MicrogramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerLiter"/>.
-        /// </summary>
-        public static MassConcentration FromMicrogramsPerLiter(double microgramsperliter) => new MassConcentration(microgramsperliter, MassConcentrationUnit.MicrogramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerMicroliter"/>.
-        /// </summary>
-        public static MassConcentration FromMicrogramsPerMicroliter(double microgramspermicroliter) => new MassConcentration(microgramspermicroliter, MassConcentrationUnit.MicrogramPerMicroliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerMilliliter"/>.
-        /// </summary>
-        public static MassConcentration FromMicrogramsPerMilliliter(double microgramspermilliliter) => new MassConcentration(microgramspermilliliter, MassConcentrationUnit.MicrogramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerCubicMeter"/>.
-        /// </summary>
-        public static MassConcentration FromMilligramsPerCubicMeter(double milligramspercubicmeter) => new MassConcentration(milligramspercubicmeter, MassConcentrationUnit.MilligramPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerDeciliter"/>.
-        /// </summary>
-        public static MassConcentration FromMilligramsPerDeciliter(double milligramsperdeciliter) => new MassConcentration(milligramsperdeciliter, MassConcentrationUnit.MilligramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerLiter"/>.
-        /// </summary>
-        public static MassConcentration FromMilligramsPerLiter(double milligramsperliter) => new MassConcentration(milligramsperliter, MassConcentrationUnit.MilligramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerMicroliter"/>.
-        /// </summary>
-        public static MassConcentration FromMilligramsPerMicroliter(double milligramspermicroliter) => new MassConcentration(milligramspermicroliter, MassConcentrationUnit.MilligramPerMicroliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerMilliliter"/>.
-        /// </summary>
-        public static MassConcentration FromMilligramsPerMilliliter(double milligramspermilliliter) => new MassConcentration(milligramspermilliliter, MassConcentrationUnit.MilligramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerDeciliter"/>.
-        /// </summary>
-        public static MassConcentration FromNanogramsPerDeciliter(double nanogramsperdeciliter) => new MassConcentration(nanogramsperdeciliter, MassConcentrationUnit.NanogramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerLiter"/>.
-        /// </summary>
-        public static MassConcentration FromNanogramsPerLiter(double nanogramsperliter) => new MassConcentration(nanogramsperliter, MassConcentrationUnit.NanogramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerMicroliter"/>.
-        /// </summary>
-        public static MassConcentration FromNanogramsPerMicroliter(double nanogramspermicroliter) => new MassConcentration(nanogramspermicroliter, MassConcentrationUnit.NanogramPerMicroliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerMilliliter"/>.
-        /// </summary>
-        public static MassConcentration FromNanogramsPerMilliliter(double nanogramspermilliliter) => new MassConcentration(nanogramspermilliliter, MassConcentrationUnit.NanogramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.OuncePerImperialGallon"/>.
-        /// </summary>
-        public static MassConcentration FromOuncesPerImperialGallon(double ouncesperimperialgallon) => new MassConcentration(ouncesperimperialgallon, MassConcentrationUnit.OuncePerImperialGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.OuncePerUSGallon"/>.
-        /// </summary>
-        public static MassConcentration FromOuncesPerUSGallon(double ouncesperusgallon) => new MassConcentration(ouncesperusgallon, MassConcentrationUnit.OuncePerUSGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerDeciliter"/>.
-        /// </summary>
-        public static MassConcentration FromPicogramsPerDeciliter(double picogramsperdeciliter) => new MassConcentration(picogramsperdeciliter, MassConcentrationUnit.PicogramPerDeciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerLiter"/>.
-        /// </summary>
-        public static MassConcentration FromPicogramsPerLiter(double picogramsperliter) => new MassConcentration(picogramsperliter, MassConcentrationUnit.PicogramPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerMicroliter"/>.
-        /// </summary>
-        public static MassConcentration FromPicogramsPerMicroliter(double picogramspermicroliter) => new MassConcentration(picogramspermicroliter, MassConcentrationUnit.PicogramPerMicroliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerMilliliter"/>.
-        /// </summary>
-        public static MassConcentration FromPicogramsPerMilliliter(double picogramspermilliliter) => new MassConcentration(picogramspermilliliter, MassConcentrationUnit.PicogramPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerCubicFoot"/>.
-        /// </summary>
-        public static MassConcentration FromPoundsPerCubicFoot(double poundspercubicfoot) => new MassConcentration(poundspercubicfoot, MassConcentrationUnit.PoundPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerCubicInch"/>.
-        /// </summary>
-        public static MassConcentration FromPoundsPerCubicInch(double poundspercubicinch) => new MassConcentration(poundspercubicinch, MassConcentrationUnit.PoundPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerImperialGallon"/>.
-        /// </summary>
-        public static MassConcentration FromPoundsPerImperialGallon(double poundsperimperialgallon) => new MassConcentration(poundsperimperialgallon, MassConcentrationUnit.PoundPerImperialGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerUSGallon"/>.
-        /// </summary>
-        public static MassConcentration FromPoundsPerUSGallon(double poundsperusgallon) => new MassConcentration(poundsperusgallon, MassConcentrationUnit.PoundPerUSGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.SlugPerCubicFoot"/>.
-        /// </summary>
-        public static MassConcentration FromSlugsPerCubicFoot(double slugspercubicfoot) => new MassConcentration(slugspercubicfoot, MassConcentrationUnit.SlugPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicCentimeter"/>.
-        /// </summary>
-        public static MassConcentration FromTonnesPerCubicCentimeter(double tonnespercubiccentimeter) => new MassConcentration(tonnespercubiccentimeter, MassConcentrationUnit.TonnePerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicMeter"/>.
-        /// </summary>
-        public static MassConcentration FromTonnesPerCubicMeter(double tonnespercubicmeter) => new MassConcentration(tonnespercubicmeter, MassConcentrationUnit.TonnePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicMillimeter"/>.
-        /// </summary>
-        public static MassConcentration FromTonnesPerCubicMillimeter(double tonnespercubicmillimeter) => new MassConcentration(tonnespercubicmillimeter, MassConcentrationUnit.TonnePerCubicMillimeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassConcentrationUnit" /> to <see cref="MassConcentration" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MassConcentration unit value.</returns>
-        public static MassConcentration From(double value, MassConcentrationUnit fromUnit)
-        {
-            return new MassConcentration(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MassConcentrationUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MassConcentration to another MassConcentration with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MassConcentration with the specified unit.</returns>
-                public MassConcentration ToUnit(MassConcentrationUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MassConcentration(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MassConcentrationUnit.CentigramPerDeciliter => (_value / 1e-1) * 1e-2d,
-                        MassConcentrationUnit.CentigramPerLiter => (_value) * 1e-2d,
-                        MassConcentrationUnit.CentigramPerMicroliter => (_value / 1e-6) * 1e-2d,
-                        MassConcentrationUnit.CentigramPerMilliliter => (_value / 1e-3) * 1e-2d,
-                        MassConcentrationUnit.DecigramPerDeciliter => (_value / 1e-1) * 1e-1d,
-                        MassConcentrationUnit.DecigramPerLiter => (_value) * 1e-1d,
-                        MassConcentrationUnit.DecigramPerMicroliter => (_value / 1e-6) * 1e-1d,
-                        MassConcentrationUnit.DecigramPerMilliliter => (_value / 1e-3) * 1e-1d,
-                        MassConcentrationUnit.GramPerCubicCentimeter => _value / 1e-3,
-                        MassConcentrationUnit.GramPerCubicMeter => _value / 1e3,
-                        MassConcentrationUnit.GramPerCubicMillimeter => _value / 1e-6,
-                        MassConcentrationUnit.GramPerDeciliter => _value / 1e-1,
-                        MassConcentrationUnit.GramPerLiter => _value,
-                        MassConcentrationUnit.GramPerMicroliter => _value / 1e-6,
-                        MassConcentrationUnit.GramPerMilliliter => _value / 1e-3,
-                        MassConcentrationUnit.KilogramPerCubicCentimeter => (_value / 1e-3) * 1e3d,
-                        MassConcentrationUnit.KilogramPerCubicMeter => (_value / 1e3) * 1e3d,
-                        MassConcentrationUnit.KilogramPerCubicMillimeter => (_value / 1e-6) * 1e3d,
-                        MassConcentrationUnit.KilogramPerLiter => (_value) * 1e3d,
-                        MassConcentrationUnit.KilopoundPerCubicFoot => (_value * 0.45359237 / 0.028316846592) * 1e3d,
-                        MassConcentrationUnit.KilopoundPerCubicInch => (_value * 0.45359237 / 1.6387064e-5) * 1e3d,
-                        MassConcentrationUnit.MicrogramPerCubicMeter => (_value / 1e3) * 1e-6d,
-                        MassConcentrationUnit.MicrogramPerDeciliter => (_value / 1e-1) * 1e-6d,
-                        MassConcentrationUnit.MicrogramPerLiter => (_value) * 1e-6d,
-                        MassConcentrationUnit.MicrogramPerMicroliter => (_value / 1e-6) * 1e-6d,
-                        MassConcentrationUnit.MicrogramPerMilliliter => (_value / 1e-3) * 1e-6d,
-                        MassConcentrationUnit.MilligramPerCubicMeter => (_value / 1e3) * 1e-3d,
-                        MassConcentrationUnit.MilligramPerDeciliter => (_value / 1e-1) * 1e-3d,
-                        MassConcentrationUnit.MilligramPerLiter => (_value) * 1e-3d,
-                        MassConcentrationUnit.MilligramPerMicroliter => (_value / 1e-6) * 1e-3d,
-                        MassConcentrationUnit.MilligramPerMilliliter => (_value / 1e-3) * 1e-3d,
-                        MassConcentrationUnit.NanogramPerDeciliter => (_value / 1e-1) * 1e-9d,
-                        MassConcentrationUnit.NanogramPerLiter => (_value) * 1e-9d,
-                        MassConcentrationUnit.NanogramPerMicroliter => (_value / 1e-6) * 1e-9d,
-                        MassConcentrationUnit.NanogramPerMilliliter => (_value / 1e-3) * 1e-9d,
-                        MassConcentrationUnit.OuncePerImperialGallon => _value * 0.028349523125 / 0.00454609,
-                        MassConcentrationUnit.OuncePerUSGallon => _value * 0.028349523125 / 0.003785411784,
-                        MassConcentrationUnit.PicogramPerDeciliter => (_value / 1e-1) * 1e-12d,
-                        MassConcentrationUnit.PicogramPerLiter => (_value) * 1e-12d,
-                        MassConcentrationUnit.PicogramPerMicroliter => (_value / 1e-6) * 1e-12d,
-                        MassConcentrationUnit.PicogramPerMilliliter => (_value / 1e-3) * 1e-12d,
-                        MassConcentrationUnit.PoundPerCubicFoot => _value * 0.45359237 / 0.028316846592,
-                        MassConcentrationUnit.PoundPerCubicInch => _value * 0.45359237 / 1.6387064e-5,
-                        MassConcentrationUnit.PoundPerImperialGallon => _value * 0.45359237 / 0.00454609,
-                        MassConcentrationUnit.PoundPerUSGallon => _value * 0.45359237 / 0.003785411784,
-                        MassConcentrationUnit.SlugPerCubicFoot => _value * (0.45359237 * 9.80665) / (0.3048 * 0.028316846592),
-                        MassConcentrationUnit.TonnePerCubicCentimeter => _value / 1e-9,
-                        MassConcentrationUnit.TonnePerCubicMeter => _value / 0.001,
-                        MassConcentrationUnit.TonnePerCubicMillimeter => _value / 1e-12,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MassConcentrationUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MassConcentrationUnit.CentigramPerDeciliter => (baseUnitValue * 1e-1) / 1e-2d,
-                        MassConcentrationUnit.CentigramPerLiter => (baseUnitValue) / 1e-2d,
-                        MassConcentrationUnit.CentigramPerMicroliter => (baseUnitValue * 1e-6) / 1e-2d,
-                        MassConcentrationUnit.CentigramPerMilliliter => (baseUnitValue * 1e-3) / 1e-2d,
-                        MassConcentrationUnit.DecigramPerDeciliter => (baseUnitValue * 1e-1) / 1e-1d,
-                        MassConcentrationUnit.DecigramPerLiter => (baseUnitValue) / 1e-1d,
-                        MassConcentrationUnit.DecigramPerMicroliter => (baseUnitValue * 1e-6) / 1e-1d,
-                        MassConcentrationUnit.DecigramPerMilliliter => (baseUnitValue * 1e-3) / 1e-1d,
-                        MassConcentrationUnit.GramPerCubicCentimeter => baseUnitValue * 1e-3,
-                        MassConcentrationUnit.GramPerCubicMeter => baseUnitValue * 1e3,
-                        MassConcentrationUnit.GramPerCubicMillimeter => baseUnitValue * 1e-6,
-                        MassConcentrationUnit.GramPerDeciliter => baseUnitValue * 1e-1,
-                        MassConcentrationUnit.GramPerLiter => baseUnitValue,
-                        MassConcentrationUnit.GramPerMicroliter => baseUnitValue * 1e-6,
-                        MassConcentrationUnit.GramPerMilliliter => baseUnitValue * 1e-3,
-                        MassConcentrationUnit.KilogramPerCubicCentimeter => (baseUnitValue * 1e-3) / 1e3d,
-                        MassConcentrationUnit.KilogramPerCubicMeter => (baseUnitValue * 1e3) / 1e3d,
-                        MassConcentrationUnit.KilogramPerCubicMillimeter => (baseUnitValue * 1e-6) / 1e3d,
-                        MassConcentrationUnit.KilogramPerLiter => (baseUnitValue) / 1e3d,
-                        MassConcentrationUnit.KilopoundPerCubicFoot => (baseUnitValue * 0.028316846592 / 0.45359237) / 1e3d,
-                        MassConcentrationUnit.KilopoundPerCubicInch => (baseUnitValue * 1.6387064e-5 / 0.45359237) / 1e3d,
-                        MassConcentrationUnit.MicrogramPerCubicMeter => (baseUnitValue * 1e3) / 1e-6d,
-                        MassConcentrationUnit.MicrogramPerDeciliter => (baseUnitValue * 1e-1) / 1e-6d,
-                        MassConcentrationUnit.MicrogramPerLiter => (baseUnitValue) / 1e-6d,
-                        MassConcentrationUnit.MicrogramPerMicroliter => (baseUnitValue * 1e-6) / 1e-6d,
-                        MassConcentrationUnit.MicrogramPerMilliliter => (baseUnitValue * 1e-3) / 1e-6d,
-                        MassConcentrationUnit.MilligramPerCubicMeter => (baseUnitValue * 1e3) / 1e-3d,
-                        MassConcentrationUnit.MilligramPerDeciliter => (baseUnitValue * 1e-1) / 1e-3d,
-                        MassConcentrationUnit.MilligramPerLiter => (baseUnitValue) / 1e-3d,
-                        MassConcentrationUnit.MilligramPerMicroliter => (baseUnitValue * 1e-6) / 1e-3d,
-                        MassConcentrationUnit.MilligramPerMilliliter => (baseUnitValue * 1e-3) / 1e-3d,
-                        MassConcentrationUnit.NanogramPerDeciliter => (baseUnitValue * 1e-1) / 1e-9d,
-                        MassConcentrationUnit.NanogramPerLiter => (baseUnitValue) / 1e-9d,
-                        MassConcentrationUnit.NanogramPerMicroliter => (baseUnitValue * 1e-6) / 1e-9d,
-                        MassConcentrationUnit.NanogramPerMilliliter => (baseUnitValue * 1e-3) / 1e-9d,
-                        MassConcentrationUnit.OuncePerImperialGallon => baseUnitValue * 0.00454609 / 0.028349523125,
-                        MassConcentrationUnit.OuncePerUSGallon => baseUnitValue * 0.003785411784 / 0.028349523125,
-                        MassConcentrationUnit.PicogramPerDeciliter => (baseUnitValue * 1e-1) / 1e-12d,
-                        MassConcentrationUnit.PicogramPerLiter => (baseUnitValue) / 1e-12d,
-                        MassConcentrationUnit.PicogramPerMicroliter => (baseUnitValue * 1e-6) / 1e-12d,
-                        MassConcentrationUnit.PicogramPerMilliliter => (baseUnitValue * 1e-3) / 1e-12d,
-                        MassConcentrationUnit.PoundPerCubicFoot => baseUnitValue * 0.028316846592 / 0.45359237,
-                        MassConcentrationUnit.PoundPerCubicInch => baseUnitValue * 1.6387064e-5 / 0.45359237,
-                        MassConcentrationUnit.PoundPerImperialGallon => baseUnitValue * 0.00454609 / 0.45359237,
-                        MassConcentrationUnit.PoundPerUSGallon => baseUnitValue * 0.003785411784 / 0.45359237,
-                        MassConcentrationUnit.SlugPerCubicFoot => baseUnitValue * (0.3048 * 0.028316846592) / (0.45359237 * 9.80665),
-                        MassConcentrationUnit.TonnePerCubicCentimeter => baseUnitValue * 1e-9,
-                        MassConcentrationUnit.TonnePerCubicMeter => baseUnitValue * 0.001,
-                        MassConcentrationUnit.TonnePerCubicMillimeter => baseUnitValue * 1e-12,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassFlow.g.cs
deleted file mode 100644
index d6812a6347..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassFlow.g.cs
+++ /dev/null
@@ -1,541 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Mass flow is the ratio of the mass change to the time during which the change occurred (value of mass changes per unit time).
-    /// </summary>
-    public struct  MassFlow
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MassFlowUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MassFlowUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MassFlow(double value, MassFlowUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MassFlow, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MassFlowUnit BaseUnit { get; } = MassFlowUnit.GramPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of MassFlow.
-        /// </summary>
-        public static MassFlow MaxValue { get; } = new MassFlow(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MassFlow.
-        /// </summary>
-        public static MassFlow MinValue { get; } = new MassFlow(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MassFlow Zero { get; } = new MassFlow(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.CentigramPerDay"/>
-        /// </summary>
-        public double CentigramsPerDay => As(MassFlowUnit.CentigramPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.CentigramPerSecond"/>
-        /// </summary>
-        public double CentigramsPerSecond => As(MassFlowUnit.CentigramPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.DecagramPerDay"/>
-        /// </summary>
-        public double DecagramsPerDay => As(MassFlowUnit.DecagramPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.DecagramPerSecond"/>
-        /// </summary>
-        public double DecagramsPerSecond => As(MassFlowUnit.DecagramPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.DecigramPerDay"/>
-        /// </summary>
-        public double DecigramsPerDay => As(MassFlowUnit.DecigramPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.DecigramPerSecond"/>
-        /// </summary>
-        public double DecigramsPerSecond => As(MassFlowUnit.DecigramPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.GramPerDay"/>
-        /// </summary>
-        public double GramsPerDay => As(MassFlowUnit.GramPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.GramPerHour"/>
-        /// </summary>
-        public double GramsPerHour => As(MassFlowUnit.GramPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.GramPerSecond"/>
-        /// </summary>
-        public double GramsPerSecond => As(MassFlowUnit.GramPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.HectogramPerDay"/>
-        /// </summary>
-        public double HectogramsPerDay => As(MassFlowUnit.HectogramPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.HectogramPerSecond"/>
-        /// </summary>
-        public double HectogramsPerSecond => As(MassFlowUnit.HectogramPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerDay"/>
-        /// </summary>
-        public double KilogramsPerDay => As(MassFlowUnit.KilogramPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerHour"/>
-        /// </summary>
-        public double KilogramsPerHour => As(MassFlowUnit.KilogramPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerMinute"/>
-        /// </summary>
-        public double KilogramsPerMinute => As(MassFlowUnit.KilogramPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerSecond"/>
-        /// </summary>
-        public double KilogramsPerSecond => As(MassFlowUnit.KilogramPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MegagramPerDay"/>
-        /// </summary>
-        public double MegagramsPerDay => As(MassFlowUnit.MegagramPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerDay"/>
-        /// </summary>
-        public double MegapoundsPerDay => As(MassFlowUnit.MegapoundPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerHour"/>
-        /// </summary>
-        public double MegapoundsPerHour => As(MassFlowUnit.MegapoundPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerMinute"/>
-        /// </summary>
-        public double MegapoundsPerMinute => As(MassFlowUnit.MegapoundPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerSecond"/>
-        /// </summary>
-        public double MegapoundsPerSecond => As(MassFlowUnit.MegapoundPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MicrogramPerDay"/>
-        /// </summary>
-        public double MicrogramsPerDay => As(MassFlowUnit.MicrogramPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MicrogramPerSecond"/>
-        /// </summary>
-        public double MicrogramsPerSecond => As(MassFlowUnit.MicrogramPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MilligramPerDay"/>
-        /// </summary>
-        public double MilligramsPerDay => As(MassFlowUnit.MilligramPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MilligramPerSecond"/>
-        /// </summary>
-        public double MilligramsPerSecond => As(MassFlowUnit.MilligramPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.NanogramPerDay"/>
-        /// </summary>
-        public double NanogramsPerDay => As(MassFlowUnit.NanogramPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.NanogramPerSecond"/>
-        /// </summary>
-        public double NanogramsPerSecond => As(MassFlowUnit.NanogramPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerDay"/>
-        /// </summary>
-        public double PoundsPerDay => As(MassFlowUnit.PoundPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerHour"/>
-        /// </summary>
-        public double PoundsPerHour => As(MassFlowUnit.PoundPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerMinute"/>
-        /// </summary>
-        public double PoundsPerMinute => As(MassFlowUnit.PoundPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerSecond"/>
-        /// </summary>
-        public double PoundsPerSecond => As(MassFlowUnit.PoundPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.ShortTonPerHour"/>
-        /// </summary>
-        public double ShortTonsPerHour => As(MassFlowUnit.ShortTonPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.TonnePerDay"/>
-        /// </summary>
-        public double TonnesPerDay => As(MassFlowUnit.TonnePerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.TonnePerHour"/>
-        /// </summary>
-        public double TonnesPerHour => As(MassFlowUnit.TonnePerHour);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.CentigramPerDay"/>.
-        /// </summary>
-        public static MassFlow FromCentigramsPerDay(double centigramsperday) => new MassFlow(centigramsperday, MassFlowUnit.CentigramPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.CentigramPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromCentigramsPerSecond(double centigramspersecond) => new MassFlow(centigramspersecond, MassFlowUnit.CentigramPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecagramPerDay"/>.
-        /// </summary>
-        public static MassFlow FromDecagramsPerDay(double decagramsperday) => new MassFlow(decagramsperday, MassFlowUnit.DecagramPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecagramPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromDecagramsPerSecond(double decagramspersecond) => new MassFlow(decagramspersecond, MassFlowUnit.DecagramPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecigramPerDay"/>.
-        /// </summary>
-        public static MassFlow FromDecigramsPerDay(double decigramsperday) => new MassFlow(decigramsperday, MassFlowUnit.DecigramPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecigramPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromDecigramsPerSecond(double decigramspersecond) => new MassFlow(decigramspersecond, MassFlowUnit.DecigramPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerDay"/>.
-        /// </summary>
-        public static MassFlow FromGramsPerDay(double gramsperday) => new MassFlow(gramsperday, MassFlowUnit.GramPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerHour"/>.
-        /// </summary>
-        public static MassFlow FromGramsPerHour(double gramsperhour) => new MassFlow(gramsperhour, MassFlowUnit.GramPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromGramsPerSecond(double gramspersecond) => new MassFlow(gramspersecond, MassFlowUnit.GramPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.HectogramPerDay"/>.
-        /// </summary>
-        public static MassFlow FromHectogramsPerDay(double hectogramsperday) => new MassFlow(hectogramsperday, MassFlowUnit.HectogramPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.HectogramPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromHectogramsPerSecond(double hectogramspersecond) => new MassFlow(hectogramspersecond, MassFlowUnit.HectogramPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerDay"/>.
-        /// </summary>
-        public static MassFlow FromKilogramsPerDay(double kilogramsperday) => new MassFlow(kilogramsperday, MassFlowUnit.KilogramPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerHour"/>.
-        /// </summary>
-        public static MassFlow FromKilogramsPerHour(double kilogramsperhour) => new MassFlow(kilogramsperhour, MassFlowUnit.KilogramPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerMinute"/>.
-        /// </summary>
-        public static MassFlow FromKilogramsPerMinute(double kilogramsperminute) => new MassFlow(kilogramsperminute, MassFlowUnit.KilogramPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromKilogramsPerSecond(double kilogramspersecond) => new MassFlow(kilogramspersecond, MassFlowUnit.KilogramPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegagramPerDay"/>.
-        /// </summary>
-        public static MassFlow FromMegagramsPerDay(double megagramsperday) => new MassFlow(megagramsperday, MassFlowUnit.MegagramPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerDay"/>.
-        /// </summary>
-        public static MassFlow FromMegapoundsPerDay(double megapoundsperday) => new MassFlow(megapoundsperday, MassFlowUnit.MegapoundPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerHour"/>.
-        /// </summary>
-        public static MassFlow FromMegapoundsPerHour(double megapoundsperhour) => new MassFlow(megapoundsperhour, MassFlowUnit.MegapoundPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerMinute"/>.
-        /// </summary>
-        public static MassFlow FromMegapoundsPerMinute(double megapoundsperminute) => new MassFlow(megapoundsperminute, MassFlowUnit.MegapoundPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromMegapoundsPerSecond(double megapoundspersecond) => new MassFlow(megapoundspersecond, MassFlowUnit.MegapoundPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MicrogramPerDay"/>.
-        /// </summary>
-        public static MassFlow FromMicrogramsPerDay(double microgramsperday) => new MassFlow(microgramsperday, MassFlowUnit.MicrogramPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MicrogramPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromMicrogramsPerSecond(double microgramspersecond) => new MassFlow(microgramspersecond, MassFlowUnit.MicrogramPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MilligramPerDay"/>.
-        /// </summary>
-        public static MassFlow FromMilligramsPerDay(double milligramsperday) => new MassFlow(milligramsperday, MassFlowUnit.MilligramPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MilligramPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromMilligramsPerSecond(double milligramspersecond) => new MassFlow(milligramspersecond, MassFlowUnit.MilligramPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.NanogramPerDay"/>.
-        /// </summary>
-        public static MassFlow FromNanogramsPerDay(double nanogramsperday) => new MassFlow(nanogramsperday, MassFlowUnit.NanogramPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.NanogramPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromNanogramsPerSecond(double nanogramspersecond) => new MassFlow(nanogramspersecond, MassFlowUnit.NanogramPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerDay"/>.
-        /// </summary>
-        public static MassFlow FromPoundsPerDay(double poundsperday) => new MassFlow(poundsperday, MassFlowUnit.PoundPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerHour"/>.
-        /// </summary>
-        public static MassFlow FromPoundsPerHour(double poundsperhour) => new MassFlow(poundsperhour, MassFlowUnit.PoundPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerMinute"/>.
-        /// </summary>
-        public static MassFlow FromPoundsPerMinute(double poundsperminute) => new MassFlow(poundsperminute, MassFlowUnit.PoundPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerSecond"/>.
-        /// </summary>
-        public static MassFlow FromPoundsPerSecond(double poundspersecond) => new MassFlow(poundspersecond, MassFlowUnit.PoundPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.ShortTonPerHour"/>.
-        /// </summary>
-        public static MassFlow FromShortTonsPerHour(double shorttonsperhour) => new MassFlow(shorttonsperhour, MassFlowUnit.ShortTonPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.TonnePerDay"/>.
-        /// </summary>
-        public static MassFlow FromTonnesPerDay(double tonnesperday) => new MassFlow(tonnesperday, MassFlowUnit.TonnePerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.TonnePerHour"/>.
-        /// </summary>
-        public static MassFlow FromTonnesPerHour(double tonnesperhour) => new MassFlow(tonnesperhour, MassFlowUnit.TonnePerHour);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassFlowUnit" /> to <see cref="MassFlow" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MassFlow unit value.</returns>
-        public static MassFlow From(double value, MassFlowUnit fromUnit)
-        {
-            return new MassFlow(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MassFlowUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MassFlow to another MassFlow with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MassFlow with the specified unit.</returns>
-                public MassFlow ToUnit(MassFlowUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MassFlow(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MassFlowUnit.CentigramPerDay => (_value / 86400) * 1e-2d,
-                        MassFlowUnit.CentigramPerSecond => (_value) * 1e-2d,
-                        MassFlowUnit.DecagramPerDay => (_value / 86400) * 1e1d,
-                        MassFlowUnit.DecagramPerSecond => (_value) * 1e1d,
-                        MassFlowUnit.DecigramPerDay => (_value / 86400) * 1e-1d,
-                        MassFlowUnit.DecigramPerSecond => (_value) * 1e-1d,
-                        MassFlowUnit.GramPerDay => _value / 86400,
-                        MassFlowUnit.GramPerHour => _value / 3600,
-                        MassFlowUnit.GramPerSecond => _value,
-                        MassFlowUnit.HectogramPerDay => (_value / 86400) * 1e2d,
-                        MassFlowUnit.HectogramPerSecond => (_value) * 1e2d,
-                        MassFlowUnit.KilogramPerDay => (_value / 86400) * 1e3d,
-                        MassFlowUnit.KilogramPerHour => _value / 3.6,
-                        MassFlowUnit.KilogramPerMinute => _value / 0.06,
-                        MassFlowUnit.KilogramPerSecond => (_value) * 1e3d,
-                        MassFlowUnit.MegagramPerDay => (_value / 86400) * 1e6d,
-                        MassFlowUnit.MegapoundPerDay => (_value * 453.59237 / 86400) * 1e6d,
-                        MassFlowUnit.MegapoundPerHour => (_value * 453.59237 / 3600) * 1e6d,
-                        MassFlowUnit.MegapoundPerMinute => (_value * 453.59237 / 60) * 1e6d,
-                        MassFlowUnit.MegapoundPerSecond => (_value * 453.59237) * 1e6d,
-                        MassFlowUnit.MicrogramPerDay => (_value / 86400) * 1e-6d,
-                        MassFlowUnit.MicrogramPerSecond => (_value) * 1e-6d,
-                        MassFlowUnit.MilligramPerDay => (_value / 86400) * 1e-3d,
-                        MassFlowUnit.MilligramPerSecond => (_value) * 1e-3d,
-                        MassFlowUnit.NanogramPerDay => (_value / 86400) * 1e-9d,
-                        MassFlowUnit.NanogramPerSecond => (_value) * 1e-9d,
-                        MassFlowUnit.PoundPerDay => _value * 453.59237 / 86400,
-                        MassFlowUnit.PoundPerHour => _value * 453.59237 / 3600,
-                        MassFlowUnit.PoundPerMinute => _value * 453.59237 / 60,
-                        MassFlowUnit.PoundPerSecond => _value * 453.59237,
-                        MassFlowUnit.ShortTonPerHour => _value * 907.18474 / 3.6,
-                        MassFlowUnit.TonnePerDay => _value / 0.0864000,
-                        MassFlowUnit.TonnePerHour => _value * 1000 / 3.6,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MassFlowUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MassFlowUnit.CentigramPerDay => (baseUnitValue * 86400) / 1e-2d,
-                        MassFlowUnit.CentigramPerSecond => (baseUnitValue) / 1e-2d,
-                        MassFlowUnit.DecagramPerDay => (baseUnitValue * 86400) / 1e1d,
-                        MassFlowUnit.DecagramPerSecond => (baseUnitValue) / 1e1d,
-                        MassFlowUnit.DecigramPerDay => (baseUnitValue * 86400) / 1e-1d,
-                        MassFlowUnit.DecigramPerSecond => (baseUnitValue) / 1e-1d,
-                        MassFlowUnit.GramPerDay => baseUnitValue * 86400,
-                        MassFlowUnit.GramPerHour => baseUnitValue * 3600,
-                        MassFlowUnit.GramPerSecond => baseUnitValue,
-                        MassFlowUnit.HectogramPerDay => (baseUnitValue * 86400) / 1e2d,
-                        MassFlowUnit.HectogramPerSecond => (baseUnitValue) / 1e2d,
-                        MassFlowUnit.KilogramPerDay => (baseUnitValue * 86400) / 1e3d,
-                        MassFlowUnit.KilogramPerHour => baseUnitValue * 3.6,
-                        MassFlowUnit.KilogramPerMinute => baseUnitValue * 0.06,
-                        MassFlowUnit.KilogramPerSecond => (baseUnitValue) / 1e3d,
-                        MassFlowUnit.MegagramPerDay => (baseUnitValue * 86400) / 1e6d,
-                        MassFlowUnit.MegapoundPerDay => (baseUnitValue * 86400 / 453.59237) / 1e6d,
-                        MassFlowUnit.MegapoundPerHour => (baseUnitValue * 3600 / 453.59237) / 1e6d,
-                        MassFlowUnit.MegapoundPerMinute => (baseUnitValue * 60 / 453.59237) / 1e6d,
-                        MassFlowUnit.MegapoundPerSecond => (baseUnitValue / 453.59237) / 1e6d,
-                        MassFlowUnit.MicrogramPerDay => (baseUnitValue * 86400) / 1e-6d,
-                        MassFlowUnit.MicrogramPerSecond => (baseUnitValue) / 1e-6d,
-                        MassFlowUnit.MilligramPerDay => (baseUnitValue * 86400) / 1e-3d,
-                        MassFlowUnit.MilligramPerSecond => (baseUnitValue) / 1e-3d,
-                        MassFlowUnit.NanogramPerDay => (baseUnitValue * 86400) / 1e-9d,
-                        MassFlowUnit.NanogramPerSecond => (baseUnitValue) / 1e-9d,
-                        MassFlowUnit.PoundPerDay => baseUnitValue * 86400 / 453.59237,
-                        MassFlowUnit.PoundPerHour => baseUnitValue * 3600 / 453.59237,
-                        MassFlowUnit.PoundPerMinute => baseUnitValue * 60 / 453.59237,
-                        MassFlowUnit.PoundPerSecond => baseUnitValue / 453.59237,
-                        MassFlowUnit.ShortTonPerHour => baseUnitValue * 3.6 / 907.18474,
-                        MassFlowUnit.TonnePerDay => baseUnitValue * 0.0864000,
-                        MassFlowUnit.TonnePerHour => baseUnitValue * 3.6 / 1000,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassFlux.g.cs
deleted file mode 100644
index 3d73e1427c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassFlux.g.cs
+++ /dev/null
@@ -1,289 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Mass flux is the mass flow rate per unit area.
-    /// </summary>
-    public struct  MassFlux
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MassFluxUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MassFluxUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MassFlux(double value, MassFluxUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MassFlux, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MassFluxUnit BaseUnit { get; } = MassFluxUnit.KilogramPerSecondPerSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of MassFlux.
-        /// </summary>
-        public static MassFlux MaxValue { get; } = new MassFlux(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MassFlux.
-        /// </summary>
-        public static MassFlux MinValue { get; } = new MassFlux(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MassFlux Zero { get; } = new MassFlux(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerHourPerSquareCentimeter"/>
-        /// </summary>
-        public double GramsPerHourPerSquareCentimeter => As(MassFluxUnit.GramPerHourPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerHourPerSquareMeter"/>
-        /// </summary>
-        public double GramsPerHourPerSquareMeter => As(MassFluxUnit.GramPerHourPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerHourPerSquareMillimeter"/>
-        /// </summary>
-        public double GramsPerHourPerSquareMillimeter => As(MassFluxUnit.GramPerHourPerSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerSecondPerSquareCentimeter"/>
-        /// </summary>
-        public double GramsPerSecondPerSquareCentimeter => As(MassFluxUnit.GramPerSecondPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerSecondPerSquareMeter"/>
-        /// </summary>
-        public double GramsPerSecondPerSquareMeter => As(MassFluxUnit.GramPerSecondPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerSecondPerSquareMillimeter"/>
-        /// </summary>
-        public double GramsPerSecondPerSquareMillimeter => As(MassFluxUnit.GramPerSecondPerSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerHourPerSquareCentimeter"/>
-        /// </summary>
-        public double KilogramsPerHourPerSquareCentimeter => As(MassFluxUnit.KilogramPerHourPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerHourPerSquareMeter"/>
-        /// </summary>
-        public double KilogramsPerHourPerSquareMeter => As(MassFluxUnit.KilogramPerHourPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerHourPerSquareMillimeter"/>
-        /// </summary>
-        public double KilogramsPerHourPerSquareMillimeter => As(MassFluxUnit.KilogramPerHourPerSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerSecondPerSquareCentimeter"/>
-        /// </summary>
-        public double KilogramsPerSecondPerSquareCentimeter => As(MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerSecondPerSquareMeter"/>
-        /// </summary>
-        public double KilogramsPerSecondPerSquareMeter => As(MassFluxUnit.KilogramPerSecondPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerSecondPerSquareMillimeter"/>
-        /// </summary>
-        public double KilogramsPerSecondPerSquareMillimeter => As(MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareCentimeter"/>.
-        /// </summary>
-        public static MassFlux FromGramsPerHourPerSquareCentimeter(double gramsperhourpersquarecentimeter) => new MassFlux(gramsperhourpersquarecentimeter, MassFluxUnit.GramPerHourPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareMeter"/>.
-        /// </summary>
-        public static MassFlux FromGramsPerHourPerSquareMeter(double gramsperhourpersquaremeter) => new MassFlux(gramsperhourpersquaremeter, MassFluxUnit.GramPerHourPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareMillimeter"/>.
-        /// </summary>
-        public static MassFlux FromGramsPerHourPerSquareMillimeter(double gramsperhourpersquaremillimeter) => new MassFlux(gramsperhourpersquaremillimeter, MassFluxUnit.GramPerHourPerSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareCentimeter"/>.
-        /// </summary>
-        public static MassFlux FromGramsPerSecondPerSquareCentimeter(double gramspersecondpersquarecentimeter) => new MassFlux(gramspersecondpersquarecentimeter, MassFluxUnit.GramPerSecondPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareMeter"/>.
-        /// </summary>
-        public static MassFlux FromGramsPerSecondPerSquareMeter(double gramspersecondpersquaremeter) => new MassFlux(gramspersecondpersquaremeter, MassFluxUnit.GramPerSecondPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareMillimeter"/>.
-        /// </summary>
-        public static MassFlux FromGramsPerSecondPerSquareMillimeter(double gramspersecondpersquaremillimeter) => new MassFlux(gramspersecondpersquaremillimeter, MassFluxUnit.GramPerSecondPerSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareCentimeter"/>.
-        /// </summary>
-        public static MassFlux FromKilogramsPerHourPerSquareCentimeter(double kilogramsperhourpersquarecentimeter) => new MassFlux(kilogramsperhourpersquarecentimeter, MassFluxUnit.KilogramPerHourPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareMeter"/>.
-        /// </summary>
-        public static MassFlux FromKilogramsPerHourPerSquareMeter(double kilogramsperhourpersquaremeter) => new MassFlux(kilogramsperhourpersquaremeter, MassFluxUnit.KilogramPerHourPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareMillimeter"/>.
-        /// </summary>
-        public static MassFlux FromKilogramsPerHourPerSquareMillimeter(double kilogramsperhourpersquaremillimeter) => new MassFlux(kilogramsperhourpersquaremillimeter, MassFluxUnit.KilogramPerHourPerSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareCentimeter"/>.
-        /// </summary>
-        public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(double kilogramspersecondpersquarecentimeter) => new MassFlux(kilogramspersecondpersquarecentimeter, MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareMeter"/>.
-        /// </summary>
-        public static MassFlux FromKilogramsPerSecondPerSquareMeter(double kilogramspersecondpersquaremeter) => new MassFlux(kilogramspersecondpersquaremeter, MassFluxUnit.KilogramPerSecondPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareMillimeter"/>.
-        /// </summary>
-        public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(double kilogramspersecondpersquaremillimeter) => new MassFlux(kilogramspersecondpersquaremillimeter, MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassFluxUnit" /> to <see cref="MassFlux" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MassFlux unit value.</returns>
-        public static MassFlux From(double value, MassFluxUnit fromUnit)
-        {
-            return new MassFlux(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MassFluxUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MassFlux to another MassFlux with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MassFlux with the specified unit.</returns>
-                public MassFlux ToUnit(MassFluxUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MassFlux(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MassFluxUnit.GramPerHourPerSquareCentimeter => _value / 3.6e2,
-                        MassFluxUnit.GramPerHourPerSquareMeter => _value / 3.6e6,
-                        MassFluxUnit.GramPerHourPerSquareMillimeter => _value / 3.6e0,
-                        MassFluxUnit.GramPerSecondPerSquareCentimeter => _value / 1e-1,
-                        MassFluxUnit.GramPerSecondPerSquareMeter => _value / 1e3,
-                        MassFluxUnit.GramPerSecondPerSquareMillimeter => _value / 1e-3,
-                        MassFluxUnit.KilogramPerHourPerSquareCentimeter => (_value / 3.6e2) * 1e3d,
-                        MassFluxUnit.KilogramPerHourPerSquareMeter => (_value / 3.6e6) * 1e3d,
-                        MassFluxUnit.KilogramPerHourPerSquareMillimeter => (_value / 3.6e0) * 1e3d,
-                        MassFluxUnit.KilogramPerSecondPerSquareCentimeter => (_value / 1e-1) * 1e3d,
-                        MassFluxUnit.KilogramPerSecondPerSquareMeter => (_value / 1e3) * 1e3d,
-                        MassFluxUnit.KilogramPerSecondPerSquareMillimeter => (_value / 1e-3) * 1e3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MassFluxUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MassFluxUnit.GramPerHourPerSquareCentimeter => baseUnitValue * 3.6e2,
-                        MassFluxUnit.GramPerHourPerSquareMeter => baseUnitValue * 3.6e6,
-                        MassFluxUnit.GramPerHourPerSquareMillimeter => baseUnitValue * 3.6e0,
-                        MassFluxUnit.GramPerSecondPerSquareCentimeter => baseUnitValue * 1e-1,
-                        MassFluxUnit.GramPerSecondPerSquareMeter => baseUnitValue * 1e3,
-                        MassFluxUnit.GramPerSecondPerSquareMillimeter => baseUnitValue * 1e-3,
-                        MassFluxUnit.KilogramPerHourPerSquareCentimeter => (baseUnitValue * 3.6e2) / 1e3d,
-                        MassFluxUnit.KilogramPerHourPerSquareMeter => (baseUnitValue * 3.6e6) / 1e3d,
-                        MassFluxUnit.KilogramPerHourPerSquareMillimeter => (baseUnitValue * 3.6e0) / 1e3d,
-                        MassFluxUnit.KilogramPerSecondPerSquareCentimeter => (baseUnitValue * 1e-1) / 1e3d,
-                        MassFluxUnit.KilogramPerSecondPerSquareMeter => (baseUnitValue * 1e3) / 1e3d,
-                        MassFluxUnit.KilogramPerSecondPerSquareMillimeter => (baseUnitValue * 1e-3) / 1e3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassFraction.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassFraction.g.cs
deleted file mode 100644
index bf63376d96..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassFraction.g.cs
+++ /dev/null
@@ -1,436 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The mass fraction is defined as the mass of a constituent divided by the total mass of the mixture.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Mass_fraction_(chemistry)
-    /// </remarks>
-    public struct  MassFraction
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MassFractionUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MassFractionUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MassFraction(double value, MassFractionUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MassFraction, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MassFractionUnit BaseUnit { get; } = MassFractionUnit.DecimalFraction;
-
-        /// <summary>
-        /// Represents the largest possible value of MassFraction.
-        /// </summary>
-        public static MassFraction MaxValue { get; } = new MassFraction(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MassFraction.
-        /// </summary>
-        public static MassFraction MinValue { get; } = new MassFraction(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MassFraction Zero { get; } = new MassFraction(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.CentigramPerGram"/>
-        /// </summary>
-        public double CentigramsPerGram => As(MassFractionUnit.CentigramPerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.CentigramPerKilogram"/>
-        /// </summary>
-        public double CentigramsPerKilogram => As(MassFractionUnit.CentigramPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.DecagramPerGram"/>
-        /// </summary>
-        public double DecagramsPerGram => As(MassFractionUnit.DecagramPerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.DecagramPerKilogram"/>
-        /// </summary>
-        public double DecagramsPerKilogram => As(MassFractionUnit.DecagramPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.DecigramPerGram"/>
-        /// </summary>
-        public double DecigramsPerGram => As(MassFractionUnit.DecigramPerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.DecigramPerKilogram"/>
-        /// </summary>
-        public double DecigramsPerKilogram => As(MassFractionUnit.DecigramPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.DecimalFraction"/>
-        /// </summary>
-        public double DecimalFractions => As(MassFractionUnit.DecimalFraction);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.GramPerGram"/>
-        /// </summary>
-        public double GramsPerGram => As(MassFractionUnit.GramPerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.GramPerKilogram"/>
-        /// </summary>
-        public double GramsPerKilogram => As(MassFractionUnit.GramPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.HectogramPerGram"/>
-        /// </summary>
-        public double HectogramsPerGram => As(MassFractionUnit.HectogramPerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.HectogramPerKilogram"/>
-        /// </summary>
-        public double HectogramsPerKilogram => As(MassFractionUnit.HectogramPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.KilogramPerGram"/>
-        /// </summary>
-        public double KilogramsPerGram => As(MassFractionUnit.KilogramPerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.KilogramPerKilogram"/>
-        /// </summary>
-        public double KilogramsPerKilogram => As(MassFractionUnit.KilogramPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.MicrogramPerGram"/>
-        /// </summary>
-        public double MicrogramsPerGram => As(MassFractionUnit.MicrogramPerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.MicrogramPerKilogram"/>
-        /// </summary>
-        public double MicrogramsPerKilogram => As(MassFractionUnit.MicrogramPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.MilligramPerGram"/>
-        /// </summary>
-        public double MilligramsPerGram => As(MassFractionUnit.MilligramPerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.MilligramPerKilogram"/>
-        /// </summary>
-        public double MilligramsPerKilogram => As(MassFractionUnit.MilligramPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.NanogramPerGram"/>
-        /// </summary>
-        public double NanogramsPerGram => As(MassFractionUnit.NanogramPerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.NanogramPerKilogram"/>
-        /// </summary>
-        public double NanogramsPerKilogram => As(MassFractionUnit.NanogramPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerBillion"/>
-        /// </summary>
-        public double PartsPerBillion => As(MassFractionUnit.PartPerBillion);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerMillion"/>
-        /// </summary>
-        public double PartsPerMillion => As(MassFractionUnit.PartPerMillion);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerThousand"/>
-        /// </summary>
-        public double PartsPerThousand => As(MassFractionUnit.PartPerThousand);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerTrillion"/>
-        /// </summary>
-        public double PartsPerTrillion => As(MassFractionUnit.PartPerTrillion);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.Percent"/>
-        /// </summary>
-        public double Percent => As(MassFractionUnit.Percent);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.CentigramPerGram"/>.
-        /// </summary>
-        public static MassFraction FromCentigramsPerGram(double centigramspergram) => new MassFraction(centigramspergram, MassFractionUnit.CentigramPerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.CentigramPerKilogram"/>.
-        /// </summary>
-        public static MassFraction FromCentigramsPerKilogram(double centigramsperkilogram) => new MassFraction(centigramsperkilogram, MassFractionUnit.CentigramPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecagramPerGram"/>.
-        /// </summary>
-        public static MassFraction FromDecagramsPerGram(double decagramspergram) => new MassFraction(decagramspergram, MassFractionUnit.DecagramPerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecagramPerKilogram"/>.
-        /// </summary>
-        public static MassFraction FromDecagramsPerKilogram(double decagramsperkilogram) => new MassFraction(decagramsperkilogram, MassFractionUnit.DecagramPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecigramPerGram"/>.
-        /// </summary>
-        public static MassFraction FromDecigramsPerGram(double decigramspergram) => new MassFraction(decigramspergram, MassFractionUnit.DecigramPerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecigramPerKilogram"/>.
-        /// </summary>
-        public static MassFraction FromDecigramsPerKilogram(double decigramsperkilogram) => new MassFraction(decigramsperkilogram, MassFractionUnit.DecigramPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecimalFraction"/>.
-        /// </summary>
-        public static MassFraction FromDecimalFractions(double decimalfractions) => new MassFraction(decimalfractions, MassFractionUnit.DecimalFraction);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.GramPerGram"/>.
-        /// </summary>
-        public static MassFraction FromGramsPerGram(double gramspergram) => new MassFraction(gramspergram, MassFractionUnit.GramPerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.GramPerKilogram"/>.
-        /// </summary>
-        public static MassFraction FromGramsPerKilogram(double gramsperkilogram) => new MassFraction(gramsperkilogram, MassFractionUnit.GramPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.HectogramPerGram"/>.
-        /// </summary>
-        public static MassFraction FromHectogramsPerGram(double hectogramspergram) => new MassFraction(hectogramspergram, MassFractionUnit.HectogramPerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.HectogramPerKilogram"/>.
-        /// </summary>
-        public static MassFraction FromHectogramsPerKilogram(double hectogramsperkilogram) => new MassFraction(hectogramsperkilogram, MassFractionUnit.HectogramPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.KilogramPerGram"/>.
-        /// </summary>
-        public static MassFraction FromKilogramsPerGram(double kilogramspergram) => new MassFraction(kilogramspergram, MassFractionUnit.KilogramPerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.KilogramPerKilogram"/>.
-        /// </summary>
-        public static MassFraction FromKilogramsPerKilogram(double kilogramsperkilogram) => new MassFraction(kilogramsperkilogram, MassFractionUnit.KilogramPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MicrogramPerGram"/>.
-        /// </summary>
-        public static MassFraction FromMicrogramsPerGram(double microgramspergram) => new MassFraction(microgramspergram, MassFractionUnit.MicrogramPerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MicrogramPerKilogram"/>.
-        /// </summary>
-        public static MassFraction FromMicrogramsPerKilogram(double microgramsperkilogram) => new MassFraction(microgramsperkilogram, MassFractionUnit.MicrogramPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MilligramPerGram"/>.
-        /// </summary>
-        public static MassFraction FromMilligramsPerGram(double milligramspergram) => new MassFraction(milligramspergram, MassFractionUnit.MilligramPerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MilligramPerKilogram"/>.
-        /// </summary>
-        public static MassFraction FromMilligramsPerKilogram(double milligramsperkilogram) => new MassFraction(milligramsperkilogram, MassFractionUnit.MilligramPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.NanogramPerGram"/>.
-        /// </summary>
-        public static MassFraction FromNanogramsPerGram(double nanogramspergram) => new MassFraction(nanogramspergram, MassFractionUnit.NanogramPerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.NanogramPerKilogram"/>.
-        /// </summary>
-        public static MassFraction FromNanogramsPerKilogram(double nanogramsperkilogram) => new MassFraction(nanogramsperkilogram, MassFractionUnit.NanogramPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerBillion"/>.
-        /// </summary>
-        public static MassFraction FromPartsPerBillion(double partsperbillion) => new MassFraction(partsperbillion, MassFractionUnit.PartPerBillion);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerMillion"/>.
-        /// </summary>
-        public static MassFraction FromPartsPerMillion(double partspermillion) => new MassFraction(partspermillion, MassFractionUnit.PartPerMillion);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerThousand"/>.
-        /// </summary>
-        public static MassFraction FromPartsPerThousand(double partsperthousand) => new MassFraction(partsperthousand, MassFractionUnit.PartPerThousand);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerTrillion"/>.
-        /// </summary>
-        public static MassFraction FromPartsPerTrillion(double partspertrillion) => new MassFraction(partspertrillion, MassFractionUnit.PartPerTrillion);
-
-        /// <summary>
-        ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.Percent"/>.
-        /// </summary>
-        public static MassFraction FromPercent(double percent) => new MassFraction(percent, MassFractionUnit.Percent);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassFractionUnit" /> to <see cref="MassFraction" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MassFraction unit value.</returns>
-        public static MassFraction From(double value, MassFractionUnit fromUnit)
-        {
-            return new MassFraction(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MassFractionUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MassFraction to another MassFraction with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MassFraction with the specified unit.</returns>
-                public MassFraction ToUnit(MassFractionUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MassFraction(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MassFractionUnit.CentigramPerGram => (_value) * 1e-2d,
-                        MassFractionUnit.CentigramPerKilogram => (_value / 1e3) * 1e-2d,
-                        MassFractionUnit.DecagramPerGram => (_value) * 1e1d,
-                        MassFractionUnit.DecagramPerKilogram => (_value / 1e3) * 1e1d,
-                        MassFractionUnit.DecigramPerGram => (_value) * 1e-1d,
-                        MassFractionUnit.DecigramPerKilogram => (_value / 1e3) * 1e-1d,
-                        MassFractionUnit.DecimalFraction => _value,
-                        MassFractionUnit.GramPerGram => _value,
-                        MassFractionUnit.GramPerKilogram => _value / 1e3,
-                        MassFractionUnit.HectogramPerGram => (_value) * 1e2d,
-                        MassFractionUnit.HectogramPerKilogram => (_value / 1e3) * 1e2d,
-                        MassFractionUnit.KilogramPerGram => (_value) * 1e3d,
-                        MassFractionUnit.KilogramPerKilogram => (_value / 1e3) * 1e3d,
-                        MassFractionUnit.MicrogramPerGram => (_value) * 1e-6d,
-                        MassFractionUnit.MicrogramPerKilogram => (_value / 1e3) * 1e-6d,
-                        MassFractionUnit.MilligramPerGram => (_value) * 1e-3d,
-                        MassFractionUnit.MilligramPerKilogram => (_value / 1e3) * 1e-3d,
-                        MassFractionUnit.NanogramPerGram => (_value) * 1e-9d,
-                        MassFractionUnit.NanogramPerKilogram => (_value / 1e3) * 1e-9d,
-                        MassFractionUnit.PartPerBillion => _value / 1e9,
-                        MassFractionUnit.PartPerMillion => _value / 1e6,
-                        MassFractionUnit.PartPerThousand => _value / 1e3,
-                        MassFractionUnit.PartPerTrillion => _value / 1e12,
-                        MassFractionUnit.Percent => _value / 1e2,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MassFractionUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MassFractionUnit.CentigramPerGram => (baseUnitValue) / 1e-2d,
-                        MassFractionUnit.CentigramPerKilogram => (baseUnitValue * 1e3) / 1e-2d,
-                        MassFractionUnit.DecagramPerGram => (baseUnitValue) / 1e1d,
-                        MassFractionUnit.DecagramPerKilogram => (baseUnitValue * 1e3) / 1e1d,
-                        MassFractionUnit.DecigramPerGram => (baseUnitValue) / 1e-1d,
-                        MassFractionUnit.DecigramPerKilogram => (baseUnitValue * 1e3) / 1e-1d,
-                        MassFractionUnit.DecimalFraction => baseUnitValue,
-                        MassFractionUnit.GramPerGram => baseUnitValue,
-                        MassFractionUnit.GramPerKilogram => baseUnitValue * 1e3,
-                        MassFractionUnit.HectogramPerGram => (baseUnitValue) / 1e2d,
-                        MassFractionUnit.HectogramPerKilogram => (baseUnitValue * 1e3) / 1e2d,
-                        MassFractionUnit.KilogramPerGram => (baseUnitValue) / 1e3d,
-                        MassFractionUnit.KilogramPerKilogram => (baseUnitValue * 1e3) / 1e3d,
-                        MassFractionUnit.MicrogramPerGram => (baseUnitValue) / 1e-6d,
-                        MassFractionUnit.MicrogramPerKilogram => (baseUnitValue * 1e3) / 1e-6d,
-                        MassFractionUnit.MilligramPerGram => (baseUnitValue) / 1e-3d,
-                        MassFractionUnit.MilligramPerKilogram => (baseUnitValue * 1e3) / 1e-3d,
-                        MassFractionUnit.NanogramPerGram => (baseUnitValue) / 1e-9d,
-                        MassFractionUnit.NanogramPerKilogram => (baseUnitValue * 1e3) / 1e-9d,
-                        MassFractionUnit.PartPerBillion => baseUnitValue * 1e9,
-                        MassFractionUnit.PartPerMillion => baseUnitValue * 1e6,
-                        MassFractionUnit.PartPerThousand => baseUnitValue * 1e3,
-                        MassFractionUnit.PartPerTrillion => baseUnitValue * 1e12,
-                        MassFractionUnit.Percent => baseUnitValue * 1e2,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
deleted file mode 100644
index 1c80b42c24..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
+++ /dev/null
@@ -1,481 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     A property of body reflects how its mass is distributed with regard to an axis.
-    /// </summary>
-    public struct  MassMomentOfInertia
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MassMomentOfInertiaUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MassMomentOfInertiaUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MassMomentOfInertia(double value, MassMomentOfInertiaUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MassMomentOfInertia, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MassMomentOfInertiaUnit BaseUnit { get; } = MassMomentOfInertiaUnit.KilogramSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of MassMomentOfInertia.
-        /// </summary>
-        public static MassMomentOfInertia MaxValue { get; } = new MassMomentOfInertia(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MassMomentOfInertia.
-        /// </summary>
-        public static MassMomentOfInertia MinValue { get; } = new MassMomentOfInertia(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MassMomentOfInertia Zero { get; } = new MassMomentOfInertia(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareCentimeter"/>
-        /// </summary>
-        public double GramSquareCentimeters => As(MassMomentOfInertiaUnit.GramSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareDecimeter"/>
-        /// </summary>
-        public double GramSquareDecimeters => As(MassMomentOfInertiaUnit.GramSquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareMeter"/>
-        /// </summary>
-        public double GramSquareMeters => As(MassMomentOfInertiaUnit.GramSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareMillimeter"/>
-        /// </summary>
-        public double GramSquareMillimeters => As(MassMomentOfInertiaUnit.GramSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareCentimeter"/>
-        /// </summary>
-        public double KilogramSquareCentimeters => As(MassMomentOfInertiaUnit.KilogramSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareDecimeter"/>
-        /// </summary>
-        public double KilogramSquareDecimeters => As(MassMomentOfInertiaUnit.KilogramSquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareMeter"/>
-        /// </summary>
-        public double KilogramSquareMeters => As(MassMomentOfInertiaUnit.KilogramSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareMillimeter"/>
-        /// </summary>
-        public double KilogramSquareMillimeters => As(MassMomentOfInertiaUnit.KilogramSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareCentimeter"/>
-        /// </summary>
-        public double KilotonneSquareCentimeters => As(MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareDecimeter"/>
-        /// </summary>
-        public double KilotonneSquareDecimeters => As(MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareMeter"/>
-        /// </summary>
-        public double KilotonneSquareMeters => As(MassMomentOfInertiaUnit.KilotonneSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareMillimeter"/>
-        /// </summary>
-        public double KilotonneSquareMillimeters => As(MassMomentOfInertiaUnit.KilotonneSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareCentimeter"/>
-        /// </summary>
-        public double MegatonneSquareCentimeters => As(MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareDecimeter"/>
-        /// </summary>
-        public double MegatonneSquareDecimeters => As(MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareMeter"/>
-        /// </summary>
-        public double MegatonneSquareMeters => As(MassMomentOfInertiaUnit.MegatonneSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareMillimeter"/>
-        /// </summary>
-        public double MegatonneSquareMillimeters => As(MassMomentOfInertiaUnit.MegatonneSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareCentimeter"/>
-        /// </summary>
-        public double MilligramSquareCentimeters => As(MassMomentOfInertiaUnit.MilligramSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareDecimeter"/>
-        /// </summary>
-        public double MilligramSquareDecimeters => As(MassMomentOfInertiaUnit.MilligramSquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareMeter"/>
-        /// </summary>
-        public double MilligramSquareMeters => As(MassMomentOfInertiaUnit.MilligramSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareMillimeter"/>
-        /// </summary>
-        public double MilligramSquareMillimeters => As(MassMomentOfInertiaUnit.MilligramSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.PoundSquareFoot"/>
-        /// </summary>
-        public double PoundSquareFeet => As(MassMomentOfInertiaUnit.PoundSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.PoundSquareInch"/>
-        /// </summary>
-        public double PoundSquareInches => As(MassMomentOfInertiaUnit.PoundSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.SlugSquareFoot"/>
-        /// </summary>
-        public double SlugSquareFeet => As(MassMomentOfInertiaUnit.SlugSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.SlugSquareInch"/>
-        /// </summary>
-        public double SlugSquareInches => As(MassMomentOfInertiaUnit.SlugSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareCentimeter"/>
-        /// </summary>
-        public double TonneSquareCentimeters => As(MassMomentOfInertiaUnit.TonneSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareDecimeter"/>
-        /// </summary>
-        public double TonneSquareDecimeters => As(MassMomentOfInertiaUnit.TonneSquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareMeter"/>
-        /// </summary>
-        public double TonneSquareMeters => As(MassMomentOfInertiaUnit.TonneSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareMillimeter"/>
-        /// </summary>
-        public double TonneSquareMillimeters => As(MassMomentOfInertiaUnit.TonneSquareMillimeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareCentimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromGramSquareCentimeters(double gramsquarecentimeters) => new MassMomentOfInertia(gramsquarecentimeters, MassMomentOfInertiaUnit.GramSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareDecimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromGramSquareDecimeters(double gramsquaredecimeters) => new MassMomentOfInertia(gramsquaredecimeters, MassMomentOfInertiaUnit.GramSquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareMeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromGramSquareMeters(double gramsquaremeters) => new MassMomentOfInertia(gramsquaremeters, MassMomentOfInertiaUnit.GramSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareMillimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromGramSquareMillimeters(double gramsquaremillimeters) => new MassMomentOfInertia(gramsquaremillimeters, MassMomentOfInertiaUnit.GramSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareCentimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromKilogramSquareCentimeters(double kilogramsquarecentimeters) => new MassMomentOfInertia(kilogramsquarecentimeters, MassMomentOfInertiaUnit.KilogramSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareDecimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromKilogramSquareDecimeters(double kilogramsquaredecimeters) => new MassMomentOfInertia(kilogramsquaredecimeters, MassMomentOfInertiaUnit.KilogramSquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareMeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromKilogramSquareMeters(double kilogramsquaremeters) => new MassMomentOfInertia(kilogramsquaremeters, MassMomentOfInertiaUnit.KilogramSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareMillimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromKilogramSquareMillimeters(double kilogramsquaremillimeters) => new MassMomentOfInertia(kilogramsquaremillimeters, MassMomentOfInertiaUnit.KilogramSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareCentimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromKilotonneSquareCentimeters(double kilotonnesquarecentimeters) => new MassMomentOfInertia(kilotonnesquarecentimeters, MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareDecimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromKilotonneSquareDecimeters(double kilotonnesquaredecimeters) => new MassMomentOfInertia(kilotonnesquaredecimeters, MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareMeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromKilotonneSquareMeters(double kilotonnesquaremeters) => new MassMomentOfInertia(kilotonnesquaremeters, MassMomentOfInertiaUnit.KilotonneSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareMillimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromKilotonneSquareMillimeters(double kilotonnesquaremillimeters) => new MassMomentOfInertia(kilotonnesquaremillimeters, MassMomentOfInertiaUnit.KilotonneSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareCentimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromMegatonneSquareCentimeters(double megatonnesquarecentimeters) => new MassMomentOfInertia(megatonnesquarecentimeters, MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareDecimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromMegatonneSquareDecimeters(double megatonnesquaredecimeters) => new MassMomentOfInertia(megatonnesquaredecimeters, MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareMeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromMegatonneSquareMeters(double megatonnesquaremeters) => new MassMomentOfInertia(megatonnesquaremeters, MassMomentOfInertiaUnit.MegatonneSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareMillimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromMegatonneSquareMillimeters(double megatonnesquaremillimeters) => new MassMomentOfInertia(megatonnesquaremillimeters, MassMomentOfInertiaUnit.MegatonneSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareCentimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromMilligramSquareCentimeters(double milligramsquarecentimeters) => new MassMomentOfInertia(milligramsquarecentimeters, MassMomentOfInertiaUnit.MilligramSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareDecimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromMilligramSquareDecimeters(double milligramsquaredecimeters) => new MassMomentOfInertia(milligramsquaredecimeters, MassMomentOfInertiaUnit.MilligramSquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareMeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromMilligramSquareMeters(double milligramsquaremeters) => new MassMomentOfInertia(milligramsquaremeters, MassMomentOfInertiaUnit.MilligramSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareMillimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromMilligramSquareMillimeters(double milligramsquaremillimeters) => new MassMomentOfInertia(milligramsquaremillimeters, MassMomentOfInertiaUnit.MilligramSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.PoundSquareFoot"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromPoundSquareFeet(double poundsquarefeet) => new MassMomentOfInertia(poundsquarefeet, MassMomentOfInertiaUnit.PoundSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.PoundSquareInch"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromPoundSquareInches(double poundsquareinches) => new MassMomentOfInertia(poundsquareinches, MassMomentOfInertiaUnit.PoundSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.SlugSquareFoot"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromSlugSquareFeet(double slugsquarefeet) => new MassMomentOfInertia(slugsquarefeet, MassMomentOfInertiaUnit.SlugSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.SlugSquareInch"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromSlugSquareInches(double slugsquareinches) => new MassMomentOfInertia(slugsquareinches, MassMomentOfInertiaUnit.SlugSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareCentimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromTonneSquareCentimeters(double tonnesquarecentimeters) => new MassMomentOfInertia(tonnesquarecentimeters, MassMomentOfInertiaUnit.TonneSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareDecimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromTonneSquareDecimeters(double tonnesquaredecimeters) => new MassMomentOfInertia(tonnesquaredecimeters, MassMomentOfInertiaUnit.TonneSquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareMeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromTonneSquareMeters(double tonnesquaremeters) => new MassMomentOfInertia(tonnesquaremeters, MassMomentOfInertiaUnit.TonneSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareMillimeter"/>.
-        /// </summary>
-        public static MassMomentOfInertia FromTonneSquareMillimeters(double tonnesquaremillimeters) => new MassMomentOfInertia(tonnesquaremillimeters, MassMomentOfInertiaUnit.TonneSquareMillimeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MassMomentOfInertiaUnit" /> to <see cref="MassMomentOfInertia" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MassMomentOfInertia unit value.</returns>
-        public static MassMomentOfInertia From(double value, MassMomentOfInertiaUnit fromUnit)
-        {
-            return new MassMomentOfInertia(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MassMomentOfInertiaUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MassMomentOfInertia to another MassMomentOfInertia with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MassMomentOfInertia with the specified unit.</returns>
-                public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MassMomentOfInertia(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MassMomentOfInertiaUnit.GramSquareCentimeter => _value / 1e7,
-                        MassMomentOfInertiaUnit.GramSquareDecimeter => _value / 1e5,
-                        MassMomentOfInertiaUnit.GramSquareMeter => _value / 1e3,
-                        MassMomentOfInertiaUnit.GramSquareMillimeter => _value / 1e9,
-                        MassMomentOfInertiaUnit.KilogramSquareCentimeter => (_value / 1e7) * 1e3d,
-                        MassMomentOfInertiaUnit.KilogramSquareDecimeter => (_value / 1e5) * 1e3d,
-                        MassMomentOfInertiaUnit.KilogramSquareMeter => (_value / 1e3) * 1e3d,
-                        MassMomentOfInertiaUnit.KilogramSquareMillimeter => (_value / 1e9) * 1e3d,
-                        MassMomentOfInertiaUnit.KilotonneSquareCentimeter => (_value / 1e1) * 1e3d,
-                        MassMomentOfInertiaUnit.KilotonneSquareDecimeter => (_value / 1e-1) * 1e3d,
-                        MassMomentOfInertiaUnit.KilotonneSquareMeter => (_value / 1e-3) * 1e3d,
-                        MassMomentOfInertiaUnit.KilotonneSquareMillimeter => (_value / 1e3) * 1e3d,
-                        MassMomentOfInertiaUnit.MegatonneSquareCentimeter => (_value / 1e1) * 1e6d,
-                        MassMomentOfInertiaUnit.MegatonneSquareDecimeter => (_value / 1e-1) * 1e6d,
-                        MassMomentOfInertiaUnit.MegatonneSquareMeter => (_value / 1e-3) * 1e6d,
-                        MassMomentOfInertiaUnit.MegatonneSquareMillimeter => (_value / 1e3) * 1e6d,
-                        MassMomentOfInertiaUnit.MilligramSquareCentimeter => (_value / 1e7) * 1e-3d,
-                        MassMomentOfInertiaUnit.MilligramSquareDecimeter => (_value / 1e5) * 1e-3d,
-                        MassMomentOfInertiaUnit.MilligramSquareMeter => (_value / 1e3) * 1e-3d,
-                        MassMomentOfInertiaUnit.MilligramSquareMillimeter => (_value / 1e9) * 1e-3d,
-                        MassMomentOfInertiaUnit.PoundSquareFoot => _value * (0.45359237 * 9.290304e-2),
-                        MassMomentOfInertiaUnit.PoundSquareInch => _value * (0.45359237 * 0.00064516),
-                        MassMomentOfInertiaUnit.SlugSquareFoot => _value * 0.45359237 * 9.290304e-2 * 9.80665 / 0.3048,
-                        MassMomentOfInertiaUnit.SlugSquareInch => _value * 0.45359237 * 0.00064516 * 9.80665 / 0.3048,
-                        MassMomentOfInertiaUnit.TonneSquareCentimeter => _value / 1e1,
-                        MassMomentOfInertiaUnit.TonneSquareDecimeter => _value / 1e-1,
-                        MassMomentOfInertiaUnit.TonneSquareMeter => _value / 1e-3,
-                        MassMomentOfInertiaUnit.TonneSquareMillimeter => _value / 1e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MassMomentOfInertiaUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MassMomentOfInertiaUnit.GramSquareCentimeter => baseUnitValue * 1e7,
-                        MassMomentOfInertiaUnit.GramSquareDecimeter => baseUnitValue * 1e5,
-                        MassMomentOfInertiaUnit.GramSquareMeter => baseUnitValue * 1e3,
-                        MassMomentOfInertiaUnit.GramSquareMillimeter => baseUnitValue * 1e9,
-                        MassMomentOfInertiaUnit.KilogramSquareCentimeter => (baseUnitValue * 1e7) / 1e3d,
-                        MassMomentOfInertiaUnit.KilogramSquareDecimeter => (baseUnitValue * 1e5) / 1e3d,
-                        MassMomentOfInertiaUnit.KilogramSquareMeter => (baseUnitValue * 1e3) / 1e3d,
-                        MassMomentOfInertiaUnit.KilogramSquareMillimeter => (baseUnitValue * 1e9) / 1e3d,
-                        MassMomentOfInertiaUnit.KilotonneSquareCentimeter => (baseUnitValue * 1e1) / 1e3d,
-                        MassMomentOfInertiaUnit.KilotonneSquareDecimeter => (baseUnitValue * 1e-1) / 1e3d,
-                        MassMomentOfInertiaUnit.KilotonneSquareMeter => (baseUnitValue * 1e-3) / 1e3d,
-                        MassMomentOfInertiaUnit.KilotonneSquareMillimeter => (baseUnitValue * 1e3) / 1e3d,
-                        MassMomentOfInertiaUnit.MegatonneSquareCentimeter => (baseUnitValue * 1e1) / 1e6d,
-                        MassMomentOfInertiaUnit.MegatonneSquareDecimeter => (baseUnitValue * 1e-1) / 1e6d,
-                        MassMomentOfInertiaUnit.MegatonneSquareMeter => (baseUnitValue * 1e-3) / 1e6d,
-                        MassMomentOfInertiaUnit.MegatonneSquareMillimeter => (baseUnitValue * 1e3) / 1e6d,
-                        MassMomentOfInertiaUnit.MilligramSquareCentimeter => (baseUnitValue * 1e7) / 1e-3d,
-                        MassMomentOfInertiaUnit.MilligramSquareDecimeter => (baseUnitValue * 1e5) / 1e-3d,
-                        MassMomentOfInertiaUnit.MilligramSquareMeter => (baseUnitValue * 1e3) / 1e-3d,
-                        MassMomentOfInertiaUnit.MilligramSquareMillimeter => (baseUnitValue * 1e9) / 1e-3d,
-                        MassMomentOfInertiaUnit.PoundSquareFoot => baseUnitValue / (0.45359237 * 9.290304e-2),
-                        MassMomentOfInertiaUnit.PoundSquareInch => baseUnitValue / (0.45359237 * 0.00064516),
-                        MassMomentOfInertiaUnit.SlugSquareFoot => baseUnitValue * 0.3048 / (0.45359237 * 9.290304e-2 * 9.80665),
-                        MassMomentOfInertiaUnit.SlugSquareInch => baseUnitValue * 0.3048 / (0.45359237 * 0.00064516 * 9.80665),
-                        MassMomentOfInertiaUnit.TonneSquareCentimeter => baseUnitValue * 1e1,
-                        MassMomentOfInertiaUnit.TonneSquareDecimeter => baseUnitValue * 1e-1,
-                        MassMomentOfInertiaUnit.TonneSquareMeter => baseUnitValue * 1e-3,
-                        MassMomentOfInertiaUnit.TonneSquareMillimeter => baseUnitValue * 1e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Molality.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Molality.g.cs
deleted file mode 100644
index d959f00afc..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Molality.g.cs
+++ /dev/null
@@ -1,184 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Molality is a measure of the amount of solute in a solution relative to a given mass of solvent.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Molality
-    /// </remarks>
-    public struct  Molality
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MolalityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MolalityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Molality(double value, MolalityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Molality, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MolalityUnit BaseUnit { get; } = MolalityUnit.MolePerKilogram;
-
-        /// <summary>
-        /// Represents the largest possible value of Molality.
-        /// </summary>
-        public static Molality MaxValue { get; } = new Molality(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Molality.
-        /// </summary>
-        public static Molality MinValue { get; } = new Molality(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Molality Zero { get; } = new Molality(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolalityUnit.MillimolePerKilogram"/>
-        /// </summary>
-        public double MillimolesPerKilogram => As(MolalityUnit.MillimolePerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolalityUnit.MolePerGram"/>
-        /// </summary>
-        public double MolesPerGram => As(MolalityUnit.MolePerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolalityUnit.MolePerKilogram"/>
-        /// </summary>
-        public double MolesPerKilogram => As(MolalityUnit.MolePerKilogram);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Molality"/> from <see cref="MolalityUnit.MillimolePerKilogram"/>.
-        /// </summary>
-        public static Molality FromMillimolesPerKilogram(double millimolesperkilogram) => new Molality(millimolesperkilogram, MolalityUnit.MillimolePerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="Molality"/> from <see cref="MolalityUnit.MolePerGram"/>.
-        /// </summary>
-        public static Molality FromMolesPerGram(double molespergram) => new Molality(molespergram, MolalityUnit.MolePerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="Molality"/> from <see cref="MolalityUnit.MolePerKilogram"/>.
-        /// </summary>
-        public static Molality FromMolesPerKilogram(double molesperkilogram) => new Molality(molesperkilogram, MolalityUnit.MolePerKilogram);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MolalityUnit" /> to <see cref="Molality" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Molality unit value.</returns>
-        public static Molality From(double value, MolalityUnit fromUnit)
-        {
-            return new Molality(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MolalityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Molality to another Molality with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Molality with the specified unit.</returns>
-                public Molality ToUnit(MolalityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Molality(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MolalityUnit.MillimolePerKilogram => (_value) * 1e-3d,
-                        MolalityUnit.MolePerGram => _value / 1e-3,
-                        MolalityUnit.MolePerKilogram => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MolalityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MolalityUnit.MillimolePerKilogram => (baseUnitValue) / 1e-3d,
-                        MolalityUnit.MolePerGram => baseUnitValue * 1e-3,
-                        MolalityUnit.MolePerKilogram => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarEnergy.g.cs
deleted file mode 100644
index 2934e13f88..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarEnergy.g.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Molar energy is the amount of energy stored in 1 mole of a substance.
-    /// </summary>
-    public struct  MolarEnergy
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MolarEnergyUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MolarEnergyUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MolarEnergy(double value, MolarEnergyUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MolarEnergy, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MolarEnergyUnit BaseUnit { get; } = MolarEnergyUnit.JoulePerMole;
-
-        /// <summary>
-        /// Represents the largest possible value of MolarEnergy.
-        /// </summary>
-        public static MolarEnergy MaxValue { get; } = new MolarEnergy(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MolarEnergy.
-        /// </summary>
-        public static MolarEnergy MinValue { get; } = new MolarEnergy(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MolarEnergy Zero { get; } = new MolarEnergy(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEnergyUnit.JoulePerMole"/>
-        /// </summary>
-        public double JoulesPerMole => As(MolarEnergyUnit.JoulePerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEnergyUnit.KilojoulePerMole"/>
-        /// </summary>
-        public double KilojoulesPerMole => As(MolarEnergyUnit.KilojoulePerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEnergyUnit.MegajoulePerMole"/>
-        /// </summary>
-        public double MegajoulesPerMole => As(MolarEnergyUnit.MegajoulePerMole);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.JoulePerMole"/>.
-        /// </summary>
-        public static MolarEnergy FromJoulesPerMole(double joulespermole) => new MolarEnergy(joulespermole, MolarEnergyUnit.JoulePerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.KilojoulePerMole"/>.
-        /// </summary>
-        public static MolarEnergy FromKilojoulesPerMole(double kilojoulespermole) => new MolarEnergy(kilojoulespermole, MolarEnergyUnit.KilojoulePerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.MegajoulePerMole"/>.
-        /// </summary>
-        public static MolarEnergy FromMegajoulesPerMole(double megajoulespermole) => new MolarEnergy(megajoulespermole, MolarEnergyUnit.MegajoulePerMole);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MolarEnergyUnit" /> to <see cref="MolarEnergy" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MolarEnergy unit value.</returns>
-        public static MolarEnergy From(double value, MolarEnergyUnit fromUnit)
-        {
-            return new MolarEnergy(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MolarEnergyUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MolarEnergy to another MolarEnergy with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MolarEnergy with the specified unit.</returns>
-                public MolarEnergy ToUnit(MolarEnergyUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MolarEnergy(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MolarEnergyUnit.JoulePerMole => _value,
-                        MolarEnergyUnit.KilojoulePerMole => (_value) * 1e3d,
-                        MolarEnergyUnit.MegajoulePerMole => (_value) * 1e6d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MolarEnergyUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MolarEnergyUnit.JoulePerMole => baseUnitValue,
-                        MolarEnergyUnit.KilojoulePerMole => (baseUnitValue) / 1e3d,
-                        MolarEnergyUnit.MegajoulePerMole => (baseUnitValue) / 1e6d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarEntropy.g.cs
deleted file mode 100644
index caedf9eaba..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarEntropy.g.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Molar entropy is amount of energy required to increase temperature of 1 mole substance by 1 Kelvin.
-    /// </summary>
-    public struct  MolarEntropy
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MolarEntropyUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MolarEntropyUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MolarEntropy(double value, MolarEntropyUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MolarEntropy, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MolarEntropyUnit BaseUnit { get; } = MolarEntropyUnit.JoulePerMoleKelvin;
-
-        /// <summary>
-        /// Represents the largest possible value of MolarEntropy.
-        /// </summary>
-        public static MolarEntropy MaxValue { get; } = new MolarEntropy(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MolarEntropy.
-        /// </summary>
-        public static MolarEntropy MinValue { get; } = new MolarEntropy(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MolarEntropy Zero { get; } = new MolarEntropy(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEntropyUnit.JoulePerMoleKelvin"/>
-        /// </summary>
-        public double JoulesPerMoleKelvin => As(MolarEntropyUnit.JoulePerMoleKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEntropyUnit.KilojoulePerMoleKelvin"/>
-        /// </summary>
-        public double KilojoulesPerMoleKelvin => As(MolarEntropyUnit.KilojoulePerMoleKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEntropyUnit.MegajoulePerMoleKelvin"/>
-        /// </summary>
-        public double MegajoulesPerMoleKelvin => As(MolarEntropyUnit.MegajoulePerMoleKelvin);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.JoulePerMoleKelvin"/>.
-        /// </summary>
-        public static MolarEntropy FromJoulesPerMoleKelvin(double joulespermolekelvin) => new MolarEntropy(joulespermolekelvin, MolarEntropyUnit.JoulePerMoleKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.KilojoulePerMoleKelvin"/>.
-        /// </summary>
-        public static MolarEntropy FromKilojoulesPerMoleKelvin(double kilojoulespermolekelvin) => new MolarEntropy(kilojoulespermolekelvin, MolarEntropyUnit.KilojoulePerMoleKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.MegajoulePerMoleKelvin"/>.
-        /// </summary>
-        public static MolarEntropy FromMegajoulesPerMoleKelvin(double megajoulespermolekelvin) => new MolarEntropy(megajoulespermolekelvin, MolarEntropyUnit.MegajoulePerMoleKelvin);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MolarEntropyUnit" /> to <see cref="MolarEntropy" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MolarEntropy unit value.</returns>
-        public static MolarEntropy From(double value, MolarEntropyUnit fromUnit)
-        {
-            return new MolarEntropy(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MolarEntropyUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MolarEntropy to another MolarEntropy with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MolarEntropy with the specified unit.</returns>
-                public MolarEntropy ToUnit(MolarEntropyUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MolarEntropy(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MolarEntropyUnit.JoulePerMoleKelvin => _value,
-                        MolarEntropyUnit.KilojoulePerMoleKelvin => (_value) * 1e3d,
-                        MolarEntropyUnit.MegajoulePerMoleKelvin => (_value) * 1e6d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MolarEntropyUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MolarEntropyUnit.JoulePerMoleKelvin => baseUnitValue,
-                        MolarEntropyUnit.KilojoulePerMoleKelvin => (baseUnitValue) / 1e3d,
-                        MolarEntropyUnit.MegajoulePerMoleKelvin => (baseUnitValue) / 1e6d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarFlow.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarFlow.g.cs
deleted file mode 100644
index 3aca64c697..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarFlow.g.cs
+++ /dev/null
@@ -1,253 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Molar flow is the ratio of the amount of substance change to the time during which the change occurred (value of amount of substance changes per unit time).
-    /// </summary>
-    public struct  MolarFlow
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MolarFlowUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MolarFlowUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MolarFlow(double value, MolarFlowUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MolarFlow, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MolarFlowUnit BaseUnit { get; } = MolarFlowUnit.MolePerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of MolarFlow.
-        /// </summary>
-        public static MolarFlow MaxValue { get; } = new MolarFlow(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MolarFlow.
-        /// </summary>
-        public static MolarFlow MinValue { get; } = new MolarFlow(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MolarFlow Zero { get; } = new MolarFlow(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.KilomolePerHour"/>
-        /// </summary>
-        public double KilomolesPerHour => As(MolarFlowUnit.KilomolePerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.KilomolePerMinute"/>
-        /// </summary>
-        public double KilomolesPerMinute => As(MolarFlowUnit.KilomolePerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.KilomolePerSecond"/>
-        /// </summary>
-        public double KilomolesPerSecond => As(MolarFlowUnit.KilomolePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.MolePerHour"/>
-        /// </summary>
-        public double MolesPerHour => As(MolarFlowUnit.MolePerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.MolePerMinute"/>
-        /// </summary>
-        public double MolesPerMinute => As(MolarFlowUnit.MolePerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.MolePerSecond"/>
-        /// </summary>
-        public double MolesPerSecond => As(MolarFlowUnit.MolePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.PoundMolePerHour"/>
-        /// </summary>
-        public double PoundMolesPerHour => As(MolarFlowUnit.PoundMolePerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.PoundMolePerMinute"/>
-        /// </summary>
-        public double PoundMolesPerMinute => As(MolarFlowUnit.PoundMolePerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.PoundMolePerSecond"/>
-        /// </summary>
-        public double PoundMolesPerSecond => As(MolarFlowUnit.PoundMolePerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerHour"/>.
-        /// </summary>
-        public static MolarFlow FromKilomolesPerHour(double kilomolesperhour) => new MolarFlow(kilomolesperhour, MolarFlowUnit.KilomolePerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerMinute"/>.
-        /// </summary>
-        public static MolarFlow FromKilomolesPerMinute(double kilomolesperminute) => new MolarFlow(kilomolesperminute, MolarFlowUnit.KilomolePerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerSecond"/>.
-        /// </summary>
-        public static MolarFlow FromKilomolesPerSecond(double kilomolespersecond) => new MolarFlow(kilomolespersecond, MolarFlowUnit.KilomolePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerHour"/>.
-        /// </summary>
-        public static MolarFlow FromMolesPerHour(double molesperhour) => new MolarFlow(molesperhour, MolarFlowUnit.MolePerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerMinute"/>.
-        /// </summary>
-        public static MolarFlow FromMolesPerMinute(double molesperminute) => new MolarFlow(molesperminute, MolarFlowUnit.MolePerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerSecond"/>.
-        /// </summary>
-        public static MolarFlow FromMolesPerSecond(double molespersecond) => new MolarFlow(molespersecond, MolarFlowUnit.MolePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerHour"/>.
-        /// </summary>
-        public static MolarFlow FromPoundMolesPerHour(double poundmolesperhour) => new MolarFlow(poundmolesperhour, MolarFlowUnit.PoundMolePerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerMinute"/>.
-        /// </summary>
-        public static MolarFlow FromPoundMolesPerMinute(double poundmolesperminute) => new MolarFlow(poundmolesperminute, MolarFlowUnit.PoundMolePerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerSecond"/>.
-        /// </summary>
-        public static MolarFlow FromPoundMolesPerSecond(double poundmolespersecond) => new MolarFlow(poundmolespersecond, MolarFlowUnit.PoundMolePerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MolarFlowUnit" /> to <see cref="MolarFlow" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MolarFlow unit value.</returns>
-        public static MolarFlow From(double value, MolarFlowUnit fromUnit)
-        {
-            return new MolarFlow(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MolarFlowUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MolarFlow to another MolarFlow with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MolarFlow with the specified unit.</returns>
-                public MolarFlow ToUnit(MolarFlowUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MolarFlow(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MolarFlowUnit.KilomolePerHour => (_value / 3600) * 1e3d,
-                        MolarFlowUnit.KilomolePerMinute => (_value / 60) * 1e3d,
-                        MolarFlowUnit.KilomolePerSecond => (_value) * 1e3d,
-                        MolarFlowUnit.MolePerHour => _value / 3600,
-                        MolarFlowUnit.MolePerMinute => _value / 60,
-                        MolarFlowUnit.MolePerSecond => _value,
-                        MolarFlowUnit.PoundMolePerHour => (_value * 453.59237) / 3600,
-                        MolarFlowUnit.PoundMolePerMinute => (_value * 453.59237) / 60,
-                        MolarFlowUnit.PoundMolePerSecond => _value * 453.59237,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MolarFlowUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MolarFlowUnit.KilomolePerHour => (baseUnitValue * 3600) / 1e3d,
-                        MolarFlowUnit.KilomolePerMinute => (baseUnitValue * 60) / 1e3d,
-                        MolarFlowUnit.KilomolePerSecond => (baseUnitValue) / 1e3d,
-                        MolarFlowUnit.MolePerHour => baseUnitValue * 3600,
-                        MolarFlowUnit.MolePerMinute => baseUnitValue * 60,
-                        MolarFlowUnit.MolePerSecond => baseUnitValue,
-                        MolarFlowUnit.PoundMolePerHour => (baseUnitValue / 453.59237) * 3600,
-                        MolarFlowUnit.PoundMolePerMinute => (baseUnitValue / 453.59237) * 60,
-                        MolarFlowUnit.PoundMolePerSecond => baseUnitValue / 453.59237,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarMass.g.cs
deleted file mode 100644
index a61a13b27b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MolarMass.g.cs
+++ /dev/null
@@ -1,301 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In chemistry, the molar mass M is a physical property defined as the mass of a given substance (chemical element or chemical compound) divided by the amount of substance.
-    /// </summary>
-    public struct  MolarMass
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MolarMassUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MolarMassUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MolarMass(double value, MolarMassUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of MolarMass, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MolarMassUnit BaseUnit { get; } = MolarMassUnit.KilogramPerMole;
-
-        /// <summary>
-        /// Represents the largest possible value of MolarMass.
-        /// </summary>
-        public static MolarMass MaxValue { get; } = new MolarMass(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of MolarMass.
-        /// </summary>
-        public static MolarMass MinValue { get; } = new MolarMass(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static MolarMass Zero { get; } = new MolarMass(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.CentigramPerMole"/>
-        /// </summary>
-        public double CentigramsPerMole => As(MolarMassUnit.CentigramPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.DecagramPerMole"/>
-        /// </summary>
-        public double DecagramsPerMole => As(MolarMassUnit.DecagramPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.DecigramPerMole"/>
-        /// </summary>
-        public double DecigramsPerMole => As(MolarMassUnit.DecigramPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.GramPerMole"/>
-        /// </summary>
-        public double GramsPerMole => As(MolarMassUnit.GramPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.HectogramPerMole"/>
-        /// </summary>
-        public double HectogramsPerMole => As(MolarMassUnit.HectogramPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.KilogramPerKilomole"/>
-        /// </summary>
-        public double KilogramsPerKilomole => As(MolarMassUnit.KilogramPerKilomole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.KilogramPerMole"/>
-        /// </summary>
-        public double KilogramsPerMole => As(MolarMassUnit.KilogramPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.KilopoundPerMole"/>
-        /// </summary>
-        public double KilopoundsPerMole => As(MolarMassUnit.KilopoundPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.MegapoundPerMole"/>
-        /// </summary>
-        public double MegapoundsPerMole => As(MolarMassUnit.MegapoundPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.MicrogramPerMole"/>
-        /// </summary>
-        public double MicrogramsPerMole => As(MolarMassUnit.MicrogramPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.MilligramPerMole"/>
-        /// </summary>
-        public double MilligramsPerMole => As(MolarMassUnit.MilligramPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.NanogramPerMole"/>
-        /// </summary>
-        public double NanogramsPerMole => As(MolarMassUnit.NanogramPerMole);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.PoundPerMole"/>
-        /// </summary>
-        public double PoundsPerMole => As(MolarMassUnit.PoundPerMole);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.CentigramPerMole"/>.
-        /// </summary>
-        public static MolarMass FromCentigramsPerMole(double centigramspermole) => new MolarMass(centigramspermole, MolarMassUnit.CentigramPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.DecagramPerMole"/>.
-        /// </summary>
-        public static MolarMass FromDecagramsPerMole(double decagramspermole) => new MolarMass(decagramspermole, MolarMassUnit.DecagramPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.DecigramPerMole"/>.
-        /// </summary>
-        public static MolarMass FromDecigramsPerMole(double decigramspermole) => new MolarMass(decigramspermole, MolarMassUnit.DecigramPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.GramPerMole"/>.
-        /// </summary>
-        public static MolarMass FromGramsPerMole(double gramspermole) => new MolarMass(gramspermole, MolarMassUnit.GramPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.HectogramPerMole"/>.
-        /// </summary>
-        public static MolarMass FromHectogramsPerMole(double hectogramspermole) => new MolarMass(hectogramspermole, MolarMassUnit.HectogramPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilogramPerKilomole"/>.
-        /// </summary>
-        public static MolarMass FromKilogramsPerKilomole(double kilogramsperkilomole) => new MolarMass(kilogramsperkilomole, MolarMassUnit.KilogramPerKilomole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilogramPerMole"/>.
-        /// </summary>
-        public static MolarMass FromKilogramsPerMole(double kilogramspermole) => new MolarMass(kilogramspermole, MolarMassUnit.KilogramPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilopoundPerMole"/>.
-        /// </summary>
-        public static MolarMass FromKilopoundsPerMole(double kilopoundspermole) => new MolarMass(kilopoundspermole, MolarMassUnit.KilopoundPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MegapoundPerMole"/>.
-        /// </summary>
-        public static MolarMass FromMegapoundsPerMole(double megapoundspermole) => new MolarMass(megapoundspermole, MolarMassUnit.MegapoundPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MicrogramPerMole"/>.
-        /// </summary>
-        public static MolarMass FromMicrogramsPerMole(double microgramspermole) => new MolarMass(microgramspermole, MolarMassUnit.MicrogramPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MilligramPerMole"/>.
-        /// </summary>
-        public static MolarMass FromMilligramsPerMole(double milligramspermole) => new MolarMass(milligramspermole, MolarMassUnit.MilligramPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.NanogramPerMole"/>.
-        /// </summary>
-        public static MolarMass FromNanogramsPerMole(double nanogramspermole) => new MolarMass(nanogramspermole, MolarMassUnit.NanogramPerMole);
-
-        /// <summary>
-        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.PoundPerMole"/>.
-        /// </summary>
-        public static MolarMass FromPoundsPerMole(double poundspermole) => new MolarMass(poundspermole, MolarMassUnit.PoundPerMole);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MolarMassUnit" /> to <see cref="MolarMass" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>MolarMass unit value.</returns>
-        public static MolarMass From(double value, MolarMassUnit fromUnit)
-        {
-            return new MolarMass(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MolarMassUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this MolarMass to another MolarMass with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A MolarMass with the specified unit.</returns>
-                public MolarMass ToUnit(MolarMassUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new MolarMass(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MolarMassUnit.CentigramPerMole => (_value / 1e3) * 1e-2d,
-                        MolarMassUnit.DecagramPerMole => (_value / 1e3) * 1e1d,
-                        MolarMassUnit.DecigramPerMole => (_value / 1e3) * 1e-1d,
-                        MolarMassUnit.GramPerMole => _value / 1e3,
-                        MolarMassUnit.HectogramPerMole => (_value / 1e3) * 1e2d,
-                        MolarMassUnit.KilogramPerKilomole => _value / 1e3,
-                        MolarMassUnit.KilogramPerMole => (_value / 1e3) * 1e3d,
-                        MolarMassUnit.KilopoundPerMole => (_value * 0.45359237) * 1e3d,
-                        MolarMassUnit.MegapoundPerMole => (_value * 0.45359237) * 1e6d,
-                        MolarMassUnit.MicrogramPerMole => (_value / 1e3) * 1e-6d,
-                        MolarMassUnit.MilligramPerMole => (_value / 1e3) * 1e-3d,
-                        MolarMassUnit.NanogramPerMole => (_value / 1e3) * 1e-9d,
-                        MolarMassUnit.PoundPerMole => _value * 0.45359237,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MolarMassUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MolarMassUnit.CentigramPerMole => (baseUnitValue * 1e3) / 1e-2d,
-                        MolarMassUnit.DecagramPerMole => (baseUnitValue * 1e3) / 1e1d,
-                        MolarMassUnit.DecigramPerMole => (baseUnitValue * 1e3) / 1e-1d,
-                        MolarMassUnit.GramPerMole => baseUnitValue * 1e3,
-                        MolarMassUnit.HectogramPerMole => (baseUnitValue * 1e3) / 1e2d,
-                        MolarMassUnit.KilogramPerKilomole => baseUnitValue * 1e3,
-                        MolarMassUnit.KilogramPerMole => (baseUnitValue * 1e3) / 1e3d,
-                        MolarMassUnit.KilopoundPerMole => (baseUnitValue / 0.45359237) / 1e3d,
-                        MolarMassUnit.MegapoundPerMole => (baseUnitValue / 0.45359237) / 1e6d,
-                        MolarMassUnit.MicrogramPerMole => (baseUnitValue * 1e3) / 1e-6d,
-                        MolarMassUnit.MilligramPerMole => (baseUnitValue * 1e3) / 1e-3d,
-                        MolarMassUnit.NanogramPerMole => (baseUnitValue * 1e3) / 1e-9d,
-                        MolarMassUnit.PoundPerMole => baseUnitValue / 0.45359237,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Molarity.g.cs
deleted file mode 100644
index 75a20a08f7..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Molarity.g.cs
+++ /dev/null
@@ -1,280 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Molar concentration, also called molarity, amount concentration or substance concentration, is a measure of the concentration of a solute in a solution, or of any chemical species, in terms of amount of substance in a given volume.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Molar_concentration
-    /// </remarks>
-    public struct  Molarity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly MolarityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public MolarityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Molarity(double value, MolarityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Molarity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static MolarityUnit BaseUnit { get; } = MolarityUnit.MolePerCubicMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Molarity.
-        /// </summary>
-        public static Molarity MaxValue { get; } = new Molarity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Molarity.
-        /// </summary>
-        public static Molarity MinValue { get; } = new Molarity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Molarity Zero { get; } = new Molarity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.CentimolePerLiter"/>
-        /// </summary>
-        public double CentimolesPerLiter => As(MolarityUnit.CentimolePerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.DecimolePerLiter"/>
-        /// </summary>
-        public double DecimolesPerLiter => As(MolarityUnit.DecimolePerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.FemtomolePerLiter"/>
-        /// </summary>
-        public double FemtomolesPerLiter => As(MolarityUnit.FemtomolePerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.KilomolePerCubicMeter"/>
-        /// </summary>
-        public double KilomolesPerCubicMeter => As(MolarityUnit.KilomolePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.MicromolePerLiter"/>
-        /// </summary>
-        public double MicromolesPerLiter => As(MolarityUnit.MicromolePerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.MillimolePerLiter"/>
-        /// </summary>
-        public double MillimolesPerLiter => As(MolarityUnit.MillimolePerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.MolePerCubicMeter"/>
-        /// </summary>
-        public double MolesPerCubicMeter => As(MolarityUnit.MolePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.MolePerLiter"/>
-        /// </summary>
-        public double MolesPerLiter => As(MolarityUnit.MolePerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.NanomolePerLiter"/>
-        /// </summary>
-        public double NanomolesPerLiter => As(MolarityUnit.NanomolePerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.PicomolePerLiter"/>
-        /// </summary>
-        public double PicomolesPerLiter => As(MolarityUnit.PicomolePerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.PoundMolePerCubicFoot"/>
-        /// </summary>
-        public double PoundMolesPerCubicFoot => As(MolarityUnit.PoundMolePerCubicFoot);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.CentimolePerLiter"/>.
-        /// </summary>
-        public static Molarity FromCentimolesPerLiter(double centimolesperliter) => new Molarity(centimolesperliter, MolarityUnit.CentimolePerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.DecimolePerLiter"/>.
-        /// </summary>
-        public static Molarity FromDecimolesPerLiter(double decimolesperliter) => new Molarity(decimolesperliter, MolarityUnit.DecimolePerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.FemtomolePerLiter"/>.
-        /// </summary>
-        public static Molarity FromFemtomolesPerLiter(double femtomolesperliter) => new Molarity(femtomolesperliter, MolarityUnit.FemtomolePerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.KilomolePerCubicMeter"/>.
-        /// </summary>
-        public static Molarity FromKilomolesPerCubicMeter(double kilomolespercubicmeter) => new Molarity(kilomolespercubicmeter, MolarityUnit.KilomolePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MicromolePerLiter"/>.
-        /// </summary>
-        public static Molarity FromMicromolesPerLiter(double micromolesperliter) => new Molarity(micromolesperliter, MolarityUnit.MicromolePerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MillimolePerLiter"/>.
-        /// </summary>
-        public static Molarity FromMillimolesPerLiter(double millimolesperliter) => new Molarity(millimolesperliter, MolarityUnit.MillimolePerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MolePerCubicMeter"/>.
-        /// </summary>
-        public static Molarity FromMolesPerCubicMeter(double molespercubicmeter) => new Molarity(molespercubicmeter, MolarityUnit.MolePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MolePerLiter"/>.
-        /// </summary>
-        public static Molarity FromMolesPerLiter(double molesperliter) => new Molarity(molesperliter, MolarityUnit.MolePerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.NanomolePerLiter"/>.
-        /// </summary>
-        public static Molarity FromNanomolesPerLiter(double nanomolesperliter) => new Molarity(nanomolesperliter, MolarityUnit.NanomolePerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.PicomolePerLiter"/>.
-        /// </summary>
-        public static Molarity FromPicomolesPerLiter(double picomolesperliter) => new Molarity(picomolesperliter, MolarityUnit.PicomolePerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.PoundMolePerCubicFoot"/>.
-        /// </summary>
-        public static Molarity FromPoundMolesPerCubicFoot(double poundmolespercubicfoot) => new Molarity(poundmolespercubicfoot, MolarityUnit.PoundMolePerCubicFoot);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="MolarityUnit" /> to <see cref="Molarity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Molarity unit value.</returns>
-        public static Molarity From(double value, MolarityUnit fromUnit)
-        {
-            return new Molarity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(MolarityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Molarity to another Molarity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Molarity with the specified unit.</returns>
-                public Molarity ToUnit(MolarityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Molarity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        MolarityUnit.CentimolePerLiter => (_value / 1e-3) * 1e-2d,
-                        MolarityUnit.DecimolePerLiter => (_value / 1e-3) * 1e-1d,
-                        MolarityUnit.FemtomolePerLiter => (_value / 1e-3) * 1e-15d,
-                        MolarityUnit.KilomolePerCubicMeter => (_value) * 1e3d,
-                        MolarityUnit.MicromolePerLiter => (_value / 1e-3) * 1e-6d,
-                        MolarityUnit.MillimolePerLiter => (_value / 1e-3) * 1e-3d,
-                        MolarityUnit.MolePerCubicMeter => _value,
-                        MolarityUnit.MolePerLiter => _value / 1e-3,
-                        MolarityUnit.NanomolePerLiter => (_value / 1e-3) * 1e-9d,
-                        MolarityUnit.PicomolePerLiter => (_value / 1e-3) * 1e-12d,
-                        MolarityUnit.PoundMolePerCubicFoot => _value * 1000 * 0.45359237 / 0.028316846592,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(MolarityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        MolarityUnit.CentimolePerLiter => (baseUnitValue * 1e-3) / 1e-2d,
-                        MolarityUnit.DecimolePerLiter => (baseUnitValue * 1e-3) / 1e-1d,
-                        MolarityUnit.FemtomolePerLiter => (baseUnitValue * 1e-3) / 1e-15d,
-                        MolarityUnit.KilomolePerCubicMeter => (baseUnitValue) / 1e3d,
-                        MolarityUnit.MicromolePerLiter => (baseUnitValue * 1e-3) / 1e-6d,
-                        MolarityUnit.MillimolePerLiter => (baseUnitValue * 1e-3) / 1e-3d,
-                        MolarityUnit.MolePerCubicMeter => baseUnitValue,
-                        MolarityUnit.MolePerLiter => baseUnitValue * 1e-3,
-                        MolarityUnit.NanomolePerLiter => (baseUnitValue * 1e-3) / 1e-9d,
-                        MolarityUnit.PicomolePerLiter => (baseUnitValue * 1e-3) / 1e-12d,
-                        MolarityUnit.PoundMolePerCubicFoot => baseUnitValue / (1000 * 0.45359237 / 0.028316846592),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Permeability.g.cs
deleted file mode 100644
index 98167f4a14..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Permeability.g.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In electromagnetism, permeability is the measure of the ability of a material to support the formation of a magnetic field within itself.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Permeability_(electromagnetism)
-    /// </remarks>
-    public struct  Permeability
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly PermeabilityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public PermeabilityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Permeability(double value, PermeabilityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Permeability, which is Second. All conversions go via this value.
-        /// </summary>
-        public static PermeabilityUnit BaseUnit { get; } = PermeabilityUnit.HenryPerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Permeability.
-        /// </summary>
-        public static Permeability MaxValue { get; } = new Permeability(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Permeability.
-        /// </summary>
-        public static Permeability MinValue { get; } = new Permeability(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Permeability Zero { get; } = new Permeability(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PermeabilityUnit.HenryPerMeter"/>
-        /// </summary>
-        public double HenriesPerMeter => As(PermeabilityUnit.HenryPerMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Permeability"/> from <see cref="PermeabilityUnit.HenryPerMeter"/>.
-        /// </summary>
-        public static Permeability FromHenriesPerMeter(double henriespermeter) => new Permeability(henriespermeter, PermeabilityUnit.HenryPerMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PermeabilityUnit" /> to <see cref="Permeability" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Permeability unit value.</returns>
-        public static Permeability From(double value, PermeabilityUnit fromUnit)
-        {
-            return new Permeability(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(PermeabilityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Permeability to another Permeability with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Permeability with the specified unit.</returns>
-                public Permeability ToUnit(PermeabilityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Permeability(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        PermeabilityUnit.HenryPerMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(PermeabilityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        PermeabilityUnit.HenryPerMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Permittivity.g.cs
deleted file mode 100644
index 22878acd37..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Permittivity.g.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In electromagnetism, permittivity is the measure of resistance that is encountered when forming an electric field in a particular medium.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Permittivity
-    /// </remarks>
-    public struct  Permittivity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly PermittivityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public PermittivityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Permittivity(double value, PermittivityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Permittivity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static PermittivityUnit BaseUnit { get; } = PermittivityUnit.FaradPerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Permittivity.
-        /// </summary>
-        public static Permittivity MaxValue { get; } = new Permittivity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Permittivity.
-        /// </summary>
-        public static Permittivity MinValue { get; } = new Permittivity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Permittivity Zero { get; } = new Permittivity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PermittivityUnit.FaradPerMeter"/>
-        /// </summary>
-        public double FaradsPerMeter => As(PermittivityUnit.FaradPerMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Permittivity"/> from <see cref="PermittivityUnit.FaradPerMeter"/>.
-        /// </summary>
-        public static Permittivity FromFaradsPerMeter(double faradspermeter) => new Permittivity(faradspermeter, PermittivityUnit.FaradPerMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PermittivityUnit" /> to <see cref="Permittivity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Permittivity unit value.</returns>
-        public static Permittivity From(double value, PermittivityUnit fromUnit)
-        {
-            return new Permittivity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(PermittivityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Permittivity to another Permittivity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Permittivity with the specified unit.</returns>
-                public Permittivity ToUnit(PermittivityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Permittivity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        PermittivityUnit.FaradPerMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(PermittivityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        PermittivityUnit.FaradPerMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/PorousMediumPermeability.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
deleted file mode 100644
index 06676e08ae..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
+++ /dev/null
@@ -1,208 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Permeability_(Earth_sciences)
-    /// </remarks>
-    public struct  PorousMediumPermeability
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly PorousMediumPermeabilityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public PorousMediumPermeabilityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public PorousMediumPermeability(double value, PorousMediumPermeabilityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of PorousMediumPermeability, which is Second. All conversions go via this value.
-        /// </summary>
-        public static PorousMediumPermeabilityUnit BaseUnit { get; } = PorousMediumPermeabilityUnit.SquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of PorousMediumPermeability.
-        /// </summary>
-        public static PorousMediumPermeability MaxValue { get; } = new PorousMediumPermeability(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of PorousMediumPermeability.
-        /// </summary>
-        public static PorousMediumPermeability MinValue { get; } = new PorousMediumPermeability(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static PorousMediumPermeability Zero { get; } = new PorousMediumPermeability(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.Darcy"/>
-        /// </summary>
-        public double Darcys => As(PorousMediumPermeabilityUnit.Darcy);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.Microdarcy"/>
-        /// </summary>
-        public double Microdarcys => As(PorousMediumPermeabilityUnit.Microdarcy);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.Millidarcy"/>
-        /// </summary>
-        public double Millidarcys => As(PorousMediumPermeabilityUnit.Millidarcy);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.SquareCentimeter"/>
-        /// </summary>
-        public double SquareCentimeters => As(PorousMediumPermeabilityUnit.SquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.SquareMeter"/>
-        /// </summary>
-        public double SquareMeters => As(PorousMediumPermeabilityUnit.SquareMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Darcy"/>.
-        /// </summary>
-        public static PorousMediumPermeability FromDarcys(double darcys) => new PorousMediumPermeability(darcys, PorousMediumPermeabilityUnit.Darcy);
-
-        /// <summary>
-        ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Microdarcy"/>.
-        /// </summary>
-        public static PorousMediumPermeability FromMicrodarcys(double microdarcys) => new PorousMediumPermeability(microdarcys, PorousMediumPermeabilityUnit.Microdarcy);
-
-        /// <summary>
-        ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Millidarcy"/>.
-        /// </summary>
-        public static PorousMediumPermeability FromMillidarcys(double millidarcys) => new PorousMediumPermeability(millidarcys, PorousMediumPermeabilityUnit.Millidarcy);
-
-        /// <summary>
-        ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.SquareCentimeter"/>.
-        /// </summary>
-        public static PorousMediumPermeability FromSquareCentimeters(double squarecentimeters) => new PorousMediumPermeability(squarecentimeters, PorousMediumPermeabilityUnit.SquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.SquareMeter"/>.
-        /// </summary>
-        public static PorousMediumPermeability FromSquareMeters(double squaremeters) => new PorousMediumPermeability(squaremeters, PorousMediumPermeabilityUnit.SquareMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PorousMediumPermeabilityUnit" /> to <see cref="PorousMediumPermeability" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>PorousMediumPermeability unit value.</returns>
-        public static PorousMediumPermeability From(double value, PorousMediumPermeabilityUnit fromUnit)
-        {
-            return new PorousMediumPermeability(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(PorousMediumPermeabilityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this PorousMediumPermeability to another PorousMediumPermeability with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A PorousMediumPermeability with the specified unit.</returns>
-                public PorousMediumPermeability ToUnit(PorousMediumPermeabilityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new PorousMediumPermeability(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        PorousMediumPermeabilityUnit.Darcy => _value * 9.869233e-13,
-                        PorousMediumPermeabilityUnit.Microdarcy => (_value * 9.869233e-13) * 1e-6d,
-                        PorousMediumPermeabilityUnit.Millidarcy => (_value * 9.869233e-13) * 1e-3d,
-                        PorousMediumPermeabilityUnit.SquareCentimeter => _value * 1e-4,
-                        PorousMediumPermeabilityUnit.SquareMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(PorousMediumPermeabilityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        PorousMediumPermeabilityUnit.Darcy => baseUnitValue / 9.869233e-13,
-                        PorousMediumPermeabilityUnit.Microdarcy => (baseUnitValue / 9.869233e-13) / 1e-6d,
-                        PorousMediumPermeabilityUnit.Millidarcy => (baseUnitValue / 9.869233e-13) / 1e-3d,
-                        PorousMediumPermeabilityUnit.SquareCentimeter => baseUnitValue / 1e-4,
-                        PorousMediumPermeabilityUnit.SquareMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Power.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Power.g.cs
deleted file mode 100644
index d06e73550e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Power.g.cs
+++ /dev/null
@@ -1,469 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In physics, power is the rate of doing work. It is equivalent to an amount of energy consumed per unit time.
-    /// </summary>
-    public struct  Power
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly PowerUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public PowerUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Power(double value, PowerUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Power, which is Second. All conversions go via this value.
-        /// </summary>
-        public static PowerUnit BaseUnit { get; } = PowerUnit.Watt;
-
-        /// <summary>
-        /// Represents the largest possible value of Power.
-        /// </summary>
-        public static Power MaxValue { get; } = new Power(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Power.
-        /// </summary>
-        public static Power MinValue { get; } = new Power(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Power Zero { get; } = new Power(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.BoilerHorsepower"/>
-        /// </summary>
-        public double BoilerHorsepower => As(PowerUnit.BoilerHorsepower);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.BritishThermalUnitPerHour"/>
-        /// </summary>
-        public double BritishThermalUnitsPerHour => As(PowerUnit.BritishThermalUnitPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Decawatt"/>
-        /// </summary>
-        public double Decawatts => As(PowerUnit.Decawatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Deciwatt"/>
-        /// </summary>
-        public double Deciwatts => As(PowerUnit.Deciwatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.ElectricalHorsepower"/>
-        /// </summary>
-        public double ElectricalHorsepower => As(PowerUnit.ElectricalHorsepower);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Femtowatt"/>
-        /// </summary>
-        public double Femtowatts => As(PowerUnit.Femtowatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.GigajoulePerHour"/>
-        /// </summary>
-        public double GigajoulesPerHour => As(PowerUnit.GigajoulePerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Gigawatt"/>
-        /// </summary>
-        public double Gigawatts => As(PowerUnit.Gigawatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.HydraulicHorsepower"/>
-        /// </summary>
-        public double HydraulicHorsepower => As(PowerUnit.HydraulicHorsepower);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.JoulePerHour"/>
-        /// </summary>
-        public double JoulesPerHour => As(PowerUnit.JoulePerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.KilobritishThermalUnitPerHour"/>
-        /// </summary>
-        public double KilobritishThermalUnitsPerHour => As(PowerUnit.KilobritishThermalUnitPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.KilojoulePerHour"/>
-        /// </summary>
-        public double KilojoulesPerHour => As(PowerUnit.KilojoulePerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Kilowatt"/>
-        /// </summary>
-        public double Kilowatts => As(PowerUnit.Kilowatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.MechanicalHorsepower"/>
-        /// </summary>
-        public double MechanicalHorsepower => As(PowerUnit.MechanicalHorsepower);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.MegabritishThermalUnitPerHour"/>
-        /// </summary>
-        public double MegabritishThermalUnitsPerHour => As(PowerUnit.MegabritishThermalUnitPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.MegajoulePerHour"/>
-        /// </summary>
-        public double MegajoulesPerHour => As(PowerUnit.MegajoulePerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Megawatt"/>
-        /// </summary>
-        public double Megawatts => As(PowerUnit.Megawatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.MetricHorsepower"/>
-        /// </summary>
-        public double MetricHorsepower => As(PowerUnit.MetricHorsepower);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Microwatt"/>
-        /// </summary>
-        public double Microwatts => As(PowerUnit.Microwatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.MillijoulePerHour"/>
-        /// </summary>
-        public double MillijoulesPerHour => As(PowerUnit.MillijoulePerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Milliwatt"/>
-        /// </summary>
-        public double Milliwatts => As(PowerUnit.Milliwatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Nanowatt"/>
-        /// </summary>
-        public double Nanowatts => As(PowerUnit.Nanowatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Petawatt"/>
-        /// </summary>
-        public double Petawatts => As(PowerUnit.Petawatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Picowatt"/>
-        /// </summary>
-        public double Picowatts => As(PowerUnit.Picowatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Terawatt"/>
-        /// </summary>
-        public double Terawatts => As(PowerUnit.Terawatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.TonOfRefrigeration"/>
-        /// </summary>
-        public double TonsOfRefrigeration => As(PowerUnit.TonOfRefrigeration);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Watt"/>
-        /// </summary>
-        public double Watts => As(PowerUnit.Watt);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.BoilerHorsepower"/>.
-        /// </summary>
-        public static Power FromBoilerHorsepower(double boilerhorsepower) => new Power(boilerhorsepower, PowerUnit.BoilerHorsepower);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.BritishThermalUnitPerHour"/>.
-        /// </summary>
-        public static Power FromBritishThermalUnitsPerHour(double britishthermalunitsperhour) => new Power(britishthermalunitsperhour, PowerUnit.BritishThermalUnitPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Decawatt"/>.
-        /// </summary>
-        public static Power FromDecawatts(double decawatts) => new Power(decawatts, PowerUnit.Decawatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Deciwatt"/>.
-        /// </summary>
-        public static Power FromDeciwatts(double deciwatts) => new Power(deciwatts, PowerUnit.Deciwatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.ElectricalHorsepower"/>.
-        /// </summary>
-        public static Power FromElectricalHorsepower(double electricalhorsepower) => new Power(electricalhorsepower, PowerUnit.ElectricalHorsepower);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Femtowatt"/>.
-        /// </summary>
-        public static Power FromFemtowatts(double femtowatts) => new Power(femtowatts, PowerUnit.Femtowatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.GigajoulePerHour"/>.
-        /// </summary>
-        public static Power FromGigajoulesPerHour(double gigajoulesperhour) => new Power(gigajoulesperhour, PowerUnit.GigajoulePerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Gigawatt"/>.
-        /// </summary>
-        public static Power FromGigawatts(double gigawatts) => new Power(gigawatts, PowerUnit.Gigawatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.HydraulicHorsepower"/>.
-        /// </summary>
-        public static Power FromHydraulicHorsepower(double hydraulichorsepower) => new Power(hydraulichorsepower, PowerUnit.HydraulicHorsepower);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.JoulePerHour"/>.
-        /// </summary>
-        public static Power FromJoulesPerHour(double joulesperhour) => new Power(joulesperhour, PowerUnit.JoulePerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.KilobritishThermalUnitPerHour"/>.
-        /// </summary>
-        public static Power FromKilobritishThermalUnitsPerHour(double kilobritishthermalunitsperhour) => new Power(kilobritishthermalunitsperhour, PowerUnit.KilobritishThermalUnitPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.KilojoulePerHour"/>.
-        /// </summary>
-        public static Power FromKilojoulesPerHour(double kilojoulesperhour) => new Power(kilojoulesperhour, PowerUnit.KilojoulePerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Kilowatt"/>.
-        /// </summary>
-        public static Power FromKilowatts(double kilowatts) => new Power(kilowatts, PowerUnit.Kilowatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MechanicalHorsepower"/>.
-        /// </summary>
-        public static Power FromMechanicalHorsepower(double mechanicalhorsepower) => new Power(mechanicalhorsepower, PowerUnit.MechanicalHorsepower);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MegabritishThermalUnitPerHour"/>.
-        /// </summary>
-        public static Power FromMegabritishThermalUnitsPerHour(double megabritishthermalunitsperhour) => new Power(megabritishthermalunitsperhour, PowerUnit.MegabritishThermalUnitPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MegajoulePerHour"/>.
-        /// </summary>
-        public static Power FromMegajoulesPerHour(double megajoulesperhour) => new Power(megajoulesperhour, PowerUnit.MegajoulePerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Megawatt"/>.
-        /// </summary>
-        public static Power FromMegawatts(double megawatts) => new Power(megawatts, PowerUnit.Megawatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MetricHorsepower"/>.
-        /// </summary>
-        public static Power FromMetricHorsepower(double metrichorsepower) => new Power(metrichorsepower, PowerUnit.MetricHorsepower);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Microwatt"/>.
-        /// </summary>
-        public static Power FromMicrowatts(double microwatts) => new Power(microwatts, PowerUnit.Microwatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MillijoulePerHour"/>.
-        /// </summary>
-        public static Power FromMillijoulesPerHour(double millijoulesperhour) => new Power(millijoulesperhour, PowerUnit.MillijoulePerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Milliwatt"/>.
-        /// </summary>
-        public static Power FromMilliwatts(double milliwatts) => new Power(milliwatts, PowerUnit.Milliwatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Nanowatt"/>.
-        /// </summary>
-        public static Power FromNanowatts(double nanowatts) => new Power(nanowatts, PowerUnit.Nanowatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Petawatt"/>.
-        /// </summary>
-        public static Power FromPetawatts(double petawatts) => new Power(petawatts, PowerUnit.Petawatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Picowatt"/>.
-        /// </summary>
-        public static Power FromPicowatts(double picowatts) => new Power(picowatts, PowerUnit.Picowatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Terawatt"/>.
-        /// </summary>
-        public static Power FromTerawatts(double terawatts) => new Power(terawatts, PowerUnit.Terawatt);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.TonOfRefrigeration"/>.
-        /// </summary>
-        public static Power FromTonsOfRefrigeration(double tonsofrefrigeration) => new Power(tonsofrefrigeration, PowerUnit.TonOfRefrigeration);
-
-        /// <summary>
-        ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Watt"/>.
-        /// </summary>
-        public static Power FromWatts(double watts) => new Power(watts, PowerUnit.Watt);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PowerUnit" /> to <see cref="Power" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Power unit value.</returns>
-        public static Power From(double value, PowerUnit fromUnit)
-        {
-            return new Power(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(PowerUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Power to another Power with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Power with the specified unit.</returns>
-                public Power ToUnit(PowerUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Power(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        PowerUnit.BoilerHorsepower => _value * 9812.5,
-                        PowerUnit.BritishThermalUnitPerHour => _value * 1055.05585262 / 3600,
-                        PowerUnit.Decawatt => (_value) * 1e1d,
-                        PowerUnit.Deciwatt => (_value) * 1e-1d,
-                        PowerUnit.ElectricalHorsepower => _value * 746,
-                        PowerUnit.Femtowatt => (_value) * 1e-15d,
-                        PowerUnit.GigajoulePerHour => (_value / 3600) * 1e9d,
-                        PowerUnit.Gigawatt => (_value) * 1e9d,
-                        PowerUnit.HydraulicHorsepower => _value * 745.69987158227022,
-                        PowerUnit.JoulePerHour => _value / 3600,
-                        PowerUnit.KilobritishThermalUnitPerHour => (_value * 1055.05585262 / 3600) * 1e3d,
-                        PowerUnit.KilojoulePerHour => (_value / 3600) * 1e3d,
-                        PowerUnit.Kilowatt => (_value) * 1e3d,
-                        PowerUnit.MechanicalHorsepower => _value * 76.0402249 * 9.80665,
-                        PowerUnit.MegabritishThermalUnitPerHour => (_value * 1055.05585262 / 3600) * 1e6d,
-                        PowerUnit.MegajoulePerHour => (_value / 3600) * 1e6d,
-                        PowerUnit.Megawatt => (_value) * 1e6d,
-                        PowerUnit.MetricHorsepower => _value * 75 * 9.80665,
-                        PowerUnit.Microwatt => (_value) * 1e-6d,
-                        PowerUnit.MillijoulePerHour => (_value / 3600) * 1e-3d,
-                        PowerUnit.Milliwatt => (_value) * 1e-3d,
-                        PowerUnit.Nanowatt => (_value) * 1e-9d,
-                        PowerUnit.Petawatt => (_value) * 1e15d,
-                        PowerUnit.Picowatt => (_value) * 1e-12d,
-                        PowerUnit.Terawatt => (_value) * 1e12d,
-                        PowerUnit.TonOfRefrigeration => _value * 3516.853,
-                        PowerUnit.Watt => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(PowerUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        PowerUnit.BoilerHorsepower => baseUnitValue / 9812.5,
-                        PowerUnit.BritishThermalUnitPerHour => baseUnitValue * 3600 / 1055.05585262,
-                        PowerUnit.Decawatt => (baseUnitValue) / 1e1d,
-                        PowerUnit.Deciwatt => (baseUnitValue) / 1e-1d,
-                        PowerUnit.ElectricalHorsepower => baseUnitValue / 746,
-                        PowerUnit.Femtowatt => (baseUnitValue) / 1e-15d,
-                        PowerUnit.GigajoulePerHour => (baseUnitValue * 3600) / 1e9d,
-                        PowerUnit.Gigawatt => (baseUnitValue) / 1e9d,
-                        PowerUnit.HydraulicHorsepower => baseUnitValue / 745.69987158227022,
-                        PowerUnit.JoulePerHour => baseUnitValue * 3600,
-                        PowerUnit.KilobritishThermalUnitPerHour => (baseUnitValue * 3600 / 1055.05585262) / 1e3d,
-                        PowerUnit.KilojoulePerHour => (baseUnitValue * 3600) / 1e3d,
-                        PowerUnit.Kilowatt => (baseUnitValue) / 1e3d,
-                        PowerUnit.MechanicalHorsepower => baseUnitValue / (76.0402249 * 9.80665),
-                        PowerUnit.MegabritishThermalUnitPerHour => (baseUnitValue * 3600 / 1055.05585262) / 1e6d,
-                        PowerUnit.MegajoulePerHour => (baseUnitValue * 3600) / 1e6d,
-                        PowerUnit.Megawatt => (baseUnitValue) / 1e6d,
-                        PowerUnit.MetricHorsepower => baseUnitValue / (75 * 9.80665),
-                        PowerUnit.Microwatt => (baseUnitValue) / 1e-6d,
-                        PowerUnit.MillijoulePerHour => (baseUnitValue * 3600) / 1e-3d,
-                        PowerUnit.Milliwatt => (baseUnitValue) / 1e-3d,
-                        PowerUnit.Nanowatt => (baseUnitValue) / 1e-9d,
-                        PowerUnit.Petawatt => (baseUnitValue) / 1e15d,
-                        PowerUnit.Picowatt => (baseUnitValue) / 1e-12d,
-                        PowerUnit.Terawatt => (baseUnitValue) / 1e12d,
-                        PowerUnit.TonOfRefrigeration => baseUnitValue / 3516.853,
-                        PowerUnit.Watt => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/PowerDensity.g.cs
deleted file mode 100644
index 0ad6bd97a9..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/PowerDensity.g.cs
+++ /dev/null
@@ -1,673 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The amount of power in a volume.
-    /// </summary>
-    public struct  PowerDensity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly PowerDensityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public PowerDensityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public PowerDensity(double value, PowerDensityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of PowerDensity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static PowerDensityUnit BaseUnit { get; } = PowerDensityUnit.WattPerCubicMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of PowerDensity.
-        /// </summary>
-        public static PowerDensity MaxValue { get; } = new PowerDensity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of PowerDensity.
-        /// </summary>
-        public static PowerDensity MinValue { get; } = new PowerDensity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static PowerDensity Zero { get; } = new PowerDensity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerCubicFoot"/>
-        /// </summary>
-        public double DecawattsPerCubicFoot => As(PowerDensityUnit.DecawattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerCubicInch"/>
-        /// </summary>
-        public double DecawattsPerCubicInch => As(PowerDensityUnit.DecawattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerCubicMeter"/>
-        /// </summary>
-        public double DecawattsPerCubicMeter => As(PowerDensityUnit.DecawattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerLiter"/>
-        /// </summary>
-        public double DecawattsPerLiter => As(PowerDensityUnit.DecawattPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerCubicFoot"/>
-        /// </summary>
-        public double DeciwattsPerCubicFoot => As(PowerDensityUnit.DeciwattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerCubicInch"/>
-        /// </summary>
-        public double DeciwattsPerCubicInch => As(PowerDensityUnit.DeciwattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerCubicMeter"/>
-        /// </summary>
-        public double DeciwattsPerCubicMeter => As(PowerDensityUnit.DeciwattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerLiter"/>
-        /// </summary>
-        public double DeciwattsPerLiter => As(PowerDensityUnit.DeciwattPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerCubicFoot"/>
-        /// </summary>
-        public double GigawattsPerCubicFoot => As(PowerDensityUnit.GigawattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerCubicInch"/>
-        /// </summary>
-        public double GigawattsPerCubicInch => As(PowerDensityUnit.GigawattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerCubicMeter"/>
-        /// </summary>
-        public double GigawattsPerCubicMeter => As(PowerDensityUnit.GigawattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerLiter"/>
-        /// </summary>
-        public double GigawattsPerLiter => As(PowerDensityUnit.GigawattPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerCubicFoot"/>
-        /// </summary>
-        public double KilowattsPerCubicFoot => As(PowerDensityUnit.KilowattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerCubicInch"/>
-        /// </summary>
-        public double KilowattsPerCubicInch => As(PowerDensityUnit.KilowattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerCubicMeter"/>
-        /// </summary>
-        public double KilowattsPerCubicMeter => As(PowerDensityUnit.KilowattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerLiter"/>
-        /// </summary>
-        public double KilowattsPerLiter => As(PowerDensityUnit.KilowattPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerCubicFoot"/>
-        /// </summary>
-        public double MegawattsPerCubicFoot => As(PowerDensityUnit.MegawattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerCubicInch"/>
-        /// </summary>
-        public double MegawattsPerCubicInch => As(PowerDensityUnit.MegawattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerCubicMeter"/>
-        /// </summary>
-        public double MegawattsPerCubicMeter => As(PowerDensityUnit.MegawattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerLiter"/>
-        /// </summary>
-        public double MegawattsPerLiter => As(PowerDensityUnit.MegawattPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerCubicFoot"/>
-        /// </summary>
-        public double MicrowattsPerCubicFoot => As(PowerDensityUnit.MicrowattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerCubicInch"/>
-        /// </summary>
-        public double MicrowattsPerCubicInch => As(PowerDensityUnit.MicrowattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerCubicMeter"/>
-        /// </summary>
-        public double MicrowattsPerCubicMeter => As(PowerDensityUnit.MicrowattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerLiter"/>
-        /// </summary>
-        public double MicrowattsPerLiter => As(PowerDensityUnit.MicrowattPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerCubicFoot"/>
-        /// </summary>
-        public double MilliwattsPerCubicFoot => As(PowerDensityUnit.MilliwattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerCubicInch"/>
-        /// </summary>
-        public double MilliwattsPerCubicInch => As(PowerDensityUnit.MilliwattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerCubicMeter"/>
-        /// </summary>
-        public double MilliwattsPerCubicMeter => As(PowerDensityUnit.MilliwattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerLiter"/>
-        /// </summary>
-        public double MilliwattsPerLiter => As(PowerDensityUnit.MilliwattPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerCubicFoot"/>
-        /// </summary>
-        public double NanowattsPerCubicFoot => As(PowerDensityUnit.NanowattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerCubicInch"/>
-        /// </summary>
-        public double NanowattsPerCubicInch => As(PowerDensityUnit.NanowattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerCubicMeter"/>
-        /// </summary>
-        public double NanowattsPerCubicMeter => As(PowerDensityUnit.NanowattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerLiter"/>
-        /// </summary>
-        public double NanowattsPerLiter => As(PowerDensityUnit.NanowattPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerCubicFoot"/>
-        /// </summary>
-        public double PicowattsPerCubicFoot => As(PowerDensityUnit.PicowattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerCubicInch"/>
-        /// </summary>
-        public double PicowattsPerCubicInch => As(PowerDensityUnit.PicowattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerCubicMeter"/>
-        /// </summary>
-        public double PicowattsPerCubicMeter => As(PowerDensityUnit.PicowattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerLiter"/>
-        /// </summary>
-        public double PicowattsPerLiter => As(PowerDensityUnit.PicowattPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerCubicFoot"/>
-        /// </summary>
-        public double TerawattsPerCubicFoot => As(PowerDensityUnit.TerawattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerCubicInch"/>
-        /// </summary>
-        public double TerawattsPerCubicInch => As(PowerDensityUnit.TerawattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerCubicMeter"/>
-        /// </summary>
-        public double TerawattsPerCubicMeter => As(PowerDensityUnit.TerawattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerLiter"/>
-        /// </summary>
-        public double TerawattsPerLiter => As(PowerDensityUnit.TerawattPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerCubicFoot"/>
-        /// </summary>
-        public double WattsPerCubicFoot => As(PowerDensityUnit.WattPerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerCubicInch"/>
-        /// </summary>
-        public double WattsPerCubicInch => As(PowerDensityUnit.WattPerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerCubicMeter"/>
-        /// </summary>
-        public double WattsPerCubicMeter => As(PowerDensityUnit.WattPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerLiter"/>
-        /// </summary>
-        public double WattsPerLiter => As(PowerDensityUnit.WattPerLiter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromDecawattsPerCubicFoot(double decawattspercubicfoot) => new PowerDensity(decawattspercubicfoot, PowerDensityUnit.DecawattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromDecawattsPerCubicInch(double decawattspercubicinch) => new PowerDensity(decawattspercubicinch, PowerDensityUnit.DecawattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromDecawattsPerCubicMeter(double decawattspercubicmeter) => new PowerDensity(decawattspercubicmeter, PowerDensityUnit.DecawattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromDecawattsPerLiter(double decawattsperliter) => new PowerDensity(decawattsperliter, PowerDensityUnit.DecawattPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromDeciwattsPerCubicFoot(double deciwattspercubicfoot) => new PowerDensity(deciwattspercubicfoot, PowerDensityUnit.DeciwattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromDeciwattsPerCubicInch(double deciwattspercubicinch) => new PowerDensity(deciwattspercubicinch, PowerDensityUnit.DeciwattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromDeciwattsPerCubicMeter(double deciwattspercubicmeter) => new PowerDensity(deciwattspercubicmeter, PowerDensityUnit.DeciwattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromDeciwattsPerLiter(double deciwattsperliter) => new PowerDensity(deciwattsperliter, PowerDensityUnit.DeciwattPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromGigawattsPerCubicFoot(double gigawattspercubicfoot) => new PowerDensity(gigawattspercubicfoot, PowerDensityUnit.GigawattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromGigawattsPerCubicInch(double gigawattspercubicinch) => new PowerDensity(gigawattspercubicinch, PowerDensityUnit.GigawattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromGigawattsPerCubicMeter(double gigawattspercubicmeter) => new PowerDensity(gigawattspercubicmeter, PowerDensityUnit.GigawattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromGigawattsPerLiter(double gigawattsperliter) => new PowerDensity(gigawattsperliter, PowerDensityUnit.GigawattPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromKilowattsPerCubicFoot(double kilowattspercubicfoot) => new PowerDensity(kilowattspercubicfoot, PowerDensityUnit.KilowattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromKilowattsPerCubicInch(double kilowattspercubicinch) => new PowerDensity(kilowattspercubicinch, PowerDensityUnit.KilowattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromKilowattsPerCubicMeter(double kilowattspercubicmeter) => new PowerDensity(kilowattspercubicmeter, PowerDensityUnit.KilowattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromKilowattsPerLiter(double kilowattsperliter) => new PowerDensity(kilowattsperliter, PowerDensityUnit.KilowattPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromMegawattsPerCubicFoot(double megawattspercubicfoot) => new PowerDensity(megawattspercubicfoot, PowerDensityUnit.MegawattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromMegawattsPerCubicInch(double megawattspercubicinch) => new PowerDensity(megawattspercubicinch, PowerDensityUnit.MegawattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromMegawattsPerCubicMeter(double megawattspercubicmeter) => new PowerDensity(megawattspercubicmeter, PowerDensityUnit.MegawattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromMegawattsPerLiter(double megawattsperliter) => new PowerDensity(megawattsperliter, PowerDensityUnit.MegawattPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromMicrowattsPerCubicFoot(double microwattspercubicfoot) => new PowerDensity(microwattspercubicfoot, PowerDensityUnit.MicrowattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromMicrowattsPerCubicInch(double microwattspercubicinch) => new PowerDensity(microwattspercubicinch, PowerDensityUnit.MicrowattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromMicrowattsPerCubicMeter(double microwattspercubicmeter) => new PowerDensity(microwattspercubicmeter, PowerDensityUnit.MicrowattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromMicrowattsPerLiter(double microwattsperliter) => new PowerDensity(microwattsperliter, PowerDensityUnit.MicrowattPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromMilliwattsPerCubicFoot(double milliwattspercubicfoot) => new PowerDensity(milliwattspercubicfoot, PowerDensityUnit.MilliwattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromMilliwattsPerCubicInch(double milliwattspercubicinch) => new PowerDensity(milliwattspercubicinch, PowerDensityUnit.MilliwattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromMilliwattsPerCubicMeter(double milliwattspercubicmeter) => new PowerDensity(milliwattspercubicmeter, PowerDensityUnit.MilliwattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromMilliwattsPerLiter(double milliwattsperliter) => new PowerDensity(milliwattsperliter, PowerDensityUnit.MilliwattPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromNanowattsPerCubicFoot(double nanowattspercubicfoot) => new PowerDensity(nanowattspercubicfoot, PowerDensityUnit.NanowattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromNanowattsPerCubicInch(double nanowattspercubicinch) => new PowerDensity(nanowattspercubicinch, PowerDensityUnit.NanowattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromNanowattsPerCubicMeter(double nanowattspercubicmeter) => new PowerDensity(nanowattspercubicmeter, PowerDensityUnit.NanowattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromNanowattsPerLiter(double nanowattsperliter) => new PowerDensity(nanowattsperliter, PowerDensityUnit.NanowattPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromPicowattsPerCubicFoot(double picowattspercubicfoot) => new PowerDensity(picowattspercubicfoot, PowerDensityUnit.PicowattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromPicowattsPerCubicInch(double picowattspercubicinch) => new PowerDensity(picowattspercubicinch, PowerDensityUnit.PicowattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromPicowattsPerCubicMeter(double picowattspercubicmeter) => new PowerDensity(picowattspercubicmeter, PowerDensityUnit.PicowattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromPicowattsPerLiter(double picowattsperliter) => new PowerDensity(picowattsperliter, PowerDensityUnit.PicowattPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromTerawattsPerCubicFoot(double terawattspercubicfoot) => new PowerDensity(terawattspercubicfoot, PowerDensityUnit.TerawattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromTerawattsPerCubicInch(double terawattspercubicinch) => new PowerDensity(terawattspercubicinch, PowerDensityUnit.TerawattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromTerawattsPerCubicMeter(double terawattspercubicmeter) => new PowerDensity(terawattspercubicmeter, PowerDensityUnit.TerawattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromTerawattsPerLiter(double terawattsperliter) => new PowerDensity(terawattsperliter, PowerDensityUnit.TerawattPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicFoot"/>.
-        /// </summary>
-        public static PowerDensity FromWattsPerCubicFoot(double wattspercubicfoot) => new PowerDensity(wattspercubicfoot, PowerDensityUnit.WattPerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicInch"/>.
-        /// </summary>
-        public static PowerDensity FromWattsPerCubicInch(double wattspercubicinch) => new PowerDensity(wattspercubicinch, PowerDensityUnit.WattPerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicMeter"/>.
-        /// </summary>
-        public static PowerDensity FromWattsPerCubicMeter(double wattspercubicmeter) => new PowerDensity(wattspercubicmeter, PowerDensityUnit.WattPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerLiter"/>.
-        /// </summary>
-        public static PowerDensity FromWattsPerLiter(double wattsperliter) => new PowerDensity(wattsperliter, PowerDensityUnit.WattPerLiter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PowerDensityUnit" /> to <see cref="PowerDensity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>PowerDensity unit value.</returns>
-        public static PowerDensity From(double value, PowerDensityUnit fromUnit)
-        {
-            return new PowerDensity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(PowerDensityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this PowerDensity to another PowerDensity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A PowerDensity with the specified unit.</returns>
-                public PowerDensity ToUnit(PowerDensityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new PowerDensity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        PowerDensityUnit.DecawattPerCubicFoot => (_value / 0.028316846592) * 1e1d,
-                        PowerDensityUnit.DecawattPerCubicInch => (_value / 1.6387064e-5) * 1e1d,
-                        PowerDensityUnit.DecawattPerCubicMeter => (_value) * 1e1d,
-                        PowerDensityUnit.DecawattPerLiter => (_value * 1.0e3) * 1e1d,
-                        PowerDensityUnit.DeciwattPerCubicFoot => (_value / 0.028316846592) * 1e-1d,
-                        PowerDensityUnit.DeciwattPerCubicInch => (_value / 1.6387064e-5) * 1e-1d,
-                        PowerDensityUnit.DeciwattPerCubicMeter => (_value) * 1e-1d,
-                        PowerDensityUnit.DeciwattPerLiter => (_value * 1.0e3) * 1e-1d,
-                        PowerDensityUnit.GigawattPerCubicFoot => (_value / 0.028316846592) * 1e9d,
-                        PowerDensityUnit.GigawattPerCubicInch => (_value / 1.6387064e-5) * 1e9d,
-                        PowerDensityUnit.GigawattPerCubicMeter => (_value) * 1e9d,
-                        PowerDensityUnit.GigawattPerLiter => (_value * 1.0e3) * 1e9d,
-                        PowerDensityUnit.KilowattPerCubicFoot => (_value / 0.028316846592) * 1e3d,
-                        PowerDensityUnit.KilowattPerCubicInch => (_value / 1.6387064e-5) * 1e3d,
-                        PowerDensityUnit.KilowattPerCubicMeter => (_value) * 1e3d,
-                        PowerDensityUnit.KilowattPerLiter => (_value * 1.0e3) * 1e3d,
-                        PowerDensityUnit.MegawattPerCubicFoot => (_value / 0.028316846592) * 1e6d,
-                        PowerDensityUnit.MegawattPerCubicInch => (_value / 1.6387064e-5) * 1e6d,
-                        PowerDensityUnit.MegawattPerCubicMeter => (_value) * 1e6d,
-                        PowerDensityUnit.MegawattPerLiter => (_value * 1.0e3) * 1e6d,
-                        PowerDensityUnit.MicrowattPerCubicFoot => (_value / 0.028316846592) * 1e-6d,
-                        PowerDensityUnit.MicrowattPerCubicInch => (_value / 1.6387064e-5) * 1e-6d,
-                        PowerDensityUnit.MicrowattPerCubicMeter => (_value) * 1e-6d,
-                        PowerDensityUnit.MicrowattPerLiter => (_value * 1.0e3) * 1e-6d,
-                        PowerDensityUnit.MilliwattPerCubicFoot => (_value / 0.028316846592) * 1e-3d,
-                        PowerDensityUnit.MilliwattPerCubicInch => (_value / 1.6387064e-5) * 1e-3d,
-                        PowerDensityUnit.MilliwattPerCubicMeter => (_value) * 1e-3d,
-                        PowerDensityUnit.MilliwattPerLiter => (_value * 1.0e3) * 1e-3d,
-                        PowerDensityUnit.NanowattPerCubicFoot => (_value / 0.028316846592) * 1e-9d,
-                        PowerDensityUnit.NanowattPerCubicInch => (_value / 1.6387064e-5) * 1e-9d,
-                        PowerDensityUnit.NanowattPerCubicMeter => (_value) * 1e-9d,
-                        PowerDensityUnit.NanowattPerLiter => (_value * 1.0e3) * 1e-9d,
-                        PowerDensityUnit.PicowattPerCubicFoot => (_value / 0.028316846592) * 1e-12d,
-                        PowerDensityUnit.PicowattPerCubicInch => (_value / 1.6387064e-5) * 1e-12d,
-                        PowerDensityUnit.PicowattPerCubicMeter => (_value) * 1e-12d,
-                        PowerDensityUnit.PicowattPerLiter => (_value * 1.0e3) * 1e-12d,
-                        PowerDensityUnit.TerawattPerCubicFoot => (_value / 0.028316846592) * 1e12d,
-                        PowerDensityUnit.TerawattPerCubicInch => (_value / 1.6387064e-5) * 1e12d,
-                        PowerDensityUnit.TerawattPerCubicMeter => (_value) * 1e12d,
-                        PowerDensityUnit.TerawattPerLiter => (_value * 1.0e3) * 1e12d,
-                        PowerDensityUnit.WattPerCubicFoot => _value / 0.028316846592,
-                        PowerDensityUnit.WattPerCubicInch => _value / 1.6387064e-5,
-                        PowerDensityUnit.WattPerCubicMeter => _value,
-                        PowerDensityUnit.WattPerLiter => _value * 1.0e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(PowerDensityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        PowerDensityUnit.DecawattPerCubicFoot => (baseUnitValue * 0.028316846592) / 1e1d,
-                        PowerDensityUnit.DecawattPerCubicInch => (baseUnitValue * 1.6387064e-5) / 1e1d,
-                        PowerDensityUnit.DecawattPerCubicMeter => (baseUnitValue) / 1e1d,
-                        PowerDensityUnit.DecawattPerLiter => (baseUnitValue / 1.0e3) / 1e1d,
-                        PowerDensityUnit.DeciwattPerCubicFoot => (baseUnitValue * 0.028316846592) / 1e-1d,
-                        PowerDensityUnit.DeciwattPerCubicInch => (baseUnitValue * 1.6387064e-5) / 1e-1d,
-                        PowerDensityUnit.DeciwattPerCubicMeter => (baseUnitValue) / 1e-1d,
-                        PowerDensityUnit.DeciwattPerLiter => (baseUnitValue / 1.0e3) / 1e-1d,
-                        PowerDensityUnit.GigawattPerCubicFoot => (baseUnitValue * 0.028316846592) / 1e9d,
-                        PowerDensityUnit.GigawattPerCubicInch => (baseUnitValue * 1.6387064e-5) / 1e9d,
-                        PowerDensityUnit.GigawattPerCubicMeter => (baseUnitValue) / 1e9d,
-                        PowerDensityUnit.GigawattPerLiter => (baseUnitValue / 1.0e3) / 1e9d,
-                        PowerDensityUnit.KilowattPerCubicFoot => (baseUnitValue * 0.028316846592) / 1e3d,
-                        PowerDensityUnit.KilowattPerCubicInch => (baseUnitValue * 1.6387064e-5) / 1e3d,
-                        PowerDensityUnit.KilowattPerCubicMeter => (baseUnitValue) / 1e3d,
-                        PowerDensityUnit.KilowattPerLiter => (baseUnitValue / 1.0e3) / 1e3d,
-                        PowerDensityUnit.MegawattPerCubicFoot => (baseUnitValue * 0.028316846592) / 1e6d,
-                        PowerDensityUnit.MegawattPerCubicInch => (baseUnitValue * 1.6387064e-5) / 1e6d,
-                        PowerDensityUnit.MegawattPerCubicMeter => (baseUnitValue) / 1e6d,
-                        PowerDensityUnit.MegawattPerLiter => (baseUnitValue / 1.0e3) / 1e6d,
-                        PowerDensityUnit.MicrowattPerCubicFoot => (baseUnitValue * 0.028316846592) / 1e-6d,
-                        PowerDensityUnit.MicrowattPerCubicInch => (baseUnitValue * 1.6387064e-5) / 1e-6d,
-                        PowerDensityUnit.MicrowattPerCubicMeter => (baseUnitValue) / 1e-6d,
-                        PowerDensityUnit.MicrowattPerLiter => (baseUnitValue / 1.0e3) / 1e-6d,
-                        PowerDensityUnit.MilliwattPerCubicFoot => (baseUnitValue * 0.028316846592) / 1e-3d,
-                        PowerDensityUnit.MilliwattPerCubicInch => (baseUnitValue * 1.6387064e-5) / 1e-3d,
-                        PowerDensityUnit.MilliwattPerCubicMeter => (baseUnitValue) / 1e-3d,
-                        PowerDensityUnit.MilliwattPerLiter => (baseUnitValue / 1.0e3) / 1e-3d,
-                        PowerDensityUnit.NanowattPerCubicFoot => (baseUnitValue * 0.028316846592) / 1e-9d,
-                        PowerDensityUnit.NanowattPerCubicInch => (baseUnitValue * 1.6387064e-5) / 1e-9d,
-                        PowerDensityUnit.NanowattPerCubicMeter => (baseUnitValue) / 1e-9d,
-                        PowerDensityUnit.NanowattPerLiter => (baseUnitValue / 1.0e3) / 1e-9d,
-                        PowerDensityUnit.PicowattPerCubicFoot => (baseUnitValue * 0.028316846592) / 1e-12d,
-                        PowerDensityUnit.PicowattPerCubicInch => (baseUnitValue * 1.6387064e-5) / 1e-12d,
-                        PowerDensityUnit.PicowattPerCubicMeter => (baseUnitValue) / 1e-12d,
-                        PowerDensityUnit.PicowattPerLiter => (baseUnitValue / 1.0e3) / 1e-12d,
-                        PowerDensityUnit.TerawattPerCubicFoot => (baseUnitValue * 0.028316846592) / 1e12d,
-                        PowerDensityUnit.TerawattPerCubicInch => (baseUnitValue * 1.6387064e-5) / 1e12d,
-                        PowerDensityUnit.TerawattPerCubicMeter => (baseUnitValue) / 1e12d,
-                        PowerDensityUnit.TerawattPerLiter => (baseUnitValue / 1.0e3) / 1e12d,
-                        PowerDensityUnit.WattPerCubicFoot => baseUnitValue * 0.028316846592,
-                        PowerDensityUnit.WattPerCubicInch => baseUnitValue * 1.6387064e-5,
-                        PowerDensityUnit.WattPerCubicMeter => baseUnitValue,
-                        PowerDensityUnit.WattPerLiter => baseUnitValue / 1.0e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/PowerRatio.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/PowerRatio.g.cs
deleted file mode 100644
index 5cd1825e49..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/PowerRatio.g.cs
+++ /dev/null
@@ -1,169 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The strength of a signal expressed in decibels (dB) relative to one watt.
-    /// </summary>
-    public struct  PowerRatio
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly PowerRatioUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public PowerRatioUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public PowerRatio(double value, PowerRatioUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of PowerRatio, which is Second. All conversions go via this value.
-        /// </summary>
-        public static PowerRatioUnit BaseUnit { get; } = PowerRatioUnit.DecibelWatt;
-
-        /// <summary>
-        /// Represents the largest possible value of PowerRatio.
-        /// </summary>
-        public static PowerRatio MaxValue { get; } = new PowerRatio(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of PowerRatio.
-        /// </summary>
-        public static PowerRatio MinValue { get; } = new PowerRatio(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static PowerRatio Zero { get; } = new PowerRatio(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerRatioUnit.DecibelMilliwatt"/>
-        /// </summary>
-        public double DecibelMilliwatts => As(PowerRatioUnit.DecibelMilliwatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerRatioUnit.DecibelWatt"/>
-        /// </summary>
-        public double DecibelWatts => As(PowerRatioUnit.DecibelWatt);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="PowerRatio"/> from <see cref="PowerRatioUnit.DecibelMilliwatt"/>.
-        /// </summary>
-        public static PowerRatio FromDecibelMilliwatts(double decibelmilliwatts) => new PowerRatio(decibelmilliwatts, PowerRatioUnit.DecibelMilliwatt);
-
-        /// <summary>
-        ///     Creates a <see cref="PowerRatio"/> from <see cref="PowerRatioUnit.DecibelWatt"/>.
-        /// </summary>
-        public static PowerRatio FromDecibelWatts(double decibelwatts) => new PowerRatio(decibelwatts, PowerRatioUnit.DecibelWatt);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PowerRatioUnit" /> to <see cref="PowerRatio" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>PowerRatio unit value.</returns>
-        public static PowerRatio From(double value, PowerRatioUnit fromUnit)
-        {
-            return new PowerRatio(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(PowerRatioUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this PowerRatio to another PowerRatio with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A PowerRatio with the specified unit.</returns>
-                public PowerRatio ToUnit(PowerRatioUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new PowerRatio(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        PowerRatioUnit.DecibelMilliwatt => _value - 30,
-                        PowerRatioUnit.DecibelWatt => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(PowerRatioUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        PowerRatioUnit.DecibelMilliwatt => baseUnitValue + 30,
-                        PowerRatioUnit.DecibelWatt => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Pressure.g.cs
deleted file mode 100644
index 84fa430f11..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Pressure.g.cs
+++ /dev/null
@@ -1,721 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Pressure (symbol: P or p) is the ratio of force to the area over which that force is distributed. Pressure is force per unit area applied in a direction perpendicular to the surface of an object. Gauge pressure (also spelled gage pressure)[a] is the pressure relative to the local atmospheric or ambient pressure. Pressure is measured in any unit of force divided by any unit of area. The SI unit of pressure is the newton per square metre, which is called the pascal (Pa) after the seventeenth-century philosopher and scientist Blaise Pascal. A pressure of 1 Pa is small; it approximately equals the pressure exerted by a dollar bill resting flat on a table. Everyday pressures are often stated in kilopascals (1 kPa = 1000 Pa).
-    /// </summary>
-    public struct  Pressure
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly PressureUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public PressureUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Pressure(double value, PressureUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Pressure, which is Second. All conversions go via this value.
-        /// </summary>
-        public static PressureUnit BaseUnit { get; } = PressureUnit.Pascal;
-
-        /// <summary>
-        /// Represents the largest possible value of Pressure.
-        /// </summary>
-        public static Pressure MaxValue { get; } = new Pressure(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Pressure.
-        /// </summary>
-        public static Pressure MinValue { get; } = new Pressure(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Pressure Zero { get; } = new Pressure(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Atmosphere"/>
-        /// </summary>
-        public double Atmospheres => As(PressureUnit.Atmosphere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Bar"/>
-        /// </summary>
-        public double Bars => As(PressureUnit.Bar);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Centibar"/>
-        /// </summary>
-        public double Centibars => As(PressureUnit.Centibar);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.CentimeterOfWaterColumn"/>
-        /// </summary>
-        public double CentimetersOfWaterColumn => As(PressureUnit.CentimeterOfWaterColumn);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Decapascal"/>
-        /// </summary>
-        public double Decapascals => As(PressureUnit.Decapascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Decibar"/>
-        /// </summary>
-        public double Decibars => As(PressureUnit.Decibar);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.DynePerSquareCentimeter"/>
-        /// </summary>
-        public double DynesPerSquareCentimeter => As(PressureUnit.DynePerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.FootOfHead"/>
-        /// </summary>
-        public double FeetOfHead => As(PressureUnit.FootOfHead);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Gigapascal"/>
-        /// </summary>
-        public double Gigapascals => As(PressureUnit.Gigapascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Hectopascal"/>
-        /// </summary>
-        public double Hectopascals => As(PressureUnit.Hectopascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.InchOfMercury"/>
-        /// </summary>
-        public double InchesOfMercury => As(PressureUnit.InchOfMercury);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.InchOfWaterColumn"/>
-        /// </summary>
-        public double InchesOfWaterColumn => As(PressureUnit.InchOfWaterColumn);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Kilobar"/>
-        /// </summary>
-        public double Kilobars => As(PressureUnit.Kilobar);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilogramForcePerSquareCentimeter"/>
-        /// </summary>
-        public double KilogramsForcePerSquareCentimeter => As(PressureUnit.KilogramForcePerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilogramForcePerSquareMeter"/>
-        /// </summary>
-        public double KilogramsForcePerSquareMeter => As(PressureUnit.KilogramForcePerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilogramForcePerSquareMillimeter"/>
-        /// </summary>
-        public double KilogramsForcePerSquareMillimeter => As(PressureUnit.KilogramForcePerSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilonewtonPerSquareCentimeter"/>
-        /// </summary>
-        public double KilonewtonsPerSquareCentimeter => As(PressureUnit.KilonewtonPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilonewtonPerSquareMeter"/>
-        /// </summary>
-        public double KilonewtonsPerSquareMeter => As(PressureUnit.KilonewtonPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilonewtonPerSquareMillimeter"/>
-        /// </summary>
-        public double KilonewtonsPerSquareMillimeter => As(PressureUnit.KilonewtonPerSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Kilopascal"/>
-        /// </summary>
-        public double Kilopascals => As(PressureUnit.Kilopascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilopoundForcePerSquareFoot"/>
-        /// </summary>
-        public double KilopoundsForcePerSquareFoot => As(PressureUnit.KilopoundForcePerSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilopoundForcePerSquareInch"/>
-        /// </summary>
-        public double KilopoundsForcePerSquareInch => As(PressureUnit.KilopoundForcePerSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilopoundForcePerSquareMil"/>
-        /// </summary>
-        public double KilopoundsForcePerSquareMil => As(PressureUnit.KilopoundForcePerSquareMil);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Megabar"/>
-        /// </summary>
-        public double Megabars => As(PressureUnit.Megabar);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.MeganewtonPerSquareMeter"/>
-        /// </summary>
-        public double MeganewtonsPerSquareMeter => As(PressureUnit.MeganewtonPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Megapascal"/>
-        /// </summary>
-        public double Megapascals => As(PressureUnit.Megapascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.MeterOfHead"/>
-        /// </summary>
-        public double MetersOfHead => As(PressureUnit.MeterOfHead);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.MeterOfWaterColumn"/>
-        /// </summary>
-        public double MetersOfWaterColumn => As(PressureUnit.MeterOfWaterColumn);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Microbar"/>
-        /// </summary>
-        public double Microbars => As(PressureUnit.Microbar);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Micropascal"/>
-        /// </summary>
-        public double Micropascals => As(PressureUnit.Micropascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Millibar"/>
-        /// </summary>
-        public double Millibars => As(PressureUnit.Millibar);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.MillimeterOfMercury"/>
-        /// </summary>
-        public double MillimetersOfMercury => As(PressureUnit.MillimeterOfMercury);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.MillimeterOfWaterColumn"/>
-        /// </summary>
-        public double MillimetersOfWaterColumn => As(PressureUnit.MillimeterOfWaterColumn);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Millipascal"/>
-        /// </summary>
-        public double Millipascals => As(PressureUnit.Millipascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Millitorr"/>
-        /// </summary>
-        public double Millitorrs => As(PressureUnit.Millitorr);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.NewtonPerSquareCentimeter"/>
-        /// </summary>
-        public double NewtonsPerSquareCentimeter => As(PressureUnit.NewtonPerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.NewtonPerSquareMeter"/>
-        /// </summary>
-        public double NewtonsPerSquareMeter => As(PressureUnit.NewtonPerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.NewtonPerSquareMillimeter"/>
-        /// </summary>
-        public double NewtonsPerSquareMillimeter => As(PressureUnit.NewtonPerSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Pascal"/>
-        /// </summary>
-        public double Pascals => As(PressureUnit.Pascal);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.PoundForcePerSquareFoot"/>
-        /// </summary>
-        public double PoundsForcePerSquareFoot => As(PressureUnit.PoundForcePerSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.PoundForcePerSquareInch"/>
-        /// </summary>
-        public double PoundsForcePerSquareInch => As(PressureUnit.PoundForcePerSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.PoundForcePerSquareMil"/>
-        /// </summary>
-        public double PoundsForcePerSquareMil => As(PressureUnit.PoundForcePerSquareMil);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.PoundPerInchSecondSquared"/>
-        /// </summary>
-        public double PoundsPerInchSecondSquared => As(PressureUnit.PoundPerInchSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.TechnicalAtmosphere"/>
-        /// </summary>
-        public double TechnicalAtmospheres => As(PressureUnit.TechnicalAtmosphere);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.TonneForcePerSquareCentimeter"/>
-        /// </summary>
-        public double TonnesForcePerSquareCentimeter => As(PressureUnit.TonneForcePerSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.TonneForcePerSquareMeter"/>
-        /// </summary>
-        public double TonnesForcePerSquareMeter => As(PressureUnit.TonneForcePerSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.TonneForcePerSquareMillimeter"/>
-        /// </summary>
-        public double TonnesForcePerSquareMillimeter => As(PressureUnit.TonneForcePerSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Torr"/>
-        /// </summary>
-        public double Torrs => As(PressureUnit.Torr);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Atmosphere"/>.
-        /// </summary>
-        public static Pressure FromAtmospheres(double atmospheres) => new Pressure(atmospheres, PressureUnit.Atmosphere);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Bar"/>.
-        /// </summary>
-        public static Pressure FromBars(double bars) => new Pressure(bars, PressureUnit.Bar);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Centibar"/>.
-        /// </summary>
-        public static Pressure FromCentibars(double centibars) => new Pressure(centibars, PressureUnit.Centibar);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.CentimeterOfWaterColumn"/>.
-        /// </summary>
-        public static Pressure FromCentimetersOfWaterColumn(double centimetersofwatercolumn) => new Pressure(centimetersofwatercolumn, PressureUnit.CentimeterOfWaterColumn);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Decapascal"/>.
-        /// </summary>
-        public static Pressure FromDecapascals(double decapascals) => new Pressure(decapascals, PressureUnit.Decapascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Decibar"/>.
-        /// </summary>
-        public static Pressure FromDecibars(double decibars) => new Pressure(decibars, PressureUnit.Decibar);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.DynePerSquareCentimeter"/>.
-        /// </summary>
-        public static Pressure FromDynesPerSquareCentimeter(double dynespersquarecentimeter) => new Pressure(dynespersquarecentimeter, PressureUnit.DynePerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.FootOfHead"/>.
-        /// </summary>
-        public static Pressure FromFeetOfHead(double feetofhead) => new Pressure(feetofhead, PressureUnit.FootOfHead);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Gigapascal"/>.
-        /// </summary>
-        public static Pressure FromGigapascals(double gigapascals) => new Pressure(gigapascals, PressureUnit.Gigapascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Hectopascal"/>.
-        /// </summary>
-        public static Pressure FromHectopascals(double hectopascals) => new Pressure(hectopascals, PressureUnit.Hectopascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.InchOfMercury"/>.
-        /// </summary>
-        public static Pressure FromInchesOfMercury(double inchesofmercury) => new Pressure(inchesofmercury, PressureUnit.InchOfMercury);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.InchOfWaterColumn"/>.
-        /// </summary>
-        public static Pressure FromInchesOfWaterColumn(double inchesofwatercolumn) => new Pressure(inchesofwatercolumn, PressureUnit.InchOfWaterColumn);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Kilobar"/>.
-        /// </summary>
-        public static Pressure FromKilobars(double kilobars) => new Pressure(kilobars, PressureUnit.Kilobar);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareCentimeter"/>.
-        /// </summary>
-        public static Pressure FromKilogramsForcePerSquareCentimeter(double kilogramsforcepersquarecentimeter) => new Pressure(kilogramsforcepersquarecentimeter, PressureUnit.KilogramForcePerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareMeter"/>.
-        /// </summary>
-        public static Pressure FromKilogramsForcePerSquareMeter(double kilogramsforcepersquaremeter) => new Pressure(kilogramsforcepersquaremeter, PressureUnit.KilogramForcePerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareMillimeter"/>.
-        /// </summary>
-        public static Pressure FromKilogramsForcePerSquareMillimeter(double kilogramsforcepersquaremillimeter) => new Pressure(kilogramsforcepersquaremillimeter, PressureUnit.KilogramForcePerSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareCentimeter"/>.
-        /// </summary>
-        public static Pressure FromKilonewtonsPerSquareCentimeter(double kilonewtonspersquarecentimeter) => new Pressure(kilonewtonspersquarecentimeter, PressureUnit.KilonewtonPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareMeter"/>.
-        /// </summary>
-        public static Pressure FromKilonewtonsPerSquareMeter(double kilonewtonspersquaremeter) => new Pressure(kilonewtonspersquaremeter, PressureUnit.KilonewtonPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareMillimeter"/>.
-        /// </summary>
-        public static Pressure FromKilonewtonsPerSquareMillimeter(double kilonewtonspersquaremillimeter) => new Pressure(kilonewtonspersquaremillimeter, PressureUnit.KilonewtonPerSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Kilopascal"/>.
-        /// </summary>
-        public static Pressure FromKilopascals(double kilopascals) => new Pressure(kilopascals, PressureUnit.Kilopascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareFoot"/>.
-        /// </summary>
-        public static Pressure FromKilopoundsForcePerSquareFoot(double kilopoundsforcepersquarefoot) => new Pressure(kilopoundsforcepersquarefoot, PressureUnit.KilopoundForcePerSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareInch"/>.
-        /// </summary>
-        public static Pressure FromKilopoundsForcePerSquareInch(double kilopoundsforcepersquareinch) => new Pressure(kilopoundsforcepersquareinch, PressureUnit.KilopoundForcePerSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareMil"/>.
-        /// </summary>
-        public static Pressure FromKilopoundsForcePerSquareMil(double kilopoundsforcepersquaremil) => new Pressure(kilopoundsforcepersquaremil, PressureUnit.KilopoundForcePerSquareMil);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Megabar"/>.
-        /// </summary>
-        public static Pressure FromMegabars(double megabars) => new Pressure(megabars, PressureUnit.Megabar);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeganewtonPerSquareMeter"/>.
-        /// </summary>
-        public static Pressure FromMeganewtonsPerSquareMeter(double meganewtonspersquaremeter) => new Pressure(meganewtonspersquaremeter, PressureUnit.MeganewtonPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Megapascal"/>.
-        /// </summary>
-        public static Pressure FromMegapascals(double megapascals) => new Pressure(megapascals, PressureUnit.Megapascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeterOfHead"/>.
-        /// </summary>
-        public static Pressure FromMetersOfHead(double metersofhead) => new Pressure(metersofhead, PressureUnit.MeterOfHead);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeterOfWaterColumn"/>.
-        /// </summary>
-        public static Pressure FromMetersOfWaterColumn(double metersofwatercolumn) => new Pressure(metersofwatercolumn, PressureUnit.MeterOfWaterColumn);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Microbar"/>.
-        /// </summary>
-        public static Pressure FromMicrobars(double microbars) => new Pressure(microbars, PressureUnit.Microbar);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Micropascal"/>.
-        /// </summary>
-        public static Pressure FromMicropascals(double micropascals) => new Pressure(micropascals, PressureUnit.Micropascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Millibar"/>.
-        /// </summary>
-        public static Pressure FromMillibars(double millibars) => new Pressure(millibars, PressureUnit.Millibar);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MillimeterOfMercury"/>.
-        /// </summary>
-        public static Pressure FromMillimetersOfMercury(double millimetersofmercury) => new Pressure(millimetersofmercury, PressureUnit.MillimeterOfMercury);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MillimeterOfWaterColumn"/>.
-        /// </summary>
-        public static Pressure FromMillimetersOfWaterColumn(double millimetersofwatercolumn) => new Pressure(millimetersofwatercolumn, PressureUnit.MillimeterOfWaterColumn);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Millipascal"/>.
-        /// </summary>
-        public static Pressure FromMillipascals(double millipascals) => new Pressure(millipascals, PressureUnit.Millipascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Millitorr"/>.
-        /// </summary>
-        public static Pressure FromMillitorrs(double millitorrs) => new Pressure(millitorrs, PressureUnit.Millitorr);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareCentimeter"/>.
-        /// </summary>
-        public static Pressure FromNewtonsPerSquareCentimeter(double newtonspersquarecentimeter) => new Pressure(newtonspersquarecentimeter, PressureUnit.NewtonPerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareMeter"/>.
-        /// </summary>
-        public static Pressure FromNewtonsPerSquareMeter(double newtonspersquaremeter) => new Pressure(newtonspersquaremeter, PressureUnit.NewtonPerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareMillimeter"/>.
-        /// </summary>
-        public static Pressure FromNewtonsPerSquareMillimeter(double newtonspersquaremillimeter) => new Pressure(newtonspersquaremillimeter, PressureUnit.NewtonPerSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Pascal"/>.
-        /// </summary>
-        public static Pressure FromPascals(double pascals) => new Pressure(pascals, PressureUnit.Pascal);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareFoot"/>.
-        /// </summary>
-        public static Pressure FromPoundsForcePerSquareFoot(double poundsforcepersquarefoot) => new Pressure(poundsforcepersquarefoot, PressureUnit.PoundForcePerSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareInch"/>.
-        /// </summary>
-        public static Pressure FromPoundsForcePerSquareInch(double poundsforcepersquareinch) => new Pressure(poundsforcepersquareinch, PressureUnit.PoundForcePerSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareMil"/>.
-        /// </summary>
-        public static Pressure FromPoundsForcePerSquareMil(double poundsforcepersquaremil) => new Pressure(poundsforcepersquaremil, PressureUnit.PoundForcePerSquareMil);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundPerInchSecondSquared"/>.
-        /// </summary>
-        public static Pressure FromPoundsPerInchSecondSquared(double poundsperinchsecondsquared) => new Pressure(poundsperinchsecondsquared, PressureUnit.PoundPerInchSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TechnicalAtmosphere"/>.
-        /// </summary>
-        public static Pressure FromTechnicalAtmospheres(double technicalatmospheres) => new Pressure(technicalatmospheres, PressureUnit.TechnicalAtmosphere);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareCentimeter"/>.
-        /// </summary>
-        public static Pressure FromTonnesForcePerSquareCentimeter(double tonnesforcepersquarecentimeter) => new Pressure(tonnesforcepersquarecentimeter, PressureUnit.TonneForcePerSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareMeter"/>.
-        /// </summary>
-        public static Pressure FromTonnesForcePerSquareMeter(double tonnesforcepersquaremeter) => new Pressure(tonnesforcepersquaremeter, PressureUnit.TonneForcePerSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareMillimeter"/>.
-        /// </summary>
-        public static Pressure FromTonnesForcePerSquareMillimeter(double tonnesforcepersquaremillimeter) => new Pressure(tonnesforcepersquaremillimeter, PressureUnit.TonneForcePerSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Torr"/>.
-        /// </summary>
-        public static Pressure FromTorrs(double torrs) => new Pressure(torrs, PressureUnit.Torr);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PressureUnit" /> to <see cref="Pressure" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Pressure unit value.</returns>
-        public static Pressure From(double value, PressureUnit fromUnit)
-        {
-            return new Pressure(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(PressureUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Pressure to another Pressure with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Pressure with the specified unit.</returns>
-                public Pressure ToUnit(PressureUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Pressure(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        PressureUnit.Atmosphere => _value * 1.01325 * 1e5,
-                        PressureUnit.Bar => _value * 1e5,
-                        PressureUnit.Centibar => (_value * 1e5) * 1e-2d,
-                        PressureUnit.CentimeterOfWaterColumn => (_value * 9.80665e3) * 1e-2d,
-                        PressureUnit.Decapascal => (_value) * 1e1d,
-                        PressureUnit.Decibar => (_value * 1e5) * 1e-1d,
-                        PressureUnit.DynePerSquareCentimeter => _value * 1.0e-1,
-                        PressureUnit.FootOfHead => _value * 9804.139432 * 0.3048,
-                        PressureUnit.Gigapascal => (_value) * 1e9d,
-                        PressureUnit.Hectopascal => (_value) * 1e2d,
-                        PressureUnit.InchOfMercury => _value * 2.54e1 * 133.322387415,
-                        PressureUnit.InchOfWaterColumn => _value * 2.54e-2 * 9.80665e3,
-                        PressureUnit.Kilobar => (_value * 1e5) * 1e3d,
-                        PressureUnit.KilogramForcePerSquareCentimeter => _value * 9.80665e4,
-                        PressureUnit.KilogramForcePerSquareMeter => _value * 9.80665,
-                        PressureUnit.KilogramForcePerSquareMillimeter => _value * 9.80665e6,
-                        PressureUnit.KilonewtonPerSquareCentimeter => (_value * 1e4) * 1e3d,
-                        PressureUnit.KilonewtonPerSquareMeter => (_value) * 1e3d,
-                        PressureUnit.KilonewtonPerSquareMillimeter => (_value * 1e6) * 1e3d,
-                        PressureUnit.Kilopascal => (_value) * 1e3d,
-                        PressureUnit.KilopoundForcePerSquareFoot => (_value * 4.4482216152605 / 9.290304e-2) * 1e3d,
-                        PressureUnit.KilopoundForcePerSquareInch => (_value * 4.4482216152605 / 0.00064516) * 1e3d,
-                        PressureUnit.KilopoundForcePerSquareMil => (_value * 4.4482216152605 / (2.54e-5 * 2.54e-5)) * 1e3d,
-                        PressureUnit.Megabar => (_value * 1e5) * 1e6d,
-                        PressureUnit.MeganewtonPerSquareMeter => (_value) * 1e6d,
-                        PressureUnit.Megapascal => (_value) * 1e6d,
-                        PressureUnit.MeterOfHead => _value * 9804.139432,
-                        PressureUnit.MeterOfWaterColumn => _value * 9.80665e3,
-                        PressureUnit.Microbar => (_value * 1e5) * 1e-6d,
-                        PressureUnit.Micropascal => (_value) * 1e-6d,
-                        PressureUnit.Millibar => (_value * 1e5) * 1e-3d,
-                        PressureUnit.MillimeterOfMercury => _value * 133.322387415,
-                        PressureUnit.MillimeterOfWaterColumn => (_value * 9.80665e3) * 1e-3d,
-                        PressureUnit.Millipascal => (_value) * 1e-3d,
-                        PressureUnit.Millitorr => (_value * 101325 / 760) * 1e-3d,
-                        PressureUnit.NewtonPerSquareCentimeter => _value * 1e4,
-                        PressureUnit.NewtonPerSquareMeter => _value,
-                        PressureUnit.NewtonPerSquareMillimeter => _value * 1e6,
-                        PressureUnit.Pascal => _value,
-                        PressureUnit.PoundForcePerSquareFoot => _value * 4.4482216152605 / 9.290304e-2,
-                        PressureUnit.PoundForcePerSquareInch => _value * 4.4482216152605 / 0.00064516,
-                        PressureUnit.PoundForcePerSquareMil => _value * 4.4482216152605 / (2.54e-5 * 2.54e-5),
-                        PressureUnit.PoundPerInchSecondSquared => _value * (4.4482216152605 / 0.00064516) / 386.0886,
-                        PressureUnit.TechnicalAtmosphere => _value * 9.80665e4,
-                        PressureUnit.TonneForcePerSquareCentimeter => _value * 9.80665e7,
-                        PressureUnit.TonneForcePerSquareMeter => _value * 9.80665e3,
-                        PressureUnit.TonneForcePerSquareMillimeter => _value * 9.80665e9,
-                        PressureUnit.Torr => _value * 101325 / 760,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(PressureUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        PressureUnit.Atmosphere => baseUnitValue / (1.01325 * 1e5),
-                        PressureUnit.Bar => baseUnitValue / 1e5,
-                        PressureUnit.Centibar => (baseUnitValue / 1e5) / 1e-2d,
-                        PressureUnit.CentimeterOfWaterColumn => (baseUnitValue / 9.80665e3) / 1e-2d,
-                        PressureUnit.Decapascal => (baseUnitValue) / 1e1d,
-                        PressureUnit.Decibar => (baseUnitValue / 1e5) / 1e-1d,
-                        PressureUnit.DynePerSquareCentimeter => baseUnitValue / 1.0e-1,
-                        PressureUnit.FootOfHead => baseUnitValue / (9804.139432 * 0.3048),
-                        PressureUnit.Gigapascal => (baseUnitValue) / 1e9d,
-                        PressureUnit.Hectopascal => (baseUnitValue) / 1e2d,
-                        PressureUnit.InchOfMercury => baseUnitValue / (2.54e1 * 133.322387415),
-                        PressureUnit.InchOfWaterColumn => baseUnitValue / (2.54e-2 * 9.80665e3),
-                        PressureUnit.Kilobar => (baseUnitValue / 1e5) / 1e3d,
-                        PressureUnit.KilogramForcePerSquareCentimeter => baseUnitValue / 9.80665e4,
-                        PressureUnit.KilogramForcePerSquareMeter => baseUnitValue / 9.80665,
-                        PressureUnit.KilogramForcePerSquareMillimeter => baseUnitValue / 9.80665e6,
-                        PressureUnit.KilonewtonPerSquareCentimeter => (baseUnitValue / 1e4) / 1e3d,
-                        PressureUnit.KilonewtonPerSquareMeter => (baseUnitValue) / 1e3d,
-                        PressureUnit.KilonewtonPerSquareMillimeter => (baseUnitValue / 1e6) / 1e3d,
-                        PressureUnit.Kilopascal => (baseUnitValue) / 1e3d,
-                        PressureUnit.KilopoundForcePerSquareFoot => (baseUnitValue * 9.290304e-2 / 4.4482216152605) / 1e3d,
-                        PressureUnit.KilopoundForcePerSquareInch => (baseUnitValue * 0.00064516 / 4.4482216152605) / 1e3d,
-                        PressureUnit.KilopoundForcePerSquareMil => (baseUnitValue * (2.54e-5 * 2.54e-5) / 4.4482216152605) / 1e3d,
-                        PressureUnit.Megabar => (baseUnitValue / 1e5) / 1e6d,
-                        PressureUnit.MeganewtonPerSquareMeter => (baseUnitValue) / 1e6d,
-                        PressureUnit.Megapascal => (baseUnitValue) / 1e6d,
-                        PressureUnit.MeterOfHead => baseUnitValue / 9804.139432,
-                        PressureUnit.MeterOfWaterColumn => baseUnitValue / 9.80665e3,
-                        PressureUnit.Microbar => (baseUnitValue / 1e5) / 1e-6d,
-                        PressureUnit.Micropascal => (baseUnitValue) / 1e-6d,
-                        PressureUnit.Millibar => (baseUnitValue / 1e5) / 1e-3d,
-                        PressureUnit.MillimeterOfMercury => baseUnitValue / 133.322387415,
-                        PressureUnit.MillimeterOfWaterColumn => (baseUnitValue / 9.80665e3) / 1e-3d,
-                        PressureUnit.Millipascal => (baseUnitValue) / 1e-3d,
-                        PressureUnit.Millitorr => (baseUnitValue * 760 / 101325) / 1e-3d,
-                        PressureUnit.NewtonPerSquareCentimeter => baseUnitValue / 1e4,
-                        PressureUnit.NewtonPerSquareMeter => baseUnitValue,
-                        PressureUnit.NewtonPerSquareMillimeter => baseUnitValue / 1e6,
-                        PressureUnit.Pascal => baseUnitValue,
-                        PressureUnit.PoundForcePerSquareFoot => baseUnitValue * 9.290304e-2 / 4.4482216152605,
-                        PressureUnit.PoundForcePerSquareInch => baseUnitValue * 0.00064516 / 4.4482216152605,
-                        PressureUnit.PoundForcePerSquareMil => baseUnitValue * (2.54e-5 * 2.54e-5) / 4.4482216152605,
-                        PressureUnit.PoundPerInchSecondSquared => baseUnitValue * 386.0886 / (4.4482216152605 / 0.00064516),
-                        PressureUnit.TechnicalAtmosphere => baseUnitValue / 9.80665e4,
-                        PressureUnit.TonneForcePerSquareCentimeter => baseUnitValue / 9.80665e7,
-                        PressureUnit.TonneForcePerSquareMeter => baseUnitValue / 9.80665e3,
-                        PressureUnit.TonneForcePerSquareMillimeter => baseUnitValue / 9.80665e9,
-                        PressureUnit.Torr => baseUnitValue * 760 / 101325,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/PressureChangeRate.g.cs
deleted file mode 100644
index c5547c401d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/PressureChangeRate.g.cs
+++ /dev/null
@@ -1,361 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Pressure change rate is the ratio of the pressure change to the time during which the change occurred (value of pressure changes per unit time).
-    /// </summary>
-    public struct  PressureChangeRate
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly PressureChangeRateUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public PressureChangeRateUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public PressureChangeRate(double value, PressureChangeRateUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of PressureChangeRate, which is Second. All conversions go via this value.
-        /// </summary>
-        public static PressureChangeRateUnit BaseUnit { get; } = PressureChangeRateUnit.PascalPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of PressureChangeRate.
-        /// </summary>
-        public static PressureChangeRate MaxValue { get; } = new PressureChangeRate(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of PressureChangeRate.
-        /// </summary>
-        public static PressureChangeRate MinValue { get; } = new PressureChangeRate(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static PressureChangeRate Zero { get; } = new PressureChangeRate(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.AtmospherePerSecond"/>
-        /// </summary>
-        public double AtmospheresPerSecond => As(PressureChangeRateUnit.AtmospherePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.BarPerMinute"/>
-        /// </summary>
-        public double BarsPerMinute => As(PressureChangeRateUnit.BarPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.BarPerSecond"/>
-        /// </summary>
-        public double BarsPerSecond => As(PressureChangeRateUnit.BarPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopascalPerMinute"/>
-        /// </summary>
-        public double KilopascalsPerMinute => As(PressureChangeRateUnit.KilopascalPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopascalPerSecond"/>
-        /// </summary>
-        public double KilopascalsPerSecond => As(PressureChangeRateUnit.KilopascalPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute"/>
-        /// </summary>
-        public double KilopoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond"/>
-        /// </summary>
-        public double KilopoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapascalPerMinute"/>
-        /// </summary>
-        public double MegapascalsPerMinute => As(PressureChangeRateUnit.MegapascalPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapascalPerSecond"/>
-        /// </summary>
-        public double MegapascalsPerSecond => As(PressureChangeRateUnit.MegapascalPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute"/>
-        /// </summary>
-        public double MegapoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond"/>
-        /// </summary>
-        public double MegapoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MillibarPerMinute"/>
-        /// </summary>
-        public double MillibarsPerMinute => As(PressureChangeRateUnit.MillibarPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MillibarPerSecond"/>
-        /// </summary>
-        public double MillibarsPerSecond => As(PressureChangeRateUnit.MillibarPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MillimeterOfMercuryPerSecond"/>
-        /// </summary>
-        public double MillimetersOfMercuryPerSecond => As(PressureChangeRateUnit.MillimeterOfMercuryPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PascalPerMinute"/>
-        /// </summary>
-        public double PascalsPerMinute => As(PressureChangeRateUnit.PascalPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PascalPerSecond"/>
-        /// </summary>
-        public double PascalsPerSecond => As(PressureChangeRateUnit.PascalPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerMinute"/>
-        /// </summary>
-        public double PoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerSecond"/>
-        /// </summary>
-        public double PoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.AtmospherePerSecond"/>.
-        /// </summary>
-        public static PressureChangeRate FromAtmospheresPerSecond(double atmospherespersecond) => new PressureChangeRate(atmospherespersecond, PressureChangeRateUnit.AtmospherePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.BarPerMinute"/>.
-        /// </summary>
-        public static PressureChangeRate FromBarsPerMinute(double barsperminute) => new PressureChangeRate(barsperminute, PressureChangeRateUnit.BarPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.BarPerSecond"/>.
-        /// </summary>
-        public static PressureChangeRate FromBarsPerSecond(double barspersecond) => new PressureChangeRate(barspersecond, PressureChangeRateUnit.BarPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopascalPerMinute"/>.
-        /// </summary>
-        public static PressureChangeRate FromKilopascalsPerMinute(double kilopascalsperminute) => new PressureChangeRate(kilopascalsperminute, PressureChangeRateUnit.KilopascalPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopascalPerSecond"/>.
-        /// </summary>
-        public static PressureChangeRate FromKilopascalsPerSecond(double kilopascalspersecond) => new PressureChangeRate(kilopascalspersecond, PressureChangeRateUnit.KilopascalPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute"/>.
-        /// </summary>
-        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(double kilopoundsforcepersquareinchperminute) => new PressureChangeRate(kilopoundsforcepersquareinchperminute, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond"/>.
-        /// </summary>
-        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(double kilopoundsforcepersquareinchpersecond) => new PressureChangeRate(kilopoundsforcepersquareinchpersecond, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapascalPerMinute"/>.
-        /// </summary>
-        public static PressureChangeRate FromMegapascalsPerMinute(double megapascalsperminute) => new PressureChangeRate(megapascalsperminute, PressureChangeRateUnit.MegapascalPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapascalPerSecond"/>.
-        /// </summary>
-        public static PressureChangeRate FromMegapascalsPerSecond(double megapascalspersecond) => new PressureChangeRate(megapascalspersecond, PressureChangeRateUnit.MegapascalPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute"/>.
-        /// </summary>
-        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(double megapoundsforcepersquareinchperminute) => new PressureChangeRate(megapoundsforcepersquareinchperminute, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond"/>.
-        /// </summary>
-        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(double megapoundsforcepersquareinchpersecond) => new PressureChangeRate(megapoundsforcepersquareinchpersecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillibarPerMinute"/>.
-        /// </summary>
-        public static PressureChangeRate FromMillibarsPerMinute(double millibarsperminute) => new PressureChangeRate(millibarsperminute, PressureChangeRateUnit.MillibarPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillibarPerSecond"/>.
-        /// </summary>
-        public static PressureChangeRate FromMillibarsPerSecond(double millibarspersecond) => new PressureChangeRate(millibarspersecond, PressureChangeRateUnit.MillibarPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillimeterOfMercuryPerSecond"/>.
-        /// </summary>
-        public static PressureChangeRate FromMillimetersOfMercuryPerSecond(double millimetersofmercurypersecond) => new PressureChangeRate(millimetersofmercurypersecond, PressureChangeRateUnit.MillimeterOfMercuryPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PascalPerMinute"/>.
-        /// </summary>
-        public static PressureChangeRate FromPascalsPerMinute(double pascalsperminute) => new PressureChangeRate(pascalsperminute, PressureChangeRateUnit.PascalPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PascalPerSecond"/>.
-        /// </summary>
-        public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond) => new PressureChangeRate(pascalspersecond, PressureChangeRateUnit.PascalPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerMinute"/>.
-        /// </summary>
-        public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(double poundsforcepersquareinchperminute) => new PressureChangeRate(poundsforcepersquareinchperminute, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerSecond"/>.
-        /// </summary>
-        public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(double poundsforcepersquareinchpersecond) => new PressureChangeRate(poundsforcepersquareinchpersecond, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="PressureChangeRateUnit" /> to <see cref="PressureChangeRate" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>PressureChangeRate unit value.</returns>
-        public static PressureChangeRate From(double value, PressureChangeRateUnit fromUnit)
-        {
-            return new PressureChangeRate(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(PressureChangeRateUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this PressureChangeRate to another PressureChangeRate with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A PressureChangeRate with the specified unit.</returns>
-                public PressureChangeRate ToUnit(PressureChangeRateUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new PressureChangeRate(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        PressureChangeRateUnit.AtmospherePerSecond => _value * 1.01325 * 1e5,
-                        PressureChangeRateUnit.BarPerMinute => _value * 1e5 / 60,
-                        PressureChangeRateUnit.BarPerSecond => _value * 1e5,
-                        PressureChangeRateUnit.KilopascalPerMinute => (_value / 60) * 1e3d,
-                        PressureChangeRateUnit.KilopascalPerSecond => (_value) * 1e3d,
-                        PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute => (_value * (4.4482216152605 / 0.00064516) / 60) * 1e3d,
-                        PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond => (_value * 4.4482216152605 / 0.00064516) * 1e3d,
-                        PressureChangeRateUnit.MegapascalPerMinute => (_value / 60) * 1e6d,
-                        PressureChangeRateUnit.MegapascalPerSecond => (_value) * 1e6d,
-                        PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute => (_value * (4.4482216152605 / 0.00064516) / 60) * 1e6d,
-                        PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond => (_value * 4.4482216152605 / 0.00064516) * 1e6d,
-                        PressureChangeRateUnit.MillibarPerMinute => (_value * 1e5 / 60) * 1e-3d,
-                        PressureChangeRateUnit.MillibarPerSecond => (_value * 1e5) * 1e-3d,
-                        PressureChangeRateUnit.MillimeterOfMercuryPerSecond => _value * 133.322387415,
-                        PressureChangeRateUnit.PascalPerMinute => _value / 60,
-                        PressureChangeRateUnit.PascalPerSecond => _value,
-                        PressureChangeRateUnit.PoundForcePerSquareInchPerMinute => _value * (4.4482216152605 / 0.00064516) / 60,
-                        PressureChangeRateUnit.PoundForcePerSquareInchPerSecond => _value * 4.4482216152605 / 0.00064516,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(PressureChangeRateUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        PressureChangeRateUnit.AtmospherePerSecond => baseUnitValue / (1.01325 * 1e5),
-                        PressureChangeRateUnit.BarPerMinute => baseUnitValue / 1e5 * 60,
-                        PressureChangeRateUnit.BarPerSecond => baseUnitValue / 1e5,
-                        PressureChangeRateUnit.KilopascalPerMinute => (baseUnitValue * 60) / 1e3d,
-                        PressureChangeRateUnit.KilopascalPerSecond => (baseUnitValue) / 1e3d,
-                        PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute => (baseUnitValue * 60 / (4.4482216152605 / 0.00064516)) / 1e3d,
-                        PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond => (baseUnitValue * 0.00064516 / 4.4482216152605) / 1e3d,
-                        PressureChangeRateUnit.MegapascalPerMinute => (baseUnitValue * 60) / 1e6d,
-                        PressureChangeRateUnit.MegapascalPerSecond => (baseUnitValue) / 1e6d,
-                        PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute => (baseUnitValue * 60 / (4.4482216152605 / 0.00064516)) / 1e6d,
-                        PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond => (baseUnitValue * 0.00064516 / 4.4482216152605) / 1e6d,
-                        PressureChangeRateUnit.MillibarPerMinute => (baseUnitValue / 1e5 * 60) / 1e-3d,
-                        PressureChangeRateUnit.MillibarPerSecond => (baseUnitValue / 1e5) / 1e-3d,
-                        PressureChangeRateUnit.MillimeterOfMercuryPerSecond => baseUnitValue / 133.322387415,
-                        PressureChangeRateUnit.PascalPerMinute => baseUnitValue * 60,
-                        PressureChangeRateUnit.PascalPerSecond => baseUnitValue,
-                        PressureChangeRateUnit.PoundForcePerSquareInchPerMinute => baseUnitValue * 60 / (4.4482216152605 / 0.00064516),
-                        PressureChangeRateUnit.PoundForcePerSquareInchPerSecond => baseUnitValue * 0.00064516 / 4.4482216152605,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs
deleted file mode 100644
index 57ea2e0869..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs
+++ /dev/null
@@ -1,217 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Equivalent dose is a dose quantity representing the stochastic health effects of low levels of ionizing radiation on the human body which represents the probability of radiation-induced cancer and genetic damage.
-    /// </summary>
-    public struct  RadiationEquivalentDose
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RadiationEquivalentDoseUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RadiationEquivalentDoseUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RadiationEquivalentDose(double value, RadiationEquivalentDoseUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of RadiationEquivalentDose, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RadiationEquivalentDoseUnit BaseUnit { get; } = RadiationEquivalentDoseUnit.Sievert;
-
-        /// <summary>
-        /// Represents the largest possible value of RadiationEquivalentDose.
-        /// </summary>
-        public static RadiationEquivalentDose MaxValue { get; } = new RadiationEquivalentDose(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of RadiationEquivalentDose.
-        /// </summary>
-        public static RadiationEquivalentDose MinValue { get; } = new RadiationEquivalentDose(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static RadiationEquivalentDose Zero { get; } = new RadiationEquivalentDose(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Microsievert"/>
-        /// </summary>
-        public double Microsieverts => As(RadiationEquivalentDoseUnit.Microsievert);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan"/>
-        /// </summary>
-        public double MilliroentgensEquivalentMan => As(RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Millisievert"/>
-        /// </summary>
-        public double Millisieverts => As(RadiationEquivalentDoseUnit.Millisievert);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Nanosievert"/>
-        /// </summary>
-        public double Nanosieverts => As(RadiationEquivalentDoseUnit.Nanosievert);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.RoentgenEquivalentMan"/>
-        /// </summary>
-        public double RoentgensEquivalentMan => As(RadiationEquivalentDoseUnit.RoentgenEquivalentMan);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Sievert"/>
-        /// </summary>
-        public double Sieverts => As(RadiationEquivalentDoseUnit.Sievert);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.Microsievert"/>.
-        /// </summary>
-        public static RadiationEquivalentDose FromMicrosieverts(double microsieverts) => new RadiationEquivalentDose(microsieverts, RadiationEquivalentDoseUnit.Microsievert);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan"/>.
-        /// </summary>
-        public static RadiationEquivalentDose FromMilliroentgensEquivalentMan(double milliroentgensequivalentman) => new RadiationEquivalentDose(milliroentgensequivalentman, RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.Millisievert"/>.
-        /// </summary>
-        public static RadiationEquivalentDose FromMillisieverts(double millisieverts) => new RadiationEquivalentDose(millisieverts, RadiationEquivalentDoseUnit.Millisievert);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.Nanosievert"/>.
-        /// </summary>
-        public static RadiationEquivalentDose FromNanosieverts(double nanosieverts) => new RadiationEquivalentDose(nanosieverts, RadiationEquivalentDoseUnit.Nanosievert);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.RoentgenEquivalentMan"/>.
-        /// </summary>
-        public static RadiationEquivalentDose FromRoentgensEquivalentMan(double roentgensequivalentman) => new RadiationEquivalentDose(roentgensequivalentman, RadiationEquivalentDoseUnit.RoentgenEquivalentMan);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.Sievert"/>.
-        /// </summary>
-        public static RadiationEquivalentDose FromSieverts(double sieverts) => new RadiationEquivalentDose(sieverts, RadiationEquivalentDoseUnit.Sievert);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RadiationEquivalentDoseUnit" /> to <see cref="RadiationEquivalentDose" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RadiationEquivalentDose unit value.</returns>
-        public static RadiationEquivalentDose From(double value, RadiationEquivalentDoseUnit fromUnit)
-        {
-            return new RadiationEquivalentDose(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RadiationEquivalentDoseUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this RadiationEquivalentDose to another RadiationEquivalentDose with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A RadiationEquivalentDose with the specified unit.</returns>
-                public RadiationEquivalentDose ToUnit(RadiationEquivalentDoseUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new RadiationEquivalentDose(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RadiationEquivalentDoseUnit.Microsievert => (_value) * 1e-6d,
-                        RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan => (_value / 100) * 1e-3d,
-                        RadiationEquivalentDoseUnit.Millisievert => (_value) * 1e-3d,
-                        RadiationEquivalentDoseUnit.Nanosievert => (_value) * 1e-9d,
-                        RadiationEquivalentDoseUnit.RoentgenEquivalentMan => _value / 100,
-                        RadiationEquivalentDoseUnit.Sievert => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RadiationEquivalentDoseUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RadiationEquivalentDoseUnit.Microsievert => (baseUnitValue) / 1e-6d,
-                        RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan => (baseUnitValue * 100) / 1e-3d,
-                        RadiationEquivalentDoseUnit.Millisievert => (baseUnitValue) / 1e-3d,
-                        RadiationEquivalentDoseUnit.Nanosievert => (baseUnitValue) / 1e-9d,
-                        RadiationEquivalentDoseUnit.RoentgenEquivalentMan => baseUnitValue * 100,
-                        RadiationEquivalentDoseUnit.Sievert => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs
deleted file mode 100644
index cfd02e3935..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs
+++ /dev/null
@@ -1,265 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     A dose rate is quantity of radiation absorbed or delivered per unit time.
-    /// </summary>
-    public struct  RadiationEquivalentDoseRate
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RadiationEquivalentDoseRateUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RadiationEquivalentDoseRateUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RadiationEquivalentDoseRate(double value, RadiationEquivalentDoseRateUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of RadiationEquivalentDoseRate, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RadiationEquivalentDoseRateUnit BaseUnit { get; } = RadiationEquivalentDoseRateUnit.SievertPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of RadiationEquivalentDoseRate.
-        /// </summary>
-        public static RadiationEquivalentDoseRate MaxValue { get; } = new RadiationEquivalentDoseRate(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of RadiationEquivalentDoseRate.
-        /// </summary>
-        public static RadiationEquivalentDoseRate MinValue { get; } = new RadiationEquivalentDoseRate(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static RadiationEquivalentDoseRate Zero { get; } = new RadiationEquivalentDoseRate(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MicrosievertPerHour"/>
-        /// </summary>
-        public double MicrosievertsPerHour => As(RadiationEquivalentDoseRateUnit.MicrosievertPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MicrosievertPerSecond"/>
-        /// </summary>
-        public double MicrosievertsPerSecond => As(RadiationEquivalentDoseRateUnit.MicrosievertPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour"/>
-        /// </summary>
-        public double MilliroentgensEquivalentManPerHour => As(RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MillisievertPerHour"/>
-        /// </summary>
-        public double MillisievertsPerHour => As(RadiationEquivalentDoseRateUnit.MillisievertPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MillisievertPerSecond"/>
-        /// </summary>
-        public double MillisievertsPerSecond => As(RadiationEquivalentDoseRateUnit.MillisievertPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.NanosievertPerHour"/>
-        /// </summary>
-        public double NanosievertsPerHour => As(RadiationEquivalentDoseRateUnit.NanosievertPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.NanosievertPerSecond"/>
-        /// </summary>
-        public double NanosievertsPerSecond => As(RadiationEquivalentDoseRateUnit.NanosievertPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour"/>
-        /// </summary>
-        public double RoentgensEquivalentManPerHour => As(RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.SievertPerHour"/>
-        /// </summary>
-        public double SievertsPerHour => As(RadiationEquivalentDoseRateUnit.SievertPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.SievertPerSecond"/>
-        /// </summary>
-        public double SievertsPerSecond => As(RadiationEquivalentDoseRateUnit.SievertPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.MicrosievertPerHour"/>.
-        /// </summary>
-        public static RadiationEquivalentDoseRate FromMicrosievertsPerHour(double microsievertsperhour) => new RadiationEquivalentDoseRate(microsievertsperhour, RadiationEquivalentDoseRateUnit.MicrosievertPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.MicrosievertPerSecond"/>.
-        /// </summary>
-        public static RadiationEquivalentDoseRate FromMicrosievertsPerSecond(double microsievertspersecond) => new RadiationEquivalentDoseRate(microsievertspersecond, RadiationEquivalentDoseRateUnit.MicrosievertPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour"/>.
-        /// </summary>
-        public static RadiationEquivalentDoseRate FromMilliroentgensEquivalentManPerHour(double milliroentgensequivalentmanperhour) => new RadiationEquivalentDoseRate(milliroentgensequivalentmanperhour, RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.MillisievertPerHour"/>.
-        /// </summary>
-        public static RadiationEquivalentDoseRate FromMillisievertsPerHour(double millisievertsperhour) => new RadiationEquivalentDoseRate(millisievertsperhour, RadiationEquivalentDoseRateUnit.MillisievertPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.MillisievertPerSecond"/>.
-        /// </summary>
-        public static RadiationEquivalentDoseRate FromMillisievertsPerSecond(double millisievertspersecond) => new RadiationEquivalentDoseRate(millisievertspersecond, RadiationEquivalentDoseRateUnit.MillisievertPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.NanosievertPerHour"/>.
-        /// </summary>
-        public static RadiationEquivalentDoseRate FromNanosievertsPerHour(double nanosievertsperhour) => new RadiationEquivalentDoseRate(nanosievertsperhour, RadiationEquivalentDoseRateUnit.NanosievertPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.NanosievertPerSecond"/>.
-        /// </summary>
-        public static RadiationEquivalentDoseRate FromNanosievertsPerSecond(double nanosievertspersecond) => new RadiationEquivalentDoseRate(nanosievertspersecond, RadiationEquivalentDoseRateUnit.NanosievertPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour"/>.
-        /// </summary>
-        public static RadiationEquivalentDoseRate FromRoentgensEquivalentManPerHour(double roentgensequivalentmanperhour) => new RadiationEquivalentDoseRate(roentgensequivalentmanperhour, RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.SievertPerHour"/>.
-        /// </summary>
-        public static RadiationEquivalentDoseRate FromSievertsPerHour(double sievertsperhour) => new RadiationEquivalentDoseRate(sievertsperhour, RadiationEquivalentDoseRateUnit.SievertPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.SievertPerSecond"/>.
-        /// </summary>
-        public static RadiationEquivalentDoseRate FromSievertsPerSecond(double sievertspersecond) => new RadiationEquivalentDoseRate(sievertspersecond, RadiationEquivalentDoseRateUnit.SievertPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RadiationEquivalentDoseRateUnit" /> to <see cref="RadiationEquivalentDoseRate" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RadiationEquivalentDoseRate unit value.</returns>
-        public static RadiationEquivalentDoseRate From(double value, RadiationEquivalentDoseRateUnit fromUnit)
-        {
-            return new RadiationEquivalentDoseRate(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RadiationEquivalentDoseRateUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this RadiationEquivalentDoseRate to another RadiationEquivalentDoseRate with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A RadiationEquivalentDoseRate with the specified unit.</returns>
-                public RadiationEquivalentDoseRate ToUnit(RadiationEquivalentDoseRateUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new RadiationEquivalentDoseRate(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RadiationEquivalentDoseRateUnit.MicrosievertPerHour => (_value/3600) * 1e-6d,
-                        RadiationEquivalentDoseRateUnit.MicrosievertPerSecond => (_value) * 1e-6d,
-                        RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour => (_value / 100 / 3600) * 1e-3d,
-                        RadiationEquivalentDoseRateUnit.MillisievertPerHour => (_value/3600) * 1e-3d,
-                        RadiationEquivalentDoseRateUnit.MillisievertPerSecond => (_value) * 1e-3d,
-                        RadiationEquivalentDoseRateUnit.NanosievertPerHour => (_value/3600) * 1e-9d,
-                        RadiationEquivalentDoseRateUnit.NanosievertPerSecond => (_value) * 1e-9d,
-                        RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour => _value / 100 / 3600,
-                        RadiationEquivalentDoseRateUnit.SievertPerHour => _value/3600,
-                        RadiationEquivalentDoseRateUnit.SievertPerSecond => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RadiationEquivalentDoseRateUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RadiationEquivalentDoseRateUnit.MicrosievertPerHour => (baseUnitValue*3600) / 1e-6d,
-                        RadiationEquivalentDoseRateUnit.MicrosievertPerSecond => (baseUnitValue) / 1e-6d,
-                        RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour => (baseUnitValue * 100 * 3600) / 1e-3d,
-                        RadiationEquivalentDoseRateUnit.MillisievertPerHour => (baseUnitValue*3600) / 1e-3d,
-                        RadiationEquivalentDoseRateUnit.MillisievertPerSecond => (baseUnitValue) / 1e-3d,
-                        RadiationEquivalentDoseRateUnit.NanosievertPerHour => (baseUnitValue*3600) / 1e-9d,
-                        RadiationEquivalentDoseRateUnit.NanosievertPerSecond => (baseUnitValue) / 1e-9d,
-                        RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour => baseUnitValue * 100 * 3600,
-                        RadiationEquivalentDoseRateUnit.SievertPerHour => baseUnitValue*3600,
-                        RadiationEquivalentDoseRateUnit.SievertPerSecond => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RadiationExposure.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/RadiationExposure.g.cs
deleted file mode 100644
index eb3b34d723..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RadiationExposure.g.cs
+++ /dev/null
@@ -1,241 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Radiation exposure is a measure of the ionization of air due to ionizing radiation from photons.
-    /// </summary>
-    public struct  RadiationExposure
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RadiationExposureUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RadiationExposureUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RadiationExposure(double value, RadiationExposureUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of RadiationExposure, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RadiationExposureUnit BaseUnit { get; } = RadiationExposureUnit.CoulombPerKilogram;
-
-        /// <summary>
-        /// Represents the largest possible value of RadiationExposure.
-        /// </summary>
-        public static RadiationExposure MaxValue { get; } = new RadiationExposure(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of RadiationExposure.
-        /// </summary>
-        public static RadiationExposure MinValue { get; } = new RadiationExposure(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static RadiationExposure Zero { get; } = new RadiationExposure(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.CoulombPerKilogram"/>
-        /// </summary>
-        public double CoulombsPerKilogram => As(RadiationExposureUnit.CoulombPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.MicrocoulombPerKilogram"/>
-        /// </summary>
-        public double MicrocoulombsPerKilogram => As(RadiationExposureUnit.MicrocoulombPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.Microroentgen"/>
-        /// </summary>
-        public double Microroentgens => As(RadiationExposureUnit.Microroentgen);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.MillicoulombPerKilogram"/>
-        /// </summary>
-        public double MillicoulombsPerKilogram => As(RadiationExposureUnit.MillicoulombPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.Milliroentgen"/>
-        /// </summary>
-        public double Milliroentgens => As(RadiationExposureUnit.Milliroentgen);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.NanocoulombPerKilogram"/>
-        /// </summary>
-        public double NanocoulombsPerKilogram => As(RadiationExposureUnit.NanocoulombPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.PicocoulombPerKilogram"/>
-        /// </summary>
-        public double PicocoulombsPerKilogram => As(RadiationExposureUnit.PicocoulombPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.Roentgen"/>
-        /// </summary>
-        public double Roentgens => As(RadiationExposureUnit.Roentgen);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.CoulombPerKilogram"/>.
-        /// </summary>
-        public static RadiationExposure FromCoulombsPerKilogram(double coulombsperkilogram) => new RadiationExposure(coulombsperkilogram, RadiationExposureUnit.CoulombPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.MicrocoulombPerKilogram"/>.
-        /// </summary>
-        public static RadiationExposure FromMicrocoulombsPerKilogram(double microcoulombsperkilogram) => new RadiationExposure(microcoulombsperkilogram, RadiationExposureUnit.MicrocoulombPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Microroentgen"/>.
-        /// </summary>
-        public static RadiationExposure FromMicroroentgens(double microroentgens) => new RadiationExposure(microroentgens, RadiationExposureUnit.Microroentgen);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.MillicoulombPerKilogram"/>.
-        /// </summary>
-        public static RadiationExposure FromMillicoulombsPerKilogram(double millicoulombsperkilogram) => new RadiationExposure(millicoulombsperkilogram, RadiationExposureUnit.MillicoulombPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Milliroentgen"/>.
-        /// </summary>
-        public static RadiationExposure FromMilliroentgens(double milliroentgens) => new RadiationExposure(milliroentgens, RadiationExposureUnit.Milliroentgen);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.NanocoulombPerKilogram"/>.
-        /// </summary>
-        public static RadiationExposure FromNanocoulombsPerKilogram(double nanocoulombsperkilogram) => new RadiationExposure(nanocoulombsperkilogram, RadiationExposureUnit.NanocoulombPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.PicocoulombPerKilogram"/>.
-        /// </summary>
-        public static RadiationExposure FromPicocoulombsPerKilogram(double picocoulombsperkilogram) => new RadiationExposure(picocoulombsperkilogram, RadiationExposureUnit.PicocoulombPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Roentgen"/>.
-        /// </summary>
-        public static RadiationExposure FromRoentgens(double roentgens) => new RadiationExposure(roentgens, RadiationExposureUnit.Roentgen);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RadiationExposureUnit" /> to <see cref="RadiationExposure" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RadiationExposure unit value.</returns>
-        public static RadiationExposure From(double value, RadiationExposureUnit fromUnit)
-        {
-            return new RadiationExposure(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RadiationExposureUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this RadiationExposure to another RadiationExposure with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A RadiationExposure with the specified unit.</returns>
-                public RadiationExposure ToUnit(RadiationExposureUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new RadiationExposure(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RadiationExposureUnit.CoulombPerKilogram => _value,
-                        RadiationExposureUnit.MicrocoulombPerKilogram => (_value) * 1e-6d,
-                        RadiationExposureUnit.Microroentgen => (_value * 2.58e-4) * 1e-6d,
-                        RadiationExposureUnit.MillicoulombPerKilogram => (_value) * 1e-3d,
-                        RadiationExposureUnit.Milliroentgen => (_value * 2.58e-4) * 1e-3d,
-                        RadiationExposureUnit.NanocoulombPerKilogram => (_value) * 1e-9d,
-                        RadiationExposureUnit.PicocoulombPerKilogram => (_value) * 1e-12d,
-                        RadiationExposureUnit.Roentgen => _value * 2.58e-4,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RadiationExposureUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RadiationExposureUnit.CoulombPerKilogram => baseUnitValue,
-                        RadiationExposureUnit.MicrocoulombPerKilogram => (baseUnitValue) / 1e-6d,
-                        RadiationExposureUnit.Microroentgen => (baseUnitValue / 2.58e-4) / 1e-6d,
-                        RadiationExposureUnit.MillicoulombPerKilogram => (baseUnitValue) / 1e-3d,
-                        RadiationExposureUnit.Milliroentgen => (baseUnitValue / 2.58e-4) / 1e-3d,
-                        RadiationExposureUnit.NanocoulombPerKilogram => (baseUnitValue) / 1e-9d,
-                        RadiationExposureUnit.PicocoulombPerKilogram => (baseUnitValue) / 1e-12d,
-                        RadiationExposureUnit.Roentgen => baseUnitValue / 2.58e-4,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Radioactivity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Radioactivity.g.cs
deleted file mode 100644
index a5b0422773..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Radioactivity.g.cs
+++ /dev/null
@@ -1,493 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Amount of ionizing radiation released when an element spontaneously emits energy as a result of the radioactive decay of an unstable atom per unit time.
-    /// </summary>
-    public struct  Radioactivity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RadioactivityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RadioactivityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Radioactivity(double value, RadioactivityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Radioactivity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RadioactivityUnit BaseUnit { get; } = RadioactivityUnit.Becquerel;
-
-        /// <summary>
-        /// Represents the largest possible value of Radioactivity.
-        /// </summary>
-        public static Radioactivity MaxValue { get; } = new Radioactivity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Radioactivity.
-        /// </summary>
-        public static Radioactivity MinValue { get; } = new Radioactivity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Radioactivity Zero { get; } = new Radioactivity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Becquerel"/>
-        /// </summary>
-        public double Becquerels => As(RadioactivityUnit.Becquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Curie"/>
-        /// </summary>
-        public double Curies => As(RadioactivityUnit.Curie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Exabecquerel"/>
-        /// </summary>
-        public double Exabecquerels => As(RadioactivityUnit.Exabecquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Gigabecquerel"/>
-        /// </summary>
-        public double Gigabecquerels => As(RadioactivityUnit.Gigabecquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Gigacurie"/>
-        /// </summary>
-        public double Gigacuries => As(RadioactivityUnit.Gigacurie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Gigarutherford"/>
-        /// </summary>
-        public double Gigarutherfords => As(RadioactivityUnit.Gigarutherford);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Kilobecquerel"/>
-        /// </summary>
-        public double Kilobecquerels => As(RadioactivityUnit.Kilobecquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Kilocurie"/>
-        /// </summary>
-        public double Kilocuries => As(RadioactivityUnit.Kilocurie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Kilorutherford"/>
-        /// </summary>
-        public double Kilorutherfords => As(RadioactivityUnit.Kilorutherford);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Megabecquerel"/>
-        /// </summary>
-        public double Megabecquerels => As(RadioactivityUnit.Megabecquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Megacurie"/>
-        /// </summary>
-        public double Megacuries => As(RadioactivityUnit.Megacurie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Megarutherford"/>
-        /// </summary>
-        public double Megarutherfords => As(RadioactivityUnit.Megarutherford);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Microbecquerel"/>
-        /// </summary>
-        public double Microbecquerels => As(RadioactivityUnit.Microbecquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Microcurie"/>
-        /// </summary>
-        public double Microcuries => As(RadioactivityUnit.Microcurie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Microrutherford"/>
-        /// </summary>
-        public double Microrutherfords => As(RadioactivityUnit.Microrutherford);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Millibecquerel"/>
-        /// </summary>
-        public double Millibecquerels => As(RadioactivityUnit.Millibecquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Millicurie"/>
-        /// </summary>
-        public double Millicuries => As(RadioactivityUnit.Millicurie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Millirutherford"/>
-        /// </summary>
-        public double Millirutherfords => As(RadioactivityUnit.Millirutherford);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Nanobecquerel"/>
-        /// </summary>
-        public double Nanobecquerels => As(RadioactivityUnit.Nanobecquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Nanocurie"/>
-        /// </summary>
-        public double Nanocuries => As(RadioactivityUnit.Nanocurie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Nanorutherford"/>
-        /// </summary>
-        public double Nanorutherfords => As(RadioactivityUnit.Nanorutherford);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Petabecquerel"/>
-        /// </summary>
-        public double Petabecquerels => As(RadioactivityUnit.Petabecquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Picobecquerel"/>
-        /// </summary>
-        public double Picobecquerels => As(RadioactivityUnit.Picobecquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Picocurie"/>
-        /// </summary>
-        public double Picocuries => As(RadioactivityUnit.Picocurie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Picorutherford"/>
-        /// </summary>
-        public double Picorutherfords => As(RadioactivityUnit.Picorutherford);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Rutherford"/>
-        /// </summary>
-        public double Rutherfords => As(RadioactivityUnit.Rutherford);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Terabecquerel"/>
-        /// </summary>
-        public double Terabecquerels => As(RadioactivityUnit.Terabecquerel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Teracurie"/>
-        /// </summary>
-        public double Teracuries => As(RadioactivityUnit.Teracurie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Terarutherford"/>
-        /// </summary>
-        public double Terarutherfords => As(RadioactivityUnit.Terarutherford);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Becquerel"/>.
-        /// </summary>
-        public static Radioactivity FromBecquerels(double becquerels) => new Radioactivity(becquerels, RadioactivityUnit.Becquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Curie"/>.
-        /// </summary>
-        public static Radioactivity FromCuries(double curies) => new Radioactivity(curies, RadioactivityUnit.Curie);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Exabecquerel"/>.
-        /// </summary>
-        public static Radioactivity FromExabecquerels(double exabecquerels) => new Radioactivity(exabecquerels, RadioactivityUnit.Exabecquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigabecquerel"/>.
-        /// </summary>
-        public static Radioactivity FromGigabecquerels(double gigabecquerels) => new Radioactivity(gigabecquerels, RadioactivityUnit.Gigabecquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigacurie"/>.
-        /// </summary>
-        public static Radioactivity FromGigacuries(double gigacuries) => new Radioactivity(gigacuries, RadioactivityUnit.Gigacurie);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigarutherford"/>.
-        /// </summary>
-        public static Radioactivity FromGigarutherfords(double gigarutherfords) => new Radioactivity(gigarutherfords, RadioactivityUnit.Gigarutherford);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilobecquerel"/>.
-        /// </summary>
-        public static Radioactivity FromKilobecquerels(double kilobecquerels) => new Radioactivity(kilobecquerels, RadioactivityUnit.Kilobecquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilocurie"/>.
-        /// </summary>
-        public static Radioactivity FromKilocuries(double kilocuries) => new Radioactivity(kilocuries, RadioactivityUnit.Kilocurie);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilorutherford"/>.
-        /// </summary>
-        public static Radioactivity FromKilorutherfords(double kilorutherfords) => new Radioactivity(kilorutherfords, RadioactivityUnit.Kilorutherford);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megabecquerel"/>.
-        /// </summary>
-        public static Radioactivity FromMegabecquerels(double megabecquerels) => new Radioactivity(megabecquerels, RadioactivityUnit.Megabecquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megacurie"/>.
-        /// </summary>
-        public static Radioactivity FromMegacuries(double megacuries) => new Radioactivity(megacuries, RadioactivityUnit.Megacurie);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megarutherford"/>.
-        /// </summary>
-        public static Radioactivity FromMegarutherfords(double megarutherfords) => new Radioactivity(megarutherfords, RadioactivityUnit.Megarutherford);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microbecquerel"/>.
-        /// </summary>
-        public static Radioactivity FromMicrobecquerels(double microbecquerels) => new Radioactivity(microbecquerels, RadioactivityUnit.Microbecquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microcurie"/>.
-        /// </summary>
-        public static Radioactivity FromMicrocuries(double microcuries) => new Radioactivity(microcuries, RadioactivityUnit.Microcurie);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microrutherford"/>.
-        /// </summary>
-        public static Radioactivity FromMicrorutherfords(double microrutherfords) => new Radioactivity(microrutherfords, RadioactivityUnit.Microrutherford);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millibecquerel"/>.
-        /// </summary>
-        public static Radioactivity FromMillibecquerels(double millibecquerels) => new Radioactivity(millibecquerels, RadioactivityUnit.Millibecquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millicurie"/>.
-        /// </summary>
-        public static Radioactivity FromMillicuries(double millicuries) => new Radioactivity(millicuries, RadioactivityUnit.Millicurie);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millirutherford"/>.
-        /// </summary>
-        public static Radioactivity FromMillirutherfords(double millirutherfords) => new Radioactivity(millirutherfords, RadioactivityUnit.Millirutherford);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanobecquerel"/>.
-        /// </summary>
-        public static Radioactivity FromNanobecquerels(double nanobecquerels) => new Radioactivity(nanobecquerels, RadioactivityUnit.Nanobecquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanocurie"/>.
-        /// </summary>
-        public static Radioactivity FromNanocuries(double nanocuries) => new Radioactivity(nanocuries, RadioactivityUnit.Nanocurie);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanorutherford"/>.
-        /// </summary>
-        public static Radioactivity FromNanorutherfords(double nanorutherfords) => new Radioactivity(nanorutherfords, RadioactivityUnit.Nanorutherford);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Petabecquerel"/>.
-        /// </summary>
-        public static Radioactivity FromPetabecquerels(double petabecquerels) => new Radioactivity(petabecquerels, RadioactivityUnit.Petabecquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picobecquerel"/>.
-        /// </summary>
-        public static Radioactivity FromPicobecquerels(double picobecquerels) => new Radioactivity(picobecquerels, RadioactivityUnit.Picobecquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picocurie"/>.
-        /// </summary>
-        public static Radioactivity FromPicocuries(double picocuries) => new Radioactivity(picocuries, RadioactivityUnit.Picocurie);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picorutherford"/>.
-        /// </summary>
-        public static Radioactivity FromPicorutherfords(double picorutherfords) => new Radioactivity(picorutherfords, RadioactivityUnit.Picorutherford);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Rutherford"/>.
-        /// </summary>
-        public static Radioactivity FromRutherfords(double rutherfords) => new Radioactivity(rutherfords, RadioactivityUnit.Rutherford);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Terabecquerel"/>.
-        /// </summary>
-        public static Radioactivity FromTerabecquerels(double terabecquerels) => new Radioactivity(terabecquerels, RadioactivityUnit.Terabecquerel);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Teracurie"/>.
-        /// </summary>
-        public static Radioactivity FromTeracuries(double teracuries) => new Radioactivity(teracuries, RadioactivityUnit.Teracurie);
-
-        /// <summary>
-        ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Terarutherford"/>.
-        /// </summary>
-        public static Radioactivity FromTerarutherfords(double terarutherfords) => new Radioactivity(terarutherfords, RadioactivityUnit.Terarutherford);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RadioactivityUnit" /> to <see cref="Radioactivity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Radioactivity unit value.</returns>
-        public static Radioactivity From(double value, RadioactivityUnit fromUnit)
-        {
-            return new Radioactivity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RadioactivityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Radioactivity to another Radioactivity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Radioactivity with the specified unit.</returns>
-                public Radioactivity ToUnit(RadioactivityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Radioactivity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RadioactivityUnit.Becquerel => _value,
-                        RadioactivityUnit.Curie => _value * 3.7e10,
-                        RadioactivityUnit.Exabecquerel => (_value) * 1e18d,
-                        RadioactivityUnit.Gigabecquerel => (_value) * 1e9d,
-                        RadioactivityUnit.Gigacurie => (_value * 3.7e10) * 1e9d,
-                        RadioactivityUnit.Gigarutherford => (_value * 1e6) * 1e9d,
-                        RadioactivityUnit.Kilobecquerel => (_value) * 1e3d,
-                        RadioactivityUnit.Kilocurie => (_value * 3.7e10) * 1e3d,
-                        RadioactivityUnit.Kilorutherford => (_value * 1e6) * 1e3d,
-                        RadioactivityUnit.Megabecquerel => (_value) * 1e6d,
-                        RadioactivityUnit.Megacurie => (_value * 3.7e10) * 1e6d,
-                        RadioactivityUnit.Megarutherford => (_value * 1e6) * 1e6d,
-                        RadioactivityUnit.Microbecquerel => (_value) * 1e-6d,
-                        RadioactivityUnit.Microcurie => (_value * 3.7e10) * 1e-6d,
-                        RadioactivityUnit.Microrutherford => (_value * 1e6) * 1e-6d,
-                        RadioactivityUnit.Millibecquerel => (_value) * 1e-3d,
-                        RadioactivityUnit.Millicurie => (_value * 3.7e10) * 1e-3d,
-                        RadioactivityUnit.Millirutherford => (_value * 1e6) * 1e-3d,
-                        RadioactivityUnit.Nanobecquerel => (_value) * 1e-9d,
-                        RadioactivityUnit.Nanocurie => (_value * 3.7e10) * 1e-9d,
-                        RadioactivityUnit.Nanorutherford => (_value * 1e6) * 1e-9d,
-                        RadioactivityUnit.Petabecquerel => (_value) * 1e15d,
-                        RadioactivityUnit.Picobecquerel => (_value) * 1e-12d,
-                        RadioactivityUnit.Picocurie => (_value * 3.7e10) * 1e-12d,
-                        RadioactivityUnit.Picorutherford => (_value * 1e6) * 1e-12d,
-                        RadioactivityUnit.Rutherford => _value * 1e6,
-                        RadioactivityUnit.Terabecquerel => (_value) * 1e12d,
-                        RadioactivityUnit.Teracurie => (_value * 3.7e10) * 1e12d,
-                        RadioactivityUnit.Terarutherford => (_value * 1e6) * 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RadioactivityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RadioactivityUnit.Becquerel => baseUnitValue,
-                        RadioactivityUnit.Curie => baseUnitValue / 3.7e10,
-                        RadioactivityUnit.Exabecquerel => (baseUnitValue) / 1e18d,
-                        RadioactivityUnit.Gigabecquerel => (baseUnitValue) / 1e9d,
-                        RadioactivityUnit.Gigacurie => (baseUnitValue / 3.7e10) / 1e9d,
-                        RadioactivityUnit.Gigarutherford => (baseUnitValue / 1e6) / 1e9d,
-                        RadioactivityUnit.Kilobecquerel => (baseUnitValue) / 1e3d,
-                        RadioactivityUnit.Kilocurie => (baseUnitValue / 3.7e10) / 1e3d,
-                        RadioactivityUnit.Kilorutherford => (baseUnitValue / 1e6) / 1e3d,
-                        RadioactivityUnit.Megabecquerel => (baseUnitValue) / 1e6d,
-                        RadioactivityUnit.Megacurie => (baseUnitValue / 3.7e10) / 1e6d,
-                        RadioactivityUnit.Megarutherford => (baseUnitValue / 1e6) / 1e6d,
-                        RadioactivityUnit.Microbecquerel => (baseUnitValue) / 1e-6d,
-                        RadioactivityUnit.Microcurie => (baseUnitValue / 3.7e10) / 1e-6d,
-                        RadioactivityUnit.Microrutherford => (baseUnitValue / 1e6) / 1e-6d,
-                        RadioactivityUnit.Millibecquerel => (baseUnitValue) / 1e-3d,
-                        RadioactivityUnit.Millicurie => (baseUnitValue / 3.7e10) / 1e-3d,
-                        RadioactivityUnit.Millirutherford => (baseUnitValue / 1e6) / 1e-3d,
-                        RadioactivityUnit.Nanobecquerel => (baseUnitValue) / 1e-9d,
-                        RadioactivityUnit.Nanocurie => (baseUnitValue / 3.7e10) / 1e-9d,
-                        RadioactivityUnit.Nanorutherford => (baseUnitValue / 1e6) / 1e-9d,
-                        RadioactivityUnit.Petabecquerel => (baseUnitValue) / 1e15d,
-                        RadioactivityUnit.Picobecquerel => (baseUnitValue) / 1e-12d,
-                        RadioactivityUnit.Picocurie => (baseUnitValue / 3.7e10) / 1e-12d,
-                        RadioactivityUnit.Picorutherford => (baseUnitValue / 1e6) / 1e-12d,
-                        RadioactivityUnit.Rutherford => baseUnitValue / 1e6,
-                        RadioactivityUnit.Terabecquerel => (baseUnitValue) / 1e12d,
-                        RadioactivityUnit.Teracurie => (baseUnitValue / 3.7e10) / 1e12d,
-                        RadioactivityUnit.Terarutherford => (baseUnitValue / 1e6) / 1e12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Ratio.g.cs
deleted file mode 100644
index 851469f361..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Ratio.g.cs
+++ /dev/null
@@ -1,217 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In mathematics, a ratio is a relationship between two numbers of the same kind (e.g., objects, persons, students, spoonfuls, units of whatever identical dimension), usually expressed as "a to b" or a:b, sometimes expressed arithmetically as a dimensionless quotient of the two that explicitly indicates how many times the first number contains the second (not necessarily an integer).
-    /// </summary>
-    public struct  Ratio
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RatioUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RatioUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Ratio(double value, RatioUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Ratio, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RatioUnit BaseUnit { get; } = RatioUnit.DecimalFraction;
-
-        /// <summary>
-        /// Represents the largest possible value of Ratio.
-        /// </summary>
-        public static Ratio MaxValue { get; } = new Ratio(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Ratio.
-        /// </summary>
-        public static Ratio MinValue { get; } = new Ratio(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Ratio Zero { get; } = new Ratio(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.DecimalFraction"/>
-        /// </summary>
-        public double DecimalFractions => As(RatioUnit.DecimalFraction);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.PartPerBillion"/>
-        /// </summary>
-        public double PartsPerBillion => As(RatioUnit.PartPerBillion);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.PartPerMillion"/>
-        /// </summary>
-        public double PartsPerMillion => As(RatioUnit.PartPerMillion);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.PartPerThousand"/>
-        /// </summary>
-        public double PartsPerThousand => As(RatioUnit.PartPerThousand);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.PartPerTrillion"/>
-        /// </summary>
-        public double PartsPerTrillion => As(RatioUnit.PartPerTrillion);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.Percent"/>
-        /// </summary>
-        public double Percent => As(RatioUnit.Percent);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.DecimalFraction"/>.
-        /// </summary>
-        public static Ratio FromDecimalFractions(double decimalfractions) => new Ratio(decimalfractions, RatioUnit.DecimalFraction);
-
-        /// <summary>
-        ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerBillion"/>.
-        /// </summary>
-        public static Ratio FromPartsPerBillion(double partsperbillion) => new Ratio(partsperbillion, RatioUnit.PartPerBillion);
-
-        /// <summary>
-        ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerMillion"/>.
-        /// </summary>
-        public static Ratio FromPartsPerMillion(double partspermillion) => new Ratio(partspermillion, RatioUnit.PartPerMillion);
-
-        /// <summary>
-        ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerThousand"/>.
-        /// </summary>
-        public static Ratio FromPartsPerThousand(double partsperthousand) => new Ratio(partsperthousand, RatioUnit.PartPerThousand);
-
-        /// <summary>
-        ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerTrillion"/>.
-        /// </summary>
-        public static Ratio FromPartsPerTrillion(double partspertrillion) => new Ratio(partspertrillion, RatioUnit.PartPerTrillion);
-
-        /// <summary>
-        ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.Percent"/>.
-        /// </summary>
-        public static Ratio FromPercent(double percent) => new Ratio(percent, RatioUnit.Percent);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RatioUnit" /> to <see cref="Ratio" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Ratio unit value.</returns>
-        public static Ratio From(double value, RatioUnit fromUnit)
-        {
-            return new Ratio(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RatioUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Ratio to another Ratio with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Ratio with the specified unit.</returns>
-                public Ratio ToUnit(RatioUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Ratio(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RatioUnit.DecimalFraction => _value,
-                        RatioUnit.PartPerBillion => _value / 1e9,
-                        RatioUnit.PartPerMillion => _value / 1e6,
-                        RatioUnit.PartPerThousand => _value / 1e3,
-                        RatioUnit.PartPerTrillion => _value / 1e12,
-                        RatioUnit.Percent => _value / 1e2,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RatioUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RatioUnit.DecimalFraction => baseUnitValue,
-                        RatioUnit.PartPerBillion => baseUnitValue * 1e9,
-                        RatioUnit.PartPerMillion => baseUnitValue * 1e6,
-                        RatioUnit.PartPerThousand => baseUnitValue * 1e3,
-                        RatioUnit.PartPerTrillion => baseUnitValue * 1e12,
-                        RatioUnit.Percent => baseUnitValue * 1e2,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RatioChangeRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/RatioChangeRate.g.cs
deleted file mode 100644
index fbf544789d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RatioChangeRate.g.cs
+++ /dev/null
@@ -1,169 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The change in ratio per unit of time.
-    /// </summary>
-    public struct  RatioChangeRate
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RatioChangeRateUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RatioChangeRateUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RatioChangeRate(double value, RatioChangeRateUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of RatioChangeRate, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RatioChangeRateUnit BaseUnit { get; } = RatioChangeRateUnit.DecimalFractionPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of RatioChangeRate.
-        /// </summary>
-        public static RatioChangeRate MaxValue { get; } = new RatioChangeRate(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of RatioChangeRate.
-        /// </summary>
-        public static RatioChangeRate MinValue { get; } = new RatioChangeRate(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static RatioChangeRate Zero { get; } = new RatioChangeRate(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioChangeRateUnit.DecimalFractionPerSecond"/>
-        /// </summary>
-        public double DecimalFractionsPerSecond => As(RatioChangeRateUnit.DecimalFractionPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioChangeRateUnit.PercentPerSecond"/>
-        /// </summary>
-        public double PercentsPerSecond => As(RatioChangeRateUnit.PercentPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="RatioChangeRate"/> from <see cref="RatioChangeRateUnit.DecimalFractionPerSecond"/>.
-        /// </summary>
-        public static RatioChangeRate FromDecimalFractionsPerSecond(double decimalfractionspersecond) => new RatioChangeRate(decimalfractionspersecond, RatioChangeRateUnit.DecimalFractionPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RatioChangeRate"/> from <see cref="RatioChangeRateUnit.PercentPerSecond"/>.
-        /// </summary>
-        public static RatioChangeRate FromPercentsPerSecond(double percentspersecond) => new RatioChangeRate(percentspersecond, RatioChangeRateUnit.PercentPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RatioChangeRateUnit" /> to <see cref="RatioChangeRate" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RatioChangeRate unit value.</returns>
-        public static RatioChangeRate From(double value, RatioChangeRateUnit fromUnit)
-        {
-            return new RatioChangeRate(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RatioChangeRateUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this RatioChangeRate to another RatioChangeRate with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A RatioChangeRate with the specified unit.</returns>
-                public RatioChangeRate ToUnit(RatioChangeRateUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new RatioChangeRate(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RatioChangeRateUnit.DecimalFractionPerSecond => _value,
-                        RatioChangeRateUnit.PercentPerSecond => _value / 1e2,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RatioChangeRateUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RatioChangeRateUnit.DecimalFractionPerSecond => baseUnitValue,
-                        RatioChangeRateUnit.PercentPerSecond => baseUnitValue * 1e2,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ReciprocalArea.g.cs
deleted file mode 100644
index 3904a09425..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ReciprocalArea.g.cs
+++ /dev/null
@@ -1,280 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Reciprocal area (Inverse-square) quantity is used to specify a physical quantity inversely proportional to the square of the distance.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Inverse-square_law
-    /// </remarks>
-    public struct  ReciprocalArea
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ReciprocalAreaUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ReciprocalAreaUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ReciprocalArea(double value, ReciprocalAreaUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ReciprocalArea, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ReciprocalAreaUnit BaseUnit { get; } = ReciprocalAreaUnit.InverseSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of ReciprocalArea.
-        /// </summary>
-        public static ReciprocalArea MaxValue { get; } = new ReciprocalArea(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ReciprocalArea.
-        /// </summary>
-        public static ReciprocalArea MinValue { get; } = new ReciprocalArea(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ReciprocalArea Zero { get; } = new ReciprocalArea(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareCentimeter"/>
-        /// </summary>
-        public double InverseSquareCentimeters => As(ReciprocalAreaUnit.InverseSquareCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareDecimeter"/>
-        /// </summary>
-        public double InverseSquareDecimeters => As(ReciprocalAreaUnit.InverseSquareDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareFoot"/>
-        /// </summary>
-        public double InverseSquareFeet => As(ReciprocalAreaUnit.InverseSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareInch"/>
-        /// </summary>
-        public double InverseSquareInches => As(ReciprocalAreaUnit.InverseSquareInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareKilometer"/>
-        /// </summary>
-        public double InverseSquareKilometers => As(ReciprocalAreaUnit.InverseSquareKilometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMeter"/>
-        /// </summary>
-        public double InverseSquareMeters => As(ReciprocalAreaUnit.InverseSquareMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMicrometer"/>
-        /// </summary>
-        public double InverseSquareMicrometers => As(ReciprocalAreaUnit.InverseSquareMicrometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMile"/>
-        /// </summary>
-        public double InverseSquareMiles => As(ReciprocalAreaUnit.InverseSquareMile);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMillimeter"/>
-        /// </summary>
-        public double InverseSquareMillimeters => As(ReciprocalAreaUnit.InverseSquareMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareYard"/>
-        /// </summary>
-        public double InverseSquareYards => As(ReciprocalAreaUnit.InverseSquareYard);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseUsSurveySquareFoot"/>
-        /// </summary>
-        public double InverseUsSurveySquareFeet => As(ReciprocalAreaUnit.InverseUsSurveySquareFoot);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareCentimeter"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseSquareCentimeters(double inversesquarecentimeters) => new ReciprocalArea(inversesquarecentimeters, ReciprocalAreaUnit.InverseSquareCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareDecimeter"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseSquareDecimeters(double inversesquaredecimeters) => new ReciprocalArea(inversesquaredecimeters, ReciprocalAreaUnit.InverseSquareDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareFoot"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseSquareFeet(double inversesquarefeet) => new ReciprocalArea(inversesquarefeet, ReciprocalAreaUnit.InverseSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareInch"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseSquareInches(double inversesquareinches) => new ReciprocalArea(inversesquareinches, ReciprocalAreaUnit.InverseSquareInch);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareKilometer"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseSquareKilometers(double inversesquarekilometers) => new ReciprocalArea(inversesquarekilometers, ReciprocalAreaUnit.InverseSquareKilometer);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMeter"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseSquareMeters(double inversesquaremeters) => new ReciprocalArea(inversesquaremeters, ReciprocalAreaUnit.InverseSquareMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMicrometer"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseSquareMicrometers(double inversesquaremicrometers) => new ReciprocalArea(inversesquaremicrometers, ReciprocalAreaUnit.InverseSquareMicrometer);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMile"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseSquareMiles(double inversesquaremiles) => new ReciprocalArea(inversesquaremiles, ReciprocalAreaUnit.InverseSquareMile);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMillimeter"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseSquareMillimeters(double inversesquaremillimeters) => new ReciprocalArea(inversesquaremillimeters, ReciprocalAreaUnit.InverseSquareMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareYard"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseSquareYards(double inversesquareyards) => new ReciprocalArea(inversesquareyards, ReciprocalAreaUnit.InverseSquareYard);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseUsSurveySquareFoot"/>.
-        /// </summary>
-        public static ReciprocalArea FromInverseUsSurveySquareFeet(double inverseussurveysquarefeet) => new ReciprocalArea(inverseussurveysquarefeet, ReciprocalAreaUnit.InverseUsSurveySquareFoot);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ReciprocalAreaUnit" /> to <see cref="ReciprocalArea" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ReciprocalArea unit value.</returns>
-        public static ReciprocalArea From(double value, ReciprocalAreaUnit fromUnit)
-        {
-            return new ReciprocalArea(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ReciprocalAreaUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ReciprocalArea to another ReciprocalArea with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ReciprocalArea with the specified unit.</returns>
-                public ReciprocalArea ToUnit(ReciprocalAreaUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ReciprocalArea(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ReciprocalAreaUnit.InverseSquareCentimeter => _value / 1e-4,
-                        ReciprocalAreaUnit.InverseSquareDecimeter => _value / 1e-2,
-                        ReciprocalAreaUnit.InverseSquareFoot => _value / 9.290304e-2,
-                        ReciprocalAreaUnit.InverseSquareInch => _value / 0.00064516,
-                        ReciprocalAreaUnit.InverseSquareKilometer => _value / 1e6,
-                        ReciprocalAreaUnit.InverseSquareMeter => _value,
-                        ReciprocalAreaUnit.InverseSquareMicrometer => _value / 1e-12,
-                        ReciprocalAreaUnit.InverseSquareMile => _value / (1609.344 * 1609.344),
-                        ReciprocalAreaUnit.InverseSquareMillimeter => _value / 1e-6,
-                        ReciprocalAreaUnit.InverseSquareYard => _value / (0.9144 * 0.9144),
-                        ReciprocalAreaUnit.InverseUsSurveySquareFoot => _value / (1200.0 / 3937.0) / (1200.0 / 3937.0),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ReciprocalAreaUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ReciprocalAreaUnit.InverseSquareCentimeter => baseUnitValue * 1e-4,
-                        ReciprocalAreaUnit.InverseSquareDecimeter => baseUnitValue * 1e-2,
-                        ReciprocalAreaUnit.InverseSquareFoot => baseUnitValue * 9.290304e-2,
-                        ReciprocalAreaUnit.InverseSquareInch => baseUnitValue * 0.00064516,
-                        ReciprocalAreaUnit.InverseSquareKilometer => baseUnitValue * 1e6,
-                        ReciprocalAreaUnit.InverseSquareMeter => baseUnitValue,
-                        ReciprocalAreaUnit.InverseSquareMicrometer => baseUnitValue * 1e-12,
-                        ReciprocalAreaUnit.InverseSquareMile => baseUnitValue * (1609.344 * 1609.344),
-                        ReciprocalAreaUnit.InverseSquareMillimeter => baseUnitValue * 1e-6,
-                        ReciprocalAreaUnit.InverseSquareYard => baseUnitValue * (0.9144 * 0.9144),
-                        ReciprocalAreaUnit.InverseUsSurveySquareFoot => baseUnitValue * (1200.0 / 3937.0) * (1200.0 / 3937.0),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ReciprocalLength.g.cs
deleted file mode 100644
index 4663e72183..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ReciprocalLength.g.cs
+++ /dev/null
@@ -1,268 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Reciprocal (Inverse) Length is used in various fields of science and mathematics. It is defined as the inverse value of a length unit.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Reciprocal_length
-    /// </remarks>
-    public struct  ReciprocalLength
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ReciprocalLengthUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ReciprocalLengthUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ReciprocalLength(double value, ReciprocalLengthUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ReciprocalLength, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ReciprocalLengthUnit BaseUnit { get; } = ReciprocalLengthUnit.InverseMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of ReciprocalLength.
-        /// </summary>
-        public static ReciprocalLength MaxValue { get; } = new ReciprocalLength(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ReciprocalLength.
-        /// </summary>
-        public static ReciprocalLength MinValue { get; } = new ReciprocalLength(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ReciprocalLength Zero { get; } = new ReciprocalLength(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseCentimeter"/>
-        /// </summary>
-        public double InverseCentimeters => As(ReciprocalLengthUnit.InverseCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseFoot"/>
-        /// </summary>
-        public double InverseFeet => As(ReciprocalLengthUnit.InverseFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseInch"/>
-        /// </summary>
-        public double InverseInches => As(ReciprocalLengthUnit.InverseInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMeter"/>
-        /// </summary>
-        public double InverseMeters => As(ReciprocalLengthUnit.InverseMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMicroinch"/>
-        /// </summary>
-        public double InverseMicroinches => As(ReciprocalLengthUnit.InverseMicroinch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMil"/>
-        /// </summary>
-        public double InverseMils => As(ReciprocalLengthUnit.InverseMil);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMile"/>
-        /// </summary>
-        public double InverseMiles => As(ReciprocalLengthUnit.InverseMile);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMillimeter"/>
-        /// </summary>
-        public double InverseMillimeters => As(ReciprocalLengthUnit.InverseMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseUsSurveyFoot"/>
-        /// </summary>
-        public double InverseUsSurveyFeet => As(ReciprocalLengthUnit.InverseUsSurveyFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseYard"/>
-        /// </summary>
-        public double InverseYards => As(ReciprocalLengthUnit.InverseYard);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseCentimeter"/>.
-        /// </summary>
-        public static ReciprocalLength FromInverseCentimeters(double inversecentimeters) => new ReciprocalLength(inversecentimeters, ReciprocalLengthUnit.InverseCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseFoot"/>.
-        /// </summary>
-        public static ReciprocalLength FromInverseFeet(double inversefeet) => new ReciprocalLength(inversefeet, ReciprocalLengthUnit.InverseFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseInch"/>.
-        /// </summary>
-        public static ReciprocalLength FromInverseInches(double inverseinches) => new ReciprocalLength(inverseinches, ReciprocalLengthUnit.InverseInch);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMeter"/>.
-        /// </summary>
-        public static ReciprocalLength FromInverseMeters(double inversemeters) => new ReciprocalLength(inversemeters, ReciprocalLengthUnit.InverseMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMicroinch"/>.
-        /// </summary>
-        public static ReciprocalLength FromInverseMicroinches(double inversemicroinches) => new ReciprocalLength(inversemicroinches, ReciprocalLengthUnit.InverseMicroinch);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMil"/>.
-        /// </summary>
-        public static ReciprocalLength FromInverseMils(double inversemils) => new ReciprocalLength(inversemils, ReciprocalLengthUnit.InverseMil);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMile"/>.
-        /// </summary>
-        public static ReciprocalLength FromInverseMiles(double inversemiles) => new ReciprocalLength(inversemiles, ReciprocalLengthUnit.InverseMile);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMillimeter"/>.
-        /// </summary>
-        public static ReciprocalLength FromInverseMillimeters(double inversemillimeters) => new ReciprocalLength(inversemillimeters, ReciprocalLengthUnit.InverseMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseUsSurveyFoot"/>.
-        /// </summary>
-        public static ReciprocalLength FromInverseUsSurveyFeet(double inverseussurveyfeet) => new ReciprocalLength(inverseussurveyfeet, ReciprocalLengthUnit.InverseUsSurveyFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseYard"/>.
-        /// </summary>
-        public static ReciprocalLength FromInverseYards(double inverseyards) => new ReciprocalLength(inverseyards, ReciprocalLengthUnit.InverseYard);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ReciprocalLengthUnit" /> to <see cref="ReciprocalLength" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ReciprocalLength unit value.</returns>
-        public static ReciprocalLength From(double value, ReciprocalLengthUnit fromUnit)
-        {
-            return new ReciprocalLength(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ReciprocalLengthUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ReciprocalLength to another ReciprocalLength with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ReciprocalLength with the specified unit.</returns>
-                public ReciprocalLength ToUnit(ReciprocalLengthUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ReciprocalLength(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ReciprocalLengthUnit.InverseCentimeter => _value * 1e2,
-                        ReciprocalLengthUnit.InverseFoot => _value / 0.3048,
-                        ReciprocalLengthUnit.InverseInch => _value / 2.54e-2,
-                        ReciprocalLengthUnit.InverseMeter => _value,
-                        ReciprocalLengthUnit.InverseMicroinch => _value / 2.54e-8,
-                        ReciprocalLengthUnit.InverseMil => _value / 2.54e-5,
-                        ReciprocalLengthUnit.InverseMile => _value / 1609.344,
-                        ReciprocalLengthUnit.InverseMillimeter => _value * 1e3,
-                        ReciprocalLengthUnit.InverseUsSurveyFoot => _value * 3937 / 1200,
-                        ReciprocalLengthUnit.InverseYard => _value / 0.9144,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ReciprocalLengthUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ReciprocalLengthUnit.InverseCentimeter => baseUnitValue / 1e2,
-                        ReciprocalLengthUnit.InverseFoot => baseUnitValue * 0.3048,
-                        ReciprocalLengthUnit.InverseInch => baseUnitValue * 2.54e-2,
-                        ReciprocalLengthUnit.InverseMeter => baseUnitValue,
-                        ReciprocalLengthUnit.InverseMicroinch => baseUnitValue * 2.54e-8,
-                        ReciprocalLengthUnit.InverseMil => baseUnitValue * 2.54e-5,
-                        ReciprocalLengthUnit.InverseMile => baseUnitValue * 1609.344,
-                        ReciprocalLengthUnit.InverseMillimeter => baseUnitValue / 1e3,
-                        ReciprocalLengthUnit.InverseUsSurveyFoot => baseUnitValue * 1200 / 3937,
-                        ReciprocalLengthUnit.InverseYard => baseUnitValue * 0.9144,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RelativeHumidity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/RelativeHumidity.g.cs
deleted file mode 100644
index c3c583d1b3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RelativeHumidity.g.cs
+++ /dev/null
@@ -1,157 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Relative humidity is a ratio of the actual water vapor present in the air to the maximum water vapor in the air at the given temperature.
-    /// </summary>
-    public struct  RelativeHumidity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RelativeHumidityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RelativeHumidityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RelativeHumidity(double value, RelativeHumidityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of RelativeHumidity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RelativeHumidityUnit BaseUnit { get; } = RelativeHumidityUnit.Percent;
-
-        /// <summary>
-        /// Represents the largest possible value of RelativeHumidity.
-        /// </summary>
-        public static RelativeHumidity MaxValue { get; } = new RelativeHumidity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of RelativeHumidity.
-        /// </summary>
-        public static RelativeHumidity MinValue { get; } = new RelativeHumidity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static RelativeHumidity Zero { get; } = new RelativeHumidity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RelativeHumidityUnit.Percent"/>
-        /// </summary>
-        public double Percent => As(RelativeHumidityUnit.Percent);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="RelativeHumidity"/> from <see cref="RelativeHumidityUnit.Percent"/>.
-        /// </summary>
-        public static RelativeHumidity FromPercent(double percent) => new RelativeHumidity(percent, RelativeHumidityUnit.Percent);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RelativeHumidityUnit" /> to <see cref="RelativeHumidity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RelativeHumidity unit value.</returns>
-        public static RelativeHumidity From(double value, RelativeHumidityUnit fromUnit)
-        {
-            return new RelativeHumidity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RelativeHumidityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this RelativeHumidity to another RelativeHumidity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A RelativeHumidity with the specified unit.</returns>
-                public RelativeHumidity ToUnit(RelativeHumidityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new RelativeHumidity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RelativeHumidityUnit.Percent => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RelativeHumidityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RelativeHumidityUnit.Percent => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalAcceleration.g.cs
deleted file mode 100644
index 7bdaedb545..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalAcceleration.g.cs
+++ /dev/null
@@ -1,193 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Angular acceleration is the rate of change of rotational speed.
-    /// </summary>
-    public struct  RotationalAcceleration
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RotationalAccelerationUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RotationalAccelerationUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RotationalAcceleration(double value, RotationalAccelerationUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of RotationalAcceleration, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RotationalAccelerationUnit BaseUnit { get; } = RotationalAccelerationUnit.RadianPerSecondSquared;
-
-        /// <summary>
-        /// Represents the largest possible value of RotationalAcceleration.
-        /// </summary>
-        public static RotationalAcceleration MaxValue { get; } = new RotationalAcceleration(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of RotationalAcceleration.
-        /// </summary>
-        public static RotationalAcceleration MinValue { get; } = new RotationalAcceleration(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static RotationalAcceleration Zero { get; } = new RotationalAcceleration(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.DegreePerSecondSquared"/>
-        /// </summary>
-        public double DegreesPerSecondSquared => As(RotationalAccelerationUnit.DegreePerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.RadianPerSecondSquared"/>
-        /// </summary>
-        public double RadiansPerSecondSquared => As(RotationalAccelerationUnit.RadianPerSecondSquared);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.RevolutionPerMinutePerSecond"/>
-        /// </summary>
-        public double RevolutionsPerMinutePerSecond => As(RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.RevolutionPerSecondSquared"/>
-        /// </summary>
-        public double RevolutionsPerSecondSquared => As(RotationalAccelerationUnit.RevolutionPerSecondSquared);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.DegreePerSecondSquared"/>.
-        /// </summary>
-        public static RotationalAcceleration FromDegreesPerSecondSquared(double degreespersecondsquared) => new RotationalAcceleration(degreespersecondsquared, RotationalAccelerationUnit.DegreePerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RadianPerSecondSquared"/>.
-        /// </summary>
-        public static RotationalAcceleration FromRadiansPerSecondSquared(double radianspersecondsquared) => new RotationalAcceleration(radianspersecondsquared, RotationalAccelerationUnit.RadianPerSecondSquared);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RevolutionPerMinutePerSecond"/>.
-        /// </summary>
-        public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(double revolutionsperminutepersecond) => new RotationalAcceleration(revolutionsperminutepersecond, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RevolutionPerSecondSquared"/>.
-        /// </summary>
-        public static RotationalAcceleration FromRevolutionsPerSecondSquared(double revolutionspersecondsquared) => new RotationalAcceleration(revolutionspersecondsquared, RotationalAccelerationUnit.RevolutionPerSecondSquared);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RotationalAccelerationUnit" /> to <see cref="RotationalAcceleration" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RotationalAcceleration unit value.</returns>
-        public static RotationalAcceleration From(double value, RotationalAccelerationUnit fromUnit)
-        {
-            return new RotationalAcceleration(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RotationalAccelerationUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this RotationalAcceleration to another RotationalAcceleration with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A RotationalAcceleration with the specified unit.</returns>
-                public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new RotationalAcceleration(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RotationalAccelerationUnit.DegreePerSecondSquared => (3.1415926535897931 / 180) * _value,
-                        RotationalAccelerationUnit.RadianPerSecondSquared => _value,
-                        RotationalAccelerationUnit.RevolutionPerMinutePerSecond => ((2 * 3.1415926535897931) / 60) * _value,
-                        RotationalAccelerationUnit.RevolutionPerSecondSquared => (2 * 3.1415926535897931) * _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RotationalAccelerationUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RotationalAccelerationUnit.DegreePerSecondSquared => (180 / 3.1415926535897931) * baseUnitValue,
-                        RotationalAccelerationUnit.RadianPerSecondSquared => baseUnitValue,
-                        RotationalAccelerationUnit.RevolutionPerMinutePerSecond => (60 / (2 * 3.1415926535897931)) * baseUnitValue,
-                        RotationalAccelerationUnit.RevolutionPerSecondSquared => (1 / (2 * 3.1415926535897931)) * baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalSpeed.g.cs
deleted file mode 100644
index 079d1d6c7d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalSpeed.g.cs
+++ /dev/null
@@ -1,301 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Rotational speed (sometimes called speed of revolution) is the number of complete rotations, revolutions, cycles, or turns per time unit. Rotational speed is a cyclic frequency, measured in radians per second or in hertz in the SI System by scientists, or in revolutions per minute (rpm or min-1) or revolutions per second in everyday life. The symbol for rotational speed is ω (the Greek lowercase letter "omega").
-    /// </summary>
-    public struct  RotationalSpeed
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RotationalSpeedUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RotationalSpeedUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RotationalSpeed(double value, RotationalSpeedUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of RotationalSpeed, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RotationalSpeedUnit BaseUnit { get; } = RotationalSpeedUnit.RadianPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of RotationalSpeed.
-        /// </summary>
-        public static RotationalSpeed MaxValue { get; } = new RotationalSpeed(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of RotationalSpeed.
-        /// </summary>
-        public static RotationalSpeed MinValue { get; } = new RotationalSpeed(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static RotationalSpeed Zero { get; } = new RotationalSpeed(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.CentiradianPerSecond"/>
-        /// </summary>
-        public double CentiradiansPerSecond => As(RotationalSpeedUnit.CentiradianPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.DeciradianPerSecond"/>
-        /// </summary>
-        public double DeciradiansPerSecond => As(RotationalSpeedUnit.DeciradianPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.DegreePerMinute"/>
-        /// </summary>
-        public double DegreesPerMinute => As(RotationalSpeedUnit.DegreePerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.DegreePerSecond"/>
-        /// </summary>
-        public double DegreesPerSecond => As(RotationalSpeedUnit.DegreePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MicrodegreePerSecond"/>
-        /// </summary>
-        public double MicrodegreesPerSecond => As(RotationalSpeedUnit.MicrodegreePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MicroradianPerSecond"/>
-        /// </summary>
-        public double MicroradiansPerSecond => As(RotationalSpeedUnit.MicroradianPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MillidegreePerSecond"/>
-        /// </summary>
-        public double MillidegreesPerSecond => As(RotationalSpeedUnit.MillidegreePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MilliradianPerSecond"/>
-        /// </summary>
-        public double MilliradiansPerSecond => As(RotationalSpeedUnit.MilliradianPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.NanodegreePerSecond"/>
-        /// </summary>
-        public double NanodegreesPerSecond => As(RotationalSpeedUnit.NanodegreePerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.NanoradianPerSecond"/>
-        /// </summary>
-        public double NanoradiansPerSecond => As(RotationalSpeedUnit.NanoradianPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.RadianPerSecond"/>
-        /// </summary>
-        public double RadiansPerSecond => As(RotationalSpeedUnit.RadianPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.RevolutionPerMinute"/>
-        /// </summary>
-        public double RevolutionsPerMinute => As(RotationalSpeedUnit.RevolutionPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.RevolutionPerSecond"/>
-        /// </summary>
-        public double RevolutionsPerSecond => As(RotationalSpeedUnit.RevolutionPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.CentiradianPerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromCentiradiansPerSecond(double centiradianspersecond) => new RotationalSpeed(centiradianspersecond, RotationalSpeedUnit.CentiradianPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DeciradianPerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromDeciradiansPerSecond(double deciradianspersecond) => new RotationalSpeed(deciradianspersecond, RotationalSpeedUnit.DeciradianPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DegreePerMinute"/>.
-        /// </summary>
-        public static RotationalSpeed FromDegreesPerMinute(double degreesperminute) => new RotationalSpeed(degreesperminute, RotationalSpeedUnit.DegreePerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DegreePerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromDegreesPerSecond(double degreespersecond) => new RotationalSpeed(degreespersecond, RotationalSpeedUnit.DegreePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MicrodegreePerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromMicrodegreesPerSecond(double microdegreespersecond) => new RotationalSpeed(microdegreespersecond, RotationalSpeedUnit.MicrodegreePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MicroradianPerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromMicroradiansPerSecond(double microradianspersecond) => new RotationalSpeed(microradianspersecond, RotationalSpeedUnit.MicroradianPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MillidegreePerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromMillidegreesPerSecond(double millidegreespersecond) => new RotationalSpeed(millidegreespersecond, RotationalSpeedUnit.MillidegreePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MilliradianPerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromMilliradiansPerSecond(double milliradianspersecond) => new RotationalSpeed(milliradianspersecond, RotationalSpeedUnit.MilliradianPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.NanodegreePerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromNanodegreesPerSecond(double nanodegreespersecond) => new RotationalSpeed(nanodegreespersecond, RotationalSpeedUnit.NanodegreePerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.NanoradianPerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromNanoradiansPerSecond(double nanoradianspersecond) => new RotationalSpeed(nanoradianspersecond, RotationalSpeedUnit.NanoradianPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RadianPerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromRadiansPerSecond(double radianspersecond) => new RotationalSpeed(radianspersecond, RotationalSpeedUnit.RadianPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RevolutionPerMinute"/>.
-        /// </summary>
-        public static RotationalSpeed FromRevolutionsPerMinute(double revolutionsperminute) => new RotationalSpeed(revolutionsperminute, RotationalSpeedUnit.RevolutionPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RevolutionPerSecond"/>.
-        /// </summary>
-        public static RotationalSpeed FromRevolutionsPerSecond(double revolutionspersecond) => new RotationalSpeed(revolutionspersecond, RotationalSpeedUnit.RevolutionPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RotationalSpeedUnit" /> to <see cref="RotationalSpeed" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RotationalSpeed unit value.</returns>
-        public static RotationalSpeed From(double value, RotationalSpeedUnit fromUnit)
-        {
-            return new RotationalSpeed(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RotationalSpeedUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this RotationalSpeed to another RotationalSpeed with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A RotationalSpeed with the specified unit.</returns>
-                public RotationalSpeed ToUnit(RotationalSpeedUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new RotationalSpeed(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RotationalSpeedUnit.CentiradianPerSecond => (_value) * 1e-2d,
-                        RotationalSpeedUnit.DeciradianPerSecond => (_value) * 1e-1d,
-                        RotationalSpeedUnit.DegreePerMinute => (3.1415926535897931 / (180 * 60)) * _value,
-                        RotationalSpeedUnit.DegreePerSecond => (3.1415926535897931 / 180) * _value,
-                        RotationalSpeedUnit.MicrodegreePerSecond => ((3.1415926535897931 / 180) * _value) * 1e-6d,
-                        RotationalSpeedUnit.MicroradianPerSecond => (_value) * 1e-6d,
-                        RotationalSpeedUnit.MillidegreePerSecond => ((3.1415926535897931 / 180) * _value) * 1e-3d,
-                        RotationalSpeedUnit.MilliradianPerSecond => (_value) * 1e-3d,
-                        RotationalSpeedUnit.NanodegreePerSecond => ((3.1415926535897931 / 180) * _value) * 1e-9d,
-                        RotationalSpeedUnit.NanoradianPerSecond => (_value) * 1e-9d,
-                        RotationalSpeedUnit.RadianPerSecond => _value,
-                        RotationalSpeedUnit.RevolutionPerMinute => (_value * 2 * 3.1415926535897931) / 60,
-                        RotationalSpeedUnit.RevolutionPerSecond => _value * 2 * 3.1415926535897931,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RotationalSpeedUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RotationalSpeedUnit.CentiradianPerSecond => (baseUnitValue) / 1e-2d,
-                        RotationalSpeedUnit.DeciradianPerSecond => (baseUnitValue) / 1e-1d,
-                        RotationalSpeedUnit.DegreePerMinute => (180 * 60 / 3.1415926535897931) * baseUnitValue,
-                        RotationalSpeedUnit.DegreePerSecond => (180 / 3.1415926535897931) * baseUnitValue,
-                        RotationalSpeedUnit.MicrodegreePerSecond => ((180 / 3.1415926535897931) * baseUnitValue) / 1e-6d,
-                        RotationalSpeedUnit.MicroradianPerSecond => (baseUnitValue) / 1e-6d,
-                        RotationalSpeedUnit.MillidegreePerSecond => ((180 / 3.1415926535897931) * baseUnitValue) / 1e-3d,
-                        RotationalSpeedUnit.MilliradianPerSecond => (baseUnitValue) / 1e-3d,
-                        RotationalSpeedUnit.NanodegreePerSecond => ((180 / 3.1415926535897931) * baseUnitValue) / 1e-9d,
-                        RotationalSpeedUnit.NanoradianPerSecond => (baseUnitValue) / 1e-9d,
-                        RotationalSpeedUnit.RadianPerSecond => baseUnitValue,
-                        RotationalSpeedUnit.RevolutionPerMinute => (baseUnitValue / (2 * 3.1415926535897931)) * 60,
-                        RotationalSpeedUnit.RevolutionPerSecond => baseUnitValue / (2 * 3.1415926535897931),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalStiffness.g.cs
deleted file mode 100644
index b7e34514c8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalStiffness.g.cs
+++ /dev/null
@@ -1,553 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     https://en.wikipedia.org/wiki/Stiffness#Rotational_stiffness
-    /// </summary>
-    public struct  RotationalStiffness
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RotationalStiffnessUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RotationalStiffnessUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RotationalStiffness(double value, RotationalStiffnessUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of RotationalStiffness, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RotationalStiffnessUnit BaseUnit { get; } = RotationalStiffnessUnit.NewtonMeterPerRadian;
-
-        /// <summary>
-        /// Represents the largest possible value of RotationalStiffness.
-        /// </summary>
-        public static RotationalStiffness MaxValue { get; } = new RotationalStiffness(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of RotationalStiffness.
-        /// </summary>
-        public static RotationalStiffness MinValue { get; } = new RotationalStiffness(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static RotationalStiffness Zero { get; } = new RotationalStiffness(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.CentinewtonMeterPerDegree"/>
-        /// </summary>
-        public double CentinewtonMetersPerDegree => As(RotationalStiffnessUnit.CentinewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerDegree"/>
-        /// </summary>
-        public double CentinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerRadian"/>
-        /// </summary>
-        public double CentinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecanewtonMeterPerDegree"/>
-        /// </summary>
-        public double DecanewtonMetersPerDegree => As(RotationalStiffnessUnit.DecanewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerDegree"/>
-        /// </summary>
-        public double DecanewtonMillimetersPerDegree => As(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerRadian"/>
-        /// </summary>
-        public double DecanewtonMillimetersPerRadian => As(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecinewtonMeterPerDegree"/>
-        /// </summary>
-        public double DecinewtonMetersPerDegree => As(RotationalStiffnessUnit.DecinewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerDegree"/>
-        /// </summary>
-        public double DecinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerRadian"/>
-        /// </summary>
-        public double DecinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMeterPerDegree"/>
-        /// </summary>
-        public double KilonewtonMetersPerDegree => As(RotationalStiffnessUnit.KilonewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMeterPerRadian"/>
-        /// </summary>
-        public double KilonewtonMetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerDegree"/>
-        /// </summary>
-        public double KilonewtonMillimetersPerDegree => As(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerRadian"/>
-        /// </summary>
-        public double KilonewtonMillimetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilopoundForceFootPerDegrees"/>
-        /// </summary>
-        public double KilopoundForceFeetPerDegrees => As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilopoundForceFootPerRadian"/>
-        /// </summary>
-        public double KilopoundForceFeetPerRadian => As(RotationalStiffnessUnit.KilopoundForceFootPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMeterPerDegree"/>
-        /// </summary>
-        public double MeganewtonMetersPerDegree => As(RotationalStiffnessUnit.MeganewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMeterPerRadian"/>
-        /// </summary>
-        public double MeganewtonMetersPerRadian => As(RotationalStiffnessUnit.MeganewtonMeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerDegree"/>
-        /// </summary>
-        public double MeganewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerRadian"/>
-        /// </summary>
-        public double MeganewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MicronewtonMeterPerDegree"/>
-        /// </summary>
-        public double MicronewtonMetersPerDegree => As(RotationalStiffnessUnit.MicronewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerDegree"/>
-        /// </summary>
-        public double MicronewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerRadian"/>
-        /// </summary>
-        public double MicronewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MillinewtonMeterPerDegree"/>
-        /// </summary>
-        public double MillinewtonMetersPerDegree => As(RotationalStiffnessUnit.MillinewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerDegree"/>
-        /// </summary>
-        public double MillinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerRadian"/>
-        /// </summary>
-        public double MillinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NanonewtonMeterPerDegree"/>
-        /// </summary>
-        public double NanonewtonMetersPerDegree => As(RotationalStiffnessUnit.NanonewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerDegree"/>
-        /// </summary>
-        public double NanonewtonMillimetersPerDegree => As(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerRadian"/>
-        /// </summary>
-        public double NanonewtonMillimetersPerRadian => As(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMeterPerDegree"/>
-        /// </summary>
-        public double NewtonMetersPerDegree => As(RotationalStiffnessUnit.NewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMeterPerRadian"/>
-        /// </summary>
-        public double NewtonMetersPerRadian => As(RotationalStiffnessUnit.NewtonMeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMillimeterPerDegree"/>
-        /// </summary>
-        public double NewtonMillimetersPerDegree => As(RotationalStiffnessUnit.NewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMillimeterPerRadian"/>
-        /// </summary>
-        public double NewtonMillimetersPerRadian => As(RotationalStiffnessUnit.NewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.PoundForceFeetPerRadian"/>
-        /// </summary>
-        public double PoundForceFeetPerRadian => As(RotationalStiffnessUnit.PoundForceFeetPerRadian);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.PoundForceFootPerDegrees"/>
-        /// </summary>
-        public double PoundForceFeetPerDegrees => As(RotationalStiffnessUnit.PoundForceFootPerDegrees);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromCentinewtonMetersPerDegree(double centinewtonmetersperdegree) => new RotationalStiffness(centinewtonmetersperdegree, RotationalStiffnessUnit.CentinewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromCentinewtonMillimetersPerDegree(double centinewtonmillimetersperdegree) => new RotationalStiffness(centinewtonmillimetersperdegree, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromCentinewtonMillimetersPerRadian(double centinewtonmillimetersperradian) => new RotationalStiffness(centinewtonmillimetersperradian, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromDecanewtonMetersPerDegree(double decanewtonmetersperdegree) => new RotationalStiffness(decanewtonmetersperdegree, RotationalStiffnessUnit.DecanewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromDecanewtonMillimetersPerDegree(double decanewtonmillimetersperdegree) => new RotationalStiffness(decanewtonmillimetersperdegree, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromDecanewtonMillimetersPerRadian(double decanewtonmillimetersperradian) => new RotationalStiffness(decanewtonmillimetersperradian, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromDecinewtonMetersPerDegree(double decinewtonmetersperdegree) => new RotationalStiffness(decinewtonmetersperdegree, RotationalStiffnessUnit.DecinewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromDecinewtonMillimetersPerDegree(double decinewtonmillimetersperdegree) => new RotationalStiffness(decinewtonmillimetersperdegree, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromDecinewtonMillimetersPerRadian(double decinewtonmillimetersperradian) => new RotationalStiffness(decinewtonmillimetersperradian, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromKilonewtonMetersPerDegree(double kilonewtonmetersperdegree) => new RotationalStiffness(kilonewtonmetersperdegree, RotationalStiffnessUnit.KilonewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromKilonewtonMetersPerRadian(double kilonewtonmetersperradian) => new RotationalStiffness(kilonewtonmetersperradian, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromKilonewtonMillimetersPerDegree(double kilonewtonmillimetersperdegree) => new RotationalStiffness(kilonewtonmillimetersperdegree, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromKilonewtonMillimetersPerRadian(double kilonewtonmillimetersperradian) => new RotationalStiffness(kilonewtonmillimetersperradian, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilopoundForceFootPerDegrees"/>.
-        /// </summary>
-        public static RotationalStiffness FromKilopoundForceFeetPerDegrees(double kilopoundforcefeetperdegrees) => new RotationalStiffness(kilopoundforcefeetperdegrees, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilopoundForceFootPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromKilopoundForceFeetPerRadian(double kilopoundforcefeetperradian) => new RotationalStiffness(kilopoundforcefeetperradian, RotationalStiffnessUnit.KilopoundForceFootPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromMeganewtonMetersPerDegree(double meganewtonmetersperdegree) => new RotationalStiffness(meganewtonmetersperdegree, RotationalStiffnessUnit.MeganewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromMeganewtonMetersPerRadian(double meganewtonmetersperradian) => new RotationalStiffness(meganewtonmetersperradian, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromMeganewtonMillimetersPerDegree(double meganewtonmillimetersperdegree) => new RotationalStiffness(meganewtonmillimetersperdegree, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromMeganewtonMillimetersPerRadian(double meganewtonmillimetersperradian) => new RotationalStiffness(meganewtonmillimetersperradian, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromMicronewtonMetersPerDegree(double micronewtonmetersperdegree) => new RotationalStiffness(micronewtonmetersperdegree, RotationalStiffnessUnit.MicronewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromMicronewtonMillimetersPerDegree(double micronewtonmillimetersperdegree) => new RotationalStiffness(micronewtonmillimetersperdegree, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromMicronewtonMillimetersPerRadian(double micronewtonmillimetersperradian) => new RotationalStiffness(micronewtonmillimetersperradian, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromMillinewtonMetersPerDegree(double millinewtonmetersperdegree) => new RotationalStiffness(millinewtonmetersperdegree, RotationalStiffnessUnit.MillinewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromMillinewtonMillimetersPerDegree(double millinewtonmillimetersperdegree) => new RotationalStiffness(millinewtonmillimetersperdegree, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromMillinewtonMillimetersPerRadian(double millinewtonmillimetersperradian) => new RotationalStiffness(millinewtonmillimetersperradian, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromNanonewtonMetersPerDegree(double nanonewtonmetersperdegree) => new RotationalStiffness(nanonewtonmetersperdegree, RotationalStiffnessUnit.NanonewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromNanonewtonMillimetersPerDegree(double nanonewtonmillimetersperdegree) => new RotationalStiffness(nanonewtonmillimetersperdegree, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromNanonewtonMillimetersPerRadian(double nanonewtonmillimetersperradian) => new RotationalStiffness(nanonewtonmillimetersperradian, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromNewtonMetersPerDegree(double newtonmetersperdegree) => new RotationalStiffness(newtonmetersperdegree, RotationalStiffnessUnit.NewtonMeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromNewtonMetersPerRadian(double newtonmetersperradian) => new RotationalStiffness(newtonmetersperradian, RotationalStiffnessUnit.NewtonMeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMillimeterPerDegree"/>.
-        /// </summary>
-        public static RotationalStiffness FromNewtonMillimetersPerDegree(double newtonmillimetersperdegree) => new RotationalStiffness(newtonmillimetersperdegree, RotationalStiffnessUnit.NewtonMillimeterPerDegree);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMillimeterPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromNewtonMillimetersPerRadian(double newtonmillimetersperradian) => new RotationalStiffness(newtonmillimetersperradian, RotationalStiffnessUnit.NewtonMillimeterPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.PoundForceFeetPerRadian"/>.
-        /// </summary>
-        public static RotationalStiffness FromPoundForceFeetPerRadian(double poundforcefeetperradian) => new RotationalStiffness(poundforcefeetperradian, RotationalStiffnessUnit.PoundForceFeetPerRadian);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.PoundForceFootPerDegrees"/>.
-        /// </summary>
-        public static RotationalStiffness FromPoundForceFeetPerDegrees(double poundforcefeetperdegrees) => new RotationalStiffness(poundforcefeetperdegrees, RotationalStiffnessUnit.PoundForceFootPerDegrees);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RotationalStiffnessUnit" /> to <see cref="RotationalStiffness" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RotationalStiffness unit value.</returns>
-        public static RotationalStiffness From(double value, RotationalStiffnessUnit fromUnit)
-        {
-            return new RotationalStiffness(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RotationalStiffnessUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this RotationalStiffness to another RotationalStiffness with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A RotationalStiffness with the specified unit.</returns>
-                public RotationalStiffness ToUnit(RotationalStiffnessUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new RotationalStiffness(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RotationalStiffnessUnit.CentinewtonMeterPerDegree => (_value * (180 / 3.1415926535897931)) * 1e-2d,
-                        RotationalStiffnessUnit.CentinewtonMillimeterPerDegree => (_value * 180 / 3.1415926535897931 * 0.001) * 1e-2d,
-                        RotationalStiffnessUnit.CentinewtonMillimeterPerRadian => (_value * 0.001) * 1e-2d,
-                        RotationalStiffnessUnit.DecanewtonMeterPerDegree => (_value * (180 / 3.1415926535897931)) * 1e1d,
-                        RotationalStiffnessUnit.DecanewtonMillimeterPerDegree => (_value * 180 / 3.1415926535897931 * 0.001) * 1e1d,
-                        RotationalStiffnessUnit.DecanewtonMillimeterPerRadian => (_value * 0.001) * 1e1d,
-                        RotationalStiffnessUnit.DecinewtonMeterPerDegree => (_value * (180 / 3.1415926535897931)) * 1e-1d,
-                        RotationalStiffnessUnit.DecinewtonMillimeterPerDegree => (_value * 180 / 3.1415926535897931 * 0.001) * 1e-1d,
-                        RotationalStiffnessUnit.DecinewtonMillimeterPerRadian => (_value * 0.001) * 1e-1d,
-                        RotationalStiffnessUnit.KilonewtonMeterPerDegree => (_value * (180 / 3.1415926535897931)) * 1e3d,
-                        RotationalStiffnessUnit.KilonewtonMeterPerRadian => (_value) * 1e3d,
-                        RotationalStiffnessUnit.KilonewtonMillimeterPerDegree => (_value * 180 / 3.1415926535897931 * 0.001) * 1e3d,
-                        RotationalStiffnessUnit.KilonewtonMillimeterPerRadian => (_value * 0.001) * 1e3d,
-                        RotationalStiffnessUnit.KilopoundForceFootPerDegrees => _value * (4.4482216152605e3 * 0.3048 * 180 / 3.1415926535897931),
-                        RotationalStiffnessUnit.KilopoundForceFootPerRadian => _value * 4.4482216152605e3 * 0.3048,
-                        RotationalStiffnessUnit.MeganewtonMeterPerDegree => (_value * (180 / 3.1415926535897931)) * 1e6d,
-                        RotationalStiffnessUnit.MeganewtonMeterPerRadian => (_value) * 1e6d,
-                        RotationalStiffnessUnit.MeganewtonMillimeterPerDegree => (_value * 180 / 3.1415926535897931 * 0.001) * 1e6d,
-                        RotationalStiffnessUnit.MeganewtonMillimeterPerRadian => (_value * 0.001) * 1e6d,
-                        RotationalStiffnessUnit.MicronewtonMeterPerDegree => (_value * (180 / 3.1415926535897931)) * 1e-6d,
-                        RotationalStiffnessUnit.MicronewtonMillimeterPerDegree => (_value * 180 / 3.1415926535897931 * 0.001) * 1e-6d,
-                        RotationalStiffnessUnit.MicronewtonMillimeterPerRadian => (_value * 0.001) * 1e-6d,
-                        RotationalStiffnessUnit.MillinewtonMeterPerDegree => (_value * (180 / 3.1415926535897931)) * 1e-3d,
-                        RotationalStiffnessUnit.MillinewtonMillimeterPerDegree => (_value * 180 / 3.1415926535897931 * 0.001) * 1e-3d,
-                        RotationalStiffnessUnit.MillinewtonMillimeterPerRadian => (_value * 0.001) * 1e-3d,
-                        RotationalStiffnessUnit.NanonewtonMeterPerDegree => (_value * (180 / 3.1415926535897931)) * 1e-9d,
-                        RotationalStiffnessUnit.NanonewtonMillimeterPerDegree => (_value * 180 / 3.1415926535897931 * 0.001) * 1e-9d,
-                        RotationalStiffnessUnit.NanonewtonMillimeterPerRadian => (_value * 0.001) * 1e-9d,
-                        RotationalStiffnessUnit.NewtonMeterPerDegree => _value * (180 / 3.1415926535897931),
-                        RotationalStiffnessUnit.NewtonMeterPerRadian => _value,
-                        RotationalStiffnessUnit.NewtonMillimeterPerDegree => _value * 180 / 3.1415926535897931 * 0.001,
-                        RotationalStiffnessUnit.NewtonMillimeterPerRadian => _value * 0.001,
-                        RotationalStiffnessUnit.PoundForceFeetPerRadian => _value * 4.4482216152605 * 0.3048,
-                        RotationalStiffnessUnit.PoundForceFootPerDegrees => _value * (4.4482216152605 * 0.3048 * 180 / 3.1415926535897931),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RotationalStiffnessUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RotationalStiffnessUnit.CentinewtonMeterPerDegree => (baseUnitValue / (180 / 3.1415926535897931)) / 1e-2d,
-                        RotationalStiffnessUnit.CentinewtonMillimeterPerDegree => (baseUnitValue / 180 * 3.1415926535897931 * 1000) / 1e-2d,
-                        RotationalStiffnessUnit.CentinewtonMillimeterPerRadian => (baseUnitValue * 1000) / 1e-2d,
-                        RotationalStiffnessUnit.DecanewtonMeterPerDegree => (baseUnitValue / (180 / 3.1415926535897931)) / 1e1d,
-                        RotationalStiffnessUnit.DecanewtonMillimeterPerDegree => (baseUnitValue / 180 * 3.1415926535897931 * 1000) / 1e1d,
-                        RotationalStiffnessUnit.DecanewtonMillimeterPerRadian => (baseUnitValue * 1000) / 1e1d,
-                        RotationalStiffnessUnit.DecinewtonMeterPerDegree => (baseUnitValue / (180 / 3.1415926535897931)) / 1e-1d,
-                        RotationalStiffnessUnit.DecinewtonMillimeterPerDegree => (baseUnitValue / 180 * 3.1415926535897931 * 1000) / 1e-1d,
-                        RotationalStiffnessUnit.DecinewtonMillimeterPerRadian => (baseUnitValue * 1000) / 1e-1d,
-                        RotationalStiffnessUnit.KilonewtonMeterPerDegree => (baseUnitValue / (180 / 3.1415926535897931)) / 1e3d,
-                        RotationalStiffnessUnit.KilonewtonMeterPerRadian => (baseUnitValue) / 1e3d,
-                        RotationalStiffnessUnit.KilonewtonMillimeterPerDegree => (baseUnitValue / 180 * 3.1415926535897931 * 1000) / 1e3d,
-                        RotationalStiffnessUnit.KilonewtonMillimeterPerRadian => (baseUnitValue * 1000) / 1e3d,
-                        RotationalStiffnessUnit.KilopoundForceFootPerDegrees => baseUnitValue / (4.4482216152605e3 * 0.3048 * 180 / 3.1415926535897931),
-                        RotationalStiffnessUnit.KilopoundForceFootPerRadian => baseUnitValue / (4.4482216152605e3 * 0.3048),
-                        RotationalStiffnessUnit.MeganewtonMeterPerDegree => (baseUnitValue / (180 / 3.1415926535897931)) / 1e6d,
-                        RotationalStiffnessUnit.MeganewtonMeterPerRadian => (baseUnitValue) / 1e6d,
-                        RotationalStiffnessUnit.MeganewtonMillimeterPerDegree => (baseUnitValue / 180 * 3.1415926535897931 * 1000) / 1e6d,
-                        RotationalStiffnessUnit.MeganewtonMillimeterPerRadian => (baseUnitValue * 1000) / 1e6d,
-                        RotationalStiffnessUnit.MicronewtonMeterPerDegree => (baseUnitValue / (180 / 3.1415926535897931)) / 1e-6d,
-                        RotationalStiffnessUnit.MicronewtonMillimeterPerDegree => (baseUnitValue / 180 * 3.1415926535897931 * 1000) / 1e-6d,
-                        RotationalStiffnessUnit.MicronewtonMillimeterPerRadian => (baseUnitValue * 1000) / 1e-6d,
-                        RotationalStiffnessUnit.MillinewtonMeterPerDegree => (baseUnitValue / (180 / 3.1415926535897931)) / 1e-3d,
-                        RotationalStiffnessUnit.MillinewtonMillimeterPerDegree => (baseUnitValue / 180 * 3.1415926535897931 * 1000) / 1e-3d,
-                        RotationalStiffnessUnit.MillinewtonMillimeterPerRadian => (baseUnitValue * 1000) / 1e-3d,
-                        RotationalStiffnessUnit.NanonewtonMeterPerDegree => (baseUnitValue / (180 / 3.1415926535897931)) / 1e-9d,
-                        RotationalStiffnessUnit.NanonewtonMillimeterPerDegree => (baseUnitValue / 180 * 3.1415926535897931 * 1000) / 1e-9d,
-                        RotationalStiffnessUnit.NanonewtonMillimeterPerRadian => (baseUnitValue * 1000) / 1e-9d,
-                        RotationalStiffnessUnit.NewtonMeterPerDegree => baseUnitValue / (180 / 3.1415926535897931),
-                        RotationalStiffnessUnit.NewtonMeterPerRadian => baseUnitValue,
-                        RotationalStiffnessUnit.NewtonMillimeterPerDegree => baseUnitValue / 180 * 3.1415926535897931 * 1000,
-                        RotationalStiffnessUnit.NewtonMillimeterPerRadian => baseUnitValue * 1000,
-                        RotationalStiffnessUnit.PoundForceFeetPerRadian => baseUnitValue / (4.4482216152605 * 0.3048),
-                        RotationalStiffnessUnit.PoundForceFootPerDegrees => baseUnitValue / (4.4482216152605 * 0.3048 * 180 / 3.1415926535897931),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
deleted file mode 100644
index 9ace4bbc80..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
+++ /dev/null
@@ -1,205 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     https://en.wikipedia.org/wiki/Stiffness#Rotational_stiffness
-    /// </summary>
-    public struct  RotationalStiffnessPerLength
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly RotationalStiffnessPerLengthUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public RotationalStiffnessPerLengthUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RotationalStiffnessPerLength(double value, RotationalStiffnessPerLengthUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of RotationalStiffnessPerLength, which is Second. All conversions go via this value.
-        /// </summary>
-        public static RotationalStiffnessPerLengthUnit BaseUnit { get; } = RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of RotationalStiffnessPerLength.
-        /// </summary>
-        public static RotationalStiffnessPerLength MaxValue { get; } = new RotationalStiffnessPerLength(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of RotationalStiffnessPerLength.
-        /// </summary>
-        public static RotationalStiffnessPerLength MinValue { get; } = new RotationalStiffnessPerLength(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static RotationalStiffnessPerLength Zero { get; } = new RotationalStiffnessPerLength(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter"/>
-        /// </summary>
-        public double KilonewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot"/>
-        /// </summary>
-        public double KilopoundForceFeetPerDegreesPerFeet => As(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter"/>
-        /// </summary>
-        public double MeganewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter"/>
-        /// </summary>
-        public double NewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot"/>
-        /// </summary>
-        public double PoundForceFeetPerDegreesPerFeet => As(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter"/>.
-        /// </summary>
-        public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter(double kilonewtonmetersperradianpermeter) => new RotationalStiffnessPerLength(kilonewtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot"/>.
-        /// </summary>
-        public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFeet(double kilopoundforcefeetperdegreesperfeet) => new RotationalStiffnessPerLength(kilopoundforcefeetperdegreesperfeet, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter"/>.
-        /// </summary>
-        public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter(double meganewtonmetersperradianpermeter) => new RotationalStiffnessPerLength(meganewtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter"/>.
-        /// </summary>
-        public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(double newtonmetersperradianpermeter) => new RotationalStiffnessPerLength(newtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot"/>.
-        /// </summary>
-        public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(double poundforcefeetperdegreesperfeet) => new RotationalStiffnessPerLength(poundforcefeetperdegreesperfeet, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="RotationalStiffnessPerLengthUnit" /> to <see cref="RotationalStiffnessPerLength" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>RotationalStiffnessPerLength unit value.</returns>
-        public static RotationalStiffnessPerLength From(double value, RotationalStiffnessPerLengthUnit fromUnit)
-        {
-            return new RotationalStiffnessPerLength(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(RotationalStiffnessPerLengthUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this RotationalStiffnessPerLength to another RotationalStiffnessPerLength with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A RotationalStiffnessPerLength with the specified unit.</returns>
-                public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new RotationalStiffnessPerLength(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter => (_value) * 1e3d,
-                        RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot => _value * (4.4482216152605e3 * 180 / 3.1415926535897931),
-                        RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter => (_value) * 1e6d,
-                        RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter => _value,
-                        RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot => _value * (4.4482216152605 * 180 / 3.1415926535897931),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(RotationalStiffnessPerLengthUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter => (baseUnitValue) / 1e3d,
-                        RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot => baseUnitValue / (4.4482216152605e3 * 180 / 3.1415926535897931),
-                        RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter => (baseUnitValue) / 1e6d,
-                        RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter => baseUnitValue,
-                        RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot => baseUnitValue / (4.4482216152605 * 180 / 3.1415926535897931),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Scalar.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Scalar.g.cs
deleted file mode 100644
index 2f39ceaf42..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Scalar.g.cs
+++ /dev/null
@@ -1,157 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     A way of representing a number of items.
-    /// </summary>
-    public struct  Scalar
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ScalarUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ScalarUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Scalar(double value, ScalarUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Scalar, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ScalarUnit BaseUnit { get; } = ScalarUnit.Amount;
-
-        /// <summary>
-        /// Represents the largest possible value of Scalar.
-        /// </summary>
-        public static Scalar MaxValue { get; } = new Scalar(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Scalar.
-        /// </summary>
-        public static Scalar MinValue { get; } = new Scalar(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Scalar Zero { get; } = new Scalar(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ScalarUnit.Amount"/>
-        /// </summary>
-        public double Amount => As(ScalarUnit.Amount);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Scalar"/> from <see cref="ScalarUnit.Amount"/>.
-        /// </summary>
-        public static Scalar FromAmount(double amount) => new Scalar(amount, ScalarUnit.Amount);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ScalarUnit" /> to <see cref="Scalar" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Scalar unit value.</returns>
-        public static Scalar From(double value, ScalarUnit fromUnit)
-        {
-            return new Scalar(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ScalarUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Scalar to another Scalar with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Scalar with the specified unit.</returns>
-                public Scalar ToUnit(ScalarUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Scalar(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ScalarUnit.Amount => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ScalarUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ScalarUnit.Amount => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SolidAngle.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/SolidAngle.g.cs
deleted file mode 100644
index 4f5508a823..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SolidAngle.g.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In geometry, a solid angle is the two-dimensional angle in three-dimensional space that an object subtends at a point.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Solid_angle
-    /// </remarks>
-    public struct  SolidAngle
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly SolidAngleUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public SolidAngleUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SolidAngle(double value, SolidAngleUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of SolidAngle, which is Second. All conversions go via this value.
-        /// </summary>
-        public static SolidAngleUnit BaseUnit { get; } = SolidAngleUnit.Steradian;
-
-        /// <summary>
-        /// Represents the largest possible value of SolidAngle.
-        /// </summary>
-        public static SolidAngle MaxValue { get; } = new SolidAngle(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of SolidAngle.
-        /// </summary>
-        public static SolidAngle MinValue { get; } = new SolidAngle(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static SolidAngle Zero { get; } = new SolidAngle(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SolidAngleUnit.Steradian"/>
-        /// </summary>
-        public double Steradians => As(SolidAngleUnit.Steradian);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="SolidAngle"/> from <see cref="SolidAngleUnit.Steradian"/>.
-        /// </summary>
-        public static SolidAngle FromSteradians(double steradians) => new SolidAngle(steradians, SolidAngleUnit.Steradian);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SolidAngleUnit" /> to <see cref="SolidAngle" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SolidAngle unit value.</returns>
-        public static SolidAngle From(double value, SolidAngleUnit fromUnit)
-        {
-            return new SolidAngle(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(SolidAngleUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this SolidAngle to another SolidAngle with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A SolidAngle with the specified unit.</returns>
-                public SolidAngle ToUnit(SolidAngleUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new SolidAngle(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        SolidAngleUnit.Steradian => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(SolidAngleUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        SolidAngleUnit.Steradian => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificEnergy.g.cs
deleted file mode 100644
index 294728402a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificEnergy.g.cs
+++ /dev/null
@@ -1,508 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The SpecificEnergy
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Specific_energy
-    /// </remarks>
-    public struct  SpecificEnergy
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly SpecificEnergyUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public SpecificEnergyUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SpecificEnergy(double value, SpecificEnergyUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of SpecificEnergy, which is Second. All conversions go via this value.
-        /// </summary>
-        public static SpecificEnergyUnit BaseUnit { get; } = SpecificEnergyUnit.JoulePerKilogram;
-
-        /// <summary>
-        /// Represents the largest possible value of SpecificEnergy.
-        /// </summary>
-        public static SpecificEnergy MaxValue { get; } = new SpecificEnergy(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of SpecificEnergy.
-        /// </summary>
-        public static SpecificEnergy MinValue { get; } = new SpecificEnergy(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static SpecificEnergy Zero { get; } = new SpecificEnergy(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.BtuPerPound"/>
-        /// </summary>
-        public double BtuPerPound => As(SpecificEnergyUnit.BtuPerPound);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.CaloriePerGram"/>
-        /// </summary>
-        public double CaloriesPerGram => As(SpecificEnergyUnit.CaloriePerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattDayPerKilogram"/>
-        /// </summary>
-        public double GigawattDaysPerKilogram => As(SpecificEnergyUnit.GigawattDayPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattDayPerShortTon"/>
-        /// </summary>
-        public double GigawattDaysPerShortTon => As(SpecificEnergyUnit.GigawattDayPerShortTon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattDayPerTonne"/>
-        /// </summary>
-        public double GigawattDaysPerTonne => As(SpecificEnergyUnit.GigawattDayPerTonne);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattHourPerKilogram"/>
-        /// </summary>
-        public double GigawattHoursPerKilogram => As(SpecificEnergyUnit.GigawattHourPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattHourPerPound"/>
-        /// </summary>
-        public double GigawattHoursPerPound => As(SpecificEnergyUnit.GigawattHourPerPound);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.JoulePerKilogram"/>
-        /// </summary>
-        public double JoulesPerKilogram => As(SpecificEnergyUnit.JoulePerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilocaloriePerGram"/>
-        /// </summary>
-        public double KilocaloriesPerGram => As(SpecificEnergyUnit.KilocaloriePerGram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilojoulePerKilogram"/>
-        /// </summary>
-        public double KilojoulesPerKilogram => As(SpecificEnergyUnit.KilojoulePerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattDayPerKilogram"/>
-        /// </summary>
-        public double KilowattDaysPerKilogram => As(SpecificEnergyUnit.KilowattDayPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattDayPerShortTon"/>
-        /// </summary>
-        public double KilowattDaysPerShortTon => As(SpecificEnergyUnit.KilowattDayPerShortTon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattDayPerTonne"/>
-        /// </summary>
-        public double KilowattDaysPerTonne => As(SpecificEnergyUnit.KilowattDayPerTonne);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattHourPerKilogram"/>
-        /// </summary>
-        public double KilowattHoursPerKilogram => As(SpecificEnergyUnit.KilowattHourPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattHourPerPound"/>
-        /// </summary>
-        public double KilowattHoursPerPound => As(SpecificEnergyUnit.KilowattHourPerPound);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegajoulePerKilogram"/>
-        /// </summary>
-        public double MegajoulesPerKilogram => As(SpecificEnergyUnit.MegajoulePerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegajoulePerTonne"/>
-        /// </summary>
-        public double MegajoulesPerTonne => As(SpecificEnergyUnit.MegajoulePerTonne);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattDayPerKilogram"/>
-        /// </summary>
-        public double MegawattDaysPerKilogram => As(SpecificEnergyUnit.MegawattDayPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattDayPerShortTon"/>
-        /// </summary>
-        public double MegawattDaysPerShortTon => As(SpecificEnergyUnit.MegawattDayPerShortTon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattDayPerTonne"/>
-        /// </summary>
-        public double MegawattDaysPerTonne => As(SpecificEnergyUnit.MegawattDayPerTonne);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattHourPerKilogram"/>
-        /// </summary>
-        public double MegawattHoursPerKilogram => As(SpecificEnergyUnit.MegawattHourPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattHourPerPound"/>
-        /// </summary>
-        public double MegawattHoursPerPound => As(SpecificEnergyUnit.MegawattHourPerPound);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.TerawattDayPerKilogram"/>
-        /// </summary>
-        public double TerawattDaysPerKilogram => As(SpecificEnergyUnit.TerawattDayPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.TerawattDayPerShortTon"/>
-        /// </summary>
-        public double TerawattDaysPerShortTon => As(SpecificEnergyUnit.TerawattDayPerShortTon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.TerawattDayPerTonne"/>
-        /// </summary>
-        public double TerawattDaysPerTonne => As(SpecificEnergyUnit.TerawattDayPerTonne);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattDayPerKilogram"/>
-        /// </summary>
-        public double WattDaysPerKilogram => As(SpecificEnergyUnit.WattDayPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattDayPerShortTon"/>
-        /// </summary>
-        public double WattDaysPerShortTon => As(SpecificEnergyUnit.WattDayPerShortTon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattDayPerTonne"/>
-        /// </summary>
-        public double WattDaysPerTonne => As(SpecificEnergyUnit.WattDayPerTonne);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattHourPerKilogram"/>
-        /// </summary>
-        public double WattHoursPerKilogram => As(SpecificEnergyUnit.WattHourPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattHourPerPound"/>
-        /// </summary>
-        public double WattHoursPerPound => As(SpecificEnergyUnit.WattHourPerPound);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.BtuPerPound"/>.
-        /// </summary>
-        public static SpecificEnergy FromBtuPerPound(double btuperpound) => new SpecificEnergy(btuperpound, SpecificEnergyUnit.BtuPerPound);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.CaloriePerGram"/>.
-        /// </summary>
-        public static SpecificEnergy FromCaloriesPerGram(double caloriespergram) => new SpecificEnergy(caloriespergram, SpecificEnergyUnit.CaloriePerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromGigawattDaysPerKilogram(double gigawattdaysperkilogram) => new SpecificEnergy(gigawattdaysperkilogram, SpecificEnergyUnit.GigawattDayPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerShortTon"/>.
-        /// </summary>
-        public static SpecificEnergy FromGigawattDaysPerShortTon(double gigawattdayspershortton) => new SpecificEnergy(gigawattdayspershortton, SpecificEnergyUnit.GigawattDayPerShortTon);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerTonne"/>.
-        /// </summary>
-        public static SpecificEnergy FromGigawattDaysPerTonne(double gigawattdayspertonne) => new SpecificEnergy(gigawattdayspertonne, SpecificEnergyUnit.GigawattDayPerTonne);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattHourPerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromGigawattHoursPerKilogram(double gigawatthoursperkilogram) => new SpecificEnergy(gigawatthoursperkilogram, SpecificEnergyUnit.GigawattHourPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattHourPerPound"/>.
-        /// </summary>
-        public static SpecificEnergy FromGigawattHoursPerPound(double gigawatthoursperpound) => new SpecificEnergy(gigawatthoursperpound, SpecificEnergyUnit.GigawattHourPerPound);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.JoulePerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromJoulesPerKilogram(double joulesperkilogram) => new SpecificEnergy(joulesperkilogram, SpecificEnergyUnit.JoulePerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilocaloriePerGram"/>.
-        /// </summary>
-        public static SpecificEnergy FromKilocaloriesPerGram(double kilocaloriespergram) => new SpecificEnergy(kilocaloriespergram, SpecificEnergyUnit.KilocaloriePerGram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilojoulePerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromKilojoulesPerKilogram(double kilojoulesperkilogram) => new SpecificEnergy(kilojoulesperkilogram, SpecificEnergyUnit.KilojoulePerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromKilowattDaysPerKilogram(double kilowattdaysperkilogram) => new SpecificEnergy(kilowattdaysperkilogram, SpecificEnergyUnit.KilowattDayPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerShortTon"/>.
-        /// </summary>
-        public static SpecificEnergy FromKilowattDaysPerShortTon(double kilowattdayspershortton) => new SpecificEnergy(kilowattdayspershortton, SpecificEnergyUnit.KilowattDayPerShortTon);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerTonne"/>.
-        /// </summary>
-        public static SpecificEnergy FromKilowattDaysPerTonne(double kilowattdayspertonne) => new SpecificEnergy(kilowattdayspertonne, SpecificEnergyUnit.KilowattDayPerTonne);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattHourPerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromKilowattHoursPerKilogram(double kilowatthoursperkilogram) => new SpecificEnergy(kilowatthoursperkilogram, SpecificEnergyUnit.KilowattHourPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattHourPerPound"/>.
-        /// </summary>
-        public static SpecificEnergy FromKilowattHoursPerPound(double kilowatthoursperpound) => new SpecificEnergy(kilowatthoursperpound, SpecificEnergyUnit.KilowattHourPerPound);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegajoulePerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromMegajoulesPerKilogram(double megajoulesperkilogram) => new SpecificEnergy(megajoulesperkilogram, SpecificEnergyUnit.MegajoulePerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegajoulePerTonne"/>.
-        /// </summary>
-        public static SpecificEnergy FromMegajoulesPerTonne(double megajoulespertonne) => new SpecificEnergy(megajoulespertonne, SpecificEnergyUnit.MegajoulePerTonne);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromMegawattDaysPerKilogram(double megawattdaysperkilogram) => new SpecificEnergy(megawattdaysperkilogram, SpecificEnergyUnit.MegawattDayPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerShortTon"/>.
-        /// </summary>
-        public static SpecificEnergy FromMegawattDaysPerShortTon(double megawattdayspershortton) => new SpecificEnergy(megawattdayspershortton, SpecificEnergyUnit.MegawattDayPerShortTon);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerTonne"/>.
-        /// </summary>
-        public static SpecificEnergy FromMegawattDaysPerTonne(double megawattdayspertonne) => new SpecificEnergy(megawattdayspertonne, SpecificEnergyUnit.MegawattDayPerTonne);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattHourPerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromMegawattHoursPerKilogram(double megawatthoursperkilogram) => new SpecificEnergy(megawatthoursperkilogram, SpecificEnergyUnit.MegawattHourPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattHourPerPound"/>.
-        /// </summary>
-        public static SpecificEnergy FromMegawattHoursPerPound(double megawatthoursperpound) => new SpecificEnergy(megawatthoursperpound, SpecificEnergyUnit.MegawattHourPerPound);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromTerawattDaysPerKilogram(double terawattdaysperkilogram) => new SpecificEnergy(terawattdaysperkilogram, SpecificEnergyUnit.TerawattDayPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerShortTon"/>.
-        /// </summary>
-        public static SpecificEnergy FromTerawattDaysPerShortTon(double terawattdayspershortton) => new SpecificEnergy(terawattdayspershortton, SpecificEnergyUnit.TerawattDayPerShortTon);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerTonne"/>.
-        /// </summary>
-        public static SpecificEnergy FromTerawattDaysPerTonne(double terawattdayspertonne) => new SpecificEnergy(terawattdayspertonne, SpecificEnergyUnit.TerawattDayPerTonne);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromWattDaysPerKilogram(double wattdaysperkilogram) => new SpecificEnergy(wattdaysperkilogram, SpecificEnergyUnit.WattDayPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerShortTon"/>.
-        /// </summary>
-        public static SpecificEnergy FromWattDaysPerShortTon(double wattdayspershortton) => new SpecificEnergy(wattdayspershortton, SpecificEnergyUnit.WattDayPerShortTon);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerTonne"/>.
-        /// </summary>
-        public static SpecificEnergy FromWattDaysPerTonne(double wattdayspertonne) => new SpecificEnergy(wattdayspertonne, SpecificEnergyUnit.WattDayPerTonne);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattHourPerKilogram"/>.
-        /// </summary>
-        public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogram) => new SpecificEnergy(watthoursperkilogram, SpecificEnergyUnit.WattHourPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattHourPerPound"/>.
-        /// </summary>
-        public static SpecificEnergy FromWattHoursPerPound(double watthoursperpound) => new SpecificEnergy(watthoursperpound, SpecificEnergyUnit.WattHourPerPound);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpecificEnergyUnit" /> to <see cref="SpecificEnergy" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SpecificEnergy unit value.</returns>
-        public static SpecificEnergy From(double value, SpecificEnergyUnit fromUnit)
-        {
-            return new SpecificEnergy(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(SpecificEnergyUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this SpecificEnergy to another SpecificEnergy with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A SpecificEnergy with the specified unit.</returns>
-                public SpecificEnergy ToUnit(SpecificEnergyUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new SpecificEnergy(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        SpecificEnergyUnit.BtuPerPound => _value * 1055.05585262 / 0.45359237,
-                        SpecificEnergyUnit.CaloriePerGram => _value * 4.184e3,
-                        SpecificEnergyUnit.GigawattDayPerKilogram => (_value * (24 * 3.6e3)) * 1e9d,
-                        SpecificEnergyUnit.GigawattDayPerShortTon => (_value * ((24 * 3.6e3) / 9.0718474e2)) * 1e9d,
-                        SpecificEnergyUnit.GigawattDayPerTonne => (_value * ((24 * 3.6e3) / 1e3)) * 1e9d,
-                        SpecificEnergyUnit.GigawattHourPerKilogram => (_value * 3.6e3) * 1e9d,
-                        SpecificEnergyUnit.GigawattHourPerPound => (_value * 7.93664e3) * 1e9d,
-                        SpecificEnergyUnit.JoulePerKilogram => _value,
-                        SpecificEnergyUnit.KilocaloriePerGram => (_value * 4.184e3) * 1e3d,
-                        SpecificEnergyUnit.KilojoulePerKilogram => (_value) * 1e3d,
-                        SpecificEnergyUnit.KilowattDayPerKilogram => (_value * (24 * 3.6e3)) * 1e3d,
-                        SpecificEnergyUnit.KilowattDayPerShortTon => (_value * ((24 * 3.6e3) / 9.0718474e2)) * 1e3d,
-                        SpecificEnergyUnit.KilowattDayPerTonne => (_value * ((24 * 3.6e3) / 1e3)) * 1e3d,
-                        SpecificEnergyUnit.KilowattHourPerKilogram => (_value * 3.6e3) * 1e3d,
-                        SpecificEnergyUnit.KilowattHourPerPound => (_value * 7.93664e3) * 1e3d,
-                        SpecificEnergyUnit.MegajoulePerKilogram => (_value) * 1e6d,
-                        SpecificEnergyUnit.MegajoulePerTonne => _value * 1e3,
-                        SpecificEnergyUnit.MegawattDayPerKilogram => (_value * (24 * 3.6e3)) * 1e6d,
-                        SpecificEnergyUnit.MegawattDayPerShortTon => (_value * ((24 * 3.6e3) / 9.0718474e2)) * 1e6d,
-                        SpecificEnergyUnit.MegawattDayPerTonne => (_value * ((24 * 3.6e3) / 1e3)) * 1e6d,
-                        SpecificEnergyUnit.MegawattHourPerKilogram => (_value * 3.6e3) * 1e6d,
-                        SpecificEnergyUnit.MegawattHourPerPound => (_value * 7.93664e3) * 1e6d,
-                        SpecificEnergyUnit.TerawattDayPerKilogram => (_value * (24 * 3.6e3)) * 1e12d,
-                        SpecificEnergyUnit.TerawattDayPerShortTon => (_value * ((24 * 3.6e3) / 9.0718474e2)) * 1e12d,
-                        SpecificEnergyUnit.TerawattDayPerTonne => (_value * ((24 * 3.6e3) / 1e3)) * 1e12d,
-                        SpecificEnergyUnit.WattDayPerKilogram => _value * (24 * 3.6e3),
-                        SpecificEnergyUnit.WattDayPerShortTon => _value * ((24 * 3.6e3) / 9.0718474e2),
-                        SpecificEnergyUnit.WattDayPerTonne => _value * ((24 * 3.6e3) / 1e3),
-                        SpecificEnergyUnit.WattHourPerKilogram => _value * 3.6e3,
-                        SpecificEnergyUnit.WattHourPerPound => _value * 7.93664e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(SpecificEnergyUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        SpecificEnergyUnit.BtuPerPound => baseUnitValue * 0.45359237 / 1055.05585262,
-                        SpecificEnergyUnit.CaloriePerGram => baseUnitValue / 4.184e3,
-                        SpecificEnergyUnit.GigawattDayPerKilogram => (baseUnitValue / (24 * 3.6e3)) / 1e9d,
-                        SpecificEnergyUnit.GigawattDayPerShortTon => (baseUnitValue / ((24 * 3.6e3) / 9.0718474e2)) / 1e9d,
-                        SpecificEnergyUnit.GigawattDayPerTonne => (baseUnitValue / ((24 * 3.6e3) / 1e3)) / 1e9d,
-                        SpecificEnergyUnit.GigawattHourPerKilogram => (baseUnitValue / 3.6e3) / 1e9d,
-                        SpecificEnergyUnit.GigawattHourPerPound => (baseUnitValue / 7.93664e3) / 1e9d,
-                        SpecificEnergyUnit.JoulePerKilogram => baseUnitValue,
-                        SpecificEnergyUnit.KilocaloriePerGram => (baseUnitValue / 4.184e3) / 1e3d,
-                        SpecificEnergyUnit.KilojoulePerKilogram => (baseUnitValue) / 1e3d,
-                        SpecificEnergyUnit.KilowattDayPerKilogram => (baseUnitValue / (24 * 3.6e3)) / 1e3d,
-                        SpecificEnergyUnit.KilowattDayPerShortTon => (baseUnitValue / ((24 * 3.6e3) / 9.0718474e2)) / 1e3d,
-                        SpecificEnergyUnit.KilowattDayPerTonne => (baseUnitValue / ((24 * 3.6e3) / 1e3)) / 1e3d,
-                        SpecificEnergyUnit.KilowattHourPerKilogram => (baseUnitValue / 3.6e3) / 1e3d,
-                        SpecificEnergyUnit.KilowattHourPerPound => (baseUnitValue / 7.93664e3) / 1e3d,
-                        SpecificEnergyUnit.MegajoulePerKilogram => (baseUnitValue) / 1e6d,
-                        SpecificEnergyUnit.MegajoulePerTonne => baseUnitValue / 1e3,
-                        SpecificEnergyUnit.MegawattDayPerKilogram => (baseUnitValue / (24 * 3.6e3)) / 1e6d,
-                        SpecificEnergyUnit.MegawattDayPerShortTon => (baseUnitValue / ((24 * 3.6e3) / 9.0718474e2)) / 1e6d,
-                        SpecificEnergyUnit.MegawattDayPerTonne => (baseUnitValue / ((24 * 3.6e3) / 1e3)) / 1e6d,
-                        SpecificEnergyUnit.MegawattHourPerKilogram => (baseUnitValue / 3.6e3) / 1e6d,
-                        SpecificEnergyUnit.MegawattHourPerPound => (baseUnitValue / 7.93664e3) / 1e6d,
-                        SpecificEnergyUnit.TerawattDayPerKilogram => (baseUnitValue / (24 * 3.6e3)) / 1e12d,
-                        SpecificEnergyUnit.TerawattDayPerShortTon => (baseUnitValue / ((24 * 3.6e3) / 9.0718474e2)) / 1e12d,
-                        SpecificEnergyUnit.TerawattDayPerTonne => (baseUnitValue / ((24 * 3.6e3) / 1e3)) / 1e12d,
-                        SpecificEnergyUnit.WattDayPerKilogram => baseUnitValue / (24 * 3.6e3),
-                        SpecificEnergyUnit.WattDayPerShortTon => baseUnitValue / ((24 * 3.6e3) / 9.0718474e2),
-                        SpecificEnergyUnit.WattDayPerTonne => baseUnitValue / ((24 * 3.6e3) / 1e3),
-                        SpecificEnergyUnit.WattHourPerKilogram => baseUnitValue / 3.6e3,
-                        SpecificEnergyUnit.WattHourPerPound => baseUnitValue / 7.93664e3,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificEntropy.g.cs
deleted file mode 100644
index f904002032..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificEntropy.g.cs
+++ /dev/null
@@ -1,253 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Specific entropy is an amount of energy required to raise temperature of a substance by 1 Kelvin per unit mass.
-    /// </summary>
-    public struct  SpecificEntropy
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly SpecificEntropyUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public SpecificEntropyUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SpecificEntropy(double value, SpecificEntropyUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of SpecificEntropy, which is Second. All conversions go via this value.
-        /// </summary>
-        public static SpecificEntropyUnit BaseUnit { get; } = SpecificEntropyUnit.JoulePerKilogramKelvin;
-
-        /// <summary>
-        /// Represents the largest possible value of SpecificEntropy.
-        /// </summary>
-        public static SpecificEntropy MaxValue { get; } = new SpecificEntropy(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of SpecificEntropy.
-        /// </summary>
-        public static SpecificEntropy MinValue { get; } = new SpecificEntropy(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static SpecificEntropy Zero { get; } = new SpecificEntropy(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.BtuPerPoundFahrenheit"/>
-        /// </summary>
-        public double BtusPerPoundFahrenheit => As(SpecificEntropyUnit.BtuPerPoundFahrenheit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.CaloriePerGramKelvin"/>
-        /// </summary>
-        public double CaloriesPerGramKelvin => As(SpecificEntropyUnit.CaloriePerGramKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.JoulePerKilogramDegreeCelsius"/>
-        /// </summary>
-        public double JoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.JoulePerKilogramKelvin"/>
-        /// </summary>
-        public double JoulesPerKilogramKelvin => As(SpecificEntropyUnit.JoulePerKilogramKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.KilocaloriePerGramKelvin"/>
-        /// </summary>
-        public double KilocaloriesPerGramKelvin => As(SpecificEntropyUnit.KilocaloriePerGramKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius"/>
-        /// </summary>
-        public double KilojoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.KilojoulePerKilogramKelvin"/>
-        /// </summary>
-        public double KilojoulesPerKilogramKelvin => As(SpecificEntropyUnit.KilojoulePerKilogramKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius"/>
-        /// </summary>
-        public double MegajoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.MegajoulePerKilogramKelvin"/>
-        /// </summary>
-        public double MegajoulesPerKilogramKelvin => As(SpecificEntropyUnit.MegajoulePerKilogramKelvin);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.BtuPerPoundFahrenheit"/>.
-        /// </summary>
-        public static SpecificEntropy FromBtusPerPoundFahrenheit(double btusperpoundfahrenheit) => new SpecificEntropy(btusperpoundfahrenheit, SpecificEntropyUnit.BtuPerPoundFahrenheit);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.CaloriePerGramKelvin"/>.
-        /// </summary>
-        public static SpecificEntropy FromCaloriesPerGramKelvin(double caloriespergramkelvin) => new SpecificEntropy(caloriespergramkelvin, SpecificEntropyUnit.CaloriePerGramKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.JoulePerKilogramDegreeCelsius"/>.
-        /// </summary>
-        public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(double joulesperkilogramdegreecelsius) => new SpecificEntropy(joulesperkilogramdegreecelsius, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.JoulePerKilogramKelvin"/>.
-        /// </summary>
-        public static SpecificEntropy FromJoulesPerKilogramKelvin(double joulesperkilogramkelvin) => new SpecificEntropy(joulesperkilogramkelvin, SpecificEntropyUnit.JoulePerKilogramKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilocaloriePerGramKelvin"/>.
-        /// </summary>
-        public static SpecificEntropy FromKilocaloriesPerGramKelvin(double kilocaloriespergramkelvin) => new SpecificEntropy(kilocaloriespergramkelvin, SpecificEntropyUnit.KilocaloriePerGramKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius"/>.
-        /// </summary>
-        public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(double kilojoulesperkilogramdegreecelsius) => new SpecificEntropy(kilojoulesperkilogramdegreecelsius, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilojoulePerKilogramKelvin"/>.
-        /// </summary>
-        public static SpecificEntropy FromKilojoulesPerKilogramKelvin(double kilojoulesperkilogramkelvin) => new SpecificEntropy(kilojoulesperkilogramkelvin, SpecificEntropyUnit.KilojoulePerKilogramKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius"/>.
-        /// </summary>
-        public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(double megajoulesperkilogramdegreecelsius) => new SpecificEntropy(megajoulesperkilogramdegreecelsius, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.MegajoulePerKilogramKelvin"/>.
-        /// </summary>
-        public static SpecificEntropy FromMegajoulesPerKilogramKelvin(double megajoulesperkilogramkelvin) => new SpecificEntropy(megajoulesperkilogramkelvin, SpecificEntropyUnit.MegajoulePerKilogramKelvin);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpecificEntropyUnit" /> to <see cref="SpecificEntropy" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SpecificEntropy unit value.</returns>
-        public static SpecificEntropy From(double value, SpecificEntropyUnit fromUnit)
-        {
-            return new SpecificEntropy(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(SpecificEntropyUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this SpecificEntropy to another SpecificEntropy with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A SpecificEntropy with the specified unit.</returns>
-                public SpecificEntropy ToUnit(SpecificEntropyUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new SpecificEntropy(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        SpecificEntropyUnit.BtuPerPoundFahrenheit => _value * 4.1868e3,
-                        SpecificEntropyUnit.CaloriePerGramKelvin => _value * 4.184e3,
-                        SpecificEntropyUnit.JoulePerKilogramDegreeCelsius => _value,
-                        SpecificEntropyUnit.JoulePerKilogramKelvin => _value,
-                        SpecificEntropyUnit.KilocaloriePerGramKelvin => (_value * 4.184e3) * 1e3d,
-                        SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius => (_value) * 1e3d,
-                        SpecificEntropyUnit.KilojoulePerKilogramKelvin => (_value) * 1e3d,
-                        SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius => (_value) * 1e6d,
-                        SpecificEntropyUnit.MegajoulePerKilogramKelvin => (_value) * 1e6d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(SpecificEntropyUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        SpecificEntropyUnit.BtuPerPoundFahrenheit => baseUnitValue / 4.1868e3,
-                        SpecificEntropyUnit.CaloriePerGramKelvin => baseUnitValue / 4.184e3,
-                        SpecificEntropyUnit.JoulePerKilogramDegreeCelsius => baseUnitValue,
-                        SpecificEntropyUnit.JoulePerKilogramKelvin => baseUnitValue,
-                        SpecificEntropyUnit.KilocaloriePerGramKelvin => (baseUnitValue / 4.184e3) / 1e3d,
-                        SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius => (baseUnitValue) / 1e3d,
-                        SpecificEntropyUnit.KilojoulePerKilogramKelvin => (baseUnitValue) / 1e3d,
-                        SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius => (baseUnitValue) / 1e6d,
-                        SpecificEntropyUnit.MegajoulePerKilogramKelvin => (baseUnitValue) / 1e6d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
deleted file mode 100644
index 21ca83be63..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
+++ /dev/null
@@ -1,196 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     SFC is the fuel efficiency of an engine design with respect to thrust output
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Thrust-specific_fuel_consumption
-    /// </remarks>
-    public struct  SpecificFuelConsumption
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly SpecificFuelConsumptionUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public SpecificFuelConsumptionUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SpecificFuelConsumption(double value, SpecificFuelConsumptionUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of SpecificFuelConsumption, which is Second. All conversions go via this value.
-        /// </summary>
-        public static SpecificFuelConsumptionUnit BaseUnit { get; } = SpecificFuelConsumptionUnit.GramPerKilonewtonSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of SpecificFuelConsumption.
-        /// </summary>
-        public static SpecificFuelConsumption MaxValue { get; } = new SpecificFuelConsumption(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of SpecificFuelConsumption.
-        /// </summary>
-        public static SpecificFuelConsumption MinValue { get; } = new SpecificFuelConsumption(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static SpecificFuelConsumption Zero { get; } = new SpecificFuelConsumption(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.GramPerKilonewtonSecond"/>
-        /// </summary>
-        public double GramsPerKilonewtonSecond => As(SpecificFuelConsumptionUnit.GramPerKilonewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour"/>
-        /// </summary>
-        public double KilogramsPerKilogramForceHour => As(SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond"/>
-        /// </summary>
-        public double KilogramsPerKilonewtonSecond => As(SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour"/>
-        /// </summary>
-        public double PoundsMassPerPoundForceHour => As(SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.GramPerKilonewtonSecond"/>.
-        /// </summary>
-        public static SpecificFuelConsumption FromGramsPerKilonewtonSecond(double gramsperkilonewtonsecond) => new SpecificFuelConsumption(gramsperkilonewtonsecond, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour"/>.
-        /// </summary>
-        public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(double kilogramsperkilogramforcehour) => new SpecificFuelConsumption(kilogramsperkilogramforcehour, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond"/>.
-        /// </summary>
-        public static SpecificFuelConsumption FromKilogramsPerKilonewtonSecond(double kilogramsperkilonewtonsecond) => new SpecificFuelConsumption(kilogramsperkilonewtonsecond, SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour"/>.
-        /// </summary>
-        public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(double poundsmassperpoundforcehour) => new SpecificFuelConsumption(poundsmassperpoundforcehour, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpecificFuelConsumptionUnit" /> to <see cref="SpecificFuelConsumption" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SpecificFuelConsumption unit value.</returns>
-        public static SpecificFuelConsumption From(double value, SpecificFuelConsumptionUnit fromUnit)
-        {
-            return new SpecificFuelConsumption(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(SpecificFuelConsumptionUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this SpecificFuelConsumption to another SpecificFuelConsumption with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A SpecificFuelConsumption with the specified unit.</returns>
-                public SpecificFuelConsumption ToUnit(SpecificFuelConsumptionUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new SpecificFuelConsumption(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        SpecificFuelConsumptionUnit.GramPerKilonewtonSecond => _value,
-                        SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour => _value * 1000 / (9.80665e-3 * 3600),
-                        SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond => (_value) * 1e3d,
-                        SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour => _value * 1000 / (9.80665e-3 * 3600),
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(SpecificFuelConsumptionUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        SpecificFuelConsumptionUnit.GramPerKilonewtonSecond => baseUnitValue,
-                        SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour => baseUnitValue * 9.80665e-3 * 3600 / 1000,
-                        SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond => (baseUnitValue) / 1e3d,
-                        SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour => baseUnitValue * 9.80665e-3 * 3600 / 1000,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificVolume.g.cs
deleted file mode 100644
index 05c9f8554e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificVolume.g.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In thermodynamics, the specific volume of a substance is the ratio of the substance's volume to its mass. It is the reciprocal of density and an intrinsic property of matter as well.
-    /// </summary>
-    public struct  SpecificVolume
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly SpecificVolumeUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public SpecificVolumeUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SpecificVolume(double value, SpecificVolumeUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of SpecificVolume, which is Second. All conversions go via this value.
-        /// </summary>
-        public static SpecificVolumeUnit BaseUnit { get; } = SpecificVolumeUnit.CubicMeterPerKilogram;
-
-        /// <summary>
-        /// Represents the largest possible value of SpecificVolume.
-        /// </summary>
-        public static SpecificVolume MaxValue { get; } = new SpecificVolume(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of SpecificVolume.
-        /// </summary>
-        public static SpecificVolume MinValue { get; } = new SpecificVolume(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static SpecificVolume Zero { get; } = new SpecificVolume(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificVolumeUnit.CubicFootPerPound"/>
-        /// </summary>
-        public double CubicFeetPerPound => As(SpecificVolumeUnit.CubicFootPerPound);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificVolumeUnit.CubicMeterPerKilogram"/>
-        /// </summary>
-        public double CubicMetersPerKilogram => As(SpecificVolumeUnit.CubicMeterPerKilogram);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificVolumeUnit.MillicubicMeterPerKilogram"/>
-        /// </summary>
-        public double MillicubicMetersPerKilogram => As(SpecificVolumeUnit.MillicubicMeterPerKilogram);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.CubicFootPerPound"/>.
-        /// </summary>
-        public static SpecificVolume FromCubicFeetPerPound(double cubicfeetperpound) => new SpecificVolume(cubicfeetperpound, SpecificVolumeUnit.CubicFootPerPound);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.CubicMeterPerKilogram"/>.
-        /// </summary>
-        public static SpecificVolume FromCubicMetersPerKilogram(double cubicmetersperkilogram) => new SpecificVolume(cubicmetersperkilogram, SpecificVolumeUnit.CubicMeterPerKilogram);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.MillicubicMeterPerKilogram"/>.
-        /// </summary>
-        public static SpecificVolume FromMillicubicMetersPerKilogram(double millicubicmetersperkilogram) => new SpecificVolume(millicubicmetersperkilogram, SpecificVolumeUnit.MillicubicMeterPerKilogram);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpecificVolumeUnit" /> to <see cref="SpecificVolume" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SpecificVolume unit value.</returns>
-        public static SpecificVolume From(double value, SpecificVolumeUnit fromUnit)
-        {
-            return new SpecificVolume(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(SpecificVolumeUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this SpecificVolume to another SpecificVolume with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A SpecificVolume with the specified unit.</returns>
-                public SpecificVolume ToUnit(SpecificVolumeUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new SpecificVolume(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        SpecificVolumeUnit.CubicFootPerPound => _value * 0.028316846592 / 0.45359237,
-                        SpecificVolumeUnit.CubicMeterPerKilogram => _value,
-                        SpecificVolumeUnit.MillicubicMeterPerKilogram => (_value) * 1e-3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(SpecificVolumeUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        SpecificVolumeUnit.CubicFootPerPound => baseUnitValue * 0.45359237 / 0.028316846592,
-                        SpecificVolumeUnit.CubicMeterPerKilogram => baseUnitValue,
-                        SpecificVolumeUnit.MillicubicMeterPerKilogram => (baseUnitValue) / 1e-3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificWeight.g.cs
deleted file mode 100644
index 24c900aaee..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/SpecificWeight.g.cs
+++ /dev/null
@@ -1,352 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The SpecificWeight, or more precisely, the volumetric weight density, of a substance is its weight per unit volume.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Specific_weight
-    /// </remarks>
-    public struct  SpecificWeight
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly SpecificWeightUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public SpecificWeightUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SpecificWeight(double value, SpecificWeightUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of SpecificWeight, which is Second. All conversions go via this value.
-        /// </summary>
-        public static SpecificWeightUnit BaseUnit { get; } = SpecificWeightUnit.NewtonPerCubicMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of SpecificWeight.
-        /// </summary>
-        public static SpecificWeight MaxValue { get; } = new SpecificWeight(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of SpecificWeight.
-        /// </summary>
-        public static SpecificWeight MinValue { get; } = new SpecificWeight(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static SpecificWeight Zero { get; } = new SpecificWeight(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilogramForcePerCubicCentimeter"/>
-        /// </summary>
-        public double KilogramsForcePerCubicCentimeter => As(SpecificWeightUnit.KilogramForcePerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilogramForcePerCubicMeter"/>
-        /// </summary>
-        public double KilogramsForcePerCubicMeter => As(SpecificWeightUnit.KilogramForcePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilogramForcePerCubicMillimeter"/>
-        /// </summary>
-        public double KilogramsForcePerCubicMillimeter => As(SpecificWeightUnit.KilogramForcePerCubicMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilonewtonPerCubicCentimeter"/>
-        /// </summary>
-        public double KilonewtonsPerCubicCentimeter => As(SpecificWeightUnit.KilonewtonPerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilonewtonPerCubicMeter"/>
-        /// </summary>
-        public double KilonewtonsPerCubicMeter => As(SpecificWeightUnit.KilonewtonPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilonewtonPerCubicMillimeter"/>
-        /// </summary>
-        public double KilonewtonsPerCubicMillimeter => As(SpecificWeightUnit.KilonewtonPerCubicMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilopoundForcePerCubicFoot"/>
-        /// </summary>
-        public double KilopoundsForcePerCubicFoot => As(SpecificWeightUnit.KilopoundForcePerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilopoundForcePerCubicInch"/>
-        /// </summary>
-        public double KilopoundsForcePerCubicInch => As(SpecificWeightUnit.KilopoundForcePerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.MeganewtonPerCubicMeter"/>
-        /// </summary>
-        public double MeganewtonsPerCubicMeter => As(SpecificWeightUnit.MeganewtonPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.NewtonPerCubicCentimeter"/>
-        /// </summary>
-        public double NewtonsPerCubicCentimeter => As(SpecificWeightUnit.NewtonPerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.NewtonPerCubicMeter"/>
-        /// </summary>
-        public double NewtonsPerCubicMeter => As(SpecificWeightUnit.NewtonPerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.NewtonPerCubicMillimeter"/>
-        /// </summary>
-        public double NewtonsPerCubicMillimeter => As(SpecificWeightUnit.NewtonPerCubicMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.PoundForcePerCubicFoot"/>
-        /// </summary>
-        public double PoundsForcePerCubicFoot => As(SpecificWeightUnit.PoundForcePerCubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.PoundForcePerCubicInch"/>
-        /// </summary>
-        public double PoundsForcePerCubicInch => As(SpecificWeightUnit.PoundForcePerCubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.TonneForcePerCubicCentimeter"/>
-        /// </summary>
-        public double TonnesForcePerCubicCentimeter => As(SpecificWeightUnit.TonneForcePerCubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.TonneForcePerCubicMeter"/>
-        /// </summary>
-        public double TonnesForcePerCubicMeter => As(SpecificWeightUnit.TonneForcePerCubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.TonneForcePerCubicMillimeter"/>
-        /// </summary>
-        public double TonnesForcePerCubicMillimeter => As(SpecificWeightUnit.TonneForcePerCubicMillimeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicCentimeter"/>.
-        /// </summary>
-        public static SpecificWeight FromKilogramsForcePerCubicCentimeter(double kilogramsforcepercubiccentimeter) => new SpecificWeight(kilogramsforcepercubiccentimeter, SpecificWeightUnit.KilogramForcePerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicMeter"/>.
-        /// </summary>
-        public static SpecificWeight FromKilogramsForcePerCubicMeter(double kilogramsforcepercubicmeter) => new SpecificWeight(kilogramsforcepercubicmeter, SpecificWeightUnit.KilogramForcePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicMillimeter"/>.
-        /// </summary>
-        public static SpecificWeight FromKilogramsForcePerCubicMillimeter(double kilogramsforcepercubicmillimeter) => new SpecificWeight(kilogramsforcepercubicmillimeter, SpecificWeightUnit.KilogramForcePerCubicMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicCentimeter"/>.
-        /// </summary>
-        public static SpecificWeight FromKilonewtonsPerCubicCentimeter(double kilonewtonspercubiccentimeter) => new SpecificWeight(kilonewtonspercubiccentimeter, SpecificWeightUnit.KilonewtonPerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicMeter"/>.
-        /// </summary>
-        public static SpecificWeight FromKilonewtonsPerCubicMeter(double kilonewtonspercubicmeter) => new SpecificWeight(kilonewtonspercubicmeter, SpecificWeightUnit.KilonewtonPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicMillimeter"/>.
-        /// </summary>
-        public static SpecificWeight FromKilonewtonsPerCubicMillimeter(double kilonewtonspercubicmillimeter) => new SpecificWeight(kilonewtonspercubicmillimeter, SpecificWeightUnit.KilonewtonPerCubicMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilopoundForcePerCubicFoot"/>.
-        /// </summary>
-        public static SpecificWeight FromKilopoundsForcePerCubicFoot(double kilopoundsforcepercubicfoot) => new SpecificWeight(kilopoundsforcepercubicfoot, SpecificWeightUnit.KilopoundForcePerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilopoundForcePerCubicInch"/>.
-        /// </summary>
-        public static SpecificWeight FromKilopoundsForcePerCubicInch(double kilopoundsforcepercubicinch) => new SpecificWeight(kilopoundsforcepercubicinch, SpecificWeightUnit.KilopoundForcePerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.MeganewtonPerCubicMeter"/>.
-        /// </summary>
-        public static SpecificWeight FromMeganewtonsPerCubicMeter(double meganewtonspercubicmeter) => new SpecificWeight(meganewtonspercubicmeter, SpecificWeightUnit.MeganewtonPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicCentimeter"/>.
-        /// </summary>
-        public static SpecificWeight FromNewtonsPerCubicCentimeter(double newtonspercubiccentimeter) => new SpecificWeight(newtonspercubiccentimeter, SpecificWeightUnit.NewtonPerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicMeter"/>.
-        /// </summary>
-        public static SpecificWeight FromNewtonsPerCubicMeter(double newtonspercubicmeter) => new SpecificWeight(newtonspercubicmeter, SpecificWeightUnit.NewtonPerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicMillimeter"/>.
-        /// </summary>
-        public static SpecificWeight FromNewtonsPerCubicMillimeter(double newtonspercubicmillimeter) => new SpecificWeight(newtonspercubicmillimeter, SpecificWeightUnit.NewtonPerCubicMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.PoundForcePerCubicFoot"/>.
-        /// </summary>
-        public static SpecificWeight FromPoundsForcePerCubicFoot(double poundsforcepercubicfoot) => new SpecificWeight(poundsforcepercubicfoot, SpecificWeightUnit.PoundForcePerCubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.PoundForcePerCubicInch"/>.
-        /// </summary>
-        public static SpecificWeight FromPoundsForcePerCubicInch(double poundsforcepercubicinch) => new SpecificWeight(poundsforcepercubicinch, SpecificWeightUnit.PoundForcePerCubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicCentimeter"/>.
-        /// </summary>
-        public static SpecificWeight FromTonnesForcePerCubicCentimeter(double tonnesforcepercubiccentimeter) => new SpecificWeight(tonnesforcepercubiccentimeter, SpecificWeightUnit.TonneForcePerCubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicMeter"/>.
-        /// </summary>
-        public static SpecificWeight FromTonnesForcePerCubicMeter(double tonnesforcepercubicmeter) => new SpecificWeight(tonnesforcepercubicmeter, SpecificWeightUnit.TonneForcePerCubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicMillimeter"/>.
-        /// </summary>
-        public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforcepercubicmillimeter) => new SpecificWeight(tonnesforcepercubicmillimeter, SpecificWeightUnit.TonneForcePerCubicMillimeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpecificWeightUnit" /> to <see cref="SpecificWeight" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>SpecificWeight unit value.</returns>
-        public static SpecificWeight From(double value, SpecificWeightUnit fromUnit)
-        {
-            return new SpecificWeight(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(SpecificWeightUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this SpecificWeight to another SpecificWeight with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A SpecificWeight with the specified unit.</returns>
-                public SpecificWeight ToUnit(SpecificWeightUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new SpecificWeight(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        SpecificWeightUnit.KilogramForcePerCubicCentimeter => _value * 9.80665e6,
-                        SpecificWeightUnit.KilogramForcePerCubicMeter => _value * 9.80665,
-                        SpecificWeightUnit.KilogramForcePerCubicMillimeter => _value * 9.80665e9,
-                        SpecificWeightUnit.KilonewtonPerCubicCentimeter => (_value * 1000000) * 1e3d,
-                        SpecificWeightUnit.KilonewtonPerCubicMeter => (_value) * 1e3d,
-                        SpecificWeightUnit.KilonewtonPerCubicMillimeter => (_value * 1000000000) * 1e3d,
-                        SpecificWeightUnit.KilopoundForcePerCubicFoot => (_value * 4.4482216152605 / 0.028316846592) * 1e3d,
-                        SpecificWeightUnit.KilopoundForcePerCubicInch => (_value * 4.4482216152605 / 1.6387064e-5) * 1e3d,
-                        SpecificWeightUnit.MeganewtonPerCubicMeter => (_value) * 1e6d,
-                        SpecificWeightUnit.NewtonPerCubicCentimeter => _value * 1000000,
-                        SpecificWeightUnit.NewtonPerCubicMeter => _value,
-                        SpecificWeightUnit.NewtonPerCubicMillimeter => _value * 1000000000,
-                        SpecificWeightUnit.PoundForcePerCubicFoot => _value * 4.4482216152605 / 0.028316846592,
-                        SpecificWeightUnit.PoundForcePerCubicInch => _value * 4.4482216152605 / 1.6387064e-5,
-                        SpecificWeightUnit.TonneForcePerCubicCentimeter => _value * 9.80665e9,
-                        SpecificWeightUnit.TonneForcePerCubicMeter => _value * 9.80665e3,
-                        SpecificWeightUnit.TonneForcePerCubicMillimeter => _value * 9.80665e12,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(SpecificWeightUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        SpecificWeightUnit.KilogramForcePerCubicCentimeter => baseUnitValue / 9.80665e6,
-                        SpecificWeightUnit.KilogramForcePerCubicMeter => baseUnitValue / 9.80665,
-                        SpecificWeightUnit.KilogramForcePerCubicMillimeter => baseUnitValue / 9.80665e9,
-                        SpecificWeightUnit.KilonewtonPerCubicCentimeter => (baseUnitValue * 0.000001) / 1e3d,
-                        SpecificWeightUnit.KilonewtonPerCubicMeter => (baseUnitValue) / 1e3d,
-                        SpecificWeightUnit.KilonewtonPerCubicMillimeter => (baseUnitValue * 0.000000001) / 1e3d,
-                        SpecificWeightUnit.KilopoundForcePerCubicFoot => (baseUnitValue * 0.028316846592 / 4.4482216152605) / 1e3d,
-                        SpecificWeightUnit.KilopoundForcePerCubicInch => (baseUnitValue * 1.6387064e-5 / 4.4482216152605) / 1e3d,
-                        SpecificWeightUnit.MeganewtonPerCubicMeter => (baseUnitValue) / 1e6d,
-                        SpecificWeightUnit.NewtonPerCubicCentimeter => baseUnitValue * 0.000001,
-                        SpecificWeightUnit.NewtonPerCubicMeter => baseUnitValue,
-                        SpecificWeightUnit.NewtonPerCubicMillimeter => baseUnitValue * 0.000000001,
-                        SpecificWeightUnit.PoundForcePerCubicFoot => baseUnitValue * 0.028316846592 / 4.4482216152605,
-                        SpecificWeightUnit.PoundForcePerCubicInch => baseUnitValue * 1.6387064e-5 / 4.4482216152605,
-                        SpecificWeightUnit.TonneForcePerCubicCentimeter => baseUnitValue / 9.80665e9,
-                        SpecificWeightUnit.TonneForcePerCubicMeter => baseUnitValue / 9.80665e3,
-                        SpecificWeightUnit.TonneForcePerCubicMillimeter => baseUnitValue / 9.80665e12,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Speed.g.cs
deleted file mode 100644
index 2532a96562..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Speed.g.cs
+++ /dev/null
@@ -1,541 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In everyday use and in kinematics, the speed of an object is the magnitude of its velocity (the rate of change of its position); it is thus a scalar quantity.[1] The average speed of an object in an interval of time is the distance travelled by the object divided by the duration of the interval;[2] the instantaneous speed is the limit of the average speed as the duration of the time interval approaches zero.
-    /// </summary>
-    public struct  Speed
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly SpeedUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public SpeedUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Speed(double value, SpeedUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Speed, which is Second. All conversions go via this value.
-        /// </summary>
-        public static SpeedUnit BaseUnit { get; } = SpeedUnit.MeterPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of Speed.
-        /// </summary>
-        public static Speed MaxValue { get; } = new Speed(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Speed.
-        /// </summary>
-        public static Speed MinValue { get; } = new Speed(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Speed Zero { get; } = new Speed(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.CentimeterPerHour"/>
-        /// </summary>
-        public double CentimetersPerHour => As(SpeedUnit.CentimeterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.CentimeterPerMinute"/>
-        /// </summary>
-        public double CentimetersPerMinute => As(SpeedUnit.CentimeterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.CentimeterPerSecond"/>
-        /// </summary>
-        public double CentimetersPerSecond => As(SpeedUnit.CentimeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.DecimeterPerMinute"/>
-        /// </summary>
-        public double DecimetersPerMinute => As(SpeedUnit.DecimeterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.DecimeterPerSecond"/>
-        /// </summary>
-        public double DecimetersPerSecond => As(SpeedUnit.DecimeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.FootPerHour"/>
-        /// </summary>
-        public double FeetPerHour => As(SpeedUnit.FootPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.FootPerMinute"/>
-        /// </summary>
-        public double FeetPerMinute => As(SpeedUnit.FootPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.FootPerSecond"/>
-        /// </summary>
-        public double FeetPerSecond => As(SpeedUnit.FootPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.InchPerHour"/>
-        /// </summary>
-        public double InchesPerHour => As(SpeedUnit.InchPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.InchPerMinute"/>
-        /// </summary>
-        public double InchesPerMinute => As(SpeedUnit.InchPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.InchPerSecond"/>
-        /// </summary>
-        public double InchesPerSecond => As(SpeedUnit.InchPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.KilometerPerHour"/>
-        /// </summary>
-        public double KilometersPerHour => As(SpeedUnit.KilometerPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.KilometerPerMinute"/>
-        /// </summary>
-        public double KilometersPerMinute => As(SpeedUnit.KilometerPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.KilometerPerSecond"/>
-        /// </summary>
-        public double KilometersPerSecond => As(SpeedUnit.KilometerPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.Knot"/>
-        /// </summary>
-        public double Knots => As(SpeedUnit.Knot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.Mach"/>
-        /// </summary>
-        public double Mach => As(SpeedUnit.Mach);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MeterPerHour"/>
-        /// </summary>
-        public double MetersPerHour => As(SpeedUnit.MeterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MeterPerMinute"/>
-        /// </summary>
-        public double MetersPerMinute => As(SpeedUnit.MeterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MeterPerSecond"/>
-        /// </summary>
-        public double MetersPerSecond => As(SpeedUnit.MeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MicrometerPerMinute"/>
-        /// </summary>
-        public double MicrometersPerMinute => As(SpeedUnit.MicrometerPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MicrometerPerSecond"/>
-        /// </summary>
-        public double MicrometersPerSecond => As(SpeedUnit.MicrometerPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MilePerHour"/>
-        /// </summary>
-        public double MilesPerHour => As(SpeedUnit.MilePerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MillimeterPerHour"/>
-        /// </summary>
-        public double MillimetersPerHour => As(SpeedUnit.MillimeterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MillimeterPerMinute"/>
-        /// </summary>
-        public double MillimetersPerMinute => As(SpeedUnit.MillimeterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MillimeterPerSecond"/>
-        /// </summary>
-        public double MillimetersPerSecond => As(SpeedUnit.MillimeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.NanometerPerMinute"/>
-        /// </summary>
-        public double NanometersPerMinute => As(SpeedUnit.NanometerPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.NanometerPerSecond"/>
-        /// </summary>
-        public double NanometersPerSecond => As(SpeedUnit.NanometerPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.UsSurveyFootPerHour"/>
-        /// </summary>
-        public double UsSurveyFeetPerHour => As(SpeedUnit.UsSurveyFootPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.UsSurveyFootPerMinute"/>
-        /// </summary>
-        public double UsSurveyFeetPerMinute => As(SpeedUnit.UsSurveyFootPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.UsSurveyFootPerSecond"/>
-        /// </summary>
-        public double UsSurveyFeetPerSecond => As(SpeedUnit.UsSurveyFootPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.YardPerHour"/>
-        /// </summary>
-        public double YardsPerHour => As(SpeedUnit.YardPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.YardPerMinute"/>
-        /// </summary>
-        public double YardsPerMinute => As(SpeedUnit.YardPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.YardPerSecond"/>
-        /// </summary>
-        public double YardsPerSecond => As(SpeedUnit.YardPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerHour"/>.
-        /// </summary>
-        public static Speed FromCentimetersPerHour(double centimetersperhour) => new Speed(centimetersperhour, SpeedUnit.CentimeterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerMinute"/>.
-        /// </summary>
-        public static Speed FromCentimetersPerMinute(double centimetersperminute) => new Speed(centimetersperminute, SpeedUnit.CentimeterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerSecond"/>.
-        /// </summary>
-        public static Speed FromCentimetersPerSecond(double centimeterspersecond) => new Speed(centimeterspersecond, SpeedUnit.CentimeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.DecimeterPerMinute"/>.
-        /// </summary>
-        public static Speed FromDecimetersPerMinute(double decimetersperminute) => new Speed(decimetersperminute, SpeedUnit.DecimeterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.DecimeterPerSecond"/>.
-        /// </summary>
-        public static Speed FromDecimetersPerSecond(double decimeterspersecond) => new Speed(decimeterspersecond, SpeedUnit.DecimeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerHour"/>.
-        /// </summary>
-        public static Speed FromFeetPerHour(double feetperhour) => new Speed(feetperhour, SpeedUnit.FootPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerMinute"/>.
-        /// </summary>
-        public static Speed FromFeetPerMinute(double feetperminute) => new Speed(feetperminute, SpeedUnit.FootPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerSecond"/>.
-        /// </summary>
-        public static Speed FromFeetPerSecond(double feetpersecond) => new Speed(feetpersecond, SpeedUnit.FootPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerHour"/>.
-        /// </summary>
-        public static Speed FromInchesPerHour(double inchesperhour) => new Speed(inchesperhour, SpeedUnit.InchPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerMinute"/>.
-        /// </summary>
-        public static Speed FromInchesPerMinute(double inchesperminute) => new Speed(inchesperminute, SpeedUnit.InchPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerSecond"/>.
-        /// </summary>
-        public static Speed FromInchesPerSecond(double inchespersecond) => new Speed(inchespersecond, SpeedUnit.InchPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerHour"/>.
-        /// </summary>
-        public static Speed FromKilometersPerHour(double kilometersperhour) => new Speed(kilometersperhour, SpeedUnit.KilometerPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerMinute"/>.
-        /// </summary>
-        public static Speed FromKilometersPerMinute(double kilometersperminute) => new Speed(kilometersperminute, SpeedUnit.KilometerPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerSecond"/>.
-        /// </summary>
-        public static Speed FromKilometersPerSecond(double kilometerspersecond) => new Speed(kilometerspersecond, SpeedUnit.KilometerPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.Knot"/>.
-        /// </summary>
-        public static Speed FromKnots(double knots) => new Speed(knots, SpeedUnit.Knot);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.Mach"/>.
-        /// </summary>
-        public static Speed FromMach(double mach) => new Speed(mach, SpeedUnit.Mach);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerHour"/>.
-        /// </summary>
-        public static Speed FromMetersPerHour(double metersperhour) => new Speed(metersperhour, SpeedUnit.MeterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerMinute"/>.
-        /// </summary>
-        public static Speed FromMetersPerMinute(double metersperminute) => new Speed(metersperminute, SpeedUnit.MeterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerSecond"/>.
-        /// </summary>
-        public static Speed FromMetersPerSecond(double meterspersecond) => new Speed(meterspersecond, SpeedUnit.MeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MicrometerPerMinute"/>.
-        /// </summary>
-        public static Speed FromMicrometersPerMinute(double micrometersperminute) => new Speed(micrometersperminute, SpeedUnit.MicrometerPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MicrometerPerSecond"/>.
-        /// </summary>
-        public static Speed FromMicrometersPerSecond(double micrometerspersecond) => new Speed(micrometerspersecond, SpeedUnit.MicrometerPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MilePerHour"/>.
-        /// </summary>
-        public static Speed FromMilesPerHour(double milesperhour) => new Speed(milesperhour, SpeedUnit.MilePerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerHour"/>.
-        /// </summary>
-        public static Speed FromMillimetersPerHour(double millimetersperhour) => new Speed(millimetersperhour, SpeedUnit.MillimeterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerMinute"/>.
-        /// </summary>
-        public static Speed FromMillimetersPerMinute(double millimetersperminute) => new Speed(millimetersperminute, SpeedUnit.MillimeterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerSecond"/>.
-        /// </summary>
-        public static Speed FromMillimetersPerSecond(double millimeterspersecond) => new Speed(millimeterspersecond, SpeedUnit.MillimeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.NanometerPerMinute"/>.
-        /// </summary>
-        public static Speed FromNanometersPerMinute(double nanometersperminute) => new Speed(nanometersperminute, SpeedUnit.NanometerPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.NanometerPerSecond"/>.
-        /// </summary>
-        public static Speed FromNanometersPerSecond(double nanometerspersecond) => new Speed(nanometerspersecond, SpeedUnit.NanometerPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerHour"/>.
-        /// </summary>
-        public static Speed FromUsSurveyFeetPerHour(double ussurveyfeetperhour) => new Speed(ussurveyfeetperhour, SpeedUnit.UsSurveyFootPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerMinute"/>.
-        /// </summary>
-        public static Speed FromUsSurveyFeetPerMinute(double ussurveyfeetperminute) => new Speed(ussurveyfeetperminute, SpeedUnit.UsSurveyFootPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerSecond"/>.
-        /// </summary>
-        public static Speed FromUsSurveyFeetPerSecond(double ussurveyfeetpersecond) => new Speed(ussurveyfeetpersecond, SpeedUnit.UsSurveyFootPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerHour"/>.
-        /// </summary>
-        public static Speed FromYardsPerHour(double yardsperhour) => new Speed(yardsperhour, SpeedUnit.YardPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerMinute"/>.
-        /// </summary>
-        public static Speed FromYardsPerMinute(double yardsperminute) => new Speed(yardsperminute, SpeedUnit.YardPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerSecond"/>.
-        /// </summary>
-        public static Speed FromYardsPerSecond(double yardspersecond) => new Speed(yardspersecond, SpeedUnit.YardPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="SpeedUnit" /> to <see cref="Speed" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Speed unit value.</returns>
-        public static Speed From(double value, SpeedUnit fromUnit)
-        {
-            return new Speed(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(SpeedUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Speed to another Speed with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Speed with the specified unit.</returns>
-                public Speed ToUnit(SpeedUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Speed(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        SpeedUnit.CentimeterPerHour => (_value / 3600) * 1e-2d,
-                        SpeedUnit.CentimeterPerMinute => (_value / 60) * 1e-2d,
-                        SpeedUnit.CentimeterPerSecond => (_value) * 1e-2d,
-                        SpeedUnit.DecimeterPerMinute => (_value / 60) * 1e-1d,
-                        SpeedUnit.DecimeterPerSecond => (_value) * 1e-1d,
-                        SpeedUnit.FootPerHour => _value * 0.3048 / 3600,
-                        SpeedUnit.FootPerMinute => _value * 0.3048 / 60,
-                        SpeedUnit.FootPerSecond => _value * 0.3048,
-                        SpeedUnit.InchPerHour => (_value / 3600) * 2.54e-2,
-                        SpeedUnit.InchPerMinute => (_value / 60) * 2.54e-2,
-                        SpeedUnit.InchPerSecond => _value * 2.54e-2,
-                        SpeedUnit.KilometerPerHour => (_value / 3600) * 1e3d,
-                        SpeedUnit.KilometerPerMinute => (_value / 60) * 1e3d,
-                        SpeedUnit.KilometerPerSecond => (_value) * 1e3d,
-                        SpeedUnit.Knot => _value * (1852.0 / 3600.0),
-                        SpeedUnit.Mach => _value * 340.29,
-                        SpeedUnit.MeterPerHour => _value / 3600,
-                        SpeedUnit.MeterPerMinute => _value / 60,
-                        SpeedUnit.MeterPerSecond => _value,
-                        SpeedUnit.MicrometerPerMinute => (_value / 60) * 1e-6d,
-                        SpeedUnit.MicrometerPerSecond => (_value) * 1e-6d,
-                        SpeedUnit.MilePerHour => _value * 0.44704,
-                        SpeedUnit.MillimeterPerHour => (_value / 3600) * 1e-3d,
-                        SpeedUnit.MillimeterPerMinute => (_value / 60) * 1e-3d,
-                        SpeedUnit.MillimeterPerSecond => (_value) * 1e-3d,
-                        SpeedUnit.NanometerPerMinute => (_value / 60) * 1e-9d,
-                        SpeedUnit.NanometerPerSecond => (_value) * 1e-9d,
-                        SpeedUnit.UsSurveyFootPerHour => (_value * 1200 / 3937) / 3600,
-                        SpeedUnit.UsSurveyFootPerMinute => (_value * 1200 / 3937) / 60,
-                        SpeedUnit.UsSurveyFootPerSecond => _value * 1200 / 3937,
-                        SpeedUnit.YardPerHour => _value * 0.9144 / 3600,
-                        SpeedUnit.YardPerMinute => _value * 0.9144 / 60,
-                        SpeedUnit.YardPerSecond => _value * 0.9144,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(SpeedUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        SpeedUnit.CentimeterPerHour => (baseUnitValue * 3600) / 1e-2d,
-                        SpeedUnit.CentimeterPerMinute => (baseUnitValue * 60) / 1e-2d,
-                        SpeedUnit.CentimeterPerSecond => (baseUnitValue) / 1e-2d,
-                        SpeedUnit.DecimeterPerMinute => (baseUnitValue * 60) / 1e-1d,
-                        SpeedUnit.DecimeterPerSecond => (baseUnitValue) / 1e-1d,
-                        SpeedUnit.FootPerHour => baseUnitValue / 0.3048 * 3600,
-                        SpeedUnit.FootPerMinute => baseUnitValue / 0.3048 * 60,
-                        SpeedUnit.FootPerSecond => baseUnitValue / 0.3048,
-                        SpeedUnit.InchPerHour => (baseUnitValue / 2.54e-2) * 3600,
-                        SpeedUnit.InchPerMinute => (baseUnitValue / 2.54e-2) * 60,
-                        SpeedUnit.InchPerSecond => baseUnitValue / 2.54e-2,
-                        SpeedUnit.KilometerPerHour => (baseUnitValue * 3600) / 1e3d,
-                        SpeedUnit.KilometerPerMinute => (baseUnitValue * 60) / 1e3d,
-                        SpeedUnit.KilometerPerSecond => (baseUnitValue) / 1e3d,
-                        SpeedUnit.Knot => baseUnitValue / (1852.0 / 3600.0),
-                        SpeedUnit.Mach => baseUnitValue / 340.29,
-                        SpeedUnit.MeterPerHour => baseUnitValue * 3600,
-                        SpeedUnit.MeterPerMinute => baseUnitValue * 60,
-                        SpeedUnit.MeterPerSecond => baseUnitValue,
-                        SpeedUnit.MicrometerPerMinute => (baseUnitValue * 60) / 1e-6d,
-                        SpeedUnit.MicrometerPerSecond => (baseUnitValue) / 1e-6d,
-                        SpeedUnit.MilePerHour => baseUnitValue / 0.44704,
-                        SpeedUnit.MillimeterPerHour => (baseUnitValue * 3600) / 1e-3d,
-                        SpeedUnit.MillimeterPerMinute => (baseUnitValue * 60) / 1e-3d,
-                        SpeedUnit.MillimeterPerSecond => (baseUnitValue) / 1e-3d,
-                        SpeedUnit.NanometerPerMinute => (baseUnitValue * 60) / 1e-9d,
-                        SpeedUnit.NanometerPerSecond => (baseUnitValue) / 1e-9d,
-                        SpeedUnit.UsSurveyFootPerHour => (baseUnitValue * 3937 / 1200) * 3600,
-                        SpeedUnit.UsSurveyFootPerMinute => (baseUnitValue * 3937 / 1200) * 60,
-                        SpeedUnit.UsSurveyFootPerSecond => baseUnitValue * 3937 / 1200,
-                        SpeedUnit.YardPerHour => baseUnitValue / 0.9144 * 3600,
-                        SpeedUnit.YardPerMinute => baseUnitValue / 0.9144 * 60,
-                        SpeedUnit.YardPerSecond => baseUnitValue / 0.9144,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
deleted file mode 100644
index 7b87faa2d6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
+++ /dev/null
@@ -1,253 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The molar flow rate of a gas corrected to standardized conditions of temperature and pressure thus representing a fixed number of moles of gas regardless of composition and actual flow conditions.
-    /// </summary>
-    public struct  StandardVolumeFlow
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly StandardVolumeFlowUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public StandardVolumeFlowUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public StandardVolumeFlow(double value, StandardVolumeFlowUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of StandardVolumeFlow, which is Second. All conversions go via this value.
-        /// </summary>
-        public static StandardVolumeFlowUnit BaseUnit { get; } = StandardVolumeFlowUnit.StandardCubicMeterPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of StandardVolumeFlow.
-        /// </summary>
-        public static StandardVolumeFlow MaxValue { get; } = new StandardVolumeFlow(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of StandardVolumeFlow.
-        /// </summary>
-        public static StandardVolumeFlow MinValue { get; } = new StandardVolumeFlow(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static StandardVolumeFlow Zero { get; } = new StandardVolumeFlow(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute"/>
-        /// </summary>
-        public double StandardCubicCentimetersPerMinute => As(StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicFootPerHour"/>
-        /// </summary>
-        public double StandardCubicFeetPerHour => As(StandardVolumeFlowUnit.StandardCubicFootPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicFootPerMinute"/>
-        /// </summary>
-        public double StandardCubicFeetPerMinute => As(StandardVolumeFlowUnit.StandardCubicFootPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicFootPerSecond"/>
-        /// </summary>
-        public double StandardCubicFeetPerSecond => As(StandardVolumeFlowUnit.StandardCubicFootPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerDay"/>
-        /// </summary>
-        public double StandardCubicMetersPerDay => As(StandardVolumeFlowUnit.StandardCubicMeterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerHour"/>
-        /// </summary>
-        public double StandardCubicMetersPerHour => As(StandardVolumeFlowUnit.StandardCubicMeterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerMinute"/>
-        /// </summary>
-        public double StandardCubicMetersPerMinute => As(StandardVolumeFlowUnit.StandardCubicMeterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerSecond"/>
-        /// </summary>
-        public double StandardCubicMetersPerSecond => As(StandardVolumeFlowUnit.StandardCubicMeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardLiterPerMinute"/>
-        /// </summary>
-        public double StandardLitersPerMinute => As(StandardVolumeFlowUnit.StandardLiterPerMinute);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute"/>.
-        /// </summary>
-        public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(double standardcubiccentimetersperminute) => new StandardVolumeFlow(standardcubiccentimetersperminute, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerHour"/>.
-        /// </summary>
-        public static StandardVolumeFlow FromStandardCubicFeetPerHour(double standardcubicfeetperhour) => new StandardVolumeFlow(standardcubicfeetperhour, StandardVolumeFlowUnit.StandardCubicFootPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerMinute"/>.
-        /// </summary>
-        public static StandardVolumeFlow FromStandardCubicFeetPerMinute(double standardcubicfeetperminute) => new StandardVolumeFlow(standardcubicfeetperminute, StandardVolumeFlowUnit.StandardCubicFootPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerSecond"/>.
-        /// </summary>
-        public static StandardVolumeFlow FromStandardCubicFeetPerSecond(double standardcubicfeetpersecond) => new StandardVolumeFlow(standardcubicfeetpersecond, StandardVolumeFlowUnit.StandardCubicFootPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerDay"/>.
-        /// </summary>
-        public static StandardVolumeFlow FromStandardCubicMetersPerDay(double standardcubicmetersperday) => new StandardVolumeFlow(standardcubicmetersperday, StandardVolumeFlowUnit.StandardCubicMeterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerHour"/>.
-        /// </summary>
-        public static StandardVolumeFlow FromStandardCubicMetersPerHour(double standardcubicmetersperhour) => new StandardVolumeFlow(standardcubicmetersperhour, StandardVolumeFlowUnit.StandardCubicMeterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerMinute"/>.
-        /// </summary>
-        public static StandardVolumeFlow FromStandardCubicMetersPerMinute(double standardcubicmetersperminute) => new StandardVolumeFlow(standardcubicmetersperminute, StandardVolumeFlowUnit.StandardCubicMeterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerSecond"/>.
-        /// </summary>
-        public static StandardVolumeFlow FromStandardCubicMetersPerSecond(double standardcubicmeterspersecond) => new StandardVolumeFlow(standardcubicmeterspersecond, StandardVolumeFlowUnit.StandardCubicMeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardLiterPerMinute"/>.
-        /// </summary>
-        public static StandardVolumeFlow FromStandardLitersPerMinute(double standardlitersperminute) => new StandardVolumeFlow(standardlitersperminute, StandardVolumeFlowUnit.StandardLiterPerMinute);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="StandardVolumeFlowUnit" /> to <see cref="StandardVolumeFlow" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>StandardVolumeFlow unit value.</returns>
-        public static StandardVolumeFlow From(double value, StandardVolumeFlowUnit fromUnit)
-        {
-            return new StandardVolumeFlow(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(StandardVolumeFlowUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this StandardVolumeFlow to another StandardVolumeFlow with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A StandardVolumeFlow with the specified unit.</returns>
-                public StandardVolumeFlow ToUnit(StandardVolumeFlowUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new StandardVolumeFlow(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute => _value / 6e7,
-                        StandardVolumeFlowUnit.StandardCubicFootPerHour => _value * 0.028316846592 / 3600,
-                        StandardVolumeFlowUnit.StandardCubicFootPerMinute => _value * 0.028316846592 / 60,
-                        StandardVolumeFlowUnit.StandardCubicFootPerSecond => _value * 0.028316846592,
-                        StandardVolumeFlowUnit.StandardCubicMeterPerDay => _value / 86400,
-                        StandardVolumeFlowUnit.StandardCubicMeterPerHour => _value / 3600,
-                        StandardVolumeFlowUnit.StandardCubicMeterPerMinute => _value / 60,
-                        StandardVolumeFlowUnit.StandardCubicMeterPerSecond => _value,
-                        StandardVolumeFlowUnit.StandardLiterPerMinute => _value / 60000,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(StandardVolumeFlowUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute => baseUnitValue * 6e7,
-                        StandardVolumeFlowUnit.StandardCubicFootPerHour => baseUnitValue / (0.028316846592 / 3600),
-                        StandardVolumeFlowUnit.StandardCubicFootPerMinute => baseUnitValue / (0.028316846592 / 60),
-                        StandardVolumeFlowUnit.StandardCubicFootPerSecond => baseUnitValue / 0.028316846592,
-                        StandardVolumeFlowUnit.StandardCubicMeterPerDay => baseUnitValue * 86400,
-                        StandardVolumeFlowUnit.StandardCubicMeterPerHour => baseUnitValue * 3600,
-                        StandardVolumeFlowUnit.StandardCubicMeterPerMinute => baseUnitValue * 60,
-                        StandardVolumeFlowUnit.StandardCubicMeterPerSecond => baseUnitValue,
-                        StandardVolumeFlowUnit.StandardLiterPerMinute => baseUnitValue * 60000,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Temperature.g.cs
deleted file mode 100644
index cc5e7103d4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Temperature.g.cs
+++ /dev/null
@@ -1,265 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     A temperature is a numerical measure of hot or cold. Its measurement is by detection of heat radiation or particle velocity or kinetic energy, or by the bulk behavior of a thermometric material. It may be calibrated in any of various temperature scales, Celsius, Fahrenheit, Kelvin, etc. The fundamental physical definition of temperature is provided by thermodynamics.
-    /// </summary>
-    public struct  Temperature
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly TemperatureUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public TemperatureUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Temperature(double value, TemperatureUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Temperature, which is Second. All conversions go via this value.
-        /// </summary>
-        public static TemperatureUnit BaseUnit { get; } = TemperatureUnit.Kelvin;
-
-        /// <summary>
-        /// Represents the largest possible value of Temperature.
-        /// </summary>
-        public static Temperature MaxValue { get; } = new Temperature(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Temperature.
-        /// </summary>
-        public static Temperature MinValue { get; } = new Temperature(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Temperature Zero { get; } = new Temperature(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeCelsius"/>
-        /// </summary>
-        public double DegreesCelsius => As(TemperatureUnit.DegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeDelisle"/>
-        /// </summary>
-        public double DegreesDelisle => As(TemperatureUnit.DegreeDelisle);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeFahrenheit"/>
-        /// </summary>
-        public double DegreesFahrenheit => As(TemperatureUnit.DegreeFahrenheit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeNewton"/>
-        /// </summary>
-        public double DegreesNewton => As(TemperatureUnit.DegreeNewton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeRankine"/>
-        /// </summary>
-        public double DegreesRankine => As(TemperatureUnit.DegreeRankine);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeReaumur"/>
-        /// </summary>
-        public double DegreesReaumur => As(TemperatureUnit.DegreeReaumur);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeRoemer"/>
-        /// </summary>
-        public double DegreesRoemer => As(TemperatureUnit.DegreeRoemer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.Kelvin"/>
-        /// </summary>
-        public double Kelvins => As(TemperatureUnit.Kelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.MillidegreeCelsius"/>
-        /// </summary>
-        public double MillidegreesCelsius => As(TemperatureUnit.MillidegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.SolarTemperature"/>
-        /// </summary>
-        public double SolarTemperatures => As(TemperatureUnit.SolarTemperature);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeCelsius"/>.
-        /// </summary>
-        public static Temperature FromDegreesCelsius(double degreescelsius) => new Temperature(degreescelsius, TemperatureUnit.DegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeDelisle"/>.
-        /// </summary>
-        public static Temperature FromDegreesDelisle(double degreesdelisle) => new Temperature(degreesdelisle, TemperatureUnit.DegreeDelisle);
-
-        /// <summary>
-        ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeFahrenheit"/>.
-        /// </summary>
-        public static Temperature FromDegreesFahrenheit(double degreesfahrenheit) => new Temperature(degreesfahrenheit, TemperatureUnit.DegreeFahrenheit);
-
-        /// <summary>
-        ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeNewton"/>.
-        /// </summary>
-        public static Temperature FromDegreesNewton(double degreesnewton) => new Temperature(degreesnewton, TemperatureUnit.DegreeNewton);
-
-        /// <summary>
-        ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeRankine"/>.
-        /// </summary>
-        public static Temperature FromDegreesRankine(double degreesrankine) => new Temperature(degreesrankine, TemperatureUnit.DegreeRankine);
-
-        /// <summary>
-        ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeReaumur"/>.
-        /// </summary>
-        public static Temperature FromDegreesReaumur(double degreesreaumur) => new Temperature(degreesreaumur, TemperatureUnit.DegreeReaumur);
-
-        /// <summary>
-        ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeRoemer"/>.
-        /// </summary>
-        public static Temperature FromDegreesRoemer(double degreesroemer) => new Temperature(degreesroemer, TemperatureUnit.DegreeRoemer);
-
-        /// <summary>
-        ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.Kelvin"/>.
-        /// </summary>
-        public static Temperature FromKelvins(double kelvins) => new Temperature(kelvins, TemperatureUnit.Kelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.MillidegreeCelsius"/>.
-        /// </summary>
-        public static Temperature FromMillidegreesCelsius(double millidegreescelsius) => new Temperature(millidegreescelsius, TemperatureUnit.MillidegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.SolarTemperature"/>.
-        /// </summary>
-        public static Temperature FromSolarTemperatures(double solartemperatures) => new Temperature(solartemperatures, TemperatureUnit.SolarTemperature);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TemperatureUnit" /> to <see cref="Temperature" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Temperature unit value.</returns>
-        public static Temperature From(double value, TemperatureUnit fromUnit)
-        {
-            return new Temperature(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(TemperatureUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Temperature to another Temperature with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Temperature with the specified unit.</returns>
-                public Temperature ToUnit(TemperatureUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Temperature(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        TemperatureUnit.DegreeCelsius => _value + 273.15,
-                        TemperatureUnit.DegreeDelisle => _value * -2 / 3 + 373.15,
-                        TemperatureUnit.DegreeFahrenheit => _value * 5 / 9 + 459.67 * 5 / 9,
-                        TemperatureUnit.DegreeNewton => _value * 100 / 33 + 273.15,
-                        TemperatureUnit.DegreeRankine => _value * 5 / 9,
-                        TemperatureUnit.DegreeReaumur => _value * 5 / 4 + 273.15,
-                        TemperatureUnit.DegreeRoemer => _value * 40 / 21 + 273.15 - 7.5 * 40d / 21,
-                        TemperatureUnit.Kelvin => _value,
-                        TemperatureUnit.MillidegreeCelsius => _value / 1000 + 273.15,
-                        TemperatureUnit.SolarTemperature => _value * 5778,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(TemperatureUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        TemperatureUnit.DegreeCelsius => baseUnitValue - 273.15,
-                        TemperatureUnit.DegreeDelisle => (baseUnitValue - 373.15) * -3 / 2,
-                        TemperatureUnit.DegreeFahrenheit => (baseUnitValue - 459.67 * 5 / 9) * 9 / 5,
-                        TemperatureUnit.DegreeNewton => (baseUnitValue - 273.15) * 33 / 100,
-                        TemperatureUnit.DegreeRankine => baseUnitValue * 9 / 5,
-                        TemperatureUnit.DegreeReaumur => (baseUnitValue - 273.15) * 4 / 5,
-                        TemperatureUnit.DegreeRoemer => (baseUnitValue - (273.15 - 7.5 * 40d / 21)) * 21 / 40,
-                        TemperatureUnit.Kelvin => baseUnitValue,
-                        TemperatureUnit.MillidegreeCelsius => (baseUnitValue - 273.15) * 1000,
-                        TemperatureUnit.SolarTemperature => baseUnitValue / 5778,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
deleted file mode 100644
index c2604b1c46..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
+++ /dev/null
@@ -1,349 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Temperature change rate is the ratio of the temperature change to the time during which the change occurred (value of temperature changes per unit time).
-    /// </summary>
-    public struct  TemperatureChangeRate
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly TemperatureChangeRateUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public TemperatureChangeRateUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public TemperatureChangeRate(double value, TemperatureChangeRateUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of TemperatureChangeRate, which is Second. All conversions go via this value.
-        /// </summary>
-        public static TemperatureChangeRateUnit BaseUnit { get; } = TemperatureChangeRateUnit.DegreeCelsiusPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of TemperatureChangeRate.
-        /// </summary>
-        public static TemperatureChangeRate MaxValue { get; } = new TemperatureChangeRate(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of TemperatureChangeRate.
-        /// </summary>
-        public static TemperatureChangeRate MinValue { get; } = new TemperatureChangeRate(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static TemperatureChangeRate Zero { get; } = new TemperatureChangeRate(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond"/>
-        /// </summary>
-        public double CentidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond"/>
-        /// </summary>
-        public double DecadegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond"/>
-        /// </summary>
-        public double DecidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerHour"/>
-        /// </summary>
-        public double DegreesCelsiusPerHour => As(TemperatureChangeRateUnit.DegreeCelsiusPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerMinute"/>
-        /// </summary>
-        public double DegreesCelsiusPerMinute => As(TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerSecond"/>
-        /// </summary>
-        public double DegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerHour"/>
-        /// </summary>
-        public double DegreesFahrenheitPerHour => As(TemperatureChangeRateUnit.DegreeFahrenheitPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerMinute"/>
-        /// </summary>
-        public double DegreesFahrenheitPerMinute => As(TemperatureChangeRateUnit.DegreeFahrenheitPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerSecond"/>
-        /// </summary>
-        public double DegreesFahrenheitPerSecond => As(TemperatureChangeRateUnit.DegreeFahrenheitPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeKelvinPerHour"/>
-        /// </summary>
-        public double DegreesKelvinPerHour => As(TemperatureChangeRateUnit.DegreeKelvinPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeKelvinPerMinute"/>
-        /// </summary>
-        public double DegreesKelvinPerMinute => As(TemperatureChangeRateUnit.DegreeKelvinPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeKelvinPerSecond"/>
-        /// </summary>
-        public double DegreesKelvinPerSecond => As(TemperatureChangeRateUnit.DegreeKelvinPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond"/>
-        /// </summary>
-        public double HectodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond"/>
-        /// </summary>
-        public double KilodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond"/>
-        /// </summary>
-        public double MicrodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond"/>
-        /// </summary>
-        public double MillidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond"/>
-        /// </summary>
-        public double NanodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(double centidegreescelsiuspersecond) => new TemperatureChangeRate(centidegreescelsiuspersecond, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(double decadegreescelsiuspersecond) => new TemperatureChangeRate(decadegreescelsiuspersecond, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(double decidegreescelsiuspersecond) => new TemperatureChangeRate(decidegreescelsiuspersecond, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerHour"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDegreesCelsiusPerHour(double degreescelsiusperhour) => new TemperatureChangeRate(degreescelsiusperhour, TemperatureChangeRateUnit.DegreeCelsiusPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerMinute"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDegreesCelsiusPerMinute(double degreescelsiusperminute) => new TemperatureChangeRate(degreescelsiusperminute, TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDegreesCelsiusPerSecond(double degreescelsiuspersecond) => new TemperatureChangeRate(degreescelsiuspersecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerHour"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDegreesFahrenheitPerHour(double degreesfahrenheitperhour) => new TemperatureChangeRate(degreesfahrenheitperhour, TemperatureChangeRateUnit.DegreeFahrenheitPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerMinute"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDegreesFahrenheitPerMinute(double degreesfahrenheitperminute) => new TemperatureChangeRate(degreesfahrenheitperminute, TemperatureChangeRateUnit.DegreeFahrenheitPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDegreesFahrenheitPerSecond(double degreesfahrenheitpersecond) => new TemperatureChangeRate(degreesfahrenheitpersecond, TemperatureChangeRateUnit.DegreeFahrenheitPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeKelvinPerHour"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDegreesKelvinPerHour(double degreeskelvinperhour) => new TemperatureChangeRate(degreeskelvinperhour, TemperatureChangeRateUnit.DegreeKelvinPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeKelvinPerMinute"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDegreesKelvinPerMinute(double degreeskelvinperminute) => new TemperatureChangeRate(degreeskelvinperminute, TemperatureChangeRateUnit.DegreeKelvinPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeKelvinPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromDegreesKelvinPerSecond(double degreeskelvinpersecond) => new TemperatureChangeRate(degreeskelvinpersecond, TemperatureChangeRateUnit.DegreeKelvinPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(double hectodegreescelsiuspersecond) => new TemperatureChangeRate(hectodegreescelsiuspersecond, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(double kilodegreescelsiuspersecond) => new TemperatureChangeRate(kilodegreescelsiuspersecond, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(double microdegreescelsiuspersecond) => new TemperatureChangeRate(microdegreescelsiuspersecond, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(double millidegreescelsiuspersecond) => new TemperatureChangeRate(millidegreescelsiuspersecond, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond"/>.
-        /// </summary>
-        public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanodegreescelsiuspersecond) => new TemperatureChangeRate(nanodegreescelsiuspersecond, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TemperatureChangeRateUnit" /> to <see cref="TemperatureChangeRate" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>TemperatureChangeRate unit value.</returns>
-        public static TemperatureChangeRate From(double value, TemperatureChangeRateUnit fromUnit)
-        {
-            return new TemperatureChangeRate(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(TemperatureChangeRateUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this TemperatureChangeRate to another TemperatureChangeRate with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A TemperatureChangeRate with the specified unit.</returns>
-                public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new TemperatureChangeRate(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond => (_value) * 1e-2d,
-                        TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond => (_value) * 1e1d,
-                        TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond => (_value) * 1e-1d,
-                        TemperatureChangeRateUnit.DegreeCelsiusPerHour => _value / 3600,
-                        TemperatureChangeRateUnit.DegreeCelsiusPerMinute => _value / 60,
-                        TemperatureChangeRateUnit.DegreeCelsiusPerSecond => _value,
-                        TemperatureChangeRateUnit.DegreeFahrenheitPerHour => _value * 5 / 9 / 3600,
-                        TemperatureChangeRateUnit.DegreeFahrenheitPerMinute => _value * 5 / 9 / 60,
-                        TemperatureChangeRateUnit.DegreeFahrenheitPerSecond => _value * 5 / 9,
-                        TemperatureChangeRateUnit.DegreeKelvinPerHour => _value / 3600,
-                        TemperatureChangeRateUnit.DegreeKelvinPerMinute => _value / 60,
-                        TemperatureChangeRateUnit.DegreeKelvinPerSecond => _value,
-                        TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond => (_value) * 1e2d,
-                        TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond => (_value) * 1e3d,
-                        TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond => (_value) * 1e-6d,
-                        TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond => (_value) * 1e-3d,
-                        TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond => (_value) * 1e-9d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(TemperatureChangeRateUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond => (baseUnitValue) / 1e-2d,
-                        TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond => (baseUnitValue) / 1e1d,
-                        TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond => (baseUnitValue) / 1e-1d,
-                        TemperatureChangeRateUnit.DegreeCelsiusPerHour => baseUnitValue * 3600,
-                        TemperatureChangeRateUnit.DegreeCelsiusPerMinute => baseUnitValue * 60,
-                        TemperatureChangeRateUnit.DegreeCelsiusPerSecond => baseUnitValue,
-                        TemperatureChangeRateUnit.DegreeFahrenheitPerHour => baseUnitValue * 9 / 5 * 3600,
-                        TemperatureChangeRateUnit.DegreeFahrenheitPerMinute => baseUnitValue * 9 / 5 * 60,
-                        TemperatureChangeRateUnit.DegreeFahrenheitPerSecond => baseUnitValue * 9 / 5,
-                        TemperatureChangeRateUnit.DegreeKelvinPerHour => baseUnitValue * 3600,
-                        TemperatureChangeRateUnit.DegreeKelvinPerMinute => baseUnitValue * 60,
-                        TemperatureChangeRateUnit.DegreeKelvinPerSecond => baseUnitValue,
-                        TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond => (baseUnitValue) / 1e2d,
-                        TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond => (baseUnitValue) / 1e3d,
-                        TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond => (baseUnitValue) / 1e-6d,
-                        TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond => (baseUnitValue) / 1e-3d,
-                        TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond => (baseUnitValue) / 1e-9d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/TemperatureDelta.g.cs
deleted file mode 100644
index d167f59008..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/TemperatureDelta.g.cs
+++ /dev/null
@@ -1,253 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Difference between two temperatures. The conversions are different than for Temperature.
-    /// </summary>
-    public struct  TemperatureDelta
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly TemperatureDeltaUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public TemperatureDeltaUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public TemperatureDelta(double value, TemperatureDeltaUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of TemperatureDelta, which is Second. All conversions go via this value.
-        /// </summary>
-        public static TemperatureDeltaUnit BaseUnit { get; } = TemperatureDeltaUnit.Kelvin;
-
-        /// <summary>
-        /// Represents the largest possible value of TemperatureDelta.
-        /// </summary>
-        public static TemperatureDelta MaxValue { get; } = new TemperatureDelta(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of TemperatureDelta.
-        /// </summary>
-        public static TemperatureDelta MinValue { get; } = new TemperatureDelta(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static TemperatureDelta Zero { get; } = new TemperatureDelta(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeCelsius"/>
-        /// </summary>
-        public double DegreesCelsius => As(TemperatureDeltaUnit.DegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeDelisle"/>
-        /// </summary>
-        public double DegreesDelisle => As(TemperatureDeltaUnit.DegreeDelisle);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeFahrenheit"/>
-        /// </summary>
-        public double DegreesFahrenheit => As(TemperatureDeltaUnit.DegreeFahrenheit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeNewton"/>
-        /// </summary>
-        public double DegreesNewton => As(TemperatureDeltaUnit.DegreeNewton);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeRankine"/>
-        /// </summary>
-        public double DegreesRankine => As(TemperatureDeltaUnit.DegreeRankine);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeReaumur"/>
-        /// </summary>
-        public double DegreesReaumur => As(TemperatureDeltaUnit.DegreeReaumur);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeRoemer"/>
-        /// </summary>
-        public double DegreesRoemer => As(TemperatureDeltaUnit.DegreeRoemer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.Kelvin"/>
-        /// </summary>
-        public double Kelvins => As(TemperatureDeltaUnit.Kelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.MillidegreeCelsius"/>
-        /// </summary>
-        public double MillidegreesCelsius => As(TemperatureDeltaUnit.MillidegreeCelsius);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeCelsius"/>.
-        /// </summary>
-        public static TemperatureDelta FromDegreesCelsius(double degreescelsius) => new TemperatureDelta(degreescelsius, TemperatureDeltaUnit.DegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeDelisle"/>.
-        /// </summary>
-        public static TemperatureDelta FromDegreesDelisle(double degreesdelisle) => new TemperatureDelta(degreesdelisle, TemperatureDeltaUnit.DegreeDelisle);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeFahrenheit"/>.
-        /// </summary>
-        public static TemperatureDelta FromDegreesFahrenheit(double degreesfahrenheit) => new TemperatureDelta(degreesfahrenheit, TemperatureDeltaUnit.DegreeFahrenheit);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeNewton"/>.
-        /// </summary>
-        public static TemperatureDelta FromDegreesNewton(double degreesnewton) => new TemperatureDelta(degreesnewton, TemperatureDeltaUnit.DegreeNewton);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeRankine"/>.
-        /// </summary>
-        public static TemperatureDelta FromDegreesRankine(double degreesrankine) => new TemperatureDelta(degreesrankine, TemperatureDeltaUnit.DegreeRankine);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeReaumur"/>.
-        /// </summary>
-        public static TemperatureDelta FromDegreesReaumur(double degreesreaumur) => new TemperatureDelta(degreesreaumur, TemperatureDeltaUnit.DegreeReaumur);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeRoemer"/>.
-        /// </summary>
-        public static TemperatureDelta FromDegreesRoemer(double degreesroemer) => new TemperatureDelta(degreesroemer, TemperatureDeltaUnit.DegreeRoemer);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.Kelvin"/>.
-        /// </summary>
-        public static TemperatureDelta FromKelvins(double kelvins) => new TemperatureDelta(kelvins, TemperatureDeltaUnit.Kelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.MillidegreeCelsius"/>.
-        /// </summary>
-        public static TemperatureDelta FromMillidegreesCelsius(double millidegreescelsius) => new TemperatureDelta(millidegreescelsius, TemperatureDeltaUnit.MillidegreeCelsius);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TemperatureDeltaUnit" /> to <see cref="TemperatureDelta" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>TemperatureDelta unit value.</returns>
-        public static TemperatureDelta From(double value, TemperatureDeltaUnit fromUnit)
-        {
-            return new TemperatureDelta(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(TemperatureDeltaUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this TemperatureDelta to another TemperatureDelta with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A TemperatureDelta with the specified unit.</returns>
-                public TemperatureDelta ToUnit(TemperatureDeltaUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new TemperatureDelta(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        TemperatureDeltaUnit.DegreeCelsius => _value,
-                        TemperatureDeltaUnit.DegreeDelisle => _value * -2 / 3,
-                        TemperatureDeltaUnit.DegreeFahrenheit => _value * 5 / 9,
-                        TemperatureDeltaUnit.DegreeNewton => _value * 100 / 33,
-                        TemperatureDeltaUnit.DegreeRankine => _value * 5 / 9,
-                        TemperatureDeltaUnit.DegreeReaumur => _value * 5 / 4,
-                        TemperatureDeltaUnit.DegreeRoemer => _value * 40 / 21,
-                        TemperatureDeltaUnit.Kelvin => _value,
-                        TemperatureDeltaUnit.MillidegreeCelsius => (_value) * 1e-3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(TemperatureDeltaUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        TemperatureDeltaUnit.DegreeCelsius => baseUnitValue,
-                        TemperatureDeltaUnit.DegreeDelisle => baseUnitValue * -3 / 2,
-                        TemperatureDeltaUnit.DegreeFahrenheit => baseUnitValue * 9 / 5,
-                        TemperatureDeltaUnit.DegreeNewton => baseUnitValue * 33 / 100,
-                        TemperatureDeltaUnit.DegreeRankine => baseUnitValue * 9 / 5,
-                        TemperatureDeltaUnit.DegreeReaumur => baseUnitValue * 4 / 5,
-                        TemperatureDeltaUnit.DegreeRoemer => baseUnitValue * 21 / 40,
-                        TemperatureDeltaUnit.Kelvin => baseUnitValue,
-                        TemperatureDeltaUnit.MillidegreeCelsius => (baseUnitValue) / 1e-3d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/TemperatureGradient.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/TemperatureGradient.g.cs
deleted file mode 100644
index 9af36c2657..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/TemperatureGradient.g.cs
+++ /dev/null
@@ -1,193 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     
-    /// </summary>
-    public struct  TemperatureGradient
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly TemperatureGradientUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public TemperatureGradientUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public TemperatureGradient(double value, TemperatureGradientUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of TemperatureGradient, which is Second. All conversions go via this value.
-        /// </summary>
-        public static TemperatureGradientUnit BaseUnit { get; } = TemperatureGradientUnit.KelvinPerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of TemperatureGradient.
-        /// </summary>
-        public static TemperatureGradient MaxValue { get; } = new TemperatureGradient(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of TemperatureGradient.
-        /// </summary>
-        public static TemperatureGradient MinValue { get; } = new TemperatureGradient(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static TemperatureGradient Zero { get; } = new TemperatureGradient(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureGradientUnit.DegreeCelsiusPerKilometer"/>
-        /// </summary>
-        public double DegreesCelsiusPerKilometer => As(TemperatureGradientUnit.DegreeCelsiusPerKilometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureGradientUnit.DegreeCelsiusPerMeter"/>
-        /// </summary>
-        public double DegreesCelsiusPerMeter => As(TemperatureGradientUnit.DegreeCelsiusPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureGradientUnit.DegreeFahrenheitPerFoot"/>
-        /// </summary>
-        public double DegreesFahrenheitPerFoot => As(TemperatureGradientUnit.DegreeFahrenheitPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureGradientUnit.KelvinPerMeter"/>
-        /// </summary>
-        public double KelvinsPerMeter => As(TemperatureGradientUnit.KelvinPerMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeCelsiusPerKilometer"/>.
-        /// </summary>
-        public static TemperatureGradient FromDegreesCelsiusPerKilometer(double degreescelsiusperkilometer) => new TemperatureGradient(degreescelsiusperkilometer, TemperatureGradientUnit.DegreeCelsiusPerKilometer);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeCelsiusPerMeter"/>.
-        /// </summary>
-        public static TemperatureGradient FromDegreesCelsiusPerMeter(double degreescelsiuspermeter) => new TemperatureGradient(degreescelsiuspermeter, TemperatureGradientUnit.DegreeCelsiusPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeFahrenheitPerFoot"/>.
-        /// </summary>
-        public static TemperatureGradient FromDegreesFahrenheitPerFoot(double degreesfahrenheitperfoot) => new TemperatureGradient(degreesfahrenheitperfoot, TemperatureGradientUnit.DegreeFahrenheitPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.KelvinPerMeter"/>.
-        /// </summary>
-        public static TemperatureGradient FromKelvinsPerMeter(double kelvinspermeter) => new TemperatureGradient(kelvinspermeter, TemperatureGradientUnit.KelvinPerMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TemperatureGradientUnit" /> to <see cref="TemperatureGradient" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>TemperatureGradient unit value.</returns>
-        public static TemperatureGradient From(double value, TemperatureGradientUnit fromUnit)
-        {
-            return new TemperatureGradient(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(TemperatureGradientUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this TemperatureGradient to another TemperatureGradient with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A TemperatureGradient with the specified unit.</returns>
-                public TemperatureGradient ToUnit(TemperatureGradientUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new TemperatureGradient(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        TemperatureGradientUnit.DegreeCelsiusPerKilometer => _value / 1e3,
-                        TemperatureGradientUnit.DegreeCelsiusPerMeter => _value,
-                        TemperatureGradientUnit.DegreeFahrenheitPerFoot => (_value / 0.3048) * 5 / 9,
-                        TemperatureGradientUnit.KelvinPerMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(TemperatureGradientUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        TemperatureGradientUnit.DegreeCelsiusPerKilometer => baseUnitValue * 1e3,
-                        TemperatureGradientUnit.DegreeCelsiusPerMeter => baseUnitValue,
-                        TemperatureGradientUnit.DegreeFahrenheitPerFoot => (baseUnitValue * 0.3048) * 9 / 5,
-                        TemperatureGradientUnit.KelvinPerMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ThermalConductivity.g.cs
deleted file mode 100644
index 8e5e367335..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ThermalConductivity.g.cs
+++ /dev/null
@@ -1,172 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Thermal conductivity is the property of a material to conduct heat.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Thermal_Conductivity
-    /// </remarks>
-    public struct  ThermalConductivity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ThermalConductivityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ThermalConductivityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ThermalConductivity(double value, ThermalConductivityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ThermalConductivity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ThermalConductivityUnit BaseUnit { get; } = ThermalConductivityUnit.WattPerMeterKelvin;
-
-        /// <summary>
-        /// Represents the largest possible value of ThermalConductivity.
-        /// </summary>
-        public static ThermalConductivity MaxValue { get; } = new ThermalConductivity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ThermalConductivity.
-        /// </summary>
-        public static ThermalConductivity MinValue { get; } = new ThermalConductivity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ThermalConductivity Zero { get; } = new ThermalConductivity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalConductivityUnit.BtuPerHourFootFahrenheit"/>
-        /// </summary>
-        public double BtusPerHourFootFahrenheit => As(ThermalConductivityUnit.BtuPerHourFootFahrenheit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalConductivityUnit.WattPerMeterKelvin"/>
-        /// </summary>
-        public double WattsPerMeterKelvin => As(ThermalConductivityUnit.WattPerMeterKelvin);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalConductivity"/> from <see cref="ThermalConductivityUnit.BtuPerHourFootFahrenheit"/>.
-        /// </summary>
-        public static ThermalConductivity FromBtusPerHourFootFahrenheit(double btusperhourfootfahrenheit) => new ThermalConductivity(btusperhourfootfahrenheit, ThermalConductivityUnit.BtuPerHourFootFahrenheit);
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalConductivity"/> from <see cref="ThermalConductivityUnit.WattPerMeterKelvin"/>.
-        /// </summary>
-        public static ThermalConductivity FromWattsPerMeterKelvin(double wattspermeterkelvin) => new ThermalConductivity(wattspermeterkelvin, ThermalConductivityUnit.WattPerMeterKelvin);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ThermalConductivityUnit" /> to <see cref="ThermalConductivity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ThermalConductivity unit value.</returns>
-        public static ThermalConductivity From(double value, ThermalConductivityUnit fromUnit)
-        {
-            return new ThermalConductivity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ThermalConductivityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ThermalConductivity to another ThermalConductivity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ThermalConductivity with the specified unit.</returns>
-                public ThermalConductivity ToUnit(ThermalConductivityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ThermalConductivity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ThermalConductivityUnit.BtuPerHourFootFahrenheit => _value * ((1055.05585262 / (0.3048 * 3600)) * 1.8),
-                        ThermalConductivityUnit.WattPerMeterKelvin => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ThermalConductivityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ThermalConductivityUnit.BtuPerHourFootFahrenheit => baseUnitValue / ((1055.05585262 / (0.3048 * 3600)) * 1.8),
-                        ThermalConductivityUnit.WattPerMeterKelvin => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ThermalInsulance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ThermalInsulance.g.cs
deleted file mode 100644
index 90ca81b96f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ThermalInsulance.g.cs
+++ /dev/null
@@ -1,229 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Thermal insulance (R-value) is a measure of a material's resistance to the heat current. It quantifies how effectively a material can resist the transfer of heat through conduction, convection, and radiation. It has the units square metre kelvins per watt (m2⋅K/W) in SI units or square foot degree Fahrenheit–hours per British thermal unit (ft2⋅°F⋅h/Btu) in imperial units. The higher the thermal insulance, the better a material insulates against heat transfer. It is commonly used in construction to assess the insulation properties of materials such as walls, roofs, and insulation products.
-    /// </summary>
-    public struct  ThermalInsulance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ThermalInsulanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ThermalInsulanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ThermalInsulance(double value, ThermalInsulanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ThermalInsulance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ThermalInsulanceUnit BaseUnit { get; } = ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt;
-
-        /// <summary>
-        /// Represents the largest possible value of ThermalInsulance.
-        /// </summary>
-        public static ThermalInsulance MaxValue { get; } = new ThermalInsulance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ThermalInsulance.
-        /// </summary>
-        public static ThermalInsulance MinValue { get; } = new ThermalInsulance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ThermalInsulance Zero { get; } = new ThermalInsulance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu"/>
-        /// </summary>
-        public double HourSquareFeetDegreesFahrenheitPerBtu => As(ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie"/>
-        /// </summary>
-        public double SquareCentimeterHourDegreesCelsiusPerKilocalorie => As(ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt"/>
-        /// </summary>
-        public double SquareCentimeterKelvinsPerWatt => As(ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt"/>
-        /// </summary>
-        public double SquareMeterDegreesCelsiusPerWatt => As(ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt"/>
-        /// </summary>
-        public double SquareMeterKelvinsPerKilowatt => As(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMeterKelvinPerWatt"/>
-        /// </summary>
-        public double SquareMeterKelvinsPerWatt => As(ThermalInsulanceUnit.SquareMeterKelvinPerWatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt"/>
-        /// </summary>
-        public double SquareMillimeterKelvinsPerWatt => As(ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu"/>.
-        /// </summary>
-        public static ThermalInsulance FromHourSquareFeetDegreesFahrenheitPerBtu(double hoursquarefeetdegreesfahrenheitperbtu) => new ThermalInsulance(hoursquarefeetdegreesfahrenheitperbtu, ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie"/>.
-        /// </summary>
-        public static ThermalInsulance FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double squarecentimeterhourdegreescelsiusperkilocalorie) => new ThermalInsulance(squarecentimeterhourdegreescelsiusperkilocalorie, ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt"/>.
-        /// </summary>
-        public static ThermalInsulance FromSquareCentimeterKelvinsPerWatt(double squarecentimeterkelvinsperwatt) => new ThermalInsulance(squarecentimeterkelvinsperwatt, ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt);
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt"/>.
-        /// </summary>
-        public static ThermalInsulance FromSquareMeterDegreesCelsiusPerWatt(double squaremeterdegreescelsiusperwatt) => new ThermalInsulance(squaremeterdegreescelsiusperwatt, ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt);
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt"/>.
-        /// </summary>
-        public static ThermalInsulance FromSquareMeterKelvinsPerKilowatt(double squaremeterkelvinsperkilowatt) => new ThermalInsulance(squaremeterkelvinsperkilowatt, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt);
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareMeterKelvinPerWatt"/>.
-        /// </summary>
-        public static ThermalInsulance FromSquareMeterKelvinsPerWatt(double squaremeterkelvinsperwatt) => new ThermalInsulance(squaremeterkelvinsperwatt, ThermalInsulanceUnit.SquareMeterKelvinPerWatt);
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt"/>.
-        /// </summary>
-        public static ThermalInsulance FromSquareMillimeterKelvinsPerWatt(double squaremillimeterkelvinsperwatt) => new ThermalInsulance(squaremillimeterkelvinsperwatt, ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ThermalInsulanceUnit" /> to <see cref="ThermalInsulance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ThermalInsulance unit value.</returns>
-        public static ThermalInsulance From(double value, ThermalInsulanceUnit fromUnit)
-        {
-            return new ThermalInsulance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ThermalInsulanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ThermalInsulance to another ThermalInsulance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ThermalInsulance with the specified unit.</returns>
-                public ThermalInsulance ToUnit(ThermalInsulanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ThermalInsulance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu => _value * (1000 * 0.3048 * 0.3048 * 3600) / (1055.05585262 * 1.8),
-                        ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie => _value * (0.0001 * 3600) / 4.184,
-                        ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt => _value * 0.1,
-                        ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt => _value * 1000.0,
-                        ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt => _value,
-                        ThermalInsulanceUnit.SquareMeterKelvinPerWatt => _value * 1000,
-                        ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt => _value * 0.001,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ThermalInsulanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu => baseUnitValue * (1055.05585262 * 1.8) / (1000 * 0.3048 * 0.3048 * 3600),
-                        ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie => baseUnitValue * 4.184 / (0.0001 * 3600),
-                        ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt => baseUnitValue / 0.1,
-                        ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt => baseUnitValue / 1000.0,
-                        ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt => baseUnitValue,
-                        ThermalInsulanceUnit.SquareMeterKelvinPerWatt => baseUnitValue / 1000,
-                        ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt => baseUnitValue / 0.001,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ThermalResistance.g.cs
deleted file mode 100644
index 017f74e807..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ThermalResistance.g.cs
+++ /dev/null
@@ -1,169 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Thermal resistance (R) measures the opposition to the heat current in a material or system. It is measured in units of kelvins per watt (K/W) and indicates how much temperature difference (in kelvins) is required to transfer a unit of heat current (in watts) through the material or object. It is essential to optimize the building insulation, evaluate the efficiency of electronic devices, and enhance the performance of heat sinks in various applications.
-    /// </summary>
-    public struct  ThermalResistance
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly ThermalResistanceUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public ThermalResistanceUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ThermalResistance(double value, ThermalResistanceUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of ThermalResistance, which is Second. All conversions go via this value.
-        /// </summary>
-        public static ThermalResistanceUnit BaseUnit { get; } = ThermalResistanceUnit.KelvinPerWatt;
-
-        /// <summary>
-        /// Represents the largest possible value of ThermalResistance.
-        /// </summary>
-        public static ThermalResistance MaxValue { get; } = new ThermalResistance(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of ThermalResistance.
-        /// </summary>
-        public static ThermalResistance MinValue { get; } = new ThermalResistance(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static ThermalResistance Zero { get; } = new ThermalResistance(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalResistanceUnit.DegreeCelsiusPerWatt"/>
-        /// </summary>
-        public double DegreesCelsiusPerWatt => As(ThermalResistanceUnit.DegreeCelsiusPerWatt);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalResistanceUnit.KelvinPerWatt"/>
-        /// </summary>
-        public double KelvinsPerWatt => As(ThermalResistanceUnit.KelvinPerWatt);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.DegreeCelsiusPerWatt"/>.
-        /// </summary>
-        public static ThermalResistance FromDegreesCelsiusPerWatt(double degreescelsiusperwatt) => new ThermalResistance(degreescelsiusperwatt, ThermalResistanceUnit.DegreeCelsiusPerWatt);
-
-        /// <summary>
-        ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.KelvinPerWatt"/>.
-        /// </summary>
-        public static ThermalResistance FromKelvinsPerWatt(double kelvinsperwatt) => new ThermalResistance(kelvinsperwatt, ThermalResistanceUnit.KelvinPerWatt);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="ThermalResistanceUnit" /> to <see cref="ThermalResistance" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>ThermalResistance unit value.</returns>
-        public static ThermalResistance From(double value, ThermalResistanceUnit fromUnit)
-        {
-            return new ThermalResistance(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(ThermalResistanceUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this ThermalResistance to another ThermalResistance with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A ThermalResistance with the specified unit.</returns>
-                public ThermalResistance ToUnit(ThermalResistanceUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new ThermalResistance(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        ThermalResistanceUnit.DegreeCelsiusPerWatt => _value,
-                        ThermalResistanceUnit.KelvinPerWatt => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(ThermalResistanceUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        ThermalResistanceUnit.DegreeCelsiusPerWatt => baseUnitValue,
-                        ThermalResistanceUnit.KelvinPerWatt => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Torque.g.cs
deleted file mode 100644
index 07631ceb61..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Torque.g.cs
+++ /dev/null
@@ -1,445 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Torque, moment or moment of force (see the terminology below), is the tendency of a force to rotate an object about an axis,[1] fulcrum, or pivot. Just as a force is a push or a pull, a torque can be thought of as a twist to an object. Mathematically, torque is defined as the cross product of the lever-arm distance and force, which tends to produce rotation. Loosely speaking, torque is a measure of the turning force on an object such as a bolt or a flywheel. For example, pushing or pulling the handle of a wrench connected to a nut or bolt produces a torque (turning force) that loosens or tightens the nut or bolt.
-    /// </summary>
-    public struct  Torque
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly TorqueUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public TorqueUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Torque(double value, TorqueUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Torque, which is Second. All conversions go via this value.
-        /// </summary>
-        public static TorqueUnit BaseUnit { get; } = TorqueUnit.NewtonMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Torque.
-        /// </summary>
-        public static Torque MaxValue { get; } = new Torque(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Torque.
-        /// </summary>
-        public static Torque MinValue { get; } = new Torque(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Torque Zero { get; } = new Torque(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.GramForceCentimeter"/>
-        /// </summary>
-        public double GramForceCentimeters => As(TorqueUnit.GramForceCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.GramForceMeter"/>
-        /// </summary>
-        public double GramForceMeters => As(TorqueUnit.GramForceMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.GramForceMillimeter"/>
-        /// </summary>
-        public double GramForceMillimeters => As(TorqueUnit.GramForceMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilogramForceCentimeter"/>
-        /// </summary>
-        public double KilogramForceCentimeters => As(TorqueUnit.KilogramForceCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilogramForceMeter"/>
-        /// </summary>
-        public double KilogramForceMeters => As(TorqueUnit.KilogramForceMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilogramForceMillimeter"/>
-        /// </summary>
-        public double KilogramForceMillimeters => As(TorqueUnit.KilogramForceMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilonewtonCentimeter"/>
-        /// </summary>
-        public double KilonewtonCentimeters => As(TorqueUnit.KilonewtonCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilonewtonMeter"/>
-        /// </summary>
-        public double KilonewtonMeters => As(TorqueUnit.KilonewtonMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilonewtonMillimeter"/>
-        /// </summary>
-        public double KilonewtonMillimeters => As(TorqueUnit.KilonewtonMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilopoundForceFoot"/>
-        /// </summary>
-        public double KilopoundForceFeet => As(TorqueUnit.KilopoundForceFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilopoundForceInch"/>
-        /// </summary>
-        public double KilopoundForceInches => As(TorqueUnit.KilopoundForceInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.MeganewtonCentimeter"/>
-        /// </summary>
-        public double MeganewtonCentimeters => As(TorqueUnit.MeganewtonCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.MeganewtonMeter"/>
-        /// </summary>
-        public double MeganewtonMeters => As(TorqueUnit.MeganewtonMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.MeganewtonMillimeter"/>
-        /// </summary>
-        public double MeganewtonMillimeters => As(TorqueUnit.MeganewtonMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.MegapoundForceFoot"/>
-        /// </summary>
-        public double MegapoundForceFeet => As(TorqueUnit.MegapoundForceFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.MegapoundForceInch"/>
-        /// </summary>
-        public double MegapoundForceInches => As(TorqueUnit.MegapoundForceInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.NewtonCentimeter"/>
-        /// </summary>
-        public double NewtonCentimeters => As(TorqueUnit.NewtonCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.NewtonMeter"/>
-        /// </summary>
-        public double NewtonMeters => As(TorqueUnit.NewtonMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.NewtonMillimeter"/>
-        /// </summary>
-        public double NewtonMillimeters => As(TorqueUnit.NewtonMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.PoundalFoot"/>
-        /// </summary>
-        public double PoundalFeet => As(TorqueUnit.PoundalFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.PoundForceFoot"/>
-        /// </summary>
-        public double PoundForceFeet => As(TorqueUnit.PoundForceFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.PoundForceInch"/>
-        /// </summary>
-        public double PoundForceInches => As(TorqueUnit.PoundForceInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.TonneForceCentimeter"/>
-        /// </summary>
-        public double TonneForceCentimeters => As(TorqueUnit.TonneForceCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.TonneForceMeter"/>
-        /// </summary>
-        public double TonneForceMeters => As(TorqueUnit.TonneForceMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.TonneForceMillimeter"/>
-        /// </summary>
-        public double TonneForceMillimeters => As(TorqueUnit.TonneForceMillimeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceCentimeter"/>.
-        /// </summary>
-        public static Torque FromGramForceCentimeters(double gramforcecentimeters) => new Torque(gramforcecentimeters, TorqueUnit.GramForceCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceMeter"/>.
-        /// </summary>
-        public static Torque FromGramForceMeters(double gramforcemeters) => new Torque(gramforcemeters, TorqueUnit.GramForceMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceMillimeter"/>.
-        /// </summary>
-        public static Torque FromGramForceMillimeters(double gramforcemillimeters) => new Torque(gramforcemillimeters, TorqueUnit.GramForceMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceCentimeter"/>.
-        /// </summary>
-        public static Torque FromKilogramForceCentimeters(double kilogramforcecentimeters) => new Torque(kilogramforcecentimeters, TorqueUnit.KilogramForceCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceMeter"/>.
-        /// </summary>
-        public static Torque FromKilogramForceMeters(double kilogramforcemeters) => new Torque(kilogramforcemeters, TorqueUnit.KilogramForceMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceMillimeter"/>.
-        /// </summary>
-        public static Torque FromKilogramForceMillimeters(double kilogramforcemillimeters) => new Torque(kilogramforcemillimeters, TorqueUnit.KilogramForceMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonCentimeter"/>.
-        /// </summary>
-        public static Torque FromKilonewtonCentimeters(double kilonewtoncentimeters) => new Torque(kilonewtoncentimeters, TorqueUnit.KilonewtonCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonMeter"/>.
-        /// </summary>
-        public static Torque FromKilonewtonMeters(double kilonewtonmeters) => new Torque(kilonewtonmeters, TorqueUnit.KilonewtonMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonMillimeter"/>.
-        /// </summary>
-        public static Torque FromKilonewtonMillimeters(double kilonewtonmillimeters) => new Torque(kilonewtonmillimeters, TorqueUnit.KilonewtonMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilopoundForceFoot"/>.
-        /// </summary>
-        public static Torque FromKilopoundForceFeet(double kilopoundforcefeet) => new Torque(kilopoundforcefeet, TorqueUnit.KilopoundForceFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilopoundForceInch"/>.
-        /// </summary>
-        public static Torque FromKilopoundForceInches(double kilopoundforceinches) => new Torque(kilopoundforceinches, TorqueUnit.KilopoundForceInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonCentimeter"/>.
-        /// </summary>
-        public static Torque FromMeganewtonCentimeters(double meganewtoncentimeters) => new Torque(meganewtoncentimeters, TorqueUnit.MeganewtonCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonMeter"/>.
-        /// </summary>
-        public static Torque FromMeganewtonMeters(double meganewtonmeters) => new Torque(meganewtonmeters, TorqueUnit.MeganewtonMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonMillimeter"/>.
-        /// </summary>
-        public static Torque FromMeganewtonMillimeters(double meganewtonmillimeters) => new Torque(meganewtonmillimeters, TorqueUnit.MeganewtonMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MegapoundForceFoot"/>.
-        /// </summary>
-        public static Torque FromMegapoundForceFeet(double megapoundforcefeet) => new Torque(megapoundforcefeet, TorqueUnit.MegapoundForceFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MegapoundForceInch"/>.
-        /// </summary>
-        public static Torque FromMegapoundForceInches(double megapoundforceinches) => new Torque(megapoundforceinches, TorqueUnit.MegapoundForceInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonCentimeter"/>.
-        /// </summary>
-        public static Torque FromNewtonCentimeters(double newtoncentimeters) => new Torque(newtoncentimeters, TorqueUnit.NewtonCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonMeter"/>.
-        /// </summary>
-        public static Torque FromNewtonMeters(double newtonmeters) => new Torque(newtonmeters, TorqueUnit.NewtonMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonMillimeter"/>.
-        /// </summary>
-        public static Torque FromNewtonMillimeters(double newtonmillimeters) => new Torque(newtonmillimeters, TorqueUnit.NewtonMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundalFoot"/>.
-        /// </summary>
-        public static Torque FromPoundalFeet(double poundalfeet) => new Torque(poundalfeet, TorqueUnit.PoundalFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundForceFoot"/>.
-        /// </summary>
-        public static Torque FromPoundForceFeet(double poundforcefeet) => new Torque(poundforcefeet, TorqueUnit.PoundForceFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundForceInch"/>.
-        /// </summary>
-        public static Torque FromPoundForceInches(double poundforceinches) => new Torque(poundforceinches, TorqueUnit.PoundForceInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceCentimeter"/>.
-        /// </summary>
-        public static Torque FromTonneForceCentimeters(double tonneforcecentimeters) => new Torque(tonneforcecentimeters, TorqueUnit.TonneForceCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceMeter"/>.
-        /// </summary>
-        public static Torque FromTonneForceMeters(double tonneforcemeters) => new Torque(tonneforcemeters, TorqueUnit.TonneForceMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceMillimeter"/>.
-        /// </summary>
-        public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) => new Torque(tonneforcemillimeters, TorqueUnit.TonneForceMillimeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TorqueUnit" /> to <see cref="Torque" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Torque unit value.</returns>
-        public static Torque From(double value, TorqueUnit fromUnit)
-        {
-            return new Torque(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(TorqueUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Torque to another Torque with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Torque with the specified unit.</returns>
-                public Torque ToUnit(TorqueUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Torque(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        TorqueUnit.GramForceCentimeter => _value * 9.80665e-5,
-                        TorqueUnit.GramForceMeter => _value * 9.80665e-3,
-                        TorqueUnit.GramForceMillimeter => _value * 9.80665e-6,
-                        TorqueUnit.KilogramForceCentimeter => _value * 9.80665e-2,
-                        TorqueUnit.KilogramForceMeter => _value * 9.80665,
-                        TorqueUnit.KilogramForceMillimeter => _value * 9.80665e-3,
-                        TorqueUnit.KilonewtonCentimeter => (_value * 0.01) * 1e3d,
-                        TorqueUnit.KilonewtonMeter => (_value) * 1e3d,
-                        TorqueUnit.KilonewtonMillimeter => (_value * 0.001) * 1e3d,
-                        TorqueUnit.KilopoundForceFoot => (_value * 4.4482216152605 * 0.3048) * 1e3d,
-                        TorqueUnit.KilopoundForceInch => (_value * 4.4482216152605 * 2.54e-2) * 1e3d,
-                        TorqueUnit.MeganewtonCentimeter => (_value * 0.01) * 1e6d,
-                        TorqueUnit.MeganewtonMeter => (_value) * 1e6d,
-                        TorqueUnit.MeganewtonMillimeter => (_value * 0.001) * 1e6d,
-                        TorqueUnit.MegapoundForceFoot => (_value * 4.4482216152605 * 0.3048) * 1e6d,
-                        TorqueUnit.MegapoundForceInch => (_value * 4.4482216152605 * 2.54e-2) * 1e6d,
-                        TorqueUnit.NewtonCentimeter => _value * 0.01,
-                        TorqueUnit.NewtonMeter => _value,
-                        TorqueUnit.NewtonMillimeter => _value * 0.001,
-                        TorqueUnit.PoundalFoot => _value * 0.138254954376 * 0.3048,
-                        TorqueUnit.PoundForceFoot => _value * 4.4482216152605 * 0.3048,
-                        TorqueUnit.PoundForceInch => _value * 4.4482216152605 * 2.54e-2,
-                        TorqueUnit.TonneForceCentimeter => _value * 9.80665e1,
-                        TorqueUnit.TonneForceMeter => _value * 9.80665e3,
-                        TorqueUnit.TonneForceMillimeter => _value * 9.80665,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(TorqueUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        TorqueUnit.GramForceCentimeter => baseUnitValue / 9.80665e-5,
-                        TorqueUnit.GramForceMeter => baseUnitValue / 9.80665e-3,
-                        TorqueUnit.GramForceMillimeter => baseUnitValue / 9.80665e-6,
-                        TorqueUnit.KilogramForceCentimeter => baseUnitValue / 9.80665e-2,
-                        TorqueUnit.KilogramForceMeter => baseUnitValue / 9.80665,
-                        TorqueUnit.KilogramForceMillimeter => baseUnitValue / 9.80665e-3,
-                        TorqueUnit.KilonewtonCentimeter => (baseUnitValue * 100) / 1e3d,
-                        TorqueUnit.KilonewtonMeter => (baseUnitValue) / 1e3d,
-                        TorqueUnit.KilonewtonMillimeter => (baseUnitValue * 1000) / 1e3d,
-                        TorqueUnit.KilopoundForceFoot => (baseUnitValue / (4.4482216152605 * 0.3048)) / 1e3d,
-                        TorqueUnit.KilopoundForceInch => (baseUnitValue / (4.4482216152605 * 2.54e-2)) / 1e3d,
-                        TorqueUnit.MeganewtonCentimeter => (baseUnitValue * 100) / 1e6d,
-                        TorqueUnit.MeganewtonMeter => (baseUnitValue) / 1e6d,
-                        TorqueUnit.MeganewtonMillimeter => (baseUnitValue * 1000) / 1e6d,
-                        TorqueUnit.MegapoundForceFoot => (baseUnitValue / (4.4482216152605 * 0.3048)) / 1e6d,
-                        TorqueUnit.MegapoundForceInch => (baseUnitValue / (4.4482216152605 * 2.54e-2)) / 1e6d,
-                        TorqueUnit.NewtonCentimeter => baseUnitValue * 100,
-                        TorqueUnit.NewtonMeter => baseUnitValue,
-                        TorqueUnit.NewtonMillimeter => baseUnitValue * 1000,
-                        TorqueUnit.PoundalFoot => baseUnitValue / (0.138254954376 * 0.3048),
-                        TorqueUnit.PoundForceFoot => baseUnitValue / (4.4482216152605 * 0.3048),
-                        TorqueUnit.PoundForceInch => baseUnitValue / (4.4482216152605 * 2.54e-2),
-                        TorqueUnit.TonneForceCentimeter => baseUnitValue / 9.80665e1,
-                        TorqueUnit.TonneForceMeter => baseUnitValue / 9.80665e3,
-                        TorqueUnit.TonneForceMillimeter => baseUnitValue / 9.80665,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Turbidity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Turbidity.g.cs
deleted file mode 100644
index 3eef53cc6c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Turbidity.g.cs
+++ /dev/null
@@ -1,160 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Turbidity is the cloudiness or haziness of a fluid caused by large numbers of individual particles that are generally invisible to the naked eye, similar to smoke in air. The measurement of turbidity is a key test of water quality.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Turbidity
-    /// </remarks>
-    public struct  Turbidity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly TurbidityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public TurbidityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Turbidity(double value, TurbidityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Turbidity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static TurbidityUnit BaseUnit { get; } = TurbidityUnit.NTU;
-
-        /// <summary>
-        /// Represents the largest possible value of Turbidity.
-        /// </summary>
-        public static Turbidity MaxValue { get; } = new Turbidity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Turbidity.
-        /// </summary>
-        public static Turbidity MinValue { get; } = new Turbidity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Turbidity Zero { get; } = new Turbidity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TurbidityUnit.NTU"/>
-        /// </summary>
-        public double NTU => As(TurbidityUnit.NTU);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Turbidity"/> from <see cref="TurbidityUnit.NTU"/>.
-        /// </summary>
-        public static Turbidity FromNTU(double ntu) => new Turbidity(ntu, TurbidityUnit.NTU);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="TurbidityUnit" /> to <see cref="Turbidity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Turbidity unit value.</returns>
-        public static Turbidity From(double value, TurbidityUnit fromUnit)
-        {
-            return new Turbidity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(TurbidityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Turbidity to another Turbidity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Turbidity with the specified unit.</returns>
-                public Turbidity ToUnit(TurbidityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Turbidity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        TurbidityUnit.NTU => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(TurbidityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        TurbidityUnit.NTU => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VitaminA.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VitaminA.g.cs
deleted file mode 100644
index 3c742f9119..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VitaminA.g.cs
+++ /dev/null
@@ -1,157 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Vitamin A: 1 IU is the biological equivalent of 0.3 µg retinol, or of 0.6 µg beta-carotene.
-    /// </summary>
-    public struct  VitaminA
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly VitaminAUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public VitaminAUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VitaminA(double value, VitaminAUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of VitaminA, which is Second. All conversions go via this value.
-        /// </summary>
-        public static VitaminAUnit BaseUnit { get; } = VitaminAUnit.InternationalUnit;
-
-        /// <summary>
-        /// Represents the largest possible value of VitaminA.
-        /// </summary>
-        public static VitaminA MaxValue { get; } = new VitaminA(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of VitaminA.
-        /// </summary>
-        public static VitaminA MinValue { get; } = new VitaminA(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static VitaminA Zero { get; } = new VitaminA(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VitaminAUnit.InternationalUnit"/>
-        /// </summary>
-        public double InternationalUnits => As(VitaminAUnit.InternationalUnit);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="VitaminA"/> from <see cref="VitaminAUnit.InternationalUnit"/>.
-        /// </summary>
-        public static VitaminA FromInternationalUnits(double internationalunits) => new VitaminA(internationalunits, VitaminAUnit.InternationalUnit);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VitaminAUnit" /> to <see cref="VitaminA" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>VitaminA unit value.</returns>
-        public static VitaminA From(double value, VitaminAUnit fromUnit)
-        {
-            return new VitaminA(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(VitaminAUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this VitaminA to another VitaminA with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A VitaminA with the specified unit.</returns>
-                public VitaminA ToUnit(VitaminAUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new VitaminA(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        VitaminAUnit.InternationalUnit => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(VitaminAUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        VitaminAUnit.InternationalUnit => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Volume.g.cs
deleted file mode 100644
index 11217d2cf9..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Volume.g.cs
+++ /dev/null
@@ -1,805 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Volume is the quantity of three-dimensional space enclosed by some closed boundary, for example, the space that a substance (solid, liquid, gas, or plasma) or shape occupies or contains.[1] Volume is often quantified numerically using the SI derived unit, the cubic metre. The volume of a container is generally understood to be the capacity of the container, i. e. the amount of fluid (gas or liquid) that the container could hold, rather than the amount of space the container itself displaces.
-    /// </summary>
-    public struct  Volume
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly VolumeUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public VolumeUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Volume(double value, VolumeUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of Volume, which is Second. All conversions go via this value.
-        /// </summary>
-        public static VolumeUnit BaseUnit { get; } = VolumeUnit.CubicMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of Volume.
-        /// </summary>
-        public static Volume MaxValue { get; } = new Volume(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of Volume.
-        /// </summary>
-        public static Volume MinValue { get; } = new Volume(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static Volume Zero { get; } = new Volume(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.AcreFoot"/>
-        /// </summary>
-        public double AcreFeet => As(VolumeUnit.AcreFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.AuTablespoon"/>
-        /// </summary>
-        public double AuTablespoons => As(VolumeUnit.AuTablespoon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.BoardFoot"/>
-        /// </summary>
-        public double BoardFeet => As(VolumeUnit.BoardFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Centiliter"/>
-        /// </summary>
-        public double Centiliters => As(VolumeUnit.Centiliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicCentimeter"/>
-        /// </summary>
-        public double CubicCentimeters => As(VolumeUnit.CubicCentimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicDecimeter"/>
-        /// </summary>
-        public double CubicDecimeters => As(VolumeUnit.CubicDecimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicFoot"/>
-        /// </summary>
-        public double CubicFeet => As(VolumeUnit.CubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicHectometer"/>
-        /// </summary>
-        public double CubicHectometers => As(VolumeUnit.CubicHectometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicInch"/>
-        /// </summary>
-        public double CubicInches => As(VolumeUnit.CubicInch);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicKilometer"/>
-        /// </summary>
-        public double CubicKilometers => As(VolumeUnit.CubicKilometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicMeter"/>
-        /// </summary>
-        public double CubicMeters => As(VolumeUnit.CubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicMicrometer"/>
-        /// </summary>
-        public double CubicMicrometers => As(VolumeUnit.CubicMicrometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicMile"/>
-        /// </summary>
-        public double CubicMiles => As(VolumeUnit.CubicMile);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicMillimeter"/>
-        /// </summary>
-        public double CubicMillimeters => As(VolumeUnit.CubicMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicYard"/>
-        /// </summary>
-        public double CubicYards => As(VolumeUnit.CubicYard);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Decaliter"/>
-        /// </summary>
-        public double Decaliters => As(VolumeUnit.Decaliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.DecausGallon"/>
-        /// </summary>
-        public double DecausGallons => As(VolumeUnit.DecausGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Deciliter"/>
-        /// </summary>
-        public double Deciliters => As(VolumeUnit.Deciliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.DeciusGallon"/>
-        /// </summary>
-        public double DeciusGallons => As(VolumeUnit.DeciusGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.HectocubicFoot"/>
-        /// </summary>
-        public double HectocubicFeet => As(VolumeUnit.HectocubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.HectocubicMeter"/>
-        /// </summary>
-        public double HectocubicMeters => As(VolumeUnit.HectocubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Hectoliter"/>
-        /// </summary>
-        public double Hectoliters => As(VolumeUnit.Hectoliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.HectousGallon"/>
-        /// </summary>
-        public double HectousGallons => As(VolumeUnit.HectousGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.ImperialBeerBarrel"/>
-        /// </summary>
-        public double ImperialBeerBarrels => As(VolumeUnit.ImperialBeerBarrel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.ImperialGallon"/>
-        /// </summary>
-        public double ImperialGallons => As(VolumeUnit.ImperialGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.ImperialOunce"/>
-        /// </summary>
-        public double ImperialOunces => As(VolumeUnit.ImperialOunce);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.ImperialPint"/>
-        /// </summary>
-        public double ImperialPints => As(VolumeUnit.ImperialPint);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.ImperialQuart"/>
-        /// </summary>
-        public double ImperialQuarts => As(VolumeUnit.ImperialQuart);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.KilocubicFoot"/>
-        /// </summary>
-        public double KilocubicFeet => As(VolumeUnit.KilocubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.KilocubicMeter"/>
-        /// </summary>
-        public double KilocubicMeters => As(VolumeUnit.KilocubicMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.KiloimperialGallon"/>
-        /// </summary>
-        public double KiloimperialGallons => As(VolumeUnit.KiloimperialGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Kiloliter"/>
-        /// </summary>
-        public double Kiloliters => As(VolumeUnit.Kiloliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.KilousGallon"/>
-        /// </summary>
-        public double KilousGallons => As(VolumeUnit.KilousGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Liter"/>
-        /// </summary>
-        public double Liters => As(VolumeUnit.Liter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MegacubicFoot"/>
-        /// </summary>
-        public double MegacubicFeet => As(VolumeUnit.MegacubicFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MegaimperialGallon"/>
-        /// </summary>
-        public double MegaimperialGallons => As(VolumeUnit.MegaimperialGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Megaliter"/>
-        /// </summary>
-        public double Megaliters => As(VolumeUnit.Megaliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MegausGallon"/>
-        /// </summary>
-        public double MegausGallons => As(VolumeUnit.MegausGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MetricCup"/>
-        /// </summary>
-        public double MetricCups => As(VolumeUnit.MetricCup);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MetricTablespoon"/>
-        /// </summary>
-        public double MetricTablespoons => As(VolumeUnit.MetricTablespoon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MetricTeaspoon"/>
-        /// </summary>
-        public double MetricTeaspoons => As(VolumeUnit.MetricTeaspoon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Microliter"/>
-        /// </summary>
-        public double Microliters => As(VolumeUnit.Microliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Milliliter"/>
-        /// </summary>
-        public double Milliliters => As(VolumeUnit.Milliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Nanoliter"/>
-        /// </summary>
-        public double Nanoliters => As(VolumeUnit.Nanoliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.OilBarrel"/>
-        /// </summary>
-        public double OilBarrels => As(VolumeUnit.OilBarrel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UkTablespoon"/>
-        /// </summary>
-        public double UkTablespoons => As(VolumeUnit.UkTablespoon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsBeerBarrel"/>
-        /// </summary>
-        public double UsBeerBarrels => As(VolumeUnit.UsBeerBarrel);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsCustomaryCup"/>
-        /// </summary>
-        public double UsCustomaryCups => As(VolumeUnit.UsCustomaryCup);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsGallon"/>
-        /// </summary>
-        public double UsGallons => As(VolumeUnit.UsGallon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsLegalCup"/>
-        /// </summary>
-        public double UsLegalCups => As(VolumeUnit.UsLegalCup);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsOunce"/>
-        /// </summary>
-        public double UsOunces => As(VolumeUnit.UsOunce);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsPint"/>
-        /// </summary>
-        public double UsPints => As(VolumeUnit.UsPint);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsQuart"/>
-        /// </summary>
-        public double UsQuarts => As(VolumeUnit.UsQuart);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsTablespoon"/>
-        /// </summary>
-        public double UsTablespoons => As(VolumeUnit.UsTablespoon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsTeaspoon"/>
-        /// </summary>
-        public double UsTeaspoons => As(VolumeUnit.UsTeaspoon);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.AcreFoot"/>.
-        /// </summary>
-        public static Volume FromAcreFeet(double acrefeet) => new Volume(acrefeet, VolumeUnit.AcreFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.AuTablespoon"/>.
-        /// </summary>
-        public static Volume FromAuTablespoons(double autablespoons) => new Volume(autablespoons, VolumeUnit.AuTablespoon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.BoardFoot"/>.
-        /// </summary>
-        public static Volume FromBoardFeet(double boardfeet) => new Volume(boardfeet, VolumeUnit.BoardFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Centiliter"/>.
-        /// </summary>
-        public static Volume FromCentiliters(double centiliters) => new Volume(centiliters, VolumeUnit.Centiliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicCentimeter"/>.
-        /// </summary>
-        public static Volume FromCubicCentimeters(double cubiccentimeters) => new Volume(cubiccentimeters, VolumeUnit.CubicCentimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicDecimeter"/>.
-        /// </summary>
-        public static Volume FromCubicDecimeters(double cubicdecimeters) => new Volume(cubicdecimeters, VolumeUnit.CubicDecimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicFoot"/>.
-        /// </summary>
-        public static Volume FromCubicFeet(double cubicfeet) => new Volume(cubicfeet, VolumeUnit.CubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicHectometer"/>.
-        /// </summary>
-        public static Volume FromCubicHectometers(double cubichectometers) => new Volume(cubichectometers, VolumeUnit.CubicHectometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicInch"/>.
-        /// </summary>
-        public static Volume FromCubicInches(double cubicinches) => new Volume(cubicinches, VolumeUnit.CubicInch);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicKilometer"/>.
-        /// </summary>
-        public static Volume FromCubicKilometers(double cubickilometers) => new Volume(cubickilometers, VolumeUnit.CubicKilometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMeter"/>.
-        /// </summary>
-        public static Volume FromCubicMeters(double cubicmeters) => new Volume(cubicmeters, VolumeUnit.CubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMicrometer"/>.
-        /// </summary>
-        public static Volume FromCubicMicrometers(double cubicmicrometers) => new Volume(cubicmicrometers, VolumeUnit.CubicMicrometer);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMile"/>.
-        /// </summary>
-        public static Volume FromCubicMiles(double cubicmiles) => new Volume(cubicmiles, VolumeUnit.CubicMile);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMillimeter"/>.
-        /// </summary>
-        public static Volume FromCubicMillimeters(double cubicmillimeters) => new Volume(cubicmillimeters, VolumeUnit.CubicMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicYard"/>.
-        /// </summary>
-        public static Volume FromCubicYards(double cubicyards) => new Volume(cubicyards, VolumeUnit.CubicYard);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Decaliter"/>.
-        /// </summary>
-        public static Volume FromDecaliters(double decaliters) => new Volume(decaliters, VolumeUnit.Decaliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.DecausGallon"/>.
-        /// </summary>
-        public static Volume FromDecausGallons(double decausgallons) => new Volume(decausgallons, VolumeUnit.DecausGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Deciliter"/>.
-        /// </summary>
-        public static Volume FromDeciliters(double deciliters) => new Volume(deciliters, VolumeUnit.Deciliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.DeciusGallon"/>.
-        /// </summary>
-        public static Volume FromDeciusGallons(double deciusgallons) => new Volume(deciusgallons, VolumeUnit.DeciusGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectocubicFoot"/>.
-        /// </summary>
-        public static Volume FromHectocubicFeet(double hectocubicfeet) => new Volume(hectocubicfeet, VolumeUnit.HectocubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectocubicMeter"/>.
-        /// </summary>
-        public static Volume FromHectocubicMeters(double hectocubicmeters) => new Volume(hectocubicmeters, VolumeUnit.HectocubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Hectoliter"/>.
-        /// </summary>
-        public static Volume FromHectoliters(double hectoliters) => new Volume(hectoliters, VolumeUnit.Hectoliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectousGallon"/>.
-        /// </summary>
-        public static Volume FromHectousGallons(double hectousgallons) => new Volume(hectousgallons, VolumeUnit.HectousGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialBeerBarrel"/>.
-        /// </summary>
-        public static Volume FromImperialBeerBarrels(double imperialbeerbarrels) => new Volume(imperialbeerbarrels, VolumeUnit.ImperialBeerBarrel);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialGallon"/>.
-        /// </summary>
-        public static Volume FromImperialGallons(double imperialgallons) => new Volume(imperialgallons, VolumeUnit.ImperialGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialOunce"/>.
-        /// </summary>
-        public static Volume FromImperialOunces(double imperialounces) => new Volume(imperialounces, VolumeUnit.ImperialOunce);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialPint"/>.
-        /// </summary>
-        public static Volume FromImperialPints(double imperialpints) => new Volume(imperialpints, VolumeUnit.ImperialPint);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialQuart"/>.
-        /// </summary>
-        public static Volume FromImperialQuarts(double imperialquarts) => new Volume(imperialquarts, VolumeUnit.ImperialQuart);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilocubicFoot"/>.
-        /// </summary>
-        public static Volume FromKilocubicFeet(double kilocubicfeet) => new Volume(kilocubicfeet, VolumeUnit.KilocubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilocubicMeter"/>.
-        /// </summary>
-        public static Volume FromKilocubicMeters(double kilocubicmeters) => new Volume(kilocubicmeters, VolumeUnit.KilocubicMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KiloimperialGallon"/>.
-        /// </summary>
-        public static Volume FromKiloimperialGallons(double kiloimperialgallons) => new Volume(kiloimperialgallons, VolumeUnit.KiloimperialGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Kiloliter"/>.
-        /// </summary>
-        public static Volume FromKiloliters(double kiloliters) => new Volume(kiloliters, VolumeUnit.Kiloliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilousGallon"/>.
-        /// </summary>
-        public static Volume FromKilousGallons(double kilousgallons) => new Volume(kilousgallons, VolumeUnit.KilousGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Liter"/>.
-        /// </summary>
-        public static Volume FromLiters(double liters) => new Volume(liters, VolumeUnit.Liter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegacubicFoot"/>.
-        /// </summary>
-        public static Volume FromMegacubicFeet(double megacubicfeet) => new Volume(megacubicfeet, VolumeUnit.MegacubicFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegaimperialGallon"/>.
-        /// </summary>
-        public static Volume FromMegaimperialGallons(double megaimperialgallons) => new Volume(megaimperialgallons, VolumeUnit.MegaimperialGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Megaliter"/>.
-        /// </summary>
-        public static Volume FromMegaliters(double megaliters) => new Volume(megaliters, VolumeUnit.Megaliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegausGallon"/>.
-        /// </summary>
-        public static Volume FromMegausGallons(double megausgallons) => new Volume(megausgallons, VolumeUnit.MegausGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MetricCup"/>.
-        /// </summary>
-        public static Volume FromMetricCups(double metriccups) => new Volume(metriccups, VolumeUnit.MetricCup);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MetricTablespoon"/>.
-        /// </summary>
-        public static Volume FromMetricTablespoons(double metrictablespoons) => new Volume(metrictablespoons, VolumeUnit.MetricTablespoon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MetricTeaspoon"/>.
-        /// </summary>
-        public static Volume FromMetricTeaspoons(double metricteaspoons) => new Volume(metricteaspoons, VolumeUnit.MetricTeaspoon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Microliter"/>.
-        /// </summary>
-        public static Volume FromMicroliters(double microliters) => new Volume(microliters, VolumeUnit.Microliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Milliliter"/>.
-        /// </summary>
-        public static Volume FromMilliliters(double milliliters) => new Volume(milliliters, VolumeUnit.Milliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Nanoliter"/>.
-        /// </summary>
-        public static Volume FromNanoliters(double nanoliters) => new Volume(nanoliters, VolumeUnit.Nanoliter);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.OilBarrel"/>.
-        /// </summary>
-        public static Volume FromOilBarrels(double oilbarrels) => new Volume(oilbarrels, VolumeUnit.OilBarrel);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UkTablespoon"/>.
-        /// </summary>
-        public static Volume FromUkTablespoons(double uktablespoons) => new Volume(uktablespoons, VolumeUnit.UkTablespoon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsBeerBarrel"/>.
-        /// </summary>
-        public static Volume FromUsBeerBarrels(double usbeerbarrels) => new Volume(usbeerbarrels, VolumeUnit.UsBeerBarrel);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsCustomaryCup"/>.
-        /// </summary>
-        public static Volume FromUsCustomaryCups(double uscustomarycups) => new Volume(uscustomarycups, VolumeUnit.UsCustomaryCup);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsGallon"/>.
-        /// </summary>
-        public static Volume FromUsGallons(double usgallons) => new Volume(usgallons, VolumeUnit.UsGallon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsLegalCup"/>.
-        /// </summary>
-        public static Volume FromUsLegalCups(double uslegalcups) => new Volume(uslegalcups, VolumeUnit.UsLegalCup);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsOunce"/>.
-        /// </summary>
-        public static Volume FromUsOunces(double usounces) => new Volume(usounces, VolumeUnit.UsOunce);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsPint"/>.
-        /// </summary>
-        public static Volume FromUsPints(double uspints) => new Volume(uspints, VolumeUnit.UsPint);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsQuart"/>.
-        /// </summary>
-        public static Volume FromUsQuarts(double usquarts) => new Volume(usquarts, VolumeUnit.UsQuart);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsTablespoon"/>.
-        /// </summary>
-        public static Volume FromUsTablespoons(double ustablespoons) => new Volume(ustablespoons, VolumeUnit.UsTablespoon);
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsTeaspoon"/>.
-        /// </summary>
-        public static Volume FromUsTeaspoons(double usteaspoons) => new Volume(usteaspoons, VolumeUnit.UsTeaspoon);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VolumeUnit" /> to <see cref="Volume" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>Volume unit value.</returns>
-        public static Volume From(double value, VolumeUnit fromUnit)
-        {
-            return new Volume(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(VolumeUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this Volume to another Volume with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A Volume with the specified unit.</returns>
-                public Volume ToUnit(VolumeUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new Volume(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        VolumeUnit.AcreFoot => _value * 1233.48183754752,
-                        VolumeUnit.AuTablespoon => _value * 2e-5,
-                        VolumeUnit.BoardFoot => _value * (0.028316846592 / 12),
-                        VolumeUnit.Centiliter => (_value / 1e3) * 1e-2d,
-                        VolumeUnit.CubicCentimeter => _value / 1e6,
-                        VolumeUnit.CubicDecimeter => _value / 1e3,
-                        VolumeUnit.CubicFoot => _value * 0.028316846592,
-                        VolumeUnit.CubicHectometer => _value * 1e6,
-                        VolumeUnit.CubicInch => _value * 1.6387064e-5,
-                        VolumeUnit.CubicKilometer => _value * 1e9,
-                        VolumeUnit.CubicMeter => _value,
-                        VolumeUnit.CubicMicrometer => _value / 1e18,
-                        VolumeUnit.CubicMile => _value * 4.168181825440579584e9,
-                        VolumeUnit.CubicMillimeter => _value / 1e9,
-                        VolumeUnit.CubicYard => _value * 0.764554857984,
-                        VolumeUnit.Decaliter => (_value / 1e3) * 1e1d,
-                        VolumeUnit.DecausGallon => (_value * 0.003785411784) * 1e1d,
-                        VolumeUnit.Deciliter => (_value / 1e3) * 1e-1d,
-                        VolumeUnit.DeciusGallon => (_value * 0.003785411784) * 1e-1d,
-                        VolumeUnit.HectocubicFoot => (_value * 0.028316846592) * 1e2d,
-                        VolumeUnit.HectocubicMeter => (_value) * 1e2d,
-                        VolumeUnit.Hectoliter => (_value / 1e3) * 1e2d,
-                        VolumeUnit.HectousGallon => (_value * 0.003785411784) * 1e2d,
-                        VolumeUnit.ImperialBeerBarrel => _value * 0.16365924,
-                        VolumeUnit.ImperialGallon => _value * 0.00454609,
-                        VolumeUnit.ImperialOunce => _value * 2.84130625e-5,
-                        VolumeUnit.ImperialPint => _value * 5.6826125e-4,
-                        VolumeUnit.ImperialQuart => _value * 1.1365225e-3,
-                        VolumeUnit.KilocubicFoot => (_value * 0.028316846592) * 1e3d,
-                        VolumeUnit.KilocubicMeter => (_value) * 1e3d,
-                        VolumeUnit.KiloimperialGallon => (_value * 0.00454609) * 1e3d,
-                        VolumeUnit.Kiloliter => (_value / 1e3) * 1e3d,
-                        VolumeUnit.KilousGallon => (_value * 0.003785411784) * 1e3d,
-                        VolumeUnit.Liter => _value / 1e3,
-                        VolumeUnit.MegacubicFoot => (_value * 0.028316846592) * 1e6d,
-                        VolumeUnit.MegaimperialGallon => (_value * 0.00454609) * 1e6d,
-                        VolumeUnit.Megaliter => (_value / 1e3) * 1e6d,
-                        VolumeUnit.MegausGallon => (_value * 0.003785411784) * 1e6d,
-                        VolumeUnit.MetricCup => _value * 0.00025,
-                        VolumeUnit.MetricTablespoon => _value * 1.5e-5,
-                        VolumeUnit.MetricTeaspoon => _value * 0.5e-5,
-                        VolumeUnit.Microliter => (_value / 1e3) * 1e-6d,
-                        VolumeUnit.Milliliter => (_value / 1e3) * 1e-3d,
-                        VolumeUnit.Nanoliter => (_value / 1e3) * 1e-9d,
-                        VolumeUnit.OilBarrel => _value * 0.158987294928,
-                        VolumeUnit.UkTablespoon => _value * 1.5e-5,
-                        VolumeUnit.UsBeerBarrel => _value * 0.117347765304,
-                        VolumeUnit.UsCustomaryCup => _value * 0.0002365882365,
-                        VolumeUnit.UsGallon => _value * 0.003785411784,
-                        VolumeUnit.UsLegalCup => _value * 0.00024,
-                        VolumeUnit.UsOunce => _value * 2.95735295625e-5,
-                        VolumeUnit.UsPint => _value * 4.73176473e-4,
-                        VolumeUnit.UsQuart => _value * 9.46352946e-4,
-                        VolumeUnit.UsTablespoon => _value * 1.478676478125e-5,
-                        VolumeUnit.UsTeaspoon => _value * 4.92892159375e-6,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(VolumeUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        VolumeUnit.AcreFoot => baseUnitValue / 1233.48183754752,
-                        VolumeUnit.AuTablespoon => baseUnitValue / 2e-5,
-                        VolumeUnit.BoardFoot => baseUnitValue / (0.028316846592 / 12),
-                        VolumeUnit.Centiliter => (baseUnitValue * 1e3) / 1e-2d,
-                        VolumeUnit.CubicCentimeter => baseUnitValue * 1e6,
-                        VolumeUnit.CubicDecimeter => baseUnitValue * 1e3,
-                        VolumeUnit.CubicFoot => baseUnitValue / 0.028316846592,
-                        VolumeUnit.CubicHectometer => baseUnitValue / 1e6,
-                        VolumeUnit.CubicInch => baseUnitValue / 1.6387064e-5,
-                        VolumeUnit.CubicKilometer => baseUnitValue / 1e9,
-                        VolumeUnit.CubicMeter => baseUnitValue,
-                        VolumeUnit.CubicMicrometer => baseUnitValue * 1e18,
-                        VolumeUnit.CubicMile => baseUnitValue / 4.168181825440579584e9,
-                        VolumeUnit.CubicMillimeter => baseUnitValue * 1e9,
-                        VolumeUnit.CubicYard => baseUnitValue / 0.764554857984,
-                        VolumeUnit.Decaliter => (baseUnitValue * 1e3) / 1e1d,
-                        VolumeUnit.DecausGallon => (baseUnitValue / 0.003785411784) / 1e1d,
-                        VolumeUnit.Deciliter => (baseUnitValue * 1e3) / 1e-1d,
-                        VolumeUnit.DeciusGallon => (baseUnitValue / 0.003785411784) / 1e-1d,
-                        VolumeUnit.HectocubicFoot => (baseUnitValue / 0.028316846592) / 1e2d,
-                        VolumeUnit.HectocubicMeter => (baseUnitValue) / 1e2d,
-                        VolumeUnit.Hectoliter => (baseUnitValue * 1e3) / 1e2d,
-                        VolumeUnit.HectousGallon => (baseUnitValue / 0.003785411784) / 1e2d,
-                        VolumeUnit.ImperialBeerBarrel => baseUnitValue / 0.16365924,
-                        VolumeUnit.ImperialGallon => baseUnitValue / 0.00454609,
-                        VolumeUnit.ImperialOunce => baseUnitValue / 2.84130625e-5,
-                        VolumeUnit.ImperialPint => baseUnitValue / 5.6826125e-4,
-                        VolumeUnit.ImperialQuart => baseUnitValue / 1.1365225e-3,
-                        VolumeUnit.KilocubicFoot => (baseUnitValue / 0.028316846592) / 1e3d,
-                        VolumeUnit.KilocubicMeter => (baseUnitValue) / 1e3d,
-                        VolumeUnit.KiloimperialGallon => (baseUnitValue / 0.00454609) / 1e3d,
-                        VolumeUnit.Kiloliter => (baseUnitValue * 1e3) / 1e3d,
-                        VolumeUnit.KilousGallon => (baseUnitValue / 0.003785411784) / 1e3d,
-                        VolumeUnit.Liter => baseUnitValue * 1e3,
-                        VolumeUnit.MegacubicFoot => (baseUnitValue / 0.028316846592) / 1e6d,
-                        VolumeUnit.MegaimperialGallon => (baseUnitValue / 0.00454609) / 1e6d,
-                        VolumeUnit.Megaliter => (baseUnitValue * 1e3) / 1e6d,
-                        VolumeUnit.MegausGallon => (baseUnitValue / 0.003785411784) / 1e6d,
-                        VolumeUnit.MetricCup => baseUnitValue / 0.00025,
-                        VolumeUnit.MetricTablespoon => baseUnitValue / 1.5e-5,
-                        VolumeUnit.MetricTeaspoon => baseUnitValue / 0.5e-5,
-                        VolumeUnit.Microliter => (baseUnitValue * 1e3) / 1e-6d,
-                        VolumeUnit.Milliliter => (baseUnitValue * 1e3) / 1e-3d,
-                        VolumeUnit.Nanoliter => (baseUnitValue * 1e3) / 1e-9d,
-                        VolumeUnit.OilBarrel => baseUnitValue / 0.158987294928,
-                        VolumeUnit.UkTablespoon => baseUnitValue / 1.5e-5,
-                        VolumeUnit.UsBeerBarrel => baseUnitValue / 0.117347765304,
-                        VolumeUnit.UsCustomaryCup => baseUnitValue / 0.0002365882365,
-                        VolumeUnit.UsGallon => baseUnitValue / 0.003785411784,
-                        VolumeUnit.UsLegalCup => baseUnitValue / 0.00024,
-                        VolumeUnit.UsOunce => baseUnitValue / 2.95735295625e-5,
-                        VolumeUnit.UsPint => baseUnitValue / 4.73176473e-4,
-                        VolumeUnit.UsQuart => baseUnitValue / 9.46352946e-4,
-                        VolumeUnit.UsTablespoon => baseUnitValue / 1.478676478125e-5,
-                        VolumeUnit.UsTeaspoon => baseUnitValue / 4.92892159375e-6,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs
deleted file mode 100644
index cd2516f36d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs
+++ /dev/null
@@ -1,388 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The volume concentration (not to be confused with volume fraction) is defined as the volume of a constituent divided by the total volume of the mixture.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Concentration#Volume_concentration
-    /// </remarks>
-    public struct  VolumeConcentration
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly VolumeConcentrationUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public VolumeConcentrationUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VolumeConcentration(double value, VolumeConcentrationUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of VolumeConcentration, which is Second. All conversions go via this value.
-        /// </summary>
-        public static VolumeConcentrationUnit BaseUnit { get; } = VolumeConcentrationUnit.DecimalFraction;
-
-        /// <summary>
-        /// Represents the largest possible value of VolumeConcentration.
-        /// </summary>
-        public static VolumeConcentration MaxValue { get; } = new VolumeConcentration(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of VolumeConcentration.
-        /// </summary>
-        public static VolumeConcentration MinValue { get; } = new VolumeConcentration(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static VolumeConcentration Zero { get; } = new VolumeConcentration(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.CentiliterPerLiter"/>
-        /// </summary>
-        public double CentilitersPerLiter => As(VolumeConcentrationUnit.CentiliterPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.CentiliterPerMilliliter"/>
-        /// </summary>
-        public double CentilitersPerMilliliter => As(VolumeConcentrationUnit.CentiliterPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.DeciliterPerLiter"/>
-        /// </summary>
-        public double DecilitersPerLiter => As(VolumeConcentrationUnit.DeciliterPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.DeciliterPerMilliliter"/>
-        /// </summary>
-        public double DecilitersPerMilliliter => As(VolumeConcentrationUnit.DeciliterPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.DecimalFraction"/>
-        /// </summary>
-        public double DecimalFractions => As(VolumeConcentrationUnit.DecimalFraction);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.LiterPerLiter"/>
-        /// </summary>
-        public double LitersPerLiter => As(VolumeConcentrationUnit.LiterPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.LiterPerMilliliter"/>
-        /// </summary>
-        public double LitersPerMilliliter => As(VolumeConcentrationUnit.LiterPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MicroliterPerLiter"/>
-        /// </summary>
-        public double MicrolitersPerLiter => As(VolumeConcentrationUnit.MicroliterPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MicroliterPerMilliliter"/>
-        /// </summary>
-        public double MicrolitersPerMilliliter => As(VolumeConcentrationUnit.MicroliterPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MilliliterPerLiter"/>
-        /// </summary>
-        public double MillilitersPerLiter => As(VolumeConcentrationUnit.MilliliterPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MilliliterPerMilliliter"/>
-        /// </summary>
-        public double MillilitersPerMilliliter => As(VolumeConcentrationUnit.MilliliterPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.NanoliterPerLiter"/>
-        /// </summary>
-        public double NanolitersPerLiter => As(VolumeConcentrationUnit.NanoliterPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.NanoliterPerMilliliter"/>
-        /// </summary>
-        public double NanolitersPerMilliliter => As(VolumeConcentrationUnit.NanoliterPerMilliliter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerBillion"/>
-        /// </summary>
-        public double PartsPerBillion => As(VolumeConcentrationUnit.PartPerBillion);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerMillion"/>
-        /// </summary>
-        public double PartsPerMillion => As(VolumeConcentrationUnit.PartPerMillion);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerThousand"/>
-        /// </summary>
-        public double PartsPerThousand => As(VolumeConcentrationUnit.PartPerThousand);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerTrillion"/>
-        /// </summary>
-        public double PartsPerTrillion => As(VolumeConcentrationUnit.PartPerTrillion);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.Percent"/>
-        /// </summary>
-        public double Percent => As(VolumeConcentrationUnit.Percent);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PicoliterPerLiter"/>
-        /// </summary>
-        public double PicolitersPerLiter => As(VolumeConcentrationUnit.PicoliterPerLiter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PicoliterPerMilliliter"/>
-        /// </summary>
-        public double PicolitersPerMilliliter => As(VolumeConcentrationUnit.PicoliterPerMilliliter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.CentiliterPerLiter"/>.
-        /// </summary>
-        public static VolumeConcentration FromCentilitersPerLiter(double centilitersperliter) => new VolumeConcentration(centilitersperliter, VolumeConcentrationUnit.CentiliterPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.CentiliterPerMilliliter"/>.
-        /// </summary>
-        public static VolumeConcentration FromCentilitersPerMilliliter(double centiliterspermilliliter) => new VolumeConcentration(centiliterspermilliliter, VolumeConcentrationUnit.CentiliterPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DeciliterPerLiter"/>.
-        /// </summary>
-        public static VolumeConcentration FromDecilitersPerLiter(double decilitersperliter) => new VolumeConcentration(decilitersperliter, VolumeConcentrationUnit.DeciliterPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DeciliterPerMilliliter"/>.
-        /// </summary>
-        public static VolumeConcentration FromDecilitersPerMilliliter(double deciliterspermilliliter) => new VolumeConcentration(deciliterspermilliliter, VolumeConcentrationUnit.DeciliterPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DecimalFraction"/>.
-        /// </summary>
-        public static VolumeConcentration FromDecimalFractions(double decimalfractions) => new VolumeConcentration(decimalfractions, VolumeConcentrationUnit.DecimalFraction);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.LiterPerLiter"/>.
-        /// </summary>
-        public static VolumeConcentration FromLitersPerLiter(double litersperliter) => new VolumeConcentration(litersperliter, VolumeConcentrationUnit.LiterPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.LiterPerMilliliter"/>.
-        /// </summary>
-        public static VolumeConcentration FromLitersPerMilliliter(double literspermilliliter) => new VolumeConcentration(literspermilliliter, VolumeConcentrationUnit.LiterPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MicroliterPerLiter"/>.
-        /// </summary>
-        public static VolumeConcentration FromMicrolitersPerLiter(double microlitersperliter) => new VolumeConcentration(microlitersperliter, VolumeConcentrationUnit.MicroliterPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MicroliterPerMilliliter"/>.
-        /// </summary>
-        public static VolumeConcentration FromMicrolitersPerMilliliter(double microliterspermilliliter) => new VolumeConcentration(microliterspermilliliter, VolumeConcentrationUnit.MicroliterPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MilliliterPerLiter"/>.
-        /// </summary>
-        public static VolumeConcentration FromMillilitersPerLiter(double millilitersperliter) => new VolumeConcentration(millilitersperliter, VolumeConcentrationUnit.MilliliterPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MilliliterPerMilliliter"/>.
-        /// </summary>
-        public static VolumeConcentration FromMillilitersPerMilliliter(double milliliterspermilliliter) => new VolumeConcentration(milliliterspermilliliter, VolumeConcentrationUnit.MilliliterPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.NanoliterPerLiter"/>.
-        /// </summary>
-        public static VolumeConcentration FromNanolitersPerLiter(double nanolitersperliter) => new VolumeConcentration(nanolitersperliter, VolumeConcentrationUnit.NanoliterPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.NanoliterPerMilliliter"/>.
-        /// </summary>
-        public static VolumeConcentration FromNanolitersPerMilliliter(double nanoliterspermilliliter) => new VolumeConcentration(nanoliterspermilliliter, VolumeConcentrationUnit.NanoliterPerMilliliter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerBillion"/>.
-        /// </summary>
-        public static VolumeConcentration FromPartsPerBillion(double partsperbillion) => new VolumeConcentration(partsperbillion, VolumeConcentrationUnit.PartPerBillion);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerMillion"/>.
-        /// </summary>
-        public static VolumeConcentration FromPartsPerMillion(double partspermillion) => new VolumeConcentration(partspermillion, VolumeConcentrationUnit.PartPerMillion);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerThousand"/>.
-        /// </summary>
-        public static VolumeConcentration FromPartsPerThousand(double partsperthousand) => new VolumeConcentration(partsperthousand, VolumeConcentrationUnit.PartPerThousand);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerTrillion"/>.
-        /// </summary>
-        public static VolumeConcentration FromPartsPerTrillion(double partspertrillion) => new VolumeConcentration(partspertrillion, VolumeConcentrationUnit.PartPerTrillion);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.Percent"/>.
-        /// </summary>
-        public static VolumeConcentration FromPercent(double percent) => new VolumeConcentration(percent, VolumeConcentrationUnit.Percent);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PicoliterPerLiter"/>.
-        /// </summary>
-        public static VolumeConcentration FromPicolitersPerLiter(double picolitersperliter) => new VolumeConcentration(picolitersperliter, VolumeConcentrationUnit.PicoliterPerLiter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PicoliterPerMilliliter"/>.
-        /// </summary>
-        public static VolumeConcentration FromPicolitersPerMilliliter(double picoliterspermilliliter) => new VolumeConcentration(picoliterspermilliliter, VolumeConcentrationUnit.PicoliterPerMilliliter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VolumeConcentrationUnit" /> to <see cref="VolumeConcentration" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>VolumeConcentration unit value.</returns>
-        public static VolumeConcentration From(double value, VolumeConcentrationUnit fromUnit)
-        {
-            return new VolumeConcentration(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(VolumeConcentrationUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this VolumeConcentration to another VolumeConcentration with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A VolumeConcentration with the specified unit.</returns>
-                public VolumeConcentration ToUnit(VolumeConcentrationUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new VolumeConcentration(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        VolumeConcentrationUnit.CentiliterPerLiter => (_value) * 1e-2d,
-                        VolumeConcentrationUnit.CentiliterPerMilliliter => (_value / 1e-3) * 1e-2d,
-                        VolumeConcentrationUnit.DeciliterPerLiter => (_value) * 1e-1d,
-                        VolumeConcentrationUnit.DeciliterPerMilliliter => (_value / 1e-3) * 1e-1d,
-                        VolumeConcentrationUnit.DecimalFraction => _value,
-                        VolumeConcentrationUnit.LiterPerLiter => _value,
-                        VolumeConcentrationUnit.LiterPerMilliliter => _value / 1e-3,
-                        VolumeConcentrationUnit.MicroliterPerLiter => (_value) * 1e-6d,
-                        VolumeConcentrationUnit.MicroliterPerMilliliter => (_value / 1e-3) * 1e-6d,
-                        VolumeConcentrationUnit.MilliliterPerLiter => (_value) * 1e-3d,
-                        VolumeConcentrationUnit.MilliliterPerMilliliter => (_value / 1e-3) * 1e-3d,
-                        VolumeConcentrationUnit.NanoliterPerLiter => (_value) * 1e-9d,
-                        VolumeConcentrationUnit.NanoliterPerMilliliter => (_value / 1e-3) * 1e-9d,
-                        VolumeConcentrationUnit.PartPerBillion => _value / 1e9,
-                        VolumeConcentrationUnit.PartPerMillion => _value / 1e6,
-                        VolumeConcentrationUnit.PartPerThousand => _value / 1e3,
-                        VolumeConcentrationUnit.PartPerTrillion => _value / 1e12,
-                        VolumeConcentrationUnit.Percent => _value / 1e2,
-                        VolumeConcentrationUnit.PicoliterPerLiter => (_value) * 1e-12d,
-                        VolumeConcentrationUnit.PicoliterPerMilliliter => (_value / 1e-3) * 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(VolumeConcentrationUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        VolumeConcentrationUnit.CentiliterPerLiter => (baseUnitValue) / 1e-2d,
-                        VolumeConcentrationUnit.CentiliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-2d,
-                        VolumeConcentrationUnit.DeciliterPerLiter => (baseUnitValue) / 1e-1d,
-                        VolumeConcentrationUnit.DeciliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-1d,
-                        VolumeConcentrationUnit.DecimalFraction => baseUnitValue,
-                        VolumeConcentrationUnit.LiterPerLiter => baseUnitValue,
-                        VolumeConcentrationUnit.LiterPerMilliliter => baseUnitValue * 1e-3,
-                        VolumeConcentrationUnit.MicroliterPerLiter => (baseUnitValue) / 1e-6d,
-                        VolumeConcentrationUnit.MicroliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-6d,
-                        VolumeConcentrationUnit.MilliliterPerLiter => (baseUnitValue) / 1e-3d,
-                        VolumeConcentrationUnit.MilliliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-3d,
-                        VolumeConcentrationUnit.NanoliterPerLiter => (baseUnitValue) / 1e-9d,
-                        VolumeConcentrationUnit.NanoliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-9d,
-                        VolumeConcentrationUnit.PartPerBillion => baseUnitValue * 1e9,
-                        VolumeConcentrationUnit.PartPerMillion => baseUnitValue * 1e6,
-                        VolumeConcentrationUnit.PartPerThousand => baseUnitValue * 1e3,
-                        VolumeConcentrationUnit.PartPerTrillion => baseUnitValue * 1e12,
-                        VolumeConcentrationUnit.Percent => baseUnitValue * 1e2,
-                        VolumeConcentrationUnit.PicoliterPerLiter => (baseUnitValue) / 1e-12d,
-                        VolumeConcentrationUnit.PicoliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-12d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeFlow.g.cs
deleted file mode 100644
index 4fdde0e38d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeFlow.g.cs
+++ /dev/null
@@ -1,1045 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     In physics and engineering, in particular fluid dynamics and hydrometry, the volumetric flow rate, (also known as volume flow rate, rate of fluid flow or volume velocity) is the volume of fluid which passes through a given surface per unit time. The SI unit is m³/s (cubic meters per second). In US Customary Units and British Imperial Units, volumetric flow rate is often expressed as ft³/s (cubic feet per second). It is usually represented by the symbol Q.
-    /// </summary>
-    public struct  VolumeFlow
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly VolumeFlowUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public VolumeFlowUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VolumeFlow(double value, VolumeFlowUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of VolumeFlow, which is Second. All conversions go via this value.
-        /// </summary>
-        public static VolumeFlowUnit BaseUnit { get; } = VolumeFlowUnit.CubicMeterPerSecond;
-
-        /// <summary>
-        /// Represents the largest possible value of VolumeFlow.
-        /// </summary>
-        public static VolumeFlow MaxValue { get; } = new VolumeFlow(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of VolumeFlow.
-        /// </summary>
-        public static VolumeFlow MinValue { get; } = new VolumeFlow(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static VolumeFlow Zero { get; } = new VolumeFlow(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerDay"/>
-        /// </summary>
-        public double AcreFeetPerDay => As(VolumeFlowUnit.AcreFootPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerHour"/>
-        /// </summary>
-        public double AcreFeetPerHour => As(VolumeFlowUnit.AcreFootPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerMinute"/>
-        /// </summary>
-        public double AcreFeetPerMinute => As(VolumeFlowUnit.AcreFootPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerSecond"/>
-        /// </summary>
-        public double AcreFeetPerSecond => As(VolumeFlowUnit.AcreFootPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerDay"/>
-        /// </summary>
-        public double CentilitersPerDay => As(VolumeFlowUnit.CentiliterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerHour"/>
-        /// </summary>
-        public double CentilitersPerHour => As(VolumeFlowUnit.CentiliterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerMinute"/>
-        /// </summary>
-        public double CentilitersPerMinute => As(VolumeFlowUnit.CentiliterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerSecond"/>
-        /// </summary>
-        public double CentilitersPerSecond => As(VolumeFlowUnit.CentiliterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicCentimeterPerMinute"/>
-        /// </summary>
-        public double CubicCentimetersPerMinute => As(VolumeFlowUnit.CubicCentimeterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicDecimeterPerMinute"/>
-        /// </summary>
-        public double CubicDecimetersPerMinute => As(VolumeFlowUnit.CubicDecimeterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicFootPerHour"/>
-        /// </summary>
-        public double CubicFeetPerHour => As(VolumeFlowUnit.CubicFootPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicFootPerMinute"/>
-        /// </summary>
-        public double CubicFeetPerMinute => As(VolumeFlowUnit.CubicFootPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicFootPerSecond"/>
-        /// </summary>
-        public double CubicFeetPerSecond => As(VolumeFlowUnit.CubicFootPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerDay"/>
-        /// </summary>
-        public double CubicMetersPerDay => As(VolumeFlowUnit.CubicMeterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerHour"/>
-        /// </summary>
-        public double CubicMetersPerHour => As(VolumeFlowUnit.CubicMeterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerMinute"/>
-        /// </summary>
-        public double CubicMetersPerMinute => As(VolumeFlowUnit.CubicMeterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerSecond"/>
-        /// </summary>
-        public double CubicMetersPerSecond => As(VolumeFlowUnit.CubicMeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMillimeterPerSecond"/>
-        /// </summary>
-        public double CubicMillimetersPerSecond => As(VolumeFlowUnit.CubicMillimeterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerDay"/>
-        /// </summary>
-        public double CubicYardsPerDay => As(VolumeFlowUnit.CubicYardPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerHour"/>
-        /// </summary>
-        public double CubicYardsPerHour => As(VolumeFlowUnit.CubicYardPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerMinute"/>
-        /// </summary>
-        public double CubicYardsPerMinute => As(VolumeFlowUnit.CubicYardPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerSecond"/>
-        /// </summary>
-        public double CubicYardsPerSecond => As(VolumeFlowUnit.CubicYardPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerDay"/>
-        /// </summary>
-        public double DecalitersPerDay => As(VolumeFlowUnit.DecaliterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerHour"/>
-        /// </summary>
-        public double DecalitersPerHour => As(VolumeFlowUnit.DecaliterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerMinute"/>
-        /// </summary>
-        public double DecalitersPerMinute => As(VolumeFlowUnit.DecaliterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerSecond"/>
-        /// </summary>
-        public double DecalitersPerSecond => As(VolumeFlowUnit.DecaliterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerDay"/>
-        /// </summary>
-        public double DecilitersPerDay => As(VolumeFlowUnit.DeciliterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerHour"/>
-        /// </summary>
-        public double DecilitersPerHour => As(VolumeFlowUnit.DeciliterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerMinute"/>
-        /// </summary>
-        public double DecilitersPerMinute => As(VolumeFlowUnit.DeciliterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerSecond"/>
-        /// </summary>
-        public double DecilitersPerSecond => As(VolumeFlowUnit.DeciliterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerDay"/>
-        /// </summary>
-        public double HectolitersPerDay => As(VolumeFlowUnit.HectoliterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerHour"/>
-        /// </summary>
-        public double HectolitersPerHour => As(VolumeFlowUnit.HectoliterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerMinute"/>
-        /// </summary>
-        public double HectolitersPerMinute => As(VolumeFlowUnit.HectoliterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerSecond"/>
-        /// </summary>
-        public double HectolitersPerSecond => As(VolumeFlowUnit.HectoliterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerDay"/>
-        /// </summary>
-        public double KilolitersPerDay => As(VolumeFlowUnit.KiloliterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerHour"/>
-        /// </summary>
-        public double KilolitersPerHour => As(VolumeFlowUnit.KiloliterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerMinute"/>
-        /// </summary>
-        public double KilolitersPerMinute => As(VolumeFlowUnit.KiloliterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerSecond"/>
-        /// </summary>
-        public double KilolitersPerSecond => As(VolumeFlowUnit.KiloliterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.KilousGallonPerMinute"/>
-        /// </summary>
-        public double KilousGallonsPerMinute => As(VolumeFlowUnit.KilousGallonPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerDay"/>
-        /// </summary>
-        public double LitersPerDay => As(VolumeFlowUnit.LiterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerHour"/>
-        /// </summary>
-        public double LitersPerHour => As(VolumeFlowUnit.LiterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerMinute"/>
-        /// </summary>
-        public double LitersPerMinute => As(VolumeFlowUnit.LiterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerSecond"/>
-        /// </summary>
-        public double LitersPerSecond => As(VolumeFlowUnit.LiterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerDay"/>
-        /// </summary>
-        public double MegalitersPerDay => As(VolumeFlowUnit.MegaliterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerHour"/>
-        /// </summary>
-        public double MegalitersPerHour => As(VolumeFlowUnit.MegaliterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerMinute"/>
-        /// </summary>
-        public double MegalitersPerMinute => As(VolumeFlowUnit.MegaliterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerSecond"/>
-        /// </summary>
-        public double MegalitersPerSecond => As(VolumeFlowUnit.MegaliterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaukGallonPerDay"/>
-        /// </summary>
-        public double MegaukGallonsPerDay => As(VolumeFlowUnit.MegaukGallonPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaukGallonPerSecond"/>
-        /// </summary>
-        public double MegaukGallonsPerSecond => As(VolumeFlowUnit.MegaukGallonPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegausGallonPerDay"/>
-        /// </summary>
-        public double MegausGallonsPerDay => As(VolumeFlowUnit.MegausGallonPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerDay"/>
-        /// </summary>
-        public double MicrolitersPerDay => As(VolumeFlowUnit.MicroliterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerHour"/>
-        /// </summary>
-        public double MicrolitersPerHour => As(VolumeFlowUnit.MicroliterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerMinute"/>
-        /// </summary>
-        public double MicrolitersPerMinute => As(VolumeFlowUnit.MicroliterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerSecond"/>
-        /// </summary>
-        public double MicrolitersPerSecond => As(VolumeFlowUnit.MicroliterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerDay"/>
-        /// </summary>
-        public double MillilitersPerDay => As(VolumeFlowUnit.MilliliterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerHour"/>
-        /// </summary>
-        public double MillilitersPerHour => As(VolumeFlowUnit.MilliliterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerMinute"/>
-        /// </summary>
-        public double MillilitersPerMinute => As(VolumeFlowUnit.MilliliterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerSecond"/>
-        /// </summary>
-        public double MillilitersPerSecond => As(VolumeFlowUnit.MilliliterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MillionUsGallonPerDay"/>
-        /// </summary>
-        public double MillionUsGallonsPerDay => As(VolumeFlowUnit.MillionUsGallonPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerDay"/>
-        /// </summary>
-        public double NanolitersPerDay => As(VolumeFlowUnit.NanoliterPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerHour"/>
-        /// </summary>
-        public double NanolitersPerHour => As(VolumeFlowUnit.NanoliterPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerMinute"/>
-        /// </summary>
-        public double NanolitersPerMinute => As(VolumeFlowUnit.NanoliterPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerSecond"/>
-        /// </summary>
-        public double NanolitersPerSecond => As(VolumeFlowUnit.NanoliterPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerDay"/>
-        /// </summary>
-        public double OilBarrelsPerDay => As(VolumeFlowUnit.OilBarrelPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerHour"/>
-        /// </summary>
-        public double OilBarrelsPerHour => As(VolumeFlowUnit.OilBarrelPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerMinute"/>
-        /// </summary>
-        public double OilBarrelsPerMinute => As(VolumeFlowUnit.OilBarrelPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerSecond"/>
-        /// </summary>
-        public double OilBarrelsPerSecond => As(VolumeFlowUnit.OilBarrelPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerDay"/>
-        /// </summary>
-        public double UkGallonsPerDay => As(VolumeFlowUnit.UkGallonPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerHour"/>
-        /// </summary>
-        public double UkGallonsPerHour => As(VolumeFlowUnit.UkGallonPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerMinute"/>
-        /// </summary>
-        public double UkGallonsPerMinute => As(VolumeFlowUnit.UkGallonPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerSecond"/>
-        /// </summary>
-        public double UkGallonsPerSecond => As(VolumeFlowUnit.UkGallonPerSecond);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerDay"/>
-        /// </summary>
-        public double UsGallonsPerDay => As(VolumeFlowUnit.UsGallonPerDay);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerHour"/>
-        /// </summary>
-        public double UsGallonsPerHour => As(VolumeFlowUnit.UsGallonPerHour);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerMinute"/>
-        /// </summary>
-        public double UsGallonsPerMinute => As(VolumeFlowUnit.UsGallonPerMinute);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerSecond"/>
-        /// </summary>
-        public double UsGallonsPerSecond => As(VolumeFlowUnit.UsGallonPerSecond);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromAcreFeetPerDay(double acrefeetperday) => new VolumeFlow(acrefeetperday, VolumeFlowUnit.AcreFootPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromAcreFeetPerHour(double acrefeetperhour) => new VolumeFlow(acrefeetperhour, VolumeFlowUnit.AcreFootPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromAcreFeetPerMinute(double acrefeetperminute) => new VolumeFlow(acrefeetperminute, VolumeFlowUnit.AcreFootPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromAcreFeetPerSecond(double acrefeetpersecond) => new VolumeFlow(acrefeetpersecond, VolumeFlowUnit.AcreFootPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromCentilitersPerDay(double centilitersperday) => new VolumeFlow(centilitersperday, VolumeFlowUnit.CentiliterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromCentilitersPerHour(double centilitersperhour) => new VolumeFlow(centilitersperhour, VolumeFlowUnit.CentiliterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromCentilitersPerMinute(double centilitersperminute) => new VolumeFlow(centilitersperminute, VolumeFlowUnit.CentiliterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromCentilitersPerSecond(double centiliterspersecond) => new VolumeFlow(centiliterspersecond, VolumeFlowUnit.CentiliterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicCentimeterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicCentimetersPerMinute(double cubiccentimetersperminute) => new VolumeFlow(cubiccentimetersperminute, VolumeFlowUnit.CubicCentimeterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicDecimeterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicDecimetersPerMinute(double cubicdecimetersperminute) => new VolumeFlow(cubicdecimetersperminute, VolumeFlowUnit.CubicDecimeterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicFeetPerHour(double cubicfeetperhour) => new VolumeFlow(cubicfeetperhour, VolumeFlowUnit.CubicFootPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicFeetPerMinute(double cubicfeetperminute) => new VolumeFlow(cubicfeetperminute, VolumeFlowUnit.CubicFootPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicFeetPerSecond(double cubicfeetpersecond) => new VolumeFlow(cubicfeetpersecond, VolumeFlowUnit.CubicFootPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicMetersPerDay(double cubicmetersperday) => new VolumeFlow(cubicmetersperday, VolumeFlowUnit.CubicMeterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicMetersPerHour(double cubicmetersperhour) => new VolumeFlow(cubicmetersperhour, VolumeFlowUnit.CubicMeterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicMetersPerMinute(double cubicmetersperminute) => new VolumeFlow(cubicmetersperminute, VolumeFlowUnit.CubicMeterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicMetersPerSecond(double cubicmeterspersecond) => new VolumeFlow(cubicmeterspersecond, VolumeFlowUnit.CubicMeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMillimeterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicMillimetersPerSecond(double cubicmillimeterspersecond) => new VolumeFlow(cubicmillimeterspersecond, VolumeFlowUnit.CubicMillimeterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicYardsPerDay(double cubicyardsperday) => new VolumeFlow(cubicyardsperday, VolumeFlowUnit.CubicYardPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicYardsPerHour(double cubicyardsperhour) => new VolumeFlow(cubicyardsperhour, VolumeFlowUnit.CubicYardPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicYardsPerMinute(double cubicyardsperminute) => new VolumeFlow(cubicyardsperminute, VolumeFlowUnit.CubicYardPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromCubicYardsPerSecond(double cubicyardspersecond) => new VolumeFlow(cubicyardspersecond, VolumeFlowUnit.CubicYardPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DecaliterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromDecalitersPerDay(double decalitersperday) => new VolumeFlow(decalitersperday, VolumeFlowUnit.DecaliterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DecaliterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromDecalitersPerHour(double decalitersperhour) => new VolumeFlow(decalitersperhour, VolumeFlowUnit.DecaliterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DecaliterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromDecalitersPerMinute(double decalitersperminute) => new VolumeFlow(decalitersperminute, VolumeFlowUnit.DecaliterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DecaliterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromDecalitersPerSecond(double decaliterspersecond) => new VolumeFlow(decaliterspersecond, VolumeFlowUnit.DecaliterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromDecilitersPerDay(double decilitersperday) => new VolumeFlow(decilitersperday, VolumeFlowUnit.DeciliterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromDecilitersPerHour(double decilitersperhour) => new VolumeFlow(decilitersperhour, VolumeFlowUnit.DeciliterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromDecilitersPerMinute(double decilitersperminute) => new VolumeFlow(decilitersperminute, VolumeFlowUnit.DeciliterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromDecilitersPerSecond(double deciliterspersecond) => new VolumeFlow(deciliterspersecond, VolumeFlowUnit.DeciliterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.HectoliterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromHectolitersPerDay(double hectolitersperday) => new VolumeFlow(hectolitersperday, VolumeFlowUnit.HectoliterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.HectoliterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromHectolitersPerHour(double hectolitersperhour) => new VolumeFlow(hectolitersperhour, VolumeFlowUnit.HectoliterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.HectoliterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromHectolitersPerMinute(double hectolitersperminute) => new VolumeFlow(hectolitersperminute, VolumeFlowUnit.HectoliterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.HectoliterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromHectolitersPerSecond(double hectoliterspersecond) => new VolumeFlow(hectoliterspersecond, VolumeFlowUnit.HectoliterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromKilolitersPerDay(double kilolitersperday) => new VolumeFlow(kilolitersperday, VolumeFlowUnit.KiloliterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromKilolitersPerHour(double kilolitersperhour) => new VolumeFlow(kilolitersperhour, VolumeFlowUnit.KiloliterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromKilolitersPerMinute(double kilolitersperminute) => new VolumeFlow(kilolitersperminute, VolumeFlowUnit.KiloliterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromKilolitersPerSecond(double kiloliterspersecond) => new VolumeFlow(kiloliterspersecond, VolumeFlowUnit.KiloliterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KilousGallonPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromKilousGallonsPerMinute(double kilousgallonsperminute) => new VolumeFlow(kilousgallonsperminute, VolumeFlowUnit.KilousGallonPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromLitersPerDay(double litersperday) => new VolumeFlow(litersperday, VolumeFlowUnit.LiterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromLitersPerHour(double litersperhour) => new VolumeFlow(litersperhour, VolumeFlowUnit.LiterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromLitersPerMinute(double litersperminute) => new VolumeFlow(litersperminute, VolumeFlowUnit.LiterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromLitersPerSecond(double literspersecond) => new VolumeFlow(literspersecond, VolumeFlowUnit.LiterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromMegalitersPerDay(double megalitersperday) => new VolumeFlow(megalitersperday, VolumeFlowUnit.MegaliterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromMegalitersPerHour(double megalitersperhour) => new VolumeFlow(megalitersperhour, VolumeFlowUnit.MegaliterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromMegalitersPerMinute(double megalitersperminute) => new VolumeFlow(megalitersperminute, VolumeFlowUnit.MegaliterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromMegalitersPerSecond(double megaliterspersecond) => new VolumeFlow(megaliterspersecond, VolumeFlowUnit.MegaliterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaukGallonPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromMegaukGallonsPerDay(double megaukgallonsperday) => new VolumeFlow(megaukgallonsperday, VolumeFlowUnit.MegaukGallonPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaukGallonPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromMegaukGallonsPerSecond(double megaukgallonspersecond) => new VolumeFlow(megaukgallonspersecond, VolumeFlowUnit.MegaukGallonPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegausGallonPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromMegausGallonsPerDay(double megausgallonsperday) => new VolumeFlow(megausgallonsperday, VolumeFlowUnit.MegausGallonPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromMicrolitersPerDay(double microlitersperday) => new VolumeFlow(microlitersperday, VolumeFlowUnit.MicroliterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromMicrolitersPerHour(double microlitersperhour) => new VolumeFlow(microlitersperhour, VolumeFlowUnit.MicroliterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromMicrolitersPerMinute(double microlitersperminute) => new VolumeFlow(microlitersperminute, VolumeFlowUnit.MicroliterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromMicrolitersPerSecond(double microliterspersecond) => new VolumeFlow(microliterspersecond, VolumeFlowUnit.MicroliterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromMillilitersPerDay(double millilitersperday) => new VolumeFlow(millilitersperday, VolumeFlowUnit.MilliliterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromMillilitersPerHour(double millilitersperhour) => new VolumeFlow(millilitersperhour, VolumeFlowUnit.MilliliterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromMillilitersPerMinute(double millilitersperminute) => new VolumeFlow(millilitersperminute, VolumeFlowUnit.MilliliterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromMillilitersPerSecond(double milliliterspersecond) => new VolumeFlow(milliliterspersecond, VolumeFlowUnit.MilliliterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MillionUsGallonPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromMillionUsGallonsPerDay(double millionusgallonsperday) => new VolumeFlow(millionusgallonsperday, VolumeFlowUnit.MillionUsGallonPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromNanolitersPerDay(double nanolitersperday) => new VolumeFlow(nanolitersperday, VolumeFlowUnit.NanoliterPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromNanolitersPerHour(double nanolitersperhour) => new VolumeFlow(nanolitersperhour, VolumeFlowUnit.NanoliterPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromNanolitersPerMinute(double nanolitersperminute) => new VolumeFlow(nanolitersperminute, VolumeFlowUnit.NanoliterPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromNanolitersPerSecond(double nanoliterspersecond) => new VolumeFlow(nanoliterspersecond, VolumeFlowUnit.NanoliterPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromOilBarrelsPerDay(double oilbarrelsperday) => new VolumeFlow(oilbarrelsperday, VolumeFlowUnit.OilBarrelPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromOilBarrelsPerHour(double oilbarrelsperhour) => new VolumeFlow(oilbarrelsperhour, VolumeFlowUnit.OilBarrelPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromOilBarrelsPerMinute(double oilbarrelsperminute) => new VolumeFlow(oilbarrelsperminute, VolumeFlowUnit.OilBarrelPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromOilBarrelsPerSecond(double oilbarrelspersecond) => new VolumeFlow(oilbarrelspersecond, VolumeFlowUnit.OilBarrelPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromUkGallonsPerDay(double ukgallonsperday) => new VolumeFlow(ukgallonsperday, VolumeFlowUnit.UkGallonPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromUkGallonsPerHour(double ukgallonsperhour) => new VolumeFlow(ukgallonsperhour, VolumeFlowUnit.UkGallonPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromUkGallonsPerMinute(double ukgallonsperminute) => new VolumeFlow(ukgallonsperminute, VolumeFlowUnit.UkGallonPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromUkGallonsPerSecond(double ukgallonspersecond) => new VolumeFlow(ukgallonspersecond, VolumeFlowUnit.UkGallonPerSecond);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerDay"/>.
-        /// </summary>
-        public static VolumeFlow FromUsGallonsPerDay(double usgallonsperday) => new VolumeFlow(usgallonsperday, VolumeFlowUnit.UsGallonPerDay);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerHour"/>.
-        /// </summary>
-        public static VolumeFlow FromUsGallonsPerHour(double usgallonsperhour) => new VolumeFlow(usgallonsperhour, VolumeFlowUnit.UsGallonPerHour);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerMinute"/>.
-        /// </summary>
-        public static VolumeFlow FromUsGallonsPerMinute(double usgallonsperminute) => new VolumeFlow(usgallonsperminute, VolumeFlowUnit.UsGallonPerMinute);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerSecond"/>.
-        /// </summary>
-        public static VolumeFlow FromUsGallonsPerSecond(double usgallonspersecond) => new VolumeFlow(usgallonspersecond, VolumeFlowUnit.UsGallonPerSecond);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VolumeFlowUnit" /> to <see cref="VolumeFlow" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>VolumeFlow unit value.</returns>
-        public static VolumeFlow From(double value, VolumeFlowUnit fromUnit)
-        {
-            return new VolumeFlow(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(VolumeFlowUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this VolumeFlow to another VolumeFlow with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A VolumeFlow with the specified unit.</returns>
-                public VolumeFlow ToUnit(VolumeFlowUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new VolumeFlow(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        VolumeFlowUnit.AcreFootPerDay => _value * 1233.48183754752 / 86400,
-                        VolumeFlowUnit.AcreFootPerHour => _value * 1233.48183754752 / 3600,
-                        VolumeFlowUnit.AcreFootPerMinute => _value * 1233.48183754752 / 60,
-                        VolumeFlowUnit.AcreFootPerSecond => _value * 1233.48183754752,
-                        VolumeFlowUnit.CentiliterPerDay => (_value / (1000 * 86400)) * 1e-2d,
-                        VolumeFlowUnit.CentiliterPerHour => (_value / (1000 * 3600)) * 1e-2d,
-                        VolumeFlowUnit.CentiliterPerMinute => (_value / (1000 * 60)) * 1e-2d,
-                        VolumeFlowUnit.CentiliterPerSecond => (_value / 1000) * 1e-2d,
-                        VolumeFlowUnit.CubicCentimeterPerMinute => _value * 1e-6 / 60,
-                        VolumeFlowUnit.CubicDecimeterPerMinute => _value / 60000.00000,
-                        VolumeFlowUnit.CubicFootPerHour => _value * 0.028316846592 / 3600,
-                        VolumeFlowUnit.CubicFootPerMinute => _value * 0.028316846592 / 60,
-                        VolumeFlowUnit.CubicFootPerSecond => _value * 0.028316846592,
-                        VolumeFlowUnit.CubicMeterPerDay => _value / 86400,
-                        VolumeFlowUnit.CubicMeterPerHour => _value / 3600,
-                        VolumeFlowUnit.CubicMeterPerMinute => _value / 60,
-                        VolumeFlowUnit.CubicMeterPerSecond => _value,
-                        VolumeFlowUnit.CubicMillimeterPerSecond => _value * 1e-9,
-                        VolumeFlowUnit.CubicYardPerDay => _value * 0.764554857984 / 86400,
-                        VolumeFlowUnit.CubicYardPerHour => _value * 0.764554857984 / 3600,
-                        VolumeFlowUnit.CubicYardPerMinute => _value * 0.764554857984 / 60,
-                        VolumeFlowUnit.CubicYardPerSecond => _value * 0.764554857984,
-                        VolumeFlowUnit.DecaliterPerDay => (_value / (1000 * 86400)) * 1e1d,
-                        VolumeFlowUnit.DecaliterPerHour => (_value / (1000 * 3600)) * 1e1d,
-                        VolumeFlowUnit.DecaliterPerMinute => (_value / (1000 * 60)) * 1e1d,
-                        VolumeFlowUnit.DecaliterPerSecond => (_value / 1000) * 1e1d,
-                        VolumeFlowUnit.DeciliterPerDay => (_value / (1000 * 86400)) * 1e-1d,
-                        VolumeFlowUnit.DeciliterPerHour => (_value / (1000 * 3600)) * 1e-1d,
-                        VolumeFlowUnit.DeciliterPerMinute => (_value / (1000 * 60)) * 1e-1d,
-                        VolumeFlowUnit.DeciliterPerSecond => (_value / 1000) * 1e-1d,
-                        VolumeFlowUnit.HectoliterPerDay => (_value / (1000 * 86400)) * 1e2d,
-                        VolumeFlowUnit.HectoliterPerHour => (_value / (1000 * 3600)) * 1e2d,
-                        VolumeFlowUnit.HectoliterPerMinute => (_value / (1000 * 60)) * 1e2d,
-                        VolumeFlowUnit.HectoliterPerSecond => (_value / 1000) * 1e2d,
-                        VolumeFlowUnit.KiloliterPerDay => (_value / (1000 * 86400)) * 1e3d,
-                        VolumeFlowUnit.KiloliterPerHour => (_value / (1000 * 3600)) * 1e3d,
-                        VolumeFlowUnit.KiloliterPerMinute => (_value / (1000 * 60)) * 1e3d,
-                        VolumeFlowUnit.KiloliterPerSecond => (_value / 1000) * 1e3d,
-                        VolumeFlowUnit.KilousGallonPerMinute => _value * 1000 * 0.003785411784 / 60,
-                        VolumeFlowUnit.LiterPerDay => _value / (1000 * 86400),
-                        VolumeFlowUnit.LiterPerHour => _value / (1000 * 3600),
-                        VolumeFlowUnit.LiterPerMinute => _value / (1000 * 60),
-                        VolumeFlowUnit.LiterPerSecond => _value / 1000,
-                        VolumeFlowUnit.MegaliterPerDay => (_value / (1000 * 86400)) * 1e6d,
-                        VolumeFlowUnit.MegaliterPerHour => (_value / (1000 * 3600)) * 1e6d,
-                        VolumeFlowUnit.MegaliterPerMinute => (_value / (1000 * 60)) * 1e6d,
-                        VolumeFlowUnit.MegaliterPerSecond => (_value / 1000) * 1e6d,
-                        VolumeFlowUnit.MegaukGallonPerDay => (_value * 0.00454609 / 86400) * 1e6d,
-                        VolumeFlowUnit.MegaukGallonPerSecond => (_value * 0.00454609) * 1e6d,
-                        VolumeFlowUnit.MegausGallonPerDay => (_value * 0.003785411784 / 86400) * 1e6d,
-                        VolumeFlowUnit.MicroliterPerDay => (_value / (1000 * 86400)) * 1e-6d,
-                        VolumeFlowUnit.MicroliterPerHour => (_value / (1000 * 3600)) * 1e-6d,
-                        VolumeFlowUnit.MicroliterPerMinute => (_value / (1000 * 60)) * 1e-6d,
-                        VolumeFlowUnit.MicroliterPerSecond => (_value / 1000) * 1e-6d,
-                        VolumeFlowUnit.MilliliterPerDay => (_value / (1000 * 86400)) * 1e-3d,
-                        VolumeFlowUnit.MilliliterPerHour => (_value / (1000 * 3600)) * 1e-3d,
-                        VolumeFlowUnit.MilliliterPerMinute => (_value / (1000 * 60)) * 1e-3d,
-                        VolumeFlowUnit.MilliliterPerSecond => (_value / 1000) * 1e-3d,
-                        VolumeFlowUnit.MillionUsGallonPerDay => _value * 1e6 * 0.003785411784 / 86400,
-                        VolumeFlowUnit.NanoliterPerDay => (_value / (1000 * 86400)) * 1e-9d,
-                        VolumeFlowUnit.NanoliterPerHour => (_value / (1000 * 3600)) * 1e-9d,
-                        VolumeFlowUnit.NanoliterPerMinute => (_value / (1000 * 60)) * 1e-9d,
-                        VolumeFlowUnit.NanoliterPerSecond => (_value / 1000) * 1e-9d,
-                        VolumeFlowUnit.OilBarrelPerDay => _value * 0.158987294928 / 86400,
-                        VolumeFlowUnit.OilBarrelPerHour => _value * 0.158987294928 / 3600,
-                        VolumeFlowUnit.OilBarrelPerMinute => _value * 0.158987294928 / 60,
-                        VolumeFlowUnit.OilBarrelPerSecond => _value * 0.158987294928,
-                        VolumeFlowUnit.UkGallonPerDay => _value * 0.00454609 / 86400,
-                        VolumeFlowUnit.UkGallonPerHour => _value * 0.00454609 / 3600,
-                        VolumeFlowUnit.UkGallonPerMinute => _value * 0.00454609 / 60,
-                        VolumeFlowUnit.UkGallonPerSecond => _value * 0.00454609,
-                        VolumeFlowUnit.UsGallonPerDay => _value * 0.003785411784 / 86400,
-                        VolumeFlowUnit.UsGallonPerHour => _value * 0.003785411784 / 3600,
-                        VolumeFlowUnit.UsGallonPerMinute => _value * 0.003785411784 / 60,
-                        VolumeFlowUnit.UsGallonPerSecond => _value * 0.003785411784,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(VolumeFlowUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        VolumeFlowUnit.AcreFootPerDay => baseUnitValue / (1233.48183754752 / 86400),
-                        VolumeFlowUnit.AcreFootPerHour => baseUnitValue / (1233.48183754752 / 3600),
-                        VolumeFlowUnit.AcreFootPerMinute => baseUnitValue / (1233.48183754752 / 60),
-                        VolumeFlowUnit.AcreFootPerSecond => baseUnitValue / 1233.48183754752,
-                        VolumeFlowUnit.CentiliterPerDay => (baseUnitValue * (1000 * 86400)) / 1e-2d,
-                        VolumeFlowUnit.CentiliterPerHour => (baseUnitValue * (1000 * 3600)) / 1e-2d,
-                        VolumeFlowUnit.CentiliterPerMinute => (baseUnitValue * (1000 * 60)) / 1e-2d,
-                        VolumeFlowUnit.CentiliterPerSecond => (baseUnitValue * 1000) / 1e-2d,
-                        VolumeFlowUnit.CubicCentimeterPerMinute => baseUnitValue / (1e-6 / 60),
-                        VolumeFlowUnit.CubicDecimeterPerMinute => baseUnitValue * 60000.00000,
-                        VolumeFlowUnit.CubicFootPerHour => baseUnitValue / (0.028316846592 / 3600),
-                        VolumeFlowUnit.CubicFootPerMinute => baseUnitValue / (0.028316846592 / 60),
-                        VolumeFlowUnit.CubicFootPerSecond => baseUnitValue / 0.028316846592,
-                        VolumeFlowUnit.CubicMeterPerDay => baseUnitValue * 86400,
-                        VolumeFlowUnit.CubicMeterPerHour => baseUnitValue * 3600,
-                        VolumeFlowUnit.CubicMeterPerMinute => baseUnitValue * 60,
-                        VolumeFlowUnit.CubicMeterPerSecond => baseUnitValue,
-                        VolumeFlowUnit.CubicMillimeterPerSecond => baseUnitValue / 1e-9,
-                        VolumeFlowUnit.CubicYardPerDay => baseUnitValue / (0.764554857984 / 86400),
-                        VolumeFlowUnit.CubicYardPerHour => baseUnitValue / (0.764554857984 / 3600),
-                        VolumeFlowUnit.CubicYardPerMinute => baseUnitValue / (0.764554857984 / 60),
-                        VolumeFlowUnit.CubicYardPerSecond => baseUnitValue / 0.764554857984,
-                        VolumeFlowUnit.DecaliterPerDay => (baseUnitValue * (1000 * 86400)) / 1e1d,
-                        VolumeFlowUnit.DecaliterPerHour => (baseUnitValue * (1000 * 3600)) / 1e1d,
-                        VolumeFlowUnit.DecaliterPerMinute => (baseUnitValue * (1000 * 60)) / 1e1d,
-                        VolumeFlowUnit.DecaliterPerSecond => (baseUnitValue * 1000) / 1e1d,
-                        VolumeFlowUnit.DeciliterPerDay => (baseUnitValue * (1000 * 86400)) / 1e-1d,
-                        VolumeFlowUnit.DeciliterPerHour => (baseUnitValue * (1000 * 3600)) / 1e-1d,
-                        VolumeFlowUnit.DeciliterPerMinute => (baseUnitValue * (1000 * 60)) / 1e-1d,
-                        VolumeFlowUnit.DeciliterPerSecond => (baseUnitValue * 1000) / 1e-1d,
-                        VolumeFlowUnit.HectoliterPerDay => (baseUnitValue * (1000 * 86400)) / 1e2d,
-                        VolumeFlowUnit.HectoliterPerHour => (baseUnitValue * (1000 * 3600)) / 1e2d,
-                        VolumeFlowUnit.HectoliterPerMinute => (baseUnitValue * (1000 * 60)) / 1e2d,
-                        VolumeFlowUnit.HectoliterPerSecond => (baseUnitValue * 1000) / 1e2d,
-                        VolumeFlowUnit.KiloliterPerDay => (baseUnitValue * (1000 * 86400)) / 1e3d,
-                        VolumeFlowUnit.KiloliterPerHour => (baseUnitValue * (1000 * 3600)) / 1e3d,
-                        VolumeFlowUnit.KiloliterPerMinute => (baseUnitValue * (1000 * 60)) / 1e3d,
-                        VolumeFlowUnit.KiloliterPerSecond => (baseUnitValue * 1000) / 1e3d,
-                        VolumeFlowUnit.KilousGallonPerMinute => baseUnitValue / (1000 * 0.003785411784 / 60),
-                        VolumeFlowUnit.LiterPerDay => baseUnitValue * (1000 * 86400),
-                        VolumeFlowUnit.LiterPerHour => baseUnitValue * (1000 * 3600),
-                        VolumeFlowUnit.LiterPerMinute => baseUnitValue * (1000 * 60),
-                        VolumeFlowUnit.LiterPerSecond => baseUnitValue * 1000,
-                        VolumeFlowUnit.MegaliterPerDay => (baseUnitValue * (1000 * 86400)) / 1e6d,
-                        VolumeFlowUnit.MegaliterPerHour => (baseUnitValue * (1000 * 3600)) / 1e6d,
-                        VolumeFlowUnit.MegaliterPerMinute => (baseUnitValue * (1000 * 60)) / 1e6d,
-                        VolumeFlowUnit.MegaliterPerSecond => (baseUnitValue * 1000) / 1e6d,
-                        VolumeFlowUnit.MegaukGallonPerDay => (baseUnitValue / (0.00454609 / 86400)) / 1e6d,
-                        VolumeFlowUnit.MegaukGallonPerSecond => (baseUnitValue / 0.00454609) / 1e6d,
-                        VolumeFlowUnit.MegausGallonPerDay => (baseUnitValue / (0.003785411784 / 86400)) / 1e6d,
-                        VolumeFlowUnit.MicroliterPerDay => (baseUnitValue * (1000 * 86400)) / 1e-6d,
-                        VolumeFlowUnit.MicroliterPerHour => (baseUnitValue * (1000 * 3600)) / 1e-6d,
-                        VolumeFlowUnit.MicroliterPerMinute => (baseUnitValue * (1000 * 60)) / 1e-6d,
-                        VolumeFlowUnit.MicroliterPerSecond => (baseUnitValue * 1000) / 1e-6d,
-                        VolumeFlowUnit.MilliliterPerDay => (baseUnitValue * (1000 * 86400)) / 1e-3d,
-                        VolumeFlowUnit.MilliliterPerHour => (baseUnitValue * (1000 * 3600)) / 1e-3d,
-                        VolumeFlowUnit.MilliliterPerMinute => (baseUnitValue * (1000 * 60)) / 1e-3d,
-                        VolumeFlowUnit.MilliliterPerSecond => (baseUnitValue * 1000) / 1e-3d,
-                        VolumeFlowUnit.MillionUsGallonPerDay => baseUnitValue / (1e6 * 0.003785411784 / 86400),
-                        VolumeFlowUnit.NanoliterPerDay => (baseUnitValue * (1000 * 86400)) / 1e-9d,
-                        VolumeFlowUnit.NanoliterPerHour => (baseUnitValue * (1000 * 3600)) / 1e-9d,
-                        VolumeFlowUnit.NanoliterPerMinute => (baseUnitValue * (1000 * 60)) / 1e-9d,
-                        VolumeFlowUnit.NanoliterPerSecond => (baseUnitValue * 1000) / 1e-9d,
-                        VolumeFlowUnit.OilBarrelPerDay => baseUnitValue / (0.158987294928 / 86400),
-                        VolumeFlowUnit.OilBarrelPerHour => baseUnitValue / (0.158987294928 / 3600),
-                        VolumeFlowUnit.OilBarrelPerMinute => baseUnitValue / (0.158987294928 / 60),
-                        VolumeFlowUnit.OilBarrelPerSecond => baseUnitValue / 0.158987294928,
-                        VolumeFlowUnit.UkGallonPerDay => baseUnitValue / (0.00454609 / 86400),
-                        VolumeFlowUnit.UkGallonPerHour => baseUnitValue / (0.00454609 / 3600),
-                        VolumeFlowUnit.UkGallonPerMinute => baseUnitValue / (0.00454609 / 60),
-                        VolumeFlowUnit.UkGallonPerSecond => baseUnitValue / 0.00454609,
-                        VolumeFlowUnit.UsGallonPerDay => baseUnitValue / (0.003785411784 / 86400),
-                        VolumeFlowUnit.UsGallonPerHour => baseUnitValue / (0.003785411784 / 3600),
-                        VolumeFlowUnit.UsGallonPerMinute => baseUnitValue / (0.003785411784 / 60),
-                        VolumeFlowUnit.UsGallonPerSecond => baseUnitValue / 0.003785411784,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
deleted file mode 100644
index 1da095f1c0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
+++ /dev/null
@@ -1,169 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     
-    /// </summary>
-    public struct  VolumeFlowPerArea
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly VolumeFlowPerAreaUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public VolumeFlowPerAreaUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VolumeFlowPerArea(double value, VolumeFlowPerAreaUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of VolumeFlowPerArea, which is Second. All conversions go via this value.
-        /// </summary>
-        public static VolumeFlowPerAreaUnit BaseUnit { get; } = VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of VolumeFlowPerArea.
-        /// </summary>
-        public static VolumeFlowPerArea MaxValue { get; } = new VolumeFlowPerArea(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of VolumeFlowPerArea.
-        /// </summary>
-        public static VolumeFlowPerArea MinValue { get; } = new VolumeFlowPerArea(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static VolumeFlowPerArea Zero { get; } = new VolumeFlowPerArea(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot"/>
-        /// </summary>
-        public double CubicFeetPerMinutePerSquareFoot => As(VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter"/>
-        /// </summary>
-        public double CubicMetersPerSecondPerSquareMeter => As(VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlowPerArea"/> from <see cref="VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot"/>.
-        /// </summary>
-        public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(double cubicfeetperminutepersquarefoot) => new VolumeFlowPerArea(cubicfeetperminutepersquarefoot, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumeFlowPerArea"/> from <see cref="VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter"/>.
-        /// </summary>
-        public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(double cubicmeterspersecondpersquaremeter) => new VolumeFlowPerArea(cubicmeterspersecondpersquaremeter, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VolumeFlowPerAreaUnit" /> to <see cref="VolumeFlowPerArea" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>VolumeFlowPerArea unit value.</returns>
-        public static VolumeFlowPerArea From(double value, VolumeFlowPerAreaUnit fromUnit)
-        {
-            return new VolumeFlowPerArea(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(VolumeFlowPerAreaUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this VolumeFlowPerArea to another VolumeFlowPerArea with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A VolumeFlowPerArea with the specified unit.</returns>
-                public VolumeFlowPerArea ToUnit(VolumeFlowPerAreaUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new VolumeFlowPerArea(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot => _value * (0.028316846592 / 60) / 9.290304e-2,
-                        VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter => _value,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(VolumeFlowPerAreaUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot => baseUnitValue * 9.290304e-2 / (0.028316846592 / 60),
-                        VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter => baseUnitValue,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumePerLength.g.cs
deleted file mode 100644
index 5e103e7663..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumePerLength.g.cs
+++ /dev/null
@@ -1,253 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     Volume, typically of fluid, that a container can hold within a unit of length.
-    /// </summary>
-    public struct  VolumePerLength
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly VolumePerLengthUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public VolumePerLengthUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VolumePerLength(double value, VolumePerLengthUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of VolumePerLength, which is Second. All conversions go via this value.
-        /// </summary>
-        public static VolumePerLengthUnit BaseUnit { get; } = VolumePerLengthUnit.CubicMeterPerMeter;
-
-        /// <summary>
-        /// Represents the largest possible value of VolumePerLength.
-        /// </summary>
-        public static VolumePerLength MaxValue { get; } = new VolumePerLength(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of VolumePerLength.
-        /// </summary>
-        public static VolumePerLength MinValue { get; } = new VolumePerLength(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static VolumePerLength Zero { get; } = new VolumePerLength(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.CubicMeterPerMeter"/>
-        /// </summary>
-        public double CubicMetersPerMeter => As(VolumePerLengthUnit.CubicMeterPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.CubicYardPerFoot"/>
-        /// </summary>
-        public double CubicYardsPerFoot => As(VolumePerLengthUnit.CubicYardPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.CubicYardPerUsSurveyFoot"/>
-        /// </summary>
-        public double CubicYardsPerUsSurveyFoot => As(VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.ImperialGallonPerMile"/>
-        /// </summary>
-        public double ImperialGallonsPerMile => As(VolumePerLengthUnit.ImperialGallonPerMile);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.LiterPerKilometer"/>
-        /// </summary>
-        public double LitersPerKilometer => As(VolumePerLengthUnit.LiterPerKilometer);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.LiterPerMeter"/>
-        /// </summary>
-        public double LitersPerMeter => As(VolumePerLengthUnit.LiterPerMeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.LiterPerMillimeter"/>
-        /// </summary>
-        public double LitersPerMillimeter => As(VolumePerLengthUnit.LiterPerMillimeter);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.OilBarrelPerFoot"/>
-        /// </summary>
-        public double OilBarrelsPerFoot => As(VolumePerLengthUnit.OilBarrelPerFoot);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.UsGallonPerMile"/>
-        /// </summary>
-        public double UsGallonsPerMile => As(VolumePerLengthUnit.UsGallonPerMile);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicMeterPerMeter"/>.
-        /// </summary>
-        public static VolumePerLength FromCubicMetersPerMeter(double cubicmeterspermeter) => new VolumePerLength(cubicmeterspermeter, VolumePerLengthUnit.CubicMeterPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicYardPerFoot"/>.
-        /// </summary>
-        public static VolumePerLength FromCubicYardsPerFoot(double cubicyardsperfoot) => new VolumePerLength(cubicyardsperfoot, VolumePerLengthUnit.CubicYardPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicYardPerUsSurveyFoot"/>.
-        /// </summary>
-        public static VolumePerLength FromCubicYardsPerUsSurveyFoot(double cubicyardsperussurveyfoot) => new VolumePerLength(cubicyardsperussurveyfoot, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.ImperialGallonPerMile"/>.
-        /// </summary>
-        public static VolumePerLength FromImperialGallonsPerMile(double imperialgallonspermile) => new VolumePerLength(imperialgallonspermile, VolumePerLengthUnit.ImperialGallonPerMile);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerKilometer"/>.
-        /// </summary>
-        public static VolumePerLength FromLitersPerKilometer(double litersperkilometer) => new VolumePerLength(litersperkilometer, VolumePerLengthUnit.LiterPerKilometer);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerMeter"/>.
-        /// </summary>
-        public static VolumePerLength FromLitersPerMeter(double literspermeter) => new VolumePerLength(literspermeter, VolumePerLengthUnit.LiterPerMeter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerMillimeter"/>.
-        /// </summary>
-        public static VolumePerLength FromLitersPerMillimeter(double literspermillimeter) => new VolumePerLength(literspermillimeter, VolumePerLengthUnit.LiterPerMillimeter);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.OilBarrelPerFoot"/>.
-        /// </summary>
-        public static VolumePerLength FromOilBarrelsPerFoot(double oilbarrelsperfoot) => new VolumePerLength(oilbarrelsperfoot, VolumePerLengthUnit.OilBarrelPerFoot);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.UsGallonPerMile"/>.
-        /// </summary>
-        public static VolumePerLength FromUsGallonsPerMile(double usgallonspermile) => new VolumePerLength(usgallonspermile, VolumePerLengthUnit.UsGallonPerMile);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VolumePerLengthUnit" /> to <see cref="VolumePerLength" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>VolumePerLength unit value.</returns>
-        public static VolumePerLength From(double value, VolumePerLengthUnit fromUnit)
-        {
-            return new VolumePerLength(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(VolumePerLengthUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this VolumePerLength to another VolumePerLength with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A VolumePerLength with the specified unit.</returns>
-                public VolumePerLength ToUnit(VolumePerLengthUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new VolumePerLength(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        VolumePerLengthUnit.CubicMeterPerMeter => _value,
-                        VolumePerLengthUnit.CubicYardPerFoot => _value * 0.764554857984 / 0.3048,
-                        VolumePerLengthUnit.CubicYardPerUsSurveyFoot => _value * 0.764554857984 * 3937 / 1200,
-                        VolumePerLengthUnit.ImperialGallonPerMile => _value * 0.00454609 / 1609.344,
-                        VolumePerLengthUnit.LiterPerKilometer => _value / 1e6,
-                        VolumePerLengthUnit.LiterPerMeter => _value / 1000,
-                        VolumePerLengthUnit.LiterPerMillimeter => _value,
-                        VolumePerLengthUnit.OilBarrelPerFoot => _value * 0.158987294928 / 0.3048,
-                        VolumePerLengthUnit.UsGallonPerMile => _value * 0.003785411784 / 1609.344,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(VolumePerLengthUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        VolumePerLengthUnit.CubicMeterPerMeter => baseUnitValue,
-                        VolumePerLengthUnit.CubicYardPerFoot => baseUnitValue * 0.3048 / 0.764554857984,
-                        VolumePerLengthUnit.CubicYardPerUsSurveyFoot => baseUnitValue * 1200 / (0.764554857984 * 3937),
-                        VolumePerLengthUnit.ImperialGallonPerMile => baseUnitValue * 1609.344 / 0.00454609,
-                        VolumePerLengthUnit.LiterPerKilometer => baseUnitValue * 1e6,
-                        VolumePerLengthUnit.LiterPerMeter => baseUnitValue * 1000,
-                        VolumePerLengthUnit.LiterPerMillimeter => baseUnitValue,
-                        VolumePerLengthUnit.OilBarrelPerFoot => baseUnitValue * 0.3048 / 0.158987294928,
-                        VolumePerLengthUnit.UsGallonPerMile => baseUnitValue * 1609.344 / 0.003785411784,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
deleted file mode 100644
index 203048c263..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
+++ /dev/null
@@ -1,256 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     The volumetric heat capacity is the amount of energy that must be added, in the form of heat, to one unit of volume of the material in order to cause an increase of one unit in its temperature.
-    /// </summary>
-    /// <remarks>
-    ///     https://en.wikipedia.org/wiki/Volumetric_heat_capacity
-    /// </remarks>
-    public struct  VolumetricHeatCapacity
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly VolumetricHeatCapacityUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public VolumetricHeatCapacityUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VolumetricHeatCapacity(double value, VolumetricHeatCapacityUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of VolumetricHeatCapacity, which is Second. All conversions go via this value.
-        /// </summary>
-        public static VolumetricHeatCapacityUnit BaseUnit { get; } = VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin;
-
-        /// <summary>
-        /// Represents the largest possible value of VolumetricHeatCapacity.
-        /// </summary>
-        public static VolumetricHeatCapacity MaxValue { get; } = new VolumetricHeatCapacity(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of VolumetricHeatCapacity.
-        /// </summary>
-        public static VolumetricHeatCapacity MinValue { get; } = new VolumetricHeatCapacity(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static VolumetricHeatCapacity Zero { get; } = new VolumetricHeatCapacity(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit"/>
-        /// </summary>
-        public double BtusPerCubicFootDegreeFahrenheit => As(VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius"/>
-        /// </summary>
-        public double CaloriesPerCubicCentimeterDegreeCelsius => As(VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius"/>
-        /// </summary>
-        public double JoulesPerCubicMeterDegreeCelsius => As(VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin"/>
-        /// </summary>
-        public double JoulesPerCubicMeterKelvin => As(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius"/>
-        /// </summary>
-        public double KilocaloriesPerCubicCentimeterDegreeCelsius => As(VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius"/>
-        /// </summary>
-        public double KilojoulesPerCubicMeterDegreeCelsius => As(VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin"/>
-        /// </summary>
-        public double KilojoulesPerCubicMeterKelvin => As(VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius"/>
-        /// </summary>
-        public double MegajoulesPerCubicMeterDegreeCelsius => As(VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin"/>
-        /// </summary>
-        public double MegajoulesPerCubicMeterKelvin => As(VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit"/>.
-        /// </summary>
-        public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(double btuspercubicfootdegreefahrenheit) => new VolumetricHeatCapacity(btuspercubicfootdegreefahrenheit, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius"/>.
-        /// </summary>
-        public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius(double caloriespercubiccentimeterdegreecelsius) => new VolumetricHeatCapacity(caloriespercubiccentimeterdegreecelsius, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius"/>.
-        /// </summary>
-        public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(double joulespercubicmeterdegreecelsius) => new VolumetricHeatCapacity(joulespercubicmeterdegreecelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin"/>.
-        /// </summary>
-        public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(double joulespercubicmeterkelvin) => new VolumetricHeatCapacity(joulespercubicmeterkelvin, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius"/>.
-        /// </summary>
-        public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCelsius(double kilocaloriespercubiccentimeterdegreecelsius) => new VolumetricHeatCapacity(kilocaloriespercubiccentimeterdegreecelsius, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius"/>.
-        /// </summary>
-        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(double kilojoulespercubicmeterdegreecelsius) => new VolumetricHeatCapacity(kilojoulespercubicmeterdegreecelsius, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin"/>.
-        /// </summary>
-        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(double kilojoulespercubicmeterkelvin) => new VolumetricHeatCapacity(kilojoulespercubicmeterkelvin, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius"/>.
-        /// </summary>
-        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(double megajoulespercubicmeterdegreecelsius) => new VolumetricHeatCapacity(megajoulespercubicmeterdegreecelsius, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius);
-
-        /// <summary>
-        ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin"/>.
-        /// </summary>
-        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(double megajoulespercubicmeterkelvin) => new VolumetricHeatCapacity(megajoulespercubicmeterkelvin, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="VolumetricHeatCapacityUnit" /> to <see cref="VolumetricHeatCapacity" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>VolumetricHeatCapacity unit value.</returns>
-        public static VolumetricHeatCapacity From(double value, VolumetricHeatCapacityUnit fromUnit)
-        {
-            return new VolumetricHeatCapacity(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(VolumetricHeatCapacityUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this VolumetricHeatCapacity to another VolumetricHeatCapacity with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A VolumetricHeatCapacity with the specified unit.</returns>
-                public VolumetricHeatCapacity ToUnit(VolumetricHeatCapacityUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new VolumetricHeatCapacity(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit => _value * (1055.05585262 / 0.028316846592) * 1.8,
-                        VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius => _value * 4.184e6,
-                        VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius => _value,
-                        VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin => _value,
-                        VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius => (_value * 4.184e6) * 1e3d,
-                        VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius => (_value) * 1e3d,
-                        VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin => (_value) * 1e3d,
-                        VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius => (_value) * 1e6d,
-                        VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin => (_value) * 1e6d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(VolumetricHeatCapacityUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit => baseUnitValue / ((1055.05585262 / 0.028316846592) * 1.8),
-                        VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius => baseUnitValue / 4.184e6,
-                        VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius => baseUnitValue,
-                        VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin => baseUnitValue,
-                        VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius => (baseUnitValue / 4.184e6) / 1e3d,
-                        VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius => (baseUnitValue) / 1e3d,
-                        VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin => (baseUnitValue) / 1e3d,
-                        VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius => (baseUnitValue) / 1e6d,
-                        VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin => (baseUnitValue) / 1e6d,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
deleted file mode 100644
index 86f06ab93a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
+++ /dev/null
@@ -1,217 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <inheritdoc />
-    /// <summary>
-    ///     A geometric property of an area that is used to determine the warping stress.
-    /// </summary>
-    public struct  WarpingMomentOfInertia
-    {
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        private readonly double _value;
-
-        /// <summary>
-        ///     The unit this quantity was constructed with.
-        /// </summary>
-        private readonly WarpingMomentOfInertiaUnit _unit;
-
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
-
-        /// <inheritdoc />
-        public WarpingMomentOfInertiaUnit Unit => _unit;
-
-        /// <summary>
-        ///     Creates the quantity with the given numeric value and unit.
-        /// </summary>
-        /// <param name="value">The numeric value to construct this quantity with.</param>
-        /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public WarpingMomentOfInertia(double value, WarpingMomentOfInertiaUnit unit)
-        {
-            _value = value;
-            _unit = unit;
-        }
-
-        /// <summary>
-        ///     The base unit of WarpingMomentOfInertia, which is Second. All conversions go via this value.
-        /// </summary>
-        public static WarpingMomentOfInertiaUnit BaseUnit { get; } = WarpingMomentOfInertiaUnit.MeterToTheSixth;
-
-        /// <summary>
-        /// Represents the largest possible value of WarpingMomentOfInertia.
-        /// </summary>
-        public static WarpingMomentOfInertia MaxValue { get; } = new WarpingMomentOfInertia(double.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of WarpingMomentOfInertia.
-        /// </summary>
-        public static WarpingMomentOfInertia MinValue { get; } = new WarpingMomentOfInertia(double.MinValue, BaseUnit);
-
-        /// <summary>
-        ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
-        /// </summary>
-        public static WarpingMomentOfInertia Zero { get; } = new WarpingMomentOfInertia(0, BaseUnit);
-        #region Conversion Properties
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.CentimeterToTheSixth"/>
-        /// </summary>
-        public double CentimetersToTheSixth => As(WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.DecimeterToTheSixth"/>
-        /// </summary>
-        public double DecimetersToTheSixth => As(WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.FootToTheSixth"/>
-        /// </summary>
-        public double FeetToTheSixth => As(WarpingMomentOfInertiaUnit.FootToTheSixth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.InchToTheSixth"/>
-        /// </summary>
-        public double InchesToTheSixth => As(WarpingMomentOfInertiaUnit.InchToTheSixth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.MeterToTheSixth"/>
-        /// </summary>
-        public double MetersToTheSixth => As(WarpingMomentOfInertiaUnit.MeterToTheSixth);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.MillimeterToTheSixth"/>
-        /// </summary>
-        public double MillimetersToTheSixth => As(WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
-
-        #endregion
-
-        #region Static Factory Methods
-
-        /// <summary>
-        ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.CentimeterToTheSixth"/>.
-        /// </summary>
-        public static WarpingMomentOfInertia FromCentimetersToTheSixth(double centimeterstothesixth) => new WarpingMomentOfInertia(centimeterstothesixth, WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
-
-        /// <summary>
-        ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.DecimeterToTheSixth"/>.
-        /// </summary>
-        public static WarpingMomentOfInertia FromDecimetersToTheSixth(double decimeterstothesixth) => new WarpingMomentOfInertia(decimeterstothesixth, WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
-
-        /// <summary>
-        ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.FootToTheSixth"/>.
-        /// </summary>
-        public static WarpingMomentOfInertia FromFeetToTheSixth(double feettothesixth) => new WarpingMomentOfInertia(feettothesixth, WarpingMomentOfInertiaUnit.FootToTheSixth);
-
-        /// <summary>
-        ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.InchToTheSixth"/>.
-        /// </summary>
-        public static WarpingMomentOfInertia FromInchesToTheSixth(double inchestothesixth) => new WarpingMomentOfInertia(inchestothesixth, WarpingMomentOfInertiaUnit.InchToTheSixth);
-
-        /// <summary>
-        ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.MeterToTheSixth"/>.
-        /// </summary>
-        public static WarpingMomentOfInertia FromMetersToTheSixth(double meterstothesixth) => new WarpingMomentOfInertia(meterstothesixth, WarpingMomentOfInertiaUnit.MeterToTheSixth);
-
-        /// <summary>
-        ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.MillimeterToTheSixth"/>.
-        /// </summary>
-        public static WarpingMomentOfInertia FromMillimetersToTheSixth(double millimeterstothesixth) => new WarpingMomentOfInertia(millimeterstothesixth, WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
-
-        /// <summary>
-        ///     Dynamically convert from value and unit enum <see cref="WarpingMomentOfInertiaUnit" /> to <see cref="WarpingMomentOfInertia" />.
-        /// </summary>
-        /// <param name="value">Value to convert from.</param>
-        /// <param name="fromUnit">Unit to convert from.</param>
-        /// <returns>WarpingMomentOfInertia unit value.</returns>
-        public static WarpingMomentOfInertia From(double value, WarpingMomentOfInertiaUnit fromUnit)
-        {
-            return new WarpingMomentOfInertia(value, fromUnit);
-        }
-
-        #endregion
-
-                #region Conversion Methods
-
-                /// <summary>
-                ///     Convert to the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>Value converted to the specified unit.</returns>
-                public double As(WarpingMomentOfInertiaUnit unit) => GetValueAs(unit);
-
-                /// <summary>
-                ///     Converts this WarpingMomentOfInertia to another WarpingMomentOfInertia with the unit representation <paramref name="unit" />.
-                /// </summary>
-                /// <returns>A WarpingMomentOfInertia with the specified unit.</returns>
-                public WarpingMomentOfInertia ToUnit(WarpingMomentOfInertiaUnit unit)
-                {
-                    var convertedValue = GetValueAs(unit);
-                    return new WarpingMomentOfInertia(convertedValue, unit);
-                }
-
-                /// <summary>
-                ///     Converts the current value + unit to the base unit.
-                ///     This is typically the first step in converting from one unit to another.
-                /// </summary>
-                /// <returns>The value in the base unit representation.</returns>
-                private double GetValueInBaseUnit()
-                {
-                    return Unit switch
-                    {
-                        WarpingMomentOfInertiaUnit.CentimeterToTheSixth => _value / 1e12,
-                        WarpingMomentOfInertiaUnit.DecimeterToTheSixth => _value / 1e6,
-                        WarpingMomentOfInertiaUnit.FootToTheSixth => _value * 0.000801843800914862014464,
-                        WarpingMomentOfInertiaUnit.InchToTheSixth => _value * 0.000000000268535866540096,
-                        WarpingMomentOfInertiaUnit.MeterToTheSixth => _value,
-                        WarpingMomentOfInertiaUnit.MillimeterToTheSixth => _value / 1e18,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to base units.")
-                    };
-                    }
-
-                private double GetValueAs(WarpingMomentOfInertiaUnit unit)
-                {
-                    if (Unit == unit)
-                        return _value;
-
-                    var baseUnitValue = GetValueInBaseUnit();
-
-                    return unit switch
-                    {
-                        WarpingMomentOfInertiaUnit.CentimeterToTheSixth => baseUnitValue * 1e12,
-                        WarpingMomentOfInertiaUnit.DecimeterToTheSixth => baseUnitValue * 1e6,
-                        WarpingMomentOfInertiaUnit.FootToTheSixth => baseUnitValue / 0.000801843800914862014464,
-                        WarpingMomentOfInertiaUnit.InchToTheSixth => baseUnitValue / 0.000000000268535866540096,
-                        WarpingMomentOfInertiaUnit.MeterToTheSixth => baseUnitValue,
-                        WarpingMomentOfInertiaUnit.MillimeterToTheSixth => baseUnitValue * 1e18,
-                        _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.")
-                    };
-                    }
-
-                #endregion
-    }
-}
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDose/RadiationEquivalentDose.nfproj b/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDose/RadiationEquivalentDose.nfproj
deleted file mode 100644
index 552e257f67..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDose/RadiationEquivalentDose.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{dcdccf04-c930-b455-77a4-d9d4a7df8723}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.RadiationEquivalentDose</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\RadiationEquivalentDose.g.cs" />
-    <Compile Include="..\Units\RadiationEquivalentDoseUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDose/UnitsNet.NanoFramework.RadiationEquivalentDose.nuspec b/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDose/UnitsNet.NanoFramework.RadiationEquivalentDose.nuspec
deleted file mode 100644
index 90fdb4bff5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDose/UnitsNet.NanoFramework.RadiationEquivalentDose.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.RadiationEquivalentDose</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET RadiationEquivalentDose - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds RadiationEquivalentDose units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework radiationequivalentdose unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\RadiationEquivalentDose\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDose/packages.config b/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDose/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDose/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDoseRate/RadiationEquivalentDoseRate.nfproj b/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDoseRate/RadiationEquivalentDoseRate.nfproj
deleted file mode 100644
index a764c389bd..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDoseRate/RadiationEquivalentDoseRate.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{8eec9904-f4bb-c601-86ac-80fb153599f9}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.RadiationEquivalentDoseRate</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\RadiationEquivalentDoseRate.g.cs" />
-    <Compile Include="..\Units\RadiationEquivalentDoseRateUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDoseRate/UnitsNet.NanoFramework.RadiationEquivalentDoseRate.nuspec b/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDoseRate/UnitsNet.NanoFramework.RadiationEquivalentDoseRate.nuspec
deleted file mode 100644
index 8d33db4cc5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDoseRate/UnitsNet.NanoFramework.RadiationEquivalentDoseRate.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.RadiationEquivalentDoseRate</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET RadiationEquivalentDoseRate - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds RadiationEquivalentDoseRate units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework radiationequivalentdoserate unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\RadiationEquivalentDoseRate\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDoseRate/packages.config b/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDoseRate/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RadiationEquivalentDoseRate/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RadiationExposure/RadiationExposure.nfproj b/UnitsNet.NanoFramework/GeneratedCode/RadiationExposure/RadiationExposure.nfproj
deleted file mode 100644
index f2b96d78df..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RadiationExposure/RadiationExposure.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{69b383c7-828a-1857-cbe2-f11b9ba77320}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.RadiationExposure</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\RadiationExposure.g.cs" />
-    <Compile Include="..\Units\RadiationExposureUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RadiationExposure/UnitsNet.NanoFramework.RadiationExposure.nuspec b/UnitsNet.NanoFramework/GeneratedCode/RadiationExposure/UnitsNet.NanoFramework.RadiationExposure.nuspec
deleted file mode 100644
index d3de198942..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RadiationExposure/UnitsNet.NanoFramework.RadiationExposure.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.RadiationExposure</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET RadiationExposure - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds RadiationExposure units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework radiationexposure unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\RadiationExposure\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RadiationExposure/packages.config b/UnitsNet.NanoFramework/GeneratedCode/RadiationExposure/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RadiationExposure/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Radioactivity/Radioactivity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Radioactivity/Radioactivity.nfproj
deleted file mode 100644
index 760702039e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Radioactivity/Radioactivity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{abf4b42f-e999-2a78-403f-fb09524f186a}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Radioactivity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Radioactivity.g.cs" />
-    <Compile Include="..\Units\RadioactivityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Radioactivity/UnitsNet.NanoFramework.Radioactivity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Radioactivity/UnitsNet.NanoFramework.Radioactivity.nuspec
deleted file mode 100644
index f718c1e20c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Radioactivity/UnitsNet.NanoFramework.Radioactivity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Radioactivity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Radioactivity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Radioactivity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework radioactivity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Radioactivity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Radioactivity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Radioactivity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Radioactivity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Ratio/Ratio.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Ratio/Ratio.nfproj
deleted file mode 100644
index 64a1647f49..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Ratio/Ratio.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{b0be4813-d93e-7b06-d422-23ca28adf22a}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Ratio</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Ratio.g.cs" />
-    <Compile Include="..\Units\RatioUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Ratio/UnitsNet.NanoFramework.Ratio.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Ratio/UnitsNet.NanoFramework.Ratio.nuspec
deleted file mode 100644
index 829a49f7e0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Ratio/UnitsNet.NanoFramework.Ratio.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Ratio</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Ratio - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Ratio units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework ratio unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Ratio\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Ratio/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Ratio/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Ratio/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RatioChangeRate/RatioChangeRate.nfproj b/UnitsNet.NanoFramework/GeneratedCode/RatioChangeRate/RatioChangeRate.nfproj
deleted file mode 100644
index 7d1b463f9b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RatioChangeRate/RatioChangeRate.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{c028861d-f9e8-8231-2b6a-bc3b3fba349c}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.RatioChangeRate</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\RatioChangeRate.g.cs" />
-    <Compile Include="..\Units\RatioChangeRateUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RatioChangeRate/UnitsNet.NanoFramework.RatioChangeRate.nuspec b/UnitsNet.NanoFramework/GeneratedCode/RatioChangeRate/UnitsNet.NanoFramework.RatioChangeRate.nuspec
deleted file mode 100644
index beca92e395..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RatioChangeRate/UnitsNet.NanoFramework.RatioChangeRate.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.RatioChangeRate</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET RatioChangeRate - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds RatioChangeRate units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework ratiochangerate unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\RatioChangeRate\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RatioChangeRate/packages.config b/UnitsNet.NanoFramework/GeneratedCode/RatioChangeRate/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RatioChangeRate/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/ReciprocalArea.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/ReciprocalArea.nfproj
deleted file mode 100644
index 55a25d5668..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/ReciprocalArea.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ReciprocalArea</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ReciprocalArea.g.cs" />
-    <Compile Include="..\Units\ReciprocalAreaUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/UnitsNet.NanoFramework.ReciprocalArea.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/UnitsNet.NanoFramework.ReciprocalArea.nuspec
deleted file mode 100644
index bbccc6e1df..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/UnitsNet.NanoFramework.ReciprocalArea.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ReciprocalArea</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ReciprocalArea - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ReciprocalArea units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework reciprocalarea unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ReciprocalArea\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalLength/ReciprocalLength.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalLength/ReciprocalLength.nfproj
deleted file mode 100644
index 048d0f98c9..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalLength/ReciprocalLength.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{83d6c79a-c71a-d467-284c-28edbbd059d2}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ReciprocalLength</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ReciprocalLength.g.cs" />
-    <Compile Include="..\Units\ReciprocalLengthUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalLength/UnitsNet.NanoFramework.ReciprocalLength.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalLength/UnitsNet.NanoFramework.ReciprocalLength.nuspec
deleted file mode 100644
index d9162a91ec..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalLength/UnitsNet.NanoFramework.ReciprocalLength.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ReciprocalLength</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ReciprocalLength - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ReciprocalLength units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework reciprocallength unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ReciprocalLength\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalLength/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalLength/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalLength/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RelativeHumidity/RelativeHumidity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/RelativeHumidity/RelativeHumidity.nfproj
deleted file mode 100644
index 0e8a0f01e6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RelativeHumidity/RelativeHumidity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{4ac05c74-08c5-2153-f38c-976975747b5c}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.RelativeHumidity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\RelativeHumidity.g.cs" />
-    <Compile Include="..\Units\RelativeHumidityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RelativeHumidity/UnitsNet.NanoFramework.RelativeHumidity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/RelativeHumidity/UnitsNet.NanoFramework.RelativeHumidity.nuspec
deleted file mode 100644
index 3fc2d9dc62..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RelativeHumidity/UnitsNet.NanoFramework.RelativeHumidity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.RelativeHumidity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET RelativeHumidity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds RelativeHumidity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework relativehumidity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\RelativeHumidity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RelativeHumidity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/RelativeHumidity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RelativeHumidity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalAcceleration/RotationalAcceleration.nfproj b/UnitsNet.NanoFramework/GeneratedCode/RotationalAcceleration/RotationalAcceleration.nfproj
deleted file mode 100644
index 5aa8a5f088..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalAcceleration/RotationalAcceleration.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{e2110137-6a36-f4d1-2219-26eb18fee74d}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.RotationalAcceleration</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\RotationalAcceleration.g.cs" />
-    <Compile Include="..\Units\RotationalAccelerationUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalAcceleration/UnitsNet.NanoFramework.RotationalAcceleration.nuspec b/UnitsNet.NanoFramework/GeneratedCode/RotationalAcceleration/UnitsNet.NanoFramework.RotationalAcceleration.nuspec
deleted file mode 100644
index 054ed8e324..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalAcceleration/UnitsNet.NanoFramework.RotationalAcceleration.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.RotationalAcceleration</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET RotationalAcceleration - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds RotationalAcceleration units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework rotationalacceleration unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\RotationalAcceleration\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalAcceleration/packages.config b/UnitsNet.NanoFramework/GeneratedCode/RotationalAcceleration/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalAcceleration/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalSpeed/RotationalSpeed.nfproj b/UnitsNet.NanoFramework/GeneratedCode/RotationalSpeed/RotationalSpeed.nfproj
deleted file mode 100644
index 626ca3764c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalSpeed/RotationalSpeed.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{934ef064-2dce-6d50-64e9-d4d2c4d41a81}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.RotationalSpeed</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\RotationalSpeed.g.cs" />
-    <Compile Include="..\Units\RotationalSpeedUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalSpeed/UnitsNet.NanoFramework.RotationalSpeed.nuspec b/UnitsNet.NanoFramework/GeneratedCode/RotationalSpeed/UnitsNet.NanoFramework.RotationalSpeed.nuspec
deleted file mode 100644
index 69c0e15a74..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalSpeed/UnitsNet.NanoFramework.RotationalSpeed.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.RotationalSpeed</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET RotationalSpeed - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds RotationalSpeed units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework rotationalspeed unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\RotationalSpeed\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalSpeed/packages.config b/UnitsNet.NanoFramework/GeneratedCode/RotationalSpeed/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalSpeed/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffness/RotationalStiffness.nfproj b/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffness/RotationalStiffness.nfproj
deleted file mode 100644
index 263ac99a43..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffness/RotationalStiffness.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{3788f245-ea6d-eb5d-80de-f25ab30a51cc}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.RotationalStiffness</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\RotationalStiffness.g.cs" />
-    <Compile Include="..\Units\RotationalStiffnessUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffness/UnitsNet.NanoFramework.RotationalStiffness.nuspec b/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffness/UnitsNet.NanoFramework.RotationalStiffness.nuspec
deleted file mode 100644
index c45c075870..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffness/UnitsNet.NanoFramework.RotationalStiffness.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.RotationalStiffness</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET RotationalStiffness - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds RotationalStiffness units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework rotationalstiffness unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\RotationalStiffness\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffness/packages.config b/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffness/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffness/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffnessPerLength/RotationalStiffnessPerLength.nfproj b/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffnessPerLength/RotationalStiffnessPerLength.nfproj
deleted file mode 100644
index 91f6e1ba74..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffnessPerLength/RotationalStiffnessPerLength.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{eae89113-1312-f83c-1a4b-638b98e760b3}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.RotationalStiffnessPerLength</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\RotationalStiffnessPerLength.g.cs" />
-    <Compile Include="..\Units\RotationalStiffnessPerLengthUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffnessPerLength/UnitsNet.NanoFramework.RotationalStiffnessPerLength.nuspec b/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffnessPerLength/UnitsNet.NanoFramework.RotationalStiffnessPerLength.nuspec
deleted file mode 100644
index 028b1be677..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffnessPerLength/UnitsNet.NanoFramework.RotationalStiffnessPerLength.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.RotationalStiffnessPerLength</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET RotationalStiffnessPerLength - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds RotationalStiffnessPerLength units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework rotationalstiffnessperlength unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\RotationalStiffnessPerLength\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffnessPerLength/packages.config b/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffnessPerLength/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/RotationalStiffnessPerLength/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Scalar/Scalar.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Scalar/Scalar.nfproj
deleted file mode 100644
index 959d03670d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Scalar/Scalar.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{609c8143-bdb3-709b-a7a5-cc33659c9b51}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Scalar</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Scalar.g.cs" />
-    <Compile Include="..\Units\ScalarUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Scalar/UnitsNet.NanoFramework.Scalar.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Scalar/UnitsNet.NanoFramework.Scalar.nuspec
deleted file mode 100644
index 9261e94462..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Scalar/UnitsNet.NanoFramework.Scalar.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Scalar</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Scalar - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Scalar units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework scalar unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Scalar\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Scalar/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Scalar/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Scalar/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SolidAngle/SolidAngle.nfproj b/UnitsNet.NanoFramework/GeneratedCode/SolidAngle/SolidAngle.nfproj
deleted file mode 100644
index 32e06e7f7c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SolidAngle/SolidAngle.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{39d13fa7-a1df-cea6-adee-bab64a00a843}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.SolidAngle</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\SolidAngle.g.cs" />
-    <Compile Include="..\Units\SolidAngleUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SolidAngle/UnitsNet.NanoFramework.SolidAngle.nuspec b/UnitsNet.NanoFramework/GeneratedCode/SolidAngle/UnitsNet.NanoFramework.SolidAngle.nuspec
deleted file mode 100644
index cc8a74851b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SolidAngle/UnitsNet.NanoFramework.SolidAngle.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.SolidAngle</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET SolidAngle - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds SolidAngle units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework solidangle unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\SolidAngle\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SolidAngle/packages.config b/UnitsNet.NanoFramework/GeneratedCode/SolidAngle/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SolidAngle/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificEnergy/SpecificEnergy.nfproj b/UnitsNet.NanoFramework/GeneratedCode/SpecificEnergy/SpecificEnergy.nfproj
deleted file mode 100644
index e062571c81..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificEnergy/SpecificEnergy.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{5bce25ab-a4d6-d89c-5274-7eadd8c5967a}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.SpecificEnergy</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\SpecificEnergy.g.cs" />
-    <Compile Include="..\Units\SpecificEnergyUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificEnergy/UnitsNet.NanoFramework.SpecificEnergy.nuspec b/UnitsNet.NanoFramework/GeneratedCode/SpecificEnergy/UnitsNet.NanoFramework.SpecificEnergy.nuspec
deleted file mode 100644
index 3a0af8c513..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificEnergy/UnitsNet.NanoFramework.SpecificEnergy.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.SpecificEnergy</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET SpecificEnergy - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds SpecificEnergy units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework specificenergy unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\SpecificEnergy\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificEnergy/packages.config b/UnitsNet.NanoFramework/GeneratedCode/SpecificEnergy/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificEnergy/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificEntropy/SpecificEntropy.nfproj b/UnitsNet.NanoFramework/GeneratedCode/SpecificEntropy/SpecificEntropy.nfproj
deleted file mode 100644
index d4c07d679d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificEntropy/SpecificEntropy.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{0d5dc515-9d35-ac02-c0b1-12c70c3163a2}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.SpecificEntropy</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\SpecificEntropy.g.cs" />
-    <Compile Include="..\Units\SpecificEntropyUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificEntropy/UnitsNet.NanoFramework.SpecificEntropy.nuspec b/UnitsNet.NanoFramework/GeneratedCode/SpecificEntropy/UnitsNet.NanoFramework.SpecificEntropy.nuspec
deleted file mode 100644
index 9948af1758..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificEntropy/UnitsNet.NanoFramework.SpecificEntropy.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.SpecificEntropy</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET SpecificEntropy - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds SpecificEntropy units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework specificentropy unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\SpecificEntropy\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificEntropy/packages.config b/UnitsNet.NanoFramework/GeneratedCode/SpecificEntropy/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificEntropy/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificFuelConsumption/SpecificFuelConsumption.nfproj b/UnitsNet.NanoFramework/GeneratedCode/SpecificFuelConsumption/SpecificFuelConsumption.nfproj
deleted file mode 100644
index addee8e44a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificFuelConsumption/SpecificFuelConsumption.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{f1a91b9a-ec32-5f98-d4d6-75ac04c63276}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.SpecificFuelConsumption</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\SpecificFuelConsumption.g.cs" />
-    <Compile Include="..\Units\SpecificFuelConsumptionUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificFuelConsumption/UnitsNet.NanoFramework.SpecificFuelConsumption.nuspec b/UnitsNet.NanoFramework/GeneratedCode/SpecificFuelConsumption/UnitsNet.NanoFramework.SpecificFuelConsumption.nuspec
deleted file mode 100644
index b6567a00c1..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificFuelConsumption/UnitsNet.NanoFramework.SpecificFuelConsumption.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.SpecificFuelConsumption</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET SpecificFuelConsumption - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds SpecificFuelConsumption units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework specificfuelconsumption unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\SpecificFuelConsumption\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificFuelConsumption/packages.config b/UnitsNet.NanoFramework/GeneratedCode/SpecificFuelConsumption/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificFuelConsumption/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificVolume/SpecificVolume.nfproj b/UnitsNet.NanoFramework/GeneratedCode/SpecificVolume/SpecificVolume.nfproj
deleted file mode 100644
index 7ee4926161..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificVolume/SpecificVolume.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{74b88d5c-96e5-7286-d2b2-8def18538246}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.SpecificVolume</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\SpecificVolume.g.cs" />
-    <Compile Include="..\Units\SpecificVolumeUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificVolume/UnitsNet.NanoFramework.SpecificVolume.nuspec b/UnitsNet.NanoFramework/GeneratedCode/SpecificVolume/UnitsNet.NanoFramework.SpecificVolume.nuspec
deleted file mode 100644
index cc91a26ebd..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificVolume/UnitsNet.NanoFramework.SpecificVolume.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.SpecificVolume</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET SpecificVolume - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds SpecificVolume units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework specificvolume unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\SpecificVolume\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificVolume/packages.config b/UnitsNet.NanoFramework/GeneratedCode/SpecificVolume/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificVolume/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificWeight/SpecificWeight.nfproj b/UnitsNet.NanoFramework/GeneratedCode/SpecificWeight/SpecificWeight.nfproj
deleted file mode 100644
index e8b961bba0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificWeight/SpecificWeight.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{d63ac796-7087-bf6c-2848-e6511358fbe4}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.SpecificWeight</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\SpecificWeight.g.cs" />
-    <Compile Include="..\Units\SpecificWeightUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificWeight/UnitsNet.NanoFramework.SpecificWeight.nuspec b/UnitsNet.NanoFramework/GeneratedCode/SpecificWeight/UnitsNet.NanoFramework.SpecificWeight.nuspec
deleted file mode 100644
index 9a7f20aa34..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificWeight/UnitsNet.NanoFramework.SpecificWeight.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.SpecificWeight</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET SpecificWeight - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds SpecificWeight units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework specificweight unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\SpecificWeight\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/SpecificWeight/packages.config b/UnitsNet.NanoFramework/GeneratedCode/SpecificWeight/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/SpecificWeight/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Speed/Speed.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Speed/Speed.nfproj
deleted file mode 100644
index cebcbc5345..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Speed/Speed.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{e9fe72c3-56b4-856b-a592-ae6e98e571f3}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Speed</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Speed.g.cs" />
-    <Compile Include="..\Units\SpeedUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Speed/UnitsNet.NanoFramework.Speed.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Speed/UnitsNet.NanoFramework.Speed.nuspec
deleted file mode 100644
index 28cfb226a1..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Speed/UnitsNet.NanoFramework.Speed.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Speed</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Speed - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Speed units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework speed unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Speed\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Speed/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Speed/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Speed/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/StandardVolumeFlow/StandardVolumeFlow.nfproj b/UnitsNet.NanoFramework/GeneratedCode/StandardVolumeFlow/StandardVolumeFlow.nfproj
deleted file mode 100644
index 23e6f61e70..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/StandardVolumeFlow/StandardVolumeFlow.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{5da7dbe9-f180-570f-2da0-2737f043744d}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.StandardVolumeFlow</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\StandardVolumeFlow.g.cs" />
-    <Compile Include="..\Units\StandardVolumeFlowUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/StandardVolumeFlow/UnitsNet.NanoFramework.StandardVolumeFlow.nuspec b/UnitsNet.NanoFramework/GeneratedCode/StandardVolumeFlow/UnitsNet.NanoFramework.StandardVolumeFlow.nuspec
deleted file mode 100644
index 34538759b0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/StandardVolumeFlow/UnitsNet.NanoFramework.StandardVolumeFlow.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.StandardVolumeFlow</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET StandardVolumeFlow - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds StandardVolumeFlow units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework standardvolumeflow unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\StandardVolumeFlow\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/StandardVolumeFlow/packages.config b/UnitsNet.NanoFramework/GeneratedCode/StandardVolumeFlow/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/StandardVolumeFlow/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Temperature/Temperature.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Temperature/Temperature.nfproj
deleted file mode 100644
index 41ada396fa..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Temperature/Temperature.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{8bce58b9-1a87-6bb3-3cee-e0e0f012b618}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Temperature</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Temperature.g.cs" />
-    <Compile Include="..\Units\TemperatureUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Temperature/UnitsNet.NanoFramework.Temperature.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Temperature/UnitsNet.NanoFramework.Temperature.nuspec
deleted file mode 100644
index a6587d50a7..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Temperature/UnitsNet.NanoFramework.Temperature.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Temperature</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Temperature - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Temperature units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework temperature unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Temperature\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Temperature/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Temperature/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Temperature/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/TemperatureChangeRate/TemperatureChangeRate.nfproj b/UnitsNet.NanoFramework/GeneratedCode/TemperatureChangeRate/TemperatureChangeRate.nfproj
deleted file mode 100644
index 95a6af3338..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/TemperatureChangeRate/TemperatureChangeRate.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{dfbb7b9f-c604-fedd-e658-17e196043123}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.TemperatureChangeRate</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\TemperatureChangeRate.g.cs" />
-    <Compile Include="..\Units\TemperatureChangeRateUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/TemperatureChangeRate/UnitsNet.NanoFramework.TemperatureChangeRate.nuspec b/UnitsNet.NanoFramework/GeneratedCode/TemperatureChangeRate/UnitsNet.NanoFramework.TemperatureChangeRate.nuspec
deleted file mode 100644
index d18b6baa86..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/TemperatureChangeRate/UnitsNet.NanoFramework.TemperatureChangeRate.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.TemperatureChangeRate</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET TemperatureChangeRate - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds TemperatureChangeRate units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework temperaturechangerate unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\TemperatureChangeRate\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/TemperatureChangeRate/packages.config b/UnitsNet.NanoFramework/GeneratedCode/TemperatureChangeRate/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/TemperatureChangeRate/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/TemperatureDelta/TemperatureDelta.nfproj b/UnitsNet.NanoFramework/GeneratedCode/TemperatureDelta/TemperatureDelta.nfproj
deleted file mode 100644
index 8201b03171..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/TemperatureDelta/TemperatureDelta.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{8854c5e8-e40b-74c3-aafc-de0f13239276}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.TemperatureDelta</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\TemperatureDelta.g.cs" />
-    <Compile Include="..\Units\TemperatureDeltaUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/TemperatureDelta/UnitsNet.NanoFramework.TemperatureDelta.nuspec b/UnitsNet.NanoFramework/GeneratedCode/TemperatureDelta/UnitsNet.NanoFramework.TemperatureDelta.nuspec
deleted file mode 100644
index 7d2bae64f5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/TemperatureDelta/UnitsNet.NanoFramework.TemperatureDelta.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.TemperatureDelta</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET TemperatureDelta - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds TemperatureDelta units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework temperaturedelta unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\TemperatureDelta\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/TemperatureDelta/packages.config b/UnitsNet.NanoFramework/GeneratedCode/TemperatureDelta/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/TemperatureDelta/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/TemperatureGradient/TemperatureGradient.nfproj b/UnitsNet.NanoFramework/GeneratedCode/TemperatureGradient/TemperatureGradient.nfproj
deleted file mode 100644
index 291bab56e4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/TemperatureGradient/TemperatureGradient.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{83d1d75e-3c26-b8d0-f097-f99452e749cc}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.TemperatureGradient</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\TemperatureGradient.g.cs" />
-    <Compile Include="..\Units\TemperatureGradientUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/TemperatureGradient/UnitsNet.NanoFramework.TemperatureGradient.nuspec b/UnitsNet.NanoFramework/GeneratedCode/TemperatureGradient/UnitsNet.NanoFramework.TemperatureGradient.nuspec
deleted file mode 100644
index 503cd4f177..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/TemperatureGradient/UnitsNet.NanoFramework.TemperatureGradient.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.TemperatureGradient</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET TemperatureGradient - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds TemperatureGradient units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework temperaturegradient unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\TemperatureGradient\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/TemperatureGradient/packages.config b/UnitsNet.NanoFramework/GeneratedCode/TemperatureGradient/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/TemperatureGradient/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ThermalConductivity/ThermalConductivity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ThermalConductivity/ThermalConductivity.nfproj
deleted file mode 100644
index c281ac35ce..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ThermalConductivity/ThermalConductivity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{7e7d8010-b37a-151a-11a5-1db234ee1104}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ThermalConductivity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ThermalConductivity.g.cs" />
-    <Compile Include="..\Units\ThermalConductivityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ThermalConductivity/UnitsNet.NanoFramework.ThermalConductivity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ThermalConductivity/UnitsNet.NanoFramework.ThermalConductivity.nuspec
deleted file mode 100644
index 07baef261e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ThermalConductivity/UnitsNet.NanoFramework.ThermalConductivity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ThermalConductivity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ThermalConductivity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ThermalConductivity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework thermalconductivity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ThermalConductivity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ThermalConductivity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ThermalConductivity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ThermalConductivity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ThermalInsulance/ThermalInsulance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ThermalInsulance/ThermalInsulance.nfproj
deleted file mode 100644
index 0c89e9e5ef..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ThermalInsulance/ThermalInsulance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{0194c08d-ffcd-78bd-9e14-66634fe6d4ea}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ThermalInsulance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ThermalInsulance.g.cs" />
-    <Compile Include="..\Units\ThermalInsulanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ThermalInsulance/UnitsNet.NanoFramework.ThermalInsulance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ThermalInsulance/UnitsNet.NanoFramework.ThermalInsulance.nuspec
deleted file mode 100644
index cf09f8fbb8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ThermalInsulance/UnitsNet.NanoFramework.ThermalInsulance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ThermalInsulance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ThermalInsulance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ThermalInsulance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework thermalinsulance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ThermalInsulance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ThermalInsulance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ThermalInsulance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ThermalInsulance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ThermalResistance/ThermalResistance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ThermalResistance/ThermalResistance.nfproj
deleted file mode 100644
index 62823feeef..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ThermalResistance/ThermalResistance.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{c69bdd4d-3ebd-4b8e-cffb-650903da3872}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.ThermalResistance</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\ThermalResistance.g.cs" />
-    <Compile Include="..\Units\ThermalResistanceUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ThermalResistance/UnitsNet.NanoFramework.ThermalResistance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ThermalResistance/UnitsNet.NanoFramework.ThermalResistance.nuspec
deleted file mode 100644
index 54e8259b5d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ThermalResistance/UnitsNet.NanoFramework.ThermalResistance.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.ThermalResistance</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET ThermalResistance - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds ThermalResistance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework thermalresistance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\ThermalResistance\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/ThermalResistance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ThermalResistance/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/ThermalResistance/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Torque/Torque.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Torque/Torque.nfproj
deleted file mode 100644
index 9fa5c5b3db..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Torque/Torque.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{3b6bbc8a-1b22-deff-2980-53b77b6f3e5f}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Torque</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Torque.g.cs" />
-    <Compile Include="..\Units\TorqueUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Torque/UnitsNet.NanoFramework.Torque.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Torque/UnitsNet.NanoFramework.Torque.nuspec
deleted file mode 100644
index ff95d803b5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Torque/UnitsNet.NanoFramework.Torque.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Torque</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Torque - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Torque units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework torque unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Torque\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Torque/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Torque/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Torque/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Turbidity/Turbidity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Turbidity/Turbidity.nfproj
deleted file mode 100644
index 79830f8bf6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Turbidity/Turbidity.nfproj
+++ /dev/null
@@ -1,47 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{05ac8aed-49a4-5c9f-d8c2-8d2debf64791}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Turbidity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Turbidity.g.cs" />
-    <Compile Include="..\Units\TurbidityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-    <Reference Include="System.Math, Version=1.5.43.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.System.Math.1.5.43\lib\System.Math.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Turbidity/UnitsNet.NanoFramework.Turbidity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Turbidity/UnitsNet.NanoFramework.Turbidity.nuspec
deleted file mode 100644
index d3187667ba..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Turbidity/UnitsNet.NanoFramework.Turbidity.nuspec
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Turbidity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Turbidity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Turbidity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework turbidity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-      <dependency id="nanoFramework.System.Math" version="1.5.43" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Turbidity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Turbidity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Turbidity/packages.config
deleted file mode 100644
index ac11548cd6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Turbidity/packages.config
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-  <package id="nanoFramework.System.Math" version="1.5.43" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/AbsorbedDoseOfIonizingRadiationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/AbsorbedDoseOfIonizingRadiationUnit.g.cs
deleted file mode 100644
index abaa075252..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/AbsorbedDoseOfIonizingRadiationUnit.g.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum AbsorbedDoseOfIonizingRadiationUnit
-    {
-        Centigray = 6,
-        Decigray = 26,
-        Femtogray = 7,
-        Gigagray = 8,
-
-        /// <summary>
-        ///     The gray is the unit of ionizing radiation dose in the SI, defined as the absorption of one joule of radiation energy per kilogram of matter.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Gray_(unit)</remarks>
-        Gray = 5,
-        Kilogray = 9,
-        Kilorad = 4,
-        Megagray = 3,
-        Megarad = 2,
-        Microgray = 1,
-        Milligray = 10,
-        Millirad = 18,
-        Nanogray = 16,
-        Petagray = 19,
-        Picogray = 11,
-
-        /// <summary>
-        ///     The rad is a unit of absorbed radiation dose, defined as 1 rad = 0.01 Gy = 0.01 J/kg.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Rad_(radiation_unit)</remarks>
-        Rad = 17,
-        Teragray = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/AccelerationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/AccelerationUnit.g.cs
deleted file mode 100644
index a514c50ff7..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/AccelerationUnit.g.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum AccelerationUnit
-    {
-        CentimeterPerSecondSquared = 1,
-        DecimeterPerSecondSquared = 2,
-        FootPerSecondSquared = 3,
-        InchPerSecondSquared = 4,
-        KilometerPerSecondSquared = 5,
-
-        /// <summary>
-        ///     The knot (/nɒt/) is a unit of speed equal to one nautical mile per hour, exactly 1.852 km/h (approximately 1.151 mph or 0.514 m/s).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Knot_(unit)</remarks>
-        KnotPerHour = 6,
-
-        /// <summary>
-        ///     The knot (/nɒt/) is a unit of speed equal to one nautical mile per hour, exactly 1.852 km/h (approximately 1.151 mph or 0.514 m/s).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Knot_(unit)</remarks>
-        KnotPerMinute = 7,
-        KnotPerSecond = 8,
-        MeterPerSecondSquared = 9,
-        MicrometerPerSecondSquared = 10,
-        MillimeterPerSecondSquared = 11,
-        MillistandardGravity = 12,
-        NanometerPerSecondSquared = 13,
-        StandardGravity = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/AmountOfSubstanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/AmountOfSubstanceUnit.g.cs
deleted file mode 100644
index ccffc2872f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/AmountOfSubstanceUnit.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum AmountOfSubstanceUnit
-    {
-        Centimole = 1,
-        CentipoundMole = 2,
-        Decimole = 3,
-        DecipoundMole = 4,
-        Femtomole = 19,
-        Kilomole = 5,
-        KilopoundMole = 6,
-        Megamole = 7,
-        Micromole = 8,
-        MicropoundMole = 9,
-        Millimole = 10,
-        MillipoundMole = 11,
-        Mole = 12,
-        Nanomole = 13,
-        NanopoundMole = 14,
-        Picomole = 18,
-        PoundMole = 15,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/AmplitudeRatioUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/AmplitudeRatioUnit.g.cs
deleted file mode 100644
index 97a8d592f6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/AmplitudeRatioUnit.g.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum AmplitudeRatioUnit
-    {
-        DecibelMicrovolt = 1,
-        DecibelMillivolt = 2,
-        DecibelUnloaded = 3,
-        DecibelVolt = 4,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/AngleUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/AngleUnit.g.cs
deleted file mode 100644
index ed51329da8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/AngleUnit.g.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum AngleUnit
-    {
-        Arcminute = 1,
-        Arcsecond = 2,
-        Centiradian = 3,
-        Deciradian = 4,
-        Degree = 5,
-        Gradian = 6,
-        Microdegree = 7,
-        Microradian = 8,
-        Millidegree = 9,
-        Milliradian = 10,
-        Nanodegree = 11,
-        Nanoradian = 12,
-        NatoMil = 13,
-        Radian = 14,
-        Revolution = 15,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/AreaDensityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/AreaDensityUnit.g.cs
deleted file mode 100644
index bacdc7e8f4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/AreaDensityUnit.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum AreaDensityUnit
-    {
-
-        /// <summary>
-        ///     Also known as grammage for paper industry. In fiber industry used with abbreviation 'gsm'.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Grammage</remarks>
-        GramPerSquareMeter = 6,
-        KilogramPerSquareMeter = 1,
-        MilligramPerSquareMeter = 10,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/AreaMomentOfInertiaUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/AreaMomentOfInertiaUnit.g.cs
deleted file mode 100644
index 388a130b9d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/AreaMomentOfInertiaUnit.g.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum AreaMomentOfInertiaUnit
-    {
-        CentimeterToTheFourth = 1,
-        DecimeterToTheFourth = 2,
-        FootToTheFourth = 3,
-        InchToTheFourth = 4,
-        MeterToTheFourth = 5,
-        MillimeterToTheFourth = 6,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/AreaUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/AreaUnit.g.cs
deleted file mode 100644
index 73959f66fb..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/AreaUnit.g.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum AreaUnit
-    {
-
-        /// <summary>
-        ///     Based upon the international yard and pound agreement of 1959, an acre may be declared as exactly 4,046.8564224 square metres.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Acre</remarks>
-        Acre = 1,
-        Hectare = 2,
-        SquareCentimeter = 3,
-        SquareDecimeter = 4,
-        SquareFoot = 5,
-        SquareInch = 6,
-        SquareKilometer = 7,
-        SquareMeter = 8,
-        SquareMicrometer = 9,
-
-        /// <summary>
-        ///     The statute mile was standardised between the British Commonwealth and the United States by an international agreement in 1959, when it was formally redefined with respect to SI units as exactly 1,609.344 metres.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Mile</remarks>
-        SquareMile = 10,
-        SquareMillimeter = 11,
-        SquareNauticalMile = 12,
-
-        /// <summary>
-        ///     The yard (symbol: yd) is an English unit of length in both the British imperial and US customary systems of measurement equalling 3 feet (or 36 inches). Since 1959 the yard has been by international agreement standardized as exactly 0.9144 meter. A distance of 1,760 yards is equal to 1 mile.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Yard</remarks>
-        SquareYard = 13,
-
-        /// <summary>
-        ///     In the United States, the foot was defined as 12 inches, with the inch being defined by the Mendenhall Order of 1893 as 39.37 inches = 1 m. This makes a U.S. survey foot exactly 1200/3937 meters.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Foot_(unit)</remarks>
-        UsSurveySquareFoot = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/BitRateUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/BitRateUnit.g.cs
deleted file mode 100644
index ebfb72662d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/BitRateUnit.g.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum BitRateUnit
-    {
-        BitPerSecond = 1,
-        BytePerSecond = 2,
-        ExabitPerSecond = 3,
-        ExabytePerSecond = 4,
-        ExaoctetPerSecond = 29,
-        ExbibitPerSecond = 5,
-        ExbibytePerSecond = 6,
-        ExbioctetPerSecond = 31,
-        GibibitPerSecond = 7,
-        GibibytePerSecond = 8,
-        GibioctetPerSecond = 32,
-        GigabitPerSecond = 9,
-        GigabytePerSecond = 10,
-        GigaoctetPerSecond = 35,
-        KibibitPerSecond = 11,
-        KibibytePerSecond = 12,
-        KibioctetPerSecond = 30,
-        KilobitPerSecond = 13,
-        KilobytePerSecond = 14,
-        KilooctetPerSecond = 27,
-        MebibitPerSecond = 15,
-        MebibytePerSecond = 16,
-        MebioctetPerSecond = 36,
-        MegabitPerSecond = 17,
-        MegabytePerSecond = 18,
-        MegaoctetPerSecond = 34,
-        OctetPerSecond = 28,
-        PebibitPerSecond = 19,
-        PebibytePerSecond = 20,
-        PebioctetPerSecond = 33,
-        PetabitPerSecond = 21,
-        PetabytePerSecond = 22,
-        PetaoctetPerSecond = 46,
-        TebibitPerSecond = 23,
-        TebibytePerSecond = 24,
-        TebioctetPerSecond = 42,
-        TerabitPerSecond = 25,
-        TerabytePerSecond = 26,
-        TeraoctetPerSecond = 40,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/BrakeSpecificFuelConsumptionUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/BrakeSpecificFuelConsumptionUnit.g.cs
deleted file mode 100644
index 73c93e2039..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/BrakeSpecificFuelConsumptionUnit.g.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum BrakeSpecificFuelConsumptionUnit
-    {
-        GramPerKiloWattHour = 1,
-        KilogramPerJoule = 2,
-
-        /// <summary>
-        ///     The pound per horse power hour uses mechanical horse power and the imperial pound
-        /// </summary>
-        PoundPerMechanicalHorsepowerHour = 3,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/CoefficientOfThermalExpansionUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/CoefficientOfThermalExpansionUnit.g.cs
deleted file mode 100644
index 258f5065da..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/CoefficientOfThermalExpansionUnit.g.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum CoefficientOfThermalExpansionUnit
-    {
-        PerDegreeCelsius = 9,
-        PerDegreeFahrenheit = 11,
-        PerKelvin = 13,
-        PpmPerDegreeCelsius = 6,
-        PpmPerDegreeFahrenheit = 4,
-        PpmPerKelvin = 7,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs
deleted file mode 100644
index c272160cf2..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum CompressibilityUnit
-    {
-        InverseAtmosphere = 1,
-        InverseBar = 2,
-        InverseKilopascal = 3,
-        InverseMegapascal = 4,
-        InverseMillibar = 5,
-        InversePascal = 6,
-        InversePoundForcePerSquareInch = 7,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/DensityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/DensityUnit.g.cs
deleted file mode 100644
index 638b21b01a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/DensityUnit.g.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum DensityUnit
-    {
-        CentigramPerDeciliter = 1,
-        CentigramPerLiter = 2,
-        CentigramPerMilliliter = 3,
-        DecigramPerDeciliter = 4,
-        DecigramPerLiter = 5,
-        DecigramPerMilliliter = 6,
-        FemtogramPerDeciliter = 59,
-        FemtogramPerLiter = 56,
-        FemtogramPerMilliliter = 61,
-        GramPerCubicCentimeter = 7,
-        GramPerCubicFoot = 8,
-        GramPerCubicInch = 9,
-        GramPerCubicMeter = 10,
-        GramPerCubicMillimeter = 11,
-        GramPerDeciliter = 12,
-        GramPerLiter = 13,
-        GramPerMilliliter = 14,
-        KilogramPerCubicCentimeter = 15,
-        KilogramPerCubicMeter = 16,
-        KilogramPerCubicMillimeter = 17,
-        KilogramPerLiter = 18,
-        KilopoundPerCubicFoot = 19,
-        KilopoundPerCubicInch = 20,
-        KilopoundPerCubicYard = 64,
-        MicrogramPerCubicMeter = 21,
-        MicrogramPerDeciliter = 22,
-        MicrogramPerLiter = 23,
-        MicrogramPerMilliliter = 24,
-        MilligramPerCubicMeter = 25,
-        MilligramPerDeciliter = 26,
-        MilligramPerLiter = 27,
-        MilligramPerMilliliter = 28,
-        NanogramPerDeciliter = 29,
-        NanogramPerLiter = 30,
-        NanogramPerMilliliter = 31,
-        PicogramPerDeciliter = 32,
-        PicogramPerLiter = 33,
-        PicogramPerMilliliter = 34,
-        PoundPerCubicCentimeter = 35,
-        PoundPerCubicFoot = 36,
-        PoundPerCubicInch = 37,
-        PoundPerCubicMeter = 38,
-        PoundPerCubicMillimeter = 39,
-
-        /// <summary>
-        ///     Calculated from the definition of <a href="https://en.wikipedia.org/wiki/Pound_(mass)">pound</a> and <a href="https://en.wikipedia.org/wiki/Cubic_yard">Cubic yard</a> compared to metric kilogram and meter.
-        /// </summary>
-        PoundPerCubicYard = 58,
-        PoundPerImperialGallon = 40,
-        PoundPerUSGallon = 41,
-        SlugPerCubicCentimeter = 42,
-        SlugPerCubicFoot = 43,
-        SlugPerCubicInch = 44,
-        SlugPerCubicMeter = 45,
-        SlugPerCubicMillimeter = 46,
-        TonnePerCubicCentimeter = 47,
-        TonnePerCubicFoot = 48,
-        TonnePerCubicInch = 49,
-        TonnePerCubicMeter = 50,
-        TonnePerCubicMillimeter = 51,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/DoseAreaProductUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/DoseAreaProductUnit.g.cs
deleted file mode 100644
index 958c8cfbf0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/DoseAreaProductUnit.g.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum DoseAreaProductUnit
-    {
-        CentigraySquareCentimeter = 6,
-        CentigraySquareDecimeter = 3,
-        CentigraySquareMeter = 7,
-        CentigraySquareMicrometer = 21,
-        CentigraySquareMillimeter = 2,
-        DecigraySquareCentimeter = 9,
-        DecigraySquareDecimeter = 1,
-        DecigraySquareMeter = 4,
-        DecigraySquareMicrometer = 25,
-        DecigraySquareMillimeter = 8,
-        GraySquareCentimeter = 10,
-        GraySquareDecimeter = 5,
-        GraySquareMeter = 19,
-        GraySquareMicrometer = 26,
-        GraySquareMillimeter = 16,
-        MicrograySquareCentimeter = 13,
-        MicrograySquareDecimeter = 20,
-        MicrograySquareMeter = 15,
-        MicrograySquareMicrometer = 29,
-        MicrograySquareMillimeter = 18,
-        MilligraySquareCentimeter = 14,
-        MilligraySquareDecimeter = 17,
-        MilligraySquareMeter = 11,
-        MilligraySquareMicrometer = 30,
-        MilligraySquareMillimeter = 12,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/DurationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/DurationUnit.g.cs
deleted file mode 100644
index 7ae6fe672f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/DurationUnit.g.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum DurationUnit
-    {
-        Day = 1,
-        Hour = 2,
-        JulianYear = 3,
-        Microsecond = 4,
-        Millisecond = 5,
-        Minute = 6,
-        Month30 = 7,
-        Nanosecond = 8,
-        Picosecond = 12,
-        Second = 9,
-        Sol = 15,
-        Week = 10,
-        Year365 = 11,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/DynamicViscosityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/DynamicViscosityUnit.g.cs
deleted file mode 100644
index 607837db48..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/DynamicViscosityUnit.g.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum DynamicViscosityUnit
-    {
-        Centipoise = 1,
-        MicropascalSecond = 2,
-        MillipascalSecond = 3,
-        NewtonSecondPerMeterSquared = 4,
-        PascalSecond = 5,
-        Poise = 6,
-        PoundForceSecondPerSquareFoot = 7,
-        PoundForceSecondPerSquareInch = 8,
-        PoundPerFootSecond = 9,
-        Reyn = 10,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricAdmittanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricAdmittanceUnit.g.cs
deleted file mode 100644
index 8399e233bc..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricAdmittanceUnit.g.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricAdmittanceUnit
-    {
-        Gigamho = 16,
-        Gigasiemens = 19,
-        Kilomho = 8,
-        Kilosiemens = 14,
-        Megamho = 10,
-        Megasiemens = 13,
-        Mho = 7,
-        Micromho = 12,
-        Microsiemens = 1,
-        Millimho = 5,
-        Millisiemens = 2,
-        Nanomho = 6,
-        Nanosiemens = 3,
-        Siemens = 4,
-        Teramho = 15,
-        Terasiemens = 9,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricApparentEnergyUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricApparentEnergyUnit.g.cs
deleted file mode 100644
index 85d21e152a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricApparentEnergyUnit.g.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricApparentEnergyUnit
-    {
-        KilovoltampereHour = 7,
-        MegavoltampereHour = 3,
-        VoltampereHour = 10,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricApparentPowerUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricApparentPowerUnit.g.cs
deleted file mode 100644
index fc85f4fa98..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricApparentPowerUnit.g.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricApparentPowerUnit
-    {
-        Gigavoltampere = 3,
-        Kilovoltampere = 1,
-        Megavoltampere = 2,
-        Microvoltampere = 10,
-        Millivoltampere = 6,
-        Voltampere = 9,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCapacitanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCapacitanceUnit.g.cs
deleted file mode 100644
index da5499b11d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCapacitanceUnit.g.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricCapacitanceUnit
-    {
-        Farad = 3,
-        Kilofarad = 8,
-        Megafarad = 1,
-        Microfarad = 7,
-        Millifarad = 5,
-        Nanofarad = 4,
-        Picofarad = 10,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricChargeDensityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricChargeDensityUnit.g.cs
deleted file mode 100644
index 05909c9a62..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricChargeDensityUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricChargeDensityUnit
-    {
-        CoulombPerCubicMeter = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricChargeUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricChargeUnit.g.cs
deleted file mode 100644
index bf853e9a10..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricChargeUnit.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricChargeUnit
-    {
-        AmpereHour = 1,
-        Coulomb = 2,
-        KiloampereHour = 3,
-        Kilocoulomb = 13,
-        MegaampereHour = 4,
-        Megacoulomb = 6,
-        Microcoulomb = 11,
-        MilliampereHour = 5,
-        Millicoulomb = 7,
-        Nanocoulomb = 9,
-        Picocoulomb = 8,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricConductanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricConductanceUnit.g.cs
deleted file mode 100644
index 06708cf596..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricConductanceUnit.g.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricConductanceUnit
-    {
-        Gigamho = 7,
-        Gigasiemens = 18,
-        Kilomho = 15,
-        Kilosiemens = 6,
-        Megamho = 8,
-        Megasiemens = 17,
-        Mho = 12,
-        Micromho = 5,
-        Microsiemens = 1,
-        Millimho = 9,
-        Millisiemens = 2,
-        Nanomho = 14,
-        Nanosiemens = 10,
-        Siemens = 3,
-        Teramho = 19,
-        Terasiemens = 16,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricConductivityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricConductivityUnit.g.cs
deleted file mode 100644
index 3bca9b88e6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricConductivityUnit.g.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricConductivityUnit
-    {
-        MicrosiemensPerCentimeter = 6,
-        MillisiemensPerCentimeter = 12,
-        SiemensPerCentimeter = 13,
-        SiemensPerFoot = 1,
-        SiemensPerInch = 2,
-        SiemensPerMeter = 3,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentDensityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentDensityUnit.g.cs
deleted file mode 100644
index 433e70c970..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentDensityUnit.g.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricCurrentDensityUnit
-    {
-        AmperePerSquareFoot = 1,
-        AmperePerSquareInch = 2,
-        AmperePerSquareMeter = 3,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs
deleted file mode 100644
index 64607d4ef8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricCurrentGradientUnit
-    {
-        AmperePerMicrosecond = 1,
-        AmperePerMillisecond = 2,
-        AmperePerMinute = 11,
-        AmperePerNanosecond = 3,
-        AmperePerSecond = 4,
-        MilliamperePerMinute = 6,
-        MilliamperePerSecond = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentUnit.g.cs
deleted file mode 100644
index 19e8b18382..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentUnit.g.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricCurrentUnit
-    {
-        Ampere = 1,
-        Centiampere = 2,
-        Femtoampere = 9,
-        Kiloampere = 3,
-        Megaampere = 4,
-        Microampere = 5,
-        Milliampere = 6,
-        Nanoampere = 7,
-        Picoampere = 8,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricFieldUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricFieldUnit.g.cs
deleted file mode 100644
index 03ac0494d0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricFieldUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricFieldUnit
-    {
-        VoltPerMeter = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricImpedanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricImpedanceUnit.g.cs
deleted file mode 100644
index f4a01427b7..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricImpedanceUnit.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricImpedanceUnit
-    {
-        Gigaohm = 4,
-        Kiloohm = 3,
-        Megaohm = 10,
-        Microohm = 8,
-        Milliohm = 9,
-        Nanoohm = 7,
-        Ohm = 6,
-        Teraohm = 5,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricInductanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricInductanceUnit.g.cs
deleted file mode 100644
index d12d8e5cfc..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricInductanceUnit.g.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricInductanceUnit
-    {
-        Henry = 1,
-        Microhenry = 2,
-        Millihenry = 3,
-        Nanohenry = 4,
-        Picohenry = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricPotentialChangeRateUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricPotentialChangeRateUnit.g.cs
deleted file mode 100644
index cac18f9c78..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricPotentialChangeRateUnit.g.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricPotentialChangeRateUnit
-    {
-        KilovoltPerHour = 1,
-        KilovoltPerMicrosecond = 2,
-        KilovoltPerMinute = 3,
-        KilovoltPerSecond = 4,
-        MegavoltPerHour = 5,
-        MegavoltPerMicrosecond = 6,
-        MegavoltPerMinute = 7,
-        MegavoltPerSecond = 8,
-        MicrovoltPerHour = 9,
-        MicrovoltPerMicrosecond = 10,
-        MicrovoltPerMinute = 11,
-        MicrovoltPerSecond = 12,
-        MillivoltPerHour = 13,
-        MillivoltPerMicrosecond = 14,
-        MillivoltPerMinute = 15,
-        MillivoltPerSecond = 16,
-        VoltPerHour = 17,
-        VoltPerMicrosecond = 18,
-        VoltPerMinute = 19,
-        VoltPerSecond = 20,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricPotentialUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricPotentialUnit.g.cs
deleted file mode 100644
index 494424283d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricPotentialUnit.g.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricPotentialUnit
-    {
-        Kilovolt = 1,
-        Megavolt = 2,
-        Microvolt = 3,
-        Millivolt = 4,
-        Nanovolt = 11,
-        Volt = 5,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricReactanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricReactanceUnit.g.cs
deleted file mode 100644
index 2f060e90b4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricReactanceUnit.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricReactanceUnit
-    {
-        Gigaohm = 5,
-        Kiloohm = 8,
-        Megaohm = 1,
-        Microohm = 9,
-        Milliohm = 4,
-        Nanoohm = 13,
-        Ohm = 6,
-        Teraohm = 2,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricReactiveEnergyUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricReactiveEnergyUnit.g.cs
deleted file mode 100644
index 4acffa954b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricReactiveEnergyUnit.g.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricReactiveEnergyUnit
-    {
-        KilovoltampereReactiveHour = 10,
-        MegavoltampereReactiveHour = 4,
-        VoltampereReactiveHour = 7,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricReactivePowerUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricReactivePowerUnit.g.cs
deleted file mode 100644
index e905d95887..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricReactivePowerUnit.g.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricReactivePowerUnit
-    {
-        GigavoltampereReactive = 1,
-        KilovoltampereReactive = 2,
-        MegavoltampereReactive = 8,
-        VoltampereReactive = 7,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricResistanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricResistanceUnit.g.cs
deleted file mode 100644
index 0b27324d86..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricResistanceUnit.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricResistanceUnit
-    {
-        Gigaohm = 1,
-        Kiloohm = 2,
-        Megaohm = 3,
-        Microohm = 4,
-        Milliohm = 5,
-        Nanoohm = 11,
-        Ohm = 6,
-        Teraohm = 12,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricResistivityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricResistivityUnit.g.cs
deleted file mode 100644
index c7f43cfc6c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricResistivityUnit.g.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricResistivityUnit
-    {
-        KiloohmCentimeter = 1,
-        KiloohmMeter = 2,
-        MegaohmCentimeter = 3,
-        MegaohmMeter = 4,
-        MicroohmCentimeter = 5,
-        MicroohmMeter = 6,
-        MilliohmCentimeter = 7,
-        MilliohmMeter = 8,
-        NanoohmCentimeter = 9,
-        NanoohmMeter = 10,
-        OhmCentimeter = 11,
-        OhmMeter = 12,
-        PicoohmCentimeter = 13,
-        PicoohmMeter = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricSurfaceChargeDensityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricSurfaceChargeDensityUnit.g.cs
deleted file mode 100644
index 30c7a098de..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricSurfaceChargeDensityUnit.g.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricSurfaceChargeDensityUnit
-    {
-        CoulombPerSquareCentimeter = 1,
-        CoulombPerSquareInch = 2,
-        CoulombPerSquareMeter = 3,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricSusceptanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricSusceptanceUnit.g.cs
deleted file mode 100644
index 02be9d8e07..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricSusceptanceUnit.g.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ElectricSusceptanceUnit
-    {
-        Gigamho = 16,
-        Gigasiemens = 15,
-        Kilomho = 8,
-        Kilosiemens = 4,
-        Megamho = 12,
-        Megasiemens = 19,
-        Mho = 7,
-        Micromho = 9,
-        Microsiemens = 10,
-        Millimho = 3,
-        Millisiemens = 6,
-        Nanomho = 5,
-        Nanosiemens = 1,
-        Siemens = 2,
-        Teramho = 20,
-        Terasiemens = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/EnergyDensityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/EnergyDensityUnit.g.cs
deleted file mode 100644
index bf72f7d4f3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/EnergyDensityUnit.g.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum EnergyDensityUnit
-    {
-        GigajoulePerCubicMeter = 6,
-        GigawattHourPerCubicMeter = 8,
-        JoulePerCubicMeter = 3,
-        KilojoulePerCubicMeter = 5,
-        KilowattHourPerCubicMeter = 2,
-        MegajoulePerCubicMeter = 9,
-        MegawattHourPerCubicMeter = 7,
-        PetajoulePerCubicMeter = 4,
-        PetawattHourPerCubicMeter = 1,
-        TerajoulePerCubicMeter = 10,
-        TerawattHourPerCubicMeter = 12,
-        WattHourPerCubicMeter = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/EnergyUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/EnergyUnit.g.cs
deleted file mode 100644
index 87b58d3a8a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/EnergyUnit.g.cs
+++ /dev/null
@@ -1,106 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum EnergyUnit
-    {
-        BritishThermalUnit = 1,
-        Calorie = 2,
-        DecathermEc = 3,
-        DecathermImperial = 4,
-        DecathermUs = 5,
-
-        /// <summary>
-        ///     In physics, an electronvolt (symbol eV, also written electron-volt and electron volt) is the measure of an amount of kinetic energy gained by a single electron accelerating from rest through an electric potential difference of one volt in vacuum. When used as a unit of energy, the numerical value of 1 eV in joules (symbol J) is equivalent to the numerical value of the charge of an electron in coulombs (symbol C). Under the 2019 redefinition of the SI base units, this sets 1 eV equal to the exact value 1.602176634×10−19 J.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Electronvolt</remarks>
-        ElectronVolt = 6,
-
-        /// <summary>
-        ///     The erg is a unit of energy equal to 10−7 joules (100 nJ). It originated in the Centimetre–gram–second system of units (CGS). It has the symbol erg. The erg is not an SI unit. Its name is derived from ergon (ἔργον), a Greek word meaning 'work' or 'task'.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Erg</remarks>
-        Erg = 7,
-
-        /// <summary>
-        ///     A pound-foot (lb⋅ft), abbreviated from pound-force foot (lbf · ft), is a unit of torque representing one pound of force acting at a perpendicular distance of one foot from a pivot point. Conversely one foot pound-force (ft · lbf) is the moment about an axis that applies one pound-force at a radius of one foot.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Pound-foot_(torque)</remarks>
-        FootPound = 8,
-        GigabritishThermalUnit = 9,
-        GigaelectronVolt = 10,
-        Gigajoule = 11,
-        GigawattDay = 12,
-        GigawattHour = 13,
-
-        /// <summary>
-        ///     A horsepower-hour (symbol: hp⋅h) is an outdated unit of energy, not used in the International System of Units. The unit represents an amount of work a horse is supposed capable of delivering during an hour (1 horsepower integrated over a time interval of an hour).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Horsepower-hour</remarks>
-        HorsepowerHour = 14,
-        Joule = 15,
-        KilobritishThermalUnit = 16,
-        Kilocalorie = 17,
-        KiloelectronVolt = 18,
-        Kilojoule = 19,
-        KilowattDay = 20,
-        KilowattHour = 21,
-        MegabritishThermalUnit = 22,
-        Megacalorie = 23,
-        MegaelectronVolt = 24,
-        Megajoule = 25,
-        MegawattDay = 26,
-        MegawattHour = 27,
-        Microjoule = 47,
-        Millijoule = 28,
-        Nanojoule = 45,
-        Petajoule = 43,
-        TeraelectronVolt = 29,
-        Terajoule = 37,
-        TerawattDay = 30,
-        TerawattHour = 31,
-
-        /// <summary>
-        ///     The therm (symbol, thm) is a non-SI unit of heat energy equal to 100,000 British thermal units (BTU), and approximately 105 megajoules, 29.3 kilowatt-hours, 25,200 kilocalories and 25.2 thermies. One therm is the energy content of approximately 100 cubic feet (2.83 cubic metres) of natural gas at standard temperature and pressure. However, the BTU is not standardised worldwide, with slightly different values in the EU, UK, and United States, meaning that the energy content of the therm also varies by territory.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Therm</remarks>
-        ThermEc = 32,
-
-        /// <summary>
-        ///     The therm (symbol, thm) is a non-SI unit of heat energy equal to 100,000 British thermal units (BTU), and approximately 105 megajoules, 29.3 kilowatt-hours, 25,200 kilocalories and 25.2 thermies. One therm is the energy content of approximately 100 cubic feet (2.83 cubic metres) of natural gas at standard temperature and pressure. However, the BTU is not standardised worldwide, with slightly different values in the EU, UK, and United States, meaning that the energy content of the therm also varies by territory.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Therm</remarks>
-        ThermImperial = 33,
-
-        /// <summary>
-        ///     The therm (symbol, thm) is a non-SI unit of heat energy equal to 100,000 British thermal units (BTU), and approximately 105 megajoules, 29.3 kilowatt-hours, 25,200 kilocalories and 25.2 thermies. One therm is the energy content of approximately 100 cubic feet (2.83 cubic metres) of natural gas at standard temperature and pressure. However, the BTU is not standardised worldwide, with slightly different values in the EU, UK, and United States, meaning that the energy content of the therm also varies by territory.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Therm</remarks>
-        ThermUs = 34,
-        WattDay = 35,
-        WattHour = 36,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/EntropyUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/EntropyUnit.g.cs
deleted file mode 100644
index 1fbd647e03..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/EntropyUnit.g.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum EntropyUnit
-    {
-        CaloriePerKelvin = 1,
-        JoulePerDegreeCelsius = 2,
-        JoulePerKelvin = 3,
-        KilocaloriePerKelvin = 4,
-        KilojoulePerDegreeCelsius = 5,
-        KilojoulePerKelvin = 6,
-        MegajoulePerKelvin = 7,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/FluidResistanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/FluidResistanceUnit.g.cs
deleted file mode 100644
index e5576ed308..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/FluidResistanceUnit.g.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum FluidResistanceUnit
-    {
-        /// <remarks>https://en.wikipedia.org/wiki/Vascular_resistance</remarks>
-        DyneSecondPerCentimeterToTheFifth = 6,
-        MegapascalSecondPerCubicMeter = 7,
-        MillimeterMercuryMinutePerCubicCentimeter = 3,
-        MillimeterMercuryMinutePerCubicMeter = 5,
-        MillimeterMercuryMinutePerLiter = 2,
-        MillimeterMercuryMinutePerMilliliter = 9,
-        MillimeterMercurySecondPerCubicCentimeter = 8,
-        MillimeterMercurySecondPerCubicMeter = 10,
-        MillimeterMercurySecondPerLiter = 4,
-        MillimeterMercurySecondPerMilliliter = 1,
-        PascalMinutePerCubicCentimeter = 19,
-        PascalMinutePerCubicMeter = 16,
-        PascalMinutePerLiter = 15,
-        PascalMinutePerMilliliter = 12,
-        PascalSecondPerCubicCentimeter = 18,
-        PascalSecondPerCubicMeter = 13,
-        PascalSecondPerLiter = 11,
-        PascalSecondPerMilliliter = 20,
-        /// <remarks>https://en.wikipedia.org/wiki/Vascular_resistance</remarks>
-        WoodUnit = 17,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ForceChangeRateUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ForceChangeRateUnit.g.cs
deleted file mode 100644
index 9b76b2f23a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ForceChangeRateUnit.g.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ForceChangeRateUnit
-    {
-        CentinewtonPerSecond = 1,
-        DecanewtonPerMinute = 2,
-        DecanewtonPerSecond = 3,
-        DecinewtonPerSecond = 4,
-        KilonewtonPerMinute = 5,
-        KilonewtonPerSecond = 6,
-        KilopoundForcePerMinute = 7,
-        KilopoundForcePerSecond = 8,
-        MicronewtonPerSecond = 9,
-        MillinewtonPerSecond = 10,
-        NanonewtonPerSecond = 11,
-        NewtonPerMinute = 12,
-        NewtonPerSecond = 13,
-        PoundForcePerMinute = 14,
-        PoundForcePerSecond = 15,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ForcePerLengthUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ForcePerLengthUnit.g.cs
deleted file mode 100644
index 7f6a376ca3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ForcePerLengthUnit.g.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ForcePerLengthUnit
-    {
-        CentinewtonPerCentimeter = 1,
-        CentinewtonPerMeter = 2,
-        CentinewtonPerMillimeter = 3,
-        DecanewtonPerCentimeter = 4,
-        DecanewtonPerMeter = 5,
-        DecanewtonPerMillimeter = 6,
-        DecinewtonPerCentimeter = 7,
-        DecinewtonPerMeter = 8,
-        DecinewtonPerMillimeter = 9,
-        KilogramForcePerCentimeter = 10,
-        KilogramForcePerMeter = 11,
-        KilogramForcePerMillimeter = 12,
-        KilonewtonPerCentimeter = 13,
-        KilonewtonPerMeter = 14,
-        KilonewtonPerMillimeter = 15,
-        KilopoundForcePerFoot = 16,
-        KilopoundForcePerInch = 17,
-        MeganewtonPerCentimeter = 18,
-        MeganewtonPerMeter = 19,
-        MeganewtonPerMillimeter = 20,
-        MicronewtonPerCentimeter = 21,
-        MicronewtonPerMeter = 22,
-        MicronewtonPerMillimeter = 23,
-        MillinewtonPerCentimeter = 24,
-        MillinewtonPerMeter = 25,
-        MillinewtonPerMillimeter = 26,
-        NanonewtonPerCentimeter = 27,
-        NanonewtonPerMeter = 28,
-        NanonewtonPerMillimeter = 29,
-        NewtonPerCentimeter = 30,
-        NewtonPerMeter = 31,
-        NewtonPerMillimeter = 32,
-        PoundForcePerFoot = 33,
-        PoundForcePerInch = 34,
-        PoundForcePerYard = 35,
-        TonneForcePerCentimeter = 36,
-        TonneForcePerMeter = 37,
-        TonneForcePerMillimeter = 38,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ForceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ForceUnit.g.cs
deleted file mode 100644
index bc5be3f0ff..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ForceUnit.g.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ForceUnit
-    {
-        Decanewton = 1,
-
-        /// <summary>
-        ///     One dyne is equal to 10 micronewtons, 10e−5 N or to 10 nsn (nanosthenes) in the old metre–tonne–second system of units.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Dyne#Definition</remarks>
-        Dyn = 2,
-
-        /// <summary>
-        ///     The kilogram-force, or kilopond, is equal to the magnitude of the force exerted on one kilogram of mass in a 9.80665 m/s2 gravitational field (standard gravity). Therefore, one kilogram-force is by definition equal to 9.80665 N.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Kilogram-force</remarks>
-        KilogramForce = 3,
-        Kilonewton = 4,
-
-        /// <summary>
-        ///     The kilogram-force, or kilopond, is equal to the magnitude of the force exerted on one kilogram of mass in a 9.80665 m/s2 gravitational field (standard gravity). Therefore, one kilogram-force is by definition equal to 9.80665 N.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Kilogram-force</remarks>
-        Kilopond = 5,
-        KilopoundForce = 6,
-        Meganewton = 7,
-        Micronewton = 8,
-        Millinewton = 9,
-
-        /// <summary>
-        ///     The newton (symbol: N) is the unit of force in the International System of Units (SI). It is defined as 1 kg⋅m/s2, the force which gives a mass of 1 kilogram an acceleration of 1 metre per second per second.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Newton_(unit)</remarks>
-        Newton = 10,
-
-        /// <summary>
-        ///     An ounce-force is 1⁄16 of a pound-force, or about 0.2780139 newtons.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Ounce#Ounce-force</remarks>
-        OunceForce = 11,
-
-        /// <summary>
-        ///     The poundal is defined as the force necessary to accelerate 1 pound-mass at 1 foot per second per second. 1 pdl = 0.138254954376 N exactly.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Poundal</remarks>
-        Poundal = 12,
-
-        /// <summary>
-        ///     The standard values of acceleration of the standard gravitational field (gn) and the international avoirdupois pound (lb) result in a pound-force equal to 4.4482216152605 N.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Pound_(force)#Definitions</remarks>
-        PoundForce = 13,
-
-        /// <summary>
-        ///     The short ton-force is a unit of force equal to 2,000 pounds-force (907.18474 kgf), that is most commonly used in the United States – known there simply as the ton or US ton.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Ton-force#Short_ton-force</remarks>
-        ShortTonForce = 14,
-
-        /// <summary>
-        ///     The tonne-force, metric ton-force, megagram-force, and megapond (Mp) are each 1000 kilograms-force.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Kilogram-force#Related_units</remarks>
-        TonneForce = 15,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/FrequencyUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/FrequencyUnit.g.cs
deleted file mode 100644
index d50f23ceb5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/FrequencyUnit.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum FrequencyUnit
-    {
-        BeatPerMinute = 1,
-        CyclePerHour = 3,
-        CyclePerMinute = 4,
-        Gigahertz = 5,
-        Hertz = 6,
-        Kilohertz = 7,
-        Megahertz = 8,
-        Microhertz = 16,
-        Millihertz = 21,
-        PerSecond = 9,
-
-        /// <summary>
-        ///     In SI units, angular frequency is normally presented with the unit radian per second, and need not express a rotational value. The unit hertz (Hz) is dimensionally equivalent, but by convention it is only used for frequency f, never for angular frequency ω. This convention is used to help avoid the confusion that arises when dealing with quantities such as frequency and angular quantities because the units of measure (such as cycle or radian) are considered to be one and hence may be omitted when expressing quantities in terms of SI units.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Angular_frequency</remarks>
-        RadianPerSecond = 10,
-        Terahertz = 11,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/FuelEfficiencyUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/FuelEfficiencyUnit.g.cs
deleted file mode 100644
index 24491dee95..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/FuelEfficiencyUnit.g.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum FuelEfficiencyUnit
-    {
-        KilometerPerLiter = 1,
-        LiterPer100Kilometers = 2,
-        MilePerUkGallon = 3,
-        MilePerUsGallon = 4,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/HeatFluxUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/HeatFluxUnit.g.cs
deleted file mode 100644
index 0a3da3b723..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/HeatFluxUnit.g.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum HeatFluxUnit
-    {
-        /// <remarks>Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details.</remarks>
-        BtuPerHourSquareFoot = 1,
-        /// <remarks>Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details.</remarks>
-        BtuPerMinuteSquareFoot = 2,
-        /// <remarks>Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details.</remarks>
-        BtuPerSecondSquareFoot = 3,
-        /// <remarks>Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details.</remarks>
-        BtuPerSecondSquareInch = 4,
-        CaloriePerSecondSquareCentimeter = 5,
-        CentiwattPerSquareMeter = 6,
-        DeciwattPerSquareMeter = 7,
-        KilocaloriePerHourSquareMeter = 8,
-        KilocaloriePerSecondSquareCentimeter = 9,
-        KilowattPerSquareMeter = 10,
-        MicrowattPerSquareMeter = 11,
-        MilliwattPerSquareMeter = 12,
-        NanowattPerSquareMeter = 13,
-        PoundForcePerFootSecond = 14,
-        PoundPerSecondCubed = 15,
-        WattPerSquareFoot = 16,
-        WattPerSquareInch = 17,
-        WattPerSquareMeter = 18,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/HeatTransferCoefficientUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/HeatTransferCoefficientUnit.g.cs
deleted file mode 100644
index 1a52bffbfe..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/HeatTransferCoefficientUnit.g.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum HeatTransferCoefficientUnit
-    {
-        BtuPerHourSquareFootDegreeFahrenheit = 11,
-        CaloriePerHourSquareMeterDegreeCelsius = 5,
-        KilocaloriePerHourSquareMeterDegreeCelsius = 8,
-        WattPerSquareMeterCelsius = 2,
-        WattPerSquareMeterKelvin = 3,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/IlluminanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/IlluminanceUnit.g.cs
deleted file mode 100644
index 7675a53867..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/IlluminanceUnit.g.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum IlluminanceUnit
-    {
-        Kilolux = 1,
-        Lux = 2,
-        Megalux = 3,
-        Millilux = 4,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ImpulseUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ImpulseUnit.g.cs
deleted file mode 100644
index fd6c0c9ab8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ImpulseUnit.g.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ImpulseUnit
-    {
-        CentinewtonSecond = 10,
-        DecanewtonSecond = 9,
-        DecinewtonSecond = 6,
-        KilogramMeterPerSecond = 1,
-        KilonewtonSecond = 7,
-        MeganewtonSecond = 4,
-        MicronewtonSecond = 8,
-        MillinewtonSecond = 3,
-        NanonewtonSecond = 2,
-        NewtonSecond = 5,
-        PoundFootPerSecond = 16,
-        PoundForceSecond = 18,
-        SlugFootPerSecond = 11,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/InformationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/InformationUnit.g.cs
deleted file mode 100644
index ca0b4e2d4b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/InformationUnit.g.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum InformationUnit
-    {
-        Bit = 1,
-        Byte = 2,
-        Exabit = 3,
-        Exabyte = 4,
-        Exaoctet = 33,
-        Exbibit = 5,
-        Exbibyte = 6,
-        Exbioctet = 35,
-        Gibibit = 7,
-        Gibibyte = 8,
-        Gibioctet = 27,
-        Gigabit = 9,
-        Gigabyte = 10,
-        Gigaoctet = 28,
-        Kibibit = 11,
-        Kibibyte = 12,
-        Kibioctet = 30,
-        Kilobit = 13,
-        Kilobyte = 14,
-        Kilooctet = 32,
-        Mebibit = 15,
-        Mebibyte = 16,
-        Mebioctet = 36,
-        Megabit = 17,
-        Megabyte = 18,
-        Megaoctet = 34,
-        Octet = 31,
-        Pebibit = 19,
-        Pebibyte = 20,
-        Pebioctet = 29,
-        Petabit = 21,
-        Petabyte = 22,
-        Petaoctet = 39,
-        Tebibit = 23,
-        Tebibyte = 24,
-        Tebioctet = 43,
-        Terabit = 25,
-        Terabyte = 26,
-        Teraoctet = 40,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/IrradianceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/IrradianceUnit.g.cs
deleted file mode 100644
index 2ed5f09b06..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/IrradianceUnit.g.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum IrradianceUnit
-    {
-        KilowattPerSquareCentimeter = 1,
-        KilowattPerSquareMeter = 2,
-        MegawattPerSquareCentimeter = 3,
-        MegawattPerSquareMeter = 4,
-        MicrowattPerSquareCentimeter = 5,
-        MicrowattPerSquareMeter = 6,
-        MilliwattPerSquareCentimeter = 7,
-        MilliwattPerSquareMeter = 8,
-        NanowattPerSquareCentimeter = 9,
-        NanowattPerSquareMeter = 10,
-        PicowattPerSquareCentimeter = 11,
-        PicowattPerSquareMeter = 12,
-        WattPerSquareCentimeter = 13,
-        WattPerSquareMeter = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/IrradiationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/IrradiationUnit.g.cs
deleted file mode 100644
index 26d131063a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/IrradiationUnit.g.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum IrradiationUnit
-    {
-        BtuPerSquareFoot = 15,
-        JoulePerSquareCentimeter = 1,
-        JoulePerSquareMeter = 2,
-        JoulePerSquareMillimeter = 3,
-        KilobtuPerSquareFoot = 9,
-        KilojoulePerSquareMeter = 4,
-        KilowattHourPerSquareMeter = 5,
-        MillijoulePerSquareCentimeter = 6,
-        WattHourPerSquareMeter = 7,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/JerkUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/JerkUnit.g.cs
deleted file mode 100644
index e269a35497..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/JerkUnit.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum JerkUnit
-    {
-        CentimeterPerSecondCubed = 1,
-        DecimeterPerSecondCubed = 2,
-        FootPerSecondCubed = 3,
-        InchPerSecondCubed = 4,
-        KilometerPerSecondCubed = 5,
-        MeterPerSecondCubed = 6,
-        MicrometerPerSecondCubed = 7,
-        MillimeterPerSecondCubed = 8,
-        MillistandardGravitiesPerSecond = 9,
-        NanometerPerSecondCubed = 10,
-        StandardGravitiesPerSecond = 11,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/KinematicViscosityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/KinematicViscosityUnit.g.cs
deleted file mode 100644
index f01709d0c3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/KinematicViscosityUnit.g.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum KinematicViscosityUnit
-    {
-        Centistokes = 1,
-        Decistokes = 2,
-        Kilostokes = 3,
-        Microstokes = 4,
-        Millistokes = 5,
-        Nanostokes = 6,
-        SquareFootPerSecond = 7,
-        SquareMeterPerSecond = 8,
-        Stokes = 9,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/LeakRateUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/LeakRateUnit.g.cs
deleted file mode 100644
index e48896681e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/LeakRateUnit.g.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum LeakRateUnit
-    {
-        AtmCubicCentimeterPerSecond = 10,
-        MillibarLiterPerSecond = 7,
-        PascalCubicMeterPerSecond = 2,
-        TorrLiterPerSecond = 4,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/LengthUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/LengthUnit.g.cs
deleted file mode 100644
index 0c92578089..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/LengthUnit.g.cs
+++ /dev/null
@@ -1,163 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum LengthUnit
-    {
-
-        /// <summary>
-        ///     Angstrom is a metric unit of length equal to 1e-10 meter
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Angstrom</remarks>
-        Angstrom = 1,
-
-        /// <summary>
-        ///     One Astronomical Unit is the distance from the solar system Star, the sun, to planet Earth.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Astronomical_unit</remarks>
-        AstronomicalUnit = 2,
-        Centimeter = 3,
-
-        /// <summary>
-        ///     The chain (abbreviated ch) is a unit of length equal to 66 feet (22 yards), used in both the US customary and Imperial unit systems. It is subdivided into 100 links. There are 10 chains in a furlong, and 80 chains in one statute mile. In metric terms, it is 20.1168 m long.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Chain_(unit)</remarks>
-        Chain = 4,
-
-        /// <summary>
-        ///     In radar-related subjects and in JTIDS, a data mile is a unit of distance equal to 6000 feet (1.8288 kilometres or 0.987 nautical miles).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Data_mile</remarks>
-        DataMile = 5,
-        Decameter = 6,
-        Decimeter = 7,
-
-        /// <summary>
-        ///     The pica is a typographic unit of measure corresponding to approximately 1⁄6 of an inch, or from 1⁄68 to 1⁄73 of a foot. One pica is further divided into 12 points.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Pica_(typography)</remarks>
-        DtpPica = 8,
-
-        /// <summary>
-        ///     The desktop publishing point (DTP) is defined as 1⁄72 of an inch (1/72 × 25.4 mm ≈ 0.353 mm) and, as with earlier American point sizes, is considered to be 1⁄12 of a pica.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Point_(typography)</remarks>
-        DtpPoint = 9,
-        Fathom = 10,
-        Femtometer = 48,
-
-        /// <summary>
-        ///     The foot (pl. feet; standard symbol: ft) is a unit of length in the British imperial and United States customary systems of measurement. The prime symbol, ′, is commonly used to represent the foot. In both customary and imperial units, one foot comprises 12 inches, and one yard comprises three feet. Since an international agreement in 1959, the foot is defined as equal to exactly 0.3048 meters.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Foot_(unit)</remarks>
-        Foot = 11,
-        Gigameter = 44,
-
-        /// <summary>
-        ///     The hand is a non-SI unit of measurement of length standardized to 4 in (101.6 mm). It is used to measure the height of horses in many English-speaking countries, including Australia, Canada, Ireland, the United Kingdom, and the United States. It was originally based on the breadth of a human hand.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Hand_(unit)</remarks>
-        Hand = 12,
-        Hectometer = 13,
-
-        /// <summary>
-        ///     The inch (symbol: in or ″) is a unit of length in the British Imperial and the United States customary systems of measurement. It is equal to 1/36 yard or 1/12 of a foot. Derived from the Roman uncia ("twelfth"), the word inch is also sometimes used to translate similar units in other measurement systems, usually understood as deriving from the width of the human thumb.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Inch</remarks>
-        Inch = 14,
-        Kilofoot = 45,
-        KilolightYear = 15,
-        Kilometer = 16,
-        Kiloparsec = 17,
-        Kiloyard = 38,
-
-        /// <summary>
-        ///     A Light Year (ly) is the distance that light travel during an Earth year, ie 365 days.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Light-year</remarks>
-        LightYear = 18,
-        MegalightYear = 19,
-        Megameter = 41,
-        Megaparsec = 20,
-        Meter = 21,
-        Microinch = 22,
-        Micrometer = 23,
-        Mil = 24,
-
-        /// <summary>
-        ///     The statute mile was standardised between the British Commonwealth and the United States by an international agreement in 1959, when it was formally redefined with respect to SI units as exactly 1,609.344 metres.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Mile</remarks>
-        Mile = 25,
-        Millimeter = 26,
-        Nanometer = 27,
-        NauticalMile = 28,
-
-        /// <summary>
-        ///     A parsec is defined as the distance at which one astronomical unit (AU) subtends an angle of one arcsecond.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Parsec</remarks>
-        Parsec = 29,
-        Picometer = 43,
-
-        /// <summary>
-        ///     The American pica of 0.16604 inches (~4.217 mm) was established by the United States Type Founders' Association in 1886. In TeX one pica is 400⁄2409 of an inch.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Pica_(typography)</remarks>
-        PrinterPica = 30,
-
-        /// <summary>
-        ///     In typography, the point is the smallest unit of measure. It is used for measuring font size, leading, and other items on a printed page. In modern times this size of the point has been approximated as exactly 1⁄72.27 (0.01383700013837) of the inch by Donald Knuth for the default unit of his TeX computer typesetting system and is thus sometimes known as the TeX point.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Point_(typography)</remarks>
-        PrinterPoint = 31,
-        Shackle = 32,
-
-        /// <summary>
-        ///     Solar radius is a ratio unit to the radius of the solar system star, the sun.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Stellar_classification</remarks>
-        SolarRadius = 33,
-
-        /// <summary>
-        ///     A twip (abbreviating "twentieth of a point" or "twentieth of an inch point") is a typographical measurement, defined as 1⁄20 of a typographical point. One twip is 1⁄1440 inch, or ~17.64 μm.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Twip</remarks>
-        Twip = 34,
-
-        /// <summary>
-        ///     In the United States, the foot was defined as 12 inches, with the inch being defined by the Mendenhall Order of 1893 as 39.37 inches = 1 m. This makes a U.S. survey foot exactly 1200/3937 meters.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Foot_(unit)</remarks>
-        UsSurveyFoot = 35,
-
-        /// <summary>
-        ///     The yard (symbol: yd) is an English unit of length in both the British imperial and US customary systems of measurement equalling 3 feet (or 36 inches). Since 1959 the yard has been by international agreement standardized as exactly 0.9144 meter. A distance of 1,760 yards is equal to 1 mile.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Yard</remarks>
-        Yard = 36,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/LevelUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/LevelUnit.g.cs
deleted file mode 100644
index 3d1966d2b2..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/LevelUnit.g.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum LevelUnit
-    {
-        Decibel = 1,
-        Neper = 2,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/LinearDensityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/LinearDensityUnit.g.cs
deleted file mode 100644
index 0a410b3294..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/LinearDensityUnit.g.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum LinearDensityUnit
-    {
-        GramPerCentimeter = 1,
-        GramPerFoot = 22,
-        GramPerMeter = 2,
-        GramPerMillimeter = 3,
-        KilogramPerCentimeter = 4,
-        KilogramPerFoot = 19,
-        KilogramPerMeter = 5,
-        KilogramPerMillimeter = 6,
-        MicrogramPerCentimeter = 7,
-        MicrogramPerFoot = 20,
-        MicrogramPerMeter = 8,
-        MicrogramPerMillimeter = 9,
-        MilligramPerCentimeter = 10,
-        MilligramPerFoot = 18,
-        MilligramPerMeter = 11,
-        MilligramPerMillimeter = 12,
-        PoundPerFoot = 13,
-        PoundPerInch = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/LinearPowerDensityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/LinearPowerDensityUnit.g.cs
deleted file mode 100644
index 2ab6e250ac..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/LinearPowerDensityUnit.g.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum LinearPowerDensityUnit
-    {
-        GigawattPerCentimeter = 1,
-        GigawattPerFoot = 2,
-        GigawattPerInch = 3,
-        GigawattPerMeter = 4,
-        GigawattPerMillimeter = 5,
-        KilowattPerCentimeter = 6,
-        KilowattPerFoot = 7,
-        KilowattPerInch = 8,
-        KilowattPerMeter = 9,
-        KilowattPerMillimeter = 10,
-        MegawattPerCentimeter = 11,
-        MegawattPerFoot = 12,
-        MegawattPerInch = 13,
-        MegawattPerMeter = 14,
-        MegawattPerMillimeter = 15,
-        MilliwattPerCentimeter = 16,
-        MilliwattPerFoot = 17,
-        MilliwattPerInch = 18,
-        MilliwattPerMeter = 19,
-        MilliwattPerMillimeter = 20,
-        WattPerCentimeter = 21,
-        WattPerFoot = 22,
-        WattPerInch = 23,
-        WattPerMeter = 24,
-        WattPerMillimeter = 25,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/LuminanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/LuminanceUnit.g.cs
deleted file mode 100644
index 24814e4dcc..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/LuminanceUnit.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum LuminanceUnit
-    {
-        CandelaPerSquareFoot = 10,
-        CandelaPerSquareInch = 7,
-        CandelaPerSquareMeter = 8,
-        CenticandelaPerSquareMeter = 3,
-        DecicandelaPerSquareMeter = 4,
-        KilocandelaPerSquareMeter = 9,
-        MicrocandelaPerSquareMeter = 6,
-        MillicandelaPerSquareMeter = 2,
-        NanocandelaPerSquareMeter = 1,
-        /// <remarks>https://www.britannica.com/science/luminosity</remarks>
-        Nit = 5,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/LuminosityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/LuminosityUnit.g.cs
deleted file mode 100644
index f15cfe1cef..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/LuminosityUnit.g.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum LuminosityUnit
-    {
-        Decawatt = 1,
-        Deciwatt = 2,
-        Femtowatt = 3,
-        Gigawatt = 4,
-        Kilowatt = 5,
-        Megawatt = 6,
-        Microwatt = 7,
-        Milliwatt = 8,
-        Nanowatt = 9,
-        Petawatt = 10,
-        Picowatt = 11,
-
-        /// <summary>
-        ///     The IAU has defined a nominal solar luminosity of 3.828×10^26 W to promote publication of consistent and comparable values in units of the solar luminosity.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Luminosity#Measurement</remarks>
-        SolarLuminosity = 12,
-        Terawatt = 13,
-        Watt = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/LuminousFluxUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/LuminousFluxUnit.g.cs
deleted file mode 100644
index 01a956a02c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/LuminousFluxUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum LuminousFluxUnit
-    {
-        Lumen = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/LuminousIntensityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/LuminousIntensityUnit.g.cs
deleted file mode 100644
index 947d36fb22..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/LuminousIntensityUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum LuminousIntensityUnit
-    {
-        Candela = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MagneticFieldUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MagneticFieldUnit.g.cs
deleted file mode 100644
index 3915ff523d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MagneticFieldUnit.g.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MagneticFieldUnit
-    {
-        Gauss = 1,
-        Microtesla = 2,
-        Milligauss = 3,
-        Millitesla = 4,
-        Nanotesla = 5,
-        Tesla = 6,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MagneticFluxUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MagneticFluxUnit.g.cs
deleted file mode 100644
index e7f3635d2e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MagneticFluxUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MagneticFluxUnit
-    {
-        Weber = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MagnetizationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MagnetizationUnit.g.cs
deleted file mode 100644
index 956c88e2da..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MagnetizationUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MagnetizationUnit
-    {
-        AmperePerMeter = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MassConcentrationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MassConcentrationUnit.g.cs
deleted file mode 100644
index e80ca6a945..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MassConcentrationUnit.g.cs
+++ /dev/null
@@ -1,80 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MassConcentrationUnit
-    {
-        CentigramPerDeciliter = 1,
-        CentigramPerLiter = 2,
-        CentigramPerMicroliter = 3,
-        CentigramPerMilliliter = 4,
-        DecigramPerDeciliter = 5,
-        DecigramPerLiter = 6,
-        DecigramPerMicroliter = 7,
-        DecigramPerMilliliter = 8,
-        GramPerCubicCentimeter = 9,
-        GramPerCubicMeter = 10,
-        GramPerCubicMillimeter = 11,
-        GramPerDeciliter = 12,
-        GramPerLiter = 13,
-        GramPerMicroliter = 14,
-        GramPerMilliliter = 15,
-        KilogramPerCubicCentimeter = 16,
-        KilogramPerCubicMeter = 17,
-        KilogramPerCubicMillimeter = 18,
-        KilogramPerLiter = 19,
-        KilopoundPerCubicFoot = 20,
-        KilopoundPerCubicInch = 21,
-        MicrogramPerCubicMeter = 22,
-        MicrogramPerDeciliter = 23,
-        MicrogramPerLiter = 24,
-        MicrogramPerMicroliter = 25,
-        MicrogramPerMilliliter = 26,
-        MilligramPerCubicMeter = 27,
-        MilligramPerDeciliter = 28,
-        MilligramPerLiter = 29,
-        MilligramPerMicroliter = 30,
-        MilligramPerMilliliter = 31,
-        NanogramPerDeciliter = 32,
-        NanogramPerLiter = 33,
-        NanogramPerMicroliter = 34,
-        NanogramPerMilliliter = 35,
-        OuncePerImperialGallon = 36,
-        OuncePerUSGallon = 37,
-        PicogramPerDeciliter = 38,
-        PicogramPerLiter = 39,
-        PicogramPerMicroliter = 40,
-        PicogramPerMilliliter = 41,
-        PoundPerCubicFoot = 42,
-        PoundPerCubicInch = 43,
-        PoundPerImperialGallon = 44,
-        PoundPerUSGallon = 45,
-        SlugPerCubicFoot = 46,
-        TonnePerCubicCentimeter = 47,
-        TonnePerCubicMeter = 48,
-        TonnePerCubicMillimeter = 49,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MassFlowUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MassFlowUnit.g.cs
deleted file mode 100644
index 7df77cf7b5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MassFlowUnit.g.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MassFlowUnit
-    {
-        CentigramPerDay = 1,
-        CentigramPerSecond = 2,
-        DecagramPerDay = 3,
-        DecagramPerSecond = 4,
-        DecigramPerDay = 5,
-        DecigramPerSecond = 6,
-        GramPerDay = 7,
-        GramPerHour = 8,
-        GramPerSecond = 9,
-        HectogramPerDay = 10,
-        HectogramPerSecond = 11,
-        KilogramPerDay = 12,
-        KilogramPerHour = 13,
-        KilogramPerMinute = 14,
-        KilogramPerSecond = 15,
-        MegagramPerDay = 16,
-        MegapoundPerDay = 17,
-        MegapoundPerHour = 18,
-        MegapoundPerMinute = 19,
-        MegapoundPerSecond = 20,
-        MicrogramPerDay = 21,
-        MicrogramPerSecond = 22,
-        MilligramPerDay = 23,
-        MilligramPerSecond = 24,
-        NanogramPerDay = 25,
-        NanogramPerSecond = 26,
-        PoundPerDay = 27,
-        PoundPerHour = 28,
-        PoundPerMinute = 29,
-        PoundPerSecond = 30,
-        ShortTonPerHour = 31,
-        TonnePerDay = 32,
-        TonnePerHour = 33,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MassFluxUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MassFluxUnit.g.cs
deleted file mode 100644
index def9d86acb..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MassFluxUnit.g.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MassFluxUnit
-    {
-        GramPerHourPerSquareCentimeter = 1,
-        GramPerHourPerSquareMeter = 2,
-        GramPerHourPerSquareMillimeter = 3,
-        GramPerSecondPerSquareCentimeter = 4,
-        GramPerSecondPerSquareMeter = 5,
-        GramPerSecondPerSquareMillimeter = 6,
-        KilogramPerHourPerSquareCentimeter = 7,
-        KilogramPerHourPerSquareMeter = 8,
-        KilogramPerHourPerSquareMillimeter = 9,
-        KilogramPerSecondPerSquareCentimeter = 10,
-        KilogramPerSecondPerSquareMeter = 11,
-        KilogramPerSecondPerSquareMillimeter = 12,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MassFractionUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MassFractionUnit.g.cs
deleted file mode 100644
index 0dad8a059f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MassFractionUnit.g.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MassFractionUnit
-    {
-        CentigramPerGram = 1,
-        CentigramPerKilogram = 2,
-        DecagramPerGram = 3,
-        DecagramPerKilogram = 4,
-        DecigramPerGram = 5,
-        DecigramPerKilogram = 6,
-        DecimalFraction = 7,
-        GramPerGram = 8,
-        GramPerKilogram = 9,
-        HectogramPerGram = 10,
-        HectogramPerKilogram = 11,
-        KilogramPerGram = 12,
-        KilogramPerKilogram = 13,
-        MicrogramPerGram = 14,
-        MicrogramPerKilogram = 15,
-        MilligramPerGram = 16,
-        MilligramPerKilogram = 17,
-        NanogramPerGram = 18,
-        NanogramPerKilogram = 19,
-        PartPerBillion = 20,
-        PartPerMillion = 21,
-        PartPerThousand = 22,
-        PartPerTrillion = 23,
-        Percent = 24,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MassMomentOfInertiaUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MassMomentOfInertiaUnit.g.cs
deleted file mode 100644
index 05827647fd..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MassMomentOfInertiaUnit.g.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MassMomentOfInertiaUnit
-    {
-        GramSquareCentimeter = 1,
-        GramSquareDecimeter = 2,
-        GramSquareMeter = 3,
-        GramSquareMillimeter = 4,
-        KilogramSquareCentimeter = 5,
-        KilogramSquareDecimeter = 6,
-        KilogramSquareMeter = 7,
-        KilogramSquareMillimeter = 8,
-        KilotonneSquareCentimeter = 9,
-        KilotonneSquareDecimeter = 10,
-        KilotonneSquareMeter = 11,
-        KilotonneSquareMillimeter = 12,
-        MegatonneSquareCentimeter = 13,
-        MegatonneSquareDecimeter = 14,
-        MegatonneSquareMeter = 15,
-        MegatonneSquareMillimeter = 16,
-        MilligramSquareCentimeter = 17,
-        MilligramSquareDecimeter = 18,
-        MilligramSquareMeter = 19,
-        MilligramSquareMillimeter = 20,
-        PoundSquareFoot = 21,
-        PoundSquareInch = 22,
-        SlugSquareFoot = 23,
-        SlugSquareInch = 24,
-        TonneSquareCentimeter = 25,
-        TonneSquareDecimeter = 26,
-        TonneSquareMeter = 27,
-        TonneSquareMillimeter = 28,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MassUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MassUnit.g.cs
deleted file mode 100644
index 55b385ee83..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MassUnit.g.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MassUnit
-    {
-        Centigram = 1,
-
-        /// <summary>
-        ///     The Dalton or unified atomic mass unit (abbreviation Da or u) is a unit of mass defined as 1/12 of the mass of an unbound neutral atom of carbon-12 in its nuclear and electronic ground state and at rest.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Dalton_(unit)</remarks>
-        Dalton = 37,
-        Decagram = 2,
-        Decigram = 3,
-
-        /// <summary>
-        ///     Earth mass is a ratio unit to the mass of planet Earth.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Earth_mass</remarks>
-        EarthMass = 4,
-        Femtogram = 35,
-        Gigadalton = 33,
-
-        /// <summary>
-        ///     A grain is a unit of measurement of mass, and in the troy weight, avoirdupois, and Apothecaries' system, equal to exactly 64.79891 milligrams.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Grain_(unit)</remarks>
-        Grain = 5,
-        Gram = 6,
-        Hectogram = 7,
-        Kilodalton = 26,
-        Kilogram = 8,
-        Kilopound = 9,
-        Kilotonne = 10,
-
-        /// <summary>
-        ///     The long or imperial hundredweight (abbreviation cwt) is a unit of mass equal to 112 pounds in US and Canada.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Hundredweight</remarks>
-        LongHundredweight = 11,
-
-        /// <summary>
-        ///     Long ton (weight ton or Imperial ton) is a unit of mass equal to 2,240 pounds (1,016 kg) and is the name for the unit called the "ton" in the avoirdupois or Imperial system of measurements that was used in the United Kingdom and several other Commonwealth countries before metrication.
-        /// </summary>
-        /// <remarks>http://en.wikipedia.org/wiki/Long_ton</remarks>
-        LongTon = 12,
-        Megadalton = 30,
-        Megapound = 13,
-        Megatonne = 14,
-        Microgram = 15,
-        Milligram = 16,
-        Nanogram = 17,
-
-        /// <summary>
-        ///     The international avoirdupois ounce (abbreviated oz) is defined as exactly 28.349523125 g under the international yard and pound agreement of 1959, signed by the United States and countries of the Commonwealth of Nations. 16 oz make up an avoirdupois pound.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Ounce</remarks>
-        Ounce = 18,
-        Picogram = 29,
-
-        /// <summary>
-        ///     The pound or pound-mass (abbreviations: lb, lbm) is a unit of mass used in the imperial, United States customary and other systems of measurement. A number of different definitions have been used, the most common today being the international avoirdupois pound which is legally defined as exactly 0.45359237 kilograms, and which is divided into 16 avoirdupois ounces.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Pound_(mass)</remarks>
-        Pound = 19,
-
-        /// <summary>
-        ///     The short hundredweight (abbreviation cwt) is a unit of mass equal to 100 pounds in US and Canada. In British English, the short hundredweight is referred to as the "cental".
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Hundredweight</remarks>
-        ShortHundredweight = 20,
-
-        /// <summary>
-        ///     The short ton is a unit of mass equal to 2,000 pounds (907.18474 kg), that is most commonly used in the United States – known there simply as the ton.
-        /// </summary>
-        /// <remarks>http://en.wikipedia.org/wiki/Short_ton</remarks>
-        ShortTon = 21,
-
-        /// <summary>
-        ///     The slug (abbreviation slug) is a unit of mass that is accelerated by 1 ft/s² when a force of one pound (lbf) is exerted on it.
-        /// </summary>
-        /// <remarks>http://en.wikipedia.org/wiki/Slug_(unit)</remarks>
-        Slug = 22,
-
-        /// <summary>
-        ///     Solar mass is a ratio unit to the mass of the solar system star, the sun.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Solar_mass</remarks>
-        SolarMass = 23,
-
-        /// <summary>
-        ///     The stone (abbreviation st) is a unit of mass equal to 14 pounds avoirdupois (about 6.35 kilograms) used in Great Britain and Ireland for measuring human body weight.
-        /// </summary>
-        /// <remarks>http://en.wikipedia.org/wiki/Stone_(unit)</remarks>
-        Stone = 24,
-
-        /// <summary>
-        ///     The tonne is a unit of mass equal to 1,000 kilograms. It is a non-SI unit accepted for use with SI. It is also referred to as a metric ton in the United States to distinguish it from the non-metric units of the short ton (United States customary units) and the long ton (British imperial units). It is equivalent to approximately 2,204.6 pounds, 1.102 short tons, and 0.984 long tons.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Tonne</remarks>
-        Tonne = 25,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MolalityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MolalityUnit.g.cs
deleted file mode 100644
index d55c5fb6d0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MolalityUnit.g.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MolalityUnit
-    {
-        MillimolePerKilogram = 2,
-        MolePerGram = 4,
-        MolePerKilogram = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MolarEnergyUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MolarEnergyUnit.g.cs
deleted file mode 100644
index 71772f28ea..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MolarEnergyUnit.g.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MolarEnergyUnit
-    {
-        JoulePerMole = 1,
-        KilojoulePerMole = 2,
-        MegajoulePerMole = 3,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MolarEntropyUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MolarEntropyUnit.g.cs
deleted file mode 100644
index b7e6c5aa56..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MolarEntropyUnit.g.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MolarEntropyUnit
-    {
-        JoulePerMoleKelvin = 1,
-        KilojoulePerMoleKelvin = 2,
-        MegajoulePerMoleKelvin = 3,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MolarFlowUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MolarFlowUnit.g.cs
deleted file mode 100644
index 48bc201810..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MolarFlowUnit.g.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MolarFlowUnit
-    {
-        KilomolePerHour = 2,
-        KilomolePerMinute = 15,
-        KilomolePerSecond = 12,
-        MolePerHour = 8,
-        MolePerMinute = 18,
-        MolePerSecond = 3,
-        PoundMolePerHour = 6,
-        PoundMolePerMinute = 7,
-        PoundMolePerSecond = 4,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MolarMassUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MolarMassUnit.g.cs
deleted file mode 100644
index 4be43903ef..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MolarMassUnit.g.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MolarMassUnit
-    {
-        CentigramPerMole = 1,
-        DecagramPerMole = 2,
-        DecigramPerMole = 3,
-        GramPerMole = 4,
-        HectogramPerMole = 5,
-        KilogramPerKilomole = 15,
-        KilogramPerMole = 6,
-        KilopoundPerMole = 7,
-        MegapoundPerMole = 8,
-        MicrogramPerMole = 9,
-        MilligramPerMole = 10,
-        NanogramPerMole = 11,
-        PoundPerMole = 12,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MolarityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MolarityUnit.g.cs
deleted file mode 100644
index d9c7972422..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MolarityUnit.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum MolarityUnit
-    {
-        CentimolePerLiter = 1,
-        DecimolePerLiter = 3,
-        FemtomolePerLiter = 5,
-        KilomolePerCubicMeter = 25,
-        MicromolePerLiter = 6,
-        MillimolePerLiter = 8,
-        MolePerCubicMeter = 10,
-        MolePerLiter = 11,
-        NanomolePerLiter = 14,
-        PicomolePerLiter = 16,
-        PoundMolePerCubicFoot = 18,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PermeabilityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PermeabilityUnit.g.cs
deleted file mode 100644
index 19860cb22a..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/PermeabilityUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum PermeabilityUnit
-    {
-        HenryPerMeter = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PermittivityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PermittivityUnit.g.cs
deleted file mode 100644
index 77e869b6fe..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/PermittivityUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum PermittivityUnit
-    {
-        FaradPerMeter = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PorousMediumPermeabilityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PorousMediumPermeabilityUnit.g.cs
deleted file mode 100644
index 0ef3c52664..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/PorousMediumPermeabilityUnit.g.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum PorousMediumPermeabilityUnit
-    {
-
-        /// <summary>
-        ///     The darcy (or darcy unit) and millidarcy (md or mD) are units of permeability, named after Henry Darcy. They are not SI units, but they are widely used in petroleum engineering and geology.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Darcy_(unit)</remarks>
-        Darcy = 1,
-        Microdarcy = 2,
-        Millidarcy = 3,
-        SquareCentimeter = 4,
-        SquareMeter = 5,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PowerDensityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PowerDensityUnit.g.cs
deleted file mode 100644
index 74a52d1da5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/PowerDensityUnit.g.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum PowerDensityUnit
-    {
-        DecawattPerCubicFoot = 1,
-        DecawattPerCubicInch = 2,
-        DecawattPerCubicMeter = 3,
-        DecawattPerLiter = 4,
-        DeciwattPerCubicFoot = 5,
-        DeciwattPerCubicInch = 6,
-        DeciwattPerCubicMeter = 7,
-        DeciwattPerLiter = 8,
-        GigawattPerCubicFoot = 9,
-        GigawattPerCubicInch = 10,
-        GigawattPerCubicMeter = 11,
-        GigawattPerLiter = 12,
-        KilowattPerCubicFoot = 13,
-        KilowattPerCubicInch = 14,
-        KilowattPerCubicMeter = 15,
-        KilowattPerLiter = 16,
-        MegawattPerCubicFoot = 17,
-        MegawattPerCubicInch = 18,
-        MegawattPerCubicMeter = 19,
-        MegawattPerLiter = 20,
-        MicrowattPerCubicFoot = 21,
-        MicrowattPerCubicInch = 22,
-        MicrowattPerCubicMeter = 23,
-        MicrowattPerLiter = 24,
-        MilliwattPerCubicFoot = 25,
-        MilliwattPerCubicInch = 26,
-        MilliwattPerCubicMeter = 27,
-        MilliwattPerLiter = 28,
-        NanowattPerCubicFoot = 29,
-        NanowattPerCubicInch = 30,
-        NanowattPerCubicMeter = 31,
-        NanowattPerLiter = 32,
-        PicowattPerCubicFoot = 33,
-        PicowattPerCubicInch = 34,
-        PicowattPerCubicMeter = 35,
-        PicowattPerLiter = 36,
-        TerawattPerCubicFoot = 37,
-        TerawattPerCubicInch = 38,
-        TerawattPerCubicMeter = 39,
-        TerawattPerLiter = 40,
-        WattPerCubicFoot = 41,
-        WattPerCubicInch = 42,
-        WattPerCubicMeter = 43,
-        WattPerLiter = 44,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PowerRatioUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PowerRatioUnit.g.cs
deleted file mode 100644
index f0c4dc508c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/PowerRatioUnit.g.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum PowerRatioUnit
-    {
-        DecibelMilliwatt = 1,
-        DecibelWatt = 2,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PowerUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PowerUnit.g.cs
deleted file mode 100644
index c0ddfe10ec..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/PowerUnit.g.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum PowerUnit
-    {
-
-        /// <summary>
-        ///     Boiler horsepower is a boiler's capacity to deliver steam to a steam engine and is not the same unit of power as the 550 ft lb/s definition. One boiler horsepower is equal to the thermal energy rate required to evaporate 34.5 pounds (15.6 kg) of fresh water at 212 °F (100 °C) in one hour.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Horsepower#Boiler_horsepower</remarks>
-        BoilerHorsepower = 1,
-        /// <remarks>Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details.</remarks>
-        BritishThermalUnitPerHour = 2,
-        Decawatt = 3,
-        Deciwatt = 4,
-
-        /// <summary>
-        ///     Nameplates on electrical motors show their power output, not the power input (the power delivered at the shaft, not the power consumed to drive the motor). This power output is ordinarily stated in watts or kilowatts. In the United States, the power output is stated in horsepower, which for this purpose is defined as exactly 746 W.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Horsepower#Electrical_horsepower</remarks>
-        ElectricalHorsepower = 5,
-        Femtowatt = 6,
-        GigajoulePerHour = 7,
-        Gigawatt = 8,
-
-        /// <summary>
-        ///     Hydraulic horsepower can represent the power available within hydraulic machinery, power through the down-hole nozzle of a drilling rig, or can be used to estimate the mechanical power needed to generate a known hydraulic flow rate.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Horsepower#Hydraulic_horsepower</remarks>
-        HydraulicHorsepower = 9,
-        JoulePerHour = 10,
-        KilobritishThermalUnitPerHour = 11,
-        KilojoulePerHour = 12,
-        Kilowatt = 13,
-
-        /// <summary>
-        ///     Assuming the third CGPM (1901, CR 70) definition of standard gravity, gn = 9.80665 m/s2, is used to define the pound-force as well as the kilogram force, and the international avoirdupois pound (1959), one imperial horsepower is: 76.0402249 × 9.80665 kg⋅m2/s3
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Horsepower#Imperial_horsepower</remarks>
-        MechanicalHorsepower = 14,
-        MegabritishThermalUnitPerHour = 15,
-        MegajoulePerHour = 16,
-        Megawatt = 17,
-
-        /// <summary>
-        ///     DIN 66036 defines one metric horsepower as the power to raise a mass of 75 kilograms against the Earth's gravitational force over a distance of one metre in one second:[18] 75 kg × 9.80665 m/s2 × 1 m / 1 s = 75 kgf⋅m/s = 1 PS. This is equivalent to 735.49875 W, or 98.6% of an imperial horsepower.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Horsepower#Metric_horsepower_(PS,_KM,_cv,_hk,_pk,_k,_ks,_ch)</remarks>
-        MetricHorsepower = 18,
-        Microwatt = 19,
-        MillijoulePerHour = 20,
-        Milliwatt = 21,
-        Nanowatt = 22,
-        Petawatt = 23,
-        Picowatt = 24,
-        Terawatt = 25,
-        TonOfRefrigeration = 29,
-        Watt = 26,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PressureChangeRateUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PressureChangeRateUnit.g.cs
deleted file mode 100644
index 8593e5b890..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/PressureChangeRateUnit.g.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum PressureChangeRateUnit
-    {
-        AtmospherePerSecond = 1,
-        BarPerMinute = 16,
-        BarPerSecond = 23,
-        KilopascalPerMinute = 2,
-        KilopascalPerSecond = 3,
-        KilopoundForcePerSquareInchPerMinute = 4,
-        KilopoundForcePerSquareInchPerSecond = 5,
-        MegapascalPerMinute = 6,
-        MegapascalPerSecond = 7,
-        MegapoundForcePerSquareInchPerMinute = 8,
-        MegapoundForcePerSquareInchPerSecond = 9,
-        MillibarPerMinute = 24,
-        MillibarPerSecond = 20,
-        MillimeterOfMercuryPerSecond = 10,
-        PascalPerMinute = 11,
-        PascalPerSecond = 12,
-        PoundForcePerSquareInchPerMinute = 13,
-        PoundForcePerSquareInchPerSecond = 14,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PressureUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PressureUnit.g.cs
deleted file mode 100644
index dbcff54072..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/PressureUnit.g.cs
+++ /dev/null
@@ -1,124 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum PressureUnit
-    {
-
-        /// <summary>
-        ///     The standard atmosphere (symbol: atm) is a unit of pressure defined as 101325 Pa. It is sometimes used as a reference pressure or standard pressure. It is approximately equal to Earth's average atmospheric pressure at sea level.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Standard_atmosphere_(unit)</remarks>
-        Atmosphere = 1,
-
-        /// <summary>
-        ///     The bar is a metric unit of pressure defined as 100,000 Pa (100 kPa), though not part of the International System of Units (SI). A pressure of 1 bar is slightly less than the current average atmospheric pressure on Earth at sea level (approximately 1.013 bar).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Bar_(unit)</remarks>
-        Bar = 2,
-        Centibar = 3,
-        CentimeterOfWaterColumn = 48,
-        Decapascal = 4,
-        Decibar = 5,
-        DynePerSquareCentimeter = 6,
-        FootOfHead = 8,
-        Gigapascal = 9,
-        Hectopascal = 10,
-
-        /// <summary>
-        ///     Inch of mercury (inHg and ″Hg) is a non-SI unit of measurement for pressure. It is used for barometric pressure in weather reports, refrigeration and aviation in the United States. It is the pressure exerted by a column of mercury 1 inch (25.4 mm) in height at the standard acceleration of gravity.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Inch_of_mercury</remarks>
-        InchOfMercury = 11,
-
-        /// <summary>
-        ///     Inches of water is a non-SI unit for pressure. It is defined as the pressure exerted by a column of water of 1 inch in height at defined conditions. At a temperature of 4 °C (39.2 °F) pure water has its highest density (1000 kg/m3). At that temperature and assuming the standard acceleration of gravity, 1 inAq is approximately 249.082 pascals (0.0361263 psi).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Inch_of_water</remarks>
-        InchOfWaterColumn = 12,
-        Kilobar = 13,
-
-        /// <summary>
-        ///     A kilogram-force per centimetre square (kgf/cm2), often just kilogram per square centimetre (kg/cm2), or kilopond per centimetre square (kp/cm2) is a deprecated unit of pressure using metric units. It is not a part of the International System of Units (SI), the modern metric system. 1 kgf/cm2 equals 98.0665 kPa (kilopascals). It is also known as a technical atmosphere (symbol: at).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Kilogram-force_per_square_centimetre</remarks>
-        KilogramForcePerSquareCentimeter = 14,
-        KilogramForcePerSquareMeter = 15,
-        KilogramForcePerSquareMillimeter = 16,
-        KilonewtonPerSquareCentimeter = 17,
-        KilonewtonPerSquareMeter = 18,
-        KilonewtonPerSquareMillimeter = 19,
-        Kilopascal = 20,
-        KilopoundForcePerSquareFoot = 21,
-        KilopoundForcePerSquareInch = 22,
-        KilopoundForcePerSquareMil = 23,
-        Megabar = 24,
-        MeganewtonPerSquareMeter = 25,
-        Megapascal = 26,
-        MeterOfHead = 28,
-
-        /// <summary>
-        ///     A centimetre of water is defined as the pressure exerted by a column of water of 1 cm in height at 4 °C (temperature of maximum density) at the standard acceleration of gravity, so that 1 cmH2O (4°C) = 999.9720 kg/m3 × 9.80665 m/s2 × 1 cm = 98.063754138 Pa, but conventionally a nominal maximum water density of 1000 kg/m3 is used, giving 98.0665 Pa.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Centimetre_or_millimetre_of_water</remarks>
-        MeterOfWaterColumn = 57,
-        Microbar = 29,
-        Micropascal = 30,
-        Millibar = 31,
-
-        /// <summary>
-        ///     A millimetre of mercury is a manometric unit of pressure, formerly defined as the extra pressure generated by a column of mercury one millimetre high, and currently defined as exactly 133.322387415 pascals.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Millimetre_of_mercury</remarks>
-        MillimeterOfMercury = 32,
-        MillimeterOfWaterColumn = 33,
-        Millipascal = 34,
-        Millitorr = 52,
-        NewtonPerSquareCentimeter = 35,
-        NewtonPerSquareMeter = 36,
-        NewtonPerSquareMillimeter = 37,
-        Pascal = 38,
-        PoundForcePerSquareFoot = 39,
-        PoundForcePerSquareInch = 40,
-        PoundForcePerSquareMil = 41,
-        PoundPerInchSecondSquared = 42,
-
-        /// <summary>
-        ///     A kilogram-force per centimetre square (kgf/cm2), often just kilogram per square centimetre (kg/cm2), or kilopond per centimetre square (kp/cm2) is a deprecated unit of pressure using metric units. It is not a part of the International System of Units (SI), the modern metric system. 1 kgf/cm2 equals 98.0665 kPa (kilopascals). It is also known as a technical atmosphere (symbol: at).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Kilogram-force_per_square_centimetre</remarks>
-        TechnicalAtmosphere = 43,
-        TonneForcePerSquareCentimeter = 44,
-        TonneForcePerSquareMeter = 45,
-        TonneForcePerSquareMillimeter = 46,
-
-        /// <summary>
-        ///     The torr (symbol: Torr) is a unit of pressure based on an absolute scale, defined as exactly 1/760 of a standard atmosphere (101325 Pa). Thus one torr is exactly 101325/760 pascals (≈ 133.32 Pa).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Torr</remarks>
-        Torr = 47,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RadiationEquivalentDoseRateUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RadiationEquivalentDoseRateUnit.g.cs
deleted file mode 100644
index df74f109e8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RadiationEquivalentDoseRateUnit.g.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RadiationEquivalentDoseRateUnit
-    {
-        MicrosievertPerHour = 1,
-        MicrosievertPerSecond = 17,
-        MilliroentgenEquivalentManPerHour = 4,
-        MillisievertPerHour = 3,
-        MillisievertPerSecond = 14,
-        NanosievertPerHour = 2,
-        NanosievertPerSecond = 9,
-        RoentgenEquivalentManPerHour = 5,
-        SievertPerHour = 6,
-        SievertPerSecond = 16,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RadiationEquivalentDoseUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RadiationEquivalentDoseUnit.g.cs
deleted file mode 100644
index 2095852833..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RadiationEquivalentDoseUnit.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RadiationEquivalentDoseUnit
-    {
-        Microsievert = 1,
-        MilliroentgenEquivalentMan = 2,
-        Millisievert = 7,
-        Nanosievert = 5,
-        RoentgenEquivalentMan = 4,
-
-        /// <summary>
-        ///     The sievert is a unit in the International System of Units (SI) intended to represent the stochastic health risk of ionizing radiation, which is defined as the probability of causing radiation-induced cancer and genetic damage.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Sievert</remarks>
-        Sievert = 9,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RadiationExposureUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RadiationExposureUnit.g.cs
deleted file mode 100644
index 8e50cdd24f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RadiationExposureUnit.g.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RadiationExposureUnit
-    {
-        CoulombPerKilogram = 10,
-        MicrocoulombPerKilogram = 3,
-        Microroentgen = 12,
-        MillicoulombPerKilogram = 2,
-        Milliroentgen = 13,
-        NanocoulombPerKilogram = 6,
-        PicocoulombPerKilogram = 5,
-        Roentgen = 4,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RadioactivityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RadioactivityUnit.g.cs
deleted file mode 100644
index 0d77aa4e6d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RadioactivityUnit.g.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RadioactivityUnit
-    {
-
-        /// <summary>
-        ///     Activity of a quantity of radioactive material in which one nucleus decays per second.
-        /// </summary>
-        Becquerel = 7,
-        Curie = 9,
-        Exabecquerel = 10,
-        Gigabecquerel = 4,
-        Gigacurie = 5,
-        Gigarutherford = 1,
-        Kilobecquerel = 6,
-        Kilocurie = 8,
-        Kilorutherford = 2,
-        Megabecquerel = 3,
-        Megacurie = 20,
-        Megarutherford = 13,
-        Microbecquerel = 19,
-        Microcurie = 15,
-        Microrutherford = 14,
-        Millibecquerel = 17,
-        Millicurie = 18,
-        Millirutherford = 12,
-        Nanobecquerel = 16,
-        Nanocurie = 11,
-        Nanorutherford = 27,
-        Petabecquerel = 21,
-        Picobecquerel = 36,
-        Picocurie = 35,
-        Picorutherford = 25,
-
-        /// <summary>
-        ///     Activity of a quantity of radioactive material in which one million nuclei decay per second.
-        /// </summary>
-        Rutherford = 28,
-        Terabecquerel = 23,
-        Teracurie = 29,
-        Terarutherford = 22,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RatioChangeRateUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RatioChangeRateUnit.g.cs
deleted file mode 100644
index 8537a14a05..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RatioChangeRateUnit.g.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RatioChangeRateUnit
-    {
-        DecimalFractionPerSecond = 1,
-        PercentPerSecond = 2,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RatioUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RatioUnit.g.cs
deleted file mode 100644
index 32a4540bc5..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RatioUnit.g.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RatioUnit
-    {
-        DecimalFraction = 1,
-        PartPerBillion = 2,
-        PartPerMillion = 3,
-        PartPerThousand = 4,
-        PartPerTrillion = 5,
-        Percent = 6,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ReciprocalAreaUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ReciprocalAreaUnit.g.cs
deleted file mode 100644
index a1263b27b9..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ReciprocalAreaUnit.g.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ReciprocalAreaUnit
-    {
-        InverseSquareCentimeter = 1,
-        InverseSquareDecimeter = 2,
-        InverseSquareFoot = 3,
-        InverseSquareInch = 4,
-        InverseSquareKilometer = 5,
-        InverseSquareMeter = 6,
-        InverseSquareMicrometer = 7,
-        InverseSquareMile = 8,
-        InverseSquareMillimeter = 9,
-        InverseSquareYard = 10,
-        InverseUsSurveySquareFoot = 11,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ReciprocalLengthUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ReciprocalLengthUnit.g.cs
deleted file mode 100644
index fb9d93700c..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ReciprocalLengthUnit.g.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ReciprocalLengthUnit
-    {
-        InverseCentimeter = 1,
-        InverseFoot = 2,
-        InverseInch = 3,
-        InverseMeter = 4,
-        InverseMicroinch = 5,
-        InverseMil = 6,
-        InverseMile = 7,
-        InverseMillimeter = 8,
-        InverseUsSurveyFoot = 9,
-        InverseYard = 10,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RelativeHumidityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RelativeHumidityUnit.g.cs
deleted file mode 100644
index 5962021a21..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RelativeHumidityUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RelativeHumidityUnit
-    {
-        Percent = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalAccelerationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalAccelerationUnit.g.cs
deleted file mode 100644
index 78d18c4ea1..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalAccelerationUnit.g.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RotationalAccelerationUnit
-    {
-        DegreePerSecondSquared = 1,
-        RadianPerSecondSquared = 2,
-        RevolutionPerMinutePerSecond = 3,
-        RevolutionPerSecondSquared = 4,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalSpeedUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalSpeedUnit.g.cs
deleted file mode 100644
index c764514ede..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalSpeedUnit.g.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RotationalSpeedUnit
-    {
-        CentiradianPerSecond = 1,
-        DeciradianPerSecond = 2,
-        DegreePerMinute = 3,
-        DegreePerSecond = 4,
-        MicrodegreePerSecond = 5,
-        MicroradianPerSecond = 6,
-        MillidegreePerSecond = 7,
-        MilliradianPerSecond = 8,
-        NanodegreePerSecond = 9,
-        NanoradianPerSecond = 10,
-        RadianPerSecond = 11,
-        RevolutionPerMinute = 12,
-        RevolutionPerSecond = 13,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalStiffnessPerLengthUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalStiffnessPerLengthUnit.g.cs
deleted file mode 100644
index 3829297d44..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalStiffnessPerLengthUnit.g.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RotationalStiffnessPerLengthUnit
-    {
-        KilonewtonMeterPerRadianPerMeter = 1,
-        KilopoundForceFootPerDegreesPerFoot = 2,
-        MeganewtonMeterPerRadianPerMeter = 3,
-        NewtonMeterPerRadianPerMeter = 4,
-        PoundForceFootPerDegreesPerFoot = 5,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalStiffnessUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalStiffnessUnit.g.cs
deleted file mode 100644
index 1974383356..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/RotationalStiffnessUnit.g.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum RotationalStiffnessUnit
-    {
-        CentinewtonMeterPerDegree = 1,
-        CentinewtonMillimeterPerDegree = 2,
-        CentinewtonMillimeterPerRadian = 3,
-        DecanewtonMeterPerDegree = 4,
-        DecanewtonMillimeterPerDegree = 5,
-        DecanewtonMillimeterPerRadian = 6,
-        DecinewtonMeterPerDegree = 7,
-        DecinewtonMillimeterPerDegree = 8,
-        DecinewtonMillimeterPerRadian = 9,
-        KilonewtonMeterPerDegree = 10,
-        KilonewtonMeterPerRadian = 11,
-        KilonewtonMillimeterPerDegree = 12,
-        KilonewtonMillimeterPerRadian = 13,
-        KilopoundForceFootPerDegrees = 14,
-        KilopoundForceFootPerRadian = 38,
-        MeganewtonMeterPerDegree = 15,
-        MeganewtonMeterPerRadian = 16,
-        MeganewtonMillimeterPerDegree = 17,
-        MeganewtonMillimeterPerRadian = 18,
-        MicronewtonMeterPerDegree = 19,
-        MicronewtonMillimeterPerDegree = 20,
-        MicronewtonMillimeterPerRadian = 21,
-        MillinewtonMeterPerDegree = 22,
-        MillinewtonMillimeterPerDegree = 23,
-        MillinewtonMillimeterPerRadian = 24,
-        NanonewtonMeterPerDegree = 25,
-        NanonewtonMillimeterPerDegree = 26,
-        NanonewtonMillimeterPerRadian = 27,
-        NewtonMeterPerDegree = 28,
-        NewtonMeterPerRadian = 29,
-        NewtonMillimeterPerDegree = 30,
-        NewtonMillimeterPerRadian = 31,
-        PoundForceFeetPerRadian = 32,
-        PoundForceFootPerDegrees = 33,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ScalarUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ScalarUnit.g.cs
deleted file mode 100644
index c8be591b38..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ScalarUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ScalarUnit
-    {
-        Amount = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/SolidAngleUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/SolidAngleUnit.g.cs
deleted file mode 100644
index 7be81ae1a0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/SolidAngleUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum SolidAngleUnit
-    {
-        Steradian = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificEnergyUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificEnergyUnit.g.cs
deleted file mode 100644
index 1bc0278878..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificEnergyUnit.g.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum SpecificEnergyUnit
-    {
-        BtuPerPound = 1,
-        CaloriePerGram = 2,
-        GigawattDayPerKilogram = 3,
-        GigawattDayPerShortTon = 4,
-        GigawattDayPerTonne = 5,
-        GigawattHourPerKilogram = 6,
-        GigawattHourPerPound = 7,
-        JoulePerKilogram = 8,
-        KilocaloriePerGram = 9,
-        KilojoulePerKilogram = 10,
-        KilowattDayPerKilogram = 11,
-        KilowattDayPerShortTon = 12,
-        KilowattDayPerTonne = 13,
-        KilowattHourPerKilogram = 14,
-        KilowattHourPerPound = 15,
-        MegajoulePerKilogram = 16,
-        MegajoulePerTonne = 37,
-        MegawattDayPerKilogram = 17,
-        MegawattDayPerShortTon = 18,
-        MegawattDayPerTonne = 19,
-        MegawattHourPerKilogram = 20,
-        MegawattHourPerPound = 21,
-        TerawattDayPerKilogram = 22,
-        TerawattDayPerShortTon = 23,
-        TerawattDayPerTonne = 24,
-        WattDayPerKilogram = 25,
-        WattDayPerShortTon = 26,
-        WattDayPerTonne = 27,
-        WattHourPerKilogram = 28,
-        WattHourPerPound = 29,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificEntropyUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificEntropyUnit.g.cs
deleted file mode 100644
index 77e55a2af2..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificEntropyUnit.g.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum SpecificEntropyUnit
-    {
-        BtuPerPoundFahrenheit = 1,
-        CaloriePerGramKelvin = 2,
-        JoulePerKilogramDegreeCelsius = 3,
-        JoulePerKilogramKelvin = 4,
-        KilocaloriePerGramKelvin = 5,
-        KilojoulePerKilogramDegreeCelsius = 6,
-        KilojoulePerKilogramKelvin = 7,
-        MegajoulePerKilogramDegreeCelsius = 8,
-        MegajoulePerKilogramKelvin = 9,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificFuelConsumptionUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificFuelConsumptionUnit.g.cs
deleted file mode 100644
index 6801a748fc..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificFuelConsumptionUnit.g.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum SpecificFuelConsumptionUnit
-    {
-        GramPerKilonewtonSecond = 1,
-        KilogramPerKilogramForceHour = 2,
-        KilogramPerKilonewtonSecond = 3,
-        PoundMassPerPoundForceHour = 4,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificVolumeUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificVolumeUnit.g.cs
deleted file mode 100644
index 49be37c632..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificVolumeUnit.g.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum SpecificVolumeUnit
-    {
-        CubicFootPerPound = 1,
-        CubicMeterPerKilogram = 2,
-        MillicubicMeterPerKilogram = 3,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificWeightUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificWeightUnit.g.cs
deleted file mode 100644
index a4ff736200..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/SpecificWeightUnit.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum SpecificWeightUnit
-    {
-        KilogramForcePerCubicCentimeter = 1,
-        KilogramForcePerCubicMeter = 2,
-        KilogramForcePerCubicMillimeter = 3,
-        KilonewtonPerCubicCentimeter = 4,
-        KilonewtonPerCubicMeter = 5,
-        KilonewtonPerCubicMillimeter = 6,
-        KilopoundForcePerCubicFoot = 7,
-        KilopoundForcePerCubicInch = 8,
-        MeganewtonPerCubicMeter = 9,
-        NewtonPerCubicCentimeter = 10,
-        NewtonPerCubicMeter = 11,
-        NewtonPerCubicMillimeter = 12,
-        PoundForcePerCubicFoot = 13,
-        PoundForcePerCubicInch = 14,
-        TonneForcePerCubicCentimeter = 15,
-        TonneForcePerCubicMeter = 16,
-        TonneForcePerCubicMillimeter = 17,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/SpeedUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/SpeedUnit.g.cs
deleted file mode 100644
index 7b8b70b339..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/SpeedUnit.g.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum SpeedUnit
-    {
-        CentimeterPerHour = 1,
-        CentimeterPerMinute = 2,
-        CentimeterPerSecond = 3,
-        DecimeterPerMinute = 4,
-        DecimeterPerSecond = 5,
-        FootPerHour = 6,
-        FootPerMinute = 7,
-        FootPerSecond = 8,
-        InchPerHour = 9,
-        InchPerMinute = 10,
-        InchPerSecond = 11,
-        KilometerPerHour = 12,
-        KilometerPerMinute = 13,
-        KilometerPerSecond = 14,
-
-        /// <summary>
-        ///     The knot, by definition, is a unit of speed equals to 1 nautical mile per hour, which is exactly 1852.000 metres per hour. The length of the internationally agreed nautical mile is 1852 m. The US adopted the international definition in 1954, the UK adopted the international nautical mile definition in 1970.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Knot_(unit)</remarks>
-        Knot = 15,
-        Mach = 42,
-        MeterPerHour = 16,
-        MeterPerMinute = 17,
-        MeterPerSecond = 18,
-        MicrometerPerMinute = 19,
-        MicrometerPerSecond = 20,
-        MilePerHour = 21,
-        MillimeterPerHour = 22,
-        MillimeterPerMinute = 23,
-        MillimeterPerSecond = 24,
-        NanometerPerMinute = 25,
-        NanometerPerSecond = 26,
-        UsSurveyFootPerHour = 27,
-        UsSurveyFootPerMinute = 28,
-        UsSurveyFootPerSecond = 29,
-        YardPerHour = 30,
-        YardPerMinute = 31,
-        YardPerSecond = 32,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/StandardVolumeFlowUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/StandardVolumeFlowUnit.g.cs
deleted file mode 100644
index 212589934b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/StandardVolumeFlowUnit.g.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum StandardVolumeFlowUnit
-    {
-        StandardCubicCentimeterPerMinute = 1,
-        StandardCubicFootPerHour = 2,
-        StandardCubicFootPerMinute = 3,
-        StandardCubicFootPerSecond = 4,
-        StandardCubicMeterPerDay = 5,
-        StandardCubicMeterPerHour = 6,
-        StandardCubicMeterPerMinute = 7,
-        StandardCubicMeterPerSecond = 8,
-        StandardLiterPerMinute = 9,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureChangeRateUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureChangeRateUnit.g.cs
deleted file mode 100644
index f2bd27b42b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureChangeRateUnit.g.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum TemperatureChangeRateUnit
-    {
-        CentidegreeCelsiusPerSecond = 1,
-        DecadegreeCelsiusPerSecond = 2,
-        DecidegreeCelsiusPerSecond = 3,
-        DegreeCelsiusPerHour = 18,
-        DegreeCelsiusPerMinute = 4,
-        DegreeCelsiusPerSecond = 5,
-        DegreeFahrenheitPerHour = 11,
-        DegreeFahrenheitPerMinute = 16,
-        DegreeFahrenheitPerSecond = 19,
-        DegreeKelvinPerHour = 12,
-        DegreeKelvinPerMinute = 20,
-        DegreeKelvinPerSecond = 15,
-        HectodegreeCelsiusPerSecond = 6,
-        KilodegreeCelsiusPerSecond = 7,
-        MicrodegreeCelsiusPerSecond = 8,
-        MillidegreeCelsiusPerSecond = 9,
-        NanodegreeCelsiusPerSecond = 10,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureDeltaUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureDeltaUnit.g.cs
deleted file mode 100644
index 7895e204a4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureDeltaUnit.g.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum TemperatureDeltaUnit
-    {
-        DegreeCelsius = 1,
-        DegreeDelisle = 2,
-        DegreeFahrenheit = 3,
-        DegreeNewton = 4,
-        DegreeRankine = 5,
-        DegreeReaumur = 6,
-        DegreeRoemer = 7,
-        Kelvin = 8,
-        MillidegreeCelsius = 9,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureGradientUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureGradientUnit.g.cs
deleted file mode 100644
index 73040b84a2..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureGradientUnit.g.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum TemperatureGradientUnit
-    {
-        DegreeCelsiusPerKilometer = 1,
-        DegreeCelsiusPerMeter = 2,
-        DegreeFahrenheitPerFoot = 3,
-        KelvinPerMeter = 4,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureUnit.g.cs
deleted file mode 100644
index 51a02d8902..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/TemperatureUnit.g.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum TemperatureUnit
-    {
-        DegreeCelsius = 1,
-        DegreeDelisle = 2,
-        DegreeFahrenheit = 3,
-        DegreeNewton = 4,
-        DegreeRankine = 5,
-        DegreeReaumur = 6,
-        DegreeRoemer = 7,
-        Kelvin = 8,
-        MillidegreeCelsius = 9,
-        SolarTemperature = 10,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ThermalConductivityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ThermalConductivityUnit.g.cs
deleted file mode 100644
index 044fda144e..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ThermalConductivityUnit.g.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ThermalConductivityUnit
-    {
-        BtuPerHourFootFahrenheit = 1,
-        WattPerMeterKelvin = 2,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ThermalInsulanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ThermalInsulanceUnit.g.cs
deleted file mode 100644
index 28b1e44bbe..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ThermalInsulanceUnit.g.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ThermalInsulanceUnit
-    {
-        HourSquareFeetDegreeFahrenheitPerBtu = 2,
-        SquareCentimeterHourDegreeCelsiusPerKilocalorie = 6,
-        SquareCentimeterKelvinPerWatt = 7,
-        SquareMeterDegreeCelsiusPerWatt = 3,
-        SquareMeterKelvinPerKilowatt = 5,
-        SquareMeterKelvinPerWatt = 4,
-        SquareMillimeterKelvinPerWatt = 13,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ThermalResistanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ThermalResistanceUnit.g.cs
deleted file mode 100644
index b4fa64b964..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/ThermalResistanceUnit.g.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum ThermalResistanceUnit
-    {
-        DegreeCelsiusPerWatt = 10,
-        KelvinPerWatt = 11,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/TorqueUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/TorqueUnit.g.cs
deleted file mode 100644
index 74ad9eb231..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/TorqueUnit.g.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum TorqueUnit
-    {
-        GramForceCentimeter = 1,
-        GramForceMeter = 2,
-        GramForceMillimeter = 3,
-        KilogramForceCentimeter = 4,
-        KilogramForceMeter = 5,
-        KilogramForceMillimeter = 6,
-        KilonewtonCentimeter = 7,
-        KilonewtonMeter = 8,
-        KilonewtonMillimeter = 9,
-        KilopoundForceFoot = 10,
-        KilopoundForceInch = 11,
-        MeganewtonCentimeter = 12,
-        MeganewtonMeter = 13,
-        MeganewtonMillimeter = 14,
-        MegapoundForceFoot = 15,
-        MegapoundForceInch = 16,
-        NewtonCentimeter = 17,
-        NewtonMeter = 18,
-        NewtonMillimeter = 19,
-        PoundalFoot = 20,
-        PoundForceFoot = 21,
-        PoundForceInch = 22,
-        TonneForceCentimeter = 23,
-        TonneForceMeter = 24,
-        TonneForceMillimeter = 25,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/TurbidityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/TurbidityUnit.g.cs
deleted file mode 100644
index a511c7c143..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/TurbidityUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum TurbidityUnit
-    {
-        NTU = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/VitaminAUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/VitaminAUnit.g.cs
deleted file mode 100644
index 2ffecd0c47..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/VitaminAUnit.g.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum VitaminAUnit
-    {
-        InternationalUnit = 1,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeConcentrationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeConcentrationUnit.g.cs
deleted file mode 100644
index 5624e121d1..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeConcentrationUnit.g.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum VolumeConcentrationUnit
-    {
-        CentiliterPerLiter = 1,
-        CentiliterPerMilliliter = 2,
-        DeciliterPerLiter = 3,
-        DeciliterPerMilliliter = 4,
-        DecimalFraction = 5,
-        LiterPerLiter = 6,
-        LiterPerMilliliter = 7,
-        MicroliterPerLiter = 8,
-        MicroliterPerMilliliter = 9,
-        MilliliterPerLiter = 10,
-        MilliliterPerMilliliter = 11,
-        NanoliterPerLiter = 12,
-        NanoliterPerMilliliter = 13,
-        PartPerBillion = 14,
-        PartPerMillion = 15,
-        PartPerThousand = 16,
-        PartPerTrillion = 17,
-        Percent = 18,
-        PicoliterPerLiter = 19,
-        PicoliterPerMilliliter = 20,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeFlowPerAreaUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeFlowPerAreaUnit.g.cs
deleted file mode 100644
index abcdea8f8f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeFlowPerAreaUnit.g.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum VolumeFlowPerAreaUnit
-    {
-        CubicFootPerMinutePerSquareFoot = 1,
-        CubicMeterPerSecondPerSquareMeter = 2,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeFlowUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeFlowUnit.g.cs
deleted file mode 100644
index 6c14bc7b98..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeFlowUnit.g.cs
+++ /dev/null
@@ -1,106 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum VolumeFlowUnit
-    {
-        AcreFootPerDay = 1,
-        AcreFootPerHour = 2,
-        AcreFootPerMinute = 3,
-        AcreFootPerSecond = 4,
-        CentiliterPerDay = 5,
-        CentiliterPerHour = 6,
-        CentiliterPerMinute = 7,
-        CentiliterPerSecond = 8,
-        CubicCentimeterPerMinute = 9,
-        CubicDecimeterPerMinute = 10,
-        CubicFootPerHour = 11,
-        CubicFootPerMinute = 12,
-        CubicFootPerSecond = 13,
-        CubicMeterPerDay = 14,
-        CubicMeterPerHour = 15,
-        CubicMeterPerMinute = 16,
-        CubicMeterPerSecond = 17,
-        CubicMillimeterPerSecond = 18,
-        CubicYardPerDay = 19,
-        CubicYardPerHour = 20,
-        CubicYardPerMinute = 21,
-        CubicYardPerSecond = 22,
-        DecaliterPerDay = 71,
-        DecaliterPerHour = 78,
-        DecaliterPerMinute = 67,
-        DecaliterPerSecond = 70,
-        DeciliterPerDay = 23,
-        DeciliterPerHour = 24,
-        DeciliterPerMinute = 25,
-        DeciliterPerSecond = 26,
-        HectoliterPerDay = 74,
-        HectoliterPerHour = 72,
-        HectoliterPerMinute = 75,
-        HectoliterPerSecond = 69,
-        KiloliterPerDay = 27,
-        KiloliterPerHour = 28,
-        KiloliterPerMinute = 29,
-        KiloliterPerSecond = 30,
-        KilousGallonPerMinute = 31,
-        LiterPerDay = 32,
-        LiterPerHour = 33,
-        LiterPerMinute = 34,
-        LiterPerSecond = 35,
-        MegaliterPerDay = 36,
-        MegaliterPerHour = 68,
-        MegaliterPerMinute = 64,
-        MegaliterPerSecond = 65,
-        MegaukGallonPerDay = 73,
-        MegaukGallonPerSecond = 37,
-        MegausGallonPerDay = 77,
-        MicroliterPerDay = 38,
-        MicroliterPerHour = 39,
-        MicroliterPerMinute = 40,
-        MicroliterPerSecond = 41,
-        MilliliterPerDay = 42,
-        MilliliterPerHour = 43,
-        MilliliterPerMinute = 44,
-        MilliliterPerSecond = 45,
-        MillionUsGallonPerDay = 66,
-        NanoliterPerDay = 47,
-        NanoliterPerHour = 48,
-        NanoliterPerMinute = 49,
-        NanoliterPerSecond = 50,
-        OilBarrelPerDay = 51,
-        OilBarrelPerHour = 52,
-        OilBarrelPerMinute = 53,
-        OilBarrelPerSecond = 54,
-        UkGallonPerDay = 55,
-        UkGallonPerHour = 56,
-        UkGallonPerMinute = 57,
-        UkGallonPerSecond = 58,
-        UsGallonPerDay = 59,
-        UsGallonPerHour = 60,
-        UsGallonPerMinute = 61,
-        UsGallonPerSecond = 62,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumePerLengthUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumePerLengthUnit.g.cs
deleted file mode 100644
index 526d9c8509..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumePerLengthUnit.g.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum VolumePerLengthUnit
-    {
-        CubicMeterPerMeter = 1,
-        CubicYardPerFoot = 2,
-        CubicYardPerUsSurveyFoot = 3,
-        ImperialGallonPerMile = 11,
-        LiterPerKilometer = 4,
-        LiterPerMeter = 5,
-        LiterPerMillimeter = 6,
-        OilBarrelPerFoot = 7,
-        UsGallonPerMile = 8,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeUnit.g.cs
deleted file mode 100644
index c57fe745cb..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeUnit.g.cs
+++ /dev/null
@@ -1,216 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum VolumeUnit
-    {
-
-        /// <summary>
-        ///     An acre-foot is 43,560 cubic feet (~1,233.5 m3).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Acre-foot</remarks>
-        AcreFoot = 1,
-
-        /// <summary>
-        ///     In Australia, the definition of the tablespoon is 20 ml (0.70 imp fl oz).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Tablespoon#Australia</remarks>
-        AuTablespoon = 2,
-
-        /// <summary>
-        ///     The board foot or board-foot is a unit of measurement for the volume of lumber in the United States and Canada. It equals the volume of a board that is one-foot (305 mm) in length, one-foot (305 mm) in width, and one-inch (25.4 mm) in thickness.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Board_foot</remarks>
-        BoardFoot = 3,
-        Centiliter = 4,
-        CubicCentimeter = 5,
-        CubicDecimeter = 6,
-
-        /// <summary>
-        ///     The cubic foot (symbol ft3 or cu ft) is an imperial and US customary (non-metric) unit of volume, used in the United States and the United Kingdom. It is defined as the volume of a cube with sides of one foot (0.3048 m) in length.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Cubic_foot</remarks>
-        CubicFoot = 7,
-        CubicHectometer = 8,
-
-        /// <summary>
-        ///     The cubic inch (symbol in3) is a unit of volume in the Imperial units and United States customary units systems. It is the volume of a cube with each of its three dimensions (length, width, and height) being one inch long which is equivalent to 1/231 of a US gallon.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Cubic_yard</remarks>
-        CubicInch = 9,
-        CubicKilometer = 10,
-        CubicMeter = 11,
-        CubicMicrometer = 12,
-
-        /// <summary>
-        ///     A cubic mile (abbreviation: cu mi or mi3) is an imperial and US customary (non-SI non-metric) unit of volume, used in the United States, Canada and the United Kingdom. It is defined as the volume of a cube with sides of 1 mile (63360 inches, 5280 feet, 1760 yards or ~1.609 kilometres) in length.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Cubic_mile</remarks>
-        CubicMile = 13,
-        CubicMillimeter = 14,
-
-        /// <summary>
-        ///     A cubic yard is an Imperial / U.S. customary (non-SI non-metric) unit of volume, used in Canada and the United States. It is defined as the volume of a cube with sides of 1 yard (3 feet, 36 inches, 0.9144 meters) in length.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Cubic_yard</remarks>
-        CubicYard = 15,
-        Decaliter = 16,
-        DecausGallon = 17,
-        Deciliter = 18,
-        DeciusGallon = 19,
-        HectocubicFoot = 20,
-        HectocubicMeter = 21,
-        Hectoliter = 22,
-        HectousGallon = 23,
-
-        /// <summary>
-        ///     Fluid barrels vary depending on what is being measured and where. In the UK a beer barrel is 36 imperial gallons (43 US gal; ~164 L).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Barrel_(unit)#Fluid_barrel_in_the_US_and_UK</remarks>
-        ImperialBeerBarrel = 24,
-
-        /// <summary>
-        ///     The British imperial gallon (frequently called simply "gallon") is defined as exactly 4.54609 litres.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Gallon#Imperial_gallon</remarks>
-        ImperialGallon = 25,
-
-        /// <summary>
-        ///     An imperial fluid ounce is 1⁄20 of an imperial pint, 1⁄160 of an imperial gallon or exactly 28.4130625 mL.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Fluid_ounce</remarks>
-        ImperialOunce = 26,
-
-        /// <summary>
-        ///     The pint is a unit of volume or capacity in both the imperial and United States customary measurement systems. In both of those systems it is traditionally one eighth of a gallon. The British imperial pint is about 20% larger than the American pint because the two systems are defined differently.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Pint#Imperial_pint</remarks>
-        ImperialPint = 27,
-
-        /// <summary>
-        ///     The imperial quart, which is used for both liquid and dry capacity, is equal to one quarter of an imperial gallon, or exactly 1.1365225 liters.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Quart#Imperial_quart</remarks>
-        ImperialQuart = 57,
-        KilocubicFoot = 28,
-        KilocubicMeter = 29,
-        KiloimperialGallon = 30,
-        Kiloliter = 31,
-        KilousGallon = 32,
-        Liter = 33,
-        MegacubicFoot = 34,
-        MegaimperialGallon = 35,
-        Megaliter = 36,
-        MegausGallon = 37,
-
-        /// <summary>
-        ///     Australia, Canada, New Zealand, and some other members of the Commonwealth of Nations, being former British colonies that have since metricated, employ a metric cup of 250 millilitres. Although derived from the metric system, it is not an SI unit.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Cup_(unit)#Metric_cup</remarks>
-        MetricCup = 38,
-
-        /// <summary>
-        ///     An international metric tablespoon is exactly equal to 15 mL. It is the equivalence of 1⁠ 1/2 metric dessert spoons or 3 metric teaspoons.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Tablespoon#International_metric</remarks>
-        MetricTablespoon = 63,
-
-        /// <summary>
-        ///     The metric teaspoon as a unit of culinary measure is 5 ml (0.18 imp fl oz; 0.17 US fl oz),[17] equal to 5 cm3, 1⁄3 UK/Canadian metric tablespoon, or 1⁄4 Australian metric tablespoon.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Teaspoon#Metric_teaspoon</remarks>
-        MetricTeaspoon = 39,
-        Microliter = 40,
-        Milliliter = 41,
-        Nanoliter = 53,
-
-        /// <summary>
-        ///     In the oil industry, one barrel (unit symbol bbl) is a unit of volume used for measuring oil defined as exactly 42 US gallons, approximately 159 liters, or 35 imperial gallons.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Barrel_(unit)#Oil_barrel</remarks>
-        OilBarrel = 42,
-
-        /// <summary>
-        ///     In nutrition labeling in the U.S. and the U.K., a tablespoon is defined as 15 ml (0.51 US fl oz). In Australia, the definition of the tablespoon is 20 ml (0.70 imp fl oz).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Tablespoon#International</remarks>
-        UkTablespoon = 43,
-
-        /// <summary>
-        ///     Fluid barrels vary depending on what is being measured and where. In the US most fluid barrels (apart from oil) are 31.5 US gallons (26 imp gal; 119 L) (half a hogshead), but a beer barrel is 31 US gallons (26 imp gal; 117 L).
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Barrel_(unit)#Fluid_barrel_in_the_US_and_UK</remarks>
-        UsBeerBarrel = 44,
-
-        /// <summary>
-        ///     In the United States, the customary cup is half of a liquid pint or 1⁄16 US customary gallon which is 236.5882365 milliliters exactly.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Cup_(unit)#Customary_cup</remarks>
-        UsCustomaryCup = 45,
-
-        /// <summary>
-        ///     The US liquid gallon (frequently called simply "gallon") is legally defined as 231 cubic inches, which is exactly 3.785411784 litres.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Gallon#US_liquid_gallon</remarks>
-        UsGallon = 46,
-
-        /// <summary>
-        ///     The cup currently used in the United States for nutrition labelling is defined in United States law as 240 ml.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Cup_(unit)#Legal_cup</remarks>
-        UsLegalCup = 47,
-
-        /// <summary>
-        ///     A US customary fluid ounce is 1⁄16 of a US liquid pint and 1⁄128 of a US liquid gallon or exactly 29.5735295625 mL, making it about 4.08% larger than the imperial fluid ounce.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Fluid_ounce</remarks>
-        UsOunce = 48,
-
-        /// <summary>
-        ///     The pint is a unit of volume or capacity in both the imperial and United States customary measurement systems. In both of those systems it is traditionally one eighth of a gallon. The British imperial pint is about 20% larger than the American pint because the two systems are defined differently.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Pint#US_liquid_pint</remarks>
-        UsPint = 49,
-
-        /// <summary>
-        ///     The US liquid quart equals 57.75 cubic inches, which is exactly equal to 0.946352946 L.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Quart#US_liquid_quart</remarks>
-        UsQuart = 50,
-
-        /// <summary>
-        ///     The traditional U.S. interpretation of the tablespoon as a unit of volume is: 1 US tablespoon = 4 fluid drams, or 3 teaspoons or 1/2 US fluid ounce (≈ 14.8 ml)
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Tablespoon#United_States</remarks>
-        UsTablespoon = 51,
-
-        /// <summary>
-        ///     As a unit of culinary measure, one teaspoon in the United States is 1⁄3 tablespoon, exactly 4.92892159375 ml, 1 1⁄3 US fluid drams, 1⁄6 US fl oz, 1⁄48 US cup, 1⁄768 US liquid gallon, or 77⁄256 (0.30078125) cubic inches.
-        /// </summary>
-        /// <remarks>https://en.wikipedia.org/wiki/Teaspoon#United_States_customary_unit</remarks>
-        UsTeaspoon = 52,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumetricHeatCapacityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumetricHeatCapacityUnit.g.cs
deleted file mode 100644
index 59ae226aa2..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumetricHeatCapacityUnit.g.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum VolumetricHeatCapacityUnit
-    {
-        /// <remarks>Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details.</remarks>
-        BtuPerCubicFootDegreeFahrenheit = 1,
-        CaloriePerCubicCentimeterDegreeCelsius = 2,
-        JoulePerCubicMeterDegreeCelsius = 3,
-        JoulePerCubicMeterKelvin = 4,
-        KilocaloriePerCubicCentimeterDegreeCelsius = 5,
-        KilojoulePerCubicMeterDegreeCelsius = 6,
-        KilojoulePerCubicMeterKelvin = 7,
-        MegajoulePerCubicMeterDegreeCelsius = 8,
-        MegajoulePerCubicMeterKelvin = 9,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/WarpingMomentOfInertiaUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/WarpingMomentOfInertiaUnit.g.cs
deleted file mode 100644
index 5f77a6d521..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/WarpingMomentOfInertiaUnit.g.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by \generate-code.bat.
-//
-//     Changes to this file will be lost when the code is regenerated.
-//     The build server regenerates the code before each build and a pre-build
-//     step will regenerate the code on each local build.
-//
-//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
-//
-//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
-//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
-//
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-// ReSharper disable once CheckNamespace
-namespace UnitsNet.Units
-{
-    // Disable missing XML comment warnings for the generated unit enums.
-    #pragma warning disable 1591
-
-    public enum WarpingMomentOfInertiaUnit
-    {
-        CentimeterToTheSixth = 1,
-        DecimeterToTheSixth = 2,
-        FootToTheSixth = 3,
-        InchToTheSixth = 4,
-        MeterToTheSixth = 5,
-        MillimeterToTheSixth = 6,
-    }
-
-    #pragma warning restore 1591
-}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln b/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln
deleted file mode 100644
index f2d98d63c4..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln
+++ /dev/null
@@ -1,1044 +0,0 @@
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.30413.136
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "AbsorbedDoseOfIonizingRadiation", "AbsorbedDoseOfIonizingRadiation\AbsorbedDoseOfIonizingRadiation.nfproj", "{3d39134e-c97d-cba4-a559-fdb3a0da5e54}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Acceleration", "Acceleration\Acceleration.nfproj", "{8e3a6691-a05f-d71c-f12a-f537c0807f85}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "AmountOfSubstance", "AmountOfSubstance\AmountOfSubstance.nfproj", "{1cd282f3-3bdc-bc00-a63a-03a11a9b5c4d}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "AmplitudeRatio", "AmplitudeRatio\AmplitudeRatio.nfproj", "{59c09a1b-eff0-e367-6372-d16c4c984916}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Angle", "Angle\Angle.nfproj", "{4b036819-f813-0c4d-3e44-1fcc8b5f3ec7}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Area", "Area\Area.nfproj", "{04c24d02-bad7-a877-ff9b-a36a886c9633}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "AreaDensity", "AreaDensity\AreaDensity.nfproj", "{92ff1332-bf34-943e-a58d-8a76746d879e}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "AreaMomentOfInertia", "AreaMomentOfInertia\AreaMomentOfInertia.nfproj", "{566ef13c-0d17-e465-d35f-1bd9c65559bf}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "BitRate", "BitRate\BitRate.nfproj", "{b5fdf997-829f-5281-e624-ee4eee5aa26c}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "BrakeSpecificFuelConsumption", "BrakeSpecificFuelConsumption\BrakeSpecificFuelConsumption.nfproj", "{085145f2-2b8f-4d09-5290-c14cdcd452bf}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "CoefficientOfThermalExpansion", "CoefficientOfThermalExpansion\CoefficientOfThermalExpansion.nfproj", "{a9514ce6-d4e7-88ca-051e-e9e53610c519}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Compressibility", "Compressibility\Compressibility.nfproj", "{daf647be-be87-88b9-ee92-dece21fe0dff}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Density", "Density\Density.nfproj", "{d683a277-5892-aec2-985d-c2343725d0af}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "DoseAreaProduct", "DoseAreaProduct\DoseAreaProduct.nfproj", "{e074adae-f19a-6b69-67b0-b4fb425b39ce}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Duration", "Duration\Duration.nfproj", "{3c2ac54f-554c-518b-7c46-3b22d86d0e3b}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "DynamicViscosity", "DynamicViscosity\DynamicViscosity.nfproj", "{5dde57f4-3f98-c4b7-47e5-65229faf1f0f}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricAdmittance", "ElectricAdmittance\ElectricAdmittance.nfproj", "{2ee55c63-d077-25dd-f076-857adfe08080}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricApparentEnergy", "ElectricApparentEnergy\ElectricApparentEnergy.nfproj", "{f22b7bcc-5a8d-3a02-d81c-caf6c9c44d61}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricApparentPower", "ElectricApparentPower\ElectricApparentPower.nfproj", "{b7a9eb2a-4b0e-548c-2370-a33ee63b21cc}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricCapacitance", "ElectricCapacitance\ElectricCapacitance.nfproj", "{10e8cf6b-7fec-911f-770d-e3641296ac89}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricCharge", "ElectricCharge\ElectricCharge.nfproj", "{f4286cfc-484b-8466-8efa-1111696babb9}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricChargeDensity", "ElectricChargeDensity\ElectricChargeDensity.nfproj", "{b1567c85-ad77-c283-9165-777ad0e9a2eb}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricConductance", "ElectricConductance\ElectricConductance.nfproj", "{fcd3dfb2-9ee2-ad22-0e1f-4cddd575792a}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricConductivity", "ElectricConductivity\ElectricConductivity.nfproj", "{f420eccc-b12d-72e4-2ad2-f93054eeec30}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricCurrent", "ElectricCurrent\ElectricCurrent.nfproj", "{55160a70-69b2-4144-b974-b64d78bd50e0}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricCurrentDensity", "ElectricCurrentDensity\ElectricCurrentDensity.nfproj", "{8beda85e-3d20-5926-c060-f92913f1192e}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricCurrentGradient", "ElectricCurrentGradient\ElectricCurrentGradient.nfproj", "{29df066c-c160-cd60-b10f-23a0c3bb8457}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricField", "ElectricField\ElectricField.nfproj", "{635581a6-f954-d0e4-9c68-02c1725e49d2}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricImpedance", "ElectricImpedance\ElectricImpedance.nfproj", "{23a79010-5c1a-9120-0992-a69c8dd80015}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricInductance", "ElectricInductance\ElectricInductance.nfproj", "{76bf8a97-e573-a5b5-286f-04ca7e00f8e9}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricPotential", "ElectricPotential\ElectricPotential.nfproj", "{66c94dc2-e546-9737-a45b-4bc60fe0e536}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricPotentialChangeRate", "ElectricPotentialChangeRate\ElectricPotentialChangeRate.nfproj", "{679517ca-9d0b-0ec2-35ae-95230281cfba}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricReactance", "ElectricReactance\ElectricReactance.nfproj", "{e3d3c1e3-aaa3-5d40-472e-ae837457cf73}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricReactiveEnergy", "ElectricReactiveEnergy\ElectricReactiveEnergy.nfproj", "{9f892c4e-26c2-1420-a73c-08138c8f6ca2}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricReactivePower", "ElectricReactivePower\ElectricReactivePower.nfproj", "{6e5b2ba2-7712-0f4f-d2bf-2624bb877dbe}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricResistance", "ElectricResistance\ElectricResistance.nfproj", "{78d59e90-3339-54d6-3803-f68623b72eff}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricResistivity", "ElectricResistivity\ElectricResistivity.nfproj", "{6a4a0f45-c2b4-6be4-e44a-e78d3282359f}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricSurfaceChargeDensity", "ElectricSurfaceChargeDensity\ElectricSurfaceChargeDensity.nfproj", "{006e161d-aae1-2dd1-5b94-ebd45d31f50a}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ElectricSusceptance", "ElectricSusceptance\ElectricSusceptance.nfproj", "{544c006b-f7de-21a9-a1b4-8df710e184c8}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Energy", "Energy\Energy.nfproj", "{f7d3fcf2-cadc-19dd-4c4c-5a54a5102c95}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "EnergyDensity", "EnergyDensity\EnergyDensity.nfproj", "{c5025916-5039-97c2-b450-af1420f5fb08}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Entropy", "Entropy\Entropy.nfproj", "{816884bb-a5f6-5c07-967b-bb8f21d724b7}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "FluidResistance", "FluidResistance\FluidResistance.nfproj", "{d19281dc-72f6-62a9-18d5-b845d6fd8d99}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Force", "Force\Force.nfproj", "{5517dacf-b1ff-6515-e5b6-b5081f92f407}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ForceChangeRate", "ForceChangeRate\ForceChangeRate.nfproj", "{97ad732d-4ce5-2027-aabc-844002d29c23}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ForcePerLength", "ForcePerLength\ForcePerLength.nfproj", "{6b975d30-c5dd-f1fd-9d0c-4d56ecdf9b25}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Frequency", "Frequency\Frequency.nfproj", "{8d66b616-3198-b8a1-d2d0-03496db6a62b}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "FuelEfficiency", "FuelEfficiency\FuelEfficiency.nfproj", "{6e68ff9b-3947-d706-3ad7-f9237a67c874}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "HeatFlux", "HeatFlux\HeatFlux.nfproj", "{2b132458-96e5-72bf-673f-dda4a7fd514b}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "HeatTransferCoefficient", "HeatTransferCoefficient\HeatTransferCoefficient.nfproj", "{3ede821e-ee76-967e-94d7-5b1d1239c8dd}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Illuminance", "Illuminance\Illuminance.nfproj", "{d846582b-8ae3-9779-01ea-7210b5330cfd}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Impulse", "Impulse\Impulse.nfproj", "{d8d4e4e8-1dc8-0170-5e3c-18610853bd87}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Information", "Information\Information.nfproj", "{12bab01c-845f-82c9-b00b-a3639cdfb2ce}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Irradiance", "Irradiance\Irradiance.nfproj", "{5f9c09c7-9e32-8927-7a5d-90001ceffc69}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Irradiation", "Irradiation\Irradiation.nfproj", "{b545726f-7a83-3c78-2b55-6a709c5a6d00}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Jerk", "Jerk\Jerk.nfproj", "{8540cfb1-fe4a-dcc3-a70e-840262803cfc}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "KinematicViscosity", "KinematicViscosity\KinematicViscosity.nfproj", "{733e533d-9ff2-4c72-3da9-200f758dc6e3}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "LeakRate", "LeakRate\LeakRate.nfproj", "{ff162d83-3229-2000-71ed-08999160dca3}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Length", "Length\Length.nfproj", "{0556c9ad-b3a1-730c-959f-baf21e60f972}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Level", "Level\Level.nfproj", "{5c300917-a99f-d166-4f56-f0da3c3614bb}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "LinearDensity", "LinearDensity\LinearDensity.nfproj", "{ab414094-9582-3357-d0e9-20b153a1b54c}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "LinearPowerDensity", "LinearPowerDensity\LinearPowerDensity.nfproj", "{8823a9ee-673a-e7d4-3c0a-bae61a262388}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Luminance", "Luminance\Luminance.nfproj", "{cbded274-6b9b-a113-d56f-00b38006cc84}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Luminosity", "Luminosity\Luminosity.nfproj", "{fe30ed04-094f-5005-b0aa-1b3623db60b2}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "LuminousFlux", "LuminousFlux\LuminousFlux.nfproj", "{a38e4da2-f05f-aa6f-82f1-56cd2e062d96}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "LuminousIntensity", "LuminousIntensity\LuminousIntensity.nfproj", "{733f9598-101b-936b-b081-2805dd793091}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MagneticField", "MagneticField\MagneticField.nfproj", "{809c4afa-d014-471b-518b-4fd01cb7c808}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MagneticFlux", "MagneticFlux\MagneticFlux.nfproj", "{f0c5342b-fb95-48a4-029f-7aa631ce06f1}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Magnetization", "Magnetization\Magnetization.nfproj", "{3ea3301e-d3de-6979-f1d7-58352998951c}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Mass", "Mass\Mass.nfproj", "{f8c5a010-c353-31da-cadc-b56186be374f}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MassConcentration", "MassConcentration\MassConcentration.nfproj", "{0b1482c2-a3b1-6207-b73f-a07f46718b65}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MassFlow", "MassFlow\MassFlow.nfproj", "{a0821347-be46-c587-b61d-5152c578048d}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MassFlux", "MassFlux\MassFlux.nfproj", "{15622f39-b4c5-7e66-57bc-31900b6065c8}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MassFraction", "MassFraction\MassFraction.nfproj", "{db140d08-4769-dc51-8809-a9222b830ef4}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MassMomentOfInertia", "MassMomentOfInertia\MassMomentOfInertia.nfproj", "{6218c061-3905-79b2-d3bc-bb7b8fc77a69}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Molality", "Molality\Molality.nfproj", "{589b202c-e638-5c93-fefe-e1e3bab4a493}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MolarEnergy", "MolarEnergy\MolarEnergy.nfproj", "{9b77d4e0-863d-4a74-c30a-56f7b2bb7cb7}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MolarEntropy", "MolarEntropy\MolarEntropy.nfproj", "{2053731b-90f5-5141-d15e-8d7be8c2662f}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MolarFlow", "MolarFlow\MolarFlow.nfproj", "{49cc942b-d836-a48b-0429-25bf95247759}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Molarity", "Molarity\Molarity.nfproj", "{0d21f127-8c25-9b3a-9612-ce2eea6e7ac1}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "MolarMass", "MolarMass\MolarMass.nfproj", "{fe51bbda-2039-23fd-f29a-39c14adcb1f6}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Permeability", "Permeability\Permeability.nfproj", "{34a31e0b-15ec-829c-6f0b-74f5acfd97e2}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Permittivity", "Permittivity\Permittivity.nfproj", "{9b381685-8129-acba-66f0-7068fe43a6c3}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "PorousMediumPermeability", "PorousMediumPermeability\PorousMediumPermeability.nfproj", "{493d1e8e-51c6-da82-9289-25bd26fab4a4}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Power", "Power\Power.nfproj", "{56968e84-6b7d-d548-4c0b-53017bd6123c}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "PowerDensity", "PowerDensity\PowerDensity.nfproj", "{5e741dd9-690a-de16-e7a1-85e6239aa70d}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "PowerRatio", "PowerRatio\PowerRatio.nfproj", "{94317d9a-d614-b098-6175-76ee84262c05}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Pressure", "Pressure\Pressure.nfproj", "{f907841f-b1ee-9b12-580e-cfe2324bed03}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "PressureChangeRate", "PressureChangeRate\PressureChangeRate.nfproj", "{c9e4cfa9-c5d3-5e9d-243c-106ba4b6a447}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "RadiationEquivalentDose", "RadiationEquivalentDose\RadiationEquivalentDose.nfproj", "{dcdccf04-c930-b455-77a4-d9d4a7df8723}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "RadiationEquivalentDoseRate", "RadiationEquivalentDoseRate\RadiationEquivalentDoseRate.nfproj", "{8eec9904-f4bb-c601-86ac-80fb153599f9}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "RadiationExposure", "RadiationExposure\RadiationExposure.nfproj", "{69b383c7-828a-1857-cbe2-f11b9ba77320}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Radioactivity", "Radioactivity\Radioactivity.nfproj", "{abf4b42f-e999-2a78-403f-fb09524f186a}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Ratio", "Ratio\Ratio.nfproj", "{b0be4813-d93e-7b06-d422-23ca28adf22a}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "RatioChangeRate", "RatioChangeRate\RatioChangeRate.nfproj", "{c028861d-f9e8-8231-2b6a-bc3b3fba349c}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ReciprocalArea", "ReciprocalArea\ReciprocalArea.nfproj", "{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ReciprocalLength", "ReciprocalLength\ReciprocalLength.nfproj", "{83d6c79a-c71a-d467-284c-28edbbd059d2}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "RelativeHumidity", "RelativeHumidity\RelativeHumidity.nfproj", "{4ac05c74-08c5-2153-f38c-976975747b5c}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "RotationalAcceleration", "RotationalAcceleration\RotationalAcceleration.nfproj", "{e2110137-6a36-f4d1-2219-26eb18fee74d}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "RotationalSpeed", "RotationalSpeed\RotationalSpeed.nfproj", "{934ef064-2dce-6d50-64e9-d4d2c4d41a81}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "RotationalStiffness", "RotationalStiffness\RotationalStiffness.nfproj", "{3788f245-ea6d-eb5d-80de-f25ab30a51cc}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "RotationalStiffnessPerLength", "RotationalStiffnessPerLength\RotationalStiffnessPerLength.nfproj", "{eae89113-1312-f83c-1a4b-638b98e760b3}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Scalar", "Scalar\Scalar.nfproj", "{609c8143-bdb3-709b-a7a5-cc33659c9b51}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "SolidAngle", "SolidAngle\SolidAngle.nfproj", "{39d13fa7-a1df-cea6-adee-bab64a00a843}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "SpecificEnergy", "SpecificEnergy\SpecificEnergy.nfproj", "{5bce25ab-a4d6-d89c-5274-7eadd8c5967a}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "SpecificEntropy", "SpecificEntropy\SpecificEntropy.nfproj", "{0d5dc515-9d35-ac02-c0b1-12c70c3163a2}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "SpecificFuelConsumption", "SpecificFuelConsumption\SpecificFuelConsumption.nfproj", "{f1a91b9a-ec32-5f98-d4d6-75ac04c63276}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "SpecificVolume", "SpecificVolume\SpecificVolume.nfproj", "{74b88d5c-96e5-7286-d2b2-8def18538246}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "SpecificWeight", "SpecificWeight\SpecificWeight.nfproj", "{d63ac796-7087-bf6c-2848-e6511358fbe4}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Speed", "Speed\Speed.nfproj", "{e9fe72c3-56b4-856b-a592-ae6e98e571f3}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "StandardVolumeFlow", "StandardVolumeFlow\StandardVolumeFlow.nfproj", "{5da7dbe9-f180-570f-2da0-2737f043744d}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Temperature", "Temperature\Temperature.nfproj", "{8bce58b9-1a87-6bb3-3cee-e0e0f012b618}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "TemperatureChangeRate", "TemperatureChangeRate\TemperatureChangeRate.nfproj", "{dfbb7b9f-c604-fedd-e658-17e196043123}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "TemperatureDelta", "TemperatureDelta\TemperatureDelta.nfproj", "{8854c5e8-e40b-74c3-aafc-de0f13239276}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "TemperatureGradient", "TemperatureGradient\TemperatureGradient.nfproj", "{83d1d75e-3c26-b8d0-f097-f99452e749cc}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ThermalConductivity", "ThermalConductivity\ThermalConductivity.nfproj", "{7e7d8010-b37a-151a-11a5-1db234ee1104}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ThermalInsulance", "ThermalInsulance\ThermalInsulance.nfproj", "{0194c08d-ffcd-78bd-9e14-66634fe6d4ea}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ThermalResistance", "ThermalResistance\ThermalResistance.nfproj", "{c69bdd4d-3ebd-4b8e-cffb-650903da3872}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Torque", "Torque\Torque.nfproj", "{3b6bbc8a-1b22-deff-2980-53b77b6f3e5f}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Turbidity", "Turbidity\Turbidity.nfproj", "{05ac8aed-49a4-5c9f-d8c2-8d2debf64791}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "VitaminA", "VitaminA\VitaminA.nfproj", "{c00185af-8735-7674-5fa6-232424b04161}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Volume", "Volume\Volume.nfproj", "{66b90fb1-20d7-f563-3477-4c7c6b404f4d}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "VolumeConcentration", "VolumeConcentration\VolumeConcentration.nfproj", "{4aa72022-0946-6a28-a4e9-6c9add5caef6}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "VolumeFlow", "VolumeFlow\VolumeFlow.nfproj", "{b22e47e1-9506-56e6-3d19-780b887d8cb3}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "VolumeFlowPerArea", "VolumeFlowPerArea\VolumeFlowPerArea.nfproj", "{753bcc52-c451-8b29-6ae7-520b02ee6960}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "VolumePerLength", "VolumePerLength\VolumePerLength.nfproj", "{b66e3a3e-7945-3d40-24ef-73fa6e1b8d41}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "VolumetricHeatCapacity", "VolumetricHeatCapacity\VolumetricHeatCapacity.nfproj", "{cd2b60c1-a4b5-36f2-afa3-6cf1031f9e7f}"
-EndProject
-Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "WarpingMomentOfInertia", "WarpingMomentOfInertia\WarpingMomentOfInertia.nfproj", "{8433aac6-218d-9b7b-6eaa-36774e165446}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-{3d39134e-c97d-cba4-a559-fdb3a0da5e54}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{3d39134e-c97d-cba4-a559-fdb3a0da5e54}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{3d39134e-c97d-cba4-a559-fdb3a0da5e54}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{3d39134e-c97d-cba4-a559-fdb3a0da5e54}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{3d39134e-c97d-cba4-a559-fdb3a0da5e54}.Release|Any CPU.Build.0 = Release|Any CPU
-{3d39134e-c97d-cba4-a559-fdb3a0da5e54}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{8e3a6691-a05f-d71c-f12a-f537c0807f85}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{8e3a6691-a05f-d71c-f12a-f537c0807f85}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{8e3a6691-a05f-d71c-f12a-f537c0807f85}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{8e3a6691-a05f-d71c-f12a-f537c0807f85}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{8e3a6691-a05f-d71c-f12a-f537c0807f85}.Release|Any CPU.Build.0 = Release|Any CPU
-{8e3a6691-a05f-d71c-f12a-f537c0807f85}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{1cd282f3-3bdc-bc00-a63a-03a11a9b5c4d}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{1cd282f3-3bdc-bc00-a63a-03a11a9b5c4d}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{1cd282f3-3bdc-bc00-a63a-03a11a9b5c4d}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{1cd282f3-3bdc-bc00-a63a-03a11a9b5c4d}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{1cd282f3-3bdc-bc00-a63a-03a11a9b5c4d}.Release|Any CPU.Build.0 = Release|Any CPU
-{1cd282f3-3bdc-bc00-a63a-03a11a9b5c4d}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{59c09a1b-eff0-e367-6372-d16c4c984916}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{59c09a1b-eff0-e367-6372-d16c4c984916}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{59c09a1b-eff0-e367-6372-d16c4c984916}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{59c09a1b-eff0-e367-6372-d16c4c984916}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{59c09a1b-eff0-e367-6372-d16c4c984916}.Release|Any CPU.Build.0 = Release|Any CPU
-{59c09a1b-eff0-e367-6372-d16c4c984916}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{4b036819-f813-0c4d-3e44-1fcc8b5f3ec7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{4b036819-f813-0c4d-3e44-1fcc8b5f3ec7}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{4b036819-f813-0c4d-3e44-1fcc8b5f3ec7}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{4b036819-f813-0c4d-3e44-1fcc8b5f3ec7}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{4b036819-f813-0c4d-3e44-1fcc8b5f3ec7}.Release|Any CPU.Build.0 = Release|Any CPU
-{4b036819-f813-0c4d-3e44-1fcc8b5f3ec7}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{04c24d02-bad7-a877-ff9b-a36a886c9633}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{04c24d02-bad7-a877-ff9b-a36a886c9633}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{04c24d02-bad7-a877-ff9b-a36a886c9633}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{04c24d02-bad7-a877-ff9b-a36a886c9633}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{04c24d02-bad7-a877-ff9b-a36a886c9633}.Release|Any CPU.Build.0 = Release|Any CPU
-{04c24d02-bad7-a877-ff9b-a36a886c9633}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{92ff1332-bf34-943e-a58d-8a76746d879e}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{92ff1332-bf34-943e-a58d-8a76746d879e}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{92ff1332-bf34-943e-a58d-8a76746d879e}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{92ff1332-bf34-943e-a58d-8a76746d879e}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{92ff1332-bf34-943e-a58d-8a76746d879e}.Release|Any CPU.Build.0 = Release|Any CPU
-{92ff1332-bf34-943e-a58d-8a76746d879e}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{566ef13c-0d17-e465-d35f-1bd9c65559bf}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{566ef13c-0d17-e465-d35f-1bd9c65559bf}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{566ef13c-0d17-e465-d35f-1bd9c65559bf}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{566ef13c-0d17-e465-d35f-1bd9c65559bf}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{566ef13c-0d17-e465-d35f-1bd9c65559bf}.Release|Any CPU.Build.0 = Release|Any CPU
-{566ef13c-0d17-e465-d35f-1bd9c65559bf}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{b5fdf997-829f-5281-e624-ee4eee5aa26c}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{b5fdf997-829f-5281-e624-ee4eee5aa26c}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{b5fdf997-829f-5281-e624-ee4eee5aa26c}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{b5fdf997-829f-5281-e624-ee4eee5aa26c}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{b5fdf997-829f-5281-e624-ee4eee5aa26c}.Release|Any CPU.Build.0 = Release|Any CPU
-{b5fdf997-829f-5281-e624-ee4eee5aa26c}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{085145f2-2b8f-4d09-5290-c14cdcd452bf}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{085145f2-2b8f-4d09-5290-c14cdcd452bf}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{085145f2-2b8f-4d09-5290-c14cdcd452bf}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{085145f2-2b8f-4d09-5290-c14cdcd452bf}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{085145f2-2b8f-4d09-5290-c14cdcd452bf}.Release|Any CPU.Build.0 = Release|Any CPU
-{085145f2-2b8f-4d09-5290-c14cdcd452bf}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{a9514ce6-d4e7-88ca-051e-e9e53610c519}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{a9514ce6-d4e7-88ca-051e-e9e53610c519}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{a9514ce6-d4e7-88ca-051e-e9e53610c519}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{a9514ce6-d4e7-88ca-051e-e9e53610c519}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{a9514ce6-d4e7-88ca-051e-e9e53610c519}.Release|Any CPU.Build.0 = Release|Any CPU
-{a9514ce6-d4e7-88ca-051e-e9e53610c519}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{daf647be-be87-88b9-ee92-dece21fe0dff}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{daf647be-be87-88b9-ee92-dece21fe0dff}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{daf647be-be87-88b9-ee92-dece21fe0dff}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{daf647be-be87-88b9-ee92-dece21fe0dff}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{daf647be-be87-88b9-ee92-dece21fe0dff}.Release|Any CPU.Build.0 = Release|Any CPU
-{daf647be-be87-88b9-ee92-dece21fe0dff}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{d683a277-5892-aec2-985d-c2343725d0af}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{d683a277-5892-aec2-985d-c2343725d0af}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{d683a277-5892-aec2-985d-c2343725d0af}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{d683a277-5892-aec2-985d-c2343725d0af}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{d683a277-5892-aec2-985d-c2343725d0af}.Release|Any CPU.Build.0 = Release|Any CPU
-{d683a277-5892-aec2-985d-c2343725d0af}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{e074adae-f19a-6b69-67b0-b4fb425b39ce}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{e074adae-f19a-6b69-67b0-b4fb425b39ce}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{e074adae-f19a-6b69-67b0-b4fb425b39ce}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{e074adae-f19a-6b69-67b0-b4fb425b39ce}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{e074adae-f19a-6b69-67b0-b4fb425b39ce}.Release|Any CPU.Build.0 = Release|Any CPU
-{e074adae-f19a-6b69-67b0-b4fb425b39ce}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{3c2ac54f-554c-518b-7c46-3b22d86d0e3b}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{3c2ac54f-554c-518b-7c46-3b22d86d0e3b}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{3c2ac54f-554c-518b-7c46-3b22d86d0e3b}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{3c2ac54f-554c-518b-7c46-3b22d86d0e3b}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{3c2ac54f-554c-518b-7c46-3b22d86d0e3b}.Release|Any CPU.Build.0 = Release|Any CPU
-{3c2ac54f-554c-518b-7c46-3b22d86d0e3b}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{5dde57f4-3f98-c4b7-47e5-65229faf1f0f}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{5dde57f4-3f98-c4b7-47e5-65229faf1f0f}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{5dde57f4-3f98-c4b7-47e5-65229faf1f0f}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{5dde57f4-3f98-c4b7-47e5-65229faf1f0f}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{5dde57f4-3f98-c4b7-47e5-65229faf1f0f}.Release|Any CPU.Build.0 = Release|Any CPU
-{5dde57f4-3f98-c4b7-47e5-65229faf1f0f}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{2ee55c63-d077-25dd-f076-857adfe08080}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{2ee55c63-d077-25dd-f076-857adfe08080}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{2ee55c63-d077-25dd-f076-857adfe08080}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{2ee55c63-d077-25dd-f076-857adfe08080}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{2ee55c63-d077-25dd-f076-857adfe08080}.Release|Any CPU.Build.0 = Release|Any CPU
-{2ee55c63-d077-25dd-f076-857adfe08080}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{f22b7bcc-5a8d-3a02-d81c-caf6c9c44d61}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{f22b7bcc-5a8d-3a02-d81c-caf6c9c44d61}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{f22b7bcc-5a8d-3a02-d81c-caf6c9c44d61}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{f22b7bcc-5a8d-3a02-d81c-caf6c9c44d61}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{f22b7bcc-5a8d-3a02-d81c-caf6c9c44d61}.Release|Any CPU.Build.0 = Release|Any CPU
-{f22b7bcc-5a8d-3a02-d81c-caf6c9c44d61}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{b7a9eb2a-4b0e-548c-2370-a33ee63b21cc}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{b7a9eb2a-4b0e-548c-2370-a33ee63b21cc}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{b7a9eb2a-4b0e-548c-2370-a33ee63b21cc}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{b7a9eb2a-4b0e-548c-2370-a33ee63b21cc}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{b7a9eb2a-4b0e-548c-2370-a33ee63b21cc}.Release|Any CPU.Build.0 = Release|Any CPU
-{b7a9eb2a-4b0e-548c-2370-a33ee63b21cc}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{10e8cf6b-7fec-911f-770d-e3641296ac89}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{10e8cf6b-7fec-911f-770d-e3641296ac89}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{10e8cf6b-7fec-911f-770d-e3641296ac89}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{10e8cf6b-7fec-911f-770d-e3641296ac89}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{10e8cf6b-7fec-911f-770d-e3641296ac89}.Release|Any CPU.Build.0 = Release|Any CPU
-{10e8cf6b-7fec-911f-770d-e3641296ac89}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{f4286cfc-484b-8466-8efa-1111696babb9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{f4286cfc-484b-8466-8efa-1111696babb9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{f4286cfc-484b-8466-8efa-1111696babb9}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{f4286cfc-484b-8466-8efa-1111696babb9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{f4286cfc-484b-8466-8efa-1111696babb9}.Release|Any CPU.Build.0 = Release|Any CPU
-{f4286cfc-484b-8466-8efa-1111696babb9}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{b1567c85-ad77-c283-9165-777ad0e9a2eb}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{b1567c85-ad77-c283-9165-777ad0e9a2eb}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{b1567c85-ad77-c283-9165-777ad0e9a2eb}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{b1567c85-ad77-c283-9165-777ad0e9a2eb}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{b1567c85-ad77-c283-9165-777ad0e9a2eb}.Release|Any CPU.Build.0 = Release|Any CPU
-{b1567c85-ad77-c283-9165-777ad0e9a2eb}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{fcd3dfb2-9ee2-ad22-0e1f-4cddd575792a}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{fcd3dfb2-9ee2-ad22-0e1f-4cddd575792a}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{fcd3dfb2-9ee2-ad22-0e1f-4cddd575792a}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{fcd3dfb2-9ee2-ad22-0e1f-4cddd575792a}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{fcd3dfb2-9ee2-ad22-0e1f-4cddd575792a}.Release|Any CPU.Build.0 = Release|Any CPU
-{fcd3dfb2-9ee2-ad22-0e1f-4cddd575792a}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{f420eccc-b12d-72e4-2ad2-f93054eeec30}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{f420eccc-b12d-72e4-2ad2-f93054eeec30}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{f420eccc-b12d-72e4-2ad2-f93054eeec30}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{f420eccc-b12d-72e4-2ad2-f93054eeec30}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{f420eccc-b12d-72e4-2ad2-f93054eeec30}.Release|Any CPU.Build.0 = Release|Any CPU
-{f420eccc-b12d-72e4-2ad2-f93054eeec30}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{55160a70-69b2-4144-b974-b64d78bd50e0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{55160a70-69b2-4144-b974-b64d78bd50e0}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{55160a70-69b2-4144-b974-b64d78bd50e0}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{55160a70-69b2-4144-b974-b64d78bd50e0}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{55160a70-69b2-4144-b974-b64d78bd50e0}.Release|Any CPU.Build.0 = Release|Any CPU
-{55160a70-69b2-4144-b974-b64d78bd50e0}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{8beda85e-3d20-5926-c060-f92913f1192e}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{8beda85e-3d20-5926-c060-f92913f1192e}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{8beda85e-3d20-5926-c060-f92913f1192e}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{8beda85e-3d20-5926-c060-f92913f1192e}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{8beda85e-3d20-5926-c060-f92913f1192e}.Release|Any CPU.Build.0 = Release|Any CPU
-{8beda85e-3d20-5926-c060-f92913f1192e}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{29df066c-c160-cd60-b10f-23a0c3bb8457}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{29df066c-c160-cd60-b10f-23a0c3bb8457}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{29df066c-c160-cd60-b10f-23a0c3bb8457}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{29df066c-c160-cd60-b10f-23a0c3bb8457}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{29df066c-c160-cd60-b10f-23a0c3bb8457}.Release|Any CPU.Build.0 = Release|Any CPU
-{29df066c-c160-cd60-b10f-23a0c3bb8457}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{635581a6-f954-d0e4-9c68-02c1725e49d2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{635581a6-f954-d0e4-9c68-02c1725e49d2}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{635581a6-f954-d0e4-9c68-02c1725e49d2}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{635581a6-f954-d0e4-9c68-02c1725e49d2}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{635581a6-f954-d0e4-9c68-02c1725e49d2}.Release|Any CPU.Build.0 = Release|Any CPU
-{635581a6-f954-d0e4-9c68-02c1725e49d2}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{23a79010-5c1a-9120-0992-a69c8dd80015}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{23a79010-5c1a-9120-0992-a69c8dd80015}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{23a79010-5c1a-9120-0992-a69c8dd80015}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{23a79010-5c1a-9120-0992-a69c8dd80015}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{23a79010-5c1a-9120-0992-a69c8dd80015}.Release|Any CPU.Build.0 = Release|Any CPU
-{23a79010-5c1a-9120-0992-a69c8dd80015}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{76bf8a97-e573-a5b5-286f-04ca7e00f8e9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{76bf8a97-e573-a5b5-286f-04ca7e00f8e9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{76bf8a97-e573-a5b5-286f-04ca7e00f8e9}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{76bf8a97-e573-a5b5-286f-04ca7e00f8e9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{76bf8a97-e573-a5b5-286f-04ca7e00f8e9}.Release|Any CPU.Build.0 = Release|Any CPU
-{76bf8a97-e573-a5b5-286f-04ca7e00f8e9}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{66c94dc2-e546-9737-a45b-4bc60fe0e536}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{66c94dc2-e546-9737-a45b-4bc60fe0e536}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{66c94dc2-e546-9737-a45b-4bc60fe0e536}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{66c94dc2-e546-9737-a45b-4bc60fe0e536}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{66c94dc2-e546-9737-a45b-4bc60fe0e536}.Release|Any CPU.Build.0 = Release|Any CPU
-{66c94dc2-e546-9737-a45b-4bc60fe0e536}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{679517ca-9d0b-0ec2-35ae-95230281cfba}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{679517ca-9d0b-0ec2-35ae-95230281cfba}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{679517ca-9d0b-0ec2-35ae-95230281cfba}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{679517ca-9d0b-0ec2-35ae-95230281cfba}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{679517ca-9d0b-0ec2-35ae-95230281cfba}.Release|Any CPU.Build.0 = Release|Any CPU
-{679517ca-9d0b-0ec2-35ae-95230281cfba}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{e3d3c1e3-aaa3-5d40-472e-ae837457cf73}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{e3d3c1e3-aaa3-5d40-472e-ae837457cf73}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{e3d3c1e3-aaa3-5d40-472e-ae837457cf73}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{e3d3c1e3-aaa3-5d40-472e-ae837457cf73}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{e3d3c1e3-aaa3-5d40-472e-ae837457cf73}.Release|Any CPU.Build.0 = Release|Any CPU
-{e3d3c1e3-aaa3-5d40-472e-ae837457cf73}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{9f892c4e-26c2-1420-a73c-08138c8f6ca2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{9f892c4e-26c2-1420-a73c-08138c8f6ca2}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{9f892c4e-26c2-1420-a73c-08138c8f6ca2}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{9f892c4e-26c2-1420-a73c-08138c8f6ca2}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{9f892c4e-26c2-1420-a73c-08138c8f6ca2}.Release|Any CPU.Build.0 = Release|Any CPU
-{9f892c4e-26c2-1420-a73c-08138c8f6ca2}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{6e5b2ba2-7712-0f4f-d2bf-2624bb877dbe}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{6e5b2ba2-7712-0f4f-d2bf-2624bb877dbe}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{6e5b2ba2-7712-0f4f-d2bf-2624bb877dbe}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{6e5b2ba2-7712-0f4f-d2bf-2624bb877dbe}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{6e5b2ba2-7712-0f4f-d2bf-2624bb877dbe}.Release|Any CPU.Build.0 = Release|Any CPU
-{6e5b2ba2-7712-0f4f-d2bf-2624bb877dbe}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{78d59e90-3339-54d6-3803-f68623b72eff}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{78d59e90-3339-54d6-3803-f68623b72eff}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{78d59e90-3339-54d6-3803-f68623b72eff}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{78d59e90-3339-54d6-3803-f68623b72eff}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{78d59e90-3339-54d6-3803-f68623b72eff}.Release|Any CPU.Build.0 = Release|Any CPU
-{78d59e90-3339-54d6-3803-f68623b72eff}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{6a4a0f45-c2b4-6be4-e44a-e78d3282359f}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{6a4a0f45-c2b4-6be4-e44a-e78d3282359f}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{6a4a0f45-c2b4-6be4-e44a-e78d3282359f}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{6a4a0f45-c2b4-6be4-e44a-e78d3282359f}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{6a4a0f45-c2b4-6be4-e44a-e78d3282359f}.Release|Any CPU.Build.0 = Release|Any CPU
-{6a4a0f45-c2b4-6be4-e44a-e78d3282359f}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{006e161d-aae1-2dd1-5b94-ebd45d31f50a}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{006e161d-aae1-2dd1-5b94-ebd45d31f50a}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{006e161d-aae1-2dd1-5b94-ebd45d31f50a}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{006e161d-aae1-2dd1-5b94-ebd45d31f50a}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{006e161d-aae1-2dd1-5b94-ebd45d31f50a}.Release|Any CPU.Build.0 = Release|Any CPU
-{006e161d-aae1-2dd1-5b94-ebd45d31f50a}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{544c006b-f7de-21a9-a1b4-8df710e184c8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{544c006b-f7de-21a9-a1b4-8df710e184c8}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{544c006b-f7de-21a9-a1b4-8df710e184c8}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{544c006b-f7de-21a9-a1b4-8df710e184c8}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{544c006b-f7de-21a9-a1b4-8df710e184c8}.Release|Any CPU.Build.0 = Release|Any CPU
-{544c006b-f7de-21a9-a1b4-8df710e184c8}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{f7d3fcf2-cadc-19dd-4c4c-5a54a5102c95}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{f7d3fcf2-cadc-19dd-4c4c-5a54a5102c95}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{f7d3fcf2-cadc-19dd-4c4c-5a54a5102c95}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{f7d3fcf2-cadc-19dd-4c4c-5a54a5102c95}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{f7d3fcf2-cadc-19dd-4c4c-5a54a5102c95}.Release|Any CPU.Build.0 = Release|Any CPU
-{f7d3fcf2-cadc-19dd-4c4c-5a54a5102c95}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{c5025916-5039-97c2-b450-af1420f5fb08}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{c5025916-5039-97c2-b450-af1420f5fb08}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{c5025916-5039-97c2-b450-af1420f5fb08}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{c5025916-5039-97c2-b450-af1420f5fb08}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{c5025916-5039-97c2-b450-af1420f5fb08}.Release|Any CPU.Build.0 = Release|Any CPU
-{c5025916-5039-97c2-b450-af1420f5fb08}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{816884bb-a5f6-5c07-967b-bb8f21d724b7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{816884bb-a5f6-5c07-967b-bb8f21d724b7}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{816884bb-a5f6-5c07-967b-bb8f21d724b7}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{816884bb-a5f6-5c07-967b-bb8f21d724b7}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{816884bb-a5f6-5c07-967b-bb8f21d724b7}.Release|Any CPU.Build.0 = Release|Any CPU
-{816884bb-a5f6-5c07-967b-bb8f21d724b7}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Release|Any CPU.Build.0 = Release|Any CPU
-{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{5517dacf-b1ff-6515-e5b6-b5081f92f407}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{5517dacf-b1ff-6515-e5b6-b5081f92f407}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{5517dacf-b1ff-6515-e5b6-b5081f92f407}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{5517dacf-b1ff-6515-e5b6-b5081f92f407}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{5517dacf-b1ff-6515-e5b6-b5081f92f407}.Release|Any CPU.Build.0 = Release|Any CPU
-{5517dacf-b1ff-6515-e5b6-b5081f92f407}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{97ad732d-4ce5-2027-aabc-844002d29c23}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{97ad732d-4ce5-2027-aabc-844002d29c23}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{97ad732d-4ce5-2027-aabc-844002d29c23}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{97ad732d-4ce5-2027-aabc-844002d29c23}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{97ad732d-4ce5-2027-aabc-844002d29c23}.Release|Any CPU.Build.0 = Release|Any CPU
-{97ad732d-4ce5-2027-aabc-844002d29c23}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{6b975d30-c5dd-f1fd-9d0c-4d56ecdf9b25}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{6b975d30-c5dd-f1fd-9d0c-4d56ecdf9b25}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{6b975d30-c5dd-f1fd-9d0c-4d56ecdf9b25}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{6b975d30-c5dd-f1fd-9d0c-4d56ecdf9b25}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{6b975d30-c5dd-f1fd-9d0c-4d56ecdf9b25}.Release|Any CPU.Build.0 = Release|Any CPU
-{6b975d30-c5dd-f1fd-9d0c-4d56ecdf9b25}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{8d66b616-3198-b8a1-d2d0-03496db6a62b}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{8d66b616-3198-b8a1-d2d0-03496db6a62b}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{8d66b616-3198-b8a1-d2d0-03496db6a62b}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{8d66b616-3198-b8a1-d2d0-03496db6a62b}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{8d66b616-3198-b8a1-d2d0-03496db6a62b}.Release|Any CPU.Build.0 = Release|Any CPU
-{8d66b616-3198-b8a1-d2d0-03496db6a62b}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{6e68ff9b-3947-d706-3ad7-f9237a67c874}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{6e68ff9b-3947-d706-3ad7-f9237a67c874}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{6e68ff9b-3947-d706-3ad7-f9237a67c874}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{6e68ff9b-3947-d706-3ad7-f9237a67c874}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{6e68ff9b-3947-d706-3ad7-f9237a67c874}.Release|Any CPU.Build.0 = Release|Any CPU
-{6e68ff9b-3947-d706-3ad7-f9237a67c874}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{2b132458-96e5-72bf-673f-dda4a7fd514b}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{2b132458-96e5-72bf-673f-dda4a7fd514b}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{2b132458-96e5-72bf-673f-dda4a7fd514b}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{2b132458-96e5-72bf-673f-dda4a7fd514b}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{2b132458-96e5-72bf-673f-dda4a7fd514b}.Release|Any CPU.Build.0 = Release|Any CPU
-{2b132458-96e5-72bf-673f-dda4a7fd514b}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{3ede821e-ee76-967e-94d7-5b1d1239c8dd}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{3ede821e-ee76-967e-94d7-5b1d1239c8dd}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{3ede821e-ee76-967e-94d7-5b1d1239c8dd}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{3ede821e-ee76-967e-94d7-5b1d1239c8dd}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{3ede821e-ee76-967e-94d7-5b1d1239c8dd}.Release|Any CPU.Build.0 = Release|Any CPU
-{3ede821e-ee76-967e-94d7-5b1d1239c8dd}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{d846582b-8ae3-9779-01ea-7210b5330cfd}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{d846582b-8ae3-9779-01ea-7210b5330cfd}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{d846582b-8ae3-9779-01ea-7210b5330cfd}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{d846582b-8ae3-9779-01ea-7210b5330cfd}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{d846582b-8ae3-9779-01ea-7210b5330cfd}.Release|Any CPU.Build.0 = Release|Any CPU
-{d846582b-8ae3-9779-01ea-7210b5330cfd}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{d8d4e4e8-1dc8-0170-5e3c-18610853bd87}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{d8d4e4e8-1dc8-0170-5e3c-18610853bd87}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{d8d4e4e8-1dc8-0170-5e3c-18610853bd87}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{d8d4e4e8-1dc8-0170-5e3c-18610853bd87}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{d8d4e4e8-1dc8-0170-5e3c-18610853bd87}.Release|Any CPU.Build.0 = Release|Any CPU
-{d8d4e4e8-1dc8-0170-5e3c-18610853bd87}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{12bab01c-845f-82c9-b00b-a3639cdfb2ce}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{12bab01c-845f-82c9-b00b-a3639cdfb2ce}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{12bab01c-845f-82c9-b00b-a3639cdfb2ce}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{12bab01c-845f-82c9-b00b-a3639cdfb2ce}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{12bab01c-845f-82c9-b00b-a3639cdfb2ce}.Release|Any CPU.Build.0 = Release|Any CPU
-{12bab01c-845f-82c9-b00b-a3639cdfb2ce}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{5f9c09c7-9e32-8927-7a5d-90001ceffc69}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{5f9c09c7-9e32-8927-7a5d-90001ceffc69}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{5f9c09c7-9e32-8927-7a5d-90001ceffc69}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{5f9c09c7-9e32-8927-7a5d-90001ceffc69}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{5f9c09c7-9e32-8927-7a5d-90001ceffc69}.Release|Any CPU.Build.0 = Release|Any CPU
-{5f9c09c7-9e32-8927-7a5d-90001ceffc69}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{b545726f-7a83-3c78-2b55-6a709c5a6d00}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{b545726f-7a83-3c78-2b55-6a709c5a6d00}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{b545726f-7a83-3c78-2b55-6a709c5a6d00}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{b545726f-7a83-3c78-2b55-6a709c5a6d00}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{b545726f-7a83-3c78-2b55-6a709c5a6d00}.Release|Any CPU.Build.0 = Release|Any CPU
-{b545726f-7a83-3c78-2b55-6a709c5a6d00}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{8540cfb1-fe4a-dcc3-a70e-840262803cfc}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{8540cfb1-fe4a-dcc3-a70e-840262803cfc}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{8540cfb1-fe4a-dcc3-a70e-840262803cfc}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{8540cfb1-fe4a-dcc3-a70e-840262803cfc}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{8540cfb1-fe4a-dcc3-a70e-840262803cfc}.Release|Any CPU.Build.0 = Release|Any CPU
-{8540cfb1-fe4a-dcc3-a70e-840262803cfc}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{733e533d-9ff2-4c72-3da9-200f758dc6e3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{733e533d-9ff2-4c72-3da9-200f758dc6e3}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{733e533d-9ff2-4c72-3da9-200f758dc6e3}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{733e533d-9ff2-4c72-3da9-200f758dc6e3}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{733e533d-9ff2-4c72-3da9-200f758dc6e3}.Release|Any CPU.Build.0 = Release|Any CPU
-{733e533d-9ff2-4c72-3da9-200f758dc6e3}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{ff162d83-3229-2000-71ed-08999160dca3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{ff162d83-3229-2000-71ed-08999160dca3}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{ff162d83-3229-2000-71ed-08999160dca3}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{ff162d83-3229-2000-71ed-08999160dca3}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{ff162d83-3229-2000-71ed-08999160dca3}.Release|Any CPU.Build.0 = Release|Any CPU
-{ff162d83-3229-2000-71ed-08999160dca3}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{0556c9ad-b3a1-730c-959f-baf21e60f972}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{0556c9ad-b3a1-730c-959f-baf21e60f972}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{0556c9ad-b3a1-730c-959f-baf21e60f972}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{0556c9ad-b3a1-730c-959f-baf21e60f972}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{0556c9ad-b3a1-730c-959f-baf21e60f972}.Release|Any CPU.Build.0 = Release|Any CPU
-{0556c9ad-b3a1-730c-959f-baf21e60f972}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{5c300917-a99f-d166-4f56-f0da3c3614bb}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{5c300917-a99f-d166-4f56-f0da3c3614bb}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{5c300917-a99f-d166-4f56-f0da3c3614bb}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{5c300917-a99f-d166-4f56-f0da3c3614bb}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{5c300917-a99f-d166-4f56-f0da3c3614bb}.Release|Any CPU.Build.0 = Release|Any CPU
-{5c300917-a99f-d166-4f56-f0da3c3614bb}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{ab414094-9582-3357-d0e9-20b153a1b54c}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{ab414094-9582-3357-d0e9-20b153a1b54c}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{ab414094-9582-3357-d0e9-20b153a1b54c}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{ab414094-9582-3357-d0e9-20b153a1b54c}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{ab414094-9582-3357-d0e9-20b153a1b54c}.Release|Any CPU.Build.0 = Release|Any CPU
-{ab414094-9582-3357-d0e9-20b153a1b54c}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{8823a9ee-673a-e7d4-3c0a-bae61a262388}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{8823a9ee-673a-e7d4-3c0a-bae61a262388}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{8823a9ee-673a-e7d4-3c0a-bae61a262388}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{8823a9ee-673a-e7d4-3c0a-bae61a262388}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{8823a9ee-673a-e7d4-3c0a-bae61a262388}.Release|Any CPU.Build.0 = Release|Any CPU
-{8823a9ee-673a-e7d4-3c0a-bae61a262388}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{cbded274-6b9b-a113-d56f-00b38006cc84}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{cbded274-6b9b-a113-d56f-00b38006cc84}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{cbded274-6b9b-a113-d56f-00b38006cc84}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{cbded274-6b9b-a113-d56f-00b38006cc84}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{cbded274-6b9b-a113-d56f-00b38006cc84}.Release|Any CPU.Build.0 = Release|Any CPU
-{cbded274-6b9b-a113-d56f-00b38006cc84}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{fe30ed04-094f-5005-b0aa-1b3623db60b2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{fe30ed04-094f-5005-b0aa-1b3623db60b2}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{fe30ed04-094f-5005-b0aa-1b3623db60b2}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{fe30ed04-094f-5005-b0aa-1b3623db60b2}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{fe30ed04-094f-5005-b0aa-1b3623db60b2}.Release|Any CPU.Build.0 = Release|Any CPU
-{fe30ed04-094f-5005-b0aa-1b3623db60b2}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{a38e4da2-f05f-aa6f-82f1-56cd2e062d96}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{a38e4da2-f05f-aa6f-82f1-56cd2e062d96}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{a38e4da2-f05f-aa6f-82f1-56cd2e062d96}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{a38e4da2-f05f-aa6f-82f1-56cd2e062d96}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{a38e4da2-f05f-aa6f-82f1-56cd2e062d96}.Release|Any CPU.Build.0 = Release|Any CPU
-{a38e4da2-f05f-aa6f-82f1-56cd2e062d96}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{733f9598-101b-936b-b081-2805dd793091}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{733f9598-101b-936b-b081-2805dd793091}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{733f9598-101b-936b-b081-2805dd793091}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{733f9598-101b-936b-b081-2805dd793091}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{733f9598-101b-936b-b081-2805dd793091}.Release|Any CPU.Build.0 = Release|Any CPU
-{733f9598-101b-936b-b081-2805dd793091}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{809c4afa-d014-471b-518b-4fd01cb7c808}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{809c4afa-d014-471b-518b-4fd01cb7c808}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{809c4afa-d014-471b-518b-4fd01cb7c808}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{809c4afa-d014-471b-518b-4fd01cb7c808}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{809c4afa-d014-471b-518b-4fd01cb7c808}.Release|Any CPU.Build.0 = Release|Any CPU
-{809c4afa-d014-471b-518b-4fd01cb7c808}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{f0c5342b-fb95-48a4-029f-7aa631ce06f1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{f0c5342b-fb95-48a4-029f-7aa631ce06f1}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{f0c5342b-fb95-48a4-029f-7aa631ce06f1}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{f0c5342b-fb95-48a4-029f-7aa631ce06f1}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{f0c5342b-fb95-48a4-029f-7aa631ce06f1}.Release|Any CPU.Build.0 = Release|Any CPU
-{f0c5342b-fb95-48a4-029f-7aa631ce06f1}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{3ea3301e-d3de-6979-f1d7-58352998951c}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{3ea3301e-d3de-6979-f1d7-58352998951c}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{3ea3301e-d3de-6979-f1d7-58352998951c}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{3ea3301e-d3de-6979-f1d7-58352998951c}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{3ea3301e-d3de-6979-f1d7-58352998951c}.Release|Any CPU.Build.0 = Release|Any CPU
-{3ea3301e-d3de-6979-f1d7-58352998951c}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{f8c5a010-c353-31da-cadc-b56186be374f}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{f8c5a010-c353-31da-cadc-b56186be374f}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{f8c5a010-c353-31da-cadc-b56186be374f}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{f8c5a010-c353-31da-cadc-b56186be374f}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{f8c5a010-c353-31da-cadc-b56186be374f}.Release|Any CPU.Build.0 = Release|Any CPU
-{f8c5a010-c353-31da-cadc-b56186be374f}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{0b1482c2-a3b1-6207-b73f-a07f46718b65}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{0b1482c2-a3b1-6207-b73f-a07f46718b65}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{0b1482c2-a3b1-6207-b73f-a07f46718b65}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{0b1482c2-a3b1-6207-b73f-a07f46718b65}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{0b1482c2-a3b1-6207-b73f-a07f46718b65}.Release|Any CPU.Build.0 = Release|Any CPU
-{0b1482c2-a3b1-6207-b73f-a07f46718b65}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{a0821347-be46-c587-b61d-5152c578048d}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{a0821347-be46-c587-b61d-5152c578048d}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{a0821347-be46-c587-b61d-5152c578048d}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{a0821347-be46-c587-b61d-5152c578048d}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{a0821347-be46-c587-b61d-5152c578048d}.Release|Any CPU.Build.0 = Release|Any CPU
-{a0821347-be46-c587-b61d-5152c578048d}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{15622f39-b4c5-7e66-57bc-31900b6065c8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{15622f39-b4c5-7e66-57bc-31900b6065c8}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{15622f39-b4c5-7e66-57bc-31900b6065c8}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{15622f39-b4c5-7e66-57bc-31900b6065c8}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{15622f39-b4c5-7e66-57bc-31900b6065c8}.Release|Any CPU.Build.0 = Release|Any CPU
-{15622f39-b4c5-7e66-57bc-31900b6065c8}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{db140d08-4769-dc51-8809-a9222b830ef4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{db140d08-4769-dc51-8809-a9222b830ef4}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{db140d08-4769-dc51-8809-a9222b830ef4}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{db140d08-4769-dc51-8809-a9222b830ef4}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{db140d08-4769-dc51-8809-a9222b830ef4}.Release|Any CPU.Build.0 = Release|Any CPU
-{db140d08-4769-dc51-8809-a9222b830ef4}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{6218c061-3905-79b2-d3bc-bb7b8fc77a69}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{6218c061-3905-79b2-d3bc-bb7b8fc77a69}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{6218c061-3905-79b2-d3bc-bb7b8fc77a69}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{6218c061-3905-79b2-d3bc-bb7b8fc77a69}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{6218c061-3905-79b2-d3bc-bb7b8fc77a69}.Release|Any CPU.Build.0 = Release|Any CPU
-{6218c061-3905-79b2-d3bc-bb7b8fc77a69}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{589b202c-e638-5c93-fefe-e1e3bab4a493}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{589b202c-e638-5c93-fefe-e1e3bab4a493}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{589b202c-e638-5c93-fefe-e1e3bab4a493}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{589b202c-e638-5c93-fefe-e1e3bab4a493}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{589b202c-e638-5c93-fefe-e1e3bab4a493}.Release|Any CPU.Build.0 = Release|Any CPU
-{589b202c-e638-5c93-fefe-e1e3bab4a493}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{9b77d4e0-863d-4a74-c30a-56f7b2bb7cb7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{9b77d4e0-863d-4a74-c30a-56f7b2bb7cb7}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{9b77d4e0-863d-4a74-c30a-56f7b2bb7cb7}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{9b77d4e0-863d-4a74-c30a-56f7b2bb7cb7}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{9b77d4e0-863d-4a74-c30a-56f7b2bb7cb7}.Release|Any CPU.Build.0 = Release|Any CPU
-{9b77d4e0-863d-4a74-c30a-56f7b2bb7cb7}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{2053731b-90f5-5141-d15e-8d7be8c2662f}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{2053731b-90f5-5141-d15e-8d7be8c2662f}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{2053731b-90f5-5141-d15e-8d7be8c2662f}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{2053731b-90f5-5141-d15e-8d7be8c2662f}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{2053731b-90f5-5141-d15e-8d7be8c2662f}.Release|Any CPU.Build.0 = Release|Any CPU
-{2053731b-90f5-5141-d15e-8d7be8c2662f}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{49cc942b-d836-a48b-0429-25bf95247759}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{49cc942b-d836-a48b-0429-25bf95247759}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{49cc942b-d836-a48b-0429-25bf95247759}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{49cc942b-d836-a48b-0429-25bf95247759}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{49cc942b-d836-a48b-0429-25bf95247759}.Release|Any CPU.Build.0 = Release|Any CPU
-{49cc942b-d836-a48b-0429-25bf95247759}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{0d21f127-8c25-9b3a-9612-ce2eea6e7ac1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{0d21f127-8c25-9b3a-9612-ce2eea6e7ac1}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{0d21f127-8c25-9b3a-9612-ce2eea6e7ac1}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{0d21f127-8c25-9b3a-9612-ce2eea6e7ac1}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{0d21f127-8c25-9b3a-9612-ce2eea6e7ac1}.Release|Any CPU.Build.0 = Release|Any CPU
-{0d21f127-8c25-9b3a-9612-ce2eea6e7ac1}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{fe51bbda-2039-23fd-f29a-39c14adcb1f6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{fe51bbda-2039-23fd-f29a-39c14adcb1f6}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{fe51bbda-2039-23fd-f29a-39c14adcb1f6}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{fe51bbda-2039-23fd-f29a-39c14adcb1f6}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{fe51bbda-2039-23fd-f29a-39c14adcb1f6}.Release|Any CPU.Build.0 = Release|Any CPU
-{fe51bbda-2039-23fd-f29a-39c14adcb1f6}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{34a31e0b-15ec-829c-6f0b-74f5acfd97e2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{34a31e0b-15ec-829c-6f0b-74f5acfd97e2}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{34a31e0b-15ec-829c-6f0b-74f5acfd97e2}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{34a31e0b-15ec-829c-6f0b-74f5acfd97e2}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{34a31e0b-15ec-829c-6f0b-74f5acfd97e2}.Release|Any CPU.Build.0 = Release|Any CPU
-{34a31e0b-15ec-829c-6f0b-74f5acfd97e2}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{9b381685-8129-acba-66f0-7068fe43a6c3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{9b381685-8129-acba-66f0-7068fe43a6c3}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{9b381685-8129-acba-66f0-7068fe43a6c3}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{9b381685-8129-acba-66f0-7068fe43a6c3}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{9b381685-8129-acba-66f0-7068fe43a6c3}.Release|Any CPU.Build.0 = Release|Any CPU
-{9b381685-8129-acba-66f0-7068fe43a6c3}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{493d1e8e-51c6-da82-9289-25bd26fab4a4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{493d1e8e-51c6-da82-9289-25bd26fab4a4}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{493d1e8e-51c6-da82-9289-25bd26fab4a4}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{493d1e8e-51c6-da82-9289-25bd26fab4a4}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{493d1e8e-51c6-da82-9289-25bd26fab4a4}.Release|Any CPU.Build.0 = Release|Any CPU
-{493d1e8e-51c6-da82-9289-25bd26fab4a4}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{56968e84-6b7d-d548-4c0b-53017bd6123c}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{56968e84-6b7d-d548-4c0b-53017bd6123c}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{56968e84-6b7d-d548-4c0b-53017bd6123c}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{56968e84-6b7d-d548-4c0b-53017bd6123c}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{56968e84-6b7d-d548-4c0b-53017bd6123c}.Release|Any CPU.Build.0 = Release|Any CPU
-{56968e84-6b7d-d548-4c0b-53017bd6123c}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{5e741dd9-690a-de16-e7a1-85e6239aa70d}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{5e741dd9-690a-de16-e7a1-85e6239aa70d}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{5e741dd9-690a-de16-e7a1-85e6239aa70d}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{5e741dd9-690a-de16-e7a1-85e6239aa70d}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{5e741dd9-690a-de16-e7a1-85e6239aa70d}.Release|Any CPU.Build.0 = Release|Any CPU
-{5e741dd9-690a-de16-e7a1-85e6239aa70d}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{94317d9a-d614-b098-6175-76ee84262c05}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{94317d9a-d614-b098-6175-76ee84262c05}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{94317d9a-d614-b098-6175-76ee84262c05}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{94317d9a-d614-b098-6175-76ee84262c05}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{94317d9a-d614-b098-6175-76ee84262c05}.Release|Any CPU.Build.0 = Release|Any CPU
-{94317d9a-d614-b098-6175-76ee84262c05}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{f907841f-b1ee-9b12-580e-cfe2324bed03}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{f907841f-b1ee-9b12-580e-cfe2324bed03}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{f907841f-b1ee-9b12-580e-cfe2324bed03}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{f907841f-b1ee-9b12-580e-cfe2324bed03}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{f907841f-b1ee-9b12-580e-cfe2324bed03}.Release|Any CPU.Build.0 = Release|Any CPU
-{f907841f-b1ee-9b12-580e-cfe2324bed03}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{c9e4cfa9-c5d3-5e9d-243c-106ba4b6a447}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{c9e4cfa9-c5d3-5e9d-243c-106ba4b6a447}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{c9e4cfa9-c5d3-5e9d-243c-106ba4b6a447}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{c9e4cfa9-c5d3-5e9d-243c-106ba4b6a447}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{c9e4cfa9-c5d3-5e9d-243c-106ba4b6a447}.Release|Any CPU.Build.0 = Release|Any CPU
-{c9e4cfa9-c5d3-5e9d-243c-106ba4b6a447}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{dcdccf04-c930-b455-77a4-d9d4a7df8723}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{dcdccf04-c930-b455-77a4-d9d4a7df8723}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{dcdccf04-c930-b455-77a4-d9d4a7df8723}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{dcdccf04-c930-b455-77a4-d9d4a7df8723}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{dcdccf04-c930-b455-77a4-d9d4a7df8723}.Release|Any CPU.Build.0 = Release|Any CPU
-{dcdccf04-c930-b455-77a4-d9d4a7df8723}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{8eec9904-f4bb-c601-86ac-80fb153599f9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{8eec9904-f4bb-c601-86ac-80fb153599f9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{8eec9904-f4bb-c601-86ac-80fb153599f9}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{8eec9904-f4bb-c601-86ac-80fb153599f9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{8eec9904-f4bb-c601-86ac-80fb153599f9}.Release|Any CPU.Build.0 = Release|Any CPU
-{8eec9904-f4bb-c601-86ac-80fb153599f9}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{69b383c7-828a-1857-cbe2-f11b9ba77320}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{69b383c7-828a-1857-cbe2-f11b9ba77320}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{69b383c7-828a-1857-cbe2-f11b9ba77320}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{69b383c7-828a-1857-cbe2-f11b9ba77320}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{69b383c7-828a-1857-cbe2-f11b9ba77320}.Release|Any CPU.Build.0 = Release|Any CPU
-{69b383c7-828a-1857-cbe2-f11b9ba77320}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{abf4b42f-e999-2a78-403f-fb09524f186a}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{abf4b42f-e999-2a78-403f-fb09524f186a}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{abf4b42f-e999-2a78-403f-fb09524f186a}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{abf4b42f-e999-2a78-403f-fb09524f186a}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{abf4b42f-e999-2a78-403f-fb09524f186a}.Release|Any CPU.Build.0 = Release|Any CPU
-{abf4b42f-e999-2a78-403f-fb09524f186a}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{b0be4813-d93e-7b06-d422-23ca28adf22a}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{b0be4813-d93e-7b06-d422-23ca28adf22a}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{b0be4813-d93e-7b06-d422-23ca28adf22a}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{b0be4813-d93e-7b06-d422-23ca28adf22a}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{b0be4813-d93e-7b06-d422-23ca28adf22a}.Release|Any CPU.Build.0 = Release|Any CPU
-{b0be4813-d93e-7b06-d422-23ca28adf22a}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{c028861d-f9e8-8231-2b6a-bc3b3fba349c}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{c028861d-f9e8-8231-2b6a-bc3b3fba349c}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{c028861d-f9e8-8231-2b6a-bc3b3fba349c}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{c028861d-f9e8-8231-2b6a-bc3b3fba349c}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{c028861d-f9e8-8231-2b6a-bc3b3fba349c}.Release|Any CPU.Build.0 = Release|Any CPU
-{c028861d-f9e8-8231-2b6a-bc3b3fba349c}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Release|Any CPU.Build.0 = Release|Any CPU
-{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{83d6c79a-c71a-d467-284c-28edbbd059d2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{83d6c79a-c71a-d467-284c-28edbbd059d2}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{83d6c79a-c71a-d467-284c-28edbbd059d2}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{83d6c79a-c71a-d467-284c-28edbbd059d2}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{83d6c79a-c71a-d467-284c-28edbbd059d2}.Release|Any CPU.Build.0 = Release|Any CPU
-{83d6c79a-c71a-d467-284c-28edbbd059d2}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{4ac05c74-08c5-2153-f38c-976975747b5c}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{4ac05c74-08c5-2153-f38c-976975747b5c}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{4ac05c74-08c5-2153-f38c-976975747b5c}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{4ac05c74-08c5-2153-f38c-976975747b5c}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{4ac05c74-08c5-2153-f38c-976975747b5c}.Release|Any CPU.Build.0 = Release|Any CPU
-{4ac05c74-08c5-2153-f38c-976975747b5c}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{e2110137-6a36-f4d1-2219-26eb18fee74d}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{e2110137-6a36-f4d1-2219-26eb18fee74d}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{e2110137-6a36-f4d1-2219-26eb18fee74d}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{e2110137-6a36-f4d1-2219-26eb18fee74d}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{e2110137-6a36-f4d1-2219-26eb18fee74d}.Release|Any CPU.Build.0 = Release|Any CPU
-{e2110137-6a36-f4d1-2219-26eb18fee74d}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{934ef064-2dce-6d50-64e9-d4d2c4d41a81}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{934ef064-2dce-6d50-64e9-d4d2c4d41a81}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{934ef064-2dce-6d50-64e9-d4d2c4d41a81}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{934ef064-2dce-6d50-64e9-d4d2c4d41a81}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{934ef064-2dce-6d50-64e9-d4d2c4d41a81}.Release|Any CPU.Build.0 = Release|Any CPU
-{934ef064-2dce-6d50-64e9-d4d2c4d41a81}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{3788f245-ea6d-eb5d-80de-f25ab30a51cc}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{3788f245-ea6d-eb5d-80de-f25ab30a51cc}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{3788f245-ea6d-eb5d-80de-f25ab30a51cc}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{3788f245-ea6d-eb5d-80de-f25ab30a51cc}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{3788f245-ea6d-eb5d-80de-f25ab30a51cc}.Release|Any CPU.Build.0 = Release|Any CPU
-{3788f245-ea6d-eb5d-80de-f25ab30a51cc}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{eae89113-1312-f83c-1a4b-638b98e760b3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{eae89113-1312-f83c-1a4b-638b98e760b3}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{eae89113-1312-f83c-1a4b-638b98e760b3}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{eae89113-1312-f83c-1a4b-638b98e760b3}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{eae89113-1312-f83c-1a4b-638b98e760b3}.Release|Any CPU.Build.0 = Release|Any CPU
-{eae89113-1312-f83c-1a4b-638b98e760b3}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{609c8143-bdb3-709b-a7a5-cc33659c9b51}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{609c8143-bdb3-709b-a7a5-cc33659c9b51}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{609c8143-bdb3-709b-a7a5-cc33659c9b51}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{609c8143-bdb3-709b-a7a5-cc33659c9b51}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{609c8143-bdb3-709b-a7a5-cc33659c9b51}.Release|Any CPU.Build.0 = Release|Any CPU
-{609c8143-bdb3-709b-a7a5-cc33659c9b51}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{39d13fa7-a1df-cea6-adee-bab64a00a843}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{39d13fa7-a1df-cea6-adee-bab64a00a843}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{39d13fa7-a1df-cea6-adee-bab64a00a843}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{39d13fa7-a1df-cea6-adee-bab64a00a843}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{39d13fa7-a1df-cea6-adee-bab64a00a843}.Release|Any CPU.Build.0 = Release|Any CPU
-{39d13fa7-a1df-cea6-adee-bab64a00a843}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{5bce25ab-a4d6-d89c-5274-7eadd8c5967a}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{5bce25ab-a4d6-d89c-5274-7eadd8c5967a}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{5bce25ab-a4d6-d89c-5274-7eadd8c5967a}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{5bce25ab-a4d6-d89c-5274-7eadd8c5967a}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{5bce25ab-a4d6-d89c-5274-7eadd8c5967a}.Release|Any CPU.Build.0 = Release|Any CPU
-{5bce25ab-a4d6-d89c-5274-7eadd8c5967a}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{0d5dc515-9d35-ac02-c0b1-12c70c3163a2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{0d5dc515-9d35-ac02-c0b1-12c70c3163a2}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{0d5dc515-9d35-ac02-c0b1-12c70c3163a2}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{0d5dc515-9d35-ac02-c0b1-12c70c3163a2}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{0d5dc515-9d35-ac02-c0b1-12c70c3163a2}.Release|Any CPU.Build.0 = Release|Any CPU
-{0d5dc515-9d35-ac02-c0b1-12c70c3163a2}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{f1a91b9a-ec32-5f98-d4d6-75ac04c63276}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{f1a91b9a-ec32-5f98-d4d6-75ac04c63276}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{f1a91b9a-ec32-5f98-d4d6-75ac04c63276}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{f1a91b9a-ec32-5f98-d4d6-75ac04c63276}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{f1a91b9a-ec32-5f98-d4d6-75ac04c63276}.Release|Any CPU.Build.0 = Release|Any CPU
-{f1a91b9a-ec32-5f98-d4d6-75ac04c63276}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{74b88d5c-96e5-7286-d2b2-8def18538246}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{74b88d5c-96e5-7286-d2b2-8def18538246}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{74b88d5c-96e5-7286-d2b2-8def18538246}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{74b88d5c-96e5-7286-d2b2-8def18538246}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{74b88d5c-96e5-7286-d2b2-8def18538246}.Release|Any CPU.Build.0 = Release|Any CPU
-{74b88d5c-96e5-7286-d2b2-8def18538246}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{d63ac796-7087-bf6c-2848-e6511358fbe4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{d63ac796-7087-bf6c-2848-e6511358fbe4}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{d63ac796-7087-bf6c-2848-e6511358fbe4}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{d63ac796-7087-bf6c-2848-e6511358fbe4}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{d63ac796-7087-bf6c-2848-e6511358fbe4}.Release|Any CPU.Build.0 = Release|Any CPU
-{d63ac796-7087-bf6c-2848-e6511358fbe4}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{e9fe72c3-56b4-856b-a592-ae6e98e571f3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{e9fe72c3-56b4-856b-a592-ae6e98e571f3}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{e9fe72c3-56b4-856b-a592-ae6e98e571f3}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{e9fe72c3-56b4-856b-a592-ae6e98e571f3}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{e9fe72c3-56b4-856b-a592-ae6e98e571f3}.Release|Any CPU.Build.0 = Release|Any CPU
-{e9fe72c3-56b4-856b-a592-ae6e98e571f3}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{5da7dbe9-f180-570f-2da0-2737f043744d}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{5da7dbe9-f180-570f-2da0-2737f043744d}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{5da7dbe9-f180-570f-2da0-2737f043744d}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{5da7dbe9-f180-570f-2da0-2737f043744d}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{5da7dbe9-f180-570f-2da0-2737f043744d}.Release|Any CPU.Build.0 = Release|Any CPU
-{5da7dbe9-f180-570f-2da0-2737f043744d}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{8bce58b9-1a87-6bb3-3cee-e0e0f012b618}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{8bce58b9-1a87-6bb3-3cee-e0e0f012b618}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{8bce58b9-1a87-6bb3-3cee-e0e0f012b618}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{8bce58b9-1a87-6bb3-3cee-e0e0f012b618}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{8bce58b9-1a87-6bb3-3cee-e0e0f012b618}.Release|Any CPU.Build.0 = Release|Any CPU
-{8bce58b9-1a87-6bb3-3cee-e0e0f012b618}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{dfbb7b9f-c604-fedd-e658-17e196043123}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{dfbb7b9f-c604-fedd-e658-17e196043123}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{dfbb7b9f-c604-fedd-e658-17e196043123}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{dfbb7b9f-c604-fedd-e658-17e196043123}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{dfbb7b9f-c604-fedd-e658-17e196043123}.Release|Any CPU.Build.0 = Release|Any CPU
-{dfbb7b9f-c604-fedd-e658-17e196043123}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{8854c5e8-e40b-74c3-aafc-de0f13239276}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{8854c5e8-e40b-74c3-aafc-de0f13239276}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{8854c5e8-e40b-74c3-aafc-de0f13239276}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{8854c5e8-e40b-74c3-aafc-de0f13239276}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{8854c5e8-e40b-74c3-aafc-de0f13239276}.Release|Any CPU.Build.0 = Release|Any CPU
-{8854c5e8-e40b-74c3-aafc-de0f13239276}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{83d1d75e-3c26-b8d0-f097-f99452e749cc}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{83d1d75e-3c26-b8d0-f097-f99452e749cc}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{83d1d75e-3c26-b8d0-f097-f99452e749cc}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{83d1d75e-3c26-b8d0-f097-f99452e749cc}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{83d1d75e-3c26-b8d0-f097-f99452e749cc}.Release|Any CPU.Build.0 = Release|Any CPU
-{83d1d75e-3c26-b8d0-f097-f99452e749cc}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{7e7d8010-b37a-151a-11a5-1db234ee1104}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{7e7d8010-b37a-151a-11a5-1db234ee1104}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{7e7d8010-b37a-151a-11a5-1db234ee1104}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{7e7d8010-b37a-151a-11a5-1db234ee1104}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{7e7d8010-b37a-151a-11a5-1db234ee1104}.Release|Any CPU.Build.0 = Release|Any CPU
-{7e7d8010-b37a-151a-11a5-1db234ee1104}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{0194c08d-ffcd-78bd-9e14-66634fe6d4ea}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{0194c08d-ffcd-78bd-9e14-66634fe6d4ea}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{0194c08d-ffcd-78bd-9e14-66634fe6d4ea}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{0194c08d-ffcd-78bd-9e14-66634fe6d4ea}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{0194c08d-ffcd-78bd-9e14-66634fe6d4ea}.Release|Any CPU.Build.0 = Release|Any CPU
-{0194c08d-ffcd-78bd-9e14-66634fe6d4ea}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{c69bdd4d-3ebd-4b8e-cffb-650903da3872}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{c69bdd4d-3ebd-4b8e-cffb-650903da3872}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{c69bdd4d-3ebd-4b8e-cffb-650903da3872}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{c69bdd4d-3ebd-4b8e-cffb-650903da3872}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{c69bdd4d-3ebd-4b8e-cffb-650903da3872}.Release|Any CPU.Build.0 = Release|Any CPU
-{c69bdd4d-3ebd-4b8e-cffb-650903da3872}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{3b6bbc8a-1b22-deff-2980-53b77b6f3e5f}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{3b6bbc8a-1b22-deff-2980-53b77b6f3e5f}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{3b6bbc8a-1b22-deff-2980-53b77b6f3e5f}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{3b6bbc8a-1b22-deff-2980-53b77b6f3e5f}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{3b6bbc8a-1b22-deff-2980-53b77b6f3e5f}.Release|Any CPU.Build.0 = Release|Any CPU
-{3b6bbc8a-1b22-deff-2980-53b77b6f3e5f}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{05ac8aed-49a4-5c9f-d8c2-8d2debf64791}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{05ac8aed-49a4-5c9f-d8c2-8d2debf64791}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{05ac8aed-49a4-5c9f-d8c2-8d2debf64791}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{05ac8aed-49a4-5c9f-d8c2-8d2debf64791}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{05ac8aed-49a4-5c9f-d8c2-8d2debf64791}.Release|Any CPU.Build.0 = Release|Any CPU
-{05ac8aed-49a4-5c9f-d8c2-8d2debf64791}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{c00185af-8735-7674-5fa6-232424b04161}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{c00185af-8735-7674-5fa6-232424b04161}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{c00185af-8735-7674-5fa6-232424b04161}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{c00185af-8735-7674-5fa6-232424b04161}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{c00185af-8735-7674-5fa6-232424b04161}.Release|Any CPU.Build.0 = Release|Any CPU
-{c00185af-8735-7674-5fa6-232424b04161}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{66b90fb1-20d7-f563-3477-4c7c6b404f4d}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{66b90fb1-20d7-f563-3477-4c7c6b404f4d}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{66b90fb1-20d7-f563-3477-4c7c6b404f4d}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{66b90fb1-20d7-f563-3477-4c7c6b404f4d}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{66b90fb1-20d7-f563-3477-4c7c6b404f4d}.Release|Any CPU.Build.0 = Release|Any CPU
-{66b90fb1-20d7-f563-3477-4c7c6b404f4d}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{4aa72022-0946-6a28-a4e9-6c9add5caef6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{4aa72022-0946-6a28-a4e9-6c9add5caef6}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{4aa72022-0946-6a28-a4e9-6c9add5caef6}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{4aa72022-0946-6a28-a4e9-6c9add5caef6}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{4aa72022-0946-6a28-a4e9-6c9add5caef6}.Release|Any CPU.Build.0 = Release|Any CPU
-{4aa72022-0946-6a28-a4e9-6c9add5caef6}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{b22e47e1-9506-56e6-3d19-780b887d8cb3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{b22e47e1-9506-56e6-3d19-780b887d8cb3}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{b22e47e1-9506-56e6-3d19-780b887d8cb3}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{b22e47e1-9506-56e6-3d19-780b887d8cb3}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{b22e47e1-9506-56e6-3d19-780b887d8cb3}.Release|Any CPU.Build.0 = Release|Any CPU
-{b22e47e1-9506-56e6-3d19-780b887d8cb3}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{753bcc52-c451-8b29-6ae7-520b02ee6960}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{753bcc52-c451-8b29-6ae7-520b02ee6960}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{753bcc52-c451-8b29-6ae7-520b02ee6960}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{753bcc52-c451-8b29-6ae7-520b02ee6960}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{753bcc52-c451-8b29-6ae7-520b02ee6960}.Release|Any CPU.Build.0 = Release|Any CPU
-{753bcc52-c451-8b29-6ae7-520b02ee6960}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{b66e3a3e-7945-3d40-24ef-73fa6e1b8d41}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{b66e3a3e-7945-3d40-24ef-73fa6e1b8d41}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{b66e3a3e-7945-3d40-24ef-73fa6e1b8d41}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{b66e3a3e-7945-3d40-24ef-73fa6e1b8d41}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{b66e3a3e-7945-3d40-24ef-73fa6e1b8d41}.Release|Any CPU.Build.0 = Release|Any CPU
-{b66e3a3e-7945-3d40-24ef-73fa6e1b8d41}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{cd2b60c1-a4b5-36f2-afa3-6cf1031f9e7f}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{cd2b60c1-a4b5-36f2-afa3-6cf1031f9e7f}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{cd2b60c1-a4b5-36f2-afa3-6cf1031f9e7f}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{cd2b60c1-a4b5-36f2-afa3-6cf1031f9e7f}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{cd2b60c1-a4b5-36f2-afa3-6cf1031f9e7f}.Release|Any CPU.Build.0 = Release|Any CPU
-{cd2b60c1-a4b5-36f2-afa3-6cf1031f9e7f}.Release|Any CPU.Deploy.0 = Release|Any CPU
-{8433aac6-218d-9b7b-6eaa-36774e165446}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-{8433aac6-218d-9b7b-6eaa-36774e165446}.Debug|Any CPU.Build.0 = Debug|Any CPU
-{8433aac6-218d-9b7b-6eaa-36774e165446}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-{8433aac6-218d-9b7b-6eaa-36774e165446}.Release|Any CPU.ActiveCfg = Release|Any CPU
-{8433aac6-218d-9b7b-6eaa-36774e165446}.Release|Any CPU.Build.0 = Release|Any CPU
-{8433aac6-218d-9b7b-6eaa-36774e165446}.Release|Any CPU.Deploy.0 = Release|Any CPU
-
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {43971d92-3663-4f28-82ac-e63ce06ba1a3}
-	EndGlobalSection
-EndGlobal
-
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VitaminA/UnitsNet.NanoFramework.VitaminA.nuspec b/UnitsNet.NanoFramework/GeneratedCode/VitaminA/UnitsNet.NanoFramework.VitaminA.nuspec
deleted file mode 100644
index 0141948c6f..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VitaminA/UnitsNet.NanoFramework.VitaminA.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.VitaminA</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET VitaminA - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds VitaminA units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework vitamina unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\VitaminA\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VitaminA/VitaminA.nfproj b/UnitsNet.NanoFramework/GeneratedCode/VitaminA/VitaminA.nfproj
deleted file mode 100644
index 8f39d21b69..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VitaminA/VitaminA.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{c00185af-8735-7674-5fa6-232424b04161}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.VitaminA</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\VitaminA.g.cs" />
-    <Compile Include="..\Units\VitaminAUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VitaminA/packages.config b/UnitsNet.NanoFramework/GeneratedCode/VitaminA/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VitaminA/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Volume/UnitsNet.NanoFramework.Volume.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Volume/UnitsNet.NanoFramework.Volume.nuspec
deleted file mode 100644
index cc4ecb50ff..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Volume/UnitsNet.NanoFramework.Volume.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.Volume</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET Volume - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds Volume units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework volume unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\Volume\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Volume/Volume.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Volume/Volume.nfproj
deleted file mode 100644
index cd8795c28d..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Volume/Volume.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{66b90fb1-20d7-f563-3477-4c7c6b404f4d}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.Volume</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\Volume.g.cs" />
-    <Compile Include="..\Units\VolumeUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Volume/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Volume/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/Volume/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumeConcentration/UnitsNet.NanoFramework.VolumeConcentration.nuspec b/UnitsNet.NanoFramework/GeneratedCode/VolumeConcentration/UnitsNet.NanoFramework.VolumeConcentration.nuspec
deleted file mode 100644
index d3919ab1f3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumeConcentration/UnitsNet.NanoFramework.VolumeConcentration.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.VolumeConcentration</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET VolumeConcentration - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds VolumeConcentration units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework volumeconcentration unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\VolumeConcentration\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumeConcentration/VolumeConcentration.nfproj b/UnitsNet.NanoFramework/GeneratedCode/VolumeConcentration/VolumeConcentration.nfproj
deleted file mode 100644
index 139a354e79..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumeConcentration/VolumeConcentration.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{4aa72022-0946-6a28-a4e9-6c9add5caef6}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.VolumeConcentration</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\VolumeConcentration.g.cs" />
-    <Compile Include="..\Units\VolumeConcentrationUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumeConcentration/packages.config b/UnitsNet.NanoFramework/GeneratedCode/VolumeConcentration/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumeConcentration/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlow/UnitsNet.NanoFramework.VolumeFlow.nuspec b/UnitsNet.NanoFramework/GeneratedCode/VolumeFlow/UnitsNet.NanoFramework.VolumeFlow.nuspec
deleted file mode 100644
index 97a72fea68..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlow/UnitsNet.NanoFramework.VolumeFlow.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.VolumeFlow</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET VolumeFlow - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds VolumeFlow units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework volumeflow unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\VolumeFlow\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlow/VolumeFlow.nfproj b/UnitsNet.NanoFramework/GeneratedCode/VolumeFlow/VolumeFlow.nfproj
deleted file mode 100644
index 7cd2632f91..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlow/VolumeFlow.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{b22e47e1-9506-56e6-3d19-780b887d8cb3}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.VolumeFlow</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\VolumeFlow.g.cs" />
-    <Compile Include="..\Units\VolumeFlowUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlow/packages.config b/UnitsNet.NanoFramework/GeneratedCode/VolumeFlow/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlow/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlowPerArea/UnitsNet.NanoFramework.VolumeFlowPerArea.nuspec b/UnitsNet.NanoFramework/GeneratedCode/VolumeFlowPerArea/UnitsNet.NanoFramework.VolumeFlowPerArea.nuspec
deleted file mode 100644
index 49d0f95bfe..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlowPerArea/UnitsNet.NanoFramework.VolumeFlowPerArea.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.VolumeFlowPerArea</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET VolumeFlowPerArea - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds VolumeFlowPerArea units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework volumeflowperarea unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\VolumeFlowPerArea\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlowPerArea/VolumeFlowPerArea.nfproj b/UnitsNet.NanoFramework/GeneratedCode/VolumeFlowPerArea/VolumeFlowPerArea.nfproj
deleted file mode 100644
index a4e3b0f655..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlowPerArea/VolumeFlowPerArea.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{753bcc52-c451-8b29-6ae7-520b02ee6960}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.VolumeFlowPerArea</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\VolumeFlowPerArea.g.cs" />
-    <Compile Include="..\Units\VolumeFlowPerAreaUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlowPerArea/packages.config b/UnitsNet.NanoFramework/GeneratedCode/VolumeFlowPerArea/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumeFlowPerArea/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumePerLength/UnitsNet.NanoFramework.VolumePerLength.nuspec b/UnitsNet.NanoFramework/GeneratedCode/VolumePerLength/UnitsNet.NanoFramework.VolumePerLength.nuspec
deleted file mode 100644
index f43c591ff3..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumePerLength/UnitsNet.NanoFramework.VolumePerLength.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.VolumePerLength</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET VolumePerLength - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds VolumePerLength units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework volumeperlength unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\VolumePerLength\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumePerLength/VolumePerLength.nfproj b/UnitsNet.NanoFramework/GeneratedCode/VolumePerLength/VolumePerLength.nfproj
deleted file mode 100644
index 033ae1dcf0..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumePerLength/VolumePerLength.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{b66e3a3e-7945-3d40-24ef-73fa6e1b8d41}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.VolumePerLength</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\VolumePerLength.g.cs" />
-    <Compile Include="..\Units\VolumePerLengthUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumePerLength/packages.config b/UnitsNet.NanoFramework/GeneratedCode/VolumePerLength/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumePerLength/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumetricHeatCapacity/UnitsNet.NanoFramework.VolumetricHeatCapacity.nuspec b/UnitsNet.NanoFramework/GeneratedCode/VolumetricHeatCapacity/UnitsNet.NanoFramework.VolumetricHeatCapacity.nuspec
deleted file mode 100644
index 126e0e34e8..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumetricHeatCapacity/UnitsNet.NanoFramework.VolumetricHeatCapacity.nuspec
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.VolumetricHeatCapacity</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET VolumetricHeatCapacity - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds VolumetricHeatCapacity units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework volumetricheatcapacity unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\VolumetricHeatCapacity\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumetricHeatCapacity/VolumetricHeatCapacity.nfproj b/UnitsNet.NanoFramework/GeneratedCode/VolumetricHeatCapacity/VolumetricHeatCapacity.nfproj
deleted file mode 100644
index fdacea6cf9..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumetricHeatCapacity/VolumetricHeatCapacity.nfproj
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{cd2b60c1-a4b5-36f2-afa3-6cf1031f9e7f}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.VolumetricHeatCapacity</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\VolumetricHeatCapacity.g.cs" />
-    <Compile Include="..\Units\VolumetricHeatCapacityUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/VolumetricHeatCapacity/packages.config b/UnitsNet.NanoFramework/GeneratedCode/VolumetricHeatCapacity/packages.config
deleted file mode 100644
index 313a8dccdf..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/VolumetricHeatCapacity/packages.config
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/WarpingMomentOfInertia/UnitsNet.NanoFramework.WarpingMomentOfInertia.nuspec b/UnitsNet.NanoFramework/GeneratedCode/WarpingMomentOfInertia/UnitsNet.NanoFramework.WarpingMomentOfInertia.nuspec
deleted file mode 100644
index 0f84df1913..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/WarpingMomentOfInertia/UnitsNet.NanoFramework.WarpingMomentOfInertia.nuspec
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
-  <metadata>
-    <id>UnitsNet.nanoFramework.WarpingMomentOfInertia</id>
-    <version>6.0.0-pre019</version>
-    <title>Units.NET WarpingMomentOfInertia - nanoFramework</title>
-    <authors>Andreas Gullberg Larsen,nanoframework</authors>
-    <owners>UnitsNet</owners>
-    <license type="expression">MIT-0</license>
-    <projectUrl>https://github.com/angularsen/UnitsNet</projectUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Adds WarpingMomentOfInertia units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.</description>
-    <iconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</iconUrl>
-    <releaseNotes>
-    </releaseNotes>
-    <copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</copyright>
-    <language>en-US</language>
-    <tags>nanoframework warpingmomentofinertia unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</tags>
-    <dependencies>
-      <dependency id="nanoFramework.CoreLibrary" version="1.15.5" />
-      <dependency id="nanoFramework.System.Math" version="1.5.43" />
-    </dependencies>
-  </metadata>
-  <files>
-    <file src="..\..\..\Artifacts\UnitsNet.NanoFramework\WarpingMomentOfInertia\UnitsNet.*" target="lib" />
-  </files>
-</package>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/WarpingMomentOfInertia/WarpingMomentOfInertia.nfproj b/UnitsNet.NanoFramework/GeneratedCode/WarpingMomentOfInertia/WarpingMomentOfInertia.nfproj
deleted file mode 100644
index f3b390a93b..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/WarpingMomentOfInertia/WarpingMomentOfInertia.nfproj
+++ /dev/null
@@ -1,47 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <NanoFrameworkProjectSystemPath>$(MSBuildExtensionsPath)\nanoFramework\v1.0\</NanoFrameworkProjectSystemPath>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.Default.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectTypeGuids>{11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <ProjectGuid>{8433aac6-218d-9b7b-6eaa-36774e165446}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <FileAlignment>512</FileAlignment>
-    <RootNamespace>UnitsNet</RootNamespace>
-    <AssemblyName>UnitsNet.WarpingMomentOfInertia</AssemblyName>
-    <TargetFrameworkVersion>v1.0</TargetFrameworkVersion>
-    <DocumentationFile>bin\$(Configuration)\$(AssemblyName).xml</DocumentationFile>
-  </PropertyGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.props" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.props')" />
-  <ItemGroup>
-    <Compile Include="..\Quantities\WarpingMomentOfInertia.g.cs" />
-    <Compile Include="..\Units\WarpingMomentOfInertiaUnit.g.cs" />
-    <Compile Include="..\Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-    <Reference Include="System.Math, Version=1.5.43.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">
-      <HintPath>..\packages\nanoFramework.System.Math.1.5.43\lib\System.Math.dll</HintPath>
-      <Private>True</Private>
-      <SpecificVersion>True</SpecificVersion>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets" Condition="Exists('$(NanoFrameworkProjectSystemPath)NFProjectSystem.CSharp.targets')" />
-  <ProjectExtensions>
-    <ProjectCapabilities>
-      <ProjectConfigurationsDeclaredAsItems />
-    </ProjectCapabilities>
-  </ProjectExtensions>
-</Project>
diff --git a/UnitsNet.NanoFramework/GeneratedCode/WarpingMomentOfInertia/packages.config b/UnitsNet.NanoFramework/GeneratedCode/WarpingMomentOfInertia/packages.config
deleted file mode 100644
index ac11548cd6..0000000000
--- a/UnitsNet.NanoFramework/GeneratedCode/WarpingMomentOfInertia/packages.config
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="nanoFramework.CoreLibrary" version="1.15.5" targetFramework="netnanoframework10" />
-  <package id="nanoFramework.System.Math" version="1.5.43" targetFramework="netnanoframework10" />
-</packages>
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
index 5c8fb6a388..e93616d7b8 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
@@ -36,5 +36,13 @@ public void NumberToKilogramsPerSquareMeterTest() =>
         public void NumberToMilligramsPerSquareMeterTest() =>
             Assert.Equal(AreaDensity.FromMilligramsPerSquareMeter(2), 2.MilligramsPerSquareMeter);
 
+        [Fact]
+        public void NumberToPoundsPerSquareFootTest() =>
+            Assert.Equal(AreaDensity.FromPoundsPerSquareFoot(2), 2.PoundsPerSquareFoot);
+
+        [Fact]
+        public void NumberToPoundsPerThousandSquareFeetTest() =>
+            Assert.Equal(AreaDensity.FromPoundsPerThousandSquareFeet(2), 2.PoundsPerThousandSquareFeet);
+
     }
 }
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaPerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaPerLengthExtensionsTest.g.cs
new file mode 100644
index 0000000000..bedb3ca1fc
--- /dev/null
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaPerLengthExtensionsTest.g.cs
@@ -0,0 +1,52 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToAreaPerLength;
+using Xunit;
+
+namespace UnitsNet.Tests
+{
+    public class NumberToAreaPerLengthExtensionsTests
+    {
+        [Fact]
+        public void NumberToSquareCentimetersPerMeterTest() =>
+            Assert.Equal(AreaPerLength.FromSquareCentimetersPerMeter(2), 2.SquareCentimetersPerMeter);
+
+        [Fact]
+        public void NumberToSquareFeetPerFootTest() =>
+            Assert.Equal(AreaPerLength.FromSquareFeetPerFoot(2), 2.SquareFeetPerFoot);
+
+        [Fact]
+        public void NumberToSquareInchesPerFootTest() =>
+            Assert.Equal(AreaPerLength.FromSquareInchesPerFoot(2), 2.SquareInchesPerFoot);
+
+        [Fact]
+        public void NumberToSquareInchesPerInchTest() =>
+            Assert.Equal(AreaPerLength.FromSquareInchesPerInch(2), 2.SquareInchesPerInch);
+
+        [Fact]
+        public void NumberToSquareMetersPerMeterTest() =>
+            Assert.Equal(AreaPerLength.FromSquareMetersPerMeter(2), 2.SquareMetersPerMeter);
+
+        [Fact]
+        public void NumberToSquareMillimetersPerMeterTest() =>
+            Assert.Equal(AreaPerLength.FromSquareMillimetersPerMeter(2), 2.SquareMillimetersPerMeter);
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
index 7dd09f0f2b..5ae890331f 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
@@ -32,6 +32,10 @@ public void NumberToDecanewtonsTest() =>
         public void NumberToDyneTest() =>
             Assert.Equal(Force.FromDyne(2), 2.Dyne);
 
+        [Fact]
+        public void NumberToGramsForceTest() =>
+            Assert.Equal(Force.FromGramsForce(2), 2.GramsForce);
+
         [Fact]
         public void NumberToKilogramsForceTest() =>
             Assert.Equal(Force.FromKilogramsForce(2), 2.KilogramsForce);
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
index b085267732..6d2e21e133 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
@@ -48,10 +48,18 @@ public void NumberToCaloriesPerSecondSquareCentimeterTest() =>
         public void NumberToCentiwattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromCentiwattsPerSquareMeter(2), 2.CentiwattsPerSquareMeter);
 
+        [Fact]
+        public void NumberToCentiwattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromCentiwattsPerSquareMillimeter(2), 2.CentiwattsPerSquareMillimeter);
+
         [Fact]
         public void NumberToDeciwattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromDeciwattsPerSquareMeter(2), 2.DeciwattsPerSquareMeter);
 
+        [Fact]
+        public void NumberToDeciwattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromDeciwattsPerSquareMillimeter(2), 2.DeciwattsPerSquareMillimeter);
+
         [Fact]
         public void NumberToKilocaloriesPerHourSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromKilocaloriesPerHourSquareMeter(2), 2.KilocaloriesPerHourSquareMeter);
@@ -64,18 +72,34 @@ public void NumberToKilocaloriesPerSecondSquareCentimeterTest() =>
         public void NumberToKilowattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromKilowattsPerSquareMeter(2), 2.KilowattsPerSquareMeter);
 
+        [Fact]
+        public void NumberToKilowattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromKilowattsPerSquareMillimeter(2), 2.KilowattsPerSquareMillimeter);
+
         [Fact]
         public void NumberToMicrowattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromMicrowattsPerSquareMeter(2), 2.MicrowattsPerSquareMeter);
 
+        [Fact]
+        public void NumberToMicrowattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromMicrowattsPerSquareMillimeter(2), 2.MicrowattsPerSquareMillimeter);
+
         [Fact]
         public void NumberToMilliwattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromMilliwattsPerSquareMeter(2), 2.MilliwattsPerSquareMeter);
 
+        [Fact]
+        public void NumberToMilliwattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromMilliwattsPerSquareMillimeter(2), 2.MilliwattsPerSquareMillimeter);
+
         [Fact]
         public void NumberToNanowattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromNanowattsPerSquareMeter(2), 2.NanowattsPerSquareMeter);
 
+        [Fact]
+        public void NumberToNanowattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromNanowattsPerSquareMillimeter(2), 2.NanowattsPerSquareMillimeter);
+
         [Fact]
         public void NumberToPoundsForcePerFootSecondTest() =>
             Assert.Equal(HeatFlux.FromPoundsForcePerFootSecond(2), 2.PoundsForcePerFootSecond);
@@ -96,5 +120,9 @@ public void NumberToWattsPerSquareInchTest() =>
         public void NumberToWattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromWattsPerSquareMeter(2), 2.WattsPerSquareMeter);
 
+        [Fact]
+        public void NumberToWattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromWattsPerSquareMillimeter(2), 2.WattsPerSquareMillimeter);
+
     }
 }
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
index 37425e80bf..783ed71896 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
@@ -28,6 +28,10 @@ public class NumberToHeatTransferCoefficientExtensionsTests
         public void NumberToBtusPerHourSquareFootDegreeFahrenheitTest() =>
             Assert.Equal(HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(2), 2.BtusPerHourSquareFootDegreeFahrenheit);
 
+        [Fact]
+        public void NumberToBtusPerSecondSquareInchDegreeFahrenheitTest() =>
+            Assert.Equal(HeatTransferCoefficient.FromBtusPerSecondSquareInchDegreeFahrenheit(2), 2.BtusPerSecondSquareInchDegreeFahrenheit);
+
         [Fact]
         public void NumberToCaloriesPerHourSquareMeterDegreeCelsiusTest() =>
             Assert.Equal(HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(2), 2.CaloriesPerHourSquareMeterDegreeCelsius);
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
index 23859f41a6..147f04f190 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
@@ -76,5 +76,9 @@ public void NumberToNanogramsPerMoleTest() =>
         public void NumberToPoundsPerMoleTest() =>
             Assert.Equal(MolarMass.FromPoundsPerMole(2), 2.PoundsPerMole);
 
+        [Fact]
+        public void NumberToPoundsPerPoundMoleTest() =>
+            Assert.Equal(MolarMass.FromPoundsPerPoundMole(2), 2.PoundsPerPoundMole);
+
     }
 }
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
index f575799760..2a29ea471f 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
@@ -24,6 +24,14 @@ namespace UnitsNet.Tests
 {
     public class NumberToPowerDensityExtensionsTests
     {
+        [Fact]
+        public void NumberToBtusPerSecondCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromBtusPerSecondCubicFoot(2), 2.BtusPerSecondCubicFoot);
+
+        [Fact]
+        public void NumberToBtusPerSecondCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromBtusPerSecondCubicInch(2), 2.BtusPerSecondCubicInch);
+
         [Fact]
         public void NumberToDecawattsPerCubicFootTest() =>
             Assert.Equal(PowerDensity.FromDecawattsPerCubicFoot(2), 2.DecawattsPerCubicFoot);
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
index 904dc52a68..60b81b778f 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
@@ -148,6 +148,14 @@ public void NumberToMicropascalsTest() =>
         public void NumberToMillibarsTest() =>
             Assert.Equal(Pressure.FromMillibars(2), 2.Millibars);
 
+        [Fact]
+        public void NumberToMilligramsForcePerSquareFootTest() =>
+            Assert.Equal(Pressure.FromMilligramsForcePerSquareFoot(2), 2.MilligramsForcePerSquareFoot);
+
+        [Fact]
+        public void NumberToMilligramsForcePerSquareMeterTest() =>
+            Assert.Equal(Pressure.FromMilligramsForcePerSquareMeter(2), 2.MilligramsForcePerSquareMeter);
+
         [Fact]
         public void NumberToMillimetersOfMercuryTest() =>
             Assert.Equal(Pressure.FromMillimetersOfMercury(2), 2.MillimetersOfMercury);
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
index d6eb58f168..aac788a24e 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
@@ -33,8 +33,8 @@ public void NumberToCubicMetersPerKilogramTest() =>
             Assert.Equal(SpecificVolume.FromCubicMetersPerKilogram(2), 2.CubicMetersPerKilogram);
 
         [Fact]
-        public void NumberToMillicubicMetersPerKilogramTest() =>
-            Assert.Equal(SpecificVolume.FromMillicubicMetersPerKilogram(2), 2.MillicubicMetersPerKilogram);
+        public void NumberToCubicMillimetersPerKilogramTest() =>
+            Assert.Equal(SpecificVolume.FromCubicMillimetersPerKilogram(2), 2.CubicMillimetersPerKilogram);
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
index f3876ae5b0..b16d035899 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
@@ -28,6 +28,10 @@ public class NumberToThermalConductivityExtensionsTests
         public void NumberToBtusPerHourFootFahrenheitTest() =>
             Assert.Equal(ThermalConductivity.FromBtusPerHourFootFahrenheit(2), 2.BtusPerHourFootFahrenheit);
 
+        [Fact]
+        public void NumberToBtusPerSecondInchFahrenheitTest() =>
+            Assert.Equal(ThermalConductivity.FromBtusPerSecondInchFahrenheit(2), 2.BtusPerSecondInchFahrenheit);
+
         [Fact]
         public void NumberToWattsPerMeterKelvinTest() =>
             Assert.Equal(ThermalConductivity.FromWattsPerMeterKelvin(2), 2.WattsPerMeterKelvin);
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
index cf28ae5f83..5dc5d1e1c0 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
@@ -100,6 +100,14 @@ public void NumberToNewtonMetersTest() =>
         public void NumberToNewtonMillimetersTest() =>
             Assert.Equal(Torque.FromNewtonMillimeters(2), 2.NewtonMillimeters);
 
+        [Fact]
+        public void NumberToOunceForceFeetTest() =>
+            Assert.Equal(Torque.FromOunceForceFeet(2), 2.OunceForceFeet);
+
+        [Fact]
+        public void NumberToOunceForceInchesTest() =>
+            Assert.Equal(Torque.FromOunceForceInches(2), 2.OunceForceInches);
+
         [Fact]
         public void NumberToPoundalFeetTest() =>
             Assert.Equal(Torque.FromPoundalFeet(2), 2.PoundalFeet);
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
index a7560d2f66..f81e954418 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
@@ -100,14 +100,6 @@ public void NumberToDecilitersTest() =>
         public void NumberToDeciusGallonsTest() =>
             Assert.Equal(Volume.FromDeciusGallons(2), 2.DeciusGallons);
 
-        [Fact]
-        public void NumberToHectocubicFeetTest() =>
-            Assert.Equal(Volume.FromHectocubicFeet(2), 2.HectocubicFeet);
-
-        [Fact]
-        public void NumberToHectocubicMetersTest() =>
-            Assert.Equal(Volume.FromHectocubicMeters(2), 2.HectocubicMeters);
-
         [Fact]
         public void NumberToHectolitersTest() =>
             Assert.Equal(Volume.FromHectoliters(2), 2.Hectoliters);
@@ -116,6 +108,10 @@ public void NumberToHectolitersTest() =>
         public void NumberToHectousGallonsTest() =>
             Assert.Equal(Volume.FromHectousGallons(2), 2.HectousGallons);
 
+        [Fact]
+        public void NumberToHundredCubicFeetTest() =>
+            Assert.Equal(Volume.FromHundredCubicFeet(2), 2.HundredCubicFeet);
+
         [Fact]
         public void NumberToImperialBeerBarrelsTest() =>
             Assert.Equal(Volume.FromImperialBeerBarrels(2), 2.ImperialBeerBarrels);
@@ -136,14 +132,6 @@ public void NumberToImperialPintsTest() =>
         public void NumberToImperialQuartsTest() =>
             Assert.Equal(Volume.FromImperialQuarts(2), 2.ImperialQuarts);
 
-        [Fact]
-        public void NumberToKilocubicFeetTest() =>
-            Assert.Equal(Volume.FromKilocubicFeet(2), 2.KilocubicFeet);
-
-        [Fact]
-        public void NumberToKilocubicMetersTest() =>
-            Assert.Equal(Volume.FromKilocubicMeters(2), 2.KilocubicMeters);
-
         [Fact]
         public void NumberToKiloimperialGallonsTest() =>
             Assert.Equal(Volume.FromKiloimperialGallons(2), 2.KiloimperialGallons);
@@ -160,10 +148,6 @@ public void NumberToKilousGallonsTest() =>
         public void NumberToLitersTest() =>
             Assert.Equal(Volume.FromLiters(2), 2.Liters);
 
-        [Fact]
-        public void NumberToMegacubicFeetTest() =>
-            Assert.Equal(Volume.FromMegacubicFeet(2), 2.MegacubicFeet);
-
         [Fact]
         public void NumberToMegaimperialGallonsTest() =>
             Assert.Equal(Volume.FromMegaimperialGallons(2), 2.MegaimperialGallons);
@@ -196,6 +180,10 @@ public void NumberToMicrolitersTest() =>
         public void NumberToMillilitersTest() =>
             Assert.Equal(Volume.FromMilliliters(2), 2.Milliliters);
 
+        [Fact]
+        public void NumberToMillionCubicFeetTest() =>
+            Assert.Equal(Volume.FromMillionCubicFeet(2), 2.MillionCubicFeet);
+
         [Fact]
         public void NumberToNanolitersTest() =>
             Assert.Equal(Volume.FromNanoliters(2), 2.Nanoliters);
@@ -204,6 +192,14 @@ public void NumberToNanolitersTest() =>
         public void NumberToOilBarrelsTest() =>
             Assert.Equal(Volume.FromOilBarrels(2), 2.OilBarrels);
 
+        [Fact]
+        public void NumberToThousandCubicFeetTest() =>
+            Assert.Equal(Volume.FromThousandCubicFeet(2), 2.ThousandCubicFeet);
+
+        [Fact]
+        public void NumberToThousandCubicMetersTest() =>
+            Assert.Equal(Volume.FromThousandCubicMeters(2), 2.ThousandCubicMeters);
+
         [Fact]
         public void NumberToUkTablespoonsTest() =>
             Assert.Equal(Volume.FromUkTablespoons(2), 2.UkTablespoons);
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
index 9bee6763e6..93edf2bbba 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
@@ -76,6 +76,14 @@ public void NumberToCubicFeetPerMinuteTest() =>
         public void NumberToCubicFeetPerSecondTest() =>
             Assert.Equal(VolumeFlow.FromCubicFeetPerSecond(2), 2.CubicFeetPerSecond);
 
+        [Fact]
+        public void NumberToCubicInchesPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromCubicInchesPerMinute(2), 2.CubicInchesPerMinute);
+
+        [Fact]
+        public void NumberToCubicInchesPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromCubicInchesPerSecond(2), 2.CubicInchesPerSecond);
+
         [Fact]
         public void NumberToCubicMetersPerDayTest() =>
             Assert.Equal(VolumeFlow.FromCubicMetersPerDay(2), 2.CubicMetersPerDay);
@@ -92,6 +100,10 @@ public void NumberToCubicMetersPerMinuteTest() =>
         public void NumberToCubicMetersPerSecondTest() =>
             Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(2), 2.CubicMetersPerSecond);
 
+        [Fact]
+        public void NumberToCubicMillimetersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromCubicMillimetersPerMinute(2), 2.CubicMillimetersPerMinute);
+
         [Fact]
         public void NumberToCubicMillimetersPerSecondTest() =>
             Assert.Equal(VolumeFlow.FromCubicMillimetersPerSecond(2), 2.CubicMillimetersPerSecond);
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/UnitsNet.NumberExtensions.CS14.Tests.csproj b/UnitsNet.NumberExtensions.CS14.Tests/UnitsNet.NumberExtensions.CS14.Tests.csproj
index 3983936e1d..af9a2e50a9 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/UnitsNet.NumberExtensions.CS14.Tests.csproj
+++ b/UnitsNet.NumberExtensions.CS14.Tests/UnitsNet.NumberExtensions.CS14.Tests.csproj
@@ -1,7 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;net8.0;net9.0;net10.0</TargetFrameworks>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(TargetFrameworks);net48</TargetFrameworks>
     <RootNamespace>UnitsNet.NumberExtensions.Tests</RootNamespace>
     <LangVersion>preview</LangVersion>
     <Nullable>enable</Nullable>
diff --git a/UnitsNet.NumberExtensions.CS14/ConvertibleExtensions.cs b/UnitsNet.NumberExtensions.CS14/ConvertibleExtensions.cs
new file mode 100644
index 0000000000..0094b9e092
--- /dev/null
+++ b/UnitsNet.NumberExtensions.CS14/ConvertibleExtensions.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace UnitsNet;
+
+internal static class ConvertibleExtensions
+{
+    internal static QuantityValue ToQuantityValue<TNumber>(this TNumber number) where TNumber : IConvertible
+    {
+        return number.GetTypeCode() switch
+        {
+            TypeCode.SByte => number.ToSByte(null),
+            TypeCode.Byte => number.ToByte(null),
+            TypeCode.Int16 => number.ToInt16(null),
+            TypeCode.UInt16 => number.ToUInt16(null),
+            TypeCode.Int32 => number.ToInt32(null),
+            TypeCode.UInt32 => number.ToUInt32(null),
+            TypeCode.Int64 => number.ToInt64(null),
+            TypeCode.UInt64 => number.ToUInt64(null),
+            TypeCode.Single => number.ToSingle(null),
+            TypeCode.Decimal => number.ToDecimal(null),
+            TypeCode.String => QuantityValue.Parse(number.ToString(null), null),
+            _ => number.ToDouble(null)
+        };
+    }
+}
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs
index 9bbace06e6..e2396240d5 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs
@@ -42,140 +42,140 @@ public static class NumberToAbsorbedDoseOfIonizingRadiationExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromCentigrays(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromCentigrays(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Centigrays
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromCentigrays(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromCentigrays(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromCentigrays(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromCentigrays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromDecigrays(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromDecigrays(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Decigrays
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromDecigrays(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromDecigrays(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromDecigrays(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromDecigrays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromFemtograys(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromFemtograys(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Femtograys
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromFemtograys(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromFemtograys(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromFemtograys(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromFemtograys(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGigagrays(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGigagrays(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Gigagrays
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromGigagrays(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromGigagrays(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromGigagrays(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromGigagrays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGrays(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGrays(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Grays
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromGrays(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromGrays(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromGrays(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromGrays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilograys(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilograys(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Kilograys
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromKilograys(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromKilograys(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromKilograys(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromKilograys(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilorads(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilorads(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Kilorads
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromKilorads(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromKilorads(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromKilorads(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromKilorads(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegagrays(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegagrays(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Megagrays
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromMegagrays(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromMegagrays(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromMegagrays(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromMegagrays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegarads(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegarads(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Megarads
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromMegarads(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromMegarads(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromMegarads(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromMegarads(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMicrograys(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMicrograys(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Micrograys
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromMicrograys(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromMicrograys(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromMicrograys(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromMicrograys(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMilligrays(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMilligrays(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Milligrays
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromMilligrays(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromMilligrays(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromMilligrays(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromMilligrays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMillirads(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMillirads(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Millirads
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromMillirads(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromMillirads(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromMillirads(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromMillirads(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromNanograys(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromNanograys(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Nanograys
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromNanograys(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromNanograys(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromNanograys(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromNanograys(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPetagrays(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPetagrays(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Petagrays
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromPetagrays(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromPetagrays(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromPetagrays(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromPetagrays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPicograys(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPicograys(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Picograys
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromPicograys(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromPicograys(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromPicograys(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromPicograys(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromRads(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromRads(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Rads
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromRads(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromRads(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromRads(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromRads(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromTeragrays(double)" />
+            /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromTeragrays(QuantityValue)" />
             public AbsorbedDoseOfIonizingRadiation Teragrays
 #if NET7_0_OR_GREATER
-                => AbsorbedDoseOfIonizingRadiation.FromTeragrays(double.CreateChecked(value));
+                => AbsorbedDoseOfIonizingRadiation.FromTeragrays(QuantityValue.CreateChecked(value));
 #else
-                => AbsorbedDoseOfIonizingRadiation.FromTeragrays(value.ToDouble(null));
+                => AbsorbedDoseOfIonizingRadiation.FromTeragrays(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAccelerationExtensions.g.cs
index 8b649ad509..bf4028deb3 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAccelerationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAccelerationExtensions.g.cs
@@ -42,116 +42,116 @@ public static class NumberToAccelerationExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double)" />
+            /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(QuantityValue)" />
             public Acceleration CentimetersPerSecondSquared
 #if NET7_0_OR_GREATER
-                => Acceleration.FromCentimetersPerSecondSquared(double.CreateChecked(value));
+                => Acceleration.FromCentimetersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromCentimetersPerSecondSquared(value.ToDouble(null));
+                => Acceleration.FromCentimetersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double)" />
+            /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(QuantityValue)" />
             public Acceleration DecimetersPerSecondSquared
 #if NET7_0_OR_GREATER
-                => Acceleration.FromDecimetersPerSecondSquared(double.CreateChecked(value));
+                => Acceleration.FromDecimetersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromDecimetersPerSecondSquared(value.ToDouble(null));
+                => Acceleration.FromDecimetersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromFeetPerSecondSquared(double)" />
+            /// <inheritdoc cref="Acceleration.FromFeetPerSecondSquared(QuantityValue)" />
             public Acceleration FeetPerSecondSquared
 #if NET7_0_OR_GREATER
-                => Acceleration.FromFeetPerSecondSquared(double.CreateChecked(value));
+                => Acceleration.FromFeetPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromFeetPerSecondSquared(value.ToDouble(null));
+                => Acceleration.FromFeetPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromInchesPerSecondSquared(double)" />
+            /// <inheritdoc cref="Acceleration.FromInchesPerSecondSquared(QuantityValue)" />
             public Acceleration InchesPerSecondSquared
 #if NET7_0_OR_GREATER
-                => Acceleration.FromInchesPerSecondSquared(double.CreateChecked(value));
+                => Acceleration.FromInchesPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromInchesPerSecondSquared(value.ToDouble(null));
+                => Acceleration.FromInchesPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double)" />
+            /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(QuantityValue)" />
             public Acceleration KilometersPerSecondSquared
 #if NET7_0_OR_GREATER
-                => Acceleration.FromKilometersPerSecondSquared(double.CreateChecked(value));
+                => Acceleration.FromKilometersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromKilometersPerSecondSquared(value.ToDouble(null));
+                => Acceleration.FromKilometersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromKnotsPerHour(double)" />
+            /// <inheritdoc cref="Acceleration.FromKnotsPerHour(QuantityValue)" />
             public Acceleration KnotsPerHour
 #if NET7_0_OR_GREATER
-                => Acceleration.FromKnotsPerHour(double.CreateChecked(value));
+                => Acceleration.FromKnotsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromKnotsPerHour(value.ToDouble(null));
+                => Acceleration.FromKnotsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromKnotsPerMinute(double)" />
+            /// <inheritdoc cref="Acceleration.FromKnotsPerMinute(QuantityValue)" />
             public Acceleration KnotsPerMinute
 #if NET7_0_OR_GREATER
-                => Acceleration.FromKnotsPerMinute(double.CreateChecked(value));
+                => Acceleration.FromKnotsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromKnotsPerMinute(value.ToDouble(null));
+                => Acceleration.FromKnotsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromKnotsPerSecond(double)" />
+            /// <inheritdoc cref="Acceleration.FromKnotsPerSecond(QuantityValue)" />
             public Acceleration KnotsPerSecond
 #if NET7_0_OR_GREATER
-                => Acceleration.FromKnotsPerSecond(double.CreateChecked(value));
+                => Acceleration.FromKnotsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromKnotsPerSecond(value.ToDouble(null));
+                => Acceleration.FromKnotsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double)" />
+            /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(QuantityValue)" />
             public Acceleration MetersPerSecondSquared
 #if NET7_0_OR_GREATER
-                => Acceleration.FromMetersPerSecondSquared(double.CreateChecked(value));
+                => Acceleration.FromMetersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromMetersPerSecondSquared(value.ToDouble(null));
+                => Acceleration.FromMetersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double)" />
+            /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(QuantityValue)" />
             public Acceleration MicrometersPerSecondSquared
 #if NET7_0_OR_GREATER
-                => Acceleration.FromMicrometersPerSecondSquared(double.CreateChecked(value));
+                => Acceleration.FromMicrometersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromMicrometersPerSecondSquared(value.ToDouble(null));
+                => Acceleration.FromMicrometersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double)" />
+            /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(QuantityValue)" />
             public Acceleration MillimetersPerSecondSquared
 #if NET7_0_OR_GREATER
-                => Acceleration.FromMillimetersPerSecondSquared(double.CreateChecked(value));
+                => Acceleration.FromMillimetersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromMillimetersPerSecondSquared(value.ToDouble(null));
+                => Acceleration.FromMillimetersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromMillistandardGravity(double)" />
+            /// <inheritdoc cref="Acceleration.FromMillistandardGravity(QuantityValue)" />
             public Acceleration MillistandardGravity
 #if NET7_0_OR_GREATER
-                => Acceleration.FromMillistandardGravity(double.CreateChecked(value));
+                => Acceleration.FromMillistandardGravity(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromMillistandardGravity(value.ToDouble(null));
+                => Acceleration.FromMillistandardGravity(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double)" />
+            /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(QuantityValue)" />
             public Acceleration NanometersPerSecondSquared
 #if NET7_0_OR_GREATER
-                => Acceleration.FromNanometersPerSecondSquared(double.CreateChecked(value));
+                => Acceleration.FromNanometersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromNanometersPerSecondSquared(value.ToDouble(null));
+                => Acceleration.FromNanometersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Acceleration.FromStandardGravity(double)" />
+            /// <inheritdoc cref="Acceleration.FromStandardGravity(QuantityValue)" />
             public Acceleration StandardGravity
 #if NET7_0_OR_GREATER
-                => Acceleration.FromStandardGravity(double.CreateChecked(value));
+                => Acceleration.FromStandardGravity(QuantityValue.CreateChecked(value));
 #else
-                => Acceleration.FromStandardGravity(value.ToDouble(null));
+                => Acceleration.FromStandardGravity(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
index 06336e0b63..5532696978 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
@@ -42,140 +42,140 @@ public static class NumberToAmountOfSubstanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="AmountOfSubstance.FromCentimoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromCentimoles(QuantityValue)" />
             public AmountOfSubstance Centimoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromCentimoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromCentimoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromCentimoles(value.ToDouble(null));
+                => AmountOfSubstance.FromCentimoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromCentipoundMoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromCentipoundMoles(QuantityValue)" />
             public AmountOfSubstance CentipoundMoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromCentipoundMoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromCentipoundMoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromCentipoundMoles(value.ToDouble(null));
+                => AmountOfSubstance.FromCentipoundMoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromDecimoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromDecimoles(QuantityValue)" />
             public AmountOfSubstance Decimoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromDecimoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromDecimoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromDecimoles(value.ToDouble(null));
+                => AmountOfSubstance.FromDecimoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromDecipoundMoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromDecipoundMoles(QuantityValue)" />
             public AmountOfSubstance DecipoundMoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromDecipoundMoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromDecipoundMoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromDecipoundMoles(value.ToDouble(null));
+                => AmountOfSubstance.FromDecipoundMoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromFemtomoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromFemtomoles(QuantityValue)" />
             public AmountOfSubstance Femtomoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromFemtomoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromFemtomoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromFemtomoles(value.ToDouble(null));
+                => AmountOfSubstance.FromFemtomoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromKilomoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromKilomoles(QuantityValue)" />
             public AmountOfSubstance Kilomoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromKilomoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromKilomoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromKilomoles(value.ToDouble(null));
+                => AmountOfSubstance.FromKilomoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromKilopoundMoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromKilopoundMoles(QuantityValue)" />
             public AmountOfSubstance KilopoundMoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromKilopoundMoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromKilopoundMoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromKilopoundMoles(value.ToDouble(null));
+                => AmountOfSubstance.FromKilopoundMoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromMegamoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromMegamoles(QuantityValue)" />
             public AmountOfSubstance Megamoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromMegamoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromMegamoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromMegamoles(value.ToDouble(null));
+                => AmountOfSubstance.FromMegamoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromMicromoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromMicromoles(QuantityValue)" />
             public AmountOfSubstance Micromoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromMicromoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromMicromoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromMicromoles(value.ToDouble(null));
+                => AmountOfSubstance.FromMicromoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromMicropoundMoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromMicropoundMoles(QuantityValue)" />
             public AmountOfSubstance MicropoundMoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromMicropoundMoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromMicropoundMoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromMicropoundMoles(value.ToDouble(null));
+                => AmountOfSubstance.FromMicropoundMoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromMillimoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromMillimoles(QuantityValue)" />
             public AmountOfSubstance Millimoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromMillimoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromMillimoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromMillimoles(value.ToDouble(null));
+                => AmountOfSubstance.FromMillimoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromMillipoundMoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromMillipoundMoles(QuantityValue)" />
             public AmountOfSubstance MillipoundMoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromMillipoundMoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromMillipoundMoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromMillipoundMoles(value.ToDouble(null));
+                => AmountOfSubstance.FromMillipoundMoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromMoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromMoles(QuantityValue)" />
             public AmountOfSubstance Moles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromMoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromMoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromMoles(value.ToDouble(null));
+                => AmountOfSubstance.FromMoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromNanomoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromNanomoles(QuantityValue)" />
             public AmountOfSubstance Nanomoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromNanomoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromNanomoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromNanomoles(value.ToDouble(null));
+                => AmountOfSubstance.FromNanomoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromNanopoundMoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromNanopoundMoles(QuantityValue)" />
             public AmountOfSubstance NanopoundMoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromNanopoundMoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromNanopoundMoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromNanopoundMoles(value.ToDouble(null));
+                => AmountOfSubstance.FromNanopoundMoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromPicomoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromPicomoles(QuantityValue)" />
             public AmountOfSubstance Picomoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromPicomoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromPicomoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromPicomoles(value.ToDouble(null));
+                => AmountOfSubstance.FromPicomoles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmountOfSubstance.FromPoundMoles(double)" />
+            /// <inheritdoc cref="AmountOfSubstance.FromPoundMoles(QuantityValue)" />
             public AmountOfSubstance PoundMoles
 #if NET7_0_OR_GREATER
-                => AmountOfSubstance.FromPoundMoles(double.CreateChecked(value));
+                => AmountOfSubstance.FromPoundMoles(QuantityValue.CreateChecked(value));
 #else
-                => AmountOfSubstance.FromPoundMoles(value.ToDouble(null));
+                => AmountOfSubstance.FromPoundMoles(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
index 7aca317d77..7bdfb8f7a6 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
@@ -42,36 +42,36 @@ public static class NumberToAmplitudeRatioExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="AmplitudeRatio.FromDecibelMicrovolts(double)" />
+            /// <inheritdoc cref="AmplitudeRatio.FromDecibelMicrovolts(QuantityValue)" />
             public AmplitudeRatio DecibelMicrovolts
 #if NET7_0_OR_GREATER
-                => AmplitudeRatio.FromDecibelMicrovolts(double.CreateChecked(value));
+                => AmplitudeRatio.FromDecibelMicrovolts(QuantityValue.CreateChecked(value));
 #else
-                => AmplitudeRatio.FromDecibelMicrovolts(value.ToDouble(null));
+                => AmplitudeRatio.FromDecibelMicrovolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmplitudeRatio.FromDecibelMillivolts(double)" />
+            /// <inheritdoc cref="AmplitudeRatio.FromDecibelMillivolts(QuantityValue)" />
             public AmplitudeRatio DecibelMillivolts
 #if NET7_0_OR_GREATER
-                => AmplitudeRatio.FromDecibelMillivolts(double.CreateChecked(value));
+                => AmplitudeRatio.FromDecibelMillivolts(QuantityValue.CreateChecked(value));
 #else
-                => AmplitudeRatio.FromDecibelMillivolts(value.ToDouble(null));
+                => AmplitudeRatio.FromDecibelMillivolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmplitudeRatio.FromDecibelsUnloaded(double)" />
+            /// <inheritdoc cref="AmplitudeRatio.FromDecibelsUnloaded(QuantityValue)" />
             public AmplitudeRatio DecibelsUnloaded
 #if NET7_0_OR_GREATER
-                => AmplitudeRatio.FromDecibelsUnloaded(double.CreateChecked(value));
+                => AmplitudeRatio.FromDecibelsUnloaded(QuantityValue.CreateChecked(value));
 #else
-                => AmplitudeRatio.FromDecibelsUnloaded(value.ToDouble(null));
+                => AmplitudeRatio.FromDecibelsUnloaded(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AmplitudeRatio.FromDecibelVolts(double)" />
+            /// <inheritdoc cref="AmplitudeRatio.FromDecibelVolts(QuantityValue)" />
             public AmplitudeRatio DecibelVolts
 #if NET7_0_OR_GREATER
-                => AmplitudeRatio.FromDecibelVolts(double.CreateChecked(value));
+                => AmplitudeRatio.FromDecibelVolts(QuantityValue.CreateChecked(value));
 #else
-                => AmplitudeRatio.FromDecibelVolts(value.ToDouble(null));
+                => AmplitudeRatio.FromDecibelVolts(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAngleExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAngleExtensions.g.cs
index 5399e3ba9f..e35aa15e90 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAngleExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAngleExtensions.g.cs
@@ -42,124 +42,124 @@ public static class NumberToAngleExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Angle.FromArcminutes(double)" />
+            /// <inheritdoc cref="Angle.FromArcminutes(QuantityValue)" />
             public Angle Arcminutes
 #if NET7_0_OR_GREATER
-                => Angle.FromArcminutes(double.CreateChecked(value));
+                => Angle.FromArcminutes(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromArcminutes(value.ToDouble(null));
+                => Angle.FromArcminutes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromArcseconds(double)" />
+            /// <inheritdoc cref="Angle.FromArcseconds(QuantityValue)" />
             public Angle Arcseconds
 #if NET7_0_OR_GREATER
-                => Angle.FromArcseconds(double.CreateChecked(value));
+                => Angle.FromArcseconds(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromArcseconds(value.ToDouble(null));
+                => Angle.FromArcseconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromCentiradians(double)" />
+            /// <inheritdoc cref="Angle.FromCentiradians(QuantityValue)" />
             public Angle Centiradians
 #if NET7_0_OR_GREATER
-                => Angle.FromCentiradians(double.CreateChecked(value));
+                => Angle.FromCentiradians(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromCentiradians(value.ToDouble(null));
+                => Angle.FromCentiradians(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromDeciradians(double)" />
+            /// <inheritdoc cref="Angle.FromDeciradians(QuantityValue)" />
             public Angle Deciradians
 #if NET7_0_OR_GREATER
-                => Angle.FromDeciradians(double.CreateChecked(value));
+                => Angle.FromDeciradians(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromDeciradians(value.ToDouble(null));
+                => Angle.FromDeciradians(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromDegrees(double)" />
+            /// <inheritdoc cref="Angle.FromDegrees(QuantityValue)" />
             public Angle Degrees
 #if NET7_0_OR_GREATER
-                => Angle.FromDegrees(double.CreateChecked(value));
+                => Angle.FromDegrees(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromDegrees(value.ToDouble(null));
+                => Angle.FromDegrees(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromGradians(double)" />
+            /// <inheritdoc cref="Angle.FromGradians(QuantityValue)" />
             public Angle Gradians
 #if NET7_0_OR_GREATER
-                => Angle.FromGradians(double.CreateChecked(value));
+                => Angle.FromGradians(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromGradians(value.ToDouble(null));
+                => Angle.FromGradians(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromMicrodegrees(double)" />
+            /// <inheritdoc cref="Angle.FromMicrodegrees(QuantityValue)" />
             public Angle Microdegrees
 #if NET7_0_OR_GREATER
-                => Angle.FromMicrodegrees(double.CreateChecked(value));
+                => Angle.FromMicrodegrees(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromMicrodegrees(value.ToDouble(null));
+                => Angle.FromMicrodegrees(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromMicroradians(double)" />
+            /// <inheritdoc cref="Angle.FromMicroradians(QuantityValue)" />
             public Angle Microradians
 #if NET7_0_OR_GREATER
-                => Angle.FromMicroradians(double.CreateChecked(value));
+                => Angle.FromMicroradians(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromMicroradians(value.ToDouble(null));
+                => Angle.FromMicroradians(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromMillidegrees(double)" />
+            /// <inheritdoc cref="Angle.FromMillidegrees(QuantityValue)" />
             public Angle Millidegrees
 #if NET7_0_OR_GREATER
-                => Angle.FromMillidegrees(double.CreateChecked(value));
+                => Angle.FromMillidegrees(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromMillidegrees(value.ToDouble(null));
+                => Angle.FromMillidegrees(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromMilliradians(double)" />
+            /// <inheritdoc cref="Angle.FromMilliradians(QuantityValue)" />
             public Angle Milliradians
 #if NET7_0_OR_GREATER
-                => Angle.FromMilliradians(double.CreateChecked(value));
+                => Angle.FromMilliradians(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromMilliradians(value.ToDouble(null));
+                => Angle.FromMilliradians(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromNanodegrees(double)" />
+            /// <inheritdoc cref="Angle.FromNanodegrees(QuantityValue)" />
             public Angle Nanodegrees
 #if NET7_0_OR_GREATER
-                => Angle.FromNanodegrees(double.CreateChecked(value));
+                => Angle.FromNanodegrees(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromNanodegrees(value.ToDouble(null));
+                => Angle.FromNanodegrees(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromNanoradians(double)" />
+            /// <inheritdoc cref="Angle.FromNanoradians(QuantityValue)" />
             public Angle Nanoradians
 #if NET7_0_OR_GREATER
-                => Angle.FromNanoradians(double.CreateChecked(value));
+                => Angle.FromNanoradians(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromNanoradians(value.ToDouble(null));
+                => Angle.FromNanoradians(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromNatoMils(double)" />
+            /// <inheritdoc cref="Angle.FromNatoMils(QuantityValue)" />
             public Angle NatoMils
 #if NET7_0_OR_GREATER
-                => Angle.FromNatoMils(double.CreateChecked(value));
+                => Angle.FromNatoMils(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromNatoMils(value.ToDouble(null));
+                => Angle.FromNatoMils(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromRadians(double)" />
+            /// <inheritdoc cref="Angle.FromRadians(QuantityValue)" />
             public Angle Radians
 #if NET7_0_OR_GREATER
-                => Angle.FromRadians(double.CreateChecked(value));
+                => Angle.FromRadians(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromRadians(value.ToDouble(null));
+                => Angle.FromRadians(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Angle.FromRevolutions(double)" />
+            /// <inheritdoc cref="Angle.FromRevolutions(QuantityValue)" />
             public Angle Revolutions
 #if NET7_0_OR_GREATER
-                => Angle.FromRevolutions(double.CreateChecked(value));
+                => Angle.FromRevolutions(QuantityValue.CreateChecked(value));
 #else
-                => Angle.FromRevolutions(value.ToDouble(null));
+                => Angle.FromRevolutions(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaDensityExtensions.g.cs
index 76d03f1fc8..fbc8ed40d2 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaDensityExtensions.g.cs
@@ -42,28 +42,44 @@ public static class NumberToAreaDensityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="AreaDensity.FromGramsPerSquareMeter(double)" />
+            /// <inheritdoc cref="AreaDensity.FromGramsPerSquareMeter(QuantityValue)" />
             public AreaDensity GramsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => AreaDensity.FromGramsPerSquareMeter(double.CreateChecked(value));
+                => AreaDensity.FromGramsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => AreaDensity.FromGramsPerSquareMeter(value.ToDouble(null));
+                => AreaDensity.FromGramsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AreaDensity.FromKilogramsPerSquareMeter(double)" />
+            /// <inheritdoc cref="AreaDensity.FromKilogramsPerSquareMeter(QuantityValue)" />
             public AreaDensity KilogramsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => AreaDensity.FromKilogramsPerSquareMeter(double.CreateChecked(value));
+                => AreaDensity.FromKilogramsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => AreaDensity.FromKilogramsPerSquareMeter(value.ToDouble(null));
+                => AreaDensity.FromKilogramsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AreaDensity.FromMilligramsPerSquareMeter(double)" />
+            /// <inheritdoc cref="AreaDensity.FromMilligramsPerSquareMeter(QuantityValue)" />
             public AreaDensity MilligramsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => AreaDensity.FromMilligramsPerSquareMeter(double.CreateChecked(value));
+                => AreaDensity.FromMilligramsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => AreaDensity.FromMilligramsPerSquareMeter(value.ToDouble(null));
+                => AreaDensity.FromMilligramsPerSquareMeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="AreaDensity.FromPoundsPerSquareFoot(QuantityValue)" />
+            public AreaDensity PoundsPerSquareFoot
+#if NET7_0_OR_GREATER
+                => AreaDensity.FromPoundsPerSquareFoot(QuantityValue.CreateChecked(value));
+#else
+                => AreaDensity.FromPoundsPerSquareFoot(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="AreaDensity.FromPoundsPerThousandSquareFeet(QuantityValue)" />
+            public AreaDensity PoundsPerThousandSquareFeet
+#if NET7_0_OR_GREATER
+                => AreaDensity.FromPoundsPerThousandSquareFeet(QuantityValue.CreateChecked(value));
+#else
+                => AreaDensity.FromPoundsPerThousandSquareFeet(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaExtensions.g.cs
index 89c652417e..6c73585d8e 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaExtensions.g.cs
@@ -42,116 +42,116 @@ public static class NumberToAreaExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Area.FromAcres(double)" />
+            /// <inheritdoc cref="Area.FromAcres(QuantityValue)" />
             public Area Acres
 #if NET7_0_OR_GREATER
-                => Area.FromAcres(double.CreateChecked(value));
+                => Area.FromAcres(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromAcres(value.ToDouble(null));
+                => Area.FromAcres(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromHectares(double)" />
+            /// <inheritdoc cref="Area.FromHectares(QuantityValue)" />
             public Area Hectares
 #if NET7_0_OR_GREATER
-                => Area.FromHectares(double.CreateChecked(value));
+                => Area.FromHectares(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromHectares(value.ToDouble(null));
+                => Area.FromHectares(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareCentimeters(double)" />
+            /// <inheritdoc cref="Area.FromSquareCentimeters(QuantityValue)" />
             public Area SquareCentimeters
 #if NET7_0_OR_GREATER
-                => Area.FromSquareCentimeters(double.CreateChecked(value));
+                => Area.FromSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareCentimeters(value.ToDouble(null));
+                => Area.FromSquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareDecimeters(double)" />
+            /// <inheritdoc cref="Area.FromSquareDecimeters(QuantityValue)" />
             public Area SquareDecimeters
 #if NET7_0_OR_GREATER
-                => Area.FromSquareDecimeters(double.CreateChecked(value));
+                => Area.FromSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareDecimeters(value.ToDouble(null));
+                => Area.FromSquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareFeet(double)" />
+            /// <inheritdoc cref="Area.FromSquareFeet(QuantityValue)" />
             public Area SquareFeet
 #if NET7_0_OR_GREATER
-                => Area.FromSquareFeet(double.CreateChecked(value));
+                => Area.FromSquareFeet(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareFeet(value.ToDouble(null));
+                => Area.FromSquareFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareInches(double)" />
+            /// <inheritdoc cref="Area.FromSquareInches(QuantityValue)" />
             public Area SquareInches
 #if NET7_0_OR_GREATER
-                => Area.FromSquareInches(double.CreateChecked(value));
+                => Area.FromSquareInches(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareInches(value.ToDouble(null));
+                => Area.FromSquareInches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareKilometers(double)" />
+            /// <inheritdoc cref="Area.FromSquareKilometers(QuantityValue)" />
             public Area SquareKilometers
 #if NET7_0_OR_GREATER
-                => Area.FromSquareKilometers(double.CreateChecked(value));
+                => Area.FromSquareKilometers(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareKilometers(value.ToDouble(null));
+                => Area.FromSquareKilometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareMeters(double)" />
+            /// <inheritdoc cref="Area.FromSquareMeters(QuantityValue)" />
             public Area SquareMeters
 #if NET7_0_OR_GREATER
-                => Area.FromSquareMeters(double.CreateChecked(value));
+                => Area.FromSquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareMeters(value.ToDouble(null));
+                => Area.FromSquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareMicrometers(double)" />
+            /// <inheritdoc cref="Area.FromSquareMicrometers(QuantityValue)" />
             public Area SquareMicrometers
 #if NET7_0_OR_GREATER
-                => Area.FromSquareMicrometers(double.CreateChecked(value));
+                => Area.FromSquareMicrometers(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareMicrometers(value.ToDouble(null));
+                => Area.FromSquareMicrometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareMiles(double)" />
+            /// <inheritdoc cref="Area.FromSquareMiles(QuantityValue)" />
             public Area SquareMiles
 #if NET7_0_OR_GREATER
-                => Area.FromSquareMiles(double.CreateChecked(value));
+                => Area.FromSquareMiles(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareMiles(value.ToDouble(null));
+                => Area.FromSquareMiles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareMillimeters(double)" />
+            /// <inheritdoc cref="Area.FromSquareMillimeters(QuantityValue)" />
             public Area SquareMillimeters
 #if NET7_0_OR_GREATER
-                => Area.FromSquareMillimeters(double.CreateChecked(value));
+                => Area.FromSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareMillimeters(value.ToDouble(null));
+                => Area.FromSquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareNauticalMiles(double)" />
+            /// <inheritdoc cref="Area.FromSquareNauticalMiles(QuantityValue)" />
             public Area SquareNauticalMiles
 #if NET7_0_OR_GREATER
-                => Area.FromSquareNauticalMiles(double.CreateChecked(value));
+                => Area.FromSquareNauticalMiles(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareNauticalMiles(value.ToDouble(null));
+                => Area.FromSquareNauticalMiles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromSquareYards(double)" />
+            /// <inheritdoc cref="Area.FromSquareYards(QuantityValue)" />
             public Area SquareYards
 #if NET7_0_OR_GREATER
-                => Area.FromSquareYards(double.CreateChecked(value));
+                => Area.FromSquareYards(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromSquareYards(value.ToDouble(null));
+                => Area.FromSquareYards(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Area.FromUsSurveySquareFeet(double)" />
+            /// <inheritdoc cref="Area.FromUsSurveySquareFeet(QuantityValue)" />
             public Area UsSurveySquareFeet
 #if NET7_0_OR_GREATER
-                => Area.FromUsSurveySquareFeet(double.CreateChecked(value));
+                => Area.FromUsSurveySquareFeet(QuantityValue.CreateChecked(value));
 #else
-                => Area.FromUsSurveySquareFeet(value.ToDouble(null));
+                => Area.FromUsSurveySquareFeet(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
index 02cdb9014e..3d11296fc4 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
@@ -42,52 +42,52 @@ public static class NumberToAreaMomentOfInertiaExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="AreaMomentOfInertia.FromCentimetersToTheFourth(double)" />
+            /// <inheritdoc cref="AreaMomentOfInertia.FromCentimetersToTheFourth(QuantityValue)" />
             public AreaMomentOfInertia CentimetersToTheFourth
 #if NET7_0_OR_GREATER
-                => AreaMomentOfInertia.FromCentimetersToTheFourth(double.CreateChecked(value));
+                => AreaMomentOfInertia.FromCentimetersToTheFourth(QuantityValue.CreateChecked(value));
 #else
-                => AreaMomentOfInertia.FromCentimetersToTheFourth(value.ToDouble(null));
+                => AreaMomentOfInertia.FromCentimetersToTheFourth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AreaMomentOfInertia.FromDecimetersToTheFourth(double)" />
+            /// <inheritdoc cref="AreaMomentOfInertia.FromDecimetersToTheFourth(QuantityValue)" />
             public AreaMomentOfInertia DecimetersToTheFourth
 #if NET7_0_OR_GREATER
-                => AreaMomentOfInertia.FromDecimetersToTheFourth(double.CreateChecked(value));
+                => AreaMomentOfInertia.FromDecimetersToTheFourth(QuantityValue.CreateChecked(value));
 #else
-                => AreaMomentOfInertia.FromDecimetersToTheFourth(value.ToDouble(null));
+                => AreaMomentOfInertia.FromDecimetersToTheFourth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AreaMomentOfInertia.FromFeetToTheFourth(double)" />
+            /// <inheritdoc cref="AreaMomentOfInertia.FromFeetToTheFourth(QuantityValue)" />
             public AreaMomentOfInertia FeetToTheFourth
 #if NET7_0_OR_GREATER
-                => AreaMomentOfInertia.FromFeetToTheFourth(double.CreateChecked(value));
+                => AreaMomentOfInertia.FromFeetToTheFourth(QuantityValue.CreateChecked(value));
 #else
-                => AreaMomentOfInertia.FromFeetToTheFourth(value.ToDouble(null));
+                => AreaMomentOfInertia.FromFeetToTheFourth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AreaMomentOfInertia.FromInchesToTheFourth(double)" />
+            /// <inheritdoc cref="AreaMomentOfInertia.FromInchesToTheFourth(QuantityValue)" />
             public AreaMomentOfInertia InchesToTheFourth
 #if NET7_0_OR_GREATER
-                => AreaMomentOfInertia.FromInchesToTheFourth(double.CreateChecked(value));
+                => AreaMomentOfInertia.FromInchesToTheFourth(QuantityValue.CreateChecked(value));
 #else
-                => AreaMomentOfInertia.FromInchesToTheFourth(value.ToDouble(null));
+                => AreaMomentOfInertia.FromInchesToTheFourth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AreaMomentOfInertia.FromMetersToTheFourth(double)" />
+            /// <inheritdoc cref="AreaMomentOfInertia.FromMetersToTheFourth(QuantityValue)" />
             public AreaMomentOfInertia MetersToTheFourth
 #if NET7_0_OR_GREATER
-                => AreaMomentOfInertia.FromMetersToTheFourth(double.CreateChecked(value));
+                => AreaMomentOfInertia.FromMetersToTheFourth(QuantityValue.CreateChecked(value));
 #else
-                => AreaMomentOfInertia.FromMetersToTheFourth(value.ToDouble(null));
+                => AreaMomentOfInertia.FromMetersToTheFourth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="AreaMomentOfInertia.FromMillimetersToTheFourth(double)" />
+            /// <inheritdoc cref="AreaMomentOfInertia.FromMillimetersToTheFourth(QuantityValue)" />
             public AreaMomentOfInertia MillimetersToTheFourth
 #if NET7_0_OR_GREATER
-                => AreaMomentOfInertia.FromMillimetersToTheFourth(double.CreateChecked(value));
+                => AreaMomentOfInertia.FromMillimetersToTheFourth(QuantityValue.CreateChecked(value));
 #else
-                => AreaMomentOfInertia.FromMillimetersToTheFourth(value.ToDouble(null));
+                => AreaMomentOfInertia.FromMillimetersToTheFourth(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaPerLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaPerLengthExtensions.g.cs
new file mode 100644
index 0000000000..986eda5446
--- /dev/null
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaPerLengthExtensions.g.cs
@@ -0,0 +1,95 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+
+#if NET7_0_OR_GREATER
+using System.Numerics;
+#endif
+
+#nullable enable
+
+namespace UnitsNet.NumberExtensions.NumberToAreaPerLength
+{
+    /// <summary>
+    /// A number to AreaPerLength Extensions
+    /// </summary>
+    public static class NumberToAreaPerLengthExtensions
+    {
+#pragma warning disable CS1591
+        extension<T>(T value)
+#pragma warning restore CS1591
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+#else
+            , IConvertible
+#endif
+        {
+            /// <inheritdoc cref="AreaPerLength.FromSquareCentimetersPerMeter(QuantityValue)" />
+            public AreaPerLength SquareCentimetersPerMeter
+#if NET7_0_OR_GREATER
+                => AreaPerLength.FromSquareCentimetersPerMeter(QuantityValue.CreateChecked(value));
+#else
+                => AreaPerLength.FromSquareCentimetersPerMeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="AreaPerLength.FromSquareFeetPerFoot(QuantityValue)" />
+            public AreaPerLength SquareFeetPerFoot
+#if NET7_0_OR_GREATER
+                => AreaPerLength.FromSquareFeetPerFoot(QuantityValue.CreateChecked(value));
+#else
+                => AreaPerLength.FromSquareFeetPerFoot(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="AreaPerLength.FromSquareInchesPerFoot(QuantityValue)" />
+            public AreaPerLength SquareInchesPerFoot
+#if NET7_0_OR_GREATER
+                => AreaPerLength.FromSquareInchesPerFoot(QuantityValue.CreateChecked(value));
+#else
+                => AreaPerLength.FromSquareInchesPerFoot(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="AreaPerLength.FromSquareInchesPerInch(QuantityValue)" />
+            public AreaPerLength SquareInchesPerInch
+#if NET7_0_OR_GREATER
+                => AreaPerLength.FromSquareInchesPerInch(QuantityValue.CreateChecked(value));
+#else
+                => AreaPerLength.FromSquareInchesPerInch(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="AreaPerLength.FromSquareMetersPerMeter(QuantityValue)" />
+            public AreaPerLength SquareMetersPerMeter
+#if NET7_0_OR_GREATER
+                => AreaPerLength.FromSquareMetersPerMeter(QuantityValue.CreateChecked(value));
+#else
+                => AreaPerLength.FromSquareMetersPerMeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="AreaPerLength.FromSquareMillimetersPerMeter(QuantityValue)" />
+            public AreaPerLength SquareMillimetersPerMeter
+#if NET7_0_OR_GREATER
+                => AreaPerLength.FromSquareMillimetersPerMeter(QuantityValue.CreateChecked(value));
+#else
+                => AreaPerLength.FromSquareMillimetersPerMeter(value.ToQuantityValue());
+#endif
+
+        }
+    }
+}
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBitRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBitRateExtensions.g.cs
index 1b21581427..b19d30e5f8 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBitRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBitRateExtensions.g.cs
@@ -42,316 +42,316 @@ public static class NumberToBitRateExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="BitRate.FromBitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromBitsPerSecond(QuantityValue)" />
             public BitRate BitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromBitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromBitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromBitsPerSecond(value.ToDouble(null));
+                => BitRate.FromBitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromBytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromBytesPerSecond(QuantityValue)" />
             public BitRate BytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromBytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromBytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromBytesPerSecond(value.ToDouble(null));
+                => BitRate.FromBytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromExabitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromExabitsPerSecond(QuantityValue)" />
             public BitRate ExabitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromExabitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromExabitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromExabitsPerSecond(value.ToDouble(null));
+                => BitRate.FromExabitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromExabytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromExabytesPerSecond(QuantityValue)" />
             public BitRate ExabytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromExabytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromExabytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromExabytesPerSecond(value.ToDouble(null));
+                => BitRate.FromExabytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromExaoctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromExaoctetsPerSecond(QuantityValue)" />
             public BitRate ExaoctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromExaoctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromExaoctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromExaoctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromExaoctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromExbibitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromExbibitsPerSecond(QuantityValue)" />
             public BitRate ExbibitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromExbibitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromExbibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromExbibitsPerSecond(value.ToDouble(null));
+                => BitRate.FromExbibitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromExbibytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromExbibytesPerSecond(QuantityValue)" />
             public BitRate ExbibytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromExbibytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromExbibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromExbibytesPerSecond(value.ToDouble(null));
+                => BitRate.FromExbibytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromExbioctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromExbioctetsPerSecond(QuantityValue)" />
             public BitRate ExbioctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromExbioctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromExbioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromExbioctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromExbioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromGibibitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromGibibitsPerSecond(QuantityValue)" />
             public BitRate GibibitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromGibibitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromGibibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromGibibitsPerSecond(value.ToDouble(null));
+                => BitRate.FromGibibitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromGibibytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromGibibytesPerSecond(QuantityValue)" />
             public BitRate GibibytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromGibibytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromGibibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromGibibytesPerSecond(value.ToDouble(null));
+                => BitRate.FromGibibytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromGibioctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromGibioctetsPerSecond(QuantityValue)" />
             public BitRate GibioctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromGibioctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromGibioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromGibioctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromGibioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromGigabitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromGigabitsPerSecond(QuantityValue)" />
             public BitRate GigabitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromGigabitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromGigabitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromGigabitsPerSecond(value.ToDouble(null));
+                => BitRate.FromGigabitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromGigabytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromGigabytesPerSecond(QuantityValue)" />
             public BitRate GigabytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromGigabytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromGigabytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromGigabytesPerSecond(value.ToDouble(null));
+                => BitRate.FromGigabytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromGigaoctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromGigaoctetsPerSecond(QuantityValue)" />
             public BitRate GigaoctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromGigaoctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromGigaoctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromGigaoctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromGigaoctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromKibibitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromKibibitsPerSecond(QuantityValue)" />
             public BitRate KibibitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromKibibitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromKibibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromKibibitsPerSecond(value.ToDouble(null));
+                => BitRate.FromKibibitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromKibibytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromKibibytesPerSecond(QuantityValue)" />
             public BitRate KibibytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromKibibytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromKibibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromKibibytesPerSecond(value.ToDouble(null));
+                => BitRate.FromKibibytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromKibioctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromKibioctetsPerSecond(QuantityValue)" />
             public BitRate KibioctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromKibioctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromKibioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromKibioctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromKibioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromKilobitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromKilobitsPerSecond(QuantityValue)" />
             public BitRate KilobitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromKilobitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromKilobitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromKilobitsPerSecond(value.ToDouble(null));
+                => BitRate.FromKilobitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromKilobytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromKilobytesPerSecond(QuantityValue)" />
             public BitRate KilobytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromKilobytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromKilobytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromKilobytesPerSecond(value.ToDouble(null));
+                => BitRate.FromKilobytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromKilooctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromKilooctetsPerSecond(QuantityValue)" />
             public BitRate KilooctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromKilooctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromKilooctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromKilooctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromKilooctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromMebibitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromMebibitsPerSecond(QuantityValue)" />
             public BitRate MebibitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromMebibitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromMebibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromMebibitsPerSecond(value.ToDouble(null));
+                => BitRate.FromMebibitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromMebibytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromMebibytesPerSecond(QuantityValue)" />
             public BitRate MebibytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromMebibytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromMebibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromMebibytesPerSecond(value.ToDouble(null));
+                => BitRate.FromMebibytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromMebioctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromMebioctetsPerSecond(QuantityValue)" />
             public BitRate MebioctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromMebioctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromMebioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromMebioctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromMebioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromMegabitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromMegabitsPerSecond(QuantityValue)" />
             public BitRate MegabitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromMegabitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromMegabitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromMegabitsPerSecond(value.ToDouble(null));
+                => BitRate.FromMegabitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromMegabytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromMegabytesPerSecond(QuantityValue)" />
             public BitRate MegabytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromMegabytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromMegabytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromMegabytesPerSecond(value.ToDouble(null));
+                => BitRate.FromMegabytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromMegaoctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromMegaoctetsPerSecond(QuantityValue)" />
             public BitRate MegaoctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromMegaoctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromMegaoctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromMegaoctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromMegaoctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromOctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromOctetsPerSecond(QuantityValue)" />
             public BitRate OctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromOctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromOctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromOctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromOctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromPebibitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromPebibitsPerSecond(QuantityValue)" />
             public BitRate PebibitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromPebibitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromPebibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromPebibitsPerSecond(value.ToDouble(null));
+                => BitRate.FromPebibitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromPebibytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromPebibytesPerSecond(QuantityValue)" />
             public BitRate PebibytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromPebibytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromPebibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromPebibytesPerSecond(value.ToDouble(null));
+                => BitRate.FromPebibytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromPebioctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromPebioctetsPerSecond(QuantityValue)" />
             public BitRate PebioctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromPebioctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromPebioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromPebioctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromPebioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromPetabitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromPetabitsPerSecond(QuantityValue)" />
             public BitRate PetabitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromPetabitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromPetabitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromPetabitsPerSecond(value.ToDouble(null));
+                => BitRate.FromPetabitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromPetabytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromPetabytesPerSecond(QuantityValue)" />
             public BitRate PetabytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromPetabytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromPetabytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromPetabytesPerSecond(value.ToDouble(null));
+                => BitRate.FromPetabytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromPetaoctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromPetaoctetsPerSecond(QuantityValue)" />
             public BitRate PetaoctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromPetaoctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromPetaoctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromPetaoctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromPetaoctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromTebibitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromTebibitsPerSecond(QuantityValue)" />
             public BitRate TebibitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromTebibitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromTebibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromTebibitsPerSecond(value.ToDouble(null));
+                => BitRate.FromTebibitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromTebibytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromTebibytesPerSecond(QuantityValue)" />
             public BitRate TebibytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromTebibytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromTebibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromTebibytesPerSecond(value.ToDouble(null));
+                => BitRate.FromTebibytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromTebioctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromTebioctetsPerSecond(QuantityValue)" />
             public BitRate TebioctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromTebioctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromTebioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromTebioctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromTebioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromTerabitsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromTerabitsPerSecond(QuantityValue)" />
             public BitRate TerabitsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromTerabitsPerSecond(double.CreateChecked(value));
+                => BitRate.FromTerabitsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromTerabitsPerSecond(value.ToDouble(null));
+                => BitRate.FromTerabitsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromTerabytesPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromTerabytesPerSecond(QuantityValue)" />
             public BitRate TerabytesPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromTerabytesPerSecond(double.CreateChecked(value));
+                => BitRate.FromTerabytesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromTerabytesPerSecond(value.ToDouble(null));
+                => BitRate.FromTerabytesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BitRate.FromTeraoctetsPerSecond(double)" />
+            /// <inheritdoc cref="BitRate.FromTeraoctetsPerSecond(QuantityValue)" />
             public BitRate TeraoctetsPerSecond
 #if NET7_0_OR_GREATER
-                => BitRate.FromTeraoctetsPerSecond(double.CreateChecked(value));
+                => BitRate.FromTeraoctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => BitRate.FromTeraoctetsPerSecond(value.ToDouble(null));
+                => BitRate.FromTeraoctetsPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
index f50bac3761..33ecb8108b 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
@@ -42,28 +42,28 @@ public static class NumberToBrakeSpecificFuelConsumptionExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(double)" />
+            /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(QuantityValue)" />
             public BrakeSpecificFuelConsumption GramsPerKiloWattHour
 #if NET7_0_OR_GREATER
-                => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(double.CreateChecked(value));
+                => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(QuantityValue.CreateChecked(value));
 #else
-                => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(value.ToDouble(null));
+                => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromKilogramsPerJoule(double)" />
+            /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromKilogramsPerJoule(QuantityValue)" />
             public BrakeSpecificFuelConsumption KilogramsPerJoule
 #if NET7_0_OR_GREATER
-                => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(double.CreateChecked(value));
+                => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(QuantityValue.CreateChecked(value));
 #else
-                => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(value.ToDouble(null));
+                => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(double)" />
+            /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(QuantityValue)" />
             public BrakeSpecificFuelConsumption PoundsPerMechanicalHorsepowerHour
 #if NET7_0_OR_GREATER
-                => BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(double.CreateChecked(value));
+                => BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(QuantityValue.CreateChecked(value));
 #else
-                => BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(value.ToDouble(null));
+                => BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
index e274125c58..179202e756 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
@@ -42,52 +42,52 @@ public static class NumberToCoefficientOfThermalExpansionExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeCelsius(double)" />
+            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeCelsius(QuantityValue)" />
             public CoefficientOfThermalExpansion PerDegreeCelsius
 #if NET7_0_OR_GREATER
-                => CoefficientOfThermalExpansion.FromPerDegreeCelsius(double.CreateChecked(value));
+                => CoefficientOfThermalExpansion.FromPerDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => CoefficientOfThermalExpansion.FromPerDegreeCelsius(value.ToDouble(null));
+                => CoefficientOfThermalExpansion.FromPerDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(double)" />
+            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(QuantityValue)" />
             public CoefficientOfThermalExpansion PerDegreeFahrenheit
 #if NET7_0_OR_GREATER
-                => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(double.CreateChecked(value));
+                => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(QuantityValue.CreateChecked(value));
 #else
-                => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(value.ToDouble(null));
+                => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerKelvin(double)" />
+            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerKelvin(QuantityValue)" />
             public CoefficientOfThermalExpansion PerKelvin
 #if NET7_0_OR_GREATER
-                => CoefficientOfThermalExpansion.FromPerKelvin(double.CreateChecked(value));
+                => CoefficientOfThermalExpansion.FromPerKelvin(QuantityValue.CreateChecked(value));
 #else
-                => CoefficientOfThermalExpansion.FromPerKelvin(value.ToDouble(null));
+                => CoefficientOfThermalExpansion.FromPerKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(double)" />
+            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(QuantityValue)" />
             public CoefficientOfThermalExpansion PpmPerDegreeCelsius
 #if NET7_0_OR_GREATER
-                => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(double.CreateChecked(value));
+                => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(value.ToDouble(null));
+                => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(double)" />
+            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(QuantityValue)" />
             public CoefficientOfThermalExpansion PpmPerDegreeFahrenheit
 #if NET7_0_OR_GREATER
-                => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(double.CreateChecked(value));
+                => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(QuantityValue.CreateChecked(value));
 #else
-                => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(value.ToDouble(null));
+                => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerKelvin(double)" />
+            /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerKelvin(QuantityValue)" />
             public CoefficientOfThermalExpansion PpmPerKelvin
 #if NET7_0_OR_GREATER
-                => CoefficientOfThermalExpansion.FromPpmPerKelvin(double.CreateChecked(value));
+                => CoefficientOfThermalExpansion.FromPpmPerKelvin(QuantityValue.CreateChecked(value));
 #else
-                => CoefficientOfThermalExpansion.FromPpmPerKelvin(value.ToDouble(null));
+                => CoefficientOfThermalExpansion.FromPpmPerKelvin(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCompressibilityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCompressibilityExtensions.g.cs
index 7c46b12b14..3f9c127f2c 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCompressibilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCompressibilityExtensions.g.cs
@@ -42,60 +42,60 @@ public static class NumberToCompressibilityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Compressibility.FromInverseAtmospheres(double)" />
+            /// <inheritdoc cref="Compressibility.FromInverseAtmospheres(QuantityValue)" />
             public Compressibility InverseAtmospheres
 #if NET7_0_OR_GREATER
-                => Compressibility.FromInverseAtmospheres(double.CreateChecked(value));
+                => Compressibility.FromInverseAtmospheres(QuantityValue.CreateChecked(value));
 #else
-                => Compressibility.FromInverseAtmospheres(value.ToDouble(null));
+                => Compressibility.FromInverseAtmospheres(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Compressibility.FromInverseBars(double)" />
+            /// <inheritdoc cref="Compressibility.FromInverseBars(QuantityValue)" />
             public Compressibility InverseBars
 #if NET7_0_OR_GREATER
-                => Compressibility.FromInverseBars(double.CreateChecked(value));
+                => Compressibility.FromInverseBars(QuantityValue.CreateChecked(value));
 #else
-                => Compressibility.FromInverseBars(value.ToDouble(null));
+                => Compressibility.FromInverseBars(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Compressibility.FromInverseKilopascals(double)" />
+            /// <inheritdoc cref="Compressibility.FromInverseKilopascals(QuantityValue)" />
             public Compressibility InverseKilopascals
 #if NET7_0_OR_GREATER
-                => Compressibility.FromInverseKilopascals(double.CreateChecked(value));
+                => Compressibility.FromInverseKilopascals(QuantityValue.CreateChecked(value));
 #else
-                => Compressibility.FromInverseKilopascals(value.ToDouble(null));
+                => Compressibility.FromInverseKilopascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Compressibility.FromInverseMegapascals(double)" />
+            /// <inheritdoc cref="Compressibility.FromInverseMegapascals(QuantityValue)" />
             public Compressibility InverseMegapascals
 #if NET7_0_OR_GREATER
-                => Compressibility.FromInverseMegapascals(double.CreateChecked(value));
+                => Compressibility.FromInverseMegapascals(QuantityValue.CreateChecked(value));
 #else
-                => Compressibility.FromInverseMegapascals(value.ToDouble(null));
+                => Compressibility.FromInverseMegapascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Compressibility.FromInverseMillibars(double)" />
+            /// <inheritdoc cref="Compressibility.FromInverseMillibars(QuantityValue)" />
             public Compressibility InverseMillibars
 #if NET7_0_OR_GREATER
-                => Compressibility.FromInverseMillibars(double.CreateChecked(value));
+                => Compressibility.FromInverseMillibars(QuantityValue.CreateChecked(value));
 #else
-                => Compressibility.FromInverseMillibars(value.ToDouble(null));
+                => Compressibility.FromInverseMillibars(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Compressibility.FromInversePascals(double)" />
+            /// <inheritdoc cref="Compressibility.FromInversePascals(QuantityValue)" />
             public Compressibility InversePascals
 #if NET7_0_OR_GREATER
-                => Compressibility.FromInversePascals(double.CreateChecked(value));
+                => Compressibility.FromInversePascals(QuantityValue.CreateChecked(value));
 #else
-                => Compressibility.FromInversePascals(value.ToDouble(null));
+                => Compressibility.FromInversePascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Compressibility.FromInversePoundsForcePerSquareInch(double)" />
+            /// <inheritdoc cref="Compressibility.FromInversePoundsForcePerSquareInch(QuantityValue)" />
             public Compressibility InversePoundsForcePerSquareInch
 #if NET7_0_OR_GREATER
-                => Compressibility.FromInversePoundsForcePerSquareInch(double.CreateChecked(value));
+                => Compressibility.FromInversePoundsForcePerSquareInch(QuantityValue.CreateChecked(value));
 #else
-                => Compressibility.FromInversePoundsForcePerSquareInch(value.ToDouble(null));
+                => Compressibility.FromInversePoundsForcePerSquareInch(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDensityExtensions.g.cs
index b268407a7f..1e12c051d9 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDensityExtensions.g.cs
@@ -42,452 +42,452 @@ public static class NumberToDensityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Density.FromCentigramsPerDeciliter(double)" />
+            /// <inheritdoc cref="Density.FromCentigramsPerDeciliter(QuantityValue)" />
             public Density CentigramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => Density.FromCentigramsPerDeciliter(double.CreateChecked(value));
+                => Density.FromCentigramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromCentigramsPerDeciliter(value.ToDouble(null));
+                => Density.FromCentigramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromCentigramsPerLiter(double)" />
+            /// <inheritdoc cref="Density.FromCentigramsPerLiter(QuantityValue)" />
             public Density CentigramsPerLiter
 #if NET7_0_OR_GREATER
-                => Density.FromCentigramsPerLiter(double.CreateChecked(value));
+                => Density.FromCentigramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromCentigramsPerLiter(value.ToDouble(null));
+                => Density.FromCentigramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromCentigramsPerMilliliter(double)" />
+            /// <inheritdoc cref="Density.FromCentigramsPerMilliliter(QuantityValue)" />
             public Density CentigramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => Density.FromCentigramsPerMilliliter(double.CreateChecked(value));
+                => Density.FromCentigramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromCentigramsPerMilliliter(value.ToDouble(null));
+                => Density.FromCentigramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromDecigramsPerDeciliter(double)" />
+            /// <inheritdoc cref="Density.FromDecigramsPerDeciliter(QuantityValue)" />
             public Density DecigramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => Density.FromDecigramsPerDeciliter(double.CreateChecked(value));
+                => Density.FromDecigramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromDecigramsPerDeciliter(value.ToDouble(null));
+                => Density.FromDecigramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromDecigramsPerLiter(double)" />
+            /// <inheritdoc cref="Density.FromDecigramsPerLiter(QuantityValue)" />
             public Density DecigramsPerLiter
 #if NET7_0_OR_GREATER
-                => Density.FromDecigramsPerLiter(double.CreateChecked(value));
+                => Density.FromDecigramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromDecigramsPerLiter(value.ToDouble(null));
+                => Density.FromDecigramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromDecigramsPerMilliliter(double)" />
+            /// <inheritdoc cref="Density.FromDecigramsPerMilliliter(QuantityValue)" />
             public Density DecigramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => Density.FromDecigramsPerMilliliter(double.CreateChecked(value));
+                => Density.FromDecigramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromDecigramsPerMilliliter(value.ToDouble(null));
+                => Density.FromDecigramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromFemtogramsPerDeciliter(double)" />
+            /// <inheritdoc cref="Density.FromFemtogramsPerDeciliter(QuantityValue)" />
             public Density FemtogramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => Density.FromFemtogramsPerDeciliter(double.CreateChecked(value));
+                => Density.FromFemtogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromFemtogramsPerDeciliter(value.ToDouble(null));
+                => Density.FromFemtogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromFemtogramsPerLiter(double)" />
+            /// <inheritdoc cref="Density.FromFemtogramsPerLiter(QuantityValue)" />
             public Density FemtogramsPerLiter
 #if NET7_0_OR_GREATER
-                => Density.FromFemtogramsPerLiter(double.CreateChecked(value));
+                => Density.FromFemtogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromFemtogramsPerLiter(value.ToDouble(null));
+                => Density.FromFemtogramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromFemtogramsPerMilliliter(double)" />
+            /// <inheritdoc cref="Density.FromFemtogramsPerMilliliter(QuantityValue)" />
             public Density FemtogramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => Density.FromFemtogramsPerMilliliter(double.CreateChecked(value));
+                => Density.FromFemtogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromFemtogramsPerMilliliter(value.ToDouble(null));
+                => Density.FromFemtogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromGramsPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="Density.FromGramsPerCubicCentimeter(QuantityValue)" />
             public Density GramsPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => Density.FromGramsPerCubicCentimeter(double.CreateChecked(value));
+                => Density.FromGramsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromGramsPerCubicCentimeter(value.ToDouble(null));
+                => Density.FromGramsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromGramsPerCubicFoot(double)" />
+            /// <inheritdoc cref="Density.FromGramsPerCubicFoot(QuantityValue)" />
             public Density GramsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => Density.FromGramsPerCubicFoot(double.CreateChecked(value));
+                => Density.FromGramsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromGramsPerCubicFoot(value.ToDouble(null));
+                => Density.FromGramsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromGramsPerCubicInch(double)" />
+            /// <inheritdoc cref="Density.FromGramsPerCubicInch(QuantityValue)" />
             public Density GramsPerCubicInch
 #if NET7_0_OR_GREATER
-                => Density.FromGramsPerCubicInch(double.CreateChecked(value));
+                => Density.FromGramsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromGramsPerCubicInch(value.ToDouble(null));
+                => Density.FromGramsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromGramsPerCubicMeter(double)" />
+            /// <inheritdoc cref="Density.FromGramsPerCubicMeter(QuantityValue)" />
             public Density GramsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => Density.FromGramsPerCubicMeter(double.CreateChecked(value));
+                => Density.FromGramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromGramsPerCubicMeter(value.ToDouble(null));
+                => Density.FromGramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromGramsPerCubicMillimeter(double)" />
+            /// <inheritdoc cref="Density.FromGramsPerCubicMillimeter(QuantityValue)" />
             public Density GramsPerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => Density.FromGramsPerCubicMillimeter(double.CreateChecked(value));
+                => Density.FromGramsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromGramsPerCubicMillimeter(value.ToDouble(null));
+                => Density.FromGramsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromGramsPerDeciliter(double)" />
+            /// <inheritdoc cref="Density.FromGramsPerDeciliter(QuantityValue)" />
             public Density GramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => Density.FromGramsPerDeciliter(double.CreateChecked(value));
+                => Density.FromGramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromGramsPerDeciliter(value.ToDouble(null));
+                => Density.FromGramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromGramsPerLiter(double)" />
+            /// <inheritdoc cref="Density.FromGramsPerLiter(QuantityValue)" />
             public Density GramsPerLiter
 #if NET7_0_OR_GREATER
-                => Density.FromGramsPerLiter(double.CreateChecked(value));
+                => Density.FromGramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromGramsPerLiter(value.ToDouble(null));
+                => Density.FromGramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromGramsPerMilliliter(double)" />
+            /// <inheritdoc cref="Density.FromGramsPerMilliliter(QuantityValue)" />
             public Density GramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => Density.FromGramsPerMilliliter(double.CreateChecked(value));
+                => Density.FromGramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromGramsPerMilliliter(value.ToDouble(null));
+                => Density.FromGramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromKilogramsPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="Density.FromKilogramsPerCubicCentimeter(QuantityValue)" />
             public Density KilogramsPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => Density.FromKilogramsPerCubicCentimeter(double.CreateChecked(value));
+                => Density.FromKilogramsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromKilogramsPerCubicCentimeter(value.ToDouble(null));
+                => Density.FromKilogramsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromKilogramsPerCubicMeter(double)" />
+            /// <inheritdoc cref="Density.FromKilogramsPerCubicMeter(QuantityValue)" />
             public Density KilogramsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => Density.FromKilogramsPerCubicMeter(double.CreateChecked(value));
+                => Density.FromKilogramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromKilogramsPerCubicMeter(value.ToDouble(null));
+                => Density.FromKilogramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromKilogramsPerCubicMillimeter(double)" />
+            /// <inheritdoc cref="Density.FromKilogramsPerCubicMillimeter(QuantityValue)" />
             public Density KilogramsPerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => Density.FromKilogramsPerCubicMillimeter(double.CreateChecked(value));
+                => Density.FromKilogramsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromKilogramsPerCubicMillimeter(value.ToDouble(null));
+                => Density.FromKilogramsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromKilogramsPerLiter(double)" />
+            /// <inheritdoc cref="Density.FromKilogramsPerLiter(QuantityValue)" />
             public Density KilogramsPerLiter
 #if NET7_0_OR_GREATER
-                => Density.FromKilogramsPerLiter(double.CreateChecked(value));
+                => Density.FromKilogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromKilogramsPerLiter(value.ToDouble(null));
+                => Density.FromKilogramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromKilopoundsPerCubicFoot(double)" />
+            /// <inheritdoc cref="Density.FromKilopoundsPerCubicFoot(QuantityValue)" />
             public Density KilopoundsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => Density.FromKilopoundsPerCubicFoot(double.CreateChecked(value));
+                => Density.FromKilopoundsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromKilopoundsPerCubicFoot(value.ToDouble(null));
+                => Density.FromKilopoundsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromKilopoundsPerCubicInch(double)" />
+            /// <inheritdoc cref="Density.FromKilopoundsPerCubicInch(QuantityValue)" />
             public Density KilopoundsPerCubicInch
 #if NET7_0_OR_GREATER
-                => Density.FromKilopoundsPerCubicInch(double.CreateChecked(value));
+                => Density.FromKilopoundsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromKilopoundsPerCubicInch(value.ToDouble(null));
+                => Density.FromKilopoundsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromKilopoundsPerCubicYard(double)" />
+            /// <inheritdoc cref="Density.FromKilopoundsPerCubicYard(QuantityValue)" />
             public Density KilopoundsPerCubicYard
 #if NET7_0_OR_GREATER
-                => Density.FromKilopoundsPerCubicYard(double.CreateChecked(value));
+                => Density.FromKilopoundsPerCubicYard(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromKilopoundsPerCubicYard(value.ToDouble(null));
+                => Density.FromKilopoundsPerCubicYard(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromMicrogramsPerCubicMeter(double)" />
+            /// <inheritdoc cref="Density.FromMicrogramsPerCubicMeter(QuantityValue)" />
             public Density MicrogramsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => Density.FromMicrogramsPerCubicMeter(double.CreateChecked(value));
+                => Density.FromMicrogramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromMicrogramsPerCubicMeter(value.ToDouble(null));
+                => Density.FromMicrogramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromMicrogramsPerDeciliter(double)" />
+            /// <inheritdoc cref="Density.FromMicrogramsPerDeciliter(QuantityValue)" />
             public Density MicrogramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => Density.FromMicrogramsPerDeciliter(double.CreateChecked(value));
+                => Density.FromMicrogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromMicrogramsPerDeciliter(value.ToDouble(null));
+                => Density.FromMicrogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromMicrogramsPerLiter(double)" />
+            /// <inheritdoc cref="Density.FromMicrogramsPerLiter(QuantityValue)" />
             public Density MicrogramsPerLiter
 #if NET7_0_OR_GREATER
-                => Density.FromMicrogramsPerLiter(double.CreateChecked(value));
+                => Density.FromMicrogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromMicrogramsPerLiter(value.ToDouble(null));
+                => Density.FromMicrogramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromMicrogramsPerMilliliter(double)" />
+            /// <inheritdoc cref="Density.FromMicrogramsPerMilliliter(QuantityValue)" />
             public Density MicrogramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => Density.FromMicrogramsPerMilliliter(double.CreateChecked(value));
+                => Density.FromMicrogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromMicrogramsPerMilliliter(value.ToDouble(null));
+                => Density.FromMicrogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromMilligramsPerCubicMeter(double)" />
+            /// <inheritdoc cref="Density.FromMilligramsPerCubicMeter(QuantityValue)" />
             public Density MilligramsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => Density.FromMilligramsPerCubicMeter(double.CreateChecked(value));
+                => Density.FromMilligramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromMilligramsPerCubicMeter(value.ToDouble(null));
+                => Density.FromMilligramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromMilligramsPerDeciliter(double)" />
+            /// <inheritdoc cref="Density.FromMilligramsPerDeciliter(QuantityValue)" />
             public Density MilligramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => Density.FromMilligramsPerDeciliter(double.CreateChecked(value));
+                => Density.FromMilligramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromMilligramsPerDeciliter(value.ToDouble(null));
+                => Density.FromMilligramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromMilligramsPerLiter(double)" />
+            /// <inheritdoc cref="Density.FromMilligramsPerLiter(QuantityValue)" />
             public Density MilligramsPerLiter
 #if NET7_0_OR_GREATER
-                => Density.FromMilligramsPerLiter(double.CreateChecked(value));
+                => Density.FromMilligramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromMilligramsPerLiter(value.ToDouble(null));
+                => Density.FromMilligramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromMilligramsPerMilliliter(double)" />
+            /// <inheritdoc cref="Density.FromMilligramsPerMilliliter(QuantityValue)" />
             public Density MilligramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => Density.FromMilligramsPerMilliliter(double.CreateChecked(value));
+                => Density.FromMilligramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromMilligramsPerMilliliter(value.ToDouble(null));
+                => Density.FromMilligramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromNanogramsPerDeciliter(double)" />
+            /// <inheritdoc cref="Density.FromNanogramsPerDeciliter(QuantityValue)" />
             public Density NanogramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => Density.FromNanogramsPerDeciliter(double.CreateChecked(value));
+                => Density.FromNanogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromNanogramsPerDeciliter(value.ToDouble(null));
+                => Density.FromNanogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromNanogramsPerLiter(double)" />
+            /// <inheritdoc cref="Density.FromNanogramsPerLiter(QuantityValue)" />
             public Density NanogramsPerLiter
 #if NET7_0_OR_GREATER
-                => Density.FromNanogramsPerLiter(double.CreateChecked(value));
+                => Density.FromNanogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromNanogramsPerLiter(value.ToDouble(null));
+                => Density.FromNanogramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromNanogramsPerMilliliter(double)" />
+            /// <inheritdoc cref="Density.FromNanogramsPerMilliliter(QuantityValue)" />
             public Density NanogramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => Density.FromNanogramsPerMilliliter(double.CreateChecked(value));
+                => Density.FromNanogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromNanogramsPerMilliliter(value.ToDouble(null));
+                => Density.FromNanogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPicogramsPerDeciliter(double)" />
+            /// <inheritdoc cref="Density.FromPicogramsPerDeciliter(QuantityValue)" />
             public Density PicogramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => Density.FromPicogramsPerDeciliter(double.CreateChecked(value));
+                => Density.FromPicogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPicogramsPerDeciliter(value.ToDouble(null));
+                => Density.FromPicogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPicogramsPerLiter(double)" />
+            /// <inheritdoc cref="Density.FromPicogramsPerLiter(QuantityValue)" />
             public Density PicogramsPerLiter
 #if NET7_0_OR_GREATER
-                => Density.FromPicogramsPerLiter(double.CreateChecked(value));
+                => Density.FromPicogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPicogramsPerLiter(value.ToDouble(null));
+                => Density.FromPicogramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPicogramsPerMilliliter(double)" />
+            /// <inheritdoc cref="Density.FromPicogramsPerMilliliter(QuantityValue)" />
             public Density PicogramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => Density.FromPicogramsPerMilliliter(double.CreateChecked(value));
+                => Density.FromPicogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPicogramsPerMilliliter(value.ToDouble(null));
+                => Density.FromPicogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPoundsPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="Density.FromPoundsPerCubicCentimeter(QuantityValue)" />
             public Density PoundsPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => Density.FromPoundsPerCubicCentimeter(double.CreateChecked(value));
+                => Density.FromPoundsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPoundsPerCubicCentimeter(value.ToDouble(null));
+                => Density.FromPoundsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPoundsPerCubicFoot(double)" />
+            /// <inheritdoc cref="Density.FromPoundsPerCubicFoot(QuantityValue)" />
             public Density PoundsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => Density.FromPoundsPerCubicFoot(double.CreateChecked(value));
+                => Density.FromPoundsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPoundsPerCubicFoot(value.ToDouble(null));
+                => Density.FromPoundsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPoundsPerCubicInch(double)" />
+            /// <inheritdoc cref="Density.FromPoundsPerCubicInch(QuantityValue)" />
             public Density PoundsPerCubicInch
 #if NET7_0_OR_GREATER
-                => Density.FromPoundsPerCubicInch(double.CreateChecked(value));
+                => Density.FromPoundsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPoundsPerCubicInch(value.ToDouble(null));
+                => Density.FromPoundsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPoundsPerCubicMeter(double)" />
+            /// <inheritdoc cref="Density.FromPoundsPerCubicMeter(QuantityValue)" />
             public Density PoundsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => Density.FromPoundsPerCubicMeter(double.CreateChecked(value));
+                => Density.FromPoundsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPoundsPerCubicMeter(value.ToDouble(null));
+                => Density.FromPoundsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPoundsPerCubicMillimeter(double)" />
+            /// <inheritdoc cref="Density.FromPoundsPerCubicMillimeter(QuantityValue)" />
             public Density PoundsPerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => Density.FromPoundsPerCubicMillimeter(double.CreateChecked(value));
+                => Density.FromPoundsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPoundsPerCubicMillimeter(value.ToDouble(null));
+                => Density.FromPoundsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPoundsPerCubicYard(double)" />
+            /// <inheritdoc cref="Density.FromPoundsPerCubicYard(QuantityValue)" />
             public Density PoundsPerCubicYard
 #if NET7_0_OR_GREATER
-                => Density.FromPoundsPerCubicYard(double.CreateChecked(value));
+                => Density.FromPoundsPerCubicYard(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPoundsPerCubicYard(value.ToDouble(null));
+                => Density.FromPoundsPerCubicYard(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPoundsPerImperialGallon(double)" />
+            /// <inheritdoc cref="Density.FromPoundsPerImperialGallon(QuantityValue)" />
             public Density PoundsPerImperialGallon
 #if NET7_0_OR_GREATER
-                => Density.FromPoundsPerImperialGallon(double.CreateChecked(value));
+                => Density.FromPoundsPerImperialGallon(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPoundsPerImperialGallon(value.ToDouble(null));
+                => Density.FromPoundsPerImperialGallon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromPoundsPerUSGallon(double)" />
+            /// <inheritdoc cref="Density.FromPoundsPerUSGallon(QuantityValue)" />
             public Density PoundsPerUSGallon
 #if NET7_0_OR_GREATER
-                => Density.FromPoundsPerUSGallon(double.CreateChecked(value));
+                => Density.FromPoundsPerUSGallon(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromPoundsPerUSGallon(value.ToDouble(null));
+                => Density.FromPoundsPerUSGallon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromSlugsPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="Density.FromSlugsPerCubicCentimeter(QuantityValue)" />
             public Density SlugsPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => Density.FromSlugsPerCubicCentimeter(double.CreateChecked(value));
+                => Density.FromSlugsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromSlugsPerCubicCentimeter(value.ToDouble(null));
+                => Density.FromSlugsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromSlugsPerCubicFoot(double)" />
+            /// <inheritdoc cref="Density.FromSlugsPerCubicFoot(QuantityValue)" />
             public Density SlugsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => Density.FromSlugsPerCubicFoot(double.CreateChecked(value));
+                => Density.FromSlugsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromSlugsPerCubicFoot(value.ToDouble(null));
+                => Density.FromSlugsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromSlugsPerCubicInch(double)" />
+            /// <inheritdoc cref="Density.FromSlugsPerCubicInch(QuantityValue)" />
             public Density SlugsPerCubicInch
 #if NET7_0_OR_GREATER
-                => Density.FromSlugsPerCubicInch(double.CreateChecked(value));
+                => Density.FromSlugsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromSlugsPerCubicInch(value.ToDouble(null));
+                => Density.FromSlugsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromSlugsPerCubicMeter(double)" />
+            /// <inheritdoc cref="Density.FromSlugsPerCubicMeter(QuantityValue)" />
             public Density SlugsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => Density.FromSlugsPerCubicMeter(double.CreateChecked(value));
+                => Density.FromSlugsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromSlugsPerCubicMeter(value.ToDouble(null));
+                => Density.FromSlugsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromSlugsPerCubicMillimeter(double)" />
+            /// <inheritdoc cref="Density.FromSlugsPerCubicMillimeter(QuantityValue)" />
             public Density SlugsPerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => Density.FromSlugsPerCubicMillimeter(double.CreateChecked(value));
+                => Density.FromSlugsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromSlugsPerCubicMillimeter(value.ToDouble(null));
+                => Density.FromSlugsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromTonnesPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="Density.FromTonnesPerCubicCentimeter(QuantityValue)" />
             public Density TonnesPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => Density.FromTonnesPerCubicCentimeter(double.CreateChecked(value));
+                => Density.FromTonnesPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromTonnesPerCubicCentimeter(value.ToDouble(null));
+                => Density.FromTonnesPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromTonnesPerCubicFoot(double)" />
+            /// <inheritdoc cref="Density.FromTonnesPerCubicFoot(QuantityValue)" />
             public Density TonnesPerCubicFoot
 #if NET7_0_OR_GREATER
-                => Density.FromTonnesPerCubicFoot(double.CreateChecked(value));
+                => Density.FromTonnesPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromTonnesPerCubicFoot(value.ToDouble(null));
+                => Density.FromTonnesPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromTonnesPerCubicInch(double)" />
+            /// <inheritdoc cref="Density.FromTonnesPerCubicInch(QuantityValue)" />
             public Density TonnesPerCubicInch
 #if NET7_0_OR_GREATER
-                => Density.FromTonnesPerCubicInch(double.CreateChecked(value));
+                => Density.FromTonnesPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromTonnesPerCubicInch(value.ToDouble(null));
+                => Density.FromTonnesPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromTonnesPerCubicMeter(double)" />
+            /// <inheritdoc cref="Density.FromTonnesPerCubicMeter(QuantityValue)" />
             public Density TonnesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => Density.FromTonnesPerCubicMeter(double.CreateChecked(value));
+                => Density.FromTonnesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromTonnesPerCubicMeter(value.ToDouble(null));
+                => Density.FromTonnesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Density.FromTonnesPerCubicMillimeter(double)" />
+            /// <inheritdoc cref="Density.FromTonnesPerCubicMillimeter(QuantityValue)" />
             public Density TonnesPerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => Density.FromTonnesPerCubicMillimeter(double.CreateChecked(value));
+                => Density.FromTonnesPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => Density.FromTonnesPerCubicMillimeter(value.ToDouble(null));
+                => Density.FromTonnesPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs
index 91326ba09f..048f15471e 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs
@@ -42,204 +42,204 @@ public static class NumberToDoseAreaProductExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareCentimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareCentimeters(QuantityValue)" />
             public DoseAreaProduct CentigraySquareCentimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromCentigraySquareCentimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromCentigraySquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromCentigraySquareCentimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromCentigraySquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareDecimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareDecimeters(QuantityValue)" />
             public DoseAreaProduct CentigraySquareDecimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromCentigraySquareDecimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromCentigraySquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromCentigraySquareDecimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromCentigraySquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMeters(QuantityValue)" />
             public DoseAreaProduct CentigraySquareMeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromCentigraySquareMeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromCentigraySquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromCentigraySquareMeters(value.ToDouble(null));
+                => DoseAreaProduct.FromCentigraySquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMicrometers(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMicrometers(QuantityValue)" />
             public DoseAreaProduct CentigraySquareMicrometers
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromCentigraySquareMicrometers(double.CreateChecked(value));
+                => DoseAreaProduct.FromCentigraySquareMicrometers(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromCentigraySquareMicrometers(value.ToDouble(null));
+                => DoseAreaProduct.FromCentigraySquareMicrometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMillimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMillimeters(QuantityValue)" />
             public DoseAreaProduct CentigraySquareMillimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromCentigraySquareMillimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromCentigraySquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromCentigraySquareMillimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromCentigraySquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareCentimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareCentimeters(QuantityValue)" />
             public DoseAreaProduct DecigraySquareCentimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromDecigraySquareCentimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromDecigraySquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromDecigraySquareCentimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromDecigraySquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareDecimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareDecimeters(QuantityValue)" />
             public DoseAreaProduct DecigraySquareDecimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromDecigraySquareDecimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromDecigraySquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromDecigraySquareDecimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromDecigraySquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMeters(QuantityValue)" />
             public DoseAreaProduct DecigraySquareMeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromDecigraySquareMeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromDecigraySquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromDecigraySquareMeters(value.ToDouble(null));
+                => DoseAreaProduct.FromDecigraySquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMicrometers(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMicrometers(QuantityValue)" />
             public DoseAreaProduct DecigraySquareMicrometers
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromDecigraySquareMicrometers(double.CreateChecked(value));
+                => DoseAreaProduct.FromDecigraySquareMicrometers(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromDecigraySquareMicrometers(value.ToDouble(null));
+                => DoseAreaProduct.FromDecigraySquareMicrometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMillimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMillimeters(QuantityValue)" />
             public DoseAreaProduct DecigraySquareMillimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromDecigraySquareMillimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromDecigraySquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromDecigraySquareMillimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromDecigraySquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromGraySquareCentimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromGraySquareCentimeters(QuantityValue)" />
             public DoseAreaProduct GraySquareCentimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromGraySquareCentimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromGraySquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromGraySquareCentimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromGraySquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromGraySquareDecimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromGraySquareDecimeters(QuantityValue)" />
             public DoseAreaProduct GraySquareDecimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromGraySquareDecimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromGraySquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromGraySquareDecimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromGraySquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMeters(QuantityValue)" />
             public DoseAreaProduct GraySquareMeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromGraySquareMeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromGraySquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromGraySquareMeters(value.ToDouble(null));
+                => DoseAreaProduct.FromGraySquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMicrometers(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMicrometers(QuantityValue)" />
             public DoseAreaProduct GraySquareMicrometers
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromGraySquareMicrometers(double.CreateChecked(value));
+                => DoseAreaProduct.FromGraySquareMicrometers(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromGraySquareMicrometers(value.ToDouble(null));
+                => DoseAreaProduct.FromGraySquareMicrometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMillimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMillimeters(QuantityValue)" />
             public DoseAreaProduct GraySquareMillimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromGraySquareMillimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromGraySquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromGraySquareMillimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromGraySquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareCentimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareCentimeters(QuantityValue)" />
             public DoseAreaProduct MicrograySquareCentimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromMicrograySquareCentimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromMicrograySquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromMicrograySquareCentimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromMicrograySquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareDecimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareDecimeters(QuantityValue)" />
             public DoseAreaProduct MicrograySquareDecimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromMicrograySquareDecimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromMicrograySquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromMicrograySquareDecimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromMicrograySquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMeters(QuantityValue)" />
             public DoseAreaProduct MicrograySquareMeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromMicrograySquareMeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromMicrograySquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromMicrograySquareMeters(value.ToDouble(null));
+                => DoseAreaProduct.FromMicrograySquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMicrometers(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMicrometers(QuantityValue)" />
             public DoseAreaProduct MicrograySquareMicrometers
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromMicrograySquareMicrometers(double.CreateChecked(value));
+                => DoseAreaProduct.FromMicrograySquareMicrometers(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromMicrograySquareMicrometers(value.ToDouble(null));
+                => DoseAreaProduct.FromMicrograySquareMicrometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMillimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMillimeters(QuantityValue)" />
             public DoseAreaProduct MicrograySquareMillimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromMicrograySquareMillimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromMicrograySquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromMicrograySquareMillimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromMicrograySquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareCentimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareCentimeters(QuantityValue)" />
             public DoseAreaProduct MilligraySquareCentimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromMilligraySquareCentimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromMilligraySquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromMilligraySquareCentimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromMilligraySquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareDecimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareDecimeters(QuantityValue)" />
             public DoseAreaProduct MilligraySquareDecimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromMilligraySquareDecimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromMilligraySquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromMilligraySquareDecimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromMilligraySquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMeters(QuantityValue)" />
             public DoseAreaProduct MilligraySquareMeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromMilligraySquareMeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromMilligraySquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromMilligraySquareMeters(value.ToDouble(null));
+                => DoseAreaProduct.FromMilligraySquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMicrometers(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMicrometers(QuantityValue)" />
             public DoseAreaProduct MilligraySquareMicrometers
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromMilligraySquareMicrometers(double.CreateChecked(value));
+                => DoseAreaProduct.FromMilligraySquareMicrometers(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromMilligraySquareMicrometers(value.ToDouble(null));
+                => DoseAreaProduct.FromMilligraySquareMicrometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMillimeters(double)" />
+            /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMillimeters(QuantityValue)" />
             public DoseAreaProduct MilligraySquareMillimeters
 #if NET7_0_OR_GREATER
-                => DoseAreaProduct.FromMilligraySquareMillimeters(double.CreateChecked(value));
+                => DoseAreaProduct.FromMilligraySquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => DoseAreaProduct.FromMilligraySquareMillimeters(value.ToDouble(null));
+                => DoseAreaProduct.FromMilligraySquareMillimeters(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDurationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDurationExtensions.g.cs
index 3f4269f2cb..60048b7c7b 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDurationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDurationExtensions.g.cs
@@ -42,108 +42,108 @@ public static class NumberToDurationExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Duration.FromDays(double)" />
+            /// <inheritdoc cref="Duration.FromDays(QuantityValue)" />
             public Duration Days
 #if NET7_0_OR_GREATER
-                => Duration.FromDays(double.CreateChecked(value));
+                => Duration.FromDays(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromDays(value.ToDouble(null));
+                => Duration.FromDays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromHours(double)" />
+            /// <inheritdoc cref="Duration.FromHours(QuantityValue)" />
             public Duration Hours
 #if NET7_0_OR_GREATER
-                => Duration.FromHours(double.CreateChecked(value));
+                => Duration.FromHours(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromHours(value.ToDouble(null));
+                => Duration.FromHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromJulianYears(double)" />
+            /// <inheritdoc cref="Duration.FromJulianYears(QuantityValue)" />
             public Duration JulianYears
 #if NET7_0_OR_GREATER
-                => Duration.FromJulianYears(double.CreateChecked(value));
+                => Duration.FromJulianYears(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromJulianYears(value.ToDouble(null));
+                => Duration.FromJulianYears(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromMicroseconds(double)" />
+            /// <inheritdoc cref="Duration.FromMicroseconds(QuantityValue)" />
             public Duration Microseconds
 #if NET7_0_OR_GREATER
-                => Duration.FromMicroseconds(double.CreateChecked(value));
+                => Duration.FromMicroseconds(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromMicroseconds(value.ToDouble(null));
+                => Duration.FromMicroseconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromMilliseconds(double)" />
+            /// <inheritdoc cref="Duration.FromMilliseconds(QuantityValue)" />
             public Duration Milliseconds
 #if NET7_0_OR_GREATER
-                => Duration.FromMilliseconds(double.CreateChecked(value));
+                => Duration.FromMilliseconds(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromMilliseconds(value.ToDouble(null));
+                => Duration.FromMilliseconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromMinutes(double)" />
+            /// <inheritdoc cref="Duration.FromMinutes(QuantityValue)" />
             public Duration Minutes
 #if NET7_0_OR_GREATER
-                => Duration.FromMinutes(double.CreateChecked(value));
+                => Duration.FromMinutes(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromMinutes(value.ToDouble(null));
+                => Duration.FromMinutes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromMonths30(double)" />
+            /// <inheritdoc cref="Duration.FromMonths30(QuantityValue)" />
             public Duration Months30
 #if NET7_0_OR_GREATER
-                => Duration.FromMonths30(double.CreateChecked(value));
+                => Duration.FromMonths30(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromMonths30(value.ToDouble(null));
+                => Duration.FromMonths30(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromNanoseconds(double)" />
+            /// <inheritdoc cref="Duration.FromNanoseconds(QuantityValue)" />
             public Duration Nanoseconds
 #if NET7_0_OR_GREATER
-                => Duration.FromNanoseconds(double.CreateChecked(value));
+                => Duration.FromNanoseconds(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromNanoseconds(value.ToDouble(null));
+                => Duration.FromNanoseconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromPicoseconds(double)" />
+            /// <inheritdoc cref="Duration.FromPicoseconds(QuantityValue)" />
             public Duration Picoseconds
 #if NET7_0_OR_GREATER
-                => Duration.FromPicoseconds(double.CreateChecked(value));
+                => Duration.FromPicoseconds(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromPicoseconds(value.ToDouble(null));
+                => Duration.FromPicoseconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromSeconds(double)" />
+            /// <inheritdoc cref="Duration.FromSeconds(QuantityValue)" />
             public Duration Seconds
 #if NET7_0_OR_GREATER
-                => Duration.FromSeconds(double.CreateChecked(value));
+                => Duration.FromSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromSeconds(value.ToDouble(null));
+                => Duration.FromSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromSols(double)" />
+            /// <inheritdoc cref="Duration.FromSols(QuantityValue)" />
             public Duration Sols
 #if NET7_0_OR_GREATER
-                => Duration.FromSols(double.CreateChecked(value));
+                => Duration.FromSols(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromSols(value.ToDouble(null));
+                => Duration.FromSols(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromWeeks(double)" />
+            /// <inheritdoc cref="Duration.FromWeeks(QuantityValue)" />
             public Duration Weeks
 #if NET7_0_OR_GREATER
-                => Duration.FromWeeks(double.CreateChecked(value));
+                => Duration.FromWeeks(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromWeeks(value.ToDouble(null));
+                => Duration.FromWeeks(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Duration.FromYears365(double)" />
+            /// <inheritdoc cref="Duration.FromYears365(QuantityValue)" />
             public Duration Years365
 #if NET7_0_OR_GREATER
-                => Duration.FromYears365(double.CreateChecked(value));
+                => Duration.FromYears365(QuantityValue.CreateChecked(value));
 #else
-                => Duration.FromYears365(value.ToDouble(null));
+                => Duration.FromYears365(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
index 7cf7925aff..95d96d0f26 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
@@ -42,84 +42,84 @@ public static class NumberToDynamicViscosityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="DynamicViscosity.FromCentipoise(double)" />
+            /// <inheritdoc cref="DynamicViscosity.FromCentipoise(QuantityValue)" />
             public DynamicViscosity Centipoise
 #if NET7_0_OR_GREATER
-                => DynamicViscosity.FromCentipoise(double.CreateChecked(value));
+                => DynamicViscosity.FromCentipoise(QuantityValue.CreateChecked(value));
 #else
-                => DynamicViscosity.FromCentipoise(value.ToDouble(null));
+                => DynamicViscosity.FromCentipoise(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DynamicViscosity.FromMicropascalSeconds(double)" />
+            /// <inheritdoc cref="DynamicViscosity.FromMicropascalSeconds(QuantityValue)" />
             public DynamicViscosity MicropascalSeconds
 #if NET7_0_OR_GREATER
-                => DynamicViscosity.FromMicropascalSeconds(double.CreateChecked(value));
+                => DynamicViscosity.FromMicropascalSeconds(QuantityValue.CreateChecked(value));
 #else
-                => DynamicViscosity.FromMicropascalSeconds(value.ToDouble(null));
+                => DynamicViscosity.FromMicropascalSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DynamicViscosity.FromMillipascalSeconds(double)" />
+            /// <inheritdoc cref="DynamicViscosity.FromMillipascalSeconds(QuantityValue)" />
             public DynamicViscosity MillipascalSeconds
 #if NET7_0_OR_GREATER
-                => DynamicViscosity.FromMillipascalSeconds(double.CreateChecked(value));
+                => DynamicViscosity.FromMillipascalSeconds(QuantityValue.CreateChecked(value));
 #else
-                => DynamicViscosity.FromMillipascalSeconds(value.ToDouble(null));
+                => DynamicViscosity.FromMillipascalSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DynamicViscosity.FromNewtonSecondsPerMeterSquared(double)" />
+            /// <inheritdoc cref="DynamicViscosity.FromNewtonSecondsPerMeterSquared(QuantityValue)" />
             public DynamicViscosity NewtonSecondsPerMeterSquared
 #if NET7_0_OR_GREATER
-                => DynamicViscosity.FromNewtonSecondsPerMeterSquared(double.CreateChecked(value));
+                => DynamicViscosity.FromNewtonSecondsPerMeterSquared(QuantityValue.CreateChecked(value));
 #else
-                => DynamicViscosity.FromNewtonSecondsPerMeterSquared(value.ToDouble(null));
+                => DynamicViscosity.FromNewtonSecondsPerMeterSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DynamicViscosity.FromPascalSeconds(double)" />
+            /// <inheritdoc cref="DynamicViscosity.FromPascalSeconds(QuantityValue)" />
             public DynamicViscosity PascalSeconds
 #if NET7_0_OR_GREATER
-                => DynamicViscosity.FromPascalSeconds(double.CreateChecked(value));
+                => DynamicViscosity.FromPascalSeconds(QuantityValue.CreateChecked(value));
 #else
-                => DynamicViscosity.FromPascalSeconds(value.ToDouble(null));
+                => DynamicViscosity.FromPascalSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DynamicViscosity.FromPoise(double)" />
+            /// <inheritdoc cref="DynamicViscosity.FromPoise(QuantityValue)" />
             public DynamicViscosity Poise
 #if NET7_0_OR_GREATER
-                => DynamicViscosity.FromPoise(double.CreateChecked(value));
+                => DynamicViscosity.FromPoise(QuantityValue.CreateChecked(value));
 #else
-                => DynamicViscosity.FromPoise(value.ToDouble(null));
+                => DynamicViscosity.FromPoise(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareFoot(double)" />
+            /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareFoot(QuantityValue)" />
             public DynamicViscosity PoundsForceSecondPerSquareFoot
 #if NET7_0_OR_GREATER
-                => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(double.CreateChecked(value));
+                => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(value.ToDouble(null));
+                => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareInch(double)" />
+            /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareInch(QuantityValue)" />
             public DynamicViscosity PoundsForceSecondPerSquareInch
 #if NET7_0_OR_GREATER
-                => DynamicViscosity.FromPoundsForceSecondPerSquareInch(double.CreateChecked(value));
+                => DynamicViscosity.FromPoundsForceSecondPerSquareInch(QuantityValue.CreateChecked(value));
 #else
-                => DynamicViscosity.FromPoundsForceSecondPerSquareInch(value.ToDouble(null));
+                => DynamicViscosity.FromPoundsForceSecondPerSquareInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DynamicViscosity.FromPoundsPerFootSecond(double)" />
+            /// <inheritdoc cref="DynamicViscosity.FromPoundsPerFootSecond(QuantityValue)" />
             public DynamicViscosity PoundsPerFootSecond
 #if NET7_0_OR_GREATER
-                => DynamicViscosity.FromPoundsPerFootSecond(double.CreateChecked(value));
+                => DynamicViscosity.FromPoundsPerFootSecond(QuantityValue.CreateChecked(value));
 #else
-                => DynamicViscosity.FromPoundsPerFootSecond(value.ToDouble(null));
+                => DynamicViscosity.FromPoundsPerFootSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="DynamicViscosity.FromReyns(double)" />
+            /// <inheritdoc cref="DynamicViscosity.FromReyns(QuantityValue)" />
             public DynamicViscosity Reyns
 #if NET7_0_OR_GREATER
-                => DynamicViscosity.FromReyns(double.CreateChecked(value));
+                => DynamicViscosity.FromReyns(QuantityValue.CreateChecked(value));
 #else
-                => DynamicViscosity.FromReyns(value.ToDouble(null));
+                => DynamicViscosity.FromReyns(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
index b4f5d9e7e4..707b747341 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
@@ -43,148 +43,148 @@ public static class NumberToElectricAdmittanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricAdmittance.FromGigamhos(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromGigamhos(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Gigamhos
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromGigamhos(double.CreateChecked(value));
+                => ElectricAdmittance.FromGigamhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromGigamhos(value.ToDouble(null));
+                => ElectricAdmittance.FromGigamhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromGigasiemens(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromGigasiemens(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Gigasiemens
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromGigasiemens(double.CreateChecked(value));
+                => ElectricAdmittance.FromGigasiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromGigasiemens(value.ToDouble(null));
+                => ElectricAdmittance.FromGigasiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromKilomhos(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromKilomhos(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Kilomhos
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromKilomhos(double.CreateChecked(value));
+                => ElectricAdmittance.FromKilomhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromKilomhos(value.ToDouble(null));
+                => ElectricAdmittance.FromKilomhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromKilosiemens(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromKilosiemens(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Kilosiemens
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromKilosiemens(double.CreateChecked(value));
+                => ElectricAdmittance.FromKilosiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromKilosiemens(value.ToDouble(null));
+                => ElectricAdmittance.FromKilosiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromMegamhos(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromMegamhos(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Megamhos
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromMegamhos(double.CreateChecked(value));
+                => ElectricAdmittance.FromMegamhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromMegamhos(value.ToDouble(null));
+                => ElectricAdmittance.FromMegamhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromMegasiemens(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromMegasiemens(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Megasiemens
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromMegasiemens(double.CreateChecked(value));
+                => ElectricAdmittance.FromMegasiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromMegasiemens(value.ToDouble(null));
+                => ElectricAdmittance.FromMegasiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromMhos(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromMhos(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Mhos
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromMhos(double.CreateChecked(value));
+                => ElectricAdmittance.FromMhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromMhos(value.ToDouble(null));
+                => ElectricAdmittance.FromMhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromMicromhos(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromMicromhos(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Micromhos
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromMicromhos(double.CreateChecked(value));
+                => ElectricAdmittance.FromMicromhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromMicromhos(value.ToDouble(null));
+                => ElectricAdmittance.FromMicromhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromMicrosiemens(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromMicrosiemens(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Microsiemens
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromMicrosiemens(double.CreateChecked(value));
+                => ElectricAdmittance.FromMicrosiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromMicrosiemens(value.ToDouble(null));
+                => ElectricAdmittance.FromMicrosiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromMillimhos(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromMillimhos(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Millimhos
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromMillimhos(double.CreateChecked(value));
+                => ElectricAdmittance.FromMillimhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromMillimhos(value.ToDouble(null));
+                => ElectricAdmittance.FromMillimhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromMillisiemens(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromMillisiemens(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Millisiemens
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromMillisiemens(double.CreateChecked(value));
+                => ElectricAdmittance.FromMillisiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromMillisiemens(value.ToDouble(null));
+                => ElectricAdmittance.FromMillisiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromNanomhos(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromNanomhos(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Nanomhos
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromNanomhos(double.CreateChecked(value));
+                => ElectricAdmittance.FromNanomhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromNanomhos(value.ToDouble(null));
+                => ElectricAdmittance.FromNanomhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromNanosiemens(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromNanosiemens(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Nanosiemens
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromNanosiemens(double.CreateChecked(value));
+                => ElectricAdmittance.FromNanosiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromNanosiemens(value.ToDouble(null));
+                => ElectricAdmittance.FromNanosiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromSiemens(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromSiemens(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Siemens
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromSiemens(double.CreateChecked(value));
+                => ElectricAdmittance.FromSiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromSiemens(value.ToDouble(null));
+                => ElectricAdmittance.FromSiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromTeramhos(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromTeramhos(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Teramhos
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromTeramhos(double.CreateChecked(value));
+                => ElectricAdmittance.FromTeramhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromTeramhos(value.ToDouble(null));
+                => ElectricAdmittance.FromTeramhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricAdmittance.FromTerasiemens(double)" />
+            /// <inheritdoc cref="ElectricAdmittance.FromTerasiemens(QuantityValue)" />
             [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
             public ElectricAdmittance Terasiemens
 #if NET7_0_OR_GREATER
-                => ElectricAdmittance.FromTerasiemens(double.CreateChecked(value));
+                => ElectricAdmittance.FromTerasiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricAdmittance.FromTerasiemens(value.ToDouble(null));
+                => ElectricAdmittance.FromTerasiemens(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs
index 4f2e2c6322..e7e5509a0c 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs
@@ -42,28 +42,28 @@ public static class NumberToElectricApparentEnergyExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricApparentEnergy.FromKilovoltampereHours(double)" />
+            /// <inheritdoc cref="ElectricApparentEnergy.FromKilovoltampereHours(QuantityValue)" />
             public ElectricApparentEnergy KilovoltampereHours
 #if NET7_0_OR_GREATER
-                => ElectricApparentEnergy.FromKilovoltampereHours(double.CreateChecked(value));
+                => ElectricApparentEnergy.FromKilovoltampereHours(QuantityValue.CreateChecked(value));
 #else
-                => ElectricApparentEnergy.FromKilovoltampereHours(value.ToDouble(null));
+                => ElectricApparentEnergy.FromKilovoltampereHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricApparentEnergy.FromMegavoltampereHours(double)" />
+            /// <inheritdoc cref="ElectricApparentEnergy.FromMegavoltampereHours(QuantityValue)" />
             public ElectricApparentEnergy MegavoltampereHours
 #if NET7_0_OR_GREATER
-                => ElectricApparentEnergy.FromMegavoltampereHours(double.CreateChecked(value));
+                => ElectricApparentEnergy.FromMegavoltampereHours(QuantityValue.CreateChecked(value));
 #else
-                => ElectricApparentEnergy.FromMegavoltampereHours(value.ToDouble(null));
+                => ElectricApparentEnergy.FromMegavoltampereHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricApparentEnergy.FromVoltampereHours(double)" />
+            /// <inheritdoc cref="ElectricApparentEnergy.FromVoltampereHours(QuantityValue)" />
             public ElectricApparentEnergy VoltampereHours
 #if NET7_0_OR_GREATER
-                => ElectricApparentEnergy.FromVoltampereHours(double.CreateChecked(value));
+                => ElectricApparentEnergy.FromVoltampereHours(QuantityValue.CreateChecked(value));
 #else
-                => ElectricApparentEnergy.FromVoltampereHours(value.ToDouble(null));
+                => ElectricApparentEnergy.FromVoltampereHours(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs
index ea53ccfbd9..45290960f1 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs
@@ -42,52 +42,52 @@ public static class NumberToElectricApparentPowerExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricApparentPower.FromGigavoltamperes(double)" />
+            /// <inheritdoc cref="ElectricApparentPower.FromGigavoltamperes(QuantityValue)" />
             public ElectricApparentPower Gigavoltamperes
 #if NET7_0_OR_GREATER
-                => ElectricApparentPower.FromGigavoltamperes(double.CreateChecked(value));
+                => ElectricApparentPower.FromGigavoltamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricApparentPower.FromGigavoltamperes(value.ToDouble(null));
+                => ElectricApparentPower.FromGigavoltamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricApparentPower.FromKilovoltamperes(double)" />
+            /// <inheritdoc cref="ElectricApparentPower.FromKilovoltamperes(QuantityValue)" />
             public ElectricApparentPower Kilovoltamperes
 #if NET7_0_OR_GREATER
-                => ElectricApparentPower.FromKilovoltamperes(double.CreateChecked(value));
+                => ElectricApparentPower.FromKilovoltamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricApparentPower.FromKilovoltamperes(value.ToDouble(null));
+                => ElectricApparentPower.FromKilovoltamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricApparentPower.FromMegavoltamperes(double)" />
+            /// <inheritdoc cref="ElectricApparentPower.FromMegavoltamperes(QuantityValue)" />
             public ElectricApparentPower Megavoltamperes
 #if NET7_0_OR_GREATER
-                => ElectricApparentPower.FromMegavoltamperes(double.CreateChecked(value));
+                => ElectricApparentPower.FromMegavoltamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricApparentPower.FromMegavoltamperes(value.ToDouble(null));
+                => ElectricApparentPower.FromMegavoltamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricApparentPower.FromMicrovoltamperes(double)" />
+            /// <inheritdoc cref="ElectricApparentPower.FromMicrovoltamperes(QuantityValue)" />
             public ElectricApparentPower Microvoltamperes
 #if NET7_0_OR_GREATER
-                => ElectricApparentPower.FromMicrovoltamperes(double.CreateChecked(value));
+                => ElectricApparentPower.FromMicrovoltamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricApparentPower.FromMicrovoltamperes(value.ToDouble(null));
+                => ElectricApparentPower.FromMicrovoltamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricApparentPower.FromMillivoltamperes(double)" />
+            /// <inheritdoc cref="ElectricApparentPower.FromMillivoltamperes(QuantityValue)" />
             public ElectricApparentPower Millivoltamperes
 #if NET7_0_OR_GREATER
-                => ElectricApparentPower.FromMillivoltamperes(double.CreateChecked(value));
+                => ElectricApparentPower.FromMillivoltamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricApparentPower.FromMillivoltamperes(value.ToDouble(null));
+                => ElectricApparentPower.FromMillivoltamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricApparentPower.FromVoltamperes(double)" />
+            /// <inheritdoc cref="ElectricApparentPower.FromVoltamperes(QuantityValue)" />
             public ElectricApparentPower Voltamperes
 #if NET7_0_OR_GREATER
-                => ElectricApparentPower.FromVoltamperes(double.CreateChecked(value));
+                => ElectricApparentPower.FromVoltamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricApparentPower.FromVoltamperes(value.ToDouble(null));
+                => ElectricApparentPower.FromVoltamperes(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs
index 31cb55f95e..b596ba128e 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs
@@ -42,60 +42,60 @@ public static class NumberToElectricCapacitanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricCapacitance.FromFarads(double)" />
+            /// <inheritdoc cref="ElectricCapacitance.FromFarads(QuantityValue)" />
             public ElectricCapacitance Farads
 #if NET7_0_OR_GREATER
-                => ElectricCapacitance.FromFarads(double.CreateChecked(value));
+                => ElectricCapacitance.FromFarads(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCapacitance.FromFarads(value.ToDouble(null));
+                => ElectricCapacitance.FromFarads(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCapacitance.FromKilofarads(double)" />
+            /// <inheritdoc cref="ElectricCapacitance.FromKilofarads(QuantityValue)" />
             public ElectricCapacitance Kilofarads
 #if NET7_0_OR_GREATER
-                => ElectricCapacitance.FromKilofarads(double.CreateChecked(value));
+                => ElectricCapacitance.FromKilofarads(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCapacitance.FromKilofarads(value.ToDouble(null));
+                => ElectricCapacitance.FromKilofarads(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCapacitance.FromMegafarads(double)" />
+            /// <inheritdoc cref="ElectricCapacitance.FromMegafarads(QuantityValue)" />
             public ElectricCapacitance Megafarads
 #if NET7_0_OR_GREATER
-                => ElectricCapacitance.FromMegafarads(double.CreateChecked(value));
+                => ElectricCapacitance.FromMegafarads(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCapacitance.FromMegafarads(value.ToDouble(null));
+                => ElectricCapacitance.FromMegafarads(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCapacitance.FromMicrofarads(double)" />
+            /// <inheritdoc cref="ElectricCapacitance.FromMicrofarads(QuantityValue)" />
             public ElectricCapacitance Microfarads
 #if NET7_0_OR_GREATER
-                => ElectricCapacitance.FromMicrofarads(double.CreateChecked(value));
+                => ElectricCapacitance.FromMicrofarads(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCapacitance.FromMicrofarads(value.ToDouble(null));
+                => ElectricCapacitance.FromMicrofarads(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCapacitance.FromMillifarads(double)" />
+            /// <inheritdoc cref="ElectricCapacitance.FromMillifarads(QuantityValue)" />
             public ElectricCapacitance Millifarads
 #if NET7_0_OR_GREATER
-                => ElectricCapacitance.FromMillifarads(double.CreateChecked(value));
+                => ElectricCapacitance.FromMillifarads(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCapacitance.FromMillifarads(value.ToDouble(null));
+                => ElectricCapacitance.FromMillifarads(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCapacitance.FromNanofarads(double)" />
+            /// <inheritdoc cref="ElectricCapacitance.FromNanofarads(QuantityValue)" />
             public ElectricCapacitance Nanofarads
 #if NET7_0_OR_GREATER
-                => ElectricCapacitance.FromNanofarads(double.CreateChecked(value));
+                => ElectricCapacitance.FromNanofarads(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCapacitance.FromNanofarads(value.ToDouble(null));
+                => ElectricCapacitance.FromNanofarads(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCapacitance.FromPicofarads(double)" />
+            /// <inheritdoc cref="ElectricCapacitance.FromPicofarads(QuantityValue)" />
             public ElectricCapacitance Picofarads
 #if NET7_0_OR_GREATER
-                => ElectricCapacitance.FromPicofarads(double.CreateChecked(value));
+                => ElectricCapacitance.FromPicofarads(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCapacitance.FromPicofarads(value.ToDouble(null));
+                => ElectricCapacitance.FromPicofarads(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
index 3fd2e2b553..c2ef0e7fe0 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToElectricChargeDensityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricChargeDensity.FromCoulombsPerCubicMeter(double)" />
+            /// <inheritdoc cref="ElectricChargeDensity.FromCoulombsPerCubicMeter(QuantityValue)" />
             public ElectricChargeDensity CoulombsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => ElectricChargeDensity.FromCoulombsPerCubicMeter(double.CreateChecked(value));
+                => ElectricChargeDensity.FromCoulombsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricChargeDensity.FromCoulombsPerCubicMeter(value.ToDouble(null));
+                => ElectricChargeDensity.FromCoulombsPerCubicMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeExtensions.g.cs
index 0c6dbc79e1..e5a392c325 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeExtensions.g.cs
@@ -42,92 +42,92 @@ public static class NumberToElectricChargeExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricCharge.FromAmpereHours(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromAmpereHours(QuantityValue)" />
             public ElectricCharge AmpereHours
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromAmpereHours(double.CreateChecked(value));
+                => ElectricCharge.FromAmpereHours(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromAmpereHours(value.ToDouble(null));
+                => ElectricCharge.FromAmpereHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCharge.FromCoulombs(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromCoulombs(QuantityValue)" />
             public ElectricCharge Coulombs
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromCoulombs(double.CreateChecked(value));
+                => ElectricCharge.FromCoulombs(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromCoulombs(value.ToDouble(null));
+                => ElectricCharge.FromCoulombs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCharge.FromKiloampereHours(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromKiloampereHours(QuantityValue)" />
             public ElectricCharge KiloampereHours
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromKiloampereHours(double.CreateChecked(value));
+                => ElectricCharge.FromKiloampereHours(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromKiloampereHours(value.ToDouble(null));
+                => ElectricCharge.FromKiloampereHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCharge.FromKilocoulombs(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromKilocoulombs(QuantityValue)" />
             public ElectricCharge Kilocoulombs
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromKilocoulombs(double.CreateChecked(value));
+                => ElectricCharge.FromKilocoulombs(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromKilocoulombs(value.ToDouble(null));
+                => ElectricCharge.FromKilocoulombs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCharge.FromMegaampereHours(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromMegaampereHours(QuantityValue)" />
             public ElectricCharge MegaampereHours
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromMegaampereHours(double.CreateChecked(value));
+                => ElectricCharge.FromMegaampereHours(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromMegaampereHours(value.ToDouble(null));
+                => ElectricCharge.FromMegaampereHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCharge.FromMegacoulombs(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromMegacoulombs(QuantityValue)" />
             public ElectricCharge Megacoulombs
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromMegacoulombs(double.CreateChecked(value));
+                => ElectricCharge.FromMegacoulombs(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromMegacoulombs(value.ToDouble(null));
+                => ElectricCharge.FromMegacoulombs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCharge.FromMicrocoulombs(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromMicrocoulombs(QuantityValue)" />
             public ElectricCharge Microcoulombs
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromMicrocoulombs(double.CreateChecked(value));
+                => ElectricCharge.FromMicrocoulombs(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromMicrocoulombs(value.ToDouble(null));
+                => ElectricCharge.FromMicrocoulombs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCharge.FromMilliampereHours(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromMilliampereHours(QuantityValue)" />
             public ElectricCharge MilliampereHours
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromMilliampereHours(double.CreateChecked(value));
+                => ElectricCharge.FromMilliampereHours(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromMilliampereHours(value.ToDouble(null));
+                => ElectricCharge.FromMilliampereHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCharge.FromMillicoulombs(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromMillicoulombs(QuantityValue)" />
             public ElectricCharge Millicoulombs
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromMillicoulombs(double.CreateChecked(value));
+                => ElectricCharge.FromMillicoulombs(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromMillicoulombs(value.ToDouble(null));
+                => ElectricCharge.FromMillicoulombs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCharge.FromNanocoulombs(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromNanocoulombs(QuantityValue)" />
             public ElectricCharge Nanocoulombs
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromNanocoulombs(double.CreateChecked(value));
+                => ElectricCharge.FromNanocoulombs(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromNanocoulombs(value.ToDouble(null));
+                => ElectricCharge.FromNanocoulombs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCharge.FromPicocoulombs(double)" />
+            /// <inheritdoc cref="ElectricCharge.FromPicocoulombs(QuantityValue)" />
             public ElectricCharge Picocoulombs
 #if NET7_0_OR_GREATER
-                => ElectricCharge.FromPicocoulombs(double.CreateChecked(value));
+                => ElectricCharge.FromPicocoulombs(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCharge.FromPicocoulombs(value.ToDouble(null));
+                => ElectricCharge.FromPicocoulombs(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
index 601f3ced2e..be1500a121 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
@@ -42,132 +42,132 @@ public static class NumberToElectricConductanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricConductance.FromGigamhos(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromGigamhos(QuantityValue)" />
             public ElectricConductance Gigamhos
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromGigamhos(double.CreateChecked(value));
+                => ElectricConductance.FromGigamhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromGigamhos(value.ToDouble(null));
+                => ElectricConductance.FromGigamhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromGigasiemens(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromGigasiemens(QuantityValue)" />
             public ElectricConductance Gigasiemens
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromGigasiemens(double.CreateChecked(value));
+                => ElectricConductance.FromGigasiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromGigasiemens(value.ToDouble(null));
+                => ElectricConductance.FromGigasiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromKilomhos(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromKilomhos(QuantityValue)" />
             public ElectricConductance Kilomhos
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromKilomhos(double.CreateChecked(value));
+                => ElectricConductance.FromKilomhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromKilomhos(value.ToDouble(null));
+                => ElectricConductance.FromKilomhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromKilosiemens(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromKilosiemens(QuantityValue)" />
             public ElectricConductance Kilosiemens
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromKilosiemens(double.CreateChecked(value));
+                => ElectricConductance.FromKilosiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromKilosiemens(value.ToDouble(null));
+                => ElectricConductance.FromKilosiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromMegamhos(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromMegamhos(QuantityValue)" />
             public ElectricConductance Megamhos
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromMegamhos(double.CreateChecked(value));
+                => ElectricConductance.FromMegamhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromMegamhos(value.ToDouble(null));
+                => ElectricConductance.FromMegamhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromMegasiemens(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromMegasiemens(QuantityValue)" />
             public ElectricConductance Megasiemens
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromMegasiemens(double.CreateChecked(value));
+                => ElectricConductance.FromMegasiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromMegasiemens(value.ToDouble(null));
+                => ElectricConductance.FromMegasiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromMhos(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromMhos(QuantityValue)" />
             public ElectricConductance Mhos
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromMhos(double.CreateChecked(value));
+                => ElectricConductance.FromMhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromMhos(value.ToDouble(null));
+                => ElectricConductance.FromMhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromMicromhos(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromMicromhos(QuantityValue)" />
             public ElectricConductance Micromhos
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromMicromhos(double.CreateChecked(value));
+                => ElectricConductance.FromMicromhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromMicromhos(value.ToDouble(null));
+                => ElectricConductance.FromMicromhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromMicrosiemens(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromMicrosiemens(QuantityValue)" />
             public ElectricConductance Microsiemens
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromMicrosiemens(double.CreateChecked(value));
+                => ElectricConductance.FromMicrosiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromMicrosiemens(value.ToDouble(null));
+                => ElectricConductance.FromMicrosiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromMillimhos(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromMillimhos(QuantityValue)" />
             public ElectricConductance Millimhos
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromMillimhos(double.CreateChecked(value));
+                => ElectricConductance.FromMillimhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromMillimhos(value.ToDouble(null));
+                => ElectricConductance.FromMillimhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromMillisiemens(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromMillisiemens(QuantityValue)" />
             public ElectricConductance Millisiemens
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromMillisiemens(double.CreateChecked(value));
+                => ElectricConductance.FromMillisiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromMillisiemens(value.ToDouble(null));
+                => ElectricConductance.FromMillisiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromNanomhos(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromNanomhos(QuantityValue)" />
             public ElectricConductance Nanomhos
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromNanomhos(double.CreateChecked(value));
+                => ElectricConductance.FromNanomhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromNanomhos(value.ToDouble(null));
+                => ElectricConductance.FromNanomhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromNanosiemens(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromNanosiemens(QuantityValue)" />
             public ElectricConductance Nanosiemens
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromNanosiemens(double.CreateChecked(value));
+                => ElectricConductance.FromNanosiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromNanosiemens(value.ToDouble(null));
+                => ElectricConductance.FromNanosiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromSiemens(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromSiemens(QuantityValue)" />
             public ElectricConductance Siemens
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromSiemens(double.CreateChecked(value));
+                => ElectricConductance.FromSiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromSiemens(value.ToDouble(null));
+                => ElectricConductance.FromSiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromTeramhos(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromTeramhos(QuantityValue)" />
             public ElectricConductance Teramhos
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromTeramhos(double.CreateChecked(value));
+                => ElectricConductance.FromTeramhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromTeramhos(value.ToDouble(null));
+                => ElectricConductance.FromTeramhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductance.FromTerasiemens(double)" />
+            /// <inheritdoc cref="ElectricConductance.FromTerasiemens(QuantityValue)" />
             public ElectricConductance Terasiemens
 #if NET7_0_OR_GREATER
-                => ElectricConductance.FromTerasiemens(double.CreateChecked(value));
+                => ElectricConductance.FromTerasiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductance.FromTerasiemens(value.ToDouble(null));
+                => ElectricConductance.FromTerasiemens(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductivityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
index 771194c184..64e1a58503 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
@@ -42,52 +42,52 @@ public static class NumberToElectricConductivityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricConductivity.FromMicrosiemensPerCentimeter(double)" />
+            /// <inheritdoc cref="ElectricConductivity.FromMicrosiemensPerCentimeter(QuantityValue)" />
             public ElectricConductivity MicrosiemensPerCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricConductivity.FromMicrosiemensPerCentimeter(double.CreateChecked(value));
+                => ElectricConductivity.FromMicrosiemensPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductivity.FromMicrosiemensPerCentimeter(value.ToDouble(null));
+                => ElectricConductivity.FromMicrosiemensPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductivity.FromMillisiemensPerCentimeter(double)" />
+            /// <inheritdoc cref="ElectricConductivity.FromMillisiemensPerCentimeter(QuantityValue)" />
             public ElectricConductivity MillisiemensPerCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricConductivity.FromMillisiemensPerCentimeter(double.CreateChecked(value));
+                => ElectricConductivity.FromMillisiemensPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductivity.FromMillisiemensPerCentimeter(value.ToDouble(null));
+                => ElectricConductivity.FromMillisiemensPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductivity.FromSiemensPerCentimeter(double)" />
+            /// <inheritdoc cref="ElectricConductivity.FromSiemensPerCentimeter(QuantityValue)" />
             public ElectricConductivity SiemensPerCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricConductivity.FromSiemensPerCentimeter(double.CreateChecked(value));
+                => ElectricConductivity.FromSiemensPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductivity.FromSiemensPerCentimeter(value.ToDouble(null));
+                => ElectricConductivity.FromSiemensPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductivity.FromSiemensPerFoot(double)" />
+            /// <inheritdoc cref="ElectricConductivity.FromSiemensPerFoot(QuantityValue)" />
             public ElectricConductivity SiemensPerFoot
 #if NET7_0_OR_GREATER
-                => ElectricConductivity.FromSiemensPerFoot(double.CreateChecked(value));
+                => ElectricConductivity.FromSiemensPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductivity.FromSiemensPerFoot(value.ToDouble(null));
+                => ElectricConductivity.FromSiemensPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductivity.FromSiemensPerInch(double)" />
+            /// <inheritdoc cref="ElectricConductivity.FromSiemensPerInch(QuantityValue)" />
             public ElectricConductivity SiemensPerInch
 #if NET7_0_OR_GREATER
-                => ElectricConductivity.FromSiemensPerInch(double.CreateChecked(value));
+                => ElectricConductivity.FromSiemensPerInch(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductivity.FromSiemensPerInch(value.ToDouble(null));
+                => ElectricConductivity.FromSiemensPerInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricConductivity.FromSiemensPerMeter(double)" />
+            /// <inheritdoc cref="ElectricConductivity.FromSiemensPerMeter(QuantityValue)" />
             public ElectricConductivity SiemensPerMeter
 #if NET7_0_OR_GREATER
-                => ElectricConductivity.FromSiemensPerMeter(double.CreateChecked(value));
+                => ElectricConductivity.FromSiemensPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricConductivity.FromSiemensPerMeter(value.ToDouble(null));
+                => ElectricConductivity.FromSiemensPerMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
index f52bd339c7..53d1a53ade 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
@@ -42,28 +42,28 @@ public static class NumberToElectricCurrentDensityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareFoot(double)" />
+            /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareFoot(QuantityValue)" />
             public ElectricCurrentDensity AmperesPerSquareFoot
 #if NET7_0_OR_GREATER
-                => ElectricCurrentDensity.FromAmperesPerSquareFoot(double.CreateChecked(value));
+                => ElectricCurrentDensity.FromAmperesPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrentDensity.FromAmperesPerSquareFoot(value.ToDouble(null));
+                => ElectricCurrentDensity.FromAmperesPerSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareInch(double)" />
+            /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareInch(QuantityValue)" />
             public ElectricCurrentDensity AmperesPerSquareInch
 #if NET7_0_OR_GREATER
-                => ElectricCurrentDensity.FromAmperesPerSquareInch(double.CreateChecked(value));
+                => ElectricCurrentDensity.FromAmperesPerSquareInch(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrentDensity.FromAmperesPerSquareInch(value.ToDouble(null));
+                => ElectricCurrentDensity.FromAmperesPerSquareInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareMeter(double)" />
+            /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareMeter(QuantityValue)" />
             public ElectricCurrentDensity AmperesPerSquareMeter
 #if NET7_0_OR_GREATER
-                => ElectricCurrentDensity.FromAmperesPerSquareMeter(double.CreateChecked(value));
+                => ElectricCurrentDensity.FromAmperesPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrentDensity.FromAmperesPerSquareMeter(value.ToDouble(null));
+                => ElectricCurrentDensity.FromAmperesPerSquareMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
index e2353cc400..610741ec88 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
@@ -42,76 +42,76 @@ public static class NumberToElectricCurrentExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricCurrent.FromAmperes(double)" />
+            /// <inheritdoc cref="ElectricCurrent.FromAmperes(QuantityValue)" />
             public ElectricCurrent Amperes
 #if NET7_0_OR_GREATER
-                => ElectricCurrent.FromAmperes(double.CreateChecked(value));
+                => ElectricCurrent.FromAmperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrent.FromAmperes(value.ToDouble(null));
+                => ElectricCurrent.FromAmperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrent.FromCentiamperes(double)" />
+            /// <inheritdoc cref="ElectricCurrent.FromCentiamperes(QuantityValue)" />
             public ElectricCurrent Centiamperes
 #if NET7_0_OR_GREATER
-                => ElectricCurrent.FromCentiamperes(double.CreateChecked(value));
+                => ElectricCurrent.FromCentiamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrent.FromCentiamperes(value.ToDouble(null));
+                => ElectricCurrent.FromCentiamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrent.FromFemtoamperes(double)" />
+            /// <inheritdoc cref="ElectricCurrent.FromFemtoamperes(QuantityValue)" />
             public ElectricCurrent Femtoamperes
 #if NET7_0_OR_GREATER
-                => ElectricCurrent.FromFemtoamperes(double.CreateChecked(value));
+                => ElectricCurrent.FromFemtoamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrent.FromFemtoamperes(value.ToDouble(null));
+                => ElectricCurrent.FromFemtoamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrent.FromKiloamperes(double)" />
+            /// <inheritdoc cref="ElectricCurrent.FromKiloamperes(QuantityValue)" />
             public ElectricCurrent Kiloamperes
 #if NET7_0_OR_GREATER
-                => ElectricCurrent.FromKiloamperes(double.CreateChecked(value));
+                => ElectricCurrent.FromKiloamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrent.FromKiloamperes(value.ToDouble(null));
+                => ElectricCurrent.FromKiloamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrent.FromMegaamperes(double)" />
+            /// <inheritdoc cref="ElectricCurrent.FromMegaamperes(QuantityValue)" />
             public ElectricCurrent Megaamperes
 #if NET7_0_OR_GREATER
-                => ElectricCurrent.FromMegaamperes(double.CreateChecked(value));
+                => ElectricCurrent.FromMegaamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrent.FromMegaamperes(value.ToDouble(null));
+                => ElectricCurrent.FromMegaamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrent.FromMicroamperes(double)" />
+            /// <inheritdoc cref="ElectricCurrent.FromMicroamperes(QuantityValue)" />
             public ElectricCurrent Microamperes
 #if NET7_0_OR_GREATER
-                => ElectricCurrent.FromMicroamperes(double.CreateChecked(value));
+                => ElectricCurrent.FromMicroamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrent.FromMicroamperes(value.ToDouble(null));
+                => ElectricCurrent.FromMicroamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrent.FromMilliamperes(double)" />
+            /// <inheritdoc cref="ElectricCurrent.FromMilliamperes(QuantityValue)" />
             public ElectricCurrent Milliamperes
 #if NET7_0_OR_GREATER
-                => ElectricCurrent.FromMilliamperes(double.CreateChecked(value));
+                => ElectricCurrent.FromMilliamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrent.FromMilliamperes(value.ToDouble(null));
+                => ElectricCurrent.FromMilliamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrent.FromNanoamperes(double)" />
+            /// <inheritdoc cref="ElectricCurrent.FromNanoamperes(QuantityValue)" />
             public ElectricCurrent Nanoamperes
 #if NET7_0_OR_GREATER
-                => ElectricCurrent.FromNanoamperes(double.CreateChecked(value));
+                => ElectricCurrent.FromNanoamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrent.FromNanoamperes(value.ToDouble(null));
+                => ElectricCurrent.FromNanoamperes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrent.FromPicoamperes(double)" />
+            /// <inheritdoc cref="ElectricCurrent.FromPicoamperes(QuantityValue)" />
             public ElectricCurrent Picoamperes
 #if NET7_0_OR_GREATER
-                => ElectricCurrent.FromPicoamperes(double.CreateChecked(value));
+                => ElectricCurrent.FromPicoamperes(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrent.FromPicoamperes(value.ToDouble(null));
+                => ElectricCurrent.FromPicoamperes(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
index 92759d3167..6956f1176f 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
@@ -42,60 +42,60 @@ public static class NumberToElectricCurrentGradientExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMicrosecond(double)" />
+            /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMicrosecond(QuantityValue)" />
             public ElectricCurrentGradient AmperesPerMicrosecond
 #if NET7_0_OR_GREATER
-                => ElectricCurrentGradient.FromAmperesPerMicrosecond(double.CreateChecked(value));
+                => ElectricCurrentGradient.FromAmperesPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrentGradient.FromAmperesPerMicrosecond(value.ToDouble(null));
+                => ElectricCurrentGradient.FromAmperesPerMicrosecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMillisecond(double)" />
+            /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMillisecond(QuantityValue)" />
             public ElectricCurrentGradient AmperesPerMillisecond
 #if NET7_0_OR_GREATER
-                => ElectricCurrentGradient.FromAmperesPerMillisecond(double.CreateChecked(value));
+                => ElectricCurrentGradient.FromAmperesPerMillisecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrentGradient.FromAmperesPerMillisecond(value.ToDouble(null));
+                => ElectricCurrentGradient.FromAmperesPerMillisecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMinute(double)" />
+            /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMinute(QuantityValue)" />
             public ElectricCurrentGradient AmperesPerMinute
 #if NET7_0_OR_GREATER
-                => ElectricCurrentGradient.FromAmperesPerMinute(double.CreateChecked(value));
+                => ElectricCurrentGradient.FromAmperesPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrentGradient.FromAmperesPerMinute(value.ToDouble(null));
+                => ElectricCurrentGradient.FromAmperesPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerNanosecond(double)" />
+            /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerNanosecond(QuantityValue)" />
             public ElectricCurrentGradient AmperesPerNanosecond
 #if NET7_0_OR_GREATER
-                => ElectricCurrentGradient.FromAmperesPerNanosecond(double.CreateChecked(value));
+                => ElectricCurrentGradient.FromAmperesPerNanosecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrentGradient.FromAmperesPerNanosecond(value.ToDouble(null));
+                => ElectricCurrentGradient.FromAmperesPerNanosecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerSecond(double)" />
+            /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerSecond(QuantityValue)" />
             public ElectricCurrentGradient AmperesPerSecond
 #if NET7_0_OR_GREATER
-                => ElectricCurrentGradient.FromAmperesPerSecond(double.CreateChecked(value));
+                => ElectricCurrentGradient.FromAmperesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrentGradient.FromAmperesPerSecond(value.ToDouble(null));
+                => ElectricCurrentGradient.FromAmperesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerMinute(double)" />
+            /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerMinute(QuantityValue)" />
             public ElectricCurrentGradient MilliamperesPerMinute
 #if NET7_0_OR_GREATER
-                => ElectricCurrentGradient.FromMilliamperesPerMinute(double.CreateChecked(value));
+                => ElectricCurrentGradient.FromMilliamperesPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrentGradient.FromMilliamperesPerMinute(value.ToDouble(null));
+                => ElectricCurrentGradient.FromMilliamperesPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerSecond(double)" />
+            /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerSecond(QuantityValue)" />
             public ElectricCurrentGradient MilliamperesPerSecond
 #if NET7_0_OR_GREATER
-                => ElectricCurrentGradient.FromMilliamperesPerSecond(double.CreateChecked(value));
+                => ElectricCurrentGradient.FromMilliamperesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricCurrentGradient.FromMilliamperesPerSecond(value.ToDouble(null));
+                => ElectricCurrentGradient.FromMilliamperesPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricFieldExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricFieldExtensions.g.cs
index 37d5db5a71..7bf840d909 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricFieldExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricFieldExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToElectricFieldExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricField.FromVoltsPerMeter(double)" />
+            /// <inheritdoc cref="ElectricField.FromVoltsPerMeter(QuantityValue)" />
             public ElectricField VoltsPerMeter
 #if NET7_0_OR_GREATER
-                => ElectricField.FromVoltsPerMeter(double.CreateChecked(value));
+                => ElectricField.FromVoltsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricField.FromVoltsPerMeter(value.ToDouble(null));
+                => ElectricField.FromVoltsPerMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs
index 9f93ae72b0..ba5cb7b8e5 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs
@@ -43,76 +43,76 @@ public static class NumberToElectricImpedanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricImpedance.FromGigaohms(double)" />
+            /// <inheritdoc cref="ElectricImpedance.FromGigaohms(QuantityValue)" />
             [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
             public ElectricImpedance Gigaohms
 #if NET7_0_OR_GREATER
-                => ElectricImpedance.FromGigaohms(double.CreateChecked(value));
+                => ElectricImpedance.FromGigaohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricImpedance.FromGigaohms(value.ToDouble(null));
+                => ElectricImpedance.FromGigaohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricImpedance.FromKiloohms(double)" />
+            /// <inheritdoc cref="ElectricImpedance.FromKiloohms(QuantityValue)" />
             [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
             public ElectricImpedance Kiloohms
 #if NET7_0_OR_GREATER
-                => ElectricImpedance.FromKiloohms(double.CreateChecked(value));
+                => ElectricImpedance.FromKiloohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricImpedance.FromKiloohms(value.ToDouble(null));
+                => ElectricImpedance.FromKiloohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricImpedance.FromMegaohms(double)" />
+            /// <inheritdoc cref="ElectricImpedance.FromMegaohms(QuantityValue)" />
             [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
             public ElectricImpedance Megaohms
 #if NET7_0_OR_GREATER
-                => ElectricImpedance.FromMegaohms(double.CreateChecked(value));
+                => ElectricImpedance.FromMegaohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricImpedance.FromMegaohms(value.ToDouble(null));
+                => ElectricImpedance.FromMegaohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricImpedance.FromMicroohms(double)" />
+            /// <inheritdoc cref="ElectricImpedance.FromMicroohms(QuantityValue)" />
             [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
             public ElectricImpedance Microohms
 #if NET7_0_OR_GREATER
-                => ElectricImpedance.FromMicroohms(double.CreateChecked(value));
+                => ElectricImpedance.FromMicroohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricImpedance.FromMicroohms(value.ToDouble(null));
+                => ElectricImpedance.FromMicroohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricImpedance.FromMilliohms(double)" />
+            /// <inheritdoc cref="ElectricImpedance.FromMilliohms(QuantityValue)" />
             [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
             public ElectricImpedance Milliohms
 #if NET7_0_OR_GREATER
-                => ElectricImpedance.FromMilliohms(double.CreateChecked(value));
+                => ElectricImpedance.FromMilliohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricImpedance.FromMilliohms(value.ToDouble(null));
+                => ElectricImpedance.FromMilliohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricImpedance.FromNanoohms(double)" />
+            /// <inheritdoc cref="ElectricImpedance.FromNanoohms(QuantityValue)" />
             [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
             public ElectricImpedance Nanoohms
 #if NET7_0_OR_GREATER
-                => ElectricImpedance.FromNanoohms(double.CreateChecked(value));
+                => ElectricImpedance.FromNanoohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricImpedance.FromNanoohms(value.ToDouble(null));
+                => ElectricImpedance.FromNanoohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricImpedance.FromOhms(double)" />
+            /// <inheritdoc cref="ElectricImpedance.FromOhms(QuantityValue)" />
             [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
             public ElectricImpedance Ohms
 #if NET7_0_OR_GREATER
-                => ElectricImpedance.FromOhms(double.CreateChecked(value));
+                => ElectricImpedance.FromOhms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricImpedance.FromOhms(value.ToDouble(null));
+                => ElectricImpedance.FromOhms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricImpedance.FromTeraohms(double)" />
+            /// <inheritdoc cref="ElectricImpedance.FromTeraohms(QuantityValue)" />
             [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
             public ElectricImpedance Teraohms
 #if NET7_0_OR_GREATER
-                => ElectricImpedance.FromTeraohms(double.CreateChecked(value));
+                => ElectricImpedance.FromTeraohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricImpedance.FromTeraohms(value.ToDouble(null));
+                => ElectricImpedance.FromTeraohms(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricInductanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
index 88cacce674..bade074d3a 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
@@ -42,44 +42,44 @@ public static class NumberToElectricInductanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricInductance.FromHenries(double)" />
+            /// <inheritdoc cref="ElectricInductance.FromHenries(QuantityValue)" />
             public ElectricInductance Henries
 #if NET7_0_OR_GREATER
-                => ElectricInductance.FromHenries(double.CreateChecked(value));
+                => ElectricInductance.FromHenries(QuantityValue.CreateChecked(value));
 #else
-                => ElectricInductance.FromHenries(value.ToDouble(null));
+                => ElectricInductance.FromHenries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricInductance.FromMicrohenries(double)" />
+            /// <inheritdoc cref="ElectricInductance.FromMicrohenries(QuantityValue)" />
             public ElectricInductance Microhenries
 #if NET7_0_OR_GREATER
-                => ElectricInductance.FromMicrohenries(double.CreateChecked(value));
+                => ElectricInductance.FromMicrohenries(QuantityValue.CreateChecked(value));
 #else
-                => ElectricInductance.FromMicrohenries(value.ToDouble(null));
+                => ElectricInductance.FromMicrohenries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricInductance.FromMillihenries(double)" />
+            /// <inheritdoc cref="ElectricInductance.FromMillihenries(QuantityValue)" />
             public ElectricInductance Millihenries
 #if NET7_0_OR_GREATER
-                => ElectricInductance.FromMillihenries(double.CreateChecked(value));
+                => ElectricInductance.FromMillihenries(QuantityValue.CreateChecked(value));
 #else
-                => ElectricInductance.FromMillihenries(value.ToDouble(null));
+                => ElectricInductance.FromMillihenries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricInductance.FromNanohenries(double)" />
+            /// <inheritdoc cref="ElectricInductance.FromNanohenries(QuantityValue)" />
             public ElectricInductance Nanohenries
 #if NET7_0_OR_GREATER
-                => ElectricInductance.FromNanohenries(double.CreateChecked(value));
+                => ElectricInductance.FromNanohenries(QuantityValue.CreateChecked(value));
 #else
-                => ElectricInductance.FromNanohenries(value.ToDouble(null));
+                => ElectricInductance.FromNanohenries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricInductance.FromPicohenries(double)" />
+            /// <inheritdoc cref="ElectricInductance.FromPicohenries(QuantityValue)" />
             public ElectricInductance Picohenries
 #if NET7_0_OR_GREATER
-                => ElectricInductance.FromPicohenries(double.CreateChecked(value));
+                => ElectricInductance.FromPicohenries(QuantityValue.CreateChecked(value));
 #else
-                => ElectricInductance.FromPicohenries(value.ToDouble(null));
+                => ElectricInductance.FromPicohenries(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
index a5fe74376c..5866986893 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
@@ -42,164 +42,164 @@ public static class NumberToElectricPotentialChangeRateExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerHour(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerHour(QuantityValue)" />
             public ElectricPotentialChangeRate KilovoltsPerHour
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromKilovoltsPerHour(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromKilovoltsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromKilovoltsPerHour(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromKilovoltsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(QuantityValue)" />
             public ElectricPotentialChangeRate KilovoltsPerMicrosecond
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMinute(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMinute(QuantityValue)" />
             public ElectricPotentialChangeRate KilovoltsPerMinute
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromKilovoltsPerMinute(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromKilovoltsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromKilovoltsPerMinute(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromKilovoltsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerSecond(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerSecond(QuantityValue)" />
             public ElectricPotentialChangeRate KilovoltsPerSecond
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromKilovoltsPerSecond(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromKilovoltsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromKilovoltsPerSecond(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromKilovoltsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerHour(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerHour(QuantityValue)" />
             public ElectricPotentialChangeRate MegavoltsPerHour
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMegavoltsPerHour(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMegavoltsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMegavoltsPerHour(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMegavoltsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(QuantityValue)" />
             public ElectricPotentialChangeRate MegavoltsPerMicrosecond
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMinute(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMinute(QuantityValue)" />
             public ElectricPotentialChangeRate MegavoltsPerMinute
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMegavoltsPerMinute(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMegavoltsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMegavoltsPerMinute(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMegavoltsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerSecond(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerSecond(QuantityValue)" />
             public ElectricPotentialChangeRate MegavoltsPerSecond
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMegavoltsPerSecond(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMegavoltsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMegavoltsPerSecond(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMegavoltsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerHour(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerHour(QuantityValue)" />
             public ElectricPotentialChangeRate MicrovoltsPerHour
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMicrovoltsPerHour(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMicrovoltsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMicrovoltsPerHour(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMicrovoltsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(QuantityValue)" />
             public ElectricPotentialChangeRate MicrovoltsPerMicrosecond
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMinute(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMinute(QuantityValue)" />
             public ElectricPotentialChangeRate MicrovoltsPerMinute
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerSecond(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerSecond(QuantityValue)" />
             public ElectricPotentialChangeRate MicrovoltsPerSecond
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerHour(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerHour(QuantityValue)" />
             public ElectricPotentialChangeRate MillivoltsPerHour
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMillivoltsPerHour(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMillivoltsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMillivoltsPerHour(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMillivoltsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(QuantityValue)" />
             public ElectricPotentialChangeRate MillivoltsPerMicrosecond
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMinute(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMinute(QuantityValue)" />
             public ElectricPotentialChangeRate MillivoltsPerMinute
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMillivoltsPerMinute(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMillivoltsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMillivoltsPerMinute(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMillivoltsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerSecond(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerSecond(QuantityValue)" />
             public ElectricPotentialChangeRate MillivoltsPerSecond
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromMillivoltsPerSecond(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromMillivoltsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromMillivoltsPerSecond(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromMillivoltsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerHour(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerHour(QuantityValue)" />
             public ElectricPotentialChangeRate VoltsPerHour
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromVoltsPerHour(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromVoltsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromVoltsPerHour(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromVoltsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMicrosecond(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMicrosecond(QuantityValue)" />
             public ElectricPotentialChangeRate VoltsPerMicrosecond
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMinute(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMinute(QuantityValue)" />
             public ElectricPotentialChangeRate VoltsPerMinute
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromVoltsPerMinute(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromVoltsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromVoltsPerMinute(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromVoltsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerSecond(double)" />
+            /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerSecond(QuantityValue)" />
             public ElectricPotentialChangeRate VoltsPerSecond
 #if NET7_0_OR_GREATER
-                => ElectricPotentialChangeRate.FromVoltsPerSecond(double.CreateChecked(value));
+                => ElectricPotentialChangeRate.FromVoltsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotentialChangeRate.FromVoltsPerSecond(value.ToDouble(null));
+                => ElectricPotentialChangeRate.FromVoltsPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
index eae86858a2..173cdc28e7 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
@@ -42,52 +42,52 @@ public static class NumberToElectricPotentialExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricPotential.FromKilovolts(double)" />
+            /// <inheritdoc cref="ElectricPotential.FromKilovolts(QuantityValue)" />
             public ElectricPotential Kilovolts
 #if NET7_0_OR_GREATER
-                => ElectricPotential.FromKilovolts(double.CreateChecked(value));
+                => ElectricPotential.FromKilovolts(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotential.FromKilovolts(value.ToDouble(null));
+                => ElectricPotential.FromKilovolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotential.FromMegavolts(double)" />
+            /// <inheritdoc cref="ElectricPotential.FromMegavolts(QuantityValue)" />
             public ElectricPotential Megavolts
 #if NET7_0_OR_GREATER
-                => ElectricPotential.FromMegavolts(double.CreateChecked(value));
+                => ElectricPotential.FromMegavolts(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotential.FromMegavolts(value.ToDouble(null));
+                => ElectricPotential.FromMegavolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotential.FromMicrovolts(double)" />
+            /// <inheritdoc cref="ElectricPotential.FromMicrovolts(QuantityValue)" />
             public ElectricPotential Microvolts
 #if NET7_0_OR_GREATER
-                => ElectricPotential.FromMicrovolts(double.CreateChecked(value));
+                => ElectricPotential.FromMicrovolts(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotential.FromMicrovolts(value.ToDouble(null));
+                => ElectricPotential.FromMicrovolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotential.FromMillivolts(double)" />
+            /// <inheritdoc cref="ElectricPotential.FromMillivolts(QuantityValue)" />
             public ElectricPotential Millivolts
 #if NET7_0_OR_GREATER
-                => ElectricPotential.FromMillivolts(double.CreateChecked(value));
+                => ElectricPotential.FromMillivolts(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotential.FromMillivolts(value.ToDouble(null));
+                => ElectricPotential.FromMillivolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotential.FromNanovolts(double)" />
+            /// <inheritdoc cref="ElectricPotential.FromNanovolts(QuantityValue)" />
             public ElectricPotential Nanovolts
 #if NET7_0_OR_GREATER
-                => ElectricPotential.FromNanovolts(double.CreateChecked(value));
+                => ElectricPotential.FromNanovolts(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotential.FromNanovolts(value.ToDouble(null));
+                => ElectricPotential.FromNanovolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricPotential.FromVolts(double)" />
+            /// <inheritdoc cref="ElectricPotential.FromVolts(QuantityValue)" />
             public ElectricPotential Volts
 #if NET7_0_OR_GREATER
-                => ElectricPotential.FromVolts(double.CreateChecked(value));
+                => ElectricPotential.FromVolts(QuantityValue.CreateChecked(value));
 #else
-                => ElectricPotential.FromVolts(value.ToDouble(null));
+                => ElectricPotential.FromVolts(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactanceExtensions.g.cs
index 2a615184b6..d07947839b 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactanceExtensions.g.cs
@@ -42,68 +42,68 @@ public static class NumberToElectricReactanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricReactance.FromGigaohms(double)" />
+            /// <inheritdoc cref="ElectricReactance.FromGigaohms(QuantityValue)" />
             public ElectricReactance Gigaohms
 #if NET7_0_OR_GREATER
-                => ElectricReactance.FromGigaohms(double.CreateChecked(value));
+                => ElectricReactance.FromGigaohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactance.FromGigaohms(value.ToDouble(null));
+                => ElectricReactance.FromGigaohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactance.FromKiloohms(double)" />
+            /// <inheritdoc cref="ElectricReactance.FromKiloohms(QuantityValue)" />
             public ElectricReactance Kiloohms
 #if NET7_0_OR_GREATER
-                => ElectricReactance.FromKiloohms(double.CreateChecked(value));
+                => ElectricReactance.FromKiloohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactance.FromKiloohms(value.ToDouble(null));
+                => ElectricReactance.FromKiloohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactance.FromMegaohms(double)" />
+            /// <inheritdoc cref="ElectricReactance.FromMegaohms(QuantityValue)" />
             public ElectricReactance Megaohms
 #if NET7_0_OR_GREATER
-                => ElectricReactance.FromMegaohms(double.CreateChecked(value));
+                => ElectricReactance.FromMegaohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactance.FromMegaohms(value.ToDouble(null));
+                => ElectricReactance.FromMegaohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactance.FromMicroohms(double)" />
+            /// <inheritdoc cref="ElectricReactance.FromMicroohms(QuantityValue)" />
             public ElectricReactance Microohms
 #if NET7_0_OR_GREATER
-                => ElectricReactance.FromMicroohms(double.CreateChecked(value));
+                => ElectricReactance.FromMicroohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactance.FromMicroohms(value.ToDouble(null));
+                => ElectricReactance.FromMicroohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactance.FromMilliohms(double)" />
+            /// <inheritdoc cref="ElectricReactance.FromMilliohms(QuantityValue)" />
             public ElectricReactance Milliohms
 #if NET7_0_OR_GREATER
-                => ElectricReactance.FromMilliohms(double.CreateChecked(value));
+                => ElectricReactance.FromMilliohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactance.FromMilliohms(value.ToDouble(null));
+                => ElectricReactance.FromMilliohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactance.FromNanoohms(double)" />
+            /// <inheritdoc cref="ElectricReactance.FromNanoohms(QuantityValue)" />
             public ElectricReactance Nanoohms
 #if NET7_0_OR_GREATER
-                => ElectricReactance.FromNanoohms(double.CreateChecked(value));
+                => ElectricReactance.FromNanoohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactance.FromNanoohms(value.ToDouble(null));
+                => ElectricReactance.FromNanoohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactance.FromOhms(double)" />
+            /// <inheritdoc cref="ElectricReactance.FromOhms(QuantityValue)" />
             public ElectricReactance Ohms
 #if NET7_0_OR_GREATER
-                => ElectricReactance.FromOhms(double.CreateChecked(value));
+                => ElectricReactance.FromOhms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactance.FromOhms(value.ToDouble(null));
+                => ElectricReactance.FromOhms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactance.FromTeraohms(double)" />
+            /// <inheritdoc cref="ElectricReactance.FromTeraohms(QuantityValue)" />
             public ElectricReactance Teraohms
 #if NET7_0_OR_GREATER
-                => ElectricReactance.FromTeraohms(double.CreateChecked(value));
+                => ElectricReactance.FromTeraohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactance.FromTeraohms(value.ToDouble(null));
+                => ElectricReactance.FromTeraohms(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs
index 883bc97964..4ec8d10acf 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs
@@ -42,28 +42,28 @@ public static class NumberToElectricReactiveEnergyExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricReactiveEnergy.FromKilovoltampereReactiveHours(double)" />
+            /// <inheritdoc cref="ElectricReactiveEnergy.FromKilovoltampereReactiveHours(QuantityValue)" />
             public ElectricReactiveEnergy KilovoltampereReactiveHours
 #if NET7_0_OR_GREATER
-                => ElectricReactiveEnergy.FromKilovoltampereReactiveHours(double.CreateChecked(value));
+                => ElectricReactiveEnergy.FromKilovoltampereReactiveHours(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactiveEnergy.FromKilovoltampereReactiveHours(value.ToDouble(null));
+                => ElectricReactiveEnergy.FromKilovoltampereReactiveHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactiveEnergy.FromMegavoltampereReactiveHours(double)" />
+            /// <inheritdoc cref="ElectricReactiveEnergy.FromMegavoltampereReactiveHours(QuantityValue)" />
             public ElectricReactiveEnergy MegavoltampereReactiveHours
 #if NET7_0_OR_GREATER
-                => ElectricReactiveEnergy.FromMegavoltampereReactiveHours(double.CreateChecked(value));
+                => ElectricReactiveEnergy.FromMegavoltampereReactiveHours(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactiveEnergy.FromMegavoltampereReactiveHours(value.ToDouble(null));
+                => ElectricReactiveEnergy.FromMegavoltampereReactiveHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactiveEnergy.FromVoltampereReactiveHours(double)" />
+            /// <inheritdoc cref="ElectricReactiveEnergy.FromVoltampereReactiveHours(QuantityValue)" />
             public ElectricReactiveEnergy VoltampereReactiveHours
 #if NET7_0_OR_GREATER
-                => ElectricReactiveEnergy.FromVoltampereReactiveHours(double.CreateChecked(value));
+                => ElectricReactiveEnergy.FromVoltampereReactiveHours(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactiveEnergy.FromVoltampereReactiveHours(value.ToDouble(null));
+                => ElectricReactiveEnergy.FromVoltampereReactiveHours(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs
index c9287f83de..11e4d425f6 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs
@@ -42,36 +42,36 @@ public static class NumberToElectricReactivePowerExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricReactivePower.FromGigavoltamperesReactive(double)" />
+            /// <inheritdoc cref="ElectricReactivePower.FromGigavoltamperesReactive(QuantityValue)" />
             public ElectricReactivePower GigavoltamperesReactive
 #if NET7_0_OR_GREATER
-                => ElectricReactivePower.FromGigavoltamperesReactive(double.CreateChecked(value));
+                => ElectricReactivePower.FromGigavoltamperesReactive(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactivePower.FromGigavoltamperesReactive(value.ToDouble(null));
+                => ElectricReactivePower.FromGigavoltamperesReactive(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactivePower.FromKilovoltamperesReactive(double)" />
+            /// <inheritdoc cref="ElectricReactivePower.FromKilovoltamperesReactive(QuantityValue)" />
             public ElectricReactivePower KilovoltamperesReactive
 #if NET7_0_OR_GREATER
-                => ElectricReactivePower.FromKilovoltamperesReactive(double.CreateChecked(value));
+                => ElectricReactivePower.FromKilovoltamperesReactive(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactivePower.FromKilovoltamperesReactive(value.ToDouble(null));
+                => ElectricReactivePower.FromKilovoltamperesReactive(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactivePower.FromMegavoltamperesReactive(double)" />
+            /// <inheritdoc cref="ElectricReactivePower.FromMegavoltamperesReactive(QuantityValue)" />
             public ElectricReactivePower MegavoltamperesReactive
 #if NET7_0_OR_GREATER
-                => ElectricReactivePower.FromMegavoltamperesReactive(double.CreateChecked(value));
+                => ElectricReactivePower.FromMegavoltamperesReactive(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactivePower.FromMegavoltamperesReactive(value.ToDouble(null));
+                => ElectricReactivePower.FromMegavoltamperesReactive(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricReactivePower.FromVoltamperesReactive(double)" />
+            /// <inheritdoc cref="ElectricReactivePower.FromVoltamperesReactive(QuantityValue)" />
             public ElectricReactivePower VoltamperesReactive
 #if NET7_0_OR_GREATER
-                => ElectricReactivePower.FromVoltamperesReactive(double.CreateChecked(value));
+                => ElectricReactivePower.FromVoltamperesReactive(QuantityValue.CreateChecked(value));
 #else
-                => ElectricReactivePower.FromVoltamperesReactive(value.ToDouble(null));
+                => ElectricReactivePower.FromVoltamperesReactive(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
index 7c54e42ad1..eb2841de05 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
@@ -42,68 +42,68 @@ public static class NumberToElectricResistanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricResistance.FromGigaohms(double)" />
+            /// <inheritdoc cref="ElectricResistance.FromGigaohms(QuantityValue)" />
             public ElectricResistance Gigaohms
 #if NET7_0_OR_GREATER
-                => ElectricResistance.FromGigaohms(double.CreateChecked(value));
+                => ElectricResistance.FromGigaohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistance.FromGigaohms(value.ToDouble(null));
+                => ElectricResistance.FromGigaohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistance.FromKiloohms(double)" />
+            /// <inheritdoc cref="ElectricResistance.FromKiloohms(QuantityValue)" />
             public ElectricResistance Kiloohms
 #if NET7_0_OR_GREATER
-                => ElectricResistance.FromKiloohms(double.CreateChecked(value));
+                => ElectricResistance.FromKiloohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistance.FromKiloohms(value.ToDouble(null));
+                => ElectricResistance.FromKiloohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistance.FromMegaohms(double)" />
+            /// <inheritdoc cref="ElectricResistance.FromMegaohms(QuantityValue)" />
             public ElectricResistance Megaohms
 #if NET7_0_OR_GREATER
-                => ElectricResistance.FromMegaohms(double.CreateChecked(value));
+                => ElectricResistance.FromMegaohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistance.FromMegaohms(value.ToDouble(null));
+                => ElectricResistance.FromMegaohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistance.FromMicroohms(double)" />
+            /// <inheritdoc cref="ElectricResistance.FromMicroohms(QuantityValue)" />
             public ElectricResistance Microohms
 #if NET7_0_OR_GREATER
-                => ElectricResistance.FromMicroohms(double.CreateChecked(value));
+                => ElectricResistance.FromMicroohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistance.FromMicroohms(value.ToDouble(null));
+                => ElectricResistance.FromMicroohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistance.FromMilliohms(double)" />
+            /// <inheritdoc cref="ElectricResistance.FromMilliohms(QuantityValue)" />
             public ElectricResistance Milliohms
 #if NET7_0_OR_GREATER
-                => ElectricResistance.FromMilliohms(double.CreateChecked(value));
+                => ElectricResistance.FromMilliohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistance.FromMilliohms(value.ToDouble(null));
+                => ElectricResistance.FromMilliohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistance.FromNanoohms(double)" />
+            /// <inheritdoc cref="ElectricResistance.FromNanoohms(QuantityValue)" />
             public ElectricResistance Nanoohms
 #if NET7_0_OR_GREATER
-                => ElectricResistance.FromNanoohms(double.CreateChecked(value));
+                => ElectricResistance.FromNanoohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistance.FromNanoohms(value.ToDouble(null));
+                => ElectricResistance.FromNanoohms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistance.FromOhms(double)" />
+            /// <inheritdoc cref="ElectricResistance.FromOhms(QuantityValue)" />
             public ElectricResistance Ohms
 #if NET7_0_OR_GREATER
-                => ElectricResistance.FromOhms(double.CreateChecked(value));
+                => ElectricResistance.FromOhms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistance.FromOhms(value.ToDouble(null));
+                => ElectricResistance.FromOhms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistance.FromTeraohms(double)" />
+            /// <inheritdoc cref="ElectricResistance.FromTeraohms(QuantityValue)" />
             public ElectricResistance Teraohms
 #if NET7_0_OR_GREATER
-                => ElectricResistance.FromTeraohms(double.CreateChecked(value));
+                => ElectricResistance.FromTeraohms(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistance.FromTeraohms(value.ToDouble(null));
+                => ElectricResistance.FromTeraohms(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistivityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
index 621882e58e..c9b95a2aad 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
@@ -42,116 +42,116 @@ public static class NumberToElectricResistivityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricResistivity.FromKiloohmsCentimeter(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromKiloohmsCentimeter(QuantityValue)" />
             public ElectricResistivity KiloohmsCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromKiloohmsCentimeter(double.CreateChecked(value));
+                => ElectricResistivity.FromKiloohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromKiloohmsCentimeter(value.ToDouble(null));
+                => ElectricResistivity.FromKiloohmsCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromKiloohmMeters(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromKiloohmMeters(QuantityValue)" />
             public ElectricResistivity KiloohmMeters
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromKiloohmMeters(double.CreateChecked(value));
+                => ElectricResistivity.FromKiloohmMeters(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromKiloohmMeters(value.ToDouble(null));
+                => ElectricResistivity.FromKiloohmMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromMegaohmsCentimeter(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromMegaohmsCentimeter(QuantityValue)" />
             public ElectricResistivity MegaohmsCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromMegaohmsCentimeter(double.CreateChecked(value));
+                => ElectricResistivity.FromMegaohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromMegaohmsCentimeter(value.ToDouble(null));
+                => ElectricResistivity.FromMegaohmsCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromMegaohmMeters(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromMegaohmMeters(QuantityValue)" />
             public ElectricResistivity MegaohmMeters
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromMegaohmMeters(double.CreateChecked(value));
+                => ElectricResistivity.FromMegaohmMeters(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromMegaohmMeters(value.ToDouble(null));
+                => ElectricResistivity.FromMegaohmMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromMicroohmsCentimeter(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromMicroohmsCentimeter(QuantityValue)" />
             public ElectricResistivity MicroohmsCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromMicroohmsCentimeter(double.CreateChecked(value));
+                => ElectricResistivity.FromMicroohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromMicroohmsCentimeter(value.ToDouble(null));
+                => ElectricResistivity.FromMicroohmsCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromMicroohmMeters(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromMicroohmMeters(QuantityValue)" />
             public ElectricResistivity MicroohmMeters
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromMicroohmMeters(double.CreateChecked(value));
+                => ElectricResistivity.FromMicroohmMeters(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromMicroohmMeters(value.ToDouble(null));
+                => ElectricResistivity.FromMicroohmMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromMilliohmsCentimeter(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromMilliohmsCentimeter(QuantityValue)" />
             public ElectricResistivity MilliohmsCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromMilliohmsCentimeter(double.CreateChecked(value));
+                => ElectricResistivity.FromMilliohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromMilliohmsCentimeter(value.ToDouble(null));
+                => ElectricResistivity.FromMilliohmsCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromMilliohmMeters(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromMilliohmMeters(QuantityValue)" />
             public ElectricResistivity MilliohmMeters
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromMilliohmMeters(double.CreateChecked(value));
+                => ElectricResistivity.FromMilliohmMeters(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromMilliohmMeters(value.ToDouble(null));
+                => ElectricResistivity.FromMilliohmMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromNanoohmsCentimeter(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromNanoohmsCentimeter(QuantityValue)" />
             public ElectricResistivity NanoohmsCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromNanoohmsCentimeter(double.CreateChecked(value));
+                => ElectricResistivity.FromNanoohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromNanoohmsCentimeter(value.ToDouble(null));
+                => ElectricResistivity.FromNanoohmsCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromNanoohmMeters(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromNanoohmMeters(QuantityValue)" />
             public ElectricResistivity NanoohmMeters
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromNanoohmMeters(double.CreateChecked(value));
+                => ElectricResistivity.FromNanoohmMeters(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromNanoohmMeters(value.ToDouble(null));
+                => ElectricResistivity.FromNanoohmMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromOhmsCentimeter(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromOhmsCentimeter(QuantityValue)" />
             public ElectricResistivity OhmsCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromOhmsCentimeter(double.CreateChecked(value));
+                => ElectricResistivity.FromOhmsCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromOhmsCentimeter(value.ToDouble(null));
+                => ElectricResistivity.FromOhmsCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromOhmMeters(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromOhmMeters(QuantityValue)" />
             public ElectricResistivity OhmMeters
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromOhmMeters(double.CreateChecked(value));
+                => ElectricResistivity.FromOhmMeters(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromOhmMeters(value.ToDouble(null));
+                => ElectricResistivity.FromOhmMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromPicoohmsCentimeter(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromPicoohmsCentimeter(QuantityValue)" />
             public ElectricResistivity PicoohmsCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromPicoohmsCentimeter(double.CreateChecked(value));
+                => ElectricResistivity.FromPicoohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromPicoohmsCentimeter(value.ToDouble(null));
+                => ElectricResistivity.FromPicoohmsCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricResistivity.FromPicoohmMeters(double)" />
+            /// <inheritdoc cref="ElectricResistivity.FromPicoohmMeters(QuantityValue)" />
             public ElectricResistivity PicoohmMeters
 #if NET7_0_OR_GREATER
-                => ElectricResistivity.FromPicoohmMeters(double.CreateChecked(value));
+                => ElectricResistivity.FromPicoohmMeters(QuantityValue.CreateChecked(value));
 #else
-                => ElectricResistivity.FromPicoohmMeters(value.ToDouble(null));
+                => ElectricResistivity.FromPicoohmMeters(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
index de5bbb812c..a6854666d2 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
@@ -42,28 +42,28 @@ public static class NumberToElectricSurfaceChargeDensityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(QuantityValue)" />
             public ElectricSurfaceChargeDensity CoulombsPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(double.CreateChecked(value));
+                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(value.ToDouble(null));
+                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(double)" />
+            /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(QuantityValue)" />
             public ElectricSurfaceChargeDensity CoulombsPerSquareInch
 #if NET7_0_OR_GREATER
-                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(double.CreateChecked(value));
+                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(value.ToDouble(null));
+                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(double)" />
+            /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(QuantityValue)" />
             public ElectricSurfaceChargeDensity CoulombsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(double.CreateChecked(value));
+                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(value.ToDouble(null));
+                => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs
index f3635c9923..a32bc833c1 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs
@@ -42,132 +42,132 @@ public static class NumberToElectricSusceptanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ElectricSusceptance.FromGigamhos(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromGigamhos(QuantityValue)" />
             public ElectricSusceptance Gigamhos
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromGigamhos(double.CreateChecked(value));
+                => ElectricSusceptance.FromGigamhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromGigamhos(value.ToDouble(null));
+                => ElectricSusceptance.FromGigamhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromGigasiemens(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromGigasiemens(QuantityValue)" />
             public ElectricSusceptance Gigasiemens
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromGigasiemens(double.CreateChecked(value));
+                => ElectricSusceptance.FromGigasiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromGigasiemens(value.ToDouble(null));
+                => ElectricSusceptance.FromGigasiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromKilomhos(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromKilomhos(QuantityValue)" />
             public ElectricSusceptance Kilomhos
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromKilomhos(double.CreateChecked(value));
+                => ElectricSusceptance.FromKilomhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromKilomhos(value.ToDouble(null));
+                => ElectricSusceptance.FromKilomhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromKilosiemens(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromKilosiemens(QuantityValue)" />
             public ElectricSusceptance Kilosiemens
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromKilosiemens(double.CreateChecked(value));
+                => ElectricSusceptance.FromKilosiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromKilosiemens(value.ToDouble(null));
+                => ElectricSusceptance.FromKilosiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromMegamhos(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromMegamhos(QuantityValue)" />
             public ElectricSusceptance Megamhos
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromMegamhos(double.CreateChecked(value));
+                => ElectricSusceptance.FromMegamhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromMegamhos(value.ToDouble(null));
+                => ElectricSusceptance.FromMegamhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromMegasiemens(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromMegasiemens(QuantityValue)" />
             public ElectricSusceptance Megasiemens
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromMegasiemens(double.CreateChecked(value));
+                => ElectricSusceptance.FromMegasiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromMegasiemens(value.ToDouble(null));
+                => ElectricSusceptance.FromMegasiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromMhos(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromMhos(QuantityValue)" />
             public ElectricSusceptance Mhos
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromMhos(double.CreateChecked(value));
+                => ElectricSusceptance.FromMhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromMhos(value.ToDouble(null));
+                => ElectricSusceptance.FromMhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromMicromhos(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromMicromhos(QuantityValue)" />
             public ElectricSusceptance Micromhos
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromMicromhos(double.CreateChecked(value));
+                => ElectricSusceptance.FromMicromhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromMicromhos(value.ToDouble(null));
+                => ElectricSusceptance.FromMicromhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromMicrosiemens(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromMicrosiemens(QuantityValue)" />
             public ElectricSusceptance Microsiemens
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromMicrosiemens(double.CreateChecked(value));
+                => ElectricSusceptance.FromMicrosiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromMicrosiemens(value.ToDouble(null));
+                => ElectricSusceptance.FromMicrosiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromMillimhos(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromMillimhos(QuantityValue)" />
             public ElectricSusceptance Millimhos
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromMillimhos(double.CreateChecked(value));
+                => ElectricSusceptance.FromMillimhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromMillimhos(value.ToDouble(null));
+                => ElectricSusceptance.FromMillimhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromMillisiemens(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromMillisiemens(QuantityValue)" />
             public ElectricSusceptance Millisiemens
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromMillisiemens(double.CreateChecked(value));
+                => ElectricSusceptance.FromMillisiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromMillisiemens(value.ToDouble(null));
+                => ElectricSusceptance.FromMillisiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromNanomhos(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromNanomhos(QuantityValue)" />
             public ElectricSusceptance Nanomhos
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromNanomhos(double.CreateChecked(value));
+                => ElectricSusceptance.FromNanomhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromNanomhos(value.ToDouble(null));
+                => ElectricSusceptance.FromNanomhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromNanosiemens(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromNanosiemens(QuantityValue)" />
             public ElectricSusceptance Nanosiemens
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromNanosiemens(double.CreateChecked(value));
+                => ElectricSusceptance.FromNanosiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromNanosiemens(value.ToDouble(null));
+                => ElectricSusceptance.FromNanosiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromSiemens(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromSiemens(QuantityValue)" />
             public ElectricSusceptance Siemens
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromSiemens(double.CreateChecked(value));
+                => ElectricSusceptance.FromSiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromSiemens(value.ToDouble(null));
+                => ElectricSusceptance.FromSiemens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromTeramhos(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromTeramhos(QuantityValue)" />
             public ElectricSusceptance Teramhos
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromTeramhos(double.CreateChecked(value));
+                => ElectricSusceptance.FromTeramhos(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromTeramhos(value.ToDouble(null));
+                => ElectricSusceptance.FromTeramhos(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ElectricSusceptance.FromTerasiemens(double)" />
+            /// <inheritdoc cref="ElectricSusceptance.FromTerasiemens(QuantityValue)" />
             public ElectricSusceptance Terasiemens
 #if NET7_0_OR_GREATER
-                => ElectricSusceptance.FromTerasiemens(double.CreateChecked(value));
+                => ElectricSusceptance.FromTerasiemens(QuantityValue.CreateChecked(value));
 #else
-                => ElectricSusceptance.FromTerasiemens(value.ToDouble(null));
+                => ElectricSusceptance.FromTerasiemens(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyDensityExtensions.g.cs
index f3674b0e4f..d5685bddc3 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyDensityExtensions.g.cs
@@ -42,100 +42,100 @@ public static class NumberToEnergyDensityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="EnergyDensity.FromGigajoulesPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromGigajoulesPerCubicMeter(QuantityValue)" />
             public EnergyDensity GigajoulesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromGigajoulesPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromGigajoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromGigajoulesPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromGigajoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromGigawattHoursPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromGigawattHoursPerCubicMeter(QuantityValue)" />
             public EnergyDensity GigawattHoursPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromGigawattHoursPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromGigawattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromGigawattHoursPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromGigawattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromJoulesPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromJoulesPerCubicMeter(QuantityValue)" />
             public EnergyDensity JoulesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromJoulesPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromJoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromJoulesPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromJoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromKilojoulesPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromKilojoulesPerCubicMeter(QuantityValue)" />
             public EnergyDensity KilojoulesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromKilojoulesPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromKilojoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromKilojoulesPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromKilojoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromKilowattHoursPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromKilowattHoursPerCubicMeter(QuantityValue)" />
             public EnergyDensity KilowattHoursPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromKilowattHoursPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromKilowattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromKilowattHoursPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromKilowattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromMegajoulesPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromMegajoulesPerCubicMeter(QuantityValue)" />
             public EnergyDensity MegajoulesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromMegajoulesPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromMegajoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromMegajoulesPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromMegajoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromMegawattHoursPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromMegawattHoursPerCubicMeter(QuantityValue)" />
             public EnergyDensity MegawattHoursPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromMegawattHoursPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromMegawattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromMegawattHoursPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromMegawattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromPetajoulesPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromPetajoulesPerCubicMeter(QuantityValue)" />
             public EnergyDensity PetajoulesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromPetajoulesPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromPetajoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromPetajoulesPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromPetajoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromPetawattHoursPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromPetawattHoursPerCubicMeter(QuantityValue)" />
             public EnergyDensity PetawattHoursPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromPetawattHoursPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromPetawattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromPetawattHoursPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromPetawattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromTerajoulesPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromTerajoulesPerCubicMeter(QuantityValue)" />
             public EnergyDensity TerajoulesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromTerajoulesPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromTerajoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromTerajoulesPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromTerajoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromTerawattHoursPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromTerawattHoursPerCubicMeter(QuantityValue)" />
             public EnergyDensity TerawattHoursPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromTerawattHoursPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromTerawattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromTerawattHoursPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromTerawattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="EnergyDensity.FromWattHoursPerCubicMeter(double)" />
+            /// <inheritdoc cref="EnergyDensity.FromWattHoursPerCubicMeter(QuantityValue)" />
             public EnergyDensity WattHoursPerCubicMeter
 #if NET7_0_OR_GREATER
-                => EnergyDensity.FromWattHoursPerCubicMeter(double.CreateChecked(value));
+                => EnergyDensity.FromWattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => EnergyDensity.FromWattHoursPerCubicMeter(value.ToDouble(null));
+                => EnergyDensity.FromWattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyExtensions.g.cs
index d600983c22..761e0e1ec2 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyExtensions.g.cs
@@ -42,324 +42,324 @@ public static class NumberToEnergyExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Energy.FromBritishThermalUnits(double)" />
+            /// <inheritdoc cref="Energy.FromBritishThermalUnits(QuantityValue)" />
             public Energy BritishThermalUnits
 #if NET7_0_OR_GREATER
-                => Energy.FromBritishThermalUnits(double.CreateChecked(value));
+                => Energy.FromBritishThermalUnits(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromBritishThermalUnits(value.ToDouble(null));
+                => Energy.FromBritishThermalUnits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromCalories(double)" />
+            /// <inheritdoc cref="Energy.FromCalories(QuantityValue)" />
             public Energy Calories
 #if NET7_0_OR_GREATER
-                => Energy.FromCalories(double.CreateChecked(value));
+                => Energy.FromCalories(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromCalories(value.ToDouble(null));
+                => Energy.FromCalories(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromDecathermsEc(double)" />
+            /// <inheritdoc cref="Energy.FromDecathermsEc(QuantityValue)" />
             public Energy DecathermsEc
 #if NET7_0_OR_GREATER
-                => Energy.FromDecathermsEc(double.CreateChecked(value));
+                => Energy.FromDecathermsEc(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromDecathermsEc(value.ToDouble(null));
+                => Energy.FromDecathermsEc(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromDecathermsImperial(double)" />
+            /// <inheritdoc cref="Energy.FromDecathermsImperial(QuantityValue)" />
             public Energy DecathermsImperial
 #if NET7_0_OR_GREATER
-                => Energy.FromDecathermsImperial(double.CreateChecked(value));
+                => Energy.FromDecathermsImperial(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromDecathermsImperial(value.ToDouble(null));
+                => Energy.FromDecathermsImperial(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromDecathermsUs(double)" />
+            /// <inheritdoc cref="Energy.FromDecathermsUs(QuantityValue)" />
             public Energy DecathermsUs
 #if NET7_0_OR_GREATER
-                => Energy.FromDecathermsUs(double.CreateChecked(value));
+                => Energy.FromDecathermsUs(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromDecathermsUs(value.ToDouble(null));
+                => Energy.FromDecathermsUs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromElectronVolts(double)" />
+            /// <inheritdoc cref="Energy.FromElectronVolts(QuantityValue)" />
             public Energy ElectronVolts
 #if NET7_0_OR_GREATER
-                => Energy.FromElectronVolts(double.CreateChecked(value));
+                => Energy.FromElectronVolts(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromElectronVolts(value.ToDouble(null));
+                => Energy.FromElectronVolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromErgs(double)" />
+            /// <inheritdoc cref="Energy.FromErgs(QuantityValue)" />
             public Energy Ergs
 #if NET7_0_OR_GREATER
-                => Energy.FromErgs(double.CreateChecked(value));
+                => Energy.FromErgs(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromErgs(value.ToDouble(null));
+                => Energy.FromErgs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromFootPounds(double)" />
+            /// <inheritdoc cref="Energy.FromFootPounds(QuantityValue)" />
             public Energy FootPounds
 #if NET7_0_OR_GREATER
-                => Energy.FromFootPounds(double.CreateChecked(value));
+                => Energy.FromFootPounds(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromFootPounds(value.ToDouble(null));
+                => Energy.FromFootPounds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromGigabritishThermalUnits(double)" />
+            /// <inheritdoc cref="Energy.FromGigabritishThermalUnits(QuantityValue)" />
             public Energy GigabritishThermalUnits
 #if NET7_0_OR_GREATER
-                => Energy.FromGigabritishThermalUnits(double.CreateChecked(value));
+                => Energy.FromGigabritishThermalUnits(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromGigabritishThermalUnits(value.ToDouble(null));
+                => Energy.FromGigabritishThermalUnits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromGigaelectronVolts(double)" />
+            /// <inheritdoc cref="Energy.FromGigaelectronVolts(QuantityValue)" />
             public Energy GigaelectronVolts
 #if NET7_0_OR_GREATER
-                => Energy.FromGigaelectronVolts(double.CreateChecked(value));
+                => Energy.FromGigaelectronVolts(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromGigaelectronVolts(value.ToDouble(null));
+                => Energy.FromGigaelectronVolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromGigajoules(double)" />
+            /// <inheritdoc cref="Energy.FromGigajoules(QuantityValue)" />
             public Energy Gigajoules
 #if NET7_0_OR_GREATER
-                => Energy.FromGigajoules(double.CreateChecked(value));
+                => Energy.FromGigajoules(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromGigajoules(value.ToDouble(null));
+                => Energy.FromGigajoules(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromGigawattDays(double)" />
+            /// <inheritdoc cref="Energy.FromGigawattDays(QuantityValue)" />
             public Energy GigawattDays
 #if NET7_0_OR_GREATER
-                => Energy.FromGigawattDays(double.CreateChecked(value));
+                => Energy.FromGigawattDays(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromGigawattDays(value.ToDouble(null));
+                => Energy.FromGigawattDays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromGigawattHours(double)" />
+            /// <inheritdoc cref="Energy.FromGigawattHours(QuantityValue)" />
             public Energy GigawattHours
 #if NET7_0_OR_GREATER
-                => Energy.FromGigawattHours(double.CreateChecked(value));
+                => Energy.FromGigawattHours(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromGigawattHours(value.ToDouble(null));
+                => Energy.FromGigawattHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromHorsepowerHours(double)" />
+            /// <inheritdoc cref="Energy.FromHorsepowerHours(QuantityValue)" />
             public Energy HorsepowerHours
 #if NET7_0_OR_GREATER
-                => Energy.FromHorsepowerHours(double.CreateChecked(value));
+                => Energy.FromHorsepowerHours(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromHorsepowerHours(value.ToDouble(null));
+                => Energy.FromHorsepowerHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromJoules(double)" />
+            /// <inheritdoc cref="Energy.FromJoules(QuantityValue)" />
             public Energy Joules
 #if NET7_0_OR_GREATER
-                => Energy.FromJoules(double.CreateChecked(value));
+                => Energy.FromJoules(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromJoules(value.ToDouble(null));
+                => Energy.FromJoules(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromKilobritishThermalUnits(double)" />
+            /// <inheritdoc cref="Energy.FromKilobritishThermalUnits(QuantityValue)" />
             public Energy KilobritishThermalUnits
 #if NET7_0_OR_GREATER
-                => Energy.FromKilobritishThermalUnits(double.CreateChecked(value));
+                => Energy.FromKilobritishThermalUnits(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromKilobritishThermalUnits(value.ToDouble(null));
+                => Energy.FromKilobritishThermalUnits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromKilocalories(double)" />
+            /// <inheritdoc cref="Energy.FromKilocalories(QuantityValue)" />
             public Energy Kilocalories
 #if NET7_0_OR_GREATER
-                => Energy.FromKilocalories(double.CreateChecked(value));
+                => Energy.FromKilocalories(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromKilocalories(value.ToDouble(null));
+                => Energy.FromKilocalories(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromKiloelectronVolts(double)" />
+            /// <inheritdoc cref="Energy.FromKiloelectronVolts(QuantityValue)" />
             public Energy KiloelectronVolts
 #if NET7_0_OR_GREATER
-                => Energy.FromKiloelectronVolts(double.CreateChecked(value));
+                => Energy.FromKiloelectronVolts(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromKiloelectronVolts(value.ToDouble(null));
+                => Energy.FromKiloelectronVolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromKilojoules(double)" />
+            /// <inheritdoc cref="Energy.FromKilojoules(QuantityValue)" />
             public Energy Kilojoules
 #if NET7_0_OR_GREATER
-                => Energy.FromKilojoules(double.CreateChecked(value));
+                => Energy.FromKilojoules(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromKilojoules(value.ToDouble(null));
+                => Energy.FromKilojoules(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromKilowattDays(double)" />
+            /// <inheritdoc cref="Energy.FromKilowattDays(QuantityValue)" />
             public Energy KilowattDays
 #if NET7_0_OR_GREATER
-                => Energy.FromKilowattDays(double.CreateChecked(value));
+                => Energy.FromKilowattDays(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromKilowattDays(value.ToDouble(null));
+                => Energy.FromKilowattDays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromKilowattHours(double)" />
+            /// <inheritdoc cref="Energy.FromKilowattHours(QuantityValue)" />
             public Energy KilowattHours
 #if NET7_0_OR_GREATER
-                => Energy.FromKilowattHours(double.CreateChecked(value));
+                => Energy.FromKilowattHours(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromKilowattHours(value.ToDouble(null));
+                => Energy.FromKilowattHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromMegabritishThermalUnits(double)" />
+            /// <inheritdoc cref="Energy.FromMegabritishThermalUnits(QuantityValue)" />
             public Energy MegabritishThermalUnits
 #if NET7_0_OR_GREATER
-                => Energy.FromMegabritishThermalUnits(double.CreateChecked(value));
+                => Energy.FromMegabritishThermalUnits(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromMegabritishThermalUnits(value.ToDouble(null));
+                => Energy.FromMegabritishThermalUnits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromMegacalories(double)" />
+            /// <inheritdoc cref="Energy.FromMegacalories(QuantityValue)" />
             public Energy Megacalories
 #if NET7_0_OR_GREATER
-                => Energy.FromMegacalories(double.CreateChecked(value));
+                => Energy.FromMegacalories(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromMegacalories(value.ToDouble(null));
+                => Energy.FromMegacalories(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromMegaelectronVolts(double)" />
+            /// <inheritdoc cref="Energy.FromMegaelectronVolts(QuantityValue)" />
             public Energy MegaelectronVolts
 #if NET7_0_OR_GREATER
-                => Energy.FromMegaelectronVolts(double.CreateChecked(value));
+                => Energy.FromMegaelectronVolts(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromMegaelectronVolts(value.ToDouble(null));
+                => Energy.FromMegaelectronVolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromMegajoules(double)" />
+            /// <inheritdoc cref="Energy.FromMegajoules(QuantityValue)" />
             public Energy Megajoules
 #if NET7_0_OR_GREATER
-                => Energy.FromMegajoules(double.CreateChecked(value));
+                => Energy.FromMegajoules(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromMegajoules(value.ToDouble(null));
+                => Energy.FromMegajoules(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromMegawattDays(double)" />
+            /// <inheritdoc cref="Energy.FromMegawattDays(QuantityValue)" />
             public Energy MegawattDays
 #if NET7_0_OR_GREATER
-                => Energy.FromMegawattDays(double.CreateChecked(value));
+                => Energy.FromMegawattDays(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromMegawattDays(value.ToDouble(null));
+                => Energy.FromMegawattDays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromMegawattHours(double)" />
+            /// <inheritdoc cref="Energy.FromMegawattHours(QuantityValue)" />
             public Energy MegawattHours
 #if NET7_0_OR_GREATER
-                => Energy.FromMegawattHours(double.CreateChecked(value));
+                => Energy.FromMegawattHours(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromMegawattHours(value.ToDouble(null));
+                => Energy.FromMegawattHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromMicrojoules(double)" />
+            /// <inheritdoc cref="Energy.FromMicrojoules(QuantityValue)" />
             public Energy Microjoules
 #if NET7_0_OR_GREATER
-                => Energy.FromMicrojoules(double.CreateChecked(value));
+                => Energy.FromMicrojoules(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromMicrojoules(value.ToDouble(null));
+                => Energy.FromMicrojoules(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromMillijoules(double)" />
+            /// <inheritdoc cref="Energy.FromMillijoules(QuantityValue)" />
             public Energy Millijoules
 #if NET7_0_OR_GREATER
-                => Energy.FromMillijoules(double.CreateChecked(value));
+                => Energy.FromMillijoules(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromMillijoules(value.ToDouble(null));
+                => Energy.FromMillijoules(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromNanojoules(double)" />
+            /// <inheritdoc cref="Energy.FromNanojoules(QuantityValue)" />
             public Energy Nanojoules
 #if NET7_0_OR_GREATER
-                => Energy.FromNanojoules(double.CreateChecked(value));
+                => Energy.FromNanojoules(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromNanojoules(value.ToDouble(null));
+                => Energy.FromNanojoules(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromPetajoules(double)" />
+            /// <inheritdoc cref="Energy.FromPetajoules(QuantityValue)" />
             public Energy Petajoules
 #if NET7_0_OR_GREATER
-                => Energy.FromPetajoules(double.CreateChecked(value));
+                => Energy.FromPetajoules(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromPetajoules(value.ToDouble(null));
+                => Energy.FromPetajoules(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromTeraelectronVolts(double)" />
+            /// <inheritdoc cref="Energy.FromTeraelectronVolts(QuantityValue)" />
             public Energy TeraelectronVolts
 #if NET7_0_OR_GREATER
-                => Energy.FromTeraelectronVolts(double.CreateChecked(value));
+                => Energy.FromTeraelectronVolts(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromTeraelectronVolts(value.ToDouble(null));
+                => Energy.FromTeraelectronVolts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromTerajoules(double)" />
+            /// <inheritdoc cref="Energy.FromTerajoules(QuantityValue)" />
             public Energy Terajoules
 #if NET7_0_OR_GREATER
-                => Energy.FromTerajoules(double.CreateChecked(value));
+                => Energy.FromTerajoules(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromTerajoules(value.ToDouble(null));
+                => Energy.FromTerajoules(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromTerawattDays(double)" />
+            /// <inheritdoc cref="Energy.FromTerawattDays(QuantityValue)" />
             public Energy TerawattDays
 #if NET7_0_OR_GREATER
-                => Energy.FromTerawattDays(double.CreateChecked(value));
+                => Energy.FromTerawattDays(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromTerawattDays(value.ToDouble(null));
+                => Energy.FromTerawattDays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromTerawattHours(double)" />
+            /// <inheritdoc cref="Energy.FromTerawattHours(QuantityValue)" />
             public Energy TerawattHours
 #if NET7_0_OR_GREATER
-                => Energy.FromTerawattHours(double.CreateChecked(value));
+                => Energy.FromTerawattHours(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromTerawattHours(value.ToDouble(null));
+                => Energy.FromTerawattHours(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromThermsEc(double)" />
+            /// <inheritdoc cref="Energy.FromThermsEc(QuantityValue)" />
             public Energy ThermsEc
 #if NET7_0_OR_GREATER
-                => Energy.FromThermsEc(double.CreateChecked(value));
+                => Energy.FromThermsEc(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromThermsEc(value.ToDouble(null));
+                => Energy.FromThermsEc(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromThermsImperial(double)" />
+            /// <inheritdoc cref="Energy.FromThermsImperial(QuantityValue)" />
             public Energy ThermsImperial
 #if NET7_0_OR_GREATER
-                => Energy.FromThermsImperial(double.CreateChecked(value));
+                => Energy.FromThermsImperial(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromThermsImperial(value.ToDouble(null));
+                => Energy.FromThermsImperial(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromThermsUs(double)" />
+            /// <inheritdoc cref="Energy.FromThermsUs(QuantityValue)" />
             public Energy ThermsUs
 #if NET7_0_OR_GREATER
-                => Energy.FromThermsUs(double.CreateChecked(value));
+                => Energy.FromThermsUs(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromThermsUs(value.ToDouble(null));
+                => Energy.FromThermsUs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromWattDays(double)" />
+            /// <inheritdoc cref="Energy.FromWattDays(QuantityValue)" />
             public Energy WattDays
 #if NET7_0_OR_GREATER
-                => Energy.FromWattDays(double.CreateChecked(value));
+                => Energy.FromWattDays(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromWattDays(value.ToDouble(null));
+                => Energy.FromWattDays(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Energy.FromWattHours(double)" />
+            /// <inheritdoc cref="Energy.FromWattHours(QuantityValue)" />
             public Energy WattHours
 #if NET7_0_OR_GREATER
-                => Energy.FromWattHours(double.CreateChecked(value));
+                => Energy.FromWattHours(QuantityValue.CreateChecked(value));
 #else
-                => Energy.FromWattHours(value.ToDouble(null));
+                => Energy.FromWattHours(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEntropyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEntropyExtensions.g.cs
index ff957f3db7..18b7621b61 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEntropyExtensions.g.cs
@@ -42,60 +42,60 @@ public static class NumberToEntropyExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Entropy.FromCaloriesPerKelvin(double)" />
+            /// <inheritdoc cref="Entropy.FromCaloriesPerKelvin(QuantityValue)" />
             public Entropy CaloriesPerKelvin
 #if NET7_0_OR_GREATER
-                => Entropy.FromCaloriesPerKelvin(double.CreateChecked(value));
+                => Entropy.FromCaloriesPerKelvin(QuantityValue.CreateChecked(value));
 #else
-                => Entropy.FromCaloriesPerKelvin(value.ToDouble(null));
+                => Entropy.FromCaloriesPerKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Entropy.FromJoulesPerDegreeCelsius(double)" />
+            /// <inheritdoc cref="Entropy.FromJoulesPerDegreeCelsius(QuantityValue)" />
             public Entropy JoulesPerDegreeCelsius
 #if NET7_0_OR_GREATER
-                => Entropy.FromJoulesPerDegreeCelsius(double.CreateChecked(value));
+                => Entropy.FromJoulesPerDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => Entropy.FromJoulesPerDegreeCelsius(value.ToDouble(null));
+                => Entropy.FromJoulesPerDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Entropy.FromJoulesPerKelvin(double)" />
+            /// <inheritdoc cref="Entropy.FromJoulesPerKelvin(QuantityValue)" />
             public Entropy JoulesPerKelvin
 #if NET7_0_OR_GREATER
-                => Entropy.FromJoulesPerKelvin(double.CreateChecked(value));
+                => Entropy.FromJoulesPerKelvin(QuantityValue.CreateChecked(value));
 #else
-                => Entropy.FromJoulesPerKelvin(value.ToDouble(null));
+                => Entropy.FromJoulesPerKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Entropy.FromKilocaloriesPerKelvin(double)" />
+            /// <inheritdoc cref="Entropy.FromKilocaloriesPerKelvin(QuantityValue)" />
             public Entropy KilocaloriesPerKelvin
 #if NET7_0_OR_GREATER
-                => Entropy.FromKilocaloriesPerKelvin(double.CreateChecked(value));
+                => Entropy.FromKilocaloriesPerKelvin(QuantityValue.CreateChecked(value));
 #else
-                => Entropy.FromKilocaloriesPerKelvin(value.ToDouble(null));
+                => Entropy.FromKilocaloriesPerKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Entropy.FromKilojoulesPerDegreeCelsius(double)" />
+            /// <inheritdoc cref="Entropy.FromKilojoulesPerDegreeCelsius(QuantityValue)" />
             public Entropy KilojoulesPerDegreeCelsius
 #if NET7_0_OR_GREATER
-                => Entropy.FromKilojoulesPerDegreeCelsius(double.CreateChecked(value));
+                => Entropy.FromKilojoulesPerDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => Entropy.FromKilojoulesPerDegreeCelsius(value.ToDouble(null));
+                => Entropy.FromKilojoulesPerDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Entropy.FromKilojoulesPerKelvin(double)" />
+            /// <inheritdoc cref="Entropy.FromKilojoulesPerKelvin(QuantityValue)" />
             public Entropy KilojoulesPerKelvin
 #if NET7_0_OR_GREATER
-                => Entropy.FromKilojoulesPerKelvin(double.CreateChecked(value));
+                => Entropy.FromKilojoulesPerKelvin(QuantityValue.CreateChecked(value));
 #else
-                => Entropy.FromKilojoulesPerKelvin(value.ToDouble(null));
+                => Entropy.FromKilojoulesPerKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Entropy.FromMegajoulesPerKelvin(double)" />
+            /// <inheritdoc cref="Entropy.FromMegajoulesPerKelvin(QuantityValue)" />
             public Entropy MegajoulesPerKelvin
 #if NET7_0_OR_GREATER
-                => Entropy.FromMegajoulesPerKelvin(double.CreateChecked(value));
+                => Entropy.FromMegajoulesPerKelvin(QuantityValue.CreateChecked(value));
 #else
-                => Entropy.FromMegajoulesPerKelvin(value.ToDouble(null));
+                => Entropy.FromMegajoulesPerKelvin(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFluidResistanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFluidResistanceExtensions.g.cs
index 6c6101e38d..42cdd0794b 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFluidResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFluidResistanceExtensions.g.cs
@@ -42,156 +42,156 @@ public static class NumberToFluidResistanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(double)" />
+            /// <inheritdoc cref="FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(QuantityValue)" />
             public FluidResistance DyneSecondsPerCentimeterToTheFifth
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(double.CreateChecked(value));
+                => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(value.ToDouble(null));
+                => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromMegapascalSecondsPerCubicMeter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromMegapascalSecondsPerCubicMeter(QuantityValue)" />
             public FluidResistance MegapascalSecondsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromMegapascalSecondsPerCubicMeter(double.CreateChecked(value));
+                => FluidResistance.FromMegapascalSecondsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromMegapascalSecondsPerCubicMeter(value.ToDouble(null));
+                => FluidResistance.FromMegapascalSecondsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(QuantityValue)" />
             public FluidResistance MillimeterMercuryMinutesPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(double.CreateChecked(value));
+                => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(value.ToDouble(null));
+                => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(QuantityValue)" />
             public FluidResistance MillimeterMercuryMinutesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(double.CreateChecked(value));
+                => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(value.ToDouble(null));
+                => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerLiter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerLiter(QuantityValue)" />
             public FluidResistance MillimeterMercuryMinutesPerLiter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromMillimeterMercuryMinutesPerLiter(double.CreateChecked(value));
+                => FluidResistance.FromMillimeterMercuryMinutesPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromMillimeterMercuryMinutesPerLiter(value.ToDouble(null));
+                => FluidResistance.FromMillimeterMercuryMinutesPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(QuantityValue)" />
             public FluidResistance MillimeterMercuryMinutesPerMilliliter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(double.CreateChecked(value));
+                => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(value.ToDouble(null));
+                => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(QuantityValue)" />
             public FluidResistance MillimeterMercurySecondsPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(double.CreateChecked(value));
+                => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(value.ToDouble(null));
+                => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(QuantityValue)" />
             public FluidResistance MillimeterMercurySecondsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(double.CreateChecked(value));
+                => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(value.ToDouble(null));
+                => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerLiter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerLiter(QuantityValue)" />
             public FluidResistance MillimeterMercurySecondsPerLiter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromMillimeterMercurySecondsPerLiter(double.CreateChecked(value));
+                => FluidResistance.FromMillimeterMercurySecondsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromMillimeterMercurySecondsPerLiter(value.ToDouble(null));
+                => FluidResistance.FromMillimeterMercurySecondsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerMilliliter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerMilliliter(QuantityValue)" />
             public FluidResistance MillimeterMercurySecondsPerMilliliter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(double.CreateChecked(value));
+                => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(value.ToDouble(null));
+                => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerCubicCentimeter(QuantityValue)" />
             public FluidResistance PascalMinutesPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromPascalMinutesPerCubicCentimeter(double.CreateChecked(value));
+                => FluidResistance.FromPascalMinutesPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromPascalMinutesPerCubicCentimeter(value.ToDouble(null));
+                => FluidResistance.FromPascalMinutesPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerCubicMeter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerCubicMeter(QuantityValue)" />
             public FluidResistance PascalMinutesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromPascalMinutesPerCubicMeter(double.CreateChecked(value));
+                => FluidResistance.FromPascalMinutesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromPascalMinutesPerCubicMeter(value.ToDouble(null));
+                => FluidResistance.FromPascalMinutesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerLiter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerLiter(QuantityValue)" />
             public FluidResistance PascalMinutesPerLiter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromPascalMinutesPerLiter(double.CreateChecked(value));
+                => FluidResistance.FromPascalMinutesPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromPascalMinutesPerLiter(value.ToDouble(null));
+                => FluidResistance.FromPascalMinutesPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerMilliliter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerMilliliter(QuantityValue)" />
             public FluidResistance PascalMinutesPerMilliliter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromPascalMinutesPerMilliliter(double.CreateChecked(value));
+                => FluidResistance.FromPascalMinutesPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromPascalMinutesPerMilliliter(value.ToDouble(null));
+                => FluidResistance.FromPascalMinutesPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerCubicCentimeter(QuantityValue)" />
             public FluidResistance PascalSecondsPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromPascalSecondsPerCubicCentimeter(double.CreateChecked(value));
+                => FluidResistance.FromPascalSecondsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromPascalSecondsPerCubicCentimeter(value.ToDouble(null));
+                => FluidResistance.FromPascalSecondsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerCubicMeter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerCubicMeter(QuantityValue)" />
             public FluidResistance PascalSecondsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromPascalSecondsPerCubicMeter(double.CreateChecked(value));
+                => FluidResistance.FromPascalSecondsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromPascalSecondsPerCubicMeter(value.ToDouble(null));
+                => FluidResistance.FromPascalSecondsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerLiter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerLiter(QuantityValue)" />
             public FluidResistance PascalSecondsPerLiter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromPascalSecondsPerLiter(double.CreateChecked(value));
+                => FluidResistance.FromPascalSecondsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromPascalSecondsPerLiter(value.ToDouble(null));
+                => FluidResistance.FromPascalSecondsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerMilliliter(double)" />
+            /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerMilliliter(QuantityValue)" />
             public FluidResistance PascalSecondsPerMilliliter
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromPascalSecondsPerMilliliter(double.CreateChecked(value));
+                => FluidResistance.FromPascalSecondsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromPascalSecondsPerMilliliter(value.ToDouble(null));
+                => FluidResistance.FromPascalSecondsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FluidResistance.FromWoodUnits(double)" />
+            /// <inheritdoc cref="FluidResistance.FromWoodUnits(QuantityValue)" />
             public FluidResistance WoodUnits
 #if NET7_0_OR_GREATER
-                => FluidResistance.FromWoodUnits(double.CreateChecked(value));
+                => FluidResistance.FromWoodUnits(QuantityValue.CreateChecked(value));
 #else
-                => FluidResistance.FromWoodUnits(value.ToDouble(null));
+                => FluidResistance.FromWoodUnits(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
index 9f66485090..343966f8a6 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
@@ -42,124 +42,124 @@ public static class NumberToForceChangeRateExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ForceChangeRate.FromCentinewtonsPerSecond(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromCentinewtonsPerSecond(QuantityValue)" />
             public ForceChangeRate CentinewtonsPerSecond
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromCentinewtonsPerSecond(double.CreateChecked(value));
+                => ForceChangeRate.FromCentinewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromCentinewtonsPerSecond(value.ToDouble(null));
+                => ForceChangeRate.FromCentinewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerMinute(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerMinute(QuantityValue)" />
             public ForceChangeRate DecanewtonsPerMinute
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromDecanewtonsPerMinute(double.CreateChecked(value));
+                => ForceChangeRate.FromDecanewtonsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromDecanewtonsPerMinute(value.ToDouble(null));
+                => ForceChangeRate.FromDecanewtonsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerSecond(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerSecond(QuantityValue)" />
             public ForceChangeRate DecanewtonsPerSecond
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromDecanewtonsPerSecond(double.CreateChecked(value));
+                => ForceChangeRate.FromDecanewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromDecanewtonsPerSecond(value.ToDouble(null));
+                => ForceChangeRate.FromDecanewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromDecinewtonsPerSecond(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromDecinewtonsPerSecond(QuantityValue)" />
             public ForceChangeRate DecinewtonsPerSecond
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromDecinewtonsPerSecond(double.CreateChecked(value));
+                => ForceChangeRate.FromDecinewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromDecinewtonsPerSecond(value.ToDouble(null));
+                => ForceChangeRate.FromDecinewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerMinute(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerMinute(QuantityValue)" />
             public ForceChangeRate KilonewtonsPerMinute
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromKilonewtonsPerMinute(double.CreateChecked(value));
+                => ForceChangeRate.FromKilonewtonsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromKilonewtonsPerMinute(value.ToDouble(null));
+                => ForceChangeRate.FromKilonewtonsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerSecond(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerSecond(QuantityValue)" />
             public ForceChangeRate KilonewtonsPerSecond
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromKilonewtonsPerSecond(double.CreateChecked(value));
+                => ForceChangeRate.FromKilonewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromKilonewtonsPerSecond(value.ToDouble(null));
+                => ForceChangeRate.FromKilonewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerMinute(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerMinute(QuantityValue)" />
             public ForceChangeRate KilopoundsForcePerMinute
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromKilopoundsForcePerMinute(double.CreateChecked(value));
+                => ForceChangeRate.FromKilopoundsForcePerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromKilopoundsForcePerMinute(value.ToDouble(null));
+                => ForceChangeRate.FromKilopoundsForcePerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerSecond(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerSecond(QuantityValue)" />
             public ForceChangeRate KilopoundsForcePerSecond
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromKilopoundsForcePerSecond(double.CreateChecked(value));
+                => ForceChangeRate.FromKilopoundsForcePerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromKilopoundsForcePerSecond(value.ToDouble(null));
+                => ForceChangeRate.FromKilopoundsForcePerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromMicronewtonsPerSecond(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromMicronewtonsPerSecond(QuantityValue)" />
             public ForceChangeRate MicronewtonsPerSecond
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromMicronewtonsPerSecond(double.CreateChecked(value));
+                => ForceChangeRate.FromMicronewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromMicronewtonsPerSecond(value.ToDouble(null));
+                => ForceChangeRate.FromMicronewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromMillinewtonsPerSecond(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromMillinewtonsPerSecond(QuantityValue)" />
             public ForceChangeRate MillinewtonsPerSecond
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromMillinewtonsPerSecond(double.CreateChecked(value));
+                => ForceChangeRate.FromMillinewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromMillinewtonsPerSecond(value.ToDouble(null));
+                => ForceChangeRate.FromMillinewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromNanonewtonsPerSecond(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromNanonewtonsPerSecond(QuantityValue)" />
             public ForceChangeRate NanonewtonsPerSecond
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromNanonewtonsPerSecond(double.CreateChecked(value));
+                => ForceChangeRate.FromNanonewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromNanonewtonsPerSecond(value.ToDouble(null));
+                => ForceChangeRate.FromNanonewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerMinute(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerMinute(QuantityValue)" />
             public ForceChangeRate NewtonsPerMinute
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromNewtonsPerMinute(double.CreateChecked(value));
+                => ForceChangeRate.FromNewtonsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromNewtonsPerMinute(value.ToDouble(null));
+                => ForceChangeRate.FromNewtonsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerSecond(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerSecond(QuantityValue)" />
             public ForceChangeRate NewtonsPerSecond
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromNewtonsPerSecond(double.CreateChecked(value));
+                => ForceChangeRate.FromNewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromNewtonsPerSecond(value.ToDouble(null));
+                => ForceChangeRate.FromNewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerMinute(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerMinute(QuantityValue)" />
             public ForceChangeRate PoundsForcePerMinute
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromPoundsForcePerMinute(double.CreateChecked(value));
+                => ForceChangeRate.FromPoundsForcePerMinute(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromPoundsForcePerMinute(value.ToDouble(null));
+                => ForceChangeRate.FromPoundsForcePerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerSecond(double)" />
+            /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerSecond(QuantityValue)" />
             public ForceChangeRate PoundsForcePerSecond
 #if NET7_0_OR_GREATER
-                => ForceChangeRate.FromPoundsForcePerSecond(double.CreateChecked(value));
+                => ForceChangeRate.FromPoundsForcePerSecond(QuantityValue.CreateChecked(value));
 #else
-                => ForceChangeRate.FromPoundsForcePerSecond(value.ToDouble(null));
+                => ForceChangeRate.FromPoundsForcePerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceExtensions.g.cs
index 2ace22a6e0..37fabf5a53 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceExtensions.g.cs
@@ -42,124 +42,132 @@ public static class NumberToForceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Force.FromDecanewtons(double)" />
+            /// <inheritdoc cref="Force.FromDecanewtons(QuantityValue)" />
             public Force Decanewtons
 #if NET7_0_OR_GREATER
-                => Force.FromDecanewtons(double.CreateChecked(value));
+                => Force.FromDecanewtons(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromDecanewtons(value.ToDouble(null));
+                => Force.FromDecanewtons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromDyne(double)" />
+            /// <inheritdoc cref="Force.FromDyne(QuantityValue)" />
             public Force Dyne
 #if NET7_0_OR_GREATER
-                => Force.FromDyne(double.CreateChecked(value));
+                => Force.FromDyne(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromDyne(value.ToDouble(null));
+                => Force.FromDyne(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromKilogramsForce(double)" />
+            /// <inheritdoc cref="Force.FromGramsForce(QuantityValue)" />
+            public Force GramsForce
+#if NET7_0_OR_GREATER
+                => Force.FromGramsForce(QuantityValue.CreateChecked(value));
+#else
+                => Force.FromGramsForce(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="Force.FromKilogramsForce(QuantityValue)" />
             public Force KilogramsForce
 #if NET7_0_OR_GREATER
-                => Force.FromKilogramsForce(double.CreateChecked(value));
+                => Force.FromKilogramsForce(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromKilogramsForce(value.ToDouble(null));
+                => Force.FromKilogramsForce(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromKilonewtons(double)" />
+            /// <inheritdoc cref="Force.FromKilonewtons(QuantityValue)" />
             public Force Kilonewtons
 #if NET7_0_OR_GREATER
-                => Force.FromKilonewtons(double.CreateChecked(value));
+                => Force.FromKilonewtons(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromKilonewtons(value.ToDouble(null));
+                => Force.FromKilonewtons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromKiloponds(double)" />
+            /// <inheritdoc cref="Force.FromKiloponds(QuantityValue)" />
             public Force Kiloponds
 #if NET7_0_OR_GREATER
-                => Force.FromKiloponds(double.CreateChecked(value));
+                => Force.FromKiloponds(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromKiloponds(value.ToDouble(null));
+                => Force.FromKiloponds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromKilopoundsForce(double)" />
+            /// <inheritdoc cref="Force.FromKilopoundsForce(QuantityValue)" />
             public Force KilopoundsForce
 #if NET7_0_OR_GREATER
-                => Force.FromKilopoundsForce(double.CreateChecked(value));
+                => Force.FromKilopoundsForce(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromKilopoundsForce(value.ToDouble(null));
+                => Force.FromKilopoundsForce(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromMeganewtons(double)" />
+            /// <inheritdoc cref="Force.FromMeganewtons(QuantityValue)" />
             public Force Meganewtons
 #if NET7_0_OR_GREATER
-                => Force.FromMeganewtons(double.CreateChecked(value));
+                => Force.FromMeganewtons(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromMeganewtons(value.ToDouble(null));
+                => Force.FromMeganewtons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromMicronewtons(double)" />
+            /// <inheritdoc cref="Force.FromMicronewtons(QuantityValue)" />
             public Force Micronewtons
 #if NET7_0_OR_GREATER
-                => Force.FromMicronewtons(double.CreateChecked(value));
+                => Force.FromMicronewtons(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromMicronewtons(value.ToDouble(null));
+                => Force.FromMicronewtons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromMillinewtons(double)" />
+            /// <inheritdoc cref="Force.FromMillinewtons(QuantityValue)" />
             public Force Millinewtons
 #if NET7_0_OR_GREATER
-                => Force.FromMillinewtons(double.CreateChecked(value));
+                => Force.FromMillinewtons(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromMillinewtons(value.ToDouble(null));
+                => Force.FromMillinewtons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromNewtons(double)" />
+            /// <inheritdoc cref="Force.FromNewtons(QuantityValue)" />
             public Force Newtons
 #if NET7_0_OR_GREATER
-                => Force.FromNewtons(double.CreateChecked(value));
+                => Force.FromNewtons(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromNewtons(value.ToDouble(null));
+                => Force.FromNewtons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromOunceForce(double)" />
+            /// <inheritdoc cref="Force.FromOunceForce(QuantityValue)" />
             public Force OunceForce
 #if NET7_0_OR_GREATER
-                => Force.FromOunceForce(double.CreateChecked(value));
+                => Force.FromOunceForce(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromOunceForce(value.ToDouble(null));
+                => Force.FromOunceForce(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromPoundals(double)" />
+            /// <inheritdoc cref="Force.FromPoundals(QuantityValue)" />
             public Force Poundals
 #if NET7_0_OR_GREATER
-                => Force.FromPoundals(double.CreateChecked(value));
+                => Force.FromPoundals(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromPoundals(value.ToDouble(null));
+                => Force.FromPoundals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromPoundsForce(double)" />
+            /// <inheritdoc cref="Force.FromPoundsForce(QuantityValue)" />
             public Force PoundsForce
 #if NET7_0_OR_GREATER
-                => Force.FromPoundsForce(double.CreateChecked(value));
+                => Force.FromPoundsForce(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromPoundsForce(value.ToDouble(null));
+                => Force.FromPoundsForce(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromShortTonsForce(double)" />
+            /// <inheritdoc cref="Force.FromShortTonsForce(QuantityValue)" />
             public Force ShortTonsForce
 #if NET7_0_OR_GREATER
-                => Force.FromShortTonsForce(double.CreateChecked(value));
+                => Force.FromShortTonsForce(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromShortTonsForce(value.ToDouble(null));
+                => Force.FromShortTonsForce(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Force.FromTonnesForce(double)" />
+            /// <inheritdoc cref="Force.FromTonnesForce(QuantityValue)" />
             public Force TonnesForce
 #if NET7_0_OR_GREATER
-                => Force.FromTonnesForce(double.CreateChecked(value));
+                => Force.FromTonnesForce(QuantityValue.CreateChecked(value));
 #else
-                => Force.FromTonnesForce(value.ToDouble(null));
+                => Force.FromTonnesForce(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForcePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
index fb37a160c1..e6dc56c74a 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
@@ -42,308 +42,308 @@ public static class NumberToForcePerLengthExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerCentimeter(QuantityValue)" />
             public ForcePerLength CentinewtonsPerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromCentinewtonsPerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromCentinewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromCentinewtonsPerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromCentinewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMeter(QuantityValue)" />
             public ForcePerLength CentinewtonsPerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromCentinewtonsPerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromCentinewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromCentinewtonsPerMeter(value.ToDouble(null));
+                => ForcePerLength.FromCentinewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMillimeter(QuantityValue)" />
             public ForcePerLength CentinewtonsPerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromCentinewtonsPerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromCentinewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromCentinewtonsPerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromCentinewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerCentimeter(QuantityValue)" />
             public ForcePerLength DecanewtonsPerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromDecanewtonsPerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromDecanewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromDecanewtonsPerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromDecanewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMeter(QuantityValue)" />
             public ForcePerLength DecanewtonsPerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromDecanewtonsPerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromDecanewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromDecanewtonsPerMeter(value.ToDouble(null));
+                => ForcePerLength.FromDecanewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMillimeter(QuantityValue)" />
             public ForcePerLength DecanewtonsPerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromDecanewtonsPerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromDecanewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromDecanewtonsPerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromDecanewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerCentimeter(QuantityValue)" />
             public ForcePerLength DecinewtonsPerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromDecinewtonsPerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromDecinewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromDecinewtonsPerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromDecinewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMeter(QuantityValue)" />
             public ForcePerLength DecinewtonsPerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromDecinewtonsPerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromDecinewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromDecinewtonsPerMeter(value.ToDouble(null));
+                => ForcePerLength.FromDecinewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMillimeter(QuantityValue)" />
             public ForcePerLength DecinewtonsPerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromDecinewtonsPerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromDecinewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromDecinewtonsPerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromDecinewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerCentimeter(QuantityValue)" />
             public ForcePerLength KilogramsForcePerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromKilogramsForcePerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromKilogramsForcePerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromKilogramsForcePerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromKilogramsForcePerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMeter(QuantityValue)" />
             public ForcePerLength KilogramsForcePerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromKilogramsForcePerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromKilogramsForcePerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromKilogramsForcePerMeter(value.ToDouble(null));
+                => ForcePerLength.FromKilogramsForcePerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMillimeter(QuantityValue)" />
             public ForcePerLength KilogramsForcePerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromKilogramsForcePerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromKilogramsForcePerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromKilogramsForcePerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromKilogramsForcePerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerCentimeter(QuantityValue)" />
             public ForcePerLength KilonewtonsPerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromKilonewtonsPerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromKilonewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromKilonewtonsPerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromKilonewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMeter(QuantityValue)" />
             public ForcePerLength KilonewtonsPerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromKilonewtonsPerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromKilonewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromKilonewtonsPerMeter(value.ToDouble(null));
+                => ForcePerLength.FromKilonewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMillimeter(QuantityValue)" />
             public ForcePerLength KilonewtonsPerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromKilonewtonsPerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromKilonewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromKilonewtonsPerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromKilonewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerFoot(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerFoot(QuantityValue)" />
             public ForcePerLength KilopoundsForcePerFoot
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromKilopoundsForcePerFoot(double.CreateChecked(value));
+                => ForcePerLength.FromKilopoundsForcePerFoot(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromKilopoundsForcePerFoot(value.ToDouble(null));
+                => ForcePerLength.FromKilopoundsForcePerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerInch(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerInch(QuantityValue)" />
             public ForcePerLength KilopoundsForcePerInch
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromKilopoundsForcePerInch(double.CreateChecked(value));
+                => ForcePerLength.FromKilopoundsForcePerInch(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromKilopoundsForcePerInch(value.ToDouble(null));
+                => ForcePerLength.FromKilopoundsForcePerInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerCentimeter(QuantityValue)" />
             public ForcePerLength MeganewtonsPerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromMeganewtonsPerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromMeganewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromMeganewtonsPerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromMeganewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMeter(QuantityValue)" />
             public ForcePerLength MeganewtonsPerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromMeganewtonsPerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromMeganewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromMeganewtonsPerMeter(value.ToDouble(null));
+                => ForcePerLength.FromMeganewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMillimeter(QuantityValue)" />
             public ForcePerLength MeganewtonsPerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromMeganewtonsPerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromMeganewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromMeganewtonsPerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromMeganewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerCentimeter(QuantityValue)" />
             public ForcePerLength MicronewtonsPerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromMicronewtonsPerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromMicronewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromMicronewtonsPerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromMicronewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMeter(QuantityValue)" />
             public ForcePerLength MicronewtonsPerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromMicronewtonsPerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromMicronewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromMicronewtonsPerMeter(value.ToDouble(null));
+                => ForcePerLength.FromMicronewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMillimeter(QuantityValue)" />
             public ForcePerLength MicronewtonsPerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromMicronewtonsPerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromMicronewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromMicronewtonsPerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromMicronewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerCentimeter(QuantityValue)" />
             public ForcePerLength MillinewtonsPerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromMillinewtonsPerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromMillinewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromMillinewtonsPerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromMillinewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMeter(QuantityValue)" />
             public ForcePerLength MillinewtonsPerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromMillinewtonsPerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromMillinewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromMillinewtonsPerMeter(value.ToDouble(null));
+                => ForcePerLength.FromMillinewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMillimeter(QuantityValue)" />
             public ForcePerLength MillinewtonsPerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromMillinewtonsPerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromMillinewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromMillinewtonsPerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromMillinewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerCentimeter(QuantityValue)" />
             public ForcePerLength NanonewtonsPerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromNanonewtonsPerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromNanonewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromNanonewtonsPerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromNanonewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMeter(QuantityValue)" />
             public ForcePerLength NanonewtonsPerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromNanonewtonsPerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromNanonewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromNanonewtonsPerMeter(value.ToDouble(null));
+                => ForcePerLength.FromNanonewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMillimeter(QuantityValue)" />
             public ForcePerLength NanonewtonsPerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromNanonewtonsPerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromNanonewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromNanonewtonsPerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromNanonewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromNewtonsPerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromNewtonsPerCentimeter(QuantityValue)" />
             public ForcePerLength NewtonsPerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromNewtonsPerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromNewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromNewtonsPerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromNewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMeter(QuantityValue)" />
             public ForcePerLength NewtonsPerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromNewtonsPerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromNewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromNewtonsPerMeter(value.ToDouble(null));
+                => ForcePerLength.FromNewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMillimeter(QuantityValue)" />
             public ForcePerLength NewtonsPerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromNewtonsPerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromNewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromNewtonsPerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromNewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerFoot(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerFoot(QuantityValue)" />
             public ForcePerLength PoundsForcePerFoot
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromPoundsForcePerFoot(double.CreateChecked(value));
+                => ForcePerLength.FromPoundsForcePerFoot(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromPoundsForcePerFoot(value.ToDouble(null));
+                => ForcePerLength.FromPoundsForcePerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerInch(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerInch(QuantityValue)" />
             public ForcePerLength PoundsForcePerInch
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromPoundsForcePerInch(double.CreateChecked(value));
+                => ForcePerLength.FromPoundsForcePerInch(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromPoundsForcePerInch(value.ToDouble(null));
+                => ForcePerLength.FromPoundsForcePerInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerYard(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerYard(QuantityValue)" />
             public ForcePerLength PoundsForcePerYard
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromPoundsForcePerYard(double.CreateChecked(value));
+                => ForcePerLength.FromPoundsForcePerYard(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromPoundsForcePerYard(value.ToDouble(null));
+                => ForcePerLength.FromPoundsForcePerYard(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerCentimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerCentimeter(QuantityValue)" />
             public ForcePerLength TonnesForcePerCentimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromTonnesForcePerCentimeter(double.CreateChecked(value));
+                => ForcePerLength.FromTonnesForcePerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromTonnesForcePerCentimeter(value.ToDouble(null));
+                => ForcePerLength.FromTonnesForcePerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMeter(QuantityValue)" />
             public ForcePerLength TonnesForcePerMeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromTonnesForcePerMeter(double.CreateChecked(value));
+                => ForcePerLength.FromTonnesForcePerMeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromTonnesForcePerMeter(value.ToDouble(null));
+                => ForcePerLength.FromTonnesForcePerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMillimeter(double)" />
+            /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMillimeter(QuantityValue)" />
             public ForcePerLength TonnesForcePerMillimeter
 #if NET7_0_OR_GREATER
-                => ForcePerLength.FromTonnesForcePerMillimeter(double.CreateChecked(value));
+                => ForcePerLength.FromTonnesForcePerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => ForcePerLength.FromTonnesForcePerMillimeter(value.ToDouble(null));
+                => ForcePerLength.FromTonnesForcePerMillimeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFrequencyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFrequencyExtensions.g.cs
index 59ac6feb4e..a8c6f775ed 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFrequencyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFrequencyExtensions.g.cs
@@ -42,100 +42,100 @@ public static class NumberToFrequencyExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Frequency.FromBeatsPerMinute(double)" />
+            /// <inheritdoc cref="Frequency.FromBeatsPerMinute(QuantityValue)" />
             public Frequency BeatsPerMinute
 #if NET7_0_OR_GREATER
-                => Frequency.FromBeatsPerMinute(double.CreateChecked(value));
+                => Frequency.FromBeatsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromBeatsPerMinute(value.ToDouble(null));
+                => Frequency.FromBeatsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromCyclesPerHour(double)" />
+            /// <inheritdoc cref="Frequency.FromCyclesPerHour(QuantityValue)" />
             public Frequency CyclesPerHour
 #if NET7_0_OR_GREATER
-                => Frequency.FromCyclesPerHour(double.CreateChecked(value));
+                => Frequency.FromCyclesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromCyclesPerHour(value.ToDouble(null));
+                => Frequency.FromCyclesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromCyclesPerMinute(double)" />
+            /// <inheritdoc cref="Frequency.FromCyclesPerMinute(QuantityValue)" />
             public Frequency CyclesPerMinute
 #if NET7_0_OR_GREATER
-                => Frequency.FromCyclesPerMinute(double.CreateChecked(value));
+                => Frequency.FromCyclesPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromCyclesPerMinute(value.ToDouble(null));
+                => Frequency.FromCyclesPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromGigahertz(double)" />
+            /// <inheritdoc cref="Frequency.FromGigahertz(QuantityValue)" />
             public Frequency Gigahertz
 #if NET7_0_OR_GREATER
-                => Frequency.FromGigahertz(double.CreateChecked(value));
+                => Frequency.FromGigahertz(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromGigahertz(value.ToDouble(null));
+                => Frequency.FromGigahertz(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromHertz(double)" />
+            /// <inheritdoc cref="Frequency.FromHertz(QuantityValue)" />
             public Frequency Hertz
 #if NET7_0_OR_GREATER
-                => Frequency.FromHertz(double.CreateChecked(value));
+                => Frequency.FromHertz(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromHertz(value.ToDouble(null));
+                => Frequency.FromHertz(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromKilohertz(double)" />
+            /// <inheritdoc cref="Frequency.FromKilohertz(QuantityValue)" />
             public Frequency Kilohertz
 #if NET7_0_OR_GREATER
-                => Frequency.FromKilohertz(double.CreateChecked(value));
+                => Frequency.FromKilohertz(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromKilohertz(value.ToDouble(null));
+                => Frequency.FromKilohertz(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromMegahertz(double)" />
+            /// <inheritdoc cref="Frequency.FromMegahertz(QuantityValue)" />
             public Frequency Megahertz
 #if NET7_0_OR_GREATER
-                => Frequency.FromMegahertz(double.CreateChecked(value));
+                => Frequency.FromMegahertz(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromMegahertz(value.ToDouble(null));
+                => Frequency.FromMegahertz(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromMicrohertz(double)" />
+            /// <inheritdoc cref="Frequency.FromMicrohertz(QuantityValue)" />
             public Frequency Microhertz
 #if NET7_0_OR_GREATER
-                => Frequency.FromMicrohertz(double.CreateChecked(value));
+                => Frequency.FromMicrohertz(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromMicrohertz(value.ToDouble(null));
+                => Frequency.FromMicrohertz(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromMillihertz(double)" />
+            /// <inheritdoc cref="Frequency.FromMillihertz(QuantityValue)" />
             public Frequency Millihertz
 #if NET7_0_OR_GREATER
-                => Frequency.FromMillihertz(double.CreateChecked(value));
+                => Frequency.FromMillihertz(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromMillihertz(value.ToDouble(null));
+                => Frequency.FromMillihertz(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromPerSecond(double)" />
+            /// <inheritdoc cref="Frequency.FromPerSecond(QuantityValue)" />
             public Frequency PerSecond
 #if NET7_0_OR_GREATER
-                => Frequency.FromPerSecond(double.CreateChecked(value));
+                => Frequency.FromPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromPerSecond(value.ToDouble(null));
+                => Frequency.FromPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromRadiansPerSecond(double)" />
+            /// <inheritdoc cref="Frequency.FromRadiansPerSecond(QuantityValue)" />
             public Frequency RadiansPerSecond
 #if NET7_0_OR_GREATER
-                => Frequency.FromRadiansPerSecond(double.CreateChecked(value));
+                => Frequency.FromRadiansPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromRadiansPerSecond(value.ToDouble(null));
+                => Frequency.FromRadiansPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Frequency.FromTerahertz(double)" />
+            /// <inheritdoc cref="Frequency.FromTerahertz(QuantityValue)" />
             public Frequency Terahertz
 #if NET7_0_OR_GREATER
-                => Frequency.FromTerahertz(double.CreateChecked(value));
+                => Frequency.FromTerahertz(QuantityValue.CreateChecked(value));
 #else
-                => Frequency.FromTerahertz(value.ToDouble(null));
+                => Frequency.FromTerahertz(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
index f0a7095afa..2b3b940432 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
@@ -42,36 +42,36 @@ public static class NumberToFuelEfficiencyExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="FuelEfficiency.FromKilometersPerLiter(double)" />
+            /// <inheritdoc cref="FuelEfficiency.FromKilometersPerLiter(QuantityValue)" />
             public FuelEfficiency KilometersPerLiter
 #if NET7_0_OR_GREATER
-                => FuelEfficiency.FromKilometersPerLiter(double.CreateChecked(value));
+                => FuelEfficiency.FromKilometersPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => FuelEfficiency.FromKilometersPerLiter(value.ToDouble(null));
+                => FuelEfficiency.FromKilometersPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FuelEfficiency.FromLitersPer100Kilometers(double)" />
+            /// <inheritdoc cref="FuelEfficiency.FromLitersPer100Kilometers(QuantityValue)" />
             public FuelEfficiency LitersPer100Kilometers
 #if NET7_0_OR_GREATER
-                => FuelEfficiency.FromLitersPer100Kilometers(double.CreateChecked(value));
+                => FuelEfficiency.FromLitersPer100Kilometers(QuantityValue.CreateChecked(value));
 #else
-                => FuelEfficiency.FromLitersPer100Kilometers(value.ToDouble(null));
+                => FuelEfficiency.FromLitersPer100Kilometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FuelEfficiency.FromMilesPerUkGallon(double)" />
+            /// <inheritdoc cref="FuelEfficiency.FromMilesPerUkGallon(QuantityValue)" />
             public FuelEfficiency MilesPerUkGallon
 #if NET7_0_OR_GREATER
-                => FuelEfficiency.FromMilesPerUkGallon(double.CreateChecked(value));
+                => FuelEfficiency.FromMilesPerUkGallon(QuantityValue.CreateChecked(value));
 #else
-                => FuelEfficiency.FromMilesPerUkGallon(value.ToDouble(null));
+                => FuelEfficiency.FromMilesPerUkGallon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="FuelEfficiency.FromMilesPerUsGallon(double)" />
+            /// <inheritdoc cref="FuelEfficiency.FromMilesPerUsGallon(QuantityValue)" />
             public FuelEfficiency MilesPerUsGallon
 #if NET7_0_OR_GREATER
-                => FuelEfficiency.FromMilesPerUsGallon(double.CreateChecked(value));
+                => FuelEfficiency.FromMilesPerUsGallon(QuantityValue.CreateChecked(value));
 #else
-                => FuelEfficiency.FromMilesPerUsGallon(value.ToDouble(null));
+                => FuelEfficiency.FromMilesPerUsGallon(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatFluxExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatFluxExtensions.g.cs
index f7b649bafe..83aa76b2fd 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatFluxExtensions.g.cs
@@ -42,148 +42,204 @@ public static class NumberToHeatFluxExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="HeatFlux.FromBtusPerHourSquareFoot(double)" />
+            /// <inheritdoc cref="HeatFlux.FromBtusPerHourSquareFoot(QuantityValue)" />
             public HeatFlux BtusPerHourSquareFoot
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromBtusPerHourSquareFoot(double.CreateChecked(value));
+                => HeatFlux.FromBtusPerHourSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromBtusPerHourSquareFoot(value.ToDouble(null));
+                => HeatFlux.FromBtusPerHourSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromBtusPerMinuteSquareFoot(double)" />
+            /// <inheritdoc cref="HeatFlux.FromBtusPerMinuteSquareFoot(QuantityValue)" />
             public HeatFlux BtusPerMinuteSquareFoot
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromBtusPerMinuteSquareFoot(double.CreateChecked(value));
+                => HeatFlux.FromBtusPerMinuteSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromBtusPerMinuteSquareFoot(value.ToDouble(null));
+                => HeatFlux.FromBtusPerMinuteSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareFoot(double)" />
+            /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareFoot(QuantityValue)" />
             public HeatFlux BtusPerSecondSquareFoot
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromBtusPerSecondSquareFoot(double.CreateChecked(value));
+                => HeatFlux.FromBtusPerSecondSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromBtusPerSecondSquareFoot(value.ToDouble(null));
+                => HeatFlux.FromBtusPerSecondSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareInch(double)" />
+            /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareInch(QuantityValue)" />
             public HeatFlux BtusPerSecondSquareInch
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromBtusPerSecondSquareInch(double.CreateChecked(value));
+                => HeatFlux.FromBtusPerSecondSquareInch(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromBtusPerSecondSquareInch(value.ToDouble(null));
+                => HeatFlux.FromBtusPerSecondSquareInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromCaloriesPerSecondSquareCentimeter(double)" />
+            /// <inheritdoc cref="HeatFlux.FromCaloriesPerSecondSquareCentimeter(QuantityValue)" />
             public HeatFlux CaloriesPerSecondSquareCentimeter
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromCaloriesPerSecondSquareCentimeter(double.CreateChecked(value));
+                => HeatFlux.FromCaloriesPerSecondSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromCaloriesPerSecondSquareCentimeter(value.ToDouble(null));
+                => HeatFlux.FromCaloriesPerSecondSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMeter(QuantityValue)" />
             public HeatFlux CentiwattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromCentiwattsPerSquareMeter(double.CreateChecked(value));
+                => HeatFlux.FromCentiwattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromCentiwattsPerSquareMeter(value.ToDouble(null));
+                => HeatFlux.FromCentiwattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMillimeter(QuantityValue)" />
+            public HeatFlux CentiwattsPerSquareMillimeter
+#if NET7_0_OR_GREATER
+                => HeatFlux.FromCentiwattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
+#else
+                => HeatFlux.FromCentiwattsPerSquareMillimeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMeter(QuantityValue)" />
             public HeatFlux DeciwattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromDeciwattsPerSquareMeter(double.CreateChecked(value));
+                => HeatFlux.FromDeciwattsPerSquareMeter(QuantityValue.CreateChecked(value));
+#else
+                => HeatFlux.FromDeciwattsPerSquareMeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMillimeter(QuantityValue)" />
+            public HeatFlux DeciwattsPerSquareMillimeter
+#if NET7_0_OR_GREATER
+                => HeatFlux.FromDeciwattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromDeciwattsPerSquareMeter(value.ToDouble(null));
+                => HeatFlux.FromDeciwattsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerHourSquareMeter(double)" />
+            /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerHourSquareMeter(QuantityValue)" />
             public HeatFlux KilocaloriesPerHourSquareMeter
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromKilocaloriesPerHourSquareMeter(double.CreateChecked(value));
+                => HeatFlux.FromKilocaloriesPerHourSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromKilocaloriesPerHourSquareMeter(value.ToDouble(null));
+                => HeatFlux.FromKilocaloriesPerHourSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(double)" />
+            /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(QuantityValue)" />
             public HeatFlux KilocaloriesPerSecondSquareCentimeter
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(double.CreateChecked(value));
+                => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(value.ToDouble(null));
+                => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMeter(QuantityValue)" />
             public HeatFlux KilowattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromKilowattsPerSquareMeter(double.CreateChecked(value));
+                => HeatFlux.FromKilowattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromKilowattsPerSquareMeter(value.ToDouble(null));
+                => HeatFlux.FromKilowattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMillimeter(QuantityValue)" />
+            public HeatFlux KilowattsPerSquareMillimeter
+#if NET7_0_OR_GREATER
+                => HeatFlux.FromKilowattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
+#else
+                => HeatFlux.FromKilowattsPerSquareMillimeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMeter(QuantityValue)" />
             public HeatFlux MicrowattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromMicrowattsPerSquareMeter(double.CreateChecked(value));
+                => HeatFlux.FromMicrowattsPerSquareMeter(QuantityValue.CreateChecked(value));
+#else
+                => HeatFlux.FromMicrowattsPerSquareMeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMillimeter(QuantityValue)" />
+            public HeatFlux MicrowattsPerSquareMillimeter
+#if NET7_0_OR_GREATER
+                => HeatFlux.FromMicrowattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromMicrowattsPerSquareMeter(value.ToDouble(null));
+                => HeatFlux.FromMicrowattsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMeter(QuantityValue)" />
             public HeatFlux MilliwattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromMilliwattsPerSquareMeter(double.CreateChecked(value));
+                => HeatFlux.FromMilliwattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromMilliwattsPerSquareMeter(value.ToDouble(null));
+                => HeatFlux.FromMilliwattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMillimeter(QuantityValue)" />
+            public HeatFlux MilliwattsPerSquareMillimeter
+#if NET7_0_OR_GREATER
+                => HeatFlux.FromMilliwattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
+#else
+                => HeatFlux.FromMilliwattsPerSquareMillimeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMeter(QuantityValue)" />
             public HeatFlux NanowattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromNanowattsPerSquareMeter(double.CreateChecked(value));
+                => HeatFlux.FromNanowattsPerSquareMeter(QuantityValue.CreateChecked(value));
+#else
+                => HeatFlux.FromNanowattsPerSquareMeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMillimeter(QuantityValue)" />
+            public HeatFlux NanowattsPerSquareMillimeter
+#if NET7_0_OR_GREATER
+                => HeatFlux.FromNanowattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromNanowattsPerSquareMeter(value.ToDouble(null));
+                => HeatFlux.FromNanowattsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromPoundsForcePerFootSecond(double)" />
+            /// <inheritdoc cref="HeatFlux.FromPoundsForcePerFootSecond(QuantityValue)" />
             public HeatFlux PoundsForcePerFootSecond
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromPoundsForcePerFootSecond(double.CreateChecked(value));
+                => HeatFlux.FromPoundsForcePerFootSecond(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromPoundsForcePerFootSecond(value.ToDouble(null));
+                => HeatFlux.FromPoundsForcePerFootSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromPoundsPerSecondCubed(double)" />
+            /// <inheritdoc cref="HeatFlux.FromPoundsPerSecondCubed(QuantityValue)" />
             public HeatFlux PoundsPerSecondCubed
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromPoundsPerSecondCubed(double.CreateChecked(value));
+                => HeatFlux.FromPoundsPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromPoundsPerSecondCubed(value.ToDouble(null));
+                => HeatFlux.FromPoundsPerSecondCubed(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromWattsPerSquareFoot(double)" />
+            /// <inheritdoc cref="HeatFlux.FromWattsPerSquareFoot(QuantityValue)" />
             public HeatFlux WattsPerSquareFoot
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromWattsPerSquareFoot(double.CreateChecked(value));
+                => HeatFlux.FromWattsPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromWattsPerSquareFoot(value.ToDouble(null));
+                => HeatFlux.FromWattsPerSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromWattsPerSquareInch(double)" />
+            /// <inheritdoc cref="HeatFlux.FromWattsPerSquareInch(QuantityValue)" />
             public HeatFlux WattsPerSquareInch
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromWattsPerSquareInch(double.CreateChecked(value));
+                => HeatFlux.FromWattsPerSquareInch(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromWattsPerSquareInch(value.ToDouble(null));
+                => HeatFlux.FromWattsPerSquareInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMeter(QuantityValue)" />
             public HeatFlux WattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => HeatFlux.FromWattsPerSquareMeter(double.CreateChecked(value));
+                => HeatFlux.FromWattsPerSquareMeter(QuantityValue.CreateChecked(value));
+#else
+                => HeatFlux.FromWattsPerSquareMeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMillimeter(QuantityValue)" />
+            public HeatFlux WattsPerSquareMillimeter
+#if NET7_0_OR_GREATER
+                => HeatFlux.FromWattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => HeatFlux.FromWattsPerSquareMeter(value.ToDouble(null));
+                => HeatFlux.FromWattsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
index 275731d2e0..be77a724a1 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
@@ -42,44 +42,52 @@ public static class NumberToHeatTransferCoefficientExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(double)" />
+            /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(QuantityValue)" />
             public HeatTransferCoefficient BtusPerHourSquareFootDegreeFahrenheit
 #if NET7_0_OR_GREATER
-                => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(double.CreateChecked(value));
+                => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(QuantityValue.CreateChecked(value));
 #else
-                => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(value.ToDouble(null));
+                => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(double)" />
+            /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerSecondSquareInchDegreeFahrenheit(QuantityValue)" />
+            public HeatTransferCoefficient BtusPerSecondSquareInchDegreeFahrenheit
+#if NET7_0_OR_GREATER
+                => HeatTransferCoefficient.FromBtusPerSecondSquareInchDegreeFahrenheit(QuantityValue.CreateChecked(value));
+#else
+                => HeatTransferCoefficient.FromBtusPerSecondSquareInchDegreeFahrenheit(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(QuantityValue)" />
             public HeatTransferCoefficient CaloriesPerHourSquareMeterDegreeCelsius
 #if NET7_0_OR_GREATER
-                => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(double.CreateChecked(value));
+                => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(value.ToDouble(null));
+                => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(double)" />
+            /// <inheritdoc cref="HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(QuantityValue)" />
             public HeatTransferCoefficient KilocaloriesPerHourSquareMeterDegreeCelsius
 #if NET7_0_OR_GREATER
-                => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(double.CreateChecked(value));
+                => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(value.ToDouble(null));
+                => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(double)" />
+            /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(QuantityValue)" />
             public HeatTransferCoefficient WattsPerSquareMeterCelsius
 #if NET7_0_OR_GREATER
-                => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(double.CreateChecked(value));
+                => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(QuantityValue.CreateChecked(value));
 #else
-                => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(value.ToDouble(null));
+                => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(double)" />
+            /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(QuantityValue)" />
             public HeatTransferCoefficient WattsPerSquareMeterKelvin
 #if NET7_0_OR_GREATER
-                => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(double.CreateChecked(value));
+                => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(QuantityValue.CreateChecked(value));
 #else
-                => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(value.ToDouble(null));
+                => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIlluminanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIlluminanceExtensions.g.cs
index bd3195f004..28bb64c40c 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIlluminanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIlluminanceExtensions.g.cs
@@ -42,36 +42,36 @@ public static class NumberToIlluminanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Illuminance.FromKilolux(double)" />
+            /// <inheritdoc cref="Illuminance.FromKilolux(QuantityValue)" />
             public Illuminance Kilolux
 #if NET7_0_OR_GREATER
-                => Illuminance.FromKilolux(double.CreateChecked(value));
+                => Illuminance.FromKilolux(QuantityValue.CreateChecked(value));
 #else
-                => Illuminance.FromKilolux(value.ToDouble(null));
+                => Illuminance.FromKilolux(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Illuminance.FromLux(double)" />
+            /// <inheritdoc cref="Illuminance.FromLux(QuantityValue)" />
             public Illuminance Lux
 #if NET7_0_OR_GREATER
-                => Illuminance.FromLux(double.CreateChecked(value));
+                => Illuminance.FromLux(QuantityValue.CreateChecked(value));
 #else
-                => Illuminance.FromLux(value.ToDouble(null));
+                => Illuminance.FromLux(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Illuminance.FromMegalux(double)" />
+            /// <inheritdoc cref="Illuminance.FromMegalux(QuantityValue)" />
             public Illuminance Megalux
 #if NET7_0_OR_GREATER
-                => Illuminance.FromMegalux(double.CreateChecked(value));
+                => Illuminance.FromMegalux(QuantityValue.CreateChecked(value));
 #else
-                => Illuminance.FromMegalux(value.ToDouble(null));
+                => Illuminance.FromMegalux(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Illuminance.FromMillilux(double)" />
+            /// <inheritdoc cref="Illuminance.FromMillilux(QuantityValue)" />
             public Illuminance Millilux
 #if NET7_0_OR_GREATER
-                => Illuminance.FromMillilux(double.CreateChecked(value));
+                => Illuminance.FromMillilux(QuantityValue.CreateChecked(value));
 #else
-                => Illuminance.FromMillilux(value.ToDouble(null));
+                => Illuminance.FromMillilux(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToImpulseExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToImpulseExtensions.g.cs
index d85140e38e..2e6446bfa2 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToImpulseExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToImpulseExtensions.g.cs
@@ -42,108 +42,108 @@ public static class NumberToImpulseExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Impulse.FromCentinewtonSeconds(double)" />
+            /// <inheritdoc cref="Impulse.FromCentinewtonSeconds(QuantityValue)" />
             public Impulse CentinewtonSeconds
 #if NET7_0_OR_GREATER
-                => Impulse.FromCentinewtonSeconds(double.CreateChecked(value));
+                => Impulse.FromCentinewtonSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromCentinewtonSeconds(value.ToDouble(null));
+                => Impulse.FromCentinewtonSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromDecanewtonSeconds(double)" />
+            /// <inheritdoc cref="Impulse.FromDecanewtonSeconds(QuantityValue)" />
             public Impulse DecanewtonSeconds
 #if NET7_0_OR_GREATER
-                => Impulse.FromDecanewtonSeconds(double.CreateChecked(value));
+                => Impulse.FromDecanewtonSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromDecanewtonSeconds(value.ToDouble(null));
+                => Impulse.FromDecanewtonSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromDecinewtonSeconds(double)" />
+            /// <inheritdoc cref="Impulse.FromDecinewtonSeconds(QuantityValue)" />
             public Impulse DecinewtonSeconds
 #if NET7_0_OR_GREATER
-                => Impulse.FromDecinewtonSeconds(double.CreateChecked(value));
+                => Impulse.FromDecinewtonSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromDecinewtonSeconds(value.ToDouble(null));
+                => Impulse.FromDecinewtonSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromKilogramMetersPerSecond(double)" />
+            /// <inheritdoc cref="Impulse.FromKilogramMetersPerSecond(QuantityValue)" />
             public Impulse KilogramMetersPerSecond
 #if NET7_0_OR_GREATER
-                => Impulse.FromKilogramMetersPerSecond(double.CreateChecked(value));
+                => Impulse.FromKilogramMetersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromKilogramMetersPerSecond(value.ToDouble(null));
+                => Impulse.FromKilogramMetersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromKilonewtonSeconds(double)" />
+            /// <inheritdoc cref="Impulse.FromKilonewtonSeconds(QuantityValue)" />
             public Impulse KilonewtonSeconds
 #if NET7_0_OR_GREATER
-                => Impulse.FromKilonewtonSeconds(double.CreateChecked(value));
+                => Impulse.FromKilonewtonSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromKilonewtonSeconds(value.ToDouble(null));
+                => Impulse.FromKilonewtonSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromMeganewtonSeconds(double)" />
+            /// <inheritdoc cref="Impulse.FromMeganewtonSeconds(QuantityValue)" />
             public Impulse MeganewtonSeconds
 #if NET7_0_OR_GREATER
-                => Impulse.FromMeganewtonSeconds(double.CreateChecked(value));
+                => Impulse.FromMeganewtonSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromMeganewtonSeconds(value.ToDouble(null));
+                => Impulse.FromMeganewtonSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromMicronewtonSeconds(double)" />
+            /// <inheritdoc cref="Impulse.FromMicronewtonSeconds(QuantityValue)" />
             public Impulse MicronewtonSeconds
 #if NET7_0_OR_GREATER
-                => Impulse.FromMicronewtonSeconds(double.CreateChecked(value));
+                => Impulse.FromMicronewtonSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromMicronewtonSeconds(value.ToDouble(null));
+                => Impulse.FromMicronewtonSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromMillinewtonSeconds(double)" />
+            /// <inheritdoc cref="Impulse.FromMillinewtonSeconds(QuantityValue)" />
             public Impulse MillinewtonSeconds
 #if NET7_0_OR_GREATER
-                => Impulse.FromMillinewtonSeconds(double.CreateChecked(value));
+                => Impulse.FromMillinewtonSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromMillinewtonSeconds(value.ToDouble(null));
+                => Impulse.FromMillinewtonSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromNanonewtonSeconds(double)" />
+            /// <inheritdoc cref="Impulse.FromNanonewtonSeconds(QuantityValue)" />
             public Impulse NanonewtonSeconds
 #if NET7_0_OR_GREATER
-                => Impulse.FromNanonewtonSeconds(double.CreateChecked(value));
+                => Impulse.FromNanonewtonSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromNanonewtonSeconds(value.ToDouble(null));
+                => Impulse.FromNanonewtonSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromNewtonSeconds(double)" />
+            /// <inheritdoc cref="Impulse.FromNewtonSeconds(QuantityValue)" />
             public Impulse NewtonSeconds
 #if NET7_0_OR_GREATER
-                => Impulse.FromNewtonSeconds(double.CreateChecked(value));
+                => Impulse.FromNewtonSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromNewtonSeconds(value.ToDouble(null));
+                => Impulse.FromNewtonSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromPoundFeetPerSecond(double)" />
+            /// <inheritdoc cref="Impulse.FromPoundFeetPerSecond(QuantityValue)" />
             public Impulse PoundFeetPerSecond
 #if NET7_0_OR_GREATER
-                => Impulse.FromPoundFeetPerSecond(double.CreateChecked(value));
+                => Impulse.FromPoundFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromPoundFeetPerSecond(value.ToDouble(null));
+                => Impulse.FromPoundFeetPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromPoundForceSeconds(double)" />
+            /// <inheritdoc cref="Impulse.FromPoundForceSeconds(QuantityValue)" />
             public Impulse PoundForceSeconds
 #if NET7_0_OR_GREATER
-                => Impulse.FromPoundForceSeconds(double.CreateChecked(value));
+                => Impulse.FromPoundForceSeconds(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromPoundForceSeconds(value.ToDouble(null));
+                => Impulse.FromPoundForceSeconds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Impulse.FromSlugFeetPerSecond(double)" />
+            /// <inheritdoc cref="Impulse.FromSlugFeetPerSecond(QuantityValue)" />
             public Impulse SlugFeetPerSecond
 #if NET7_0_OR_GREATER
-                => Impulse.FromSlugFeetPerSecond(double.CreateChecked(value));
+                => Impulse.FromSlugFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Impulse.FromSlugFeetPerSecond(value.ToDouble(null));
+                => Impulse.FromSlugFeetPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToInformationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToInformationExtensions.g.cs
index 8cc433e6c3..0f13195eb0 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToInformationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToInformationExtensions.g.cs
@@ -42,316 +42,316 @@ public static class NumberToInformationExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Information.FromBits(double)" />
+            /// <inheritdoc cref="Information.FromBits(QuantityValue)" />
             public Information Bits
 #if NET7_0_OR_GREATER
-                => Information.FromBits(double.CreateChecked(value));
+                => Information.FromBits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromBits(value.ToDouble(null));
+                => Information.FromBits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromBytes(double)" />
+            /// <inheritdoc cref="Information.FromBytes(QuantityValue)" />
             public Information Bytes
 #if NET7_0_OR_GREATER
-                => Information.FromBytes(double.CreateChecked(value));
+                => Information.FromBytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromBytes(value.ToDouble(null));
+                => Information.FromBytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromExabits(double)" />
+            /// <inheritdoc cref="Information.FromExabits(QuantityValue)" />
             public Information Exabits
 #if NET7_0_OR_GREATER
-                => Information.FromExabits(double.CreateChecked(value));
+                => Information.FromExabits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromExabits(value.ToDouble(null));
+                => Information.FromExabits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromExabytes(double)" />
+            /// <inheritdoc cref="Information.FromExabytes(QuantityValue)" />
             public Information Exabytes
 #if NET7_0_OR_GREATER
-                => Information.FromExabytes(double.CreateChecked(value));
+                => Information.FromExabytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromExabytes(value.ToDouble(null));
+                => Information.FromExabytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromExaoctets(double)" />
+            /// <inheritdoc cref="Information.FromExaoctets(QuantityValue)" />
             public Information Exaoctets
 #if NET7_0_OR_GREATER
-                => Information.FromExaoctets(double.CreateChecked(value));
+                => Information.FromExaoctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromExaoctets(value.ToDouble(null));
+                => Information.FromExaoctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromExbibits(double)" />
+            /// <inheritdoc cref="Information.FromExbibits(QuantityValue)" />
             public Information Exbibits
 #if NET7_0_OR_GREATER
-                => Information.FromExbibits(double.CreateChecked(value));
+                => Information.FromExbibits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromExbibits(value.ToDouble(null));
+                => Information.FromExbibits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromExbibytes(double)" />
+            /// <inheritdoc cref="Information.FromExbibytes(QuantityValue)" />
             public Information Exbibytes
 #if NET7_0_OR_GREATER
-                => Information.FromExbibytes(double.CreateChecked(value));
+                => Information.FromExbibytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromExbibytes(value.ToDouble(null));
+                => Information.FromExbibytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromExbioctets(double)" />
+            /// <inheritdoc cref="Information.FromExbioctets(QuantityValue)" />
             public Information Exbioctets
 #if NET7_0_OR_GREATER
-                => Information.FromExbioctets(double.CreateChecked(value));
+                => Information.FromExbioctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromExbioctets(value.ToDouble(null));
+                => Information.FromExbioctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromGibibits(double)" />
+            /// <inheritdoc cref="Information.FromGibibits(QuantityValue)" />
             public Information Gibibits
 #if NET7_0_OR_GREATER
-                => Information.FromGibibits(double.CreateChecked(value));
+                => Information.FromGibibits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromGibibits(value.ToDouble(null));
+                => Information.FromGibibits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromGibibytes(double)" />
+            /// <inheritdoc cref="Information.FromGibibytes(QuantityValue)" />
             public Information Gibibytes
 #if NET7_0_OR_GREATER
-                => Information.FromGibibytes(double.CreateChecked(value));
+                => Information.FromGibibytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromGibibytes(value.ToDouble(null));
+                => Information.FromGibibytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromGibioctets(double)" />
+            /// <inheritdoc cref="Information.FromGibioctets(QuantityValue)" />
             public Information Gibioctets
 #if NET7_0_OR_GREATER
-                => Information.FromGibioctets(double.CreateChecked(value));
+                => Information.FromGibioctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromGibioctets(value.ToDouble(null));
+                => Information.FromGibioctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromGigabits(double)" />
+            /// <inheritdoc cref="Information.FromGigabits(QuantityValue)" />
             public Information Gigabits
 #if NET7_0_OR_GREATER
-                => Information.FromGigabits(double.CreateChecked(value));
+                => Information.FromGigabits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromGigabits(value.ToDouble(null));
+                => Information.FromGigabits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromGigabytes(double)" />
+            /// <inheritdoc cref="Information.FromGigabytes(QuantityValue)" />
             public Information Gigabytes
 #if NET7_0_OR_GREATER
-                => Information.FromGigabytes(double.CreateChecked(value));
+                => Information.FromGigabytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromGigabytes(value.ToDouble(null));
+                => Information.FromGigabytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromGigaoctets(double)" />
+            /// <inheritdoc cref="Information.FromGigaoctets(QuantityValue)" />
             public Information Gigaoctets
 #if NET7_0_OR_GREATER
-                => Information.FromGigaoctets(double.CreateChecked(value));
+                => Information.FromGigaoctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromGigaoctets(value.ToDouble(null));
+                => Information.FromGigaoctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromKibibits(double)" />
+            /// <inheritdoc cref="Information.FromKibibits(QuantityValue)" />
             public Information Kibibits
 #if NET7_0_OR_GREATER
-                => Information.FromKibibits(double.CreateChecked(value));
+                => Information.FromKibibits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromKibibits(value.ToDouble(null));
+                => Information.FromKibibits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromKibibytes(double)" />
+            /// <inheritdoc cref="Information.FromKibibytes(QuantityValue)" />
             public Information Kibibytes
 #if NET7_0_OR_GREATER
-                => Information.FromKibibytes(double.CreateChecked(value));
+                => Information.FromKibibytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromKibibytes(value.ToDouble(null));
+                => Information.FromKibibytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromKibioctets(double)" />
+            /// <inheritdoc cref="Information.FromKibioctets(QuantityValue)" />
             public Information Kibioctets
 #if NET7_0_OR_GREATER
-                => Information.FromKibioctets(double.CreateChecked(value));
+                => Information.FromKibioctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromKibioctets(value.ToDouble(null));
+                => Information.FromKibioctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromKilobits(double)" />
+            /// <inheritdoc cref="Information.FromKilobits(QuantityValue)" />
             public Information Kilobits
 #if NET7_0_OR_GREATER
-                => Information.FromKilobits(double.CreateChecked(value));
+                => Information.FromKilobits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromKilobits(value.ToDouble(null));
+                => Information.FromKilobits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromKilobytes(double)" />
+            /// <inheritdoc cref="Information.FromKilobytes(QuantityValue)" />
             public Information Kilobytes
 #if NET7_0_OR_GREATER
-                => Information.FromKilobytes(double.CreateChecked(value));
+                => Information.FromKilobytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromKilobytes(value.ToDouble(null));
+                => Information.FromKilobytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromKilooctets(double)" />
+            /// <inheritdoc cref="Information.FromKilooctets(QuantityValue)" />
             public Information Kilooctets
 #if NET7_0_OR_GREATER
-                => Information.FromKilooctets(double.CreateChecked(value));
+                => Information.FromKilooctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromKilooctets(value.ToDouble(null));
+                => Information.FromKilooctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromMebibits(double)" />
+            /// <inheritdoc cref="Information.FromMebibits(QuantityValue)" />
             public Information Mebibits
 #if NET7_0_OR_GREATER
-                => Information.FromMebibits(double.CreateChecked(value));
+                => Information.FromMebibits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromMebibits(value.ToDouble(null));
+                => Information.FromMebibits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromMebibytes(double)" />
+            /// <inheritdoc cref="Information.FromMebibytes(QuantityValue)" />
             public Information Mebibytes
 #if NET7_0_OR_GREATER
-                => Information.FromMebibytes(double.CreateChecked(value));
+                => Information.FromMebibytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromMebibytes(value.ToDouble(null));
+                => Information.FromMebibytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromMebioctets(double)" />
+            /// <inheritdoc cref="Information.FromMebioctets(QuantityValue)" />
             public Information Mebioctets
 #if NET7_0_OR_GREATER
-                => Information.FromMebioctets(double.CreateChecked(value));
+                => Information.FromMebioctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromMebioctets(value.ToDouble(null));
+                => Information.FromMebioctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromMegabits(double)" />
+            /// <inheritdoc cref="Information.FromMegabits(QuantityValue)" />
             public Information Megabits
 #if NET7_0_OR_GREATER
-                => Information.FromMegabits(double.CreateChecked(value));
+                => Information.FromMegabits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromMegabits(value.ToDouble(null));
+                => Information.FromMegabits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromMegabytes(double)" />
+            /// <inheritdoc cref="Information.FromMegabytes(QuantityValue)" />
             public Information Megabytes
 #if NET7_0_OR_GREATER
-                => Information.FromMegabytes(double.CreateChecked(value));
+                => Information.FromMegabytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromMegabytes(value.ToDouble(null));
+                => Information.FromMegabytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromMegaoctets(double)" />
+            /// <inheritdoc cref="Information.FromMegaoctets(QuantityValue)" />
             public Information Megaoctets
 #if NET7_0_OR_GREATER
-                => Information.FromMegaoctets(double.CreateChecked(value));
+                => Information.FromMegaoctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromMegaoctets(value.ToDouble(null));
+                => Information.FromMegaoctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromOctets(double)" />
+            /// <inheritdoc cref="Information.FromOctets(QuantityValue)" />
             public Information Octets
 #if NET7_0_OR_GREATER
-                => Information.FromOctets(double.CreateChecked(value));
+                => Information.FromOctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromOctets(value.ToDouble(null));
+                => Information.FromOctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromPebibits(double)" />
+            /// <inheritdoc cref="Information.FromPebibits(QuantityValue)" />
             public Information Pebibits
 #if NET7_0_OR_GREATER
-                => Information.FromPebibits(double.CreateChecked(value));
+                => Information.FromPebibits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromPebibits(value.ToDouble(null));
+                => Information.FromPebibits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromPebibytes(double)" />
+            /// <inheritdoc cref="Information.FromPebibytes(QuantityValue)" />
             public Information Pebibytes
 #if NET7_0_OR_GREATER
-                => Information.FromPebibytes(double.CreateChecked(value));
+                => Information.FromPebibytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromPebibytes(value.ToDouble(null));
+                => Information.FromPebibytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromPebioctets(double)" />
+            /// <inheritdoc cref="Information.FromPebioctets(QuantityValue)" />
             public Information Pebioctets
 #if NET7_0_OR_GREATER
-                => Information.FromPebioctets(double.CreateChecked(value));
+                => Information.FromPebioctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromPebioctets(value.ToDouble(null));
+                => Information.FromPebioctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromPetabits(double)" />
+            /// <inheritdoc cref="Information.FromPetabits(QuantityValue)" />
             public Information Petabits
 #if NET7_0_OR_GREATER
-                => Information.FromPetabits(double.CreateChecked(value));
+                => Information.FromPetabits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromPetabits(value.ToDouble(null));
+                => Information.FromPetabits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromPetabytes(double)" />
+            /// <inheritdoc cref="Information.FromPetabytes(QuantityValue)" />
             public Information Petabytes
 #if NET7_0_OR_GREATER
-                => Information.FromPetabytes(double.CreateChecked(value));
+                => Information.FromPetabytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromPetabytes(value.ToDouble(null));
+                => Information.FromPetabytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromPetaoctets(double)" />
+            /// <inheritdoc cref="Information.FromPetaoctets(QuantityValue)" />
             public Information Petaoctets
 #if NET7_0_OR_GREATER
-                => Information.FromPetaoctets(double.CreateChecked(value));
+                => Information.FromPetaoctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromPetaoctets(value.ToDouble(null));
+                => Information.FromPetaoctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromTebibits(double)" />
+            /// <inheritdoc cref="Information.FromTebibits(QuantityValue)" />
             public Information Tebibits
 #if NET7_0_OR_GREATER
-                => Information.FromTebibits(double.CreateChecked(value));
+                => Information.FromTebibits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromTebibits(value.ToDouble(null));
+                => Information.FromTebibits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromTebibytes(double)" />
+            /// <inheritdoc cref="Information.FromTebibytes(QuantityValue)" />
             public Information Tebibytes
 #if NET7_0_OR_GREATER
-                => Information.FromTebibytes(double.CreateChecked(value));
+                => Information.FromTebibytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromTebibytes(value.ToDouble(null));
+                => Information.FromTebibytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromTebioctets(double)" />
+            /// <inheritdoc cref="Information.FromTebioctets(QuantityValue)" />
             public Information Tebioctets
 #if NET7_0_OR_GREATER
-                => Information.FromTebioctets(double.CreateChecked(value));
+                => Information.FromTebioctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromTebioctets(value.ToDouble(null));
+                => Information.FromTebioctets(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromTerabits(double)" />
+            /// <inheritdoc cref="Information.FromTerabits(QuantityValue)" />
             public Information Terabits
 #if NET7_0_OR_GREATER
-                => Information.FromTerabits(double.CreateChecked(value));
+                => Information.FromTerabits(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromTerabits(value.ToDouble(null));
+                => Information.FromTerabits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromTerabytes(double)" />
+            /// <inheritdoc cref="Information.FromTerabytes(QuantityValue)" />
             public Information Terabytes
 #if NET7_0_OR_GREATER
-                => Information.FromTerabytes(double.CreateChecked(value));
+                => Information.FromTerabytes(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromTerabytes(value.ToDouble(null));
+                => Information.FromTerabytes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Information.FromTeraoctets(double)" />
+            /// <inheritdoc cref="Information.FromTeraoctets(QuantityValue)" />
             public Information Teraoctets
 #if NET7_0_OR_GREATER
-                => Information.FromTeraoctets(double.CreateChecked(value));
+                => Information.FromTeraoctets(QuantityValue.CreateChecked(value));
 #else
-                => Information.FromTeraoctets(value.ToDouble(null));
+                => Information.FromTeraoctets(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradianceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradianceExtensions.g.cs
index 61ae70193c..81079cb289 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradianceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradianceExtensions.g.cs
@@ -42,116 +42,116 @@ public static class NumberToIrradianceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareCentimeter(QuantityValue)" />
             public Irradiance KilowattsPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromKilowattsPerSquareCentimeter(double.CreateChecked(value));
+                => Irradiance.FromKilowattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromKilowattsPerSquareCentimeter(value.ToDouble(null));
+                => Irradiance.FromKilowattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareMeter(QuantityValue)" />
             public Irradiance KilowattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromKilowattsPerSquareMeter(double.CreateChecked(value));
+                => Irradiance.FromKilowattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromKilowattsPerSquareMeter(value.ToDouble(null));
+                => Irradiance.FromKilowattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareCentimeter(QuantityValue)" />
             public Irradiance MegawattsPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromMegawattsPerSquareCentimeter(double.CreateChecked(value));
+                => Irradiance.FromMegawattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromMegawattsPerSquareCentimeter(value.ToDouble(null));
+                => Irradiance.FromMegawattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareMeter(QuantityValue)" />
             public Irradiance MegawattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromMegawattsPerSquareMeter(double.CreateChecked(value));
+                => Irradiance.FromMegawattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromMegawattsPerSquareMeter(value.ToDouble(null));
+                => Irradiance.FromMegawattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareCentimeter(QuantityValue)" />
             public Irradiance MicrowattsPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromMicrowattsPerSquareCentimeter(double.CreateChecked(value));
+                => Irradiance.FromMicrowattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromMicrowattsPerSquareCentimeter(value.ToDouble(null));
+                => Irradiance.FromMicrowattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareMeter(QuantityValue)" />
             public Irradiance MicrowattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromMicrowattsPerSquareMeter(double.CreateChecked(value));
+                => Irradiance.FromMicrowattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromMicrowattsPerSquareMeter(value.ToDouble(null));
+                => Irradiance.FromMicrowattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareCentimeter(QuantityValue)" />
             public Irradiance MilliwattsPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromMilliwattsPerSquareCentimeter(double.CreateChecked(value));
+                => Irradiance.FromMilliwattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromMilliwattsPerSquareCentimeter(value.ToDouble(null));
+                => Irradiance.FromMilliwattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareMeter(QuantityValue)" />
             public Irradiance MilliwattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromMilliwattsPerSquareMeter(double.CreateChecked(value));
+                => Irradiance.FromMilliwattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromMilliwattsPerSquareMeter(value.ToDouble(null));
+                => Irradiance.FromMilliwattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareCentimeter(QuantityValue)" />
             public Irradiance NanowattsPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromNanowattsPerSquareCentimeter(double.CreateChecked(value));
+                => Irradiance.FromNanowattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromNanowattsPerSquareCentimeter(value.ToDouble(null));
+                => Irradiance.FromNanowattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareMeter(QuantityValue)" />
             public Irradiance NanowattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromNanowattsPerSquareMeter(double.CreateChecked(value));
+                => Irradiance.FromNanowattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromNanowattsPerSquareMeter(value.ToDouble(null));
+                => Irradiance.FromNanowattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareCentimeter(QuantityValue)" />
             public Irradiance PicowattsPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromPicowattsPerSquareCentimeter(double.CreateChecked(value));
+                => Irradiance.FromPicowattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromPicowattsPerSquareCentimeter(value.ToDouble(null));
+                => Irradiance.FromPicowattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareMeter(QuantityValue)" />
             public Irradiance PicowattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromPicowattsPerSquareMeter(double.CreateChecked(value));
+                => Irradiance.FromPicowattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromPicowattsPerSquareMeter(value.ToDouble(null));
+                => Irradiance.FromPicowattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromWattsPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromWattsPerSquareCentimeter(QuantityValue)" />
             public Irradiance WattsPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromWattsPerSquareCentimeter(double.CreateChecked(value));
+                => Irradiance.FromWattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromWattsPerSquareCentimeter(value.ToDouble(null));
+                => Irradiance.FromWattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiance.FromWattsPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiance.FromWattsPerSquareMeter(QuantityValue)" />
             public Irradiance WattsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiance.FromWattsPerSquareMeter(double.CreateChecked(value));
+                => Irradiance.FromWattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiance.FromWattsPerSquareMeter(value.ToDouble(null));
+                => Irradiance.FromWattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradiationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradiationExtensions.g.cs
index 4a873284ec..5d5b484a7e 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradiationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradiationExtensions.g.cs
@@ -42,76 +42,76 @@ public static class NumberToIrradiationExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Irradiation.FromBtusPerSquareFoot(double)" />
+            /// <inheritdoc cref="Irradiation.FromBtusPerSquareFoot(QuantityValue)" />
             public Irradiation BtusPerSquareFoot
 #if NET7_0_OR_GREATER
-                => Irradiation.FromBtusPerSquareFoot(double.CreateChecked(value));
+                => Irradiation.FromBtusPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => Irradiation.FromBtusPerSquareFoot(value.ToDouble(null));
+                => Irradiation.FromBtusPerSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiation.FromJoulesPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Irradiation.FromJoulesPerSquareCentimeter(QuantityValue)" />
             public Irradiation JoulesPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Irradiation.FromJoulesPerSquareCentimeter(double.CreateChecked(value));
+                => Irradiation.FromJoulesPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiation.FromJoulesPerSquareCentimeter(value.ToDouble(null));
+                => Irradiation.FromJoulesPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMeter(QuantityValue)" />
             public Irradiation JoulesPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiation.FromJoulesPerSquareMeter(double.CreateChecked(value));
+                => Irradiation.FromJoulesPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiation.FromJoulesPerSquareMeter(value.ToDouble(null));
+                => Irradiation.FromJoulesPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMillimeter(double)" />
+            /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMillimeter(QuantityValue)" />
             public Irradiation JoulesPerSquareMillimeter
 #if NET7_0_OR_GREATER
-                => Irradiation.FromJoulesPerSquareMillimeter(double.CreateChecked(value));
+                => Irradiation.FromJoulesPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiation.FromJoulesPerSquareMillimeter(value.ToDouble(null));
+                => Irradiation.FromJoulesPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiation.FromKilobtusPerSquareFoot(double)" />
+            /// <inheritdoc cref="Irradiation.FromKilobtusPerSquareFoot(QuantityValue)" />
             public Irradiation KilobtusPerSquareFoot
 #if NET7_0_OR_GREATER
-                => Irradiation.FromKilobtusPerSquareFoot(double.CreateChecked(value));
+                => Irradiation.FromKilobtusPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => Irradiation.FromKilobtusPerSquareFoot(value.ToDouble(null));
+                => Irradiation.FromKilobtusPerSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiation.FromKilojoulesPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiation.FromKilojoulesPerSquareMeter(QuantityValue)" />
             public Irradiation KilojoulesPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiation.FromKilojoulesPerSquareMeter(double.CreateChecked(value));
+                => Irradiation.FromKilojoulesPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiation.FromKilojoulesPerSquareMeter(value.ToDouble(null));
+                => Irradiation.FromKilojoulesPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiation.FromKilowattHoursPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiation.FromKilowattHoursPerSquareMeter(QuantityValue)" />
             public Irradiation KilowattHoursPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiation.FromKilowattHoursPerSquareMeter(double.CreateChecked(value));
+                => Irradiation.FromKilowattHoursPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiation.FromKilowattHoursPerSquareMeter(value.ToDouble(null));
+                => Irradiation.FromKilowattHoursPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiation.FromMillijoulesPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Irradiation.FromMillijoulesPerSquareCentimeter(QuantityValue)" />
             public Irradiation MillijoulesPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Irradiation.FromMillijoulesPerSquareCentimeter(double.CreateChecked(value));
+                => Irradiation.FromMillijoulesPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiation.FromMillijoulesPerSquareCentimeter(value.ToDouble(null));
+                => Irradiation.FromMillijoulesPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Irradiation.FromWattHoursPerSquareMeter(double)" />
+            /// <inheritdoc cref="Irradiation.FromWattHoursPerSquareMeter(QuantityValue)" />
             public Irradiation WattHoursPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Irradiation.FromWattHoursPerSquareMeter(double.CreateChecked(value));
+                => Irradiation.FromWattHoursPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Irradiation.FromWattHoursPerSquareMeter(value.ToDouble(null));
+                => Irradiation.FromWattHoursPerSquareMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToJerkExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToJerkExtensions.g.cs
index 0f7e6a25da..91480f8d21 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToJerkExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToJerkExtensions.g.cs
@@ -42,92 +42,92 @@ public static class NumberToJerkExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Jerk.FromCentimetersPerSecondCubed(double)" />
+            /// <inheritdoc cref="Jerk.FromCentimetersPerSecondCubed(QuantityValue)" />
             public Jerk CentimetersPerSecondCubed
 #if NET7_0_OR_GREATER
-                => Jerk.FromCentimetersPerSecondCubed(double.CreateChecked(value));
+                => Jerk.FromCentimetersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromCentimetersPerSecondCubed(value.ToDouble(null));
+                => Jerk.FromCentimetersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Jerk.FromDecimetersPerSecondCubed(double)" />
+            /// <inheritdoc cref="Jerk.FromDecimetersPerSecondCubed(QuantityValue)" />
             public Jerk DecimetersPerSecondCubed
 #if NET7_0_OR_GREATER
-                => Jerk.FromDecimetersPerSecondCubed(double.CreateChecked(value));
+                => Jerk.FromDecimetersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromDecimetersPerSecondCubed(value.ToDouble(null));
+                => Jerk.FromDecimetersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Jerk.FromFeetPerSecondCubed(double)" />
+            /// <inheritdoc cref="Jerk.FromFeetPerSecondCubed(QuantityValue)" />
             public Jerk FeetPerSecondCubed
 #if NET7_0_OR_GREATER
-                => Jerk.FromFeetPerSecondCubed(double.CreateChecked(value));
+                => Jerk.FromFeetPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromFeetPerSecondCubed(value.ToDouble(null));
+                => Jerk.FromFeetPerSecondCubed(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Jerk.FromInchesPerSecondCubed(double)" />
+            /// <inheritdoc cref="Jerk.FromInchesPerSecondCubed(QuantityValue)" />
             public Jerk InchesPerSecondCubed
 #if NET7_0_OR_GREATER
-                => Jerk.FromInchesPerSecondCubed(double.CreateChecked(value));
+                => Jerk.FromInchesPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromInchesPerSecondCubed(value.ToDouble(null));
+                => Jerk.FromInchesPerSecondCubed(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Jerk.FromKilometersPerSecondCubed(double)" />
+            /// <inheritdoc cref="Jerk.FromKilometersPerSecondCubed(QuantityValue)" />
             public Jerk KilometersPerSecondCubed
 #if NET7_0_OR_GREATER
-                => Jerk.FromKilometersPerSecondCubed(double.CreateChecked(value));
+                => Jerk.FromKilometersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromKilometersPerSecondCubed(value.ToDouble(null));
+                => Jerk.FromKilometersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Jerk.FromMetersPerSecondCubed(double)" />
+            /// <inheritdoc cref="Jerk.FromMetersPerSecondCubed(QuantityValue)" />
             public Jerk MetersPerSecondCubed
 #if NET7_0_OR_GREATER
-                => Jerk.FromMetersPerSecondCubed(double.CreateChecked(value));
+                => Jerk.FromMetersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromMetersPerSecondCubed(value.ToDouble(null));
+                => Jerk.FromMetersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Jerk.FromMicrometersPerSecondCubed(double)" />
+            /// <inheritdoc cref="Jerk.FromMicrometersPerSecondCubed(QuantityValue)" />
             public Jerk MicrometersPerSecondCubed
 #if NET7_0_OR_GREATER
-                => Jerk.FromMicrometersPerSecondCubed(double.CreateChecked(value));
+                => Jerk.FromMicrometersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromMicrometersPerSecondCubed(value.ToDouble(null));
+                => Jerk.FromMicrometersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Jerk.FromMillimetersPerSecondCubed(double)" />
+            /// <inheritdoc cref="Jerk.FromMillimetersPerSecondCubed(QuantityValue)" />
             public Jerk MillimetersPerSecondCubed
 #if NET7_0_OR_GREATER
-                => Jerk.FromMillimetersPerSecondCubed(double.CreateChecked(value));
+                => Jerk.FromMillimetersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromMillimetersPerSecondCubed(value.ToDouble(null));
+                => Jerk.FromMillimetersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Jerk.FromMillistandardGravitiesPerSecond(double)" />
+            /// <inheritdoc cref="Jerk.FromMillistandardGravitiesPerSecond(QuantityValue)" />
             public Jerk MillistandardGravitiesPerSecond
 #if NET7_0_OR_GREATER
-                => Jerk.FromMillistandardGravitiesPerSecond(double.CreateChecked(value));
+                => Jerk.FromMillistandardGravitiesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromMillistandardGravitiesPerSecond(value.ToDouble(null));
+                => Jerk.FromMillistandardGravitiesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Jerk.FromNanometersPerSecondCubed(double)" />
+            /// <inheritdoc cref="Jerk.FromNanometersPerSecondCubed(QuantityValue)" />
             public Jerk NanometersPerSecondCubed
 #if NET7_0_OR_GREATER
-                => Jerk.FromNanometersPerSecondCubed(double.CreateChecked(value));
+                => Jerk.FromNanometersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromNanometersPerSecondCubed(value.ToDouble(null));
+                => Jerk.FromNanometersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Jerk.FromStandardGravitiesPerSecond(double)" />
+            /// <inheritdoc cref="Jerk.FromStandardGravitiesPerSecond(QuantityValue)" />
             public Jerk StandardGravitiesPerSecond
 #if NET7_0_OR_GREATER
-                => Jerk.FromStandardGravitiesPerSecond(double.CreateChecked(value));
+                => Jerk.FromStandardGravitiesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Jerk.FromStandardGravitiesPerSecond(value.ToDouble(null));
+                => Jerk.FromStandardGravitiesPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
index 2106f8c877..6fbe4c6a90 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
@@ -42,76 +42,76 @@ public static class NumberToKinematicViscosityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="KinematicViscosity.FromCentistokes(double)" />
+            /// <inheritdoc cref="KinematicViscosity.FromCentistokes(QuantityValue)" />
             public KinematicViscosity Centistokes
 #if NET7_0_OR_GREATER
-                => KinematicViscosity.FromCentistokes(double.CreateChecked(value));
+                => KinematicViscosity.FromCentistokes(QuantityValue.CreateChecked(value));
 #else
-                => KinematicViscosity.FromCentistokes(value.ToDouble(null));
+                => KinematicViscosity.FromCentistokes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="KinematicViscosity.FromDecistokes(double)" />
+            /// <inheritdoc cref="KinematicViscosity.FromDecistokes(QuantityValue)" />
             public KinematicViscosity Decistokes
 #if NET7_0_OR_GREATER
-                => KinematicViscosity.FromDecistokes(double.CreateChecked(value));
+                => KinematicViscosity.FromDecistokes(QuantityValue.CreateChecked(value));
 #else
-                => KinematicViscosity.FromDecistokes(value.ToDouble(null));
+                => KinematicViscosity.FromDecistokes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="KinematicViscosity.FromKilostokes(double)" />
+            /// <inheritdoc cref="KinematicViscosity.FromKilostokes(QuantityValue)" />
             public KinematicViscosity Kilostokes
 #if NET7_0_OR_GREATER
-                => KinematicViscosity.FromKilostokes(double.CreateChecked(value));
+                => KinematicViscosity.FromKilostokes(QuantityValue.CreateChecked(value));
 #else
-                => KinematicViscosity.FromKilostokes(value.ToDouble(null));
+                => KinematicViscosity.FromKilostokes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="KinematicViscosity.FromMicrostokes(double)" />
+            /// <inheritdoc cref="KinematicViscosity.FromMicrostokes(QuantityValue)" />
             public KinematicViscosity Microstokes
 #if NET7_0_OR_GREATER
-                => KinematicViscosity.FromMicrostokes(double.CreateChecked(value));
+                => KinematicViscosity.FromMicrostokes(QuantityValue.CreateChecked(value));
 #else
-                => KinematicViscosity.FromMicrostokes(value.ToDouble(null));
+                => KinematicViscosity.FromMicrostokes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="KinematicViscosity.FromMillistokes(double)" />
+            /// <inheritdoc cref="KinematicViscosity.FromMillistokes(QuantityValue)" />
             public KinematicViscosity Millistokes
 #if NET7_0_OR_GREATER
-                => KinematicViscosity.FromMillistokes(double.CreateChecked(value));
+                => KinematicViscosity.FromMillistokes(QuantityValue.CreateChecked(value));
 #else
-                => KinematicViscosity.FromMillistokes(value.ToDouble(null));
+                => KinematicViscosity.FromMillistokes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="KinematicViscosity.FromNanostokes(double)" />
+            /// <inheritdoc cref="KinematicViscosity.FromNanostokes(QuantityValue)" />
             public KinematicViscosity Nanostokes
 #if NET7_0_OR_GREATER
-                => KinematicViscosity.FromNanostokes(double.CreateChecked(value));
+                => KinematicViscosity.FromNanostokes(QuantityValue.CreateChecked(value));
 #else
-                => KinematicViscosity.FromNanostokes(value.ToDouble(null));
+                => KinematicViscosity.FromNanostokes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="KinematicViscosity.FromSquareFeetPerSecond(double)" />
+            /// <inheritdoc cref="KinematicViscosity.FromSquareFeetPerSecond(QuantityValue)" />
             public KinematicViscosity SquareFeetPerSecond
 #if NET7_0_OR_GREATER
-                => KinematicViscosity.FromSquareFeetPerSecond(double.CreateChecked(value));
+                => KinematicViscosity.FromSquareFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => KinematicViscosity.FromSquareFeetPerSecond(value.ToDouble(null));
+                => KinematicViscosity.FromSquareFeetPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(double)" />
+            /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(QuantityValue)" />
             public KinematicViscosity SquareMetersPerSecond
 #if NET7_0_OR_GREATER
-                => KinematicViscosity.FromSquareMetersPerSecond(double.CreateChecked(value));
+                => KinematicViscosity.FromSquareMetersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => KinematicViscosity.FromSquareMetersPerSecond(value.ToDouble(null));
+                => KinematicViscosity.FromSquareMetersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="KinematicViscosity.FromStokes(double)" />
+            /// <inheritdoc cref="KinematicViscosity.FromStokes(QuantityValue)" />
             public KinematicViscosity Stokes
 #if NET7_0_OR_GREATER
-                => KinematicViscosity.FromStokes(double.CreateChecked(value));
+                => KinematicViscosity.FromStokes(QuantityValue.CreateChecked(value));
 #else
-                => KinematicViscosity.FromStokes(value.ToDouble(null));
+                => KinematicViscosity.FromStokes(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLeakRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLeakRateExtensions.g.cs
index 4945d7541c..4dcca9e79f 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLeakRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLeakRateExtensions.g.cs
@@ -42,36 +42,36 @@ public static class NumberToLeakRateExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="LeakRate.FromAtmCubicCentimetersPerSecond(double)" />
+            /// <inheritdoc cref="LeakRate.FromAtmCubicCentimetersPerSecond(QuantityValue)" />
             public LeakRate AtmCubicCentimetersPerSecond
 #if NET7_0_OR_GREATER
-                => LeakRate.FromAtmCubicCentimetersPerSecond(double.CreateChecked(value));
+                => LeakRate.FromAtmCubicCentimetersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => LeakRate.FromAtmCubicCentimetersPerSecond(value.ToDouble(null));
+                => LeakRate.FromAtmCubicCentimetersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LeakRate.FromMillibarLitersPerSecond(double)" />
+            /// <inheritdoc cref="LeakRate.FromMillibarLitersPerSecond(QuantityValue)" />
             public LeakRate MillibarLitersPerSecond
 #if NET7_0_OR_GREATER
-                => LeakRate.FromMillibarLitersPerSecond(double.CreateChecked(value));
+                => LeakRate.FromMillibarLitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => LeakRate.FromMillibarLitersPerSecond(value.ToDouble(null));
+                => LeakRate.FromMillibarLitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LeakRate.FromPascalCubicMetersPerSecond(double)" />
+            /// <inheritdoc cref="LeakRate.FromPascalCubicMetersPerSecond(QuantityValue)" />
             public LeakRate PascalCubicMetersPerSecond
 #if NET7_0_OR_GREATER
-                => LeakRate.FromPascalCubicMetersPerSecond(double.CreateChecked(value));
+                => LeakRate.FromPascalCubicMetersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => LeakRate.FromPascalCubicMetersPerSecond(value.ToDouble(null));
+                => LeakRate.FromPascalCubicMetersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LeakRate.FromTorrLitersPerSecond(double)" />
+            /// <inheritdoc cref="LeakRate.FromTorrLitersPerSecond(QuantityValue)" />
             public LeakRate TorrLitersPerSecond
 #if NET7_0_OR_GREATER
-                => LeakRate.FromTorrLitersPerSecond(double.CreateChecked(value));
+                => LeakRate.FromTorrLitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => LeakRate.FromTorrLitersPerSecond(value.ToDouble(null));
+                => LeakRate.FromTorrLitersPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLengthExtensions.g.cs
index 716ebe78b0..1d8373d265 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLengthExtensions.g.cs
@@ -42,340 +42,340 @@ public static class NumberToLengthExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Length.FromAngstroms(double)" />
+            /// <inheritdoc cref="Length.FromAngstroms(QuantityValue)" />
             public Length Angstroms
 #if NET7_0_OR_GREATER
-                => Length.FromAngstroms(double.CreateChecked(value));
+                => Length.FromAngstroms(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromAngstroms(value.ToDouble(null));
+                => Length.FromAngstroms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromAstronomicalUnits(double)" />
+            /// <inheritdoc cref="Length.FromAstronomicalUnits(QuantityValue)" />
             public Length AstronomicalUnits
 #if NET7_0_OR_GREATER
-                => Length.FromAstronomicalUnits(double.CreateChecked(value));
+                => Length.FromAstronomicalUnits(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromAstronomicalUnits(value.ToDouble(null));
+                => Length.FromAstronomicalUnits(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromCentimeters(double)" />
+            /// <inheritdoc cref="Length.FromCentimeters(QuantityValue)" />
             public Length Centimeters
 #if NET7_0_OR_GREATER
-                => Length.FromCentimeters(double.CreateChecked(value));
+                => Length.FromCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromCentimeters(value.ToDouble(null));
+                => Length.FromCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromChains(double)" />
+            /// <inheritdoc cref="Length.FromChains(QuantityValue)" />
             public Length Chains
 #if NET7_0_OR_GREATER
-                => Length.FromChains(double.CreateChecked(value));
+                => Length.FromChains(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromChains(value.ToDouble(null));
+                => Length.FromChains(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromDataMiles(double)" />
+            /// <inheritdoc cref="Length.FromDataMiles(QuantityValue)" />
             public Length DataMiles
 #if NET7_0_OR_GREATER
-                => Length.FromDataMiles(double.CreateChecked(value));
+                => Length.FromDataMiles(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromDataMiles(value.ToDouble(null));
+                => Length.FromDataMiles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromDecameters(double)" />
+            /// <inheritdoc cref="Length.FromDecameters(QuantityValue)" />
             public Length Decameters
 #if NET7_0_OR_GREATER
-                => Length.FromDecameters(double.CreateChecked(value));
+                => Length.FromDecameters(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromDecameters(value.ToDouble(null));
+                => Length.FromDecameters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromDecimeters(double)" />
+            /// <inheritdoc cref="Length.FromDecimeters(QuantityValue)" />
             public Length Decimeters
 #if NET7_0_OR_GREATER
-                => Length.FromDecimeters(double.CreateChecked(value));
+                => Length.FromDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromDecimeters(value.ToDouble(null));
+                => Length.FromDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromDtpPicas(double)" />
+            /// <inheritdoc cref="Length.FromDtpPicas(QuantityValue)" />
             public Length DtpPicas
 #if NET7_0_OR_GREATER
-                => Length.FromDtpPicas(double.CreateChecked(value));
+                => Length.FromDtpPicas(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromDtpPicas(value.ToDouble(null));
+                => Length.FromDtpPicas(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromDtpPoints(double)" />
+            /// <inheritdoc cref="Length.FromDtpPoints(QuantityValue)" />
             public Length DtpPoints
 #if NET7_0_OR_GREATER
-                => Length.FromDtpPoints(double.CreateChecked(value));
+                => Length.FromDtpPoints(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromDtpPoints(value.ToDouble(null));
+                => Length.FromDtpPoints(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromFathoms(double)" />
+            /// <inheritdoc cref="Length.FromFathoms(QuantityValue)" />
             public Length Fathoms
 #if NET7_0_OR_GREATER
-                => Length.FromFathoms(double.CreateChecked(value));
+                => Length.FromFathoms(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromFathoms(value.ToDouble(null));
+                => Length.FromFathoms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromFemtometers(double)" />
+            /// <inheritdoc cref="Length.FromFemtometers(QuantityValue)" />
             public Length Femtometers
 #if NET7_0_OR_GREATER
-                => Length.FromFemtometers(double.CreateChecked(value));
+                => Length.FromFemtometers(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromFemtometers(value.ToDouble(null));
+                => Length.FromFemtometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromFeet(double)" />
+            /// <inheritdoc cref="Length.FromFeet(QuantityValue)" />
             public Length Feet
 #if NET7_0_OR_GREATER
-                => Length.FromFeet(double.CreateChecked(value));
+                => Length.FromFeet(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromFeet(value.ToDouble(null));
+                => Length.FromFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromGigameters(double)" />
+            /// <inheritdoc cref="Length.FromGigameters(QuantityValue)" />
             public Length Gigameters
 #if NET7_0_OR_GREATER
-                => Length.FromGigameters(double.CreateChecked(value));
+                => Length.FromGigameters(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromGigameters(value.ToDouble(null));
+                => Length.FromGigameters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromHands(double)" />
+            /// <inheritdoc cref="Length.FromHands(QuantityValue)" />
             public Length Hands
 #if NET7_0_OR_GREATER
-                => Length.FromHands(double.CreateChecked(value));
+                => Length.FromHands(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromHands(value.ToDouble(null));
+                => Length.FromHands(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromHectometers(double)" />
+            /// <inheritdoc cref="Length.FromHectometers(QuantityValue)" />
             public Length Hectometers
 #if NET7_0_OR_GREATER
-                => Length.FromHectometers(double.CreateChecked(value));
+                => Length.FromHectometers(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromHectometers(value.ToDouble(null));
+                => Length.FromHectometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromInches(double)" />
+            /// <inheritdoc cref="Length.FromInches(QuantityValue)" />
             public Length Inches
 #if NET7_0_OR_GREATER
-                => Length.FromInches(double.CreateChecked(value));
+                => Length.FromInches(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromInches(value.ToDouble(null));
+                => Length.FromInches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromKilofeet(double)" />
+            /// <inheritdoc cref="Length.FromKilofeet(QuantityValue)" />
             public Length Kilofeet
 #if NET7_0_OR_GREATER
-                => Length.FromKilofeet(double.CreateChecked(value));
+                => Length.FromKilofeet(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromKilofeet(value.ToDouble(null));
+                => Length.FromKilofeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromKilolightYears(double)" />
+            /// <inheritdoc cref="Length.FromKilolightYears(QuantityValue)" />
             public Length KilolightYears
 #if NET7_0_OR_GREATER
-                => Length.FromKilolightYears(double.CreateChecked(value));
+                => Length.FromKilolightYears(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromKilolightYears(value.ToDouble(null));
+                => Length.FromKilolightYears(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromKilometers(double)" />
+            /// <inheritdoc cref="Length.FromKilometers(QuantityValue)" />
             public Length Kilometers
 #if NET7_0_OR_GREATER
-                => Length.FromKilometers(double.CreateChecked(value));
+                => Length.FromKilometers(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromKilometers(value.ToDouble(null));
+                => Length.FromKilometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromKiloparsecs(double)" />
+            /// <inheritdoc cref="Length.FromKiloparsecs(QuantityValue)" />
             public Length Kiloparsecs
 #if NET7_0_OR_GREATER
-                => Length.FromKiloparsecs(double.CreateChecked(value));
+                => Length.FromKiloparsecs(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromKiloparsecs(value.ToDouble(null));
+                => Length.FromKiloparsecs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromKiloyards(double)" />
+            /// <inheritdoc cref="Length.FromKiloyards(QuantityValue)" />
             public Length Kiloyards
 #if NET7_0_OR_GREATER
-                => Length.FromKiloyards(double.CreateChecked(value));
+                => Length.FromKiloyards(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromKiloyards(value.ToDouble(null));
+                => Length.FromKiloyards(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromLightYears(double)" />
+            /// <inheritdoc cref="Length.FromLightYears(QuantityValue)" />
             public Length LightYears
 #if NET7_0_OR_GREATER
-                => Length.FromLightYears(double.CreateChecked(value));
+                => Length.FromLightYears(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromLightYears(value.ToDouble(null));
+                => Length.FromLightYears(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromMegalightYears(double)" />
+            /// <inheritdoc cref="Length.FromMegalightYears(QuantityValue)" />
             public Length MegalightYears
 #if NET7_0_OR_GREATER
-                => Length.FromMegalightYears(double.CreateChecked(value));
+                => Length.FromMegalightYears(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromMegalightYears(value.ToDouble(null));
+                => Length.FromMegalightYears(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromMegameters(double)" />
+            /// <inheritdoc cref="Length.FromMegameters(QuantityValue)" />
             public Length Megameters
 #if NET7_0_OR_GREATER
-                => Length.FromMegameters(double.CreateChecked(value));
+                => Length.FromMegameters(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromMegameters(value.ToDouble(null));
+                => Length.FromMegameters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromMegaparsecs(double)" />
+            /// <inheritdoc cref="Length.FromMegaparsecs(QuantityValue)" />
             public Length Megaparsecs
 #if NET7_0_OR_GREATER
-                => Length.FromMegaparsecs(double.CreateChecked(value));
+                => Length.FromMegaparsecs(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromMegaparsecs(value.ToDouble(null));
+                => Length.FromMegaparsecs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromMeters(double)" />
+            /// <inheritdoc cref="Length.FromMeters(QuantityValue)" />
             public Length Meters
 #if NET7_0_OR_GREATER
-                => Length.FromMeters(double.CreateChecked(value));
+                => Length.FromMeters(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromMeters(value.ToDouble(null));
+                => Length.FromMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromMicroinches(double)" />
+            /// <inheritdoc cref="Length.FromMicroinches(QuantityValue)" />
             public Length Microinches
 #if NET7_0_OR_GREATER
-                => Length.FromMicroinches(double.CreateChecked(value));
+                => Length.FromMicroinches(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromMicroinches(value.ToDouble(null));
+                => Length.FromMicroinches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromMicrometers(double)" />
+            /// <inheritdoc cref="Length.FromMicrometers(QuantityValue)" />
             public Length Micrometers
 #if NET7_0_OR_GREATER
-                => Length.FromMicrometers(double.CreateChecked(value));
+                => Length.FromMicrometers(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromMicrometers(value.ToDouble(null));
+                => Length.FromMicrometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromMils(double)" />
+            /// <inheritdoc cref="Length.FromMils(QuantityValue)" />
             public Length Mils
 #if NET7_0_OR_GREATER
-                => Length.FromMils(double.CreateChecked(value));
+                => Length.FromMils(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromMils(value.ToDouble(null));
+                => Length.FromMils(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromMiles(double)" />
+            /// <inheritdoc cref="Length.FromMiles(QuantityValue)" />
             public Length Miles
 #if NET7_0_OR_GREATER
-                => Length.FromMiles(double.CreateChecked(value));
+                => Length.FromMiles(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromMiles(value.ToDouble(null));
+                => Length.FromMiles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromMillimeters(double)" />
+            /// <inheritdoc cref="Length.FromMillimeters(QuantityValue)" />
             public Length Millimeters
 #if NET7_0_OR_GREATER
-                => Length.FromMillimeters(double.CreateChecked(value));
+                => Length.FromMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromMillimeters(value.ToDouble(null));
+                => Length.FromMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromNanometers(double)" />
+            /// <inheritdoc cref="Length.FromNanometers(QuantityValue)" />
             public Length Nanometers
 #if NET7_0_OR_GREATER
-                => Length.FromNanometers(double.CreateChecked(value));
+                => Length.FromNanometers(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromNanometers(value.ToDouble(null));
+                => Length.FromNanometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromNauticalMiles(double)" />
+            /// <inheritdoc cref="Length.FromNauticalMiles(QuantityValue)" />
             public Length NauticalMiles
 #if NET7_0_OR_GREATER
-                => Length.FromNauticalMiles(double.CreateChecked(value));
+                => Length.FromNauticalMiles(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromNauticalMiles(value.ToDouble(null));
+                => Length.FromNauticalMiles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromParsecs(double)" />
+            /// <inheritdoc cref="Length.FromParsecs(QuantityValue)" />
             public Length Parsecs
 #if NET7_0_OR_GREATER
-                => Length.FromParsecs(double.CreateChecked(value));
+                => Length.FromParsecs(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromParsecs(value.ToDouble(null));
+                => Length.FromParsecs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromPicometers(double)" />
+            /// <inheritdoc cref="Length.FromPicometers(QuantityValue)" />
             public Length Picometers
 #if NET7_0_OR_GREATER
-                => Length.FromPicometers(double.CreateChecked(value));
+                => Length.FromPicometers(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromPicometers(value.ToDouble(null));
+                => Length.FromPicometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromPrinterPicas(double)" />
+            /// <inheritdoc cref="Length.FromPrinterPicas(QuantityValue)" />
             public Length PrinterPicas
 #if NET7_0_OR_GREATER
-                => Length.FromPrinterPicas(double.CreateChecked(value));
+                => Length.FromPrinterPicas(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromPrinterPicas(value.ToDouble(null));
+                => Length.FromPrinterPicas(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromPrinterPoints(double)" />
+            /// <inheritdoc cref="Length.FromPrinterPoints(QuantityValue)" />
             public Length PrinterPoints
 #if NET7_0_OR_GREATER
-                => Length.FromPrinterPoints(double.CreateChecked(value));
+                => Length.FromPrinterPoints(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromPrinterPoints(value.ToDouble(null));
+                => Length.FromPrinterPoints(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromShackles(double)" />
+            /// <inheritdoc cref="Length.FromShackles(QuantityValue)" />
             public Length Shackles
 #if NET7_0_OR_GREATER
-                => Length.FromShackles(double.CreateChecked(value));
+                => Length.FromShackles(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromShackles(value.ToDouble(null));
+                => Length.FromShackles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromSolarRadiuses(double)" />
+            /// <inheritdoc cref="Length.FromSolarRadiuses(QuantityValue)" />
             public Length SolarRadiuses
 #if NET7_0_OR_GREATER
-                => Length.FromSolarRadiuses(double.CreateChecked(value));
+                => Length.FromSolarRadiuses(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromSolarRadiuses(value.ToDouble(null));
+                => Length.FromSolarRadiuses(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromTwips(double)" />
+            /// <inheritdoc cref="Length.FromTwips(QuantityValue)" />
             public Length Twips
 #if NET7_0_OR_GREATER
-                => Length.FromTwips(double.CreateChecked(value));
+                => Length.FromTwips(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromTwips(value.ToDouble(null));
+                => Length.FromTwips(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromUsSurveyFeet(double)" />
+            /// <inheritdoc cref="Length.FromUsSurveyFeet(QuantityValue)" />
             public Length UsSurveyFeet
 #if NET7_0_OR_GREATER
-                => Length.FromUsSurveyFeet(double.CreateChecked(value));
+                => Length.FromUsSurveyFeet(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromUsSurveyFeet(value.ToDouble(null));
+                => Length.FromUsSurveyFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Length.FromYards(double)" />
+            /// <inheritdoc cref="Length.FromYards(QuantityValue)" />
             public Length Yards
 #if NET7_0_OR_GREATER
-                => Length.FromYards(double.CreateChecked(value));
+                => Length.FromYards(QuantityValue.CreateChecked(value));
 #else
-                => Length.FromYards(value.ToDouble(null));
+                => Length.FromYards(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLevelExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLevelExtensions.g.cs
index 62c3eeb0ae..a1448e05f2 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLevelExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLevelExtensions.g.cs
@@ -42,20 +42,20 @@ public static class NumberToLevelExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Level.FromDecibels(double)" />
+            /// <inheritdoc cref="Level.FromDecibels(QuantityValue)" />
             public Level Decibels
 #if NET7_0_OR_GREATER
-                => Level.FromDecibels(double.CreateChecked(value));
+                => Level.FromDecibels(QuantityValue.CreateChecked(value));
 #else
-                => Level.FromDecibels(value.ToDouble(null));
+                => Level.FromDecibels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Level.FromNepers(double)" />
+            /// <inheritdoc cref="Level.FromNepers(QuantityValue)" />
             public Level Nepers
 #if NET7_0_OR_GREATER
-                => Level.FromNepers(double.CreateChecked(value));
+                => Level.FromNepers(QuantityValue.CreateChecked(value));
 #else
-                => Level.FromNepers(value.ToDouble(null));
+                => Level.FromNepers(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearDensityExtensions.g.cs
index 53427c828e..ab60e6ae58 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearDensityExtensions.g.cs
@@ -42,148 +42,148 @@ public static class NumberToLinearDensityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="LinearDensity.FromGramsPerCentimeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromGramsPerCentimeter(QuantityValue)" />
             public LinearDensity GramsPerCentimeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromGramsPerCentimeter(double.CreateChecked(value));
+                => LinearDensity.FromGramsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromGramsPerCentimeter(value.ToDouble(null));
+                => LinearDensity.FromGramsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromGramsPerFoot(double)" />
+            /// <inheritdoc cref="LinearDensity.FromGramsPerFoot(QuantityValue)" />
             public LinearDensity GramsPerFoot
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromGramsPerFoot(double.CreateChecked(value));
+                => LinearDensity.FromGramsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromGramsPerFoot(value.ToDouble(null));
+                => LinearDensity.FromGramsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromGramsPerMeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromGramsPerMeter(QuantityValue)" />
             public LinearDensity GramsPerMeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromGramsPerMeter(double.CreateChecked(value));
+                => LinearDensity.FromGramsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromGramsPerMeter(value.ToDouble(null));
+                => LinearDensity.FromGramsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromGramsPerMillimeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromGramsPerMillimeter(QuantityValue)" />
             public LinearDensity GramsPerMillimeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromGramsPerMillimeter(double.CreateChecked(value));
+                => LinearDensity.FromGramsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromGramsPerMillimeter(value.ToDouble(null));
+                => LinearDensity.FromGramsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromKilogramsPerCentimeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromKilogramsPerCentimeter(QuantityValue)" />
             public LinearDensity KilogramsPerCentimeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromKilogramsPerCentimeter(double.CreateChecked(value));
+                => LinearDensity.FromKilogramsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromKilogramsPerCentimeter(value.ToDouble(null));
+                => LinearDensity.FromKilogramsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromKilogramsPerFoot(double)" />
+            /// <inheritdoc cref="LinearDensity.FromKilogramsPerFoot(QuantityValue)" />
             public LinearDensity KilogramsPerFoot
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromKilogramsPerFoot(double.CreateChecked(value));
+                => LinearDensity.FromKilogramsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromKilogramsPerFoot(value.ToDouble(null));
+                => LinearDensity.FromKilogramsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromKilogramsPerMeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromKilogramsPerMeter(QuantityValue)" />
             public LinearDensity KilogramsPerMeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromKilogramsPerMeter(double.CreateChecked(value));
+                => LinearDensity.FromKilogramsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromKilogramsPerMeter(value.ToDouble(null));
+                => LinearDensity.FromKilogramsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromKilogramsPerMillimeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromKilogramsPerMillimeter(QuantityValue)" />
             public LinearDensity KilogramsPerMillimeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromKilogramsPerMillimeter(double.CreateChecked(value));
+                => LinearDensity.FromKilogramsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromKilogramsPerMillimeter(value.ToDouble(null));
+                => LinearDensity.FromKilogramsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromMicrogramsPerCentimeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromMicrogramsPerCentimeter(QuantityValue)" />
             public LinearDensity MicrogramsPerCentimeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromMicrogramsPerCentimeter(double.CreateChecked(value));
+                => LinearDensity.FromMicrogramsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromMicrogramsPerCentimeter(value.ToDouble(null));
+                => LinearDensity.FromMicrogramsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromMicrogramsPerFoot(double)" />
+            /// <inheritdoc cref="LinearDensity.FromMicrogramsPerFoot(QuantityValue)" />
             public LinearDensity MicrogramsPerFoot
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromMicrogramsPerFoot(double.CreateChecked(value));
+                => LinearDensity.FromMicrogramsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromMicrogramsPerFoot(value.ToDouble(null));
+                => LinearDensity.FromMicrogramsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMeter(QuantityValue)" />
             public LinearDensity MicrogramsPerMeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromMicrogramsPerMeter(double.CreateChecked(value));
+                => LinearDensity.FromMicrogramsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromMicrogramsPerMeter(value.ToDouble(null));
+                => LinearDensity.FromMicrogramsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMillimeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMillimeter(QuantityValue)" />
             public LinearDensity MicrogramsPerMillimeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromMicrogramsPerMillimeter(double.CreateChecked(value));
+                => LinearDensity.FromMicrogramsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromMicrogramsPerMillimeter(value.ToDouble(null));
+                => LinearDensity.FromMicrogramsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromMilligramsPerCentimeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromMilligramsPerCentimeter(QuantityValue)" />
             public LinearDensity MilligramsPerCentimeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromMilligramsPerCentimeter(double.CreateChecked(value));
+                => LinearDensity.FromMilligramsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromMilligramsPerCentimeter(value.ToDouble(null));
+                => LinearDensity.FromMilligramsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromMilligramsPerFoot(double)" />
+            /// <inheritdoc cref="LinearDensity.FromMilligramsPerFoot(QuantityValue)" />
             public LinearDensity MilligramsPerFoot
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromMilligramsPerFoot(double.CreateChecked(value));
+                => LinearDensity.FromMilligramsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromMilligramsPerFoot(value.ToDouble(null));
+                => LinearDensity.FromMilligramsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromMilligramsPerMeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromMilligramsPerMeter(QuantityValue)" />
             public LinearDensity MilligramsPerMeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromMilligramsPerMeter(double.CreateChecked(value));
+                => LinearDensity.FromMilligramsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromMilligramsPerMeter(value.ToDouble(null));
+                => LinearDensity.FromMilligramsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromMilligramsPerMillimeter(double)" />
+            /// <inheritdoc cref="LinearDensity.FromMilligramsPerMillimeter(QuantityValue)" />
             public LinearDensity MilligramsPerMillimeter
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromMilligramsPerMillimeter(double.CreateChecked(value));
+                => LinearDensity.FromMilligramsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromMilligramsPerMillimeter(value.ToDouble(null));
+                => LinearDensity.FromMilligramsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromPoundsPerFoot(double)" />
+            /// <inheritdoc cref="LinearDensity.FromPoundsPerFoot(QuantityValue)" />
             public LinearDensity PoundsPerFoot
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromPoundsPerFoot(double.CreateChecked(value));
+                => LinearDensity.FromPoundsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromPoundsPerFoot(value.ToDouble(null));
+                => LinearDensity.FromPoundsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearDensity.FromPoundsPerInch(double)" />
+            /// <inheritdoc cref="LinearDensity.FromPoundsPerInch(QuantityValue)" />
             public LinearDensity PoundsPerInch
 #if NET7_0_OR_GREATER
-                => LinearDensity.FromPoundsPerInch(double.CreateChecked(value));
+                => LinearDensity.FromPoundsPerInch(QuantityValue.CreateChecked(value));
 #else
-                => LinearDensity.FromPoundsPerInch(value.ToDouble(null));
+                => LinearDensity.FromPoundsPerInch(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
index 8bec43de16..2227c8ce78 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
@@ -42,204 +42,204 @@ public static class NumberToLinearPowerDensityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerCentimeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerCentimeter(QuantityValue)" />
             public LinearPowerDensity GigawattsPerCentimeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromGigawattsPerCentimeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromGigawattsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromGigawattsPerCentimeter(value.ToDouble(null));
+                => LinearPowerDensity.FromGigawattsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerFoot(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerFoot(QuantityValue)" />
             public LinearPowerDensity GigawattsPerFoot
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromGigawattsPerFoot(double.CreateChecked(value));
+                => LinearPowerDensity.FromGigawattsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromGigawattsPerFoot(value.ToDouble(null));
+                => LinearPowerDensity.FromGigawattsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerInch(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerInch(QuantityValue)" />
             public LinearPowerDensity GigawattsPerInch
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromGigawattsPerInch(double.CreateChecked(value));
+                => LinearPowerDensity.FromGigawattsPerInch(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromGigawattsPerInch(value.ToDouble(null));
+                => LinearPowerDensity.FromGigawattsPerInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMeter(QuantityValue)" />
             public LinearPowerDensity GigawattsPerMeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromGigawattsPerMeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromGigawattsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromGigawattsPerMeter(value.ToDouble(null));
+                => LinearPowerDensity.FromGigawattsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMillimeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMillimeter(QuantityValue)" />
             public LinearPowerDensity GigawattsPerMillimeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromGigawattsPerMillimeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromGigawattsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromGigawattsPerMillimeter(value.ToDouble(null));
+                => LinearPowerDensity.FromGigawattsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerCentimeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerCentimeter(QuantityValue)" />
             public LinearPowerDensity KilowattsPerCentimeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromKilowattsPerCentimeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromKilowattsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromKilowattsPerCentimeter(value.ToDouble(null));
+                => LinearPowerDensity.FromKilowattsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerFoot(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerFoot(QuantityValue)" />
             public LinearPowerDensity KilowattsPerFoot
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromKilowattsPerFoot(double.CreateChecked(value));
+                => LinearPowerDensity.FromKilowattsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromKilowattsPerFoot(value.ToDouble(null));
+                => LinearPowerDensity.FromKilowattsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerInch(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerInch(QuantityValue)" />
             public LinearPowerDensity KilowattsPerInch
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromKilowattsPerInch(double.CreateChecked(value));
+                => LinearPowerDensity.FromKilowattsPerInch(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromKilowattsPerInch(value.ToDouble(null));
+                => LinearPowerDensity.FromKilowattsPerInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMeter(QuantityValue)" />
             public LinearPowerDensity KilowattsPerMeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromKilowattsPerMeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromKilowattsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromKilowattsPerMeter(value.ToDouble(null));
+                => LinearPowerDensity.FromKilowattsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMillimeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMillimeter(QuantityValue)" />
             public LinearPowerDensity KilowattsPerMillimeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromKilowattsPerMillimeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromKilowattsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromKilowattsPerMillimeter(value.ToDouble(null));
+                => LinearPowerDensity.FromKilowattsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerCentimeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerCentimeter(QuantityValue)" />
             public LinearPowerDensity MegawattsPerCentimeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromMegawattsPerCentimeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromMegawattsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromMegawattsPerCentimeter(value.ToDouble(null));
+                => LinearPowerDensity.FromMegawattsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerFoot(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerFoot(QuantityValue)" />
             public LinearPowerDensity MegawattsPerFoot
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromMegawattsPerFoot(double.CreateChecked(value));
+                => LinearPowerDensity.FromMegawattsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromMegawattsPerFoot(value.ToDouble(null));
+                => LinearPowerDensity.FromMegawattsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerInch(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerInch(QuantityValue)" />
             public LinearPowerDensity MegawattsPerInch
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromMegawattsPerInch(double.CreateChecked(value));
+                => LinearPowerDensity.FromMegawattsPerInch(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromMegawattsPerInch(value.ToDouble(null));
+                => LinearPowerDensity.FromMegawattsPerInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMeter(QuantityValue)" />
             public LinearPowerDensity MegawattsPerMeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromMegawattsPerMeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromMegawattsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromMegawattsPerMeter(value.ToDouble(null));
+                => LinearPowerDensity.FromMegawattsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMillimeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMillimeter(QuantityValue)" />
             public LinearPowerDensity MegawattsPerMillimeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromMegawattsPerMillimeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromMegawattsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromMegawattsPerMillimeter(value.ToDouble(null));
+                => LinearPowerDensity.FromMegawattsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerCentimeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerCentimeter(QuantityValue)" />
             public LinearPowerDensity MilliwattsPerCentimeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromMilliwattsPerCentimeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromMilliwattsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromMilliwattsPerCentimeter(value.ToDouble(null));
+                => LinearPowerDensity.FromMilliwattsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerFoot(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerFoot(QuantityValue)" />
             public LinearPowerDensity MilliwattsPerFoot
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromMilliwattsPerFoot(double.CreateChecked(value));
+                => LinearPowerDensity.FromMilliwattsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromMilliwattsPerFoot(value.ToDouble(null));
+                => LinearPowerDensity.FromMilliwattsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerInch(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerInch(QuantityValue)" />
             public LinearPowerDensity MilliwattsPerInch
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromMilliwattsPerInch(double.CreateChecked(value));
+                => LinearPowerDensity.FromMilliwattsPerInch(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromMilliwattsPerInch(value.ToDouble(null));
+                => LinearPowerDensity.FromMilliwattsPerInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMeter(QuantityValue)" />
             public LinearPowerDensity MilliwattsPerMeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromMilliwattsPerMeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromMilliwattsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromMilliwattsPerMeter(value.ToDouble(null));
+                => LinearPowerDensity.FromMilliwattsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMillimeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMillimeter(QuantityValue)" />
             public LinearPowerDensity MilliwattsPerMillimeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromMilliwattsPerMillimeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromMilliwattsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromMilliwattsPerMillimeter(value.ToDouble(null));
+                => LinearPowerDensity.FromMilliwattsPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromWattsPerCentimeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromWattsPerCentimeter(QuantityValue)" />
             public LinearPowerDensity WattsPerCentimeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromWattsPerCentimeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromWattsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromWattsPerCentimeter(value.ToDouble(null));
+                => LinearPowerDensity.FromWattsPerCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromWattsPerFoot(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromWattsPerFoot(QuantityValue)" />
             public LinearPowerDensity WattsPerFoot
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromWattsPerFoot(double.CreateChecked(value));
+                => LinearPowerDensity.FromWattsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromWattsPerFoot(value.ToDouble(null));
+                => LinearPowerDensity.FromWattsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromWattsPerInch(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromWattsPerInch(QuantityValue)" />
             public LinearPowerDensity WattsPerInch
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromWattsPerInch(double.CreateChecked(value));
+                => LinearPowerDensity.FromWattsPerInch(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromWattsPerInch(value.ToDouble(null));
+                => LinearPowerDensity.FromWattsPerInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMeter(QuantityValue)" />
             public LinearPowerDensity WattsPerMeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromWattsPerMeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromWattsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromWattsPerMeter(value.ToDouble(null));
+                => LinearPowerDensity.FromWattsPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMillimeter(double)" />
+            /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMillimeter(QuantityValue)" />
             public LinearPowerDensity WattsPerMillimeter
 #if NET7_0_OR_GREATER
-                => LinearPowerDensity.FromWattsPerMillimeter(double.CreateChecked(value));
+                => LinearPowerDensity.FromWattsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => LinearPowerDensity.FromWattsPerMillimeter(value.ToDouble(null));
+                => LinearPowerDensity.FromWattsPerMillimeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminanceExtensions.g.cs
index 34bef2c23b..53a39d6eca 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminanceExtensions.g.cs
@@ -42,84 +42,84 @@ public static class NumberToLuminanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Luminance.FromCandelasPerSquareFoot(double)" />
+            /// <inheritdoc cref="Luminance.FromCandelasPerSquareFoot(QuantityValue)" />
             public Luminance CandelasPerSquareFoot
 #if NET7_0_OR_GREATER
-                => Luminance.FromCandelasPerSquareFoot(double.CreateChecked(value));
+                => Luminance.FromCandelasPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => Luminance.FromCandelasPerSquareFoot(value.ToDouble(null));
+                => Luminance.FromCandelasPerSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminance.FromCandelasPerSquareInch(double)" />
+            /// <inheritdoc cref="Luminance.FromCandelasPerSquareInch(QuantityValue)" />
             public Luminance CandelasPerSquareInch
 #if NET7_0_OR_GREATER
-                => Luminance.FromCandelasPerSquareInch(double.CreateChecked(value));
+                => Luminance.FromCandelasPerSquareInch(QuantityValue.CreateChecked(value));
 #else
-                => Luminance.FromCandelasPerSquareInch(value.ToDouble(null));
+                => Luminance.FromCandelasPerSquareInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminance.FromCandelasPerSquareMeter(double)" />
+            /// <inheritdoc cref="Luminance.FromCandelasPerSquareMeter(QuantityValue)" />
             public Luminance CandelasPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Luminance.FromCandelasPerSquareMeter(double.CreateChecked(value));
+                => Luminance.FromCandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Luminance.FromCandelasPerSquareMeter(value.ToDouble(null));
+                => Luminance.FromCandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminance.FromCenticandelasPerSquareMeter(double)" />
+            /// <inheritdoc cref="Luminance.FromCenticandelasPerSquareMeter(QuantityValue)" />
             public Luminance CenticandelasPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Luminance.FromCenticandelasPerSquareMeter(double.CreateChecked(value));
+                => Luminance.FromCenticandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Luminance.FromCenticandelasPerSquareMeter(value.ToDouble(null));
+                => Luminance.FromCenticandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminance.FromDecicandelasPerSquareMeter(double)" />
+            /// <inheritdoc cref="Luminance.FromDecicandelasPerSquareMeter(QuantityValue)" />
             public Luminance DecicandelasPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Luminance.FromDecicandelasPerSquareMeter(double.CreateChecked(value));
+                => Luminance.FromDecicandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Luminance.FromDecicandelasPerSquareMeter(value.ToDouble(null));
+                => Luminance.FromDecicandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminance.FromKilocandelasPerSquareMeter(double)" />
+            /// <inheritdoc cref="Luminance.FromKilocandelasPerSquareMeter(QuantityValue)" />
             public Luminance KilocandelasPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Luminance.FromKilocandelasPerSquareMeter(double.CreateChecked(value));
+                => Luminance.FromKilocandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Luminance.FromKilocandelasPerSquareMeter(value.ToDouble(null));
+                => Luminance.FromKilocandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminance.FromMicrocandelasPerSquareMeter(double)" />
+            /// <inheritdoc cref="Luminance.FromMicrocandelasPerSquareMeter(QuantityValue)" />
             public Luminance MicrocandelasPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Luminance.FromMicrocandelasPerSquareMeter(double.CreateChecked(value));
+                => Luminance.FromMicrocandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Luminance.FromMicrocandelasPerSquareMeter(value.ToDouble(null));
+                => Luminance.FromMicrocandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminance.FromMillicandelasPerSquareMeter(double)" />
+            /// <inheritdoc cref="Luminance.FromMillicandelasPerSquareMeter(QuantityValue)" />
             public Luminance MillicandelasPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Luminance.FromMillicandelasPerSquareMeter(double.CreateChecked(value));
+                => Luminance.FromMillicandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Luminance.FromMillicandelasPerSquareMeter(value.ToDouble(null));
+                => Luminance.FromMillicandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminance.FromNanocandelasPerSquareMeter(double)" />
+            /// <inheritdoc cref="Luminance.FromNanocandelasPerSquareMeter(QuantityValue)" />
             public Luminance NanocandelasPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Luminance.FromNanocandelasPerSquareMeter(double.CreateChecked(value));
+                => Luminance.FromNanocandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Luminance.FromNanocandelasPerSquareMeter(value.ToDouble(null));
+                => Luminance.FromNanocandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminance.FromNits(double)" />
+            /// <inheritdoc cref="Luminance.FromNits(QuantityValue)" />
             public Luminance Nits
 #if NET7_0_OR_GREATER
-                => Luminance.FromNits(double.CreateChecked(value));
+                => Luminance.FromNits(QuantityValue.CreateChecked(value));
 #else
-                => Luminance.FromNits(value.ToDouble(null));
+                => Luminance.FromNits(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminosityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminosityExtensions.g.cs
index 30b3b188f5..5c837f4cad 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminosityExtensions.g.cs
@@ -42,116 +42,116 @@ public static class NumberToLuminosityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Luminosity.FromDecawatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromDecawatts(QuantityValue)" />
             public Luminosity Decawatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromDecawatts(double.CreateChecked(value));
+                => Luminosity.FromDecawatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromDecawatts(value.ToDouble(null));
+                => Luminosity.FromDecawatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromDeciwatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromDeciwatts(QuantityValue)" />
             public Luminosity Deciwatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromDeciwatts(double.CreateChecked(value));
+                => Luminosity.FromDeciwatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromDeciwatts(value.ToDouble(null));
+                => Luminosity.FromDeciwatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromFemtowatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromFemtowatts(QuantityValue)" />
             public Luminosity Femtowatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromFemtowatts(double.CreateChecked(value));
+                => Luminosity.FromFemtowatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromFemtowatts(value.ToDouble(null));
+                => Luminosity.FromFemtowatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromGigawatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromGigawatts(QuantityValue)" />
             public Luminosity Gigawatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromGigawatts(double.CreateChecked(value));
+                => Luminosity.FromGigawatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromGigawatts(value.ToDouble(null));
+                => Luminosity.FromGigawatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromKilowatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromKilowatts(QuantityValue)" />
             public Luminosity Kilowatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromKilowatts(double.CreateChecked(value));
+                => Luminosity.FromKilowatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromKilowatts(value.ToDouble(null));
+                => Luminosity.FromKilowatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromMegawatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromMegawatts(QuantityValue)" />
             public Luminosity Megawatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromMegawatts(double.CreateChecked(value));
+                => Luminosity.FromMegawatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromMegawatts(value.ToDouble(null));
+                => Luminosity.FromMegawatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromMicrowatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromMicrowatts(QuantityValue)" />
             public Luminosity Microwatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromMicrowatts(double.CreateChecked(value));
+                => Luminosity.FromMicrowatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromMicrowatts(value.ToDouble(null));
+                => Luminosity.FromMicrowatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromMilliwatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromMilliwatts(QuantityValue)" />
             public Luminosity Milliwatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromMilliwatts(double.CreateChecked(value));
+                => Luminosity.FromMilliwatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromMilliwatts(value.ToDouble(null));
+                => Luminosity.FromMilliwatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromNanowatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromNanowatts(QuantityValue)" />
             public Luminosity Nanowatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromNanowatts(double.CreateChecked(value));
+                => Luminosity.FromNanowatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromNanowatts(value.ToDouble(null));
+                => Luminosity.FromNanowatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromPetawatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromPetawatts(QuantityValue)" />
             public Luminosity Petawatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromPetawatts(double.CreateChecked(value));
+                => Luminosity.FromPetawatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromPetawatts(value.ToDouble(null));
+                => Luminosity.FromPetawatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromPicowatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromPicowatts(QuantityValue)" />
             public Luminosity Picowatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromPicowatts(double.CreateChecked(value));
+                => Luminosity.FromPicowatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromPicowatts(value.ToDouble(null));
+                => Luminosity.FromPicowatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromSolarLuminosities(double)" />
+            /// <inheritdoc cref="Luminosity.FromSolarLuminosities(QuantityValue)" />
             public Luminosity SolarLuminosities
 #if NET7_0_OR_GREATER
-                => Luminosity.FromSolarLuminosities(double.CreateChecked(value));
+                => Luminosity.FromSolarLuminosities(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromSolarLuminosities(value.ToDouble(null));
+                => Luminosity.FromSolarLuminosities(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromTerawatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromTerawatts(QuantityValue)" />
             public Luminosity Terawatts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromTerawatts(double.CreateChecked(value));
+                => Luminosity.FromTerawatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromTerawatts(value.ToDouble(null));
+                => Luminosity.FromTerawatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Luminosity.FromWatts(double)" />
+            /// <inheritdoc cref="Luminosity.FromWatts(QuantityValue)" />
             public Luminosity Watts
 #if NET7_0_OR_GREATER
-                => Luminosity.FromWatts(double.CreateChecked(value));
+                => Luminosity.FromWatts(QuantityValue.CreateChecked(value));
 #else
-                => Luminosity.FromWatts(value.ToDouble(null));
+                => Luminosity.FromWatts(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousFluxExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
index f33229ff3d..a0c21502bf 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToLuminousFluxExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="LuminousFlux.FromLumens(double)" />
+            /// <inheritdoc cref="LuminousFlux.FromLumens(QuantityValue)" />
             public LuminousFlux Lumens
 #if NET7_0_OR_GREATER
-                => LuminousFlux.FromLumens(double.CreateChecked(value));
+                => LuminousFlux.FromLumens(QuantityValue.CreateChecked(value));
 #else
-                => LuminousFlux.FromLumens(value.ToDouble(null));
+                => LuminousFlux.FromLumens(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
index 6a4697278e..1a4e6f954b 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToLuminousIntensityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="LuminousIntensity.FromCandela(double)" />
+            /// <inheritdoc cref="LuminousIntensity.FromCandela(QuantityValue)" />
             public LuminousIntensity Candela
 #if NET7_0_OR_GREATER
-                => LuminousIntensity.FromCandela(double.CreateChecked(value));
+                => LuminousIntensity.FromCandela(QuantityValue.CreateChecked(value));
 #else
-                => LuminousIntensity.FromCandela(value.ToDouble(null));
+                => LuminousIntensity.FromCandela(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFieldExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
index d00c79035d..1b415df68d 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
@@ -42,52 +42,52 @@ public static class NumberToMagneticFieldExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MagneticField.FromGausses(double)" />
+            /// <inheritdoc cref="MagneticField.FromGausses(QuantityValue)" />
             public MagneticField Gausses
 #if NET7_0_OR_GREATER
-                => MagneticField.FromGausses(double.CreateChecked(value));
+                => MagneticField.FromGausses(QuantityValue.CreateChecked(value));
 #else
-                => MagneticField.FromGausses(value.ToDouble(null));
+                => MagneticField.FromGausses(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MagneticField.FromMicroteslas(double)" />
+            /// <inheritdoc cref="MagneticField.FromMicroteslas(QuantityValue)" />
             public MagneticField Microteslas
 #if NET7_0_OR_GREATER
-                => MagneticField.FromMicroteslas(double.CreateChecked(value));
+                => MagneticField.FromMicroteslas(QuantityValue.CreateChecked(value));
 #else
-                => MagneticField.FromMicroteslas(value.ToDouble(null));
+                => MagneticField.FromMicroteslas(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MagneticField.FromMilligausses(double)" />
+            /// <inheritdoc cref="MagneticField.FromMilligausses(QuantityValue)" />
             public MagneticField Milligausses
 #if NET7_0_OR_GREATER
-                => MagneticField.FromMilligausses(double.CreateChecked(value));
+                => MagneticField.FromMilligausses(QuantityValue.CreateChecked(value));
 #else
-                => MagneticField.FromMilligausses(value.ToDouble(null));
+                => MagneticField.FromMilligausses(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MagneticField.FromMilliteslas(double)" />
+            /// <inheritdoc cref="MagneticField.FromMilliteslas(QuantityValue)" />
             public MagneticField Milliteslas
 #if NET7_0_OR_GREATER
-                => MagneticField.FromMilliteslas(double.CreateChecked(value));
+                => MagneticField.FromMilliteslas(QuantityValue.CreateChecked(value));
 #else
-                => MagneticField.FromMilliteslas(value.ToDouble(null));
+                => MagneticField.FromMilliteslas(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MagneticField.FromNanoteslas(double)" />
+            /// <inheritdoc cref="MagneticField.FromNanoteslas(QuantityValue)" />
             public MagneticField Nanoteslas
 #if NET7_0_OR_GREATER
-                => MagneticField.FromNanoteslas(double.CreateChecked(value));
+                => MagneticField.FromNanoteslas(QuantityValue.CreateChecked(value));
 #else
-                => MagneticField.FromNanoteslas(value.ToDouble(null));
+                => MagneticField.FromNanoteslas(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MagneticField.FromTeslas(double)" />
+            /// <inheritdoc cref="MagneticField.FromTeslas(QuantityValue)" />
             public MagneticField Teslas
 #if NET7_0_OR_GREATER
-                => MagneticField.FromTeslas(double.CreateChecked(value));
+                => MagneticField.FromTeslas(QuantityValue.CreateChecked(value));
 #else
-                => MagneticField.FromTeslas(value.ToDouble(null));
+                => MagneticField.FromTeslas(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFluxExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
index e44579feb9..81ab4e865d 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToMagneticFluxExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MagneticFlux.FromWebers(double)" />
+            /// <inheritdoc cref="MagneticFlux.FromWebers(QuantityValue)" />
             public MagneticFlux Webers
 #if NET7_0_OR_GREATER
-                => MagneticFlux.FromWebers(double.CreateChecked(value));
+                => MagneticFlux.FromWebers(QuantityValue.CreateChecked(value));
 #else
-                => MagneticFlux.FromWebers(value.ToDouble(null));
+                => MagneticFlux.FromWebers(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagnetizationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagnetizationExtensions.g.cs
index 32498d022e..9d7d0a13e0 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagnetizationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagnetizationExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToMagnetizationExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Magnetization.FromAmperesPerMeter(double)" />
+            /// <inheritdoc cref="Magnetization.FromAmperesPerMeter(QuantityValue)" />
             public Magnetization AmperesPerMeter
 #if NET7_0_OR_GREATER
-                => Magnetization.FromAmperesPerMeter(double.CreateChecked(value));
+                => Magnetization.FromAmperesPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => Magnetization.FromAmperesPerMeter(value.ToDouble(null));
+                => Magnetization.FromAmperesPerMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
index 31e563b531..81fbe4e75f 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
@@ -42,396 +42,396 @@ public static class NumberToMassConcentrationExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MassConcentration.FromCentigramsPerDeciliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromCentigramsPerDeciliter(QuantityValue)" />
             public MassConcentration CentigramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromCentigramsPerDeciliter(double.CreateChecked(value));
+                => MassConcentration.FromCentigramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromCentigramsPerDeciliter(value.ToDouble(null));
+                => MassConcentration.FromCentigramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromCentigramsPerLiter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromCentigramsPerLiter(QuantityValue)" />
             public MassConcentration CentigramsPerLiter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromCentigramsPerLiter(double.CreateChecked(value));
+                => MassConcentration.FromCentigramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromCentigramsPerLiter(value.ToDouble(null));
+                => MassConcentration.FromCentigramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromCentigramsPerMicroliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromCentigramsPerMicroliter(QuantityValue)" />
             public MassConcentration CentigramsPerMicroliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromCentigramsPerMicroliter(double.CreateChecked(value));
+                => MassConcentration.FromCentigramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromCentigramsPerMicroliter(value.ToDouble(null));
+                => MassConcentration.FromCentigramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromCentigramsPerMilliliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromCentigramsPerMilliliter(QuantityValue)" />
             public MassConcentration CentigramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromCentigramsPerMilliliter(double.CreateChecked(value));
+                => MassConcentration.FromCentigramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromCentigramsPerMilliliter(value.ToDouble(null));
+                => MassConcentration.FromCentigramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromDecigramsPerDeciliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromDecigramsPerDeciliter(QuantityValue)" />
             public MassConcentration DecigramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromDecigramsPerDeciliter(double.CreateChecked(value));
+                => MassConcentration.FromDecigramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromDecigramsPerDeciliter(value.ToDouble(null));
+                => MassConcentration.FromDecigramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromDecigramsPerLiter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromDecigramsPerLiter(QuantityValue)" />
             public MassConcentration DecigramsPerLiter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromDecigramsPerLiter(double.CreateChecked(value));
+                => MassConcentration.FromDecigramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromDecigramsPerLiter(value.ToDouble(null));
+                => MassConcentration.FromDecigramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromDecigramsPerMicroliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromDecigramsPerMicroliter(QuantityValue)" />
             public MassConcentration DecigramsPerMicroliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromDecigramsPerMicroliter(double.CreateChecked(value));
+                => MassConcentration.FromDecigramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromDecigramsPerMicroliter(value.ToDouble(null));
+                => MassConcentration.FromDecigramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromDecigramsPerMilliliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromDecigramsPerMilliliter(QuantityValue)" />
             public MassConcentration DecigramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromDecigramsPerMilliliter(double.CreateChecked(value));
+                => MassConcentration.FromDecigramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromDecigramsPerMilliliter(value.ToDouble(null));
+                => MassConcentration.FromDecigramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromGramsPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromGramsPerCubicCentimeter(QuantityValue)" />
             public MassConcentration GramsPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromGramsPerCubicCentimeter(double.CreateChecked(value));
+                => MassConcentration.FromGramsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromGramsPerCubicCentimeter(value.ToDouble(null));
+                => MassConcentration.FromGramsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMeter(QuantityValue)" />
             public MassConcentration GramsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromGramsPerCubicMeter(double.CreateChecked(value));
+                => MassConcentration.FromGramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromGramsPerCubicMeter(value.ToDouble(null));
+                => MassConcentration.FromGramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMillimeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMillimeter(QuantityValue)" />
             public MassConcentration GramsPerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromGramsPerCubicMillimeter(double.CreateChecked(value));
+                => MassConcentration.FromGramsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromGramsPerCubicMillimeter(value.ToDouble(null));
+                => MassConcentration.FromGramsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromGramsPerDeciliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromGramsPerDeciliter(QuantityValue)" />
             public MassConcentration GramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromGramsPerDeciliter(double.CreateChecked(value));
+                => MassConcentration.FromGramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromGramsPerDeciliter(value.ToDouble(null));
+                => MassConcentration.FromGramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromGramsPerLiter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromGramsPerLiter(QuantityValue)" />
             public MassConcentration GramsPerLiter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromGramsPerLiter(double.CreateChecked(value));
+                => MassConcentration.FromGramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromGramsPerLiter(value.ToDouble(null));
+                => MassConcentration.FromGramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromGramsPerMicroliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromGramsPerMicroliter(QuantityValue)" />
             public MassConcentration GramsPerMicroliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromGramsPerMicroliter(double.CreateChecked(value));
+                => MassConcentration.FromGramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromGramsPerMicroliter(value.ToDouble(null));
+                => MassConcentration.FromGramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromGramsPerMilliliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromGramsPerMilliliter(QuantityValue)" />
             public MassConcentration GramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromGramsPerMilliliter(double.CreateChecked(value));
+                => MassConcentration.FromGramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromGramsPerMilliliter(value.ToDouble(null));
+                => MassConcentration.FromGramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicCentimeter(QuantityValue)" />
             public MassConcentration KilogramsPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromKilogramsPerCubicCentimeter(double.CreateChecked(value));
+                => MassConcentration.FromKilogramsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromKilogramsPerCubicCentimeter(value.ToDouble(null));
+                => MassConcentration.FromKilogramsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMeter(QuantityValue)" />
             public MassConcentration KilogramsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromKilogramsPerCubicMeter(double.CreateChecked(value));
+                => MassConcentration.FromKilogramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromKilogramsPerCubicMeter(value.ToDouble(null));
+                => MassConcentration.FromKilogramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMillimeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMillimeter(QuantityValue)" />
             public MassConcentration KilogramsPerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromKilogramsPerCubicMillimeter(double.CreateChecked(value));
+                => MassConcentration.FromKilogramsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromKilogramsPerCubicMillimeter(value.ToDouble(null));
+                => MassConcentration.FromKilogramsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromKilogramsPerLiter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromKilogramsPerLiter(QuantityValue)" />
             public MassConcentration KilogramsPerLiter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromKilogramsPerLiter(double.CreateChecked(value));
+                => MassConcentration.FromKilogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromKilogramsPerLiter(value.ToDouble(null));
+                => MassConcentration.FromKilogramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicFoot(double)" />
+            /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicFoot(QuantityValue)" />
             public MassConcentration KilopoundsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromKilopoundsPerCubicFoot(double.CreateChecked(value));
+                => MassConcentration.FromKilopoundsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromKilopoundsPerCubicFoot(value.ToDouble(null));
+                => MassConcentration.FromKilopoundsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicInch(double)" />
+            /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicInch(QuantityValue)" />
             public MassConcentration KilopoundsPerCubicInch
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromKilopoundsPerCubicInch(double.CreateChecked(value));
+                => MassConcentration.FromKilopoundsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromKilopoundsPerCubicInch(value.ToDouble(null));
+                => MassConcentration.FromKilopoundsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromMicrogramsPerCubicMeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromMicrogramsPerCubicMeter(QuantityValue)" />
             public MassConcentration MicrogramsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromMicrogramsPerCubicMeter(double.CreateChecked(value));
+                => MassConcentration.FromMicrogramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromMicrogramsPerCubicMeter(value.ToDouble(null));
+                => MassConcentration.FromMicrogramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromMicrogramsPerDeciliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromMicrogramsPerDeciliter(QuantityValue)" />
             public MassConcentration MicrogramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromMicrogramsPerDeciliter(double.CreateChecked(value));
+                => MassConcentration.FromMicrogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromMicrogramsPerDeciliter(value.ToDouble(null));
+                => MassConcentration.FromMicrogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromMicrogramsPerLiter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromMicrogramsPerLiter(QuantityValue)" />
             public MassConcentration MicrogramsPerLiter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromMicrogramsPerLiter(double.CreateChecked(value));
+                => MassConcentration.FromMicrogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromMicrogramsPerLiter(value.ToDouble(null));
+                => MassConcentration.FromMicrogramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMicroliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMicroliter(QuantityValue)" />
             public MassConcentration MicrogramsPerMicroliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromMicrogramsPerMicroliter(double.CreateChecked(value));
+                => MassConcentration.FromMicrogramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromMicrogramsPerMicroliter(value.ToDouble(null));
+                => MassConcentration.FromMicrogramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMilliliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMilliliter(QuantityValue)" />
             public MassConcentration MicrogramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromMicrogramsPerMilliliter(double.CreateChecked(value));
+                => MassConcentration.FromMicrogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromMicrogramsPerMilliliter(value.ToDouble(null));
+                => MassConcentration.FromMicrogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromMilligramsPerCubicMeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromMilligramsPerCubicMeter(QuantityValue)" />
             public MassConcentration MilligramsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromMilligramsPerCubicMeter(double.CreateChecked(value));
+                => MassConcentration.FromMilligramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromMilligramsPerCubicMeter(value.ToDouble(null));
+                => MassConcentration.FromMilligramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromMilligramsPerDeciliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromMilligramsPerDeciliter(QuantityValue)" />
             public MassConcentration MilligramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromMilligramsPerDeciliter(double.CreateChecked(value));
+                => MassConcentration.FromMilligramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromMilligramsPerDeciliter(value.ToDouble(null));
+                => MassConcentration.FromMilligramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromMilligramsPerLiter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromMilligramsPerLiter(QuantityValue)" />
             public MassConcentration MilligramsPerLiter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromMilligramsPerLiter(double.CreateChecked(value));
+                => MassConcentration.FromMilligramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromMilligramsPerLiter(value.ToDouble(null));
+                => MassConcentration.FromMilligramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromMilligramsPerMicroliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromMilligramsPerMicroliter(QuantityValue)" />
             public MassConcentration MilligramsPerMicroliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromMilligramsPerMicroliter(double.CreateChecked(value));
+                => MassConcentration.FromMilligramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromMilligramsPerMicroliter(value.ToDouble(null));
+                => MassConcentration.FromMilligramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromMilligramsPerMilliliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromMilligramsPerMilliliter(QuantityValue)" />
             public MassConcentration MilligramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromMilligramsPerMilliliter(double.CreateChecked(value));
+                => MassConcentration.FromMilligramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromMilligramsPerMilliliter(value.ToDouble(null));
+                => MassConcentration.FromMilligramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromNanogramsPerDeciliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromNanogramsPerDeciliter(QuantityValue)" />
             public MassConcentration NanogramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromNanogramsPerDeciliter(double.CreateChecked(value));
+                => MassConcentration.FromNanogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromNanogramsPerDeciliter(value.ToDouble(null));
+                => MassConcentration.FromNanogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromNanogramsPerLiter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromNanogramsPerLiter(QuantityValue)" />
             public MassConcentration NanogramsPerLiter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromNanogramsPerLiter(double.CreateChecked(value));
+                => MassConcentration.FromNanogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromNanogramsPerLiter(value.ToDouble(null));
+                => MassConcentration.FromNanogramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromNanogramsPerMicroliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromNanogramsPerMicroliter(QuantityValue)" />
             public MassConcentration NanogramsPerMicroliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromNanogramsPerMicroliter(double.CreateChecked(value));
+                => MassConcentration.FromNanogramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromNanogramsPerMicroliter(value.ToDouble(null));
+                => MassConcentration.FromNanogramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromNanogramsPerMilliliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromNanogramsPerMilliliter(QuantityValue)" />
             public MassConcentration NanogramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromNanogramsPerMilliliter(double.CreateChecked(value));
+                => MassConcentration.FromNanogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromNanogramsPerMilliliter(value.ToDouble(null));
+                => MassConcentration.FromNanogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromOuncesPerImperialGallon(double)" />
+            /// <inheritdoc cref="MassConcentration.FromOuncesPerImperialGallon(QuantityValue)" />
             public MassConcentration OuncesPerImperialGallon
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromOuncesPerImperialGallon(double.CreateChecked(value));
+                => MassConcentration.FromOuncesPerImperialGallon(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromOuncesPerImperialGallon(value.ToDouble(null));
+                => MassConcentration.FromOuncesPerImperialGallon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromOuncesPerUSGallon(double)" />
+            /// <inheritdoc cref="MassConcentration.FromOuncesPerUSGallon(QuantityValue)" />
             public MassConcentration OuncesPerUSGallon
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromOuncesPerUSGallon(double.CreateChecked(value));
+                => MassConcentration.FromOuncesPerUSGallon(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromOuncesPerUSGallon(value.ToDouble(null));
+                => MassConcentration.FromOuncesPerUSGallon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromPicogramsPerDeciliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromPicogramsPerDeciliter(QuantityValue)" />
             public MassConcentration PicogramsPerDeciliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromPicogramsPerDeciliter(double.CreateChecked(value));
+                => MassConcentration.FromPicogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromPicogramsPerDeciliter(value.ToDouble(null));
+                => MassConcentration.FromPicogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromPicogramsPerLiter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromPicogramsPerLiter(QuantityValue)" />
             public MassConcentration PicogramsPerLiter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromPicogramsPerLiter(double.CreateChecked(value));
+                => MassConcentration.FromPicogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromPicogramsPerLiter(value.ToDouble(null));
+                => MassConcentration.FromPicogramsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromPicogramsPerMicroliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromPicogramsPerMicroliter(QuantityValue)" />
             public MassConcentration PicogramsPerMicroliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromPicogramsPerMicroliter(double.CreateChecked(value));
+                => MassConcentration.FromPicogramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromPicogramsPerMicroliter(value.ToDouble(null));
+                => MassConcentration.FromPicogramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromPicogramsPerMilliliter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromPicogramsPerMilliliter(QuantityValue)" />
             public MassConcentration PicogramsPerMilliliter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromPicogramsPerMilliliter(double.CreateChecked(value));
+                => MassConcentration.FromPicogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromPicogramsPerMilliliter(value.ToDouble(null));
+                => MassConcentration.FromPicogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicFoot(double)" />
+            /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicFoot(QuantityValue)" />
             public MassConcentration PoundsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromPoundsPerCubicFoot(double.CreateChecked(value));
+                => MassConcentration.FromPoundsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromPoundsPerCubicFoot(value.ToDouble(null));
+                => MassConcentration.FromPoundsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicInch(double)" />
+            /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicInch(QuantityValue)" />
             public MassConcentration PoundsPerCubicInch
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromPoundsPerCubicInch(double.CreateChecked(value));
+                => MassConcentration.FromPoundsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromPoundsPerCubicInch(value.ToDouble(null));
+                => MassConcentration.FromPoundsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromPoundsPerImperialGallon(double)" />
+            /// <inheritdoc cref="MassConcentration.FromPoundsPerImperialGallon(QuantityValue)" />
             public MassConcentration PoundsPerImperialGallon
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromPoundsPerImperialGallon(double.CreateChecked(value));
+                => MassConcentration.FromPoundsPerImperialGallon(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromPoundsPerImperialGallon(value.ToDouble(null));
+                => MassConcentration.FromPoundsPerImperialGallon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromPoundsPerUSGallon(double)" />
+            /// <inheritdoc cref="MassConcentration.FromPoundsPerUSGallon(QuantityValue)" />
             public MassConcentration PoundsPerUSGallon
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromPoundsPerUSGallon(double.CreateChecked(value));
+                => MassConcentration.FromPoundsPerUSGallon(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromPoundsPerUSGallon(value.ToDouble(null));
+                => MassConcentration.FromPoundsPerUSGallon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromSlugsPerCubicFoot(double)" />
+            /// <inheritdoc cref="MassConcentration.FromSlugsPerCubicFoot(QuantityValue)" />
             public MassConcentration SlugsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromSlugsPerCubicFoot(double.CreateChecked(value));
+                => MassConcentration.FromSlugsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromSlugsPerCubicFoot(value.ToDouble(null));
+                => MassConcentration.FromSlugsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicCentimeter(QuantityValue)" />
             public MassConcentration TonnesPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromTonnesPerCubicCentimeter(double.CreateChecked(value));
+                => MassConcentration.FromTonnesPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromTonnesPerCubicCentimeter(value.ToDouble(null));
+                => MassConcentration.FromTonnesPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMeter(QuantityValue)" />
             public MassConcentration TonnesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromTonnesPerCubicMeter(double.CreateChecked(value));
+                => MassConcentration.FromTonnesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromTonnesPerCubicMeter(value.ToDouble(null));
+                => MassConcentration.FromTonnesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMillimeter(double)" />
+            /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMillimeter(QuantityValue)" />
             public MassConcentration TonnesPerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => MassConcentration.FromTonnesPerCubicMillimeter(double.CreateChecked(value));
+                => MassConcentration.FromTonnesPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassConcentration.FromTonnesPerCubicMillimeter(value.ToDouble(null));
+                => MassConcentration.FromTonnesPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassExtensions.g.cs
index 27b3cfe78a..c76c08e1e0 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassExtensions.g.cs
@@ -42,252 +42,252 @@ public static class NumberToMassExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Mass.FromCentigrams(double)" />
+            /// <inheritdoc cref="Mass.FromCentigrams(QuantityValue)" />
             public Mass Centigrams
 #if NET7_0_OR_GREATER
-                => Mass.FromCentigrams(double.CreateChecked(value));
+                => Mass.FromCentigrams(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromCentigrams(value.ToDouble(null));
+                => Mass.FromCentigrams(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromDaltons(double)" />
+            /// <inheritdoc cref="Mass.FromDaltons(QuantityValue)" />
             public Mass Daltons
 #if NET7_0_OR_GREATER
-                => Mass.FromDaltons(double.CreateChecked(value));
+                => Mass.FromDaltons(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromDaltons(value.ToDouble(null));
+                => Mass.FromDaltons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromDecagrams(double)" />
+            /// <inheritdoc cref="Mass.FromDecagrams(QuantityValue)" />
             public Mass Decagrams
 #if NET7_0_OR_GREATER
-                => Mass.FromDecagrams(double.CreateChecked(value));
+                => Mass.FromDecagrams(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromDecagrams(value.ToDouble(null));
+                => Mass.FromDecagrams(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromDecigrams(double)" />
+            /// <inheritdoc cref="Mass.FromDecigrams(QuantityValue)" />
             public Mass Decigrams
 #if NET7_0_OR_GREATER
-                => Mass.FromDecigrams(double.CreateChecked(value));
+                => Mass.FromDecigrams(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromDecigrams(value.ToDouble(null));
+                => Mass.FromDecigrams(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromEarthMasses(double)" />
+            /// <inheritdoc cref="Mass.FromEarthMasses(QuantityValue)" />
             public Mass EarthMasses
 #if NET7_0_OR_GREATER
-                => Mass.FromEarthMasses(double.CreateChecked(value));
+                => Mass.FromEarthMasses(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromEarthMasses(value.ToDouble(null));
+                => Mass.FromEarthMasses(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromFemtograms(double)" />
+            /// <inheritdoc cref="Mass.FromFemtograms(QuantityValue)" />
             public Mass Femtograms
 #if NET7_0_OR_GREATER
-                => Mass.FromFemtograms(double.CreateChecked(value));
+                => Mass.FromFemtograms(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromFemtograms(value.ToDouble(null));
+                => Mass.FromFemtograms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromGigadaltons(double)" />
+            /// <inheritdoc cref="Mass.FromGigadaltons(QuantityValue)" />
             public Mass Gigadaltons
 #if NET7_0_OR_GREATER
-                => Mass.FromGigadaltons(double.CreateChecked(value));
+                => Mass.FromGigadaltons(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromGigadaltons(value.ToDouble(null));
+                => Mass.FromGigadaltons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromGrains(double)" />
+            /// <inheritdoc cref="Mass.FromGrains(QuantityValue)" />
             public Mass Grains
 #if NET7_0_OR_GREATER
-                => Mass.FromGrains(double.CreateChecked(value));
+                => Mass.FromGrains(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromGrains(value.ToDouble(null));
+                => Mass.FromGrains(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromGrams(double)" />
+            /// <inheritdoc cref="Mass.FromGrams(QuantityValue)" />
             public Mass Grams
 #if NET7_0_OR_GREATER
-                => Mass.FromGrams(double.CreateChecked(value));
+                => Mass.FromGrams(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromGrams(value.ToDouble(null));
+                => Mass.FromGrams(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromHectograms(double)" />
+            /// <inheritdoc cref="Mass.FromHectograms(QuantityValue)" />
             public Mass Hectograms
 #if NET7_0_OR_GREATER
-                => Mass.FromHectograms(double.CreateChecked(value));
+                => Mass.FromHectograms(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromHectograms(value.ToDouble(null));
+                => Mass.FromHectograms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromKilodaltons(double)" />
+            /// <inheritdoc cref="Mass.FromKilodaltons(QuantityValue)" />
             public Mass Kilodaltons
 #if NET7_0_OR_GREATER
-                => Mass.FromKilodaltons(double.CreateChecked(value));
+                => Mass.FromKilodaltons(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromKilodaltons(value.ToDouble(null));
+                => Mass.FromKilodaltons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromKilograms(double)" />
+            /// <inheritdoc cref="Mass.FromKilograms(QuantityValue)" />
             public Mass Kilograms
 #if NET7_0_OR_GREATER
-                => Mass.FromKilograms(double.CreateChecked(value));
+                => Mass.FromKilograms(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromKilograms(value.ToDouble(null));
+                => Mass.FromKilograms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromKilopounds(double)" />
+            /// <inheritdoc cref="Mass.FromKilopounds(QuantityValue)" />
             public Mass Kilopounds
 #if NET7_0_OR_GREATER
-                => Mass.FromKilopounds(double.CreateChecked(value));
+                => Mass.FromKilopounds(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromKilopounds(value.ToDouble(null));
+                => Mass.FromKilopounds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromKilotonnes(double)" />
+            /// <inheritdoc cref="Mass.FromKilotonnes(QuantityValue)" />
             public Mass Kilotonnes
 #if NET7_0_OR_GREATER
-                => Mass.FromKilotonnes(double.CreateChecked(value));
+                => Mass.FromKilotonnes(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromKilotonnes(value.ToDouble(null));
+                => Mass.FromKilotonnes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromLongHundredweight(double)" />
+            /// <inheritdoc cref="Mass.FromLongHundredweight(QuantityValue)" />
             public Mass LongHundredweight
 #if NET7_0_OR_GREATER
-                => Mass.FromLongHundredweight(double.CreateChecked(value));
+                => Mass.FromLongHundredweight(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromLongHundredweight(value.ToDouble(null));
+                => Mass.FromLongHundredweight(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromLongTons(double)" />
+            /// <inheritdoc cref="Mass.FromLongTons(QuantityValue)" />
             public Mass LongTons
 #if NET7_0_OR_GREATER
-                => Mass.FromLongTons(double.CreateChecked(value));
+                => Mass.FromLongTons(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromLongTons(value.ToDouble(null));
+                => Mass.FromLongTons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromMegadaltons(double)" />
+            /// <inheritdoc cref="Mass.FromMegadaltons(QuantityValue)" />
             public Mass Megadaltons
 #if NET7_0_OR_GREATER
-                => Mass.FromMegadaltons(double.CreateChecked(value));
+                => Mass.FromMegadaltons(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromMegadaltons(value.ToDouble(null));
+                => Mass.FromMegadaltons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromMegapounds(double)" />
+            /// <inheritdoc cref="Mass.FromMegapounds(QuantityValue)" />
             public Mass Megapounds
 #if NET7_0_OR_GREATER
-                => Mass.FromMegapounds(double.CreateChecked(value));
+                => Mass.FromMegapounds(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromMegapounds(value.ToDouble(null));
+                => Mass.FromMegapounds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromMegatonnes(double)" />
+            /// <inheritdoc cref="Mass.FromMegatonnes(QuantityValue)" />
             public Mass Megatonnes
 #if NET7_0_OR_GREATER
-                => Mass.FromMegatonnes(double.CreateChecked(value));
+                => Mass.FromMegatonnes(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromMegatonnes(value.ToDouble(null));
+                => Mass.FromMegatonnes(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromMicrograms(double)" />
+            /// <inheritdoc cref="Mass.FromMicrograms(QuantityValue)" />
             public Mass Micrograms
 #if NET7_0_OR_GREATER
-                => Mass.FromMicrograms(double.CreateChecked(value));
+                => Mass.FromMicrograms(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromMicrograms(value.ToDouble(null));
+                => Mass.FromMicrograms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromMilligrams(double)" />
+            /// <inheritdoc cref="Mass.FromMilligrams(QuantityValue)" />
             public Mass Milligrams
 #if NET7_0_OR_GREATER
-                => Mass.FromMilligrams(double.CreateChecked(value));
+                => Mass.FromMilligrams(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromMilligrams(value.ToDouble(null));
+                => Mass.FromMilligrams(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromNanograms(double)" />
+            /// <inheritdoc cref="Mass.FromNanograms(QuantityValue)" />
             public Mass Nanograms
 #if NET7_0_OR_GREATER
-                => Mass.FromNanograms(double.CreateChecked(value));
+                => Mass.FromNanograms(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromNanograms(value.ToDouble(null));
+                => Mass.FromNanograms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromOunces(double)" />
+            /// <inheritdoc cref="Mass.FromOunces(QuantityValue)" />
             public Mass Ounces
 #if NET7_0_OR_GREATER
-                => Mass.FromOunces(double.CreateChecked(value));
+                => Mass.FromOunces(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromOunces(value.ToDouble(null));
+                => Mass.FromOunces(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromPicograms(double)" />
+            /// <inheritdoc cref="Mass.FromPicograms(QuantityValue)" />
             public Mass Picograms
 #if NET7_0_OR_GREATER
-                => Mass.FromPicograms(double.CreateChecked(value));
+                => Mass.FromPicograms(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromPicograms(value.ToDouble(null));
+                => Mass.FromPicograms(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromPounds(double)" />
+            /// <inheritdoc cref="Mass.FromPounds(QuantityValue)" />
             public Mass Pounds
 #if NET7_0_OR_GREATER
-                => Mass.FromPounds(double.CreateChecked(value));
+                => Mass.FromPounds(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromPounds(value.ToDouble(null));
+                => Mass.FromPounds(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromShortHundredweight(double)" />
+            /// <inheritdoc cref="Mass.FromShortHundredweight(QuantityValue)" />
             public Mass ShortHundredweight
 #if NET7_0_OR_GREATER
-                => Mass.FromShortHundredweight(double.CreateChecked(value));
+                => Mass.FromShortHundredweight(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromShortHundredweight(value.ToDouble(null));
+                => Mass.FromShortHundredweight(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromShortTons(double)" />
+            /// <inheritdoc cref="Mass.FromShortTons(QuantityValue)" />
             public Mass ShortTons
 #if NET7_0_OR_GREATER
-                => Mass.FromShortTons(double.CreateChecked(value));
+                => Mass.FromShortTons(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromShortTons(value.ToDouble(null));
+                => Mass.FromShortTons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromSlugs(double)" />
+            /// <inheritdoc cref="Mass.FromSlugs(QuantityValue)" />
             public Mass Slugs
 #if NET7_0_OR_GREATER
-                => Mass.FromSlugs(double.CreateChecked(value));
+                => Mass.FromSlugs(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromSlugs(value.ToDouble(null));
+                => Mass.FromSlugs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromSolarMasses(double)" />
+            /// <inheritdoc cref="Mass.FromSolarMasses(QuantityValue)" />
             public Mass SolarMasses
 #if NET7_0_OR_GREATER
-                => Mass.FromSolarMasses(double.CreateChecked(value));
+                => Mass.FromSolarMasses(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromSolarMasses(value.ToDouble(null));
+                => Mass.FromSolarMasses(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromStone(double)" />
+            /// <inheritdoc cref="Mass.FromStone(QuantityValue)" />
             public Mass Stone
 #if NET7_0_OR_GREATER
-                => Mass.FromStone(double.CreateChecked(value));
+                => Mass.FromStone(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromStone(value.ToDouble(null));
+                => Mass.FromStone(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Mass.FromTonnes(double)" />
+            /// <inheritdoc cref="Mass.FromTonnes(QuantityValue)" />
             public Mass Tonnes
 #if NET7_0_OR_GREATER
-                => Mass.FromTonnes(double.CreateChecked(value));
+                => Mass.FromTonnes(QuantityValue.CreateChecked(value));
 #else
-                => Mass.FromTonnes(value.ToDouble(null));
+                => Mass.FromTonnes(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFlowExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFlowExtensions.g.cs
index fa4446a774..0ffaa71cf3 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFlowExtensions.g.cs
@@ -42,268 +42,268 @@ public static class NumberToMassFlowExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MassFlow.FromCentigramsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromCentigramsPerDay(QuantityValue)" />
             public MassFlow CentigramsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromCentigramsPerDay(double.CreateChecked(value));
+                => MassFlow.FromCentigramsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromCentigramsPerDay(value.ToDouble(null));
+                => MassFlow.FromCentigramsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromCentigramsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromCentigramsPerSecond(QuantityValue)" />
             public MassFlow CentigramsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromCentigramsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromCentigramsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromCentigramsPerSecond(value.ToDouble(null));
+                => MassFlow.FromCentigramsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromDecagramsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromDecagramsPerDay(QuantityValue)" />
             public MassFlow DecagramsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromDecagramsPerDay(double.CreateChecked(value));
+                => MassFlow.FromDecagramsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromDecagramsPerDay(value.ToDouble(null));
+                => MassFlow.FromDecagramsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromDecagramsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromDecagramsPerSecond(QuantityValue)" />
             public MassFlow DecagramsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromDecagramsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromDecagramsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromDecagramsPerSecond(value.ToDouble(null));
+                => MassFlow.FromDecagramsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromDecigramsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromDecigramsPerDay(QuantityValue)" />
             public MassFlow DecigramsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromDecigramsPerDay(double.CreateChecked(value));
+                => MassFlow.FromDecigramsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromDecigramsPerDay(value.ToDouble(null));
+                => MassFlow.FromDecigramsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromDecigramsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromDecigramsPerSecond(QuantityValue)" />
             public MassFlow DecigramsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromDecigramsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromDecigramsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromDecigramsPerSecond(value.ToDouble(null));
+                => MassFlow.FromDecigramsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromGramsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromGramsPerDay(QuantityValue)" />
             public MassFlow GramsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromGramsPerDay(double.CreateChecked(value));
+                => MassFlow.FromGramsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromGramsPerDay(value.ToDouble(null));
+                => MassFlow.FromGramsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromGramsPerHour(double)" />
+            /// <inheritdoc cref="MassFlow.FromGramsPerHour(QuantityValue)" />
             public MassFlow GramsPerHour
 #if NET7_0_OR_GREATER
-                => MassFlow.FromGramsPerHour(double.CreateChecked(value));
+                => MassFlow.FromGramsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromGramsPerHour(value.ToDouble(null));
+                => MassFlow.FromGramsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromGramsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromGramsPerSecond(QuantityValue)" />
             public MassFlow GramsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromGramsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromGramsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromGramsPerSecond(value.ToDouble(null));
+                => MassFlow.FromGramsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromHectogramsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromHectogramsPerDay(QuantityValue)" />
             public MassFlow HectogramsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromHectogramsPerDay(double.CreateChecked(value));
+                => MassFlow.FromHectogramsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromHectogramsPerDay(value.ToDouble(null));
+                => MassFlow.FromHectogramsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromHectogramsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromHectogramsPerSecond(QuantityValue)" />
             public MassFlow HectogramsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromHectogramsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromHectogramsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromHectogramsPerSecond(value.ToDouble(null));
+                => MassFlow.FromHectogramsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromKilogramsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromKilogramsPerDay(QuantityValue)" />
             public MassFlow KilogramsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromKilogramsPerDay(double.CreateChecked(value));
+                => MassFlow.FromKilogramsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromKilogramsPerDay(value.ToDouble(null));
+                => MassFlow.FromKilogramsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromKilogramsPerHour(double)" />
+            /// <inheritdoc cref="MassFlow.FromKilogramsPerHour(QuantityValue)" />
             public MassFlow KilogramsPerHour
 #if NET7_0_OR_GREATER
-                => MassFlow.FromKilogramsPerHour(double.CreateChecked(value));
+                => MassFlow.FromKilogramsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromKilogramsPerHour(value.ToDouble(null));
+                => MassFlow.FromKilogramsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromKilogramsPerMinute(double)" />
+            /// <inheritdoc cref="MassFlow.FromKilogramsPerMinute(QuantityValue)" />
             public MassFlow KilogramsPerMinute
 #if NET7_0_OR_GREATER
-                => MassFlow.FromKilogramsPerMinute(double.CreateChecked(value));
+                => MassFlow.FromKilogramsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromKilogramsPerMinute(value.ToDouble(null));
+                => MassFlow.FromKilogramsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromKilogramsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromKilogramsPerSecond(QuantityValue)" />
             public MassFlow KilogramsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromKilogramsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromKilogramsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromKilogramsPerSecond(value.ToDouble(null));
+                => MassFlow.FromKilogramsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromMegagramsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromMegagramsPerDay(QuantityValue)" />
             public MassFlow MegagramsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromMegagramsPerDay(double.CreateChecked(value));
+                => MassFlow.FromMegagramsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromMegagramsPerDay(value.ToDouble(null));
+                => MassFlow.FromMegagramsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromMegapoundsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromMegapoundsPerDay(QuantityValue)" />
             public MassFlow MegapoundsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromMegapoundsPerDay(double.CreateChecked(value));
+                => MassFlow.FromMegapoundsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromMegapoundsPerDay(value.ToDouble(null));
+                => MassFlow.FromMegapoundsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromMegapoundsPerHour(double)" />
+            /// <inheritdoc cref="MassFlow.FromMegapoundsPerHour(QuantityValue)" />
             public MassFlow MegapoundsPerHour
 #if NET7_0_OR_GREATER
-                => MassFlow.FromMegapoundsPerHour(double.CreateChecked(value));
+                => MassFlow.FromMegapoundsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromMegapoundsPerHour(value.ToDouble(null));
+                => MassFlow.FromMegapoundsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromMegapoundsPerMinute(double)" />
+            /// <inheritdoc cref="MassFlow.FromMegapoundsPerMinute(QuantityValue)" />
             public MassFlow MegapoundsPerMinute
 #if NET7_0_OR_GREATER
-                => MassFlow.FromMegapoundsPerMinute(double.CreateChecked(value));
+                => MassFlow.FromMegapoundsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromMegapoundsPerMinute(value.ToDouble(null));
+                => MassFlow.FromMegapoundsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromMegapoundsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromMegapoundsPerSecond(QuantityValue)" />
             public MassFlow MegapoundsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromMegapoundsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromMegapoundsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromMegapoundsPerSecond(value.ToDouble(null));
+                => MassFlow.FromMegapoundsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromMicrogramsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromMicrogramsPerDay(QuantityValue)" />
             public MassFlow MicrogramsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromMicrogramsPerDay(double.CreateChecked(value));
+                => MassFlow.FromMicrogramsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromMicrogramsPerDay(value.ToDouble(null));
+                => MassFlow.FromMicrogramsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromMicrogramsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromMicrogramsPerSecond(QuantityValue)" />
             public MassFlow MicrogramsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromMicrogramsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromMicrogramsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromMicrogramsPerSecond(value.ToDouble(null));
+                => MassFlow.FromMicrogramsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromMilligramsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromMilligramsPerDay(QuantityValue)" />
             public MassFlow MilligramsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromMilligramsPerDay(double.CreateChecked(value));
+                => MassFlow.FromMilligramsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromMilligramsPerDay(value.ToDouble(null));
+                => MassFlow.FromMilligramsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromMilligramsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromMilligramsPerSecond(QuantityValue)" />
             public MassFlow MilligramsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromMilligramsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromMilligramsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromMilligramsPerSecond(value.ToDouble(null));
+                => MassFlow.FromMilligramsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromNanogramsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromNanogramsPerDay(QuantityValue)" />
             public MassFlow NanogramsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromNanogramsPerDay(double.CreateChecked(value));
+                => MassFlow.FromNanogramsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromNanogramsPerDay(value.ToDouble(null));
+                => MassFlow.FromNanogramsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromNanogramsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromNanogramsPerSecond(QuantityValue)" />
             public MassFlow NanogramsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromNanogramsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromNanogramsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromNanogramsPerSecond(value.ToDouble(null));
+                => MassFlow.FromNanogramsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromPoundsPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromPoundsPerDay(QuantityValue)" />
             public MassFlow PoundsPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromPoundsPerDay(double.CreateChecked(value));
+                => MassFlow.FromPoundsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromPoundsPerDay(value.ToDouble(null));
+                => MassFlow.FromPoundsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromPoundsPerHour(double)" />
+            /// <inheritdoc cref="MassFlow.FromPoundsPerHour(QuantityValue)" />
             public MassFlow PoundsPerHour
 #if NET7_0_OR_GREATER
-                => MassFlow.FromPoundsPerHour(double.CreateChecked(value));
+                => MassFlow.FromPoundsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromPoundsPerHour(value.ToDouble(null));
+                => MassFlow.FromPoundsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromPoundsPerMinute(double)" />
+            /// <inheritdoc cref="MassFlow.FromPoundsPerMinute(QuantityValue)" />
             public MassFlow PoundsPerMinute
 #if NET7_0_OR_GREATER
-                => MassFlow.FromPoundsPerMinute(double.CreateChecked(value));
+                => MassFlow.FromPoundsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromPoundsPerMinute(value.ToDouble(null));
+                => MassFlow.FromPoundsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromPoundsPerSecond(double)" />
+            /// <inheritdoc cref="MassFlow.FromPoundsPerSecond(QuantityValue)" />
             public MassFlow PoundsPerSecond
 #if NET7_0_OR_GREATER
-                => MassFlow.FromPoundsPerSecond(double.CreateChecked(value));
+                => MassFlow.FromPoundsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromPoundsPerSecond(value.ToDouble(null));
+                => MassFlow.FromPoundsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromShortTonsPerHour(double)" />
+            /// <inheritdoc cref="MassFlow.FromShortTonsPerHour(QuantityValue)" />
             public MassFlow ShortTonsPerHour
 #if NET7_0_OR_GREATER
-                => MassFlow.FromShortTonsPerHour(double.CreateChecked(value));
+                => MassFlow.FromShortTonsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromShortTonsPerHour(value.ToDouble(null));
+                => MassFlow.FromShortTonsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromTonnesPerDay(double)" />
+            /// <inheritdoc cref="MassFlow.FromTonnesPerDay(QuantityValue)" />
             public MassFlow TonnesPerDay
 #if NET7_0_OR_GREATER
-                => MassFlow.FromTonnesPerDay(double.CreateChecked(value));
+                => MassFlow.FromTonnesPerDay(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromTonnesPerDay(value.ToDouble(null));
+                => MassFlow.FromTonnesPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlow.FromTonnesPerHour(double)" />
+            /// <inheritdoc cref="MassFlow.FromTonnesPerHour(QuantityValue)" />
             public MassFlow TonnesPerHour
 #if NET7_0_OR_GREATER
-                => MassFlow.FromTonnesPerHour(double.CreateChecked(value));
+                => MassFlow.FromTonnesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => MassFlow.FromTonnesPerHour(value.ToDouble(null));
+                => MassFlow.FromTonnesPerHour(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFluxExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFluxExtensions.g.cs
index 1739177f50..af5efc259c 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFluxExtensions.g.cs
@@ -42,100 +42,100 @@ public static class NumberToMassFluxExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareCentimeter(QuantityValue)" />
             public MassFlux GramsPerHourPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromGramsPerHourPerSquareCentimeter(double.CreateChecked(value));
+                => MassFlux.FromGramsPerHourPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromGramsPerHourPerSquareCentimeter(value.ToDouble(null));
+                => MassFlux.FromGramsPerHourPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMeter(QuantityValue)" />
             public MassFlux GramsPerHourPerSquareMeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromGramsPerHourPerSquareMeter(double.CreateChecked(value));
+                => MassFlux.FromGramsPerHourPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromGramsPerHourPerSquareMeter(value.ToDouble(null));
+                => MassFlux.FromGramsPerHourPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMillimeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMillimeter(QuantityValue)" />
             public MassFlux GramsPerHourPerSquareMillimeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromGramsPerHourPerSquareMillimeter(double.CreateChecked(value));
+                => MassFlux.FromGramsPerHourPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromGramsPerHourPerSquareMillimeter(value.ToDouble(null));
+                => MassFlux.FromGramsPerHourPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareCentimeter(QuantityValue)" />
             public MassFlux GramsPerSecondPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromGramsPerSecondPerSquareCentimeter(double.CreateChecked(value));
+                => MassFlux.FromGramsPerSecondPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromGramsPerSecondPerSquareCentimeter(value.ToDouble(null));
+                => MassFlux.FromGramsPerSecondPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMeter(QuantityValue)" />
             public MassFlux GramsPerSecondPerSquareMeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromGramsPerSecondPerSquareMeter(double.CreateChecked(value));
+                => MassFlux.FromGramsPerSecondPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromGramsPerSecondPerSquareMeter(value.ToDouble(null));
+                => MassFlux.FromGramsPerSecondPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMillimeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMillimeter(QuantityValue)" />
             public MassFlux GramsPerSecondPerSquareMillimeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromGramsPerSecondPerSquareMillimeter(double.CreateChecked(value));
+                => MassFlux.FromGramsPerSecondPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromGramsPerSecondPerSquareMillimeter(value.ToDouble(null));
+                => MassFlux.FromGramsPerSecondPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareCentimeter(QuantityValue)" />
             public MassFlux KilogramsPerHourPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromKilogramsPerHourPerSquareCentimeter(double.CreateChecked(value));
+                => MassFlux.FromKilogramsPerHourPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromKilogramsPerHourPerSquareCentimeter(value.ToDouble(null));
+                => MassFlux.FromKilogramsPerHourPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMeter(QuantityValue)" />
             public MassFlux KilogramsPerHourPerSquareMeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromKilogramsPerHourPerSquareMeter(double.CreateChecked(value));
+                => MassFlux.FromKilogramsPerHourPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromKilogramsPerHourPerSquareMeter(value.ToDouble(null));
+                => MassFlux.FromKilogramsPerHourPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMillimeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMillimeter(QuantityValue)" />
             public MassFlux KilogramsPerHourPerSquareMillimeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromKilogramsPerHourPerSquareMillimeter(double.CreateChecked(value));
+                => MassFlux.FromKilogramsPerHourPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromKilogramsPerHourPerSquareMillimeter(value.ToDouble(null));
+                => MassFlux.FromKilogramsPerHourPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareCentimeter(QuantityValue)" />
             public MassFlux KilogramsPerSecondPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(double.CreateChecked(value));
+                => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(value.ToDouble(null));
+                => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMeter(QuantityValue)" />
             public MassFlux KilogramsPerSecondPerSquareMeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromKilogramsPerSecondPerSquareMeter(double.CreateChecked(value));
+                => MassFlux.FromKilogramsPerSecondPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromKilogramsPerSecondPerSquareMeter(value.ToDouble(null));
+                => MassFlux.FromKilogramsPerSecondPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMillimeter(double)" />
+            /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMillimeter(QuantityValue)" />
             public MassFlux KilogramsPerSecondPerSquareMillimeter
 #if NET7_0_OR_GREATER
-                => MassFlux.FromKilogramsPerSecondPerSquareMillimeter(double.CreateChecked(value));
+                => MassFlux.FromKilogramsPerSecondPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => MassFlux.FromKilogramsPerSecondPerSquareMillimeter(value.ToDouble(null));
+                => MassFlux.FromKilogramsPerSecondPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFractionExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFractionExtensions.g.cs
index e9a92982e2..dbe571f1b9 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFractionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFractionExtensions.g.cs
@@ -42,196 +42,196 @@ public static class NumberToMassFractionExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MassFraction.FromCentigramsPerGram(double)" />
+            /// <inheritdoc cref="MassFraction.FromCentigramsPerGram(QuantityValue)" />
             public MassFraction CentigramsPerGram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromCentigramsPerGram(double.CreateChecked(value));
+                => MassFraction.FromCentigramsPerGram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromCentigramsPerGram(value.ToDouble(null));
+                => MassFraction.FromCentigramsPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromCentigramsPerKilogram(double)" />
+            /// <inheritdoc cref="MassFraction.FromCentigramsPerKilogram(QuantityValue)" />
             public MassFraction CentigramsPerKilogram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromCentigramsPerKilogram(double.CreateChecked(value));
+                => MassFraction.FromCentigramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromCentigramsPerKilogram(value.ToDouble(null));
+                => MassFraction.FromCentigramsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromDecagramsPerGram(double)" />
+            /// <inheritdoc cref="MassFraction.FromDecagramsPerGram(QuantityValue)" />
             public MassFraction DecagramsPerGram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromDecagramsPerGram(double.CreateChecked(value));
+                => MassFraction.FromDecagramsPerGram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromDecagramsPerGram(value.ToDouble(null));
+                => MassFraction.FromDecagramsPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromDecagramsPerKilogram(double)" />
+            /// <inheritdoc cref="MassFraction.FromDecagramsPerKilogram(QuantityValue)" />
             public MassFraction DecagramsPerKilogram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromDecagramsPerKilogram(double.CreateChecked(value));
+                => MassFraction.FromDecagramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromDecagramsPerKilogram(value.ToDouble(null));
+                => MassFraction.FromDecagramsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromDecigramsPerGram(double)" />
+            /// <inheritdoc cref="MassFraction.FromDecigramsPerGram(QuantityValue)" />
             public MassFraction DecigramsPerGram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromDecigramsPerGram(double.CreateChecked(value));
+                => MassFraction.FromDecigramsPerGram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromDecigramsPerGram(value.ToDouble(null));
+                => MassFraction.FromDecigramsPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromDecigramsPerKilogram(double)" />
+            /// <inheritdoc cref="MassFraction.FromDecigramsPerKilogram(QuantityValue)" />
             public MassFraction DecigramsPerKilogram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromDecigramsPerKilogram(double.CreateChecked(value));
+                => MassFraction.FromDecigramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromDecigramsPerKilogram(value.ToDouble(null));
+                => MassFraction.FromDecigramsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromDecimalFractions(double)" />
+            /// <inheritdoc cref="MassFraction.FromDecimalFractions(QuantityValue)" />
             public MassFraction DecimalFractions
 #if NET7_0_OR_GREATER
-                => MassFraction.FromDecimalFractions(double.CreateChecked(value));
+                => MassFraction.FromDecimalFractions(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromDecimalFractions(value.ToDouble(null));
+                => MassFraction.FromDecimalFractions(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromGramsPerGram(double)" />
+            /// <inheritdoc cref="MassFraction.FromGramsPerGram(QuantityValue)" />
             public MassFraction GramsPerGram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromGramsPerGram(double.CreateChecked(value));
+                => MassFraction.FromGramsPerGram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromGramsPerGram(value.ToDouble(null));
+                => MassFraction.FromGramsPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromGramsPerKilogram(double)" />
+            /// <inheritdoc cref="MassFraction.FromGramsPerKilogram(QuantityValue)" />
             public MassFraction GramsPerKilogram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromGramsPerKilogram(double.CreateChecked(value));
+                => MassFraction.FromGramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromGramsPerKilogram(value.ToDouble(null));
+                => MassFraction.FromGramsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromHectogramsPerGram(double)" />
+            /// <inheritdoc cref="MassFraction.FromHectogramsPerGram(QuantityValue)" />
             public MassFraction HectogramsPerGram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromHectogramsPerGram(double.CreateChecked(value));
+                => MassFraction.FromHectogramsPerGram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromHectogramsPerGram(value.ToDouble(null));
+                => MassFraction.FromHectogramsPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromHectogramsPerKilogram(double)" />
+            /// <inheritdoc cref="MassFraction.FromHectogramsPerKilogram(QuantityValue)" />
             public MassFraction HectogramsPerKilogram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromHectogramsPerKilogram(double.CreateChecked(value));
+                => MassFraction.FromHectogramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromHectogramsPerKilogram(value.ToDouble(null));
+                => MassFraction.FromHectogramsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromKilogramsPerGram(double)" />
+            /// <inheritdoc cref="MassFraction.FromKilogramsPerGram(QuantityValue)" />
             public MassFraction KilogramsPerGram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromKilogramsPerGram(double.CreateChecked(value));
+                => MassFraction.FromKilogramsPerGram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromKilogramsPerGram(value.ToDouble(null));
+                => MassFraction.FromKilogramsPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromKilogramsPerKilogram(double)" />
+            /// <inheritdoc cref="MassFraction.FromKilogramsPerKilogram(QuantityValue)" />
             public MassFraction KilogramsPerKilogram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromKilogramsPerKilogram(double.CreateChecked(value));
+                => MassFraction.FromKilogramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromKilogramsPerKilogram(value.ToDouble(null));
+                => MassFraction.FromKilogramsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromMicrogramsPerGram(double)" />
+            /// <inheritdoc cref="MassFraction.FromMicrogramsPerGram(QuantityValue)" />
             public MassFraction MicrogramsPerGram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromMicrogramsPerGram(double.CreateChecked(value));
+                => MassFraction.FromMicrogramsPerGram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromMicrogramsPerGram(value.ToDouble(null));
+                => MassFraction.FromMicrogramsPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromMicrogramsPerKilogram(double)" />
+            /// <inheritdoc cref="MassFraction.FromMicrogramsPerKilogram(QuantityValue)" />
             public MassFraction MicrogramsPerKilogram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromMicrogramsPerKilogram(double.CreateChecked(value));
+                => MassFraction.FromMicrogramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromMicrogramsPerKilogram(value.ToDouble(null));
+                => MassFraction.FromMicrogramsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromMilligramsPerGram(double)" />
+            /// <inheritdoc cref="MassFraction.FromMilligramsPerGram(QuantityValue)" />
             public MassFraction MilligramsPerGram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromMilligramsPerGram(double.CreateChecked(value));
+                => MassFraction.FromMilligramsPerGram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromMilligramsPerGram(value.ToDouble(null));
+                => MassFraction.FromMilligramsPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromMilligramsPerKilogram(double)" />
+            /// <inheritdoc cref="MassFraction.FromMilligramsPerKilogram(QuantityValue)" />
             public MassFraction MilligramsPerKilogram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromMilligramsPerKilogram(double.CreateChecked(value));
+                => MassFraction.FromMilligramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromMilligramsPerKilogram(value.ToDouble(null));
+                => MassFraction.FromMilligramsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromNanogramsPerGram(double)" />
+            /// <inheritdoc cref="MassFraction.FromNanogramsPerGram(QuantityValue)" />
             public MassFraction NanogramsPerGram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromNanogramsPerGram(double.CreateChecked(value));
+                => MassFraction.FromNanogramsPerGram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromNanogramsPerGram(value.ToDouble(null));
+                => MassFraction.FromNanogramsPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromNanogramsPerKilogram(double)" />
+            /// <inheritdoc cref="MassFraction.FromNanogramsPerKilogram(QuantityValue)" />
             public MassFraction NanogramsPerKilogram
 #if NET7_0_OR_GREATER
-                => MassFraction.FromNanogramsPerKilogram(double.CreateChecked(value));
+                => MassFraction.FromNanogramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromNanogramsPerKilogram(value.ToDouble(null));
+                => MassFraction.FromNanogramsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromPartsPerBillion(double)" />
+            /// <inheritdoc cref="MassFraction.FromPartsPerBillion(QuantityValue)" />
             public MassFraction PartsPerBillion
 #if NET7_0_OR_GREATER
-                => MassFraction.FromPartsPerBillion(double.CreateChecked(value));
+                => MassFraction.FromPartsPerBillion(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromPartsPerBillion(value.ToDouble(null));
+                => MassFraction.FromPartsPerBillion(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromPartsPerMillion(double)" />
+            /// <inheritdoc cref="MassFraction.FromPartsPerMillion(QuantityValue)" />
             public MassFraction PartsPerMillion
 #if NET7_0_OR_GREATER
-                => MassFraction.FromPartsPerMillion(double.CreateChecked(value));
+                => MassFraction.FromPartsPerMillion(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromPartsPerMillion(value.ToDouble(null));
+                => MassFraction.FromPartsPerMillion(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromPartsPerThousand(double)" />
+            /// <inheritdoc cref="MassFraction.FromPartsPerThousand(QuantityValue)" />
             public MassFraction PartsPerThousand
 #if NET7_0_OR_GREATER
-                => MassFraction.FromPartsPerThousand(double.CreateChecked(value));
+                => MassFraction.FromPartsPerThousand(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromPartsPerThousand(value.ToDouble(null));
+                => MassFraction.FromPartsPerThousand(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromPartsPerTrillion(double)" />
+            /// <inheritdoc cref="MassFraction.FromPartsPerTrillion(QuantityValue)" />
             public MassFraction PartsPerTrillion
 #if NET7_0_OR_GREATER
-                => MassFraction.FromPartsPerTrillion(double.CreateChecked(value));
+                => MassFraction.FromPartsPerTrillion(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromPartsPerTrillion(value.ToDouble(null));
+                => MassFraction.FromPartsPerTrillion(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassFraction.FromPercent(double)" />
+            /// <inheritdoc cref="MassFraction.FromPercent(QuantityValue)" />
             public MassFraction Percent
 #if NET7_0_OR_GREATER
-                => MassFraction.FromPercent(double.CreateChecked(value));
+                => MassFraction.FromPercent(QuantityValue.CreateChecked(value));
 #else
-                => MassFraction.FromPercent(value.ToDouble(null));
+                => MassFraction.FromPercent(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
index 450d9f78eb..5eeee90ed2 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
@@ -42,228 +42,228 @@ public static class NumberToMassMomentOfInertiaExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareCentimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareCentimeters(QuantityValue)" />
             public MassMomentOfInertia GramSquareCentimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromGramSquareCentimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromGramSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromGramSquareCentimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromGramSquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareDecimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareDecimeters(QuantityValue)" />
             public MassMomentOfInertia GramSquareDecimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromGramSquareDecimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromGramSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromGramSquareDecimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromGramSquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMeters(QuantityValue)" />
             public MassMomentOfInertia GramSquareMeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromGramSquareMeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromGramSquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromGramSquareMeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromGramSquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMillimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMillimeters(QuantityValue)" />
             public MassMomentOfInertia GramSquareMillimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromGramSquareMillimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromGramSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromGramSquareMillimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromGramSquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareCentimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareCentimeters(QuantityValue)" />
             public MassMomentOfInertia KilogramSquareCentimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromKilogramSquareCentimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromKilogramSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromKilogramSquareCentimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromKilogramSquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareDecimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareDecimeters(QuantityValue)" />
             public MassMomentOfInertia KilogramSquareDecimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromKilogramSquareDecimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromKilogramSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromKilogramSquareDecimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromKilogramSquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMeters(QuantityValue)" />
             public MassMomentOfInertia KilogramSquareMeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromKilogramSquareMeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromKilogramSquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromKilogramSquareMeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromKilogramSquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMillimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMillimeters(QuantityValue)" />
             public MassMomentOfInertia KilogramSquareMillimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromKilogramSquareMillimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromKilogramSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromKilogramSquareMillimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromKilogramSquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareCentimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareCentimeters(QuantityValue)" />
             public MassMomentOfInertia KilotonneSquareCentimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromKilotonneSquareCentimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromKilotonneSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromKilotonneSquareCentimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromKilotonneSquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareDecimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareDecimeters(QuantityValue)" />
             public MassMomentOfInertia KilotonneSquareDecimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromKilotonneSquareDecimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromKilotonneSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromKilotonneSquareDecimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromKilotonneSquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMeters(QuantityValue)" />
             public MassMomentOfInertia KilotonneSquareMeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromKilotonneSquareMeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromKilotonneSquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromKilotonneSquareMeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromKilotonneSquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMillimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMillimeters(QuantityValue)" />
             public MassMomentOfInertia KilotonneSquareMillimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromKilotonneSquareMillimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromKilotonneSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromKilotonneSquareMillimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromKilotonneSquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareCentimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareCentimeters(QuantityValue)" />
             public MassMomentOfInertia MegatonneSquareCentimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromMegatonneSquareCentimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromMegatonneSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromMegatonneSquareCentimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromMegatonneSquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareDecimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareDecimeters(QuantityValue)" />
             public MassMomentOfInertia MegatonneSquareDecimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromMegatonneSquareDecimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromMegatonneSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromMegatonneSquareDecimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromMegatonneSquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMeters(QuantityValue)" />
             public MassMomentOfInertia MegatonneSquareMeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromMegatonneSquareMeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromMegatonneSquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromMegatonneSquareMeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromMegatonneSquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMillimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMillimeters(QuantityValue)" />
             public MassMomentOfInertia MegatonneSquareMillimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromMegatonneSquareMillimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromMegatonneSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromMegatonneSquareMillimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromMegatonneSquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareCentimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareCentimeters(QuantityValue)" />
             public MassMomentOfInertia MilligramSquareCentimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromMilligramSquareCentimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromMilligramSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromMilligramSquareCentimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromMilligramSquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareDecimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareDecimeters(QuantityValue)" />
             public MassMomentOfInertia MilligramSquareDecimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromMilligramSquareDecimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromMilligramSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromMilligramSquareDecimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromMilligramSquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMeters(QuantityValue)" />
             public MassMomentOfInertia MilligramSquareMeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromMilligramSquareMeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromMilligramSquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromMilligramSquareMeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromMilligramSquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMillimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMillimeters(QuantityValue)" />
             public MassMomentOfInertia MilligramSquareMillimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromMilligramSquareMillimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromMilligramSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromMilligramSquareMillimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromMilligramSquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareFeet(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareFeet(QuantityValue)" />
             public MassMomentOfInertia PoundSquareFeet
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromPoundSquareFeet(double.CreateChecked(value));
+                => MassMomentOfInertia.FromPoundSquareFeet(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromPoundSquareFeet(value.ToDouble(null));
+                => MassMomentOfInertia.FromPoundSquareFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareInches(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareInches(QuantityValue)" />
             public MassMomentOfInertia PoundSquareInches
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromPoundSquareInches(double.CreateChecked(value));
+                => MassMomentOfInertia.FromPoundSquareInches(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromPoundSquareInches(value.ToDouble(null));
+                => MassMomentOfInertia.FromPoundSquareInches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareFeet(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareFeet(QuantityValue)" />
             public MassMomentOfInertia SlugSquareFeet
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromSlugSquareFeet(double.CreateChecked(value));
+                => MassMomentOfInertia.FromSlugSquareFeet(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromSlugSquareFeet(value.ToDouble(null));
+                => MassMomentOfInertia.FromSlugSquareFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareInches(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareInches(QuantityValue)" />
             public MassMomentOfInertia SlugSquareInches
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromSlugSquareInches(double.CreateChecked(value));
+                => MassMomentOfInertia.FromSlugSquareInches(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromSlugSquareInches(value.ToDouble(null));
+                => MassMomentOfInertia.FromSlugSquareInches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareCentimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareCentimeters(QuantityValue)" />
             public MassMomentOfInertia TonneSquareCentimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromTonneSquareCentimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromTonneSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromTonneSquareCentimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromTonneSquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareDecimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareDecimeters(QuantityValue)" />
             public MassMomentOfInertia TonneSquareDecimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromTonneSquareDecimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromTonneSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromTonneSquareDecimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromTonneSquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMeters(QuantityValue)" />
             public MassMomentOfInertia TonneSquareMeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromTonneSquareMeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromTonneSquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromTonneSquareMeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromTonneSquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMillimeters(double)" />
+            /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMillimeters(QuantityValue)" />
             public MassMomentOfInertia TonneSquareMillimeters
 #if NET7_0_OR_GREATER
-                => MassMomentOfInertia.FromTonneSquareMillimeters(double.CreateChecked(value));
+                => MassMomentOfInertia.FromTonneSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => MassMomentOfInertia.FromTonneSquareMillimeters(value.ToDouble(null));
+                => MassMomentOfInertia.FromTonneSquareMillimeters(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolalityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolalityExtensions.g.cs
index 0e7a18e631..5d55197b85 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolalityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolalityExtensions.g.cs
@@ -42,28 +42,28 @@ public static class NumberToMolalityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Molality.FromMillimolesPerKilogram(double)" />
+            /// <inheritdoc cref="Molality.FromMillimolesPerKilogram(QuantityValue)" />
             public Molality MillimolesPerKilogram
 #if NET7_0_OR_GREATER
-                => Molality.FromMillimolesPerKilogram(double.CreateChecked(value));
+                => Molality.FromMillimolesPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => Molality.FromMillimolesPerKilogram(value.ToDouble(null));
+                => Molality.FromMillimolesPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molality.FromMolesPerGram(double)" />
+            /// <inheritdoc cref="Molality.FromMolesPerGram(QuantityValue)" />
             public Molality MolesPerGram
 #if NET7_0_OR_GREATER
-                => Molality.FromMolesPerGram(double.CreateChecked(value));
+                => Molality.FromMolesPerGram(QuantityValue.CreateChecked(value));
 #else
-                => Molality.FromMolesPerGram(value.ToDouble(null));
+                => Molality.FromMolesPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molality.FromMolesPerKilogram(double)" />
+            /// <inheritdoc cref="Molality.FromMolesPerKilogram(QuantityValue)" />
             public Molality MolesPerKilogram
 #if NET7_0_OR_GREATER
-                => Molality.FromMolesPerKilogram(double.CreateChecked(value));
+                => Molality.FromMolesPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => Molality.FromMolesPerKilogram(value.ToDouble(null));
+                => Molality.FromMolesPerKilogram(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEnergyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
index a67cb580e7..ec5239e27b 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
@@ -42,28 +42,28 @@ public static class NumberToMolarEnergyExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MolarEnergy.FromJoulesPerMole(double)" />
+            /// <inheritdoc cref="MolarEnergy.FromJoulesPerMole(QuantityValue)" />
             public MolarEnergy JoulesPerMole
 #if NET7_0_OR_GREATER
-                => MolarEnergy.FromJoulesPerMole(double.CreateChecked(value));
+                => MolarEnergy.FromJoulesPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarEnergy.FromJoulesPerMole(value.ToDouble(null));
+                => MolarEnergy.FromJoulesPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarEnergy.FromKilojoulesPerMole(double)" />
+            /// <inheritdoc cref="MolarEnergy.FromKilojoulesPerMole(QuantityValue)" />
             public MolarEnergy KilojoulesPerMole
 #if NET7_0_OR_GREATER
-                => MolarEnergy.FromKilojoulesPerMole(double.CreateChecked(value));
+                => MolarEnergy.FromKilojoulesPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarEnergy.FromKilojoulesPerMole(value.ToDouble(null));
+                => MolarEnergy.FromKilojoulesPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarEnergy.FromMegajoulesPerMole(double)" />
+            /// <inheritdoc cref="MolarEnergy.FromMegajoulesPerMole(QuantityValue)" />
             public MolarEnergy MegajoulesPerMole
 #if NET7_0_OR_GREATER
-                => MolarEnergy.FromMegajoulesPerMole(double.CreateChecked(value));
+                => MolarEnergy.FromMegajoulesPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarEnergy.FromMegajoulesPerMole(value.ToDouble(null));
+                => MolarEnergy.FromMegajoulesPerMole(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEntropyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
index f1e7dd57a9..16e117be2d 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
@@ -42,28 +42,28 @@ public static class NumberToMolarEntropyExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MolarEntropy.FromJoulesPerMoleKelvin(double)" />
+            /// <inheritdoc cref="MolarEntropy.FromJoulesPerMoleKelvin(QuantityValue)" />
             public MolarEntropy JoulesPerMoleKelvin
 #if NET7_0_OR_GREATER
-                => MolarEntropy.FromJoulesPerMoleKelvin(double.CreateChecked(value));
+                => MolarEntropy.FromJoulesPerMoleKelvin(QuantityValue.CreateChecked(value));
 #else
-                => MolarEntropy.FromJoulesPerMoleKelvin(value.ToDouble(null));
+                => MolarEntropy.FromJoulesPerMoleKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarEntropy.FromKilojoulesPerMoleKelvin(double)" />
+            /// <inheritdoc cref="MolarEntropy.FromKilojoulesPerMoleKelvin(QuantityValue)" />
             public MolarEntropy KilojoulesPerMoleKelvin
 #if NET7_0_OR_GREATER
-                => MolarEntropy.FromKilojoulesPerMoleKelvin(double.CreateChecked(value));
+                => MolarEntropy.FromKilojoulesPerMoleKelvin(QuantityValue.CreateChecked(value));
 #else
-                => MolarEntropy.FromKilojoulesPerMoleKelvin(value.ToDouble(null));
+                => MolarEntropy.FromKilojoulesPerMoleKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarEntropy.FromMegajoulesPerMoleKelvin(double)" />
+            /// <inheritdoc cref="MolarEntropy.FromMegajoulesPerMoleKelvin(QuantityValue)" />
             public MolarEntropy MegajoulesPerMoleKelvin
 #if NET7_0_OR_GREATER
-                => MolarEntropy.FromMegajoulesPerMoleKelvin(double.CreateChecked(value));
+                => MolarEntropy.FromMegajoulesPerMoleKelvin(QuantityValue.CreateChecked(value));
 #else
-                => MolarEntropy.FromMegajoulesPerMoleKelvin(value.ToDouble(null));
+                => MolarEntropy.FromMegajoulesPerMoleKelvin(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarFlowExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarFlowExtensions.g.cs
index c7511d2b5b..ee7c161d4b 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarFlowExtensions.g.cs
@@ -42,76 +42,76 @@ public static class NumberToMolarFlowExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MolarFlow.FromKilomolesPerHour(double)" />
+            /// <inheritdoc cref="MolarFlow.FromKilomolesPerHour(QuantityValue)" />
             public MolarFlow KilomolesPerHour
 #if NET7_0_OR_GREATER
-                => MolarFlow.FromKilomolesPerHour(double.CreateChecked(value));
+                => MolarFlow.FromKilomolesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => MolarFlow.FromKilomolesPerHour(value.ToDouble(null));
+                => MolarFlow.FromKilomolesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarFlow.FromKilomolesPerMinute(double)" />
+            /// <inheritdoc cref="MolarFlow.FromKilomolesPerMinute(QuantityValue)" />
             public MolarFlow KilomolesPerMinute
 #if NET7_0_OR_GREATER
-                => MolarFlow.FromKilomolesPerMinute(double.CreateChecked(value));
+                => MolarFlow.FromKilomolesPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => MolarFlow.FromKilomolesPerMinute(value.ToDouble(null));
+                => MolarFlow.FromKilomolesPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarFlow.FromKilomolesPerSecond(double)" />
+            /// <inheritdoc cref="MolarFlow.FromKilomolesPerSecond(QuantityValue)" />
             public MolarFlow KilomolesPerSecond
 #if NET7_0_OR_GREATER
-                => MolarFlow.FromKilomolesPerSecond(double.CreateChecked(value));
+                => MolarFlow.FromKilomolesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MolarFlow.FromKilomolesPerSecond(value.ToDouble(null));
+                => MolarFlow.FromKilomolesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarFlow.FromMolesPerHour(double)" />
+            /// <inheritdoc cref="MolarFlow.FromMolesPerHour(QuantityValue)" />
             public MolarFlow MolesPerHour
 #if NET7_0_OR_GREATER
-                => MolarFlow.FromMolesPerHour(double.CreateChecked(value));
+                => MolarFlow.FromMolesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => MolarFlow.FromMolesPerHour(value.ToDouble(null));
+                => MolarFlow.FromMolesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarFlow.FromMolesPerMinute(double)" />
+            /// <inheritdoc cref="MolarFlow.FromMolesPerMinute(QuantityValue)" />
             public MolarFlow MolesPerMinute
 #if NET7_0_OR_GREATER
-                => MolarFlow.FromMolesPerMinute(double.CreateChecked(value));
+                => MolarFlow.FromMolesPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => MolarFlow.FromMolesPerMinute(value.ToDouble(null));
+                => MolarFlow.FromMolesPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarFlow.FromMolesPerSecond(double)" />
+            /// <inheritdoc cref="MolarFlow.FromMolesPerSecond(QuantityValue)" />
             public MolarFlow MolesPerSecond
 #if NET7_0_OR_GREATER
-                => MolarFlow.FromMolesPerSecond(double.CreateChecked(value));
+                => MolarFlow.FromMolesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MolarFlow.FromMolesPerSecond(value.ToDouble(null));
+                => MolarFlow.FromMolesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarFlow.FromPoundMolesPerHour(double)" />
+            /// <inheritdoc cref="MolarFlow.FromPoundMolesPerHour(QuantityValue)" />
             public MolarFlow PoundMolesPerHour
 #if NET7_0_OR_GREATER
-                => MolarFlow.FromPoundMolesPerHour(double.CreateChecked(value));
+                => MolarFlow.FromPoundMolesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => MolarFlow.FromPoundMolesPerHour(value.ToDouble(null));
+                => MolarFlow.FromPoundMolesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarFlow.FromPoundMolesPerMinute(double)" />
+            /// <inheritdoc cref="MolarFlow.FromPoundMolesPerMinute(QuantityValue)" />
             public MolarFlow PoundMolesPerMinute
 #if NET7_0_OR_GREATER
-                => MolarFlow.FromPoundMolesPerMinute(double.CreateChecked(value));
+                => MolarFlow.FromPoundMolesPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => MolarFlow.FromPoundMolesPerMinute(value.ToDouble(null));
+                => MolarFlow.FromPoundMolesPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarFlow.FromPoundMolesPerSecond(double)" />
+            /// <inheritdoc cref="MolarFlow.FromPoundMolesPerSecond(QuantityValue)" />
             public MolarFlow PoundMolesPerSecond
 #if NET7_0_OR_GREATER
-                => MolarFlow.FromPoundMolesPerSecond(double.CreateChecked(value));
+                => MolarFlow.FromPoundMolesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => MolarFlow.FromPoundMolesPerSecond(value.ToDouble(null));
+                => MolarFlow.FromPoundMolesPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarMassExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarMassExtensions.g.cs
index d8c37c284d..203de680ce 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarMassExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarMassExtensions.g.cs
@@ -42,108 +42,116 @@ public static class NumberToMolarMassExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="MolarMass.FromCentigramsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromCentigramsPerMole(QuantityValue)" />
             public MolarMass CentigramsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromCentigramsPerMole(double.CreateChecked(value));
+                => MolarMass.FromCentigramsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromCentigramsPerMole(value.ToDouble(null));
+                => MolarMass.FromCentigramsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromDecagramsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromDecagramsPerMole(QuantityValue)" />
             public MolarMass DecagramsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromDecagramsPerMole(double.CreateChecked(value));
+                => MolarMass.FromDecagramsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromDecagramsPerMole(value.ToDouble(null));
+                => MolarMass.FromDecagramsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromDecigramsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromDecigramsPerMole(QuantityValue)" />
             public MolarMass DecigramsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromDecigramsPerMole(double.CreateChecked(value));
+                => MolarMass.FromDecigramsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromDecigramsPerMole(value.ToDouble(null));
+                => MolarMass.FromDecigramsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromGramsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromGramsPerMole(QuantityValue)" />
             public MolarMass GramsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromGramsPerMole(double.CreateChecked(value));
+                => MolarMass.FromGramsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromGramsPerMole(value.ToDouble(null));
+                => MolarMass.FromGramsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromHectogramsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromHectogramsPerMole(QuantityValue)" />
             public MolarMass HectogramsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromHectogramsPerMole(double.CreateChecked(value));
+                => MolarMass.FromHectogramsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromHectogramsPerMole(value.ToDouble(null));
+                => MolarMass.FromHectogramsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromKilogramsPerKilomole(double)" />
+            /// <inheritdoc cref="MolarMass.FromKilogramsPerKilomole(QuantityValue)" />
             public MolarMass KilogramsPerKilomole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromKilogramsPerKilomole(double.CreateChecked(value));
+                => MolarMass.FromKilogramsPerKilomole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromKilogramsPerKilomole(value.ToDouble(null));
+                => MolarMass.FromKilogramsPerKilomole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromKilogramsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromKilogramsPerMole(QuantityValue)" />
             public MolarMass KilogramsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromKilogramsPerMole(double.CreateChecked(value));
+                => MolarMass.FromKilogramsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromKilogramsPerMole(value.ToDouble(null));
+                => MolarMass.FromKilogramsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromKilopoundsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromKilopoundsPerMole(QuantityValue)" />
             public MolarMass KilopoundsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromKilopoundsPerMole(double.CreateChecked(value));
+                => MolarMass.FromKilopoundsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromKilopoundsPerMole(value.ToDouble(null));
+                => MolarMass.FromKilopoundsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromMegapoundsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromMegapoundsPerMole(QuantityValue)" />
             public MolarMass MegapoundsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromMegapoundsPerMole(double.CreateChecked(value));
+                => MolarMass.FromMegapoundsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromMegapoundsPerMole(value.ToDouble(null));
+                => MolarMass.FromMegapoundsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromMicrogramsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromMicrogramsPerMole(QuantityValue)" />
             public MolarMass MicrogramsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromMicrogramsPerMole(double.CreateChecked(value));
+                => MolarMass.FromMicrogramsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromMicrogramsPerMole(value.ToDouble(null));
+                => MolarMass.FromMicrogramsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromMilligramsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromMilligramsPerMole(QuantityValue)" />
             public MolarMass MilligramsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromMilligramsPerMole(double.CreateChecked(value));
+                => MolarMass.FromMilligramsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromMilligramsPerMole(value.ToDouble(null));
+                => MolarMass.FromMilligramsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromNanogramsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromNanogramsPerMole(QuantityValue)" />
             public MolarMass NanogramsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromNanogramsPerMole(double.CreateChecked(value));
+                => MolarMass.FromNanogramsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromNanogramsPerMole(value.ToDouble(null));
+                => MolarMass.FromNanogramsPerMole(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="MolarMass.FromPoundsPerMole(double)" />
+            /// <inheritdoc cref="MolarMass.FromPoundsPerMole(QuantityValue)" />
             public MolarMass PoundsPerMole
 #if NET7_0_OR_GREATER
-                => MolarMass.FromPoundsPerMole(double.CreateChecked(value));
+                => MolarMass.FromPoundsPerMole(QuantityValue.CreateChecked(value));
 #else
-                => MolarMass.FromPoundsPerMole(value.ToDouble(null));
+                => MolarMass.FromPoundsPerMole(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="MolarMass.FromPoundsPerPoundMole(QuantityValue)" />
+            public MolarMass PoundsPerPoundMole
+#if NET7_0_OR_GREATER
+                => MolarMass.FromPoundsPerPoundMole(QuantityValue.CreateChecked(value));
+#else
+                => MolarMass.FromPoundsPerPoundMole(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarityExtensions.g.cs
index 8f57674541..1214980588 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarityExtensions.g.cs
@@ -42,92 +42,92 @@ public static class NumberToMolarityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Molarity.FromCentimolesPerLiter(double)" />
+            /// <inheritdoc cref="Molarity.FromCentimolesPerLiter(QuantityValue)" />
             public Molarity CentimolesPerLiter
 #if NET7_0_OR_GREATER
-                => Molarity.FromCentimolesPerLiter(double.CreateChecked(value));
+                => Molarity.FromCentimolesPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromCentimolesPerLiter(value.ToDouble(null));
+                => Molarity.FromCentimolesPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molarity.FromDecimolesPerLiter(double)" />
+            /// <inheritdoc cref="Molarity.FromDecimolesPerLiter(QuantityValue)" />
             public Molarity DecimolesPerLiter
 #if NET7_0_OR_GREATER
-                => Molarity.FromDecimolesPerLiter(double.CreateChecked(value));
+                => Molarity.FromDecimolesPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromDecimolesPerLiter(value.ToDouble(null));
+                => Molarity.FromDecimolesPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molarity.FromFemtomolesPerLiter(double)" />
+            /// <inheritdoc cref="Molarity.FromFemtomolesPerLiter(QuantityValue)" />
             public Molarity FemtomolesPerLiter
 #if NET7_0_OR_GREATER
-                => Molarity.FromFemtomolesPerLiter(double.CreateChecked(value));
+                => Molarity.FromFemtomolesPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromFemtomolesPerLiter(value.ToDouble(null));
+                => Molarity.FromFemtomolesPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molarity.FromKilomolesPerCubicMeter(double)" />
+            /// <inheritdoc cref="Molarity.FromKilomolesPerCubicMeter(QuantityValue)" />
             public Molarity KilomolesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => Molarity.FromKilomolesPerCubicMeter(double.CreateChecked(value));
+                => Molarity.FromKilomolesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromKilomolesPerCubicMeter(value.ToDouble(null));
+                => Molarity.FromKilomolesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molarity.FromMicromolesPerLiter(double)" />
+            /// <inheritdoc cref="Molarity.FromMicromolesPerLiter(QuantityValue)" />
             public Molarity MicromolesPerLiter
 #if NET7_0_OR_GREATER
-                => Molarity.FromMicromolesPerLiter(double.CreateChecked(value));
+                => Molarity.FromMicromolesPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromMicromolesPerLiter(value.ToDouble(null));
+                => Molarity.FromMicromolesPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molarity.FromMillimolesPerLiter(double)" />
+            /// <inheritdoc cref="Molarity.FromMillimolesPerLiter(QuantityValue)" />
             public Molarity MillimolesPerLiter
 #if NET7_0_OR_GREATER
-                => Molarity.FromMillimolesPerLiter(double.CreateChecked(value));
+                => Molarity.FromMillimolesPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromMillimolesPerLiter(value.ToDouble(null));
+                => Molarity.FromMillimolesPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molarity.FromMolesPerCubicMeter(double)" />
+            /// <inheritdoc cref="Molarity.FromMolesPerCubicMeter(QuantityValue)" />
             public Molarity MolesPerCubicMeter
 #if NET7_0_OR_GREATER
-                => Molarity.FromMolesPerCubicMeter(double.CreateChecked(value));
+                => Molarity.FromMolesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromMolesPerCubicMeter(value.ToDouble(null));
+                => Molarity.FromMolesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molarity.FromMolesPerLiter(double)" />
+            /// <inheritdoc cref="Molarity.FromMolesPerLiter(QuantityValue)" />
             public Molarity MolesPerLiter
 #if NET7_0_OR_GREATER
-                => Molarity.FromMolesPerLiter(double.CreateChecked(value));
+                => Molarity.FromMolesPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromMolesPerLiter(value.ToDouble(null));
+                => Molarity.FromMolesPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molarity.FromNanomolesPerLiter(double)" />
+            /// <inheritdoc cref="Molarity.FromNanomolesPerLiter(QuantityValue)" />
             public Molarity NanomolesPerLiter
 #if NET7_0_OR_GREATER
-                => Molarity.FromNanomolesPerLiter(double.CreateChecked(value));
+                => Molarity.FromNanomolesPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromNanomolesPerLiter(value.ToDouble(null));
+                => Molarity.FromNanomolesPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molarity.FromPicomolesPerLiter(double)" />
+            /// <inheritdoc cref="Molarity.FromPicomolesPerLiter(QuantityValue)" />
             public Molarity PicomolesPerLiter
 #if NET7_0_OR_GREATER
-                => Molarity.FromPicomolesPerLiter(double.CreateChecked(value));
+                => Molarity.FromPicomolesPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromPicomolesPerLiter(value.ToDouble(null));
+                => Molarity.FromPicomolesPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Molarity.FromPoundMolesPerCubicFoot(double)" />
+            /// <inheritdoc cref="Molarity.FromPoundMolesPerCubicFoot(QuantityValue)" />
             public Molarity PoundMolesPerCubicFoot
 #if NET7_0_OR_GREATER
-                => Molarity.FromPoundMolesPerCubicFoot(double.CreateChecked(value));
+                => Molarity.FromPoundMolesPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => Molarity.FromPoundMolesPerCubicFoot(value.ToDouble(null));
+                => Molarity.FromPoundMolesPerCubicFoot(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermeabilityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermeabilityExtensions.g.cs
index 8acd2c2e8f..1eed70dd68 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermeabilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermeabilityExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToPermeabilityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Permeability.FromHenriesPerMeter(double)" />
+            /// <inheritdoc cref="Permeability.FromHenriesPerMeter(QuantityValue)" />
             public Permeability HenriesPerMeter
 #if NET7_0_OR_GREATER
-                => Permeability.FromHenriesPerMeter(double.CreateChecked(value));
+                => Permeability.FromHenriesPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => Permeability.FromHenriesPerMeter(value.ToDouble(null));
+                => Permeability.FromHenriesPerMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermittivityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermittivityExtensions.g.cs
index 568334d284..05f29b1422 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermittivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermittivityExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToPermittivityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Permittivity.FromFaradsPerMeter(double)" />
+            /// <inheritdoc cref="Permittivity.FromFaradsPerMeter(QuantityValue)" />
             public Permittivity FaradsPerMeter
 #if NET7_0_OR_GREATER
-                => Permittivity.FromFaradsPerMeter(double.CreateChecked(value));
+                => Permittivity.FromFaradsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => Permittivity.FromFaradsPerMeter(value.ToDouble(null));
+                => Permittivity.FromFaradsPerMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs
index 307668807d..ed1e171874 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs
@@ -42,44 +42,44 @@ public static class NumberToPorousMediumPermeabilityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="PorousMediumPermeability.FromDarcys(double)" />
+            /// <inheritdoc cref="PorousMediumPermeability.FromDarcys(QuantityValue)" />
             public PorousMediumPermeability Darcys
 #if NET7_0_OR_GREATER
-                => PorousMediumPermeability.FromDarcys(double.CreateChecked(value));
+                => PorousMediumPermeability.FromDarcys(QuantityValue.CreateChecked(value));
 #else
-                => PorousMediumPermeability.FromDarcys(value.ToDouble(null));
+                => PorousMediumPermeability.FromDarcys(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PorousMediumPermeability.FromMicrodarcys(double)" />
+            /// <inheritdoc cref="PorousMediumPermeability.FromMicrodarcys(QuantityValue)" />
             public PorousMediumPermeability Microdarcys
 #if NET7_0_OR_GREATER
-                => PorousMediumPermeability.FromMicrodarcys(double.CreateChecked(value));
+                => PorousMediumPermeability.FromMicrodarcys(QuantityValue.CreateChecked(value));
 #else
-                => PorousMediumPermeability.FromMicrodarcys(value.ToDouble(null));
+                => PorousMediumPermeability.FromMicrodarcys(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PorousMediumPermeability.FromMillidarcys(double)" />
+            /// <inheritdoc cref="PorousMediumPermeability.FromMillidarcys(QuantityValue)" />
             public PorousMediumPermeability Millidarcys
 #if NET7_0_OR_GREATER
-                => PorousMediumPermeability.FromMillidarcys(double.CreateChecked(value));
+                => PorousMediumPermeability.FromMillidarcys(QuantityValue.CreateChecked(value));
 #else
-                => PorousMediumPermeability.FromMillidarcys(value.ToDouble(null));
+                => PorousMediumPermeability.FromMillidarcys(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PorousMediumPermeability.FromSquareCentimeters(double)" />
+            /// <inheritdoc cref="PorousMediumPermeability.FromSquareCentimeters(QuantityValue)" />
             public PorousMediumPermeability SquareCentimeters
 #if NET7_0_OR_GREATER
-                => PorousMediumPermeability.FromSquareCentimeters(double.CreateChecked(value));
+                => PorousMediumPermeability.FromSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => PorousMediumPermeability.FromSquareCentimeters(value.ToDouble(null));
+                => PorousMediumPermeability.FromSquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PorousMediumPermeability.FromSquareMeters(double)" />
+            /// <inheritdoc cref="PorousMediumPermeability.FromSquareMeters(QuantityValue)" />
             public PorousMediumPermeability SquareMeters
 #if NET7_0_OR_GREATER
-                => PorousMediumPermeability.FromSquareMeters(double.CreateChecked(value));
+                => PorousMediumPermeability.FromSquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => PorousMediumPermeability.FromSquareMeters(value.ToDouble(null));
+                => PorousMediumPermeability.FromSquareMeters(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerDensityExtensions.g.cs
index 76f5cfb9a3..543334a10a 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerDensityExtensions.g.cs
@@ -42,356 +42,372 @@ public static class NumberToPowerDensityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromBtusPerSecondCubicFoot(QuantityValue)" />
+            public PowerDensity BtusPerSecondCubicFoot
+#if NET7_0_OR_GREATER
+                => PowerDensity.FromBtusPerSecondCubicFoot(QuantityValue.CreateChecked(value));
+#else
+                => PowerDensity.FromBtusPerSecondCubicFoot(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="PowerDensity.FromBtusPerSecondCubicInch(QuantityValue)" />
+            public PowerDensity BtusPerSecondCubicInch
+#if NET7_0_OR_GREATER
+                => PowerDensity.FromBtusPerSecondCubicInch(QuantityValue.CreateChecked(value));
+#else
+                => PowerDensity.FromBtusPerSecondCubicInch(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicFoot(QuantityValue)" />
             public PowerDensity DecawattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromDecawattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromDecawattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromDecawattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromDecawattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicInch(QuantityValue)" />
             public PowerDensity DecawattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromDecawattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromDecawattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromDecawattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromDecawattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicMeter(QuantityValue)" />
             public PowerDensity DecawattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromDecawattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromDecawattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromDecawattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromDecawattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromDecawattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromDecawattsPerLiter(QuantityValue)" />
             public PowerDensity DecawattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromDecawattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromDecawattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromDecawattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromDecawattsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicFoot(QuantityValue)" />
             public PowerDensity DeciwattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromDeciwattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromDeciwattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromDeciwattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromDeciwattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicInch(QuantityValue)" />
             public PowerDensity DeciwattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromDeciwattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromDeciwattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromDeciwattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromDeciwattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicMeter(QuantityValue)" />
             public PowerDensity DeciwattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromDeciwattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromDeciwattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromDeciwattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromDeciwattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromDeciwattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromDeciwattsPerLiter(QuantityValue)" />
             public PowerDensity DeciwattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromDeciwattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromDeciwattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromDeciwattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromDeciwattsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicFoot(QuantityValue)" />
             public PowerDensity GigawattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromGigawattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromGigawattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromGigawattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromGigawattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicInch(QuantityValue)" />
             public PowerDensity GigawattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromGigawattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromGigawattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromGigawattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromGigawattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicMeter(QuantityValue)" />
             public PowerDensity GigawattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromGigawattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromGigawattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromGigawattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromGigawattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromGigawattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromGigawattsPerLiter(QuantityValue)" />
             public PowerDensity GigawattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromGigawattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromGigawattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromGigawattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromGigawattsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicFoot(QuantityValue)" />
             public PowerDensity KilowattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromKilowattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromKilowattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromKilowattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromKilowattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicInch(QuantityValue)" />
             public PowerDensity KilowattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromKilowattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromKilowattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromKilowattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromKilowattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicMeter(QuantityValue)" />
             public PowerDensity KilowattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromKilowattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromKilowattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromKilowattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromKilowattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromKilowattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromKilowattsPerLiter(QuantityValue)" />
             public PowerDensity KilowattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromKilowattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromKilowattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromKilowattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromKilowattsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicFoot(QuantityValue)" />
             public PowerDensity MegawattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMegawattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromMegawattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMegawattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromMegawattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicInch(QuantityValue)" />
             public PowerDensity MegawattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMegawattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromMegawattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMegawattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromMegawattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicMeter(QuantityValue)" />
             public PowerDensity MegawattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMegawattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromMegawattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMegawattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromMegawattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMegawattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMegawattsPerLiter(QuantityValue)" />
             public PowerDensity MegawattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMegawattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromMegawattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMegawattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromMegawattsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicFoot(QuantityValue)" />
             public PowerDensity MicrowattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMicrowattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromMicrowattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMicrowattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromMicrowattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicInch(QuantityValue)" />
             public PowerDensity MicrowattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMicrowattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromMicrowattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMicrowattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromMicrowattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicMeter(QuantityValue)" />
             public PowerDensity MicrowattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMicrowattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromMicrowattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMicrowattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromMicrowattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMicrowattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMicrowattsPerLiter(QuantityValue)" />
             public PowerDensity MicrowattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMicrowattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromMicrowattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMicrowattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromMicrowattsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicFoot(QuantityValue)" />
             public PowerDensity MilliwattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMilliwattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromMilliwattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMilliwattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromMilliwattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicInch(QuantityValue)" />
             public PowerDensity MilliwattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMilliwattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromMilliwattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMilliwattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromMilliwattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicMeter(QuantityValue)" />
             public PowerDensity MilliwattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMilliwattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromMilliwattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMilliwattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromMilliwattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromMilliwattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromMilliwattsPerLiter(QuantityValue)" />
             public PowerDensity MilliwattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromMilliwattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromMilliwattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromMilliwattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromMilliwattsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicFoot(QuantityValue)" />
             public PowerDensity NanowattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromNanowattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromNanowattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromNanowattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromNanowattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicInch(QuantityValue)" />
             public PowerDensity NanowattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromNanowattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromNanowattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromNanowattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromNanowattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicMeter(QuantityValue)" />
             public PowerDensity NanowattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromNanowattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromNanowattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromNanowattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromNanowattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromNanowattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromNanowattsPerLiter(QuantityValue)" />
             public PowerDensity NanowattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromNanowattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromNanowattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromNanowattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromNanowattsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicFoot(QuantityValue)" />
             public PowerDensity PicowattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromPicowattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromPicowattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromPicowattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromPicowattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicInch(QuantityValue)" />
             public PowerDensity PicowattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromPicowattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromPicowattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromPicowattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromPicowattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicMeter(QuantityValue)" />
             public PowerDensity PicowattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromPicowattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromPicowattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromPicowattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromPicowattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromPicowattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromPicowattsPerLiter(QuantityValue)" />
             public PowerDensity PicowattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromPicowattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromPicowattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromPicowattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromPicowattsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicFoot(QuantityValue)" />
             public PowerDensity TerawattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromTerawattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromTerawattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromTerawattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromTerawattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicInch(QuantityValue)" />
             public PowerDensity TerawattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromTerawattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromTerawattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromTerawattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromTerawattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicMeter(QuantityValue)" />
             public PowerDensity TerawattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromTerawattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromTerawattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromTerawattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromTerawattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromTerawattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromTerawattsPerLiter(QuantityValue)" />
             public PowerDensity TerawattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromTerawattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromTerawattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromTerawattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromTerawattsPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromWattsPerCubicFoot(double)" />
+            /// <inheritdoc cref="PowerDensity.FromWattsPerCubicFoot(QuantityValue)" />
             public PowerDensity WattsPerCubicFoot
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromWattsPerCubicFoot(double.CreateChecked(value));
+                => PowerDensity.FromWattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromWattsPerCubicFoot(value.ToDouble(null));
+                => PowerDensity.FromWattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromWattsPerCubicInch(double)" />
+            /// <inheritdoc cref="PowerDensity.FromWattsPerCubicInch(QuantityValue)" />
             public PowerDensity WattsPerCubicInch
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromWattsPerCubicInch(double.CreateChecked(value));
+                => PowerDensity.FromWattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromWattsPerCubicInch(value.ToDouble(null));
+                => PowerDensity.FromWattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromWattsPerCubicMeter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromWattsPerCubicMeter(QuantityValue)" />
             public PowerDensity WattsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromWattsPerCubicMeter(double.CreateChecked(value));
+                => PowerDensity.FromWattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromWattsPerCubicMeter(value.ToDouble(null));
+                => PowerDensity.FromWattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerDensity.FromWattsPerLiter(double)" />
+            /// <inheritdoc cref="PowerDensity.FromWattsPerLiter(QuantityValue)" />
             public PowerDensity WattsPerLiter
 #if NET7_0_OR_GREATER
-                => PowerDensity.FromWattsPerLiter(double.CreateChecked(value));
+                => PowerDensity.FromWattsPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => PowerDensity.FromWattsPerLiter(value.ToDouble(null));
+                => PowerDensity.FromWattsPerLiter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs
index 6b0b8226b7..f98cb41f3e 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs
@@ -42,220 +42,220 @@ public static class NumberToPowerExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Power.FromBoilerHorsepower(double)" />
+            /// <inheritdoc cref="Power.FromBoilerHorsepower(QuantityValue)" />
             public Power BoilerHorsepower
 #if NET7_0_OR_GREATER
-                => Power.FromBoilerHorsepower(double.CreateChecked(value));
+                => Power.FromBoilerHorsepower(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromBoilerHorsepower(value.ToDouble(null));
+                => Power.FromBoilerHorsepower(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromBritishThermalUnitsPerHour(double)" />
+            /// <inheritdoc cref="Power.FromBritishThermalUnitsPerHour(QuantityValue)" />
             public Power BritishThermalUnitsPerHour
 #if NET7_0_OR_GREATER
-                => Power.FromBritishThermalUnitsPerHour(double.CreateChecked(value));
+                => Power.FromBritishThermalUnitsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromBritishThermalUnitsPerHour(value.ToDouble(null));
+                => Power.FromBritishThermalUnitsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromDecawatts(double)" />
+            /// <inheritdoc cref="Power.FromDecawatts(QuantityValue)" />
             public Power Decawatts
 #if NET7_0_OR_GREATER
-                => Power.FromDecawatts(double.CreateChecked(value));
+                => Power.FromDecawatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromDecawatts(value.ToDouble(null));
+                => Power.FromDecawatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromDeciwatts(double)" />
+            /// <inheritdoc cref="Power.FromDeciwatts(QuantityValue)" />
             public Power Deciwatts
 #if NET7_0_OR_GREATER
-                => Power.FromDeciwatts(double.CreateChecked(value));
+                => Power.FromDeciwatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromDeciwatts(value.ToDouble(null));
+                => Power.FromDeciwatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromElectricalHorsepower(double)" />
+            /// <inheritdoc cref="Power.FromElectricalHorsepower(QuantityValue)" />
             public Power ElectricalHorsepower
 #if NET7_0_OR_GREATER
-                => Power.FromElectricalHorsepower(double.CreateChecked(value));
+                => Power.FromElectricalHorsepower(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromElectricalHorsepower(value.ToDouble(null));
+                => Power.FromElectricalHorsepower(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromFemtowatts(double)" />
+            /// <inheritdoc cref="Power.FromFemtowatts(QuantityValue)" />
             public Power Femtowatts
 #if NET7_0_OR_GREATER
-                => Power.FromFemtowatts(double.CreateChecked(value));
+                => Power.FromFemtowatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromFemtowatts(value.ToDouble(null));
+                => Power.FromFemtowatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromGigajoulesPerHour(double)" />
+            /// <inheritdoc cref="Power.FromGigajoulesPerHour(QuantityValue)" />
             public Power GigajoulesPerHour
 #if NET7_0_OR_GREATER
-                => Power.FromGigajoulesPerHour(double.CreateChecked(value));
+                => Power.FromGigajoulesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromGigajoulesPerHour(value.ToDouble(null));
+                => Power.FromGigajoulesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromGigawatts(double)" />
+            /// <inheritdoc cref="Power.FromGigawatts(QuantityValue)" />
             public Power Gigawatts
 #if NET7_0_OR_GREATER
-                => Power.FromGigawatts(double.CreateChecked(value));
+                => Power.FromGigawatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromGigawatts(value.ToDouble(null));
+                => Power.FromGigawatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromHydraulicHorsepower(double)" />
+            /// <inheritdoc cref="Power.FromHydraulicHorsepower(QuantityValue)" />
             public Power HydraulicHorsepower
 #if NET7_0_OR_GREATER
-                => Power.FromHydraulicHorsepower(double.CreateChecked(value));
+                => Power.FromHydraulicHorsepower(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromHydraulicHorsepower(value.ToDouble(null));
+                => Power.FromHydraulicHorsepower(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromJoulesPerHour(double)" />
+            /// <inheritdoc cref="Power.FromJoulesPerHour(QuantityValue)" />
             public Power JoulesPerHour
 #if NET7_0_OR_GREATER
-                => Power.FromJoulesPerHour(double.CreateChecked(value));
+                => Power.FromJoulesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromJoulesPerHour(value.ToDouble(null));
+                => Power.FromJoulesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromKilobritishThermalUnitsPerHour(double)" />
+            /// <inheritdoc cref="Power.FromKilobritishThermalUnitsPerHour(QuantityValue)" />
             public Power KilobritishThermalUnitsPerHour
 #if NET7_0_OR_GREATER
-                => Power.FromKilobritishThermalUnitsPerHour(double.CreateChecked(value));
+                => Power.FromKilobritishThermalUnitsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromKilobritishThermalUnitsPerHour(value.ToDouble(null));
+                => Power.FromKilobritishThermalUnitsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromKilojoulesPerHour(double)" />
+            /// <inheritdoc cref="Power.FromKilojoulesPerHour(QuantityValue)" />
             public Power KilojoulesPerHour
 #if NET7_0_OR_GREATER
-                => Power.FromKilojoulesPerHour(double.CreateChecked(value));
+                => Power.FromKilojoulesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromKilojoulesPerHour(value.ToDouble(null));
+                => Power.FromKilojoulesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromKilowatts(double)" />
+            /// <inheritdoc cref="Power.FromKilowatts(QuantityValue)" />
             public Power Kilowatts
 #if NET7_0_OR_GREATER
-                => Power.FromKilowatts(double.CreateChecked(value));
+                => Power.FromKilowatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromKilowatts(value.ToDouble(null));
+                => Power.FromKilowatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromMechanicalHorsepower(double)" />
+            /// <inheritdoc cref="Power.FromMechanicalHorsepower(QuantityValue)" />
             public Power MechanicalHorsepower
 #if NET7_0_OR_GREATER
-                => Power.FromMechanicalHorsepower(double.CreateChecked(value));
+                => Power.FromMechanicalHorsepower(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromMechanicalHorsepower(value.ToDouble(null));
+                => Power.FromMechanicalHorsepower(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromMegabritishThermalUnitsPerHour(double)" />
+            /// <inheritdoc cref="Power.FromMegabritishThermalUnitsPerHour(QuantityValue)" />
             public Power MegabritishThermalUnitsPerHour
 #if NET7_0_OR_GREATER
-                => Power.FromMegabritishThermalUnitsPerHour(double.CreateChecked(value));
+                => Power.FromMegabritishThermalUnitsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromMegabritishThermalUnitsPerHour(value.ToDouble(null));
+                => Power.FromMegabritishThermalUnitsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromMegajoulesPerHour(double)" />
+            /// <inheritdoc cref="Power.FromMegajoulesPerHour(QuantityValue)" />
             public Power MegajoulesPerHour
 #if NET7_0_OR_GREATER
-                => Power.FromMegajoulesPerHour(double.CreateChecked(value));
+                => Power.FromMegajoulesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromMegajoulesPerHour(value.ToDouble(null));
+                => Power.FromMegajoulesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromMegawatts(double)" />
+            /// <inheritdoc cref="Power.FromMegawatts(QuantityValue)" />
             public Power Megawatts
 #if NET7_0_OR_GREATER
-                => Power.FromMegawatts(double.CreateChecked(value));
+                => Power.FromMegawatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromMegawatts(value.ToDouble(null));
+                => Power.FromMegawatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromMetricHorsepower(double)" />
+            /// <inheritdoc cref="Power.FromMetricHorsepower(QuantityValue)" />
             public Power MetricHorsepower
 #if NET7_0_OR_GREATER
-                => Power.FromMetricHorsepower(double.CreateChecked(value));
+                => Power.FromMetricHorsepower(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromMetricHorsepower(value.ToDouble(null));
+                => Power.FromMetricHorsepower(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromMicrowatts(double)" />
+            /// <inheritdoc cref="Power.FromMicrowatts(QuantityValue)" />
             public Power Microwatts
 #if NET7_0_OR_GREATER
-                => Power.FromMicrowatts(double.CreateChecked(value));
+                => Power.FromMicrowatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromMicrowatts(value.ToDouble(null));
+                => Power.FromMicrowatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromMillijoulesPerHour(double)" />
+            /// <inheritdoc cref="Power.FromMillijoulesPerHour(QuantityValue)" />
             public Power MillijoulesPerHour
 #if NET7_0_OR_GREATER
-                => Power.FromMillijoulesPerHour(double.CreateChecked(value));
+                => Power.FromMillijoulesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromMillijoulesPerHour(value.ToDouble(null));
+                => Power.FromMillijoulesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromMilliwatts(double)" />
+            /// <inheritdoc cref="Power.FromMilliwatts(QuantityValue)" />
             public Power Milliwatts
 #if NET7_0_OR_GREATER
-                => Power.FromMilliwatts(double.CreateChecked(value));
+                => Power.FromMilliwatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromMilliwatts(value.ToDouble(null));
+                => Power.FromMilliwatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromNanowatts(double)" />
+            /// <inheritdoc cref="Power.FromNanowatts(QuantityValue)" />
             public Power Nanowatts
 #if NET7_0_OR_GREATER
-                => Power.FromNanowatts(double.CreateChecked(value));
+                => Power.FromNanowatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromNanowatts(value.ToDouble(null));
+                => Power.FromNanowatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromPetawatts(double)" />
+            /// <inheritdoc cref="Power.FromPetawatts(QuantityValue)" />
             public Power Petawatts
 #if NET7_0_OR_GREATER
-                => Power.FromPetawatts(double.CreateChecked(value));
+                => Power.FromPetawatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromPetawatts(value.ToDouble(null));
+                => Power.FromPetawatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromPicowatts(double)" />
+            /// <inheritdoc cref="Power.FromPicowatts(QuantityValue)" />
             public Power Picowatts
 #if NET7_0_OR_GREATER
-                => Power.FromPicowatts(double.CreateChecked(value));
+                => Power.FromPicowatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromPicowatts(value.ToDouble(null));
+                => Power.FromPicowatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromTerawatts(double)" />
+            /// <inheritdoc cref="Power.FromTerawatts(QuantityValue)" />
             public Power Terawatts
 #if NET7_0_OR_GREATER
-                => Power.FromTerawatts(double.CreateChecked(value));
+                => Power.FromTerawatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromTerawatts(value.ToDouble(null));
+                => Power.FromTerawatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromTonsOfRefrigeration(double)" />
+            /// <inheritdoc cref="Power.FromTonsOfRefrigeration(QuantityValue)" />
             public Power TonsOfRefrigeration
 #if NET7_0_OR_GREATER
-                => Power.FromTonsOfRefrigeration(double.CreateChecked(value));
+                => Power.FromTonsOfRefrigeration(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromTonsOfRefrigeration(value.ToDouble(null));
+                => Power.FromTonsOfRefrigeration(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Power.FromWatts(double)" />
+            /// <inheritdoc cref="Power.FromWatts(QuantityValue)" />
             public Power Watts
 #if NET7_0_OR_GREATER
-                => Power.FromWatts(double.CreateChecked(value));
+                => Power.FromWatts(QuantityValue.CreateChecked(value));
 #else
-                => Power.FromWatts(value.ToDouble(null));
+                => Power.FromWatts(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerRatioExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerRatioExtensions.g.cs
index 9f64c8e0ff..c22f9f2fef 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerRatioExtensions.g.cs
@@ -42,20 +42,20 @@ public static class NumberToPowerRatioExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="PowerRatio.FromDecibelMilliwatts(double)" />
+            /// <inheritdoc cref="PowerRatio.FromDecibelMilliwatts(QuantityValue)" />
             public PowerRatio DecibelMilliwatts
 #if NET7_0_OR_GREATER
-                => PowerRatio.FromDecibelMilliwatts(double.CreateChecked(value));
+                => PowerRatio.FromDecibelMilliwatts(QuantityValue.CreateChecked(value));
 #else
-                => PowerRatio.FromDecibelMilliwatts(value.ToDouble(null));
+                => PowerRatio.FromDecibelMilliwatts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PowerRatio.FromDecibelWatts(double)" />
+            /// <inheritdoc cref="PowerRatio.FromDecibelWatts(QuantityValue)" />
             public PowerRatio DecibelWatts
 #if NET7_0_OR_GREATER
-                => PowerRatio.FromDecibelWatts(double.CreateChecked(value));
+                => PowerRatio.FromDecibelWatts(QuantityValue.CreateChecked(value));
 #else
-                => PowerRatio.FromDecibelWatts(value.ToDouble(null));
+                => PowerRatio.FromDecibelWatts(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
index bd8155d7d4..f972b33f3a 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
@@ -42,148 +42,148 @@ public static class NumberToPressureChangeRateExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="PressureChangeRate.FromAtmospheresPerSecond(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromAtmospheresPerSecond(QuantityValue)" />
             public PressureChangeRate AtmospheresPerSecond
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromAtmospheresPerSecond(double.CreateChecked(value));
+                => PressureChangeRate.FromAtmospheresPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromAtmospheresPerSecond(value.ToDouble(null));
+                => PressureChangeRate.FromAtmospheresPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromBarsPerMinute(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromBarsPerMinute(QuantityValue)" />
             public PressureChangeRate BarsPerMinute
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromBarsPerMinute(double.CreateChecked(value));
+                => PressureChangeRate.FromBarsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromBarsPerMinute(value.ToDouble(null));
+                => PressureChangeRate.FromBarsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromBarsPerSecond(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromBarsPerSecond(QuantityValue)" />
             public PressureChangeRate BarsPerSecond
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromBarsPerSecond(double.CreateChecked(value));
+                => PressureChangeRate.FromBarsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromBarsPerSecond(value.ToDouble(null));
+                => PressureChangeRate.FromBarsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerMinute(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerMinute(QuantityValue)" />
             public PressureChangeRate KilopascalsPerMinute
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromKilopascalsPerMinute(double.CreateChecked(value));
+                => PressureChangeRate.FromKilopascalsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromKilopascalsPerMinute(value.ToDouble(null));
+                => PressureChangeRate.FromKilopascalsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerSecond(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerSecond(QuantityValue)" />
             public PressureChangeRate KilopascalsPerSecond
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromKilopascalsPerSecond(double.CreateChecked(value));
+                => PressureChangeRate.FromKilopascalsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromKilopascalsPerSecond(value.ToDouble(null));
+                => PressureChangeRate.FromKilopascalsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(QuantityValue)" />
             public PressureChangeRate KilopoundsForcePerSquareInchPerMinute
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(double.CreateChecked(value));
+                => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(value.ToDouble(null));
+                => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(QuantityValue)" />
             public PressureChangeRate KilopoundsForcePerSquareInchPerSecond
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(double.CreateChecked(value));
+                => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(value.ToDouble(null));
+                => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerMinute(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerMinute(QuantityValue)" />
             public PressureChangeRate MegapascalsPerMinute
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromMegapascalsPerMinute(double.CreateChecked(value));
+                => PressureChangeRate.FromMegapascalsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromMegapascalsPerMinute(value.ToDouble(null));
+                => PressureChangeRate.FromMegapascalsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerSecond(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerSecond(QuantityValue)" />
             public PressureChangeRate MegapascalsPerSecond
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromMegapascalsPerSecond(double.CreateChecked(value));
+                => PressureChangeRate.FromMegapascalsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromMegapascalsPerSecond(value.ToDouble(null));
+                => PressureChangeRate.FromMegapascalsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(QuantityValue)" />
             public PressureChangeRate MegapoundsForcePerSquareInchPerMinute
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(double.CreateChecked(value));
+                => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(value.ToDouble(null));
+                => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(QuantityValue)" />
             public PressureChangeRate MegapoundsForcePerSquareInchPerSecond
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(double.CreateChecked(value));
+                => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(value.ToDouble(null));
+                => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerMinute(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerMinute(QuantityValue)" />
             public PressureChangeRate MillibarsPerMinute
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromMillibarsPerMinute(double.CreateChecked(value));
+                => PressureChangeRate.FromMillibarsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromMillibarsPerMinute(value.ToDouble(null));
+                => PressureChangeRate.FromMillibarsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerSecond(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerSecond(QuantityValue)" />
             public PressureChangeRate MillibarsPerSecond
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromMillibarsPerSecond(double.CreateChecked(value));
+                => PressureChangeRate.FromMillibarsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromMillibarsPerSecond(value.ToDouble(null));
+                => PressureChangeRate.FromMillibarsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromMillimetersOfMercuryPerSecond(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromMillimetersOfMercuryPerSecond(QuantityValue)" />
             public PressureChangeRate MillimetersOfMercuryPerSecond
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromMillimetersOfMercuryPerSecond(double.CreateChecked(value));
+                => PressureChangeRate.FromMillimetersOfMercuryPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromMillimetersOfMercuryPerSecond(value.ToDouble(null));
+                => PressureChangeRate.FromMillimetersOfMercuryPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromPascalsPerMinute(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromPascalsPerMinute(QuantityValue)" />
             public PressureChangeRate PascalsPerMinute
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromPascalsPerMinute(double.CreateChecked(value));
+                => PressureChangeRate.FromPascalsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromPascalsPerMinute(value.ToDouble(null));
+                => PressureChangeRate.FromPascalsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromPascalsPerSecond(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromPascalsPerSecond(QuantityValue)" />
             public PressureChangeRate PascalsPerSecond
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromPascalsPerSecond(double.CreateChecked(value));
+                => PressureChangeRate.FromPascalsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromPascalsPerSecond(value.ToDouble(null));
+                => PressureChangeRate.FromPascalsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(QuantityValue)" />
             public PressureChangeRate PoundsForcePerSquareInchPerMinute
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(double.CreateChecked(value));
+                => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(value.ToDouble(null));
+                => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(double)" />
+            /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(QuantityValue)" />
             public PressureChangeRate PoundsForcePerSquareInchPerSecond
 #if NET7_0_OR_GREATER
-                => PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(double.CreateChecked(value));
+                => PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(value.ToDouble(null));
+                => PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs
index 538f5530f5..437767aa52 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs
@@ -42,388 +42,404 @@ public static class NumberToPressureExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Pressure.FromAtmospheres(double)" />
+            /// <inheritdoc cref="Pressure.FromAtmospheres(QuantityValue)" />
             public Pressure Atmospheres
 #if NET7_0_OR_GREATER
-                => Pressure.FromAtmospheres(double.CreateChecked(value));
+                => Pressure.FromAtmospheres(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromAtmospheres(value.ToDouble(null));
+                => Pressure.FromAtmospheres(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromBars(double)" />
+            /// <inheritdoc cref="Pressure.FromBars(QuantityValue)" />
             public Pressure Bars
 #if NET7_0_OR_GREATER
-                => Pressure.FromBars(double.CreateChecked(value));
+                => Pressure.FromBars(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromBars(value.ToDouble(null));
+                => Pressure.FromBars(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromCentibars(double)" />
+            /// <inheritdoc cref="Pressure.FromCentibars(QuantityValue)" />
             public Pressure Centibars
 #if NET7_0_OR_GREATER
-                => Pressure.FromCentibars(double.CreateChecked(value));
+                => Pressure.FromCentibars(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromCentibars(value.ToDouble(null));
+                => Pressure.FromCentibars(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromCentimetersOfWaterColumn(double)" />
+            /// <inheritdoc cref="Pressure.FromCentimetersOfWaterColumn(QuantityValue)" />
             public Pressure CentimetersOfWaterColumn
 #if NET7_0_OR_GREATER
-                => Pressure.FromCentimetersOfWaterColumn(double.CreateChecked(value));
+                => Pressure.FromCentimetersOfWaterColumn(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromCentimetersOfWaterColumn(value.ToDouble(null));
+                => Pressure.FromCentimetersOfWaterColumn(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromDecapascals(double)" />
+            /// <inheritdoc cref="Pressure.FromDecapascals(QuantityValue)" />
             public Pressure Decapascals
 #if NET7_0_OR_GREATER
-                => Pressure.FromDecapascals(double.CreateChecked(value));
+                => Pressure.FromDecapascals(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromDecapascals(value.ToDouble(null));
+                => Pressure.FromDecapascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromDecibars(double)" />
+            /// <inheritdoc cref="Pressure.FromDecibars(QuantityValue)" />
             public Pressure Decibars
 #if NET7_0_OR_GREATER
-                => Pressure.FromDecibars(double.CreateChecked(value));
+                => Pressure.FromDecibars(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromDecibars(value.ToDouble(null));
+                => Pressure.FromDecibars(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromDynesPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Pressure.FromDynesPerSquareCentimeter(QuantityValue)" />
             public Pressure DynesPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromDynesPerSquareCentimeter(double.CreateChecked(value));
+                => Pressure.FromDynesPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromDynesPerSquareCentimeter(value.ToDouble(null));
+                => Pressure.FromDynesPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromFeetOfHead(double)" />
+            /// <inheritdoc cref="Pressure.FromFeetOfHead(QuantityValue)" />
             public Pressure FeetOfHead
 #if NET7_0_OR_GREATER
-                => Pressure.FromFeetOfHead(double.CreateChecked(value));
+                => Pressure.FromFeetOfHead(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromFeetOfHead(value.ToDouble(null));
+                => Pressure.FromFeetOfHead(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromGigapascals(double)" />
+            /// <inheritdoc cref="Pressure.FromGigapascals(QuantityValue)" />
             public Pressure Gigapascals
 #if NET7_0_OR_GREATER
-                => Pressure.FromGigapascals(double.CreateChecked(value));
+                => Pressure.FromGigapascals(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromGigapascals(value.ToDouble(null));
+                => Pressure.FromGigapascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromHectopascals(double)" />
+            /// <inheritdoc cref="Pressure.FromHectopascals(QuantityValue)" />
             public Pressure Hectopascals
 #if NET7_0_OR_GREATER
-                => Pressure.FromHectopascals(double.CreateChecked(value));
+                => Pressure.FromHectopascals(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromHectopascals(value.ToDouble(null));
+                => Pressure.FromHectopascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromInchesOfMercury(double)" />
+            /// <inheritdoc cref="Pressure.FromInchesOfMercury(QuantityValue)" />
             public Pressure InchesOfMercury
 #if NET7_0_OR_GREATER
-                => Pressure.FromInchesOfMercury(double.CreateChecked(value));
+                => Pressure.FromInchesOfMercury(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromInchesOfMercury(value.ToDouble(null));
+                => Pressure.FromInchesOfMercury(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromInchesOfWaterColumn(double)" />
+            /// <inheritdoc cref="Pressure.FromInchesOfWaterColumn(QuantityValue)" />
             public Pressure InchesOfWaterColumn
 #if NET7_0_OR_GREATER
-                => Pressure.FromInchesOfWaterColumn(double.CreateChecked(value));
+                => Pressure.FromInchesOfWaterColumn(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromInchesOfWaterColumn(value.ToDouble(null));
+                => Pressure.FromInchesOfWaterColumn(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilobars(double)" />
+            /// <inheritdoc cref="Pressure.FromKilobars(QuantityValue)" />
             public Pressure Kilobars
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilobars(double.CreateChecked(value));
+                => Pressure.FromKilobars(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilobars(value.ToDouble(null));
+                => Pressure.FromKilobars(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareCentimeter(QuantityValue)" />
             public Pressure KilogramsForcePerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilogramsForcePerSquareCentimeter(double.CreateChecked(value));
+                => Pressure.FromKilogramsForcePerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilogramsForcePerSquareCentimeter(value.ToDouble(null));
+                => Pressure.FromKilogramsForcePerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMeter(double)" />
+            /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMeter(QuantityValue)" />
             public Pressure KilogramsForcePerSquareMeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilogramsForcePerSquareMeter(double.CreateChecked(value));
+                => Pressure.FromKilogramsForcePerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilogramsForcePerSquareMeter(value.ToDouble(null));
+                => Pressure.FromKilogramsForcePerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMillimeter(double)" />
+            /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMillimeter(QuantityValue)" />
             public Pressure KilogramsForcePerSquareMillimeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilogramsForcePerSquareMillimeter(double.CreateChecked(value));
+                => Pressure.FromKilogramsForcePerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilogramsForcePerSquareMillimeter(value.ToDouble(null));
+                => Pressure.FromKilogramsForcePerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareCentimeter(QuantityValue)" />
             public Pressure KilonewtonsPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilonewtonsPerSquareCentimeter(double.CreateChecked(value));
+                => Pressure.FromKilonewtonsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilonewtonsPerSquareCentimeter(value.ToDouble(null));
+                => Pressure.FromKilonewtonsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMeter(double)" />
+            /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMeter(QuantityValue)" />
             public Pressure KilonewtonsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilonewtonsPerSquareMeter(double.CreateChecked(value));
+                => Pressure.FromKilonewtonsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilonewtonsPerSquareMeter(value.ToDouble(null));
+                => Pressure.FromKilonewtonsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMillimeter(double)" />
+            /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMillimeter(QuantityValue)" />
             public Pressure KilonewtonsPerSquareMillimeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilonewtonsPerSquareMillimeter(double.CreateChecked(value));
+                => Pressure.FromKilonewtonsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilonewtonsPerSquareMillimeter(value.ToDouble(null));
+                => Pressure.FromKilonewtonsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilopascals(double)" />
+            /// <inheritdoc cref="Pressure.FromKilopascals(QuantityValue)" />
             public Pressure Kilopascals
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilopascals(double.CreateChecked(value));
+                => Pressure.FromKilopascals(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilopascals(value.ToDouble(null));
+                => Pressure.FromKilopascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareFoot(double)" />
+            /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareFoot(QuantityValue)" />
             public Pressure KilopoundsForcePerSquareFoot
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilopoundsForcePerSquareFoot(double.CreateChecked(value));
+                => Pressure.FromKilopoundsForcePerSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilopoundsForcePerSquareFoot(value.ToDouble(null));
+                => Pressure.FromKilopoundsForcePerSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareInch(double)" />
+            /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareInch(QuantityValue)" />
             public Pressure KilopoundsForcePerSquareInch
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilopoundsForcePerSquareInch(double.CreateChecked(value));
+                => Pressure.FromKilopoundsForcePerSquareInch(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilopoundsForcePerSquareInch(value.ToDouble(null));
+                => Pressure.FromKilopoundsForcePerSquareInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareMil(double)" />
+            /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareMil(QuantityValue)" />
             public Pressure KilopoundsForcePerSquareMil
 #if NET7_0_OR_GREATER
-                => Pressure.FromKilopoundsForcePerSquareMil(double.CreateChecked(value));
+                => Pressure.FromKilopoundsForcePerSquareMil(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromKilopoundsForcePerSquareMil(value.ToDouble(null));
+                => Pressure.FromKilopoundsForcePerSquareMil(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMegabars(double)" />
+            /// <inheritdoc cref="Pressure.FromMegabars(QuantityValue)" />
             public Pressure Megabars
 #if NET7_0_OR_GREATER
-                => Pressure.FromMegabars(double.CreateChecked(value));
+                => Pressure.FromMegabars(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMegabars(value.ToDouble(null));
+                => Pressure.FromMegabars(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMeganewtonsPerSquareMeter(double)" />
+            /// <inheritdoc cref="Pressure.FromMeganewtonsPerSquareMeter(QuantityValue)" />
             public Pressure MeganewtonsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromMeganewtonsPerSquareMeter(double.CreateChecked(value));
+                => Pressure.FromMeganewtonsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMeganewtonsPerSquareMeter(value.ToDouble(null));
+                => Pressure.FromMeganewtonsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMegapascals(double)" />
+            /// <inheritdoc cref="Pressure.FromMegapascals(QuantityValue)" />
             public Pressure Megapascals
 #if NET7_0_OR_GREATER
-                => Pressure.FromMegapascals(double.CreateChecked(value));
+                => Pressure.FromMegapascals(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMegapascals(value.ToDouble(null));
+                => Pressure.FromMegapascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMetersOfHead(double)" />
+            /// <inheritdoc cref="Pressure.FromMetersOfHead(QuantityValue)" />
             public Pressure MetersOfHead
 #if NET7_0_OR_GREATER
-                => Pressure.FromMetersOfHead(double.CreateChecked(value));
+                => Pressure.FromMetersOfHead(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMetersOfHead(value.ToDouble(null));
+                => Pressure.FromMetersOfHead(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMetersOfWaterColumn(double)" />
+            /// <inheritdoc cref="Pressure.FromMetersOfWaterColumn(QuantityValue)" />
             public Pressure MetersOfWaterColumn
 #if NET7_0_OR_GREATER
-                => Pressure.FromMetersOfWaterColumn(double.CreateChecked(value));
+                => Pressure.FromMetersOfWaterColumn(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMetersOfWaterColumn(value.ToDouble(null));
+                => Pressure.FromMetersOfWaterColumn(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMicrobars(double)" />
+            /// <inheritdoc cref="Pressure.FromMicrobars(QuantityValue)" />
             public Pressure Microbars
 #if NET7_0_OR_GREATER
-                => Pressure.FromMicrobars(double.CreateChecked(value));
+                => Pressure.FromMicrobars(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMicrobars(value.ToDouble(null));
+                => Pressure.FromMicrobars(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMicropascals(double)" />
+            /// <inheritdoc cref="Pressure.FromMicropascals(QuantityValue)" />
             public Pressure Micropascals
 #if NET7_0_OR_GREATER
-                => Pressure.FromMicropascals(double.CreateChecked(value));
+                => Pressure.FromMicropascals(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMicropascals(value.ToDouble(null));
+                => Pressure.FromMicropascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMillibars(double)" />
+            /// <inheritdoc cref="Pressure.FromMillibars(QuantityValue)" />
             public Pressure Millibars
 #if NET7_0_OR_GREATER
-                => Pressure.FromMillibars(double.CreateChecked(value));
+                => Pressure.FromMillibars(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMillibars(value.ToDouble(null));
+                => Pressure.FromMillibars(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMillimetersOfMercury(double)" />
+            /// <inheritdoc cref="Pressure.FromMilligramsForcePerSquareFoot(QuantityValue)" />
+            public Pressure MilligramsForcePerSquareFoot
+#if NET7_0_OR_GREATER
+                => Pressure.FromMilligramsForcePerSquareFoot(QuantityValue.CreateChecked(value));
+#else
+                => Pressure.FromMilligramsForcePerSquareFoot(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="Pressure.FromMilligramsForcePerSquareMeter(QuantityValue)" />
+            public Pressure MilligramsForcePerSquareMeter
+#if NET7_0_OR_GREATER
+                => Pressure.FromMilligramsForcePerSquareMeter(QuantityValue.CreateChecked(value));
+#else
+                => Pressure.FromMilligramsForcePerSquareMeter(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="Pressure.FromMillimetersOfMercury(QuantityValue)" />
             public Pressure MillimetersOfMercury
 #if NET7_0_OR_GREATER
-                => Pressure.FromMillimetersOfMercury(double.CreateChecked(value));
+                => Pressure.FromMillimetersOfMercury(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMillimetersOfMercury(value.ToDouble(null));
+                => Pressure.FromMillimetersOfMercury(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMillimetersOfWaterColumn(double)" />
+            /// <inheritdoc cref="Pressure.FromMillimetersOfWaterColumn(QuantityValue)" />
             public Pressure MillimetersOfWaterColumn
 #if NET7_0_OR_GREATER
-                => Pressure.FromMillimetersOfWaterColumn(double.CreateChecked(value));
+                => Pressure.FromMillimetersOfWaterColumn(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMillimetersOfWaterColumn(value.ToDouble(null));
+                => Pressure.FromMillimetersOfWaterColumn(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMillipascals(double)" />
+            /// <inheritdoc cref="Pressure.FromMillipascals(QuantityValue)" />
             public Pressure Millipascals
 #if NET7_0_OR_GREATER
-                => Pressure.FromMillipascals(double.CreateChecked(value));
+                => Pressure.FromMillipascals(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMillipascals(value.ToDouble(null));
+                => Pressure.FromMillipascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromMillitorrs(double)" />
+            /// <inheritdoc cref="Pressure.FromMillitorrs(QuantityValue)" />
             public Pressure Millitorrs
 #if NET7_0_OR_GREATER
-                => Pressure.FromMillitorrs(double.CreateChecked(value));
+                => Pressure.FromMillitorrs(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromMillitorrs(value.ToDouble(null));
+                => Pressure.FromMillitorrs(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromNewtonsPerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Pressure.FromNewtonsPerSquareCentimeter(QuantityValue)" />
             public Pressure NewtonsPerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromNewtonsPerSquareCentimeter(double.CreateChecked(value));
+                => Pressure.FromNewtonsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromNewtonsPerSquareCentimeter(value.ToDouble(null));
+                => Pressure.FromNewtonsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMeter(double)" />
+            /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMeter(QuantityValue)" />
             public Pressure NewtonsPerSquareMeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromNewtonsPerSquareMeter(double.CreateChecked(value));
+                => Pressure.FromNewtonsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromNewtonsPerSquareMeter(value.ToDouble(null));
+                => Pressure.FromNewtonsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMillimeter(double)" />
+            /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMillimeter(QuantityValue)" />
             public Pressure NewtonsPerSquareMillimeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromNewtonsPerSquareMillimeter(double.CreateChecked(value));
+                => Pressure.FromNewtonsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromNewtonsPerSquareMillimeter(value.ToDouble(null));
+                => Pressure.FromNewtonsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromPascals(double)" />
+            /// <inheritdoc cref="Pressure.FromPascals(QuantityValue)" />
             public Pressure Pascals
 #if NET7_0_OR_GREATER
-                => Pressure.FromPascals(double.CreateChecked(value));
+                => Pressure.FromPascals(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromPascals(value.ToDouble(null));
+                => Pressure.FromPascals(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareFoot(double)" />
+            /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareFoot(QuantityValue)" />
             public Pressure PoundsForcePerSquareFoot
 #if NET7_0_OR_GREATER
-                => Pressure.FromPoundsForcePerSquareFoot(double.CreateChecked(value));
+                => Pressure.FromPoundsForcePerSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromPoundsForcePerSquareFoot(value.ToDouble(null));
+                => Pressure.FromPoundsForcePerSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareInch(double)" />
+            /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareInch(QuantityValue)" />
             public Pressure PoundsForcePerSquareInch
 #if NET7_0_OR_GREATER
-                => Pressure.FromPoundsForcePerSquareInch(double.CreateChecked(value));
+                => Pressure.FromPoundsForcePerSquareInch(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromPoundsForcePerSquareInch(value.ToDouble(null));
+                => Pressure.FromPoundsForcePerSquareInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareMil(double)" />
+            /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareMil(QuantityValue)" />
             public Pressure PoundsForcePerSquareMil
 #if NET7_0_OR_GREATER
-                => Pressure.FromPoundsForcePerSquareMil(double.CreateChecked(value));
+                => Pressure.FromPoundsForcePerSquareMil(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromPoundsForcePerSquareMil(value.ToDouble(null));
+                => Pressure.FromPoundsForcePerSquareMil(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromPoundsPerInchSecondSquared(double)" />
+            /// <inheritdoc cref="Pressure.FromPoundsPerInchSecondSquared(QuantityValue)" />
             public Pressure PoundsPerInchSecondSquared
 #if NET7_0_OR_GREATER
-                => Pressure.FromPoundsPerInchSecondSquared(double.CreateChecked(value));
+                => Pressure.FromPoundsPerInchSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromPoundsPerInchSecondSquared(value.ToDouble(null));
+                => Pressure.FromPoundsPerInchSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromTechnicalAtmospheres(double)" />
+            /// <inheritdoc cref="Pressure.FromTechnicalAtmospheres(QuantityValue)" />
             public Pressure TechnicalAtmospheres
 #if NET7_0_OR_GREATER
-                => Pressure.FromTechnicalAtmospheres(double.CreateChecked(value));
+                => Pressure.FromTechnicalAtmospheres(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromTechnicalAtmospheres(value.ToDouble(null));
+                => Pressure.FromTechnicalAtmospheres(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareCentimeter(double)" />
+            /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareCentimeter(QuantityValue)" />
             public Pressure TonnesForcePerSquareCentimeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromTonnesForcePerSquareCentimeter(double.CreateChecked(value));
+                => Pressure.FromTonnesForcePerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromTonnesForcePerSquareCentimeter(value.ToDouble(null));
+                => Pressure.FromTonnesForcePerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMeter(double)" />
+            /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMeter(QuantityValue)" />
             public Pressure TonnesForcePerSquareMeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromTonnesForcePerSquareMeter(double.CreateChecked(value));
+                => Pressure.FromTonnesForcePerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromTonnesForcePerSquareMeter(value.ToDouble(null));
+                => Pressure.FromTonnesForcePerSquareMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMillimeter(double)" />
+            /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMillimeter(QuantityValue)" />
             public Pressure TonnesForcePerSquareMillimeter
 #if NET7_0_OR_GREATER
-                => Pressure.FromTonnesForcePerSquareMillimeter(double.CreateChecked(value));
+                => Pressure.FromTonnesForcePerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromTonnesForcePerSquareMillimeter(value.ToDouble(null));
+                => Pressure.FromTonnesForcePerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Pressure.FromTorrs(double)" />
+            /// <inheritdoc cref="Pressure.FromTorrs(QuantityValue)" />
             public Pressure Torrs
 #if NET7_0_OR_GREATER
-                => Pressure.FromTorrs(double.CreateChecked(value));
+                => Pressure.FromTorrs(QuantityValue.CreateChecked(value));
 #else
-                => Pressure.FromTorrs(value.ToDouble(null));
+                => Pressure.FromTorrs(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs
index dd6408e8ed..0d508ae9be 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs
@@ -42,52 +42,52 @@ public static class NumberToRadiationEquivalentDoseExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="RadiationEquivalentDose.FromMicrosieverts(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDose.FromMicrosieverts(QuantityValue)" />
             public RadiationEquivalentDose Microsieverts
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDose.FromMicrosieverts(double.CreateChecked(value));
+                => RadiationEquivalentDose.FromMicrosieverts(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDose.FromMicrosieverts(value.ToDouble(null));
+                => RadiationEquivalentDose.FromMicrosieverts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDose.FromMilliroentgensEquivalentMan(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDose.FromMilliroentgensEquivalentMan(QuantityValue)" />
             public RadiationEquivalentDose MilliroentgensEquivalentMan
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDose.FromMilliroentgensEquivalentMan(double.CreateChecked(value));
+                => RadiationEquivalentDose.FromMilliroentgensEquivalentMan(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDose.FromMilliroentgensEquivalentMan(value.ToDouble(null));
+                => RadiationEquivalentDose.FromMilliroentgensEquivalentMan(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDose.FromMillisieverts(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDose.FromMillisieverts(QuantityValue)" />
             public RadiationEquivalentDose Millisieverts
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDose.FromMillisieverts(double.CreateChecked(value));
+                => RadiationEquivalentDose.FromMillisieverts(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDose.FromMillisieverts(value.ToDouble(null));
+                => RadiationEquivalentDose.FromMillisieverts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDose.FromNanosieverts(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDose.FromNanosieverts(QuantityValue)" />
             public RadiationEquivalentDose Nanosieverts
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDose.FromNanosieverts(double.CreateChecked(value));
+                => RadiationEquivalentDose.FromNanosieverts(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDose.FromNanosieverts(value.ToDouble(null));
+                => RadiationEquivalentDose.FromNanosieverts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDose.FromRoentgensEquivalentMan(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDose.FromRoentgensEquivalentMan(QuantityValue)" />
             public RadiationEquivalentDose RoentgensEquivalentMan
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDose.FromRoentgensEquivalentMan(double.CreateChecked(value));
+                => RadiationEquivalentDose.FromRoentgensEquivalentMan(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDose.FromRoentgensEquivalentMan(value.ToDouble(null));
+                => RadiationEquivalentDose.FromRoentgensEquivalentMan(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDose.FromSieverts(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDose.FromSieverts(QuantityValue)" />
             public RadiationEquivalentDose Sieverts
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDose.FromSieverts(double.CreateChecked(value));
+                => RadiationEquivalentDose.FromSieverts(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDose.FromSieverts(value.ToDouble(null));
+                => RadiationEquivalentDose.FromSieverts(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs
index e37019c0aa..75acfc25e6 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs
@@ -42,84 +42,84 @@ public static class NumberToRadiationEquivalentDoseRateExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMicrosievertsPerHour(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMicrosievertsPerHour(QuantityValue)" />
             public RadiationEquivalentDoseRate MicrosievertsPerHour
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDoseRate.FromMicrosievertsPerHour(double.CreateChecked(value));
+                => RadiationEquivalentDoseRate.FromMicrosievertsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDoseRate.FromMicrosievertsPerHour(value.ToDouble(null));
+                => RadiationEquivalentDoseRate.FromMicrosievertsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(QuantityValue)" />
             public RadiationEquivalentDoseRate MicrosievertsPerSecond
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(double.CreateChecked(value));
+                => RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(value.ToDouble(null));
+                => RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(QuantityValue)" />
             public RadiationEquivalentDoseRate MilliroentgensEquivalentManPerHour
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(double.CreateChecked(value));
+                => RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(value.ToDouble(null));
+                => RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMillisievertsPerHour(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMillisievertsPerHour(QuantityValue)" />
             public RadiationEquivalentDoseRate MillisievertsPerHour
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDoseRate.FromMillisievertsPerHour(double.CreateChecked(value));
+                => RadiationEquivalentDoseRate.FromMillisievertsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDoseRate.FromMillisievertsPerHour(value.ToDouble(null));
+                => RadiationEquivalentDoseRate.FromMillisievertsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMillisievertsPerSecond(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMillisievertsPerSecond(QuantityValue)" />
             public RadiationEquivalentDoseRate MillisievertsPerSecond
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDoseRate.FromMillisievertsPerSecond(double.CreateChecked(value));
+                => RadiationEquivalentDoseRate.FromMillisievertsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDoseRate.FromMillisievertsPerSecond(value.ToDouble(null));
+                => RadiationEquivalentDoseRate.FromMillisievertsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromNanosievertsPerHour(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromNanosievertsPerHour(QuantityValue)" />
             public RadiationEquivalentDoseRate NanosievertsPerHour
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDoseRate.FromNanosievertsPerHour(double.CreateChecked(value));
+                => RadiationEquivalentDoseRate.FromNanosievertsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDoseRate.FromNanosievertsPerHour(value.ToDouble(null));
+                => RadiationEquivalentDoseRate.FromNanosievertsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromNanosievertsPerSecond(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromNanosievertsPerSecond(QuantityValue)" />
             public RadiationEquivalentDoseRate NanosievertsPerSecond
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDoseRate.FromNanosievertsPerSecond(double.CreateChecked(value));
+                => RadiationEquivalentDoseRate.FromNanosievertsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDoseRate.FromNanosievertsPerSecond(value.ToDouble(null));
+                => RadiationEquivalentDoseRate.FromNanosievertsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(QuantityValue)" />
             public RadiationEquivalentDoseRate RoentgensEquivalentManPerHour
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(double.CreateChecked(value));
+                => RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(value.ToDouble(null));
+                => RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromSievertsPerHour(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromSievertsPerHour(QuantityValue)" />
             public RadiationEquivalentDoseRate SievertsPerHour
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDoseRate.FromSievertsPerHour(double.CreateChecked(value));
+                => RadiationEquivalentDoseRate.FromSievertsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDoseRate.FromSievertsPerHour(value.ToDouble(null));
+                => RadiationEquivalentDoseRate.FromSievertsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromSievertsPerSecond(double)" />
+            /// <inheritdoc cref="RadiationEquivalentDoseRate.FromSievertsPerSecond(QuantityValue)" />
             public RadiationEquivalentDoseRate SievertsPerSecond
 #if NET7_0_OR_GREATER
-                => RadiationEquivalentDoseRate.FromSievertsPerSecond(double.CreateChecked(value));
+                => RadiationEquivalentDoseRate.FromSievertsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RadiationEquivalentDoseRate.FromSievertsPerSecond(value.ToDouble(null));
+                => RadiationEquivalentDoseRate.FromSievertsPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationExposureExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationExposureExtensions.g.cs
index e6a6a5b0a6..f40a188335 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationExposureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationExposureExtensions.g.cs
@@ -42,68 +42,68 @@ public static class NumberToRadiationExposureExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="RadiationExposure.FromCoulombsPerKilogram(double)" />
+            /// <inheritdoc cref="RadiationExposure.FromCoulombsPerKilogram(QuantityValue)" />
             public RadiationExposure CoulombsPerKilogram
 #if NET7_0_OR_GREATER
-                => RadiationExposure.FromCoulombsPerKilogram(double.CreateChecked(value));
+                => RadiationExposure.FromCoulombsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => RadiationExposure.FromCoulombsPerKilogram(value.ToDouble(null));
+                => RadiationExposure.FromCoulombsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationExposure.FromMicrocoulombsPerKilogram(double)" />
+            /// <inheritdoc cref="RadiationExposure.FromMicrocoulombsPerKilogram(QuantityValue)" />
             public RadiationExposure MicrocoulombsPerKilogram
 #if NET7_0_OR_GREATER
-                => RadiationExposure.FromMicrocoulombsPerKilogram(double.CreateChecked(value));
+                => RadiationExposure.FromMicrocoulombsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => RadiationExposure.FromMicrocoulombsPerKilogram(value.ToDouble(null));
+                => RadiationExposure.FromMicrocoulombsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationExposure.FromMicroroentgens(double)" />
+            /// <inheritdoc cref="RadiationExposure.FromMicroroentgens(QuantityValue)" />
             public RadiationExposure Microroentgens
 #if NET7_0_OR_GREATER
-                => RadiationExposure.FromMicroroentgens(double.CreateChecked(value));
+                => RadiationExposure.FromMicroroentgens(QuantityValue.CreateChecked(value));
 #else
-                => RadiationExposure.FromMicroroentgens(value.ToDouble(null));
+                => RadiationExposure.FromMicroroentgens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationExposure.FromMillicoulombsPerKilogram(double)" />
+            /// <inheritdoc cref="RadiationExposure.FromMillicoulombsPerKilogram(QuantityValue)" />
             public RadiationExposure MillicoulombsPerKilogram
 #if NET7_0_OR_GREATER
-                => RadiationExposure.FromMillicoulombsPerKilogram(double.CreateChecked(value));
+                => RadiationExposure.FromMillicoulombsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => RadiationExposure.FromMillicoulombsPerKilogram(value.ToDouble(null));
+                => RadiationExposure.FromMillicoulombsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationExposure.FromMilliroentgens(double)" />
+            /// <inheritdoc cref="RadiationExposure.FromMilliroentgens(QuantityValue)" />
             public RadiationExposure Milliroentgens
 #if NET7_0_OR_GREATER
-                => RadiationExposure.FromMilliroentgens(double.CreateChecked(value));
+                => RadiationExposure.FromMilliroentgens(QuantityValue.CreateChecked(value));
 #else
-                => RadiationExposure.FromMilliroentgens(value.ToDouble(null));
+                => RadiationExposure.FromMilliroentgens(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationExposure.FromNanocoulombsPerKilogram(double)" />
+            /// <inheritdoc cref="RadiationExposure.FromNanocoulombsPerKilogram(QuantityValue)" />
             public RadiationExposure NanocoulombsPerKilogram
 #if NET7_0_OR_GREATER
-                => RadiationExposure.FromNanocoulombsPerKilogram(double.CreateChecked(value));
+                => RadiationExposure.FromNanocoulombsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => RadiationExposure.FromNanocoulombsPerKilogram(value.ToDouble(null));
+                => RadiationExposure.FromNanocoulombsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationExposure.FromPicocoulombsPerKilogram(double)" />
+            /// <inheritdoc cref="RadiationExposure.FromPicocoulombsPerKilogram(QuantityValue)" />
             public RadiationExposure PicocoulombsPerKilogram
 #if NET7_0_OR_GREATER
-                => RadiationExposure.FromPicocoulombsPerKilogram(double.CreateChecked(value));
+                => RadiationExposure.FromPicocoulombsPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => RadiationExposure.FromPicocoulombsPerKilogram(value.ToDouble(null));
+                => RadiationExposure.FromPicocoulombsPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RadiationExposure.FromRoentgens(double)" />
+            /// <inheritdoc cref="RadiationExposure.FromRoentgens(QuantityValue)" />
             public RadiationExposure Roentgens
 #if NET7_0_OR_GREATER
-                => RadiationExposure.FromRoentgens(double.CreateChecked(value));
+                => RadiationExposure.FromRoentgens(QuantityValue.CreateChecked(value));
 #else
-                => RadiationExposure.FromRoentgens(value.ToDouble(null));
+                => RadiationExposure.FromRoentgens(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadioactivityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadioactivityExtensions.g.cs
index f6e447bf48..f581956a1f 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadioactivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadioactivityExtensions.g.cs
@@ -42,236 +42,236 @@ public static class NumberToRadioactivityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Radioactivity.FromBecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromBecquerels(QuantityValue)" />
             public Radioactivity Becquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromBecquerels(double.CreateChecked(value));
+                => Radioactivity.FromBecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromBecquerels(value.ToDouble(null));
+                => Radioactivity.FromBecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromCuries(double)" />
+            /// <inheritdoc cref="Radioactivity.FromCuries(QuantityValue)" />
             public Radioactivity Curies
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromCuries(double.CreateChecked(value));
+                => Radioactivity.FromCuries(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromCuries(value.ToDouble(null));
+                => Radioactivity.FromCuries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromExabecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromExabecquerels(QuantityValue)" />
             public Radioactivity Exabecquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromExabecquerels(double.CreateChecked(value));
+                => Radioactivity.FromExabecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromExabecquerels(value.ToDouble(null));
+                => Radioactivity.FromExabecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromGigabecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromGigabecquerels(QuantityValue)" />
             public Radioactivity Gigabecquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromGigabecquerels(double.CreateChecked(value));
+                => Radioactivity.FromGigabecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromGigabecquerels(value.ToDouble(null));
+                => Radioactivity.FromGigabecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromGigacuries(double)" />
+            /// <inheritdoc cref="Radioactivity.FromGigacuries(QuantityValue)" />
             public Radioactivity Gigacuries
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromGigacuries(double.CreateChecked(value));
+                => Radioactivity.FromGigacuries(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromGigacuries(value.ToDouble(null));
+                => Radioactivity.FromGigacuries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromGigarutherfords(double)" />
+            /// <inheritdoc cref="Radioactivity.FromGigarutherfords(QuantityValue)" />
             public Radioactivity Gigarutherfords
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromGigarutherfords(double.CreateChecked(value));
+                => Radioactivity.FromGigarutherfords(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromGigarutherfords(value.ToDouble(null));
+                => Radioactivity.FromGigarutherfords(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromKilobecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromKilobecquerels(QuantityValue)" />
             public Radioactivity Kilobecquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromKilobecquerels(double.CreateChecked(value));
+                => Radioactivity.FromKilobecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromKilobecquerels(value.ToDouble(null));
+                => Radioactivity.FromKilobecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromKilocuries(double)" />
+            /// <inheritdoc cref="Radioactivity.FromKilocuries(QuantityValue)" />
             public Radioactivity Kilocuries
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromKilocuries(double.CreateChecked(value));
+                => Radioactivity.FromKilocuries(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromKilocuries(value.ToDouble(null));
+                => Radioactivity.FromKilocuries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromKilorutherfords(double)" />
+            /// <inheritdoc cref="Radioactivity.FromKilorutherfords(QuantityValue)" />
             public Radioactivity Kilorutherfords
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromKilorutherfords(double.CreateChecked(value));
+                => Radioactivity.FromKilorutherfords(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromKilorutherfords(value.ToDouble(null));
+                => Radioactivity.FromKilorutherfords(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromMegabecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromMegabecquerels(QuantityValue)" />
             public Radioactivity Megabecquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromMegabecquerels(double.CreateChecked(value));
+                => Radioactivity.FromMegabecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromMegabecquerels(value.ToDouble(null));
+                => Radioactivity.FromMegabecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromMegacuries(double)" />
+            /// <inheritdoc cref="Radioactivity.FromMegacuries(QuantityValue)" />
             public Radioactivity Megacuries
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromMegacuries(double.CreateChecked(value));
+                => Radioactivity.FromMegacuries(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromMegacuries(value.ToDouble(null));
+                => Radioactivity.FromMegacuries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromMegarutherfords(double)" />
+            /// <inheritdoc cref="Radioactivity.FromMegarutherfords(QuantityValue)" />
             public Radioactivity Megarutherfords
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromMegarutherfords(double.CreateChecked(value));
+                => Radioactivity.FromMegarutherfords(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromMegarutherfords(value.ToDouble(null));
+                => Radioactivity.FromMegarutherfords(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromMicrobecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromMicrobecquerels(QuantityValue)" />
             public Radioactivity Microbecquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromMicrobecquerels(double.CreateChecked(value));
+                => Radioactivity.FromMicrobecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromMicrobecquerels(value.ToDouble(null));
+                => Radioactivity.FromMicrobecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromMicrocuries(double)" />
+            /// <inheritdoc cref="Radioactivity.FromMicrocuries(QuantityValue)" />
             public Radioactivity Microcuries
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromMicrocuries(double.CreateChecked(value));
+                => Radioactivity.FromMicrocuries(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromMicrocuries(value.ToDouble(null));
+                => Radioactivity.FromMicrocuries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromMicrorutherfords(double)" />
+            /// <inheritdoc cref="Radioactivity.FromMicrorutherfords(QuantityValue)" />
             public Radioactivity Microrutherfords
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromMicrorutherfords(double.CreateChecked(value));
+                => Radioactivity.FromMicrorutherfords(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromMicrorutherfords(value.ToDouble(null));
+                => Radioactivity.FromMicrorutherfords(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromMillibecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromMillibecquerels(QuantityValue)" />
             public Radioactivity Millibecquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromMillibecquerels(double.CreateChecked(value));
+                => Radioactivity.FromMillibecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromMillibecquerels(value.ToDouble(null));
+                => Radioactivity.FromMillibecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromMillicuries(double)" />
+            /// <inheritdoc cref="Radioactivity.FromMillicuries(QuantityValue)" />
             public Radioactivity Millicuries
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromMillicuries(double.CreateChecked(value));
+                => Radioactivity.FromMillicuries(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromMillicuries(value.ToDouble(null));
+                => Radioactivity.FromMillicuries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromMillirutherfords(double)" />
+            /// <inheritdoc cref="Radioactivity.FromMillirutherfords(QuantityValue)" />
             public Radioactivity Millirutherfords
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromMillirutherfords(double.CreateChecked(value));
+                => Radioactivity.FromMillirutherfords(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromMillirutherfords(value.ToDouble(null));
+                => Radioactivity.FromMillirutherfords(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromNanobecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromNanobecquerels(QuantityValue)" />
             public Radioactivity Nanobecquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromNanobecquerels(double.CreateChecked(value));
+                => Radioactivity.FromNanobecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromNanobecquerels(value.ToDouble(null));
+                => Radioactivity.FromNanobecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromNanocuries(double)" />
+            /// <inheritdoc cref="Radioactivity.FromNanocuries(QuantityValue)" />
             public Radioactivity Nanocuries
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromNanocuries(double.CreateChecked(value));
+                => Radioactivity.FromNanocuries(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromNanocuries(value.ToDouble(null));
+                => Radioactivity.FromNanocuries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromNanorutherfords(double)" />
+            /// <inheritdoc cref="Radioactivity.FromNanorutherfords(QuantityValue)" />
             public Radioactivity Nanorutherfords
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromNanorutherfords(double.CreateChecked(value));
+                => Radioactivity.FromNanorutherfords(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromNanorutherfords(value.ToDouble(null));
+                => Radioactivity.FromNanorutherfords(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromPetabecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromPetabecquerels(QuantityValue)" />
             public Radioactivity Petabecquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromPetabecquerels(double.CreateChecked(value));
+                => Radioactivity.FromPetabecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromPetabecquerels(value.ToDouble(null));
+                => Radioactivity.FromPetabecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromPicobecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromPicobecquerels(QuantityValue)" />
             public Radioactivity Picobecquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromPicobecquerels(double.CreateChecked(value));
+                => Radioactivity.FromPicobecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromPicobecquerels(value.ToDouble(null));
+                => Radioactivity.FromPicobecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromPicocuries(double)" />
+            /// <inheritdoc cref="Radioactivity.FromPicocuries(QuantityValue)" />
             public Radioactivity Picocuries
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromPicocuries(double.CreateChecked(value));
+                => Radioactivity.FromPicocuries(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromPicocuries(value.ToDouble(null));
+                => Radioactivity.FromPicocuries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromPicorutherfords(double)" />
+            /// <inheritdoc cref="Radioactivity.FromPicorutherfords(QuantityValue)" />
             public Radioactivity Picorutherfords
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromPicorutherfords(double.CreateChecked(value));
+                => Radioactivity.FromPicorutherfords(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromPicorutherfords(value.ToDouble(null));
+                => Radioactivity.FromPicorutherfords(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromRutherfords(double)" />
+            /// <inheritdoc cref="Radioactivity.FromRutherfords(QuantityValue)" />
             public Radioactivity Rutherfords
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromRutherfords(double.CreateChecked(value));
+                => Radioactivity.FromRutherfords(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromRutherfords(value.ToDouble(null));
+                => Radioactivity.FromRutherfords(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromTerabecquerels(double)" />
+            /// <inheritdoc cref="Radioactivity.FromTerabecquerels(QuantityValue)" />
             public Radioactivity Terabecquerels
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromTerabecquerels(double.CreateChecked(value));
+                => Radioactivity.FromTerabecquerels(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromTerabecquerels(value.ToDouble(null));
+                => Radioactivity.FromTerabecquerels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromTeracuries(double)" />
+            /// <inheritdoc cref="Radioactivity.FromTeracuries(QuantityValue)" />
             public Radioactivity Teracuries
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromTeracuries(double.CreateChecked(value));
+                => Radioactivity.FromTeracuries(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromTeracuries(value.ToDouble(null));
+                => Radioactivity.FromTeracuries(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Radioactivity.FromTerarutherfords(double)" />
+            /// <inheritdoc cref="Radioactivity.FromTerarutherfords(QuantityValue)" />
             public Radioactivity Terarutherfords
 #if NET7_0_OR_GREATER
-                => Radioactivity.FromTerarutherfords(double.CreateChecked(value));
+                => Radioactivity.FromTerarutherfords(QuantityValue.CreateChecked(value));
 #else
-                => Radioactivity.FromTerarutherfords(value.ToDouble(null));
+                => Radioactivity.FromTerarutherfords(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
index 87ab8bbd5e..6763bdb226 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
@@ -42,20 +42,20 @@ public static class NumberToRatioChangeRateExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="RatioChangeRate.FromDecimalFractionsPerSecond(double)" />
+            /// <inheritdoc cref="RatioChangeRate.FromDecimalFractionsPerSecond(QuantityValue)" />
             public RatioChangeRate DecimalFractionsPerSecond
 #if NET7_0_OR_GREATER
-                => RatioChangeRate.FromDecimalFractionsPerSecond(double.CreateChecked(value));
+                => RatioChangeRate.FromDecimalFractionsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RatioChangeRate.FromDecimalFractionsPerSecond(value.ToDouble(null));
+                => RatioChangeRate.FromDecimalFractionsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RatioChangeRate.FromPercentsPerSecond(double)" />
+            /// <inheritdoc cref="RatioChangeRate.FromPercentsPerSecond(QuantityValue)" />
             public RatioChangeRate PercentsPerSecond
 #if NET7_0_OR_GREATER
-                => RatioChangeRate.FromPercentsPerSecond(double.CreateChecked(value));
+                => RatioChangeRate.FromPercentsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RatioChangeRate.FromPercentsPerSecond(value.ToDouble(null));
+                => RatioChangeRate.FromPercentsPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioExtensions.g.cs
index 2645ed3511..fc8bdcbe95 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioExtensions.g.cs
@@ -42,52 +42,52 @@ public static class NumberToRatioExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Ratio.FromDecimalFractions(double)" />
+            /// <inheritdoc cref="Ratio.FromDecimalFractions(QuantityValue)" />
             public Ratio DecimalFractions
 #if NET7_0_OR_GREATER
-                => Ratio.FromDecimalFractions(double.CreateChecked(value));
+                => Ratio.FromDecimalFractions(QuantityValue.CreateChecked(value));
 #else
-                => Ratio.FromDecimalFractions(value.ToDouble(null));
+                => Ratio.FromDecimalFractions(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Ratio.FromPartsPerBillion(double)" />
+            /// <inheritdoc cref="Ratio.FromPartsPerBillion(QuantityValue)" />
             public Ratio PartsPerBillion
 #if NET7_0_OR_GREATER
-                => Ratio.FromPartsPerBillion(double.CreateChecked(value));
+                => Ratio.FromPartsPerBillion(QuantityValue.CreateChecked(value));
 #else
-                => Ratio.FromPartsPerBillion(value.ToDouble(null));
+                => Ratio.FromPartsPerBillion(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Ratio.FromPartsPerMillion(double)" />
+            /// <inheritdoc cref="Ratio.FromPartsPerMillion(QuantityValue)" />
             public Ratio PartsPerMillion
 #if NET7_0_OR_GREATER
-                => Ratio.FromPartsPerMillion(double.CreateChecked(value));
+                => Ratio.FromPartsPerMillion(QuantityValue.CreateChecked(value));
 #else
-                => Ratio.FromPartsPerMillion(value.ToDouble(null));
+                => Ratio.FromPartsPerMillion(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Ratio.FromPartsPerThousand(double)" />
+            /// <inheritdoc cref="Ratio.FromPartsPerThousand(QuantityValue)" />
             public Ratio PartsPerThousand
 #if NET7_0_OR_GREATER
-                => Ratio.FromPartsPerThousand(double.CreateChecked(value));
+                => Ratio.FromPartsPerThousand(QuantityValue.CreateChecked(value));
 #else
-                => Ratio.FromPartsPerThousand(value.ToDouble(null));
+                => Ratio.FromPartsPerThousand(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Ratio.FromPartsPerTrillion(double)" />
+            /// <inheritdoc cref="Ratio.FromPartsPerTrillion(QuantityValue)" />
             public Ratio PartsPerTrillion
 #if NET7_0_OR_GREATER
-                => Ratio.FromPartsPerTrillion(double.CreateChecked(value));
+                => Ratio.FromPartsPerTrillion(QuantityValue.CreateChecked(value));
 #else
-                => Ratio.FromPartsPerTrillion(value.ToDouble(null));
+                => Ratio.FromPartsPerTrillion(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Ratio.FromPercent(double)" />
+            /// <inheritdoc cref="Ratio.FromPercent(QuantityValue)" />
             public Ratio Percent
 #if NET7_0_OR_GREATER
-                => Ratio.FromPercent(double.CreateChecked(value));
+                => Ratio.FromPercent(QuantityValue.CreateChecked(value));
 #else
-                => Ratio.FromPercent(value.ToDouble(null));
+                => Ratio.FromPercent(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs
index 4f5f008539..f006ec7c89 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs
@@ -42,92 +42,92 @@ public static class NumberToReciprocalAreaExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareCentimeters(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareCentimeters(QuantityValue)" />
             public ReciprocalArea InverseSquareCentimeters
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseSquareCentimeters(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseSquareCentimeters(value.ToDouble(null));
+                => ReciprocalArea.FromInverseSquareCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareDecimeters(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareDecimeters(QuantityValue)" />
             public ReciprocalArea InverseSquareDecimeters
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseSquareDecimeters(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseSquareDecimeters(value.ToDouble(null));
+                => ReciprocalArea.FromInverseSquareDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareFeet(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareFeet(QuantityValue)" />
             public ReciprocalArea InverseSquareFeet
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseSquareFeet(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseSquareFeet(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseSquareFeet(value.ToDouble(null));
+                => ReciprocalArea.FromInverseSquareFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareInches(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareInches(QuantityValue)" />
             public ReciprocalArea InverseSquareInches
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseSquareInches(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseSquareInches(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseSquareInches(value.ToDouble(null));
+                => ReciprocalArea.FromInverseSquareInches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareKilometers(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareKilometers(QuantityValue)" />
             public ReciprocalArea InverseSquareKilometers
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseSquareKilometers(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseSquareKilometers(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseSquareKilometers(value.ToDouble(null));
+                => ReciprocalArea.FromInverseSquareKilometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMeters(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMeters(QuantityValue)" />
             public ReciprocalArea InverseSquareMeters
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseSquareMeters(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseSquareMeters(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseSquareMeters(value.ToDouble(null));
+                => ReciprocalArea.FromInverseSquareMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMicrometers(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMicrometers(QuantityValue)" />
             public ReciprocalArea InverseSquareMicrometers
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseSquareMicrometers(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseSquareMicrometers(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseSquareMicrometers(value.ToDouble(null));
+                => ReciprocalArea.FromInverseSquareMicrometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMiles(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMiles(QuantityValue)" />
             public ReciprocalArea InverseSquareMiles
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseSquareMiles(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseSquareMiles(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseSquareMiles(value.ToDouble(null));
+                => ReciprocalArea.FromInverseSquareMiles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMillimeters(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMillimeters(QuantityValue)" />
             public ReciprocalArea InverseSquareMillimeters
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseSquareMillimeters(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseSquareMillimeters(value.ToDouble(null));
+                => ReciprocalArea.FromInverseSquareMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareYards(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseSquareYards(QuantityValue)" />
             public ReciprocalArea InverseSquareYards
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseSquareYards(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseSquareYards(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseSquareYards(value.ToDouble(null));
+                => ReciprocalArea.FromInverseSquareYards(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalArea.FromInverseUsSurveySquareFeet(double)" />
+            /// <inheritdoc cref="ReciprocalArea.FromInverseUsSurveySquareFeet(QuantityValue)" />
             public ReciprocalArea InverseUsSurveySquareFeet
 #if NET7_0_OR_GREATER
-                => ReciprocalArea.FromInverseUsSurveySquareFeet(double.CreateChecked(value));
+                => ReciprocalArea.FromInverseUsSurveySquareFeet(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalArea.FromInverseUsSurveySquareFeet(value.ToDouble(null));
+                => ReciprocalArea.FromInverseUsSurveySquareFeet(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs
index 6b880dfb95..5726b39962 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs
@@ -42,84 +42,84 @@ public static class NumberToReciprocalLengthExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ReciprocalLength.FromInverseCentimeters(double)" />
+            /// <inheritdoc cref="ReciprocalLength.FromInverseCentimeters(QuantityValue)" />
             public ReciprocalLength InverseCentimeters
 #if NET7_0_OR_GREATER
-                => ReciprocalLength.FromInverseCentimeters(double.CreateChecked(value));
+                => ReciprocalLength.FromInverseCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalLength.FromInverseCentimeters(value.ToDouble(null));
+                => ReciprocalLength.FromInverseCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalLength.FromInverseFeet(double)" />
+            /// <inheritdoc cref="ReciprocalLength.FromInverseFeet(QuantityValue)" />
             public ReciprocalLength InverseFeet
 #if NET7_0_OR_GREATER
-                => ReciprocalLength.FromInverseFeet(double.CreateChecked(value));
+                => ReciprocalLength.FromInverseFeet(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalLength.FromInverseFeet(value.ToDouble(null));
+                => ReciprocalLength.FromInverseFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalLength.FromInverseInches(double)" />
+            /// <inheritdoc cref="ReciprocalLength.FromInverseInches(QuantityValue)" />
             public ReciprocalLength InverseInches
 #if NET7_0_OR_GREATER
-                => ReciprocalLength.FromInverseInches(double.CreateChecked(value));
+                => ReciprocalLength.FromInverseInches(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalLength.FromInverseInches(value.ToDouble(null));
+                => ReciprocalLength.FromInverseInches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalLength.FromInverseMeters(double)" />
+            /// <inheritdoc cref="ReciprocalLength.FromInverseMeters(QuantityValue)" />
             public ReciprocalLength InverseMeters
 #if NET7_0_OR_GREATER
-                => ReciprocalLength.FromInverseMeters(double.CreateChecked(value));
+                => ReciprocalLength.FromInverseMeters(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalLength.FromInverseMeters(value.ToDouble(null));
+                => ReciprocalLength.FromInverseMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalLength.FromInverseMicroinches(double)" />
+            /// <inheritdoc cref="ReciprocalLength.FromInverseMicroinches(QuantityValue)" />
             public ReciprocalLength InverseMicroinches
 #if NET7_0_OR_GREATER
-                => ReciprocalLength.FromInverseMicroinches(double.CreateChecked(value));
+                => ReciprocalLength.FromInverseMicroinches(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalLength.FromInverseMicroinches(value.ToDouble(null));
+                => ReciprocalLength.FromInverseMicroinches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalLength.FromInverseMils(double)" />
+            /// <inheritdoc cref="ReciprocalLength.FromInverseMils(QuantityValue)" />
             public ReciprocalLength InverseMils
 #if NET7_0_OR_GREATER
-                => ReciprocalLength.FromInverseMils(double.CreateChecked(value));
+                => ReciprocalLength.FromInverseMils(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalLength.FromInverseMils(value.ToDouble(null));
+                => ReciprocalLength.FromInverseMils(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalLength.FromInverseMiles(double)" />
+            /// <inheritdoc cref="ReciprocalLength.FromInverseMiles(QuantityValue)" />
             public ReciprocalLength InverseMiles
 #if NET7_0_OR_GREATER
-                => ReciprocalLength.FromInverseMiles(double.CreateChecked(value));
+                => ReciprocalLength.FromInverseMiles(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalLength.FromInverseMiles(value.ToDouble(null));
+                => ReciprocalLength.FromInverseMiles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalLength.FromInverseMillimeters(double)" />
+            /// <inheritdoc cref="ReciprocalLength.FromInverseMillimeters(QuantityValue)" />
             public ReciprocalLength InverseMillimeters
 #if NET7_0_OR_GREATER
-                => ReciprocalLength.FromInverseMillimeters(double.CreateChecked(value));
+                => ReciprocalLength.FromInverseMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalLength.FromInverseMillimeters(value.ToDouble(null));
+                => ReciprocalLength.FromInverseMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalLength.FromInverseUsSurveyFeet(double)" />
+            /// <inheritdoc cref="ReciprocalLength.FromInverseUsSurveyFeet(QuantityValue)" />
             public ReciprocalLength InverseUsSurveyFeet
 #if NET7_0_OR_GREATER
-                => ReciprocalLength.FromInverseUsSurveyFeet(double.CreateChecked(value));
+                => ReciprocalLength.FromInverseUsSurveyFeet(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalLength.FromInverseUsSurveyFeet(value.ToDouble(null));
+                => ReciprocalLength.FromInverseUsSurveyFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ReciprocalLength.FromInverseYards(double)" />
+            /// <inheritdoc cref="ReciprocalLength.FromInverseYards(QuantityValue)" />
             public ReciprocalLength InverseYards
 #if NET7_0_OR_GREATER
-                => ReciprocalLength.FromInverseYards(double.CreateChecked(value));
+                => ReciprocalLength.FromInverseYards(QuantityValue.CreateChecked(value));
 #else
-                => ReciprocalLength.FromInverseYards(value.ToDouble(null));
+                => ReciprocalLength.FromInverseYards(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
index af37a8c3e5..e0597a6740 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToRelativeHumidityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="RelativeHumidity.FromPercent(double)" />
+            /// <inheritdoc cref="RelativeHumidity.FromPercent(QuantityValue)" />
             public RelativeHumidity Percent
 #if NET7_0_OR_GREATER
-                => RelativeHumidity.FromPercent(double.CreateChecked(value));
+                => RelativeHumidity.FromPercent(QuantityValue.CreateChecked(value));
 #else
-                => RelativeHumidity.FromPercent(value.ToDouble(null));
+                => RelativeHumidity.FromPercent(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
index 4b09a09679..a646c2d23a 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
@@ -42,36 +42,36 @@ public static class NumberToRotationalAccelerationExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="RotationalAcceleration.FromDegreesPerSecondSquared(double)" />
+            /// <inheritdoc cref="RotationalAcceleration.FromDegreesPerSecondSquared(QuantityValue)" />
             public RotationalAcceleration DegreesPerSecondSquared
 #if NET7_0_OR_GREATER
-                => RotationalAcceleration.FromDegreesPerSecondSquared(double.CreateChecked(value));
+                => RotationalAcceleration.FromDegreesPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => RotationalAcceleration.FromDegreesPerSecondSquared(value.ToDouble(null));
+                => RotationalAcceleration.FromDegreesPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalAcceleration.FromRadiansPerSecondSquared(double)" />
+            /// <inheritdoc cref="RotationalAcceleration.FromRadiansPerSecondSquared(QuantityValue)" />
             public RotationalAcceleration RadiansPerSecondSquared
 #if NET7_0_OR_GREATER
-                => RotationalAcceleration.FromRadiansPerSecondSquared(double.CreateChecked(value));
+                => RotationalAcceleration.FromRadiansPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => RotationalAcceleration.FromRadiansPerSecondSquared(value.ToDouble(null));
+                => RotationalAcceleration.FromRadiansPerSecondSquared(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerMinutePerSecond(double)" />
+            /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerMinutePerSecond(QuantityValue)" />
             public RotationalAcceleration RevolutionsPerMinutePerSecond
 #if NET7_0_OR_GREATER
-                => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(double.CreateChecked(value));
+                => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(value.ToDouble(null));
+                => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerSecondSquared(double)" />
+            /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerSecondSquared(QuantityValue)" />
             public RotationalAcceleration RevolutionsPerSecondSquared
 #if NET7_0_OR_GREATER
-                => RotationalAcceleration.FromRevolutionsPerSecondSquared(double.CreateChecked(value));
+                => RotationalAcceleration.FromRevolutionsPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
-                => RotationalAcceleration.FromRevolutionsPerSecondSquared(value.ToDouble(null));
+                => RotationalAcceleration.FromRevolutionsPerSecondSquared(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
index 16c614240a..3e86dd91dd 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
@@ -42,108 +42,108 @@ public static class NumberToRotationalSpeedExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="RotationalSpeed.FromCentiradiansPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromCentiradiansPerSecond(QuantityValue)" />
             public RotationalSpeed CentiradiansPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromCentiradiansPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromCentiradiansPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromCentiradiansPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromCentiradiansPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromDeciradiansPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromDeciradiansPerSecond(QuantityValue)" />
             public RotationalSpeed DeciradiansPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromDeciradiansPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromDeciradiansPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromDeciradiansPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromDeciradiansPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromDegreesPerMinute(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromDegreesPerMinute(QuantityValue)" />
             public RotationalSpeed DegreesPerMinute
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromDegreesPerMinute(double.CreateChecked(value));
+                => RotationalSpeed.FromDegreesPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromDegreesPerMinute(value.ToDouble(null));
+                => RotationalSpeed.FromDegreesPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromDegreesPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromDegreesPerSecond(QuantityValue)" />
             public RotationalSpeed DegreesPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromDegreesPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromDegreesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromDegreesPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromDegreesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromMicrodegreesPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromMicrodegreesPerSecond(QuantityValue)" />
             public RotationalSpeed MicrodegreesPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromMicrodegreesPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromMicrodegreesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromMicrodegreesPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromMicrodegreesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromMicroradiansPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromMicroradiansPerSecond(QuantityValue)" />
             public RotationalSpeed MicroradiansPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromMicroradiansPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromMicroradiansPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromMicroradiansPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromMicroradiansPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromMillidegreesPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromMillidegreesPerSecond(QuantityValue)" />
             public RotationalSpeed MillidegreesPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromMillidegreesPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromMillidegreesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromMillidegreesPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromMillidegreesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromMilliradiansPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromMilliradiansPerSecond(QuantityValue)" />
             public RotationalSpeed MilliradiansPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromMilliradiansPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromMilliradiansPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromMilliradiansPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromMilliradiansPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromNanodegreesPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromNanodegreesPerSecond(QuantityValue)" />
             public RotationalSpeed NanodegreesPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromNanodegreesPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromNanodegreesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromNanodegreesPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromNanodegreesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromNanoradiansPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromNanoradiansPerSecond(QuantityValue)" />
             public RotationalSpeed NanoradiansPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromNanoradiansPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromNanoradiansPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromNanoradiansPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromNanoradiansPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromRadiansPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromRadiansPerSecond(QuantityValue)" />
             public RotationalSpeed RadiansPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromRadiansPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromRadiansPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromRadiansPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromRadiansPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(QuantityValue)" />
             public RotationalSpeed RevolutionsPerMinute
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromRevolutionsPerMinute(double.CreateChecked(value));
+                => RotationalSpeed.FromRevolutionsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromRevolutionsPerMinute(value.ToDouble(null));
+                => RotationalSpeed.FromRevolutionsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerSecond(double)" />
+            /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerSecond(QuantityValue)" />
             public RotationalSpeed RevolutionsPerSecond
 #if NET7_0_OR_GREATER
-                => RotationalSpeed.FromRevolutionsPerSecond(double.CreateChecked(value));
+                => RotationalSpeed.FromRevolutionsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => RotationalSpeed.FromRevolutionsPerSecond(value.ToDouble(null));
+                => RotationalSpeed.FromRevolutionsPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
index 40c2e9a00f..21ada15b3a 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
@@ -42,276 +42,276 @@ public static class NumberToRotationalStiffnessExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMetersPerDegree(QuantityValue)" />
             public RotationalStiffness CentinewtonMetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromCentinewtonMetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromCentinewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromCentinewtonMetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromCentinewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerDegree(QuantityValue)" />
             public RotationalStiffness CentinewtonMillimetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromCentinewtonMillimetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromCentinewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromCentinewtonMillimetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromCentinewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerRadian(QuantityValue)" />
             public RotationalStiffness CentinewtonMillimetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromCentinewtonMillimetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromCentinewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromCentinewtonMillimetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromCentinewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMetersPerDegree(QuantityValue)" />
             public RotationalStiffness DecanewtonMetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromDecanewtonMetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromDecanewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromDecanewtonMetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromDecanewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerDegree(QuantityValue)" />
             public RotationalStiffness DecanewtonMillimetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromDecanewtonMillimetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromDecanewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromDecanewtonMillimetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromDecanewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerRadian(QuantityValue)" />
             public RotationalStiffness DecanewtonMillimetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromDecanewtonMillimetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromDecanewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromDecanewtonMillimetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromDecanewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMetersPerDegree(QuantityValue)" />
             public RotationalStiffness DecinewtonMetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromDecinewtonMetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromDecinewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromDecinewtonMetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromDecinewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerDegree(QuantityValue)" />
             public RotationalStiffness DecinewtonMillimetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromDecinewtonMillimetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromDecinewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromDecinewtonMillimetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromDecinewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerRadian(QuantityValue)" />
             public RotationalStiffness DecinewtonMillimetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromDecinewtonMillimetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromDecinewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromDecinewtonMillimetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromDecinewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerDegree(QuantityValue)" />
             public RotationalStiffness KilonewtonMetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromKilonewtonMetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromKilonewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromKilonewtonMetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromKilonewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerRadian(QuantityValue)" />
             public RotationalStiffness KilonewtonMetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromKilonewtonMetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromKilonewtonMetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromKilonewtonMetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromKilonewtonMetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerDegree(QuantityValue)" />
             public RotationalStiffness KilonewtonMillimetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromKilonewtonMillimetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromKilonewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromKilonewtonMillimetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromKilonewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerRadian(QuantityValue)" />
             public RotationalStiffness KilonewtonMillimetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromKilonewtonMillimetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromKilonewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromKilonewtonMillimetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromKilonewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerDegrees(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerDegrees(QuantityValue)" />
             public RotationalStiffness KilopoundForceFeetPerDegrees
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromKilopoundForceFeetPerDegrees(double.CreateChecked(value));
+                => RotationalStiffness.FromKilopoundForceFeetPerDegrees(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromKilopoundForceFeetPerDegrees(value.ToDouble(null));
+                => RotationalStiffness.FromKilopoundForceFeetPerDegrees(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerRadian(QuantityValue)" />
             public RotationalStiffness KilopoundForceFeetPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromKilopoundForceFeetPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromKilopoundForceFeetPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromKilopoundForceFeetPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromKilopoundForceFeetPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerDegree(QuantityValue)" />
             public RotationalStiffness MeganewtonMetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromMeganewtonMetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromMeganewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromMeganewtonMetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromMeganewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerRadian(QuantityValue)" />
             public RotationalStiffness MeganewtonMetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromMeganewtonMetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromMeganewtonMetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromMeganewtonMetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromMeganewtonMetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerDegree(QuantityValue)" />
             public RotationalStiffness MeganewtonMillimetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromMeganewtonMillimetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromMeganewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromMeganewtonMillimetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromMeganewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerRadian(QuantityValue)" />
             public RotationalStiffness MeganewtonMillimetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromMeganewtonMillimetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromMeganewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromMeganewtonMillimetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromMeganewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMetersPerDegree(QuantityValue)" />
             public RotationalStiffness MicronewtonMetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromMicronewtonMetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromMicronewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromMicronewtonMetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromMicronewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerDegree(QuantityValue)" />
             public RotationalStiffness MicronewtonMillimetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromMicronewtonMillimetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromMicronewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromMicronewtonMillimetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromMicronewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerRadian(QuantityValue)" />
             public RotationalStiffness MicronewtonMillimetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromMicronewtonMillimetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromMicronewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromMicronewtonMillimetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromMicronewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMetersPerDegree(QuantityValue)" />
             public RotationalStiffness MillinewtonMetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromMillinewtonMetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromMillinewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromMillinewtonMetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromMillinewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerDegree(QuantityValue)" />
             public RotationalStiffness MillinewtonMillimetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromMillinewtonMillimetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromMillinewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromMillinewtonMillimetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromMillinewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerRadian(QuantityValue)" />
             public RotationalStiffness MillinewtonMillimetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromMillinewtonMillimetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromMillinewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromMillinewtonMillimetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromMillinewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMetersPerDegree(QuantityValue)" />
             public RotationalStiffness NanonewtonMetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromNanonewtonMetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromNanonewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromNanonewtonMetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromNanonewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerDegree(QuantityValue)" />
             public RotationalStiffness NanonewtonMillimetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromNanonewtonMillimetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromNanonewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromNanonewtonMillimetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromNanonewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerRadian(QuantityValue)" />
             public RotationalStiffness NanonewtonMillimetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromNanonewtonMillimetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromNanonewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromNanonewtonMillimetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromNanonewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerDegree(QuantityValue)" />
             public RotationalStiffness NewtonMetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromNewtonMetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromNewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromNewtonMetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromNewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerRadian(QuantityValue)" />
             public RotationalStiffness NewtonMetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromNewtonMetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromNewtonMetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromNewtonMetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromNewtonMetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerDegree(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerDegree(QuantityValue)" />
             public RotationalStiffness NewtonMillimetersPerDegree
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromNewtonMillimetersPerDegree(double.CreateChecked(value));
+                => RotationalStiffness.FromNewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromNewtonMillimetersPerDegree(value.ToDouble(null));
+                => RotationalStiffness.FromNewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerRadian(QuantityValue)" />
             public RotationalStiffness NewtonMillimetersPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromNewtonMillimetersPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromNewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromNewtonMillimetersPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromNewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerRadian(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerRadian(QuantityValue)" />
             public RotationalStiffness PoundForceFeetPerRadian
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromPoundForceFeetPerRadian(double.CreateChecked(value));
+                => RotationalStiffness.FromPoundForceFeetPerRadian(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromPoundForceFeetPerRadian(value.ToDouble(null));
+                => RotationalStiffness.FromPoundForceFeetPerRadian(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerDegrees(double)" />
+            /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerDegrees(QuantityValue)" />
             public RotationalStiffness PoundForceFeetPerDegrees
 #if NET7_0_OR_GREATER
-                => RotationalStiffness.FromPoundForceFeetPerDegrees(double.CreateChecked(value));
+                => RotationalStiffness.FromPoundForceFeetPerDegrees(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffness.FromPoundForceFeetPerDegrees(value.ToDouble(null));
+                => RotationalStiffness.FromPoundForceFeetPerDegrees(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
index 4856cde4fa..a3ee7ba571 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
@@ -42,44 +42,44 @@ public static class NumberToRotationalStiffnessPerLengthExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(double)" />
+            /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(QuantityValue)" />
             public RotationalStiffnessPerLength KilonewtonMetersPerRadianPerMeter
 #if NET7_0_OR_GREATER
-                => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(double.CreateChecked(value));
+                => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(value.ToDouble(null));
+                => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(double)" />
+            /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(QuantityValue)" />
             public RotationalStiffnessPerLength KilopoundForceFeetPerDegreesPerFeet
 #if NET7_0_OR_GREATER
-                => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(double.CreateChecked(value));
+                => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(value.ToDouble(null));
+                => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(double)" />
+            /// <inheritdoc cref="RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(QuantityValue)" />
             public RotationalStiffnessPerLength MeganewtonMetersPerRadianPerMeter
 #if NET7_0_OR_GREATER
-                => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(double.CreateChecked(value));
+                => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(value.ToDouble(null));
+                => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(double)" />
+            /// <inheritdoc cref="RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(QuantityValue)" />
             public RotationalStiffnessPerLength NewtonMetersPerRadianPerMeter
 #if NET7_0_OR_GREATER
-                => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(double.CreateChecked(value));
+                => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(value.ToDouble(null));
+                => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(double)" />
+            /// <inheritdoc cref="RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(QuantityValue)" />
             public RotationalStiffnessPerLength PoundForceFeetPerDegreesPerFeet
 #if NET7_0_OR_GREATER
-                => RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(double.CreateChecked(value));
+                => RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(QuantityValue.CreateChecked(value));
 #else
-                => RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(value.ToDouble(null));
+                => RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToScalarExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToScalarExtensions.g.cs
index 62ce75ab9d..31a33d1e8b 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToScalarExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToScalarExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToScalarExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Scalar.FromAmount(double)" />
+            /// <inheritdoc cref="Scalar.FromAmount(QuantityValue)" />
             public Scalar Amount
 #if NET7_0_OR_GREATER
-                => Scalar.FromAmount(double.CreateChecked(value));
+                => Scalar.FromAmount(QuantityValue.CreateChecked(value));
 #else
-                => Scalar.FromAmount(value.ToDouble(null));
+                => Scalar.FromAmount(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSolidAngleExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSolidAngleExtensions.g.cs
index a6050dcc68..39ef02f0b0 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSolidAngleExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSolidAngleExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToSolidAngleExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="SolidAngle.FromSteradians(double)" />
+            /// <inheritdoc cref="SolidAngle.FromSteradians(QuantityValue)" />
             public SolidAngle Steradians
 #if NET7_0_OR_GREATER
-                => SolidAngle.FromSteradians(double.CreateChecked(value));
+                => SolidAngle.FromSteradians(QuantityValue.CreateChecked(value));
 #else
-                => SolidAngle.FromSteradians(value.ToDouble(null));
+                => SolidAngle.FromSteradians(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
index 7067d994c5..ed4d0ef517 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
@@ -42,244 +42,244 @@ public static class NumberToSpecificEnergyExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="SpecificEnergy.FromBtuPerPound(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromBtuPerPound(QuantityValue)" />
             public SpecificEnergy BtuPerPound
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromBtuPerPound(double.CreateChecked(value));
+                => SpecificEnergy.FromBtuPerPound(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromBtuPerPound(value.ToDouble(null));
+                => SpecificEnergy.FromBtuPerPound(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromCaloriesPerGram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromCaloriesPerGram(QuantityValue)" />
             public SpecificEnergy CaloriesPerGram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromCaloriesPerGram(double.CreateChecked(value));
+                => SpecificEnergy.FromCaloriesPerGram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromCaloriesPerGram(value.ToDouble(null));
+                => SpecificEnergy.FromCaloriesPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerKilogram(QuantityValue)" />
             public SpecificEnergy GigawattDaysPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromGigawattDaysPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromGigawattDaysPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromGigawattDaysPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromGigawattDaysPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerShortTon(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerShortTon(QuantityValue)" />
             public SpecificEnergy GigawattDaysPerShortTon
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromGigawattDaysPerShortTon(double.CreateChecked(value));
+                => SpecificEnergy.FromGigawattDaysPerShortTon(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromGigawattDaysPerShortTon(value.ToDouble(null));
+                => SpecificEnergy.FromGigawattDaysPerShortTon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerTonne(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerTonne(QuantityValue)" />
             public SpecificEnergy GigawattDaysPerTonne
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromGigawattDaysPerTonne(double.CreateChecked(value));
+                => SpecificEnergy.FromGigawattDaysPerTonne(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromGigawattDaysPerTonne(value.ToDouble(null));
+                => SpecificEnergy.FromGigawattDaysPerTonne(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerKilogram(QuantityValue)" />
             public SpecificEnergy GigawattHoursPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromGigawattHoursPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromGigawattHoursPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromGigawattHoursPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromGigawattHoursPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerPound(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerPound(QuantityValue)" />
             public SpecificEnergy GigawattHoursPerPound
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromGigawattHoursPerPound(double.CreateChecked(value));
+                => SpecificEnergy.FromGigawattHoursPerPound(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromGigawattHoursPerPound(value.ToDouble(null));
+                => SpecificEnergy.FromGigawattHoursPerPound(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromJoulesPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromJoulesPerKilogram(QuantityValue)" />
             public SpecificEnergy JoulesPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromJoulesPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromJoulesPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromJoulesPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromJoulesPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromKilocaloriesPerGram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromKilocaloriesPerGram(QuantityValue)" />
             public SpecificEnergy KilocaloriesPerGram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromKilocaloriesPerGram(double.CreateChecked(value));
+                => SpecificEnergy.FromKilocaloriesPerGram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromKilocaloriesPerGram(value.ToDouble(null));
+                => SpecificEnergy.FromKilocaloriesPerGram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromKilojoulesPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromKilojoulesPerKilogram(QuantityValue)" />
             public SpecificEnergy KilojoulesPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromKilojoulesPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromKilojoulesPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromKilojoulesPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromKilojoulesPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerKilogram(QuantityValue)" />
             public SpecificEnergy KilowattDaysPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromKilowattDaysPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromKilowattDaysPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromKilowattDaysPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromKilowattDaysPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerShortTon(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerShortTon(QuantityValue)" />
             public SpecificEnergy KilowattDaysPerShortTon
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromKilowattDaysPerShortTon(double.CreateChecked(value));
+                => SpecificEnergy.FromKilowattDaysPerShortTon(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromKilowattDaysPerShortTon(value.ToDouble(null));
+                => SpecificEnergy.FromKilowattDaysPerShortTon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerTonne(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerTonne(QuantityValue)" />
             public SpecificEnergy KilowattDaysPerTonne
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromKilowattDaysPerTonne(double.CreateChecked(value));
+                => SpecificEnergy.FromKilowattDaysPerTonne(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromKilowattDaysPerTonne(value.ToDouble(null));
+                => SpecificEnergy.FromKilowattDaysPerTonne(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerKilogram(QuantityValue)" />
             public SpecificEnergy KilowattHoursPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromKilowattHoursPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromKilowattHoursPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromKilowattHoursPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromKilowattHoursPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerPound(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerPound(QuantityValue)" />
             public SpecificEnergy KilowattHoursPerPound
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromKilowattHoursPerPound(double.CreateChecked(value));
+                => SpecificEnergy.FromKilowattHoursPerPound(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromKilowattHoursPerPound(value.ToDouble(null));
+                => SpecificEnergy.FromKilowattHoursPerPound(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerKilogram(QuantityValue)" />
             public SpecificEnergy MegajoulesPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromMegajoulesPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromMegajoulesPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromMegajoulesPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromMegajoulesPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerTonne(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerTonne(QuantityValue)" />
             public SpecificEnergy MegajoulesPerTonne
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromMegajoulesPerTonne(double.CreateChecked(value));
+                => SpecificEnergy.FromMegajoulesPerTonne(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromMegajoulesPerTonne(value.ToDouble(null));
+                => SpecificEnergy.FromMegajoulesPerTonne(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerKilogram(QuantityValue)" />
             public SpecificEnergy MegawattDaysPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromMegawattDaysPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromMegawattDaysPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromMegawattDaysPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromMegawattDaysPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerShortTon(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerShortTon(QuantityValue)" />
             public SpecificEnergy MegawattDaysPerShortTon
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromMegawattDaysPerShortTon(double.CreateChecked(value));
+                => SpecificEnergy.FromMegawattDaysPerShortTon(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromMegawattDaysPerShortTon(value.ToDouble(null));
+                => SpecificEnergy.FromMegawattDaysPerShortTon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerTonne(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerTonne(QuantityValue)" />
             public SpecificEnergy MegawattDaysPerTonne
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromMegawattDaysPerTonne(double.CreateChecked(value));
+                => SpecificEnergy.FromMegawattDaysPerTonne(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromMegawattDaysPerTonne(value.ToDouble(null));
+                => SpecificEnergy.FromMegawattDaysPerTonne(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerKilogram(QuantityValue)" />
             public SpecificEnergy MegawattHoursPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromMegawattHoursPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromMegawattHoursPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromMegawattHoursPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromMegawattHoursPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerPound(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerPound(QuantityValue)" />
             public SpecificEnergy MegawattHoursPerPound
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromMegawattHoursPerPound(double.CreateChecked(value));
+                => SpecificEnergy.FromMegawattHoursPerPound(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromMegawattHoursPerPound(value.ToDouble(null));
+                => SpecificEnergy.FromMegawattHoursPerPound(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerKilogram(QuantityValue)" />
             public SpecificEnergy TerawattDaysPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromTerawattDaysPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromTerawattDaysPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromTerawattDaysPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromTerawattDaysPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerShortTon(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerShortTon(QuantityValue)" />
             public SpecificEnergy TerawattDaysPerShortTon
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromTerawattDaysPerShortTon(double.CreateChecked(value));
+                => SpecificEnergy.FromTerawattDaysPerShortTon(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromTerawattDaysPerShortTon(value.ToDouble(null));
+                => SpecificEnergy.FromTerawattDaysPerShortTon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerTonne(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerTonne(QuantityValue)" />
             public SpecificEnergy TerawattDaysPerTonne
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromTerawattDaysPerTonne(double.CreateChecked(value));
+                => SpecificEnergy.FromTerawattDaysPerTonne(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromTerawattDaysPerTonne(value.ToDouble(null));
+                => SpecificEnergy.FromTerawattDaysPerTonne(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerKilogram(QuantityValue)" />
             public SpecificEnergy WattDaysPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromWattDaysPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromWattDaysPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromWattDaysPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromWattDaysPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerShortTon(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerShortTon(QuantityValue)" />
             public SpecificEnergy WattDaysPerShortTon
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromWattDaysPerShortTon(double.CreateChecked(value));
+                => SpecificEnergy.FromWattDaysPerShortTon(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromWattDaysPerShortTon(value.ToDouble(null));
+                => SpecificEnergy.FromWattDaysPerShortTon(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerTonne(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerTonne(QuantityValue)" />
             public SpecificEnergy WattDaysPerTonne
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromWattDaysPerTonne(double.CreateChecked(value));
+                => SpecificEnergy.FromWattDaysPerTonne(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromWattDaysPerTonne(value.ToDouble(null));
+                => SpecificEnergy.FromWattDaysPerTonne(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerKilogram(QuantityValue)" />
             public SpecificEnergy WattHoursPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromWattHoursPerKilogram(double.CreateChecked(value));
+                => SpecificEnergy.FromWattHoursPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromWattHoursPerKilogram(value.ToDouble(null));
+                => SpecificEnergy.FromWattHoursPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerPound(double)" />
+            /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerPound(QuantityValue)" />
             public SpecificEnergy WattHoursPerPound
 #if NET7_0_OR_GREATER
-                => SpecificEnergy.FromWattHoursPerPound(double.CreateChecked(value));
+                => SpecificEnergy.FromWattHoursPerPound(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEnergy.FromWattHoursPerPound(value.ToDouble(null));
+                => SpecificEnergy.FromWattHoursPerPound(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
index 71542313ed..12ab8ed4fc 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
@@ -42,76 +42,76 @@ public static class NumberToSpecificEntropyExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="SpecificEntropy.FromBtusPerPoundFahrenheit(double)" />
+            /// <inheritdoc cref="SpecificEntropy.FromBtusPerPoundFahrenheit(QuantityValue)" />
             public SpecificEntropy BtusPerPoundFahrenheit
 #if NET7_0_OR_GREATER
-                => SpecificEntropy.FromBtusPerPoundFahrenheit(double.CreateChecked(value));
+                => SpecificEntropy.FromBtusPerPoundFahrenheit(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEntropy.FromBtusPerPoundFahrenheit(value.ToDouble(null));
+                => SpecificEntropy.FromBtusPerPoundFahrenheit(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEntropy.FromCaloriesPerGramKelvin(double)" />
+            /// <inheritdoc cref="SpecificEntropy.FromCaloriesPerGramKelvin(QuantityValue)" />
             public SpecificEntropy CaloriesPerGramKelvin
 #if NET7_0_OR_GREATER
-                => SpecificEntropy.FromCaloriesPerGramKelvin(double.CreateChecked(value));
+                => SpecificEntropy.FromCaloriesPerGramKelvin(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEntropy.FromCaloriesPerGramKelvin(value.ToDouble(null));
+                => SpecificEntropy.FromCaloriesPerGramKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(double)" />
+            /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(QuantityValue)" />
             public SpecificEntropy JoulesPerKilogramDegreeCelsius
 #if NET7_0_OR_GREATER
-                => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(double.CreateChecked(value));
+                => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(value.ToDouble(null));
+                => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramKelvin(double)" />
+            /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramKelvin(QuantityValue)" />
             public SpecificEntropy JoulesPerKilogramKelvin
 #if NET7_0_OR_GREATER
-                => SpecificEntropy.FromJoulesPerKilogramKelvin(double.CreateChecked(value));
+                => SpecificEntropy.FromJoulesPerKilogramKelvin(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEntropy.FromJoulesPerKilogramKelvin(value.ToDouble(null));
+                => SpecificEntropy.FromJoulesPerKilogramKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEntropy.FromKilocaloriesPerGramKelvin(double)" />
+            /// <inheritdoc cref="SpecificEntropy.FromKilocaloriesPerGramKelvin(QuantityValue)" />
             public SpecificEntropy KilocaloriesPerGramKelvin
 #if NET7_0_OR_GREATER
-                => SpecificEntropy.FromKilocaloriesPerGramKelvin(double.CreateChecked(value));
+                => SpecificEntropy.FromKilocaloriesPerGramKelvin(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEntropy.FromKilocaloriesPerGramKelvin(value.ToDouble(null));
+                => SpecificEntropy.FromKilocaloriesPerGramKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(double)" />
+            /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(QuantityValue)" />
             public SpecificEntropy KilojoulesPerKilogramDegreeCelsius
 #if NET7_0_OR_GREATER
-                => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(double.CreateChecked(value));
+                => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(value.ToDouble(null));
+                => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramKelvin(double)" />
+            /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramKelvin(QuantityValue)" />
             public SpecificEntropy KilojoulesPerKilogramKelvin
 #if NET7_0_OR_GREATER
-                => SpecificEntropy.FromKilojoulesPerKilogramKelvin(double.CreateChecked(value));
+                => SpecificEntropy.FromKilojoulesPerKilogramKelvin(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEntropy.FromKilojoulesPerKilogramKelvin(value.ToDouble(null));
+                => SpecificEntropy.FromKilojoulesPerKilogramKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(double)" />
+            /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(QuantityValue)" />
             public SpecificEntropy MegajoulesPerKilogramDegreeCelsius
 #if NET7_0_OR_GREATER
-                => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(double.CreateChecked(value));
+                => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(value.ToDouble(null));
+                => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramKelvin(double)" />
+            /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramKelvin(QuantityValue)" />
             public SpecificEntropy MegajoulesPerKilogramKelvin
 #if NET7_0_OR_GREATER
-                => SpecificEntropy.FromMegajoulesPerKilogramKelvin(double.CreateChecked(value));
+                => SpecificEntropy.FromMegajoulesPerKilogramKelvin(QuantityValue.CreateChecked(value));
 #else
-                => SpecificEntropy.FromMegajoulesPerKilogramKelvin(value.ToDouble(null));
+                => SpecificEntropy.FromMegajoulesPerKilogramKelvin(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs
index 4473785b64..ca7231fbce 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs
@@ -42,36 +42,36 @@ public static class NumberToSpecificFuelConsumptionExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="SpecificFuelConsumption.FromGramsPerKilonewtonSecond(double)" />
+            /// <inheritdoc cref="SpecificFuelConsumption.FromGramsPerKilonewtonSecond(QuantityValue)" />
             public SpecificFuelConsumption GramsPerKilonewtonSecond
 #if NET7_0_OR_GREATER
-                => SpecificFuelConsumption.FromGramsPerKilonewtonSecond(double.CreateChecked(value));
+                => SpecificFuelConsumption.FromGramsPerKilonewtonSecond(QuantityValue.CreateChecked(value));
 #else
-                => SpecificFuelConsumption.FromGramsPerKilonewtonSecond(value.ToDouble(null));
+                => SpecificFuelConsumption.FromGramsPerKilonewtonSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(double)" />
+            /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(QuantityValue)" />
             public SpecificFuelConsumption KilogramsPerKilogramForceHour
 #if NET7_0_OR_GREATER
-                => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(double.CreateChecked(value));
+                => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(QuantityValue.CreateChecked(value));
 #else
-                => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(value.ToDouble(null));
+                => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(double)" />
+            /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(QuantityValue)" />
             public SpecificFuelConsumption KilogramsPerKilonewtonSecond
 #if NET7_0_OR_GREATER
-                => SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(double.CreateChecked(value));
+                => SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(QuantityValue.CreateChecked(value));
 #else
-                => SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(value.ToDouble(null));
+                => SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(double)" />
+            /// <inheritdoc cref="SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(QuantityValue)" />
             public SpecificFuelConsumption PoundsMassPerPoundForceHour
 #if NET7_0_OR_GREATER
-                => SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(double.CreateChecked(value));
+                => SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(QuantityValue.CreateChecked(value));
 #else
-                => SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(value.ToDouble(null));
+                => SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
index b8762fcea6..b33df10c09 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
@@ -42,28 +42,28 @@ public static class NumberToSpecificVolumeExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="SpecificVolume.FromCubicFeetPerPound(double)" />
+            /// <inheritdoc cref="SpecificVolume.FromCubicFeetPerPound(QuantityValue)" />
             public SpecificVolume CubicFeetPerPound
 #if NET7_0_OR_GREATER
-                => SpecificVolume.FromCubicFeetPerPound(double.CreateChecked(value));
+                => SpecificVolume.FromCubicFeetPerPound(QuantityValue.CreateChecked(value));
 #else
-                => SpecificVolume.FromCubicFeetPerPound(value.ToDouble(null));
+                => SpecificVolume.FromCubicFeetPerPound(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificVolume.FromCubicMetersPerKilogram(double)" />
+            /// <inheritdoc cref="SpecificVolume.FromCubicMetersPerKilogram(QuantityValue)" />
             public SpecificVolume CubicMetersPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificVolume.FromCubicMetersPerKilogram(double.CreateChecked(value));
+                => SpecificVolume.FromCubicMetersPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificVolume.FromCubicMetersPerKilogram(value.ToDouble(null));
+                => SpecificVolume.FromCubicMetersPerKilogram(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificVolume.FromMillicubicMetersPerKilogram(double)" />
-            public SpecificVolume MillicubicMetersPerKilogram
+            /// <inheritdoc cref="SpecificVolume.FromCubicMillimetersPerKilogram(QuantityValue)" />
+            public SpecificVolume CubicMillimetersPerKilogram
 #if NET7_0_OR_GREATER
-                => SpecificVolume.FromMillicubicMetersPerKilogram(double.CreateChecked(value));
+                => SpecificVolume.FromCubicMillimetersPerKilogram(QuantityValue.CreateChecked(value));
 #else
-                => SpecificVolume.FromMillicubicMetersPerKilogram(value.ToDouble(null));
+                => SpecificVolume.FromCubicMillimetersPerKilogram(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificWeightExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
index 45ae4bcb2f..1f4cd47061 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
@@ -42,140 +42,140 @@ public static class NumberToSpecificWeightExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicCentimeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicCentimeter(QuantityValue)" />
             public SpecificWeight KilogramsForcePerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromKilogramsForcePerCubicCentimeter(double.CreateChecked(value));
+                => SpecificWeight.FromKilogramsForcePerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromKilogramsForcePerCubicCentimeter(value.ToDouble(null));
+                => SpecificWeight.FromKilogramsForcePerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMeter(QuantityValue)" />
             public SpecificWeight KilogramsForcePerCubicMeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromKilogramsForcePerCubicMeter(double.CreateChecked(value));
+                => SpecificWeight.FromKilogramsForcePerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromKilogramsForcePerCubicMeter(value.ToDouble(null));
+                => SpecificWeight.FromKilogramsForcePerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMillimeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMillimeter(QuantityValue)" />
             public SpecificWeight KilogramsForcePerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromKilogramsForcePerCubicMillimeter(double.CreateChecked(value));
+                => SpecificWeight.FromKilogramsForcePerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromKilogramsForcePerCubicMillimeter(value.ToDouble(null));
+                => SpecificWeight.FromKilogramsForcePerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicCentimeter(QuantityValue)" />
             public SpecificWeight KilonewtonsPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromKilonewtonsPerCubicCentimeter(double.CreateChecked(value));
+                => SpecificWeight.FromKilonewtonsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromKilonewtonsPerCubicCentimeter(value.ToDouble(null));
+                => SpecificWeight.FromKilonewtonsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMeter(QuantityValue)" />
             public SpecificWeight KilonewtonsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromKilonewtonsPerCubicMeter(double.CreateChecked(value));
+                => SpecificWeight.FromKilonewtonsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromKilonewtonsPerCubicMeter(value.ToDouble(null));
+                => SpecificWeight.FromKilonewtonsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMillimeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMillimeter(QuantityValue)" />
             public SpecificWeight KilonewtonsPerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromKilonewtonsPerCubicMillimeter(double.CreateChecked(value));
+                => SpecificWeight.FromKilonewtonsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromKilonewtonsPerCubicMillimeter(value.ToDouble(null));
+                => SpecificWeight.FromKilonewtonsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicFoot(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicFoot(QuantityValue)" />
             public SpecificWeight KilopoundsForcePerCubicFoot
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromKilopoundsForcePerCubicFoot(double.CreateChecked(value));
+                => SpecificWeight.FromKilopoundsForcePerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromKilopoundsForcePerCubicFoot(value.ToDouble(null));
+                => SpecificWeight.FromKilopoundsForcePerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicInch(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicInch(QuantityValue)" />
             public SpecificWeight KilopoundsForcePerCubicInch
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromKilopoundsForcePerCubicInch(double.CreateChecked(value));
+                => SpecificWeight.FromKilopoundsForcePerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromKilopoundsForcePerCubicInch(value.ToDouble(null));
+                => SpecificWeight.FromKilopoundsForcePerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromMeganewtonsPerCubicMeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromMeganewtonsPerCubicMeter(QuantityValue)" />
             public SpecificWeight MeganewtonsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromMeganewtonsPerCubicMeter(double.CreateChecked(value));
+                => SpecificWeight.FromMeganewtonsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromMeganewtonsPerCubicMeter(value.ToDouble(null));
+                => SpecificWeight.FromMeganewtonsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicCentimeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicCentimeter(QuantityValue)" />
             public SpecificWeight NewtonsPerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromNewtonsPerCubicCentimeter(double.CreateChecked(value));
+                => SpecificWeight.FromNewtonsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromNewtonsPerCubicCentimeter(value.ToDouble(null));
+                => SpecificWeight.FromNewtonsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMeter(QuantityValue)" />
             public SpecificWeight NewtonsPerCubicMeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromNewtonsPerCubicMeter(double.CreateChecked(value));
+                => SpecificWeight.FromNewtonsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromNewtonsPerCubicMeter(value.ToDouble(null));
+                => SpecificWeight.FromNewtonsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMillimeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMillimeter(QuantityValue)" />
             public SpecificWeight NewtonsPerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromNewtonsPerCubicMillimeter(double.CreateChecked(value));
+                => SpecificWeight.FromNewtonsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromNewtonsPerCubicMillimeter(value.ToDouble(null));
+                => SpecificWeight.FromNewtonsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicFoot(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicFoot(QuantityValue)" />
             public SpecificWeight PoundsForcePerCubicFoot
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromPoundsForcePerCubicFoot(double.CreateChecked(value));
+                => SpecificWeight.FromPoundsForcePerCubicFoot(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromPoundsForcePerCubicFoot(value.ToDouble(null));
+                => SpecificWeight.FromPoundsForcePerCubicFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicInch(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicInch(QuantityValue)" />
             public SpecificWeight PoundsForcePerCubicInch
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromPoundsForcePerCubicInch(double.CreateChecked(value));
+                => SpecificWeight.FromPoundsForcePerCubicInch(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromPoundsForcePerCubicInch(value.ToDouble(null));
+                => SpecificWeight.FromPoundsForcePerCubicInch(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicCentimeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicCentimeter(QuantityValue)" />
             public SpecificWeight TonnesForcePerCubicCentimeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromTonnesForcePerCubicCentimeter(double.CreateChecked(value));
+                => SpecificWeight.FromTonnesForcePerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromTonnesForcePerCubicCentimeter(value.ToDouble(null));
+                => SpecificWeight.FromTonnesForcePerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMeter(QuantityValue)" />
             public SpecificWeight TonnesForcePerCubicMeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromTonnesForcePerCubicMeter(double.CreateChecked(value));
+                => SpecificWeight.FromTonnesForcePerCubicMeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromTonnesForcePerCubicMeter(value.ToDouble(null));
+                => SpecificWeight.FromTonnesForcePerCubicMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMillimeter(double)" />
+            /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMillimeter(QuantityValue)" />
             public SpecificWeight TonnesForcePerCubicMillimeter
 #if NET7_0_OR_GREATER
-                => SpecificWeight.FromTonnesForcePerCubicMillimeter(double.CreateChecked(value));
+                => SpecificWeight.FromTonnesForcePerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => SpecificWeight.FromTonnesForcePerCubicMillimeter(value.ToDouble(null));
+                => SpecificWeight.FromTonnesForcePerCubicMillimeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpeedExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpeedExtensions.g.cs
index c71cf409a3..be5137aedc 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpeedExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpeedExtensions.g.cs
@@ -42,268 +42,268 @@ public static class NumberToSpeedExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Speed.FromCentimetersPerHour(double)" />
+            /// <inheritdoc cref="Speed.FromCentimetersPerHour(QuantityValue)" />
             public Speed CentimetersPerHour
 #if NET7_0_OR_GREATER
-                => Speed.FromCentimetersPerHour(double.CreateChecked(value));
+                => Speed.FromCentimetersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromCentimetersPerHour(value.ToDouble(null));
+                => Speed.FromCentimetersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromCentimetersPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromCentimetersPerMinute(QuantityValue)" />
             public Speed CentimetersPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromCentimetersPerMinute(double.CreateChecked(value));
+                => Speed.FromCentimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromCentimetersPerMinute(value.ToDouble(null));
+                => Speed.FromCentimetersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromCentimetersPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromCentimetersPerSecond(QuantityValue)" />
             public Speed CentimetersPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromCentimetersPerSecond(double.CreateChecked(value));
+                => Speed.FromCentimetersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromCentimetersPerSecond(value.ToDouble(null));
+                => Speed.FromCentimetersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromDecimetersPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromDecimetersPerMinute(QuantityValue)" />
             public Speed DecimetersPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromDecimetersPerMinute(double.CreateChecked(value));
+                => Speed.FromDecimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromDecimetersPerMinute(value.ToDouble(null));
+                => Speed.FromDecimetersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromDecimetersPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromDecimetersPerSecond(QuantityValue)" />
             public Speed DecimetersPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromDecimetersPerSecond(double.CreateChecked(value));
+                => Speed.FromDecimetersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromDecimetersPerSecond(value.ToDouble(null));
+                => Speed.FromDecimetersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromFeetPerHour(double)" />
+            /// <inheritdoc cref="Speed.FromFeetPerHour(QuantityValue)" />
             public Speed FeetPerHour
 #if NET7_0_OR_GREATER
-                => Speed.FromFeetPerHour(double.CreateChecked(value));
+                => Speed.FromFeetPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromFeetPerHour(value.ToDouble(null));
+                => Speed.FromFeetPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromFeetPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromFeetPerMinute(QuantityValue)" />
             public Speed FeetPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromFeetPerMinute(double.CreateChecked(value));
+                => Speed.FromFeetPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromFeetPerMinute(value.ToDouble(null));
+                => Speed.FromFeetPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromFeetPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromFeetPerSecond(QuantityValue)" />
             public Speed FeetPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromFeetPerSecond(double.CreateChecked(value));
+                => Speed.FromFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromFeetPerSecond(value.ToDouble(null));
+                => Speed.FromFeetPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromInchesPerHour(double)" />
+            /// <inheritdoc cref="Speed.FromInchesPerHour(QuantityValue)" />
             public Speed InchesPerHour
 #if NET7_0_OR_GREATER
-                => Speed.FromInchesPerHour(double.CreateChecked(value));
+                => Speed.FromInchesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromInchesPerHour(value.ToDouble(null));
+                => Speed.FromInchesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromInchesPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromInchesPerMinute(QuantityValue)" />
             public Speed InchesPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromInchesPerMinute(double.CreateChecked(value));
+                => Speed.FromInchesPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromInchesPerMinute(value.ToDouble(null));
+                => Speed.FromInchesPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromInchesPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromInchesPerSecond(QuantityValue)" />
             public Speed InchesPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromInchesPerSecond(double.CreateChecked(value));
+                => Speed.FromInchesPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromInchesPerSecond(value.ToDouble(null));
+                => Speed.FromInchesPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromKilometersPerHour(double)" />
+            /// <inheritdoc cref="Speed.FromKilometersPerHour(QuantityValue)" />
             public Speed KilometersPerHour
 #if NET7_0_OR_GREATER
-                => Speed.FromKilometersPerHour(double.CreateChecked(value));
+                => Speed.FromKilometersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromKilometersPerHour(value.ToDouble(null));
+                => Speed.FromKilometersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromKilometersPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromKilometersPerMinute(QuantityValue)" />
             public Speed KilometersPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromKilometersPerMinute(double.CreateChecked(value));
+                => Speed.FromKilometersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromKilometersPerMinute(value.ToDouble(null));
+                => Speed.FromKilometersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromKilometersPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromKilometersPerSecond(QuantityValue)" />
             public Speed KilometersPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromKilometersPerSecond(double.CreateChecked(value));
+                => Speed.FromKilometersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromKilometersPerSecond(value.ToDouble(null));
+                => Speed.FromKilometersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromKnots(double)" />
+            /// <inheritdoc cref="Speed.FromKnots(QuantityValue)" />
             public Speed Knots
 #if NET7_0_OR_GREATER
-                => Speed.FromKnots(double.CreateChecked(value));
+                => Speed.FromKnots(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromKnots(value.ToDouble(null));
+                => Speed.FromKnots(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromMach(double)" />
+            /// <inheritdoc cref="Speed.FromMach(QuantityValue)" />
             public Speed Mach
 #if NET7_0_OR_GREATER
-                => Speed.FromMach(double.CreateChecked(value));
+                => Speed.FromMach(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromMach(value.ToDouble(null));
+                => Speed.FromMach(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromMetersPerHour(double)" />
+            /// <inheritdoc cref="Speed.FromMetersPerHour(QuantityValue)" />
             public Speed MetersPerHour
 #if NET7_0_OR_GREATER
-                => Speed.FromMetersPerHour(double.CreateChecked(value));
+                => Speed.FromMetersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromMetersPerHour(value.ToDouble(null));
+                => Speed.FromMetersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromMetersPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromMetersPerMinute(QuantityValue)" />
             public Speed MetersPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromMetersPerMinute(double.CreateChecked(value));
+                => Speed.FromMetersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromMetersPerMinute(value.ToDouble(null));
+                => Speed.FromMetersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromMetersPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromMetersPerSecond(QuantityValue)" />
             public Speed MetersPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromMetersPerSecond(double.CreateChecked(value));
+                => Speed.FromMetersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromMetersPerSecond(value.ToDouble(null));
+                => Speed.FromMetersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromMicrometersPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromMicrometersPerMinute(QuantityValue)" />
             public Speed MicrometersPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromMicrometersPerMinute(double.CreateChecked(value));
+                => Speed.FromMicrometersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromMicrometersPerMinute(value.ToDouble(null));
+                => Speed.FromMicrometersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromMicrometersPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromMicrometersPerSecond(QuantityValue)" />
             public Speed MicrometersPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromMicrometersPerSecond(double.CreateChecked(value));
+                => Speed.FromMicrometersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromMicrometersPerSecond(value.ToDouble(null));
+                => Speed.FromMicrometersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromMilesPerHour(double)" />
+            /// <inheritdoc cref="Speed.FromMilesPerHour(QuantityValue)" />
             public Speed MilesPerHour
 #if NET7_0_OR_GREATER
-                => Speed.FromMilesPerHour(double.CreateChecked(value));
+                => Speed.FromMilesPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromMilesPerHour(value.ToDouble(null));
+                => Speed.FromMilesPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromMillimetersPerHour(double)" />
+            /// <inheritdoc cref="Speed.FromMillimetersPerHour(QuantityValue)" />
             public Speed MillimetersPerHour
 #if NET7_0_OR_GREATER
-                => Speed.FromMillimetersPerHour(double.CreateChecked(value));
+                => Speed.FromMillimetersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromMillimetersPerHour(value.ToDouble(null));
+                => Speed.FromMillimetersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromMillimetersPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromMillimetersPerMinute(QuantityValue)" />
             public Speed MillimetersPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromMillimetersPerMinute(double.CreateChecked(value));
+                => Speed.FromMillimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromMillimetersPerMinute(value.ToDouble(null));
+                => Speed.FromMillimetersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromMillimetersPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromMillimetersPerSecond(QuantityValue)" />
             public Speed MillimetersPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromMillimetersPerSecond(double.CreateChecked(value));
+                => Speed.FromMillimetersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromMillimetersPerSecond(value.ToDouble(null));
+                => Speed.FromMillimetersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromNanometersPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromNanometersPerMinute(QuantityValue)" />
             public Speed NanometersPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromNanometersPerMinute(double.CreateChecked(value));
+                => Speed.FromNanometersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromNanometersPerMinute(value.ToDouble(null));
+                => Speed.FromNanometersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromNanometersPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromNanometersPerSecond(QuantityValue)" />
             public Speed NanometersPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromNanometersPerSecond(double.CreateChecked(value));
+                => Speed.FromNanometersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromNanometersPerSecond(value.ToDouble(null));
+                => Speed.FromNanometersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromUsSurveyFeetPerHour(double)" />
+            /// <inheritdoc cref="Speed.FromUsSurveyFeetPerHour(QuantityValue)" />
             public Speed UsSurveyFeetPerHour
 #if NET7_0_OR_GREATER
-                => Speed.FromUsSurveyFeetPerHour(double.CreateChecked(value));
+                => Speed.FromUsSurveyFeetPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromUsSurveyFeetPerHour(value.ToDouble(null));
+                => Speed.FromUsSurveyFeetPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromUsSurveyFeetPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromUsSurveyFeetPerMinute(QuantityValue)" />
             public Speed UsSurveyFeetPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromUsSurveyFeetPerMinute(double.CreateChecked(value));
+                => Speed.FromUsSurveyFeetPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromUsSurveyFeetPerMinute(value.ToDouble(null));
+                => Speed.FromUsSurveyFeetPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromUsSurveyFeetPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromUsSurveyFeetPerSecond(QuantityValue)" />
             public Speed UsSurveyFeetPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromUsSurveyFeetPerSecond(double.CreateChecked(value));
+                => Speed.FromUsSurveyFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromUsSurveyFeetPerSecond(value.ToDouble(null));
+                => Speed.FromUsSurveyFeetPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromYardsPerHour(double)" />
+            /// <inheritdoc cref="Speed.FromYardsPerHour(QuantityValue)" />
             public Speed YardsPerHour
 #if NET7_0_OR_GREATER
-                => Speed.FromYardsPerHour(double.CreateChecked(value));
+                => Speed.FromYardsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromYardsPerHour(value.ToDouble(null));
+                => Speed.FromYardsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromYardsPerMinute(double)" />
+            /// <inheritdoc cref="Speed.FromYardsPerMinute(QuantityValue)" />
             public Speed YardsPerMinute
 #if NET7_0_OR_GREATER
-                => Speed.FromYardsPerMinute(double.CreateChecked(value));
+                => Speed.FromYardsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromYardsPerMinute(value.ToDouble(null));
+                => Speed.FromYardsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Speed.FromYardsPerSecond(double)" />
+            /// <inheritdoc cref="Speed.FromYardsPerSecond(QuantityValue)" />
             public Speed YardsPerSecond
 #if NET7_0_OR_GREATER
-                => Speed.FromYardsPerSecond(double.CreateChecked(value));
+                => Speed.FromYardsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => Speed.FromYardsPerSecond(value.ToDouble(null));
+                => Speed.FromYardsPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs
index 136ac4c994..13ab88df64 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs
@@ -42,76 +42,76 @@ public static class NumberToStandardVolumeFlowExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(double)" />
+            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(QuantityValue)" />
             public StandardVolumeFlow StandardCubicCentimetersPerMinute
 #if NET7_0_OR_GREATER
-                => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(double.CreateChecked(value));
+                => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(value.ToDouble(null));
+                => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerHour(double)" />
+            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerHour(QuantityValue)" />
             public StandardVolumeFlow StandardCubicFeetPerHour
 #if NET7_0_OR_GREATER
-                => StandardVolumeFlow.FromStandardCubicFeetPerHour(double.CreateChecked(value));
+                => StandardVolumeFlow.FromStandardCubicFeetPerHour(QuantityValue.CreateChecked(value));
 #else
-                => StandardVolumeFlow.FromStandardCubicFeetPerHour(value.ToDouble(null));
+                => StandardVolumeFlow.FromStandardCubicFeetPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerMinute(double)" />
+            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerMinute(QuantityValue)" />
             public StandardVolumeFlow StandardCubicFeetPerMinute
 #if NET7_0_OR_GREATER
-                => StandardVolumeFlow.FromStandardCubicFeetPerMinute(double.CreateChecked(value));
+                => StandardVolumeFlow.FromStandardCubicFeetPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => StandardVolumeFlow.FromStandardCubicFeetPerMinute(value.ToDouble(null));
+                => StandardVolumeFlow.FromStandardCubicFeetPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerSecond(double)" />
+            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerSecond(QuantityValue)" />
             public StandardVolumeFlow StandardCubicFeetPerSecond
 #if NET7_0_OR_GREATER
-                => StandardVolumeFlow.FromStandardCubicFeetPerSecond(double.CreateChecked(value));
+                => StandardVolumeFlow.FromStandardCubicFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => StandardVolumeFlow.FromStandardCubicFeetPerSecond(value.ToDouble(null));
+                => StandardVolumeFlow.FromStandardCubicFeetPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerDay(double)" />
+            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerDay(QuantityValue)" />
             public StandardVolumeFlow StandardCubicMetersPerDay
 #if NET7_0_OR_GREATER
-                => StandardVolumeFlow.FromStandardCubicMetersPerDay(double.CreateChecked(value));
+                => StandardVolumeFlow.FromStandardCubicMetersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => StandardVolumeFlow.FromStandardCubicMetersPerDay(value.ToDouble(null));
+                => StandardVolumeFlow.FromStandardCubicMetersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerHour(double)" />
+            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerHour(QuantityValue)" />
             public StandardVolumeFlow StandardCubicMetersPerHour
 #if NET7_0_OR_GREATER
-                => StandardVolumeFlow.FromStandardCubicMetersPerHour(double.CreateChecked(value));
+                => StandardVolumeFlow.FromStandardCubicMetersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => StandardVolumeFlow.FromStandardCubicMetersPerHour(value.ToDouble(null));
+                => StandardVolumeFlow.FromStandardCubicMetersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerMinute(double)" />
+            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerMinute(QuantityValue)" />
             public StandardVolumeFlow StandardCubicMetersPerMinute
 #if NET7_0_OR_GREATER
-                => StandardVolumeFlow.FromStandardCubicMetersPerMinute(double.CreateChecked(value));
+                => StandardVolumeFlow.FromStandardCubicMetersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => StandardVolumeFlow.FromStandardCubicMetersPerMinute(value.ToDouble(null));
+                => StandardVolumeFlow.FromStandardCubicMetersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerSecond(double)" />
+            /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerSecond(QuantityValue)" />
             public StandardVolumeFlow StandardCubicMetersPerSecond
 #if NET7_0_OR_GREATER
-                => StandardVolumeFlow.FromStandardCubicMetersPerSecond(double.CreateChecked(value));
+                => StandardVolumeFlow.FromStandardCubicMetersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => StandardVolumeFlow.FromStandardCubicMetersPerSecond(value.ToDouble(null));
+                => StandardVolumeFlow.FromStandardCubicMetersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="StandardVolumeFlow.FromStandardLitersPerMinute(double)" />
+            /// <inheritdoc cref="StandardVolumeFlow.FromStandardLitersPerMinute(QuantityValue)" />
             public StandardVolumeFlow StandardLitersPerMinute
 #if NET7_0_OR_GREATER
-                => StandardVolumeFlow.FromStandardLitersPerMinute(double.CreateChecked(value));
+                => StandardVolumeFlow.FromStandardLitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => StandardVolumeFlow.FromStandardLitersPerMinute(value.ToDouble(null));
+                => StandardVolumeFlow.FromStandardLitersPerMinute(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
index c8a51389e1..896e9a80c0 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
@@ -42,140 +42,140 @@ public static class NumberToTemperatureChangeRateExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(QuantityValue)" />
             public TemperatureChangeRate CentidegreesCelsiusPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(QuantityValue)" />
             public TemperatureChangeRate DecadegreesCelsiusPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(QuantityValue)" />
             public TemperatureChangeRate DecidegreesCelsiusPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerHour(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerHour(QuantityValue)" />
             public TemperatureChangeRate DegreesCelsiusPerHour
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDegreesCelsiusPerHour(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDegreesCelsiusPerHour(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDegreesCelsiusPerHour(value.ToDouble(null));
+                => TemperatureChangeRate.FromDegreesCelsiusPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerMinute(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerMinute(QuantityValue)" />
             public TemperatureChangeRate DegreesCelsiusPerMinute
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDegreesCelsiusPerMinute(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDegreesCelsiusPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDegreesCelsiusPerMinute(value.ToDouble(null));
+                => TemperatureChangeRate.FromDegreesCelsiusPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerSecond(QuantityValue)" />
             public TemperatureChangeRate DegreesCelsiusPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDegreesCelsiusPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDegreesCelsiusPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromDegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerHour(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerHour(QuantityValue)" />
             public TemperatureChangeRate DegreesFahrenheitPerHour
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDegreesFahrenheitPerHour(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDegreesFahrenheitPerHour(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDegreesFahrenheitPerHour(value.ToDouble(null));
+                => TemperatureChangeRate.FromDegreesFahrenheitPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerMinute(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerMinute(QuantityValue)" />
             public TemperatureChangeRate DegreesFahrenheitPerMinute
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDegreesFahrenheitPerMinute(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDegreesFahrenheitPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDegreesFahrenheitPerMinute(value.ToDouble(null));
+                => TemperatureChangeRate.FromDegreesFahrenheitPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerSecond(QuantityValue)" />
             public TemperatureChangeRate DegreesFahrenheitPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDegreesFahrenheitPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDegreesFahrenheitPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDegreesFahrenheitPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromDegreesFahrenheitPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerHour(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerHour(QuantityValue)" />
             public TemperatureChangeRate DegreesKelvinPerHour
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDegreesKelvinPerHour(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDegreesKelvinPerHour(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDegreesKelvinPerHour(value.ToDouble(null));
+                => TemperatureChangeRate.FromDegreesKelvinPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerMinute(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerMinute(QuantityValue)" />
             public TemperatureChangeRate DegreesKelvinPerMinute
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDegreesKelvinPerMinute(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDegreesKelvinPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDegreesKelvinPerMinute(value.ToDouble(null));
+                => TemperatureChangeRate.FromDegreesKelvinPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerSecond(QuantityValue)" />
             public TemperatureChangeRate DegreesKelvinPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromDegreesKelvinPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromDegreesKelvinPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromDegreesKelvinPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromDegreesKelvinPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(QuantityValue)" />
             public TemperatureChangeRate HectodegreesCelsiusPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(QuantityValue)" />
             public TemperatureChangeRate KilodegreesCelsiusPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(QuantityValue)" />
             public TemperatureChangeRate MicrodegreesCelsiusPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(QuantityValue)" />
             public TemperatureChangeRate MillidegreesCelsiusPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(double)" />
+            /// <inheritdoc cref="TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(QuantityValue)" />
             public TemperatureChangeRate NanodegreesCelsiusPerSecond
 #if NET7_0_OR_GREATER
-                => TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(double.CreateChecked(value));
+                => TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(value.ToDouble(null));
+                => TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
index e7f019d3be..b22010b719 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
@@ -42,76 +42,76 @@ public static class NumberToTemperatureDeltaExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="TemperatureDelta.FromDegreesCelsius(double)" />
+            /// <inheritdoc cref="TemperatureDelta.FromDegreesCelsius(QuantityValue)" />
             public TemperatureDelta DegreesCelsius
 #if NET7_0_OR_GREATER
-                => TemperatureDelta.FromDegreesCelsius(double.CreateChecked(value));
+                => TemperatureDelta.FromDegreesCelsius(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureDelta.FromDegreesCelsius(value.ToDouble(null));
+                => TemperatureDelta.FromDegreesCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureDelta.FromDegreesDelisle(double)" />
+            /// <inheritdoc cref="TemperatureDelta.FromDegreesDelisle(QuantityValue)" />
             public TemperatureDelta DegreesDelisle
 #if NET7_0_OR_GREATER
-                => TemperatureDelta.FromDegreesDelisle(double.CreateChecked(value));
+                => TemperatureDelta.FromDegreesDelisle(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureDelta.FromDegreesDelisle(value.ToDouble(null));
+                => TemperatureDelta.FromDegreesDelisle(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureDelta.FromDegreesFahrenheit(double)" />
+            /// <inheritdoc cref="TemperatureDelta.FromDegreesFahrenheit(QuantityValue)" />
             public TemperatureDelta DegreesFahrenheit
 #if NET7_0_OR_GREATER
-                => TemperatureDelta.FromDegreesFahrenheit(double.CreateChecked(value));
+                => TemperatureDelta.FromDegreesFahrenheit(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureDelta.FromDegreesFahrenheit(value.ToDouble(null));
+                => TemperatureDelta.FromDegreesFahrenheit(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureDelta.FromDegreesNewton(double)" />
+            /// <inheritdoc cref="TemperatureDelta.FromDegreesNewton(QuantityValue)" />
             public TemperatureDelta DegreesNewton
 #if NET7_0_OR_GREATER
-                => TemperatureDelta.FromDegreesNewton(double.CreateChecked(value));
+                => TemperatureDelta.FromDegreesNewton(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureDelta.FromDegreesNewton(value.ToDouble(null));
+                => TemperatureDelta.FromDegreesNewton(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureDelta.FromDegreesRankine(double)" />
+            /// <inheritdoc cref="TemperatureDelta.FromDegreesRankine(QuantityValue)" />
             public TemperatureDelta DegreesRankine
 #if NET7_0_OR_GREATER
-                => TemperatureDelta.FromDegreesRankine(double.CreateChecked(value));
+                => TemperatureDelta.FromDegreesRankine(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureDelta.FromDegreesRankine(value.ToDouble(null));
+                => TemperatureDelta.FromDegreesRankine(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureDelta.FromDegreesReaumur(double)" />
+            /// <inheritdoc cref="TemperatureDelta.FromDegreesReaumur(QuantityValue)" />
             public TemperatureDelta DegreesReaumur
 #if NET7_0_OR_GREATER
-                => TemperatureDelta.FromDegreesReaumur(double.CreateChecked(value));
+                => TemperatureDelta.FromDegreesReaumur(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureDelta.FromDegreesReaumur(value.ToDouble(null));
+                => TemperatureDelta.FromDegreesReaumur(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureDelta.FromDegreesRoemer(double)" />
+            /// <inheritdoc cref="TemperatureDelta.FromDegreesRoemer(QuantityValue)" />
             public TemperatureDelta DegreesRoemer
 #if NET7_0_OR_GREATER
-                => TemperatureDelta.FromDegreesRoemer(double.CreateChecked(value));
+                => TemperatureDelta.FromDegreesRoemer(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureDelta.FromDegreesRoemer(value.ToDouble(null));
+                => TemperatureDelta.FromDegreesRoemer(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureDelta.FromKelvins(double)" />
+            /// <inheritdoc cref="TemperatureDelta.FromKelvins(QuantityValue)" />
             public TemperatureDelta Kelvins
 #if NET7_0_OR_GREATER
-                => TemperatureDelta.FromKelvins(double.CreateChecked(value));
+                => TemperatureDelta.FromKelvins(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureDelta.FromKelvins(value.ToDouble(null));
+                => TemperatureDelta.FromKelvins(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureDelta.FromMillidegreesCelsius(double)" />
+            /// <inheritdoc cref="TemperatureDelta.FromMillidegreesCelsius(QuantityValue)" />
             public TemperatureDelta MillidegreesCelsius
 #if NET7_0_OR_GREATER
-                => TemperatureDelta.FromMillidegreesCelsius(double.CreateChecked(value));
+                => TemperatureDelta.FromMillidegreesCelsius(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureDelta.FromMillidegreesCelsius(value.ToDouble(null));
+                => TemperatureDelta.FromMillidegreesCelsius(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureExtensions.g.cs
index 9fb7dbb94b..6f5958166a 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureExtensions.g.cs
@@ -42,84 +42,84 @@ public static class NumberToTemperatureExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Temperature.FromDegreesCelsius(double)" />
+            /// <inheritdoc cref="Temperature.FromDegreesCelsius(QuantityValue)" />
             public Temperature DegreesCelsius
 #if NET7_0_OR_GREATER
-                => Temperature.FromDegreesCelsius(double.CreateChecked(value));
+                => Temperature.FromDegreesCelsius(QuantityValue.CreateChecked(value));
 #else
-                => Temperature.FromDegreesCelsius(value.ToDouble(null));
+                => Temperature.FromDegreesCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Temperature.FromDegreesDelisle(double)" />
+            /// <inheritdoc cref="Temperature.FromDegreesDelisle(QuantityValue)" />
             public Temperature DegreesDelisle
 #if NET7_0_OR_GREATER
-                => Temperature.FromDegreesDelisle(double.CreateChecked(value));
+                => Temperature.FromDegreesDelisle(QuantityValue.CreateChecked(value));
 #else
-                => Temperature.FromDegreesDelisle(value.ToDouble(null));
+                => Temperature.FromDegreesDelisle(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Temperature.FromDegreesFahrenheit(double)" />
+            /// <inheritdoc cref="Temperature.FromDegreesFahrenheit(QuantityValue)" />
             public Temperature DegreesFahrenheit
 #if NET7_0_OR_GREATER
-                => Temperature.FromDegreesFahrenheit(double.CreateChecked(value));
+                => Temperature.FromDegreesFahrenheit(QuantityValue.CreateChecked(value));
 #else
-                => Temperature.FromDegreesFahrenheit(value.ToDouble(null));
+                => Temperature.FromDegreesFahrenheit(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Temperature.FromDegreesNewton(double)" />
+            /// <inheritdoc cref="Temperature.FromDegreesNewton(QuantityValue)" />
             public Temperature DegreesNewton
 #if NET7_0_OR_GREATER
-                => Temperature.FromDegreesNewton(double.CreateChecked(value));
+                => Temperature.FromDegreesNewton(QuantityValue.CreateChecked(value));
 #else
-                => Temperature.FromDegreesNewton(value.ToDouble(null));
+                => Temperature.FromDegreesNewton(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Temperature.FromDegreesRankine(double)" />
+            /// <inheritdoc cref="Temperature.FromDegreesRankine(QuantityValue)" />
             public Temperature DegreesRankine
 #if NET7_0_OR_GREATER
-                => Temperature.FromDegreesRankine(double.CreateChecked(value));
+                => Temperature.FromDegreesRankine(QuantityValue.CreateChecked(value));
 #else
-                => Temperature.FromDegreesRankine(value.ToDouble(null));
+                => Temperature.FromDegreesRankine(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Temperature.FromDegreesReaumur(double)" />
+            /// <inheritdoc cref="Temperature.FromDegreesReaumur(QuantityValue)" />
             public Temperature DegreesReaumur
 #if NET7_0_OR_GREATER
-                => Temperature.FromDegreesReaumur(double.CreateChecked(value));
+                => Temperature.FromDegreesReaumur(QuantityValue.CreateChecked(value));
 #else
-                => Temperature.FromDegreesReaumur(value.ToDouble(null));
+                => Temperature.FromDegreesReaumur(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Temperature.FromDegreesRoemer(double)" />
+            /// <inheritdoc cref="Temperature.FromDegreesRoemer(QuantityValue)" />
             public Temperature DegreesRoemer
 #if NET7_0_OR_GREATER
-                => Temperature.FromDegreesRoemer(double.CreateChecked(value));
+                => Temperature.FromDegreesRoemer(QuantityValue.CreateChecked(value));
 #else
-                => Temperature.FromDegreesRoemer(value.ToDouble(null));
+                => Temperature.FromDegreesRoemer(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Temperature.FromKelvins(double)" />
+            /// <inheritdoc cref="Temperature.FromKelvins(QuantityValue)" />
             public Temperature Kelvins
 #if NET7_0_OR_GREATER
-                => Temperature.FromKelvins(double.CreateChecked(value));
+                => Temperature.FromKelvins(QuantityValue.CreateChecked(value));
 #else
-                => Temperature.FromKelvins(value.ToDouble(null));
+                => Temperature.FromKelvins(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Temperature.FromMillidegreesCelsius(double)" />
+            /// <inheritdoc cref="Temperature.FromMillidegreesCelsius(QuantityValue)" />
             public Temperature MillidegreesCelsius
 #if NET7_0_OR_GREATER
-                => Temperature.FromMillidegreesCelsius(double.CreateChecked(value));
+                => Temperature.FromMillidegreesCelsius(QuantityValue.CreateChecked(value));
 #else
-                => Temperature.FromMillidegreesCelsius(value.ToDouble(null));
+                => Temperature.FromMillidegreesCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Temperature.FromSolarTemperatures(double)" />
+            /// <inheritdoc cref="Temperature.FromSolarTemperatures(QuantityValue)" />
             public Temperature SolarTemperatures
 #if NET7_0_OR_GREATER
-                => Temperature.FromSolarTemperatures(double.CreateChecked(value));
+                => Temperature.FromSolarTemperatures(QuantityValue.CreateChecked(value));
 #else
-                => Temperature.FromSolarTemperatures(value.ToDouble(null));
+                => Temperature.FromSolarTemperatures(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs
index 073efe31f7..e8ec8be792 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs
@@ -42,36 +42,36 @@ public static class NumberToTemperatureGradientExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerKilometer(double)" />
+            /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerKilometer(QuantityValue)" />
             public TemperatureGradient DegreesCelsiusPerKilometer
 #if NET7_0_OR_GREATER
-                => TemperatureGradient.FromDegreesCelsiusPerKilometer(double.CreateChecked(value));
+                => TemperatureGradient.FromDegreesCelsiusPerKilometer(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureGradient.FromDegreesCelsiusPerKilometer(value.ToDouble(null));
+                => TemperatureGradient.FromDegreesCelsiusPerKilometer(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerMeter(double)" />
+            /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerMeter(QuantityValue)" />
             public TemperatureGradient DegreesCelsiusPerMeter
 #if NET7_0_OR_GREATER
-                => TemperatureGradient.FromDegreesCelsiusPerMeter(double.CreateChecked(value));
+                => TemperatureGradient.FromDegreesCelsiusPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureGradient.FromDegreesCelsiusPerMeter(value.ToDouble(null));
+                => TemperatureGradient.FromDegreesCelsiusPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureGradient.FromDegreesFahrenheitPerFoot(double)" />
+            /// <inheritdoc cref="TemperatureGradient.FromDegreesFahrenheitPerFoot(QuantityValue)" />
             public TemperatureGradient DegreesFahrenheitPerFoot
 #if NET7_0_OR_GREATER
-                => TemperatureGradient.FromDegreesFahrenheitPerFoot(double.CreateChecked(value));
+                => TemperatureGradient.FromDegreesFahrenheitPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureGradient.FromDegreesFahrenheitPerFoot(value.ToDouble(null));
+                => TemperatureGradient.FromDegreesFahrenheitPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="TemperatureGradient.FromKelvinsPerMeter(double)" />
+            /// <inheritdoc cref="TemperatureGradient.FromKelvinsPerMeter(QuantityValue)" />
             public TemperatureGradient KelvinsPerMeter
 #if NET7_0_OR_GREATER
-                => TemperatureGradient.FromKelvinsPerMeter(double.CreateChecked(value));
+                => TemperatureGradient.FromKelvinsPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => TemperatureGradient.FromKelvinsPerMeter(value.ToDouble(null));
+                => TemperatureGradient.FromKelvinsPerMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalConductivityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
index c3b662365a..bb1ee537dd 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
@@ -42,20 +42,28 @@ public static class NumberToThermalConductivityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ThermalConductivity.FromBtusPerHourFootFahrenheit(double)" />
+            /// <inheritdoc cref="ThermalConductivity.FromBtusPerHourFootFahrenheit(QuantityValue)" />
             public ThermalConductivity BtusPerHourFootFahrenheit
 #if NET7_0_OR_GREATER
-                => ThermalConductivity.FromBtusPerHourFootFahrenheit(double.CreateChecked(value));
+                => ThermalConductivity.FromBtusPerHourFootFahrenheit(QuantityValue.CreateChecked(value));
 #else
-                => ThermalConductivity.FromBtusPerHourFootFahrenheit(value.ToDouble(null));
+                => ThermalConductivity.FromBtusPerHourFootFahrenheit(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ThermalConductivity.FromWattsPerMeterKelvin(double)" />
+            /// <inheritdoc cref="ThermalConductivity.FromBtusPerSecondInchFahrenheit(QuantityValue)" />
+            public ThermalConductivity BtusPerSecondInchFahrenheit
+#if NET7_0_OR_GREATER
+                => ThermalConductivity.FromBtusPerSecondInchFahrenheit(QuantityValue.CreateChecked(value));
+#else
+                => ThermalConductivity.FromBtusPerSecondInchFahrenheit(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="ThermalConductivity.FromWattsPerMeterKelvin(QuantityValue)" />
             public ThermalConductivity WattsPerMeterKelvin
 #if NET7_0_OR_GREATER
-                => ThermalConductivity.FromWattsPerMeterKelvin(double.CreateChecked(value));
+                => ThermalConductivity.FromWattsPerMeterKelvin(QuantityValue.CreateChecked(value));
 #else
-                => ThermalConductivity.FromWattsPerMeterKelvin(value.ToDouble(null));
+                => ThermalConductivity.FromWattsPerMeterKelvin(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs
index 5298a28686..1ffc83b0cd 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs
@@ -42,60 +42,60 @@ public static class NumberToThermalInsulanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(double)" />
+            /// <inheritdoc cref="ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(QuantityValue)" />
             public ThermalInsulance HourSquareFeetDegreesFahrenheitPerBtu
 #if NET7_0_OR_GREATER
-                => ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(double.CreateChecked(value));
+                => ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(QuantityValue.CreateChecked(value));
 #else
-                => ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(value.ToDouble(null));
+                => ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double)" />
+            /// <inheritdoc cref="ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(QuantityValue)" />
             public ThermalInsulance SquareCentimeterHourDegreesCelsiusPerKilocalorie
 #if NET7_0_OR_GREATER
-                => ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double.CreateChecked(value));
+                => ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(QuantityValue.CreateChecked(value));
 #else
-                => ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(value.ToDouble(null));
+                => ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(double)" />
+            /// <inheritdoc cref="ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(QuantityValue)" />
             public ThermalInsulance SquareCentimeterKelvinsPerWatt
 #if NET7_0_OR_GREATER
-                => ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(double.CreateChecked(value));
+                => ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(QuantityValue.CreateChecked(value));
 #else
-                => ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(value.ToDouble(null));
+                => ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(double)" />
+            /// <inheritdoc cref="ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(QuantityValue)" />
             public ThermalInsulance SquareMeterDegreesCelsiusPerWatt
 #if NET7_0_OR_GREATER
-                => ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(double.CreateChecked(value));
+                => ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(QuantityValue.CreateChecked(value));
 #else
-                => ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(value.ToDouble(null));
+                => ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(double)" />
+            /// <inheritdoc cref="ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(QuantityValue)" />
             public ThermalInsulance SquareMeterKelvinsPerKilowatt
 #if NET7_0_OR_GREATER
-                => ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(double.CreateChecked(value));
+                => ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(QuantityValue.CreateChecked(value));
 #else
-                => ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(value.ToDouble(null));
+                => ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ThermalInsulance.FromSquareMeterKelvinsPerWatt(double)" />
+            /// <inheritdoc cref="ThermalInsulance.FromSquareMeterKelvinsPerWatt(QuantityValue)" />
             public ThermalInsulance SquareMeterKelvinsPerWatt
 #if NET7_0_OR_GREATER
-                => ThermalInsulance.FromSquareMeterKelvinsPerWatt(double.CreateChecked(value));
+                => ThermalInsulance.FromSquareMeterKelvinsPerWatt(QuantityValue.CreateChecked(value));
 #else
-                => ThermalInsulance.FromSquareMeterKelvinsPerWatt(value.ToDouble(null));
+                => ThermalInsulance.FromSquareMeterKelvinsPerWatt(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(double)" />
+            /// <inheritdoc cref="ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(QuantityValue)" />
             public ThermalInsulance SquareMillimeterKelvinsPerWatt
 #if NET7_0_OR_GREATER
-                => ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(double.CreateChecked(value));
+                => ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(QuantityValue.CreateChecked(value));
 #else
-                => ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(value.ToDouble(null));
+                => ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalResistanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
index ff84646a34..e4fa077bc9 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
@@ -42,20 +42,20 @@ public static class NumberToThermalResistanceExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="ThermalResistance.FromDegreesCelsiusPerWatt(double)" />
+            /// <inheritdoc cref="ThermalResistance.FromDegreesCelsiusPerWatt(QuantityValue)" />
             public ThermalResistance DegreesCelsiusPerWatt
 #if NET7_0_OR_GREATER
-                => ThermalResistance.FromDegreesCelsiusPerWatt(double.CreateChecked(value));
+                => ThermalResistance.FromDegreesCelsiusPerWatt(QuantityValue.CreateChecked(value));
 #else
-                => ThermalResistance.FromDegreesCelsiusPerWatt(value.ToDouble(null));
+                => ThermalResistance.FromDegreesCelsiusPerWatt(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="ThermalResistance.FromKelvinsPerWatt(double)" />
+            /// <inheritdoc cref="ThermalResistance.FromKelvinsPerWatt(QuantityValue)" />
             public ThermalResistance KelvinsPerWatt
 #if NET7_0_OR_GREATER
-                => ThermalResistance.FromKelvinsPerWatt(double.CreateChecked(value));
+                => ThermalResistance.FromKelvinsPerWatt(QuantityValue.CreateChecked(value));
 #else
-                => ThermalResistance.FromKelvinsPerWatt(value.ToDouble(null));
+                => ThermalResistance.FromKelvinsPerWatt(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs
index 1f146d4cbe..7bfc1cb974 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs
@@ -42,204 +42,220 @@ public static class NumberToTorqueExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Torque.FromGramForceCentimeters(double)" />
+            /// <inheritdoc cref="Torque.FromGramForceCentimeters(QuantityValue)" />
             public Torque GramForceCentimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromGramForceCentimeters(double.CreateChecked(value));
+                => Torque.FromGramForceCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromGramForceCentimeters(value.ToDouble(null));
+                => Torque.FromGramForceCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromGramForceMeters(double)" />
+            /// <inheritdoc cref="Torque.FromGramForceMeters(QuantityValue)" />
             public Torque GramForceMeters
 #if NET7_0_OR_GREATER
-                => Torque.FromGramForceMeters(double.CreateChecked(value));
+                => Torque.FromGramForceMeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromGramForceMeters(value.ToDouble(null));
+                => Torque.FromGramForceMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromGramForceMillimeters(double)" />
+            /// <inheritdoc cref="Torque.FromGramForceMillimeters(QuantityValue)" />
             public Torque GramForceMillimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromGramForceMillimeters(double.CreateChecked(value));
+                => Torque.FromGramForceMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromGramForceMillimeters(value.ToDouble(null));
+                => Torque.FromGramForceMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromKilogramForceCentimeters(double)" />
+            /// <inheritdoc cref="Torque.FromKilogramForceCentimeters(QuantityValue)" />
             public Torque KilogramForceCentimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromKilogramForceCentimeters(double.CreateChecked(value));
+                => Torque.FromKilogramForceCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromKilogramForceCentimeters(value.ToDouble(null));
+                => Torque.FromKilogramForceCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromKilogramForceMeters(double)" />
+            /// <inheritdoc cref="Torque.FromKilogramForceMeters(QuantityValue)" />
             public Torque KilogramForceMeters
 #if NET7_0_OR_GREATER
-                => Torque.FromKilogramForceMeters(double.CreateChecked(value));
+                => Torque.FromKilogramForceMeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromKilogramForceMeters(value.ToDouble(null));
+                => Torque.FromKilogramForceMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromKilogramForceMillimeters(double)" />
+            /// <inheritdoc cref="Torque.FromKilogramForceMillimeters(QuantityValue)" />
             public Torque KilogramForceMillimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromKilogramForceMillimeters(double.CreateChecked(value));
+                => Torque.FromKilogramForceMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromKilogramForceMillimeters(value.ToDouble(null));
+                => Torque.FromKilogramForceMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromKilonewtonCentimeters(double)" />
+            /// <inheritdoc cref="Torque.FromKilonewtonCentimeters(QuantityValue)" />
             public Torque KilonewtonCentimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromKilonewtonCentimeters(double.CreateChecked(value));
+                => Torque.FromKilonewtonCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromKilonewtonCentimeters(value.ToDouble(null));
+                => Torque.FromKilonewtonCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromKilonewtonMeters(double)" />
+            /// <inheritdoc cref="Torque.FromKilonewtonMeters(QuantityValue)" />
             public Torque KilonewtonMeters
 #if NET7_0_OR_GREATER
-                => Torque.FromKilonewtonMeters(double.CreateChecked(value));
+                => Torque.FromKilonewtonMeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromKilonewtonMeters(value.ToDouble(null));
+                => Torque.FromKilonewtonMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromKilonewtonMillimeters(double)" />
+            /// <inheritdoc cref="Torque.FromKilonewtonMillimeters(QuantityValue)" />
             public Torque KilonewtonMillimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromKilonewtonMillimeters(double.CreateChecked(value));
+                => Torque.FromKilonewtonMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromKilonewtonMillimeters(value.ToDouble(null));
+                => Torque.FromKilonewtonMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromKilopoundForceFeet(double)" />
+            /// <inheritdoc cref="Torque.FromKilopoundForceFeet(QuantityValue)" />
             public Torque KilopoundForceFeet
 #if NET7_0_OR_GREATER
-                => Torque.FromKilopoundForceFeet(double.CreateChecked(value));
+                => Torque.FromKilopoundForceFeet(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromKilopoundForceFeet(value.ToDouble(null));
+                => Torque.FromKilopoundForceFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromKilopoundForceInches(double)" />
+            /// <inheritdoc cref="Torque.FromKilopoundForceInches(QuantityValue)" />
             public Torque KilopoundForceInches
 #if NET7_0_OR_GREATER
-                => Torque.FromKilopoundForceInches(double.CreateChecked(value));
+                => Torque.FromKilopoundForceInches(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromKilopoundForceInches(value.ToDouble(null));
+                => Torque.FromKilopoundForceInches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromMeganewtonCentimeters(double)" />
+            /// <inheritdoc cref="Torque.FromMeganewtonCentimeters(QuantityValue)" />
             public Torque MeganewtonCentimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromMeganewtonCentimeters(double.CreateChecked(value));
+                => Torque.FromMeganewtonCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromMeganewtonCentimeters(value.ToDouble(null));
+                => Torque.FromMeganewtonCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromMeganewtonMeters(double)" />
+            /// <inheritdoc cref="Torque.FromMeganewtonMeters(QuantityValue)" />
             public Torque MeganewtonMeters
 #if NET7_0_OR_GREATER
-                => Torque.FromMeganewtonMeters(double.CreateChecked(value));
+                => Torque.FromMeganewtonMeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromMeganewtonMeters(value.ToDouble(null));
+                => Torque.FromMeganewtonMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromMeganewtonMillimeters(double)" />
+            /// <inheritdoc cref="Torque.FromMeganewtonMillimeters(QuantityValue)" />
             public Torque MeganewtonMillimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromMeganewtonMillimeters(double.CreateChecked(value));
+                => Torque.FromMeganewtonMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromMeganewtonMillimeters(value.ToDouble(null));
+                => Torque.FromMeganewtonMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromMegapoundForceFeet(double)" />
+            /// <inheritdoc cref="Torque.FromMegapoundForceFeet(QuantityValue)" />
             public Torque MegapoundForceFeet
 #if NET7_0_OR_GREATER
-                => Torque.FromMegapoundForceFeet(double.CreateChecked(value));
+                => Torque.FromMegapoundForceFeet(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromMegapoundForceFeet(value.ToDouble(null));
+                => Torque.FromMegapoundForceFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromMegapoundForceInches(double)" />
+            /// <inheritdoc cref="Torque.FromMegapoundForceInches(QuantityValue)" />
             public Torque MegapoundForceInches
 #if NET7_0_OR_GREATER
-                => Torque.FromMegapoundForceInches(double.CreateChecked(value));
+                => Torque.FromMegapoundForceInches(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromMegapoundForceInches(value.ToDouble(null));
+                => Torque.FromMegapoundForceInches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromNewtonCentimeters(double)" />
+            /// <inheritdoc cref="Torque.FromNewtonCentimeters(QuantityValue)" />
             public Torque NewtonCentimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromNewtonCentimeters(double.CreateChecked(value));
+                => Torque.FromNewtonCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromNewtonCentimeters(value.ToDouble(null));
+                => Torque.FromNewtonCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromNewtonMeters(double)" />
+            /// <inheritdoc cref="Torque.FromNewtonMeters(QuantityValue)" />
             public Torque NewtonMeters
 #if NET7_0_OR_GREATER
-                => Torque.FromNewtonMeters(double.CreateChecked(value));
+                => Torque.FromNewtonMeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromNewtonMeters(value.ToDouble(null));
+                => Torque.FromNewtonMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromNewtonMillimeters(double)" />
+            /// <inheritdoc cref="Torque.FromNewtonMillimeters(QuantityValue)" />
             public Torque NewtonMillimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromNewtonMillimeters(double.CreateChecked(value));
+                => Torque.FromNewtonMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromNewtonMillimeters(value.ToDouble(null));
+                => Torque.FromNewtonMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromPoundalFeet(double)" />
+            /// <inheritdoc cref="Torque.FromOunceForceFeet(QuantityValue)" />
+            public Torque OunceForceFeet
+#if NET7_0_OR_GREATER
+                => Torque.FromOunceForceFeet(QuantityValue.CreateChecked(value));
+#else
+                => Torque.FromOunceForceFeet(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="Torque.FromOunceForceInches(QuantityValue)" />
+            public Torque OunceForceInches
+#if NET7_0_OR_GREATER
+                => Torque.FromOunceForceInches(QuantityValue.CreateChecked(value));
+#else
+                => Torque.FromOunceForceInches(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="Torque.FromPoundalFeet(QuantityValue)" />
             public Torque PoundalFeet
 #if NET7_0_OR_GREATER
-                => Torque.FromPoundalFeet(double.CreateChecked(value));
+                => Torque.FromPoundalFeet(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromPoundalFeet(value.ToDouble(null));
+                => Torque.FromPoundalFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromPoundForceFeet(double)" />
+            /// <inheritdoc cref="Torque.FromPoundForceFeet(QuantityValue)" />
             public Torque PoundForceFeet
 #if NET7_0_OR_GREATER
-                => Torque.FromPoundForceFeet(double.CreateChecked(value));
+                => Torque.FromPoundForceFeet(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromPoundForceFeet(value.ToDouble(null));
+                => Torque.FromPoundForceFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromPoundForceInches(double)" />
+            /// <inheritdoc cref="Torque.FromPoundForceInches(QuantityValue)" />
             public Torque PoundForceInches
 #if NET7_0_OR_GREATER
-                => Torque.FromPoundForceInches(double.CreateChecked(value));
+                => Torque.FromPoundForceInches(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromPoundForceInches(value.ToDouble(null));
+                => Torque.FromPoundForceInches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromTonneForceCentimeters(double)" />
+            /// <inheritdoc cref="Torque.FromTonneForceCentimeters(QuantityValue)" />
             public Torque TonneForceCentimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromTonneForceCentimeters(double.CreateChecked(value));
+                => Torque.FromTonneForceCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromTonneForceCentimeters(value.ToDouble(null));
+                => Torque.FromTonneForceCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromTonneForceMeters(double)" />
+            /// <inheritdoc cref="Torque.FromTonneForceMeters(QuantityValue)" />
             public Torque TonneForceMeters
 #if NET7_0_OR_GREATER
-                => Torque.FromTonneForceMeters(double.CreateChecked(value));
+                => Torque.FromTonneForceMeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromTonneForceMeters(value.ToDouble(null));
+                => Torque.FromTonneForceMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Torque.FromTonneForceMillimeters(double)" />
+            /// <inheritdoc cref="Torque.FromTonneForceMillimeters(QuantityValue)" />
             public Torque TonneForceMillimeters
 #if NET7_0_OR_GREATER
-                => Torque.FromTonneForceMillimeters(double.CreateChecked(value));
+                => Torque.FromTonneForceMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => Torque.FromTonneForceMillimeters(value.ToDouble(null));
+                => Torque.FromTonneForceMillimeters(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTurbidityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTurbidityExtensions.g.cs
index 2baa5b9556..255c673a4a 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTurbidityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTurbidityExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToTurbidityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Turbidity.FromNTU(double)" />
+            /// <inheritdoc cref="Turbidity.FromNTU(QuantityValue)" />
             public Turbidity NTU
 #if NET7_0_OR_GREATER
-                => Turbidity.FromNTU(double.CreateChecked(value));
+                => Turbidity.FromNTU(QuantityValue.CreateChecked(value));
 #else
-                => Turbidity.FromNTU(value.ToDouble(null));
+                => Turbidity.FromNTU(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVitaminAExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVitaminAExtensions.g.cs
index 680e4b5632..571b4c3e7c 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVitaminAExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVitaminAExtensions.g.cs
@@ -42,12 +42,12 @@ public static class NumberToVitaminAExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="VitaminA.FromInternationalUnits(double)" />
+            /// <inheritdoc cref="VitaminA.FromInternationalUnits(QuantityValue)" />
             public VitaminA InternationalUnits
 #if NET7_0_OR_GREATER
-                => VitaminA.FromInternationalUnits(double.CreateChecked(value));
+                => VitaminA.FromInternationalUnits(QuantityValue.CreateChecked(value));
 #else
-                => VitaminA.FromInternationalUnits(value.ToDouble(null));
+                => VitaminA.FromInternationalUnits(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
index cf0bb7207c..dd215874bb 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
@@ -42,164 +42,164 @@ public static class NumberToVolumeConcentrationExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerLiter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerLiter(QuantityValue)" />
             public VolumeConcentration CentilitersPerLiter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromCentilitersPerLiter(double.CreateChecked(value));
+                => VolumeConcentration.FromCentilitersPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromCentilitersPerLiter(value.ToDouble(null));
+                => VolumeConcentration.FromCentilitersPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerMilliliter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerMilliliter(QuantityValue)" />
             public VolumeConcentration CentilitersPerMilliliter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromCentilitersPerMilliliter(double.CreateChecked(value));
+                => VolumeConcentration.FromCentilitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromCentilitersPerMilliliter(value.ToDouble(null));
+                => VolumeConcentration.FromCentilitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerLiter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerLiter(QuantityValue)" />
             public VolumeConcentration DecilitersPerLiter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromDecilitersPerLiter(double.CreateChecked(value));
+                => VolumeConcentration.FromDecilitersPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromDecilitersPerLiter(value.ToDouble(null));
+                => VolumeConcentration.FromDecilitersPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerMilliliter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerMilliliter(QuantityValue)" />
             public VolumeConcentration DecilitersPerMilliliter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromDecilitersPerMilliliter(double.CreateChecked(value));
+                => VolumeConcentration.FromDecilitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromDecilitersPerMilliliter(value.ToDouble(null));
+                => VolumeConcentration.FromDecilitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromDecimalFractions(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromDecimalFractions(QuantityValue)" />
             public VolumeConcentration DecimalFractions
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromDecimalFractions(double.CreateChecked(value));
+                => VolumeConcentration.FromDecimalFractions(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromDecimalFractions(value.ToDouble(null));
+                => VolumeConcentration.FromDecimalFractions(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromLitersPerLiter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromLitersPerLiter(QuantityValue)" />
             public VolumeConcentration LitersPerLiter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromLitersPerLiter(double.CreateChecked(value));
+                => VolumeConcentration.FromLitersPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromLitersPerLiter(value.ToDouble(null));
+                => VolumeConcentration.FromLitersPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromLitersPerMilliliter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromLitersPerMilliliter(QuantityValue)" />
             public VolumeConcentration LitersPerMilliliter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromLitersPerMilliliter(double.CreateChecked(value));
+                => VolumeConcentration.FromLitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromLitersPerMilliliter(value.ToDouble(null));
+                => VolumeConcentration.FromLitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerLiter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerLiter(QuantityValue)" />
             public VolumeConcentration MicrolitersPerLiter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromMicrolitersPerLiter(double.CreateChecked(value));
+                => VolumeConcentration.FromMicrolitersPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromMicrolitersPerLiter(value.ToDouble(null));
+                => VolumeConcentration.FromMicrolitersPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerMilliliter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerMilliliter(QuantityValue)" />
             public VolumeConcentration MicrolitersPerMilliliter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromMicrolitersPerMilliliter(double.CreateChecked(value));
+                => VolumeConcentration.FromMicrolitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromMicrolitersPerMilliliter(value.ToDouble(null));
+                => VolumeConcentration.FromMicrolitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerLiter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerLiter(QuantityValue)" />
             public VolumeConcentration MillilitersPerLiter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromMillilitersPerLiter(double.CreateChecked(value));
+                => VolumeConcentration.FromMillilitersPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromMillilitersPerLiter(value.ToDouble(null));
+                => VolumeConcentration.FromMillilitersPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerMilliliter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerMilliliter(QuantityValue)" />
             public VolumeConcentration MillilitersPerMilliliter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromMillilitersPerMilliliter(double.CreateChecked(value));
+                => VolumeConcentration.FromMillilitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromMillilitersPerMilliliter(value.ToDouble(null));
+                => VolumeConcentration.FromMillilitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerLiter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerLiter(QuantityValue)" />
             public VolumeConcentration NanolitersPerLiter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromNanolitersPerLiter(double.CreateChecked(value));
+                => VolumeConcentration.FromNanolitersPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromNanolitersPerLiter(value.ToDouble(null));
+                => VolumeConcentration.FromNanolitersPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerMilliliter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerMilliliter(QuantityValue)" />
             public VolumeConcentration NanolitersPerMilliliter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromNanolitersPerMilliliter(double.CreateChecked(value));
+                => VolumeConcentration.FromNanolitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromNanolitersPerMilliliter(value.ToDouble(null));
+                => VolumeConcentration.FromNanolitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromPartsPerBillion(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromPartsPerBillion(QuantityValue)" />
             public VolumeConcentration PartsPerBillion
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromPartsPerBillion(double.CreateChecked(value));
+                => VolumeConcentration.FromPartsPerBillion(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromPartsPerBillion(value.ToDouble(null));
+                => VolumeConcentration.FromPartsPerBillion(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromPartsPerMillion(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromPartsPerMillion(QuantityValue)" />
             public VolumeConcentration PartsPerMillion
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromPartsPerMillion(double.CreateChecked(value));
+                => VolumeConcentration.FromPartsPerMillion(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromPartsPerMillion(value.ToDouble(null));
+                => VolumeConcentration.FromPartsPerMillion(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromPartsPerThousand(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromPartsPerThousand(QuantityValue)" />
             public VolumeConcentration PartsPerThousand
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromPartsPerThousand(double.CreateChecked(value));
+                => VolumeConcentration.FromPartsPerThousand(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromPartsPerThousand(value.ToDouble(null));
+                => VolumeConcentration.FromPartsPerThousand(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromPartsPerTrillion(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromPartsPerTrillion(QuantityValue)" />
             public VolumeConcentration PartsPerTrillion
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromPartsPerTrillion(double.CreateChecked(value));
+                => VolumeConcentration.FromPartsPerTrillion(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromPartsPerTrillion(value.ToDouble(null));
+                => VolumeConcentration.FromPartsPerTrillion(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromPercent(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromPercent(QuantityValue)" />
             public VolumeConcentration Percent
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromPercent(double.CreateChecked(value));
+                => VolumeConcentration.FromPercent(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromPercent(value.ToDouble(null));
+                => VolumeConcentration.FromPercent(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerLiter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerLiter(QuantityValue)" />
             public VolumeConcentration PicolitersPerLiter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromPicolitersPerLiter(double.CreateChecked(value));
+                => VolumeConcentration.FromPicolitersPerLiter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromPicolitersPerLiter(value.ToDouble(null));
+                => VolumeConcentration.FromPicolitersPerLiter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerMilliliter(double)" />
+            /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerMilliliter(QuantityValue)" />
             public VolumeConcentration PicolitersPerMilliliter
 #if NET7_0_OR_GREATER
-                => VolumeConcentration.FromPicolitersPerMilliliter(double.CreateChecked(value));
+                => VolumeConcentration.FromPicolitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeConcentration.FromPicolitersPerMilliliter(value.ToDouble(null));
+                => VolumeConcentration.FromPicolitersPerMilliliter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeExtensions.g.cs
index 4d20b2f1a6..f0450b1865 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeExtensions.g.cs
@@ -42,444 +42,436 @@ public static class NumberToVolumeExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="Volume.FromAcreFeet(double)" />
+            /// <inheritdoc cref="Volume.FromAcreFeet(QuantityValue)" />
             public Volume AcreFeet
 #if NET7_0_OR_GREATER
-                => Volume.FromAcreFeet(double.CreateChecked(value));
+                => Volume.FromAcreFeet(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromAcreFeet(value.ToDouble(null));
+                => Volume.FromAcreFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromAuTablespoons(double)" />
+            /// <inheritdoc cref="Volume.FromAuTablespoons(QuantityValue)" />
             public Volume AuTablespoons
 #if NET7_0_OR_GREATER
-                => Volume.FromAuTablespoons(double.CreateChecked(value));
+                => Volume.FromAuTablespoons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromAuTablespoons(value.ToDouble(null));
+                => Volume.FromAuTablespoons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromBoardFeet(double)" />
+            /// <inheritdoc cref="Volume.FromBoardFeet(QuantityValue)" />
             public Volume BoardFeet
 #if NET7_0_OR_GREATER
-                => Volume.FromBoardFeet(double.CreateChecked(value));
+                => Volume.FromBoardFeet(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromBoardFeet(value.ToDouble(null));
+                => Volume.FromBoardFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCentiliters(double)" />
+            /// <inheritdoc cref="Volume.FromCentiliters(QuantityValue)" />
             public Volume Centiliters
 #if NET7_0_OR_GREATER
-                => Volume.FromCentiliters(double.CreateChecked(value));
+                => Volume.FromCentiliters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCentiliters(value.ToDouble(null));
+                => Volume.FromCentiliters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicCentimeters(double)" />
+            /// <inheritdoc cref="Volume.FromCubicCentimeters(QuantityValue)" />
             public Volume CubicCentimeters
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicCentimeters(double.CreateChecked(value));
+                => Volume.FromCubicCentimeters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicCentimeters(value.ToDouble(null));
+                => Volume.FromCubicCentimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicDecimeters(double)" />
+            /// <inheritdoc cref="Volume.FromCubicDecimeters(QuantityValue)" />
             public Volume CubicDecimeters
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicDecimeters(double.CreateChecked(value));
+                => Volume.FromCubicDecimeters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicDecimeters(value.ToDouble(null));
+                => Volume.FromCubicDecimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicFeet(double)" />
+            /// <inheritdoc cref="Volume.FromCubicFeet(QuantityValue)" />
             public Volume CubicFeet
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicFeet(double.CreateChecked(value));
+                => Volume.FromCubicFeet(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicFeet(value.ToDouble(null));
+                => Volume.FromCubicFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicHectometers(double)" />
+            /// <inheritdoc cref="Volume.FromCubicHectometers(QuantityValue)" />
             public Volume CubicHectometers
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicHectometers(double.CreateChecked(value));
+                => Volume.FromCubicHectometers(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicHectometers(value.ToDouble(null));
+                => Volume.FromCubicHectometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicInches(double)" />
+            /// <inheritdoc cref="Volume.FromCubicInches(QuantityValue)" />
             public Volume CubicInches
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicInches(double.CreateChecked(value));
+                => Volume.FromCubicInches(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicInches(value.ToDouble(null));
+                => Volume.FromCubicInches(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicKilometers(double)" />
+            /// <inheritdoc cref="Volume.FromCubicKilometers(QuantityValue)" />
             public Volume CubicKilometers
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicKilometers(double.CreateChecked(value));
+                => Volume.FromCubicKilometers(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicKilometers(value.ToDouble(null));
+                => Volume.FromCubicKilometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicMeters(double)" />
+            /// <inheritdoc cref="Volume.FromCubicMeters(QuantityValue)" />
             public Volume CubicMeters
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicMeters(double.CreateChecked(value));
+                => Volume.FromCubicMeters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicMeters(value.ToDouble(null));
+                => Volume.FromCubicMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicMicrometers(double)" />
+            /// <inheritdoc cref="Volume.FromCubicMicrometers(QuantityValue)" />
             public Volume CubicMicrometers
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicMicrometers(double.CreateChecked(value));
+                => Volume.FromCubicMicrometers(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicMicrometers(value.ToDouble(null));
+                => Volume.FromCubicMicrometers(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicMiles(double)" />
+            /// <inheritdoc cref="Volume.FromCubicMiles(QuantityValue)" />
             public Volume CubicMiles
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicMiles(double.CreateChecked(value));
+                => Volume.FromCubicMiles(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicMiles(value.ToDouble(null));
+                => Volume.FromCubicMiles(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicMillimeters(double)" />
+            /// <inheritdoc cref="Volume.FromCubicMillimeters(QuantityValue)" />
             public Volume CubicMillimeters
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicMillimeters(double.CreateChecked(value));
+                => Volume.FromCubicMillimeters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicMillimeters(value.ToDouble(null));
+                => Volume.FromCubicMillimeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromCubicYards(double)" />
+            /// <inheritdoc cref="Volume.FromCubicYards(QuantityValue)" />
             public Volume CubicYards
 #if NET7_0_OR_GREATER
-                => Volume.FromCubicYards(double.CreateChecked(value));
+                => Volume.FromCubicYards(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromCubicYards(value.ToDouble(null));
+                => Volume.FromCubicYards(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromDecaliters(double)" />
+            /// <inheritdoc cref="Volume.FromDecaliters(QuantityValue)" />
             public Volume Decaliters
 #if NET7_0_OR_GREATER
-                => Volume.FromDecaliters(double.CreateChecked(value));
+                => Volume.FromDecaliters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromDecaliters(value.ToDouble(null));
+                => Volume.FromDecaliters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromDecausGallons(double)" />
+            /// <inheritdoc cref="Volume.FromDecausGallons(QuantityValue)" />
             public Volume DecausGallons
 #if NET7_0_OR_GREATER
-                => Volume.FromDecausGallons(double.CreateChecked(value));
+                => Volume.FromDecausGallons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromDecausGallons(value.ToDouble(null));
+                => Volume.FromDecausGallons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromDeciliters(double)" />
+            /// <inheritdoc cref="Volume.FromDeciliters(QuantityValue)" />
             public Volume Deciliters
 #if NET7_0_OR_GREATER
-                => Volume.FromDeciliters(double.CreateChecked(value));
+                => Volume.FromDeciliters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromDeciliters(value.ToDouble(null));
+                => Volume.FromDeciliters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromDeciusGallons(double)" />
+            /// <inheritdoc cref="Volume.FromDeciusGallons(QuantityValue)" />
             public Volume DeciusGallons
 #if NET7_0_OR_GREATER
-                => Volume.FromDeciusGallons(double.CreateChecked(value));
+                => Volume.FromDeciusGallons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromDeciusGallons(value.ToDouble(null));
+                => Volume.FromDeciusGallons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromHectocubicFeet(double)" />
-            public Volume HectocubicFeet
-#if NET7_0_OR_GREATER
-                => Volume.FromHectocubicFeet(double.CreateChecked(value));
-#else
-                => Volume.FromHectocubicFeet(value.ToDouble(null));
-#endif
-
-            /// <inheritdoc cref="Volume.FromHectocubicMeters(double)" />
-            public Volume HectocubicMeters
+            /// <inheritdoc cref="Volume.FromHectoliters(QuantityValue)" />
+            public Volume Hectoliters
 #if NET7_0_OR_GREATER
-                => Volume.FromHectocubicMeters(double.CreateChecked(value));
+                => Volume.FromHectoliters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromHectocubicMeters(value.ToDouble(null));
+                => Volume.FromHectoliters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromHectoliters(double)" />
-            public Volume Hectoliters
+            /// <inheritdoc cref="Volume.FromHectousGallons(QuantityValue)" />
+            public Volume HectousGallons
 #if NET7_0_OR_GREATER
-                => Volume.FromHectoliters(double.CreateChecked(value));
+                => Volume.FromHectousGallons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromHectoliters(value.ToDouble(null));
+                => Volume.FromHectousGallons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromHectousGallons(double)" />
-            public Volume HectousGallons
+            /// <inheritdoc cref="Volume.FromHundredCubicFeet(QuantityValue)" />
+            public Volume HundredCubicFeet
 #if NET7_0_OR_GREATER
-                => Volume.FromHectousGallons(double.CreateChecked(value));
+                => Volume.FromHundredCubicFeet(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromHectousGallons(value.ToDouble(null));
+                => Volume.FromHundredCubicFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromImperialBeerBarrels(double)" />
+            /// <inheritdoc cref="Volume.FromImperialBeerBarrels(QuantityValue)" />
             public Volume ImperialBeerBarrels
 #if NET7_0_OR_GREATER
-                => Volume.FromImperialBeerBarrels(double.CreateChecked(value));
+                => Volume.FromImperialBeerBarrels(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromImperialBeerBarrels(value.ToDouble(null));
+                => Volume.FromImperialBeerBarrels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromImperialGallons(double)" />
+            /// <inheritdoc cref="Volume.FromImperialGallons(QuantityValue)" />
             public Volume ImperialGallons
 #if NET7_0_OR_GREATER
-                => Volume.FromImperialGallons(double.CreateChecked(value));
+                => Volume.FromImperialGallons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromImperialGallons(value.ToDouble(null));
+                => Volume.FromImperialGallons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromImperialOunces(double)" />
+            /// <inheritdoc cref="Volume.FromImperialOunces(QuantityValue)" />
             public Volume ImperialOunces
 #if NET7_0_OR_GREATER
-                => Volume.FromImperialOunces(double.CreateChecked(value));
+                => Volume.FromImperialOunces(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromImperialOunces(value.ToDouble(null));
+                => Volume.FromImperialOunces(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromImperialPints(double)" />
+            /// <inheritdoc cref="Volume.FromImperialPints(QuantityValue)" />
             public Volume ImperialPints
 #if NET7_0_OR_GREATER
-                => Volume.FromImperialPints(double.CreateChecked(value));
+                => Volume.FromImperialPints(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromImperialPints(value.ToDouble(null));
+                => Volume.FromImperialPints(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromImperialQuarts(double)" />
+            /// <inheritdoc cref="Volume.FromImperialQuarts(QuantityValue)" />
             public Volume ImperialQuarts
 #if NET7_0_OR_GREATER
-                => Volume.FromImperialQuarts(double.CreateChecked(value));
-#else
-                => Volume.FromImperialQuarts(value.ToDouble(null));
-#endif
-
-            /// <inheritdoc cref="Volume.FromKilocubicFeet(double)" />
-            public Volume KilocubicFeet
-#if NET7_0_OR_GREATER
-                => Volume.FromKilocubicFeet(double.CreateChecked(value));
-#else
-                => Volume.FromKilocubicFeet(value.ToDouble(null));
-#endif
-
-            /// <inheritdoc cref="Volume.FromKilocubicMeters(double)" />
-            public Volume KilocubicMeters
-#if NET7_0_OR_GREATER
-                => Volume.FromKilocubicMeters(double.CreateChecked(value));
+                => Volume.FromImperialQuarts(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromKilocubicMeters(value.ToDouble(null));
+                => Volume.FromImperialQuarts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromKiloimperialGallons(double)" />
+            /// <inheritdoc cref="Volume.FromKiloimperialGallons(QuantityValue)" />
             public Volume KiloimperialGallons
 #if NET7_0_OR_GREATER
-                => Volume.FromKiloimperialGallons(double.CreateChecked(value));
+                => Volume.FromKiloimperialGallons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromKiloimperialGallons(value.ToDouble(null));
+                => Volume.FromKiloimperialGallons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromKiloliters(double)" />
+            /// <inheritdoc cref="Volume.FromKiloliters(QuantityValue)" />
             public Volume Kiloliters
 #if NET7_0_OR_GREATER
-                => Volume.FromKiloliters(double.CreateChecked(value));
+                => Volume.FromKiloliters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromKiloliters(value.ToDouble(null));
+                => Volume.FromKiloliters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromKilousGallons(double)" />
+            /// <inheritdoc cref="Volume.FromKilousGallons(QuantityValue)" />
             public Volume KilousGallons
 #if NET7_0_OR_GREATER
-                => Volume.FromKilousGallons(double.CreateChecked(value));
+                => Volume.FromKilousGallons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromKilousGallons(value.ToDouble(null));
+                => Volume.FromKilousGallons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromLiters(double)" />
+            /// <inheritdoc cref="Volume.FromLiters(QuantityValue)" />
             public Volume Liters
 #if NET7_0_OR_GREATER
-                => Volume.FromLiters(double.CreateChecked(value));
+                => Volume.FromLiters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromLiters(value.ToDouble(null));
+                => Volume.FromLiters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromMegacubicFeet(double)" />
-            public Volume MegacubicFeet
-#if NET7_0_OR_GREATER
-                => Volume.FromMegacubicFeet(double.CreateChecked(value));
-#else
-                => Volume.FromMegacubicFeet(value.ToDouble(null));
-#endif
-
-            /// <inheritdoc cref="Volume.FromMegaimperialGallons(double)" />
+            /// <inheritdoc cref="Volume.FromMegaimperialGallons(QuantityValue)" />
             public Volume MegaimperialGallons
 #if NET7_0_OR_GREATER
-                => Volume.FromMegaimperialGallons(double.CreateChecked(value));
+                => Volume.FromMegaimperialGallons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromMegaimperialGallons(value.ToDouble(null));
+                => Volume.FromMegaimperialGallons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromMegaliters(double)" />
+            /// <inheritdoc cref="Volume.FromMegaliters(QuantityValue)" />
             public Volume Megaliters
 #if NET7_0_OR_GREATER
-                => Volume.FromMegaliters(double.CreateChecked(value));
+                => Volume.FromMegaliters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromMegaliters(value.ToDouble(null));
+                => Volume.FromMegaliters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromMegausGallons(double)" />
+            /// <inheritdoc cref="Volume.FromMegausGallons(QuantityValue)" />
             public Volume MegausGallons
 #if NET7_0_OR_GREATER
-                => Volume.FromMegausGallons(double.CreateChecked(value));
+                => Volume.FromMegausGallons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromMegausGallons(value.ToDouble(null));
+                => Volume.FromMegausGallons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromMetricCups(double)" />
+            /// <inheritdoc cref="Volume.FromMetricCups(QuantityValue)" />
             public Volume MetricCups
 #if NET7_0_OR_GREATER
-                => Volume.FromMetricCups(double.CreateChecked(value));
+                => Volume.FromMetricCups(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromMetricCups(value.ToDouble(null));
+                => Volume.FromMetricCups(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromMetricTablespoons(double)" />
+            /// <inheritdoc cref="Volume.FromMetricTablespoons(QuantityValue)" />
             public Volume MetricTablespoons
 #if NET7_0_OR_GREATER
-                => Volume.FromMetricTablespoons(double.CreateChecked(value));
+                => Volume.FromMetricTablespoons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromMetricTablespoons(value.ToDouble(null));
+                => Volume.FromMetricTablespoons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromMetricTeaspoons(double)" />
+            /// <inheritdoc cref="Volume.FromMetricTeaspoons(QuantityValue)" />
             public Volume MetricTeaspoons
 #if NET7_0_OR_GREATER
-                => Volume.FromMetricTeaspoons(double.CreateChecked(value));
+                => Volume.FromMetricTeaspoons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromMetricTeaspoons(value.ToDouble(null));
+                => Volume.FromMetricTeaspoons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromMicroliters(double)" />
+            /// <inheritdoc cref="Volume.FromMicroliters(QuantityValue)" />
             public Volume Microliters
 #if NET7_0_OR_GREATER
-                => Volume.FromMicroliters(double.CreateChecked(value));
+                => Volume.FromMicroliters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromMicroliters(value.ToDouble(null));
+                => Volume.FromMicroliters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromMilliliters(double)" />
+            /// <inheritdoc cref="Volume.FromMilliliters(QuantityValue)" />
             public Volume Milliliters
 #if NET7_0_OR_GREATER
-                => Volume.FromMilliliters(double.CreateChecked(value));
+                => Volume.FromMilliliters(QuantityValue.CreateChecked(value));
+#else
+                => Volume.FromMilliliters(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="Volume.FromMillionCubicFeet(QuantityValue)" />
+            public Volume MillionCubicFeet
+#if NET7_0_OR_GREATER
+                => Volume.FromMillionCubicFeet(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromMilliliters(value.ToDouble(null));
+                => Volume.FromMillionCubicFeet(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromNanoliters(double)" />
+            /// <inheritdoc cref="Volume.FromNanoliters(QuantityValue)" />
             public Volume Nanoliters
 #if NET7_0_OR_GREATER
-                => Volume.FromNanoliters(double.CreateChecked(value));
+                => Volume.FromNanoliters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromNanoliters(value.ToDouble(null));
+                => Volume.FromNanoliters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromOilBarrels(double)" />
+            /// <inheritdoc cref="Volume.FromOilBarrels(QuantityValue)" />
             public Volume OilBarrels
 #if NET7_0_OR_GREATER
-                => Volume.FromOilBarrels(double.CreateChecked(value));
+                => Volume.FromOilBarrels(QuantityValue.CreateChecked(value));
+#else
+                => Volume.FromOilBarrels(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="Volume.FromThousandCubicFeet(QuantityValue)" />
+            public Volume ThousandCubicFeet
+#if NET7_0_OR_GREATER
+                => Volume.FromThousandCubicFeet(QuantityValue.CreateChecked(value));
+#else
+                => Volume.FromThousandCubicFeet(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="Volume.FromThousandCubicMeters(QuantityValue)" />
+            public Volume ThousandCubicMeters
+#if NET7_0_OR_GREATER
+                => Volume.FromThousandCubicMeters(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromOilBarrels(value.ToDouble(null));
+                => Volume.FromThousandCubicMeters(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromUkTablespoons(double)" />
+            /// <inheritdoc cref="Volume.FromUkTablespoons(QuantityValue)" />
             public Volume UkTablespoons
 #if NET7_0_OR_GREATER
-                => Volume.FromUkTablespoons(double.CreateChecked(value));
+                => Volume.FromUkTablespoons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromUkTablespoons(value.ToDouble(null));
+                => Volume.FromUkTablespoons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromUsBeerBarrels(double)" />
+            /// <inheritdoc cref="Volume.FromUsBeerBarrels(QuantityValue)" />
             public Volume UsBeerBarrels
 #if NET7_0_OR_GREATER
-                => Volume.FromUsBeerBarrels(double.CreateChecked(value));
+                => Volume.FromUsBeerBarrels(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromUsBeerBarrels(value.ToDouble(null));
+                => Volume.FromUsBeerBarrels(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromUsCustomaryCups(double)" />
+            /// <inheritdoc cref="Volume.FromUsCustomaryCups(QuantityValue)" />
             public Volume UsCustomaryCups
 #if NET7_0_OR_GREATER
-                => Volume.FromUsCustomaryCups(double.CreateChecked(value));
+                => Volume.FromUsCustomaryCups(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromUsCustomaryCups(value.ToDouble(null));
+                => Volume.FromUsCustomaryCups(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromUsGallons(double)" />
+            /// <inheritdoc cref="Volume.FromUsGallons(QuantityValue)" />
             public Volume UsGallons
 #if NET7_0_OR_GREATER
-                => Volume.FromUsGallons(double.CreateChecked(value));
+                => Volume.FromUsGallons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromUsGallons(value.ToDouble(null));
+                => Volume.FromUsGallons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromUsLegalCups(double)" />
+            /// <inheritdoc cref="Volume.FromUsLegalCups(QuantityValue)" />
             public Volume UsLegalCups
 #if NET7_0_OR_GREATER
-                => Volume.FromUsLegalCups(double.CreateChecked(value));
+                => Volume.FromUsLegalCups(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromUsLegalCups(value.ToDouble(null));
+                => Volume.FromUsLegalCups(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromUsOunces(double)" />
+            /// <inheritdoc cref="Volume.FromUsOunces(QuantityValue)" />
             public Volume UsOunces
 #if NET7_0_OR_GREATER
-                => Volume.FromUsOunces(double.CreateChecked(value));
+                => Volume.FromUsOunces(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromUsOunces(value.ToDouble(null));
+                => Volume.FromUsOunces(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromUsPints(double)" />
+            /// <inheritdoc cref="Volume.FromUsPints(QuantityValue)" />
             public Volume UsPints
 #if NET7_0_OR_GREATER
-                => Volume.FromUsPints(double.CreateChecked(value));
+                => Volume.FromUsPints(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromUsPints(value.ToDouble(null));
+                => Volume.FromUsPints(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromUsQuarts(double)" />
+            /// <inheritdoc cref="Volume.FromUsQuarts(QuantityValue)" />
             public Volume UsQuarts
 #if NET7_0_OR_GREATER
-                => Volume.FromUsQuarts(double.CreateChecked(value));
+                => Volume.FromUsQuarts(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromUsQuarts(value.ToDouble(null));
+                => Volume.FromUsQuarts(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromUsTablespoons(double)" />
+            /// <inheritdoc cref="Volume.FromUsTablespoons(QuantityValue)" />
             public Volume UsTablespoons
 #if NET7_0_OR_GREATER
-                => Volume.FromUsTablespoons(double.CreateChecked(value));
+                => Volume.FromUsTablespoons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromUsTablespoons(value.ToDouble(null));
+                => Volume.FromUsTablespoons(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="Volume.FromUsTeaspoons(double)" />
+            /// <inheritdoc cref="Volume.FromUsTeaspoons(QuantityValue)" />
             public Volume UsTeaspoons
 #if NET7_0_OR_GREATER
-                => Volume.FromUsTeaspoons(double.CreateChecked(value));
+                => Volume.FromUsTeaspoons(QuantityValue.CreateChecked(value));
 #else
-                => Volume.FromUsTeaspoons(value.ToDouble(null));
+                => Volume.FromUsTeaspoons(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
index 50dc5ee625..d37afafe03 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
@@ -42,604 +42,628 @@ public static class NumberToVolumeFlowExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerDay(QuantityValue)" />
             public VolumeFlow AcreFeetPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromAcreFeetPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromAcreFeetPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromAcreFeetPerDay(value.ToDouble(null));
+                => VolumeFlow.FromAcreFeetPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerHour(QuantityValue)" />
             public VolumeFlow AcreFeetPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromAcreFeetPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromAcreFeetPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromAcreFeetPerHour(value.ToDouble(null));
+                => VolumeFlow.FromAcreFeetPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerMinute(QuantityValue)" />
             public VolumeFlow AcreFeetPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromAcreFeetPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromAcreFeetPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromAcreFeetPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromAcreFeetPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerSecond(QuantityValue)" />
             public VolumeFlow AcreFeetPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromAcreFeetPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromAcreFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromAcreFeetPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromAcreFeetPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCentilitersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCentilitersPerDay(QuantityValue)" />
             public VolumeFlow CentilitersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCentilitersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromCentilitersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCentilitersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromCentilitersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCentilitersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCentilitersPerHour(QuantityValue)" />
             public VolumeFlow CentilitersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCentilitersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromCentilitersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCentilitersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromCentilitersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCentilitersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCentilitersPerMinute(QuantityValue)" />
             public VolumeFlow CentilitersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCentilitersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromCentilitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCentilitersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromCentilitersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCentilitersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCentilitersPerSecond(QuantityValue)" />
             public VolumeFlow CentilitersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCentilitersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromCentilitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCentilitersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromCentilitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicCentimetersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicCentimetersPerMinute(QuantityValue)" />
             public VolumeFlow CubicCentimetersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicCentimetersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromCubicCentimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicCentimetersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromCubicCentimetersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicDecimetersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicDecimetersPerMinute(QuantityValue)" />
             public VolumeFlow CubicDecimetersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicDecimetersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromCubicDecimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicDecimetersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromCubicDecimetersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerHour(QuantityValue)" />
             public VolumeFlow CubicFeetPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicFeetPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromCubicFeetPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicFeetPerHour(value.ToDouble(null));
+                => VolumeFlow.FromCubicFeetPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerMinute(QuantityValue)" />
             public VolumeFlow CubicFeetPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicFeetPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromCubicFeetPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicFeetPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromCubicFeetPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerSecond(QuantityValue)" />
             public VolumeFlow CubicFeetPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicFeetPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromCubicFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicFeetPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromCubicFeetPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicInchesPerMinute(QuantityValue)" />
+            public VolumeFlow CubicInchesPerMinute
+#if NET7_0_OR_GREATER
+                => VolumeFlow.FromCubicInchesPerMinute(QuantityValue.CreateChecked(value));
+#else
+                => VolumeFlow.FromCubicInchesPerMinute(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="VolumeFlow.FromCubicInchesPerSecond(QuantityValue)" />
+            public VolumeFlow CubicInchesPerSecond
+#if NET7_0_OR_GREATER
+                => VolumeFlow.FromCubicInchesPerSecond(QuantityValue.CreateChecked(value));
+#else
+                => VolumeFlow.FromCubicInchesPerSecond(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerDay(QuantityValue)" />
             public VolumeFlow CubicMetersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicMetersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromCubicMetersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicMetersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromCubicMetersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerHour(QuantityValue)" />
             public VolumeFlow CubicMetersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicMetersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromCubicMetersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicMetersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromCubicMetersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerMinute(QuantityValue)" />
             public VolumeFlow CubicMetersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicMetersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromCubicMetersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicMetersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromCubicMetersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerSecond(QuantityValue)" />
             public VolumeFlow CubicMetersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicMetersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromCubicMetersPerSecond(QuantityValue.CreateChecked(value));
+#else
+                => VolumeFlow.FromCubicMetersPerSecond(value.ToQuantityValue());
+#endif
+
+            /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerMinute(QuantityValue)" />
+            public VolumeFlow CubicMillimetersPerMinute
+#if NET7_0_OR_GREATER
+                => VolumeFlow.FromCubicMillimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicMetersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromCubicMillimetersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerSecond(QuantityValue)" />
             public VolumeFlow CubicMillimetersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicMillimetersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromCubicMillimetersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicMillimetersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromCubicMillimetersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerDay(QuantityValue)" />
             public VolumeFlow CubicYardsPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicYardsPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromCubicYardsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicYardsPerDay(value.ToDouble(null));
+                => VolumeFlow.FromCubicYardsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerHour(QuantityValue)" />
             public VolumeFlow CubicYardsPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicYardsPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromCubicYardsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicYardsPerHour(value.ToDouble(null));
+                => VolumeFlow.FromCubicYardsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerMinute(QuantityValue)" />
             public VolumeFlow CubicYardsPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicYardsPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromCubicYardsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicYardsPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromCubicYardsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerSecond(QuantityValue)" />
             public VolumeFlow CubicYardsPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromCubicYardsPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromCubicYardsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromCubicYardsPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromCubicYardsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromDecalitersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromDecalitersPerDay(QuantityValue)" />
             public VolumeFlow DecalitersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromDecalitersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromDecalitersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromDecalitersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromDecalitersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromDecalitersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromDecalitersPerHour(QuantityValue)" />
             public VolumeFlow DecalitersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromDecalitersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromDecalitersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromDecalitersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromDecalitersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromDecalitersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromDecalitersPerMinute(QuantityValue)" />
             public VolumeFlow DecalitersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromDecalitersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromDecalitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromDecalitersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromDecalitersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromDecalitersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromDecalitersPerSecond(QuantityValue)" />
             public VolumeFlow DecalitersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromDecalitersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromDecalitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromDecalitersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromDecalitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromDecilitersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromDecilitersPerDay(QuantityValue)" />
             public VolumeFlow DecilitersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromDecilitersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromDecilitersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromDecilitersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromDecilitersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromDecilitersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromDecilitersPerHour(QuantityValue)" />
             public VolumeFlow DecilitersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromDecilitersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromDecilitersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromDecilitersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromDecilitersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromDecilitersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromDecilitersPerMinute(QuantityValue)" />
             public VolumeFlow DecilitersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromDecilitersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromDecilitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromDecilitersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromDecilitersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromDecilitersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromDecilitersPerSecond(QuantityValue)" />
             public VolumeFlow DecilitersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromDecilitersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromDecilitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromDecilitersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromDecilitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromHectolitersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromHectolitersPerDay(QuantityValue)" />
             public VolumeFlow HectolitersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromHectolitersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromHectolitersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromHectolitersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromHectolitersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromHectolitersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromHectolitersPerHour(QuantityValue)" />
             public VolumeFlow HectolitersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromHectolitersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromHectolitersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromHectolitersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromHectolitersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromHectolitersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromHectolitersPerMinute(QuantityValue)" />
             public VolumeFlow HectolitersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromHectolitersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromHectolitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromHectolitersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromHectolitersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromHectolitersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromHectolitersPerSecond(QuantityValue)" />
             public VolumeFlow HectolitersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromHectolitersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromHectolitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromHectolitersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromHectolitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromKilolitersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromKilolitersPerDay(QuantityValue)" />
             public VolumeFlow KilolitersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromKilolitersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromKilolitersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromKilolitersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromKilolitersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromKilolitersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromKilolitersPerHour(QuantityValue)" />
             public VolumeFlow KilolitersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromKilolitersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromKilolitersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromKilolitersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromKilolitersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromKilolitersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromKilolitersPerMinute(QuantityValue)" />
             public VolumeFlow KilolitersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromKilolitersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromKilolitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromKilolitersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromKilolitersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromKilolitersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromKilolitersPerSecond(QuantityValue)" />
             public VolumeFlow KilolitersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromKilolitersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromKilolitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromKilolitersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromKilolitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromKilousGallonsPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromKilousGallonsPerMinute(QuantityValue)" />
             public VolumeFlow KilousGallonsPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromKilousGallonsPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromKilousGallonsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromKilousGallonsPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromKilousGallonsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromLitersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromLitersPerDay(QuantityValue)" />
             public VolumeFlow LitersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromLitersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromLitersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromLitersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromLitersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromLitersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromLitersPerHour(QuantityValue)" />
             public VolumeFlow LitersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromLitersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromLitersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromLitersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromLitersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromLitersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromLitersPerMinute(QuantityValue)" />
             public VolumeFlow LitersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromLitersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromLitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromLitersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromLitersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromLitersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromLitersPerSecond(QuantityValue)" />
             public VolumeFlow LitersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromLitersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromLitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromLitersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromLitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMegalitersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMegalitersPerDay(QuantityValue)" />
             public VolumeFlow MegalitersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMegalitersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromMegalitersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMegalitersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromMegalitersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMegalitersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMegalitersPerHour(QuantityValue)" />
             public VolumeFlow MegalitersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMegalitersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromMegalitersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMegalitersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromMegalitersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMegalitersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMegalitersPerMinute(QuantityValue)" />
             public VolumeFlow MegalitersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMegalitersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromMegalitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMegalitersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromMegalitersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMegalitersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMegalitersPerSecond(QuantityValue)" />
             public VolumeFlow MegalitersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMegalitersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromMegalitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMegalitersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromMegalitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerDay(QuantityValue)" />
             public VolumeFlow MegaukGallonsPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMegaukGallonsPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromMegaukGallonsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMegaukGallonsPerDay(value.ToDouble(null));
+                => VolumeFlow.FromMegaukGallonsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerSecond(QuantityValue)" />
             public VolumeFlow MegaukGallonsPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMegaukGallonsPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromMegaukGallonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMegaukGallonsPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromMegaukGallonsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMegausGallonsPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMegausGallonsPerDay(QuantityValue)" />
             public VolumeFlow MegausGallonsPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMegausGallonsPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromMegausGallonsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMegausGallonsPerDay(value.ToDouble(null));
+                => VolumeFlow.FromMegausGallonsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerDay(QuantityValue)" />
             public VolumeFlow MicrolitersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMicrolitersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromMicrolitersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMicrolitersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromMicrolitersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerHour(QuantityValue)" />
             public VolumeFlow MicrolitersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMicrolitersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromMicrolitersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMicrolitersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromMicrolitersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerMinute(QuantityValue)" />
             public VolumeFlow MicrolitersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMicrolitersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromMicrolitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMicrolitersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromMicrolitersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerSecond(QuantityValue)" />
             public VolumeFlow MicrolitersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMicrolitersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromMicrolitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMicrolitersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromMicrolitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMillilitersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMillilitersPerDay(QuantityValue)" />
             public VolumeFlow MillilitersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMillilitersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromMillilitersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMillilitersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromMillilitersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMillilitersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMillilitersPerHour(QuantityValue)" />
             public VolumeFlow MillilitersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMillilitersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromMillilitersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMillilitersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromMillilitersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMillilitersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMillilitersPerMinute(QuantityValue)" />
             public VolumeFlow MillilitersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMillilitersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromMillilitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMillilitersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromMillilitersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMillilitersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMillilitersPerSecond(QuantityValue)" />
             public VolumeFlow MillilitersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMillilitersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromMillilitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMillilitersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromMillilitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromMillionUsGallonsPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromMillionUsGallonsPerDay(QuantityValue)" />
             public VolumeFlow MillionUsGallonsPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromMillionUsGallonsPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromMillionUsGallonsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromMillionUsGallonsPerDay(value.ToDouble(null));
+                => VolumeFlow.FromMillionUsGallonsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromNanolitersPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromNanolitersPerDay(QuantityValue)" />
             public VolumeFlow NanolitersPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromNanolitersPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromNanolitersPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromNanolitersPerDay(value.ToDouble(null));
+                => VolumeFlow.FromNanolitersPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromNanolitersPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromNanolitersPerHour(QuantityValue)" />
             public VolumeFlow NanolitersPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromNanolitersPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromNanolitersPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromNanolitersPerHour(value.ToDouble(null));
+                => VolumeFlow.FromNanolitersPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromNanolitersPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromNanolitersPerMinute(QuantityValue)" />
             public VolumeFlow NanolitersPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromNanolitersPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromNanolitersPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromNanolitersPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromNanolitersPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromNanolitersPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromNanolitersPerSecond(QuantityValue)" />
             public VolumeFlow NanolitersPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromNanolitersPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromNanolitersPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromNanolitersPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromNanolitersPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerDay(QuantityValue)" />
             public VolumeFlow OilBarrelsPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromOilBarrelsPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromOilBarrelsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromOilBarrelsPerDay(value.ToDouble(null));
+                => VolumeFlow.FromOilBarrelsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerHour(QuantityValue)" />
             public VolumeFlow OilBarrelsPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromOilBarrelsPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromOilBarrelsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromOilBarrelsPerHour(value.ToDouble(null));
+                => VolumeFlow.FromOilBarrelsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerMinute(QuantityValue)" />
             public VolumeFlow OilBarrelsPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromOilBarrelsPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromOilBarrelsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromOilBarrelsPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromOilBarrelsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerSecond(QuantityValue)" />
             public VolumeFlow OilBarrelsPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromOilBarrelsPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromOilBarrelsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromOilBarrelsPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromOilBarrelsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerDay(QuantityValue)" />
             public VolumeFlow UkGallonsPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromUkGallonsPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromUkGallonsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromUkGallonsPerDay(value.ToDouble(null));
+                => VolumeFlow.FromUkGallonsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerHour(QuantityValue)" />
             public VolumeFlow UkGallonsPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromUkGallonsPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromUkGallonsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromUkGallonsPerHour(value.ToDouble(null));
+                => VolumeFlow.FromUkGallonsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerMinute(QuantityValue)" />
             public VolumeFlow UkGallonsPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromUkGallonsPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromUkGallonsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromUkGallonsPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromUkGallonsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerSecond(QuantityValue)" />
             public VolumeFlow UkGallonsPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromUkGallonsPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromUkGallonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromUkGallonsPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromUkGallonsPerSecond(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerDay(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerDay(QuantityValue)" />
             public VolumeFlow UsGallonsPerDay
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromUsGallonsPerDay(double.CreateChecked(value));
+                => VolumeFlow.FromUsGallonsPerDay(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromUsGallonsPerDay(value.ToDouble(null));
+                => VolumeFlow.FromUsGallonsPerDay(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerHour(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerHour(QuantityValue)" />
             public VolumeFlow UsGallonsPerHour
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromUsGallonsPerHour(double.CreateChecked(value));
+                => VolumeFlow.FromUsGallonsPerHour(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromUsGallonsPerHour(value.ToDouble(null));
+                => VolumeFlow.FromUsGallonsPerHour(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerMinute(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerMinute(QuantityValue)" />
             public VolumeFlow UsGallonsPerMinute
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromUsGallonsPerMinute(double.CreateChecked(value));
+                => VolumeFlow.FromUsGallonsPerMinute(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromUsGallonsPerMinute(value.ToDouble(null));
+                => VolumeFlow.FromUsGallonsPerMinute(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerSecond(double)" />
+            /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerSecond(QuantityValue)" />
             public VolumeFlow UsGallonsPerSecond
 #if NET7_0_OR_GREATER
-                => VolumeFlow.FromUsGallonsPerSecond(double.CreateChecked(value));
+                => VolumeFlow.FromUsGallonsPerSecond(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlow.FromUsGallonsPerSecond(value.ToDouble(null));
+                => VolumeFlow.FromUsGallonsPerSecond(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs
index eed8f9a6f6..6fd1803c0f 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs
@@ -42,20 +42,20 @@ public static class NumberToVolumeFlowPerAreaExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(double)" />
+            /// <inheritdoc cref="VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(QuantityValue)" />
             public VolumeFlowPerArea CubicFeetPerMinutePerSquareFoot
 #if NET7_0_OR_GREATER
-                => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(double.CreateChecked(value));
+                => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(value.ToDouble(null));
+                => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(double)" />
+            /// <inheritdoc cref="VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(QuantityValue)" />
             public VolumeFlowPerArea CubicMetersPerSecondPerSquareMeter
 #if NET7_0_OR_GREATER
-                => VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(double.CreateChecked(value));
+                => VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
-                => VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(value.ToDouble(null));
+                => VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
index d8a6ffed9e..d2af8790da 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
@@ -42,76 +42,76 @@ public static class NumberToVolumePerLengthExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="VolumePerLength.FromCubicMetersPerMeter(double)" />
+            /// <inheritdoc cref="VolumePerLength.FromCubicMetersPerMeter(QuantityValue)" />
             public VolumePerLength CubicMetersPerMeter
 #if NET7_0_OR_GREATER
-                => VolumePerLength.FromCubicMetersPerMeter(double.CreateChecked(value));
+                => VolumePerLength.FromCubicMetersPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => VolumePerLength.FromCubicMetersPerMeter(value.ToDouble(null));
+                => VolumePerLength.FromCubicMetersPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerFoot(double)" />
+            /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerFoot(QuantityValue)" />
             public VolumePerLength CubicYardsPerFoot
 #if NET7_0_OR_GREATER
-                => VolumePerLength.FromCubicYardsPerFoot(double.CreateChecked(value));
+                => VolumePerLength.FromCubicYardsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => VolumePerLength.FromCubicYardsPerFoot(value.ToDouble(null));
+                => VolumePerLength.FromCubicYardsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerUsSurveyFoot(double)" />
+            /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerUsSurveyFoot(QuantityValue)" />
             public VolumePerLength CubicYardsPerUsSurveyFoot
 #if NET7_0_OR_GREATER
-                => VolumePerLength.FromCubicYardsPerUsSurveyFoot(double.CreateChecked(value));
+                => VolumePerLength.FromCubicYardsPerUsSurveyFoot(QuantityValue.CreateChecked(value));
 #else
-                => VolumePerLength.FromCubicYardsPerUsSurveyFoot(value.ToDouble(null));
+                => VolumePerLength.FromCubicYardsPerUsSurveyFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumePerLength.FromImperialGallonsPerMile(double)" />
+            /// <inheritdoc cref="VolumePerLength.FromImperialGallonsPerMile(QuantityValue)" />
             public VolumePerLength ImperialGallonsPerMile
 #if NET7_0_OR_GREATER
-                => VolumePerLength.FromImperialGallonsPerMile(double.CreateChecked(value));
+                => VolumePerLength.FromImperialGallonsPerMile(QuantityValue.CreateChecked(value));
 #else
-                => VolumePerLength.FromImperialGallonsPerMile(value.ToDouble(null));
+                => VolumePerLength.FromImperialGallonsPerMile(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumePerLength.FromLitersPerKilometer(double)" />
+            /// <inheritdoc cref="VolumePerLength.FromLitersPerKilometer(QuantityValue)" />
             public VolumePerLength LitersPerKilometer
 #if NET7_0_OR_GREATER
-                => VolumePerLength.FromLitersPerKilometer(double.CreateChecked(value));
+                => VolumePerLength.FromLitersPerKilometer(QuantityValue.CreateChecked(value));
 #else
-                => VolumePerLength.FromLitersPerKilometer(value.ToDouble(null));
+                => VolumePerLength.FromLitersPerKilometer(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumePerLength.FromLitersPerMeter(double)" />
+            /// <inheritdoc cref="VolumePerLength.FromLitersPerMeter(QuantityValue)" />
             public VolumePerLength LitersPerMeter
 #if NET7_0_OR_GREATER
-                => VolumePerLength.FromLitersPerMeter(double.CreateChecked(value));
+                => VolumePerLength.FromLitersPerMeter(QuantityValue.CreateChecked(value));
 #else
-                => VolumePerLength.FromLitersPerMeter(value.ToDouble(null));
+                => VolumePerLength.FromLitersPerMeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumePerLength.FromLitersPerMillimeter(double)" />
+            /// <inheritdoc cref="VolumePerLength.FromLitersPerMillimeter(QuantityValue)" />
             public VolumePerLength LitersPerMillimeter
 #if NET7_0_OR_GREATER
-                => VolumePerLength.FromLitersPerMillimeter(double.CreateChecked(value));
+                => VolumePerLength.FromLitersPerMillimeter(QuantityValue.CreateChecked(value));
 #else
-                => VolumePerLength.FromLitersPerMillimeter(value.ToDouble(null));
+                => VolumePerLength.FromLitersPerMillimeter(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumePerLength.FromOilBarrelsPerFoot(double)" />
+            /// <inheritdoc cref="VolumePerLength.FromOilBarrelsPerFoot(QuantityValue)" />
             public VolumePerLength OilBarrelsPerFoot
 #if NET7_0_OR_GREATER
-                => VolumePerLength.FromOilBarrelsPerFoot(double.CreateChecked(value));
+                => VolumePerLength.FromOilBarrelsPerFoot(QuantityValue.CreateChecked(value));
 #else
-                => VolumePerLength.FromOilBarrelsPerFoot(value.ToDouble(null));
+                => VolumePerLength.FromOilBarrelsPerFoot(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumePerLength.FromUsGallonsPerMile(double)" />
+            /// <inheritdoc cref="VolumePerLength.FromUsGallonsPerMile(QuantityValue)" />
             public VolumePerLength UsGallonsPerMile
 #if NET7_0_OR_GREATER
-                => VolumePerLength.FromUsGallonsPerMile(double.CreateChecked(value));
+                => VolumePerLength.FromUsGallonsPerMile(QuantityValue.CreateChecked(value));
 #else
-                => VolumePerLength.FromUsGallonsPerMile(value.ToDouble(null));
+                => VolumePerLength.FromUsGallonsPerMile(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs
index 9d52803c04..b573555011 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs
@@ -42,76 +42,76 @@ public static class NumberToVolumetricHeatCapacityExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(double)" />
+            /// <inheritdoc cref="VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(QuantityValue)" />
             public VolumetricHeatCapacity BtusPerCubicFootDegreeFahrenheit
 #if NET7_0_OR_GREATER
-                => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(double.CreateChecked(value));
+                => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(QuantityValue.CreateChecked(value));
 #else
-                => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(value.ToDouble(null));
+                => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(double)" />
+            /// <inheritdoc cref="VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(QuantityValue)" />
             public VolumetricHeatCapacity CaloriesPerCubicCentimeterDegreeCelsius
 #if NET7_0_OR_GREATER
-                => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(double.CreateChecked(value));
+                => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(value.ToDouble(null));
+                => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(double)" />
+            /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(QuantityValue)" />
             public VolumetricHeatCapacity JoulesPerCubicMeterDegreeCelsius
 #if NET7_0_OR_GREATER
-                => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(double.CreateChecked(value));
+                => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(value.ToDouble(null));
+                => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(double)" />
+            /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(QuantityValue)" />
             public VolumetricHeatCapacity JoulesPerCubicMeterKelvin
 #if NET7_0_OR_GREATER
-                => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(double.CreateChecked(value));
+                => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(QuantityValue.CreateChecked(value));
 #else
-                => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(value.ToDouble(null));
+                => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(double)" />
+            /// <inheritdoc cref="VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(QuantityValue)" />
             public VolumetricHeatCapacity KilocaloriesPerCubicCentimeterDegreeCelsius
 #if NET7_0_OR_GREATER
-                => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(double.CreateChecked(value));
+                => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(value.ToDouble(null));
+                => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(double)" />
+            /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(QuantityValue)" />
             public VolumetricHeatCapacity KilojoulesPerCubicMeterDegreeCelsius
 #if NET7_0_OR_GREATER
-                => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(double.CreateChecked(value));
+                => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(value.ToDouble(null));
+                => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(double)" />
+            /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(QuantityValue)" />
             public VolumetricHeatCapacity KilojoulesPerCubicMeterKelvin
 #if NET7_0_OR_GREATER
-                => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(double.CreateChecked(value));
+                => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(QuantityValue.CreateChecked(value));
 #else
-                => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(value.ToDouble(null));
+                => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(double)" />
+            /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(QuantityValue)" />
             public VolumetricHeatCapacity MegajoulesPerCubicMeterDegreeCelsius
 #if NET7_0_OR_GREATER
-                => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(double.CreateChecked(value));
+                => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
-                => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(value.ToDouble(null));
+                => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(double)" />
+            /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(QuantityValue)" />
             public VolumetricHeatCapacity MegajoulesPerCubicMeterKelvin
 #if NET7_0_OR_GREATER
-                => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(double.CreateChecked(value));
+                => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(QuantityValue.CreateChecked(value));
 #else
-                => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(value.ToDouble(null));
+                => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
index 46da4dd527..b7467a1ac1 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
@@ -42,52 +42,52 @@ public static class NumberToWarpingMomentOfInertiaExtensions
             , IConvertible
 #endif
         {
-            /// <inheritdoc cref="WarpingMomentOfInertia.FromCentimetersToTheSixth(double)" />
+            /// <inheritdoc cref="WarpingMomentOfInertia.FromCentimetersToTheSixth(QuantityValue)" />
             public WarpingMomentOfInertia CentimetersToTheSixth
 #if NET7_0_OR_GREATER
-                => WarpingMomentOfInertia.FromCentimetersToTheSixth(double.CreateChecked(value));
+                => WarpingMomentOfInertia.FromCentimetersToTheSixth(QuantityValue.CreateChecked(value));
 #else
-                => WarpingMomentOfInertia.FromCentimetersToTheSixth(value.ToDouble(null));
+                => WarpingMomentOfInertia.FromCentimetersToTheSixth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="WarpingMomentOfInertia.FromDecimetersToTheSixth(double)" />
+            /// <inheritdoc cref="WarpingMomentOfInertia.FromDecimetersToTheSixth(QuantityValue)" />
             public WarpingMomentOfInertia DecimetersToTheSixth
 #if NET7_0_OR_GREATER
-                => WarpingMomentOfInertia.FromDecimetersToTheSixth(double.CreateChecked(value));
+                => WarpingMomentOfInertia.FromDecimetersToTheSixth(QuantityValue.CreateChecked(value));
 #else
-                => WarpingMomentOfInertia.FromDecimetersToTheSixth(value.ToDouble(null));
+                => WarpingMomentOfInertia.FromDecimetersToTheSixth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="WarpingMomentOfInertia.FromFeetToTheSixth(double)" />
+            /// <inheritdoc cref="WarpingMomentOfInertia.FromFeetToTheSixth(QuantityValue)" />
             public WarpingMomentOfInertia FeetToTheSixth
 #if NET7_0_OR_GREATER
-                => WarpingMomentOfInertia.FromFeetToTheSixth(double.CreateChecked(value));
+                => WarpingMomentOfInertia.FromFeetToTheSixth(QuantityValue.CreateChecked(value));
 #else
-                => WarpingMomentOfInertia.FromFeetToTheSixth(value.ToDouble(null));
+                => WarpingMomentOfInertia.FromFeetToTheSixth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="WarpingMomentOfInertia.FromInchesToTheSixth(double)" />
+            /// <inheritdoc cref="WarpingMomentOfInertia.FromInchesToTheSixth(QuantityValue)" />
             public WarpingMomentOfInertia InchesToTheSixth
 #if NET7_0_OR_GREATER
-                => WarpingMomentOfInertia.FromInchesToTheSixth(double.CreateChecked(value));
+                => WarpingMomentOfInertia.FromInchesToTheSixth(QuantityValue.CreateChecked(value));
 #else
-                => WarpingMomentOfInertia.FromInchesToTheSixth(value.ToDouble(null));
+                => WarpingMomentOfInertia.FromInchesToTheSixth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="WarpingMomentOfInertia.FromMetersToTheSixth(double)" />
+            /// <inheritdoc cref="WarpingMomentOfInertia.FromMetersToTheSixth(QuantityValue)" />
             public WarpingMomentOfInertia MetersToTheSixth
 #if NET7_0_OR_GREATER
-                => WarpingMomentOfInertia.FromMetersToTheSixth(double.CreateChecked(value));
+                => WarpingMomentOfInertia.FromMetersToTheSixth(QuantityValue.CreateChecked(value));
 #else
-                => WarpingMomentOfInertia.FromMetersToTheSixth(value.ToDouble(null));
+                => WarpingMomentOfInertia.FromMetersToTheSixth(value.ToQuantityValue());
 #endif
 
-            /// <inheritdoc cref="WarpingMomentOfInertia.FromMillimetersToTheSixth(double)" />
+            /// <inheritdoc cref="WarpingMomentOfInertia.FromMillimetersToTheSixth(QuantityValue)" />
             public WarpingMomentOfInertia MillimetersToTheSixth
 #if NET7_0_OR_GREATER
-                => WarpingMomentOfInertia.FromMillimetersToTheSixth(double.CreateChecked(value));
+                => WarpingMomentOfInertia.FromMillimetersToTheSixth(QuantityValue.CreateChecked(value));
 #else
-                => WarpingMomentOfInertia.FromMillimetersToTheSixth(value.ToDouble(null));
+                => WarpingMomentOfInertia.FromMillimetersToTheSixth(value.ToQuantityValue());
 #endif
 
         }
diff --git a/UnitsNet.NumberExtensions.CS14/UnitsNet.NumberExtensions.CS14.csproj b/UnitsNet.NumberExtensions.CS14/UnitsNet.NumberExtensions.CS14.csproj
index 9ff4fcacde..df6e8c4c38 100644
--- a/UnitsNet.NumberExtensions.CS14/UnitsNet.NumberExtensions.CS14.csproj
+++ b/UnitsNet.NumberExtensions.CS14/UnitsNet.NumberExtensions.CS14.csproj
@@ -2,7 +2,7 @@
   <!-- NuGet properties -->
   <PropertyGroup>
     <PackageId>UnitsNet.NumberExtensions.CS14</PackageId>
-    <Version>6.0.0-pre017</Version>
+    <Version>6.0.0-pre021</Version>
     <Authors>Andreas Gullberg Larsen, Lu Li, Jon Suda</Authors>
     <Title>Units.NET NumberExtensions for C# 14</Title>
     <Description>C# 14 extension members for number types to create quantities using the new syntax, such as 5.Meters instead of Length.FromMeters(5). Requires C# 14 preview.</Description>
@@ -15,6 +15,7 @@
     <PackageLicenseExpression>MIT-0</PackageLicenseExpression>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>UnitsNet Extensions NumberToExtensions NumberToUnitsExtensions NumberExtensions NumberToUnits convert conversion parse</PackageTags>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
   </PropertyGroup>
 
   <!-- Assembly and msbuild properties -->
@@ -52,6 +53,7 @@
   <!-- Files to include in nuget package -->
   <ItemGroup>
     <None Include="../Docs/Images/logo-32.png" Pack="true" PackagePath="/" />
+    <None Include="../README.md" Pack="true" PackagePath="/" />
   </ItemGroup>
 
 </Project>
diff --git a/UnitsNet.NumberExtensions.Tests/ConvertibleExtensionsTest.cs b/UnitsNet.NumberExtensions.Tests/ConvertibleExtensionsTest.cs
new file mode 100644
index 0000000000..7657e97568
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/ConvertibleExtensionsTest.cs
@@ -0,0 +1,118 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using UnitsNet.NumberExtensions.NumberToMass;
+using Xunit;
+
+namespace UnitsNet.NumberExtensions.Tests;
+
+public class ConvertibleExtensionsTest
+{
+    [Fact]
+    public void FromDecimal_ToQuantityValue_ConvertsChecked()
+    {
+        QuantityValue quantityValue = 4.2m;
+        Assert.Equal(quantityValue, 4.2m.Grams().Value);
+    }
+
+    [Fact]
+    public void FromDouble_ConvertsSaturating()
+    {
+        QuantityValue quantityValue = 4.2;
+        Assert.Equal(quantityValue, 4.2.Grams().Value);
+    }
+
+    [Fact]
+    public void FromSingle_ConvertsSaturating()
+    {
+        QuantityValue quantityValue = 4.2f;
+        Assert.Equal(quantityValue, 4.2f.Grams().Value);
+    }
+
+    [Fact]
+    public void FromInt64_ConvertsChecked()
+    {
+        QuantityValue quantityValue = 4L;
+        Assert.Equal(quantityValue, 4L.Grams().Value);
+    }
+
+    [Fact]
+    public void FromUInt64_ConvertsChecked()
+    {
+        QuantityValue quantityValue = 4ul;
+        Assert.Equal(quantityValue, 4ul.Grams().Value);
+    }
+
+    [Fact]
+    public void FromInt32_ConvertsChecked()
+    {
+        QuantityValue quantityValue = 4;
+        Assert.Equal(quantityValue, 4.Grams().Value);
+    }
+
+    [Fact]
+    public void FromUInt32_ConvertsChecked()
+    {
+        QuantityValue quantityValue = 4u;
+        Assert.Equal(quantityValue, 4u.Grams().Value);
+    }
+
+    [Fact]
+    public void FromUInt16_ConvertsChecked()
+    {
+        const ushort valueToTest = 4;
+        QuantityValue quantityValue = valueToTest;
+        Assert.Equal(quantityValue, valueToTest.Grams().Value);
+    }
+
+    [Fact]
+    public void FromInt16_ConvertsChecked()
+    {
+        const ushort valueToTest = 4;
+        QuantityValue quantityValue = valueToTest;
+        Assert.Equal(quantityValue, valueToTest.Grams().Value);
+    }
+
+    [Fact]
+    public void FromByte_ConvertsChecked()
+    {
+        const byte valueToTest = 4;
+        QuantityValue quantityValue = valueToTest;
+        Assert.Equal(quantityValue, valueToTest.Grams().Value);
+    }
+
+    [Fact]
+    public void FromSByte_ConvertsChecked()
+    {
+        const sbyte valueToTest = 4;
+        QuantityValue quantityValue = valueToTest;
+        Assert.Equal(quantityValue, valueToTest.Grams().Value);
+    }
+
+    [Fact]
+    public void FromBoolean_ReturnsZeroOrOne()
+    {
+        Assert.Equal(QuantityValue.One, true.Grams().Value);
+        Assert.Equal(QuantityValue.Zero, false.Grams().Value);
+    }
+
+    [Fact]
+    public void FromChar_ThrowsInvalidCastException()
+    {
+        Assert.Throws<InvalidCastException>(() => 'z'.Grams().Value);
+    }
+
+    [Fact]
+    public void FromDateTime_ThrowsInvalidCastException()
+    {
+        Assert.Throws<InvalidCastException>(() => DateTime.MinValue.Grams().Value);
+    }
+
+    [Fact]
+    public void FromString_ReturnsTheParsedValue()
+    {
+        QuantityValue expectedValue = 42;
+        Assert.Equal(expectedValue, "42".Grams().Value);
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
index fa46181b00..331cf37fff 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
@@ -36,5 +36,13 @@ public void NumberToKilogramsPerSquareMeterTest() =>
         public void NumberToMilligramsPerSquareMeterTest() =>
             Assert.Equal(AreaDensity.FromMilligramsPerSquareMeter(2), 2.MilligramsPerSquareMeter());
 
+        [Fact]
+        public void NumberToPoundsPerSquareFootTest() =>
+            Assert.Equal(AreaDensity.FromPoundsPerSquareFoot(2), 2.PoundsPerSquareFoot());
+
+        [Fact]
+        public void NumberToPoundsPerThousandSquareFeetTest() =>
+            Assert.Equal(AreaDensity.FromPoundsPerThousandSquareFeet(2), 2.PoundsPerThousandSquareFeet());
+
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaPerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaPerLengthExtensionsTest.g.cs
new file mode 100644
index 0000000000..801cd9f5f5
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaPerLengthExtensionsTest.g.cs
@@ -0,0 +1,52 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToAreaPerLength;
+using Xunit;
+
+namespace UnitsNet.Tests
+{
+    public class NumberToAreaPerLengthExtensionsTests
+    {
+        [Fact]
+        public void NumberToSquareCentimetersPerMeterTest() =>
+            Assert.Equal(AreaPerLength.FromSquareCentimetersPerMeter(2), 2.SquareCentimetersPerMeter());
+
+        [Fact]
+        public void NumberToSquareFeetPerFootTest() =>
+            Assert.Equal(AreaPerLength.FromSquareFeetPerFoot(2), 2.SquareFeetPerFoot());
+
+        [Fact]
+        public void NumberToSquareInchesPerFootTest() =>
+            Assert.Equal(AreaPerLength.FromSquareInchesPerFoot(2), 2.SquareInchesPerFoot());
+
+        [Fact]
+        public void NumberToSquareInchesPerInchTest() =>
+            Assert.Equal(AreaPerLength.FromSquareInchesPerInch(2), 2.SquareInchesPerInch());
+
+        [Fact]
+        public void NumberToSquareMetersPerMeterTest() =>
+            Assert.Equal(AreaPerLength.FromSquareMetersPerMeter(2), 2.SquareMetersPerMeter());
+
+        [Fact]
+        public void NumberToSquareMillimetersPerMeterTest() =>
+            Assert.Equal(AreaPerLength.FromSquareMillimetersPerMeter(2), 2.SquareMillimetersPerMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
index 24e1c9752c..eb3a1453d5 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
@@ -32,6 +32,10 @@ public void NumberToDecanewtonsTest() =>
         public void NumberToDyneTest() =>
             Assert.Equal(Force.FromDyne(2), 2.Dyne());
 
+        [Fact]
+        public void NumberToGramsForceTest() =>
+            Assert.Equal(Force.FromGramsForce(2), 2.GramsForce());
+
         [Fact]
         public void NumberToKilogramsForceTest() =>
             Assert.Equal(Force.FromKilogramsForce(2), 2.KilogramsForce());
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
index 4ee308e104..3380c9aa23 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
@@ -48,10 +48,18 @@ public void NumberToCaloriesPerSecondSquareCentimeterTest() =>
         public void NumberToCentiwattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromCentiwattsPerSquareMeter(2), 2.CentiwattsPerSquareMeter());
 
+        [Fact]
+        public void NumberToCentiwattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromCentiwattsPerSquareMillimeter(2), 2.CentiwattsPerSquareMillimeter());
+
         [Fact]
         public void NumberToDeciwattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromDeciwattsPerSquareMeter(2), 2.DeciwattsPerSquareMeter());
 
+        [Fact]
+        public void NumberToDeciwattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromDeciwattsPerSquareMillimeter(2), 2.DeciwattsPerSquareMillimeter());
+
         [Fact]
         public void NumberToKilocaloriesPerHourSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromKilocaloriesPerHourSquareMeter(2), 2.KilocaloriesPerHourSquareMeter());
@@ -64,18 +72,34 @@ public void NumberToKilocaloriesPerSecondSquareCentimeterTest() =>
         public void NumberToKilowattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromKilowattsPerSquareMeter(2), 2.KilowattsPerSquareMeter());
 
+        [Fact]
+        public void NumberToKilowattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromKilowattsPerSquareMillimeter(2), 2.KilowattsPerSquareMillimeter());
+
         [Fact]
         public void NumberToMicrowattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromMicrowattsPerSquareMeter(2), 2.MicrowattsPerSquareMeter());
 
+        [Fact]
+        public void NumberToMicrowattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromMicrowattsPerSquareMillimeter(2), 2.MicrowattsPerSquareMillimeter());
+
         [Fact]
         public void NumberToMilliwattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromMilliwattsPerSquareMeter(2), 2.MilliwattsPerSquareMeter());
 
+        [Fact]
+        public void NumberToMilliwattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromMilliwattsPerSquareMillimeter(2), 2.MilliwattsPerSquareMillimeter());
+
         [Fact]
         public void NumberToNanowattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromNanowattsPerSquareMeter(2), 2.NanowattsPerSquareMeter());
 
+        [Fact]
+        public void NumberToNanowattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromNanowattsPerSquareMillimeter(2), 2.NanowattsPerSquareMillimeter());
+
         [Fact]
         public void NumberToPoundsForcePerFootSecondTest() =>
             Assert.Equal(HeatFlux.FromPoundsForcePerFootSecond(2), 2.PoundsForcePerFootSecond());
@@ -96,5 +120,9 @@ public void NumberToWattsPerSquareInchTest() =>
         public void NumberToWattsPerSquareMeterTest() =>
             Assert.Equal(HeatFlux.FromWattsPerSquareMeter(2), 2.WattsPerSquareMeter());
 
+        [Fact]
+        public void NumberToWattsPerSquareMillimeterTest() =>
+            Assert.Equal(HeatFlux.FromWattsPerSquareMillimeter(2), 2.WattsPerSquareMillimeter());
+
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
index fb4878717d..cd581d28ab 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
@@ -28,6 +28,10 @@ public class NumberToHeatTransferCoefficientExtensionsTests
         public void NumberToBtusPerHourSquareFootDegreeFahrenheitTest() =>
             Assert.Equal(HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(2), 2.BtusPerHourSquareFootDegreeFahrenheit());
 
+        [Fact]
+        public void NumberToBtusPerSecondSquareInchDegreeFahrenheitTest() =>
+            Assert.Equal(HeatTransferCoefficient.FromBtusPerSecondSquareInchDegreeFahrenheit(2), 2.BtusPerSecondSquareInchDegreeFahrenheit());
+
         [Fact]
         public void NumberToCaloriesPerHourSquareMeterDegreeCelsiusTest() =>
             Assert.Equal(HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(2), 2.CaloriesPerHourSquareMeterDegreeCelsius());
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
index cc48f3cbf5..a8fc1f576b 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
@@ -76,5 +76,9 @@ public void NumberToNanogramsPerMoleTest() =>
         public void NumberToPoundsPerMoleTest() =>
             Assert.Equal(MolarMass.FromPoundsPerMole(2), 2.PoundsPerMole());
 
+        [Fact]
+        public void NumberToPoundsPerPoundMoleTest() =>
+            Assert.Equal(MolarMass.FromPoundsPerPoundMole(2), 2.PoundsPerPoundMole());
+
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
index fed5acad1e..7c94fc3ccc 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
@@ -24,6 +24,14 @@ namespace UnitsNet.Tests
 {
     public class NumberToPowerDensityExtensionsTests
     {
+        [Fact]
+        public void NumberToBtusPerSecondCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromBtusPerSecondCubicFoot(2), 2.BtusPerSecondCubicFoot());
+
+        [Fact]
+        public void NumberToBtusPerSecondCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromBtusPerSecondCubicInch(2), 2.BtusPerSecondCubicInch());
+
         [Fact]
         public void NumberToDecawattsPerCubicFootTest() =>
             Assert.Equal(PowerDensity.FromDecawattsPerCubicFoot(2), 2.DecawattsPerCubicFoot());
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
index eccdde9422..763287cadf 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
@@ -148,6 +148,14 @@ public void NumberToMicropascalsTest() =>
         public void NumberToMillibarsTest() =>
             Assert.Equal(Pressure.FromMillibars(2), 2.Millibars());
 
+        [Fact]
+        public void NumberToMilligramsForcePerSquareFootTest() =>
+            Assert.Equal(Pressure.FromMilligramsForcePerSquareFoot(2), 2.MilligramsForcePerSquareFoot());
+
+        [Fact]
+        public void NumberToMilligramsForcePerSquareMeterTest() =>
+            Assert.Equal(Pressure.FromMilligramsForcePerSquareMeter(2), 2.MilligramsForcePerSquareMeter());
+
         [Fact]
         public void NumberToMillimetersOfMercuryTest() =>
             Assert.Equal(Pressure.FromMillimetersOfMercury(2), 2.MillimetersOfMercury());
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
index 1dc005ba3d..449e1e4500 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
@@ -33,8 +33,8 @@ public void NumberToCubicMetersPerKilogramTest() =>
             Assert.Equal(SpecificVolume.FromCubicMetersPerKilogram(2), 2.CubicMetersPerKilogram());
 
         [Fact]
-        public void NumberToMillicubicMetersPerKilogramTest() =>
-            Assert.Equal(SpecificVolume.FromMillicubicMetersPerKilogram(2), 2.MillicubicMetersPerKilogram());
+        public void NumberToCubicMillimetersPerKilogramTest() =>
+            Assert.Equal(SpecificVolume.FromCubicMillimetersPerKilogram(2), 2.CubicMillimetersPerKilogram());
 
     }
 }
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
index d0eb466936..f3086935c7 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
@@ -28,6 +28,10 @@ public class NumberToThermalConductivityExtensionsTests
         public void NumberToBtusPerHourFootFahrenheitTest() =>
             Assert.Equal(ThermalConductivity.FromBtusPerHourFootFahrenheit(2), 2.BtusPerHourFootFahrenheit());
 
+        [Fact]
+        public void NumberToBtusPerSecondInchFahrenheitTest() =>
+            Assert.Equal(ThermalConductivity.FromBtusPerSecondInchFahrenheit(2), 2.BtusPerSecondInchFahrenheit());
+
         [Fact]
         public void NumberToWattsPerMeterKelvinTest() =>
             Assert.Equal(ThermalConductivity.FromWattsPerMeterKelvin(2), 2.WattsPerMeterKelvin());
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
index b2e9768911..041cfc7580 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
@@ -100,6 +100,14 @@ public void NumberToNewtonMetersTest() =>
         public void NumberToNewtonMillimetersTest() =>
             Assert.Equal(Torque.FromNewtonMillimeters(2), 2.NewtonMillimeters());
 
+        [Fact]
+        public void NumberToOunceForceFeetTest() =>
+            Assert.Equal(Torque.FromOunceForceFeet(2), 2.OunceForceFeet());
+
+        [Fact]
+        public void NumberToOunceForceInchesTest() =>
+            Assert.Equal(Torque.FromOunceForceInches(2), 2.OunceForceInches());
+
         [Fact]
         public void NumberToPoundalFeetTest() =>
             Assert.Equal(Torque.FromPoundalFeet(2), 2.PoundalFeet());
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
index 7a047c5df7..c5f4cf71f8 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
@@ -100,14 +100,6 @@ public void NumberToDecilitersTest() =>
         public void NumberToDeciusGallonsTest() =>
             Assert.Equal(Volume.FromDeciusGallons(2), 2.DeciusGallons());
 
-        [Fact]
-        public void NumberToHectocubicFeetTest() =>
-            Assert.Equal(Volume.FromHectocubicFeet(2), 2.HectocubicFeet());
-
-        [Fact]
-        public void NumberToHectocubicMetersTest() =>
-            Assert.Equal(Volume.FromHectocubicMeters(2), 2.HectocubicMeters());
-
         [Fact]
         public void NumberToHectolitersTest() =>
             Assert.Equal(Volume.FromHectoliters(2), 2.Hectoliters());
@@ -116,6 +108,10 @@ public void NumberToHectolitersTest() =>
         public void NumberToHectousGallonsTest() =>
             Assert.Equal(Volume.FromHectousGallons(2), 2.HectousGallons());
 
+        [Fact]
+        public void NumberToHundredCubicFeetTest() =>
+            Assert.Equal(Volume.FromHundredCubicFeet(2), 2.HundredCubicFeet());
+
         [Fact]
         public void NumberToImperialBeerBarrelsTest() =>
             Assert.Equal(Volume.FromImperialBeerBarrels(2), 2.ImperialBeerBarrels());
@@ -136,14 +132,6 @@ public void NumberToImperialPintsTest() =>
         public void NumberToImperialQuartsTest() =>
             Assert.Equal(Volume.FromImperialQuarts(2), 2.ImperialQuarts());
 
-        [Fact]
-        public void NumberToKilocubicFeetTest() =>
-            Assert.Equal(Volume.FromKilocubicFeet(2), 2.KilocubicFeet());
-
-        [Fact]
-        public void NumberToKilocubicMetersTest() =>
-            Assert.Equal(Volume.FromKilocubicMeters(2), 2.KilocubicMeters());
-
         [Fact]
         public void NumberToKiloimperialGallonsTest() =>
             Assert.Equal(Volume.FromKiloimperialGallons(2), 2.KiloimperialGallons());
@@ -160,10 +148,6 @@ public void NumberToKilousGallonsTest() =>
         public void NumberToLitersTest() =>
             Assert.Equal(Volume.FromLiters(2), 2.Liters());
 
-        [Fact]
-        public void NumberToMegacubicFeetTest() =>
-            Assert.Equal(Volume.FromMegacubicFeet(2), 2.MegacubicFeet());
-
         [Fact]
         public void NumberToMegaimperialGallonsTest() =>
             Assert.Equal(Volume.FromMegaimperialGallons(2), 2.MegaimperialGallons());
@@ -196,6 +180,10 @@ public void NumberToMicrolitersTest() =>
         public void NumberToMillilitersTest() =>
             Assert.Equal(Volume.FromMilliliters(2), 2.Milliliters());
 
+        [Fact]
+        public void NumberToMillionCubicFeetTest() =>
+            Assert.Equal(Volume.FromMillionCubicFeet(2), 2.MillionCubicFeet());
+
         [Fact]
         public void NumberToNanolitersTest() =>
             Assert.Equal(Volume.FromNanoliters(2), 2.Nanoliters());
@@ -204,6 +192,14 @@ public void NumberToNanolitersTest() =>
         public void NumberToOilBarrelsTest() =>
             Assert.Equal(Volume.FromOilBarrels(2), 2.OilBarrels());
 
+        [Fact]
+        public void NumberToThousandCubicFeetTest() =>
+            Assert.Equal(Volume.FromThousandCubicFeet(2), 2.ThousandCubicFeet());
+
+        [Fact]
+        public void NumberToThousandCubicMetersTest() =>
+            Assert.Equal(Volume.FromThousandCubicMeters(2), 2.ThousandCubicMeters());
+
         [Fact]
         public void NumberToUkTablespoonsTest() =>
             Assert.Equal(Volume.FromUkTablespoons(2), 2.UkTablespoons());
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
index 028a366069..75e0f22a7e 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
@@ -76,6 +76,14 @@ public void NumberToCubicFeetPerMinuteTest() =>
         public void NumberToCubicFeetPerSecondTest() =>
             Assert.Equal(VolumeFlow.FromCubicFeetPerSecond(2), 2.CubicFeetPerSecond());
 
+        [Fact]
+        public void NumberToCubicInchesPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromCubicInchesPerMinute(2), 2.CubicInchesPerMinute());
+
+        [Fact]
+        public void NumberToCubicInchesPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromCubicInchesPerSecond(2), 2.CubicInchesPerSecond());
+
         [Fact]
         public void NumberToCubicMetersPerDayTest() =>
             Assert.Equal(VolumeFlow.FromCubicMetersPerDay(2), 2.CubicMetersPerDay());
@@ -92,6 +100,10 @@ public void NumberToCubicMetersPerMinuteTest() =>
         public void NumberToCubicMetersPerSecondTest() =>
             Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(2), 2.CubicMetersPerSecond());
 
+        [Fact]
+        public void NumberToCubicMillimetersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromCubicMillimetersPerMinute(2), 2.CubicMillimetersPerMinute());
+
         [Fact]
         public void NumberToCubicMillimetersPerSecondTest() =>
             Assert.Equal(VolumeFlow.FromCubicMillimetersPerSecond(2), 2.CubicMillimetersPerSecond());
diff --git a/UnitsNet.NumberExtensions.Tests/UnitsNet.NumberExtensions.Tests.csproj b/UnitsNet.NumberExtensions.Tests/UnitsNet.NumberExtensions.Tests.csproj
index be1d2ddbb8..77bed80f32 100644
--- a/UnitsNet.NumberExtensions.Tests/UnitsNet.NumberExtensions.Tests.csproj
+++ b/UnitsNet.NumberExtensions.Tests/UnitsNet.NumberExtensions.Tests.csproj
@@ -1,7 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;net8.0;net9.0;net10.0</TargetFrameworks>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(TargetFrameworks);net48</TargetFrameworks>
     <RootNamespace>UnitsNet.NumberExtensions.Tests</RootNamespace>
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
@@ -18,6 +19,10 @@
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
   </PropertyGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' != 'net48'">
+    <Compile Remove="ConvertibleExtensionsTest.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="xunit" />
diff --git a/UnitsNet.NumberExtensions/ConvertibleExtensions.cs b/UnitsNet.NumberExtensions/ConvertibleExtensions.cs
new file mode 100644
index 0000000000..e0c1cd2946
--- /dev/null
+++ b/UnitsNet.NumberExtensions/ConvertibleExtensions.cs
@@ -0,0 +1,23 @@
+namespace UnitsNet;
+
+internal static class ConvertibleExtensions
+{
+    internal static QuantityValue ToQuantityValue<TNumber>(this TNumber number) where TNumber : IConvertible
+    {
+        return number.GetTypeCode() switch
+        {
+            TypeCode.SByte => number.ToSByte(null),
+            TypeCode.Byte => number.ToByte(null),
+            TypeCode.Int16 => number.ToInt16(null),
+            TypeCode.UInt16 => number.ToUInt16(null),
+            TypeCode.Int32 => number.ToInt32(null),
+            TypeCode.UInt32 => number.ToUInt32(null),
+            TypeCode.Int64 => number.ToInt64(null),
+            TypeCode.UInt64 => number.ToUInt64(null),
+            TypeCode.Single => number.ToSingle(null),
+            TypeCode.Decimal => number.ToDecimal(null),
+            TypeCode.String => QuantityValue.Parse(number.ToString(null), null),
+            _ => number.ToDouble(null)
+        };
+    }
+}
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs
index e6ed3cdc87..8ec253bbb0 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs
@@ -32,191 +32,191 @@ namespace UnitsNet.NumberExtensions.NumberToAbsorbedDoseOfIonizingRadiation
     /// </summary>
     public static class NumberToAbsorbedDoseOfIonizingRadiationExtensions
     {
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromCentigrays(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromCentigrays(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Centigrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromCentigrays(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromCentigrays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromCentigrays(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromCentigrays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromDecigrays(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromDecigrays(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Decigrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromDecigrays(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromDecigrays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromDecigrays(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromDecigrays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromFemtograys(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromFemtograys(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Femtograys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromFemtograys(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromFemtograys(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromFemtograys(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromFemtograys(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGigagrays(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGigagrays(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Gigagrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromGigagrays(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromGigagrays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromGigagrays(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromGigagrays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGrays(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGrays(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Grays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromGrays(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromGrays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromGrays(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromGrays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilograys(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilograys(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Kilograys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromKilograys(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromKilograys(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromKilograys(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromKilograys(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilorads(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilorads(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Kilorads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromKilorads(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromKilorads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromKilorads(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromKilorads(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegagrays(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegagrays(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Megagrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromMegagrays(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromMegagrays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromMegagrays(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromMegagrays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegarads(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegarads(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Megarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromMegarads(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromMegarads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromMegarads(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromMegarads(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMicrograys(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMicrograys(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Micrograys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromMicrograys(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromMicrograys(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromMicrograys(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromMicrograys(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMilligrays(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMilligrays(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Milligrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromMilligrays(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromMilligrays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromMilligrays(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromMilligrays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMillirads(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMillirads(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Millirads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromMillirads(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromMillirads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromMillirads(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromMillirads(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromNanograys(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromNanograys(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Nanograys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromNanograys(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromNanograys(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromNanograys(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromNanograys(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPetagrays(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPetagrays(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Petagrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromPetagrays(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromPetagrays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromPetagrays(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromPetagrays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPicograys(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPicograys(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Picograys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromPicograys(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromPicograys(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromPicograys(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromPicograys(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromRads(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromRads(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Rads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromRads(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromRads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromRads(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromRads(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromTeragrays(double)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromTeragrays(QuantityValue)" />
         public static AbsorbedDoseOfIonizingRadiation Teragrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AbsorbedDoseOfIonizingRadiation.FromTeragrays(double.CreateChecked(value));
+            => AbsorbedDoseOfIonizingRadiation.FromTeragrays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AbsorbedDoseOfIonizingRadiation.FromTeragrays(value.ToDouble(null));
+            => AbsorbedDoseOfIonizingRadiation.FromTeragrays(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
index c0eb105add..8dcc9ec0da 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
@@ -32,158 +32,158 @@ namespace UnitsNet.NumberExtensions.NumberToAcceleration
     /// </summary>
     public static class NumberToAccelerationExtensions
     {
-        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double)" />
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(QuantityValue)" />
         public static Acceleration CentimetersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromCentimetersPerSecondSquared(double.CreateChecked(value));
+            => Acceleration.FromCentimetersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromCentimetersPerSecondSquared(value.ToDouble(null));
+            => Acceleration.FromCentimetersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double)" />
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(QuantityValue)" />
         public static Acceleration DecimetersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromDecimetersPerSecondSquared(double.CreateChecked(value));
+            => Acceleration.FromDecimetersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromDecimetersPerSecondSquared(value.ToDouble(null));
+            => Acceleration.FromDecimetersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromFeetPerSecondSquared(double)" />
+        /// <inheritdoc cref="Acceleration.FromFeetPerSecondSquared(QuantityValue)" />
         public static Acceleration FeetPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromFeetPerSecondSquared(double.CreateChecked(value));
+            => Acceleration.FromFeetPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromFeetPerSecondSquared(value.ToDouble(null));
+            => Acceleration.FromFeetPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromInchesPerSecondSquared(double)" />
+        /// <inheritdoc cref="Acceleration.FromInchesPerSecondSquared(QuantityValue)" />
         public static Acceleration InchesPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromInchesPerSecondSquared(double.CreateChecked(value));
+            => Acceleration.FromInchesPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromInchesPerSecondSquared(value.ToDouble(null));
+            => Acceleration.FromInchesPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double)" />
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(QuantityValue)" />
         public static Acceleration KilometersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromKilometersPerSecondSquared(double.CreateChecked(value));
+            => Acceleration.FromKilometersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromKilometersPerSecondSquared(value.ToDouble(null));
+            => Acceleration.FromKilometersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromKnotsPerHour(double)" />
+        /// <inheritdoc cref="Acceleration.FromKnotsPerHour(QuantityValue)" />
         public static Acceleration KnotsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromKnotsPerHour(double.CreateChecked(value));
+            => Acceleration.FromKnotsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromKnotsPerHour(value.ToDouble(null));
+            => Acceleration.FromKnotsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromKnotsPerMinute(double)" />
+        /// <inheritdoc cref="Acceleration.FromKnotsPerMinute(QuantityValue)" />
         public static Acceleration KnotsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromKnotsPerMinute(double.CreateChecked(value));
+            => Acceleration.FromKnotsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromKnotsPerMinute(value.ToDouble(null));
+            => Acceleration.FromKnotsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromKnotsPerSecond(double)" />
+        /// <inheritdoc cref="Acceleration.FromKnotsPerSecond(QuantityValue)" />
         public static Acceleration KnotsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromKnotsPerSecond(double.CreateChecked(value));
+            => Acceleration.FromKnotsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromKnotsPerSecond(value.ToDouble(null));
+            => Acceleration.FromKnotsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double)" />
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(QuantityValue)" />
         public static Acceleration MetersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromMetersPerSecondSquared(double.CreateChecked(value));
+            => Acceleration.FromMetersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromMetersPerSecondSquared(value.ToDouble(null));
+            => Acceleration.FromMetersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double)" />
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(QuantityValue)" />
         public static Acceleration MicrometersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromMicrometersPerSecondSquared(double.CreateChecked(value));
+            => Acceleration.FromMicrometersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromMicrometersPerSecondSquared(value.ToDouble(null));
+            => Acceleration.FromMicrometersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double)" />
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(QuantityValue)" />
         public static Acceleration MillimetersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromMillimetersPerSecondSquared(double.CreateChecked(value));
+            => Acceleration.FromMillimetersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromMillimetersPerSecondSquared(value.ToDouble(null));
+            => Acceleration.FromMillimetersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromMillistandardGravity(double)" />
+        /// <inheritdoc cref="Acceleration.FromMillistandardGravity(QuantityValue)" />
         public static Acceleration MillistandardGravity<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromMillistandardGravity(double.CreateChecked(value));
+            => Acceleration.FromMillistandardGravity(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromMillistandardGravity(value.ToDouble(null));
+            => Acceleration.FromMillistandardGravity(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double)" />
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(QuantityValue)" />
         public static Acceleration NanometersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromNanometersPerSecondSquared(double.CreateChecked(value));
+            => Acceleration.FromNanometersPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromNanometersPerSecondSquared(value.ToDouble(null));
+            => Acceleration.FromNanometersPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Acceleration.FromStandardGravity(double)" />
+        /// <inheritdoc cref="Acceleration.FromStandardGravity(QuantityValue)" />
         public static Acceleration StandardGravity<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Acceleration.FromStandardGravity(double.CreateChecked(value));
+            => Acceleration.FromStandardGravity(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Acceleration.FromStandardGravity(value.ToDouble(null));
+            => Acceleration.FromStandardGravity(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
index d68957f638..8d9555a0bc 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
@@ -32,191 +32,191 @@ namespace UnitsNet.NumberExtensions.NumberToAmountOfSubstance
     /// </summary>
     public static class NumberToAmountOfSubstanceExtensions
     {
-        /// <inheritdoc cref="AmountOfSubstance.FromCentimoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromCentimoles(QuantityValue)" />
         public static AmountOfSubstance Centimoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromCentimoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromCentimoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromCentimoles(value.ToDouble(null));
+            => AmountOfSubstance.FromCentimoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromCentipoundMoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromCentipoundMoles(QuantityValue)" />
         public static AmountOfSubstance CentipoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromCentipoundMoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromCentipoundMoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromCentipoundMoles(value.ToDouble(null));
+            => AmountOfSubstance.FromCentipoundMoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromDecimoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromDecimoles(QuantityValue)" />
         public static AmountOfSubstance Decimoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromDecimoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromDecimoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromDecimoles(value.ToDouble(null));
+            => AmountOfSubstance.FromDecimoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromDecipoundMoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromDecipoundMoles(QuantityValue)" />
         public static AmountOfSubstance DecipoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromDecipoundMoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromDecipoundMoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromDecipoundMoles(value.ToDouble(null));
+            => AmountOfSubstance.FromDecipoundMoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromFemtomoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromFemtomoles(QuantityValue)" />
         public static AmountOfSubstance Femtomoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromFemtomoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromFemtomoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromFemtomoles(value.ToDouble(null));
+            => AmountOfSubstance.FromFemtomoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromKilomoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromKilomoles(QuantityValue)" />
         public static AmountOfSubstance Kilomoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromKilomoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromKilomoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromKilomoles(value.ToDouble(null));
+            => AmountOfSubstance.FromKilomoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromKilopoundMoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromKilopoundMoles(QuantityValue)" />
         public static AmountOfSubstance KilopoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromKilopoundMoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromKilopoundMoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromKilopoundMoles(value.ToDouble(null));
+            => AmountOfSubstance.FromKilopoundMoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMegamoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMegamoles(QuantityValue)" />
         public static AmountOfSubstance Megamoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromMegamoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromMegamoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromMegamoles(value.ToDouble(null));
+            => AmountOfSubstance.FromMegamoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMicromoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMicromoles(QuantityValue)" />
         public static AmountOfSubstance Micromoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromMicromoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromMicromoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromMicromoles(value.ToDouble(null));
+            => AmountOfSubstance.FromMicromoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMicropoundMoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMicropoundMoles(QuantityValue)" />
         public static AmountOfSubstance MicropoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromMicropoundMoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromMicropoundMoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromMicropoundMoles(value.ToDouble(null));
+            => AmountOfSubstance.FromMicropoundMoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMillimoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMillimoles(QuantityValue)" />
         public static AmountOfSubstance Millimoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromMillimoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromMillimoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromMillimoles(value.ToDouble(null));
+            => AmountOfSubstance.FromMillimoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMillipoundMoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMillipoundMoles(QuantityValue)" />
         public static AmountOfSubstance MillipoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromMillipoundMoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromMillipoundMoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromMillipoundMoles(value.ToDouble(null));
+            => AmountOfSubstance.FromMillipoundMoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMoles(QuantityValue)" />
         public static AmountOfSubstance Moles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromMoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromMoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromMoles(value.ToDouble(null));
+            => AmountOfSubstance.FromMoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromNanomoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromNanomoles(QuantityValue)" />
         public static AmountOfSubstance Nanomoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromNanomoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromNanomoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromNanomoles(value.ToDouble(null));
+            => AmountOfSubstance.FromNanomoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromNanopoundMoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromNanopoundMoles(QuantityValue)" />
         public static AmountOfSubstance NanopoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromNanopoundMoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromNanopoundMoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromNanopoundMoles(value.ToDouble(null));
+            => AmountOfSubstance.FromNanopoundMoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromPicomoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromPicomoles(QuantityValue)" />
         public static AmountOfSubstance Picomoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromPicomoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromPicomoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromPicomoles(value.ToDouble(null));
+            => AmountOfSubstance.FromPicomoles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmountOfSubstance.FromPoundMoles(double)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromPoundMoles(QuantityValue)" />
         public static AmountOfSubstance PoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmountOfSubstance.FromPoundMoles(double.CreateChecked(value));
+            => AmountOfSubstance.FromPoundMoles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmountOfSubstance.FromPoundMoles(value.ToDouble(null));
+            => AmountOfSubstance.FromPoundMoles(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
index 57d41c7817..59186c1a1f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
@@ -32,48 +32,48 @@ namespace UnitsNet.NumberExtensions.NumberToAmplitudeRatio
     /// </summary>
     public static class NumberToAmplitudeRatioExtensions
     {
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMicrovolts(double)" />
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMicrovolts(QuantityValue)" />
         public static AmplitudeRatio DecibelMicrovolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmplitudeRatio.FromDecibelMicrovolts(double.CreateChecked(value));
+            => AmplitudeRatio.FromDecibelMicrovolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmplitudeRatio.FromDecibelMicrovolts(value.ToDouble(null));
+            => AmplitudeRatio.FromDecibelMicrovolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMillivolts(double)" />
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMillivolts(QuantityValue)" />
         public static AmplitudeRatio DecibelMillivolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmplitudeRatio.FromDecibelMillivolts(double.CreateChecked(value));
+            => AmplitudeRatio.FromDecibelMillivolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmplitudeRatio.FromDecibelMillivolts(value.ToDouble(null));
+            => AmplitudeRatio.FromDecibelMillivolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelsUnloaded(double)" />
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelsUnloaded(QuantityValue)" />
         public static AmplitudeRatio DecibelsUnloaded<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmplitudeRatio.FromDecibelsUnloaded(double.CreateChecked(value));
+            => AmplitudeRatio.FromDecibelsUnloaded(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmplitudeRatio.FromDecibelsUnloaded(value.ToDouble(null));
+            => AmplitudeRatio.FromDecibelsUnloaded(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelVolts(double)" />
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelVolts(QuantityValue)" />
         public static AmplitudeRatio DecibelVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AmplitudeRatio.FromDecibelVolts(double.CreateChecked(value));
+            => AmplitudeRatio.FromDecibelVolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AmplitudeRatio.FromDecibelVolts(value.ToDouble(null));
+            => AmplitudeRatio.FromDecibelVolts(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
index 94270005db..c766192414 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
@@ -32,169 +32,169 @@ namespace UnitsNet.NumberExtensions.NumberToAngle
     /// </summary>
     public static class NumberToAngleExtensions
     {
-        /// <inheritdoc cref="Angle.FromArcminutes(double)" />
+        /// <inheritdoc cref="Angle.FromArcminutes(QuantityValue)" />
         public static Angle Arcminutes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromArcminutes(double.CreateChecked(value));
+            => Angle.FromArcminutes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromArcminutes(value.ToDouble(null));
+            => Angle.FromArcminutes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromArcseconds(double)" />
+        /// <inheritdoc cref="Angle.FromArcseconds(QuantityValue)" />
         public static Angle Arcseconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromArcseconds(double.CreateChecked(value));
+            => Angle.FromArcseconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromArcseconds(value.ToDouble(null));
+            => Angle.FromArcseconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromCentiradians(double)" />
+        /// <inheritdoc cref="Angle.FromCentiradians(QuantityValue)" />
         public static Angle Centiradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromCentiradians(double.CreateChecked(value));
+            => Angle.FromCentiradians(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromCentiradians(value.ToDouble(null));
+            => Angle.FromCentiradians(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromDeciradians(double)" />
+        /// <inheritdoc cref="Angle.FromDeciradians(QuantityValue)" />
         public static Angle Deciradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromDeciradians(double.CreateChecked(value));
+            => Angle.FromDeciradians(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromDeciradians(value.ToDouble(null));
+            => Angle.FromDeciradians(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromDegrees(double)" />
+        /// <inheritdoc cref="Angle.FromDegrees(QuantityValue)" />
         public static Angle Degrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromDegrees(double.CreateChecked(value));
+            => Angle.FromDegrees(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromDegrees(value.ToDouble(null));
+            => Angle.FromDegrees(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromGradians(double)" />
+        /// <inheritdoc cref="Angle.FromGradians(QuantityValue)" />
         public static Angle Gradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromGradians(double.CreateChecked(value));
+            => Angle.FromGradians(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromGradians(value.ToDouble(null));
+            => Angle.FromGradians(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromMicrodegrees(double)" />
+        /// <inheritdoc cref="Angle.FromMicrodegrees(QuantityValue)" />
         public static Angle Microdegrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromMicrodegrees(double.CreateChecked(value));
+            => Angle.FromMicrodegrees(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromMicrodegrees(value.ToDouble(null));
+            => Angle.FromMicrodegrees(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromMicroradians(double)" />
+        /// <inheritdoc cref="Angle.FromMicroradians(QuantityValue)" />
         public static Angle Microradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromMicroradians(double.CreateChecked(value));
+            => Angle.FromMicroradians(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromMicroradians(value.ToDouble(null));
+            => Angle.FromMicroradians(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromMillidegrees(double)" />
+        /// <inheritdoc cref="Angle.FromMillidegrees(QuantityValue)" />
         public static Angle Millidegrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromMillidegrees(double.CreateChecked(value));
+            => Angle.FromMillidegrees(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromMillidegrees(value.ToDouble(null));
+            => Angle.FromMillidegrees(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromMilliradians(double)" />
+        /// <inheritdoc cref="Angle.FromMilliradians(QuantityValue)" />
         public static Angle Milliradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromMilliradians(double.CreateChecked(value));
+            => Angle.FromMilliradians(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromMilliradians(value.ToDouble(null));
+            => Angle.FromMilliradians(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromNanodegrees(double)" />
+        /// <inheritdoc cref="Angle.FromNanodegrees(QuantityValue)" />
         public static Angle Nanodegrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromNanodegrees(double.CreateChecked(value));
+            => Angle.FromNanodegrees(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromNanodegrees(value.ToDouble(null));
+            => Angle.FromNanodegrees(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromNanoradians(double)" />
+        /// <inheritdoc cref="Angle.FromNanoradians(QuantityValue)" />
         public static Angle Nanoradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromNanoradians(double.CreateChecked(value));
+            => Angle.FromNanoradians(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromNanoradians(value.ToDouble(null));
+            => Angle.FromNanoradians(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromNatoMils(double)" />
+        /// <inheritdoc cref="Angle.FromNatoMils(QuantityValue)" />
         public static Angle NatoMils<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromNatoMils(double.CreateChecked(value));
+            => Angle.FromNatoMils(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromNatoMils(value.ToDouble(null));
+            => Angle.FromNatoMils(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromRadians(double)" />
+        /// <inheritdoc cref="Angle.FromRadians(QuantityValue)" />
         public static Angle Radians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromRadians(double.CreateChecked(value));
+            => Angle.FromRadians(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromRadians(value.ToDouble(null));
+            => Angle.FromRadians(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Angle.FromRevolutions(double)" />
+        /// <inheritdoc cref="Angle.FromRevolutions(QuantityValue)" />
         public static Angle Revolutions<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Angle.FromRevolutions(double.CreateChecked(value));
+            => Angle.FromRevolutions(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Angle.FromRevolutions(value.ToDouble(null));
+            => Angle.FromRevolutions(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
index 0ce7edeee7..970074a1c0 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
@@ -32,37 +32,59 @@ namespace UnitsNet.NumberExtensions.NumberToAreaDensity
     /// </summary>
     public static class NumberToAreaDensityExtensions
     {
-        /// <inheritdoc cref="AreaDensity.FromGramsPerSquareMeter(double)" />
+        /// <inheritdoc cref="AreaDensity.FromGramsPerSquareMeter(QuantityValue)" />
         public static AreaDensity GramsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AreaDensity.FromGramsPerSquareMeter(double.CreateChecked(value));
+            => AreaDensity.FromGramsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AreaDensity.FromGramsPerSquareMeter(value.ToDouble(null));
+            => AreaDensity.FromGramsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AreaDensity.FromKilogramsPerSquareMeter(double)" />
+        /// <inheritdoc cref="AreaDensity.FromKilogramsPerSquareMeter(QuantityValue)" />
         public static AreaDensity KilogramsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AreaDensity.FromKilogramsPerSquareMeter(double.CreateChecked(value));
+            => AreaDensity.FromKilogramsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AreaDensity.FromKilogramsPerSquareMeter(value.ToDouble(null));
+            => AreaDensity.FromKilogramsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AreaDensity.FromMilligramsPerSquareMeter(double)" />
+        /// <inheritdoc cref="AreaDensity.FromMilligramsPerSquareMeter(QuantityValue)" />
         public static AreaDensity MilligramsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AreaDensity.FromMilligramsPerSquareMeter(double.CreateChecked(value));
+            => AreaDensity.FromMilligramsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AreaDensity.FromMilligramsPerSquareMeter(value.ToDouble(null));
+            => AreaDensity.FromMilligramsPerSquareMeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="AreaDensity.FromPoundsPerSquareFoot(QuantityValue)" />
+        public static AreaDensity PoundsPerSquareFoot<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => AreaDensity.FromPoundsPerSquareFoot(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => AreaDensity.FromPoundsPerSquareFoot(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="AreaDensity.FromPoundsPerThousandSquareFeet(QuantityValue)" />
+        public static AreaDensity PoundsPerThousandSquareFeet<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => AreaDensity.FromPoundsPerThousandSquareFeet(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => AreaDensity.FromPoundsPerThousandSquareFeet(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
index 246fec606f..f253ba26bb 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
@@ -32,158 +32,158 @@ namespace UnitsNet.NumberExtensions.NumberToArea
     /// </summary>
     public static class NumberToAreaExtensions
     {
-        /// <inheritdoc cref="Area.FromAcres(double)" />
+        /// <inheritdoc cref="Area.FromAcres(QuantityValue)" />
         public static Area Acres<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromAcres(double.CreateChecked(value));
+            => Area.FromAcres(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromAcres(value.ToDouble(null));
+            => Area.FromAcres(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromHectares(double)" />
+        /// <inheritdoc cref="Area.FromHectares(QuantityValue)" />
         public static Area Hectares<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromHectares(double.CreateChecked(value));
+            => Area.FromHectares(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromHectares(value.ToDouble(null));
+            => Area.FromHectares(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareCentimeters(double)" />
+        /// <inheritdoc cref="Area.FromSquareCentimeters(QuantityValue)" />
         public static Area SquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareCentimeters(double.CreateChecked(value));
+            => Area.FromSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareCentimeters(value.ToDouble(null));
+            => Area.FromSquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareDecimeters(double)" />
+        /// <inheritdoc cref="Area.FromSquareDecimeters(QuantityValue)" />
         public static Area SquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareDecimeters(double.CreateChecked(value));
+            => Area.FromSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareDecimeters(value.ToDouble(null));
+            => Area.FromSquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareFeet(double)" />
+        /// <inheritdoc cref="Area.FromSquareFeet(QuantityValue)" />
         public static Area SquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareFeet(double.CreateChecked(value));
+            => Area.FromSquareFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareFeet(value.ToDouble(null));
+            => Area.FromSquareFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareInches(double)" />
+        /// <inheritdoc cref="Area.FromSquareInches(QuantityValue)" />
         public static Area SquareInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareInches(double.CreateChecked(value));
+            => Area.FromSquareInches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareInches(value.ToDouble(null));
+            => Area.FromSquareInches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareKilometers(double)" />
+        /// <inheritdoc cref="Area.FromSquareKilometers(QuantityValue)" />
         public static Area SquareKilometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareKilometers(double.CreateChecked(value));
+            => Area.FromSquareKilometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareKilometers(value.ToDouble(null));
+            => Area.FromSquareKilometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareMeters(double)" />
+        /// <inheritdoc cref="Area.FromSquareMeters(QuantityValue)" />
         public static Area SquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareMeters(double.CreateChecked(value));
+            => Area.FromSquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareMeters(value.ToDouble(null));
+            => Area.FromSquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareMicrometers(double)" />
+        /// <inheritdoc cref="Area.FromSquareMicrometers(QuantityValue)" />
         public static Area SquareMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareMicrometers(double.CreateChecked(value));
+            => Area.FromSquareMicrometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareMicrometers(value.ToDouble(null));
+            => Area.FromSquareMicrometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareMiles(double)" />
+        /// <inheritdoc cref="Area.FromSquareMiles(QuantityValue)" />
         public static Area SquareMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareMiles(double.CreateChecked(value));
+            => Area.FromSquareMiles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareMiles(value.ToDouble(null));
+            => Area.FromSquareMiles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareMillimeters(double)" />
+        /// <inheritdoc cref="Area.FromSquareMillimeters(QuantityValue)" />
         public static Area SquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareMillimeters(double.CreateChecked(value));
+            => Area.FromSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareMillimeters(value.ToDouble(null));
+            => Area.FromSquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareNauticalMiles(double)" />
+        /// <inheritdoc cref="Area.FromSquareNauticalMiles(QuantityValue)" />
         public static Area SquareNauticalMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareNauticalMiles(double.CreateChecked(value));
+            => Area.FromSquareNauticalMiles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareNauticalMiles(value.ToDouble(null));
+            => Area.FromSquareNauticalMiles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromSquareYards(double)" />
+        /// <inheritdoc cref="Area.FromSquareYards(QuantityValue)" />
         public static Area SquareYards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromSquareYards(double.CreateChecked(value));
+            => Area.FromSquareYards(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromSquareYards(value.ToDouble(null));
+            => Area.FromSquareYards(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Area.FromUsSurveySquareFeet(double)" />
+        /// <inheritdoc cref="Area.FromUsSurveySquareFeet(QuantityValue)" />
         public static Area UsSurveySquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Area.FromUsSurveySquareFeet(double.CreateChecked(value));
+            => Area.FromUsSurveySquareFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Area.FromUsSurveySquareFeet(value.ToDouble(null));
+            => Area.FromUsSurveySquareFeet(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
index b48728ea88..c330f50527 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
@@ -32,70 +32,70 @@ namespace UnitsNet.NumberExtensions.NumberToAreaMomentOfInertia
     /// </summary>
     public static class NumberToAreaMomentOfInertiaExtensions
     {
-        /// <inheritdoc cref="AreaMomentOfInertia.FromCentimetersToTheFourth(double)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromCentimetersToTheFourth(QuantityValue)" />
         public static AreaMomentOfInertia CentimetersToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AreaMomentOfInertia.FromCentimetersToTheFourth(double.CreateChecked(value));
+            => AreaMomentOfInertia.FromCentimetersToTheFourth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AreaMomentOfInertia.FromCentimetersToTheFourth(value.ToDouble(null));
+            => AreaMomentOfInertia.FromCentimetersToTheFourth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromDecimetersToTheFourth(double)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromDecimetersToTheFourth(QuantityValue)" />
         public static AreaMomentOfInertia DecimetersToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AreaMomentOfInertia.FromDecimetersToTheFourth(double.CreateChecked(value));
+            => AreaMomentOfInertia.FromDecimetersToTheFourth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AreaMomentOfInertia.FromDecimetersToTheFourth(value.ToDouble(null));
+            => AreaMomentOfInertia.FromDecimetersToTheFourth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromFeetToTheFourth(double)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromFeetToTheFourth(QuantityValue)" />
         public static AreaMomentOfInertia FeetToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AreaMomentOfInertia.FromFeetToTheFourth(double.CreateChecked(value));
+            => AreaMomentOfInertia.FromFeetToTheFourth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AreaMomentOfInertia.FromFeetToTheFourth(value.ToDouble(null));
+            => AreaMomentOfInertia.FromFeetToTheFourth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromInchesToTheFourth(double)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromInchesToTheFourth(QuantityValue)" />
         public static AreaMomentOfInertia InchesToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AreaMomentOfInertia.FromInchesToTheFourth(double.CreateChecked(value));
+            => AreaMomentOfInertia.FromInchesToTheFourth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AreaMomentOfInertia.FromInchesToTheFourth(value.ToDouble(null));
+            => AreaMomentOfInertia.FromInchesToTheFourth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromMetersToTheFourth(double)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromMetersToTheFourth(QuantityValue)" />
         public static AreaMomentOfInertia MetersToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AreaMomentOfInertia.FromMetersToTheFourth(double.CreateChecked(value));
+            => AreaMomentOfInertia.FromMetersToTheFourth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AreaMomentOfInertia.FromMetersToTheFourth(value.ToDouble(null));
+            => AreaMomentOfInertia.FromMetersToTheFourth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromMillimetersToTheFourth(double)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromMillimetersToTheFourth(QuantityValue)" />
         public static AreaMomentOfInertia MillimetersToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => AreaMomentOfInertia.FromMillimetersToTheFourth(double.CreateChecked(value));
+            => AreaMomentOfInertia.FromMillimetersToTheFourth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => AreaMomentOfInertia.FromMillimetersToTheFourth(value.ToDouble(null));
+            => AreaMomentOfInertia.FromMillimetersToTheFourth(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaPerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaPerLengthExtensions.g.cs
new file mode 100644
index 0000000000..7e04d7cf00
--- /dev/null
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaPerLengthExtensions.g.cs
@@ -0,0 +1,102 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+
+#if NET7_0_OR_GREATER
+using System.Numerics;
+#endif
+
+#nullable enable
+
+namespace UnitsNet.NumberExtensions.NumberToAreaPerLength
+{
+    /// <summary>
+    /// A number to AreaPerLength Extensions
+    /// </summary>
+    public static class NumberToAreaPerLengthExtensions
+    {
+        /// <inheritdoc cref="AreaPerLength.FromSquareCentimetersPerMeter(QuantityValue)" />
+        public static AreaPerLength SquareCentimetersPerMeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => AreaPerLength.FromSquareCentimetersPerMeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => AreaPerLength.FromSquareCentimetersPerMeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="AreaPerLength.FromSquareFeetPerFoot(QuantityValue)" />
+        public static AreaPerLength SquareFeetPerFoot<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => AreaPerLength.FromSquareFeetPerFoot(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => AreaPerLength.FromSquareFeetPerFoot(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="AreaPerLength.FromSquareInchesPerFoot(QuantityValue)" />
+        public static AreaPerLength SquareInchesPerFoot<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => AreaPerLength.FromSquareInchesPerFoot(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => AreaPerLength.FromSquareInchesPerFoot(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="AreaPerLength.FromSquareInchesPerInch(QuantityValue)" />
+        public static AreaPerLength SquareInchesPerInch<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => AreaPerLength.FromSquareInchesPerInch(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => AreaPerLength.FromSquareInchesPerInch(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="AreaPerLength.FromSquareMetersPerMeter(QuantityValue)" />
+        public static AreaPerLength SquareMetersPerMeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => AreaPerLength.FromSquareMetersPerMeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => AreaPerLength.FromSquareMetersPerMeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="AreaPerLength.FromSquareMillimetersPerMeter(QuantityValue)" />
+        public static AreaPerLength SquareMillimetersPerMeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => AreaPerLength.FromSquareMillimetersPerMeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => AreaPerLength.FromSquareMillimetersPerMeter(value.ToQuantityValue());
+#endif
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
index e747c0aef6..1a742798fa 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
@@ -32,433 +32,433 @@ namespace UnitsNet.NumberExtensions.NumberToBitRate
     /// </summary>
     public static class NumberToBitRateExtensions
     {
-        /// <inheritdoc cref="BitRate.FromBitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromBitsPerSecond(QuantityValue)" />
         public static BitRate BitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromBitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromBitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromBitsPerSecond(value.ToDouble(null));
+            => BitRate.FromBitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromBytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromBytesPerSecond(QuantityValue)" />
         public static BitRate BytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromBytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromBytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromBytesPerSecond(value.ToDouble(null));
+            => BitRate.FromBytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromExabitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromExabitsPerSecond(QuantityValue)" />
         public static BitRate ExabitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromExabitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromExabitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromExabitsPerSecond(value.ToDouble(null));
+            => BitRate.FromExabitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromExabytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromExabytesPerSecond(QuantityValue)" />
         public static BitRate ExabytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromExabytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromExabytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromExabytesPerSecond(value.ToDouble(null));
+            => BitRate.FromExabytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromExaoctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromExaoctetsPerSecond(QuantityValue)" />
         public static BitRate ExaoctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromExaoctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromExaoctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromExaoctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromExaoctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromExbibitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromExbibitsPerSecond(QuantityValue)" />
         public static BitRate ExbibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromExbibitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromExbibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromExbibitsPerSecond(value.ToDouble(null));
+            => BitRate.FromExbibitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromExbibytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromExbibytesPerSecond(QuantityValue)" />
         public static BitRate ExbibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromExbibytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromExbibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromExbibytesPerSecond(value.ToDouble(null));
+            => BitRate.FromExbibytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromExbioctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromExbioctetsPerSecond(QuantityValue)" />
         public static BitRate ExbioctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromExbioctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromExbioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromExbioctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromExbioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromGibibitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromGibibitsPerSecond(QuantityValue)" />
         public static BitRate GibibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromGibibitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromGibibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromGibibitsPerSecond(value.ToDouble(null));
+            => BitRate.FromGibibitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromGibibytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromGibibytesPerSecond(QuantityValue)" />
         public static BitRate GibibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromGibibytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromGibibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromGibibytesPerSecond(value.ToDouble(null));
+            => BitRate.FromGibibytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromGibioctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromGibioctetsPerSecond(QuantityValue)" />
         public static BitRate GibioctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromGibioctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromGibioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromGibioctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromGibioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromGigabitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromGigabitsPerSecond(QuantityValue)" />
         public static BitRate GigabitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromGigabitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromGigabitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromGigabitsPerSecond(value.ToDouble(null));
+            => BitRate.FromGigabitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromGigabytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromGigabytesPerSecond(QuantityValue)" />
         public static BitRate GigabytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromGigabytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromGigabytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromGigabytesPerSecond(value.ToDouble(null));
+            => BitRate.FromGigabytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromGigaoctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromGigaoctetsPerSecond(QuantityValue)" />
         public static BitRate GigaoctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromGigaoctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromGigaoctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromGigaoctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromGigaoctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromKibibitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromKibibitsPerSecond(QuantityValue)" />
         public static BitRate KibibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromKibibitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromKibibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromKibibitsPerSecond(value.ToDouble(null));
+            => BitRate.FromKibibitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromKibibytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromKibibytesPerSecond(QuantityValue)" />
         public static BitRate KibibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromKibibytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromKibibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromKibibytesPerSecond(value.ToDouble(null));
+            => BitRate.FromKibibytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromKibioctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromKibioctetsPerSecond(QuantityValue)" />
         public static BitRate KibioctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromKibioctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromKibioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromKibioctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromKibioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromKilobitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromKilobitsPerSecond(QuantityValue)" />
         public static BitRate KilobitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromKilobitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromKilobitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromKilobitsPerSecond(value.ToDouble(null));
+            => BitRate.FromKilobitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromKilobytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromKilobytesPerSecond(QuantityValue)" />
         public static BitRate KilobytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromKilobytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromKilobytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromKilobytesPerSecond(value.ToDouble(null));
+            => BitRate.FromKilobytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromKilooctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromKilooctetsPerSecond(QuantityValue)" />
         public static BitRate KilooctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromKilooctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromKilooctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromKilooctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromKilooctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromMebibitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromMebibitsPerSecond(QuantityValue)" />
         public static BitRate MebibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromMebibitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromMebibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromMebibitsPerSecond(value.ToDouble(null));
+            => BitRate.FromMebibitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromMebibytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromMebibytesPerSecond(QuantityValue)" />
         public static BitRate MebibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromMebibytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromMebibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromMebibytesPerSecond(value.ToDouble(null));
+            => BitRate.FromMebibytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromMebioctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromMebioctetsPerSecond(QuantityValue)" />
         public static BitRate MebioctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromMebioctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromMebioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromMebioctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromMebioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromMegabitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromMegabitsPerSecond(QuantityValue)" />
         public static BitRate MegabitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromMegabitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromMegabitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromMegabitsPerSecond(value.ToDouble(null));
+            => BitRate.FromMegabitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromMegabytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromMegabytesPerSecond(QuantityValue)" />
         public static BitRate MegabytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromMegabytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromMegabytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromMegabytesPerSecond(value.ToDouble(null));
+            => BitRate.FromMegabytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromMegaoctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromMegaoctetsPerSecond(QuantityValue)" />
         public static BitRate MegaoctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromMegaoctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromMegaoctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromMegaoctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromMegaoctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromOctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromOctetsPerSecond(QuantityValue)" />
         public static BitRate OctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromOctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromOctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromOctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromOctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromPebibitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromPebibitsPerSecond(QuantityValue)" />
         public static BitRate PebibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromPebibitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromPebibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromPebibitsPerSecond(value.ToDouble(null));
+            => BitRate.FromPebibitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromPebibytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromPebibytesPerSecond(QuantityValue)" />
         public static BitRate PebibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromPebibytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromPebibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromPebibytesPerSecond(value.ToDouble(null));
+            => BitRate.FromPebibytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromPebioctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromPebioctetsPerSecond(QuantityValue)" />
         public static BitRate PebioctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromPebioctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromPebioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromPebioctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromPebioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromPetabitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromPetabitsPerSecond(QuantityValue)" />
         public static BitRate PetabitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromPetabitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromPetabitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromPetabitsPerSecond(value.ToDouble(null));
+            => BitRate.FromPetabitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromPetabytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromPetabytesPerSecond(QuantityValue)" />
         public static BitRate PetabytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromPetabytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromPetabytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromPetabytesPerSecond(value.ToDouble(null));
+            => BitRate.FromPetabytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromPetaoctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromPetaoctetsPerSecond(QuantityValue)" />
         public static BitRate PetaoctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromPetaoctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromPetaoctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromPetaoctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromPetaoctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromTebibitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromTebibitsPerSecond(QuantityValue)" />
         public static BitRate TebibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromTebibitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromTebibitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromTebibitsPerSecond(value.ToDouble(null));
+            => BitRate.FromTebibitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromTebibytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromTebibytesPerSecond(QuantityValue)" />
         public static BitRate TebibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromTebibytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromTebibytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromTebibytesPerSecond(value.ToDouble(null));
+            => BitRate.FromTebibytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromTebioctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromTebioctetsPerSecond(QuantityValue)" />
         public static BitRate TebioctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromTebioctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromTebioctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromTebioctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromTebioctetsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromTerabitsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromTerabitsPerSecond(QuantityValue)" />
         public static BitRate TerabitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromTerabitsPerSecond(double.CreateChecked(value));
+            => BitRate.FromTerabitsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromTerabitsPerSecond(value.ToDouble(null));
+            => BitRate.FromTerabitsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromTerabytesPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromTerabytesPerSecond(QuantityValue)" />
         public static BitRate TerabytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromTerabytesPerSecond(double.CreateChecked(value));
+            => BitRate.FromTerabytesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromTerabytesPerSecond(value.ToDouble(null));
+            => BitRate.FromTerabytesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BitRate.FromTeraoctetsPerSecond(double)" />
+        /// <inheritdoc cref="BitRate.FromTeraoctetsPerSecond(QuantityValue)" />
         public static BitRate TeraoctetsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BitRate.FromTeraoctetsPerSecond(double.CreateChecked(value));
+            => BitRate.FromTeraoctetsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BitRate.FromTeraoctetsPerSecond(value.ToDouble(null));
+            => BitRate.FromTeraoctetsPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
index 6881a06193..6c275fa041 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
@@ -32,37 +32,37 @@ namespace UnitsNet.NumberExtensions.NumberToBrakeSpecificFuelConsumption
     /// </summary>
     public static class NumberToBrakeSpecificFuelConsumptionExtensions
     {
-        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(double)" />
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(QuantityValue)" />
         public static BrakeSpecificFuelConsumption GramsPerKiloWattHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(double.CreateChecked(value));
+            => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(value.ToDouble(null));
+            => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromKilogramsPerJoule(double)" />
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromKilogramsPerJoule(QuantityValue)" />
         public static BrakeSpecificFuelConsumption KilogramsPerJoule<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(double.CreateChecked(value));
+            => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(value.ToDouble(null));
+            => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(double)" />
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(QuantityValue)" />
         public static BrakeSpecificFuelConsumption PoundsPerMechanicalHorsepowerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(double.CreateChecked(value));
+            => BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(value.ToDouble(null));
+            => BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
index 93f1ba1af7..1ca4c4ea56 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
@@ -32,70 +32,70 @@ namespace UnitsNet.NumberExtensions.NumberToCoefficientOfThermalExpansion
     /// </summary>
     public static class NumberToCoefficientOfThermalExpansionExtensions
     {
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeCelsius(double)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeCelsius(QuantityValue)" />
         public static CoefficientOfThermalExpansion PerDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => CoefficientOfThermalExpansion.FromPerDegreeCelsius(double.CreateChecked(value));
+            => CoefficientOfThermalExpansion.FromPerDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => CoefficientOfThermalExpansion.FromPerDegreeCelsius(value.ToDouble(null));
+            => CoefficientOfThermalExpansion.FromPerDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(double)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(QuantityValue)" />
         public static CoefficientOfThermalExpansion PerDegreeFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(double.CreateChecked(value));
+            => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(value.ToDouble(null));
+            => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerKelvin(double)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerKelvin(QuantityValue)" />
         public static CoefficientOfThermalExpansion PerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => CoefficientOfThermalExpansion.FromPerKelvin(double.CreateChecked(value));
+            => CoefficientOfThermalExpansion.FromPerKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => CoefficientOfThermalExpansion.FromPerKelvin(value.ToDouble(null));
+            => CoefficientOfThermalExpansion.FromPerKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(double)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(QuantityValue)" />
         public static CoefficientOfThermalExpansion PpmPerDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(double.CreateChecked(value));
+            => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(value.ToDouble(null));
+            => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(double)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(QuantityValue)" />
         public static CoefficientOfThermalExpansion PpmPerDegreeFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(double.CreateChecked(value));
+            => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(value.ToDouble(null));
+            => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerKelvin(double)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerKelvin(QuantityValue)" />
         public static CoefficientOfThermalExpansion PpmPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => CoefficientOfThermalExpansion.FromPpmPerKelvin(double.CreateChecked(value));
+            => CoefficientOfThermalExpansion.FromPpmPerKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => CoefficientOfThermalExpansion.FromPpmPerKelvin(value.ToDouble(null));
+            => CoefficientOfThermalExpansion.FromPpmPerKelvin(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs
index d5d03e5737..5c261502b1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs
@@ -32,81 +32,81 @@ namespace UnitsNet.NumberExtensions.NumberToCompressibility
     /// </summary>
     public static class NumberToCompressibilityExtensions
     {
-        /// <inheritdoc cref="Compressibility.FromInverseAtmospheres(double)" />
+        /// <inheritdoc cref="Compressibility.FromInverseAtmospheres(QuantityValue)" />
         public static Compressibility InverseAtmospheres<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Compressibility.FromInverseAtmospheres(double.CreateChecked(value));
+            => Compressibility.FromInverseAtmospheres(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Compressibility.FromInverseAtmospheres(value.ToDouble(null));
+            => Compressibility.FromInverseAtmospheres(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Compressibility.FromInverseBars(double)" />
+        /// <inheritdoc cref="Compressibility.FromInverseBars(QuantityValue)" />
         public static Compressibility InverseBars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Compressibility.FromInverseBars(double.CreateChecked(value));
+            => Compressibility.FromInverseBars(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Compressibility.FromInverseBars(value.ToDouble(null));
+            => Compressibility.FromInverseBars(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Compressibility.FromInverseKilopascals(double)" />
+        /// <inheritdoc cref="Compressibility.FromInverseKilopascals(QuantityValue)" />
         public static Compressibility InverseKilopascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Compressibility.FromInverseKilopascals(double.CreateChecked(value));
+            => Compressibility.FromInverseKilopascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Compressibility.FromInverseKilopascals(value.ToDouble(null));
+            => Compressibility.FromInverseKilopascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Compressibility.FromInverseMegapascals(double)" />
+        /// <inheritdoc cref="Compressibility.FromInverseMegapascals(QuantityValue)" />
         public static Compressibility InverseMegapascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Compressibility.FromInverseMegapascals(double.CreateChecked(value));
+            => Compressibility.FromInverseMegapascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Compressibility.FromInverseMegapascals(value.ToDouble(null));
+            => Compressibility.FromInverseMegapascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Compressibility.FromInverseMillibars(double)" />
+        /// <inheritdoc cref="Compressibility.FromInverseMillibars(QuantityValue)" />
         public static Compressibility InverseMillibars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Compressibility.FromInverseMillibars(double.CreateChecked(value));
+            => Compressibility.FromInverseMillibars(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Compressibility.FromInverseMillibars(value.ToDouble(null));
+            => Compressibility.FromInverseMillibars(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Compressibility.FromInversePascals(double)" />
+        /// <inheritdoc cref="Compressibility.FromInversePascals(QuantityValue)" />
         public static Compressibility InversePascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Compressibility.FromInversePascals(double.CreateChecked(value));
+            => Compressibility.FromInversePascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Compressibility.FromInversePascals(value.ToDouble(null));
+            => Compressibility.FromInversePascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Compressibility.FromInversePoundsForcePerSquareInch(double)" />
+        /// <inheritdoc cref="Compressibility.FromInversePoundsForcePerSquareInch(QuantityValue)" />
         public static Compressibility InversePoundsForcePerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Compressibility.FromInversePoundsForcePerSquareInch(double.CreateChecked(value));
+            => Compressibility.FromInversePoundsForcePerSquareInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Compressibility.FromInversePoundsForcePerSquareInch(value.ToDouble(null));
+            => Compressibility.FromInversePoundsForcePerSquareInch(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
index 41e548ce0c..b32202283f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
@@ -32,620 +32,620 @@ namespace UnitsNet.NumberExtensions.NumberToDensity
     /// </summary>
     public static class NumberToDensityExtensions
     {
-        /// <inheritdoc cref="Density.FromCentigramsPerDeciliter(double)" />
+        /// <inheritdoc cref="Density.FromCentigramsPerDeciliter(QuantityValue)" />
         public static Density CentigramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromCentigramsPerDeciliter(double.CreateChecked(value));
+            => Density.FromCentigramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromCentigramsPerDeciliter(value.ToDouble(null));
+            => Density.FromCentigramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromCentigramsPerLiter(double)" />
+        /// <inheritdoc cref="Density.FromCentigramsPerLiter(QuantityValue)" />
         public static Density CentigramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromCentigramsPerLiter(double.CreateChecked(value));
+            => Density.FromCentigramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromCentigramsPerLiter(value.ToDouble(null));
+            => Density.FromCentigramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromCentigramsPerMilliliter(double)" />
+        /// <inheritdoc cref="Density.FromCentigramsPerMilliliter(QuantityValue)" />
         public static Density CentigramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromCentigramsPerMilliliter(double.CreateChecked(value));
+            => Density.FromCentigramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromCentigramsPerMilliliter(value.ToDouble(null));
+            => Density.FromCentigramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromDecigramsPerDeciliter(double)" />
+        /// <inheritdoc cref="Density.FromDecigramsPerDeciliter(QuantityValue)" />
         public static Density DecigramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromDecigramsPerDeciliter(double.CreateChecked(value));
+            => Density.FromDecigramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromDecigramsPerDeciliter(value.ToDouble(null));
+            => Density.FromDecigramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromDecigramsPerLiter(double)" />
+        /// <inheritdoc cref="Density.FromDecigramsPerLiter(QuantityValue)" />
         public static Density DecigramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromDecigramsPerLiter(double.CreateChecked(value));
+            => Density.FromDecigramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromDecigramsPerLiter(value.ToDouble(null));
+            => Density.FromDecigramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromDecigramsPerMilliliter(double)" />
+        /// <inheritdoc cref="Density.FromDecigramsPerMilliliter(QuantityValue)" />
         public static Density DecigramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromDecigramsPerMilliliter(double.CreateChecked(value));
+            => Density.FromDecigramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromDecigramsPerMilliliter(value.ToDouble(null));
+            => Density.FromDecigramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromFemtogramsPerDeciliter(double)" />
+        /// <inheritdoc cref="Density.FromFemtogramsPerDeciliter(QuantityValue)" />
         public static Density FemtogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromFemtogramsPerDeciliter(double.CreateChecked(value));
+            => Density.FromFemtogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromFemtogramsPerDeciliter(value.ToDouble(null));
+            => Density.FromFemtogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromFemtogramsPerLiter(double)" />
+        /// <inheritdoc cref="Density.FromFemtogramsPerLiter(QuantityValue)" />
         public static Density FemtogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromFemtogramsPerLiter(double.CreateChecked(value));
+            => Density.FromFemtogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromFemtogramsPerLiter(value.ToDouble(null));
+            => Density.FromFemtogramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromFemtogramsPerMilliliter(double)" />
+        /// <inheritdoc cref="Density.FromFemtogramsPerMilliliter(QuantityValue)" />
         public static Density FemtogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromFemtogramsPerMilliliter(double.CreateChecked(value));
+            => Density.FromFemtogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromFemtogramsPerMilliliter(value.ToDouble(null));
+            => Density.FromFemtogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="Density.FromGramsPerCubicCentimeter(QuantityValue)" />
         public static Density GramsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromGramsPerCubicCentimeter(double.CreateChecked(value));
+            => Density.FromGramsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromGramsPerCubicCentimeter(value.ToDouble(null));
+            => Density.FromGramsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicFoot(double)" />
+        /// <inheritdoc cref="Density.FromGramsPerCubicFoot(QuantityValue)" />
         public static Density GramsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromGramsPerCubicFoot(double.CreateChecked(value));
+            => Density.FromGramsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromGramsPerCubicFoot(value.ToDouble(null));
+            => Density.FromGramsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicInch(double)" />
+        /// <inheritdoc cref="Density.FromGramsPerCubicInch(QuantityValue)" />
         public static Density GramsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromGramsPerCubicInch(double.CreateChecked(value));
+            => Density.FromGramsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromGramsPerCubicInch(value.ToDouble(null));
+            => Density.FromGramsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicMeter(double)" />
+        /// <inheritdoc cref="Density.FromGramsPerCubicMeter(QuantityValue)" />
         public static Density GramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromGramsPerCubicMeter(double.CreateChecked(value));
+            => Density.FromGramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromGramsPerCubicMeter(value.ToDouble(null));
+            => Density.FromGramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicMillimeter(double)" />
+        /// <inheritdoc cref="Density.FromGramsPerCubicMillimeter(QuantityValue)" />
         public static Density GramsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromGramsPerCubicMillimeter(double.CreateChecked(value));
+            => Density.FromGramsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromGramsPerCubicMillimeter(value.ToDouble(null));
+            => Density.FromGramsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromGramsPerDeciliter(double)" />
+        /// <inheritdoc cref="Density.FromGramsPerDeciliter(QuantityValue)" />
         public static Density GramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromGramsPerDeciliter(double.CreateChecked(value));
+            => Density.FromGramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromGramsPerDeciliter(value.ToDouble(null));
+            => Density.FromGramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromGramsPerLiter(double)" />
+        /// <inheritdoc cref="Density.FromGramsPerLiter(QuantityValue)" />
         public static Density GramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromGramsPerLiter(double.CreateChecked(value));
+            => Density.FromGramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromGramsPerLiter(value.ToDouble(null));
+            => Density.FromGramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromGramsPerMilliliter(double)" />
+        /// <inheritdoc cref="Density.FromGramsPerMilliliter(QuantityValue)" />
         public static Density GramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromGramsPerMilliliter(double.CreateChecked(value));
+            => Density.FromGramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromGramsPerMilliliter(value.ToDouble(null));
+            => Density.FromGramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromKilogramsPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="Density.FromKilogramsPerCubicCentimeter(QuantityValue)" />
         public static Density KilogramsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromKilogramsPerCubicCentimeter(double.CreateChecked(value));
+            => Density.FromKilogramsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromKilogramsPerCubicCentimeter(value.ToDouble(null));
+            => Density.FromKilogramsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromKilogramsPerCubicMeter(double)" />
+        /// <inheritdoc cref="Density.FromKilogramsPerCubicMeter(QuantityValue)" />
         public static Density KilogramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromKilogramsPerCubicMeter(double.CreateChecked(value));
+            => Density.FromKilogramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromKilogramsPerCubicMeter(value.ToDouble(null));
+            => Density.FromKilogramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromKilogramsPerCubicMillimeter(double)" />
+        /// <inheritdoc cref="Density.FromKilogramsPerCubicMillimeter(QuantityValue)" />
         public static Density KilogramsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromKilogramsPerCubicMillimeter(double.CreateChecked(value));
+            => Density.FromKilogramsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromKilogramsPerCubicMillimeter(value.ToDouble(null));
+            => Density.FromKilogramsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromKilogramsPerLiter(double)" />
+        /// <inheritdoc cref="Density.FromKilogramsPerLiter(QuantityValue)" />
         public static Density KilogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromKilogramsPerLiter(double.CreateChecked(value));
+            => Density.FromKilogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromKilogramsPerLiter(value.ToDouble(null));
+            => Density.FromKilogramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromKilopoundsPerCubicFoot(double)" />
+        /// <inheritdoc cref="Density.FromKilopoundsPerCubicFoot(QuantityValue)" />
         public static Density KilopoundsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromKilopoundsPerCubicFoot(double.CreateChecked(value));
+            => Density.FromKilopoundsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromKilopoundsPerCubicFoot(value.ToDouble(null));
+            => Density.FromKilopoundsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromKilopoundsPerCubicInch(double)" />
+        /// <inheritdoc cref="Density.FromKilopoundsPerCubicInch(QuantityValue)" />
         public static Density KilopoundsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromKilopoundsPerCubicInch(double.CreateChecked(value));
+            => Density.FromKilopoundsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromKilopoundsPerCubicInch(value.ToDouble(null));
+            => Density.FromKilopoundsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromKilopoundsPerCubicYard(double)" />
+        /// <inheritdoc cref="Density.FromKilopoundsPerCubicYard(QuantityValue)" />
         public static Density KilopoundsPerCubicYard<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromKilopoundsPerCubicYard(double.CreateChecked(value));
+            => Density.FromKilopoundsPerCubicYard(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromKilopoundsPerCubicYard(value.ToDouble(null));
+            => Density.FromKilopoundsPerCubicYard(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerCubicMeter(double)" />
+        /// <inheritdoc cref="Density.FromMicrogramsPerCubicMeter(QuantityValue)" />
         public static Density MicrogramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromMicrogramsPerCubicMeter(double.CreateChecked(value));
+            => Density.FromMicrogramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromMicrogramsPerCubicMeter(value.ToDouble(null));
+            => Density.FromMicrogramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerDeciliter(double)" />
+        /// <inheritdoc cref="Density.FromMicrogramsPerDeciliter(QuantityValue)" />
         public static Density MicrogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromMicrogramsPerDeciliter(double.CreateChecked(value));
+            => Density.FromMicrogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromMicrogramsPerDeciliter(value.ToDouble(null));
+            => Density.FromMicrogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerLiter(double)" />
+        /// <inheritdoc cref="Density.FromMicrogramsPerLiter(QuantityValue)" />
         public static Density MicrogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromMicrogramsPerLiter(double.CreateChecked(value));
+            => Density.FromMicrogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromMicrogramsPerLiter(value.ToDouble(null));
+            => Density.FromMicrogramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerMilliliter(double)" />
+        /// <inheritdoc cref="Density.FromMicrogramsPerMilliliter(QuantityValue)" />
         public static Density MicrogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromMicrogramsPerMilliliter(double.CreateChecked(value));
+            => Density.FromMicrogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromMicrogramsPerMilliliter(value.ToDouble(null));
+            => Density.FromMicrogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromMilligramsPerCubicMeter(double)" />
+        /// <inheritdoc cref="Density.FromMilligramsPerCubicMeter(QuantityValue)" />
         public static Density MilligramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromMilligramsPerCubicMeter(double.CreateChecked(value));
+            => Density.FromMilligramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromMilligramsPerCubicMeter(value.ToDouble(null));
+            => Density.FromMilligramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromMilligramsPerDeciliter(double)" />
+        /// <inheritdoc cref="Density.FromMilligramsPerDeciliter(QuantityValue)" />
         public static Density MilligramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromMilligramsPerDeciliter(double.CreateChecked(value));
+            => Density.FromMilligramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromMilligramsPerDeciliter(value.ToDouble(null));
+            => Density.FromMilligramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromMilligramsPerLiter(double)" />
+        /// <inheritdoc cref="Density.FromMilligramsPerLiter(QuantityValue)" />
         public static Density MilligramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromMilligramsPerLiter(double.CreateChecked(value));
+            => Density.FromMilligramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromMilligramsPerLiter(value.ToDouble(null));
+            => Density.FromMilligramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromMilligramsPerMilliliter(double)" />
+        /// <inheritdoc cref="Density.FromMilligramsPerMilliliter(QuantityValue)" />
         public static Density MilligramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromMilligramsPerMilliliter(double.CreateChecked(value));
+            => Density.FromMilligramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromMilligramsPerMilliliter(value.ToDouble(null));
+            => Density.FromMilligramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromNanogramsPerDeciliter(double)" />
+        /// <inheritdoc cref="Density.FromNanogramsPerDeciliter(QuantityValue)" />
         public static Density NanogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromNanogramsPerDeciliter(double.CreateChecked(value));
+            => Density.FromNanogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromNanogramsPerDeciliter(value.ToDouble(null));
+            => Density.FromNanogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromNanogramsPerLiter(double)" />
+        /// <inheritdoc cref="Density.FromNanogramsPerLiter(QuantityValue)" />
         public static Density NanogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromNanogramsPerLiter(double.CreateChecked(value));
+            => Density.FromNanogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromNanogramsPerLiter(value.ToDouble(null));
+            => Density.FromNanogramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromNanogramsPerMilliliter(double)" />
+        /// <inheritdoc cref="Density.FromNanogramsPerMilliliter(QuantityValue)" />
         public static Density NanogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromNanogramsPerMilliliter(double.CreateChecked(value));
+            => Density.FromNanogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromNanogramsPerMilliliter(value.ToDouble(null));
+            => Density.FromNanogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPicogramsPerDeciliter(double)" />
+        /// <inheritdoc cref="Density.FromPicogramsPerDeciliter(QuantityValue)" />
         public static Density PicogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPicogramsPerDeciliter(double.CreateChecked(value));
+            => Density.FromPicogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPicogramsPerDeciliter(value.ToDouble(null));
+            => Density.FromPicogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPicogramsPerLiter(double)" />
+        /// <inheritdoc cref="Density.FromPicogramsPerLiter(QuantityValue)" />
         public static Density PicogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPicogramsPerLiter(double.CreateChecked(value));
+            => Density.FromPicogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPicogramsPerLiter(value.ToDouble(null));
+            => Density.FromPicogramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPicogramsPerMilliliter(double)" />
+        /// <inheritdoc cref="Density.FromPicogramsPerMilliliter(QuantityValue)" />
         public static Density PicogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPicogramsPerMilliliter(double.CreateChecked(value));
+            => Density.FromPicogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPicogramsPerMilliliter(value.ToDouble(null));
+            => Density.FromPicogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicCentimeter(QuantityValue)" />
         public static Density PoundsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPoundsPerCubicCentimeter(double.CreateChecked(value));
+            => Density.FromPoundsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPoundsPerCubicCentimeter(value.ToDouble(null));
+            => Density.FromPoundsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicFoot(double)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicFoot(QuantityValue)" />
         public static Density PoundsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPoundsPerCubicFoot(double.CreateChecked(value));
+            => Density.FromPoundsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPoundsPerCubicFoot(value.ToDouble(null));
+            => Density.FromPoundsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicInch(double)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicInch(QuantityValue)" />
         public static Density PoundsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPoundsPerCubicInch(double.CreateChecked(value));
+            => Density.FromPoundsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPoundsPerCubicInch(value.ToDouble(null));
+            => Density.FromPoundsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicMeter(double)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicMeter(QuantityValue)" />
         public static Density PoundsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPoundsPerCubicMeter(double.CreateChecked(value));
+            => Density.FromPoundsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPoundsPerCubicMeter(value.ToDouble(null));
+            => Density.FromPoundsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicMillimeter(double)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicMillimeter(QuantityValue)" />
         public static Density PoundsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPoundsPerCubicMillimeter(double.CreateChecked(value));
+            => Density.FromPoundsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPoundsPerCubicMillimeter(value.ToDouble(null));
+            => Density.FromPoundsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicYard(double)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicYard(QuantityValue)" />
         public static Density PoundsPerCubicYard<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPoundsPerCubicYard(double.CreateChecked(value));
+            => Density.FromPoundsPerCubicYard(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPoundsPerCubicYard(value.ToDouble(null));
+            => Density.FromPoundsPerCubicYard(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPoundsPerImperialGallon(double)" />
+        /// <inheritdoc cref="Density.FromPoundsPerImperialGallon(QuantityValue)" />
         public static Density PoundsPerImperialGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPoundsPerImperialGallon(double.CreateChecked(value));
+            => Density.FromPoundsPerImperialGallon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPoundsPerImperialGallon(value.ToDouble(null));
+            => Density.FromPoundsPerImperialGallon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromPoundsPerUSGallon(double)" />
+        /// <inheritdoc cref="Density.FromPoundsPerUSGallon(QuantityValue)" />
         public static Density PoundsPerUSGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromPoundsPerUSGallon(double.CreateChecked(value));
+            => Density.FromPoundsPerUSGallon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromPoundsPerUSGallon(value.ToDouble(null));
+            => Density.FromPoundsPerUSGallon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="Density.FromSlugsPerCubicCentimeter(QuantityValue)" />
         public static Density SlugsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromSlugsPerCubicCentimeter(double.CreateChecked(value));
+            => Density.FromSlugsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromSlugsPerCubicCentimeter(value.ToDouble(null));
+            => Density.FromSlugsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicFoot(double)" />
+        /// <inheritdoc cref="Density.FromSlugsPerCubicFoot(QuantityValue)" />
         public static Density SlugsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromSlugsPerCubicFoot(double.CreateChecked(value));
+            => Density.FromSlugsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromSlugsPerCubicFoot(value.ToDouble(null));
+            => Density.FromSlugsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicInch(double)" />
+        /// <inheritdoc cref="Density.FromSlugsPerCubicInch(QuantityValue)" />
         public static Density SlugsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromSlugsPerCubicInch(double.CreateChecked(value));
+            => Density.FromSlugsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromSlugsPerCubicInch(value.ToDouble(null));
+            => Density.FromSlugsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicMeter(double)" />
+        /// <inheritdoc cref="Density.FromSlugsPerCubicMeter(QuantityValue)" />
         public static Density SlugsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromSlugsPerCubicMeter(double.CreateChecked(value));
+            => Density.FromSlugsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromSlugsPerCubicMeter(value.ToDouble(null));
+            => Density.FromSlugsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicMillimeter(double)" />
+        /// <inheritdoc cref="Density.FromSlugsPerCubicMillimeter(QuantityValue)" />
         public static Density SlugsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromSlugsPerCubicMillimeter(double.CreateChecked(value));
+            => Density.FromSlugsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromSlugsPerCubicMillimeter(value.ToDouble(null));
+            => Density.FromSlugsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="Density.FromTonnesPerCubicCentimeter(QuantityValue)" />
         public static Density TonnesPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromTonnesPerCubicCentimeter(double.CreateChecked(value));
+            => Density.FromTonnesPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromTonnesPerCubicCentimeter(value.ToDouble(null));
+            => Density.FromTonnesPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicFoot(double)" />
+        /// <inheritdoc cref="Density.FromTonnesPerCubicFoot(QuantityValue)" />
         public static Density TonnesPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromTonnesPerCubicFoot(double.CreateChecked(value));
+            => Density.FromTonnesPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromTonnesPerCubicFoot(value.ToDouble(null));
+            => Density.FromTonnesPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicInch(double)" />
+        /// <inheritdoc cref="Density.FromTonnesPerCubicInch(QuantityValue)" />
         public static Density TonnesPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromTonnesPerCubicInch(double.CreateChecked(value));
+            => Density.FromTonnesPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromTonnesPerCubicInch(value.ToDouble(null));
+            => Density.FromTonnesPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicMeter(double)" />
+        /// <inheritdoc cref="Density.FromTonnesPerCubicMeter(QuantityValue)" />
         public static Density TonnesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromTonnesPerCubicMeter(double.CreateChecked(value));
+            => Density.FromTonnesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromTonnesPerCubicMeter(value.ToDouble(null));
+            => Density.FromTonnesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicMillimeter(double)" />
+        /// <inheritdoc cref="Density.FromTonnesPerCubicMillimeter(QuantityValue)" />
         public static Density TonnesPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Density.FromTonnesPerCubicMillimeter(double.CreateChecked(value));
+            => Density.FromTonnesPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Density.FromTonnesPerCubicMillimeter(value.ToDouble(null));
+            => Density.FromTonnesPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs
index b0a770e93d..87715fc479 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs
@@ -32,279 +32,279 @@ namespace UnitsNet.NumberExtensions.NumberToDoseAreaProduct
     /// </summary>
     public static class NumberToDoseAreaProductExtensions
     {
-        /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareCentimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareCentimeters(QuantityValue)" />
         public static DoseAreaProduct CentigraySquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromCentigraySquareCentimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromCentigraySquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromCentigraySquareCentimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromCentigraySquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareDecimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareDecimeters(QuantityValue)" />
         public static DoseAreaProduct CentigraySquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromCentigraySquareDecimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromCentigraySquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromCentigraySquareDecimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromCentigraySquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMeters(QuantityValue)" />
         public static DoseAreaProduct CentigraySquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromCentigraySquareMeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromCentigraySquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromCentigraySquareMeters(value.ToDouble(null));
+            => DoseAreaProduct.FromCentigraySquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMicrometers(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMicrometers(QuantityValue)" />
         public static DoseAreaProduct CentigraySquareMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromCentigraySquareMicrometers(double.CreateChecked(value));
+            => DoseAreaProduct.FromCentigraySquareMicrometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromCentigraySquareMicrometers(value.ToDouble(null));
+            => DoseAreaProduct.FromCentigraySquareMicrometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMillimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromCentigraySquareMillimeters(QuantityValue)" />
         public static DoseAreaProduct CentigraySquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromCentigraySquareMillimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromCentigraySquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromCentigraySquareMillimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromCentigraySquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareCentimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareCentimeters(QuantityValue)" />
         public static DoseAreaProduct DecigraySquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromDecigraySquareCentimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromDecigraySquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromDecigraySquareCentimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromDecigraySquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareDecimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareDecimeters(QuantityValue)" />
         public static DoseAreaProduct DecigraySquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromDecigraySquareDecimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromDecigraySquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromDecigraySquareDecimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromDecigraySquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMeters(QuantityValue)" />
         public static DoseAreaProduct DecigraySquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromDecigraySquareMeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromDecigraySquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromDecigraySquareMeters(value.ToDouble(null));
+            => DoseAreaProduct.FromDecigraySquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMicrometers(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMicrometers(QuantityValue)" />
         public static DoseAreaProduct DecigraySquareMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromDecigraySquareMicrometers(double.CreateChecked(value));
+            => DoseAreaProduct.FromDecigraySquareMicrometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromDecigraySquareMicrometers(value.ToDouble(null));
+            => DoseAreaProduct.FromDecigraySquareMicrometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMillimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromDecigraySquareMillimeters(QuantityValue)" />
         public static DoseAreaProduct DecigraySquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromDecigraySquareMillimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromDecigraySquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromDecigraySquareMillimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromDecigraySquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromGraySquareCentimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromGraySquareCentimeters(QuantityValue)" />
         public static DoseAreaProduct GraySquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromGraySquareCentimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromGraySquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromGraySquareCentimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromGraySquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromGraySquareDecimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromGraySquareDecimeters(QuantityValue)" />
         public static DoseAreaProduct GraySquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromGraySquareDecimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromGraySquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromGraySquareDecimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromGraySquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMeters(QuantityValue)" />
         public static DoseAreaProduct GraySquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromGraySquareMeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromGraySquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromGraySquareMeters(value.ToDouble(null));
+            => DoseAreaProduct.FromGraySquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMicrometers(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMicrometers(QuantityValue)" />
         public static DoseAreaProduct GraySquareMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromGraySquareMicrometers(double.CreateChecked(value));
+            => DoseAreaProduct.FromGraySquareMicrometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromGraySquareMicrometers(value.ToDouble(null));
+            => DoseAreaProduct.FromGraySquareMicrometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMillimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromGraySquareMillimeters(QuantityValue)" />
         public static DoseAreaProduct GraySquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromGraySquareMillimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromGraySquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromGraySquareMillimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromGraySquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareCentimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareCentimeters(QuantityValue)" />
         public static DoseAreaProduct MicrograySquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromMicrograySquareCentimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromMicrograySquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromMicrograySquareCentimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromMicrograySquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareDecimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareDecimeters(QuantityValue)" />
         public static DoseAreaProduct MicrograySquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromMicrograySquareDecimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromMicrograySquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromMicrograySquareDecimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromMicrograySquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMeters(QuantityValue)" />
         public static DoseAreaProduct MicrograySquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromMicrograySquareMeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromMicrograySquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromMicrograySquareMeters(value.ToDouble(null));
+            => DoseAreaProduct.FromMicrograySquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMicrometers(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMicrometers(QuantityValue)" />
         public static DoseAreaProduct MicrograySquareMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromMicrograySquareMicrometers(double.CreateChecked(value));
+            => DoseAreaProduct.FromMicrograySquareMicrometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromMicrograySquareMicrometers(value.ToDouble(null));
+            => DoseAreaProduct.FromMicrograySquareMicrometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMillimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromMicrograySquareMillimeters(QuantityValue)" />
         public static DoseAreaProduct MicrograySquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromMicrograySquareMillimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromMicrograySquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromMicrograySquareMillimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromMicrograySquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareCentimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareCentimeters(QuantityValue)" />
         public static DoseAreaProduct MilligraySquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromMilligraySquareCentimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromMilligraySquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromMilligraySquareCentimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromMilligraySquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareDecimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareDecimeters(QuantityValue)" />
         public static DoseAreaProduct MilligraySquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromMilligraySquareDecimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromMilligraySquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromMilligraySquareDecimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromMilligraySquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMeters(QuantityValue)" />
         public static DoseAreaProduct MilligraySquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromMilligraySquareMeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromMilligraySquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromMilligraySquareMeters(value.ToDouble(null));
+            => DoseAreaProduct.FromMilligraySquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMicrometers(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMicrometers(QuantityValue)" />
         public static DoseAreaProduct MilligraySquareMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromMilligraySquareMicrometers(double.CreateChecked(value));
+            => DoseAreaProduct.FromMilligraySquareMicrometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromMilligraySquareMicrometers(value.ToDouble(null));
+            => DoseAreaProduct.FromMilligraySquareMicrometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMillimeters(double)" />
+        /// <inheritdoc cref="DoseAreaProduct.FromMilligraySquareMillimeters(QuantityValue)" />
         public static DoseAreaProduct MilligraySquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DoseAreaProduct.FromMilligraySquareMillimeters(double.CreateChecked(value));
+            => DoseAreaProduct.FromMilligraySquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DoseAreaProduct.FromMilligraySquareMillimeters(value.ToDouble(null));
+            => DoseAreaProduct.FromMilligraySquareMillimeters(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
index 55aa0a6a3a..a5758fbfea 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
@@ -32,147 +32,147 @@ namespace UnitsNet.NumberExtensions.NumberToDuration
     /// </summary>
     public static class NumberToDurationExtensions
     {
-        /// <inheritdoc cref="Duration.FromDays(double)" />
+        /// <inheritdoc cref="Duration.FromDays(QuantityValue)" />
         public static Duration Days<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromDays(double.CreateChecked(value));
+            => Duration.FromDays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromDays(value.ToDouble(null));
+            => Duration.FromDays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromHours(double)" />
+        /// <inheritdoc cref="Duration.FromHours(QuantityValue)" />
         public static Duration Hours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromHours(double.CreateChecked(value));
+            => Duration.FromHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromHours(value.ToDouble(null));
+            => Duration.FromHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromJulianYears(double)" />
+        /// <inheritdoc cref="Duration.FromJulianYears(QuantityValue)" />
         public static Duration JulianYears<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromJulianYears(double.CreateChecked(value));
+            => Duration.FromJulianYears(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromJulianYears(value.ToDouble(null));
+            => Duration.FromJulianYears(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromMicroseconds(double)" />
+        /// <inheritdoc cref="Duration.FromMicroseconds(QuantityValue)" />
         public static Duration Microseconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromMicroseconds(double.CreateChecked(value));
+            => Duration.FromMicroseconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromMicroseconds(value.ToDouble(null));
+            => Duration.FromMicroseconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromMilliseconds(double)" />
+        /// <inheritdoc cref="Duration.FromMilliseconds(QuantityValue)" />
         public static Duration Milliseconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromMilliseconds(double.CreateChecked(value));
+            => Duration.FromMilliseconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromMilliseconds(value.ToDouble(null));
+            => Duration.FromMilliseconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromMinutes(double)" />
+        /// <inheritdoc cref="Duration.FromMinutes(QuantityValue)" />
         public static Duration Minutes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromMinutes(double.CreateChecked(value));
+            => Duration.FromMinutes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromMinutes(value.ToDouble(null));
+            => Duration.FromMinutes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromMonths30(double)" />
+        /// <inheritdoc cref="Duration.FromMonths30(QuantityValue)" />
         public static Duration Months30<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromMonths30(double.CreateChecked(value));
+            => Duration.FromMonths30(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromMonths30(value.ToDouble(null));
+            => Duration.FromMonths30(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromNanoseconds(double)" />
+        /// <inheritdoc cref="Duration.FromNanoseconds(QuantityValue)" />
         public static Duration Nanoseconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromNanoseconds(double.CreateChecked(value));
+            => Duration.FromNanoseconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromNanoseconds(value.ToDouble(null));
+            => Duration.FromNanoseconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromPicoseconds(double)" />
+        /// <inheritdoc cref="Duration.FromPicoseconds(QuantityValue)" />
         public static Duration Picoseconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromPicoseconds(double.CreateChecked(value));
+            => Duration.FromPicoseconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromPicoseconds(value.ToDouble(null));
+            => Duration.FromPicoseconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromSeconds(double)" />
+        /// <inheritdoc cref="Duration.FromSeconds(QuantityValue)" />
         public static Duration Seconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromSeconds(double.CreateChecked(value));
+            => Duration.FromSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromSeconds(value.ToDouble(null));
+            => Duration.FromSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromSols(double)" />
+        /// <inheritdoc cref="Duration.FromSols(QuantityValue)" />
         public static Duration Sols<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromSols(double.CreateChecked(value));
+            => Duration.FromSols(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromSols(value.ToDouble(null));
+            => Duration.FromSols(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromWeeks(double)" />
+        /// <inheritdoc cref="Duration.FromWeeks(QuantityValue)" />
         public static Duration Weeks<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromWeeks(double.CreateChecked(value));
+            => Duration.FromWeeks(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromWeeks(value.ToDouble(null));
+            => Duration.FromWeeks(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Duration.FromYears365(double)" />
+        /// <inheritdoc cref="Duration.FromYears365(QuantityValue)" />
         public static Duration Years365<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Duration.FromYears365(double.CreateChecked(value));
+            => Duration.FromYears365(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Duration.FromYears365(value.ToDouble(null));
+            => Duration.FromYears365(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
index 037a0eaf3a..a5a5b0fd37 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
@@ -32,114 +32,114 @@ namespace UnitsNet.NumberExtensions.NumberToDynamicViscosity
     /// </summary>
     public static class NumberToDynamicViscosityExtensions
     {
-        /// <inheritdoc cref="DynamicViscosity.FromCentipoise(double)" />
+        /// <inheritdoc cref="DynamicViscosity.FromCentipoise(QuantityValue)" />
         public static DynamicViscosity Centipoise<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DynamicViscosity.FromCentipoise(double.CreateChecked(value));
+            => DynamicViscosity.FromCentipoise(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DynamicViscosity.FromCentipoise(value.ToDouble(null));
+            => DynamicViscosity.FromCentipoise(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DynamicViscosity.FromMicropascalSeconds(double)" />
+        /// <inheritdoc cref="DynamicViscosity.FromMicropascalSeconds(QuantityValue)" />
         public static DynamicViscosity MicropascalSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DynamicViscosity.FromMicropascalSeconds(double.CreateChecked(value));
+            => DynamicViscosity.FromMicropascalSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DynamicViscosity.FromMicropascalSeconds(value.ToDouble(null));
+            => DynamicViscosity.FromMicropascalSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DynamicViscosity.FromMillipascalSeconds(double)" />
+        /// <inheritdoc cref="DynamicViscosity.FromMillipascalSeconds(QuantityValue)" />
         public static DynamicViscosity MillipascalSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DynamicViscosity.FromMillipascalSeconds(double.CreateChecked(value));
+            => DynamicViscosity.FromMillipascalSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DynamicViscosity.FromMillipascalSeconds(value.ToDouble(null));
+            => DynamicViscosity.FromMillipascalSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DynamicViscosity.FromNewtonSecondsPerMeterSquared(double)" />
+        /// <inheritdoc cref="DynamicViscosity.FromNewtonSecondsPerMeterSquared(QuantityValue)" />
         public static DynamicViscosity NewtonSecondsPerMeterSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DynamicViscosity.FromNewtonSecondsPerMeterSquared(double.CreateChecked(value));
+            => DynamicViscosity.FromNewtonSecondsPerMeterSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DynamicViscosity.FromNewtonSecondsPerMeterSquared(value.ToDouble(null));
+            => DynamicViscosity.FromNewtonSecondsPerMeterSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DynamicViscosity.FromPascalSeconds(double)" />
+        /// <inheritdoc cref="DynamicViscosity.FromPascalSeconds(QuantityValue)" />
         public static DynamicViscosity PascalSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DynamicViscosity.FromPascalSeconds(double.CreateChecked(value));
+            => DynamicViscosity.FromPascalSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DynamicViscosity.FromPascalSeconds(value.ToDouble(null));
+            => DynamicViscosity.FromPascalSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoise(double)" />
+        /// <inheritdoc cref="DynamicViscosity.FromPoise(QuantityValue)" />
         public static DynamicViscosity Poise<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DynamicViscosity.FromPoise(double.CreateChecked(value));
+            => DynamicViscosity.FromPoise(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DynamicViscosity.FromPoise(value.ToDouble(null));
+            => DynamicViscosity.FromPoise(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareFoot(double)" />
+        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareFoot(QuantityValue)" />
         public static DynamicViscosity PoundsForceSecondPerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(double.CreateChecked(value));
+            => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(value.ToDouble(null));
+            => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareInch(double)" />
+        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareInch(QuantityValue)" />
         public static DynamicViscosity PoundsForceSecondPerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DynamicViscosity.FromPoundsForceSecondPerSquareInch(double.CreateChecked(value));
+            => DynamicViscosity.FromPoundsForceSecondPerSquareInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DynamicViscosity.FromPoundsForceSecondPerSquareInch(value.ToDouble(null));
+            => DynamicViscosity.FromPoundsForceSecondPerSquareInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoundsPerFootSecond(double)" />
+        /// <inheritdoc cref="DynamicViscosity.FromPoundsPerFootSecond(QuantityValue)" />
         public static DynamicViscosity PoundsPerFootSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DynamicViscosity.FromPoundsPerFootSecond(double.CreateChecked(value));
+            => DynamicViscosity.FromPoundsPerFootSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DynamicViscosity.FromPoundsPerFootSecond(value.ToDouble(null));
+            => DynamicViscosity.FromPoundsPerFootSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="DynamicViscosity.FromReyns(double)" />
+        /// <inheritdoc cref="DynamicViscosity.FromReyns(QuantityValue)" />
         public static DynamicViscosity Reyns<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => DynamicViscosity.FromReyns(double.CreateChecked(value));
+            => DynamicViscosity.FromReyns(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => DynamicViscosity.FromReyns(value.ToDouble(null));
+            => DynamicViscosity.FromReyns(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
index c8ec024579..9bfd71cc75 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
@@ -33,196 +33,196 @@ namespace UnitsNet.NumberExtensions.NumberToElectricAdmittance
     [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
     public static class NumberToElectricAdmittanceExtensions
     {
-        /// <inheritdoc cref="ElectricAdmittance.FromGigamhos(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromGigamhos(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Gigamhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromGigamhos(double.CreateChecked(value));
+            => ElectricAdmittance.FromGigamhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromGigamhos(value.ToDouble(null));
+            => ElectricAdmittance.FromGigamhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromGigasiemens(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromGigasiemens(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Gigasiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromGigasiemens(double.CreateChecked(value));
+            => ElectricAdmittance.FromGigasiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromGigasiemens(value.ToDouble(null));
+            => ElectricAdmittance.FromGigasiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromKilomhos(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromKilomhos(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Kilomhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromKilomhos(double.CreateChecked(value));
+            => ElectricAdmittance.FromKilomhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromKilomhos(value.ToDouble(null));
+            => ElectricAdmittance.FromKilomhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromKilosiemens(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromKilosiemens(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Kilosiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromKilosiemens(double.CreateChecked(value));
+            => ElectricAdmittance.FromKilosiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromKilosiemens(value.ToDouble(null));
+            => ElectricAdmittance.FromKilosiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromMegamhos(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromMegamhos(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Megamhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromMegamhos(double.CreateChecked(value));
+            => ElectricAdmittance.FromMegamhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromMegamhos(value.ToDouble(null));
+            => ElectricAdmittance.FromMegamhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromMegasiemens(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromMegasiemens(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Megasiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromMegasiemens(double.CreateChecked(value));
+            => ElectricAdmittance.FromMegasiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromMegasiemens(value.ToDouble(null));
+            => ElectricAdmittance.FromMegasiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromMhos(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromMhos(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Mhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromMhos(double.CreateChecked(value));
+            => ElectricAdmittance.FromMhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromMhos(value.ToDouble(null));
+            => ElectricAdmittance.FromMhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromMicromhos(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromMicromhos(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Micromhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromMicromhos(double.CreateChecked(value));
+            => ElectricAdmittance.FromMicromhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromMicromhos(value.ToDouble(null));
+            => ElectricAdmittance.FromMicromhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromMicrosiemens(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromMicrosiemens(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Microsiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromMicrosiemens(double.CreateChecked(value));
+            => ElectricAdmittance.FromMicrosiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromMicrosiemens(value.ToDouble(null));
+            => ElectricAdmittance.FromMicrosiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromMillimhos(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromMillimhos(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Millimhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromMillimhos(double.CreateChecked(value));
+            => ElectricAdmittance.FromMillimhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromMillimhos(value.ToDouble(null));
+            => ElectricAdmittance.FromMillimhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromMillisiemens(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromMillisiemens(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Millisiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromMillisiemens(double.CreateChecked(value));
+            => ElectricAdmittance.FromMillisiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromMillisiemens(value.ToDouble(null));
+            => ElectricAdmittance.FromMillisiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromNanomhos(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromNanomhos(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Nanomhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromNanomhos(double.CreateChecked(value));
+            => ElectricAdmittance.FromNanomhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromNanomhos(value.ToDouble(null));
+            => ElectricAdmittance.FromNanomhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromNanosiemens(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromNanosiemens(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Nanosiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromNanosiemens(double.CreateChecked(value));
+            => ElectricAdmittance.FromNanosiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromNanosiemens(value.ToDouble(null));
+            => ElectricAdmittance.FromNanosiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromSiemens(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromSiemens(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Siemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromSiemens(double.CreateChecked(value));
+            => ElectricAdmittance.FromSiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromSiemens(value.ToDouble(null));
+            => ElectricAdmittance.FromSiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromTeramhos(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromTeramhos(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Teramhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromTeramhos(double.CreateChecked(value));
+            => ElectricAdmittance.FromTeramhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromTeramhos(value.ToDouble(null));
+            => ElectricAdmittance.FromTeramhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricAdmittance.FromTerasiemens(double)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromTerasiemens(QuantityValue)" />
         [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
         public static ElectricAdmittance Terasiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricAdmittance.FromTerasiemens(double.CreateChecked(value));
+            => ElectricAdmittance.FromTerasiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricAdmittance.FromTerasiemens(value.ToDouble(null));
+            => ElectricAdmittance.FromTerasiemens(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs
index 68150d2888..6d5c3d32b2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs
@@ -32,37 +32,37 @@ namespace UnitsNet.NumberExtensions.NumberToElectricApparentEnergy
     /// </summary>
     public static class NumberToElectricApparentEnergyExtensions
     {
-        /// <inheritdoc cref="ElectricApparentEnergy.FromKilovoltampereHours(double)" />
+        /// <inheritdoc cref="ElectricApparentEnergy.FromKilovoltampereHours(QuantityValue)" />
         public static ElectricApparentEnergy KilovoltampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricApparentEnergy.FromKilovoltampereHours(double.CreateChecked(value));
+            => ElectricApparentEnergy.FromKilovoltampereHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricApparentEnergy.FromKilovoltampereHours(value.ToDouble(null));
+            => ElectricApparentEnergy.FromKilovoltampereHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricApparentEnergy.FromMegavoltampereHours(double)" />
+        /// <inheritdoc cref="ElectricApparentEnergy.FromMegavoltampereHours(QuantityValue)" />
         public static ElectricApparentEnergy MegavoltampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricApparentEnergy.FromMegavoltampereHours(double.CreateChecked(value));
+            => ElectricApparentEnergy.FromMegavoltampereHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricApparentEnergy.FromMegavoltampereHours(value.ToDouble(null));
+            => ElectricApparentEnergy.FromMegavoltampereHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricApparentEnergy.FromVoltampereHours(double)" />
+        /// <inheritdoc cref="ElectricApparentEnergy.FromVoltampereHours(QuantityValue)" />
         public static ElectricApparentEnergy VoltampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricApparentEnergy.FromVoltampereHours(double.CreateChecked(value));
+            => ElectricApparentEnergy.FromVoltampereHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricApparentEnergy.FromVoltampereHours(value.ToDouble(null));
+            => ElectricApparentEnergy.FromVoltampereHours(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs
index 239697de4b..5d37bc497d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs
@@ -32,70 +32,70 @@ namespace UnitsNet.NumberExtensions.NumberToElectricApparentPower
     /// </summary>
     public static class NumberToElectricApparentPowerExtensions
     {
-        /// <inheritdoc cref="ElectricApparentPower.FromGigavoltamperes(double)" />
+        /// <inheritdoc cref="ElectricApparentPower.FromGigavoltamperes(QuantityValue)" />
         public static ElectricApparentPower Gigavoltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricApparentPower.FromGigavoltamperes(double.CreateChecked(value));
+            => ElectricApparentPower.FromGigavoltamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricApparentPower.FromGigavoltamperes(value.ToDouble(null));
+            => ElectricApparentPower.FromGigavoltamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricApparentPower.FromKilovoltamperes(double)" />
+        /// <inheritdoc cref="ElectricApparentPower.FromKilovoltamperes(QuantityValue)" />
         public static ElectricApparentPower Kilovoltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricApparentPower.FromKilovoltamperes(double.CreateChecked(value));
+            => ElectricApparentPower.FromKilovoltamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricApparentPower.FromKilovoltamperes(value.ToDouble(null));
+            => ElectricApparentPower.FromKilovoltamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricApparentPower.FromMegavoltamperes(double)" />
+        /// <inheritdoc cref="ElectricApparentPower.FromMegavoltamperes(QuantityValue)" />
         public static ElectricApparentPower Megavoltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricApparentPower.FromMegavoltamperes(double.CreateChecked(value));
+            => ElectricApparentPower.FromMegavoltamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricApparentPower.FromMegavoltamperes(value.ToDouble(null));
+            => ElectricApparentPower.FromMegavoltamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricApparentPower.FromMicrovoltamperes(double)" />
+        /// <inheritdoc cref="ElectricApparentPower.FromMicrovoltamperes(QuantityValue)" />
         public static ElectricApparentPower Microvoltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricApparentPower.FromMicrovoltamperes(double.CreateChecked(value));
+            => ElectricApparentPower.FromMicrovoltamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricApparentPower.FromMicrovoltamperes(value.ToDouble(null));
+            => ElectricApparentPower.FromMicrovoltamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricApparentPower.FromMillivoltamperes(double)" />
+        /// <inheritdoc cref="ElectricApparentPower.FromMillivoltamperes(QuantityValue)" />
         public static ElectricApparentPower Millivoltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricApparentPower.FromMillivoltamperes(double.CreateChecked(value));
+            => ElectricApparentPower.FromMillivoltamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricApparentPower.FromMillivoltamperes(value.ToDouble(null));
+            => ElectricApparentPower.FromMillivoltamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricApparentPower.FromVoltamperes(double)" />
+        /// <inheritdoc cref="ElectricApparentPower.FromVoltamperes(QuantityValue)" />
         public static ElectricApparentPower Voltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricApparentPower.FromVoltamperes(double.CreateChecked(value));
+            => ElectricApparentPower.FromVoltamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricApparentPower.FromVoltamperes(value.ToDouble(null));
+            => ElectricApparentPower.FromVoltamperes(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs
index 314ba14684..94789bcd8c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs
@@ -32,81 +32,81 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCapacitance
     /// </summary>
     public static class NumberToElectricCapacitanceExtensions
     {
-        /// <inheritdoc cref="ElectricCapacitance.FromFarads(double)" />
+        /// <inheritdoc cref="ElectricCapacitance.FromFarads(QuantityValue)" />
         public static ElectricCapacitance Farads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCapacitance.FromFarads(double.CreateChecked(value));
+            => ElectricCapacitance.FromFarads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCapacitance.FromFarads(value.ToDouble(null));
+            => ElectricCapacitance.FromFarads(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCapacitance.FromKilofarads(double)" />
+        /// <inheritdoc cref="ElectricCapacitance.FromKilofarads(QuantityValue)" />
         public static ElectricCapacitance Kilofarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCapacitance.FromKilofarads(double.CreateChecked(value));
+            => ElectricCapacitance.FromKilofarads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCapacitance.FromKilofarads(value.ToDouble(null));
+            => ElectricCapacitance.FromKilofarads(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCapacitance.FromMegafarads(double)" />
+        /// <inheritdoc cref="ElectricCapacitance.FromMegafarads(QuantityValue)" />
         public static ElectricCapacitance Megafarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCapacitance.FromMegafarads(double.CreateChecked(value));
+            => ElectricCapacitance.FromMegafarads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCapacitance.FromMegafarads(value.ToDouble(null));
+            => ElectricCapacitance.FromMegafarads(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCapacitance.FromMicrofarads(double)" />
+        /// <inheritdoc cref="ElectricCapacitance.FromMicrofarads(QuantityValue)" />
         public static ElectricCapacitance Microfarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCapacitance.FromMicrofarads(double.CreateChecked(value));
+            => ElectricCapacitance.FromMicrofarads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCapacitance.FromMicrofarads(value.ToDouble(null));
+            => ElectricCapacitance.FromMicrofarads(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCapacitance.FromMillifarads(double)" />
+        /// <inheritdoc cref="ElectricCapacitance.FromMillifarads(QuantityValue)" />
         public static ElectricCapacitance Millifarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCapacitance.FromMillifarads(double.CreateChecked(value));
+            => ElectricCapacitance.FromMillifarads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCapacitance.FromMillifarads(value.ToDouble(null));
+            => ElectricCapacitance.FromMillifarads(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCapacitance.FromNanofarads(double)" />
+        /// <inheritdoc cref="ElectricCapacitance.FromNanofarads(QuantityValue)" />
         public static ElectricCapacitance Nanofarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCapacitance.FromNanofarads(double.CreateChecked(value));
+            => ElectricCapacitance.FromNanofarads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCapacitance.FromNanofarads(value.ToDouble(null));
+            => ElectricCapacitance.FromNanofarads(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCapacitance.FromPicofarads(double)" />
+        /// <inheritdoc cref="ElectricCapacitance.FromPicofarads(QuantityValue)" />
         public static ElectricCapacitance Picofarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCapacitance.FromPicofarads(double.CreateChecked(value));
+            => ElectricCapacitance.FromPicofarads(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCapacitance.FromPicofarads(value.ToDouble(null));
+            => ElectricCapacitance.FromPicofarads(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
index 18614db17a..7bcb06e2c5 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToElectricChargeDensity
     /// </summary>
     public static class NumberToElectricChargeDensityExtensions
     {
-        /// <inheritdoc cref="ElectricChargeDensity.FromCoulombsPerCubicMeter(double)" />
+        /// <inheritdoc cref="ElectricChargeDensity.FromCoulombsPerCubicMeter(QuantityValue)" />
         public static ElectricChargeDensity CoulombsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricChargeDensity.FromCoulombsPerCubicMeter(double.CreateChecked(value));
+            => ElectricChargeDensity.FromCoulombsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricChargeDensity.FromCoulombsPerCubicMeter(value.ToDouble(null));
+            => ElectricChargeDensity.FromCoulombsPerCubicMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
index 65081e701a..7a1fe00300 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
@@ -32,125 +32,125 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCharge
     /// </summary>
     public static class NumberToElectricChargeExtensions
     {
-        /// <inheritdoc cref="ElectricCharge.FromAmpereHours(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromAmpereHours(QuantityValue)" />
         public static ElectricCharge AmpereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromAmpereHours(double.CreateChecked(value));
+            => ElectricCharge.FromAmpereHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromAmpereHours(value.ToDouble(null));
+            => ElectricCharge.FromAmpereHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCharge.FromCoulombs(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromCoulombs(QuantityValue)" />
         public static ElectricCharge Coulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromCoulombs(double.CreateChecked(value));
+            => ElectricCharge.FromCoulombs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromCoulombs(value.ToDouble(null));
+            => ElectricCharge.FromCoulombs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCharge.FromKiloampereHours(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromKiloampereHours(QuantityValue)" />
         public static ElectricCharge KiloampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromKiloampereHours(double.CreateChecked(value));
+            => ElectricCharge.FromKiloampereHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromKiloampereHours(value.ToDouble(null));
+            => ElectricCharge.FromKiloampereHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCharge.FromKilocoulombs(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromKilocoulombs(QuantityValue)" />
         public static ElectricCharge Kilocoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromKilocoulombs(double.CreateChecked(value));
+            => ElectricCharge.FromKilocoulombs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromKilocoulombs(value.ToDouble(null));
+            => ElectricCharge.FromKilocoulombs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCharge.FromMegaampereHours(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromMegaampereHours(QuantityValue)" />
         public static ElectricCharge MegaampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromMegaampereHours(double.CreateChecked(value));
+            => ElectricCharge.FromMegaampereHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromMegaampereHours(value.ToDouble(null));
+            => ElectricCharge.FromMegaampereHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCharge.FromMegacoulombs(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromMegacoulombs(QuantityValue)" />
         public static ElectricCharge Megacoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromMegacoulombs(double.CreateChecked(value));
+            => ElectricCharge.FromMegacoulombs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromMegacoulombs(value.ToDouble(null));
+            => ElectricCharge.FromMegacoulombs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCharge.FromMicrocoulombs(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromMicrocoulombs(QuantityValue)" />
         public static ElectricCharge Microcoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromMicrocoulombs(double.CreateChecked(value));
+            => ElectricCharge.FromMicrocoulombs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromMicrocoulombs(value.ToDouble(null));
+            => ElectricCharge.FromMicrocoulombs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCharge.FromMilliampereHours(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromMilliampereHours(QuantityValue)" />
         public static ElectricCharge MilliampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromMilliampereHours(double.CreateChecked(value));
+            => ElectricCharge.FromMilliampereHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromMilliampereHours(value.ToDouble(null));
+            => ElectricCharge.FromMilliampereHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCharge.FromMillicoulombs(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromMillicoulombs(QuantityValue)" />
         public static ElectricCharge Millicoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromMillicoulombs(double.CreateChecked(value));
+            => ElectricCharge.FromMillicoulombs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromMillicoulombs(value.ToDouble(null));
+            => ElectricCharge.FromMillicoulombs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCharge.FromNanocoulombs(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromNanocoulombs(QuantityValue)" />
         public static ElectricCharge Nanocoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromNanocoulombs(double.CreateChecked(value));
+            => ElectricCharge.FromNanocoulombs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromNanocoulombs(value.ToDouble(null));
+            => ElectricCharge.FromNanocoulombs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCharge.FromPicocoulombs(double)" />
+        /// <inheritdoc cref="ElectricCharge.FromPicocoulombs(QuantityValue)" />
         public static ElectricCharge Picocoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCharge.FromPicocoulombs(double.CreateChecked(value));
+            => ElectricCharge.FromPicocoulombs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCharge.FromPicocoulombs(value.ToDouble(null));
+            => ElectricCharge.FromPicocoulombs(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
index 1ceafdf1c5..547d61a075 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
@@ -32,180 +32,180 @@ namespace UnitsNet.NumberExtensions.NumberToElectricConductance
     /// </summary>
     public static class NumberToElectricConductanceExtensions
     {
-        /// <inheritdoc cref="ElectricConductance.FromGigamhos(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromGigamhos(QuantityValue)" />
         public static ElectricConductance Gigamhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromGigamhos(double.CreateChecked(value));
+            => ElectricConductance.FromGigamhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromGigamhos(value.ToDouble(null));
+            => ElectricConductance.FromGigamhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromGigasiemens(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromGigasiemens(QuantityValue)" />
         public static ElectricConductance Gigasiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromGigasiemens(double.CreateChecked(value));
+            => ElectricConductance.FromGigasiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromGigasiemens(value.ToDouble(null));
+            => ElectricConductance.FromGigasiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromKilomhos(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromKilomhos(QuantityValue)" />
         public static ElectricConductance Kilomhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromKilomhos(double.CreateChecked(value));
+            => ElectricConductance.FromKilomhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromKilomhos(value.ToDouble(null));
+            => ElectricConductance.FromKilomhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromKilosiemens(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromKilosiemens(QuantityValue)" />
         public static ElectricConductance Kilosiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromKilosiemens(double.CreateChecked(value));
+            => ElectricConductance.FromKilosiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromKilosiemens(value.ToDouble(null));
+            => ElectricConductance.FromKilosiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromMegamhos(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromMegamhos(QuantityValue)" />
         public static ElectricConductance Megamhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromMegamhos(double.CreateChecked(value));
+            => ElectricConductance.FromMegamhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromMegamhos(value.ToDouble(null));
+            => ElectricConductance.FromMegamhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromMegasiemens(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromMegasiemens(QuantityValue)" />
         public static ElectricConductance Megasiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromMegasiemens(double.CreateChecked(value));
+            => ElectricConductance.FromMegasiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromMegasiemens(value.ToDouble(null));
+            => ElectricConductance.FromMegasiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromMhos(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromMhos(QuantityValue)" />
         public static ElectricConductance Mhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromMhos(double.CreateChecked(value));
+            => ElectricConductance.FromMhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromMhos(value.ToDouble(null));
+            => ElectricConductance.FromMhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromMicromhos(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromMicromhos(QuantityValue)" />
         public static ElectricConductance Micromhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromMicromhos(double.CreateChecked(value));
+            => ElectricConductance.FromMicromhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromMicromhos(value.ToDouble(null));
+            => ElectricConductance.FromMicromhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromMicrosiemens(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromMicrosiemens(QuantityValue)" />
         public static ElectricConductance Microsiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromMicrosiemens(double.CreateChecked(value));
+            => ElectricConductance.FromMicrosiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromMicrosiemens(value.ToDouble(null));
+            => ElectricConductance.FromMicrosiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromMillimhos(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromMillimhos(QuantityValue)" />
         public static ElectricConductance Millimhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromMillimhos(double.CreateChecked(value));
+            => ElectricConductance.FromMillimhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromMillimhos(value.ToDouble(null));
+            => ElectricConductance.FromMillimhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromMillisiemens(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromMillisiemens(QuantityValue)" />
         public static ElectricConductance Millisiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromMillisiemens(double.CreateChecked(value));
+            => ElectricConductance.FromMillisiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromMillisiemens(value.ToDouble(null));
+            => ElectricConductance.FromMillisiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromNanomhos(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromNanomhos(QuantityValue)" />
         public static ElectricConductance Nanomhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromNanomhos(double.CreateChecked(value));
+            => ElectricConductance.FromNanomhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromNanomhos(value.ToDouble(null));
+            => ElectricConductance.FromNanomhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromNanosiemens(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromNanosiemens(QuantityValue)" />
         public static ElectricConductance Nanosiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromNanosiemens(double.CreateChecked(value));
+            => ElectricConductance.FromNanosiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromNanosiemens(value.ToDouble(null));
+            => ElectricConductance.FromNanosiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromSiemens(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromSiemens(QuantityValue)" />
         public static ElectricConductance Siemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromSiemens(double.CreateChecked(value));
+            => ElectricConductance.FromSiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromSiemens(value.ToDouble(null));
+            => ElectricConductance.FromSiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromTeramhos(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromTeramhos(QuantityValue)" />
         public static ElectricConductance Teramhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromTeramhos(double.CreateChecked(value));
+            => ElectricConductance.FromTeramhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromTeramhos(value.ToDouble(null));
+            => ElectricConductance.FromTeramhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductance.FromTerasiemens(double)" />
+        /// <inheritdoc cref="ElectricConductance.FromTerasiemens(QuantityValue)" />
         public static ElectricConductance Terasiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductance.FromTerasiemens(double.CreateChecked(value));
+            => ElectricConductance.FromTerasiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductance.FromTerasiemens(value.ToDouble(null));
+            => ElectricConductance.FromTerasiemens(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
index a9e1dbd9c0..b12f9623f2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
@@ -32,70 +32,70 @@ namespace UnitsNet.NumberExtensions.NumberToElectricConductivity
     /// </summary>
     public static class NumberToElectricConductivityExtensions
     {
-        /// <inheritdoc cref="ElectricConductivity.FromMicrosiemensPerCentimeter(double)" />
+        /// <inheritdoc cref="ElectricConductivity.FromMicrosiemensPerCentimeter(QuantityValue)" />
         public static ElectricConductivity MicrosiemensPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductivity.FromMicrosiemensPerCentimeter(double.CreateChecked(value));
+            => ElectricConductivity.FromMicrosiemensPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductivity.FromMicrosiemensPerCentimeter(value.ToDouble(null));
+            => ElectricConductivity.FromMicrosiemensPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductivity.FromMillisiemensPerCentimeter(double)" />
+        /// <inheritdoc cref="ElectricConductivity.FromMillisiemensPerCentimeter(QuantityValue)" />
         public static ElectricConductivity MillisiemensPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductivity.FromMillisiemensPerCentimeter(double.CreateChecked(value));
+            => ElectricConductivity.FromMillisiemensPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductivity.FromMillisiemensPerCentimeter(value.ToDouble(null));
+            => ElectricConductivity.FromMillisiemensPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerCentimeter(double)" />
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerCentimeter(QuantityValue)" />
         public static ElectricConductivity SiemensPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductivity.FromSiemensPerCentimeter(double.CreateChecked(value));
+            => ElectricConductivity.FromSiemensPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductivity.FromSiemensPerCentimeter(value.ToDouble(null));
+            => ElectricConductivity.FromSiemensPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerFoot(double)" />
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerFoot(QuantityValue)" />
         public static ElectricConductivity SiemensPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductivity.FromSiemensPerFoot(double.CreateChecked(value));
+            => ElectricConductivity.FromSiemensPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductivity.FromSiemensPerFoot(value.ToDouble(null));
+            => ElectricConductivity.FromSiemensPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerInch(double)" />
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerInch(QuantityValue)" />
         public static ElectricConductivity SiemensPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductivity.FromSiemensPerInch(double.CreateChecked(value));
+            => ElectricConductivity.FromSiemensPerInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductivity.FromSiemensPerInch(value.ToDouble(null));
+            => ElectricConductivity.FromSiemensPerInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerMeter(double)" />
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerMeter(QuantityValue)" />
         public static ElectricConductivity SiemensPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricConductivity.FromSiemensPerMeter(double.CreateChecked(value));
+            => ElectricConductivity.FromSiemensPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricConductivity.FromSiemensPerMeter(value.ToDouble(null));
+            => ElectricConductivity.FromSiemensPerMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
index c617a38750..87548fcb22 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
@@ -32,37 +32,37 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCurrentDensity
     /// </summary>
     public static class NumberToElectricCurrentDensityExtensions
     {
-        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareFoot(double)" />
+        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareFoot(QuantityValue)" />
         public static ElectricCurrentDensity AmperesPerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrentDensity.FromAmperesPerSquareFoot(double.CreateChecked(value));
+            => ElectricCurrentDensity.FromAmperesPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrentDensity.FromAmperesPerSquareFoot(value.ToDouble(null));
+            => ElectricCurrentDensity.FromAmperesPerSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareInch(double)" />
+        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareInch(QuantityValue)" />
         public static ElectricCurrentDensity AmperesPerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrentDensity.FromAmperesPerSquareInch(double.CreateChecked(value));
+            => ElectricCurrentDensity.FromAmperesPerSquareInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrentDensity.FromAmperesPerSquareInch(value.ToDouble(null));
+            => ElectricCurrentDensity.FromAmperesPerSquareInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareMeter(double)" />
+        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareMeter(QuantityValue)" />
         public static ElectricCurrentDensity AmperesPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrentDensity.FromAmperesPerSquareMeter(double.CreateChecked(value));
+            => ElectricCurrentDensity.FromAmperesPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrentDensity.FromAmperesPerSquareMeter(value.ToDouble(null));
+            => ElectricCurrentDensity.FromAmperesPerSquareMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
index adb8a09db7..2a220ee58c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
@@ -32,103 +32,103 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCurrent
     /// </summary>
     public static class NumberToElectricCurrentExtensions
     {
-        /// <inheritdoc cref="ElectricCurrent.FromAmperes(double)" />
+        /// <inheritdoc cref="ElectricCurrent.FromAmperes(QuantityValue)" />
         public static ElectricCurrent Amperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrent.FromAmperes(double.CreateChecked(value));
+            => ElectricCurrent.FromAmperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrent.FromAmperes(value.ToDouble(null));
+            => ElectricCurrent.FromAmperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrent.FromCentiamperes(double)" />
+        /// <inheritdoc cref="ElectricCurrent.FromCentiamperes(QuantityValue)" />
         public static ElectricCurrent Centiamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrent.FromCentiamperes(double.CreateChecked(value));
+            => ElectricCurrent.FromCentiamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrent.FromCentiamperes(value.ToDouble(null));
+            => ElectricCurrent.FromCentiamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrent.FromFemtoamperes(double)" />
+        /// <inheritdoc cref="ElectricCurrent.FromFemtoamperes(QuantityValue)" />
         public static ElectricCurrent Femtoamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrent.FromFemtoamperes(double.CreateChecked(value));
+            => ElectricCurrent.FromFemtoamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrent.FromFemtoamperes(value.ToDouble(null));
+            => ElectricCurrent.FromFemtoamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrent.FromKiloamperes(double)" />
+        /// <inheritdoc cref="ElectricCurrent.FromKiloamperes(QuantityValue)" />
         public static ElectricCurrent Kiloamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrent.FromKiloamperes(double.CreateChecked(value));
+            => ElectricCurrent.FromKiloamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrent.FromKiloamperes(value.ToDouble(null));
+            => ElectricCurrent.FromKiloamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrent.FromMegaamperes(double)" />
+        /// <inheritdoc cref="ElectricCurrent.FromMegaamperes(QuantityValue)" />
         public static ElectricCurrent Megaamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrent.FromMegaamperes(double.CreateChecked(value));
+            => ElectricCurrent.FromMegaamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrent.FromMegaamperes(value.ToDouble(null));
+            => ElectricCurrent.FromMegaamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrent.FromMicroamperes(double)" />
+        /// <inheritdoc cref="ElectricCurrent.FromMicroamperes(QuantityValue)" />
         public static ElectricCurrent Microamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrent.FromMicroamperes(double.CreateChecked(value));
+            => ElectricCurrent.FromMicroamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrent.FromMicroamperes(value.ToDouble(null));
+            => ElectricCurrent.FromMicroamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrent.FromMilliamperes(double)" />
+        /// <inheritdoc cref="ElectricCurrent.FromMilliamperes(QuantityValue)" />
         public static ElectricCurrent Milliamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrent.FromMilliamperes(double.CreateChecked(value));
+            => ElectricCurrent.FromMilliamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrent.FromMilliamperes(value.ToDouble(null));
+            => ElectricCurrent.FromMilliamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrent.FromNanoamperes(double)" />
+        /// <inheritdoc cref="ElectricCurrent.FromNanoamperes(QuantityValue)" />
         public static ElectricCurrent Nanoamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrent.FromNanoamperes(double.CreateChecked(value));
+            => ElectricCurrent.FromNanoamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrent.FromNanoamperes(value.ToDouble(null));
+            => ElectricCurrent.FromNanoamperes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrent.FromPicoamperes(double)" />
+        /// <inheritdoc cref="ElectricCurrent.FromPicoamperes(QuantityValue)" />
         public static ElectricCurrent Picoamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrent.FromPicoamperes(double.CreateChecked(value));
+            => ElectricCurrent.FromPicoamperes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrent.FromPicoamperes(value.ToDouble(null));
+            => ElectricCurrent.FromPicoamperes(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
index ac56dc17e0..69f7580d1e 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
@@ -32,81 +32,81 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCurrentGradient
     /// </summary>
     public static class NumberToElectricCurrentGradientExtensions
     {
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMicrosecond(double)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMicrosecond(QuantityValue)" />
         public static ElectricCurrentGradient AmperesPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrentGradient.FromAmperesPerMicrosecond(double.CreateChecked(value));
+            => ElectricCurrentGradient.FromAmperesPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrentGradient.FromAmperesPerMicrosecond(value.ToDouble(null));
+            => ElectricCurrentGradient.FromAmperesPerMicrosecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMillisecond(double)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMillisecond(QuantityValue)" />
         public static ElectricCurrentGradient AmperesPerMillisecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrentGradient.FromAmperesPerMillisecond(double.CreateChecked(value));
+            => ElectricCurrentGradient.FromAmperesPerMillisecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrentGradient.FromAmperesPerMillisecond(value.ToDouble(null));
+            => ElectricCurrentGradient.FromAmperesPerMillisecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMinute(double)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMinute(QuantityValue)" />
         public static ElectricCurrentGradient AmperesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrentGradient.FromAmperesPerMinute(double.CreateChecked(value));
+            => ElectricCurrentGradient.FromAmperesPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrentGradient.FromAmperesPerMinute(value.ToDouble(null));
+            => ElectricCurrentGradient.FromAmperesPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerNanosecond(double)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerNanosecond(QuantityValue)" />
         public static ElectricCurrentGradient AmperesPerNanosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrentGradient.FromAmperesPerNanosecond(double.CreateChecked(value));
+            => ElectricCurrentGradient.FromAmperesPerNanosecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrentGradient.FromAmperesPerNanosecond(value.ToDouble(null));
+            => ElectricCurrentGradient.FromAmperesPerNanosecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerSecond(double)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerSecond(QuantityValue)" />
         public static ElectricCurrentGradient AmperesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrentGradient.FromAmperesPerSecond(double.CreateChecked(value));
+            => ElectricCurrentGradient.FromAmperesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrentGradient.FromAmperesPerSecond(value.ToDouble(null));
+            => ElectricCurrentGradient.FromAmperesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerMinute(double)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerMinute(QuantityValue)" />
         public static ElectricCurrentGradient MilliamperesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrentGradient.FromMilliamperesPerMinute(double.CreateChecked(value));
+            => ElectricCurrentGradient.FromMilliamperesPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrentGradient.FromMilliamperesPerMinute(value.ToDouble(null));
+            => ElectricCurrentGradient.FromMilliamperesPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerSecond(double)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerSecond(QuantityValue)" />
         public static ElectricCurrentGradient MilliamperesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricCurrentGradient.FromMilliamperesPerSecond(double.CreateChecked(value));
+            => ElectricCurrentGradient.FromMilliamperesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricCurrentGradient.FromMilliamperesPerSecond(value.ToDouble(null));
+            => ElectricCurrentGradient.FromMilliamperesPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
index 05c1a8de62..8f9406a1a5 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToElectricField
     /// </summary>
     public static class NumberToElectricFieldExtensions
     {
-        /// <inheritdoc cref="ElectricField.FromVoltsPerMeter(double)" />
+        /// <inheritdoc cref="ElectricField.FromVoltsPerMeter(QuantityValue)" />
         public static ElectricField VoltsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricField.FromVoltsPerMeter(double.CreateChecked(value));
+            => ElectricField.FromVoltsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricField.FromVoltsPerMeter(value.ToDouble(null));
+            => ElectricField.FromVoltsPerMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs
index b3b2a9ba52..7b61247548 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs
@@ -33,100 +33,100 @@ namespace UnitsNet.NumberExtensions.NumberToElectricImpedance
     [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
     public static class NumberToElectricImpedanceExtensions
     {
-        /// <inheritdoc cref="ElectricImpedance.FromGigaohms(double)" />
+        /// <inheritdoc cref="ElectricImpedance.FromGigaohms(QuantityValue)" />
         [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
         public static ElectricImpedance Gigaohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricImpedance.FromGigaohms(double.CreateChecked(value));
+            => ElectricImpedance.FromGigaohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricImpedance.FromGigaohms(value.ToDouble(null));
+            => ElectricImpedance.FromGigaohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricImpedance.FromKiloohms(double)" />
+        /// <inheritdoc cref="ElectricImpedance.FromKiloohms(QuantityValue)" />
         [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
         public static ElectricImpedance Kiloohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricImpedance.FromKiloohms(double.CreateChecked(value));
+            => ElectricImpedance.FromKiloohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricImpedance.FromKiloohms(value.ToDouble(null));
+            => ElectricImpedance.FromKiloohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricImpedance.FromMegaohms(double)" />
+        /// <inheritdoc cref="ElectricImpedance.FromMegaohms(QuantityValue)" />
         [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
         public static ElectricImpedance Megaohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricImpedance.FromMegaohms(double.CreateChecked(value));
+            => ElectricImpedance.FromMegaohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricImpedance.FromMegaohms(value.ToDouble(null));
+            => ElectricImpedance.FromMegaohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricImpedance.FromMicroohms(double)" />
+        /// <inheritdoc cref="ElectricImpedance.FromMicroohms(QuantityValue)" />
         [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
         public static ElectricImpedance Microohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricImpedance.FromMicroohms(double.CreateChecked(value));
+            => ElectricImpedance.FromMicroohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricImpedance.FromMicroohms(value.ToDouble(null));
+            => ElectricImpedance.FromMicroohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricImpedance.FromMilliohms(double)" />
+        /// <inheritdoc cref="ElectricImpedance.FromMilliohms(QuantityValue)" />
         [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
         public static ElectricImpedance Milliohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricImpedance.FromMilliohms(double.CreateChecked(value));
+            => ElectricImpedance.FromMilliohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricImpedance.FromMilliohms(value.ToDouble(null));
+            => ElectricImpedance.FromMilliohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricImpedance.FromNanoohms(double)" />
+        /// <inheritdoc cref="ElectricImpedance.FromNanoohms(QuantityValue)" />
         [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
         public static ElectricImpedance Nanoohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricImpedance.FromNanoohms(double.CreateChecked(value));
+            => ElectricImpedance.FromNanoohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricImpedance.FromNanoohms(value.ToDouble(null));
+            => ElectricImpedance.FromNanoohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricImpedance.FromOhms(double)" />
+        /// <inheritdoc cref="ElectricImpedance.FromOhms(QuantityValue)" />
         [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
         public static ElectricImpedance Ohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricImpedance.FromOhms(double.CreateChecked(value));
+            => ElectricImpedance.FromOhms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricImpedance.FromOhms(value.ToDouble(null));
+            => ElectricImpedance.FromOhms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricImpedance.FromTeraohms(double)" />
+        /// <inheritdoc cref="ElectricImpedance.FromTeraohms(QuantityValue)" />
         [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
         public static ElectricImpedance Teraohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricImpedance.FromTeraohms(double.CreateChecked(value));
+            => ElectricImpedance.FromTeraohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricImpedance.FromTeraohms(value.ToDouble(null));
+            => ElectricImpedance.FromTeraohms(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
index bc0ce716f4..c239b5044d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
@@ -32,59 +32,59 @@ namespace UnitsNet.NumberExtensions.NumberToElectricInductance
     /// </summary>
     public static class NumberToElectricInductanceExtensions
     {
-        /// <inheritdoc cref="ElectricInductance.FromHenries(double)" />
+        /// <inheritdoc cref="ElectricInductance.FromHenries(QuantityValue)" />
         public static ElectricInductance Henries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricInductance.FromHenries(double.CreateChecked(value));
+            => ElectricInductance.FromHenries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricInductance.FromHenries(value.ToDouble(null));
+            => ElectricInductance.FromHenries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricInductance.FromMicrohenries(double)" />
+        /// <inheritdoc cref="ElectricInductance.FromMicrohenries(QuantityValue)" />
         public static ElectricInductance Microhenries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricInductance.FromMicrohenries(double.CreateChecked(value));
+            => ElectricInductance.FromMicrohenries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricInductance.FromMicrohenries(value.ToDouble(null));
+            => ElectricInductance.FromMicrohenries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricInductance.FromMillihenries(double)" />
+        /// <inheritdoc cref="ElectricInductance.FromMillihenries(QuantityValue)" />
         public static ElectricInductance Millihenries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricInductance.FromMillihenries(double.CreateChecked(value));
+            => ElectricInductance.FromMillihenries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricInductance.FromMillihenries(value.ToDouble(null));
+            => ElectricInductance.FromMillihenries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricInductance.FromNanohenries(double)" />
+        /// <inheritdoc cref="ElectricInductance.FromNanohenries(QuantityValue)" />
         public static ElectricInductance Nanohenries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricInductance.FromNanohenries(double.CreateChecked(value));
+            => ElectricInductance.FromNanohenries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricInductance.FromNanohenries(value.ToDouble(null));
+            => ElectricInductance.FromNanohenries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricInductance.FromPicohenries(double)" />
+        /// <inheritdoc cref="ElectricInductance.FromPicohenries(QuantityValue)" />
         public static ElectricInductance Picohenries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricInductance.FromPicohenries(double.CreateChecked(value));
+            => ElectricInductance.FromPicohenries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricInductance.FromPicohenries(value.ToDouble(null));
+            => ElectricInductance.FromPicohenries(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
index ae7d19c814..a8f0933f2c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
@@ -32,224 +32,224 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotentialChangeRate
     /// </summary>
     public static class NumberToElectricPotentialChangeRateExtensions
     {
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerHour(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerHour(QuantityValue)" />
         public static ElectricPotentialChangeRate KilovoltsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromKilovoltsPerHour(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromKilovoltsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromKilovoltsPerHour(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromKilovoltsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(QuantityValue)" />
         public static ElectricPotentialChangeRate KilovoltsPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMinute(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMinute(QuantityValue)" />
         public static ElectricPotentialChangeRate KilovoltsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromKilovoltsPerMinute(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromKilovoltsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromKilovoltsPerMinute(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromKilovoltsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerSecond(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerSecond(QuantityValue)" />
         public static ElectricPotentialChangeRate KilovoltsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromKilovoltsPerSecond(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromKilovoltsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromKilovoltsPerSecond(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromKilovoltsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerHour(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerHour(QuantityValue)" />
         public static ElectricPotentialChangeRate MegavoltsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMegavoltsPerHour(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMegavoltsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMegavoltsPerHour(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMegavoltsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(QuantityValue)" />
         public static ElectricPotentialChangeRate MegavoltsPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMinute(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMinute(QuantityValue)" />
         public static ElectricPotentialChangeRate MegavoltsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMegavoltsPerMinute(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMegavoltsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMegavoltsPerMinute(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMegavoltsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerSecond(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerSecond(QuantityValue)" />
         public static ElectricPotentialChangeRate MegavoltsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMegavoltsPerSecond(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMegavoltsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMegavoltsPerSecond(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMegavoltsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerHour(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerHour(QuantityValue)" />
         public static ElectricPotentialChangeRate MicrovoltsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMicrovoltsPerHour(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMicrovoltsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMicrovoltsPerHour(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMicrovoltsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(QuantityValue)" />
         public static ElectricPotentialChangeRate MicrovoltsPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMinute(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMinute(QuantityValue)" />
         public static ElectricPotentialChangeRate MicrovoltsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerSecond(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerSecond(QuantityValue)" />
         public static ElectricPotentialChangeRate MicrovoltsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerHour(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerHour(QuantityValue)" />
         public static ElectricPotentialChangeRate MillivoltsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMillivoltsPerHour(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMillivoltsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMillivoltsPerHour(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMillivoltsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(QuantityValue)" />
         public static ElectricPotentialChangeRate MillivoltsPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMinute(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMinute(QuantityValue)" />
         public static ElectricPotentialChangeRate MillivoltsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMillivoltsPerMinute(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMillivoltsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMillivoltsPerMinute(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMillivoltsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerSecond(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerSecond(QuantityValue)" />
         public static ElectricPotentialChangeRate MillivoltsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromMillivoltsPerSecond(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromMillivoltsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromMillivoltsPerSecond(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromMillivoltsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerHour(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerHour(QuantityValue)" />
         public static ElectricPotentialChangeRate VoltsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromVoltsPerHour(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromVoltsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromVoltsPerHour(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromVoltsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMicrosecond(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMicrosecond(QuantityValue)" />
         public static ElectricPotentialChangeRate VoltsPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMinute(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMinute(QuantityValue)" />
         public static ElectricPotentialChangeRate VoltsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromVoltsPerMinute(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromVoltsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromVoltsPerMinute(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromVoltsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerSecond(double)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerSecond(QuantityValue)" />
         public static ElectricPotentialChangeRate VoltsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotentialChangeRate.FromVoltsPerSecond(double.CreateChecked(value));
+            => ElectricPotentialChangeRate.FromVoltsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotentialChangeRate.FromVoltsPerSecond(value.ToDouble(null));
+            => ElectricPotentialChangeRate.FromVoltsPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
index 4f1cb041b0..26001885bc 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
@@ -32,70 +32,70 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotential
     /// </summary>
     public static class NumberToElectricPotentialExtensions
     {
-        /// <inheritdoc cref="ElectricPotential.FromKilovolts(double)" />
+        /// <inheritdoc cref="ElectricPotential.FromKilovolts(QuantityValue)" />
         public static ElectricPotential Kilovolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotential.FromKilovolts(double.CreateChecked(value));
+            => ElectricPotential.FromKilovolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotential.FromKilovolts(value.ToDouble(null));
+            => ElectricPotential.FromKilovolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotential.FromMegavolts(double)" />
+        /// <inheritdoc cref="ElectricPotential.FromMegavolts(QuantityValue)" />
         public static ElectricPotential Megavolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotential.FromMegavolts(double.CreateChecked(value));
+            => ElectricPotential.FromMegavolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotential.FromMegavolts(value.ToDouble(null));
+            => ElectricPotential.FromMegavolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotential.FromMicrovolts(double)" />
+        /// <inheritdoc cref="ElectricPotential.FromMicrovolts(QuantityValue)" />
         public static ElectricPotential Microvolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotential.FromMicrovolts(double.CreateChecked(value));
+            => ElectricPotential.FromMicrovolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotential.FromMicrovolts(value.ToDouble(null));
+            => ElectricPotential.FromMicrovolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotential.FromMillivolts(double)" />
+        /// <inheritdoc cref="ElectricPotential.FromMillivolts(QuantityValue)" />
         public static ElectricPotential Millivolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotential.FromMillivolts(double.CreateChecked(value));
+            => ElectricPotential.FromMillivolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotential.FromMillivolts(value.ToDouble(null));
+            => ElectricPotential.FromMillivolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotential.FromNanovolts(double)" />
+        /// <inheritdoc cref="ElectricPotential.FromNanovolts(QuantityValue)" />
         public static ElectricPotential Nanovolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotential.FromNanovolts(double.CreateChecked(value));
+            => ElectricPotential.FromNanovolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotential.FromNanovolts(value.ToDouble(null));
+            => ElectricPotential.FromNanovolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricPotential.FromVolts(double)" />
+        /// <inheritdoc cref="ElectricPotential.FromVolts(QuantityValue)" />
         public static ElectricPotential Volts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricPotential.FromVolts(double.CreateChecked(value));
+            => ElectricPotential.FromVolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricPotential.FromVolts(value.ToDouble(null));
+            => ElectricPotential.FromVolts(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactanceExtensions.g.cs
index 3aee4ab12f..f6ec657790 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactanceExtensions.g.cs
@@ -32,92 +32,92 @@ namespace UnitsNet.NumberExtensions.NumberToElectricReactance
     /// </summary>
     public static class NumberToElectricReactanceExtensions
     {
-        /// <inheritdoc cref="ElectricReactance.FromGigaohms(double)" />
+        /// <inheritdoc cref="ElectricReactance.FromGigaohms(QuantityValue)" />
         public static ElectricReactance Gigaohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactance.FromGigaohms(double.CreateChecked(value));
+            => ElectricReactance.FromGigaohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactance.FromGigaohms(value.ToDouble(null));
+            => ElectricReactance.FromGigaohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactance.FromKiloohms(double)" />
+        /// <inheritdoc cref="ElectricReactance.FromKiloohms(QuantityValue)" />
         public static ElectricReactance Kiloohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactance.FromKiloohms(double.CreateChecked(value));
+            => ElectricReactance.FromKiloohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactance.FromKiloohms(value.ToDouble(null));
+            => ElectricReactance.FromKiloohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactance.FromMegaohms(double)" />
+        /// <inheritdoc cref="ElectricReactance.FromMegaohms(QuantityValue)" />
         public static ElectricReactance Megaohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactance.FromMegaohms(double.CreateChecked(value));
+            => ElectricReactance.FromMegaohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactance.FromMegaohms(value.ToDouble(null));
+            => ElectricReactance.FromMegaohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactance.FromMicroohms(double)" />
+        /// <inheritdoc cref="ElectricReactance.FromMicroohms(QuantityValue)" />
         public static ElectricReactance Microohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactance.FromMicroohms(double.CreateChecked(value));
+            => ElectricReactance.FromMicroohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactance.FromMicroohms(value.ToDouble(null));
+            => ElectricReactance.FromMicroohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactance.FromMilliohms(double)" />
+        /// <inheritdoc cref="ElectricReactance.FromMilliohms(QuantityValue)" />
         public static ElectricReactance Milliohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactance.FromMilliohms(double.CreateChecked(value));
+            => ElectricReactance.FromMilliohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactance.FromMilliohms(value.ToDouble(null));
+            => ElectricReactance.FromMilliohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactance.FromNanoohms(double)" />
+        /// <inheritdoc cref="ElectricReactance.FromNanoohms(QuantityValue)" />
         public static ElectricReactance Nanoohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactance.FromNanoohms(double.CreateChecked(value));
+            => ElectricReactance.FromNanoohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactance.FromNanoohms(value.ToDouble(null));
+            => ElectricReactance.FromNanoohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactance.FromOhms(double)" />
+        /// <inheritdoc cref="ElectricReactance.FromOhms(QuantityValue)" />
         public static ElectricReactance Ohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactance.FromOhms(double.CreateChecked(value));
+            => ElectricReactance.FromOhms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactance.FromOhms(value.ToDouble(null));
+            => ElectricReactance.FromOhms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactance.FromTeraohms(double)" />
+        /// <inheritdoc cref="ElectricReactance.FromTeraohms(QuantityValue)" />
         public static ElectricReactance Teraohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactance.FromTeraohms(double.CreateChecked(value));
+            => ElectricReactance.FromTeraohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactance.FromTeraohms(value.ToDouble(null));
+            => ElectricReactance.FromTeraohms(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs
index 402ab24ed2..d4acf99ac1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs
@@ -32,37 +32,37 @@ namespace UnitsNet.NumberExtensions.NumberToElectricReactiveEnergy
     /// </summary>
     public static class NumberToElectricReactiveEnergyExtensions
     {
-        /// <inheritdoc cref="ElectricReactiveEnergy.FromKilovoltampereReactiveHours(double)" />
+        /// <inheritdoc cref="ElectricReactiveEnergy.FromKilovoltampereReactiveHours(QuantityValue)" />
         public static ElectricReactiveEnergy KilovoltampereReactiveHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactiveEnergy.FromKilovoltampereReactiveHours(double.CreateChecked(value));
+            => ElectricReactiveEnergy.FromKilovoltampereReactiveHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactiveEnergy.FromKilovoltampereReactiveHours(value.ToDouble(null));
+            => ElectricReactiveEnergy.FromKilovoltampereReactiveHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactiveEnergy.FromMegavoltampereReactiveHours(double)" />
+        /// <inheritdoc cref="ElectricReactiveEnergy.FromMegavoltampereReactiveHours(QuantityValue)" />
         public static ElectricReactiveEnergy MegavoltampereReactiveHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactiveEnergy.FromMegavoltampereReactiveHours(double.CreateChecked(value));
+            => ElectricReactiveEnergy.FromMegavoltampereReactiveHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactiveEnergy.FromMegavoltampereReactiveHours(value.ToDouble(null));
+            => ElectricReactiveEnergy.FromMegavoltampereReactiveHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactiveEnergy.FromVoltampereReactiveHours(double)" />
+        /// <inheritdoc cref="ElectricReactiveEnergy.FromVoltampereReactiveHours(QuantityValue)" />
         public static ElectricReactiveEnergy VoltampereReactiveHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactiveEnergy.FromVoltampereReactiveHours(double.CreateChecked(value));
+            => ElectricReactiveEnergy.FromVoltampereReactiveHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactiveEnergy.FromVoltampereReactiveHours(value.ToDouble(null));
+            => ElectricReactiveEnergy.FromVoltampereReactiveHours(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs
index 0ad77fa1f1..651c311725 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs
@@ -32,48 +32,48 @@ namespace UnitsNet.NumberExtensions.NumberToElectricReactivePower
     /// </summary>
     public static class NumberToElectricReactivePowerExtensions
     {
-        /// <inheritdoc cref="ElectricReactivePower.FromGigavoltamperesReactive(double)" />
+        /// <inheritdoc cref="ElectricReactivePower.FromGigavoltamperesReactive(QuantityValue)" />
         public static ElectricReactivePower GigavoltamperesReactive<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactivePower.FromGigavoltamperesReactive(double.CreateChecked(value));
+            => ElectricReactivePower.FromGigavoltamperesReactive(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactivePower.FromGigavoltamperesReactive(value.ToDouble(null));
+            => ElectricReactivePower.FromGigavoltamperesReactive(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactivePower.FromKilovoltamperesReactive(double)" />
+        /// <inheritdoc cref="ElectricReactivePower.FromKilovoltamperesReactive(QuantityValue)" />
         public static ElectricReactivePower KilovoltamperesReactive<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactivePower.FromKilovoltamperesReactive(double.CreateChecked(value));
+            => ElectricReactivePower.FromKilovoltamperesReactive(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactivePower.FromKilovoltamperesReactive(value.ToDouble(null));
+            => ElectricReactivePower.FromKilovoltamperesReactive(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactivePower.FromMegavoltamperesReactive(double)" />
+        /// <inheritdoc cref="ElectricReactivePower.FromMegavoltamperesReactive(QuantityValue)" />
         public static ElectricReactivePower MegavoltamperesReactive<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactivePower.FromMegavoltamperesReactive(double.CreateChecked(value));
+            => ElectricReactivePower.FromMegavoltamperesReactive(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactivePower.FromMegavoltamperesReactive(value.ToDouble(null));
+            => ElectricReactivePower.FromMegavoltamperesReactive(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricReactivePower.FromVoltamperesReactive(double)" />
+        /// <inheritdoc cref="ElectricReactivePower.FromVoltamperesReactive(QuantityValue)" />
         public static ElectricReactivePower VoltamperesReactive<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricReactivePower.FromVoltamperesReactive(double.CreateChecked(value));
+            => ElectricReactivePower.FromVoltamperesReactive(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricReactivePower.FromVoltamperesReactive(value.ToDouble(null));
+            => ElectricReactivePower.FromVoltamperesReactive(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
index 2d1953bf75..fb0737a4e6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
@@ -32,92 +32,92 @@ namespace UnitsNet.NumberExtensions.NumberToElectricResistance
     /// </summary>
     public static class NumberToElectricResistanceExtensions
     {
-        /// <inheritdoc cref="ElectricResistance.FromGigaohms(double)" />
+        /// <inheritdoc cref="ElectricResistance.FromGigaohms(QuantityValue)" />
         public static ElectricResistance Gigaohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistance.FromGigaohms(double.CreateChecked(value));
+            => ElectricResistance.FromGigaohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistance.FromGigaohms(value.ToDouble(null));
+            => ElectricResistance.FromGigaohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistance.FromKiloohms(double)" />
+        /// <inheritdoc cref="ElectricResistance.FromKiloohms(QuantityValue)" />
         public static ElectricResistance Kiloohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistance.FromKiloohms(double.CreateChecked(value));
+            => ElectricResistance.FromKiloohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistance.FromKiloohms(value.ToDouble(null));
+            => ElectricResistance.FromKiloohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistance.FromMegaohms(double)" />
+        /// <inheritdoc cref="ElectricResistance.FromMegaohms(QuantityValue)" />
         public static ElectricResistance Megaohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistance.FromMegaohms(double.CreateChecked(value));
+            => ElectricResistance.FromMegaohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistance.FromMegaohms(value.ToDouble(null));
+            => ElectricResistance.FromMegaohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistance.FromMicroohms(double)" />
+        /// <inheritdoc cref="ElectricResistance.FromMicroohms(QuantityValue)" />
         public static ElectricResistance Microohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistance.FromMicroohms(double.CreateChecked(value));
+            => ElectricResistance.FromMicroohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistance.FromMicroohms(value.ToDouble(null));
+            => ElectricResistance.FromMicroohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistance.FromMilliohms(double)" />
+        /// <inheritdoc cref="ElectricResistance.FromMilliohms(QuantityValue)" />
         public static ElectricResistance Milliohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistance.FromMilliohms(double.CreateChecked(value));
+            => ElectricResistance.FromMilliohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistance.FromMilliohms(value.ToDouble(null));
+            => ElectricResistance.FromMilliohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistance.FromNanoohms(double)" />
+        /// <inheritdoc cref="ElectricResistance.FromNanoohms(QuantityValue)" />
         public static ElectricResistance Nanoohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistance.FromNanoohms(double.CreateChecked(value));
+            => ElectricResistance.FromNanoohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistance.FromNanoohms(value.ToDouble(null));
+            => ElectricResistance.FromNanoohms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistance.FromOhms(double)" />
+        /// <inheritdoc cref="ElectricResistance.FromOhms(QuantityValue)" />
         public static ElectricResistance Ohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistance.FromOhms(double.CreateChecked(value));
+            => ElectricResistance.FromOhms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistance.FromOhms(value.ToDouble(null));
+            => ElectricResistance.FromOhms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistance.FromTeraohms(double)" />
+        /// <inheritdoc cref="ElectricResistance.FromTeraohms(QuantityValue)" />
         public static ElectricResistance Teraohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistance.FromTeraohms(double.CreateChecked(value));
+            => ElectricResistance.FromTeraohms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistance.FromTeraohms(value.ToDouble(null));
+            => ElectricResistance.FromTeraohms(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
index 558fc64eb2..68334bf74f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
@@ -32,158 +32,158 @@ namespace UnitsNet.NumberExtensions.NumberToElectricResistivity
     /// </summary>
     public static class NumberToElectricResistivityExtensions
     {
-        /// <inheritdoc cref="ElectricResistivity.FromKiloohmsCentimeter(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromKiloohmsCentimeter(QuantityValue)" />
         public static ElectricResistivity KiloohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromKiloohmsCentimeter(double.CreateChecked(value));
+            => ElectricResistivity.FromKiloohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromKiloohmsCentimeter(value.ToDouble(null));
+            => ElectricResistivity.FromKiloohmsCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromKiloohmMeters(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromKiloohmMeters(QuantityValue)" />
         public static ElectricResistivity KiloohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromKiloohmMeters(double.CreateChecked(value));
+            => ElectricResistivity.FromKiloohmMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromKiloohmMeters(value.ToDouble(null));
+            => ElectricResistivity.FromKiloohmMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromMegaohmsCentimeter(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMegaohmsCentimeter(QuantityValue)" />
         public static ElectricResistivity MegaohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromMegaohmsCentimeter(double.CreateChecked(value));
+            => ElectricResistivity.FromMegaohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromMegaohmsCentimeter(value.ToDouble(null));
+            => ElectricResistivity.FromMegaohmsCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromMegaohmMeters(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMegaohmMeters(QuantityValue)" />
         public static ElectricResistivity MegaohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromMegaohmMeters(double.CreateChecked(value));
+            => ElectricResistivity.FromMegaohmMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromMegaohmMeters(value.ToDouble(null));
+            => ElectricResistivity.FromMegaohmMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromMicroohmsCentimeter(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMicroohmsCentimeter(QuantityValue)" />
         public static ElectricResistivity MicroohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromMicroohmsCentimeter(double.CreateChecked(value));
+            => ElectricResistivity.FromMicroohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromMicroohmsCentimeter(value.ToDouble(null));
+            => ElectricResistivity.FromMicroohmsCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromMicroohmMeters(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMicroohmMeters(QuantityValue)" />
         public static ElectricResistivity MicroohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromMicroohmMeters(double.CreateChecked(value));
+            => ElectricResistivity.FromMicroohmMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromMicroohmMeters(value.ToDouble(null));
+            => ElectricResistivity.FromMicroohmMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromMilliohmsCentimeter(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMilliohmsCentimeter(QuantityValue)" />
         public static ElectricResistivity MilliohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromMilliohmsCentimeter(double.CreateChecked(value));
+            => ElectricResistivity.FromMilliohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromMilliohmsCentimeter(value.ToDouble(null));
+            => ElectricResistivity.FromMilliohmsCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromMilliohmMeters(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMilliohmMeters(QuantityValue)" />
         public static ElectricResistivity MilliohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromMilliohmMeters(double.CreateChecked(value));
+            => ElectricResistivity.FromMilliohmMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromMilliohmMeters(value.ToDouble(null));
+            => ElectricResistivity.FromMilliohmMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromNanoohmsCentimeter(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromNanoohmsCentimeter(QuantityValue)" />
         public static ElectricResistivity NanoohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromNanoohmsCentimeter(double.CreateChecked(value));
+            => ElectricResistivity.FromNanoohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromNanoohmsCentimeter(value.ToDouble(null));
+            => ElectricResistivity.FromNanoohmsCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromNanoohmMeters(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromNanoohmMeters(QuantityValue)" />
         public static ElectricResistivity NanoohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromNanoohmMeters(double.CreateChecked(value));
+            => ElectricResistivity.FromNanoohmMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromNanoohmMeters(value.ToDouble(null));
+            => ElectricResistivity.FromNanoohmMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromOhmsCentimeter(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromOhmsCentimeter(QuantityValue)" />
         public static ElectricResistivity OhmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromOhmsCentimeter(double.CreateChecked(value));
+            => ElectricResistivity.FromOhmsCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromOhmsCentimeter(value.ToDouble(null));
+            => ElectricResistivity.FromOhmsCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromOhmMeters(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromOhmMeters(QuantityValue)" />
         public static ElectricResistivity OhmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromOhmMeters(double.CreateChecked(value));
+            => ElectricResistivity.FromOhmMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromOhmMeters(value.ToDouble(null));
+            => ElectricResistivity.FromOhmMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromPicoohmsCentimeter(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromPicoohmsCentimeter(QuantityValue)" />
         public static ElectricResistivity PicoohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromPicoohmsCentimeter(double.CreateChecked(value));
+            => ElectricResistivity.FromPicoohmsCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromPicoohmsCentimeter(value.ToDouble(null));
+            => ElectricResistivity.FromPicoohmsCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricResistivity.FromPicoohmMeters(double)" />
+        /// <inheritdoc cref="ElectricResistivity.FromPicoohmMeters(QuantityValue)" />
         public static ElectricResistivity PicoohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricResistivity.FromPicoohmMeters(double.CreateChecked(value));
+            => ElectricResistivity.FromPicoohmMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricResistivity.FromPicoohmMeters(value.ToDouble(null));
+            => ElectricResistivity.FromPicoohmMeters(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
index d28a14e8af..3f1edac0b2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
@@ -32,37 +32,37 @@ namespace UnitsNet.NumberExtensions.NumberToElectricSurfaceChargeDensity
     /// </summary>
     public static class NumberToElectricSurfaceChargeDensityExtensions
     {
-        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(QuantityValue)" />
         public static ElectricSurfaceChargeDensity CoulombsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(double.CreateChecked(value));
+            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(value.ToDouble(null));
+            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(double)" />
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(QuantityValue)" />
         public static ElectricSurfaceChargeDensity CoulombsPerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(double.CreateChecked(value));
+            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(value.ToDouble(null));
+            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(double)" />
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(QuantityValue)" />
         public static ElectricSurfaceChargeDensity CoulombsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(double.CreateChecked(value));
+            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(value.ToDouble(null));
+            => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs
index db36d33d50..ca94d5c3d7 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs
@@ -32,180 +32,180 @@ namespace UnitsNet.NumberExtensions.NumberToElectricSusceptance
     /// </summary>
     public static class NumberToElectricSusceptanceExtensions
     {
-        /// <inheritdoc cref="ElectricSusceptance.FromGigamhos(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromGigamhos(QuantityValue)" />
         public static ElectricSusceptance Gigamhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromGigamhos(double.CreateChecked(value));
+            => ElectricSusceptance.FromGigamhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromGigamhos(value.ToDouble(null));
+            => ElectricSusceptance.FromGigamhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromGigasiemens(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromGigasiemens(QuantityValue)" />
         public static ElectricSusceptance Gigasiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromGigasiemens(double.CreateChecked(value));
+            => ElectricSusceptance.FromGigasiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromGigasiemens(value.ToDouble(null));
+            => ElectricSusceptance.FromGigasiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromKilomhos(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromKilomhos(QuantityValue)" />
         public static ElectricSusceptance Kilomhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromKilomhos(double.CreateChecked(value));
+            => ElectricSusceptance.FromKilomhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromKilomhos(value.ToDouble(null));
+            => ElectricSusceptance.FromKilomhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromKilosiemens(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromKilosiemens(QuantityValue)" />
         public static ElectricSusceptance Kilosiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromKilosiemens(double.CreateChecked(value));
+            => ElectricSusceptance.FromKilosiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromKilosiemens(value.ToDouble(null));
+            => ElectricSusceptance.FromKilosiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromMegamhos(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromMegamhos(QuantityValue)" />
         public static ElectricSusceptance Megamhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromMegamhos(double.CreateChecked(value));
+            => ElectricSusceptance.FromMegamhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromMegamhos(value.ToDouble(null));
+            => ElectricSusceptance.FromMegamhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromMegasiemens(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromMegasiemens(QuantityValue)" />
         public static ElectricSusceptance Megasiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromMegasiemens(double.CreateChecked(value));
+            => ElectricSusceptance.FromMegasiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromMegasiemens(value.ToDouble(null));
+            => ElectricSusceptance.FromMegasiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromMhos(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromMhos(QuantityValue)" />
         public static ElectricSusceptance Mhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromMhos(double.CreateChecked(value));
+            => ElectricSusceptance.FromMhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromMhos(value.ToDouble(null));
+            => ElectricSusceptance.FromMhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromMicromhos(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromMicromhos(QuantityValue)" />
         public static ElectricSusceptance Micromhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromMicromhos(double.CreateChecked(value));
+            => ElectricSusceptance.FromMicromhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromMicromhos(value.ToDouble(null));
+            => ElectricSusceptance.FromMicromhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromMicrosiemens(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromMicrosiemens(QuantityValue)" />
         public static ElectricSusceptance Microsiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromMicrosiemens(double.CreateChecked(value));
+            => ElectricSusceptance.FromMicrosiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromMicrosiemens(value.ToDouble(null));
+            => ElectricSusceptance.FromMicrosiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromMillimhos(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromMillimhos(QuantityValue)" />
         public static ElectricSusceptance Millimhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromMillimhos(double.CreateChecked(value));
+            => ElectricSusceptance.FromMillimhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromMillimhos(value.ToDouble(null));
+            => ElectricSusceptance.FromMillimhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromMillisiemens(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromMillisiemens(QuantityValue)" />
         public static ElectricSusceptance Millisiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromMillisiemens(double.CreateChecked(value));
+            => ElectricSusceptance.FromMillisiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromMillisiemens(value.ToDouble(null));
+            => ElectricSusceptance.FromMillisiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromNanomhos(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromNanomhos(QuantityValue)" />
         public static ElectricSusceptance Nanomhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromNanomhos(double.CreateChecked(value));
+            => ElectricSusceptance.FromNanomhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromNanomhos(value.ToDouble(null));
+            => ElectricSusceptance.FromNanomhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromNanosiemens(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromNanosiemens(QuantityValue)" />
         public static ElectricSusceptance Nanosiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromNanosiemens(double.CreateChecked(value));
+            => ElectricSusceptance.FromNanosiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromNanosiemens(value.ToDouble(null));
+            => ElectricSusceptance.FromNanosiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromSiemens(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromSiemens(QuantityValue)" />
         public static ElectricSusceptance Siemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromSiemens(double.CreateChecked(value));
+            => ElectricSusceptance.FromSiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromSiemens(value.ToDouble(null));
+            => ElectricSusceptance.FromSiemens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromTeramhos(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromTeramhos(QuantityValue)" />
         public static ElectricSusceptance Teramhos<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromTeramhos(double.CreateChecked(value));
+            => ElectricSusceptance.FromTeramhos(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromTeramhos(value.ToDouble(null));
+            => ElectricSusceptance.FromTeramhos(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ElectricSusceptance.FromTerasiemens(double)" />
+        /// <inheritdoc cref="ElectricSusceptance.FromTerasiemens(QuantityValue)" />
         public static ElectricSusceptance Terasiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ElectricSusceptance.FromTerasiemens(double.CreateChecked(value));
+            => ElectricSusceptance.FromTerasiemens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ElectricSusceptance.FromTerasiemens(value.ToDouble(null));
+            => ElectricSusceptance.FromTerasiemens(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyDensityExtensions.g.cs
index 24007897fa..f54dea1f03 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyDensityExtensions.g.cs
@@ -32,136 +32,136 @@ namespace UnitsNet.NumberExtensions.NumberToEnergyDensity
     /// </summary>
     public static class NumberToEnergyDensityExtensions
     {
-        /// <inheritdoc cref="EnergyDensity.FromGigajoulesPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromGigajoulesPerCubicMeter(QuantityValue)" />
         public static EnergyDensity GigajoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromGigajoulesPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromGigajoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromGigajoulesPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromGigajoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromGigawattHoursPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromGigawattHoursPerCubicMeter(QuantityValue)" />
         public static EnergyDensity GigawattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromGigawattHoursPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromGigawattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromGigawattHoursPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromGigawattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromJoulesPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromJoulesPerCubicMeter(QuantityValue)" />
         public static EnergyDensity JoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromJoulesPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromJoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromJoulesPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromJoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromKilojoulesPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromKilojoulesPerCubicMeter(QuantityValue)" />
         public static EnergyDensity KilojoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromKilojoulesPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromKilojoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromKilojoulesPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromKilojoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromKilowattHoursPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromKilowattHoursPerCubicMeter(QuantityValue)" />
         public static EnergyDensity KilowattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromKilowattHoursPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromKilowattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromKilowattHoursPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromKilowattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromMegajoulesPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromMegajoulesPerCubicMeter(QuantityValue)" />
         public static EnergyDensity MegajoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromMegajoulesPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromMegajoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromMegajoulesPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromMegajoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromMegawattHoursPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromMegawattHoursPerCubicMeter(QuantityValue)" />
         public static EnergyDensity MegawattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromMegawattHoursPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromMegawattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromMegawattHoursPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromMegawattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromPetajoulesPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromPetajoulesPerCubicMeter(QuantityValue)" />
         public static EnergyDensity PetajoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromPetajoulesPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromPetajoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromPetajoulesPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromPetajoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromPetawattHoursPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromPetawattHoursPerCubicMeter(QuantityValue)" />
         public static EnergyDensity PetawattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromPetawattHoursPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromPetawattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromPetawattHoursPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromPetawattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromTerajoulesPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromTerajoulesPerCubicMeter(QuantityValue)" />
         public static EnergyDensity TerajoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromTerajoulesPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromTerajoulesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromTerajoulesPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromTerajoulesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromTerawattHoursPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromTerawattHoursPerCubicMeter(QuantityValue)" />
         public static EnergyDensity TerawattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromTerawattHoursPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromTerawattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromTerawattHoursPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromTerawattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="EnergyDensity.FromWattHoursPerCubicMeter(double)" />
+        /// <inheritdoc cref="EnergyDensity.FromWattHoursPerCubicMeter(QuantityValue)" />
         public static EnergyDensity WattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => EnergyDensity.FromWattHoursPerCubicMeter(double.CreateChecked(value));
+            => EnergyDensity.FromWattHoursPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => EnergyDensity.FromWattHoursPerCubicMeter(value.ToDouble(null));
+            => EnergyDensity.FromWattHoursPerCubicMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
index 50db7a9579..1cec063180 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
@@ -32,444 +32,444 @@ namespace UnitsNet.NumberExtensions.NumberToEnergy
     /// </summary>
     public static class NumberToEnergyExtensions
     {
-        /// <inheritdoc cref="Energy.FromBritishThermalUnits(double)" />
+        /// <inheritdoc cref="Energy.FromBritishThermalUnits(QuantityValue)" />
         public static Energy BritishThermalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromBritishThermalUnits(double.CreateChecked(value));
+            => Energy.FromBritishThermalUnits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromBritishThermalUnits(value.ToDouble(null));
+            => Energy.FromBritishThermalUnits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromCalories(double)" />
+        /// <inheritdoc cref="Energy.FromCalories(QuantityValue)" />
         public static Energy Calories<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromCalories(double.CreateChecked(value));
+            => Energy.FromCalories(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromCalories(value.ToDouble(null));
+            => Energy.FromCalories(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromDecathermsEc(double)" />
+        /// <inheritdoc cref="Energy.FromDecathermsEc(QuantityValue)" />
         public static Energy DecathermsEc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromDecathermsEc(double.CreateChecked(value));
+            => Energy.FromDecathermsEc(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromDecathermsEc(value.ToDouble(null));
+            => Energy.FromDecathermsEc(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromDecathermsImperial(double)" />
+        /// <inheritdoc cref="Energy.FromDecathermsImperial(QuantityValue)" />
         public static Energy DecathermsImperial<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromDecathermsImperial(double.CreateChecked(value));
+            => Energy.FromDecathermsImperial(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromDecathermsImperial(value.ToDouble(null));
+            => Energy.FromDecathermsImperial(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromDecathermsUs(double)" />
+        /// <inheritdoc cref="Energy.FromDecathermsUs(QuantityValue)" />
         public static Energy DecathermsUs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromDecathermsUs(double.CreateChecked(value));
+            => Energy.FromDecathermsUs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromDecathermsUs(value.ToDouble(null));
+            => Energy.FromDecathermsUs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromElectronVolts(double)" />
+        /// <inheritdoc cref="Energy.FromElectronVolts(QuantityValue)" />
         public static Energy ElectronVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromElectronVolts(double.CreateChecked(value));
+            => Energy.FromElectronVolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromElectronVolts(value.ToDouble(null));
+            => Energy.FromElectronVolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromErgs(double)" />
+        /// <inheritdoc cref="Energy.FromErgs(QuantityValue)" />
         public static Energy Ergs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromErgs(double.CreateChecked(value));
+            => Energy.FromErgs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromErgs(value.ToDouble(null));
+            => Energy.FromErgs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromFootPounds(double)" />
+        /// <inheritdoc cref="Energy.FromFootPounds(QuantityValue)" />
         public static Energy FootPounds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromFootPounds(double.CreateChecked(value));
+            => Energy.FromFootPounds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromFootPounds(value.ToDouble(null));
+            => Energy.FromFootPounds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromGigabritishThermalUnits(double)" />
+        /// <inheritdoc cref="Energy.FromGigabritishThermalUnits(QuantityValue)" />
         public static Energy GigabritishThermalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromGigabritishThermalUnits(double.CreateChecked(value));
+            => Energy.FromGigabritishThermalUnits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromGigabritishThermalUnits(value.ToDouble(null));
+            => Energy.FromGigabritishThermalUnits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromGigaelectronVolts(double)" />
+        /// <inheritdoc cref="Energy.FromGigaelectronVolts(QuantityValue)" />
         public static Energy GigaelectronVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromGigaelectronVolts(double.CreateChecked(value));
+            => Energy.FromGigaelectronVolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromGigaelectronVolts(value.ToDouble(null));
+            => Energy.FromGigaelectronVolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromGigajoules(double)" />
+        /// <inheritdoc cref="Energy.FromGigajoules(QuantityValue)" />
         public static Energy Gigajoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromGigajoules(double.CreateChecked(value));
+            => Energy.FromGigajoules(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromGigajoules(value.ToDouble(null));
+            => Energy.FromGigajoules(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromGigawattDays(double)" />
+        /// <inheritdoc cref="Energy.FromGigawattDays(QuantityValue)" />
         public static Energy GigawattDays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromGigawattDays(double.CreateChecked(value));
+            => Energy.FromGigawattDays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromGigawattDays(value.ToDouble(null));
+            => Energy.FromGigawattDays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromGigawattHours(double)" />
+        /// <inheritdoc cref="Energy.FromGigawattHours(QuantityValue)" />
         public static Energy GigawattHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromGigawattHours(double.CreateChecked(value));
+            => Energy.FromGigawattHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromGigawattHours(value.ToDouble(null));
+            => Energy.FromGigawattHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromHorsepowerHours(double)" />
+        /// <inheritdoc cref="Energy.FromHorsepowerHours(QuantityValue)" />
         public static Energy HorsepowerHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromHorsepowerHours(double.CreateChecked(value));
+            => Energy.FromHorsepowerHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromHorsepowerHours(value.ToDouble(null));
+            => Energy.FromHorsepowerHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromJoules(double)" />
+        /// <inheritdoc cref="Energy.FromJoules(QuantityValue)" />
         public static Energy Joules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromJoules(double.CreateChecked(value));
+            => Energy.FromJoules(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromJoules(value.ToDouble(null));
+            => Energy.FromJoules(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromKilobritishThermalUnits(double)" />
+        /// <inheritdoc cref="Energy.FromKilobritishThermalUnits(QuantityValue)" />
         public static Energy KilobritishThermalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromKilobritishThermalUnits(double.CreateChecked(value));
+            => Energy.FromKilobritishThermalUnits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromKilobritishThermalUnits(value.ToDouble(null));
+            => Energy.FromKilobritishThermalUnits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromKilocalories(double)" />
+        /// <inheritdoc cref="Energy.FromKilocalories(QuantityValue)" />
         public static Energy Kilocalories<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromKilocalories(double.CreateChecked(value));
+            => Energy.FromKilocalories(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromKilocalories(value.ToDouble(null));
+            => Energy.FromKilocalories(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromKiloelectronVolts(double)" />
+        /// <inheritdoc cref="Energy.FromKiloelectronVolts(QuantityValue)" />
         public static Energy KiloelectronVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromKiloelectronVolts(double.CreateChecked(value));
+            => Energy.FromKiloelectronVolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromKiloelectronVolts(value.ToDouble(null));
+            => Energy.FromKiloelectronVolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromKilojoules(double)" />
+        /// <inheritdoc cref="Energy.FromKilojoules(QuantityValue)" />
         public static Energy Kilojoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromKilojoules(double.CreateChecked(value));
+            => Energy.FromKilojoules(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromKilojoules(value.ToDouble(null));
+            => Energy.FromKilojoules(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromKilowattDays(double)" />
+        /// <inheritdoc cref="Energy.FromKilowattDays(QuantityValue)" />
         public static Energy KilowattDays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromKilowattDays(double.CreateChecked(value));
+            => Energy.FromKilowattDays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromKilowattDays(value.ToDouble(null));
+            => Energy.FromKilowattDays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromKilowattHours(double)" />
+        /// <inheritdoc cref="Energy.FromKilowattHours(QuantityValue)" />
         public static Energy KilowattHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromKilowattHours(double.CreateChecked(value));
+            => Energy.FromKilowattHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromKilowattHours(value.ToDouble(null));
+            => Energy.FromKilowattHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromMegabritishThermalUnits(double)" />
+        /// <inheritdoc cref="Energy.FromMegabritishThermalUnits(QuantityValue)" />
         public static Energy MegabritishThermalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromMegabritishThermalUnits(double.CreateChecked(value));
+            => Energy.FromMegabritishThermalUnits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromMegabritishThermalUnits(value.ToDouble(null));
+            => Energy.FromMegabritishThermalUnits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromMegacalories(double)" />
+        /// <inheritdoc cref="Energy.FromMegacalories(QuantityValue)" />
         public static Energy Megacalories<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromMegacalories(double.CreateChecked(value));
+            => Energy.FromMegacalories(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromMegacalories(value.ToDouble(null));
+            => Energy.FromMegacalories(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromMegaelectronVolts(double)" />
+        /// <inheritdoc cref="Energy.FromMegaelectronVolts(QuantityValue)" />
         public static Energy MegaelectronVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromMegaelectronVolts(double.CreateChecked(value));
+            => Energy.FromMegaelectronVolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromMegaelectronVolts(value.ToDouble(null));
+            => Energy.FromMegaelectronVolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromMegajoules(double)" />
+        /// <inheritdoc cref="Energy.FromMegajoules(QuantityValue)" />
         public static Energy Megajoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromMegajoules(double.CreateChecked(value));
+            => Energy.FromMegajoules(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromMegajoules(value.ToDouble(null));
+            => Energy.FromMegajoules(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromMegawattDays(double)" />
+        /// <inheritdoc cref="Energy.FromMegawattDays(QuantityValue)" />
         public static Energy MegawattDays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromMegawattDays(double.CreateChecked(value));
+            => Energy.FromMegawattDays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromMegawattDays(value.ToDouble(null));
+            => Energy.FromMegawattDays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromMegawattHours(double)" />
+        /// <inheritdoc cref="Energy.FromMegawattHours(QuantityValue)" />
         public static Energy MegawattHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromMegawattHours(double.CreateChecked(value));
+            => Energy.FromMegawattHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromMegawattHours(value.ToDouble(null));
+            => Energy.FromMegawattHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromMicrojoules(double)" />
+        /// <inheritdoc cref="Energy.FromMicrojoules(QuantityValue)" />
         public static Energy Microjoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromMicrojoules(double.CreateChecked(value));
+            => Energy.FromMicrojoules(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromMicrojoules(value.ToDouble(null));
+            => Energy.FromMicrojoules(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromMillijoules(double)" />
+        /// <inheritdoc cref="Energy.FromMillijoules(QuantityValue)" />
         public static Energy Millijoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromMillijoules(double.CreateChecked(value));
+            => Energy.FromMillijoules(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromMillijoules(value.ToDouble(null));
+            => Energy.FromMillijoules(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromNanojoules(double)" />
+        /// <inheritdoc cref="Energy.FromNanojoules(QuantityValue)" />
         public static Energy Nanojoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromNanojoules(double.CreateChecked(value));
+            => Energy.FromNanojoules(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromNanojoules(value.ToDouble(null));
+            => Energy.FromNanojoules(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromPetajoules(double)" />
+        /// <inheritdoc cref="Energy.FromPetajoules(QuantityValue)" />
         public static Energy Petajoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromPetajoules(double.CreateChecked(value));
+            => Energy.FromPetajoules(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromPetajoules(value.ToDouble(null));
+            => Energy.FromPetajoules(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromTeraelectronVolts(double)" />
+        /// <inheritdoc cref="Energy.FromTeraelectronVolts(QuantityValue)" />
         public static Energy TeraelectronVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromTeraelectronVolts(double.CreateChecked(value));
+            => Energy.FromTeraelectronVolts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromTeraelectronVolts(value.ToDouble(null));
+            => Energy.FromTeraelectronVolts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromTerajoules(double)" />
+        /// <inheritdoc cref="Energy.FromTerajoules(QuantityValue)" />
         public static Energy Terajoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromTerajoules(double.CreateChecked(value));
+            => Energy.FromTerajoules(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromTerajoules(value.ToDouble(null));
+            => Energy.FromTerajoules(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromTerawattDays(double)" />
+        /// <inheritdoc cref="Energy.FromTerawattDays(QuantityValue)" />
         public static Energy TerawattDays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromTerawattDays(double.CreateChecked(value));
+            => Energy.FromTerawattDays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromTerawattDays(value.ToDouble(null));
+            => Energy.FromTerawattDays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromTerawattHours(double)" />
+        /// <inheritdoc cref="Energy.FromTerawattHours(QuantityValue)" />
         public static Energy TerawattHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromTerawattHours(double.CreateChecked(value));
+            => Energy.FromTerawattHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromTerawattHours(value.ToDouble(null));
+            => Energy.FromTerawattHours(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromThermsEc(double)" />
+        /// <inheritdoc cref="Energy.FromThermsEc(QuantityValue)" />
         public static Energy ThermsEc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromThermsEc(double.CreateChecked(value));
+            => Energy.FromThermsEc(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromThermsEc(value.ToDouble(null));
+            => Energy.FromThermsEc(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromThermsImperial(double)" />
+        /// <inheritdoc cref="Energy.FromThermsImperial(QuantityValue)" />
         public static Energy ThermsImperial<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromThermsImperial(double.CreateChecked(value));
+            => Energy.FromThermsImperial(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromThermsImperial(value.ToDouble(null));
+            => Energy.FromThermsImperial(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromThermsUs(double)" />
+        /// <inheritdoc cref="Energy.FromThermsUs(QuantityValue)" />
         public static Energy ThermsUs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromThermsUs(double.CreateChecked(value));
+            => Energy.FromThermsUs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromThermsUs(value.ToDouble(null));
+            => Energy.FromThermsUs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromWattDays(double)" />
+        /// <inheritdoc cref="Energy.FromWattDays(QuantityValue)" />
         public static Energy WattDays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromWattDays(double.CreateChecked(value));
+            => Energy.FromWattDays(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromWattDays(value.ToDouble(null));
+            => Energy.FromWattDays(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Energy.FromWattHours(double)" />
+        /// <inheritdoc cref="Energy.FromWattHours(QuantityValue)" />
         public static Energy WattHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Energy.FromWattHours(double.CreateChecked(value));
+            => Energy.FromWattHours(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Energy.FromWattHours(value.ToDouble(null));
+            => Energy.FromWattHours(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
index 7eb721f455..175c6c6c00 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
@@ -32,81 +32,81 @@ namespace UnitsNet.NumberExtensions.NumberToEntropy
     /// </summary>
     public static class NumberToEntropyExtensions
     {
-        /// <inheritdoc cref="Entropy.FromCaloriesPerKelvin(double)" />
+        /// <inheritdoc cref="Entropy.FromCaloriesPerKelvin(QuantityValue)" />
         public static Entropy CaloriesPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Entropy.FromCaloriesPerKelvin(double.CreateChecked(value));
+            => Entropy.FromCaloriesPerKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Entropy.FromCaloriesPerKelvin(value.ToDouble(null));
+            => Entropy.FromCaloriesPerKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Entropy.FromJoulesPerDegreeCelsius(double)" />
+        /// <inheritdoc cref="Entropy.FromJoulesPerDegreeCelsius(QuantityValue)" />
         public static Entropy JoulesPerDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Entropy.FromJoulesPerDegreeCelsius(double.CreateChecked(value));
+            => Entropy.FromJoulesPerDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Entropy.FromJoulesPerDegreeCelsius(value.ToDouble(null));
+            => Entropy.FromJoulesPerDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Entropy.FromJoulesPerKelvin(double)" />
+        /// <inheritdoc cref="Entropy.FromJoulesPerKelvin(QuantityValue)" />
         public static Entropy JoulesPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Entropy.FromJoulesPerKelvin(double.CreateChecked(value));
+            => Entropy.FromJoulesPerKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Entropy.FromJoulesPerKelvin(value.ToDouble(null));
+            => Entropy.FromJoulesPerKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Entropy.FromKilocaloriesPerKelvin(double)" />
+        /// <inheritdoc cref="Entropy.FromKilocaloriesPerKelvin(QuantityValue)" />
         public static Entropy KilocaloriesPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Entropy.FromKilocaloriesPerKelvin(double.CreateChecked(value));
+            => Entropy.FromKilocaloriesPerKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Entropy.FromKilocaloriesPerKelvin(value.ToDouble(null));
+            => Entropy.FromKilocaloriesPerKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Entropy.FromKilojoulesPerDegreeCelsius(double)" />
+        /// <inheritdoc cref="Entropy.FromKilojoulesPerDegreeCelsius(QuantityValue)" />
         public static Entropy KilojoulesPerDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Entropy.FromKilojoulesPerDegreeCelsius(double.CreateChecked(value));
+            => Entropy.FromKilojoulesPerDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Entropy.FromKilojoulesPerDegreeCelsius(value.ToDouble(null));
+            => Entropy.FromKilojoulesPerDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Entropy.FromKilojoulesPerKelvin(double)" />
+        /// <inheritdoc cref="Entropy.FromKilojoulesPerKelvin(QuantityValue)" />
         public static Entropy KilojoulesPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Entropy.FromKilojoulesPerKelvin(double.CreateChecked(value));
+            => Entropy.FromKilojoulesPerKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Entropy.FromKilojoulesPerKelvin(value.ToDouble(null));
+            => Entropy.FromKilojoulesPerKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Entropy.FromMegajoulesPerKelvin(double)" />
+        /// <inheritdoc cref="Entropy.FromMegajoulesPerKelvin(QuantityValue)" />
         public static Entropy MegajoulesPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Entropy.FromMegajoulesPerKelvin(double.CreateChecked(value));
+            => Entropy.FromMegajoulesPerKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Entropy.FromMegajoulesPerKelvin(value.ToDouble(null));
+            => Entropy.FromMegajoulesPerKelvin(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFluidResistanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFluidResistanceExtensions.g.cs
index 3e8fc2ad46..22c74d7bf4 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFluidResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFluidResistanceExtensions.g.cs
@@ -32,213 +32,213 @@ namespace UnitsNet.NumberExtensions.NumberToFluidResistance
     /// </summary>
     public static class NumberToFluidResistanceExtensions
     {
-        /// <inheritdoc cref="FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(double)" />
+        /// <inheritdoc cref="FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(QuantityValue)" />
         public static FluidResistance DyneSecondsPerCentimeterToTheFifth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(double.CreateChecked(value));
+            => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(value.ToDouble(null));
+            => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromMegapascalSecondsPerCubicMeter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromMegapascalSecondsPerCubicMeter(QuantityValue)" />
         public static FluidResistance MegapascalSecondsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromMegapascalSecondsPerCubicMeter(double.CreateChecked(value));
+            => FluidResistance.FromMegapascalSecondsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromMegapascalSecondsPerCubicMeter(value.ToDouble(null));
+            => FluidResistance.FromMegapascalSecondsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(QuantityValue)" />
         public static FluidResistance MillimeterMercuryMinutesPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(double.CreateChecked(value));
+            => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(value.ToDouble(null));
+            => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(QuantityValue)" />
         public static FluidResistance MillimeterMercuryMinutesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(double.CreateChecked(value));
+            => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(value.ToDouble(null));
+            => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerLiter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerLiter(QuantityValue)" />
         public static FluidResistance MillimeterMercuryMinutesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromMillimeterMercuryMinutesPerLiter(double.CreateChecked(value));
+            => FluidResistance.FromMillimeterMercuryMinutesPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromMillimeterMercuryMinutesPerLiter(value.ToDouble(null));
+            => FluidResistance.FromMillimeterMercuryMinutesPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(QuantityValue)" />
         public static FluidResistance MillimeterMercuryMinutesPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(double.CreateChecked(value));
+            => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(value.ToDouble(null));
+            => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(QuantityValue)" />
         public static FluidResistance MillimeterMercurySecondsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(double.CreateChecked(value));
+            => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(value.ToDouble(null));
+            => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(QuantityValue)" />
         public static FluidResistance MillimeterMercurySecondsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(double.CreateChecked(value));
+            => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(value.ToDouble(null));
+            => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerLiter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerLiter(QuantityValue)" />
         public static FluidResistance MillimeterMercurySecondsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromMillimeterMercurySecondsPerLiter(double.CreateChecked(value));
+            => FluidResistance.FromMillimeterMercurySecondsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromMillimeterMercurySecondsPerLiter(value.ToDouble(null));
+            => FluidResistance.FromMillimeterMercurySecondsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerMilliliter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromMillimeterMercurySecondsPerMilliliter(QuantityValue)" />
         public static FluidResistance MillimeterMercurySecondsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(double.CreateChecked(value));
+            => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(value.ToDouble(null));
+            => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerCubicCentimeter(QuantityValue)" />
         public static FluidResistance PascalMinutesPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromPascalMinutesPerCubicCentimeter(double.CreateChecked(value));
+            => FluidResistance.FromPascalMinutesPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromPascalMinutesPerCubicCentimeter(value.ToDouble(null));
+            => FluidResistance.FromPascalMinutesPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerCubicMeter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerCubicMeter(QuantityValue)" />
         public static FluidResistance PascalMinutesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromPascalMinutesPerCubicMeter(double.CreateChecked(value));
+            => FluidResistance.FromPascalMinutesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromPascalMinutesPerCubicMeter(value.ToDouble(null));
+            => FluidResistance.FromPascalMinutesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerLiter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerLiter(QuantityValue)" />
         public static FluidResistance PascalMinutesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromPascalMinutesPerLiter(double.CreateChecked(value));
+            => FluidResistance.FromPascalMinutesPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromPascalMinutesPerLiter(value.ToDouble(null));
+            => FluidResistance.FromPascalMinutesPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerMilliliter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromPascalMinutesPerMilliliter(QuantityValue)" />
         public static FluidResistance PascalMinutesPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromPascalMinutesPerMilliliter(double.CreateChecked(value));
+            => FluidResistance.FromPascalMinutesPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromPascalMinutesPerMilliliter(value.ToDouble(null));
+            => FluidResistance.FromPascalMinutesPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerCubicCentimeter(QuantityValue)" />
         public static FluidResistance PascalSecondsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromPascalSecondsPerCubicCentimeter(double.CreateChecked(value));
+            => FluidResistance.FromPascalSecondsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromPascalSecondsPerCubicCentimeter(value.ToDouble(null));
+            => FluidResistance.FromPascalSecondsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerCubicMeter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerCubicMeter(QuantityValue)" />
         public static FluidResistance PascalSecondsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromPascalSecondsPerCubicMeter(double.CreateChecked(value));
+            => FluidResistance.FromPascalSecondsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromPascalSecondsPerCubicMeter(value.ToDouble(null));
+            => FluidResistance.FromPascalSecondsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerLiter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerLiter(QuantityValue)" />
         public static FluidResistance PascalSecondsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromPascalSecondsPerLiter(double.CreateChecked(value));
+            => FluidResistance.FromPascalSecondsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromPascalSecondsPerLiter(value.ToDouble(null));
+            => FluidResistance.FromPascalSecondsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerMilliliter(double)" />
+        /// <inheritdoc cref="FluidResistance.FromPascalSecondsPerMilliliter(QuantityValue)" />
         public static FluidResistance PascalSecondsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromPascalSecondsPerMilliliter(double.CreateChecked(value));
+            => FluidResistance.FromPascalSecondsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromPascalSecondsPerMilliliter(value.ToDouble(null));
+            => FluidResistance.FromPascalSecondsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FluidResistance.FromWoodUnits(double)" />
+        /// <inheritdoc cref="FluidResistance.FromWoodUnits(QuantityValue)" />
         public static FluidResistance WoodUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FluidResistance.FromWoodUnits(double.CreateChecked(value));
+            => FluidResistance.FromWoodUnits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FluidResistance.FromWoodUnits(value.ToDouble(null));
+            => FluidResistance.FromWoodUnits(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
index 667a6aa8eb..f1baf49edf 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
@@ -32,169 +32,169 @@ namespace UnitsNet.NumberExtensions.NumberToForceChangeRate
     /// </summary>
     public static class NumberToForceChangeRateExtensions
     {
-        /// <inheritdoc cref="ForceChangeRate.FromCentinewtonsPerSecond(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromCentinewtonsPerSecond(QuantityValue)" />
         public static ForceChangeRate CentinewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromCentinewtonsPerSecond(double.CreateChecked(value));
+            => ForceChangeRate.FromCentinewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromCentinewtonsPerSecond(value.ToDouble(null));
+            => ForceChangeRate.FromCentinewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerMinute(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerMinute(QuantityValue)" />
         public static ForceChangeRate DecanewtonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromDecanewtonsPerMinute(double.CreateChecked(value));
+            => ForceChangeRate.FromDecanewtonsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromDecanewtonsPerMinute(value.ToDouble(null));
+            => ForceChangeRate.FromDecanewtonsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerSecond(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerSecond(QuantityValue)" />
         public static ForceChangeRate DecanewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromDecanewtonsPerSecond(double.CreateChecked(value));
+            => ForceChangeRate.FromDecanewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromDecanewtonsPerSecond(value.ToDouble(null));
+            => ForceChangeRate.FromDecanewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromDecinewtonsPerSecond(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromDecinewtonsPerSecond(QuantityValue)" />
         public static ForceChangeRate DecinewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromDecinewtonsPerSecond(double.CreateChecked(value));
+            => ForceChangeRate.FromDecinewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromDecinewtonsPerSecond(value.ToDouble(null));
+            => ForceChangeRate.FromDecinewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerMinute(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerMinute(QuantityValue)" />
         public static ForceChangeRate KilonewtonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromKilonewtonsPerMinute(double.CreateChecked(value));
+            => ForceChangeRate.FromKilonewtonsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromKilonewtonsPerMinute(value.ToDouble(null));
+            => ForceChangeRate.FromKilonewtonsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerSecond(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerSecond(QuantityValue)" />
         public static ForceChangeRate KilonewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromKilonewtonsPerSecond(double.CreateChecked(value));
+            => ForceChangeRate.FromKilonewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromKilonewtonsPerSecond(value.ToDouble(null));
+            => ForceChangeRate.FromKilonewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerMinute(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerMinute(QuantityValue)" />
         public static ForceChangeRate KilopoundsForcePerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromKilopoundsForcePerMinute(double.CreateChecked(value));
+            => ForceChangeRate.FromKilopoundsForcePerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromKilopoundsForcePerMinute(value.ToDouble(null));
+            => ForceChangeRate.FromKilopoundsForcePerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerSecond(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerSecond(QuantityValue)" />
         public static ForceChangeRate KilopoundsForcePerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromKilopoundsForcePerSecond(double.CreateChecked(value));
+            => ForceChangeRate.FromKilopoundsForcePerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromKilopoundsForcePerSecond(value.ToDouble(null));
+            => ForceChangeRate.FromKilopoundsForcePerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromMicronewtonsPerSecond(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromMicronewtonsPerSecond(QuantityValue)" />
         public static ForceChangeRate MicronewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromMicronewtonsPerSecond(double.CreateChecked(value));
+            => ForceChangeRate.FromMicronewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromMicronewtonsPerSecond(value.ToDouble(null));
+            => ForceChangeRate.FromMicronewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromMillinewtonsPerSecond(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromMillinewtonsPerSecond(QuantityValue)" />
         public static ForceChangeRate MillinewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromMillinewtonsPerSecond(double.CreateChecked(value));
+            => ForceChangeRate.FromMillinewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromMillinewtonsPerSecond(value.ToDouble(null));
+            => ForceChangeRate.FromMillinewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromNanonewtonsPerSecond(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromNanonewtonsPerSecond(QuantityValue)" />
         public static ForceChangeRate NanonewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromNanonewtonsPerSecond(double.CreateChecked(value));
+            => ForceChangeRate.FromNanonewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromNanonewtonsPerSecond(value.ToDouble(null));
+            => ForceChangeRate.FromNanonewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerMinute(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerMinute(QuantityValue)" />
         public static ForceChangeRate NewtonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromNewtonsPerMinute(double.CreateChecked(value));
+            => ForceChangeRate.FromNewtonsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromNewtonsPerMinute(value.ToDouble(null));
+            => ForceChangeRate.FromNewtonsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerSecond(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerSecond(QuantityValue)" />
         public static ForceChangeRate NewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromNewtonsPerSecond(double.CreateChecked(value));
+            => ForceChangeRate.FromNewtonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromNewtonsPerSecond(value.ToDouble(null));
+            => ForceChangeRate.FromNewtonsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerMinute(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerMinute(QuantityValue)" />
         public static ForceChangeRate PoundsForcePerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromPoundsForcePerMinute(double.CreateChecked(value));
+            => ForceChangeRate.FromPoundsForcePerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromPoundsForcePerMinute(value.ToDouble(null));
+            => ForceChangeRate.FromPoundsForcePerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerSecond(double)" />
+        /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerSecond(QuantityValue)" />
         public static ForceChangeRate PoundsForcePerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForceChangeRate.FromPoundsForcePerSecond(double.CreateChecked(value));
+            => ForceChangeRate.FromPoundsForcePerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForceChangeRate.FromPoundsForcePerSecond(value.ToDouble(null));
+            => ForceChangeRate.FromPoundsForcePerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
index fcdad772ea..68333db3a9 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
@@ -32,169 +32,180 @@ namespace UnitsNet.NumberExtensions.NumberToForce
     /// </summary>
     public static class NumberToForceExtensions
     {
-        /// <inheritdoc cref="Force.FromDecanewtons(double)" />
+        /// <inheritdoc cref="Force.FromDecanewtons(QuantityValue)" />
         public static Force Decanewtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromDecanewtons(double.CreateChecked(value));
+            => Force.FromDecanewtons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromDecanewtons(value.ToDouble(null));
+            => Force.FromDecanewtons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromDyne(double)" />
+        /// <inheritdoc cref="Force.FromDyne(QuantityValue)" />
         public static Force Dyne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromDyne(double.CreateChecked(value));
+            => Force.FromDyne(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromDyne(value.ToDouble(null));
+            => Force.FromDyne(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromKilogramsForce(double)" />
+        /// <inheritdoc cref="Force.FromGramsForce(QuantityValue)" />
+        public static Force GramsForce<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => Force.FromGramsForce(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => Force.FromGramsForce(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="Force.FromKilogramsForce(QuantityValue)" />
         public static Force KilogramsForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromKilogramsForce(double.CreateChecked(value));
+            => Force.FromKilogramsForce(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromKilogramsForce(value.ToDouble(null));
+            => Force.FromKilogramsForce(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromKilonewtons(double)" />
+        /// <inheritdoc cref="Force.FromKilonewtons(QuantityValue)" />
         public static Force Kilonewtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromKilonewtons(double.CreateChecked(value));
+            => Force.FromKilonewtons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromKilonewtons(value.ToDouble(null));
+            => Force.FromKilonewtons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromKiloponds(double)" />
+        /// <inheritdoc cref="Force.FromKiloponds(QuantityValue)" />
         public static Force Kiloponds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromKiloponds(double.CreateChecked(value));
+            => Force.FromKiloponds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromKiloponds(value.ToDouble(null));
+            => Force.FromKiloponds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromKilopoundsForce(double)" />
+        /// <inheritdoc cref="Force.FromKilopoundsForce(QuantityValue)" />
         public static Force KilopoundsForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromKilopoundsForce(double.CreateChecked(value));
+            => Force.FromKilopoundsForce(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromKilopoundsForce(value.ToDouble(null));
+            => Force.FromKilopoundsForce(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromMeganewtons(double)" />
+        /// <inheritdoc cref="Force.FromMeganewtons(QuantityValue)" />
         public static Force Meganewtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromMeganewtons(double.CreateChecked(value));
+            => Force.FromMeganewtons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromMeganewtons(value.ToDouble(null));
+            => Force.FromMeganewtons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromMicronewtons(double)" />
+        /// <inheritdoc cref="Force.FromMicronewtons(QuantityValue)" />
         public static Force Micronewtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromMicronewtons(double.CreateChecked(value));
+            => Force.FromMicronewtons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromMicronewtons(value.ToDouble(null));
+            => Force.FromMicronewtons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromMillinewtons(double)" />
+        /// <inheritdoc cref="Force.FromMillinewtons(QuantityValue)" />
         public static Force Millinewtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromMillinewtons(double.CreateChecked(value));
+            => Force.FromMillinewtons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromMillinewtons(value.ToDouble(null));
+            => Force.FromMillinewtons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromNewtons(double)" />
+        /// <inheritdoc cref="Force.FromNewtons(QuantityValue)" />
         public static Force Newtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromNewtons(double.CreateChecked(value));
+            => Force.FromNewtons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromNewtons(value.ToDouble(null));
+            => Force.FromNewtons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromOunceForce(double)" />
+        /// <inheritdoc cref="Force.FromOunceForce(QuantityValue)" />
         public static Force OunceForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromOunceForce(double.CreateChecked(value));
+            => Force.FromOunceForce(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromOunceForce(value.ToDouble(null));
+            => Force.FromOunceForce(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromPoundals(double)" />
+        /// <inheritdoc cref="Force.FromPoundals(QuantityValue)" />
         public static Force Poundals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromPoundals(double.CreateChecked(value));
+            => Force.FromPoundals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromPoundals(value.ToDouble(null));
+            => Force.FromPoundals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromPoundsForce(double)" />
+        /// <inheritdoc cref="Force.FromPoundsForce(QuantityValue)" />
         public static Force PoundsForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromPoundsForce(double.CreateChecked(value));
+            => Force.FromPoundsForce(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromPoundsForce(value.ToDouble(null));
+            => Force.FromPoundsForce(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromShortTonsForce(double)" />
+        /// <inheritdoc cref="Force.FromShortTonsForce(QuantityValue)" />
         public static Force ShortTonsForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromShortTonsForce(double.CreateChecked(value));
+            => Force.FromShortTonsForce(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromShortTonsForce(value.ToDouble(null));
+            => Force.FromShortTonsForce(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Force.FromTonnesForce(double)" />
+        /// <inheritdoc cref="Force.FromTonnesForce(QuantityValue)" />
         public static Force TonnesForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Force.FromTonnesForce(double.CreateChecked(value));
+            => Force.FromTonnesForce(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Force.FromTonnesForce(value.ToDouble(null));
+            => Force.FromTonnesForce(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
index 001e77662f..9dcd094580 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
@@ -32,422 +32,422 @@ namespace UnitsNet.NumberExtensions.NumberToForcePerLength
     /// </summary>
     public static class NumberToForcePerLengthExtensions
     {
-        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerCentimeter(QuantityValue)" />
         public static ForcePerLength CentinewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromCentinewtonsPerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromCentinewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromCentinewtonsPerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromCentinewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMeter(QuantityValue)" />
         public static ForcePerLength CentinewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromCentinewtonsPerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromCentinewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromCentinewtonsPerMeter(value.ToDouble(null));
+            => ForcePerLength.FromCentinewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMillimeter(QuantityValue)" />
         public static ForcePerLength CentinewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromCentinewtonsPerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromCentinewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromCentinewtonsPerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromCentinewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerCentimeter(QuantityValue)" />
         public static ForcePerLength DecanewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromDecanewtonsPerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromDecanewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromDecanewtonsPerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromDecanewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMeter(QuantityValue)" />
         public static ForcePerLength DecanewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromDecanewtonsPerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromDecanewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromDecanewtonsPerMeter(value.ToDouble(null));
+            => ForcePerLength.FromDecanewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMillimeter(QuantityValue)" />
         public static ForcePerLength DecanewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromDecanewtonsPerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromDecanewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromDecanewtonsPerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromDecanewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerCentimeter(QuantityValue)" />
         public static ForcePerLength DecinewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromDecinewtonsPerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromDecinewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromDecinewtonsPerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromDecinewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMeter(QuantityValue)" />
         public static ForcePerLength DecinewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromDecinewtonsPerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromDecinewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromDecinewtonsPerMeter(value.ToDouble(null));
+            => ForcePerLength.FromDecinewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMillimeter(QuantityValue)" />
         public static ForcePerLength DecinewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromDecinewtonsPerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromDecinewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromDecinewtonsPerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromDecinewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerCentimeter(QuantityValue)" />
         public static ForcePerLength KilogramsForcePerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromKilogramsForcePerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromKilogramsForcePerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromKilogramsForcePerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromKilogramsForcePerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMeter(QuantityValue)" />
         public static ForcePerLength KilogramsForcePerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromKilogramsForcePerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromKilogramsForcePerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromKilogramsForcePerMeter(value.ToDouble(null));
+            => ForcePerLength.FromKilogramsForcePerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMillimeter(QuantityValue)" />
         public static ForcePerLength KilogramsForcePerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromKilogramsForcePerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromKilogramsForcePerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromKilogramsForcePerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromKilogramsForcePerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerCentimeter(QuantityValue)" />
         public static ForcePerLength KilonewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromKilonewtonsPerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromKilonewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromKilonewtonsPerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromKilonewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMeter(QuantityValue)" />
         public static ForcePerLength KilonewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromKilonewtonsPerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromKilonewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromKilonewtonsPerMeter(value.ToDouble(null));
+            => ForcePerLength.FromKilonewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMillimeter(QuantityValue)" />
         public static ForcePerLength KilonewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromKilonewtonsPerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromKilonewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromKilonewtonsPerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromKilonewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerFoot(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerFoot(QuantityValue)" />
         public static ForcePerLength KilopoundsForcePerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromKilopoundsForcePerFoot(double.CreateChecked(value));
+            => ForcePerLength.FromKilopoundsForcePerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromKilopoundsForcePerFoot(value.ToDouble(null));
+            => ForcePerLength.FromKilopoundsForcePerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerInch(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerInch(QuantityValue)" />
         public static ForcePerLength KilopoundsForcePerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromKilopoundsForcePerInch(double.CreateChecked(value));
+            => ForcePerLength.FromKilopoundsForcePerInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromKilopoundsForcePerInch(value.ToDouble(null));
+            => ForcePerLength.FromKilopoundsForcePerInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerCentimeter(QuantityValue)" />
         public static ForcePerLength MeganewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromMeganewtonsPerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromMeganewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromMeganewtonsPerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromMeganewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMeter(QuantityValue)" />
         public static ForcePerLength MeganewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromMeganewtonsPerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromMeganewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromMeganewtonsPerMeter(value.ToDouble(null));
+            => ForcePerLength.FromMeganewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMillimeter(QuantityValue)" />
         public static ForcePerLength MeganewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromMeganewtonsPerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromMeganewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromMeganewtonsPerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromMeganewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerCentimeter(QuantityValue)" />
         public static ForcePerLength MicronewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromMicronewtonsPerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromMicronewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromMicronewtonsPerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromMicronewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMeter(QuantityValue)" />
         public static ForcePerLength MicronewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromMicronewtonsPerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromMicronewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromMicronewtonsPerMeter(value.ToDouble(null));
+            => ForcePerLength.FromMicronewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMillimeter(QuantityValue)" />
         public static ForcePerLength MicronewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromMicronewtonsPerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromMicronewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromMicronewtonsPerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromMicronewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerCentimeter(QuantityValue)" />
         public static ForcePerLength MillinewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromMillinewtonsPerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromMillinewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromMillinewtonsPerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromMillinewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMeter(QuantityValue)" />
         public static ForcePerLength MillinewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromMillinewtonsPerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromMillinewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromMillinewtonsPerMeter(value.ToDouble(null));
+            => ForcePerLength.FromMillinewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMillimeter(QuantityValue)" />
         public static ForcePerLength MillinewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromMillinewtonsPerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromMillinewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromMillinewtonsPerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromMillinewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerCentimeter(QuantityValue)" />
         public static ForcePerLength NanonewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromNanonewtonsPerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromNanonewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromNanonewtonsPerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromNanonewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMeter(QuantityValue)" />
         public static ForcePerLength NanonewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromNanonewtonsPerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromNanonewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromNanonewtonsPerMeter(value.ToDouble(null));
+            => ForcePerLength.FromNanonewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMillimeter(QuantityValue)" />
         public static ForcePerLength NanonewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromNanonewtonsPerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromNanonewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromNanonewtonsPerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromNanonewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerCentimeter(QuantityValue)" />
         public static ForcePerLength NewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromNewtonsPerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromNewtonsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromNewtonsPerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromNewtonsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMeter(QuantityValue)" />
         public static ForcePerLength NewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromNewtonsPerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromNewtonsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromNewtonsPerMeter(value.ToDouble(null));
+            => ForcePerLength.FromNewtonsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMillimeter(QuantityValue)" />
         public static ForcePerLength NewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromNewtonsPerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromNewtonsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromNewtonsPerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromNewtonsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerFoot(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerFoot(QuantityValue)" />
         public static ForcePerLength PoundsForcePerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromPoundsForcePerFoot(double.CreateChecked(value));
+            => ForcePerLength.FromPoundsForcePerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromPoundsForcePerFoot(value.ToDouble(null));
+            => ForcePerLength.FromPoundsForcePerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerInch(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerInch(QuantityValue)" />
         public static ForcePerLength PoundsForcePerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromPoundsForcePerInch(double.CreateChecked(value));
+            => ForcePerLength.FromPoundsForcePerInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromPoundsForcePerInch(value.ToDouble(null));
+            => ForcePerLength.FromPoundsForcePerInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerYard(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerYard(QuantityValue)" />
         public static ForcePerLength PoundsForcePerYard<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromPoundsForcePerYard(double.CreateChecked(value));
+            => ForcePerLength.FromPoundsForcePerYard(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromPoundsForcePerYard(value.ToDouble(null));
+            => ForcePerLength.FromPoundsForcePerYard(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerCentimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerCentimeter(QuantityValue)" />
         public static ForcePerLength TonnesForcePerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromTonnesForcePerCentimeter(double.CreateChecked(value));
+            => ForcePerLength.FromTonnesForcePerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromTonnesForcePerCentimeter(value.ToDouble(null));
+            => ForcePerLength.FromTonnesForcePerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMeter(QuantityValue)" />
         public static ForcePerLength TonnesForcePerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromTonnesForcePerMeter(double.CreateChecked(value));
+            => ForcePerLength.FromTonnesForcePerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromTonnesForcePerMeter(value.ToDouble(null));
+            => ForcePerLength.FromTonnesForcePerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMillimeter(double)" />
+        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMillimeter(QuantityValue)" />
         public static ForcePerLength TonnesForcePerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ForcePerLength.FromTonnesForcePerMillimeter(double.CreateChecked(value));
+            => ForcePerLength.FromTonnesForcePerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ForcePerLength.FromTonnesForcePerMillimeter(value.ToDouble(null));
+            => ForcePerLength.FromTonnesForcePerMillimeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
index afc8943c39..b68cf5ad70 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
@@ -32,136 +32,136 @@ namespace UnitsNet.NumberExtensions.NumberToFrequency
     /// </summary>
     public static class NumberToFrequencyExtensions
     {
-        /// <inheritdoc cref="Frequency.FromBeatsPerMinute(double)" />
+        /// <inheritdoc cref="Frequency.FromBeatsPerMinute(QuantityValue)" />
         public static Frequency BeatsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromBeatsPerMinute(double.CreateChecked(value));
+            => Frequency.FromBeatsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromBeatsPerMinute(value.ToDouble(null));
+            => Frequency.FromBeatsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromCyclesPerHour(double)" />
+        /// <inheritdoc cref="Frequency.FromCyclesPerHour(QuantityValue)" />
         public static Frequency CyclesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromCyclesPerHour(double.CreateChecked(value));
+            => Frequency.FromCyclesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromCyclesPerHour(value.ToDouble(null));
+            => Frequency.FromCyclesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromCyclesPerMinute(double)" />
+        /// <inheritdoc cref="Frequency.FromCyclesPerMinute(QuantityValue)" />
         public static Frequency CyclesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromCyclesPerMinute(double.CreateChecked(value));
+            => Frequency.FromCyclesPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromCyclesPerMinute(value.ToDouble(null));
+            => Frequency.FromCyclesPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromGigahertz(double)" />
+        /// <inheritdoc cref="Frequency.FromGigahertz(QuantityValue)" />
         public static Frequency Gigahertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromGigahertz(double.CreateChecked(value));
+            => Frequency.FromGigahertz(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromGigahertz(value.ToDouble(null));
+            => Frequency.FromGigahertz(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromHertz(double)" />
+        /// <inheritdoc cref="Frequency.FromHertz(QuantityValue)" />
         public static Frequency Hertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromHertz(double.CreateChecked(value));
+            => Frequency.FromHertz(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromHertz(value.ToDouble(null));
+            => Frequency.FromHertz(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromKilohertz(double)" />
+        /// <inheritdoc cref="Frequency.FromKilohertz(QuantityValue)" />
         public static Frequency Kilohertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromKilohertz(double.CreateChecked(value));
+            => Frequency.FromKilohertz(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromKilohertz(value.ToDouble(null));
+            => Frequency.FromKilohertz(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromMegahertz(double)" />
+        /// <inheritdoc cref="Frequency.FromMegahertz(QuantityValue)" />
         public static Frequency Megahertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromMegahertz(double.CreateChecked(value));
+            => Frequency.FromMegahertz(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromMegahertz(value.ToDouble(null));
+            => Frequency.FromMegahertz(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromMicrohertz(double)" />
+        /// <inheritdoc cref="Frequency.FromMicrohertz(QuantityValue)" />
         public static Frequency Microhertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromMicrohertz(double.CreateChecked(value));
+            => Frequency.FromMicrohertz(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromMicrohertz(value.ToDouble(null));
+            => Frequency.FromMicrohertz(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromMillihertz(double)" />
+        /// <inheritdoc cref="Frequency.FromMillihertz(QuantityValue)" />
         public static Frequency Millihertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromMillihertz(double.CreateChecked(value));
+            => Frequency.FromMillihertz(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromMillihertz(value.ToDouble(null));
+            => Frequency.FromMillihertz(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromPerSecond(double)" />
+        /// <inheritdoc cref="Frequency.FromPerSecond(QuantityValue)" />
         public static Frequency PerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromPerSecond(double.CreateChecked(value));
+            => Frequency.FromPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromPerSecond(value.ToDouble(null));
+            => Frequency.FromPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromRadiansPerSecond(double)" />
+        /// <inheritdoc cref="Frequency.FromRadiansPerSecond(QuantityValue)" />
         public static Frequency RadiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromRadiansPerSecond(double.CreateChecked(value));
+            => Frequency.FromRadiansPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromRadiansPerSecond(value.ToDouble(null));
+            => Frequency.FromRadiansPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Frequency.FromTerahertz(double)" />
+        /// <inheritdoc cref="Frequency.FromTerahertz(QuantityValue)" />
         public static Frequency Terahertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Frequency.FromTerahertz(double.CreateChecked(value));
+            => Frequency.FromTerahertz(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Frequency.FromTerahertz(value.ToDouble(null));
+            => Frequency.FromTerahertz(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
index dbe0748f54..5d715f4848 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
@@ -32,48 +32,48 @@ namespace UnitsNet.NumberExtensions.NumberToFuelEfficiency
     /// </summary>
     public static class NumberToFuelEfficiencyExtensions
     {
-        /// <inheritdoc cref="FuelEfficiency.FromKilometersPerLiter(double)" />
+        /// <inheritdoc cref="FuelEfficiency.FromKilometersPerLiter(QuantityValue)" />
         public static FuelEfficiency KilometersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FuelEfficiency.FromKilometersPerLiter(double.CreateChecked(value));
+            => FuelEfficiency.FromKilometersPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FuelEfficiency.FromKilometersPerLiter(value.ToDouble(null));
+            => FuelEfficiency.FromKilometersPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FuelEfficiency.FromLitersPer100Kilometers(double)" />
+        /// <inheritdoc cref="FuelEfficiency.FromLitersPer100Kilometers(QuantityValue)" />
         public static FuelEfficiency LitersPer100Kilometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FuelEfficiency.FromLitersPer100Kilometers(double.CreateChecked(value));
+            => FuelEfficiency.FromLitersPer100Kilometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FuelEfficiency.FromLitersPer100Kilometers(value.ToDouble(null));
+            => FuelEfficiency.FromLitersPer100Kilometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUkGallon(double)" />
+        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUkGallon(QuantityValue)" />
         public static FuelEfficiency MilesPerUkGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FuelEfficiency.FromMilesPerUkGallon(double.CreateChecked(value));
+            => FuelEfficiency.FromMilesPerUkGallon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FuelEfficiency.FromMilesPerUkGallon(value.ToDouble(null));
+            => FuelEfficiency.FromMilesPerUkGallon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUsGallon(double)" />
+        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUsGallon(QuantityValue)" />
         public static FuelEfficiency MilesPerUsGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => FuelEfficiency.FromMilesPerUsGallon(double.CreateChecked(value));
+            => FuelEfficiency.FromMilesPerUsGallon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => FuelEfficiency.FromMilesPerUsGallon(value.ToDouble(null));
+            => FuelEfficiency.FromMilesPerUsGallon(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
index ac5855e7bf..cbfcd0ef8a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
@@ -32,202 +32,279 @@ namespace UnitsNet.NumberExtensions.NumberToHeatFlux
     /// </summary>
     public static class NumberToHeatFluxExtensions
     {
-        /// <inheritdoc cref="HeatFlux.FromBtusPerHourSquareFoot(double)" />
+        /// <inheritdoc cref="HeatFlux.FromBtusPerHourSquareFoot(QuantityValue)" />
         public static HeatFlux BtusPerHourSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromBtusPerHourSquareFoot(double.CreateChecked(value));
+            => HeatFlux.FromBtusPerHourSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromBtusPerHourSquareFoot(value.ToDouble(null));
+            => HeatFlux.FromBtusPerHourSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromBtusPerMinuteSquareFoot(double)" />
+        /// <inheritdoc cref="HeatFlux.FromBtusPerMinuteSquareFoot(QuantityValue)" />
         public static HeatFlux BtusPerMinuteSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromBtusPerMinuteSquareFoot(double.CreateChecked(value));
+            => HeatFlux.FromBtusPerMinuteSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromBtusPerMinuteSquareFoot(value.ToDouble(null));
+            => HeatFlux.FromBtusPerMinuteSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareFoot(double)" />
+        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareFoot(QuantityValue)" />
         public static HeatFlux BtusPerSecondSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromBtusPerSecondSquareFoot(double.CreateChecked(value));
+            => HeatFlux.FromBtusPerSecondSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromBtusPerSecondSquareFoot(value.ToDouble(null));
+            => HeatFlux.FromBtusPerSecondSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareInch(double)" />
+        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareInch(QuantityValue)" />
         public static HeatFlux BtusPerSecondSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromBtusPerSecondSquareInch(double.CreateChecked(value));
+            => HeatFlux.FromBtusPerSecondSquareInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromBtusPerSecondSquareInch(value.ToDouble(null));
+            => HeatFlux.FromBtusPerSecondSquareInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromCaloriesPerSecondSquareCentimeter(double)" />
+        /// <inheritdoc cref="HeatFlux.FromCaloriesPerSecondSquareCentimeter(QuantityValue)" />
         public static HeatFlux CaloriesPerSecondSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromCaloriesPerSecondSquareCentimeter(double.CreateChecked(value));
+            => HeatFlux.FromCaloriesPerSecondSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromCaloriesPerSecondSquareCentimeter(value.ToDouble(null));
+            => HeatFlux.FromCaloriesPerSecondSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMeter(QuantityValue)" />
         public static HeatFlux CentiwattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromCentiwattsPerSquareMeter(double.CreateChecked(value));
+            => HeatFlux.FromCentiwattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromCentiwattsPerSquareMeter(value.ToDouble(null));
+            => HeatFlux.FromCentiwattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMillimeter(QuantityValue)" />
+        public static HeatFlux CentiwattsPerSquareMillimeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => HeatFlux.FromCentiwattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => HeatFlux.FromCentiwattsPerSquareMillimeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMeter(QuantityValue)" />
         public static HeatFlux DeciwattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromDeciwattsPerSquareMeter(double.CreateChecked(value));
+            => HeatFlux.FromDeciwattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromDeciwattsPerSquareMeter(value.ToDouble(null));
+            => HeatFlux.FromDeciwattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerHourSquareMeter(double)" />
+        /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMillimeter(QuantityValue)" />
+        public static HeatFlux DeciwattsPerSquareMillimeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => HeatFlux.FromDeciwattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => HeatFlux.FromDeciwattsPerSquareMillimeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerHourSquareMeter(QuantityValue)" />
         public static HeatFlux KilocaloriesPerHourSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromKilocaloriesPerHourSquareMeter(double.CreateChecked(value));
+            => HeatFlux.FromKilocaloriesPerHourSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromKilocaloriesPerHourSquareMeter(value.ToDouble(null));
+            => HeatFlux.FromKilocaloriesPerHourSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(double)" />
+        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(QuantityValue)" />
         public static HeatFlux KilocaloriesPerSecondSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(double.CreateChecked(value));
+            => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(value.ToDouble(null));
+            => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMeter(QuantityValue)" />
         public static HeatFlux KilowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromKilowattsPerSquareMeter(double.CreateChecked(value));
+            => HeatFlux.FromKilowattsPerSquareMeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => HeatFlux.FromKilowattsPerSquareMeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMillimeter(QuantityValue)" />
+        public static HeatFlux KilowattsPerSquareMillimeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => HeatFlux.FromKilowattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromKilowattsPerSquareMeter(value.ToDouble(null));
+            => HeatFlux.FromKilowattsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMeter(QuantityValue)" />
         public static HeatFlux MicrowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromMicrowattsPerSquareMeter(double.CreateChecked(value));
+            => HeatFlux.FromMicrowattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromMicrowattsPerSquareMeter(value.ToDouble(null));
+            => HeatFlux.FromMicrowattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMillimeter(QuantityValue)" />
+        public static HeatFlux MicrowattsPerSquareMillimeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => HeatFlux.FromMicrowattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => HeatFlux.FromMicrowattsPerSquareMillimeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMeter(QuantityValue)" />
         public static HeatFlux MilliwattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromMilliwattsPerSquareMeter(double.CreateChecked(value));
+            => HeatFlux.FromMilliwattsPerSquareMeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => HeatFlux.FromMilliwattsPerSquareMeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMillimeter(QuantityValue)" />
+        public static HeatFlux MilliwattsPerSquareMillimeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => HeatFlux.FromMilliwattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromMilliwattsPerSquareMeter(value.ToDouble(null));
+            => HeatFlux.FromMilliwattsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMeter(QuantityValue)" />
         public static HeatFlux NanowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromNanowattsPerSquareMeter(double.CreateChecked(value));
+            => HeatFlux.FromNanowattsPerSquareMeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => HeatFlux.FromNanowattsPerSquareMeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMillimeter(QuantityValue)" />
+        public static HeatFlux NanowattsPerSquareMillimeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => HeatFlux.FromNanowattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromNanowattsPerSquareMeter(value.ToDouble(null));
+            => HeatFlux.FromNanowattsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromPoundsForcePerFootSecond(double)" />
+        /// <inheritdoc cref="HeatFlux.FromPoundsForcePerFootSecond(QuantityValue)" />
         public static HeatFlux PoundsForcePerFootSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromPoundsForcePerFootSecond(double.CreateChecked(value));
+            => HeatFlux.FromPoundsForcePerFootSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromPoundsForcePerFootSecond(value.ToDouble(null));
+            => HeatFlux.FromPoundsForcePerFootSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromPoundsPerSecondCubed(double)" />
+        /// <inheritdoc cref="HeatFlux.FromPoundsPerSecondCubed(QuantityValue)" />
         public static HeatFlux PoundsPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromPoundsPerSecondCubed(double.CreateChecked(value));
+            => HeatFlux.FromPoundsPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromPoundsPerSecondCubed(value.ToDouble(null));
+            => HeatFlux.FromPoundsPerSecondCubed(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareFoot(double)" />
+        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareFoot(QuantityValue)" />
         public static HeatFlux WattsPerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromWattsPerSquareFoot(double.CreateChecked(value));
+            => HeatFlux.FromWattsPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromWattsPerSquareFoot(value.ToDouble(null));
+            => HeatFlux.FromWattsPerSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareInch(double)" />
+        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareInch(QuantityValue)" />
         public static HeatFlux WattsPerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromWattsPerSquareInch(double.CreateChecked(value));
+            => HeatFlux.FromWattsPerSquareInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromWattsPerSquareInch(value.ToDouble(null));
+            => HeatFlux.FromWattsPerSquareInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMeter(QuantityValue)" />
         public static HeatFlux WattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatFlux.FromWattsPerSquareMeter(double.CreateChecked(value));
+            => HeatFlux.FromWattsPerSquareMeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => HeatFlux.FromWattsPerSquareMeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMillimeter(QuantityValue)" />
+        public static HeatFlux WattsPerSquareMillimeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => HeatFlux.FromWattsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatFlux.FromWattsPerSquareMeter(value.ToDouble(null));
+            => HeatFlux.FromWattsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
index 9eb8e34d50..3835ddb936 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
@@ -32,59 +32,70 @@ namespace UnitsNet.NumberExtensions.NumberToHeatTransferCoefficient
     /// </summary>
     public static class NumberToHeatTransferCoefficientExtensions
     {
-        /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(double)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(QuantityValue)" />
         public static HeatTransferCoefficient BtusPerHourSquareFootDegreeFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(double.CreateChecked(value));
+            => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(value.ToDouble(null));
+            => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(double)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerSecondSquareInchDegreeFahrenheit(QuantityValue)" />
+        public static HeatTransferCoefficient BtusPerSecondSquareInchDegreeFahrenheit<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => HeatTransferCoefficient.FromBtusPerSecondSquareInchDegreeFahrenheit(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => HeatTransferCoefficient.FromBtusPerSecondSquareInchDegreeFahrenheit(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(QuantityValue)" />
         public static HeatTransferCoefficient CaloriesPerHourSquareMeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(double.CreateChecked(value));
+            => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(value.ToDouble(null));
+            => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(double)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(QuantityValue)" />
         public static HeatTransferCoefficient KilocaloriesPerHourSquareMeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(double.CreateChecked(value));
+            => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(value.ToDouble(null));
+            => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(double)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(QuantityValue)" />
         public static HeatTransferCoefficient WattsPerSquareMeterCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(double.CreateChecked(value));
+            => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(value.ToDouble(null));
+            => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(double)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(QuantityValue)" />
         public static HeatTransferCoefficient WattsPerSquareMeterKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(double.CreateChecked(value));
+            => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(value.ToDouble(null));
+            => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
index 0367a8f14c..449169eda5 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
@@ -32,48 +32,48 @@ namespace UnitsNet.NumberExtensions.NumberToIlluminance
     /// </summary>
     public static class NumberToIlluminanceExtensions
     {
-        /// <inheritdoc cref="Illuminance.FromKilolux(double)" />
+        /// <inheritdoc cref="Illuminance.FromKilolux(QuantityValue)" />
         public static Illuminance Kilolux<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Illuminance.FromKilolux(double.CreateChecked(value));
+            => Illuminance.FromKilolux(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Illuminance.FromKilolux(value.ToDouble(null));
+            => Illuminance.FromKilolux(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Illuminance.FromLux(double)" />
+        /// <inheritdoc cref="Illuminance.FromLux(QuantityValue)" />
         public static Illuminance Lux<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Illuminance.FromLux(double.CreateChecked(value));
+            => Illuminance.FromLux(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Illuminance.FromLux(value.ToDouble(null));
+            => Illuminance.FromLux(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Illuminance.FromMegalux(double)" />
+        /// <inheritdoc cref="Illuminance.FromMegalux(QuantityValue)" />
         public static Illuminance Megalux<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Illuminance.FromMegalux(double.CreateChecked(value));
+            => Illuminance.FromMegalux(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Illuminance.FromMegalux(value.ToDouble(null));
+            => Illuminance.FromMegalux(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Illuminance.FromMillilux(double)" />
+        /// <inheritdoc cref="Illuminance.FromMillilux(QuantityValue)" />
         public static Illuminance Millilux<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Illuminance.FromMillilux(double.CreateChecked(value));
+            => Illuminance.FromMillilux(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Illuminance.FromMillilux(value.ToDouble(null));
+            => Illuminance.FromMillilux(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToImpulseExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToImpulseExtensions.g.cs
index 35cff39110..cacacb3bfc 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToImpulseExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToImpulseExtensions.g.cs
@@ -32,147 +32,147 @@ namespace UnitsNet.NumberExtensions.NumberToImpulse
     /// </summary>
     public static class NumberToImpulseExtensions
     {
-        /// <inheritdoc cref="Impulse.FromCentinewtonSeconds(double)" />
+        /// <inheritdoc cref="Impulse.FromCentinewtonSeconds(QuantityValue)" />
         public static Impulse CentinewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromCentinewtonSeconds(double.CreateChecked(value));
+            => Impulse.FromCentinewtonSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromCentinewtonSeconds(value.ToDouble(null));
+            => Impulse.FromCentinewtonSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromDecanewtonSeconds(double)" />
+        /// <inheritdoc cref="Impulse.FromDecanewtonSeconds(QuantityValue)" />
         public static Impulse DecanewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromDecanewtonSeconds(double.CreateChecked(value));
+            => Impulse.FromDecanewtonSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromDecanewtonSeconds(value.ToDouble(null));
+            => Impulse.FromDecanewtonSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromDecinewtonSeconds(double)" />
+        /// <inheritdoc cref="Impulse.FromDecinewtonSeconds(QuantityValue)" />
         public static Impulse DecinewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromDecinewtonSeconds(double.CreateChecked(value));
+            => Impulse.FromDecinewtonSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromDecinewtonSeconds(value.ToDouble(null));
+            => Impulse.FromDecinewtonSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromKilogramMetersPerSecond(double)" />
+        /// <inheritdoc cref="Impulse.FromKilogramMetersPerSecond(QuantityValue)" />
         public static Impulse KilogramMetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromKilogramMetersPerSecond(double.CreateChecked(value));
+            => Impulse.FromKilogramMetersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromKilogramMetersPerSecond(value.ToDouble(null));
+            => Impulse.FromKilogramMetersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromKilonewtonSeconds(double)" />
+        /// <inheritdoc cref="Impulse.FromKilonewtonSeconds(QuantityValue)" />
         public static Impulse KilonewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromKilonewtonSeconds(double.CreateChecked(value));
+            => Impulse.FromKilonewtonSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromKilonewtonSeconds(value.ToDouble(null));
+            => Impulse.FromKilonewtonSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromMeganewtonSeconds(double)" />
+        /// <inheritdoc cref="Impulse.FromMeganewtonSeconds(QuantityValue)" />
         public static Impulse MeganewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromMeganewtonSeconds(double.CreateChecked(value));
+            => Impulse.FromMeganewtonSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromMeganewtonSeconds(value.ToDouble(null));
+            => Impulse.FromMeganewtonSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromMicronewtonSeconds(double)" />
+        /// <inheritdoc cref="Impulse.FromMicronewtonSeconds(QuantityValue)" />
         public static Impulse MicronewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromMicronewtonSeconds(double.CreateChecked(value));
+            => Impulse.FromMicronewtonSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromMicronewtonSeconds(value.ToDouble(null));
+            => Impulse.FromMicronewtonSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromMillinewtonSeconds(double)" />
+        /// <inheritdoc cref="Impulse.FromMillinewtonSeconds(QuantityValue)" />
         public static Impulse MillinewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromMillinewtonSeconds(double.CreateChecked(value));
+            => Impulse.FromMillinewtonSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromMillinewtonSeconds(value.ToDouble(null));
+            => Impulse.FromMillinewtonSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromNanonewtonSeconds(double)" />
+        /// <inheritdoc cref="Impulse.FromNanonewtonSeconds(QuantityValue)" />
         public static Impulse NanonewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromNanonewtonSeconds(double.CreateChecked(value));
+            => Impulse.FromNanonewtonSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromNanonewtonSeconds(value.ToDouble(null));
+            => Impulse.FromNanonewtonSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromNewtonSeconds(double)" />
+        /// <inheritdoc cref="Impulse.FromNewtonSeconds(QuantityValue)" />
         public static Impulse NewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromNewtonSeconds(double.CreateChecked(value));
+            => Impulse.FromNewtonSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromNewtonSeconds(value.ToDouble(null));
+            => Impulse.FromNewtonSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromPoundFeetPerSecond(double)" />
+        /// <inheritdoc cref="Impulse.FromPoundFeetPerSecond(QuantityValue)" />
         public static Impulse PoundFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromPoundFeetPerSecond(double.CreateChecked(value));
+            => Impulse.FromPoundFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromPoundFeetPerSecond(value.ToDouble(null));
+            => Impulse.FromPoundFeetPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromPoundForceSeconds(double)" />
+        /// <inheritdoc cref="Impulse.FromPoundForceSeconds(QuantityValue)" />
         public static Impulse PoundForceSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromPoundForceSeconds(double.CreateChecked(value));
+            => Impulse.FromPoundForceSeconds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromPoundForceSeconds(value.ToDouble(null));
+            => Impulse.FromPoundForceSeconds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Impulse.FromSlugFeetPerSecond(double)" />
+        /// <inheritdoc cref="Impulse.FromSlugFeetPerSecond(QuantityValue)" />
         public static Impulse SlugFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Impulse.FromSlugFeetPerSecond(double.CreateChecked(value));
+            => Impulse.FromSlugFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Impulse.FromSlugFeetPerSecond(value.ToDouble(null));
+            => Impulse.FromSlugFeetPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
index 3158412758..ea679fa744 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
@@ -32,433 +32,433 @@ namespace UnitsNet.NumberExtensions.NumberToInformation
     /// </summary>
     public static class NumberToInformationExtensions
     {
-        /// <inheritdoc cref="Information.FromBits(double)" />
+        /// <inheritdoc cref="Information.FromBits(QuantityValue)" />
         public static Information Bits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromBits(double.CreateChecked(value));
+            => Information.FromBits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromBits(value.ToDouble(null));
+            => Information.FromBits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromBytes(double)" />
+        /// <inheritdoc cref="Information.FromBytes(QuantityValue)" />
         public static Information Bytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromBytes(double.CreateChecked(value));
+            => Information.FromBytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromBytes(value.ToDouble(null));
+            => Information.FromBytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromExabits(double)" />
+        /// <inheritdoc cref="Information.FromExabits(QuantityValue)" />
         public static Information Exabits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromExabits(double.CreateChecked(value));
+            => Information.FromExabits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromExabits(value.ToDouble(null));
+            => Information.FromExabits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromExabytes(double)" />
+        /// <inheritdoc cref="Information.FromExabytes(QuantityValue)" />
         public static Information Exabytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromExabytes(double.CreateChecked(value));
+            => Information.FromExabytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromExabytes(value.ToDouble(null));
+            => Information.FromExabytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromExaoctets(double)" />
+        /// <inheritdoc cref="Information.FromExaoctets(QuantityValue)" />
         public static Information Exaoctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromExaoctets(double.CreateChecked(value));
+            => Information.FromExaoctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromExaoctets(value.ToDouble(null));
+            => Information.FromExaoctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromExbibits(double)" />
+        /// <inheritdoc cref="Information.FromExbibits(QuantityValue)" />
         public static Information Exbibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromExbibits(double.CreateChecked(value));
+            => Information.FromExbibits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromExbibits(value.ToDouble(null));
+            => Information.FromExbibits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromExbibytes(double)" />
+        /// <inheritdoc cref="Information.FromExbibytes(QuantityValue)" />
         public static Information Exbibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromExbibytes(double.CreateChecked(value));
+            => Information.FromExbibytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromExbibytes(value.ToDouble(null));
+            => Information.FromExbibytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromExbioctets(double)" />
+        /// <inheritdoc cref="Information.FromExbioctets(QuantityValue)" />
         public static Information Exbioctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromExbioctets(double.CreateChecked(value));
+            => Information.FromExbioctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromExbioctets(value.ToDouble(null));
+            => Information.FromExbioctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromGibibits(double)" />
+        /// <inheritdoc cref="Information.FromGibibits(QuantityValue)" />
         public static Information Gibibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromGibibits(double.CreateChecked(value));
+            => Information.FromGibibits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromGibibits(value.ToDouble(null));
+            => Information.FromGibibits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromGibibytes(double)" />
+        /// <inheritdoc cref="Information.FromGibibytes(QuantityValue)" />
         public static Information Gibibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromGibibytes(double.CreateChecked(value));
+            => Information.FromGibibytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromGibibytes(value.ToDouble(null));
+            => Information.FromGibibytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromGibioctets(double)" />
+        /// <inheritdoc cref="Information.FromGibioctets(QuantityValue)" />
         public static Information Gibioctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromGibioctets(double.CreateChecked(value));
+            => Information.FromGibioctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromGibioctets(value.ToDouble(null));
+            => Information.FromGibioctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromGigabits(double)" />
+        /// <inheritdoc cref="Information.FromGigabits(QuantityValue)" />
         public static Information Gigabits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromGigabits(double.CreateChecked(value));
+            => Information.FromGigabits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromGigabits(value.ToDouble(null));
+            => Information.FromGigabits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromGigabytes(double)" />
+        /// <inheritdoc cref="Information.FromGigabytes(QuantityValue)" />
         public static Information Gigabytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromGigabytes(double.CreateChecked(value));
+            => Information.FromGigabytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromGigabytes(value.ToDouble(null));
+            => Information.FromGigabytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromGigaoctets(double)" />
+        /// <inheritdoc cref="Information.FromGigaoctets(QuantityValue)" />
         public static Information Gigaoctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromGigaoctets(double.CreateChecked(value));
+            => Information.FromGigaoctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromGigaoctets(value.ToDouble(null));
+            => Information.FromGigaoctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromKibibits(double)" />
+        /// <inheritdoc cref="Information.FromKibibits(QuantityValue)" />
         public static Information Kibibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromKibibits(double.CreateChecked(value));
+            => Information.FromKibibits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromKibibits(value.ToDouble(null));
+            => Information.FromKibibits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromKibibytes(double)" />
+        /// <inheritdoc cref="Information.FromKibibytes(QuantityValue)" />
         public static Information Kibibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromKibibytes(double.CreateChecked(value));
+            => Information.FromKibibytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromKibibytes(value.ToDouble(null));
+            => Information.FromKibibytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromKibioctets(double)" />
+        /// <inheritdoc cref="Information.FromKibioctets(QuantityValue)" />
         public static Information Kibioctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromKibioctets(double.CreateChecked(value));
+            => Information.FromKibioctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromKibioctets(value.ToDouble(null));
+            => Information.FromKibioctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromKilobits(double)" />
+        /// <inheritdoc cref="Information.FromKilobits(QuantityValue)" />
         public static Information Kilobits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromKilobits(double.CreateChecked(value));
+            => Information.FromKilobits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromKilobits(value.ToDouble(null));
+            => Information.FromKilobits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromKilobytes(double)" />
+        /// <inheritdoc cref="Information.FromKilobytes(QuantityValue)" />
         public static Information Kilobytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromKilobytes(double.CreateChecked(value));
+            => Information.FromKilobytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromKilobytes(value.ToDouble(null));
+            => Information.FromKilobytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromKilooctets(double)" />
+        /// <inheritdoc cref="Information.FromKilooctets(QuantityValue)" />
         public static Information Kilooctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromKilooctets(double.CreateChecked(value));
+            => Information.FromKilooctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromKilooctets(value.ToDouble(null));
+            => Information.FromKilooctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromMebibits(double)" />
+        /// <inheritdoc cref="Information.FromMebibits(QuantityValue)" />
         public static Information Mebibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromMebibits(double.CreateChecked(value));
+            => Information.FromMebibits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromMebibits(value.ToDouble(null));
+            => Information.FromMebibits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromMebibytes(double)" />
+        /// <inheritdoc cref="Information.FromMebibytes(QuantityValue)" />
         public static Information Mebibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromMebibytes(double.CreateChecked(value));
+            => Information.FromMebibytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromMebibytes(value.ToDouble(null));
+            => Information.FromMebibytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromMebioctets(double)" />
+        /// <inheritdoc cref="Information.FromMebioctets(QuantityValue)" />
         public static Information Mebioctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromMebioctets(double.CreateChecked(value));
+            => Information.FromMebioctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromMebioctets(value.ToDouble(null));
+            => Information.FromMebioctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromMegabits(double)" />
+        /// <inheritdoc cref="Information.FromMegabits(QuantityValue)" />
         public static Information Megabits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromMegabits(double.CreateChecked(value));
+            => Information.FromMegabits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromMegabits(value.ToDouble(null));
+            => Information.FromMegabits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromMegabytes(double)" />
+        /// <inheritdoc cref="Information.FromMegabytes(QuantityValue)" />
         public static Information Megabytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromMegabytes(double.CreateChecked(value));
+            => Information.FromMegabytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromMegabytes(value.ToDouble(null));
+            => Information.FromMegabytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromMegaoctets(double)" />
+        /// <inheritdoc cref="Information.FromMegaoctets(QuantityValue)" />
         public static Information Megaoctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromMegaoctets(double.CreateChecked(value));
+            => Information.FromMegaoctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromMegaoctets(value.ToDouble(null));
+            => Information.FromMegaoctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromOctets(double)" />
+        /// <inheritdoc cref="Information.FromOctets(QuantityValue)" />
         public static Information Octets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromOctets(double.CreateChecked(value));
+            => Information.FromOctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromOctets(value.ToDouble(null));
+            => Information.FromOctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromPebibits(double)" />
+        /// <inheritdoc cref="Information.FromPebibits(QuantityValue)" />
         public static Information Pebibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromPebibits(double.CreateChecked(value));
+            => Information.FromPebibits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromPebibits(value.ToDouble(null));
+            => Information.FromPebibits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromPebibytes(double)" />
+        /// <inheritdoc cref="Information.FromPebibytes(QuantityValue)" />
         public static Information Pebibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromPebibytes(double.CreateChecked(value));
+            => Information.FromPebibytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromPebibytes(value.ToDouble(null));
+            => Information.FromPebibytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromPebioctets(double)" />
+        /// <inheritdoc cref="Information.FromPebioctets(QuantityValue)" />
         public static Information Pebioctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromPebioctets(double.CreateChecked(value));
+            => Information.FromPebioctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromPebioctets(value.ToDouble(null));
+            => Information.FromPebioctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromPetabits(double)" />
+        /// <inheritdoc cref="Information.FromPetabits(QuantityValue)" />
         public static Information Petabits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromPetabits(double.CreateChecked(value));
+            => Information.FromPetabits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromPetabits(value.ToDouble(null));
+            => Information.FromPetabits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromPetabytes(double)" />
+        /// <inheritdoc cref="Information.FromPetabytes(QuantityValue)" />
         public static Information Petabytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromPetabytes(double.CreateChecked(value));
+            => Information.FromPetabytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromPetabytes(value.ToDouble(null));
+            => Information.FromPetabytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromPetaoctets(double)" />
+        /// <inheritdoc cref="Information.FromPetaoctets(QuantityValue)" />
         public static Information Petaoctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromPetaoctets(double.CreateChecked(value));
+            => Information.FromPetaoctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromPetaoctets(value.ToDouble(null));
+            => Information.FromPetaoctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromTebibits(double)" />
+        /// <inheritdoc cref="Information.FromTebibits(QuantityValue)" />
         public static Information Tebibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromTebibits(double.CreateChecked(value));
+            => Information.FromTebibits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromTebibits(value.ToDouble(null));
+            => Information.FromTebibits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromTebibytes(double)" />
+        /// <inheritdoc cref="Information.FromTebibytes(QuantityValue)" />
         public static Information Tebibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromTebibytes(double.CreateChecked(value));
+            => Information.FromTebibytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromTebibytes(value.ToDouble(null));
+            => Information.FromTebibytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromTebioctets(double)" />
+        /// <inheritdoc cref="Information.FromTebioctets(QuantityValue)" />
         public static Information Tebioctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromTebioctets(double.CreateChecked(value));
+            => Information.FromTebioctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromTebioctets(value.ToDouble(null));
+            => Information.FromTebioctets(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromTerabits(double)" />
+        /// <inheritdoc cref="Information.FromTerabits(QuantityValue)" />
         public static Information Terabits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromTerabits(double.CreateChecked(value));
+            => Information.FromTerabits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromTerabits(value.ToDouble(null));
+            => Information.FromTerabits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromTerabytes(double)" />
+        /// <inheritdoc cref="Information.FromTerabytes(QuantityValue)" />
         public static Information Terabytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromTerabytes(double.CreateChecked(value));
+            => Information.FromTerabytes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromTerabytes(value.ToDouble(null));
+            => Information.FromTerabytes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Information.FromTeraoctets(double)" />
+        /// <inheritdoc cref="Information.FromTeraoctets(QuantityValue)" />
         public static Information Teraoctets<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Information.FromTeraoctets(double.CreateChecked(value));
+            => Information.FromTeraoctets(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Information.FromTeraoctets(value.ToDouble(null));
+            => Information.FromTeraoctets(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
index a003581b53..e8fac71f73 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
@@ -32,158 +32,158 @@ namespace UnitsNet.NumberExtensions.NumberToIrradiance
     /// </summary>
     public static class NumberToIrradianceExtensions
     {
-        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareCentimeter(QuantityValue)" />
         public static Irradiance KilowattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromKilowattsPerSquareCentimeter(double.CreateChecked(value));
+            => Irradiance.FromKilowattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromKilowattsPerSquareCentimeter(value.ToDouble(null));
+            => Irradiance.FromKilowattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareMeter(QuantityValue)" />
         public static Irradiance KilowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromKilowattsPerSquareMeter(double.CreateChecked(value));
+            => Irradiance.FromKilowattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromKilowattsPerSquareMeter(value.ToDouble(null));
+            => Irradiance.FromKilowattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareCentimeter(QuantityValue)" />
         public static Irradiance MegawattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromMegawattsPerSquareCentimeter(double.CreateChecked(value));
+            => Irradiance.FromMegawattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromMegawattsPerSquareCentimeter(value.ToDouble(null));
+            => Irradiance.FromMegawattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareMeter(QuantityValue)" />
         public static Irradiance MegawattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromMegawattsPerSquareMeter(double.CreateChecked(value));
+            => Irradiance.FromMegawattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromMegawattsPerSquareMeter(value.ToDouble(null));
+            => Irradiance.FromMegawattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareCentimeter(QuantityValue)" />
         public static Irradiance MicrowattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromMicrowattsPerSquareCentimeter(double.CreateChecked(value));
+            => Irradiance.FromMicrowattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromMicrowattsPerSquareCentimeter(value.ToDouble(null));
+            => Irradiance.FromMicrowattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareMeter(QuantityValue)" />
         public static Irradiance MicrowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromMicrowattsPerSquareMeter(double.CreateChecked(value));
+            => Irradiance.FromMicrowattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromMicrowattsPerSquareMeter(value.ToDouble(null));
+            => Irradiance.FromMicrowattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareCentimeter(QuantityValue)" />
         public static Irradiance MilliwattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromMilliwattsPerSquareCentimeter(double.CreateChecked(value));
+            => Irradiance.FromMilliwattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromMilliwattsPerSquareCentimeter(value.ToDouble(null));
+            => Irradiance.FromMilliwattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareMeter(QuantityValue)" />
         public static Irradiance MilliwattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromMilliwattsPerSquareMeter(double.CreateChecked(value));
+            => Irradiance.FromMilliwattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromMilliwattsPerSquareMeter(value.ToDouble(null));
+            => Irradiance.FromMilliwattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareCentimeter(QuantityValue)" />
         public static Irradiance NanowattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromNanowattsPerSquareCentimeter(double.CreateChecked(value));
+            => Irradiance.FromNanowattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromNanowattsPerSquareCentimeter(value.ToDouble(null));
+            => Irradiance.FromNanowattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareMeter(QuantityValue)" />
         public static Irradiance NanowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromNanowattsPerSquareMeter(double.CreateChecked(value));
+            => Irradiance.FromNanowattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromNanowattsPerSquareMeter(value.ToDouble(null));
+            => Irradiance.FromNanowattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareCentimeter(QuantityValue)" />
         public static Irradiance PicowattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromPicowattsPerSquareCentimeter(double.CreateChecked(value));
+            => Irradiance.FromPicowattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromPicowattsPerSquareCentimeter(value.ToDouble(null));
+            => Irradiance.FromPicowattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareMeter(QuantityValue)" />
         public static Irradiance PicowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromPicowattsPerSquareMeter(double.CreateChecked(value));
+            => Irradiance.FromPicowattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromPicowattsPerSquareMeter(value.ToDouble(null));
+            => Irradiance.FromPicowattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromWattsPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromWattsPerSquareCentimeter(QuantityValue)" />
         public static Irradiance WattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromWattsPerSquareCentimeter(double.CreateChecked(value));
+            => Irradiance.FromWattsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromWattsPerSquareCentimeter(value.ToDouble(null));
+            => Irradiance.FromWattsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiance.FromWattsPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiance.FromWattsPerSquareMeter(QuantityValue)" />
         public static Irradiance WattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiance.FromWattsPerSquareMeter(double.CreateChecked(value));
+            => Irradiance.FromWattsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiance.FromWattsPerSquareMeter(value.ToDouble(null));
+            => Irradiance.FromWattsPerSquareMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
index a9fed1227a..4b1c1a21bd 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
@@ -32,103 +32,103 @@ namespace UnitsNet.NumberExtensions.NumberToIrradiation
     /// </summary>
     public static class NumberToIrradiationExtensions
     {
-        /// <inheritdoc cref="Irradiation.FromBtusPerSquareFoot(double)" />
+        /// <inheritdoc cref="Irradiation.FromBtusPerSquareFoot(QuantityValue)" />
         public static Irradiation BtusPerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiation.FromBtusPerSquareFoot(double.CreateChecked(value));
+            => Irradiation.FromBtusPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiation.FromBtusPerSquareFoot(value.ToDouble(null));
+            => Irradiation.FromBtusPerSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareCentimeter(QuantityValue)" />
         public static Irradiation JoulesPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiation.FromJoulesPerSquareCentimeter(double.CreateChecked(value));
+            => Irradiation.FromJoulesPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiation.FromJoulesPerSquareCentimeter(value.ToDouble(null));
+            => Irradiation.FromJoulesPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMeter(QuantityValue)" />
         public static Irradiation JoulesPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiation.FromJoulesPerSquareMeter(double.CreateChecked(value));
+            => Irradiation.FromJoulesPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiation.FromJoulesPerSquareMeter(value.ToDouble(null));
+            => Irradiation.FromJoulesPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMillimeter(double)" />
+        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMillimeter(QuantityValue)" />
         public static Irradiation JoulesPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiation.FromJoulesPerSquareMillimeter(double.CreateChecked(value));
+            => Irradiation.FromJoulesPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiation.FromJoulesPerSquareMillimeter(value.ToDouble(null));
+            => Irradiation.FromJoulesPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiation.FromKilobtusPerSquareFoot(double)" />
+        /// <inheritdoc cref="Irradiation.FromKilobtusPerSquareFoot(QuantityValue)" />
         public static Irradiation KilobtusPerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiation.FromKilobtusPerSquareFoot(double.CreateChecked(value));
+            => Irradiation.FromKilobtusPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiation.FromKilobtusPerSquareFoot(value.ToDouble(null));
+            => Irradiation.FromKilobtusPerSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiation.FromKilojoulesPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiation.FromKilojoulesPerSquareMeter(QuantityValue)" />
         public static Irradiation KilojoulesPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiation.FromKilojoulesPerSquareMeter(double.CreateChecked(value));
+            => Irradiation.FromKilojoulesPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiation.FromKilojoulesPerSquareMeter(value.ToDouble(null));
+            => Irradiation.FromKilojoulesPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiation.FromKilowattHoursPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiation.FromKilowattHoursPerSquareMeter(QuantityValue)" />
         public static Irradiation KilowattHoursPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiation.FromKilowattHoursPerSquareMeter(double.CreateChecked(value));
+            => Irradiation.FromKilowattHoursPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiation.FromKilowattHoursPerSquareMeter(value.ToDouble(null));
+            => Irradiation.FromKilowattHoursPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiation.FromMillijoulesPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Irradiation.FromMillijoulesPerSquareCentimeter(QuantityValue)" />
         public static Irradiation MillijoulesPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiation.FromMillijoulesPerSquareCentimeter(double.CreateChecked(value));
+            => Irradiation.FromMillijoulesPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiation.FromMillijoulesPerSquareCentimeter(value.ToDouble(null));
+            => Irradiation.FromMillijoulesPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Irradiation.FromWattHoursPerSquareMeter(double)" />
+        /// <inheritdoc cref="Irradiation.FromWattHoursPerSquareMeter(QuantityValue)" />
         public static Irradiation WattHoursPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Irradiation.FromWattHoursPerSquareMeter(double.CreateChecked(value));
+            => Irradiation.FromWattHoursPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Irradiation.FromWattHoursPerSquareMeter(value.ToDouble(null));
+            => Irradiation.FromWattHoursPerSquareMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToJerkExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToJerkExtensions.g.cs
index b53a174a31..c87c7d8b01 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToJerkExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToJerkExtensions.g.cs
@@ -32,125 +32,125 @@ namespace UnitsNet.NumberExtensions.NumberToJerk
     /// </summary>
     public static class NumberToJerkExtensions
     {
-        /// <inheritdoc cref="Jerk.FromCentimetersPerSecondCubed(double)" />
+        /// <inheritdoc cref="Jerk.FromCentimetersPerSecondCubed(QuantityValue)" />
         public static Jerk CentimetersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromCentimetersPerSecondCubed(double.CreateChecked(value));
+            => Jerk.FromCentimetersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromCentimetersPerSecondCubed(value.ToDouble(null));
+            => Jerk.FromCentimetersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Jerk.FromDecimetersPerSecondCubed(double)" />
+        /// <inheritdoc cref="Jerk.FromDecimetersPerSecondCubed(QuantityValue)" />
         public static Jerk DecimetersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromDecimetersPerSecondCubed(double.CreateChecked(value));
+            => Jerk.FromDecimetersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromDecimetersPerSecondCubed(value.ToDouble(null));
+            => Jerk.FromDecimetersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Jerk.FromFeetPerSecondCubed(double)" />
+        /// <inheritdoc cref="Jerk.FromFeetPerSecondCubed(QuantityValue)" />
         public static Jerk FeetPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromFeetPerSecondCubed(double.CreateChecked(value));
+            => Jerk.FromFeetPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromFeetPerSecondCubed(value.ToDouble(null));
+            => Jerk.FromFeetPerSecondCubed(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Jerk.FromInchesPerSecondCubed(double)" />
+        /// <inheritdoc cref="Jerk.FromInchesPerSecondCubed(QuantityValue)" />
         public static Jerk InchesPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromInchesPerSecondCubed(double.CreateChecked(value));
+            => Jerk.FromInchesPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromInchesPerSecondCubed(value.ToDouble(null));
+            => Jerk.FromInchesPerSecondCubed(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Jerk.FromKilometersPerSecondCubed(double)" />
+        /// <inheritdoc cref="Jerk.FromKilometersPerSecondCubed(QuantityValue)" />
         public static Jerk KilometersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromKilometersPerSecondCubed(double.CreateChecked(value));
+            => Jerk.FromKilometersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromKilometersPerSecondCubed(value.ToDouble(null));
+            => Jerk.FromKilometersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Jerk.FromMetersPerSecondCubed(double)" />
+        /// <inheritdoc cref="Jerk.FromMetersPerSecondCubed(QuantityValue)" />
         public static Jerk MetersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromMetersPerSecondCubed(double.CreateChecked(value));
+            => Jerk.FromMetersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromMetersPerSecondCubed(value.ToDouble(null));
+            => Jerk.FromMetersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Jerk.FromMicrometersPerSecondCubed(double)" />
+        /// <inheritdoc cref="Jerk.FromMicrometersPerSecondCubed(QuantityValue)" />
         public static Jerk MicrometersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromMicrometersPerSecondCubed(double.CreateChecked(value));
+            => Jerk.FromMicrometersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromMicrometersPerSecondCubed(value.ToDouble(null));
+            => Jerk.FromMicrometersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Jerk.FromMillimetersPerSecondCubed(double)" />
+        /// <inheritdoc cref="Jerk.FromMillimetersPerSecondCubed(QuantityValue)" />
         public static Jerk MillimetersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromMillimetersPerSecondCubed(double.CreateChecked(value));
+            => Jerk.FromMillimetersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromMillimetersPerSecondCubed(value.ToDouble(null));
+            => Jerk.FromMillimetersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Jerk.FromMillistandardGravitiesPerSecond(double)" />
+        /// <inheritdoc cref="Jerk.FromMillistandardGravitiesPerSecond(QuantityValue)" />
         public static Jerk MillistandardGravitiesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromMillistandardGravitiesPerSecond(double.CreateChecked(value));
+            => Jerk.FromMillistandardGravitiesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromMillistandardGravitiesPerSecond(value.ToDouble(null));
+            => Jerk.FromMillistandardGravitiesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Jerk.FromNanometersPerSecondCubed(double)" />
+        /// <inheritdoc cref="Jerk.FromNanometersPerSecondCubed(QuantityValue)" />
         public static Jerk NanometersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromNanometersPerSecondCubed(double.CreateChecked(value));
+            => Jerk.FromNanometersPerSecondCubed(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromNanometersPerSecondCubed(value.ToDouble(null));
+            => Jerk.FromNanometersPerSecondCubed(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Jerk.FromStandardGravitiesPerSecond(double)" />
+        /// <inheritdoc cref="Jerk.FromStandardGravitiesPerSecond(QuantityValue)" />
         public static Jerk StandardGravitiesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Jerk.FromStandardGravitiesPerSecond(double.CreateChecked(value));
+            => Jerk.FromStandardGravitiesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Jerk.FromStandardGravitiesPerSecond(value.ToDouble(null));
+            => Jerk.FromStandardGravitiesPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
index 0d0b8432a0..471121df00 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
@@ -32,103 +32,103 @@ namespace UnitsNet.NumberExtensions.NumberToKinematicViscosity
     /// </summary>
     public static class NumberToKinematicViscosityExtensions
     {
-        /// <inheritdoc cref="KinematicViscosity.FromCentistokes(double)" />
+        /// <inheritdoc cref="KinematicViscosity.FromCentistokes(QuantityValue)" />
         public static KinematicViscosity Centistokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => KinematicViscosity.FromCentistokes(double.CreateChecked(value));
+            => KinematicViscosity.FromCentistokes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => KinematicViscosity.FromCentistokes(value.ToDouble(null));
+            => KinematicViscosity.FromCentistokes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="KinematicViscosity.FromDecistokes(double)" />
+        /// <inheritdoc cref="KinematicViscosity.FromDecistokes(QuantityValue)" />
         public static KinematicViscosity Decistokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => KinematicViscosity.FromDecistokes(double.CreateChecked(value));
+            => KinematicViscosity.FromDecistokes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => KinematicViscosity.FromDecistokes(value.ToDouble(null));
+            => KinematicViscosity.FromDecistokes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="KinematicViscosity.FromKilostokes(double)" />
+        /// <inheritdoc cref="KinematicViscosity.FromKilostokes(QuantityValue)" />
         public static KinematicViscosity Kilostokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => KinematicViscosity.FromKilostokes(double.CreateChecked(value));
+            => KinematicViscosity.FromKilostokes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => KinematicViscosity.FromKilostokes(value.ToDouble(null));
+            => KinematicViscosity.FromKilostokes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="KinematicViscosity.FromMicrostokes(double)" />
+        /// <inheritdoc cref="KinematicViscosity.FromMicrostokes(QuantityValue)" />
         public static KinematicViscosity Microstokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => KinematicViscosity.FromMicrostokes(double.CreateChecked(value));
+            => KinematicViscosity.FromMicrostokes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => KinematicViscosity.FromMicrostokes(value.ToDouble(null));
+            => KinematicViscosity.FromMicrostokes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="KinematicViscosity.FromMillistokes(double)" />
+        /// <inheritdoc cref="KinematicViscosity.FromMillistokes(QuantityValue)" />
         public static KinematicViscosity Millistokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => KinematicViscosity.FromMillistokes(double.CreateChecked(value));
+            => KinematicViscosity.FromMillistokes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => KinematicViscosity.FromMillistokes(value.ToDouble(null));
+            => KinematicViscosity.FromMillistokes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="KinematicViscosity.FromNanostokes(double)" />
+        /// <inheritdoc cref="KinematicViscosity.FromNanostokes(QuantityValue)" />
         public static KinematicViscosity Nanostokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => KinematicViscosity.FromNanostokes(double.CreateChecked(value));
+            => KinematicViscosity.FromNanostokes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => KinematicViscosity.FromNanostokes(value.ToDouble(null));
+            => KinematicViscosity.FromNanostokes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="KinematicViscosity.FromSquareFeetPerSecond(double)" />
+        /// <inheritdoc cref="KinematicViscosity.FromSquareFeetPerSecond(QuantityValue)" />
         public static KinematicViscosity SquareFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => KinematicViscosity.FromSquareFeetPerSecond(double.CreateChecked(value));
+            => KinematicViscosity.FromSquareFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => KinematicViscosity.FromSquareFeetPerSecond(value.ToDouble(null));
+            => KinematicViscosity.FromSquareFeetPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(double)" />
+        /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(QuantityValue)" />
         public static KinematicViscosity SquareMetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => KinematicViscosity.FromSquareMetersPerSecond(double.CreateChecked(value));
+            => KinematicViscosity.FromSquareMetersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => KinematicViscosity.FromSquareMetersPerSecond(value.ToDouble(null));
+            => KinematicViscosity.FromSquareMetersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="KinematicViscosity.FromStokes(double)" />
+        /// <inheritdoc cref="KinematicViscosity.FromStokes(QuantityValue)" />
         public static KinematicViscosity Stokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => KinematicViscosity.FromStokes(double.CreateChecked(value));
+            => KinematicViscosity.FromStokes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => KinematicViscosity.FromStokes(value.ToDouble(null));
+            => KinematicViscosity.FromStokes(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLeakRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLeakRateExtensions.g.cs
index 97baf4167b..91f7a37b12 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLeakRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLeakRateExtensions.g.cs
@@ -32,48 +32,48 @@ namespace UnitsNet.NumberExtensions.NumberToLeakRate
     /// </summary>
     public static class NumberToLeakRateExtensions
     {
-        /// <inheritdoc cref="LeakRate.FromAtmCubicCentimetersPerSecond(double)" />
+        /// <inheritdoc cref="LeakRate.FromAtmCubicCentimetersPerSecond(QuantityValue)" />
         public static LeakRate AtmCubicCentimetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LeakRate.FromAtmCubicCentimetersPerSecond(double.CreateChecked(value));
+            => LeakRate.FromAtmCubicCentimetersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LeakRate.FromAtmCubicCentimetersPerSecond(value.ToDouble(null));
+            => LeakRate.FromAtmCubicCentimetersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LeakRate.FromMillibarLitersPerSecond(double)" />
+        /// <inheritdoc cref="LeakRate.FromMillibarLitersPerSecond(QuantityValue)" />
         public static LeakRate MillibarLitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LeakRate.FromMillibarLitersPerSecond(double.CreateChecked(value));
+            => LeakRate.FromMillibarLitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LeakRate.FromMillibarLitersPerSecond(value.ToDouble(null));
+            => LeakRate.FromMillibarLitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LeakRate.FromPascalCubicMetersPerSecond(double)" />
+        /// <inheritdoc cref="LeakRate.FromPascalCubicMetersPerSecond(QuantityValue)" />
         public static LeakRate PascalCubicMetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LeakRate.FromPascalCubicMetersPerSecond(double.CreateChecked(value));
+            => LeakRate.FromPascalCubicMetersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LeakRate.FromPascalCubicMetersPerSecond(value.ToDouble(null));
+            => LeakRate.FromPascalCubicMetersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LeakRate.FromTorrLitersPerSecond(double)" />
+        /// <inheritdoc cref="LeakRate.FromTorrLitersPerSecond(QuantityValue)" />
         public static LeakRate TorrLitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LeakRate.FromTorrLitersPerSecond(double.CreateChecked(value));
+            => LeakRate.FromTorrLitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LeakRate.FromTorrLitersPerSecond(value.ToDouble(null));
+            => LeakRate.FromTorrLitersPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
index 2ef0258f35..08c56dc264 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
@@ -32,466 +32,466 @@ namespace UnitsNet.NumberExtensions.NumberToLength
     /// </summary>
     public static class NumberToLengthExtensions
     {
-        /// <inheritdoc cref="Length.FromAngstroms(double)" />
+        /// <inheritdoc cref="Length.FromAngstroms(QuantityValue)" />
         public static Length Angstroms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromAngstroms(double.CreateChecked(value));
+            => Length.FromAngstroms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromAngstroms(value.ToDouble(null));
+            => Length.FromAngstroms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromAstronomicalUnits(double)" />
+        /// <inheritdoc cref="Length.FromAstronomicalUnits(QuantityValue)" />
         public static Length AstronomicalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromAstronomicalUnits(double.CreateChecked(value));
+            => Length.FromAstronomicalUnits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromAstronomicalUnits(value.ToDouble(null));
+            => Length.FromAstronomicalUnits(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromCentimeters(double)" />
+        /// <inheritdoc cref="Length.FromCentimeters(QuantityValue)" />
         public static Length Centimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromCentimeters(double.CreateChecked(value));
+            => Length.FromCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromCentimeters(value.ToDouble(null));
+            => Length.FromCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromChains(double)" />
+        /// <inheritdoc cref="Length.FromChains(QuantityValue)" />
         public static Length Chains<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromChains(double.CreateChecked(value));
+            => Length.FromChains(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromChains(value.ToDouble(null));
+            => Length.FromChains(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromDataMiles(double)" />
+        /// <inheritdoc cref="Length.FromDataMiles(QuantityValue)" />
         public static Length DataMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromDataMiles(double.CreateChecked(value));
+            => Length.FromDataMiles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromDataMiles(value.ToDouble(null));
+            => Length.FromDataMiles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromDecameters(double)" />
+        /// <inheritdoc cref="Length.FromDecameters(QuantityValue)" />
         public static Length Decameters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromDecameters(double.CreateChecked(value));
+            => Length.FromDecameters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromDecameters(value.ToDouble(null));
+            => Length.FromDecameters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromDecimeters(double)" />
+        /// <inheritdoc cref="Length.FromDecimeters(QuantityValue)" />
         public static Length Decimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromDecimeters(double.CreateChecked(value));
+            => Length.FromDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromDecimeters(value.ToDouble(null));
+            => Length.FromDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromDtpPicas(double)" />
+        /// <inheritdoc cref="Length.FromDtpPicas(QuantityValue)" />
         public static Length DtpPicas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromDtpPicas(double.CreateChecked(value));
+            => Length.FromDtpPicas(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromDtpPicas(value.ToDouble(null));
+            => Length.FromDtpPicas(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromDtpPoints(double)" />
+        /// <inheritdoc cref="Length.FromDtpPoints(QuantityValue)" />
         public static Length DtpPoints<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromDtpPoints(double.CreateChecked(value));
+            => Length.FromDtpPoints(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromDtpPoints(value.ToDouble(null));
+            => Length.FromDtpPoints(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromFathoms(double)" />
+        /// <inheritdoc cref="Length.FromFathoms(QuantityValue)" />
         public static Length Fathoms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromFathoms(double.CreateChecked(value));
+            => Length.FromFathoms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromFathoms(value.ToDouble(null));
+            => Length.FromFathoms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromFemtometers(double)" />
+        /// <inheritdoc cref="Length.FromFemtometers(QuantityValue)" />
         public static Length Femtometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromFemtometers(double.CreateChecked(value));
+            => Length.FromFemtometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromFemtometers(value.ToDouble(null));
+            => Length.FromFemtometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromFeet(double)" />
+        /// <inheritdoc cref="Length.FromFeet(QuantityValue)" />
         public static Length Feet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromFeet(double.CreateChecked(value));
+            => Length.FromFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromFeet(value.ToDouble(null));
+            => Length.FromFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromGigameters(double)" />
+        /// <inheritdoc cref="Length.FromGigameters(QuantityValue)" />
         public static Length Gigameters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromGigameters(double.CreateChecked(value));
+            => Length.FromGigameters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromGigameters(value.ToDouble(null));
+            => Length.FromGigameters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromHands(double)" />
+        /// <inheritdoc cref="Length.FromHands(QuantityValue)" />
         public static Length Hands<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromHands(double.CreateChecked(value));
+            => Length.FromHands(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromHands(value.ToDouble(null));
+            => Length.FromHands(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromHectometers(double)" />
+        /// <inheritdoc cref="Length.FromHectometers(QuantityValue)" />
         public static Length Hectometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromHectometers(double.CreateChecked(value));
+            => Length.FromHectometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromHectometers(value.ToDouble(null));
+            => Length.FromHectometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromInches(double)" />
+        /// <inheritdoc cref="Length.FromInches(QuantityValue)" />
         public static Length Inches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromInches(double.CreateChecked(value));
+            => Length.FromInches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromInches(value.ToDouble(null));
+            => Length.FromInches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromKilofeet(double)" />
+        /// <inheritdoc cref="Length.FromKilofeet(QuantityValue)" />
         public static Length Kilofeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromKilofeet(double.CreateChecked(value));
+            => Length.FromKilofeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromKilofeet(value.ToDouble(null));
+            => Length.FromKilofeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromKilolightYears(double)" />
+        /// <inheritdoc cref="Length.FromKilolightYears(QuantityValue)" />
         public static Length KilolightYears<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromKilolightYears(double.CreateChecked(value));
+            => Length.FromKilolightYears(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromKilolightYears(value.ToDouble(null));
+            => Length.FromKilolightYears(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromKilometers(double)" />
+        /// <inheritdoc cref="Length.FromKilometers(QuantityValue)" />
         public static Length Kilometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromKilometers(double.CreateChecked(value));
+            => Length.FromKilometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromKilometers(value.ToDouble(null));
+            => Length.FromKilometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromKiloparsecs(double)" />
+        /// <inheritdoc cref="Length.FromKiloparsecs(QuantityValue)" />
         public static Length Kiloparsecs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromKiloparsecs(double.CreateChecked(value));
+            => Length.FromKiloparsecs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromKiloparsecs(value.ToDouble(null));
+            => Length.FromKiloparsecs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromKiloyards(double)" />
+        /// <inheritdoc cref="Length.FromKiloyards(QuantityValue)" />
         public static Length Kiloyards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromKiloyards(double.CreateChecked(value));
+            => Length.FromKiloyards(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromKiloyards(value.ToDouble(null));
+            => Length.FromKiloyards(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromLightYears(double)" />
+        /// <inheritdoc cref="Length.FromLightYears(QuantityValue)" />
         public static Length LightYears<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromLightYears(double.CreateChecked(value));
+            => Length.FromLightYears(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromLightYears(value.ToDouble(null));
+            => Length.FromLightYears(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromMegalightYears(double)" />
+        /// <inheritdoc cref="Length.FromMegalightYears(QuantityValue)" />
         public static Length MegalightYears<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromMegalightYears(double.CreateChecked(value));
+            => Length.FromMegalightYears(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromMegalightYears(value.ToDouble(null));
+            => Length.FromMegalightYears(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromMegameters(double)" />
+        /// <inheritdoc cref="Length.FromMegameters(QuantityValue)" />
         public static Length Megameters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromMegameters(double.CreateChecked(value));
+            => Length.FromMegameters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromMegameters(value.ToDouble(null));
+            => Length.FromMegameters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromMegaparsecs(double)" />
+        /// <inheritdoc cref="Length.FromMegaparsecs(QuantityValue)" />
         public static Length Megaparsecs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromMegaparsecs(double.CreateChecked(value));
+            => Length.FromMegaparsecs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromMegaparsecs(value.ToDouble(null));
+            => Length.FromMegaparsecs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromMeters(double)" />
+        /// <inheritdoc cref="Length.FromMeters(QuantityValue)" />
         public static Length Meters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromMeters(double.CreateChecked(value));
+            => Length.FromMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromMeters(value.ToDouble(null));
+            => Length.FromMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromMicroinches(double)" />
+        /// <inheritdoc cref="Length.FromMicroinches(QuantityValue)" />
         public static Length Microinches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromMicroinches(double.CreateChecked(value));
+            => Length.FromMicroinches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromMicroinches(value.ToDouble(null));
+            => Length.FromMicroinches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromMicrometers(double)" />
+        /// <inheritdoc cref="Length.FromMicrometers(QuantityValue)" />
         public static Length Micrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromMicrometers(double.CreateChecked(value));
+            => Length.FromMicrometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromMicrometers(value.ToDouble(null));
+            => Length.FromMicrometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromMils(double)" />
+        /// <inheritdoc cref="Length.FromMils(QuantityValue)" />
         public static Length Mils<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromMils(double.CreateChecked(value));
+            => Length.FromMils(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromMils(value.ToDouble(null));
+            => Length.FromMils(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromMiles(double)" />
+        /// <inheritdoc cref="Length.FromMiles(QuantityValue)" />
         public static Length Miles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromMiles(double.CreateChecked(value));
+            => Length.FromMiles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromMiles(value.ToDouble(null));
+            => Length.FromMiles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromMillimeters(double)" />
+        /// <inheritdoc cref="Length.FromMillimeters(QuantityValue)" />
         public static Length Millimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromMillimeters(double.CreateChecked(value));
+            => Length.FromMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromMillimeters(value.ToDouble(null));
+            => Length.FromMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromNanometers(double)" />
+        /// <inheritdoc cref="Length.FromNanometers(QuantityValue)" />
         public static Length Nanometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromNanometers(double.CreateChecked(value));
+            => Length.FromNanometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromNanometers(value.ToDouble(null));
+            => Length.FromNanometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromNauticalMiles(double)" />
+        /// <inheritdoc cref="Length.FromNauticalMiles(QuantityValue)" />
         public static Length NauticalMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromNauticalMiles(double.CreateChecked(value));
+            => Length.FromNauticalMiles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromNauticalMiles(value.ToDouble(null));
+            => Length.FromNauticalMiles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromParsecs(double)" />
+        /// <inheritdoc cref="Length.FromParsecs(QuantityValue)" />
         public static Length Parsecs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromParsecs(double.CreateChecked(value));
+            => Length.FromParsecs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromParsecs(value.ToDouble(null));
+            => Length.FromParsecs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromPicometers(double)" />
+        /// <inheritdoc cref="Length.FromPicometers(QuantityValue)" />
         public static Length Picometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromPicometers(double.CreateChecked(value));
+            => Length.FromPicometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromPicometers(value.ToDouble(null));
+            => Length.FromPicometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromPrinterPicas(double)" />
+        /// <inheritdoc cref="Length.FromPrinterPicas(QuantityValue)" />
         public static Length PrinterPicas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromPrinterPicas(double.CreateChecked(value));
+            => Length.FromPrinterPicas(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromPrinterPicas(value.ToDouble(null));
+            => Length.FromPrinterPicas(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromPrinterPoints(double)" />
+        /// <inheritdoc cref="Length.FromPrinterPoints(QuantityValue)" />
         public static Length PrinterPoints<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromPrinterPoints(double.CreateChecked(value));
+            => Length.FromPrinterPoints(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromPrinterPoints(value.ToDouble(null));
+            => Length.FromPrinterPoints(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromShackles(double)" />
+        /// <inheritdoc cref="Length.FromShackles(QuantityValue)" />
         public static Length Shackles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromShackles(double.CreateChecked(value));
+            => Length.FromShackles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromShackles(value.ToDouble(null));
+            => Length.FromShackles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromSolarRadiuses(double)" />
+        /// <inheritdoc cref="Length.FromSolarRadiuses(QuantityValue)" />
         public static Length SolarRadiuses<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromSolarRadiuses(double.CreateChecked(value));
+            => Length.FromSolarRadiuses(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromSolarRadiuses(value.ToDouble(null));
+            => Length.FromSolarRadiuses(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromTwips(double)" />
+        /// <inheritdoc cref="Length.FromTwips(QuantityValue)" />
         public static Length Twips<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromTwips(double.CreateChecked(value));
+            => Length.FromTwips(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromTwips(value.ToDouble(null));
+            => Length.FromTwips(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromUsSurveyFeet(double)" />
+        /// <inheritdoc cref="Length.FromUsSurveyFeet(QuantityValue)" />
         public static Length UsSurveyFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromUsSurveyFeet(double.CreateChecked(value));
+            => Length.FromUsSurveyFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromUsSurveyFeet(value.ToDouble(null));
+            => Length.FromUsSurveyFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Length.FromYards(double)" />
+        /// <inheritdoc cref="Length.FromYards(QuantityValue)" />
         public static Length Yards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Length.FromYards(double.CreateChecked(value));
+            => Length.FromYards(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Length.FromYards(value.ToDouble(null));
+            => Length.FromYards(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
index 8152e30451..639ed80d32 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
@@ -32,26 +32,26 @@ namespace UnitsNet.NumberExtensions.NumberToLevel
     /// </summary>
     public static class NumberToLevelExtensions
     {
-        /// <inheritdoc cref="Level.FromDecibels(double)" />
+        /// <inheritdoc cref="Level.FromDecibels(QuantityValue)" />
         public static Level Decibels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Level.FromDecibels(double.CreateChecked(value));
+            => Level.FromDecibels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Level.FromDecibels(value.ToDouble(null));
+            => Level.FromDecibels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Level.FromNepers(double)" />
+        /// <inheritdoc cref="Level.FromNepers(QuantityValue)" />
         public static Level Nepers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Level.FromNepers(double.CreateChecked(value));
+            => Level.FromNepers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Level.FromNepers(value.ToDouble(null));
+            => Level.FromNepers(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
index 59b841b487..b23ed92c4f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
@@ -32,202 +32,202 @@ namespace UnitsNet.NumberExtensions.NumberToLinearDensity
     /// </summary>
     public static class NumberToLinearDensityExtensions
     {
-        /// <inheritdoc cref="LinearDensity.FromGramsPerCentimeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromGramsPerCentimeter(QuantityValue)" />
         public static LinearDensity GramsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromGramsPerCentimeter(double.CreateChecked(value));
+            => LinearDensity.FromGramsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromGramsPerCentimeter(value.ToDouble(null));
+            => LinearDensity.FromGramsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromGramsPerFoot(double)" />
+        /// <inheritdoc cref="LinearDensity.FromGramsPerFoot(QuantityValue)" />
         public static LinearDensity GramsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromGramsPerFoot(double.CreateChecked(value));
+            => LinearDensity.FromGramsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromGramsPerFoot(value.ToDouble(null));
+            => LinearDensity.FromGramsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromGramsPerMeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromGramsPerMeter(QuantityValue)" />
         public static LinearDensity GramsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromGramsPerMeter(double.CreateChecked(value));
+            => LinearDensity.FromGramsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromGramsPerMeter(value.ToDouble(null));
+            => LinearDensity.FromGramsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromGramsPerMillimeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromGramsPerMillimeter(QuantityValue)" />
         public static LinearDensity GramsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromGramsPerMillimeter(double.CreateChecked(value));
+            => LinearDensity.FromGramsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromGramsPerMillimeter(value.ToDouble(null));
+            => LinearDensity.FromGramsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromKilogramsPerCentimeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromKilogramsPerCentimeter(QuantityValue)" />
         public static LinearDensity KilogramsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromKilogramsPerCentimeter(double.CreateChecked(value));
+            => LinearDensity.FromKilogramsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromKilogramsPerCentimeter(value.ToDouble(null));
+            => LinearDensity.FromKilogramsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromKilogramsPerFoot(double)" />
+        /// <inheritdoc cref="LinearDensity.FromKilogramsPerFoot(QuantityValue)" />
         public static LinearDensity KilogramsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromKilogramsPerFoot(double.CreateChecked(value));
+            => LinearDensity.FromKilogramsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromKilogramsPerFoot(value.ToDouble(null));
+            => LinearDensity.FromKilogramsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMeter(QuantityValue)" />
         public static LinearDensity KilogramsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromKilogramsPerMeter(double.CreateChecked(value));
+            => LinearDensity.FromKilogramsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromKilogramsPerMeter(value.ToDouble(null));
+            => LinearDensity.FromKilogramsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMillimeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMillimeter(QuantityValue)" />
         public static LinearDensity KilogramsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromKilogramsPerMillimeter(double.CreateChecked(value));
+            => LinearDensity.FromKilogramsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromKilogramsPerMillimeter(value.ToDouble(null));
+            => LinearDensity.FromKilogramsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerCentimeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerCentimeter(QuantityValue)" />
         public static LinearDensity MicrogramsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromMicrogramsPerCentimeter(double.CreateChecked(value));
+            => LinearDensity.FromMicrogramsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromMicrogramsPerCentimeter(value.ToDouble(null));
+            => LinearDensity.FromMicrogramsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerFoot(double)" />
+        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerFoot(QuantityValue)" />
         public static LinearDensity MicrogramsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromMicrogramsPerFoot(double.CreateChecked(value));
+            => LinearDensity.FromMicrogramsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromMicrogramsPerFoot(value.ToDouble(null));
+            => LinearDensity.FromMicrogramsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMeter(QuantityValue)" />
         public static LinearDensity MicrogramsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromMicrogramsPerMeter(double.CreateChecked(value));
+            => LinearDensity.FromMicrogramsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromMicrogramsPerMeter(value.ToDouble(null));
+            => LinearDensity.FromMicrogramsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMillimeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMillimeter(QuantityValue)" />
         public static LinearDensity MicrogramsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromMicrogramsPerMillimeter(double.CreateChecked(value));
+            => LinearDensity.FromMicrogramsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromMicrogramsPerMillimeter(value.ToDouble(null));
+            => LinearDensity.FromMicrogramsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromMilligramsPerCentimeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromMilligramsPerCentimeter(QuantityValue)" />
         public static LinearDensity MilligramsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromMilligramsPerCentimeter(double.CreateChecked(value));
+            => LinearDensity.FromMilligramsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromMilligramsPerCentimeter(value.ToDouble(null));
+            => LinearDensity.FromMilligramsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromMilligramsPerFoot(double)" />
+        /// <inheritdoc cref="LinearDensity.FromMilligramsPerFoot(QuantityValue)" />
         public static LinearDensity MilligramsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromMilligramsPerFoot(double.CreateChecked(value));
+            => LinearDensity.FromMilligramsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromMilligramsPerFoot(value.ToDouble(null));
+            => LinearDensity.FromMilligramsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromMilligramsPerMeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromMilligramsPerMeter(QuantityValue)" />
         public static LinearDensity MilligramsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromMilligramsPerMeter(double.CreateChecked(value));
+            => LinearDensity.FromMilligramsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromMilligramsPerMeter(value.ToDouble(null));
+            => LinearDensity.FromMilligramsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromMilligramsPerMillimeter(double)" />
+        /// <inheritdoc cref="LinearDensity.FromMilligramsPerMillimeter(QuantityValue)" />
         public static LinearDensity MilligramsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromMilligramsPerMillimeter(double.CreateChecked(value));
+            => LinearDensity.FromMilligramsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromMilligramsPerMillimeter(value.ToDouble(null));
+            => LinearDensity.FromMilligramsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromPoundsPerFoot(double)" />
+        /// <inheritdoc cref="LinearDensity.FromPoundsPerFoot(QuantityValue)" />
         public static LinearDensity PoundsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromPoundsPerFoot(double.CreateChecked(value));
+            => LinearDensity.FromPoundsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromPoundsPerFoot(value.ToDouble(null));
+            => LinearDensity.FromPoundsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearDensity.FromPoundsPerInch(double)" />
+        /// <inheritdoc cref="LinearDensity.FromPoundsPerInch(QuantityValue)" />
         public static LinearDensity PoundsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearDensity.FromPoundsPerInch(double.CreateChecked(value));
+            => LinearDensity.FromPoundsPerInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearDensity.FromPoundsPerInch(value.ToDouble(null));
+            => LinearDensity.FromPoundsPerInch(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
index 3f32d79b86..ab06b93b5b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
@@ -32,279 +32,279 @@ namespace UnitsNet.NumberExtensions.NumberToLinearPowerDensity
     /// </summary>
     public static class NumberToLinearPowerDensityExtensions
     {
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerCentimeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerCentimeter(QuantityValue)" />
         public static LinearPowerDensity GigawattsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromGigawattsPerCentimeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromGigawattsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromGigawattsPerCentimeter(value.ToDouble(null));
+            => LinearPowerDensity.FromGigawattsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerFoot(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerFoot(QuantityValue)" />
         public static LinearPowerDensity GigawattsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromGigawattsPerFoot(double.CreateChecked(value));
+            => LinearPowerDensity.FromGigawattsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromGigawattsPerFoot(value.ToDouble(null));
+            => LinearPowerDensity.FromGigawattsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerInch(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerInch(QuantityValue)" />
         public static LinearPowerDensity GigawattsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromGigawattsPerInch(double.CreateChecked(value));
+            => LinearPowerDensity.FromGigawattsPerInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromGigawattsPerInch(value.ToDouble(null));
+            => LinearPowerDensity.FromGigawattsPerInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMeter(QuantityValue)" />
         public static LinearPowerDensity GigawattsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromGigawattsPerMeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromGigawattsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromGigawattsPerMeter(value.ToDouble(null));
+            => LinearPowerDensity.FromGigawattsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMillimeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMillimeter(QuantityValue)" />
         public static LinearPowerDensity GigawattsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromGigawattsPerMillimeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromGigawattsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromGigawattsPerMillimeter(value.ToDouble(null));
+            => LinearPowerDensity.FromGigawattsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerCentimeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerCentimeter(QuantityValue)" />
         public static LinearPowerDensity KilowattsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromKilowattsPerCentimeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromKilowattsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromKilowattsPerCentimeter(value.ToDouble(null));
+            => LinearPowerDensity.FromKilowattsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerFoot(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerFoot(QuantityValue)" />
         public static LinearPowerDensity KilowattsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromKilowattsPerFoot(double.CreateChecked(value));
+            => LinearPowerDensity.FromKilowattsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromKilowattsPerFoot(value.ToDouble(null));
+            => LinearPowerDensity.FromKilowattsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerInch(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerInch(QuantityValue)" />
         public static LinearPowerDensity KilowattsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromKilowattsPerInch(double.CreateChecked(value));
+            => LinearPowerDensity.FromKilowattsPerInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromKilowattsPerInch(value.ToDouble(null));
+            => LinearPowerDensity.FromKilowattsPerInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMeter(QuantityValue)" />
         public static LinearPowerDensity KilowattsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromKilowattsPerMeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromKilowattsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromKilowattsPerMeter(value.ToDouble(null));
+            => LinearPowerDensity.FromKilowattsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMillimeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMillimeter(QuantityValue)" />
         public static LinearPowerDensity KilowattsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromKilowattsPerMillimeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromKilowattsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromKilowattsPerMillimeter(value.ToDouble(null));
+            => LinearPowerDensity.FromKilowattsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerCentimeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerCentimeter(QuantityValue)" />
         public static LinearPowerDensity MegawattsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromMegawattsPerCentimeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromMegawattsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromMegawattsPerCentimeter(value.ToDouble(null));
+            => LinearPowerDensity.FromMegawattsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerFoot(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerFoot(QuantityValue)" />
         public static LinearPowerDensity MegawattsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromMegawattsPerFoot(double.CreateChecked(value));
+            => LinearPowerDensity.FromMegawattsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromMegawattsPerFoot(value.ToDouble(null));
+            => LinearPowerDensity.FromMegawattsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerInch(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerInch(QuantityValue)" />
         public static LinearPowerDensity MegawattsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromMegawattsPerInch(double.CreateChecked(value));
+            => LinearPowerDensity.FromMegawattsPerInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromMegawattsPerInch(value.ToDouble(null));
+            => LinearPowerDensity.FromMegawattsPerInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMeter(QuantityValue)" />
         public static LinearPowerDensity MegawattsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromMegawattsPerMeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromMegawattsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromMegawattsPerMeter(value.ToDouble(null));
+            => LinearPowerDensity.FromMegawattsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMillimeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMillimeter(QuantityValue)" />
         public static LinearPowerDensity MegawattsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromMegawattsPerMillimeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromMegawattsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromMegawattsPerMillimeter(value.ToDouble(null));
+            => LinearPowerDensity.FromMegawattsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerCentimeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerCentimeter(QuantityValue)" />
         public static LinearPowerDensity MilliwattsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromMilliwattsPerCentimeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromMilliwattsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromMilliwattsPerCentimeter(value.ToDouble(null));
+            => LinearPowerDensity.FromMilliwattsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerFoot(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerFoot(QuantityValue)" />
         public static LinearPowerDensity MilliwattsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromMilliwattsPerFoot(double.CreateChecked(value));
+            => LinearPowerDensity.FromMilliwattsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromMilliwattsPerFoot(value.ToDouble(null));
+            => LinearPowerDensity.FromMilliwattsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerInch(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerInch(QuantityValue)" />
         public static LinearPowerDensity MilliwattsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromMilliwattsPerInch(double.CreateChecked(value));
+            => LinearPowerDensity.FromMilliwattsPerInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromMilliwattsPerInch(value.ToDouble(null));
+            => LinearPowerDensity.FromMilliwattsPerInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMeter(QuantityValue)" />
         public static LinearPowerDensity MilliwattsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromMilliwattsPerMeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromMilliwattsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromMilliwattsPerMeter(value.ToDouble(null));
+            => LinearPowerDensity.FromMilliwattsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMillimeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMillimeter(QuantityValue)" />
         public static LinearPowerDensity MilliwattsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromMilliwattsPerMillimeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromMilliwattsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromMilliwattsPerMillimeter(value.ToDouble(null));
+            => LinearPowerDensity.FromMilliwattsPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerCentimeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerCentimeter(QuantityValue)" />
         public static LinearPowerDensity WattsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromWattsPerCentimeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromWattsPerCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromWattsPerCentimeter(value.ToDouble(null));
+            => LinearPowerDensity.FromWattsPerCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerFoot(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerFoot(QuantityValue)" />
         public static LinearPowerDensity WattsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromWattsPerFoot(double.CreateChecked(value));
+            => LinearPowerDensity.FromWattsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromWattsPerFoot(value.ToDouble(null));
+            => LinearPowerDensity.FromWattsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerInch(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerInch(QuantityValue)" />
         public static LinearPowerDensity WattsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromWattsPerInch(double.CreateChecked(value));
+            => LinearPowerDensity.FromWattsPerInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromWattsPerInch(value.ToDouble(null));
+            => LinearPowerDensity.FromWattsPerInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMeter(QuantityValue)" />
         public static LinearPowerDensity WattsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromWattsPerMeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromWattsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromWattsPerMeter(value.ToDouble(null));
+            => LinearPowerDensity.FromWattsPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMillimeter(double)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMillimeter(QuantityValue)" />
         public static LinearPowerDensity WattsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LinearPowerDensity.FromWattsPerMillimeter(double.CreateChecked(value));
+            => LinearPowerDensity.FromWattsPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LinearPowerDensity.FromWattsPerMillimeter(value.ToDouble(null));
+            => LinearPowerDensity.FromWattsPerMillimeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminanceExtensions.g.cs
index ef5a2a1453..1af6e8be91 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminanceExtensions.g.cs
@@ -32,114 +32,114 @@ namespace UnitsNet.NumberExtensions.NumberToLuminance
     /// </summary>
     public static class NumberToLuminanceExtensions
     {
-        /// <inheritdoc cref="Luminance.FromCandelasPerSquareFoot(double)" />
+        /// <inheritdoc cref="Luminance.FromCandelasPerSquareFoot(QuantityValue)" />
         public static Luminance CandelasPerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminance.FromCandelasPerSquareFoot(double.CreateChecked(value));
+            => Luminance.FromCandelasPerSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminance.FromCandelasPerSquareFoot(value.ToDouble(null));
+            => Luminance.FromCandelasPerSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminance.FromCandelasPerSquareInch(double)" />
+        /// <inheritdoc cref="Luminance.FromCandelasPerSquareInch(QuantityValue)" />
         public static Luminance CandelasPerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminance.FromCandelasPerSquareInch(double.CreateChecked(value));
+            => Luminance.FromCandelasPerSquareInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminance.FromCandelasPerSquareInch(value.ToDouble(null));
+            => Luminance.FromCandelasPerSquareInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminance.FromCandelasPerSquareMeter(double)" />
+        /// <inheritdoc cref="Luminance.FromCandelasPerSquareMeter(QuantityValue)" />
         public static Luminance CandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminance.FromCandelasPerSquareMeter(double.CreateChecked(value));
+            => Luminance.FromCandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminance.FromCandelasPerSquareMeter(value.ToDouble(null));
+            => Luminance.FromCandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminance.FromCenticandelasPerSquareMeter(double)" />
+        /// <inheritdoc cref="Luminance.FromCenticandelasPerSquareMeter(QuantityValue)" />
         public static Luminance CenticandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminance.FromCenticandelasPerSquareMeter(double.CreateChecked(value));
+            => Luminance.FromCenticandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminance.FromCenticandelasPerSquareMeter(value.ToDouble(null));
+            => Luminance.FromCenticandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminance.FromDecicandelasPerSquareMeter(double)" />
+        /// <inheritdoc cref="Luminance.FromDecicandelasPerSquareMeter(QuantityValue)" />
         public static Luminance DecicandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminance.FromDecicandelasPerSquareMeter(double.CreateChecked(value));
+            => Luminance.FromDecicandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminance.FromDecicandelasPerSquareMeter(value.ToDouble(null));
+            => Luminance.FromDecicandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminance.FromKilocandelasPerSquareMeter(double)" />
+        /// <inheritdoc cref="Luminance.FromKilocandelasPerSquareMeter(QuantityValue)" />
         public static Luminance KilocandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminance.FromKilocandelasPerSquareMeter(double.CreateChecked(value));
+            => Luminance.FromKilocandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminance.FromKilocandelasPerSquareMeter(value.ToDouble(null));
+            => Luminance.FromKilocandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminance.FromMicrocandelasPerSquareMeter(double)" />
+        /// <inheritdoc cref="Luminance.FromMicrocandelasPerSquareMeter(QuantityValue)" />
         public static Luminance MicrocandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminance.FromMicrocandelasPerSquareMeter(double.CreateChecked(value));
+            => Luminance.FromMicrocandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminance.FromMicrocandelasPerSquareMeter(value.ToDouble(null));
+            => Luminance.FromMicrocandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminance.FromMillicandelasPerSquareMeter(double)" />
+        /// <inheritdoc cref="Luminance.FromMillicandelasPerSquareMeter(QuantityValue)" />
         public static Luminance MillicandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminance.FromMillicandelasPerSquareMeter(double.CreateChecked(value));
+            => Luminance.FromMillicandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminance.FromMillicandelasPerSquareMeter(value.ToDouble(null));
+            => Luminance.FromMillicandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminance.FromNanocandelasPerSquareMeter(double)" />
+        /// <inheritdoc cref="Luminance.FromNanocandelasPerSquareMeter(QuantityValue)" />
         public static Luminance NanocandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminance.FromNanocandelasPerSquareMeter(double.CreateChecked(value));
+            => Luminance.FromNanocandelasPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminance.FromNanocandelasPerSquareMeter(value.ToDouble(null));
+            => Luminance.FromNanocandelasPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminance.FromNits(double)" />
+        /// <inheritdoc cref="Luminance.FromNits(QuantityValue)" />
         public static Luminance Nits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminance.FromNits(double.CreateChecked(value));
+            => Luminance.FromNits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminance.FromNits(value.ToDouble(null));
+            => Luminance.FromNits(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
index d9c5901e1f..dd8111a618 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
@@ -32,158 +32,158 @@ namespace UnitsNet.NumberExtensions.NumberToLuminosity
     /// </summary>
     public static class NumberToLuminosityExtensions
     {
-        /// <inheritdoc cref="Luminosity.FromDecawatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromDecawatts(QuantityValue)" />
         public static Luminosity Decawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromDecawatts(double.CreateChecked(value));
+            => Luminosity.FromDecawatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromDecawatts(value.ToDouble(null));
+            => Luminosity.FromDecawatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromDeciwatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromDeciwatts(QuantityValue)" />
         public static Luminosity Deciwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromDeciwatts(double.CreateChecked(value));
+            => Luminosity.FromDeciwatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromDeciwatts(value.ToDouble(null));
+            => Luminosity.FromDeciwatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromFemtowatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromFemtowatts(QuantityValue)" />
         public static Luminosity Femtowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromFemtowatts(double.CreateChecked(value));
+            => Luminosity.FromFemtowatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromFemtowatts(value.ToDouble(null));
+            => Luminosity.FromFemtowatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromGigawatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromGigawatts(QuantityValue)" />
         public static Luminosity Gigawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromGigawatts(double.CreateChecked(value));
+            => Luminosity.FromGigawatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromGigawatts(value.ToDouble(null));
+            => Luminosity.FromGigawatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromKilowatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromKilowatts(QuantityValue)" />
         public static Luminosity Kilowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromKilowatts(double.CreateChecked(value));
+            => Luminosity.FromKilowatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromKilowatts(value.ToDouble(null));
+            => Luminosity.FromKilowatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromMegawatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromMegawatts(QuantityValue)" />
         public static Luminosity Megawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromMegawatts(double.CreateChecked(value));
+            => Luminosity.FromMegawatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromMegawatts(value.ToDouble(null));
+            => Luminosity.FromMegawatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromMicrowatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromMicrowatts(QuantityValue)" />
         public static Luminosity Microwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromMicrowatts(double.CreateChecked(value));
+            => Luminosity.FromMicrowatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromMicrowatts(value.ToDouble(null));
+            => Luminosity.FromMicrowatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromMilliwatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromMilliwatts(QuantityValue)" />
         public static Luminosity Milliwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromMilliwatts(double.CreateChecked(value));
+            => Luminosity.FromMilliwatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromMilliwatts(value.ToDouble(null));
+            => Luminosity.FromMilliwatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromNanowatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromNanowatts(QuantityValue)" />
         public static Luminosity Nanowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromNanowatts(double.CreateChecked(value));
+            => Luminosity.FromNanowatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromNanowatts(value.ToDouble(null));
+            => Luminosity.FromNanowatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromPetawatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromPetawatts(QuantityValue)" />
         public static Luminosity Petawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromPetawatts(double.CreateChecked(value));
+            => Luminosity.FromPetawatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromPetawatts(value.ToDouble(null));
+            => Luminosity.FromPetawatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromPicowatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromPicowatts(QuantityValue)" />
         public static Luminosity Picowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromPicowatts(double.CreateChecked(value));
+            => Luminosity.FromPicowatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromPicowatts(value.ToDouble(null));
+            => Luminosity.FromPicowatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromSolarLuminosities(double)" />
+        /// <inheritdoc cref="Luminosity.FromSolarLuminosities(QuantityValue)" />
         public static Luminosity SolarLuminosities<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromSolarLuminosities(double.CreateChecked(value));
+            => Luminosity.FromSolarLuminosities(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromSolarLuminosities(value.ToDouble(null));
+            => Luminosity.FromSolarLuminosities(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromTerawatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromTerawatts(QuantityValue)" />
         public static Luminosity Terawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromTerawatts(double.CreateChecked(value));
+            => Luminosity.FromTerawatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromTerawatts(value.ToDouble(null));
+            => Luminosity.FromTerawatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Luminosity.FromWatts(double)" />
+        /// <inheritdoc cref="Luminosity.FromWatts(QuantityValue)" />
         public static Luminosity Watts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Luminosity.FromWatts(double.CreateChecked(value));
+            => Luminosity.FromWatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Luminosity.FromWatts(value.ToDouble(null));
+            => Luminosity.FromWatts(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
index 77b32a6349..cc402384a7 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToLuminousFlux
     /// </summary>
     public static class NumberToLuminousFluxExtensions
     {
-        /// <inheritdoc cref="LuminousFlux.FromLumens(double)" />
+        /// <inheritdoc cref="LuminousFlux.FromLumens(QuantityValue)" />
         public static LuminousFlux Lumens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LuminousFlux.FromLumens(double.CreateChecked(value));
+            => LuminousFlux.FromLumens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LuminousFlux.FromLumens(value.ToDouble(null));
+            => LuminousFlux.FromLumens(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
index 0f7022e11f..1ca22a12dd 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToLuminousIntensity
     /// </summary>
     public static class NumberToLuminousIntensityExtensions
     {
-        /// <inheritdoc cref="LuminousIntensity.FromCandela(double)" />
+        /// <inheritdoc cref="LuminousIntensity.FromCandela(QuantityValue)" />
         public static LuminousIntensity Candela<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => LuminousIntensity.FromCandela(double.CreateChecked(value));
+            => LuminousIntensity.FromCandela(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => LuminousIntensity.FromCandela(value.ToDouble(null));
+            => LuminousIntensity.FromCandela(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
index 7df946205f..7394148f9a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
@@ -32,70 +32,70 @@ namespace UnitsNet.NumberExtensions.NumberToMagneticField
     /// </summary>
     public static class NumberToMagneticFieldExtensions
     {
-        /// <inheritdoc cref="MagneticField.FromGausses(double)" />
+        /// <inheritdoc cref="MagneticField.FromGausses(QuantityValue)" />
         public static MagneticField Gausses<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MagneticField.FromGausses(double.CreateChecked(value));
+            => MagneticField.FromGausses(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MagneticField.FromGausses(value.ToDouble(null));
+            => MagneticField.FromGausses(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MagneticField.FromMicroteslas(double)" />
+        /// <inheritdoc cref="MagneticField.FromMicroteslas(QuantityValue)" />
         public static MagneticField Microteslas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MagneticField.FromMicroteslas(double.CreateChecked(value));
+            => MagneticField.FromMicroteslas(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MagneticField.FromMicroteslas(value.ToDouble(null));
+            => MagneticField.FromMicroteslas(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MagneticField.FromMilligausses(double)" />
+        /// <inheritdoc cref="MagneticField.FromMilligausses(QuantityValue)" />
         public static MagneticField Milligausses<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MagneticField.FromMilligausses(double.CreateChecked(value));
+            => MagneticField.FromMilligausses(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MagneticField.FromMilligausses(value.ToDouble(null));
+            => MagneticField.FromMilligausses(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MagneticField.FromMilliteslas(double)" />
+        /// <inheritdoc cref="MagneticField.FromMilliteslas(QuantityValue)" />
         public static MagneticField Milliteslas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MagneticField.FromMilliteslas(double.CreateChecked(value));
+            => MagneticField.FromMilliteslas(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MagneticField.FromMilliteslas(value.ToDouble(null));
+            => MagneticField.FromMilliteslas(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MagneticField.FromNanoteslas(double)" />
+        /// <inheritdoc cref="MagneticField.FromNanoteslas(QuantityValue)" />
         public static MagneticField Nanoteslas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MagneticField.FromNanoteslas(double.CreateChecked(value));
+            => MagneticField.FromNanoteslas(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MagneticField.FromNanoteslas(value.ToDouble(null));
+            => MagneticField.FromNanoteslas(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MagneticField.FromTeslas(double)" />
+        /// <inheritdoc cref="MagneticField.FromTeslas(QuantityValue)" />
         public static MagneticField Teslas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MagneticField.FromTeslas(double.CreateChecked(value));
+            => MagneticField.FromTeslas(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MagneticField.FromTeslas(value.ToDouble(null));
+            => MagneticField.FromTeslas(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
index 6d96430872..473c0f26c3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToMagneticFlux
     /// </summary>
     public static class NumberToMagneticFluxExtensions
     {
-        /// <inheritdoc cref="MagneticFlux.FromWebers(double)" />
+        /// <inheritdoc cref="MagneticFlux.FromWebers(QuantityValue)" />
         public static MagneticFlux Webers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MagneticFlux.FromWebers(double.CreateChecked(value));
+            => MagneticFlux.FromWebers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MagneticFlux.FromWebers(value.ToDouble(null));
+            => MagneticFlux.FromWebers(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
index 663b43fd9b..fac03116da 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToMagnetization
     /// </summary>
     public static class NumberToMagnetizationExtensions
     {
-        /// <inheritdoc cref="Magnetization.FromAmperesPerMeter(double)" />
+        /// <inheritdoc cref="Magnetization.FromAmperesPerMeter(QuantityValue)" />
         public static Magnetization AmperesPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Magnetization.FromAmperesPerMeter(double.CreateChecked(value));
+            => Magnetization.FromAmperesPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Magnetization.FromAmperesPerMeter(value.ToDouble(null));
+            => Magnetization.FromAmperesPerMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
index f1e991a534..22861dedf2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
@@ -32,543 +32,543 @@ namespace UnitsNet.NumberExtensions.NumberToMassConcentration
     /// </summary>
     public static class NumberToMassConcentrationExtensions
     {
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerDeciliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerDeciliter(QuantityValue)" />
         public static MassConcentration CentigramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromCentigramsPerDeciliter(double.CreateChecked(value));
+            => MassConcentration.FromCentigramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromCentigramsPerDeciliter(value.ToDouble(null));
+            => MassConcentration.FromCentigramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerLiter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerLiter(QuantityValue)" />
         public static MassConcentration CentigramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromCentigramsPerLiter(double.CreateChecked(value));
+            => MassConcentration.FromCentigramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromCentigramsPerLiter(value.ToDouble(null));
+            => MassConcentration.FromCentigramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMicroliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMicroliter(QuantityValue)" />
         public static MassConcentration CentigramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromCentigramsPerMicroliter(double.CreateChecked(value));
+            => MassConcentration.FromCentigramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromCentigramsPerMicroliter(value.ToDouble(null));
+            => MassConcentration.FromCentigramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMilliliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMilliliter(QuantityValue)" />
         public static MassConcentration CentigramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromCentigramsPerMilliliter(double.CreateChecked(value));
+            => MassConcentration.FromCentigramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromCentigramsPerMilliliter(value.ToDouble(null));
+            => MassConcentration.FromCentigramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerDeciliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerDeciliter(QuantityValue)" />
         public static MassConcentration DecigramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromDecigramsPerDeciliter(double.CreateChecked(value));
+            => MassConcentration.FromDecigramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromDecigramsPerDeciliter(value.ToDouble(null));
+            => MassConcentration.FromDecigramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerLiter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerLiter(QuantityValue)" />
         public static MassConcentration DecigramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromDecigramsPerLiter(double.CreateChecked(value));
+            => MassConcentration.FromDecigramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromDecigramsPerLiter(value.ToDouble(null));
+            => MassConcentration.FromDecigramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMicroliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMicroliter(QuantityValue)" />
         public static MassConcentration DecigramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromDecigramsPerMicroliter(double.CreateChecked(value));
+            => MassConcentration.FromDecigramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromDecigramsPerMicroliter(value.ToDouble(null));
+            => MassConcentration.FromDecigramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMilliliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMilliliter(QuantityValue)" />
         public static MassConcentration DecigramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromDecigramsPerMilliliter(double.CreateChecked(value));
+            => MassConcentration.FromDecigramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromDecigramsPerMilliliter(value.ToDouble(null));
+            => MassConcentration.FromDecigramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicCentimeter(QuantityValue)" />
         public static MassConcentration GramsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromGramsPerCubicCentimeter(double.CreateChecked(value));
+            => MassConcentration.FromGramsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromGramsPerCubicCentimeter(value.ToDouble(null));
+            => MassConcentration.FromGramsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMeter(QuantityValue)" />
         public static MassConcentration GramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromGramsPerCubicMeter(double.CreateChecked(value));
+            => MassConcentration.FromGramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromGramsPerCubicMeter(value.ToDouble(null));
+            => MassConcentration.FromGramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMillimeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMillimeter(QuantityValue)" />
         public static MassConcentration GramsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromGramsPerCubicMillimeter(double.CreateChecked(value));
+            => MassConcentration.FromGramsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromGramsPerCubicMillimeter(value.ToDouble(null));
+            => MassConcentration.FromGramsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerDeciliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerDeciliter(QuantityValue)" />
         public static MassConcentration GramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromGramsPerDeciliter(double.CreateChecked(value));
+            => MassConcentration.FromGramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromGramsPerDeciliter(value.ToDouble(null));
+            => MassConcentration.FromGramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerLiter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerLiter(QuantityValue)" />
         public static MassConcentration GramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromGramsPerLiter(double.CreateChecked(value));
+            => MassConcentration.FromGramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromGramsPerLiter(value.ToDouble(null));
+            => MassConcentration.FromGramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerMicroliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerMicroliter(QuantityValue)" />
         public static MassConcentration GramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromGramsPerMicroliter(double.CreateChecked(value));
+            => MassConcentration.FromGramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromGramsPerMicroliter(value.ToDouble(null));
+            => MassConcentration.FromGramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerMilliliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerMilliliter(QuantityValue)" />
         public static MassConcentration GramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromGramsPerMilliliter(double.CreateChecked(value));
+            => MassConcentration.FromGramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromGramsPerMilliliter(value.ToDouble(null));
+            => MassConcentration.FromGramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicCentimeter(QuantityValue)" />
         public static MassConcentration KilogramsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromKilogramsPerCubicCentimeter(double.CreateChecked(value));
+            => MassConcentration.FromKilogramsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromKilogramsPerCubicCentimeter(value.ToDouble(null));
+            => MassConcentration.FromKilogramsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMeter(QuantityValue)" />
         public static MassConcentration KilogramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromKilogramsPerCubicMeter(double.CreateChecked(value));
+            => MassConcentration.FromKilogramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromKilogramsPerCubicMeter(value.ToDouble(null));
+            => MassConcentration.FromKilogramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMillimeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMillimeter(QuantityValue)" />
         public static MassConcentration KilogramsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromKilogramsPerCubicMillimeter(double.CreateChecked(value));
+            => MassConcentration.FromKilogramsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromKilogramsPerCubicMillimeter(value.ToDouble(null));
+            => MassConcentration.FromKilogramsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerLiter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerLiter(QuantityValue)" />
         public static MassConcentration KilogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromKilogramsPerLiter(double.CreateChecked(value));
+            => MassConcentration.FromKilogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromKilogramsPerLiter(value.ToDouble(null));
+            => MassConcentration.FromKilogramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicFoot(double)" />
+        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicFoot(QuantityValue)" />
         public static MassConcentration KilopoundsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromKilopoundsPerCubicFoot(double.CreateChecked(value));
+            => MassConcentration.FromKilopoundsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromKilopoundsPerCubicFoot(value.ToDouble(null));
+            => MassConcentration.FromKilopoundsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicInch(double)" />
+        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicInch(QuantityValue)" />
         public static MassConcentration KilopoundsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromKilopoundsPerCubicInch(double.CreateChecked(value));
+            => MassConcentration.FromKilopoundsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromKilopoundsPerCubicInch(value.ToDouble(null));
+            => MassConcentration.FromKilopoundsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerCubicMeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerCubicMeter(QuantityValue)" />
         public static MassConcentration MicrogramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromMicrogramsPerCubicMeter(double.CreateChecked(value));
+            => MassConcentration.FromMicrogramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromMicrogramsPerCubicMeter(value.ToDouble(null));
+            => MassConcentration.FromMicrogramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerDeciliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerDeciliter(QuantityValue)" />
         public static MassConcentration MicrogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromMicrogramsPerDeciliter(double.CreateChecked(value));
+            => MassConcentration.FromMicrogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromMicrogramsPerDeciliter(value.ToDouble(null));
+            => MassConcentration.FromMicrogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerLiter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerLiter(QuantityValue)" />
         public static MassConcentration MicrogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromMicrogramsPerLiter(double.CreateChecked(value));
+            => MassConcentration.FromMicrogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromMicrogramsPerLiter(value.ToDouble(null));
+            => MassConcentration.FromMicrogramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMicroliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMicroliter(QuantityValue)" />
         public static MassConcentration MicrogramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromMicrogramsPerMicroliter(double.CreateChecked(value));
+            => MassConcentration.FromMicrogramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromMicrogramsPerMicroliter(value.ToDouble(null));
+            => MassConcentration.FromMicrogramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMilliliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMilliliter(QuantityValue)" />
         public static MassConcentration MicrogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromMicrogramsPerMilliliter(double.CreateChecked(value));
+            => MassConcentration.FromMicrogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromMicrogramsPerMilliliter(value.ToDouble(null));
+            => MassConcentration.FromMicrogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerCubicMeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerCubicMeter(QuantityValue)" />
         public static MassConcentration MilligramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromMilligramsPerCubicMeter(double.CreateChecked(value));
+            => MassConcentration.FromMilligramsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromMilligramsPerCubicMeter(value.ToDouble(null));
+            => MassConcentration.FromMilligramsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerDeciliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerDeciliter(QuantityValue)" />
         public static MassConcentration MilligramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromMilligramsPerDeciliter(double.CreateChecked(value));
+            => MassConcentration.FromMilligramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromMilligramsPerDeciliter(value.ToDouble(null));
+            => MassConcentration.FromMilligramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerLiter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerLiter(QuantityValue)" />
         public static MassConcentration MilligramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromMilligramsPerLiter(double.CreateChecked(value));
+            => MassConcentration.FromMilligramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromMilligramsPerLiter(value.ToDouble(null));
+            => MassConcentration.FromMilligramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMicroliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMicroliter(QuantityValue)" />
         public static MassConcentration MilligramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromMilligramsPerMicroliter(double.CreateChecked(value));
+            => MassConcentration.FromMilligramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromMilligramsPerMicroliter(value.ToDouble(null));
+            => MassConcentration.FromMilligramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMilliliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMilliliter(QuantityValue)" />
         public static MassConcentration MilligramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromMilligramsPerMilliliter(double.CreateChecked(value));
+            => MassConcentration.FromMilligramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromMilligramsPerMilliliter(value.ToDouble(null));
+            => MassConcentration.FromMilligramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerDeciliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerDeciliter(QuantityValue)" />
         public static MassConcentration NanogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromNanogramsPerDeciliter(double.CreateChecked(value));
+            => MassConcentration.FromNanogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromNanogramsPerDeciliter(value.ToDouble(null));
+            => MassConcentration.FromNanogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerLiter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerLiter(QuantityValue)" />
         public static MassConcentration NanogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromNanogramsPerLiter(double.CreateChecked(value));
+            => MassConcentration.FromNanogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromNanogramsPerLiter(value.ToDouble(null));
+            => MassConcentration.FromNanogramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMicroliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMicroliter(QuantityValue)" />
         public static MassConcentration NanogramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromNanogramsPerMicroliter(double.CreateChecked(value));
+            => MassConcentration.FromNanogramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromNanogramsPerMicroliter(value.ToDouble(null));
+            => MassConcentration.FromNanogramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMilliliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMilliliter(QuantityValue)" />
         public static MassConcentration NanogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromNanogramsPerMilliliter(double.CreateChecked(value));
+            => MassConcentration.FromNanogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromNanogramsPerMilliliter(value.ToDouble(null));
+            => MassConcentration.FromNanogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromOuncesPerImperialGallon(double)" />
+        /// <inheritdoc cref="MassConcentration.FromOuncesPerImperialGallon(QuantityValue)" />
         public static MassConcentration OuncesPerImperialGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromOuncesPerImperialGallon(double.CreateChecked(value));
+            => MassConcentration.FromOuncesPerImperialGallon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromOuncesPerImperialGallon(value.ToDouble(null));
+            => MassConcentration.FromOuncesPerImperialGallon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromOuncesPerUSGallon(double)" />
+        /// <inheritdoc cref="MassConcentration.FromOuncesPerUSGallon(QuantityValue)" />
         public static MassConcentration OuncesPerUSGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromOuncesPerUSGallon(double.CreateChecked(value));
+            => MassConcentration.FromOuncesPerUSGallon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromOuncesPerUSGallon(value.ToDouble(null));
+            => MassConcentration.FromOuncesPerUSGallon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerDeciliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerDeciliter(QuantityValue)" />
         public static MassConcentration PicogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromPicogramsPerDeciliter(double.CreateChecked(value));
+            => MassConcentration.FromPicogramsPerDeciliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromPicogramsPerDeciliter(value.ToDouble(null));
+            => MassConcentration.FromPicogramsPerDeciliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerLiter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerLiter(QuantityValue)" />
         public static MassConcentration PicogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromPicogramsPerLiter(double.CreateChecked(value));
+            => MassConcentration.FromPicogramsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromPicogramsPerLiter(value.ToDouble(null));
+            => MassConcentration.FromPicogramsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMicroliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMicroliter(QuantityValue)" />
         public static MassConcentration PicogramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromPicogramsPerMicroliter(double.CreateChecked(value));
+            => MassConcentration.FromPicogramsPerMicroliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromPicogramsPerMicroliter(value.ToDouble(null));
+            => MassConcentration.FromPicogramsPerMicroliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMilliliter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMilliliter(QuantityValue)" />
         public static MassConcentration PicogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromPicogramsPerMilliliter(double.CreateChecked(value));
+            => MassConcentration.FromPicogramsPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromPicogramsPerMilliliter(value.ToDouble(null));
+            => MassConcentration.FromPicogramsPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicFoot(double)" />
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicFoot(QuantityValue)" />
         public static MassConcentration PoundsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromPoundsPerCubicFoot(double.CreateChecked(value));
+            => MassConcentration.FromPoundsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromPoundsPerCubicFoot(value.ToDouble(null));
+            => MassConcentration.FromPoundsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicInch(double)" />
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicInch(QuantityValue)" />
         public static MassConcentration PoundsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromPoundsPerCubicInch(double.CreateChecked(value));
+            => MassConcentration.FromPoundsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromPoundsPerCubicInch(value.ToDouble(null));
+            => MassConcentration.FromPoundsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerImperialGallon(double)" />
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerImperialGallon(QuantityValue)" />
         public static MassConcentration PoundsPerImperialGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromPoundsPerImperialGallon(double.CreateChecked(value));
+            => MassConcentration.FromPoundsPerImperialGallon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromPoundsPerImperialGallon(value.ToDouble(null));
+            => MassConcentration.FromPoundsPerImperialGallon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerUSGallon(double)" />
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerUSGallon(QuantityValue)" />
         public static MassConcentration PoundsPerUSGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromPoundsPerUSGallon(double.CreateChecked(value));
+            => MassConcentration.FromPoundsPerUSGallon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromPoundsPerUSGallon(value.ToDouble(null));
+            => MassConcentration.FromPoundsPerUSGallon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromSlugsPerCubicFoot(double)" />
+        /// <inheritdoc cref="MassConcentration.FromSlugsPerCubicFoot(QuantityValue)" />
         public static MassConcentration SlugsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromSlugsPerCubicFoot(double.CreateChecked(value));
+            => MassConcentration.FromSlugsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromSlugsPerCubicFoot(value.ToDouble(null));
+            => MassConcentration.FromSlugsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicCentimeter(QuantityValue)" />
         public static MassConcentration TonnesPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromTonnesPerCubicCentimeter(double.CreateChecked(value));
+            => MassConcentration.FromTonnesPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromTonnesPerCubicCentimeter(value.ToDouble(null));
+            => MassConcentration.FromTonnesPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMeter(QuantityValue)" />
         public static MassConcentration TonnesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromTonnesPerCubicMeter(double.CreateChecked(value));
+            => MassConcentration.FromTonnesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromTonnesPerCubicMeter(value.ToDouble(null));
+            => MassConcentration.FromTonnesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMillimeter(double)" />
+        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMillimeter(QuantityValue)" />
         public static MassConcentration TonnesPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassConcentration.FromTonnesPerCubicMillimeter(double.CreateChecked(value));
+            => MassConcentration.FromTonnesPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassConcentration.FromTonnesPerCubicMillimeter(value.ToDouble(null));
+            => MassConcentration.FromTonnesPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
index ea9af0c243..ff9724e38d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
@@ -32,345 +32,345 @@ namespace UnitsNet.NumberExtensions.NumberToMass
     /// </summary>
     public static class NumberToMassExtensions
     {
-        /// <inheritdoc cref="Mass.FromCentigrams(double)" />
+        /// <inheritdoc cref="Mass.FromCentigrams(QuantityValue)" />
         public static Mass Centigrams<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromCentigrams(double.CreateChecked(value));
+            => Mass.FromCentigrams(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromCentigrams(value.ToDouble(null));
+            => Mass.FromCentigrams(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromDaltons(double)" />
+        /// <inheritdoc cref="Mass.FromDaltons(QuantityValue)" />
         public static Mass Daltons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromDaltons(double.CreateChecked(value));
+            => Mass.FromDaltons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromDaltons(value.ToDouble(null));
+            => Mass.FromDaltons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromDecagrams(double)" />
+        /// <inheritdoc cref="Mass.FromDecagrams(QuantityValue)" />
         public static Mass Decagrams<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromDecagrams(double.CreateChecked(value));
+            => Mass.FromDecagrams(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromDecagrams(value.ToDouble(null));
+            => Mass.FromDecagrams(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromDecigrams(double)" />
+        /// <inheritdoc cref="Mass.FromDecigrams(QuantityValue)" />
         public static Mass Decigrams<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromDecigrams(double.CreateChecked(value));
+            => Mass.FromDecigrams(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromDecigrams(value.ToDouble(null));
+            => Mass.FromDecigrams(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromEarthMasses(double)" />
+        /// <inheritdoc cref="Mass.FromEarthMasses(QuantityValue)" />
         public static Mass EarthMasses<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromEarthMasses(double.CreateChecked(value));
+            => Mass.FromEarthMasses(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromEarthMasses(value.ToDouble(null));
+            => Mass.FromEarthMasses(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromFemtograms(double)" />
+        /// <inheritdoc cref="Mass.FromFemtograms(QuantityValue)" />
         public static Mass Femtograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromFemtograms(double.CreateChecked(value));
+            => Mass.FromFemtograms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromFemtograms(value.ToDouble(null));
+            => Mass.FromFemtograms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromGigadaltons(double)" />
+        /// <inheritdoc cref="Mass.FromGigadaltons(QuantityValue)" />
         public static Mass Gigadaltons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromGigadaltons(double.CreateChecked(value));
+            => Mass.FromGigadaltons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromGigadaltons(value.ToDouble(null));
+            => Mass.FromGigadaltons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromGrains(double)" />
+        /// <inheritdoc cref="Mass.FromGrains(QuantityValue)" />
         public static Mass Grains<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromGrains(double.CreateChecked(value));
+            => Mass.FromGrains(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromGrains(value.ToDouble(null));
+            => Mass.FromGrains(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromGrams(double)" />
+        /// <inheritdoc cref="Mass.FromGrams(QuantityValue)" />
         public static Mass Grams<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromGrams(double.CreateChecked(value));
+            => Mass.FromGrams(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromGrams(value.ToDouble(null));
+            => Mass.FromGrams(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromHectograms(double)" />
+        /// <inheritdoc cref="Mass.FromHectograms(QuantityValue)" />
         public static Mass Hectograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromHectograms(double.CreateChecked(value));
+            => Mass.FromHectograms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromHectograms(value.ToDouble(null));
+            => Mass.FromHectograms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromKilodaltons(double)" />
+        /// <inheritdoc cref="Mass.FromKilodaltons(QuantityValue)" />
         public static Mass Kilodaltons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromKilodaltons(double.CreateChecked(value));
+            => Mass.FromKilodaltons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromKilodaltons(value.ToDouble(null));
+            => Mass.FromKilodaltons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromKilograms(double)" />
+        /// <inheritdoc cref="Mass.FromKilograms(QuantityValue)" />
         public static Mass Kilograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromKilograms(double.CreateChecked(value));
+            => Mass.FromKilograms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromKilograms(value.ToDouble(null));
+            => Mass.FromKilograms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromKilopounds(double)" />
+        /// <inheritdoc cref="Mass.FromKilopounds(QuantityValue)" />
         public static Mass Kilopounds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromKilopounds(double.CreateChecked(value));
+            => Mass.FromKilopounds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromKilopounds(value.ToDouble(null));
+            => Mass.FromKilopounds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromKilotonnes(double)" />
+        /// <inheritdoc cref="Mass.FromKilotonnes(QuantityValue)" />
         public static Mass Kilotonnes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromKilotonnes(double.CreateChecked(value));
+            => Mass.FromKilotonnes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromKilotonnes(value.ToDouble(null));
+            => Mass.FromKilotonnes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromLongHundredweight(double)" />
+        /// <inheritdoc cref="Mass.FromLongHundredweight(QuantityValue)" />
         public static Mass LongHundredweight<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromLongHundredweight(double.CreateChecked(value));
+            => Mass.FromLongHundredweight(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromLongHundredweight(value.ToDouble(null));
+            => Mass.FromLongHundredweight(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromLongTons(double)" />
+        /// <inheritdoc cref="Mass.FromLongTons(QuantityValue)" />
         public static Mass LongTons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromLongTons(double.CreateChecked(value));
+            => Mass.FromLongTons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromLongTons(value.ToDouble(null));
+            => Mass.FromLongTons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromMegadaltons(double)" />
+        /// <inheritdoc cref="Mass.FromMegadaltons(QuantityValue)" />
         public static Mass Megadaltons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromMegadaltons(double.CreateChecked(value));
+            => Mass.FromMegadaltons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromMegadaltons(value.ToDouble(null));
+            => Mass.FromMegadaltons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromMegapounds(double)" />
+        /// <inheritdoc cref="Mass.FromMegapounds(QuantityValue)" />
         public static Mass Megapounds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromMegapounds(double.CreateChecked(value));
+            => Mass.FromMegapounds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromMegapounds(value.ToDouble(null));
+            => Mass.FromMegapounds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromMegatonnes(double)" />
+        /// <inheritdoc cref="Mass.FromMegatonnes(QuantityValue)" />
         public static Mass Megatonnes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromMegatonnes(double.CreateChecked(value));
+            => Mass.FromMegatonnes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromMegatonnes(value.ToDouble(null));
+            => Mass.FromMegatonnes(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromMicrograms(double)" />
+        /// <inheritdoc cref="Mass.FromMicrograms(QuantityValue)" />
         public static Mass Micrograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromMicrograms(double.CreateChecked(value));
+            => Mass.FromMicrograms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromMicrograms(value.ToDouble(null));
+            => Mass.FromMicrograms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromMilligrams(double)" />
+        /// <inheritdoc cref="Mass.FromMilligrams(QuantityValue)" />
         public static Mass Milligrams<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromMilligrams(double.CreateChecked(value));
+            => Mass.FromMilligrams(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromMilligrams(value.ToDouble(null));
+            => Mass.FromMilligrams(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromNanograms(double)" />
+        /// <inheritdoc cref="Mass.FromNanograms(QuantityValue)" />
         public static Mass Nanograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromNanograms(double.CreateChecked(value));
+            => Mass.FromNanograms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromNanograms(value.ToDouble(null));
+            => Mass.FromNanograms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromOunces(double)" />
+        /// <inheritdoc cref="Mass.FromOunces(QuantityValue)" />
         public static Mass Ounces<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromOunces(double.CreateChecked(value));
+            => Mass.FromOunces(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromOunces(value.ToDouble(null));
+            => Mass.FromOunces(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromPicograms(double)" />
+        /// <inheritdoc cref="Mass.FromPicograms(QuantityValue)" />
         public static Mass Picograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromPicograms(double.CreateChecked(value));
+            => Mass.FromPicograms(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromPicograms(value.ToDouble(null));
+            => Mass.FromPicograms(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromPounds(double)" />
+        /// <inheritdoc cref="Mass.FromPounds(QuantityValue)" />
         public static Mass Pounds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromPounds(double.CreateChecked(value));
+            => Mass.FromPounds(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromPounds(value.ToDouble(null));
+            => Mass.FromPounds(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromShortHundredweight(double)" />
+        /// <inheritdoc cref="Mass.FromShortHundredweight(QuantityValue)" />
         public static Mass ShortHundredweight<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromShortHundredweight(double.CreateChecked(value));
+            => Mass.FromShortHundredweight(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromShortHundredweight(value.ToDouble(null));
+            => Mass.FromShortHundredweight(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromShortTons(double)" />
+        /// <inheritdoc cref="Mass.FromShortTons(QuantityValue)" />
         public static Mass ShortTons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromShortTons(double.CreateChecked(value));
+            => Mass.FromShortTons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromShortTons(value.ToDouble(null));
+            => Mass.FromShortTons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromSlugs(double)" />
+        /// <inheritdoc cref="Mass.FromSlugs(QuantityValue)" />
         public static Mass Slugs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromSlugs(double.CreateChecked(value));
+            => Mass.FromSlugs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromSlugs(value.ToDouble(null));
+            => Mass.FromSlugs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromSolarMasses(double)" />
+        /// <inheritdoc cref="Mass.FromSolarMasses(QuantityValue)" />
         public static Mass SolarMasses<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromSolarMasses(double.CreateChecked(value));
+            => Mass.FromSolarMasses(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromSolarMasses(value.ToDouble(null));
+            => Mass.FromSolarMasses(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromStone(double)" />
+        /// <inheritdoc cref="Mass.FromStone(QuantityValue)" />
         public static Mass Stone<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromStone(double.CreateChecked(value));
+            => Mass.FromStone(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromStone(value.ToDouble(null));
+            => Mass.FromStone(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Mass.FromTonnes(double)" />
+        /// <inheritdoc cref="Mass.FromTonnes(QuantityValue)" />
         public static Mass Tonnes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Mass.FromTonnes(double.CreateChecked(value));
+            => Mass.FromTonnes(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Mass.FromTonnes(value.ToDouble(null));
+            => Mass.FromTonnes(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
index 487d0f3e19..9b0577191b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
@@ -32,367 +32,367 @@ namespace UnitsNet.NumberExtensions.NumberToMassFlow
     /// </summary>
     public static class NumberToMassFlowExtensions
     {
-        /// <inheritdoc cref="MassFlow.FromCentigramsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromCentigramsPerDay(QuantityValue)" />
         public static MassFlow CentigramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromCentigramsPerDay(double.CreateChecked(value));
+            => MassFlow.FromCentigramsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromCentigramsPerDay(value.ToDouble(null));
+            => MassFlow.FromCentigramsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromCentigramsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromCentigramsPerSecond(QuantityValue)" />
         public static MassFlow CentigramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromCentigramsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromCentigramsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromCentigramsPerSecond(value.ToDouble(null));
+            => MassFlow.FromCentigramsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromDecagramsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromDecagramsPerDay(QuantityValue)" />
         public static MassFlow DecagramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromDecagramsPerDay(double.CreateChecked(value));
+            => MassFlow.FromDecagramsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromDecagramsPerDay(value.ToDouble(null));
+            => MassFlow.FromDecagramsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromDecagramsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromDecagramsPerSecond(QuantityValue)" />
         public static MassFlow DecagramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromDecagramsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromDecagramsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromDecagramsPerSecond(value.ToDouble(null));
+            => MassFlow.FromDecagramsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromDecigramsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromDecigramsPerDay(QuantityValue)" />
         public static MassFlow DecigramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromDecigramsPerDay(double.CreateChecked(value));
+            => MassFlow.FromDecigramsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromDecigramsPerDay(value.ToDouble(null));
+            => MassFlow.FromDecigramsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromDecigramsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromDecigramsPerSecond(QuantityValue)" />
         public static MassFlow DecigramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromDecigramsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromDecigramsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromDecigramsPerSecond(value.ToDouble(null));
+            => MassFlow.FromDecigramsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromGramsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromGramsPerDay(QuantityValue)" />
         public static MassFlow GramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromGramsPerDay(double.CreateChecked(value));
+            => MassFlow.FromGramsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromGramsPerDay(value.ToDouble(null));
+            => MassFlow.FromGramsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromGramsPerHour(double)" />
+        /// <inheritdoc cref="MassFlow.FromGramsPerHour(QuantityValue)" />
         public static MassFlow GramsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromGramsPerHour(double.CreateChecked(value));
+            => MassFlow.FromGramsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromGramsPerHour(value.ToDouble(null));
+            => MassFlow.FromGramsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromGramsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromGramsPerSecond(QuantityValue)" />
         public static MassFlow GramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromGramsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromGramsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromGramsPerSecond(value.ToDouble(null));
+            => MassFlow.FromGramsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromHectogramsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromHectogramsPerDay(QuantityValue)" />
         public static MassFlow HectogramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromHectogramsPerDay(double.CreateChecked(value));
+            => MassFlow.FromHectogramsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromHectogramsPerDay(value.ToDouble(null));
+            => MassFlow.FromHectogramsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromHectogramsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromHectogramsPerSecond(QuantityValue)" />
         public static MassFlow HectogramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromHectogramsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromHectogramsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromHectogramsPerSecond(value.ToDouble(null));
+            => MassFlow.FromHectogramsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerDay(QuantityValue)" />
         public static MassFlow KilogramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromKilogramsPerDay(double.CreateChecked(value));
+            => MassFlow.FromKilogramsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromKilogramsPerDay(value.ToDouble(null));
+            => MassFlow.FromKilogramsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerHour(double)" />
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerHour(QuantityValue)" />
         public static MassFlow KilogramsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromKilogramsPerHour(double.CreateChecked(value));
+            => MassFlow.FromKilogramsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromKilogramsPerHour(value.ToDouble(null));
+            => MassFlow.FromKilogramsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerMinute(double)" />
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerMinute(QuantityValue)" />
         public static MassFlow KilogramsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromKilogramsPerMinute(double.CreateChecked(value));
+            => MassFlow.FromKilogramsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromKilogramsPerMinute(value.ToDouble(null));
+            => MassFlow.FromKilogramsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerSecond(QuantityValue)" />
         public static MassFlow KilogramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromKilogramsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromKilogramsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromKilogramsPerSecond(value.ToDouble(null));
+            => MassFlow.FromKilogramsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromMegagramsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromMegagramsPerDay(QuantityValue)" />
         public static MassFlow MegagramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromMegagramsPerDay(double.CreateChecked(value));
+            => MassFlow.FromMegagramsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromMegagramsPerDay(value.ToDouble(null));
+            => MassFlow.FromMegagramsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerDay(QuantityValue)" />
         public static MassFlow MegapoundsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromMegapoundsPerDay(double.CreateChecked(value));
+            => MassFlow.FromMegapoundsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromMegapoundsPerDay(value.ToDouble(null));
+            => MassFlow.FromMegapoundsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerHour(double)" />
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerHour(QuantityValue)" />
         public static MassFlow MegapoundsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromMegapoundsPerHour(double.CreateChecked(value));
+            => MassFlow.FromMegapoundsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromMegapoundsPerHour(value.ToDouble(null));
+            => MassFlow.FromMegapoundsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerMinute(double)" />
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerMinute(QuantityValue)" />
         public static MassFlow MegapoundsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromMegapoundsPerMinute(double.CreateChecked(value));
+            => MassFlow.FromMegapoundsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromMegapoundsPerMinute(value.ToDouble(null));
+            => MassFlow.FromMegapoundsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerSecond(QuantityValue)" />
         public static MassFlow MegapoundsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromMegapoundsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromMegapoundsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromMegapoundsPerSecond(value.ToDouble(null));
+            => MassFlow.FromMegapoundsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromMicrogramsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromMicrogramsPerDay(QuantityValue)" />
         public static MassFlow MicrogramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromMicrogramsPerDay(double.CreateChecked(value));
+            => MassFlow.FromMicrogramsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromMicrogramsPerDay(value.ToDouble(null));
+            => MassFlow.FromMicrogramsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromMicrogramsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromMicrogramsPerSecond(QuantityValue)" />
         public static MassFlow MicrogramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromMicrogramsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromMicrogramsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromMicrogramsPerSecond(value.ToDouble(null));
+            => MassFlow.FromMicrogramsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromMilligramsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromMilligramsPerDay(QuantityValue)" />
         public static MassFlow MilligramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromMilligramsPerDay(double.CreateChecked(value));
+            => MassFlow.FromMilligramsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromMilligramsPerDay(value.ToDouble(null));
+            => MassFlow.FromMilligramsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromMilligramsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromMilligramsPerSecond(QuantityValue)" />
         public static MassFlow MilligramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromMilligramsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromMilligramsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromMilligramsPerSecond(value.ToDouble(null));
+            => MassFlow.FromMilligramsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromNanogramsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromNanogramsPerDay(QuantityValue)" />
         public static MassFlow NanogramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromNanogramsPerDay(double.CreateChecked(value));
+            => MassFlow.FromNanogramsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromNanogramsPerDay(value.ToDouble(null));
+            => MassFlow.FromNanogramsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromNanogramsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromNanogramsPerSecond(QuantityValue)" />
         public static MassFlow NanogramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromNanogramsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromNanogramsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromNanogramsPerSecond(value.ToDouble(null));
+            => MassFlow.FromNanogramsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromPoundsPerDay(QuantityValue)" />
         public static MassFlow PoundsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromPoundsPerDay(double.CreateChecked(value));
+            => MassFlow.FromPoundsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromPoundsPerDay(value.ToDouble(null));
+            => MassFlow.FromPoundsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerHour(double)" />
+        /// <inheritdoc cref="MassFlow.FromPoundsPerHour(QuantityValue)" />
         public static MassFlow PoundsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromPoundsPerHour(double.CreateChecked(value));
+            => MassFlow.FromPoundsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromPoundsPerHour(value.ToDouble(null));
+            => MassFlow.FromPoundsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerMinute(double)" />
+        /// <inheritdoc cref="MassFlow.FromPoundsPerMinute(QuantityValue)" />
         public static MassFlow PoundsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromPoundsPerMinute(double.CreateChecked(value));
+            => MassFlow.FromPoundsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromPoundsPerMinute(value.ToDouble(null));
+            => MassFlow.FromPoundsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerSecond(double)" />
+        /// <inheritdoc cref="MassFlow.FromPoundsPerSecond(QuantityValue)" />
         public static MassFlow PoundsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromPoundsPerSecond(double.CreateChecked(value));
+            => MassFlow.FromPoundsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromPoundsPerSecond(value.ToDouble(null));
+            => MassFlow.FromPoundsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromShortTonsPerHour(double)" />
+        /// <inheritdoc cref="MassFlow.FromShortTonsPerHour(QuantityValue)" />
         public static MassFlow ShortTonsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromShortTonsPerHour(double.CreateChecked(value));
+            => MassFlow.FromShortTonsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromShortTonsPerHour(value.ToDouble(null));
+            => MassFlow.FromShortTonsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromTonnesPerDay(double)" />
+        /// <inheritdoc cref="MassFlow.FromTonnesPerDay(QuantityValue)" />
         public static MassFlow TonnesPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromTonnesPerDay(double.CreateChecked(value));
+            => MassFlow.FromTonnesPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromTonnesPerDay(value.ToDouble(null));
+            => MassFlow.FromTonnesPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlow.FromTonnesPerHour(double)" />
+        /// <inheritdoc cref="MassFlow.FromTonnesPerHour(QuantityValue)" />
         public static MassFlow TonnesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlow.FromTonnesPerHour(double.CreateChecked(value));
+            => MassFlow.FromTonnesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlow.FromTonnesPerHour(value.ToDouble(null));
+            => MassFlow.FromTonnesPerHour(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
index 486934bfba..9df2392291 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
@@ -32,136 +32,136 @@ namespace UnitsNet.NumberExtensions.NumberToMassFlux
     /// </summary>
     public static class NumberToMassFluxExtensions
     {
-        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareCentimeter(QuantityValue)" />
         public static MassFlux GramsPerHourPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromGramsPerHourPerSquareCentimeter(double.CreateChecked(value));
+            => MassFlux.FromGramsPerHourPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromGramsPerHourPerSquareCentimeter(value.ToDouble(null));
+            => MassFlux.FromGramsPerHourPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMeter(QuantityValue)" />
         public static MassFlux GramsPerHourPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromGramsPerHourPerSquareMeter(double.CreateChecked(value));
+            => MassFlux.FromGramsPerHourPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromGramsPerHourPerSquareMeter(value.ToDouble(null));
+            => MassFlux.FromGramsPerHourPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMillimeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMillimeter(QuantityValue)" />
         public static MassFlux GramsPerHourPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromGramsPerHourPerSquareMillimeter(double.CreateChecked(value));
+            => MassFlux.FromGramsPerHourPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromGramsPerHourPerSquareMillimeter(value.ToDouble(null));
+            => MassFlux.FromGramsPerHourPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareCentimeter(QuantityValue)" />
         public static MassFlux GramsPerSecondPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromGramsPerSecondPerSquareCentimeter(double.CreateChecked(value));
+            => MassFlux.FromGramsPerSecondPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromGramsPerSecondPerSquareCentimeter(value.ToDouble(null));
+            => MassFlux.FromGramsPerSecondPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMeter(QuantityValue)" />
         public static MassFlux GramsPerSecondPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromGramsPerSecondPerSquareMeter(double.CreateChecked(value));
+            => MassFlux.FromGramsPerSecondPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromGramsPerSecondPerSquareMeter(value.ToDouble(null));
+            => MassFlux.FromGramsPerSecondPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMillimeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMillimeter(QuantityValue)" />
         public static MassFlux GramsPerSecondPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromGramsPerSecondPerSquareMillimeter(double.CreateChecked(value));
+            => MassFlux.FromGramsPerSecondPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromGramsPerSecondPerSquareMillimeter(value.ToDouble(null));
+            => MassFlux.FromGramsPerSecondPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareCentimeter(QuantityValue)" />
         public static MassFlux KilogramsPerHourPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromKilogramsPerHourPerSquareCentimeter(double.CreateChecked(value));
+            => MassFlux.FromKilogramsPerHourPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromKilogramsPerHourPerSquareCentimeter(value.ToDouble(null));
+            => MassFlux.FromKilogramsPerHourPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMeter(QuantityValue)" />
         public static MassFlux KilogramsPerHourPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromKilogramsPerHourPerSquareMeter(double.CreateChecked(value));
+            => MassFlux.FromKilogramsPerHourPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromKilogramsPerHourPerSquareMeter(value.ToDouble(null));
+            => MassFlux.FromKilogramsPerHourPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMillimeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMillimeter(QuantityValue)" />
         public static MassFlux KilogramsPerHourPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromKilogramsPerHourPerSquareMillimeter(double.CreateChecked(value));
+            => MassFlux.FromKilogramsPerHourPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromKilogramsPerHourPerSquareMillimeter(value.ToDouble(null));
+            => MassFlux.FromKilogramsPerHourPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareCentimeter(QuantityValue)" />
         public static MassFlux KilogramsPerSecondPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(double.CreateChecked(value));
+            => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(value.ToDouble(null));
+            => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMeter(QuantityValue)" />
         public static MassFlux KilogramsPerSecondPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromKilogramsPerSecondPerSquareMeter(double.CreateChecked(value));
+            => MassFlux.FromKilogramsPerSecondPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromKilogramsPerSecondPerSquareMeter(value.ToDouble(null));
+            => MassFlux.FromKilogramsPerSecondPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMillimeter(double)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMillimeter(QuantityValue)" />
         public static MassFlux KilogramsPerSecondPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFlux.FromKilogramsPerSecondPerSquareMillimeter(double.CreateChecked(value));
+            => MassFlux.FromKilogramsPerSecondPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFlux.FromKilogramsPerSecondPerSquareMillimeter(value.ToDouble(null));
+            => MassFlux.FromKilogramsPerSecondPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
index 29c2971233..c1cb0c6a5a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
@@ -32,268 +32,268 @@ namespace UnitsNet.NumberExtensions.NumberToMassFraction
     /// </summary>
     public static class NumberToMassFractionExtensions
     {
-        /// <inheritdoc cref="MassFraction.FromCentigramsPerGram(double)" />
+        /// <inheritdoc cref="MassFraction.FromCentigramsPerGram(QuantityValue)" />
         public static MassFraction CentigramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromCentigramsPerGram(double.CreateChecked(value));
+            => MassFraction.FromCentigramsPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromCentigramsPerGram(value.ToDouble(null));
+            => MassFraction.FromCentigramsPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromCentigramsPerKilogram(double)" />
+        /// <inheritdoc cref="MassFraction.FromCentigramsPerKilogram(QuantityValue)" />
         public static MassFraction CentigramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromCentigramsPerKilogram(double.CreateChecked(value));
+            => MassFraction.FromCentigramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromCentigramsPerKilogram(value.ToDouble(null));
+            => MassFraction.FromCentigramsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromDecagramsPerGram(double)" />
+        /// <inheritdoc cref="MassFraction.FromDecagramsPerGram(QuantityValue)" />
         public static MassFraction DecagramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromDecagramsPerGram(double.CreateChecked(value));
+            => MassFraction.FromDecagramsPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromDecagramsPerGram(value.ToDouble(null));
+            => MassFraction.FromDecagramsPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromDecagramsPerKilogram(double)" />
+        /// <inheritdoc cref="MassFraction.FromDecagramsPerKilogram(QuantityValue)" />
         public static MassFraction DecagramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromDecagramsPerKilogram(double.CreateChecked(value));
+            => MassFraction.FromDecagramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromDecagramsPerKilogram(value.ToDouble(null));
+            => MassFraction.FromDecagramsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromDecigramsPerGram(double)" />
+        /// <inheritdoc cref="MassFraction.FromDecigramsPerGram(QuantityValue)" />
         public static MassFraction DecigramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromDecigramsPerGram(double.CreateChecked(value));
+            => MassFraction.FromDecigramsPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromDecigramsPerGram(value.ToDouble(null));
+            => MassFraction.FromDecigramsPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromDecigramsPerKilogram(double)" />
+        /// <inheritdoc cref="MassFraction.FromDecigramsPerKilogram(QuantityValue)" />
         public static MassFraction DecigramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromDecigramsPerKilogram(double.CreateChecked(value));
+            => MassFraction.FromDecigramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromDecigramsPerKilogram(value.ToDouble(null));
+            => MassFraction.FromDecigramsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromDecimalFractions(double)" />
+        /// <inheritdoc cref="MassFraction.FromDecimalFractions(QuantityValue)" />
         public static MassFraction DecimalFractions<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromDecimalFractions(double.CreateChecked(value));
+            => MassFraction.FromDecimalFractions(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromDecimalFractions(value.ToDouble(null));
+            => MassFraction.FromDecimalFractions(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromGramsPerGram(double)" />
+        /// <inheritdoc cref="MassFraction.FromGramsPerGram(QuantityValue)" />
         public static MassFraction GramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromGramsPerGram(double.CreateChecked(value));
+            => MassFraction.FromGramsPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromGramsPerGram(value.ToDouble(null));
+            => MassFraction.FromGramsPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromGramsPerKilogram(double)" />
+        /// <inheritdoc cref="MassFraction.FromGramsPerKilogram(QuantityValue)" />
         public static MassFraction GramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromGramsPerKilogram(double.CreateChecked(value));
+            => MassFraction.FromGramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromGramsPerKilogram(value.ToDouble(null));
+            => MassFraction.FromGramsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromHectogramsPerGram(double)" />
+        /// <inheritdoc cref="MassFraction.FromHectogramsPerGram(QuantityValue)" />
         public static MassFraction HectogramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromHectogramsPerGram(double.CreateChecked(value));
+            => MassFraction.FromHectogramsPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromHectogramsPerGram(value.ToDouble(null));
+            => MassFraction.FromHectogramsPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromHectogramsPerKilogram(double)" />
+        /// <inheritdoc cref="MassFraction.FromHectogramsPerKilogram(QuantityValue)" />
         public static MassFraction HectogramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromHectogramsPerKilogram(double.CreateChecked(value));
+            => MassFraction.FromHectogramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromHectogramsPerKilogram(value.ToDouble(null));
+            => MassFraction.FromHectogramsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromKilogramsPerGram(double)" />
+        /// <inheritdoc cref="MassFraction.FromKilogramsPerGram(QuantityValue)" />
         public static MassFraction KilogramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromKilogramsPerGram(double.CreateChecked(value));
+            => MassFraction.FromKilogramsPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromKilogramsPerGram(value.ToDouble(null));
+            => MassFraction.FromKilogramsPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromKilogramsPerKilogram(double)" />
+        /// <inheritdoc cref="MassFraction.FromKilogramsPerKilogram(QuantityValue)" />
         public static MassFraction KilogramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromKilogramsPerKilogram(double.CreateChecked(value));
+            => MassFraction.FromKilogramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromKilogramsPerKilogram(value.ToDouble(null));
+            => MassFraction.FromKilogramsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromMicrogramsPerGram(double)" />
+        /// <inheritdoc cref="MassFraction.FromMicrogramsPerGram(QuantityValue)" />
         public static MassFraction MicrogramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromMicrogramsPerGram(double.CreateChecked(value));
+            => MassFraction.FromMicrogramsPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromMicrogramsPerGram(value.ToDouble(null));
+            => MassFraction.FromMicrogramsPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromMicrogramsPerKilogram(double)" />
+        /// <inheritdoc cref="MassFraction.FromMicrogramsPerKilogram(QuantityValue)" />
         public static MassFraction MicrogramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromMicrogramsPerKilogram(double.CreateChecked(value));
+            => MassFraction.FromMicrogramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromMicrogramsPerKilogram(value.ToDouble(null));
+            => MassFraction.FromMicrogramsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromMilligramsPerGram(double)" />
+        /// <inheritdoc cref="MassFraction.FromMilligramsPerGram(QuantityValue)" />
         public static MassFraction MilligramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromMilligramsPerGram(double.CreateChecked(value));
+            => MassFraction.FromMilligramsPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromMilligramsPerGram(value.ToDouble(null));
+            => MassFraction.FromMilligramsPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromMilligramsPerKilogram(double)" />
+        /// <inheritdoc cref="MassFraction.FromMilligramsPerKilogram(QuantityValue)" />
         public static MassFraction MilligramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromMilligramsPerKilogram(double.CreateChecked(value));
+            => MassFraction.FromMilligramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromMilligramsPerKilogram(value.ToDouble(null));
+            => MassFraction.FromMilligramsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromNanogramsPerGram(double)" />
+        /// <inheritdoc cref="MassFraction.FromNanogramsPerGram(QuantityValue)" />
         public static MassFraction NanogramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromNanogramsPerGram(double.CreateChecked(value));
+            => MassFraction.FromNanogramsPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromNanogramsPerGram(value.ToDouble(null));
+            => MassFraction.FromNanogramsPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromNanogramsPerKilogram(double)" />
+        /// <inheritdoc cref="MassFraction.FromNanogramsPerKilogram(QuantityValue)" />
         public static MassFraction NanogramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromNanogramsPerKilogram(double.CreateChecked(value));
+            => MassFraction.FromNanogramsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromNanogramsPerKilogram(value.ToDouble(null));
+            => MassFraction.FromNanogramsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerBillion(double)" />
+        /// <inheritdoc cref="MassFraction.FromPartsPerBillion(QuantityValue)" />
         public static MassFraction PartsPerBillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromPartsPerBillion(double.CreateChecked(value));
+            => MassFraction.FromPartsPerBillion(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromPartsPerBillion(value.ToDouble(null));
+            => MassFraction.FromPartsPerBillion(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerMillion(double)" />
+        /// <inheritdoc cref="MassFraction.FromPartsPerMillion(QuantityValue)" />
         public static MassFraction PartsPerMillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromPartsPerMillion(double.CreateChecked(value));
+            => MassFraction.FromPartsPerMillion(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromPartsPerMillion(value.ToDouble(null));
+            => MassFraction.FromPartsPerMillion(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerThousand(double)" />
+        /// <inheritdoc cref="MassFraction.FromPartsPerThousand(QuantityValue)" />
         public static MassFraction PartsPerThousand<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromPartsPerThousand(double.CreateChecked(value));
+            => MassFraction.FromPartsPerThousand(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromPartsPerThousand(value.ToDouble(null));
+            => MassFraction.FromPartsPerThousand(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerTrillion(double)" />
+        /// <inheritdoc cref="MassFraction.FromPartsPerTrillion(QuantityValue)" />
         public static MassFraction PartsPerTrillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromPartsPerTrillion(double.CreateChecked(value));
+            => MassFraction.FromPartsPerTrillion(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromPartsPerTrillion(value.ToDouble(null));
+            => MassFraction.FromPartsPerTrillion(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassFraction.FromPercent(double)" />
+        /// <inheritdoc cref="MassFraction.FromPercent(QuantityValue)" />
         public static MassFraction Percent<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassFraction.FromPercent(double.CreateChecked(value));
+            => MassFraction.FromPercent(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassFraction.FromPercent(value.ToDouble(null));
+            => MassFraction.FromPercent(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
index 98e24d2491..bbe9b2991d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
@@ -32,312 +32,312 @@ namespace UnitsNet.NumberExtensions.NumberToMassMomentOfInertia
     /// </summary>
     public static class NumberToMassMomentOfInertiaExtensions
     {
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareCentimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareCentimeters(QuantityValue)" />
         public static MassMomentOfInertia GramSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromGramSquareCentimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromGramSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromGramSquareCentimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromGramSquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareDecimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareDecimeters(QuantityValue)" />
         public static MassMomentOfInertia GramSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromGramSquareDecimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromGramSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromGramSquareDecimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromGramSquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMeters(QuantityValue)" />
         public static MassMomentOfInertia GramSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromGramSquareMeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromGramSquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromGramSquareMeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromGramSquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMillimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMillimeters(QuantityValue)" />
         public static MassMomentOfInertia GramSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromGramSquareMillimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromGramSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromGramSquareMillimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromGramSquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareCentimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareCentimeters(QuantityValue)" />
         public static MassMomentOfInertia KilogramSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromKilogramSquareCentimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromKilogramSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromKilogramSquareCentimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromKilogramSquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareDecimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareDecimeters(QuantityValue)" />
         public static MassMomentOfInertia KilogramSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromKilogramSquareDecimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromKilogramSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromKilogramSquareDecimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromKilogramSquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMeters(QuantityValue)" />
         public static MassMomentOfInertia KilogramSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromKilogramSquareMeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromKilogramSquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromKilogramSquareMeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromKilogramSquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMillimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMillimeters(QuantityValue)" />
         public static MassMomentOfInertia KilogramSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromKilogramSquareMillimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromKilogramSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromKilogramSquareMillimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromKilogramSquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareCentimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareCentimeters(QuantityValue)" />
         public static MassMomentOfInertia KilotonneSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromKilotonneSquareCentimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromKilotonneSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromKilotonneSquareCentimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromKilotonneSquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareDecimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareDecimeters(QuantityValue)" />
         public static MassMomentOfInertia KilotonneSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromKilotonneSquareDecimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromKilotonneSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromKilotonneSquareDecimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromKilotonneSquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMeters(QuantityValue)" />
         public static MassMomentOfInertia KilotonneSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromKilotonneSquareMeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromKilotonneSquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromKilotonneSquareMeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromKilotonneSquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMillimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMillimeters(QuantityValue)" />
         public static MassMomentOfInertia KilotonneSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromKilotonneSquareMillimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromKilotonneSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromKilotonneSquareMillimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromKilotonneSquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareCentimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareCentimeters(QuantityValue)" />
         public static MassMomentOfInertia MegatonneSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromMegatonneSquareCentimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromMegatonneSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromMegatonneSquareCentimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromMegatonneSquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareDecimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareDecimeters(QuantityValue)" />
         public static MassMomentOfInertia MegatonneSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromMegatonneSquareDecimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromMegatonneSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromMegatonneSquareDecimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromMegatonneSquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMeters(QuantityValue)" />
         public static MassMomentOfInertia MegatonneSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromMegatonneSquareMeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromMegatonneSquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromMegatonneSquareMeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromMegatonneSquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMillimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMillimeters(QuantityValue)" />
         public static MassMomentOfInertia MegatonneSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromMegatonneSquareMillimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromMegatonneSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromMegatonneSquareMillimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromMegatonneSquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareCentimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareCentimeters(QuantityValue)" />
         public static MassMomentOfInertia MilligramSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromMilligramSquareCentimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromMilligramSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromMilligramSquareCentimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromMilligramSquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareDecimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareDecimeters(QuantityValue)" />
         public static MassMomentOfInertia MilligramSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromMilligramSquareDecimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromMilligramSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromMilligramSquareDecimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromMilligramSquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMeters(QuantityValue)" />
         public static MassMomentOfInertia MilligramSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromMilligramSquareMeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromMilligramSquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromMilligramSquareMeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromMilligramSquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMillimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMillimeters(QuantityValue)" />
         public static MassMomentOfInertia MilligramSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromMilligramSquareMillimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromMilligramSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromMilligramSquareMillimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromMilligramSquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareFeet(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareFeet(QuantityValue)" />
         public static MassMomentOfInertia PoundSquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromPoundSquareFeet(double.CreateChecked(value));
+            => MassMomentOfInertia.FromPoundSquareFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromPoundSquareFeet(value.ToDouble(null));
+            => MassMomentOfInertia.FromPoundSquareFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareInches(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareInches(QuantityValue)" />
         public static MassMomentOfInertia PoundSquareInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromPoundSquareInches(double.CreateChecked(value));
+            => MassMomentOfInertia.FromPoundSquareInches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromPoundSquareInches(value.ToDouble(null));
+            => MassMomentOfInertia.FromPoundSquareInches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareFeet(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareFeet(QuantityValue)" />
         public static MassMomentOfInertia SlugSquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromSlugSquareFeet(double.CreateChecked(value));
+            => MassMomentOfInertia.FromSlugSquareFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromSlugSquareFeet(value.ToDouble(null));
+            => MassMomentOfInertia.FromSlugSquareFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareInches(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareInches(QuantityValue)" />
         public static MassMomentOfInertia SlugSquareInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromSlugSquareInches(double.CreateChecked(value));
+            => MassMomentOfInertia.FromSlugSquareInches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromSlugSquareInches(value.ToDouble(null));
+            => MassMomentOfInertia.FromSlugSquareInches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareCentimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareCentimeters(QuantityValue)" />
         public static MassMomentOfInertia TonneSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromTonneSquareCentimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromTonneSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromTonneSquareCentimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromTonneSquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareDecimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareDecimeters(QuantityValue)" />
         public static MassMomentOfInertia TonneSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromTonneSquareDecimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromTonneSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromTonneSquareDecimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromTonneSquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMeters(QuantityValue)" />
         public static MassMomentOfInertia TonneSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromTonneSquareMeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromTonneSquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromTonneSquareMeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromTonneSquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMillimeters(double)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMillimeters(QuantityValue)" />
         public static MassMomentOfInertia TonneSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MassMomentOfInertia.FromTonneSquareMillimeters(double.CreateChecked(value));
+            => MassMomentOfInertia.FromTonneSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MassMomentOfInertia.FromTonneSquareMillimeters(value.ToDouble(null));
+            => MassMomentOfInertia.FromTonneSquareMillimeters(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolalityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolalityExtensions.g.cs
index 086acee33c..949f512a9f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolalityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolalityExtensions.g.cs
@@ -32,37 +32,37 @@ namespace UnitsNet.NumberExtensions.NumberToMolality
     /// </summary>
     public static class NumberToMolalityExtensions
     {
-        /// <inheritdoc cref="Molality.FromMillimolesPerKilogram(double)" />
+        /// <inheritdoc cref="Molality.FromMillimolesPerKilogram(QuantityValue)" />
         public static Molality MillimolesPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molality.FromMillimolesPerKilogram(double.CreateChecked(value));
+            => Molality.FromMillimolesPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molality.FromMillimolesPerKilogram(value.ToDouble(null));
+            => Molality.FromMillimolesPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molality.FromMolesPerGram(double)" />
+        /// <inheritdoc cref="Molality.FromMolesPerGram(QuantityValue)" />
         public static Molality MolesPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molality.FromMolesPerGram(double.CreateChecked(value));
+            => Molality.FromMolesPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molality.FromMolesPerGram(value.ToDouble(null));
+            => Molality.FromMolesPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molality.FromMolesPerKilogram(double)" />
+        /// <inheritdoc cref="Molality.FromMolesPerKilogram(QuantityValue)" />
         public static Molality MolesPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molality.FromMolesPerKilogram(double.CreateChecked(value));
+            => Molality.FromMolesPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molality.FromMolesPerKilogram(value.ToDouble(null));
+            => Molality.FromMolesPerKilogram(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
index 293f1a4ec0..51f0d67b78 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
@@ -32,37 +32,37 @@ namespace UnitsNet.NumberExtensions.NumberToMolarEnergy
     /// </summary>
     public static class NumberToMolarEnergyExtensions
     {
-        /// <inheritdoc cref="MolarEnergy.FromJoulesPerMole(double)" />
+        /// <inheritdoc cref="MolarEnergy.FromJoulesPerMole(QuantityValue)" />
         public static MolarEnergy JoulesPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarEnergy.FromJoulesPerMole(double.CreateChecked(value));
+            => MolarEnergy.FromJoulesPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarEnergy.FromJoulesPerMole(value.ToDouble(null));
+            => MolarEnergy.FromJoulesPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarEnergy.FromKilojoulesPerMole(double)" />
+        /// <inheritdoc cref="MolarEnergy.FromKilojoulesPerMole(QuantityValue)" />
         public static MolarEnergy KilojoulesPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarEnergy.FromKilojoulesPerMole(double.CreateChecked(value));
+            => MolarEnergy.FromKilojoulesPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarEnergy.FromKilojoulesPerMole(value.ToDouble(null));
+            => MolarEnergy.FromKilojoulesPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarEnergy.FromMegajoulesPerMole(double)" />
+        /// <inheritdoc cref="MolarEnergy.FromMegajoulesPerMole(QuantityValue)" />
         public static MolarEnergy MegajoulesPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarEnergy.FromMegajoulesPerMole(double.CreateChecked(value));
+            => MolarEnergy.FromMegajoulesPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarEnergy.FromMegajoulesPerMole(value.ToDouble(null));
+            => MolarEnergy.FromMegajoulesPerMole(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
index 103a179231..ffbbe9fd6a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
@@ -32,37 +32,37 @@ namespace UnitsNet.NumberExtensions.NumberToMolarEntropy
     /// </summary>
     public static class NumberToMolarEntropyExtensions
     {
-        /// <inheritdoc cref="MolarEntropy.FromJoulesPerMoleKelvin(double)" />
+        /// <inheritdoc cref="MolarEntropy.FromJoulesPerMoleKelvin(QuantityValue)" />
         public static MolarEntropy JoulesPerMoleKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarEntropy.FromJoulesPerMoleKelvin(double.CreateChecked(value));
+            => MolarEntropy.FromJoulesPerMoleKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarEntropy.FromJoulesPerMoleKelvin(value.ToDouble(null));
+            => MolarEntropy.FromJoulesPerMoleKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarEntropy.FromKilojoulesPerMoleKelvin(double)" />
+        /// <inheritdoc cref="MolarEntropy.FromKilojoulesPerMoleKelvin(QuantityValue)" />
         public static MolarEntropy KilojoulesPerMoleKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarEntropy.FromKilojoulesPerMoleKelvin(double.CreateChecked(value));
+            => MolarEntropy.FromKilojoulesPerMoleKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarEntropy.FromKilojoulesPerMoleKelvin(value.ToDouble(null));
+            => MolarEntropy.FromKilojoulesPerMoleKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarEntropy.FromMegajoulesPerMoleKelvin(double)" />
+        /// <inheritdoc cref="MolarEntropy.FromMegajoulesPerMoleKelvin(QuantityValue)" />
         public static MolarEntropy MegajoulesPerMoleKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarEntropy.FromMegajoulesPerMoleKelvin(double.CreateChecked(value));
+            => MolarEntropy.FromMegajoulesPerMoleKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarEntropy.FromMegajoulesPerMoleKelvin(value.ToDouble(null));
+            => MolarEntropy.FromMegajoulesPerMoleKelvin(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarFlowExtensions.g.cs
index 5dbfb6e6a3..ebcf4953a2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarFlowExtensions.g.cs
@@ -32,103 +32,103 @@ namespace UnitsNet.NumberExtensions.NumberToMolarFlow
     /// </summary>
     public static class NumberToMolarFlowExtensions
     {
-        /// <inheritdoc cref="MolarFlow.FromKilomolesPerHour(double)" />
+        /// <inheritdoc cref="MolarFlow.FromKilomolesPerHour(QuantityValue)" />
         public static MolarFlow KilomolesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarFlow.FromKilomolesPerHour(double.CreateChecked(value));
+            => MolarFlow.FromKilomolesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarFlow.FromKilomolesPerHour(value.ToDouble(null));
+            => MolarFlow.FromKilomolesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarFlow.FromKilomolesPerMinute(double)" />
+        /// <inheritdoc cref="MolarFlow.FromKilomolesPerMinute(QuantityValue)" />
         public static MolarFlow KilomolesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarFlow.FromKilomolesPerMinute(double.CreateChecked(value));
+            => MolarFlow.FromKilomolesPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarFlow.FromKilomolesPerMinute(value.ToDouble(null));
+            => MolarFlow.FromKilomolesPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarFlow.FromKilomolesPerSecond(double)" />
+        /// <inheritdoc cref="MolarFlow.FromKilomolesPerSecond(QuantityValue)" />
         public static MolarFlow KilomolesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarFlow.FromKilomolesPerSecond(double.CreateChecked(value));
+            => MolarFlow.FromKilomolesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarFlow.FromKilomolesPerSecond(value.ToDouble(null));
+            => MolarFlow.FromKilomolesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarFlow.FromMolesPerHour(double)" />
+        /// <inheritdoc cref="MolarFlow.FromMolesPerHour(QuantityValue)" />
         public static MolarFlow MolesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarFlow.FromMolesPerHour(double.CreateChecked(value));
+            => MolarFlow.FromMolesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarFlow.FromMolesPerHour(value.ToDouble(null));
+            => MolarFlow.FromMolesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarFlow.FromMolesPerMinute(double)" />
+        /// <inheritdoc cref="MolarFlow.FromMolesPerMinute(QuantityValue)" />
         public static MolarFlow MolesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarFlow.FromMolesPerMinute(double.CreateChecked(value));
+            => MolarFlow.FromMolesPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarFlow.FromMolesPerMinute(value.ToDouble(null));
+            => MolarFlow.FromMolesPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarFlow.FromMolesPerSecond(double)" />
+        /// <inheritdoc cref="MolarFlow.FromMolesPerSecond(QuantityValue)" />
         public static MolarFlow MolesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarFlow.FromMolesPerSecond(double.CreateChecked(value));
+            => MolarFlow.FromMolesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarFlow.FromMolesPerSecond(value.ToDouble(null));
+            => MolarFlow.FromMolesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerHour(double)" />
+        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerHour(QuantityValue)" />
         public static MolarFlow PoundMolesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarFlow.FromPoundMolesPerHour(double.CreateChecked(value));
+            => MolarFlow.FromPoundMolesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarFlow.FromPoundMolesPerHour(value.ToDouble(null));
+            => MolarFlow.FromPoundMolesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerMinute(double)" />
+        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerMinute(QuantityValue)" />
         public static MolarFlow PoundMolesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarFlow.FromPoundMolesPerMinute(double.CreateChecked(value));
+            => MolarFlow.FromPoundMolesPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarFlow.FromPoundMolesPerMinute(value.ToDouble(null));
+            => MolarFlow.FromPoundMolesPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerSecond(double)" />
+        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerSecond(QuantityValue)" />
         public static MolarFlow PoundMolesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarFlow.FromPoundMolesPerSecond(double.CreateChecked(value));
+            => MolarFlow.FromPoundMolesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarFlow.FromPoundMolesPerSecond(value.ToDouble(null));
+            => MolarFlow.FromPoundMolesPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
index 8b8236f581..431a311b67 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
@@ -32,147 +32,158 @@ namespace UnitsNet.NumberExtensions.NumberToMolarMass
     /// </summary>
     public static class NumberToMolarMassExtensions
     {
-        /// <inheritdoc cref="MolarMass.FromCentigramsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromCentigramsPerMole(QuantityValue)" />
         public static MolarMass CentigramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromCentigramsPerMole(double.CreateChecked(value));
+            => MolarMass.FromCentigramsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromCentigramsPerMole(value.ToDouble(null));
+            => MolarMass.FromCentigramsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromDecagramsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromDecagramsPerMole(QuantityValue)" />
         public static MolarMass DecagramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromDecagramsPerMole(double.CreateChecked(value));
+            => MolarMass.FromDecagramsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromDecagramsPerMole(value.ToDouble(null));
+            => MolarMass.FromDecagramsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromDecigramsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromDecigramsPerMole(QuantityValue)" />
         public static MolarMass DecigramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromDecigramsPerMole(double.CreateChecked(value));
+            => MolarMass.FromDecigramsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromDecigramsPerMole(value.ToDouble(null));
+            => MolarMass.FromDecigramsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromGramsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromGramsPerMole(QuantityValue)" />
         public static MolarMass GramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromGramsPerMole(double.CreateChecked(value));
+            => MolarMass.FromGramsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromGramsPerMole(value.ToDouble(null));
+            => MolarMass.FromGramsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromHectogramsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromHectogramsPerMole(QuantityValue)" />
         public static MolarMass HectogramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromHectogramsPerMole(double.CreateChecked(value));
+            => MolarMass.FromHectogramsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromHectogramsPerMole(value.ToDouble(null));
+            => MolarMass.FromHectogramsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromKilogramsPerKilomole(double)" />
+        /// <inheritdoc cref="MolarMass.FromKilogramsPerKilomole(QuantityValue)" />
         public static MolarMass KilogramsPerKilomole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromKilogramsPerKilomole(double.CreateChecked(value));
+            => MolarMass.FromKilogramsPerKilomole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromKilogramsPerKilomole(value.ToDouble(null));
+            => MolarMass.FromKilogramsPerKilomole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromKilogramsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromKilogramsPerMole(QuantityValue)" />
         public static MolarMass KilogramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromKilogramsPerMole(double.CreateChecked(value));
+            => MolarMass.FromKilogramsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromKilogramsPerMole(value.ToDouble(null));
+            => MolarMass.FromKilogramsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromKilopoundsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromKilopoundsPerMole(QuantityValue)" />
         public static MolarMass KilopoundsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromKilopoundsPerMole(double.CreateChecked(value));
+            => MolarMass.FromKilopoundsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromKilopoundsPerMole(value.ToDouble(null));
+            => MolarMass.FromKilopoundsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromMegapoundsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromMegapoundsPerMole(QuantityValue)" />
         public static MolarMass MegapoundsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromMegapoundsPerMole(double.CreateChecked(value));
+            => MolarMass.FromMegapoundsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromMegapoundsPerMole(value.ToDouble(null));
+            => MolarMass.FromMegapoundsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromMicrogramsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromMicrogramsPerMole(QuantityValue)" />
         public static MolarMass MicrogramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromMicrogramsPerMole(double.CreateChecked(value));
+            => MolarMass.FromMicrogramsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromMicrogramsPerMole(value.ToDouble(null));
+            => MolarMass.FromMicrogramsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromMilligramsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromMilligramsPerMole(QuantityValue)" />
         public static MolarMass MilligramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromMilligramsPerMole(double.CreateChecked(value));
+            => MolarMass.FromMilligramsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromMilligramsPerMole(value.ToDouble(null));
+            => MolarMass.FromMilligramsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromNanogramsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromNanogramsPerMole(QuantityValue)" />
         public static MolarMass NanogramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromNanogramsPerMole(double.CreateChecked(value));
+            => MolarMass.FromNanogramsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromNanogramsPerMole(value.ToDouble(null));
+            => MolarMass.FromNanogramsPerMole(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="MolarMass.FromPoundsPerMole(double)" />
+        /// <inheritdoc cref="MolarMass.FromPoundsPerMole(QuantityValue)" />
         public static MolarMass PoundsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => MolarMass.FromPoundsPerMole(double.CreateChecked(value));
+            => MolarMass.FromPoundsPerMole(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => MolarMass.FromPoundsPerMole(value.ToDouble(null));
+            => MolarMass.FromPoundsPerMole(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="MolarMass.FromPoundsPerPoundMole(QuantityValue)" />
+        public static MolarMass PoundsPerPoundMole<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => MolarMass.FromPoundsPerPoundMole(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => MolarMass.FromPoundsPerPoundMole(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
index a9fb608bf2..a7480085fe 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
@@ -32,125 +32,125 @@ namespace UnitsNet.NumberExtensions.NumberToMolarity
     /// </summary>
     public static class NumberToMolarityExtensions
     {
-        /// <inheritdoc cref="Molarity.FromCentimolesPerLiter(double)" />
+        /// <inheritdoc cref="Molarity.FromCentimolesPerLiter(QuantityValue)" />
         public static Molarity CentimolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromCentimolesPerLiter(double.CreateChecked(value));
+            => Molarity.FromCentimolesPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromCentimolesPerLiter(value.ToDouble(null));
+            => Molarity.FromCentimolesPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molarity.FromDecimolesPerLiter(double)" />
+        /// <inheritdoc cref="Molarity.FromDecimolesPerLiter(QuantityValue)" />
         public static Molarity DecimolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromDecimolesPerLiter(double.CreateChecked(value));
+            => Molarity.FromDecimolesPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromDecimolesPerLiter(value.ToDouble(null));
+            => Molarity.FromDecimolesPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molarity.FromFemtomolesPerLiter(double)" />
+        /// <inheritdoc cref="Molarity.FromFemtomolesPerLiter(QuantityValue)" />
         public static Molarity FemtomolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromFemtomolesPerLiter(double.CreateChecked(value));
+            => Molarity.FromFemtomolesPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromFemtomolesPerLiter(value.ToDouble(null));
+            => Molarity.FromFemtomolesPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molarity.FromKilomolesPerCubicMeter(double)" />
+        /// <inheritdoc cref="Molarity.FromKilomolesPerCubicMeter(QuantityValue)" />
         public static Molarity KilomolesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromKilomolesPerCubicMeter(double.CreateChecked(value));
+            => Molarity.FromKilomolesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromKilomolesPerCubicMeter(value.ToDouble(null));
+            => Molarity.FromKilomolesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molarity.FromMicromolesPerLiter(double)" />
+        /// <inheritdoc cref="Molarity.FromMicromolesPerLiter(QuantityValue)" />
         public static Molarity MicromolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromMicromolesPerLiter(double.CreateChecked(value));
+            => Molarity.FromMicromolesPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromMicromolesPerLiter(value.ToDouble(null));
+            => Molarity.FromMicromolesPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molarity.FromMillimolesPerLiter(double)" />
+        /// <inheritdoc cref="Molarity.FromMillimolesPerLiter(QuantityValue)" />
         public static Molarity MillimolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromMillimolesPerLiter(double.CreateChecked(value));
+            => Molarity.FromMillimolesPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromMillimolesPerLiter(value.ToDouble(null));
+            => Molarity.FromMillimolesPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molarity.FromMolesPerCubicMeter(double)" />
+        /// <inheritdoc cref="Molarity.FromMolesPerCubicMeter(QuantityValue)" />
         public static Molarity MolesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromMolesPerCubicMeter(double.CreateChecked(value));
+            => Molarity.FromMolesPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromMolesPerCubicMeter(value.ToDouble(null));
+            => Molarity.FromMolesPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molarity.FromMolesPerLiter(double)" />
+        /// <inheritdoc cref="Molarity.FromMolesPerLiter(QuantityValue)" />
         public static Molarity MolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromMolesPerLiter(double.CreateChecked(value));
+            => Molarity.FromMolesPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromMolesPerLiter(value.ToDouble(null));
+            => Molarity.FromMolesPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molarity.FromNanomolesPerLiter(double)" />
+        /// <inheritdoc cref="Molarity.FromNanomolesPerLiter(QuantityValue)" />
         public static Molarity NanomolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromNanomolesPerLiter(double.CreateChecked(value));
+            => Molarity.FromNanomolesPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromNanomolesPerLiter(value.ToDouble(null));
+            => Molarity.FromNanomolesPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molarity.FromPicomolesPerLiter(double)" />
+        /// <inheritdoc cref="Molarity.FromPicomolesPerLiter(QuantityValue)" />
         public static Molarity PicomolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromPicomolesPerLiter(double.CreateChecked(value));
+            => Molarity.FromPicomolesPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromPicomolesPerLiter(value.ToDouble(null));
+            => Molarity.FromPicomolesPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Molarity.FromPoundMolesPerCubicFoot(double)" />
+        /// <inheritdoc cref="Molarity.FromPoundMolesPerCubicFoot(QuantityValue)" />
         public static Molarity PoundMolesPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Molarity.FromPoundMolesPerCubicFoot(double.CreateChecked(value));
+            => Molarity.FromPoundMolesPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Molarity.FromPoundMolesPerCubicFoot(value.ToDouble(null));
+            => Molarity.FromPoundMolesPerCubicFoot(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
index 0a4dc39592..dd7ce0fba0 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToPermeability
     /// </summary>
     public static class NumberToPermeabilityExtensions
     {
-        /// <inheritdoc cref="Permeability.FromHenriesPerMeter(double)" />
+        /// <inheritdoc cref="Permeability.FromHenriesPerMeter(QuantityValue)" />
         public static Permeability HenriesPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Permeability.FromHenriesPerMeter(double.CreateChecked(value));
+            => Permeability.FromHenriesPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Permeability.FromHenriesPerMeter(value.ToDouble(null));
+            => Permeability.FromHenriesPerMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
index 1aa3a2b179..f843bfb315 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToPermittivity
     /// </summary>
     public static class NumberToPermittivityExtensions
     {
-        /// <inheritdoc cref="Permittivity.FromFaradsPerMeter(double)" />
+        /// <inheritdoc cref="Permittivity.FromFaradsPerMeter(QuantityValue)" />
         public static Permittivity FaradsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Permittivity.FromFaradsPerMeter(double.CreateChecked(value));
+            => Permittivity.FromFaradsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Permittivity.FromFaradsPerMeter(value.ToDouble(null));
+            => Permittivity.FromFaradsPerMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs
index 1c661842ae..63b3a665f2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs
@@ -32,59 +32,59 @@ namespace UnitsNet.NumberExtensions.NumberToPorousMediumPermeability
     /// </summary>
     public static class NumberToPorousMediumPermeabilityExtensions
     {
-        /// <inheritdoc cref="PorousMediumPermeability.FromDarcys(double)" />
+        /// <inheritdoc cref="PorousMediumPermeability.FromDarcys(QuantityValue)" />
         public static PorousMediumPermeability Darcys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PorousMediumPermeability.FromDarcys(double.CreateChecked(value));
+            => PorousMediumPermeability.FromDarcys(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PorousMediumPermeability.FromDarcys(value.ToDouble(null));
+            => PorousMediumPermeability.FromDarcys(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PorousMediumPermeability.FromMicrodarcys(double)" />
+        /// <inheritdoc cref="PorousMediumPermeability.FromMicrodarcys(QuantityValue)" />
         public static PorousMediumPermeability Microdarcys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PorousMediumPermeability.FromMicrodarcys(double.CreateChecked(value));
+            => PorousMediumPermeability.FromMicrodarcys(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PorousMediumPermeability.FromMicrodarcys(value.ToDouble(null));
+            => PorousMediumPermeability.FromMicrodarcys(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PorousMediumPermeability.FromMillidarcys(double)" />
+        /// <inheritdoc cref="PorousMediumPermeability.FromMillidarcys(QuantityValue)" />
         public static PorousMediumPermeability Millidarcys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PorousMediumPermeability.FromMillidarcys(double.CreateChecked(value));
+            => PorousMediumPermeability.FromMillidarcys(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PorousMediumPermeability.FromMillidarcys(value.ToDouble(null));
+            => PorousMediumPermeability.FromMillidarcys(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PorousMediumPermeability.FromSquareCentimeters(double)" />
+        /// <inheritdoc cref="PorousMediumPermeability.FromSquareCentimeters(QuantityValue)" />
         public static PorousMediumPermeability SquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PorousMediumPermeability.FromSquareCentimeters(double.CreateChecked(value));
+            => PorousMediumPermeability.FromSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PorousMediumPermeability.FromSquareCentimeters(value.ToDouble(null));
+            => PorousMediumPermeability.FromSquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PorousMediumPermeability.FromSquareMeters(double)" />
+        /// <inheritdoc cref="PorousMediumPermeability.FromSquareMeters(QuantityValue)" />
         public static PorousMediumPermeability SquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PorousMediumPermeability.FromSquareMeters(double.CreateChecked(value));
+            => PorousMediumPermeability.FromSquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PorousMediumPermeability.FromSquareMeters(value.ToDouble(null));
+            => PorousMediumPermeability.FromSquareMeters(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
index 685f2c96e7..275a2ba0f1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
@@ -32,488 +32,510 @@ namespace UnitsNet.NumberExtensions.NumberToPowerDensity
     /// </summary>
     public static class NumberToPowerDensityExtensions
     {
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromBtusPerSecondCubicFoot(QuantityValue)" />
+        public static PowerDensity BtusPerSecondCubicFoot<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => PowerDensity.FromBtusPerSecondCubicFoot(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => PowerDensity.FromBtusPerSecondCubicFoot(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="PowerDensity.FromBtusPerSecondCubicInch(QuantityValue)" />
+        public static PowerDensity BtusPerSecondCubicInch<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => PowerDensity.FromBtusPerSecondCubicInch(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => PowerDensity.FromBtusPerSecondCubicInch(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity DecawattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromDecawattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromDecawattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromDecawattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromDecawattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicInch(QuantityValue)" />
         public static PowerDensity DecawattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromDecawattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromDecawattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromDecawattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromDecawattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity DecawattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromDecawattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromDecawattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromDecawattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromDecawattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerLiter(QuantityValue)" />
         public static PowerDensity DecawattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromDecawattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromDecawattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromDecawattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromDecawattsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity DeciwattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromDeciwattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromDeciwattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromDeciwattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromDeciwattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicInch(QuantityValue)" />
         public static PowerDensity DeciwattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromDeciwattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromDeciwattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromDeciwattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromDeciwattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity DeciwattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromDeciwattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromDeciwattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromDeciwattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromDeciwattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerLiter(QuantityValue)" />
         public static PowerDensity DeciwattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromDeciwattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromDeciwattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromDeciwattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromDeciwattsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity GigawattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromGigawattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromGigawattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromGigawattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromGigawattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicInch(QuantityValue)" />
         public static PowerDensity GigawattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromGigawattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromGigawattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromGigawattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromGigawattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity GigawattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromGigawattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromGigawattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromGigawattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromGigawattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerLiter(QuantityValue)" />
         public static PowerDensity GigawattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromGigawattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromGigawattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromGigawattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromGigawattsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity KilowattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromKilowattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromKilowattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromKilowattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromKilowattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicInch(QuantityValue)" />
         public static PowerDensity KilowattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromKilowattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromKilowattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromKilowattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromKilowattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity KilowattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromKilowattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromKilowattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromKilowattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromKilowattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerLiter(QuantityValue)" />
         public static PowerDensity KilowattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromKilowattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromKilowattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromKilowattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromKilowattsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity MegawattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMegawattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromMegawattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMegawattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromMegawattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicInch(QuantityValue)" />
         public static PowerDensity MegawattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMegawattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromMegawattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMegawattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromMegawattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity MegawattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMegawattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromMegawattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMegawattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromMegawattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerLiter(QuantityValue)" />
         public static PowerDensity MegawattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMegawattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromMegawattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMegawattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromMegawattsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity MicrowattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMicrowattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromMicrowattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMicrowattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromMicrowattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicInch(QuantityValue)" />
         public static PowerDensity MicrowattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMicrowattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromMicrowattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMicrowattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromMicrowattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity MicrowattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMicrowattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromMicrowattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMicrowattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromMicrowattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerLiter(QuantityValue)" />
         public static PowerDensity MicrowattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMicrowattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromMicrowattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMicrowattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromMicrowattsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity MilliwattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMilliwattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromMilliwattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMilliwattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromMilliwattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicInch(QuantityValue)" />
         public static PowerDensity MilliwattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMilliwattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromMilliwattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMilliwattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromMilliwattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity MilliwattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMilliwattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromMilliwattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMilliwattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromMilliwattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerLiter(QuantityValue)" />
         public static PowerDensity MilliwattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromMilliwattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromMilliwattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromMilliwattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromMilliwattsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity NanowattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromNanowattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromNanowattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromNanowattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromNanowattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicInch(QuantityValue)" />
         public static PowerDensity NanowattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromNanowattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromNanowattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromNanowattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromNanowattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity NanowattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromNanowattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromNanowattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromNanowattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromNanowattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerLiter(QuantityValue)" />
         public static PowerDensity NanowattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromNanowattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromNanowattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromNanowattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromNanowattsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity PicowattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromPicowattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromPicowattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromPicowattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromPicowattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicInch(QuantityValue)" />
         public static PowerDensity PicowattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromPicowattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromPicowattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromPicowattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromPicowattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity PicowattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromPicowattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromPicowattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromPicowattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromPicowattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerLiter(QuantityValue)" />
         public static PowerDensity PicowattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromPicowattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromPicowattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromPicowattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromPicowattsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity TerawattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromTerawattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromTerawattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromTerawattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromTerawattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicInch(QuantityValue)" />
         public static PowerDensity TerawattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromTerawattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromTerawattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromTerawattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromTerawattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity TerawattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromTerawattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromTerawattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromTerawattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromTerawattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerLiter(QuantityValue)" />
         public static PowerDensity TerawattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromTerawattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromTerawattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromTerawattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromTerawattsPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicFoot(double)" />
+        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicFoot(QuantityValue)" />
         public static PowerDensity WattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromWattsPerCubicFoot(double.CreateChecked(value));
+            => PowerDensity.FromWattsPerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromWattsPerCubicFoot(value.ToDouble(null));
+            => PowerDensity.FromWattsPerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicInch(double)" />
+        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicInch(QuantityValue)" />
         public static PowerDensity WattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromWattsPerCubicInch(double.CreateChecked(value));
+            => PowerDensity.FromWattsPerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromWattsPerCubicInch(value.ToDouble(null));
+            => PowerDensity.FromWattsPerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicMeter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicMeter(QuantityValue)" />
         public static PowerDensity WattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromWattsPerCubicMeter(double.CreateChecked(value));
+            => PowerDensity.FromWattsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromWattsPerCubicMeter(value.ToDouble(null));
+            => PowerDensity.FromWattsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerLiter(double)" />
+        /// <inheritdoc cref="PowerDensity.FromWattsPerLiter(QuantityValue)" />
         public static PowerDensity WattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerDensity.FromWattsPerLiter(double.CreateChecked(value));
+            => PowerDensity.FromWattsPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerDensity.FromWattsPerLiter(value.ToDouble(null));
+            => PowerDensity.FromWattsPerLiter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
index a3f802215b..886ab7566b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
@@ -32,301 +32,301 @@ namespace UnitsNet.NumberExtensions.NumberToPower
     /// </summary>
     public static class NumberToPowerExtensions
     {
-        /// <inheritdoc cref="Power.FromBoilerHorsepower(double)" />
+        /// <inheritdoc cref="Power.FromBoilerHorsepower(QuantityValue)" />
         public static Power BoilerHorsepower<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromBoilerHorsepower(double.CreateChecked(value));
+            => Power.FromBoilerHorsepower(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromBoilerHorsepower(value.ToDouble(null));
+            => Power.FromBoilerHorsepower(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromBritishThermalUnitsPerHour(double)" />
+        /// <inheritdoc cref="Power.FromBritishThermalUnitsPerHour(QuantityValue)" />
         public static Power BritishThermalUnitsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromBritishThermalUnitsPerHour(double.CreateChecked(value));
+            => Power.FromBritishThermalUnitsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromBritishThermalUnitsPerHour(value.ToDouble(null));
+            => Power.FromBritishThermalUnitsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromDecawatts(double)" />
+        /// <inheritdoc cref="Power.FromDecawatts(QuantityValue)" />
         public static Power Decawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromDecawatts(double.CreateChecked(value));
+            => Power.FromDecawatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromDecawatts(value.ToDouble(null));
+            => Power.FromDecawatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromDeciwatts(double)" />
+        /// <inheritdoc cref="Power.FromDeciwatts(QuantityValue)" />
         public static Power Deciwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromDeciwatts(double.CreateChecked(value));
+            => Power.FromDeciwatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromDeciwatts(value.ToDouble(null));
+            => Power.FromDeciwatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromElectricalHorsepower(double)" />
+        /// <inheritdoc cref="Power.FromElectricalHorsepower(QuantityValue)" />
         public static Power ElectricalHorsepower<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromElectricalHorsepower(double.CreateChecked(value));
+            => Power.FromElectricalHorsepower(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromElectricalHorsepower(value.ToDouble(null));
+            => Power.FromElectricalHorsepower(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromFemtowatts(double)" />
+        /// <inheritdoc cref="Power.FromFemtowatts(QuantityValue)" />
         public static Power Femtowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromFemtowatts(double.CreateChecked(value));
+            => Power.FromFemtowatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromFemtowatts(value.ToDouble(null));
+            => Power.FromFemtowatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromGigajoulesPerHour(double)" />
+        /// <inheritdoc cref="Power.FromGigajoulesPerHour(QuantityValue)" />
         public static Power GigajoulesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromGigajoulesPerHour(double.CreateChecked(value));
+            => Power.FromGigajoulesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromGigajoulesPerHour(value.ToDouble(null));
+            => Power.FromGigajoulesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromGigawatts(double)" />
+        /// <inheritdoc cref="Power.FromGigawatts(QuantityValue)" />
         public static Power Gigawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromGigawatts(double.CreateChecked(value));
+            => Power.FromGigawatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromGigawatts(value.ToDouble(null));
+            => Power.FromGigawatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromHydraulicHorsepower(double)" />
+        /// <inheritdoc cref="Power.FromHydraulicHorsepower(QuantityValue)" />
         public static Power HydraulicHorsepower<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromHydraulicHorsepower(double.CreateChecked(value));
+            => Power.FromHydraulicHorsepower(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromHydraulicHorsepower(value.ToDouble(null));
+            => Power.FromHydraulicHorsepower(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromJoulesPerHour(double)" />
+        /// <inheritdoc cref="Power.FromJoulesPerHour(QuantityValue)" />
         public static Power JoulesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromJoulesPerHour(double.CreateChecked(value));
+            => Power.FromJoulesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromJoulesPerHour(value.ToDouble(null));
+            => Power.FromJoulesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromKilobritishThermalUnitsPerHour(double)" />
+        /// <inheritdoc cref="Power.FromKilobritishThermalUnitsPerHour(QuantityValue)" />
         public static Power KilobritishThermalUnitsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromKilobritishThermalUnitsPerHour(double.CreateChecked(value));
+            => Power.FromKilobritishThermalUnitsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromKilobritishThermalUnitsPerHour(value.ToDouble(null));
+            => Power.FromKilobritishThermalUnitsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromKilojoulesPerHour(double)" />
+        /// <inheritdoc cref="Power.FromKilojoulesPerHour(QuantityValue)" />
         public static Power KilojoulesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromKilojoulesPerHour(double.CreateChecked(value));
+            => Power.FromKilojoulesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromKilojoulesPerHour(value.ToDouble(null));
+            => Power.FromKilojoulesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromKilowatts(double)" />
+        /// <inheritdoc cref="Power.FromKilowatts(QuantityValue)" />
         public static Power Kilowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromKilowatts(double.CreateChecked(value));
+            => Power.FromKilowatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromKilowatts(value.ToDouble(null));
+            => Power.FromKilowatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromMechanicalHorsepower(double)" />
+        /// <inheritdoc cref="Power.FromMechanicalHorsepower(QuantityValue)" />
         public static Power MechanicalHorsepower<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromMechanicalHorsepower(double.CreateChecked(value));
+            => Power.FromMechanicalHorsepower(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromMechanicalHorsepower(value.ToDouble(null));
+            => Power.FromMechanicalHorsepower(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromMegabritishThermalUnitsPerHour(double)" />
+        /// <inheritdoc cref="Power.FromMegabritishThermalUnitsPerHour(QuantityValue)" />
         public static Power MegabritishThermalUnitsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromMegabritishThermalUnitsPerHour(double.CreateChecked(value));
+            => Power.FromMegabritishThermalUnitsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromMegabritishThermalUnitsPerHour(value.ToDouble(null));
+            => Power.FromMegabritishThermalUnitsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromMegajoulesPerHour(double)" />
+        /// <inheritdoc cref="Power.FromMegajoulesPerHour(QuantityValue)" />
         public static Power MegajoulesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromMegajoulesPerHour(double.CreateChecked(value));
+            => Power.FromMegajoulesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromMegajoulesPerHour(value.ToDouble(null));
+            => Power.FromMegajoulesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromMegawatts(double)" />
+        /// <inheritdoc cref="Power.FromMegawatts(QuantityValue)" />
         public static Power Megawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromMegawatts(double.CreateChecked(value));
+            => Power.FromMegawatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromMegawatts(value.ToDouble(null));
+            => Power.FromMegawatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromMetricHorsepower(double)" />
+        /// <inheritdoc cref="Power.FromMetricHorsepower(QuantityValue)" />
         public static Power MetricHorsepower<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromMetricHorsepower(double.CreateChecked(value));
+            => Power.FromMetricHorsepower(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromMetricHorsepower(value.ToDouble(null));
+            => Power.FromMetricHorsepower(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromMicrowatts(double)" />
+        /// <inheritdoc cref="Power.FromMicrowatts(QuantityValue)" />
         public static Power Microwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromMicrowatts(double.CreateChecked(value));
+            => Power.FromMicrowatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromMicrowatts(value.ToDouble(null));
+            => Power.FromMicrowatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromMillijoulesPerHour(double)" />
+        /// <inheritdoc cref="Power.FromMillijoulesPerHour(QuantityValue)" />
         public static Power MillijoulesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromMillijoulesPerHour(double.CreateChecked(value));
+            => Power.FromMillijoulesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromMillijoulesPerHour(value.ToDouble(null));
+            => Power.FromMillijoulesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromMilliwatts(double)" />
+        /// <inheritdoc cref="Power.FromMilliwatts(QuantityValue)" />
         public static Power Milliwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromMilliwatts(double.CreateChecked(value));
+            => Power.FromMilliwatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromMilliwatts(value.ToDouble(null));
+            => Power.FromMilliwatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromNanowatts(double)" />
+        /// <inheritdoc cref="Power.FromNanowatts(QuantityValue)" />
         public static Power Nanowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromNanowatts(double.CreateChecked(value));
+            => Power.FromNanowatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromNanowatts(value.ToDouble(null));
+            => Power.FromNanowatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromPetawatts(double)" />
+        /// <inheritdoc cref="Power.FromPetawatts(QuantityValue)" />
         public static Power Petawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromPetawatts(double.CreateChecked(value));
+            => Power.FromPetawatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromPetawatts(value.ToDouble(null));
+            => Power.FromPetawatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromPicowatts(double)" />
+        /// <inheritdoc cref="Power.FromPicowatts(QuantityValue)" />
         public static Power Picowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromPicowatts(double.CreateChecked(value));
+            => Power.FromPicowatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromPicowatts(value.ToDouble(null));
+            => Power.FromPicowatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromTerawatts(double)" />
+        /// <inheritdoc cref="Power.FromTerawatts(QuantityValue)" />
         public static Power Terawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromTerawatts(double.CreateChecked(value));
+            => Power.FromTerawatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromTerawatts(value.ToDouble(null));
+            => Power.FromTerawatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromTonsOfRefrigeration(double)" />
+        /// <inheritdoc cref="Power.FromTonsOfRefrigeration(QuantityValue)" />
         public static Power TonsOfRefrigeration<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromTonsOfRefrigeration(double.CreateChecked(value));
+            => Power.FromTonsOfRefrigeration(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromTonsOfRefrigeration(value.ToDouble(null));
+            => Power.FromTonsOfRefrigeration(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Power.FromWatts(double)" />
+        /// <inheritdoc cref="Power.FromWatts(QuantityValue)" />
         public static Power Watts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Power.FromWatts(double.CreateChecked(value));
+            => Power.FromWatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Power.FromWatts(value.ToDouble(null));
+            => Power.FromWatts(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
index 2577f12def..6e2869e040 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
@@ -32,26 +32,26 @@ namespace UnitsNet.NumberExtensions.NumberToPowerRatio
     /// </summary>
     public static class NumberToPowerRatioExtensions
     {
-        /// <inheritdoc cref="PowerRatio.FromDecibelMilliwatts(double)" />
+        /// <inheritdoc cref="PowerRatio.FromDecibelMilliwatts(QuantityValue)" />
         public static PowerRatio DecibelMilliwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerRatio.FromDecibelMilliwatts(double.CreateChecked(value));
+            => PowerRatio.FromDecibelMilliwatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerRatio.FromDecibelMilliwatts(value.ToDouble(null));
+            => PowerRatio.FromDecibelMilliwatts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PowerRatio.FromDecibelWatts(double)" />
+        /// <inheritdoc cref="PowerRatio.FromDecibelWatts(QuantityValue)" />
         public static PowerRatio DecibelWatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PowerRatio.FromDecibelWatts(double.CreateChecked(value));
+            => PowerRatio.FromDecibelWatts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PowerRatio.FromDecibelWatts(value.ToDouble(null));
+            => PowerRatio.FromDecibelWatts(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
index 525d631589..891ed7ae78 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
@@ -32,202 +32,202 @@ namespace UnitsNet.NumberExtensions.NumberToPressureChangeRate
     /// </summary>
     public static class NumberToPressureChangeRateExtensions
     {
-        /// <inheritdoc cref="PressureChangeRate.FromAtmospheresPerSecond(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromAtmospheresPerSecond(QuantityValue)" />
         public static PressureChangeRate AtmospheresPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromAtmospheresPerSecond(double.CreateChecked(value));
+            => PressureChangeRate.FromAtmospheresPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromAtmospheresPerSecond(value.ToDouble(null));
+            => PressureChangeRate.FromAtmospheresPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromBarsPerMinute(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromBarsPerMinute(QuantityValue)" />
         public static PressureChangeRate BarsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromBarsPerMinute(double.CreateChecked(value));
+            => PressureChangeRate.FromBarsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromBarsPerMinute(value.ToDouble(null));
+            => PressureChangeRate.FromBarsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromBarsPerSecond(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromBarsPerSecond(QuantityValue)" />
         public static PressureChangeRate BarsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromBarsPerSecond(double.CreateChecked(value));
+            => PressureChangeRate.FromBarsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromBarsPerSecond(value.ToDouble(null));
+            => PressureChangeRate.FromBarsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerMinute(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerMinute(QuantityValue)" />
         public static PressureChangeRate KilopascalsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromKilopascalsPerMinute(double.CreateChecked(value));
+            => PressureChangeRate.FromKilopascalsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromKilopascalsPerMinute(value.ToDouble(null));
+            => PressureChangeRate.FromKilopascalsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerSecond(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerSecond(QuantityValue)" />
         public static PressureChangeRate KilopascalsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromKilopascalsPerSecond(double.CreateChecked(value));
+            => PressureChangeRate.FromKilopascalsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromKilopascalsPerSecond(value.ToDouble(null));
+            => PressureChangeRate.FromKilopascalsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(QuantityValue)" />
         public static PressureChangeRate KilopoundsForcePerSquareInchPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(double.CreateChecked(value));
+            => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(value.ToDouble(null));
+            => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(QuantityValue)" />
         public static PressureChangeRate KilopoundsForcePerSquareInchPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(double.CreateChecked(value));
+            => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(value.ToDouble(null));
+            => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerMinute(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerMinute(QuantityValue)" />
         public static PressureChangeRate MegapascalsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromMegapascalsPerMinute(double.CreateChecked(value));
+            => PressureChangeRate.FromMegapascalsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromMegapascalsPerMinute(value.ToDouble(null));
+            => PressureChangeRate.FromMegapascalsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerSecond(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerSecond(QuantityValue)" />
         public static PressureChangeRate MegapascalsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromMegapascalsPerSecond(double.CreateChecked(value));
+            => PressureChangeRate.FromMegapascalsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromMegapascalsPerSecond(value.ToDouble(null));
+            => PressureChangeRate.FromMegapascalsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(QuantityValue)" />
         public static PressureChangeRate MegapoundsForcePerSquareInchPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(double.CreateChecked(value));
+            => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(value.ToDouble(null));
+            => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(QuantityValue)" />
         public static PressureChangeRate MegapoundsForcePerSquareInchPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(double.CreateChecked(value));
+            => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(value.ToDouble(null));
+            => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerMinute(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerMinute(QuantityValue)" />
         public static PressureChangeRate MillibarsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromMillibarsPerMinute(double.CreateChecked(value));
+            => PressureChangeRate.FromMillibarsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromMillibarsPerMinute(value.ToDouble(null));
+            => PressureChangeRate.FromMillibarsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerSecond(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerSecond(QuantityValue)" />
         public static PressureChangeRate MillibarsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromMillibarsPerSecond(double.CreateChecked(value));
+            => PressureChangeRate.FromMillibarsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromMillibarsPerSecond(value.ToDouble(null));
+            => PressureChangeRate.FromMillibarsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromMillimetersOfMercuryPerSecond(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMillimetersOfMercuryPerSecond(QuantityValue)" />
         public static PressureChangeRate MillimetersOfMercuryPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromMillimetersOfMercuryPerSecond(double.CreateChecked(value));
+            => PressureChangeRate.FromMillimetersOfMercuryPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromMillimetersOfMercuryPerSecond(value.ToDouble(null));
+            => PressureChangeRate.FromMillimetersOfMercuryPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerMinute(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerMinute(QuantityValue)" />
         public static PressureChangeRate PascalsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromPascalsPerMinute(double.CreateChecked(value));
+            => PressureChangeRate.FromPascalsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromPascalsPerMinute(value.ToDouble(null));
+            => PressureChangeRate.FromPascalsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerSecond(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerSecond(QuantityValue)" />
         public static PressureChangeRate PascalsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromPascalsPerSecond(double.CreateChecked(value));
+            => PressureChangeRate.FromPascalsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromPascalsPerSecond(value.ToDouble(null));
+            => PressureChangeRate.FromPascalsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(QuantityValue)" />
         public static PressureChangeRate PoundsForcePerSquareInchPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(double.CreateChecked(value));
+            => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(value.ToDouble(null));
+            => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(double)" />
+        /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(QuantityValue)" />
         public static PressureChangeRate PoundsForcePerSquareInchPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(double.CreateChecked(value));
+            => PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(value.ToDouble(null));
+            => PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
index b731ef1138..72dfbde2f7 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
@@ -32,532 +32,554 @@ namespace UnitsNet.NumberExtensions.NumberToPressure
     /// </summary>
     public static class NumberToPressureExtensions
     {
-        /// <inheritdoc cref="Pressure.FromAtmospheres(double)" />
+        /// <inheritdoc cref="Pressure.FromAtmospheres(QuantityValue)" />
         public static Pressure Atmospheres<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromAtmospheres(double.CreateChecked(value));
+            => Pressure.FromAtmospheres(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromAtmospheres(value.ToDouble(null));
+            => Pressure.FromAtmospheres(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromBars(double)" />
+        /// <inheritdoc cref="Pressure.FromBars(QuantityValue)" />
         public static Pressure Bars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromBars(double.CreateChecked(value));
+            => Pressure.FromBars(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromBars(value.ToDouble(null));
+            => Pressure.FromBars(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromCentibars(double)" />
+        /// <inheritdoc cref="Pressure.FromCentibars(QuantityValue)" />
         public static Pressure Centibars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromCentibars(double.CreateChecked(value));
+            => Pressure.FromCentibars(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromCentibars(value.ToDouble(null));
+            => Pressure.FromCentibars(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromCentimetersOfWaterColumn(double)" />
+        /// <inheritdoc cref="Pressure.FromCentimetersOfWaterColumn(QuantityValue)" />
         public static Pressure CentimetersOfWaterColumn<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromCentimetersOfWaterColumn(double.CreateChecked(value));
+            => Pressure.FromCentimetersOfWaterColumn(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromCentimetersOfWaterColumn(value.ToDouble(null));
+            => Pressure.FromCentimetersOfWaterColumn(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromDecapascals(double)" />
+        /// <inheritdoc cref="Pressure.FromDecapascals(QuantityValue)" />
         public static Pressure Decapascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromDecapascals(double.CreateChecked(value));
+            => Pressure.FromDecapascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromDecapascals(value.ToDouble(null));
+            => Pressure.FromDecapascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromDecibars(double)" />
+        /// <inheritdoc cref="Pressure.FromDecibars(QuantityValue)" />
         public static Pressure Decibars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromDecibars(double.CreateChecked(value));
+            => Pressure.FromDecibars(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromDecibars(value.ToDouble(null));
+            => Pressure.FromDecibars(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromDynesPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Pressure.FromDynesPerSquareCentimeter(QuantityValue)" />
         public static Pressure DynesPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromDynesPerSquareCentimeter(double.CreateChecked(value));
+            => Pressure.FromDynesPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromDynesPerSquareCentimeter(value.ToDouble(null));
+            => Pressure.FromDynesPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromFeetOfHead(double)" />
+        /// <inheritdoc cref="Pressure.FromFeetOfHead(QuantityValue)" />
         public static Pressure FeetOfHead<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromFeetOfHead(double.CreateChecked(value));
+            => Pressure.FromFeetOfHead(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromFeetOfHead(value.ToDouble(null));
+            => Pressure.FromFeetOfHead(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromGigapascals(double)" />
+        /// <inheritdoc cref="Pressure.FromGigapascals(QuantityValue)" />
         public static Pressure Gigapascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromGigapascals(double.CreateChecked(value));
+            => Pressure.FromGigapascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromGigapascals(value.ToDouble(null));
+            => Pressure.FromGigapascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromHectopascals(double)" />
+        /// <inheritdoc cref="Pressure.FromHectopascals(QuantityValue)" />
         public static Pressure Hectopascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromHectopascals(double.CreateChecked(value));
+            => Pressure.FromHectopascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromHectopascals(value.ToDouble(null));
+            => Pressure.FromHectopascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromInchesOfMercury(double)" />
+        /// <inheritdoc cref="Pressure.FromInchesOfMercury(QuantityValue)" />
         public static Pressure InchesOfMercury<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromInchesOfMercury(double.CreateChecked(value));
+            => Pressure.FromInchesOfMercury(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromInchesOfMercury(value.ToDouble(null));
+            => Pressure.FromInchesOfMercury(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromInchesOfWaterColumn(double)" />
+        /// <inheritdoc cref="Pressure.FromInchesOfWaterColumn(QuantityValue)" />
         public static Pressure InchesOfWaterColumn<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromInchesOfWaterColumn(double.CreateChecked(value));
+            => Pressure.FromInchesOfWaterColumn(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromInchesOfWaterColumn(value.ToDouble(null));
+            => Pressure.FromInchesOfWaterColumn(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilobars(double)" />
+        /// <inheritdoc cref="Pressure.FromKilobars(QuantityValue)" />
         public static Pressure Kilobars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilobars(double.CreateChecked(value));
+            => Pressure.FromKilobars(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilobars(value.ToDouble(null));
+            => Pressure.FromKilobars(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareCentimeter(QuantityValue)" />
         public static Pressure KilogramsForcePerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilogramsForcePerSquareCentimeter(double.CreateChecked(value));
+            => Pressure.FromKilogramsForcePerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilogramsForcePerSquareCentimeter(value.ToDouble(null));
+            => Pressure.FromKilogramsForcePerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMeter(double)" />
+        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMeter(QuantityValue)" />
         public static Pressure KilogramsForcePerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilogramsForcePerSquareMeter(double.CreateChecked(value));
+            => Pressure.FromKilogramsForcePerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilogramsForcePerSquareMeter(value.ToDouble(null));
+            => Pressure.FromKilogramsForcePerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMillimeter(double)" />
+        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMillimeter(QuantityValue)" />
         public static Pressure KilogramsForcePerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilogramsForcePerSquareMillimeter(double.CreateChecked(value));
+            => Pressure.FromKilogramsForcePerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilogramsForcePerSquareMillimeter(value.ToDouble(null));
+            => Pressure.FromKilogramsForcePerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareCentimeter(QuantityValue)" />
         public static Pressure KilonewtonsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilonewtonsPerSquareCentimeter(double.CreateChecked(value));
+            => Pressure.FromKilonewtonsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilonewtonsPerSquareCentimeter(value.ToDouble(null));
+            => Pressure.FromKilonewtonsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMeter(double)" />
+        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMeter(QuantityValue)" />
         public static Pressure KilonewtonsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilonewtonsPerSquareMeter(double.CreateChecked(value));
+            => Pressure.FromKilonewtonsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilonewtonsPerSquareMeter(value.ToDouble(null));
+            => Pressure.FromKilonewtonsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMillimeter(double)" />
+        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMillimeter(QuantityValue)" />
         public static Pressure KilonewtonsPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilonewtonsPerSquareMillimeter(double.CreateChecked(value));
+            => Pressure.FromKilonewtonsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilonewtonsPerSquareMillimeter(value.ToDouble(null));
+            => Pressure.FromKilonewtonsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilopascals(double)" />
+        /// <inheritdoc cref="Pressure.FromKilopascals(QuantityValue)" />
         public static Pressure Kilopascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilopascals(double.CreateChecked(value));
+            => Pressure.FromKilopascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilopascals(value.ToDouble(null));
+            => Pressure.FromKilopascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareFoot(double)" />
+        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareFoot(QuantityValue)" />
         public static Pressure KilopoundsForcePerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilopoundsForcePerSquareFoot(double.CreateChecked(value));
+            => Pressure.FromKilopoundsForcePerSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilopoundsForcePerSquareFoot(value.ToDouble(null));
+            => Pressure.FromKilopoundsForcePerSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareInch(double)" />
+        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareInch(QuantityValue)" />
         public static Pressure KilopoundsForcePerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilopoundsForcePerSquareInch(double.CreateChecked(value));
+            => Pressure.FromKilopoundsForcePerSquareInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilopoundsForcePerSquareInch(value.ToDouble(null));
+            => Pressure.FromKilopoundsForcePerSquareInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareMil(double)" />
+        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareMil(QuantityValue)" />
         public static Pressure KilopoundsForcePerSquareMil<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromKilopoundsForcePerSquareMil(double.CreateChecked(value));
+            => Pressure.FromKilopoundsForcePerSquareMil(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromKilopoundsForcePerSquareMil(value.ToDouble(null));
+            => Pressure.FromKilopoundsForcePerSquareMil(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMegabars(double)" />
+        /// <inheritdoc cref="Pressure.FromMegabars(QuantityValue)" />
         public static Pressure Megabars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMegabars(double.CreateChecked(value));
+            => Pressure.FromMegabars(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMegabars(value.ToDouble(null));
+            => Pressure.FromMegabars(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMeganewtonsPerSquareMeter(double)" />
+        /// <inheritdoc cref="Pressure.FromMeganewtonsPerSquareMeter(QuantityValue)" />
         public static Pressure MeganewtonsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMeganewtonsPerSquareMeter(double.CreateChecked(value));
+            => Pressure.FromMeganewtonsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMeganewtonsPerSquareMeter(value.ToDouble(null));
+            => Pressure.FromMeganewtonsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMegapascals(double)" />
+        /// <inheritdoc cref="Pressure.FromMegapascals(QuantityValue)" />
         public static Pressure Megapascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMegapascals(double.CreateChecked(value));
+            => Pressure.FromMegapascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMegapascals(value.ToDouble(null));
+            => Pressure.FromMegapascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMetersOfHead(double)" />
+        /// <inheritdoc cref="Pressure.FromMetersOfHead(QuantityValue)" />
         public static Pressure MetersOfHead<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMetersOfHead(double.CreateChecked(value));
+            => Pressure.FromMetersOfHead(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMetersOfHead(value.ToDouble(null));
+            => Pressure.FromMetersOfHead(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMetersOfWaterColumn(double)" />
+        /// <inheritdoc cref="Pressure.FromMetersOfWaterColumn(QuantityValue)" />
         public static Pressure MetersOfWaterColumn<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMetersOfWaterColumn(double.CreateChecked(value));
+            => Pressure.FromMetersOfWaterColumn(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMetersOfWaterColumn(value.ToDouble(null));
+            => Pressure.FromMetersOfWaterColumn(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMicrobars(double)" />
+        /// <inheritdoc cref="Pressure.FromMicrobars(QuantityValue)" />
         public static Pressure Microbars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMicrobars(double.CreateChecked(value));
+            => Pressure.FromMicrobars(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMicrobars(value.ToDouble(null));
+            => Pressure.FromMicrobars(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMicropascals(double)" />
+        /// <inheritdoc cref="Pressure.FromMicropascals(QuantityValue)" />
         public static Pressure Micropascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMicropascals(double.CreateChecked(value));
+            => Pressure.FromMicropascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMicropascals(value.ToDouble(null));
+            => Pressure.FromMicropascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMillibars(double)" />
+        /// <inheritdoc cref="Pressure.FromMillibars(QuantityValue)" />
         public static Pressure Millibars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMillibars(double.CreateChecked(value));
+            => Pressure.FromMillibars(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMillibars(value.ToDouble(null));
+            => Pressure.FromMillibars(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMillimetersOfMercury(double)" />
+        /// <inheritdoc cref="Pressure.FromMilligramsForcePerSquareFoot(QuantityValue)" />
+        public static Pressure MilligramsForcePerSquareFoot<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => Pressure.FromMilligramsForcePerSquareFoot(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => Pressure.FromMilligramsForcePerSquareFoot(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="Pressure.FromMilligramsForcePerSquareMeter(QuantityValue)" />
+        public static Pressure MilligramsForcePerSquareMeter<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => Pressure.FromMilligramsForcePerSquareMeter(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => Pressure.FromMilligramsForcePerSquareMeter(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="Pressure.FromMillimetersOfMercury(QuantityValue)" />
         public static Pressure MillimetersOfMercury<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMillimetersOfMercury(double.CreateChecked(value));
+            => Pressure.FromMillimetersOfMercury(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMillimetersOfMercury(value.ToDouble(null));
+            => Pressure.FromMillimetersOfMercury(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMillimetersOfWaterColumn(double)" />
+        /// <inheritdoc cref="Pressure.FromMillimetersOfWaterColumn(QuantityValue)" />
         public static Pressure MillimetersOfWaterColumn<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMillimetersOfWaterColumn(double.CreateChecked(value));
+            => Pressure.FromMillimetersOfWaterColumn(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMillimetersOfWaterColumn(value.ToDouble(null));
+            => Pressure.FromMillimetersOfWaterColumn(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMillipascals(double)" />
+        /// <inheritdoc cref="Pressure.FromMillipascals(QuantityValue)" />
         public static Pressure Millipascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMillipascals(double.CreateChecked(value));
+            => Pressure.FromMillipascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMillipascals(value.ToDouble(null));
+            => Pressure.FromMillipascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromMillitorrs(double)" />
+        /// <inheritdoc cref="Pressure.FromMillitorrs(QuantityValue)" />
         public static Pressure Millitorrs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromMillitorrs(double.CreateChecked(value));
+            => Pressure.FromMillitorrs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromMillitorrs(value.ToDouble(null));
+            => Pressure.FromMillitorrs(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareCentimeter(QuantityValue)" />
         public static Pressure NewtonsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromNewtonsPerSquareCentimeter(double.CreateChecked(value));
+            => Pressure.FromNewtonsPerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromNewtonsPerSquareCentimeter(value.ToDouble(null));
+            => Pressure.FromNewtonsPerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMeter(double)" />
+        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMeter(QuantityValue)" />
         public static Pressure NewtonsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromNewtonsPerSquareMeter(double.CreateChecked(value));
+            => Pressure.FromNewtonsPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromNewtonsPerSquareMeter(value.ToDouble(null));
+            => Pressure.FromNewtonsPerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMillimeter(double)" />
+        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMillimeter(QuantityValue)" />
         public static Pressure NewtonsPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromNewtonsPerSquareMillimeter(double.CreateChecked(value));
+            => Pressure.FromNewtonsPerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromNewtonsPerSquareMillimeter(value.ToDouble(null));
+            => Pressure.FromNewtonsPerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromPascals(double)" />
+        /// <inheritdoc cref="Pressure.FromPascals(QuantityValue)" />
         public static Pressure Pascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromPascals(double.CreateChecked(value));
+            => Pressure.FromPascals(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromPascals(value.ToDouble(null));
+            => Pressure.FromPascals(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareFoot(double)" />
+        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareFoot(QuantityValue)" />
         public static Pressure PoundsForcePerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromPoundsForcePerSquareFoot(double.CreateChecked(value));
+            => Pressure.FromPoundsForcePerSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromPoundsForcePerSquareFoot(value.ToDouble(null));
+            => Pressure.FromPoundsForcePerSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareInch(double)" />
+        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareInch(QuantityValue)" />
         public static Pressure PoundsForcePerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromPoundsForcePerSquareInch(double.CreateChecked(value));
+            => Pressure.FromPoundsForcePerSquareInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromPoundsForcePerSquareInch(value.ToDouble(null));
+            => Pressure.FromPoundsForcePerSquareInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareMil(double)" />
+        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareMil(QuantityValue)" />
         public static Pressure PoundsForcePerSquareMil<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromPoundsForcePerSquareMil(double.CreateChecked(value));
+            => Pressure.FromPoundsForcePerSquareMil(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromPoundsForcePerSquareMil(value.ToDouble(null));
+            => Pressure.FromPoundsForcePerSquareMil(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromPoundsPerInchSecondSquared(double)" />
+        /// <inheritdoc cref="Pressure.FromPoundsPerInchSecondSquared(QuantityValue)" />
         public static Pressure PoundsPerInchSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromPoundsPerInchSecondSquared(double.CreateChecked(value));
+            => Pressure.FromPoundsPerInchSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromPoundsPerInchSecondSquared(value.ToDouble(null));
+            => Pressure.FromPoundsPerInchSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromTechnicalAtmospheres(double)" />
+        /// <inheritdoc cref="Pressure.FromTechnicalAtmospheres(QuantityValue)" />
         public static Pressure TechnicalAtmospheres<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromTechnicalAtmospheres(double.CreateChecked(value));
+            => Pressure.FromTechnicalAtmospheres(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromTechnicalAtmospheres(value.ToDouble(null));
+            => Pressure.FromTechnicalAtmospheres(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareCentimeter(double)" />
+        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareCentimeter(QuantityValue)" />
         public static Pressure TonnesForcePerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromTonnesForcePerSquareCentimeter(double.CreateChecked(value));
+            => Pressure.FromTonnesForcePerSquareCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromTonnesForcePerSquareCentimeter(value.ToDouble(null));
+            => Pressure.FromTonnesForcePerSquareCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMeter(double)" />
+        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMeter(QuantityValue)" />
         public static Pressure TonnesForcePerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromTonnesForcePerSquareMeter(double.CreateChecked(value));
+            => Pressure.FromTonnesForcePerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromTonnesForcePerSquareMeter(value.ToDouble(null));
+            => Pressure.FromTonnesForcePerSquareMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMillimeter(double)" />
+        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMillimeter(QuantityValue)" />
         public static Pressure TonnesForcePerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromTonnesForcePerSquareMillimeter(double.CreateChecked(value));
+            => Pressure.FromTonnesForcePerSquareMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromTonnesForcePerSquareMillimeter(value.ToDouble(null));
+            => Pressure.FromTonnesForcePerSquareMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Pressure.FromTorrs(double)" />
+        /// <inheritdoc cref="Pressure.FromTorrs(QuantityValue)" />
         public static Pressure Torrs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Pressure.FromTorrs(double.CreateChecked(value));
+            => Pressure.FromTorrs(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Pressure.FromTorrs(value.ToDouble(null));
+            => Pressure.FromTorrs(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs
index e86c930c83..1c5eb87336 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs
@@ -32,70 +32,70 @@ namespace UnitsNet.NumberExtensions.NumberToRadiationEquivalentDose
     /// </summary>
     public static class NumberToRadiationEquivalentDoseExtensions
     {
-        /// <inheritdoc cref="RadiationEquivalentDose.FromMicrosieverts(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDose.FromMicrosieverts(QuantityValue)" />
         public static RadiationEquivalentDose Microsieverts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDose.FromMicrosieverts(double.CreateChecked(value));
+            => RadiationEquivalentDose.FromMicrosieverts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDose.FromMicrosieverts(value.ToDouble(null));
+            => RadiationEquivalentDose.FromMicrosieverts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDose.FromMilliroentgensEquivalentMan(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDose.FromMilliroentgensEquivalentMan(QuantityValue)" />
         public static RadiationEquivalentDose MilliroentgensEquivalentMan<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDose.FromMilliroentgensEquivalentMan(double.CreateChecked(value));
+            => RadiationEquivalentDose.FromMilliroentgensEquivalentMan(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDose.FromMilliroentgensEquivalentMan(value.ToDouble(null));
+            => RadiationEquivalentDose.FromMilliroentgensEquivalentMan(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDose.FromMillisieverts(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDose.FromMillisieverts(QuantityValue)" />
         public static RadiationEquivalentDose Millisieverts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDose.FromMillisieverts(double.CreateChecked(value));
+            => RadiationEquivalentDose.FromMillisieverts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDose.FromMillisieverts(value.ToDouble(null));
+            => RadiationEquivalentDose.FromMillisieverts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDose.FromNanosieverts(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDose.FromNanosieverts(QuantityValue)" />
         public static RadiationEquivalentDose Nanosieverts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDose.FromNanosieverts(double.CreateChecked(value));
+            => RadiationEquivalentDose.FromNanosieverts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDose.FromNanosieverts(value.ToDouble(null));
+            => RadiationEquivalentDose.FromNanosieverts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDose.FromRoentgensEquivalentMan(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDose.FromRoentgensEquivalentMan(QuantityValue)" />
         public static RadiationEquivalentDose RoentgensEquivalentMan<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDose.FromRoentgensEquivalentMan(double.CreateChecked(value));
+            => RadiationEquivalentDose.FromRoentgensEquivalentMan(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDose.FromRoentgensEquivalentMan(value.ToDouble(null));
+            => RadiationEquivalentDose.FromRoentgensEquivalentMan(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDose.FromSieverts(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDose.FromSieverts(QuantityValue)" />
         public static RadiationEquivalentDose Sieverts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDose.FromSieverts(double.CreateChecked(value));
+            => RadiationEquivalentDose.FromSieverts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDose.FromSieverts(value.ToDouble(null));
+            => RadiationEquivalentDose.FromSieverts(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs
index c0c03ea347..1d6f43c731 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs
@@ -32,114 +32,114 @@ namespace UnitsNet.NumberExtensions.NumberToRadiationEquivalentDoseRate
     /// </summary>
     public static class NumberToRadiationEquivalentDoseRateExtensions
     {
-        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMicrosievertsPerHour(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMicrosievertsPerHour(QuantityValue)" />
         public static RadiationEquivalentDoseRate MicrosievertsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDoseRate.FromMicrosievertsPerHour(double.CreateChecked(value));
+            => RadiationEquivalentDoseRate.FromMicrosievertsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDoseRate.FromMicrosievertsPerHour(value.ToDouble(null));
+            => RadiationEquivalentDoseRate.FromMicrosievertsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(QuantityValue)" />
         public static RadiationEquivalentDoseRate MicrosievertsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(double.CreateChecked(value));
+            => RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(value.ToDouble(null));
+            => RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(QuantityValue)" />
         public static RadiationEquivalentDoseRate MilliroentgensEquivalentManPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(double.CreateChecked(value));
+            => RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(value.ToDouble(null));
+            => RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMillisievertsPerHour(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMillisievertsPerHour(QuantityValue)" />
         public static RadiationEquivalentDoseRate MillisievertsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDoseRate.FromMillisievertsPerHour(double.CreateChecked(value));
+            => RadiationEquivalentDoseRate.FromMillisievertsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDoseRate.FromMillisievertsPerHour(value.ToDouble(null));
+            => RadiationEquivalentDoseRate.FromMillisievertsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMillisievertsPerSecond(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromMillisievertsPerSecond(QuantityValue)" />
         public static RadiationEquivalentDoseRate MillisievertsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDoseRate.FromMillisievertsPerSecond(double.CreateChecked(value));
+            => RadiationEquivalentDoseRate.FromMillisievertsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDoseRate.FromMillisievertsPerSecond(value.ToDouble(null));
+            => RadiationEquivalentDoseRate.FromMillisievertsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromNanosievertsPerHour(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromNanosievertsPerHour(QuantityValue)" />
         public static RadiationEquivalentDoseRate NanosievertsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDoseRate.FromNanosievertsPerHour(double.CreateChecked(value));
+            => RadiationEquivalentDoseRate.FromNanosievertsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDoseRate.FromNanosievertsPerHour(value.ToDouble(null));
+            => RadiationEquivalentDoseRate.FromNanosievertsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromNanosievertsPerSecond(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromNanosievertsPerSecond(QuantityValue)" />
         public static RadiationEquivalentDoseRate NanosievertsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDoseRate.FromNanosievertsPerSecond(double.CreateChecked(value));
+            => RadiationEquivalentDoseRate.FromNanosievertsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDoseRate.FromNanosievertsPerSecond(value.ToDouble(null));
+            => RadiationEquivalentDoseRate.FromNanosievertsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(QuantityValue)" />
         public static RadiationEquivalentDoseRate RoentgensEquivalentManPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(double.CreateChecked(value));
+            => RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(value.ToDouble(null));
+            => RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromSievertsPerHour(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromSievertsPerHour(QuantityValue)" />
         public static RadiationEquivalentDoseRate SievertsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDoseRate.FromSievertsPerHour(double.CreateChecked(value));
+            => RadiationEquivalentDoseRate.FromSievertsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDoseRate.FromSievertsPerHour(value.ToDouble(null));
+            => RadiationEquivalentDoseRate.FromSievertsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromSievertsPerSecond(double)" />
+        /// <inheritdoc cref="RadiationEquivalentDoseRate.FromSievertsPerSecond(QuantityValue)" />
         public static RadiationEquivalentDoseRate SievertsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationEquivalentDoseRate.FromSievertsPerSecond(double.CreateChecked(value));
+            => RadiationEquivalentDoseRate.FromSievertsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationEquivalentDoseRate.FromSievertsPerSecond(value.ToDouble(null));
+            => RadiationEquivalentDoseRate.FromSievertsPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationExposureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationExposureExtensions.g.cs
index 001ea47db6..adcb0dd5ae 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationExposureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationExposureExtensions.g.cs
@@ -32,92 +32,92 @@ namespace UnitsNet.NumberExtensions.NumberToRadiationExposure
     /// </summary>
     public static class NumberToRadiationExposureExtensions
     {
-        /// <inheritdoc cref="RadiationExposure.FromCoulombsPerKilogram(double)" />
+        /// <inheritdoc cref="RadiationExposure.FromCoulombsPerKilogram(QuantityValue)" />
         public static RadiationExposure CoulombsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationExposure.FromCoulombsPerKilogram(double.CreateChecked(value));
+            => RadiationExposure.FromCoulombsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationExposure.FromCoulombsPerKilogram(value.ToDouble(null));
+            => RadiationExposure.FromCoulombsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationExposure.FromMicrocoulombsPerKilogram(double)" />
+        /// <inheritdoc cref="RadiationExposure.FromMicrocoulombsPerKilogram(QuantityValue)" />
         public static RadiationExposure MicrocoulombsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationExposure.FromMicrocoulombsPerKilogram(double.CreateChecked(value));
+            => RadiationExposure.FromMicrocoulombsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationExposure.FromMicrocoulombsPerKilogram(value.ToDouble(null));
+            => RadiationExposure.FromMicrocoulombsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationExposure.FromMicroroentgens(double)" />
+        /// <inheritdoc cref="RadiationExposure.FromMicroroentgens(QuantityValue)" />
         public static RadiationExposure Microroentgens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationExposure.FromMicroroentgens(double.CreateChecked(value));
+            => RadiationExposure.FromMicroroentgens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationExposure.FromMicroroentgens(value.ToDouble(null));
+            => RadiationExposure.FromMicroroentgens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationExposure.FromMillicoulombsPerKilogram(double)" />
+        /// <inheritdoc cref="RadiationExposure.FromMillicoulombsPerKilogram(QuantityValue)" />
         public static RadiationExposure MillicoulombsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationExposure.FromMillicoulombsPerKilogram(double.CreateChecked(value));
+            => RadiationExposure.FromMillicoulombsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationExposure.FromMillicoulombsPerKilogram(value.ToDouble(null));
+            => RadiationExposure.FromMillicoulombsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationExposure.FromMilliroentgens(double)" />
+        /// <inheritdoc cref="RadiationExposure.FromMilliroentgens(QuantityValue)" />
         public static RadiationExposure Milliroentgens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationExposure.FromMilliroentgens(double.CreateChecked(value));
+            => RadiationExposure.FromMilliroentgens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationExposure.FromMilliroentgens(value.ToDouble(null));
+            => RadiationExposure.FromMilliroentgens(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationExposure.FromNanocoulombsPerKilogram(double)" />
+        /// <inheritdoc cref="RadiationExposure.FromNanocoulombsPerKilogram(QuantityValue)" />
         public static RadiationExposure NanocoulombsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationExposure.FromNanocoulombsPerKilogram(double.CreateChecked(value));
+            => RadiationExposure.FromNanocoulombsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationExposure.FromNanocoulombsPerKilogram(value.ToDouble(null));
+            => RadiationExposure.FromNanocoulombsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationExposure.FromPicocoulombsPerKilogram(double)" />
+        /// <inheritdoc cref="RadiationExposure.FromPicocoulombsPerKilogram(QuantityValue)" />
         public static RadiationExposure PicocoulombsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationExposure.FromPicocoulombsPerKilogram(double.CreateChecked(value));
+            => RadiationExposure.FromPicocoulombsPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationExposure.FromPicocoulombsPerKilogram(value.ToDouble(null));
+            => RadiationExposure.FromPicocoulombsPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RadiationExposure.FromRoentgens(double)" />
+        /// <inheritdoc cref="RadiationExposure.FromRoentgens(QuantityValue)" />
         public static RadiationExposure Roentgens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RadiationExposure.FromRoentgens(double.CreateChecked(value));
+            => RadiationExposure.FromRoentgens(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RadiationExposure.FromRoentgens(value.ToDouble(null));
+            => RadiationExposure.FromRoentgens(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadioactivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadioactivityExtensions.g.cs
index f9c6f632ac..c4021baa64 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadioactivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadioactivityExtensions.g.cs
@@ -32,323 +32,323 @@ namespace UnitsNet.NumberExtensions.NumberToRadioactivity
     /// </summary>
     public static class NumberToRadioactivityExtensions
     {
-        /// <inheritdoc cref="Radioactivity.FromBecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromBecquerels(QuantityValue)" />
         public static Radioactivity Becquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromBecquerels(double.CreateChecked(value));
+            => Radioactivity.FromBecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromBecquerels(value.ToDouble(null));
+            => Radioactivity.FromBecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromCuries(double)" />
+        /// <inheritdoc cref="Radioactivity.FromCuries(QuantityValue)" />
         public static Radioactivity Curies<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromCuries(double.CreateChecked(value));
+            => Radioactivity.FromCuries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromCuries(value.ToDouble(null));
+            => Radioactivity.FromCuries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromExabecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromExabecquerels(QuantityValue)" />
         public static Radioactivity Exabecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromExabecquerels(double.CreateChecked(value));
+            => Radioactivity.FromExabecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromExabecquerels(value.ToDouble(null));
+            => Radioactivity.FromExabecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromGigabecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromGigabecquerels(QuantityValue)" />
         public static Radioactivity Gigabecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromGigabecquerels(double.CreateChecked(value));
+            => Radioactivity.FromGigabecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromGigabecquerels(value.ToDouble(null));
+            => Radioactivity.FromGigabecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromGigacuries(double)" />
+        /// <inheritdoc cref="Radioactivity.FromGigacuries(QuantityValue)" />
         public static Radioactivity Gigacuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromGigacuries(double.CreateChecked(value));
+            => Radioactivity.FromGigacuries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromGigacuries(value.ToDouble(null));
+            => Radioactivity.FromGigacuries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromGigarutherfords(double)" />
+        /// <inheritdoc cref="Radioactivity.FromGigarutherfords(QuantityValue)" />
         public static Radioactivity Gigarutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromGigarutherfords(double.CreateChecked(value));
+            => Radioactivity.FromGigarutherfords(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromGigarutherfords(value.ToDouble(null));
+            => Radioactivity.FromGigarutherfords(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromKilobecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromKilobecquerels(QuantityValue)" />
         public static Radioactivity Kilobecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromKilobecquerels(double.CreateChecked(value));
+            => Radioactivity.FromKilobecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromKilobecquerels(value.ToDouble(null));
+            => Radioactivity.FromKilobecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromKilocuries(double)" />
+        /// <inheritdoc cref="Radioactivity.FromKilocuries(QuantityValue)" />
         public static Radioactivity Kilocuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromKilocuries(double.CreateChecked(value));
+            => Radioactivity.FromKilocuries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromKilocuries(value.ToDouble(null));
+            => Radioactivity.FromKilocuries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromKilorutherfords(double)" />
+        /// <inheritdoc cref="Radioactivity.FromKilorutherfords(QuantityValue)" />
         public static Radioactivity Kilorutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromKilorutherfords(double.CreateChecked(value));
+            => Radioactivity.FromKilorutherfords(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromKilorutherfords(value.ToDouble(null));
+            => Radioactivity.FromKilorutherfords(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromMegabecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromMegabecquerels(QuantityValue)" />
         public static Radioactivity Megabecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromMegabecquerels(double.CreateChecked(value));
+            => Radioactivity.FromMegabecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromMegabecquerels(value.ToDouble(null));
+            => Radioactivity.FromMegabecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromMegacuries(double)" />
+        /// <inheritdoc cref="Radioactivity.FromMegacuries(QuantityValue)" />
         public static Radioactivity Megacuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromMegacuries(double.CreateChecked(value));
+            => Radioactivity.FromMegacuries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromMegacuries(value.ToDouble(null));
+            => Radioactivity.FromMegacuries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromMegarutherfords(double)" />
+        /// <inheritdoc cref="Radioactivity.FromMegarutherfords(QuantityValue)" />
         public static Radioactivity Megarutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromMegarutherfords(double.CreateChecked(value));
+            => Radioactivity.FromMegarutherfords(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromMegarutherfords(value.ToDouble(null));
+            => Radioactivity.FromMegarutherfords(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromMicrobecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromMicrobecquerels(QuantityValue)" />
         public static Radioactivity Microbecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromMicrobecquerels(double.CreateChecked(value));
+            => Radioactivity.FromMicrobecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromMicrobecquerels(value.ToDouble(null));
+            => Radioactivity.FromMicrobecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromMicrocuries(double)" />
+        /// <inheritdoc cref="Radioactivity.FromMicrocuries(QuantityValue)" />
         public static Radioactivity Microcuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromMicrocuries(double.CreateChecked(value));
+            => Radioactivity.FromMicrocuries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromMicrocuries(value.ToDouble(null));
+            => Radioactivity.FromMicrocuries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromMicrorutherfords(double)" />
+        /// <inheritdoc cref="Radioactivity.FromMicrorutherfords(QuantityValue)" />
         public static Radioactivity Microrutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromMicrorutherfords(double.CreateChecked(value));
+            => Radioactivity.FromMicrorutherfords(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromMicrorutherfords(value.ToDouble(null));
+            => Radioactivity.FromMicrorutherfords(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromMillibecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromMillibecquerels(QuantityValue)" />
         public static Radioactivity Millibecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromMillibecquerels(double.CreateChecked(value));
+            => Radioactivity.FromMillibecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromMillibecquerels(value.ToDouble(null));
+            => Radioactivity.FromMillibecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromMillicuries(double)" />
+        /// <inheritdoc cref="Radioactivity.FromMillicuries(QuantityValue)" />
         public static Radioactivity Millicuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromMillicuries(double.CreateChecked(value));
+            => Radioactivity.FromMillicuries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromMillicuries(value.ToDouble(null));
+            => Radioactivity.FromMillicuries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromMillirutherfords(double)" />
+        /// <inheritdoc cref="Radioactivity.FromMillirutherfords(QuantityValue)" />
         public static Radioactivity Millirutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromMillirutherfords(double.CreateChecked(value));
+            => Radioactivity.FromMillirutherfords(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromMillirutherfords(value.ToDouble(null));
+            => Radioactivity.FromMillirutherfords(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromNanobecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromNanobecquerels(QuantityValue)" />
         public static Radioactivity Nanobecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromNanobecquerels(double.CreateChecked(value));
+            => Radioactivity.FromNanobecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromNanobecquerels(value.ToDouble(null));
+            => Radioactivity.FromNanobecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromNanocuries(double)" />
+        /// <inheritdoc cref="Radioactivity.FromNanocuries(QuantityValue)" />
         public static Radioactivity Nanocuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromNanocuries(double.CreateChecked(value));
+            => Radioactivity.FromNanocuries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromNanocuries(value.ToDouble(null));
+            => Radioactivity.FromNanocuries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromNanorutherfords(double)" />
+        /// <inheritdoc cref="Radioactivity.FromNanorutherfords(QuantityValue)" />
         public static Radioactivity Nanorutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromNanorutherfords(double.CreateChecked(value));
+            => Radioactivity.FromNanorutherfords(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromNanorutherfords(value.ToDouble(null));
+            => Radioactivity.FromNanorutherfords(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromPetabecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromPetabecquerels(QuantityValue)" />
         public static Radioactivity Petabecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromPetabecquerels(double.CreateChecked(value));
+            => Radioactivity.FromPetabecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromPetabecquerels(value.ToDouble(null));
+            => Radioactivity.FromPetabecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromPicobecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromPicobecquerels(QuantityValue)" />
         public static Radioactivity Picobecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromPicobecquerels(double.CreateChecked(value));
+            => Radioactivity.FromPicobecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromPicobecquerels(value.ToDouble(null));
+            => Radioactivity.FromPicobecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromPicocuries(double)" />
+        /// <inheritdoc cref="Radioactivity.FromPicocuries(QuantityValue)" />
         public static Radioactivity Picocuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromPicocuries(double.CreateChecked(value));
+            => Radioactivity.FromPicocuries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromPicocuries(value.ToDouble(null));
+            => Radioactivity.FromPicocuries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromPicorutherfords(double)" />
+        /// <inheritdoc cref="Radioactivity.FromPicorutherfords(QuantityValue)" />
         public static Radioactivity Picorutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromPicorutherfords(double.CreateChecked(value));
+            => Radioactivity.FromPicorutherfords(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromPicorutherfords(value.ToDouble(null));
+            => Radioactivity.FromPicorutherfords(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromRutherfords(double)" />
+        /// <inheritdoc cref="Radioactivity.FromRutherfords(QuantityValue)" />
         public static Radioactivity Rutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromRutherfords(double.CreateChecked(value));
+            => Radioactivity.FromRutherfords(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromRutherfords(value.ToDouble(null));
+            => Radioactivity.FromRutherfords(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromTerabecquerels(double)" />
+        /// <inheritdoc cref="Radioactivity.FromTerabecquerels(QuantityValue)" />
         public static Radioactivity Terabecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromTerabecquerels(double.CreateChecked(value));
+            => Radioactivity.FromTerabecquerels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromTerabecquerels(value.ToDouble(null));
+            => Radioactivity.FromTerabecquerels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromTeracuries(double)" />
+        /// <inheritdoc cref="Radioactivity.FromTeracuries(QuantityValue)" />
         public static Radioactivity Teracuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromTeracuries(double.CreateChecked(value));
+            => Radioactivity.FromTeracuries(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromTeracuries(value.ToDouble(null));
+            => Radioactivity.FromTeracuries(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Radioactivity.FromTerarutherfords(double)" />
+        /// <inheritdoc cref="Radioactivity.FromTerarutherfords(QuantityValue)" />
         public static Radioactivity Terarutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Radioactivity.FromTerarutherfords(double.CreateChecked(value));
+            => Radioactivity.FromTerarutherfords(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Radioactivity.FromTerarutherfords(value.ToDouble(null));
+            => Radioactivity.FromTerarutherfords(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
index 535a410298..d1ffec7a31 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
@@ -32,26 +32,26 @@ namespace UnitsNet.NumberExtensions.NumberToRatioChangeRate
     /// </summary>
     public static class NumberToRatioChangeRateExtensions
     {
-        /// <inheritdoc cref="RatioChangeRate.FromDecimalFractionsPerSecond(double)" />
+        /// <inheritdoc cref="RatioChangeRate.FromDecimalFractionsPerSecond(QuantityValue)" />
         public static RatioChangeRate DecimalFractionsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RatioChangeRate.FromDecimalFractionsPerSecond(double.CreateChecked(value));
+            => RatioChangeRate.FromDecimalFractionsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RatioChangeRate.FromDecimalFractionsPerSecond(value.ToDouble(null));
+            => RatioChangeRate.FromDecimalFractionsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RatioChangeRate.FromPercentsPerSecond(double)" />
+        /// <inheritdoc cref="RatioChangeRate.FromPercentsPerSecond(QuantityValue)" />
         public static RatioChangeRate PercentsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RatioChangeRate.FromPercentsPerSecond(double.CreateChecked(value));
+            => RatioChangeRate.FromPercentsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RatioChangeRate.FromPercentsPerSecond(value.ToDouble(null));
+            => RatioChangeRate.FromPercentsPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
index ce070b42a0..197232eea4 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
@@ -32,70 +32,70 @@ namespace UnitsNet.NumberExtensions.NumberToRatio
     /// </summary>
     public static class NumberToRatioExtensions
     {
-        /// <inheritdoc cref="Ratio.FromDecimalFractions(double)" />
+        /// <inheritdoc cref="Ratio.FromDecimalFractions(QuantityValue)" />
         public static Ratio DecimalFractions<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Ratio.FromDecimalFractions(double.CreateChecked(value));
+            => Ratio.FromDecimalFractions(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Ratio.FromDecimalFractions(value.ToDouble(null));
+            => Ratio.FromDecimalFractions(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Ratio.FromPartsPerBillion(double)" />
+        /// <inheritdoc cref="Ratio.FromPartsPerBillion(QuantityValue)" />
         public static Ratio PartsPerBillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Ratio.FromPartsPerBillion(double.CreateChecked(value));
+            => Ratio.FromPartsPerBillion(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Ratio.FromPartsPerBillion(value.ToDouble(null));
+            => Ratio.FromPartsPerBillion(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Ratio.FromPartsPerMillion(double)" />
+        /// <inheritdoc cref="Ratio.FromPartsPerMillion(QuantityValue)" />
         public static Ratio PartsPerMillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Ratio.FromPartsPerMillion(double.CreateChecked(value));
+            => Ratio.FromPartsPerMillion(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Ratio.FromPartsPerMillion(value.ToDouble(null));
+            => Ratio.FromPartsPerMillion(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Ratio.FromPartsPerThousand(double)" />
+        /// <inheritdoc cref="Ratio.FromPartsPerThousand(QuantityValue)" />
         public static Ratio PartsPerThousand<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Ratio.FromPartsPerThousand(double.CreateChecked(value));
+            => Ratio.FromPartsPerThousand(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Ratio.FromPartsPerThousand(value.ToDouble(null));
+            => Ratio.FromPartsPerThousand(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Ratio.FromPartsPerTrillion(double)" />
+        /// <inheritdoc cref="Ratio.FromPartsPerTrillion(QuantityValue)" />
         public static Ratio PartsPerTrillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Ratio.FromPartsPerTrillion(double.CreateChecked(value));
+            => Ratio.FromPartsPerTrillion(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Ratio.FromPartsPerTrillion(value.ToDouble(null));
+            => Ratio.FromPartsPerTrillion(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Ratio.FromPercent(double)" />
+        /// <inheritdoc cref="Ratio.FromPercent(QuantityValue)" />
         public static Ratio Percent<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Ratio.FromPercent(double.CreateChecked(value));
+            => Ratio.FromPercent(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Ratio.FromPercent(value.ToDouble(null));
+            => Ratio.FromPercent(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs
index 9ab826de36..6316ad09c8 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs
@@ -32,125 +32,125 @@ namespace UnitsNet.NumberExtensions.NumberToReciprocalArea
     /// </summary>
     public static class NumberToReciprocalAreaExtensions
     {
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareCentimeters(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareCentimeters(QuantityValue)" />
         public static ReciprocalArea InverseSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseSquareCentimeters(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseSquareCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseSquareCentimeters(value.ToDouble(null));
+            => ReciprocalArea.FromInverseSquareCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareDecimeters(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareDecimeters(QuantityValue)" />
         public static ReciprocalArea InverseSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseSquareDecimeters(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseSquareDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseSquareDecimeters(value.ToDouble(null));
+            => ReciprocalArea.FromInverseSquareDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareFeet(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareFeet(QuantityValue)" />
         public static ReciprocalArea InverseSquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseSquareFeet(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseSquareFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseSquareFeet(value.ToDouble(null));
+            => ReciprocalArea.FromInverseSquareFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareInches(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareInches(QuantityValue)" />
         public static ReciprocalArea InverseSquareInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseSquareInches(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseSquareInches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseSquareInches(value.ToDouble(null));
+            => ReciprocalArea.FromInverseSquareInches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareKilometers(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareKilometers(QuantityValue)" />
         public static ReciprocalArea InverseSquareKilometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseSquareKilometers(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseSquareKilometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseSquareKilometers(value.ToDouble(null));
+            => ReciprocalArea.FromInverseSquareKilometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMeters(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMeters(QuantityValue)" />
         public static ReciprocalArea InverseSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseSquareMeters(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseSquareMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseSquareMeters(value.ToDouble(null));
+            => ReciprocalArea.FromInverseSquareMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMicrometers(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMicrometers(QuantityValue)" />
         public static ReciprocalArea InverseSquareMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseSquareMicrometers(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseSquareMicrometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseSquareMicrometers(value.ToDouble(null));
+            => ReciprocalArea.FromInverseSquareMicrometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMiles(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMiles(QuantityValue)" />
         public static ReciprocalArea InverseSquareMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseSquareMiles(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseSquareMiles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseSquareMiles(value.ToDouble(null));
+            => ReciprocalArea.FromInverseSquareMiles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMillimeters(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMillimeters(QuantityValue)" />
         public static ReciprocalArea InverseSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseSquareMillimeters(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseSquareMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseSquareMillimeters(value.ToDouble(null));
+            => ReciprocalArea.FromInverseSquareMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareYards(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareYards(QuantityValue)" />
         public static ReciprocalArea InverseSquareYards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseSquareYards(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseSquareYards(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseSquareYards(value.ToDouble(null));
+            => ReciprocalArea.FromInverseSquareYards(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseUsSurveySquareFeet(double)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseUsSurveySquareFeet(QuantityValue)" />
         public static ReciprocalArea InverseUsSurveySquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalArea.FromInverseUsSurveySquareFeet(double.CreateChecked(value));
+            => ReciprocalArea.FromInverseUsSurveySquareFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalArea.FromInverseUsSurveySquareFeet(value.ToDouble(null));
+            => ReciprocalArea.FromInverseUsSurveySquareFeet(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs
index 2023c853fa..8d47f7f26d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs
@@ -32,114 +32,114 @@ namespace UnitsNet.NumberExtensions.NumberToReciprocalLength
     /// </summary>
     public static class NumberToReciprocalLengthExtensions
     {
-        /// <inheritdoc cref="ReciprocalLength.FromInverseCentimeters(double)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseCentimeters(QuantityValue)" />
         public static ReciprocalLength InverseCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalLength.FromInverseCentimeters(double.CreateChecked(value));
+            => ReciprocalLength.FromInverseCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalLength.FromInverseCentimeters(value.ToDouble(null));
+            => ReciprocalLength.FromInverseCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseFeet(double)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseFeet(QuantityValue)" />
         public static ReciprocalLength InverseFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalLength.FromInverseFeet(double.CreateChecked(value));
+            => ReciprocalLength.FromInverseFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalLength.FromInverseFeet(value.ToDouble(null));
+            => ReciprocalLength.FromInverseFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseInches(double)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseInches(QuantityValue)" />
         public static ReciprocalLength InverseInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalLength.FromInverseInches(double.CreateChecked(value));
+            => ReciprocalLength.FromInverseInches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalLength.FromInverseInches(value.ToDouble(null));
+            => ReciprocalLength.FromInverseInches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseMeters(double)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseMeters(QuantityValue)" />
         public static ReciprocalLength InverseMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalLength.FromInverseMeters(double.CreateChecked(value));
+            => ReciprocalLength.FromInverseMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalLength.FromInverseMeters(value.ToDouble(null));
+            => ReciprocalLength.FromInverseMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseMicroinches(double)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseMicroinches(QuantityValue)" />
         public static ReciprocalLength InverseMicroinches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalLength.FromInverseMicroinches(double.CreateChecked(value));
+            => ReciprocalLength.FromInverseMicroinches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalLength.FromInverseMicroinches(value.ToDouble(null));
+            => ReciprocalLength.FromInverseMicroinches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseMils(double)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseMils(QuantityValue)" />
         public static ReciprocalLength InverseMils<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalLength.FromInverseMils(double.CreateChecked(value));
+            => ReciprocalLength.FromInverseMils(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalLength.FromInverseMils(value.ToDouble(null));
+            => ReciprocalLength.FromInverseMils(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseMiles(double)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseMiles(QuantityValue)" />
         public static ReciprocalLength InverseMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalLength.FromInverseMiles(double.CreateChecked(value));
+            => ReciprocalLength.FromInverseMiles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalLength.FromInverseMiles(value.ToDouble(null));
+            => ReciprocalLength.FromInverseMiles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseMillimeters(double)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseMillimeters(QuantityValue)" />
         public static ReciprocalLength InverseMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalLength.FromInverseMillimeters(double.CreateChecked(value));
+            => ReciprocalLength.FromInverseMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalLength.FromInverseMillimeters(value.ToDouble(null));
+            => ReciprocalLength.FromInverseMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseUsSurveyFeet(double)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseUsSurveyFeet(QuantityValue)" />
         public static ReciprocalLength InverseUsSurveyFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalLength.FromInverseUsSurveyFeet(double.CreateChecked(value));
+            => ReciprocalLength.FromInverseUsSurveyFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalLength.FromInverseUsSurveyFeet(value.ToDouble(null));
+            => ReciprocalLength.FromInverseUsSurveyFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseYards(double)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseYards(QuantityValue)" />
         public static ReciprocalLength InverseYards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ReciprocalLength.FromInverseYards(double.CreateChecked(value));
+            => ReciprocalLength.FromInverseYards(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ReciprocalLength.FromInverseYards(value.ToDouble(null));
+            => ReciprocalLength.FromInverseYards(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
index c512c9d2eb..8db70b9d33 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToRelativeHumidity
     /// </summary>
     public static class NumberToRelativeHumidityExtensions
     {
-        /// <inheritdoc cref="RelativeHumidity.FromPercent(double)" />
+        /// <inheritdoc cref="RelativeHumidity.FromPercent(QuantityValue)" />
         public static RelativeHumidity Percent<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RelativeHumidity.FromPercent(double.CreateChecked(value));
+            => RelativeHumidity.FromPercent(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RelativeHumidity.FromPercent(value.ToDouble(null));
+            => RelativeHumidity.FromPercent(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
index d20ff97a15..da7d9664bd 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
@@ -32,48 +32,48 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalAcceleration
     /// </summary>
     public static class NumberToRotationalAccelerationExtensions
     {
-        /// <inheritdoc cref="RotationalAcceleration.FromDegreesPerSecondSquared(double)" />
+        /// <inheritdoc cref="RotationalAcceleration.FromDegreesPerSecondSquared(QuantityValue)" />
         public static RotationalAcceleration DegreesPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalAcceleration.FromDegreesPerSecondSquared(double.CreateChecked(value));
+            => RotationalAcceleration.FromDegreesPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalAcceleration.FromDegreesPerSecondSquared(value.ToDouble(null));
+            => RotationalAcceleration.FromDegreesPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalAcceleration.FromRadiansPerSecondSquared(double)" />
+        /// <inheritdoc cref="RotationalAcceleration.FromRadiansPerSecondSquared(QuantityValue)" />
         public static RotationalAcceleration RadiansPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalAcceleration.FromRadiansPerSecondSquared(double.CreateChecked(value));
+            => RotationalAcceleration.FromRadiansPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalAcceleration.FromRadiansPerSecondSquared(value.ToDouble(null));
+            => RotationalAcceleration.FromRadiansPerSecondSquared(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerMinutePerSecond(double)" />
+        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerMinutePerSecond(QuantityValue)" />
         public static RotationalAcceleration RevolutionsPerMinutePerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(double.CreateChecked(value));
+            => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(value.ToDouble(null));
+            => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerSecondSquared(double)" />
+        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerSecondSquared(QuantityValue)" />
         public static RotationalAcceleration RevolutionsPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalAcceleration.FromRevolutionsPerSecondSquared(double.CreateChecked(value));
+            => RotationalAcceleration.FromRevolutionsPerSecondSquared(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalAcceleration.FromRevolutionsPerSecondSquared(value.ToDouble(null));
+            => RotationalAcceleration.FromRevolutionsPerSecondSquared(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
index e49a4938a1..81ff773006 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
@@ -32,147 +32,147 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalSpeed
     /// </summary>
     public static class NumberToRotationalSpeedExtensions
     {
-        /// <inheritdoc cref="RotationalSpeed.FromCentiradiansPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromCentiradiansPerSecond(QuantityValue)" />
         public static RotationalSpeed CentiradiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromCentiradiansPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromCentiradiansPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromCentiradiansPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromCentiradiansPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromDeciradiansPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromDeciradiansPerSecond(QuantityValue)" />
         public static RotationalSpeed DeciradiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromDeciradiansPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromDeciradiansPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromDeciradiansPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromDeciradiansPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerMinute(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerMinute(QuantityValue)" />
         public static RotationalSpeed DegreesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromDegreesPerMinute(double.CreateChecked(value));
+            => RotationalSpeed.FromDegreesPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromDegreesPerMinute(value.ToDouble(null));
+            => RotationalSpeed.FromDegreesPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerSecond(QuantityValue)" />
         public static RotationalSpeed DegreesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromDegreesPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromDegreesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromDegreesPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromDegreesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromMicrodegreesPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromMicrodegreesPerSecond(QuantityValue)" />
         public static RotationalSpeed MicrodegreesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromMicrodegreesPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromMicrodegreesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromMicrodegreesPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromMicrodegreesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromMicroradiansPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromMicroradiansPerSecond(QuantityValue)" />
         public static RotationalSpeed MicroradiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromMicroradiansPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromMicroradiansPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromMicroradiansPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromMicroradiansPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromMillidegreesPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromMillidegreesPerSecond(QuantityValue)" />
         public static RotationalSpeed MillidegreesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromMillidegreesPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromMillidegreesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromMillidegreesPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromMillidegreesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromMilliradiansPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromMilliradiansPerSecond(QuantityValue)" />
         public static RotationalSpeed MilliradiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromMilliradiansPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromMilliradiansPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromMilliradiansPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromMilliradiansPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromNanodegreesPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromNanodegreesPerSecond(QuantityValue)" />
         public static RotationalSpeed NanodegreesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromNanodegreesPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromNanodegreesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromNanodegreesPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromNanodegreesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromNanoradiansPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromNanoradiansPerSecond(QuantityValue)" />
         public static RotationalSpeed NanoradiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromNanoradiansPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromNanoradiansPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromNanoradiansPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromNanoradiansPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromRadiansPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromRadiansPerSecond(QuantityValue)" />
         public static RotationalSpeed RadiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromRadiansPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromRadiansPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromRadiansPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromRadiansPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(QuantityValue)" />
         public static RotationalSpeed RevolutionsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromRevolutionsPerMinute(double.CreateChecked(value));
+            => RotationalSpeed.FromRevolutionsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromRevolutionsPerMinute(value.ToDouble(null));
+            => RotationalSpeed.FromRevolutionsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerSecond(double)" />
+        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerSecond(QuantityValue)" />
         public static RotationalSpeed RevolutionsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalSpeed.FromRevolutionsPerSecond(double.CreateChecked(value));
+            => RotationalSpeed.FromRevolutionsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalSpeed.FromRevolutionsPerSecond(value.ToDouble(null));
+            => RotationalSpeed.FromRevolutionsPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
index 0784067570..fc13315e36 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
@@ -32,378 +32,378 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalStiffness
     /// </summary>
     public static class NumberToRotationalStiffnessExtensions
     {
-        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMetersPerDegree(QuantityValue)" />
         public static RotationalStiffness CentinewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromCentinewtonMetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromCentinewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromCentinewtonMetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromCentinewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerDegree(QuantityValue)" />
         public static RotationalStiffness CentinewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromCentinewtonMillimetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromCentinewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromCentinewtonMillimetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromCentinewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerRadian(QuantityValue)" />
         public static RotationalStiffness CentinewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromCentinewtonMillimetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromCentinewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromCentinewtonMillimetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromCentinewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMetersPerDegree(QuantityValue)" />
         public static RotationalStiffness DecanewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromDecanewtonMetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromDecanewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromDecanewtonMetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromDecanewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerDegree(QuantityValue)" />
         public static RotationalStiffness DecanewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromDecanewtonMillimetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromDecanewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromDecanewtonMillimetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromDecanewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerRadian(QuantityValue)" />
         public static RotationalStiffness DecanewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromDecanewtonMillimetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromDecanewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromDecanewtonMillimetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromDecanewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMetersPerDegree(QuantityValue)" />
         public static RotationalStiffness DecinewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromDecinewtonMetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromDecinewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromDecinewtonMetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromDecinewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerDegree(QuantityValue)" />
         public static RotationalStiffness DecinewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromDecinewtonMillimetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromDecinewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromDecinewtonMillimetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromDecinewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerRadian(QuantityValue)" />
         public static RotationalStiffness DecinewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromDecinewtonMillimetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromDecinewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromDecinewtonMillimetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromDecinewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerDegree(QuantityValue)" />
         public static RotationalStiffness KilonewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromKilonewtonMetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromKilonewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromKilonewtonMetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromKilonewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerRadian(QuantityValue)" />
         public static RotationalStiffness KilonewtonMetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromKilonewtonMetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromKilonewtonMetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromKilonewtonMetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromKilonewtonMetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerDegree(QuantityValue)" />
         public static RotationalStiffness KilonewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromKilonewtonMillimetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromKilonewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromKilonewtonMillimetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromKilonewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerRadian(QuantityValue)" />
         public static RotationalStiffness KilonewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromKilonewtonMillimetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromKilonewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromKilonewtonMillimetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromKilonewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerDegrees(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerDegrees(QuantityValue)" />
         public static RotationalStiffness KilopoundForceFeetPerDegrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromKilopoundForceFeetPerDegrees(double.CreateChecked(value));
+            => RotationalStiffness.FromKilopoundForceFeetPerDegrees(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromKilopoundForceFeetPerDegrees(value.ToDouble(null));
+            => RotationalStiffness.FromKilopoundForceFeetPerDegrees(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerRadian(QuantityValue)" />
         public static RotationalStiffness KilopoundForceFeetPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromKilopoundForceFeetPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromKilopoundForceFeetPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromKilopoundForceFeetPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromKilopoundForceFeetPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerDegree(QuantityValue)" />
         public static RotationalStiffness MeganewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromMeganewtonMetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromMeganewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromMeganewtonMetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromMeganewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerRadian(QuantityValue)" />
         public static RotationalStiffness MeganewtonMetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromMeganewtonMetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromMeganewtonMetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromMeganewtonMetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromMeganewtonMetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerDegree(QuantityValue)" />
         public static RotationalStiffness MeganewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromMeganewtonMillimetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromMeganewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromMeganewtonMillimetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromMeganewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerRadian(QuantityValue)" />
         public static RotationalStiffness MeganewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromMeganewtonMillimetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromMeganewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromMeganewtonMillimetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromMeganewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMetersPerDegree(QuantityValue)" />
         public static RotationalStiffness MicronewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromMicronewtonMetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromMicronewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromMicronewtonMetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromMicronewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerDegree(QuantityValue)" />
         public static RotationalStiffness MicronewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromMicronewtonMillimetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromMicronewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromMicronewtonMillimetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromMicronewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerRadian(QuantityValue)" />
         public static RotationalStiffness MicronewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromMicronewtonMillimetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromMicronewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromMicronewtonMillimetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromMicronewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMetersPerDegree(QuantityValue)" />
         public static RotationalStiffness MillinewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromMillinewtonMetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromMillinewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromMillinewtonMetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromMillinewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerDegree(QuantityValue)" />
         public static RotationalStiffness MillinewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromMillinewtonMillimetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromMillinewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromMillinewtonMillimetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromMillinewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerRadian(QuantityValue)" />
         public static RotationalStiffness MillinewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromMillinewtonMillimetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromMillinewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromMillinewtonMillimetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromMillinewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMetersPerDegree(QuantityValue)" />
         public static RotationalStiffness NanonewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromNanonewtonMetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromNanonewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromNanonewtonMetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromNanonewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerDegree(QuantityValue)" />
         public static RotationalStiffness NanonewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromNanonewtonMillimetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromNanonewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromNanonewtonMillimetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromNanonewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerRadian(QuantityValue)" />
         public static RotationalStiffness NanonewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromNanonewtonMillimetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromNanonewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromNanonewtonMillimetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromNanonewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerDegree(QuantityValue)" />
         public static RotationalStiffness NewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromNewtonMetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromNewtonMetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromNewtonMetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromNewtonMetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerRadian(QuantityValue)" />
         public static RotationalStiffness NewtonMetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromNewtonMetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromNewtonMetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromNewtonMetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromNewtonMetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerDegree(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerDegree(QuantityValue)" />
         public static RotationalStiffness NewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromNewtonMillimetersPerDegree(double.CreateChecked(value));
+            => RotationalStiffness.FromNewtonMillimetersPerDegree(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromNewtonMillimetersPerDegree(value.ToDouble(null));
+            => RotationalStiffness.FromNewtonMillimetersPerDegree(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerRadian(QuantityValue)" />
         public static RotationalStiffness NewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromNewtonMillimetersPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromNewtonMillimetersPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromNewtonMillimetersPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromNewtonMillimetersPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerRadian(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerRadian(QuantityValue)" />
         public static RotationalStiffness PoundForceFeetPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromPoundForceFeetPerRadian(double.CreateChecked(value));
+            => RotationalStiffness.FromPoundForceFeetPerRadian(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromPoundForceFeetPerRadian(value.ToDouble(null));
+            => RotationalStiffness.FromPoundForceFeetPerRadian(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerDegrees(double)" />
+        /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerDegrees(QuantityValue)" />
         public static RotationalStiffness PoundForceFeetPerDegrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffness.FromPoundForceFeetPerDegrees(double.CreateChecked(value));
+            => RotationalStiffness.FromPoundForceFeetPerDegrees(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffness.FromPoundForceFeetPerDegrees(value.ToDouble(null));
+            => RotationalStiffness.FromPoundForceFeetPerDegrees(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
index b49fa9ec38..01b73a5c7a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
@@ -32,59 +32,59 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalStiffnessPerLength
     /// </summary>
     public static class NumberToRotationalStiffnessPerLengthExtensions
     {
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(double)" />
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(QuantityValue)" />
         public static RotationalStiffnessPerLength KilonewtonMetersPerRadianPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(double.CreateChecked(value));
+            => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(value.ToDouble(null));
+            => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(double)" />
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(QuantityValue)" />
         public static RotationalStiffnessPerLength KilopoundForceFeetPerDegreesPerFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(double.CreateChecked(value));
+            => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(value.ToDouble(null));
+            => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(double)" />
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(QuantityValue)" />
         public static RotationalStiffnessPerLength MeganewtonMetersPerRadianPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(double.CreateChecked(value));
+            => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(value.ToDouble(null));
+            => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(double)" />
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(QuantityValue)" />
         public static RotationalStiffnessPerLength NewtonMetersPerRadianPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(double.CreateChecked(value));
+            => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(value.ToDouble(null));
+            => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(double)" />
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(QuantityValue)" />
         public static RotationalStiffnessPerLength PoundForceFeetPerDegreesPerFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(double.CreateChecked(value));
+            => RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(value.ToDouble(null));
+            => RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToScalarExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToScalarExtensions.g.cs
index decb61c473..386e60a893 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToScalarExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToScalarExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToScalar
     /// </summary>
     public static class NumberToScalarExtensions
     {
-        /// <inheritdoc cref="Scalar.FromAmount(double)" />
+        /// <inheritdoc cref="Scalar.FromAmount(QuantityValue)" />
         public static Scalar Amount<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Scalar.FromAmount(double.CreateChecked(value));
+            => Scalar.FromAmount(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Scalar.FromAmount(value.ToDouble(null));
+            => Scalar.FromAmount(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
index 7af5f9550a..aadd2f279c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToSolidAngle
     /// </summary>
     public static class NumberToSolidAngleExtensions
     {
-        /// <inheritdoc cref="SolidAngle.FromSteradians(double)" />
+        /// <inheritdoc cref="SolidAngle.FromSteradians(QuantityValue)" />
         public static SolidAngle Steradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SolidAngle.FromSteradians(double.CreateChecked(value));
+            => SolidAngle.FromSteradians(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SolidAngle.FromSteradians(value.ToDouble(null));
+            => SolidAngle.FromSteradians(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
index b3805d2950..2ac5ad5c1e 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
@@ -32,334 +32,334 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificEnergy
     /// </summary>
     public static class NumberToSpecificEnergyExtensions
     {
-        /// <inheritdoc cref="SpecificEnergy.FromBtuPerPound(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromBtuPerPound(QuantityValue)" />
         public static SpecificEnergy BtuPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromBtuPerPound(double.CreateChecked(value));
+            => SpecificEnergy.FromBtuPerPound(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromBtuPerPound(value.ToDouble(null));
+            => SpecificEnergy.FromBtuPerPound(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromCaloriesPerGram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromCaloriesPerGram(QuantityValue)" />
         public static SpecificEnergy CaloriesPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromCaloriesPerGram(double.CreateChecked(value));
+            => SpecificEnergy.FromCaloriesPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromCaloriesPerGram(value.ToDouble(null));
+            => SpecificEnergy.FromCaloriesPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerKilogram(QuantityValue)" />
         public static SpecificEnergy GigawattDaysPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromGigawattDaysPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromGigawattDaysPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromGigawattDaysPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromGigawattDaysPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerShortTon(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerShortTon(QuantityValue)" />
         public static SpecificEnergy GigawattDaysPerShortTon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromGigawattDaysPerShortTon(double.CreateChecked(value));
+            => SpecificEnergy.FromGigawattDaysPerShortTon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromGigawattDaysPerShortTon(value.ToDouble(null));
+            => SpecificEnergy.FromGigawattDaysPerShortTon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerTonne(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerTonne(QuantityValue)" />
         public static SpecificEnergy GigawattDaysPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromGigawattDaysPerTonne(double.CreateChecked(value));
+            => SpecificEnergy.FromGigawattDaysPerTonne(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromGigawattDaysPerTonne(value.ToDouble(null));
+            => SpecificEnergy.FromGigawattDaysPerTonne(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerKilogram(QuantityValue)" />
         public static SpecificEnergy GigawattHoursPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromGigawattHoursPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromGigawattHoursPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromGigawattHoursPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromGigawattHoursPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerPound(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerPound(QuantityValue)" />
         public static SpecificEnergy GigawattHoursPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromGigawattHoursPerPound(double.CreateChecked(value));
+            => SpecificEnergy.FromGigawattHoursPerPound(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromGigawattHoursPerPound(value.ToDouble(null));
+            => SpecificEnergy.FromGigawattHoursPerPound(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromJoulesPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromJoulesPerKilogram(QuantityValue)" />
         public static SpecificEnergy JoulesPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromJoulesPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromJoulesPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromJoulesPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromJoulesPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilocaloriesPerGram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilocaloriesPerGram(QuantityValue)" />
         public static SpecificEnergy KilocaloriesPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromKilocaloriesPerGram(double.CreateChecked(value));
+            => SpecificEnergy.FromKilocaloriesPerGram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromKilocaloriesPerGram(value.ToDouble(null));
+            => SpecificEnergy.FromKilocaloriesPerGram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilojoulesPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilojoulesPerKilogram(QuantityValue)" />
         public static SpecificEnergy KilojoulesPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromKilojoulesPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromKilojoulesPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromKilojoulesPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromKilojoulesPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerKilogram(QuantityValue)" />
         public static SpecificEnergy KilowattDaysPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromKilowattDaysPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromKilowattDaysPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromKilowattDaysPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromKilowattDaysPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerShortTon(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerShortTon(QuantityValue)" />
         public static SpecificEnergy KilowattDaysPerShortTon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromKilowattDaysPerShortTon(double.CreateChecked(value));
+            => SpecificEnergy.FromKilowattDaysPerShortTon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromKilowattDaysPerShortTon(value.ToDouble(null));
+            => SpecificEnergy.FromKilowattDaysPerShortTon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerTonne(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerTonne(QuantityValue)" />
         public static SpecificEnergy KilowattDaysPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromKilowattDaysPerTonne(double.CreateChecked(value));
+            => SpecificEnergy.FromKilowattDaysPerTonne(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromKilowattDaysPerTonne(value.ToDouble(null));
+            => SpecificEnergy.FromKilowattDaysPerTonne(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerKilogram(QuantityValue)" />
         public static SpecificEnergy KilowattHoursPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromKilowattHoursPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromKilowattHoursPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromKilowattHoursPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromKilowattHoursPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerPound(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerPound(QuantityValue)" />
         public static SpecificEnergy KilowattHoursPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromKilowattHoursPerPound(double.CreateChecked(value));
+            => SpecificEnergy.FromKilowattHoursPerPound(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromKilowattHoursPerPound(value.ToDouble(null));
+            => SpecificEnergy.FromKilowattHoursPerPound(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerKilogram(QuantityValue)" />
         public static SpecificEnergy MegajoulesPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromMegajoulesPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromMegajoulesPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromMegajoulesPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromMegajoulesPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerTonne(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerTonne(QuantityValue)" />
         public static SpecificEnergy MegajoulesPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromMegajoulesPerTonne(double.CreateChecked(value));
+            => SpecificEnergy.FromMegajoulesPerTonne(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromMegajoulesPerTonne(value.ToDouble(null));
+            => SpecificEnergy.FromMegajoulesPerTonne(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerKilogram(QuantityValue)" />
         public static SpecificEnergy MegawattDaysPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromMegawattDaysPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromMegawattDaysPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromMegawattDaysPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromMegawattDaysPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerShortTon(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerShortTon(QuantityValue)" />
         public static SpecificEnergy MegawattDaysPerShortTon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromMegawattDaysPerShortTon(double.CreateChecked(value));
+            => SpecificEnergy.FromMegawattDaysPerShortTon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromMegawattDaysPerShortTon(value.ToDouble(null));
+            => SpecificEnergy.FromMegawattDaysPerShortTon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerTonne(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerTonne(QuantityValue)" />
         public static SpecificEnergy MegawattDaysPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromMegawattDaysPerTonne(double.CreateChecked(value));
+            => SpecificEnergy.FromMegawattDaysPerTonne(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromMegawattDaysPerTonne(value.ToDouble(null));
+            => SpecificEnergy.FromMegawattDaysPerTonne(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerKilogram(QuantityValue)" />
         public static SpecificEnergy MegawattHoursPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromMegawattHoursPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromMegawattHoursPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromMegawattHoursPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromMegawattHoursPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerPound(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerPound(QuantityValue)" />
         public static SpecificEnergy MegawattHoursPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromMegawattHoursPerPound(double.CreateChecked(value));
+            => SpecificEnergy.FromMegawattHoursPerPound(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromMegawattHoursPerPound(value.ToDouble(null));
+            => SpecificEnergy.FromMegawattHoursPerPound(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerKilogram(QuantityValue)" />
         public static SpecificEnergy TerawattDaysPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromTerawattDaysPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromTerawattDaysPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromTerawattDaysPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromTerawattDaysPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerShortTon(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerShortTon(QuantityValue)" />
         public static SpecificEnergy TerawattDaysPerShortTon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromTerawattDaysPerShortTon(double.CreateChecked(value));
+            => SpecificEnergy.FromTerawattDaysPerShortTon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromTerawattDaysPerShortTon(value.ToDouble(null));
+            => SpecificEnergy.FromTerawattDaysPerShortTon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerTonne(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerTonne(QuantityValue)" />
         public static SpecificEnergy TerawattDaysPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromTerawattDaysPerTonne(double.CreateChecked(value));
+            => SpecificEnergy.FromTerawattDaysPerTonne(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromTerawattDaysPerTonne(value.ToDouble(null));
+            => SpecificEnergy.FromTerawattDaysPerTonne(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerKilogram(QuantityValue)" />
         public static SpecificEnergy WattDaysPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromWattDaysPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromWattDaysPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromWattDaysPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromWattDaysPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerShortTon(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerShortTon(QuantityValue)" />
         public static SpecificEnergy WattDaysPerShortTon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromWattDaysPerShortTon(double.CreateChecked(value));
+            => SpecificEnergy.FromWattDaysPerShortTon(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromWattDaysPerShortTon(value.ToDouble(null));
+            => SpecificEnergy.FromWattDaysPerShortTon(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerTonne(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerTonne(QuantityValue)" />
         public static SpecificEnergy WattDaysPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromWattDaysPerTonne(double.CreateChecked(value));
+            => SpecificEnergy.FromWattDaysPerTonne(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromWattDaysPerTonne(value.ToDouble(null));
+            => SpecificEnergy.FromWattDaysPerTonne(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerKilogram(QuantityValue)" />
         public static SpecificEnergy WattHoursPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromWattHoursPerKilogram(double.CreateChecked(value));
+            => SpecificEnergy.FromWattHoursPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromWattHoursPerKilogram(value.ToDouble(null));
+            => SpecificEnergy.FromWattHoursPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerPound(double)" />
+        /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerPound(QuantityValue)" />
         public static SpecificEnergy WattHoursPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEnergy.FromWattHoursPerPound(double.CreateChecked(value));
+            => SpecificEnergy.FromWattHoursPerPound(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEnergy.FromWattHoursPerPound(value.ToDouble(null));
+            => SpecificEnergy.FromWattHoursPerPound(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
index cf22bc3712..a6688da3ed 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
@@ -32,103 +32,103 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificEntropy
     /// </summary>
     public static class NumberToSpecificEntropyExtensions
     {
-        /// <inheritdoc cref="SpecificEntropy.FromBtusPerPoundFahrenheit(double)" />
+        /// <inheritdoc cref="SpecificEntropy.FromBtusPerPoundFahrenheit(QuantityValue)" />
         public static SpecificEntropy BtusPerPoundFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEntropy.FromBtusPerPoundFahrenheit(double.CreateChecked(value));
+            => SpecificEntropy.FromBtusPerPoundFahrenheit(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEntropy.FromBtusPerPoundFahrenheit(value.ToDouble(null));
+            => SpecificEntropy.FromBtusPerPoundFahrenheit(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEntropy.FromCaloriesPerGramKelvin(double)" />
+        /// <inheritdoc cref="SpecificEntropy.FromCaloriesPerGramKelvin(QuantityValue)" />
         public static SpecificEntropy CaloriesPerGramKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEntropy.FromCaloriesPerGramKelvin(double.CreateChecked(value));
+            => SpecificEntropy.FromCaloriesPerGramKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEntropy.FromCaloriesPerGramKelvin(value.ToDouble(null));
+            => SpecificEntropy.FromCaloriesPerGramKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(double)" />
+        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(QuantityValue)" />
         public static SpecificEntropy JoulesPerKilogramDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(double.CreateChecked(value));
+            => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(value.ToDouble(null));
+            => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramKelvin(double)" />
+        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramKelvin(QuantityValue)" />
         public static SpecificEntropy JoulesPerKilogramKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEntropy.FromJoulesPerKilogramKelvin(double.CreateChecked(value));
+            => SpecificEntropy.FromJoulesPerKilogramKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEntropy.FromJoulesPerKilogramKelvin(value.ToDouble(null));
+            => SpecificEntropy.FromJoulesPerKilogramKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEntropy.FromKilocaloriesPerGramKelvin(double)" />
+        /// <inheritdoc cref="SpecificEntropy.FromKilocaloriesPerGramKelvin(QuantityValue)" />
         public static SpecificEntropy KilocaloriesPerGramKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEntropy.FromKilocaloriesPerGramKelvin(double.CreateChecked(value));
+            => SpecificEntropy.FromKilocaloriesPerGramKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEntropy.FromKilocaloriesPerGramKelvin(value.ToDouble(null));
+            => SpecificEntropy.FromKilocaloriesPerGramKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(double)" />
+        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(QuantityValue)" />
         public static SpecificEntropy KilojoulesPerKilogramDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(double.CreateChecked(value));
+            => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(value.ToDouble(null));
+            => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramKelvin(double)" />
+        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramKelvin(QuantityValue)" />
         public static SpecificEntropy KilojoulesPerKilogramKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEntropy.FromKilojoulesPerKilogramKelvin(double.CreateChecked(value));
+            => SpecificEntropy.FromKilojoulesPerKilogramKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEntropy.FromKilojoulesPerKilogramKelvin(value.ToDouble(null));
+            => SpecificEntropy.FromKilojoulesPerKilogramKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(double)" />
+        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(QuantityValue)" />
         public static SpecificEntropy MegajoulesPerKilogramDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(double.CreateChecked(value));
+            => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(value.ToDouble(null));
+            => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramKelvin(double)" />
+        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramKelvin(QuantityValue)" />
         public static SpecificEntropy MegajoulesPerKilogramKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificEntropy.FromMegajoulesPerKilogramKelvin(double.CreateChecked(value));
+            => SpecificEntropy.FromMegajoulesPerKilogramKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificEntropy.FromMegajoulesPerKilogramKelvin(value.ToDouble(null));
+            => SpecificEntropy.FromMegajoulesPerKilogramKelvin(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs
index f1479d7feb..832423fe15 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs
@@ -32,48 +32,48 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificFuelConsumption
     /// </summary>
     public static class NumberToSpecificFuelConsumptionExtensions
     {
-        /// <inheritdoc cref="SpecificFuelConsumption.FromGramsPerKilonewtonSecond(double)" />
+        /// <inheritdoc cref="SpecificFuelConsumption.FromGramsPerKilonewtonSecond(QuantityValue)" />
         public static SpecificFuelConsumption GramsPerKilonewtonSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificFuelConsumption.FromGramsPerKilonewtonSecond(double.CreateChecked(value));
+            => SpecificFuelConsumption.FromGramsPerKilonewtonSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificFuelConsumption.FromGramsPerKilonewtonSecond(value.ToDouble(null));
+            => SpecificFuelConsumption.FromGramsPerKilonewtonSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(double)" />
+        /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(QuantityValue)" />
         public static SpecificFuelConsumption KilogramsPerKilogramForceHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(double.CreateChecked(value));
+            => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(value.ToDouble(null));
+            => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(double)" />
+        /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(QuantityValue)" />
         public static SpecificFuelConsumption KilogramsPerKilonewtonSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(double.CreateChecked(value));
+            => SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(value.ToDouble(null));
+            => SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(double)" />
+        /// <inheritdoc cref="SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(QuantityValue)" />
         public static SpecificFuelConsumption PoundsMassPerPoundForceHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(double.CreateChecked(value));
+            => SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(value.ToDouble(null));
+            => SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
index 3839372237..08929cb7e0 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
@@ -32,37 +32,37 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificVolume
     /// </summary>
     public static class NumberToSpecificVolumeExtensions
     {
-        /// <inheritdoc cref="SpecificVolume.FromCubicFeetPerPound(double)" />
+        /// <inheritdoc cref="SpecificVolume.FromCubicFeetPerPound(QuantityValue)" />
         public static SpecificVolume CubicFeetPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificVolume.FromCubicFeetPerPound(double.CreateChecked(value));
+            => SpecificVolume.FromCubicFeetPerPound(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificVolume.FromCubicFeetPerPound(value.ToDouble(null));
+            => SpecificVolume.FromCubicFeetPerPound(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificVolume.FromCubicMetersPerKilogram(double)" />
+        /// <inheritdoc cref="SpecificVolume.FromCubicMetersPerKilogram(QuantityValue)" />
         public static SpecificVolume CubicMetersPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificVolume.FromCubicMetersPerKilogram(double.CreateChecked(value));
+            => SpecificVolume.FromCubicMetersPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificVolume.FromCubicMetersPerKilogram(value.ToDouble(null));
+            => SpecificVolume.FromCubicMetersPerKilogram(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificVolume.FromMillicubicMetersPerKilogram(double)" />
-        public static SpecificVolume MillicubicMetersPerKilogram<T>(this T value)
+        /// <inheritdoc cref="SpecificVolume.FromCubicMillimetersPerKilogram(QuantityValue)" />
+        public static SpecificVolume CubicMillimetersPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificVolume.FromMillicubicMetersPerKilogram(double.CreateChecked(value));
+            => SpecificVolume.FromCubicMillimetersPerKilogram(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificVolume.FromMillicubicMetersPerKilogram(value.ToDouble(null));
+            => SpecificVolume.FromCubicMillimetersPerKilogram(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
index 3bef134ca9..aa13088a97 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
@@ -32,191 +32,191 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificWeight
     /// </summary>
     public static class NumberToSpecificWeightExtensions
     {
-        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicCentimeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicCentimeter(QuantityValue)" />
         public static SpecificWeight KilogramsForcePerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromKilogramsForcePerCubicCentimeter(double.CreateChecked(value));
+            => SpecificWeight.FromKilogramsForcePerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromKilogramsForcePerCubicCentimeter(value.ToDouble(null));
+            => SpecificWeight.FromKilogramsForcePerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMeter(QuantityValue)" />
         public static SpecificWeight KilogramsForcePerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromKilogramsForcePerCubicMeter(double.CreateChecked(value));
+            => SpecificWeight.FromKilogramsForcePerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromKilogramsForcePerCubicMeter(value.ToDouble(null));
+            => SpecificWeight.FromKilogramsForcePerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMillimeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMillimeter(QuantityValue)" />
         public static SpecificWeight KilogramsForcePerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromKilogramsForcePerCubicMillimeter(double.CreateChecked(value));
+            => SpecificWeight.FromKilogramsForcePerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromKilogramsForcePerCubicMillimeter(value.ToDouble(null));
+            => SpecificWeight.FromKilogramsForcePerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicCentimeter(QuantityValue)" />
         public static SpecificWeight KilonewtonsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromKilonewtonsPerCubicCentimeter(double.CreateChecked(value));
+            => SpecificWeight.FromKilonewtonsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromKilonewtonsPerCubicCentimeter(value.ToDouble(null));
+            => SpecificWeight.FromKilonewtonsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMeter(QuantityValue)" />
         public static SpecificWeight KilonewtonsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromKilonewtonsPerCubicMeter(double.CreateChecked(value));
+            => SpecificWeight.FromKilonewtonsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromKilonewtonsPerCubicMeter(value.ToDouble(null));
+            => SpecificWeight.FromKilonewtonsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMillimeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMillimeter(QuantityValue)" />
         public static SpecificWeight KilonewtonsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromKilonewtonsPerCubicMillimeter(double.CreateChecked(value));
+            => SpecificWeight.FromKilonewtonsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromKilonewtonsPerCubicMillimeter(value.ToDouble(null));
+            => SpecificWeight.FromKilonewtonsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicFoot(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicFoot(QuantityValue)" />
         public static SpecificWeight KilopoundsForcePerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromKilopoundsForcePerCubicFoot(double.CreateChecked(value));
+            => SpecificWeight.FromKilopoundsForcePerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromKilopoundsForcePerCubicFoot(value.ToDouble(null));
+            => SpecificWeight.FromKilopoundsForcePerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicInch(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicInch(QuantityValue)" />
         public static SpecificWeight KilopoundsForcePerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromKilopoundsForcePerCubicInch(double.CreateChecked(value));
+            => SpecificWeight.FromKilopoundsForcePerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromKilopoundsForcePerCubicInch(value.ToDouble(null));
+            => SpecificWeight.FromKilopoundsForcePerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromMeganewtonsPerCubicMeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromMeganewtonsPerCubicMeter(QuantityValue)" />
         public static SpecificWeight MeganewtonsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromMeganewtonsPerCubicMeter(double.CreateChecked(value));
+            => SpecificWeight.FromMeganewtonsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromMeganewtonsPerCubicMeter(value.ToDouble(null));
+            => SpecificWeight.FromMeganewtonsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicCentimeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicCentimeter(QuantityValue)" />
         public static SpecificWeight NewtonsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromNewtonsPerCubicCentimeter(double.CreateChecked(value));
+            => SpecificWeight.FromNewtonsPerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromNewtonsPerCubicCentimeter(value.ToDouble(null));
+            => SpecificWeight.FromNewtonsPerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMeter(QuantityValue)" />
         public static SpecificWeight NewtonsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromNewtonsPerCubicMeter(double.CreateChecked(value));
+            => SpecificWeight.FromNewtonsPerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromNewtonsPerCubicMeter(value.ToDouble(null));
+            => SpecificWeight.FromNewtonsPerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMillimeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMillimeter(QuantityValue)" />
         public static SpecificWeight NewtonsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromNewtonsPerCubicMillimeter(double.CreateChecked(value));
+            => SpecificWeight.FromNewtonsPerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromNewtonsPerCubicMillimeter(value.ToDouble(null));
+            => SpecificWeight.FromNewtonsPerCubicMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicFoot(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicFoot(QuantityValue)" />
         public static SpecificWeight PoundsForcePerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromPoundsForcePerCubicFoot(double.CreateChecked(value));
+            => SpecificWeight.FromPoundsForcePerCubicFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromPoundsForcePerCubicFoot(value.ToDouble(null));
+            => SpecificWeight.FromPoundsForcePerCubicFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicInch(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicInch(QuantityValue)" />
         public static SpecificWeight PoundsForcePerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromPoundsForcePerCubicInch(double.CreateChecked(value));
+            => SpecificWeight.FromPoundsForcePerCubicInch(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromPoundsForcePerCubicInch(value.ToDouble(null));
+            => SpecificWeight.FromPoundsForcePerCubicInch(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicCentimeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicCentimeter(QuantityValue)" />
         public static SpecificWeight TonnesForcePerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromTonnesForcePerCubicCentimeter(double.CreateChecked(value));
+            => SpecificWeight.FromTonnesForcePerCubicCentimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromTonnesForcePerCubicCentimeter(value.ToDouble(null));
+            => SpecificWeight.FromTonnesForcePerCubicCentimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMeter(QuantityValue)" />
         public static SpecificWeight TonnesForcePerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromTonnesForcePerCubicMeter(double.CreateChecked(value));
+            => SpecificWeight.FromTonnesForcePerCubicMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromTonnesForcePerCubicMeter(value.ToDouble(null));
+            => SpecificWeight.FromTonnesForcePerCubicMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMillimeter(double)" />
+        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMillimeter(QuantityValue)" />
         public static SpecificWeight TonnesForcePerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => SpecificWeight.FromTonnesForcePerCubicMillimeter(double.CreateChecked(value));
+            => SpecificWeight.FromTonnesForcePerCubicMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => SpecificWeight.FromTonnesForcePerCubicMillimeter(value.ToDouble(null));
+            => SpecificWeight.FromTonnesForcePerCubicMillimeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
index 75bd5bbe13..ec1e070bfd 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
@@ -32,367 +32,367 @@ namespace UnitsNet.NumberExtensions.NumberToSpeed
     /// </summary>
     public static class NumberToSpeedExtensions
     {
-        /// <inheritdoc cref="Speed.FromCentimetersPerHour(double)" />
+        /// <inheritdoc cref="Speed.FromCentimetersPerHour(QuantityValue)" />
         public static Speed CentimetersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromCentimetersPerHour(double.CreateChecked(value));
+            => Speed.FromCentimetersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromCentimetersPerHour(value.ToDouble(null));
+            => Speed.FromCentimetersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromCentimetersPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromCentimetersPerMinute(QuantityValue)" />
         public static Speed CentimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromCentimetersPerMinute(double.CreateChecked(value));
+            => Speed.FromCentimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromCentimetersPerMinute(value.ToDouble(null));
+            => Speed.FromCentimetersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromCentimetersPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromCentimetersPerSecond(QuantityValue)" />
         public static Speed CentimetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromCentimetersPerSecond(double.CreateChecked(value));
+            => Speed.FromCentimetersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromCentimetersPerSecond(value.ToDouble(null));
+            => Speed.FromCentimetersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromDecimetersPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromDecimetersPerMinute(QuantityValue)" />
         public static Speed DecimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromDecimetersPerMinute(double.CreateChecked(value));
+            => Speed.FromDecimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromDecimetersPerMinute(value.ToDouble(null));
+            => Speed.FromDecimetersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromDecimetersPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromDecimetersPerSecond(QuantityValue)" />
         public static Speed DecimetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromDecimetersPerSecond(double.CreateChecked(value));
+            => Speed.FromDecimetersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromDecimetersPerSecond(value.ToDouble(null));
+            => Speed.FromDecimetersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromFeetPerHour(double)" />
+        /// <inheritdoc cref="Speed.FromFeetPerHour(QuantityValue)" />
         public static Speed FeetPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromFeetPerHour(double.CreateChecked(value));
+            => Speed.FromFeetPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromFeetPerHour(value.ToDouble(null));
+            => Speed.FromFeetPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromFeetPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromFeetPerMinute(QuantityValue)" />
         public static Speed FeetPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromFeetPerMinute(double.CreateChecked(value));
+            => Speed.FromFeetPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromFeetPerMinute(value.ToDouble(null));
+            => Speed.FromFeetPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromFeetPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromFeetPerSecond(QuantityValue)" />
         public static Speed FeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromFeetPerSecond(double.CreateChecked(value));
+            => Speed.FromFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromFeetPerSecond(value.ToDouble(null));
+            => Speed.FromFeetPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromInchesPerHour(double)" />
+        /// <inheritdoc cref="Speed.FromInchesPerHour(QuantityValue)" />
         public static Speed InchesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromInchesPerHour(double.CreateChecked(value));
+            => Speed.FromInchesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromInchesPerHour(value.ToDouble(null));
+            => Speed.FromInchesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromInchesPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromInchesPerMinute(QuantityValue)" />
         public static Speed InchesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromInchesPerMinute(double.CreateChecked(value));
+            => Speed.FromInchesPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromInchesPerMinute(value.ToDouble(null));
+            => Speed.FromInchesPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromInchesPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromInchesPerSecond(QuantityValue)" />
         public static Speed InchesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromInchesPerSecond(double.CreateChecked(value));
+            => Speed.FromInchesPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromInchesPerSecond(value.ToDouble(null));
+            => Speed.FromInchesPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromKilometersPerHour(double)" />
+        /// <inheritdoc cref="Speed.FromKilometersPerHour(QuantityValue)" />
         public static Speed KilometersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromKilometersPerHour(double.CreateChecked(value));
+            => Speed.FromKilometersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromKilometersPerHour(value.ToDouble(null));
+            => Speed.FromKilometersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromKilometersPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromKilometersPerMinute(QuantityValue)" />
         public static Speed KilometersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromKilometersPerMinute(double.CreateChecked(value));
+            => Speed.FromKilometersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromKilometersPerMinute(value.ToDouble(null));
+            => Speed.FromKilometersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromKilometersPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromKilometersPerSecond(QuantityValue)" />
         public static Speed KilometersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromKilometersPerSecond(double.CreateChecked(value));
+            => Speed.FromKilometersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromKilometersPerSecond(value.ToDouble(null));
+            => Speed.FromKilometersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromKnots(double)" />
+        /// <inheritdoc cref="Speed.FromKnots(QuantityValue)" />
         public static Speed Knots<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromKnots(double.CreateChecked(value));
+            => Speed.FromKnots(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromKnots(value.ToDouble(null));
+            => Speed.FromKnots(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromMach(double)" />
+        /// <inheritdoc cref="Speed.FromMach(QuantityValue)" />
         public static Speed Mach<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromMach(double.CreateChecked(value));
+            => Speed.FromMach(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromMach(value.ToDouble(null));
+            => Speed.FromMach(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromMetersPerHour(double)" />
+        /// <inheritdoc cref="Speed.FromMetersPerHour(QuantityValue)" />
         public static Speed MetersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromMetersPerHour(double.CreateChecked(value));
+            => Speed.FromMetersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromMetersPerHour(value.ToDouble(null));
+            => Speed.FromMetersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromMetersPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromMetersPerMinute(QuantityValue)" />
         public static Speed MetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromMetersPerMinute(double.CreateChecked(value));
+            => Speed.FromMetersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromMetersPerMinute(value.ToDouble(null));
+            => Speed.FromMetersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromMetersPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromMetersPerSecond(QuantityValue)" />
         public static Speed MetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromMetersPerSecond(double.CreateChecked(value));
+            => Speed.FromMetersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromMetersPerSecond(value.ToDouble(null));
+            => Speed.FromMetersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromMicrometersPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromMicrometersPerMinute(QuantityValue)" />
         public static Speed MicrometersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromMicrometersPerMinute(double.CreateChecked(value));
+            => Speed.FromMicrometersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromMicrometersPerMinute(value.ToDouble(null));
+            => Speed.FromMicrometersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromMicrometersPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromMicrometersPerSecond(QuantityValue)" />
         public static Speed MicrometersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromMicrometersPerSecond(double.CreateChecked(value));
+            => Speed.FromMicrometersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromMicrometersPerSecond(value.ToDouble(null));
+            => Speed.FromMicrometersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromMilesPerHour(double)" />
+        /// <inheritdoc cref="Speed.FromMilesPerHour(QuantityValue)" />
         public static Speed MilesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromMilesPerHour(double.CreateChecked(value));
+            => Speed.FromMilesPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromMilesPerHour(value.ToDouble(null));
+            => Speed.FromMilesPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromMillimetersPerHour(double)" />
+        /// <inheritdoc cref="Speed.FromMillimetersPerHour(QuantityValue)" />
         public static Speed MillimetersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromMillimetersPerHour(double.CreateChecked(value));
+            => Speed.FromMillimetersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromMillimetersPerHour(value.ToDouble(null));
+            => Speed.FromMillimetersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromMillimetersPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromMillimetersPerMinute(QuantityValue)" />
         public static Speed MillimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromMillimetersPerMinute(double.CreateChecked(value));
+            => Speed.FromMillimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromMillimetersPerMinute(value.ToDouble(null));
+            => Speed.FromMillimetersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromMillimetersPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromMillimetersPerSecond(QuantityValue)" />
         public static Speed MillimetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromMillimetersPerSecond(double.CreateChecked(value));
+            => Speed.FromMillimetersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromMillimetersPerSecond(value.ToDouble(null));
+            => Speed.FromMillimetersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromNanometersPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromNanometersPerMinute(QuantityValue)" />
         public static Speed NanometersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromNanometersPerMinute(double.CreateChecked(value));
+            => Speed.FromNanometersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromNanometersPerMinute(value.ToDouble(null));
+            => Speed.FromNanometersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromNanometersPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromNanometersPerSecond(QuantityValue)" />
         public static Speed NanometersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromNanometersPerSecond(double.CreateChecked(value));
+            => Speed.FromNanometersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromNanometersPerSecond(value.ToDouble(null));
+            => Speed.FromNanometersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerHour(double)" />
+        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerHour(QuantityValue)" />
         public static Speed UsSurveyFeetPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromUsSurveyFeetPerHour(double.CreateChecked(value));
+            => Speed.FromUsSurveyFeetPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromUsSurveyFeetPerHour(value.ToDouble(null));
+            => Speed.FromUsSurveyFeetPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerMinute(QuantityValue)" />
         public static Speed UsSurveyFeetPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromUsSurveyFeetPerMinute(double.CreateChecked(value));
+            => Speed.FromUsSurveyFeetPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromUsSurveyFeetPerMinute(value.ToDouble(null));
+            => Speed.FromUsSurveyFeetPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerSecond(QuantityValue)" />
         public static Speed UsSurveyFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromUsSurveyFeetPerSecond(double.CreateChecked(value));
+            => Speed.FromUsSurveyFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromUsSurveyFeetPerSecond(value.ToDouble(null));
+            => Speed.FromUsSurveyFeetPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromYardsPerHour(double)" />
+        /// <inheritdoc cref="Speed.FromYardsPerHour(QuantityValue)" />
         public static Speed YardsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromYardsPerHour(double.CreateChecked(value));
+            => Speed.FromYardsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromYardsPerHour(value.ToDouble(null));
+            => Speed.FromYardsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromYardsPerMinute(double)" />
+        /// <inheritdoc cref="Speed.FromYardsPerMinute(QuantityValue)" />
         public static Speed YardsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromYardsPerMinute(double.CreateChecked(value));
+            => Speed.FromYardsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromYardsPerMinute(value.ToDouble(null));
+            => Speed.FromYardsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Speed.FromYardsPerSecond(double)" />
+        /// <inheritdoc cref="Speed.FromYardsPerSecond(QuantityValue)" />
         public static Speed YardsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Speed.FromYardsPerSecond(double.CreateChecked(value));
+            => Speed.FromYardsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Speed.FromYardsPerSecond(value.ToDouble(null));
+            => Speed.FromYardsPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs
index f442ff3bfe..8b9a18370f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs
@@ -32,103 +32,103 @@ namespace UnitsNet.NumberExtensions.NumberToStandardVolumeFlow
     /// </summary>
     public static class NumberToStandardVolumeFlowExtensions
     {
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(double)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(QuantityValue)" />
         public static StandardVolumeFlow StandardCubicCentimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(double.CreateChecked(value));
+            => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(value.ToDouble(null));
+            => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerHour(double)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerHour(QuantityValue)" />
         public static StandardVolumeFlow StandardCubicFeetPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => StandardVolumeFlow.FromStandardCubicFeetPerHour(double.CreateChecked(value));
+            => StandardVolumeFlow.FromStandardCubicFeetPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => StandardVolumeFlow.FromStandardCubicFeetPerHour(value.ToDouble(null));
+            => StandardVolumeFlow.FromStandardCubicFeetPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerMinute(double)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerMinute(QuantityValue)" />
         public static StandardVolumeFlow StandardCubicFeetPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => StandardVolumeFlow.FromStandardCubicFeetPerMinute(double.CreateChecked(value));
+            => StandardVolumeFlow.FromStandardCubicFeetPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => StandardVolumeFlow.FromStandardCubicFeetPerMinute(value.ToDouble(null));
+            => StandardVolumeFlow.FromStandardCubicFeetPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerSecond(double)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerSecond(QuantityValue)" />
         public static StandardVolumeFlow StandardCubicFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => StandardVolumeFlow.FromStandardCubicFeetPerSecond(double.CreateChecked(value));
+            => StandardVolumeFlow.FromStandardCubicFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => StandardVolumeFlow.FromStandardCubicFeetPerSecond(value.ToDouble(null));
+            => StandardVolumeFlow.FromStandardCubicFeetPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerDay(double)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerDay(QuantityValue)" />
         public static StandardVolumeFlow StandardCubicMetersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => StandardVolumeFlow.FromStandardCubicMetersPerDay(double.CreateChecked(value));
+            => StandardVolumeFlow.FromStandardCubicMetersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => StandardVolumeFlow.FromStandardCubicMetersPerDay(value.ToDouble(null));
+            => StandardVolumeFlow.FromStandardCubicMetersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerHour(double)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerHour(QuantityValue)" />
         public static StandardVolumeFlow StandardCubicMetersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => StandardVolumeFlow.FromStandardCubicMetersPerHour(double.CreateChecked(value));
+            => StandardVolumeFlow.FromStandardCubicMetersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => StandardVolumeFlow.FromStandardCubicMetersPerHour(value.ToDouble(null));
+            => StandardVolumeFlow.FromStandardCubicMetersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerMinute(double)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerMinute(QuantityValue)" />
         public static StandardVolumeFlow StandardCubicMetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => StandardVolumeFlow.FromStandardCubicMetersPerMinute(double.CreateChecked(value));
+            => StandardVolumeFlow.FromStandardCubicMetersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => StandardVolumeFlow.FromStandardCubicMetersPerMinute(value.ToDouble(null));
+            => StandardVolumeFlow.FromStandardCubicMetersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerSecond(double)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerSecond(QuantityValue)" />
         public static StandardVolumeFlow StandardCubicMetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => StandardVolumeFlow.FromStandardCubicMetersPerSecond(double.CreateChecked(value));
+            => StandardVolumeFlow.FromStandardCubicMetersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => StandardVolumeFlow.FromStandardCubicMetersPerSecond(value.ToDouble(null));
+            => StandardVolumeFlow.FromStandardCubicMetersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardLitersPerMinute(double)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardLitersPerMinute(QuantityValue)" />
         public static StandardVolumeFlow StandardLitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => StandardVolumeFlow.FromStandardLitersPerMinute(double.CreateChecked(value));
+            => StandardVolumeFlow.FromStandardLitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => StandardVolumeFlow.FromStandardLitersPerMinute(value.ToDouble(null));
+            => StandardVolumeFlow.FromStandardLitersPerMinute(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
index d236ae0499..e71814b000 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
@@ -32,191 +32,191 @@ namespace UnitsNet.NumberExtensions.NumberToTemperatureChangeRate
     /// </summary>
     public static class NumberToTemperatureChangeRateExtensions
     {
-        /// <inheritdoc cref="TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(QuantityValue)" />
         public static TemperatureChangeRate CentidegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(QuantityValue)" />
         public static TemperatureChangeRate DecadegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(QuantityValue)" />
         public static TemperatureChangeRate DecidegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerHour(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerHour(QuantityValue)" />
         public static TemperatureChangeRate DegreesCelsiusPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDegreesCelsiusPerHour(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDegreesCelsiusPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDegreesCelsiusPerHour(value.ToDouble(null));
+            => TemperatureChangeRate.FromDegreesCelsiusPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerMinute(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerMinute(QuantityValue)" />
         public static TemperatureChangeRate DegreesCelsiusPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDegreesCelsiusPerMinute(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDegreesCelsiusPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDegreesCelsiusPerMinute(value.ToDouble(null));
+            => TemperatureChangeRate.FromDegreesCelsiusPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerSecond(QuantityValue)" />
         public static TemperatureChangeRate DegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDegreesCelsiusPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDegreesCelsiusPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromDegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerHour(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerHour(QuantityValue)" />
         public static TemperatureChangeRate DegreesFahrenheitPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDegreesFahrenheitPerHour(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDegreesFahrenheitPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDegreesFahrenheitPerHour(value.ToDouble(null));
+            => TemperatureChangeRate.FromDegreesFahrenheitPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerMinute(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerMinute(QuantityValue)" />
         public static TemperatureChangeRate DegreesFahrenheitPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDegreesFahrenheitPerMinute(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDegreesFahrenheitPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDegreesFahrenheitPerMinute(value.ToDouble(null));
+            => TemperatureChangeRate.FromDegreesFahrenheitPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesFahrenheitPerSecond(QuantityValue)" />
         public static TemperatureChangeRate DegreesFahrenheitPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDegreesFahrenheitPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDegreesFahrenheitPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDegreesFahrenheitPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromDegreesFahrenheitPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerHour(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerHour(QuantityValue)" />
         public static TemperatureChangeRate DegreesKelvinPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDegreesKelvinPerHour(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDegreesKelvinPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDegreesKelvinPerHour(value.ToDouble(null));
+            => TemperatureChangeRate.FromDegreesKelvinPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerMinute(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerMinute(QuantityValue)" />
         public static TemperatureChangeRate DegreesKelvinPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDegreesKelvinPerMinute(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDegreesKelvinPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDegreesKelvinPerMinute(value.ToDouble(null));
+            => TemperatureChangeRate.FromDegreesKelvinPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesKelvinPerSecond(QuantityValue)" />
         public static TemperatureChangeRate DegreesKelvinPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromDegreesKelvinPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromDegreesKelvinPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromDegreesKelvinPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromDegreesKelvinPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(QuantityValue)" />
         public static TemperatureChangeRate HectodegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(QuantityValue)" />
         public static TemperatureChangeRate KilodegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(QuantityValue)" />
         public static TemperatureChangeRate MicrodegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(QuantityValue)" />
         public static TemperatureChangeRate MillidegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(double)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(QuantityValue)" />
         public static TemperatureChangeRate NanodegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(double.CreateChecked(value));
+            => TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(value.ToDouble(null));
+            => TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
index 3ed118969c..a280c84c87 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
@@ -32,103 +32,103 @@ namespace UnitsNet.NumberExtensions.NumberToTemperatureDelta
     /// </summary>
     public static class NumberToTemperatureDeltaExtensions
     {
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesCelsius(double)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesCelsius(QuantityValue)" />
         public static TemperatureDelta DegreesCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureDelta.FromDegreesCelsius(double.CreateChecked(value));
+            => TemperatureDelta.FromDegreesCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureDelta.FromDegreesCelsius(value.ToDouble(null));
+            => TemperatureDelta.FromDegreesCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesDelisle(double)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesDelisle(QuantityValue)" />
         public static TemperatureDelta DegreesDelisle<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureDelta.FromDegreesDelisle(double.CreateChecked(value));
+            => TemperatureDelta.FromDegreesDelisle(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureDelta.FromDegreesDelisle(value.ToDouble(null));
+            => TemperatureDelta.FromDegreesDelisle(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesFahrenheit(double)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesFahrenheit(QuantityValue)" />
         public static TemperatureDelta DegreesFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureDelta.FromDegreesFahrenheit(double.CreateChecked(value));
+            => TemperatureDelta.FromDegreesFahrenheit(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureDelta.FromDegreesFahrenheit(value.ToDouble(null));
+            => TemperatureDelta.FromDegreesFahrenheit(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesNewton(double)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesNewton(QuantityValue)" />
         public static TemperatureDelta DegreesNewton<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureDelta.FromDegreesNewton(double.CreateChecked(value));
+            => TemperatureDelta.FromDegreesNewton(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureDelta.FromDegreesNewton(value.ToDouble(null));
+            => TemperatureDelta.FromDegreesNewton(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesRankine(double)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesRankine(QuantityValue)" />
         public static TemperatureDelta DegreesRankine<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureDelta.FromDegreesRankine(double.CreateChecked(value));
+            => TemperatureDelta.FromDegreesRankine(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureDelta.FromDegreesRankine(value.ToDouble(null));
+            => TemperatureDelta.FromDegreesRankine(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesReaumur(double)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesReaumur(QuantityValue)" />
         public static TemperatureDelta DegreesReaumur<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureDelta.FromDegreesReaumur(double.CreateChecked(value));
+            => TemperatureDelta.FromDegreesReaumur(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureDelta.FromDegreesReaumur(value.ToDouble(null));
+            => TemperatureDelta.FromDegreesReaumur(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesRoemer(double)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesRoemer(QuantityValue)" />
         public static TemperatureDelta DegreesRoemer<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureDelta.FromDegreesRoemer(double.CreateChecked(value));
+            => TemperatureDelta.FromDegreesRoemer(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureDelta.FromDegreesRoemer(value.ToDouble(null));
+            => TemperatureDelta.FromDegreesRoemer(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureDelta.FromKelvins(double)" />
+        /// <inheritdoc cref="TemperatureDelta.FromKelvins(QuantityValue)" />
         public static TemperatureDelta Kelvins<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureDelta.FromKelvins(double.CreateChecked(value));
+            => TemperatureDelta.FromKelvins(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureDelta.FromKelvins(value.ToDouble(null));
+            => TemperatureDelta.FromKelvins(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureDelta.FromMillidegreesCelsius(double)" />
+        /// <inheritdoc cref="TemperatureDelta.FromMillidegreesCelsius(QuantityValue)" />
         public static TemperatureDelta MillidegreesCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureDelta.FromMillidegreesCelsius(double.CreateChecked(value));
+            => TemperatureDelta.FromMillidegreesCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureDelta.FromMillidegreesCelsius(value.ToDouble(null));
+            => TemperatureDelta.FromMillidegreesCelsius(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
index ec97af50a2..66c4f2f357 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
@@ -32,114 +32,114 @@ namespace UnitsNet.NumberExtensions.NumberToTemperature
     /// </summary>
     public static class NumberToTemperatureExtensions
     {
-        /// <inheritdoc cref="Temperature.FromDegreesCelsius(double)" />
+        /// <inheritdoc cref="Temperature.FromDegreesCelsius(QuantityValue)" />
         public static Temperature DegreesCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Temperature.FromDegreesCelsius(double.CreateChecked(value));
+            => Temperature.FromDegreesCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Temperature.FromDegreesCelsius(value.ToDouble(null));
+            => Temperature.FromDegreesCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Temperature.FromDegreesDelisle(double)" />
+        /// <inheritdoc cref="Temperature.FromDegreesDelisle(QuantityValue)" />
         public static Temperature DegreesDelisle<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Temperature.FromDegreesDelisle(double.CreateChecked(value));
+            => Temperature.FromDegreesDelisle(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Temperature.FromDegreesDelisle(value.ToDouble(null));
+            => Temperature.FromDegreesDelisle(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Temperature.FromDegreesFahrenheit(double)" />
+        /// <inheritdoc cref="Temperature.FromDegreesFahrenheit(QuantityValue)" />
         public static Temperature DegreesFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Temperature.FromDegreesFahrenheit(double.CreateChecked(value));
+            => Temperature.FromDegreesFahrenheit(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Temperature.FromDegreesFahrenheit(value.ToDouble(null));
+            => Temperature.FromDegreesFahrenheit(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Temperature.FromDegreesNewton(double)" />
+        /// <inheritdoc cref="Temperature.FromDegreesNewton(QuantityValue)" />
         public static Temperature DegreesNewton<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Temperature.FromDegreesNewton(double.CreateChecked(value));
+            => Temperature.FromDegreesNewton(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Temperature.FromDegreesNewton(value.ToDouble(null));
+            => Temperature.FromDegreesNewton(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Temperature.FromDegreesRankine(double)" />
+        /// <inheritdoc cref="Temperature.FromDegreesRankine(QuantityValue)" />
         public static Temperature DegreesRankine<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Temperature.FromDegreesRankine(double.CreateChecked(value));
+            => Temperature.FromDegreesRankine(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Temperature.FromDegreesRankine(value.ToDouble(null));
+            => Temperature.FromDegreesRankine(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Temperature.FromDegreesReaumur(double)" />
+        /// <inheritdoc cref="Temperature.FromDegreesReaumur(QuantityValue)" />
         public static Temperature DegreesReaumur<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Temperature.FromDegreesReaumur(double.CreateChecked(value));
+            => Temperature.FromDegreesReaumur(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Temperature.FromDegreesReaumur(value.ToDouble(null));
+            => Temperature.FromDegreesReaumur(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Temperature.FromDegreesRoemer(double)" />
+        /// <inheritdoc cref="Temperature.FromDegreesRoemer(QuantityValue)" />
         public static Temperature DegreesRoemer<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Temperature.FromDegreesRoemer(double.CreateChecked(value));
+            => Temperature.FromDegreesRoemer(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Temperature.FromDegreesRoemer(value.ToDouble(null));
+            => Temperature.FromDegreesRoemer(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Temperature.FromKelvins(double)" />
+        /// <inheritdoc cref="Temperature.FromKelvins(QuantityValue)" />
         public static Temperature Kelvins<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Temperature.FromKelvins(double.CreateChecked(value));
+            => Temperature.FromKelvins(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Temperature.FromKelvins(value.ToDouble(null));
+            => Temperature.FromKelvins(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Temperature.FromMillidegreesCelsius(double)" />
+        /// <inheritdoc cref="Temperature.FromMillidegreesCelsius(QuantityValue)" />
         public static Temperature MillidegreesCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Temperature.FromMillidegreesCelsius(double.CreateChecked(value));
+            => Temperature.FromMillidegreesCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Temperature.FromMillidegreesCelsius(value.ToDouble(null));
+            => Temperature.FromMillidegreesCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Temperature.FromSolarTemperatures(double)" />
+        /// <inheritdoc cref="Temperature.FromSolarTemperatures(QuantityValue)" />
         public static Temperature SolarTemperatures<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Temperature.FromSolarTemperatures(double.CreateChecked(value));
+            => Temperature.FromSolarTemperatures(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Temperature.FromSolarTemperatures(value.ToDouble(null));
+            => Temperature.FromSolarTemperatures(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs
index 12302bd6a5..39b50cba92 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs
@@ -32,48 +32,48 @@ namespace UnitsNet.NumberExtensions.NumberToTemperatureGradient
     /// </summary>
     public static class NumberToTemperatureGradientExtensions
     {
-        /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerKilometer(double)" />
+        /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerKilometer(QuantityValue)" />
         public static TemperatureGradient DegreesCelsiusPerKilometer<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureGradient.FromDegreesCelsiusPerKilometer(double.CreateChecked(value));
+            => TemperatureGradient.FromDegreesCelsiusPerKilometer(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureGradient.FromDegreesCelsiusPerKilometer(value.ToDouble(null));
+            => TemperatureGradient.FromDegreesCelsiusPerKilometer(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerMeter(double)" />
+        /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerMeter(QuantityValue)" />
         public static TemperatureGradient DegreesCelsiusPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureGradient.FromDegreesCelsiusPerMeter(double.CreateChecked(value));
+            => TemperatureGradient.FromDegreesCelsiusPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureGradient.FromDegreesCelsiusPerMeter(value.ToDouble(null));
+            => TemperatureGradient.FromDegreesCelsiusPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureGradient.FromDegreesFahrenheitPerFoot(double)" />
+        /// <inheritdoc cref="TemperatureGradient.FromDegreesFahrenheitPerFoot(QuantityValue)" />
         public static TemperatureGradient DegreesFahrenheitPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureGradient.FromDegreesFahrenheitPerFoot(double.CreateChecked(value));
+            => TemperatureGradient.FromDegreesFahrenheitPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureGradient.FromDegreesFahrenheitPerFoot(value.ToDouble(null));
+            => TemperatureGradient.FromDegreesFahrenheitPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="TemperatureGradient.FromKelvinsPerMeter(double)" />
+        /// <inheritdoc cref="TemperatureGradient.FromKelvinsPerMeter(QuantityValue)" />
         public static TemperatureGradient KelvinsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => TemperatureGradient.FromKelvinsPerMeter(double.CreateChecked(value));
+            => TemperatureGradient.FromKelvinsPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => TemperatureGradient.FromKelvinsPerMeter(value.ToDouble(null));
+            => TemperatureGradient.FromKelvinsPerMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
index 8b9539d7f3..1b0ff4be94 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
@@ -32,26 +32,37 @@ namespace UnitsNet.NumberExtensions.NumberToThermalConductivity
     /// </summary>
     public static class NumberToThermalConductivityExtensions
     {
-        /// <inheritdoc cref="ThermalConductivity.FromBtusPerHourFootFahrenheit(double)" />
+        /// <inheritdoc cref="ThermalConductivity.FromBtusPerHourFootFahrenheit(QuantityValue)" />
         public static ThermalConductivity BtusPerHourFootFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalConductivity.FromBtusPerHourFootFahrenheit(double.CreateChecked(value));
+            => ThermalConductivity.FromBtusPerHourFootFahrenheit(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalConductivity.FromBtusPerHourFootFahrenheit(value.ToDouble(null));
+            => ThermalConductivity.FromBtusPerHourFootFahrenheit(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ThermalConductivity.FromWattsPerMeterKelvin(double)" />
+        /// <inheritdoc cref="ThermalConductivity.FromBtusPerSecondInchFahrenheit(QuantityValue)" />
+        public static ThermalConductivity BtusPerSecondInchFahrenheit<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => ThermalConductivity.FromBtusPerSecondInchFahrenheit(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => ThermalConductivity.FromBtusPerSecondInchFahrenheit(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="ThermalConductivity.FromWattsPerMeterKelvin(QuantityValue)" />
         public static ThermalConductivity WattsPerMeterKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalConductivity.FromWattsPerMeterKelvin(double.CreateChecked(value));
+            => ThermalConductivity.FromWattsPerMeterKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalConductivity.FromWattsPerMeterKelvin(value.ToDouble(null));
+            => ThermalConductivity.FromWattsPerMeterKelvin(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs
index 6b90922967..df46662a52 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs
@@ -32,81 +32,81 @@ namespace UnitsNet.NumberExtensions.NumberToThermalInsulance
     /// </summary>
     public static class NumberToThermalInsulanceExtensions
     {
-        /// <inheritdoc cref="ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(double)" />
+        /// <inheritdoc cref="ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(QuantityValue)" />
         public static ThermalInsulance HourSquareFeetDegreesFahrenheitPerBtu<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(double.CreateChecked(value));
+            => ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(value.ToDouble(null));
+            => ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double)" />
+        /// <inheritdoc cref="ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(QuantityValue)" />
         public static ThermalInsulance SquareCentimeterHourDegreesCelsiusPerKilocalorie<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double.CreateChecked(value));
+            => ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(value.ToDouble(null));
+            => ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(double)" />
+        /// <inheritdoc cref="ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(QuantityValue)" />
         public static ThermalInsulance SquareCentimeterKelvinsPerWatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(double.CreateChecked(value));
+            => ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(value.ToDouble(null));
+            => ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(double)" />
+        /// <inheritdoc cref="ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(QuantityValue)" />
         public static ThermalInsulance SquareMeterDegreesCelsiusPerWatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(double.CreateChecked(value));
+            => ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(value.ToDouble(null));
+            => ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(double)" />
+        /// <inheritdoc cref="ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(QuantityValue)" />
         public static ThermalInsulance SquareMeterKelvinsPerKilowatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(double.CreateChecked(value));
+            => ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(value.ToDouble(null));
+            => ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ThermalInsulance.FromSquareMeterKelvinsPerWatt(double)" />
+        /// <inheritdoc cref="ThermalInsulance.FromSquareMeterKelvinsPerWatt(QuantityValue)" />
         public static ThermalInsulance SquareMeterKelvinsPerWatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalInsulance.FromSquareMeterKelvinsPerWatt(double.CreateChecked(value));
+            => ThermalInsulance.FromSquareMeterKelvinsPerWatt(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalInsulance.FromSquareMeterKelvinsPerWatt(value.ToDouble(null));
+            => ThermalInsulance.FromSquareMeterKelvinsPerWatt(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(double)" />
+        /// <inheritdoc cref="ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(QuantityValue)" />
         public static ThermalInsulance SquareMillimeterKelvinsPerWatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(double.CreateChecked(value));
+            => ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(value.ToDouble(null));
+            => ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
index b2c18e4c12..d8e96cfa92 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
@@ -32,26 +32,26 @@ namespace UnitsNet.NumberExtensions.NumberToThermalResistance
     /// </summary>
     public static class NumberToThermalResistanceExtensions
     {
-        /// <inheritdoc cref="ThermalResistance.FromDegreesCelsiusPerWatt(double)" />
+        /// <inheritdoc cref="ThermalResistance.FromDegreesCelsiusPerWatt(QuantityValue)" />
         public static ThermalResistance DegreesCelsiusPerWatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalResistance.FromDegreesCelsiusPerWatt(double.CreateChecked(value));
+            => ThermalResistance.FromDegreesCelsiusPerWatt(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalResistance.FromDegreesCelsiusPerWatt(value.ToDouble(null));
+            => ThermalResistance.FromDegreesCelsiusPerWatt(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="ThermalResistance.FromKelvinsPerWatt(double)" />
+        /// <inheritdoc cref="ThermalResistance.FromKelvinsPerWatt(QuantityValue)" />
         public static ThermalResistance KelvinsPerWatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => ThermalResistance.FromKelvinsPerWatt(double.CreateChecked(value));
+            => ThermalResistance.FromKelvinsPerWatt(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => ThermalResistance.FromKelvinsPerWatt(value.ToDouble(null));
+            => ThermalResistance.FromKelvinsPerWatt(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
index 8fcea0a9be..8d828bb31f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
@@ -32,279 +32,301 @@ namespace UnitsNet.NumberExtensions.NumberToTorque
     /// </summary>
     public static class NumberToTorqueExtensions
     {
-        /// <inheritdoc cref="Torque.FromGramForceCentimeters(double)" />
+        /// <inheritdoc cref="Torque.FromGramForceCentimeters(QuantityValue)" />
         public static Torque GramForceCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromGramForceCentimeters(double.CreateChecked(value));
+            => Torque.FromGramForceCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromGramForceCentimeters(value.ToDouble(null));
+            => Torque.FromGramForceCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromGramForceMeters(double)" />
+        /// <inheritdoc cref="Torque.FromGramForceMeters(QuantityValue)" />
         public static Torque GramForceMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromGramForceMeters(double.CreateChecked(value));
+            => Torque.FromGramForceMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromGramForceMeters(value.ToDouble(null));
+            => Torque.FromGramForceMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromGramForceMillimeters(double)" />
+        /// <inheritdoc cref="Torque.FromGramForceMillimeters(QuantityValue)" />
         public static Torque GramForceMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromGramForceMillimeters(double.CreateChecked(value));
+            => Torque.FromGramForceMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromGramForceMillimeters(value.ToDouble(null));
+            => Torque.FromGramForceMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromKilogramForceCentimeters(double)" />
+        /// <inheritdoc cref="Torque.FromKilogramForceCentimeters(QuantityValue)" />
         public static Torque KilogramForceCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromKilogramForceCentimeters(double.CreateChecked(value));
+            => Torque.FromKilogramForceCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromKilogramForceCentimeters(value.ToDouble(null));
+            => Torque.FromKilogramForceCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromKilogramForceMeters(double)" />
+        /// <inheritdoc cref="Torque.FromKilogramForceMeters(QuantityValue)" />
         public static Torque KilogramForceMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromKilogramForceMeters(double.CreateChecked(value));
+            => Torque.FromKilogramForceMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromKilogramForceMeters(value.ToDouble(null));
+            => Torque.FromKilogramForceMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromKilogramForceMillimeters(double)" />
+        /// <inheritdoc cref="Torque.FromKilogramForceMillimeters(QuantityValue)" />
         public static Torque KilogramForceMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromKilogramForceMillimeters(double.CreateChecked(value));
+            => Torque.FromKilogramForceMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromKilogramForceMillimeters(value.ToDouble(null));
+            => Torque.FromKilogramForceMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromKilonewtonCentimeters(double)" />
+        /// <inheritdoc cref="Torque.FromKilonewtonCentimeters(QuantityValue)" />
         public static Torque KilonewtonCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromKilonewtonCentimeters(double.CreateChecked(value));
+            => Torque.FromKilonewtonCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromKilonewtonCentimeters(value.ToDouble(null));
+            => Torque.FromKilonewtonCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromKilonewtonMeters(double)" />
+        /// <inheritdoc cref="Torque.FromKilonewtonMeters(QuantityValue)" />
         public static Torque KilonewtonMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromKilonewtonMeters(double.CreateChecked(value));
+            => Torque.FromKilonewtonMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromKilonewtonMeters(value.ToDouble(null));
+            => Torque.FromKilonewtonMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromKilonewtonMillimeters(double)" />
+        /// <inheritdoc cref="Torque.FromKilonewtonMillimeters(QuantityValue)" />
         public static Torque KilonewtonMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromKilonewtonMillimeters(double.CreateChecked(value));
+            => Torque.FromKilonewtonMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromKilonewtonMillimeters(value.ToDouble(null));
+            => Torque.FromKilonewtonMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromKilopoundForceFeet(double)" />
+        /// <inheritdoc cref="Torque.FromKilopoundForceFeet(QuantityValue)" />
         public static Torque KilopoundForceFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromKilopoundForceFeet(double.CreateChecked(value));
+            => Torque.FromKilopoundForceFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromKilopoundForceFeet(value.ToDouble(null));
+            => Torque.FromKilopoundForceFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromKilopoundForceInches(double)" />
+        /// <inheritdoc cref="Torque.FromKilopoundForceInches(QuantityValue)" />
         public static Torque KilopoundForceInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromKilopoundForceInches(double.CreateChecked(value));
+            => Torque.FromKilopoundForceInches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromKilopoundForceInches(value.ToDouble(null));
+            => Torque.FromKilopoundForceInches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromMeganewtonCentimeters(double)" />
+        /// <inheritdoc cref="Torque.FromMeganewtonCentimeters(QuantityValue)" />
         public static Torque MeganewtonCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromMeganewtonCentimeters(double.CreateChecked(value));
+            => Torque.FromMeganewtonCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromMeganewtonCentimeters(value.ToDouble(null));
+            => Torque.FromMeganewtonCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromMeganewtonMeters(double)" />
+        /// <inheritdoc cref="Torque.FromMeganewtonMeters(QuantityValue)" />
         public static Torque MeganewtonMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromMeganewtonMeters(double.CreateChecked(value));
+            => Torque.FromMeganewtonMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromMeganewtonMeters(value.ToDouble(null));
+            => Torque.FromMeganewtonMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromMeganewtonMillimeters(double)" />
+        /// <inheritdoc cref="Torque.FromMeganewtonMillimeters(QuantityValue)" />
         public static Torque MeganewtonMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromMeganewtonMillimeters(double.CreateChecked(value));
+            => Torque.FromMeganewtonMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromMeganewtonMillimeters(value.ToDouble(null));
+            => Torque.FromMeganewtonMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromMegapoundForceFeet(double)" />
+        /// <inheritdoc cref="Torque.FromMegapoundForceFeet(QuantityValue)" />
         public static Torque MegapoundForceFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromMegapoundForceFeet(double.CreateChecked(value));
+            => Torque.FromMegapoundForceFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromMegapoundForceFeet(value.ToDouble(null));
+            => Torque.FromMegapoundForceFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromMegapoundForceInches(double)" />
+        /// <inheritdoc cref="Torque.FromMegapoundForceInches(QuantityValue)" />
         public static Torque MegapoundForceInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromMegapoundForceInches(double.CreateChecked(value));
+            => Torque.FromMegapoundForceInches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromMegapoundForceInches(value.ToDouble(null));
+            => Torque.FromMegapoundForceInches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromNewtonCentimeters(double)" />
+        /// <inheritdoc cref="Torque.FromNewtonCentimeters(QuantityValue)" />
         public static Torque NewtonCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromNewtonCentimeters(double.CreateChecked(value));
+            => Torque.FromNewtonCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromNewtonCentimeters(value.ToDouble(null));
+            => Torque.FromNewtonCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromNewtonMeters(double)" />
+        /// <inheritdoc cref="Torque.FromNewtonMeters(QuantityValue)" />
         public static Torque NewtonMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromNewtonMeters(double.CreateChecked(value));
+            => Torque.FromNewtonMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromNewtonMeters(value.ToDouble(null));
+            => Torque.FromNewtonMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromNewtonMillimeters(double)" />
+        /// <inheritdoc cref="Torque.FromNewtonMillimeters(QuantityValue)" />
         public static Torque NewtonMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromNewtonMillimeters(double.CreateChecked(value));
+            => Torque.FromNewtonMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromNewtonMillimeters(value.ToDouble(null));
+            => Torque.FromNewtonMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromPoundalFeet(double)" />
+        /// <inheritdoc cref="Torque.FromOunceForceFeet(QuantityValue)" />
+        public static Torque OunceForceFeet<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => Torque.FromOunceForceFeet(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => Torque.FromOunceForceFeet(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="Torque.FromOunceForceInches(QuantityValue)" />
+        public static Torque OunceForceInches<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => Torque.FromOunceForceInches(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => Torque.FromOunceForceInches(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="Torque.FromPoundalFeet(QuantityValue)" />
         public static Torque PoundalFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromPoundalFeet(double.CreateChecked(value));
+            => Torque.FromPoundalFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromPoundalFeet(value.ToDouble(null));
+            => Torque.FromPoundalFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromPoundForceFeet(double)" />
+        /// <inheritdoc cref="Torque.FromPoundForceFeet(QuantityValue)" />
         public static Torque PoundForceFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromPoundForceFeet(double.CreateChecked(value));
+            => Torque.FromPoundForceFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromPoundForceFeet(value.ToDouble(null));
+            => Torque.FromPoundForceFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromPoundForceInches(double)" />
+        /// <inheritdoc cref="Torque.FromPoundForceInches(QuantityValue)" />
         public static Torque PoundForceInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromPoundForceInches(double.CreateChecked(value));
+            => Torque.FromPoundForceInches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromPoundForceInches(value.ToDouble(null));
+            => Torque.FromPoundForceInches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromTonneForceCentimeters(double)" />
+        /// <inheritdoc cref="Torque.FromTonneForceCentimeters(QuantityValue)" />
         public static Torque TonneForceCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromTonneForceCentimeters(double.CreateChecked(value));
+            => Torque.FromTonneForceCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromTonneForceCentimeters(value.ToDouble(null));
+            => Torque.FromTonneForceCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromTonneForceMeters(double)" />
+        /// <inheritdoc cref="Torque.FromTonneForceMeters(QuantityValue)" />
         public static Torque TonneForceMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromTonneForceMeters(double.CreateChecked(value));
+            => Torque.FromTonneForceMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromTonneForceMeters(value.ToDouble(null));
+            => Torque.FromTonneForceMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Torque.FromTonneForceMillimeters(double)" />
+        /// <inheritdoc cref="Torque.FromTonneForceMillimeters(QuantityValue)" />
         public static Torque TonneForceMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Torque.FromTonneForceMillimeters(double.CreateChecked(value));
+            => Torque.FromTonneForceMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Torque.FromTonneForceMillimeters(value.ToDouble(null));
+            => Torque.FromTonneForceMillimeters(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs
index 8e0c38ad6f..75a0c33069 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToTurbidity
     /// </summary>
     public static class NumberToTurbidityExtensions
     {
-        /// <inheritdoc cref="Turbidity.FromNTU(double)" />
+        /// <inheritdoc cref="Turbidity.FromNTU(QuantityValue)" />
         public static Turbidity NTU<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Turbidity.FromNTU(double.CreateChecked(value));
+            => Turbidity.FromNTU(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Turbidity.FromNTU(value.ToDouble(null));
+            => Turbidity.FromNTU(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
index 4a1fe53313..14c93e23b1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
@@ -32,15 +32,15 @@ namespace UnitsNet.NumberExtensions.NumberToVitaminA
     /// </summary>
     public static class NumberToVitaminAExtensions
     {
-        /// <inheritdoc cref="VitaminA.FromInternationalUnits(double)" />
+        /// <inheritdoc cref="VitaminA.FromInternationalUnits(QuantityValue)" />
         public static VitaminA InternationalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VitaminA.FromInternationalUnits(double.CreateChecked(value));
+            => VitaminA.FromInternationalUnits(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VitaminA.FromInternationalUnits(value.ToDouble(null));
+            => VitaminA.FromInternationalUnits(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
index 9ccb786e82..f2f26c5fa1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
@@ -32,224 +32,224 @@ namespace UnitsNet.NumberExtensions.NumberToVolumeConcentration
     /// </summary>
     public static class NumberToVolumeConcentrationExtensions
     {
-        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerLiter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerLiter(QuantityValue)" />
         public static VolumeConcentration CentilitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromCentilitersPerLiter(double.CreateChecked(value));
+            => VolumeConcentration.FromCentilitersPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromCentilitersPerLiter(value.ToDouble(null));
+            => VolumeConcentration.FromCentilitersPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerMilliliter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerMilliliter(QuantityValue)" />
         public static VolumeConcentration CentilitersPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromCentilitersPerMilliliter(double.CreateChecked(value));
+            => VolumeConcentration.FromCentilitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromCentilitersPerMilliliter(value.ToDouble(null));
+            => VolumeConcentration.FromCentilitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerLiter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerLiter(QuantityValue)" />
         public static VolumeConcentration DecilitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromDecilitersPerLiter(double.CreateChecked(value));
+            => VolumeConcentration.FromDecilitersPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromDecilitersPerLiter(value.ToDouble(null));
+            => VolumeConcentration.FromDecilitersPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerMilliliter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerMilliliter(QuantityValue)" />
         public static VolumeConcentration DecilitersPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromDecilitersPerMilliliter(double.CreateChecked(value));
+            => VolumeConcentration.FromDecilitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromDecilitersPerMilliliter(value.ToDouble(null));
+            => VolumeConcentration.FromDecilitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromDecimalFractions(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromDecimalFractions(QuantityValue)" />
         public static VolumeConcentration DecimalFractions<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromDecimalFractions(double.CreateChecked(value));
+            => VolumeConcentration.FromDecimalFractions(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromDecimalFractions(value.ToDouble(null));
+            => VolumeConcentration.FromDecimalFractions(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromLitersPerLiter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromLitersPerLiter(QuantityValue)" />
         public static VolumeConcentration LitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromLitersPerLiter(double.CreateChecked(value));
+            => VolumeConcentration.FromLitersPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromLitersPerLiter(value.ToDouble(null));
+            => VolumeConcentration.FromLitersPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromLitersPerMilliliter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromLitersPerMilliliter(QuantityValue)" />
         public static VolumeConcentration LitersPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromLitersPerMilliliter(double.CreateChecked(value));
+            => VolumeConcentration.FromLitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromLitersPerMilliliter(value.ToDouble(null));
+            => VolumeConcentration.FromLitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerLiter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerLiter(QuantityValue)" />
         public static VolumeConcentration MicrolitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromMicrolitersPerLiter(double.CreateChecked(value));
+            => VolumeConcentration.FromMicrolitersPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromMicrolitersPerLiter(value.ToDouble(null));
+            => VolumeConcentration.FromMicrolitersPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerMilliliter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerMilliliter(QuantityValue)" />
         public static VolumeConcentration MicrolitersPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromMicrolitersPerMilliliter(double.CreateChecked(value));
+            => VolumeConcentration.FromMicrolitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromMicrolitersPerMilliliter(value.ToDouble(null));
+            => VolumeConcentration.FromMicrolitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerLiter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerLiter(QuantityValue)" />
         public static VolumeConcentration MillilitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromMillilitersPerLiter(double.CreateChecked(value));
+            => VolumeConcentration.FromMillilitersPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromMillilitersPerLiter(value.ToDouble(null));
+            => VolumeConcentration.FromMillilitersPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerMilliliter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerMilliliter(QuantityValue)" />
         public static VolumeConcentration MillilitersPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromMillilitersPerMilliliter(double.CreateChecked(value));
+            => VolumeConcentration.FromMillilitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromMillilitersPerMilliliter(value.ToDouble(null));
+            => VolumeConcentration.FromMillilitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerLiter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerLiter(QuantityValue)" />
         public static VolumeConcentration NanolitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromNanolitersPerLiter(double.CreateChecked(value));
+            => VolumeConcentration.FromNanolitersPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromNanolitersPerLiter(value.ToDouble(null));
+            => VolumeConcentration.FromNanolitersPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerMilliliter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerMilliliter(QuantityValue)" />
         public static VolumeConcentration NanolitersPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromNanolitersPerMilliliter(double.CreateChecked(value));
+            => VolumeConcentration.FromNanolitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromNanolitersPerMilliliter(value.ToDouble(null));
+            => VolumeConcentration.FromNanolitersPerMilliliter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerBillion(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerBillion(QuantityValue)" />
         public static VolumeConcentration PartsPerBillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromPartsPerBillion(double.CreateChecked(value));
+            => VolumeConcentration.FromPartsPerBillion(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromPartsPerBillion(value.ToDouble(null));
+            => VolumeConcentration.FromPartsPerBillion(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerMillion(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerMillion(QuantityValue)" />
         public static VolumeConcentration PartsPerMillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromPartsPerMillion(double.CreateChecked(value));
+            => VolumeConcentration.FromPartsPerMillion(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromPartsPerMillion(value.ToDouble(null));
+            => VolumeConcentration.FromPartsPerMillion(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerThousand(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerThousand(QuantityValue)" />
         public static VolumeConcentration PartsPerThousand<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromPartsPerThousand(double.CreateChecked(value));
+            => VolumeConcentration.FromPartsPerThousand(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromPartsPerThousand(value.ToDouble(null));
+            => VolumeConcentration.FromPartsPerThousand(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerTrillion(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerTrillion(QuantityValue)" />
         public static VolumeConcentration PartsPerTrillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromPartsPerTrillion(double.CreateChecked(value));
+            => VolumeConcentration.FromPartsPerTrillion(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromPartsPerTrillion(value.ToDouble(null));
+            => VolumeConcentration.FromPartsPerTrillion(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromPercent(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPercent(QuantityValue)" />
         public static VolumeConcentration Percent<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromPercent(double.CreateChecked(value));
+            => VolumeConcentration.FromPercent(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromPercent(value.ToDouble(null));
+            => VolumeConcentration.FromPercent(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerLiter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerLiter(QuantityValue)" />
         public static VolumeConcentration PicolitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromPicolitersPerLiter(double.CreateChecked(value));
+            => VolumeConcentration.FromPicolitersPerLiter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromPicolitersPerLiter(value.ToDouble(null));
+            => VolumeConcentration.FromPicolitersPerLiter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerMilliliter(double)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerMilliliter(QuantityValue)" />
         public static VolumeConcentration PicolitersPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeConcentration.FromPicolitersPerMilliliter(double.CreateChecked(value));
+            => VolumeConcentration.FromPicolitersPerMilliliter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeConcentration.FromPicolitersPerMilliliter(value.ToDouble(null));
+            => VolumeConcentration.FromPicolitersPerMilliliter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
index 82828124f6..b42368dc3b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
@@ -32,609 +32,598 @@ namespace UnitsNet.NumberExtensions.NumberToVolume
     /// </summary>
     public static class NumberToVolumeExtensions
     {
-        /// <inheritdoc cref="Volume.FromAcreFeet(double)" />
+        /// <inheritdoc cref="Volume.FromAcreFeet(QuantityValue)" />
         public static Volume AcreFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromAcreFeet(double.CreateChecked(value));
+            => Volume.FromAcreFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromAcreFeet(value.ToDouble(null));
+            => Volume.FromAcreFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromAuTablespoons(double)" />
+        /// <inheritdoc cref="Volume.FromAuTablespoons(QuantityValue)" />
         public static Volume AuTablespoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromAuTablespoons(double.CreateChecked(value));
+            => Volume.FromAuTablespoons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromAuTablespoons(value.ToDouble(null));
+            => Volume.FromAuTablespoons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromBoardFeet(double)" />
+        /// <inheritdoc cref="Volume.FromBoardFeet(QuantityValue)" />
         public static Volume BoardFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromBoardFeet(double.CreateChecked(value));
+            => Volume.FromBoardFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromBoardFeet(value.ToDouble(null));
+            => Volume.FromBoardFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCentiliters(double)" />
+        /// <inheritdoc cref="Volume.FromCentiliters(QuantityValue)" />
         public static Volume Centiliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCentiliters(double.CreateChecked(value));
+            => Volume.FromCentiliters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCentiliters(value.ToDouble(null));
+            => Volume.FromCentiliters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicCentimeters(double)" />
+        /// <inheritdoc cref="Volume.FromCubicCentimeters(QuantityValue)" />
         public static Volume CubicCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicCentimeters(double.CreateChecked(value));
+            => Volume.FromCubicCentimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicCentimeters(value.ToDouble(null));
+            => Volume.FromCubicCentimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicDecimeters(double)" />
+        /// <inheritdoc cref="Volume.FromCubicDecimeters(QuantityValue)" />
         public static Volume CubicDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicDecimeters(double.CreateChecked(value));
+            => Volume.FromCubicDecimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicDecimeters(value.ToDouble(null));
+            => Volume.FromCubicDecimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicFeet(double)" />
+        /// <inheritdoc cref="Volume.FromCubicFeet(QuantityValue)" />
         public static Volume CubicFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicFeet(double.CreateChecked(value));
+            => Volume.FromCubicFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicFeet(value.ToDouble(null));
+            => Volume.FromCubicFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicHectometers(double)" />
+        /// <inheritdoc cref="Volume.FromCubicHectometers(QuantityValue)" />
         public static Volume CubicHectometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicHectometers(double.CreateChecked(value));
+            => Volume.FromCubicHectometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicHectometers(value.ToDouble(null));
+            => Volume.FromCubicHectometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicInches(double)" />
+        /// <inheritdoc cref="Volume.FromCubicInches(QuantityValue)" />
         public static Volume CubicInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicInches(double.CreateChecked(value));
+            => Volume.FromCubicInches(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicInches(value.ToDouble(null));
+            => Volume.FromCubicInches(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicKilometers(double)" />
+        /// <inheritdoc cref="Volume.FromCubicKilometers(QuantityValue)" />
         public static Volume CubicKilometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicKilometers(double.CreateChecked(value));
+            => Volume.FromCubicKilometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicKilometers(value.ToDouble(null));
+            => Volume.FromCubicKilometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicMeters(double)" />
+        /// <inheritdoc cref="Volume.FromCubicMeters(QuantityValue)" />
         public static Volume CubicMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicMeters(double.CreateChecked(value));
+            => Volume.FromCubicMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicMeters(value.ToDouble(null));
+            => Volume.FromCubicMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicMicrometers(double)" />
+        /// <inheritdoc cref="Volume.FromCubicMicrometers(QuantityValue)" />
         public static Volume CubicMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicMicrometers(double.CreateChecked(value));
+            => Volume.FromCubicMicrometers(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicMicrometers(value.ToDouble(null));
+            => Volume.FromCubicMicrometers(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicMiles(double)" />
+        /// <inheritdoc cref="Volume.FromCubicMiles(QuantityValue)" />
         public static Volume CubicMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicMiles(double.CreateChecked(value));
+            => Volume.FromCubicMiles(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicMiles(value.ToDouble(null));
+            => Volume.FromCubicMiles(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicMillimeters(double)" />
+        /// <inheritdoc cref="Volume.FromCubicMillimeters(QuantityValue)" />
         public static Volume CubicMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicMillimeters(double.CreateChecked(value));
+            => Volume.FromCubicMillimeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicMillimeters(value.ToDouble(null));
+            => Volume.FromCubicMillimeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromCubicYards(double)" />
+        /// <inheritdoc cref="Volume.FromCubicYards(QuantityValue)" />
         public static Volume CubicYards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromCubicYards(double.CreateChecked(value));
+            => Volume.FromCubicYards(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromCubicYards(value.ToDouble(null));
+            => Volume.FromCubicYards(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromDecaliters(double)" />
+        /// <inheritdoc cref="Volume.FromDecaliters(QuantityValue)" />
         public static Volume Decaliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromDecaliters(double.CreateChecked(value));
+            => Volume.FromDecaliters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromDecaliters(value.ToDouble(null));
+            => Volume.FromDecaliters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromDecausGallons(double)" />
+        /// <inheritdoc cref="Volume.FromDecausGallons(QuantityValue)" />
         public static Volume DecausGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromDecausGallons(double.CreateChecked(value));
+            => Volume.FromDecausGallons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromDecausGallons(value.ToDouble(null));
+            => Volume.FromDecausGallons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromDeciliters(double)" />
+        /// <inheritdoc cref="Volume.FromDeciliters(QuantityValue)" />
         public static Volume Deciliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromDeciliters(double.CreateChecked(value));
+            => Volume.FromDeciliters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromDeciliters(value.ToDouble(null));
+            => Volume.FromDeciliters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromDeciusGallons(double)" />
+        /// <inheritdoc cref="Volume.FromDeciusGallons(QuantityValue)" />
         public static Volume DeciusGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromDeciusGallons(double.CreateChecked(value));
+            => Volume.FromDeciusGallons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromDeciusGallons(value.ToDouble(null));
+            => Volume.FromDeciusGallons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromHectocubicFeet(double)" />
-        public static Volume HectocubicFeet<T>(this T value)
-            where T : notnull
-#if NET7_0_OR_GREATER
-            , INumber<T>
-            => Volume.FromHectocubicFeet(double.CreateChecked(value));
-#else
-            , IConvertible
-            => Volume.FromHectocubicFeet(value.ToDouble(null));
-#endif
-
-        /// <inheritdoc cref="Volume.FromHectocubicMeters(double)" />
-        public static Volume HectocubicMeters<T>(this T value)
+        /// <inheritdoc cref="Volume.FromHectoliters(QuantityValue)" />
+        public static Volume Hectoliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromHectocubicMeters(double.CreateChecked(value));
+            => Volume.FromHectoliters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromHectocubicMeters(value.ToDouble(null));
+            => Volume.FromHectoliters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromHectoliters(double)" />
-        public static Volume Hectoliters<T>(this T value)
+        /// <inheritdoc cref="Volume.FromHectousGallons(QuantityValue)" />
+        public static Volume HectousGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromHectoliters(double.CreateChecked(value));
+            => Volume.FromHectousGallons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromHectoliters(value.ToDouble(null));
+            => Volume.FromHectousGallons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromHectousGallons(double)" />
-        public static Volume HectousGallons<T>(this T value)
+        /// <inheritdoc cref="Volume.FromHundredCubicFeet(QuantityValue)" />
+        public static Volume HundredCubicFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromHectousGallons(double.CreateChecked(value));
+            => Volume.FromHundredCubicFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromHectousGallons(value.ToDouble(null));
+            => Volume.FromHundredCubicFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromImperialBeerBarrels(double)" />
+        /// <inheritdoc cref="Volume.FromImperialBeerBarrels(QuantityValue)" />
         public static Volume ImperialBeerBarrels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromImperialBeerBarrels(double.CreateChecked(value));
+            => Volume.FromImperialBeerBarrels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromImperialBeerBarrels(value.ToDouble(null));
+            => Volume.FromImperialBeerBarrels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromImperialGallons(double)" />
+        /// <inheritdoc cref="Volume.FromImperialGallons(QuantityValue)" />
         public static Volume ImperialGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromImperialGallons(double.CreateChecked(value));
+            => Volume.FromImperialGallons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromImperialGallons(value.ToDouble(null));
+            => Volume.FromImperialGallons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromImperialOunces(double)" />
+        /// <inheritdoc cref="Volume.FromImperialOunces(QuantityValue)" />
         public static Volume ImperialOunces<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromImperialOunces(double.CreateChecked(value));
+            => Volume.FromImperialOunces(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromImperialOunces(value.ToDouble(null));
+            => Volume.FromImperialOunces(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromImperialPints(double)" />
+        /// <inheritdoc cref="Volume.FromImperialPints(QuantityValue)" />
         public static Volume ImperialPints<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromImperialPints(double.CreateChecked(value));
+            => Volume.FromImperialPints(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromImperialPints(value.ToDouble(null));
+            => Volume.FromImperialPints(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromImperialQuarts(double)" />
+        /// <inheritdoc cref="Volume.FromImperialQuarts(QuantityValue)" />
         public static Volume ImperialQuarts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromImperialQuarts(double.CreateChecked(value));
+            => Volume.FromImperialQuarts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromImperialQuarts(value.ToDouble(null));
+            => Volume.FromImperialQuarts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromKilocubicFeet(double)" />
-        public static Volume KilocubicFeet<T>(this T value)
+        /// <inheritdoc cref="Volume.FromKiloimperialGallons(QuantityValue)" />
+        public static Volume KiloimperialGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromKilocubicFeet(double.CreateChecked(value));
+            => Volume.FromKiloimperialGallons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromKilocubicFeet(value.ToDouble(null));
+            => Volume.FromKiloimperialGallons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromKilocubicMeters(double)" />
-        public static Volume KilocubicMeters<T>(this T value)
+        /// <inheritdoc cref="Volume.FromKiloliters(QuantityValue)" />
+        public static Volume Kiloliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromKilocubicMeters(double.CreateChecked(value));
+            => Volume.FromKiloliters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromKilocubicMeters(value.ToDouble(null));
+            => Volume.FromKiloliters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromKiloimperialGallons(double)" />
-        public static Volume KiloimperialGallons<T>(this T value)
+        /// <inheritdoc cref="Volume.FromKilousGallons(QuantityValue)" />
+        public static Volume KilousGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromKiloimperialGallons(double.CreateChecked(value));
+            => Volume.FromKilousGallons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromKiloimperialGallons(value.ToDouble(null));
+            => Volume.FromKilousGallons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromKiloliters(double)" />
-        public static Volume Kiloliters<T>(this T value)
+        /// <inheritdoc cref="Volume.FromLiters(QuantityValue)" />
+        public static Volume Liters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromKiloliters(double.CreateChecked(value));
+            => Volume.FromLiters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromKiloliters(value.ToDouble(null));
+            => Volume.FromLiters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromKilousGallons(double)" />
-        public static Volume KilousGallons<T>(this T value)
+        /// <inheritdoc cref="Volume.FromMegaimperialGallons(QuantityValue)" />
+        public static Volume MegaimperialGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromKilousGallons(double.CreateChecked(value));
+            => Volume.FromMegaimperialGallons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromKilousGallons(value.ToDouble(null));
+            => Volume.FromMegaimperialGallons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromLiters(double)" />
-        public static Volume Liters<T>(this T value)
+        /// <inheritdoc cref="Volume.FromMegaliters(QuantityValue)" />
+        public static Volume Megaliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromLiters(double.CreateChecked(value));
+            => Volume.FromMegaliters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromLiters(value.ToDouble(null));
+            => Volume.FromMegaliters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromMegacubicFeet(double)" />
-        public static Volume MegacubicFeet<T>(this T value)
+        /// <inheritdoc cref="Volume.FromMegausGallons(QuantityValue)" />
+        public static Volume MegausGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromMegacubicFeet(double.CreateChecked(value));
+            => Volume.FromMegausGallons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromMegacubicFeet(value.ToDouble(null));
+            => Volume.FromMegausGallons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromMegaimperialGallons(double)" />
-        public static Volume MegaimperialGallons<T>(this T value)
+        /// <inheritdoc cref="Volume.FromMetricCups(QuantityValue)" />
+        public static Volume MetricCups<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromMegaimperialGallons(double.CreateChecked(value));
+            => Volume.FromMetricCups(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromMegaimperialGallons(value.ToDouble(null));
+            => Volume.FromMetricCups(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromMegaliters(double)" />
-        public static Volume Megaliters<T>(this T value)
+        /// <inheritdoc cref="Volume.FromMetricTablespoons(QuantityValue)" />
+        public static Volume MetricTablespoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromMegaliters(double.CreateChecked(value));
+            => Volume.FromMetricTablespoons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromMegaliters(value.ToDouble(null));
+            => Volume.FromMetricTablespoons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromMegausGallons(double)" />
-        public static Volume MegausGallons<T>(this T value)
+        /// <inheritdoc cref="Volume.FromMetricTeaspoons(QuantityValue)" />
+        public static Volume MetricTeaspoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromMegausGallons(double.CreateChecked(value));
+            => Volume.FromMetricTeaspoons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromMegausGallons(value.ToDouble(null));
+            => Volume.FromMetricTeaspoons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromMetricCups(double)" />
-        public static Volume MetricCups<T>(this T value)
+        /// <inheritdoc cref="Volume.FromMicroliters(QuantityValue)" />
+        public static Volume Microliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromMetricCups(double.CreateChecked(value));
+            => Volume.FromMicroliters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromMetricCups(value.ToDouble(null));
+            => Volume.FromMicroliters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromMetricTablespoons(double)" />
-        public static Volume MetricTablespoons<T>(this T value)
+        /// <inheritdoc cref="Volume.FromMilliliters(QuantityValue)" />
+        public static Volume Milliliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromMetricTablespoons(double.CreateChecked(value));
+            => Volume.FromMilliliters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromMetricTablespoons(value.ToDouble(null));
+            => Volume.FromMilliliters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromMetricTeaspoons(double)" />
-        public static Volume MetricTeaspoons<T>(this T value)
+        /// <inheritdoc cref="Volume.FromMillionCubicFeet(QuantityValue)" />
+        public static Volume MillionCubicFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromMetricTeaspoons(double.CreateChecked(value));
+            => Volume.FromMillionCubicFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromMetricTeaspoons(value.ToDouble(null));
+            => Volume.FromMillionCubicFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromMicroliters(double)" />
-        public static Volume Microliters<T>(this T value)
+        /// <inheritdoc cref="Volume.FromNanoliters(QuantityValue)" />
+        public static Volume Nanoliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromMicroliters(double.CreateChecked(value));
+            => Volume.FromNanoliters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromMicroliters(value.ToDouble(null));
+            => Volume.FromNanoliters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromMilliliters(double)" />
-        public static Volume Milliliters<T>(this T value)
+        /// <inheritdoc cref="Volume.FromOilBarrels(QuantityValue)" />
+        public static Volume OilBarrels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromMilliliters(double.CreateChecked(value));
+            => Volume.FromOilBarrels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromMilliliters(value.ToDouble(null));
+            => Volume.FromOilBarrels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromNanoliters(double)" />
-        public static Volume Nanoliters<T>(this T value)
+        /// <inheritdoc cref="Volume.FromThousandCubicFeet(QuantityValue)" />
+        public static Volume ThousandCubicFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromNanoliters(double.CreateChecked(value));
+            => Volume.FromThousandCubicFeet(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromNanoliters(value.ToDouble(null));
+            => Volume.FromThousandCubicFeet(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromOilBarrels(double)" />
-        public static Volume OilBarrels<T>(this T value)
+        /// <inheritdoc cref="Volume.FromThousandCubicMeters(QuantityValue)" />
+        public static Volume ThousandCubicMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromOilBarrels(double.CreateChecked(value));
+            => Volume.FromThousandCubicMeters(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromOilBarrels(value.ToDouble(null));
+            => Volume.FromThousandCubicMeters(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromUkTablespoons(double)" />
+        /// <inheritdoc cref="Volume.FromUkTablespoons(QuantityValue)" />
         public static Volume UkTablespoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromUkTablespoons(double.CreateChecked(value));
+            => Volume.FromUkTablespoons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromUkTablespoons(value.ToDouble(null));
+            => Volume.FromUkTablespoons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromUsBeerBarrels(double)" />
+        /// <inheritdoc cref="Volume.FromUsBeerBarrels(QuantityValue)" />
         public static Volume UsBeerBarrels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromUsBeerBarrels(double.CreateChecked(value));
+            => Volume.FromUsBeerBarrels(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromUsBeerBarrels(value.ToDouble(null));
+            => Volume.FromUsBeerBarrels(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromUsCustomaryCups(double)" />
+        /// <inheritdoc cref="Volume.FromUsCustomaryCups(QuantityValue)" />
         public static Volume UsCustomaryCups<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromUsCustomaryCups(double.CreateChecked(value));
+            => Volume.FromUsCustomaryCups(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromUsCustomaryCups(value.ToDouble(null));
+            => Volume.FromUsCustomaryCups(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromUsGallons(double)" />
+        /// <inheritdoc cref="Volume.FromUsGallons(QuantityValue)" />
         public static Volume UsGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromUsGallons(double.CreateChecked(value));
+            => Volume.FromUsGallons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromUsGallons(value.ToDouble(null));
+            => Volume.FromUsGallons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromUsLegalCups(double)" />
+        /// <inheritdoc cref="Volume.FromUsLegalCups(QuantityValue)" />
         public static Volume UsLegalCups<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromUsLegalCups(double.CreateChecked(value));
+            => Volume.FromUsLegalCups(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromUsLegalCups(value.ToDouble(null));
+            => Volume.FromUsLegalCups(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromUsOunces(double)" />
+        /// <inheritdoc cref="Volume.FromUsOunces(QuantityValue)" />
         public static Volume UsOunces<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromUsOunces(double.CreateChecked(value));
+            => Volume.FromUsOunces(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromUsOunces(value.ToDouble(null));
+            => Volume.FromUsOunces(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromUsPints(double)" />
+        /// <inheritdoc cref="Volume.FromUsPints(QuantityValue)" />
         public static Volume UsPints<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromUsPints(double.CreateChecked(value));
+            => Volume.FromUsPints(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromUsPints(value.ToDouble(null));
+            => Volume.FromUsPints(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromUsQuarts(double)" />
+        /// <inheritdoc cref="Volume.FromUsQuarts(QuantityValue)" />
         public static Volume UsQuarts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromUsQuarts(double.CreateChecked(value));
+            => Volume.FromUsQuarts(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromUsQuarts(value.ToDouble(null));
+            => Volume.FromUsQuarts(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromUsTablespoons(double)" />
+        /// <inheritdoc cref="Volume.FromUsTablespoons(QuantityValue)" />
         public static Volume UsTablespoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromUsTablespoons(double.CreateChecked(value));
+            => Volume.FromUsTablespoons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromUsTablespoons(value.ToDouble(null));
+            => Volume.FromUsTablespoons(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="Volume.FromUsTeaspoons(double)" />
+        /// <inheritdoc cref="Volume.FromUsTeaspoons(QuantityValue)" />
         public static Volume UsTeaspoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => Volume.FromUsTeaspoons(double.CreateChecked(value));
+            => Volume.FromUsTeaspoons(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => Volume.FromUsTeaspoons(value.ToDouble(null));
+            => Volume.FromUsTeaspoons(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
index 6a85e5560b..4ac461924d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
@@ -32,829 +32,862 @@ namespace UnitsNet.NumberExtensions.NumberToVolumeFlow
     /// </summary>
     public static class NumberToVolumeFlowExtensions
     {
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerDay(QuantityValue)" />
         public static VolumeFlow AcreFeetPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromAcreFeetPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromAcreFeetPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromAcreFeetPerDay(value.ToDouble(null));
+            => VolumeFlow.FromAcreFeetPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerHour(QuantityValue)" />
         public static VolumeFlow AcreFeetPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromAcreFeetPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromAcreFeetPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromAcreFeetPerHour(value.ToDouble(null));
+            => VolumeFlow.FromAcreFeetPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerMinute(QuantityValue)" />
         public static VolumeFlow AcreFeetPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromAcreFeetPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromAcreFeetPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromAcreFeetPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromAcreFeetPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerSecond(QuantityValue)" />
         public static VolumeFlow AcreFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromAcreFeetPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromAcreFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromAcreFeetPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromAcreFeetPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerDay(QuantityValue)" />
         public static VolumeFlow CentilitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCentilitersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromCentilitersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCentilitersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromCentilitersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerHour(QuantityValue)" />
         public static VolumeFlow CentilitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCentilitersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromCentilitersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCentilitersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromCentilitersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerMinute(QuantityValue)" />
         public static VolumeFlow CentilitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCentilitersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromCentilitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCentilitersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromCentilitersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerSecond(QuantityValue)" />
         public static VolumeFlow CentilitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCentilitersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromCentilitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCentilitersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromCentilitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicCentimetersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicCentimetersPerMinute(QuantityValue)" />
         public static VolumeFlow CubicCentimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicCentimetersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromCubicCentimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicCentimetersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromCubicCentimetersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicDecimetersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicDecimetersPerMinute(QuantityValue)" />
         public static VolumeFlow CubicDecimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicDecimetersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromCubicDecimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicDecimetersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromCubicDecimetersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerHour(QuantityValue)" />
         public static VolumeFlow CubicFeetPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicFeetPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromCubicFeetPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicFeetPerHour(value.ToDouble(null));
+            => VolumeFlow.FromCubicFeetPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerMinute(QuantityValue)" />
         public static VolumeFlow CubicFeetPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicFeetPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromCubicFeetPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicFeetPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromCubicFeetPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerSecond(QuantityValue)" />
         public static VolumeFlow CubicFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicFeetPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromCubicFeetPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicFeetPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromCubicFeetPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicInchesPerMinute(QuantityValue)" />
+        public static VolumeFlow CubicInchesPerMinute<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => VolumeFlow.FromCubicInchesPerMinute(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => VolumeFlow.FromCubicInchesPerMinute(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicInchesPerSecond(QuantityValue)" />
+        public static VolumeFlow CubicInchesPerSecond<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => VolumeFlow.FromCubicInchesPerSecond(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => VolumeFlow.FromCubicInchesPerSecond(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerDay(QuantityValue)" />
         public static VolumeFlow CubicMetersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicMetersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromCubicMetersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicMetersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromCubicMetersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerHour(QuantityValue)" />
         public static VolumeFlow CubicMetersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicMetersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromCubicMetersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicMetersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromCubicMetersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerMinute(QuantityValue)" />
         public static VolumeFlow CubicMetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicMetersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromCubicMetersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicMetersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromCubicMetersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerSecond(QuantityValue)" />
         public static VolumeFlow CubicMetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicMetersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromCubicMetersPerSecond(QuantityValue.CreateChecked(value));
+#else
+            , IConvertible
+            => VolumeFlow.FromCubicMetersPerSecond(value.ToQuantityValue());
+#endif
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerMinute(QuantityValue)" />
+        public static VolumeFlow CubicMillimetersPerMinute<T>(this T value)
+            where T : notnull
+#if NET7_0_OR_GREATER
+            , INumber<T>
+            => VolumeFlow.FromCubicMillimetersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicMetersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromCubicMillimetersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerSecond(QuantityValue)" />
         public static VolumeFlow CubicMillimetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicMillimetersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromCubicMillimetersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicMillimetersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromCubicMillimetersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerDay(QuantityValue)" />
         public static VolumeFlow CubicYardsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicYardsPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromCubicYardsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicYardsPerDay(value.ToDouble(null));
+            => VolumeFlow.FromCubicYardsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerHour(QuantityValue)" />
         public static VolumeFlow CubicYardsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicYardsPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromCubicYardsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicYardsPerHour(value.ToDouble(null));
+            => VolumeFlow.FromCubicYardsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerMinute(QuantityValue)" />
         public static VolumeFlow CubicYardsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicYardsPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromCubicYardsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicYardsPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromCubicYardsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerSecond(QuantityValue)" />
         public static VolumeFlow CubicYardsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromCubicYardsPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromCubicYardsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromCubicYardsPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromCubicYardsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromDecalitersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecalitersPerDay(QuantityValue)" />
         public static VolumeFlow DecalitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromDecalitersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromDecalitersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromDecalitersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromDecalitersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromDecalitersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecalitersPerHour(QuantityValue)" />
         public static VolumeFlow DecalitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromDecalitersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromDecalitersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromDecalitersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromDecalitersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromDecalitersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecalitersPerMinute(QuantityValue)" />
         public static VolumeFlow DecalitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromDecalitersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromDecalitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromDecalitersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromDecalitersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromDecalitersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecalitersPerSecond(QuantityValue)" />
         public static VolumeFlow DecalitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromDecalitersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromDecalitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromDecalitersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromDecalitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerDay(QuantityValue)" />
         public static VolumeFlow DecilitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromDecilitersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromDecilitersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromDecilitersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromDecilitersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerHour(QuantityValue)" />
         public static VolumeFlow DecilitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromDecilitersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromDecilitersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromDecilitersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromDecilitersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerMinute(QuantityValue)" />
         public static VolumeFlow DecilitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromDecilitersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromDecilitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromDecilitersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromDecilitersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerSecond(QuantityValue)" />
         public static VolumeFlow DecilitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromDecilitersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromDecilitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromDecilitersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromDecilitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromHectolitersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromHectolitersPerDay(QuantityValue)" />
         public static VolumeFlow HectolitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromHectolitersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromHectolitersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromHectolitersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromHectolitersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromHectolitersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromHectolitersPerHour(QuantityValue)" />
         public static VolumeFlow HectolitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromHectolitersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromHectolitersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromHectolitersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromHectolitersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromHectolitersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromHectolitersPerMinute(QuantityValue)" />
         public static VolumeFlow HectolitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromHectolitersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromHectolitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromHectolitersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromHectolitersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromHectolitersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromHectolitersPerSecond(QuantityValue)" />
         public static VolumeFlow HectolitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromHectolitersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromHectolitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromHectolitersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromHectolitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerDay(QuantityValue)" />
         public static VolumeFlow KilolitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromKilolitersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromKilolitersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromKilolitersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromKilolitersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerHour(QuantityValue)" />
         public static VolumeFlow KilolitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromKilolitersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromKilolitersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromKilolitersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromKilolitersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerMinute(QuantityValue)" />
         public static VolumeFlow KilolitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromKilolitersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromKilolitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromKilolitersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromKilolitersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerSecond(QuantityValue)" />
         public static VolumeFlow KilolitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromKilolitersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromKilolitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromKilolitersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromKilolitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromKilousGallonsPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromKilousGallonsPerMinute(QuantityValue)" />
         public static VolumeFlow KilousGallonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromKilousGallonsPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromKilousGallonsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromKilousGallonsPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromKilousGallonsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerDay(QuantityValue)" />
         public static VolumeFlow LitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromLitersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromLitersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromLitersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromLitersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerHour(QuantityValue)" />
         public static VolumeFlow LitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromLitersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromLitersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromLitersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromLitersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerMinute(QuantityValue)" />
         public static VolumeFlow LitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromLitersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromLitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromLitersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromLitersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerSecond(QuantityValue)" />
         public static VolumeFlow LitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromLitersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromLitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromLitersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromLitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerDay(QuantityValue)" />
         public static VolumeFlow MegalitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMegalitersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromMegalitersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMegalitersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromMegalitersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerHour(QuantityValue)" />
         public static VolumeFlow MegalitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMegalitersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromMegalitersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMegalitersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromMegalitersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerMinute(QuantityValue)" />
         public static VolumeFlow MegalitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMegalitersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromMegalitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMegalitersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromMegalitersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerSecond(QuantityValue)" />
         public static VolumeFlow MegalitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMegalitersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromMegalitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMegalitersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromMegalitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerDay(QuantityValue)" />
         public static VolumeFlow MegaukGallonsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMegaukGallonsPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromMegaukGallonsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMegaukGallonsPerDay(value.ToDouble(null));
+            => VolumeFlow.FromMegaukGallonsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerSecond(QuantityValue)" />
         public static VolumeFlow MegaukGallonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMegaukGallonsPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromMegaukGallonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMegaukGallonsPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromMegaukGallonsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMegausGallonsPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegausGallonsPerDay(QuantityValue)" />
         public static VolumeFlow MegausGallonsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMegausGallonsPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromMegausGallonsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMegausGallonsPerDay(value.ToDouble(null));
+            => VolumeFlow.FromMegausGallonsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerDay(QuantityValue)" />
         public static VolumeFlow MicrolitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMicrolitersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromMicrolitersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMicrolitersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromMicrolitersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerHour(QuantityValue)" />
         public static VolumeFlow MicrolitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMicrolitersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromMicrolitersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMicrolitersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromMicrolitersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerMinute(QuantityValue)" />
         public static VolumeFlow MicrolitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMicrolitersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromMicrolitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMicrolitersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromMicrolitersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerSecond(QuantityValue)" />
         public static VolumeFlow MicrolitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMicrolitersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromMicrolitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMicrolitersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromMicrolitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerDay(QuantityValue)" />
         public static VolumeFlow MillilitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMillilitersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromMillilitersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMillilitersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromMillilitersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerHour(QuantityValue)" />
         public static VolumeFlow MillilitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMillilitersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromMillilitersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMillilitersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromMillilitersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerMinute(QuantityValue)" />
         public static VolumeFlow MillilitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMillilitersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromMillilitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMillilitersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromMillilitersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerSecond(QuantityValue)" />
         public static VolumeFlow MillilitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMillilitersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromMillilitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMillilitersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromMillilitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromMillionUsGallonsPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromMillionUsGallonsPerDay(QuantityValue)" />
         public static VolumeFlow MillionUsGallonsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromMillionUsGallonsPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromMillionUsGallonsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromMillionUsGallonsPerDay(value.ToDouble(null));
+            => VolumeFlow.FromMillionUsGallonsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerDay(QuantityValue)" />
         public static VolumeFlow NanolitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromNanolitersPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromNanolitersPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromNanolitersPerDay(value.ToDouble(null));
+            => VolumeFlow.FromNanolitersPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerHour(QuantityValue)" />
         public static VolumeFlow NanolitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromNanolitersPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromNanolitersPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromNanolitersPerHour(value.ToDouble(null));
+            => VolumeFlow.FromNanolitersPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerMinute(QuantityValue)" />
         public static VolumeFlow NanolitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromNanolitersPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromNanolitersPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromNanolitersPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromNanolitersPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerSecond(QuantityValue)" />
         public static VolumeFlow NanolitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromNanolitersPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromNanolitersPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromNanolitersPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromNanolitersPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerDay(QuantityValue)" />
         public static VolumeFlow OilBarrelsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromOilBarrelsPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromOilBarrelsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromOilBarrelsPerDay(value.ToDouble(null));
+            => VolumeFlow.FromOilBarrelsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerHour(QuantityValue)" />
         public static VolumeFlow OilBarrelsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromOilBarrelsPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromOilBarrelsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromOilBarrelsPerHour(value.ToDouble(null));
+            => VolumeFlow.FromOilBarrelsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerMinute(QuantityValue)" />
         public static VolumeFlow OilBarrelsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromOilBarrelsPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromOilBarrelsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromOilBarrelsPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromOilBarrelsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerSecond(QuantityValue)" />
         public static VolumeFlow OilBarrelsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromOilBarrelsPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromOilBarrelsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromOilBarrelsPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromOilBarrelsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerDay(QuantityValue)" />
         public static VolumeFlow UkGallonsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromUkGallonsPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromUkGallonsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromUkGallonsPerDay(value.ToDouble(null));
+            => VolumeFlow.FromUkGallonsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerHour(QuantityValue)" />
         public static VolumeFlow UkGallonsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromUkGallonsPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromUkGallonsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromUkGallonsPerHour(value.ToDouble(null));
+            => VolumeFlow.FromUkGallonsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerMinute(QuantityValue)" />
         public static VolumeFlow UkGallonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromUkGallonsPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromUkGallonsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromUkGallonsPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromUkGallonsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerSecond(QuantityValue)" />
         public static VolumeFlow UkGallonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromUkGallonsPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromUkGallonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromUkGallonsPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromUkGallonsPerSecond(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerDay(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerDay(QuantityValue)" />
         public static VolumeFlow UsGallonsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromUsGallonsPerDay(double.CreateChecked(value));
+            => VolumeFlow.FromUsGallonsPerDay(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromUsGallonsPerDay(value.ToDouble(null));
+            => VolumeFlow.FromUsGallonsPerDay(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerHour(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerHour(QuantityValue)" />
         public static VolumeFlow UsGallonsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromUsGallonsPerHour(double.CreateChecked(value));
+            => VolumeFlow.FromUsGallonsPerHour(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromUsGallonsPerHour(value.ToDouble(null));
+            => VolumeFlow.FromUsGallonsPerHour(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerMinute(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerMinute(QuantityValue)" />
         public static VolumeFlow UsGallonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromUsGallonsPerMinute(double.CreateChecked(value));
+            => VolumeFlow.FromUsGallonsPerMinute(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromUsGallonsPerMinute(value.ToDouble(null));
+            => VolumeFlow.FromUsGallonsPerMinute(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerSecond(double)" />
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerSecond(QuantityValue)" />
         public static VolumeFlow UsGallonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlow.FromUsGallonsPerSecond(double.CreateChecked(value));
+            => VolumeFlow.FromUsGallonsPerSecond(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlow.FromUsGallonsPerSecond(value.ToDouble(null));
+            => VolumeFlow.FromUsGallonsPerSecond(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs
index f77cb69c07..903849d52d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs
@@ -32,26 +32,26 @@ namespace UnitsNet.NumberExtensions.NumberToVolumeFlowPerArea
     /// </summary>
     public static class NumberToVolumeFlowPerAreaExtensions
     {
-        /// <inheritdoc cref="VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(double)" />
+        /// <inheritdoc cref="VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(QuantityValue)" />
         public static VolumeFlowPerArea CubicFeetPerMinutePerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(double.CreateChecked(value));
+            => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(value.ToDouble(null));
+            => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(double)" />
+        /// <inheritdoc cref="VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(QuantityValue)" />
         public static VolumeFlowPerArea CubicMetersPerSecondPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(double.CreateChecked(value));
+            => VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(value.ToDouble(null));
+            => VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
index a2e143dcc6..a816a68fe1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
@@ -32,103 +32,103 @@ namespace UnitsNet.NumberExtensions.NumberToVolumePerLength
     /// </summary>
     public static class NumberToVolumePerLengthExtensions
     {
-        /// <inheritdoc cref="VolumePerLength.FromCubicMetersPerMeter(double)" />
+        /// <inheritdoc cref="VolumePerLength.FromCubicMetersPerMeter(QuantityValue)" />
         public static VolumePerLength CubicMetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumePerLength.FromCubicMetersPerMeter(double.CreateChecked(value));
+            => VolumePerLength.FromCubicMetersPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumePerLength.FromCubicMetersPerMeter(value.ToDouble(null));
+            => VolumePerLength.FromCubicMetersPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerFoot(double)" />
+        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerFoot(QuantityValue)" />
         public static VolumePerLength CubicYardsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumePerLength.FromCubicYardsPerFoot(double.CreateChecked(value));
+            => VolumePerLength.FromCubicYardsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumePerLength.FromCubicYardsPerFoot(value.ToDouble(null));
+            => VolumePerLength.FromCubicYardsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerUsSurveyFoot(double)" />
+        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerUsSurveyFoot(QuantityValue)" />
         public static VolumePerLength CubicYardsPerUsSurveyFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumePerLength.FromCubicYardsPerUsSurveyFoot(double.CreateChecked(value));
+            => VolumePerLength.FromCubicYardsPerUsSurveyFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumePerLength.FromCubicYardsPerUsSurveyFoot(value.ToDouble(null));
+            => VolumePerLength.FromCubicYardsPerUsSurveyFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumePerLength.FromImperialGallonsPerMile(double)" />
+        /// <inheritdoc cref="VolumePerLength.FromImperialGallonsPerMile(QuantityValue)" />
         public static VolumePerLength ImperialGallonsPerMile<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumePerLength.FromImperialGallonsPerMile(double.CreateChecked(value));
+            => VolumePerLength.FromImperialGallonsPerMile(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumePerLength.FromImperialGallonsPerMile(value.ToDouble(null));
+            => VolumePerLength.FromImperialGallonsPerMile(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumePerLength.FromLitersPerKilometer(double)" />
+        /// <inheritdoc cref="VolumePerLength.FromLitersPerKilometer(QuantityValue)" />
         public static VolumePerLength LitersPerKilometer<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumePerLength.FromLitersPerKilometer(double.CreateChecked(value));
+            => VolumePerLength.FromLitersPerKilometer(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumePerLength.FromLitersPerKilometer(value.ToDouble(null));
+            => VolumePerLength.FromLitersPerKilometer(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumePerLength.FromLitersPerMeter(double)" />
+        /// <inheritdoc cref="VolumePerLength.FromLitersPerMeter(QuantityValue)" />
         public static VolumePerLength LitersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumePerLength.FromLitersPerMeter(double.CreateChecked(value));
+            => VolumePerLength.FromLitersPerMeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumePerLength.FromLitersPerMeter(value.ToDouble(null));
+            => VolumePerLength.FromLitersPerMeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumePerLength.FromLitersPerMillimeter(double)" />
+        /// <inheritdoc cref="VolumePerLength.FromLitersPerMillimeter(QuantityValue)" />
         public static VolumePerLength LitersPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumePerLength.FromLitersPerMillimeter(double.CreateChecked(value));
+            => VolumePerLength.FromLitersPerMillimeter(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumePerLength.FromLitersPerMillimeter(value.ToDouble(null));
+            => VolumePerLength.FromLitersPerMillimeter(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumePerLength.FromOilBarrelsPerFoot(double)" />
+        /// <inheritdoc cref="VolumePerLength.FromOilBarrelsPerFoot(QuantityValue)" />
         public static VolumePerLength OilBarrelsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumePerLength.FromOilBarrelsPerFoot(double.CreateChecked(value));
+            => VolumePerLength.FromOilBarrelsPerFoot(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumePerLength.FromOilBarrelsPerFoot(value.ToDouble(null));
+            => VolumePerLength.FromOilBarrelsPerFoot(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumePerLength.FromUsGallonsPerMile(double)" />
+        /// <inheritdoc cref="VolumePerLength.FromUsGallonsPerMile(QuantityValue)" />
         public static VolumePerLength UsGallonsPerMile<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumePerLength.FromUsGallonsPerMile(double.CreateChecked(value));
+            => VolumePerLength.FromUsGallonsPerMile(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumePerLength.FromUsGallonsPerMile(value.ToDouble(null));
+            => VolumePerLength.FromUsGallonsPerMile(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs
index 3f0be5fd73..eb2b89d601 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs
@@ -32,103 +32,103 @@ namespace UnitsNet.NumberExtensions.NumberToVolumetricHeatCapacity
     /// </summary>
     public static class NumberToVolumetricHeatCapacityExtensions
     {
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(double)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(QuantityValue)" />
         public static VolumetricHeatCapacity BtusPerCubicFootDegreeFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(double.CreateChecked(value));
+            => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(value.ToDouble(null));
+            => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(double)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(QuantityValue)" />
         public static VolumetricHeatCapacity CaloriesPerCubicCentimeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(double.CreateChecked(value));
+            => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(value.ToDouble(null));
+            => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(double)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(QuantityValue)" />
         public static VolumetricHeatCapacity JoulesPerCubicMeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(double.CreateChecked(value));
+            => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(value.ToDouble(null));
+            => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(double)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(QuantityValue)" />
         public static VolumetricHeatCapacity JoulesPerCubicMeterKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(double.CreateChecked(value));
+            => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(value.ToDouble(null));
+            => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(double)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(QuantityValue)" />
         public static VolumetricHeatCapacity KilocaloriesPerCubicCentimeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(double.CreateChecked(value));
+            => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(value.ToDouble(null));
+            => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(double)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(QuantityValue)" />
         public static VolumetricHeatCapacity KilojoulesPerCubicMeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(double.CreateChecked(value));
+            => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(value.ToDouble(null));
+            => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(double)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(QuantityValue)" />
         public static VolumetricHeatCapacity KilojoulesPerCubicMeterKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(double.CreateChecked(value));
+            => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(value.ToDouble(null));
+            => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(double)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(QuantityValue)" />
         public static VolumetricHeatCapacity MegajoulesPerCubicMeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(double.CreateChecked(value));
+            => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(value.ToDouble(null));
+            => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(double)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(QuantityValue)" />
         public static VolumetricHeatCapacity MegajoulesPerCubicMeterKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(double.CreateChecked(value));
+            => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(value.ToDouble(null));
+            => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
index 460a3c2a8d..54f3e523cc 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
@@ -32,70 +32,70 @@ namespace UnitsNet.NumberExtensions.NumberToWarpingMomentOfInertia
     /// </summary>
     public static class NumberToWarpingMomentOfInertiaExtensions
     {
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromCentimetersToTheSixth(double)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromCentimetersToTheSixth(QuantityValue)" />
         public static WarpingMomentOfInertia CentimetersToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => WarpingMomentOfInertia.FromCentimetersToTheSixth(double.CreateChecked(value));
+            => WarpingMomentOfInertia.FromCentimetersToTheSixth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => WarpingMomentOfInertia.FromCentimetersToTheSixth(value.ToDouble(null));
+            => WarpingMomentOfInertia.FromCentimetersToTheSixth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromDecimetersToTheSixth(double)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromDecimetersToTheSixth(QuantityValue)" />
         public static WarpingMomentOfInertia DecimetersToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => WarpingMomentOfInertia.FromDecimetersToTheSixth(double.CreateChecked(value));
+            => WarpingMomentOfInertia.FromDecimetersToTheSixth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => WarpingMomentOfInertia.FromDecimetersToTheSixth(value.ToDouble(null));
+            => WarpingMomentOfInertia.FromDecimetersToTheSixth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromFeetToTheSixth(double)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromFeetToTheSixth(QuantityValue)" />
         public static WarpingMomentOfInertia FeetToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => WarpingMomentOfInertia.FromFeetToTheSixth(double.CreateChecked(value));
+            => WarpingMomentOfInertia.FromFeetToTheSixth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => WarpingMomentOfInertia.FromFeetToTheSixth(value.ToDouble(null));
+            => WarpingMomentOfInertia.FromFeetToTheSixth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromInchesToTheSixth(double)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromInchesToTheSixth(QuantityValue)" />
         public static WarpingMomentOfInertia InchesToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => WarpingMomentOfInertia.FromInchesToTheSixth(double.CreateChecked(value));
+            => WarpingMomentOfInertia.FromInchesToTheSixth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => WarpingMomentOfInertia.FromInchesToTheSixth(value.ToDouble(null));
+            => WarpingMomentOfInertia.FromInchesToTheSixth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromMetersToTheSixth(double)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromMetersToTheSixth(QuantityValue)" />
         public static WarpingMomentOfInertia MetersToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => WarpingMomentOfInertia.FromMetersToTheSixth(double.CreateChecked(value));
+            => WarpingMomentOfInertia.FromMetersToTheSixth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => WarpingMomentOfInertia.FromMetersToTheSixth(value.ToDouble(null));
+            => WarpingMomentOfInertia.FromMetersToTheSixth(value.ToQuantityValue());
 #endif
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromMillimetersToTheSixth(double)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromMillimetersToTheSixth(QuantityValue)" />
         public static WarpingMomentOfInertia MillimetersToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
             , INumber<T>
-            => WarpingMomentOfInertia.FromMillimetersToTheSixth(double.CreateChecked(value));
+            => WarpingMomentOfInertia.FromMillimetersToTheSixth(QuantityValue.CreateChecked(value));
 #else
             , IConvertible
-            => WarpingMomentOfInertia.FromMillimetersToTheSixth(value.ToDouble(null));
+            => WarpingMomentOfInertia.FromMillimetersToTheSixth(value.ToQuantityValue());
 #endif
 
     }
diff --git a/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj b/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
index d79cb3901d..3360f648d3 100644
--- a/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
+++ b/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
@@ -2,7 +2,7 @@
   <!-- NuGet properties -->
   <PropertyGroup>
     <PackageId>UnitsNet.NumberExtensions</PackageId>
-    <Version>6.0.0-pre019</Version>
+    <Version>6.0.0-pre021</Version>
     <Authors>Andreas Gullberg Larsen, Lu Li, Jon Suda</Authors>
     <Title>Units.NET NumberExtensions</Title>
     <Description>Adds extension methods to number types to more easily create quantities, such as 5.Meters() instead of Length.FromMeters(5).</Description>
@@ -15,6 +15,7 @@
     <PackageLicenseExpression>MIT-0</PackageLicenseExpression>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>UnitsNet Extensions NumberToExtensions NumberToUnitsExtensions NumberExtensions NumberToUnits convert conversion parse</PackageTags>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
   </PropertyGroup>
 
   <!-- Assembly and msbuild properties -->
@@ -25,6 +26,7 @@
     <FileVersion>$(VersionNoSuffix)</FileVersion> <!-- Match the NuGet version number, except any suffix in the semantic version. -->
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
     <RootNamespace>UnitsNet</RootNamespace>
     <TargetFrameworks>netstandard2.0;net8.0;net9.0;net10.0</TargetFrameworks>
     <IsAotCompatible Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">true</IsAotCompatible>
@@ -34,6 +36,10 @@
     <Folder Include="GeneratedCode\" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">
+    <Compile Remove="ConvertibleExtensions.cs" />
+  </ItemGroup>
+
   <!-- Strong name signing -->
   <PropertyGroup>
     <AssemblyOriginatorKeyFile>../UnitsNet.snk</AssemblyOriginatorKeyFile>
@@ -49,6 +55,11 @@
   <!-- Files to include in nuget package -->
   <ItemGroup>
     <None Include="../Docs/Images/logo-32.png" Pack="true" PackagePath="/" />
+    <None Include="../README.md" Pack="true" PackagePath="/" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="System.Numerics" Condition="'$(TargetFramework)' != 'netstandard2.0'" />
   </ItemGroup>
 
 </Project>
diff --git a/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs
index 78e1e0326b..16787c10d4 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs
@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Globalization;
 using System.IO;
 using System.Text;
 using Newtonsoft.Json;
@@ -12,7 +13,9 @@ namespace UnitsNet.Serialization.JsonNet.Tests
 {
     public class AbbreviatedUnitsConverterTests : JsonNetSerializationTestsBase
     {
-        public AbbreviatedUnitsConverterTests() : base(new AbbreviatedUnitsConverter())
+        public AbbreviatedUnitsConverterTests()
+            : base(new AbbreviatedUnitsConverter(
+                new QuantityValueFormatOptions(QuantityValueSerializationFormat.DoublePrecision, QuantityValueDeserializationFormat.RoundedDouble)))
         {
         }
 
@@ -29,6 +32,18 @@ public void DoubleQuantity_SerializedWithDoubleValueAndAbbreviatedUnit()
             Assert.Equal(expectedJson, json);
         }
 
+        [Fact]
+        public void DoublePrecision_SerializesWith17SignificantDigits()
+        {
+            QuantityValue value = QuantityValue.Parse("1.2345678901234567", CultureInfo.InvariantCulture);
+            var quantity = Mass.FromMilligrams(value);
+            const string expectedJson = """{"Value":1.2345678901234567,"Unit":"mg","Type":"Mass"}""";
+
+            var json = SerializeObject(quantity);
+
+            Assert.Equal(expectedJson, json);
+        }
+
         [Fact]
         public void InterfaceObject_IncludesTypeInformation()
         {
@@ -72,7 +87,7 @@ public void NonNullNullableValueNestedInObject_ExpectJsonUnaffected()
                 NonNullableFrequency = Frequency.FromHertz(10)
             };
 
-            string expectedJson = """{"NullableFrequency":{"Value":10.0,"Unit":"Hz","Type":"Frequency"},"NonNullableFrequency":{"Value":10.0,"Unit":"Hz","Type":"Frequency"}}""";
+            string expectedJson = """{"NullableFrequency":{"Value":10,"Unit":"Hz","Type":"Frequency"},"NonNullableFrequency":{"Value":10,"Unit":"Hz","Type":"Frequency"}}""";
 
             string json = SerializeObject(testObj);
 
@@ -87,7 +102,7 @@ public void NullQuantityNestedInObject_SerializesAsNull()
                 NonNullableFrequency = Frequency.FromHertz(10)
             };
 
-            string expectedJson = """{"NullableFrequency":null,"NonNullableFrequency":{"Value":10.0,"Unit":"Hz","Type":"Frequency"}}""";
+            string expectedJson = """{"NullableFrequency":null,"NonNullableFrequency":{"Value":10,"Unit":"Hz","Type":"Frequency"}}""";
 
             string json = SerializeObject(testObj);
 
@@ -123,6 +138,24 @@ public void Serializing_UnknownQuantity_ThrowsUnitNotFoundException()
             Assert.Throws<UnitNotFoundException>(() => SerializeObject(HowMuch.From(1, HowMuchUnit.Some)));
         }
 
+        [Fact]
+        public void Serializing_CustomQuantity_ReturnsTheExpectedResult()
+        {
+            // Arrange
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
+            unitAbbreviationsCache.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, CultureInfo.InvariantCulture, "s");
+            var settings = new JsonSerializerSettings { Converters = [new AbbreviatedUnitsConverter(new UnitParser(unitAbbreviationsCache))] };
+
+            var quantity = HowMuch.From(1.2, HowMuchUnit.Some);
+            const string expectedJson = """{"Value":1.2,"Unit":"s","Type":"HowMuch"}""";
+
+            // Act
+            var result = JsonConvert.SerializeObject(quantity, settings);
+
+            // Assert
+            Assert.Equal(expectedJson, result);
+        }
+
         #endregion
 
         #region Deserialization tests
@@ -134,7 +167,19 @@ public void DoubleIQuantity_DeserializedFromDoubleValueAndAbbreviatedUnit()
 
             var quantity = DeserializeObject<IQuantity>(json);
             
-            Assert.Equal(1.2, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
+            Assert.Equal(MassUnit.Milligram, quantity.Unit);
+        }
+
+        [Fact]
+        public void DoubleQuantity_DeserializedFromVeryPreciseValueAndAbbreviatedUnit()
+        {
+            var json = """{"Value":12345678901234567890.1234567890123456789,"Unit":"mg","Type":"Mass"}""";
+            var expectedValue = QuantityValue.FromDoubleRounded(1.234567890123456E+19);
+
+            var quantity = DeserializeObject<Mass>(json);
+
+            Assert.Equal(expectedValue, quantity.Value);
             Assert.Equal(MassUnit.Milligram, quantity.Unit);
         }
 
@@ -145,7 +190,7 @@ public void DoubleQuantity_DeserializedFromDoubleValueAndAbbreviatedUnit()
 
             var quantity = DeserializeObject<Mass>(json);
 
-            Assert.Equal(1.2, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
             Assert.Equal(MassUnit.Milligram, quantity.Unit);
         }
 
@@ -156,18 +201,10 @@ public void DoubleIQuantity_DeserializedFromDoubleValueAndNonAmbiguousAbbreviate
 
             var quantity = DeserializeObject<IQuantity>(json);
 
-            Assert.Equal(1.2, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
             Assert.Equal(MassUnit.EarthMass, quantity.Unit);
         }
 
-        [Fact]
-        public void ThrowsAmbiguousUnitParseException_WhenDeserializingAmbiguousAbbreviation_WithoutQuantityType()
-        {
-            var json = """{"Value":1.2,"Unit":"mg"}""";
-
-            Assert.Throws<AmbiguousUnitParseException>(() => DeserializeObject<IQuantity>(json));
-        }
-
         [Fact]
         public void DoubleIQuantity_DeserializedFromDoubleValueAndAbbreviatedUnit_CaseInsensitive()
         {
@@ -175,7 +212,7 @@ public void DoubleIQuantity_DeserializedFromDoubleValueAndAbbreviatedUnit_CaseIn
 
             var quantity = DeserializeObject<IQuantity>(json);
 
-            Assert.Equal(1.2, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
             Assert.Equal(MassUnit.Milligram, quantity.Unit);
         }
 
@@ -187,8 +224,8 @@ public void DoubleIQuantity_DeserializedFromDoubleValueAndAbbreviatedUnit_CaseSe
             var megabar = DeserializeObject<IQuantity>(json);
             var millibar = DeserializeObject<IQuantity>(json.ToLower());
 
-            Assert.Equal(1.2, megabar.Value);
-            Assert.Equal(1.2, millibar.Value);
+            Assert.Equal(1.2m, megabar.Value);
+            Assert.Equal(1.2m, millibar.Value);
             Assert.Equal(PressureUnit.Megabar, megabar.Unit);
             Assert.Equal(PressureUnit.Millibar, millibar.Unit);
         }
@@ -200,10 +237,27 @@ public void Converter_IgnoresUnknownProperties()
 
             var quantity = DeserializeObject<IQuantity>(json);
 
-            Assert.Equal(1.2, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
             Assert.Equal(MassUnit.Milligram, quantity.Unit);
         }
 
+        [Fact]
+        public void Converter_WithAdditionalProperties_AndMissingMemberHandlingAsError_ThrowsJsonException()
+        {
+            var json = """{"Value":1.2,"Something":"Else","Unit":"mg","Type":"Mass"}""";
+            var options = new JsonSerializerSettings { Converters = [new AbbreviatedUnitsConverter()], MissingMemberHandling = MissingMemberHandling.Error};
+            
+            Assert.Throws<JsonException>(() => JsonConvert.DeserializeObject<Mass>(json, options));
+        }
+
+        [Fact]
+        public void Deserializing_FromUnknownQuantityType_ThrowsQuantityNotFoundException()
+        {
+            var json = """{"Value":1.2,"Unit":"mg","Type":"invalid"}""";
+
+            Assert.Throws<QuantityNotFoundException>(() => DeserializeObject<Mass>(json));
+        }
+
         [Fact]
         public void Deserializing_FromUnknownUnitForTargetQuantity_ThrowsUnitsNotFoundException()
         {
@@ -253,7 +307,7 @@ public void DoubleIQuantity_DeserializedFromQuotedDoubleValueAndAbbreviatedUnit(
 
             var quantity = DeserializeObject<IQuantity>(json);
 
-            Assert.Equal(1.2, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
             Assert.Equal(MassUnit.Milligram, quantity.Unit);
         }
 
@@ -264,7 +318,7 @@ public void DoubleQuantity_DeserializedFromQuotedDoubleValueAndAbbreviatedUnit()
 
             var quantity = DeserializeObject<Mass>(json);
 
-            Assert.Equal(1.2, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
             Assert.Equal(MassUnit.Milligram, quantity.Unit);
         }
 
@@ -297,7 +351,7 @@ public void DoubleBaseUnitQuantity_DeserializedFromValueAndNoUnit()
 
             var quantity = DeserializeObject<IQuantity>(json);
 
-            Assert.Equal(1.2, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
             Assert.Equal(Mass.BaseUnit, quantity.Unit);
         }
 
@@ -308,7 +362,7 @@ public void DoubleBaseUnitIQuantity_DeserializedFromValueAndNoUnit()
 
             var quantity = DeserializeObject<Mass>(json);
 
-            Assert.Equal(1.2, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
             Assert.Equal(Mass.BaseUnit, quantity.Unit);
         }
 
@@ -334,6 +388,38 @@ public void DoubleZeroBaseQuantity_DeserializedFromEmptyInput()
             Assert.Equal(Mass.BaseUnit, quantity.Unit);
         }
         
+        [Fact]
+        public void Deserializing_CustomQuantity_ReturnsTheExpectedResult()
+        {
+            // Arrange
+            var unitAbbreviationsCache = new UnitAbbreviationsCache([HowMuch.Info]);
+            unitAbbreviationsCache.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, CultureInfo.InvariantCulture, "s");
+            var settings = new JsonSerializerSettings { Converters = [new AbbreviatedUnitsConverter(new UnitParser(unitAbbreviationsCache))] };
+
+            const string json = """{"Value":1.2,"Unit":"s","Type":"HowMuch"}""";
+            var expectedQuantity = HowMuch.From(1.2, HowMuchUnit.Some);
+
+            // Act
+            HowMuch result = JsonConvert.DeserializeObject<HowMuch>(json, settings);
+
+            // Assert
+            Assert.Equal(expectedQuantity, result);
+        }
+        
+        [Fact]
+        public void Deserializing_NullValue_ThrowsJsonSerializationException()
+        {
+            const string json = """{"Value":null,"Unit":"mg","Type":"Mass"}""";
+            Assert.Throws<JsonSerializationException>(() => DeserializeObject<Mass>(json));
+        }
+
+        [Fact]
+        public void Deserializing_EmptyValue_ThrowsJsonSerializationException()
+        {
+            const string json = """{"Value":"","Unit":"mg","Type":"Mass"}""";
+            Assert.Throws<JsonSerializationException>(() => DeserializeObject<Mass>(json));
+        }
+        
         #endregion
     }
 }
diff --git a/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterWithCustomFormatOptionsTests.cs b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterWithCustomFormatOptionsTests.cs
new file mode 100644
index 0000000000..f040059e8a
--- /dev/null
+++ b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterWithCustomFormatOptionsTests.cs
@@ -0,0 +1,17 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.Serialization.JsonNet.Value;
+
+namespace UnitsNet.Serialization.JsonNet.Tests;
+
+public class AbbreviatedUnitsConverterWithCustomFormatOptionsTests : JsonNetSerializationTestsBase
+{
+    public AbbreviatedUnitsConverterWithCustomFormatOptionsTests()
+        : base(
+            new AbbreviatedUnitsConverter(
+                new QuantityValueFormatOptions(QuantityValueSerializationFormat.Custom, QuantityValueDeserializationFormat.Custom)),
+            new QuantityValueFractionalNotationConverter())
+    {
+    }
+}
diff --git a/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterWithDecimalPrecisionFormatOptionsTests.cs b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterWithDecimalPrecisionFormatOptionsTests.cs
new file mode 100644
index 0000000000..84557e306b
--- /dev/null
+++ b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterWithDecimalPrecisionFormatOptionsTests.cs
@@ -0,0 +1,69 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Globalization;
+using Newtonsoft.Json;
+using UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.Serialization.JsonNet.Tests;
+
+public class AbbreviatedUnitsConverterWithDecimalPrecisionFormatOptionsTests : JsonNetSerializationTestsBase
+{
+    public AbbreviatedUnitsConverterWithDecimalPrecisionFormatOptionsTests()
+        : base(new AbbreviatedUnitsConverter(new QuantityValueFormatOptions
+        {
+            // all values should be serialized as G29
+            SerializationFormat = QuantityValueSerializationFormat.DecimalPrecision,
+            // all values should be converted from their exact decimal representation (any number of digits)
+            DeserializationFormat = QuantityValueDeserializationFormat.ExactNumber
+        }))
+    {
+    }
+
+    [Fact]
+    public void LargeQuantity_SerializedWithHighPrecisionAndAbbreviatedUnit()
+    {
+        // Arrange
+        var value = Mass.FromMilligrams(QuantityValue.Parse("12345678901234567890.1234567890123456789", CultureInfo.InvariantCulture));
+        const string expectedJson = """{"Value":12345678901234567890.123456789,"Unit":"mg","Type":"Mass"}""";
+
+        // Act
+        var result = SerializeObject(value);
+
+        //Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Quantity_DeserializedFromVeryPreciseValueAndAbbreviatedUnit()
+    {
+        // Arrange
+        const string json = """{"Value":12345678901234567890.1234567890123456789,"Unit":"mg","Type":"Mass"}""";
+        var expectedValue = QuantityValue.Parse("12345678901234567890.1234567890123456789", CultureInfo.InvariantCulture);
+
+        // Act
+        Mass quantity = DeserializeObject<Mass>(json);
+
+        //Assert
+        Assert.Equal(expectedValue, quantity.Value);
+        Assert.Equal(MassUnit.Milligram, quantity.Unit);
+    }
+
+    [Fact]
+    public void Deserializing_WithNullValue_ThrowsJsonSerializationException()
+    {
+        const string json = """{"Value":null,"Unit":"mg","Type":"Mass"}""";
+
+        Assert.Throws<JsonSerializationException>(() => DeserializeObject<Mass>(json));
+    }
+
+    [Fact]
+    public void Deserializing_WithEmptyValue_ThrowsJsonSerializationException()
+    {
+        const string json = """{"Value":"","Unit":"mg","Type":"Mass"}""";
+
+        Assert.Throws<FormatException>(() => DeserializeObject<Mass>(json));
+    }
+}
diff --git a/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterWithRoundTripFormatOptionsTests.cs b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterWithRoundTripFormatOptionsTests.cs
new file mode 100644
index 0000000000..235cd01967
--- /dev/null
+++ b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterWithRoundTripFormatOptionsTests.cs
@@ -0,0 +1,203 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using Newtonsoft.Json;
+using UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.Serialization.JsonNet.Tests;
+
+public class AbbreviatedUnitsConverterWithRoundTripFormatOptionsTests : JsonNetSerializationTestsBase
+{
+    public AbbreviatedUnitsConverterWithRoundTripFormatOptionsTests()
+        : base(new AbbreviatedUnitsConverter(
+            new QuantityValueFormatOptions(QuantityValueSerializationFormat.RoundTrip, QuantityValueDeserializationFormat.RoundTrip)))
+    {
+    }
+
+    [Fact]
+    public void Serializing_Quantity_WithDecimalNotationAndAbbreviatedUnit()
+    {
+        // Arrange
+        var value = Mass.FromMilligrams(4.25m);
+        const string expectedJson = """{"Value":4.25,"Unit":"mg","Type":"Mass"}""";
+
+        // Act
+        var result = SerializeObject(value);
+
+        //Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_LargeQuantity_WithHighPrecisionAndAbbreviatedUnit()
+    {
+        // Arrange
+        var value = Mass.FromMilligrams(QuantityValue.Parse("12345678901234567890.1234567890123456789", CultureInfo.InvariantCulture));
+        const string expectedJson = """{"Value":12345678901234567890.1234567890123456789,"Unit":"mg","Type":"Mass"}""";
+
+        // Act
+        var result = SerializeObject(value);
+
+        //Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_Quantity_WithFractionalFormatAndAbbreviatedUnit()
+    {
+        // Arrange
+        var value = Mass.FromMilligrams(QuantityValue.FromTerms(1, 3));
+        const string expectedJson = """{"Value":"1/3","Unit":"mg","Type":"Mass"}""";
+
+        // Act
+        var result = SerializeObject(value);
+
+        //Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Theory]
+    [InlineData(510)]
+    [InlineData(511)]
+    public void Serialize_VeryLargeDecimalNumber_ReturnsTheExpectedResult(int nbZeros)
+    {
+        // Arrange: 10000[...]4.2 (written as a decimal, with all its zeros)
+        var valueString = $"1{new string(Enumerable.Repeat('0', nbZeros).ToArray())}4.2";
+        var value = Mass.FromMilligrams(QuantityValue.FromTerms(42 + BigInteger.Pow(10, nbZeros + 2), 10));
+        var expectedJson = $$"""{"Value":{{valueString}},"Unit":"mg","Type":"Mass"}""";
+
+        // Act
+        var result = SerializeObject(value);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serialize_VeryPreciseDecimalNumber_ReturnsTheExpectedResult()
+    {
+        // Arrange: 4.2e-255 (written as a decimal, with all its zeros)
+        var valueString = "0." + new string(Enumerable.Repeat('0', 512).ToArray()) + "42";
+        var expectedJson = $$"""{"Value":{{valueString}},"Unit":"mg","Type":"Mass"}""";
+        var value = Mass.FromMilligrams(QuantityValue.FromPowerOfTen(42, -514));
+
+        // Act
+        var result = SerializeObject(value);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serialize_VeryLargeFractionalNumber_ReturnsTheExpectedResult()
+    {
+        // Arrange: (1/3)e256 (written as a fraction, with all its zeros)
+        var numeratorString = new string(Enumerable.Repeat('0', 255).Prepend('1').ToArray());
+        var expectedJson = $$"""{"Value":"{{numeratorString}}/3","Unit":"mg","Type":"Mass"}""";
+        var value = Mass.FromMilligrams(QuantityValue.FromPowerOfTen(1, 3, 255));
+
+        // Act
+        var result = SerializeObject(value);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_NaN_WithSymbolAndAbbreviatedUnit()
+    {
+        // Arrange
+        var value = Mass.FromMilligrams(QuantityValue.NaN);
+        const string expectedJson = """{"Value":"NaN","Unit":"mg","Type":"Mass"}""";
+
+        // Act
+        var result = SerializeObject(value);
+
+        //Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_PositiveInfinity_WithSymbolAndAbbreviatedUnit()
+    {
+        // Arrange
+        var value = Mass.FromMilligrams(QuantityValue.PositiveInfinity);
+        const string expectedJson = """{"Value":"Infinity","Unit":"mg","Type":"Mass"}""";
+
+        // Act
+        var result = SerializeObject(value);
+
+        //Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_NegativeInfinity_WithSymbolAndAbbreviatedUnit()
+    {
+        // Arrange
+        var value = Mass.FromMilligrams(QuantityValue.NegativeInfinity);
+        const string expectedJson = """{"Value":"-Infinity","Unit":"mg","Type":"Mass"}""";
+
+        // Act
+        var result = SerializeObject(value);
+
+        //Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Deserializing_Quantity_FromVeryPreciseValueAndAbbreviatedUnit()
+    {
+        // Arrange
+        const string json = """{"Value":12345678901234567890.1234567890123456789,"Unit":"mg","Type":"Mass"}""";
+        var expectedValue = QuantityValue.Parse("12345678901234567890.1234567890123456789", CultureInfo.InvariantCulture);
+
+        // Act
+        Mass quantity = DeserializeObject<Mass>(json);
+
+        //Assert
+        Assert.Equal(expectedValue, quantity.Value);
+        Assert.Equal(MassUnit.Milligram, quantity.Unit);
+    }
+
+    [Fact]
+    public void Deserializing_Quantity_WithFractionalFormatAndAbbreviatedUnit()
+    {
+        // Arrange
+        const string json = """{"Value":"1/3","Unit":"mg","Type":"Mass"}""";
+        var expectedValue = QuantityValue.FromTerms(1, 3);
+
+        // Act
+        Mass quantity = DeserializeObject<Mass>(json);
+
+        //Assert
+        Assert.Equal(expectedValue, quantity.Value);
+        Assert.Equal(MassUnit.Milligram, quantity.Unit);
+    }
+
+    [Fact]
+    public void Deserializing_NullValue_ThrowsJsonSerializationException()
+    {
+        const string json = """{"Value":null,"Unit":"mg","Type":"Mass"}""";
+        Assert.Throws<JsonSerializationException>(() => DeserializeObject<Mass>(json));
+    }
+
+    [Fact]
+    public void Deserializing_EmptyValue_ThrowsJsonSerializationException()
+    {
+        const string json = """{"Value":"","Unit":"mg","Type":"Mass"}""";
+        Assert.Throws<FormatException>(() => DeserializeObject<Mass>(json));
+    }
+
+    [Fact]
+    public void Deserializing_InvalidFractionFormat_ThrowsFormatException()
+    {
+        const string json = """{"Value":"1/3invalid","Unit":"mg","Type":"Mass"}""";
+        Assert.Throws<FormatException>(() => DeserializeObject<Mass>(json));
+    }
+}
diff --git a/UnitsNet.Serialization.JsonNet.Tests/CustomQuantities/HowMuchTests.cs b/UnitsNet.Serialization.JsonNet.Tests/CustomQuantities/HowMuchTests.cs
index 93741a89d1..e66a3059bd 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/CustomQuantities/HowMuchTests.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/CustomQuantities/HowMuchTests.cs
@@ -1,4 +1,4 @@
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using UnitsNet.Tests.CustomQuantities;
 using Xunit;
 
diff --git a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObject.cs b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObject.cs
index a33729602a..8e8e4baca3 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObject.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObject.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet.Serialization.JsonNet.Tests.Infrastructure
diff --git a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithIComparable.cs b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithIComparable.cs
index 41473629f9..11ea87fd02 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithIComparable.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithIComparable.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithThreeIComparable.cs b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithThreeIComparable.cs
index 7806e248fd..ea242517db 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithThreeIComparable.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithThreeIComparable.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithValueAndUnitAsIComparable.cs b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithValueAndUnitAsIComparable.cs
index 314e2c1aa2..2dea9b418f 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithValueAndUnitAsIComparable.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithValueAndUnitAsIComparable.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithValueAsIComparable.cs b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithValueAsIComparable.cs
index 7f458475c5..fb6c7f2320 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithValueAsIComparable.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/TestObjectWithValueAsIComparable.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/UnitsNetJsonBaseTest.cs b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/UnitsNetJsonBaseTest.cs
index d961281e30..a83ee8aeb8 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/UnitsNetJsonBaseTest.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/Infrastructure/UnitsNetJsonBaseTest.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Newtonsoft.Json;
diff --git a/UnitsNet.Serialization.JsonNet.Tests/JsonNetSerializationTestsBase.cs b/UnitsNet.Serialization.JsonNet.Tests/JsonNetSerializationTestsBase.cs
index 7430a7201c..edfb54e994 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/JsonNetSerializationTestsBase.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/JsonNetSerializationTestsBase.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Linq;
diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj b/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
index dddf08cd08..8203d80098 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
@@ -1,8 +1,10 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(TargetFrameworks);net48</TargetFrameworks>
     <RootNamespace>UnitsNet.Serialization.JsonNet.Tests</RootNamespace>
+    <LangVersion>latest</LangVersion>
     <IsTestProject>true</IsTestProject>
     <NoWarn>CS0618</NoWarn>
   </PropertyGroup>
@@ -14,6 +16,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="JetBrains.Annotations" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="xunit" />
     <PackageReference Include="xunit.runner.visualstudio">
diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
index b07bf62272..141cd78be3 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -7,6 +7,7 @@
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
+using UnitsNet.Tests.CustomQuantities;
 using Xunit;
 
 namespace UnitsNet.Serialization.JsonNet.Tests
@@ -34,7 +35,7 @@ public void UnitsNetBaseJsonConverter_ConvertIQuantity_throws_ArgumentNullExcept
         {
             var result = Assert.Throws<ArgumentNullException>(() => _sut.Test_ConvertDoubleIQuantity(null));
 
-            Assert.Equal("Value cannot be null. (Parameter 'quantity')", result.Message);
+            Assert.Equal("quantity", result.ParamName);
         }
 
         [Fact]
@@ -67,6 +68,39 @@ public void UnitsNetBaseJsonConverter_ConvertValueUnit_throws_UnitsNetException_
             Assert.Equal("PowerUnit Watt", result.Data["type"]);
         }
 
+        [Fact]
+        public void UnitsNetBaseJsonConverter_ConvertValueUnit_throws_UnitsNetException_when_registered_quantity_cannot_be_instantiated()
+        {
+            var sut = new TestQuantityConverter();
+            sut.RegisterCustomType(typeof(IQuantity), typeof(HowMuchUnit));
+
+            var result = Assert.Throws<UnitsNetException>(() => sut.Test_ConvertValueUnit("HowMuchUnit.Some", 10.2365));
+
+            Assert.Contains("Unable to instantiate registered quantity type", result.Message);
+            Assert.Equal("JsonNetRegisteredQuantityInstantiationFailed", result.Data[UnitsNetException.ErrorCodeDataKey]);
+            Assert.Equal(typeof(IQuantity), result.Data["quantityType"]);
+            Assert.Equal(typeof(HowMuchUnit), result.Data["unitType"]);
+            Assert.Equal(HowMuchUnit.Some, result.Data["unit"]);
+            Assert.NotNull(result.InnerException);
+        }
+
+        [Fact]
+        public void UnitsNetBaseJsonConverter_ConvertValueUnit_wraps_exception_when_registered_quantity_constructor_throws()
+        {
+            var sut = new TestQuantityConverter();
+            sut.RegisterCustomType(typeof(ThrowingQuantity), typeof(HowMuchUnit));
+
+            var result = Assert.Throws<UnitsNetException>(() => sut.Test_ConvertValueUnit("HowMuchUnit.Some", 10.2365));
+
+            Assert.Contains("Unable to instantiate registered quantity type", result.Message);
+            Assert.Equal("JsonNetRegisteredQuantityInstantiationFailed", result.Data[UnitsNetException.ErrorCodeDataKey]);
+            Assert.Equal(typeof(ThrowingQuantity), result.Data["quantityType"]);
+            Assert.Equal(typeof(HowMuchUnit), result.Data["unitType"]);
+            Assert.Equal(HowMuchUnit.Some, result.Data["unit"]);
+            Assert.NotNull(result.InnerException);
+            Assert.Contains("Thrown from registered quantity constructor.", result.InnerException.ToString());
+        }
+
         [Fact]
         public void UnitsNetBaseJsonConverter_CreateLocalSerializer_works_as_expected()
         {
@@ -226,5 +260,29 @@ private class TestConverter : UnitsNetBaseJsonConverter<string>
                 return (result.Unit, result.Value);
             }
         }
+
+        private class TestQuantityConverter : UnitsNetBaseJsonConverter<IQuantity>
+        {
+            public override bool CanRead => false;
+            public override bool CanWrite => false;
+            public override void WriteJson(JsonWriter writer, IQuantity value, JsonSerializer serializer) => throw new NotImplementedException();
+            public override IQuantity ReadJson(JsonReader reader, Type objectType, IQuantity existingValue, bool hasExistingValue, JsonSerializer serializer) => throw new NotImplementedException();
+
+            public IQuantity Test_ConvertValueUnit(string unit, double value) => ConvertValueUnit(new ValueUnit {Unit = unit, Value = value});
+        }
+
+        private class ThrowingQuantity : IQuantity
+        {
+            public ThrowingQuantity(QuantityValue value, HowMuchUnit unit)
+            {
+                throw new UnitsNetException("Thrown from registered quantity constructor.");
+            }
+
+            public QuantityInfo QuantityInfo => throw new NotImplementedException();
+            public Enum Unit => throw new NotImplementedException();
+            public QuantityValue Value => throw new NotImplementedException();
+            public UnitKey UnitKey => throw new NotImplementedException();
+            public string ToString(string format, IFormatProvider formatProvider) => throw new NotImplementedException();
+        }
     }
 }
diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetIComparableJsonConverterTest.cs b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetIComparableJsonConverterTest.cs
index ccbbc220e1..001c20215f 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetIComparableJsonConverterTest.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetIComparableJsonConverterTest.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -51,7 +51,7 @@ public void UnitsNetIComparableJsonConverter_ReadJson_throws_ArgumentNullExcepti
         {
             var exception = Assert.Throws<ArgumentNullException>(() => _sut.ReadJson(reader, typeof(IQuantity), null, false, serializer));
 
-            Assert.Equal($"Value cannot be null. (Parameter '{paramName}')", exception.Message);
+            Assert.Equal(paramName, exception.ParamName);
         }
 
         [Fact]
diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetIQuantityJsonConverterTest.cs b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetIQuantityJsonConverterTest.cs
index 613f791cef..daf3f82ba7 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetIQuantityJsonConverterTest.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetIQuantityJsonConverterTest.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -38,7 +38,7 @@ public void
         {
             var exception = Assert.Throws<ArgumentNullException>(() => _sut.WriteJson(writer, Power.FromWatts(10D), serializer));
 
-            Assert.Equal($"Value cannot be null. (Parameter '{parameterName}')", exception.Message);
+            Assert.Equal(parameterName, exception.ParamName);
         }
 
         [Fact]
@@ -86,7 +86,7 @@ public void UnitsNetIQuantityJsonConverter_ReadJson_throws_ArgumentNullException
         {
             var exception = Assert.Throws<ArgumentNullException>(() => _sut.ReadJson(reader, typeof(IQuantity), null, false, serializer));
 
-            Assert.Equal($"Value cannot be null. (Parameter '{paramName}')", exception.Message);
+            Assert.Equal(paramName, exception.ParamName);
         }
 
         [Fact]
@@ -118,7 +118,7 @@ public void UnitsNetIQuantityJsonConverter_ReadJson_works_as_expected()
 
             Assert.NotNull(result);
             Assert.IsType<Power>(result);
-            Assert.Equal(10.3654, ((Power)result).Watts);
+            Assert.Equal(10.3654m, ((Power)result).Watts);
         }
     }
 }
diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonDeserializationTests.cs b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonDeserializationTests.cs
index 0660deb3f7..cc53362a4e 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonDeserializationTests.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonDeserializationTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Newtonsoft.Json;
@@ -296,7 +296,7 @@ public void CanDeserializeDoubleQuantityJson()
                 """;
 
             Length deserialized = DeserializeObject<Length>(json);
-            Assert.Equal(10.5, deserialized.Value);
+            Assert.Equal(10.5m, deserialized.Value);
             Assert.Equal(LengthUnit.Centimeter, deserialized.Unit);
         }
 
@@ -308,7 +308,6 @@ public void CanDeserializeDoubleQuantityJson()
         ///     discriminator to describe whether the value was double or decimal.
         ///     <br/><br/>
         ///     <see cref="double"/> based quantities were serialized with <see cref="UnitsNetBaseJsonConverter{T}.ValueUnit"/> DTO, with <c>double Value</c> + <c>string Unit</c> properties.<br />
-        ///     <see cref="decimal"/> based quantities were serialized with <see cref="UnitsNetBaseJsonConverter{T}.ExtendedValueUnit"/> DTO, extending with ValueString and ValueType properties.
         /// </summary>
         [Fact]
         public void CanDeserializeLegacyDecimalQuantityJson()
@@ -324,7 +323,7 @@ public void CanDeserializeLegacyDecimalQuantityJson()
                 """;
 
             Information deserialized = DeserializeObject<Information>(json);
-            Assert.Equal(10.5, deserialized.Value);
+            Assert.Equal(10.5m, deserialized.Value);
             Assert.Equal(InformationUnit.Kilobyte, deserialized.Unit);
         }
 
diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonSerializationTests.cs b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonSerializationTests.cs
index ea72ae3c67..c8aed31ea7 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonSerializationTests.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetJsonSerializationTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using UnitsNet.Serialization.JsonNet.Tests.Infrastructure;
diff --git a/UnitsNet.Serialization.JsonNet.Tests/Value/QuantityValueFractionalNotationConverterTests.cs b/UnitsNet.Serialization.JsonNet.Tests/Value/QuantityValueFractionalNotationConverterTests.cs
new file mode 100644
index 0000000000..c0b4c33545
--- /dev/null
+++ b/UnitsNet.Serialization.JsonNet.Tests/Value/QuantityValueFractionalNotationConverterTests.cs
@@ -0,0 +1,298 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+using UnitsNet.Serialization.JsonNet.Value;
+using Xunit;
+
+namespace UnitsNet.Serialization.JsonNet.Tests.Value;
+
+[TestSubject(typeof(QuantityValueFractionalNotationConverter))]
+public class QuantityValueFractionalNotationConverterTests
+{
+    private static JsonSerializerSettings CreateDefaultOptions()
+    {
+        var options = new JsonSerializerSettings();
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Default);
+        return options;
+    }
+
+    [Fact]
+    public void Serialize_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var expected = """{"N":42,"D":10}""";
+        QuantityValue value = 4.2m;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        var result = JsonConvert.SerializeObject(value, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serialize_WithReduction_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var expected = """{"N":21,"D":5}""";
+        QuantityValue value = 4.2m;
+        var options = new JsonSerializerSettings();
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Reducing);
+
+        // Act
+        var result = JsonConvert.SerializeObject(value, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serialize_Zero_WithDefaultSettings_ReturnsBothTerms()
+    {
+        // Arrange
+        var expected = """{"N":0,"D":1}""";
+        var value = QuantityValue.Zero;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        var result = JsonConvert.SerializeObject(value, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serialize_Zero_IgnoringDefaultValues_ReturnsAnEmptyObject()
+    {
+        // Arrange
+        var expected = "{}";
+        var value = QuantityValue.Zero;
+        JsonSerializerSettings options = CreateDefaultOptions();
+        options.DefaultValueHandling = DefaultValueHandling.Ignore;
+
+        // Act
+        var result = JsonConvert.SerializeObject(value, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serialize_IntegerNumber_WithIgnoreCondition_WhenWritingDefault_ReturnsTheNumerator()
+    {
+        // Arrange
+        var expected = """{"N":5}""";
+        QuantityValue value = 5;
+        JsonSerializerSettings options = CreateDefaultOptions();
+        options.DefaultValueHandling = DefaultValueHandling.Ignore;
+
+        // Act
+        var result = JsonConvert.SerializeObject(value, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serialize_DecimalNumber_WithIgnoreCondition_WhenWritingDefault_ReturnsBothTerms()
+    {
+        // Arrange
+        var expected = """{"N":42,"D":10}""";
+        QuantityValue value = 4.2m;
+        JsonSerializerSettings options = CreateDefaultOptions();
+        options.DefaultValueHandling = DefaultValueHandling.Ignore;
+
+        // Act
+        var result = JsonConvert.SerializeObject(value, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_ValidJson_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = """{"N":42,"D":10}""";
+        QuantityValue expected = 4.2m;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonConvert.DeserializeObject<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_ValidJson_WithCaseInsensitiveMatching_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = """{"N":42,"d":10}""";
+        QuantityValue expected = 4.2m;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonConvert.DeserializeObject<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_ValidJson_WithAdditionalProperties_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = """{"N":42,"something":2,"D":10}""";
+        QuantityValue expected = 4.2m;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonConvert.DeserializeObject<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_Json_WithAdditionalProperties_AndMissingMemberHandlingAsError_ThrowsJsonException()
+    {
+        // Arrange
+        var json = """{"N":42,"something":2,"D":10}""";
+        JsonSerializerSettings options = CreateDefaultOptions();
+        options.MissingMemberHandling = MissingMemberHandling.Error;
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonConvert.DeserializeObject<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserialize_ValidJsonWithQuotedTerms_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = """{"N":"42","D":"10"}""";
+        QuantityValue expected = 4.2m;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonConvert.DeserializeObject<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithoutDenominator_ReturnsTheExpectedIntegerValue()
+    {
+        // Arrange
+        var json = """{"N":42}""";
+        QuantityValue expected = 42;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonConvert.DeserializeObject<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithoutNumeratorAndDenominator_ReturnsZero()
+    {
+        // Arrange
+        var json = "{}";
+        QuantityValue expected = QuantityValue.Zero;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonConvert.DeserializeObject<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithoutNumeratorAndNonZeroDenominator_ReturnsZero()
+    {
+        // Arrange
+        var json = """{"D":1}""";
+        QuantityValue expected = QuantityValue.Zero;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonConvert.DeserializeObject<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithoutNumeratorAndZeroDenominator_ReturnsNaN()
+    {
+        // Arrange
+        var json = """{"D":0}""";
+        QuantityValue expected = QuantityValue.NaN;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonConvert.DeserializeObject<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithoutPositiveNumeratorAndZeroDenominator_ReturnsPositiveInfinity()
+    {
+        // Arrange
+        var json = """{"N":1,"D":0}""";
+        QuantityValue expected = QuantityValue.PositiveInfinity;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonConvert.DeserializeObject<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithNegativeNumeratorAndZeroDenominator_ReturnsNegativeInfinity()
+    {
+        // Arrange
+        var json = """{"N":-1,"D":0}""";
+        QuantityValue expected = QuantityValue.NegativeInfinity;
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonConvert.DeserializeObject<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserializing_WithInvalidString_ThrowsFormatException()
+    {
+        // Arrange
+        var json = """{"N":"4invalid2","D":"10"}""";
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Assert
+        Assert.Throws<JsonSerializationException>(() => JsonConvert.DeserializeObject<QuantityValue>(json, options));
+    }
+
+    [Theory]
+    [InlineData("43")]
+    public void Deserializing_WithInvalidJsonString_ThrowsJsonException(string invalidJson)
+    {
+        // Arrange
+        JsonSerializerSettings options = CreateDefaultOptions();
+
+        // Assert
+        Assert.Throws<JsonSerializationException>(() => JsonConvert.DeserializeObject<QuantityValue>(invalidJson, options));
+    }
+}
diff --git a/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs b/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs
index 10fc5b9b19..3d9dfbb8b6 100644
--- a/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs
@@ -1,9 +1,6 @@
-using System;
+using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using Newtonsoft.Json;
-using UnitsNet.Units;
 
 namespace UnitsNet.Serialization.JsonNet
 {
@@ -14,7 +11,7 @@ namespace UnitsNet.Serialization.JsonNet
     /// <example>
     /// <code>
     /// {
-    ///     "Value": 1.20,
+    ///     "Value": 1.2,
     ///     "Unit": "mg",
     ///     "Type": "Mass"
     /// }
@@ -27,42 +24,85 @@ public class AbbreviatedUnitsConverter : NullableQuantityConverter<IQuantity>
         private const string UnitProperty = "Unit";
         private const string TypeProperty = "Type";
 
-        private readonly UnitAbbreviationsCache _abbreviations;
+        private readonly QuantityValueSerializationFormat _valueSerializationFormat;
+        private readonly QuantityValueDeserializationFormat _valueDeserializationFormat;
         private readonly IEqualityComparer<string?> _propertyComparer;
-        private readonly IReadOnlyDictionary<string, QuantityInfo> _quantities;
-        private readonly UnitParser _unitParser;
 
+        private readonly UnitParser _unitParser;
+        
         /// <summary>
-        ///     Construct a converter using the default list of quantities (case insensitive) and unit abbreviation provider
+        ///     Initializes a new instance of the <see cref="AbbreviatedUnitsConverter" /> class using the default
+        ///     case-insensitive comparer and the specified <see cref="QuantityValueFormatOptions" />.
         /// </summary>
-        public AbbreviatedUnitsConverter()
-            : this(StringComparer.OrdinalIgnoreCase)
+        /// <param name="valueFormatOptions">
+        ///     The options for formatting quantity values during serialization and deserialization.
+        ///     Defaults to a new instance of <see cref="QuantityValueFormatOptions" /> if not specified.
+        /// </param>
+        public AbbreviatedUnitsConverter(QuantityValueFormatOptions valueFormatOptions = new())
+            : this(StringComparer.OrdinalIgnoreCase, valueFormatOptions)
         {
         }
 
         /// <summary>
-        ///     Construct a converter using the default list of quantities and unit abbreviation provider
+        ///     Initializes a new instance of the <see cref="AbbreviatedUnitsConverter" /> class.
         /// </summary>
-        /// <param name="comparer">The comparer used to compare the property/quantity names (e.g. StringComparer.OrdinalIgnoreCase) </param>
-        public AbbreviatedUnitsConverter(IEqualityComparer<string?> comparer)
-            : this(Quantity.ByName, UnitsNetSetup.Default.UnitAbbreviations, comparer)
+        /// <param name="comparer">
+        ///     The equality comparer used to compare property or quantity names, such as
+        ///     <see cref="StringComparer.OrdinalIgnoreCase" />.
+        /// </param>
+        /// <param name="valueFormatOptions">
+        ///     Options for formatting the quantity value during serialization and deserialization.
+        /// </param>
+        /// <remarks>
+        ///     The <paramref name="comparer" /> is used exclusively for property name matching.
+        ///     Quantity names are matched using the default comparer of <see cref="Quantity.ByName" />,
+        ///     which is currently <see cref="StringComparer.OrdinalIgnoreCase" />.
+        /// </remarks>
+        public AbbreviatedUnitsConverter(IEqualityComparer<string?> comparer, QuantityValueFormatOptions valueFormatOptions = new())
+            : this(UnitParser.Default, comparer, valueFormatOptions)
         {
         }
 
         /// <summary>
-        ///     Construct a converter using the provided map of {name : quantity}
+        ///     Initializes a new instance of the <see cref="AbbreviatedUnitsConverter" /> class.
         /// </summary>
-        /// <param name="quantities">The dictionary of quantity names</param>
-        /// <param name="abbreviations">The unit abbreviations used for the serialization </param>
-        /// <param name="propertyComparer">The comparer used to compare the property names (e.g. StringComparer.OrdinalIgnoreCase) </param>
-        public AbbreviatedUnitsConverter(IReadOnlyDictionary<string, QuantityInfo> quantities, UnitAbbreviationsCache abbreviations, IEqualityComparer<string?> propertyComparer)
+        /// <param name="unitParser">
+        ///     The <see cref="UnitParser" /> used for deserializing an abbreviation back into its
+        ///     corresponding unit.
+        /// </param>
+        /// <param name="valueFormatOptions">
+        ///     The options specifying how values should be serialized and deserialized.
+        ///     Defaults to a new instance of <see cref="QuantityValueFormatOptions" /> if not provided.
+        /// </param>
+        public AbbreviatedUnitsConverter(UnitParser unitParser, QuantityValueFormatOptions valueFormatOptions = new())
+            : this(unitParser, StringComparer.OrdinalIgnoreCase, valueFormatOptions)
         {
-            _quantities = quantities;
-            _abbreviations = abbreviations;
-            _propertyComparer = propertyComparer;
-            _unitParser = new UnitParser(abbreviations);
         }
 
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="AbbreviatedUnitsConverter" /> class.
+        /// </summary>
+        /// <param name="unitParser">
+        ///     The <see cref="UnitParser" /> used for deserializing an abbreviation back into its
+        ///     corresponding unit.
+        /// </param>
+        /// <param name="propertyComparer">
+        ///     The comparer used to compare property names during serialization and deserialization.
+        ///     For example, <see cref="StringComparer.OrdinalIgnoreCase" /> can be used for case-insensitive comparisons.
+        /// </param>
+        /// <param name="valueFormatOptions">
+        ///     The options specifying how values should be serialized and deserialized.
+        ///     Defaults to a new instance of <see cref="QuantityValueFormatOptions" /> if not provided.
+        /// </param>
+        public AbbreviatedUnitsConverter(UnitParser unitParser, IEqualityComparer<string?> propertyComparer,
+            QuantityValueFormatOptions valueFormatOptions = new())
+        {
+            _unitParser = unitParser ?? throw new ArgumentNullException(nameof(unitParser));
+            _propertyComparer = propertyComparer?? throw new ArgumentNullException(nameof(propertyComparer));
+            _valueSerializationFormat = valueFormatOptions.SerializationFormat;
+            _valueDeserializationFormat = valueFormatOptions.DeserializationFormat;
+        }
+        
         /// <inheritdoc />
         public override void WriteJson(JsonWriter writer, IQuantity? quantity, JsonSerializer serializer)
         {
@@ -71,47 +111,125 @@ public override void WriteJson(JsonWriter writer, IQuantity? quantity, JsonSeria
                 writer.WriteNull();
                 return;
             }
+            
+            writer.WriteStartObject();
 
-            var unit = GetUnitAbbreviation(quantity.Unit); // by default this should be equal to quantity.ToString("a", CultureInfo.InvariantCulture);
-            var quantityType = GetQuantityType(quantity); // by default this should be equal to quantity.QuantityInfo.Name
+            WriteValueProperty(writer, quantity, serializer);
+            WriteUnitProperty(writer, quantity, serializer);
+            WriteTypeProperty(writer, quantity, serializer);
 
-            writer.WriteStartObject();
+            writer.WriteEndObject();
+        }
 
-            // write the 'Value' using the actual type
+        /// <summary>
+        /// Writes the 'Value' property of the specified quantity to the JSON output.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> used to write the JSON data.</param>
+        /// <param name="quantity">The <see cref="IQuantity"/> instance whose 'Value' property is to be written.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <remarks>
+        /// This method writes the numerical value of the quantity using the general ("G") format and invariant culture.
+        /// It can be overridden to customize the representation of the value, such as using a fractional format or a different numeric type.
+        /// </remarks>
+        protected virtual void WriteValueProperty(JsonWriter writer, IQuantity quantity, JsonSerializer serializer)
+        {
             writer.WritePropertyName(ValueProperty);
-            writer.WriteValue((double)quantity.Value);
+            writer.WriteValue(quantity.Value, serializer, _valueSerializationFormat);
+        }
 
-            //  write the 'Unit' abbreviation
+        /// <summary>
+        /// Writes the 'Unit' property to the JSON output.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> used to write the JSON content.</param>
+        /// <param name="quantity">The <see cref="IQuantity"/> instance whose unit is being written.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <remarks>
+        /// This method can be overridden to customize the format or type of the 'Unit' property in the JSON payload.
+        /// </remarks>
+        protected virtual void WriteUnitProperty(JsonWriter writer, IQuantity quantity, JsonSerializer serializer)
+        {
             writer.WritePropertyName(UnitProperty);
-            writer.WriteValue(unit);
+            writer.WriteValue(_unitParser.Abbreviations.GetDefaultAbbreviation(quantity.UnitKey, serializer.Culture));
+        }
 
-            // write the quantity 'Type'
+        /// <summary>
+        ///     Writes the 'Type' property.
+        /// </summary>
+        /// <param name="writer">The JsonWriter to write to.</param>
+        /// <param name="quantity"></param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <remarks>
+        ///     This method can be overridden to customize the payload type or format.
+        /// </remarks>
+        protected virtual void WriteTypeProperty(JsonWriter writer, IQuantity quantity, JsonSerializer serializer)
+        {
             writer.WritePropertyName(TypeProperty);
-            writer.WriteValue(quantityType);
+#pragma warning disable CS0618 // Type or member is obsolete
+            writer.WriteValue(quantity.QuantityInfo.Name);
+#pragma warning restore CS0618 // Type or member is obsolete
+        }
 
-            writer.WriteEndObject();
+        /// <summary>
+        ///     Reads the "Value" property from the JSON reader and converts it to a <see cref="QuantityValue" />.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader" /> to read the value from.</param>
+        /// <param name="objectType">The type of the object to deserialize.</param>
+        /// <param name="serializer">The <see cref="JsonSerializer" /> used for deserialization.</param>
+        /// <returns>The parsed <see cref="QuantityValue" />.</returns>
+        /// <exception cref="JsonSerializationException">
+        ///     Thrown if the value cannot be read or converted to a <see cref="QuantityValue" />.
+        /// </exception>
+        protected virtual QuantityValue ReadValueProperty(JsonReader reader, Type objectType, JsonSerializer serializer)
+        {
+            return reader.ReadValue(serializer, _valueDeserializationFormat);
         }
 
         /// <summary>
-        ///     Get the string representation associated with the given quantity
+        ///     Reads the unit abbreviation property from the JSON reader.
         /// </summary>
-        /// <param name="quantity">The quantity that is being serialized</param>
-        /// <returns>The string representation associated with the given quantity</returns>
-        protected string GetQuantityType(IQuantity quantity)
+        /// <param name="reader">The <see cref="JsonReader" /> instance to read from.</param>
+        /// <param name="objectType">The type of the object to deserialize.</param>
+        /// <param name="serializer">The <see cref="JsonSerializer"/> used for deserialization.</param>
+        /// <returns>
+        ///     The unit abbreviation as a <see cref="string" /> if present; otherwise, <c>null</c>.
+        /// </returns>
+        /// <exception cref="JsonReaderException">
+        ///     Thrown if the JSON reader is not positioned at a valid string value for the unit abbreviation.
+        /// </exception>
+        protected virtual string? ReadUnitAbbreviationProperty(JsonReader reader, Type objectType, JsonSerializer serializer)
         {
-            return _quantities[quantity.QuantityInfo.Name].Name;
+            return reader.ReadAsString();
         }
 
+        /// <summary>
+        ///     Reads the quantity name property from the JSON reader.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader" /> instance used to read the JSON data.</param>
+        /// <param name="objectType">The type of the object to deserialize.</param>
+        /// <param name="serializer">The <see cref="JsonSerializer"/> used for deserialization.</param>
+        /// <returns>
+        ///     The quantity name as a string, or <c>null</c> if the value is not present or cannot be read.
+        /// </returns>
+        /// <remarks>
+        ///     This method is used to extract the name of the quantity type from the JSON data.
+        ///     The quantity name is typically used to identify the type of measurement (e.g., "Mass", "Length").
+        /// </remarks>
+        protected virtual string? ReadQuantityNameProperty(JsonReader reader, Type objectType, JsonSerializer serializer)
+        {
+            return reader.ReadAsString();
+        }
+        
         /// <inheritdoc />
         public override IQuantity? ReadJson(JsonReader reader, Type objectType, IQuantity? existingValue, bool hasExistingValue, JsonSerializer serializer)
         {
-            QuantityInfo? quantityInfo;
             if (reader.TokenType == JsonToken.Null)
             {
-                return TryGetQuantity(objectType.Name, out quantityInfo) ? quantityInfo.Zero : default;
+                return objectType == typeof(IQuantity) || typeof(IQuantity).IsAssignableFrom(Nullable.GetUnderlyingType(objectType))
+                    ? null
+                    : _unitParser.Quantities.GetQuantityInfo(objectType).Zero;
             }
 
-            string? valueToken = null;
+            QuantityValue value = QuantityValue.Zero;
             string? unitAbbreviation = null, quantityName = null;
             if (reader.TokenType == JsonToken.StartObject)
             {
@@ -122,201 +240,53 @@ protected string GetQuantityType(IQuantity quantity)
                         var propertyName = reader.Value as string;
                         if (_propertyComparer.Equals(propertyName, ValueProperty))
                         {
-                            valueToken = reader.ReadAsString();
+                            value = ReadValueProperty(reader, objectType, serializer);
                         }
                         else if (_propertyComparer.Equals(propertyName, UnitProperty))
                         {
-                            unitAbbreviation = reader.ReadAsString();
+                            unitAbbreviation = ReadUnitAbbreviationProperty(reader, objectType, serializer);
                         }
                         else if (_propertyComparer.Equals(propertyName, TypeProperty))
                         {
-                            quantityName = reader.ReadAsString();
+                            quantityName = ReadQuantityNameProperty(reader, objectType, serializer);
                         }
-                        else
+                        else if (serializer.MissingMemberHandling == MissingMemberHandling.Ignore)
                         {
                             reader.Skip();
                         }
+                        else
+                        {
+                            throw new JsonException($"'{propertyName}' was no found in the list of members of '{objectType}'.");
+                        }
                     }
                 }
             }
-
-
-            Enum unit;
-            if (quantityName is null)
+            
+            UnitInfo unitInfo;
+            if (quantityName != null && unitAbbreviation != null)
             {
-                if (TryGetQuantity(objectType.Name, out quantityInfo))
-                {
-                    unit = GetUnitOrDefault(unitAbbreviation, quantityInfo);
-                }
-                else if (unitAbbreviation != null) // the objectType doesn't match any concrete quantity type (likely it is an IQuantity)
-                {
-                    // failing back to an exhaustive search (it is possible that this converter was created with a short-list of non-ambiguous quantities
-                    unit = FindUnit(unitAbbreviation, out quantityInfo);
-                }
-                else
-                {
-                    throw new FormatException("No unit abbreviation found in JSON.");
-                }
+                unitInfo = _unitParser.GetUnitFromAbbreviation(quantityName, unitAbbreviation, serializer.Culture);
             }
-            else
+            else if (unitAbbreviation != null)
             {
-                quantityInfo = GetQuantityInfo(quantityName);
-                unit = GetUnitOrDefault(unitAbbreviation, quantityInfo);
+                unitInfo = objectType == typeof(IQuantity)
+                    ? _unitParser.GetUnitFromAbbreviation(unitAbbreviation, serializer.Culture)
+                    : _unitParser.GetUnitFromAbbreviation(Nullable.GetUnderlyingType(objectType) ?? objectType, unitAbbreviation, serializer.Culture);
             }
-
-            double value;
-            if (valueToken is null)
+            else if (quantityName != null)
             {
-                value = default;
+                unitInfo = _unitParser.Quantities.GetQuantityByName(quantityName).BaseUnitInfo;
             }
-            else
+            else if (objectType != typeof(IQuantity))
             {
-                value = double.Parse(valueToken, CultureInfo.InvariantCulture);
+                unitInfo = _unitParser.Quantities.GetQuantityInfo(Nullable.GetUnderlyingType(objectType) ?? objectType).BaseUnitInfo;
             }
-
-            return Quantity.From(value, unit);
-        }
-
-        /// <summary>
-        ///     Attempt to find a unique (non-ambiguous) unit matching the provided abbreviation.
-        ///     <remarks>
-        ///         An exhaustive search using all quantities is very likely to fail with an
-        ///         <exception cref="AmbiguousUnitParseException" />, so make sure you're using the minimum set of supported quantities.
-        ///     </remarks>
-        /// </summary>
-        /// <param name="unitAbbreviation">The unit abbreviation </param>
-        /// <param name="quantityInfo">The quantity type where the resulting unit was found </param>
-        /// <returns>The unit associated with the given <paramref name="unitAbbreviation" /></returns>
-        /// <exception cref="AmbiguousUnitParseException"></exception>
-        /// <exception cref="UnitNotFoundException"></exception>
-        protected virtual Enum FindUnit(string unitAbbreviation, out QuantityInfo quantityInfo)
-        {
-            if (unitAbbreviation is null) // we could assume string.Empty instead
-            {
-                throw new UnitNotFoundException("The unit abbreviation and quantity type cannot both be null");
-            }
-
-            Enum? unit = null;
-            QuantityInfo? tempQuantityInfo = default;
-            foreach (var targetQuantity in _quantities.Values)
-            {
-                if (!TryParse(unitAbbreviation, targetQuantity, out var unitMatched))
-                {
-                    continue;
-                }
-
-                if (unit != null &&
-                    !(targetQuantity == tempQuantityInfo && Equals(unit, unitMatched))) // it is possible to have "synonyms": e.g. "Mass" and "Weight"
-                {
-                    throw new AmbiguousUnitParseException($"Multiple quantities found matching the provided abbreviation: {unit}, {unitMatched}");
-                }
-
-                tempQuantityInfo = targetQuantity;
-                unit = unitMatched;
-            }
-
-            if (unit is null || tempQuantityInfo is null)
-            {
-                throw new UnitNotFoundException($"No quantity found with abbreviation [{unitAbbreviation}].");
-            }
-
-            quantityInfo = tempQuantityInfo;
-            return unit;
-        }
-
-
-        /// <summary>
-        ///     Get the unit abbreviation associated with the given unit
-        /// </summary>
-        /// <param name="unit">Unit enum value, such as <see cref="MassUnit.Kilogram" />.</param>
-        /// <returns>The default abbreviation as provided by the associated <see cref="UnitAbbreviationsCache" /></returns>
-        protected string GetUnitAbbreviation(Enum unit)
-        {
-            return _abbreviations.GetDefaultAbbreviation(unit, CultureInfo.InvariantCulture);
-        }
-
-        /// <summary>
-        ///     If the unit abbreviation is unspecified: returns the default (BaseUnit) unit for the
-        ///     <paramref name="quantityInfo" />, otherwise attempts to <see cref="Parse" /> the
-        ///     <paramref name="unitAbbreviation" />
-        /// </summary>
-        /// <param name="unitAbbreviation">
-        ///     Unit abbreviation, such as "kg" or "m" for <see cref="MassUnit.Kilogram" /> and
-        ///     <see cref="LengthUnit.Meter" /> respectively.
-        /// </param>
-        /// <param name="quantityInfo">The associated quantity info</param>
-        /// <returns>Unit enum value, such as <see cref="MassUnit.Kilogram" />.</returns>
-        /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
-        /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
-        protected virtual Enum GetUnitOrDefault(string? unitAbbreviation, QuantityInfo quantityInfo)
-        {
-            return unitAbbreviation == null
-                ? quantityInfo.BaseUnitInfo.Value
-                : _unitParser.Parse(unitAbbreviation, quantityInfo.UnitType, CultureInfo.InvariantCulture);
-        }
-
-        /// <param name="unitAbbreviation">
-        ///     Unit abbreviation, such as "kg" or "m" for <see cref="MassUnit.Kilogram" /> and
-        ///     <see cref="LengthUnit.Meter" /> respectively.
-        /// </param>
-        /// <param name="quantityInfo">The associated quantity info</param>
-        /// <returns>Unit enum value, such as <see cref="MassUnit.Kilogram" />.</returns>
-        /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
-        /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
-        protected Enum Parse(string unitAbbreviation, QuantityInfo quantityInfo)
-        {
-            return _unitParser.Parse(unitAbbreviation, quantityInfo.UnitType, CultureInfo.InvariantCulture);
-        }
-
-        /// <param name="unitAbbreviation">
-        ///     Unit abbreviation, such as "kg" or "m" for <see cref="MassUnit.Kilogram" /> and
-        ///     <see cref="LengthUnit.Meter" /> respectively.
-        /// </param>
-        /// <param name="quantityInfo">The associated quantity info</param>
-        /// <param name="unit">The unit enum value as out result.</param>
-        /// <returns>True if successful.</returns>
-        /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
-        /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
-        protected bool TryParse(string? unitAbbreviation, QuantityInfo quantityInfo, [NotNullWhen(true)] out Enum? unit)
-        {
-            return _unitParser.TryParse(unitAbbreviation, quantityInfo.UnitType, CultureInfo.InvariantCulture, out unit);
-        }
-
-        /// <summary>
-        ///     Try to get the quantity info associated with a given quantity name
-        /// </summary>
-        /// <param name="quantityName">The name of the quantity: i.e. <see cref="QuantityInfo.Name" /></param>
-        /// <param name="quantityInfo">The quantity information associated with the given quantity name</param>
-        /// <returns>
-        ///     <value>true</value>
-        ///     if a matching quantity is found or
-        ///     <value>false</value>
-        ///     otherwise
-        /// </returns>
-        protected bool TryGetQuantity(string quantityName, [NotNullWhen(true)] out QuantityInfo? quantityInfo)
-        {
-            return _quantities.TryGetValue(quantityName, out quantityInfo);
-        }
-
-        /// <summary>
-        ///     Get the quantity info associated with a given quantity name
-        /// </summary>
-        /// <param name="quantityName">The name of the quantity: i.e. <see cref="QuantityInfo.Name" /></param>
-        /// <returns>
-        ///     <value>true</value>
-        ///     if a matching quantity is found or
-        ///     <value>false</value>
-        ///     otherwise
-        /// </returns>
-        /// <exception cref="UnitsNetException">Quantity not found exception is thrown if no match found</exception>
-        protected QuantityInfo GetQuantityInfo(string quantityName)
-        {
-            if (!TryGetQuantity(quantityName, out var quantityInfo))
+            else
             {
-                throw new UnitsNetException($"Failed to find the quantity type: {quantityName}.") { Data = { ["type"] = quantityName } };
+                throw new FormatException("The target unit cannot be determined from the provided JSON.");
             }
 
-            return quantityInfo;
+            return unitInfo.From(value);
         }
     }
 }
diff --git a/UnitsNet.Serialization.JsonNet/NullableQuantityConverter.cs b/UnitsNet.Serialization.JsonNet/NullableQuantityConverter.cs
index bc6a8a6486..ed2b07ded7 100644
--- a/UnitsNet.Serialization.JsonNet/NullableQuantityConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/NullableQuantityConverter.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Serialization.JsonNet/QuantityValueFormatOptions.cs b/UnitsNet.Serialization.JsonNet/QuantityValueFormatOptions.cs
new file mode 100644
index 0000000000..d516dbfac7
--- /dev/null
+++ b/UnitsNet.Serialization.JsonNet/QuantityValueFormatOptions.cs
@@ -0,0 +1,106 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet.Serialization.JsonNet;
+
+/// <summary>
+///     Represents options for formatting quantity values during serialization and deserialization.
+/// </summary>
+public record struct QuantityValueFormatOptions(
+    QuantityValueSerializationFormat SerializationFormat = QuantityValueSerializationFormat.DecimalPrecision,
+    QuantityValueDeserializationFormat DeserializationFormat = QuantityValueDeserializationFormat.ExactNumber);
+
+/// <summary>
+///     Specifies the format used for serializing <see cref="QuantityValue" /> to JSON.
+/// </summary>
+public enum QuantityValueSerializationFormat
+{
+    /// <summary>
+    ///     Represents the serialization format where the quantity value is serialized as a number with decimal precision.
+    /// </summary>
+    /// <remarks>
+    ///     This number is represented with up to 29 significant digits. Numbers such as "1/3" would be represented as
+    ///     "0.3333333333333333333333333333".
+    /// </remarks>
+    DecimalPrecision,
+
+    /// <summary>
+    ///     Represents the serialization format where the quantity value is serialized as a number with double precision.
+    /// </summary>
+    /// <remarks>
+    ///     This number is represented with up to 17 significant digits. Numbers such as "1/3" would be represented as
+    ///     "0.3333333333333333".
+    /// </remarks>
+    DoublePrecision,
+
+    /// <summary>
+    ///     Represents a serialization format that ensures the exact value of a quantity is preserved during serialization and
+    ///     deserialization.
+    ///     This format is particularly useful for scenarios where precision and round-trip accuracy are critical.
+    /// </summary>
+    /// <remarks>
+    ///     This format dynamically switches between decimal and fractional notation
+    ///     depending on the value being serialized. This ensures that the serialized representation is both precise and
+    ///     compact.
+    ///     For example:
+    ///     - A value such as <c>1.23456789</c> will be serialized in decimal notation, including all significant digits.
+    ///     - A value such as <c>1/3</c> will be serialized as a fraction (e.g., <c>"1/3"</c>).
+    ///     This format is ideal for scenarios where the exact representation of a value is required for round-trip
+    ///     serialization and deserialization.
+    /// </remarks>
+    RoundTrip,
+
+    /// <summary>
+    ///     Relies on the presence of a custom converter for the <see cref="QuantityValue" />.
+    /// </summary>
+    /// <remarks>
+    ///     When this option is selected <c>JsonConvert</c> is used for the serialization.
+    /// </remarks>
+    Custom
+}
+
+/// <summary>
+///     Specifies the format used for deserializing <see cref="QuantityValue" /> from JSON.
+/// </summary>
+public enum QuantityValueDeserializationFormat
+{
+    /// <summary>
+    ///     Deserializes the numeric value of a JSON number exactly, without converting through <see cref="double" /> or
+    ///     <see cref="decimal" />.
+    /// </summary>
+    /// <remarks>
+    ///     Every digit is parsed directly into a <see cref="QuantityValue" />. The original textual representation is not
+    ///     retained, so equivalent JSON numbers such as <c>1.2300e2</c> and <c>123</c> produce the same numeric value.
+    /// </remarks>
+    ExactNumber,
+
+    /// <summary>
+    ///     Deserializes the quantity value as a double precision number, which is then rounded to 15 significant digits.
+    /// </summary>
+    RoundedDouble,
+
+    /// <summary>
+    ///     Represents a serialization format that ensures the exact value of a quantity is preserved during serialization and
+    ///     deserialization.
+    ///     This format is particularly useful for scenarios where precision and round-trip accuracy are critical.
+    /// </summary>
+    /// <remarks>
+    ///     This format dynamically switches between decimal and fractional notation
+    ///     depending on the value being serialized. This ensures that the serialized representation is both precise and
+    ///     compact.
+    ///     For example:
+    ///     - A value such as <c>1.23456789</c> will be serialized in decimal notation, including all significant digits.
+    ///     - A value such as <c>1/3</c> will be serialized as a fraction (e.g., <c>"1/3"</c>).
+    ///     This format is ideal for scenarios where the exact representation of a value is required for round-trip
+    ///     serialization and deserialization.
+    /// </remarks>
+    RoundTrip,
+
+    /// <summary>
+    ///     Relies on the presence of a custom converter for the <see cref="QuantityValue" />.
+    /// </summary>
+    /// <remarks>
+    ///     When this option is selected <c>JsonConvert</c> is used for the deserialization.
+    /// </remarks>
+    Custom
+}
diff --git a/UnitsNet.Serialization.JsonNet/QuantityValueJsonReaderExtensions.cs b/UnitsNet.Serialization.JsonNet/QuantityValueJsonReaderExtensions.cs
new file mode 100644
index 0000000000..2a24d9fdd5
--- /dev/null
+++ b/UnitsNet.Serialization.JsonNet/QuantityValueJsonReaderExtensions.cs
@@ -0,0 +1,104 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Globalization;
+using System.Numerics;
+using Newtonsoft.Json;
+
+namespace UnitsNet.Serialization.JsonNet;
+
+internal static class QuantityValueJsonReaderExtensions
+{
+    public static QuantityValue ReadValue(this JsonReader reader, JsonSerializer serializer, QuantityValueDeserializationFormat format)
+    {
+        switch (format)
+        {
+            case QuantityValueDeserializationFormat.ExactNumber:
+                return reader.ReadExactNumber();
+            case QuantityValueDeserializationFormat.RoundedDouble:
+                return reader.ReadValueFromDouble();
+            case QuantityValueDeserializationFormat.RoundTrip:
+                return reader.ReadValueRoundTrip();
+            case QuantityValueDeserializationFormat.Custom:
+            default:
+                reader.Read();
+                return serializer.Deserialize<QuantityValue>(reader);
+        }
+    }
+
+    public static QuantityValue ReadExactNumber(this JsonReader reader)
+    {
+        var valueString = reader.ReadAsString();
+        if (valueString == null)
+        {
+            throw new JsonSerializationException("Error converting value {null} to type 'QuantityValue'");
+        }
+
+        return QuantityValue.Parse(valueString, NumberStyles.Float, CultureInfo.InvariantCulture);
+    }
+
+    public static QuantityValue ReadValueFromDouble(this JsonReader reader)
+    {
+        var doubleValue = reader.ReadAsDouble();
+        if (!doubleValue.HasValue)
+        {
+            throw new JsonSerializationException("Error converting value {null} to type 'QuantityValue'");
+        }
+
+        return QuantityValue.FromDoubleRounded(doubleValue.Value);
+    }
+
+    public static QuantityValue ReadValueRoundTrip(this JsonReader reader)
+    {
+        var valueString = reader.ReadAsString();
+        if (valueString == null)
+        {
+            throw new JsonSerializationException("Error converting value {null} to type 'QuantityValue'");
+        }
+
+#if NET
+        ReadOnlySpan<char> valueSpan = valueString.AsSpan();
+        return TryParseFraction(valueSpan, out QuantityValue quantityValue)
+            ? quantityValue
+            : QuantityValue.Parse(valueSpan, NumberStyles.Float, CultureInfo.InvariantCulture);
+#else
+            return TryParseFraction(valueString, out QuantityValue quantityValue)
+                ? quantityValue
+                : QuantityValue.Parse(valueString, NumberStyles.Float, CultureInfo.InvariantCulture);
+#endif
+
+#if NET
+        static bool TryParseFraction(ReadOnlySpan<char> value, out QuantityValue quantityValue)
+        {
+            if (value.TrySplit('/', out ReadOnlySpan<char> numeratorSpan, out ReadOnlySpan<char> denominatorSpan))
+            {
+                if (BigInteger.TryParse(numeratorSpan, out BigInteger numerator) && BigInteger.TryParse(denominatorSpan, out BigInteger denominator))
+                {
+                    quantityValue = QuantityValue.FromTerms(numerator, denominator);
+                    return true;
+                }
+            }
+
+            quantityValue = default;
+            return false;
+        }
+#else
+            static bool TryParseFraction(string valueToken, out QuantityValue quantityValue)
+            {
+                var ranges = valueToken.Split('/');
+                if (ranges.Length == 2)
+                {
+                    if (BigInteger.TryParse(ranges[0], out BigInteger numerator) && BigInteger.TryParse(ranges[1], out BigInteger denominator))
+                    {
+                        quantityValue = QuantityValue.FromTerms(numerator, denominator);
+                        return true;
+                    }
+                }
+
+                quantityValue = default;
+                return false;
+            }
+#endif
+    }
+}
diff --git a/UnitsNet.Serialization.JsonNet/QuantityValueJsonWriterExtensions.cs b/UnitsNet.Serialization.JsonNet/QuantityValueJsonWriterExtensions.cs
new file mode 100644
index 0000000000..6078990123
--- /dev/null
+++ b/UnitsNet.Serialization.JsonNet/QuantityValueJsonWriterExtensions.cs
@@ -0,0 +1,185 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Globalization;
+using System.Numerics;
+using Newtonsoft.Json;
+#if NETSTANDARD2_0
+using System.Text;
+#endif
+
+namespace UnitsNet.Serialization.JsonNet;
+
+internal static class QuantityValueJsonWriterExtensions
+{
+    public static void WriteValue(this JsonWriter writer, QuantityValue value, JsonSerializer serializer, QuantityValueSerializationFormat format)
+    {
+        switch (format)
+        {
+            case QuantityValueSerializationFormat.DoublePrecision:
+                writer.WriteValueWithDoublePrecision(value);
+                break;
+            case QuantityValueSerializationFormat.DecimalPrecision:
+                writer.WriteValueWithDecimalPrecision(value);
+                break;
+            case QuantityValueSerializationFormat.RoundTrip:
+                writer.WriteValueRoundTrip(value);
+                break;
+            case QuantityValueSerializationFormat.Custom:
+            default:
+                serializer.Serialize(writer, value);
+                break;
+        }
+    }
+
+    public static void WriteValueWithDoublePrecision(this JsonWriter writer, QuantityValue value)
+    {
+        writer.WriteRawValue(value.ToString("G17", CultureInfo.InvariantCulture));
+    }
+
+    public static void WriteValueWithDecimalPrecision(this JsonWriter writer, QuantityValue value)
+    {
+        writer.WriteRawValue(value.ToString("G29", CultureInfo.InvariantCulture));
+    }
+
+    public static void WriteValueRoundTrip(this JsonWriter writer, QuantityValue value)
+    {
+        (BigInteger numerator, BigInteger denominator) = QuantityValue.Reduce(value);
+        // TODO see about using exponential notation
+        if (denominator <= long.MaxValue / 10)
+        {
+            if (numerator <= long.MaxValue && numerator >= long.MinValue)
+            {
+                WriteSmallTerms(writer, (long)numerator, (long)denominator);
+                return;
+            }
+
+            if (denominator.IsOne)
+            {
+                writer.WriteValue(numerator);
+                return;
+            }
+        }
+
+        if (!QuantityValue.HasNonDecimalFactors(denominator))
+        {
+            // failed to format the value as a decimal number
+            writer.WriteValue($"{numerator}/{denominator}");
+            return;
+        }
+
+        // decimal number
+        var quotient = BigInteger.DivRem(numerator, denominator, out BigInteger remainder);
+
+#if NET
+            var bufferSize = 512;
+            Span<char> charBuffer = stackalloc char[bufferSize];
+            int charsWritten;
+            while (!quotient.TryFormat(charBuffer, out charsWritten))
+            {
+                bufferSize *= 4;
+                charBuffer = new char[bufferSize];
+            }
+
+            if (charsWritten + 2 > bufferSize)
+            {
+                bufferSize *= 2;
+                var extendedBuffer = new char[bufferSize * 2];
+                charBuffer.CopyTo(extendedBuffer);
+                charBuffer = extendedBuffer;
+            }
+
+            BigInteger ten = 10;
+            charBuffer[charsWritten++] = '.';
+            remainder = BigInteger.Abs(remainder);
+            do
+            {
+                var digit = (int)BigInteger.DivRem(remainder * ten, denominator, out remainder);
+                if (charsWritten == bufferSize)
+                {
+                    // extend the buffer
+                    bufferSize *= 2;
+                    var extendedBuffer = new char[bufferSize * 2];
+                    charBuffer.CopyTo(extendedBuffer);
+                    charBuffer = extendedBuffer;
+                }
+
+                charBuffer[charsWritten++] = (char)('0' + digit);
+            } while (!remainder.IsZero);
+
+            writer.WriteRawValue(new string(charBuffer[..charsWritten]));
+#else
+        // decimal number
+        StringBuilder sb = new StringBuilder(quotient.ToString()).Append('.');
+        BigInteger ten = 10;
+        remainder = BigInteger.Abs(remainder);
+        do
+        {
+            var digit = (int)BigInteger.DivRem(remainder * ten, denominator, out remainder);
+            sb.Append((char)('0' + digit));
+        } while (!remainder.IsZero);
+
+        writer.WriteRawValue(sb.ToString());
+#endif
+
+        static void WriteSmallTerms(JsonWriter writer, long numerator, long denominator)
+        {
+            switch (denominator)
+            {
+                case 0:
+                    // NaN or Infinity
+                    switch (numerator)
+                    {
+                        case > 0:
+                            writer.WriteValue(NumberFormatInfo.InvariantInfo.PositiveInfinitySymbol);
+                            return;
+                        case < 0:
+                            writer.WriteValue(NumberFormatInfo.InvariantInfo.NegativeInfinitySymbol);
+                            return;
+                        default:
+                            writer.WriteValue(NumberFormatInfo.InvariantInfo.NaNSymbol);
+                            return;
+                    }
+                case 1:
+                    writer.WriteValue(numerator);
+                    return;
+            }
+
+            var quotient = Math.DivRem(numerator, denominator, out var remainder);
+
+            // decimal number
+            const int bufferSize = 45;
+#if NET
+                Span<char> charBuffer = stackalloc char[bufferSize];
+
+                quotient.TryFormat(charBuffer, out var charsWritten);
+#else
+            var charBuffer = new char[bufferSize];
+            var quotientString = quotient.ToString();
+            quotientString.CopyTo(0, charBuffer, 0, quotientString.Length);
+            var charsWritten = quotientString.Length;
+#endif
+            charBuffer[charsWritten++] = '.';
+            remainder = Math.Abs(remainder);
+            do
+            {
+                var digit = Math.DivRem(remainder * 10, denominator, out remainder);
+
+                charBuffer[charsWritten++] = (char)(digit + '0');
+                if (remainder == 0)
+                {
+#if NET
+                        writer.WriteRawValue(new string(charBuffer[..charsWritten]));
+#else
+                    writer.WriteRawValue(new string(charBuffer, 0, charsWritten));
+#endif
+                    return;
+                }
+            } while (charsWritten < bufferSize);
+
+            // failed to format the value as a decimal number
+            writer.WriteValue($"{numerator}/{denominator}");
+        }
+    }
+}
diff --git a/UnitsNet.Serialization.JsonNet/StringExtensions.cs b/UnitsNet.Serialization.JsonNet/StringExtensions.cs
index 0c99180464..92cfbb119a 100644
--- a/UnitsNet.Serialization.JsonNet/StringExtensions.cs
+++ b/UnitsNet.Serialization.JsonNet/StringExtensions.cs
@@ -1,7 +1,10 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Diagnostics.CodeAnalysis;
+#if NET
+using System;
+#endif
 
 namespace UnitsNet.Serialization.JsonNet
 {
@@ -21,5 +24,23 @@ internal static class StringExtensions
                 ? value.Substring(0, maxLength - truncationSuffix.Length) + truncationSuffix
                 : value;
         }
+
+#if NET
+        public static bool TrySplit(this ReadOnlySpan<char> span, char separator, out ReadOnlySpan<char> firstSpan, out ReadOnlySpan<char> secondSpan)
+        {
+            var separatorIndex = span.IndexOf(separator);
+
+            if (separatorIndex < 0)
+            {
+                firstSpan = span;
+                secondSpan = ReadOnlySpan<char>.Empty;
+                return false;
+            }
+
+            firstSpan = span.Slice(0, separatorIndex);
+            secondSpan = span.Slice(separatorIndex + 1);
+            return true;
+        }
+#endif
     }
 }
diff --git a/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj b/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj
index 5a056d5c54..3f189d469d 100644
--- a/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj
+++ b/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj
@@ -2,7 +2,7 @@
   <!-- NuGet properties -->
   <PropertyGroup>
     <PackageId>UnitsNet.Serialization.JsonNet</PackageId>
-    <Version>6.0.0-pre019</Version>
+    <Version>6.0.0-pre021</Version>
     <Authors>Andreas Gullberg Larsen</Authors>
     <Title>Units.NET Serialization with Json.NET</Title>
     <Description>A helper library for serializing and deserializing types in Units.NET using Json.NET.</Description>
@@ -15,6 +15,7 @@
     <PackageLicenseExpression>MIT-0</PackageLicenseExpression>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>unit units measurement json Json.NET Newtonsoft serialize deserialize serialization deserialization</PackageTags>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageReleaseNotes>Upgrade JSON.NET to 12.0.3. Support arrays.</PackageReleaseNotes>
   </PropertyGroup>
 
@@ -51,6 +52,7 @@
   <!-- Files to include in nuget package -->
   <ItemGroup>
     <None Include="../Docs/Images/logo-32.png" Pack="true" PackagePath="/" />
+    <None Include="../README.md" Pack="true" PackagePath="/" />
   </ItemGroup>
 
 </Project>
diff --git a/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs b/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
index 73f4cce110..b512913545 100644
--- a/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -21,12 +21,14 @@ namespace UnitsNet.Serialization.JsonNet
 #endif
     public abstract class UnitsNetBaseJsonConverter<T> : NullableQuantityConverter<T>
     {
+        private const string RegisteredQuantityInstantiationFailedErrorCode = "JsonNetRegisteredQuantityInstantiationFailed";
+
         private readonly ConcurrentDictionary<string, (Type Quantity, Type Unit)> _registeredTypes = new();
 
         /// <summary>
         /// Register custom types so that the converter can instantiate these quantities.
-        /// Instead of calling <see cref="Quantity.From(double,UnitKey)"/>, the <see cref="Activator"/> will be used to instantiate the object.
-        /// It is therefore assumed that the constructor of <paramref name="quantity"/> is specified with <c>new T(double value, typeof(<paramref name="unit"/>) unit)</c>.
+        /// Instead of calling <see cref="Quantity.From(QuantityValue,UnitKey)"/>, <see cref="Activator.CreateInstance(Type, object?[])"/> will be used to instantiate the object.
+        /// It is therefore assumed that <paramref name="quantity"/> has a public constructor that accepts <c>(QuantityValue value, <paramref name="unit"/> unit)</c>.
         /// Registering the same <paramref name="unit"/> multiple times, it will overwrite the one registered.
         /// </summary>
         public void RegisterCustomType(Type quantity, Type unit)
@@ -82,7 +84,7 @@ public void RegisterCustomType(Type quantity, Type unit)
         /// Convert a <see cref="ValueUnit"/> to an <see cref="IQuantity"/>
         /// </summary>
         /// <param name="valueUnit">The value unit to convert</param>
-        /// <exception cref="UnitsNetException">Thrown when an invalid Unit has been provided</exception>
+        /// <exception cref="UnitsNetException">Thrown when an invalid unit has been provided, or when a registered custom quantity type cannot be instantiated.</exception>
         /// <returns>An IQuantity</returns>
         protected IQuantity ConvertValueUnit(ValueUnit valueUnit)
         {
@@ -92,14 +94,40 @@ protected IQuantity ConvertValueUnit(ValueUnit valueUnit)
             }
 
             var unit = GetUnit(valueUnit.Unit);
-            var registeredQuantity = GetRegisteredType(valueUnit.Unit).Quantity;
+            var registeredType = GetRegisteredType(valueUnit.Unit);
+            var registeredQuantity = registeredType.Quantity;
 
             if (registeredQuantity is not null)
             {
-                return (IQuantity)Activator.CreateInstance(registeredQuantity, valueUnit.Value, unit)!;
+                // RegisterCustomType stores quantity/unit pairs, so a registered quantity has a registered unit.
+                Type registeredUnit = registeredType.Unit!;
+                try
+                {
+                    IQuantity? instance =
+                        (IQuantity?)Activator.CreateInstance(registeredQuantity, QuantityValue.FromDoubleRounded(valueUnit.Value), unit);
+                    return instance ?? throw CreateRegisteredQuantityInstantiationException(registeredQuantity, registeredUnit, unit);
+                }
+                catch (Exception ex) when (!IsRegisteredQuantityInstantiationException(ex))
+                {
+                    throw CreateRegisteredQuantityInstantiationException(registeredQuantity, registeredUnit, unit, ex);
+                }
             }
 
-            return Quantity.From(valueUnit.Value, unit);
+            return Quantity.From(QuantityValue.FromDoubleRounded(valueUnit.Value), unit);
+        }
+
+        private static bool IsRegisteredQuantityInstantiationException(Exception ex) =>
+            ex is UnitsNetException && Equals(ex.Data[UnitsNetException.ErrorCodeDataKey], RegisteredQuantityInstantiationFailedErrorCode);
+
+        private static UnitsNetException CreateRegisteredQuantityInstantiationException(Type quantityType, Type unitType, Enum unit, Exception? innerException = null)
+        {
+            string message = $"Unable to instantiate registered quantity type \"{quantityType.FullName}\" for unit \"{unitType.FullName}.{unit}\". The converter expected a non-null quantity instance from a public constructor accepting (QuantityValue value, {unitType.Name} unit).";
+            var ex = innerException is null ? new UnitsNetException(message) : new UnitsNetException(message, innerException);
+            ex.Data[UnitsNetException.ErrorCodeDataKey] = RegisteredQuantityInstantiationFailedErrorCode;
+            ex.Data["quantityType"] = quantityType;
+            ex.Data["unitType"] = unitType;
+            ex.Data["unit"] = unit;
+            return ex;
         }
 
         private (Type? Quantity, Type? Unit) GetRegisteredType(string unit)
@@ -164,7 +192,9 @@ protected ValueUnit ConvertIQuantity(IQuantity quantity)
         {
             quantity = quantity ?? throw new ArgumentNullException(nameof(quantity));
 
+#pragma warning disable CS0618 // IQuantity.QuantityInfo: serialization must work for custom quantities not registered in UnitsNetSetup.Default.
             return new ValueUnit {Value = (double)quantity.Value, Unit = $"{quantity.QuantityInfo.UnitType.Name}.{quantity.Unit}"};
+#pragma warning restore CS0618
         }
 
         /// <summary>
diff --git a/UnitsNet.Serialization.JsonNet/UnitsNetIComparableJsonConverter.cs b/UnitsNet.Serialization.JsonNet/UnitsNetIComparableJsonConverter.cs
index f1aa8b7618..fe8aa39044 100644
--- a/UnitsNet.Serialization.JsonNet/UnitsNetIComparableJsonConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/UnitsNetIComparableJsonConverter.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Serialization.JsonNet/UnitsNetIQuantityJsonConverter.cs b/UnitsNet.Serialization.JsonNet/UnitsNetIQuantityJsonConverter.cs
index ceb76c6ecb..ccd06408f3 100644
--- a/UnitsNet.Serialization.JsonNet/UnitsNetIQuantityJsonConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/UnitsNetIQuantityJsonConverter.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Serialization.JsonNet/Value/QuantityValueFractionalNotationConverter.cs b/UnitsNet.Serialization.JsonNet/Value/QuantityValueFractionalNotationConverter.cs
new file mode 100644
index 0000000000..2706055fb2
--- /dev/null
+++ b/UnitsNet.Serialization.JsonNet/Value/QuantityValueFractionalNotationConverter.cs
@@ -0,0 +1,157 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Numerics;
+using Newtonsoft.Json;
+
+namespace UnitsNet.Serialization.JsonNet.Value;
+
+/// <summary>
+///     A custom JSON converter for serializing and deserializing <see cref="QuantityValue" /> objects.
+/// </summary>
+/// <remarks>
+///     This converter handles the serialization of <see cref="QuantityValue" /> as a fraction,
+///     represented by its numerator and denominator, to ensure precise representation of values.
+/// </remarks>
+public class QuantityValueFractionalNotationConverter : JsonConverter<QuantityValue>
+{
+    private const string NumeratorPropertyName = "N";
+    private const string DenominatorPropertyName = "D";
+    private readonly bool _reduceTerms;
+
+    /// <summary>
+    ///     Gets the default instance of the <see cref="QuantityValueFractionalNotationConverter" />.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides a pre-configured, shared instance of the converter
+    ///     with default settings, simplifying the serialization and deserialization
+    ///     of <see cref="QuantityValue" /> objects in JSON format.
+    /// </remarks>
+    public static QuantityValueFractionalNotationConverter Default { get; } = new();
+    
+    /// <summary>
+    ///     Gets an instance of <see cref="QuantityValueFractionalNotationConverter" /> configured to reduce terms
+    ///     during serialization and deserialization.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides a pre-configured converter that simplifies fractional representations
+    ///     by reducing the numerator and denominator to their smallest terms.
+    /// </remarks>
+    public static QuantityValueFractionalNotationConverter Reducing { get; } = new(true);
+        
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValue" /> class
+    ///     with default settings.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor sets up the converter to handle the serialization and deserialization
+    ///     of <see cref="QuantityValueFractionalNotationConverter" /> objects in JSON format, using default behavior.
+    /// </remarks>
+    public QuantityValueFractionalNotationConverter()
+        : this(false)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValueFractionalNotationConverter" /> class
+    ///     with the default configuration.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor sets up the converter with default settings, where terms are not reduced
+    ///     during serialization and deserialization.
+    /// </remarks>
+    public QuantityValueFractionalNotationConverter(bool reduceTerms)
+    {
+        _reduceTerms = reduceTerms;
+    }
+
+    /// <inheritdoc />
+    public override void WriteJson(JsonWriter writer, QuantityValue value, JsonSerializer serializer)
+    {
+        (BigInteger numerator, BigInteger denominator) = _reduceTerms ? QuantityValue.Reduce(value) : value;
+        
+        writer.WriteStartObject();
+
+        if((serializer.DefaultValueHandling & DefaultValueHandling.Ignore) != 0)
+        {
+            // Write only if the property is non-default.
+            if (!numerator.IsZero)
+            {
+                writer.WritePropertyName(NumeratorPropertyName);
+                serializer.Serialize(writer, numerator);
+            }
+
+            if (!denominator.IsOne)
+            {
+                writer.WritePropertyName(DenominatorPropertyName);
+                serializer.Serialize(writer, denominator);
+            }
+        }
+        else
+        {
+            writer.WritePropertyName(NumeratorPropertyName);
+            serializer.Serialize(writer, numerator);
+            writer.WritePropertyName(DenominatorPropertyName);
+            serializer.Serialize(writer, denominator);
+        }
+
+        writer.WriteEndObject();
+    }
+
+    /// <inheritdoc />
+    public override QuantityValue ReadJson(JsonReader reader, Type objectType, QuantityValue existingValue, bool hasExistingValue,
+        JsonSerializer serializer)
+    {
+        BigInteger? numerator = null;
+        BigInteger? denominator = null;
+        // Ensure the reader is at the start of an object
+        if (reader.TokenType != JsonToken.StartObject)
+        {
+            throw new JsonSerializationException("Expected StartObject token.");
+        }
+
+        // Read through the JSON object
+        while (reader.Read())
+        {
+            if (reader.TokenType == JsonToken.EndObject)
+            {
+                break; // End of the object
+            }
+
+            if (reader.TokenType == JsonToken.PropertyName)
+            {
+                var propertyName = (string)reader.Value!;
+                reader.Read(); // Move to the value
+                if (string.Equals(propertyName, NumeratorPropertyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    numerator = serializer.Deserialize<BigInteger>(reader);
+                }
+                else if (string.Equals(propertyName, DenominatorPropertyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    denominator = serializer.Deserialize<BigInteger>(reader);
+                }
+                else if (serializer.MissingMemberHandling == MissingMemberHandling.Ignore)
+                {
+                    reader.Skip();
+                }
+                else
+                {
+                    throw new JsonException($"'{propertyName}' was no found in the list of members of '{objectType}'.");
+                }
+            }
+        }
+
+        if (numerator.HasValue && denominator.HasValue)
+        {
+            return QuantityValue.FromTerms(numerator.Value, denominator.Value);
+        }
+
+        if (numerator.HasValue)
+        {
+            return numerator.Value;
+        }
+
+        return denominator.HasValue ? QuantityValue.FromTerms(BigInteger.Zero, denominator.Value) : QuantityValue.Zero;
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedInterfaceQuantityConverterWithValueConverterTest.cs b/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedInterfaceQuantityConverterWithValueConverterTest.cs
new file mode 100644
index 0000000000..eefd84b075
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedInterfaceQuantityConverterWithValueConverterTest.cs
@@ -0,0 +1,269 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Value;
+using UnitsNet.Units;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests;
+
+[TestSubject(typeof(AbbreviatedInterfaceQuantityWithValueConverter))]
+public class AbbreviatedInterfaceQuantityConverterWithValueConverterTest
+{
+    [Fact]
+    public void Constructor_WithNullAbbreviations_ThrowsArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => new AbbreviatedInterfaceQuantityWithValueConverter(null!));
+        Assert.Throws<ArgumentNullException>(() => new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default, null!));
+    }
+
+    [Theory]
+    [InlineData("""{"Value":10,"Unit":"m","Type":"Length"}""", typeof(Length), 10, LengthUnit.Meter)]
+    [InlineData("""{"Value":5,"Unit":"g","Type":"Mass"}""", typeof(Mass), 5, MassUnit.Gram)]
+    [InlineData("""{"Value":5,"Type":"Mass"}""", typeof(Mass), 5, MassUnit.Kilogram)]
+    [InlineData("""{"Value":5,"Unit":"kg"}""", typeof(Mass), 5, MassUnit.Kilogram)]
+    [InlineData("""{"Value":0,"Unit":"s","Type":"Duration"}""", typeof(Duration), 0, DurationUnit.Second)]
+    public void Deserializing_WithDecimalNotation_ReturnsCorrectQuantity(string json, Type expectedType, decimal expectedValue, Enum expectedUnit)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+    
+        // Act
+        IQuantity result = JsonSerializer.Deserialize<IQuantity>(json, options)!;
+
+        // Assert
+        Assert.IsType(expectedType, result);
+        Assert.Equal(expectedValue, result.Value);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+    
+    [Theory]
+    [InlineData("""{"value":10,"unit":"m","type":"Length"}""", typeof(Length), 10, LengthUnit.Meter)]
+    [InlineData("""{"value":5,"unit":"g","type":"Mass"}""", typeof(Mass), 5, MassUnit.Gram)]
+    [InlineData("""{"value":0,"unit":"s","type":"Duration"}""", typeof(Duration), 0, DurationUnit.Second)]
+    public void Deserializing_WithDecimalNotation_And_CamelCasePropertyNamingPolicy_ReturnsCorrectQuantity(string json, Type expectedType, decimal expectedValue, Enum expectedUnit)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions {PropertyNamingPolicy = JsonNamingPolicy.CamelCase};
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+    
+        // Act
+        IQuantity result = JsonSerializer.Deserialize<IQuantity>(json, options)!;
+
+        // Assert
+        Assert.IsType(expectedType, result);
+        Assert.Equal(expectedValue, result.Value);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+    
+
+    [Theory]
+    [InlineData("""{"Value":10,"Unit":"m","Type":"Length"}""", typeof(Length), 10, LengthUnit.Meter)]
+    [InlineData("""{"value":5,"unit":"g","type":"Mass"}""", typeof(Mass), 5, MassUnit.Gram)]
+    [InlineData("""{"VALUE":0,"uniT":"s","tYPe":"Duration"}""", typeof(Duration), 0, DurationUnit.Second)]
+    public void Deserializing_WithDecimalNotation_IgnoringCase_ReturnsCorrectQuantity(string json, Type expectedType, decimal expectedValue, Enum expectedUnit)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions {PropertyNameCaseInsensitive = true};
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+
+        // Act
+        IQuantity result = JsonSerializer.Deserialize<IQuantity>(json, options)!;
+
+        // Assert
+        Assert.IsType(expectedType, result);
+        Assert.Equal(expectedValue, result.Value);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void Deserializing_WithDecimalNotation_WithExtraProperties(bool ignoreCasing)
+    {
+        // Arrange
+        const string json = """{"UnknownProperty":"Something", "Value":5,"Unit":"g","Type":"Mass"}""";
+        var expectedQuantity = Mass.FromGrams(5);
+        var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = ignoreCasing };
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+        
+        // Act
+        IQuantity result = JsonSerializer.Deserialize<IQuantity>(json, options)!;
+        
+        // Assert
+        Assert.Equal(expectedQuantity, result);
+    }
+    
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void Deserialize_WithAdditionalProperties_WhenUnmappedMemberHandlingIsDisallowed_ThrowsJsonException(bool ignoreCasing)
+    {
+        // Arrange
+        const string json = """{"UnknownProperty":"Something", "Value":5,"Unit":"g","Type":"Mass"}""";
+        var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = ignoreCasing, UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow};
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithoutUnitAndType_ThrowsJsonException()
+    {
+        // Arrange
+        const string json = """{"Value":5}""";
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+
+        // Act
+        var exception = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+
+        // Assert
+        Assert.Equal("Both the quantity name and unit abbreviation are missing from the JSON.", exception.Message);
+    }
+
+    [Fact]
+    public void Deserializing_WithAmbiguousUnitAndNotType_ThrowsAmbiguousUnitParseException()
+    {
+        // Arrange
+        const string json = """{"Value":10,"Unit":"m"}""";;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+
+        // Act
+        var exception = Assert.Throws<AmbiguousUnitParseException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+
+        // Assert
+        Assert.Equal("""Cannot parse "m" since it matches multiple units: Meter ("m"), Minute ("m").""", exception.Message);
+    }
+
+    [Fact]
+    public void Deserializing_WithNonAmbiguousUnitAndNoType_ReturnsTheExpectedQuantity()
+    {
+        // Arrange
+        const string json = """{"Value":10,"Unit":"m"}""";;
+        var expected = Length.FromMeters(10);
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default, new UnitParser([Length.Info])));
+
+        // Act
+        IQuantity result = JsonSerializer.Deserialize<IQuantity>(json, options)!;
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(10, "Meter", "Length", """{"Value":10,"Unit":"m","Type":"Length"}""")]
+    [InlineData(5, "Kilogram", "Mass", """{"Value":5,"Unit":"kg","Type":"Mass"}""")]
+    [InlineData(0, "Second", "Duration", """{"Value":0,"Unit":"s","Type":"Duration"}""")]
+    public void Serializing_WithDecimalNotation_ReturnsTheExpectedJson(double value, string unit, string type, string expectedJson)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+
+        IQuantity quantity = Quantity.From(value, type, unit);
+        
+        // Act
+        var actualJson = JsonSerializer.Serialize(quantity, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, actualJson);
+    }
+
+    [Fact]
+    public void Deserializing_WithUnknownQuantity_ThrowsQuantityNotFoundException()
+    {
+        // Arrange
+        const string json = """{"Value":10,"Unit":"m","Type":"Length"}""";;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default, new UnitParser([Mass.Info])));
+
+        // Assert
+        Assert.Throws<QuantityNotFoundException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithUnknownUnit_ThrowsUnitNotFoundException()
+    {
+        // Arrange
+        const string json = """{"Value":10,"Unit":"unknown","Type":"Length"}""";;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+
+        // Assert
+        Assert.Throws<UnitNotFoundException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+    }
+    
+    [Theory]
+    [InlineData(10, "Meter", "Length", """{"value":10,"unit":"m","type":"Length"}""")]
+    [InlineData(5, "Kilogram", "Mass", """{"value":5,"unit":"kg","type":"Mass"}""")]
+    [InlineData(0, "Second", "Duration", """{"value":0,"unit":"s","type":"Duration"}""")]
+    public void Serializing_WithDecimalNotation_And_CamelCasePropertyNamingPolicy_ReturnsTheExpectedJson(double value, string unit, string type, string expectedJson)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions {PropertyNamingPolicy = JsonNamingPolicy.CamelCase};
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+        
+        IQuantity quantity = Quantity.From(value, type, unit);
+        
+        // Act
+        var actualJson = JsonSerializer.Serialize(quantity, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, actualJson);
+    }
+    
+    [Theory]
+    [InlineData(10, "Centimeter", "Length", """{"Value":10,"Unit":"cm","Type":"Length"}""")]
+    [InlineData(5, "Kilogram", "Mass", """{"Value":5,"Type":"Mass"}""")]
+    [InlineData(0, "Second", "Duration", """{"Type":"Duration"}""")]
+    public void Serializing_WithDecimalNotation_IgnoringDefaultValues_ReturnsTheExpectedJson(double value, string unit, string quantityName, string expectedJson)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions {DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault};
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+        
+        IQuantity quantity = Quantity.From(value, quantityName, unit);
+        
+        // Act
+        var actualJson = JsonSerializer.Serialize(quantity, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, actualJson);
+    }
+
+    [Fact]
+    public void Serializing_NullQuantity_WritesNull()
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default));
+
+        IQuantity quantity = null!;
+        
+        // Act
+        var actualJson = JsonSerializer.Serialize(quantity, options);
+        
+        // Assert
+        Assert.Equal("null", actualJson);
+    }
+
+    [Fact]
+    public void Serializing_UnknownQuantity_ThrowsUnitNotFoundException()
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithValueConverter(QuantityValueMixedNotationConverter.Default, new UnitParser([Mass.Info])));
+        
+        IQuantity quantity = Length.Zero;
+
+        // Assert
+        Assert.Throws<UnitNotFoundException>(() => JsonSerializer.Serialize(quantity, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedInterfaceQuantityWithAvailableValueConverterTest.cs b/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedInterfaceQuantityWithAvailableValueConverterTest.cs
new file mode 100644
index 0000000000..0024f0e0a9
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedInterfaceQuantityWithAvailableValueConverterTest.cs
@@ -0,0 +1,311 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Value;
+using UnitsNet.Units;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests;
+
+[TestSubject(typeof(AbbreviatedInterfaceQuantityWithAvailableValueConverter))]
+public class AbbreviatedInterfaceQuantityWithAvailableValueConverterTest
+{
+    [Fact]
+    public void Constructor_WithNullAbbreviations_ThrowsArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => new AbbreviatedInterfaceQuantityWithAvailableValueConverter(null!));
+    }
+
+    [Theory]
+    [InlineData("""{"Value":10,"Unit":"m","Type":"Length"}""", typeof(Length), 10, LengthUnit.Meter)]
+    [InlineData("""{"Value":5,"Unit":"g","Type":"Mass"}""", typeof(Mass), 5, MassUnit.Gram)]
+    [InlineData("""{"Value":5,"Type":"Mass"}""", typeof(Mass), 5, MassUnit.Kilogram)]
+    [InlineData("""{"Value":5,"Unit":"kg"}""", typeof(Mass), 5, MassUnit.Kilogram)]
+    [InlineData("""{"Value":0,"Unit":"s","Type":"Duration"}""", typeof(Duration), 0, DurationUnit.Second)]
+    public void Deserializing_WithDecimalNotation_ReturnsCorrectQuantity(string json, Type expectedType, decimal expectedValue, Enum expectedUnit)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+    
+        // Act
+        IQuantity result = JsonSerializer.Deserialize<IQuantity>(json, options)!;
+
+        // Assert
+        Assert.IsType(expectedType, result);
+        Assert.Equal(expectedValue, result.Value);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+    
+    [Theory]
+    [InlineData("""{"value":10,"unit":"m","type":"Length"}""", typeof(Length), 10, LengthUnit.Meter)]
+    [InlineData("""{"value":5,"unit":"g","type":"Mass"}""", typeof(Mass), 5, MassUnit.Gram)]
+    [InlineData("""{"value":0,"unit":"s","type":"Duration"}""", typeof(Duration), 0, DurationUnit.Second)]
+    public void Deserializing_WithDecimalNotation_And_CamelCasePropertyNamingPolicy_ReturnsCorrectQuantity(string json, Type expectedType, decimal expectedValue, Enum expectedUnit)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions {PropertyNamingPolicy = JsonNamingPolicy.CamelCase};
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+    
+        // Act
+        IQuantity result = JsonSerializer.Deserialize<IQuantity>(json, options)!;
+
+        // Assert
+        Assert.IsType(expectedType, result);
+        Assert.Equal(expectedValue, result.Value);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+    
+
+    [Theory]
+    [InlineData("""{"Value":10,"Unit":"m","Type":"Length"}""", typeof(Length), 10, LengthUnit.Meter)]
+    [InlineData("""{"value":5,"unit":"g","type":"Mass"}""", typeof(Mass), 5, MassUnit.Gram)]
+    [InlineData("""{"VALUE":0,"uniT":"s","tYPe":"Duration"}""", typeof(Duration), 0, DurationUnit.Second)]
+    public void Deserializing_WithDecimalNotation_IgnoringCase_ReturnsCorrectQuantity(string json, Type expectedType, decimal expectedValue, Enum expectedUnit)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions {PropertyNameCaseInsensitive = true};
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+
+        // Act
+        IQuantity result = JsonSerializer.Deserialize<IQuantity>(json, options)!;
+
+        // Assert
+        Assert.IsType(expectedType, result);
+        Assert.Equal(expectedValue, result.Value);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void Deserializing_WithDecimalNotation_WithExtraProperties(bool ignoreCasing)
+    {
+        // Arrange
+        const string json = """{"UnknownProperty":"Something", "Value":5,"Unit":"g","Type":"Mass"}""";
+        var expectedQuantity = Mass.FromGrams(5);
+        var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = ignoreCasing };
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+        
+        // Act
+        IQuantity result = JsonSerializer.Deserialize<IQuantity>(json, options)!;
+        
+        // Assert
+        Assert.Equal(expectedQuantity, result);
+    }
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void Deserialize_WithAdditionalProperties_WhenUnmappedMemberHandlingIsDisallowed_ThrowsJsonException(bool ignoreCasing)
+    {
+        // Arrange
+        const string json = """{"UnknownProperty":"Something", "Value":5,"Unit":"g","Type":"Mass"}""";
+        var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = ignoreCasing, UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow};
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithoutUnitAndType_ThrowsJsonException()
+    {
+        // Arrange
+        const string json = """{"Value":5}""";
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+
+        // Act
+        var exception = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+
+        // Assert
+        Assert.Equal("Both the quantity name and unit abbreviation are missing from the JSON.", exception.Message);
+    }
+
+    [Fact]
+    public void Deserializing_WithAmbiguousUnitAndNotType_ThrowsAmbiguousUnitParseException()
+    {
+        // Arrange
+        const string json = """{"Value":10,"Unit":"m"}""";;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+
+        // Act
+        var exception = Assert.Throws<AmbiguousUnitParseException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+
+        // Assert
+        Assert.Equal("""Cannot parse "m" since it matches multiple units: Meter ("m"), Minute ("m").""", exception.Message);
+    }
+
+    [Fact]
+    public void Deserializing_WithNonAmbiguousUnitAndNoType_ReturnsTheExpectedQuantity()
+    {
+        // Arrange
+        const string json = """{"Value":10,"Unit":"m"}""";;
+        var expected = Length.FromMeters(10);
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter(new UnitParser([Length.Info])));
+
+        // Act
+        IQuantity result = JsonSerializer.Deserialize<IQuantity>(json, options)!;
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(10, "Meter", "Length", """{"Value":10,"Unit":"m","Type":"Length"}""")]
+    [InlineData(5, "Kilogram", "Mass", """{"Value":5,"Unit":"kg","Type":"Mass"}""")]
+    [InlineData(0, "Second", "Duration", """{"Value":0,"Unit":"s","Type":"Duration"}""")]
+    public void Serializing_WithDecimalNotation_ReturnsTheExpectedJson(double value, string unit, string type, string expectedJson)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+
+        IQuantity quantity = Quantity.From(value, type, unit);
+        
+        // Act
+        var actualJson = JsonSerializer.Serialize(quantity, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, actualJson);
+    }
+
+    [Fact]
+    public void Deserializing_WithUnknownQuantity_ThrowsQuantityNotFoundException()
+    {
+        // Arrange
+        const string json = """{"Value":10,"Unit":"m","Type":"Length"}""";;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter(new UnitParser([Mass.Info])));
+
+        // Assert
+        Assert.Throws<QuantityNotFoundException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithUnknownUnit_ThrowsUnitNotFoundException()
+    {
+        // Arrange
+        const string json = """{"Value":10,"Unit":"unknown","Type":"Length"}""";;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+
+        // Assert
+        Assert.Throws<UnitNotFoundException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithoutQuantityValueConverter_ThrowsJsonException()
+    {
+        // Arrange
+        const string json = """{"Value":10,"Unit":"m","Type":"Length"}""";;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IQuantity>(json, options));
+    }
+    
+    [Theory]
+    [InlineData(10, "Meter", "Length", """{"value":10,"unit":"m","type":"Length"}""")]
+    [InlineData(5, "Kilogram", "Mass", """{"value":5,"unit":"kg","type":"Mass"}""")]
+    [InlineData(0, "Second", "Duration", """{"value":0,"unit":"s","type":"Duration"}""")]
+    public void Serializing_WithDecimalNotation_And_CamelCasePropertyNamingPolicy_ReturnsTheExpectedJson(double value, string unit, string type, string expectedJson)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions {PropertyNamingPolicy = JsonNamingPolicy.CamelCase};
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+        
+        IQuantity quantity = Quantity.From(value, type, unit);
+        
+        // Act
+        var actualJson = JsonSerializer.Serialize(quantity, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, actualJson);
+    }
+    
+    [Theory]
+    [InlineData(10, "Centimeter", "Length", """{"Value":10,"Unit":"cm","Type":"Length"}""")]
+    [InlineData(5, "Kilogram", "Mass", """{"Value":5,"Type":"Mass"}""")]
+    [InlineData(0, "Second", "Duration", """{"Type":"Duration"}""")]
+    public void Serializing_WithDecimalNotation_IgnoringDefaultValues_ReturnsTheExpectedJson(double value, string unit, string quantityName, string expectedJson)
+    {
+        // Arrange
+        var options = new JsonSerializerOptions {DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault};
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+        
+        IQuantity quantity = Quantity.From(value, quantityName, unit);
+        
+        // Act
+        var actualJson = JsonSerializer.Serialize(quantity, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, actualJson);
+    }
+
+    [Fact]
+    public void Serializing_NullQuantity_WritesNull()
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+
+        IQuantity quantity = null!;
+        
+        // Act
+        var actualJson = JsonSerializer.Serialize(quantity, options);
+        
+        // Assert
+        Assert.Equal("null", actualJson);
+    }
+
+    [Fact]
+    public void Serializing_WithoutQuantityValueConverter_LeavesTheValueObjectEmpty()
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+        
+        IQuantity quantity = new Length(42, LengthUnit.Meter);
+        const string expectedJson = """{"Value":{},"Unit":"m","Type":"Length"}""";
+        
+        // Act
+        var result = JsonSerializer.Serialize(quantity, options);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_UnknownQuantity_ThrowsUnitNotFoundException()
+    {
+        // Arrange
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter(new UnitParser([Mass.Info])));
+        
+        IQuantity quantity = Length.Zero;
+
+        // Assert
+        Assert.Throws<UnitNotFoundException>(() => JsonSerializer.Serialize(quantity, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedQuantityConverterTests.cs b/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedQuantityConverterTests.cs
new file mode 100644
index 0000000000..ee802fc9f9
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedQuantityConverterTests.cs
@@ -0,0 +1,63 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Value;
+using UnitsNet.Units;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests;
+
+[TestSubject(typeof(AbbreviatedQuantityConverter))]
+public class AbbreviatedQuantityConverterTests
+{
+    [Fact]
+    public void Serializing_WithoutAConverter_UsesDefaultFractionalNotationConverter()
+    {
+        // Arrange
+        var json = """{"Value":{"N":42,"D":10},"Unit":"g"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedQuantityConverter());
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_WithDecimalNotationConverter()
+    {
+        // Arrange
+        var json = """{"Value":4.2,"Unit":"g"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedQuantityConverter(new QuantityValueDecimalNotationConverter()));
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void CreateConverter_InvalidType_ReturnsNull()
+    {
+        // Arrange
+        var converter = new AbbreviatedQuantityConverter();
+        var options = new JsonSerializerOptions();
+        Type typeToConvert = typeof(string);
+
+        // Act & Assert
+        Assert.Null(converter.CreateConverter(typeToConvert, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedQuantityGenericConverterTests.cs b/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedQuantityGenericConverterTests.cs
new file mode 100644
index 0000000000..034fdf1805
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/AbbreviatedQuantityGenericConverterTests.cs
@@ -0,0 +1,51 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Value;
+using UnitsNet.Units;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests;
+
+[TestSubject(typeof(AbbreviatedQuantityConverter<,>))]
+public class AbbreviatedQuantityGenericConverterTests
+{
+    [Fact]
+    public void Serializing_WithoutAConverter_UsesDefaultFractionalNotationConverter()
+    {
+        // Arrange
+        var json = """{"Value":{"N":42,"D":10},"Unit":"g"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedQuantityConverter<Mass, MassUnit>());
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+        
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_WithDecimalNotationConverter()
+    {
+        // Arrange
+        var json = """{"Value":4.2,"Unit":"g"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedQuantityConverter<Mass, MassUnit>(Mass.Info, new QuantityValueDecimalNotationConverter()));
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/JsonQuantityConverterFactoryTest.cs b/UnitsNet.Serialization.SystemTextJson.Tests/JsonQuantityConverterFactoryTest.cs
new file mode 100644
index 0000000000..028034a70d
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/JsonQuantityConverterFactoryTest.cs
@@ -0,0 +1,58 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using UnitsNet.Units;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests;
+
+[TestSubject(typeof(JsonQuantityConverter))]
+public class JsonQuantityConverterFactoryTest
+{
+    [Theory]
+    [InlineData(typeof(int), false)]
+    [InlineData(typeof(double), false)]
+    [InlineData(typeof(string), false)]
+    [InlineData(typeof(Length), true)]
+    public void CanConvert_ReturnsExpectedResult(Type typeToConvert, bool expectedResult)
+    {
+        // Arrange
+        var converter = new JsonQuantityConverter();
+
+        // Act
+        var result = converter.CanConvert(typeToConvert);
+
+        // Assert
+        Assert.Equal(expectedResult, result);
+    }
+
+    [Fact]
+    public void CreateConverter_ValidType_ReturnsExpectedConverter()
+    {
+        // Arrange
+        var converter = new JsonQuantityConverter();
+        var options = new JsonSerializerOptions();
+        Type typeToConvert = typeof(Length);
+
+        // Act
+        JsonConverter? result = converter.CreateConverter(typeToConvert, options);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.IsType<JsonQuantityConverter<Length, LengthUnit>>(result);
+    }
+
+    [Fact]
+    public void CreateConverter_InvalidType_ReturnsNull()
+    {
+        // Arrange
+        var converter = new JsonQuantityConverter();
+        var options = new JsonSerializerOptions();
+        Type typeToConvert = typeof(string);
+
+        // Act & Assert
+        Assert.Null(converter.CreateConverter(typeToConvert, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/JsonQuantityConverterTest.cs b/UnitsNet.Serialization.SystemTextJson.Tests/JsonQuantityConverterTest.cs
new file mode 100644
index 0000000000..4b155369b9
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/JsonQuantityConverterTest.cs
@@ -0,0 +1,273 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Unit;
+using UnitsNet.Serialization.SystemTextJson.Value;
+using UnitsNet.Units;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests;
+public sealed class TestObject
+{
+    public Mass? NullableMass { get; set; }
+    public Mass NonNullableMass { get; set; }
+}
+
+[TestSubject(typeof(JsonQuantityConverter<,>))]
+public class JsonQuantityConverterTest
+{
+    [Fact]
+    public void Serializing_WithDecimalNotationAndAbbreviatedUnit()
+    {
+        // Arrange
+        var json = """{"Value":4.2,"Unit":"g"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>());
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_WithDecimalNotationAndAbbreviatedUnit_WithCamelCase()
+    {
+        // Arrange
+        var json = """{"value":4.2,"unit":"g"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_OneKilogram_WithGenericQuantityConverter_IgnoringDefaultValues()
+    {
+        // Arrange
+        var json = """{"Value":{"N":1}}""";
+        var expected = new Mass(QuantityValue.One, MassUnit.Kilogram);
+        var options = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault };
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Default);
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_ZeroGrams_WithGenericQuantityConverter_IgnoringDefaultValues()
+    {
+        // Arrange
+        var json = """{"Unit":6}""";
+        var expected = new Mass(QuantityValue.Zero, MassUnit.Gram);
+        var options = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault };
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_ZeroMass_WithGenericQuantityConverter_IgnoringDefaultValues()
+    {
+        // Arrange
+        var json = "{}";
+        Mass expected = Mass.Zero;
+        var options = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault };
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_MassAsNullable()
+    {
+        // Arrange
+        var testObject = new TestObject { NullableMass = Mass.FromGrams(5), NonNullableMass = Mass.FromMilligrams(10) };
+        var expectedJson = """{"NullableMass":{"Value":5,"Unit":"g"},"NonNullableMass":{"Value":10,"Unit":"mg"}}""";
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Act
+        var json = JsonSerializer.Serialize(testObject, options);
+
+        // Assert
+        Assert.Equal(expectedJson, json);
+    }
+
+    [Fact]
+    public void Serializing_NullMass_AsNullable()
+    {
+        // Arrange
+        var testObject = new TestObject { NonNullableMass = Mass.FromMilligrams(10) };
+        var expectedJson = """{"NullableMass":null,"NonNullableMass":{"Value":10,"Unit":"mg"}}""";
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Act
+        var json = JsonSerializer.Serialize(testObject, options);
+
+        // Assert
+        Assert.Equal(expectedJson, json);
+    }
+
+    [Fact]
+    public void Serializing_NullMass_AsNullable_IgnoringNullValues()
+    {
+        // Arrange
+        var testObject = new TestObject();
+        var expectedJson = """{"NonNullableMass":{"Value":0,"Unit":"kg"}}""";
+
+        var options = new JsonSerializerOptions{DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull};
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Act
+        var json = JsonSerializer.Serialize(testObject, options);
+
+        // Assert
+        Assert.Equal(expectedJson, json);
+    }
+
+    [Fact]
+    public void Serializing_NullMass_AsNullable_IgnoringNullAndDefaultValues()
+    {
+        // Arrange
+        var testObject = new TestObject();
+        var expectedJson = "{}";
+
+        var options = new JsonSerializerOptions{DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault};
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Act
+        var json = JsonSerializer.Serialize(testObject, options);
+
+        // Assert
+        Assert.Equal(expectedJson, json);
+    }
+
+    [Fact]
+    public void Deserializing_WithDecimalNotationAndAbbreviatedUnit_IgnoringCase()
+    {
+        // Arrange
+        var json = """{"VALUE":4.2,"uNit":"G"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true};
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Act
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void Deserializing_WithDecimalNotationAndAbbreviatedUnit_WithExtraProperties(bool caseInsensitive)
+    {
+        // Arrange
+        var json = """{"Value":4.2,"Unit":"g", "Something":"else"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions {PropertyNameCaseInsensitive = caseInsensitive};
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Act
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Deserialize_WithAdditionalProperties_WhenUnmappedMemberHandlingIsDisallowed_ThrowsJsonException(bool caseInsensitive)
+    {
+        // Arrange
+        var invalidJson = """{"Value":4.2,"Unit":"g", "Something":"else"}""";
+        var options = new JsonSerializerOptions { UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow, PropertyNameCaseInsensitive = caseInsensitive };
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(new JsonQuantityConverter<Mass, MassUnit>(Mass.Info));
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Mass>(invalidJson, options));
+    }
+
+    [Fact]
+    public void Constructor_DefaultQuantityInfo_Success()
+    {
+        var converter = new JsonQuantityConverter<Length, LengthUnit>(Length.Info);
+        Assert.NotNull(converter);
+    }
+
+    [Fact]
+    public void Constructor_CustomQuantityInfo_Success()
+    {
+        QuantityInfo<Length, LengthUnit> quantityInfo = Length.Info;
+        var converter = new JsonQuantityConverter<Length, LengthUnit>(quantityInfo);
+        Assert.NotNull(converter);
+    }
+
+    [Fact]
+    public void Read_InvalidJson_ThrowsJsonException()
+    {
+        var options = new JsonSerializerOptions { Converters = { new JsonQuantityConverter<Length, LengthUnit>(Length.Info) } };
+#pragma warning disable JSON001
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<Length>("InvalidJson", options));
+#pragma warning restore JSON001
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/QuantityConverterOptionsTest.cs b/UnitsNet.Serialization.SystemTextJson.Tests/QuantityConverterOptionsTest.cs
new file mode 100644
index 0000000000..cc50810e35
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/QuantityConverterOptionsTest.cs
@@ -0,0 +1,158 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using UnitsNet.Serialization.SystemTextJson.Unit;
+using UnitsNet.Serialization.SystemTextJson.Value;
+using UnitsNet.Units;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests;
+
+public class QuantityConverterOptionsTest
+{
+    [Fact]
+    public void Serializing_WithDecimalNotationConverterAndUnitTypeAndNameConverter_ReturnsExpectedMass()
+    {
+        // Arrange
+        var json = """{"Value":4.2,"Unit":"MassUnit.Gram"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new UnitTypeAndNameConverter());
+        options.Converters.Add(new JsonQuantityConverter());
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_WithFractionalNotationConverterAndStringEnumConverter()
+    {
+        // Arrange
+        var json = """{"Value":{"N":42,"D":10},"Unit":"Gram"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueFractionalNotationConverter(false));
+        options.Converters.Add(new JsonStringEnumConverter());
+        options.Converters.Add(new JsonQuantityConverter());
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_OneKilogram_WithJsonQuantityConverter_IgnoringDefaultValues()
+    {
+        // Arrange
+        var json = """{"Value":{"N":1}}""";
+        var expected = new Mass(QuantityValue.One, MassUnit.Kilogram);
+        var options = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault };
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Default);
+        options.Converters.Add(new JsonQuantityConverter());
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_ArrayOfMasses_WithJsonQuantityConverter_IgnoringDefaultValues()
+    {
+        // Arrange
+        var json = """[{"Value":{"N":42,"D":10},"Unit":6},{"Value":{"N":1}},{}]""";
+        Mass[] masses = [new(4.2m, MassUnit.Gram), new(1, MassUnit.Kilogram), Mass.Zero];
+        var options = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault };
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Default);
+        options.Converters.Add(new JsonQuantityConverter());
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(masses, options);
+        Mass[] result = JsonSerializer.Deserialize<Mass[]>(json, options)!;
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(masses, result);
+    }
+
+
+    [Fact]
+    public void Serializing_WithFractionalNotationAndAbbreviation()
+    {
+        // Arrange
+        var json = """{"Value":{"N":42,"D":10},"Unit":"g"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Default);
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        options.Converters.Add(new JsonQuantityConverter());
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(expected, options);
+        Mass result = JsonSerializer.Deserialize<Mass>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Serializing_ArrayOfMasses_WithJsonQuantityConverter()
+    {
+        // Arrange
+        var json = """[{"Value":{"N":42,"D":10},"Unit":6},{"Value":{"N":1,"D":1},"Unit":8},{"Value":{"N":0,"D":1},"Unit":8}]""";
+        Mass[] masses = [new(4.2m, MassUnit.Gram), new(1, MassUnit.Kilogram), Mass.Zero];
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Default);
+        options.Converters.Add(new JsonQuantityConverter());
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(masses, options);
+        Mass[] result = JsonSerializer.Deserialize<Mass[]>(json, options)!;
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(masses, result);
+    }
+
+    [Fact]
+    public void Serializing_IQuantity_WithDecimalNotationAndAbbreviation()
+    {
+        // Arrange
+        var json = """{"Value":4.2,"Unit":"g","Type":"Mass"}""";
+        var expected = new Mass(4.2m, MassUnit.Gram);
+        IQuantity interfaceQuantity = expected;
+
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        options.Converters.Add(new AbbreviatedInterfaceQuantityWithAvailableValueConverter());
+        options.Converters.Add(new JsonQuantityConverter());  // this one should not be called when serializing via the IQuantity interface
+        options.Converters.Add(new UnitTypeAndNameConverter()); // this one should not be called when serializing via the IQuantity interface
+
+        // Act
+        var actualJson = JsonSerializer.Serialize(interfaceQuantity, options);
+        IQuantity? result = JsonSerializer.Deserialize<IQuantity>(json, options);
+
+        // Assert
+        Assert.Equal(json, actualJson);
+        Assert.Equal(expected, result);
+        Assert.NotEqual(json, JsonSerializer.Serialize(expected, options)); // this should serialize using the UnitTypeAndNameConverter
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/Unit/AbbreviatedUnitConverterTests.cs b/UnitsNet.Serialization.SystemTextJson.Tests/Unit/AbbreviatedUnitConverterTests.cs
new file mode 100644
index 0000000000..5067d028ef
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/Unit/AbbreviatedUnitConverterTests.cs
@@ -0,0 +1,183 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Globalization;
+using System.Text.Json;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Unit;
+using UnitsNet.Units;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests.Unit;
+
+[TestSubject(typeof(AbbreviatedUnitConverter))]
+public class AbbreviatedUnitConverterTests
+{
+    private static JsonSerializerOptions CreateOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedUnitConverter());
+        return options;
+    }
+
+    [Fact]
+    public void Serialize_ReturnsExpectedAbbreviation()
+    {
+        // Arrange
+        const MassUnit unit = MassUnit.Gram;
+        const string expectedJson = """
+                                    "g"
+                                    """;
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        var json = JsonSerializer.Serialize(unit, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, json);
+    }
+    
+    [Fact]
+    public void Serialize_WithConverterForType_ReturnsExpectedAbbreviationForTheSpecifiedType()
+    {
+        // Arrange
+        const MassUnit unit = MassUnit.Gram;
+        const string expectedJson = """
+                                    "g"
+                                    """;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedUnitConverter<MassUnit>());
+        
+        // Act
+        var json = JsonSerializer.Serialize(unit, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, json);
+        Assert.Equal("1", JsonSerializer.Serialize(VolumeUnit.AcreFoot, options));
+    }
+
+    [Fact]
+    public void Serialize_WithCustomAbbreviations_ReturnsExpectedAbbreviation()
+    {
+        // Arrange
+        const MassUnit unit = MassUnit.Gram;
+        const string expectedJson = """
+                                    "g (custom)"
+                                    """;
+        var abbreviations = new UnitAbbreviationsCache([Mass.Info]);
+        abbreviations.MapUnitToDefaultAbbreviation(MassUnit.Gram, CultureInfo.InvariantCulture, "g (custom)");
+        
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedUnitConverter(new UnitParser(abbreviations)));
+        
+        // Act
+        var json = JsonSerializer.Serialize(unit, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, json);
+        Assert.Equal("1", JsonSerializer.Serialize(VolumeUnit.AcreFoot, options));
+    }
+
+    [Fact]
+    public void Serialize_WithCustomCulture_ReturnsExpectedAbbreviation()
+    {
+        // Arrange
+        const MassUnit unit = MassUnit.Gram;
+        const string expectedJson = """
+                                    "\u0433"
+                                    """; // "г"
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedUnitConverter<MassUnit>(UnitParser.Default, CultureInfo.GetCultureInfo("ru-RU")));
+        
+        // Act
+        var json = JsonSerializer.Serialize(unit, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, json);
+    }
+
+    [Fact]
+    public void Serialize_AsDictionaryKey_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var dictionary = new Dictionary<MassUnit, string>
+        {
+            {MassUnit.Gram, "grams"},
+            {MassUnit.Kilogram, "kilograms"}
+        };
+        const string expectedJson = """{"g":"grams","kg":"kilograms"}""";
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        var json = JsonSerializer.Serialize(dictionary, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, json);
+    }
+
+    [Fact]
+    public void Deserialize_ReturnsExpectedMassUnit()
+    {
+        // Arrange
+        const string json = """
+                            "g"
+                            """;
+        const MassUnit expected = MassUnit.Gram;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        MassUnit result = JsonSerializer.Deserialize<MassUnit>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithCustomCulture_ReturnsExpectedMassUnit()
+    {
+        // Arrange
+        var json = """
+                   "\u0433"
+                   """; // "г"
+        MassUnit expected = MassUnit.Gram;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new AbbreviatedUnitConverter(UnitParser.Default, CultureInfo.GetCultureInfo("ru-RU")));
+
+        // Act
+        MassUnit result = JsonSerializer.Deserialize<MassUnit>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_AsDictionaryKey_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string json = """{"g":"grams","kg":"kilograms"}""";
+        var expectedDictionary = new Dictionary<MassUnit, string>
+        {
+            {MassUnit.Gram, "grams"},
+            {MassUnit.Kilogram, "kilograms"}
+        };
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        Dictionary<MassUnit, string>? dictionary = JsonSerializer.Deserialize<Dictionary<MassUnit, string>>(json, options);
+        
+        // Assert
+        Assert.Equal(expectedDictionary, dictionary);
+    }
+
+    [Fact]
+    public void Deserialize_WithInvalidAbbreviation_ThrowsUnitNotFoundException()
+    {
+        // Arrange
+        const string json = """
+                            "invalid"
+                            """;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Assert
+        Assert.Throws<UnitNotFoundException>(() => JsonSerializer.Deserialize<MassUnit>(json, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/Unit/UnitTypeAndNameConverterTests.cs b/UnitsNet.Serialization.SystemTextJson.Tests/Unit/UnitTypeAndNameConverterTests.cs
new file mode 100644
index 0000000000..1ca20d503e
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/Unit/UnitTypeAndNameConverterTests.cs
@@ -0,0 +1,266 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Unit;
+using UnitsNet.Units;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests.Unit;
+
+[TestSubject(typeof(UnitTypeAndNameConverter<>))]
+public class UnitTypeAndNameConverterTests
+{
+    private static JsonSerializerOptions CreateOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new UnitTypeAndNameConverter());
+        return options;
+    }
+
+    [Fact]
+    public void Serialize_ReturnsExpectedTypeAndEnumName()
+    {
+        // Arrange
+        const MassUnit unit = MassUnit.Gram;
+        const string expectedJson = """
+                                    "MassUnit.Gram"
+                                    """;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        var json = JsonSerializer.Serialize(unit, options);
+
+        // Assert
+        Assert.Equal(expectedJson, json);
+    }
+
+    [Fact]
+    public void Serialize_WithConverterForType_ReturnsExpectedTypeAndEnumNameForTheSpecifiedType()
+    {
+        // Arrange
+        const MassUnit unit = MassUnit.Gram;
+        const string expectedJson = """
+                                    "MassUnit.Gram"
+                                    """;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new UnitTypeAndNameConverter<MassUnit>(Mass.Info));
+
+        // Act
+        var json = JsonSerializer.Serialize(unit, options);
+
+        // Assert
+        Assert.Equal(expectedJson, json);
+        Assert.Equal("1", JsonSerializer.Serialize(VolumeUnit.AcreFoot, options));
+    }
+
+    [Fact]
+    public void Serialize_WithCustomQuantities_ReturnsExpectedTypeAndEnumName()
+    {
+        // Arrange
+        const MassUnit unit = MassUnit.Gram;
+        const string expectedJson = """
+                                    "MassUnit.Gram"
+                                    """;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new UnitTypeAndNameConverter(new QuantityInfoLookup([Mass.Info])));
+
+        // Act
+        var json = JsonSerializer.Serialize(unit, options);
+
+        // Assert
+        Assert.Equal(expectedJson, json);
+        Assert.Equal("1", JsonSerializer.Serialize(VolumeUnit.AcreFoot, options));
+    }
+
+    [Fact]
+    public void Serialize_WithCustomMassUnit_ReturnsExpectedTypeAndEnumName()
+    {
+        // Arrange
+        const MassUnit unit = (MassUnit)(-1);
+        var customMassInfo = Mass.MassInfo.CreateDefault(units => units.Append(new UnitDefinition<MassUnit>(unit, "Custom", "Customs", BaseUnits.Undefined)));
+        const string expectedJson = """
+                                    "MassUnit.Custom"
+                                    """;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new UnitTypeAndNameConverter(new QuantityInfoLookup([customMassInfo])));
+
+        // Act
+        var json = JsonSerializer.Serialize(unit, options);
+
+        // Assert
+        Assert.Equal(expectedJson, json);
+    }
+
+    [Fact]
+    public void Serialize_AsDictionaryKey_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var dictionary = new Dictionary<MassUnit, string>
+        {
+            {MassUnit.Gram, "grams"},
+            {MassUnit.Kilogram, "kilograms"}
+        };
+        const string expectedJson = """{"MassUnit.Gram":"grams","MassUnit.Kilogram":"kilograms"}""";
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        var json = JsonSerializer.Serialize(dictionary, options);
+        
+        // Assert
+        Assert.Equal(expectedJson, json);
+    }
+
+    [Fact]
+    public void Deserialize_ReturnsExpectedMassUnit()
+    {
+        // Arrange
+        const string json = """
+                            "MassUnit.Gram"
+                            """;
+        const MassUnit expected = MassUnit.Gram;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        MassUnit result = JsonSerializer.Deserialize<MassUnit>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithLowercaseUnit_ThrowsUnitNotFoundException()
+    {
+        // Arrange
+        const string json = """
+                            "MassUnit.gram"
+                            """;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Assert
+        Assert.Throws<UnitNotFoundException>(() => JsonSerializer.Deserialize<MassUnit>(json, options));
+    }
+
+    [Fact]
+    public void Deserialize_WithLowercaseUnit_AndCaseInsensitiveMatching_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string json = """
+                            "MassUnit.gram"
+                            """;
+        const MassUnit expected = MassUnit.Gram;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new UnitTypeAndNameConverter(true));
+
+        // Act
+        MassUnit result = JsonSerializer.Deserialize<MassUnit>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithCustomUnit_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string json = """
+                            "MassUnit.Custom"
+                            """;
+        const MassUnit expected = (MassUnit)(-1);
+        var customMassInfo = Mass.MassInfo.CreateDefault(units => units.Append(new UnitDefinition<MassUnit>(expected, "Custom", "Customs", BaseUnits.Undefined)));
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new UnitTypeAndNameConverter(new QuantityInfoLookup([customMassInfo])));
+
+        // Act
+        MassUnit result = JsonSerializer.Deserialize<MassUnit>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_AsDictionaryKey_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string json = """{"MassUnit.Gram":"grams","MassUnit.Kilogram":"kilograms"}""";
+        var expectedDictionary = new Dictionary<MassUnit, string>
+        {
+            {MassUnit.Gram, "grams"},
+            {MassUnit.Kilogram, "kilograms"}
+        };
+        
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        Dictionary<MassUnit, string>? dictionary = JsonSerializer.Deserialize<Dictionary<MassUnit, string>>(json, options);
+        
+        // Assert
+        Assert.Equal(expectedDictionary, dictionary);
+    }
+
+    [Fact]
+    public void Deserialize_WithUnitValue_ThrowsUnitNotFoundException()
+    {
+        // Arrange
+        const string json = """
+                            "MassUnit.1"
+                            """;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Assert
+        Assert.Throws<UnitNotFoundException>(() => JsonSerializer.Deserialize<MassUnit>(json, options));
+    }
+
+    [Fact]
+    public void Deserialize_WithEmptyString_ThrowsJsonException()
+    {
+        // Arrange
+        const string json = """
+                            ""
+                            """;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<MassUnit>(json, options));
+    }
+
+    [Fact]
+    public void Deserialize_WithInvalidStringFormat_ThrowsJsonException()
+    {
+        // Arrange
+        const string json = """
+                            "Gram"
+                            """;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<MassUnit>(json, options));
+    }
+
+    [Fact]
+    public void Deserialize_WithInvalidUnitName_ThrowsUnitNotFoundException()
+    {
+        // Arrange
+        const string json = """
+                            "MassUnit.Invalid"
+                            """;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Assert
+        Assert.Throws<UnitNotFoundException>(() => JsonSerializer.Deserialize<MassUnit>(json, options));
+    }
+
+    [Fact]
+    public void Deserialize_WithInvalidUnitName_WhenUsingCaseInsensitiveMatching_ThrowsUnitNotFoundException()
+    {
+        // Arrange
+        const string json = """
+                            "MassUnit.Invalid"
+                            """;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new UnitTypeAndNameConverter(true));
+
+        // Assert
+        Assert.Throws<UnitNotFoundException>(() => JsonSerializer.Deserialize<MassUnit>(json, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/UnitsNet.Serialization.SystemTextJson.Tests.csproj b/UnitsNet.Serialization.SystemTextJson.Tests/UnitsNet.Serialization.SystemTextJson.Tests.csproj
new file mode 100644
index 0000000000..81f78943c1
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/UnitsNet.Serialization.SystemTextJson.Tests.csproj
@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net48;net8.0;net9.0;net10.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="JetBrains.Annotations" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\UnitsNet.Serialization.SystemTextJson\UnitsNet.Serialization.SystemTextJson.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/Value/BigIntegerConverterTests.cs b/UnitsNet.Serialization.SystemTextJson.Tests/Value/BigIntegerConverterTests.cs
new file mode 100644
index 0000000000..f13ae5ec24
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/Value/BigIntegerConverterTests.cs
@@ -0,0 +1,215 @@
+using System.Globalization;
+using System.Numerics;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests.Value;
+
+[TestSubject(typeof(BigIntegerConverter))]
+public class BigIntegerConverterTests
+{
+    private static JsonSerializerOptions CreateOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new BigIntegerConverter());
+        return options;
+    }
+
+    [Fact]
+    public void Serializing_ReturnsBigIntegerAsNumber()
+    {
+        // Arrange: A JSON string without any escape sequences.
+        const string json = "123456789012345678901234567890";
+        var value = BigInteger.Parse("123456789012345678901234567890", CultureInfo.InvariantCulture);
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serializing_VeryLargeNumbers_ReturnsTheExpectedResult()
+    {
+        // Arrange: A JSON string representing the string '10...' with 520 zeros
+        var json = new string(Enumerable.Repeat('0', 520).Prepend('1').ToArray());
+        var value = BigInteger.Pow(10, 520);
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serializing_AsString_ReturnsBigIntegerAsNumber()
+    {
+        // Arrange: A JSON string without any escape sequences.
+        const string json = """
+                            "123456789012345678901234567890"
+                            """;
+        var value = BigInteger.Parse("123456789012345678901234567890", CultureInfo.InvariantCulture);
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.WriteAsString;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serializing_VeryLargeNumbers_AsString_ReturnsTheExpectedResult()
+    {
+        // Arrange: A JSON string representing the string "10..." with 520 zeros
+        var json = new string(Enumerable.Repeat('0', 520).Prepend('1').Prepend('"').Append('"').ToArray());
+        var value = BigInteger.Pow(10, 520);
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.WriteAsString;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Deserializing_NumberString_ReturnsExpectedBigInteger()
+    {
+        // Arrange: A JSON string without any escape sequences.
+        const string json = "123456789012345678901234567890";
+        var expected = BigInteger.Parse("123456789012345678901234567890", CultureInfo.InvariantCulture);
+
+        // Act
+        BigInteger result = JsonSerializer.Deserialize<BigInteger>(json, CreateOptions());
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserializing_QuotedNumber_WithDefaultNumberHandling_ThrowsJsonException()
+    {
+        // Arrange: A JSON string without any escape sequences.
+        const string json = """
+                            "123456789012345678901234567890"
+                            """;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<BigInteger>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_QuotedNumber_WithAllowReadingFromString_ReturnsExpectedBigInteger()
+    {
+        // Arrange: A JSON string without any escape sequences.
+        const string json = """
+                            "123456789012345678901234567890"
+                            """;
+        var expected = BigInteger.Parse("123456789012345678901234567890", CultureInfo.InvariantCulture);
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+
+        // Act
+        BigInteger result = JsonSerializer.Deserialize<BigInteger>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserializing_VeryLongNumbers_ReturnsTheExpectedResult()
+    {
+        // Arrange: A very long number string ('10...' with 520 zeros)
+        var json = new string(Enumerable.Repeat('0', 520).Prepend('1').ToArray());
+        var expected = BigInteger.Pow(10, 520);
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        BigInteger result = JsonSerializer.Deserialize<BigInteger>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_EscapedString_WithAllowReadingFromString_ReturnsExpectedBigInteger()
+    {
+        // Arrange: A JSON string with Unicode escape sequences.
+        // The JSON literal "12345\u0034\u0035" should be interpreted as "1234545".
+        var json = """
+                   "12345\u0034\u0035"
+                   """;
+        var expected = BigInteger.Parse("1234545", CultureInfo.InvariantCulture);
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+
+        // Act
+        BigInteger result = JsonSerializer.Deserialize<BigInteger>(json, options);
+    
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserializing_InvalidNumberString_ThrowsFormatException()
+    {
+        // Arrange: A JSON string without any escape sequences.
+#pragma warning disable JSON001
+        const string json = """
+                            "12345678901234567890123456789invalid0"
+                            """;
+#pragma warning restore JSON001
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+
+        // Assert
+        Assert.Throws<FormatException>(() => JsonSerializer.Deserialize<BigInteger>(json, options));
+    }
+    
+    [Fact]
+    public void Deserializing_EmptyString_ThrowsJsonException()
+    {
+        // Arrange: A JSON string without any escape sequences.
+        const string json = """
+                            ""
+                            """;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+
+        // Assert
+        Assert.Throws<FormatException>(() => JsonSerializer.Deserialize<BigInteger>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_EmptyObjectString_ThrowsJsonException()
+    {
+        // Arrange: A JSON string without any escape sequences.
+        const string json = "{}";
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<BigInteger>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_NullObject_ThrowsJsonException()
+    {
+        // Arrange: A JSON string without any escape sequences.
+        const string json = "null";
+        JsonSerializerOptions options = CreateOptions();
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<BigInteger>(json, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueDecimalConverterTests.cs b/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueDecimalConverterTests.cs
new file mode 100644
index 0000000000..0674edcd52
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueDecimalConverterTests.cs
@@ -0,0 +1,248 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests.Value;
+
+[TestSubject(typeof(QuantityValueDecimalConverter))]
+public class QuantityValueDecimalConverterTests
+{
+    private static JsonSerializerOptions CreateOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalConverter());
+        return options;
+    }
+    
+    [Fact]
+    public void Serialize_ReturnsTheValueInDecimalNotation()
+    {
+        // Arrange
+        var json = "4.2";
+        QuantityValue value = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WithJsonNumberHandling_WriteAsString_ReturnsTheValueInDecimalNotation()
+    {
+        // Arrange
+        var json = "\"4.2\"";
+        QuantityValue value = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.WriteAsString;
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WithDefaultSettings_ReturnsTheValueFormattedAsG29()
+    {
+        // Arrange
+        var json = "0.3333333333333333333333333333";
+        var value = QuantityValue.FromTerms(1, 3);
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WithNumbersBeyondTheDecimalRange_ThrowsOverflowException()
+    {
+        // Arrange
+        var value = QuantityValue.FromPowerOfTen(1, 40);
+        JsonSerializerOptions options = CreateOptions();
+        
+        Assert.Throws<OverflowException>(() => JsonSerializer.Serialize(value, options));
+    }
+
+    [Fact]
+    public void Serializing_NaN_or_Infinity_WithStrictNumberHandling_ThrowsJsonException()
+    {
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.Strict;
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(QuantityValue.NaN, options));
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(QuantityValue.PositiveInfinity, options));
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(QuantityValue.NegativeInfinity, options));
+    }
+
+    [Fact]
+    public void Serializing_NaN_WithAllowNamedFloatingPointLiterals_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var expectedJson = "\"NaN\"";
+        var value = QuantityValue.NaN;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_PositiveInfinity_WithAllowNamedFloatingPointLiterals_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var expectedJson = "\"Infinity\"";
+        var value = QuantityValue.PositiveInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Deserialize_ValidNumberString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "4.2";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_NumberStringInScientificNotation_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "3.3333333E-06";
+        QuantityValue expected = 3.3333333E-06; // ~ 1/300_000
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+    
+    [Fact]
+    public void Deserialize_QuotedNumber_With_AllowReadingFromString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"4.2\"";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_PositiveInfinity_With_AllowNamedFloatingPointLiterals_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"Infinity\"";
+        QuantityValue expected = QuantityValue.PositiveInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_NegativeInfinity_With_AllowNamedFloatingPointLiterals_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"-Infinity\"";
+        QuantityValue expected = QuantityValue.NegativeInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_NaN_With_AllowNamedFloatingPointLiterals_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"NaN\"";
+        QuantityValue expected = QuantityValue.NaN;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserializing_NaN_Without_AllowNamedFloatingPointLiterals_FormatException()
+    {
+        // Arrange
+        var json = "\"NaN\"";
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+        
+        // Assert
+        Assert.Throws<FormatException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithInvalidString_ThrowsFormatException()
+    {
+        // Arrange
+        var json = "\"123invalid456\"";
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithEmptyObjectString_ThrowsJsonException()
+    {
+        // Arrange
+        var json = "{}";
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueDecimalNotationConverterTests.cs b/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueDecimalNotationConverterTests.cs
new file mode 100644
index 0000000000..266bcd9d0a
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueDecimalNotationConverterTests.cs
@@ -0,0 +1,275 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests.Value;
+
+[TestSubject(typeof(QuantityValueDecimalNotationConverter))]
+public class QuantityValueDecimalNotationConverterTests
+{
+    private static JsonSerializerOptions CreateOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter());
+        return options;
+    }
+
+    [Fact]
+    public void Creating_WithNegativePrecision_ThrowsArgumentOutOfRangeException()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new QuantityValueDecimalNotationConverter(-1));
+    }
+
+    [Fact]
+    public void Serialize_ReturnsTheValueInDecimalNotation()
+    {
+        // Arrange
+        var json = "4.2";
+        QuantityValue value = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WithJsonNumberHandling_WriteAsString_ReturnsTheValueInDecimalNotation()
+    {
+        // Arrange
+        var json = "\"4.2\"";
+        QuantityValue value = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.WriteAsString;
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WithDefaultSettings_ReturnsTheValueFormattedAsG17()
+    {
+        // Arrange
+        var json = "0.33333333333333333";
+        var value = QuantityValue.FromTerms(1, 3);
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WithMaxNumberOfSignificantDigits_ReturnsTheValueWithTheSpecifiedPrecision()
+    {
+        // Arrange
+        var json = "3.3333333E-06";
+        var value = QuantityValue.FromTerms(1, 300_000);
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter(8));
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WithExtremeNumberOfSignificantDigits_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var json = "0." + new string(Enumerable.Repeat('3', 260).ToArray());
+        var value = QuantityValue.FromTerms(1, 3);
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDecimalNotationConverter(260));
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serializing_NaN_or_Infinity_WithStrictNumberHandling_ThrowsJsonException()
+    {
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.Strict;
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(QuantityValue.NaN, options));
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(QuantityValue.PositiveInfinity, options));
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(QuantityValue.NegativeInfinity, options));
+    }
+
+    [Fact]
+    public void Serializing_NaN_WithAllowNamedFloatingPointLiterals_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var expectedJson = "\"NaN\"";
+        var value = QuantityValue.NaN;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_PositiveInfinity_WithAllowNamedFloatingPointLiterals_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var expectedJson = "\"Infinity\"";
+        var value = QuantityValue.PositiveInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Deserialize_ValidNumberString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "4.2";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_NumberStringInScientificNotation_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "3.3333333E-06";
+        QuantityValue expected = 3.3333333E-06; // ~ 1/300_000
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+    
+    [Fact]
+    public void Deserialize_QuotedNumber_With_AllowReadingFromString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"4.2\"";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_PositiveInfinity_With_AllowNamedFloatingPointLiterals_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"Infinity\"";
+        QuantityValue expected = QuantityValue.PositiveInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_NegativeInfinity_With_AllowNamedFloatingPointLiterals_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"-Infinity\"";
+        QuantityValue expected = QuantityValue.NegativeInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_NaN_With_AllowNamedFloatingPointLiterals_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"NaN\"";
+        QuantityValue expected = QuantityValue.NaN;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserializing_NaN_Without_AllowNamedFloatingPointLiterals_ThrowsJsonException()
+    {
+        // Arrange
+        var json = "\"NaN\"";
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithInvalidString_ThrowsJsonException()
+    {
+        // Arrange
+        var json = "\"123invalid456\"";
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithEmptyObjectString_ThrowsJsonException()
+    {
+        // Arrange
+        var json = "{}";
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueDoubleConverterTests.cs b/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueDoubleConverterTests.cs
new file mode 100644
index 0000000000..29a31be0ee
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueDoubleConverterTests.cs
@@ -0,0 +1,259 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests.Value;
+
+[TestSubject(typeof(QuantityValueDoubleConverter))]
+public class QuantityValueDoubleConverterTests
+{
+    private static JsonSerializerOptions CreateOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(new QuantityValueDoubleConverter());
+        return options;
+    }
+
+    [Fact]
+    public void Constructor_GivenAnInvalidNumberOfSignificantDigits_ThrowsArgumentException()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new QuantityValueDoubleConverter(0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new QuantityValueDoubleConverter(18));
+    }
+    
+    [Fact]
+    public void Serialize_ReturnsTheValueInDecimalNotation()
+    {
+        // Arrange
+        #if NET
+        var json = "4.2";
+        #else
+        var json = "4.2000000000000002";
+        #endif
+        QuantityValue value = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+        Assert.Equal(json, JsonSerializer.Serialize(4.2, options)); // same as serializing the double
+    }
+
+    [Fact]
+    public void Serialize_WithJsonNumberHandling_WriteAsString_ReturnsTheValueInDecimalNotation()
+    {
+        // Arrange
+        var json = "\"4.2\"";
+        QuantityValue value = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.WriteAsString;
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+#if NET
+        Assert.Equal(json, JsonSerializer.Serialize(4.2, options)); // same as serializing the double
+ #else
+        Assert.Equal("\"4.2000000000000002\"", JsonSerializer.Serialize(4.2, options)); // not sure why this is different...
+#endif
+    }
+
+    [Fact]
+    public void Serialize_WithDefaultSettings_ReturnsTheValueFormattedAsG17()
+    {
+        // Arrange
+#if NET
+        var json = "0.3333333333333333";
+#else
+        var json = "0.33333333333333331";
+#endif
+        var value = QuantityValue.FromTerms(1, 3);
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+        Assert.Equal(json, JsonSerializer.Serialize(1 / 3.0, options)); // same as serializing the double
+    }
+
+    [Fact]
+    public void Serializing_NaN_or_Infinity_WithStrictNumberHandling_ThrowsJsonException()
+    {
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.Strict;
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(QuantityValue.NaN, options));
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(QuantityValue.PositiveInfinity, options));
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(QuantityValue.NegativeInfinity, options));
+    }
+
+    [Fact]
+    public void Serializing_NaN_WithAllowNamedFloatingPointLiterals_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var expectedJson = "\"NaN\"";
+        var value = QuantityValue.NaN;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_PositiveInfinity_WithAllowNamedFloatingPointLiterals_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        var expectedJson = "\"Infinity\"";
+        var value = QuantityValue.PositiveInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Deserialize_ValidNumberString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "4.2";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_NumberStringInScientificNotation_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "3.3333333E-06";
+        QuantityValue expected = 3.3333333E-06; // ~ 1/300_000
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+    
+    [Fact]
+    public void Deserialize_QuotedNumber_With_AllowReadingFromString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"4.2\"";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_PositiveInfinity_With_AllowNamedFloatingPointLiterals_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"Infinity\"";
+        QuantityValue expected = QuantityValue.PositiveInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_NegativeInfinity_With_AllowNamedFloatingPointLiterals_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"-Infinity\"";
+        QuantityValue expected = QuantityValue.NegativeInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_NaN_With_AllowNamedFloatingPointLiterals_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        var json = "\"NaN\"";
+        QuantityValue expected = QuantityValue.NaN;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserializing_NaN_Without_AllowNamedFloatingPointLiterals_ThrowsJsonException()
+    {
+        // Arrange
+        var json = "\"NaN\"";
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithInvalidString_ThrowsJsonException()
+    {
+        // Arrange
+        var json = "\"123invalid456\"";
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithEmptyObjectString_ThrowsJsonException()
+    {
+        // Arrange
+        var json = "{}";
+        JsonSerializerOptions options = CreateOptions();
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueFractionalNotationConverterTests.cs b/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueFractionalNotationConverterTests.cs
new file mode 100644
index 0000000000..0e3fb549c4
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueFractionalNotationConverterTests.cs
@@ -0,0 +1,370 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests.Value;
+
+[TestSubject(typeof(QuantityValueFractionalNotationConverter))]
+public class QuantityValueFractionalNotationConverterTests
+{
+    private static JsonSerializerOptions CreateDefaultOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Default);
+        return options;
+    }
+
+    [Fact]
+    public void Creating_WithNullBigIntegerConverter_ThrowsArgumentOutOfRangeException()
+    {
+        Assert.Throws<ArgumentNullException>(() => new QuantityValueFractionalNotationConverter(null!));
+    }
+
+    [Fact]
+    public void Serialize_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string json = """{"N":42,"D":10}""";
+        QuantityValue value = 4.2m;
+        JsonSerializerOptions options = CreateDefaultOptions();
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WithReduction_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string json = """{"N":21,"D":5}""";
+        QuantityValue value = 4.2m;
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(QuantityValueFractionalNotationConverter.Reducing);
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WithLowerCaseProperties_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string json = """{"n":42,"d":10}""";
+        QuantityValue value = 4.2m;
+        JsonSerializerOptions options = CreateDefaultOptions();
+        options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_Zero_WithDefaultSettings_ReturnsBothTerms()
+    {
+        // Arrange
+        const string json = """{"N":0,"D":1}""";
+        var value = QuantityValue.Zero;
+        JsonSerializerOptions options = CreateDefaultOptions();
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_Zero_IgnoringDefaultValues_ReturnsAnEmptyObject()
+    {
+        // Arrange
+        var json = "{}";
+        var value = QuantityValue.Zero;
+        JsonSerializerOptions options = CreateDefaultOptions();
+        options.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault;
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_IntegerNumber_WithIgnoreCondition_WhenWritingDefault_ReturnsTheNumerator()
+    {
+        // Arrange
+        const string json = """{"N":5}""";
+        QuantityValue value = 5;
+        JsonSerializerOptions options = CreateDefaultOptions();
+        options.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault;
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_DecimalNumber_WithIgnoreCondition_WhenWritingDefault_ReturnsBothTerms()
+    {
+        // Arrange
+        const string json = """{"N":42,"D":10}""";
+        QuantityValue value = 4.2m;
+        JsonSerializerOptions options = CreateDefaultOptions();
+        options.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault;
+        
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+        
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Deserialize_ValidJson_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = """{"N":42,"D":10}""";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_ValidJson_WithLowercasePolicy_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = """{"n":42,"d":10}""";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateDefaultOptions();
+        options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
+        
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_ValidJson_WithCaseInsensitiveMatching_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = """{"N":42,"d":10}""";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateDefaultOptions();
+        options.PropertyNameCaseInsensitive = true;
+        
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_ValidJson_WithAdditionalProperties_WithCaseInsensitiveMatching_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = """{"N":42,"something":2,"d":10}""";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateDefaultOptions();
+        options.PropertyNameCaseInsensitive = true;
+        
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_JsonWithQuotedTerms_WithDefaultNumberHandling_ThrowsJsonException()
+    {
+        // Arrange
+        const string json = """{"N":"42","D":"10"}""";
+        JsonSerializerOptions options = CreateDefaultOptions();
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserialize_ValidJsonWithQuotedTerms_WithAllowReadingFromString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = """{"N":"42","D":"10"}""";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateDefaultOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithoutDenominator_ReturnsTheExpectedIntegerValue()
+    {
+        // Arrange
+        const string json = """{"N":42}""";
+        QuantityValue expected = 42;
+        JsonSerializerOptions options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithoutNumeratorAndDenominator_ReturnsZero()
+    {
+        // Arrange
+        var json = "{}";
+        QuantityValue expected = QuantityValue.Zero;
+        JsonSerializerOptions options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithoutNumeratorAndNonZeroDenominator_ReturnsZero()
+    {
+        // Arrange
+        const string json = """{"D":1}""";
+        QuantityValue expected = QuantityValue.Zero;
+        JsonSerializerOptions options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithoutNumeratorAndZeroDenominator_ReturnsNaN()
+    {
+        // Arrange
+        const string json = """{"D":0}""";
+        QuantityValue expected = QuantityValue.NaN;
+        JsonSerializerOptions options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithoutPositiveNumeratorAndZeroDenominator_ReturnsPositiveInfinity()
+    {
+        // Arrange
+        const string json = """{"N":1,"D":0}""";
+        QuantityValue expected = QuantityValue.PositiveInfinity;
+        JsonSerializerOptions options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithNegativeNumeratorAndZeroDenominator_ReturnsNegativeInfinity()
+    {
+        // Arrange
+        const string json = """{"N":-1,"D":0}""";
+        QuantityValue expected = QuantityValue.NegativeInfinity;
+        JsonSerializerOptions options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_WithAdditionalProperties_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string json = """{"N":42,"D":10,"C":1}""";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateDefaultOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+        
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Deserialize_WithAdditionalProperties_WhenUnmappedMemberHandlingIsDisallowed_ThrowsJsonException(bool caseInsensitive)
+    {
+        // Arrange
+        const string invalidJson = """{"N":42,"D":10,"C":1}""";
+        JsonSerializerOptions options = CreateDefaultOptions();
+        options.PropertyNameCaseInsensitive = caseInsensitive;
+        options.UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow;
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(invalidJson, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithInvalidString_ThrowsFormatException()
+    {
+        // Arrange
+        const string invalidJson = """{"N":"4invalid2","D":"10"}""";
+        JsonSerializerOptions options = CreateDefaultOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+
+        // Assert
+        Assert.Throws<FormatException>(() => JsonSerializer.Deserialize<QuantityValue>(invalidJson, options));
+    }
+
+    [Theory]
+    [InlineData("43")]
+    [InlineData("""{"N":4""")]
+    public void Deserializing_WithInvalidJsonString_ThrowsJsonException(string invalidJson)
+    {
+        // Arrange
+        JsonSerializerOptions options = CreateDefaultOptions();
+        
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(invalidJson, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueMixedNotationConverterTests.cs b/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueMixedNotationConverterTests.cs
new file mode 100644
index 0000000000..e006139468
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson.Tests/Value/QuantityValueMixedNotationConverterTests.cs
@@ -0,0 +1,398 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Numerics;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using JetBrains.Annotations;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Serialization.SystemTextJson.Tests.Value;
+
+[TestSubject(typeof(QuantityValueMixedNotationConverter))]
+public class QuantityValueMixedNotationConverterTests
+{
+    private static JsonSerializerOptions CreateOptions()
+    {
+        var options = new JsonSerializerOptions();
+        options.Converters.Add(QuantityValueMixedNotationConverter.Default);
+        return options;
+    }
+
+    [Fact]
+    public void Serialize_WholeNumber_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = "42";
+        QuantityValue value = 42;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WholeNumber_WithoutReduction_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = "42";
+        var value = QuantityValue.FromTerms(420, 10);
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_WholeNumber_AsString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = """
+                            "42"
+                            """;
+        QuantityValue value = 42;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.WriteAsString;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_VeryLargeWholeNumber_ReturnsTheExpectedResult()
+    {
+        // Arrange: 1e260 (written with all its zeros)
+        var json = new string(Enumerable.Repeat('0', 512).Prepend('1').ToArray());
+        QuantityValue value = BigInteger.Pow(10, 512);
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_TerminatingDecimal_ReturnsTheValueInDecimalNotation()
+    {
+        // Arrange
+        const string json = "4.25";
+        QuantityValue value = 4.25m;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_TerminatingDecimal_AsString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = """
+                            "42.5"
+                            """;
+        QuantityValue value = 42.5m;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.WriteAsString;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_NonTerminatingDecimal_ReturnsTheValueFraction()
+    {
+        // Arrange
+        const string json = """
+                            "1/3"
+                            """;
+        var value = QuantityValue.FromTerms(1, 3);
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+    
+    [Theory]
+    [InlineData(510)]
+    [InlineData(511)]
+    public void Serialize_VeryLargeDecimalNumber_ReturnsTheExpectedResult(int nbZeros)
+    {
+        // Arrange: 10000[...]4.2 (written as a decimal, with all its zeros)
+        var json = $"1{new string(Enumerable.Repeat('0', nbZeros).ToArray())}4.2";
+        var value = QuantityValue.FromTerms(42 + BigInteger.Pow(10, nbZeros + 2), 10);
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Fact]
+    public void Serialize_VeryLargeDecimalNumber_AsString_ReturnsTheExpectedResult()
+    {
+        // Arrange: 4.2e-255 (written as a quoted decimal, with all its zeros)
+        var json = $"""
+                    "0.{new string(Enumerable.Repeat('0', 512).ToArray())}42"
+                    """;
+        var value = QuantityValue.FromPowerOfTen(42, -514);
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.WriteAsString;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+
+    [Theory]
+    [InlineData(511)]
+    [InlineData(512)]
+    [InlineData(-510)]
+    public void Serialize_FractionalWithLargeExponent_ReturnsTheExpectedResult(int exponent)
+    {
+        // Arrange: (1/3)e256 (written as a fraction, with all its zeros)
+        var value = QuantityValue.FromPowerOfTen(1, 3, exponent);
+        var (numerator, denominator) = QuantityValue.Reduce(value);
+        var json = $"""
+                    "{numerator}/{denominator}"
+                    """;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(json, result);
+    }
+    
+//     [Theory]
+//     // [InlineData(250, 250)]
+//     // [InlineData(40, 250)]
+//     [InlineData(2, 1)]
+//     // [InlineData(14, 6)]
+//     // [InlineData(25, 3)]
+//     public void Serialize_FractionalWithLargeTerms_ReturnsTheExpectedResult(int numeratorDigits, int denominatorDigits)
+//     {
+//         // Arrange: (1/3)e256 (written as a fraction, with all its zeros)
+//         var value = QuantityValue.FromTerms(
+//             BigInteger.Parse(new string(Enumerable.Repeat('2', numeratorDigits).ToArray())),
+//             BigInteger.Parse("1234567" + new string(Enumerable.Repeat('3', denominatorDigits).ToArray())));
+//         var (numerator, denominator) = QuantityValue.Reduce(value);
+//         var json = $"""
+//                     "{numerator}/{denominator}"
+//                     """;
+//         JsonSerializerOptions options = CreateOptions();
+//
+//         // Act
+//         var result = JsonSerializer.Serialize(value, options);
+//
+//         // Assert
+//         Assert.Equal(json, result);
+//     }
+
+    [Fact]
+    public void Serializing_NaN_WithDefaultNumberHandling_ThrowsJsonException()
+    {
+        JsonSerializerOptions options = CreateOptions();
+        Assert.Throws<JsonException>(() => JsonSerializer.Serialize(QuantityValue.NaN, options));
+    }
+
+    [Fact]
+    public void Serializing_NaN_WithAllowNamedFloatingPointLiterals_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string expectedJson = """
+                                    "NaN"
+                                    """;
+        QuantityValue value = QuantityValue.NaN;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_PositiveInfinity_WithAllowNamedFloatingPointLiterals_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string expectedJson = """
+                                    "Infinity"
+                                    """;
+        QuantityValue value = QuantityValue.PositiveInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Serializing_NegativeInfinity_WithAllowNamedFloatingPointLiterals_ReturnsTheExpectedResult()
+    {
+        // Arrange
+        const string expectedJson = """
+                                    "-Infinity"
+                                    """;
+        QuantityValue value = QuantityValue.NegativeInfinity;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals;
+
+        // Act
+        var result = JsonSerializer.Serialize(value, options);
+
+        // Assert
+        Assert.Equal(expectedJson, result);
+    }
+
+    [Fact]
+    public void Deserialize_DecimalNumberString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = "4.2";
+        QuantityValue expected = 4.2m;
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_NumberStringInScientificNotation_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = "3.3333333E-06";
+        QuantityValue expected = 3.3333333E-06; // ~ 1/300_000
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void Deserialize_FractionString_ReturnsTheExpectedValue()
+    {
+        // Arrange
+        const string json = """
+                            "1/3"
+                            """;
+        var expected = QuantityValue.FromTerms(1, 3);
+        JsonSerializerOptions options = CreateOptions();
+
+        // Act
+        QuantityValue result = JsonSerializer.Deserialize<QuantityValue>(json, options);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData("""
+                "12345"
+                """)]
+    [InlineData("""
+                "12345\u0034\u0035"
+                """)]
+    public void Deserializing_QuotedNumber_WithDefaultNumberHandling_ThrowsJsonException(string json)
+    {
+        JsonSerializerOptions options = CreateOptions();
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithValidEscapedCharacters_ReturnsTheExpectedResult()
+    {
+        // Arrange 1234545 (using the unicode '4')
+        const string json = """
+                            "12345\u0034\u0035"
+                            """;
+        QuantityValue expectedValue = 1234545;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+
+        // Assert
+        Assert.Equal(expectedValue, JsonSerializer.Deserialize<int>(json, options));
+        Assert.Equal(expectedValue, JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Theory]
+    [InlineData("""
+                "123invalid456"
+                """)]
+    [InlineData("""
+                "123/invalid456"
+                """)]
+    public void Deserializing_WithInvalidString_ThrowsFormatException(string json)
+    {
+        // Arrange
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+
+        // Assert
+        Assert.Throws<FormatException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithEmptyString_ThrowsFormatException()
+    {
+        // Arrange
+        const string json = """
+                            ""
+                            """;
+        JsonSerializerOptions options = CreateOptions();
+        options.NumberHandling = JsonNumberHandling.AllowReadingFromString;
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<double>(json, options));
+        Assert.Throws<FormatException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+
+    [Fact]
+    public void Deserializing_WithEmptyObjectString_ThrowsJsonException()
+    {
+        // Arrange
+        const string json = "{}";
+        JsonSerializerOptions options = CreateOptions();
+
+        // Assert
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<double>(json, options));
+        Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<QuantityValue>(json, options));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/AbbreviatedInterfaceQuantityWithAvailableValueConverter.cs b/UnitsNet.Serialization.SystemTextJson/AbbreviatedInterfaceQuantityWithAvailableValueConverter.cs
new file mode 100644
index 0000000000..a2e11de676
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/AbbreviatedInterfaceQuantityWithAvailableValueConverter.cs
@@ -0,0 +1,228 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+#if NET
+using System.Diagnostics.CodeAnalysis;
+#endif
+
+namespace UnitsNet.Serialization.SystemTextJson;
+
+/// <summary>
+///     Provides a custom JSON converter for <see cref="UnitsNet.IQuantity" />.
+///     This converter handles serialization and deserialization of quantities,
+///     ensuring that <see cref="UnitsNet.IQuantity" /> objects are correctly
+///     represented in JSON format.
+/// </summary>
+public abstract class AbbreviatedInterfaceQuantityConverterBase : InterfaceQuantityConverterBase<string?>
+{
+    private readonly CultureInfo _culture = CultureInfo.InvariantCulture;
+    private readonly UnitParser _unitParser;
+
+    /// <summary>
+    ///     Initializes a new instance of the converter using the default  <see cref="UnitParser" />.
+    /// </summary>
+    protected AbbreviatedInterfaceQuantityConverterBase()
+        : this(UnitParser.Default)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the converter using the provided <see cref="UnitParser" />.
+    /// </summary>
+    /// <param name="unitParser">
+    ///     The <see cref="UnitParser" /> used for deserializing an abbreviation back into its
+    ///     corresponding unit.
+    /// </param>
+    /// <exception cref="ArgumentNullException">
+    ///     Thrown when the <paramref name="unitParser" /> parameter is <c>null</c>.
+    /// </exception>
+    protected AbbreviatedInterfaceQuantityConverterBase(UnitParser unitParser)
+    {
+        _unitParser = unitParser ?? throw new ArgumentNullException(nameof(unitParser));
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the converter using the provided <see cref="UnitParser" />.
+    /// </summary>
+    /// <param name="unitParser">
+    ///     The <see cref="UnitParser" /> used for deserializing an abbreviation back into its
+    ///     corresponding unit.
+    /// </param>
+    /// <param name="culture">The primary culture that is used for the unit abbreviations.</param>
+    /// <exception cref="ArgumentNullException">
+    ///     Thrown when the <paramref name="unitParser" /> parameter is <c>null</c>.
+    /// </exception>
+    protected AbbreviatedInterfaceQuantityConverterBase(UnitParser unitParser, CultureInfo culture)
+    {
+        _unitParser = unitParser ?? throw new ArgumentNullException(nameof(unitParser));
+        _culture = culture ?? throw new ArgumentNullException(nameof(culture));
+    }
+
+    /// <inheritdoc />
+    protected override void WriteUnitProperty(Utf8JsonWriter writer, IQuantity quantity, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(_unitParser.Abbreviations.GetDefaultAbbreviation(quantity.UnitKey, _culture));
+    }
+
+    /// <inheritdoc />
+    protected override string? ReadUnitProperty(ref Utf8JsonReader reader, JsonSerializerOptions options)
+    {
+        return reader.GetString();
+    }
+
+    /// <inheritdoc />
+    protected override IQuantity CreateQuantity(QuantityValue value, string? unitAbbreviation, string? quantityName)
+    {
+        UnitInfo unitInfo;
+        if (quantityName != null && unitAbbreviation != null)
+        {
+            unitInfo = _unitParser.GetUnitFromAbbreviation(quantityName, unitAbbreviation, _culture);
+        }
+        else if (unitAbbreviation != null)
+        {
+            unitInfo = _unitParser.GetUnitFromAbbreviation(unitAbbreviation, _culture);
+        }
+        else if (quantityName != null)
+        {
+            unitInfo = _unitParser.Quantities.GetQuantityByName(quantityName).BaseUnitInfo;
+        }
+        else
+        {
+            throw new JsonException("Both the quantity name and unit abbreviation are missing from the JSON.");
+        }
+
+        return unitInfo.From(value);
+    }
+}
+
+/// <summary>
+///     Provides a specialized JSON converter for <see cref="UnitsNet.IQuantity" /> that utilizes a custom
+///     <see cref="System.Text.Json.Serialization.JsonConverter{T}" /> for handling the value property of quantities.
+///     This class extends the functionality of <see cref="AbbreviatedInterfaceQuantityWithAvailableValueConverter" /> by
+///     enabling
+///     the use of a specific value converter for serialization and deserialization of the quantity's value.
+/// </summary>
+public class AbbreviatedInterfaceQuantityWithValueConverter : AbbreviatedInterfaceQuantityConverterBase
+{
+    private readonly JsonConverter<QuantityValue> _valueConverter;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedInterfaceQuantityWithValueConverter" /> class
+    ///     with the specified value converter for handling the <see cref="QuantityValue" /> property of quantities.
+    /// </summary>
+    /// <param name="valueConverter">
+    ///     The <see cref="JsonConverter{T}" /> to be used for serializing and deserializing the <see cref="QuantityValue" />
+    ///     property.
+    /// </param>
+    public AbbreviatedInterfaceQuantityWithValueConverter(JsonConverter<QuantityValue> valueConverter)
+        : this(valueConverter, UnitParser.Default)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the
+    ///     <see cref="AbbreviatedInterfaceQuantityWithValueConverter" /> class
+    ///     with the specified value converter and unit parser.
+    /// </summary>
+    /// <param name="valueConverter">
+    ///     The <see cref="System.Text.Json.Serialization.JsonConverter{T}" /> used to handle the serialization and
+    ///     deserialization of the value property of quantities.
+    /// </param>
+    /// <param name="unitParser">
+    ///     The <see cref="UnitsNet.UnitParser" /> used to parse and interpret unit abbreviations.
+    /// </param>
+    /// <exception cref="System.ArgumentNullException">
+    ///     Thrown when <paramref name="valueConverter" /> is <c>null</c>.
+    /// </exception>
+    public AbbreviatedInterfaceQuantityWithValueConverter(JsonConverter<QuantityValue> valueConverter, UnitParser unitParser)
+        : base(unitParser)
+    {
+        _valueConverter = valueConverter ?? throw new ArgumentNullException(nameof(valueConverter));
+    }
+
+    /// <inheritdoc />
+    protected override QuantityValue ReadValueProperty(ref Utf8JsonReader reader, JsonSerializerOptions options)
+    {
+        return _valueConverter.Read(ref reader, typeof(QuantityValue), options);
+    }
+
+    /// <inheritdoc />
+    protected override void WriteValueProperty(Utf8JsonWriter writer, IQuantity quantity, JsonSerializerOptions options)
+    {
+        _valueConverter.Write(writer, quantity.Value, options);
+    }
+}
+
+/// <summary>
+///     Provides a custom JSON converter for <see cref="UnitsNet.IQuantity" />.
+///     This converter handles serialization and deserialization of quantities,
+///     ensuring that <see cref="UnitsNet.IQuantity" /> objects are correctly
+///     represented in JSON format.
+/// </summary>
+#if NET
+[RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")]
+[RequiresUnreferencedCode(
+    "If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
+#endif
+public class AbbreviatedInterfaceQuantityWithAvailableValueConverter : AbbreviatedInterfaceQuantityConverterBase
+{
+    /// <inheritdoc />
+    public AbbreviatedInterfaceQuantityWithAvailableValueConverter()
+    {
+    }
+
+    /// <inheritdoc />
+    public AbbreviatedInterfaceQuantityWithAvailableValueConverter(UnitParser unitParser)
+        : base(unitParser)
+    {
+    }
+
+    /// <inheritdoc />
+    public AbbreviatedInterfaceQuantityWithAvailableValueConverter(UnitParser unitParser, CultureInfo culture)
+        : base(unitParser, culture)
+    {
+    }
+
+    /// <summary>
+    ///     Reads the value property of a JSON object representing a quantity.
+    /// </summary>
+    /// <param name="reader">
+    ///     The <see cref="Utf8JsonReader" /> used to read the JSON data.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for deserialization.
+    /// </param>
+    /// <returns>
+    ///     A <see cref="QuantityValue" /> representing the value of the quantity read from the JSON data.
+    /// </returns>
+    /// <remarks>
+    ///     This method is virtual, allowing derived classes to customize how the value property is read.
+    /// </remarks>
+    /// <exception cref="JsonException">
+    ///     Thrown if the JSON data is invalid or cannot be deserialized into a <see cref="QuantityValue" />.
+    /// </exception>
+    protected override QuantityValue ReadValueProperty(ref Utf8JsonReader reader, JsonSerializerOptions options)
+    {
+        return JsonSerializer.Deserialize<QuantityValue>(ref reader, options);
+    }
+
+    /// <summary>
+    ///     Writes the "Value" property of the quantity to the JSON output.
+    /// </summary>
+    /// <param name="writer">
+    ///     The <see cref="Utf8JsonWriter" /> used to write the JSON output.
+    /// </param>
+    /// <param name="quantity">
+    ///     The quantity whose "Value" property is being written.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for JSON serialization.
+    /// </param>
+    protected override void WriteValueProperty(Utf8JsonWriter writer, IQuantity quantity, JsonSerializerOptions options)
+    {
+        JsonSerializer.Serialize(writer, quantity.Value, options);
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/AbbreviatedQuantityConverter.cs b/UnitsNet.Serialization.SystemTextJson/AbbreviatedQuantityConverter.cs
new file mode 100644
index 0000000000..197b5e1c34
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/AbbreviatedQuantityConverter.cs
@@ -0,0 +1,207 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using UnitsNet.Serialization.SystemTextJson.Unit;
+using UnitsNet.Serialization.SystemTextJson.Value;
+
+namespace UnitsNet.Serialization.SystemTextJson;
+
+/// <inheritdoc />
+#if NET
+[RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")]
+[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
+#endif
+public class AbbreviatedQuantityConverter : JsonQuantityConverter
+{
+    private readonly CultureInfo _culture;
+    private readonly UnitParser _unitParser;
+    private readonly JsonConverter<QuantityValue> _valueConverter;
+
+    /// <inheritdoc />
+    public AbbreviatedQuantityConverter()
+        : this(QuantityValueFractionalNotationConverter.Default)
+    {
+    }
+
+    /// <inheritdoc />
+    public AbbreviatedQuantityConverter(JsonConverter<QuantityValue> valueConverter)
+        : this(valueConverter, UnitParser.Default)
+    {
+    }
+
+    /// <inheritdoc />
+    public AbbreviatedQuantityConverter(JsonConverter<QuantityValue> valueConverter, UnitParser unitParser)
+        : this(valueConverter, unitParser, CultureInfo.InvariantCulture)
+    {
+    }
+
+    /// <inheritdoc />
+    public AbbreviatedQuantityConverter(JsonConverter<QuantityValue> valueConverter, UnitParser unitParser, CultureInfo culture)
+        : base(unitParser.Quantities)
+    {
+        _valueConverter = valueConverter ?? throw new ArgumentNullException(nameof(valueConverter));
+        _unitParser = unitParser;
+        _culture = culture ?? throw new ArgumentNullException(nameof(culture));
+    }
+
+    /// <inheritdoc />
+    public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (!TryGetQuantityInfo(typeToConvert, out QuantityInfo? quantityInfo))
+        {
+            return null;
+        }
+
+        Type converterType = typeof(AbbreviatedQuantityConverter<,>).MakeGenericType(typeToConvert, quantityInfo.UnitType);
+        return (JsonConverter?)Activator.CreateInstance(converterType, quantityInfo, _valueConverter, _unitParser, _culture);
+    }
+}
+
+/// <inheritdoc />
+public class AbbreviatedQuantityConverter<TQuantity, TUnit> : JsonQuantityConverterBase<TQuantity, TUnit>
+    where TQuantity : IQuantity<TQuantity, TUnit>
+    where TUnit : struct, Enum
+{
+    private readonly JsonConverter<TUnit> _unitConverter;
+    private readonly JsonConverter<QuantityValue> _valueConverter;
+
+    /// <inheritdoc />
+    public AbbreviatedQuantityConverter()
+        // TODO what should be the default
+        : this(QuantityValueFractionalNotationConverter.Default)
+    {
+    }
+
+#if NET
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedQuantityConverter{TQuantity, TUnit}" /> class
+    ///     with the specified JSON converter for <see cref="QuantityValue" />.
+    /// </summary>
+    /// <param name="valueConverter">
+    ///     The JSON converter used to handle serialization and deserialization of <see cref="QuantityValue" />.
+    /// </param>
+    /// <remarks>
+    ///     This constructor allows customization of the <see cref="QuantityValue" /> conversion logic
+    ///     by providing a specific <see cref="JsonConverter{T}" /> implementation.
+    /// </remarks>
+    public AbbreviatedQuantityConverter(JsonConverter<QuantityValue> valueConverter)
+        : this(TQuantity.Info, valueConverter)
+    {
+    }
+#else
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedQuantityConverter{TQuantity, TUnit}" /> class
+    ///     with a specified JSON converter for <see cref="QuantityValue" />.
+    /// </summary>
+    /// <param name="valueConverter">
+    ///     The <see cref="JsonConverter{T}" /> used to convert <see cref="QuantityValue" /> instances during serialization and
+    ///     deserialization.
+    /// </param>
+    public AbbreviatedQuantityConverter(JsonConverter<QuantityValue> valueConverter)
+        : this((QuantityInfo<TQuantity, TUnit>)UnitsNetSetup.Default.Quantities.GetQuantityInfo(typeof(TQuantity)), valueConverter)
+    {
+    }
+#endif
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedQuantityConverter{TQuantity, TUnit}" /> class.
+    /// </summary>
+    /// <param name="quantityInfo">
+    ///     The <see cref="QuantityInfo{TQuantity, TUnit}" /> containing metadata about the quantity type and its units.
+    /// </param>
+    /// <param name="valueConverter">
+    ///     The <see cref="JsonConverter{T}" /> used to convert the quantity value.
+    /// </param>
+    /// <remarks>
+    ///     This constructor allows specifying the quantity information and a custom value converter for serialization and
+    ///     deserialization.
+    /// </remarks>
+    public AbbreviatedQuantityConverter(QuantityInfo<TQuantity, TUnit> quantityInfo, JsonConverter<QuantityValue> valueConverter)
+        : this(quantityInfo, valueConverter, UnitParser.Default)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedQuantityConverter{TQuantity, TUnit}" /> class
+    ///     with the specified quantity information, value converter, unit parser, and culture settings.
+    /// </summary>
+    /// <param name="quantityInfo">
+    ///     The <see cref="QuantityInfo{TQuantity, TUnit}" /> containing metadata about the quantity type and its units.
+    /// </param>
+    /// <param name="valueConverter">
+    ///     The <see cref="JsonConverter{T}" /> used to serialize and deserialize the quantity value.
+    /// </param>
+    /// <param name="unitParser">
+    ///     The <see cref="UnitParser" /> used to parse unit abbreviations.
+    /// </param>
+    public AbbreviatedQuantityConverter(QuantityInfo<TQuantity, TUnit> quantityInfo, JsonConverter<QuantityValue> valueConverter, UnitParser unitParser)
+        : this(quantityInfo, valueConverter, unitParser, CultureInfo.InvariantCulture)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedQuantityConverter{TQuantity, TUnit}" /> class.
+    /// </summary>
+    /// <param name="quantityInfo">
+    ///     The <see cref="QuantityInfo{TQuantity, TUnit}" /> containing metadata about the quantity type and its units.
+    /// </param>
+    /// <param name="valueConverter">
+    ///     The <see cref="JsonConverter{T}" /> used to serialize and deserialize the quantity value.
+    /// </param>
+    /// <param name="unitParser">
+    ///     The <see cref="UnitParser" /> used to parse unit abbreviations.
+    /// </param>
+    /// <param name="culture">
+    ///     The <see cref="CultureInfo" /> used for culture-specific formatting and parsing.
+    /// </param>
+    public AbbreviatedQuantityConverter(QuantityInfo<TQuantity, TUnit> quantityInfo, JsonConverter<QuantityValue> valueConverter, UnitParser unitParser,
+        CultureInfo culture)
+        : this(quantityInfo, valueConverter, new AbbreviatedUnitConverter<TUnit>(unitParser, culture))
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedQuantityConverter{TQuantity, TUnit}" /> class.
+    /// </summary>
+    /// <param name="quantityInfo">The quantity information used for serialization and deserialization.</param>
+    /// <param name="valueConverter">The JSON converter for handling <see cref="QuantityValue" /> instances.</param>
+    /// <param name="unitConverter">The JSON converter for handling unit types of <typeparamref name="TUnit" />.</param>
+    /// <exception cref="ArgumentNullException">
+    ///     Thrown when <paramref name="valueConverter" /> or <paramref name="unitConverter" /> is <c>null</c>.
+    /// </exception>
+    public AbbreviatedQuantityConverter(QuantityInfo<TQuantity, TUnit> quantityInfo, JsonConverter<QuantityValue> valueConverter,
+        JsonConverter<TUnit> unitConverter)
+        : base(quantityInfo)
+    {
+        _valueConverter = valueConverter ?? throw new ArgumentNullException(nameof(valueConverter));
+        _unitConverter = unitConverter ?? throw new ArgumentNullException(nameof(unitConverter));
+    }
+
+    /// <inheritdoc />
+    protected override TUnit? ReadUnitProperty(ref Utf8JsonReader reader, JsonSerializerOptions options)
+    {
+        return _unitConverter.Read(ref reader, typeof(TUnit), options);
+    }
+
+    /// <inheritdoc />
+    protected override QuantityValue ReadValueProperty(ref Utf8JsonReader reader, JsonSerializerOptions options)
+    {
+        return _valueConverter.Read(ref reader, typeof(QuantityValue), options);
+    }
+
+    /// <inheritdoc />
+    protected override void WriteUnitProperty(Utf8JsonWriter writer, TQuantity quantity, JsonSerializerOptions options)
+    {
+        _unitConverter.Write(writer, quantity.Unit, options);
+    }
+
+    /// <inheritdoc />
+    protected override void WriteValueProperty(Utf8JsonWriter writer, TQuantity quantity, JsonSerializerOptions options)
+    {
+        _valueConverter.Write(writer, quantity.Value, options);
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/InterfaceQuantityConverterBase.cs b/UnitsNet.Serialization.SystemTextJson/InterfaceQuantityConverterBase.cs
new file mode 100644
index 0000000000..7132a8b3e8
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/InterfaceQuantityConverterBase.cs
@@ -0,0 +1,219 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace UnitsNet.Serialization.SystemTextJson;
+
+/// <summary>
+///     Provides a custom JSON converter for <see cref="UnitsNet.IQuantity" />.
+///     This converter handles serialization and deserialization of quantities,
+///     ensuring that <see cref="UnitsNet.IQuantity" /> objects are correctly
+///     represented in JSON format.
+/// </summary>
+public abstract class InterfaceQuantityConverterBase<TJsonUnit> : JsonConverter<IQuantity>
+{
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, IQuantity quantity, JsonSerializerOptions options)
+    {
+        writer.WriteStartObject();
+
+        JsonEncodedText valueProperty, unitProperty, typeProperty;
+        if (options.PropertyNamesShouldStartWithLowercase())
+        {
+            valueProperty = JsonQuantityPropertyNames.ValuePropertyName_Lowercase;
+            unitProperty = JsonQuantityPropertyNames.UnitPropertyName_Lowercase;
+            typeProperty = JsonQuantityPropertyNames.TypePropertyName_Lowercase;
+        }
+        else
+        {
+            valueProperty = JsonQuantityPropertyNames.ValuePropertyName;
+            unitProperty = JsonQuantityPropertyNames.UnitPropertyName;
+            typeProperty = JsonQuantityPropertyNames.TypePropertyName;
+        }
+
+#pragma warning disable CS0618 // Type or member is obsolete
+        QuantityInfo quantityInfo = quantity.QuantityInfo;
+#pragma warning restore CS0618 // Type or member is obsolete
+        if (options.DefaultIgnoreCondition == JsonIgnoreCondition.WhenWritingDefault)
+        {
+            if (!QuantityValue.IsZero(quantity.Value))
+            {
+                // write the Value property
+                writer.WritePropertyName(valueProperty);
+                WriteValueProperty(writer, quantity, options);
+            }
+
+            if (quantity.UnitKey.UnitEnumValue != quantityInfo.BaseUnitInfo.UnitKey.UnitEnumValue)
+            {
+                // write the Unit property
+                writer.WritePropertyName(unitProperty);
+                WriteUnitProperty(writer, quantity, options);
+            }
+        }
+        else
+        {
+            // write the Value property
+            writer.WritePropertyName(valueProperty);
+            WriteValueProperty(writer, quantity, options);
+            // write the Unit property 
+            writer.WritePropertyName(unitProperty);
+            WriteUnitProperty(writer, quantity, options);
+        }
+
+        // write the Type property (disambiguation based on the quantity name)
+        writer.WriteString(typeProperty, quantityInfo.Name);
+
+        writer.WriteEndObject();
+    }
+    
+    /// <inheritdoc />
+    public override IQuantity Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        QuantityValue value = QuantityValue.Zero;
+        TJsonUnit? unit = default;
+        string? quantityName = null;
+        JsonEncodedText valueProperty, unitProperty, typeProperty;
+        if (options.PropertyNamesShouldStartWithLowercase())
+        {
+            valueProperty = JsonQuantityPropertyNames.ValuePropertyName_Lowercase;
+            unitProperty = JsonQuantityPropertyNames.UnitPropertyName_Lowercase;
+            typeProperty = JsonQuantityPropertyNames.TypePropertyName_Lowercase;
+        }
+        else
+        {
+            valueProperty = JsonQuantityPropertyNames.ValuePropertyName;
+            unitProperty = JsonQuantityPropertyNames.UnitPropertyName;
+            typeProperty = JsonQuantityPropertyNames.TypePropertyName;
+        }
+
+        if (options.PropertyNameCaseInsensitive)
+        {
+            while (reader.ReadNextProperty())
+            {
+                var propertyName = reader.GetString();
+                reader.Read();
+                if (StringComparer.OrdinalIgnoreCase.Equals(propertyName, valueProperty.Value))
+                {
+                    value = ReadValueProperty(ref reader, options);
+                }
+                else if (StringComparer.OrdinalIgnoreCase.Equals(propertyName, unitProperty.Value))
+                {
+                    unit = ReadUnitProperty(ref reader, options);
+                }
+                else if (StringComparer.OrdinalIgnoreCase.Equals(propertyName, typeProperty.Value))
+                {
+                    quantityName = reader.GetString();
+                }
+                else if (options.UnmappedMemberHandling == JsonUnmappedMemberHandling.Skip)
+                {
+                    reader.Skip(); // Skip unknown properties
+                }
+                else
+                {
+                    throw new JsonException($"'{propertyName}' was no found in the list of members of '{typeToConvert}'.");
+                }
+            }
+        }
+        else
+        {
+            while (reader.ReadNextProperty())
+            {
+                if (reader.ValueTextEquals(valueProperty.EncodedUtf8Bytes))
+                {
+                    reader.Read();
+                    value = ReadValueProperty(ref reader, options);
+                }
+                else if (reader.ValueTextEquals(unitProperty.EncodedUtf8Bytes))
+                {
+                    reader.Read();
+                    unit = ReadUnitProperty(ref reader, options);
+                }
+                else if (reader.ValueTextEquals(typeProperty.EncodedUtf8Bytes))
+                {
+                    reader.Read();
+                    quantityName = reader.GetString();
+                }
+                else if (options.UnmappedMemberHandling == JsonUnmappedMemberHandling.Skip)
+                {
+                    reader.Skip(); // Skip unknown properties
+                }
+                else
+                {
+                    throw new JsonException($"'{reader.GetString()}' was no found in the list of members of '{typeToConvert}'.");
+                }
+            }
+        }
+
+        return CreateQuantity(value, unit, quantityName);
+    }
+    
+    /// <summary>
+    ///     Writes the value property of the quantity to the JSON output.
+    /// </summary>
+    /// <param name="writer">
+    ///     The <see cref="Utf8JsonWriter" /> used to write the JSON output.
+    /// </param>
+    /// <param name="quantity">
+    ///     The quantity whose "Value" property is being written.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for JSON serialization.
+    /// </param>
+    protected abstract void WriteValueProperty(Utf8JsonWriter writer, IQuantity quantity, JsonSerializerOptions options);
+
+    /// <summary>
+    ///     Writes the unit property of the quantity to the JSON output.
+    /// </summary>
+    /// <param name="writer">
+    ///     The <see cref="Utf8JsonWriter" /> used to write the JSON output.
+    /// </param>
+    /// <param name="quantity">
+    ///     The quantity whose unit is being written.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for JSON serialization.
+    /// </param>
+    protected abstract void WriteUnitProperty(Utf8JsonWriter writer, IQuantity quantity, JsonSerializerOptions options);
+
+    /// <summary>
+    ///     Reads the value property of a JSON object representing a quantity.
+    /// </summary>
+    /// <param name="reader">
+    ///     The <see cref="Utf8JsonReader" /> used to read the JSON data.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for deserialization.
+    /// </param>
+    /// <returns>
+    ///     A <see cref="QuantityValue" /> representing the value of the quantity read from the JSON data.
+    /// </returns>
+    protected abstract QuantityValue ReadValueProperty(ref Utf8JsonReader reader, JsonSerializerOptions options);
+
+    /// <summary>
+    ///     Reads the "Unit" property of a JSON object representing a quantity.
+    /// </summary>
+    /// <param name="reader">
+    ///     The <see cref="Utf8JsonReader" /> used to read the JSON data.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for deserialization.
+    /// </param>
+    /// <returns>
+    ///     A <see cref="UnitInfo" /> representing the matching unit of the quantity read from the JSON data.
+    /// </returns>
+    /// <remarks>
+    ///     This method is virtual, allowing derived classes to customize how the value property is read.
+    /// </remarks>
+    protected abstract TJsonUnit ReadUnitProperty(ref Utf8JsonReader reader, JsonSerializerOptions options);
+    
+    /// <summary>
+    /// Creates an instance of <see cref="UnitsNet.IQuantity" /> using the specified value, unit, and quantity name.
+    /// </summary>
+    /// <param name="value">The numerical value of the quantity.</param>
+    /// <param name="unit">The unit associated with the quantity.</param>
+    /// <param name="quantityName">The name used to identify the type of quantity.</param>
+    /// <returns>An instance of <see cref="UnitsNet.IQuantity" /> representing the specified value and unit.</returns>
+    protected abstract IQuantity CreateQuantity(QuantityValue value, TJsonUnit? unit, string? quantityName);
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/JsonExtensions.cs b/UnitsNet.Serialization.SystemTextJson/JsonExtensions.cs
new file mode 100644
index 0000000000..8793f3bd54
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/JsonExtensions.cs
@@ -0,0 +1,197 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
+
+namespace UnitsNet.Serialization.SystemTextJson;
+
+internal static class JsonExtensions
+{
+    public static bool ReadNextProperty(this ref Utf8JsonReader reader)
+    {
+        reader.Read();
+        return reader.TokenType switch
+        {
+            JsonTokenType.PropertyName => true,
+            JsonTokenType.EndObject => false,
+            _ => throw new JsonException("Expected PropertyName token.")
+        };
+    }
+
+    [SuppressMessage("ReSharper", "ReplaceSliceWithRangeIndexer")]
+    public static bool TrySplit(this ReadOnlySpan<char> span, char separator, out ReadOnlySpan<char> firstSpan, out ReadOnlySpan<char> secondSpan)
+    {
+        var separatorIndex = span.IndexOf(separator);
+
+        if (separatorIndex < 0)
+        {
+            firstSpan = span;
+            secondSpan = ReadOnlySpan<char>.Empty;
+            return false;
+        }
+
+        firstSpan = span.Slice(0, separatorIndex);
+        secondSpan = span.Slice(separatorIndex + 1);
+        return true;
+    }
+
+
+    public static bool PropertyNamesShouldStartWithLowercase(this JsonSerializerOptions options)
+    {
+        JsonNamingPolicy? namingPolicy = options.PropertyNamingPolicy;
+        return namingPolicy == JsonNamingPolicy.CamelCase || namingPolicy == JsonNamingPolicy.KebabCaseLower || namingPolicy == JsonNamingPolicy.SnakeCaseLower;
+    }
+    
+    public static void WriteStringValues(this Utf8JsonWriter writer, ReadOnlySpan<char> first, char separator, ReadOnlySpan<char> second)
+    {
+        var requiredLength = first.Length + second.Length + 1;
+        Span<char> charBuffer = requiredLength <= 512 ? stackalloc char[requiredLength] : new char[requiredLength];
+        CombineSpansWithSeparator(first, separator, second, charBuffer);
+        writer.WriteStringValue(charBuffer);
+    }
+    
+    public static void WriteValuesAsPropertyName(this Utf8JsonWriter writer, ReadOnlySpan<char> first, char separator, ReadOnlySpan<char> second)
+    {
+        var requiredLength = first.Length + second.Length + 1;
+        Span<char> charBuffer = requiredLength <= 512 ? stackalloc char[requiredLength] : new char[requiredLength];
+        CombineSpansWithSeparator(first, separator, second, charBuffer);
+        writer.WritePropertyName(charBuffer);
+    }
+    
+    // ReSharper disable once ReplaceSliceWithRangeIndexer
+    private static void CombineSpansWithSeparator(ReadOnlySpan<char> first, char separator, ReadOnlySpan<char> second, Span<char> charBuffer)
+    {
+        first.CopyTo(charBuffer);
+        charBuffer[first.Length] = separator;
+        second.CopyTo(charBuffer.Slice(first.Length + 1));
+    }
+
+#if NET
+    public static void WriteValuesAsString<TValue>(this Utf8JsonWriter writer, TValue first, char separator, TValue second, IFormatProvider? formatProvider = null, int stackAlloc = 512)
+        where TValue: ISpanFormattable
+    {
+        Span<char> charBuffer = stackalloc char[stackAlloc];
+        int firstCharsWritten;
+        while (!first.TryFormat(charBuffer, out firstCharsWritten, ReadOnlySpan<char>.Empty, formatProvider))
+        {
+            charBuffer = new char[charBuffer.Length * 2];
+        }
+
+        if (firstCharsWritten == charBuffer.Length)
+        {
+            var extendedBuffer = new char[charBuffer.Length * 2];
+            charBuffer.CopyTo(extendedBuffer);
+            charBuffer = extendedBuffer;
+        }
+        
+        charBuffer[firstCharsWritten] = separator;
+
+        int secondCharsWritten;
+        while (!second.TryFormat(charBuffer[(firstCharsWritten + 1)..], out secondCharsWritten, ReadOnlySpan<char>.Empty, formatProvider))
+        {
+            var extendedBuffer = new char[charBuffer.Length * 2];
+            charBuffer.CopyTo(extendedBuffer);
+            charBuffer = extendedBuffer;
+        }
+
+        writer.WriteStringValue(charBuffer[..(firstCharsWritten + secondCharsWritten + 1)]);
+    }
+
+#endif
+
+
+    // private const int StackallocByteThreshold = 512;
+    //
+    // internal static int CopyValue(this ref Utf8JsonReader reader, Span<char> destination)
+    // {
+    //     // Debug.Assert(_tokenType is JsonTokenType.String or JsonTokenType.PropertyName or JsonTokenType.Number);
+    //     // Debug.Assert(_tokenType != JsonTokenType.Number || !ValueIsEscaped, "Numbers can't contain escape characters.");
+    //
+    //     scoped ReadOnlySpan<byte> unescapedSource;
+    //     byte[]? rentedBuffer = null;
+    //     int valueLength;
+    //
+    //     if (reader.ValueIsEscaped)
+    //     {
+    //         valueLength = reader.HasValueSequence ? checked((int)reader.ValueSequence.Length) : reader.ValueSpan.Length;
+    //
+    //         Span<byte> unescapedBuffer = valueLength <= StackallocByteThreshold ?
+    //             stackalloc byte[StackallocByteThreshold] :
+    //             (rentedBuffer = ArrayPool<byte>.Shared.Rent(valueLength));
+    //
+    //         bool success = TryCopyEscapedString(ref reader, unescapedBuffer, out int bytesWritten);
+    //         // Debug.Assert(success);
+    //         unescapedSource = unescapedBuffer.Slice(0, bytesWritten);
+    //     }
+    //     else
+    //     {
+    //         if (reader.HasValueSequence)
+    //         {
+    //             ReadOnlySequence<byte> valueSequence = reader.ValueSequence;
+    //             valueLength = checked((int)valueSequence.Length);
+    //
+    //             Span<byte> intermediate = valueLength <= StackallocByteThreshold ?
+    //                 stackalloc byte[StackallocByteThreshold] :
+    //                 (rentedBuffer = ArrayPool<byte>.Shared.Rent(valueLength));
+    //
+    //             valueSequence.CopyTo(intermediate);
+    //             unescapedSource = intermediate.Slice(0, valueLength);
+    //         }
+    //         else
+    //         {
+    //             unescapedSource = reader.ValueSpan;
+    //         }
+    //     }
+    //
+    //     int charsWritten = JsonReaderHelper.TranscodeHelper(unescapedSource, destination);
+    //
+    //     if (rentedBuffer != null)
+    //     {
+    //         new Span<byte>(rentedBuffer, 0, unescapedSource.Length).Clear();
+    //         ArrayPool<byte>.Shared.Return(rentedBuffer);
+    //     }
+    //
+    //     return charsWritten;
+    // }
+    //
+    // private static bool TryCopyEscapedString(this ref Utf8JsonReader reader, Span<byte> destination, out int bytesWritten)
+    // {
+    //     Debug.Assert(_tokenType is JsonTokenType.String or JsonTokenType.PropertyName);
+    //     Debug.Assert(ValueIsEscaped);
+    //
+    //     byte[]? rentedBuffer = null;
+    //     scoped ReadOnlySpan<byte> source;
+    //
+    //     if (reader.HasValueSequence)
+    //     {
+    //         ReadOnlySequence<byte> valueSequence = reader.ValueSequence;
+    //         int sequenceLength = checked((int)valueSequence.Length);
+    //
+    //         Span<byte> intermediate = sequenceLength <= StackallocByteThreshold ?
+    //             stackalloc byte[StackallocByteThreshold] :
+    //             (rentedBuffer = ArrayPool<byte>.Shared.Rent(sequenceLength));
+    //
+    //         valueSequence.CopyTo(intermediate);
+    //         source = intermediate.Slice(0, sequenceLength);
+    //     }
+    //     else
+    //     {
+    //         source = reader.ValueSpan;
+    //     }
+    //
+    //     bool success = JsonReaderHelper.TryUnescape(source, destination, out bytesWritten);
+    //
+    //     if (rentedBuffer != null)
+    //     {
+    //         new Span<byte>(rentedBuffer, 0, source.Length).Clear();
+    //         ArrayPool<byte>.Shared.Return(rentedBuffer);
+    //     }
+    //
+    //     Debug.Assert(bytesWritten < source.Length, "source buffer must contain at least one escape sequence");
+    //     return success;
+    // }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/JsonQuantityConverter.cs b/UnitsNet.Serialization.SystemTextJson/JsonQuantityConverter.cs
new file mode 100644
index 0000000000..0603f3cd30
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/JsonQuantityConverter.cs
@@ -0,0 +1,472 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace UnitsNet.Serialization.SystemTextJson;
+
+internal static class JsonQuantityPropertyNames
+{
+    public static readonly JsonEncodedText ValuePropertyName = JsonEncodedText.Encode("Value");
+    public static readonly JsonEncodedText ValuePropertyName_Lowercase = JsonEncodedText.Encode("value");
+
+    public static readonly JsonEncodedText UnitPropertyName = JsonEncodedText.Encode("Unit");
+    public static readonly JsonEncodedText UnitPropertyName_Lowercase = JsonEncodedText.Encode("unit");
+    
+    public static readonly JsonEncodedText TypePropertyName = JsonEncodedText.Encode("Type");
+    public static readonly JsonEncodedText TypePropertyName_Lowercase = JsonEncodedText.Encode("type");
+}
+
+/// <summary>
+///     Provides a custom JSON converter for quantities implementing <see cref="UnitsNet.IQuantity{TSelf, TUnitType}" />.
+///     This generic converter handles serialization and deserialization of quantities,
+///     ensuring that objects of type <typeparamref name="TQuantity" /> are correctly
+///     represented in JSON format.
+/// </summary>
+/// <typeparam name="TQuantity">
+///     The type of the quantity being serialized or deserialized, which must implement
+///     <see cref="UnitsNet.IQuantity{TSelf, TUnitType}" />.
+/// </typeparam>
+/// <typeparam name="TUnit">
+///     The type of the unit enumeration associated with the quantity, which must be a value type and an enumeration.
+/// </typeparam>
+/// <remarks>
+///     In order to use this converter directly, you need to make sure that the <see cref="JsonSerializerOptions" />
+///     contains a converter for both the <see cref="IQuantity{TUnitType}.Unit" /> and the
+///     <see cref="IQuantity.Value" /> of the quantity.
+/// </remarks>
+public abstract class JsonQuantityConverterBase<TQuantity, TUnit> : JsonConverter<TQuantity>
+    where TQuantity : IQuantity<TQuantity, TUnit>
+    where TUnit : struct, Enum
+{
+    private readonly QuantityInfo<TQuantity, TUnit> _quantityInfo;
+
+    /// <summary>
+    ///     Initializes a new instance of the converter using the default <see cref="QuantityInfo{TQuantity, TUnit}" /> of the specified quantity type.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor creates a converter that uses the default <see cref="QuantityInfo{TQuantity, TUnit}" />
+    ///     for the specified quantity type <typeparamref name="TQuantity" />. It is particularly useful when
+    ///     no custom <see cref="QuantityInfo{TQuantity, TUnit}" /> is required for serialization or deserialization.
+    /// </remarks>
+    protected JsonQuantityConverterBase()
+#if NET
+        : this(TQuantity.Info)
+#else
+        : this((QuantityInfo<TQuantity, TUnit>)UnitsNetSetup.Default.Quantities.GetQuantityInfo(typeof(TQuantity)))
+#endif
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the converter with the specified <see cref="QuantityInfo{TQuantity, TUnit}" />.
+    /// </summary>
+    /// <param name="quantityInfo">
+    ///     The <see cref="QuantityInfo{TQuantity, TUnit}" /> instance that provides metadata and configuration
+    ///     for the quantity type <typeparamref name="TQuantity" /> and its associated unit type <typeparamref name="TUnit" />.
+    /// </param>
+    protected JsonQuantityConverterBase(QuantityInfo<TQuantity, TUnit> quantityInfo)
+    {
+        _quantityInfo = quantityInfo ?? throw new ArgumentNullException(nameof(quantityInfo));
+    }
+
+    /// <inheritdoc />
+    public override TQuantity Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        QuantityValue value = QuantityValue.Zero;
+        TUnit? unit = null;
+        JsonEncodedText valueProperty, unitProperty;
+        if (options.PropertyNamesShouldStartWithLowercase())
+        {
+            valueProperty = JsonQuantityPropertyNames.ValuePropertyName_Lowercase;
+            unitProperty = JsonQuantityPropertyNames.UnitPropertyName_Lowercase;
+        }
+        else
+        {
+            valueProperty = JsonQuantityPropertyNames.ValuePropertyName;
+            unitProperty = JsonQuantityPropertyNames.UnitPropertyName;
+        }
+
+        if (options.PropertyNameCaseInsensitive)
+        {
+            while (reader.ReadNextProperty())
+            {
+                var propertyName = reader.GetString();
+                reader.Read();
+
+                if (StringComparer.OrdinalIgnoreCase.Equals(propertyName, valueProperty.Value))
+                {
+                    value = ReadValueProperty(ref reader, options);
+                }
+                else if (StringComparer.OrdinalIgnoreCase.Equals(propertyName, unitProperty.Value))
+                {
+                    unit = ReadUnitProperty(ref reader, options);
+                }
+                else if (options.UnmappedMemberHandling == JsonUnmappedMemberHandling.Skip)
+                {
+                    reader.Skip(); // Skip unknown properties
+                }
+                else
+                {
+                    throw new JsonException($"'{propertyName}' was no found in the list of members of '{typeToConvert}'.");
+                }
+            }
+        }
+        else
+        {
+            while (reader.ReadNextProperty())
+            {
+                if (reader.ValueTextEquals(valueProperty.EncodedUtf8Bytes))
+                {
+                    reader.Read();
+                    value = ReadValueProperty(ref reader, options);
+                }
+                else if (reader.ValueTextEquals(unitProperty.EncodedUtf8Bytes))
+                {
+                    reader.Read();
+                    unit = ReadUnitProperty(ref reader, options);
+                }
+                else if (options.UnmappedMemberHandling == JsonUnmappedMemberHandling.Skip)
+                {
+                    reader.Skip(); // Skip unknown properties
+                }
+                else
+                {
+                    throw new JsonException($"'{reader.GetString()}' was no found in the list of members of '{typeToConvert}'.");
+                }
+            }
+        }
+
+        // note: we could be using TQuantity.From(value, unit.Value) instead
+        return unit == null ? _quantityInfo.BaseUnitInfo.From(value) : _quantityInfo.From(value, unit.Value);
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, TQuantity quantity, JsonSerializerOptions options)
+    {
+        writer.WriteStartObject();
+
+        JsonEncodedText valueProperty, unitProperty;
+        if (options.PropertyNamesShouldStartWithLowercase())
+        {
+            valueProperty = JsonQuantityPropertyNames.ValuePropertyName_Lowercase;
+            unitProperty = JsonQuantityPropertyNames.UnitPropertyName_Lowercase;
+        }
+        else
+        {
+            valueProperty = JsonQuantityPropertyNames.ValuePropertyName;
+            unitProperty = JsonQuantityPropertyNames.UnitPropertyName;
+        }
+
+        if (options.DefaultIgnoreCondition == JsonIgnoreCondition.WhenWritingDefault)
+        {
+            if (!QuantityValue.IsZero(quantity.Value))
+            {
+                writer.WritePropertyName(valueProperty);
+                WriteValueProperty(writer, quantity, options);
+            }
+
+            if (!EqualityComparer<TUnit>.Default.Equals(quantity.Unit, _quantityInfo.BaseUnitInfo.Value))
+            {
+                writer.WritePropertyName(unitProperty);
+                WriteUnitProperty(writer, quantity, options);
+            }
+        }
+        else
+        {
+            writer.WritePropertyName(valueProperty);
+            WriteValueProperty(writer, quantity, options);
+            writer.WritePropertyName(unitProperty);
+            WriteUnitProperty(writer, quantity, options);
+        }
+
+        writer.WriteEndObject();
+    }
+
+    /// <summary>
+    ///     Reads the value property of a JSON object representing a quantity.
+    /// </summary>
+    /// <param name="reader">
+    ///     The <see cref="Utf8JsonReader" /> used to read the JSON data.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for deserialization.
+    /// </param>
+    /// <returns>
+    ///     A <see cref="QuantityValue" /> representing the value of the quantity read from the JSON data.
+    /// </returns>
+    /// <remarks>
+    ///     This method is virtual, allowing derived classes to customize how the value property is read.
+    /// </remarks>
+    /// <exception cref="JsonException">
+    ///     Thrown if the JSON data is invalid or cannot be deserialized into a <see cref="QuantityValue" />.
+    /// </exception>
+    protected abstract QuantityValue ReadValueProperty(ref Utf8JsonReader reader, JsonSerializerOptions options);
+
+    /// <summary>
+    ///     Reads the unit property from the JSON input.
+    /// </summary>
+    /// <param name="reader">
+    ///     The <see cref="Utf8JsonReader" /> used to read the JSON input.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for deserialization.
+    /// </param>
+    /// <returns>
+    ///     The deserialized unit of type <typeparamref name="TUnit" />, or <c>null</c> if the unit could not be read.
+    /// </returns>
+    /// <exception cref="JsonException">
+    ///     Thrown if the JSON input is invalid or does not contain a valid unit property.
+    /// </exception>
+    protected abstract TUnit? ReadUnitProperty(ref Utf8JsonReader reader, JsonSerializerOptions options);
+
+    /// <summary>
+    ///     Writes the "Value" property of the quantity to the JSON output.
+    /// </summary>
+    /// <param name="writer">
+    ///     The <see cref="Utf8JsonWriter" /> used to write the JSON output.
+    /// </param>
+    /// <param name="quantity">
+    ///     The quantity whose "Value" property is being written.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for JSON serialization.
+    /// </param>
+    protected abstract void WriteValueProperty(Utf8JsonWriter writer, TQuantity quantity, JsonSerializerOptions options);
+
+    /// <summary>
+    ///     Writes the unit property of the quantity to the JSON output.
+    /// </summary>
+    /// <param name="writer">
+    ///     The <see cref="Utf8JsonWriter" /> used to write the JSON output.
+    /// </param>
+    /// <param name="quantity">
+    ///     The quantity whose unit property is being written.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for JSON serialization.
+    /// </param>
+    /// <remarks>
+    ///     This method writes the unit property name and its value to the JSON output.
+    ///     The property name is determined by the <see cref="JsonSerializerOptions.PropertyNamingPolicy" /> if specified,
+    ///     otherwise it defaults to the value of <c>UnitPropertyName</c>.
+    /// </remarks>
+    protected abstract void WriteUnitProperty(Utf8JsonWriter writer, TQuantity quantity, JsonSerializerOptions options);
+}
+
+/// <summary>
+///     Provides a custom JSON converter for quantities implementing <see cref="UnitsNet.IQuantity{TSelf, TUnitType}" />.
+///     This generic converter handles serialization and deserialization of quantities,
+///     ensuring that objects of type <typeparamref name="TQuantity" /> are correctly
+///     represented in JSON format.
+/// </summary>
+/// <typeparam name="TQuantity">
+///     The type of the quantity being serialized or deserialized, which must implement
+///     <see cref="UnitsNet.IQuantity{TSelf, TUnitType}" />.
+/// </typeparam>
+/// <typeparam name="TUnit">
+///     The type of the unit enumeration associated with the quantity, which must be a value type and an enumeration.
+/// </typeparam>
+/// <remarks>
+///     In order to use this converter directly, you need to make sure that the <see cref="JsonSerializerOptions" />
+///     contains a converter for both the <see cref="IQuantity{TUnitType}.Unit" /> and the
+///     <see cref="IQuantity.Value" /> of the quantity.
+/// </remarks>
+#if NET
+[RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")]
+[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
+#endif
+public class JsonQuantityConverter<TQuantity, TUnit> : JsonQuantityConverterBase<TQuantity, TUnit>
+    where TQuantity : IQuantity<TQuantity, TUnit>
+    where TUnit : struct, Enum
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="JsonQuantityConverter{TQuantity,TUnit}" /> class
+    ///     using the default <see cref="QuantityInfo{TQuantity, TUnit}" /> of the specified quantity type.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor creates a converter that uses the default <see cref="QuantityInfo{TQuantity, TUnit}" />
+    ///     for the specified quantity type <typeparamref name="TQuantity" />. It is particularly useful when
+    ///     no custom <see cref="QuantityInfo{TQuantity, TUnit}" /> is required for serialization or deserialization.
+    /// </remarks>
+    public JsonQuantityConverter()
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="JsonQuantityConverter{TQuantity,TUnit}" /> class
+    ///     with the specified <see cref="QuantityInfo{TQuantity, TUnit}" />.
+    /// </summary>
+    /// <param name="quantityInfo">
+    ///     The <see cref="QuantityInfo{TQuantity, TUnit}" /> instance that provides metadata and configuration
+    ///     for the quantity type <typeparamref name="TQuantity" /> and its associated unit type <typeparamref name="TUnit" />.
+    /// </param>
+    public JsonQuantityConverter(QuantityInfo<TQuantity, TUnit> quantityInfo)
+        : base(quantityInfo)
+    {
+    }
+
+    /// <summary>
+    ///     Reads the value property of a JSON object representing a quantity.
+    /// </summary>
+    /// <param name="reader">
+    ///     The <see cref="Utf8JsonReader" /> used to read the JSON data.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for deserialization.
+    /// </param>
+    /// <returns>
+    ///     A <see cref="QuantityValue" /> representing the value of the quantity read from the JSON data.
+    /// </returns>
+    /// <remarks>
+    ///     This method is virtual, allowing derived classes to customize how the value property is read.
+    /// </remarks>
+    /// <exception cref="JsonException">
+    ///     Thrown if the JSON data is invalid or cannot be deserialized into a <see cref="QuantityValue" />.
+    /// </exception>
+    protected override QuantityValue ReadValueProperty(ref Utf8JsonReader reader, JsonSerializerOptions options)
+    {
+        QuantityValue value = JsonSerializer.Deserialize<QuantityValue>(ref reader, options);
+        return value;
+    }
+
+    /// <summary>
+    ///     Reads the unit property from the JSON input.
+    /// </summary>
+    /// <param name="reader">
+    ///     The <see cref="Utf8JsonReader" /> used to read the JSON input.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for deserialization.
+    /// </param>
+    /// <returns>
+    ///     The deserialized unit of type <typeparamref name="TUnit" />, or <c>null</c> if the unit could not be read.
+    /// </returns>
+    /// <exception cref="JsonException">
+    ///     Thrown if the JSON input is invalid or does not contain a valid unit property.
+    /// </exception>
+    protected override TUnit? ReadUnitProperty(ref Utf8JsonReader reader, JsonSerializerOptions options)
+    {
+        TUnit? unit = JsonSerializer.Deserialize<TUnit>(ref reader, options);
+        return unit;
+    }
+
+    /// <summary>
+    ///     Writes the "Value" property of the quantity to the JSON output.
+    /// </summary>
+    /// <param name="writer">
+    ///     The <see cref="Utf8JsonWriter" /> used to write the JSON output.
+    /// </param>
+    /// <param name="quantity">
+    ///     The quantity whose "Value" property is being written.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for JSON serialization.
+    /// </param>
+    protected override void WriteValueProperty(Utf8JsonWriter writer, TQuantity quantity, JsonSerializerOptions options)
+    {
+        JsonSerializer.Serialize(writer, quantity.Value, options);
+    }
+
+    /// <summary>
+    ///     Writes the unit property of the quantity to the JSON output.
+    /// </summary>
+    /// <param name="writer">
+    ///     The <see cref="Utf8JsonWriter" /> used to write the JSON output.
+    /// </param>
+    /// <param name="quantity">
+    ///     The quantity whose unit property is being written.
+    /// </param>
+    /// <param name="options">
+    ///     The <see cref="JsonSerializerOptions" /> that specify options for JSON serialization.
+    /// </param>
+    /// <remarks>
+    ///     This method writes the unit property name and its value to the JSON output.
+    ///     The property name is determined by the <see cref="JsonSerializerOptions.PropertyNamingPolicy" /> if specified,
+    ///     otherwise it defaults to the value of <c>UnitPropertyName</c>.
+    /// </remarks>
+    protected override void WriteUnitProperty(Utf8JsonWriter writer, TQuantity quantity, JsonSerializerOptions options)
+    {
+        JsonSerializer.Serialize(writer, quantity.Unit, options);
+    }
+}
+
+/// <summary>
+///     Provides a factory for creating JSON converters that handle serialization and deserialization
+///     of quantities and their associated units.
+/// </summary>
+/// <remarks>
+///     This class leverages the <see cref="QuantityInfoLookup" /> to resolve quantity and unit information
+///     during JSON serialization and deserialization.
+///     <para>
+///         In order to use this converter directly, you need to make sure that the <see cref="JsonSerializerOptions" />
+///         contains a converter for both the <see cref="IQuantity{TUnitType}.Unit" /> and the
+///         <see cref="IQuantity.Value" /> of the quantity.
+///     </para>
+/// </remarks>
+#if NET
+[RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")]
+[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
+#endif
+public class JsonQuantityConverter : JsonConverterFactory
+{
+    private readonly QuantityInfoLookup _quantities;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="JsonQuantityConverter" /> class
+    ///     with an option to specify case sensitivity.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor uses the default <see cref="QuantityInfoLookup" /> from <see cref="UnitsNetSetup.Default" />
+    ///     to resolve unit names during JSON serialization and deserialization.
+    /// </remarks>
+    public JsonQuantityConverter()
+        : this(UnitsNetSetup.Default.Quantities)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="JsonQuantityConverter" /> class with the specified
+    ///     <see cref="QuantityInfoLookup" /> and case-sensitivity configuration.
+    /// </summary>
+    /// <param name="quantities">
+    ///     The <see cref="QuantityInfoLookup" /> instance used to resolve quantity and unit information
+    ///     during JSON serialization and deserialization.
+    /// </param>
+    /// <remarks>
+    ///     This constructor allows customization of the <see cref="QuantityInfoLookup" /> used for parsing and
+    ///     formatting unit names, enabling advanced scenarios where specific quantity and unit information is required.
+    /// </remarks>
+    public JsonQuantityConverter(QuantityInfoLookup quantities)
+    {
+        _quantities = quantities ?? throw new ArgumentNullException(nameof(quantities));
+    }
+
+    /// <inheritdoc />
+    public override bool CanConvert(Type typeToConvert)
+    {
+        return TryGetQuantityInfo(typeToConvert, out _);
+    }
+
+    /// <inheritdoc />
+    public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (!TryGetQuantityInfo(typeToConvert, out QuantityInfo? quantityInfo))
+        {
+            return null;
+        }
+
+        Type converterType = typeof(JsonQuantityConverter<,>).MakeGenericType(typeToConvert, quantityInfo.UnitType);
+        return (JsonConverter?)Activator.CreateInstance(converterType, quantityInfo);
+    }
+
+    /// <summary>
+    ///     Try to get the <see cref="QuantityInfo" /> for a given quantity type.
+    /// </summary>
+    protected bool TryGetQuantityInfo(Type typeToConvert, [NotNullWhen(true)] out QuantityInfo? quantityInfo)
+    {
+        return _quantities.TryGetQuantityInfo(typeToConvert, out quantityInfo);
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/Unit/AbbreviatedUnitConverter.cs b/UnitsNet.Serialization.SystemTextJson/Unit/AbbreviatedUnitConverter.cs
new file mode 100644
index 0000000000..ac96796d80
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/Unit/AbbreviatedUnitConverter.cs
@@ -0,0 +1,173 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+#if NET
+using System.Diagnostics.CodeAnalysis;
+#endif
+
+namespace UnitsNet.Serialization.SystemTextJson.Unit;
+
+/// <summary>
+///     Converter to convert unit-enums to and from abbreviated strings.
+/// </summary>
+/// <remarks>
+///     Reading is case-insensitive, with case-sensitive disambiguation.
+/// </remarks>
+#if NET
+[RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")]
+[RequiresUnreferencedCode(
+    "If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
+#endif
+public class AbbreviatedUnitConverter : JsonConverterFactory
+{
+    private readonly UnitParser _unitParser;
+    private readonly CultureInfo _culture = CultureInfo.InvariantCulture;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedUnitConverter" /> class
+    ///     using the default <see cref="UnitParser" />.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor sets up the converter to use the default <see cref="UnitParser" />
+    ///     for resolving unit abbreviations during JSON serialization and deserialization.
+    /// </remarks>
+    public AbbreviatedUnitConverter()
+        : this(UnitParser.Default)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedUnitConverter" /> class with the specified unit parser.
+    /// </summary>
+    /// <param name="unitParser">
+    ///     The <see cref="UnitParser" /> used for deserializing an abbreviation back into its
+    ///     corresponding unit.
+    /// </param>
+    /// <remarks>
+    ///     This constructor sets up the converter to utilize the provided <see cref="UnitParser" />
+    ///     for managing unit abbreviations and parsing during JSON operations.
+    /// </remarks>
+    public AbbreviatedUnitConverter(UnitParser unitParser)
+    {
+        _unitParser = unitParser ?? throw new ArgumentNullException(nameof(unitParser));
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedUnitConverter" /> class with the specified unit parser and culture.
+    /// </summary>
+    /// <param name="unitParser">
+    ///     The <see cref="UnitParser" /> used for deserializing an abbreviation back into its
+    ///     corresponding unit.
+    /// </param>
+    /// <param name="culture">The <see cref="CultureInfo" /> used for parsing and formatting unit abbreviations.</param>
+    /// <remarks>
+    ///     This constructor allows customization of both the unit abbreviations cache and the culture used for parsing and
+    ///     formatting unit abbreviations.
+    /// </remarks>
+    public AbbreviatedUnitConverter(UnitParser unitParser, CultureInfo culture)
+    {
+        _unitParser = unitParser ?? throw new ArgumentNullException(nameof(unitParser));
+        _culture = culture ?? throw new ArgumentNullException(nameof(culture));
+    }
+
+    /// <inheritdoc />
+    public sealed override bool CanConvert(Type typeToConvert)
+    {
+        return _unitParser.Quantities.TryGetQuantityByUnitType(typeToConvert, out _);
+    }
+
+    /// <inheritdoc />
+    public sealed override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+    {
+        // QuantityInfo quantityInfo = _unitParser.Quantities.GetQuantityByUnitType(typeToConvert);
+        Type converterType = typeof(AbbreviatedUnitConverter<>).MakeGenericType(typeToConvert);
+        return (JsonConverter?)Activator.CreateInstance(converterType, _unitParser, _culture);
+    }
+}
+
+/// <summary>
+///     Converter to convert unit-enums to and from abbreviated strings.
+/// </summary>
+/// <remarks>
+///     Reading is case-insensitive, with case-sensitive disambiguation.
+/// </remarks>
+public class AbbreviatedUnitConverter<TUnit> : JsonConverter<TUnit> where TUnit : struct, Enum
+{
+    private readonly UnitParser _unitParser;
+    private readonly CultureInfo _culture = CultureInfo.InvariantCulture;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedUnitConverter" /> class
+    ///     using the default <see cref="UnitParser" />.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor sets up the converter to use the default <see cref="UnitParser" />
+    ///     for resolving unit abbreviations during JSON serialization and deserialization.
+    /// </remarks>
+    public AbbreviatedUnitConverter()
+        : this(UnitParser.Default)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedUnitConverter" /> class with the specified unit parser.
+    /// </summary>
+    /// <param name="unitParser">
+    ///     The <see cref="UnitParser" /> used for deserializing an abbreviation back into its
+    ///     corresponding unit.
+    /// </param>
+    /// <remarks>
+    ///     This constructor sets up the converter to utilize the provided <see cref="UnitParser" />
+    ///     for managing unit abbreviations and parsing during JSON operations.
+    /// </remarks>
+    public AbbreviatedUnitConverter(UnitParser unitParser)
+    {
+        _unitParser = unitParser ?? throw new ArgumentNullException(nameof(unitParser));
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="AbbreviatedUnitConverter" /> class with the specified unit parser and culture.
+    /// </summary>
+    /// <param name="unitParser">
+    ///     The <see cref="UnitParser" /> used for deserializing an abbreviation back into its
+    ///     corresponding unit.
+    /// </param>
+    /// <param name="culture">The <see cref="CultureInfo" /> used for parsing and formatting unit abbreviations.</param>
+    /// <remarks>
+    ///     This constructor allows customization of both the unit abbreviations cache and the culture used for parsing and
+    ///     formatting unit abbreviations.
+    /// </remarks>
+    public AbbreviatedUnitConverter(UnitParser unitParser, CultureInfo culture)
+    {
+        _unitParser = unitParser ?? throw new ArgumentNullException(nameof(unitParser));
+        _culture = culture ?? throw new ArgumentNullException(nameof(culture));
+    }
+
+    /// <inheritdoc />
+    public override TUnit Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        return _unitParser.Parse<TUnit>(reader.GetString()!, _culture);
+    }
+
+    /// <inheritdoc />
+    public override TUnit ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        return Read(ref reader, typeToConvert, options);
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, TUnit value, JsonSerializerOptions options)
+    {
+        var abbreviation = _unitParser.Abbreviations.GetDefaultAbbreviation(value, _culture);
+        writer.WriteStringValue(abbreviation);
+    }
+
+    /// <inheritdoc />
+    public override void WriteAsPropertyName(Utf8JsonWriter writer, TUnit value, JsonSerializerOptions options)
+    {
+        writer.WritePropertyName(_unitParser.Abbreviations.GetDefaultAbbreviation(value, _culture));
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/Unit/UnitTypeAndNameConverter.cs b/UnitsNet.Serialization.SystemTextJson/Unit/UnitTypeAndNameConverter.cs
new file mode 100644
index 0000000000..4a87924995
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/Unit/UnitTypeAndNameConverter.cs
@@ -0,0 +1,203 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+#if NET
+using System.Text;
+using System.Diagnostics.CodeAnalysis;
+#endif
+
+namespace UnitsNet.Serialization.SystemTextJson.Unit;
+
+/// <summary>
+///     Provides functionality for converting units of a specific type to and from their string representations
+///     in JSON serialization and deserialization processes.
+/// </summary>
+/// <remarks>
+///     This converter uses the <see cref="UnitInfo.Name" /> corresponding to the given unit in the provided
+///     <see cref="QuantityInfoLookup" />.
+///     <para>It supports case-sensitive or case-insensitive comparisons based on the specified configuration.</para>
+/// </remarks>
+/// <seealso cref="System.Text.Json.Serialization.JsonConverter{T}" />
+/// <seealso cref="System.Text.Json.Serialization.JsonConverterFactory" />
+#if NET
+[RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")]
+[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
+#endif
+public class UnitTypeAndNameConverter : JsonConverterFactory
+{
+    private readonly bool _ignoreCase;
+    private readonly QuantityInfoLookup _quantities;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitTypeAndNameConverter" /> class with case-sensitive unit matching.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor uses the default <see cref="QuantityInfoLookup" /> from <see cref="UnitsNetSetup.Default" />
+    ///     to resolve unit names during JSON serialization and deserialization.
+    /// </remarks>
+    public UnitTypeAndNameConverter()
+        : this(UnitsNetSetup.Default.Quantities)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitTypeAndNameConverter" /> class
+    ///     with an option to specify case sensitivity.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor uses the default <see cref="QuantityInfoLookup" /> from <see cref="UnitsNetSetup.Default" />
+    ///     to resolve unit names during JSON serialization and deserialization.
+    /// </remarks>
+    public UnitTypeAndNameConverter(bool ignoreCase)
+        : this(UnitsNetSetup.Default.Quantities, ignoreCase)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitTypeAndNameConverter" /> class with the specified
+    ///     <see cref="QuantityInfoLookup" />  and an option to specify case sensitivity.
+    /// </summary>
+    /// <param name="quantities">
+    ///     The <see cref="QuantityInfoLookup" /> instance used to resolve quantity and unit information
+    ///     during JSON serialization and deserialization.
+    /// </param>
+    /// <param name="ignoreCase">
+    ///     A boolean value indicating whether the unit name comparison should ignore case during JSON serialization and
+    ///     deserialization.
+    /// </param>
+    /// <remarks>
+    ///     This constructor allows customization of the <see cref="QuantityInfoLookup" /> used for parsing and
+    ///     formatting unit names, enabling advanced scenarios where specific quantity and unit information is required.
+    /// </remarks>
+    public UnitTypeAndNameConverter(QuantityInfoLookup quantities, bool ignoreCase = false)
+    {
+        _quantities = quantities;
+        _ignoreCase = ignoreCase;
+    }
+
+    /// <inheritdoc />
+    public sealed override bool CanConvert(Type typeToConvert)
+    {
+        return _quantities.TryGetQuantityByUnitType(typeToConvert, out _);
+    }
+
+    /// <inheritdoc />
+    public sealed override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+    {
+        QuantityInfo quantityInfo = _quantities.GetQuantityByUnitType(typeToConvert);
+        Type converterType = typeof(UnitTypeAndNameConverter<>).MakeGenericType(typeToConvert);
+        return (JsonConverter?)Activator.CreateInstance(converterType, quantityInfo, _ignoreCase);
+    }
+}
+
+/// <summary>
+///     Provides functionality for converting units of a specific type to and from their string representations
+///     in JSON serialization and deserialization processes.
+/// </summary>
+/// <typeparam name="TUnit">
+///     The type of the unit being converted, which must be a struct and an enumeration.
+/// </typeparam>
+/// <remarks>
+///     This converter uses the <see cref="UnitInfo.Name" /> corresponding to the given unit in the
+///     provided <see cref="QuantityInfo{TUnit}" />.
+///     <para>It supports case-sensitive or case-insensitive comparisons based on the specified configuration.</para>
+/// </remarks>
+/// <seealso cref="System.Text.Json.Serialization.JsonConverter{T}" />
+/// <seealso cref="System.Text.Json.Serialization.JsonConverterFactory" />
+public class UnitTypeAndNameConverter<TUnit> : JsonConverter<TUnit> where TUnit : struct, Enum
+{
+    private const int StackAllocThreshold = 512;
+    
+    private readonly bool _ignoreCase;
+    private readonly QuantityInfo<TUnit> _quantityInfo;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitTypeAndNameConverter{TUnit}" /> class with the specified
+    ///     quantity information and an option to configure case sensitivity for unit name comparisons.
+    /// </summary>
+    /// <param name="quantityInfo">
+    ///     The quantity information that provides metadata about the unit type, including unit abbreviations and the base
+    ///     unit.
+    /// </param>
+    /// <param name="ignoreCase">
+    ///     A boolean value indicating whether the unit name comparison should ignore case during JSON serialization and
+    ///     deserialization.
+    /// </param>
+    /// <exception cref="ArgumentNullException">
+    ///     Thrown when <paramref name="quantityInfo" /> is <c>null</c>.
+    /// </exception>
+    public UnitTypeAndNameConverter(QuantityInfo<TUnit> quantityInfo, bool ignoreCase = false)
+    {
+        _quantityInfo = quantityInfo ?? throw new ArgumentNullException(nameof(quantityInfo));
+        _ignoreCase = ignoreCase;
+    }
+
+    /// <inheritdoc />
+    public override TUnit Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var nbBytes = reader.HasValueSequence ? checked((int)reader.ValueSequence.Length) : reader.ValueSpan.Length;
+        Span<char> charBuffer = nbBytes <= StackAllocThreshold ? stackalloc char[nbBytes] : new char[nbBytes];
+        var charsWritten = reader.CopyString(charBuffer);
+        ReadOnlySpan<char> unitSpan = charBuffer.Slice(0, charsWritten);
+        if (!unitSpan.TrySplit('.', out _, out ReadOnlySpan<char> unitName))
+        {
+#if NET
+            throw new JsonException($"Invalid unit format: \"{unitSpan}\"");
+#else
+            throw new JsonException($"Invalid unit format: \"{unitSpan.ToString()}\"");
+#endif
+        }
+
+        IReadOnlyList<UnitInfo<TUnit>> unitInfos = _quantityInfo.UnitInfos;
+        var nbUnits = unitInfos.Count;
+        if (_ignoreCase)
+        {
+            for (var i = 0; i < nbUnits; i++)
+            {
+                UnitInfo<TUnit> unitInfo = unitInfos[i];
+                if (unitName.Equals(unitInfo.Name.AsSpan(), StringComparison.OrdinalIgnoreCase))
+                {
+                    return unitInfo.Value;
+                }
+            }
+        }
+        else
+        {
+            // TODO see if we want to also validate the first part of the format
+            for (var i = 0; i < nbUnits; i++)
+            {
+                UnitInfo<TUnit> unitInfo = unitInfos[i];
+                if (unitName.SequenceEqual(unitInfo.Name.AsSpan()))
+                {
+                    return unitInfo.Value;
+                }
+            }
+        }
+
+        var unitNamePart = unitName.ToString();
+        throw new UnitNotFoundException($"No unit was found for quantity '{_quantityInfo.Name}' with the name: '{unitNamePart}'.")
+        {
+            Data = { ["quantityName"] = _quantityInfo.Name, ["unitName"] = unitNamePart }
+        };
+    }
+
+    /// <inheritdoc />
+    public override TUnit ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        return Read(ref reader, typeToConvert, options);
+    }
+    
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, TUnit value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValues(typeof(TUnit).Name.AsSpan(), '.', _quantityInfo[value].Name.AsSpan());
+    }
+
+    /// <inheritdoc />
+    public override void WriteAsPropertyName(Utf8JsonWriter writer, TUnit value, JsonSerializerOptions options)
+    {
+        writer.WriteValuesAsPropertyName(typeof(TUnit).Name.AsSpan(), '.', _quantityInfo[value].Name.AsSpan());
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/UnitsNet.Serialization.SystemTextJson.csproj b/UnitsNet.Serialization.SystemTextJson/UnitsNet.Serialization.SystemTextJson.csproj
new file mode 100644
index 0000000000..da3721560c
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/UnitsNet.Serialization.SystemTextJson.csproj
@@ -0,0 +1,54 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- NuGet properties -->
+  <PropertyGroup>
+    <PackageId>UnitsNet.Serialization.SystemTextJson</PackageId>
+    <Version>6.0.0-pre021</Version>
+    <Authors>Andreas Gullberg Larsen</Authors>
+    <Title>Units.NET Serialization with System.Text.Json</Title>
+    <Description>A helper library for serializing and deserializing types in Units.NET using System.Text.Json.</Description>
+    <Copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</Copyright>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <RepositoryUrl>https://github.com/angularsen/UnitsNet</RepositoryUrl>
+    <PackageIcon>logo-32.png</PackageIcon>
+    <PackageIconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</PackageIconUrl>
+    <PackageProjectUrl>https://github.com/angularsen/UnitsNet</PackageProjectUrl>
+    <PackageLicenseExpression>MIT-0</PackageLicenseExpression>
+    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
+    <PackageTags>unit units measurement json System.Text.Json serialize deserialize serialization deserialization</PackageTags>
+    <PackageReleaseNotes>Initial release with quantity, unit, and QuantityValue converters.</PackageReleaseNotes>
+    <IsAotCompatible Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">true</IsAotCompatible>
+  </PropertyGroup>
+
+  <!-- Assembly and msbuild properties -->
+  <PropertyGroup>
+    <AssemblyVersion>6.0.0.0</AssemblyVersion> <!-- Should reflect major part of Version -->
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <RootNamespace>UnitsNet.Serialization.SystemTextJson</RootNamespace>
+    <TargetFrameworks>netstandard2.0;net8.0;net9.0;net10.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <!-- Strong name signing -->
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>../UnitsNet.snk</AssemblyOriginatorKeyFile>
+    <DelaySign>false</DelaySign>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+
+  <!-- NuGet references that work for both signed and unsigned -->
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Text.Json" />
+  </ItemGroup>
+
+  <!-- Project references, will also generate the corresponding nuget dependencies -->
+  <ItemGroup>
+    <ProjectReference Include="..\UnitsNet\UnitsNet.csproj" />
+  </ItemGroup>
+
+  <!-- Files to include in nuget package -->
+  <ItemGroup>
+    <None Include="../Docs/Images/logo-32.png" Pack="true" PackagePath="/" />
+  </ItemGroup>
+
+</Project>
diff --git a/UnitsNet.Serialization.SystemTextJson/Value/BigIntegerConverter.cs b/UnitsNet.Serialization.SystemTextJson/Value/BigIntegerConverter.cs
new file mode 100644
index 0000000000..708692292b
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/Value/BigIntegerConverter.cs
@@ -0,0 +1,120 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Globalization;
+using System.Numerics;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+#if NETSTANDARD2_0
+using System.Buffers;
+#endif
+
+namespace UnitsNet.Serialization.SystemTextJson.Value;
+
+/// <summary>
+///     Provides a custom JSON converter for <see cref="System.Numerics.BigInteger" />.
+///     This converter serializes <see cref="System.Numerics.BigInteger" /> values as JSON strings
+///     and deserializes JSON strings back into <see cref="System.Numerics.BigInteger" /> values.
+/// </summary>
+public class BigIntegerConverter : JsonConverter<BigInteger>
+{
+    /// <summary>
+    ///     Gets the default instance of the <see cref="BigIntegerConverter" />.
+    /// </summary>
+    /// <remarks>
+    ///     This instance can be used as a singleton for converting <see cref="System.Numerics.BigInteger" />
+    ///     values to and from JSON without the need to create a new instance of <see cref="BigIntegerConverter" />.
+    /// </remarks>
+    public static BigIntegerConverter Default { get; } = new();
+
+    /// <inheritdoc />
+    public override BigInteger Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        switch (reader.TokenType)
+        {
+            case JsonTokenType.Number:
+            {
+#if NET
+                var nbBytes = reader.HasValueSequence ? checked((int)reader.ValueSequence.Length) : reader.ValueSpan.Length;
+                Span<char> charBuffer = nbBytes <= 512 ? stackalloc char[nbBytes] : new char[nbBytes];
+                var charsWritten = reader.HasValueSequence
+                    ? Encoding.UTF8.GetChars(reader.ValueSequence, charBuffer)
+                    : Encoding.UTF8.GetChars(reader.ValueSpan, charBuffer);
+                return BigInteger.Parse(charBuffer[..charsWritten], CultureInfo.InvariantCulture);
+#else
+                var bytes = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();
+                var charBuffer = new char[bytes.Length];
+                var charsWritten = Encoding.UTF8.GetChars(bytes, 0, bytes.Length, charBuffer, 0);
+                return BigInteger.Parse(new string(charBuffer, 0, charsWritten), CultureInfo.InvariantCulture);
+#endif
+            }
+            case JsonTokenType.String:
+            {
+                if ((options.NumberHandling & JsonNumberHandling.AllowReadingFromString) == 0)
+                {
+                    throw new JsonException(
+                        "String tokens are not supported with the current `NumberHandling` settings. Consider specifying 'JsonNumberHandling.AllowReadingFromString' (see https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonnumberhandling)");
+                }
+
+#if NET
+                var nbBytes = reader.HasValueSequence ? checked((int)reader.ValueSequence.Length) : reader.ValueSpan.Length;
+                Span<char> charBuffer = nbBytes <= 512 ? stackalloc char[nbBytes] : new char[nbBytes];
+                var charsWritten = reader.CopyString(charBuffer);
+                return BigInteger.Parse(charBuffer[..charsWritten], CultureInfo.InvariantCulture);
+#else
+                return BigInteger.Parse(reader.GetString()!, CultureInfo.InvariantCulture);
+#endif
+            }
+            case JsonTokenType.None:
+            case JsonTokenType.StartObject:
+            case JsonTokenType.EndObject:
+            case JsonTokenType.StartArray:
+            case JsonTokenType.EndArray:
+            case JsonTokenType.PropertyName:
+            case JsonTokenType.Comment:
+            case JsonTokenType.True:
+            case JsonTokenType.False:
+            case JsonTokenType.Null:
+            default:
+                throw new JsonException($"Unexpected token type: {reader.TokenType}");
+        }
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, BigInteger value, JsonSerializerOptions options)
+    {
+        if ((options.NumberHandling & JsonNumberHandling.WriteAsString) == 0)
+        {
+#if NET
+            Span<char> charBuffer = stackalloc char[512];
+            if (value.TryFormat(charBuffer, out var charsWritten, provider: NumberFormatInfo.InvariantInfo))
+            {
+                writer.WriteRawValue(charBuffer[..charsWritten], true);
+            }
+            else // the number did not fit into the buffer
+            {
+                writer.WriteRawValue(value.ToString(NumberFormatInfo.InvariantInfo), true);
+            }
+#else
+            writer.WriteRawValue(value.ToString(NumberFormatInfo.InvariantInfo), true);
+#endif
+        }
+        else
+        {
+#if NET
+            Span<char> charBuffer = stackalloc char[512];
+            if (value.TryFormat(charBuffer, out var charsWritten, provider: NumberFormatInfo.InvariantInfo))
+            {
+                writer.WriteStringValue(charBuffer[..charsWritten]);
+            }
+            else // the number did not fit into the buffer
+            {
+                writer.WriteStringValue(value.ToString(NumberFormatInfo.InvariantInfo));
+            }
+#else
+            writer.WriteStringValue(value.ToString(NumberFormatInfo.InvariantInfo));
+#endif
+        }
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueDecimalConverter.cs b/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueDecimalConverter.cs
new file mode 100644
index 0000000000..c5bab5af39
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueDecimalConverter.cs
@@ -0,0 +1,86 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace UnitsNet.Serialization.SystemTextJson.Value;
+
+/// <summary>
+///     A JSON converter for <see cref="QuantityValue" /> that serializes and deserializes values using the decimal type.
+/// </summary>
+/// <remarks>
+///     This converter is tailored for handling <see cref="QuantityValue" /> objects, ensuring precise serialization and
+///     deserialization with support for arbitrary scale and precision. The value is written and read as a regular decimal,
+///     with overflow behavior when the number exceeds the range of a decimal. Additionally, it supports <see cref="JsonNumberHandling" />
+///     options, including reading and writing from strings and handling named floating-point literals.
+/// </remarks>
+public class QuantityValueDecimalConverter : JsonConverter<QuantityValue>
+{
+    /// <inheritdoc />
+    public override QuantityValue Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        decimal value;
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var stringValue = reader.GetString()!;
+            CultureInfo culture = CultureInfo.InvariantCulture;
+            // TODO see if we want to support the named literals
+            if ((options.NumberHandling & JsonNumberHandling.AllowNamedFloatingPointLiterals) != 0)
+            {
+                if (stringValue == culture.NumberFormat.NaNSymbol)
+                {
+                    return QuantityValue.NaN;
+                }
+
+                if (stringValue == culture.NumberFormat.PositiveInfinitySymbol)
+                {
+                    return QuantityValue.PositiveInfinity;
+                }
+
+                if (stringValue == culture.NumberFormat.NegativeInfinitySymbol)
+                {
+                    return QuantityValue.NegativeInfinity;
+                }
+            }
+            
+            if ((options.NumberHandling & JsonNumberHandling.AllowReadingFromString) == 0)
+            {
+                throw new JsonException(
+                    "String tokens are not supported with the current `NumberHandling` settings. Consider specifying 'JsonNumberHandling.AllowReadingFromString' (see https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonnumberhandling)");
+            }
+
+            value = decimal.Parse(stringValue, culture);
+        }
+        else
+        {
+            value = reader.GetDecimal();
+        }
+
+        return new QuantityValue(value);
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, QuantityValue value, JsonSerializerOptions options)
+    {
+        if ((options.NumberHandling & JsonNumberHandling.WriteAsString) != 0)
+        {
+            writer.WriteStringValue(value.ToDecimal().ToString(CultureInfo.InvariantCulture));
+        }
+        else if (QuantityValue.IsNaN(value) || QuantityValue.IsInfinity(value))
+        {
+            if ((options.NumberHandling & JsonNumberHandling.AllowNamedFloatingPointLiterals) == 0)
+            {
+                throw new JsonException(
+                    $"Serializing '{value}' is not allowed. Consider specifying 'JsonNumberHandling.AllowNamedFloatingPointLiterals' (see https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonnumberhandling)");
+            }
+
+            writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
+        }
+        else
+        {
+            writer.WriteNumberValue(value.ToDecimal());
+        }
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueDecimalNotationConverter.cs b/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueDecimalNotationConverter.cs
new file mode 100644
index 0000000000..142c1fab64
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueDecimalNotationConverter.cs
@@ -0,0 +1,180 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+#if NETSTANDARD2_0
+using System.Buffers;
+#endif
+
+namespace UnitsNet.Serialization.SystemTextJson.Value;
+
+/// <summary>
+///     Provides functionality to convert <see cref="QuantityValue" /> instances to and from their JSON representation
+///     using decimal notation, which supports arbitrary scale and precision.
+/// </summary>
+/// <remarks>
+///     This converter is designed to handle serialization and deserialization of <see cref="QuantityValue" /> objects
+///     using decimal notation. A configurable maximum number of significant digits, corresponding to the `G` format
+///     specifier, can be used to control the precision of the serialized output.
+///     <para>
+///         While this converter supports arbitrary precision, without any limits on the scale, it should be noted that
+///         the serialized payload may fall outside the capabilities of the standard numeric types.
+///     </para>
+///     <para>Values such as 1/3 cannot be represented exactly.</para>
+/// </remarks>
+public class QuantityValueDecimalNotationConverter : JsonConverter<QuantityValue>
+{
+    private const int StackAllocThreshold = 512;
+    
+    private readonly string _serializationFormat;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValueDecimalNotationConverter" /> class
+    ///     with a default maximum number of significant digits set to 17.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor simplifies the creation of the converter by using a default precision of 17 significant digits,
+    ///     which corresponds to the `G17` format specifier.
+    /// </remarks>
+    public QuantityValueDecimalNotationConverter()
+        : this(17)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValueDecimalNotationConverter" /> class with an optional
+    ///     maximum number of significant digits for serialization.
+    /// </summary>
+    /// <param name="maxNumberOfSignificantDigits">
+    ///     The maximum number of significant digits to use during serialization.
+    /// </param>
+    /// <exception cref="ArgumentOutOfRangeException">
+    ///     Thrown when <paramref name="maxNumberOfSignificantDigits" /> is less than 0.
+    /// </exception>
+    /// <remarks>
+    ///     This constructor allows configuring the precision of the serialized output by specifying the maximum
+    ///     number of significant digits, which corresponds to the `G` format specifier.
+    /// </remarks>
+    public QuantityValueDecimalNotationConverter(int maxNumberOfSignificantDigits)
+    {
+        if (maxNumberOfSignificantDigits < 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(maxNumberOfSignificantDigits), "The number of significant digits must greater or equal to 0.");
+        }
+
+        _serializationFormat = "G" + maxNumberOfSignificantDigits;
+    }
+
+    /// <inheritdoc />
+    public override QuantityValue Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        switch (reader.TokenType)
+        {
+            case JsonTokenType.Number:
+            {
+#if NET
+                var nbBytes = reader.HasValueSequence ? checked((int)reader.ValueSequence.Length) : reader.ValueSpan.Length;
+                Span<char> charBuffer = nbBytes <= StackAllocThreshold ? stackalloc char[nbBytes] : new char[nbBytes];
+                var charsWritten = reader.HasValueSequence
+                    ? Encoding.UTF8.GetChars(reader.ValueSequence, charBuffer)
+                    : Encoding.UTF8.GetChars(reader.ValueSpan, charBuffer);
+                return QuantityValue.Parse(charBuffer[..charsWritten], NumberStyles.Float, CultureInfo.InvariantCulture);
+#else
+                var bytes = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();
+                var charBuffer = new char[bytes.Length];
+                var charsWritten = Encoding.UTF8.GetChars(bytes, 0, bytes.Length, charBuffer, 0);
+                return QuantityValue.Parse(new string(charBuffer, 0, charsWritten), NumberStyles.Float, CultureInfo.InvariantCulture);
+#endif
+            }
+            case JsonTokenType.String:
+            {
+                if ((options.NumberHandling & (JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals)) == 0)
+                {
+                    throw new JsonException(
+                        "String tokens are not supported with the current `NumberHandling` settings. Consider specifying 'JsonNumberHandling.AllowReadingFromString' (see https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonnumberhandling)");
+                }
+
+                var nbBytes = reader.HasValueSequence ? checked((int)reader.ValueSequence.Length) : reader.ValueSpan.Length;
+                Span<char> charBuffer = nbBytes <= StackAllocThreshold ? stackalloc char[nbBytes] : new char[nbBytes];
+                var charsWritten = reader.CopyString(charBuffer);
+#if NET
+                return QuantityValue.Parse(charBuffer[..charsWritten], NumberStyles.Float, CultureInfo.InvariantCulture);
+#else
+                return QuantityValue.Parse(charBuffer.Slice(0, charsWritten).ToString(), NumberStyles.Float, CultureInfo.InvariantCulture);
+#endif
+            }
+            case JsonTokenType.None:
+            case JsonTokenType.StartObject:
+            case JsonTokenType.EndObject:
+            case JsonTokenType.StartArray:
+            case JsonTokenType.EndArray:
+            case JsonTokenType.PropertyName:
+            case JsonTokenType.Comment:
+            case JsonTokenType.True:
+            case JsonTokenType.False:
+            case JsonTokenType.Null:
+            default:
+                throw new JsonException($"Unexpected token type: {reader.TokenType}");
+        }
+
+        
+//         if (reader.TokenType is not (JsonTokenType.Number or JsonTokenType.String))
+//         {
+//             throw new JsonException($"Expected a string or a number, not a {reader.TokenType}");
+//         }
+//
+//         if (reader.TokenType == JsonTokenType.String && (options.NumberHandling & (JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals)) == 0)
+//         {
+//             throw new JsonException("Reading numbers from string tokens is not allowed. Consider specifying 'JsonNumberHandling.AllowReadingFromString' (see https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonnumberhandling)");
+//         }
+// #if NET
+//         ReadOnlySpan<byte> bytes = reader.ValueSpan;
+//         var charCount = Encoding.UTF8.GetCharCount(bytes);
+//         Span<char> charBuffer = charCount <= 256 ? stackalloc char[charCount] : new char[charCount];
+//         Encoding.UTF8.GetChars(bytes, charBuffer);
+//         return QuantityValue.Parse(charBuffer, NumberStyles.Float, CultureInfo.InvariantCulture);
+// #else
+//         var bytes = reader.ValueSpan.ToArray();
+//         var charCount = Encoding.UTF8.GetCharCount(bytes);
+//         var charBuffer = new char[charCount];
+//         Encoding.UTF8.GetChars(bytes, 0, bytes.Length, charBuffer, 0);
+//         return QuantityValue.Parse(new string(charBuffer), NumberStyles.Float, CultureInfo.InvariantCulture);
+// #endif
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, QuantityValue value, JsonSerializerOptions options)
+    {
+        if ((options.NumberHandling & JsonNumberHandling.WriteAsString) != 0)
+        {
+            writer.WriteStringValue(value.ToString(_serializationFormat, CultureInfo.InvariantCulture));
+        }
+        else if (QuantityValue.IsNaN(value) || QuantityValue.IsInfinity(value))
+        {
+            if ((options.NumberHandling & JsonNumberHandling.AllowNamedFloatingPointLiterals) == 0)
+            {
+                throw new JsonException($"Serializing '{value}' is not allowed. Consider specifying 'JsonNumberHandling.AllowNamedFloatingPointLiterals' (see https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonnumberhandling)");
+            }
+
+            writer.WriteStringValue(value.ToString(_serializationFormat, CultureInfo.InvariantCulture));
+        }
+        else
+        {
+#if NET
+            Span<char> charBuffer = stackalloc char[256];
+            int charsWritten;
+            while (!value.TryFormat(charBuffer, out charsWritten, _serializationFormat, CultureInfo.InvariantCulture))
+            {
+                charBuffer = new char[charBuffer.Length * 2];
+            }
+            
+            writer.WriteRawValue(charBuffer[..charsWritten], true);   
+#else
+            writer.WriteRawValue(value.ToString(_serializationFormat, CultureInfo.InvariantCulture), true);
+#endif
+        }
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueDoubleConverter.cs b/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueDoubleConverter.cs
new file mode 100644
index 0000000000..320306b140
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueDoubleConverter.cs
@@ -0,0 +1,110 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace UnitsNet.Serialization.SystemTextJson.Value;
+
+/// <summary>
+///     Provides functionality to convert <see cref="QuantityValue" /> instances to and from their JSON representation
+///     using double-precision floating-point notation.
+/// </summary>
+/// <remarks>
+///     This converter is designed to handle serialization and deserialization of <see cref="QuantityValue" /> objects
+///     using double-precision floating-point notation. The configurable maximum number of significant digits is only
+///     applied during deserialization to control the precision of the parsed input.
+///     <para>
+///         Additionally, this converter supports the <see cref="JsonNumberHandling.WriteAsString" /> option for writing
+///         numeric values as strings during serialization, and the
+///         <see cref="JsonNumberHandling.AllowNamedFloatingPointLiterals" />
+///         option for deserializing named floating-point literals such as "NaN", "Infinity", and "-Infinity".
+///     </para>
+/// </remarks>
+public class QuantityValueDoubleConverter : JsonConverter<QuantityValue>
+{
+    private readonly byte _maxNumberOfSignificantDigits;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValueDoubleConverter" /> class
+    ///     with a default maximum number of significant digits set to 15.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor simplifies the creation of the converter by using a default serialization precision of 15
+    ///     significant digits.
+    /// </remarks>
+    public QuantityValueDoubleConverter()
+        : this(15)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValueDoubleConverter" /> class with an optional
+    ///     maximum number of significant digits for serialization.
+    /// </summary>
+    /// <param name="maxNumberOfSignificantDigits">
+    ///     The maximum number of significant digits to use during serialization.
+    /// </param>
+    /// <exception cref="T:System.ArgumentOutOfRangeException">
+    ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+    /// </exception>
+    /// <remarks>
+    ///     This constructor allows configuring the precision of the precision used when converting from double.
+    /// </remarks>
+    public QuantityValueDoubleConverter(byte maxNumberOfSignificantDigits)
+    {
+        if (maxNumberOfSignificantDigits is < 1 or > 17)
+        {
+            throw new ArgumentOutOfRangeException(nameof(maxNumberOfSignificantDigits), maxNumberOfSignificantDigits,
+                "The maximum number of significant digits must be between 1 and 17.");
+        }
+        
+        _maxNumberOfSignificantDigits = maxNumberOfSignificantDigits;
+    }
+
+    /// <inheritdoc />
+    public override QuantityValue Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        double value;
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            if ((options.NumberHandling & (JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.AllowNamedFloatingPointLiterals)) == 0)
+            {
+                throw new JsonException(
+                    "String tokens are not supported with the current `NumberHandling` settings. Consider specifying 'JsonNumberHandling.AllowReadingFromString' (see https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonnumberhandling)");
+            }
+
+            value = double.Parse(reader.GetString()!, CultureInfo.InvariantCulture);
+        }
+        else
+        {
+            value = reader.GetDouble();
+        }
+
+        return QuantityValue.FromDoubleRounded(value, _maxNumberOfSignificantDigits);
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, QuantityValue value, JsonSerializerOptions options)
+    {
+        if ((options.NumberHandling & JsonNumberHandling.WriteAsString) != 0)
+        {
+            writer.WriteStringValue(value.ToString("R", CultureInfo.InvariantCulture));
+        }
+        else if (QuantityValue.IsNaN(value) || QuantityValue.IsInfinity(value))
+        {
+            if ((options.NumberHandling & JsonNumberHandling.AllowNamedFloatingPointLiterals) == 0)
+            {
+                throw new JsonException(
+                    $"Serializing '{value}' is not allowed. Consider specifying 'JsonNumberHandling.AllowNamedFloatingPointLiterals' (see https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonnumberhandling)");
+            }
+
+            writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
+        }
+        else
+        {
+            writer.WriteNumberValue(value.ToDouble());
+        }
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueFractionalNotationConverter.cs b/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueFractionalNotationConverter.cs
new file mode 100644
index 0000000000..bed51a5289
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueFractionalNotationConverter.cs
@@ -0,0 +1,227 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Numerics;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace UnitsNet.Serialization.SystemTextJson.Value;
+
+/// <summary>
+///     Provides functionality for serializing and deserializing <see cref="QuantityValue" /> objects
+///     to and from JSON format.
+/// </summary>
+/// <remarks>
+///     This converter handles the serialization and deserialization of <see cref="QuantityValue" /> objects
+///     by utilizing a custom <see cref="QuantityValue" /> for <see cref="JsonConverter{T}" /> values.
+///     It ensures that the numerator and denominator properties of <see cref="BigInteger" /> are
+///     properly processed during JSON operations.
+/// </remarks>
+public class QuantityValueFractionalNotationConverter : JsonConverter<QuantityValue>
+{
+    private static readonly JsonEncodedText PropName_Numerator = JsonEncodedText.Encode("N");
+    private static readonly JsonEncodedText PropName_Numerator_Lowercase = JsonEncodedText.Encode("n");
+
+    private static readonly JsonEncodedText PropName_Denominator = JsonEncodedText.Encode("D");
+    private static readonly JsonEncodedText PropName_Denominator_Lowercase = JsonEncodedText.Encode("d");
+
+    private readonly JsonConverter<BigInteger> _bigIntegerConverter;
+    private readonly bool _reduceTerms;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValue" /> class
+    ///     with default settings.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor sets up the converter to handle the serialization and deserialization
+    ///     of <see cref="QuantityValueFractionalNotationConverter" /> objects in JSON format, using default behavior.
+    /// </remarks>
+    public QuantityValueFractionalNotationConverter()
+        : this(false)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValueFractionalNotationConverter" /> class
+    ///     with the default configuration.
+    /// </summary>
+    /// <remarks>
+    ///     This constructor sets up the converter with default settings, where terms are not reduced
+    ///     during serialization and deserialization.
+    /// </remarks>
+    public QuantityValueFractionalNotationConverter(bool reduceTerms)
+        : this(BigIntegerConverter.Default, reduceTerms)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValueFractionalNotationConverter" /> class
+    ///     with the specified <see cref="JsonConverter{T}" /> for <see cref="BigInteger" /> values and an option
+    ///     to reduce terms during serialization.
+    /// </summary>
+    /// <param name="bigIntegerConverter">
+    ///     The <see cref="JsonConverter{T}" /> used to handle serialization and deserialization of <see cref="BigInteger" />
+    ///     values.
+    /// </param>
+    /// <param name="reduceTerms">
+    ///     A boolean value indicating whether the terms should be reduced before serializing.
+    /// </param>
+    /// <exception cref="ArgumentNullException">
+    ///     Thrown when the <paramref name="bigIntegerConverter" /> is <c>null</c>.
+    /// </exception>
+    public QuantityValueFractionalNotationConverter(JsonConverter<BigInteger> bigIntegerConverter, bool reduceTerms = false)
+    {
+        _bigIntegerConverter = bigIntegerConverter ?? throw new ArgumentNullException(nameof(bigIntegerConverter));
+        _reduceTerms = reduceTerms;
+    }
+
+    /// <summary>
+    ///     Gets the default instance of the <see cref="QuantityValueFractionalNotationConverter" />.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides a pre-configured, shared instance of the converter
+    ///     with default settings, simplifying the serialization and deserialization
+    ///     of <see cref="QuantityValue" /> objects in JSON format.
+    /// </remarks>
+    public static QuantityValueFractionalNotationConverter Default { get; } = new();
+
+    /// <summary>
+    ///     Gets an instance of <see cref="QuantityValueFractionalNotationConverter" /> configured to reduce terms
+    ///     during serialization and deserialization.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides a pre-configured converter that simplifies fractional representations
+    ///     by reducing the numerator and denominator to their smallest terms.
+    /// </remarks>
+    public static QuantityValueFractionalNotationConverter Reducing { get; } = new(true);
+
+    /// <inheritdoc />
+    public override QuantityValue Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.StartObject)
+        {
+            throw new JsonException("Expected StartObject token.");
+        }
+
+        BigInteger? numerator = null;
+        BigInteger? denominator = null;
+        JsonEncodedText numeratorProperty, denominatorProperty;
+        if (options.PropertyNamesShouldStartWithLowercase())
+        {
+            numeratorProperty = PropName_Numerator_Lowercase;
+            denominatorProperty = PropName_Denominator_Lowercase;
+        }
+        else
+        {
+            numeratorProperty = PropName_Numerator;
+            denominatorProperty = PropName_Denominator;
+        }
+
+        if (options.PropertyNameCaseInsensitive)
+        {
+            while (reader.ReadNextProperty())
+            {
+                var propertyName = reader.GetString();
+                reader.Read();
+                if (StringComparer.OrdinalIgnoreCase.Equals(propertyName, numeratorProperty.Value))
+                {
+                    numerator = _bigIntegerConverter.Read(ref reader, typeof(BigInteger), options);
+                }
+                else if (StringComparer.OrdinalIgnoreCase.Equals(propertyName, denominatorProperty.Value))
+                {
+                    denominator = _bigIntegerConverter.Read(ref reader, typeof(BigInteger), options);
+                }
+                else if (options.UnmappedMemberHandling == JsonUnmappedMemberHandling.Skip)
+                {
+                    reader.Skip(); // Skip unknown properties
+                }
+                else
+                {
+                    throw new JsonException($"'{propertyName}' was no found in the list of members of '{typeToConvert}'.");
+                }
+            }
+        }
+        else
+        {
+            while (reader.ReadNextProperty())
+            {
+                if (reader.ValueTextEquals(numeratorProperty.EncodedUtf8Bytes))
+                {
+                    reader.Read();
+                    numerator = _bigIntegerConverter.Read(ref reader, typeof(BigInteger), options);
+                }
+                else if (reader.ValueTextEquals(denominatorProperty.EncodedUtf8Bytes))
+                {
+                    reader.Read();
+                    denominator = _bigIntegerConverter.Read(ref reader, typeof(BigInteger), options);
+                }
+                else if (options.UnmappedMemberHandling == JsonUnmappedMemberHandling.Skip)
+                {
+                    reader.Skip(); // Skip unknown properties
+                }
+                else
+                {
+                    throw new JsonException($"'{reader.GetString()}' was no found in the list of members of '{typeToConvert}'.");
+                }
+            }
+        }
+
+        if (numerator.HasValue && denominator.HasValue)
+        {
+            return QuantityValue.FromTerms(numerator.Value, denominator.Value);
+        }
+
+        if (numerator.HasValue)
+        {
+            return numerator.Value;
+        }
+
+        return denominator.HasValue ? QuantityValue.FromTerms(BigInteger.Zero, denominator.Value) : QuantityValue.Zero;
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, QuantityValue value, JsonSerializerOptions options)
+    {
+        writer.WriteStartObject();
+
+        (BigInteger numerator, BigInteger denominator) = _reduceTerms ? QuantityValue.Reduce(value) : value;
+        JsonEncodedText numeratorProperty, denominatorProperty;
+        if (options.PropertyNamesShouldStartWithLowercase())
+        {
+            numeratorProperty = PropName_Numerator_Lowercase;
+            denominatorProperty = PropName_Denominator_Lowercase;
+        }
+        else
+        {
+            numeratorProperty = PropName_Numerator;
+            denominatorProperty = PropName_Denominator;
+        }
+
+        if (options.DefaultIgnoreCondition == JsonIgnoreCondition.WhenWritingDefault)
+        {
+            // Write only if the property is non-default.
+            if (!numerator.IsZero)
+            {
+                WriteBigInteger(writer, options, numeratorProperty, numerator);
+            }
+
+            if (!denominator.IsOne)
+            {
+                WriteBigInteger(writer, options, denominatorProperty, denominator);
+            }
+        }
+        else // For example, when DefaultIgnoreCondition is Never.
+        {
+            WriteBigInteger(writer, options, numeratorProperty, numerator);
+            WriteBigInteger(writer, options, denominatorProperty, denominator);
+        }
+
+        writer.WriteEndObject();
+    }
+
+    private void WriteBigInteger(Utf8JsonWriter writer, JsonSerializerOptions options, JsonEncodedText propertyName, BigInteger value)
+    {
+        writer.WritePropertyName(propertyName);
+        _bigIntegerConverter.Write(writer, value, options);
+    }
+}
diff --git a/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueMixedNotationConverter.cs b/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueMixedNotationConverter.cs
new file mode 100644
index 0000000000..86c636164d
--- /dev/null
+++ b/UnitsNet.Serialization.SystemTextJson/Value/QuantityValueMixedNotationConverter.cs
@@ -0,0 +1,306 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Numerics;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+#if NETSTANDARD2_0
+using System.Buffers;
+#endif
+
+namespace UnitsNet.Serialization.SystemTextJson.Value;
+
+/// <summary>
+///     Provides a custom JSON converter for serializing and deserializing <see cref="QuantityValue" /> objects
+///     using mixed notation, supporting both fractional and decimal representations.
+/// </summary>
+/// <remarks>
+///     This converter ensures that any <see cref="QuantityValue" /> can round-trip exactly during serialization
+///     and deserialization, even for values like 1/3 that cannot be represented precisely as a finite decimal.
+///     For values with a finite decimal expansion, the shorter and more readable decimal format is used.
+/// </remarks>
+[SuppressMessage("ReSharper", "ReplaceSliceWithRangeIndexer")]
+public class QuantityValueMixedNotationConverter : JsonConverter<QuantityValue>
+{
+    private const int StackAllocThreshold = 512;
+
+    /// <summary>
+    ///     Gets the default instance of the <see cref="QuantityValueMixedNotationConverter" />.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides a pre-configured, shared instance of the converter
+    ///     with default settings, simplifying the serialization and deserialization
+    ///     of <see cref="QuantityValue" /> objects in JSON format.
+    /// </remarks>
+    public static QuantityValueMixedNotationConverter Default { get; } = new();
+
+    /// <inheritdoc />
+    public override QuantityValue Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        switch (reader.TokenType)
+        {
+            case JsonTokenType.Number:
+            {
+#if NET
+                var nbBytes = reader.HasValueSequence ? checked((int)reader.ValueSequence.Length) : reader.ValueSpan.Length;
+                Span<char> charBuffer = nbBytes <= StackAllocThreshold ? stackalloc char[nbBytes] : new char[nbBytes];
+                var charsWritten = reader.HasValueSequence
+                    ? Encoding.UTF8.GetChars(reader.ValueSequence, charBuffer)
+                    : Encoding.UTF8.GetChars(reader.ValueSpan, charBuffer);
+                return QuantityValue.Parse(charBuffer[..charsWritten], NumberStyles.Float, CultureInfo.InvariantCulture);
+#else
+                var bytes = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();
+                var charBuffer = new char[bytes.Length];
+                var charsWritten = Encoding.UTF8.GetChars(bytes, 0, bytes.Length, charBuffer, 0);
+                return QuantityValue.Parse(new string(charBuffer, 0, charsWritten), NumberStyles.Float, CultureInfo.InvariantCulture);
+#endif
+            }
+            case JsonTokenType.String:
+            {
+                var decimalNotationNotAllowed = (options.NumberHandling & JsonNumberHandling.AllowReadingFromString) == 0;
+                if (decimalNotationNotAllowed && reader.ValueIsEscaped)
+                {
+                    throw new JsonException("Numbers can't contain escape characters.");
+                }
+
+                var nbBytes = reader.HasValueSequence ? checked((int)reader.ValueSequence.Length) : reader.ValueSpan.Length;
+                Span<char> charBuffer = nbBytes <= StackAllocThreshold ? stackalloc char[nbBytes] : new char[nbBytes];
+                var charsWritten = reader.CopyString(charBuffer);
+                if (TryParseFraction(charBuffer.Slice(0, charsWritten), out QuantityValue quantityValue))
+                {
+                    return quantityValue;
+                }
+
+                // falling back to the default quoted number handling
+                if (decimalNotationNotAllowed)
+                {
+                    throw new JsonException(
+                        "String tokens are not supported with the current `NumberHandling` settings. Consider specifying 'JsonNumberHandling.AllowReadingFromString' (see https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonnumberhandling)");
+                }
+
+#if NET
+                return QuantityValue.Parse(charBuffer[..charsWritten], NumberStyles.Float, CultureInfo.InvariantCulture);
+#else
+                return QuantityValue.Parse(charBuffer.Slice(0, charsWritten).ToString(), NumberStyles.Float, CultureInfo.InvariantCulture);
+#endif
+            }
+            case JsonTokenType.None:
+            case JsonTokenType.StartObject:
+            case JsonTokenType.EndObject:
+            case JsonTokenType.StartArray:
+            case JsonTokenType.EndArray:
+            case JsonTokenType.PropertyName:
+            case JsonTokenType.Comment:
+            case JsonTokenType.True:
+            case JsonTokenType.False:
+            case JsonTokenType.Null:
+            default:
+                throw new JsonException($"Unexpected token type: {reader.TokenType}");
+        }
+    }
+
+    private static bool TryParseFraction(ReadOnlySpan<char> value, out QuantityValue quantityValue)
+    {
+        if (value.TrySplit('/', out ReadOnlySpan<char> numeratorSpan, out ReadOnlySpan<char> denominatorSpan))
+        {
+#if NET
+            if (BigInteger.TryParse(numeratorSpan, out BigInteger numerator) && BigInteger.TryParse(denominatorSpan, out BigInteger denominator))
+#else
+            if (BigInteger.TryParse(numeratorSpan.ToString(), out BigInteger numerator) &&
+                BigInteger.TryParse(denominatorSpan.ToString(), out BigInteger denominator))
+#endif
+            {
+                quantityValue = QuantityValue.FromTerms(numerator, denominator);
+                return true;
+            }
+        }
+
+        quantityValue = default;
+        return false;
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, QuantityValue value, JsonSerializerOptions options)
+    {
+        (BigInteger numerator, BigInteger denominator) = QuantityValue.Reduce(value);
+        // TODO see about using exponential notation
+
+        if (denominator <= long.MaxValue / 10)
+        {
+            if (numerator <= long.MaxValue && numerator >= long.MinValue)
+            {
+                WriteSmallTerms(writer, (long)numerator, (long)denominator, options.NumberHandling);
+                return;
+            }
+
+            if (denominator.IsOne)
+            {
+                BigIntegerConverter.Default.Write(writer, numerator, options);
+                return;
+            }
+        }
+        
+        if (!QuantityValue.HasNonDecimalFactors(denominator))
+        {
+#if NET
+            writer.WriteValuesAsString(numerator, '/', denominator);
+#else
+            writer.WriteStringValues(numerator.ToString().AsSpan(), '/', denominator.ToString().AsSpan());
+#endif
+            return;
+        }
+
+        var quotient = BigInteger.DivRem(numerator, denominator, out BigInteger remainder);
+
+        // decimal number
+        var bufferSize = StackAllocThreshold;
+#if NET
+        Span<char> charBuffer = stackalloc char[bufferSize];
+        int charsWritten;
+        while (!quotient.TryFormat(charBuffer, out charsWritten))
+        {
+            bufferSize *= 4;
+            charBuffer = new char[bufferSize];
+        }
+
+        if (charsWritten + 2 > bufferSize)
+        {
+            bufferSize *= 2;
+            var extendedBuffer = new char[bufferSize * 2];
+            charBuffer.CopyTo(extendedBuffer);
+            charBuffer = extendedBuffer;
+        }
+#else
+        var quotientString = quotient.ToString();
+        if (quotientString.Length + 2 > bufferSize)
+        {
+            bufferSize = quotientString.Length * 2;
+        }
+
+        // Copy the quotient string into the char buffer
+        Span<char> charBuffer = bufferSize <= StackAllocThreshold ? stackalloc char[bufferSize] : new char[bufferSize];
+        quotientString.AsSpan().CopyTo(charBuffer);
+        var charsWritten = quotientString.Length;
+#endif
+
+        BigInteger ten = 10;
+        charBuffer[charsWritten++] = '.';
+        remainder = BigInteger.Abs(remainder);
+        do
+        {
+            var digit = (int)BigInteger.DivRem(remainder * ten, denominator, out remainder);
+            if (charsWritten == bufferSize)
+            {
+                // extend the buffer
+                bufferSize *= 2;
+                var extendedBuffer = new char[bufferSize * 2];
+                charBuffer.CopyTo(extendedBuffer);
+                charBuffer = extendedBuffer;
+            }
+
+            charBuffer[charsWritten++] = (char)('0' + digit);
+        } while (!remainder.IsZero);
+
+        if ((options.NumberHandling & JsonNumberHandling.WriteAsString) == 0)
+        {
+            writer.WriteRawValue(charBuffer.Slice(0, charsWritten), true);
+        }
+        else
+        {
+            writer.WriteStringValue(charBuffer.Slice(0, charsWritten));
+        }
+    }
+
+    private static void WriteSmallTerms(Utf8JsonWriter writer, long numerator, long denominator, JsonNumberHandling numberHandling)
+    {
+        switch (denominator)
+        {
+            case 0:
+                if ((numberHandling & JsonNumberHandling.AllowNamedFloatingPointLiterals) == 0)
+                {
+                    throw new JsonException(
+                        "NamedFloatingPointLiterals are not supported with the current `NumberHandling` settings. Consider specifying 'JsonNumberHandling.AllowNamedFloatingPointLiterals' (see https://learn.microsoft.com/dotnet/api/system.text.json.serialization.jsonnumberhandling)");
+                }
+
+                // NaN or Infinity
+                switch (numerator)
+                {
+                    case > 0:
+                        writer.WriteStringValue(NumberFormatInfo.InvariantInfo.PositiveInfinitySymbol);
+                        return;
+                    case < 0:
+                        writer.WriteStringValue(NumberFormatInfo.InvariantInfo.NegativeInfinitySymbol);
+                        return;
+                    default:
+                        writer.WriteStringValue(NumberFormatInfo.InvariantInfo.NaNSymbol);
+                        return;
+                }
+            case 1:
+                if ((numberHandling & JsonNumberHandling.WriteAsString) == 0)
+                {
+                    writer.WriteNumberValue(numerator);
+                }
+                else
+                {
+                    writer.WriteStringValue(numerator.ToString());
+                }
+
+                return;
+        }
+
+        var quotient = Math.DivRem(numerator, denominator, out var remainder);
+
+        // decimal number
+        const int bufferSize = 45;
+        Span<char> charBuffer = stackalloc char[bufferSize];
+#if NET
+        quotient.TryFormat(charBuffer, out var charsWritten);
+#else
+        var quotientString = quotient.ToString();
+        quotientString.AsSpan().CopyTo(charBuffer);
+        var charsWritten = quotientString.Length;
+#endif
+        charBuffer[charsWritten++] = '.';
+        remainder = Math.Abs(remainder);
+        do
+        {
+            var digit = Math.DivRem(remainder * 10, denominator, out remainder);
+            
+            charBuffer[charsWritten++] = (char)(digit + '0');
+            if (remainder == 0)
+            {
+                if ((numberHandling & JsonNumberHandling.WriteAsString) == 0)
+                {
+                    writer.WriteRawValue(charBuffer.Slice(0, charsWritten), true);
+                }
+                else
+                {
+                    writer.WriteStringValue(charBuffer.Slice(0, charsWritten));
+                }
+
+                return;
+            }
+        } while (charsWritten < bufferSize);
+
+        // failed to format the value as a decimal number
+
+        // note: the following code is equivalent to the string interpolation:
+        // writer.WriteStringValue($"{numerator}/{denominator}");
+#if NET
+        numerator.TryFormat(charBuffer, out var numeratorLength);
+        charBuffer[numeratorLength] = '/';
+        denominator.TryFormat(charBuffer[(numeratorLength + 1)..], out var denominatorLength);
+        writer.WriteStringValue(charBuffer[..(numeratorLength + denominatorLength + 1)]);
+#else
+        ReadOnlySpan<char> numeratorSpan = numerator.ToString().AsSpan();
+        numeratorSpan.CopyTo(charBuffer);
+        charBuffer[numeratorSpan.Length] = '/';
+        ReadOnlySpan<char> denominatorSpan = denominator.ToString().AsSpan();
+        denominatorSpan.CopyTo(charBuffer.Slice(numeratorSpan.Length + 1));
+        writer.WriteStringValue(charBuffer.Slice(0, numeratorSpan.Length + denominatorSpan.Length + 1));
+#endif
+    }
+}
diff --git a/UnitsNet.Tests/AffineQuantityExtensionsTest.cs b/UnitsNet.Tests/AffineQuantityExtensionsTest.cs
index 5da68a2030..9c8a091454 100644
--- a/UnitsNet.Tests/AffineQuantityExtensionsTest.cs
+++ b/UnitsNet.Tests/AffineQuantityExtensionsTest.cs
@@ -1,14 +1,15 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
+using UnitsNet.Tests.CustomQuantities;
+
 namespace UnitsNet.Tests;
 
 public class AffineQuantityExtensionsTest
 {
     [Theory]
     [InlineData(25.0, 25.0, 0.1, true)] // Equal values
-    // [InlineData(25.0, 25.1, 0.1, true)] // Within tolerance (but fails due to rounding)
-    [InlineData(25.0, 25.1, 0.10001, true)] // Within tolerance
+    [InlineData(25.0, 25.1, 0.1, true)] // Within tolerance
     [InlineData(25.0, 25.2, 0.1, false)] // Outside tolerance
     [InlineData(25.0, 25.0, 0.0, true)] // Zero tolerance, equal values
     [InlineData(25.0, 25.1, 0.0, false)] // Zero tolerance, different values
@@ -56,8 +57,7 @@ public void Equals_Temperature_TemperatureDelta_ThrowsArgumentOutOfRangeExceptio
 
     [Theory]
     [InlineData(25.0, 25.0, 0.1, true)] // Equal values
-    // [InlineData(25.0, 25.1, 0.1, true)] // Within tolerance (but fails due to rounding)
-    [InlineData(25.0, 25.1, 0.10001, true)] // Within tolerance
+    [InlineData(25.0, 25.1, 0.1, true)] // Within tolerance
     [InlineData(25.0, 25.2, 0.1, false)] // Outside tolerance
     [InlineData(25.0, 25.0, 0.0, true)] // Zero tolerance, equal values
     [InlineData(25.0, 25.1, 0.0, false)] // Zero tolerance, different values
@@ -76,7 +76,7 @@ public void Equals_Temperature_IQuantity(double value1, double value2, double to
     public void Equals_Temperature_IQuantity_WithDifferentType_ReturnsFalse()
     {
         var temperature1 = Temperature.FromDegreesCelsius(25.0);
-        IQuantity length = Length.From(1, LengthUnit.Meter);
+        IQuantity length = Length.From(QuantityValue.One, LengthUnit.Meter);
         var tolerance = TemperatureDelta.FromDegreesCelsius(1);
 
         var result = temperature1.Equals(length, tolerance);
@@ -90,11 +90,27 @@ public void Equals_WithNullOther_ReturnsFalse()
         var quantity = Temperature.FromDegreesCelsius(25.0);
         var tolerance = TemperatureDelta.FromDegreesCelsius(25.0);
 
+        // since 'other' is not a reference type, this ends up calling the IQuantity overload
         var result = quantity.Equals(null, tolerance);
 
         Assert.False(result);
     }
 
+#if NET
+    [Fact]
+    public void Equals_TQuantity_WithNullOther_ReturnsFalse()
+    {
+        var quantity = new ClassOfAffineQuantity(2, ClassOfAffineQuantityUnit.ATon);
+        var tolerance = new ClassOfLinearQuantity(0.1m, ClassOfLinearQuantityUnit.Some);
+        ClassOfAffineQuantity? nullOther = null;
+
+        // since 'other' is a reference type, this is calling the TQuantity overload
+        var result = quantity.Equals(nullOther, tolerance);
+
+        Assert.False(result);
+    }
+#endif
+
     [Fact]
     public void Equals_ThrowsArgumentOutOfRangeException_ForNegativeTolerance()
     {
@@ -111,11 +127,12 @@ public void Equals_ThrowsArgumentOutOfRangeException_ForNegativeTolerance()
     [InlineData(new[] { 25.0 }, 25.0)] // Single value
     public void Average_Temperature(double[] values, double expectedAverage)
     {
+        var expectedAverageValue = QuantityValue.FromDoubleRounded(expectedAverage);
         Temperature[] temperatures = Array.ConvertAll(values, value => Temperature.FromDegreesCelsius(value));
 
         Temperature result = temperatures.Average();
-        
-        Assert.Equal(expectedAverage, result.Value);
+
+        Assert.Equal(expectedAverageValue, result.Value);
         Assert.Equal(TemperatureUnit.DegreeCelsius, result.Unit);
     }
 
@@ -156,11 +173,12 @@ public void Average_Temperature_ThrowsInvalidOperationException_ForEmptyCollecti
     [InlineData(new[] { 77.0, 86.0, 95.0 }, TemperatureUnit.DegreeFahrenheit, 86.0)] // Average in Fahrenheit
     public void Average_Temperature_WithUnit(double[] values, TemperatureUnit unit, double expectedAverage)
     {
+        var expectedAverageValue = QuantityValue.FromDoubleRounded(expectedAverage);
         Temperature[] temperatures = Array.ConvertAll(values, value => Temperature.From(value, unit));
 
         Temperature result = temperatures.Average(unit);
 
-        Assert.Equal(expectedAverage, result.Value);
+        Assert.Equal(expectedAverageValue, result.Value);
         Assert.Equal(unit, result.Unit);
     }
     
diff --git a/UnitsNet.Tests/AlphabeticalOrderer.cs b/UnitsNet.Tests/AlphabeticalOrderer.cs
index bb7754a431..e12d433d80 100644
--- a/UnitsNet.Tests/AlphabeticalOrderer.cs
+++ b/UnitsNet.Tests/AlphabeticalOrderer.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Collections.Generic;
diff --git a/UnitsNet.Tests/AssemblyAttributeTests.cs b/UnitsNet.Tests/AssemblyAttributeTests.cs
index 8e11543c88..7a69f18f4a 100644
--- a/UnitsNet.Tests/AssemblyAttributeTests.cs
+++ b/UnitsNet.Tests/AssemblyAttributeTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/AssertEx.cs b/UnitsNet.Tests/AssertEx.cs
index d052adfeec..57a0e3083a 100644
--- a/UnitsNet.Tests/AssertEx.cs
+++ b/UnitsNet.Tests/AssertEx.cs
@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Numerics;
 using Xunit;
 
 namespace UnitsNet.Tests
@@ -8,21 +9,45 @@ namespace UnitsNet.Tests
     /// </summary>
     public static class AssertEx
     {
-        public static void EqualTolerance(double expected, double actual, double tolerance, ComparisonType comparisonType = ComparisonType.Relative)
+        public static void EqualTolerance(QuantityValue expected, QuantityValue actual, QuantityValue tolerance, ComparisonType comparisonType = ComparisonType.Relative)
         {
             if (comparisonType == ComparisonType.Relative)
             {
-                bool areEqual = Comparison.EqualsRelative(expected, actual, tolerance);
-
-                double difference = Math.Abs(expected - actual);
-                double relativeDifference = difference / expected;
-
-                Assert.True( areEqual, $"Values are not equal within relative tolerance: {tolerance:P4}\nExpected: {expected}\nActual: {actual}\nDiff: {relativeDifference:P4}" );
+                var areEqual = Comparison.EqualsRelative(expected, actual, tolerance);
+                if (areEqual)
+                {
+                    return;
+                }
+                
+                var difference = QuantityValue.Abs(expected - actual);
+                QuantityValue relativeDifference = difference / expected;
+                // Assert.True(areEqual, $"Values are not equal within relative tolerance: {tolerance:P4}\nExpected: {expected}\nActual: {actual}\nDiff: {relativeDifference:P4}");
+                
+                int percentDecimals;
+                if (tolerance >= QuantityValue.One)
+                {
+                    percentDecimals = 0;
+                }
+                else
+                {
+                    (BigInteger _, BigInteger denominator) = tolerance;
+                    percentDecimals = Math.Max(0, denominator.ToString().Length - 3);
+                }
+                
+                var toleranceFormat = "P" + percentDecimals;
+                var differenceFormat = "P" + (percentDecimals + 1);
+                var userMessage = $"Values are not equal within relative tolerance: {tolerance.ToString(toleranceFormat)}\nExpected: {expected}\nActual: {actual}\nDiff: {relativeDifference.ToString(differenceFormat)}";
+                Assert.True(areEqual, userMessage);
             }
             else if (comparisonType == ComparisonType.Absolute)
             {
-                bool areEqual = Comparison.EqualsAbsolute(expected, actual, tolerance);
-                Assert.True( areEqual, $"Values are not equal within absolute tolerance: {tolerance}\nExpected: {expected}\nActual: {actual}\nDiff: {actual - expected:e}" );
+                var areEqual = Comparison.EqualsAbsolute(expected, actual, tolerance);
+                if (areEqual)
+                {
+                    return;
+                }
+                
+                Assert.True(areEqual, $"Values are not equal within absolute tolerance: {tolerance}\nExpected: {expected}\nActual: {actual}\nDiff: {actual - expected:e}" );
             }
         }
     }
diff --git a/UnitsNet.Tests/BaseDimensionsTests.cs b/UnitsNet.Tests/BaseDimensionsTests.cs
index bd034c7ac4..cd8de46b3b 100644
--- a/UnitsNet.Tests/BaseDimensionsTests.cs
+++ b/UnitsNet.Tests/BaseDimensionsTests.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Xunit;
 
diff --git a/UnitsNet.Tests/BaseUnitsTests.cs b/UnitsNet.Tests/BaseUnitsTests.cs
index fc43e0e895..0382432f6a 100644
--- a/UnitsNet.Tests/BaseUnitsTests.cs
+++ b/UnitsNet.Tests/BaseUnitsTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CompiledLambdasTests.cs b/UnitsNet.Tests/CompiledLambdasTests.cs
index 2e6630de54..d3fe00d736 100644
--- a/UnitsNet.Tests/CompiledLambdasTests.cs
+++ b/UnitsNet.Tests/CompiledLambdasTests.cs
@@ -1,7 +1,8 @@
-using Xunit;
+using Xunit;
 
 namespace UnitsNet.Tests
 {
+    #if COMPILED_LAMBDAS_ENABLED
     public class CompiledLambdasTests
     {
         [Theory]
@@ -91,4 +92,5 @@ public void GreaterThanOrEqualReturnsExpectedValues<TLeft, TRight>(TLeft left, T
             Assert.Equal(expected, CompiledLambdas.GreaterThanOrEqual(left, right));
         }
     }
+    #endif
 }
diff --git a/UnitsNet.Tests/ConversionExpressionTests.cs b/UnitsNet.Tests/ConversionExpressionTests.cs
new file mode 100644
index 0000000000..9f6c66d3b1
--- /dev/null
+++ b/UnitsNet.Tests/ConversionExpressionTests.cs
@@ -0,0 +1,469 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Globalization;
+using System.Text;
+using Xunit;
+
+namespace UnitsNet.Tests
+{
+    public class ConversionExpressionTest
+    {
+        [Fact]
+        public void Constructor_WithAllParameters_ShouldInitializeProperties()
+        {
+            // Arrange
+            QuantityValue coefficient = 2.0m;
+            ConvertValueDelegate? nestedFunction = value => value * 2;
+            var exponent = 3;
+            QuantityValue constantTerm = 5.0m;
+            // Act
+            var conversionExpression = new ConversionExpression(coefficient, nestedFunction, exponent, constantTerm);
+            // Assert
+            Assert.Equal(coefficient, conversionExpression.Coefficient);
+            Assert.Equal(exponent, conversionExpression.Exponent);
+            Assert.Equal(nestedFunction, conversionExpression.NestedFunction);
+            Assert.Equal(constantTerm, conversionExpression.ConstantTerm);
+        }
+
+        [Fact]
+        public void Constructor_WithCoefficientAndConstantTerm_ShouldInitializeProperties()
+        {
+            // Arrange
+            QuantityValue coefficient = 2.0m;
+            QuantityValue constantTerm = 5.0m;
+            // Act
+            var conversionExpression = new ConversionExpression(coefficient, constantTerm);
+            // Assert
+            Assert.Equal(coefficient, conversionExpression.Coefficient);
+            Assert.Null(conversionExpression.NestedFunction);
+            Assert.Equal(1, conversionExpression.Exponent);
+            Assert.Equal(constantTerm, conversionExpression.ConstantTerm);
+        }
+
+        [Fact]
+        public void Constructor_WithCoefficient_ShouldInitializeProperties()
+        {
+            // Arrange
+            QuantityValue coefficient = 2.0m;
+            // Act
+            var conversionExpression = new ConversionExpression(coefficient);
+            // Assert
+            Assert.Equal(coefficient, conversionExpression.Coefficient);
+            Assert.Null(conversionExpression.NestedFunction);
+            Assert.Equal(1, conversionExpression.Exponent);
+            Assert.True(QuantityValue.IsZero(conversionExpression.ConstantTerm));
+        }
+
+        [Fact]
+        public void ImplicitConversion_FromQuantityValue_ShouldInitializeTheCoefficient()
+        {
+            // Arrange
+            QuantityValue quantityValue = 2.0m;
+            // Act
+            ConversionExpression conversionExpression = quantityValue;
+            // Assert
+            Assert.Equal(quantityValue, conversionExpression.Coefficient);
+            Assert.Null(conversionExpression.NestedFunction);
+            Assert.Equal(1, conversionExpression.Exponent);
+            Assert.True(QuantityValue.IsZero(conversionExpression.ConstantTerm));
+        }
+
+        [Fact]
+        public void ImplicitConversion_FromInt_ShouldInitializeTheCoefficient()
+        {
+            // Arrange
+            var value = 2;
+            // Act
+            ConversionExpression conversionExpression = value;
+            // Assert
+            Assert.Equal(value, conversionExpression.Coefficient);
+            Assert.Null(conversionExpression.NestedFunction);
+            Assert.Equal(1, conversionExpression.Exponent);
+            Assert.True(QuantityValue.IsZero(conversionExpression.ConstantTerm));
+        }
+
+        [Fact]
+        public void ImplicitConversion_FromLong_ShouldInitializeTheCoefficient()
+        {
+            // Arrange
+            long value = 2;
+            // Act
+            ConversionExpression conversionExpression = value;
+            // Assert
+            Assert.Equal(value, conversionExpression.Coefficient);
+            Assert.Null(conversionExpression.NestedFunction);
+            Assert.Equal(1, conversionExpression.Exponent);
+            Assert.True(QuantityValue.IsZero(conversionExpression.ConstantTerm));
+        }
+
+        [Theory]
+        [InlineData(0, 1, 0, 0, 0)]
+        [InlineData(1, 1, 2, 3, 5)] // x + 2 with x = 3 -> 3 + 2 = 5
+        [InlineData(2, 2, 3, 4, 35)] // 2x^2 + 3 with x = 4 -> 2 * 16 + 3 = 35
+        [InlineData(-1, 1, -2, -3, 1)] // -x - 2 with x = -3 -> 3 - 2 = 1
+        public void Evaluate_Value_ReturnsExpectedResult(double coefficient, int exponent, double constantTerm, double value, double expected)
+        {
+            var expression = new ConversionExpression(coefficient, null, exponent, constantTerm);
+            QuantityValue result = expression.Evaluate(value);
+            Assert.Equal(QuantityValue.FromDoubleRounded(expected), result);
+        }
+
+        [Theory]
+        [InlineData(0, 1, 0, 0, 0)]
+        [InlineData(1, 1, 2, 3, 0.5)] // g(x) + 2 with x = 3 -> -1.5 + 2 = 0.5
+        [InlineData(2, 2, 3, 4, 11)] // 2 * g(x)^2 + 3 with x = 4 -> 2 * (-2)^2 + 3 = 11
+        [InlineData(-1, 1, -2, -3, -3.5)] // -g(x) - 2 with x = -3 -> -1.5 - 2 = -3.5
+        public void Evaluate_Value_WithNestedFunction_ReturnsExpectedResult(double coefficient, int exponent, double constantTerm, double value,
+            double expected)
+        {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            var expression = new ConversionExpression(coefficient, quantityValue => -quantityValue / 2, exponent, constantTerm);
+            QuantityValue result = expression.Evaluate(value);
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Theory]
+        [InlineData(0, 1, 0)]
+        [InlineData(1, 1, 0)]
+        [InlineData(10, 1, 0)]
+        [InlineData(-1, 1, 0)]
+        [InlineData(-10, 1, 0)]
+        [InlineData(0, 1, 5)]
+        [InlineData(1, 1, 5)]
+        [InlineData(10, 1, 5)]
+        [InlineData(-1, 1, 5)]
+        [InlineData(-10, 1, 5)]
+        [InlineData(0, 1, -5)]
+        [InlineData(1, 1, -5)]
+        [InlineData(10, 1, -5)]
+        [InlineData(-10, 1, -5)]
+        [InlineData(-1, 1, -5)]
+        [InlineData(0, -1, 0)]
+        [InlineData(1, -1, 0)]
+        [InlineData(10, -1, 0)]
+        [InlineData(-1, -1, 0)]
+        [InlineData(-10, -1, 0)]
+        [InlineData(0, -1, 5)]
+        [InlineData(1, -1, 5)]
+        [InlineData(10, -1, 5)]
+        [InlineData(-10, -1, 5)]
+        [InlineData(-1, -1, 5)]
+        [InlineData(0, -1, -5)]
+        [InlineData(1, -1, -5)]
+        [InlineData(10, -1, -5)]
+        [InlineData(-1, -1, -5)]
+        [InlineData(-10, -1, -5)]
+        [InlineData(0, 2, 0)]
+        [InlineData(1, 2, 0)]
+        [InlineData(10, 2, 0)]
+        [InlineData(-10, 2, 0)]
+        [InlineData(-1, 2, 0)]
+        [InlineData(0, 2, 5)]
+        [InlineData(1, 2, 5)]
+        [InlineData(10, 2, 5)]
+        [InlineData(-1, 2, 5)]
+        [InlineData(-10, 2, 5)]
+        [InlineData(0, 2, -5)]
+        [InlineData(1, 2, -5)]
+        [InlineData(10, 2, -5)]
+        [InlineData(-1, 2, -5)]
+        [InlineData(-10, 2, -5)]
+        [InlineData(0, -2, 0)]
+        [InlineData(1, -2, 0)]
+        [InlineData(10, -2, 0)]
+        [InlineData(-1, -2, 0)]
+        [InlineData(-10, -2, 0)]
+        [InlineData(0, -2, 5)]
+        [InlineData(1, -2, 5)]
+        [InlineData(10, -2, 5)]
+        [InlineData(-1, -2, 5)]
+        [InlineData(-10, -2, 5)]
+        [InlineData(0, -2, -5)]
+        [InlineData(1, -2, -5)]
+        [InlineData(10, -2, -5)]
+        [InlineData(-1, -2, -5)]
+        [InlineData(-10, -2, -5)]
+        public void ExpressionWithoutNestedFunction_ConvertsTo_ConvertValueDelegate(double coefficient, int exponent, double constantTerm)
+        {
+            // Arrange
+            var expression = new ConversionExpression(coefficient, null, exponent, constantTerm);
+            QuantityValue expectedValueFor10 = expression.Evaluate(QuantityValue.Ten);
+            // Act
+            ConvertValueDelegate conversionFunction = expression;
+            // Assert
+            Assert.Equal(expectedValueFor10, conversionFunction(QuantityValue.Ten));
+        }
+
+        [Theory]
+        [InlineData(0, 1, 0)]
+        [InlineData(1, 1, 0)]
+        [InlineData(10, 1, 0)]
+        [InlineData(-1, 1, 0)]
+        [InlineData(-10, 1, 0)]
+        [InlineData(0, 1, 5)]
+        [InlineData(1, 1, 5)]
+        [InlineData(10, 1, 5)]
+        [InlineData(-1, 1, 5)]
+        [InlineData(-10, 1, 5)]
+        [InlineData(0, 1, -5)]
+        [InlineData(1, 1, -5)]
+        [InlineData(10, 1, -5)]
+        [InlineData(-10, 1, -5)]
+        [InlineData(-1, 1, -5)]
+        [InlineData(0, -1, 0)]
+        [InlineData(1, -1, 0)]
+        [InlineData(10, -1, 0)]
+        [InlineData(-1, -1, 0)]
+        [InlineData(-10, -1, 0)]
+        [InlineData(0, -1, 5)]
+        [InlineData(1, -1, 5)]
+        [InlineData(10, -1, 5)]
+        [InlineData(-10, -1, 5)]
+        [InlineData(-1, -1, 5)]
+        [InlineData(0, -1, -5)]
+        [InlineData(1, -1, -5)]
+        [InlineData(10, -1, -5)]
+        [InlineData(-1, -1, -5)]
+        [InlineData(-10, -1, -5)]
+        [InlineData(0, 2, 0)]
+        [InlineData(1, 2, 0)]
+        [InlineData(10, 2, 0)]
+        [InlineData(-10, 2, 0)]
+        [InlineData(-1, 2, 0)]
+        [InlineData(0, 2, 5)]
+        [InlineData(1, 2, 5)]
+        [InlineData(10, 2, 5)]
+        [InlineData(-1, 2, 5)]
+        [InlineData(-10, 2, 5)]
+        [InlineData(0, 2, -5)]
+        [InlineData(1, 2, -5)]
+        [InlineData(10, 2, -5)]
+        [InlineData(-1, 2, -5)]
+        [InlineData(-10, 2, -5)]
+        [InlineData(0, -2, 0)]
+        [InlineData(1, -2, 0)]
+        [InlineData(10, -2, 0)]
+        [InlineData(-1, -2, 0)]
+        [InlineData(-10, -2, 0)]
+        [InlineData(0, -2, 5)]
+        [InlineData(1, -2, 5)]
+        [InlineData(10, -2, 5)]
+        [InlineData(-1, -2, 5)]
+        [InlineData(-10, -2, 5)]
+        [InlineData(0, -2, -5)]
+        [InlineData(1, -2, -5)]
+        [InlineData(10, -2, -5)]
+        [InlineData(-1, -2, -5)]
+        [InlineData(-10, -2, -5)]
+        public void ExpressionWithNestedFunction_ConvertsTo_ConvertValueDelegate(double coefficient, int exponent, double constantTerm)
+        {
+            // Arrange
+            var expression = new ConversionExpression(coefficient, quantityValue => -quantityValue / 2, exponent, constantTerm);
+            QuantityValue expectedValueFor10 = expression.Evaluate(QuantityValue.Ten);
+            // Act
+            ConvertValueDelegate conversionFunction = expression;
+            // Assert
+            Assert.Equal(expectedValueFor10, conversionFunction(QuantityValue.Ten));
+        }
+
+        [Theory]
+        [InlineData(0, 1, 0, 0, 1, 0)]
+        [InlineData(10, 1, 0, 2, 1, 0)]
+        [InlineData(0.1, 2, 0, 4, -1, 0)]
+        [InlineData(-1, 1, -2, -3, -2, 0)]
+        [InlineData(10, 1, 5, 2, 1, 0)]
+        [InlineData(2, 1, 0, 3, 1, 10)]
+        [InlineData(1, 1, 2, 3, 1, 10)]
+        [InlineData(2, 2, 3, 4, -1, 38)]
+        [InlineData(-1, 1, -2, -3, -2, -14)]
+        [InlineData(0, -1, 0, 0, 1, 0)]
+        [InlineData(10, -1, 0, 2, 1, 0)]
+        [InlineData(0.1, -2, 0, 4, -1, 0)]
+        [InlineData(-1, -1, -2, -3, -2, 0)]
+        [InlineData(10, -1, 5, 2, 1, 0)]
+        [InlineData(2, -1, 0, 3, 1, 10)]
+        [InlineData(1, -1, 2, 3, 1, 10)]
+        [InlineData(2, -2, 3, 4, -1, 38)]
+        [InlineData(-1, -1, -2, -3, -2, -14)]
+        public void Evaluate_IntermediateExpression_ReturnsExpectedResult(decimal coefficient1, int exponent1, decimal constantTerm1,
+            decimal coefficient2, int exponent2, decimal constantTerm2)
+        {
+            // Arrange
+            var expression1 = new ConversionExpression(coefficient1, null, exponent1, constantTerm1);
+            var expression2 = new ConversionExpression(coefficient2, null, exponent2, constantTerm2);
+            QuantityValue expectedValueFor10 = expression1.Evaluate(expression2.Evaluate(QuantityValue.Ten));
+            // Act
+            ConversionExpression compositeExpression = expression1.Evaluate(expression2);
+            // Assert
+            if (expression1.Exponent == 1 || expression1.Exponent == -1 && expression2.ConstantTerm == QuantityValue.Zero)
+            {
+                Assert.Null(compositeExpression.NestedFunction);
+            }
+            else
+            {
+                Assert.NotNull(compositeExpression.NestedFunction);
+            }
+
+            Assert.Equal(expectedValueFor10, compositeExpression.Evaluate(QuantityValue.Ten));
+        }
+
+        [Theory]
+        [InlineData(0, 1, 0, 0, 1, 0)]
+        [InlineData(10, 1, 0, 2, 1, 0)]
+        [InlineData(0.1, 2, 0, 4, -1, 0)]
+        [InlineData(-1, 1, -2, -3, -2, 0)]
+        [InlineData(10, 1, 5, 2, 1, 0)]
+        [InlineData(2, 1, 0, 3, 1, 10)]
+        [InlineData(1, 1, 2, 3, 1, 10)]
+        [InlineData(2, 2, 3, 4, -1, 38)]
+        [InlineData(-1, 1, -2, -3, -2, -14)]
+        [InlineData(0, -1, 0, 0, 1, 0)]
+        [InlineData(10, -1, 0, 2, 1, 0)]
+        [InlineData(0.1, -2, 0, 4, -1, 0)]
+        [InlineData(-1, -1, -2, -3, -2, 0)]
+        [InlineData(10, -1, 5, 2, 1, 0)]
+        [InlineData(2, -1, 0, 3, 1, 10)]
+        [InlineData(1, -1, 2, 3, 1, 10)]
+        [InlineData(2, -2, 3, 4, -1, 38)]
+        [InlineData(-1, -1, -2, -3, -2, -14)]
+        public void EvaluateAndReduce_IntermediateExpression_ReturnsExpectedResult(decimal coefficient1, int exponent1, decimal constantTerm1,
+            decimal coefficient2, int exponent2, decimal constantTerm2)
+        {
+            // Arrange
+            var expression1 = new ConversionExpression(coefficient1, null, exponent1, constantTerm1);
+            var expression2 = new ConversionExpression(coefficient2, null, exponent2, constantTerm2);
+            QuantityValue expectedValueFor10 = expression1.Evaluate(expression2.Evaluate(QuantityValue.Ten));
+            // Act
+            ConversionExpression compositeExpression = expression1.Evaluate(expression2, true);
+            // Assert
+            if (expression1.Exponent == 1 || expression1.Exponent == -1 && expression2.ConstantTerm == QuantityValue.Zero)
+            {
+                Assert.Null(compositeExpression.NestedFunction);
+            }
+            else
+            {
+                Assert.NotNull(compositeExpression.NestedFunction);
+            }
+
+            Assert.True(QuantityValue.IsCanonical(compositeExpression.Coefficient));
+            Assert.Equal(expectedValueFor10, compositeExpression.Evaluate(QuantityValue.Ten));
+        }
+
+        [Theory]
+        [InlineData(0, 1, 0, 0, 1, 0)]
+        [InlineData(10, 1, 0, 2, 1, 0)]
+        [InlineData(0.1, 2, 0, 4, -1, 0)]
+        [InlineData(-1, 1, -2, -3, -2, 0)]
+        [InlineData(10, 1, 5, 2, 1, 0)]
+        [InlineData(2, 1, 0, 3, 1, 10)]
+        [InlineData(1, 1, 2, 3, 1, 10)]
+        [InlineData(2, 2, 3, 4, -1, 38)]
+        [InlineData(-1, 1, -2, -3, -2, -14)]
+        [InlineData(0, -1, 0, 0, 1, 0)]
+        [InlineData(10, -1, 0, 2, 1, 0)]
+        [InlineData(0.1, -2, 0, 4, -1, 0)]
+        [InlineData(-1, -1, -2, -3, -2, 0)]
+        [InlineData(10, -1, 5, 2, 1, 0)]
+        [InlineData(2, -1, 0, 3, 1, 10)]
+        [InlineData(1, -1, 2, 3, 1, 10)]
+        [InlineData(2, -2, 3, 4, -1, 38)]
+        [InlineData(-1, -1, -2, -3, -2, -14)]
+        public void Evaluate_IntermediateExpression_WithNestedFunctions_ReturnsExpectedResult(decimal coefficient1, int exponent1, decimal constantTerm1,
+            decimal coefficient2, int exponent2, decimal constantTerm2)
+        {
+            // Arrange
+            var expression1 = new ConversionExpression(coefficient1, QuantityValue.Abs, exponent1, constantTerm1);
+            var expression2 = new ConversionExpression(coefficient2, QuantityValue.Inverse, exponent2, constantTerm2);
+            QuantityValue expectedValueFor10 = expression1.Evaluate(expression2.Evaluate(QuantityValue.Ten));
+            // Act
+            ConversionExpression compositeExpression = expression1.Evaluate(expression2);
+            // Assert
+            Assert.Equal(expression1.Coefficient, compositeExpression.Coefficient);
+            Assert.NotNull(compositeExpression.NestedFunction);
+            Assert.NotEqual(expression1.NestedFunction, compositeExpression.NestedFunction);
+            Assert.NotEqual(expression2.NestedFunction, compositeExpression.NestedFunction);
+            Assert.Equal(expression1.Exponent, compositeExpression.Exponent);
+            Assert.Equal(expression1.ConstantTerm, compositeExpression.ConstantTerm);
+            Assert.Equal(expectedValueFor10, compositeExpression.Evaluate(QuantityValue.Ten));
+        }
+
+        [Theory]
+        [InlineData(1, 1, 2)]
+        [InlineData(2, 2, 3)]
+        [InlineData(0, 1, 0)]
+        [InlineData(-1, 1, -2)]
+        public void Negate_ReturnsExpectedResult(double coefficient, int exponent, double constantTerm)
+        {
+            // Arrange
+            var expression = new ConversionExpression(coefficient, null, exponent, constantTerm);
+            QuantityValue expectedCoefficient = -expression.Coefficient;
+            QuantityValue expectedConstantTerm = -expression.ConstantTerm;
+            // Act
+            ConversionExpression negatedExpression = -expression;
+            // Assert
+            Assert.Equal(expectedCoefficient, negatedExpression.Coefficient);
+            Assert.Null(negatedExpression.NestedFunction);
+            Assert.Equal(expression.Exponent, negatedExpression.Exponent);
+            Assert.Equal(expectedConstantTerm, negatedExpression.ConstantTerm);
+        }
+
+        [Theory]
+        [InlineData(0, 1, 0, "0 * x")]
+        [InlineData(1, 1, 2, "x + 2")]
+        [InlineData(2, 2, 3, "2 * x^2 + 3")]
+        [InlineData(-1, 1, -2, "-x - 2")]
+        [InlineData(-2.5, 1, -2, "-2.5 * x - 2")]
+        [InlineData(2, -1, 2, "2 / x + 2")]
+        [InlineData(2, -2, 2, "2 * x^-2 + 2")]
+        public void ToString_ReturnsExpectedResult(double coefficient, int exponent, double constantTerm, string expected)
+        {
+            var expression = new ConversionExpression(coefficient, null, exponent, constantTerm);
+            var result = expression.ToString();
+            Assert.Equal(expected, result);
+        }
+
+        [Fact]
+        public void ToString_WithNonInvariantCurrentCulture_UsesInvariantNotation()
+        {
+            CultureInfo previousCulture = CultureInfo.CurrentCulture;
+            try
+            {
+                CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("nb-NO");
+                var expression = new ConversionExpression(-2.5, null, 1, -2.5);
+
+                Assert.Equal("-2.5 * x - 2.5", expression.ToString());
+            }
+            finally
+            {
+                CultureInfo.CurrentCulture = previousCulture;
+            }
+        }
+
+        [Fact]
+        public void PrintMembers_ShouldReturnCorrectString()
+        {
+            var conversionExpression = new ConversionExpression(coefficient: 1);
+            var stringBuilder = new StringBuilder();
+
+            var success = conversionExpression.GetType().GetMethod("PrintMembers", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)!
+                .Invoke(conversionExpression, [stringBuilder]);
+
+            Assert.Equal(true, success);
+            Assert.Equal("Coefficient = 1, Exponent = 1, ConstantTerm = 0", stringBuilder.ToString());
+        }
+
+        [Fact]
+        public void PrintMembers_WithNestedFunction_ShouldReturnCorrectString()
+        {
+            var conversionExpression = new ConversionExpression(coefficient: 1, QuantityValue.Inverse);
+            var stringBuilder = new StringBuilder();
+
+            var success = conversionExpression.GetType().GetMethod("PrintMembers", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)!
+                .Invoke(conversionExpression, [stringBuilder]);
+
+            Assert.Equal(true, success);
+            Assert.Equal("Coefficient = 1, Exponent = 1, ConstantTerm = 0, NestedFunction = Inverse", stringBuilder.ToString());
+        }
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/AbsorbedDoseOfIonizingRadiationTests.cs b/UnitsNet.Tests/CustomCode/AbsorbedDoseOfIonizingRadiationTests.cs
index f0e5b14ceb..701f21fddf 100644
--- a/UnitsNet.Tests/CustomCode/AbsorbedDoseOfIonizingRadiationTests.cs
+++ b/UnitsNet.Tests/CustomCode/AbsorbedDoseOfIonizingRadiationTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -41,5 +41,18 @@ public class AbsorbedDoseOfIonizingRadiationTests : AbsorbedDoseOfIonizingRadiat
         protected override double PicograysInOneGray => 1E+12;
         protected override double RadsInOneGray => 100;
         protected override double TeragraysInOneGray => 1E-12;
+
+        [Fact]
+        public void AbsorbedDoseOfIonizingRadiationTimesAreaEqualsDoseAreaProduct()
+        {
+            AbsorbedDoseOfIonizingRadiation dose = AbsorbedDoseOfIonizingRadiation.FromGrays(2);
+            Area area = Area.FromSquareMeters(3);
+            DoseAreaProduct expected = DoseAreaProduct.FromGraySquareMeters(6);
+
+            Assert.Equal(expected, dose * area);
+            Assert.Equal(expected, area * dose);
+            Assert.Equal(area, expected / dose);
+            Assert.Equal(dose, expected / area);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/AccelerationTests.cs b/UnitsNet.Tests/CustomCode/AccelerationTests.cs
index 898b07807b..f652519d07 100644
--- a/UnitsNet.Tests/CustomCode/AccelerationTests.cs
+++ b/UnitsNet.Tests/CustomCode/AccelerationTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
@@ -35,6 +35,13 @@ public class AccelerationTests : AccelerationTestsBase
 
         protected override double MillistandardGravityInOneMeterPerSecondSquared => 101.9716212977928;
 
+        [Fact]
+        public void AccelerationTimesAreaDensityEqualsPressure()
+        {
+            Pressure pressure = Acceleration.FromMetersPerSecondSquared(10) * AreaDensity.FromKilogramsPerSquareMeter(2);
+            Assert.Equal(Pressure.FromPascals(20), pressure);
+        }
+
         [Fact]
         public void AccelerationTimesDensityEqualsSpecificWeight()
         {
@@ -48,5 +55,12 @@ public void AccelerationTimesDuration()
             Speed speed = Acceleration.FromMetersPerSecondSquared(10) * Duration.FromSeconds(10);
             Assert.Equal(Speed.FromMetersPerSecond(100), speed);
         }
+
+        [Fact]
+        public void AccelerationTimesLinearDensityEqualsForcePerLength()
+        {
+            ForcePerLength forcePerLength = Acceleration.FromMetersPerSecondSquared(10) * LinearDensity.FromKilogramsPerMeter(2);
+            Assert.Equal(ForcePerLength.FromNewtonsPerMeter(20), forcePerLength);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/AmountOfSubstanceTests.cs b/UnitsNet.Tests/CustomCode/AmountOfSubstanceTests.cs
index 205db5cd83..f37adae915 100644
--- a/UnitsNet.Tests/CustomCode/AmountOfSubstanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/AmountOfSubstanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/AmplitudeRatioTests.cs b/UnitsNet.Tests/CustomCode/AmplitudeRatioTests.cs
index a9123f08af..56714f1578 100644
--- a/UnitsNet.Tests/CustomCode/AmplitudeRatioTests.cs
+++ b/UnitsNet.Tests/CustomCode/AmplitudeRatioTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -47,11 +47,12 @@ public void InvalidVoltage_ExpectArgumentOutOfRangeException(double voltage)
         [InlineData(1000, 60)]
         public void ExpectVoltageConvertedToAmplitudeRatioCorrectly(double voltage, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             // Amplitude ratio increases linearly by 20 dBV with power-of-10 increases of voltage.
             ElectricPotential v = ElectricPotential.FromVolts(voltage);
 
             var actual = AmplitudeRatio.FromElectricPotential(v).DecibelVolts;
-            Assert.Equal(expected, actual);
+            Assert.Equal(expectedValue, actual);
         }
 
         [Theory]
@@ -62,11 +63,12 @@ public void ExpectVoltageConvertedToAmplitudeRatioCorrectly(double voltage, doub
         [InlineData(40, 100)]
         public void ExpectAmplitudeRatioConvertedToVoltageCorrectly(double amplitudeRatio, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             // Voltage increases by powers of 10 for every 20 dBV increase in amplitude ratio.
             AmplitudeRatio ar = AmplitudeRatio.FromDecibelVolts(amplitudeRatio);
-            
+
             var actual = ar.ToElectricPotential().Volts;
-            Assert.Equal(expected, actual);
+            Assert.Equal(expectedValue, actual);
         }
 
         // http://www.maximintegrated.com/en/app-notes/index.mvp/id/808
@@ -79,9 +81,10 @@ public void ExpectAmplitudeRatioConvertedToVoltageCorrectly(double amplitudeRati
         public void AmplitudeRatioToPowerRatio_50OhmImpedance(double dBmV, double expected)
         {
             AmplitudeRatio ampRatio = AmplitudeRatio.FromDecibelMillivolts(dBmV);
-            
-            var actual = Math.Round(ampRatio.ToPowerRatio(ElectricResistance.FromOhms(50)).DecibelMilliwatts, 2);
-            Assert.Equal(expected, actual);
+
+            QuantityValue actual = ampRatio.ToPowerRatio(ElectricResistance.FromOhms(50)).DecibelMilliwatts;
+
+            AssertEx.EqualTolerance(expected, actual, 1e-2m, ComparisonType.Absolute);
         }
 
         [Theory]
@@ -92,9 +95,10 @@ public void AmplitudeRatioToPowerRatio_50OhmImpedance(double dBmV, double expect
         public void AmplitudeRatioToPowerRatio_75OhmImpedance(double dBmV, double expected)
         {
             AmplitudeRatio ampRatio = AmplitudeRatio.FromDecibelMillivolts(dBmV);
-            
-            var actual = Math.Round(ampRatio.ToPowerRatio(ElectricResistance.FromOhms(75)).DecibelMilliwatts, 2);
-            Assert.Equal(expected, actual);
+
+            QuantityValue actual = ampRatio.ToPowerRatio(ElectricResistance.FromOhms(75)).DecibelMilliwatts;
+
+            AssertEx.EqualTolerance(expected, actual, 1e-2m, ComparisonType.Absolute);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/AngleTests.cs b/UnitsNet.Tests/CustomCode/AngleTests.cs
index b886d2762f..49dfce1dbd 100644
--- a/UnitsNet.Tests/CustomCode/AngleTests.cs
+++ b/UnitsNet.Tests/CustomCode/AngleTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/AreaDensityTests.cs b/UnitsNet.Tests/CustomCode/AreaDensityTests.cs
index f9a113d705..789c9d8698 100644
--- a/UnitsNet.Tests/CustomCode/AreaDensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/AreaDensityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -34,11 +34,45 @@ public class AreaDensityTests : AreaDensityTestsBase
 
         protected override double MilligramsPerSquareMeterInOneKilogramPerSquareMeter => 1000000;
 
+        /// <summary>https://www.kylesconverter.com/area-density/kilograms-per-square-meter-to-pounds-per-square-foot</summary>
+        protected override double PoundsPerSquareFootInOneKilogramPerSquareMeter => 0.20481614362252172;
+
+        /// <summary>https://www.kylesconverter.com/area-density/grams-per-square-meter-to-pounds-per-thousand-square-feet</summary>
+        protected override double PoundsPerThousandSquareFeetInOneKilogramPerSquareMeter => 204.81614362252172;
+
+        [Fact]
+        public void AreaDensityDividedByDensityEqualsLength()
+        {
+            Length length = AreaDensity.FromKilogramsPerSquareMeter(20) / Density.FromKilogramsPerCubicMeter(2);
+            Assert.Equal(Length.FromMeters(10), length);
+        }
+
+        [Fact]
+        public void AreaDensityDividedByLengthEqualsDensity()
+        {
+            Density density = AreaDensity.FromKilogramsPerSquareMeter(20) / Length.FromMeters(2);
+            Assert.Equal(Density.FromKilogramsPerCubicMeter(10), density);
+        }
+
+        [Fact]
+        public void AreaDensityTimesAccelerationEqualsPressure()
+        {
+            Pressure pressure = AreaDensity.FromKilogramsPerSquareMeter(10) * Acceleration.FromMetersPerSecondSquared(2);
+            Assert.Equal(Pressure.FromPascals(20), pressure);
+        }
+
         [Fact]
         public void AreaDensityTimesAreaEqualsMass()
         {
             Mass massOfOneA4Paper = AreaDensity.FromGramsPerSquareMeter(120) * Area.FromSquareCentimeters(625);
-            Assert.Equal(7.5, massOfOneA4Paper.Grams);
+            Assert.Equal(7.5m, massOfOneA4Paper.Grams);
+        }
+
+        [Fact]
+        public void AreaDensityTimesLengthEqualsLinearDensity()
+        {
+            LinearDensity linearDensity = AreaDensity.FromKilogramsPerSquareMeter(10) * Length.FromMeters(2);
+            Assert.Equal(LinearDensity.FromKilogramsPerMeter(20), linearDensity);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/AreaMomentOfInertiaTests.cs b/UnitsNet.Tests/CustomCode/AreaMomentOfInertiaTests.cs
index e43027813d..abafeb3aff 100644
--- a/UnitsNet.Tests/CustomCode/AreaMomentOfInertiaTests.cs
+++ b/UnitsNet.Tests/CustomCode/AreaMomentOfInertiaTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -46,5 +46,12 @@ public void AreaMomentOfInertiaDividedByLengthEqualsVolume()
             Volume volume = AreaMomentOfInertia.FromMetersToTheFourth(20) / Length.FromMeters(10);
             Assert.Equal(Volume.FromCubicMeters(2), volume);
         }
+
+        [Fact]
+        public void AreaMomentOfInertiaDividedByAreaEqualsArea()
+        {
+            Area area = AreaMomentOfInertia.FromMetersToTheFourth(20) / Area.FromSquareMeters(10);
+            Assert.Equal(Area.FromSquareMeters(2), area);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/AreaPerLengthTests.cs b/UnitsNet.Tests/CustomCode/AreaPerLengthTests.cs
new file mode 100644
index 0000000000..87ef089d59
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/AreaPerLengthTests.cs
@@ -0,0 +1,40 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using Xunit;
+
+namespace UnitsNet.Tests
+{
+    public class AreaPerLengthTests : AreaPerLengthTestsBase
+    {
+        // Sanity checked against area-per-length conversion tables:
+        // - Cognite PROSPER units: https://docs.cognite.com/cdf/integration/guides/simulators/connectors/prosper/prosper_units
+        // - Nucor Skyline technical product manual: https://www.nucorskyline.com/file%20library/document%20library/english/brochures/product_manual_en.pdf
+
+        protected override double SquareMetersPerMeterInOneSquareMeterPerMeter => 1;
+
+        protected override double SquareCentimetersPerMeterInOneSquareMeterPerMeter => 1E4;
+
+        protected override double SquareMillimetersPerMeterInOneSquareMeterPerMeter => 1E6;
+
+        protected override double SquareInchesPerFootInOneSquareMeterPerMeter => 472.44094488188976;
+
+        protected override double SquareInchesPerInchInOneSquareMeterPerMeter => 39.370078740157481;
+
+        protected override double SquareFeetPerFootInOneSquareMeterPerMeter => 3.2808398950131234;
+
+        [Fact]
+        public void AreaPerLengthTimesLengthEqualsArea()
+        {
+            Area area = AreaPerLength.FromSquareMillimetersPerMeter(500) * Length.FromMeters(10);
+            Assert.Equal(5000, area.SquareMillimeters);
+        }
+
+        [Fact]
+        public void LengthTimesAreaPerLengthEqualsArea()
+        {
+            Area area = Length.FromFeet(20) * AreaPerLength.FromSquareInchesPerFoot(3);
+            Assert.Equal(60, area.SquareInches, 12);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/AreaTests.cs b/UnitsNet.Tests/CustomCode/AreaTests.cs
index df6a6dbc62..efa1def2c3 100644
--- a/UnitsNet.Tests/CustomCode/AreaTests.cs
+++ b/UnitsNet.Tests/CustomCode/AreaTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using UnitsNet.Units;
@@ -73,9 +73,9 @@ public void AreaFromCircleDiameterCalculatedCorrectly(double diameterMeters, dou
         {
             Length diameter = Length.FromMeters(diameterMeters);
 
-            double actual = Area.FromCircleDiameter(diameter).SquareMeters;
+            QuantityValue actual = Area.FromCircleDiameter(diameter).SquareMeters;
 
-            Assert.Equal(expected, actual);
+            AssertEx.EqualTolerance(expected, actual, SquareMetersTolerance);
         }
 
         [Theory]
@@ -87,9 +87,9 @@ public void AreaFromCircleRadiusCalculatedCorrectly(double radiusMeters, double
         {
             Length radius = Length.FromMeters(radiusMeters);
 
-            double actual = Area.FromCircleRadius(radius).SquareMeters;
+            QuantityValue actual = Area.FromCircleRadius(radius).SquareMeters;
 
-            Assert.Equal(expected, actual);
+            AssertEx.EqualTolerance(expected, actual, SquareMetersTolerance);
         }
 
         [Fact]
@@ -110,7 +110,7 @@ public void Constructor_UnitSystemSI_AssignsSIUnit()
         public void As_GivenSIUnitSystem_ReturnsSIValue()
         {
             var squareInches = new Area(2.0, AreaUnit.SquareInch);
-            Assert.Equal(0.00129032, squareInches.As(UnitSystem.SI));
+            Assert.Equal(0.00129032m, squareInches.As(UnitSystem.SI));
         }
 
         [Fact]
@@ -120,7 +120,7 @@ public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity()
 
             var inSI = squareInches.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(0.00129032, inSI.Value);
+            Assert.Equal(0.00129032m, inSI.Value);
             Assert.Equal(AreaUnit.SquareMeter, inSI.Unit);
         }
 
@@ -132,16 +132,17 @@ public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity()
         [InlineData(2.0, 0.5)]
         public void InverseReturnsReciprocalArea(double value, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var area = new Area(value, AreaUnit.SquareMeter);
             var inverseArea = area.Inverse();
-            Assert.Equal(expected, inverseArea.InverseSquareMeters);
+            Assert.Equal(expectedValue, inverseArea.InverseSquareMeters);
         }
 
         [Fact]
         public void AreaTimesReciprocalAreaEqualsRatio()
         {
             Ratio ratio = Area.FromSquareMeters(0.5) * ReciprocalArea.FromInverseSquareMeters(10);
-            Assert.Equal(5.0, ratio.Value);
+            Assert.Equal(5.0m, ratio.Value);
         }
 
         [Fact]
@@ -199,5 +200,12 @@ public void AreaDividedByReciprocalLengthEqualsVolume()
             Volume volume = Area.FromSquareMeters(20) / ReciprocalLength.FromInverseMeters(5);
             Assert.Equal(Volume.FromCubicMeters(4), volume);
         }
+
+        [Fact]
+        public void AreaTimesAreaEqualsAreaMomentOfInertia()
+        {
+            AreaMomentOfInertia areaMomentOfInertia = Area.FromSquareMeters(3) * Area.FromSquareMeters(4);
+            Assert.Equal(AreaMomentOfInertia.FromMetersToTheFourth(12), areaMomentOfInertia);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/BitRateTests.cs b/UnitsNet.Tests/CustomCode/BitRateTests.cs
index 8a7f25e800..a065a749f6 100644
--- a/UnitsNet.Tests/CustomCode/BitRateTests.cs
+++ b/UnitsNet.Tests/CustomCode/BitRateTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -22,6 +22,7 @@
 
 
 using System;
+using Xunit;
 
 namespace UnitsNet.Tests.CustomCode
 {
@@ -72,5 +73,37 @@ public class BitRateTests : BitRateTestsBase
         protected override double ExbibitsPerSecondInOneBitPerSecond => 8.67361738E-19;
         protected override double ExbibytesPerSecondInOneBitPerSecond => 1.0842021724855E-19;
         protected override double ExbioctetsPerSecondInOneBitPerSecond => 1.0842021724855E-19;
+
+        [Fact]
+        public void BitRateTimesDurationEqualsInformation()
+        {
+            Information information = BitRate.FromKilobitsPerSecond(10) * Duration.FromSeconds(3);
+
+            Assert.Equal(30000, information.Bits);
+        }
+
+        [Fact]
+        public void DurationTimesBitRateEqualsInformation()
+        {
+            Information information = Duration.FromMilliseconds(500) * BitRate.FromKilobitsPerSecond(10);
+
+            Assert.Equal(5000, information.Bits);
+        }
+
+        [Fact]
+        public void BitRateDividedByFrequencyEqualsInformation()
+        {
+            Information information = BitRate.FromKilobitsPerSecond(16) / Frequency.FromHertz(2);
+
+            Assert.Equal(8000, information.Bits);
+        }
+
+        [Fact]
+        public void BitRateDividedByInformationEqualsFrequency()
+        {
+            Frequency frequency = BitRate.FromKilobitsPerSecond(16) / Information.FromKilobytes(1);
+
+            Assert.Equal(2, frequency.Hertz);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/BrakeSpecificFuelConsumptionTests.cs b/UnitsNet.Tests/CustomCode/BrakeSpecificFuelConsumptionTests.cs
index 95f6bbeb38..3375cf5191 100644
--- a/UnitsNet.Tests/CustomCode/BrakeSpecificFuelConsumptionTests.cs
+++ b/UnitsNet.Tests/CustomCode/BrakeSpecificFuelConsumptionTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 
diff --git a/UnitsNet.Tests/CustomCode/CoefficientOfThermalExpansionTests.cs b/UnitsNet.Tests/CustomCode/CoefficientOfThermalExpansionTests.cs
index e6a4aaceff..01a5990ec1 100644
--- a/UnitsNet.Tests/CustomCode/CoefficientOfThermalExpansionTests.cs
+++ b/UnitsNet.Tests/CustomCode/CoefficientOfThermalExpansionTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/CompressibilityTests.cs b/UnitsNet.Tests/CustomCode/CompressibilityTests.cs
index 9f67b1223c..20b487a5c8 100644
--- a/UnitsNet.Tests/CustomCode/CompressibilityTests.cs
+++ b/UnitsNet.Tests/CustomCode/CompressibilityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -18,19 +18,65 @@
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
+using UnitsNet.Units;
+using Xunit;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class CompressibilityTests : CompressibilityTestsBase
     {
-        // Override properties in base class here
-
         protected override double InversePascalsInOneInversePascal => 1;
-        protected override double InverseMillibarsInOneInversePascal => 1e-2;
-        protected override double InverseKilopascalsInOneInversePascal => 1e-3;
-        protected override double InverseMegapascalsInOneInversePascal => 1e-6;
-        protected override double InverseBarsInOneInversePascal => 1e-5;
-        protected override double InversePoundsForcePerSquareInchInOneInversePascal => 1.450377377302092151542e-4;
-        protected override double InverseAtmospheresInOneInversePascal => 9.86923266716013e-6;
+        protected override double InverseMillibarsInOneInversePascal => 100;
+        protected override double InverseKilopascalsInOneInversePascal => 1e3;
+        protected override double InverseMegapascalsInOneInversePascal => 1e6;
+        protected override double InverseBarsInOneInversePascal => 1e5;
+        protected override double InversePoundsForcePerSquareInchInOneInversePascal => 6.894757293168361e3;
+        protected override double InverseAtmospheresInOneInversePascal => 101325;
+
+        [Fact]
+        public void InverseKilopascalToInversePoundForcePerSquareInch()
+        {
+            Compressibility compressibility = Compressibility.FromInverseKilopascals(1);
+
+            // 1 psi = 6.894757293168361 kPa, so 1 kPa^-1 = 6.894757293168361 psi^-1.
+            AssertEx.EqualTolerance(6.894757293168361, compressibility.InversePoundsForcePerSquareInch, 1e-12);
+        }
+
+        [Fact]
+        public void InversePoundForcePerSquareInchToInverseKilopascal()
+        {
+            Compressibility compressibility = Compressibility.FromInversePoundsForcePerSquareInch(1);
+
+            // 1 psi = 6.894757293168361 kPa, so 1 psi^-1 = 0.14503773773020923 kPa^-1.
+            AssertEx.EqualTolerance(0.14503773773020923, compressibility.InverseKilopascals, 1e-12);
+        }
+
+        [Theory]
+        [InlineData(CompressibilityUnit.InverseMillibar, 100)]
+        [InlineData(CompressibilityUnit.InverseKilopascal, 1e3)]
+        [InlineData(CompressibilityUnit.InverseMegapascal, 1e6)]
+        [InlineData(CompressibilityUnit.InverseBar, 1e5)]
+        [InlineData(CompressibilityUnit.InverseAtmosphere, 101325)]
+        [InlineData(CompressibilityUnit.InversePoundForcePerSquareInch, 6.894757293168361e3)]
+        public void OneInversePascalEqualsPressureFactorInInversePressureUnit(CompressibilityUnit unit, double expected)
+        {
+            Compressibility compressibility = Compressibility.FromInversePascals(1);
+
+            // If 1 target pressure unit equals N pascals, then 1 Pa^-1 equals N target-unit^-1.
+            AssertEx.EqualTolerance(expected, compressibility.As(unit), 1e-12);
+        }
+
+        [Fact]
+        public void CompressibilityTimesPressureEqualsRatio()
+        {
+            Compressibility compressibility = Compressibility.FromInversePascals(2);
+            Pressure pressure = Pressure.FromPascals(3);
+            Ratio expected = Ratio.FromDecimalFractions(6);
+
+            Assert.Equal(expected, compressibility * pressure);
+            Assert.Equal(expected, pressure * compressibility);
+            Assert.Equal(pressure, expected / compressibility);
+            Assert.Equal(compressibility, expected / pressure);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/DensityTests.cs b/UnitsNet.Tests/CustomCode/DensityTests.cs
index 178e5043cb..00ee525c1b 100644
--- a/UnitsNet.Tests/CustomCode/DensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/DensityTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
@@ -161,6 +161,13 @@ public void DensityTimesAreaEqualsLinearDensity()
             Assert.Equal(20, linearDensity.GramsPerCentimeter);
         }
 
+        [Fact]
+        public void DensityTimesLengthEqualsAreaDensity()
+        {
+            AreaDensity areaDensity = Density.FromKilogramsPerCubicMeter(10) * Length.FromMeters(2);
+            Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(20), areaDensity);
+        }
+
         [Fact]
         public static void DensityTimesVolumeConcentrationEqualsMassConcentration()
         {
diff --git a/UnitsNet.Tests/CustomCode/DoseAreaProductTests.cs b/UnitsNet.Tests/CustomCode/DoseAreaProductTests.cs
index c0cb0095bf..bd9347dc56 100644
--- a/UnitsNet.Tests/CustomCode/DoseAreaProductTests.cs
+++ b/UnitsNet.Tests/CustomCode/DoseAreaProductTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/DurationTests.cs b/UnitsNet.Tests/CustomCode/DurationTests.cs
index 9753a43986..fa4b20a7a6 100644
--- a/UnitsNet.Tests/CustomCode/DurationTests.cs
+++ b/UnitsNet.Tests/CustomCode/DurationTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -242,5 +242,13 @@ public void DurationTimesForceChangeRate()
             Force force = Duration.FromSeconds(10) * ForceChangeRate.FromNewtonsPerSecond(100);
             Assert.Equal(Force.FromNewtons(1000), force);
         }
+
+        [Fact]
+        public void DurationInverseEqualsFrequency()
+        {
+            Frequency frequency = Duration.FromMilliseconds(250).Inverse();
+
+            Assert.Equal(4, frequency.Hertz);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/DynamicViscosityTests.cs b/UnitsNet.Tests/CustomCode/DynamicViscosityTests.cs
index d275a19597..2a1a8ba6bb 100644
--- a/UnitsNet.Tests/CustomCode/DynamicViscosityTests.cs
+++ b/UnitsNet.Tests/CustomCode/DynamicViscosityTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 
diff --git a/UnitsNet.Tests/CustomCode/ElectricAdmittanceTests.cs b/UnitsNet.Tests/CustomCode/ElectricAdmittanceTests.cs
index 14a6982cf3..b7f9872ae7 100644
--- a/UnitsNet.Tests/CustomCode/ElectricAdmittanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricAdmittanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/ElectricApparentEnergyTests.cs b/UnitsNet.Tests/CustomCode/ElectricApparentEnergyTests.cs
index 33e85f4386..4e16e3f69e 100644
--- a/UnitsNet.Tests/CustomCode/ElectricApparentEnergyTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricApparentEnergyTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/ElectricApparentPowerTests.cs b/UnitsNet.Tests/CustomCode/ElectricApparentPowerTests.cs
index b683366814..74b2916a92 100644
--- a/UnitsNet.Tests/CustomCode/ElectricApparentPowerTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricApparentPowerTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -34,5 +34,18 @@ public class ElectricApparentPowerTests : ElectricApparentPowerTestsBase
         protected override double MicrovoltamperesInOneVoltampere => 1E6;
 
         protected override double MillivoltamperesInOneVoltampere => 1E3;
+
+        [Fact]
+        public void ElectricApparentPowerTimesDurationEqualsElectricApparentEnergy()
+        {
+            ElectricApparentPower apparentPower = ElectricApparentPower.FromVoltamperes(2);
+            Duration duration = Duration.FromHours(3);
+            ElectricApparentEnergy expected = ElectricApparentEnergy.FromVoltampereHours(6);
+
+            Assert.Equal(expected, apparentPower * duration);
+            Assert.Equal(expected, duration * apparentPower);
+            Assert.Equal(duration, expected / apparentPower);
+            Assert.Equal(apparentPower, expected / duration);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricCapacitanceTests.cs b/UnitsNet.Tests/CustomCode/ElectricCapacitanceTests.cs
index e314a96a86..2cfe26b63f 100644
--- a/UnitsNet.Tests/CustomCode/ElectricCapacitanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricCapacitanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -36,5 +36,18 @@ public class ElectricCapacitanceTests : ElectricCapacitanceTestsBase
         protected override double KilofaradsInOneFarad => 1e-3;
 
         protected override double MegafaradsInOneFarad => 1e-6;
+
+        [Fact]
+        public void ElectricCapacitanceTimesElectricPotentialEqualsElectricCharge()
+        {
+            ElectricCapacitance capacitance = ElectricCapacitance.FromFarads(2);
+            ElectricPotential potential = ElectricPotential.FromVolts(3);
+            ElectricCharge expected = ElectricCharge.FromCoulombs(6);
+
+            Assert.Equal(expected, capacitance * potential);
+            Assert.Equal(expected, potential * capacitance);
+            Assert.Equal(potential, expected / capacitance);
+            Assert.Equal(capacitance, expected / potential);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricChargeDensityTests.cs b/UnitsNet.Tests/CustomCode/ElectricChargeDensityTests.cs
index 28315edf4e..18db88254c 100644
--- a/UnitsNet.Tests/CustomCode/ElectricChargeDensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricChargeDensityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -28,5 +28,18 @@ namespace UnitsNet.Tests.CustomCode
     public class ElectricChargeDensityTests : ElectricChargeDensityTestsBase
     {
         protected override double CoulombsPerCubicMeterInOneCoulombPerCubicMeter => 1;
+
+        [Fact]
+        public void ElectricChargeDensityTimesVolumeEqualsElectricCharge()
+        {
+            ElectricChargeDensity chargeDensity = ElectricChargeDensity.FromCoulombsPerCubicMeter(2);
+            Volume volume = Volume.FromCubicMeters(3);
+            ElectricCharge expected = ElectricCharge.FromCoulombs(6);
+
+            Assert.Equal(expected, chargeDensity * volume);
+            Assert.Equal(expected, volume * chargeDensity);
+            Assert.Equal(volume, expected / chargeDensity);
+            Assert.Equal(chargeDensity, expected / volume);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricChargeTests.cs b/UnitsNet.Tests/CustomCode/ElectricChargeTests.cs
index 5551c60b7a..78b95bdf7c 100644
--- a/UnitsNet.Tests/CustomCode/ElectricChargeTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricChargeTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
diff --git a/UnitsNet.Tests/CustomCode/ElectricConductanceTests.cs b/UnitsNet.Tests/CustomCode/ElectricConductanceTests.cs
index 7071ebb470..c38e031984 100644
--- a/UnitsNet.Tests/CustomCode/ElectricConductanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricConductanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/ElectricConductivityTests.cs b/UnitsNet.Tests/CustomCode/ElectricConductivityTests.cs
index d9eb6687c1..ac088e1cdf 100644
--- a/UnitsNet.Tests/CustomCode/ElectricConductivityTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricConductivityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -44,10 +44,11 @@ public class ElectricConductivityTests : ElectricConductivityTestsBase
         [InlineData( 2.0, 0.5 )]
         public static void InverseTest( double value, double expected )
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var unit = new ElectricConductivity( value, ElectricConductivityUnit.SiemensPerMeter );
             var inverse = unit.Inverse();
 
-            Assert.Equal( expected, inverse.OhmMeters );
+            Assert.Equal(expectedValue, inverse.OhmMeters );
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricCurrentDensityTests.cs b/UnitsNet.Tests/CustomCode/ElectricCurrentDensityTests.cs
index 507bf52ff3..306734858d 100644
--- a/UnitsNet.Tests/CustomCode/ElectricCurrentDensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricCurrentDensityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -30,5 +30,18 @@ public class ElectricCurrentDensityTests : ElectricCurrentDensityTestsBase
         protected override double AmperesPerSquareMeterInOneAmperePerSquareMeter => 1;
         protected override double AmperesPerSquareInchInOneAmperePerSquareMeter => 6.4516e-4;
         protected override double AmperesPerSquareFootInOneAmperePerSquareMeter => 9.290304e-2;
+
+        [Fact]
+        public void ElectricCurrentDensityTimesAreaEqualsElectricCurrent()
+        {
+            ElectricCurrentDensity currentDensity = ElectricCurrentDensity.FromAmperesPerSquareMeter(2);
+            Area area = Area.FromSquareMeters(3);
+            ElectricCurrent expected = ElectricCurrent.FromAmperes(6);
+
+            Assert.Equal(expected, currentDensity * area);
+            Assert.Equal(expected, area * currentDensity);
+            Assert.Equal(area, expected / currentDensity);
+            Assert.Equal(currentDensity, expected / area);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs b/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs
index b93535f7d7..2ff15dea93 100644
--- a/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/ElectricCurrentTests.cs b/UnitsNet.Tests/CustomCode/ElectricCurrentTests.cs
index bd89eb62d0..e67ed8ead6 100644
--- a/UnitsNet.Tests/CustomCode/ElectricCurrentTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricCurrentTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/ElectricFieldTests.cs b/UnitsNet.Tests/CustomCode/ElectricFieldTests.cs
index 092e041fac..5080b8ccf9 100644
--- a/UnitsNet.Tests/CustomCode/ElectricFieldTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricFieldTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -28,5 +28,18 @@ namespace UnitsNet.Tests.CustomCode
     public class ElectricFieldTests : ElectricFieldTestsBase
     {
         protected override double VoltsPerMeterInOneVoltPerMeter => 1;
+
+        [Fact]
+        public void ElectricFieldTimesLengthEqualsElectricPotential()
+        {
+            ElectricField electricField = ElectricField.FromVoltsPerMeter(2);
+            Length length = Length.FromMeters(3);
+            ElectricPotential expected = ElectricPotential.FromVolts(6);
+
+            Assert.Equal(expected, electricField * length);
+            Assert.Equal(expected, length * electricField);
+            Assert.Equal(length, expected / electricField);
+            Assert.Equal(electricField, expected / length);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricImpedanceTests.cs b/UnitsNet.Tests/CustomCode/ElectricImpedanceTests.cs
index d84c5bcd66..13732b2ae4 100644
--- a/UnitsNet.Tests/CustomCode/ElectricImpedanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricImpedanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/ElectricInductanceTests.cs b/UnitsNet.Tests/CustomCode/ElectricInductanceTests.cs
index d423db50b7..df2a050e8c 100644
--- a/UnitsNet.Tests/CustomCode/ElectricInductanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricInductanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/ElectricPotentialChangeRateTests.cs b/UnitsNet.Tests/CustomCode/ElectricPotentialChangeRateTests.cs
index f34bd831d3..3995cc5f5a 100644
--- a/UnitsNet.Tests/CustomCode/ElectricPotentialChangeRateTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricPotentialChangeRateTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -43,5 +43,18 @@ public class ElectricPotentialChangeRateTests : ElectricPotentialChangeRateTests
         protected override double VoltsPerMicrosecondInOneVoltPerSecond => 1e-06;
         protected override double VoltsPerMinuteInOneVoltPerSecond => 60;
         protected override double VoltsPerSecondInOneVoltPerSecond => 1;
+
+        [Fact]
+        public void ElectricPotentialChangeRateTimesDurationEqualsElectricPotential()
+        {
+            ElectricPotentialChangeRate changeRate = ElectricPotentialChangeRate.FromVoltsPerSecond(2);
+            Duration duration = Duration.FromSeconds(3);
+            ElectricPotential expected = ElectricPotential.FromVolts(6);
+
+            Assert.Equal(expected, changeRate * duration);
+            Assert.Equal(expected, duration * changeRate);
+            Assert.Equal(duration, expected / changeRate);
+            Assert.Equal(changeRate, expected / duration);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricPotentialTests.cs b/UnitsNet.Tests/CustomCode/ElectricPotentialTests.cs
index 5c174b1829..49cdb99444 100644
--- a/UnitsNet.Tests/CustomCode/ElectricPotentialTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricPotentialTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
@@ -61,5 +61,18 @@ public void ElectricPotentialMultipliedByElectricChargeEqualsEnergy(float potent
             Energy j = ElectricPotential.FromVolts(potential) * ElectricCharge.FromCoulombs(current);
             Assert.Equal(expected, j.Joules);
         }
+
+        [Fact]
+        public void ElectricPotentialTimesElectricConductanceEqualsElectricCurrent()
+        {
+            ElectricPotential potential = ElectricPotential.FromVolts(2);
+            ElectricConductance conductance = ElectricConductance.FromSiemens(3);
+            ElectricCurrent expected = ElectricCurrent.FromAmperes(6);
+
+            Assert.Equal(expected, potential * conductance);
+            Assert.Equal(expected, conductance * potential);
+            Assert.Equal(conductance, expected / potential);
+            Assert.Equal(potential, expected / conductance);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricReactanceTests.cs b/UnitsNet.Tests/CustomCode/ElectricReactanceTests.cs
index 4d44009596..030b318243 100644
--- a/UnitsNet.Tests/CustomCode/ElectricReactanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricReactanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/ElectricReactiveEnergyTests.cs b/UnitsNet.Tests/CustomCode/ElectricReactiveEnergyTests.cs
index f1a56b6811..e2915da24d 100644
--- a/UnitsNet.Tests/CustomCode/ElectricReactiveEnergyTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricReactiveEnergyTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/ElectricReactivePowerTests.cs b/UnitsNet.Tests/CustomCode/ElectricReactivePowerTests.cs
index b05403d59a..293167758e 100644
--- a/UnitsNet.Tests/CustomCode/ElectricReactivePowerTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricReactivePowerTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -30,5 +30,18 @@ public class ElectricReactivePowerTests : ElectricReactivePowerTestsBase
         protected override double MegavoltamperesReactiveInOneVoltampereReactive => 1E-6;
 
         protected override double GigavoltamperesReactiveInOneVoltampereReactive => 1E-9;
+
+        [Fact]
+        public void ElectricReactivePowerTimesDurationEqualsElectricReactiveEnergy()
+        {
+            ElectricReactivePower reactivePower = ElectricReactivePower.FromVoltamperesReactive(2);
+            Duration duration = Duration.FromHours(3);
+            ElectricReactiveEnergy expected = ElectricReactiveEnergy.FromVoltampereReactiveHours(6);
+
+            Assert.Equal(expected, reactivePower * duration);
+            Assert.Equal(expected, duration * reactivePower);
+            Assert.Equal(duration, expected / reactivePower);
+            Assert.Equal(reactivePower, expected / duration);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricResistanceTests.cs b/UnitsNet.Tests/CustomCode/ElectricResistanceTests.cs
index b4f43a4b1c..c9bd7bb20e 100644
--- a/UnitsNet.Tests/CustomCode/ElectricResistanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricResistanceTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
diff --git a/UnitsNet.Tests/CustomCode/ElectricResistivityTests.cs b/UnitsNet.Tests/CustomCode/ElectricResistivityTests.cs
index 89e934d629..ced397d2f1 100644
--- a/UnitsNet.Tests/CustomCode/ElectricResistivityTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricResistivityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -65,10 +65,11 @@ public class ElectricResistivityTests : ElectricResistivityTestsBase
         [InlineData( 2.0, 0.5 )]
         public static void InverseTest( double value, double expected )
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var unit = new ElectricResistivity( value, ElectricResistivityUnit.OhmMeter );
             var inverse = unit.Inverse();
 
-            Assert.Equal( expected, inverse.SiemensPerMeter );
+            Assert.Equal(expectedValue, inverse.SiemensPerMeter );
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricSurfaceChargeDensityTests.cs b/UnitsNet.Tests/CustomCode/ElectricSurfaceChargeDensityTests.cs
index 5314164358..7934ca0671 100644
--- a/UnitsNet.Tests/CustomCode/ElectricSurfaceChargeDensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricSurfaceChargeDensityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -31,5 +31,18 @@ public class ElectricSurfaceChargeDensityTests : ElectricSurfaceChargeDensityTes
         protected override double CoulombsPerSquareCentimeterInOneCoulombPerSquareMeter => 1.0e-4;
 
         protected override double CoulombsPerSquareInchInOneCoulombPerSquareMeter => 6.4516e-4;
+
+        [Fact]
+        public void ElectricSurfaceChargeDensityTimesAreaEqualsElectricCharge()
+        {
+            ElectricSurfaceChargeDensity chargeDensity = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(2);
+            Area area = Area.FromSquareMeters(3);
+            ElectricCharge expected = ElectricCharge.FromCoulombs(6);
+
+            Assert.Equal(expected, chargeDensity * area);
+            Assert.Equal(expected, area * chargeDensity);
+            Assert.Equal(area, expected / chargeDensity);
+            Assert.Equal(chargeDensity, expected / area);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ElectricSusceptanceTests.cs b/UnitsNet.Tests/CustomCode/ElectricSusceptanceTests.cs
index cf3540b710..b496f3c63d 100644
--- a/UnitsNet.Tests/CustomCode/ElectricSusceptanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ElectricSusceptanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/EnergyDensityTests.cs b/UnitsNet.Tests/CustomCode/EnergyDensityTests.cs
index 854615278f..95dca2f64d 100644
--- a/UnitsNet.Tests/CustomCode/EnergyDensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/EnergyDensityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -56,7 +56,7 @@ public void CombustionEnergy()
             Energy energy = EnergyDensity.CombustionEnergy(EnergyDensity.FromKilowattHoursPerCubicMeter(9.88),
                                                            Volume.FromCubicMeters(1),
                                                            Ratio.FromDecimalFractions(0.9543));
-            Assert.Equal(9.428484, energy.KilowattHours, 5);
+            Assert.Equal(9.428484m, energy.KilowattHours);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/EnergyTests.cs b/UnitsNet.Tests/CustomCode/EnergyTests.cs
index 590fb328ec..b47fea65dc 100644
--- a/UnitsNet.Tests/CustomCode/EnergyTests.cs
+++ b/UnitsNet.Tests/CustomCode/EnergyTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -92,25 +92,25 @@ public class EnergyTests : EnergyTestsBase
         [Fact]
         public void Constructor_UnitSystemSI_AssignsSIUnit()
         {
-            var energy = new Energy(1.0, UnitSystem.SI);
+            var energy = new Energy(1, UnitSystem.SI);
             Assert.Equal(EnergyUnit.Joule, energy.Unit);
         }
 
         [Fact]
         public void As_GivenSIUnitSystem_ReturnsSIValue()
         {
-            var btus = new Energy(2.0, EnergyUnit.BritishThermalUnit);
-            Assert.Equal(2110.11170524, btus.As(UnitSystem.SI));
+            var btus = new Energy(2, EnergyUnit.BritishThermalUnit);
+            Assert.Equal(2110.11170524m, btus.As(UnitSystem.SI));
         }
 
         [Fact]
         public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity()
         {
-            var btus = new Energy(2.0, EnergyUnit.BritishThermalUnit);
+            var btus = new Energy(2, EnergyUnit.BritishThermalUnit);
 
             var inSI = btus.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(2110.11170524, inSI.Value);
+            Assert.Equal(2110.11170524m, inSI.Value);
             Assert.Equal(EnergyUnit.Joule, inSI.Unit);
         }
 
diff --git a/UnitsNet.Tests/CustomCode/EntropyTests.cs b/UnitsNet.Tests/CustomCode/EntropyTests.cs
index c6c16aea51..155e0fe28a 100644
--- a/UnitsNet.Tests/CustomCode/EntropyTests.cs
+++ b/UnitsNet.Tests/CustomCode/EntropyTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/FluidResistanceTests.cs b/UnitsNet.Tests/CustomCode/FluidResistanceTests.cs
index 998220e8e5..340022b93b 100644
--- a/UnitsNet.Tests/CustomCode/FluidResistanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/FluidResistanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -44,5 +44,18 @@ public class FluidResistanceTests : FluidResistanceTestsBase
         protected override double PascalSecondsPerLiterInOnePascalSecondPerCubicMeter => 1e-3; // Pa·s/l
         protected override double PascalSecondsPerMilliliterInOnePascalSecondPerCubicMeter => 1e-6; // Pa·s/ml
         protected override double WoodUnitsInOnePascalSecondPerCubicMeter => 1.25010625903202e-7; // WU
+
+        [Fact]
+        public void FluidResistanceTimesVolumeFlowEqualsPressure()
+        {
+            FluidResistance fluidResistance = FluidResistance.FromPascalSecondsPerCubicMeter(2);
+            VolumeFlow volumeFlow = VolumeFlow.FromCubicMetersPerSecond(3);
+            Pressure expected = Pressure.FromPascals(6);
+
+            Assert.Equal(expected, fluidResistance * volumeFlow);
+            Assert.Equal(expected, volumeFlow * fluidResistance);
+            Assert.Equal(volumeFlow, expected / fluidResistance);
+            Assert.Equal(fluidResistance, expected / volumeFlow);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs b/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs
index 4f4ead01c8..7e9e763f5a 100644
--- a/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
diff --git a/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs b/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs
index 410caf25cb..41d3435c5d 100644
--- a/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -89,5 +89,19 @@ public void ForcePerLengthTimesAreaEqualTorque()
             Torque torque = ForcePerLength.FromNewtonsPerMeter(10) * Area.FromSquareMeters(9);
             Assert.Equal(torque, Torque.FromNewtonMeters(90));
         }
+
+        [Fact]
+        public void ForcePerLengthDividedByAccelerationEqualsLinearDensity()
+        {
+            LinearDensity linearDensity = ForcePerLength.FromNewtonsPerMeter(20) / Acceleration.FromMetersPerSecondSquared(2);
+            Assert.Equal(LinearDensity.FromKilogramsPerMeter(10), linearDensity);
+        }
+
+        [Fact]
+        public void ForcePerLengthDividedByLinearDensityEqualsAcceleration()
+        {
+            Acceleration acceleration = ForcePerLength.FromNewtonsPerMeter(20) / LinearDensity.FromKilogramsPerMeter(2);
+            Assert.Equal(Acceleration.FromMetersPerSecondSquared(10), acceleration);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ForceTests.cs b/UnitsNet.Tests/CustomCode/ForceTests.cs
index 30eaf69bc4..7d5b5ae544 100644
--- a/UnitsNet.Tests/CustomCode/ForceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForceTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
@@ -10,6 +10,7 @@ public class ForceTests : ForceTestsBase
         protected override double DecanewtonsInOneNewton => 1E-1;
         protected override double DyneInOneNewton => 1E5;
 
+        protected override double GramsForceInOneNewton => 0.1019716e3;
         protected override double KilogramsForceInOneNewton => 0.1019716;
 
         protected override double KilopoundsForceInOneNewton => 0.2248089e-3;
@@ -69,6 +70,20 @@ public void ForceDividedByLengthEqualsForcePerLength()
             Assert.Equal(forcePerLength, ForcePerLength.FromNewtonsPerMeter(4));
         }
 
+        [Fact]
+        public void ForceDividedBySpecificWeightEqualsVolume()
+        {
+            Volume volume = Force.FromNewtons(200) / SpecificWeight.FromNewtonsPerCubicMeter(50);
+            Assert.Equal(Volume.FromCubicMeters(4), volume);
+        }
+
+        [Fact]
+        public void ForceDividedByVolumeEqualsSpecificWeight()
+        {
+            SpecificWeight specificWeight = Force.FromNewtons(200) / Volume.FromCubicMeters(50);
+            Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(4), specificWeight);
+        }
+
         [Fact]
         public void MassByAccelerationEqualsForce()
         {
@@ -108,7 +123,27 @@ public void ForceDividedByForceChangeRateEqualsDuration()
         public void KilogramForceDividedByNewtonEqualsStandardGravity()
         {
             var duration = Force.FromKilogramsForce(1) / Force.FromNewtons(1);
-            Assert.Equal(9.80665, duration);
+            Assert.Equal(9.80665m, duration);
+        }
+
+        [Fact]
+        public void ThousandGramsForceEqualsOneKilogramForce()
+        {
+            var force = Force.FromGramsForce(1000);
+            Assert.Equal(Force.FromKilogramsForce(1), force.ToUnit(ForceUnit.KilogramForce));
+        }
+
+        [Fact]
+        public void ForceTimesDurationEqualsImpulse()
+        {
+            Force force = Force.FromNewtons(2);
+            Duration duration = Duration.FromSeconds(3);
+            Impulse expected = Impulse.FromNewtonSeconds(6);
+
+            Assert.Equal(expected, force * duration);
+            Assert.Equal(expected, duration * force);
+            Assert.Equal(duration, expected / force);
+            Assert.Equal(force, expected / duration);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/FrequencyTests.cs b/UnitsNet.Tests/CustomCode/FrequencyTests.cs
index e5f76d64a4..012c677c04 100644
--- a/UnitsNet.Tests/CustomCode/FrequencyTests.cs
+++ b/UnitsNet.Tests/CustomCode/FrequencyTests.cs
@@ -1,7 +1,8 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
+using Xunit;
 
 namespace UnitsNet.Tests
 {
@@ -30,5 +31,13 @@ public class FrequencyTests : FrequencyTestsBase
         protected override double RadiansPerSecondInOneHertz => 2 * Math.PI;
 
         protected override double BeatsPerMinuteInOneHertz => 60;
+
+        [Fact]
+        public void FrequencyInverseEqualsDuration()
+        {
+            Duration duration = Frequency.FromHertz(2).Inverse();
+
+            Assert.Equal(0.5, duration.Seconds.ToDouble());
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/FuelEfficiencyTests.cs b/UnitsNet.Tests/CustomCode/FuelEfficiencyTests.cs
index 3e6e249af0..2868566527 100644
--- a/UnitsNet.Tests/CustomCode/FuelEfficiencyTests.cs
+++ b/UnitsNet.Tests/CustomCode/FuelEfficiencyTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/HeatFluxTests.cs b/UnitsNet.Tests/CustomCode/HeatFluxTests.cs
index 7072323f2a..ef7f6f0ac1 100644
--- a/UnitsNet.Tests/CustomCode/HeatFluxTests.cs
+++ b/UnitsNet.Tests/CustomCode/HeatFluxTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -34,16 +34,23 @@ public class HeatFluxTests : HeatFluxTestsBase
         protected override double BtusPerSecondSquareInchInOneWattPerSquareMeter => 6.11493693e-7;
         protected override double CaloriesPerSecondSquareCentimeterInOneWattPerSquareMeter => 2.390057361376673e-05;
         protected override double CentiwattsPerSquareMeterInOneWattPerSquareMeter => 1e2;
+        protected override double CentiwattsPerSquareMillimeterInOneWattPerSquareMeter => 1e-4;
         protected override double DeciwattsPerSquareMeterInOneWattPerSquareMeter => 1e1;
+        protected override double DeciwattsPerSquareMillimeterInOneWattPerSquareMeter => 1e-5;
         protected override double KilocaloriesPerSecondSquareCentimeterInOneWattPerSquareMeter => 2.390057361376673e-8;
         protected override double KilocaloriesPerHourSquareMeterInOneWattPerSquareMeter => 0.8604206500956023;
         protected override double KilowattsPerSquareMeterInOneWattPerSquareMeter => 1e-3;
+        protected override double KilowattsPerSquareMillimeterInOneWattPerSquareMeter => 1e-9;
         protected override double MicrowattsPerSquareMeterInOneWattPerSquareMeter => 1e6;
+        protected override double MicrowattsPerSquareMillimeterInOneWattPerSquareMeter => 1;
         protected override double MilliwattsPerSquareMeterInOneWattPerSquareMeter => 1e3;
+        protected override double MilliwattsPerSquareMillimeterInOneWattPerSquareMeter => 1e-3;
         protected override double NanowattsPerSquareMeterInOneWattPerSquareMeter => 1e9;
+        protected override double NanowattsPerSquareMillimeterInOneWattPerSquareMeter => 1e3;
         protected override double WattsPerSquareFootInOneWattPerSquareMeter => 9.290304e-2;
         protected override double WattsPerSquareInchInOneWattPerSquareMeter => 6.4516e-4;
         protected override double WattsPerSquareMeterInOneWattPerSquareMeter => 1;
+        protected override double WattsPerSquareMillimeterInOneWattPerSquareMeter => 1e-6;
         protected override double PoundsForcePerFootSecondInOneWattPerSquareMeter => 6.852176585679176e-2;
         protected override double PoundsPerSecondCubedInOneWattPerSquareMeter => 2.204622621848776;
 
diff --git a/UnitsNet.Tests/CustomCode/HeatTransferCoefficientTests.cs b/UnitsNet.Tests/CustomCode/HeatTransferCoefficientTests.cs
index 9cd3a2d471..a4b75e5517 100644
--- a/UnitsNet.Tests/CustomCode/HeatTransferCoefficientTests.cs
+++ b/UnitsNet.Tests/CustomCode/HeatTransferCoefficientTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -30,7 +30,21 @@ public class HeatTransferCoefficientTests : HeatTransferCoefficientTestsBase
         protected override double WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin => 1;
         protected override double WattsPerSquareMeterKelvinInOneWattPerSquareMeterKelvin => 1;
         protected override double BtusPerHourSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin => 1.7611018368230584e-1;
+        protected override double BtusPerSecondSquareInchDegreeFahrenheitInOneWattPerSquareMeterKelvin => 3.3971871852296651e-7;
         protected override double KilocaloriesPerHourSquareMeterDegreeCelsiusInOneWattPerSquareMeterKelvin => 0.8604206500956023;
         protected override double CaloriesPerHourSquareMeterDegreeCelsiusInOneWattPerSquareMeterKelvin => 860.4206500956023;
+
+        [Fact]
+        public void HeatTransferCoefficientTimesTemperatureDeltaEqualsHeatFlux()
+        {
+            HeatTransferCoefficient heatTransferCoefficient = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(2);
+            TemperatureDelta temperatureDelta = TemperatureDelta.FromKelvins(3);
+            HeatFlux expected = HeatFlux.FromWattsPerSquareMeter(6);
+
+            Assert.Equal(expected, heatTransferCoefficient * temperatureDelta);
+            Assert.Equal(expected, temperatureDelta * heatTransferCoefficient);
+            Assert.Equal(temperatureDelta, expected / heatTransferCoefficient);
+            Assert.Equal(heatTransferCoefficient, expected / temperatureDelta);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/IQuantityTests.cs b/UnitsNet.Tests/CustomCode/IQuantityTests.cs
index 2aee75a27d..eb1a376d96 100644
--- a/UnitsNet.Tests/CustomCode/IQuantityTests.cs
+++ b/UnitsNet.Tests/CustomCode/IQuantityTests.cs
@@ -1,21 +1,108 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
+using System.Numerics;
+
 namespace UnitsNet.Tests;
 
 // ReSharper disable once InconsistentNaming
 public partial class IQuantityTests
 {
     [Fact]
-    public void As_GivenWrongUnitType_ThrowsArgumentException()
+    public void As_GivenWrongUnitType_ThrowsUnitNotFoundException()
+    {
+        Assert.All(Quantity.Infos.Select(x => x.Zero), quantity => { Assert.Throws<UnitNotFoundException>(() => quantity.As(ComparisonType.Absolute)); });
+    }
+
+    [Fact]
+    public void ToUnit_GivenWrongUnitType_ThrowsUnitNotFoundException()
+    {
+        Assert.All(Quantity.Infos.Select(x => x.Zero),
+            quantity => { Assert.Throws<UnitNotFoundException>(() => quantity.ToUnit(ComparisonType.Absolute)); });
+    }
+
+    [Fact]
+    public void As_InterfaceReferences_ReturnConvertedValue()
+    {
+        var mass = Mass.FromKilograms(1);
+        IQuantity quantity = mass;
+        IQuantity<MassUnit> typedQuantity = mass;
+
+        Assert.Equal(1000, quantity.As(MassUnit.Gram));
+        Assert.Equal(1000, typedQuantity.As(MassUnit.Gram));
+    }
+
+    [Fact]
+    public void ToUnit_IQuantityFromNonBaseUnit_ReturnsConvertedQuantity()
     {
-        Assert.All(Quantity.Infos.Select(x => x.Zero), quantity => { Assert.Throws<ArgumentException>(() => quantity.As(ComparisonType.Absolute)); });
+        IQuantity quantity = Length.FromKilometers(1);
+
+        IQuantity convertedQuantity = quantity.ToUnit(LengthUnit.Centimeter);
+
+        Assert.Equal(100_000, convertedQuantity.Value);
+        Assert.Equal(LengthUnit.Centimeter, convertedQuantity.Unit);
     }
 
     [Fact]
-    public void ToUnit_GivenWrongUnitType_ThrowsArgumentException()
+    public void ToUnit_GenericConstraintWithCustomConverter_UsesProvidedConverter()
     {
-        Assert.All(Quantity.Infos.Select(x => x.Zero), quantity => { Assert.Throws<ArgumentException>(() => quantity.ToUnit(ComparisonType.Absolute)); });
+        QuantityInfo<Length, LengthUnit> customLengthInfo = Length.LengthInfo.CreateDefault(unitDefinitions =>
+            unitDefinitions.Configure(LengthUnit.Centimeter, definition => definition.WithConversionFactorFromBase(123)));
+        UnitConverter converter = UnitConverter.Create(new UnitParser([customLengthInfo]), new QuantityConverterBuildOptions());
+
+        Length convertedQuantity = ConvertToUnit(Length.FromMeters(1), LengthUnit.Centimeter, converter);
+
+        Assert.Equal(123, convertedQuantity.Value);
+        Assert.Equal(LengthUnit.Centimeter, convertedQuantity.Unit);
+
+        static TQuantity ConvertToUnit<TQuantity, TUnit>(TQuantity quantity, TUnit unit, UnitConverter unitConverter)
+            where TQuantity : IQuantity<TQuantity, TUnit>
+            where TUnit : struct, Enum
+        {
+            return quantity.ToUnit(unit, unitConverter);
+        }
+    }
+
+    [Fact]
+    public void As_GenericConstraintWithCustomConverter_UsesProvidedConverter()
+    {
+        QuantityInfo<Length, LengthUnit> customLengthInfo = Length.LengthInfo.CreateDefault(unitDefinitions =>
+            unitDefinitions.Configure(LengthUnit.Centimeter, definition => definition.WithConversionFactorFromBase(123)));
+        UnitConverter converter = UnitConverter.Create(new UnitParser([customLengthInfo]), new QuantityConverterBuildOptions());
+
+        QuantityValue convertedValue = ConvertValue(Length.FromMeters(1), LengthUnit.Centimeter, converter);
+
+        Assert.Equal(123, convertedValue.ToDouble());
+
+        static QuantityValue ConvertValue<TQuantity, TUnit>(TQuantity quantity, TUnit unit, UnitConverter unitConverter)
+            where TQuantity : IQuantity<TQuantity, TUnit>
+            where TUnit : struct, Enum
+        {
+            return quantity.As(unit, unitConverter);
+        }
+    }
+
+    [Fact]
+    public void ConversionExtensions_GenericConstraintWithNullConverter_ThrowsArgumentNullException()
+    {
+        var quantity = Length.FromMeters(1);
+
+        Assert.Throws<ArgumentNullException>(() => ConvertValue(quantity, LengthUnit.Centimeter, null!));
+        Assert.Throws<ArgumentNullException>(() => ConvertToUnit(quantity, LengthUnit.Centimeter, null!));
+
+        static QuantityValue ConvertValue<TQuantity, TUnit>(TQuantity quantity, TUnit unit, UnitConverter unitConverter)
+            where TQuantity : IQuantity<TQuantity, TUnit>
+            where TUnit : struct, Enum
+        {
+            return quantity.As(unit, unitConverter);
+        }
+
+        static TQuantity ConvertToUnit<TQuantity, TUnit>(TQuantity quantity, TUnit unit, UnitConverter unitConverter)
+            where TQuantity : IQuantity<TQuantity, TUnit>
+            where TUnit : struct, Enum
+        {
+            return quantity.ToUnit(unit, unitConverter);
+        }
     }
 
     [Fact]
@@ -59,6 +146,48 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         });
     }
 
+#if NET
+
+    [Fact]
+    public void ILinearQuantity_AdditiveIdentity_ReturnsZero()
+    {
+        AssertThat_ILinearQuantity_AdditiveIdentity_ReturnsZero<Mass>();
+    }
+
+    private static void AssertThat_ILinearQuantity_AdditiveIdentity_ReturnsZero<TQuantity>()
+        where TQuantity : ILinearQuantity<TQuantity>
+    {
+        Assert.Equal(TQuantity.Zero, TQuantity.AdditiveIdentity);
+    }
+
+    private static void AssertThat_IAffineQuantity_AdditiveIdentity_ReturnsTheZeroOffset<TQuantity, TOffset>()
+        where TQuantity : IAffineQuantity<TQuantity, TOffset>
+        where TOffset : IAdditiveIdentity<TOffset, TOffset>
+    {
+        Assert.Equal(TOffset.AdditiveIdentity, TQuantity.AdditiveIdentity);
+    }
+
+    [Fact]
+    public void ILogarithmicQuantity_MultiplicativeIdentity_ReturnsZero()
+    {
+        AssertThat_ILogarithmicQuantity_MultiplicativeIdentity_ReturnsZero<PowerRatio>();
+    }
+
+    private static void AssertThat_ILogarithmicQuantity_MultiplicativeIdentity_ReturnsZero<TQuantity>()
+        where TQuantity : ILogarithmicQuantity<TQuantity>
+    {
+        Assert.Equal(TQuantity.Zero, TQuantity.MultiplicativeIdentity);
+    }
+
+    [Fact]
+    public void IAffineQuantity_AdditiveIdentity_ReturnsTheZeroOffset()
+    {
+        AssertThat_ILinearQuantity_AdditiveIdentity_ReturnsZero<TemperatureDelta>();
+        AssertThat_IAffineQuantity_AdditiveIdentity_ReturnsTheZeroOffset<Temperature, TemperatureDelta>();
+    }
+
+#endif
+
     [Fact]
     public void GetUnitInfo_ReturnsUnitInfoForQuantityUnit()
     {
@@ -116,6 +245,78 @@ public void GetUnitInfo_MatchesUnit()
         });
     }
 
+    [Fact]
+    public void GetQuantityInfo_NonGeneric_ReturnsRegisteredQuantityInfo()
+    {
+        IQuantity quantity = new Mass(1.0, MassUnit.Kilogram);
+
+        QuantityInfo info = quantity.GetQuantityInfo();
+
+        Assert.Same(Mass.Info, info);
+    }
+
+    [Fact]
+    public void GetQuantityInfo_Typed_ReturnsRegisteredQuantityInfo()
+    {
+        IQuantity<MassUnit> quantity = new Mass(1.0, MassUnit.Kilogram);
+
+        QuantityInfo<MassUnit> info = quantity.GetQuantityInfo();
+
+        Assert.Same(Mass.Info, info);
+    }
+
+#if NET
+    [Fact]
+    public void StaticAbstract_Info_ReturnsSameAsTypedInfo()
+    {
+        // Calls IQuantity<TSelf, TUnitType>.Info via the static abstract member.
+        QuantityInfo<Mass, MassUnit> typedInfo = Mass.Info;
+        QuantityInfo<Mass, MassUnit> viaStaticAbstract = StaticAbstractAccess<Mass, MassUnit>();
+
+        Assert.Same(typedInfo, viaStaticAbstract);
+
+        static QuantityInfo<TSelf, TUnit> StaticAbstractAccess<TSelf, TUnit>()
+            where TSelf : IQuantity<TSelf, TUnit>
+            where TUnit : struct, Enum
+        {
+            return TSelf.Info;
+        }
+    }
+
+    [Fact]
+    public void StaticAbstract_Info_NonGeneric_ReturnsSameAsTypedInfo()
+    {
+        // Calls IQuantityOfType<TQuantity>.Info via the static abstract member.
+        QuantityInfo info = StaticAbstractAccess<Mass>();
+
+        Assert.Same((QuantityInfo)Mass.Info, info);
+
+        static QuantityInfo StaticAbstractAccess<TQuantity>()
+            where TQuantity : IQuantityOfType<TQuantity>
+        {
+            return TQuantity.Info;
+        }
+    }
+
+    [Fact]
+    public void ToUnit_SelfTypedGenericConstraint_ReturnsConcreteQuantity()
+    {
+        var length = Length.FromKilometers(1.5);
+
+        Length converted = ConvertToUnit<Length, LengthUnit>(length, LengthUnit.Meter);
+
+        Assert.Equal(1500, converted.Value);
+        Assert.Equal(LengthUnit.Meter, converted.Unit);
+
+        static TQuantity ConvertToUnit<TQuantity, TUnit>(TQuantity quantity, TUnit unit)
+            where TQuantity : IQuantity<TQuantity, TUnit>
+            where TUnit : struct, Enum
+        {
+            return quantity.ToUnit(unit);
+        }
+    }
+#endif
+
     [Fact]
     public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
     {
diff --git a/UnitsNet.Tests/CustomCode/IlluminanceTests.cs b/UnitsNet.Tests/CustomCode/IlluminanceTests.cs
index b7b52ffc04..7fc5074e34 100644
--- a/UnitsNet.Tests/CustomCode/IlluminanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/IlluminanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/ImpulseTests.cs b/UnitsNet.Tests/CustomCode/ImpulseTests.cs
index e42fab6b8c..d81aa52889 100644
--- a/UnitsNet.Tests/CustomCode/ImpulseTests.cs
+++ b/UnitsNet.Tests/CustomCode/ImpulseTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/InformationTests.cs b/UnitsNet.Tests/CustomCode/InformationTests.cs
index 3cd13ab2c4..7c0d9b8786 100644
--- a/UnitsNet.Tests/CustomCode/InformationTests.cs
+++ b/UnitsNet.Tests/CustomCode/InformationTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -91,5 +91,37 @@ public void OneKBHas1000Bytes()
         {
             Assert.Equal(1000, Information.FromKilobytes(1).Bytes);
         }
+
+        [Fact]
+        public void InformationDividedByDurationEqualsBitRate()
+        {
+            BitRate bitRate = Information.FromKilobytes(3) / Duration.FromSeconds(2);
+
+            Assert.Equal(12000, bitRate.BitsPerSecond);
+        }
+
+        [Fact]
+        public void InformationDividedByBitRateEqualsDuration()
+        {
+            Duration duration = Information.FromMegabits(3) / BitRate.FromMegabitsPerSecond(2);
+
+            Assert.Equal(1.5, duration.Seconds.ToDouble());
+        }
+
+        [Fact]
+        public void InformationTimesFrequencyEqualsBitRate()
+        {
+            BitRate bitRate = Information.FromBytes(100) * Frequency.FromHertz(2);
+
+            Assert.Equal(1600, bitRate.BitsPerSecond);
+        }
+
+        [Fact]
+        public void FrequencyTimesInformationEqualsBitRate()
+        {
+            BitRate bitRate = Frequency.FromHertz(2) * Information.FromBytes(100);
+
+            Assert.Equal(1600, bitRate.BitsPerSecond);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/IrradianceTests.cs b/UnitsNet.Tests/CustomCode/IrradianceTests.cs
index 31da081b01..e2b70b6b45 100644
--- a/UnitsNet.Tests/CustomCode/IrradianceTests.cs
+++ b/UnitsNet.Tests/CustomCode/IrradianceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -54,5 +54,18 @@ public class IrradianceTests : IrradianceTestsBase
         protected override double WattsPerSquareCentimeterInOneWattPerSquareMeter => 1e-4;
 
         protected override double WattsPerSquareMeterInOneWattPerSquareMeter => 1;
+
+        [Fact]
+        public void IrradianceTimesDurationEqualsIrradiation()
+        {
+            Irradiance irradiance = Irradiance.FromWattsPerSquareMeter(2);
+            Duration duration = Duration.FromSeconds(3);
+            Irradiation expected = Irradiation.FromJoulesPerSquareMeter(6);
+
+            Assert.Equal(expected, irradiance * duration);
+            Assert.Equal(expected, duration * irradiance);
+            Assert.Equal(duration, expected / irradiance);
+            Assert.Equal(irradiance, expected / duration);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/IrradiationTests.cs b/UnitsNet.Tests/CustomCode/IrradiationTests.cs
index 20665798c7..ec31d67a1f 100644
--- a/UnitsNet.Tests/CustomCode/IrradiationTests.cs
+++ b/UnitsNet.Tests/CustomCode/IrradiationTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/JerkTests.cs b/UnitsNet.Tests/CustomCode/JerkTests.cs
index 248ad2cf39..d1d7e149fa 100644
--- a/UnitsNet.Tests/CustomCode/JerkTests.cs
+++ b/UnitsNet.Tests/CustomCode/JerkTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
diff --git a/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs b/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs
index 8df2d1d623..89b72c6685 100644
--- a/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs
+++ b/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/KnownQuantities.cs b/UnitsNet.Tests/CustomCode/KnownQuantities.cs
index 641ef020e5..5b2080b388 100644
--- a/UnitsNet.Tests/CustomCode/KnownQuantities.cs
+++ b/UnitsNet.Tests/CustomCode/KnownQuantities.cs
@@ -1,4 +1,4 @@
-namespace UnitsNet.Tests
+namespace UnitsNet.Tests
 {
     public static class KnownQuantities
     {
diff --git a/UnitsNet.Tests/CustomCode/LeakRateTests.cs b/UnitsNet.Tests/CustomCode/LeakRateTests.cs
index 0e61c09773..4f77889c60 100644
--- a/UnitsNet.Tests/CustomCode/LeakRateTests.cs
+++ b/UnitsNet.Tests/CustomCode/LeakRateTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/LengthTests.FeetInches.cs b/UnitsNet.Tests/CustomCode/LengthTests.FeetInches.cs
index 4c4855b436..c7b529d8fe 100644
--- a/UnitsNet.Tests/CustomCode/LengthTests.FeetInches.cs
+++ b/UnitsNet.Tests/CustomCode/LengthTests.FeetInches.cs
@@ -1,112 +1,114 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Collections.Generic;
 using System.Globalization;
 using Xunit;
 
-namespace UnitsNet.Tests
+namespace UnitsNet.Tests;
+
+public class FeetInchesTests
 {
-    public class FeetInchesTests
+    private const string EnglishUs = "en-US";
+    private const string GermanSwitzerland = "de-CH";
+    
+    [Fact]
+    public void FeetInchesFrom()
     {
-        private static readonly CultureInfo EnglishUs = new("en-US", useUserOverride: false);
-        private static readonly CultureInfo GermanSwitzerland = new("de-CH", useUserOverride: false);
-        private const double FeetInOneMeter = 3.28084;
-        private const double InchesInOneMeter = 39.37007874;
-        private const double FeetTolerance = 1e-5;
-        private const double InchesTolerance = 1e-5;
-
-        [Fact]
-        public void FeetInchesFrom()
-        {
-            Length meter = Length.FromFeetInches(2, 3);
-            double expectedMeters = 2/FeetInOneMeter + 3/InchesInOneMeter;
-            AssertEx.EqualTolerance(expectedMeters, meter.Meters, FeetTolerance);
-        }
+        var meter = Length.FromFeetInches(2, 3);
+        Assert.Equal(0.6858m, meter.Meters);
+    }
 
-        [Fact]
-        public void FeetInchesRoundTrip()
-        {
-            Length meter = Length.FromFeetInches(2, 3);
-            FeetInches feetInches = meter.FeetInches;
-            AssertEx.EqualTolerance(2, feetInches.Feet, FeetTolerance);
-            AssertEx.EqualTolerance(3, feetInches.Inches, InchesTolerance);
-        }
+    [Fact]
+    public void FeetInchesRoundTrip()
+    {
+        var meter = Length.FromFeetInches(2, 3);
+        FeetInches feetInches = meter.FeetInches;
+        Assert.Equal(2, feetInches.Feet);
+        Assert.Equal(3, feetInches.Inches);
+    }
 
-        public static IEnumerable<object[]> ValidData => new List<object[]>
-        {
-            new object[]{"1'", 1, EnglishUs},                    // Feet only
-            new object[]{"1′", 1, EnglishUs},                    // Feet only
-            new object[]{"1,000′", 1000, EnglishUs},             // Feet only, with seperator
-            new object[]{"1e3'", 1000, EnglishUs},               // Feet only, exponential notation
-            new object[]{"1\"", 0.08333333, EnglishUs},          // Inches only
-            new object[]{"1″", 0.08333333, EnglishUs},           // Inches only
-            new object[]{"0' 1\"", 0.08333333, EnglishUs},       // Inches only
-            new object[]{"0' 1″", 0.08333333, EnglishUs},        // Inches only
-            new object[]{"0′ 1\"", 0.08333333, EnglishUs},       // Inches only
-            new object[]{"0′ 1″", 0.08333333, EnglishUs},        // Inches only
-            new object[]{"1' 1\"", 1.08333333, EnglishUs},       // Normal form
-            new object[]{"1′ 1″", 1.08333333, EnglishUs},        // Normal form
-            new object[]{" 1′ 1″ ", 1.08333333, EnglishUs},      // Normal form, requires trimming
-            new object[]{"1'1\"", 1.08333333, EnglishUs},        // Without space
-            new object[]{"1′1″", 1.08333333, EnglishUs},         // Without space
-            new object[]{"1 ft 1 in", 1.08333333, EnglishUs},
-            new object[]{"1ft 1in", 1.08333333, EnglishUs},
-            new object[]{"-1'", -1, EnglishUs},                  // Feet only
-            new object[]{"-1′", -1, EnglishUs},                  // Feet only
-            new object[]{"-1,000′", -1000, EnglishUs},           // Feet only, with seperator
-            new object[]{"-1e3'", -1000, EnglishUs},             // Feet only, exponential notation
-            new object[]{"-1\"", -0.08333333, EnglishUs},        // Inches only
-            new object[]{"-1″", -0.08333333, EnglishUs},         // Inches only
-            new object[]{"-0' 1\"", -0.08333333, EnglishUs},     // Inches only
-            new object[]{"-0' 1″", -0.08333333, EnglishUs},      // Inches only
-            new object[]{"-0′ 1\"", -0.08333333, EnglishUs},     // Inches only
-            new object[]{"-0′ 1″", -0.08333333, EnglishUs},      // Inches only
-            new object[]{"-1' 1\"", -1.08333333, EnglishUs},     // Normal form
-            new object[]{"-1′ 1″", -1.08333333, EnglishUs},      // Normal form
-            new object[]{" -1′ 1″ ", -1.08333333, EnglishUs},    // Normal form, requires trimming
-            new object[]{"-1'1\"", -1.08333333, EnglishUs},      // Without space
-            new object[]{"-1′1″", -1.08333333, EnglishUs},       // Without space
-            new object[]{"-1 ft 1 in", -1.08333333, EnglishUs},
-            new object[]{"-1ft 1in", -1.08333333, EnglishUs},
-            new object[]{"1’000′", 1000, GermanSwitzerland},             // Feet only, with seperator
-            new object[]{"1’000′ 6\"", 1000.5, GermanSwitzerland},       // Normal form, using separators for culture
-        };
+    public static IEnumerable<object[]> ValidData
+    {
+        get =>
+        [
+            ["1'", 1, EnglishUs], // Feet only
+            ["1′", 1, EnglishUs], // Feet only
+            ["1,000′", 1000, EnglishUs], // Feet only, with separator
+            ["1e3'", 1000, EnglishUs], // Feet only, exponential notation
+            ["1\"", 0.08333333, EnglishUs], // Inches only
+            ["1″", 0.08333333, EnglishUs], // Inches only
+            ["0' 1\"", 0.08333333, EnglishUs], // Inches only
+            ["0' 1″", 0.08333333, EnglishUs], // Inches only
+            ["0′ 1\"", 0.08333333, EnglishUs], // Inches only
+            ["0′ 1″", 0.08333333, EnglishUs], // Inches only
+            ["1' 1\"", 1.08333333, EnglishUs], // Normal form
+            ["1′ 1″", 1.08333333, EnglishUs], // Normal form
+            [" 1′ 1″ ", 1.08333333, EnglishUs], // Normal form, requires trimming
+            ["1'1\"", 1.08333333, EnglishUs], // Without space
+            ["1′1″", 1.08333333, EnglishUs], // Without space
+            ["1 ft 1 in", 1.08333333, EnglishUs],
+            ["1ft 1in", 1.08333333, EnglishUs],
+            ["-1'", -1, EnglishUs], // Feet only
+            ["-1′", -1, EnglishUs], // Feet only
+            ["-1,000′", -1000, EnglishUs], // Feet only, with separator
+            ["-1e3'", -1000, EnglishUs], // Feet only, exponential notation
+            ["-1\"", -0.08333333, EnglishUs], // Inches only
+            ["-1″", -0.08333333, EnglishUs], // Inches only
+            ["-0' 1\"", -0.08333333, EnglishUs], // Inches only
+            ["-0' 1″", -0.08333333, EnglishUs], // Inches only
+            ["-0′ 1\"", -0.08333333, EnglishUs], // Inches only
+            ["-0′ 1″", -0.08333333, EnglishUs], // Inches only
+            ["-1' 1\"", -1.08333333, EnglishUs], // Normal form
+            ["-1′ 1″", -1.08333333, EnglishUs], // Normal form
+            [" -1′ 1″ ", -1.08333333, EnglishUs], // Normal form, requires trimming
+            ["-1'1\"", -1.08333333, EnglishUs], // Without space
+            ["-1′1″", -1.08333333, EnglishUs], // Without space
+            ["-1 ft 1 in", -1.08333333, EnglishUs],
+            ["-1ft 1in", -1.08333333, EnglishUs],
+            ["1’000′", 1000, GermanSwitzerland], // Feet only, with separator
+            ["1’000′ 6\"", 1000.5, GermanSwitzerland] // Normal form, using separators for culture
+        ];
+    }
 
-        [Theory]
-        [MemberData(nameof(ValidData))]
-        public void TryParseFeetInches(string str, double expectedFeet, CultureInfo formatProvider)
-        {
-            Assert.True(Length.TryParseFeetInches(str, out Length result, formatProvider));
-            AssertEx.EqualTolerance(expectedFeet, result.Feet, 1e-5);
-        }
+    [Theory]
+    [MemberData(nameof(ValidData))]
+    public void TryParseFeetInches(string str, double expectedFeet, string cultureName)
+    {
+        var formatProvider = new CultureInfo(cultureName, false);
+        Assert.True(Length.TryParseFeetInches(str, out Length result, formatProvider));
+        AssertEx.EqualTolerance(expectedFeet, result.Feet, 1e-5);
+    }
 
-        public static IEnumerable<object[]> InvalidData => new List<object[]>
-        {
-            new object[]{"a", EnglishUs},        // Missing or invalid apostrophe or double prime chars
-            new object[]{"1", EnglishUs},
-            new object[]{"1`", EnglishUs},
-            new object[]{"1^", EnglishUs},
-            new object[]{"1' 1'", EnglishUs},    // Feet apostrophe twice
-            new object[]{"1′ 1′", EnglishUs},
-            new object[]{"1' 1", EnglishUs},     // No inches double prime
-            new object[]{"1′ 1", EnglishUs},
-            new object[]{"1′ 1`", EnglishUs},    // Invalid inches double prime
-            new object[]{"1' 1`", EnglishUs},
-            new object[]{"1'1'", EnglishUs},     // Same without space
-            new object[]{"1′1′", EnglishUs},
-            new object[]{"1'1", EnglishUs},
-            new object[]{"1′1", EnglishUs},
-            new object[]{"1′1`", EnglishUs},
-            new object[]{"1'1`", EnglishUs}
-        };
+    public static IEnumerable<object[]> InvalidData
+    {
+        get =>
+        [
+            ["a", EnglishUs], // Missing or invalid apostrophe or double prime chars
+            ["1", EnglishUs],
+            ["1`", EnglishUs],
+            ["1^", EnglishUs],
+            ["1' 1'", EnglishUs], // Feet apostrophe twice
+            ["1′ 1′", EnglishUs],
+            ["1' 1", EnglishUs], // No inches double prime
+            ["1′ 1", EnglishUs],
+            ["1′ 1`", EnglishUs], // Invalid inches double prime
+            ["1' 1`", EnglishUs],
+            ["1'1'", EnglishUs], // Same without space
+            ["1′1′", EnglishUs],
+            ["1'1", EnglishUs],
+            ["1′1", EnglishUs],
+            ["1′1`", EnglishUs],
+            ["1'1`", EnglishUs]
+        ];
+    }
 
-        [Theory]
-        [MemberData(nameof(InvalidData))]
-        public void TryParseFeetInches_GivenInvalidString_ReturnsFalseAndZeroOut(string str, CultureInfo formatProvider)
-        {
-            Assert.False(Length.TryParseFeetInches(str, out Length result, formatProvider));
-            Assert.Equal(Length.Zero, result);
-        }
+    [Theory]
+    [MemberData(nameof(InvalidData))]
+    public void TryParseFeetInches_GivenInvalidString_ReturnsFalseAndZeroOut(string str, string cultureName)
+    {
+        var formatProvider = new CultureInfo(cultureName, false);
+        Assert.False(Length.TryParseFeetInches(str, out Length result, formatProvider));
+        Assert.Equal(Length.Zero, result);
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/LengthTests.cs b/UnitsNet.Tests/CustomCode/LengthTests.cs
index f658ed9d87..42c6401c90 100644
--- a/UnitsNet.Tests/CustomCode/LengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/LengthTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -107,6 +107,13 @@ public void ForceTimesLengthEqualsTorque()
             Assert.Equal(torque, Torque.FromNewtonMeters(3));
         }
 
+        [Fact]
+        public void LengthTimesAreaDensityEqualsLinearDensity()
+        {
+            LinearDensity linearDensity = Length.FromMeters(2) * AreaDensity.FromKilogramsPerSquareMeter(10);
+            Assert.Equal(LinearDensity.FromKilogramsPerMeter(20), linearDensity);
+        }
+
         [Fact]
         public void LengthTimesAreaEqualsVolume()
         {
@@ -114,6 +121,13 @@ public void LengthTimesAreaEqualsVolume()
             Assert.Equal(volume, Volume.FromCubicMeters(27));
         }
 
+        [Fact]
+        public void LengthTimesDensityEqualsAreaDensity()
+        {
+            AreaDensity areaDensity = Length.FromMeters(2) * Density.FromKilogramsPerCubicMeter(10);
+            Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(20), areaDensity);
+        }
+
         [Fact]
         public void LengthTimesForceEqualsTorque()
         {
@@ -182,13 +196,13 @@ public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefaultUnit()
         [Fact]
         public void NegativeLengthToStonePoundsReturnsCorrectValues()
         {
-            var negativeLength = Length.FromInches(-1.0);
+            var negativeLength = Length.FromInches(-1);
             var feetInches = negativeLength.FeetInches;
 
             Assert.Equal(0, feetInches.Feet);
-            Assert.Equal(-1.0, feetInches.Inches);
+            Assert.Equal(-1, feetInches.Inches);
 
-            negativeLength = Length.FromInches(-25.0);
+            negativeLength = Length.FromInches(-25);
             feetInches = negativeLength.FeetInches;
 
             Assert.Equal(-2, feetInches.Feet);
@@ -198,31 +212,31 @@ public void NegativeLengthToStonePoundsReturnsCorrectValues()
         [Fact]
         public void Constructor_UnitSystemNull_ThrowsArgumentNullException()
         {
-            Assert.Throws<ArgumentNullException>(() => new Length(1.0, unitSystem: null!));
+            Assert.Throws<ArgumentNullException>(() => new Length(1, unitSystem: null!));
         }
 
         [Fact]
         public void Constructor_UnitSystemSI_AssignsSIUnit()
         {
-            var length = new Length(1.0, UnitSystem.SI);
+            var length = new Length(1, UnitSystem.SI);
             Assert.Equal(LengthUnit.Meter, length.Unit);
         }
 
         [Fact]
         public void As_GivenSIUnitSystem_ReturnsSIValue()
         {
-            var inches = new Length(2.0, LengthUnit.Inch);
-            Assert.Equal(0.0508, inches.As(UnitSystem.SI));
+            var inches = new Length(2, LengthUnit.Inch);
+            Assert.Equal(0.0508m, inches.As(UnitSystem.SI));
         }
 
         [Fact]
         public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity()
         {
-            var inches = new Length(2.0, LengthUnit.Inch);
+            var inches = new Length(2, LengthUnit.Inch);
 
             var inSI = inches.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(0.0508, inSI.Value);
+            Assert.Equal(0.0508m, inSI.Value);
             Assert.Equal(LengthUnit.Meter, inSI.Unit);
         }
 
@@ -234,10 +248,11 @@ public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity()
         [InlineData(2.0, 0.5)]
         public static void InverseReturnsReciprocalLength(double value, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var length = new Length(value, LengthUnit.Meter);
             var inverseLength = length.Inverse();
 
-            Assert.Equal(expected, inverseLength.InverseMeters);
+            Assert.Equal(expectedValue, inverseLength.InverseMeters);
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/CustomCode/LevelTests.cs b/UnitsNet.Tests/CustomCode/LevelTests.cs
index c714eb0bb9..33c7da370a 100644
--- a/UnitsNet.Tests/CustomCode/LevelTests.cs
+++ b/UnitsNet.Tests/CustomCode/LevelTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/LinearDensityTests.cs b/UnitsNet.Tests/CustomCode/LinearDensityTests.cs
index a20e7de897..08bfe00343 100644
--- a/UnitsNet.Tests/CustomCode/LinearDensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/LinearDensityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -60,6 +60,13 @@ public void LinearDensityDividedByAreaEqualsDensity()
             Assert.Equal(5, density.GramsPerCubicCentimeter);
         }
 
+        [Fact]
+        public void LinearDensityDividedByAreaDensityEqualsLength()
+        {
+            Length length = LinearDensity.FromKilogramsPerMeter(20) / AreaDensity.FromKilogramsPerSquareMeter(2);
+            Assert.Equal(Length.FromMeters(10), length);
+        }
+
         [Fact]
         public void LinearDensityDividedByDensityEqualsArea()
         {
@@ -67,6 +74,20 @@ public void LinearDensityDividedByDensityEqualsArea()
             Assert.Equal(5, area.SquareCentimeters);
         }
 
+        [Fact]
+        public void LinearDensityDividedByLengthEqualsAreaDensity()
+        {
+            AreaDensity areaDensity = LinearDensity.FromKilogramsPerMeter(20) / Length.FromMeters(2);
+            Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(10), areaDensity);
+        }
+
+        [Fact]
+        public void LinearDensityTimesAccelerationEqualsForcePerLength()
+        {
+            ForcePerLength forcePerLength = LinearDensity.FromKilogramsPerMeter(10) * Acceleration.FromMetersPerSecondSquared(2);
+            Assert.Equal(ForcePerLength.FromNewtonsPerMeter(20), forcePerLength);
+        }
+
         [Fact]
         public void LinearDensityTimesLengthEqualsMass()
         {
diff --git a/UnitsNet.Tests/CustomCode/LinearPowerDensityTests.cs b/UnitsNet.Tests/CustomCode/LinearPowerDensityTests.cs
index be222b368b..f17657b66f 100644
--- a/UnitsNet.Tests/CustomCode/LinearPowerDensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/LinearPowerDensityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -52,5 +52,18 @@ public class LinearPowerDensityTests : LinearPowerDensityTestsBase
         protected override double MilliwattsPerInchInOneWattPerMeter => 2.5400e1;
         protected override double MilliwattsPerMeterInOneWattPerMeter => 1e3;
         protected override double MilliwattsPerMillimeterInOneWattPerMeter => 1;
+
+        [Fact]
+        public void LinearPowerDensityTimesLengthEqualsPower()
+        {
+            LinearPowerDensity linearPowerDensity = LinearPowerDensity.FromWattsPerMeter(2);
+            Length length = Length.FromMeters(3);
+            Power expected = Power.FromWatts(6);
+
+            Assert.Equal(expected, linearPowerDensity * length);
+            Assert.Equal(expected, length * linearPowerDensity);
+            Assert.Equal(length, expected / linearPowerDensity);
+            Assert.Equal(linearPowerDensity, expected / length);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/LuminanceTests.cs b/UnitsNet.Tests/CustomCode/LuminanceTests.cs
index e4eb673646..f8af88aaa2 100644
--- a/UnitsNet.Tests/CustomCode/LuminanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/LuminanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/LuminosityTests.cs b/UnitsNet.Tests/CustomCode/LuminosityTests.cs
index 3a96f3e111..d657e2a89a 100644
--- a/UnitsNet.Tests/CustomCode/LuminosityTests.cs
+++ b/UnitsNet.Tests/CustomCode/LuminosityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/LuminousFluxTests.cs b/UnitsNet.Tests/CustomCode/LuminousFluxTests.cs
index bce400207e..beb28a9f5e 100644
--- a/UnitsNet.Tests/CustomCode/LuminousFluxTests.cs
+++ b/UnitsNet.Tests/CustomCode/LuminousFluxTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/LuminousIntensityTests.cs b/UnitsNet.Tests/CustomCode/LuminousIntensityTests.cs
index e7d79ac886..c747d5c566 100644
--- a/UnitsNet.Tests/CustomCode/LuminousIntensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/LuminousIntensityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -35,5 +35,18 @@ public void AllBaseQuantityUnitsAreBaseUnits()
         {
             Assert.All(LuminousIntensity.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(luminousIntensity: unitInfo.Value), unitInfo.BaseUnits));
         }
+
+        [Fact]
+        public void LuminousIntensityTimesSolidAngleEqualsLuminousFlux()
+        {
+            LuminousIntensity luminousIntensity = LuminousIntensity.FromCandela(2);
+            SolidAngle solidAngle = SolidAngle.FromSteradians(3);
+            LuminousFlux expected = LuminousFlux.FromLumens(6);
+
+            Assert.Equal(expected, luminousIntensity * solidAngle);
+            Assert.Equal(expected, solidAngle * luminousIntensity);
+            Assert.Equal(solidAngle, expected / luminousIntensity);
+            Assert.Equal(luminousIntensity, expected / solidAngle);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/MagneticFieldTests.cs b/UnitsNet.Tests/CustomCode/MagneticFieldTests.cs
index a5eee69d0d..5749b89a5b 100644
--- a/UnitsNet.Tests/CustomCode/MagneticFieldTests.cs
+++ b/UnitsNet.Tests/CustomCode/MagneticFieldTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -33,5 +33,18 @@ public class MagneticFieldTests : MagneticFieldTestsBase
         protected override double MilliteslasInOneTesla => 1e3;
         protected override double GaussesInOneTesla => 1e4;
         protected override double MilligaussesInOneTesla => 1e7;
+
+        [Fact]
+        public void MagneticFieldTimesAreaEqualsMagneticFlux()
+        {
+            MagneticField magneticField = MagneticField.FromTeslas(2);
+            Area area = Area.FromSquareMeters(3);
+            MagneticFlux expected = MagneticFlux.FromWebers(6);
+
+            Assert.Equal(expected, magneticField * area);
+            Assert.Equal(expected, area * magneticField);
+            Assert.Equal(area, expected / magneticField);
+            Assert.Equal(magneticField, expected / area);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/MagneticFluxTests.cs b/UnitsNet.Tests/CustomCode/MagneticFluxTests.cs
index a7ce8b20fa..0ba47d3a46 100644
--- a/UnitsNet.Tests/CustomCode/MagneticFluxTests.cs
+++ b/UnitsNet.Tests/CustomCode/MagneticFluxTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/MagnetizationTests.cs b/UnitsNet.Tests/CustomCode/MagnetizationTests.cs
index 90f87434b3..9f706b3feb 100644
--- a/UnitsNet.Tests/CustomCode/MagnetizationTests.cs
+++ b/UnitsNet.Tests/CustomCode/MagnetizationTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs b/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs
index cec5946fcc..c544687a61 100644
--- a/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/MassFlowTests.cs b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
index 0d51ed4e5f..0f7a701d15 100644
--- a/UnitsNet.Tests/CustomCode/MassFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/MassFluxTests.cs b/UnitsNet.Tests/CustomCode/MassFluxTests.cs
index 11c3d30a78..d4df2393e2 100644
--- a/UnitsNet.Tests/CustomCode/MassFluxTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFluxTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/MassFractionTests.cs b/UnitsNet.Tests/CustomCode/MassFractionTests.cs
index 5574d62975..a6174b0805 100644
--- a/UnitsNet.Tests/CustomCode/MassFractionTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFractionTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/MassMomentOfInertiaTests.cs b/UnitsNet.Tests/CustomCode/MassMomentOfInertiaTests.cs
index 26a24ddbf0..766181bf0a 100644
--- a/UnitsNet.Tests/CustomCode/MassMomentOfInertiaTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassMomentOfInertiaTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/MassTests.cs b/UnitsNet.Tests/CustomCode/MassTests.cs
index 5a8ce60e5d..9b4b35b50b 100644
--- a/UnitsNet.Tests/CustomCode/MassTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -141,17 +141,17 @@ public void MassDividedByLinearDensityEqualsLength()
         [Fact]
         public void NegativeMassToStonePoundsReturnsCorrectValues()
         {
-            var negativeMass = Mass.FromPounds(-1.0);
+            var negativeMass = Mass.FromPounds(-1);
             var stonePounds = negativeMass.StonePounds;
 
             Assert.Equal(0, stonePounds.Stone);
-            Assert.Equal(-1.0, stonePounds.Pounds);
+            Assert.Equal(-1, stonePounds.Pounds);
 
-            negativeMass = Mass.FromPounds(-25.0);
+            negativeMass = Mass.FromPounds(-25);
             stonePounds = negativeMass.StonePounds;
 
-            Assert.Equal(-1.0, stonePounds.Stone);
-            Assert.Equal(-11.0, stonePounds.Pounds);
+            Assert.Equal(-1, stonePounds.Stone);
+            Assert.Equal(-11, stonePounds.Pounds);
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/CustomCode/MolalityTests.cs b/UnitsNet.Tests/CustomCode/MolalityTests.cs
index 22de6472be..11772ff24f 100644
--- a/UnitsNet.Tests/CustomCode/MolalityTests.cs
+++ b/UnitsNet.Tests/CustomCode/MolalityTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/MolarEnergyTests.cs b/UnitsNet.Tests/CustomCode/MolarEnergyTests.cs
index d6a012e0a2..337621d550 100644
--- a/UnitsNet.Tests/CustomCode/MolarEnergyTests.cs
+++ b/UnitsNet.Tests/CustomCode/MolarEnergyTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/MolarEntropyTests.cs b/UnitsNet.Tests/CustomCode/MolarEntropyTests.cs
index 3021519d49..72b61379d1 100644
--- a/UnitsNet.Tests/CustomCode/MolarEntropyTests.cs
+++ b/UnitsNet.Tests/CustomCode/MolarEntropyTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/MolarFlowTests.cs b/UnitsNet.Tests/CustomCode/MolarFlowTests.cs
index 8608df7624..185f8461b5 100644
--- a/UnitsNet.Tests/CustomCode/MolarFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/MolarFlowTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/MolarMassTests.cs b/UnitsNet.Tests/CustomCode/MolarMassTests.cs
index 1e0dadbfe8..f12e8dc7e5 100644
--- a/UnitsNet.Tests/CustomCode/MolarMassTests.cs
+++ b/UnitsNet.Tests/CustomCode/MolarMassTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -41,8 +41,32 @@ public class MolarMassTests : MolarMassTestsBase
         protected override double NanogramsPerMoleTolerance => 1e-3;
         protected override double NanogramsPerMoleInOneKilogramPerMole => 1e12;
         protected override double PoundsPerMoleInOneKilogramPerMole => 2.2046226218487757;
+        protected override double PoundsPerPoundMoleInOneKilogramPerMole => 1e3;
         protected override double KilogramsPerKilomoleInOneKilogramPerMole => 1e3;
 
+        [Fact]
+        public void PoundPerPoundMoleMatchesKilogramPerKilomole()
+        {
+            // Engineering Toolbox lists air molecular weight as 28.966 in kg/kmol, g/mol, and lb/lbmol.
+            const double airMolecularWeight = 28.966;
+
+            MolarMass molarMass = MolarMass.FromPoundsPerPoundMole(airMolecularWeight);
+
+            Assert.Equal(airMolecularWeight, molarMass.KilogramsPerKilomole, precision: 12);
+        }
+
+        [Fact]
+        public void PoundPerPoundMoleIsDistinctFromPoundPerMole()
+        {
+            const double value = 1;
+
+            MolarMass poundPerPoundMole = MolarMass.FromPoundsPerPoundMole(value);
+            MolarMass poundPerMole = MolarMass.FromPoundsPerMole(value);
+
+            Assert.Equal(value, poundPerPoundMole.KilogramsPerKilomole, precision: 12);
+            Assert.True(poundPerMole.KilogramsPerKilomole > poundPerPoundMole.KilogramsPerKilomole);
+        }
+
         [Fact]
         public void MolarMassTimesAmountOfSubstanceEqualsMass()
         {
diff --git a/UnitsNet.Tests/CustomCode/MolarityTests.cs b/UnitsNet.Tests/CustomCode/MolarityTests.cs
index c65f0d483d..4c2db39c27 100644
--- a/UnitsNet.Tests/CustomCode/MolarityTests.cs
+++ b/UnitsNet.Tests/CustomCode/MolarityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/ParseTests.cs b/UnitsNet.Tests/CustomCode/ParseTests.cs
index d53a55a1f5..1bdba8c839 100644
--- a/UnitsNet.Tests/CustomCode/ParseTests.cs
+++ b/UnitsNet.Tests/CustomCode/ParseTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -26,9 +26,10 @@ public class ParseTests
         [InlineData("500,005 m", 500005)]
         public void ParseLengthToMetersUsEnglish(string s, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             CultureInfo usEnglish = CultureInfo.GetCultureInfo("en-US");
-            double actual = Length.Parse(s, usEnglish).Meters;
-            Assert.Equal(expected, actual);
+            QuantityValue actual = Length.Parse(s, usEnglish).Meters;
+            Assert.Equal(expectedValue, actual);
         }
 
         [Theory]
@@ -49,16 +50,17 @@ public void ParseLength_InvalidString_USEnglish_ThrowsException(string? s, Type
         [InlineData("5.5 m", 5.5)]
         [InlineData("500 005 m", 500005)]
         // quantity doesn't match number format
-        public void ParseWithCultureUsingSpaceAsThousandSeparators(string? s, double expected)
+        public void ParseWithCultureUsingSpaceAsThousandSeparators(string s, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var numberFormat = (NumberFormatInfo) CultureInfo.InvariantCulture.NumberFormat.Clone();
             numberFormat.NumberGroupSeparator = " ";
             numberFormat.CurrencyGroupSeparator = " ";
             numberFormat.NumberDecimalSeparator = ".";
             numberFormat.CurrencyDecimalSeparator = ".";
 
-            double actual = Length.Parse(s!, numberFormat).Meters;
-            Assert.Equal(expected, actual);
+            QuantityValue actual = Length.Parse(s, numberFormat).Meters;
+            Assert.Equal(expectedValue, actual);
         }
 
         [Theory]
@@ -82,14 +84,15 @@ public void ParseWithCultureUsingSpaceAsThousandSeparators_ThrowsExceptionOnInva
         [InlineData("5.555 m", 5555)] // Dot is group separator not decimal
         public void ParseWithCultureUsingDotAsThousandSeparators(string s, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var numberFormat = (NumberFormatInfo) CultureInfo.InvariantCulture.NumberFormat.Clone();
             numberFormat.NumberGroupSeparator = ".";
             numberFormat.CurrencyGroupSeparator = ".";
             numberFormat.NumberDecimalSeparator = ",";
             numberFormat.CurrencyDecimalSeparator = ",";
 
-            double actual = Length.Parse(s, numberFormat).Meters;
-            Assert.Equal(expected, actual);
+            QuantityValue actual = Length.Parse(s, numberFormat).Meters;
+            Assert.Equal(expectedValue, actual);
         }
 
         [Fact]
@@ -150,8 +153,9 @@ public void TryParseLengthUnitUsEnglish(string? s, bool expected)
         [InlineData("1 г", "ru-RU", 1, MassUnit.Gram)]
         [InlineData("1 kg", "en-US", 1, MassUnit.Kilogram)]
         [InlineData("1 кг", "ru-RU", 1, MassUnit.Kilogram)]
-        public void ParseMassWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expectedValue, Enum expectedUnit)
+        public void ParseMassWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expected, Enum expectedUnit)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var actual = Mass.Parse(str, CultureInfo.GetCultureInfo(cultureName));
 
             Assert.Equal(expectedUnit, actual.Unit);
@@ -165,8 +169,9 @@ public void ParseMassWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAnd
         [InlineData("1 м", "ru-RU", 1, LengthUnit.Meter)]
         [InlineData("1 km", "en-US", 1, LengthUnit.Kilometer)]
         [InlineData("1 км", "ru-RU", 1, LengthUnit.Kilometer)]
-        public void ParseLengthWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expectedValue, Enum expectedUnit)
+        public void ParseLengthWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expected, Enum expectedUnit)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var actual = Length.Parse(str, CultureInfo.GetCultureInfo(cultureName));
 
             Assert.Equal(expectedUnit, actual.Unit);
@@ -180,8 +185,9 @@ public void ParseLengthWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitA
         [InlineData("1 Н", "ru-RU", 1, ForceUnit.Newton)]
         [InlineData("1 kN", "en-US", 1, ForceUnit.Kilonewton)]
         [InlineData("1 кН", "ru-RU", 1, ForceUnit.Kilonewton)]
-        public void ParseForceWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expectedValue, Enum expectedUnit)
+        public void ParseForceWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expected, Enum expectedUnit)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var actual = Force.Parse(str, CultureInfo.GetCultureInfo(cultureName));
 
             Assert.Equal(expectedUnit, actual.Unit);
@@ -201,8 +207,9 @@ public void ParseForceWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAn
         [InlineData("1 MB", "ru-RU", 1, InformationUnit.Megabyte)]
         [InlineData("1 MiB", "en-US", 1, InformationUnit.Mebibyte)]
         [InlineData("1 MiB", "ru-RU", 1, InformationUnit.Mebibyte)]
-        public void ParseInformationWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expectedValue, Enum expectedUnit)
+        public void ParseInformationWithPrefixUnits_GivenCulture_ReturnsQuantityWithSameUnitAndValue(string str, string cultureName, double expected, Enum expectedUnit)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var actual = Information.Parse(str, CultureInfo.GetCultureInfo(cultureName));
 
             Assert.Equal(expectedUnit, actual.Unit);
diff --git a/UnitsNet.Tests/CustomCode/PermeabilityTests.cs b/UnitsNet.Tests/CustomCode/PermeabilityTests.cs
index 7052a2132a..b4977aa1b5 100644
--- a/UnitsNet.Tests/CustomCode/PermeabilityTests.cs
+++ b/UnitsNet.Tests/CustomCode/PermeabilityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/PermittivityTests.cs b/UnitsNet.Tests/CustomCode/PermittivityTests.cs
index bbb7cb9355..6d83201639 100644
--- a/UnitsNet.Tests/CustomCode/PermittivityTests.cs
+++ b/UnitsNet.Tests/CustomCode/PermittivityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/PorousMediumPermeabilityTests.cs b/UnitsNet.Tests/CustomCode/PorousMediumPermeabilityTests.cs
index b1f075380e..27a4155c71 100644
--- a/UnitsNet.Tests/CustomCode/PorousMediumPermeabilityTests.cs
+++ b/UnitsNet.Tests/CustomCode/PorousMediumPermeabilityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/PowerDensityTests.cs b/UnitsNet.Tests/CustomCode/PowerDensityTests.cs
index 1d5a2c8817..1ad0418f8e 100644
--- a/UnitsNet.Tests/CustomCode/PowerDensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/PowerDensityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -74,5 +74,21 @@ public class PowerDensityTests : PowerDensityTestsBase
         protected override double MegawattsPerLiterInOneWattPerCubicMeter => 1e-9;
         protected override double GigawattsPerLiterInOneWattPerCubicMeter => 1e-12;
         protected override double TerawattsPerLiterInOneWattPerCubicMeter => 1e-15;
+
+        protected override double BtusPerSecondCubicInchInOneWattPerCubicMeter => 1.5531939811e-8;
+        protected override double BtusPerSecondCubicFootInOneWattPerCubicMeter => 2.6839191993e-5;
+
+        [Fact]
+        public void PowerDensityTimesVolumeEqualsPower()
+        {
+            PowerDensity powerDensity = PowerDensity.FromWattsPerCubicMeter(2);
+            Volume volume = Volume.FromCubicMeters(3);
+            Power expected = Power.FromWatts(6);
+
+            Assert.Equal(expected, powerDensity * volume);
+            Assert.Equal(expected, volume * powerDensity);
+            Assert.Equal(volume, expected / powerDensity);
+            Assert.Equal(powerDensity, expected / volume);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/PowerRatioTests.cs b/UnitsNet.Tests/CustomCode/PowerRatioTests.cs
index b310bed861..7714f6215a 100644
--- a/UnitsNet.Tests/CustomCode/PowerRatioTests.cs
+++ b/UnitsNet.Tests/CustomCode/PowerRatioTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -39,9 +39,10 @@ public void InvalidPower_ExpectArgumentOutOfRangeException(double power)
         [InlineData(100, 20)]
         public void ExpectPowerConvertedCorrectly(double power, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             Power p = Power.FromWatts(power);
             var actual = PowerRatio.FromPower(p).DecibelWatts;
-            Assert.Equal(expected, actual);
+            Assert.Equal(expectedValue, actual);
         }
 
         [Theory]
@@ -52,9 +53,10 @@ public void ExpectPowerConvertedCorrectly(double power, double expected)
         [InlineData(20, 100)]
         public void ExpectPowerRatioConvertedCorrectly(double powerRatio, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             PowerRatio pr = PowerRatio.FromDecibelWatts(powerRatio);
             var actual = pr.ToPower().Watts;
-            Assert.Equal(expected, actual);
+            Assert.Equal(expectedValue, actual);
         }
 
         // http://www.maximintegrated.com/en/app-notes/index.mvp/id/808
@@ -68,8 +70,9 @@ public void PowerRatioToAmplitudeRatio_50OhmImpedance(double dBmW, double expect
         {
             PowerRatio powerRatio = PowerRatio.FromDecibelMilliwatts(dBmW);
 
-            double actual = Math.Round(powerRatio.ToAmplitudeRatio(ElectricResistance.FromOhms(50)).DecibelMillivolts, 2);
-            Assert.Equal(expected, actual);
+            QuantityValue actual = powerRatio.ToAmplitudeRatio(ElectricResistance.FromOhms(50)).DecibelMillivolts;
+
+            AssertEx.EqualTolerance(expected, actual, 1e-2m, ComparisonType.Absolute);
         }
 
         [Theory]
@@ -81,8 +84,9 @@ public void PowerRatioToAmplitudeRatio_75OhmImpedance(double dBmW, double expect
         {
             PowerRatio powerRatio = PowerRatio.FromDecibelMilliwatts(dBmW);
 
-            double actual = Math.Round(powerRatio.ToAmplitudeRatio(ElectricResistance.FromOhms(75)).DecibelMillivolts, 2);
-            Assert.Equal(expected, actual);
+            QuantityValue actual = powerRatio.ToAmplitudeRatio(ElectricResistance.FromOhms(75)).DecibelMillivolts;
+
+            AssertEx.EqualTolerance(expected, actual, 1e-2m, ComparisonType.Absolute);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/PowerTests.cs b/UnitsNet.Tests/CustomCode/PowerTests.cs
index 945031a401..92b374e569 100644
--- a/UnitsNet.Tests/CustomCode/PowerTests.cs
+++ b/UnitsNet.Tests/CustomCode/PowerTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs b/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs
index 6d56282577..580925acf9 100644
--- a/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs
+++ b/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs
index f536bfa00c..daee0a9535 100644
--- a/UnitsNet.Tests/CustomCode/PressureTests.cs
+++ b/UnitsNet.Tests/CustomCode/PressureTests.cs
@@ -1,10 +1,11 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using UnitsNet.CustomCode.Units;
+using UnitsNet.InternalHelpers;
 using UnitsNet.Units;
 using UnitsNet.Wrappers;
 using Xunit;
@@ -108,6 +109,10 @@ public class PressureTests : PressureTestsBase
 
         protected override double MillipascalsInOnePascal => 1e3;
 
+        protected override double MilligramsForcePerSquareFootInOnePascal => 9.4734736122936992615e3;
+
+        protected override double MilligramsForcePerSquareMeterInOnePascal => 1.0197162129779282259e5;
+
         [Fact]
         public void Absolute_WithAbsolutePressureReference_IsEqual()
         {
@@ -169,7 +174,7 @@ public void ReferencePressure_WithInvalidPressureReference_ThrowsNotImplementedE
         [Fact]
         public void ReferencePressureReferences_ReturnsTheExpectedEnumValues()
         {
-            IEnumerable<PressureReference> expectedValues = Enum.GetValues<PressureReference>();
+            IEnumerable<PressureReference> expectedValues = EnumHelper.GetValues<PressureReference>();
 
             PressureReference[] actualValues = ReferencePressure.References;
 
@@ -211,6 +216,20 @@ public void Gauge_WithVacuumPressureReference_ThrowsArgumentOutOfRangeException(
             Assert.Throws<ArgumentOutOfRangeException>(() => refPressure.Gauge.Atmospheres);
         }
 
+        [Fact]
+        public void PressureDividedByAccelerationEqualsAreaDensity()
+        {
+            var areaDensity = Pressure.FromPascals(20) / Acceleration.FromMetersPerSecondSquared(2);
+            Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(10), areaDensity);
+        }
+
+        [Fact]
+        public void PressureDividedByAreaDensityEqualsAcceleration()
+        {
+            var acceleration = Pressure.FromPascals(20) / AreaDensity.FromKilogramsPerSquareMeter(2);
+            Assert.Equal(Acceleration.FromMetersPerSecondSquared(10), acceleration);
+        }
+
         [Fact]
         public void PressureDividedByLengthEqualsSpecificWeight()
         {
@@ -285,16 +304,29 @@ public void PressureDividedByTimeSpanEqualsPressureChangeRate()
         [Fact]
         public void PressureFromElevation_ConvertsWithRounding()
         {
-            var pressureFromElevation = Pressure.FromElevation(new Length(129149.9769457631, LengthUnit.Foot));
-            Assert.Equal(1, pressureFromElevation.Pascals, PascalsTolerance);
+            var pressureFromElevation = Pressure.FromElevation(new Length(129149.9769457631m, LengthUnit.Foot), significantDigits: 13);
+            Assert.Equal(1, pressureFromElevation.Pascals);
         }
 
         [Fact]
         public void ElevationFromPressure_ConvertsWithRounding()
         {
-            Length elevationFromPressure = Pressure.FromPascals(1).ToElevation();
+            Length elevationFromPressure = Pressure.FromPascals(1).ToElevation(significantDigits: 15);
             Assert.Equal(LengthUnit.Foot, elevationFromPressure.Unit);
-            Assert.Equal(129149.976945763, elevationFromPressure.Value, 9);
+            Assert.Equal(129149.976945763m, elevationFromPressure.Value);
+        }
+
+        [Fact]
+        public void PressureTimesVolumeFlowEqualsLeakRate()
+        {
+            Pressure pressure = Pressure.FromPascals(2);
+            VolumeFlow volumeFlow = VolumeFlow.FromCubicMetersPerSecond(3);
+            LeakRate expected = LeakRate.FromPascalCubicMetersPerSecond(6);
+
+            Assert.Equal(expected, pressure * volumeFlow);
+            Assert.Equal(expected, volumeFlow * pressure);
+            Assert.Equal(volumeFlow, expected / pressure);
+            Assert.Equal(pressure, expected / volumeFlow);
         }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantitiesInfoBuilderTest.cs b/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantitiesInfoBuilderTest.cs
new file mode 100644
index 0000000000..14279e7444
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantitiesInfoBuilderTest.cs
@@ -0,0 +1,69 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.Tests.QuantityInfos.Builder;
+
+public class QuantitiesInfoBuilderTest
+{
+    [Fact]
+    public void ConfigureQuantity_ValidInput_AddsCustomization()
+    {
+        var builder = new QuantitiesInfoBuilder();
+
+        builder.ConfigureQuantity(() =>
+            new QuantityInfo<Length, LengthUnit>(LengthUnit.Centimeter, Length.LengthInfo.GetDefaultMappings(), BaseDimensions.Dimensionless, Length.From));
+
+        QuantityInfo result = builder.CreateOrDefault(Length.Info);
+
+        Assert.Equal(LengthUnit.Centimeter, result.BaseUnitInfo.Value);
+        Assert.Equal(BaseDimensions.Dimensionless, result.BaseDimensions);
+    }
+
+    [Fact]
+    public void ConfigureQuantity_NullDelegate_ThrowsArgumentNullException()
+    {
+        var builder = new QuantitiesInfoBuilder();
+
+        Assert.Throws<ArgumentNullException>(() =>
+            builder.ConfigureQuantity<Length, LengthUnit>(null!));
+    }
+
+    [Fact]
+    public void CreateOrDefault_NoCustomization_ReturnsDefault()
+    {
+        var builder = new QuantitiesInfoBuilder();
+        QuantityInfo<Length, LengthUnit> defaultConfig = Length.Info;
+
+        QuantityInfo result = builder.CreateOrDefault(defaultConfig);
+
+        Assert.Equal(defaultConfig, result);
+    }
+
+    [Fact]
+    public void CreateOrDefault_Generic_NoCustomization_ReturnsDefault()
+    {
+        var builder = new QuantitiesInfoBuilder();
+
+        QuantityInfo<Length, LengthUnit> result = builder.CreateOrDefault(() => Length.Info);
+
+        Assert.Equal(Length.Info, result);
+    }
+
+    [Fact]
+    public void CreateOrDefault_Generic_WithCustomization_ReturnsCustomized()
+    {
+        var builder = new QuantitiesInfoBuilder();
+        
+        builder.ConfigureQuantity(() =>
+            new QuantityInfo<Length, LengthUnit>(LengthUnit.Centimeter, Length.LengthInfo.GetDefaultMappings(), BaseDimensions.Dimensionless, Length.From));
+
+        QuantityInfo<Length, LengthUnit> result = builder.CreateOrDefault(() => Length.Info);
+
+        Assert.Equal(LengthUnit.Centimeter, result.BaseUnitInfo.Value);
+        Assert.Equal(BaseDimensions.Dimensionless, result.BaseDimensions);
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantitiesSelectorTest.cs b/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantitiesSelectorTest.cs
new file mode 100644
index 0000000000..61efa4348d
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantitiesSelectorTest.cs
@@ -0,0 +1,65 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Collections.Generic;
+using UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.Tests.QuantityInfos.Builder;
+
+public class QuantitiesSelectorTest
+{
+    [Fact]
+    public void Constructor_InitializesQuantitiesSelected()
+    {
+        var selector = new QuantitiesSelector(() => []);
+        Assert.Empty(selector.GetQuantityInfos());
+    }
+
+    [Fact]
+    public void WithAdditionalQuantities_AddsQuantities()
+    {
+        QuantitiesSelector selector = new QuantitiesSelector(() => [Length.Info])
+            .WithAdditionalQuantities([Mass.Info]);
+
+        Assert.Equal([Length.Info, Mass.Info], selector.GetQuantityInfos());
+    }
+
+    [Fact]
+    public void Configure_AddsCustomConfiguration()
+    {
+        var selector = new QuantitiesSelector(() => [Length.Info, Mass.Info]);
+        var customLengthConfig =
+            new QuantityInfo<Length, LengthUnit>(LengthUnit.Centimeter, Length.LengthInfo.GetDefaultMappings(), BaseDimensions.Dimensionless, Length.From);
+
+        selector.Configure(() => customLengthConfig);
+
+        Assert.Equal([customLengthConfig, Mass.Info], selector.GetQuantityInfos());
+        Assert.Equal(customLengthConfig, selector.CreateOrDefault(() => Length.Info));
+        Assert.Equal(Mass.Info, selector.CreateOrDefault(() => Mass.Info));
+    }
+
+    [Fact]
+    public void Configure_AdditionalQuantity_AddsCustomConfiguration()
+    {
+        QuantitiesSelector selector = new QuantitiesSelector(() => [Mass.Info]).WithAdditionalQuantities([Length.Info]);
+        var customLengthConfig =
+            new QuantityInfo<Length, LengthUnit>(LengthUnit.Centimeter, Length.LengthInfo.GetDefaultMappings(), BaseDimensions.Dimensionless, Length.From);
+
+        selector.Configure(() => customLengthConfig);
+
+        Assert.Equal([Mass.Info, customLengthConfig], selector.GetQuantityInfos());
+        Assert.Equal(customLengthConfig, selector.CreateOrDefault(() => Length.Info));
+        Assert.Equal(Mass.Info, selector.CreateOrDefault(() => Mass.Info));
+    }
+
+    [Fact]
+    public void BuildSelection_ReturnsDefaultQuantities_WhenNoAdditionalOrCustomQuantities()
+    {
+        var selector = new QuantitiesSelector(() => [Length.Info]);
+
+        IEnumerable<QuantityInfo> result = selector.GetQuantityInfos();
+
+        Assert.Equal([Length.Info], result);
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantitiesSelectorTests.cs b/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantitiesSelectorTests.cs
new file mode 100644
index 0000000000..78fc005fcd
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantitiesSelectorTests.cs
@@ -0,0 +1,33 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet.Tests.QuantityInfos.Builder;
+
+public class QuantitiesSelectorTests
+{
+    [Fact]
+    public void GetQuantityInfos_WithoutAdditions_ReturnsBaseSelection()
+    {
+        var selector = new QuantitiesSelector(() => [Length.Info]);
+
+        Assert.Equal([Length.Info], selector.GetQuantityInfos());
+    }
+
+    [Fact]
+    public void WithAdditionalQuantities_AppendsAllSelectionsInOrder()
+    {
+        QuantitiesSelector selector = new QuantitiesSelector(() => [Length.Info])
+            .WithAdditionalQuantities([Mass.Info])
+            .WithAdditionalQuantities([Duration.Info]);
+
+        Assert.Equal([Length.Info, Mass.Info, Duration.Info], selector.GetQuantityInfos());
+    }
+
+    [Fact]
+    public void WithAdditionalQuantities_WithNull_ThrowsArgumentNullException()
+    {
+        var selector = new QuantitiesSelector(() => [Length.Info]);
+
+        Assert.Throws<ArgumentNullException>(() => selector.WithAdditionalQuantities(null!));
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantityInfoBuilderExtensionsTest.cs b/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantityInfoBuilderExtensionsTest.cs
new file mode 100644
index 0000000000..0fb8ccd7d0
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantityInfoBuilderExtensionsTest.cs
@@ -0,0 +1,91 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet.Tests.QuantityInfos.Builder;
+
+public class QuantityInfoBuilderExtensionsTest
+{
+    [Fact]
+    public void SelectUnits_FiltersCorrectly()
+    {
+        LengthUnit[] filterUnits = [LengthUnit.Centimeter, LengthUnit.Inch];
+
+        IEnumerable<UnitDefinition<LengthUnit>> result = Length.LengthInfo.GetDefaultMappings().SelectUnits(filterUnits);
+
+        Assert.Equal(filterUnits, result.Select(u => u.Value).ToArray());
+    }
+
+    [Fact]
+    public void ExcludeUnits_FiltersCorrectly()
+    {
+        var unitDefinitions = Length.LengthInfo.GetDefaultMappings()
+            .Where(x => x.Value is LengthUnit.Centimeter or LengthUnit.Meter or LengthUnit.Foot)
+            .ToList();
+
+        IEnumerable<UnitDefinition<LengthUnit>> result = unitDefinitions.ExcludeUnits(LengthUnit.Meter, LengthUnit.Centimeter);
+
+        Assert.Single(result, unitDefinition => unitDefinition.Value == LengthUnit.Foot);
+    }
+
+    [Fact]
+    public void Configure_UpdatesSpecificUnit()
+    {
+        var unitDefinitions = Length.LengthInfo.GetDefaultMappings()
+            .Where(x => x.Value is LengthUnit.Centimeter or LengthUnit.Meter or LengthUnit.Foot)
+            .ToList();
+        var customMeterDefinition = new UnitDefinition<LengthUnit>(LengthUnit.Meter, "UpdatedMeter", "UpdatedMeters", BaseUnits.Undefined);
+
+        var result = unitDefinitions.Configure(LengthUnit.Meter, _ => customMeterDefinition).ToList();
+
+        Assert.Equal("UpdatedMeter", result.First(u => u.Value == LengthUnit.Meter).Name);
+        Assert.Equal("Centimeter", result.First(u => u.Value == LengthUnit.Centimeter).Name);
+        Assert.Equal("Foot", result.First(u => u.Value == LengthUnit.Foot).Name);
+    }
+
+    [Fact]
+    public void WithConversionFromBase_CreatesNewDefinition()
+    {
+        UnitDefinition<LengthUnit> oldDefinition = Length.LengthInfo.GetDefaultMappings().First();
+
+        UnitDefinition<LengthUnit> newDefinition = oldDefinition.WithConversionFactorFromBase(20);
+
+        Assert.Equal(oldDefinition.Value, newDefinition.Value);
+        Assert.Equal(oldDefinition.Name, newDefinition.Name);
+        Assert.Equal(oldDefinition.PluralName, newDefinition.PluralName);
+        Assert.Equal(20, newDefinition.ConversionFromBase);
+        Assert.Equal(QuantityValue.Inverse(20), newDefinition.ConversionToBase);
+        Assert.Equal(oldDefinition.BaseUnits, newDefinition.BaseUnits);
+    }
+
+    [Fact]
+    public void WithConversionToBase_CreatesNewDefinition()
+    {
+        UnitInfo<Length, LengthUnit> oldDefinition = Length.Info.BaseUnitInfo;
+
+        UnitDefinition<LengthUnit> newDefinition = oldDefinition.WithConversionFactorToBase(20);
+
+        Assert.Equal(oldDefinition.Value, newDefinition.Value);
+        Assert.Equal(oldDefinition.Name, newDefinition.Name);
+        Assert.Equal(oldDefinition.PluralName, newDefinition.PluralName);
+        Assert.Equal(QuantityValue.Inverse(20), newDefinition.ConversionFromBase);
+        Assert.Equal(20, newDefinition.ConversionToBase);
+        Assert.Equal(oldDefinition.BaseUnits, newDefinition.BaseUnits);
+    }
+
+    [Fact]
+    public void WithConversionExpression_CreatesNewDefinition()
+    {
+        UnitInfo<Length, LengthUnit> oldDefinition = Length.Info.BaseUnitInfo;
+        var conversionFromBase = new ConversionExpression(coefficient: 20);
+        var conversionToBase = new ConversionExpression(coefficient: 0.05);
+
+        UnitDefinition<LengthUnit> newDefinition = oldDefinition.WithConversionExpression(conversionFromBase, conversionToBase);
+
+        Assert.Equal(oldDefinition.Value, newDefinition.Value);
+        Assert.Equal(oldDefinition.Name, newDefinition.Name);
+        Assert.Equal(oldDefinition.PluralName, newDefinition.PluralName);
+        Assert.Equal(conversionFromBase, newDefinition.ConversionFromBase);
+        Assert.Equal(conversionToBase, newDefinition.ConversionToBase);
+        Assert.Equal(oldDefinition.BaseUnits, newDefinition.BaseUnits);
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantityInfoBuilderTest.cs b/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantityInfoBuilderTest.cs
new file mode 100644
index 0000000000..2cdadbcce7
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/QuantityInfos/Builder/QuantityInfoBuilderTest.cs
@@ -0,0 +1,55 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.Tests.QuantityInfos.Builder;
+
+public class QuantityInfoBuilderTest
+{
+    [Fact]
+    public void Constructor_NullFactory_ThrowsArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => new QuantityInfoBuilder<Length, LengthUnit>(null!));
+    }
+
+    [Fact]
+    public void Constructor_ValidFactory_DoesNotThrow()
+    {
+        var builder = new QuantityInfoBuilder<Length, LengthUnit>(() => Length.Info);
+        Assert.NotNull(builder);
+    }
+
+    [Fact]
+    public void Build_ValidFactory_ReturnsQuantityInfo()
+    {
+        var builder = new QuantityInfoBuilder<Length, LengthUnit>(() => Length.Info);
+
+        QuantityInfo<Length, LengthUnit> result = builder.Build();
+
+        Assert.Same(Length.Info, result);
+    }
+
+    [Fact]
+    public void Build_CalledMultipleTimes_ReturnsSameInstance()
+    {
+        var builder = new QuantityInfoBuilder<Length, LengthUnit>(() => Length.Info);
+
+        QuantityInfo<Length, LengthUnit> firstResult = builder.Build();
+        QuantityInfo<Length, LengthUnit> secondResult = builder.Build();
+
+        Assert.Same(firstResult, secondResult);
+    }
+
+    [Fact]
+    public void Build_InterfaceImplementation_ReturnsQuantityInfo()
+    {
+        IQuantityInfoBuilder builder = new QuantityInfoBuilder<Length, LengthUnit>(() => Length.Info);
+
+        QuantityInfo result = builder.Build();
+
+        Assert.Same(Length.Info, result);
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/QuantityInfos/QuantityInfoExtensionsTest.cs b/UnitsNet.Tests/CustomCode/QuantityInfos/QuantityInfoExtensionsTest.cs
index 24085e6b4a..03cf4ff742 100644
--- a/UnitsNet.Tests/CustomCode/QuantityInfos/QuantityInfoExtensionsTest.cs
+++ b/UnitsNet.Tests/CustomCode/QuantityInfos/QuantityInfoExtensionsTest.cs
@@ -1,9 +1,7 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
-using System;
-using UnitsNet.Units;
-using Xunit;
+using UnitsNet.Tests.CustomQuantities;
 
 namespace UnitsNet.Tests.QuantityInfos;
 
@@ -68,4 +66,405 @@ public void GetDefaultUnit_ReturnsTheBaseUnit_WhenGivenADimensionlessQuantity()
             () => Assert.Equal(AngleUnit.Radian, Angle.Info.GetDefaultUnit(UnitSystem.SI)),
             () => Assert.Equal(SolidAngleUnit.Steradian, SolidAngle.Info.GetDefaultUnit(UnitSystem.SI)));
     }
+    
+    [Fact]
+    public void ConvertValueToBaseUnit_ReturnsValueInBaseUnit()
+    {
+        Assert.Equal(1000, Length.Info[LengthUnit.Kilometer].ConvertValueToBaseUnit(1));
+    }
+
+    [Fact]
+    public void ConvertValueToFromUnit_ReturnsValueInTargetUnit()
+    {
+        Assert.Equal(1, Length.Info[LengthUnit.Kilometer].ConvertValueFromBaseUnit(1000));
+    }
+
+    [Fact]
+    public void GetValueFrom_ReturnsValueInTargetUnit()
+    {
+        QuantityValue valueToConvert = 123.45m;
+        foreach (QuantityInfo quantityInfo in Quantity.Infos)
+        {
+            foreach (UnitInfo fromUnit in quantityInfo.UnitInfos)
+            {
+                IQuantity fromQuantity = quantityInfo.From(valueToConvert, fromUnit.Value);
+                foreach (UnitInfo toUnit in quantityInfo.UnitInfos)
+                {
+                    QuantityValue expectedValue = fromQuantity.As(toUnit.Value);
+                    Assert.Equal(expectedValue, toUnit.GetValueFrom(valueToConvert, fromUnit));
+                }
+            }
+        }
+    }
+
+    [Theory]
+    [InlineData(AreaUnit.SquareMeter, ReciprocalAreaUnit.InverseSquareMeter)]
+    [InlineData(AreaUnit.SquareCentimeter, ReciprocalAreaUnit.InverseSquareCentimeter)]
+    [InlineData(AreaUnit.SquareFoot, ReciprocalAreaUnit.InverseSquareFoot)]
+    [InlineData(AreaUnit.Acre, ReciprocalAreaUnit.InverseSquareMeter)]
+    public void TryToConvertFrom_QuantityWithInverseDimensions_ToQuantity(AreaUnit fromUnit, ReciprocalAreaUnit expectedUnit)
+    {
+        QuantityValue valueToConvert = 100;
+        UnitInfo fromUnitInfo = Area.Info[fromUnit];
+        ReciprocalArea expectedResult = Area.From(valueToConvert, fromUnit).Inverse();
+
+        var success = ReciprocalArea.Info.TryConvertFrom(valueToConvert, fromUnitInfo, out ReciprocalArea result);
+
+        Assert.True(success);
+        Assert.Equal(expectedResult, result);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Theory]
+    [InlineData(AreaUnit.SquareMeter, ReciprocalAreaUnit.InverseSquareMeter)]
+    [InlineData(AreaUnit.SquareCentimeter, ReciprocalAreaUnit.InverseSquareCentimeter)]
+    [InlineData(AreaUnit.SquareFoot, ReciprocalAreaUnit.InverseSquareFoot)]
+    [InlineData(AreaUnit.Acre, ReciprocalAreaUnit.InverseSquareMeter)]
+    public void TryToConvertFrom_QuantityWithInverseDimensions_ToIQuantity(AreaUnit fromUnit, ReciprocalAreaUnit expectedUnit)
+    {
+        QuantityValue valueToConvert = 100;
+        UnitInfo fromUnitInfo = Area.Info[fromUnit];
+        QuantityInfo targetQuantityInfo = ReciprocalArea.Info;
+
+        IQuantity expectedResult = Area.From(valueToConvert, fromUnit).Inverse();
+
+        var success = targetQuantityInfo.TryConvertFrom(valueToConvert, fromUnitInfo, out IQuantity? result);
+
+        Assert.True(success);
+        Assert.Equal(expectedResult, result);
+        Assert.Equal(expectedUnit, result!.Unit);
+    }
+
+    [Theory]
+    [InlineData(AreaUnit.SquareMeter, ReciprocalAreaUnit.InverseSquareMeter)]
+    [InlineData(AreaUnit.SquareCentimeter, ReciprocalAreaUnit.InverseSquareCentimeter)]
+    [InlineData(AreaUnit.SquareFoot, ReciprocalAreaUnit.InverseSquareFoot)]
+    [InlineData(AreaUnit.Acre, ReciprocalAreaUnit.InverseSquareMeter)]
+    public void ConvertFrom_QuantityWithInverseDimensions_ToQuantity(AreaUnit fromUnit, ReciprocalAreaUnit expectedUnit)
+    {
+        QuantityValue valueToConvert = 100;
+        UnitInfo fromUnitInfo = Area.Info[fromUnit];
+
+        ReciprocalArea expectedResult = Area.From(valueToConvert, fromUnit).Inverse();
+
+        ReciprocalArea convertedQuantity = ReciprocalArea.Info.ConvertFrom(valueToConvert, fromUnitInfo);
+
+        Assert.Equal(expectedResult, convertedQuantity);
+        Assert.Equal(expectedUnit, convertedQuantity.Unit);
+    }
+
+    [Theory]
+    [InlineData(AreaUnit.SquareMeter, ReciprocalAreaUnit.InverseSquareMeter)]
+    [InlineData(AreaUnit.SquareCentimeter, ReciprocalAreaUnit.InverseSquareCentimeter)]
+    [InlineData(AreaUnit.SquareFoot, ReciprocalAreaUnit.InverseSquareFoot)]
+    [InlineData(AreaUnit.Acre, ReciprocalAreaUnit.InverseSquareMeter)]
+    public void ConvertFrom_QuantityWithInverseDimensions_ToIQuantity(AreaUnit fromUnit, ReciprocalAreaUnit expectedUnit)
+    {
+        QuantityValue valueToConvert = 100;
+        UnitInfo fromUnitInfo = Area.Info[fromUnit];
+        QuantityInfo targetQuantityInfo = ReciprocalArea.Info;
+
+        IQuantity expectedResult = Area.From(valueToConvert, fromUnit).Inverse();
+
+        IQuantity convertedQuantity = targetQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+
+        Assert.Equal(expectedResult, convertedQuantity);
+        Assert.Equal(expectedUnit, convertedQuantity.Unit);
+    }
+
+    [Theory]
+    [InlineData(MassConcentrationUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerCubicMeter)]
+    [InlineData(MassConcentrationUnit.GramPerCubicMeter, DensityUnit.GramPerCubicMeter)]
+    [InlineData(MassConcentrationUnit.PoundPerCubicFoot, DensityUnit.PoundPerCubicFoot)]
+    [InlineData(MassConcentrationUnit.GramPerLiter, DensityUnit.GramPerLiter)]
+    [InlineData(MassConcentrationUnit.PoundPerUSGallon, DensityUnit.KilogramPerCubicMeter)]
+    public void TryToConvertFrom_QuantityWithSameDimensions_ToQuantity(MassConcentrationUnit fromUnit, DensityUnit expectedUnit)
+    {
+        QuantityValue valueToConvert = 100;
+        UnitInfo fromUnitInfo = MassConcentration.Info[fromUnit];
+
+        var expectedResult = Density.From(MassConcentration.From(valueToConvert, fromUnit).KilogramsPerCubicMeter, DensityUnit.KilogramPerCubicMeter);
+
+        var success = Density.Info.TryConvertFrom(valueToConvert, fromUnitInfo, out Density result);
+
+        Assert.True(success);
+        Assert.Equal(expectedResult, result);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Theory]
+    [InlineData(MassConcentrationUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerCubicMeter)]
+    [InlineData(MassConcentrationUnit.GramPerCubicMeter, DensityUnit.GramPerCubicMeter)]
+    [InlineData(MassConcentrationUnit.PoundPerCubicFoot, DensityUnit.PoundPerCubicFoot)]
+    [InlineData(MassConcentrationUnit.GramPerLiter, DensityUnit.GramPerLiter)]
+    [InlineData(MassConcentrationUnit.PoundPerUSGallon, DensityUnit.KilogramPerCubicMeter)]
+    public void TryToConvertFrom_QuantityWithSameDimensions_ToIQuantity(MassConcentrationUnit fromUnit, DensityUnit expectedUnit)
+    {
+        QuantityValue valueToConvert = 100;
+        UnitInfo fromUnitInfo = MassConcentration.Info[fromUnit];
+        QuantityInfo targetQuantityInfo = Density.Info;
+
+        IQuantity expectedResult = Density.From(MassConcentration.From(valueToConvert, fromUnit).KilogramsPerCubicMeter, DensityUnit.KilogramPerCubicMeter);
+
+        var success = targetQuantityInfo.TryConvertFrom(valueToConvert, fromUnitInfo, out IQuantity? result);
+
+        Assert.True(success);
+        Assert.Equal(expectedResult, result);
+        Assert.Equal(expectedUnit, result!.Unit);
+    }
+
+    [Theory]
+    [InlineData(MassFractionUnit.DecimalFraction, RatioUnit.DecimalFraction)]
+    [InlineData(MassFractionUnit.Percent, RatioUnit.DecimalFraction)]
+    [InlineData(MassFractionUnit.GramPerKilogram, RatioUnit.DecimalFraction)]
+    public void TryToConvertFrom_DimensionlessQuantity_ToQuantity(MassFractionUnit fromUnit, RatioUnit expectedUnit)
+    {
+        QuantityValue valueToConvert = 100;
+        UnitInfo fromUnitInfo = MassFraction.Info[fromUnit];
+
+        var expectedResult = Ratio.From(MassFraction.From(valueToConvert, fromUnit).DecimalFractions, RatioUnit.DecimalFraction);
+
+        var success = Ratio.Info.TryConvertFrom(valueToConvert, fromUnitInfo, out Ratio result);
+
+        Assert.True(success);
+        Assert.Equal(expectedResult, result);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Theory]
+    [InlineData(MassFractionUnit.DecimalFraction, RatioUnit.DecimalFraction)]
+    [InlineData(MassFractionUnit.Percent, RatioUnit.DecimalFraction)]
+    [InlineData(MassFractionUnit.GramPerKilogram, RatioUnit.DecimalFraction)]
+    public void TryToConvertFrom_DimensionlessQuantity_ToIQuantity(MassFractionUnit fromUnit, RatioUnit expectedUnit)
+    {
+        QuantityValue valueToConvert = 100;
+        UnitInfo fromUnitInfo = MassFraction.Info[fromUnit];
+
+        var expectedResult = Ratio.From(MassFraction.From(valueToConvert, fromUnit).DecimalFractions, RatioUnit.DecimalFraction);
+
+        var success = Ratio.Info.TryConvertFrom(valueToConvert, fromUnitInfo, out IQuantity? result);
+
+        Assert.True(success);
+        Assert.Equal(expectedResult, result);
+        Assert.Equal(expectedUnit, result!.Unit);
+    }
+
+    [Theory]
+    [InlineData(HowMuchUnit.ATon, MassUnit.Tonne, 1)]
+    [InlineData(HowMuchUnit.Some, MassUnit.Tonne, 0.1)]
+    [InlineData(HowMuchUnit.AShitTon, MassUnit.Tonne, 10)]
+    public void TryToConvertFrom_QuantityWithoutSIBase_ToQuantity(HowMuchUnit fromUnit, MassUnit expectedUnit, double expected)
+    {
+        var expectedValue = QuantityValue.FromDoubleRounded(expected);
+        QuantityValue valueToConvert = QuantityValue.One;
+        UnitInfo fromUnitInfo = HowMuch.Info[fromUnit];
+
+        var success = Mass.Info.TryConvertFrom(valueToConvert, fromUnitInfo, out Mass result);
+
+        Assert.True(success);
+        Assert.Equal(expectedValue, result.Value);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Theory]
+    [InlineData(MassUnit.Tonne, HowMuchUnit.ATon, 1)]
+    [InlineData(MassUnit.Kilogram, HowMuchUnit.ATon, 0.001)]
+    [InlineData(MassUnit.Gram, HowMuchUnit.ATon, 0.000001)]
+    public void TryToConvertFrom_QuantityWithoutMatchingSIBase_ToIQuantity(MassUnit fromUnit, HowMuchUnit expectedUnit, double expected)
+    {
+        var expectedValue = QuantityValue.FromDoubleRounded(expected);
+        QuantityValue valueToConvert = QuantityValue.One;
+        UnitInfo fromUnitInfo = Mass.Info[fromUnit];
+        var success = HowMuch.Info.TryConvertFrom(valueToConvert, fromUnitInfo, out IQuantity? result);
+
+        Assert.True(success);
+        Assert.Equal(expectedValue, result!.Value);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Theory]
+    [InlineData(TemperatureChangeRateUnit.DegreeKelvinPerSecond, TemperatureChangeRateUnit.DegreeKelvinPerSecond, 1)]
+    [InlineData(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, 1)]
+    [InlineData(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, 10)]
+    public void TryToConvertFrom_QuantityBaseDifferentFromSI_ToQuantity(TemperatureChangeRateUnit fromUnit, TemperatureChangeRateUnit expectedUnit,
+        double expected)
+    {
+        var expectedValue = QuantityValue.FromDoubleRounded(expected);
+        QuantityValue valueToConvert = QuantityValue.One;
+        UnitInfo fromUnitInfo = TemperatureChangeRate.Info[fromUnit];
+        // we simulate a different quantity type, having a non-standard base unit (note: the "official" TemperatureChangeRate is currently using DegreeCelsiusPerSecond)
+        var customQuantityInfo = new TemperatureChangeRate.TemperatureChangeRateInfo("TestTemperature", TemperatureChangeRateUnit.DegreeKelvinPerSecond,
+            TemperatureChangeRate.TemperatureChangeRateInfo.GetDefaultMappings(), TemperatureChangeRate.Zero, TemperatureChangeRate.BaseDimensions);
+
+        var success = customQuantityInfo.TryConvertFrom(valueToConvert, fromUnitInfo, out TemperatureChangeRate result);
+
+        Assert.True(success);
+        Assert.Equal(expectedValue, result.Value);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Theory]
+    [InlineData(TemperatureChangeRateUnit.DegreeKelvinPerSecond, TemperatureChangeRateUnit.DegreeKelvinPerSecond, 1)]
+    [InlineData(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, 1)]
+    [InlineData(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, 10)]
+    public void TryToConvertFrom_QuantityBaseDifferentFromSI_ToIQuantity(TemperatureChangeRateUnit fromUnit, TemperatureChangeRateUnit expectedUnit,
+        double expected)
+    {
+        var expectedValue = QuantityValue.FromDoubleRounded(expected);
+        QuantityValue valueToConvert = QuantityValue.One;
+        UnitInfo fromUnitInfo = TemperatureChangeRate.Info[fromUnit];
+        // we simulate a different quantity type, having a non-standard base unit (note: the "official" TemperatureChangeRate is currently using DegreeCelsiusPerSecond)
+        QuantityInfo customQuantityInfo = new TemperatureChangeRate.TemperatureChangeRateInfo("TestTemperature", TemperatureChangeRateUnit.DegreeKelvinPerSecond,
+            TemperatureChangeRate.TemperatureChangeRateInfo.GetDefaultMappings(), TemperatureChangeRate.Zero, TemperatureChangeRate.BaseDimensions);
+
+        var success = customQuantityInfo.TryConvertFrom(valueToConvert, fromUnitInfo, out IQuantity? result);
+
+        Assert.True(success);
+        Assert.Equal(expectedValue, result!.Value);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Theory]
+    [InlineData(MassConcentrationUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerCubicMeter)]
+    [InlineData(MassConcentrationUnit.GramPerCubicMeter, DensityUnit.GramPerCubicMeter)]
+    [InlineData(MassConcentrationUnit.PoundPerCubicFoot, DensityUnit.PoundPerCubicFoot)]
+    [InlineData(MassConcentrationUnit.GramPerLiter, DensityUnit.GramPerLiter)]
+    [InlineData(MassConcentrationUnit.PoundPerUSGallon, DensityUnit.KilogramPerCubicMeter)]
+    public void ConvertFrom_QuantityWithSameDimensions_ToQuantity(MassConcentrationUnit fromUnit, DensityUnit expectedUnit)
+    {
+        QuantityValue valueToConvert = 100;
+        UnitInfo fromUnitInfo = MassConcentration.Info[fromUnit];
+
+        var expectedResult = Density.From(MassConcentration.From(valueToConvert, fromUnit).KilogramsPerCubicMeter, DensityUnit.KilogramPerCubicMeter);
+
+        Density result = Density.Info.ConvertFrom(valueToConvert, fromUnitInfo);
+
+        Assert.Equal(expectedResult, result);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Theory]
+    [InlineData(MassConcentrationUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerCubicMeter)]
+    [InlineData(MassConcentrationUnit.GramPerCubicMeter, DensityUnit.GramPerCubicMeter)]
+    [InlineData(MassConcentrationUnit.PoundPerCubicFoot, DensityUnit.PoundPerCubicFoot)]
+    [InlineData(MassConcentrationUnit.GramPerLiter, DensityUnit.GramPerLiter)]
+    [InlineData(MassConcentrationUnit.PoundPerUSGallon, DensityUnit.KilogramPerCubicMeter)]
+    public void ConvertFrom_QuantityWithSameDimensions_ToIQuantity(MassConcentrationUnit fromUnit, DensityUnit expectedUnit)
+    {
+        QuantityValue valueToConvert = 100;
+        UnitInfo fromUnitInfo = MassConcentration.Info[fromUnit];
+        QuantityInfo targetQuantityInfo = Density.Info;
+
+        IQuantity expectedResult = Density.From(MassConcentration.From(valueToConvert, fromUnit).KilogramsPerCubicMeter, DensityUnit.KilogramPerCubicMeter);
+
+        IQuantity result = targetQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+
+        Assert.Equal(expectedResult, result);
+        Assert.Equal(expectedUnit, result.Unit);
+    }
+
+    [Fact]
+    public void TryToConvertFrom_QuantityWithIncompatibleDimensions_ToQuantity_ReturnsFalse()
+    {
+        UnitInfo fromUnitInfo = MassConcentration.Info[MassConcentrationUnit.GramPerCubicMeter];
+
+        var success = Volume.Info.TryConvertFrom(1, fromUnitInfo, out Volume _);
+
+        Assert.False(success);
+    }
+
+    [Fact]
+    public void TryToConvertFrom_QuantityWithIncompatibleDimensions_ToIQuantity_ReturnsFalse()
+    {
+        UnitInfo fromUnitInfo = MassConcentration.Info[MassConcentrationUnit.GramPerCubicMeter];
+        QuantityInfo targetQuantityInfo = Volume.Info;
+
+        var success = targetQuantityInfo.TryConvertFrom(1, fromUnitInfo, out IQuantity? _);
+
+        Assert.False(success);
+    }
+
+    [Fact]
+    public void TryToConvertFrom_QuantityWithNoMatchingBaseUnits_ToQuantity_ReturnsFalse()
+    {
+        UnitInfo fromUnitInfo = MassConcentration.Info[MassConcentrationUnit.GramPerCubicMeter];
+        // we simulate a target quantity without any base units
+        var targetQuantityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+            unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+
+        var success = targetQuantityInfo.TryConvertFrom(1, fromUnitInfo, out Density _);
+
+        Assert.False(success);
+    }
+
+    [Fact]
+    public void TryToConvertFrom_QuantityWithNoMatchingBaseUnits_ToIQuantity_ReturnsFalse()
+    {
+        UnitInfo fromUnitInfo = MassConcentration.Info[MassConcentrationUnit.GramPerCubicMeter];
+        // we simulate a target quantity without any base units
+        QuantityInfo targetQuantityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+            unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+
+        var success = targetQuantityInfo.TryConvertFrom(1, fromUnitInfo, out IQuantity? _);
+
+        Assert.False(success);
+    }
+
+    [Fact]
+    public void ConvertFrom_QuantityWithIncompatibleDimensions_ToQuantity_ThrowsInvalidConversionException()
+    {
+        UnitInfo fromUnitInfo = MassConcentration.Info[MassConcentrationUnit.GramPerCubicMeter];
+
+        Assert.Throws<InvalidConversionException>(() => Volume.Info.ConvertFrom(1, fromUnitInfo));
+    }
+
+    [Fact]
+    public void ConvertFrom_QuantityWithIncompatibleDimensions_ToIQuantity_ThrowsInvalidConversionException()
+    {
+        UnitInfo fromUnitInfo = MassConcentration.Info[MassConcentrationUnit.GramPerCubicMeter];
+        QuantityInfo targetQuantityInfo = Volume.Info;
+
+        Assert.Throws<InvalidConversionException>(() => targetQuantityInfo.ConvertFrom(1, fromUnitInfo));
+    }
+
+    [Fact]
+    public void ConvertFrom_QuantityWithNoMatchingBaseUnits_ToQuantity_ThrowsInvalidConversionException()
+    {
+        UnitInfo fromUnitInfo = MassConcentration.Info[MassConcentrationUnit.GramPerCubicMeter];
+        // we simulate a target quantity without any base units
+        var targetQuantityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+            unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+
+        Assert.Throws<InvalidConversionException>(() => targetQuantityInfo.ConvertFrom(1, fromUnitInfo));
+    }
+
+    [Fact]
+    public void ConvertFrom_QuantityWithNoMatchingBaseUnits_ToIQuantity_ThrowsInvalidConversionException()
+    {
+        UnitInfo fromUnitInfo = MassConcentration.Info[MassConcentrationUnit.GramPerCubicMeter];
+        // we simulate a target quantity without any base units
+        QuantityInfo targetQuantityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+            unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+
+        Assert.Throws<InvalidConversionException>(() => targetQuantityInfo.ConvertFrom(1, fromUnitInfo));
+    }
+
+    [Theory]
+    [InlineData(1, 0, 0, 0, 0, 0, 0)]
+    [InlineData(0, 1, 0, 0, 0, 0, 0)]
+    [InlineData(0, 0, 1, 0, 0, 0, 0)]
+    [InlineData(0, 0, 0, 1, 0, 0, 0)]
+    [InlineData(0, 0, 0, 0, 1, 0, 0)]
+    [InlineData(0, 0, 0, 0, 0, 1, 0)]
+    [InlineData(0, 0, 0, 0, 0, 0, 1)]
+    public void IsInverse_BaseDimension_ReturnsTheExpectedValue(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity)
+    {
+        var baseDimensions = new BaseDimensions(length, mass, time, current, temperature, amount, luminousIntensity);
+        var inverseDimensions = new BaseDimensions(-length, -mass, -time, -current, -temperature, -amount, -luminousIntensity);
+        Assert.True(baseDimensions.IsInverseOf(inverseDimensions));
+        Assert.True(inverseDimensions.IsInverseOf(baseDimensions));
+        Assert.False(baseDimensions.IsInverseOf(baseDimensions));
+        Assert.False(baseDimensions.IsInverseOf(BaseDimensions.Dimensionless));
+        Assert.False(BaseDimensions.Dimensionless.IsInverseOf(baseDimensions));
+    }
 }
diff --git a/UnitsNet.Tests/CustomCode/RadiationEquivalentDoseRateTests.cs b/UnitsNet.Tests/CustomCode/RadiationEquivalentDoseRateTests.cs
index 9016a68d03..006cf9b282 100644
--- a/UnitsNet.Tests/CustomCode/RadiationEquivalentDoseRateTests.cs
+++ b/UnitsNet.Tests/CustomCode/RadiationEquivalentDoseRateTests.cs
@@ -1,3 +1,19 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
 // Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
diff --git a/UnitsNet.Tests/CustomCode/RadiationEquivalentDoseTests.cs b/UnitsNet.Tests/CustomCode/RadiationEquivalentDoseTests.cs
index 0ed278230a..ae2575fc08 100644
--- a/UnitsNet.Tests/CustomCode/RadiationEquivalentDoseTests.cs
+++ b/UnitsNet.Tests/CustomCode/RadiationEquivalentDoseTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/RadiationExposureTests.cs b/UnitsNet.Tests/CustomCode/RadiationExposureTests.cs
index 982e69de1c..da6a836e2d 100644
--- a/UnitsNet.Tests/CustomCode/RadiationExposureTests.cs
+++ b/UnitsNet.Tests/CustomCode/RadiationExposureTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/RadioactivityTests.cs b/UnitsNet.Tests/CustomCode/RadioactivityTests.cs
index d6918d70da..266b4425db 100644
--- a/UnitsNet.Tests/CustomCode/RadioactivityTests.cs
+++ b/UnitsNet.Tests/CustomCode/RadioactivityTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/RatioChangeRateTests.cs b/UnitsNet.Tests/CustomCode/RatioChangeRateTests.cs
index b53dcbe33c..79215e6a01 100644
--- a/UnitsNet.Tests/CustomCode/RatioChangeRateTests.cs
+++ b/UnitsNet.Tests/CustomCode/RatioChangeRateTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -25,5 +25,18 @@ public class RatioChangeRateTests : RatioChangeRateTestsBase
     {
         protected override double DecimalFractionsPerSecondInOneDecimalFractionPerSecond => 1;
         protected override double PercentsPerSecondInOneDecimalFractionPerSecond => 100;
+
+        [Fact]
+        public void RatioChangeRateTimesDurationEqualsRatio()
+        {
+            RatioChangeRate changeRate = RatioChangeRate.FromDecimalFractionsPerSecond(2);
+            Duration duration = Duration.FromSeconds(3);
+            Ratio expected = Ratio.FromDecimalFractions(6);
+
+            Assert.Equal(expected, changeRate * duration);
+            Assert.Equal(expected, duration * changeRate);
+            Assert.Equal(duration, expected / changeRate);
+            Assert.Equal(changeRate, expected / duration);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/RatioTests.cs b/UnitsNet.Tests/CustomCode/RatioTests.cs
index 615befd16b..af449ed3e9 100644
--- a/UnitsNet.Tests/CustomCode/RatioTests.cs
+++ b/UnitsNet.Tests/CustomCode/RatioTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet.Tests
diff --git a/UnitsNet.Tests/CustomCode/ReciprocalAreaTests.cs b/UnitsNet.Tests/CustomCode/ReciprocalAreaTests.cs
index abc9485980..ddeca53661 100644
--- a/UnitsNet.Tests/CustomCode/ReciprocalAreaTests.cs
+++ b/UnitsNet.Tests/CustomCode/ReciprocalAreaTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -45,10 +45,11 @@ public class ReciprocalAreaTests : ReciprocalAreaTestsBase
         [InlineData(2.0, 0.5)]
         public void InverseReturnsArea(double value, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var inverseArea = new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter);
             var area = inverseArea.Inverse();
 
-            Assert.Equal(expected, area.SquareMeters);
+            Assert.Equal(expectedValue, area.SquareMeters);
         }
 
         [Fact]
@@ -62,7 +63,7 @@ public void ReciprocalAreaTimesForceEqualsPressure()
         public void ReciprocalAreaTimesAreaEqualsRatio()
         {
             Ratio ratio = ReciprocalArea.FromInverseSquareMeters(10) * Area.FromSquareMeters(0.5);
-            Assert.Equal(5.0, ratio.Value);
+            Assert.Equal(5, ratio.Value);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/CustomCode/ReciprocalLengthTests.cs b/UnitsNet.Tests/CustomCode/ReciprocalLengthTests.cs
index bbce308c17..940345ea5a 100644
--- a/UnitsNet.Tests/CustomCode/ReciprocalLengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/ReciprocalLengthTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -46,10 +46,11 @@ public class ReciprocalLengthTests : ReciprocalLengthTestsBase
         [InlineData(2.0, 0.5)]
         public static void InverseReturnsLength(double value, double expected)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var inverseLength = new ReciprocalLength(value, ReciprocalLengthUnit.InverseMeter);
             var length = inverseLength.Inverse();
 
-            Assert.Equal(expected, length.Meters);
+            Assert.Equal(expectedValue, length.Meters);
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/CustomCode/RelativeHumidityTests.cs b/UnitsNet.Tests/CustomCode/RelativeHumidityTests.cs
index 981e555b9f..8c94d369ce 100644
--- a/UnitsNet.Tests/CustomCode/RelativeHumidityTests.cs
+++ b/UnitsNet.Tests/CustomCode/RelativeHumidityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/RotationalAccelerationTests.cs b/UnitsNet.Tests/CustomCode/RotationalAccelerationTests.cs
index 571f26aa72..e3eb5b32cb 100644
--- a/UnitsNet.Tests/CustomCode/RotationalAccelerationTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalAccelerationTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -31,5 +31,18 @@ public class RotationalAccelerationTests : RotationalAccelerationTestsBase
         protected override double RadiansPerSecondSquaredInOneRadianPerSecondSquared => 1;
         protected override double RevolutionsPerMinutePerSecondInOneRadianPerSecondSquared => 9.549296586;
         protected override double RevolutionsPerSecondSquaredInOneRadianPerSecondSquared=> 0.159154943091895;
+
+        [Fact]
+        public void RotationalAccelerationTimesDurationEqualsRotationalSpeed()
+        {
+            RotationalAcceleration acceleration = RotationalAcceleration.FromRadiansPerSecondSquared(2);
+            Duration duration = Duration.FromSeconds(3);
+            RotationalSpeed expected = RotationalSpeed.FromRadiansPerSecond(6);
+
+            Assert.Equal(expected, acceleration * duration);
+            Assert.Equal(expected, duration * acceleration);
+            Assert.Equal(duration, expected / acceleration);
+            Assert.Equal(acceleration, expected / duration);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
index c57c4534be..441f7c267e 100644
--- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/RotationalStiffnessPerLengthTests.cs b/UnitsNet.Tests/CustomCode/RotationalStiffnessPerLengthTests.cs
index 674008b663..72bd9d51fd 100644
--- a/UnitsNet.Tests/CustomCode/RotationalStiffnessPerLengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalStiffnessPerLengthTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs b/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs
index 710480c458..8767d89c5d 100644
--- a/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/ScalarTests.cs b/UnitsNet.Tests/CustomCode/ScalarTests.cs
index 6c34cb39a0..b5820a5f49 100644
--- a/UnitsNet.Tests/CustomCode/ScalarTests.cs
+++ b/UnitsNet.Tests/CustomCode/ScalarTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/SolidAngleTests.cs b/UnitsNet.Tests/CustomCode/SolidAngleTests.cs
index 33776fc85f..315dd00d8b 100644
--- a/UnitsNet.Tests/CustomCode/SolidAngleTests.cs
+++ b/UnitsNet.Tests/CustomCode/SolidAngleTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
index f17204e372..9c3ceef8d4 100644
--- a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
diff --git a/UnitsNet.Tests/CustomCode/SpecificEntropyTests.cs b/UnitsNet.Tests/CustomCode/SpecificEntropyTests.cs
index 2e463383f5..14ea282fb6 100644
--- a/UnitsNet.Tests/CustomCode/SpecificEntropyTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificEntropyTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/SpecificFuelConsumptionTests.cs b/UnitsNet.Tests/CustomCode/SpecificFuelConsumptionTests.cs
index 1be50cf8c1..963ca2de9b 100644
--- a/UnitsNet.Tests/CustomCode/SpecificFuelConsumptionTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificFuelConsumptionTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/SpecificVolumeTests.cs b/UnitsNet.Tests/CustomCode/SpecificVolumeTests.cs
index d07d305874..63cb9114cd 100644
--- a/UnitsNet.Tests/CustomCode/SpecificVolumeTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificVolumeTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -30,7 +30,19 @@ public class SpecificVolumeTests : SpecificVolumeTestsBase
 
         protected override double CubicFeetPerPoundInOneCubicMeterPerKilogram => 16.01846353;
 
-        protected override double MillicubicMetersPerKilogramInOneCubicMeterPerKilogram => 1e3;
+        protected override double CubicMillimetersPerKilogramInOneCubicMeterPerKilogram => 1e9;
+
+        /// <summary>
+        /// https://www.bipm.org/en/measurement-units/si-prefixes
+        /// </summary>
+        [Fact]
+        public static void ConvertByAbbreviation_CubicMetersPerKilogramToCubicMillimetersPerKilogram()
+        {
+            bool converted = UnitConverter.TryConvertByAbbreviation(1e-9, "SpecificVolume", "m³/kg", "mm³/kg", out QuantityValue result);
+
+            Assert.True(converted);
+            Assert.Equal(QuantityValue.One, result);
+        }
 
         [Fact]
         public static void SpecificVolumeTimesMassEqualsVolume()
diff --git a/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs b/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs
index f6e56d7ab4..4fffb5480e 100644
--- a/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
@@ -48,6 +48,13 @@ public void SpecificWeightTimesLengthEqualsPressure()
             Assert.Equal(Pressure.FromPascals(20), pressure);
         }
 
+        [Fact]
+        public void SpecificWeightTimesVolumeEqualsForce()
+        {
+            Force force = SpecificWeight.FromNewtonsPerCubicMeter(10) * Volume.FromCubicMeters(2);
+            Assert.Equal(Force.FromNewtons(20), force);
+        }
+
         [Fact]
         public void SpecificWeightDividedByDensityEqualsAcceleration()
         {
diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs
index 268bd91e0d..07afe7758e 100644
--- a/UnitsNet.Tests/CustomCode/SpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/StandardVolumeFlowTests.cs b/UnitsNet.Tests/CustomCode/StandardVolumeFlowTests.cs
index e226a67457..bce134a969 100644
--- a/UnitsNet.Tests/CustomCode/StandardVolumeFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/StandardVolumeFlowTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/StonePoundsTests.cs b/UnitsNet.Tests/CustomCode/StonePoundsTests.cs
index 29d51626d5..96e38329c8 100644
--- a/UnitsNet.Tests/CustomCode/StonePoundsTests.cs
+++ b/UnitsNet.Tests/CustomCode/StonePoundsTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Globalization;
diff --git a/UnitsNet.Tests/CustomCode/TemperatureChangeRateTests.cs b/UnitsNet.Tests/CustomCode/TemperatureChangeRateTests.cs
index 6a3a5f80fd..15148a4ceb 100644
--- a/UnitsNet.Tests/CustomCode/TemperatureChangeRateTests.cs
+++ b/UnitsNet.Tests/CustomCode/TemperatureChangeRateTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs b/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs
index 8b8e96d5f8..72d0cafa0f 100644
--- a/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs
+++ b/UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/TemperatureGradientTests.cs b/UnitsNet.Tests/CustomCode/TemperatureGradientTests.cs
index 245ccd505a..9330c09eda 100644
--- a/UnitsNet.Tests/CustomCode/TemperatureGradientTests.cs
+++ b/UnitsNet.Tests/CustomCode/TemperatureGradientTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/TemperatureTests.cs b/UnitsNet.Tests/CustomCode/TemperatureTests.cs
index b75e306809..46fcceceb4 100644
--- a/UnitsNet.Tests/CustomCode/TemperatureTests.cs
+++ b/UnitsNet.Tests/CustomCode/TemperatureTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet.Tests;
@@ -33,73 +33,73 @@ public void AllBaseQuantityUnitsAreBaseUnits()
 
     public static IEnumerable<object[]> TemperatureDeltaPlusTemperatureEqualsTemperatureData { get; } =
     [
-        [-10d, TemperatureUnit.DegreeCelsius, 0d, TemperatureDeltaUnit.DegreeCelsius, -10d, TemperatureUnit.DegreeCelsius],
-        [-10d, TemperatureUnit.DegreeCelsius, 10d, TemperatureDeltaUnit.DegreeCelsius, 0d, TemperatureUnit.DegreeCelsius],
-        [-10d, TemperatureUnit.DegreeCelsius, 20d, TemperatureDeltaUnit.DegreeCelsius, 10d, TemperatureUnit.DegreeCelsius],
-        [-10d, TemperatureUnit.DegreeFahrenheit, 0d, TemperatureDeltaUnit.DegreeFahrenheit, -10d, TemperatureUnit.DegreeFahrenheit],
-        [-10d, TemperatureUnit.DegreeFahrenheit, 10d, TemperatureDeltaUnit.DegreeFahrenheit, 0d, TemperatureUnit.DegreeFahrenheit],
-        [-10d, TemperatureUnit.DegreeFahrenheit, 20d, TemperatureDeltaUnit.DegreeFahrenheit, 10d, TemperatureUnit.DegreeFahrenheit]
+        [-10m, TemperatureUnit.DegreeCelsius, 0m, TemperatureDeltaUnit.DegreeCelsius, -10m, TemperatureUnit.DegreeCelsius],
+        [-10m, TemperatureUnit.DegreeCelsius, 10m, TemperatureDeltaUnit.DegreeCelsius, 0m, TemperatureUnit.DegreeCelsius],
+        [-10m, TemperatureUnit.DegreeCelsius, 20m, TemperatureDeltaUnit.DegreeCelsius, 10m, TemperatureUnit.DegreeCelsius],
+        [-10m, TemperatureUnit.DegreeFahrenheit, 0m, TemperatureDeltaUnit.DegreeFahrenheit, -10m, TemperatureUnit.DegreeFahrenheit],
+        [-10m, TemperatureUnit.DegreeFahrenheit, 10m, TemperatureDeltaUnit.DegreeFahrenheit, 0m, TemperatureUnit.DegreeFahrenheit],
+        [-10m, TemperatureUnit.DegreeFahrenheit, 20m, TemperatureDeltaUnit.DegreeFahrenheit, 10m, TemperatureUnit.DegreeFahrenheit]
     ];
 
     [Theory]
     [MemberData(nameof(TemperatureDeltaPlusTemperatureEqualsTemperatureData))]
-    public void TemperatureDeltaPlusTemperatureEqualsTemperature(double temperatureValue, TemperatureUnit temperatureUnit, double deltaValue,
-        TemperatureDeltaUnit deltaUnit, double expectedValue, TemperatureUnit expectedUnit)
+    public void TemperatureDeltaPlusTemperatureEqualsTemperature(decimal temperatureValue, TemperatureUnit temperatureUnit, decimal deltaValue,
+        TemperatureDeltaUnit deltaUnit, decimal expectedValue, TemperatureUnit expectedUnit)
     {
         var temperature = new Temperature(temperatureValue, temperatureUnit);
         var temperatureDelta = new TemperatureDelta(deltaValue, deltaUnit);
         var expectedTemperature = new Temperature(expectedValue, expectedUnit);
-
+            
         Temperature result = temperature + temperatureDelta;
-
-        Assert.True(expectedTemperature.Equals(result, TemperatureDelta.FromKelvins(KelvinsTolerance)));
+            
+        Assert.Equal(expectedTemperature, result);
     }
 
     public static IEnumerable<object[]> TemperatureMinusTemperatureDeltaEqualsTemperatureData { get; } =
     [
-        [20d, TemperatureUnit.DegreeCelsius, 10d, TemperatureDeltaUnit.DegreeCelsius, 10d, TemperatureUnit.DegreeCelsius],
-        [20d, TemperatureUnit.DegreeCelsius, 20d, TemperatureDeltaUnit.DegreeCelsius, 0d, TemperatureUnit.DegreeCelsius],
-        [20d, TemperatureUnit.DegreeCelsius, 30d, TemperatureDeltaUnit.DegreeCelsius, -10d, TemperatureUnit.DegreeCelsius],
-        [20d, TemperatureUnit.DegreeFahrenheit, 10d, TemperatureDeltaUnit.DegreeFahrenheit, 10d, TemperatureUnit.DegreeFahrenheit],
-        [20d, TemperatureUnit.DegreeFahrenheit, 20d, TemperatureDeltaUnit.DegreeFahrenheit, 0d, TemperatureUnit.DegreeFahrenheit],
-        [20d, TemperatureUnit.DegreeFahrenheit, 30d, TemperatureDeltaUnit.DegreeFahrenheit, -10d, TemperatureUnit.DegreeFahrenheit]
+        [20m, TemperatureUnit.DegreeCelsius, 10m, TemperatureDeltaUnit.DegreeCelsius, 10m, TemperatureUnit.DegreeCelsius],
+        [20m, TemperatureUnit.DegreeCelsius, 20m, TemperatureDeltaUnit.DegreeCelsius, 0m, TemperatureUnit.DegreeCelsius],
+        [20m, TemperatureUnit.DegreeCelsius, 30m, TemperatureDeltaUnit.DegreeCelsius, -10m, TemperatureUnit.DegreeCelsius],
+        [20m, TemperatureUnit.DegreeFahrenheit, 10m, TemperatureDeltaUnit.DegreeFahrenheit, 10m, TemperatureUnit.DegreeFahrenheit],
+        [20m, TemperatureUnit.DegreeFahrenheit, 20m, TemperatureDeltaUnit.DegreeFahrenheit, 0m, TemperatureUnit.DegreeFahrenheit],
+        [20m, TemperatureUnit.DegreeFahrenheit, 30m, TemperatureDeltaUnit.DegreeFahrenheit, -10m, TemperatureUnit.DegreeFahrenheit]
     ];
 
     [Theory]
     [MemberData(nameof(TemperatureMinusTemperatureDeltaEqualsTemperatureData))]
-    public void TemperatureMinusTemperatureDeltaEqualsTemperature(double temperatureValue, TemperatureUnit temperatureUnit, double deltaValue,
-        TemperatureDeltaUnit deltaUnit, double expectedValue, TemperatureUnit expectedUnit)
+    public void TemperatureMinusTemperatureDeltaEqualsTemperature(decimal temperatureValue, TemperatureUnit temperatureUnit, decimal deltaValue,
+        TemperatureDeltaUnit deltaUnit, decimal expectedValue, TemperatureUnit expectedUnit)
     {
         var temp = new Temperature(temperatureValue, temperatureUnit);
         var delta = new TemperatureDelta(deltaValue, deltaUnit);
         var expectedTemperature = new Temperature(expectedValue, expectedUnit);
-
+            
         Temperature result = temp - delta;
-
-        Assert.True(expectedTemperature.Equals(result, TemperatureDelta.FromKelvins(KelvinsTolerance)));
+            
+        Assert.Equal(expectedTemperature, result);
     }
 
     public static IEnumerable<object[]> TemperaturePlusTemperatureDeltaEqualsTemperatureData { get; } =
     [
-        [-10d, TemperatureUnit.DegreeCelsius, 0d, TemperatureDeltaUnit.DegreeCelsius, -10d, TemperatureUnit.DegreeCelsius],
-        [-10d, TemperatureUnit.DegreeCelsius, 10d, TemperatureDeltaUnit.DegreeCelsius, 0d, TemperatureUnit.DegreeCelsius],
-        [-10d, TemperatureUnit.DegreeCelsius, 20d, TemperatureDeltaUnit.DegreeCelsius, 10d, TemperatureUnit.DegreeCelsius],
-        [-10d, TemperatureUnit.DegreeFahrenheit, 0d, TemperatureDeltaUnit.DegreeFahrenheit, -10d, TemperatureUnit.DegreeFahrenheit],
-        [-10d, TemperatureUnit.DegreeFahrenheit, 10d, TemperatureDeltaUnit.DegreeFahrenheit, 0d, TemperatureUnit.DegreeFahrenheit],
-        [-10d, TemperatureUnit.DegreeFahrenheit, 20d, TemperatureDeltaUnit.DegreeFahrenheit, 10d, TemperatureUnit.DegreeFahrenheit]
+        [-10m, TemperatureUnit.DegreeCelsius, 0m, TemperatureDeltaUnit.DegreeCelsius, -10m, TemperatureUnit.DegreeCelsius],
+        [-10m, TemperatureUnit.DegreeCelsius, 10m, TemperatureDeltaUnit.DegreeCelsius, 0m, TemperatureUnit.DegreeCelsius],
+        [-10m, TemperatureUnit.DegreeCelsius, 20m, TemperatureDeltaUnit.DegreeCelsius, 10m, TemperatureUnit.DegreeCelsius],
+        [-10m, TemperatureUnit.DegreeFahrenheit, 0m, TemperatureDeltaUnit.DegreeFahrenheit, -10m, TemperatureUnit.DegreeFahrenheit],
+        [-10m, TemperatureUnit.DegreeFahrenheit, 10m, TemperatureDeltaUnit.DegreeFahrenheit, 0m, TemperatureUnit.DegreeFahrenheit],
+        [-10m, TemperatureUnit.DegreeFahrenheit, 20m, TemperatureDeltaUnit.DegreeFahrenheit, 10m, TemperatureUnit.DegreeFahrenheit]
     ];
 
     [Theory]
     [MemberData(nameof(TemperaturePlusTemperatureDeltaEqualsTemperatureData))]
-    public void TemperaturePlusTemperatureDeltaEqualsTemperature(double temperatureValue, TemperatureUnit temperatureUnit, double deltaValue,
-        TemperatureDeltaUnit deltaUnit, double expectedValue, TemperatureUnit expectedUnit)
+    public void TemperaturePlusTemperatureDeltaEqualsTemperature(decimal temperatureValue, TemperatureUnit temperatureUnit, decimal deltaValue,
+        TemperatureDeltaUnit deltaUnit, decimal expectedValue, TemperatureUnit expectedUnit)
     {
         var temp = new Temperature(temperatureValue, temperatureUnit);
         var delta = new TemperatureDelta(deltaValue, deltaUnit);
         var expectedTemperature = new Temperature(expectedValue, expectedUnit);
-
+            
         Temperature result = temp + delta;
-
-        Assert.True(expectedTemperature.Equals(result, TemperatureDelta.FromKelvins(KelvinsTolerance)));
+            
+        Assert.Equal(expectedTemperature, result);
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/TestsBase/QuantityTestsBase.cs b/UnitsNet.Tests/CustomCode/TestsBase/QuantityTestsBase.cs
index 4e48ed174e..fe23922a47 100644
--- a/UnitsNet.Tests/CustomCode/TestsBase/QuantityTestsBase.cs
+++ b/UnitsNet.Tests/CustomCode/TestsBase/QuantityTestsBase.cs
@@ -1,4 +1,4 @@
-using UnitsNet.Units;
+using UnitsNet.Units;
 
 namespace UnitsNet.Tests.TestsBase
 {
diff --git a/UnitsNet.Tests/CustomCode/ThermalConductivityTests.cs b/UnitsNet.Tests/CustomCode/ThermalConductivityTests.cs
index fe566b4a13..9af98ba2e5 100644
--- a/UnitsNet.Tests/CustomCode/ThermalConductivityTests.cs
+++ b/UnitsNet.Tests/CustomCode/ThermalConductivityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -29,5 +29,6 @@ public class ThermalConductivityTests : ThermalConductivityTestsBase
     {
         protected override double WattsPerMeterKelvinInOneWattPerMeterKelvin => 1;
         protected override double BtusPerHourFootFahrenheitInOneWattPerMeterKelvin => 5.77789317e-1;
+        protected override double BtusPerSecondInchFahrenheitInOneWattPerMeterKelvin => 1.33747527e-5;
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ThermalInsulanceTests.cs b/UnitsNet.Tests/CustomCode/ThermalInsulanceTests.cs
index 12acb2d0aa..596b99f4e7 100644
--- a/UnitsNet.Tests/CustomCode/ThermalInsulanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ThermalInsulanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -32,10 +32,32 @@ public class ThermalInsulanceTests : ThermalInsulanceTestsBase
        protected override double SquareMeterKelvinsPerWattInOneSquareMeterKelvinPerKilowatt => 0.001;
        protected override double SquareMillimeterKelvinsPerWattInOneSquareMeterKelvinPerKilowatt => 1000;
 
+       // TODO see about changing the base unit
+       
+       // protected override double HourSquareFeetDegreesFahrenheitPerBtuInOneSquareMeterKelvinPerWatt => 5.678263337;
+       // protected override double SquareCentimeterHourDegreesCelsiusPerKilocalorieInOneSquareMeterKelvinPerWatt => 418.68;
+       // protected override double SquareCentimeterKelvinsPerWattInOneSquareMeterKelvinPerWatt => 1e4;
+       // protected override double SquareMeterDegreesCelsiusPerWattInOneSquareMeterKelvinPerWatt => 1;
+       // protected override double SquareMeterKelvinsPerKilowattInOneSquareMeterKelvinPerWatt => 1e-3;
+       // protected override double SquareMeterKelvinsPerWattInOneSquareMeterKelvinPerWatt => 1;
+       
        [Fact(Skip = "See about changing the BaseUnit to SquareMeterKelvinPerWatt")]
        public override void BaseUnit_HasSIBase()
        {
            base.BaseUnit_HasSIBase();
        } 
+
+       [Fact]
+       public void ThermalInsulanceTimesHeatFluxEqualsTemperatureDelta()
+       {
+           ThermalInsulance thermalInsulance = ThermalInsulance.FromSquareMeterKelvinsPerWatt(2);
+           HeatFlux heatFlux = HeatFlux.FromWattsPerSquareMeter(3);
+           TemperatureDelta expected = TemperatureDelta.FromKelvins(6);
+
+           Assert.Equal(expected, thermalInsulance * heatFlux);
+           Assert.Equal(expected, heatFlux * thermalInsulance);
+           Assert.Equal(heatFlux, expected / thermalInsulance);
+           Assert.Equal(thermalInsulance, expected / heatFlux);
+       }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ThermalResistanceTests.cs b/UnitsNet.Tests/CustomCode/ThermalResistanceTests.cs
index edc5bcf4d1..b86ca50e11 100644
--- a/UnitsNet.Tests/CustomCode/ThermalResistanceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ThermalResistanceTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -26,5 +26,18 @@ public class ThermalResistanceTests : ThermalResistanceTestsBase
         protected override double KelvinsPerWattInOneKelvinPerWatt => 1;
 
         protected override double DegreesCelsiusPerWattInOneKelvinPerWatt => 1;
+
+        [Fact]
+        public void ThermalResistanceTimesPowerEqualsTemperatureDelta()
+        {
+            ThermalResistance thermalResistance = ThermalResistance.FromKelvinsPerWatt(2);
+            Power power = Power.FromWatts(3);
+            TemperatureDelta expected = TemperatureDelta.FromKelvins(6);
+
+            Assert.Equal(expected, thermalResistance * power);
+            Assert.Equal(expected, power * thermalResistance);
+            Assert.Equal(power, expected / thermalResistance);
+            Assert.Equal(thermalResistance, expected / power);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/TorqueTests.cs b/UnitsNet.Tests/CustomCode/TorqueTests.cs
index ec29e22398..7265840ed6 100644
--- a/UnitsNet.Tests/CustomCode/TorqueTests.cs
+++ b/UnitsNet.Tests/CustomCode/TorqueTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
@@ -45,6 +45,10 @@ public class TorqueTests : TorqueTestsBase
 
         protected override double NewtonMillimetersInOneNewtonMeter => 1000;
 
+        protected override double OunceForceFeetInOneNewtonMeter => 11.800994388436246;
+
+        protected override double OunceForceInchesInOneNewtonMeter => 141.61193266123496;
+
         protected override double PoundForceFeetInOneNewtonMeter => 0.737562149277;
 
         protected override double PoundForceInchesInOneNewtonMeter => 8.85074579;
diff --git a/UnitsNet.Tests/CustomCode/TurbidityTests.cs b/UnitsNet.Tests/CustomCode/TurbidityTests.cs
index fb31376ff8..39701edfee 100644
--- a/UnitsNet.Tests/CustomCode/TurbidityTests.cs
+++ b/UnitsNet.Tests/CustomCode/TurbidityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ArithmeticOperations.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ArithmeticOperations.cs
new file mode 100644
index 0000000000..0d8f9d93af
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ArithmeticOperations.cs
@@ -0,0 +1,736 @@
+using Xunit.Abstractions;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    public class ArithmeticOperatorTests
+    {
+        [Theory]
+        [ClassData(typeof(AdditionTestData))]
+        public void AdditionOperatorTests(OperatorTestCase testCase)
+        {
+            var (value1, value2, expectedValue) = testCase;
+            Assert.Multiple(() =>
+            {
+                // the operation is implemented as expected
+                Assert.Equal(expectedValue, value1 + value2);
+                Assert.Equal(expectedValue, value2 + value1);
+            }, () =>
+            {
+#if NET
+                // double-checking that the expectations are correct
+                var doubleResult = (double)value1 + (double)value2;
+                if (double.IsFinite(doubleResult))
+                {
+                    Assert.Equal((double)expectedValue, doubleResult, 15);
+                }
+                else
+                {
+                    Assert.Equal((double)expectedValue, doubleResult);
+                }
+#endif
+            });
+        }
+
+        [Fact]
+        public void UnaryIncrementOperator_IncrementsTheValueByOne()
+        {
+            var value = new QuantityValue(1, 2);
+            value++;
+            Assert.Equal(new QuantityValue(3, 2), value);
+        }
+
+        [Fact]
+        public void PlusOperator_ReturnsTheSameValue()
+        {
+            Assert.Equal(QuantityValue.One, +QuantityValue.One);
+            Assert.Equal(QuantityValue.MinusOne, +QuantityValue.MinusOne);
+            Assert.Equal(QuantityValue.Zero, +QuantityValue.Zero);
+        }
+
+        [Fact]
+        public void MinusOperator_ReturnsTheNegatedValue()
+        {
+            Assert.Equal(QuantityValue.MinusOne, -QuantityValue.One);
+            Assert.Equal(QuantityValue.One, -QuantityValue.MinusOne);
+            Assert.Equal(QuantityValue.Zero, -QuantityValue.Zero);
+        }
+
+        [Theory]
+        [ClassData(typeof(SubtractionTestData))]
+        public void SubtractionOperatorTests(OperatorTestCase testCase)
+        {
+            var (value1, value2, expectedValue) = testCase;
+            Assert.Multiple(() =>
+            {
+                // the operation is implemented as expected
+                Assert.Equal(expectedValue, value1 - value2);
+            }, () =>
+            {
+#if NET
+                // double-checking that the expectations are correct
+                var doubleResult = (double)value1 - (double)value2;
+                if (double.IsFinite(doubleResult))
+                {
+                    Assert.Equal((double)expectedValue, doubleResult, 15);
+                }
+                else
+                {
+                    Assert.Equal((double)expectedValue, doubleResult);
+                }
+#endif
+            });
+        }
+
+        [Fact]
+        public void UnaryDecrementOperator_DecrementsTheValueByOne()
+        {
+            var value = new QuantityValue(1, 2);
+            value--;
+            Assert.Equal(new QuantityValue(-1, 2), value);
+        }
+
+        [Theory]
+        [ClassData(typeof(MultiplicationTestData))]
+        public void MultiplicationOperatorTests(OperatorTestCase testCase)
+        {
+            var (value1, value2, expectedValue) = testCase;
+            Assert.Multiple(() =>
+            {
+                // the operation is implemented as expected
+                Assert.Equal(expectedValue, value1 * value2);
+                Assert.Equal(expectedValue, value2 * value1);
+            }, () =>
+            {
+#if NET
+                // double-checking that the expectations are correct
+                var doubleResult = (double)value1 * (double)value2;
+                if (double.IsFinite(doubleResult))
+                {
+                    Assert.Equal((double)expectedValue, doubleResult, 15);
+                }
+                else
+                {
+                    Assert.Equal((double)expectedValue, doubleResult);
+                }
+#endif
+            });
+        }
+
+        [Theory]
+        [ClassData(typeof(DivisionTestData))]
+        public void DivisionOperatorTests(OperatorTestCase testCase)
+        {
+            var (value1, value2, expectedValue) = testCase;
+            Assert.Multiple(() =>
+            {
+                // the operation is implemented as expected
+                Assert.Equal(expectedValue, value1 / value2);
+            }, () =>
+            {
+#if NET
+                // double-checking that the expectations are correct
+                var doubleResult = (double)value1 / (double)value2;
+                if (double.IsFinite(doubleResult))
+                {
+                    Assert.Equal((double)expectedValue, doubleResult, 14);
+                }
+                else
+                {
+                    Assert.Equal((double)expectedValue, doubleResult);
+                }
+#endif
+            });
+        }
+
+        [Theory]
+        [ClassData(typeof(ModulusTestData))]
+        public void ModulusOperatorTests(OperatorTestCase testCase)
+        {
+            var (value1, value2, expectedValue) = testCase;
+            Assert.Multiple(() =>
+            {
+                // the operation is implemented as expected
+                Assert.Equal(expectedValue, value1 % value2);
+            }, () =>
+            {
+#if NET
+                // double-checking that the expectations are correct
+                var doubleResult = (double)value1 % (double)value2;
+                if (double.IsFinite(doubleResult))
+                {
+                    Assert.Equal((double)expectedValue, doubleResult, 15);
+                }
+                else
+                {
+                    Assert.Equal((double)expectedValue, doubleResult);
+                }
+#endif
+            });
+        }
+
+        public abstract record OperatorTestCase : IXunitSerializable
+        {
+            protected OperatorTestCase(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+            {
+                Value1 = value1;
+                Value2 = value2;
+                ExpectedValue = expectedValue;
+            }
+
+            public QuantityValue Value1 { get; private set; }
+            public QuantityValue Value2 { get; private set; }
+            public QuantityValue ExpectedValue { get; private set; }
+
+            public void Deconstruct(out QuantityValue value1, out QuantityValue value2, out QuantityValue expectedValue)
+            {
+                value1 = Value1;
+                value2 = Value2;
+                expectedValue = ExpectedValue;
+            }
+
+            #region Implementation of IXunitSerializable
+
+            public OperatorTestCase()
+            {
+            }
+
+            public void Serialize(IXunitSerializationInfo info)
+            {
+                info.AddValue("v1", (QuantityValueData)Value1);
+                info.AddValue("v2", (QuantityValueData)Value2);
+                info.AddValue("expected", (QuantityValueData)ExpectedValue);
+            }
+
+            public void Deserialize(IXunitSerializationInfo info)
+            {
+                Value1 = info.GetValue<QuantityValueData>("v1");
+                Value2 = info.GetValue<QuantityValueData>("v2");
+                ExpectedValue = info.GetValue<QuantityValueData>("expected");
+            }
+
+            #endregion
+        }
+
+        public sealed class AdditionTestData : TheoryData<OperatorTestCase>
+        {
+            public AdditionTestData()
+            {
+                // zero
+                Add(QuantityValue.Zero, new QuantityValue(0, 10), QuantityValue.Zero);
+                Add(QuantityValue.Zero, QuantityValue.One, QuantityValue.One);
+                Add(QuantityValue.Zero, QuantityValue.MinusOne, QuantityValue.MinusOne);
+
+                // positive
+                // 4.2 + 0.5 = 4.7
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(1, 2),
+                    new QuantityValue(47, 10));
+                // 4.2 + (-0.333..) = 3.666..
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(-1, 3),
+                    new QuantityValue(116, 30));
+
+                // negative
+                // -4.2 + 0.5 = -3.7
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(1, 2),
+                    new QuantityValue(-37, 10));
+
+                // -4.2 + (-0.333..) = -4.533..
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(-1, 3),
+                    new QuantityValue(-136, 30));
+
+                // positive infinity
+                Add(QuantityValue.PositiveInfinity, QuantityValue.Zero, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, QuantityValue.One, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, QuantityValue.MinusOne, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, new QuantityValue(10, 0), QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, new QuantityValue(-10, 0), QuantityValue.NaN);
+
+                // negative infinity
+                Add(QuantityValue.NegativeInfinity, QuantityValue.Zero, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.NegativeInfinity, QuantityValue.One, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.NegativeInfinity, QuantityValue.MinusOne, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.NegativeInfinity, new QuantityValue(-10, 0), QuantityValue.NegativeInfinity);
+                Add(QuantityValue.NegativeInfinity, new QuantityValue(10, 0), QuantityValue.NaN);
+
+                // NaN
+                Add(QuantityValue.NaN, QuantityValue.NaN, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.Zero, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.One, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.MinusOne, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.PositiveInfinity, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.NegativeInfinity, QuantityValue.NaN);
+            }
+
+            private void Add(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+            {
+                Add(new AdditionOperationTestCase(value1, value2, expectedValue));
+            }
+
+            public sealed record AdditionOperationTestCase : OperatorTestCase
+            {
+                public AdditionOperationTestCase()
+                {
+                }
+
+                public AdditionOperationTestCase(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+                    : base(value1, value2, expectedValue)
+                {
+                }
+
+                public override string ToString()
+                {
+                    // return $"{Value1} + {Value2} = {ExpectedValue}";
+                    return $"{Value1.Numerator}/{Value1.Denominator} + {Value2.Numerator}/{Value2.Denominator} = {ExpectedValue.Numerator}/{ExpectedValue.Denominator}";
+                }
+            }
+        }
+
+        public sealed class SubtractionTestData : TheoryData<OperatorTestCase>
+        {
+            public SubtractionTestData()
+            {
+                // zero
+                Add(QuantityValue.Zero, new QuantityValue(0, 10), QuantityValue.Zero);
+                Add(QuantityValue.Zero, QuantityValue.One, QuantityValue.MinusOne);
+                Add(QuantityValue.Zero, QuantityValue.MinusOne, QuantityValue.One);
+
+                // positive
+                // 4.2 - 0.5 = 3.7
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(1, 2),
+                    new QuantityValue(37, 10));
+                // 4.2 - (-0.333..) = 4.533..
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(-1, 3),
+                    new QuantityValue(136, 30));
+
+                // negative
+                // -4.2 - 0.5 = -4.7
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(1, 2),
+                    new QuantityValue(-47, 10));
+
+                // -4.2 - (-0.333..) = -3.866..
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(-1, 3),
+                    new QuantityValue(-116, 30));
+
+                // positive infinity
+                Add(QuantityValue.PositiveInfinity, QuantityValue.Zero, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, QuantityValue.One, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, QuantityValue.MinusOne, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, new QuantityValue(10, 0), QuantityValue.NaN);
+                Add(QuantityValue.PositiveInfinity, new QuantityValue(-10, 0), QuantityValue.PositiveInfinity);
+
+                // negative infinity
+                Add(QuantityValue.NegativeInfinity, QuantityValue.Zero, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.NegativeInfinity, QuantityValue.One, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.NegativeInfinity, QuantityValue.MinusOne, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.NegativeInfinity, new QuantityValue(-10, 0), QuantityValue.NaN);
+                Add(QuantityValue.NegativeInfinity, new QuantityValue(10, 0), QuantityValue.NegativeInfinity);
+
+                // NaN
+                Add(QuantityValue.NaN, QuantityValue.NaN, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.Zero, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.One, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.MinusOne, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.PositiveInfinity, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.NegativeInfinity, QuantityValue.NaN);
+            }
+
+            private void Add(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+            {
+                Add(new SubtractionOperationTestCase(value1, value2, expectedValue));
+            }
+
+            public sealed record SubtractionOperationTestCase : OperatorTestCase
+            {
+                public SubtractionOperationTestCase()
+                {
+                }
+
+                public SubtractionOperationTestCase(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+                    : base(value1, value2, expectedValue)
+                {
+                }
+
+                public override string ToString()
+                {
+                    // return $"{Value1} - {Value2} = {ExpectedValue}";
+                    return $"{Value1.Numerator}/{Value1.Denominator} - {Value2.Numerator}/{Value2.Denominator} = {ExpectedValue.Numerator}/{ExpectedValue.Denominator}";
+                }
+            }
+        }
+
+        public sealed class MultiplicationTestData : TheoryData<OperatorTestCase>
+        {
+            public MultiplicationTestData()
+            {
+                // zero
+                Add(QuantityValue.Zero, new QuantityValue(0, 10), QuantityValue.Zero);
+                Add(QuantityValue.Zero, QuantityValue.One, QuantityValue.Zero);
+                Add(QuantityValue.Zero, QuantityValue.MinusOne, QuantityValue.Zero);
+
+                // positive
+                // 4.2 * 0.5 = 2.1
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(1, 2),
+                    new QuantityValue(21, 10));
+                // 4.2 * (-0.333..) = -1.4
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(-1, 3),
+                    new QuantityValue(-14, 10));
+
+                // negative
+                // -4.2 * 0.5 = -2.1
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(1, 2),
+                    new QuantityValue(-21, 10));
+
+                // -4.2 * (-0.333..) = 1.4
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(-1, 3),
+                    new QuantityValue(14, 10));
+
+                // positive infinity
+                Add(QuantityValue.PositiveInfinity, QuantityValue.Zero, QuantityValue.NaN);
+                Add(QuantityValue.PositiveInfinity, QuantityValue.One, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, QuantityValue.MinusOne, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.PositiveInfinity, new QuantityValue(10, 0), QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, new QuantityValue(-10, 0), QuantityValue.NegativeInfinity);
+
+                // negative infinity
+                Add(QuantityValue.NegativeInfinity, QuantityValue.Zero, QuantityValue.NaN);
+                Add(QuantityValue.NegativeInfinity, QuantityValue.One, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.NegativeInfinity, QuantityValue.MinusOne, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.NegativeInfinity, new QuantityValue(-10, 0), QuantityValue.PositiveInfinity);
+                Add(QuantityValue.NegativeInfinity, new QuantityValue(10, 0), QuantityValue.NegativeInfinity);
+
+                // NaN
+                Add(QuantityValue.NaN, QuantityValue.NaN, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.Zero, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.One, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.MinusOne, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.PositiveInfinity, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.NegativeInfinity, QuantityValue.NaN);
+            }
+
+            private void Add(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+            {
+                Add(new MultiplicationOperationTestCase(value1, value2, expectedValue));
+            }
+
+            public sealed record MultiplicationOperationTestCase : OperatorTestCase
+            {
+                public MultiplicationOperationTestCase()
+                {
+                }
+
+                public MultiplicationOperationTestCase(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+                    : base(value1, value2, expectedValue)
+                {
+                }
+
+                public override string ToString()
+                {
+                    // return $"{Value1} * {Value2} = {ExpectedValue}";
+                    return $"{Value1.Numerator}/{Value1.Denominator} * {Value2.Numerator}/{Value2.Denominator} = {ExpectedValue.Numerator}/{ExpectedValue.Denominator}";
+                }
+            }
+        }
+
+        public sealed class DivisionTestData : TheoryData<OperatorTestCase>
+        {
+            public DivisionTestData()
+            {
+                // zero
+                Add(QuantityValue.Zero, new QuantityValue(0, 10), QuantityValue.NaN);
+                Add(QuantityValue.Zero, QuantityValue.NaN, QuantityValue.NaN);
+                Add(QuantityValue.Zero, QuantityValue.One, QuantityValue.Zero);
+                Add(QuantityValue.Zero, QuantityValue.MinusOne, QuantityValue.Zero);
+
+                // division by zero
+                Add(QuantityValue.One, QuantityValue.Zero, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.MinusOne, QuantityValue.Zero, QuantityValue.NegativeInfinity);
+
+                #region positive / positive
+
+                // 4.2 / 1 = 8.4
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(1, 1),
+                    new QuantityValue(42, 10));
+
+                // 4.2 / 0.5 = 8.4
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(1, 2),
+                    new QuantityValue(84, 10));
+
+                // 4.2 / 1.5 = 2.8
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(3, 2),
+                    new QuantityValue(28, 10));
+
+                // 4.2 / 2 = 2.1
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(2, 1),
+                    new QuantityValue(21, 10));
+
+                // 42 / 2 = 21
+                Add(new QuantityValue(42, 1),
+                    new QuantityValue(2, 1),
+                    new QuantityValue(21, 1));
+
+                // 1 / 45.6 = {10/456}
+                Add(new QuantityValue(1, 1),
+                    new QuantityValue(456, 10),
+                    new QuantityValue(10, 456));
+
+                // 0.025 / 0.01 = 2.5
+                Add(new QuantityValue(1, 40),
+                    new QuantityValue(1, 100),
+                    new QuantityValue(100, 40));
+
+                // 0.05 / 0.01 = 5
+                Add(new QuantityValue(2, 40),
+                    new QuantityValue(1, 100),
+                    new QuantityValue(200, 40));
+
+                // 0.25 / 4.2 = {5/84}
+                Add(new QuantityValue(1, 4),
+                    new QuantityValue(42, 10),
+                    new QuantityValue(5, 84));
+
+                // 0.33.. / 4.2 = {10/126}
+                Add(new QuantityValue(1, 3),
+                    new QuantityValue(42, 10),
+                    new QuantityValue(10, 126));
+
+                // 0.5 / 4.2 = {10/84}
+                Add(new QuantityValue(1, 2),
+                    new QuantityValue(42, 10),
+                    new QuantityValue(10, 84));
+
+                // 1.5 / 4.2 = {30/84}
+                Add(new QuantityValue(3, 2),
+                    new QuantityValue(42, 10),
+                    new QuantityValue(30, 84));
+
+                // 123 / 45.6 = {1230/456}
+                Add(new QuantityValue(123, 1),
+                    new QuantityValue(456, 10),
+                    new QuantityValue(1230, 456));
+
+                #endregion
+
+                #region positive / negative
+
+                // 4.2 / -0.333.. = -12.6
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(-1, 3),
+                    new QuantityValue(-126, 10));
+
+                // 4.2 / -0.5 = -8.4
+                Add(new QuantityValue(42, 10),
+                    new QuantityValue(-1, 2),
+                    new QuantityValue(-84, 10));
+
+                // 0.01 / -0.05 = -0.2
+                Add(new QuantityValue(1, 100),
+                    new QuantityValue(-2, 40),
+                    new QuantityValue(-40, 200));
+
+                #endregion
+
+                #region negative / positive
+
+                // -4.2 / 1 = -8.4
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(1, 1),
+                    new QuantityValue(-42, 10));
+
+                // -4.2 / 0.5 = -8.4
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(1, 2),
+                    new QuantityValue(-84, 10));
+
+                // -4.2 / 1.5 = 2.8
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(3, 2),
+                    new QuantityValue(-28, 10));
+
+                // -4.2 / 2 = -2.1
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(2, 1),
+                    new QuantityValue(-21, 10));
+
+                // -42 / 2 = -21
+                Add(new QuantityValue(-42, 1),
+                    new QuantityValue(2, 1),
+                    new QuantityValue(-21, 1));
+
+                // -1 / 45.6 = {10/456}
+                Add(new QuantityValue(-1, 1),
+                    new QuantityValue(456, 10),
+                    new QuantityValue(-10, 456));
+
+                // -0.025 / 0.01 = 2.5
+                Add(new QuantityValue(-1, 40),
+                    new QuantityValue(1, 100),
+                    new QuantityValue(-100, 40));
+
+                // -0.05 / 0.01 = 5
+                Add(new QuantityValue(-2, 40),
+                    new QuantityValue(1, 100),
+                    new QuantityValue(-200, 40));
+
+                // -0.25 / 4.2 = {5/84}
+                Add(new QuantityValue(-1, 4),
+                    new QuantityValue(42, 10),
+                    new QuantityValue(-5, 84));
+
+                // -0.33.. / 4.2 = {10/126}
+                Add(new QuantityValue(-1, 3),
+                    new QuantityValue(42, 10),
+                    new QuantityValue(-10, 126));
+
+                // -0.5 / 4.2 = {-10/84}
+                Add(new QuantityValue(-1, 2),
+                    new QuantityValue(42, 10),
+                    new QuantityValue(-10, 84));
+
+                // -1.5 / 4.2 = {-30/84}
+                Add(new QuantityValue(-3, 2),
+                    new QuantityValue(42, 10),
+                    new QuantityValue(-30, 84));
+
+                // -123 / 45.6 = {-1230/456}
+                Add(new QuantityValue(-123, 1),
+                    new QuantityValue(456, 10),
+                    new QuantityValue(-1230, 456));
+
+                #endregion
+
+                #region negative / negative
+
+                // -4.2 / (-0.333..) = 12.6
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(-1, 3),
+                    new QuantityValue(126, 10));
+
+                // -4.2 / -0.5 = 8.4
+                Add(new QuantityValue(-42, 10),
+                    new QuantityValue(-1, 2),
+                    new QuantityValue(84, 10));
+
+                // -0.01 / -0.05 = 0.2
+                Add(new QuantityValue(-1, 100),
+                    new QuantityValue(-2, 40),
+                    new QuantityValue(40, 200));
+
+                #endregion
+
+                // positive infinity
+                Add(QuantityValue.PositiveInfinity, QuantityValue.Zero, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, QuantityValue.One, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.PositiveInfinity, QuantityValue.MinusOne, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.PositiveInfinity, new QuantityValue(10, 0), QuantityValue.NaN);
+                Add(QuantityValue.PositiveInfinity, new QuantityValue(-10, 0), QuantityValue.NaN);
+
+                // division by positive infinity
+                Add(QuantityValue.Zero, QuantityValue.PositiveInfinity, QuantityValue.Zero);
+                Add(QuantityValue.One, QuantityValue.PositiveInfinity, QuantityValue.Zero);
+                Add(QuantityValue.MinusOne, QuantityValue.PositiveInfinity, QuantityValue.Zero);
+
+                // negative infinity
+                Add(QuantityValue.NegativeInfinity, QuantityValue.Zero, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.NegativeInfinity, QuantityValue.One, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.NegativeInfinity, QuantityValue.MinusOne, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.NegativeInfinity, new QuantityValue(-10, 0), QuantityValue.NaN);
+                Add(QuantityValue.NegativeInfinity, new QuantityValue(10, 0), QuantityValue.NaN);
+
+                // division by negative infinity
+                Add(QuantityValue.Zero, QuantityValue.NegativeInfinity, QuantityValue.Zero);
+                Add(QuantityValue.One, QuantityValue.NegativeInfinity, QuantityValue.Zero);
+                Add(QuantityValue.MinusOne, QuantityValue.NegativeInfinity, QuantityValue.Zero);
+
+                // NaN
+                Add(QuantityValue.NaN, QuantityValue.NaN, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.Zero, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.One, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.MinusOne, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.PositiveInfinity, QuantityValue.NaN);
+                Add(QuantityValue.NaN, QuantityValue.NegativeInfinity, QuantityValue.NaN);
+            }
+
+            private void Add(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+            {
+                Add(new DivisionOperationTestCase(value1, value2, expectedValue));
+            }
+
+            public sealed record DivisionOperationTestCase : OperatorTestCase
+            {
+                public DivisionOperationTestCase()
+                {
+                }
+
+                public DivisionOperationTestCase(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+                    : base(value1, value2, expectedValue)
+                {
+                }
+
+                public override string ToString()
+                {
+                    // return $"{Value1} / {Value2} = {ExpectedValue}";
+                    return $"{Value1.Numerator}/{Value1.Denominator} / {Value2.Numerator}/{Value2.Denominator} = {ExpectedValue.Numerator}/{ExpectedValue.Denominator}";
+                }
+            }
+        }
+
+        public sealed class ModulusTestData : TheoryData<OperatorTestCase>
+        {
+            public ModulusTestData()
+            {
+                Add(QuantityValue.One, QuantityValue.Zero, QuantityValue.NaN);
+                Add(QuantityValue.Zero, QuantityValue.NaN, QuantityValue.NaN);
+                Add(QuantityValue.Zero, QuantityValue.One, QuantityValue.Zero);
+                Add(QuantityValue.PositiveInfinity, QuantityValue.One, QuantityValue.NaN);
+                Add(QuantityValue.NegativeInfinity, QuantityValue.One, QuantityValue.NaN);
+                Add(QuantityValue.One, QuantityValue.PositiveInfinity, QuantityValue.One);
+                Add(QuantityValue.One, QuantityValue.NegativeInfinity, QuantityValue.One);
+                Add(1, 2, 1);
+                Add(new QuantityValue(1, 2), new QuantityValue(1, 5), new QuantityValue(1, 10));
+                Add(new QuantityValue(1, 4), new QuantityValue(1, 2), new QuantityValue(1, 4));
+                Add(new QuantityValue(1, 2), new QuantityValue(1, 4), QuantityValue.Zero);
+                Add(new QuantityValue(1, 4), new QuantityValue(1, 10), new QuantityValue(5, 100));
+            }
+
+            private void Add(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+            {
+                Add(new ModulusOperationTestCase(value1, value2, expectedValue));
+            }
+
+            public sealed record ModulusOperationTestCase : OperatorTestCase
+            {
+                public ModulusOperationTestCase()
+                {
+                }
+
+                public ModulusOperationTestCase(QuantityValue value1, QuantityValue value2, QuantityValue expectedValue)
+                    : base(value1, value2, expectedValue)
+                {
+                }
+
+                public override string ToString()
+                {
+                    // return $"{Value1} % {Value2} = {ExpectedValue}";
+                    return $"{Value1.Numerator}/{Value1.Denominator} % {Value2.Numerator}/{Value2.Denominator} = {ExpectedValue.Numerator}/{ExpectedValue.Denominator}";
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ComparisonOperations.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ComparisonOperations.cs
new file mode 100644
index 0000000000..ae25eca1eb
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ComparisonOperations.cs
@@ -0,0 +1,482 @@
+using System.Diagnostics.CodeAnalysis;
+using Xunit.Abstractions;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    public static class ComparisonTests
+    {
+        #region Test cases
+
+        /// <summary>
+        ///     Represents a pair of <see cref="QuantityValue" /> instances that are considered equal for comparison purposes.
+        /// </summary>
+        /// <remarks>
+        ///     This record is used in unit tests to validate equality and comparison operations between two
+        ///     <see cref="QuantityValue" /> instances.
+        ///     It implements <see cref="IXunitSerializable" /> to support serialization and deserialization of test data.
+        /// </remarks>
+        public sealed record EqualValuesPair : IXunitSerializable
+        {
+            public EqualValuesPair(QuantityValue value1, QuantityValue value2)
+            {
+                Value1 = value1;
+                Value2 = value2;
+            }
+
+            public QuantityValue Value1 { get; private set; }
+
+            public QuantityValue Value2 { get; private set; }
+
+            public void Deconstruct(out QuantityValue value1, out QuantityValue value2)
+            {
+                value1 = Value1;
+                value2 = Value2;
+            }
+
+            public override string ToString()
+            {
+                return $"{Value1.Numerator}/{Value1.Denominator} == {Value2.Numerator}/{Value2.Denominator}";
+            }
+
+            #region Implementation of IXunitSerializable
+
+            public EqualValuesPair()
+            {
+            }
+
+            public void Serialize(IXunitSerializationInfo info)
+            {
+                info.AddValue("v1", (QuantityValueData)Value1);
+                info.AddValue("v2", (QuantityValueData)Value2);
+            }
+
+            public void Deserialize(IXunitSerializationInfo info)
+            {
+                Value1 = info.GetValue<QuantityValueData>("v1");
+                Value2 = info.GetValue<QuantityValueData>("v2");
+            }
+
+            #endregion
+        }
+
+        /// <summary>
+        ///     Provides a collection of test cases for verifying the equality of <see cref="QuantityValue" /> instances.
+        /// </summary>
+        /// <remarks>
+        ///     This class is used in unit tests to supply pairs of <see cref="QuantityValue" /> instances that are expected to be
+        ///     equal.
+        ///     It extends <see cref="TheoryData{T}" /> to facilitate parameterized testing with xUnit.
+        /// </remarks>
+        public sealed class EqualTestCases : TheoryData<EqualValuesPair>
+        {
+            public EqualTestCases()
+            {
+                Add(QuantityValue.PositiveInfinity, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.NegativeInfinity, QuantityValue.NegativeInfinity);
+                Add(QuantityValue.Zero, QuantityValue.Zero);
+                Add(QuantityValue.Zero, new QuantityValue(0, 2));
+                Add(new QuantityValue(0, 2), QuantityValue.Zero);
+                Add(QuantityValue.One, new QuantityValue(2, 2));
+                Add(QuantityValue.MinusOne, new QuantityValue(-2, 2));
+                Add(new QuantityValue(1, 2), new QuantityValue(2, 4));
+                Add(new QuantityValue(-1, 2), new QuantityValue(-2, 4));
+                Add(42, 42);
+                Add(-42, -42);
+            }
+
+            private void Add(QuantityValue value1, QuantityValue value2)
+            {
+                Add(new EqualValuesPair(value1, value2));
+            }
+        }
+
+        /// <summary>
+        ///     Represents a pair of unequal <see cref="QuantityValue" /> instances, where one value is smaller than the other.
+        /// </summary>
+        /// <remarks>
+        ///     This record is used in unit tests to validate comparison operations between <see cref="QuantityValue" /> instances.
+        ///     It implements <see cref="IXunitSerializable" /> to support serialization and deserialization for test cases.
+        /// </remarks>
+        public sealed record UnequalValuesPair : IXunitSerializable
+        {
+            public UnequalValuesPair(QuantityValue smaller, QuantityValue larger)
+            {
+                Smaller = smaller;
+                Larger = larger;
+            }
+
+            public QuantityValue Smaller { get; private set; }
+
+            public QuantityValue Larger { get; private set; }
+
+            public void Deconstruct(out QuantityValue smaller, out QuantityValue larger)
+            {
+                smaller = Smaller;
+                larger = Larger;
+            }
+
+            public override string ToString()
+            {
+                return $"{Smaller.Numerator}/{Smaller.Denominator} < {Larger.Numerator}/{Larger.Denominator}";
+            }
+
+            #region Implementation of IXunitSerializable
+
+            public UnequalValuesPair()
+            {
+            }
+
+            public void Serialize(IXunitSerializationInfo info)
+            {
+                info.AddValue("v1", (QuantityValueData)Smaller);
+                info.AddValue("v2", (QuantityValueData)Larger);
+            }
+
+            public void Deserialize(IXunitSerializationInfo info)
+            {
+                Smaller = info.GetValue<QuantityValueData>("v1");
+                Larger = info.GetValue<QuantityValueData>("v2");
+            }
+
+            #endregion
+        }
+
+        /// <summary>
+        ///     Provides a collection of test cases for validating the behavior of comparison operations
+        ///     between unequal <see cref="QuantityValue" /> instances.
+        /// </summary>
+        /// <remarks>
+        ///     This class is used in unit tests to supply pairs of <see cref="QuantityValue" /> instances
+        ///     where one value is smaller than the other. It extends <see cref="TheoryData{T}" /> to
+        ///     facilitate parameterized tests with <see cref="Xunit.TheoryAttribute" />.
+        /// </remarks>
+        public sealed class UnequalTestCases : TheoryData<UnequalValuesPair>
+        {
+            public UnequalTestCases()
+            {
+                Add(QuantityValue.NegativeInfinity, QuantityValue.PositiveInfinity);
+                Add(QuantityValue.NegativeInfinity, new QuantityValue(1, 2));
+                Add(new QuantityValue(1, 2), QuantityValue.PositiveInfinity);
+                Add(QuantityValue.Zero, QuantityValue.One);
+                Add(QuantityValue.MinusOne, QuantityValue.Zero);
+                Add(QuantityValue.MinusOne, QuantityValue.One);
+                Add(QuantityValue.Zero, new QuantityValue(1, 2));
+                Add(new QuantityValue(-1, 2), QuantityValue.Zero);
+                Add(new QuantityValue(-1, 2), new QuantityValue(2, 4));
+                Add(new QuantityValue(1, 3), new QuantityValue(1, 2));
+                Add(new QuantityValue(-1, 2), new QuantityValue(-1, 3));
+                Add(new QuantityValue(3, 2), new QuantityValue(2, 1));
+                Add(new QuantityValue(-2, 1), new QuantityValue(-3, 2));
+                Add(new QuantityValue(3, 5), new QuantityValue(2, 3));
+                Add(new QuantityValue(-2, 3), new QuantityValue(-3, 5));
+                Add(new QuantityValue(2, 3), new QuantityValue(4, 5));
+                Add(new QuantityValue(-4, 5), new QuantityValue(-2, 3));
+                Add(new QuantityValue(4, 2), new QuantityValue(9, 4));
+                Add(new QuantityValue(-9, 4), new QuantityValue(-4, 2));
+                Add(new QuantityValue(8, 5), new QuantityValue(4, 2));
+                Add(new QuantityValue(-4, 2), new QuantityValue(-8, 5));
+                Add(42, 43);
+                Add(-43, -42);
+            }
+
+            private void Add(QuantityValue value1, QuantityValue value2)
+            {
+                Add(new UnequalValuesPair(value1, value2));
+            }
+        }
+
+        #endregion
+
+        public class EqualityContractTests
+        {
+            [Fact]
+            [SuppressMessage("ReSharper", "EqualExpressionComparison")]
+            [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
+            public void Equals_WithNaN_ReturnsTrue()
+            {
+                Assert.True(double.NaN.Equals(double.NaN));
+                Assert.True(QuantityValue.NaN.Equals(QuantityValue.NaN));
+            }
+
+            [Fact]
+            public void Equals_WithAnotherType_ReturnsFalse()
+            {
+                // ReSharper disable once SuspiciousTypeConversion.Global
+                Assert.False(QuantityValue.Zero.Equals("text"));
+            }
+
+            [Fact]
+            public void Equals_WithNull_ReturnsFalse()
+            {
+                Assert.False(QuantityValue.Zero.Equals(null));
+            }
+
+            [Theory]
+            [ClassData(typeof(EqualTestCases))]
+            public void Equals_WithSameValueAsObject_ReturnsTrue(EqualValuesPair test)
+            {
+                Assert.True(test.Value1.Equals((object)test.Value2));
+                Assert.True(test.Value2.Equals((object)test.Value1));
+            }
+
+            [Theory]
+            [ClassData(typeof(UnequalTestCases))]
+            public void Equals_WithAnotherValueAsObject_ReturnsFalse(UnequalValuesPair test)
+            {
+                Assert.False(test.Smaller.Equals((object)test.Larger));
+                Assert.False(test.Larger.Equals((object)test.Smaller));
+            }
+
+            [Theory]
+            [ClassData(typeof(EqualTestCases))]
+            public void GetHashCode_WithSameValues_ReturnsTheSameCode(EqualValuesPair test)
+            {
+                Assert.Equal(test.Value1.GetHashCode(), test.Value2.GetHashCode());
+            }
+        }
+
+        public class EqualityOperatorTests
+        {
+            [Theory]
+            [ClassData(typeof(EqualTestCases))]
+            public void EqualityOperator_WithEqualValues_ReturnsTrue(EqualValuesPair testCase)
+            {
+                Assert.True(testCase.Value1 == testCase.Value2);
+                Assert.True(testCase.Value2 == testCase.Value1);
+            }
+
+            [Theory]
+            [ClassData(typeof(UnequalTestCases))]
+            public void EqualityOperator_WithDifferentValues_ReturnsFalse(UnequalValuesPair testCase)
+            {
+                Assert.False(testCase.Smaller == testCase.Larger);
+                Assert.False(testCase.Larger == testCase.Smaller);
+            }
+
+            [Fact]
+            [SuppressMessage("ReSharper", "EqualExpressionComparison")]
+            [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
+            public void EqualityOperator_WithNaN_ReturnsFalse()
+            {
+#pragma warning disable CS1718
+                Assert.False(double.NaN == double.NaN);
+#pragma warning restore CS1718
+
+                Assert.Multiple(
+                    () => Assert.False(QuantityValue.NaN == QuantityValue.NaN),
+                    () => Assert.False(QuantityValue.Zero == QuantityValue.NaN),
+                    () => Assert.False(QuantityValue.NaN == QuantityValue.Zero));
+            }
+
+            [Theory]
+            [ClassData(typeof(EqualTestCases))]
+            public void InequalityOperator_WithEqualValues_ReturnsFalse(EqualValuesPair testCase)
+            {
+                Assert.False(testCase.Value1 != testCase.Value2);
+                Assert.False(testCase.Value2 != testCase.Value1);
+            }
+
+            [Theory]
+            [ClassData(typeof(UnequalTestCases))]
+            public void InequalityOperator_WithDifferentValues_ReturnsTrue(UnequalValuesPair testCase)
+            {
+                Assert.True(testCase.Smaller != testCase.Larger);
+                Assert.True(testCase.Larger != testCase.Smaller);
+            }
+
+            [Fact]
+            [SuppressMessage("ReSharper", "EqualExpressionComparison")]
+            [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
+            public void InequalityOperator_WithNaN_ReturnsTrue()
+            {
+#pragma warning disable CS1718
+                Assert.True(double.NaN != double.NaN);
+#pragma warning restore CS1718
+
+                Assert.Multiple(
+                    () => Assert.True(QuantityValue.NaN != QuantityValue.NaN),
+                    () => Assert.True(QuantityValue.Zero != QuantityValue.NaN),
+                    () => Assert.True(QuantityValue.NaN != QuantityValue.Zero));
+            }
+        }
+
+        public class ComparableContractTests
+        {
+            [Fact]
+            [SuppressMessage("ReSharper", "EqualExpressionComparison")]
+            [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
+            public void CompareTo_WithNaN_ReturnsZero()
+            {
+                Assert.Equal(0, double.NaN.CompareTo(double.NaN));
+                Assert.Equal(0, QuantityValue.NaN.CompareTo(QuantityValue.NaN));
+            }
+
+            [Fact]
+            public void CompareTo_WithAnotherType_ThrowsArgumentException()
+            {
+                Assert.Throws<ArgumentException>(() => QuantityValue.Zero.CompareTo("text"));
+            }
+
+            [Fact]
+            public void CompareTo_WithNull_ReturnsOne()
+            {
+                Assert.Equal(1, double.NegativeInfinity.CompareTo(null));
+                Assert.Equal(1, QuantityValue.NegativeInfinity.CompareTo(null));
+            }
+
+            [Theory]
+            [ClassData(typeof(EqualTestCases))]
+            public void CompareTo_WithSameValueAsObject_ReturnsZero(EqualValuesPair test)
+            {
+                Assert.Equal(0, test.Value1.CompareTo((object)test.Value2));
+            }
+
+            [Theory]
+            [ClassData(typeof(UnequalTestCases))]
+            public void CompareTo_WithLargerValueAsObject_ReturnsOne(UnequalValuesPair test)
+            {
+                Assert.Equal(1, test.Larger.CompareTo((object)test.Smaller));
+            }
+
+            [Theory]
+            [ClassData(typeof(UnequalTestCases))]
+            public void CompareTo_WithSmallerValueAsObject_ReturnsMinusOne(UnequalValuesPair test)
+            {
+                Assert.Equal(-1, test.Smaller.CompareTo((object)test.Larger));
+            }
+        }
+
+        public class ComparisonOperatorTests
+        {
+            [Theory]
+            [ClassData(typeof(EqualTestCases))]
+            public void SmallerThanOperator_WithEqualValues_ReturnsFalse(EqualValuesPair testCase)
+            {
+                Assert.False(testCase.Value1 < testCase.Value2);
+                Assert.False(testCase.Value2 < testCase.Value1);
+            }
+
+            [Theory]
+            [ClassData(typeof(UnequalTestCases))]
+            public void SmallerThanOperator_WithDifferentValues_ReturnsTheExpectedResult(UnequalValuesPair testCase)
+            {
+                Assert.True(testCase.Smaller < testCase.Larger);
+                Assert.False(testCase.Larger < testCase.Smaller);
+            }
+
+            [Fact]
+            [SuppressMessage("ReSharper", "EqualExpressionComparison")]
+            public void SmallerThanOperator_WithNaN_ReturnsFalse()
+            {
+                Assert.Multiple(
+                    () => Assert.False(QuantityValue.NaN < QuantityValue.NaN),
+                    () => Assert.False(QuantityValue.NegativeInfinity < QuantityValue.NaN),
+                    () => Assert.False(QuantityValue.NaN < QuantityValue.PositiveInfinity),
+#pragma warning disable CS1718
+                    () => Assert.False(double.NaN < double.NaN),
+#pragma warning restore CS1718
+                    () => Assert.False(double.NegativeInfinity < double.NaN),
+                    () => Assert.False(double.NaN < double.PositiveInfinity));
+            }
+
+            [Theory]
+            [ClassData(typeof(EqualTestCases))]
+            public void SmallerThanOrEqualsOperator_WithEqualValues_ReturnsTrue(EqualValuesPair testCase)
+            {
+                Assert.True(testCase.Value1 <= testCase.Value2);
+                Assert.True(testCase.Value2 <= testCase.Value1);
+            }
+
+            [Theory]
+            [ClassData(typeof(UnequalTestCases))]
+            public void SmallerThanOrEqualsOperator_WithDifferentValues_ReturnsTheExpectedResult(UnequalValuesPair testCase)
+            {
+                Assert.True(testCase.Smaller <= testCase.Larger);
+                Assert.False(testCase.Larger <= testCase.Smaller);
+            }
+
+            [Fact]
+            [SuppressMessage("ReSharper", "EqualExpressionComparison")]
+            public void SmallerThanOrEqualsOperator_WithNaN_ReturnsFalse()
+            {
+#pragma warning disable CS1718
+                Assert.False(double.NaN <= double.NaN);
+#pragma warning disable CS1718
+                Assert.False(double.NegativeInfinity <= double.NaN);
+                Assert.False(double.NaN <= double.PositiveInfinity);
+                
+                Assert.Multiple(
+                    () => Assert.False(QuantityValue.NaN <= QuantityValue.NaN),
+                    () => Assert.False(QuantityValue.NegativeInfinity <= QuantityValue.NaN),
+                    () => Assert.False(QuantityValue.NaN <= QuantityValue.PositiveInfinity));
+            }
+
+
+            [Theory]
+            [ClassData(typeof(EqualTestCases))]
+            public void LargerThanOperator_WithEqualValues_ReturnsFalse(EqualValuesPair testCase)
+            {
+                Assert.False(testCase.Value1 > testCase.Value2);
+                Assert.False(testCase.Value2 > testCase.Value1);
+            }
+
+            [Theory]
+            [ClassData(typeof(UnequalTestCases))]
+            public void LargerThanOperator_WithDifferentValues_ReturnsTheExpectedResult(UnequalValuesPair testCase)
+            {
+                Assert.True(testCase.Larger > testCase.Smaller);
+                Assert.False(testCase.Smaller > testCase.Larger);
+            }
+
+            [Fact]
+            [SuppressMessage("ReSharper", "EqualExpressionComparison")]
+            public void LargerThanOperator_WithNaN_ReturnsFalse()
+            {
+#pragma warning disable CS1718
+                Assert.False(double.NaN > double.NaN);
+#pragma warning disable CS1718
+                Assert.False(double.PositiveInfinity > double.NaN);
+                Assert.False(double.NaN > double.NegativeInfinity);
+                
+                Assert.Multiple(
+                    () => Assert.False(QuantityValue.NaN > QuantityValue.NaN),
+                    () => Assert.False(QuantityValue.PositiveInfinity > QuantityValue.NaN),
+                    () => Assert.False(QuantityValue.NaN > QuantityValue.NegativeInfinity));
+            }
+
+            [Theory]
+            [ClassData(typeof(EqualTestCases))]
+            public void LargerThanOrEqualsOperator_WithEqualValues_ReturnsTrue(EqualValuesPair testCase)
+            {
+                Assert.True(testCase.Value1 >= testCase.Value2);
+                Assert.True(testCase.Value2 >= testCase.Value1);
+            }
+
+            [Theory]
+            [ClassData(typeof(UnequalTestCases))]
+            public void LargerThanOrEqualsOperator_WithDifferentValues_ReturnsTheExpectedResult(UnequalValuesPair testCase)
+            {
+                Assert.True(testCase.Larger >= testCase.Smaller);
+                Assert.False(testCase.Smaller >= testCase.Larger);
+            }
+
+            [Fact]
+            [SuppressMessage("ReSharper", "EqualExpressionComparison")]
+            public void LargerThanOrEqualsOperator_WithNaN_ReturnsFalse()
+            {
+#pragma warning disable CS1718
+                Assert.False(double.NaN >= double.NaN);
+#pragma warning disable CS1718
+                Assert.False(double.PositiveInfinity >= double.NaN);
+                Assert.False(double.NaN >= double.NegativeInfinity);
+                
+                Assert.Multiple(
+                    () => Assert.False(QuantityValue.NaN >= QuantityValue.NaN),
+                    () => Assert.False(QuantityValue.PositiveInfinity >= QuantityValue.NaN),
+                    () => Assert.False(QuantityValue.NaN >= QuantityValue.NegativeInfinity));
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertFromNumber.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertFromNumber.cs
new file mode 100644
index 0000000000..b04d5b5345
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertFromNumber.cs
@@ -0,0 +1,430 @@
+using System.Numerics;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    public class ConvertFromNumberTests
+    {
+        [Theory]
+        [InlineData(2.5123, 1, 3, 1)]
+        [InlineData(2.5123, 2, 25, 10)]
+        [InlineData(2.5123, 3, 251, 100)]
+        [InlineData(25.123, 1, 25, 1)]
+        [InlineData(251.23, 1, 250, 1)]
+        [InlineData(double.PositiveInfinity, 1, 1, 0)]
+        [InlineData(double.NegativeInfinity, 1, -1, 0)]
+        [InlineData(double.NaN, 1, 0, 0)]
+        public void FromDoubleRounded(double value, byte digits, BigInteger numerator, BigInteger denominator)
+        {
+            var convertedValue = QuantityValue.FromDoubleRounded(value, digits);
+            Assert.Equal(numerator, convertedValue.Numerator);
+            Assert.Equal(denominator, convertedValue.Denominator);
+        }
+
+        [Fact]
+        public void FromDoubleRounded_WithZeroSignificantDigits_ThrowsArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => QuantityValue.FromDoubleRounded(2.5123, 0));
+        }
+
+        [Fact]
+        public void FromDoubleRounded_WithMoreThan17SignificantDigits_ThrowsArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => QuantityValue.FromDoubleRounded(2.5123, 18));
+        }
+
+        [Theory]
+        [InlineData(2, 3, 2, 3)]
+        [InlineData(-2, -3, 2, 3)]
+        [InlineData(-2, 3, -2, 3)]
+        [InlineData(2, -3, -2, 3)]
+        public void FromTerms_ReturnsTheExpectedResult(BigInteger numerator, BigInteger denominator, BigInteger expectedNumerator, BigInteger expectedDenominator)
+        {
+            Assert.Equal(new QuantityValue(expectedNumerator, expectedDenominator), QuantityValue.FromTerms(numerator, denominator));
+        }
+
+        [Theory]
+        [InlineData(2, 3, 3, 2e3, 3)]
+        [InlineData(-2, -3, 3, 2e3, 3)]
+        [InlineData(-2, 3, 3, -2e3, 3)]
+        [InlineData(2, -3, 3, -2e3, 3)]
+        [InlineData(2, 3, -3, 2, 3e3)]
+        [InlineData(-2, -3, -3, 2, 3e3)]
+        [InlineData(-2, 3, -3, -2, 3e3)]
+        [InlineData(2, -3, -3, -2, 3e3)]
+        public void FromPowerOfTen_ReturnsTheExpectedResult(BigInteger numerator, BigInteger denominator, int powerOfTen, BigInteger expectedNumerator, BigInteger expectedDenominator)
+        {
+            Assert.Equal(new QuantityValue(expectedNumerator, expectedDenominator), QuantityValue.FromPowerOfTen(numerator, denominator, powerOfTen));
+        }
+
+        [Fact]
+        public void FromPowerOfTen_WithWholeNumber_ReturnsTheExpectedResult()
+        {
+            Assert.Equal(0.05m, QuantityValue.FromPowerOfTen(5, -2));
+        }
+
+        public class ImplicitConversionTests
+        {
+            [Fact]
+            public void ImplicitConversionFromByte()
+            {
+                const byte valueToConvert = 10;
+                QuantityValue convertedValue = valueToConvert;
+                Assert.Equal(convertedValue.Numerator, valueToConvert);
+                Assert.Equal(convertedValue.Denominator, BigInteger.One);
+            }
+            
+            [Fact]
+            public void ImplicitConversionFromSByte()
+            {
+                const sbyte valueToConvert = -10;
+                QuantityValue convertedValue = valueToConvert;
+                Assert.Equal(convertedValue.Numerator, valueToConvert);
+                Assert.Equal(convertedValue.Denominator, BigInteger.One);
+            }
+
+            [Fact]
+            public void ImplicitConversionFromShort()
+            {
+                const short valueToConvert = 10;
+                QuantityValue convertedValue = valueToConvert;
+                Assert.Equal(convertedValue.Numerator, valueToConvert);
+                Assert.Equal(convertedValue.Denominator, BigInteger.One);
+            }
+
+            [Fact]
+            public void ImplicitConversionFromUShort()
+            {
+                const ushort valueToConvert = 10;
+                QuantityValue convertedValue = valueToConvert;
+                Assert.Equal(convertedValue.Numerator, valueToConvert);
+                Assert.Equal(convertedValue.Denominator, BigInteger.One);
+            }
+
+            [Fact]
+            public void ImplicitConversionFromInt()
+            {
+                const int valueToConvert = 10;
+                QuantityValue convertedValue = valueToConvert;
+                Assert.Equal(convertedValue.Numerator, valueToConvert);
+                Assert.Equal(convertedValue.Denominator, BigInteger.One);
+            }
+
+            [Fact]
+            public void ImplicitConversionFromUInt()
+            {
+                const uint valueToConvert = 10;
+                QuantityValue convertedValue = valueToConvert;
+                Assert.Equal(convertedValue.Numerator, valueToConvert);
+                Assert.Equal(convertedValue.Denominator, BigInteger.One);
+            }
+
+            [Fact]
+            public void ImplicitConversionFromLong()
+            {
+                const long valueToConvert = 10;
+                QuantityValue convertedValue = valueToConvert;
+                Assert.Equal(convertedValue.Numerator, valueToConvert);
+                Assert.Equal(convertedValue.Denominator, BigInteger.One);
+            }
+
+            [Fact]
+            public void ImplicitConversionFromULong()
+            {
+                const ulong valueToConvert = 10;
+                QuantityValue convertedValue = valueToConvert;
+                Assert.Equal(convertedValue.Numerator, valueToConvert);
+                Assert.Equal(convertedValue.Denominator, BigInteger.One);
+            }
+
+            [Theory]
+            [InlineData(2.5, 25, 10)]
+            [InlineData(-2.5, -25, 10)]
+            public void ImplicitConversionFromDecimal(decimal value, BigInteger numerator, BigInteger denominator)
+            {
+                QuantityValue convertedValue = value;
+                Assert.Equal(numerator, convertedValue.Numerator);
+                Assert.Equal(denominator, convertedValue.Denominator);
+            }
+
+            [Fact]
+            public void ImplicitConversionFromFloat()
+            {
+                const float valueToConvert = 10.5f;
+                QuantityValue convertedValue = valueToConvert;
+                Assert.Equal(convertedValue.Numerator, 105);
+                Assert.Equal(convertedValue.Denominator, 10);
+            }
+
+            [Theory]
+            [InlineData(0, 0, 1)]
+            [InlineData(double.NaN, 0, 0)]
+            [InlineData(double.PositiveInfinity, 1, 0)]
+            [InlineData(double.NegativeInfinity, -1, 0)]
+            [InlineData(2, 2, 1)]
+            [InlineData(2.5, 25, 10)]
+            [InlineData(-2.5, -25, 10)]
+            [InlineData(0.123, 123, 1000)]
+            public void ImplicitConversionFromDouble(double value, BigInteger numerator, BigInteger denominator)
+            {
+                QuantityValue convertedValue = value;
+                Assert.Equal(numerator, convertedValue.Numerator);
+                Assert.Equal(denominator, convertedValue.Denominator);
+            }
+        }
+
+#if NET
+        public class ConvertFromCheckedTests
+        {
+            private static TNumber CreateChecked<TNumber, TOther>(TOther value)
+                where TNumber : INumberBase<TNumber>
+                where TOther : INumberBase<TOther>
+            {
+                return TNumber.CreateChecked(value);
+            }
+
+            private static QuantityValue CreateChecked<TOther>(TOther number) where TOther : INumberBase<TOther>
+            {
+                return CreateChecked<QuantityValue, TOther>(number);
+            }
+
+            [Fact]
+            public void CreateChecked_WithARealFiniteNumber_ShouldReturnTheConvertedValue()
+            {
+                Assert.Equal(new QuantityValue(1, 3), CreateChecked(new QuantityValue(1, 3)));
+                Assert.Equal(new QuantityValue(3, 2), CreateChecked(1.5));
+                Assert.Equal(new QuantityValue(3, 2), CreateChecked(new Complex(1.5, 0)));
+                Assert.Equal(new QuantityValue(3, 2), CreateChecked(1.5m));
+                Assert.Equal(new QuantityValue(3, 2), CreateChecked((Half)1.5));
+                Assert.Equal(QuantityValue.One, CreateChecked(BigInteger.One));
+                Assert.Equal(QuantityValue.One, CreateChecked(Int128.One));
+                Assert.Equal(QuantityValue.One, CreateChecked(UInt128.One));
+                Assert.Equal(QuantityValue.One, CreateChecked(1L));
+                Assert.Equal(QuantityValue.One, CreateChecked(1UL));
+                Assert.Equal(QuantityValue.One, CreateChecked(1));
+                Assert.Equal(QuantityValue.One, CreateChecked(1U));
+                Assert.Equal(QuantityValue.One, CreateChecked((nint)1));
+                Assert.Equal(QuantityValue.One, CreateChecked((UIntPtr)1));
+                Assert.Equal(QuantityValue.One, CreateChecked((short)1));
+                Assert.Equal(QuantityValue.One, CreateChecked((ushort)1));
+                Assert.Equal(QuantityValue.One, CreateChecked((byte)1));
+                Assert.Equal(QuantityValue.One, CreateChecked((sbyte)1));
+                Assert.Equal(new QuantityValue(97), CreateChecked('a'));
+            }
+
+            [Fact]
+            public void CreateChecked_WithANaN_ShouldReturnNaN()
+            {
+                Assert.Equal(QuantityValue.NaN, CreateChecked(QuantityValue.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateChecked(double.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateChecked(float.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateChecked(Half.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateChecked(Complex.NaN));
+            }
+
+            [Fact]
+            public void CreateChecked_WithARealPositiveInfinity_ShouldReturnPositiveInfinity()
+            {
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateChecked(double.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateChecked(float.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateChecked(Half.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateChecked(new Complex(double.PositiveInfinity, 0)));
+            }
+
+            [Fact]
+            public void CreateChecked_WithARealNegativeInfinity_ShouldReturnNegativeInfinity()
+            {
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateChecked(double.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateChecked(float.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateChecked(Half.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateChecked(new Complex(double.NegativeInfinity, 0)));
+            }
+
+            [Fact]
+            public void CreateChecked_WithAComplexNumberHavingAnImaginaryPart_ShouldReturnNaN()
+            {
+                Assert.Equal(QuantityValue.NaN, CreateChecked(Complex.ImaginaryOne));
+                Assert.Equal(QuantityValue.NaN, CreateChecked(Complex.Infinity));
+            }
+
+            [Fact]
+            public void CreateChecked_WithAnUnsupportedType_ThrowsNotSupportedException()
+            {
+                Assert.Throws<NotSupportedException>(() => CreateChecked(FakeNumber.Zero));
+            }
+        }
+
+        public class ConvertFromSaturatingTests
+        {
+            private static TNumber CreateSaturating<TNumber, TOther>(TOther value)
+                where TNumber : INumberBase<TNumber>
+                where TOther : INumberBase<TOther>
+            {
+                return TNumber.CreateSaturating(value);
+            }
+
+            private static QuantityValue CreateSaturating<TOther>(TOther number) where TOther : INumberBase<TOther>
+            {
+                return CreateSaturating<QuantityValue, TOther>(number);
+            }
+
+            [Fact]
+            public void CreateSaturating_WithARealFiniteNumber_ShouldReturnTheConvertedQuantityValue()
+            {
+                Assert.Equal(new QuantityValue(1, 3), CreateSaturating(new QuantityValue(1, 3)));
+                Assert.Equal(new QuantityValue(3, 2), CreateSaturating(1.5));
+                Assert.Equal(new QuantityValue(3, 2), CreateSaturating(new Complex(1.5, 0)));
+                Assert.Equal(new QuantityValue(3, 2), CreateSaturating(1.5m));
+                Assert.Equal(new QuantityValue(3, 2), CreateSaturating((Half)1.5));
+                Assert.Equal(QuantityValue.One, CreateSaturating(BigInteger.One));
+                Assert.Equal(QuantityValue.One, CreateSaturating(Int128.One));
+                Assert.Equal(QuantityValue.One, CreateSaturating(UInt128.One));
+                Assert.Equal(QuantityValue.One, CreateSaturating(1L));
+                Assert.Equal(QuantityValue.One, CreateSaturating(1UL));
+                Assert.Equal(QuantityValue.One, CreateSaturating(1));
+                Assert.Equal(QuantityValue.One, CreateSaturating(1U));
+                Assert.Equal(QuantityValue.One, CreateSaturating((nint)1));
+                Assert.Equal(QuantityValue.One, CreateSaturating((UIntPtr)1));
+                Assert.Equal(QuantityValue.One, CreateSaturating((short)1));
+                Assert.Equal(QuantityValue.One, CreateSaturating((ushort)1));
+                Assert.Equal(QuantityValue.One, CreateSaturating((byte)1));
+                Assert.Equal(QuantityValue.One, CreateSaturating((sbyte)1));
+                Assert.Equal(new QuantityValue(97), CreateSaturating('a'));
+            }
+
+            [Fact]
+            public void CreateSaturating_WithANaN_ShouldReturnNaN()
+            {
+                Assert.Equal(QuantityValue.NaN, CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateSaturating(double.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateSaturating(float.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateSaturating(Half.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateSaturating(Complex.NaN));
+            }
+
+            [Fact]
+            public void CreateSaturating_WithARealPositiveInfinity_ShouldReturnPositiveInfinity()
+            {
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateSaturating(double.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateSaturating(float.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateSaturating(Half.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateSaturating(new Complex(double.PositiveInfinity, 0)));
+            }
+
+            [Fact]
+            public void CreateSaturating_WithARealNegativeInfinity_ShouldReturnNegativeInfinity()
+            {
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateSaturating(double.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateSaturating(float.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateSaturating(Half.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateSaturating(new Complex(double.NegativeInfinity, 0)));
+            }
+
+            [Fact]
+            public void CreateSaturating_WithAComplexNumberHavingAnImaginaryPart_ShouldReturnNaN()
+            {
+                Assert.Equal(0, CreateSaturating<double, Complex>(Complex.ImaginaryOne));
+                Assert.Equal(QuantityValue.Zero, CreateSaturating(Complex.ImaginaryOne));
+                Assert.Equal(double.PositiveInfinity, CreateSaturating<double, Complex>(Complex.Infinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateSaturating(Complex.Infinity));
+            }
+
+            [Fact]
+            public void CreateSaturating_WithAnUnsupportedType_ThrowsNotSupportedException()
+            {
+                Assert.Throws<NotSupportedException>(() => CreateSaturating(FakeNumber.Zero));
+            }
+        }
+
+        public class ConvertFromTruncatingTests
+        {
+            private static TNumber CreateTruncating<TNumber, TOther>(TOther value)
+                where TNumber : INumberBase<TNumber>
+                where TOther : INumberBase<TOther>
+            {
+                return TNumber.CreateTruncating(value);
+            }
+
+            private static QuantityValue CreateTruncating<TOther>(TOther number) where TOther : INumberBase<TOther>
+            {
+                return CreateTruncating<QuantityValue, TOther>(number);
+            }
+
+            [Fact]
+            public void CreateTruncating_WithARealFiniteNumber_ShouldReturnTheConvertedQuantityValue()
+            {
+                Assert.Equal(new QuantityValue(1, 3), CreateTruncating(new QuantityValue(1, 3)));
+                Assert.Equal(new QuantityValue(3, 2), CreateTruncating(1.5));
+                Assert.Equal(new QuantityValue(3, 2), CreateTruncating(new Complex(1.5, 0)));
+                Assert.Equal(new QuantityValue(3, 2), CreateTruncating(1.5m));
+                Assert.Equal(new QuantityValue(3, 2), CreateTruncating((Half)1.5));
+                Assert.Equal(QuantityValue.One, CreateTruncating(BigInteger.One));
+                Assert.Equal(QuantityValue.One, CreateTruncating(Int128.One));
+                Assert.Equal(QuantityValue.One, CreateTruncating(UInt128.One));
+                Assert.Equal(QuantityValue.One, CreateTruncating(1L));
+                Assert.Equal(QuantityValue.One, CreateTruncating(1UL));
+                Assert.Equal(QuantityValue.One, CreateTruncating(1));
+                Assert.Equal(QuantityValue.One, CreateTruncating(1U));
+                Assert.Equal(QuantityValue.One, CreateTruncating((nint)1));
+                Assert.Equal(QuantityValue.One, CreateTruncating((UIntPtr)1));
+                Assert.Equal(QuantityValue.One, CreateTruncating((short)1));
+                Assert.Equal(QuantityValue.One, CreateTruncating((ushort)1));
+                Assert.Equal(QuantityValue.One, CreateTruncating((byte)1));
+                Assert.Equal(QuantityValue.One, CreateTruncating((sbyte)1));
+                Assert.Equal(new QuantityValue(97), CreateTruncating('a'));
+            }
+
+            [Fact]
+            public void CreateTruncating_WithANaN_ShouldReturnNaN()
+            {
+                Assert.Equal(QuantityValue.NaN, CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateTruncating(double.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateTruncating(float.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateTruncating(Half.NaN));
+                Assert.Equal(QuantityValue.NaN, CreateTruncating(Complex.NaN));
+            }
+
+            [Fact]
+            public void CreateTruncating_WithARealPositiveInfinity_ShouldReturnPositiveInfinity()
+            {
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateTruncating(double.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateTruncating(float.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateTruncating(Half.PositiveInfinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateTruncating(new Complex(double.PositiveInfinity, 0)));
+            }
+
+            [Fact]
+            public void CreateTruncating_WithARealNegativeInfinity_ShouldReturnNegativeInfinity()
+            {
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateTruncating(double.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateTruncating(float.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateTruncating(Half.NegativeInfinity));
+                Assert.Equal(QuantityValue.NegativeInfinity, CreateTruncating(new Complex(double.NegativeInfinity, 0)));
+            }
+
+            [Fact]
+            public void CreateTruncating_WithAComplexNumberHavingAnImaginaryPart_ShouldReturnNaN()
+            {
+                Assert.Equal(0, CreateTruncating<double, Complex>(Complex.ImaginaryOne));
+                Assert.Equal(QuantityValue.Zero, CreateTruncating(Complex.ImaginaryOne));
+                Assert.Equal(double.PositiveInfinity, CreateTruncating<double, Complex>(Complex.Infinity));
+                Assert.Equal(QuantityValue.PositiveInfinity, CreateTruncating(Complex.Infinity));
+            }
+
+            [Fact]
+            public void CreateTruncating_WithAnUnsupportedType_ThrowsNotSupportedException()
+            {
+                Assert.Throws<NotSupportedException>(() => CreateTruncating(FakeNumber.Zero));
+            }
+        }
+
+#endif
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertFromString.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertFromString.cs
new file mode 100644
index 0000000000..3eb733d50b
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertFromString.cs
@@ -0,0 +1,750 @@
+using System.Globalization;
+using System.Numerics;
+using UnitsNet.Tests.Helpers;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    public static class ConversionFromStringTests
+    {
+        public class ParsingWithInvariantCulture
+        {
+            [Theory]
+            [InlineData("")]
+            [InlineData(" ")]
+            [InlineData("  ")]
+            [InlineData(null)]
+            public void ShouldNotWorkWithNullOrEmptyString(string? valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse!, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData(" 1")]
+            [InlineData(" +1")]
+            [InlineData(" -1")]
+            [InlineData(" 1-")]
+            [InlineData(" (1)")]
+            public void ShouldNotWorkWithLeadingWhitespaceWhenItIsNotAllowed(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any & ~NumberStyles.AllowLeadingWhite, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("1 ")]
+            [InlineData("+1 ")]
+            [InlineData("-1 ")]
+            [InlineData("1- ")]
+            [InlineData("(1) ")]
+            public void ShouldNotWorkWithTrailingWhitespaceWhenItIsNotAllowed(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any & ~NumberStyles.AllowTrailingWhite, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("-123456789987654321.123456789987654321")]
+            [InlineData("+123456789987654321.123456789987654321")]
+            public void ShouldNotWorkWithLeadingSignWhenItIsNotAllowed(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any & ~NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("123456789987654321.123456789987654321-")]
+            [InlineData("123456789987654321.123456789987654321+")]
+            public void ShouldNotWorkWithTrailingSignWhenItIsNotAllowed(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any & ~NumberStyles.AllowTrailingSign, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("-123456789987654321.123456789987654321-")]
+            [InlineData("+123456789987654321.123456789987654321+")]
+            [InlineData("+123456789987654321.123456789987654321-")]
+            [InlineData("-123456789987654321.123456789987654321+")]
+            [InlineData("-3.5+")]
+            [InlineData("-(3.5)")]
+            [InlineData("(3.5)-")]
+            public void ShouldNotWorkWithSignsOnBothSides(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("1.53")]
+            [InlineData("-1.53")]
+            public void ShouldNotWorkWithDecimalSymbolWhenItIsNotAllowed(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any & ~NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("1 234")]
+            [InlineData("-1 234")]
+            [InlineData("1 234.5")]
+            [InlineData("-1 234.5")]
+            public void ShouldNotWorkWithGroupSeparatorWhenItIsNotAllowed(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any & ~NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("123456789987654321.123456789,987654321")]
+            [InlineData("123456789987654321.,123456789987654321")]
+            public void ShouldNotWorkWithGroupsInTheMiddle(string valueToParse)
+            {
+                Assert.False(double.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _), "The format isn't supposed to be recognized by double.TryParse");
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("123456789987654321.-123456789987654321")]
+            [InlineData("123456789987654321-.123456789987654321")]
+            [InlineData("123456789987654321.+123456789987654321")]
+            [InlineData("123456789987654321+.123456789987654321")]
+            public void ShouldNotWorkWithSignsInTheMiddle(string valueToParse)
+            {
+                Assert.False(double.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _), "The format isn't supposed to be recognized by double.TryParse");
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("(1)")]
+            [InlineData(" (1) ")]
+            [InlineData("-(1)")]
+            [InlineData("(-1)")]
+            [InlineData("+(1)")]
+            [InlineData("(1)+")]
+            [InlineData("(1 234)")]
+            [InlineData("(1234.5)")]
+            public void ShouldNotWorkWithParenthesesWhenItIsNotAllowed(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any & ~NumberStyles.AllowParentheses, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("(")]
+            [InlineData("1(")]
+            [InlineData("1)")]
+            [InlineData(")1")]
+            [InlineData("¤(")]
+            [InlineData("¤(.")]
+            [InlineData(")")]
+            [InlineData("(1")]
+            [InlineData(" 1) ")]
+            [InlineData("-1)")]
+            [InlineData("- 1)")]
+            [InlineData("+1)")]
+            [InlineData("-(1")]
+            [InlineData("(1-")]
+            [InlineData("+(1-")]
+            [InlineData("(1 234")]
+            [InlineData("(1234.5")]
+            public void ShouldNotWorkWithParenthesesOnOneSide(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("(1(")]
+            [InlineData("((1")]
+            [InlineData(")1)")]
+            [InlineData("1))")]
+            [InlineData("((1))")]
+            [InlineData("(())")]
+            public void ShouldNotWorkWithMultipleParenthesesOnEitherSide(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData(" ")]
+            [InlineData(".")]
+            [InlineData(" .")]
+            [InlineData(". ")]
+            [InlineData("-")]
+            [InlineData("+")]
+            [InlineData(" .-")]
+            [InlineData("+.")]
+            [InlineData("+. ")]
+            [InlineData("()")]
+            [InlineData("(.)")]
+            [InlineData("-(.) ")]
+            [InlineData("+(.)")]
+            [InlineData("(.)-")]
+            [InlineData("¤()")]
+            public void ShouldNotWorkWithoutDigits(string valueToParse)
+            {
+                Assert.False(double.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _), "The format isn't supposed to be recognized by double.TryParse");
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("1x2")]
+            [InlineData("1.x2")]
+            [InlineData("x1.2")]
+            [InlineData("1.2x")]
+            [InlineData("1.2x-")]
+            [InlineData("-1.2x")]
+            public void ShouldNotWorkWithInvalidCharactersInTheString(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Fact]
+            public void Parsing_NaN_or_Infinity_ShouldReturnTheExpectedResult()
+            {
+                Assert.Equal(QuantityValue.NaN, QuantityValue.Parse("NaN", CultureInfo.InvariantCulture));
+                Assert.Equal(QuantityValue.PositiveInfinity, QuantityValue.Parse("Infinity", CultureInfo.InvariantCulture));
+                Assert.Equal(QuantityValue.NegativeInfinity, QuantityValue.Parse("-Infinity", CultureInfo.InvariantCulture));
+            }
+
+            [Theory]
+            [ClassData(typeof(ValidDecimalStringCases))]
+            public void ShouldReturnTheExpectedValueWhenTheStringIsValid(string valueToParse, QuantityValueData expectedResult)
+            {
+                Assert.True(double.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _), "The format is also recognized by double.TryParse");
+                var result = QuantityValue.Parse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture);
+                Assert.Equal(expectedResult.Value, result);
+            }
+
+            public class ValidDecimalStringCases : TheoryData<string, QuantityValueData>
+            {
+                public ValidDecimalStringCases()
+                {
+                    // Zero
+                    AddZeroCases();
+                    // +42 without a decimal separator
+                    AddPositiveIntegerCases();
+                    // -5 without a decimal separator
+                    AddNegativeIntegerCases();
+                    // Negative decimals
+                    AddNegativeDecimalCases();
+                    // Negative integers that also contain a decimal point
+                    AddNegativeIntegerWithDecimalSeparatorCases();
+                    // 0.1 written as "-.1" (and other sign variants)
+                    AddPositiveDecimalWithoutLeadingZeroCases();
+                    // -0.1 written as "-.1" (and other sign variants)
+                    AddNegativeDecimalWithoutLeadingZeroCases();
+                }
+
+                private void AddZeroCases()
+                {
+                    QuantityValueData zero = QuantityValue.Zero;
+                    Add("0", zero);
+                    Add("0.", zero);
+                    Add(".0", zero);
+                    Add("000000000000000000.0000000000000000000", zero);
+                    Add("-000000000000000000.0000000000000000000", zero);
+                }
+
+                private void AddPositiveIntegerCases()
+                {
+                    QuantityValueData quantityValueData = 42;
+                    Add("42", quantityValueData);
+                    Add(" 42 ", quantityValueData);
+                    Add("+42", quantityValueData);
+                    Add(" +42", quantityValueData);
+                    Add("42+", quantityValueData);
+                    Add("42+ ", quantityValueData);
+                    Add(" 42+ ", quantityValueData);
+                    Add(" 42 + ", quantityValueData); // any spaces before or after the trailing sign are ok
+                }
+
+                private void AddNegativeIntegerCases()
+                {
+                    QuantityValueData expectedValue = -5;
+                    Add("-5", expectedValue);
+                    Add("5-", expectedValue);
+                    Add(" -5", expectedValue);
+                    Add("5- ", expectedValue);
+                    Add("5 - ", expectedValue); // any spaces before or after the trailing sign are ok 
+                    Add("(5)", expectedValue);
+                    Add(" (5)", expectedValue);
+                    Add(" (5) ", expectedValue);
+                }
+
+                private void AddNegativeDecimalCases()
+                {
+                    QuantityValueData expectedValue = new QuantityValue(BigInteger.Parse("-123456789987654321123456789987654321"), BigInteger.Pow(10, 18));
+                    Add("-123456789987654321.1234567899876543210", expectedValue);
+                    Add("123456789987654321.1234567899876543210-", expectedValue);
+                    Add("1234,56789987654321.1234567899876543210-", expectedValue);
+                    Add("(1234,56789987654321.1234567899876543210)", expectedValue);
+                    Add(" (1234,56789987654321.1234567899876543210)", expectedValue);
+                    Add(" (1234,56789987654321.1234567899876543210) ", expectedValue);
+                    Add(" (1234,56789987654321.1234567899876543210 ) ", expectedValue);
+                }
+
+                private void AddNegativeIntegerWithDecimalSeparatorCases()
+                {
+                    QuantityValueData expectedValue = new QuantityValue(BigInteger.Parse("-123456789987654321"));
+                    Add("-123456789987654321.0", expectedValue);
+                    Add("123456789987654321.0-", expectedValue);
+                    Add("1234,56789987654321.0-", expectedValue);
+                    Add("-123456789987654321.", expectedValue);
+                    Add("123456789987654321.-", expectedValue);
+                    Add("1234,56789987654321.-", expectedValue);
+                    Add("(1234,56789987654321.)", expectedValue);
+                    Add(" (1234,56789987654321.)", expectedValue);
+                    Add(" (1234,56789987654321.) ", expectedValue);
+                    Add(" (1234,56789987654321. ) ", expectedValue);
+                }
+
+                private void AddPositiveDecimalWithoutLeadingZeroCases()
+                {
+                    var expectedValue = new QuantityValue(1, 10);
+                    Add(".10", expectedValue);
+                    Add(" .10", expectedValue);
+                    Add(".10 ", expectedValue);
+                    Add("+.10", expectedValue);
+                    Add(".10+", expectedValue);
+                    Add(" +.10", expectedValue);
+                    Add(".10+ ", expectedValue);
+                }
+
+                private void AddNegativeDecimalWithoutLeadingZeroCases()
+                {
+                    var expectedValue = new QuantityValue(-1, 10);
+                    Add("-.10", expectedValue);
+                    Add(".10-", expectedValue);
+                    Add(" -.10", expectedValue);
+                    Add(".10- ", expectedValue);
+                    Add("(.10)", expectedValue);
+                    Add(" (.10)", expectedValue);
+                    Add(" (.10) ", expectedValue);
+                }
+            }
+        }
+
+        public class ParsingWithScientificNotation
+        {
+            [Theory]
+            [InlineData("1.23456789987654321E+41.5")]
+            [InlineData("1.23456789987654321e+41.5")]
+            [InlineData("-1.23456789987654321E+41.5")]
+            [InlineData("-1.23456789987654321e+41.5")]
+            public void Parsing_StringWithDecimalExponent_ShouldThrow_FormatException(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("1.2345+9876+E5")]
+            [InlineData("1.2345-9876+E5")]
+            [InlineData("1.2345+9876-E5")]
+            [InlineData("1.2345-9876-E5")]
+            public void Parsing_StringWithSignInTheMiddle_ShouldThrow_FormatException(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("1.23456789,987654321E-24")]
+            [InlineData("1.23456789,987654321e-24")]
+            [InlineData("-1.23456789,987654321E-24")]
+            [InlineData("-1.23456789,987654321e-24")]
+            public void Parsing_StringWithGroupInTheMiddle_ShouldThrow_FormatException(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("1.2345E")]
+            [InlineData("1.2345e")]
+            public void Parsing_StringWithNothingAfterTheExponent_ShouldThrow_FormatException(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData(".E1")]
+            [InlineData(".e1")]
+            public void Parsing_StringWithNothingBeforeTheExponent_ShouldThrow_FormatException(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("1.5E3")]
+            [InlineData("1.5e3")]
+            public void Parsing_ExponentStringWithDecimalSeparator_With_NumberStyle_ExcludingDecimals_ShouldThrow_FormatException(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Any & ~NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Fact]
+            public void Parsing_ExponentStringWithoutDecimalSeparator_With_NumberStyle_ExcludingDecimals_ShouldReturnTheExpectedResult()
+            {
+                var result = QuantityValue.Parse("1e3", NumberStyles.Any & ~ NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
+                Assert.Equal(1e3m, result);
+            }
+
+            [Theory]
+            [ClassData(typeof(ValidExponentialStringCases))]
+            public void Parsing_ExponentString_With_NumberStyle_Number_ShouldThrow_FormatException(string valueToParse, QuantityValueData _)
+            {
+                Assert.Throws<FormatException>(() => QuantityValue.Parse(valueToParse, NumberStyles.Number, CultureInfo.InvariantCulture));
+            }
+
+            [Theory]
+            [ClassData(typeof(ValidExponentialStringCases))]
+            public void Parsing_ValidExponentString_ShouldReturnTheExpectedResult(string valueToParse, QuantityValueData expectedResult)
+            {
+                Assert.True(double.TryParse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture, out _), "The format is also recognized by double.TryParse");
+                var result = QuantityValue.Parse(valueToParse, NumberStyles.Any, CultureInfo.InvariantCulture);
+                Assert.Equal(expectedResult.Value, result);
+            }
+
+            public class ValidExponentialStringCases : TheoryData<string, QuantityValueData>
+            {
+                public ValidExponentialStringCases()
+                {
+                    AddPositiveIntegerCases();
+                    AddNegativeIntegerCases();
+                    AddLargePositiveCases();
+                    AddLargeNegativeCases();
+                    AddSmallPositiveCases();
+                    AddSmallNegativeCases();
+                }
+
+                private void AddPositiveIntegerCases()
+                {
+                    QuantityValueData expectedValue = new QuantityValue(new BigInteger(123456789987654321) * BigInteger.Pow(10, 5));
+                    Add("123456789987654321E+5", expectedValue);
+                    Add("123456789987654321e+5", expectedValue);
+                }
+
+                private void AddNegativeIntegerCases()
+                {
+                    QuantityValueData expectedValue = new QuantityValue(new BigInteger(-123456789987654321) * BigInteger.Pow(10, 5));
+                    Add("-123456789987654321E+5", expectedValue);
+                    Add("-123456789987654321e+5", expectedValue);
+                }
+
+                private void AddLargePositiveCases()
+                {
+                    QuantityValueData expectedValue = new QuantityValue(new BigInteger(123456789987654321) * BigInteger.Pow(10, 24));
+                    Add("1.23456789987654321E+41", expectedValue);
+                    Add("1.23456789987654321e+41", expectedValue);
+                    Add("1.234567899876543210E+41", expectedValue);
+                    Add("1.234567899876543210e+41", expectedValue);
+                }
+
+                private void AddLargeNegativeCases()
+                {
+                    QuantityValueData expectedValue = new QuantityValue(new BigInteger(-123456789987654321) * BigInteger.Pow(10, 24));
+                    Add("-1.23456789987654321E+41", expectedValue);
+                    Add("-1.23456789987654321e+41", expectedValue);
+                    Add("-1.234567899876543210E+41", expectedValue);
+                    Add("-1.234567899876543210e+41", expectedValue);
+                }
+
+                private void AddSmallPositiveCases()
+                {
+                    QuantityValueData expectedValue = new QuantityValue(new BigInteger(123456789987654321), BigInteger.Pow(10, 41));
+                    Add("1.23456789987654321E-24", expectedValue);
+                    Add("1.23456789987654321e-24", expectedValue);
+                    Add("1.234567899876543210E-24", expectedValue);
+                    Add("1.234567899876543210e-24", expectedValue);
+                    Add("1.23456789987654321E-24+", expectedValue);
+                    Add("1.23456789987654321e-24+", expectedValue);
+                    Add("1.234567899876543210E-24+", expectedValue);
+                    Add("1.234567899876543210e-24+", expectedValue);
+                    Add("12345.6789987654321E-28", expectedValue);
+                    Add("12345.6789987654321e-28", expectedValue);
+                    Add("12345.67899876543210E-28", expectedValue);
+                    Add("12345.67899876543210e-28", expectedValue);
+                    Add("12,345.6789987654321E-28", expectedValue);
+                    Add("12,345.6789987654321e-28", expectedValue);
+                    Add("12,345.67899876543210E-28", expectedValue);
+                    Add("12,345.67899876543210e-28", expectedValue);
+                }
+
+                private void AddSmallNegativeCases()
+                {
+                    QuantityValueData expectedValue = new QuantityValue(new BigInteger(-123456789987654321), BigInteger.Pow(10, 41));
+                    Add("-1.23456789987654321E-24", expectedValue);
+                    Add("-1.23456789987654321e-24", expectedValue);
+                    Add("-1.234567899876543210E-24", expectedValue);
+                    Add("-1.234567899876543210e-24", expectedValue);
+                }
+            }
+        }
+
+        public class ParsingWithHexNotation
+        {
+            [Theory]
+            [InlineData("2A")]
+            public void ShouldNotWorkWhenParsingAsNumber(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.Number, CultureInfo.InvariantCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("2A")]
+            [InlineData("2A ")]
+            [InlineData(" 2A")]
+            [InlineData(" 2A ")]
+            public void TheResultShouldBe42WhenParsingAsHex(string valueToParse)
+            {
+                var expectedValue = new QuantityValue(42);
+                var result = QuantityValue.Parse(valueToParse, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+                Assert.Equal(expectedValue, result);
+            }
+
+            [Theory]
+            [InlineData("2 A")]
+            public void ShouldNotWorkWithSpacesInTheMiddle(string valueToParse)
+            {
+                Assert.False(QuantityValue.TryParse(valueToParse, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out _));
+            }
+        }
+
+        public class ParsingWithCurrencySymbol
+        {
+            [Theory]
+            [InlineData("€3,5")]
+            [InlineData("€ 3,5")]
+            [InlineData("€3,5 ")]
+            [InlineData("€+3,5")]
+            [InlineData("€ +3,5")]
+            [InlineData("€+3,5 ")]
+            [InlineData("+€3,5")]
+            [InlineData("€3,5+")]
+            [InlineData("€3,5+ ")]
+            [InlineData("€3,5 + ")]
+            [InlineData(" €3,5 + ")]
+            [InlineData("€ 3,5+")]
+            [InlineData(" € 3,5+")]
+            [InlineData(" € 3,5 +")]
+            [InlineData(" € 3,5 + ")]
+            [InlineData("3,5€")]
+            [InlineData(" 3,5€")]
+            [InlineData("3,5 € ")]
+            [InlineData("+3,5€")]
+            [InlineData(" +3,5€")]
+            [InlineData("+3,5 €")]
+            [InlineData(" +3,5 €")]
+            [InlineData(" +3,5 € ")]
+            [InlineData("3,5€+")]
+            [InlineData(" 3,5€+")]
+            [InlineData("3,5 €+ ")]
+            [InlineData("3,5 € + ")]
+            [InlineData(" 3,5 € + ")]
+            [InlineData("3,5 €+")]
+            [InlineData(" 3,5€ +")]
+            [InlineData(" 3,5+ €")]
+            [InlineData(" 3,5 + € ")]
+            [InlineData("€+ 3,5")]
+            [InlineData("+€ 3,5")]
+            [InlineData(" € + 3,5")]
+            [InlineData(" +€ 3,5")]
+            public void Parsing_ValidCurrencyString_ShouldReturnTheExpectedResult(string value)
+            {
+                var germanCulture = CultureInfo.GetCultureInfo("de-DE");
+                Assert.True(double.TryParse(value, NumberStyles.Any, germanCulture, out _), "making sure the format is also recognized by double.TryParse");
+                var result = QuantityValue.Parse(value, NumberStyles.Any, germanCulture);
+                Assert.Equal(new QuantityValue(35, 10), result);
+            }
+
+            [Theory]
+            [InlineData("-€3,5")]
+            [InlineData("€3,5-")]
+            [InlineData("€3,5- ")]
+            [InlineData("€3,5 - ")]
+            [InlineData(" €3,5 - ")]
+            [InlineData("€ 3,5-")]
+            [InlineData(" € 3,5-")]
+            [InlineData(" € 3,5 -")]
+            [InlineData(" € 3,5 - ")]
+            [InlineData("-3,5€")]
+            [InlineData(" -3,5€")]
+            [InlineData("-3,5 €")]
+            [InlineData(" -3,5 €")]
+            [InlineData(" -3,5 € ")]
+            [InlineData("3,5€-")]
+            [InlineData(" 3,5€-")]
+            [InlineData("3,5 €- ")]
+            [InlineData("3,5 € - ")]
+            [InlineData(" 3,5 € - ")]
+            [InlineData("3,5 €-")]
+            [InlineData(" 3,5€ -")]
+            [InlineData(" 3,5- €")]
+            [InlineData(" 3,5 - € ")]
+            [InlineData("€- 3,5")]
+            [InlineData("-€ 3,5")]
+            [InlineData(" € - 3,5")]
+            [InlineData(" -€ 3,5")]
+            [InlineData("€ (3,5)")] // any number of white-spaces are allowed following a leading currency symbol (but no other signs)
+            [InlineData("(€ 3,5)")] // any number of white-spaces are allowed following a leading currency symbol (but no other signs)
+            public void Parsing_NegativeCurrencyString_ShouldReturnTheExpectedResult(string value)
+            {
+                var germanCulture = CultureInfo.GetCultureInfo("de-DE");
+                Assert.True(double.TryParse(value, NumberStyles.Any, germanCulture, out _), "making sure the format is also recognized by double.TryParse");
+                var result = QuantityValue.Parse(value, NumberStyles.Any, germanCulture);
+                Assert.Equal(new QuantityValue(-35, 10), result);
+            }
+
+            [Theory]
+            [InlineData("+ 3,5€")]
+            [InlineData("+ €3,5")]
+            [InlineData("+ € 3,5")]
+            [InlineData("- 3,5€")]
+            [InlineData("- €3,5")]
+            [InlineData("- € 3,5")] // this one is peculiar: any spaces after the leading sign are rejected (as long as there isn't a currency symbol preceding it)
+            public void Parsing_WithInvalidSpaces_ShouldNotWork(string value)
+            {
+                var germanCulture = CultureInfo.GetCultureInfo("de-DE");
+                Assert.False(double.TryParse(value, NumberStyles.Any, germanCulture, out _), "the format isn't supposed to be recognized by double.TryParse");
+                Assert.False(QuantityValue.TryParse(value, NumberStyles.Any, germanCulture, out _));
+            }
+
+            [Theory]
+            [InlineData("€3,5€")]
+            [InlineData("€+3,5€")]
+            [InlineData("+€3,5€")]
+            [InlineData("€3,5€+")]
+            [InlineData("€3,5+€")]
+            [InlineData("€-3,5€")]
+            [InlineData("-€3,5€")]
+            [InlineData("€3,5€-")]
+            [InlineData("€3,5-€")]
+            [InlineData("(€")]
+            public void Parsing_WithMultipleCurrencySymbols_ShouldNotWork(string value)
+            {
+                var germanCulture = CultureInfo.GetCultureInfo("de-DE");
+                Assert.False(double.TryParse(value, NumberStyles.Any, germanCulture, out _), "the format isn't supposed to be recognized by double.TryParse");
+                Assert.False(QuantityValue.TryParse(value, germanCulture, out _));
+            }
+
+            [Fact]
+            public void Parsing_CurrencyStringWithMultiCharacterSymbol_ShouldReturnTheExpectedResult()
+            {
+                var customCulture = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                customCulture.NumberFormat.CurrencySymbol = "EUR";
+                Assert.False(QuantityValue.TryParse("(1", NumberStyles.Any, customCulture, out _));
+            }
+
+            [Fact]
+            public void Parsing_WithCurrency_WhenTheCurrencyParsingIsDisabled_ShouldNotWork()
+            {
+                var germanCulture = CultureInfo.GetCultureInfo("de-DE");
+                Assert.False(QuantityValue.TryParse("1€", NumberStyles.Any & ~NumberStyles.AllowCurrencySymbol, germanCulture, out _));
+            }
+
+            public class ParsingWithDefaultCulture
+            {
+                [Fact]
+                public void Parsing_NaN_or_InfinitySymbol_WithGermanCulture_ShouldReturnTheExpectedValue()
+                {
+                    var formatProvider = CultureInfo.GetCultureInfo("de-DE");
+                    Assert.Equal(QuantityValue.NaN, QuantityValue.Parse("NaN", formatProvider));
+                    Assert.Equal(QuantityValue.PositiveInfinity, QuantityValue.Parse("∞", formatProvider));
+                    Assert.Equal(QuantityValue.NegativeInfinity, QuantityValue.Parse("-∞", formatProvider));
+                }
+
+                [Fact]
+                public void TryParse_WithValidString_ShouldReturnTheExpectedValue()
+                {
+                    using var _ = new CultureScope("de-DE");
+                    Assert.True(QuantityValue.TryParse("123,45", null, out var result));
+                    Assert.Equal(new QuantityValue(12345, 100), result);
+                }
+
+                [Fact]
+                public void TryParse_WithInvalidString_ShouldReturnFalse()
+                {
+                    using var _ = new CultureScope("de-DE");
+                    Assert.False(QuantityValue.TryParse("12 345", null, out var _));
+                }
+
+#if NET
+                [Fact]
+                public void Parse_ReadOnlySpan_WithValidString_ShouldReturnTheExpectedValue()
+                {
+                    using var _ = new CultureScope("de-DE");
+                    ReadOnlySpan<char> input = "123,45";
+                    var result = QuantityValue.Parse(input, null);
+                    Assert.Equal(new QuantityValue(12345, 100), result);
+                }
+
+                [Fact]
+                public void Parse_ReadOnlySpan_WithInvalidString_ShouldThrow_FormatException()
+                {
+                    using var _ = new CultureScope("de-DE");
+                    Assert.Throws<FormatException>(() => QuantityValue.Parse("12 345".AsSpan(), null));
+                }
+
+                [Fact]
+                public void TryParse_ReadOnlySpan_WithValidString_ShouldReturnTheExpectedValue()
+                {
+                    using var _ = new CultureScope("de-DE");
+                    ReadOnlySpan<char> input = "123,45";
+                    Assert.True(QuantityValue.TryParse(input, null, out var result));
+                    Assert.Equal(new QuantityValue(12345, 100), result);
+                }
+
+                [Fact]
+                public void TryParse_ReadOnlySpan_WithInvalidString_ShouldReturnFalse()
+                {
+                    using var _ = new CultureScope("de-DE");
+                    Assert.False(QuantityValue.TryParse("12 345".AsSpan(), null, out var _));
+                }
+#endif
+            }
+
+            public class ParsingWithCustomCulture
+            {
+                [Fact]
+                public void Parsing_WithCustomizedCulture_RespectsTheCultureFormat()
+                {
+                    // Arrange
+                    var customCulture = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                    customCulture.NumberFormat.NegativeSign = "_minus_";
+                    customCulture.NumberFormat.NumberGroupSeparator = "_group_";
+                    customCulture.NumberFormat.NumberDecimalSeparator = "_decimal_";
+                    var valueToParse = "_minus_1_group_234_decimal_56";
+                    QuantityValue expectedValue = -1234.56m;
+
+                    // Act
+                    var parsedValue = QuantityValue.Parse(valueToParse, NumberStyles.Number, customCulture);
+
+                    // Assert
+                    Assert.Equal(expectedValue, parsedValue);
+                }
+
+                [Fact]
+                public void Parsing_NaN_or_InfinitySymbol_WithCustomCulture_ShouldReturnTheExpectedValue()
+                {
+                    // Arrange
+                    var customCulture = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                    customCulture.NumberFormat.NaNSymbol = "Q";
+                    customCulture.NumberFormat.PositiveInfinitySymbol = "P";
+                    customCulture.NumberFormat.NegativeInfinitySymbol = "N";
+                    Assert.Equal(QuantityValue.NaN, QuantityValue.Parse("Q", customCulture));
+                    Assert.Equal(QuantityValue.PositiveInfinity, QuantityValue.Parse("P", customCulture));
+                    Assert.Equal(QuantityValue.NegativeInfinity, QuantityValue.Parse("N", customCulture));
+                }
+
+                [Fact]
+                public void Parsing_CurrencyStringWithCustomCultureWithoutCurrencySymbol_ShouldNotWork()
+                {
+                    // Arrange
+                    var customCulture = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                    customCulture.NumberFormat.CurrencySymbol = string.Empty;
+                    Assert.False(QuantityValue.TryParse("1.5€", NumberStyles.Any, customCulture, out _));
+                }
+
+                [Fact]
+                public void NumberFormat_WithEmptyDecimalSeparator_ThrowsArgumentException()
+                {
+                    var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                    Assert.Throws<ArgumentException>(() => formatProvider.NumberFormat.NumberDecimalSeparator = string.Empty);
+                    Assert.Equal("1", formatProvider.NumberFormat.NumberDecimalSeparator = "1");
+                }
+            }
+        }
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertToNumber.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertToNumber.cs
new file mode 100644
index 0000000000..e1383beff6
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertToNumber.cs
@@ -0,0 +1,920 @@
+using System.Numerics;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    public class ConvertToNumberTests
+    {
+        public class ToDecimalTests
+        {
+            [Fact]
+            public void ToDecimal_WithNaNOrInfinity_ThrowsOverflowException()
+            {
+                Assert.Throws<OverflowException>(() => QuantityValue.NaN.ToDecimal());
+                Assert.Throws<OverflowException>(() => QuantityValue.PositiveInfinity.ToDecimal());
+                Assert.Throws<OverflowException>(() => QuantityValue.NegativeInfinity.ToDecimal());
+            }
+
+            [Fact]
+            public void ToDecimal_WithValueOutsideTheDecimalRange_ThrowsOverflowException()
+            {
+                var largeNumber = 2 * new BigInteger(decimal.MaxValue);
+                Assert.Throws<OverflowException>(() => new QuantityValue(largeNumber).ToDecimal());
+                Assert.Throws<OverflowException>(() => new QuantityValue(-largeNumber).ToDecimal());
+                Assert.Throws<OverflowException>(() => new QuantityValue(1, largeNumber).ToDecimal());
+                Assert.Throws<OverflowException>(() => new QuantityValue(-1, largeNumber).ToDecimal());
+            }
+
+            [Theory]
+            [ClassData(typeof(ToDecimalTestData))]
+            public void ToDecimal_WithAValueWithinTheDecimalRange_ReturnsTheExpectedResult(BigInteger numerator, BigInteger denominator, decimal expected)
+            {
+                var quantityValue = new QuantityValue(numerator, denominator);
+                Assert.Equal(expected, quantityValue.ToDecimal());
+            }
+
+            public class ToDecimalTestData : TheoryData<BigInteger, BigInteger, decimal>
+            {
+                public ToDecimalTestData()
+                {
+                    var largeNumber = 2 * new BigInteger(decimal.MaxValue);
+                    // Zero cases
+                    Add(0, 1, 0.0m); // 0 / 1
+                    Add(0, 10, 0.0m); // 0 / 10
+                    Add(0, largeNumber, 0.0m); // 0 / largeNumber
+                    // Positive cases
+                    Add(2, 1, 2.0m); // 2 / 1
+                    Add(1, 2, 0.5m); // 1 / 2
+                    Add(1, 3, 1.0m / 3.0m); // 1 / 3
+                    Add(largeNumber, 4, decimal.MaxValue / 2); // 2 * maxValue / 4
+                    Add(4, largeNumber, 2 / decimal.MaxValue); // 4 / (maxValue * 2)
+                    Add(3, largeNumber, 1.5m / decimal.MaxValue); // 3 / (maxValue * 2)
+                    Add(largeNumber, largeNumber, 1.0m); // largeNumber / largeNumber
+                    Add(2 * largeNumber, largeNumber, 2.0m); // 2 * largeNumber / largeNumber
+                    Add(largeNumber, 2 * largeNumber, 0.5m); // largeNumber / 2 * largeNumber
+                    Add(3 * largeNumber, 2 * largeNumber, 1.5m); // 3 * largeNumber / 2 * largeNumber
+                    Add(2 * largeNumber, 3 * largeNumber, 2.0m / 3.0m); // 2 * largeNumber / 3 * largeNumber
+                    // Negative cases
+                    Add(-2, 1, -2.0m); // -2 / 1
+                    Add(-1, 2, -0.5m); // -1 / 2
+                    Add(-1, 3, -1.0m / 3.0m); // -1 / 3
+                    Add(-largeNumber, 4, decimal.MinValue / 2); // -2 * maxValue / 4
+                    Add(-4, largeNumber, -2 / decimal.MaxValue); // -4 / (maxValue * 2)
+                    Add(-3, largeNumber, -1.5m / decimal.MaxValue); // -3 / (maxValue * 2)
+                    Add(-largeNumber, largeNumber, -1.0m); // -largeNumber / largeNumber
+                    Add(-2 * largeNumber, largeNumber, -2.0m); // -2 * largeNumber / largeNumber
+                    Add(-largeNumber, 2 * largeNumber, -0.5m); // -largeNumber / 2 * largeNumber
+                    Add(-3 * largeNumber, 2 * largeNumber, -1.5m); // -3 * largeNumber / 2 * largeNumber
+                    Add(-2 * largeNumber, 3 * largeNumber, -2.0m / 3.0m); // -2 * largeNumber / 3 * largeNumber
+                }
+            }
+        }
+
+        public class ToDecimalSaturatingTests
+        {
+            [Theory]
+            [ClassData(typeof(ToDecimalSaturatingTestData))]
+            public void ToDecimalSaturating_ConvertsTheValueToTheDecimalRange(BigInteger numerator, BigInteger denominator, decimal expected)
+            {
+                var quantityValue = new QuantityValue(numerator, denominator);
+                Assert.Equal(expected, quantityValue.ToDecimalSaturating());
+            }
+
+            public class ToDecimalSaturatingTestData : TheoryData<BigInteger, BigInteger, decimal>
+            {
+                public ToDecimalSaturatingTestData()
+                {
+                    var largeNumber = 2 * new BigInteger(decimal.MaxValue);
+                    // Zero cases
+                    Add(0, 1, 0.0m); // 0 / 1
+                    Add(0, 10, 0.0m); // 0 / 10
+                    Add(0, largeNumber, 0.0m); // 0 / largeNumber
+                    // Positive cases
+                    Add(2, 1, 2.0m); // 2 / 1
+                    Add(1, 2, 0.5m); // 1 / 2
+                    Add(1, 3, 1.0m / 3.0m); // 1 / 3
+                    Add(largeNumber, 4, decimal.MaxValue / 2); // 2 * maxValue / 4
+                    Add(4, largeNumber, 2 / decimal.MaxValue); // 4 / (maxValue * 2)
+                    Add(3, largeNumber, 1.5m / decimal.MaxValue); // 3 / (maxValue * 2)
+                    Add(largeNumber, largeNumber, 1.0m); // largeNumber / largeNumber
+                    Add(2 * largeNumber, largeNumber, 2.0m); // 2 * largeNumber / largeNumber
+                    Add(largeNumber, 2 * largeNumber, 0.5m); // largeNumber / 2 * largeNumber
+                    Add(3 * largeNumber, 2 * largeNumber, 1.5m); // 3 * largeNumber / 2 * largeNumber
+                    Add(2 * largeNumber, 3 * largeNumber, 2.0m / 3.0m); // 2 * largeNumber / 3 * largeNumber
+                    // Negative cases
+                    Add(-2, 1, -2.0m); // -2 / 1
+                    Add(-1, 2, -0.5m); // -1 / 2
+                    Add(-1, 3, -1.0m / 3.0m); // -1 / 3
+                    Add(-largeNumber, 4, decimal.MinValue / 2); // -2 * maxValue / 4
+                    Add(-4, largeNumber, -2 / decimal.MaxValue); // -4 / (maxValue * 2)
+                    Add(-3, largeNumber, -1.5m / decimal.MaxValue); // -3 / (maxValue * 2)
+                    Add(-largeNumber, largeNumber, -1.0m); // -largeNumber / largeNumber
+                    Add(-2 * largeNumber, largeNumber, -2.0m); // -2 * largeNumber / largeNumber
+                    Add(-largeNumber, 2 * largeNumber, -0.5m); // -largeNumber / 2 * largeNumber
+                    Add(-3 * largeNumber, 2 * largeNumber, -1.5m); // -3 * largeNumber / 2 * largeNumber
+                    Add(-2 * largeNumber, 3 * largeNumber, -2.0m / 3.0m); // -2 * largeNumber / 3 * largeNumber
+                    // overflowing cases
+                    Add(largeNumber, 1, decimal.MaxValue);
+                    Add(-largeNumber, 1, decimal.MinValue);
+                    Add(2 * largeNumber, 2, decimal.MaxValue);
+                    Add(-2 * largeNumber, 2, decimal.MinValue);
+                    Add(1, largeNumber, 0m);
+                    Add(-1, largeNumber, 0m);
+                    // special values
+                    Add(0, 0, 0m); // NaN
+                    Add(1, 0, decimal.MaxValue); // PositiveInfinity
+                    Add(-1, 0, decimal.MinValue); // NegativeInfinity
+                }
+            }
+        }
+
+        public class ToDoubleTests
+        {
+            [Theory]
+            [ClassData(typeof(ToDoubleTestData))]
+            public void ToDouble_ConvertsTheValueToTheDoubleRange(BigInteger numerator, BigInteger denominator, double expected)
+            {
+                var quantityValue = new QuantityValue(numerator, denominator);
+                Assert.Equal(expected, quantityValue.ToDouble());
+            }
+
+            public class ToDoubleTestData : TheoryData<BigInteger, BigInteger, double>
+            {
+                public ToDoubleTestData()
+                {
+                    var largeNumber = 2 * new BigInteger(double.MaxValue);
+                    // Zero cases
+                    Add(0, 1, 0.0); // 0 / 1
+                    Add(0, 10, 0.0); // 0 / 10
+                    Add(0, largeNumber, 0.0); // 0 / largeNumber
+                    // Positive cases
+                    Add(2, 1, 2.0); // 2 / 1
+                    Add(1, 2, 0.5); // 1 / 2
+                    Add(1, 3, 1.0 / 3.0); // 1 / 3
+                    Add(largeNumber, 4, double.MaxValue / 2); // 2 * maxValue / 4
+                    Add(4, largeNumber, 2 / double.MaxValue); // 4 / (maxValue * 2)
+                    Add(3, largeNumber, 1.5 / double.MaxValue); // 3 / (maxValue * 2)
+                    Add(largeNumber, largeNumber, 1.0); // largeNumber / largeNumber
+                    Add(2 * largeNumber, largeNumber, 2.0); // 2 * largeNumber / largeNumber
+                    Add(largeNumber, 2 * largeNumber, 0.5); // largeNumber / 2 * largeNumber
+                    Add(3 * largeNumber, 2 * largeNumber, 1.5); // 3 * largeNumber / 2 * largeNumber
+                    Add(2 * largeNumber, 3 * largeNumber, 2.0 / 3.0); // 2 * largeNumber / 3 * largeNumber
+                    // Negative cases
+                    Add(-2, 1, -2.0); // -2 / 1
+                    Add(-1, 2, -0.5); // -1 / 2
+                    Add(-1, 3, -1.0 / 3.0); // -1 / 3
+                    Add(-largeNumber, 4, double.MinValue / 2); // -2 * maxValue / 4
+                    Add(-4, largeNumber, -2 / double.MaxValue); // -4 / (maxValue * 2)
+                    Add(-3, largeNumber, -1.5 / double.MaxValue); // -3 / (maxValue * 2)
+                    Add(-largeNumber, largeNumber, -1.0); // -largeNumber / largeNumber
+                    Add(-2 * largeNumber, largeNumber, -2.0); // -2 * largeNumber / largeNumber
+                    Add(-largeNumber, 2 * largeNumber, -0.5); // -largeNumber / 2 * largeNumber
+                    Add(-3 * largeNumber, 2 * largeNumber, -1.5); // -3 * largeNumber / 2 * largeNumber
+                    Add(-2 * largeNumber, 3 * largeNumber, -2.0 / 3.0); // -2 * largeNumber / 3 * largeNumber
+                    // overflowing cases
+                    Add(largeNumber, 1, double.PositiveInfinity);
+                    Add(-largeNumber, 1, double.NegativeInfinity);
+                    Add(2 * largeNumber, 2, double.PositiveInfinity);
+                    Add(-2 * largeNumber, 2, double.NegativeInfinity);
+                    Add(1, largeNumber, 0);
+                    Add(-1, largeNumber, 0);
+                    // special values
+                    Add(0, 0, double.NaN); // NaN
+                    Add(1, 0, double.PositiveInfinity); // PositiveInfinity
+                    Add(-1, 0, double.NegativeInfinity); // NegativeInfinity
+                }
+            }
+        }
+
+        public class ExplicitConversionTests
+        {
+            [Fact]
+            public void ExplicitConversionToDecimal()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(quantityValue.ToDecimal(), (decimal)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToDouble()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4.2, (double)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToFloat()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4.2, (float)quantityValue, 2);
+            }
+
+            [Fact]
+            public void ExplicitConversionToBigInteger()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4, (BigInteger)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToLong()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4, (long)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToULong()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4ul, (ulong)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToInteger()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4, (int)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToUInt()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4u, (uint)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToShort()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4, (short)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToUShort()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal((ushort)4, (ushort)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToByte()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal((byte)4, (byte)quantityValue);
+            }
+
+#if NET
+            [Fact]
+            public void ExplicitConversionToHalf()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal((Half)4.2, (Half)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToInt128()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4, (Int128)quantityValue);
+            }
+
+            [Fact]
+            public void ExplicitConversionToUInt128()
+            {
+                var quantityValue = new QuantityValue(42, 10);
+                Assert.Equal((UInt128)4, (UInt128)quantityValue);
+            }
+#endif
+        }
+       
+        public class ConvertibleTests
+        {
+            [Fact]
+            public void ToDecimal_ConvertsChecked()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4.2m, quantityValue.ToDecimal(null));
+            }
+
+            [Fact]
+            public void ToDouble_ConvertsSaturating()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4.2, quantityValue.ToDouble(null));
+            }
+
+            [Fact]
+            public void ToSingle_ConvertsSaturating()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4.2f, quantityValue.ToSingle(null), 2);
+            }
+
+            [Fact]
+            public void ToInt64_ConvertsChecked()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4L, quantityValue.ToInt64(null));
+            }
+
+            [Fact]
+            public void ToUInt64_ConvertsChecked()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4ul, quantityValue.ToUInt64(null));
+            }
+
+            [Fact]
+            public void ToInt32_ConvertsChecked()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4, quantityValue.ToInt32(null));
+            }
+
+            [Fact]
+            public void ToUInt32_ConvertsChecked()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4u, quantityValue.ToUInt32(null));
+            }
+
+            [Fact]
+            public void ToUInt16_ConvertsChecked()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal((ushort)4, quantityValue.ToUInt16(null));
+            }
+
+            [Fact]
+            public void ToInt16_ConvertsChecked()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal((short)4, quantityValue.ToInt16(null));
+            }
+
+            [Fact]
+            public void ToByte_ConvertsChecked()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal((byte)4, quantityValue.ToByte(null));
+            }
+
+            [Fact]
+            public void ToSByte_ConvertsChecked()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal((sbyte)4, quantityValue.ToSByte(null));
+            }
+
+            [Fact]
+            public void ToChar_ThrowsInvalidCastException()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Throws<InvalidCastException>(() => quantityValue.ToChar(null));
+            }
+
+            [Fact]
+            public void ToBoolean_ThrowsInvalidCastException()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Throws<InvalidCastException>(() => quantityValue.ToBoolean(null));
+            }
+
+            [Fact]
+            public void ToDateTime_ThrowsInvalidCastException()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Throws<InvalidCastException>(() => quantityValue.ToDateTime(null));
+            }
+
+            [Fact]
+            public void ToString_ReturnsTheValueAsString()
+            {
+                var valueToConvert = new QuantityValue(42, 10);
+                IFormatProvider? formatProvider = null;
+                var expectedFormat = valueToConvert.ToString(null, formatProvider);
+                IConvertible quantityValue = valueToConvert;
+                Assert.Equal(expectedFormat, quantityValue.ToString(formatProvider));
+            }
+
+            [Fact]
+            public void GetTypeCode_ReturnsObject()
+            {
+                IConvertible quantityValue = QuantityValue.One;
+                Assert.Equal(TypeCode.Object, quantityValue.GetTypeCode());
+            }
+
+            [Fact]
+            public void ToType_WithNumericType_ReturnsTheExpectedResult()
+            {
+                IConvertible quantityValue = new QuantityValue(42, 10);
+                Assert.Equal(4.2, quantityValue.ToType(typeof(double), null));
+                Assert.Equal(4.2m, quantityValue.ToType(typeof(decimal), null));
+                Assert.Equal(4.2, (float)quantityValue.ToType(typeof(float), null), 2);
+                Assert.Equal(4L, quantityValue.ToType(typeof(long), null));
+                Assert.Equal(4ul, quantityValue.ToType(typeof(ulong), null));
+                Assert.Equal(4, quantityValue.ToType(typeof(int), null));
+                Assert.Equal(4u, quantityValue.ToType(typeof(uint), null));
+                Assert.Equal((short)4, quantityValue.ToType(typeof(short), null));
+                Assert.Equal((ushort)4, quantityValue.ToType(typeof(ushort), null));
+                Assert.Equal((byte)4, quantityValue.ToType(typeof(byte), null));
+                Assert.Equal((sbyte)4, quantityValue.ToType(typeof(sbyte), null));
+            }
+
+            [Fact]
+            public void ToType_WithTypeOfString_ReturnsTheValueAsString()
+            {
+                var valueToConvert = new QuantityValue(42, 10);
+                IFormatProvider? formatProvider = null;
+                var expectedFormat = valueToConvert.ToString(null, formatProvider);
+                IConvertible quantityValue = valueToConvert;
+                Assert.Equal(expectedFormat, quantityValue.ToType(typeof(string), formatProvider));
+            }
+
+            [Fact]
+            public void ToType_WithUnsupportedType_ThrowsInvalidCastException()
+            {
+                IConvertible valueToConvert = QuantityValue.One;
+                Assert.Throws<InvalidCastException>(() => valueToConvert.ToType(typeof(bool), null));
+            }
+
+            [Fact]
+            public void ToType_WithNullType_ThrowsArgumentNullException()
+            {
+                IConvertible valueToConvert = QuantityValue.One;
+                Assert.Throws<ArgumentNullException>(() => valueToConvert.ToType(null!, null));
+            }
+        }
+#if NET7_0_OR_GREATER
+
+        public class ConvertToCheckedTests
+        {
+            private static TNumber CreateChecked<TNumber, TOther>(TOther value)
+                where TNumber : INumberBase<TNumber>
+                where TOther : INumberBase<TOther>
+            {
+                return TNumber.CreateChecked(value);
+            }
+
+            [Fact]
+            public void CreateChecked_FromFinitePositiveValue_ShouldReturnTheExpectedValue()
+            {
+                var quantityValue = new QuantityValue(3, 2);
+                Assert.Equal(1.5, double.CreateChecked(quantityValue));
+                Assert.Equal(new Complex(1.5, 0), Complex.CreateChecked(quantityValue));
+                Assert.Equal(1.5m, decimal.CreateChecked(quantityValue));
+                Assert.Equal(1.5f, float.CreateChecked(quantityValue));
+                Assert.Equal((Half)1.5, Half.CreateChecked(quantityValue));
+                Assert.Equal(1, BigInteger.CreateChecked(quantityValue));
+                Assert.Equal(1, Int128.CreateChecked(quantityValue));
+                Assert.Equal(1u, UInt128.CreateChecked(quantityValue));
+                Assert.Equal(1, long.CreateChecked(quantityValue));
+                Assert.Equal((ulong)1, ulong.CreateChecked(quantityValue));
+                Assert.Equal(1, int.CreateChecked(quantityValue));
+                Assert.Equal((uint)1, uint.CreateChecked(quantityValue));
+                Assert.Equal(1, nint.CreateChecked(quantityValue));
+                Assert.Equal((UIntPtr)1, UIntPtr.CreateChecked(quantityValue));
+                Assert.Equal((short)1, short.CreateChecked(quantityValue));
+                Assert.Equal((ushort)1, ushort.CreateChecked(quantityValue));
+                Assert.Equal((byte)1, byte.CreateChecked(quantityValue));
+                Assert.Equal((sbyte)1, sbyte.CreateChecked(quantityValue));
+                // although there isn't any char.CreateChecked(..) method, all numeric types support this conversion as well
+                Assert.Equal('a', CreateChecked<char, double>(97.9));
+                Assert.Equal('a', CreateChecked<char, QuantityValue>(new QuantityValue(979, 10)));
+            }
+
+            [Fact]
+            public void CreateChecked_FromFiniteNegativeValue_ShouldReturnTheExpectedValue()
+            {
+                var fraction = new QuantityValue(-3, 2);
+                Assert.Equal(-1.5, double.CreateChecked(fraction));
+                Assert.Equal(new Complex(-1.5, 0), Complex.CreateChecked(fraction));
+                Assert.Equal(-1.5m, decimal.CreateChecked(fraction));
+                Assert.Equal(-1.5f, float.CreateChecked(fraction));
+                Assert.Equal((Half)(-1.5), Half.CreateChecked(fraction));
+                Assert.Equal(-1, BigInteger.CreateChecked(fraction));
+                Assert.Equal(-1, Int128.CreateChecked(fraction));
+                Assert.Throws<OverflowException>(() => UInt128.CreateChecked(fraction));
+                Assert.Equal(-1, long.CreateChecked(fraction));
+                Assert.Throws<OverflowException>(() => ulong.CreateChecked(fraction));
+                Assert.Equal(-1, int.CreateChecked(fraction));
+                Assert.Throws<OverflowException>(() => uint.CreateChecked(fraction));
+                Assert.Equal(-1, nint.CreateChecked(fraction));
+                Assert.Throws<OverflowException>(() => UIntPtr.CreateChecked(fraction));
+                Assert.Equal((short)-1, short.CreateChecked(fraction));
+                Assert.Throws<OverflowException>(() => ushort.CreateChecked(fraction));
+                Assert.Throws<OverflowException>(() => byte.CreateChecked(fraction));
+                Assert.Equal((sbyte)-1, sbyte.CreateChecked(fraction));
+                // although there isn't any char.CreateChecked(..) method, all numeric types support this conversion as well
+                Assert.Throws<OverflowException>(() => CreateChecked<char, double>(-1.5));
+                Assert.Throws<OverflowException>(() => CreateChecked<char, QuantityValue>(fraction));
+            }
+
+            [Fact]
+            public void CreateChecked_FromNaN_ShouldReturnNaNOrThrowAnException()
+            {
+                Assert.Equal(double.NaN, double.CreateChecked(QuantityValue.NaN));
+                Assert.Equal(new Complex(double.NaN, 0), Complex.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => decimal.CreateChecked(QuantityValue.NaN));
+                Assert.Equal(float.NaN, float.CreateChecked(QuantityValue.NaN));
+                Assert.Equal(Half.NaN, Half.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => BigInteger.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => Int128.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => UInt128.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => long.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => ulong.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => int.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => uint.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => nint.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => UIntPtr.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => short.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => ushort.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => byte.CreateChecked(QuantityValue.NaN));
+                Assert.Throws<OverflowException>(() => sbyte.CreateChecked(QuantityValue.NaN));
+                // although there isn't any char.CreateChecked(..) method, all numeric types support this conversion as well
+                Assert.Throws<OverflowException>(() => CreateChecked<char, double>(double.NaN));
+                Assert.Throws<OverflowException>(() => CreateChecked<char, QuantityValue>(QuantityValue.NaN));
+            }
+
+            [Fact]
+            public void CreateChecked_FromPositiveInfinity_ShouldReturnPositiveInfinityOrThrowOverflowException()
+            {
+                Assert.Equal(double.PositiveInfinity, double.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Equal(new Complex(double.PositiveInfinity, 0), Complex.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => decimal.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Equal(float.PositiveInfinity, float.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Equal(Half.PositiveInfinity, Half.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => BigInteger.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => Int128.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => UInt128.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => long.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => ulong.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => int.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => uint.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => nint.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => UIntPtr.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => short.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => ushort.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => byte.CreateChecked(QuantityValue.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => sbyte.CreateChecked(QuantityValue.PositiveInfinity));
+                // although there isn't any char.CreateChecked(..) method, all numeric types support this conversion as well
+                Assert.Throws<OverflowException>(() => CreateChecked<char, double>(double.PositiveInfinity));
+                Assert.Throws<OverflowException>(() => CreateChecked<char, QuantityValue>(QuantityValue.PositiveInfinity));
+            }
+
+            [Fact]
+            public void CreateChecked_FromNegativeInfinity_ShouldReturnNegativeInfinityOrThrowOverflowException()
+            {
+                Assert.Equal(double.NegativeInfinity, double.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Equal(new Complex(double.NegativeInfinity, 0), Complex.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => decimal.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Equal(float.NegativeInfinity, float.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Equal(Half.NegativeInfinity, Half.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => BigInteger.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => Int128.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => UInt128.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => long.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => ulong.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => int.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => uint.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => nint.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => UIntPtr.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => short.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => ushort.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => byte.CreateChecked(QuantityValue.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => sbyte.CreateChecked(QuantityValue.NegativeInfinity));
+                // although there isn't any char.CreateChecked(..) method, all numeric types support this conversion as well
+                Assert.Throws<OverflowException>(() => CreateChecked<char, double>(double.NegativeInfinity));
+                Assert.Throws<OverflowException>(() => CreateChecked<char, QuantityValue>(QuantityValue.NegativeInfinity));
+            }
+
+            [Fact]
+            public void CreateChecked_WithUnsupportedType_ThrowsNotSupportedException()
+            {
+                Assert.Throws<NotSupportedException>(() => CreateChecked<FakeNumber, QuantityValue>(QuantityValue.One));
+            }
+        }
+
+        public class ConvertToSaturatingTests
+        {
+            private static TNumber CreateSaturating<TNumber, TOther>(TOther value)
+                where TNumber : INumberBase<TNumber>
+                where TOther : INumberBase<TOther>
+            {
+                return TNumber.CreateSaturating(value);
+            }
+
+            [Fact]
+            public void CreateSaturating_FromFinitePositiveValue_ShouldReturnTheExpectedValue()
+            {
+                var quantityValue = new QuantityValue(3, 2);
+                Assert.Equal(1.5, double.CreateSaturating(quantityValue));
+                Assert.Equal(new Complex(1.5, 0), Complex.CreateSaturating(quantityValue));
+                Assert.Equal(1.5m, decimal.CreateSaturating(quantityValue));
+                Assert.Equal(1.5f, float.CreateSaturating(quantityValue));
+                Assert.Equal((Half)1.5, Half.CreateSaturating(quantityValue));
+                Assert.Equal(1, BigInteger.CreateSaturating(quantityValue));
+                Assert.Equal(1, Int128.CreateSaturating(quantityValue));
+                Assert.Equal(1u, UInt128.CreateSaturating(quantityValue));
+                Assert.Equal(1, long.CreateSaturating(quantityValue));
+                Assert.Equal((ulong)1, ulong.CreateSaturating(quantityValue));
+                Assert.Equal(1, int.CreateSaturating(quantityValue));
+                Assert.Equal((uint)1, uint.CreateSaturating(quantityValue));
+                Assert.Equal(1, nint.CreateSaturating(quantityValue));
+                Assert.Equal((UIntPtr)1, UIntPtr.CreateSaturating(quantityValue));
+                Assert.Equal((short)1, short.CreateSaturating(quantityValue));
+                Assert.Equal((ushort)1, ushort.CreateSaturating(quantityValue));
+                Assert.Equal((byte)1, byte.CreateSaturating(quantityValue));
+                Assert.Equal((sbyte)1, sbyte.CreateSaturating(quantityValue));
+                // although there isn't any char.CreateSaturating(..) method, all numeric types support this conversion as well
+                Assert.Equal('a', CreateSaturating<char, double>(97.9));
+                Assert.Equal('a', CreateSaturating<char, QuantityValue>(new QuantityValue(979, 10)));
+            }
+
+            [Fact]
+            public void CreateSaturating_FromFiniteNegativeValue_ShouldReturnTheExpectedValue()
+            {
+                var fraction = new QuantityValue(-3, 2);
+                Assert.Equal(-1.5, double.CreateSaturating(fraction));
+                Assert.Equal(new Complex(-1.5, 0), Complex.CreateSaturating(fraction));
+                Assert.Equal(-1.5m, decimal.CreateSaturating(fraction));
+                Assert.Equal(-1.5f, float.CreateSaturating(fraction));
+                Assert.Equal((Half)(-1.5), Half.CreateSaturating(fraction));
+                Assert.Equal(-1, BigInteger.CreateSaturating(fraction));
+                Assert.Equal(-1, Int128.CreateSaturating(fraction));
+                Assert.Equal(0u, UInt128.CreateSaturating(fraction));
+                Assert.Equal(-1, long.CreateSaturating(fraction));
+                Assert.Equal(0UL, ulong.CreateSaturating(fraction));
+                Assert.Equal(-1, int.CreateSaturating(fraction));
+                Assert.Equal(0U, uint.CreateSaturating(fraction));
+                Assert.Equal(-1, nint.CreateSaturating(fraction));
+                Assert.Equal((UIntPtr)0, UIntPtr.CreateSaturating(fraction));
+                Assert.Equal((short)-1, short.CreateSaturating(fraction));
+                Assert.Equal((ushort)0, ushort.CreateSaturating(fraction));
+                Assert.Equal((byte)0, byte.CreateSaturating(fraction));
+                Assert.Equal((sbyte)-1, sbyte.CreateSaturating(fraction));
+                // although there isn't any char.CreateSaturating(..) method, all numeric types support this conversion as well
+                Assert.Equal(char.MinValue, CreateSaturating<char, double>(-1.5));
+                Assert.Equal(char.MinValue, CreateSaturating<char, QuantityValue>(fraction));
+            }
+
+            [Fact]
+            public void CreateSaturating_FromNaN_ShouldReturnZeroOrNaN()
+            {
+                Assert.Equal(double.NaN, double.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(new Complex(double.NaN, 0), Complex.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(decimal.Zero, decimal.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(float.NaN, float.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(Half.NaN, Half.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(BigInteger.Zero, BigInteger.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(Int128.Zero, Int128.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(UInt128.Zero, UInt128.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(0, long.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(0UL, ulong.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(0, int.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(0U, uint.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(nint.Zero, nint.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(UIntPtr.Zero, UIntPtr.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(default, short.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(default, ushort.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(default, byte.CreateSaturating(QuantityValue.NaN));
+                Assert.Equal(default, sbyte.CreateSaturating(QuantityValue.NaN));
+                // although there isn't any char.CreateChecked(..) method, all numeric types support this conversion as well
+                Assert.Equal('\0', CreateSaturating<char, double>(double.NaN));
+                Assert.Equal('\0', CreateSaturating<char, QuantityValue>(QuantityValue.NaN));
+            }
+
+            [Fact]
+            public void CreateSaturating_BigInteger_FromPositiveInfinity_ShouldThrowOverflowException()
+            {
+                Assert.Throws<OverflowException>(() => BigInteger.CreateSaturating(QuantityValue.PositiveInfinity));
+            }
+
+            [Fact]
+            public void CreateSaturating_FromPositiveInfinity_ShouldReturnMaxValueOrPositiveInfinity()
+            {
+                Assert.Equal(double.PositiveInfinity, double.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(new Complex(double.PositiveInfinity, 0), Complex.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(decimal.MaxValue, decimal.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(float.PositiveInfinity, float.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(Half.PositiveInfinity, Half.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(Int128.MaxValue, Int128.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(UInt128.MaxValue, UInt128.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(long.MaxValue, long.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(ulong.MaxValue, ulong.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(int.MaxValue, int.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(uint.MaxValue, uint.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(nint.MaxValue, nint.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(UIntPtr.MaxValue, UIntPtr.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(short.MaxValue, short.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(ushort.MaxValue, ushort.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(byte.MaxValue, byte.CreateSaturating(QuantityValue.PositiveInfinity));
+                Assert.Equal(sbyte.MaxValue, sbyte.CreateSaturating(QuantityValue.PositiveInfinity));
+                // although there isn't any char.CreateSaturating(..) method, all numeric types support this conversion as well
+                Assert.Equal(char.MaxValue, CreateSaturating<char, double>(double.PositiveInfinity));
+                Assert.Equal(char.MaxValue, CreateSaturating<char, QuantityValue>(QuantityValue.PositiveInfinity));
+            }
+
+            [Fact]
+            public void CreateSaturating_BigInteger_FromNegativeInfinity_ShouldThrowOverflowException()
+            {
+                Assert.Throws<OverflowException>(() => BigInteger.CreateSaturating(QuantityValue.NegativeInfinity));
+            }
+
+            [Fact]
+            public void CreateSaturating_FromNegativeInfinity_ShouldReturnMinValueOrNegativeInfinity()
+            {
+                Assert.Equal(double.NegativeInfinity, double.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(new Complex(double.NegativeInfinity, 0), Complex.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(decimal.MinValue, decimal.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(float.NegativeInfinity, float.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(Half.NegativeInfinity, Half.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(Int128.MinValue, Int128.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(UInt128.MinValue, UInt128.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(long.MinValue, long.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(ulong.MinValue, ulong.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(int.MinValue, int.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(uint.MinValue, uint.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(nint.MinValue, nint.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(UIntPtr.MinValue, UIntPtr.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(short.MinValue, short.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(ushort.MinValue, ushort.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(byte.MinValue, byte.CreateSaturating(QuantityValue.NegativeInfinity));
+                Assert.Equal(sbyte.MinValue, sbyte.CreateSaturating(QuantityValue.NegativeInfinity));
+                // although there isn't any char.CreateSaturating(..) method, all numeric types support this conversion as well
+                Assert.Equal(char.MinValue, CreateSaturating<char, double>(double.NegativeInfinity));
+                Assert.Equal(char.MinValue, CreateSaturating<char, QuantityValue>(QuantityValue.NegativeInfinity));
+            }
+
+            [Fact]
+            public void CreateSaturating_WithUnsupportedType_ThrowsNotSupportedException()
+            {
+                Assert.Throws<NotSupportedException>(() => CreateSaturating<FakeNumber, QuantityValue>(QuantityValue.One));
+            }
+        }
+
+        public class ConvertToTruncatingTests
+        {
+            private static TNumber CreateTruncating<TNumber, TOther>(TOther value)
+                where TNumber : INumberBase<TNumber>
+                where TOther : INumberBase<TOther>
+            {
+                return TNumber.CreateTruncating(value);
+            }
+
+            [Fact]
+            public void CreateTruncating_FromFinitePositiveValue_ShouldReturnTheExpectedValue()
+            {
+                var quantityValue = new QuantityValue(3, 2);
+                Assert.Equal(1.5, double.CreateTruncating(quantityValue));
+                Assert.Equal(new Complex(1.5, 0), Complex.CreateTruncating(quantityValue));
+                Assert.Equal(1.5m, decimal.CreateTruncating(quantityValue));
+                Assert.Equal(1.5f, float.CreateTruncating(quantityValue));
+                Assert.Equal((Half)1.5, Half.CreateTruncating(quantityValue));
+                Assert.Equal(1, BigInteger.CreateTruncating(quantityValue));
+                Assert.Equal(1, Int128.CreateTruncating(quantityValue));
+                Assert.Equal(1u, UInt128.CreateTruncating(quantityValue));
+                Assert.Equal(1, long.CreateTruncating(quantityValue));
+                Assert.Equal((ulong)1, ulong.CreateTruncating(quantityValue));
+                Assert.Equal(1, int.CreateTruncating(quantityValue));
+                Assert.Equal((uint)1, uint.CreateTruncating(quantityValue));
+                Assert.Equal(1, nint.CreateTruncating(quantityValue));
+                Assert.Equal((UIntPtr)1, UIntPtr.CreateTruncating(quantityValue));
+                Assert.Equal((short)1, short.CreateTruncating(quantityValue));
+                Assert.Equal((ushort)1, ushort.CreateTruncating(quantityValue));
+                Assert.Equal((byte)1, byte.CreateTruncating(quantityValue));
+                Assert.Equal((sbyte)1, sbyte.CreateTruncating(quantityValue));
+                // although there isn't any char.CreateTruncating(..) method, all numeric types support this conversion as well
+                Assert.Equal('a', CreateTruncating<char, double>(97.9));
+                Assert.Equal('a', CreateTruncating<char, QuantityValue>(new QuantityValue(979, 10)));
+            }
+
+            [Fact]
+            public void CreateTruncating_FromFiniteNegativeValue_ShouldReturnTheExpectedValue()
+            {
+                var fraction = new QuantityValue(-3, 2);
+                Assert.Equal(-1.5, double.CreateTruncating(fraction));
+                Assert.Equal(new Complex(-1.5, 0), Complex.CreateTruncating(fraction));
+                Assert.Equal(-1.5m, decimal.CreateTruncating(fraction));
+                Assert.Equal(-1.5f, float.CreateTruncating(fraction));
+                Assert.Equal((Half)(-1.5), Half.CreateTruncating(fraction));
+                Assert.Equal(-1, BigInteger.CreateTruncating(fraction));
+                Assert.Equal(-1, Int128.CreateTruncating(fraction));
+                Assert.Equal(new UInt128(18446744073709551615, 18446744073709551615), UInt128.CreateTruncating(fraction));
+                Assert.Equal(-1, long.CreateTruncating(fraction));
+                Assert.Equal(ulong.MaxValue, ulong.CreateTruncating(fraction));
+                Assert.Equal(-1, int.CreateTruncating(fraction));
+                Assert.Equal(uint.MaxValue, uint.CreateTruncating(fraction));
+                Assert.Equal(-1, nint.CreateTruncating(fraction));
+                Assert.Equal(new UIntPtr(18446744073709551615), UIntPtr.CreateTruncating(fraction));
+                Assert.Equal((short)-1, short.CreateTruncating(fraction));
+                Assert.Equal(ushort.MaxValue, ushort.CreateTruncating(fraction));
+                Assert.Equal(byte.MaxValue, byte.CreateTruncating(fraction));
+                Assert.Equal((sbyte)-1, sbyte.CreateTruncating(fraction));
+                // although there isn't any char.CreateTruncating(..) method, all numeric types support this conversion as well
+                // note: for some reason the floating point types don't care implement an independent truncating method, instead they return the saturated result
+                Assert.Equal(char.MinValue, CreateTruncating<char, double>(-1.5));
+                Assert.Equal(char.MaxValue, CreateTruncating<char, int>(-1));
+                Assert.Equal(char.MaxValue, CreateTruncating<char, QuantityValue>(fraction));
+            }
+
+            [Fact]
+            public void CreateTruncating_FromNaN_ShouldReturnZeroOrNaN()
+            {
+                Assert.Equal(double.NaN, double.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(new Complex(double.NaN, 0), Complex.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(decimal.Zero, decimal.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(float.NaN, float.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(Half.NaN, Half.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(BigInteger.Zero, BigInteger.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(Int128.Zero, Int128.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(UInt128.Zero, UInt128.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(0, long.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(0UL, ulong.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(0, int.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(0U, uint.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(nint.Zero, nint.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(UIntPtr.Zero, UIntPtr.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(default, short.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(default, ushort.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(default, byte.CreateTruncating(QuantityValue.NaN));
+                Assert.Equal(default, sbyte.CreateTruncating(QuantityValue.NaN));
+                // although there isn't any char.CreateTruncating(..) method, all numeric types support this conversion as well
+                Assert.Equal('\0', CreateTruncating<char, double>(double.NaN));
+                Assert.Equal('\0', CreateTruncating<char, QuantityValue>(QuantityValue.NaN));
+            }
+
+            [Fact]
+            public void CreateTruncating_BigInteger_FromPositiveInfinity_ShouldThrowOverflowException()
+            {
+                Assert.Throws<OverflowException>(() => BigInteger.CreateTruncating(QuantityValue.PositiveInfinity));
+            }
+
+            [Fact]
+            public void CreateTruncating_FromPositiveInfinity_ShouldReturnMaxValueOrPositiveInfinity()
+            {
+                Assert.Equal(double.PositiveInfinity, double.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(new Complex(double.PositiveInfinity, 0), Complex.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(decimal.MaxValue, decimal.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(float.PositiveInfinity, float.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(Half.PositiveInfinity, Half.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(Int128.MaxValue, Int128.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(UInt128.MaxValue, UInt128.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(long.MaxValue, long.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(ulong.MaxValue, ulong.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(int.MaxValue, int.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(uint.MaxValue, uint.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(nint.MaxValue, nint.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(UIntPtr.MaxValue, UIntPtr.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(short.MaxValue, short.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(ushort.MaxValue, ushort.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(byte.MaxValue, byte.CreateTruncating(QuantityValue.PositiveInfinity));
+                Assert.Equal(sbyte.MaxValue, sbyte.CreateTruncating(QuantityValue.PositiveInfinity));
+                // although there isn't any char.CreateTruncating(..) method, all numeric types support this conversion as well
+                Assert.Equal(char.MaxValue, CreateTruncating<char, double>(double.PositiveInfinity));
+                Assert.Equal(char.MaxValue, CreateTruncating<char, QuantityValue>(QuantityValue.PositiveInfinity));
+            }
+
+            [Fact]
+            public void CreateTruncating_FromNegativeInfinity_BigInteger_ShouldThrowOverflowException()
+            {
+                Assert.Throws<OverflowException>(() => BigInteger.CreateTruncating(QuantityValue.NegativeInfinity));
+            }
+
+            [Fact]
+            public void CreateTruncating_FromNegativeInfinity_ShouldReturnMinValueOrNegativeInfinity()
+            {
+                Assert.Equal(double.NegativeInfinity, double.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(new Complex(double.NegativeInfinity, 0), Complex.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(decimal.MinValue, decimal.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(float.NegativeInfinity, float.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(Half.NegativeInfinity, Half.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(Int128.MinValue, Int128.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(UInt128.MinValue, UInt128.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(long.MinValue, long.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(ulong.MinValue, ulong.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(int.MinValue, int.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(uint.MinValue, uint.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(nint.MinValue, nint.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(UIntPtr.MinValue, UIntPtr.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(short.MinValue, short.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(ushort.MinValue, ushort.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(byte.MinValue, byte.CreateTruncating(QuantityValue.NegativeInfinity));
+                Assert.Equal(sbyte.MinValue, sbyte.CreateTruncating(QuantityValue.NegativeInfinity));
+                // although there isn't any char.CreateTruncating(..) method, all numeric types support this conversion as well
+                Assert.Equal(char.MinValue, CreateTruncating<char, double>(double.NegativeInfinity));
+                Assert.Equal(char.MinValue, CreateTruncating<char, QuantityValue>(QuantityValue.NegativeInfinity));
+            }
+
+            [Fact]
+            public void CreateTruncating_WithUnsupportedType_ThrowsNotSupportedException()
+            {
+                Assert.Throws<NotSupportedException>(() => CreateTruncating<FakeNumber, QuantityValue>(QuantityValue.One));
+            }
+        }
+#endif
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertToString.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertToString.cs
new file mode 100644
index 0000000000..5e8ed1ab2d
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.ConvertToString.cs
@@ -0,0 +1,1338 @@
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using Xunit.Abstractions;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    public class ConvertToStringTests
+    {
+        internal static readonly QuantityValueData[] TerminatingFractions =
+        [
+            0, 1, -1, 10, -10, 100, -100, 1000, -1000, 10000, -10000, 100000, -100000,
+            0.1m, -0.1m, 0.2m, -0.2m, 0.5m, -0.5m, 1.2m, -1.2m, 1.5m, -1.5m, 1.95m, -1.95m, 2.5m, -2.5m,
+            2.001234m, -2.001234m, // rounds to 2
+            0.000015545665434654m, -0.000015545665434654m,
+            0.00015545665434654m, -0.00015545665434654m,
+            0.0015545665434654m, -0.0015545665434654m,
+            0.015545665434654m, -0.015545665434654m,
+            0.15545665434654m, -0.15545665434654m,
+            1.5545665434654m, -1.5545665434654m,
+            15.545665434654m, -15.545665434654m,
+            155.45665434654m, -155.45665434654m,
+            1554.5665434654m, -1554.5665434654m,
+            15545.665434654m, -15545.665434654m,
+            155456.65434654m, -155456.65434654m,
+            1554566.5434654m, -1554566.5434654m,
+            new QuantityValue(10, 20), new QuantityValue(-10, 20),
+            // 128 in binary is 10000000, so its bit length is 8. 1400 is between 2^10 (1024) and 2^11 (2048), so its bit length is 11.
+            new QuantityValue(128, 1400), new QuantityValue(-128, 1400), 
+        ];
+
+        internal static readonly QuantityValueData[] NonTerminatingFractions =
+        [
+            new QuantityValue(1, 3), new QuantityValue(-1, 3),
+            new QuantityValue(2, 3), new QuantityValue(-2, 3),
+            new QuantityValue(19999991, 3),
+            new QuantityValue(-19999991, 3), // note: for all but the percent (P) format we could be using two more digits ('99')
+            new QuantityValue(20000001, 3),
+            new QuantityValue(-20000001, 3), // note: for all but the percent (P) format we could be using two more digits ('00')
+            new QuantityValue(4, 3), new QuantityValue(-4, 3),
+            new QuantityValue(5, 3), new QuantityValue(-5, 3),
+            new QuantityValue(7, 3), new QuantityValue(-7, 3)
+        ];
+        
+        /// <summary>
+        ///     Represents a pair consisting of a <see cref="QuantityValue" /> and its associated format string.
+        /// </summary>
+        /// <remarks>
+        ///     This class is primarily used in unit tests to validate the behavior of <see cref="QuantityValue" />
+        ///     when formatted as a string using specific format strings.
+        ///     It also implements <see cref="IXunitSerializable" /> to facilitate serialization and deserialization
+        ///     of test data for xUnit test cases.
+        /// </remarks>
+        public class ValueFormatPair : IXunitSerializable
+        {
+            private QuantityValueData _value;
+
+            public ValueFormatPair(QuantityValueData value, string format)
+            {
+                _value = value;
+                Format = format;
+            }
+
+            public QuantityValue Value
+            {
+                get => _value;
+                private set => _value = value;
+            }
+
+            public string Format { get; private set; }
+
+            public void Deconstruct(out QuantityValue value, out string format)
+            {
+                value = Value;
+                format = Format;
+            }
+
+            public override string ToString()
+            {
+                var fraction = Value;
+                return $"{fraction.Numerator}/{fraction.Denominator} : {Format}";
+            }
+
+            #region Implementation of IXunitSerializable
+
+            public ValueFormatPair()
+            {
+                _value = null!;
+                Format = null!;
+            }
+
+            public void Serialize(IXunitSerializationInfo info)
+            {
+                info.AddValue("v1", _value);
+                info.AddValue("v2", Format);
+            }
+
+            public void Deserialize(IXunitSerializationInfo info)
+            {
+                Value = info.GetValue<QuantityValueData>("v1");
+                Format = info.GetValue<string>("v2");
+            }
+
+            #endregion
+        }
+
+        /// <summary>
+        ///     The general ("G") format specifier converts a number to the more compact of either fixed-point or scientific
+        ///     notation, depending on the type of the number and whether a precision specifier is present. The precision specifier
+        ///     defines the maximum number of significant digits that can appear in the result string. If the precision specifier
+        ///     is omitted or zero, the type of the number determines the default precision.
+        /// </summary>
+        public class GeneralFormatTests
+        {
+            private static readonly string[] GeneralFormats = ["G1", "G2", "G3", "G4", "G5", "G6", "g1", "g6", "G27"];
+
+            [Theory]
+            [ClassData(typeof(TerminatingFractionCases))]
+            public void ToString_WithTerminatingFraction(ValueFormatPair testCase, string expected)
+            {
+                var (value, format) = testCase;
+                var result = value.ToString(format);
+                Assert.Equal(expected, result);
+            }
+
+            [Theory]
+            [ClassData(typeof(NonTerminatingFractionCases))]
+            public void ToString_WithNonTerminatingFraction(ValueFormatPair testCase, string expected)
+            {
+                var (value, format) = testCase;
+                var result = value.ToString(format);
+                Assert.Equal(expected, result);
+            }
+
+            [Fact]
+            public void ToString_WithoutFormatSpecifier()
+            {
+                var value = new QuantityValue(1, 3);
+#if NET
+                Assert.Equal(value.ToString("G16", CultureInfo.CurrentCulture), value.ToString("G"));
+#else
+                Assert.Equal(value.ToString("G15", CultureInfo.CurrentCulture), value.ToString("G"));
+#endif
+                Assert.Equal(value.ToString("G", CultureInfo.CurrentCulture), value.ToString("G0", null));
+            }
+
+            #if NET
+        
+            [Fact]
+            public void TryFormat_Zero_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = 0;
+                var destination = new Span<char>(new char[1]);
+                var result = value.TryFormat(destination, out var charsWritten, "G", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(1, charsWritten);
+                Assert.Equal("0", destination[Range.EndAt(charsWritten)]);
+            }
+        
+            [Fact]
+            public void TryFormat_WithG0AndValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = 123.456m;
+                var destination = new Span<char>(new char[10]);
+                var result = value.TryFormat(destination, out var charsWritten, "G0", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(7, charsWritten);
+                Assert.Equal("123.456", destination[Range.EndAt(charsWritten)]);
+            }
+        
+            [Fact]
+            public void TryFormat_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = 123.456m;
+                var destination = new Span<char>(new char[10]);
+                var result = value.TryFormat(destination, out var charsWritten, "G", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(7, charsWritten);
+                Assert.Equal("123.456", destination[Range.EndAt(charsWritten)]);
+            }
+
+            [Theory]
+            [InlineData(123400, "G6", 5)]
+            [InlineData(123400, "G1", 0)]
+            [InlineData(123400, "G2", 0)]
+            [InlineData(123400, "G2", 1)]
+            [InlineData(123400, "G2", 3)]
+            [InlineData(123.456, "G2", 4)]
+            [InlineData(123.456, "G2", 5)]
+            [InlineData(0.000123, "G5", 5)]
+            public void TryFormat_WithInvalidSpanLength_ReturnsFalse(decimal decimalValue, string format, int testLength)
+            {
+                QuantityValue value = decimalValue;
+                var destination = new Span<char>(new char[testLength]);
+                var result = value.TryFormat(destination, out var charsWritten, format, CultureInfo.InvariantCulture);
+                Assert.False(result);
+                // Assert.Equal(0, charsWritten); // TODO should we make sure that nothing was written?
+            }
+
+            [Theory]
+            [InlineData(-1234, -10, "G1", 0)]
+            [InlineData(-1234, -10, "G2", 3)]
+            [InlineData(-1234, -10, "G2", 4)]
+            [InlineData(-1234, -10, "G2", 5)]
+            [InlineData(-1234, -10, "G20", 1)]
+            [InlineData(-1234, -10, "G20", 2)]
+            [InlineData(-1234, -10, "G20", 5)]
+            [InlineData(1, -1000, "G1", 2)]
+            public void TryFormat_FromPowerOfTen_WithInvalidSpanLength_ReturnsFalse(int number, int powerOfTen, string format, int testLength)
+            {
+                var value = QuantityValue.FromPowerOfTen(number, powerOfTen);
+                var destination = new Span<char>(new char[testLength]);
+                var result = value.TryFormat(destination, out var charsWritten, format, CultureInfo.InvariantCulture);
+                Assert.False(result);
+                // Assert.Equal(0, charsWritten); // TODO should we make sure that nothing was written?
+            }
+            
+            #endif
+
+            public sealed class TerminatingFractionCases : TheoryData<ValueFormatPair, string>
+            {
+                public TerminatingFractionCases()
+                {
+                    foreach (var value in TerminatingFractions)
+                    {
+                        foreach (var format in GeneralFormats)
+                        {
+                            Add(new ValueFormatPair(value, format), value.Value.ToDecimal().ToString(format));
+                        }
+                    }
+                }
+            }
+
+            public sealed class NonTerminatingFractionCases : TheoryData<ValueFormatPair, string>
+            {
+                public NonTerminatingFractionCases()
+                {
+                    foreach (var value in NonTerminatingFractions)
+                    {
+                        foreach (var format in GeneralFormats)
+                        {
+                            Add(new ValueFormatPair(value, format), value.Value.ToDecimal().ToString(format));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///     The fixed-point ("F") format specifier converts a number to a string of the form "-ddd.ddd…" where each "d"
+        ///     indicates a digit (0-9). The string starts with a minus sign if the number is negative.
+        ///     The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted, the
+        ///     current NumberFormatInfo.NumberDecimalDigits property supplies the numeric precision.
+        /// </summary>
+        public class FixedPointFormatTests
+        {
+            private static readonly string[] FixedPointFormats = ["F", "F0", "F1", "F2", "F3", "F4", "F5", "F6", "F27"];
+
+            [Theory]
+            [ClassData(typeof(TerminatingFractionCases))]
+            public void ToString_WithTerminatingFraction(ValueFormatPair testCase, string expected)
+            {
+                var (value, format) = testCase;
+                var result = value.ToString(format);
+                Assert.Equal(expected, result);
+            }
+
+            public sealed class TerminatingFractionCases : TheoryData<ValueFormatPair, string>
+            {
+                public TerminatingFractionCases()
+                {
+                    foreach (var value in TerminatingFractions)
+                    {
+                        foreach (var format in FixedPointFormats)
+                        {
+                            Add(new ValueFormatPair(value, format), value.Value.ToDecimal().ToString(format));
+                        }
+                    }
+                }
+            }
+
+            [Fact]
+            public void ToString_F250_ReturnsTheExpectedResult()
+            {
+                QuantityValue value = 4.2;
+                var expected = "4.2" + new string(Enumerable.Repeat('0', 249).ToArray());
+
+                var result = value.ToString("F250", CultureInfo.InvariantCulture);
+
+                Assert.Equal(expected, result);
+            }
+
+#if NET
+            [Fact]
+            public void TryFormat_Zero_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = 0;
+                var destination = new Span<char>(new char[4]);
+                var result = value.TryFormat(destination, out var charsWritten, "F2", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(4, charsWritten);
+                Assert.Equal("0.00", destination[Range.EndAt(charsWritten)]);
+            }
+
+            [Fact]
+            public void TryFormat_NegativeInteger_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = -42;
+                var destination = new Span<char>(new char[6]);
+                var result = value.TryFormat(destination, out var charsWritten, "F2", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(6, charsWritten);
+                Assert.Equal("-42.00", destination[Range.EndAt(charsWritten)]);
+            }
+
+            [Fact]
+            public void TryFormat_NegativeDecimal_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = -4.2;
+                var destination = new Span<char>(new char[5]);
+                var result = value.TryFormat(destination, out var charsWritten, "F2", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(5, charsWritten);
+                Assert.Equal("-4.20", destination[Range.EndAt(charsWritten)]);
+            }
+
+            [Theory]
+            [InlineData(-123.4, "F1", 0)]
+            [InlineData(-123.4, "F1", 4)]
+            [InlineData(-123.4, "F1", 5)]
+            [InlineData(-123.4, "F20", 3)]
+            [InlineData(-123.4, "F20", 4)]
+            [InlineData(-123.4, "F20", 5)]
+            public void TryFormat_Decimal_WithInvalidSpanLength_ReturnsFalse(decimal decimalValue, string format, int testLength)
+            {
+                QuantityValue value = decimalValue;
+                var destination = new Span<char>(new char[testLength]);
+                var result = value.TryFormat(destination, out var charsWritten, format, CultureInfo.InvariantCulture);
+                Assert.False(result);
+                // Assert.Equal(0, charsWritten); // TODO should we make sure that nothing was written?
+            }
+
+            [Fact]
+            public void TryFormat_PreciseDecimal_WithInvalidSpanLength_ReturnsFalse()
+            {
+                // 1e-20: should return 22 characters: "0.000..1"
+                var value = QuantityValue.FromPowerOfTen(1, 1, -20);
+                var destination = new Span<char>(new char[21]);
+                var result = value.TryFormat(destination, out var charsWritten, "F20", CultureInfo.InvariantCulture);
+                Assert.False(result);
+                // Assert.Equal(0, charsWritten); // TODO should we make sure that nothing was written?
+                
+            }
+#endif
+        }
+
+        /// <summary>
+        ///     The numeric ("N") format specifier converts a number to a string of the form "-d,ddd,ddd.ddd…", where "-" indicates
+        ///     a negative number symbol if required, "d" indicates a digit (0-9), "," indicates a group separator, and "."
+        ///     indicates a decimal point symbol. The precision specifier indicates the desired number of digits after the decimal
+        ///     point. If the precision specifier is omitted, the number of decimal places is defined by the current
+        ///     NumberFormatInfo.NumberDecimalDigits property.
+        /// </summary>
+        public class NumericFormatTests
+        {
+            private static readonly string[] NumberFormats = ["N", "N0", "N1", "N2", "N3", "N4", "N5", "N6"];
+
+            private static readonly int[] NumberNegativePatterns =
+            [
+                0, // (n)
+                1, // -n
+                2, // - n
+                3, // n-
+                4 // n -
+            ];
+
+            [Fact]
+            public void NumberFormat_WithInvalidNumberNegativePatterns_ThrowsArgumentOutOfRangeException()
+            {
+                var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                var numberFormat = formatProvider.NumberFormat;
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.NumberNegativePattern = -1);
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.NumberNegativePattern = 5);
+            }
+
+            [Fact]
+            public void NumberFormat_WithInvalidNumberDecimalDigits_ThrowsArgumentOutOfRangeException()
+            {
+                var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                var numberFormat = formatProvider.NumberFormat;
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.NumberDecimalDigits = -1);
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.NumberDecimalDigits = 100);
+            }
+
+            [Theory]
+            [ClassData(typeof(TerminatingFractionCases))]
+            public void ToString_WithTerminatingFraction(ValueFormatPair testCase, string expected)
+            {
+                var (value, format) = testCase;
+                var result = value.ToString(format);
+                Assert.Equal(expected, result);
+            }
+
+            [Theory]
+            [ClassData(typeof(NonTerminatingFractionCases))]
+            public void ToString_WithNonTerminatingFraction(ValueFormatPair testCase, string expected)
+            {
+                var (value, format) = testCase;
+                var result = value.ToString(format);
+                Assert.Equal(expected, result);
+            }
+
+            [Theory]
+            [ClassData(typeof(NegativePatternCases))]
+            public void ToString_WithCustomNegativePattern(ValueFormatPair testCase, int pattern, string expected)
+            {
+                // Arrange
+                var (value, format) = testCase;
+                var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                formatProvider.NumberFormat.NumberNegativePattern = pattern;
+                // Act
+                var result = value.ToString(format, formatProvider);
+                // Assert
+                Assert.Equal(expected, result);
+            }
+
+            [Fact]
+            public void ToString_N250_ReturnsTheExpectedResult()
+            {
+                // Arrange
+                QuantityValue value = 4.2;
+                var expected = "4.2" + new string(Enumerable.Repeat('0', 249).ToArray());
+                // Act
+                var result = value.ToString("N250", CultureInfo.InvariantCulture);
+                // Assert
+                Assert.Equal(expected, result);
+            }
+            
+#if NET
+            [Fact]
+            public void TryFormat_Zero_WithValidSpanLength_ReturnsTrue()
+            {
+                // Arrange
+                QuantityValue value = 0;
+                var destination = new Span<char>(new char[4]);
+                // Act
+                var result = value.TryFormat(destination, out var charsWritten, "N", CultureInfo.InvariantCulture);
+                // Assert
+                Assert.True(result);
+                Assert.Equal(4, charsWritten);
+                Assert.Equal("0.00", destination[Range.EndAt(charsWritten)]);
+            }
+            
+            [Fact]
+            public void TryFormat_NegativeInteger_WithValidSpanLength_ReturnsTrue()
+            {
+                // Arrange
+                QuantityValue value = -4200;
+                var destination = new Span<char>(new char[9]);
+                // Act
+                var result = value.TryFormat(destination, out var charsWritten, "N", CultureInfo.InvariantCulture);
+                // Assert
+                Assert.True(result);
+                Assert.Equal(9, charsWritten);
+                Assert.Equal("-4,200.00", destination[Range.EndAt(charsWritten)]);
+            }
+            
+            [Fact]
+            public void TryFormat_NegativeDecimal_WithValidSpanLength_ReturnsTrue()
+            {
+                // Arrange
+                QuantityValue value = -4.2;
+                var destination = new Span<char>(new char[5]);
+                // Act
+                var result = value.TryFormat(destination, out var charsWritten, "N", CultureInfo.InvariantCulture);
+                // Assert
+                Assert.True(result);
+                Assert.Equal(5, charsWritten);
+                Assert.Equal("-4.20", destination[Range.EndAt(charsWritten)]);
+            }
+
+            [Theory]
+            [InlineData(-0.1, "N1", 0, 0)] // (n)
+            [InlineData(-0.1, "N1", 0, 1)] // (n)
+            [InlineData(-0.1, "N1", 0, 4)] // (n)
+            [InlineData(-0.1, "N1", 1, 0)] // -n
+            [InlineData(-0.1, "N1", 2, 0)] // - n
+            [InlineData(-0.1, "N1", 2, 1)] // - n
+            [InlineData(-0.1, "N1", 3, 3)] // n-
+            [InlineData(-0.1, "N1", 4, 3)] // n -
+            [InlineData(-0.1, "N1", 4, 4)] // n -
+            public void TryFormat_NegativeNumber_WithInvalidSpanLength_ReturnsFalse(decimal decimalValue, string format, int pattern, int testLength)
+            {
+                // Arrange
+                var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                formatProvider.NumberFormat.NumberNegativePattern = pattern;
+                QuantityValue value = decimalValue;
+                var destination = new Span<char>(new char[testLength]);
+                // Act
+                var result = value.TryFormat(destination, out var charsWritten, format, formatProvider);
+                // Assert
+                Assert.False(result);
+                // Assert.Equal(0, charsWritten); // TODO should we make sure that nothing was written?
+            }
+#endif
+
+            public sealed class TerminatingFractionCases : TheoryData<ValueFormatPair, string>
+            {
+                public TerminatingFractionCases()
+                {
+                    foreach (var value in TerminatingFractions)
+                    {
+                        foreach (var format in NumberFormats)
+                        {
+                            Add(new ValueFormatPair(value, format), value.Value.ToDecimal().ToString(format));
+                        }
+                    }
+                }
+            }
+
+            public sealed class NonTerminatingFractionCases : TheoryData<ValueFormatPair, string>
+            {
+                public NonTerminatingFractionCases()
+                {
+                    foreach (var value in NonTerminatingFractions)
+                    {
+                        foreach (var format in NumberFormats)
+                        {
+                            Add(new ValueFormatPair(value, format), value.Value.ToDecimal().ToString(format));
+                        }
+                    }
+                }
+            }
+
+            public sealed class NegativePatternCases : TheoryData<ValueFormatPair, int, string>
+            {
+                public NegativePatternCases()
+                {
+                    QuantityValue[] valuesToTest = [1, 0, -0.1m, -1, -1.23456789m];
+                    foreach (var pattern in NumberNegativePatterns)
+                    {
+                        var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                        formatProvider.NumberFormat.NumberNegativePattern = pattern;
+                        foreach (var format in NumberFormats)
+                        {
+                            foreach (var value in valuesToTest)
+                            {
+                                Add(new ValueFormatPair(value, format), pattern, value.ToDecimal().ToString(format, formatProvider));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Exponential format specifier (E)
+        ///     The exponential ("E") format specifier converts a number to a string of the form "-d.ddd…E+ddd" or "-d.ddd…e+ddd",
+        ///     where each "d" indicates a digit (0-9). The string starts with a minus sign if the number is negative. Exactly one
+        ///     digit always precedes the decimal point.
+        ///     The precision specifier indicates the desired number of digits after the decimal point. If the precision specifier
+        ///     is omitted, a default of six digits after the decimal point is used.
+        ///     The case of the format specifier indicates whether to prefix the exponent with an "E" or an "e". The exponent
+        ///     always consists of a plus or minus sign and a minimum of three digits. The exponent is padded with zeros to meet
+        ///     this minimum, if required.
+        /// </summary>
+        public class ExponentialFormatTests
+        {
+            private static readonly string[] ScientificFormats = ["E", "E0", "E1", "E2", "E3", "E4", "E5", "E6", "e1", "e6"];
+
+            [Theory]
+            [ClassData(typeof(TerminatingFractionCases))]
+            public void ToString_WithTerminatingFraction(ValueFormatPair testCase, string expected)
+            {
+                var (value, format) = testCase;
+                var result = value.ToString(format);
+                Assert.Equal(expected, result);
+            }
+
+            public sealed class TerminatingFractionCases : TheoryData<ValueFormatPair, string>
+            {
+                public TerminatingFractionCases()
+                {
+                    foreach (var value in TerminatingFractions)
+                    {
+                        foreach (var format in ScientificFormats)
+                        {
+                            Add(new ValueFormatPair(value, format), value.Value.ToDecimal().ToString(format));
+                        }
+                    }
+                }
+            }    
+            
+#if NET
+            [Fact]
+            public void TryFormat_Zero_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = 0;
+                var destination = new Span<char>(new char[13]);
+                var result = value.TryFormat(destination, out var charsWritten, "E", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(13, charsWritten);
+                Assert.Equal("0.000000E+000", destination[Range.EndAt(charsWritten)]);
+            }
+            
+            [Fact]
+            public void TryFormat_NegativeNumber_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = -42;
+                var destination = new Span<char>(new char[14]);
+                var result = value.TryFormat(destination, out var charsWritten, "E", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(14, charsWritten);
+                Assert.Equal("-4.200000E+001", destination[Range.EndAt(charsWritten)]);
+            }
+            
+            [Fact]
+            public void TryFormat_SmallNegativeNumber_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = -0.00042;
+                var destination = new Span<char>(new char[14]);
+                var result = value.TryFormat(destination, out var charsWritten, "E", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(14, charsWritten);
+                Assert.Equal("-4.200000E-004", destination[Range.EndAt(charsWritten)]);
+            }
+
+            [Theory]
+            [InlineData(-1.5, "E0", 0)]
+            [InlineData(1.5, "E0", 0)]
+            [InlineData(123.456, "E2", 3)] // 1.2[3E+002]
+            [InlineData(123.456, "E2", 4)] // 1.23[E+002]
+            [InlineData(123.456, "E2", 5)] // 1.23E[+002]
+            [InlineData(123.456, "E2", 8)] // 1.23E+00[2]
+            public void TryFormat_WithInvalidSpanLength_ReturnsFalse(decimal decimalValue, string format, int testLength)
+            {
+                QuantityValue value= decimalValue;
+                var destination = new Span<char>(new char[testLength]);
+                var result = value.TryFormat(destination, out var charsWritten, format, CultureInfo.InvariantCulture);
+                Assert.False(result);
+                // Assert.Equal(0, charsWritten); // TODO should we make sure that nothing was written?
+            }
+#endif
+        }
+
+        /// <summary>
+        ///     The "C" (or currency) format specifier converts a number to a string that represents a currency amount. The
+        ///     precision specifier indicates the desired number of decimal places in the result string. If the precision specifier
+        ///     is omitted, the default precision is defined by the NumberFormatInfo.CurrencyDecimalDigits property.
+        ///     If the value to be formatted has more than the specified or default number of decimal places, the fractional value
+        ///     is rounded in the result string. If the value to the right of the number of specified decimal places is 5 or
+        ///     greater, the last digit in the result string is rounded away from zero.
+        /// </summary>
+        public class CurrencyFormatTests
+        {
+            private static readonly string[] CurrencyFormats = ["C", "C0", "C1", "C2", "C3", "C4", "C5", "C6"];
+
+            public static readonly int[] CurrencyPositivePatterns =
+            [
+                00, // $n
+                01, // n$
+                02, // $ n
+                03 // n $
+            ];
+
+            public static readonly int[] CurrencyNegativePatterns =
+            [
+                00, // ($n)
+                01, // -$n
+                02, // $-n
+                03, // $n-
+                04, // (n$)
+                05, // -n$
+                06, // n-$
+                07, // n$-
+                08, // -n $
+                09, // -$ n
+                10, // n $-
+                11, // $ n-
+                12, // $ -n
+                13, // n- $
+                14, // ($ n)
+                15, // (n $)
+#if NET
+                16, // $- n
+#endif
+            ];
+
+            [Fact]
+            public void CurrencyPositivePattern_WithInvalidValue_ThrowsArgumentOutOfRangeException()
+            {
+                var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                var numberFormat = formatProvider.NumberFormat;
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.CurrencyPositivePattern = -1);
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.CurrencyPositivePattern = 4);
+            }
+
+            [Fact]
+            public void CurrencyNegativePattern_WithInvalidValue_ThrowsArgumentOutOfRangeException()
+            {
+                var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                var numberFormat = formatProvider.NumberFormat;
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.CurrencyNegativePattern = -1);
+#if NET
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.CurrencyNegativePattern = 17);
+#else
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.CurrencyNegativePattern = 16);
+#endif
+            }
+
+            [Theory]
+            [ClassData(typeof(TerminatingFractionCases))]
+            public void ToString_WithTerminatingFraction(ValueFormatPair testCase, string expected)
+            {
+                var (value, format) = testCase;
+                var result = value.ToString(format);
+                Assert.Equal(expected, result);
+            }
+
+            [Fact]
+            public void ToString_C250_ReturnsTheExpectedResult()
+            {
+                QuantityValue value = 4.2;
+                var expected = "$4.2" + new string(Enumerable.Repeat('0', 249).ToArray());
+                
+                var result = value.ToString("C250", CultureInfo.GetCultureInfo("en-US"));
+                
+                Assert.Equal(expected, result);
+            }
+
+#if NET
+            [Fact]
+            public void TryFormat_Zero_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = 0;
+                var destination = new Span<char>(new char[5]);
+                var result = value.TryFormat(destination, out var charsWritten, "C", CultureInfo.GetCultureInfo("en-US"));
+                Assert.True(result);
+                Assert.Equal(5, charsWritten);
+                Assert.Equal("$0.00", destination[Range.EndAt(charsWritten)]);
+            }
+            
+            [Fact]
+            public void TryFormat_NegativeInteger_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = -42;
+                var destination = new Span<char>(new char[7]);
+                var result = value.TryFormat(destination, out var charsWritten, "C", CultureInfo.GetCultureInfo("en-US"));
+                Assert.True(result);
+                Assert.Equal(7, charsWritten);
+                Assert.Equal("-$42.00", destination[Range.EndAt(charsWritten)]);
+            }
+            
+            [Fact]
+            public void TryFormat_NegativeDecimal_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = -4.2;
+                var destination = new Span<char>(new char[6]);
+                var result = value.TryFormat(destination, out var charsWritten, "C", CultureInfo.GetCultureInfo("en-US"));
+                Assert.True(result);
+                Assert.Equal(6, charsWritten);
+                Assert.Equal("-$4.20", destination[Range.EndAt(charsWritten)]);
+            }
+            
+            [Theory]
+            [InlineData(0.1, "C1", 0, 0)] // $n
+            [InlineData(0.1, "C1", 0, 3)] // $n
+            [InlineData(0.1, "C1", 1, 3)] // n$ 
+            [InlineData(0.1, "C1", 2, 1)] // $ n
+            [InlineData(0.1, "C1", 3, 4)] // n $
+            // [InlineData(0.1, "C0", 2, 1)] // $ n
+            // [InlineData(0.1, "C1", 3, 0)] // n $
+            // [InlineData(0.1, "C1", 3, 1)] // n $
+            public void TryFormat_PositiveNumber_WithInvalidSpanLength_ReturnsFalse(decimal decimalValue, string format, int pattern, int testLength)
+            {
+                // Arrange
+                var formatProvider = (CultureInfo)CultureInfo.GetCultureInfo("en-US").Clone();
+                formatProvider.NumberFormat.CurrencyPositivePattern = pattern;
+                QuantityValue value = decimalValue;
+                var destination = new Span<char>(new char[testLength]);
+                // Act
+                var result = value.TryFormat(destination, out var charsWritten, format, formatProvider);
+                // Assert
+                Assert.False(result);
+                // Assert.Equal(0, charsWritten); // TODO should we make sure that nothing was written?
+            }
+            
+            [Theory]
+            [InlineData(-0.1, "C1", 0, 3)] // ($n)
+            [InlineData(-0.1, "C1", 0, 4)] // ($n)
+            [InlineData(-0.1, "C1", 0, 5)] // ($n)
+            [InlineData(-0.1, "C1", 1, 2)] // -$n
+            [InlineData(-0.1, "C1", 2, 2)] // $-n
+            [InlineData(-0.1, "C1", 3, 2)] // $n-
+            [InlineData(-0.1, "C1", 3, 4)] // $n-
+            [InlineData(-0.1, "C1", 4, 3)] // (n$)
+            [InlineData(-0.1, "C1", 4, 5)] // (n$)
+            [InlineData(-0.1, "C1", 5, 2)] // -n$
+            [InlineData(-0.1, "C1", 5, 4)] // -n$
+            [InlineData(-0.1, "C1", 6, 4)] // n-$
+            [InlineData(-0.1, "C1", 7, 4)] // n$-
+            [InlineData(-0.1, "C1", 8, 3)] // -n $
+            [InlineData(-0.1, "C1", 8, 5)] // -n $
+            [InlineData(-0.1, "C1", 9, 3)] // -$ n
+            [InlineData(-0.1, "C1", 10, 5)] // n $-
+            [InlineData(-0.1, "C1", 11, 3)] // $ n-
+            [InlineData(-0.1, "C1", 11, 5)] // $ n-
+            [InlineData(-0.1, "C1", 12, 3)] // $ -n
+            [InlineData(-0.1, "C1", 13, 5)] // n- $
+            [InlineData(-0.1, "C1", 14, 4)] // ($ n)
+            [InlineData(-0.1, "C1", 14, 6)] // ($ n)
+            [InlineData(-0.1, "C1", 15, 4)] // (n $)
+            [InlineData(-0.1, "C1", 15, 6)] // (n $)
+            [InlineData(-0.1, "C1", 16, 3)] // $- n
+            public void TryFormat_NegativeNumber_WithInvalidSpanLength_ReturnsFalse(decimal decimalValue, string format, int pattern, int testLength)
+            {
+                // Arrange
+                var formatProvider = (CultureInfo)CultureInfo.GetCultureInfo("en-US").Clone();
+                formatProvider.NumberFormat.CurrencyNegativePattern = pattern;
+                QuantityValue value = decimalValue;
+                var destination = new Span<char>(new char[testLength]);
+                // Act
+                var result = value.TryFormat(destination, out var charsWritten, format, formatProvider);
+                // Assert
+                Assert.False(result);
+                // Assert.Equal(0, charsWritten); // TODO should we make sure that nothing was written?
+            }
+#endif
+
+            [Theory]
+            [ClassData(typeof(NegativePatternCases))]
+            public void ToString_WithCustomNegativePattern(ValueFormatPair testCase, int pattern, string expected)
+            {
+                // Arrange
+                var (value, format) = testCase;
+                var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                formatProvider.NumberFormat.CurrencyNegativePattern = pattern;
+                // Act
+                var result = value.ToString(format, formatProvider);
+                // Assert
+                Assert.Equal(expected, result);
+            }
+
+            [Theory]
+            [ClassData(typeof(PositivePatternCases))]
+            public void ToString_WithCustomPositivePattern(ValueFormatPair testCase, int pattern, string expected)
+            {
+                // Arrange
+                var (value, format) = testCase;
+                var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                formatProvider.NumberFormat.CurrencyPositivePattern = pattern;
+                // Act
+                var result = value.ToString(format, formatProvider);
+                // Assert
+                Assert.Equal(expected, result);
+            }
+
+            public sealed class TerminatingFractionCases : TheoryData<ValueFormatPair, string>
+            {
+                public TerminatingFractionCases()
+                {
+                    foreach (var value in TerminatingFractions)
+                    {
+                        foreach (var format in CurrencyFormats)
+                        {
+                            Add(new ValueFormatPair(value, format), value.Value.ToDecimal().ToString(format));
+                        }
+                    }
+                }
+            }
+
+            public sealed class NegativePatternCases : TheoryData<ValueFormatPair, int, string>
+            {
+                public NegativePatternCases()
+                {
+                    QuantityValue[] valuesToTest = [1, 0, -0.1m, -1, -1.23456789m];
+                    foreach (var pattern in CurrencyNegativePatterns)
+                    {
+                        var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                        formatProvider.NumberFormat.CurrencyNegativePattern = pattern;
+                        foreach (var format in CurrencyFormats)
+                        {
+                            foreach (var value in valuesToTest)
+                            {
+                                Add(new ValueFormatPair(value, format), pattern, value.ToDecimal().ToString(format, formatProvider));
+                            }
+                        }
+                    }
+                }
+            }
+
+            public sealed class PositivePatternCases : TheoryData<ValueFormatPair, int, string>
+            {
+                public PositivePatternCases()
+                {
+                    QuantityValue[] valuesToTest = [-1, 0, 0.1m, 1, 1.2345789m];
+                    foreach (var pattern in CurrencyPositivePatterns)
+                    {
+                        var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                        formatProvider.NumberFormat.CurrencyPositivePattern = pattern;
+                        foreach (var format in CurrencyFormats)
+                        {
+                            foreach (var value in valuesToTest)
+                            {
+                                Add(new ValueFormatPair(value, format), pattern, value.ToDecimal().ToString(format, formatProvider));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///     The percent ("P") format specifier multiplies a number by 100 and converts it to a string that represents a
+        ///     percentage. The precision specifier indicates the desired number of decimal places. If the precision specifier is
+        ///     omitted, the default numeric precision supplied by the current PercentDecimalDigits property is used.
+        /// </summary>
+        public class PercentageFormatTests
+        {
+            private static readonly string[] PercentFormats = ["P", "P0", "P1", "P2", "P3", "P4", "P5", "P6"];
+
+            public static readonly int[] PercentPositivePatterns =
+            [
+                00, // n %
+                01, // n%
+                02, // %n
+                03 // % n
+            ];
+
+            public static readonly int[] PercentNegativePatterns =
+            [
+                00, // -n %
+                01, // -n%
+                02, // -%n
+                03, // %-n
+                04, // n- %
+                05, // n-%
+                06, // %n-
+                07, // n %-
+                08, // -% n
+                09, // %- n
+                10, // n %- 
+                11 // % n-
+            ];
+
+            [Fact]
+            public void PercentPositivePattern_WithInvalidValue_ThrowsArgumentOutOfRangeException()
+            {
+                var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                var numberFormat = formatProvider.NumberFormat;
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.PercentPositivePattern = -1);
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.PercentPositivePattern = 4);
+            }
+
+            [Fact]
+            public void PercentNegativePattern_WithInvalidValue_ThrowsArgumentOutOfRangeException()
+            {
+                var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                var numberFormat = formatProvider.NumberFormat;
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.PercentNegativePattern = -1);
+                Assert.Throws<ArgumentOutOfRangeException>(() => numberFormat.PercentNegativePattern = 12);
+            }
+
+            [Theory]
+            [ClassData(typeof(TerminatingFractionCases))]
+            public void ToString_WithTerminatingFraction(ValueFormatPair testCase, string expected)
+            {
+                var (value, format) = testCase;
+                var result = value.ToString(format);
+                Assert.Equal(expected, result);
+            }
+
+            [Theory]
+            [ClassData(typeof(NegativePatternCases))]
+            public void ToString_WithCustomNegativePattern(ValueFormatPair testCase, int pattern, string expected)
+            {
+                // Arrange
+                var (value, format) = testCase;
+                var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                formatProvider.NumberFormat.PercentNegativePattern = pattern;
+                // Act
+                var result = value.ToString(format, formatProvider);
+                // Assert
+                Assert.Equal(expected, result);
+            }
+
+            [Theory]
+            [ClassData(typeof(PositivePatternCases))]
+            public void ToString_WithCustomPositivePattern(ValueFormatPair testCase, int pattern, string expected)
+            {
+                // Arrange
+                var (value, format) = testCase;
+                var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                formatProvider.NumberFormat.PercentPositivePattern = pattern;
+                // Act
+                var result = value.ToString(format, formatProvider);
+                // Assert
+                Assert.Equal(expected, result);
+            }
+
+            [Fact]
+            public void ToString_P250_ReturnsTheExpectedResult()
+            {
+                QuantityValue value = 0.042;
+                var expected = "4.2" + new string(Enumerable.Repeat('0', 249).Append(' ').Append('%').ToArray());
+                
+                var result = value.ToString("P250", CultureInfo.InvariantCulture);
+                
+                Assert.Equal(expected, result);
+            }
+            
+#if NET
+            [Fact]
+            public void TryFormat_Zero_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = 0;
+                var destination = new Span<char>(new char[6]);
+                var result = value.TryFormat(destination, out var charsWritten, "P", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(6, charsWritten);
+                Assert.Equal("0.00 %", destination[Range.EndAt(charsWritten)]);
+            }
+            
+            [Fact]
+            public void TryFormat_NegativeInteger_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = -2;
+                var destination = new Span<char>(new char[9]);
+                var result = value.TryFormat(destination, out var charsWritten, "P", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(9, charsWritten);
+                Assert.Equal("-200.00 %", destination[Range.EndAt(charsWritten)]);
+            }
+            
+            [Fact]
+            public void TryFormat_NegativeDecimal_WithValidSpanLength_ReturnsTrue()
+            {
+                QuantityValue value = -0.042;
+                var destination = new Span<char>(new char[7]);
+                var result = value.TryFormat(destination, out var charsWritten, "P", CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(7, charsWritten);
+                Assert.Equal("-4.20 %", destination[Range.EndAt(charsWritten)]);
+            }
+            
+            [Theory]
+            [InlineData(0.1, "P1", 0, 0)] // n %
+            [InlineData(0.1, "P1", 0, 4)] // n %
+            [InlineData(0.1, "P1", 0, 5)] // n %
+            [InlineData(0.1, "P0", 1, 2)] // n% 
+            [InlineData(0.1, "P0", 2, 0)] // %n
+            [InlineData(0.1, "P0", 2, 1)] // %n
+            [InlineData(0.1, "P1", 3, 0)] // % n
+            [InlineData(0.1, "P1", 3, 1)] // % n
+            public void TryFormat_PositiveNumber_WithInvalidSpanLength_ReturnsFalse(decimal decimalValue, string format, int pattern, int testLength)
+            {
+                // Arrange
+                var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                formatProvider.NumberFormat.PercentPositivePattern = pattern;
+                QuantityValue value = decimalValue;
+                var destination = new Span<char>(new char[testLength]);
+                // Act
+                var result = value.TryFormat(destination, out var charsWritten, format, formatProvider);
+                // Assert
+                Assert.False(result);
+                // Assert.Equal(0, charsWritten); // TODO should we make sure that nothing was written?
+            }
+            
+            [Theory]
+            [InlineData(-0.1, "P1", 0, 0)] // -n %
+            [InlineData(-0.1, "P1", 0, 4)] // -n %
+            [InlineData(-0.1, "P1", 0, 5)] // -n %
+            [InlineData(-0.1, "P1", 0, 6)] // -n %
+            [InlineData(-0.1, "P1", 1, 0)] // -n%
+            [InlineData(-0.1, "P1", 1, 5)] // -n%
+            [InlineData(-0.1, "P0", 2, 0)] // -%n
+            [InlineData(-0.1, "P0", 2, 1)] // -%n
+            [InlineData(-0.1, "P0", 2, 3)] // -%n
+            [InlineData(-0.1, "P0", 3, 0)] // %-n
+            [InlineData(-0.1, "P0", 3, 1)] // %-n
+            [InlineData(-0.1, "P0", 4, 0)] // %n-
+            [InlineData(-0.1, "P0", 4, 3)] // %n-
+            [InlineData(-0.1, "P0", 5, 2)] // n-%
+            [InlineData(-0.1, "P0", 5, 3)] // n-%
+            [InlineData(-0.1, "P0", 6, 2)] // n%-
+            [InlineData(-0.1, "P0", 6, 3)] // n%-
+            [InlineData(-0.1, "P0", 7, 0)] // -% n
+            [InlineData(-0.1, "P0", 7, 1)] // -% n
+            [InlineData(-0.1, "P0", 7, 2)] // -% n
+            [InlineData(-0.1, "P0", 8, 4)] // n %-
+            [InlineData(-0.1, "P0", 9, 0)] // % n
+            [InlineData(-0.1, "P0", 9, 1)] // % n
+            [InlineData(-0.1, "P0", 9, 4)] // % n
+            [InlineData(-0.1, "P0", 10, 0)] // % -n
+            [InlineData(-0.1, "P0", 10, 1)] // % -n
+            [InlineData(-0.1, "P0", 10, 2)] // % -n
+            [InlineData(-0.1, "P0", 11, 2)] // n- %
+            [InlineData(-0.1, "P0", 11, 3)] // n- %
+            [InlineData(-0.1, "P0", 11, 4)] // n- %
+            public void TryFormat_NegativeNumber_WithInvalidSpanLength_ReturnsFalse(decimal decimalValue, string format, int pattern, int testLength)
+            {
+                // Arrange
+                var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                formatProvider.NumberFormat.PercentNegativePattern = pattern;
+                QuantityValue value = decimalValue;
+                var destination = new Span<char>(new char[testLength]);
+                // Act
+                var result = value.TryFormat(destination, out var charsWritten, format, formatProvider);
+                // Assert
+                Assert.False(result);
+                // Assert.Equal(0, charsWritten); // TODO should we make sure that nothing was written?
+            }
+#endif
+
+            public sealed class TerminatingFractionCases : TheoryData<ValueFormatPair, string>
+            {
+                public TerminatingFractionCases()
+                {
+                    foreach (var value in TerminatingFractions)
+                    {
+                        foreach (var format in PercentFormats)
+                        {
+                            Add(new ValueFormatPair(value, format), value.Value.ToDecimal().ToString(format));
+                            // Add(new ValueFormatPair(value, format), value.Value.ToDouble().ToString(format));
+                        }
+                    }
+                }
+            }
+
+            public sealed class PositivePatternCases : TheoryData<ValueFormatPair, int, string>
+            {
+                public PositivePatternCases()
+                {
+                    QuantityValue[] valuesToTest = [-1, 0, 0.1m, 1, 1.2345789m];
+                    foreach (var pattern in PercentPositivePatterns)
+                    {
+                        var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                        formatProvider.NumberFormat.PercentPositivePattern = pattern;
+                        foreach (var format in PercentFormats)
+                        {
+                            foreach (var value in valuesToTest)
+                            {
+                                Add(new ValueFormatPair(value, format), pattern, value.ToDecimal().ToString(format, formatProvider));
+                            }
+                        }
+                    }
+                }
+            }
+
+            public sealed class NegativePatternCases : TheoryData<ValueFormatPair, int, string>
+            {
+                public NegativePatternCases()
+                {
+                    QuantityValue[] valuesToTest = [1, 0, -0.1m, -1, -1.23456789m];
+                    foreach (var pattern in PercentNegativePatterns)
+                    {
+                        var formatProvider = (CultureInfo)CultureInfo.CurrentCulture.Clone();
+                        formatProvider.NumberFormat.PercentNegativePattern = pattern;
+                        foreach (var format in PercentFormats)
+                        {
+                            foreach (var value in valuesToTest)
+                            {
+                                Add(new ValueFormatPair(value, format), pattern, value.ToDecimal().ToString(format, formatProvider));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+
+        public class RemovedQuantitySpecificFormatTests
+        {
+            [Theory]
+            [InlineData("S")]
+            [InlineData("s2")]
+            [InlineData("S+4")]
+            public void ToString_ThrowsWithMigrationGuidance(string format)
+            {
+                FormatException exception = Assert.Throws<FormatException>(
+                    () => QuantityValue.One.ToString(format, CultureInfo.InvariantCulture));
+
+                Assert.Contains("no longer supported", exception.Message, StringComparison.Ordinal);
+            }
+
+#if NET
+            [Fact]
+            public void TryFormat_ThrowsWithMigrationGuidance()
+            {
+                FormatException exception = Assert.Throws<FormatException>(
+                    () => QuantityValue.One.TryFormat(new char[16], out _, "S2", CultureInfo.InvariantCulture));
+
+                Assert.Contains("no longer supported", exception.Message, StringComparison.Ordinal);
+            }
+#endif
+        }
+
+        public class CustomFormatTests
+        {
+            [Theory]
+            [ClassData(typeof(CustomFormatCases))]
+            public void ToString_WithCustomFormat(ValueFormatPair pair, string expected)
+            {
+                var (value, format) = pair;
+                var actual = value.ToString(format, CultureInfo.InvariantCulture);
+                Assert.Equal(expected, actual);
+            }
+
+#if NET
+            [Theory]
+            [ClassData(typeof(CustomFormatCases))]
+            public void TryFormat_WithCustomFormat(ValueFormatPair pair, string expected)
+            {
+                var (value, format) = pair;
+                var destination = new Span<char>(new char[100]);
+                var result = value.TryFormat(destination, out var charsWritten, format, CultureInfo.InvariantCulture);
+                Assert.True(result);
+                Assert.Equal(expected, destination[Range.EndAt(charsWritten)]);
+            }
+#endif
+
+            [Fact]
+            public void NumberFormat_WithEmptySign_DoesNotThrow()
+            {
+                var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
+                var numberFormat = formatProvider.NumberFormat;
+                Assert.Equal("", numberFormat.NegativeSign = "");
+                Assert.Equal(" ", numberFormat.NegativeSign = " ");
+                Assert.Equal("1", numberFormat.NegativeSign = "1");
+            }
+
+            public sealed class CustomFormatCases : TheoryData<ValueFormatPair, string>
+            {
+                public CustomFormatCases()
+                {
+                    var oneHalf = new QuantityValue(1, 2);
+                    Add(new ValueFormatPair(oneHalf, "Test: 0.00"), "Test: 0.50");
+                    Add(new ValueFormatPair(oneHalf, "Guess: 0.00"), "Guess: 0.50");
+                    Add(new ValueFormatPair(oneHalf, "Feet: 0.00"), "Feet: 0.50");
+                    Add(new ValueFormatPair(oneHalf, "Number: 0.00"), "Number: 0.50");
+                    Add(new ValueFormatPair(oneHalf, "Eons: 0.00"), "Eons: 0.50");
+                    Add(new ValueFormatPair(oneHalf, "Cans: 0.00"), "Cans: 0.50");
+                    Add(new ValueFormatPair(oneHalf, "Parsecs: 0.00"), "Parsecs: 0.50");
+                    Add(new ValueFormatPair(oneHalf, "Some: 0.00"), "Some: 0.50");
+                }
+            }
+        }
+
+        [Fact]
+        public void ToString_DefaultsToTheGeneralFormat_WithCurrentCulture()
+        {
+            var value = new QuantityValue(1, 3);
+            // ReSharper disable once SpecifyACultureInStringConversionExplicitly
+            Assert.Equal(value.ToString("G", CultureInfo.CurrentCulture), value.ToString());
+            Assert.Equal(value.ToString("G", CultureInfo.CurrentCulture), value.ToString(string.Empty));
+            Assert.Equal(value.ToString("G", CultureInfo.CurrentCulture), value.ToString(null, null));
+        }
+
+        [Fact]
+        public void ToString_WithTheRoundTripFormat_ReturnsTheDoubleRepresentation()
+        {
+            QuantityValue value = 123.456m;
+            var expectedValue = value.ToDouble().ToString("R");
+            var result = value.ToString("R");
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Fact]
+        public void ToString_WithNaNOrInfinity_ReturnsTheCorrespondingSymbol()
+        {
+            Assert.Multiple(
+                () => Assert.Equal(double.NaN.ToString(null, null), QuantityValue.NaN.ToString(null, null)),
+                () => Assert.Equal(double.PositiveInfinity.ToString(null, null), QuantityValue.PositiveInfinity.ToString(null, null)),
+                () => Assert.Equal(double.NegativeInfinity.ToString(null, null), QuantityValue.NegativeInfinity.ToString(null, null))
+            );
+        }
+
+#if NET
+        [Fact]
+        public void TryFormat_DefaultsToTheGeneralFormat_WithCurrentCulture()
+        {
+            var value = new QuantityValue(1, 3);
+            Span<char> buffer = stackalloc char[32];
+            Assert.True(value.TryFormat(buffer, out var charsWritten, default, null));
+            Assert.Equal(value.ToString("G", CultureInfo.CurrentCulture), buffer[..charsWritten]);
+        }
+        
+        [Fact]
+        public void TryFormat_NaNOrInfinity_ReturnsTheCorrespondingSymbol()
+        {
+            Assert.Multiple(
+                () =>
+                {
+                    Span<char> buffer = stackalloc char[32];
+                    Assert.True(QuantityValue.NaN.TryFormat(buffer, out var charsWritten, null, null));
+                    Assert.Equal(double.NaN.ToString(null, null), new string(buffer[..charsWritten]));
+                },
+                () =>
+                {
+                    Span<char> buffer = stackalloc char[32];
+                    Assert.True(QuantityValue.PositiveInfinity.TryFormat(buffer, out var charsWritten, null, null));
+                    Assert.Equal(double.PositiveInfinity.ToString(null, null), new string(buffer[..charsWritten]));
+                },
+                () =>
+                {
+                    Span<char> buffer = stackalloc char[32];
+                    Assert.True(QuantityValue.NegativeInfinity.TryFormat(buffer, out var charsWritten, null, null));
+                    Assert.Equal(double.NegativeInfinity.ToString(null, null), new string(buffer[..charsWritten]));
+                }
+            );
+        }
+
+        [Fact]
+        public void TryFormat_NaNOrInfinity_WithInvalidSpanLength_ReturnsFalse()
+        {
+            Assert.Multiple(
+                () =>
+                {
+                    Assert.False(QuantityValue.NaN.TryFormat(Span<char>.Empty, out var charsWritten, null, null));
+                    Assert.Equal(0, charsWritten);
+                },
+                () =>
+                {
+                    Assert.False(QuantityValue.PositiveInfinity.TryFormat(Span<char>.Empty, out var charsWritten, null, null));
+                    Assert.Equal(0, charsWritten);
+                },
+                () =>
+                {
+                    Assert.False(QuantityValue.NegativeInfinity.TryFormat(Span<char>.Empty, out var charsWritten, null, null));
+                    Assert.Equal(0, charsWritten);
+                }
+            );
+        }
+#endif
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.DebugView.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.DebugView.cs
new file mode 100644
index 0000000000..4eee2ea9ad
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.DebugView.cs
@@ -0,0 +1,89 @@
+using System.Numerics;
+using JetBrains.Annotations;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    [TestSubject(typeof(QuantityValue.QuantityValueDebugView))]
+    public class DebugViewTests
+    {
+        [Theory]
+        [InlineData(1, 1, true, 2)]
+        [InlineData(2, 4, false, 5)]
+        [InlineData(0, 1, true, 1)]
+        [InlineData(1, 0, true, 1)] // Corner case: Denominator is zero
+        [InlineData(-200, 1, true, 9)] // Negative numerator
+        [InlineData(0, 0, true, 0)] // Both numerator and denominator are zero
+        public void QuantityValueDebugView_Properties_ShouldReturnExpectedValues(
+            int numerator, int denominator, bool expectedIsReduced, long expectedNbBits)
+        {
+            var value = new QuantityValue(new BigInteger(numerator), new BigInteger(denominator));
+            var debugView = new QuantityValue.QuantityValueDebugView(value);
+
+            Assert.Equal(expectedIsReduced, debugView.IsReduced);
+            Assert.Equal(expectedNbBits, debugView.NbBits);
+        }
+
+        [Theory]
+        [InlineData(1, 1, "1/1")]
+        [InlineData(2, 4, "1/2")]
+        [InlineData(0, 1, "0/1")]
+        [InlineData(1, 0, "1/0")] // Corner case: Denominator is zero
+        [InlineData(-1, 1, "-1/1")] // Negative numerator
+        [InlineData(0, 0, "0/0")] // Both numerator and denominator are zero
+        public void StringFormatsView_SimplifiedFraction_ShouldReturnExpectedString(
+            int numerator, int denominator, string expectedSimplifiedFraction)
+        {
+            var value = new QuantityValue(new BigInteger(numerator), new BigInteger(denominator));
+            var debugView = new QuantityValue.QuantityValueDebugView(value);
+
+            Assert.Equal(expectedSimplifiedFraction, debugView.StringFormats.SimplifiedFraction);
+        }
+        
+        [Theory]
+        [InlineData(1.23)]
+        [InlineData(-1.23)]
+        [InlineData(100000)]
+        [InlineData(0.00001)]
+        public void StringFormatsView_GeneralFormat_ShouldReturnExpectedString(double decimalValue)
+        {
+            QuantityValue value = decimalValue;
+            var debugView = new QuantityValue.QuantityValueDebugView(value);
+
+            Assert.Equal(value.ToString("G"), debugView.StringFormats.GeneralFormat);
+        }
+        
+        [Theory]
+        [InlineData(1.23)]
+        [InlineData(-1.23)]
+        [InlineData(100000)]
+        [InlineData(0.00001)]
+        public void StringFormatsView_ShortFormat_ShouldReturnExpectedString(double decimalValue)
+        {
+            QuantityValue value = decimalValue;
+            var debugView = new QuantityValue.QuantityValueDebugView(value);
+
+            Assert.Equal(value.ToString("G6"), debugView.StringFormats.ShortFormat);
+        }
+
+        [Theory]
+        [InlineData(1, 1, 1, 1.0, 1.0)]
+        [InlineData(2, 1, 2, 2.0, 2.0)]
+        [InlineData(1, 2, 0, 0.5, 0.5)]
+        [InlineData(0, 1, 0, 0.0, 0.0)]
+        [InlineData(-1, 1, -1, -1.0, -1.0)] // Negative numerator
+        [InlineData(1, -1, -1, -1.0, -1.0)] // Negative denominator
+        public void NumericFormatsView_Properties_ShouldReturnExpectedValues(
+            int numerator, int denominator, int expectedInteger, double expectedDouble, decimal expectedDecimal)
+        {
+            var value = new QuantityValue(new BigInteger(numerator), new BigInteger(denominator));
+            var debugView = new QuantityValue.QuantityValueDebugView(value);
+
+            Assert.Equal(expectedInteger, debugView.ValueFormats.Integer);
+            Assert.Equal(expectedInteger, debugView.ValueFormats.Long);
+            Assert.Equal(expectedDouble, debugView.ValueFormats.Double);
+            Assert.Equal(expectedDecimal, debugView.ValueFormats.Decimal);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Extensions.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Extensions.cs
new file mode 100644
index 0000000000..f5d9f56341
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Extensions.cs
@@ -0,0 +1,219 @@
+using JetBrains.Annotations;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    [TestSubject(typeof(QuantityValueExtensions))]
+    public class ExtensionTests
+    {
+        [Fact]
+        public void Sum_WithQuantityValues_ReturnsCorrectSum()
+        {
+            IEnumerable<QuantityValue> values = [1.0m, 2.0m, 3.0m];
+            QuantityValue result = values.Sum();
+            Assert.Equal(6.0m, result);
+        }
+
+        [Fact]
+        public void Sum_WithEmptyCollection_ReturnsZero()
+        {
+            QuantityValue result = Array.Empty<QuantityValue>().Sum();
+            Assert.Equal(QuantityValue.Zero, result);
+        }
+
+        [Fact]
+        public void Sum_WithEmptySelector_ReturnsZero()
+        {
+            IEnumerable<QuantityValue> empty = Array.Empty<QuantityValue>();
+            Assert.Equal(QuantityValue.Zero, empty.Select(value => value).Sum());
+        }
+
+        [Fact]
+        public void Average_WithASingleValues_ReturnsTheSameValue()
+        {
+            IEnumerable<QuantityValue> values = [42];
+            QuantityValue result = values.Average();
+            Assert.Equal(42, result);
+        }
+
+        [Fact]
+        public void Average_WithQuantityValues_ReturnsCorrectAverage()
+        {
+            IEnumerable<QuantityValue> values = [1.0m, 2.0m, 3.0m];
+            QuantityValue result = values.Average();
+            Assert.Equal(2.0m, result);
+        }
+
+        [Fact]
+        public void Average_WithSelector_ReturnsCorrectAverage()
+        {
+            IEnumerable<QuantityValue> values = [1.0m, 2.0m, 3.0m];
+            QuantityValue result = values.Select(v => v).Average();
+            Assert.Equal(2.0m, result);
+        }
+
+        [Fact]
+        public void Average_WithEmptyCollection_ThrowsInvalidOperationException()
+        {
+            Assert.Throws<InvalidOperationException>(() => Array.Empty<QuantityValue>().Average());
+        }
+
+        [Fact]
+        public void Average_WithEmptySelector_ThrowsInvalidOperationException()
+        {
+            IEnumerable<QuantityValue> empty = Array.Empty<QuantityValue>();
+            Assert.Throws<InvalidOperationException>(() => empty.Select(v => v).Average());
+        }
+
+        [Theory]
+        [InlineData(-1, 1, 0.1)]
+        [InlineData(0, 1, 1)]
+        [InlineData(1.0, 1, 10.0)]
+        [InlineData(2.0, 1, 100.0)]
+        [InlineData(3.0, 1, 1000.0)]
+        [InlineData(4.2, 1, 15848.93192)]
+        [InlineData(-10, 10, 0.1)]
+        [InlineData(0, 10, 1)]
+        [InlineData(10, 10, 10.0)]
+        [InlineData(20, 10, 100.0)]
+        [InlineData(30, 10, 1000.0)]
+        public void ToLinearSpace_ReturnsCorrectLinearValue(decimal logValue, decimal scalingFactor, double expected)
+        {
+            var result = ((QuantityValue)logValue).ToLinearSpace(scalingFactor);
+            Assert.Equal(expected, result, 5);
+        }
+
+        [Theory]
+        [InlineData(-1, 1, 15, 0.1)]
+        [InlineData(0, 1, 15, 1)]
+        [InlineData(1.0, 1, 15, 10.0)]
+        [InlineData(2.0, 1, 15, 100.0)]
+        [InlineData(3.0, 1, 15, 1000.0)]
+        [InlineData(4.2, 1, 8, 15848.932)]
+        [InlineData(-10, 10, 15, 0.1)]
+        [InlineData(0, 10, 15, 1)]
+        [InlineData(10, 10, 5, 10.0)]
+        [InlineData(20, 10, 5, 100.0)]
+        [InlineData(30, 10, 5, 1000.0)]
+        public void ToLinearSpace_WithSignificantDigits_ReturnsCorrectLinearValue(decimal logValue, decimal scalingFactor, byte significantDigits, decimal expected)
+        {
+            QuantityValue result = ((QuantityValue)logValue).ToLinearSpace(scalingFactor, significantDigits);
+            Assert.Equal(expected, result);
+        }
+
+        [Theory]
+        [InlineData(1, 1, 15, 0)]
+        [InlineData(10.0, 1, 15, 1.0)]
+        [InlineData(100.0, 1, 15, 2.0)]
+        [InlineData(1000.0, 1, 15, 3.0)]
+        [InlineData(100.0, 10, 15, 20)]
+        [InlineData(1000.0, 10, 15, 30)]
+        [InlineData(10000.0, 10, 15, 40)]
+        public void ToLogSpace_ReturnsCorrectLogValue(decimal value, decimal scalingFactor, byte significantDigits, decimal expected)
+        {
+            QuantityValue result = ((QuantityValue)value).ToLogSpace(scalingFactor, significantDigits);
+            Assert.Equal(expected, result);
+        }
+
+        [Theory]
+        [InlineData(10.0, 1, 5, 1.0)]
+        [InlineData(100.0, 1, 5, 2.0)]
+        [InlineData(1000.0, 1, 5, 3.0)]
+        [InlineData(100.0, 10, 15, 20)]
+        [InlineData(1000.0, 10, 15, 30)]
+        [InlineData(10000.0, 10, 15, 40)]
+        public void ToLogSpace_WithQuantityValue_ReturnsCorrectLogValue(decimal value, decimal scalingFactor, byte significantDigits, decimal expected)
+        {
+            QuantityValue result = ((QuantityValue)value).ToLogSpace(scalingFactor, significantDigits);
+            Assert.Equal(expected, result);
+        }
+
+        [Theory]
+        [InlineData(1)]
+        [InlineData(10)]
+        public void ToLogSpace_WithZero_ReturnsNegativeInfinity(decimal scalingFactor)
+        {
+            QuantityValue result = QuantityValue.Zero.ToLogSpace(scalingFactor);
+            Assert.True(QuantityValue.IsNegativeInfinity(result));
+        }
+
+        [Theory]
+        [InlineData(-0.1, 1)]
+        [InlineData(-1.0, 1)]
+        [InlineData(-10, 1)]
+        [InlineData(-0.1, 10)]
+        [InlineData(-1, 10)]
+        [InlineData(-10, 10)]
+        public void ToLogSpace_WithNegativeValues_ReturnsNaN(decimal logValue, decimal scalingFactor)
+        {
+            QuantityValue result = ((QuantityValue)logValue).ToLogSpace(scalingFactor);
+            Assert.True(QuantityValue.IsNaN(result));
+        }
+
+        [Theory]
+        [InlineData(1.0, 1.0, 1, 2, 1.30)]
+        [InlineData(1.0, 1.0, 1, 5, 1.3010)]
+        [InlineData(2.0, 2.0, 1, 5, 2.301)]
+        [InlineData(3.0, 3.0, 1, 5, 3.301)]
+        [InlineData(1.0, -1.0, 1, 5, 1.0043)]
+        [InlineData(1.0, -2.0, 1, 5, 1.0004)]
+        [InlineData(0, -2.0, 1, 5, 0.0043214)]
+        [InlineData(-1.0, -2.0, 1, 5, -0.95861)]
+        [InlineData(1.0, 1.0, 10, 5, 4.0103)]
+        [InlineData(2.0, 2.0, 10, 5, 5.0103)]
+        [InlineData(3.0, 3.0, 10, 5, 6.0103)]
+        [InlineData(10, 30, 20, 5, 30.828)]
+        [InlineData(20, 30, 20, 5, 32.386)]
+        [InlineData(30, 30, 20, 5, 36.020)]
+        public void AddWithLogScaling_ReturnsCorrectLogSum(decimal leftValue, decimal rightValue, decimal scalingFactor, byte significantDigits, decimal expected)
+        {
+            QuantityValue result = QuantityValueExtensions.AddWithLogScaling(leftValue, rightValue, scalingFactor, significantDigits);
+            Assert.Equal(expected, result);
+        }
+
+        [Theory]
+        [InlineData(2.0, 1.0, 1, 5, 1.9542)]
+        [InlineData(3.0, 1.0, 1, 5, 2.9956)]
+        [InlineData(20, 10, 1, 12, 20)]
+        [InlineData(30, 10, 1, 15, 30)]
+        [InlineData(40, 10, 1, 15, 40)]
+        [InlineData(2.0, 1.0, 10, 5, -4.8683)]
+        [InlineData(3.0, 1.0, 10, 5, -1.3292)]
+        [InlineData(20, 10, 10, 5, 19.542)]
+        [InlineData(30, 10, 10, 5, 29.956)]
+        [InlineData(40, 10, 10, 5, 39.996)]
+        [InlineData(200, 100, 10, 12, 200)]
+        [InlineData(300, 100, 10, 15, 300)]
+        [InlineData(400, 100, 10, 15, 400)]
+        public void SubtractWithLogScaling_ReturnsCorrectLogDifference(decimal leftValue, decimal rightValue, decimal scalingFactor, byte significantDigits,
+            decimal expected)
+        {
+            QuantityValue result = QuantityValueExtensions.SubtractWithLogScaling(leftValue, rightValue, scalingFactor, significantDigits);
+            Assert.Equal(expected, result);
+        }
+
+        [Theory]
+        [InlineData(1.0, 1.0, 1, 5)]
+        [InlineData(-1.0, -1.0, 1, 5)]
+        [InlineData(1.0, 1.0, 10, 5)]
+        [InlineData(-1.0, -1.0, 10, 5)]
+        public void SubtractWithLogScaling_WithSameValues_ReturnsNegativeInfinity(decimal leftValue, decimal rightValue, decimal scalingFactor,
+            byte significantDigits)
+        {
+            QuantityValue result = QuantityValueExtensions.SubtractWithLogScaling(leftValue, rightValue, scalingFactor, significantDigits);
+            Assert.True(QuantityValue.IsNegativeInfinity(result));
+        }
+
+        [Theory]
+        [InlineData(-20.0, 1, 1, 5)]
+        [InlineData(-20.0, 1, 10, 5)]
+        [InlineData(-1.0, 20, 1, 5)]
+        [InlineData(-1.0, 20, 10, 5)]
+        public void SubtractWithLogScaling_WithNegativeValues_ReturnsNaN(decimal leftValue, decimal rightValue, decimal scalingFactor, byte significantDigits)
+        {
+            QuantityValue result = QuantityValueExtensions.SubtractWithLogScaling(leftValue, rightValue, scalingFactor, significantDigits);
+            Assert.True(QuantityValue.IsNaN(result));
+        }
+    }
+}
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Fraction.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Fraction.cs
new file mode 100644
index 0000000000..84d1d5f462
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Fraction.cs
@@ -0,0 +1,37 @@
+using System.Numerics;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    public class FractionTests
+    {
+        [Theory]
+        [InlineData(1, 1, 1, 1)]
+        [InlineData(2, 1, 1, 2)]
+        public void InverseTests(BigInteger num, BigInteger den, BigInteger expectedNum, BigInteger expectedDen)
+        {
+            var value = new QuantityValue(num, den);
+            var expected = new QuantityValue(expectedNum, expectedDen);
+            Assert.Equal(expected, QuantityValue.Inverse(value));
+        }
+
+        [Theory]
+        [InlineData(0, 0, 0, 0)] // NaN
+        [InlineData(1, 0, 1, 0)] // PositiveInfinity
+        [InlineData(-1, 0, -1, 0)] // NegativeInfinity
+        [InlineData(0, 1, 0, 1)] // Zero
+        [InlineData(1, 1, 1, 1)] // One
+        [InlineData(-1, 1, -1, 1)] // MinusOne
+        [InlineData(2, 1, 2, 1)] // Two (whole number)
+        [InlineData(2, 4, 1, 2)] // 2/4 -> 1/2 
+        [InlineData(2, 5, 2, 5)] // 2/5 -> 2/5 (unchanged) 
+        public void ReduceTests(BigInteger num, BigInteger den, BigInteger expectedNum, BigInteger expectedDen)
+        {
+            var value = new QuantityValue(num, den);
+            var (numerator, denominator) = QuantityValue.Reduce(value);
+            Assert.Equal(expectedNum, numerator);
+            Assert.Equal(expectedDen, denominator);
+        }
+    }
+}
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Number.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Number.cs
new file mode 100644
index 0000000000..af0e2e22ff
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Number.cs
@@ -0,0 +1,477 @@
+using System.Numerics;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    public class NumberTests
+    {
+#if NET7_0_OR_GREATER
+        [Fact]
+        public void Radix_Returns_Ten()
+        {
+            Assert.Equal(10, GetRadix<QuantityValue>());
+            return;
+
+            static int GetRadix<T>()
+                where T : INumber<T>
+            {
+                return T.Radix;
+            }
+        }
+
+        [Fact]
+        public void AdditiveIdentity_Returns_Zero()
+        {
+            Assert.Equal(0, GetAdditiveIdentity<QuantityValue>());
+            return;
+
+            static T GetAdditiveIdentity<T>()
+                where T : IAdditiveIdentity<T, T>
+            {
+                return T.AdditiveIdentity;
+            }
+        }
+
+        [Fact]
+        public void MultiplicativeIdentity_Returns_One()
+        {
+            Assert.Equal(1, GetMultiplicativeIdentity<QuantityValue>());
+            return;
+
+            static T GetMultiplicativeIdentity<T>()
+                where T : IMultiplicativeIdentity<T, T>
+            {
+                return T.MultiplicativeIdentity;
+            }
+        }
+
+        [Fact]
+        public void NegativeOne__Returns_MinusOne()
+        {
+            Assert.Equal(-1, QuantityValue.MinusOne);
+            Assert.Equal(-1, GetNegativeOne<QuantityValue>());
+            return;
+
+            static T GetNegativeOne<T>()
+                where T : ISignedNumber<T>
+            {
+                return T.NegativeOne;
+            }
+        }
+
+        [Fact]
+        public void IsNormal_WithFiniteValue_ReturnsTrue()
+        {
+            Assert.True(IsNormal(new QuantityValue(1, 3)));
+            return;
+                
+            static bool IsNormal<T>(T value)
+                where T : INumberBase<T>
+            {
+                return T.IsNormal(value);
+            }
+        }
+
+        [Fact]
+        public void IsNormal_WithNonFiniteValue_ReturnsFalse()
+        {
+            Assert.Multiple(() =>
+            {
+                Assert.False(IsNormal(QuantityValue.NaN));
+                Assert.False(IsNormal(QuantityValue.PositiveInfinity));
+                Assert.False(IsNormal(QuantityValue.NegativeInfinity));
+            }, () =>
+            {
+                // same as the behavior of double
+                Assert.False(IsNormal(double.NaN));
+                Assert.False(IsNormal(double.PositiveInfinity));
+                Assert.False(IsNormal(double.NegativeInfinity));
+            });
+            return;
+
+            static bool IsNormal<T>(T value)
+                where T : INumberBase<T>
+            {
+                return T.IsNormal(value);
+            }
+        }
+
+        [Fact]
+        public void IsRealNumber_WithInfinity_ReturnsTrue()
+        {
+            Assert.Multiple(() =>
+            {
+                Assert.True(IsRealNumber(QuantityValue.PositiveInfinity));
+                Assert.True(IsRealNumber(QuantityValue.NegativeInfinity));
+            }, () =>
+            {
+                // same as the behavior of double
+                Assert.True(IsRealNumber(double.PositiveInfinity));
+                Assert.True(IsRealNumber(double.NegativeInfinity));
+            });
+            return;
+
+            static bool IsRealNumber<T>(T value)
+                where T : INumberBase<T>
+            {
+                return T.IsRealNumber(value);
+            }
+        }
+
+        [Fact]
+        public void IsRealNumber_WithNaN_ReturnsFalse()
+        {
+            Assert.Multiple(() =>
+            {
+                Assert.False(IsRealNumber(QuantityValue.NaN));
+            }, () =>
+            {
+                // same as the behavior of double
+                Assert.False(IsRealNumber(double.NaN));
+            });
+            return;
+
+            static bool IsRealNumber<T>(T value)
+                where T : INumberBase<T>
+            {
+                return T.IsRealNumber(value);
+            }
+        }
+
+        [Fact]
+        public void IsComplexNumber_ReturnsFalse()
+        {
+            Assert.Multiple(() =>
+            {
+                Assert.False(IsComplexNumber(QuantityValue.One));
+                Assert.False(IsComplexNumber(QuantityValue.NaN));
+                Assert.False(IsComplexNumber(QuantityValue.PositiveInfinity));
+                Assert.False(IsComplexNumber(QuantityValue.NegativeInfinity));
+            }, () =>
+            {
+                // same as the behavior of double
+                Assert.False(IsComplexNumber(1.0));
+                Assert.False(IsComplexNumber(double.NaN));
+                Assert.False(IsComplexNumber(double.PositiveInfinity));
+                Assert.False(IsComplexNumber(double.NegativeInfinity));
+            });
+            return;
+
+            static bool IsComplexNumber<T>(T value)
+                where T : INumberBase<T>
+            {
+                return T.IsComplexNumber(value);
+            }
+        }
+
+        [Fact]
+        public void IsImaginaryNumber_ReturnsFalse()
+        {
+            Assert.Multiple(() =>
+            {
+                Assert.False(IsImaginaryNumber(QuantityValue.One));
+                Assert.False(IsImaginaryNumber(QuantityValue.NaN));
+                Assert.False(IsImaginaryNumber(QuantityValue.PositiveInfinity));
+                Assert.False(IsImaginaryNumber(QuantityValue.NegativeInfinity));
+            }, () =>
+            {
+                // same as the behavior of double
+                Assert.False(IsImaginaryNumber(1.0));
+                Assert.False(IsImaginaryNumber(double.NaN));
+                Assert.False(IsImaginaryNumber(double.PositiveInfinity));
+                Assert.False(IsImaginaryNumber(double.NegativeInfinity));
+            });
+            return;
+
+            static bool IsImaginaryNumber<T>(T value)
+                where T : INumberBase<T>
+            {
+                return T.IsImaginaryNumber(value);
+            }
+        }
+
+        [Fact]
+        public void IsSubnormal_ReturnsFalse()
+        {
+            Assert.Multiple(() =>
+            {
+                Assert.False(IsSubnormal(QuantityValue.One));
+                Assert.False(IsSubnormal(QuantityValue.NaN));
+                Assert.False(IsSubnormal(QuantityValue.PositiveInfinity));
+                Assert.False(IsSubnormal(QuantityValue.NegativeInfinity));
+            }, () =>
+            {
+                // same as the behavior of double
+                Assert.False(IsSubnormal(1.0));
+                Assert.False(IsSubnormal(double.NaN));
+                Assert.False(IsSubnormal(double.PositiveInfinity));
+                Assert.False(IsSubnormal(double.NegativeInfinity));
+            });
+            return;
+
+            static bool IsSubnormal<T>(T value)
+                where T : INumberBase<T>
+            {
+                return T.IsSubnormal(value);
+            }
+        }
+        
+#endif
+
+        [Theory]
+        [InlineData(0, 1, true)]
+        [InlineData(1, 1, true)]
+        [InlineData(-1, 1, true)]
+        [InlineData(-1, -1, true)]
+        [InlineData(2, 1, true)]
+        [InlineData(1, 2, true)]
+        [InlineData(1, 0, true)]
+        [InlineData(-1, 0, true)]
+        [InlineData(0, 0, true)]
+        [InlineData(2, 2, false)]
+        [InlineData(-2, 2, false)]
+        [InlineData(-2, -2, false)]
+        public void IsCanonicalTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsCanonical(value));
+        }
+        
+        [Theory]
+        [InlineData(0, 1, true)]
+        [InlineData(1, 0, false)]
+        [InlineData(1, 2, true)]
+        [InlineData(1, 3, false)]
+        [InlineData(1, 4, true)]
+        [InlineData(1, 10, true)]
+        [InlineData(1, 50, true)]
+        [InlineData(1, 350, false)]
+        public void HasFiniteDecimalExpansion(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.HasFiniteDecimalExpansion(value));
+        }
+
+        [Theory]
+        [InlineData(2, 1, true)]
+        [InlineData(3, 1, false)]
+        [InlineData(1, 0, false)]
+        [InlineData(4, 2, true)]
+        [InlineData(6, 2, false)]
+        [InlineData(3, 2, false)]
+        public void IsEvenIntegerTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsEvenInteger(value));
+        }
+
+        [Theory]
+        [InlineData(1, 1, true)]
+        [InlineData(0, 1, true)]
+        [InlineData(1, 0, false)]
+        public void IsFiniteTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsFinite(value));
+        }
+
+        [Theory]
+        [InlineData(1, 0, true)]
+        [InlineData(0, 1, false)]
+        public void IsInfinityTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsInfinity(value));
+        }
+
+        [Theory]
+        [InlineData(0, 1, true)]
+        [InlineData(0, 2, true)]
+        [InlineData(1, 1, true)]
+        [InlineData(2, 1, true)]
+        [InlineData(-6, 3, true)]
+        [InlineData(1, 2, false)]
+        [InlineData(3, 2, false)]
+        [InlineData(1, 0, false)]
+        public void IsIntegerTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsInteger(value));
+        }
+
+        [Theory]
+        [InlineData(0, 0, true)]
+        [InlineData(1, 1, false)]
+        public void IsNaNTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsNaN(value));
+        }
+
+        [Theory]
+        [InlineData(-1, 1, true)]
+        [InlineData(1, 1, false)]
+        public void IsNegativeTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsNegative(value));
+        }
+
+        [Theory]
+        [InlineData(-1, 0, true)]
+        [InlineData(1, 0, false)]
+        public void IsNegativeInfinityTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsNegativeInfinity(value));
+        }
+
+        [Theory]
+        [InlineData(2, 1, false)]
+        [InlineData(3, 1, true)]
+        [InlineData(1, 0, false)]
+        [InlineData(1, 2, false)]
+        [InlineData(6, 2, true)]
+        [InlineData(6, 3, false)]
+        public void IsOddIntegerTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsOddInteger(value));
+        }
+
+        [Theory]
+        [InlineData(1, 1, true)]
+        [InlineData(0, 1, false)]
+        [InlineData(1, 0, true)]
+        [InlineData(-1, 1, false)]
+        [InlineData(-1, 0, false)]
+        [InlineData(0, 0, false)]
+        public void IsPositiveTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsPositive(value));
+        }
+
+        [Theory]
+        [InlineData(1, 0, true)]
+        [InlineData(-1, 0, false)]
+        public void IsPositiveInfinityTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsPositiveInfinity(value));
+        }
+
+        [Theory]
+        [InlineData(0, 1, true)]
+        [InlineData(1, 1, false)]
+        public void IsZeroTests(BigInteger numerator, BigInteger denominator, bool expected)
+        {
+            var value = new QuantityValue(numerator, denominator);
+            Assert.Equal(expected, QuantityValue.IsZero(value));
+        }
+
+        [Theory]
+        [InlineData(1, 2, 1, 3, 1, 2)]
+        [InlineData(-1, 2, 1, 3, -1, 2)]
+        [InlineData(0, 1, 1, 3, 1, 3)]
+        [InlineData(0, 0, 1, 3, 0, 0)] // NaN
+        [InlineData(1, 3, 0, 0, 0, 0)] // NaN
+        [InlineData(0, 0, 1, 0, 0, 0)] // NaN
+        [InlineData(1, 0, 0, 0, 0, 0)] // NaN
+        [InlineData(0, 0, -1, 0, 0, 0)] // NaN
+        [InlineData(-1, 0, 0, 0, 0, 0)] // NaN
+        [InlineData(1, 0, -1, 0, 1, 0)] // PositiveInfinity
+        [InlineData(-1, 0, 1, 0, 1, 0)] // PositiveInfinity
+        public void MaxMagnitudeTests(BigInteger num1, BigInteger den1, BigInteger num2, BigInteger den2, BigInteger expectedNum, BigInteger expectedDen)
+        {
+            var value1 = new QuantityValue(num1, den1);
+            var value2 = new QuantityValue(num2, den2);
+            var expected = new QuantityValue(expectedNum, expectedDen);
+#if NET
+            Assert.Equal(double.MaxMagnitude(value1.ToDouble(), value2.ToDouble()), expected.ToDouble()); // making sure the expectation is correct
+#endif
+            Assert.Equal(expected, QuantityValue.MaxMagnitude(value1, value2));
+        }
+
+        [Theory]
+        [InlineData(1, 2, 1, 3, 1, 2)]
+        [InlineData(-1, 2, 1, 3, -1, 2)]
+        [InlineData(1, 3, -1, 2, -1, 2)]
+        [InlineData(0, 0, 1, 3, 1, 3)] // NaN
+        [InlineData(1, 2, 0, 0, 1, 2)] // NaN
+        [InlineData(0, 0, 1, 0, 1, 0)] // NaN and PositiveInfinity
+        [InlineData(1, 0, 0, 0, 1, 0)] // PositiveInfinity and NaN
+        [InlineData(0, 0, -1, 0, -1, 0)] // NaN and NegativeInfinity
+        [InlineData(-1, 0, 0, 0, -1, 0)] // NegativeInfinity and NaN
+        [InlineData(1, 0, -1, 0, 1, 0)] // PositiveInfinity and NegativeInfinity
+        [InlineData(-1, 0, 1, 0, 1, 0)] // NegativeInfinity and PositiveInfinity
+        [InlineData(0, 0, 0, 0, 0, 0)] // NaN and NaN
+        public void MaxMagnitudeNumberTests(BigInteger num1, BigInteger den1, BigInteger num2, BigInteger den2, BigInteger expectedNum, BigInteger expectedDen)
+        {
+            var value1 = new QuantityValue(num1, den1);
+            var value2 = new QuantityValue(num2, den2);
+            var expected = new QuantityValue(expectedNum, expectedDen);
+#if NET
+            Assert.Equal(double.MaxMagnitudeNumber(value1.ToDouble(), value2.ToDouble()), expected.ToDouble()); // making sure the expectation is correct
+#endif
+            Assert.Equal(expected, QuantityValue.MaxMagnitudeNumber(value1, value2));
+        }
+
+        [Theory]
+        [InlineData(1, 2, 1, 3, 1, 3)]
+        [InlineData(-1, 2, 1, 3, 1, 3)]
+        [InlineData(0, 1, 1, 3, 0, 1)]
+        [InlineData(0, 0, 1, 3, 0, 0)] // NaN
+        [InlineData(1, 3, 0, 0, 0, 0)] // NaN
+        [InlineData(0, 0, 1, 0, 0, 0)] // NaN
+        [InlineData(1, 0, 0, 0, 0, 0)] // NaN
+        [InlineData(0, 0, -1, 0, 0, 0)] // NaN
+        [InlineData(-1, 0, 0, 0, 0, 0)] // NaN
+        [InlineData(1, 0, -1, 0, -1, 0)] // PositiveInfinity and NegativeInfinity
+        [InlineData(-1, 0, 1, 0, -1, 0)] // NegativeInfinity and PositiveInfinity
+        public void MinMagnitudeTests(BigInteger num1, BigInteger den1, BigInteger num2, BigInteger den2, BigInteger expectedNum, BigInteger expectedDen)
+        {
+            var value1 = new QuantityValue(num1, den1);
+            var value2 = new QuantityValue(num2, den2);
+            var expected = new QuantityValue(expectedNum, expectedDen);
+#if NET
+            Assert.Equal(double.MinMagnitude(value1.ToDouble(), value2.ToDouble()), expected.ToDouble()); // making sure the expectation is correct
+#endif
+            Assert.Equal(expected, QuantityValue.MinMagnitude(value1, value2));
+        }
+
+        [Theory]
+        [InlineData(1, 2, 1, 3, 1, 3)]
+        [InlineData(-1, 2, 1, 3, 1, 3)]
+        [InlineData(0, 0, 1, 3, 1, 3)] // NaN
+        [InlineData(1, 2, 0, 0, 1, 2)] // NaN
+        [InlineData(0, 0, 1, 0, 1, 0)] // NaN and PositiveInfinity
+        [InlineData(1, 0, 0, 0, 1, 0)] // PositiveInfinity and NaN
+        [InlineData(0, 0, -1, 0, -1, 0)] // NaN and NegativeInfinity
+        [InlineData(-1, 0, 0, 0, -1, 0)] // NegativeInfinity and NaN
+        [InlineData(1, 0, -1, 0, -1, 0)] // PositiveInfinity and NegativeInfinity
+        [InlineData(-1, 0, 1, 0, -1, 0)] // NegativeInfinity and PositiveInfinity
+        [InlineData(0, 0, 0, 0, 0, 0)] // NaN and NaN
+        public void MinMagnitudeNumberTests(BigInteger num1, BigInteger den1, BigInteger num2, BigInteger den2, BigInteger expectedNum, BigInteger expectedDen)
+        {
+            var value1 = new QuantityValue(num1, den1);
+            var value2 = new QuantityValue(num2, den2);
+            var expected = new QuantityValue(expectedNum, expectedDen);
+#if NET
+            Assert.Equal(double.MinMagnitudeNumber(value1.ToDouble(), value2.ToDouble()), expected.ToDouble()); // making sure the expectation is correct
+#endif
+            Assert.Equal(expected, QuantityValue.MinMagnitudeNumber(value1, value2));
+        }
+
+        [Theory]
+        [InlineData(1, 1, 1, 1)]
+        [InlineData(-1, 1, 1, 1)]
+        public void AbsTests(BigInteger num, BigInteger den, BigInteger expectedNum, BigInteger expectedDen)
+        {
+            var value = new QuantityValue(num, den);
+            var expected = new QuantityValue(expectedNum, expectedDen);
+            Assert.Equal(expected, QuantityValue.Abs(value));
+        }
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.PowerMath.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.PowerMath.cs
new file mode 100644
index 0000000000..a3e0627a19
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.PowerMath.cs
@@ -0,0 +1,435 @@
+using System.Globalization;
+using System.Numerics;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    public class PowerMathTests
+    {
+        [Theory]
+        [InlineData(18)]
+        [InlineData(19)]
+        [InlineData(36)]
+        [InlineData(37)]
+        [InlineData(54)]
+        [InlineData(55)]
+        public void PowerOfTen_Equals_BigIntegerPow(int power)
+        {
+            BigInteger powerOfTen = QuantityValue.PowerOfTen(power);
+            var bigIntegerPower = BigInteger.Pow(10, power);
+            Assert.Equal(bigIntegerPower, powerOfTen);
+        }
+        
+        [Theory]
+        [InlineData(0, 1, 1, 0, 1)] // 0^1 == 0
+        [InlineData(2, 1, 0, 1, 1)] // 2^0 == 1
+        [InlineData(2, 1, -1, 1, 2)] // 2^-1 == 1/2
+        [InlineData(2, 1, -2, 1, 4)] // 2^-2 == 1/4
+        [InlineData(-2, 1, -1, -1, 2)] // 2^-1 == -1/2
+        [InlineData(-2, 1, -2, 1, 4)] // -2^-2 == 1/4
+        [InlineData(0, 1, -2, 1, 0)] // 0^-2 == PositiveInfinity
+        [InlineData(2, 1, 1, 2, 1)]
+        [InlineData(1, 1, 2, 1, 1)]
+        [InlineData(2, 1, 2, 4, 1)]
+        [InlineData(3, 1, 2, 9, 1)]
+        [InlineData(1, 2, 2, 1, 4)]
+        public void PowTests(BigInteger num, BigInteger den, int power, BigInteger expectedNum, BigInteger expectedDen)
+        {
+            var value = new QuantityValue(num, den);
+            var expected = new QuantityValue(expectedNum, expectedDen);
+
+            var result = QuantityValue.Pow(value, power);
+
+#if NET
+            Assert.Equal(double.Pow(value.ToDouble(), power), result.ToDouble(), 15);
+#endif
+            Assert.Equal(expected, result);
+        }
+
+        [Theory]
+        [InlineData(double.NaN, -2, double.NaN)]
+        [InlineData(double.NaN, -1, double.NaN)]
+        [InlineData(double.NaN, 0, 1)]
+        [InlineData(double.NaN, 1, double.NaN)]
+        [InlineData(double.NaN, 2, double.NaN)]
+        [InlineData(double.PositiveInfinity, -2, 0)]
+        [InlineData(double.PositiveInfinity, -1, 0)]
+        [InlineData(double.PositiveInfinity, 0, 1)]
+        [InlineData(double.PositiveInfinity, 1, double.PositiveInfinity)]
+        [InlineData(double.PositiveInfinity, 2, double.PositiveInfinity)]
+        [InlineData(double.NegativeInfinity, -2, 0)]
+        [InlineData(double.NegativeInfinity, -1, 0)]
+        [InlineData(double.NegativeInfinity, 0, 1)]
+        [InlineData(double.NegativeInfinity, 1, double.NegativeInfinity)]
+        [InlineData(double.NegativeInfinity, 2, double.PositiveInfinity)]
+        public void PowWithNaNOrInfinityTests(double number, int power, double expected)
+        {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            var result = QuantityValue.Pow(number, power);
+#if NET
+            Assert.Equal(double.Pow(number, power), result.ToDouble());
+#endif
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Theory]
+        [InlineData(2, 1, 1, 1, 2, 1)]
+        [InlineData(1, 1, 2, 1, 1, 1)]
+        [InlineData(2, 1, 2, 2, 2, 1)]
+        [InlineData(2, 1, 4, 2, 4, 1)]
+        [InlineData(81, 1, 1, 2, 9, 1)]
+        [InlineData(81, 1, 1, 4, 3, 1)]
+        [InlineData(81, 1, 1, 10, 155184557391536, 100000000000000)]
+        public void PowRationalTests(BigInteger num, BigInteger den, BigInteger powerNum, BigInteger powerDen, BigInteger expectedNum, BigInteger expectedDen)
+        {
+            var value = new QuantityValue(num, den);
+            var power = new QuantityValue(powerNum, powerDen);
+            var expected = new QuantityValue(expectedNum, expectedDen);
+            Assert.Equal(expected, QuantityValue.Pow(value, power, 15));
+        }
+
+        [Theory]
+        [InlineData(double.NaN, -3, double.NaN)]
+        [InlineData(double.NaN, -2, double.NaN)]
+        [InlineData(double.NaN, -1, double.NaN)]
+        [InlineData(double.NaN, 0, 1)]
+        [InlineData(double.NaN, 1, double.NaN)]
+        [InlineData(double.NaN, 2, double.NaN)]
+        [InlineData(double.NaN, 3, double.NaN)]
+        [InlineData(double.PositiveInfinity, -3, 0)]
+        [InlineData(double.PositiveInfinity, -2, 0)]
+        [InlineData(double.PositiveInfinity, -1, 0)]
+        [InlineData(double.PositiveInfinity, 0, 1)]
+        [InlineData(double.PositiveInfinity, 1, double.PositiveInfinity)]
+        [InlineData(double.PositiveInfinity, 2, double.PositiveInfinity)]
+        [InlineData(double.NegativeInfinity, -3, 0)]
+        [InlineData(double.NegativeInfinity, -2, 0)]
+        [InlineData(double.NegativeInfinity, -1, 0)]
+        [InlineData(double.NegativeInfinity, 0, 1)]
+        [InlineData(double.NegativeInfinity, 1, double.NegativeInfinity)]
+        [InlineData(double.NegativeInfinity, 2, double.PositiveInfinity)]
+        [InlineData(double.NegativeInfinity, 3, double.NegativeInfinity)]
+        public void PowRationalWithNaNOrInfinityTests(double number, double power, double expected)
+        {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            var result = QuantityValue.Pow(number, power);
+#if NET
+            Assert.Equal(double.Pow(number, power), result.ToDouble());
+#endif
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Fact]
+        public void Sqrt_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => QuantityValue.Sqrt(QuantityValue.One, -1));
+        }
+
+        [Theory]
+        [InlineData(double.NaN)]
+        [InlineData(double.PositiveInfinity)]
+        [InlineData(double.NegativeInfinity)]
+        [InlineData(-1)]
+        [InlineData(0)]
+        [InlineData(1)]
+        public void Sqrt_WithSpecialValues_MatchesTheOutputOfMathSqrt(double doubleValue)
+        {
+            var expected = Math.Sqrt(doubleValue);
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+
+            var actual = QuantityValue.Sqrt(doubleValue);
+
+            Assert.Equal(expectedValue, actual);
+        }
+
+        [Theory]
+        [InlineData(0.1)]
+        [InlineData(12.34)]
+        [InlineData(0.01234)]
+        [InlineData(123.45)]
+        [InlineData(0.0012345)]
+        public void Sqrt_WithLowAccuracy_MatchesTheOutputOfMathSqrt(double doubleValue)
+        {
+            var expected = Math.Sqrt(doubleValue);
+
+            var actual = QuantityValue.Sqrt(doubleValue, 15);
+
+            Assert.Equal(expected, actual.ToDouble(), 15);
+        }
+
+        [Theory]
+        [InlineData(2, 1, 5)]
+        [InlineData(10, 1, 5)]
+        [InlineData(30, 20, 5)]
+        [InlineData(4, 3, 5)]
+        [InlineData(5, 3, 5)]
+        [InlineData(12345678, 9, 5)] // reduced to 1371742/1
+        [InlineData(123456789, 2, 7)]
+        [InlineData(1, 2, 5)]
+        [InlineData(1, 3, 5)]
+        [InlineData(1, 10, 5)]
+        [InlineData(2, 3, 5)]
+        [InlineData(20, 30, 5)]
+        [InlineData(9, 12345678, 5)] // reduced to 1/1371742
+        [InlineData(2, 123456789, 7)]
+        public void Sqrt_WithExactRoot_CalculatesExactly(int numerator, int denominator, int accuracy)
+        {
+            var expectedValue = new QuantityValue(numerator, denominator);
+            var quantityValue = expectedValue * expectedValue;
+
+            var actualValue = QuantityValue.Sqrt(quantityValue, accuracy);
+
+            Assert.Equal(expectedValue, actualValue);
+        }
+
+        [Fact]
+        public void Sqrt_ReturnsNoLessThanTheSpecifiedNumberOfCorrectDigits()
+        {
+            // these are the first 100 decimal places (from http://www.numberworld.org/digits/Sqrt(2)/)
+            const string firstOneHundredDecimals = "1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727";
+            var expected = QuantityValue.Parse(firstOneHundredDecimals, CultureInfo.InvariantCulture);
+            Assert.All(Enumerable.Range(1, 100), digits =>
+            {
+                var result = QuantityValue.Sqrt(2, digits);
+                AssertEx.EqualTolerance(expected, result, new QuantityValue(1, BigInteger.Pow(10, digits)));
+            });
+        }
+
+        [Fact]
+        public void Sqrt_ReturnsMoreThanTheSpecifiedNumberOfDigits()
+        {
+            // Sqrt(2, 1) ~= 14/10, Sqrt(2, 2) ~= 141/100.. Sqrt(2, n) = a/b with len(a) ~= n
+            var tolerance = new QuantityValue(2038, 10000); // ~20.38%
+            Assert.All(Enumerable.Range(1, 1000), digits =>
+            {
+                var result = QuantityValue.Sqrt(2, digits);
+                var (numerator, _) = result;
+                AssertEx.EqualTolerance(digits + 1, numerator.ToString().Length, tolerance);
+            });
+        }
+
+        [Fact]
+        public void Sqrt_WithVeryPreciseQuantityValue_CalculatesCorrectly()
+        {
+            // Arrange: a very precise quantity value ~ {0.3160846809101182}
+            var numerator = BigInteger.Parse(
+                "7017075566499415481183895525487656110361817123500083731653571771256593466607002465509486669805631606869622837818618382797847715440102824717432866745242640865976075222884078899654447525335854152217507362365722656250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
+            var denominator = BigInteger.Parse(
+                "22199986238797791147406259737557652523540869928960600626046611277198843489042928693958126769955174387224059480985453176875329090776309059513483264000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
+            var quantityValue = new QuantityValue(numerator, denominator);
+            // Act
+            var result = QuantityValue.Sqrt(quantityValue, 5);
+            // Assert
+            AssertEx.EqualTolerance(result, 0.56m, 0.1);
+#if NET
+            Assert.Equal(573312, result.Numerator);
+            Assert.Equal(1019740, result.Denominator);
+#else
+            // since we don't have access to BigInteger.GetBitLength we are slightly more conservative (using a larger shift)
+            Assert.Equal(1146624, result.Numerator);
+            Assert.Equal(2039480, result.Denominator);
+#endif
+        }
+
+        [Theory]
+        [InlineData(2, 1)]
+        [InlineData(10, 1)]
+        [InlineData(30, 20)]
+        [InlineData(200, 300)]
+        [InlineData(1234, 56789)]
+        public void Sqrt_WithVeryLargeValue_CalculatesCorrectly(int numeratorScale, int denominatorScale)
+        {
+            var expectedValue = new QuantityValue(numeratorScale, denominatorScale) * double.MaxValue;
+            var quantityValue = expectedValue * expectedValue;
+
+            var actualValue = QuantityValue.Sqrt(quantityValue, 190); // double.MaxValue ~= 1.8e308 but the exact value is found early
+
+            Assert.Equal(expectedValue, actualValue);
+        }
+
+        [Theory]
+        [InlineData(1, 2)]
+        [InlineData(1, 10)]
+        [InlineData(20, 30)]
+        [InlineData(200, 300)]
+        [InlineData(1234, 56789)]
+        public void Sqrt_WithVerySmallValue_CalculatesCorrectly(int numeratorScale, int denominatorScale)
+        {
+            var expectedValue = new QuantityValue(numeratorScale, denominatorScale) / double.MaxValue;
+            var quantityValue = expectedValue * expectedValue;
+
+            var actualValue = QuantityValue.Sqrt(quantityValue, 190); // double.MaxValue ~= 1.8e308 but the exact value is found early
+
+            Assert.Equal(expectedValue, actualValue);
+        }
+
+        [Theory]
+        [InlineData(2)]
+        [InlineData(20)]
+        [InlineData(300000)]
+        [InlineData(9007199254740993)]
+        [InlineData(long.MaxValue)]
+        [InlineData(ulong.MaxValue)]
+        public void Sqrt_WithWholeNumber_CalculatesWithTheSpecifiedAccuracy(ulong expectedValue)
+        {
+            var squaredValue = BigInteger.Pow(expectedValue, 2);
+            var expectedString = expectedValue.ToString("G");
+            var maxDigits = expectedString.Length;
+
+            for (var digits = 1; digits < maxDigits; digits++)
+            {
+                var result = QuantityValue.Sqrt(squaredValue, digits);
+
+                if (result == expectedValue)
+                {
+                    break; // the extra digits happened to be correct (compounding probability)
+                }
+
+                AssertEx.EqualTolerance(expectedValue, result, new QuantityValue(1, BigInteger.Pow(10, digits)));
+            }
+
+            Assert.Equal(expectedValue, QuantityValue.Sqrt(squaredValue, maxDigits));
+        }
+
+        [Theory]
+        [InlineData(1)]
+        [InlineData(20)]
+        [InlineData(300000)]
+        [InlineData(9007199254740993)]
+        [InlineData(long.MaxValue)]
+        [InlineData(ulong.MaxValue)]
+        public void Sqrt_WithLargeWholeNumber_CalculatesWithTheSpecifiedAccuracy(ulong scale)
+        {
+            var expectedValue = scale * (BigInteger)double.MaxValue;
+            var squaredValue = BigInteger.Pow(expectedValue, 2);
+            var expectedString = expectedValue.ToString("G");
+            var maxDigits = expectedString.Length;
+
+            for (var digits = 1; digits < maxDigits; digits++)
+            {
+                var result = QuantityValue.Sqrt(squaredValue, digits);
+
+                if (result == expectedValue)
+                {
+                    break; // the extra digits happened to be correct (compounding probability)
+                }
+
+                AssertEx.EqualTolerance(expectedValue, result, new QuantityValue(1, BigInteger.Pow(10, digits)));
+            }
+
+            Assert.Equal(expectedValue, QuantityValue.Sqrt(squaredValue, maxDigits));
+        }
+
+        [Theory]
+        // (x, -3)
+        [InlineData(-3, -3, -0.693361274350635)]
+        [InlineData(-2, -3, -0.7937005259841)]
+        [InlineData(-1, -3, -1)]
+        [InlineData(0, -3, double.PositiveInfinity)]
+        [InlineData(1, -3, 1)]
+        [InlineData(2, -3, 0.7937005259841)]
+        [InlineData(3, -3, 0.693361274350635)]
+        // (x, -2)
+        [InlineData(-3, -2, double.NaN)]
+        [InlineData(-2, -2, double.NaN)]
+        [InlineData(-1, -2, double.NaN)]
+        [InlineData(0, -2, double.PositiveInfinity)]
+        [InlineData(1, -2, 1)]
+        [InlineData(2, -2, 0.70710678118654802)]
+        [InlineData(3, -2, 0.577350269189626)]
+        // (x, -1)
+        [InlineData(-3, -1, -0.333333333333333)]
+        [InlineData(-2, -1, -0.5)]
+        [InlineData(-1, -1, -1)]
+        [InlineData(0, -1, double.PositiveInfinity)]
+        [InlineData(1, -1, 1)]
+        [InlineData(2, -1, 0.5)]
+        [InlineData(3, -1, 0.333333333333333)]
+        // (x, 0)
+        [InlineData(-3, 0, double.NaN)] // NaN
+        [InlineData(-2, 0, double.NaN)] // NaN
+        [InlineData(-1, 0, double.NaN)] // NaN
+        [InlineData(0, 0, double.NaN)] // NaN
+        [InlineData(1, 0, double.NaN)] // NaN
+        [InlineData(2, 0, double.NaN)] // NaN
+        [InlineData(3, 0, double.NaN)] // NaN
+        // (x, 1)
+        [InlineData(-3, 1, -3)]
+        [InlineData(-2, 1, -2)]
+        [InlineData(-1, 1, -1)]
+        [InlineData(0, 1, 0)]
+        [InlineData(1, 1, 1)]
+        [InlineData(2, 1, 2)]
+        [InlineData(3, 1, 3)]
+        // (x, 2)
+        [InlineData(-3, 2, double.NaN)]
+        [InlineData(-2, 2, double.NaN)]
+        [InlineData(-1, 2, double.NaN)]
+        [InlineData(0, 2, 0)]
+        [InlineData(1, 2, 1)]
+        [InlineData(2, 2, 1.414213562373095)]
+        [InlineData(3, 2, 1.732050807568877)]
+        // (x, 3)
+        [InlineData(-3, 3, -1.4422495703074081)]
+        [InlineData(-2, 3, -1.259921049894873)]
+        [InlineData(-1, 3, -1)]
+        [InlineData(0, 3, 0)]
+        [InlineData(1, 3, 1)]
+        [InlineData(2, 3, 1.259921049894873)]
+        [InlineData(3, 3, 1.4422495703074081)]
+        [InlineData(8, 3, 2)]
+        [InlineData(27, 3, 3)]
+        // (x, 4)
+        [InlineData(16, 4, 2)]
+        [InlineData(0.0625, 4, 0.5)]
+        public void RootTests(double number, int root, double expectedValue)
+        {
+            QuantityValue quantityValue = number;
+
+            var result = QuantityValue.RootN(quantityValue, root);
+#if NET
+            // The platform implementation of double.RootN can differ by a few units in the last place.
+            Assert.Equal(double.RootN(number, root), result.ToDouble(), tolerance: 1e-14);
+#endif
+            Assert.Equal(expectedValue, result.ToDouble(), 15);
+        }
+
+        [Theory]
+        [InlineData(double.NaN, -3, double.NaN)]
+        [InlineData(double.NaN, -2, double.NaN)]
+        [InlineData(double.NaN, -1, double.NaN)]
+        [InlineData(double.NaN, 0, double.NaN)]
+        [InlineData(double.NaN, 1, double.NaN)]
+        [InlineData(double.NaN, 2, double.NaN)]
+        [InlineData(double.NaN, 3, double.NaN)]
+        [InlineData(double.PositiveInfinity, -3, 0)]
+        [InlineData(double.PositiveInfinity, -2, 0)]
+        [InlineData(double.PositiveInfinity, -1, 0)]
+        [InlineData(double.PositiveInfinity, 0, double.NaN)]
+        [InlineData(double.PositiveInfinity, 1, double.PositiveInfinity)]
+        [InlineData(double.PositiveInfinity, 2, double.PositiveInfinity)]
+        [InlineData(double.NegativeInfinity, -3, 0)]
+        [InlineData(double.NegativeInfinity, -2, double.NaN)]
+        [InlineData(double.NegativeInfinity, -1, 0)]
+        [InlineData(double.NegativeInfinity, 0, double.NaN)]
+        [InlineData(double.NegativeInfinity, 1, double.NegativeInfinity)]
+        [InlineData(double.NegativeInfinity, 2, double.NaN)]
+        [InlineData(double.NegativeInfinity, 3, double.NegativeInfinity)]
+        public void RootWithNaNOrInfinityTests(double number, int root, double expected)
+        {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            var result = QuantityValue.RootN(number, root);
+#if NET
+            Assert.Equal(double.RootN(number, root), result.ToDouble());
+#endif
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Fact]
+        public void RootWithNegativeAccuracyThrowsArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => QuantityValue.RootN(1, 1, -1));
+        }
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.QuantityValueTypeConverter.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.QuantityValueTypeConverter.cs
new file mode 100644
index 0000000000..468ee53925
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.QuantityValueTypeConverter.cs
@@ -0,0 +1,254 @@
+using System.Globalization;
+using System.Numerics;
+using JetBrains.Annotations;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    [TestSubject(typeof(QuantityValueTypeConverter))]
+    public class TypeConverterTests
+    {
+        [Theory]
+        [InlineData(typeof(string), true)]
+        [InlineData(typeof(int), true)]
+        [InlineData(typeof(long), true)]
+        [InlineData(typeof(decimal), true)]
+        [InlineData(typeof(double), true)]
+        [InlineData(typeof(QuantityValue), true)]
+        [InlineData(typeof(BigInteger), true)]
+        [InlineData(typeof(object), false)]
+        public void CanConvertTo_ReturnsExpectedResult(Type destinationType, bool expected)
+        {
+            var converter = new QuantityValueTypeConverter();
+            Assert.Equal(expected, converter.CanConvertTo(null, destinationType));
+        }
+
+        [Theory]
+        [InlineData(typeof(string), true)]
+        [InlineData(typeof(int), true)]
+        [InlineData(typeof(long), true)]
+        [InlineData(typeof(decimal), true)]
+        [InlineData(typeof(double), true)]
+        [InlineData(typeof(QuantityValue), true)]
+        [InlineData(typeof(BigInteger), true)]
+        [InlineData(typeof(object), false)]
+        public void CanConvertFrom_ReturnsExpectedResult(Type sourceType, bool expected)
+        {
+            var converter = new QuantityValueTypeConverter();
+            Assert.Equal(expected, converter.CanConvertFrom(null, sourceType));
+        }
+
+        [Fact]
+        public void ConvertTo_String()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var quantityValue = new QuantityValue(123.45m);
+            // Act
+            var result = converter.ConvertTo(null, CultureInfo.InvariantCulture, quantityValue, typeof(string));
+            // Assert
+            Assert.Equal("123.45", result);
+        }
+
+        [Fact]
+        public void ConvertTo_Int()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var quantityValue = new QuantityValue(123m);
+            // Act
+            var result = converter.ConvertTo(null, CultureInfo.InvariantCulture, quantityValue, typeof(int));
+            // Assert
+            Assert.Equal(123, result);
+        }
+
+        [Fact]
+        public void ConvertTo_Long()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var quantityValue = new QuantityValue(123L);
+            // Act
+            var result = converter.ConvertTo(null, CultureInfo.InvariantCulture, quantityValue, typeof(long));
+            // Assert
+            Assert.Equal(123L, result);
+        }
+
+        [Fact]
+        public void ConvertTo_Decimal()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var quantityValue = new QuantityValue(123.45m);
+            // Act
+            var result = converter.ConvertTo(null, CultureInfo.InvariantCulture, quantityValue, typeof(decimal));
+            // Assert
+            Assert.Equal(123.45m, result);
+        }
+
+        [Fact]
+        public void ConvertTo_Double()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var quantityValue = new QuantityValue(123.45m);
+            // Act
+            var result = converter.ConvertTo(null, CultureInfo.InvariantCulture, quantityValue, typeof(double));
+            // Assert
+            Assert.Equal(123.45, result);
+        }
+
+        [Fact]
+        public void ConvertTo_BigInteger()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var quantityValue = new QuantityValue(123.45m);
+            // Act
+            var result = converter.ConvertTo(null, CultureInfo.InvariantCulture, quantityValue, typeof(BigInteger));
+            // Assert
+            Assert.Equal(new BigInteger(123), result);
+        }
+
+        [Fact]
+        public void ConvertTo_QuantityValue()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var quantityValue = new QuantityValue(123.45m);
+            // Act
+            var result = converter.ConvertTo(null, CultureInfo.InvariantCulture, quantityValue, typeof(QuantityValue));
+            // Assert
+            Assert.Equal(quantityValue, result);
+        }
+
+        [Fact]
+        public void ConvertFrom_Null()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            // Act
+            var result = converter.ConvertFrom(null, CultureInfo.InvariantCulture, null);
+            // Assert
+            Assert.Equal(QuantityValue.Zero, result);
+        }
+
+        [Fact]
+        public void ConvertFrom_String()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var expectedValue = new QuantityValue(123.45m);
+            // Act
+            var result = converter.ConvertFrom(null, CultureInfo.InvariantCulture, "123.45");
+            // Assert
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Fact]
+        public void ConvertFrom_Int()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var expectedValue = new QuantityValue(123);
+            // Act
+            var result = converter.ConvertFrom(null, CultureInfo.InvariantCulture, 123);
+            // Assert
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Fact]
+        public void ConvertFrom_Long()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var expectedValue = new QuantityValue(123);
+            // Act
+            var result = converter.ConvertFrom(null, CultureInfo.InvariantCulture, 123L);
+            // Assert
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Fact]
+        public void ConvertFrom_Decimal()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            var expectedValue = new QuantityValue(123.45m);
+            // Act
+            var result = converter.ConvertFrom(null, CultureInfo.InvariantCulture, 123.45m);
+            // Assert
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Fact]
+        public void ConvertFrom_Double()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            QuantityValue expectedValue = 123.45;
+            // Act
+            var result = converter.ConvertFrom(null, CultureInfo.InvariantCulture, 123.45);
+            // Assert
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Fact]
+        public void ConvertFrom_BigInteger()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            QuantityValue expectedValue = 123;
+            // Act
+            var result = converter.ConvertFrom(null, CultureInfo.InvariantCulture, new BigInteger(123));
+            // Assert
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Fact]
+        public void ConvertFrom_QuantityValue()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            QuantityValue inputValue = 123;
+            // Act
+            var result = converter.ConvertFrom(null, CultureInfo.InvariantCulture, inputValue);
+            // Assert
+            Assert.Equal(inputValue, result);
+        }
+
+        [Fact]
+        public void ConvertFrom_Null_Returns_Zero()
+        {
+            // Arrange
+            var converter = new QuantityValueTypeConverter();
+            // Act
+            var result = converter.ConvertFrom(null, CultureInfo.InvariantCulture, null);
+            // Assert
+            Assert.Equal(QuantityValue.Zero, result);
+        }
+
+        [Fact]
+        public void ConvertTo_InvalidConversions_ThrowsException()
+        {
+            var converter = new QuantityValueTypeConverter();
+            var quantityValue = new QuantityValue(123.45m);
+            Assert.Throws<NotSupportedException>(() => converter.ConvertTo(null, CultureInfo.InvariantCulture, quantityValue, typeof(DateTime)));
+        }
+
+        [Fact]
+        public void ConvertTo_WithNull_ThrowsException()
+        {
+            var converter = new QuantityValueTypeConverter();
+            Assert.Throws<NotSupportedException>(() => converter.ConvertTo(null, CultureInfo.InvariantCulture, null, typeof(decimal)));
+        }
+
+        [Fact]
+        public void ConvertFrom_InvalidConversions_ThrowsException()
+        {
+            var converter = new QuantityValueTypeConverter();
+            Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(null, CultureInfo.InvariantCulture, DateTime.MinValue));
+        }
+    }
+}
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Rounding.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Rounding.cs
new file mode 100644
index 0000000000..f560c65278
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.Rounding.cs
@@ -0,0 +1,102 @@
+using System.Numerics;
+
+namespace UnitsNet.Tests;
+
+public partial class QuantityValueTests
+{
+    public class RoundingTests
+    {
+        private static readonly QuantityValueData[] DecimalFractions = [
+            0, 1, -1, 10, -10,
+            0.5m, -0.5m, 0.55m, -0.55m, 1.5m, -1.5m, 1.55m, -1.55m,
+            0.1m, -0.1m, 0.15m, -0.15m, 1.2m, -1.2m, 1.25m, -1.25m,
+            1.5545665434654m, -1.5545665434654m,
+            15.545665434654m, -15.545665434654m,
+            155.45665434654m, -155.45665434654m,
+            1554.5665434654m, -1554.5665434654m,
+            15545.665434654m, -15545.665434654m,
+            155456.65434654m, -155456.65434654m,
+            new QuantityValue(1, 3), new QuantityValue(-1, 3),
+            new QuantityValue(2, 3), new QuantityValue(-2, 3),
+            new QuantityValue(1999999999999999991, 3), new QuantityValue(-1999999999999999991, 3),
+            new QuantityValue(2000000000000000001, 3), new QuantityValue(-2000000000000000001, 3),
+        ];
+        
+        private static readonly MidpointRounding[] RoundingModes = [
+            MidpointRounding.ToEven,
+            MidpointRounding.AwayFromZero,
+#if NET
+            MidpointRounding.ToZero,
+            MidpointRounding.ToNegativeInfinity,
+            MidpointRounding.ToPositiveInfinity
+#endif
+        ];
+
+        public sealed class BigIntegerTestCases : TheoryData<QuantityValueData, MidpointRounding, BigInteger>
+        {
+            public BigIntegerTestCases()
+            {
+                foreach (var roundingMode in RoundingModes)
+                {
+                    foreach (var decimalFraction in DecimalFractions)
+                    {
+                        Add(decimalFraction, roundingMode, (BigInteger)Math.Round(decimalFraction.Value.ToDecimal(), roundingMode));
+                    }
+                }
+            }
+        }
+
+        [Theory]
+        [ClassData(typeof(BigIntegerTestCases))]
+        public void RoundToBigInteger_ReturnsTheExpectedResult(QuantityValueData value, MidpointRounding mode, BigInteger expected)
+        {
+            Assert.Equal(expected, QuantityValue.Round(value, mode));
+        }
+
+        [Fact]
+        public void RoundToBigInteger_Given_NaN_or_Infinity_ThrowsDivideByZeroException()
+        {
+            Assert.Throws<OverflowException>(() => QuantityValue.Round(QuantityValue.NaN, MidpointRounding.ToEven));
+            Assert.Throws<OverflowException>(() => QuantityValue.Round(QuantityValue.PositiveInfinity, MidpointRounding.ToEven));
+            Assert.Throws<OverflowException>(() => QuantityValue.Round(QuantityValue.NegativeInfinity, MidpointRounding.ToEven));
+        }
+        
+        [Fact]
+        public void RoundToBigInteger_WithInvalidRoundingMode_ThrowsArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => QuantityValue.Round(new QuantityValue(1, 2), (MidpointRounding)5));
+        }
+        
+        [Fact]
+        public void Round_ToNegativeDecimals_ThrowsArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => QuantityValue.Round(new QuantityValue(1, 2), -1));
+        }
+
+        public sealed class DecimalFractionsFractionTestCases : TheoryData<QuantityValueData, MidpointRounding, int, QuantityValueData>
+        {
+            private static readonly int[] DecimalPlaces = Enumerable.Range(0, 6).ToArray();
+            
+            public DecimalFractionsFractionTestCases()
+            {
+                foreach (var roundingMode in RoundingModes)
+                {
+                    foreach (var nbDecimals in DecimalPlaces)
+                    {
+                        foreach (var decimalFraction in DecimalFractions)
+                        {
+                            Add(decimalFraction, roundingMode, nbDecimals, Math.Round(decimalFraction.Value.ToDecimal(), nbDecimals, roundingMode));
+                        }
+                    }
+                }
+            }
+        }
+        
+        [Theory]
+        [ClassData(typeof(DecimalFractionsFractionTestCases))]
+        public void Round_ReturnsTheExpectedResult(QuantityValueData value, MidpointRounding mode, int decimals, QuantityValueData expected)
+        {
+            Assert.Equal(expected.Value, QuantityValue.Round(value.Value, decimals, mode));
+        }
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.cs b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.cs
new file mode 100644
index 0000000000..96241edd79
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/ValueTests/QuantityValueTests.cs
@@ -0,0 +1,359 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Numerics;
+using JetBrains.Annotations;
+using Xunit.Abstractions;
+
+namespace UnitsNet.Tests;
+
+[TestSubject(typeof(QuantityValue))]
+public static partial class QuantityValueTests
+{
+    public class QuantityValueData : IXunitSerializable
+    {
+        private QuantityValue _value;
+
+        public QuantityValueData()
+        {
+            // empty constructor
+        }
+
+        public QuantityValueData(QuantityValue value)
+        {
+            _value = value;
+        }
+
+        public static implicit operator QuantityValue(QuantityValueData data)
+        {
+            return data._value;
+        }
+
+        public static implicit operator QuantityValueData(QuantityValue value)
+        {
+            return new QuantityValueData(value);
+        }
+
+        public static implicit operator QuantityValueData(int value)
+        {
+            return new QuantityValueData(value);
+        }
+
+        public static implicit operator QuantityValueData(decimal value)
+        {
+            return new QuantityValueData(value);
+        }
+
+        public static implicit operator QuantityValueData(double value)
+        {
+            return new QuantityValueData(value);
+        }
+
+        public QuantityValue Value => _value;
+
+        #region Implementation of IXunitSerializable
+
+        public void Serialize(IXunitSerializationInfo info)
+        {
+            info.AddValue("Numerator", _value.Numerator);
+            info.AddValue("Denominator", _value.Denominator);
+        }
+
+        public void Deserialize(IXunitSerializationInfo info)
+        {
+            var numerator = info.GetValue<BigInteger>("Numerator");
+            var denominator = info.GetValue<BigInteger>("Denominator");
+            _value = new QuantityValue(numerator, denominator);
+        }
+
+        #endregion
+
+        public override string ToString()
+        {
+            return $"{Value.Numerator}/{Value.Denominator}";
+        }
+    }
+
+#if NET
+    /// <summary>
+    ///     Represents a fake number implementation for testing purposes.
+    /// </summary>
+    /// <remarks>
+    ///     This class is used internally within the test suite to simulate a number type that implements the
+    ///     <see cref="System.Numerics.INumberBase{T}" /> interface.
+    ///     It provides functionality to test conversions and operations involving custom number types.
+    /// </remarks>
+#pragma warning disable CA1067, CS0660
+    private class FakeNumber : INumberBase<FakeNumber>
+#pragma warning restore CS0660, CA1067
+    {
+        public static FakeNumber Zero { get; } = new();
+
+        static bool INumberBase<FakeNumber>.TryConvertFromChecked<TOther>(TOther value, [MaybeNullWhen(false)] out FakeNumber result)
+        {
+            result = null;
+            return false;
+        }
+
+        static bool INumberBase<FakeNumber>.TryConvertFromSaturating<TOther>(TOther value, [MaybeNullWhen(false)] out FakeNumber result)
+        {
+            result = null;
+            return false;
+        }
+
+        static bool INumberBase<FakeNumber>.TryConvertFromTruncating<TOther>(TOther value, [MaybeNullWhen(false)] out FakeNumber result)
+        {
+            result = null;
+            return false;
+        }
+
+        static bool INumberBase<FakeNumber>.TryConvertToChecked<TOther>(FakeNumber value, [MaybeNullWhen(false)] out TOther result)
+        {
+            result = default;
+            return false;
+        }
+
+        static bool INumberBase<FakeNumber>.TryConvertToSaturating<TOther>(FakeNumber value, [MaybeNullWhen(false)] out TOther result)
+        {
+            result = default;
+            return false;
+        }
+
+        static bool INumberBase<FakeNumber>.TryConvertToTruncating<TOther>(FakeNumber value, [MaybeNullWhen(false)] out TOther result)
+        {
+            result = default;
+            return false;
+        }
+
+        #region Other interface members (not implemented)
+
+        bool IEquatable<FakeNumber>.Equals(FakeNumber? other)
+        {
+            throw new NotImplementedException();
+        }
+
+        string IFormattable.ToString(string? format, IFormatProvider? formatProvider)
+        {
+            throw new NotImplementedException();
+        }
+
+        bool ISpanFormattable.TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber IParsable<FakeNumber>.Parse(string s, IFormatProvider? provider)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool IParsable<FakeNumber>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out FakeNumber result)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber ISpanParsable<FakeNumber>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool ISpanParsable<FakeNumber>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out FakeNumber result)
+        {
+            throw new NotImplementedException();
+        }
+
+
+        static FakeNumber IAdditionOperators<FakeNumber, FakeNumber, FakeNumber>.operator +(FakeNumber left, FakeNumber right)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber IAdditiveIdentity<FakeNumber, FakeNumber>.AdditiveIdentity { get; } = new();
+
+        static FakeNumber IDecrementOperators<FakeNumber>.operator --(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber IDivisionOperators<FakeNumber, FakeNumber, FakeNumber>.operator /(FakeNumber left, FakeNumber right)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool IEqualityOperators<FakeNumber, FakeNumber, bool>.operator ==(FakeNumber? left, FakeNumber? right)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool IEqualityOperators<FakeNumber, FakeNumber, bool>.operator !=(FakeNumber? left, FakeNumber? right)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber IIncrementOperators<FakeNumber>.operator ++(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber IMultiplicativeIdentity<FakeNumber, FakeNumber>.MultiplicativeIdentity { get; } = new();
+
+        static FakeNumber IMultiplyOperators<FakeNumber, FakeNumber, FakeNumber>.operator *(FakeNumber left, FakeNumber right)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber ISubtractionOperators<FakeNumber, FakeNumber, FakeNumber>.operator -(FakeNumber left, FakeNumber right)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber IUnaryNegationOperators<FakeNumber, FakeNumber>.operator -(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber IUnaryPlusOperators<FakeNumber, FakeNumber>.operator +(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber INumberBase<FakeNumber>.Abs(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsCanonical(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsComplexNumber(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsEvenInteger(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsFinite(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsImaginaryNumber(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsInfinity(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsInteger(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsNaN(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsNegative(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsNegativeInfinity(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsNormal(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsOddInteger(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsPositive(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsPositiveInfinity(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsRealNumber(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsSubnormal(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.IsZero(FakeNumber value)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber INumberBase<FakeNumber>.MaxMagnitude(FakeNumber x, FakeNumber y)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber INumberBase<FakeNumber>.MaxMagnitudeNumber(FakeNumber x, FakeNumber y)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber INumberBase<FakeNumber>.MinMagnitude(FakeNumber x, FakeNumber y)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber INumberBase<FakeNumber>.MinMagnitudeNumber(FakeNumber x, FakeNumber y)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber INumberBase<FakeNumber>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber INumberBase<FakeNumber>.Parse(string s, NumberStyles style, IFormatProvider? provider)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, [MaybeNullWhen(false)] out FakeNumber result)
+        {
+            throw new NotImplementedException();
+        }
+
+        static bool INumberBase<FakeNumber>.TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, [MaybeNullWhen(false)] out FakeNumber result)
+        {
+            throw new NotImplementedException();
+        }
+
+        static FakeNumber INumberBase<FakeNumber>.One { get; } = new();
+        static int INumberBase<FakeNumber>.Radix { get; } = 10;
+
+        #endregion
+    }
+    
+#endif
+}
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/VitaminATests.cs b/UnitsNet.Tests/CustomCode/VitaminATests.cs
index 1418760f26..57174e5688 100644
--- a/UnitsNet.Tests/CustomCode/VitaminATests.cs
+++ b/UnitsNet.Tests/CustomCode/VitaminATests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet.Tests
diff --git a/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs b/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs
index 2734776253..778855bb53 100644
--- a/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
diff --git a/UnitsNet.Tests/CustomCode/VolumeFlowPerAreaTests.cs b/UnitsNet.Tests/CustomCode/VolumeFlowPerAreaTests.cs
index 9725847bf2..e0a0bd15cc 100644
--- a/UnitsNet.Tests/CustomCode/VolumeFlowPerAreaTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeFlowPerAreaTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -27,5 +27,16 @@ public class VolumeFlowPerAreaTests : VolumeFlowPerAreaTestsBase
         protected override double CubicFeetPerMinutePerSquareFootInOneCubicMeterPerSecondPerSquareMeter => 196.850394;
 
         protected override double CubicMetersPerSecondPerSquareMeterInOneCubicMeterPerSecondPerSquareMeter =>  1;
+
+        [Fact]
+        public void VolumeFlowPerAreaTimesAreaEqualsVolumeFlow()
+        {
+            VolumeFlowPerArea volumeFlowPerArea = VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(2);
+            Area area = Area.FromSquareMeters(3);
+            VolumeFlow expected = VolumeFlow.FromCubicMetersPerSecond(6);
+
+            Assert.Equal(expected, volumeFlowPerArea * area);
+            Assert.Equal(expected, area * volumeFlowPerArea);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs b/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs
index 2b66eb040e..2a7106bc2c 100644
--- a/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -53,6 +53,14 @@ public class VolumeFlowTests : VolumeFlowTestsBase
 
         protected override double CubicFeetPerSecondInOneCubicMeterPerSecond => 35.314666721489;
 
+        // https://www.wolframalpha.com/input?i=1+cubic+meter+per+second+to+cubic+inches+per+second
+        // It should be the same as CubicInchesInOneCubicMeter
+        protected override double CubicInchesPerSecondInOneCubicMeterPerSecond => 6.1023744094732284e+4;
+
+        // https://www.wolframalpha.com/input?i=1+cubic+meter+per+second+to+cubic+inches+per+minute
+        // or 60x the previous value, which is 3661424.645683937
+        protected override double CubicInchesPerMinuteInOneCubicMeterPerSecond => 3.661424645683937e+6;
+
         protected override double CubicMetersPerDayInOneCubicMeterPerSecond => 8.64e4;
 
         protected override double CubicMetersPerHourInOneCubicMeterPerSecond => 3.6e3;
@@ -63,6 +71,10 @@ public class VolumeFlowTests : VolumeFlowTestsBase
 
         protected override double CubicMillimetersPerSecondInOneCubicMeterPerSecond => 1e9;
 
+        // https://www.wolframalpha.com/input?i=1+cubic+meter+per+second+to+cubic+millimeters+per+minute
+        // or 60x the previous value, which is 60 x 10^9 = 6e10
+        protected override double CubicMillimetersPerMinuteInOneCubicMeterPerSecond => 6e10;
+
         protected override double CubicYardsPerDayInOneCubicMeterPerSecond => 1.13007e5;
 
         protected override double CubicYardsPerHourInOneCubicMeterPerSecond => 4.708622232E3;
diff --git a/UnitsNet.Tests/CustomCode/VolumePerLengthTests.cs b/UnitsNet.Tests/CustomCode/VolumePerLengthTests.cs
index 58984f880a..7c5db97dda 100644
--- a/UnitsNet.Tests/CustomCode/VolumePerLengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumePerLengthTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated (once) by \generate-code.bat, but will not be
 //     regenerated when it already exists. The purpose of creating this file is to make
@@ -45,5 +45,16 @@ public class VolumePerLengthTests : VolumePerLengthTestsBase
 
         // https://www.wolframalpha.com/input?i=1.0000000000000000+cubic+meter+per+meter+to+imperial+gallon+per+mile
         protected override double ImperialGallonsPerMileInOneCubicMeterPerMeter => 3.540061899346471e5;
+
+        [Fact]
+        public void VolumePerLengthTimesLengthEqualsVolume()
+        {
+            VolumePerLength volumePerLength = VolumePerLength.FromCubicMetersPerMeter(2);
+            Length length = Length.FromMeters(3);
+            Volume expected = Volume.FromCubicMeters(6);
+
+            Assert.Equal(expected, volumePerLength * length);
+            Assert.Equal(expected, length * volumePerLength);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/VolumeTests.cs b/UnitsNet.Tests/CustomCode/VolumeTests.cs
index 0df729bde5..b2bd7fb84a 100644
--- a/UnitsNet.Tests/CustomCode/VolumeTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -37,8 +37,7 @@ public class VolumeTests : VolumeTestsBase
 
         protected override double DecilitersInOneCubicMeter => 1E4;
         protected override double DeciusGallonsInOneCubicMeter => 2.6417217e+3;
-        protected override double HectocubicFeetInOneCubicMeter => 3.531472e-1;
-        protected override double HectocubicMetersInOneCubicMeter => 0.01;
+        protected override double HundredCubicFeetInOneCubicMeter => 3.531472e-1;
 
         protected override double HectolitersInOneCubicMeter => 1E1;
 
@@ -48,15 +47,15 @@ public class VolumeTests : VolumeTestsBase
 
         protected override double ImperialOuncesInOneCubicMeter => 35195.07972;
 
-        protected override double KilocubicFeetInOneCubicMeter => 3.531472e-2;
-        protected override double KilocubicMetersInOneCubicMeter => 0.001;
+        protected override double ThousandCubicFeetInOneCubicMeter => 3.531472e-2;
+        protected override double ThousandCubicMetersInOneCubicMeter => 0.001;
         protected override double KiloimperialGallonsInOneCubicMeter => 2.1996924e-1;
         protected override double KilousGallonsInOneCubicMeter => 2.6417217e-1;
 
         protected override double LitersInOneCubicMeter => 1E3;
         protected override double KilolitersInOneCubicMeter => 1;
 
-        protected override double MegacubicFeetInOneCubicMeter => 3.531472e-5;
+        protected override double MillionCubicFeetInOneCubicMeter => 3.531472e-5;
         protected override double MegaimperialGallonsInOneCubicMeter => 2.1996924e-4;
         protected override double MegausGallonsInOneCubicMeter => 2.6417217e-4;
 
@@ -113,6 +112,20 @@ public class VolumeTests : VolumeTestsBase
         /// </summary>
         protected override double ImperialQuartsInOneCubicMeter => 879.876993196;
 
+        /// <summary>
+        /// https://www.bipm.org/en/measurement-units/si-prefixes
+        /// </summary>
+        [Theory]
+        [InlineData(1e6, "hm³")]
+        [InlineData(1e9, "km³")]
+        public void ConvertByAbbreviation_CubicMetersToTrueCubicPrefixedUnits(double cubicMeters, string abbreviation)
+        {
+            bool converted = UnitConverter.TryConvertByAbbreviation(cubicMeters, "Volume", "m³", abbreviation, out QuantityValue result);
+
+            Assert.True(converted);
+            Assert.Equal(QuantityValue.One, result);
+        }
+
         [Fact]
         public void VolumeDividedByAreaEqualsLength()
         {
@@ -134,6 +147,13 @@ public void VolumeTimesDensityEqualsMass()
             Assert.Equal(mass, Mass.FromKilograms(6));
         }
 
+        [Fact]
+        public void VolumeTimesSpecificWeightEqualsForce()
+        {
+            Force force = Volume.FromCubicMeters(2) * SpecificWeight.FromNewtonsPerCubicMeter(3);
+            Assert.Equal(force, Force.FromNewtons(6));
+        }
+
         [Theory]
         [InlineData(20, 2, 10)]
         [InlineData(20, 80, 0.25)]
diff --git a/UnitsNet.Tests/CustomCode/VolumetricHeatCapacityTests.cs b/UnitsNet.Tests/CustomCode/VolumetricHeatCapacityTests.cs
index 51392a43d9..2bddb8c169 100644
--- a/UnitsNet.Tests/CustomCode/VolumetricHeatCapacityTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumetricHeatCapacityTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
@@ -34,6 +34,19 @@ public class VolumetricHeatCapacityTests : VolumetricHeatCapacityTestsBase
 
         protected override double JoulesPerCubicMeterDegreeCelsiusInOneJoulePerCubicMeterKelvin => 1;
         protected override double KilojoulesPerCubicMeterDegreeCelsiusInOneJoulePerCubicMeterKelvin => 1E-3;
-        protected override double MegajoulesPerCubicMeterDegreeCelsiusInOneJoulePerCubicMeterKelvin => 1E-6;        
+        protected override double MegajoulesPerCubicMeterDegreeCelsiusInOneJoulePerCubicMeterKelvin => 1E-6;
+
+        [Fact]
+        public void VolumetricHeatCapacityTimesTemperatureDeltaEqualsEnergyDensity()
+        {
+            VolumetricHeatCapacity volumetricHeatCapacity = VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(2);
+            TemperatureDelta temperatureDelta = TemperatureDelta.FromKelvins(3);
+            EnergyDensity expected = EnergyDensity.FromJoulesPerCubicMeter(6);
+
+            Assert.Equal(expected, volumetricHeatCapacity * temperatureDelta);
+            Assert.Equal(expected, temperatureDelta * volumetricHeatCapacity);
+            Assert.Equal(temperatureDelta, expected / volumetricHeatCapacity);
+            Assert.Equal(volumetricHeatCapacity, expected / temperatureDelta);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/WarpingMomentOfInertiaTests.cs b/UnitsNet.Tests/CustomCode/WarpingMomentOfInertiaTests.cs
index 8889c394f9..1245b6db79 100644
--- a/UnitsNet.Tests/CustomCode/WarpingMomentOfInertiaTests.cs
+++ b/UnitsNet.Tests/CustomCode/WarpingMomentOfInertiaTests.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet.Tests/CustomQuantities/ClassOfAffineQuantity.cs b/UnitsNet.Tests/CustomQuantities/ClassOfAffineQuantity.cs
new file mode 100644
index 0000000000..a037033cde
--- /dev/null
+++ b/UnitsNet.Tests/CustomQuantities/ClassOfAffineQuantity.cs
@@ -0,0 +1,105 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Diagnostics;
+using UnitsNet.Debug;
+
+namespace UnitsNet.Tests.CustomQuantities;
+
+/// <summary>
+///     Example of a custom/third-party quantity implementation, for plugging in quantities and units at runtime.
+/// </summary>
+public enum ClassOfAffineQuantityUnit
+{
+    Some,
+    ATon,
+    AShitTon
+}
+
+/// <inheritdoc cref="IQuantity" />
+/// <summary>
+///     Example of a custom/third-party quantity implementation, for plugging in quantities and units at runtime.
+/// </summary>
+[DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+[DebuggerTypeProxy(typeof(QuantityDebugProxy))]
+public class ClassOfAffineQuantity(QuantityValue value, ClassOfAffineQuantityUnit unit) : IAffineQuantity<ClassOfAffineQuantity, ClassOfAffineQuantityUnit, ClassOfLinearQuantity>
+{
+    public static QuantityInfo<ClassOfAffineQuantity, ClassOfAffineQuantityUnit> Info { get; } = new(
+        ClassOfAffineQuantityUnit.Some,
+        new UnitDefinition<ClassOfAffineQuantityUnit>[]
+        {
+            new(ClassOfAffineQuantityUnit.Some, "Some", BaseUnits.Undefined),
+            new(ClassOfAffineQuantityUnit.ATon, "Tons", new BaseUnits(mass: MassUnit.Tonne), QuantityValue.FromTerms(1, 10)),
+            new(ClassOfAffineQuantityUnit.AShitTon, "ShitTons", BaseUnits.Undefined, QuantityValue.FromTerms(1, 100))
+        },
+        new BaseDimensions(0, 1, 0, 0, 0, 0, 0),
+        From);
+
+    public ClassOfAffineQuantityUnit Unit { get; } = unit;
+
+    public QuantityValue Value { get; } = value;
+
+    public static ClassOfAffineQuantity From(QuantityValue value, ClassOfAffineQuantityUnit unit)
+    {
+        return new ClassOfAffineQuantity(value, unit);
+    }
+
+    public static ClassOfAffineQuantity Zero { get; } = new(0, ClassOfAffineQuantityUnit.Some);
+    
+    public static ClassOfAffineQuantity operator +(ClassOfAffineQuantity left, ClassOfLinearQuantity right)
+    {
+        return new ClassOfAffineQuantity(left.As(ClassOfAffineQuantityUnit.Some) + right.As(ClassOfLinearQuantityUnit.Some), ClassOfAffineQuantityUnit.Some);
+    }
+
+    public static ClassOfLinearQuantity operator -(ClassOfAffineQuantity left, ClassOfAffineQuantity right)
+    {
+        return new ClassOfLinearQuantity(left.As(ClassOfAffineQuantityUnit.Some) - right.As(ClassOfAffineQuantityUnit.Some), ClassOfLinearQuantityUnit.Some);
+    }
+
+    #region IQuantity
+
+    QuantityInfo<ClassOfAffineQuantity, ClassOfAffineQuantityUnit> IQuantity<ClassOfAffineQuantity, ClassOfAffineQuantityUnit>.QuantityInfo
+    {
+        get => Info;
+    }
+
+    public override string ToString()
+    {
+        return ToString("G", null);
+    }
+
+    public string ToString(string? format, IFormatProvider? formatProvider)
+    {
+        return QuantityFormatter.Default.Format(this, format, formatProvider);
+    }
+
+    UnitKey IQuantity.UnitKey
+    {
+        get => UnitKey.ForUnit(Unit);
+    }
+    
+#if !NET
+    QuantityInfo IQuantity.QuantityInfo
+    {
+        get => Info;
+    }
+
+    IQuantityInstanceInfo<ClassOfAffineQuantity> IQuantityOfType<ClassOfAffineQuantity>.QuantityInfo
+    {
+        get => Info;
+    }
+
+    Enum IQuantity.Unit
+    {
+        get => Unit;
+    }
+
+    QuantityInfo<ClassOfAffineQuantityUnit> IQuantity<ClassOfAffineQuantityUnit>.QuantityInfo
+    {
+        get => Info;
+    }
+#endif
+
+    #endregion
+
+}
diff --git a/UnitsNet.Tests/CustomQuantities/ClassOfLinearQuantity.cs b/UnitsNet.Tests/CustomQuantities/ClassOfLinearQuantity.cs
new file mode 100644
index 0000000000..7faeb0d5ff
--- /dev/null
+++ b/UnitsNet.Tests/CustomQuantities/ClassOfLinearQuantity.cs
@@ -0,0 +1,119 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Diagnostics;
+using UnitsNet.Debug;
+
+namespace UnitsNet.Tests.CustomQuantities;
+
+/// <summary>
+///     Example of a custom/third-party quantity implementation, for plugging in quantities and units at runtime.
+/// </summary>
+public enum ClassOfLinearQuantityUnit
+{
+    Some,
+    ATon,
+    AShitTon
+}
+
+/// <inheritdoc cref="IQuantity" />
+/// <summary>
+///     Example of a custom/third-party quantity implementation, for plugging in quantities and units at runtime.
+/// </summary>
+[DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+[DebuggerTypeProxy(typeof(QuantityDebugProxy))]
+public class ClassOfLinearQuantity(QuantityValue value, ClassOfLinearQuantityUnit unit) : ILinearQuantity<ClassOfLinearQuantity, ClassOfLinearQuantityUnit>
+{
+    public static QuantityInfo<ClassOfLinearQuantity, ClassOfLinearQuantityUnit> Info { get; } = new(
+        ClassOfLinearQuantityUnit.Some,
+        new UnitDefinition<ClassOfLinearQuantityUnit>[]
+        {
+            new(ClassOfLinearQuantityUnit.Some, "Some", BaseUnits.Undefined),
+            new(ClassOfLinearQuantityUnit.ATon, "Tons", new BaseUnits(mass: MassUnit.Tonne), QuantityValue.FromTerms(1, 10)),
+            new(ClassOfLinearQuantityUnit.AShitTon, "ShitTons", BaseUnits.Undefined, QuantityValue.FromTerms(1, 100))
+        },
+        new BaseDimensions(0, 1, 0, 0, 0, 0, 0),
+        From);
+
+    public ClassOfLinearQuantityUnit Unit { get; } = unit;
+
+    public QuantityValue Value { get; } = value;
+
+    public static ClassOfLinearQuantity From(QuantityValue value, ClassOfLinearQuantityUnit unit)
+    {
+        return new ClassOfLinearQuantity(value, unit);
+    }
+
+    public static ClassOfLinearQuantity Zero { get; } = new(0, ClassOfLinearQuantityUnit.Some);
+
+    public static ClassOfLinearQuantity operator +(ClassOfLinearQuantity left, ClassOfLinearQuantity right)
+    {
+        return new ClassOfLinearQuantity(left.Value + right.As(left.Unit), left.Unit);
+    }
+
+    public static ClassOfLinearQuantity operator -(ClassOfLinearQuantity left, ClassOfLinearQuantity right)
+    {
+        return new ClassOfLinearQuantity(left.Value - right.As(left.Unit), left.Unit);
+    }
+
+    public static ClassOfLinearQuantity operator *(ClassOfLinearQuantity left, QuantityValue right)
+    {
+        return new ClassOfLinearQuantity(left.Value * right, left.Unit);
+    }
+
+    public static ClassOfLinearQuantity operator /(ClassOfLinearQuantity left, QuantityValue right)
+    {
+        return new ClassOfLinearQuantity(left.Value / right, left.Unit);
+    }
+
+    public static ClassOfLinearQuantity operator -(ClassOfLinearQuantity value)
+    {
+        return new ClassOfLinearQuantity(-value.Value, value.Unit);
+    }
+
+    #region IQuantity
+
+    QuantityInfo<ClassOfLinearQuantity, ClassOfLinearQuantityUnit> IQuantity<ClassOfLinearQuantity, ClassOfLinearQuantityUnit>.QuantityInfo
+    {
+        get => Info;
+    }
+
+    public override string ToString()
+    {
+        return ToString("G", null);
+    }
+
+    public string ToString(string? format, IFormatProvider? formatProvider)
+    {
+        return QuantityFormatter.Default.Format(this, format, formatProvider);
+    }
+
+    UnitKey IQuantity.UnitKey
+    {
+        get => UnitKey.ForUnit(Unit);
+    }
+    
+#if !NET
+    QuantityInfo IQuantity.QuantityInfo
+    {
+        get => Info;
+    }
+
+    IQuantityInstanceInfo<ClassOfLinearQuantity> IQuantityOfType<ClassOfLinearQuantity>.QuantityInfo
+    {
+        get => Info;
+    }
+
+    Enum IQuantity.Unit
+    {
+        get => Unit;
+    }
+
+    QuantityInfo<ClassOfLinearQuantityUnit> IQuantity<ClassOfLinearQuantityUnit>.QuantityInfo
+    {
+        get => Info;
+    }
+#endif
+
+    #endregion
+}
diff --git a/UnitsNet.Tests/CustomQuantities/ClassOfLogarithmicQuantity.cs b/UnitsNet.Tests/CustomQuantities/ClassOfLogarithmicQuantity.cs
new file mode 100644
index 0000000000..eb81f7cd22
--- /dev/null
+++ b/UnitsNet.Tests/CustomQuantities/ClassOfLogarithmicQuantity.cs
@@ -0,0 +1,129 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Diagnostics;
+using UnitsNet.Debug;
+
+namespace UnitsNet.Tests.CustomQuantities;
+
+/// <summary>
+///     Example of a custom/third-party quantity implementation, for plugging in quantities and units at runtime.
+/// </summary>
+public enum ClassOfLogarithmicQuantityUnit
+{
+    Some,
+    ATon,
+    AShitTon
+}
+
+/// <inheritdoc cref="IQuantity" />
+/// <summary>
+///     Example of a custom/third-party quantity implementation, for plugging in quantities and units at runtime.
+/// </summary>
+[DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+[DebuggerTypeProxy(typeof(QuantityDebugProxy))]
+public class ClassOfLogarithmicQuantity(QuantityValue value, ClassOfLogarithmicQuantityUnit unit) : ILogarithmicQuantity<ClassOfLogarithmicQuantity, ClassOfLogarithmicQuantityUnit>
+{
+    public static QuantityInfo<ClassOfLogarithmicQuantity, ClassOfLogarithmicQuantityUnit> Info { get; } = new(
+        ClassOfLogarithmicQuantityUnit.Some,
+        new UnitDefinition<ClassOfLogarithmicQuantityUnit>[]
+        {
+            new(ClassOfLogarithmicQuantityUnit.Some, "Some", BaseUnits.Undefined),
+            new(ClassOfLogarithmicQuantityUnit.ATon, "Tons", new BaseUnits(mass: MassUnit.Tonne), QuantityValue.FromTerms(1, 10)),
+            new(ClassOfLogarithmicQuantityUnit.AShitTon, "ShitTons", BaseUnits.Undefined, QuantityValue.FromTerms(1, 100))
+        },
+        new BaseDimensions(0, 1, 0, 0, 0, 0, 0),
+        From);
+
+    public ClassOfLogarithmicQuantityUnit Unit { get; } = unit;
+
+    public QuantityValue Value { get; } = value;
+
+    public static ClassOfLogarithmicQuantity From(QuantityValue value, ClassOfLogarithmicQuantityUnit unit)
+    {
+        return new ClassOfLogarithmicQuantity(value, unit);
+    }
+
+    public static QuantityValue LogarithmicScalingFactor { get => 10; }
+    
+    public static ClassOfLogarithmicQuantity Zero { get; } = new(0, ClassOfLogarithmicQuantityUnit.Some);
+
+    public static ClassOfLogarithmicQuantity operator +(ClassOfLogarithmicQuantity left, ClassOfLogarithmicQuantity right)
+    {
+        // note: the AddWithLogScaling function isn't public
+        return new ClassOfLogarithmicQuantity(QuantityValueExtensions.AddWithLogScaling(left.Value, right.As(left.Unit), LogarithmicScalingFactor), left.Unit);
+    }
+
+    public static ClassOfLogarithmicQuantity operator -(ClassOfLogarithmicQuantity left, ClassOfLogarithmicQuantity right)
+    {
+        // note: the SubtractWithLogScaling function isn't public
+        return new ClassOfLogarithmicQuantity(QuantityValueExtensions.SubtractWithLogScaling(left.Value, right.As(left.Unit), LogarithmicScalingFactor), left.Unit);
+    }
+
+    public static ClassOfLogarithmicQuantity operator *(ClassOfLogarithmicQuantity left, QuantityValue right)
+    {
+        return new ClassOfLogarithmicQuantity(left.Value + right, left.Unit);
+    }
+
+    public static ClassOfLogarithmicQuantity operator /(ClassOfLogarithmicQuantity left, QuantityValue right)
+    {
+        return new ClassOfLogarithmicQuantity(left.Value - right, left.Unit);
+    }
+
+    public static ClassOfLogarithmicQuantity operator -(ClassOfLogarithmicQuantity value)
+    {
+        return new ClassOfLogarithmicQuantity(-value.Value, value.Unit);
+    }
+
+    #region IQuantity
+
+    QuantityInfo<ClassOfLogarithmicQuantity, ClassOfLogarithmicQuantityUnit> IQuantity<ClassOfLogarithmicQuantity, ClassOfLogarithmicQuantityUnit>.QuantityInfo
+    {
+        get => Info;
+    }
+
+    public override string ToString()
+    {
+        return ToString("G", null);
+    }
+
+    public string ToString(string? format, IFormatProvider? formatProvider)
+    {
+        return QuantityFormatter.Default.Format(this, format, formatProvider);
+    }
+
+    UnitKey IQuantity.UnitKey
+    {
+        get => UnitKey.ForUnit(Unit);
+    }
+    
+#if !NET
+
+    QuantityValue ILogarithmicQuantity<ClassOfLogarithmicQuantity>.LogarithmicScalingFactor
+    {
+        get => LogarithmicScalingFactor;
+    }
+
+    QuantityInfo IQuantity.QuantityInfo
+    {
+        get => Info;
+    }
+
+    IQuantityInstanceInfo<ClassOfLogarithmicQuantity> IQuantityOfType<ClassOfLogarithmicQuantity>.QuantityInfo
+    {
+        get => Info;
+    }
+
+    Enum IQuantity.Unit
+    {
+        get => Unit;
+    }
+
+    QuantityInfo<ClassOfLogarithmicQuantityUnit> IQuantity<ClassOfLogarithmicQuantityUnit>.QuantityInfo
+    {
+        get => Info;
+    }
+#endif
+
+    #endregion
+}
diff --git a/UnitsNet.Tests/CustomQuantities/HowMuch.cs b/UnitsNet.Tests/CustomQuantities/HowMuch.cs
index 7a59f20a8d..4352988008 100644
--- a/UnitsNet.Tests/CustomQuantities/HowMuch.cs
+++ b/UnitsNet.Tests/CustomQuantities/HowMuch.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using UnitsNet.Units;
 
 namespace UnitsNet.Tests.CustomQuantities
@@ -9,36 +9,31 @@ namespace UnitsNet.Tests.CustomQuantities
     /// </summary>
     public readonly struct HowMuch : IQuantity<HowMuch, HowMuchUnit>
     {
-        public HowMuch(double value, HowMuchUnit unit)
+        public HowMuch(QuantityValue value, HowMuchUnit unit)
         {
             Unit = unit;
             Value = value;
         }
 
-        public static HowMuch From(double value, HowMuchUnit unit)
+        public static HowMuch From(QuantityValue value, HowMuchUnit unit)
         {
             return new HowMuch(value, unit);
         }
 
-        public double As(HowMuchUnit unit)
-        {
-            throw new NotImplementedException();
-        }
-
         public HowMuchUnit Unit { get; }
 
-        public double Value { get; }
+        public QuantityValue Value { get; }
 
         #region IQuantity
         
-        public static readonly QuantityInfo<HowMuch, HowMuchUnit> Info = new(
+        public static QuantityInfo<HowMuch, HowMuchUnit> Info { get; } = new(
             nameof(HowMuch),
             HowMuchUnit.Some,
             new UnitDefinition<HowMuchUnit>[]
             {
                 new(HowMuchUnit.Some, "Some", BaseUnits.Undefined),
-                new(HowMuchUnit.ATon, "Tons", new BaseUnits(mass: MassUnit.Tonne)),
-                new(HowMuchUnit.AShitTon, "ShitTons", BaseUnits.Undefined)
+                new(HowMuchUnit.ATon, "Tons", new BaseUnits(mass: MassUnit.Tonne), new QuantityValue(1, 10)),
+                new(HowMuchUnit.AShitTon, "ShitTons", BaseUnits.Undefined, new QuantityValue(1, 100))
             },
             new HowMuch(0, HowMuchUnit.Some),
             new BaseDimensions(0, 1, 0, 0, 0, 0, 0),
@@ -64,23 +59,6 @@ UnitKey IQuantity.UnitKey
             get => UnitKey.ForUnit(Unit);
         }
 
-        public double As(Enum unit) => Convert.ToDouble(unit);
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<HowMuchUnit>());
-        }
-
-        public IQuantity ToUnit(Enum unit)
-        {
-            if (unit is HowMuchUnit howMuchUnit) return new HowMuch(As(unit), howMuchUnit);
-            throw new ArgumentException("Must be of type HowMuchUnit.", nameof(unit));
-        }
-
-        public IQuantity<HowMuchUnit> ToUnit(HowMuchUnit unit)
-        {
-            throw new NotImplementedException();
-        }
-
         public override string ToString()
         {
             return $"{Value} {Unit}";
@@ -92,11 +70,7 @@ public string ToString(string? format, IFormatProvider? formatProvider)
         }
 
 #if !NET
-
-        QuantityInfo IQuantity.QuantityInfo
-        {
-            get { return Info; }
-        }
+        IQuantityInstanceInfo<HowMuch> IQuantityOfType<HowMuch>.QuantityInfo => Info;
 
         Enum IQuantity.Unit => Unit;
 #endif
diff --git a/UnitsNet.Tests/DisableParallelizationCollectionFixture.cs b/UnitsNet.Tests/DisableParallelizationCollectionFixture.cs
index 71aeda5945..471f4c8e76 100644
--- a/UnitsNet.Tests/DisableParallelizationCollectionFixture.cs
+++ b/UnitsNet.Tests/DisableParallelizationCollectionFixture.cs
@@ -1,4 +1,5 @@
-using System.Globalization;
+using System.Globalization;
+using UnitsNet.Tests.Helpers;
 using Xunit;
 
 namespace UnitsNet.Tests;
diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
index 9dfabd182a..cdb328511b 100644
--- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
@@ -40,8 +40,9 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity)
             Assertion(3, AmplitudeRatioUnit.DecibelVolt, Quantity.From(3, AmplitudeRatioUnit.DecibelVolt));
             Assertion(3, AngleUnit.Revolution, Quantity.From(3, AngleUnit.Revolution));
             Assertion(3, AreaUnit.UsSurveySquareFoot, Quantity.From(3, AreaUnit.UsSurveySquareFoot));
-            Assertion(3, AreaDensityUnit.MilligramPerSquareMeter, Quantity.From(3, AreaDensityUnit.MilligramPerSquareMeter));
+            Assertion(3, AreaDensityUnit.PoundPerThousandSquareFeet, Quantity.From(3, AreaDensityUnit.PoundPerThousandSquareFeet));
             Assertion(3, AreaMomentOfInertiaUnit.MillimeterToTheFourth, Quantity.From(3, AreaMomentOfInertiaUnit.MillimeterToTheFourth));
+            Assertion(3, AreaPerLengthUnit.SquareMillimeterPerMeter, Quantity.From(3, AreaPerLengthUnit.SquareMillimeterPerMeter));
             Assertion(3, BitRateUnit.TeraoctetPerSecond, Quantity.From(3, BitRateUnit.TeraoctetPerSecond));
             Assertion(3, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, Quantity.From(3, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour));
             Assertion(3, CoefficientOfThermalExpansionUnit.PpmPerKelvin, Quantity.From(3, CoefficientOfThermalExpansionUnit.PpmPerKelvin));
@@ -82,7 +83,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity)
             Assertion(3, ForcePerLengthUnit.TonneForcePerMillimeter, Quantity.From(3, ForcePerLengthUnit.TonneForcePerMillimeter));
             Assertion(3, FrequencyUnit.Terahertz, Quantity.From(3, FrequencyUnit.Terahertz));
             Assertion(3, FuelEfficiencyUnit.MilePerUsGallon, Quantity.From(3, FuelEfficiencyUnit.MilePerUsGallon));
-            Assertion(3, HeatFluxUnit.WattPerSquareMeter, Quantity.From(3, HeatFluxUnit.WattPerSquareMeter));
+            Assertion(3, HeatFluxUnit.WattPerSquareMillimeter, Quantity.From(3, HeatFluxUnit.WattPerSquareMillimeter));
             Assertion(3, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, Quantity.From(3, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
             Assertion(3, IlluminanceUnit.Millilux, Quantity.From(3, IlluminanceUnit.Millilux));
             Assertion(3, ImpulseUnit.SlugFootPerSecond, Quantity.From(3, ImpulseUnit.SlugFootPerSecond));
@@ -114,7 +115,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity)
             Assertion(3, MolarEntropyUnit.MegajoulePerMoleKelvin, Quantity.From(3, MolarEntropyUnit.MegajoulePerMoleKelvin));
             Assertion(3, MolarFlowUnit.PoundMolePerSecond, Quantity.From(3, MolarFlowUnit.PoundMolePerSecond));
             Assertion(3, MolarityUnit.PoundMolePerCubicFoot, Quantity.From(3, MolarityUnit.PoundMolePerCubicFoot));
-            Assertion(3, MolarMassUnit.PoundPerMole, Quantity.From(3, MolarMassUnit.PoundPerMole));
+            Assertion(3, MolarMassUnit.PoundPerPoundMole, Quantity.From(3, MolarMassUnit.PoundPerPoundMole));
             Assertion(3, PermeabilityUnit.HenryPerMeter, Quantity.From(3, PermeabilityUnit.HenryPerMeter));
             Assertion(3, PermittivityUnit.FaradPerMeter, Quantity.From(3, PermittivityUnit.FaradPerMeter));
             Assertion(3, PorousMediumPermeabilityUnit.SquareMeter, Quantity.From(3, PorousMediumPermeabilityUnit.SquareMeter));
@@ -141,7 +142,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity)
             Assertion(3, SpecificEnergyUnit.WattHourPerPound, Quantity.From(3, SpecificEnergyUnit.WattHourPerPound));
             Assertion(3, SpecificEntropyUnit.MegajoulePerKilogramKelvin, Quantity.From(3, SpecificEntropyUnit.MegajoulePerKilogramKelvin));
             Assertion(3, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour, Quantity.From(3, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour));
-            Assertion(3, SpecificVolumeUnit.MillicubicMeterPerKilogram, Quantity.From(3, SpecificVolumeUnit.MillicubicMeterPerKilogram));
+            Assertion(3, SpecificVolumeUnit.CubicMillimeterPerKilogram, Quantity.From(3, SpecificVolumeUnit.CubicMillimeterPerKilogram));
             Assertion(3, SpecificWeightUnit.TonneForcePerCubicMillimeter, Quantity.From(3, SpecificWeightUnit.TonneForcePerCubicMillimeter));
             Assertion(3, SpeedUnit.YardPerSecond, Quantity.From(3, SpeedUnit.YardPerSecond));
             Assertion(3, StandardVolumeFlowUnit.StandardLiterPerMinute, Quantity.From(3, StandardVolumeFlowUnit.StandardLiterPerMinute));
@@ -177,6 +178,7 @@ public void QuantityInfo_IsSameAsStaticInfoProperty()
             Assertion(Area.Info, Area.Zero);
             Assertion(AreaDensity.Info, AreaDensity.Zero);
             Assertion(AreaMomentOfInertia.Info, AreaMomentOfInertia.Zero);
+            Assertion(AreaPerLength.Info, AreaPerLength.Zero);
             Assertion(BitRate.Info, BitRate.Zero);
             Assertion(BrakeSpecificFuelConsumption.Info, BrakeSpecificFuelConsumption.Zero);
             Assertion(CoefficientOfThermalExpansion.Info, CoefficientOfThermalExpansion.Zero);
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AbsorbedDoseOfIonizingRadiationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AbsorbedDoseOfIonizingRadiationTestsBase.g.cs
index 8840d0d429..e9b6c7ac20 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AbsorbedDoseOfIonizingRadiationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AbsorbedDoseOfIonizingRadiationTestsBase.g.cs
@@ -189,6 +189,20 @@ public void AbsorbedDoseOfIonizingRadiation_QuantityInfo_ReturnsQuantityInfoDesc
             Assert.Equal(quantityInfo, ((IQuantity<AbsorbedDoseOfIonizingRadiationUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void AbsorbedDoseOfIonizingRadiationInfo_CreateWithCustomUnitInfos()
+        {
+            AbsorbedDoseOfIonizingRadiationUnit[] expectedUnits = [AbsorbedDoseOfIonizingRadiationUnit.Gray];
+
+            AbsorbedDoseOfIonizingRadiation.AbsorbedDoseOfIonizingRadiationInfo quantityInfo = AbsorbedDoseOfIonizingRadiation.AbsorbedDoseOfIonizingRadiationInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("AbsorbedDoseOfIonizingRadiation", quantityInfo.Name);
+            Assert.Equal(AbsorbedDoseOfIonizingRadiation.Zero, quantityInfo.Zero);
+            Assert.Equal(AbsorbedDoseOfIonizingRadiation.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void GrayToAbsorbedDoseOfIonizingRadiationUnits()
         {
@@ -305,26 +319,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = AbsorbedDoseOfIonizingRadiation.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            AbsorbedDoseOfIonizingRadiation convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                AbsorbedDoseOfIonizingRadiation quantityToConvert = quantity;
+
+                AbsorbedDoseOfIonizingRadiation convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<AbsorbedDoseOfIonizingRadiationUnit> quantityToConvert = quantity;
+
+                IQuantity<AbsorbedDoseOfIonizingRadiationUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new AbsorbedDoseOfIonizingRadiation(value: 1, unit: AbsorbedDoseOfIonizingRadiation.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new AbsorbedDoseOfIonizingRadiation(value: 1, unit: AbsorbedDoseOfIonizingRadiation.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<AbsorbedDoseOfIonizingRadiationUnit> quantity = new AbsorbedDoseOfIonizingRadiation(value: 1, unit: AbsorbedDoseOfIonizingRadiation.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new AbsorbedDoseOfIonizingRadiation(value: 1, unit: AbsorbedDoseOfIonizingRadiation.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new AbsorbedDoseOfIonizingRadiation(value: 1, unit: AbsorbedDoseOfIonizingRadiation.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new AbsorbedDoseOfIonizingRadiation(value: 1, unit: AbsorbedDoseOfIonizingRadiation.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<AbsorbedDoseOfIonizingRadiationUnit> quantity = new AbsorbedDoseOfIonizingRadiation(value: 1, unit: AbsorbedDoseOfIonizingRadiation.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new AbsorbedDoseOfIonizingRadiation(value: 1, unit: AbsorbedDoseOfIonizingRadiation.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -362,7 +419,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 пГр", AbsorbedDoseOfIonizingRadiationUnit.Picogray, 4.2)]
         [InlineData("ru-RU", "4,2 рад", AbsorbedDoseOfIonizingRadiationUnit.Rad, 4.2)]
         [InlineData("ru-RU", "4,2 ТГр", AbsorbedDoseOfIonizingRadiationUnit.Teragray, 4.2)]
-        public void Parse(string culture, string quantityString, AbsorbedDoseOfIonizingRadiationUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, AbsorbedDoseOfIonizingRadiationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = AbsorbedDoseOfIonizingRadiation.Parse(quantityString);
@@ -405,7 +462,7 @@ public void Parse(string culture, string quantityString, AbsorbedDoseOfIonizingR
         [InlineData("ru-RU", "4,2 пГр", AbsorbedDoseOfIonizingRadiationUnit.Picogray, 4.2)]
         [InlineData("ru-RU", "4,2 рад", AbsorbedDoseOfIonizingRadiationUnit.Rad, 4.2)]
         [InlineData("ru-RU", "4,2 ТГр", AbsorbedDoseOfIonizingRadiationUnit.Teragray, 4.2)]
-        public void TryParse(string culture, string quantityString, AbsorbedDoseOfIonizingRadiationUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, AbsorbedDoseOfIonizingRadiationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(AbsorbedDoseOfIonizingRadiation.TryParse(quantityString, out AbsorbedDoseOfIonizingRadiation parsed));
@@ -767,6 +824,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(AbsorbedDoseOfIo
                 var quantity = AbsorbedDoseOfIonizingRadiation.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -790,48 +848,50 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(AbsorbedDoseOfIoniz
                 IQuantity<AbsorbedDoseOfIonizingRadiationUnit> quantityToConvert = quantity;
                 IQuantity<AbsorbedDoseOfIonizingRadiationUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            AbsorbedDoseOfIonizingRadiation gray = AbsorbedDoseOfIonizingRadiation.FromGrays(1);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromCentigrays(gray.Centigrays).Grays, CentigraysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromDecigrays(gray.Decigrays).Grays, DecigraysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromFemtograys(gray.Femtograys).Grays, FemtograysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromGigagrays(gray.Gigagrays).Grays, GigagraysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromGrays(gray.Grays).Grays, GraysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromKilograys(gray.Kilograys).Grays, KilograysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromKilorads(gray.Kilorads).Grays, KiloradsTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromMegagrays(gray.Megagrays).Grays, MegagraysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromMegarads(gray.Megarads).Grays, MegaradsTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromMicrograys(gray.Micrograys).Grays, MicrograysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromMilligrays(gray.Milligrays).Grays, MilligraysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromMillirads(gray.Millirads).Grays, MilliradsTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromNanograys(gray.Nanograys).Grays, NanograysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromPetagrays(gray.Petagrays).Grays, PetagraysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromPicograys(gray.Picograys).Grays, PicograysTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromRads(gray.Rads).Grays, RadsTolerance);
-            AssertEx.EqualTolerance(1, AbsorbedDoseOfIonizingRadiation.FromTeragrays(gray.Teragrays).Grays, TeragraysTolerance);
+            AbsorbedDoseOfIonizingRadiation gray = AbsorbedDoseOfIonizingRadiation.FromGrays(3);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromCentigrays(gray.Centigrays).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromDecigrays(gray.Decigrays).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromFemtograys(gray.Femtograys).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromGigagrays(gray.Gigagrays).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromGrays(gray.Grays).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromKilograys(gray.Kilograys).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromKilorads(gray.Kilorads).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromMegagrays(gray.Megagrays).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromMegarads(gray.Megarads).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromMicrograys(gray.Micrograys).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromMilligrays(gray.Milligrays).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromMillirads(gray.Millirads).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromNanograys(gray.Nanograys).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromPetagrays(gray.Petagrays).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromPicograys(gray.Picograys).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromRads(gray.Rads).Grays);
+            Assert.Equal(3, AbsorbedDoseOfIonizingRadiation.FromTeragrays(gray.Teragrays).Grays);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             AbsorbedDoseOfIonizingRadiation v = AbsorbedDoseOfIonizingRadiation.FromGrays(1);
-            AssertEx.EqualTolerance(-1, -v.Grays, GraysTolerance);
-            AssertEx.EqualTolerance(2, (AbsorbedDoseOfIonizingRadiation.FromGrays(3)-v).Grays, GraysTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Grays, GraysTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Grays, GraysTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Grays, GraysTolerance);
-            AssertEx.EqualTolerance(2, (AbsorbedDoseOfIonizingRadiation.FromGrays(10)/5).Grays, GraysTolerance);
-            AssertEx.EqualTolerance(2, AbsorbedDoseOfIonizingRadiation.FromGrays(10)/AbsorbedDoseOfIonizingRadiation.FromGrays(5), GraysTolerance);
+            Assert.Equal(-1, -v.Grays);
+            Assert.Equal(2, (AbsorbedDoseOfIonizingRadiation.FromGrays(3) - v).Grays);
+            Assert.Equal(2, (v + v).Grays);
+            Assert.Equal(10, (v * 10).Grays);
+            Assert.Equal(10, (10 * v).Grays);
+            Assert.Equal(2, (AbsorbedDoseOfIonizingRadiation.FromGrays(10) / 5).Grays);
+            Assert.Equal(2, AbsorbedDoseOfIonizingRadiation.FromGrays(10) / AbsorbedDoseOfIonizingRadiation.FromGrays(5));
         }
 
         [Fact]
@@ -877,8 +937,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, AbsorbedDoseOfIonizingRadiationUnit.Gray, 1, AbsorbedDoseOfIonizingRadiationUnit.Gray, true)]  // Same value and unit.
         [InlineData(1, AbsorbedDoseOfIonizingRadiationUnit.Gray, 2, AbsorbedDoseOfIonizingRadiationUnit.Gray, false)] // Different value.
-        [InlineData(2, AbsorbedDoseOfIonizingRadiationUnit.Gray, 1, AbsorbedDoseOfIonizingRadiationUnit.Centigray, false)] // Different value and unit.
-        [InlineData(1, AbsorbedDoseOfIonizingRadiationUnit.Gray, 1, AbsorbedDoseOfIonizingRadiationUnit.Centigray, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, AbsorbedDoseOfIonizingRadiationUnit unitA, double valueB, AbsorbedDoseOfIonizingRadiationUnit unitB, bool expectEqual)
         {
             var a = new AbsorbedDoseOfIonizingRadiation(valueA, unitA);
@@ -938,8 +996,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = AbsorbedDoseOfIonizingRadiation.FromGrays(firstValue);
             var otherQuantity = AbsorbedDoseOfIonizingRadiation.FromGrays(secondValue);
             AbsorbedDoseOfIonizingRadiation maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, AbsorbedDoseOfIonizingRadiation.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -958,7 +1016,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<AbsorbedDoseOfIonizingRadiationUnit>();
+            var units = EnumHelper.GetValues<AbsorbedDoseOfIonizingRadiationUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -971,6 +1029,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(AbsorbedDoseOfIonizingRadiation.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(AbsorbedDoseOfIonizingRadiation.Info.Units, AbsorbedDoseOfIonizingRadiation.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, AbsorbedDoseOfIonizingRadiation.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1019,26 +1089,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 TGy", new AbsorbedDoseOfIonizingRadiation(1, AbsorbedDoseOfIonizingRadiationUnit.Teragray).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Gy", new AbsorbedDoseOfIonizingRadiation(0.123456, AbsorbedDoseOfIonizingRadiationUnit.Gray).ToString("s1"));
-            Assert.Equal("0.12 Gy", new AbsorbedDoseOfIonizingRadiation(0.123456, AbsorbedDoseOfIonizingRadiationUnit.Gray).ToString("s2"));
-            Assert.Equal("0.123 Gy", new AbsorbedDoseOfIonizingRadiation(0.123456, AbsorbedDoseOfIonizingRadiationUnit.Gray).ToString("s3"));
-            Assert.Equal("0.1235 Gy", new AbsorbedDoseOfIonizingRadiation(0.123456, AbsorbedDoseOfIonizingRadiationUnit.Gray).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Gy", new AbsorbedDoseOfIonizingRadiation(0.123456, AbsorbedDoseOfIonizingRadiationUnit.Gray).ToString("s1", culture));
-            Assert.Equal("0.12 Gy", new AbsorbedDoseOfIonizingRadiation(0.123456, AbsorbedDoseOfIonizingRadiationUnit.Gray).ToString("s2", culture));
-            Assert.Equal("0.123 Gy", new AbsorbedDoseOfIonizingRadiation(0.123456, AbsorbedDoseOfIonizingRadiationUnit.Gray).ToString("s3", culture));
-            Assert.Equal("0.1235 Gy", new AbsorbedDoseOfIonizingRadiation(0.123456, AbsorbedDoseOfIonizingRadiationUnit.Gray).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1065,7 +1115,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = AbsorbedDoseOfIonizingRadiation.FromGrays(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(AbsorbedDoseOfIonizingRadiation), quantity.As(AbsorbedDoseOfIonizingRadiation.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs
index c9600ef2ed..937a601ac3 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AccelerationTestsBase.g.cs
@@ -177,6 +177,20 @@ public void Acceleration_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<AccelerationUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void AccelerationInfo_CreateWithCustomUnitInfos()
+        {
+            AccelerationUnit[] expectedUnits = [AccelerationUnit.MeterPerSecondSquared];
+
+            Acceleration.AccelerationInfo quantityInfo = Acceleration.AccelerationInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Acceleration", quantityInfo.Name);
+            Assert.Equal(Acceleration.Zero, quantityInfo.Zero);
+            Assert.Equal(Acceleration.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void MeterPerSecondSquaredToAccelerationUnits()
         {
@@ -287,26 +301,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Acceleration.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Acceleration convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Acceleration quantityToConvert = quantity;
+
+                Acceleration convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<AccelerationUnit> quantityToConvert = quantity;
+
+                IQuantity<AccelerationUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Acceleration(value: 1, unit: Acceleration.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Acceleration(value: 1, unit: Acceleration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<AccelerationUnit> quantity = new Acceleration(value: 1, unit: Acceleration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Acceleration(value: 1, unit: Acceleration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Acceleration(value: 1, unit: Acceleration.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Acceleration(value: 1, unit: Acceleration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<AccelerationUnit> quantity = new Acceleration(value: 1, unit: Acceleration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Acceleration(value: 1, unit: Acceleration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -338,7 +395,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 мg", AccelerationUnit.MillistandardGravity, 4.2)]
         [InlineData("ru-RU", "4,2 нм/с²", AccelerationUnit.NanometerPerSecondSquared, 4.2)]
         [InlineData("ru-RU", "4,2 g", AccelerationUnit.StandardGravity, 4.2)]
-        public void Parse(string culture, string quantityString, AccelerationUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, AccelerationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Acceleration.Parse(quantityString);
@@ -375,7 +432,7 @@ public void Parse(string culture, string quantityString, AccelerationUnit expect
         [InlineData("ru-RU", "4,2 мg", AccelerationUnit.MillistandardGravity, 4.2)]
         [InlineData("ru-RU", "4,2 нм/с²", AccelerationUnit.NanometerPerSecondSquared, 4.2)]
         [InlineData("ru-RU", "4,2 g", AccelerationUnit.StandardGravity, 4.2)]
-        public void TryParse(string culture, string quantityString, AccelerationUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, AccelerationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Acceleration.TryParse(quantityString, out Acceleration parsed));
@@ -695,6 +752,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(AccelerationUnit
                 var quantity = Acceleration.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -718,45 +776,47 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(AccelerationUnit un
                 IQuantity<AccelerationUnit> quantityToConvert = quantity;
                 IQuantity<AccelerationUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
-            AssertEx.EqualTolerance(1, Acceleration.FromCentimetersPerSecondSquared(meterpersecondsquared.CentimetersPerSecondSquared).MetersPerSecondSquared, CentimetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromDecimetersPerSecondSquared(meterpersecondsquared.DecimetersPerSecondSquared).MetersPerSecondSquared, DecimetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromFeetPerSecondSquared(meterpersecondsquared.FeetPerSecondSquared).MetersPerSecondSquared, FeetPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromInchesPerSecondSquared(meterpersecondsquared.InchesPerSecondSquared).MetersPerSecondSquared, InchesPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKilometersPerSecondSquared(meterpersecondsquared.KilometersPerSecondSquared).MetersPerSecondSquared, KilometersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerHour(meterpersecondsquared.KnotsPerHour).MetersPerSecondSquared, KnotsPerHourTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerMinute(meterpersecondsquared.KnotsPerMinute).MetersPerSecondSquared, KnotsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerSecond(meterpersecondsquared.KnotsPerSecond).MetersPerSecondSquared, KnotsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMetersPerSecondSquared(meterpersecondsquared.MetersPerSecondSquared).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMicrometersPerSecondSquared(meterpersecondsquared.MicrometersPerSecondSquared).MetersPerSecondSquared, MicrometersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMillimetersPerSecondSquared(meterpersecondsquared.MillimetersPerSecondSquared).MetersPerSecondSquared, MillimetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMillistandardGravity(meterpersecondsquared.MillistandardGravity).MetersPerSecondSquared, MillistandardGravityTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromNanometersPerSecondSquared(meterpersecondsquared.NanometersPerSecondSquared).MetersPerSecondSquared, NanometersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromStandardGravity(meterpersecondsquared.StandardGravity).MetersPerSecondSquared, StandardGravityTolerance);
+            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(3);
+            Assert.Equal(3, Acceleration.FromCentimetersPerSecondSquared(meterpersecondsquared.CentimetersPerSecondSquared).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromDecimetersPerSecondSquared(meterpersecondsquared.DecimetersPerSecondSquared).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromFeetPerSecondSquared(meterpersecondsquared.FeetPerSecondSquared).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromInchesPerSecondSquared(meterpersecondsquared.InchesPerSecondSquared).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromKilometersPerSecondSquared(meterpersecondsquared.KilometersPerSecondSquared).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromKnotsPerHour(meterpersecondsquared.KnotsPerHour).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromKnotsPerMinute(meterpersecondsquared.KnotsPerMinute).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromKnotsPerSecond(meterpersecondsquared.KnotsPerSecond).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromMetersPerSecondSquared(meterpersecondsquared.MetersPerSecondSquared).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromMicrometersPerSecondSquared(meterpersecondsquared.MicrometersPerSecondSquared).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromMillimetersPerSecondSquared(meterpersecondsquared.MillimetersPerSecondSquared).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromMillistandardGravity(meterpersecondsquared.MillistandardGravity).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromNanometersPerSecondSquared(meterpersecondsquared.NanometersPerSecondSquared).MetersPerSecondSquared);
+            Assert.Equal(3, Acceleration.FromStandardGravity(meterpersecondsquared.StandardGravity).MetersPerSecondSquared);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Acceleration v = Acceleration.FromMetersPerSecondSquared(1);
-            AssertEx.EqualTolerance(-1, -v.MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (Acceleration.FromMetersPerSecondSquared(3)-v).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (v + v).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(10, (v*10).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(10, (10*v).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (Acceleration.FromMetersPerSecondSquared(10)/5).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, Acceleration.FromMetersPerSecondSquared(10)/Acceleration.FromMetersPerSecondSquared(5), MetersPerSecondSquaredTolerance);
+            Assert.Equal(-1, -v.MetersPerSecondSquared);
+            Assert.Equal(2, (Acceleration.FromMetersPerSecondSquared(3) - v).MetersPerSecondSquared);
+            Assert.Equal(2, (v + v).MetersPerSecondSquared);
+            Assert.Equal(10, (v * 10).MetersPerSecondSquared);
+            Assert.Equal(10, (10 * v).MetersPerSecondSquared);
+            Assert.Equal(2, (Acceleration.FromMetersPerSecondSquared(10) / 5).MetersPerSecondSquared);
+            Assert.Equal(2, Acceleration.FromMetersPerSecondSquared(10) / Acceleration.FromMetersPerSecondSquared(5));
         }
 
         [Fact]
@@ -802,8 +862,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, AccelerationUnit.MeterPerSecondSquared, 1, AccelerationUnit.MeterPerSecondSquared, true)]  // Same value and unit.
         [InlineData(1, AccelerationUnit.MeterPerSecondSquared, 2, AccelerationUnit.MeterPerSecondSquared, false)] // Different value.
-        [InlineData(2, AccelerationUnit.MeterPerSecondSquared, 1, AccelerationUnit.CentimeterPerSecondSquared, false)] // Different value and unit.
-        [InlineData(1, AccelerationUnit.MeterPerSecondSquared, 1, AccelerationUnit.CentimeterPerSecondSquared, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, AccelerationUnit unitA, double valueB, AccelerationUnit unitB, bool expectEqual)
         {
             var a = new Acceleration(valueA, unitA);
@@ -863,8 +921,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Acceleration.FromMetersPerSecondSquared(firstValue);
             var otherQuantity = Acceleration.FromMetersPerSecondSquared(secondValue);
             Acceleration maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Acceleration.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -883,7 +941,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<AccelerationUnit>();
+            var units = EnumHelper.GetValues<AccelerationUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -896,6 +954,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Acceleration.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Acceleration.Info.Units, Acceleration.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Acceleration.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -938,26 +1008,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 g", new Acceleration(1, AccelerationUnit.StandardGravity).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m/s²", new Acceleration(0.123456, AccelerationUnit.MeterPerSecondSquared).ToString("s1"));
-            Assert.Equal("0.12 m/s²", new Acceleration(0.123456, AccelerationUnit.MeterPerSecondSquared).ToString("s2"));
-            Assert.Equal("0.123 m/s²", new Acceleration(0.123456, AccelerationUnit.MeterPerSecondSquared).ToString("s3"));
-            Assert.Equal("0.1235 m/s²", new Acceleration(0.123456, AccelerationUnit.MeterPerSecondSquared).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m/s²", new Acceleration(0.123456, AccelerationUnit.MeterPerSecondSquared).ToString("s1", culture));
-            Assert.Equal("0.12 m/s²", new Acceleration(0.123456, AccelerationUnit.MeterPerSecondSquared).ToString("s2", culture));
-            Assert.Equal("0.123 m/s²", new Acceleration(0.123456, AccelerationUnit.MeterPerSecondSquared).ToString("s3", culture));
-            Assert.Equal("0.1235 m/s²", new Acceleration(0.123456, AccelerationUnit.MeterPerSecondSquared).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -984,7 +1034,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Acceleration.FromMetersPerSecondSquared(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Acceleration), quantity.As(Acceleration.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs
index a18ed6b913..95b5f62a2b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AmountOfSubstanceTestsBase.g.cs
@@ -189,6 +189,20 @@ public void AmountOfSubstance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
             Assert.Equal(quantityInfo, ((IQuantity<AmountOfSubstanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void AmountOfSubstanceInfo_CreateWithCustomUnitInfos()
+        {
+            AmountOfSubstanceUnit[] expectedUnits = [AmountOfSubstanceUnit.Mole];
+
+            AmountOfSubstance.AmountOfSubstanceInfo quantityInfo = AmountOfSubstance.AmountOfSubstanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("AmountOfSubstance", quantityInfo.Name);
+            Assert.Equal(AmountOfSubstance.Zero, quantityInfo.Zero);
+            Assert.Equal(AmountOfSubstance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void MoleToAmountOfSubstanceUnits()
         {
@@ -305,26 +319,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = AmountOfSubstance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            AmountOfSubstance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                AmountOfSubstance quantityToConvert = quantity;
+
+                AmountOfSubstance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<AmountOfSubstanceUnit> quantityToConvert = quantity;
+
+                IQuantity<AmountOfSubstanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new AmountOfSubstance(value: 1, unit: AmountOfSubstance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new AmountOfSubstance(value: 1, unit: AmountOfSubstance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<AmountOfSubstanceUnit> quantity = new AmountOfSubstance(value: 1, unit: AmountOfSubstance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new AmountOfSubstance(value: 1, unit: AmountOfSubstance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new AmountOfSubstance(value: 1, unit: AmountOfSubstance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new AmountOfSubstance(value: 1, unit: AmountOfSubstance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<AmountOfSubstanceUnit> quantity = new AmountOfSubstance(value: 1, unit: AmountOfSubstance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new AmountOfSubstance(value: 1, unit: AmountOfSubstance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -345,7 +402,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 nlbmol", AmountOfSubstanceUnit.NanopoundMole, 4.2)]
         [InlineData("en-US", "4.2 pmol", AmountOfSubstanceUnit.Picomole, 4.2)]
         [InlineData("en-US", "4.2 lbmol", AmountOfSubstanceUnit.PoundMole, 4.2)]
-        public void Parse(string culture, string quantityString, AmountOfSubstanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, AmountOfSubstanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = AmountOfSubstance.Parse(quantityString);
@@ -371,7 +428,7 @@ public void Parse(string culture, string quantityString, AmountOfSubstanceUnit e
         [InlineData("en-US", "4.2 nlbmol", AmountOfSubstanceUnit.NanopoundMole, 4.2)]
         [InlineData("en-US", "4.2 pmol", AmountOfSubstanceUnit.Picomole, 4.2)]
         [InlineData("en-US", "4.2 lbmol", AmountOfSubstanceUnit.PoundMole, 4.2)]
-        public void TryParse(string culture, string quantityString, AmountOfSubstanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, AmountOfSubstanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(AmountOfSubstance.TryParse(quantityString, out AmountOfSubstance parsed));
@@ -648,6 +705,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(AmountOfSubstanc
                 var quantity = AmountOfSubstance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -671,48 +729,50 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(AmountOfSubstanceUn
                 IQuantity<AmountOfSubstanceUnit> quantityToConvert = quantity;
                 IQuantity<AmountOfSubstanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            AmountOfSubstance mole = AmountOfSubstance.FromMoles(1);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromCentimoles(mole.Centimoles).Moles, CentimolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromCentipoundMoles(mole.CentipoundMoles).Moles, CentipoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromDecimoles(mole.Decimoles).Moles, DecimolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromDecipoundMoles(mole.DecipoundMoles).Moles, DecipoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromFemtomoles(mole.Femtomoles).Moles, FemtomolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromKilomoles(mole.Kilomoles).Moles, KilomolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromKilopoundMoles(mole.KilopoundMoles).Moles, KilopoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMegamoles(mole.Megamoles).Moles, MegamolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMicromoles(mole.Micromoles).Moles, MicromolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMicropoundMoles(mole.MicropoundMoles).Moles, MicropoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMillimoles(mole.Millimoles).Moles, MillimolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMillipoundMoles(mole.MillipoundMoles).Moles, MillipoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromMoles(mole.Moles).Moles, MolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromNanomoles(mole.Nanomoles).Moles, NanomolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromNanopoundMoles(mole.NanopoundMoles).Moles, NanopoundMolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromPicomoles(mole.Picomoles).Moles, PicomolesTolerance);
-            AssertEx.EqualTolerance(1, AmountOfSubstance.FromPoundMoles(mole.PoundMoles).Moles, PoundMolesTolerance);
+            AmountOfSubstance mole = AmountOfSubstance.FromMoles(3);
+            Assert.Equal(3, AmountOfSubstance.FromCentimoles(mole.Centimoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromCentipoundMoles(mole.CentipoundMoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromDecimoles(mole.Decimoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromDecipoundMoles(mole.DecipoundMoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromFemtomoles(mole.Femtomoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromKilomoles(mole.Kilomoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromKilopoundMoles(mole.KilopoundMoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromMegamoles(mole.Megamoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromMicromoles(mole.Micromoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromMicropoundMoles(mole.MicropoundMoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromMillimoles(mole.Millimoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromMillipoundMoles(mole.MillipoundMoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromMoles(mole.Moles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromNanomoles(mole.Nanomoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromNanopoundMoles(mole.NanopoundMoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromPicomoles(mole.Picomoles).Moles);
+            Assert.Equal(3, AmountOfSubstance.FromPoundMoles(mole.PoundMoles).Moles);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             AmountOfSubstance v = AmountOfSubstance.FromMoles(1);
-            AssertEx.EqualTolerance(-1, -v.Moles, MolesTolerance);
-            AssertEx.EqualTolerance(2, (AmountOfSubstance.FromMoles(3)-v).Moles, MolesTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Moles, MolesTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Moles, MolesTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Moles, MolesTolerance);
-            AssertEx.EqualTolerance(2, (AmountOfSubstance.FromMoles(10)/5).Moles, MolesTolerance);
-            AssertEx.EqualTolerance(2, AmountOfSubstance.FromMoles(10)/AmountOfSubstance.FromMoles(5), MolesTolerance);
+            Assert.Equal(-1, -v.Moles);
+            Assert.Equal(2, (AmountOfSubstance.FromMoles(3) - v).Moles);
+            Assert.Equal(2, (v + v).Moles);
+            Assert.Equal(10, (v * 10).Moles);
+            Assert.Equal(10, (10 * v).Moles);
+            Assert.Equal(2, (AmountOfSubstance.FromMoles(10) / 5).Moles);
+            Assert.Equal(2, AmountOfSubstance.FromMoles(10) / AmountOfSubstance.FromMoles(5));
         }
 
         [Fact]
@@ -758,8 +818,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, AmountOfSubstanceUnit.Mole, 1, AmountOfSubstanceUnit.Mole, true)]  // Same value and unit.
         [InlineData(1, AmountOfSubstanceUnit.Mole, 2, AmountOfSubstanceUnit.Mole, false)] // Different value.
-        [InlineData(2, AmountOfSubstanceUnit.Mole, 1, AmountOfSubstanceUnit.Centimole, false)] // Different value and unit.
-        [InlineData(1, AmountOfSubstanceUnit.Mole, 1, AmountOfSubstanceUnit.Centimole, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, AmountOfSubstanceUnit unitA, double valueB, AmountOfSubstanceUnit unitB, bool expectEqual)
         {
             var a = new AmountOfSubstance(valueA, unitA);
@@ -819,8 +877,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = AmountOfSubstance.FromMoles(firstValue);
             var otherQuantity = AmountOfSubstance.FromMoles(secondValue);
             AmountOfSubstance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, AmountOfSubstance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -839,7 +897,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<AmountOfSubstanceUnit>();
+            var units = EnumHelper.GetValues<AmountOfSubstanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -852,6 +910,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(AmountOfSubstance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(AmountOfSubstance.Info.Units, AmountOfSubstance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, AmountOfSubstance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -900,26 +970,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 lbmol", new AmountOfSubstance(1, AmountOfSubstanceUnit.PoundMole).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 mol", new AmountOfSubstance(0.123456, AmountOfSubstanceUnit.Mole).ToString("s1"));
-            Assert.Equal("0.12 mol", new AmountOfSubstance(0.123456, AmountOfSubstanceUnit.Mole).ToString("s2"));
-            Assert.Equal("0.123 mol", new AmountOfSubstance(0.123456, AmountOfSubstanceUnit.Mole).ToString("s3"));
-            Assert.Equal("0.1235 mol", new AmountOfSubstance(0.123456, AmountOfSubstanceUnit.Mole).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 mol", new AmountOfSubstance(0.123456, AmountOfSubstanceUnit.Mole).ToString("s1", culture));
-            Assert.Equal("0.12 mol", new AmountOfSubstance(0.123456, AmountOfSubstanceUnit.Mole).ToString("s2", culture));
-            Assert.Equal("0.123 mol", new AmountOfSubstance(0.123456, AmountOfSubstanceUnit.Mole).ToString("s3", culture));
-            Assert.Equal("0.1235 mol", new AmountOfSubstance(0.123456, AmountOfSubstanceUnit.Mole).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -946,7 +996,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = AmountOfSubstance.FromMoles(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(AmountOfSubstance), quantity.As(AmountOfSubstance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AmplitudeRatioTestsBase.g.cs
index f59245efa9..51aef3c030 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AmplitudeRatioTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AmplitudeRatioTestsBase.g.cs
@@ -116,6 +116,20 @@ public void AmplitudeRatio_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<AmplitudeRatioUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void AmplitudeRatioInfo_CreateWithCustomUnitInfos()
+        {
+            AmplitudeRatioUnit[] expectedUnits = [AmplitudeRatioUnit.DecibelVolt];
+
+            AmplitudeRatio.AmplitudeRatioInfo quantityInfo = AmplitudeRatio.AmplitudeRatioInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("AmplitudeRatio", quantityInfo.Name);
+            Assert.Equal(AmplitudeRatio.Zero, quantityInfo.Zero);
+            Assert.Equal(AmplitudeRatio.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void DecibelVoltToAmplitudeRatioUnits()
         {
@@ -186,12 +200,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new AmplitudeRatio(value: 1, unit: AmplitudeRatioUnit.DecibelVolt);
+            Assert.Multiple(() =>
+            {
+                var quantity = new AmplitudeRatio(value: 1, unit: AmplitudeRatioUnit.DecibelVolt);
+
+                AmplitudeRatio convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(AmplitudeRatioUnit.DecibelVolt, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<AmplitudeRatioUnit> quantity = new AmplitudeRatio(value: 1, unit: AmplitudeRatioUnit.DecibelVolt);
+
+                IQuantity<AmplitudeRatioUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(AmplitudeRatioUnit.DecibelVolt, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new AmplitudeRatio(value: 1, unit: AmplitudeRatioUnit.DecibelVolt);
 
-            AmplitudeRatio convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(AmplitudeRatioUnit.DecibelVolt, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(AmplitudeRatioUnit.DecibelVolt, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -218,7 +251,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [InlineData("en-US", "4.2 dBmV", AmplitudeRatioUnit.DecibelMillivolt, 4.2)]
         [InlineData("en-US", "4.2 dBu", AmplitudeRatioUnit.DecibelUnloaded, 4.2)]
         [InlineData("en-US", "4.2 dBV", AmplitudeRatioUnit.DecibelVolt, 4.2)]
-        public void Parse(string culture, string quantityString, AmplitudeRatioUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, AmplitudeRatioUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = AmplitudeRatio.Parse(quantityString);
@@ -231,7 +264,7 @@ public void Parse(string culture, string quantityString, AmplitudeRatioUnit expe
         [InlineData("en-US", "4.2 dBmV", AmplitudeRatioUnit.DecibelMillivolt, 4.2)]
         [InlineData("en-US", "4.2 dBu", AmplitudeRatioUnit.DecibelUnloaded, 4.2)]
         [InlineData("en-US", "4.2 dBV", AmplitudeRatioUnit.DecibelVolt, 4.2)]
-        public void TryParse(string culture, string quantityString, AmplitudeRatioUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, AmplitudeRatioUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(AmplitudeRatio.TryParse(quantityString, out AmplitudeRatio parsed));
@@ -391,6 +424,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(AmplitudeRatioUn
                 var quantity = AmplitudeRatio.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -414,35 +448,37 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(AmplitudeRatioUnit
                 IQuantity<AmplitudeRatioUnit> quantityToConvert = quantity;
                 IQuantity<AmplitudeRatioUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
-            AssertEx.EqualTolerance(1, AmplitudeRatio.FromDecibelMicrovolts(decibelvolt.DecibelMicrovolts).DecibelVolts, DecibelMicrovoltsTolerance);
-            AssertEx.EqualTolerance(1, AmplitudeRatio.FromDecibelMillivolts(decibelvolt.DecibelMillivolts).DecibelVolts, DecibelMillivoltsTolerance);
-            AssertEx.EqualTolerance(1, AmplitudeRatio.FromDecibelsUnloaded(decibelvolt.DecibelsUnloaded).DecibelVolts, DecibelsUnloadedTolerance);
-            AssertEx.EqualTolerance(1, AmplitudeRatio.FromDecibelVolts(decibelvolt.DecibelVolts).DecibelVolts, DecibelVoltsTolerance);
+            AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(3);
+            Assert.Equal(3, AmplitudeRatio.FromDecibelMicrovolts(decibelvolt.DecibelMicrovolts).DecibelVolts);
+            Assert.Equal(3, AmplitudeRatio.FromDecibelMillivolts(decibelvolt.DecibelMillivolts).DecibelVolts);
+            Assert.Equal(3, AmplitudeRatio.FromDecibelsUnloaded(decibelvolt.DecibelsUnloaded).DecibelVolts);
+            Assert.Equal(3, AmplitudeRatio.FromDecibelVolts(decibelvolt.DecibelVolts).DecibelVolts);
         }
 
         [Fact]
         public void LogarithmicArithmeticOperators()
         {
             AmplitudeRatio v = AmplitudeRatio.FromDecibelVolts(40);
-            AssertEx.EqualTolerance(-40, -v.DecibelVolts, DecibelVoltsTolerance);
+            Assert.Equal(-40, -v.DecibelVolts);
             AssertLogarithmicAddition();
             AssertLogarithmicSubtraction();
-            AssertEx.EqualTolerance(50, (v*10).DecibelVolts, DecibelVoltsTolerance);
-            AssertEx.EqualTolerance(50, (10*v).DecibelVolts, DecibelVoltsTolerance);
-            AssertEx.EqualTolerance(35, (v/5).DecibelVolts, DecibelVoltsTolerance);
-            AssertEx.EqualTolerance(35, v/AmplitudeRatio.FromDecibelVolts(5), DecibelVoltsTolerance);
+            Assert.Equal(50, (v * 10).DecibelVolts);
+            Assert.Equal(50, (10 * v).DecibelVolts);
+            Assert.Equal(35, (v / 5).DecibelVolts);
+            Assert.Equal(35, v / AmplitudeRatio.FromDecibelVolts(5));
         }
 
         protected abstract void AssertLogarithmicAddition();
@@ -492,8 +528,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, AmplitudeRatioUnit.DecibelVolt, 1, AmplitudeRatioUnit.DecibelVolt, true)]  // Same value and unit.
         [InlineData(1, AmplitudeRatioUnit.DecibelVolt, 2, AmplitudeRatioUnit.DecibelVolt, false)] // Different value.
-        [InlineData(2, AmplitudeRatioUnit.DecibelVolt, 1, AmplitudeRatioUnit.DecibelMicrovolt, false)] // Different value and unit.
-        [InlineData(1, AmplitudeRatioUnit.DecibelVolt, 1, AmplitudeRatioUnit.DecibelMicrovolt, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, AmplitudeRatioUnit unitA, double valueB, AmplitudeRatioUnit unitB, bool expectEqual)
         {
             var a = new AmplitudeRatio(valueA, unitA);
@@ -553,8 +587,8 @@ public void Equals_Logarithmic_WithTolerance(double firstValue, double secondVal
             var quantity = AmplitudeRatio.FromDecibelVolts(firstValue);
             var otherQuantity = AmplitudeRatio.FromDecibelVolts(secondValue);
             AmplitudeRatio maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, AmplitudeRatio.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, largerTolerance));
@@ -575,7 +609,7 @@ public void Equals_Logarithmic_WithNegativeTolerance_DoesNotThrowArgumentOutOfRa
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<AmplitudeRatioUnit>();
+            var units = EnumHelper.GetValues<AmplitudeRatioUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -588,6 +622,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(AmplitudeRatio.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(AmplitudeRatio.Info.Units, AmplitudeRatio.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, AmplitudeRatio.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -610,26 +656,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 dBV", new AmplitudeRatio(1, AmplitudeRatioUnit.DecibelVolt).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 dBV", new AmplitudeRatio(0.123456, AmplitudeRatioUnit.DecibelVolt).ToString("s1"));
-            Assert.Equal("0.12 dBV", new AmplitudeRatio(0.123456, AmplitudeRatioUnit.DecibelVolt).ToString("s2"));
-            Assert.Equal("0.123 dBV", new AmplitudeRatio(0.123456, AmplitudeRatioUnit.DecibelVolt).ToString("s3"));
-            Assert.Equal("0.1235 dBV", new AmplitudeRatio(0.123456, AmplitudeRatioUnit.DecibelVolt).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 dBV", new AmplitudeRatio(0.123456, AmplitudeRatioUnit.DecibelVolt).ToString("s1", culture));
-            Assert.Equal("0.12 dBV", new AmplitudeRatio(0.123456, AmplitudeRatioUnit.DecibelVolt).ToString("s2", culture));
-            Assert.Equal("0.123 dBV", new AmplitudeRatio(0.123456, AmplitudeRatioUnit.DecibelVolt).ToString("s3", culture));
-            Assert.Equal("0.1235 dBV", new AmplitudeRatio(0.123456, AmplitudeRatioUnit.DecibelVolt).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -656,7 +682,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = AmplitudeRatio.FromDecibelVolts(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(AmplitudeRatio), quantity.As(AmplitudeRatio.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs
index b9fc738a7f..573d3ffe37 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AngleTestsBase.g.cs
@@ -160,6 +160,20 @@ public void Angle_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<AngleUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void AngleInfo_CreateWithCustomUnitInfos()
+        {
+            AngleUnit[] expectedUnits = [AngleUnit.Radian];
+
+            Angle.AngleInfo quantityInfo = Angle.AngleInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Angle", quantityInfo.Name);
+            Assert.Equal(Angle.Zero, quantityInfo.Zero);
+            Assert.Equal(Angle.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void RadianToAngleUnits()
         {
@@ -252,12 +266,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new Angle(value: 1, unit: AngleUnit.Radian);
+            Assert.Multiple(() =>
+            {
+                var quantity = new Angle(value: 1, unit: AngleUnit.Radian);
+
+                Angle convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(AngleUnit.Radian, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<AngleUnit> quantity = new Angle(value: 1, unit: AngleUnit.Radian);
+
+                IQuantity<AngleUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(AngleUnit.Radian, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new Angle(value: 1, unit: AngleUnit.Radian);
 
-            Angle convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(AngleUnit.Radian, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(AngleUnit.Radian, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -317,7 +350,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [InlineData("ru-RU", "4,2 нрад", AngleUnit.Nanoradian, 4.2)]
         [InlineData("ru-RU", "4,2 рад", AngleUnit.Radian, 4.2)]
         [InlineData("ru-RU", "4,2 r", AngleUnit.Revolution, 4.2)]
-        public void Parse(string culture, string quantityString, AngleUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, AngleUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Angle.Parse(quantityString);
@@ -363,7 +396,7 @@ public void Parse(string culture, string quantityString, AngleUnit expectedUnit,
         [InlineData("ru-RU", "4,2 нрад", AngleUnit.Nanoradian, 4.2)]
         [InlineData("ru-RU", "4,2 рад", AngleUnit.Radian, 4.2)]
         [InlineData("ru-RU", "4,2 r", AngleUnit.Revolution, 4.2)]
-        public void TryParse(string culture, string quantityString, AngleUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, AngleUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Angle.TryParse(quantityString, out Angle parsed));
@@ -762,6 +795,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(AngleUnit unit)
                 var quantity = Angle.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -785,46 +819,48 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(AngleUnit unit)
                 IQuantity<AngleUnit> quantityToConvert = quantity;
                 IQuantity<AngleUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Angle radian = Angle.FromRadians(1);
-            AssertEx.EqualTolerance(1, Angle.FromArcminutes(radian.Arcminutes).Radians, ArcminutesTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromArcseconds(radian.Arcseconds).Radians, ArcsecondsTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromCentiradians(radian.Centiradians).Radians, CentiradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromDeciradians(radian.Deciradians).Radians, DeciradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromDegrees(radian.Degrees).Radians, DegreesTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromGradians(radian.Gradians).Radians, GradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromMicrodegrees(radian.Microdegrees).Radians, MicrodegreesTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromMicroradians(radian.Microradians).Radians, MicroradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromMillidegrees(radian.Millidegrees).Radians, MillidegreesTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromMilliradians(radian.Milliradians).Radians, MilliradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromNanodegrees(radian.Nanodegrees).Radians, NanodegreesTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromNanoradians(radian.Nanoradians).Radians, NanoradiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromNatoMils(radian.NatoMils).Radians, NatoMilsTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromRadians(radian.Radians).Radians, RadiansTolerance);
-            AssertEx.EqualTolerance(1, Angle.FromRevolutions(radian.Revolutions).Radians, RevolutionsTolerance);
+            Angle radian = Angle.FromRadians(3);
+            Assert.Equal(3, Angle.FromArcminutes(radian.Arcminutes).Radians);
+            Assert.Equal(3, Angle.FromArcseconds(radian.Arcseconds).Radians);
+            Assert.Equal(3, Angle.FromCentiradians(radian.Centiradians).Radians);
+            Assert.Equal(3, Angle.FromDeciradians(radian.Deciradians).Radians);
+            Assert.Equal(3, Angle.FromDegrees(radian.Degrees).Radians);
+            Assert.Equal(3, Angle.FromGradians(radian.Gradians).Radians);
+            Assert.Equal(3, Angle.FromMicrodegrees(radian.Microdegrees).Radians);
+            Assert.Equal(3, Angle.FromMicroradians(radian.Microradians).Radians);
+            Assert.Equal(3, Angle.FromMillidegrees(radian.Millidegrees).Radians);
+            Assert.Equal(3, Angle.FromMilliradians(radian.Milliradians).Radians);
+            Assert.Equal(3, Angle.FromNanodegrees(radian.Nanodegrees).Radians);
+            Assert.Equal(3, Angle.FromNanoradians(radian.Nanoradians).Radians);
+            Assert.Equal(3, Angle.FromNatoMils(radian.NatoMils).Radians);
+            Assert.Equal(3, Angle.FromRadians(radian.Radians).Radians);
+            Assert.Equal(3, Angle.FromRevolutions(radian.Revolutions).Radians);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Angle v = Angle.FromRadians(1);
-            AssertEx.EqualTolerance(-1, -v.Radians, RadiansTolerance);
-            AssertEx.EqualTolerance(2, (Angle.FromRadians(3)-v).Radians, RadiansTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Radians, RadiansTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Radians, RadiansTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Radians, RadiansTolerance);
-            AssertEx.EqualTolerance(2, (Angle.FromRadians(10)/5).Radians, RadiansTolerance);
-            AssertEx.EqualTolerance(2, Angle.FromRadians(10)/Angle.FromRadians(5), RadiansTolerance);
+            Assert.Equal(-1, -v.Radians);
+            Assert.Equal(2, (Angle.FromRadians(3) - v).Radians);
+            Assert.Equal(2, (v + v).Radians);
+            Assert.Equal(10, (v * 10).Radians);
+            Assert.Equal(10, (10 * v).Radians);
+            Assert.Equal(2, (Angle.FromRadians(10) / 5).Radians);
+            Assert.Equal(2, Angle.FromRadians(10) / Angle.FromRadians(5));
         }
 
         [Fact]
@@ -870,8 +906,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, AngleUnit.Radian, 1, AngleUnit.Radian, true)]  // Same value and unit.
         [InlineData(1, AngleUnit.Radian, 2, AngleUnit.Radian, false)] // Different value.
-        [InlineData(2, AngleUnit.Radian, 1, AngleUnit.Arcminute, false)] // Different value and unit.
-        [InlineData(1, AngleUnit.Radian, 1, AngleUnit.Arcminute, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, AngleUnit unitA, double valueB, AngleUnit unitB, bool expectEqual)
         {
             var a = new Angle(valueA, unitA);
@@ -931,8 +965,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Angle.FromRadians(firstValue);
             var otherQuantity = Angle.FromRadians(secondValue);
             Angle maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Angle.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -951,7 +985,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<AngleUnit>();
+            var units = EnumHelper.GetValues<AngleUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -964,6 +998,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Angle.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Angle.Info.Units, Angle.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Angle.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1008,26 +1054,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 r", new Angle(1, AngleUnit.Revolution).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 rad", new Angle(0.123456, AngleUnit.Radian).ToString("s1"));
-            Assert.Equal("0.12 rad", new Angle(0.123456, AngleUnit.Radian).ToString("s2"));
-            Assert.Equal("0.123 rad", new Angle(0.123456, AngleUnit.Radian).ToString("s3"));
-            Assert.Equal("0.1235 rad", new Angle(0.123456, AngleUnit.Radian).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 rad", new Angle(0.123456, AngleUnit.Radian).ToString("s1", culture));
-            Assert.Equal("0.12 rad", new Angle(0.123456, AngleUnit.Radian).ToString("s2", culture));
-            Assert.Equal("0.123 rad", new Angle(0.123456, AngleUnit.Radian).ToString("s3", culture));
-            Assert.Equal("0.1235 rad", new Angle(0.123456, AngleUnit.Radian).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1054,7 +1080,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Angle.FromRadians(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Angle), quantity.As(Angle.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs
index 9389bf8362..77464d7663 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaDensityTestsBase.g.cs
@@ -43,11 +43,15 @@ public abstract partial class AreaDensityTestsBase : QuantityTestsBase
         protected abstract double GramsPerSquareMeterInOneKilogramPerSquareMeter { get; }
         protected abstract double KilogramsPerSquareMeterInOneKilogramPerSquareMeter { get; }
         protected abstract double MilligramsPerSquareMeterInOneKilogramPerSquareMeter { get; }
+        protected abstract double PoundsPerSquareFootInOneKilogramPerSquareMeter { get; }
+        protected abstract double PoundsPerThousandSquareFeetInOneKilogramPerSquareMeter { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double GramsPerSquareMeterTolerance { get { return 1e-5; } }
         protected virtual double KilogramsPerSquareMeterTolerance { get { return 1e-5; } }
         protected virtual double MilligramsPerSquareMeterTolerance { get { return 1e-5; } }
+        protected virtual double PoundsPerSquareFootTolerance { get { return 1e-5; } }
+        protected virtual double PoundsPerThousandSquareFeetTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(AreaDensityUnit unit)
@@ -57,6 +61,8 @@ public abstract partial class AreaDensityTestsBase : QuantityTestsBase
                 AreaDensityUnit.GramPerSquareMeter => (GramsPerSquareMeterInOneKilogramPerSquareMeter, GramsPerSquareMeterTolerance),
                 AreaDensityUnit.KilogramPerSquareMeter => (KilogramsPerSquareMeterInOneKilogramPerSquareMeter, KilogramsPerSquareMeterTolerance),
                 AreaDensityUnit.MilligramPerSquareMeter => (MilligramsPerSquareMeterInOneKilogramPerSquareMeter, MilligramsPerSquareMeterTolerance),
+                AreaDensityUnit.PoundPerSquareFoot => (PoundsPerSquareFootInOneKilogramPerSquareMeter, PoundsPerSquareFootTolerance),
+                AreaDensityUnit.PoundPerThousandSquareFeet => (PoundsPerThousandSquareFeetInOneKilogramPerSquareMeter, PoundsPerThousandSquareFeetTolerance),
                 _ => throw new NotSupportedException()
             };
         }
@@ -66,6 +72,8 @@ public abstract partial class AreaDensityTestsBase : QuantityTestsBase
             new object[] { AreaDensityUnit.GramPerSquareMeter },
             new object[] { AreaDensityUnit.KilogramPerSquareMeter },
             new object[] { AreaDensityUnit.MilligramPerSquareMeter },
+            new object[] { AreaDensityUnit.PoundPerSquareFoot },
+            new object[] { AreaDensityUnit.PoundPerThousandSquareFeet },
         };
 
         [Fact]
@@ -133,6 +141,20 @@ public void AreaDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<AreaDensityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void AreaDensityInfo_CreateWithCustomUnitInfos()
+        {
+            AreaDensityUnit[] expectedUnits = [AreaDensityUnit.KilogramPerSquareMeter];
+
+            AreaDensity.AreaDensityInfo quantityInfo = AreaDensity.AreaDensityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("AreaDensity", quantityInfo.Name);
+            Assert.Equal(AreaDensity.Zero, quantityInfo.Zero);
+            Assert.Equal(AreaDensity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KilogramPerSquareMeterToAreaDensityUnits()
         {
@@ -140,6 +162,8 @@ public void KilogramPerSquareMeterToAreaDensityUnits()
             AssertEx.EqualTolerance(GramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.GramsPerSquareMeter, GramsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(KilogramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(MilligramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.MilligramsPerSquareMeter, MilligramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(PoundsPerSquareFootInOneKilogramPerSquareMeter, kilogrampersquaremeter.PoundsPerSquareFoot, PoundsPerSquareFootTolerance);
+            AssertEx.EqualTolerance(PoundsPerThousandSquareFeetInOneKilogramPerSquareMeter, kilogrampersquaremeter.PoundsPerThousandSquareFeet, PoundsPerThousandSquareFeetTolerance);
         }
 
         [Fact]
@@ -178,6 +202,8 @@ public void As()
             AssertEx.EqualTolerance(GramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.As(AreaDensityUnit.GramPerSquareMeter), GramsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(KilogramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.As(AreaDensityUnit.KilogramPerSquareMeter), KilogramsPerSquareMeterTolerance);
             AssertEx.EqualTolerance(MilligramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.As(AreaDensityUnit.MilligramPerSquareMeter), MilligramsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(PoundsPerSquareFootInOneKilogramPerSquareMeter, kilogrampersquaremeter.As(AreaDensityUnit.PoundPerSquareFoot), PoundsPerSquareFootTolerance);
+            AssertEx.EqualTolerance(PoundsPerThousandSquareFeetInOneKilogramPerSquareMeter, kilogrampersquaremeter.As(AreaDensityUnit.PoundPerThousandSquareFeet), PoundsPerThousandSquareFeetTolerance);
         }
 
         [Fact]
@@ -221,26 +247,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = AreaDensity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            AreaDensity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                AreaDensity quantityToConvert = quantity;
+
+                AreaDensity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<AreaDensityUnit> quantityToConvert = quantity;
+
+                IQuantity<AreaDensityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new AreaDensity(value: 1, unit: AreaDensity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new AreaDensity(value: 1, unit: AreaDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<AreaDensityUnit> quantity = new AreaDensity(value: 1, unit: AreaDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new AreaDensity(value: 1, unit: AreaDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new AreaDensity(value: 1, unit: AreaDensity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new AreaDensity(value: 1, unit: AreaDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<AreaDensityUnit> quantity = new AreaDensity(value: 1, unit: AreaDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new AreaDensity(value: 1, unit: AreaDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -248,7 +317,16 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 gsm", AreaDensityUnit.GramPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 kg/m²", AreaDensityUnit.KilogramPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 mg/m²", AreaDensityUnit.MilligramPerSquareMeter, 4.2)]
-        public void Parse(string culture, string quantityString, AreaDensityUnit expectedUnit, double expectedValue)
+        [InlineData("en-US", "4.2 lb/ft²", AreaDensityUnit.PoundPerSquareFoot, 4.2)]
+        [InlineData("en-US", "4.2 lbs/ft²", AreaDensityUnit.PoundPerSquareFoot, 4.2)]
+        [InlineData("en-US", "4.2 lb/SF", AreaDensityUnit.PoundPerSquareFoot, 4.2)]
+        [InlineData("en-US", "4.2 lbs/SF", AreaDensityUnit.PoundPerSquareFoot, 4.2)]
+        [InlineData("en-US", "4.2 lb/MSF", AreaDensityUnit.PoundPerThousandSquareFeet, 4.2)]
+        [InlineData("en-US", "4.2 lbs/MSF", AreaDensityUnit.PoundPerThousandSquareFeet, 4.2)]
+        [InlineData("en-US", "4.2 lb/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet, 4.2)]
+        [InlineData("en-US", "4.2 lbs/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet, 4.2)]
+        [InlineData("en-US", "4.2 lbm/MSF", AreaDensityUnit.PoundPerThousandSquareFeet, 4.2)]
+        public void Parse(string culture, string quantityString, AreaDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = AreaDensity.Parse(quantityString);
@@ -261,7 +339,16 @@ public void Parse(string culture, string quantityString, AreaDensityUnit expecte
         [InlineData("en-US", "4.2 gsm", AreaDensityUnit.GramPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 kg/m²", AreaDensityUnit.KilogramPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 mg/m²", AreaDensityUnit.MilligramPerSquareMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, AreaDensityUnit expectedUnit, double expectedValue)
+        [InlineData("en-US", "4.2 lb/ft²", AreaDensityUnit.PoundPerSquareFoot, 4.2)]
+        [InlineData("en-US", "4.2 lbs/ft²", AreaDensityUnit.PoundPerSquareFoot, 4.2)]
+        [InlineData("en-US", "4.2 lb/SF", AreaDensityUnit.PoundPerSquareFoot, 4.2)]
+        [InlineData("en-US", "4.2 lbs/SF", AreaDensityUnit.PoundPerSquareFoot, 4.2)]
+        [InlineData("en-US", "4.2 lb/MSF", AreaDensityUnit.PoundPerThousandSquareFeet, 4.2)]
+        [InlineData("en-US", "4.2 lbs/MSF", AreaDensityUnit.PoundPerThousandSquareFeet, 4.2)]
+        [InlineData("en-US", "4.2 lb/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet, 4.2)]
+        [InlineData("en-US", "4.2 lbs/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet, 4.2)]
+        [InlineData("en-US", "4.2 lbm/MSF", AreaDensityUnit.PoundPerThousandSquareFeet, 4.2)]
+        public void TryParse(string culture, string quantityString, AreaDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(AreaDensity.TryParse(quantityString, out AreaDensity parsed));
@@ -274,6 +361,15 @@ public void TryParse(string culture, string quantityString, AreaDensityUnit expe
         [InlineData("gsm", AreaDensityUnit.GramPerSquareMeter)]
         [InlineData("kg/m²", AreaDensityUnit.KilogramPerSquareMeter)]
         [InlineData("mg/m²", AreaDensityUnit.MilligramPerSquareMeter)]
+        [InlineData("lb/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lbs/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lb/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lbs/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lb/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbs/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lb/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbs/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbm/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
         public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, AreaDensityUnit expectedUnit)
         {
             // Fallback culture "en-US" is always localized
@@ -287,6 +383,15 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, AreaDensi
         [InlineData("gsm", AreaDensityUnit.GramPerSquareMeter)]
         [InlineData("kg/m²", AreaDensityUnit.KilogramPerSquareMeter)]
         [InlineData("mg/m²", AreaDensityUnit.MilligramPerSquareMeter)]
+        [InlineData("lb/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lbs/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lb/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lbs/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lb/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbs/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lb/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbs/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbm/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
         public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, AreaDensityUnit expectedUnit)
         {
             // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing.
@@ -300,6 +405,15 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "gsm", AreaDensityUnit.GramPerSquareMeter)]
         [InlineData("en-US", "kg/m²", AreaDensityUnit.KilogramPerSquareMeter)]
         [InlineData("en-US", "mg/m²", AreaDensityUnit.MilligramPerSquareMeter)]
+        [InlineData("en-US", "lb/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lbs/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lb/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lbs/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lb/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbs/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lb/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbs/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbm/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
         public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, AreaDensityUnit expectedUnit)
         {
             using var _ = new CultureScope(culture);
@@ -312,6 +426,15 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Ar
         [InlineData("en-US", "gsm", AreaDensityUnit.GramPerSquareMeter)]
         [InlineData("en-US", "kg/m²", AreaDensityUnit.KilogramPerSquareMeter)]
         [InlineData("en-US", "mg/m²", AreaDensityUnit.MilligramPerSquareMeter)]
+        [InlineData("en-US", "lb/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lbs/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lb/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lbs/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lb/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbs/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lb/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbs/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbm/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
         public void ParseUnit_WithCulture(string culture, string abbreviation, AreaDensityUnit expectedUnit)
         {
             AreaDensityUnit parsedUnit = AreaDensity.ParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture));
@@ -323,6 +446,15 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, AreaDensi
         [InlineData("gsm", AreaDensityUnit.GramPerSquareMeter)]
         [InlineData("kg/m²", AreaDensityUnit.KilogramPerSquareMeter)]
         [InlineData("mg/m²", AreaDensityUnit.MilligramPerSquareMeter)]
+        [InlineData("lb/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lbs/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lb/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lbs/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lb/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbs/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lb/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbs/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbm/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
         public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, AreaDensityUnit expectedUnit)
         {
             // Fallback culture "en-US" is always localized
@@ -336,6 +468,15 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, AreaDe
         [InlineData("gsm", AreaDensityUnit.GramPerSquareMeter)]
         [InlineData("kg/m²", AreaDensityUnit.KilogramPerSquareMeter)]
         [InlineData("mg/m²", AreaDensityUnit.MilligramPerSquareMeter)]
+        [InlineData("lb/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lbs/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lb/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lbs/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("lb/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbs/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lb/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbs/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("lbm/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
         public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, AreaDensityUnit expectedUnit)
         {
             // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing.
@@ -349,6 +490,15 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "gsm", AreaDensityUnit.GramPerSquareMeter)]
         [InlineData("en-US", "kg/m²", AreaDensityUnit.KilogramPerSquareMeter)]
         [InlineData("en-US", "mg/m²", AreaDensityUnit.MilligramPerSquareMeter)]
+        [InlineData("en-US", "lb/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lbs/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lb/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lbs/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lb/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbs/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lb/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbs/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbm/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
         public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, AreaDensityUnit expectedUnit)
         {
             using var _ = new CultureScope(culture);
@@ -361,6 +511,15 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "gsm", AreaDensityUnit.GramPerSquareMeter)]
         [InlineData("en-US", "kg/m²", AreaDensityUnit.KilogramPerSquareMeter)]
         [InlineData("en-US", "mg/m²", AreaDensityUnit.MilligramPerSquareMeter)]
+        [InlineData("en-US", "lb/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lbs/ft²", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lb/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lbs/SF", AreaDensityUnit.PoundPerSquareFoot)]
+        [InlineData("en-US", "lb/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbs/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lb/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbs/1000ft²", AreaDensityUnit.PoundPerThousandSquareFeet)]
+        [InlineData("en-US", "lbm/MSF", AreaDensityUnit.PoundPerThousandSquareFeet)]
         public void TryParseUnit_WithCulture(string culture, string abbreviation, AreaDensityUnit expectedUnit)
         {
             Assert.True(AreaDensity.TryParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture), out AreaDensityUnit parsedUnit));
@@ -371,6 +530,8 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, AreaDe
         [InlineData("en-US", AreaDensityUnit.GramPerSquareMeter, "g/m²")]
         [InlineData("en-US", AreaDensityUnit.KilogramPerSquareMeter, "kg/m²")]
         [InlineData("en-US", AreaDensityUnit.MilligramPerSquareMeter, "mg/m²")]
+        [InlineData("en-US", AreaDensityUnit.PoundPerSquareFoot, "lb/ft²")]
+        [InlineData("en-US", AreaDensityUnit.PoundPerThousandSquareFeet, "lb/MSF")]
         public void GetAbbreviationForCulture(string culture, AreaDensityUnit unit, string expectedAbbreviation)
         {
             var defaultAbbreviation = AreaDensity.GetAbbreviation(unit, CultureInfo.GetCultureInfo(culture));
@@ -420,6 +581,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(AreaDensityUnit
                 var quantity = AreaDensity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -443,34 +605,38 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(AreaDensityUnit uni
                 IQuantity<AreaDensityUnit> quantityToConvert = quantity;
                 IQuantity<AreaDensityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            AreaDensity kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, AreaDensity.FromGramsPerSquareMeter(kilogrampersquaremeter.GramsPerSquareMeter).KilogramsPerSquareMeter, GramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, AreaDensity.FromKilogramsPerSquareMeter(kilogrampersquaremeter.KilogramsPerSquareMeter).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, AreaDensity.FromMilligramsPerSquareMeter(kilogrampersquaremeter.MilligramsPerSquareMeter).KilogramsPerSquareMeter, MilligramsPerSquareMeterTolerance);
+            AreaDensity kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(3);
+            Assert.Equal(3, AreaDensity.FromGramsPerSquareMeter(kilogrampersquaremeter.GramsPerSquareMeter).KilogramsPerSquareMeter);
+            Assert.Equal(3, AreaDensity.FromKilogramsPerSquareMeter(kilogrampersquaremeter.KilogramsPerSquareMeter).KilogramsPerSquareMeter);
+            Assert.Equal(3, AreaDensity.FromMilligramsPerSquareMeter(kilogrampersquaremeter.MilligramsPerSquareMeter).KilogramsPerSquareMeter);
+            Assert.Equal(3, AreaDensity.FromPoundsPerSquareFoot(kilogrampersquaremeter.PoundsPerSquareFoot).KilogramsPerSquareMeter);
+            Assert.Equal(3, AreaDensity.FromPoundsPerThousandSquareFeet(kilogrampersquaremeter.PoundsPerThousandSquareFeet).KilogramsPerSquareMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             AreaDensity v = AreaDensity.FromKilogramsPerSquareMeter(1);
-            AssertEx.EqualTolerance(-1, -v.KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (AreaDensity.FromKilogramsPerSquareMeter(3)-v).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (AreaDensity.FromKilogramsPerSquareMeter(10)/5).KilogramsPerSquareMeter, KilogramsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, AreaDensity.FromKilogramsPerSquareMeter(10)/AreaDensity.FromKilogramsPerSquareMeter(5), KilogramsPerSquareMeterTolerance);
+            Assert.Equal(-1, -v.KilogramsPerSquareMeter);
+            Assert.Equal(2, (AreaDensity.FromKilogramsPerSquareMeter(3) - v).KilogramsPerSquareMeter);
+            Assert.Equal(2, (v + v).KilogramsPerSquareMeter);
+            Assert.Equal(10, (v * 10).KilogramsPerSquareMeter);
+            Assert.Equal(10, (10 * v).KilogramsPerSquareMeter);
+            Assert.Equal(2, (AreaDensity.FromKilogramsPerSquareMeter(10) / 5).KilogramsPerSquareMeter);
+            Assert.Equal(2, AreaDensity.FromKilogramsPerSquareMeter(10) / AreaDensity.FromKilogramsPerSquareMeter(5));
         }
 
         [Fact]
@@ -516,8 +682,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, AreaDensityUnit.KilogramPerSquareMeter, 1, AreaDensityUnit.KilogramPerSquareMeter, true)]  // Same value and unit.
         [InlineData(1, AreaDensityUnit.KilogramPerSquareMeter, 2, AreaDensityUnit.KilogramPerSquareMeter, false)] // Different value.
-        [InlineData(2, AreaDensityUnit.KilogramPerSquareMeter, 1, AreaDensityUnit.GramPerSquareMeter, false)] // Different value and unit.
-        [InlineData(1, AreaDensityUnit.KilogramPerSquareMeter, 1, AreaDensityUnit.GramPerSquareMeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, AreaDensityUnit unitA, double valueB, AreaDensityUnit unitB, bool expectEqual)
         {
             var a = new AreaDensity(valueA, unitA);
@@ -577,8 +741,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = AreaDensity.FromKilogramsPerSquareMeter(firstValue);
             var otherQuantity = AreaDensity.FromKilogramsPerSquareMeter(secondValue);
             AreaDensity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, AreaDensity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -597,7 +761,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<AreaDensityUnit>();
+            var units = EnumHelper.GetValues<AreaDensityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -610,6 +774,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(AreaDensity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(AreaDensity.Info.Units, AreaDensity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, AreaDensity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -617,6 +793,8 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
             Assert.Equal("1 g/m²", new AreaDensity(1, AreaDensityUnit.GramPerSquareMeter).ToString());
             Assert.Equal("1 kg/m²", new AreaDensity(1, AreaDensityUnit.KilogramPerSquareMeter).ToString());
             Assert.Equal("1 mg/m²", new AreaDensity(1, AreaDensityUnit.MilligramPerSquareMeter).ToString());
+            Assert.Equal("1 lb/ft²", new AreaDensity(1, AreaDensityUnit.PoundPerSquareFoot).ToString());
+            Assert.Equal("1 lb/MSF", new AreaDensity(1, AreaDensityUnit.PoundPerThousandSquareFeet).ToString());
         }
 
         [Fact]
@@ -628,26 +806,8 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 g/m²", new AreaDensity(1, AreaDensityUnit.GramPerSquareMeter).ToString(swedishCulture));
             Assert.Equal("1 kg/m²", new AreaDensity(1, AreaDensityUnit.KilogramPerSquareMeter).ToString(swedishCulture));
             Assert.Equal("1 mg/m²", new AreaDensity(1, AreaDensityUnit.MilligramPerSquareMeter).ToString(swedishCulture));
-        }
-
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 kg/m²", new AreaDensity(0.123456, AreaDensityUnit.KilogramPerSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 kg/m²", new AreaDensity(0.123456, AreaDensityUnit.KilogramPerSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 kg/m²", new AreaDensity(0.123456, AreaDensityUnit.KilogramPerSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 kg/m²", new AreaDensity(0.123456, AreaDensityUnit.KilogramPerSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 kg/m²", new AreaDensity(0.123456, AreaDensityUnit.KilogramPerSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 kg/m²", new AreaDensity(0.123456, AreaDensityUnit.KilogramPerSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 kg/m²", new AreaDensity(0.123456, AreaDensityUnit.KilogramPerSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 kg/m²", new AreaDensity(0.123456, AreaDensityUnit.KilogramPerSquareMeter).ToString("s4", culture));
+            Assert.Equal("1 lb/ft²", new AreaDensity(1, AreaDensityUnit.PoundPerSquareFoot).ToString(swedishCulture));
+            Assert.Equal("1 lb/MSF", new AreaDensity(1, AreaDensityUnit.PoundPerThousandSquareFeet).ToString(swedishCulture));
         }
 
         [Theory]
@@ -676,7 +836,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = AreaDensity.FromKilogramsPerSquareMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(AreaDensity), quantity.As(AreaDensity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs
index ba59189e55..d38e65b559 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaMomentOfInertiaTestsBase.g.cs
@@ -145,6 +145,20 @@ public void AreaMomentOfInertia_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
             Assert.Equal(quantityInfo, ((IQuantity<AreaMomentOfInertiaUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void AreaMomentOfInertiaInfo_CreateWithCustomUnitInfos()
+        {
+            AreaMomentOfInertiaUnit[] expectedUnits = [AreaMomentOfInertiaUnit.MeterToTheFourth];
+
+            AreaMomentOfInertia.AreaMomentOfInertiaInfo quantityInfo = AreaMomentOfInertia.AreaMomentOfInertiaInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("AreaMomentOfInertia", quantityInfo.Name);
+            Assert.Equal(AreaMomentOfInertia.Zero, quantityInfo.Zero);
+            Assert.Equal(AreaMomentOfInertia.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void MeterToTheFourthToAreaMomentOfInertiaUnits()
         {
@@ -239,26 +253,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = AreaMomentOfInertia.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            AreaMomentOfInertia convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                AreaMomentOfInertia quantityToConvert = quantity;
+
+                AreaMomentOfInertia convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<AreaMomentOfInertiaUnit> quantityToConvert = quantity;
+
+                IQuantity<AreaMomentOfInertiaUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new AreaMomentOfInertia(value: 1, unit: AreaMomentOfInertia.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new AreaMomentOfInertia(value: 1, unit: AreaMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<AreaMomentOfInertiaUnit> quantity = new AreaMomentOfInertia(value: 1, unit: AreaMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new AreaMomentOfInertia(value: 1, unit: AreaMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new AreaMomentOfInertia(value: 1, unit: AreaMomentOfInertia.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new AreaMomentOfInertia(value: 1, unit: AreaMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<AreaMomentOfInertiaUnit> quantity = new AreaMomentOfInertia(value: 1, unit: AreaMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new AreaMomentOfInertia(value: 1, unit: AreaMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -268,7 +325,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 in⁴", AreaMomentOfInertiaUnit.InchToTheFourth, 4.2)]
         [InlineData("en-US", "4.2 m⁴", AreaMomentOfInertiaUnit.MeterToTheFourth, 4.2)]
         [InlineData("en-US", "4.2 mm⁴", AreaMomentOfInertiaUnit.MillimeterToTheFourth, 4.2)]
-        public void Parse(string culture, string quantityString, AreaMomentOfInertiaUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, AreaMomentOfInertiaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = AreaMomentOfInertia.Parse(quantityString);
@@ -283,7 +340,7 @@ public void Parse(string culture, string quantityString, AreaMomentOfInertiaUnit
         [InlineData("en-US", "4.2 in⁴", AreaMomentOfInertiaUnit.InchToTheFourth, 4.2)]
         [InlineData("en-US", "4.2 m⁴", AreaMomentOfInertiaUnit.MeterToTheFourth, 4.2)]
         [InlineData("en-US", "4.2 mm⁴", AreaMomentOfInertiaUnit.MillimeterToTheFourth, 4.2)]
-        public void TryParse(string culture, string quantityString, AreaMomentOfInertiaUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, AreaMomentOfInertiaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(AreaMomentOfInertia.TryParse(quantityString, out AreaMomentOfInertia parsed));
@@ -461,6 +518,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(AreaMomentOfIner
                 var quantity = AreaMomentOfInertia.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -484,37 +542,39 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(AreaMomentOfInertia
                 IQuantity<AreaMomentOfInertiaUnit> quantityToConvert = quantity;
                 IQuantity<AreaMomentOfInertiaUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            AreaMomentOfInertia metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(1);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromCentimetersToTheFourth(metertothefourth.CentimetersToTheFourth).MetersToTheFourth, CentimetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromDecimetersToTheFourth(metertothefourth.DecimetersToTheFourth).MetersToTheFourth, DecimetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromFeetToTheFourth(metertothefourth.FeetToTheFourth).MetersToTheFourth, FeetToTheFourthTolerance);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromInchesToTheFourth(metertothefourth.InchesToTheFourth).MetersToTheFourth, InchesToTheFourthTolerance);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromMetersToTheFourth(metertothefourth.MetersToTheFourth).MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(1, AreaMomentOfInertia.FromMillimetersToTheFourth(metertothefourth.MillimetersToTheFourth).MetersToTheFourth, MillimetersToTheFourthTolerance);
+            AreaMomentOfInertia metertothefourth = AreaMomentOfInertia.FromMetersToTheFourth(3);
+            Assert.Equal(3, AreaMomentOfInertia.FromCentimetersToTheFourth(metertothefourth.CentimetersToTheFourth).MetersToTheFourth);
+            Assert.Equal(3, AreaMomentOfInertia.FromDecimetersToTheFourth(metertothefourth.DecimetersToTheFourth).MetersToTheFourth);
+            Assert.Equal(3, AreaMomentOfInertia.FromFeetToTheFourth(metertothefourth.FeetToTheFourth).MetersToTheFourth);
+            Assert.Equal(3, AreaMomentOfInertia.FromInchesToTheFourth(metertothefourth.InchesToTheFourth).MetersToTheFourth);
+            Assert.Equal(3, AreaMomentOfInertia.FromMetersToTheFourth(metertothefourth.MetersToTheFourth).MetersToTheFourth);
+            Assert.Equal(3, AreaMomentOfInertia.FromMillimetersToTheFourth(metertothefourth.MillimetersToTheFourth).MetersToTheFourth);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             AreaMomentOfInertia v = AreaMomentOfInertia.FromMetersToTheFourth(1);
-            AssertEx.EqualTolerance(-1, -v.MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(2, (AreaMomentOfInertia.FromMetersToTheFourth(3)-v).MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(2, (v + v).MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(10, (v*10).MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(10, (10*v).MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(2, (AreaMomentOfInertia.FromMetersToTheFourth(10)/5).MetersToTheFourth, MetersToTheFourthTolerance);
-            AssertEx.EqualTolerance(2, AreaMomentOfInertia.FromMetersToTheFourth(10)/AreaMomentOfInertia.FromMetersToTheFourth(5), MetersToTheFourthTolerance);
+            Assert.Equal(-1, -v.MetersToTheFourth);
+            Assert.Equal(2, (AreaMomentOfInertia.FromMetersToTheFourth(3) - v).MetersToTheFourth);
+            Assert.Equal(2, (v + v).MetersToTheFourth);
+            Assert.Equal(10, (v * 10).MetersToTheFourth);
+            Assert.Equal(10, (10 * v).MetersToTheFourth);
+            Assert.Equal(2, (AreaMomentOfInertia.FromMetersToTheFourth(10) / 5).MetersToTheFourth);
+            Assert.Equal(2, AreaMomentOfInertia.FromMetersToTheFourth(10) / AreaMomentOfInertia.FromMetersToTheFourth(5));
         }
 
         [Fact]
@@ -560,8 +620,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, AreaMomentOfInertiaUnit.MeterToTheFourth, 1, AreaMomentOfInertiaUnit.MeterToTheFourth, true)]  // Same value and unit.
         [InlineData(1, AreaMomentOfInertiaUnit.MeterToTheFourth, 2, AreaMomentOfInertiaUnit.MeterToTheFourth, false)] // Different value.
-        [InlineData(2, AreaMomentOfInertiaUnit.MeterToTheFourth, 1, AreaMomentOfInertiaUnit.CentimeterToTheFourth, false)] // Different value and unit.
-        [InlineData(1, AreaMomentOfInertiaUnit.MeterToTheFourth, 1, AreaMomentOfInertiaUnit.CentimeterToTheFourth, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, AreaMomentOfInertiaUnit unitA, double valueB, AreaMomentOfInertiaUnit unitB, bool expectEqual)
         {
             var a = new AreaMomentOfInertia(valueA, unitA);
@@ -621,8 +679,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = AreaMomentOfInertia.FromMetersToTheFourth(firstValue);
             var otherQuantity = AreaMomentOfInertia.FromMetersToTheFourth(secondValue);
             AreaMomentOfInertia maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, AreaMomentOfInertia.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -641,7 +699,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<AreaMomentOfInertiaUnit>();
+            var units = EnumHelper.GetValues<AreaMomentOfInertiaUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -654,6 +712,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(AreaMomentOfInertia.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(AreaMomentOfInertia.Info.Units, AreaMomentOfInertia.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, AreaMomentOfInertia.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -680,26 +750,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 mm⁴", new AreaMomentOfInertia(1, AreaMomentOfInertiaUnit.MillimeterToTheFourth).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m⁴", new AreaMomentOfInertia(0.123456, AreaMomentOfInertiaUnit.MeterToTheFourth).ToString("s1"));
-            Assert.Equal("0.12 m⁴", new AreaMomentOfInertia(0.123456, AreaMomentOfInertiaUnit.MeterToTheFourth).ToString("s2"));
-            Assert.Equal("0.123 m⁴", new AreaMomentOfInertia(0.123456, AreaMomentOfInertiaUnit.MeterToTheFourth).ToString("s3"));
-            Assert.Equal("0.1235 m⁴", new AreaMomentOfInertia(0.123456, AreaMomentOfInertiaUnit.MeterToTheFourth).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m⁴", new AreaMomentOfInertia(0.123456, AreaMomentOfInertiaUnit.MeterToTheFourth).ToString("s1", culture));
-            Assert.Equal("0.12 m⁴", new AreaMomentOfInertia(0.123456, AreaMomentOfInertiaUnit.MeterToTheFourth).ToString("s2", culture));
-            Assert.Equal("0.123 m⁴", new AreaMomentOfInertia(0.123456, AreaMomentOfInertiaUnit.MeterToTheFourth).ToString("s3", culture));
-            Assert.Equal("0.1235 m⁴", new AreaMomentOfInertia(0.123456, AreaMomentOfInertiaUnit.MeterToTheFourth).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -726,7 +776,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = AreaMomentOfInertia.FromMetersToTheFourth(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(AreaMomentOfInertia), quantity.As(AreaMomentOfInertia.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaPerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaPerLengthTestsBase.g.cs
new file mode 100644
index 0000000000..ec8ff0fbfb
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaPerLengthTestsBase.g.cs
@@ -0,0 +1,792 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using UnitsNet.InternalHelpers;
+using UnitsNet.Tests.Helpers;
+using UnitsNet.Tests.TestsBase;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of AreaPerLength.
+    /// </summary>
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class AreaPerLengthTestsBase : QuantityTestsBase
+    {
+        protected abstract double SquareCentimetersPerMeterInOneSquareMeterPerMeter { get; }
+        protected abstract double SquareFeetPerFootInOneSquareMeterPerMeter { get; }
+        protected abstract double SquareInchesPerFootInOneSquareMeterPerMeter { get; }
+        protected abstract double SquareInchesPerInchInOneSquareMeterPerMeter { get; }
+        protected abstract double SquareMetersPerMeterInOneSquareMeterPerMeter { get; }
+        protected abstract double SquareMillimetersPerMeterInOneSquareMeterPerMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double SquareCentimetersPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double SquareFeetPerFootTolerance { get { return 1e-5; } }
+        protected virtual double SquareInchesPerFootTolerance { get { return 1e-5; } }
+        protected virtual double SquareInchesPerInchTolerance { get { return 1e-5; } }
+        protected virtual double SquareMetersPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double SquareMillimetersPerMeterTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(AreaPerLengthUnit unit)
+        {
+            return unit switch
+            {
+                AreaPerLengthUnit.SquareCentimeterPerMeter => (SquareCentimetersPerMeterInOneSquareMeterPerMeter, SquareCentimetersPerMeterTolerance),
+                AreaPerLengthUnit.SquareFootPerFoot => (SquareFeetPerFootInOneSquareMeterPerMeter, SquareFeetPerFootTolerance),
+                AreaPerLengthUnit.SquareInchPerFoot => (SquareInchesPerFootInOneSquareMeterPerMeter, SquareInchesPerFootTolerance),
+                AreaPerLengthUnit.SquareInchPerInch => (SquareInchesPerInchInOneSquareMeterPerMeter, SquareInchesPerInchTolerance),
+                AreaPerLengthUnit.SquareMeterPerMeter => (SquareMetersPerMeterInOneSquareMeterPerMeter, SquareMetersPerMeterTolerance),
+                AreaPerLengthUnit.SquareMillimeterPerMeter => (SquareMillimetersPerMeterInOneSquareMeterPerMeter, SquareMillimetersPerMeterTolerance),
+                _ => throw new NotSupportedException()
+            };
+        }
+
+        public static IEnumerable<object[]> UnitTypes = new List<object[]>
+        {
+            new object[] { AreaPerLengthUnit.SquareCentimeterPerMeter },
+            new object[] { AreaPerLengthUnit.SquareFootPerFoot },
+            new object[] { AreaPerLengthUnit.SquareInchPerFoot },
+            new object[] { AreaPerLengthUnit.SquareInchPerInch },
+            new object[] { AreaPerLengthUnit.SquareMeterPerMeter },
+            new object[] { AreaPerLengthUnit.SquareMillimeterPerMeter },
+        };
+
+        [Fact]
+        public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
+        {
+            var quantity = new AreaPerLength();
+            Assert.Equal(0, quantity.Value);
+            Assert.Equal(AreaPerLengthUnit.SquareMeterPerMeter, quantity.Unit);
+        }
+
+        [Fact]
+        public void Ctor_WithInfinityValue_DoNotThrowsArgumentException()
+        {
+            var exception1 = Record.Exception(() => new AreaPerLength(double.PositiveInfinity, AreaPerLengthUnit.SquareMeterPerMeter));
+            var exception2 = Record.Exception(() => new AreaPerLength(double.NegativeInfinity, AreaPerLengthUnit.SquareMeterPerMeter));
+
+            Assert.Null(exception1);
+            Assert.Null(exception2);
+        }
+
+        [Fact]
+        public void Ctor_WithNaNValue_DoNotThrowsArgumentException()
+        {
+            var exception = Record.Exception(() => new AreaPerLength(double.NaN, AreaPerLengthUnit.SquareMeterPerMeter));
+
+            Assert.Null(exception);
+        }
+
+        [Fact]
+        public void Ctor_NullAsUnitSystem_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => new AreaPerLength(value: 1, unitSystem: null));
+        }
+
+        [Fact]
+        public virtual void Ctor_SIUnitSystem_ReturnsQuantityWithSIUnits()
+        {
+            var quantity = new AreaPerLength(value: 1, unitSystem: UnitSystem.SI);
+            Assert.Equal(1, quantity.Value);
+            Assert.True(quantity.QuantityInfo[quantity.Unit].BaseUnits.IsSubsetOf(UnitSystem.SI.BaseUnits));
+        }
+
+        [Fact]
+        public void Ctor_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
+        {
+            var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
+            Assert.Throws<ArgumentException>(() => new AreaPerLength(value: 1, unitSystem: unsupportedUnitSystem));
+        }
+
+        [Fact]
+        public void AreaPerLength_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
+        {
+            AreaPerLengthUnit[] unitsOrderedByName = EnumHelper.GetValues<AreaPerLengthUnit>().OrderBy(x => x.ToString(), StringComparer.OrdinalIgnoreCase).ToArray();
+            var quantity = new AreaPerLength(1, AreaPerLengthUnit.SquareMeterPerMeter);
+
+            QuantityInfo<AreaPerLength, AreaPerLengthUnit> quantityInfo = quantity.QuantityInfo;
+
+            Assert.Equal("AreaPerLength", quantityInfo.Name);
+            Assert.Equal(AreaPerLength.Zero, quantityInfo.Zero);
+            Assert.Equal(AreaPerLength.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(unitsOrderedByName, quantityInfo.Units);
+            Assert.Equal(unitsOrderedByName, quantityInfo.UnitInfos.Select(x => x.Value));
+            Assert.Equal(AreaPerLength.Info, quantityInfo);
+            Assert.Equal(quantityInfo, ((IQuantity)quantity).QuantityInfo);
+            Assert.Equal(quantityInfo, ((IQuantity<AreaPerLengthUnit>)quantity).QuantityInfo);
+        }
+
+        [Fact]
+        public void AreaPerLengthInfo_CreateWithCustomUnitInfos()
+        {
+            AreaPerLengthUnit[] expectedUnits = [AreaPerLengthUnit.SquareMeterPerMeter];
+
+            AreaPerLength.AreaPerLengthInfo quantityInfo = AreaPerLength.AreaPerLengthInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("AreaPerLength", quantityInfo.Name);
+            Assert.Equal(AreaPerLength.Zero, quantityInfo.Zero);
+            Assert.Equal(AreaPerLength.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
+        [Fact]
+        public void SquareMeterPerMeterToAreaPerLengthUnits()
+        {
+            AreaPerLength squaremeterpermeter = AreaPerLength.FromSquareMetersPerMeter(1);
+            AssertEx.EqualTolerance(SquareCentimetersPerMeterInOneSquareMeterPerMeter, squaremeterpermeter.SquareCentimetersPerMeter, SquareCentimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(SquareFeetPerFootInOneSquareMeterPerMeter, squaremeterpermeter.SquareFeetPerFoot, SquareFeetPerFootTolerance);
+            AssertEx.EqualTolerance(SquareInchesPerFootInOneSquareMeterPerMeter, squaremeterpermeter.SquareInchesPerFoot, SquareInchesPerFootTolerance);
+            AssertEx.EqualTolerance(SquareInchesPerInchInOneSquareMeterPerMeter, squaremeterpermeter.SquareInchesPerInch, SquareInchesPerInchTolerance);
+            AssertEx.EqualTolerance(SquareMetersPerMeterInOneSquareMeterPerMeter, squaremeterpermeter.SquareMetersPerMeter, SquareMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(SquareMillimetersPerMeterInOneSquareMeterPerMeter, squaremeterpermeter.SquareMillimetersPerMeter, SquareMillimetersPerMeterTolerance);
+        }
+
+        [Fact]
+        public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
+        {
+            Assert.All(EnumHelper.GetValues<AreaPerLengthUnit>(), unit =>
+            {
+                var quantity = AreaPerLength.From(1, unit);
+                Assert.Equal(1, quantity.Value);
+                Assert.Equal(unit, quantity.Unit);
+            });
+        }
+
+        [Fact]
+        public void FromSquareMetersPerMeter_WithInfinityValue_DoNotThrowsArgumentException()
+        {
+            var exception1 = Record.Exception(() => AreaPerLength.FromSquareMetersPerMeter(double.PositiveInfinity));
+            var exception2 = Record.Exception(() => AreaPerLength.FromSquareMetersPerMeter(double.NegativeInfinity));
+
+            Assert.Null(exception1);
+            Assert.Null(exception2);
+        }
+
+        [Fact]
+        public void FromSquareMetersPerMeter_WithNanValue_DoNotThrowsArgumentException()
+        {
+            var exception = Record.Exception(() => AreaPerLength.FromSquareMetersPerMeter(double.NaN));
+
+            Assert.Null(exception);
+        }
+
+        [Fact]
+        public void As()
+        {
+            var squaremeterpermeter = AreaPerLength.FromSquareMetersPerMeter(1);
+            AssertEx.EqualTolerance(SquareCentimetersPerMeterInOneSquareMeterPerMeter, squaremeterpermeter.As(AreaPerLengthUnit.SquareCentimeterPerMeter), SquareCentimetersPerMeterTolerance);
+            AssertEx.EqualTolerance(SquareFeetPerFootInOneSquareMeterPerMeter, squaremeterpermeter.As(AreaPerLengthUnit.SquareFootPerFoot), SquareFeetPerFootTolerance);
+            AssertEx.EqualTolerance(SquareInchesPerFootInOneSquareMeterPerMeter, squaremeterpermeter.As(AreaPerLengthUnit.SquareInchPerFoot), SquareInchesPerFootTolerance);
+            AssertEx.EqualTolerance(SquareInchesPerInchInOneSquareMeterPerMeter, squaremeterpermeter.As(AreaPerLengthUnit.SquareInchPerInch), SquareInchesPerInchTolerance);
+            AssertEx.EqualTolerance(SquareMetersPerMeterInOneSquareMeterPerMeter, squaremeterpermeter.As(AreaPerLengthUnit.SquareMeterPerMeter), SquareMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(SquareMillimetersPerMeterInOneSquareMeterPerMeter, squaremeterpermeter.As(AreaPerLengthUnit.SquareMillimeterPerMeter), SquareMillimetersPerMeterTolerance);
+        }
+
+        [Fact]
+        public virtual void BaseUnit_HasSIBase()
+        {
+            var baseUnitInfo = AreaPerLength.Info.BaseUnitInfo;
+            Assert.True(baseUnitInfo.BaseUnits.IsSubsetOf(UnitSystem.SI.BaseUnits));
+        }
+
+        [Fact]
+        public virtual void As_UnitSystem_SI_ReturnsQuantityInSIUnits()
+        {
+            var quantity = new AreaPerLength(value: 1, unit: AreaPerLength.BaseUnit);
+            var expectedValue = quantity.As(AreaPerLength.Info.GetDefaultUnit(UnitSystem.SI));
+
+            var convertedValue = quantity.As(UnitSystem.SI);
+
+            Assert.Equal(expectedValue, convertedValue);
+        }
+
+        [Fact]
+        public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
+        {
+            var quantity = new AreaPerLength(value: 1, unit: AreaPerLength.BaseUnit);
+            UnitSystem nullUnitSystem = null!;
+            Assert.Throws<ArgumentNullException>(() => quantity.As(nullUnitSystem));
+        }
+
+        [Fact]
+        public void As_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
+        {
+            var quantity = new AreaPerLength(value: 1, unit: AreaPerLength.BaseUnit);
+            var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
+            Assert.Throws<ArgumentException>(() => quantity.As(unsupportedUnitSystem));
+        }
+
+        [Fact]
+        public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
+        {
+            var quantity = new AreaPerLength(value: 1, unit: AreaPerLength.BaseUnit);
+            var expectedUnit = AreaPerLength.Info.GetDefaultUnit(UnitSystem.SI);
+            var expectedValue = quantity.As(expectedUnit);
+
+            Assert.Multiple(() =>
+            {
+                AreaPerLength quantityToConvert = quantity;
+
+                AreaPerLength convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<AreaPerLengthUnit> quantityToConvert = quantity;
+
+                IQuantity<AreaPerLengthUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
+        }
+
+        [Fact]
+        public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
+        {
+            UnitSystem nullUnitSystem = null!;
+            Assert.Multiple(() =>
+            {
+                var quantity = new AreaPerLength(value: 1, unit: AreaPerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<AreaPerLengthUnit> quantity = new AreaPerLength(value: 1, unit: AreaPerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new AreaPerLength(value: 1, unit: AreaPerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
+        }
+
+        [Fact]
+        public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
+        {
+            var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
+            Assert.Multiple(() =>
+            {
+                var quantity = new AreaPerLength(value: 1, unit: AreaPerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<AreaPerLengthUnit> quantity = new AreaPerLength(value: 1, unit: AreaPerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new AreaPerLength(value: 1, unit: AreaPerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
+        }
+
+        [Theory]
+        [InlineData("en-US", "4.2 cm²/m", AreaPerLengthUnit.SquareCentimeterPerMeter, 4.2)]
+        [InlineData("en-US", "4.2 ft²/ft", AreaPerLengthUnit.SquareFootPerFoot, 4.2)]
+        [InlineData("en-US", "4.2 in²/ft", AreaPerLengthUnit.SquareInchPerFoot, 4.2)]
+        [InlineData("en-US", "4.2 in²/in", AreaPerLengthUnit.SquareInchPerInch, 4.2)]
+        [InlineData("en-US", "4.2 m²/m", AreaPerLengthUnit.SquareMeterPerMeter, 4.2)]
+        [InlineData("en-US", "4.2 mm²/m", AreaPerLengthUnit.SquareMillimeterPerMeter, 4.2)]
+        public void Parse(string culture, string quantityString, AreaPerLengthUnit expectedUnit, decimal expectedValue)
+        {
+            using var _ = new CultureScope(culture);
+            var parsed = AreaPerLength.Parse(quantityString);
+            Assert.Equal(expectedUnit, parsed.Unit);
+            Assert.Equal(expectedValue, parsed.Value);
+        }
+
+        [Theory]
+        [InlineData("en-US", "4.2 cm²/m", AreaPerLengthUnit.SquareCentimeterPerMeter, 4.2)]
+        [InlineData("en-US", "4.2 ft²/ft", AreaPerLengthUnit.SquareFootPerFoot, 4.2)]
+        [InlineData("en-US", "4.2 in²/ft", AreaPerLengthUnit.SquareInchPerFoot, 4.2)]
+        [InlineData("en-US", "4.2 in²/in", AreaPerLengthUnit.SquareInchPerInch, 4.2)]
+        [InlineData("en-US", "4.2 m²/m", AreaPerLengthUnit.SquareMeterPerMeter, 4.2)]
+        [InlineData("en-US", "4.2 mm²/m", AreaPerLengthUnit.SquareMillimeterPerMeter, 4.2)]
+        public void TryParse(string culture, string quantityString, AreaPerLengthUnit expectedUnit, decimal expectedValue)
+        {
+            using var _ = new CultureScope(culture);
+            Assert.True(AreaPerLength.TryParse(quantityString, out AreaPerLength parsed));
+            Assert.Equal(expectedUnit, parsed.Unit);
+            Assert.Equal(expectedValue, parsed.Value);
+        }
+
+        [Theory]
+        [InlineData("cm²/m", AreaPerLengthUnit.SquareCentimeterPerMeter)]
+        [InlineData("ft²/ft", AreaPerLengthUnit.SquareFootPerFoot)]
+        [InlineData("in²/ft", AreaPerLengthUnit.SquareInchPerFoot)]
+        [InlineData("in²/in", AreaPerLengthUnit.SquareInchPerInch)]
+        [InlineData("m²/m", AreaPerLengthUnit.SquareMeterPerMeter)]
+        [InlineData("mm²/m", AreaPerLengthUnit.SquareMillimeterPerMeter)]
+        public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, AreaPerLengthUnit expectedUnit)
+        {
+            // Fallback culture "en-US" is always localized
+            using var _ = new CultureScope("en-US");
+            AreaPerLengthUnit parsedUnit = AreaPerLength.ParseUnit(abbreviation);
+            Assert.Equal(expectedUnit, parsedUnit);
+        }
+
+        [Theory]
+        [InlineData("cm²/m", AreaPerLengthUnit.SquareCentimeterPerMeter)]
+        [InlineData("ft²/ft", AreaPerLengthUnit.SquareFootPerFoot)]
+        [InlineData("in²/ft", AreaPerLengthUnit.SquareInchPerFoot)]
+        [InlineData("in²/in", AreaPerLengthUnit.SquareInchPerInch)]
+        [InlineData("m²/m", AreaPerLengthUnit.SquareMeterPerMeter)]
+        [InlineData("mm²/m", AreaPerLengthUnit.SquareMillimeterPerMeter)]
+        public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, AreaPerLengthUnit expectedUnit)
+        {
+            // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing.
+            using var _ = new CultureScope("is-IS");
+            AreaPerLengthUnit parsedUnit = AreaPerLength.ParseUnit(abbreviation);
+            Assert.Equal(expectedUnit, parsedUnit);
+        }
+
+        [Theory]
+        [InlineData("en-US", "cm²/m", AreaPerLengthUnit.SquareCentimeterPerMeter)]
+        [InlineData("en-US", "ft²/ft", AreaPerLengthUnit.SquareFootPerFoot)]
+        [InlineData("en-US", "in²/ft", AreaPerLengthUnit.SquareInchPerFoot)]
+        [InlineData("en-US", "in²/in", AreaPerLengthUnit.SquareInchPerInch)]
+        [InlineData("en-US", "m²/m", AreaPerLengthUnit.SquareMeterPerMeter)]
+        [InlineData("en-US", "mm²/m", AreaPerLengthUnit.SquareMillimeterPerMeter)]
+        public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, AreaPerLengthUnit expectedUnit)
+        {
+            using var _ = new CultureScope(culture);
+            AreaPerLengthUnit parsedUnit = AreaPerLength.ParseUnit(abbreviation);
+            Assert.Equal(expectedUnit, parsedUnit);
+        }
+
+        [Theory]
+        [InlineData("en-US", "cm²/m", AreaPerLengthUnit.SquareCentimeterPerMeter)]
+        [InlineData("en-US", "ft²/ft", AreaPerLengthUnit.SquareFootPerFoot)]
+        [InlineData("en-US", "in²/ft", AreaPerLengthUnit.SquareInchPerFoot)]
+        [InlineData("en-US", "in²/in", AreaPerLengthUnit.SquareInchPerInch)]
+        [InlineData("en-US", "m²/m", AreaPerLengthUnit.SquareMeterPerMeter)]
+        [InlineData("en-US", "mm²/m", AreaPerLengthUnit.SquareMillimeterPerMeter)]
+        public void ParseUnit_WithCulture(string culture, string abbreviation, AreaPerLengthUnit expectedUnit)
+        {
+            AreaPerLengthUnit parsedUnit = AreaPerLength.ParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture));
+            Assert.Equal(expectedUnit, parsedUnit);
+        }
+
+        [Theory]
+        [InlineData("cm²/m", AreaPerLengthUnit.SquareCentimeterPerMeter)]
+        [InlineData("ft²/ft", AreaPerLengthUnit.SquareFootPerFoot)]
+        [InlineData("in²/ft", AreaPerLengthUnit.SquareInchPerFoot)]
+        [InlineData("in²/in", AreaPerLengthUnit.SquareInchPerInch)]
+        [InlineData("m²/m", AreaPerLengthUnit.SquareMeterPerMeter)]
+        [InlineData("mm²/m", AreaPerLengthUnit.SquareMillimeterPerMeter)]
+        public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, AreaPerLengthUnit expectedUnit)
+        {
+            // Fallback culture "en-US" is always localized
+            using var _ = new CultureScope("en-US");
+            Assert.True(AreaPerLength.TryParseUnit(abbreviation, out AreaPerLengthUnit parsedUnit));
+            Assert.Equal(expectedUnit, parsedUnit);
+        }
+
+        [Theory]
+        [InlineData("cm²/m", AreaPerLengthUnit.SquareCentimeterPerMeter)]
+        [InlineData("ft²/ft", AreaPerLengthUnit.SquareFootPerFoot)]
+        [InlineData("in²/ft", AreaPerLengthUnit.SquareInchPerFoot)]
+        [InlineData("in²/in", AreaPerLengthUnit.SquareInchPerInch)]
+        [InlineData("m²/m", AreaPerLengthUnit.SquareMeterPerMeter)]
+        [InlineData("mm²/m", AreaPerLengthUnit.SquareMillimeterPerMeter)]
+        public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, AreaPerLengthUnit expectedUnit)
+        {
+            // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing.
+            using var _ = new CultureScope("is-IS");
+            Assert.True(AreaPerLength.TryParseUnit(abbreviation, out AreaPerLengthUnit parsedUnit));
+            Assert.Equal(expectedUnit, parsedUnit);
+        }
+
+        [Theory]
+        [InlineData("en-US", "cm²/m", AreaPerLengthUnit.SquareCentimeterPerMeter)]
+        [InlineData("en-US", "ft²/ft", AreaPerLengthUnit.SquareFootPerFoot)]
+        [InlineData("en-US", "in²/ft", AreaPerLengthUnit.SquareInchPerFoot)]
+        [InlineData("en-US", "in²/in", AreaPerLengthUnit.SquareInchPerInch)]
+        [InlineData("en-US", "m²/m", AreaPerLengthUnit.SquareMeterPerMeter)]
+        [InlineData("en-US", "mm²/m", AreaPerLengthUnit.SquareMillimeterPerMeter)]
+        public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, AreaPerLengthUnit expectedUnit)
+        {
+            using var _ = new CultureScope(culture);
+            Assert.True(AreaPerLength.TryParseUnit(abbreviation, out AreaPerLengthUnit parsedUnit));
+            Assert.Equal(expectedUnit, parsedUnit);
+        }
+
+        [Theory]
+        [InlineData("en-US", "cm²/m", AreaPerLengthUnit.SquareCentimeterPerMeter)]
+        [InlineData("en-US", "ft²/ft", AreaPerLengthUnit.SquareFootPerFoot)]
+        [InlineData("en-US", "in²/ft", AreaPerLengthUnit.SquareInchPerFoot)]
+        [InlineData("en-US", "in²/in", AreaPerLengthUnit.SquareInchPerInch)]
+        [InlineData("en-US", "m²/m", AreaPerLengthUnit.SquareMeterPerMeter)]
+        [InlineData("en-US", "mm²/m", AreaPerLengthUnit.SquareMillimeterPerMeter)]
+        public void TryParseUnit_WithCulture(string culture, string abbreviation, AreaPerLengthUnit expectedUnit)
+        {
+            Assert.True(AreaPerLength.TryParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture), out AreaPerLengthUnit parsedUnit));
+            Assert.Equal(expectedUnit, parsedUnit);
+        }
+
+        [Theory]
+        [InlineData("en-US", AreaPerLengthUnit.SquareCentimeterPerMeter, "cm²/m")]
+        [InlineData("en-US", AreaPerLengthUnit.SquareFootPerFoot, "ft²/ft")]
+        [InlineData("en-US", AreaPerLengthUnit.SquareInchPerFoot, "in²/ft")]
+        [InlineData("en-US", AreaPerLengthUnit.SquareInchPerInch, "in²/in")]
+        [InlineData("en-US", AreaPerLengthUnit.SquareMeterPerMeter, "m²/m")]
+        [InlineData("en-US", AreaPerLengthUnit.SquareMillimeterPerMeter, "mm²/m")]
+        public void GetAbbreviationForCulture(string culture, AreaPerLengthUnit unit, string expectedAbbreviation)
+        {
+            var defaultAbbreviation = AreaPerLength.GetAbbreviation(unit, CultureInfo.GetCultureInfo(culture));
+            Assert.Equal(expectedAbbreviation, defaultAbbreviation);
+        }
+
+        [Fact]
+        public void GetAbbreviationWithDefaultCulture()
+        {
+            Assert.All(AreaPerLength.Units, unit =>
+            {
+                var expectedAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
+
+                var defaultAbbreviation = AreaPerLength.GetAbbreviation(unit);
+
+                Assert.Equal(expectedAbbreviation, defaultAbbreviation);
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(UnitTypes))]
+        public void ToUnit(AreaPerLengthUnit unit)
+        {
+            var inBaseUnits = AreaPerLength.From(1.0, AreaPerLength.BaseUnit);
+            var converted = inBaseUnits.ToUnit(unit);
+
+            var conversionFactor = GetConversionFactor(unit);
+            AssertEx.EqualTolerance(conversionFactor.UnitsInBaseUnit, converted.Value, conversionFactor.Tolerence);
+            Assert.Equal(unit, converted.Unit);
+        }
+
+        [Theory]
+        [MemberData(nameof(UnitTypes))]
+        public void ToUnit_WithSameUnits_AreEqual(AreaPerLengthUnit unit)
+        {
+            var quantity = AreaPerLength.From(3.0, unit);
+            var toUnitWithSameUnit = quantity.ToUnit(unit);
+            Assert.Equal(quantity, toUnitWithSameUnit);
+        }
+
+        [Theory]
+        [MemberData(nameof(UnitTypes))]
+        public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(AreaPerLengthUnit unit)
+        {
+            Assert.All(AreaPerLength.Units.Where(u => u != AreaPerLength.BaseUnit), fromUnit =>
+            {
+                var quantity = AreaPerLength.From(3.0, fromUnit);
+                var converted = quantity.ToUnit(unit);
+                Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(UnitTypes))]
+        public virtual void ToUnit_FromDefaultQuantity_ReturnsQuantityWithGivenUnit(AreaPerLengthUnit unit)
+        {
+            var quantity = default(AreaPerLength);
+            var converted = quantity.ToUnit(unit);
+            Assert.Equal(converted.Unit, unit);
+        }
+
+        [Theory]
+        [MemberData(nameof(UnitTypes))]
+        public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(AreaPerLengthUnit unit)
+        {
+            var quantity = AreaPerLength.From(3, AreaPerLength.BaseUnit);
+            AreaPerLength expectedQuantity = quantity.ToUnit(unit);
+            Assert.Multiple(() =>
+            {
+                IQuantity<AreaPerLengthUnit> quantityToConvert = quantity;
+                IQuantity<AreaPerLengthUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
+                Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
+                Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
+            });
+        }
+
+        [Fact]
+        public void ConversionRoundTrip()
+        {
+            AreaPerLength squaremeterpermeter = AreaPerLength.FromSquareMetersPerMeter(3);
+            Assert.Equal(3, AreaPerLength.FromSquareCentimetersPerMeter(squaremeterpermeter.SquareCentimetersPerMeter).SquareMetersPerMeter);
+            Assert.Equal(3, AreaPerLength.FromSquareFeetPerFoot(squaremeterpermeter.SquareFeetPerFoot).SquareMetersPerMeter);
+            Assert.Equal(3, AreaPerLength.FromSquareInchesPerFoot(squaremeterpermeter.SquareInchesPerFoot).SquareMetersPerMeter);
+            Assert.Equal(3, AreaPerLength.FromSquareInchesPerInch(squaremeterpermeter.SquareInchesPerInch).SquareMetersPerMeter);
+            Assert.Equal(3, AreaPerLength.FromSquareMetersPerMeter(squaremeterpermeter.SquareMetersPerMeter).SquareMetersPerMeter);
+            Assert.Equal(3, AreaPerLength.FromSquareMillimetersPerMeter(squaremeterpermeter.SquareMillimetersPerMeter).SquareMetersPerMeter);
+        }
+
+        [Fact]
+        public void ArithmeticOperators()
+        {
+            AreaPerLength v = AreaPerLength.FromSquareMetersPerMeter(1);
+            Assert.Equal(-1, -v.SquareMetersPerMeter);
+            Assert.Equal(2, (AreaPerLength.FromSquareMetersPerMeter(3) - v).SquareMetersPerMeter);
+            Assert.Equal(2, (v + v).SquareMetersPerMeter);
+            Assert.Equal(10, (v * 10).SquareMetersPerMeter);
+            Assert.Equal(10, (10 * v).SquareMetersPerMeter);
+            Assert.Equal(2, (AreaPerLength.FromSquareMetersPerMeter(10) / 5).SquareMetersPerMeter);
+            Assert.Equal(2, AreaPerLength.FromSquareMetersPerMeter(10) / AreaPerLength.FromSquareMetersPerMeter(5));
+        }
+
+        [Fact]
+        public void ComparisonOperators()
+        {
+            AreaPerLength oneSquareMeterPerMeter = AreaPerLength.FromSquareMetersPerMeter(1);
+            AreaPerLength twoSquareMetersPerMeter = AreaPerLength.FromSquareMetersPerMeter(2);
+
+            Assert.True(oneSquareMeterPerMeter < twoSquareMetersPerMeter);
+            Assert.True(oneSquareMeterPerMeter <= twoSquareMetersPerMeter);
+            Assert.True(twoSquareMetersPerMeter > oneSquareMeterPerMeter);
+            Assert.True(twoSquareMetersPerMeter >= oneSquareMeterPerMeter);
+
+            Assert.False(oneSquareMeterPerMeter > twoSquareMetersPerMeter);
+            Assert.False(oneSquareMeterPerMeter >= twoSquareMetersPerMeter);
+            Assert.False(twoSquareMetersPerMeter < oneSquareMeterPerMeter);
+            Assert.False(twoSquareMetersPerMeter <= oneSquareMeterPerMeter);
+        }
+
+        [Fact]
+        public void CompareToIsImplemented()
+        {
+            AreaPerLength squaremeterpermeter = AreaPerLength.FromSquareMetersPerMeter(1);
+            Assert.Equal(0, squaremeterpermeter.CompareTo(squaremeterpermeter));
+            Assert.True(squaremeterpermeter.CompareTo(AreaPerLength.Zero) > 0);
+            Assert.True(AreaPerLength.Zero.CompareTo(squaremeterpermeter) < 0);
+        }
+
+        [Fact]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            AreaPerLength squaremeterpermeter = AreaPerLength.FromSquareMetersPerMeter(1);
+            Assert.Throws<ArgumentException>(() => squaremeterpermeter.CompareTo(new object()));
+        }
+
+        [Fact]
+        public void CompareToThrowsOnNull()
+        {
+            AreaPerLength squaremeterpermeter = AreaPerLength.FromSquareMetersPerMeter(1);
+            Assert.Throws<ArgumentNullException>(() => squaremeterpermeter.CompareTo(null));
+        }
+
+        [Theory]
+        [InlineData(1, AreaPerLengthUnit.SquareMeterPerMeter, 1, AreaPerLengthUnit.SquareMeterPerMeter, true)]  // Same value and unit.
+        [InlineData(1, AreaPerLengthUnit.SquareMeterPerMeter, 2, AreaPerLengthUnit.SquareMeterPerMeter, false)] // Different value.
+        public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, AreaPerLengthUnit unitA, double valueB, AreaPerLengthUnit unitB, bool expectEqual)
+        {
+            var a = new AreaPerLength(valueA, unitA);
+            var b = new AreaPerLength(valueB, unitB);
+
+            // Operator overloads.
+            Assert.Equal(expectEqual, a == b);
+            Assert.Equal(expectEqual, b == a);
+            Assert.Equal(!expectEqual, a != b);
+            Assert.Equal(!expectEqual, b != a);
+
+            // IEquatable<T>
+            Assert.Equal(expectEqual, a.Equals(b));
+            Assert.Equal(expectEqual, b.Equals(a));
+
+            // IEquatable
+            Assert.Equal(expectEqual, a.Equals((object)b));
+            Assert.Equal(expectEqual, b.Equals((object)a));
+        }
+
+        [Fact]
+        public void Equals_Null_ReturnsFalse()
+        {
+            var a = AreaPerLength.Zero;
+
+            Assert.False(a.Equals((object)null));
+
+            // "The result of the expression is always 'false'..."
+            #pragma warning disable CS8073
+            Assert.False(a == null);
+            Assert.False(null == a);
+            Assert.True(a != null);
+            Assert.True(null != a);
+            #pragma warning restore CS8073
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            AreaPerLength squaremeterpermeter = AreaPerLength.FromSquareMetersPerMeter(1);
+            Assert.False(squaremeterpermeter.Equals(new object()));
+        }
+
+        [Fact]
+        public void EqualsReturnsFalseOnNull()
+        {
+            AreaPerLength squaremeterpermeter = AreaPerLength.FromSquareMetersPerMeter(1);
+            Assert.False(squaremeterpermeter.Equals(null));
+        }
+
+        [Theory]
+        [InlineData(1, 2)]
+        [InlineData(100, 110)]
+        [InlineData(100, 90)]
+        public void Equals_WithTolerance(double firstValue, double secondValue)
+        {
+            var quantity = AreaPerLength.FromSquareMetersPerMeter(firstValue);
+            var otherQuantity = AreaPerLength.FromSquareMetersPerMeter(secondValue);
+            AreaPerLength maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
+            Assert.True(quantity.Equals(quantity, AreaPerLength.Zero));
+            Assert.True(quantity.Equals(quantity, maxTolerance));
+            Assert.True(quantity.Equals(otherQuantity, maxTolerance));
+            Assert.True(quantity.Equals(otherQuantity, largerTolerance));
+            Assert.False(quantity.Equals(otherQuantity, smallerTolerance));
+        }
+
+        [Fact]
+        public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
+        {
+            var quantity = AreaPerLength.FromSquareMetersPerMeter(1);
+            var negativeTolerance = AreaPerLength.FromSquareMetersPerMeter(-1);
+            Assert.Throws<ArgumentOutOfRangeException>(() => quantity.Equals(quantity, negativeTolerance));
+        }
+
+        [Fact]
+        public void HasAtLeastOneAbbreviationSpecified()
+        {
+            var units = EnumHelper.GetValues<AreaPerLengthUnit>();
+            foreach (var unit in units)
+            {
+                var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
+            }
+        }
+
+        [Fact]
+        public void BaseDimensionsShouldNeverBeNull()
+        {
+            Assert.False(AreaPerLength.BaseDimensions is null);
+        }
+
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(AreaPerLength.Info.Units, AreaPerLength.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, AreaPerLength.DefaultConversionFunctions);
+        }
+
+        [Fact]
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        {
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 cm²/m", new AreaPerLength(1, AreaPerLengthUnit.SquareCentimeterPerMeter).ToString());
+            Assert.Equal("1 ft²/ft", new AreaPerLength(1, AreaPerLengthUnit.SquareFootPerFoot).ToString());
+            Assert.Equal("1 in²/ft", new AreaPerLength(1, AreaPerLengthUnit.SquareInchPerFoot).ToString());
+            Assert.Equal("1 in²/in", new AreaPerLength(1, AreaPerLengthUnit.SquareInchPerInch).ToString());
+            Assert.Equal("1 m²/m", new AreaPerLength(1, AreaPerLengthUnit.SquareMeterPerMeter).ToString());
+            Assert.Equal("1 mm²/m", new AreaPerLength(1, AreaPerLengthUnit.SquareMillimeterPerMeter).ToString());
+        }
+
+        [Fact]
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        {
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 cm²/m", new AreaPerLength(1, AreaPerLengthUnit.SquareCentimeterPerMeter).ToString(swedishCulture));
+            Assert.Equal("1 ft²/ft", new AreaPerLength(1, AreaPerLengthUnit.SquareFootPerFoot).ToString(swedishCulture));
+            Assert.Equal("1 in²/ft", new AreaPerLength(1, AreaPerLengthUnit.SquareInchPerFoot).ToString(swedishCulture));
+            Assert.Equal("1 in²/in", new AreaPerLength(1, AreaPerLengthUnit.SquareInchPerInch).ToString(swedishCulture));
+            Assert.Equal("1 m²/m", new AreaPerLength(1, AreaPerLengthUnit.SquareMeterPerMeter).ToString(swedishCulture));
+            Assert.Equal("1 mm²/m", new AreaPerLength(1, AreaPerLengthUnit.SquareMillimeterPerMeter).ToString(swedishCulture));
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("en-US")]
+        public void ToString_NullFormat_DefaultsToGeneralFormat(string cultureName)
+        {
+            var quantity = AreaPerLength.FromSquareMetersPerMeter(1.0);
+            CultureInfo formatProvider = cultureName == null
+                ? null
+                : CultureInfo.GetCultureInfo(cultureName);
+
+            Assert.Equal(quantity.ToString("G", formatProvider), quantity.ToString(null, formatProvider));
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("g")]
+        public void ToString_NullProvider_EqualsCurrentCulture(string format)
+        {
+            var quantity = AreaPerLength.FromSquareMetersPerMeter(1.0);
+            Assert.Equal(quantity.ToString(format, CultureInfo.CurrentCulture), quantity.ToString(format, null));
+        }
+
+        [Fact]
+        public void GetHashCode_Equals()
+        {
+            var quantity = AreaPerLength.FromSquareMetersPerMeter(1.0);
+            var expected = Comparison.GetHashCode(typeof(AreaPerLength), quantity.As(AreaPerLength.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
+        }
+
+        [Theory]
+        [InlineData(1.0)]
+        [InlineData(-1.0)]
+        public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
+        {
+            var quantity = AreaPerLength.FromSquareMetersPerMeter(value);
+            Assert.Equal(AreaPerLength.FromSquareMetersPerMeter(-value), -quantity);
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs
index cebf87cd99..bed4b11eae 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/AreaTestsBase.g.cs
@@ -177,6 +177,20 @@ public void Area_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<AreaUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void AreaInfo_CreateWithCustomUnitInfos()
+        {
+            AreaUnit[] expectedUnits = [AreaUnit.SquareMeter];
+
+            Area.AreaInfo quantityInfo = Area.AreaInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Area", quantityInfo.Name);
+            Assert.Equal(Area.Zero, quantityInfo.Zero);
+            Assert.Equal(Area.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SquareMeterToAreaUnits()
         {
@@ -287,26 +301,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Area.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Area convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Area quantityToConvert = quantity;
+
+                Area convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<AreaUnit> quantityToConvert = quantity;
+
+                IQuantity<AreaUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Area(value: 1, unit: Area.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Area(value: 1, unit: Area.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<AreaUnit> quantity = new Area(value: 1, unit: Area.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Area(value: 1, unit: Area.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Area(value: 1, unit: Area.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Area(value: 1, unit: Area.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<AreaUnit> quantity = new Area(value: 1, unit: Area.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Area(value: 1, unit: Area.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -349,7 +406,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("zh-CN", "4.2 平方毫米", AreaUnit.SquareMillimeter, 4.2)]
         [InlineData("zh-CN", "4.2 平方海里", AreaUnit.SquareNauticalMile, 4.2)]
         [InlineData("zh-CN", "4.2 平方码", AreaUnit.SquareYard, 4.2)]
-        public void Parse(string culture, string quantityString, AreaUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, AreaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Area.Parse(quantityString);
@@ -404,7 +461,7 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("zh-CN", "4.2 平方毫米", AreaUnit.SquareMillimeter, 4.2)]
         [InlineData("zh-CN", "4.2 平方海里", AreaUnit.SquareNauticalMile, 4.2)]
         [InlineData("zh-CN", "4.2 平方码", AreaUnit.SquareYard, 4.2)]
-        public void TryParse(string culture, string quantityString, AreaUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, AreaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Area.TryParse(quantityString, out Area parsed));
@@ -802,6 +859,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(AreaUnit unit)
                 var quantity = Area.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -825,45 +883,47 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(AreaUnit unit)
                 IQuantity<AreaUnit> quantityToConvert = quantity;
                 IQuantity<AreaUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Area squaremeter = Area.FromSquareMeters(1);
-            AssertEx.EqualTolerance(1, Area.FromAcres(squaremeter.Acres).SquareMeters, AcresTolerance);
-            AssertEx.EqualTolerance(1, Area.FromHectares(squaremeter.Hectares).SquareMeters, HectaresTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareCentimeters(squaremeter.SquareCentimeters).SquareMeters, SquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareDecimeters(squaremeter.SquareDecimeters).SquareMeters, SquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareFeet(squaremeter.SquareFeet).SquareMeters, SquareFeetTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareInches(squaremeter.SquareInches).SquareMeters, SquareInchesTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareKilometers(squaremeter.SquareKilometers).SquareMeters, SquareKilometersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareMeters(squaremeter.SquareMeters).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareMicrometers(squaremeter.SquareMicrometers).SquareMeters, SquareMicrometersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareMiles(squaremeter.SquareMiles).SquareMeters, SquareMilesTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareMillimeters(squaremeter.SquareMillimeters).SquareMeters, SquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareNauticalMiles(squaremeter.SquareNauticalMiles).SquareMeters, SquareNauticalMilesTolerance);
-            AssertEx.EqualTolerance(1, Area.FromSquareYards(squaremeter.SquareYards).SquareMeters, SquareYardsTolerance);
-            AssertEx.EqualTolerance(1, Area.FromUsSurveySquareFeet(squaremeter.UsSurveySquareFeet).SquareMeters, UsSurveySquareFeetTolerance);
+            Area squaremeter = Area.FromSquareMeters(3);
+            Assert.Equal(3, Area.FromAcres(squaremeter.Acres).SquareMeters);
+            Assert.Equal(3, Area.FromHectares(squaremeter.Hectares).SquareMeters);
+            Assert.Equal(3, Area.FromSquareCentimeters(squaremeter.SquareCentimeters).SquareMeters);
+            Assert.Equal(3, Area.FromSquareDecimeters(squaremeter.SquareDecimeters).SquareMeters);
+            Assert.Equal(3, Area.FromSquareFeet(squaremeter.SquareFeet).SquareMeters);
+            Assert.Equal(3, Area.FromSquareInches(squaremeter.SquareInches).SquareMeters);
+            Assert.Equal(3, Area.FromSquareKilometers(squaremeter.SquareKilometers).SquareMeters);
+            Assert.Equal(3, Area.FromSquareMeters(squaremeter.SquareMeters).SquareMeters);
+            Assert.Equal(3, Area.FromSquareMicrometers(squaremeter.SquareMicrometers).SquareMeters);
+            Assert.Equal(3, Area.FromSquareMiles(squaremeter.SquareMiles).SquareMeters);
+            Assert.Equal(3, Area.FromSquareMillimeters(squaremeter.SquareMillimeters).SquareMeters);
+            Assert.Equal(3, Area.FromSquareNauticalMiles(squaremeter.SquareNauticalMiles).SquareMeters);
+            Assert.Equal(3, Area.FromSquareYards(squaremeter.SquareYards).SquareMeters);
+            Assert.Equal(3, Area.FromUsSurveySquareFeet(squaremeter.UsSurveySquareFeet).SquareMeters);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Area v = Area.FromSquareMeters(1);
-            AssertEx.EqualTolerance(-1, -v.SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (Area.FromSquareMeters(3)-v).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (Area.FromSquareMeters(10)/5).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, Area.FromSquareMeters(10)/Area.FromSquareMeters(5), SquareMetersTolerance);
+            Assert.Equal(-1, -v.SquareMeters);
+            Assert.Equal(2, (Area.FromSquareMeters(3) - v).SquareMeters);
+            Assert.Equal(2, (v + v).SquareMeters);
+            Assert.Equal(10, (v * 10).SquareMeters);
+            Assert.Equal(10, (10 * v).SquareMeters);
+            Assert.Equal(2, (Area.FromSquareMeters(10) / 5).SquareMeters);
+            Assert.Equal(2, Area.FromSquareMeters(10) / Area.FromSquareMeters(5));
         }
 
         [Fact]
@@ -909,8 +969,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, AreaUnit.SquareMeter, 1, AreaUnit.SquareMeter, true)]  // Same value and unit.
         [InlineData(1, AreaUnit.SquareMeter, 2, AreaUnit.SquareMeter, false)] // Different value.
-        [InlineData(2, AreaUnit.SquareMeter, 1, AreaUnit.Acre, false)] // Different value and unit.
-        [InlineData(1, AreaUnit.SquareMeter, 1, AreaUnit.Acre, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, AreaUnit unitA, double valueB, AreaUnit unitB, bool expectEqual)
         {
             var a = new Area(valueA, unitA);
@@ -970,8 +1028,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Area.FromSquareMeters(firstValue);
             var otherQuantity = Area.FromSquareMeters(secondValue);
             Area maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Area.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -990,7 +1048,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<AreaUnit>();
+            var units = EnumHelper.GetValues<AreaUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1003,6 +1061,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Area.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Area.Info.Units, Area.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Area.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1045,26 +1115,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 ft² (US)", new Area(1, AreaUnit.UsSurveySquareFoot).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m²", new Area(0.123456, AreaUnit.SquareMeter).ToString("s1"));
-            Assert.Equal("0.12 m²", new Area(0.123456, AreaUnit.SquareMeter).ToString("s2"));
-            Assert.Equal("0.123 m²", new Area(0.123456, AreaUnit.SquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 m²", new Area(0.123456, AreaUnit.SquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m²", new Area(0.123456, AreaUnit.SquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 m²", new Area(0.123456, AreaUnit.SquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 m²", new Area(0.123456, AreaUnit.SquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 m²", new Area(0.123456, AreaUnit.SquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1091,7 +1141,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Area.FromSquareMeters(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Area), quantity.As(Area.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs
index 5d2d759816..c34baf4899 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs
@@ -277,6 +277,20 @@ public void BitRate_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<BitRateUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void BitRateInfo_CreateWithCustomUnitInfos()
+        {
+            BitRateUnit[] expectedUnits = [BitRateUnit.BitPerSecond];
+
+            BitRate.BitRateInfo quantityInfo = BitRate.BitRateInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("BitRate", quantityInfo.Name);
+            Assert.Equal(BitRate.Zero, quantityInfo.Zero);
+            Assert.Equal(BitRate.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void BitPerSecondToBitRateUnits()
         {
@@ -437,26 +451,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = BitRate.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            BitRate convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                BitRate quantityToConvert = quantity;
+
+                BitRate convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<BitRateUnit> quantityToConvert = quantity;
+
+                IQuantity<BitRateUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new BitRate(value: 1, unit: BitRate.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new BitRate(value: 1, unit: BitRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<BitRateUnit> quantity = new BitRate(value: 1, unit: BitRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new BitRate(value: 1, unit: BitRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new BitRate(value: 1, unit: BitRate.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new BitRate(value: 1, unit: BitRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<BitRateUnit> quantity = new BitRate(value: 1, unit: BitRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new BitRate(value: 1, unit: BitRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -512,7 +569,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 Tbps", BitRateUnit.TerabitPerSecond, 4.2)]
         [InlineData("en-US", "4.2 TB/s", BitRateUnit.TerabytePerSecond, 4.2)]
         [InlineData("en-US", "4.2 To/s", BitRateUnit.TeraoctetPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, BitRateUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, BitRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = BitRate.Parse(quantityString);
@@ -573,7 +630,7 @@ public void Parse(string culture, string quantityString, BitRateUnit expectedUni
         [InlineData("en-US", "4.2 Tbps", BitRateUnit.TerabitPerSecond, 4.2)]
         [InlineData("en-US", "4.2 TB/s", BitRateUnit.TerabytePerSecond, 4.2)]
         [InlineData("en-US", "4.2 To/s", BitRateUnit.TeraoctetPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, BitRateUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, BitRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(BitRate.TryParse(quantityString, out BitRate parsed));
@@ -1152,6 +1209,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(BitRateUnit unit
                 var quantity = BitRate.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1175,70 +1233,72 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(BitRateUnit unit)
                 IQuantity<BitRateUnit> quantityToConvert = quantity;
                 IQuantity<BitRateUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            BitRate bitpersecond = BitRate.FromBitsPerSecond(1);
-            AssertEx.EqualTolerance(1, BitRate.FromBitsPerSecond(bitpersecond.BitsPerSecond).BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromBytesPerSecond(bitpersecond.BytesPerSecond).BitsPerSecond, BytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromExabitsPerSecond(bitpersecond.ExabitsPerSecond).BitsPerSecond, ExabitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromExabytesPerSecond(bitpersecond.ExabytesPerSecond).BitsPerSecond, ExabytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromExaoctetsPerSecond(bitpersecond.ExaoctetsPerSecond).BitsPerSecond, ExaoctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromExbibitsPerSecond(bitpersecond.ExbibitsPerSecond).BitsPerSecond, ExbibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromExbibytesPerSecond(bitpersecond.ExbibytesPerSecond).BitsPerSecond, ExbibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromExbioctetsPerSecond(bitpersecond.ExbioctetsPerSecond).BitsPerSecond, ExbioctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromGibibitsPerSecond(bitpersecond.GibibitsPerSecond).BitsPerSecond, GibibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromGibibytesPerSecond(bitpersecond.GibibytesPerSecond).BitsPerSecond, GibibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromGibioctetsPerSecond(bitpersecond.GibioctetsPerSecond).BitsPerSecond, GibioctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromGigabitsPerSecond(bitpersecond.GigabitsPerSecond).BitsPerSecond, GigabitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromGigabytesPerSecond(bitpersecond.GigabytesPerSecond).BitsPerSecond, GigabytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromGigaoctetsPerSecond(bitpersecond.GigaoctetsPerSecond).BitsPerSecond, GigaoctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromKibibitsPerSecond(bitpersecond.KibibitsPerSecond).BitsPerSecond, KibibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromKibibytesPerSecond(bitpersecond.KibibytesPerSecond).BitsPerSecond, KibibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromKibioctetsPerSecond(bitpersecond.KibioctetsPerSecond).BitsPerSecond, KibioctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromKilobitsPerSecond(bitpersecond.KilobitsPerSecond).BitsPerSecond, KilobitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromKilobytesPerSecond(bitpersecond.KilobytesPerSecond).BitsPerSecond, KilobytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromKilooctetsPerSecond(bitpersecond.KilooctetsPerSecond).BitsPerSecond, KilooctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromMebibitsPerSecond(bitpersecond.MebibitsPerSecond).BitsPerSecond, MebibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromMebibytesPerSecond(bitpersecond.MebibytesPerSecond).BitsPerSecond, MebibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromMebioctetsPerSecond(bitpersecond.MebioctetsPerSecond).BitsPerSecond, MebioctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromMegabitsPerSecond(bitpersecond.MegabitsPerSecond).BitsPerSecond, MegabitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromMegabytesPerSecond(bitpersecond.MegabytesPerSecond).BitsPerSecond, MegabytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromMegaoctetsPerSecond(bitpersecond.MegaoctetsPerSecond).BitsPerSecond, MegaoctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromOctetsPerSecond(bitpersecond.OctetsPerSecond).BitsPerSecond, OctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromPebibitsPerSecond(bitpersecond.PebibitsPerSecond).BitsPerSecond, PebibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromPebibytesPerSecond(bitpersecond.PebibytesPerSecond).BitsPerSecond, PebibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromPebioctetsPerSecond(bitpersecond.PebioctetsPerSecond).BitsPerSecond, PebioctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromPetabitsPerSecond(bitpersecond.PetabitsPerSecond).BitsPerSecond, PetabitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromPetabytesPerSecond(bitpersecond.PetabytesPerSecond).BitsPerSecond, PetabytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromPetaoctetsPerSecond(bitpersecond.PetaoctetsPerSecond).BitsPerSecond, PetaoctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromTebibitsPerSecond(bitpersecond.TebibitsPerSecond).BitsPerSecond, TebibitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromTebibytesPerSecond(bitpersecond.TebibytesPerSecond).BitsPerSecond, TebibytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromTebioctetsPerSecond(bitpersecond.TebioctetsPerSecond).BitsPerSecond, TebioctetsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromTerabitsPerSecond(bitpersecond.TerabitsPerSecond).BitsPerSecond, TerabitsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromTerabytesPerSecond(bitpersecond.TerabytesPerSecond).BitsPerSecond, TerabytesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, BitRate.FromTeraoctetsPerSecond(bitpersecond.TeraoctetsPerSecond).BitsPerSecond, TeraoctetsPerSecondTolerance);
+            BitRate bitpersecond = BitRate.FromBitsPerSecond(3);
+            Assert.Equal(3, BitRate.FromBitsPerSecond(bitpersecond.BitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromBytesPerSecond(bitpersecond.BytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromExabitsPerSecond(bitpersecond.ExabitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromExabytesPerSecond(bitpersecond.ExabytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromExaoctetsPerSecond(bitpersecond.ExaoctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromExbibitsPerSecond(bitpersecond.ExbibitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromExbibytesPerSecond(bitpersecond.ExbibytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromExbioctetsPerSecond(bitpersecond.ExbioctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromGibibitsPerSecond(bitpersecond.GibibitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromGibibytesPerSecond(bitpersecond.GibibytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromGibioctetsPerSecond(bitpersecond.GibioctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromGigabitsPerSecond(bitpersecond.GigabitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromGigabytesPerSecond(bitpersecond.GigabytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromGigaoctetsPerSecond(bitpersecond.GigaoctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromKibibitsPerSecond(bitpersecond.KibibitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromKibibytesPerSecond(bitpersecond.KibibytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromKibioctetsPerSecond(bitpersecond.KibioctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromKilobitsPerSecond(bitpersecond.KilobitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromKilobytesPerSecond(bitpersecond.KilobytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromKilooctetsPerSecond(bitpersecond.KilooctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromMebibitsPerSecond(bitpersecond.MebibitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromMebibytesPerSecond(bitpersecond.MebibytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromMebioctetsPerSecond(bitpersecond.MebioctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromMegabitsPerSecond(bitpersecond.MegabitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromMegabytesPerSecond(bitpersecond.MegabytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromMegaoctetsPerSecond(bitpersecond.MegaoctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromOctetsPerSecond(bitpersecond.OctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromPebibitsPerSecond(bitpersecond.PebibitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromPebibytesPerSecond(bitpersecond.PebibytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromPebioctetsPerSecond(bitpersecond.PebioctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromPetabitsPerSecond(bitpersecond.PetabitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromPetabytesPerSecond(bitpersecond.PetabytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromPetaoctetsPerSecond(bitpersecond.PetaoctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromTebibitsPerSecond(bitpersecond.TebibitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromTebibytesPerSecond(bitpersecond.TebibytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromTebioctetsPerSecond(bitpersecond.TebioctetsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromTerabitsPerSecond(bitpersecond.TerabitsPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromTerabytesPerSecond(bitpersecond.TerabytesPerSecond).BitsPerSecond);
+            Assert.Equal(3, BitRate.FromTeraoctetsPerSecond(bitpersecond.TeraoctetsPerSecond).BitsPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             BitRate v = BitRate.FromBitsPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (BitRate.FromBitsPerSecond(3)-v).BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (BitRate.FromBitsPerSecond(10)/5).BitsPerSecond, BitsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, BitRate.FromBitsPerSecond(10)/BitRate.FromBitsPerSecond(5), BitsPerSecondTolerance);
+            Assert.Equal(-1, -v.BitsPerSecond);
+            Assert.Equal(2, (BitRate.FromBitsPerSecond(3) - v).BitsPerSecond);
+            Assert.Equal(2, (v + v).BitsPerSecond);
+            Assert.Equal(10, (v * 10).BitsPerSecond);
+            Assert.Equal(10, (10 * v).BitsPerSecond);
+            Assert.Equal(2, (BitRate.FromBitsPerSecond(10) / 5).BitsPerSecond);
+            Assert.Equal(2, BitRate.FromBitsPerSecond(10) / BitRate.FromBitsPerSecond(5));
         }
 
         [Fact]
@@ -1284,8 +1344,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, BitRateUnit.BitPerSecond, 1, BitRateUnit.BitPerSecond, true)]  // Same value and unit.
         [InlineData(1, BitRateUnit.BitPerSecond, 2, BitRateUnit.BitPerSecond, false)] // Different value.
-        [InlineData(2, BitRateUnit.BitPerSecond, 1, BitRateUnit.BytePerSecond, false)] // Different value and unit.
-        [InlineData(1, BitRateUnit.BitPerSecond, 1, BitRateUnit.BytePerSecond, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, BitRateUnit unitA, double valueB, BitRateUnit unitB, bool expectEqual)
         {
             var a = new BitRate(valueA, unitA);
@@ -1345,8 +1403,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = BitRate.FromBitsPerSecond(firstValue);
             var otherQuantity = BitRate.FromBitsPerSecond(secondValue);
             BitRate maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, BitRate.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1365,7 +1423,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<BitRateUnit>();
+            var units = EnumHelper.GetValues<BitRateUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1378,6 +1436,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(BitRate.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(BitRate.Info.Units, BitRate.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, BitRate.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1470,26 +1540,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 To/s", new BitRate(1, BitRateUnit.TeraoctetPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 bit/s", new BitRate(0.123456, BitRateUnit.BitPerSecond).ToString("s1"));
-            Assert.Equal("0.12 bit/s", new BitRate(0.123456, BitRateUnit.BitPerSecond).ToString("s2"));
-            Assert.Equal("0.123 bit/s", new BitRate(0.123456, BitRateUnit.BitPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 bit/s", new BitRate(0.123456, BitRateUnit.BitPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 bit/s", new BitRate(0.123456, BitRateUnit.BitPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 bit/s", new BitRate(0.123456, BitRateUnit.BitPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 bit/s", new BitRate(0.123456, BitRateUnit.BitPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 bit/s", new BitRate(0.123456, BitRateUnit.BitPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1516,7 +1566,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = BitRate.FromBitsPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(BitRate), quantity.As(BitRate.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs
index 2a2dc55d8b..3163b86a9a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/BrakeSpecificFuelConsumptionTestsBase.g.cs
@@ -133,6 +133,20 @@ public void BrakeSpecificFuelConsumption_QuantityInfo_ReturnsQuantityInfoDescrib
             Assert.Equal(quantityInfo, ((IQuantity<BrakeSpecificFuelConsumptionUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void BrakeSpecificFuelConsumptionInfo_CreateWithCustomUnitInfos()
+        {
+            BrakeSpecificFuelConsumptionUnit[] expectedUnits = [BrakeSpecificFuelConsumptionUnit.KilogramPerJoule];
+
+            BrakeSpecificFuelConsumption.BrakeSpecificFuelConsumptionInfo quantityInfo = BrakeSpecificFuelConsumption.BrakeSpecificFuelConsumptionInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("BrakeSpecificFuelConsumption", quantityInfo.Name);
+            Assert.Equal(BrakeSpecificFuelConsumption.Zero, quantityInfo.Zero);
+            Assert.Equal(BrakeSpecificFuelConsumption.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KilogramPerJouleToBrakeSpecificFuelConsumptionUnits()
         {
@@ -221,33 +235,76 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = BrakeSpecificFuelConsumption.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            BrakeSpecificFuelConsumption convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                BrakeSpecificFuelConsumption quantityToConvert = quantity;
+
+                BrakeSpecificFuelConsumption convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<BrakeSpecificFuelConsumptionUnit> quantityToConvert = quantity;
+
+                IQuantity<BrakeSpecificFuelConsumptionUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new BrakeSpecificFuelConsumption(value: 1, unit: BrakeSpecificFuelConsumption.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new BrakeSpecificFuelConsumption(value: 1, unit: BrakeSpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<BrakeSpecificFuelConsumptionUnit> quantity = new BrakeSpecificFuelConsumption(value: 1, unit: BrakeSpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new BrakeSpecificFuelConsumption(value: 1, unit: BrakeSpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new BrakeSpecificFuelConsumption(value: 1, unit: BrakeSpecificFuelConsumption.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new BrakeSpecificFuelConsumption(value: 1, unit: BrakeSpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<BrakeSpecificFuelConsumptionUnit> quantity = new BrakeSpecificFuelConsumption(value: 1, unit: BrakeSpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new BrakeSpecificFuelConsumption(value: 1, unit: BrakeSpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 g/kWh", BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, 4.2)]
         [InlineData("en-US", "4.2 kg/J", BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, 4.2)]
         [InlineData("en-US", "4.2 lb/hph", BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, 4.2)]
-        public void Parse(string culture, string quantityString, BrakeSpecificFuelConsumptionUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, BrakeSpecificFuelConsumptionUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = BrakeSpecificFuelConsumption.Parse(quantityString);
@@ -259,7 +316,7 @@ public void Parse(string culture, string quantityString, BrakeSpecificFuelConsum
         [InlineData("en-US", "4.2 g/kWh", BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, 4.2)]
         [InlineData("en-US", "4.2 kg/J", BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, 4.2)]
         [InlineData("en-US", "4.2 lb/hph", BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, 4.2)]
-        public void TryParse(string culture, string quantityString, BrakeSpecificFuelConsumptionUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, BrakeSpecificFuelConsumptionUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(BrakeSpecificFuelConsumption.TryParse(quantityString, out BrakeSpecificFuelConsumption parsed));
@@ -410,6 +467,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(BrakeSpecificFue
                 var quantity = BrakeSpecificFuelConsumption.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -433,34 +491,36 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(BrakeSpecificFuelCo
                 IQuantity<BrakeSpecificFuelConsumptionUnit> quantityToConvert = quantity;
                 IQuantity<BrakeSpecificFuelConsumptionUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            BrakeSpecificFuelConsumption kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
-            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(kilogramperjoule.GramsPerKiloWattHour).KilogramsPerJoule, GramsPerKiloWattHourTolerance);
-            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption.FromKilogramsPerJoule(kilogramperjoule.KilogramsPerJoule).KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(1, BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(kilogramperjoule.PoundsPerMechanicalHorsepowerHour).KilogramsPerJoule, PoundsPerMechanicalHorsepowerHourTolerance);
+            BrakeSpecificFuelConsumption kilogramperjoule = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(3);
+            Assert.Equal(3, BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(kilogramperjoule.GramsPerKiloWattHour).KilogramsPerJoule);
+            Assert.Equal(3, BrakeSpecificFuelConsumption.FromKilogramsPerJoule(kilogramperjoule.KilogramsPerJoule).KilogramsPerJoule);
+            Assert.Equal(3, BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(kilogramperjoule.PoundsPerMechanicalHorsepowerHour).KilogramsPerJoule);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             BrakeSpecificFuelConsumption v = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
-            AssertEx.EqualTolerance(-1, -v.KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(2, (BrakeSpecificFuelConsumption.FromKilogramsPerJoule(3)-v).KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(2, (BrakeSpecificFuelConsumption.FromKilogramsPerJoule(10)/5).KilogramsPerJoule, KilogramsPerJouleTolerance);
-            AssertEx.EqualTolerance(2, BrakeSpecificFuelConsumption.FromKilogramsPerJoule(10)/BrakeSpecificFuelConsumption.FromKilogramsPerJoule(5), KilogramsPerJouleTolerance);
+            Assert.Equal(-1, -v.KilogramsPerJoule);
+            Assert.Equal(2, (BrakeSpecificFuelConsumption.FromKilogramsPerJoule(3) - v).KilogramsPerJoule);
+            Assert.Equal(2, (v + v).KilogramsPerJoule);
+            Assert.Equal(10, (v * 10).KilogramsPerJoule);
+            Assert.Equal(10, (10 * v).KilogramsPerJoule);
+            Assert.Equal(2, (BrakeSpecificFuelConsumption.FromKilogramsPerJoule(10) / 5).KilogramsPerJoule);
+            Assert.Equal(2, BrakeSpecificFuelConsumption.FromKilogramsPerJoule(10) / BrakeSpecificFuelConsumption.FromKilogramsPerJoule(5));
         }
 
         [Fact]
@@ -506,8 +566,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, 1, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, true)]  // Same value and unit.
         [InlineData(1, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, 2, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, false)] // Different value.
-        [InlineData(2, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, 1, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, false)] // Different value and unit.
-        [InlineData(1, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, 1, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, BrakeSpecificFuelConsumptionUnit unitA, double valueB, BrakeSpecificFuelConsumptionUnit unitB, bool expectEqual)
         {
             var a = new BrakeSpecificFuelConsumption(valueA, unitA);
@@ -567,8 +625,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(firstValue);
             var otherQuantity = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(secondValue);
             BrakeSpecificFuelConsumption maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, BrakeSpecificFuelConsumption.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -587,7 +645,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<BrakeSpecificFuelConsumptionUnit>();
+            var units = EnumHelper.GetValues<BrakeSpecificFuelConsumptionUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -600,6 +658,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(BrakeSpecificFuelConsumption.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(BrakeSpecificFuelConsumption.Info.Units, BrakeSpecificFuelConsumption.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, BrakeSpecificFuelConsumption.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -620,26 +690,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 lb/hph", new BrakeSpecificFuelConsumption(1, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 kg/J", new BrakeSpecificFuelConsumption(0.123456, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule).ToString("s1"));
-            Assert.Equal("0.12 kg/J", new BrakeSpecificFuelConsumption(0.123456, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule).ToString("s2"));
-            Assert.Equal("0.123 kg/J", new BrakeSpecificFuelConsumption(0.123456, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule).ToString("s3"));
-            Assert.Equal("0.1235 kg/J", new BrakeSpecificFuelConsumption(0.123456, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 kg/J", new BrakeSpecificFuelConsumption(0.123456, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule).ToString("s1", culture));
-            Assert.Equal("0.12 kg/J", new BrakeSpecificFuelConsumption(0.123456, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule).ToString("s2", culture));
-            Assert.Equal("0.123 kg/J", new BrakeSpecificFuelConsumption(0.123456, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule).ToString("s3", culture));
-            Assert.Equal("0.1235 kg/J", new BrakeSpecificFuelConsumption(0.123456, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -666,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(BrakeSpecificFuelConsumption), quantity.As(BrakeSpecificFuelConsumption.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs
index 26119fec3c..b5d024a461 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/CoefficientOfThermalExpansionTestsBase.g.cs
@@ -145,6 +145,20 @@ public void CoefficientOfThermalExpansion_QuantityInfo_ReturnsQuantityInfoDescri
             Assert.Equal(quantityInfo, ((IQuantity<CoefficientOfThermalExpansionUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void CoefficientOfThermalExpansionInfo_CreateWithCustomUnitInfos()
+        {
+            CoefficientOfThermalExpansionUnit[] expectedUnits = [CoefficientOfThermalExpansionUnit.PerKelvin];
+
+            CoefficientOfThermalExpansion.CoefficientOfThermalExpansionInfo quantityInfo = CoefficientOfThermalExpansion.CoefficientOfThermalExpansionInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("CoefficientOfThermalExpansion", quantityInfo.Name);
+            Assert.Equal(CoefficientOfThermalExpansion.Zero, quantityInfo.Zero);
+            Assert.Equal(CoefficientOfThermalExpansion.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void PerKelvinToCoefficientOfThermalExpansionUnits()
         {
@@ -239,26 +253,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = CoefficientOfThermalExpansion.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            CoefficientOfThermalExpansion convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                CoefficientOfThermalExpansion quantityToConvert = quantity;
+
+                CoefficientOfThermalExpansion convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<CoefficientOfThermalExpansionUnit> quantityToConvert = quantity;
+
+                IQuantity<CoefficientOfThermalExpansionUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new CoefficientOfThermalExpansion(value: 1, unit: CoefficientOfThermalExpansion.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new CoefficientOfThermalExpansion(value: 1, unit: CoefficientOfThermalExpansion.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<CoefficientOfThermalExpansionUnit> quantity = new CoefficientOfThermalExpansion(value: 1, unit: CoefficientOfThermalExpansion.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new CoefficientOfThermalExpansion(value: 1, unit: CoefficientOfThermalExpansion.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new CoefficientOfThermalExpansion(value: 1, unit: CoefficientOfThermalExpansion.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new CoefficientOfThermalExpansion(value: 1, unit: CoefficientOfThermalExpansion.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<CoefficientOfThermalExpansionUnit> quantity = new CoefficientOfThermalExpansion(value: 1, unit: CoefficientOfThermalExpansion.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new CoefficientOfThermalExpansion(value: 1, unit: CoefficientOfThermalExpansion.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -268,7 +325,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 ppm/°C", CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 ppm/°F", CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit, 4.2)]
         [InlineData("en-US", "4.2 ppm/K", CoefficientOfThermalExpansionUnit.PpmPerKelvin, 4.2)]
-        public void Parse(string culture, string quantityString, CoefficientOfThermalExpansionUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, CoefficientOfThermalExpansionUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = CoefficientOfThermalExpansion.Parse(quantityString);
@@ -283,7 +340,7 @@ public void Parse(string culture, string quantityString, CoefficientOfThermalExp
         [InlineData("en-US", "4.2 ppm/°C", CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 ppm/°F", CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit, 4.2)]
         [InlineData("en-US", "4.2 ppm/K", CoefficientOfThermalExpansionUnit.PpmPerKelvin, 4.2)]
-        public void TryParse(string culture, string quantityString, CoefficientOfThermalExpansionUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, CoefficientOfThermalExpansionUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(CoefficientOfThermalExpansion.TryParse(quantityString, out CoefficientOfThermalExpansion parsed));
@@ -461,6 +518,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(CoefficientOfThe
                 var quantity = CoefficientOfThermalExpansion.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -484,37 +542,39 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(CoefficientOfTherma
                 IQuantity<CoefficientOfThermalExpansionUnit> quantityToConvert = quantity;
                 IQuantity<CoefficientOfThermalExpansionUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            CoefficientOfThermalExpansion perkelvin = CoefficientOfThermalExpansion.FromPerKelvin(1);
-            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromPerDegreeCelsius(perkelvin.PerDegreeCelsius).PerKelvin, PerDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(perkelvin.PerDegreeFahrenheit).PerKelvin, PerDegreeFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromPerKelvin(perkelvin.PerKelvin).PerKelvin, PerKelvinTolerance);
-            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(perkelvin.PpmPerDegreeCelsius).PerKelvin, PpmPerDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(perkelvin.PpmPerDegreeFahrenheit).PerKelvin, PpmPerDegreeFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, CoefficientOfThermalExpansion.FromPpmPerKelvin(perkelvin.PpmPerKelvin).PerKelvin, PpmPerKelvinTolerance);
+            CoefficientOfThermalExpansion perkelvin = CoefficientOfThermalExpansion.FromPerKelvin(3);
+            Assert.Equal(3, CoefficientOfThermalExpansion.FromPerDegreeCelsius(perkelvin.PerDegreeCelsius).PerKelvin);
+            Assert.Equal(3, CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(perkelvin.PerDegreeFahrenheit).PerKelvin);
+            Assert.Equal(3, CoefficientOfThermalExpansion.FromPerKelvin(perkelvin.PerKelvin).PerKelvin);
+            Assert.Equal(3, CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(perkelvin.PpmPerDegreeCelsius).PerKelvin);
+            Assert.Equal(3, CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(perkelvin.PpmPerDegreeFahrenheit).PerKelvin);
+            Assert.Equal(3, CoefficientOfThermalExpansion.FromPpmPerKelvin(perkelvin.PpmPerKelvin).PerKelvin);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             CoefficientOfThermalExpansion v = CoefficientOfThermalExpansion.FromPerKelvin(1);
-            AssertEx.EqualTolerance(-1, -v.PerKelvin, PerKelvinTolerance);
-            AssertEx.EqualTolerance(2, (CoefficientOfThermalExpansion.FromPerKelvin(3)-v).PerKelvin, PerKelvinTolerance);
-            AssertEx.EqualTolerance(2, (v + v).PerKelvin, PerKelvinTolerance);
-            AssertEx.EqualTolerance(10, (v*10).PerKelvin, PerKelvinTolerance);
-            AssertEx.EqualTolerance(10, (10*v).PerKelvin, PerKelvinTolerance);
-            AssertEx.EqualTolerance(2, (CoefficientOfThermalExpansion.FromPerKelvin(10)/5).PerKelvin, PerKelvinTolerance);
-            AssertEx.EqualTolerance(2, CoefficientOfThermalExpansion.FromPerKelvin(10)/CoefficientOfThermalExpansion.FromPerKelvin(5), PerKelvinTolerance);
+            Assert.Equal(-1, -v.PerKelvin);
+            Assert.Equal(2, (CoefficientOfThermalExpansion.FromPerKelvin(3) - v).PerKelvin);
+            Assert.Equal(2, (v + v).PerKelvin);
+            Assert.Equal(10, (v * 10).PerKelvin);
+            Assert.Equal(10, (10 * v).PerKelvin);
+            Assert.Equal(2, (CoefficientOfThermalExpansion.FromPerKelvin(10) / 5).PerKelvin);
+            Assert.Equal(2, CoefficientOfThermalExpansion.FromPerKelvin(10) / CoefficientOfThermalExpansion.FromPerKelvin(5));
         }
 
         [Fact]
@@ -560,8 +620,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, CoefficientOfThermalExpansionUnit.PerKelvin, 1, CoefficientOfThermalExpansionUnit.PerKelvin, true)]  // Same value and unit.
         [InlineData(1, CoefficientOfThermalExpansionUnit.PerKelvin, 2, CoefficientOfThermalExpansionUnit.PerKelvin, false)] // Different value.
-        [InlineData(2, CoefficientOfThermalExpansionUnit.PerKelvin, 1, CoefficientOfThermalExpansionUnit.PerDegreeCelsius, false)] // Different value and unit.
-        [InlineData(1, CoefficientOfThermalExpansionUnit.PerKelvin, 1, CoefficientOfThermalExpansionUnit.PerDegreeCelsius, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, CoefficientOfThermalExpansionUnit unitA, double valueB, CoefficientOfThermalExpansionUnit unitB, bool expectEqual)
         {
             var a = new CoefficientOfThermalExpansion(valueA, unitA);
@@ -621,8 +679,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = CoefficientOfThermalExpansion.FromPerKelvin(firstValue);
             var otherQuantity = CoefficientOfThermalExpansion.FromPerKelvin(secondValue);
             CoefficientOfThermalExpansion maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, CoefficientOfThermalExpansion.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -641,7 +699,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<CoefficientOfThermalExpansionUnit>();
+            var units = EnumHelper.GetValues<CoefficientOfThermalExpansionUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -654,6 +712,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(CoefficientOfThermalExpansion.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(CoefficientOfThermalExpansion.Info.Units, CoefficientOfThermalExpansion.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, CoefficientOfThermalExpansion.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -680,26 +750,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 ppm/K", new CoefficientOfThermalExpansion(1, CoefficientOfThermalExpansionUnit.PpmPerKelvin).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 K⁻¹", new CoefficientOfThermalExpansion(0.123456, CoefficientOfThermalExpansionUnit.PerKelvin).ToString("s1"));
-            Assert.Equal("0.12 K⁻¹", new CoefficientOfThermalExpansion(0.123456, CoefficientOfThermalExpansionUnit.PerKelvin).ToString("s2"));
-            Assert.Equal("0.123 K⁻¹", new CoefficientOfThermalExpansion(0.123456, CoefficientOfThermalExpansionUnit.PerKelvin).ToString("s3"));
-            Assert.Equal("0.1235 K⁻¹", new CoefficientOfThermalExpansion(0.123456, CoefficientOfThermalExpansionUnit.PerKelvin).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 K⁻¹", new CoefficientOfThermalExpansion(0.123456, CoefficientOfThermalExpansionUnit.PerKelvin).ToString("s1", culture));
-            Assert.Equal("0.12 K⁻¹", new CoefficientOfThermalExpansion(0.123456, CoefficientOfThermalExpansionUnit.PerKelvin).ToString("s2", culture));
-            Assert.Equal("0.123 K⁻¹", new CoefficientOfThermalExpansion(0.123456, CoefficientOfThermalExpansionUnit.PerKelvin).ToString("s3", culture));
-            Assert.Equal("0.1235 K⁻¹", new CoefficientOfThermalExpansion(0.123456, CoefficientOfThermalExpansionUnit.PerKelvin).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -726,7 +776,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = CoefficientOfThermalExpansion.FromPerKelvin(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(CoefficientOfThermalExpansion), quantity.As(CoefficientOfThermalExpansion.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs
index 6069068fc7..6396e13c7d 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs
@@ -149,6 +149,20 @@ public void Compressibility_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<CompressibilityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void CompressibilityInfo_CreateWithCustomUnitInfos()
+        {
+            CompressibilityUnit[] expectedUnits = [CompressibilityUnit.InversePascal];
+
+            Compressibility.CompressibilityInfo quantityInfo = Compressibility.CompressibilityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Compressibility", quantityInfo.Name);
+            Assert.Equal(Compressibility.Zero, quantityInfo.Zero);
+            Assert.Equal(Compressibility.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void InversePascalToCompressibilityUnits()
         {
@@ -245,26 +259,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Compressibility.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Compressibility convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Compressibility quantityToConvert = quantity;
+
+                Compressibility convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<CompressibilityUnit> quantityToConvert = quantity;
+
+                IQuantity<CompressibilityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Compressibility(value: 1, unit: Compressibility.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Compressibility(value: 1, unit: Compressibility.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<CompressibilityUnit> quantity = new Compressibility(value: 1, unit: Compressibility.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Compressibility(value: 1, unit: Compressibility.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Compressibility(value: 1, unit: Compressibility.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Compressibility(value: 1, unit: Compressibility.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<CompressibilityUnit> quantity = new Compressibility(value: 1, unit: Compressibility.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Compressibility(value: 1, unit: Compressibility.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -282,7 +339,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 1/Pa", CompressibilityUnit.InversePascal, 4.2)]
         [InlineData("en-US", "4.2 psi⁻¹", CompressibilityUnit.InversePoundForcePerSquareInch, 4.2)]
         [InlineData("en-US", "4.2 1/psi", CompressibilityUnit.InversePoundForcePerSquareInch, 4.2)]
-        public void Parse(string culture, string quantityString, CompressibilityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, CompressibilityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Compressibility.Parse(quantityString);
@@ -305,7 +362,7 @@ public void Parse(string culture, string quantityString, CompressibilityUnit exp
         [InlineData("en-US", "4.2 1/Pa", CompressibilityUnit.InversePascal, 4.2)]
         [InlineData("en-US", "4.2 psi⁻¹", CompressibilityUnit.InversePoundForcePerSquareInch, 4.2)]
         [InlineData("en-US", "4.2 1/psi", CompressibilityUnit.InversePoundForcePerSquareInch, 4.2)]
-        public void TryParse(string culture, string quantityString, CompressibilityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, CompressibilityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Compressibility.TryParse(quantityString, out Compressibility parsed));
@@ -548,6 +605,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(CompressibilityU
                 var quantity = Compressibility.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -571,38 +629,40 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(CompressibilityUnit
                 IQuantity<CompressibilityUnit> quantityToConvert = quantity;
                 IQuantity<CompressibilityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Compressibility inversepascal = Compressibility.FromInversePascals(1);
-            AssertEx.EqualTolerance(1, Compressibility.FromInverseAtmospheres(inversepascal.InverseAtmospheres).InversePascals, InverseAtmospheresTolerance);
-            AssertEx.EqualTolerance(1, Compressibility.FromInverseBars(inversepascal.InverseBars).InversePascals, InverseBarsTolerance);
-            AssertEx.EqualTolerance(1, Compressibility.FromInverseKilopascals(inversepascal.InverseKilopascals).InversePascals, InverseKilopascalsTolerance);
-            AssertEx.EqualTolerance(1, Compressibility.FromInverseMegapascals(inversepascal.InverseMegapascals).InversePascals, InverseMegapascalsTolerance);
-            AssertEx.EqualTolerance(1, Compressibility.FromInverseMillibars(inversepascal.InverseMillibars).InversePascals, InverseMillibarsTolerance);
-            AssertEx.EqualTolerance(1, Compressibility.FromInversePascals(inversepascal.InversePascals).InversePascals, InversePascalsTolerance);
-            AssertEx.EqualTolerance(1, Compressibility.FromInversePoundsForcePerSquareInch(inversepascal.InversePoundsForcePerSquareInch).InversePascals, InversePoundsForcePerSquareInchTolerance);
+            Compressibility inversepascal = Compressibility.FromInversePascals(3);
+            Assert.Equal(3, Compressibility.FromInverseAtmospheres(inversepascal.InverseAtmospheres).InversePascals);
+            Assert.Equal(3, Compressibility.FromInverseBars(inversepascal.InverseBars).InversePascals);
+            Assert.Equal(3, Compressibility.FromInverseKilopascals(inversepascal.InverseKilopascals).InversePascals);
+            Assert.Equal(3, Compressibility.FromInverseMegapascals(inversepascal.InverseMegapascals).InversePascals);
+            Assert.Equal(3, Compressibility.FromInverseMillibars(inversepascal.InverseMillibars).InversePascals);
+            Assert.Equal(3, Compressibility.FromInversePascals(inversepascal.InversePascals).InversePascals);
+            Assert.Equal(3, Compressibility.FromInversePoundsForcePerSquareInch(inversepascal.InversePoundsForcePerSquareInch).InversePascals);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Compressibility v = Compressibility.FromInversePascals(1);
-            AssertEx.EqualTolerance(-1, -v.InversePascals, InversePascalsTolerance);
-            AssertEx.EqualTolerance(2, (Compressibility.FromInversePascals(3)-v).InversePascals, InversePascalsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).InversePascals, InversePascalsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).InversePascals, InversePascalsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).InversePascals, InversePascalsTolerance);
-            AssertEx.EqualTolerance(2, (Compressibility.FromInversePascals(10)/5).InversePascals, InversePascalsTolerance);
-            AssertEx.EqualTolerance(2, Compressibility.FromInversePascals(10)/Compressibility.FromInversePascals(5), InversePascalsTolerance);
+            Assert.Equal(-1, -v.InversePascals);
+            Assert.Equal(2, (Compressibility.FromInversePascals(3) - v).InversePascals);
+            Assert.Equal(2, (v + v).InversePascals);
+            Assert.Equal(10, (v * 10).InversePascals);
+            Assert.Equal(10, (10 * v).InversePascals);
+            Assert.Equal(2, (Compressibility.FromInversePascals(10) / 5).InversePascals);
+            Assert.Equal(2, Compressibility.FromInversePascals(10) / Compressibility.FromInversePascals(5));
         }
 
         [Fact]
@@ -648,8 +708,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, CompressibilityUnit.InversePascal, 1, CompressibilityUnit.InversePascal, true)]  // Same value and unit.
         [InlineData(1, CompressibilityUnit.InversePascal, 2, CompressibilityUnit.InversePascal, false)] // Different value.
-        [InlineData(2, CompressibilityUnit.InversePascal, 1, CompressibilityUnit.InverseAtmosphere, false)] // Different value and unit.
-        [InlineData(1, CompressibilityUnit.InversePascal, 1, CompressibilityUnit.InverseAtmosphere, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, CompressibilityUnit unitA, double valueB, CompressibilityUnit unitB, bool expectEqual)
         {
             var a = new Compressibility(valueA, unitA);
@@ -709,8 +767,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Compressibility.FromInversePascals(firstValue);
             var otherQuantity = Compressibility.FromInversePascals(secondValue);
             Compressibility maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Compressibility.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -729,7 +787,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<CompressibilityUnit>();
+            var units = EnumHelper.GetValues<CompressibilityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -742,6 +800,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Compressibility.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Compressibility.Info.Units, Compressibility.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Compressibility.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -770,26 +840,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 psi⁻¹", new Compressibility(1, CompressibilityUnit.InversePoundForcePerSquareInch).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s1"));
-            Assert.Equal("0.12 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s2"));
-            Assert.Equal("0.123 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s3"));
-            Assert.Equal("0.1235 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s1", culture));
-            Assert.Equal("0.12 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s2", culture));
-            Assert.Equal("0.123 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s3", culture));
-            Assert.Equal("0.1235 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -816,7 +866,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Compressibility.FromInversePascals(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Compressibility), quantity.As(Compressibility.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs
index 77efc0fcc8..1871d518a3 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs
@@ -345,6 +345,20 @@ public void Density_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<DensityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void DensityInfo_CreateWithCustomUnitInfos()
+        {
+            DensityUnit[] expectedUnits = [DensityUnit.KilogramPerCubicMeter];
+
+            Density.DensityInfo quantityInfo = Density.DensityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Density", quantityInfo.Name);
+            Assert.Equal(Density.Zero, quantityInfo.Zero);
+            Assert.Equal(Density.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KilogramPerCubicMeterToDensityUnits()
         {
@@ -539,26 +553,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Density.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Density convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Density quantityToConvert = quantity;
+
+                Density convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<DensityUnit> quantityToConvert = quantity;
+
+                IQuantity<DensityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Density(value: 1, unit: Density.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Density(value: 1, unit: Density.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<DensityUnit> quantity = new Density(value: 1, unit: Density.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Density(value: 1, unit: Density.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Density(value: 1, unit: Density.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Density(value: 1, unit: Density.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<DensityUnit> quantity = new Density(value: 1, unit: Density.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Density(value: 1, unit: Density.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -628,7 +685,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 кг/м³", DensityUnit.KilogramPerCubicMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мкг/м³", DensityUnit.MicrogramPerCubicMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мг/м³", DensityUnit.MilligramPerCubicMeter, 4.2)]
-        public void Parse(string culture, string quantityString, DensityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, DensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Density.Parse(quantityString);
@@ -703,7 +760,7 @@ public void Parse(string culture, string quantityString, DensityUnit expectedUni
         [InlineData("ru-RU", "4,2 кг/м³", DensityUnit.KilogramPerCubicMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мкг/м³", DensityUnit.MicrogramPerCubicMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мг/м³", DensityUnit.MilligramPerCubicMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, DensityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, DensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Density.TryParse(quantityString, out Density parsed));
@@ -1399,6 +1456,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(DensityUnit unit
                 var quantity = Density.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1422,87 +1480,89 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(DensityUnit unit)
                 IQuantity<DensityUnit> quantityToConvert = quantity;
                 IQuantity<DensityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, Density.FromCentigramsPerDeciliter(kilogrampercubicmeter.CentigramsPerDeciliter).KilogramsPerCubicMeter, CentigramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromCentigramsPerLiter(kilogrampercubicmeter.CentigramsPerLiter).KilogramsPerCubicMeter, CentigramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromCentigramsPerMilliliter(kilogrampercubicmeter.CentigramsPerMilliliter).KilogramsPerCubicMeter, CentigramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromDecigramsPerDeciliter(kilogrampercubicmeter.DecigramsPerDeciliter).KilogramsPerCubicMeter, DecigramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromDecigramsPerLiter(kilogrampercubicmeter.DecigramsPerLiter).KilogramsPerCubicMeter, DecigramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromDecigramsPerMilliliter(kilogrampercubicmeter.DecigramsPerMilliliter).KilogramsPerCubicMeter, DecigramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromFemtogramsPerDeciliter(kilogrampercubicmeter.FemtogramsPerDeciliter).KilogramsPerCubicMeter, FemtogramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromFemtogramsPerLiter(kilogrampercubicmeter.FemtogramsPerLiter).KilogramsPerCubicMeter, FemtogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromFemtogramsPerMilliliter(kilogrampercubicmeter.FemtogramsPerMilliliter).KilogramsPerCubicMeter, FemtogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerCubicCentimeter(kilogrampercubicmeter.GramsPerCubicCentimeter).KilogramsPerCubicMeter, GramsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerCubicFoot(kilogrampercubicmeter.GramsPerCubicFoot).KilogramsPerCubicMeter, GramsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerCubicInch(kilogrampercubicmeter.GramsPerCubicInch).KilogramsPerCubicMeter, GramsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerCubicMeter(kilogrampercubicmeter.GramsPerCubicMeter).KilogramsPerCubicMeter, GramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerCubicMillimeter(kilogrampercubicmeter.GramsPerCubicMillimeter).KilogramsPerCubicMeter, GramsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerDeciliter(kilogrampercubicmeter.GramsPerDeciliter).KilogramsPerCubicMeter, GramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerLiter(kilogrampercubicmeter.GramsPerLiter).KilogramsPerCubicMeter, GramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromGramsPerMilliliter(kilogrampercubicmeter.GramsPerMilliliter).KilogramsPerCubicMeter, GramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilogramsPerCubicCentimeter(kilogrampercubicmeter.KilogramsPerCubicCentimeter).KilogramsPerCubicMeter, KilogramsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilogramsPerCubicMeter(kilogrampercubicmeter.KilogramsPerCubicMeter).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilogramsPerCubicMillimeter(kilogrampercubicmeter.KilogramsPerCubicMillimeter).KilogramsPerCubicMeter, KilogramsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilogramsPerLiter(kilogrampercubicmeter.KilogramsPerLiter).KilogramsPerCubicMeter, KilogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilopoundsPerCubicFoot(kilogrampercubicmeter.KilopoundsPerCubicFoot).KilogramsPerCubicMeter, KilopoundsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilopoundsPerCubicInch(kilogrampercubicmeter.KilopoundsPerCubicInch).KilogramsPerCubicMeter, KilopoundsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, Density.FromKilopoundsPerCubicYard(kilogrampercubicmeter.KilopoundsPerCubicYard).KilogramsPerCubicMeter, KilopoundsPerCubicYardTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMicrogramsPerCubicMeter(kilogrampercubicmeter.MicrogramsPerCubicMeter).KilogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMicrogramsPerDeciliter(kilogrampercubicmeter.MicrogramsPerDeciliter).KilogramsPerCubicMeter, MicrogramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMicrogramsPerLiter(kilogrampercubicmeter.MicrogramsPerLiter).KilogramsPerCubicMeter, MicrogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMicrogramsPerMilliliter(kilogrampercubicmeter.MicrogramsPerMilliliter).KilogramsPerCubicMeter, MicrogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMilligramsPerCubicMeter(kilogrampercubicmeter.MilligramsPerCubicMeter).KilogramsPerCubicMeter, MilligramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMilligramsPerDeciliter(kilogrampercubicmeter.MilligramsPerDeciliter).KilogramsPerCubicMeter, MilligramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMilligramsPerLiter(kilogrampercubicmeter.MilligramsPerLiter).KilogramsPerCubicMeter, MilligramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromMilligramsPerMilliliter(kilogrampercubicmeter.MilligramsPerMilliliter).KilogramsPerCubicMeter, MilligramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromNanogramsPerDeciliter(kilogrampercubicmeter.NanogramsPerDeciliter).KilogramsPerCubicMeter, NanogramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromNanogramsPerLiter(kilogrampercubicmeter.NanogramsPerLiter).KilogramsPerCubicMeter, NanogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromNanogramsPerMilliliter(kilogrampercubicmeter.NanogramsPerMilliliter).KilogramsPerCubicMeter, NanogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPicogramsPerDeciliter(kilogrampercubicmeter.PicogramsPerDeciliter).KilogramsPerCubicMeter, PicogramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter, PicogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPicogramsPerMilliliter(kilogrampercubicmeter.PicogramsPerMilliliter).KilogramsPerCubicMeter, PicogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicCentimeter(kilogrampercubicmeter.PoundsPerCubicCentimeter).KilogramsPerCubicMeter, PoundsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicFoot(kilogrampercubicmeter.PoundsPerCubicFoot).KilogramsPerCubicMeter, PoundsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicInch(kilogrampercubicmeter.PoundsPerCubicInch).KilogramsPerCubicMeter, PoundsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicMeter(kilogrampercubicmeter.PoundsPerCubicMeter).KilogramsPerCubicMeter, PoundsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicMillimeter(kilogrampercubicmeter.PoundsPerCubicMillimeter).KilogramsPerCubicMeter, PoundsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicYard(kilogrampercubicmeter.PoundsPerCubicYard).KilogramsPerCubicMeter, PoundsPerCubicYardTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerImperialGallon(kilogrampercubicmeter.PoundsPerImperialGallon).KilogramsPerCubicMeter, PoundsPerImperialGallonTolerance);
-            AssertEx.EqualTolerance(1, Density.FromPoundsPerUSGallon(kilogrampercubicmeter.PoundsPerUSGallon).KilogramsPerCubicMeter, PoundsPerUSGallonTolerance);
-            AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicCentimeter(kilogrampercubicmeter.SlugsPerCubicCentimeter).KilogramsPerCubicMeter, SlugsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicFoot(kilogrampercubicmeter.SlugsPerCubicFoot).KilogramsPerCubicMeter, SlugsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicInch(kilogrampercubicmeter.SlugsPerCubicInch).KilogramsPerCubicMeter, SlugsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicMeter(kilogrampercubicmeter.SlugsPerCubicMeter).KilogramsPerCubicMeter, SlugsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromSlugsPerCubicMillimeter(kilogrampercubicmeter.SlugsPerCubicMillimeter).KilogramsPerCubicMeter, SlugsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicCentimeter(kilogrampercubicmeter.TonnesPerCubicCentimeter).KilogramsPerCubicMeter, TonnesPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicFoot(kilogrampercubicmeter.TonnesPerCubicFoot).KilogramsPerCubicMeter, TonnesPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicInch(kilogrampercubicmeter.TonnesPerCubicInch).KilogramsPerCubicMeter, TonnesPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicMeter(kilogrampercubicmeter.TonnesPerCubicMeter).KilogramsPerCubicMeter, TonnesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Density.FromTonnesPerCubicMillimeter(kilogrampercubicmeter.TonnesPerCubicMillimeter).KilogramsPerCubicMeter, TonnesPerCubicMillimeterTolerance);
+            Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(3);
+            Assert.Equal(3, Density.FromCentigramsPerDeciliter(kilogrampercubicmeter.CentigramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromCentigramsPerLiter(kilogrampercubicmeter.CentigramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromCentigramsPerMilliliter(kilogrampercubicmeter.CentigramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromDecigramsPerDeciliter(kilogrampercubicmeter.DecigramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromDecigramsPerLiter(kilogrampercubicmeter.DecigramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromDecigramsPerMilliliter(kilogrampercubicmeter.DecigramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromFemtogramsPerDeciliter(kilogrampercubicmeter.FemtogramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromFemtogramsPerLiter(kilogrampercubicmeter.FemtogramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromFemtogramsPerMilliliter(kilogrampercubicmeter.FemtogramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromGramsPerCubicCentimeter(kilogrampercubicmeter.GramsPerCubicCentimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromGramsPerCubicFoot(kilogrampercubicmeter.GramsPerCubicFoot).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromGramsPerCubicInch(kilogrampercubicmeter.GramsPerCubicInch).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromGramsPerCubicMeter(kilogrampercubicmeter.GramsPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromGramsPerCubicMillimeter(kilogrampercubicmeter.GramsPerCubicMillimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromGramsPerDeciliter(kilogrampercubicmeter.GramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromGramsPerLiter(kilogrampercubicmeter.GramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromGramsPerMilliliter(kilogrampercubicmeter.GramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromKilogramsPerCubicCentimeter(kilogrampercubicmeter.KilogramsPerCubicCentimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromKilogramsPerCubicMeter(kilogrampercubicmeter.KilogramsPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromKilogramsPerCubicMillimeter(kilogrampercubicmeter.KilogramsPerCubicMillimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromKilogramsPerLiter(kilogrampercubicmeter.KilogramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromKilopoundsPerCubicFoot(kilogrampercubicmeter.KilopoundsPerCubicFoot).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromKilopoundsPerCubicInch(kilogrampercubicmeter.KilopoundsPerCubicInch).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromKilopoundsPerCubicYard(kilogrampercubicmeter.KilopoundsPerCubicYard).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromMicrogramsPerCubicMeter(kilogrampercubicmeter.MicrogramsPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromMicrogramsPerDeciliter(kilogrampercubicmeter.MicrogramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromMicrogramsPerLiter(kilogrampercubicmeter.MicrogramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromMicrogramsPerMilliliter(kilogrampercubicmeter.MicrogramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromMilligramsPerCubicMeter(kilogrampercubicmeter.MilligramsPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromMilligramsPerDeciliter(kilogrampercubicmeter.MilligramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromMilligramsPerLiter(kilogrampercubicmeter.MilligramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromMilligramsPerMilliliter(kilogrampercubicmeter.MilligramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromNanogramsPerDeciliter(kilogrampercubicmeter.NanogramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromNanogramsPerLiter(kilogrampercubicmeter.NanogramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromNanogramsPerMilliliter(kilogrampercubicmeter.NanogramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPicogramsPerDeciliter(kilogrampercubicmeter.PicogramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPicogramsPerMilliliter(kilogrampercubicmeter.PicogramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPoundsPerCubicCentimeter(kilogrampercubicmeter.PoundsPerCubicCentimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPoundsPerCubicFoot(kilogrampercubicmeter.PoundsPerCubicFoot).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPoundsPerCubicInch(kilogrampercubicmeter.PoundsPerCubicInch).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPoundsPerCubicMeter(kilogrampercubicmeter.PoundsPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPoundsPerCubicMillimeter(kilogrampercubicmeter.PoundsPerCubicMillimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPoundsPerCubicYard(kilogrampercubicmeter.PoundsPerCubicYard).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPoundsPerImperialGallon(kilogrampercubicmeter.PoundsPerImperialGallon).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromPoundsPerUSGallon(kilogrampercubicmeter.PoundsPerUSGallon).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromSlugsPerCubicCentimeter(kilogrampercubicmeter.SlugsPerCubicCentimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromSlugsPerCubicFoot(kilogrampercubicmeter.SlugsPerCubicFoot).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromSlugsPerCubicInch(kilogrampercubicmeter.SlugsPerCubicInch).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromSlugsPerCubicMeter(kilogrampercubicmeter.SlugsPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromSlugsPerCubicMillimeter(kilogrampercubicmeter.SlugsPerCubicMillimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromTonnesPerCubicCentimeter(kilogrampercubicmeter.TonnesPerCubicCentimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromTonnesPerCubicFoot(kilogrampercubicmeter.TonnesPerCubicFoot).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromTonnesPerCubicInch(kilogrampercubicmeter.TonnesPerCubicInch).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromTonnesPerCubicMeter(kilogrampercubicmeter.TonnesPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, Density.FromTonnesPerCubicMillimeter(kilogrampercubicmeter.TonnesPerCubicMillimeter).KilogramsPerCubicMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Density v = Density.FromKilogramsPerCubicMeter(1);
-            AssertEx.EqualTolerance(-1, -v.KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (Density.FromKilogramsPerCubicMeter(3)-v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (Density.FromKilogramsPerCubicMeter(10)/5).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, Density.FromKilogramsPerCubicMeter(10)/Density.FromKilogramsPerCubicMeter(5), KilogramsPerCubicMeterTolerance);
+            Assert.Equal(-1, -v.KilogramsPerCubicMeter);
+            Assert.Equal(2, (Density.FromKilogramsPerCubicMeter(3) - v).KilogramsPerCubicMeter);
+            Assert.Equal(2, (v + v).KilogramsPerCubicMeter);
+            Assert.Equal(10, (v * 10).KilogramsPerCubicMeter);
+            Assert.Equal(10, (10 * v).KilogramsPerCubicMeter);
+            Assert.Equal(2, (Density.FromKilogramsPerCubicMeter(10) / 5).KilogramsPerCubicMeter);
+            Assert.Equal(2, Density.FromKilogramsPerCubicMeter(10) / Density.FromKilogramsPerCubicMeter(5));
         }
 
         [Fact]
@@ -1548,8 +1608,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, DensityUnit.KilogramPerCubicMeter, 1, DensityUnit.KilogramPerCubicMeter, true)]  // Same value and unit.
         [InlineData(1, DensityUnit.KilogramPerCubicMeter, 2, DensityUnit.KilogramPerCubicMeter, false)] // Different value.
-        [InlineData(2, DensityUnit.KilogramPerCubicMeter, 1, DensityUnit.CentigramPerDeciliter, false)] // Different value and unit.
-        [InlineData(1, DensityUnit.KilogramPerCubicMeter, 1, DensityUnit.CentigramPerDeciliter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, DensityUnit unitA, double valueB, DensityUnit unitB, bool expectEqual)
         {
             var a = new Density(valueA, unitA);
@@ -1609,8 +1667,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Density.FromKilogramsPerCubicMeter(firstValue);
             var otherQuantity = Density.FromKilogramsPerCubicMeter(secondValue);
             Density maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Density.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1629,7 +1687,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<DensityUnit>();
+            var units = EnumHelper.GetValues<DensityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1642,6 +1700,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Density.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Density.Info.Units, Density.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Density.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1768,26 +1838,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 t/mm³", new Density(1, DensityUnit.TonnePerCubicMillimeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 kg/m³", new Density(0.123456, DensityUnit.KilogramPerCubicMeter).ToString("s1"));
-            Assert.Equal("0.12 kg/m³", new Density(0.123456, DensityUnit.KilogramPerCubicMeter).ToString("s2"));
-            Assert.Equal("0.123 kg/m³", new Density(0.123456, DensityUnit.KilogramPerCubicMeter).ToString("s3"));
-            Assert.Equal("0.1235 kg/m³", new Density(0.123456, DensityUnit.KilogramPerCubicMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 kg/m³", new Density(0.123456, DensityUnit.KilogramPerCubicMeter).ToString("s1", culture));
-            Assert.Equal("0.12 kg/m³", new Density(0.123456, DensityUnit.KilogramPerCubicMeter).ToString("s2", culture));
-            Assert.Equal("0.123 kg/m³", new Density(0.123456, DensityUnit.KilogramPerCubicMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 kg/m³", new Density(0.123456, DensityUnit.KilogramPerCubicMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1814,7 +1864,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Density.FromKilogramsPerCubicMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Density), quantity.As(Density.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DoseAreaProductTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DoseAreaProductTestsBase.g.cs
index 61ab4c58b2..9cc4ce697a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/DoseAreaProductTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DoseAreaProductTestsBase.g.cs
@@ -221,6 +221,20 @@ public void DoseAreaProduct_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<DoseAreaProductUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void DoseAreaProductInfo_CreateWithCustomUnitInfos()
+        {
+            DoseAreaProductUnit[] expectedUnits = [DoseAreaProductUnit.GraySquareMeter];
+
+            DoseAreaProduct.DoseAreaProductInfo quantityInfo = DoseAreaProduct.DoseAreaProductInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("DoseAreaProduct", quantityInfo.Name);
+            Assert.Equal(DoseAreaProduct.Zero, quantityInfo.Zero);
+            Assert.Equal(DoseAreaProduct.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void GraySquareMeterToDoseAreaProductUnits()
         {
@@ -353,26 +367,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = DoseAreaProduct.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            DoseAreaProduct convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                DoseAreaProduct quantityToConvert = quantity;
+
+                DoseAreaProduct convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<DoseAreaProductUnit> quantityToConvert = quantity;
+
+                IQuantity<DoseAreaProductUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new DoseAreaProduct(value: 1, unit: DoseAreaProduct.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new DoseAreaProduct(value: 1, unit: DoseAreaProduct.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<DoseAreaProductUnit> quantity = new DoseAreaProduct(value: 1, unit: DoseAreaProduct.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new DoseAreaProduct(value: 1, unit: DoseAreaProduct.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new DoseAreaProduct(value: 1, unit: DoseAreaProduct.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new DoseAreaProduct(value: 1, unit: DoseAreaProduct.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<DoseAreaProductUnit> quantity = new DoseAreaProduct(value: 1, unit: DoseAreaProduct.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new DoseAreaProduct(value: 1, unit: DoseAreaProduct.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -426,7 +483,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 мГр·м²", DoseAreaProductUnit.MilligraySquareMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мГр·мкм²", DoseAreaProductUnit.MilligraySquareMicrometer, 4.2)]
         [InlineData("ru-RU", "4,2 мГр·мм²", DoseAreaProductUnit.MilligraySquareMillimeter, 4.2)]
-        public void Parse(string culture, string quantityString, DoseAreaProductUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, DoseAreaProductUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = DoseAreaProduct.Parse(quantityString);
@@ -485,7 +542,7 @@ public void Parse(string culture, string quantityString, DoseAreaProductUnit exp
         [InlineData("ru-RU", "4,2 мГр·м²", DoseAreaProductUnit.MilligraySquareMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мГр·мкм²", DoseAreaProductUnit.MilligraySquareMicrometer, 4.2)]
         [InlineData("ru-RU", "4,2 мГр·мм²", DoseAreaProductUnit.MilligraySquareMillimeter, 4.2)]
-        public void TryParse(string culture, string quantityString, DoseAreaProductUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, DoseAreaProductUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(DoseAreaProduct.TryParse(quantityString, out DoseAreaProduct parsed));
@@ -959,6 +1016,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(DoseAreaProductU
                 var quantity = DoseAreaProduct.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -982,56 +1040,58 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(DoseAreaProductUnit
                 IQuantity<DoseAreaProductUnit> quantityToConvert = quantity;
                 IQuantity<DoseAreaProductUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            DoseAreaProduct graysquaremeter = DoseAreaProduct.FromGraySquareMeters(1);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromCentigraySquareCentimeters(graysquaremeter.CentigraySquareCentimeters).GraySquareMeters, CentigraySquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromCentigraySquareDecimeters(graysquaremeter.CentigraySquareDecimeters).GraySquareMeters, CentigraySquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromCentigraySquareMeters(graysquaremeter.CentigraySquareMeters).GraySquareMeters, CentigraySquareMetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromCentigraySquareMicrometers(graysquaremeter.CentigraySquareMicrometers).GraySquareMeters, CentigraySquareMicrometersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromCentigraySquareMillimeters(graysquaremeter.CentigraySquareMillimeters).GraySquareMeters, CentigraySquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromDecigraySquareCentimeters(graysquaremeter.DecigraySquareCentimeters).GraySquareMeters, DecigraySquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromDecigraySquareDecimeters(graysquaremeter.DecigraySquareDecimeters).GraySquareMeters, DecigraySquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromDecigraySquareMeters(graysquaremeter.DecigraySquareMeters).GraySquareMeters, DecigraySquareMetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromDecigraySquareMicrometers(graysquaremeter.DecigraySquareMicrometers).GraySquareMeters, DecigraySquareMicrometersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromDecigraySquareMillimeters(graysquaremeter.DecigraySquareMillimeters).GraySquareMeters, DecigraySquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromGraySquareCentimeters(graysquaremeter.GraySquareCentimeters).GraySquareMeters, GraySquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromGraySquareDecimeters(graysquaremeter.GraySquareDecimeters).GraySquareMeters, GraySquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromGraySquareMeters(graysquaremeter.GraySquareMeters).GraySquareMeters, GraySquareMetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromGraySquareMicrometers(graysquaremeter.GraySquareMicrometers).GraySquareMeters, GraySquareMicrometersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromGraySquareMillimeters(graysquaremeter.GraySquareMillimeters).GraySquareMeters, GraySquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromMicrograySquareCentimeters(graysquaremeter.MicrograySquareCentimeters).GraySquareMeters, MicrograySquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromMicrograySquareDecimeters(graysquaremeter.MicrograySquareDecimeters).GraySquareMeters, MicrograySquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromMicrograySquareMeters(graysquaremeter.MicrograySquareMeters).GraySquareMeters, MicrograySquareMetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromMicrograySquareMicrometers(graysquaremeter.MicrograySquareMicrometers).GraySquareMeters, MicrograySquareMicrometersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromMicrograySquareMillimeters(graysquaremeter.MicrograySquareMillimeters).GraySquareMeters, MicrograySquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromMilligraySquareCentimeters(graysquaremeter.MilligraySquareCentimeters).GraySquareMeters, MilligraySquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromMilligraySquareDecimeters(graysquaremeter.MilligraySquareDecimeters).GraySquareMeters, MilligraySquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromMilligraySquareMeters(graysquaremeter.MilligraySquareMeters).GraySquareMeters, MilligraySquareMetersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromMilligraySquareMicrometers(graysquaremeter.MilligraySquareMicrometers).GraySquareMeters, MilligraySquareMicrometersTolerance);
-            AssertEx.EqualTolerance(1, DoseAreaProduct.FromMilligraySquareMillimeters(graysquaremeter.MilligraySquareMillimeters).GraySquareMeters, MilligraySquareMillimetersTolerance);
+            DoseAreaProduct graysquaremeter = DoseAreaProduct.FromGraySquareMeters(3);
+            Assert.Equal(3, DoseAreaProduct.FromCentigraySquareCentimeters(graysquaremeter.CentigraySquareCentimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromCentigraySquareDecimeters(graysquaremeter.CentigraySquareDecimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromCentigraySquareMeters(graysquaremeter.CentigraySquareMeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromCentigraySquareMicrometers(graysquaremeter.CentigraySquareMicrometers).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromCentigraySquareMillimeters(graysquaremeter.CentigraySquareMillimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromDecigraySquareCentimeters(graysquaremeter.DecigraySquareCentimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromDecigraySquareDecimeters(graysquaremeter.DecigraySquareDecimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromDecigraySquareMeters(graysquaremeter.DecigraySquareMeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromDecigraySquareMicrometers(graysquaremeter.DecigraySquareMicrometers).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromDecigraySquareMillimeters(graysquaremeter.DecigraySquareMillimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromGraySquareCentimeters(graysquaremeter.GraySquareCentimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromGraySquareDecimeters(graysquaremeter.GraySquareDecimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromGraySquareMeters(graysquaremeter.GraySquareMeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromGraySquareMicrometers(graysquaremeter.GraySquareMicrometers).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromGraySquareMillimeters(graysquaremeter.GraySquareMillimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromMicrograySquareCentimeters(graysquaremeter.MicrograySquareCentimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromMicrograySquareDecimeters(graysquaremeter.MicrograySquareDecimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromMicrograySquareMeters(graysquaremeter.MicrograySquareMeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromMicrograySquareMicrometers(graysquaremeter.MicrograySquareMicrometers).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromMicrograySquareMillimeters(graysquaremeter.MicrograySquareMillimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromMilligraySquareCentimeters(graysquaremeter.MilligraySquareCentimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromMilligraySquareDecimeters(graysquaremeter.MilligraySquareDecimeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromMilligraySquareMeters(graysquaremeter.MilligraySquareMeters).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromMilligraySquareMicrometers(graysquaremeter.MilligraySquareMicrometers).GraySquareMeters);
+            Assert.Equal(3, DoseAreaProduct.FromMilligraySquareMillimeters(graysquaremeter.MilligraySquareMillimeters).GraySquareMeters);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             DoseAreaProduct v = DoseAreaProduct.FromGraySquareMeters(1);
-            AssertEx.EqualTolerance(-1, -v.GraySquareMeters, GraySquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (DoseAreaProduct.FromGraySquareMeters(3)-v).GraySquareMeters, GraySquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).GraySquareMeters, GraySquareMetersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).GraySquareMeters, GraySquareMetersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).GraySquareMeters, GraySquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (DoseAreaProduct.FromGraySquareMeters(10)/5).GraySquareMeters, GraySquareMetersTolerance);
-            AssertEx.EqualTolerance(2, DoseAreaProduct.FromGraySquareMeters(10)/DoseAreaProduct.FromGraySquareMeters(5), GraySquareMetersTolerance);
+            Assert.Equal(-1, -v.GraySquareMeters);
+            Assert.Equal(2, (DoseAreaProduct.FromGraySquareMeters(3) - v).GraySquareMeters);
+            Assert.Equal(2, (v + v).GraySquareMeters);
+            Assert.Equal(10, (v * 10).GraySquareMeters);
+            Assert.Equal(10, (10 * v).GraySquareMeters);
+            Assert.Equal(2, (DoseAreaProduct.FromGraySquareMeters(10) / 5).GraySquareMeters);
+            Assert.Equal(2, DoseAreaProduct.FromGraySquareMeters(10) / DoseAreaProduct.FromGraySquareMeters(5));
         }
 
         [Fact]
@@ -1077,8 +1137,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, DoseAreaProductUnit.GraySquareMeter, 1, DoseAreaProductUnit.GraySquareMeter, true)]  // Same value and unit.
         [InlineData(1, DoseAreaProductUnit.GraySquareMeter, 2, DoseAreaProductUnit.GraySquareMeter, false)] // Different value.
-        [InlineData(2, DoseAreaProductUnit.GraySquareMeter, 1, DoseAreaProductUnit.CentigraySquareCentimeter, false)] // Different value and unit.
-        [InlineData(1, DoseAreaProductUnit.GraySquareMeter, 1, DoseAreaProductUnit.CentigraySquareCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, DoseAreaProductUnit unitA, double valueB, DoseAreaProductUnit unitB, bool expectEqual)
         {
             var a = new DoseAreaProduct(valueA, unitA);
@@ -1138,8 +1196,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = DoseAreaProduct.FromGraySquareMeters(firstValue);
             var otherQuantity = DoseAreaProduct.FromGraySquareMeters(secondValue);
             DoseAreaProduct maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, DoseAreaProduct.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1158,7 +1216,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<DoseAreaProductUnit>();
+            var units = EnumHelper.GetValues<DoseAreaProductUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1171,6 +1229,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(DoseAreaProduct.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(DoseAreaProduct.Info.Units, DoseAreaProduct.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, DoseAreaProduct.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1235,26 +1305,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 mGy·mm²", new DoseAreaProduct(1, DoseAreaProductUnit.MilligraySquareMillimeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Gy·m²", new DoseAreaProduct(0.123456, DoseAreaProductUnit.GraySquareMeter).ToString("s1"));
-            Assert.Equal("0.12 Gy·m²", new DoseAreaProduct(0.123456, DoseAreaProductUnit.GraySquareMeter).ToString("s2"));
-            Assert.Equal("0.123 Gy·m²", new DoseAreaProduct(0.123456, DoseAreaProductUnit.GraySquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 Gy·m²", new DoseAreaProduct(0.123456, DoseAreaProductUnit.GraySquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Gy·m²", new DoseAreaProduct(0.123456, DoseAreaProductUnit.GraySquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 Gy·m²", new DoseAreaProduct(0.123456, DoseAreaProductUnit.GraySquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 Gy·m²", new DoseAreaProduct(0.123456, DoseAreaProductUnit.GraySquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 Gy·m²", new DoseAreaProduct(0.123456, DoseAreaProductUnit.GraySquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1281,7 +1331,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = DoseAreaProduct.FromGraySquareMeters(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(DoseAreaProduct), quantity.As(DoseAreaProduct.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs
index c6f76a8a57..773355ae9c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DurationTestsBase.g.cs
@@ -173,6 +173,20 @@ public void Duration_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<DurationUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void DurationInfo_CreateWithCustomUnitInfos()
+        {
+            DurationUnit[] expectedUnits = [DurationUnit.Second];
+
+            Duration.DurationInfo quantityInfo = Duration.DurationInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Duration", quantityInfo.Name);
+            Assert.Equal(Duration.Zero, quantityInfo.Zero);
+            Assert.Equal(Duration.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SecondToDurationUnits()
         {
@@ -281,26 +295,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Duration.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Duration convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Duration quantityToConvert = quantity;
+
+                Duration convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<DurationUnit> quantityToConvert = quantity;
+
+                IQuantity<DurationUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Duration(value: 1, unit: Duration.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Duration(value: 1, unit: Duration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<DurationUnit> quantity = new Duration(value: 1, unit: Duration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Duration(value: 1, unit: Duration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Duration(value: 1, unit: Duration.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Duration(value: 1, unit: Duration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<DurationUnit> quantity = new Duration(value: 1, unit: Duration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Duration(value: 1, unit: Duration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -372,7 +429,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 с", DurationUnit.Second, 4.2)]
         [InlineData("ru-RU", "4,2 нед", DurationUnit.Week, 4.2)]
         [InlineData("ru-RU", "4,2 год", DurationUnit.Year365, 4.2)]
-        public void Parse(string culture, string quantityString, DurationUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, DurationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Duration.Parse(quantityString);
@@ -449,7 +506,7 @@ public void Parse(string culture, string quantityString, DurationUnit expectedUn
         [InlineData("ru-RU", "4,2 с", DurationUnit.Second, 4.2)]
         [InlineData("ru-RU", "4,2 нед", DurationUnit.Week, 4.2)]
         [InlineData("ru-RU", "4,2 год", DurationUnit.Year365, 4.2)]
-        public void TryParse(string culture, string quantityString, DurationUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, DurationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Duration.TryParse(quantityString, out Duration parsed));
@@ -1069,6 +1126,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(DurationUnit uni
                 var quantity = Duration.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1092,44 +1150,46 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(DurationUnit unit)
                 IQuantity<DurationUnit> quantityToConvert = quantity;
                 IQuantity<DurationUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Duration second = Duration.FromSeconds(1);
-            AssertEx.EqualTolerance(1, Duration.FromDays(second.Days).Seconds, DaysTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromHours(second.Hours).Seconds, HoursTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromJulianYears(second.JulianYears).Seconds, JulianYearsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromMicroseconds(second.Microseconds).Seconds, MicrosecondsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromMilliseconds(second.Milliseconds).Seconds, MillisecondsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromMinutes(second.Minutes).Seconds, MinutesTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromMonths30(second.Months30).Seconds, Months30Tolerance);
-            AssertEx.EqualTolerance(1, Duration.FromNanoseconds(second.Nanoseconds).Seconds, NanosecondsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromPicoseconds(second.Picoseconds).Seconds, PicosecondsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromSeconds(second.Seconds).Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromSols(second.Sols).Seconds, SolsTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromWeeks(second.Weeks).Seconds, WeeksTolerance);
-            AssertEx.EqualTolerance(1, Duration.FromYears365(second.Years365).Seconds, Years365Tolerance);
+            Duration second = Duration.FromSeconds(3);
+            Assert.Equal(3, Duration.FromDays(second.Days).Seconds);
+            Assert.Equal(3, Duration.FromHours(second.Hours).Seconds);
+            Assert.Equal(3, Duration.FromJulianYears(second.JulianYears).Seconds);
+            Assert.Equal(3, Duration.FromMicroseconds(second.Microseconds).Seconds);
+            Assert.Equal(3, Duration.FromMilliseconds(second.Milliseconds).Seconds);
+            Assert.Equal(3, Duration.FromMinutes(second.Minutes).Seconds);
+            Assert.Equal(3, Duration.FromMonths30(second.Months30).Seconds);
+            Assert.Equal(3, Duration.FromNanoseconds(second.Nanoseconds).Seconds);
+            Assert.Equal(3, Duration.FromPicoseconds(second.Picoseconds).Seconds);
+            Assert.Equal(3, Duration.FromSeconds(second.Seconds).Seconds);
+            Assert.Equal(3, Duration.FromSols(second.Sols).Seconds);
+            Assert.Equal(3, Duration.FromWeeks(second.Weeks).Seconds);
+            Assert.Equal(3, Duration.FromYears365(second.Years365).Seconds);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Duration v = Duration.FromSeconds(1);
-            AssertEx.EqualTolerance(-1, -v.Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(2, (Duration.FromSeconds(3)-v).Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(2, (Duration.FromSeconds(10)/5).Seconds, SecondsTolerance);
-            AssertEx.EqualTolerance(2, Duration.FromSeconds(10)/Duration.FromSeconds(5), SecondsTolerance);
+            Assert.Equal(-1, -v.Seconds);
+            Assert.Equal(2, (Duration.FromSeconds(3) - v).Seconds);
+            Assert.Equal(2, (v + v).Seconds);
+            Assert.Equal(10, (v * 10).Seconds);
+            Assert.Equal(10, (10 * v).Seconds);
+            Assert.Equal(2, (Duration.FromSeconds(10) / 5).Seconds);
+            Assert.Equal(2, Duration.FromSeconds(10) / Duration.FromSeconds(5));
         }
 
         [Fact]
@@ -1175,8 +1235,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, DurationUnit.Second, 1, DurationUnit.Second, true)]  // Same value and unit.
         [InlineData(1, DurationUnit.Second, 2, DurationUnit.Second, false)] // Different value.
-        [InlineData(2, DurationUnit.Second, 1, DurationUnit.Day, false)] // Different value and unit.
-        [InlineData(1, DurationUnit.Second, 1, DurationUnit.Day, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, DurationUnit unitA, double valueB, DurationUnit unitB, bool expectEqual)
         {
             var a = new Duration(valueA, unitA);
@@ -1236,8 +1294,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Duration.FromSeconds(firstValue);
             var otherQuantity = Duration.FromSeconds(secondValue);
             Duration maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Duration.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1256,7 +1314,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<DurationUnit>();
+            var units = EnumHelper.GetValues<DurationUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1269,6 +1327,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Duration.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Duration.Info.Units, Duration.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Duration.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1309,26 +1379,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 yr", new Duration(1, DurationUnit.Year365).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 s", new Duration(0.123456, DurationUnit.Second).ToString("s1"));
-            Assert.Equal("0.12 s", new Duration(0.123456, DurationUnit.Second).ToString("s2"));
-            Assert.Equal("0.123 s", new Duration(0.123456, DurationUnit.Second).ToString("s3"));
-            Assert.Equal("0.1235 s", new Duration(0.123456, DurationUnit.Second).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 s", new Duration(0.123456, DurationUnit.Second).ToString("s1", culture));
-            Assert.Equal("0.12 s", new Duration(0.123456, DurationUnit.Second).ToString("s2", culture));
-            Assert.Equal("0.123 s", new Duration(0.123456, DurationUnit.Second).ToString("s3", culture));
-            Assert.Equal("0.1235 s", new Duration(0.123456, DurationUnit.Second).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1355,7 +1405,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Duration.FromSeconds(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Duration), quantity.As(Duration.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs
index 12ac7a9c89..5c0f4702b7 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DynamicViscosityTestsBase.g.cs
@@ -161,6 +161,20 @@ public void DynamicViscosity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity(
             Assert.Equal(quantityInfo, ((IQuantity<DynamicViscosityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void DynamicViscosityInfo_CreateWithCustomUnitInfos()
+        {
+            DynamicViscosityUnit[] expectedUnits = [DynamicViscosityUnit.NewtonSecondPerMeterSquared];
+
+            DynamicViscosity.DynamicViscosityInfo quantityInfo = DynamicViscosity.DynamicViscosityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("DynamicViscosity", quantityInfo.Name);
+            Assert.Equal(DynamicViscosity.Zero, quantityInfo.Zero);
+            Assert.Equal(DynamicViscosity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void NewtonSecondPerMeterSquaredToDynamicViscosityUnits()
         {
@@ -263,26 +277,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = DynamicViscosity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            DynamicViscosity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                DynamicViscosity quantityToConvert = quantity;
+
+                DynamicViscosity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<DynamicViscosityUnit> quantityToConvert = quantity;
+
+                IQuantity<DynamicViscosityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new DynamicViscosity(value: 1, unit: DynamicViscosity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new DynamicViscosity(value: 1, unit: DynamicViscosity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<DynamicViscosityUnit> quantity = new DynamicViscosity(value: 1, unit: DynamicViscosity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new DynamicViscosity(value: 1, unit: DynamicViscosity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new DynamicViscosity(value: 1, unit: DynamicViscosity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new DynamicViscosity(value: 1, unit: DynamicViscosity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<DynamicViscosityUnit> quantity = new DynamicViscosity(value: 1, unit: DynamicViscosity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new DynamicViscosity(value: 1, unit: DynamicViscosity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -299,7 +356,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 lbf·s/in²", DynamicViscosityUnit.PoundForceSecondPerSquareInch, 4.2)]
         [InlineData("en-US", "4.2 lb/(ft·s)", DynamicViscosityUnit.PoundPerFootSecond, 4.2)]
         [InlineData("en-US", "4.2 reyn", DynamicViscosityUnit.Reyn, 4.2)]
-        public void Parse(string culture, string quantityString, DynamicViscosityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, DynamicViscosityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = DynamicViscosity.Parse(quantityString);
@@ -321,7 +378,7 @@ public void Parse(string culture, string quantityString, DynamicViscosityUnit ex
         [InlineData("en-US", "4.2 lbf·s/in²", DynamicViscosityUnit.PoundForceSecondPerSquareInch, 4.2)]
         [InlineData("en-US", "4.2 lb/(ft·s)", DynamicViscosityUnit.PoundPerFootSecond, 4.2)]
         [InlineData("en-US", "4.2 reyn", DynamicViscosityUnit.Reyn, 4.2)]
-        public void TryParse(string culture, string quantityString, DynamicViscosityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, DynamicViscosityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(DynamicViscosity.TryParse(quantityString, out DynamicViscosity parsed));
@@ -559,6 +616,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(DynamicViscosity
                 var quantity = DynamicViscosity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -582,41 +640,43 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(DynamicViscosityUni
                 IQuantity<DynamicViscosityUnit> quantityToConvert = quantity;
                 IQuantity<DynamicViscosityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            DynamicViscosity newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromCentipoise(newtonsecondpermetersquared.Centipoise).NewtonSecondsPerMeterSquared, CentipoiseTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromMicropascalSeconds(newtonsecondpermetersquared.MicropascalSeconds).NewtonSecondsPerMeterSquared, MicropascalSecondsTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromMillipascalSeconds(newtonsecondpermetersquared.MillipascalSeconds).NewtonSecondsPerMeterSquared, MillipascalSecondsTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromNewtonSecondsPerMeterSquared(newtonsecondpermetersquared.NewtonSecondsPerMeterSquared).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromPascalSeconds(newtonsecondpermetersquared.PascalSeconds).NewtonSecondsPerMeterSquared, PascalSecondsTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromPoise(newtonsecondpermetersquared.Poise).NewtonSecondsPerMeterSquared, PoiseTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromPoundsForceSecondPerSquareFoot(newtonsecondpermetersquared.PoundsForceSecondPerSquareFoot).NewtonSecondsPerMeterSquared, PoundsForceSecondPerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromPoundsForceSecondPerSquareInch(newtonsecondpermetersquared.PoundsForceSecondPerSquareInch).NewtonSecondsPerMeterSquared, PoundsForceSecondPerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromPoundsPerFootSecond(newtonsecondpermetersquared.PoundsPerFootSecond).NewtonSecondsPerMeterSquared, PoundsPerFootSecondTolerance);
-            AssertEx.EqualTolerance(1, DynamicViscosity.FromReyns(newtonsecondpermetersquared.Reyns).NewtonSecondsPerMeterSquared, ReynsTolerance);
+            DynamicViscosity newtonsecondpermetersquared = DynamicViscosity.FromNewtonSecondsPerMeterSquared(3);
+            Assert.Equal(3, DynamicViscosity.FromCentipoise(newtonsecondpermetersquared.Centipoise).NewtonSecondsPerMeterSquared);
+            Assert.Equal(3, DynamicViscosity.FromMicropascalSeconds(newtonsecondpermetersquared.MicropascalSeconds).NewtonSecondsPerMeterSquared);
+            Assert.Equal(3, DynamicViscosity.FromMillipascalSeconds(newtonsecondpermetersquared.MillipascalSeconds).NewtonSecondsPerMeterSquared);
+            Assert.Equal(3, DynamicViscosity.FromNewtonSecondsPerMeterSquared(newtonsecondpermetersquared.NewtonSecondsPerMeterSquared).NewtonSecondsPerMeterSquared);
+            Assert.Equal(3, DynamicViscosity.FromPascalSeconds(newtonsecondpermetersquared.PascalSeconds).NewtonSecondsPerMeterSquared);
+            Assert.Equal(3, DynamicViscosity.FromPoise(newtonsecondpermetersquared.Poise).NewtonSecondsPerMeterSquared);
+            Assert.Equal(3, DynamicViscosity.FromPoundsForceSecondPerSquareFoot(newtonsecondpermetersquared.PoundsForceSecondPerSquareFoot).NewtonSecondsPerMeterSquared);
+            Assert.Equal(3, DynamicViscosity.FromPoundsForceSecondPerSquareInch(newtonsecondpermetersquared.PoundsForceSecondPerSquareInch).NewtonSecondsPerMeterSquared);
+            Assert.Equal(3, DynamicViscosity.FromPoundsPerFootSecond(newtonsecondpermetersquared.PoundsPerFootSecond).NewtonSecondsPerMeterSquared);
+            Assert.Equal(3, DynamicViscosity.FromReyns(newtonsecondpermetersquared.Reyns).NewtonSecondsPerMeterSquared);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             DynamicViscosity v = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
-            AssertEx.EqualTolerance(-1, -v.NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(2, (DynamicViscosity.FromNewtonSecondsPerMeterSquared(3)-v).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(2, (v + v).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(10, (v*10).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(10, (10*v).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(2, (DynamicViscosity.FromNewtonSecondsPerMeterSquared(10)/5).NewtonSecondsPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance);
-            AssertEx.EqualTolerance(2, DynamicViscosity.FromNewtonSecondsPerMeterSquared(10)/DynamicViscosity.FromNewtonSecondsPerMeterSquared(5), NewtonSecondsPerMeterSquaredTolerance);
+            Assert.Equal(-1, -v.NewtonSecondsPerMeterSquared);
+            Assert.Equal(2, (DynamicViscosity.FromNewtonSecondsPerMeterSquared(3) - v).NewtonSecondsPerMeterSquared);
+            Assert.Equal(2, (v + v).NewtonSecondsPerMeterSquared);
+            Assert.Equal(10, (v * 10).NewtonSecondsPerMeterSquared);
+            Assert.Equal(10, (10 * v).NewtonSecondsPerMeterSquared);
+            Assert.Equal(2, (DynamicViscosity.FromNewtonSecondsPerMeterSquared(10) / 5).NewtonSecondsPerMeterSquared);
+            Assert.Equal(2, DynamicViscosity.FromNewtonSecondsPerMeterSquared(10) / DynamicViscosity.FromNewtonSecondsPerMeterSquared(5));
         }
 
         [Fact]
@@ -662,8 +722,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, DynamicViscosityUnit.NewtonSecondPerMeterSquared, 1, DynamicViscosityUnit.NewtonSecondPerMeterSquared, true)]  // Same value and unit.
         [InlineData(1, DynamicViscosityUnit.NewtonSecondPerMeterSquared, 2, DynamicViscosityUnit.NewtonSecondPerMeterSquared, false)] // Different value.
-        [InlineData(2, DynamicViscosityUnit.NewtonSecondPerMeterSquared, 1, DynamicViscosityUnit.Centipoise, false)] // Different value and unit.
-        [InlineData(1, DynamicViscosityUnit.NewtonSecondPerMeterSquared, 1, DynamicViscosityUnit.Centipoise, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, DynamicViscosityUnit unitA, double valueB, DynamicViscosityUnit unitB, bool expectEqual)
         {
             var a = new DynamicViscosity(valueA, unitA);
@@ -723,8 +781,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = DynamicViscosity.FromNewtonSecondsPerMeterSquared(firstValue);
             var otherQuantity = DynamicViscosity.FromNewtonSecondsPerMeterSquared(secondValue);
             DynamicViscosity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, DynamicViscosity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -743,7 +801,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<DynamicViscosityUnit>();
+            var units = EnumHelper.GetValues<DynamicViscosityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -756,6 +814,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(DynamicViscosity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(DynamicViscosity.Info.Units, DynamicViscosity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, DynamicViscosity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -790,26 +860,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 reyn", new DynamicViscosity(1, DynamicViscosityUnit.Reyn).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Ns/m²", new DynamicViscosity(0.123456, DynamicViscosityUnit.NewtonSecondPerMeterSquared).ToString("s1"));
-            Assert.Equal("0.12 Ns/m²", new DynamicViscosity(0.123456, DynamicViscosityUnit.NewtonSecondPerMeterSquared).ToString("s2"));
-            Assert.Equal("0.123 Ns/m²", new DynamicViscosity(0.123456, DynamicViscosityUnit.NewtonSecondPerMeterSquared).ToString("s3"));
-            Assert.Equal("0.1235 Ns/m²", new DynamicViscosity(0.123456, DynamicViscosityUnit.NewtonSecondPerMeterSquared).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Ns/m²", new DynamicViscosity(0.123456, DynamicViscosityUnit.NewtonSecondPerMeterSquared).ToString("s1", culture));
-            Assert.Equal("0.12 Ns/m²", new DynamicViscosity(0.123456, DynamicViscosityUnit.NewtonSecondPerMeterSquared).ToString("s2", culture));
-            Assert.Equal("0.123 Ns/m²", new DynamicViscosity(0.123456, DynamicViscosityUnit.NewtonSecondPerMeterSquared).ToString("s3", culture));
-            Assert.Equal("0.1235 Ns/m²", new DynamicViscosity(0.123456, DynamicViscosityUnit.NewtonSecondPerMeterSquared).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -836,7 +886,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(DynamicViscosity), quantity.As(DynamicViscosity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricAdmittanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricAdmittanceTestsBase.g.cs
index acb1078b4b..398cd74b9a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricAdmittanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricAdmittanceTestsBase.g.cs
@@ -185,6 +185,20 @@ public void ElectricAdmittance_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
             Assert.Equal(quantityInfo, ((IQuantity<ElectricAdmittanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricAdmittanceInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricAdmittanceUnit[] expectedUnits = [ElectricAdmittanceUnit.Siemens];
+
+            ElectricAdmittance.ElectricAdmittanceInfo quantityInfo = ElectricAdmittance.ElectricAdmittanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricAdmittance", quantityInfo.Name);
+            Assert.Equal(ElectricAdmittance.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricAdmittance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SiemensToElectricAdmittanceUnits()
         {
@@ -299,26 +313,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricAdmittance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricAdmittance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricAdmittance quantityToConvert = quantity;
+
+                ElectricAdmittance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricAdmittanceUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricAdmittanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricAdmittance(value: 1, unit: ElectricAdmittance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricAdmittance(value: 1, unit: ElectricAdmittance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricAdmittanceUnit> quantity = new ElectricAdmittance(value: 1, unit: ElectricAdmittance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricAdmittance(value: 1, unit: ElectricAdmittance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricAdmittance(value: 1, unit: ElectricAdmittance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricAdmittance(value: 1, unit: ElectricAdmittance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricAdmittanceUnit> quantity = new ElectricAdmittance(value: 1, unit: ElectricAdmittance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricAdmittance(value: 1, unit: ElectricAdmittance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -338,7 +395,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 S", ElectricAdmittanceUnit.Siemens, 4.2)]
         [InlineData("en-US", "4.2 T℧", ElectricAdmittanceUnit.Teramho, 4.2)]
         [InlineData("en-US", "4.2 TS", ElectricAdmittanceUnit.Terasiemens, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricAdmittanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricAdmittanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricAdmittance.Parse(quantityString);
@@ -363,7 +420,7 @@ public void Parse(string culture, string quantityString, ElectricAdmittanceUnit
         [InlineData("en-US", "4.2 S", ElectricAdmittanceUnit.Siemens, 4.2)]
         [InlineData("en-US", "4.2 T℧", ElectricAdmittanceUnit.Teramho, 4.2)]
         [InlineData("en-US", "4.2 TS", ElectricAdmittanceUnit.Terasiemens, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricAdmittanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricAdmittanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricAdmittance.TryParse(quantityString, out ElectricAdmittance parsed));
@@ -631,6 +688,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricAdmittan
                 var quantity = ElectricAdmittance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -654,47 +712,49 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricAdmittanceU
                 IQuantity<ElectricAdmittanceUnit> quantityToConvert = quantity;
                 IQuantity<ElectricAdmittanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricAdmittance siemens = ElectricAdmittance.FromSiemens(1);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromGigamhos(siemens.Gigamhos).Siemens, GigamhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromGigasiemens(siemens.Gigasiemens).Siemens, GigasiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromKilomhos(siemens.Kilomhos).Siemens, KilomhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromKilosiemens(siemens.Kilosiemens).Siemens, KilosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromMegamhos(siemens.Megamhos).Siemens, MegamhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromMegasiemens(siemens.Megasiemens).Siemens, MegasiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromMhos(siemens.Mhos).Siemens, MhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromMicromhos(siemens.Micromhos).Siemens, MicromhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromMicrosiemens(siemens.Microsiemens).Siemens, MicrosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromMillimhos(siemens.Millimhos).Siemens, MillimhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromMillisiemens(siemens.Millisiemens).Siemens, MillisiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromNanomhos(siemens.Nanomhos).Siemens, NanomhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromNanosiemens(siemens.Nanosiemens).Siemens, NanosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromSiemens(siemens.Siemens).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromTeramhos(siemens.Teramhos).Siemens, TeramhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricAdmittance.FromTerasiemens(siemens.Terasiemens).Siemens, TerasiemensTolerance);
+            ElectricAdmittance siemens = ElectricAdmittance.FromSiemens(3);
+            Assert.Equal(3, ElectricAdmittance.FromGigamhos(siemens.Gigamhos).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromGigasiemens(siemens.Gigasiemens).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromKilomhos(siemens.Kilomhos).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromKilosiemens(siemens.Kilosiemens).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromMegamhos(siemens.Megamhos).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromMegasiemens(siemens.Megasiemens).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromMhos(siemens.Mhos).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromMicromhos(siemens.Micromhos).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromMicrosiemens(siemens.Microsiemens).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromMillimhos(siemens.Millimhos).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromMillisiemens(siemens.Millisiemens).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromNanomhos(siemens.Nanomhos).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromNanosiemens(siemens.Nanosiemens).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromSiemens(siemens.Siemens).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromTeramhos(siemens.Teramhos).Siemens);
+            Assert.Equal(3, ElectricAdmittance.FromTerasiemens(siemens.Terasiemens).Siemens);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricAdmittance v = ElectricAdmittance.FromSiemens(1);
-            AssertEx.EqualTolerance(-1, -v.Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (ElectricAdmittance.FromSiemens(3)-v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (ElectricAdmittance.FromSiemens(10)/5).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, ElectricAdmittance.FromSiemens(10)/ElectricAdmittance.FromSiemens(5), SiemensTolerance);
+            Assert.Equal(-1, -v.Siemens);
+            Assert.Equal(2, (ElectricAdmittance.FromSiemens(3) - v).Siemens);
+            Assert.Equal(2, (v + v).Siemens);
+            Assert.Equal(10, (v * 10).Siemens);
+            Assert.Equal(10, (10 * v).Siemens);
+            Assert.Equal(2, (ElectricAdmittance.FromSiemens(10) / 5).Siemens);
+            Assert.Equal(2, ElectricAdmittance.FromSiemens(10) / ElectricAdmittance.FromSiemens(5));
         }
 
         [Fact]
@@ -740,8 +800,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricAdmittanceUnit.Siemens, 1, ElectricAdmittanceUnit.Siemens, true)]  // Same value and unit.
         [InlineData(1, ElectricAdmittanceUnit.Siemens, 2, ElectricAdmittanceUnit.Siemens, false)] // Different value.
-        [InlineData(2, ElectricAdmittanceUnit.Siemens, 1, ElectricAdmittanceUnit.Gigamho, false)] // Different value and unit.
-        [InlineData(1, ElectricAdmittanceUnit.Siemens, 1, ElectricAdmittanceUnit.Gigamho, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricAdmittanceUnit unitA, double valueB, ElectricAdmittanceUnit unitB, bool expectEqual)
         {
             var a = new ElectricAdmittance(valueA, unitA);
@@ -801,8 +859,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricAdmittance.FromSiemens(firstValue);
             var otherQuantity = ElectricAdmittance.FromSiemens(secondValue);
             ElectricAdmittance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricAdmittance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -821,7 +879,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricAdmittanceUnit>();
+            var units = EnumHelper.GetValues<ElectricAdmittanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -834,6 +892,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricAdmittance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricAdmittance.Info.Units, ElectricAdmittance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricAdmittance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -880,26 +950,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 TS", new ElectricAdmittance(1, ElectricAdmittanceUnit.Terasiemens).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 S", new ElectricAdmittance(0.123456, ElectricAdmittanceUnit.Siemens).ToString("s1"));
-            Assert.Equal("0.12 S", new ElectricAdmittance(0.123456, ElectricAdmittanceUnit.Siemens).ToString("s2"));
-            Assert.Equal("0.123 S", new ElectricAdmittance(0.123456, ElectricAdmittanceUnit.Siemens).ToString("s3"));
-            Assert.Equal("0.1235 S", new ElectricAdmittance(0.123456, ElectricAdmittanceUnit.Siemens).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 S", new ElectricAdmittance(0.123456, ElectricAdmittanceUnit.Siemens).ToString("s1", culture));
-            Assert.Equal("0.12 S", new ElectricAdmittance(0.123456, ElectricAdmittanceUnit.Siemens).ToString("s2", culture));
-            Assert.Equal("0.123 S", new ElectricAdmittance(0.123456, ElectricAdmittanceUnit.Siemens).ToString("s3", culture));
-            Assert.Equal("0.1235 S", new ElectricAdmittance(0.123456, ElectricAdmittanceUnit.Siemens).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -926,7 +976,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricAdmittance.FromSiemens(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricAdmittance), quantity.As(ElectricAdmittance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricApparentEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricApparentEnergyTestsBase.g.cs
index 70c351debd..bc2b9102c2 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricApparentEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricApparentEnergyTestsBase.g.cs
@@ -133,6 +133,20 @@ public void ElectricApparentEnergy_QuantityInfo_ReturnsQuantityInfoDescribingQua
             Assert.Equal(quantityInfo, ((IQuantity<ElectricApparentEnergyUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricApparentEnergyInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricApparentEnergyUnit[] expectedUnits = [ElectricApparentEnergyUnit.VoltampereHour];
+
+            ElectricApparentEnergy.ElectricApparentEnergyInfo quantityInfo = ElectricApparentEnergy.ElectricApparentEnergyInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricApparentEnergy", quantityInfo.Name);
+            Assert.Equal(ElectricApparentEnergy.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricApparentEnergy.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void VoltampereHourToElectricApparentEnergyUnits()
         {
@@ -221,33 +235,76 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricApparentEnergy.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricApparentEnergy convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricApparentEnergy quantityToConvert = quantity;
+
+                ElectricApparentEnergy convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricApparentEnergyUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricApparentEnergyUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricApparentEnergy(value: 1, unit: ElectricApparentEnergy.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricApparentEnergy(value: 1, unit: ElectricApparentEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricApparentEnergyUnit> quantity = new ElectricApparentEnergy(value: 1, unit: ElectricApparentEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricApparentEnergy(value: 1, unit: ElectricApparentEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricApparentEnergy(value: 1, unit: ElectricApparentEnergy.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricApparentEnergy(value: 1, unit: ElectricApparentEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricApparentEnergyUnit> quantity = new ElectricApparentEnergy(value: 1, unit: ElectricApparentEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricApparentEnergy(value: 1, unit: ElectricApparentEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 kVAh", ElectricApparentEnergyUnit.KilovoltampereHour, 4.2)]
         [InlineData("en-US", "4.2 MVAh", ElectricApparentEnergyUnit.MegavoltampereHour, 4.2)]
         [InlineData("en-US", "4.2 VAh", ElectricApparentEnergyUnit.VoltampereHour, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricApparentEnergyUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricApparentEnergyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricApparentEnergy.Parse(quantityString);
@@ -259,7 +316,7 @@ public void Parse(string culture, string quantityString, ElectricApparentEnergyU
         [InlineData("en-US", "4.2 kVAh", ElectricApparentEnergyUnit.KilovoltampereHour, 4.2)]
         [InlineData("en-US", "4.2 MVAh", ElectricApparentEnergyUnit.MegavoltampereHour, 4.2)]
         [InlineData("en-US", "4.2 VAh", ElectricApparentEnergyUnit.VoltampereHour, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricApparentEnergyUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricApparentEnergyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricApparentEnergy.TryParse(quantityString, out ElectricApparentEnergy parsed));
@@ -410,6 +467,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricApparent
                 var quantity = ElectricApparentEnergy.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -433,34 +491,36 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricApparentEne
                 IQuantity<ElectricApparentEnergyUnit> quantityToConvert = quantity;
                 IQuantity<ElectricApparentEnergyUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricApparentEnergy voltamperehour = ElectricApparentEnergy.FromVoltampereHours(1);
-            AssertEx.EqualTolerance(1, ElectricApparentEnergy.FromKilovoltampereHours(voltamperehour.KilovoltampereHours).VoltampereHours, KilovoltampereHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricApparentEnergy.FromMegavoltampereHours(voltamperehour.MegavoltampereHours).VoltampereHours, MegavoltampereHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricApparentEnergy.FromVoltampereHours(voltamperehour.VoltampereHours).VoltampereHours, VoltampereHoursTolerance);
+            ElectricApparentEnergy voltamperehour = ElectricApparentEnergy.FromVoltampereHours(3);
+            Assert.Equal(3, ElectricApparentEnergy.FromKilovoltampereHours(voltamperehour.KilovoltampereHours).VoltampereHours);
+            Assert.Equal(3, ElectricApparentEnergy.FromMegavoltampereHours(voltamperehour.MegavoltampereHours).VoltampereHours);
+            Assert.Equal(3, ElectricApparentEnergy.FromVoltampereHours(voltamperehour.VoltampereHours).VoltampereHours);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricApparentEnergy v = ElectricApparentEnergy.FromVoltampereHours(1);
-            AssertEx.EqualTolerance(-1, -v.VoltampereHours, VoltampereHoursTolerance);
-            AssertEx.EqualTolerance(2, (ElectricApparentEnergy.FromVoltampereHours(3)-v).VoltampereHours, VoltampereHoursTolerance);
-            AssertEx.EqualTolerance(2, (v + v).VoltampereHours, VoltampereHoursTolerance);
-            AssertEx.EqualTolerance(10, (v*10).VoltampereHours, VoltampereHoursTolerance);
-            AssertEx.EqualTolerance(10, (10*v).VoltampereHours, VoltampereHoursTolerance);
-            AssertEx.EqualTolerance(2, (ElectricApparentEnergy.FromVoltampereHours(10)/5).VoltampereHours, VoltampereHoursTolerance);
-            AssertEx.EqualTolerance(2, ElectricApparentEnergy.FromVoltampereHours(10)/ElectricApparentEnergy.FromVoltampereHours(5), VoltampereHoursTolerance);
+            Assert.Equal(-1, -v.VoltampereHours);
+            Assert.Equal(2, (ElectricApparentEnergy.FromVoltampereHours(3) - v).VoltampereHours);
+            Assert.Equal(2, (v + v).VoltampereHours);
+            Assert.Equal(10, (v * 10).VoltampereHours);
+            Assert.Equal(10, (10 * v).VoltampereHours);
+            Assert.Equal(2, (ElectricApparentEnergy.FromVoltampereHours(10) / 5).VoltampereHours);
+            Assert.Equal(2, ElectricApparentEnergy.FromVoltampereHours(10) / ElectricApparentEnergy.FromVoltampereHours(5));
         }
 
         [Fact]
@@ -506,8 +566,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricApparentEnergyUnit.VoltampereHour, 1, ElectricApparentEnergyUnit.VoltampereHour, true)]  // Same value and unit.
         [InlineData(1, ElectricApparentEnergyUnit.VoltampereHour, 2, ElectricApparentEnergyUnit.VoltampereHour, false)] // Different value.
-        [InlineData(2, ElectricApparentEnergyUnit.VoltampereHour, 1, ElectricApparentEnergyUnit.KilovoltampereHour, false)] // Different value and unit.
-        [InlineData(1, ElectricApparentEnergyUnit.VoltampereHour, 1, ElectricApparentEnergyUnit.KilovoltampereHour, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricApparentEnergyUnit unitA, double valueB, ElectricApparentEnergyUnit unitB, bool expectEqual)
         {
             var a = new ElectricApparentEnergy(valueA, unitA);
@@ -567,8 +625,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricApparentEnergy.FromVoltampereHours(firstValue);
             var otherQuantity = ElectricApparentEnergy.FromVoltampereHours(secondValue);
             ElectricApparentEnergy maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricApparentEnergy.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -587,7 +645,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricApparentEnergyUnit>();
+            var units = EnumHelper.GetValues<ElectricApparentEnergyUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -600,6 +658,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricApparentEnergy.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricApparentEnergy.Info.Units, ElectricApparentEnergy.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricApparentEnergy.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -620,26 +690,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 VAh", new ElectricApparentEnergy(1, ElectricApparentEnergyUnit.VoltampereHour).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 VAh", new ElectricApparentEnergy(0.123456, ElectricApparentEnergyUnit.VoltampereHour).ToString("s1"));
-            Assert.Equal("0.12 VAh", new ElectricApparentEnergy(0.123456, ElectricApparentEnergyUnit.VoltampereHour).ToString("s2"));
-            Assert.Equal("0.123 VAh", new ElectricApparentEnergy(0.123456, ElectricApparentEnergyUnit.VoltampereHour).ToString("s3"));
-            Assert.Equal("0.1235 VAh", new ElectricApparentEnergy(0.123456, ElectricApparentEnergyUnit.VoltampereHour).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 VAh", new ElectricApparentEnergy(0.123456, ElectricApparentEnergyUnit.VoltampereHour).ToString("s1", culture));
-            Assert.Equal("0.12 VAh", new ElectricApparentEnergy(0.123456, ElectricApparentEnergyUnit.VoltampereHour).ToString("s2", culture));
-            Assert.Equal("0.123 VAh", new ElectricApparentEnergy(0.123456, ElectricApparentEnergyUnit.VoltampereHour).ToString("s3", culture));
-            Assert.Equal("0.1235 VAh", new ElectricApparentEnergy(0.123456, ElectricApparentEnergyUnit.VoltampereHour).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -666,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricApparentEnergy.FromVoltampereHours(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricApparentEnergy), quantity.As(ElectricApparentEnergy.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricApparentPowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricApparentPowerTestsBase.g.cs
index ce74ec86aa..162daa1d08 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricApparentPowerTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricApparentPowerTestsBase.g.cs
@@ -145,6 +145,20 @@ public void ElectricApparentPower_QuantityInfo_ReturnsQuantityInfoDescribingQuan
             Assert.Equal(quantityInfo, ((IQuantity<ElectricApparentPowerUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricApparentPowerInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricApparentPowerUnit[] expectedUnits = [ElectricApparentPowerUnit.Voltampere];
+
+            ElectricApparentPower.ElectricApparentPowerInfo quantityInfo = ElectricApparentPower.ElectricApparentPowerInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricApparentPower", quantityInfo.Name);
+            Assert.Equal(ElectricApparentPower.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricApparentPower.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void VoltampereToElectricApparentPowerUnits()
         {
@@ -239,26 +253,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricApparentPower.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricApparentPower convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricApparentPower quantityToConvert = quantity;
+
+                ElectricApparentPower convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricApparentPowerUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricApparentPowerUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricApparentPower(value: 1, unit: ElectricApparentPower.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricApparentPower(value: 1, unit: ElectricApparentPower.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricApparentPowerUnit> quantity = new ElectricApparentPower(value: 1, unit: ElectricApparentPower.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricApparentPower(value: 1, unit: ElectricApparentPower.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricApparentPower(value: 1, unit: ElectricApparentPower.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricApparentPower(value: 1, unit: ElectricApparentPower.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricApparentPowerUnit> quantity = new ElectricApparentPower(value: 1, unit: ElectricApparentPower.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricApparentPower(value: 1, unit: ElectricApparentPower.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -268,7 +325,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 µVA", ElectricApparentPowerUnit.Microvoltampere, 4.2)]
         [InlineData("en-US", "4.2 mVA", ElectricApparentPowerUnit.Millivoltampere, 4.2)]
         [InlineData("en-US", "4.2 VA", ElectricApparentPowerUnit.Voltampere, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricApparentPowerUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricApparentPowerUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricApparentPower.Parse(quantityString);
@@ -283,7 +340,7 @@ public void Parse(string culture, string quantityString, ElectricApparentPowerUn
         [InlineData("en-US", "4.2 µVA", ElectricApparentPowerUnit.Microvoltampere, 4.2)]
         [InlineData("en-US", "4.2 mVA", ElectricApparentPowerUnit.Millivoltampere, 4.2)]
         [InlineData("en-US", "4.2 VA", ElectricApparentPowerUnit.Voltampere, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricApparentPowerUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricApparentPowerUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricApparentPower.TryParse(quantityString, out ElectricApparentPower parsed));
@@ -461,6 +518,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricApparent
                 var quantity = ElectricApparentPower.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -484,37 +542,39 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricApparentPow
                 IQuantity<ElectricApparentPowerUnit> quantityToConvert = quantity;
                 IQuantity<ElectricApparentPowerUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricApparentPower voltampere = ElectricApparentPower.FromVoltamperes(1);
-            AssertEx.EqualTolerance(1, ElectricApparentPower.FromGigavoltamperes(voltampere.Gigavoltamperes).Voltamperes, GigavoltamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricApparentPower.FromKilovoltamperes(voltampere.Kilovoltamperes).Voltamperes, KilovoltamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricApparentPower.FromMegavoltamperes(voltampere.Megavoltamperes).Voltamperes, MegavoltamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricApparentPower.FromMicrovoltamperes(voltampere.Microvoltamperes).Voltamperes, MicrovoltamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricApparentPower.FromMillivoltamperes(voltampere.Millivoltamperes).Voltamperes, MillivoltamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricApparentPower.FromVoltamperes(voltampere.Voltamperes).Voltamperes, VoltamperesTolerance);
+            ElectricApparentPower voltampere = ElectricApparentPower.FromVoltamperes(3);
+            Assert.Equal(3, ElectricApparentPower.FromGigavoltamperes(voltampere.Gigavoltamperes).Voltamperes);
+            Assert.Equal(3, ElectricApparentPower.FromKilovoltamperes(voltampere.Kilovoltamperes).Voltamperes);
+            Assert.Equal(3, ElectricApparentPower.FromMegavoltamperes(voltampere.Megavoltamperes).Voltamperes);
+            Assert.Equal(3, ElectricApparentPower.FromMicrovoltamperes(voltampere.Microvoltamperes).Voltamperes);
+            Assert.Equal(3, ElectricApparentPower.FromMillivoltamperes(voltampere.Millivoltamperes).Voltamperes);
+            Assert.Equal(3, ElectricApparentPower.FromVoltamperes(voltampere.Voltamperes).Voltamperes);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricApparentPower v = ElectricApparentPower.FromVoltamperes(1);
-            AssertEx.EqualTolerance(-1, -v.Voltamperes, VoltamperesTolerance);
-            AssertEx.EqualTolerance(2, (ElectricApparentPower.FromVoltamperes(3)-v).Voltamperes, VoltamperesTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Voltamperes, VoltamperesTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Voltamperes, VoltamperesTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Voltamperes, VoltamperesTolerance);
-            AssertEx.EqualTolerance(2, (ElectricApparentPower.FromVoltamperes(10)/5).Voltamperes, VoltamperesTolerance);
-            AssertEx.EqualTolerance(2, ElectricApparentPower.FromVoltamperes(10)/ElectricApparentPower.FromVoltamperes(5), VoltamperesTolerance);
+            Assert.Equal(-1, -v.Voltamperes);
+            Assert.Equal(2, (ElectricApparentPower.FromVoltamperes(3) - v).Voltamperes);
+            Assert.Equal(2, (v + v).Voltamperes);
+            Assert.Equal(10, (v * 10).Voltamperes);
+            Assert.Equal(10, (10 * v).Voltamperes);
+            Assert.Equal(2, (ElectricApparentPower.FromVoltamperes(10) / 5).Voltamperes);
+            Assert.Equal(2, ElectricApparentPower.FromVoltamperes(10) / ElectricApparentPower.FromVoltamperes(5));
         }
 
         [Fact]
@@ -560,8 +620,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricApparentPowerUnit.Voltampere, 1, ElectricApparentPowerUnit.Voltampere, true)]  // Same value and unit.
         [InlineData(1, ElectricApparentPowerUnit.Voltampere, 2, ElectricApparentPowerUnit.Voltampere, false)] // Different value.
-        [InlineData(2, ElectricApparentPowerUnit.Voltampere, 1, ElectricApparentPowerUnit.Gigavoltampere, false)] // Different value and unit.
-        [InlineData(1, ElectricApparentPowerUnit.Voltampere, 1, ElectricApparentPowerUnit.Gigavoltampere, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricApparentPowerUnit unitA, double valueB, ElectricApparentPowerUnit unitB, bool expectEqual)
         {
             var a = new ElectricApparentPower(valueA, unitA);
@@ -621,8 +679,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricApparentPower.FromVoltamperes(firstValue);
             var otherQuantity = ElectricApparentPower.FromVoltamperes(secondValue);
             ElectricApparentPower maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricApparentPower.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -641,7 +699,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricApparentPowerUnit>();
+            var units = EnumHelper.GetValues<ElectricApparentPowerUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -654,6 +712,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricApparentPower.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricApparentPower.Info.Units, ElectricApparentPower.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricApparentPower.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -680,26 +750,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 VA", new ElectricApparentPower(1, ElectricApparentPowerUnit.Voltampere).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 VA", new ElectricApparentPower(0.123456, ElectricApparentPowerUnit.Voltampere).ToString("s1"));
-            Assert.Equal("0.12 VA", new ElectricApparentPower(0.123456, ElectricApparentPowerUnit.Voltampere).ToString("s2"));
-            Assert.Equal("0.123 VA", new ElectricApparentPower(0.123456, ElectricApparentPowerUnit.Voltampere).ToString("s3"));
-            Assert.Equal("0.1235 VA", new ElectricApparentPower(0.123456, ElectricApparentPowerUnit.Voltampere).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 VA", new ElectricApparentPower(0.123456, ElectricApparentPowerUnit.Voltampere).ToString("s1", culture));
-            Assert.Equal("0.12 VA", new ElectricApparentPower(0.123456, ElectricApparentPowerUnit.Voltampere).ToString("s2", culture));
-            Assert.Equal("0.123 VA", new ElectricApparentPower(0.123456, ElectricApparentPowerUnit.Voltampere).ToString("s3", culture));
-            Assert.Equal("0.1235 VA", new ElectricApparentPower(0.123456, ElectricApparentPowerUnit.Voltampere).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -726,7 +776,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricApparentPower.FromVoltamperes(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricApparentPower), quantity.As(ElectricApparentPower.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCapacitanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCapacitanceTestsBase.g.cs
index ba285112ff..98dc46263b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCapacitanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCapacitanceTestsBase.g.cs
@@ -149,6 +149,20 @@ public void ElectricCapacitance_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
             Assert.Equal(quantityInfo, ((IQuantity<ElectricCapacitanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricCapacitanceInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricCapacitanceUnit[] expectedUnits = [ElectricCapacitanceUnit.Farad];
+
+            ElectricCapacitance.ElectricCapacitanceInfo quantityInfo = ElectricCapacitance.ElectricCapacitanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricCapacitance", quantityInfo.Name);
+            Assert.Equal(ElectricCapacitance.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricCapacitance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void FaradToElectricCapacitanceUnits()
         {
@@ -245,26 +259,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricCapacitance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricCapacitance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricCapacitance quantityToConvert = quantity;
+
+                ElectricCapacitance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricCapacitanceUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricCapacitanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricCapacitance(value: 1, unit: ElectricCapacitance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricCapacitance(value: 1, unit: ElectricCapacitance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricCapacitanceUnit> quantity = new ElectricCapacitance(value: 1, unit: ElectricCapacitance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricCapacitance(value: 1, unit: ElectricCapacitance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricCapacitance(value: 1, unit: ElectricCapacitance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricCapacitance(value: 1, unit: ElectricCapacitance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricCapacitanceUnit> quantity = new ElectricCapacitance(value: 1, unit: ElectricCapacitance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricCapacitance(value: 1, unit: ElectricCapacitance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -275,7 +332,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mF", ElectricCapacitanceUnit.Millifarad, 4.2)]
         [InlineData("en-US", "4.2 nF", ElectricCapacitanceUnit.Nanofarad, 4.2)]
         [InlineData("en-US", "4.2 pF", ElectricCapacitanceUnit.Picofarad, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricCapacitanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricCapacitanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricCapacitance.Parse(quantityString);
@@ -291,7 +348,7 @@ public void Parse(string culture, string quantityString, ElectricCapacitanceUnit
         [InlineData("en-US", "4.2 mF", ElectricCapacitanceUnit.Millifarad, 4.2)]
         [InlineData("en-US", "4.2 nF", ElectricCapacitanceUnit.Nanofarad, 4.2)]
         [InlineData("en-US", "4.2 pF", ElectricCapacitanceUnit.Picofarad, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricCapacitanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricCapacitanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricCapacitance.TryParse(quantityString, out ElectricCapacitance parsed));
@@ -478,6 +535,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricCapacita
                 var quantity = ElectricCapacitance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -501,38 +559,40 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricCapacitance
                 IQuantity<ElectricCapacitanceUnit> quantityToConvert = quantity;
                 IQuantity<ElectricCapacitanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricCapacitance farad = ElectricCapacitance.FromFarads(1);
-            AssertEx.EqualTolerance(1, ElectricCapacitance.FromFarads(farad.Farads).Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCapacitance.FromKilofarads(farad.Kilofarads).Farads, KilofaradsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCapacitance.FromMegafarads(farad.Megafarads).Farads, MegafaradsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCapacitance.FromMicrofarads(farad.Microfarads).Farads, MicrofaradsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCapacitance.FromMillifarads(farad.Millifarads).Farads, MillifaradsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCapacitance.FromNanofarads(farad.Nanofarads).Farads, NanofaradsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCapacitance.FromPicofarads(farad.Picofarads).Farads, PicofaradsTolerance);
+            ElectricCapacitance farad = ElectricCapacitance.FromFarads(3);
+            Assert.Equal(3, ElectricCapacitance.FromFarads(farad.Farads).Farads);
+            Assert.Equal(3, ElectricCapacitance.FromKilofarads(farad.Kilofarads).Farads);
+            Assert.Equal(3, ElectricCapacitance.FromMegafarads(farad.Megafarads).Farads);
+            Assert.Equal(3, ElectricCapacitance.FromMicrofarads(farad.Microfarads).Farads);
+            Assert.Equal(3, ElectricCapacitance.FromMillifarads(farad.Millifarads).Farads);
+            Assert.Equal(3, ElectricCapacitance.FromNanofarads(farad.Nanofarads).Farads);
+            Assert.Equal(3, ElectricCapacitance.FromPicofarads(farad.Picofarads).Farads);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricCapacitance v = ElectricCapacitance.FromFarads(1);
-            AssertEx.EqualTolerance(-1, -v.Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCapacitance.FromFarads(3)-v).Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCapacitance.FromFarads(10)/5).Farads, FaradsTolerance);
-            AssertEx.EqualTolerance(2, ElectricCapacitance.FromFarads(10)/ElectricCapacitance.FromFarads(5), FaradsTolerance);
+            Assert.Equal(-1, -v.Farads);
+            Assert.Equal(2, (ElectricCapacitance.FromFarads(3) - v).Farads);
+            Assert.Equal(2, (v + v).Farads);
+            Assert.Equal(10, (v * 10).Farads);
+            Assert.Equal(10, (10 * v).Farads);
+            Assert.Equal(2, (ElectricCapacitance.FromFarads(10) / 5).Farads);
+            Assert.Equal(2, ElectricCapacitance.FromFarads(10) / ElectricCapacitance.FromFarads(5));
         }
 
         [Fact]
@@ -578,8 +638,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricCapacitanceUnit.Farad, 1, ElectricCapacitanceUnit.Farad, true)]  // Same value and unit.
         [InlineData(1, ElectricCapacitanceUnit.Farad, 2, ElectricCapacitanceUnit.Farad, false)] // Different value.
-        [InlineData(2, ElectricCapacitanceUnit.Farad, 1, ElectricCapacitanceUnit.Kilofarad, false)] // Different value and unit.
-        [InlineData(1, ElectricCapacitanceUnit.Farad, 1, ElectricCapacitanceUnit.Kilofarad, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricCapacitanceUnit unitA, double valueB, ElectricCapacitanceUnit unitB, bool expectEqual)
         {
             var a = new ElectricCapacitance(valueA, unitA);
@@ -639,8 +697,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricCapacitance.FromFarads(firstValue);
             var otherQuantity = ElectricCapacitance.FromFarads(secondValue);
             ElectricCapacitance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricCapacitance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -659,7 +717,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricCapacitanceUnit>();
+            var units = EnumHelper.GetValues<ElectricCapacitanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -672,6 +730,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricCapacitance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricCapacitance.Info.Units, ElectricCapacitance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricCapacitance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -700,26 +770,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 pF", new ElectricCapacitance(1, ElectricCapacitanceUnit.Picofarad).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 F", new ElectricCapacitance(0.123456, ElectricCapacitanceUnit.Farad).ToString("s1"));
-            Assert.Equal("0.12 F", new ElectricCapacitance(0.123456, ElectricCapacitanceUnit.Farad).ToString("s2"));
-            Assert.Equal("0.123 F", new ElectricCapacitance(0.123456, ElectricCapacitanceUnit.Farad).ToString("s3"));
-            Assert.Equal("0.1235 F", new ElectricCapacitance(0.123456, ElectricCapacitanceUnit.Farad).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 F", new ElectricCapacitance(0.123456, ElectricCapacitanceUnit.Farad).ToString("s1", culture));
-            Assert.Equal("0.12 F", new ElectricCapacitance(0.123456, ElectricCapacitanceUnit.Farad).ToString("s2", culture));
-            Assert.Equal("0.123 F", new ElectricCapacitance(0.123456, ElectricCapacitanceUnit.Farad).ToString("s3", culture));
-            Assert.Equal("0.1235 F", new ElectricCapacitance(0.123456, ElectricCapacitanceUnit.Farad).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -746,7 +796,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricCapacitance.FromFarads(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricCapacitance), quantity.As(ElectricCapacitance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeDensityTestsBase.g.cs
index 98973d7cea..5581c632e8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeDensityTestsBase.g.cs
@@ -125,6 +125,20 @@ public void ElectricChargeDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuan
             Assert.Equal(quantityInfo, ((IQuantity<ElectricChargeDensityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricChargeDensityInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricChargeDensityUnit[] expectedUnits = [ElectricChargeDensityUnit.CoulombPerCubicMeter];
+
+            ElectricChargeDensity.ElectricChargeDensityInfo quantityInfo = ElectricChargeDensity.ElectricChargeDensityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricChargeDensity", quantityInfo.Name);
+            Assert.Equal(ElectricChargeDensity.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricChargeDensity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CoulombPerCubicMeterToElectricChargeDensityUnits()
         {
@@ -209,31 +223,74 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricChargeDensity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricChargeDensity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricChargeDensity quantityToConvert = quantity;
+
+                ElectricChargeDensity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricChargeDensityUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricChargeDensityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricChargeDensity(value: 1, unit: ElectricChargeDensity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricChargeDensity(value: 1, unit: ElectricChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricChargeDensityUnit> quantity = new ElectricChargeDensity(value: 1, unit: ElectricChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricChargeDensity(value: 1, unit: ElectricChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricChargeDensity(value: 1, unit: ElectricChargeDensity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricChargeDensity(value: 1, unit: ElectricChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricChargeDensityUnit> quantity = new ElectricChargeDensity(value: 1, unit: ElectricChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricChargeDensity(value: 1, unit: ElectricChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 C/m³", ElectricChargeDensityUnit.CoulombPerCubicMeter, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricChargeDensityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricChargeDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricChargeDensity.Parse(quantityString);
@@ -243,7 +300,7 @@ public void Parse(string culture, string quantityString, ElectricChargeDensityUn
 
         [Theory]
         [InlineData("en-US", "4.2 C/m³", ElectricChargeDensityUnit.CoulombPerCubicMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricChargeDensityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricChargeDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricChargeDensity.TryParse(quantityString, out ElectricChargeDensity parsed));
@@ -376,6 +433,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricChargeDe
                 var quantity = ElectricChargeDensity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -399,32 +457,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricChargeDensi
                 IQuantity<ElectricChargeDensityUnit> quantityToConvert = quantity;
                 IQuantity<ElectricChargeDensityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricChargeDensity coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, ElectricChargeDensity.FromCoulombsPerCubicMeter(coulombpercubicmeter.CoulombsPerCubicMeter).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
+            ElectricChargeDensity coulombpercubicmeter = ElectricChargeDensity.FromCoulombsPerCubicMeter(3);
+            Assert.Equal(3, ElectricChargeDensity.FromCoulombsPerCubicMeter(coulombpercubicmeter.CoulombsPerCubicMeter).CoulombsPerCubicMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricChargeDensity v = ElectricChargeDensity.FromCoulombsPerCubicMeter(1);
-            AssertEx.EqualTolerance(-1, -v.CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricChargeDensity.FromCoulombsPerCubicMeter(3)-v).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricChargeDensity.FromCoulombsPerCubicMeter(10)/5).CoulombsPerCubicMeter, CoulombsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, ElectricChargeDensity.FromCoulombsPerCubicMeter(10)/ElectricChargeDensity.FromCoulombsPerCubicMeter(5), CoulombsPerCubicMeterTolerance);
+            Assert.Equal(-1, -v.CoulombsPerCubicMeter);
+            Assert.Equal(2, (ElectricChargeDensity.FromCoulombsPerCubicMeter(3) - v).CoulombsPerCubicMeter);
+            Assert.Equal(2, (v + v).CoulombsPerCubicMeter);
+            Assert.Equal(10, (v * 10).CoulombsPerCubicMeter);
+            Assert.Equal(10, (10 * v).CoulombsPerCubicMeter);
+            Assert.Equal(2, (ElectricChargeDensity.FromCoulombsPerCubicMeter(10) / 5).CoulombsPerCubicMeter);
+            Assert.Equal(2, ElectricChargeDensity.FromCoulombsPerCubicMeter(10) / ElectricChargeDensity.FromCoulombsPerCubicMeter(5));
         }
 
         [Fact]
@@ -470,7 +530,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricChargeDensityUnit.CoulombPerCubicMeter, 1, ElectricChargeDensityUnit.CoulombPerCubicMeter, true)]  // Same value and unit.
         [InlineData(1, ElectricChargeDensityUnit.CoulombPerCubicMeter, 2, ElectricChargeDensityUnit.CoulombPerCubicMeter, false)] // Different value.
-        [InlineData(2, ElectricChargeDensityUnit.CoulombPerCubicMeter, 1, ElectricChargeDensityUnit.CoulombPerCubicMeter, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricChargeDensityUnit unitA, double valueB, ElectricChargeDensityUnit unitB, bool expectEqual)
         {
             var a = new ElectricChargeDensity(valueA, unitA);
@@ -530,8 +589,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricChargeDensity.FromCoulombsPerCubicMeter(firstValue);
             var otherQuantity = ElectricChargeDensity.FromCoulombsPerCubicMeter(secondValue);
             ElectricChargeDensity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricChargeDensity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -550,7 +609,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricChargeDensityUnit>();
+            var units = EnumHelper.GetValues<ElectricChargeDensityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -564,39 +623,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 C/m³", new ElectricChargeDensity(1, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString());
+            Assert.Equal(ElectricChargeDensity.Info.Units, ElectricChargeDensity.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 C/m³", new ElectricChargeDensity(1, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, ElectricChargeDensity.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 C/m³", new ElectricChargeDensity(0.123456, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString("s1"));
-            Assert.Equal("0.12 C/m³", new ElectricChargeDensity(0.123456, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString("s2"));
-            Assert.Equal("0.123 C/m³", new ElectricChargeDensity(0.123456, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString("s3"));
-            Assert.Equal("0.1235 C/m³", new ElectricChargeDensity(0.123456, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 C/m³", new ElectricChargeDensity(1, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 C/m³", new ElectricChargeDensity(0.123456, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString("s1", culture));
-            Assert.Equal("0.12 C/m³", new ElectricChargeDensity(0.123456, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString("s2", culture));
-            Assert.Equal("0.123 C/m³", new ElectricChargeDensity(0.123456, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 C/m³", new ElectricChargeDensity(0.123456, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 C/m³", new ElectricChargeDensity(1, ElectricChargeDensityUnit.CoulombPerCubicMeter).ToString(swedishCulture));
         }
 
         [Theory]
@@ -625,7 +676,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricChargeDensity.FromCoulombsPerCubicMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricChargeDensity), quantity.As(ElectricChargeDensity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs
index 1ea18ab026..62e250ef91 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricChargeTestsBase.g.cs
@@ -165,6 +165,20 @@ public void ElectricCharge_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<ElectricChargeUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricChargeInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricChargeUnit[] expectedUnits = [ElectricChargeUnit.Coulomb];
+
+            ElectricCharge.ElectricChargeInfo quantityInfo = ElectricCharge.ElectricChargeInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricCharge", quantityInfo.Name);
+            Assert.Equal(ElectricCharge.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricCharge.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CoulombToElectricChargeUnits()
         {
@@ -269,26 +283,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricCharge.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricCharge convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricCharge quantityToConvert = quantity;
+
+                ElectricCharge convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricChargeUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricChargeUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricCharge(value: 1, unit: ElectricCharge.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricCharge(value: 1, unit: ElectricCharge.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricChargeUnit> quantity = new ElectricCharge(value: 1, unit: ElectricCharge.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricCharge(value: 1, unit: ElectricCharge.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricCharge(value: 1, unit: ElectricCharge.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricCharge(value: 1, unit: ElectricCharge.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricChargeUnit> quantity = new ElectricCharge(value: 1, unit: ElectricCharge.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricCharge(value: 1, unit: ElectricCharge.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -307,7 +364,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mC", ElectricChargeUnit.Millicoulomb, 4.2)]
         [InlineData("en-US", "4.2 nC", ElectricChargeUnit.Nanocoulomb, 4.2)]
         [InlineData("en-US", "4.2 pC", ElectricChargeUnit.Picocoulomb, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricChargeUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricChargeUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricCharge.Parse(quantityString);
@@ -331,7 +388,7 @@ public void Parse(string culture, string quantityString, ElectricChargeUnit expe
         [InlineData("en-US", "4.2 mC", ElectricChargeUnit.Millicoulomb, 4.2)]
         [InlineData("en-US", "4.2 nC", ElectricChargeUnit.Nanocoulomb, 4.2)]
         [InlineData("en-US", "4.2 pC", ElectricChargeUnit.Picocoulomb, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricChargeUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricChargeUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricCharge.TryParse(quantityString, out ElectricCharge parsed));
@@ -586,6 +643,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricChargeUn
                 var quantity = ElectricCharge.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -609,42 +667,44 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricChargeUnit
                 IQuantity<ElectricChargeUnit> quantityToConvert = quantity;
                 IQuantity<ElectricChargeUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricCharge coulomb = ElectricCharge.FromCoulombs(1);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromAmpereHours(coulomb.AmpereHours).Coulombs, AmpereHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromCoulombs(coulomb.Coulombs).Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromKiloampereHours(coulomb.KiloampereHours).Coulombs, KiloampereHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromKilocoulombs(coulomb.Kilocoulombs).Coulombs, KilocoulombsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromMegaampereHours(coulomb.MegaampereHours).Coulombs, MegaampereHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromMegacoulombs(coulomb.Megacoulombs).Coulombs, MegacoulombsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromMicrocoulombs(coulomb.Microcoulombs).Coulombs, MicrocoulombsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromMilliampereHours(coulomb.MilliampereHours).Coulombs, MilliampereHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromMillicoulombs(coulomb.Millicoulombs).Coulombs, MillicoulombsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromNanocoulombs(coulomb.Nanocoulombs).Coulombs, NanocoulombsTolerance);
-            AssertEx.EqualTolerance(1, ElectricCharge.FromPicocoulombs(coulomb.Picocoulombs).Coulombs, PicocoulombsTolerance);
+            ElectricCharge coulomb = ElectricCharge.FromCoulombs(3);
+            Assert.Equal(3, ElectricCharge.FromAmpereHours(coulomb.AmpereHours).Coulombs);
+            Assert.Equal(3, ElectricCharge.FromCoulombs(coulomb.Coulombs).Coulombs);
+            Assert.Equal(3, ElectricCharge.FromKiloampereHours(coulomb.KiloampereHours).Coulombs);
+            Assert.Equal(3, ElectricCharge.FromKilocoulombs(coulomb.Kilocoulombs).Coulombs);
+            Assert.Equal(3, ElectricCharge.FromMegaampereHours(coulomb.MegaampereHours).Coulombs);
+            Assert.Equal(3, ElectricCharge.FromMegacoulombs(coulomb.Megacoulombs).Coulombs);
+            Assert.Equal(3, ElectricCharge.FromMicrocoulombs(coulomb.Microcoulombs).Coulombs);
+            Assert.Equal(3, ElectricCharge.FromMilliampereHours(coulomb.MilliampereHours).Coulombs);
+            Assert.Equal(3, ElectricCharge.FromMillicoulombs(coulomb.Millicoulombs).Coulombs);
+            Assert.Equal(3, ElectricCharge.FromNanocoulombs(coulomb.Nanocoulombs).Coulombs);
+            Assert.Equal(3, ElectricCharge.FromPicocoulombs(coulomb.Picocoulombs).Coulombs);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricCharge v = ElectricCharge.FromCoulombs(1);
-            AssertEx.EqualTolerance(-1, -v.Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCharge.FromCoulombs(3)-v).Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCharge.FromCoulombs(10)/5).Coulombs, CoulombsTolerance);
-            AssertEx.EqualTolerance(2, ElectricCharge.FromCoulombs(10)/ElectricCharge.FromCoulombs(5), CoulombsTolerance);
+            Assert.Equal(-1, -v.Coulombs);
+            Assert.Equal(2, (ElectricCharge.FromCoulombs(3) - v).Coulombs);
+            Assert.Equal(2, (v + v).Coulombs);
+            Assert.Equal(10, (v * 10).Coulombs);
+            Assert.Equal(10, (10 * v).Coulombs);
+            Assert.Equal(2, (ElectricCharge.FromCoulombs(10) / 5).Coulombs);
+            Assert.Equal(2, ElectricCharge.FromCoulombs(10) / ElectricCharge.FromCoulombs(5));
         }
 
         [Fact]
@@ -690,8 +750,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricChargeUnit.Coulomb, 1, ElectricChargeUnit.Coulomb, true)]  // Same value and unit.
         [InlineData(1, ElectricChargeUnit.Coulomb, 2, ElectricChargeUnit.Coulomb, false)] // Different value.
-        [InlineData(2, ElectricChargeUnit.Coulomb, 1, ElectricChargeUnit.AmpereHour, false)] // Different value and unit.
-        [InlineData(1, ElectricChargeUnit.Coulomb, 1, ElectricChargeUnit.AmpereHour, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricChargeUnit unitA, double valueB, ElectricChargeUnit unitB, bool expectEqual)
         {
             var a = new ElectricCharge(valueA, unitA);
@@ -751,8 +809,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricCharge.FromCoulombs(firstValue);
             var otherQuantity = ElectricCharge.FromCoulombs(secondValue);
             ElectricCharge maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricCharge.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -771,7 +829,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricChargeUnit>();
+            var units = EnumHelper.GetValues<ElectricChargeUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -784,6 +842,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricCharge.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricCharge.Info.Units, ElectricCharge.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricCharge.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -820,26 +890,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 pC", new ElectricCharge(1, ElectricChargeUnit.Picocoulomb).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 C", new ElectricCharge(0.123456, ElectricChargeUnit.Coulomb).ToString("s1"));
-            Assert.Equal("0.12 C", new ElectricCharge(0.123456, ElectricChargeUnit.Coulomb).ToString("s2"));
-            Assert.Equal("0.123 C", new ElectricCharge(0.123456, ElectricChargeUnit.Coulomb).ToString("s3"));
-            Assert.Equal("0.1235 C", new ElectricCharge(0.123456, ElectricChargeUnit.Coulomb).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 C", new ElectricCharge(0.123456, ElectricChargeUnit.Coulomb).ToString("s1", culture));
-            Assert.Equal("0.12 C", new ElectricCharge(0.123456, ElectricChargeUnit.Coulomb).ToString("s2", culture));
-            Assert.Equal("0.123 C", new ElectricCharge(0.123456, ElectricChargeUnit.Coulomb).ToString("s3", culture));
-            Assert.Equal("0.1235 C", new ElectricCharge(0.123456, ElectricChargeUnit.Coulomb).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -866,7 +916,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricCharge.FromCoulombs(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricCharge), quantity.As(ElectricCharge.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductanceTestsBase.g.cs
index 0994d2484e..8fcf21a5c2 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductanceTestsBase.g.cs
@@ -185,6 +185,20 @@ public void ElectricConductance_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
             Assert.Equal(quantityInfo, ((IQuantity<ElectricConductanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricConductanceInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricConductanceUnit[] expectedUnits = [ElectricConductanceUnit.Siemens];
+
+            ElectricConductance.ElectricConductanceInfo quantityInfo = ElectricConductance.ElectricConductanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricConductance", quantityInfo.Name);
+            Assert.Equal(ElectricConductance.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricConductance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SiemensToElectricConductanceUnits()
         {
@@ -299,26 +313,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricConductance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricConductance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricConductance quantityToConvert = quantity;
+
+                ElectricConductance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricConductanceUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricConductanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricConductance(value: 1, unit: ElectricConductance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricConductance(value: 1, unit: ElectricConductance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricConductanceUnit> quantity = new ElectricConductance(value: 1, unit: ElectricConductance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricConductance(value: 1, unit: ElectricConductance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricConductance(value: 1, unit: ElectricConductance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricConductance(value: 1, unit: ElectricConductance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricConductanceUnit> quantity = new ElectricConductance(value: 1, unit: ElectricConductance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricConductance(value: 1, unit: ElectricConductance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -338,7 +395,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 S", ElectricConductanceUnit.Siemens, 4.2)]
         [InlineData("en-US", "4.2 T℧", ElectricConductanceUnit.Teramho, 4.2)]
         [InlineData("en-US", "4.2 TS", ElectricConductanceUnit.Terasiemens, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricConductanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricConductanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricConductance.Parse(quantityString);
@@ -363,7 +420,7 @@ public void Parse(string culture, string quantityString, ElectricConductanceUnit
         [InlineData("en-US", "4.2 S", ElectricConductanceUnit.Siemens, 4.2)]
         [InlineData("en-US", "4.2 T℧", ElectricConductanceUnit.Teramho, 4.2)]
         [InlineData("en-US", "4.2 TS", ElectricConductanceUnit.Terasiemens, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricConductanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricConductanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricConductance.TryParse(quantityString, out ElectricConductance parsed));
@@ -631,6 +688,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricConducta
                 var quantity = ElectricConductance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -654,47 +712,49 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricConductance
                 IQuantity<ElectricConductanceUnit> quantityToConvert = quantity;
                 IQuantity<ElectricConductanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricConductance siemens = ElectricConductance.FromSiemens(1);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromGigamhos(siemens.Gigamhos).Siemens, GigamhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromGigasiemens(siemens.Gigasiemens).Siemens, GigasiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromKilomhos(siemens.Kilomhos).Siemens, KilomhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromKilosiemens(siemens.Kilosiemens).Siemens, KilosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromMegamhos(siemens.Megamhos).Siemens, MegamhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromMegasiemens(siemens.Megasiemens).Siemens, MegasiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromMhos(siemens.Mhos).Siemens, MhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromMicromhos(siemens.Micromhos).Siemens, MicromhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromMicrosiemens(siemens.Microsiemens).Siemens, MicrosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromMillimhos(siemens.Millimhos).Siemens, MillimhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromMillisiemens(siemens.Millisiemens).Siemens, MillisiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromNanomhos(siemens.Nanomhos).Siemens, NanomhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromNanosiemens(siemens.Nanosiemens).Siemens, NanosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromSiemens(siemens.Siemens).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromTeramhos(siemens.Teramhos).Siemens, TeramhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductance.FromTerasiemens(siemens.Terasiemens).Siemens, TerasiemensTolerance);
+            ElectricConductance siemens = ElectricConductance.FromSiemens(3);
+            Assert.Equal(3, ElectricConductance.FromGigamhos(siemens.Gigamhos).Siemens);
+            Assert.Equal(3, ElectricConductance.FromGigasiemens(siemens.Gigasiemens).Siemens);
+            Assert.Equal(3, ElectricConductance.FromKilomhos(siemens.Kilomhos).Siemens);
+            Assert.Equal(3, ElectricConductance.FromKilosiemens(siemens.Kilosiemens).Siemens);
+            Assert.Equal(3, ElectricConductance.FromMegamhos(siemens.Megamhos).Siemens);
+            Assert.Equal(3, ElectricConductance.FromMegasiemens(siemens.Megasiemens).Siemens);
+            Assert.Equal(3, ElectricConductance.FromMhos(siemens.Mhos).Siemens);
+            Assert.Equal(3, ElectricConductance.FromMicromhos(siemens.Micromhos).Siemens);
+            Assert.Equal(3, ElectricConductance.FromMicrosiemens(siemens.Microsiemens).Siemens);
+            Assert.Equal(3, ElectricConductance.FromMillimhos(siemens.Millimhos).Siemens);
+            Assert.Equal(3, ElectricConductance.FromMillisiemens(siemens.Millisiemens).Siemens);
+            Assert.Equal(3, ElectricConductance.FromNanomhos(siemens.Nanomhos).Siemens);
+            Assert.Equal(3, ElectricConductance.FromNanosiemens(siemens.Nanosiemens).Siemens);
+            Assert.Equal(3, ElectricConductance.FromSiemens(siemens.Siemens).Siemens);
+            Assert.Equal(3, ElectricConductance.FromTeramhos(siemens.Teramhos).Siemens);
+            Assert.Equal(3, ElectricConductance.FromTerasiemens(siemens.Terasiemens).Siemens);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricConductance v = ElectricConductance.FromSiemens(1);
-            AssertEx.EqualTolerance(-1, -v.Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (ElectricConductance.FromSiemens(3)-v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (ElectricConductance.FromSiemens(10)/5).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, ElectricConductance.FromSiemens(10)/ElectricConductance.FromSiemens(5), SiemensTolerance);
+            Assert.Equal(-1, -v.Siemens);
+            Assert.Equal(2, (ElectricConductance.FromSiemens(3) - v).Siemens);
+            Assert.Equal(2, (v + v).Siemens);
+            Assert.Equal(10, (v * 10).Siemens);
+            Assert.Equal(10, (10 * v).Siemens);
+            Assert.Equal(2, (ElectricConductance.FromSiemens(10) / 5).Siemens);
+            Assert.Equal(2, ElectricConductance.FromSiemens(10) / ElectricConductance.FromSiemens(5));
         }
 
         [Fact]
@@ -740,8 +800,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricConductanceUnit.Siemens, 1, ElectricConductanceUnit.Siemens, true)]  // Same value and unit.
         [InlineData(1, ElectricConductanceUnit.Siemens, 2, ElectricConductanceUnit.Siemens, false)] // Different value.
-        [InlineData(2, ElectricConductanceUnit.Siemens, 1, ElectricConductanceUnit.Gigamho, false)] // Different value and unit.
-        [InlineData(1, ElectricConductanceUnit.Siemens, 1, ElectricConductanceUnit.Gigamho, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricConductanceUnit unitA, double valueB, ElectricConductanceUnit unitB, bool expectEqual)
         {
             var a = new ElectricConductance(valueA, unitA);
@@ -801,8 +859,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricConductance.FromSiemens(firstValue);
             var otherQuantity = ElectricConductance.FromSiemens(secondValue);
             ElectricConductance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricConductance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -821,7 +879,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricConductanceUnit>();
+            var units = EnumHelper.GetValues<ElectricConductanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -834,6 +892,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricConductance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricConductance.Info.Units, ElectricConductance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricConductance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -880,26 +950,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 TS", new ElectricConductance(1, ElectricConductanceUnit.Terasiemens).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 S", new ElectricConductance(0.123456, ElectricConductanceUnit.Siemens).ToString("s1"));
-            Assert.Equal("0.12 S", new ElectricConductance(0.123456, ElectricConductanceUnit.Siemens).ToString("s2"));
-            Assert.Equal("0.123 S", new ElectricConductance(0.123456, ElectricConductanceUnit.Siemens).ToString("s3"));
-            Assert.Equal("0.1235 S", new ElectricConductance(0.123456, ElectricConductanceUnit.Siemens).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 S", new ElectricConductance(0.123456, ElectricConductanceUnit.Siemens).ToString("s1", culture));
-            Assert.Equal("0.12 S", new ElectricConductance(0.123456, ElectricConductanceUnit.Siemens).ToString("s2", culture));
-            Assert.Equal("0.123 S", new ElectricConductance(0.123456, ElectricConductanceUnit.Siemens).ToString("s3", culture));
-            Assert.Equal("0.1235 S", new ElectricConductance(0.123456, ElectricConductanceUnit.Siemens).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -926,7 +976,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricConductance.FromSiemens(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricConductance), quantity.As(ElectricConductance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs
index 2c1f78e00b..e586a71a0e 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricConductivityTestsBase.g.cs
@@ -145,6 +145,20 @@ public void ElectricConductivity_QuantityInfo_ReturnsQuantityInfoDescribingQuant
             Assert.Equal(quantityInfo, ((IQuantity<ElectricConductivityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricConductivityInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricConductivityUnit[] expectedUnits = [ElectricConductivityUnit.SiemensPerMeter];
+
+            ElectricConductivity.ElectricConductivityInfo quantityInfo = ElectricConductivity.ElectricConductivityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricConductivity", quantityInfo.Name);
+            Assert.Equal(ElectricConductivity.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricConductivity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SiemensPerMeterToElectricConductivityUnits()
         {
@@ -239,26 +253,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricConductivity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricConductivity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricConductivity quantityToConvert = quantity;
+
+                ElectricConductivity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricConductivityUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricConductivityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricConductivity(value: 1, unit: ElectricConductivity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricConductivity(value: 1, unit: ElectricConductivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricConductivityUnit> quantity = new ElectricConductivity(value: 1, unit: ElectricConductivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricConductivity(value: 1, unit: ElectricConductivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricConductivity(value: 1, unit: ElectricConductivity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricConductivity(value: 1, unit: ElectricConductivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricConductivityUnit> quantity = new ElectricConductivity(value: 1, unit: ElectricConductivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricConductivity(value: 1, unit: ElectricConductivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -268,7 +325,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 S/ft", ElectricConductivityUnit.SiemensPerFoot, 4.2)]
         [InlineData("en-US", "4.2 S/in", ElectricConductivityUnit.SiemensPerInch, 4.2)]
         [InlineData("en-US", "4.2 S/m", ElectricConductivityUnit.SiemensPerMeter, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricConductivityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricConductivityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricConductivity.Parse(quantityString);
@@ -283,7 +340,7 @@ public void Parse(string culture, string quantityString, ElectricConductivityUni
         [InlineData("en-US", "4.2 S/ft", ElectricConductivityUnit.SiemensPerFoot, 4.2)]
         [InlineData("en-US", "4.2 S/in", ElectricConductivityUnit.SiemensPerInch, 4.2)]
         [InlineData("en-US", "4.2 S/m", ElectricConductivityUnit.SiemensPerMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricConductivityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricConductivityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricConductivity.TryParse(quantityString, out ElectricConductivity parsed));
@@ -461,6 +518,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricConducti
                 var quantity = ElectricConductivity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -484,37 +542,39 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricConductivit
                 IQuantity<ElectricConductivityUnit> quantityToConvert = quantity;
                 IQuantity<ElectricConductivityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricConductivity siemenspermeter = ElectricConductivity.FromSiemensPerMeter(1);
-            AssertEx.EqualTolerance(1, ElectricConductivity.FromMicrosiemensPerCentimeter(siemenspermeter.MicrosiemensPerCentimeter).SiemensPerMeter, MicrosiemensPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductivity.FromMillisiemensPerCentimeter(siemenspermeter.MillisiemensPerCentimeter).SiemensPerMeter, MillisiemensPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductivity.FromSiemensPerCentimeter(siemenspermeter.SiemensPerCentimeter).SiemensPerMeter, SiemensPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductivity.FromSiemensPerFoot(siemenspermeter.SiemensPerFoot).SiemensPerMeter, SiemensPerFootTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductivity.FromSiemensPerInch(siemenspermeter.SiemensPerInch).SiemensPerMeter, SiemensPerInchTolerance);
-            AssertEx.EqualTolerance(1, ElectricConductivity.FromSiemensPerMeter(siemenspermeter.SiemensPerMeter).SiemensPerMeter, SiemensPerMeterTolerance);
+            ElectricConductivity siemenspermeter = ElectricConductivity.FromSiemensPerMeter(3);
+            Assert.Equal(3, ElectricConductivity.FromMicrosiemensPerCentimeter(siemenspermeter.MicrosiemensPerCentimeter).SiemensPerMeter);
+            Assert.Equal(3, ElectricConductivity.FromMillisiemensPerCentimeter(siemenspermeter.MillisiemensPerCentimeter).SiemensPerMeter);
+            Assert.Equal(3, ElectricConductivity.FromSiemensPerCentimeter(siemenspermeter.SiemensPerCentimeter).SiemensPerMeter);
+            Assert.Equal(3, ElectricConductivity.FromSiemensPerFoot(siemenspermeter.SiemensPerFoot).SiemensPerMeter);
+            Assert.Equal(3, ElectricConductivity.FromSiemensPerInch(siemenspermeter.SiemensPerInch).SiemensPerMeter);
+            Assert.Equal(3, ElectricConductivity.FromSiemensPerMeter(siemenspermeter.SiemensPerMeter).SiemensPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricConductivity v = ElectricConductivity.FromSiemensPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.SiemensPerMeter, SiemensPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricConductivity.FromSiemensPerMeter(3)-v).SiemensPerMeter, SiemensPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).SiemensPerMeter, SiemensPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).SiemensPerMeter, SiemensPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).SiemensPerMeter, SiemensPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricConductivity.FromSiemensPerMeter(10)/5).SiemensPerMeter, SiemensPerMeterTolerance);
-            AssertEx.EqualTolerance(2, ElectricConductivity.FromSiemensPerMeter(10)/ElectricConductivity.FromSiemensPerMeter(5), SiemensPerMeterTolerance);
+            Assert.Equal(-1, -v.SiemensPerMeter);
+            Assert.Equal(2, (ElectricConductivity.FromSiemensPerMeter(3) - v).SiemensPerMeter);
+            Assert.Equal(2, (v + v).SiemensPerMeter);
+            Assert.Equal(10, (v * 10).SiemensPerMeter);
+            Assert.Equal(10, (10 * v).SiemensPerMeter);
+            Assert.Equal(2, (ElectricConductivity.FromSiemensPerMeter(10) / 5).SiemensPerMeter);
+            Assert.Equal(2, ElectricConductivity.FromSiemensPerMeter(10) / ElectricConductivity.FromSiemensPerMeter(5));
         }
 
         [Fact]
@@ -560,8 +620,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricConductivityUnit.SiemensPerMeter, 1, ElectricConductivityUnit.SiemensPerMeter, true)]  // Same value and unit.
         [InlineData(1, ElectricConductivityUnit.SiemensPerMeter, 2, ElectricConductivityUnit.SiemensPerMeter, false)] // Different value.
-        [InlineData(2, ElectricConductivityUnit.SiemensPerMeter, 1, ElectricConductivityUnit.MicrosiemensPerCentimeter, false)] // Different value and unit.
-        [InlineData(1, ElectricConductivityUnit.SiemensPerMeter, 1, ElectricConductivityUnit.MicrosiemensPerCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricConductivityUnit unitA, double valueB, ElectricConductivityUnit unitB, bool expectEqual)
         {
             var a = new ElectricConductivity(valueA, unitA);
@@ -621,8 +679,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricConductivity.FromSiemensPerMeter(firstValue);
             var otherQuantity = ElectricConductivity.FromSiemensPerMeter(secondValue);
             ElectricConductivity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricConductivity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -641,7 +699,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricConductivityUnit>();
+            var units = EnumHelper.GetValues<ElectricConductivityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -654,6 +712,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricConductivity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricConductivity.Info.Units, ElectricConductivity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricConductivity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -680,26 +750,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 S/m", new ElectricConductivity(1, ElectricConductivityUnit.SiemensPerMeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 S/m", new ElectricConductivity(0.123456, ElectricConductivityUnit.SiemensPerMeter).ToString("s1"));
-            Assert.Equal("0.12 S/m", new ElectricConductivity(0.123456, ElectricConductivityUnit.SiemensPerMeter).ToString("s2"));
-            Assert.Equal("0.123 S/m", new ElectricConductivity(0.123456, ElectricConductivityUnit.SiemensPerMeter).ToString("s3"));
-            Assert.Equal("0.1235 S/m", new ElectricConductivity(0.123456, ElectricConductivityUnit.SiemensPerMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 S/m", new ElectricConductivity(0.123456, ElectricConductivityUnit.SiemensPerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 S/m", new ElectricConductivity(0.123456, ElectricConductivityUnit.SiemensPerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 S/m", new ElectricConductivity(0.123456, ElectricConductivityUnit.SiemensPerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 S/m", new ElectricConductivity(0.123456, ElectricConductivityUnit.SiemensPerMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -726,7 +776,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricConductivity.FromSiemensPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricConductivity), quantity.As(ElectricConductivity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentDensityTestsBase.g.cs
index c232faff41..619ac911a9 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentDensityTestsBase.g.cs
@@ -133,6 +133,20 @@ public void ElectricCurrentDensity_QuantityInfo_ReturnsQuantityInfoDescribingQua
             Assert.Equal(quantityInfo, ((IQuantity<ElectricCurrentDensityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricCurrentDensityInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricCurrentDensityUnit[] expectedUnits = [ElectricCurrentDensityUnit.AmperePerSquareMeter];
+
+            ElectricCurrentDensity.ElectricCurrentDensityInfo quantityInfo = ElectricCurrentDensity.ElectricCurrentDensityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricCurrentDensity", quantityInfo.Name);
+            Assert.Equal(ElectricCurrentDensity.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricCurrentDensity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void AmperePerSquareMeterToElectricCurrentDensityUnits()
         {
@@ -221,33 +235,76 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricCurrentDensity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricCurrentDensity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricCurrentDensity quantityToConvert = quantity;
+
+                ElectricCurrentDensity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricCurrentDensityUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricCurrentDensityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricCurrentDensity(value: 1, unit: ElectricCurrentDensity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricCurrentDensity(value: 1, unit: ElectricCurrentDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricCurrentDensityUnit> quantity = new ElectricCurrentDensity(value: 1, unit: ElectricCurrentDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricCurrentDensity(value: 1, unit: ElectricCurrentDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricCurrentDensity(value: 1, unit: ElectricCurrentDensity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricCurrentDensity(value: 1, unit: ElectricCurrentDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricCurrentDensityUnit> quantity = new ElectricCurrentDensity(value: 1, unit: ElectricCurrentDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricCurrentDensity(value: 1, unit: ElectricCurrentDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 A/ft²", ElectricCurrentDensityUnit.AmperePerSquareFoot, 4.2)]
         [InlineData("en-US", "4.2 A/in²", ElectricCurrentDensityUnit.AmperePerSquareInch, 4.2)]
         [InlineData("en-US", "4.2 A/m²", ElectricCurrentDensityUnit.AmperePerSquareMeter, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricCurrentDensityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricCurrentDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricCurrentDensity.Parse(quantityString);
@@ -259,7 +316,7 @@ public void Parse(string culture, string quantityString, ElectricCurrentDensityU
         [InlineData("en-US", "4.2 A/ft²", ElectricCurrentDensityUnit.AmperePerSquareFoot, 4.2)]
         [InlineData("en-US", "4.2 A/in²", ElectricCurrentDensityUnit.AmperePerSquareInch, 4.2)]
         [InlineData("en-US", "4.2 A/m²", ElectricCurrentDensityUnit.AmperePerSquareMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricCurrentDensityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricCurrentDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricCurrentDensity.TryParse(quantityString, out ElectricCurrentDensity parsed));
@@ -410,6 +467,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricCurrentD
                 var quantity = ElectricCurrentDensity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -433,34 +491,36 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricCurrentDens
                 IQuantity<ElectricCurrentDensityUnit> quantityToConvert = quantity;
                 IQuantity<ElectricCurrentDensityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricCurrentDensity amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, ElectricCurrentDensity.FromAmperesPerSquareFoot(amperepersquaremeter.AmperesPerSquareFoot).AmperesPerSquareMeter, AmperesPerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentDensity.FromAmperesPerSquareInch(amperepersquaremeter.AmperesPerSquareInch).AmperesPerSquareMeter, AmperesPerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentDensity.FromAmperesPerSquareMeter(amperepersquaremeter.AmperesPerSquareMeter).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
+            ElectricCurrentDensity amperepersquaremeter = ElectricCurrentDensity.FromAmperesPerSquareMeter(3);
+            Assert.Equal(3, ElectricCurrentDensity.FromAmperesPerSquareFoot(amperepersquaremeter.AmperesPerSquareFoot).AmperesPerSquareMeter);
+            Assert.Equal(3, ElectricCurrentDensity.FromAmperesPerSquareInch(amperepersquaremeter.AmperesPerSquareInch).AmperesPerSquareMeter);
+            Assert.Equal(3, ElectricCurrentDensity.FromAmperesPerSquareMeter(amperepersquaremeter.AmperesPerSquareMeter).AmperesPerSquareMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricCurrentDensity v = ElectricCurrentDensity.FromAmperesPerSquareMeter(1);
-            AssertEx.EqualTolerance(-1, -v.AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrentDensity.FromAmperesPerSquareMeter(3)-v).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrentDensity.FromAmperesPerSquareMeter(10)/5).AmperesPerSquareMeter, AmperesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, ElectricCurrentDensity.FromAmperesPerSquareMeter(10)/ElectricCurrentDensity.FromAmperesPerSquareMeter(5), AmperesPerSquareMeterTolerance);
+            Assert.Equal(-1, -v.AmperesPerSquareMeter);
+            Assert.Equal(2, (ElectricCurrentDensity.FromAmperesPerSquareMeter(3) - v).AmperesPerSquareMeter);
+            Assert.Equal(2, (v + v).AmperesPerSquareMeter);
+            Assert.Equal(10, (v * 10).AmperesPerSquareMeter);
+            Assert.Equal(10, (10 * v).AmperesPerSquareMeter);
+            Assert.Equal(2, (ElectricCurrentDensity.FromAmperesPerSquareMeter(10) / 5).AmperesPerSquareMeter);
+            Assert.Equal(2, ElectricCurrentDensity.FromAmperesPerSquareMeter(10) / ElectricCurrentDensity.FromAmperesPerSquareMeter(5));
         }
 
         [Fact]
@@ -506,8 +566,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricCurrentDensityUnit.AmperePerSquareMeter, 1, ElectricCurrentDensityUnit.AmperePerSquareMeter, true)]  // Same value and unit.
         [InlineData(1, ElectricCurrentDensityUnit.AmperePerSquareMeter, 2, ElectricCurrentDensityUnit.AmperePerSquareMeter, false)] // Different value.
-        [InlineData(2, ElectricCurrentDensityUnit.AmperePerSquareMeter, 1, ElectricCurrentDensityUnit.AmperePerSquareFoot, false)] // Different value and unit.
-        [InlineData(1, ElectricCurrentDensityUnit.AmperePerSquareMeter, 1, ElectricCurrentDensityUnit.AmperePerSquareFoot, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricCurrentDensityUnit unitA, double valueB, ElectricCurrentDensityUnit unitB, bool expectEqual)
         {
             var a = new ElectricCurrentDensity(valueA, unitA);
@@ -567,8 +625,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricCurrentDensity.FromAmperesPerSquareMeter(firstValue);
             var otherQuantity = ElectricCurrentDensity.FromAmperesPerSquareMeter(secondValue);
             ElectricCurrentDensity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricCurrentDensity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -587,7 +645,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricCurrentDensityUnit>();
+            var units = EnumHelper.GetValues<ElectricCurrentDensityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -600,6 +658,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricCurrentDensity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricCurrentDensity.Info.Units, ElectricCurrentDensity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricCurrentDensity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -620,26 +690,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 A/m²", new ElectricCurrentDensity(1, ElectricCurrentDensityUnit.AmperePerSquareMeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 A/m²", new ElectricCurrentDensity(0.123456, ElectricCurrentDensityUnit.AmperePerSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 A/m²", new ElectricCurrentDensity(0.123456, ElectricCurrentDensityUnit.AmperePerSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 A/m²", new ElectricCurrentDensity(0.123456, ElectricCurrentDensityUnit.AmperePerSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 A/m²", new ElectricCurrentDensity(0.123456, ElectricCurrentDensityUnit.AmperePerSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 A/m²", new ElectricCurrentDensity(0.123456, ElectricCurrentDensityUnit.AmperePerSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 A/m²", new ElectricCurrentDensity(0.123456, ElectricCurrentDensityUnit.AmperePerSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 A/m²", new ElectricCurrentDensity(0.123456, ElectricCurrentDensityUnit.AmperePerSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 A/m²", new ElectricCurrentDensity(0.123456, ElectricCurrentDensityUnit.AmperePerSquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -666,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricCurrentDensity.FromAmperesPerSquareMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricCurrentDensity), quantity.As(ElectricCurrentDensity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs
index 52921cb032..81c9667a52 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs
@@ -149,6 +149,20 @@ public void ElectricCurrentGradient_QuantityInfo_ReturnsQuantityInfoDescribingQu
             Assert.Equal(quantityInfo, ((IQuantity<ElectricCurrentGradientUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricCurrentGradientInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricCurrentGradientUnit[] expectedUnits = [ElectricCurrentGradientUnit.AmperePerSecond];
+
+            ElectricCurrentGradient.ElectricCurrentGradientInfo quantityInfo = ElectricCurrentGradient.ElectricCurrentGradientInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricCurrentGradient", quantityInfo.Name);
+            Assert.Equal(ElectricCurrentGradient.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricCurrentGradient.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void AmperePerSecondToElectricCurrentGradientUnits()
         {
@@ -245,26 +259,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricCurrentGradient.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricCurrentGradient convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricCurrentGradient quantityToConvert = quantity;
+
+                ElectricCurrentGradient convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricCurrentGradientUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricCurrentGradientUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricCurrentGradient(value: 1, unit: ElectricCurrentGradient.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricCurrentGradient(value: 1, unit: ElectricCurrentGradient.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricCurrentGradientUnit> quantity = new ElectricCurrentGradient(value: 1, unit: ElectricCurrentGradient.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricCurrentGradient(value: 1, unit: ElectricCurrentGradient.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricCurrentGradient(value: 1, unit: ElectricCurrentGradient.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricCurrentGradient(value: 1, unit: ElectricCurrentGradient.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricCurrentGradientUnit> quantity = new ElectricCurrentGradient(value: 1, unit: ElectricCurrentGradient.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricCurrentGradient(value: 1, unit: ElectricCurrentGradient.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -275,7 +332,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 A/s", ElectricCurrentGradientUnit.AmperePerSecond, 4.2)]
         [InlineData("en-US", "4.2 mA/min", ElectricCurrentGradientUnit.MilliamperePerMinute, 4.2)]
         [InlineData("en-US", "4.2 mA/s", ElectricCurrentGradientUnit.MilliamperePerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricCurrentGradientUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricCurrentGradientUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricCurrentGradient.Parse(quantityString);
@@ -291,7 +348,7 @@ public void Parse(string culture, string quantityString, ElectricCurrentGradient
         [InlineData("en-US", "4.2 A/s", ElectricCurrentGradientUnit.AmperePerSecond, 4.2)]
         [InlineData("en-US", "4.2 mA/min", ElectricCurrentGradientUnit.MilliamperePerMinute, 4.2)]
         [InlineData("en-US", "4.2 mA/s", ElectricCurrentGradientUnit.MilliamperePerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricCurrentGradientUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricCurrentGradientUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricCurrentGradient.TryParse(quantityString, out ElectricCurrentGradient parsed));
@@ -478,6 +535,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricCurrentG
                 var quantity = ElectricCurrentGradient.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -501,38 +559,40 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricCurrentGrad
                 IQuantity<ElectricCurrentGradientUnit> quantityToConvert = quantity;
                 IQuantity<ElectricCurrentGradientUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerMicrosecond(amperepersecond.AmperesPerMicrosecond).AmperesPerSecond, AmperesPerMicrosecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerMillisecond(amperepersecond.AmperesPerMillisecond).AmperesPerSecond, AmperesPerMillisecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerMinute(amperepersecond.AmperesPerMinute).AmperesPerSecond, AmperesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerNanosecond(amperepersecond.AmperesPerNanosecond).AmperesPerSecond, AmperesPerNanosecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerSecond(amperepersecond.AmperesPerSecond).AmperesPerSecond, AmperesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromMilliamperesPerMinute(amperepersecond.MilliamperesPerMinute).AmperesPerSecond, MilliamperesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromMilliamperesPerSecond(amperepersecond.MilliamperesPerSecond).AmperesPerSecond, MilliamperesPerSecondTolerance);
+            ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(3);
+            Assert.Equal(3, ElectricCurrentGradient.FromAmperesPerMicrosecond(amperepersecond.AmperesPerMicrosecond).AmperesPerSecond);
+            Assert.Equal(3, ElectricCurrentGradient.FromAmperesPerMillisecond(amperepersecond.AmperesPerMillisecond).AmperesPerSecond);
+            Assert.Equal(3, ElectricCurrentGradient.FromAmperesPerMinute(amperepersecond.AmperesPerMinute).AmperesPerSecond);
+            Assert.Equal(3, ElectricCurrentGradient.FromAmperesPerNanosecond(amperepersecond.AmperesPerNanosecond).AmperesPerSecond);
+            Assert.Equal(3, ElectricCurrentGradient.FromAmperesPerSecond(amperepersecond.AmperesPerSecond).AmperesPerSecond);
+            Assert.Equal(3, ElectricCurrentGradient.FromMilliamperesPerMinute(amperepersecond.MilliamperesPerMinute).AmperesPerSecond);
+            Assert.Equal(3, ElectricCurrentGradient.FromMilliamperesPerSecond(amperepersecond.MilliamperesPerSecond).AmperesPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricCurrentGradient v = ElectricCurrentGradient.FromAmperesPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.AmperesPerSecond, AmperesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrentGradient.FromAmperesPerSecond(3)-v).AmperesPerSecond, AmperesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).AmperesPerSecond, AmperesPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).AmperesPerSecond, AmperesPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).AmperesPerSecond, AmperesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrentGradient.FromAmperesPerSecond(10)/5).AmperesPerSecond, AmperesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, ElectricCurrentGradient.FromAmperesPerSecond(10)/ElectricCurrentGradient.FromAmperesPerSecond(5), AmperesPerSecondTolerance);
+            Assert.Equal(-1, -v.AmperesPerSecond);
+            Assert.Equal(2, (ElectricCurrentGradient.FromAmperesPerSecond(3) - v).AmperesPerSecond);
+            Assert.Equal(2, (v + v).AmperesPerSecond);
+            Assert.Equal(10, (v * 10).AmperesPerSecond);
+            Assert.Equal(10, (10 * v).AmperesPerSecond);
+            Assert.Equal(2, (ElectricCurrentGradient.FromAmperesPerSecond(10) / 5).AmperesPerSecond);
+            Assert.Equal(2, ElectricCurrentGradient.FromAmperesPerSecond(10) / ElectricCurrentGradient.FromAmperesPerSecond(5));
         }
 
         [Fact]
@@ -578,8 +638,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricCurrentGradientUnit.AmperePerSecond, 1, ElectricCurrentGradientUnit.AmperePerSecond, true)]  // Same value and unit.
         [InlineData(1, ElectricCurrentGradientUnit.AmperePerSecond, 2, ElectricCurrentGradientUnit.AmperePerSecond, false)] // Different value.
-        [InlineData(2, ElectricCurrentGradientUnit.AmperePerSecond, 1, ElectricCurrentGradientUnit.AmperePerMicrosecond, false)] // Different value and unit.
-        [InlineData(1, ElectricCurrentGradientUnit.AmperePerSecond, 1, ElectricCurrentGradientUnit.AmperePerMicrosecond, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricCurrentGradientUnit unitA, double valueB, ElectricCurrentGradientUnit unitB, bool expectEqual)
         {
             var a = new ElectricCurrentGradient(valueA, unitA);
@@ -639,8 +697,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricCurrentGradient.FromAmperesPerSecond(firstValue);
             var otherQuantity = ElectricCurrentGradient.FromAmperesPerSecond(secondValue);
             ElectricCurrentGradient maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricCurrentGradient.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -659,7 +717,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricCurrentGradientUnit>();
+            var units = EnumHelper.GetValues<ElectricCurrentGradientUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -672,6 +730,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricCurrentGradient.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricCurrentGradient.Info.Units, ElectricCurrentGradient.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricCurrentGradient.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -700,26 +770,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 mA/s", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.MilliamperePerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 A/s", new ElectricCurrentGradient(0.123456, ElectricCurrentGradientUnit.AmperePerSecond).ToString("s1"));
-            Assert.Equal("0.12 A/s", new ElectricCurrentGradient(0.123456, ElectricCurrentGradientUnit.AmperePerSecond).ToString("s2"));
-            Assert.Equal("0.123 A/s", new ElectricCurrentGradient(0.123456, ElectricCurrentGradientUnit.AmperePerSecond).ToString("s3"));
-            Assert.Equal("0.1235 A/s", new ElectricCurrentGradient(0.123456, ElectricCurrentGradientUnit.AmperePerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 A/s", new ElectricCurrentGradient(0.123456, ElectricCurrentGradientUnit.AmperePerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 A/s", new ElectricCurrentGradient(0.123456, ElectricCurrentGradientUnit.AmperePerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 A/s", new ElectricCurrentGradient(0.123456, ElectricCurrentGradientUnit.AmperePerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 A/s", new ElectricCurrentGradient(0.123456, ElectricCurrentGradientUnit.AmperePerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -746,7 +796,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricCurrentGradient.FromAmperesPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricCurrentGradient), quantity.As(ElectricCurrentGradient.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs
index a2ab2d38d1..678af9af70 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentTestsBase.g.cs
@@ -157,6 +157,20 @@ public void ElectricCurrent_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<ElectricCurrentUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricCurrentInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricCurrentUnit[] expectedUnits = [ElectricCurrentUnit.Ampere];
+
+            ElectricCurrent.ElectricCurrentInfo quantityInfo = ElectricCurrent.ElectricCurrentInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricCurrent", quantityInfo.Name);
+            Assert.Equal(ElectricCurrent.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricCurrent.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void AmpereToElectricCurrentUnits()
         {
@@ -257,26 +271,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricCurrent.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricCurrent convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricCurrent quantityToConvert = quantity;
+
+                ElectricCurrent convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricCurrentUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricCurrentUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricCurrent(value: 1, unit: ElectricCurrent.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricCurrent(value: 1, unit: ElectricCurrent.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricCurrentUnit> quantity = new ElectricCurrent(value: 1, unit: ElectricCurrent.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricCurrent(value: 1, unit: ElectricCurrent.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricCurrent(value: 1, unit: ElectricCurrent.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricCurrent(value: 1, unit: ElectricCurrent.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricCurrentUnit> quantity = new ElectricCurrent(value: 1, unit: ElectricCurrent.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricCurrent(value: 1, unit: ElectricCurrent.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -289,7 +346,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mA", ElectricCurrentUnit.Milliampere, 4.2)]
         [InlineData("en-US", "4.2 nA", ElectricCurrentUnit.Nanoampere, 4.2)]
         [InlineData("en-US", "4.2 pA", ElectricCurrentUnit.Picoampere, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricCurrentUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricCurrentUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricCurrent.Parse(quantityString);
@@ -307,7 +364,7 @@ public void Parse(string culture, string quantityString, ElectricCurrentUnit exp
         [InlineData("en-US", "4.2 mA", ElectricCurrentUnit.Milliampere, 4.2)]
         [InlineData("en-US", "4.2 nA", ElectricCurrentUnit.Nanoampere, 4.2)]
         [InlineData("en-US", "4.2 pA", ElectricCurrentUnit.Picoampere, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricCurrentUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricCurrentUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricCurrent.TryParse(quantityString, out ElectricCurrent parsed));
@@ -512,6 +569,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricCurrentU
                 var quantity = ElectricCurrent.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -535,40 +593,42 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricCurrentUnit
                 IQuantity<ElectricCurrentUnit> quantityToConvert = quantity;
                 IQuantity<ElectricCurrentUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricCurrent ampere = ElectricCurrent.FromAmperes(1);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromAmperes(ampere.Amperes).Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromCentiamperes(ampere.Centiamperes).Amperes, CentiamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromFemtoamperes(ampere.Femtoamperes).Amperes, FemtoamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromKiloamperes(ampere.Kiloamperes).Amperes, KiloamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromMegaamperes(ampere.Megaamperes).Amperes, MegaamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromMicroamperes(ampere.Microamperes).Amperes, MicroamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromMilliamperes(ampere.Milliamperes).Amperes, MilliamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromNanoamperes(ampere.Nanoamperes).Amperes, NanoamperesTolerance);
-            AssertEx.EqualTolerance(1, ElectricCurrent.FromPicoamperes(ampere.Picoamperes).Amperes, PicoamperesTolerance);
+            ElectricCurrent ampere = ElectricCurrent.FromAmperes(3);
+            Assert.Equal(3, ElectricCurrent.FromAmperes(ampere.Amperes).Amperes);
+            Assert.Equal(3, ElectricCurrent.FromCentiamperes(ampere.Centiamperes).Amperes);
+            Assert.Equal(3, ElectricCurrent.FromFemtoamperes(ampere.Femtoamperes).Amperes);
+            Assert.Equal(3, ElectricCurrent.FromKiloamperes(ampere.Kiloamperes).Amperes);
+            Assert.Equal(3, ElectricCurrent.FromMegaamperes(ampere.Megaamperes).Amperes);
+            Assert.Equal(3, ElectricCurrent.FromMicroamperes(ampere.Microamperes).Amperes);
+            Assert.Equal(3, ElectricCurrent.FromMilliamperes(ampere.Milliamperes).Amperes);
+            Assert.Equal(3, ElectricCurrent.FromNanoamperes(ampere.Nanoamperes).Amperes);
+            Assert.Equal(3, ElectricCurrent.FromPicoamperes(ampere.Picoamperes).Amperes);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricCurrent v = ElectricCurrent.FromAmperes(1);
-            AssertEx.EqualTolerance(-1, -v.Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrent.FromAmperes(3)-v).Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(2, (ElectricCurrent.FromAmperes(10)/5).Amperes, AmperesTolerance);
-            AssertEx.EqualTolerance(2, ElectricCurrent.FromAmperes(10)/ElectricCurrent.FromAmperes(5), AmperesTolerance);
+            Assert.Equal(-1, -v.Amperes);
+            Assert.Equal(2, (ElectricCurrent.FromAmperes(3) - v).Amperes);
+            Assert.Equal(2, (v + v).Amperes);
+            Assert.Equal(10, (v * 10).Amperes);
+            Assert.Equal(10, (10 * v).Amperes);
+            Assert.Equal(2, (ElectricCurrent.FromAmperes(10) / 5).Amperes);
+            Assert.Equal(2, ElectricCurrent.FromAmperes(10) / ElectricCurrent.FromAmperes(5));
         }
 
         [Fact]
@@ -614,8 +674,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricCurrentUnit.Ampere, 1, ElectricCurrentUnit.Ampere, true)]  // Same value and unit.
         [InlineData(1, ElectricCurrentUnit.Ampere, 2, ElectricCurrentUnit.Ampere, false)] // Different value.
-        [InlineData(2, ElectricCurrentUnit.Ampere, 1, ElectricCurrentUnit.Centiampere, false)] // Different value and unit.
-        [InlineData(1, ElectricCurrentUnit.Ampere, 1, ElectricCurrentUnit.Centiampere, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricCurrentUnit unitA, double valueB, ElectricCurrentUnit unitB, bool expectEqual)
         {
             var a = new ElectricCurrent(valueA, unitA);
@@ -675,8 +733,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricCurrent.FromAmperes(firstValue);
             var otherQuantity = ElectricCurrent.FromAmperes(secondValue);
             ElectricCurrent maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricCurrent.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -695,7 +753,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricCurrentUnit>();
+            var units = EnumHelper.GetValues<ElectricCurrentUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -708,6 +766,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricCurrent.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricCurrent.Info.Units, ElectricCurrent.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricCurrent.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -740,26 +810,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 pA", new ElectricCurrent(1, ElectricCurrentUnit.Picoampere).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 A", new ElectricCurrent(0.123456, ElectricCurrentUnit.Ampere).ToString("s1"));
-            Assert.Equal("0.12 A", new ElectricCurrent(0.123456, ElectricCurrentUnit.Ampere).ToString("s2"));
-            Assert.Equal("0.123 A", new ElectricCurrent(0.123456, ElectricCurrentUnit.Ampere).ToString("s3"));
-            Assert.Equal("0.1235 A", new ElectricCurrent(0.123456, ElectricCurrentUnit.Ampere).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 A", new ElectricCurrent(0.123456, ElectricCurrentUnit.Ampere).ToString("s1", culture));
-            Assert.Equal("0.12 A", new ElectricCurrent(0.123456, ElectricCurrentUnit.Ampere).ToString("s2", culture));
-            Assert.Equal("0.123 A", new ElectricCurrent(0.123456, ElectricCurrentUnit.Ampere).ToString("s3", culture));
-            Assert.Equal("0.1235 A", new ElectricCurrent(0.123456, ElectricCurrentUnit.Ampere).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -786,7 +836,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricCurrent.FromAmperes(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricCurrent), quantity.As(ElectricCurrent.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricFieldTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricFieldTestsBase.g.cs
index bb071eb658..acb61aac54 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricFieldTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricFieldTestsBase.g.cs
@@ -125,6 +125,20 @@ public void ElectricField_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<ElectricFieldUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricFieldInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricFieldUnit[] expectedUnits = [ElectricFieldUnit.VoltPerMeter];
+
+            ElectricField.ElectricFieldInfo quantityInfo = ElectricField.ElectricFieldInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricField", quantityInfo.Name);
+            Assert.Equal(ElectricField.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricField.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void VoltPerMeterToElectricFieldUnits()
         {
@@ -209,31 +223,74 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricField.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricField convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricField quantityToConvert = quantity;
+
+                ElectricField convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricFieldUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricFieldUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricField(value: 1, unit: ElectricField.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricField(value: 1, unit: ElectricField.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricFieldUnit> quantity = new ElectricField(value: 1, unit: ElectricField.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricField(value: 1, unit: ElectricField.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricField(value: 1, unit: ElectricField.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricField(value: 1, unit: ElectricField.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricFieldUnit> quantity = new ElectricField(value: 1, unit: ElectricField.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricField(value: 1, unit: ElectricField.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 V/m", ElectricFieldUnit.VoltPerMeter, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricFieldUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricFieldUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricField.Parse(quantityString);
@@ -243,7 +300,7 @@ public void Parse(string culture, string quantityString, ElectricFieldUnit expec
 
         [Theory]
         [InlineData("en-US", "4.2 V/m", ElectricFieldUnit.VoltPerMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricFieldUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricFieldUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricField.TryParse(quantityString, out ElectricField parsed));
@@ -376,6 +433,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricFieldUni
                 var quantity = ElectricField.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -399,32 +457,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricFieldUnit u
                 IQuantity<ElectricFieldUnit> quantityToConvert = quantity;
                 IQuantity<ElectricFieldUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricField voltpermeter = ElectricField.FromVoltsPerMeter(1);
-            AssertEx.EqualTolerance(1, ElectricField.FromVoltsPerMeter(voltpermeter.VoltsPerMeter).VoltsPerMeter, VoltsPerMeterTolerance);
+            ElectricField voltpermeter = ElectricField.FromVoltsPerMeter(3);
+            Assert.Equal(3, ElectricField.FromVoltsPerMeter(voltpermeter.VoltsPerMeter).VoltsPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricField v = ElectricField.FromVoltsPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.VoltsPerMeter, VoltsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricField.FromVoltsPerMeter(3)-v).VoltsPerMeter, VoltsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).VoltsPerMeter, VoltsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).VoltsPerMeter, VoltsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).VoltsPerMeter, VoltsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricField.FromVoltsPerMeter(10)/5).VoltsPerMeter, VoltsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, ElectricField.FromVoltsPerMeter(10)/ElectricField.FromVoltsPerMeter(5), VoltsPerMeterTolerance);
+            Assert.Equal(-1, -v.VoltsPerMeter);
+            Assert.Equal(2, (ElectricField.FromVoltsPerMeter(3) - v).VoltsPerMeter);
+            Assert.Equal(2, (v + v).VoltsPerMeter);
+            Assert.Equal(10, (v * 10).VoltsPerMeter);
+            Assert.Equal(10, (10 * v).VoltsPerMeter);
+            Assert.Equal(2, (ElectricField.FromVoltsPerMeter(10) / 5).VoltsPerMeter);
+            Assert.Equal(2, ElectricField.FromVoltsPerMeter(10) / ElectricField.FromVoltsPerMeter(5));
         }
 
         [Fact]
@@ -470,7 +530,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricFieldUnit.VoltPerMeter, 1, ElectricFieldUnit.VoltPerMeter, true)]  // Same value and unit.
         [InlineData(1, ElectricFieldUnit.VoltPerMeter, 2, ElectricFieldUnit.VoltPerMeter, false)] // Different value.
-        [InlineData(2, ElectricFieldUnit.VoltPerMeter, 1, ElectricFieldUnit.VoltPerMeter, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricFieldUnit unitA, double valueB, ElectricFieldUnit unitB, bool expectEqual)
         {
             var a = new ElectricField(valueA, unitA);
@@ -530,8 +589,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricField.FromVoltsPerMeter(firstValue);
             var otherQuantity = ElectricField.FromVoltsPerMeter(secondValue);
             ElectricField maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricField.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -550,7 +609,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricFieldUnit>();
+            var units = EnumHelper.GetValues<ElectricFieldUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -564,39 +623,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 V/m", new ElectricField(1, ElectricFieldUnit.VoltPerMeter).ToString());
+            Assert.Equal(ElectricField.Info.Units, ElectricField.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 V/m", new ElectricField(1, ElectricFieldUnit.VoltPerMeter).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, ElectricField.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 V/m", new ElectricField(0.123456, ElectricFieldUnit.VoltPerMeter).ToString("s1"));
-            Assert.Equal("0.12 V/m", new ElectricField(0.123456, ElectricFieldUnit.VoltPerMeter).ToString("s2"));
-            Assert.Equal("0.123 V/m", new ElectricField(0.123456, ElectricFieldUnit.VoltPerMeter).ToString("s3"));
-            Assert.Equal("0.1235 V/m", new ElectricField(0.123456, ElectricFieldUnit.VoltPerMeter).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 V/m", new ElectricField(1, ElectricFieldUnit.VoltPerMeter).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 V/m", new ElectricField(0.123456, ElectricFieldUnit.VoltPerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 V/m", new ElectricField(0.123456, ElectricFieldUnit.VoltPerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 V/m", new ElectricField(0.123456, ElectricFieldUnit.VoltPerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 V/m", new ElectricField(0.123456, ElectricFieldUnit.VoltPerMeter).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 V/m", new ElectricField(1, ElectricFieldUnit.VoltPerMeter).ToString(swedishCulture));
         }
 
         [Theory]
@@ -625,7 +676,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricField.FromVoltsPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricField), quantity.As(ElectricField.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricImpedanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricImpedanceTestsBase.g.cs
index 79e1bbe725..25a3860cd2 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricImpedanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricImpedanceTestsBase.g.cs
@@ -153,6 +153,20 @@ public void ElectricImpedance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
             Assert.Equal(quantityInfo, ((IQuantity<ElectricImpedanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricImpedanceInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricImpedanceUnit[] expectedUnits = [ElectricImpedanceUnit.Ohm];
+
+            ElectricImpedance.ElectricImpedanceInfo quantityInfo = ElectricImpedance.ElectricImpedanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricImpedance", quantityInfo.Name);
+            Assert.Equal(ElectricImpedance.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricImpedance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void OhmToElectricImpedanceUnits()
         {
@@ -251,26 +265,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricImpedance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricImpedance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricImpedance quantityToConvert = quantity;
+
+                ElectricImpedance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricImpedanceUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricImpedanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricImpedance(value: 1, unit: ElectricImpedance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricImpedance(value: 1, unit: ElectricImpedance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricImpedanceUnit> quantity = new ElectricImpedance(value: 1, unit: ElectricImpedance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricImpedance(value: 1, unit: ElectricImpedance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricImpedance(value: 1, unit: ElectricImpedance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricImpedance(value: 1, unit: ElectricImpedance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricImpedanceUnit> quantity = new ElectricImpedance(value: 1, unit: ElectricImpedance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricImpedance(value: 1, unit: ElectricImpedance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -282,7 +339,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 nΩ", ElectricImpedanceUnit.Nanoohm, 4.2)]
         [InlineData("en-US", "4.2 Ω", ElectricImpedanceUnit.Ohm, 4.2)]
         [InlineData("en-US", "4.2 TΩ", ElectricImpedanceUnit.Teraohm, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricImpedanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricImpedanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricImpedance.Parse(quantityString);
@@ -299,7 +356,7 @@ public void Parse(string culture, string quantityString, ElectricImpedanceUnit e
         [InlineData("en-US", "4.2 nΩ", ElectricImpedanceUnit.Nanoohm, 4.2)]
         [InlineData("en-US", "4.2 Ω", ElectricImpedanceUnit.Ohm, 4.2)]
         [InlineData("en-US", "4.2 TΩ", ElectricImpedanceUnit.Teraohm, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricImpedanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricImpedanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricImpedance.TryParse(quantityString, out ElectricImpedance parsed));
@@ -495,6 +552,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricImpedanc
                 var quantity = ElectricImpedance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -518,39 +576,41 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricImpedanceUn
                 IQuantity<ElectricImpedanceUnit> quantityToConvert = quantity;
                 IQuantity<ElectricImpedanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricImpedance ohm = ElectricImpedance.FromOhms(1);
-            AssertEx.EqualTolerance(1, ElectricImpedance.FromGigaohms(ohm.Gigaohms).Ohms, GigaohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricImpedance.FromKiloohms(ohm.Kiloohms).Ohms, KiloohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricImpedance.FromMegaohms(ohm.Megaohms).Ohms, MegaohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricImpedance.FromMicroohms(ohm.Microohms).Ohms, MicroohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricImpedance.FromMilliohms(ohm.Milliohms).Ohms, MilliohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricImpedance.FromNanoohms(ohm.Nanoohms).Ohms, NanoohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricImpedance.FromOhms(ohm.Ohms).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricImpedance.FromTeraohms(ohm.Teraohms).Ohms, TeraohmsTolerance);
+            ElectricImpedance ohm = ElectricImpedance.FromOhms(3);
+            Assert.Equal(3, ElectricImpedance.FromGigaohms(ohm.Gigaohms).Ohms);
+            Assert.Equal(3, ElectricImpedance.FromKiloohms(ohm.Kiloohms).Ohms);
+            Assert.Equal(3, ElectricImpedance.FromMegaohms(ohm.Megaohms).Ohms);
+            Assert.Equal(3, ElectricImpedance.FromMicroohms(ohm.Microohms).Ohms);
+            Assert.Equal(3, ElectricImpedance.FromMilliohms(ohm.Milliohms).Ohms);
+            Assert.Equal(3, ElectricImpedance.FromNanoohms(ohm.Nanoohms).Ohms);
+            Assert.Equal(3, ElectricImpedance.FromOhms(ohm.Ohms).Ohms);
+            Assert.Equal(3, ElectricImpedance.FromTeraohms(ohm.Teraohms).Ohms);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricImpedance v = ElectricImpedance.FromOhms(1);
-            AssertEx.EqualTolerance(-1, -v.Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricImpedance.FromOhms(3)-v).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricImpedance.FromOhms(10)/5).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, ElectricImpedance.FromOhms(10)/ElectricImpedance.FromOhms(5), OhmsTolerance);
+            Assert.Equal(-1, -v.Ohms);
+            Assert.Equal(2, (ElectricImpedance.FromOhms(3) - v).Ohms);
+            Assert.Equal(2, (v + v).Ohms);
+            Assert.Equal(10, (v * 10).Ohms);
+            Assert.Equal(10, (10 * v).Ohms);
+            Assert.Equal(2, (ElectricImpedance.FromOhms(10) / 5).Ohms);
+            Assert.Equal(2, ElectricImpedance.FromOhms(10) / ElectricImpedance.FromOhms(5));
         }
 
         [Fact]
@@ -596,8 +656,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricImpedanceUnit.Ohm, 1, ElectricImpedanceUnit.Ohm, true)]  // Same value and unit.
         [InlineData(1, ElectricImpedanceUnit.Ohm, 2, ElectricImpedanceUnit.Ohm, false)] // Different value.
-        [InlineData(2, ElectricImpedanceUnit.Ohm, 1, ElectricImpedanceUnit.Gigaohm, false)] // Different value and unit.
-        [InlineData(1, ElectricImpedanceUnit.Ohm, 1, ElectricImpedanceUnit.Gigaohm, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricImpedanceUnit unitA, double valueB, ElectricImpedanceUnit unitB, bool expectEqual)
         {
             var a = new ElectricImpedance(valueA, unitA);
@@ -657,8 +715,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricImpedance.FromOhms(firstValue);
             var otherQuantity = ElectricImpedance.FromOhms(secondValue);
             ElectricImpedance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricImpedance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -677,7 +735,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricImpedanceUnit>();
+            var units = EnumHelper.GetValues<ElectricImpedanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -690,6 +748,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricImpedance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricImpedance.Info.Units, ElectricImpedance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricImpedance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -720,26 +790,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 TΩ", new ElectricImpedance(1, ElectricImpedanceUnit.Teraohm).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Ω", new ElectricImpedance(0.123456, ElectricImpedanceUnit.Ohm).ToString("s1"));
-            Assert.Equal("0.12 Ω", new ElectricImpedance(0.123456, ElectricImpedanceUnit.Ohm).ToString("s2"));
-            Assert.Equal("0.123 Ω", new ElectricImpedance(0.123456, ElectricImpedanceUnit.Ohm).ToString("s3"));
-            Assert.Equal("0.1235 Ω", new ElectricImpedance(0.123456, ElectricImpedanceUnit.Ohm).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Ω", new ElectricImpedance(0.123456, ElectricImpedanceUnit.Ohm).ToString("s1", culture));
-            Assert.Equal("0.12 Ω", new ElectricImpedance(0.123456, ElectricImpedanceUnit.Ohm).ToString("s2", culture));
-            Assert.Equal("0.123 Ω", new ElectricImpedance(0.123456, ElectricImpedanceUnit.Ohm).ToString("s3", culture));
-            Assert.Equal("0.1235 Ω", new ElectricImpedance(0.123456, ElectricImpedanceUnit.Ohm).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -766,7 +816,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricImpedance.FromOhms(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricImpedance), quantity.As(ElectricImpedance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricInductanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricInductanceTestsBase.g.cs
index e26f61f5d1..64c21436de 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricInductanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricInductanceTestsBase.g.cs
@@ -141,6 +141,20 @@ public void ElectricInductance_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
             Assert.Equal(quantityInfo, ((IQuantity<ElectricInductanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricInductanceInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricInductanceUnit[] expectedUnits = [ElectricInductanceUnit.Henry];
+
+            ElectricInductance.ElectricInductanceInfo quantityInfo = ElectricInductance.ElectricInductanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricInductance", quantityInfo.Name);
+            Assert.Equal(ElectricInductance.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricInductance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void HenryToElectricInductanceUnits()
         {
@@ -233,26 +247,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricInductance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricInductance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricInductance quantityToConvert = quantity;
+
+                ElectricInductance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricInductanceUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricInductanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricInductance(value: 1, unit: ElectricInductance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricInductance(value: 1, unit: ElectricInductance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricInductanceUnit> quantity = new ElectricInductance(value: 1, unit: ElectricInductance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricInductance(value: 1, unit: ElectricInductance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricInductance(value: 1, unit: ElectricInductance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricInductance(value: 1, unit: ElectricInductance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricInductanceUnit> quantity = new ElectricInductance(value: 1, unit: ElectricInductance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricInductance(value: 1, unit: ElectricInductance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -261,7 +318,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mH", ElectricInductanceUnit.Millihenry, 4.2)]
         [InlineData("en-US", "4.2 nH", ElectricInductanceUnit.Nanohenry, 4.2)]
         [InlineData("en-US", "4.2 pH", ElectricInductanceUnit.Picohenry, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricInductanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricInductanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricInductance.Parse(quantityString);
@@ -275,7 +332,7 @@ public void Parse(string culture, string quantityString, ElectricInductanceUnit
         [InlineData("en-US", "4.2 mH", ElectricInductanceUnit.Millihenry, 4.2)]
         [InlineData("en-US", "4.2 nH", ElectricInductanceUnit.Nanohenry, 4.2)]
         [InlineData("en-US", "4.2 pH", ElectricInductanceUnit.Picohenry, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricInductanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricInductanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricInductance.TryParse(quantityString, out ElectricInductance parsed));
@@ -444,6 +501,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricInductan
                 var quantity = ElectricInductance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -467,36 +525,38 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricInductanceU
                 IQuantity<ElectricInductanceUnit> quantityToConvert = quantity;
                 IQuantity<ElectricInductanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricInductance henry = ElectricInductance.FromHenries(1);
-            AssertEx.EqualTolerance(1, ElectricInductance.FromHenries(henry.Henries).Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(1, ElectricInductance.FromMicrohenries(henry.Microhenries).Henries, MicrohenriesTolerance);
-            AssertEx.EqualTolerance(1, ElectricInductance.FromMillihenries(henry.Millihenries).Henries, MillihenriesTolerance);
-            AssertEx.EqualTolerance(1, ElectricInductance.FromNanohenries(henry.Nanohenries).Henries, NanohenriesTolerance);
-            AssertEx.EqualTolerance(1, ElectricInductance.FromPicohenries(henry.Picohenries).Henries, PicohenriesTolerance);
+            ElectricInductance henry = ElectricInductance.FromHenries(3);
+            Assert.Equal(3, ElectricInductance.FromHenries(henry.Henries).Henries);
+            Assert.Equal(3, ElectricInductance.FromMicrohenries(henry.Microhenries).Henries);
+            Assert.Equal(3, ElectricInductance.FromMillihenries(henry.Millihenries).Henries);
+            Assert.Equal(3, ElectricInductance.FromNanohenries(henry.Nanohenries).Henries);
+            Assert.Equal(3, ElectricInductance.FromPicohenries(henry.Picohenries).Henries);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricInductance v = ElectricInductance.FromHenries(1);
-            AssertEx.EqualTolerance(-1, -v.Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(2, (ElectricInductance.FromHenries(3)-v).Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(2, (ElectricInductance.FromHenries(10)/5).Henries, HenriesTolerance);
-            AssertEx.EqualTolerance(2, ElectricInductance.FromHenries(10)/ElectricInductance.FromHenries(5), HenriesTolerance);
+            Assert.Equal(-1, -v.Henries);
+            Assert.Equal(2, (ElectricInductance.FromHenries(3) - v).Henries);
+            Assert.Equal(2, (v + v).Henries);
+            Assert.Equal(10, (v * 10).Henries);
+            Assert.Equal(10, (10 * v).Henries);
+            Assert.Equal(2, (ElectricInductance.FromHenries(10) / 5).Henries);
+            Assert.Equal(2, ElectricInductance.FromHenries(10) / ElectricInductance.FromHenries(5));
         }
 
         [Fact]
@@ -542,8 +602,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricInductanceUnit.Henry, 1, ElectricInductanceUnit.Henry, true)]  // Same value and unit.
         [InlineData(1, ElectricInductanceUnit.Henry, 2, ElectricInductanceUnit.Henry, false)] // Different value.
-        [InlineData(2, ElectricInductanceUnit.Henry, 1, ElectricInductanceUnit.Microhenry, false)] // Different value and unit.
-        [InlineData(1, ElectricInductanceUnit.Henry, 1, ElectricInductanceUnit.Microhenry, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricInductanceUnit unitA, double valueB, ElectricInductanceUnit unitB, bool expectEqual)
         {
             var a = new ElectricInductance(valueA, unitA);
@@ -603,8 +661,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricInductance.FromHenries(firstValue);
             var otherQuantity = ElectricInductance.FromHenries(secondValue);
             ElectricInductance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricInductance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -623,7 +681,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricInductanceUnit>();
+            var units = EnumHelper.GetValues<ElectricInductanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -636,6 +694,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricInductance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricInductance.Info.Units, ElectricInductance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricInductance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -660,26 +730,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 pH", new ElectricInductance(1, ElectricInductanceUnit.Picohenry).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 H", new ElectricInductance(0.123456, ElectricInductanceUnit.Henry).ToString("s1"));
-            Assert.Equal("0.12 H", new ElectricInductance(0.123456, ElectricInductanceUnit.Henry).ToString("s2"));
-            Assert.Equal("0.123 H", new ElectricInductance(0.123456, ElectricInductanceUnit.Henry).ToString("s3"));
-            Assert.Equal("0.1235 H", new ElectricInductance(0.123456, ElectricInductanceUnit.Henry).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 H", new ElectricInductance(0.123456, ElectricInductanceUnit.Henry).ToString("s1", culture));
-            Assert.Equal("0.12 H", new ElectricInductance(0.123456, ElectricInductanceUnit.Henry).ToString("s2", culture));
-            Assert.Equal("0.123 H", new ElectricInductance(0.123456, ElectricInductanceUnit.Henry).ToString("s3", culture));
-            Assert.Equal("0.1235 H", new ElectricInductance(0.123456, ElectricInductanceUnit.Henry).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -706,7 +756,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricInductance.FromHenries(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricInductance), quantity.As(ElectricInductance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs
index 9f2d788ca4..73029ac1aa 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs
@@ -201,6 +201,20 @@ public void ElectricPotentialChangeRate_QuantityInfo_ReturnsQuantityInfoDescribi
             Assert.Equal(quantityInfo, ((IQuantity<ElectricPotentialChangeRateUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricPotentialChangeRateInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricPotentialChangeRateUnit[] expectedUnits = [ElectricPotentialChangeRateUnit.VoltPerSecond];
+
+            ElectricPotentialChangeRate.ElectricPotentialChangeRateInfo quantityInfo = ElectricPotentialChangeRate.ElectricPotentialChangeRateInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricPotentialChangeRate", quantityInfo.Name);
+            Assert.Equal(ElectricPotentialChangeRate.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricPotentialChangeRate.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void VoltPerSecondToElectricPotentialChangeRateUnits()
         {
@@ -323,26 +337,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricPotentialChangeRate.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricPotentialChangeRate convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricPotentialChangeRate quantityToConvert = quantity;
+
+                ElectricPotentialChangeRate convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricPotentialChangeRateUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricPotentialChangeRateUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricPotentialChangeRate(value: 1, unit: ElectricPotentialChangeRate.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricPotentialChangeRate(value: 1, unit: ElectricPotentialChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricPotentialChangeRateUnit> quantity = new ElectricPotentialChangeRate(value: 1, unit: ElectricPotentialChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricPotentialChangeRate(value: 1, unit: ElectricPotentialChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricPotentialChangeRate(value: 1, unit: ElectricPotentialChangeRate.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricPotentialChangeRate(value: 1, unit: ElectricPotentialChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricPotentialChangeRateUnit> quantity = new ElectricPotentialChangeRate(value: 1, unit: ElectricPotentialChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricPotentialChangeRate(value: 1, unit: ElectricPotentialChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -366,7 +423,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 V/μs", ElectricPotentialChangeRateUnit.VoltPerMicrosecond, 4.2)]
         [InlineData("en-US", "4.2 V/min", ElectricPotentialChangeRateUnit.VoltPerMinute, 4.2)]
         [InlineData("en-US", "4.2 V/s", ElectricPotentialChangeRateUnit.VoltPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricPotentialChangeRateUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricPotentialChangeRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricPotentialChangeRate.Parse(quantityString);
@@ -395,7 +452,7 @@ public void Parse(string culture, string quantityString, ElectricPotentialChange
         [InlineData("en-US", "4.2 V/μs", ElectricPotentialChangeRateUnit.VoltPerMicrosecond, 4.2)]
         [InlineData("en-US", "4.2 V/min", ElectricPotentialChangeRateUnit.VoltPerMinute, 4.2)]
         [InlineData("en-US", "4.2 V/s", ElectricPotentialChangeRateUnit.VoltPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricPotentialChangeRateUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricPotentialChangeRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricPotentialChangeRate.TryParse(quantityString, out ElectricPotentialChangeRate parsed));
@@ -699,6 +756,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricPotentia
                 var quantity = ElectricPotentialChangeRate.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -722,51 +780,53 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricPotentialCh
                 IQuantity<ElectricPotentialChangeRateUnit> quantityToConvert = quantity;
                 IQuantity<ElectricPotentialChangeRateUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSecond(1);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerHour(voltpersecond.KilovoltsPerHour).VoltsPerSecond, KilovoltsPerHourTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(voltpersecond.KilovoltsPerMicrosecond).VoltsPerSecond, KilovoltsPerMicrosecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerMinute(voltpersecond.KilovoltsPerMinute).VoltsPerSecond, KilovoltsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerSecond(voltpersecond.KilovoltsPerSecond).VoltsPerSecond, KilovoltsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerHour(voltpersecond.MegavoltsPerHour).VoltsPerSecond, MegavoltsPerHourTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(voltpersecond.MegavoltsPerMicrosecond).VoltsPerSecond, MegavoltsPerMicrosecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerMinute(voltpersecond.MegavoltsPerMinute).VoltsPerSecond, MegavoltsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerSecond(voltpersecond.MegavoltsPerSecond).VoltsPerSecond, MegavoltsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerHour(voltpersecond.MicrovoltsPerHour).VoltsPerSecond, MicrovoltsPerHourTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(voltpersecond.MicrovoltsPerMicrosecond).VoltsPerSecond, MicrovoltsPerMicrosecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerMinute(voltpersecond.MicrovoltsPerMinute).VoltsPerSecond, MicrovoltsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerSecond(voltpersecond.MicrovoltsPerSecond).VoltsPerSecond, MicrovoltsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerHour(voltpersecond.MillivoltsPerHour).VoltsPerSecond, MillivoltsPerHourTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(voltpersecond.MillivoltsPerMicrosecond).VoltsPerSecond, MillivoltsPerMicrosecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerMinute(voltpersecond.MillivoltsPerMinute).VoltsPerSecond, MillivoltsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerSecond(voltpersecond.MillivoltsPerSecond).VoltsPerSecond, MillivoltsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerHour(voltpersecond.VoltsPerHour).VoltsPerSecond, VoltsPerHourTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerMicrosecond(voltpersecond.VoltsPerMicrosecond).VoltsPerSecond, VoltsPerMicrosecondTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerMinute(voltpersecond.VoltsPerMinute).VoltsPerSecond, VoltsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerSecond(voltpersecond.VoltsPerSecond).VoltsPerSecond, VoltsPerSecondTolerance);
+            ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSecond(3);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromKilovoltsPerHour(voltpersecond.KilovoltsPerHour).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(voltpersecond.KilovoltsPerMicrosecond).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromKilovoltsPerMinute(voltpersecond.KilovoltsPerMinute).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromKilovoltsPerSecond(voltpersecond.KilovoltsPerSecond).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMegavoltsPerHour(voltpersecond.MegavoltsPerHour).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(voltpersecond.MegavoltsPerMicrosecond).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMegavoltsPerMinute(voltpersecond.MegavoltsPerMinute).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMegavoltsPerSecond(voltpersecond.MegavoltsPerSecond).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMicrovoltsPerHour(voltpersecond.MicrovoltsPerHour).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(voltpersecond.MicrovoltsPerMicrosecond).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMicrovoltsPerMinute(voltpersecond.MicrovoltsPerMinute).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMicrovoltsPerSecond(voltpersecond.MicrovoltsPerSecond).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMillivoltsPerHour(voltpersecond.MillivoltsPerHour).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(voltpersecond.MillivoltsPerMicrosecond).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMillivoltsPerMinute(voltpersecond.MillivoltsPerMinute).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromMillivoltsPerSecond(voltpersecond.MillivoltsPerSecond).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromVoltsPerHour(voltpersecond.VoltsPerHour).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromVoltsPerMicrosecond(voltpersecond.VoltsPerMicrosecond).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromVoltsPerMinute(voltpersecond.VoltsPerMinute).VoltsPerSecond);
+            Assert.Equal(3, ElectricPotentialChangeRate.FromVoltsPerSecond(voltpersecond.VoltsPerSecond).VoltsPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricPotentialChangeRate v = ElectricPotentialChangeRate.FromVoltsPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.VoltsPerSecond, VoltsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotentialChangeRate.FromVoltsPerSecond(3)-v).VoltsPerSecond, VoltsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).VoltsPerSecond, VoltsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).VoltsPerSecond, VoltsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).VoltsPerSecond, VoltsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotentialChangeRate.FromVoltsPerSecond(10)/5).VoltsPerSecond, VoltsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, ElectricPotentialChangeRate.FromVoltsPerSecond(10)/ElectricPotentialChangeRate.FromVoltsPerSecond(5), VoltsPerSecondTolerance);
+            Assert.Equal(-1, -v.VoltsPerSecond);
+            Assert.Equal(2, (ElectricPotentialChangeRate.FromVoltsPerSecond(3) - v).VoltsPerSecond);
+            Assert.Equal(2, (v + v).VoltsPerSecond);
+            Assert.Equal(10, (v * 10).VoltsPerSecond);
+            Assert.Equal(10, (10 * v).VoltsPerSecond);
+            Assert.Equal(2, (ElectricPotentialChangeRate.FromVoltsPerSecond(10) / 5).VoltsPerSecond);
+            Assert.Equal(2, ElectricPotentialChangeRate.FromVoltsPerSecond(10) / ElectricPotentialChangeRate.FromVoltsPerSecond(5));
         }
 
         [Fact]
@@ -812,8 +872,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricPotentialChangeRateUnit.VoltPerSecond, 1, ElectricPotentialChangeRateUnit.VoltPerSecond, true)]  // Same value and unit.
         [InlineData(1, ElectricPotentialChangeRateUnit.VoltPerSecond, 2, ElectricPotentialChangeRateUnit.VoltPerSecond, false)] // Different value.
-        [InlineData(2, ElectricPotentialChangeRateUnit.VoltPerSecond, 1, ElectricPotentialChangeRateUnit.KilovoltPerHour, false)] // Different value and unit.
-        [InlineData(1, ElectricPotentialChangeRateUnit.VoltPerSecond, 1, ElectricPotentialChangeRateUnit.KilovoltPerHour, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricPotentialChangeRateUnit unitA, double valueB, ElectricPotentialChangeRateUnit unitB, bool expectEqual)
         {
             var a = new ElectricPotentialChangeRate(valueA, unitA);
@@ -873,8 +931,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(firstValue);
             var otherQuantity = ElectricPotentialChangeRate.FromVoltsPerSecond(secondValue);
             ElectricPotentialChangeRate maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricPotentialChangeRate.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -893,7 +951,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricPotentialChangeRateUnit>();
+            var units = EnumHelper.GetValues<ElectricPotentialChangeRateUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -906,6 +964,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricPotentialChangeRate.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricPotentialChangeRate.Info.Units, ElectricPotentialChangeRate.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricPotentialChangeRate.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -960,26 +1030,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 V/s", new ElectricPotentialChangeRate(1, ElectricPotentialChangeRateUnit.VoltPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 V/s", new ElectricPotentialChangeRate(0.123456, ElectricPotentialChangeRateUnit.VoltPerSecond).ToString("s1"));
-            Assert.Equal("0.12 V/s", new ElectricPotentialChangeRate(0.123456, ElectricPotentialChangeRateUnit.VoltPerSecond).ToString("s2"));
-            Assert.Equal("0.123 V/s", new ElectricPotentialChangeRate(0.123456, ElectricPotentialChangeRateUnit.VoltPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 V/s", new ElectricPotentialChangeRate(0.123456, ElectricPotentialChangeRateUnit.VoltPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 V/s", new ElectricPotentialChangeRate(0.123456, ElectricPotentialChangeRateUnit.VoltPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 V/s", new ElectricPotentialChangeRate(0.123456, ElectricPotentialChangeRateUnit.VoltPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 V/s", new ElectricPotentialChangeRate(0.123456, ElectricPotentialChangeRateUnit.VoltPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 V/s", new ElectricPotentialChangeRate(0.123456, ElectricPotentialChangeRateUnit.VoltPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1006,7 +1056,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricPotentialChangeRate), quantity.As(ElectricPotentialChangeRate.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs
index 6af93caf9c..8c4f0aee4c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialTestsBase.g.cs
@@ -145,6 +145,20 @@ public void ElectricPotential_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
             Assert.Equal(quantityInfo, ((IQuantity<ElectricPotentialUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricPotentialInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricPotentialUnit[] expectedUnits = [ElectricPotentialUnit.Volt];
+
+            ElectricPotential.ElectricPotentialInfo quantityInfo = ElectricPotential.ElectricPotentialInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricPotential", quantityInfo.Name);
+            Assert.Equal(ElectricPotential.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricPotential.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void VoltToElectricPotentialUnits()
         {
@@ -239,26 +253,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricPotential.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricPotential convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricPotential quantityToConvert = quantity;
+
+                ElectricPotential convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricPotentialUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricPotentialUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricPotential(value: 1, unit: ElectricPotential.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricPotential(value: 1, unit: ElectricPotential.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricPotentialUnit> quantity = new ElectricPotential(value: 1, unit: ElectricPotential.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricPotential(value: 1, unit: ElectricPotential.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricPotential(value: 1, unit: ElectricPotential.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricPotential(value: 1, unit: ElectricPotential.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricPotentialUnit> quantity = new ElectricPotential(value: 1, unit: ElectricPotential.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricPotential(value: 1, unit: ElectricPotential.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -274,7 +331,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 мВ", ElectricPotentialUnit.Millivolt, 4.2)]
         [InlineData("ru-RU", "4,2 нВ", ElectricPotentialUnit.Nanovolt, 4.2)]
         [InlineData("ru-RU", "4,2 В", ElectricPotentialUnit.Volt, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricPotentialUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricPotentialUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricPotential.Parse(quantityString);
@@ -295,7 +352,7 @@ public void Parse(string culture, string quantityString, ElectricPotentialUnit e
         [InlineData("ru-RU", "4,2 мВ", ElectricPotentialUnit.Millivolt, 4.2)]
         [InlineData("ru-RU", "4,2 нВ", ElectricPotentialUnit.Nanovolt, 4.2)]
         [InlineData("ru-RU", "4,2 В", ElectricPotentialUnit.Volt, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricPotentialUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricPotentialUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricPotential.TryParse(quantityString, out ElectricPotential parsed));
@@ -503,6 +560,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricPotentia
                 var quantity = ElectricPotential.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -526,37 +584,39 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricPotentialUn
                 IQuantity<ElectricPotentialUnit> quantityToConvert = quantity;
                 IQuantity<ElectricPotentialUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricPotential volt = ElectricPotential.FromVolts(1);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromKilovolts(volt.Kilovolts).Volts, KilovoltsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromMegavolts(volt.Megavolts).Volts, MegavoltsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromMicrovolts(volt.Microvolts).Volts, MicrovoltsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromMillivolts(volt.Millivolts).Volts, MillivoltsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromNanovolts(volt.Nanovolts).Volts, NanovoltsTolerance);
-            AssertEx.EqualTolerance(1, ElectricPotential.FromVolts(volt.Volts).Volts, VoltsTolerance);
+            ElectricPotential volt = ElectricPotential.FromVolts(3);
+            Assert.Equal(3, ElectricPotential.FromKilovolts(volt.Kilovolts).Volts);
+            Assert.Equal(3, ElectricPotential.FromMegavolts(volt.Megavolts).Volts);
+            Assert.Equal(3, ElectricPotential.FromMicrovolts(volt.Microvolts).Volts);
+            Assert.Equal(3, ElectricPotential.FromMillivolts(volt.Millivolts).Volts);
+            Assert.Equal(3, ElectricPotential.FromNanovolts(volt.Nanovolts).Volts);
+            Assert.Equal(3, ElectricPotential.FromVolts(volt.Volts).Volts);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricPotential v = ElectricPotential.FromVolts(1);
-            AssertEx.EqualTolerance(-1, -v.Volts, VoltsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotential.FromVolts(3)-v).Volts, VoltsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Volts, VoltsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Volts, VoltsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Volts, VoltsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricPotential.FromVolts(10)/5).Volts, VoltsTolerance);
-            AssertEx.EqualTolerance(2, ElectricPotential.FromVolts(10)/ElectricPotential.FromVolts(5), VoltsTolerance);
+            Assert.Equal(-1, -v.Volts);
+            Assert.Equal(2, (ElectricPotential.FromVolts(3) - v).Volts);
+            Assert.Equal(2, (v + v).Volts);
+            Assert.Equal(10, (v * 10).Volts);
+            Assert.Equal(10, (10 * v).Volts);
+            Assert.Equal(2, (ElectricPotential.FromVolts(10) / 5).Volts);
+            Assert.Equal(2, ElectricPotential.FromVolts(10) / ElectricPotential.FromVolts(5));
         }
 
         [Fact]
@@ -602,8 +662,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricPotentialUnit.Volt, 1, ElectricPotentialUnit.Volt, true)]  // Same value and unit.
         [InlineData(1, ElectricPotentialUnit.Volt, 2, ElectricPotentialUnit.Volt, false)] // Different value.
-        [InlineData(2, ElectricPotentialUnit.Volt, 1, ElectricPotentialUnit.Kilovolt, false)] // Different value and unit.
-        [InlineData(1, ElectricPotentialUnit.Volt, 1, ElectricPotentialUnit.Kilovolt, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricPotentialUnit unitA, double valueB, ElectricPotentialUnit unitB, bool expectEqual)
         {
             var a = new ElectricPotential(valueA, unitA);
@@ -663,8 +721,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricPotential.FromVolts(firstValue);
             var otherQuantity = ElectricPotential.FromVolts(secondValue);
             ElectricPotential maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricPotential.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -683,7 +741,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricPotentialUnit>();
+            var units = EnumHelper.GetValues<ElectricPotentialUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -696,6 +754,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricPotential.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricPotential.Info.Units, ElectricPotential.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricPotential.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -722,26 +792,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 V", new ElectricPotential(1, ElectricPotentialUnit.Volt).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 V", new ElectricPotential(0.123456, ElectricPotentialUnit.Volt).ToString("s1"));
-            Assert.Equal("0.12 V", new ElectricPotential(0.123456, ElectricPotentialUnit.Volt).ToString("s2"));
-            Assert.Equal("0.123 V", new ElectricPotential(0.123456, ElectricPotentialUnit.Volt).ToString("s3"));
-            Assert.Equal("0.1235 V", new ElectricPotential(0.123456, ElectricPotentialUnit.Volt).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 V", new ElectricPotential(0.123456, ElectricPotentialUnit.Volt).ToString("s1", culture));
-            Assert.Equal("0.12 V", new ElectricPotential(0.123456, ElectricPotentialUnit.Volt).ToString("s2", culture));
-            Assert.Equal("0.123 V", new ElectricPotential(0.123456, ElectricPotentialUnit.Volt).ToString("s3", culture));
-            Assert.Equal("0.1235 V", new ElectricPotential(0.123456, ElectricPotentialUnit.Volt).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -768,7 +818,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricPotential.FromVolts(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricPotential), quantity.As(ElectricPotential.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactanceTestsBase.g.cs
index 251faa950c..de64a6a6cb 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactanceTestsBase.g.cs
@@ -153,6 +153,20 @@ public void ElectricReactance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
             Assert.Equal(quantityInfo, ((IQuantity<ElectricReactanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricReactanceInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricReactanceUnit[] expectedUnits = [ElectricReactanceUnit.Ohm];
+
+            ElectricReactance.ElectricReactanceInfo quantityInfo = ElectricReactance.ElectricReactanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricReactance", quantityInfo.Name);
+            Assert.Equal(ElectricReactance.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricReactance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void OhmToElectricReactanceUnits()
         {
@@ -251,26 +265,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricReactance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricReactance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricReactance quantityToConvert = quantity;
+
+                ElectricReactance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricReactanceUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricReactanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricReactance(value: 1, unit: ElectricReactance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricReactance(value: 1, unit: ElectricReactance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricReactanceUnit> quantity = new ElectricReactance(value: 1, unit: ElectricReactance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricReactance(value: 1, unit: ElectricReactance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricReactance(value: 1, unit: ElectricReactance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricReactance(value: 1, unit: ElectricReactance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricReactanceUnit> quantity = new ElectricReactance(value: 1, unit: ElectricReactance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricReactance(value: 1, unit: ElectricReactance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -282,7 +339,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 nΩ", ElectricReactanceUnit.Nanoohm, 4.2)]
         [InlineData("en-US", "4.2 Ω", ElectricReactanceUnit.Ohm, 4.2)]
         [InlineData("en-US", "4.2 TΩ", ElectricReactanceUnit.Teraohm, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricReactanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricReactanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricReactance.Parse(quantityString);
@@ -299,7 +356,7 @@ public void Parse(string culture, string quantityString, ElectricReactanceUnit e
         [InlineData("en-US", "4.2 nΩ", ElectricReactanceUnit.Nanoohm, 4.2)]
         [InlineData("en-US", "4.2 Ω", ElectricReactanceUnit.Ohm, 4.2)]
         [InlineData("en-US", "4.2 TΩ", ElectricReactanceUnit.Teraohm, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricReactanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricReactanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricReactance.TryParse(quantityString, out ElectricReactance parsed));
@@ -495,6 +552,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricReactanc
                 var quantity = ElectricReactance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -518,39 +576,41 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricReactanceUn
                 IQuantity<ElectricReactanceUnit> quantityToConvert = quantity;
                 IQuantity<ElectricReactanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricReactance ohm = ElectricReactance.FromOhms(1);
-            AssertEx.EqualTolerance(1, ElectricReactance.FromGigaohms(ohm.Gigaohms).Ohms, GigaohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactance.FromKiloohms(ohm.Kiloohms).Ohms, KiloohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactance.FromMegaohms(ohm.Megaohms).Ohms, MegaohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactance.FromMicroohms(ohm.Microohms).Ohms, MicroohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactance.FromMilliohms(ohm.Milliohms).Ohms, MilliohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactance.FromNanoohms(ohm.Nanoohms).Ohms, NanoohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactance.FromOhms(ohm.Ohms).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactance.FromTeraohms(ohm.Teraohms).Ohms, TeraohmsTolerance);
+            ElectricReactance ohm = ElectricReactance.FromOhms(3);
+            Assert.Equal(3, ElectricReactance.FromGigaohms(ohm.Gigaohms).Ohms);
+            Assert.Equal(3, ElectricReactance.FromKiloohms(ohm.Kiloohms).Ohms);
+            Assert.Equal(3, ElectricReactance.FromMegaohms(ohm.Megaohms).Ohms);
+            Assert.Equal(3, ElectricReactance.FromMicroohms(ohm.Microohms).Ohms);
+            Assert.Equal(3, ElectricReactance.FromMilliohms(ohm.Milliohms).Ohms);
+            Assert.Equal(3, ElectricReactance.FromNanoohms(ohm.Nanoohms).Ohms);
+            Assert.Equal(3, ElectricReactance.FromOhms(ohm.Ohms).Ohms);
+            Assert.Equal(3, ElectricReactance.FromTeraohms(ohm.Teraohms).Ohms);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricReactance v = ElectricReactance.FromOhms(1);
-            AssertEx.EqualTolerance(-1, -v.Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricReactance.FromOhms(3)-v).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricReactance.FromOhms(10)/5).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, ElectricReactance.FromOhms(10)/ElectricReactance.FromOhms(5), OhmsTolerance);
+            Assert.Equal(-1, -v.Ohms);
+            Assert.Equal(2, (ElectricReactance.FromOhms(3) - v).Ohms);
+            Assert.Equal(2, (v + v).Ohms);
+            Assert.Equal(10, (v * 10).Ohms);
+            Assert.Equal(10, (10 * v).Ohms);
+            Assert.Equal(2, (ElectricReactance.FromOhms(10) / 5).Ohms);
+            Assert.Equal(2, ElectricReactance.FromOhms(10) / ElectricReactance.FromOhms(5));
         }
 
         [Fact]
@@ -596,8 +656,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricReactanceUnit.Ohm, 1, ElectricReactanceUnit.Ohm, true)]  // Same value and unit.
         [InlineData(1, ElectricReactanceUnit.Ohm, 2, ElectricReactanceUnit.Ohm, false)] // Different value.
-        [InlineData(2, ElectricReactanceUnit.Ohm, 1, ElectricReactanceUnit.Gigaohm, false)] // Different value and unit.
-        [InlineData(1, ElectricReactanceUnit.Ohm, 1, ElectricReactanceUnit.Gigaohm, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricReactanceUnit unitA, double valueB, ElectricReactanceUnit unitB, bool expectEqual)
         {
             var a = new ElectricReactance(valueA, unitA);
@@ -657,8 +715,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricReactance.FromOhms(firstValue);
             var otherQuantity = ElectricReactance.FromOhms(secondValue);
             ElectricReactance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricReactance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -677,7 +735,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricReactanceUnit>();
+            var units = EnumHelper.GetValues<ElectricReactanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -690,6 +748,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricReactance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricReactance.Info.Units, ElectricReactance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricReactance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -720,26 +790,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 TΩ", new ElectricReactance(1, ElectricReactanceUnit.Teraohm).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Ω", new ElectricReactance(0.123456, ElectricReactanceUnit.Ohm).ToString("s1"));
-            Assert.Equal("0.12 Ω", new ElectricReactance(0.123456, ElectricReactanceUnit.Ohm).ToString("s2"));
-            Assert.Equal("0.123 Ω", new ElectricReactance(0.123456, ElectricReactanceUnit.Ohm).ToString("s3"));
-            Assert.Equal("0.1235 Ω", new ElectricReactance(0.123456, ElectricReactanceUnit.Ohm).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Ω", new ElectricReactance(0.123456, ElectricReactanceUnit.Ohm).ToString("s1", culture));
-            Assert.Equal("0.12 Ω", new ElectricReactance(0.123456, ElectricReactanceUnit.Ohm).ToString("s2", culture));
-            Assert.Equal("0.123 Ω", new ElectricReactance(0.123456, ElectricReactanceUnit.Ohm).ToString("s3", culture));
-            Assert.Equal("0.1235 Ω", new ElectricReactance(0.123456, ElectricReactanceUnit.Ohm).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -766,7 +816,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricReactance.FromOhms(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricReactance), quantity.As(ElectricReactance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactiveEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactiveEnergyTestsBase.g.cs
index 8a024ca4a4..cda7a8f1b9 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactiveEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactiveEnergyTestsBase.g.cs
@@ -133,6 +133,20 @@ public void ElectricReactiveEnergy_QuantityInfo_ReturnsQuantityInfoDescribingQua
             Assert.Equal(quantityInfo, ((IQuantity<ElectricReactiveEnergyUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricReactiveEnergyInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricReactiveEnergyUnit[] expectedUnits = [ElectricReactiveEnergyUnit.VoltampereReactiveHour];
+
+            ElectricReactiveEnergy.ElectricReactiveEnergyInfo quantityInfo = ElectricReactiveEnergy.ElectricReactiveEnergyInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricReactiveEnergy", quantityInfo.Name);
+            Assert.Equal(ElectricReactiveEnergy.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricReactiveEnergy.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void VoltampereReactiveHourToElectricReactiveEnergyUnits()
         {
@@ -221,33 +235,76 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricReactiveEnergy.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricReactiveEnergy convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricReactiveEnergy quantityToConvert = quantity;
+
+                ElectricReactiveEnergy convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricReactiveEnergyUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricReactiveEnergyUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricReactiveEnergy(value: 1, unit: ElectricReactiveEnergy.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricReactiveEnergy(value: 1, unit: ElectricReactiveEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricReactiveEnergyUnit> quantity = new ElectricReactiveEnergy(value: 1, unit: ElectricReactiveEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricReactiveEnergy(value: 1, unit: ElectricReactiveEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricReactiveEnergy(value: 1, unit: ElectricReactiveEnergy.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricReactiveEnergy(value: 1, unit: ElectricReactiveEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricReactiveEnergyUnit> quantity = new ElectricReactiveEnergy(value: 1, unit: ElectricReactiveEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricReactiveEnergy(value: 1, unit: ElectricReactiveEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 kvarh", ElectricReactiveEnergyUnit.KilovoltampereReactiveHour, 4.2)]
         [InlineData("en-US", "4.2 Mvarh", ElectricReactiveEnergyUnit.MegavoltampereReactiveHour, 4.2)]
         [InlineData("en-US", "4.2 varh", ElectricReactiveEnergyUnit.VoltampereReactiveHour, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricReactiveEnergyUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricReactiveEnergyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricReactiveEnergy.Parse(quantityString);
@@ -259,7 +316,7 @@ public void Parse(string culture, string quantityString, ElectricReactiveEnergyU
         [InlineData("en-US", "4.2 kvarh", ElectricReactiveEnergyUnit.KilovoltampereReactiveHour, 4.2)]
         [InlineData("en-US", "4.2 Mvarh", ElectricReactiveEnergyUnit.MegavoltampereReactiveHour, 4.2)]
         [InlineData("en-US", "4.2 varh", ElectricReactiveEnergyUnit.VoltampereReactiveHour, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricReactiveEnergyUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricReactiveEnergyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricReactiveEnergy.TryParse(quantityString, out ElectricReactiveEnergy parsed));
@@ -410,6 +467,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricReactive
                 var quantity = ElectricReactiveEnergy.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -433,34 +491,36 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricReactiveEne
                 IQuantity<ElectricReactiveEnergyUnit> quantityToConvert = quantity;
                 IQuantity<ElectricReactiveEnergyUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricReactiveEnergy voltamperereactivehour = ElectricReactiveEnergy.FromVoltampereReactiveHours(1);
-            AssertEx.EqualTolerance(1, ElectricReactiveEnergy.FromKilovoltampereReactiveHours(voltamperereactivehour.KilovoltampereReactiveHours).VoltampereReactiveHours, KilovoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactiveEnergy.FromMegavoltampereReactiveHours(voltamperereactivehour.MegavoltampereReactiveHours).VoltampereReactiveHours, MegavoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactiveEnergy.FromVoltampereReactiveHours(voltamperereactivehour.VoltampereReactiveHours).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
+            ElectricReactiveEnergy voltamperereactivehour = ElectricReactiveEnergy.FromVoltampereReactiveHours(3);
+            Assert.Equal(3, ElectricReactiveEnergy.FromKilovoltampereReactiveHours(voltamperereactivehour.KilovoltampereReactiveHours).VoltampereReactiveHours);
+            Assert.Equal(3, ElectricReactiveEnergy.FromMegavoltampereReactiveHours(voltamperereactivehour.MegavoltampereReactiveHours).VoltampereReactiveHours);
+            Assert.Equal(3, ElectricReactiveEnergy.FromVoltampereReactiveHours(voltamperereactivehour.VoltampereReactiveHours).VoltampereReactiveHours);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricReactiveEnergy v = ElectricReactiveEnergy.FromVoltampereReactiveHours(1);
-            AssertEx.EqualTolerance(-1, -v.VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(2, (ElectricReactiveEnergy.FromVoltampereReactiveHours(3)-v).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(2, (v + v).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(10, (v*10).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(10, (10*v).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(2, (ElectricReactiveEnergy.FromVoltampereReactiveHours(10)/5).VoltampereReactiveHours, VoltampereReactiveHoursTolerance);
-            AssertEx.EqualTolerance(2, ElectricReactiveEnergy.FromVoltampereReactiveHours(10)/ElectricReactiveEnergy.FromVoltampereReactiveHours(5), VoltampereReactiveHoursTolerance);
+            Assert.Equal(-1, -v.VoltampereReactiveHours);
+            Assert.Equal(2, (ElectricReactiveEnergy.FromVoltampereReactiveHours(3) - v).VoltampereReactiveHours);
+            Assert.Equal(2, (v + v).VoltampereReactiveHours);
+            Assert.Equal(10, (v * 10).VoltampereReactiveHours);
+            Assert.Equal(10, (10 * v).VoltampereReactiveHours);
+            Assert.Equal(2, (ElectricReactiveEnergy.FromVoltampereReactiveHours(10) / 5).VoltampereReactiveHours);
+            Assert.Equal(2, ElectricReactiveEnergy.FromVoltampereReactiveHours(10) / ElectricReactiveEnergy.FromVoltampereReactiveHours(5));
         }
 
         [Fact]
@@ -506,8 +566,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricReactiveEnergyUnit.VoltampereReactiveHour, 1, ElectricReactiveEnergyUnit.VoltampereReactiveHour, true)]  // Same value and unit.
         [InlineData(1, ElectricReactiveEnergyUnit.VoltampereReactiveHour, 2, ElectricReactiveEnergyUnit.VoltampereReactiveHour, false)] // Different value.
-        [InlineData(2, ElectricReactiveEnergyUnit.VoltampereReactiveHour, 1, ElectricReactiveEnergyUnit.KilovoltampereReactiveHour, false)] // Different value and unit.
-        [InlineData(1, ElectricReactiveEnergyUnit.VoltampereReactiveHour, 1, ElectricReactiveEnergyUnit.KilovoltampereReactiveHour, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricReactiveEnergyUnit unitA, double valueB, ElectricReactiveEnergyUnit unitB, bool expectEqual)
         {
             var a = new ElectricReactiveEnergy(valueA, unitA);
@@ -567,8 +625,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricReactiveEnergy.FromVoltampereReactiveHours(firstValue);
             var otherQuantity = ElectricReactiveEnergy.FromVoltampereReactiveHours(secondValue);
             ElectricReactiveEnergy maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricReactiveEnergy.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -587,7 +645,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricReactiveEnergyUnit>();
+            var units = EnumHelper.GetValues<ElectricReactiveEnergyUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -600,6 +658,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricReactiveEnergy.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricReactiveEnergy.Info.Units, ElectricReactiveEnergy.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricReactiveEnergy.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -620,26 +690,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 varh", new ElectricReactiveEnergy(1, ElectricReactiveEnergyUnit.VoltampereReactiveHour).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 varh", new ElectricReactiveEnergy(0.123456, ElectricReactiveEnergyUnit.VoltampereReactiveHour).ToString("s1"));
-            Assert.Equal("0.12 varh", new ElectricReactiveEnergy(0.123456, ElectricReactiveEnergyUnit.VoltampereReactiveHour).ToString("s2"));
-            Assert.Equal("0.123 varh", new ElectricReactiveEnergy(0.123456, ElectricReactiveEnergyUnit.VoltampereReactiveHour).ToString("s3"));
-            Assert.Equal("0.1235 varh", new ElectricReactiveEnergy(0.123456, ElectricReactiveEnergyUnit.VoltampereReactiveHour).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 varh", new ElectricReactiveEnergy(0.123456, ElectricReactiveEnergyUnit.VoltampereReactiveHour).ToString("s1", culture));
-            Assert.Equal("0.12 varh", new ElectricReactiveEnergy(0.123456, ElectricReactiveEnergyUnit.VoltampereReactiveHour).ToString("s2", culture));
-            Assert.Equal("0.123 varh", new ElectricReactiveEnergy(0.123456, ElectricReactiveEnergyUnit.VoltampereReactiveHour).ToString("s3", culture));
-            Assert.Equal("0.1235 varh", new ElectricReactiveEnergy(0.123456, ElectricReactiveEnergyUnit.VoltampereReactiveHour).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -666,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricReactiveEnergy.FromVoltampereReactiveHours(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricReactiveEnergy), quantity.As(ElectricReactiveEnergy.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactivePowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactivePowerTestsBase.g.cs
index e828a9817c..a03c61cc56 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactivePowerTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricReactivePowerTestsBase.g.cs
@@ -137,6 +137,20 @@ public void ElectricReactivePower_QuantityInfo_ReturnsQuantityInfoDescribingQuan
             Assert.Equal(quantityInfo, ((IQuantity<ElectricReactivePowerUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricReactivePowerInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricReactivePowerUnit[] expectedUnits = [ElectricReactivePowerUnit.VoltampereReactive];
+
+            ElectricReactivePower.ElectricReactivePowerInfo quantityInfo = ElectricReactivePower.ElectricReactivePowerInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricReactivePower", quantityInfo.Name);
+            Assert.Equal(ElectricReactivePower.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricReactivePower.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void VoltampereReactiveToElectricReactivePowerUnits()
         {
@@ -227,26 +241,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricReactivePower.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricReactivePower convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricReactivePower quantityToConvert = quantity;
+
+                ElectricReactivePower convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricReactivePowerUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricReactivePowerUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricReactivePower(value: 1, unit: ElectricReactivePower.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricReactivePower(value: 1, unit: ElectricReactivePower.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricReactivePowerUnit> quantity = new ElectricReactivePower(value: 1, unit: ElectricReactivePower.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricReactivePower(value: 1, unit: ElectricReactivePower.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricReactivePower(value: 1, unit: ElectricReactivePower.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricReactivePower(value: 1, unit: ElectricReactivePower.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricReactivePowerUnit> quantity = new ElectricReactivePower(value: 1, unit: ElectricReactivePower.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricReactivePower(value: 1, unit: ElectricReactivePower.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -254,7 +311,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 kvar", ElectricReactivePowerUnit.KilovoltampereReactive, 4.2)]
         [InlineData("en-US", "4.2 Mvar", ElectricReactivePowerUnit.MegavoltampereReactive, 4.2)]
         [InlineData("en-US", "4.2 var", ElectricReactivePowerUnit.VoltampereReactive, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricReactivePowerUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricReactivePowerUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricReactivePower.Parse(quantityString);
@@ -267,7 +324,7 @@ public void Parse(string culture, string quantityString, ElectricReactivePowerUn
         [InlineData("en-US", "4.2 kvar", ElectricReactivePowerUnit.KilovoltampereReactive, 4.2)]
         [InlineData("en-US", "4.2 Mvar", ElectricReactivePowerUnit.MegavoltampereReactive, 4.2)]
         [InlineData("en-US", "4.2 var", ElectricReactivePowerUnit.VoltampereReactive, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricReactivePowerUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricReactivePowerUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricReactivePower.TryParse(quantityString, out ElectricReactivePower parsed));
@@ -427,6 +484,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricReactive
                 var quantity = ElectricReactivePower.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -450,35 +508,37 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricReactivePow
                 IQuantity<ElectricReactivePowerUnit> quantityToConvert = quantity;
                 IQuantity<ElectricReactivePowerUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricReactivePower voltamperereactive = ElectricReactivePower.FromVoltamperesReactive(1);
-            AssertEx.EqualTolerance(1, ElectricReactivePower.FromGigavoltamperesReactive(voltamperereactive.GigavoltamperesReactive).VoltamperesReactive, GigavoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactivePower.FromKilovoltamperesReactive(voltamperereactive.KilovoltamperesReactive).VoltamperesReactive, KilovoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactivePower.FromMegavoltamperesReactive(voltamperereactive.MegavoltamperesReactive).VoltamperesReactive, MegavoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(1, ElectricReactivePower.FromVoltamperesReactive(voltamperereactive.VoltamperesReactive).VoltamperesReactive, VoltamperesReactiveTolerance);
+            ElectricReactivePower voltamperereactive = ElectricReactivePower.FromVoltamperesReactive(3);
+            Assert.Equal(3, ElectricReactivePower.FromGigavoltamperesReactive(voltamperereactive.GigavoltamperesReactive).VoltamperesReactive);
+            Assert.Equal(3, ElectricReactivePower.FromKilovoltamperesReactive(voltamperereactive.KilovoltamperesReactive).VoltamperesReactive);
+            Assert.Equal(3, ElectricReactivePower.FromMegavoltamperesReactive(voltamperereactive.MegavoltamperesReactive).VoltamperesReactive);
+            Assert.Equal(3, ElectricReactivePower.FromVoltamperesReactive(voltamperereactive.VoltamperesReactive).VoltamperesReactive);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricReactivePower v = ElectricReactivePower.FromVoltamperesReactive(1);
-            AssertEx.EqualTolerance(-1, -v.VoltamperesReactive, VoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(2, (ElectricReactivePower.FromVoltamperesReactive(3)-v).VoltamperesReactive, VoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(2, (v + v).VoltamperesReactive, VoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(10, (v*10).VoltamperesReactive, VoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(10, (10*v).VoltamperesReactive, VoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(2, (ElectricReactivePower.FromVoltamperesReactive(10)/5).VoltamperesReactive, VoltamperesReactiveTolerance);
-            AssertEx.EqualTolerance(2, ElectricReactivePower.FromVoltamperesReactive(10)/ElectricReactivePower.FromVoltamperesReactive(5), VoltamperesReactiveTolerance);
+            Assert.Equal(-1, -v.VoltamperesReactive);
+            Assert.Equal(2, (ElectricReactivePower.FromVoltamperesReactive(3) - v).VoltamperesReactive);
+            Assert.Equal(2, (v + v).VoltamperesReactive);
+            Assert.Equal(10, (v * 10).VoltamperesReactive);
+            Assert.Equal(10, (10 * v).VoltamperesReactive);
+            Assert.Equal(2, (ElectricReactivePower.FromVoltamperesReactive(10) / 5).VoltamperesReactive);
+            Assert.Equal(2, ElectricReactivePower.FromVoltamperesReactive(10) / ElectricReactivePower.FromVoltamperesReactive(5));
         }
 
         [Fact]
@@ -524,8 +584,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricReactivePowerUnit.VoltampereReactive, 1, ElectricReactivePowerUnit.VoltampereReactive, true)]  // Same value and unit.
         [InlineData(1, ElectricReactivePowerUnit.VoltampereReactive, 2, ElectricReactivePowerUnit.VoltampereReactive, false)] // Different value.
-        [InlineData(2, ElectricReactivePowerUnit.VoltampereReactive, 1, ElectricReactivePowerUnit.GigavoltampereReactive, false)] // Different value and unit.
-        [InlineData(1, ElectricReactivePowerUnit.VoltampereReactive, 1, ElectricReactivePowerUnit.GigavoltampereReactive, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricReactivePowerUnit unitA, double valueB, ElectricReactivePowerUnit unitB, bool expectEqual)
         {
             var a = new ElectricReactivePower(valueA, unitA);
@@ -585,8 +643,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricReactivePower.FromVoltamperesReactive(firstValue);
             var otherQuantity = ElectricReactivePower.FromVoltamperesReactive(secondValue);
             ElectricReactivePower maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricReactivePower.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -605,7 +663,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricReactivePowerUnit>();
+            var units = EnumHelper.GetValues<ElectricReactivePowerUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -618,6 +676,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricReactivePower.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricReactivePower.Info.Units, ElectricReactivePower.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricReactivePower.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -640,26 +710,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 var", new ElectricReactivePower(1, ElectricReactivePowerUnit.VoltampereReactive).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 var", new ElectricReactivePower(0.123456, ElectricReactivePowerUnit.VoltampereReactive).ToString("s1"));
-            Assert.Equal("0.12 var", new ElectricReactivePower(0.123456, ElectricReactivePowerUnit.VoltampereReactive).ToString("s2"));
-            Assert.Equal("0.123 var", new ElectricReactivePower(0.123456, ElectricReactivePowerUnit.VoltampereReactive).ToString("s3"));
-            Assert.Equal("0.1235 var", new ElectricReactivePower(0.123456, ElectricReactivePowerUnit.VoltampereReactive).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 var", new ElectricReactivePower(0.123456, ElectricReactivePowerUnit.VoltampereReactive).ToString("s1", culture));
-            Assert.Equal("0.12 var", new ElectricReactivePower(0.123456, ElectricReactivePowerUnit.VoltampereReactive).ToString("s2", culture));
-            Assert.Equal("0.123 var", new ElectricReactivePower(0.123456, ElectricReactivePowerUnit.VoltampereReactive).ToString("s3", culture));
-            Assert.Equal("0.1235 var", new ElectricReactivePower(0.123456, ElectricReactivePowerUnit.VoltampereReactive).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -686,7 +736,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricReactivePower.FromVoltamperesReactive(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricReactivePower), quantity.As(ElectricReactivePower.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs
index b490a6789f..5d55fdffbe 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistanceTestsBase.g.cs
@@ -153,6 +153,20 @@ public void ElectricResistance_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
             Assert.Equal(quantityInfo, ((IQuantity<ElectricResistanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricResistanceInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricResistanceUnit[] expectedUnits = [ElectricResistanceUnit.Ohm];
+
+            ElectricResistance.ElectricResistanceInfo quantityInfo = ElectricResistance.ElectricResistanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricResistance", quantityInfo.Name);
+            Assert.Equal(ElectricResistance.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricResistance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void OhmToElectricResistanceUnits()
         {
@@ -251,26 +265,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricResistance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricResistance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricResistance quantityToConvert = quantity;
+
+                ElectricResistance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricResistanceUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricResistanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricResistance(value: 1, unit: ElectricResistance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricResistance(value: 1, unit: ElectricResistance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricResistanceUnit> quantity = new ElectricResistance(value: 1, unit: ElectricResistance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricResistance(value: 1, unit: ElectricResistance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricResistance(value: 1, unit: ElectricResistance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricResistance(value: 1, unit: ElectricResistance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricResistanceUnit> quantity = new ElectricResistance(value: 1, unit: ElectricResistance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricResistance(value: 1, unit: ElectricResistance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -282,7 +339,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 nΩ", ElectricResistanceUnit.Nanoohm, 4.2)]
         [InlineData("en-US", "4.2 Ω", ElectricResistanceUnit.Ohm, 4.2)]
         [InlineData("en-US", "4.2 TΩ", ElectricResistanceUnit.Teraohm, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricResistanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricResistanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricResistance.Parse(quantityString);
@@ -299,7 +356,7 @@ public void Parse(string culture, string quantityString, ElectricResistanceUnit
         [InlineData("en-US", "4.2 nΩ", ElectricResistanceUnit.Nanoohm, 4.2)]
         [InlineData("en-US", "4.2 Ω", ElectricResistanceUnit.Ohm, 4.2)]
         [InlineData("en-US", "4.2 TΩ", ElectricResistanceUnit.Teraohm, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricResistanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricResistanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricResistance.TryParse(quantityString, out ElectricResistance parsed));
@@ -495,6 +552,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricResistan
                 var quantity = ElectricResistance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -518,39 +576,41 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricResistanceU
                 IQuantity<ElectricResistanceUnit> quantityToConvert = quantity;
                 IQuantity<ElectricResistanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricResistance ohm = ElectricResistance.FromOhms(1);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromGigaohms(ohm.Gigaohms).Ohms, GigaohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromKiloohms(ohm.Kiloohms).Ohms, KiloohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromMegaohms(ohm.Megaohms).Ohms, MegaohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromMicroohms(ohm.Microohms).Ohms, MicroohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromMilliohms(ohm.Milliohms).Ohms, MilliohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromNanoohms(ohm.Nanoohms).Ohms, NanoohmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromOhms(ohm.Ohms).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistance.FromTeraohms(ohm.Teraohms).Ohms, TeraohmsTolerance);
+            ElectricResistance ohm = ElectricResistance.FromOhms(3);
+            Assert.Equal(3, ElectricResistance.FromGigaohms(ohm.Gigaohms).Ohms);
+            Assert.Equal(3, ElectricResistance.FromKiloohms(ohm.Kiloohms).Ohms);
+            Assert.Equal(3, ElectricResistance.FromMegaohms(ohm.Megaohms).Ohms);
+            Assert.Equal(3, ElectricResistance.FromMicroohms(ohm.Microohms).Ohms);
+            Assert.Equal(3, ElectricResistance.FromMilliohms(ohm.Milliohms).Ohms);
+            Assert.Equal(3, ElectricResistance.FromNanoohms(ohm.Nanoohms).Ohms);
+            Assert.Equal(3, ElectricResistance.FromOhms(ohm.Ohms).Ohms);
+            Assert.Equal(3, ElectricResistance.FromTeraohms(ohm.Teraohms).Ohms);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricResistance v = ElectricResistance.FromOhms(1);
-            AssertEx.EqualTolerance(-1, -v.Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricResistance.FromOhms(3)-v).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, (ElectricResistance.FromOhms(10)/5).Ohms, OhmsTolerance);
-            AssertEx.EqualTolerance(2, ElectricResistance.FromOhms(10)/ElectricResistance.FromOhms(5), OhmsTolerance);
+            Assert.Equal(-1, -v.Ohms);
+            Assert.Equal(2, (ElectricResistance.FromOhms(3) - v).Ohms);
+            Assert.Equal(2, (v + v).Ohms);
+            Assert.Equal(10, (v * 10).Ohms);
+            Assert.Equal(10, (10 * v).Ohms);
+            Assert.Equal(2, (ElectricResistance.FromOhms(10) / 5).Ohms);
+            Assert.Equal(2, ElectricResistance.FromOhms(10) / ElectricResistance.FromOhms(5));
         }
 
         [Fact]
@@ -596,8 +656,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricResistanceUnit.Ohm, 1, ElectricResistanceUnit.Ohm, true)]  // Same value and unit.
         [InlineData(1, ElectricResistanceUnit.Ohm, 2, ElectricResistanceUnit.Ohm, false)] // Different value.
-        [InlineData(2, ElectricResistanceUnit.Ohm, 1, ElectricResistanceUnit.Gigaohm, false)] // Different value and unit.
-        [InlineData(1, ElectricResistanceUnit.Ohm, 1, ElectricResistanceUnit.Gigaohm, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricResistanceUnit unitA, double valueB, ElectricResistanceUnit unitB, bool expectEqual)
         {
             var a = new ElectricResistance(valueA, unitA);
@@ -657,8 +715,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricResistance.FromOhms(firstValue);
             var otherQuantity = ElectricResistance.FromOhms(secondValue);
             ElectricResistance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricResistance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -677,7 +735,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricResistanceUnit>();
+            var units = EnumHelper.GetValues<ElectricResistanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -690,6 +748,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricResistance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricResistance.Info.Units, ElectricResistance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricResistance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -720,26 +790,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 TΩ", new ElectricResistance(1, ElectricResistanceUnit.Teraohm).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Ω", new ElectricResistance(0.123456, ElectricResistanceUnit.Ohm).ToString("s1"));
-            Assert.Equal("0.12 Ω", new ElectricResistance(0.123456, ElectricResistanceUnit.Ohm).ToString("s2"));
-            Assert.Equal("0.123 Ω", new ElectricResistance(0.123456, ElectricResistanceUnit.Ohm).ToString("s3"));
-            Assert.Equal("0.1235 Ω", new ElectricResistance(0.123456, ElectricResistanceUnit.Ohm).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Ω", new ElectricResistance(0.123456, ElectricResistanceUnit.Ohm).ToString("s1", culture));
-            Assert.Equal("0.12 Ω", new ElectricResistance(0.123456, ElectricResistanceUnit.Ohm).ToString("s2", culture));
-            Assert.Equal("0.123 Ω", new ElectricResistance(0.123456, ElectricResistanceUnit.Ohm).ToString("s3", culture));
-            Assert.Equal("0.1235 Ω", new ElectricResistance(0.123456, ElectricResistanceUnit.Ohm).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -766,7 +816,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricResistance.FromOhms(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricResistance), quantity.As(ElectricResistance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs
index 345994d34b..b70788c514 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricResistivityTestsBase.g.cs
@@ -177,6 +177,20 @@ public void ElectricResistivity_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
             Assert.Equal(quantityInfo, ((IQuantity<ElectricResistivityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricResistivityInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricResistivityUnit[] expectedUnits = [ElectricResistivityUnit.OhmMeter];
+
+            ElectricResistivity.ElectricResistivityInfo quantityInfo = ElectricResistivity.ElectricResistivityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricResistivity", quantityInfo.Name);
+            Assert.Equal(ElectricResistivity.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricResistivity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void OhmMeterToElectricResistivityUnits()
         {
@@ -287,26 +301,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricResistivity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricResistivity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricResistivity quantityToConvert = quantity;
+
+                ElectricResistivity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricResistivityUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricResistivityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricResistivity(value: 1, unit: ElectricResistivity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricResistivity(value: 1, unit: ElectricResistivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricResistivityUnit> quantity = new ElectricResistivity(value: 1, unit: ElectricResistivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricResistivity(value: 1, unit: ElectricResistivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricResistivity(value: 1, unit: ElectricResistivity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricResistivity(value: 1, unit: ElectricResistivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricResistivityUnit> quantity = new ElectricResistivity(value: 1, unit: ElectricResistivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricResistivity(value: 1, unit: ElectricResistivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -324,7 +381,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 Ω·m", ElectricResistivityUnit.OhmMeter, 4.2)]
         [InlineData("en-US", "4.2 pΩ·cm", ElectricResistivityUnit.PicoohmCentimeter, 4.2)]
         [InlineData("en-US", "4.2 pΩ·m", ElectricResistivityUnit.PicoohmMeter, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricResistivityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricResistivityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricResistivity.Parse(quantityString);
@@ -347,7 +404,7 @@ public void Parse(string culture, string quantityString, ElectricResistivityUnit
         [InlineData("en-US", "4.2 Ω·m", ElectricResistivityUnit.OhmMeter, 4.2)]
         [InlineData("en-US", "4.2 pΩ·cm", ElectricResistivityUnit.PicoohmCentimeter, 4.2)]
         [InlineData("en-US", "4.2 pΩ·m", ElectricResistivityUnit.PicoohmMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricResistivityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricResistivityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricResistivity.TryParse(quantityString, out ElectricResistivity parsed));
@@ -597,6 +654,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricResistiv
                 var quantity = ElectricResistivity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -620,45 +678,47 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricResistivity
                 IQuantity<ElectricResistivityUnit> quantityToConvert = quantity;
                 IQuantity<ElectricResistivityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricResistivity ohmmeter = ElectricResistivity.FromOhmMeters(1);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromKiloohmsCentimeter(ohmmeter.KiloohmsCentimeter).OhmMeters, KiloohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromKiloohmMeters(ohmmeter.KiloohmMeters).OhmMeters, KiloohmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMegaohmsCentimeter(ohmmeter.MegaohmsCentimeter).OhmMeters, MegaohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMegaohmMeters(ohmmeter.MegaohmMeters).OhmMeters, MegaohmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMicroohmsCentimeter(ohmmeter.MicroohmsCentimeter).OhmMeters, MicroohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMicroohmMeters(ohmmeter.MicroohmMeters).OhmMeters, MicroohmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMilliohmsCentimeter(ohmmeter.MilliohmsCentimeter).OhmMeters, MilliohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromMilliohmMeters(ohmmeter.MilliohmMeters).OhmMeters, MilliohmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromNanoohmsCentimeter(ohmmeter.NanoohmsCentimeter).OhmMeters, NanoohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromNanoohmMeters(ohmmeter.NanoohmMeters).OhmMeters, NanoohmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromOhmsCentimeter(ohmmeter.OhmsCentimeter).OhmMeters, OhmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromOhmMeters(ohmmeter.OhmMeters).OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromPicoohmsCentimeter(ohmmeter.PicoohmsCentimeter).OhmMeters, PicoohmsCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricResistivity.FromPicoohmMeters(ohmmeter.PicoohmMeters).OhmMeters, PicoohmMetersTolerance);
+            ElectricResistivity ohmmeter = ElectricResistivity.FromOhmMeters(3);
+            Assert.Equal(3, ElectricResistivity.FromKiloohmsCentimeter(ohmmeter.KiloohmsCentimeter).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromKiloohmMeters(ohmmeter.KiloohmMeters).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromMegaohmsCentimeter(ohmmeter.MegaohmsCentimeter).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromMegaohmMeters(ohmmeter.MegaohmMeters).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromMicroohmsCentimeter(ohmmeter.MicroohmsCentimeter).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromMicroohmMeters(ohmmeter.MicroohmMeters).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromMilliohmsCentimeter(ohmmeter.MilliohmsCentimeter).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromMilliohmMeters(ohmmeter.MilliohmMeters).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromNanoohmsCentimeter(ohmmeter.NanoohmsCentimeter).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromNanoohmMeters(ohmmeter.NanoohmMeters).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromOhmsCentimeter(ohmmeter.OhmsCentimeter).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromOhmMeters(ohmmeter.OhmMeters).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromPicoohmsCentimeter(ohmmeter.PicoohmsCentimeter).OhmMeters);
+            Assert.Equal(3, ElectricResistivity.FromPicoohmMeters(ohmmeter.PicoohmMeters).OhmMeters);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricResistivity v = ElectricResistivity.FromOhmMeters(1);
-            AssertEx.EqualTolerance(-1, -v.OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(2, (ElectricResistivity.FromOhmMeters(3)-v).OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(2, (ElectricResistivity.FromOhmMeters(10)/5).OhmMeters, OhmMetersTolerance);
-            AssertEx.EqualTolerance(2, ElectricResistivity.FromOhmMeters(10)/ElectricResistivity.FromOhmMeters(5), OhmMetersTolerance);
+            Assert.Equal(-1, -v.OhmMeters);
+            Assert.Equal(2, (ElectricResistivity.FromOhmMeters(3) - v).OhmMeters);
+            Assert.Equal(2, (v + v).OhmMeters);
+            Assert.Equal(10, (v * 10).OhmMeters);
+            Assert.Equal(10, (10 * v).OhmMeters);
+            Assert.Equal(2, (ElectricResistivity.FromOhmMeters(10) / 5).OhmMeters);
+            Assert.Equal(2, ElectricResistivity.FromOhmMeters(10) / ElectricResistivity.FromOhmMeters(5));
         }
 
         [Fact]
@@ -704,8 +764,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricResistivityUnit.OhmMeter, 1, ElectricResistivityUnit.OhmMeter, true)]  // Same value and unit.
         [InlineData(1, ElectricResistivityUnit.OhmMeter, 2, ElectricResistivityUnit.OhmMeter, false)] // Different value.
-        [InlineData(2, ElectricResistivityUnit.OhmMeter, 1, ElectricResistivityUnit.KiloohmCentimeter, false)] // Different value and unit.
-        [InlineData(1, ElectricResistivityUnit.OhmMeter, 1, ElectricResistivityUnit.KiloohmCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricResistivityUnit unitA, double valueB, ElectricResistivityUnit unitB, bool expectEqual)
         {
             var a = new ElectricResistivity(valueA, unitA);
@@ -765,8 +823,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricResistivity.FromOhmMeters(firstValue);
             var otherQuantity = ElectricResistivity.FromOhmMeters(secondValue);
             ElectricResistivity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricResistivity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -785,7 +843,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricResistivityUnit>();
+            var units = EnumHelper.GetValues<ElectricResistivityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -798,6 +856,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricResistivity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricResistivity.Info.Units, ElectricResistivity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricResistivity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -840,26 +910,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 pΩ·m", new ElectricResistivity(1, ElectricResistivityUnit.PicoohmMeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Ω·m", new ElectricResistivity(0.123456, ElectricResistivityUnit.OhmMeter).ToString("s1"));
-            Assert.Equal("0.12 Ω·m", new ElectricResistivity(0.123456, ElectricResistivityUnit.OhmMeter).ToString("s2"));
-            Assert.Equal("0.123 Ω·m", new ElectricResistivity(0.123456, ElectricResistivityUnit.OhmMeter).ToString("s3"));
-            Assert.Equal("0.1235 Ω·m", new ElectricResistivity(0.123456, ElectricResistivityUnit.OhmMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Ω·m", new ElectricResistivity(0.123456, ElectricResistivityUnit.OhmMeter).ToString("s1", culture));
-            Assert.Equal("0.12 Ω·m", new ElectricResistivity(0.123456, ElectricResistivityUnit.OhmMeter).ToString("s2", culture));
-            Assert.Equal("0.123 Ω·m", new ElectricResistivity(0.123456, ElectricResistivityUnit.OhmMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 Ω·m", new ElectricResistivity(0.123456, ElectricResistivityUnit.OhmMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -886,7 +936,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricResistivity.FromOhmMeters(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricResistivity), quantity.As(ElectricResistivity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSurfaceChargeDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSurfaceChargeDensityTestsBase.g.cs
index 24c8046d0f..26a737e2dd 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSurfaceChargeDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSurfaceChargeDensityTestsBase.g.cs
@@ -133,6 +133,20 @@ public void ElectricSurfaceChargeDensity_QuantityInfo_ReturnsQuantityInfoDescrib
             Assert.Equal(quantityInfo, ((IQuantity<ElectricSurfaceChargeDensityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricSurfaceChargeDensityInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricSurfaceChargeDensityUnit[] expectedUnits = [ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter];
+
+            ElectricSurfaceChargeDensity.ElectricSurfaceChargeDensityInfo quantityInfo = ElectricSurfaceChargeDensity.ElectricSurfaceChargeDensityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricSurfaceChargeDensity", quantityInfo.Name);
+            Assert.Equal(ElectricSurfaceChargeDensity.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricSurfaceChargeDensity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CoulombPerSquareMeterToElectricSurfaceChargeDensityUnits()
         {
@@ -221,33 +235,76 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricSurfaceChargeDensity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricSurfaceChargeDensity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricSurfaceChargeDensity quantityToConvert = quantity;
+
+                ElectricSurfaceChargeDensity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricSurfaceChargeDensityUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricSurfaceChargeDensityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricSurfaceChargeDensity(value: 1, unit: ElectricSurfaceChargeDensity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricSurfaceChargeDensity(value: 1, unit: ElectricSurfaceChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricSurfaceChargeDensityUnit> quantity = new ElectricSurfaceChargeDensity(value: 1, unit: ElectricSurfaceChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricSurfaceChargeDensity(value: 1, unit: ElectricSurfaceChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricSurfaceChargeDensity(value: 1, unit: ElectricSurfaceChargeDensity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricSurfaceChargeDensity(value: 1, unit: ElectricSurfaceChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricSurfaceChargeDensityUnit> quantity = new ElectricSurfaceChargeDensity(value: 1, unit: ElectricSurfaceChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricSurfaceChargeDensity(value: 1, unit: ElectricSurfaceChargeDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 C/cm²", ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 C/in²", ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, 4.2)]
         [InlineData("en-US", "4.2 C/m²", ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricSurfaceChargeDensityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricSurfaceChargeDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricSurfaceChargeDensity.Parse(quantityString);
@@ -259,7 +316,7 @@ public void Parse(string culture, string quantityString, ElectricSurfaceChargeDe
         [InlineData("en-US", "4.2 C/cm²", ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 C/in²", ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, 4.2)]
         [InlineData("en-US", "4.2 C/m²", ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricSurfaceChargeDensityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricSurfaceChargeDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricSurfaceChargeDensity.TryParse(quantityString, out ElectricSurfaceChargeDensity parsed));
@@ -410,6 +467,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricSurfaceC
                 var quantity = ElectricSurfaceChargeDensity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -433,34 +491,36 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricSurfaceChar
                 IQuantity<ElectricSurfaceChargeDensityUnit> quantityToConvert = quantity;
                 IQuantity<ElectricSurfaceChargeDensityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricSurfaceChargeDensity coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(coulombpersquaremeter.CoulombsPerSquareCentimeter).CoulombsPerSquareMeter, CoulombsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(coulombpersquaremeter.CoulombsPerSquareInch).CoulombsPerSquareMeter, CoulombsPerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(coulombpersquaremeter.CoulombsPerSquareMeter).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
+            ElectricSurfaceChargeDensity coulombpersquaremeter = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(3);
+            Assert.Equal(3, ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(coulombpersquaremeter.CoulombsPerSquareCentimeter).CoulombsPerSquareMeter);
+            Assert.Equal(3, ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(coulombpersquaremeter.CoulombsPerSquareInch).CoulombsPerSquareMeter);
+            Assert.Equal(3, ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(coulombpersquaremeter.CoulombsPerSquareMeter).CoulombsPerSquareMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricSurfaceChargeDensity v = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1);
-            AssertEx.EqualTolerance(-1, -v.CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(3)-v).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(10)/5).CoulombsPerSquareMeter, CoulombsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(10)/ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(5), CoulombsPerSquareMeterTolerance);
+            Assert.Equal(-1, -v.CoulombsPerSquareMeter);
+            Assert.Equal(2, (ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(3) - v).CoulombsPerSquareMeter);
+            Assert.Equal(2, (v + v).CoulombsPerSquareMeter);
+            Assert.Equal(10, (v * 10).CoulombsPerSquareMeter);
+            Assert.Equal(10, (10 * v).CoulombsPerSquareMeter);
+            Assert.Equal(2, (ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(10) / 5).CoulombsPerSquareMeter);
+            Assert.Equal(2, ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(10) / ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(5));
         }
 
         [Fact]
@@ -506,8 +566,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, 1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, true)]  // Same value and unit.
         [InlineData(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, 2, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, false)] // Different value.
-        [InlineData(2, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, 1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, false)] // Different value and unit.
-        [InlineData(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, 1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricSurfaceChargeDensityUnit unitA, double valueB, ElectricSurfaceChargeDensityUnit unitB, bool expectEqual)
         {
             var a = new ElectricSurfaceChargeDensity(valueA, unitA);
@@ -567,8 +625,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(firstValue);
             var otherQuantity = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(secondValue);
             ElectricSurfaceChargeDensity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricSurfaceChargeDensity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -587,7 +645,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricSurfaceChargeDensityUnit>();
+            var units = EnumHelper.GetValues<ElectricSurfaceChargeDensityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -600,6 +658,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricSurfaceChargeDensity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricSurfaceChargeDensity.Info.Units, ElectricSurfaceChargeDensity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricSurfaceChargeDensity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -620,26 +690,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 C/m²", new ElectricSurfaceChargeDensity(1, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 C/m²", new ElectricSurfaceChargeDensity(0.123456, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 C/m²", new ElectricSurfaceChargeDensity(0.123456, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 C/m²", new ElectricSurfaceChargeDensity(0.123456, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 C/m²", new ElectricSurfaceChargeDensity(0.123456, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 C/m²", new ElectricSurfaceChargeDensity(0.123456, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 C/m²", new ElectricSurfaceChargeDensity(0.123456, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 C/m²", new ElectricSurfaceChargeDensity(0.123456, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 C/m²", new ElectricSurfaceChargeDensity(0.123456, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -666,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricSurfaceChargeDensity), quantity.As(ElectricSurfaceChargeDensity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSusceptanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSusceptanceTestsBase.g.cs
index d36c679ee4..a964f5605a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSusceptanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricSusceptanceTestsBase.g.cs
@@ -185,6 +185,20 @@ public void ElectricSusceptance_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
             Assert.Equal(quantityInfo, ((IQuantity<ElectricSusceptanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ElectricSusceptanceInfo_CreateWithCustomUnitInfos()
+        {
+            ElectricSusceptanceUnit[] expectedUnits = [ElectricSusceptanceUnit.Siemens];
+
+            ElectricSusceptance.ElectricSusceptanceInfo quantityInfo = ElectricSusceptance.ElectricSusceptanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ElectricSusceptance", quantityInfo.Name);
+            Assert.Equal(ElectricSusceptance.Zero, quantityInfo.Zero);
+            Assert.Equal(ElectricSusceptance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SiemensToElectricSusceptanceUnits()
         {
@@ -299,26 +313,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ElectricSusceptance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ElectricSusceptance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ElectricSusceptance quantityToConvert = quantity;
+
+                ElectricSusceptance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ElectricSusceptanceUnit> quantityToConvert = quantity;
+
+                IQuantity<ElectricSusceptanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ElectricSusceptance(value: 1, unit: ElectricSusceptance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricSusceptance(value: 1, unit: ElectricSusceptance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricSusceptanceUnit> quantity = new ElectricSusceptance(value: 1, unit: ElectricSusceptance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricSusceptance(value: 1, unit: ElectricSusceptance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ElectricSusceptance(value: 1, unit: ElectricSusceptance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ElectricSusceptance(value: 1, unit: ElectricSusceptance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ElectricSusceptanceUnit> quantity = new ElectricSusceptance(value: 1, unit: ElectricSusceptance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ElectricSusceptance(value: 1, unit: ElectricSusceptance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -338,7 +395,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 S", ElectricSusceptanceUnit.Siemens, 4.2)]
         [InlineData("en-US", "4.2 T℧", ElectricSusceptanceUnit.Teramho, 4.2)]
         [InlineData("en-US", "4.2 TS", ElectricSusceptanceUnit.Terasiemens, 4.2)]
-        public void Parse(string culture, string quantityString, ElectricSusceptanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ElectricSusceptanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ElectricSusceptance.Parse(quantityString);
@@ -363,7 +420,7 @@ public void Parse(string culture, string quantityString, ElectricSusceptanceUnit
         [InlineData("en-US", "4.2 S", ElectricSusceptanceUnit.Siemens, 4.2)]
         [InlineData("en-US", "4.2 T℧", ElectricSusceptanceUnit.Teramho, 4.2)]
         [InlineData("en-US", "4.2 TS", ElectricSusceptanceUnit.Terasiemens, 4.2)]
-        public void TryParse(string culture, string quantityString, ElectricSusceptanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ElectricSusceptanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ElectricSusceptance.TryParse(quantityString, out ElectricSusceptance parsed));
@@ -631,6 +688,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ElectricSuscepta
                 var quantity = ElectricSusceptance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -654,47 +712,49 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ElectricSusceptance
                 IQuantity<ElectricSusceptanceUnit> quantityToConvert = quantity;
                 IQuantity<ElectricSusceptanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ElectricSusceptance siemens = ElectricSusceptance.FromSiemens(1);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromGigamhos(siemens.Gigamhos).Siemens, GigamhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromGigasiemens(siemens.Gigasiemens).Siemens, GigasiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromKilomhos(siemens.Kilomhos).Siemens, KilomhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromKilosiemens(siemens.Kilosiemens).Siemens, KilosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromMegamhos(siemens.Megamhos).Siemens, MegamhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromMegasiemens(siemens.Megasiemens).Siemens, MegasiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromMhos(siemens.Mhos).Siemens, MhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromMicromhos(siemens.Micromhos).Siemens, MicromhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromMicrosiemens(siemens.Microsiemens).Siemens, MicrosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromMillimhos(siemens.Millimhos).Siemens, MillimhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromMillisiemens(siemens.Millisiemens).Siemens, MillisiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromNanomhos(siemens.Nanomhos).Siemens, NanomhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromNanosiemens(siemens.Nanosiemens).Siemens, NanosiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromSiemens(siemens.Siemens).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromTeramhos(siemens.Teramhos).Siemens, TeramhosTolerance);
-            AssertEx.EqualTolerance(1, ElectricSusceptance.FromTerasiemens(siemens.Terasiemens).Siemens, TerasiemensTolerance);
+            ElectricSusceptance siemens = ElectricSusceptance.FromSiemens(3);
+            Assert.Equal(3, ElectricSusceptance.FromGigamhos(siemens.Gigamhos).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromGigasiemens(siemens.Gigasiemens).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromKilomhos(siemens.Kilomhos).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromKilosiemens(siemens.Kilosiemens).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromMegamhos(siemens.Megamhos).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromMegasiemens(siemens.Megasiemens).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromMhos(siemens.Mhos).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromMicromhos(siemens.Micromhos).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromMicrosiemens(siemens.Microsiemens).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromMillimhos(siemens.Millimhos).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromMillisiemens(siemens.Millisiemens).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromNanomhos(siemens.Nanomhos).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromNanosiemens(siemens.Nanosiemens).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromSiemens(siemens.Siemens).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromTeramhos(siemens.Teramhos).Siemens);
+            Assert.Equal(3, ElectricSusceptance.FromTerasiemens(siemens.Terasiemens).Siemens);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ElectricSusceptance v = ElectricSusceptance.FromSiemens(1);
-            AssertEx.EqualTolerance(-1, -v.Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (ElectricSusceptance.FromSiemens(3)-v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, (ElectricSusceptance.FromSiemens(10)/5).Siemens, SiemensTolerance);
-            AssertEx.EqualTolerance(2, ElectricSusceptance.FromSiemens(10)/ElectricSusceptance.FromSiemens(5), SiemensTolerance);
+            Assert.Equal(-1, -v.Siemens);
+            Assert.Equal(2, (ElectricSusceptance.FromSiemens(3) - v).Siemens);
+            Assert.Equal(2, (v + v).Siemens);
+            Assert.Equal(10, (v * 10).Siemens);
+            Assert.Equal(10, (10 * v).Siemens);
+            Assert.Equal(2, (ElectricSusceptance.FromSiemens(10) / 5).Siemens);
+            Assert.Equal(2, ElectricSusceptance.FromSiemens(10) / ElectricSusceptance.FromSiemens(5));
         }
 
         [Fact]
@@ -740,8 +800,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ElectricSusceptanceUnit.Siemens, 1, ElectricSusceptanceUnit.Siemens, true)]  // Same value and unit.
         [InlineData(1, ElectricSusceptanceUnit.Siemens, 2, ElectricSusceptanceUnit.Siemens, false)] // Different value.
-        [InlineData(2, ElectricSusceptanceUnit.Siemens, 1, ElectricSusceptanceUnit.Gigamho, false)] // Different value and unit.
-        [InlineData(1, ElectricSusceptanceUnit.Siemens, 1, ElectricSusceptanceUnit.Gigamho, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ElectricSusceptanceUnit unitA, double valueB, ElectricSusceptanceUnit unitB, bool expectEqual)
         {
             var a = new ElectricSusceptance(valueA, unitA);
@@ -801,8 +859,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ElectricSusceptance.FromSiemens(firstValue);
             var otherQuantity = ElectricSusceptance.FromSiemens(secondValue);
             ElectricSusceptance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ElectricSusceptance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -821,7 +879,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ElectricSusceptanceUnit>();
+            var units = EnumHelper.GetValues<ElectricSusceptanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -834,6 +892,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ElectricSusceptance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ElectricSusceptance.Info.Units, ElectricSusceptance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ElectricSusceptance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -880,26 +950,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 TS", new ElectricSusceptance(1, ElectricSusceptanceUnit.Terasiemens).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 S", new ElectricSusceptance(0.123456, ElectricSusceptanceUnit.Siemens).ToString("s1"));
-            Assert.Equal("0.12 S", new ElectricSusceptance(0.123456, ElectricSusceptanceUnit.Siemens).ToString("s2"));
-            Assert.Equal("0.123 S", new ElectricSusceptance(0.123456, ElectricSusceptanceUnit.Siemens).ToString("s3"));
-            Assert.Equal("0.1235 S", new ElectricSusceptance(0.123456, ElectricSusceptanceUnit.Siemens).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 S", new ElectricSusceptance(0.123456, ElectricSusceptanceUnit.Siemens).ToString("s1", culture));
-            Assert.Equal("0.12 S", new ElectricSusceptance(0.123456, ElectricSusceptanceUnit.Siemens).ToString("s2", culture));
-            Assert.Equal("0.123 S", new ElectricSusceptance(0.123456, ElectricSusceptanceUnit.Siemens).ToString("s3", culture));
-            Assert.Equal("0.1235 S", new ElectricSusceptance(0.123456, ElectricSusceptanceUnit.Siemens).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -926,7 +976,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ElectricSusceptance.FromSiemens(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ElectricSusceptance), quantity.As(ElectricSusceptance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyDensityTestsBase.g.cs
index c1f52bd393..0373739d03 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyDensityTestsBase.g.cs
@@ -169,6 +169,20 @@ public void EnergyDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<EnergyDensityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void EnergyDensityInfo_CreateWithCustomUnitInfos()
+        {
+            EnergyDensityUnit[] expectedUnits = [EnergyDensityUnit.JoulePerCubicMeter];
+
+            EnergyDensity.EnergyDensityInfo quantityInfo = EnergyDensity.EnergyDensityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("EnergyDensity", quantityInfo.Name);
+            Assert.Equal(EnergyDensity.Zero, quantityInfo.Zero);
+            Assert.Equal(EnergyDensity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void JoulePerCubicMeterToEnergyDensityUnits()
         {
@@ -275,26 +289,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = EnergyDensity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            EnergyDensity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                EnergyDensity quantityToConvert = quantity;
+
+                EnergyDensity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<EnergyDensityUnit> quantityToConvert = quantity;
+
+                IQuantity<EnergyDensityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new EnergyDensity(value: 1, unit: EnergyDensity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new EnergyDensity(value: 1, unit: EnergyDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<EnergyDensityUnit> quantity = new EnergyDensity(value: 1, unit: EnergyDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new EnergyDensity(value: 1, unit: EnergyDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new EnergyDensity(value: 1, unit: EnergyDensity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new EnergyDensity(value: 1, unit: EnergyDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<EnergyDensityUnit> quantity = new EnergyDensity(value: 1, unit: EnergyDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new EnergyDensity(value: 1, unit: EnergyDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -310,7 +367,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 TJ/m³", EnergyDensityUnit.TerajoulePerCubicMeter, 4.2)]
         [InlineData("en-US", "4.2 TWh/m³", EnergyDensityUnit.TerawattHourPerCubicMeter, 4.2)]
         [InlineData("en-US", "4.2 Wh/m³", EnergyDensityUnit.WattHourPerCubicMeter, 4.2)]
-        public void Parse(string culture, string quantityString, EnergyDensityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, EnergyDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = EnergyDensity.Parse(quantityString);
@@ -331,7 +388,7 @@ public void Parse(string culture, string quantityString, EnergyDensityUnit expec
         [InlineData("en-US", "4.2 TJ/m³", EnergyDensityUnit.TerajoulePerCubicMeter, 4.2)]
         [InlineData("en-US", "4.2 TWh/m³", EnergyDensityUnit.TerawattHourPerCubicMeter, 4.2)]
         [InlineData("en-US", "4.2 Wh/m³", EnergyDensityUnit.WattHourPerCubicMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, EnergyDensityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, EnergyDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(EnergyDensity.TryParse(quantityString, out EnergyDensity parsed));
@@ -563,6 +620,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(EnergyDensityUni
                 var quantity = EnergyDensity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -586,43 +644,45 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(EnergyDensityUnit u
                 IQuantity<EnergyDensityUnit> quantityToConvert = quantity;
                 IQuantity<EnergyDensityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            EnergyDensity joulepercubicmeter = EnergyDensity.FromJoulesPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromGigajoulesPerCubicMeter(joulepercubicmeter.GigajoulesPerCubicMeter).JoulesPerCubicMeter, GigajoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromGigawattHoursPerCubicMeter(joulepercubicmeter.GigawattHoursPerCubicMeter).JoulesPerCubicMeter, GigawattHoursPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromJoulesPerCubicMeter(joulepercubicmeter.JoulesPerCubicMeter).JoulesPerCubicMeter, JoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromKilojoulesPerCubicMeter(joulepercubicmeter.KilojoulesPerCubicMeter).JoulesPerCubicMeter, KilojoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromKilowattHoursPerCubicMeter(joulepercubicmeter.KilowattHoursPerCubicMeter).JoulesPerCubicMeter, KilowattHoursPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromMegajoulesPerCubicMeter(joulepercubicmeter.MegajoulesPerCubicMeter).JoulesPerCubicMeter, MegajoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromMegawattHoursPerCubicMeter(joulepercubicmeter.MegawattHoursPerCubicMeter).JoulesPerCubicMeter, MegawattHoursPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromPetajoulesPerCubicMeter(joulepercubicmeter.PetajoulesPerCubicMeter).JoulesPerCubicMeter, PetajoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromPetawattHoursPerCubicMeter(joulepercubicmeter.PetawattHoursPerCubicMeter).JoulesPerCubicMeter, PetawattHoursPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromTerajoulesPerCubicMeter(joulepercubicmeter.TerajoulesPerCubicMeter).JoulesPerCubicMeter, TerajoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromTerawattHoursPerCubicMeter(joulepercubicmeter.TerawattHoursPerCubicMeter).JoulesPerCubicMeter, TerawattHoursPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, EnergyDensity.FromWattHoursPerCubicMeter(joulepercubicmeter.WattHoursPerCubicMeter).JoulesPerCubicMeter, WattHoursPerCubicMeterTolerance);
+            EnergyDensity joulepercubicmeter = EnergyDensity.FromJoulesPerCubicMeter(3);
+            Assert.Equal(3, EnergyDensity.FromGigajoulesPerCubicMeter(joulepercubicmeter.GigajoulesPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromGigawattHoursPerCubicMeter(joulepercubicmeter.GigawattHoursPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromJoulesPerCubicMeter(joulepercubicmeter.JoulesPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromKilojoulesPerCubicMeter(joulepercubicmeter.KilojoulesPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromKilowattHoursPerCubicMeter(joulepercubicmeter.KilowattHoursPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromMegajoulesPerCubicMeter(joulepercubicmeter.MegajoulesPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromMegawattHoursPerCubicMeter(joulepercubicmeter.MegawattHoursPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromPetajoulesPerCubicMeter(joulepercubicmeter.PetajoulesPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromPetawattHoursPerCubicMeter(joulepercubicmeter.PetawattHoursPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromTerajoulesPerCubicMeter(joulepercubicmeter.TerajoulesPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromTerawattHoursPerCubicMeter(joulepercubicmeter.TerawattHoursPerCubicMeter).JoulesPerCubicMeter);
+            Assert.Equal(3, EnergyDensity.FromWattHoursPerCubicMeter(joulepercubicmeter.WattHoursPerCubicMeter).JoulesPerCubicMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             EnergyDensity v = EnergyDensity.FromJoulesPerCubicMeter(1);
-            AssertEx.EqualTolerance(-1, -v.JoulesPerCubicMeter, JoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (EnergyDensity.FromJoulesPerCubicMeter(3)-v).JoulesPerCubicMeter, JoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).JoulesPerCubicMeter, JoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).JoulesPerCubicMeter, JoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).JoulesPerCubicMeter, JoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (EnergyDensity.FromJoulesPerCubicMeter(10)/5).JoulesPerCubicMeter, JoulesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, EnergyDensity.FromJoulesPerCubicMeter(10)/EnergyDensity.FromJoulesPerCubicMeter(5), JoulesPerCubicMeterTolerance);
+            Assert.Equal(-1, -v.JoulesPerCubicMeter);
+            Assert.Equal(2, (EnergyDensity.FromJoulesPerCubicMeter(3) - v).JoulesPerCubicMeter);
+            Assert.Equal(2, (v + v).JoulesPerCubicMeter);
+            Assert.Equal(10, (v * 10).JoulesPerCubicMeter);
+            Assert.Equal(10, (10 * v).JoulesPerCubicMeter);
+            Assert.Equal(2, (EnergyDensity.FromJoulesPerCubicMeter(10) / 5).JoulesPerCubicMeter);
+            Assert.Equal(2, EnergyDensity.FromJoulesPerCubicMeter(10) / EnergyDensity.FromJoulesPerCubicMeter(5));
         }
 
         [Fact]
@@ -668,8 +728,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, EnergyDensityUnit.JoulePerCubicMeter, 1, EnergyDensityUnit.JoulePerCubicMeter, true)]  // Same value and unit.
         [InlineData(1, EnergyDensityUnit.JoulePerCubicMeter, 2, EnergyDensityUnit.JoulePerCubicMeter, false)] // Different value.
-        [InlineData(2, EnergyDensityUnit.JoulePerCubicMeter, 1, EnergyDensityUnit.GigajoulePerCubicMeter, false)] // Different value and unit.
-        [InlineData(1, EnergyDensityUnit.JoulePerCubicMeter, 1, EnergyDensityUnit.GigajoulePerCubicMeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, EnergyDensityUnit unitA, double valueB, EnergyDensityUnit unitB, bool expectEqual)
         {
             var a = new EnergyDensity(valueA, unitA);
@@ -729,8 +787,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = EnergyDensity.FromJoulesPerCubicMeter(firstValue);
             var otherQuantity = EnergyDensity.FromJoulesPerCubicMeter(secondValue);
             EnergyDensity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, EnergyDensity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -749,7 +807,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<EnergyDensityUnit>();
+            var units = EnumHelper.GetValues<EnergyDensityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -762,6 +820,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(EnergyDensity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(EnergyDensity.Info.Units, EnergyDensity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, EnergyDensity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -800,26 +870,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 Wh/m³", new EnergyDensity(1, EnergyDensityUnit.WattHourPerCubicMeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 J/m³", new EnergyDensity(0.123456, EnergyDensityUnit.JoulePerCubicMeter).ToString("s1"));
-            Assert.Equal("0.12 J/m³", new EnergyDensity(0.123456, EnergyDensityUnit.JoulePerCubicMeter).ToString("s2"));
-            Assert.Equal("0.123 J/m³", new EnergyDensity(0.123456, EnergyDensityUnit.JoulePerCubicMeter).ToString("s3"));
-            Assert.Equal("0.1235 J/m³", new EnergyDensity(0.123456, EnergyDensityUnit.JoulePerCubicMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 J/m³", new EnergyDensity(0.123456, EnergyDensityUnit.JoulePerCubicMeter).ToString("s1", culture));
-            Assert.Equal("0.12 J/m³", new EnergyDensity(0.123456, EnergyDensityUnit.JoulePerCubicMeter).ToString("s2", culture));
-            Assert.Equal("0.123 J/m³", new EnergyDensity(0.123456, EnergyDensityUnit.JoulePerCubicMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 J/m³", new EnergyDensity(0.123456, EnergyDensityUnit.JoulePerCubicMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -846,7 +896,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = EnergyDensity.FromJoulesPerCubicMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(EnergyDensity), quantity.As(EnergyDensity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs
index b11ba62ff4..acf40ff3e8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/EnergyTestsBase.g.cs
@@ -281,6 +281,20 @@ public void Energy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<EnergyUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void EnergyInfo_CreateWithCustomUnitInfos()
+        {
+            EnergyUnit[] expectedUnits = [EnergyUnit.Joule];
+
+            Energy.EnergyInfo quantityInfo = Energy.EnergyInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Energy", quantityInfo.Name);
+            Assert.Equal(Energy.Zero, quantityInfo.Zero);
+            Assert.Equal(Energy.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void JouleToEnergyUnits()
         {
@@ -443,26 +457,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Energy.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Energy convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Energy quantityToConvert = quantity;
+
+                Energy convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<EnergyUnit> quantityToConvert = quantity;
+
+                IQuantity<EnergyUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Energy(value: 1, unit: Energy.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Energy(value: 1, unit: Energy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<EnergyUnit> quantity = new Energy(value: 1, unit: Energy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Energy(value: 1, unit: Energy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Energy(value: 1, unit: Energy.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Energy(value: 1, unit: Energy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<EnergyUnit> quantity = new Energy(value: 1, unit: Energy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Energy(value: 1, unit: Energy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -527,7 +584,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 Американский терм", EnergyUnit.ThermUs, 4.2)]
         [InlineData("ru-RU", "4,2 Вт/д", EnergyUnit.WattDay, 4.2)]
         [InlineData("ru-RU", "4,2 Вт/ч", EnergyUnit.WattHour, 4.2)]
-        public void Parse(string culture, string quantityString, EnergyUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, EnergyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Energy.Parse(quantityString);
@@ -597,7 +654,7 @@ public void Parse(string culture, string quantityString, EnergyUnit expectedUnit
         [InlineData("ru-RU", "4,2 Американский терм", EnergyUnit.ThermUs, 4.2)]
         [InlineData("ru-RU", "4,2 Вт/д", EnergyUnit.WattDay, 4.2)]
         [InlineData("ru-RU", "4,2 Вт/ч", EnergyUnit.WattHour, 4.2)]
-        public void TryParse(string culture, string quantityString, EnergyUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, EnergyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Energy.TryParse(quantityString, out Energy parsed));
@@ -1186,6 +1243,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(EnergyUnit unit)
                 var quantity = Energy.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1209,71 +1267,73 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(EnergyUnit unit)
                 IQuantity<EnergyUnit> quantityToConvert = quantity;
                 IQuantity<EnergyUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Energy joule = Energy.FromJoules(1);
-            AssertEx.EqualTolerance(1, Energy.FromBritishThermalUnits(joule.BritishThermalUnits).Joules, BritishThermalUnitsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromCalories(joule.Calories).Joules, CaloriesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromDecathermsEc(joule.DecathermsEc).Joules, DecathermsEcTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromDecathermsImperial(joule.DecathermsImperial).Joules, DecathermsImperialTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromDecathermsUs(joule.DecathermsUs).Joules, DecathermsUsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromElectronVolts(joule.ElectronVolts).Joules, ElectronVoltsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromErgs(joule.Ergs).Joules, ErgsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromFootPounds(joule.FootPounds).Joules, FootPoundsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromGigabritishThermalUnits(joule.GigabritishThermalUnits).Joules, GigabritishThermalUnitsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromGigaelectronVolts(joule.GigaelectronVolts).Joules, GigaelectronVoltsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromGigajoules(joule.Gigajoules).Joules, GigajoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromGigawattDays(joule.GigawattDays).Joules, GigawattDaysTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromGigawattHours(joule.GigawattHours).Joules, GigawattHoursTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromHorsepowerHours(joule.HorsepowerHours).Joules, HorsepowerHoursTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromJoules(joule.Joules).Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKilobritishThermalUnits(joule.KilobritishThermalUnits).Joules, KilobritishThermalUnitsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKilocalories(joule.Kilocalories).Joules, KilocaloriesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKiloelectronVolts(joule.KiloelectronVolts).Joules, KiloelectronVoltsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKilojoules(joule.Kilojoules).Joules, KilojoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKilowattDays(joule.KilowattDays).Joules, KilowattDaysTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromKilowattHours(joule.KilowattHours).Joules, KilowattHoursTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegabritishThermalUnits(joule.MegabritishThermalUnits).Joules, MegabritishThermalUnitsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegacalories(joule.Megacalories).Joules, MegacaloriesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegaelectronVolts(joule.MegaelectronVolts).Joules, MegaelectronVoltsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegajoules(joule.Megajoules).Joules, MegajoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegawattDays(joule.MegawattDays).Joules, MegawattDaysTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMegawattHours(joule.MegawattHours).Joules, MegawattHoursTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMicrojoules(joule.Microjoules).Joules, MicrojoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromMillijoules(joule.Millijoules).Joules, MillijoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromNanojoules(joule.Nanojoules).Joules, NanojoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromPetajoules(joule.Petajoules).Joules, PetajoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromTeraelectronVolts(joule.TeraelectronVolts).Joules, TeraelectronVoltsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromTerajoules(joule.Terajoules).Joules, TerajoulesTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromTerawattDays(joule.TerawattDays).Joules, TerawattDaysTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromTerawattHours(joule.TerawattHours).Joules, TerawattHoursTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromThermsEc(joule.ThermsEc).Joules, ThermsEcTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromThermsImperial(joule.ThermsImperial).Joules, ThermsImperialTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromThermsUs(joule.ThermsUs).Joules, ThermsUsTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromWattDays(joule.WattDays).Joules, WattDaysTolerance);
-            AssertEx.EqualTolerance(1, Energy.FromWattHours(joule.WattHours).Joules, WattHoursTolerance);
+            Energy joule = Energy.FromJoules(3);
+            Assert.Equal(3, Energy.FromBritishThermalUnits(joule.BritishThermalUnits).Joules);
+            Assert.Equal(3, Energy.FromCalories(joule.Calories).Joules);
+            Assert.Equal(3, Energy.FromDecathermsEc(joule.DecathermsEc).Joules);
+            Assert.Equal(3, Energy.FromDecathermsImperial(joule.DecathermsImperial).Joules);
+            Assert.Equal(3, Energy.FromDecathermsUs(joule.DecathermsUs).Joules);
+            Assert.Equal(3, Energy.FromElectronVolts(joule.ElectronVolts).Joules);
+            Assert.Equal(3, Energy.FromErgs(joule.Ergs).Joules);
+            Assert.Equal(3, Energy.FromFootPounds(joule.FootPounds).Joules);
+            Assert.Equal(3, Energy.FromGigabritishThermalUnits(joule.GigabritishThermalUnits).Joules);
+            Assert.Equal(3, Energy.FromGigaelectronVolts(joule.GigaelectronVolts).Joules);
+            Assert.Equal(3, Energy.FromGigajoules(joule.Gigajoules).Joules);
+            Assert.Equal(3, Energy.FromGigawattDays(joule.GigawattDays).Joules);
+            Assert.Equal(3, Energy.FromGigawattHours(joule.GigawattHours).Joules);
+            Assert.Equal(3, Energy.FromHorsepowerHours(joule.HorsepowerHours).Joules);
+            Assert.Equal(3, Energy.FromJoules(joule.Joules).Joules);
+            Assert.Equal(3, Energy.FromKilobritishThermalUnits(joule.KilobritishThermalUnits).Joules);
+            Assert.Equal(3, Energy.FromKilocalories(joule.Kilocalories).Joules);
+            Assert.Equal(3, Energy.FromKiloelectronVolts(joule.KiloelectronVolts).Joules);
+            Assert.Equal(3, Energy.FromKilojoules(joule.Kilojoules).Joules);
+            Assert.Equal(3, Energy.FromKilowattDays(joule.KilowattDays).Joules);
+            Assert.Equal(3, Energy.FromKilowattHours(joule.KilowattHours).Joules);
+            Assert.Equal(3, Energy.FromMegabritishThermalUnits(joule.MegabritishThermalUnits).Joules);
+            Assert.Equal(3, Energy.FromMegacalories(joule.Megacalories).Joules);
+            Assert.Equal(3, Energy.FromMegaelectronVolts(joule.MegaelectronVolts).Joules);
+            Assert.Equal(3, Energy.FromMegajoules(joule.Megajoules).Joules);
+            Assert.Equal(3, Energy.FromMegawattDays(joule.MegawattDays).Joules);
+            Assert.Equal(3, Energy.FromMegawattHours(joule.MegawattHours).Joules);
+            Assert.Equal(3, Energy.FromMicrojoules(joule.Microjoules).Joules);
+            Assert.Equal(3, Energy.FromMillijoules(joule.Millijoules).Joules);
+            Assert.Equal(3, Energy.FromNanojoules(joule.Nanojoules).Joules);
+            Assert.Equal(3, Energy.FromPetajoules(joule.Petajoules).Joules);
+            Assert.Equal(3, Energy.FromTeraelectronVolts(joule.TeraelectronVolts).Joules);
+            Assert.Equal(3, Energy.FromTerajoules(joule.Terajoules).Joules);
+            Assert.Equal(3, Energy.FromTerawattDays(joule.TerawattDays).Joules);
+            Assert.Equal(3, Energy.FromTerawattHours(joule.TerawattHours).Joules);
+            Assert.Equal(3, Energy.FromThermsEc(joule.ThermsEc).Joules);
+            Assert.Equal(3, Energy.FromThermsImperial(joule.ThermsImperial).Joules);
+            Assert.Equal(3, Energy.FromThermsUs(joule.ThermsUs).Joules);
+            Assert.Equal(3, Energy.FromWattDays(joule.WattDays).Joules);
+            Assert.Equal(3, Energy.FromWattHours(joule.WattHours).Joules);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Energy v = Energy.FromJoules(1);
-            AssertEx.EqualTolerance(-1, -v.Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(2, (Energy.FromJoules(3)-v).Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(2, (Energy.FromJoules(10)/5).Joules, JoulesTolerance);
-            AssertEx.EqualTolerance(2, Energy.FromJoules(10)/Energy.FromJoules(5), JoulesTolerance);
+            Assert.Equal(-1, -v.Joules);
+            Assert.Equal(2, (Energy.FromJoules(3) - v).Joules);
+            Assert.Equal(2, (v + v).Joules);
+            Assert.Equal(10, (v * 10).Joules);
+            Assert.Equal(10, (10 * v).Joules);
+            Assert.Equal(2, (Energy.FromJoules(10) / 5).Joules);
+            Assert.Equal(2, Energy.FromJoules(10) / Energy.FromJoules(5));
         }
 
         [Fact]
@@ -1319,8 +1379,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, EnergyUnit.Joule, 1, EnergyUnit.Joule, true)]  // Same value and unit.
         [InlineData(1, EnergyUnit.Joule, 2, EnergyUnit.Joule, false)] // Different value.
-        [InlineData(2, EnergyUnit.Joule, 1, EnergyUnit.BritishThermalUnit, false)] // Different value and unit.
-        [InlineData(1, EnergyUnit.Joule, 1, EnergyUnit.BritishThermalUnit, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, EnergyUnit unitA, double valueB, EnergyUnit unitB, bool expectEqual)
         {
             var a = new Energy(valueA, unitA);
@@ -1380,8 +1438,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Energy.FromJoules(firstValue);
             var otherQuantity = Energy.FromJoules(secondValue);
             Energy maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Energy.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1400,7 +1458,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<EnergyUnit>();
+            var units = EnumHelper.GetValues<EnergyUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1413,6 +1471,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Energy.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Energy.Info.Units, Energy.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Energy.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1507,26 +1577,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 Wh", new Energy(1, EnergyUnit.WattHour).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 J", new Energy(0.123456, EnergyUnit.Joule).ToString("s1"));
-            Assert.Equal("0.12 J", new Energy(0.123456, EnergyUnit.Joule).ToString("s2"));
-            Assert.Equal("0.123 J", new Energy(0.123456, EnergyUnit.Joule).ToString("s3"));
-            Assert.Equal("0.1235 J", new Energy(0.123456, EnergyUnit.Joule).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 J", new Energy(0.123456, EnergyUnit.Joule).ToString("s1", culture));
-            Assert.Equal("0.12 J", new Energy(0.123456, EnergyUnit.Joule).ToString("s2", culture));
-            Assert.Equal("0.123 J", new Energy(0.123456, EnergyUnit.Joule).ToString("s3", culture));
-            Assert.Equal("0.1235 J", new Energy(0.123456, EnergyUnit.Joule).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1553,7 +1603,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Energy.FromJoules(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Energy), quantity.As(Energy.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs
index 35ba253a34..c735616719 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/EntropyTestsBase.g.cs
@@ -149,6 +149,20 @@ public void Entropy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<EntropyUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void EntropyInfo_CreateWithCustomUnitInfos()
+        {
+            EntropyUnit[] expectedUnits = [EntropyUnit.JoulePerKelvin];
+
+            Entropy.EntropyInfo quantityInfo = Entropy.EntropyInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Entropy", quantityInfo.Name);
+            Assert.Equal(Entropy.Zero, quantityInfo.Zero);
+            Assert.Equal(Entropy.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void JoulePerKelvinToEntropyUnits()
         {
@@ -245,26 +259,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Entropy.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Entropy convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Entropy quantityToConvert = quantity;
+
+                Entropy convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<EntropyUnit> quantityToConvert = quantity;
+
+                IQuantity<EntropyUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Entropy(value: 1, unit: Entropy.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Entropy(value: 1, unit: Entropy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<EntropyUnit> quantity = new Entropy(value: 1, unit: Entropy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Entropy(value: 1, unit: Entropy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Entropy(value: 1, unit: Entropy.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Entropy(value: 1, unit: Entropy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<EntropyUnit> quantity = new Entropy(value: 1, unit: Entropy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Entropy(value: 1, unit: Entropy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -275,7 +332,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 kJ/°C", EntropyUnit.KilojoulePerDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 kJ/K", EntropyUnit.KilojoulePerKelvin, 4.2)]
         [InlineData("en-US", "4.2 MJ/K", EntropyUnit.MegajoulePerKelvin, 4.2)]
-        public void Parse(string culture, string quantityString, EntropyUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, EntropyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Entropy.Parse(quantityString);
@@ -291,7 +348,7 @@ public void Parse(string culture, string quantityString, EntropyUnit expectedUni
         [InlineData("en-US", "4.2 kJ/°C", EntropyUnit.KilojoulePerDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 kJ/K", EntropyUnit.KilojoulePerKelvin, 4.2)]
         [InlineData("en-US", "4.2 MJ/K", EntropyUnit.MegajoulePerKelvin, 4.2)]
-        public void TryParse(string culture, string quantityString, EntropyUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, EntropyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Entropy.TryParse(quantityString, out Entropy parsed));
@@ -478,6 +535,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(EntropyUnit unit
                 var quantity = Entropy.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -501,38 +559,40 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(EntropyUnit unit)
                 IQuantity<EntropyUnit> quantityToConvert = quantity;
                 IQuantity<EntropyUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Entropy jouleperkelvin = Entropy.FromJoulesPerKelvin(1);
-            AssertEx.EqualTolerance(1, Entropy.FromCaloriesPerKelvin(jouleperkelvin.CaloriesPerKelvin).JoulesPerKelvin, CaloriesPerKelvinTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromJoulesPerDegreeCelsius(jouleperkelvin.JoulesPerDegreeCelsius).JoulesPerKelvin, JoulesPerDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromJoulesPerKelvin(jouleperkelvin.JoulesPerKelvin).JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromKilocaloriesPerKelvin(jouleperkelvin.KilocaloriesPerKelvin).JoulesPerKelvin, KilocaloriesPerKelvinTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromKilojoulesPerDegreeCelsius(jouleperkelvin.KilojoulesPerDegreeCelsius).JoulesPerKelvin, KilojoulesPerDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromKilojoulesPerKelvin(jouleperkelvin.KilojoulesPerKelvin).JoulesPerKelvin, KilojoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(1, Entropy.FromMegajoulesPerKelvin(jouleperkelvin.MegajoulesPerKelvin).JoulesPerKelvin, MegajoulesPerKelvinTolerance);
+            Entropy jouleperkelvin = Entropy.FromJoulesPerKelvin(3);
+            Assert.Equal(3, Entropy.FromCaloriesPerKelvin(jouleperkelvin.CaloriesPerKelvin).JoulesPerKelvin);
+            Assert.Equal(3, Entropy.FromJoulesPerDegreeCelsius(jouleperkelvin.JoulesPerDegreeCelsius).JoulesPerKelvin);
+            Assert.Equal(3, Entropy.FromJoulesPerKelvin(jouleperkelvin.JoulesPerKelvin).JoulesPerKelvin);
+            Assert.Equal(3, Entropy.FromKilocaloriesPerKelvin(jouleperkelvin.KilocaloriesPerKelvin).JoulesPerKelvin);
+            Assert.Equal(3, Entropy.FromKilojoulesPerDegreeCelsius(jouleperkelvin.KilojoulesPerDegreeCelsius).JoulesPerKelvin);
+            Assert.Equal(3, Entropy.FromKilojoulesPerKelvin(jouleperkelvin.KilojoulesPerKelvin).JoulesPerKelvin);
+            Assert.Equal(3, Entropy.FromMegajoulesPerKelvin(jouleperkelvin.MegajoulesPerKelvin).JoulesPerKelvin);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Entropy v = Entropy.FromJoulesPerKelvin(1);
-            AssertEx.EqualTolerance(-1, -v.JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(2, (Entropy.FromJoulesPerKelvin(3)-v).JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(2, (v + v).JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(10, (v*10).JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(10, (10*v).JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(2, (Entropy.FromJoulesPerKelvin(10)/5).JoulesPerKelvin, JoulesPerKelvinTolerance);
-            AssertEx.EqualTolerance(2, Entropy.FromJoulesPerKelvin(10)/Entropy.FromJoulesPerKelvin(5), JoulesPerKelvinTolerance);
+            Assert.Equal(-1, -v.JoulesPerKelvin);
+            Assert.Equal(2, (Entropy.FromJoulesPerKelvin(3) - v).JoulesPerKelvin);
+            Assert.Equal(2, (v + v).JoulesPerKelvin);
+            Assert.Equal(10, (v * 10).JoulesPerKelvin);
+            Assert.Equal(10, (10 * v).JoulesPerKelvin);
+            Assert.Equal(2, (Entropy.FromJoulesPerKelvin(10) / 5).JoulesPerKelvin);
+            Assert.Equal(2, Entropy.FromJoulesPerKelvin(10) / Entropy.FromJoulesPerKelvin(5));
         }
 
         [Fact]
@@ -578,8 +638,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, EntropyUnit.JoulePerKelvin, 1, EntropyUnit.JoulePerKelvin, true)]  // Same value and unit.
         [InlineData(1, EntropyUnit.JoulePerKelvin, 2, EntropyUnit.JoulePerKelvin, false)] // Different value.
-        [InlineData(2, EntropyUnit.JoulePerKelvin, 1, EntropyUnit.CaloriePerKelvin, false)] // Different value and unit.
-        [InlineData(1, EntropyUnit.JoulePerKelvin, 1, EntropyUnit.CaloriePerKelvin, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, EntropyUnit unitA, double valueB, EntropyUnit unitB, bool expectEqual)
         {
             var a = new Entropy(valueA, unitA);
@@ -639,8 +697,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Entropy.FromJoulesPerKelvin(firstValue);
             var otherQuantity = Entropy.FromJoulesPerKelvin(secondValue);
             Entropy maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Entropy.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -659,7 +717,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<EntropyUnit>();
+            var units = EnumHelper.GetValues<EntropyUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -672,6 +730,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Entropy.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Entropy.Info.Units, Entropy.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Entropy.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -700,26 +770,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 MJ/K", new Entropy(1, EntropyUnit.MegajoulePerKelvin).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 J/K", new Entropy(0.123456, EntropyUnit.JoulePerKelvin).ToString("s1"));
-            Assert.Equal("0.12 J/K", new Entropy(0.123456, EntropyUnit.JoulePerKelvin).ToString("s2"));
-            Assert.Equal("0.123 J/K", new Entropy(0.123456, EntropyUnit.JoulePerKelvin).ToString("s3"));
-            Assert.Equal("0.1235 J/K", new Entropy(0.123456, EntropyUnit.JoulePerKelvin).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 J/K", new Entropy(0.123456, EntropyUnit.JoulePerKelvin).ToString("s1", culture));
-            Assert.Equal("0.12 J/K", new Entropy(0.123456, EntropyUnit.JoulePerKelvin).ToString("s2", culture));
-            Assert.Equal("0.123 J/K", new Entropy(0.123456, EntropyUnit.JoulePerKelvin).ToString("s3", culture));
-            Assert.Equal("0.1235 J/K", new Entropy(0.123456, EntropyUnit.JoulePerKelvin).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -746,7 +796,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Entropy.FromJoulesPerKelvin(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Entropy), quantity.As(Entropy.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/FluidResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/FluidResistanceTestsBase.g.cs
index faf7bc6e39..6f8f81288f 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/FluidResistanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/FluidResistanceTestsBase.g.cs
@@ -197,6 +197,20 @@ public void FluidResistance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<FluidResistanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void FluidResistanceInfo_CreateWithCustomUnitInfos()
+        {
+            FluidResistanceUnit[] expectedUnits = [FluidResistanceUnit.PascalSecondPerCubicMeter];
+
+            FluidResistance.FluidResistanceInfo quantityInfo = FluidResistance.FluidResistanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("FluidResistance", quantityInfo.Name);
+            Assert.Equal(FluidResistance.Zero, quantityInfo.Zero);
+            Assert.Equal(FluidResistance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void PascalSecondPerCubicMeterToFluidResistanceUnits()
         {
@@ -317,26 +331,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = FluidResistance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            FluidResistance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                FluidResistance quantityToConvert = quantity;
+
+                FluidResistance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<FluidResistanceUnit> quantityToConvert = quantity;
+
+                IQuantity<FluidResistanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new FluidResistance(value: 1, unit: FluidResistance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new FluidResistance(value: 1, unit: FluidResistance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<FluidResistanceUnit> quantity = new FluidResistance(value: 1, unit: FluidResistance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new FluidResistance(value: 1, unit: FluidResistance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new FluidResistance(value: 1, unit: FluidResistance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new FluidResistance(value: 1, unit: FluidResistance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<FluidResistanceUnit> quantity = new FluidResistance(value: 1, unit: FluidResistance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new FluidResistance(value: 1, unit: FluidResistance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -382,7 +439,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 Па·с/мл", FluidResistanceUnit.PascalSecondPerMilliliter, 4.2)]
         [InlineData("ru-RU", "4,2 ЕВ", FluidResistanceUnit.WoodUnit, 4.2)]
         [InlineData("ru-RU", "4,2 ЕГС", FluidResistanceUnit.WoodUnit, 4.2)]
-        public void Parse(string culture, string quantityString, FluidResistanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, FluidResistanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = FluidResistance.Parse(quantityString);
@@ -433,7 +490,7 @@ public void Parse(string culture, string quantityString, FluidResistanceUnit exp
         [InlineData("ru-RU", "4,2 Па·с/мл", FluidResistanceUnit.PascalSecondPerMilliliter, 4.2)]
         [InlineData("ru-RU", "4,2 ЕВ", FluidResistanceUnit.WoodUnit, 4.2)]
         [InlineData("ru-RU", "4,2 ЕГС", FluidResistanceUnit.WoodUnit, 4.2)]
-        public void TryParse(string culture, string quantityString, FluidResistanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, FluidResistanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(FluidResistance.TryParse(quantityString, out FluidResistance parsed));
@@ -847,6 +904,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(FluidResistanceU
                 var quantity = FluidResistance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -870,50 +928,52 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(FluidResistanceUnit
                 IQuantity<FluidResistanceUnit> quantityToConvert = quantity;
                 IQuantity<FluidResistanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            FluidResistance pascalsecondpercubicmeter = FluidResistance.FromPascalSecondsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(pascalsecondpercubicmeter.DyneSecondsPerCentimeterToTheFifth).PascalSecondsPerCubicMeter, DyneSecondsPerCentimeterToTheFifthTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromMegapascalSecondsPerCubicMeter(pascalsecondpercubicmeter.MegapascalSecondsPerCubicMeter).PascalSecondsPerCubicMeter, MegapascalSecondsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(pascalsecondpercubicmeter.MillimeterMercuryMinutesPerCubicCentimeter).PascalSecondsPerCubicMeter, MillimeterMercuryMinutesPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(pascalsecondpercubicmeter.MillimeterMercuryMinutesPerCubicMeter).PascalSecondsPerCubicMeter, MillimeterMercuryMinutesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromMillimeterMercuryMinutesPerLiter(pascalsecondpercubicmeter.MillimeterMercuryMinutesPerLiter).PascalSecondsPerCubicMeter, MillimeterMercuryMinutesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(pascalsecondpercubicmeter.MillimeterMercuryMinutesPerMilliliter).PascalSecondsPerCubicMeter, MillimeterMercuryMinutesPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(pascalsecondpercubicmeter.MillimeterMercurySecondsPerCubicCentimeter).PascalSecondsPerCubicMeter, MillimeterMercurySecondsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(pascalsecondpercubicmeter.MillimeterMercurySecondsPerCubicMeter).PascalSecondsPerCubicMeter, MillimeterMercurySecondsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromMillimeterMercurySecondsPerLiter(pascalsecondpercubicmeter.MillimeterMercurySecondsPerLiter).PascalSecondsPerCubicMeter, MillimeterMercurySecondsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromMillimeterMercurySecondsPerMilliliter(pascalsecondpercubicmeter.MillimeterMercurySecondsPerMilliliter).PascalSecondsPerCubicMeter, MillimeterMercurySecondsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromPascalMinutesPerCubicCentimeter(pascalsecondpercubicmeter.PascalMinutesPerCubicCentimeter).PascalSecondsPerCubicMeter, PascalMinutesPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromPascalMinutesPerCubicMeter(pascalsecondpercubicmeter.PascalMinutesPerCubicMeter).PascalSecondsPerCubicMeter, PascalMinutesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromPascalMinutesPerLiter(pascalsecondpercubicmeter.PascalMinutesPerLiter).PascalSecondsPerCubicMeter, PascalMinutesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromPascalMinutesPerMilliliter(pascalsecondpercubicmeter.PascalMinutesPerMilliliter).PascalSecondsPerCubicMeter, PascalMinutesPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromPascalSecondsPerCubicCentimeter(pascalsecondpercubicmeter.PascalSecondsPerCubicCentimeter).PascalSecondsPerCubicMeter, PascalSecondsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromPascalSecondsPerCubicMeter(pascalsecondpercubicmeter.PascalSecondsPerCubicMeter).PascalSecondsPerCubicMeter, PascalSecondsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromPascalSecondsPerLiter(pascalsecondpercubicmeter.PascalSecondsPerLiter).PascalSecondsPerCubicMeter, PascalSecondsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromPascalSecondsPerMilliliter(pascalsecondpercubicmeter.PascalSecondsPerMilliliter).PascalSecondsPerCubicMeter, PascalSecondsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, FluidResistance.FromWoodUnits(pascalsecondpercubicmeter.WoodUnits).PascalSecondsPerCubicMeter, WoodUnitsTolerance);
+            FluidResistance pascalsecondpercubicmeter = FluidResistance.FromPascalSecondsPerCubicMeter(3);
+            Assert.Equal(3, FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(pascalsecondpercubicmeter.DyneSecondsPerCentimeterToTheFifth).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromMegapascalSecondsPerCubicMeter(pascalsecondpercubicmeter.MegapascalSecondsPerCubicMeter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(pascalsecondpercubicmeter.MillimeterMercuryMinutesPerCubicCentimeter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(pascalsecondpercubicmeter.MillimeterMercuryMinutesPerCubicMeter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromMillimeterMercuryMinutesPerLiter(pascalsecondpercubicmeter.MillimeterMercuryMinutesPerLiter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(pascalsecondpercubicmeter.MillimeterMercuryMinutesPerMilliliter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(pascalsecondpercubicmeter.MillimeterMercurySecondsPerCubicCentimeter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(pascalsecondpercubicmeter.MillimeterMercurySecondsPerCubicMeter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromMillimeterMercurySecondsPerLiter(pascalsecondpercubicmeter.MillimeterMercurySecondsPerLiter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromMillimeterMercurySecondsPerMilliliter(pascalsecondpercubicmeter.MillimeterMercurySecondsPerMilliliter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromPascalMinutesPerCubicCentimeter(pascalsecondpercubicmeter.PascalMinutesPerCubicCentimeter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromPascalMinutesPerCubicMeter(pascalsecondpercubicmeter.PascalMinutesPerCubicMeter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromPascalMinutesPerLiter(pascalsecondpercubicmeter.PascalMinutesPerLiter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromPascalMinutesPerMilliliter(pascalsecondpercubicmeter.PascalMinutesPerMilliliter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromPascalSecondsPerCubicCentimeter(pascalsecondpercubicmeter.PascalSecondsPerCubicCentimeter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromPascalSecondsPerCubicMeter(pascalsecondpercubicmeter.PascalSecondsPerCubicMeter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromPascalSecondsPerLiter(pascalsecondpercubicmeter.PascalSecondsPerLiter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromPascalSecondsPerMilliliter(pascalsecondpercubicmeter.PascalSecondsPerMilliliter).PascalSecondsPerCubicMeter);
+            Assert.Equal(3, FluidResistance.FromWoodUnits(pascalsecondpercubicmeter.WoodUnits).PascalSecondsPerCubicMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             FluidResistance v = FluidResistance.FromPascalSecondsPerCubicMeter(1);
-            AssertEx.EqualTolerance(-1, -v.PascalSecondsPerCubicMeter, PascalSecondsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (FluidResistance.FromPascalSecondsPerCubicMeter(3)-v).PascalSecondsPerCubicMeter, PascalSecondsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).PascalSecondsPerCubicMeter, PascalSecondsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).PascalSecondsPerCubicMeter, PascalSecondsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).PascalSecondsPerCubicMeter, PascalSecondsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (FluidResistance.FromPascalSecondsPerCubicMeter(10)/5).PascalSecondsPerCubicMeter, PascalSecondsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, FluidResistance.FromPascalSecondsPerCubicMeter(10)/FluidResistance.FromPascalSecondsPerCubicMeter(5), PascalSecondsPerCubicMeterTolerance);
+            Assert.Equal(-1, -v.PascalSecondsPerCubicMeter);
+            Assert.Equal(2, (FluidResistance.FromPascalSecondsPerCubicMeter(3) - v).PascalSecondsPerCubicMeter);
+            Assert.Equal(2, (v + v).PascalSecondsPerCubicMeter);
+            Assert.Equal(10, (v * 10).PascalSecondsPerCubicMeter);
+            Assert.Equal(10, (10 * v).PascalSecondsPerCubicMeter);
+            Assert.Equal(2, (FluidResistance.FromPascalSecondsPerCubicMeter(10) / 5).PascalSecondsPerCubicMeter);
+            Assert.Equal(2, FluidResistance.FromPascalSecondsPerCubicMeter(10) / FluidResistance.FromPascalSecondsPerCubicMeter(5));
         }
 
         [Fact]
@@ -959,8 +1019,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, FluidResistanceUnit.PascalSecondPerCubicMeter, 1, FluidResistanceUnit.PascalSecondPerCubicMeter, true)]  // Same value and unit.
         [InlineData(1, FluidResistanceUnit.PascalSecondPerCubicMeter, 2, FluidResistanceUnit.PascalSecondPerCubicMeter, false)] // Different value.
-        [InlineData(2, FluidResistanceUnit.PascalSecondPerCubicMeter, 1, FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth, false)] // Different value and unit.
-        [InlineData(1, FluidResistanceUnit.PascalSecondPerCubicMeter, 1, FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, FluidResistanceUnit unitA, double valueB, FluidResistanceUnit unitB, bool expectEqual)
         {
             var a = new FluidResistance(valueA, unitA);
@@ -1020,8 +1078,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = FluidResistance.FromPascalSecondsPerCubicMeter(firstValue);
             var otherQuantity = FluidResistance.FromPascalSecondsPerCubicMeter(secondValue);
             FluidResistance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, FluidResistance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1040,7 +1098,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<FluidResistanceUnit>();
+            var units = EnumHelper.GetValues<FluidResistanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1053,6 +1111,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(FluidResistance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(FluidResistance.Info.Units, FluidResistance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, FluidResistance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1105,26 +1175,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 WU", new FluidResistance(1, FluidResistanceUnit.WoodUnit).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Pa·s/m³", new FluidResistance(0.123456, FluidResistanceUnit.PascalSecondPerCubicMeter).ToString("s1"));
-            Assert.Equal("0.12 Pa·s/m³", new FluidResistance(0.123456, FluidResistanceUnit.PascalSecondPerCubicMeter).ToString("s2"));
-            Assert.Equal("0.123 Pa·s/m³", new FluidResistance(0.123456, FluidResistanceUnit.PascalSecondPerCubicMeter).ToString("s3"));
-            Assert.Equal("0.1235 Pa·s/m³", new FluidResistance(0.123456, FluidResistanceUnit.PascalSecondPerCubicMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Pa·s/m³", new FluidResistance(0.123456, FluidResistanceUnit.PascalSecondPerCubicMeter).ToString("s1", culture));
-            Assert.Equal("0.12 Pa·s/m³", new FluidResistance(0.123456, FluidResistanceUnit.PascalSecondPerCubicMeter).ToString("s2", culture));
-            Assert.Equal("0.123 Pa·s/m³", new FluidResistance(0.123456, FluidResistanceUnit.PascalSecondPerCubicMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 Pa·s/m³", new FluidResistance(0.123456, FluidResistanceUnit.PascalSecondPerCubicMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1151,7 +1201,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = FluidResistance.FromPascalSecondsPerCubicMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(FluidResistance), quantity.As(FluidResistance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs
index 8a1d0d30bd..d5bd56cbd0 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceChangeRateTestsBase.g.cs
@@ -181,6 +181,20 @@ public void ForceChangeRate_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<ForceChangeRateUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ForceChangeRateInfo_CreateWithCustomUnitInfos()
+        {
+            ForceChangeRateUnit[] expectedUnits = [ForceChangeRateUnit.NewtonPerSecond];
+
+            ForceChangeRate.ForceChangeRateInfo quantityInfo = ForceChangeRate.ForceChangeRateInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ForceChangeRate", quantityInfo.Name);
+            Assert.Equal(ForceChangeRate.Zero, quantityInfo.Zero);
+            Assert.Equal(ForceChangeRate.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void NewtonPerSecondToForceChangeRateUnits()
         {
@@ -293,26 +307,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ForceChangeRate.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ForceChangeRate convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ForceChangeRate quantityToConvert = quantity;
+
+                ForceChangeRate convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ForceChangeRateUnit> quantityToConvert = quantity;
+
+                IQuantity<ForceChangeRateUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ForceChangeRate(value: 1, unit: ForceChangeRate.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ForceChangeRate(value: 1, unit: ForceChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ForceChangeRateUnit> quantity = new ForceChangeRate(value: 1, unit: ForceChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ForceChangeRate(value: 1, unit: ForceChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ForceChangeRate(value: 1, unit: ForceChangeRate.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ForceChangeRate(value: 1, unit: ForceChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ForceChangeRateUnit> quantity = new ForceChangeRate(value: 1, unit: ForceChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ForceChangeRate(value: 1, unit: ForceChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -335,7 +392,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 N/s", ForceChangeRateUnit.NewtonPerSecond, 4.2)]
         [InlineData("en-US", "4.2 lbf/min", ForceChangeRateUnit.PoundForcePerMinute, 4.2)]
         [InlineData("en-US", "4.2 lbf/s", ForceChangeRateUnit.PoundForcePerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, ForceChangeRateUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ForceChangeRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ForceChangeRate.Parse(quantityString);
@@ -363,7 +420,7 @@ public void Parse(string culture, string quantityString, ForceChangeRateUnit exp
         [InlineData("en-US", "4.2 N/s", ForceChangeRateUnit.NewtonPerSecond, 4.2)]
         [InlineData("en-US", "4.2 lbf/min", ForceChangeRateUnit.PoundForcePerMinute, 4.2)]
         [InlineData("en-US", "4.2 lbf/s", ForceChangeRateUnit.PoundForcePerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, ForceChangeRateUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ForceChangeRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ForceChangeRate.TryParse(quantityString, out ForceChangeRate parsed));
@@ -654,6 +711,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ForceChangeRateU
                 var quantity = ForceChangeRate.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -677,46 +735,48 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ForceChangeRateUnit
                 IQuantity<ForceChangeRateUnit> quantityToConvert = quantity;
                 IQuantity<ForceChangeRateUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromCentinewtonsPerSecond(newtonpersecond.CentinewtonsPerSecond).NewtonsPerSecond, CentinewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromDecanewtonsPerMinute(newtonpersecond.DecanewtonsPerMinute).NewtonsPerSecond, DecanewtonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromDecanewtonsPerSecond(newtonpersecond.DecanewtonsPerSecond).NewtonsPerSecond, DecanewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromDecinewtonsPerSecond(newtonpersecond.DecinewtonsPerSecond).NewtonsPerSecond, DecinewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromKilonewtonsPerMinute(newtonpersecond.KilonewtonsPerMinute).NewtonsPerSecond, KilonewtonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromKilonewtonsPerSecond(newtonpersecond.KilonewtonsPerSecond).NewtonsPerSecond, KilonewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromKilopoundsForcePerMinute(newtonpersecond.KilopoundsForcePerMinute).NewtonsPerSecond, KilopoundsForcePerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromKilopoundsForcePerSecond(newtonpersecond.KilopoundsForcePerSecond).NewtonsPerSecond, KilopoundsForcePerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromMicronewtonsPerSecond(newtonpersecond.MicronewtonsPerSecond).NewtonsPerSecond, MicronewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromMillinewtonsPerSecond(newtonpersecond.MillinewtonsPerSecond).NewtonsPerSecond, MillinewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromNanonewtonsPerSecond(newtonpersecond.NanonewtonsPerSecond).NewtonsPerSecond, NanonewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromNewtonsPerMinute(newtonpersecond.NewtonsPerMinute).NewtonsPerSecond, NewtonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromNewtonsPerSecond(newtonpersecond.NewtonsPerSecond).NewtonsPerSecond, NewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromPoundsForcePerMinute(newtonpersecond.PoundsForcePerMinute).NewtonsPerSecond, PoundsForcePerMinuteTolerance);
-            AssertEx.EqualTolerance(1, ForceChangeRate.FromPoundsForcePerSecond(newtonpersecond.PoundsForcePerSecond).NewtonsPerSecond, PoundsForcePerSecondTolerance);
+            ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(3);
+            Assert.Equal(3, ForceChangeRate.FromCentinewtonsPerSecond(newtonpersecond.CentinewtonsPerSecond).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromDecanewtonsPerMinute(newtonpersecond.DecanewtonsPerMinute).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromDecanewtonsPerSecond(newtonpersecond.DecanewtonsPerSecond).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromDecinewtonsPerSecond(newtonpersecond.DecinewtonsPerSecond).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromKilonewtonsPerMinute(newtonpersecond.KilonewtonsPerMinute).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromKilonewtonsPerSecond(newtonpersecond.KilonewtonsPerSecond).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromKilopoundsForcePerMinute(newtonpersecond.KilopoundsForcePerMinute).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromKilopoundsForcePerSecond(newtonpersecond.KilopoundsForcePerSecond).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromMicronewtonsPerSecond(newtonpersecond.MicronewtonsPerSecond).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromMillinewtonsPerSecond(newtonpersecond.MillinewtonsPerSecond).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromNanonewtonsPerSecond(newtonpersecond.NanonewtonsPerSecond).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromNewtonsPerMinute(newtonpersecond.NewtonsPerMinute).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromNewtonsPerSecond(newtonpersecond.NewtonsPerSecond).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromPoundsForcePerMinute(newtonpersecond.PoundsForcePerMinute).NewtonsPerSecond);
+            Assert.Equal(3, ForceChangeRate.FromPoundsForcePerSecond(newtonpersecond.PoundsForcePerSecond).NewtonsPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ForceChangeRate v = ForceChangeRate.FromNewtonsPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.NewtonsPerSecond, NewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (ForceChangeRate.FromNewtonsPerSecond(3)-v).NewtonsPerSecond, NewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).NewtonsPerSecond, NewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).NewtonsPerSecond, NewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).NewtonsPerSecond, NewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (ForceChangeRate.FromNewtonsPerSecond(10)/5).NewtonsPerSecond, NewtonsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, ForceChangeRate.FromNewtonsPerSecond(10)/ForceChangeRate.FromNewtonsPerSecond(5), NewtonsPerSecondTolerance);
+            Assert.Equal(-1, -v.NewtonsPerSecond);
+            Assert.Equal(2, (ForceChangeRate.FromNewtonsPerSecond(3) - v).NewtonsPerSecond);
+            Assert.Equal(2, (v + v).NewtonsPerSecond);
+            Assert.Equal(10, (v * 10).NewtonsPerSecond);
+            Assert.Equal(10, (10 * v).NewtonsPerSecond);
+            Assert.Equal(2, (ForceChangeRate.FromNewtonsPerSecond(10) / 5).NewtonsPerSecond);
+            Assert.Equal(2, ForceChangeRate.FromNewtonsPerSecond(10) / ForceChangeRate.FromNewtonsPerSecond(5));
         }
 
         [Fact]
@@ -762,8 +822,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ForceChangeRateUnit.NewtonPerSecond, 1, ForceChangeRateUnit.NewtonPerSecond, true)]  // Same value and unit.
         [InlineData(1, ForceChangeRateUnit.NewtonPerSecond, 2, ForceChangeRateUnit.NewtonPerSecond, false)] // Different value.
-        [InlineData(2, ForceChangeRateUnit.NewtonPerSecond, 1, ForceChangeRateUnit.CentinewtonPerSecond, false)] // Different value and unit.
-        [InlineData(1, ForceChangeRateUnit.NewtonPerSecond, 1, ForceChangeRateUnit.CentinewtonPerSecond, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ForceChangeRateUnit unitA, double valueB, ForceChangeRateUnit unitB, bool expectEqual)
         {
             var a = new ForceChangeRate(valueA, unitA);
@@ -823,8 +881,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ForceChangeRate.FromNewtonsPerSecond(firstValue);
             var otherQuantity = ForceChangeRate.FromNewtonsPerSecond(secondValue);
             ForceChangeRate maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ForceChangeRate.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -843,7 +901,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ForceChangeRateUnit>();
+            var units = EnumHelper.GetValues<ForceChangeRateUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -856,6 +914,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ForceChangeRate.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ForceChangeRate.Info.Units, ForceChangeRate.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ForceChangeRate.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -900,26 +970,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 lbf/s", new ForceChangeRate(1, ForceChangeRateUnit.PoundForcePerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 N/s", new ForceChangeRate(0.123456, ForceChangeRateUnit.NewtonPerSecond).ToString("s1"));
-            Assert.Equal("0.12 N/s", new ForceChangeRate(0.123456, ForceChangeRateUnit.NewtonPerSecond).ToString("s2"));
-            Assert.Equal("0.123 N/s", new ForceChangeRate(0.123456, ForceChangeRateUnit.NewtonPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 N/s", new ForceChangeRate(0.123456, ForceChangeRateUnit.NewtonPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 N/s", new ForceChangeRate(0.123456, ForceChangeRateUnit.NewtonPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 N/s", new ForceChangeRate(0.123456, ForceChangeRateUnit.NewtonPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 N/s", new ForceChangeRate(0.123456, ForceChangeRateUnit.NewtonPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 N/s", new ForceChangeRate(0.123456, ForceChangeRateUnit.NewtonPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -946,7 +996,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ForceChangeRate.FromNewtonsPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ForceChangeRate), quantity.As(ForceChangeRate.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs
index 6aae573015..960bc0b3ba 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForcePerLengthTestsBase.g.cs
@@ -273,6 +273,20 @@ public void ForcePerLength_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<ForcePerLengthUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ForcePerLengthInfo_CreateWithCustomUnitInfos()
+        {
+            ForcePerLengthUnit[] expectedUnits = [ForcePerLengthUnit.NewtonPerMeter];
+
+            ForcePerLength.ForcePerLengthInfo quantityInfo = ForcePerLength.ForcePerLengthInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ForcePerLength", quantityInfo.Name);
+            Assert.Equal(ForcePerLength.Zero, quantityInfo.Zero);
+            Assert.Equal(ForcePerLength.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void NewtonPerMeterToForcePerLengthUnits()
         {
@@ -431,26 +445,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ForcePerLength.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ForcePerLength convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ForcePerLength quantityToConvert = quantity;
+
+                ForcePerLength convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ForcePerLengthUnit> quantityToConvert = quantity;
+
+                IQuantity<ForcePerLengthUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ForcePerLength(value: 1, unit: ForcePerLength.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ForcePerLength(value: 1, unit: ForcePerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ForcePerLengthUnit> quantity = new ForcePerLength(value: 1, unit: ForcePerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ForcePerLength(value: 1, unit: ForcePerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ForcePerLength(value: 1, unit: ForcePerLength.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ForcePerLength(value: 1, unit: ForcePerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ForcePerLengthUnit> quantity = new ForcePerLength(value: 1, unit: ForcePerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ForcePerLength(value: 1, unit: ForcePerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -502,7 +559,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 тс/см", ForcePerLengthUnit.TonneForcePerCentimeter, 4.2)]
         [InlineData("ru-RU", "4,2 тс/м", ForcePerLengthUnit.TonneForcePerMeter, 4.2)]
         [InlineData("ru-RU", "4,2 тс/мм", ForcePerLengthUnit.TonneForcePerMillimeter, 4.2)]
-        public void Parse(string culture, string quantityString, ForcePerLengthUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ForcePerLengthUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ForcePerLength.Parse(quantityString);
@@ -559,7 +616,7 @@ public void Parse(string culture, string quantityString, ForcePerLengthUnit expe
         [InlineData("ru-RU", "4,2 тс/см", ForcePerLengthUnit.TonneForcePerCentimeter, 4.2)]
         [InlineData("ru-RU", "4,2 тс/м", ForcePerLengthUnit.TonneForcePerMeter, 4.2)]
         [InlineData("ru-RU", "4,2 тс/мм", ForcePerLengthUnit.TonneForcePerMillimeter, 4.2)]
-        public void TryParse(string culture, string quantityString, ForcePerLengthUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ForcePerLengthUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ForcePerLength.TryParse(quantityString, out ForcePerLength parsed));
@@ -1087,6 +1144,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ForcePerLengthUn
                 var quantity = ForcePerLength.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1110,69 +1168,71 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ForcePerLengthUnit
                 IQuantity<ForcePerLengthUnit> quantityToConvert = quantity;
                 IQuantity<ForcePerLengthUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ForcePerLength newtonpermeter = ForcePerLength.FromNewtonsPerMeter(1);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromCentinewtonsPerCentimeter(newtonpermeter.CentinewtonsPerCentimeter).NewtonsPerMeter, CentinewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromCentinewtonsPerMeter(newtonpermeter.CentinewtonsPerMeter).NewtonsPerMeter, CentinewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromCentinewtonsPerMillimeter(newtonpermeter.CentinewtonsPerMillimeter).NewtonsPerMeter, CentinewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecanewtonsPerCentimeter(newtonpermeter.DecanewtonsPerCentimeter).NewtonsPerMeter, DecanewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecanewtonsPerMeter(newtonpermeter.DecanewtonsPerMeter).NewtonsPerMeter, DecanewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecanewtonsPerMillimeter(newtonpermeter.DecanewtonsPerMillimeter).NewtonsPerMeter, DecanewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecinewtonsPerCentimeter(newtonpermeter.DecinewtonsPerCentimeter).NewtonsPerMeter, DecinewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecinewtonsPerMeter(newtonpermeter.DecinewtonsPerMeter).NewtonsPerMeter, DecinewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromDecinewtonsPerMillimeter(newtonpermeter.DecinewtonsPerMillimeter).NewtonsPerMeter, DecinewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilogramsForcePerCentimeter(newtonpermeter.KilogramsForcePerCentimeter).NewtonsPerMeter, KilogramsForcePerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilogramsForcePerMeter(newtonpermeter.KilogramsForcePerMeter).NewtonsPerMeter, KilogramsForcePerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilogramsForcePerMillimeter(newtonpermeter.KilogramsForcePerMillimeter).NewtonsPerMeter, KilogramsForcePerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilonewtonsPerCentimeter(newtonpermeter.KilonewtonsPerCentimeter).NewtonsPerMeter, KilonewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilonewtonsPerMeter(newtonpermeter.KilonewtonsPerMeter).NewtonsPerMeter, KilonewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilonewtonsPerMillimeter(newtonpermeter.KilonewtonsPerMillimeter).NewtonsPerMeter, KilonewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilopoundsForcePerFoot(newtonpermeter.KilopoundsForcePerFoot).NewtonsPerMeter, KilopoundsForcePerFootTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromKilopoundsForcePerInch(newtonpermeter.KilopoundsForcePerInch).NewtonsPerMeter, KilopoundsForcePerInchTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMeganewtonsPerCentimeter(newtonpermeter.MeganewtonsPerCentimeter).NewtonsPerMeter, MeganewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMeganewtonsPerMeter(newtonpermeter.MeganewtonsPerMeter).NewtonsPerMeter, MeganewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMeganewtonsPerMillimeter(newtonpermeter.MeganewtonsPerMillimeter).NewtonsPerMeter, MeganewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMicronewtonsPerCentimeter(newtonpermeter.MicronewtonsPerCentimeter).NewtonsPerMeter, MicronewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMicronewtonsPerMeter(newtonpermeter.MicronewtonsPerMeter).NewtonsPerMeter, MicronewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMicronewtonsPerMillimeter(newtonpermeter.MicronewtonsPerMillimeter).NewtonsPerMeter, MicronewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMillinewtonsPerCentimeter(newtonpermeter.MillinewtonsPerCentimeter).NewtonsPerMeter, MillinewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMillinewtonsPerMeter(newtonpermeter.MillinewtonsPerMeter).NewtonsPerMeter, MillinewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromMillinewtonsPerMillimeter(newtonpermeter.MillinewtonsPerMillimeter).NewtonsPerMeter, MillinewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNanonewtonsPerCentimeter(newtonpermeter.NanonewtonsPerCentimeter).NewtonsPerMeter, NanonewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNanonewtonsPerMeter(newtonpermeter.NanonewtonsPerMeter).NewtonsPerMeter, NanonewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNanonewtonsPerMillimeter(newtonpermeter.NanonewtonsPerMillimeter).NewtonsPerMeter, NanonewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNewtonsPerCentimeter(newtonpermeter.NewtonsPerCentimeter).NewtonsPerMeter, NewtonsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNewtonsPerMeter(newtonpermeter.NewtonsPerMeter).NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromNewtonsPerMillimeter(newtonpermeter.NewtonsPerMillimeter).NewtonsPerMeter, NewtonsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromPoundsForcePerFoot(newtonpermeter.PoundsForcePerFoot).NewtonsPerMeter, PoundsForcePerFootTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromPoundsForcePerInch(newtonpermeter.PoundsForcePerInch).NewtonsPerMeter, PoundsForcePerInchTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromPoundsForcePerYard(newtonpermeter.PoundsForcePerYard).NewtonsPerMeter, PoundsForcePerYardTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromTonnesForcePerCentimeter(newtonpermeter.TonnesForcePerCentimeter).NewtonsPerMeter, TonnesForcePerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromTonnesForcePerMeter(newtonpermeter.TonnesForcePerMeter).NewtonsPerMeter, TonnesForcePerMeterTolerance);
-            AssertEx.EqualTolerance(1, ForcePerLength.FromTonnesForcePerMillimeter(newtonpermeter.TonnesForcePerMillimeter).NewtonsPerMeter, TonnesForcePerMillimeterTolerance);
+            ForcePerLength newtonpermeter = ForcePerLength.FromNewtonsPerMeter(3);
+            Assert.Equal(3, ForcePerLength.FromCentinewtonsPerCentimeter(newtonpermeter.CentinewtonsPerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromCentinewtonsPerMeter(newtonpermeter.CentinewtonsPerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromCentinewtonsPerMillimeter(newtonpermeter.CentinewtonsPerMillimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromDecanewtonsPerCentimeter(newtonpermeter.DecanewtonsPerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromDecanewtonsPerMeter(newtonpermeter.DecanewtonsPerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromDecanewtonsPerMillimeter(newtonpermeter.DecanewtonsPerMillimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromDecinewtonsPerCentimeter(newtonpermeter.DecinewtonsPerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromDecinewtonsPerMeter(newtonpermeter.DecinewtonsPerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromDecinewtonsPerMillimeter(newtonpermeter.DecinewtonsPerMillimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromKilogramsForcePerCentimeter(newtonpermeter.KilogramsForcePerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromKilogramsForcePerMeter(newtonpermeter.KilogramsForcePerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromKilogramsForcePerMillimeter(newtonpermeter.KilogramsForcePerMillimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromKilonewtonsPerCentimeter(newtonpermeter.KilonewtonsPerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromKilonewtonsPerMeter(newtonpermeter.KilonewtonsPerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromKilonewtonsPerMillimeter(newtonpermeter.KilonewtonsPerMillimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromKilopoundsForcePerFoot(newtonpermeter.KilopoundsForcePerFoot).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromKilopoundsForcePerInch(newtonpermeter.KilopoundsForcePerInch).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromMeganewtonsPerCentimeter(newtonpermeter.MeganewtonsPerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromMeganewtonsPerMeter(newtonpermeter.MeganewtonsPerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromMeganewtonsPerMillimeter(newtonpermeter.MeganewtonsPerMillimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromMicronewtonsPerCentimeter(newtonpermeter.MicronewtonsPerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromMicronewtonsPerMeter(newtonpermeter.MicronewtonsPerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromMicronewtonsPerMillimeter(newtonpermeter.MicronewtonsPerMillimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromMillinewtonsPerCentimeter(newtonpermeter.MillinewtonsPerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromMillinewtonsPerMeter(newtonpermeter.MillinewtonsPerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromMillinewtonsPerMillimeter(newtonpermeter.MillinewtonsPerMillimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromNanonewtonsPerCentimeter(newtonpermeter.NanonewtonsPerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromNanonewtonsPerMeter(newtonpermeter.NanonewtonsPerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromNanonewtonsPerMillimeter(newtonpermeter.NanonewtonsPerMillimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromNewtonsPerCentimeter(newtonpermeter.NewtonsPerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromNewtonsPerMeter(newtonpermeter.NewtonsPerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromNewtonsPerMillimeter(newtonpermeter.NewtonsPerMillimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromPoundsForcePerFoot(newtonpermeter.PoundsForcePerFoot).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromPoundsForcePerInch(newtonpermeter.PoundsForcePerInch).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromPoundsForcePerYard(newtonpermeter.PoundsForcePerYard).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromTonnesForcePerCentimeter(newtonpermeter.TonnesForcePerCentimeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromTonnesForcePerMeter(newtonpermeter.TonnesForcePerMeter).NewtonsPerMeter);
+            Assert.Equal(3, ForcePerLength.FromTonnesForcePerMillimeter(newtonpermeter.TonnesForcePerMillimeter).NewtonsPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ForcePerLength v = ForcePerLength.FromNewtonsPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ForcePerLength.FromNewtonsPerMeter(3)-v).NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (ForcePerLength.FromNewtonsPerMeter(10)/5).NewtonsPerMeter, NewtonsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, ForcePerLength.FromNewtonsPerMeter(10)/ForcePerLength.FromNewtonsPerMeter(5), NewtonsPerMeterTolerance);
+            Assert.Equal(-1, -v.NewtonsPerMeter);
+            Assert.Equal(2, (ForcePerLength.FromNewtonsPerMeter(3) - v).NewtonsPerMeter);
+            Assert.Equal(2, (v + v).NewtonsPerMeter);
+            Assert.Equal(10, (v * 10).NewtonsPerMeter);
+            Assert.Equal(10, (10 * v).NewtonsPerMeter);
+            Assert.Equal(2, (ForcePerLength.FromNewtonsPerMeter(10) / 5).NewtonsPerMeter);
+            Assert.Equal(2, ForcePerLength.FromNewtonsPerMeter(10) / ForcePerLength.FromNewtonsPerMeter(5));
         }
 
         [Fact]
@@ -1218,8 +1278,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ForcePerLengthUnit.NewtonPerMeter, 1, ForcePerLengthUnit.NewtonPerMeter, true)]  // Same value and unit.
         [InlineData(1, ForcePerLengthUnit.NewtonPerMeter, 2, ForcePerLengthUnit.NewtonPerMeter, false)] // Different value.
-        [InlineData(2, ForcePerLengthUnit.NewtonPerMeter, 1, ForcePerLengthUnit.CentinewtonPerCentimeter, false)] // Different value and unit.
-        [InlineData(1, ForcePerLengthUnit.NewtonPerMeter, 1, ForcePerLengthUnit.CentinewtonPerCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ForcePerLengthUnit unitA, double valueB, ForcePerLengthUnit unitB, bool expectEqual)
         {
             var a = new ForcePerLength(valueA, unitA);
@@ -1279,8 +1337,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ForcePerLength.FromNewtonsPerMeter(firstValue);
             var otherQuantity = ForcePerLength.FromNewtonsPerMeter(secondValue);
             ForcePerLength maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ForcePerLength.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1299,7 +1357,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ForcePerLengthUnit>();
+            var units = EnumHelper.GetValues<ForcePerLengthUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1312,6 +1370,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ForcePerLength.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ForcePerLength.Info.Units, ForcePerLength.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ForcePerLength.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1402,26 +1472,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 tf/mm", new ForcePerLength(1, ForcePerLengthUnit.TonneForcePerMillimeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 N/m", new ForcePerLength(0.123456, ForcePerLengthUnit.NewtonPerMeter).ToString("s1"));
-            Assert.Equal("0.12 N/m", new ForcePerLength(0.123456, ForcePerLengthUnit.NewtonPerMeter).ToString("s2"));
-            Assert.Equal("0.123 N/m", new ForcePerLength(0.123456, ForcePerLengthUnit.NewtonPerMeter).ToString("s3"));
-            Assert.Equal("0.1235 N/m", new ForcePerLength(0.123456, ForcePerLengthUnit.NewtonPerMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 N/m", new ForcePerLength(0.123456, ForcePerLengthUnit.NewtonPerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 N/m", new ForcePerLength(0.123456, ForcePerLengthUnit.NewtonPerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 N/m", new ForcePerLength(0.123456, ForcePerLengthUnit.NewtonPerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 N/m", new ForcePerLength(0.123456, ForcePerLengthUnit.NewtonPerMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1448,7 +1498,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ForcePerLength.FromNewtonsPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ForcePerLength), quantity.As(ForcePerLength.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs
index 1514287143..a50c572652 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs
@@ -42,6 +42,7 @@ public abstract partial class ForceTestsBase : QuantityTestsBase
     {
         protected abstract double DecanewtonsInOneNewton { get; }
         protected abstract double DyneInOneNewton { get; }
+        protected abstract double GramsForceInOneNewton { get; }
         protected abstract double KilogramsForceInOneNewton { get; }
         protected abstract double KilonewtonsInOneNewton { get; }
         protected abstract double KilopondsInOneNewton { get; }
@@ -59,6 +60,7 @@ public abstract partial class ForceTestsBase : QuantityTestsBase
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double DecanewtonsTolerance { get { return 1e-5; } }
         protected virtual double DyneTolerance { get { return 1e-5; } }
+        protected virtual double GramsForceTolerance { get { return 1e-5; } }
         protected virtual double KilogramsForceTolerance { get { return 1e-5; } }
         protected virtual double KilonewtonsTolerance { get { return 1e-5; } }
         protected virtual double KilopondsTolerance { get { return 1e-5; } }
@@ -80,6 +82,7 @@ public abstract partial class ForceTestsBase : QuantityTestsBase
             {
                 ForceUnit.Decanewton => (DecanewtonsInOneNewton, DecanewtonsTolerance),
                 ForceUnit.Dyn => (DyneInOneNewton, DyneTolerance),
+                ForceUnit.GramForce => (GramsForceInOneNewton, GramsForceTolerance),
                 ForceUnit.KilogramForce => (KilogramsForceInOneNewton, KilogramsForceTolerance),
                 ForceUnit.Kilonewton => (KilonewtonsInOneNewton, KilonewtonsTolerance),
                 ForceUnit.Kilopond => (KilopondsInOneNewton, KilopondsTolerance),
@@ -101,6 +104,7 @@ public abstract partial class ForceTestsBase : QuantityTestsBase
         {
             new object[] { ForceUnit.Decanewton },
             new object[] { ForceUnit.Dyn },
+            new object[] { ForceUnit.GramForce },
             new object[] { ForceUnit.KilogramForce },
             new object[] { ForceUnit.Kilonewton },
             new object[] { ForceUnit.Kilopond },
@@ -181,12 +185,27 @@ public void Force_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<ForceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ForceInfo_CreateWithCustomUnitInfos()
+        {
+            ForceUnit[] expectedUnits = [ForceUnit.Newton];
+
+            Force.ForceInfo quantityInfo = Force.ForceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Force", quantityInfo.Name);
+            Assert.Equal(Force.Zero, quantityInfo.Zero);
+            Assert.Equal(Force.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void NewtonToForceUnits()
         {
             Force newton = Force.FromNewtons(1);
             AssertEx.EqualTolerance(DecanewtonsInOneNewton, newton.Decanewtons, DecanewtonsTolerance);
             AssertEx.EqualTolerance(DyneInOneNewton, newton.Dyne, DyneTolerance);
+            AssertEx.EqualTolerance(GramsForceInOneNewton, newton.GramsForce, GramsForceTolerance);
             AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.KilogramsForce, KilogramsForceTolerance);
             AssertEx.EqualTolerance(KilonewtonsInOneNewton, newton.Kilonewtons, KilonewtonsTolerance);
             AssertEx.EqualTolerance(KilopondsInOneNewton, newton.Kiloponds, KilopondsTolerance);
@@ -237,6 +256,7 @@ public void As()
             var newton = Force.FromNewtons(1);
             AssertEx.EqualTolerance(DecanewtonsInOneNewton, newton.As(ForceUnit.Decanewton), DecanewtonsTolerance);
             AssertEx.EqualTolerance(DyneInOneNewton, newton.As(ForceUnit.Dyn), DyneTolerance);
+            AssertEx.EqualTolerance(GramsForceInOneNewton, newton.As(ForceUnit.GramForce), GramsForceTolerance);
             AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.As(ForceUnit.KilogramForce), KilogramsForceTolerance);
             AssertEx.EqualTolerance(KilonewtonsInOneNewton, newton.As(ForceUnit.Kilonewton), KilonewtonsTolerance);
             AssertEx.EqualTolerance(KilopondsInOneNewton, newton.As(ForceUnit.Kilopond), KilopondsTolerance);
@@ -293,31 +313,75 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Force.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Force convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Force quantityToConvert = quantity;
+
+                Force convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ForceUnit> quantityToConvert = quantity;
+
+                IQuantity<ForceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Force(value: 1, unit: Force.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Force(value: 1, unit: Force.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ForceUnit> quantity = new Force(value: 1, unit: Force.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Force(value: 1, unit: Force.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Force(value: 1, unit: Force.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Force(value: 1, unit: Force.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ForceUnit> quantity = new Force(value: 1, unit: Force.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Force(value: 1, unit: Force.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 daN", ForceUnit.Decanewton, 4.2)]
         [InlineData("en-US", "4.2 dyn", ForceUnit.Dyn, 4.2)]
+        [InlineData("en-US", "4.2 gf", ForceUnit.GramForce, 4.2)]
         [InlineData("en-US", "4.2 kgf", ForceUnit.KilogramForce, 4.2)]
         [InlineData("en-US", "4.2 kN", ForceUnit.Kilonewton, 4.2)]
         [InlineData("en-US", "4.2 kp", ForceUnit.Kilopond, 4.2)]
@@ -338,6 +402,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 Ton", ForceUnit.TonneForce, 4.2)]
         [InlineData("ru-RU", "4,2 даН", ForceUnit.Decanewton, 4.2)]
         [InlineData("ru-RU", "4,2 дин", ForceUnit.Dyn, 4.2)]
+        [InlineData("ru-RU", "4,2 гс", ForceUnit.GramForce, 4.2)]
         [InlineData("ru-RU", "4,2 кН", ForceUnit.Kilonewton, 4.2)]
         [InlineData("ru-RU", "4,2 кипф", ForceUnit.KilopoundForce, 4.2)]
         [InlineData("ru-RU", "4,2 койка", ForceUnit.KilopoundForce, 4.2)]
@@ -349,7 +414,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 паундаль", ForceUnit.Poundal, 4.2)]
         [InlineData("ru-RU", "4,2 фунт-сила", ForceUnit.PoundForce, 4.2)]
         [InlineData("ru-RU", "4,2 тс", ForceUnit.TonneForce, 4.2)]
-        public void Parse(string culture, string quantityString, ForceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ForceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Force.Parse(quantityString);
@@ -367,6 +432,7 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [Theory]
         [InlineData("en-US", "4.2 daN", ForceUnit.Decanewton, 4.2)]
         [InlineData("en-US", "4.2 dyn", ForceUnit.Dyn, 4.2)]
+        [InlineData("en-US", "4.2 gf", ForceUnit.GramForce, 4.2)]
         [InlineData("en-US", "4.2 kgf", ForceUnit.KilogramForce, 4.2)]
         [InlineData("en-US", "4.2 kN", ForceUnit.Kilonewton, 4.2)]
         [InlineData("en-US", "4.2 kp", ForceUnit.Kilopond, 4.2)]
@@ -387,6 +453,7 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("en-US", "4.2 Ton", ForceUnit.TonneForce, 4.2)]
         [InlineData("ru-RU", "4,2 даН", ForceUnit.Decanewton, 4.2)]
         [InlineData("ru-RU", "4,2 дин", ForceUnit.Dyn, 4.2)]
+        [InlineData("ru-RU", "4,2 гс", ForceUnit.GramForce, 4.2)]
         [InlineData("ru-RU", "4,2 кН", ForceUnit.Kilonewton, 4.2)]
         [InlineData("ru-RU", "4,2 кипф", ForceUnit.KilopoundForce, 4.2)]
         [InlineData("ru-RU", "4,2 койка", ForceUnit.KilopoundForce, 4.2)]
@@ -398,7 +465,7 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("ru-RU", "4,2 паундаль", ForceUnit.Poundal, 4.2)]
         [InlineData("ru-RU", "4,2 фунт-сила", ForceUnit.PoundForce, 4.2)]
         [InlineData("ru-RU", "4,2 тс", ForceUnit.TonneForce, 4.2)]
-        public void TryParse(string culture, string quantityString, ForceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ForceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Force.TryParse(quantityString, out Force parsed));
@@ -416,6 +483,7 @@ public void TryParseWithAmbiguousAbbreviation(string culture, string quantityStr
         [Theory]
         [InlineData("daN", ForceUnit.Decanewton)]
         [InlineData("dyn", ForceUnit.Dyn)]
+        [InlineData("gf", ForceUnit.GramForce)]
         [InlineData("kgf", ForceUnit.KilogramForce)]
         [InlineData("kN", ForceUnit.Kilonewton)]
         [InlineData("kp", ForceUnit.Kilopond)]
@@ -445,6 +513,7 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, ForceUnit
         [Theory]
         [InlineData("daN", ForceUnit.Decanewton)]
         [InlineData("dyn", ForceUnit.Dyn)]
+        [InlineData("gf", ForceUnit.GramForce)]
         [InlineData("kgf", ForceUnit.KilogramForce)]
         [InlineData("kN", ForceUnit.Kilonewton)]
         [InlineData("kp", ForceUnit.Kilopond)]
@@ -474,6 +543,7 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [Theory]
         [InlineData("en-US", "daN", ForceUnit.Decanewton)]
         [InlineData("en-US", "dyn", ForceUnit.Dyn)]
+        [InlineData("en-US", "gf", ForceUnit.GramForce)]
         [InlineData("en-US", "kgf", ForceUnit.KilogramForce)]
         [InlineData("en-US", "kN", ForceUnit.Kilonewton)]
         [InlineData("en-US", "kp", ForceUnit.Kilopond)]
@@ -494,6 +564,7 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "Ton", ForceUnit.TonneForce)]
         [InlineData("ru-RU", "даН", ForceUnit.Decanewton)]
         [InlineData("ru-RU", "дин", ForceUnit.Dyn)]
+        [InlineData("ru-RU", "гс", ForceUnit.GramForce)]
         [InlineData("ru-RU", "кН", ForceUnit.Kilonewton)]
         [InlineData("ru-RU", "кипф", ForceUnit.KilopoundForce)]
         [InlineData("ru-RU", "койка", ForceUnit.KilopoundForce)]
@@ -515,6 +586,7 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Fo
         [Theory]
         [InlineData("en-US", "daN", ForceUnit.Decanewton)]
         [InlineData("en-US", "dyn", ForceUnit.Dyn)]
+        [InlineData("en-US", "gf", ForceUnit.GramForce)]
         [InlineData("en-US", "kgf", ForceUnit.KilogramForce)]
         [InlineData("en-US", "kN", ForceUnit.Kilonewton)]
         [InlineData("en-US", "kp", ForceUnit.Kilopond)]
@@ -535,6 +607,7 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Fo
         [InlineData("en-US", "Ton", ForceUnit.TonneForce)]
         [InlineData("ru-RU", "даН", ForceUnit.Decanewton)]
         [InlineData("ru-RU", "дин", ForceUnit.Dyn)]
+        [InlineData("ru-RU", "гс", ForceUnit.GramForce)]
         [InlineData("ru-RU", "кН", ForceUnit.Kilonewton)]
         [InlineData("ru-RU", "кипф", ForceUnit.KilopoundForce)]
         [InlineData("ru-RU", "койка", ForceUnit.KilopoundForce)]
@@ -562,6 +635,7 @@ public void ParseUnitWithAmbiguousAbbreviation(string culture, string abbreviati
         [Theory]
         [InlineData("daN", ForceUnit.Decanewton)]
         [InlineData("dyn", ForceUnit.Dyn)]
+        [InlineData("gf", ForceUnit.GramForce)]
         [InlineData("kgf", ForceUnit.KilogramForce)]
         [InlineData("kN", ForceUnit.Kilonewton)]
         [InlineData("kp", ForceUnit.Kilopond)]
@@ -591,6 +665,7 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, ForceU
         [Theory]
         [InlineData("daN", ForceUnit.Decanewton)]
         [InlineData("dyn", ForceUnit.Dyn)]
+        [InlineData("gf", ForceUnit.GramForce)]
         [InlineData("kgf", ForceUnit.KilogramForce)]
         [InlineData("kN", ForceUnit.Kilonewton)]
         [InlineData("kp", ForceUnit.Kilopond)]
@@ -620,6 +695,7 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [Theory]
         [InlineData("en-US", "daN", ForceUnit.Decanewton)]
         [InlineData("en-US", "dyn", ForceUnit.Dyn)]
+        [InlineData("en-US", "gf", ForceUnit.GramForce)]
         [InlineData("en-US", "kgf", ForceUnit.KilogramForce)]
         [InlineData("en-US", "kN", ForceUnit.Kilonewton)]
         [InlineData("en-US", "kp", ForceUnit.Kilopond)]
@@ -640,6 +716,7 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "Ton", ForceUnit.TonneForce)]
         [InlineData("ru-RU", "даН", ForceUnit.Decanewton)]
         [InlineData("ru-RU", "дин", ForceUnit.Dyn)]
+        [InlineData("ru-RU", "гс", ForceUnit.GramForce)]
         [InlineData("ru-RU", "кН", ForceUnit.Kilonewton)]
         [InlineData("ru-RU", "кипф", ForceUnit.KilopoundForce)]
         [InlineData("ru-RU", "койка", ForceUnit.KilopoundForce)]
@@ -661,6 +738,7 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [Theory]
         [InlineData("en-US", "daN", ForceUnit.Decanewton)]
         [InlineData("en-US", "dyn", ForceUnit.Dyn)]
+        [InlineData("en-US", "gf", ForceUnit.GramForce)]
         [InlineData("en-US", "kgf", ForceUnit.KilogramForce)]
         [InlineData("en-US", "kN", ForceUnit.Kilonewton)]
         [InlineData("en-US", "kp", ForceUnit.Kilopond)]
@@ -681,6 +759,7 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "Ton", ForceUnit.TonneForce)]
         [InlineData("ru-RU", "даН", ForceUnit.Decanewton)]
         [InlineData("ru-RU", "дин", ForceUnit.Dyn)]
+        [InlineData("ru-RU", "гс", ForceUnit.GramForce)]
         [InlineData("ru-RU", "кН", ForceUnit.Kilonewton)]
         [InlineData("ru-RU", "кипф", ForceUnit.KilopoundForce)]
         [InlineData("ru-RU", "койка", ForceUnit.KilopoundForce)]
@@ -708,6 +787,7 @@ public void TryParseUnitWithAmbiguousAbbreviation(string culture, string abbrevi
         [Theory]
         [InlineData("en-US", ForceUnit.Decanewton, "daN")]
         [InlineData("en-US", ForceUnit.Dyn, "dyn")]
+        [InlineData("en-US", ForceUnit.GramForce, "gf")]
         [InlineData("en-US", ForceUnit.KilogramForce, "kgf")]
         [InlineData("en-US", ForceUnit.Kilonewton, "kN")]
         [InlineData("en-US", ForceUnit.Kilopond, "kp")]
@@ -723,6 +803,7 @@ public void TryParseUnitWithAmbiguousAbbreviation(string culture, string abbrevi
         [InlineData("en-US", ForceUnit.TonneForce, "tf")]
         [InlineData("ru-RU", ForceUnit.Decanewton, "даН")]
         [InlineData("ru-RU", ForceUnit.Dyn, "дин")]
+        [InlineData("ru-RU", ForceUnit.GramForce, "гс")]
         [InlineData("ru-RU", ForceUnit.KilogramForce, "кгс")]
         [InlineData("ru-RU", ForceUnit.Kilonewton, "кН")]
         [InlineData("ru-RU", ForceUnit.Kilopond, "кгс")]
@@ -783,6 +864,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ForceUnit unit)
                 var quantity = Force.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -806,46 +888,49 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ForceUnit unit)
                 IQuantity<ForceUnit> quantityToConvert = quantity;
                 IQuantity<ForceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Force newton = Force.FromNewtons(1);
-            AssertEx.EqualTolerance(1, Force.FromDecanewtons(newton.Decanewtons).Newtons, DecanewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromDyne(newton.Dyne).Newtons, DyneTolerance);
-            AssertEx.EqualTolerance(1, Force.FromKilogramsForce(newton.KilogramsForce).Newtons, KilogramsForceTolerance);
-            AssertEx.EqualTolerance(1, Force.FromKilonewtons(newton.Kilonewtons).Newtons, KilonewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromKiloponds(newton.Kiloponds).Newtons, KilopondsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromKilopoundsForce(newton.KilopoundsForce).Newtons, KilopoundsForceTolerance);
-            AssertEx.EqualTolerance(1, Force.FromMeganewtons(newton.Meganewtons).Newtons, MeganewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromMicronewtons(newton.Micronewtons).Newtons, MicronewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromMillinewtons(newton.Millinewtons).Newtons, MillinewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromNewtons(newton.Newtons).Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromOunceForce(newton.OunceForce).Newtons, OunceForceTolerance);
-            AssertEx.EqualTolerance(1, Force.FromPoundals(newton.Poundals).Newtons, PoundalsTolerance);
-            AssertEx.EqualTolerance(1, Force.FromPoundsForce(newton.PoundsForce).Newtons, PoundsForceTolerance);
-            AssertEx.EqualTolerance(1, Force.FromShortTonsForce(newton.ShortTonsForce).Newtons, ShortTonsForceTolerance);
-            AssertEx.EqualTolerance(1, Force.FromTonnesForce(newton.TonnesForce).Newtons, TonnesForceTolerance);
+            Force newton = Force.FromNewtons(3);
+            Assert.Equal(3, Force.FromDecanewtons(newton.Decanewtons).Newtons);
+            Assert.Equal(3, Force.FromDyne(newton.Dyne).Newtons);
+            Assert.Equal(3, Force.FromGramsForce(newton.GramsForce).Newtons);
+            Assert.Equal(3, Force.FromKilogramsForce(newton.KilogramsForce).Newtons);
+            Assert.Equal(3, Force.FromKilonewtons(newton.Kilonewtons).Newtons);
+            Assert.Equal(3, Force.FromKiloponds(newton.Kiloponds).Newtons);
+            Assert.Equal(3, Force.FromKilopoundsForce(newton.KilopoundsForce).Newtons);
+            Assert.Equal(3, Force.FromMeganewtons(newton.Meganewtons).Newtons);
+            Assert.Equal(3, Force.FromMicronewtons(newton.Micronewtons).Newtons);
+            Assert.Equal(3, Force.FromMillinewtons(newton.Millinewtons).Newtons);
+            Assert.Equal(3, Force.FromNewtons(newton.Newtons).Newtons);
+            Assert.Equal(3, Force.FromOunceForce(newton.OunceForce).Newtons);
+            Assert.Equal(3, Force.FromPoundals(newton.Poundals).Newtons);
+            Assert.Equal(3, Force.FromPoundsForce(newton.PoundsForce).Newtons);
+            Assert.Equal(3, Force.FromShortTonsForce(newton.ShortTonsForce).Newtons);
+            Assert.Equal(3, Force.FromTonnesForce(newton.TonnesForce).Newtons);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Force v = Force.FromNewtons(1);
-            AssertEx.EqualTolerance(-1, -v.Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(2, (Force.FromNewtons(3)-v).Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(2, (Force.FromNewtons(10)/5).Newtons, NewtonsTolerance);
-            AssertEx.EqualTolerance(2, Force.FromNewtons(10)/Force.FromNewtons(5), NewtonsTolerance);
+            Assert.Equal(-1, -v.Newtons);
+            Assert.Equal(2, (Force.FromNewtons(3) - v).Newtons);
+            Assert.Equal(2, (v + v).Newtons);
+            Assert.Equal(10, (v * 10).Newtons);
+            Assert.Equal(10, (10 * v).Newtons);
+            Assert.Equal(2, (Force.FromNewtons(10) / 5).Newtons);
+            Assert.Equal(2, Force.FromNewtons(10) / Force.FromNewtons(5));
         }
 
         [Fact]
@@ -891,8 +976,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ForceUnit.Newton, 1, ForceUnit.Newton, true)]  // Same value and unit.
         [InlineData(1, ForceUnit.Newton, 2, ForceUnit.Newton, false)] // Different value.
-        [InlineData(2, ForceUnit.Newton, 1, ForceUnit.Decanewton, false)] // Different value and unit.
-        [InlineData(1, ForceUnit.Newton, 1, ForceUnit.Decanewton, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ForceUnit unitA, double valueB, ForceUnit unitB, bool expectEqual)
         {
             var a = new Force(valueA, unitA);
@@ -952,8 +1035,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Force.FromNewtons(firstValue);
             var otherQuantity = Force.FromNewtons(secondValue);
             Force maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Force.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -972,7 +1055,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ForceUnit>();
+            var units = EnumHelper.GetValues<ForceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -985,12 +1068,25 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Force.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Force.Info.Units, Force.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Force.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
             using var _ = new CultureScope("en-US");
             Assert.Equal("1 daN", new Force(1, ForceUnit.Decanewton).ToString());
             Assert.Equal("1 dyn", new Force(1, ForceUnit.Dyn).ToString());
+            Assert.Equal("1 gf", new Force(1, ForceUnit.GramForce).ToString());
             Assert.Equal("1 kgf", new Force(1, ForceUnit.KilogramForce).ToString());
             Assert.Equal("1 kN", new Force(1, ForceUnit.Kilonewton).ToString());
             Assert.Equal("1 kp", new Force(1, ForceUnit.Kilopond).ToString());
@@ -1014,6 +1110,7 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
 
             Assert.Equal("1 daN", new Force(1, ForceUnit.Decanewton).ToString(swedishCulture));
             Assert.Equal("1 dyn", new Force(1, ForceUnit.Dyn).ToString(swedishCulture));
+            Assert.Equal("1 gf", new Force(1, ForceUnit.GramForce).ToString(swedishCulture));
             Assert.Equal("1 kgf", new Force(1, ForceUnit.KilogramForce).ToString(swedishCulture));
             Assert.Equal("1 kN", new Force(1, ForceUnit.Kilonewton).ToString(swedishCulture));
             Assert.Equal("1 kp", new Force(1, ForceUnit.Kilopond).ToString(swedishCulture));
@@ -1029,26 +1126,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 tf", new Force(1, ForceUnit.TonneForce).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 N", new Force(0.123456, ForceUnit.Newton).ToString("s1"));
-            Assert.Equal("0.12 N", new Force(0.123456, ForceUnit.Newton).ToString("s2"));
-            Assert.Equal("0.123 N", new Force(0.123456, ForceUnit.Newton).ToString("s3"));
-            Assert.Equal("0.1235 N", new Force(0.123456, ForceUnit.Newton).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 N", new Force(0.123456, ForceUnit.Newton).ToString("s1", culture));
-            Assert.Equal("0.12 N", new Force(0.123456, ForceUnit.Newton).ToString("s2", culture));
-            Assert.Equal("0.123 N", new Force(0.123456, ForceUnit.Newton).ToString("s3", culture));
-            Assert.Equal("0.1235 N", new Force(0.123456, ForceUnit.Newton).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1075,7 +1152,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Force.FromNewtons(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Force), quantity.As(Force.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs
index 9969c0cb93..0ee853ef70 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs
@@ -169,6 +169,20 @@ public void Frequency_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<FrequencyUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void FrequencyInfo_CreateWithCustomUnitInfos()
+        {
+            FrequencyUnit[] expectedUnits = [FrequencyUnit.Hertz];
+
+            Frequency.FrequencyInfo quantityInfo = Frequency.FrequencyInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Frequency", quantityInfo.Name);
+            Assert.Equal(Frequency.Zero, quantityInfo.Zero);
+            Assert.Equal(Frequency.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void HertzToFrequencyUnits()
         {
@@ -275,26 +289,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Frequency.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Frequency convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Frequency quantityToConvert = quantity;
+
+                Frequency convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<FrequencyUnit> quantityToConvert = quantity;
+
+                IQuantity<FrequencyUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Frequency(value: 1, unit: Frequency.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Frequency(value: 1, unit: Frequency.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<FrequencyUnit> quantity = new Frequency(value: 1, unit: Frequency.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Frequency(value: 1, unit: Frequency.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Frequency(value: 1, unit: Frequency.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Frequency(value: 1, unit: Frequency.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<FrequencyUnit> quantity = new Frequency(value: 1, unit: Frequency.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Frequency(value: 1, unit: Frequency.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -319,7 +376,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 с⁻¹", FrequencyUnit.PerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 рад/с", FrequencyUnit.RadianPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 ТГц", FrequencyUnit.Terahertz, 4.2)]
-        public void Parse(string culture, string quantityString, FrequencyUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, FrequencyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Frequency.Parse(quantityString);
@@ -349,7 +406,7 @@ public void Parse(string culture, string quantityString, FrequencyUnit expectedU
         [InlineData("ru-RU", "4,2 с⁻¹", FrequencyUnit.PerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 рад/с", FrequencyUnit.RadianPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 ТГц", FrequencyUnit.Terahertz, 4.2)]
-        public void TryParse(string culture, string quantityString, FrequencyUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, FrequencyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Frequency.TryParse(quantityString, out Frequency parsed));
@@ -626,6 +683,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(FrequencyUnit un
                 var quantity = Frequency.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -649,43 +707,45 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(FrequencyUnit unit)
                 IQuantity<FrequencyUnit> quantityToConvert = quantity;
                 IQuantity<FrequencyUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Frequency hertz = Frequency.FromHertz(1);
-            AssertEx.EqualTolerance(1, Frequency.FromBeatsPerMinute(hertz.BeatsPerMinute).Hertz, BeatsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromCyclesPerHour(hertz.CyclesPerHour).Hertz, CyclesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromCyclesPerMinute(hertz.CyclesPerMinute).Hertz, CyclesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromGigahertz(hertz.Gigahertz).Hertz, GigahertzTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromHertz(hertz.Hertz).Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromKilohertz(hertz.Kilohertz).Hertz, KilohertzTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromMegahertz(hertz.Megahertz).Hertz, MegahertzTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromMicrohertz(hertz.Microhertz).Hertz, MicrohertzTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromMillihertz(hertz.Millihertz).Hertz, MillihertzTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromPerSecond(hertz.PerSecond).Hertz, PerSecondTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromRadiansPerSecond(hertz.RadiansPerSecond).Hertz, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Frequency.FromTerahertz(hertz.Terahertz).Hertz, TerahertzTolerance);
+            Frequency hertz = Frequency.FromHertz(3);
+            Assert.Equal(3, Frequency.FromBeatsPerMinute(hertz.BeatsPerMinute).Hertz);
+            Assert.Equal(3, Frequency.FromCyclesPerHour(hertz.CyclesPerHour).Hertz);
+            Assert.Equal(3, Frequency.FromCyclesPerMinute(hertz.CyclesPerMinute).Hertz);
+            Assert.Equal(3, Frequency.FromGigahertz(hertz.Gigahertz).Hertz);
+            Assert.Equal(3, Frequency.FromHertz(hertz.Hertz).Hertz);
+            Assert.Equal(3, Frequency.FromKilohertz(hertz.Kilohertz).Hertz);
+            Assert.Equal(3, Frequency.FromMegahertz(hertz.Megahertz).Hertz);
+            Assert.Equal(3, Frequency.FromMicrohertz(hertz.Microhertz).Hertz);
+            Assert.Equal(3, Frequency.FromMillihertz(hertz.Millihertz).Hertz);
+            Assert.Equal(3, Frequency.FromPerSecond(hertz.PerSecond).Hertz);
+            Assert.Equal(3, Frequency.FromRadiansPerSecond(hertz.RadiansPerSecond).Hertz);
+            Assert.Equal(3, Frequency.FromTerahertz(hertz.Terahertz).Hertz);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Frequency v = Frequency.FromHertz(1);
-            AssertEx.EqualTolerance(-1, -v.Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(2, (Frequency.FromHertz(3)-v).Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(2, (Frequency.FromHertz(10)/5).Hertz, HertzTolerance);
-            AssertEx.EqualTolerance(2, Frequency.FromHertz(10)/Frequency.FromHertz(5), HertzTolerance);
+            Assert.Equal(-1, -v.Hertz);
+            Assert.Equal(2, (Frequency.FromHertz(3) - v).Hertz);
+            Assert.Equal(2, (v + v).Hertz);
+            Assert.Equal(10, (v * 10).Hertz);
+            Assert.Equal(10, (10 * v).Hertz);
+            Assert.Equal(2, (Frequency.FromHertz(10) / 5).Hertz);
+            Assert.Equal(2, Frequency.FromHertz(10) / Frequency.FromHertz(5));
         }
 
         [Fact]
@@ -731,8 +791,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, FrequencyUnit.Hertz, 1, FrequencyUnit.Hertz, true)]  // Same value and unit.
         [InlineData(1, FrequencyUnit.Hertz, 2, FrequencyUnit.Hertz, false)] // Different value.
-        [InlineData(2, FrequencyUnit.Hertz, 1, FrequencyUnit.BeatPerMinute, false)] // Different value and unit.
-        [InlineData(1, FrequencyUnit.Hertz, 1, FrequencyUnit.BeatPerMinute, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, FrequencyUnit unitA, double valueB, FrequencyUnit unitB, bool expectEqual)
         {
             var a = new Frequency(valueA, unitA);
@@ -792,8 +850,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Frequency.FromHertz(firstValue);
             var otherQuantity = Frequency.FromHertz(secondValue);
             Frequency maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Frequency.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -812,7 +870,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<FrequencyUnit>();
+            var units = EnumHelper.GetValues<FrequencyUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -825,6 +883,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Frequency.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Frequency.Info.Units, Frequency.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Frequency.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -863,26 +933,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 THz", new Frequency(1, FrequencyUnit.Terahertz).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Hz", new Frequency(0.123456, FrequencyUnit.Hertz).ToString("s1"));
-            Assert.Equal("0.12 Hz", new Frequency(0.123456, FrequencyUnit.Hertz).ToString("s2"));
-            Assert.Equal("0.123 Hz", new Frequency(0.123456, FrequencyUnit.Hertz).ToString("s3"));
-            Assert.Equal("0.1235 Hz", new Frequency(0.123456, FrequencyUnit.Hertz).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Hz", new Frequency(0.123456, FrequencyUnit.Hertz).ToString("s1", culture));
-            Assert.Equal("0.12 Hz", new Frequency(0.123456, FrequencyUnit.Hertz).ToString("s2", culture));
-            Assert.Equal("0.123 Hz", new Frequency(0.123456, FrequencyUnit.Hertz).ToString("s3", culture));
-            Assert.Equal("0.1235 Hz", new Frequency(0.123456, FrequencyUnit.Hertz).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -909,7 +959,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Frequency.FromHertz(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Frequency), quantity.As(Frequency.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs
index 568dc6995a..68dcabf512 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs
@@ -137,6 +137,20 @@ public void FuelEfficiency_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<FuelEfficiencyUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void FuelEfficiencyInfo_CreateWithCustomUnitInfos()
+        {
+            FuelEfficiencyUnit[] expectedUnits = [FuelEfficiencyUnit.KilometerPerLiter];
+
+            FuelEfficiency.FuelEfficiencyInfo quantityInfo = FuelEfficiency.FuelEfficiencyInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("FuelEfficiency", quantityInfo.Name);
+            Assert.Equal(FuelEfficiency.Zero, quantityInfo.Zero);
+            Assert.Equal(FuelEfficiency.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KilometerPerLiterToFuelEfficiencyUnits()
         {
@@ -227,26 +241,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = FuelEfficiency.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            FuelEfficiency convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                FuelEfficiency quantityToConvert = quantity;
+
+                FuelEfficiency convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<FuelEfficiencyUnit> quantityToConvert = quantity;
+
+                IQuantity<FuelEfficiencyUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new FuelEfficiency(value: 1, unit: FuelEfficiency.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new FuelEfficiency(value: 1, unit: FuelEfficiency.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<FuelEfficiencyUnit> quantity = new FuelEfficiency(value: 1, unit: FuelEfficiency.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new FuelEfficiency(value: 1, unit: FuelEfficiency.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new FuelEfficiency(value: 1, unit: FuelEfficiency.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new FuelEfficiency(value: 1, unit: FuelEfficiency.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<FuelEfficiencyUnit> quantity = new FuelEfficiency(value: 1, unit: FuelEfficiency.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new FuelEfficiency(value: 1, unit: FuelEfficiency.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -254,7 +311,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 l/100km", FuelEfficiencyUnit.LiterPer100Kilometers, 4.2)]
         [InlineData("en-US", "4.2 mpg (imp.)", FuelEfficiencyUnit.MilePerUkGallon, 4.2)]
         [InlineData("en-US", "4.2 mpg (U.S.)", FuelEfficiencyUnit.MilePerUsGallon, 4.2)]
-        public void Parse(string culture, string quantityString, FuelEfficiencyUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, FuelEfficiencyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = FuelEfficiency.Parse(quantityString);
@@ -267,7 +324,7 @@ public void Parse(string culture, string quantityString, FuelEfficiencyUnit expe
         [InlineData("en-US", "4.2 l/100km", FuelEfficiencyUnit.LiterPer100Kilometers, 4.2)]
         [InlineData("en-US", "4.2 mpg (imp.)", FuelEfficiencyUnit.MilePerUkGallon, 4.2)]
         [InlineData("en-US", "4.2 mpg (U.S.)", FuelEfficiencyUnit.MilePerUsGallon, 4.2)]
-        public void TryParse(string culture, string quantityString, FuelEfficiencyUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, FuelEfficiencyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(FuelEfficiency.TryParse(quantityString, out FuelEfficiency parsed));
@@ -427,6 +484,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(FuelEfficiencyUn
                 var quantity = FuelEfficiency.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -450,35 +508,37 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(FuelEfficiencyUnit
                 IQuantity<FuelEfficiencyUnit> quantityToConvert = quantity;
                 IQuantity<FuelEfficiencyUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            FuelEfficiency kilometerperliter = FuelEfficiency.FromKilometersPerLiter(1);
-            AssertEx.EqualTolerance(1, FuelEfficiency.FromKilometersPerLiter(kilometerperliter.KilometersPerLiter).KilometersPerLiter, KilometersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, FuelEfficiency.FromLitersPer100Kilometers(kilometerperliter.LitersPer100Kilometers).KilometersPerLiter, LitersPer100KilometersTolerance);
-            AssertEx.EqualTolerance(1, FuelEfficiency.FromMilesPerUkGallon(kilometerperliter.MilesPerUkGallon).KilometersPerLiter, MilesPerUkGallonTolerance);
-            AssertEx.EqualTolerance(1, FuelEfficiency.FromMilesPerUsGallon(kilometerperliter.MilesPerUsGallon).KilometersPerLiter, MilesPerUsGallonTolerance);
+            FuelEfficiency kilometerperliter = FuelEfficiency.FromKilometersPerLiter(3);
+            Assert.Equal(3, FuelEfficiency.FromKilometersPerLiter(kilometerperliter.KilometersPerLiter).KilometersPerLiter);
+            Assert.Equal(3, FuelEfficiency.FromLitersPer100Kilometers(kilometerperliter.LitersPer100Kilometers).KilometersPerLiter);
+            Assert.Equal(3, FuelEfficiency.FromMilesPerUkGallon(kilometerperliter.MilesPerUkGallon).KilometersPerLiter);
+            Assert.Equal(3, FuelEfficiency.FromMilesPerUsGallon(kilometerperliter.MilesPerUsGallon).KilometersPerLiter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             FuelEfficiency v = FuelEfficiency.FromKilometersPerLiter(1);
-            AssertEx.EqualTolerance(-1, -v.KilometersPerLiter, KilometersPerLiterTolerance);
-            AssertEx.EqualTolerance(2, (FuelEfficiency.FromKilometersPerLiter(3)-v).KilometersPerLiter, KilometersPerLiterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KilometersPerLiter, KilometersPerLiterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KilometersPerLiter, KilometersPerLiterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KilometersPerLiter, KilometersPerLiterTolerance);
-            AssertEx.EqualTolerance(2, (FuelEfficiency.FromKilometersPerLiter(10)/5).KilometersPerLiter, KilometersPerLiterTolerance);
-            AssertEx.EqualTolerance(2, FuelEfficiency.FromKilometersPerLiter(10)/FuelEfficiency.FromKilometersPerLiter(5), KilometersPerLiterTolerance);
+            Assert.Equal(-1, -v.KilometersPerLiter);
+            Assert.Equal(2, (FuelEfficiency.FromKilometersPerLiter(3) - v).KilometersPerLiter);
+            Assert.Equal(2, (v + v).KilometersPerLiter);
+            Assert.Equal(10, (v * 10).KilometersPerLiter);
+            Assert.Equal(10, (10 * v).KilometersPerLiter);
+            Assert.Equal(2, (FuelEfficiency.FromKilometersPerLiter(10) / 5).KilometersPerLiter);
+            Assert.Equal(2, FuelEfficiency.FromKilometersPerLiter(10) / FuelEfficiency.FromKilometersPerLiter(5));
         }
 
         [Fact]
@@ -524,8 +584,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, FuelEfficiencyUnit.KilometerPerLiter, 1, FuelEfficiencyUnit.KilometerPerLiter, true)]  // Same value and unit.
         [InlineData(1, FuelEfficiencyUnit.KilometerPerLiter, 2, FuelEfficiencyUnit.KilometerPerLiter, false)] // Different value.
-        [InlineData(2, FuelEfficiencyUnit.KilometerPerLiter, 1, FuelEfficiencyUnit.LiterPer100Kilometers, false)] // Different value and unit.
-        [InlineData(1, FuelEfficiencyUnit.KilometerPerLiter, 1, FuelEfficiencyUnit.LiterPer100Kilometers, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, FuelEfficiencyUnit unitA, double valueB, FuelEfficiencyUnit unitB, bool expectEqual)
         {
             var a = new FuelEfficiency(valueA, unitA);
@@ -585,8 +643,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = FuelEfficiency.FromKilometersPerLiter(firstValue);
             var otherQuantity = FuelEfficiency.FromKilometersPerLiter(secondValue);
             FuelEfficiency maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, FuelEfficiency.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -605,7 +663,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<FuelEfficiencyUnit>();
+            var units = EnumHelper.GetValues<FuelEfficiencyUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -618,6 +676,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(FuelEfficiency.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(FuelEfficiency.Info.Units, FuelEfficiency.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, FuelEfficiency.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -640,26 +710,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 mpg (U.S.)", new FuelEfficiency(1, FuelEfficiencyUnit.MilePerUsGallon).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 km/l", new FuelEfficiency(0.123456, FuelEfficiencyUnit.KilometerPerLiter).ToString("s1"));
-            Assert.Equal("0.12 km/l", new FuelEfficiency(0.123456, FuelEfficiencyUnit.KilometerPerLiter).ToString("s2"));
-            Assert.Equal("0.123 km/l", new FuelEfficiency(0.123456, FuelEfficiencyUnit.KilometerPerLiter).ToString("s3"));
-            Assert.Equal("0.1235 km/l", new FuelEfficiency(0.123456, FuelEfficiencyUnit.KilometerPerLiter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 km/l", new FuelEfficiency(0.123456, FuelEfficiencyUnit.KilometerPerLiter).ToString("s1", culture));
-            Assert.Equal("0.12 km/l", new FuelEfficiency(0.123456, FuelEfficiencyUnit.KilometerPerLiter).ToString("s2", culture));
-            Assert.Equal("0.123 km/l", new FuelEfficiency(0.123456, FuelEfficiencyUnit.KilometerPerLiter).ToString("s3", culture));
-            Assert.Equal("0.1235 km/l", new FuelEfficiency(0.123456, FuelEfficiencyUnit.KilometerPerLiter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -686,7 +736,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = FuelEfficiency.FromKilometersPerLiter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(FuelEfficiency), quantity.As(FuelEfficiency.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs
index b2dfbfdb44..3ef39a8954 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/HeatFluxTestsBase.g.cs
@@ -46,18 +46,25 @@ public abstract partial class HeatFluxTestsBase : QuantityTestsBase
         protected abstract double BtusPerSecondSquareInchInOneWattPerSquareMeter { get; }
         protected abstract double CaloriesPerSecondSquareCentimeterInOneWattPerSquareMeter { get; }
         protected abstract double CentiwattsPerSquareMeterInOneWattPerSquareMeter { get; }
+        protected abstract double CentiwattsPerSquareMillimeterInOneWattPerSquareMeter { get; }
         protected abstract double DeciwattsPerSquareMeterInOneWattPerSquareMeter { get; }
+        protected abstract double DeciwattsPerSquareMillimeterInOneWattPerSquareMeter { get; }
         protected abstract double KilocaloriesPerHourSquareMeterInOneWattPerSquareMeter { get; }
         protected abstract double KilocaloriesPerSecondSquareCentimeterInOneWattPerSquareMeter { get; }
         protected abstract double KilowattsPerSquareMeterInOneWattPerSquareMeter { get; }
+        protected abstract double KilowattsPerSquareMillimeterInOneWattPerSquareMeter { get; }
         protected abstract double MicrowattsPerSquareMeterInOneWattPerSquareMeter { get; }
+        protected abstract double MicrowattsPerSquareMillimeterInOneWattPerSquareMeter { get; }
         protected abstract double MilliwattsPerSquareMeterInOneWattPerSquareMeter { get; }
+        protected abstract double MilliwattsPerSquareMillimeterInOneWattPerSquareMeter { get; }
         protected abstract double NanowattsPerSquareMeterInOneWattPerSquareMeter { get; }
+        protected abstract double NanowattsPerSquareMillimeterInOneWattPerSquareMeter { get; }
         protected abstract double PoundsForcePerFootSecondInOneWattPerSquareMeter { get; }
         protected abstract double PoundsPerSecondCubedInOneWattPerSquareMeter { get; }
         protected abstract double WattsPerSquareFootInOneWattPerSquareMeter { get; }
         protected abstract double WattsPerSquareInchInOneWattPerSquareMeter { get; }
         protected abstract double WattsPerSquareMeterInOneWattPerSquareMeter { get; }
+        protected abstract double WattsPerSquareMillimeterInOneWattPerSquareMeter { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double BtusPerHourSquareFootTolerance { get { return 1e-5; } }
@@ -66,18 +73,25 @@ public abstract partial class HeatFluxTestsBase : QuantityTestsBase
         protected virtual double BtusPerSecondSquareInchTolerance { get { return 1e-5; } }
         protected virtual double CaloriesPerSecondSquareCentimeterTolerance { get { return 1e-5; } }
         protected virtual double CentiwattsPerSquareMeterTolerance { get { return 1e-5; } }
+        protected virtual double CentiwattsPerSquareMillimeterTolerance { get { return 1e-5; } }
         protected virtual double DeciwattsPerSquareMeterTolerance { get { return 1e-5; } }
+        protected virtual double DeciwattsPerSquareMillimeterTolerance { get { return 1e-5; } }
         protected virtual double KilocaloriesPerHourSquareMeterTolerance { get { return 1e-5; } }
         protected virtual double KilocaloriesPerSecondSquareCentimeterTolerance { get { return 1e-5; } }
         protected virtual double KilowattsPerSquareMeterTolerance { get { return 1e-5; } }
+        protected virtual double KilowattsPerSquareMillimeterTolerance { get { return 1e-5; } }
         protected virtual double MicrowattsPerSquareMeterTolerance { get { return 1e-5; } }
+        protected virtual double MicrowattsPerSquareMillimeterTolerance { get { return 1e-5; } }
         protected virtual double MilliwattsPerSquareMeterTolerance { get { return 1e-5; } }
+        protected virtual double MilliwattsPerSquareMillimeterTolerance { get { return 1e-5; } }
         protected virtual double NanowattsPerSquareMeterTolerance { get { return 1e-5; } }
+        protected virtual double NanowattsPerSquareMillimeterTolerance { get { return 1e-5; } }
         protected virtual double PoundsForcePerFootSecondTolerance { get { return 1e-5; } }
         protected virtual double PoundsPerSecondCubedTolerance { get { return 1e-5; } }
         protected virtual double WattsPerSquareFootTolerance { get { return 1e-5; } }
         protected virtual double WattsPerSquareInchTolerance { get { return 1e-5; } }
         protected virtual double WattsPerSquareMeterTolerance { get { return 1e-5; } }
+        protected virtual double WattsPerSquareMillimeterTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(HeatFluxUnit unit)
@@ -90,18 +104,25 @@ public abstract partial class HeatFluxTestsBase : QuantityTestsBase
                 HeatFluxUnit.BtuPerSecondSquareInch => (BtusPerSecondSquareInchInOneWattPerSquareMeter, BtusPerSecondSquareInchTolerance),
                 HeatFluxUnit.CaloriePerSecondSquareCentimeter => (CaloriesPerSecondSquareCentimeterInOneWattPerSquareMeter, CaloriesPerSecondSquareCentimeterTolerance),
                 HeatFluxUnit.CentiwattPerSquareMeter => (CentiwattsPerSquareMeterInOneWattPerSquareMeter, CentiwattsPerSquareMeterTolerance),
+                HeatFluxUnit.CentiwattPerSquareMillimeter => (CentiwattsPerSquareMillimeterInOneWattPerSquareMeter, CentiwattsPerSquareMillimeterTolerance),
                 HeatFluxUnit.DeciwattPerSquareMeter => (DeciwattsPerSquareMeterInOneWattPerSquareMeter, DeciwattsPerSquareMeterTolerance),
+                HeatFluxUnit.DeciwattPerSquareMillimeter => (DeciwattsPerSquareMillimeterInOneWattPerSquareMeter, DeciwattsPerSquareMillimeterTolerance),
                 HeatFluxUnit.KilocaloriePerHourSquareMeter => (KilocaloriesPerHourSquareMeterInOneWattPerSquareMeter, KilocaloriesPerHourSquareMeterTolerance),
                 HeatFluxUnit.KilocaloriePerSecondSquareCentimeter => (KilocaloriesPerSecondSquareCentimeterInOneWattPerSquareMeter, KilocaloriesPerSecondSquareCentimeterTolerance),
                 HeatFluxUnit.KilowattPerSquareMeter => (KilowattsPerSquareMeterInOneWattPerSquareMeter, KilowattsPerSquareMeterTolerance),
+                HeatFluxUnit.KilowattPerSquareMillimeter => (KilowattsPerSquareMillimeterInOneWattPerSquareMeter, KilowattsPerSquareMillimeterTolerance),
                 HeatFluxUnit.MicrowattPerSquareMeter => (MicrowattsPerSquareMeterInOneWattPerSquareMeter, MicrowattsPerSquareMeterTolerance),
+                HeatFluxUnit.MicrowattPerSquareMillimeter => (MicrowattsPerSquareMillimeterInOneWattPerSquareMeter, MicrowattsPerSquareMillimeterTolerance),
                 HeatFluxUnit.MilliwattPerSquareMeter => (MilliwattsPerSquareMeterInOneWattPerSquareMeter, MilliwattsPerSquareMeterTolerance),
+                HeatFluxUnit.MilliwattPerSquareMillimeter => (MilliwattsPerSquareMillimeterInOneWattPerSquareMeter, MilliwattsPerSquareMillimeterTolerance),
                 HeatFluxUnit.NanowattPerSquareMeter => (NanowattsPerSquareMeterInOneWattPerSquareMeter, NanowattsPerSquareMeterTolerance),
+                HeatFluxUnit.NanowattPerSquareMillimeter => (NanowattsPerSquareMillimeterInOneWattPerSquareMeter, NanowattsPerSquareMillimeterTolerance),
                 HeatFluxUnit.PoundForcePerFootSecond => (PoundsForcePerFootSecondInOneWattPerSquareMeter, PoundsForcePerFootSecondTolerance),
                 HeatFluxUnit.PoundPerSecondCubed => (PoundsPerSecondCubedInOneWattPerSquareMeter, PoundsPerSecondCubedTolerance),
                 HeatFluxUnit.WattPerSquareFoot => (WattsPerSquareFootInOneWattPerSquareMeter, WattsPerSquareFootTolerance),
                 HeatFluxUnit.WattPerSquareInch => (WattsPerSquareInchInOneWattPerSquareMeter, WattsPerSquareInchTolerance),
                 HeatFluxUnit.WattPerSquareMeter => (WattsPerSquareMeterInOneWattPerSquareMeter, WattsPerSquareMeterTolerance),
+                HeatFluxUnit.WattPerSquareMillimeter => (WattsPerSquareMillimeterInOneWattPerSquareMeter, WattsPerSquareMillimeterTolerance),
                 _ => throw new NotSupportedException()
             };
         }
@@ -114,18 +135,25 @@ public abstract partial class HeatFluxTestsBase : QuantityTestsBase
             new object[] { HeatFluxUnit.BtuPerSecondSquareInch },
             new object[] { HeatFluxUnit.CaloriePerSecondSquareCentimeter },
             new object[] { HeatFluxUnit.CentiwattPerSquareMeter },
+            new object[] { HeatFluxUnit.CentiwattPerSquareMillimeter },
             new object[] { HeatFluxUnit.DeciwattPerSquareMeter },
+            new object[] { HeatFluxUnit.DeciwattPerSquareMillimeter },
             new object[] { HeatFluxUnit.KilocaloriePerHourSquareMeter },
             new object[] { HeatFluxUnit.KilocaloriePerSecondSquareCentimeter },
             new object[] { HeatFluxUnit.KilowattPerSquareMeter },
+            new object[] { HeatFluxUnit.KilowattPerSquareMillimeter },
             new object[] { HeatFluxUnit.MicrowattPerSquareMeter },
+            new object[] { HeatFluxUnit.MicrowattPerSquareMillimeter },
             new object[] { HeatFluxUnit.MilliwattPerSquareMeter },
+            new object[] { HeatFluxUnit.MilliwattPerSquareMillimeter },
             new object[] { HeatFluxUnit.NanowattPerSquareMeter },
+            new object[] { HeatFluxUnit.NanowattPerSquareMillimeter },
             new object[] { HeatFluxUnit.PoundForcePerFootSecond },
             new object[] { HeatFluxUnit.PoundPerSecondCubed },
             new object[] { HeatFluxUnit.WattPerSquareFoot },
             new object[] { HeatFluxUnit.WattPerSquareInch },
             new object[] { HeatFluxUnit.WattPerSquareMeter },
+            new object[] { HeatFluxUnit.WattPerSquareMillimeter },
         };
 
         [Fact]
@@ -193,6 +221,20 @@ public void HeatFlux_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<HeatFluxUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void HeatFluxInfo_CreateWithCustomUnitInfos()
+        {
+            HeatFluxUnit[] expectedUnits = [HeatFluxUnit.WattPerSquareMeter];
+
+            HeatFlux.HeatFluxInfo quantityInfo = HeatFlux.HeatFluxInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("HeatFlux", quantityInfo.Name);
+            Assert.Equal(HeatFlux.Zero, quantityInfo.Zero);
+            Assert.Equal(HeatFlux.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void WattPerSquareMeterToHeatFluxUnits()
         {
@@ -203,18 +245,25 @@ public void WattPerSquareMeterToHeatFluxUnits()
             AssertEx.EqualTolerance(BtusPerSecondSquareInchInOneWattPerSquareMeter, wattpersquaremeter.BtusPerSecondSquareInch, BtusPerSecondSquareInchTolerance);
             AssertEx.EqualTolerance(CaloriesPerSecondSquareCentimeterInOneWattPerSquareMeter, wattpersquaremeter.CaloriesPerSecondSquareCentimeter, CaloriesPerSecondSquareCentimeterTolerance);
             AssertEx.EqualTolerance(CentiwattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.CentiwattsPerSquareMeter, CentiwattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(CentiwattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.CentiwattsPerSquareMillimeter, CentiwattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(DeciwattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.DeciwattsPerSquareMeter, DeciwattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(DeciwattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.DeciwattsPerSquareMillimeter, DeciwattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(KilocaloriesPerHourSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.KilocaloriesPerHourSquareMeter, KilocaloriesPerHourSquareMeterTolerance);
             AssertEx.EqualTolerance(KilocaloriesPerSecondSquareCentimeterInOneWattPerSquareMeter, wattpersquaremeter.KilocaloriesPerSecondSquareCentimeter, KilocaloriesPerSecondSquareCentimeterTolerance);
             AssertEx.EqualTolerance(KilowattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.KilowattsPerSquareMeter, KilowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(KilowattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.KilowattsPerSquareMillimeter, KilowattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(MicrowattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.MicrowattsPerSquareMeter, MicrowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(MicrowattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.MicrowattsPerSquareMillimeter, MicrowattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(MilliwattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.MilliwattsPerSquareMeter, MilliwattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(MilliwattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.MilliwattsPerSquareMillimeter, MilliwattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(NanowattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.NanowattsPerSquareMeter, NanowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(NanowattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.NanowattsPerSquareMillimeter, NanowattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(PoundsForcePerFootSecondInOneWattPerSquareMeter, wattpersquaremeter.PoundsForcePerFootSecond, PoundsForcePerFootSecondTolerance);
             AssertEx.EqualTolerance(PoundsPerSecondCubedInOneWattPerSquareMeter, wattpersquaremeter.PoundsPerSecondCubed, PoundsPerSecondCubedTolerance);
             AssertEx.EqualTolerance(WattsPerSquareFootInOneWattPerSquareMeter, wattpersquaremeter.WattsPerSquareFoot, WattsPerSquareFootTolerance);
             AssertEx.EqualTolerance(WattsPerSquareInchInOneWattPerSquareMeter, wattpersquaremeter.WattsPerSquareInch, WattsPerSquareInchTolerance);
             AssertEx.EqualTolerance(WattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.WattsPerSquareMeter, WattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(WattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.WattsPerSquareMillimeter, WattsPerSquareMillimeterTolerance);
         }
 
         [Fact]
@@ -256,18 +305,25 @@ public void As()
             AssertEx.EqualTolerance(BtusPerSecondSquareInchInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.BtuPerSecondSquareInch), BtusPerSecondSquareInchTolerance);
             AssertEx.EqualTolerance(CaloriesPerSecondSquareCentimeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.CaloriePerSecondSquareCentimeter), CaloriesPerSecondSquareCentimeterTolerance);
             AssertEx.EqualTolerance(CentiwattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.CentiwattPerSquareMeter), CentiwattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(CentiwattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.CentiwattPerSquareMillimeter), CentiwattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(DeciwattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.DeciwattPerSquareMeter), DeciwattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(DeciwattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.DeciwattPerSquareMillimeter), DeciwattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(KilocaloriesPerHourSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.KilocaloriePerHourSquareMeter), KilocaloriesPerHourSquareMeterTolerance);
             AssertEx.EqualTolerance(KilocaloriesPerSecondSquareCentimeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter), KilocaloriesPerSecondSquareCentimeterTolerance);
             AssertEx.EqualTolerance(KilowattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.KilowattPerSquareMeter), KilowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(KilowattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.KilowattPerSquareMillimeter), KilowattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(MicrowattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.MicrowattPerSquareMeter), MicrowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(MicrowattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.MicrowattPerSquareMillimeter), MicrowattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(MilliwattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.MilliwattPerSquareMeter), MilliwattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(MilliwattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.MilliwattPerSquareMillimeter), MilliwattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(NanowattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.NanowattPerSquareMeter), NanowattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(NanowattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.NanowattPerSquareMillimeter), NanowattsPerSquareMillimeterTolerance);
             AssertEx.EqualTolerance(PoundsForcePerFootSecondInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.PoundForcePerFootSecond), PoundsForcePerFootSecondTolerance);
             AssertEx.EqualTolerance(PoundsPerSecondCubedInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.PoundPerSecondCubed), PoundsPerSecondCubedTolerance);
             AssertEx.EqualTolerance(WattsPerSquareFootInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.WattPerSquareFoot), WattsPerSquareFootTolerance);
             AssertEx.EqualTolerance(WattsPerSquareInchInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.WattPerSquareInch), WattsPerSquareInchTolerance);
             AssertEx.EqualTolerance(WattsPerSquareMeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.WattPerSquareMeter), WattsPerSquareMeterTolerance);
+            AssertEx.EqualTolerance(WattsPerSquareMillimeterInOneWattPerSquareMeter, wattpersquaremeter.As(HeatFluxUnit.WattPerSquareMillimeter), WattsPerSquareMillimeterTolerance);
         }
 
         [Fact]
@@ -311,26 +367,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = HeatFlux.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            HeatFlux convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                HeatFlux quantityToConvert = quantity;
+
+                HeatFlux convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<HeatFluxUnit> quantityToConvert = quantity;
+
+                IQuantity<HeatFluxUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new HeatFlux(value: 1, unit: HeatFlux.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new HeatFlux(value: 1, unit: HeatFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<HeatFluxUnit> quantity = new HeatFlux(value: 1, unit: HeatFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new HeatFlux(value: 1, unit: HeatFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new HeatFlux(value: 1, unit: HeatFlux.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new HeatFlux(value: 1, unit: HeatFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<HeatFluxUnit> quantity = new HeatFlux(value: 1, unit: HeatFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new HeatFlux(value: 1, unit: HeatFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -340,20 +439,27 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 BTU/(s·in²)", HeatFluxUnit.BtuPerSecondSquareInch, 4.2)]
         [InlineData("en-US", "4.2 cal/(s·cm²)", HeatFluxUnit.CaloriePerSecondSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 cW/m²", HeatFluxUnit.CentiwattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 cW/mm²", HeatFluxUnit.CentiwattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 dW/m²", HeatFluxUnit.DeciwattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 dW/mm²", HeatFluxUnit.DeciwattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 kcal/(h·m²)", HeatFluxUnit.KilocaloriePerHourSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 kcal/(s·cm²)", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 kW/m²", HeatFluxUnit.KilowattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 kW/mm²", HeatFluxUnit.KilowattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 µW/m²", HeatFluxUnit.MicrowattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 µW/mm²", HeatFluxUnit.MicrowattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 mW/m²", HeatFluxUnit.MilliwattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 mW/mm²", HeatFluxUnit.MilliwattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 nW/m²", HeatFluxUnit.NanowattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 nW/mm²", HeatFluxUnit.NanowattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 lbf/(ft·s)", HeatFluxUnit.PoundForcePerFootSecond, 4.2)]
         [InlineData("en-US", "4.2 lb/s³", HeatFluxUnit.PoundPerSecondCubed, 4.2)]
         [InlineData("en-US", "4.2 lbm/s³", HeatFluxUnit.PoundPerSecondCubed, 4.2)]
         [InlineData("en-US", "4.2 W/ft²", HeatFluxUnit.WattPerSquareFoot, 4.2)]
         [InlineData("en-US", "4.2 W/in²", HeatFluxUnit.WattPerSquareInch, 4.2)]
         [InlineData("en-US", "4.2 W/m²", HeatFluxUnit.WattPerSquareMeter, 4.2)]
-        public void Parse(string culture, string quantityString, HeatFluxUnit expectedUnit, double expectedValue)
+        [InlineData("en-US", "4.2 W/mm²", HeatFluxUnit.WattPerSquareMillimeter, 4.2)]
+        public void Parse(string culture, string quantityString, HeatFluxUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = HeatFlux.Parse(quantityString);
@@ -368,20 +474,27 @@ public void Parse(string culture, string quantityString, HeatFluxUnit expectedUn
         [InlineData("en-US", "4.2 BTU/(s·in²)", HeatFluxUnit.BtuPerSecondSquareInch, 4.2)]
         [InlineData("en-US", "4.2 cal/(s·cm²)", HeatFluxUnit.CaloriePerSecondSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 cW/m²", HeatFluxUnit.CentiwattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 cW/mm²", HeatFluxUnit.CentiwattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 dW/m²", HeatFluxUnit.DeciwattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 dW/mm²", HeatFluxUnit.DeciwattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 kcal/(h·m²)", HeatFluxUnit.KilocaloriePerHourSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 kcal/(s·cm²)", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 kW/m²", HeatFluxUnit.KilowattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 kW/mm²", HeatFluxUnit.KilowattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 µW/m²", HeatFluxUnit.MicrowattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 µW/mm²", HeatFluxUnit.MicrowattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 mW/m²", HeatFluxUnit.MilliwattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 mW/mm²", HeatFluxUnit.MilliwattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 nW/m²", HeatFluxUnit.NanowattPerSquareMeter, 4.2)]
+        [InlineData("en-US", "4.2 nW/mm²", HeatFluxUnit.NanowattPerSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 lbf/(ft·s)", HeatFluxUnit.PoundForcePerFootSecond, 4.2)]
         [InlineData("en-US", "4.2 lb/s³", HeatFluxUnit.PoundPerSecondCubed, 4.2)]
         [InlineData("en-US", "4.2 lbm/s³", HeatFluxUnit.PoundPerSecondCubed, 4.2)]
         [InlineData("en-US", "4.2 W/ft²", HeatFluxUnit.WattPerSquareFoot, 4.2)]
         [InlineData("en-US", "4.2 W/in²", HeatFluxUnit.WattPerSquareInch, 4.2)]
         [InlineData("en-US", "4.2 W/m²", HeatFluxUnit.WattPerSquareMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, HeatFluxUnit expectedUnit, double expectedValue)
+        [InlineData("en-US", "4.2 W/mm²", HeatFluxUnit.WattPerSquareMillimeter, 4.2)]
+        public void TryParse(string culture, string quantityString, HeatFluxUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(HeatFlux.TryParse(quantityString, out HeatFlux parsed));
@@ -396,19 +509,26 @@ public void TryParse(string culture, string quantityString, HeatFluxUnit expecte
         [InlineData("BTU/(s·in²)", HeatFluxUnit.BtuPerSecondSquareInch)]
         [InlineData("cal/(s·cm²)", HeatFluxUnit.CaloriePerSecondSquareCentimeter)]
         [InlineData("cW/m²", HeatFluxUnit.CentiwattPerSquareMeter)]
+        [InlineData("cW/mm²", HeatFluxUnit.CentiwattPerSquareMillimeter)]
         [InlineData("dW/m²", HeatFluxUnit.DeciwattPerSquareMeter)]
+        [InlineData("dW/mm²", HeatFluxUnit.DeciwattPerSquareMillimeter)]
         [InlineData("kcal/(h·m²)", HeatFluxUnit.KilocaloriePerHourSquareMeter)]
         [InlineData("kcal/(s·cm²)", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)]
         [InlineData("kW/m²", HeatFluxUnit.KilowattPerSquareMeter)]
+        [InlineData("kW/mm²", HeatFluxUnit.KilowattPerSquareMillimeter)]
         [InlineData("µW/m²", HeatFluxUnit.MicrowattPerSquareMeter)]
+        [InlineData("µW/mm²", HeatFluxUnit.MicrowattPerSquareMillimeter)]
         [InlineData("mW/m²", HeatFluxUnit.MilliwattPerSquareMeter)]
+        [InlineData("mW/mm²", HeatFluxUnit.MilliwattPerSquareMillimeter)]
         [InlineData("nW/m²", HeatFluxUnit.NanowattPerSquareMeter)]
+        [InlineData("nW/mm²", HeatFluxUnit.NanowattPerSquareMillimeter)]
         [InlineData("lbf/(ft·s)", HeatFluxUnit.PoundForcePerFootSecond)]
         [InlineData("lb/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("lbm/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("W/ft²", HeatFluxUnit.WattPerSquareFoot)]
         [InlineData("W/in²", HeatFluxUnit.WattPerSquareInch)]
         [InlineData("W/m²", HeatFluxUnit.WattPerSquareMeter)]
+        [InlineData("W/mm²", HeatFluxUnit.WattPerSquareMillimeter)]
         public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, HeatFluxUnit expectedUnit)
         {
             // Fallback culture "en-US" is always localized
@@ -424,19 +544,26 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, HeatFluxU
         [InlineData("BTU/(s·in²)", HeatFluxUnit.BtuPerSecondSquareInch)]
         [InlineData("cal/(s·cm²)", HeatFluxUnit.CaloriePerSecondSquareCentimeter)]
         [InlineData("cW/m²", HeatFluxUnit.CentiwattPerSquareMeter)]
+        [InlineData("cW/mm²", HeatFluxUnit.CentiwattPerSquareMillimeter)]
         [InlineData("dW/m²", HeatFluxUnit.DeciwattPerSquareMeter)]
+        [InlineData("dW/mm²", HeatFluxUnit.DeciwattPerSquareMillimeter)]
         [InlineData("kcal/(h·m²)", HeatFluxUnit.KilocaloriePerHourSquareMeter)]
         [InlineData("kcal/(s·cm²)", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)]
         [InlineData("kW/m²", HeatFluxUnit.KilowattPerSquareMeter)]
+        [InlineData("kW/mm²", HeatFluxUnit.KilowattPerSquareMillimeter)]
         [InlineData("µW/m²", HeatFluxUnit.MicrowattPerSquareMeter)]
+        [InlineData("µW/mm²", HeatFluxUnit.MicrowattPerSquareMillimeter)]
         [InlineData("mW/m²", HeatFluxUnit.MilliwattPerSquareMeter)]
+        [InlineData("mW/mm²", HeatFluxUnit.MilliwattPerSquareMillimeter)]
         [InlineData("nW/m²", HeatFluxUnit.NanowattPerSquareMeter)]
+        [InlineData("nW/mm²", HeatFluxUnit.NanowattPerSquareMillimeter)]
         [InlineData("lbf/(ft·s)", HeatFluxUnit.PoundForcePerFootSecond)]
         [InlineData("lb/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("lbm/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("W/ft²", HeatFluxUnit.WattPerSquareFoot)]
         [InlineData("W/in²", HeatFluxUnit.WattPerSquareInch)]
         [InlineData("W/m²", HeatFluxUnit.WattPerSquareMeter)]
+        [InlineData("W/mm²", HeatFluxUnit.WattPerSquareMillimeter)]
         public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, HeatFluxUnit expectedUnit)
         {
             // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing.
@@ -452,19 +579,26 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "BTU/(s·in²)", HeatFluxUnit.BtuPerSecondSquareInch)]
         [InlineData("en-US", "cal/(s·cm²)", HeatFluxUnit.CaloriePerSecondSquareCentimeter)]
         [InlineData("en-US", "cW/m²", HeatFluxUnit.CentiwattPerSquareMeter)]
+        [InlineData("en-US", "cW/mm²", HeatFluxUnit.CentiwattPerSquareMillimeter)]
         [InlineData("en-US", "dW/m²", HeatFluxUnit.DeciwattPerSquareMeter)]
+        [InlineData("en-US", "dW/mm²", HeatFluxUnit.DeciwattPerSquareMillimeter)]
         [InlineData("en-US", "kcal/(h·m²)", HeatFluxUnit.KilocaloriePerHourSquareMeter)]
         [InlineData("en-US", "kcal/(s·cm²)", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)]
         [InlineData("en-US", "kW/m²", HeatFluxUnit.KilowattPerSquareMeter)]
+        [InlineData("en-US", "kW/mm²", HeatFluxUnit.KilowattPerSquareMillimeter)]
         [InlineData("en-US", "µW/m²", HeatFluxUnit.MicrowattPerSquareMeter)]
+        [InlineData("en-US", "µW/mm²", HeatFluxUnit.MicrowattPerSquareMillimeter)]
         [InlineData("en-US", "mW/m²", HeatFluxUnit.MilliwattPerSquareMeter)]
+        [InlineData("en-US", "mW/mm²", HeatFluxUnit.MilliwattPerSquareMillimeter)]
         [InlineData("en-US", "nW/m²", HeatFluxUnit.NanowattPerSquareMeter)]
+        [InlineData("en-US", "nW/mm²", HeatFluxUnit.NanowattPerSquareMillimeter)]
         [InlineData("en-US", "lbf/(ft·s)", HeatFluxUnit.PoundForcePerFootSecond)]
         [InlineData("en-US", "lb/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("en-US", "lbm/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("en-US", "W/ft²", HeatFluxUnit.WattPerSquareFoot)]
         [InlineData("en-US", "W/in²", HeatFluxUnit.WattPerSquareInch)]
         [InlineData("en-US", "W/m²", HeatFluxUnit.WattPerSquareMeter)]
+        [InlineData("en-US", "W/mm²", HeatFluxUnit.WattPerSquareMillimeter)]
         public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, HeatFluxUnit expectedUnit)
         {
             using var _ = new CultureScope(culture);
@@ -479,19 +613,26 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, He
         [InlineData("en-US", "BTU/(s·in²)", HeatFluxUnit.BtuPerSecondSquareInch)]
         [InlineData("en-US", "cal/(s·cm²)", HeatFluxUnit.CaloriePerSecondSquareCentimeter)]
         [InlineData("en-US", "cW/m²", HeatFluxUnit.CentiwattPerSquareMeter)]
+        [InlineData("en-US", "cW/mm²", HeatFluxUnit.CentiwattPerSquareMillimeter)]
         [InlineData("en-US", "dW/m²", HeatFluxUnit.DeciwattPerSquareMeter)]
+        [InlineData("en-US", "dW/mm²", HeatFluxUnit.DeciwattPerSquareMillimeter)]
         [InlineData("en-US", "kcal/(h·m²)", HeatFluxUnit.KilocaloriePerHourSquareMeter)]
         [InlineData("en-US", "kcal/(s·cm²)", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)]
         [InlineData("en-US", "kW/m²", HeatFluxUnit.KilowattPerSquareMeter)]
+        [InlineData("en-US", "kW/mm²", HeatFluxUnit.KilowattPerSquareMillimeter)]
         [InlineData("en-US", "µW/m²", HeatFluxUnit.MicrowattPerSquareMeter)]
+        [InlineData("en-US", "µW/mm²", HeatFluxUnit.MicrowattPerSquareMillimeter)]
         [InlineData("en-US", "mW/m²", HeatFluxUnit.MilliwattPerSquareMeter)]
+        [InlineData("en-US", "mW/mm²", HeatFluxUnit.MilliwattPerSquareMillimeter)]
         [InlineData("en-US", "nW/m²", HeatFluxUnit.NanowattPerSquareMeter)]
+        [InlineData("en-US", "nW/mm²", HeatFluxUnit.NanowattPerSquareMillimeter)]
         [InlineData("en-US", "lbf/(ft·s)", HeatFluxUnit.PoundForcePerFootSecond)]
         [InlineData("en-US", "lb/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("en-US", "lbm/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("en-US", "W/ft²", HeatFluxUnit.WattPerSquareFoot)]
         [InlineData("en-US", "W/in²", HeatFluxUnit.WattPerSquareInch)]
         [InlineData("en-US", "W/m²", HeatFluxUnit.WattPerSquareMeter)]
+        [InlineData("en-US", "W/mm²", HeatFluxUnit.WattPerSquareMillimeter)]
         public void ParseUnit_WithCulture(string culture, string abbreviation, HeatFluxUnit expectedUnit)
         {
             HeatFluxUnit parsedUnit = HeatFlux.ParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture));
@@ -505,19 +646,26 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, HeatFluxU
         [InlineData("BTU/(s·in²)", HeatFluxUnit.BtuPerSecondSquareInch)]
         [InlineData("cal/(s·cm²)", HeatFluxUnit.CaloriePerSecondSquareCentimeter)]
         [InlineData("cW/m²", HeatFluxUnit.CentiwattPerSquareMeter)]
+        [InlineData("cW/mm²", HeatFluxUnit.CentiwattPerSquareMillimeter)]
         [InlineData("dW/m²", HeatFluxUnit.DeciwattPerSquareMeter)]
+        [InlineData("dW/mm²", HeatFluxUnit.DeciwattPerSquareMillimeter)]
         [InlineData("kcal/(h·m²)", HeatFluxUnit.KilocaloriePerHourSquareMeter)]
         [InlineData("kcal/(s·cm²)", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)]
         [InlineData("kW/m²", HeatFluxUnit.KilowattPerSquareMeter)]
+        [InlineData("kW/mm²", HeatFluxUnit.KilowattPerSquareMillimeter)]
         [InlineData("µW/m²", HeatFluxUnit.MicrowattPerSquareMeter)]
+        [InlineData("µW/mm²", HeatFluxUnit.MicrowattPerSquareMillimeter)]
         [InlineData("mW/m²", HeatFluxUnit.MilliwattPerSquareMeter)]
+        [InlineData("mW/mm²", HeatFluxUnit.MilliwattPerSquareMillimeter)]
         [InlineData("nW/m²", HeatFluxUnit.NanowattPerSquareMeter)]
+        [InlineData("nW/mm²", HeatFluxUnit.NanowattPerSquareMillimeter)]
         [InlineData("lbf/(ft·s)", HeatFluxUnit.PoundForcePerFootSecond)]
         [InlineData("lb/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("lbm/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("W/ft²", HeatFluxUnit.WattPerSquareFoot)]
         [InlineData("W/in²", HeatFluxUnit.WattPerSquareInch)]
         [InlineData("W/m²", HeatFluxUnit.WattPerSquareMeter)]
+        [InlineData("W/mm²", HeatFluxUnit.WattPerSquareMillimeter)]
         public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, HeatFluxUnit expectedUnit)
         {
             // Fallback culture "en-US" is always localized
@@ -533,19 +681,26 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, HeatFl
         [InlineData("BTU/(s·in²)", HeatFluxUnit.BtuPerSecondSquareInch)]
         [InlineData("cal/(s·cm²)", HeatFluxUnit.CaloriePerSecondSquareCentimeter)]
         [InlineData("cW/m²", HeatFluxUnit.CentiwattPerSquareMeter)]
+        [InlineData("cW/mm²", HeatFluxUnit.CentiwattPerSquareMillimeter)]
         [InlineData("dW/m²", HeatFluxUnit.DeciwattPerSquareMeter)]
+        [InlineData("dW/mm²", HeatFluxUnit.DeciwattPerSquareMillimeter)]
         [InlineData("kcal/(h·m²)", HeatFluxUnit.KilocaloriePerHourSquareMeter)]
         [InlineData("kcal/(s·cm²)", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)]
         [InlineData("kW/m²", HeatFluxUnit.KilowattPerSquareMeter)]
+        [InlineData("kW/mm²", HeatFluxUnit.KilowattPerSquareMillimeter)]
         [InlineData("µW/m²", HeatFluxUnit.MicrowattPerSquareMeter)]
+        [InlineData("µW/mm²", HeatFluxUnit.MicrowattPerSquareMillimeter)]
         [InlineData("mW/m²", HeatFluxUnit.MilliwattPerSquareMeter)]
+        [InlineData("mW/mm²", HeatFluxUnit.MilliwattPerSquareMillimeter)]
         [InlineData("nW/m²", HeatFluxUnit.NanowattPerSquareMeter)]
+        [InlineData("nW/mm²", HeatFluxUnit.NanowattPerSquareMillimeter)]
         [InlineData("lbf/(ft·s)", HeatFluxUnit.PoundForcePerFootSecond)]
         [InlineData("lb/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("lbm/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("W/ft²", HeatFluxUnit.WattPerSquareFoot)]
         [InlineData("W/in²", HeatFluxUnit.WattPerSquareInch)]
         [InlineData("W/m²", HeatFluxUnit.WattPerSquareMeter)]
+        [InlineData("W/mm²", HeatFluxUnit.WattPerSquareMillimeter)]
         public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, HeatFluxUnit expectedUnit)
         {
             // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing.
@@ -561,19 +716,26 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "BTU/(s·in²)", HeatFluxUnit.BtuPerSecondSquareInch)]
         [InlineData("en-US", "cal/(s·cm²)", HeatFluxUnit.CaloriePerSecondSquareCentimeter)]
         [InlineData("en-US", "cW/m²", HeatFluxUnit.CentiwattPerSquareMeter)]
+        [InlineData("en-US", "cW/mm²", HeatFluxUnit.CentiwattPerSquareMillimeter)]
         [InlineData("en-US", "dW/m²", HeatFluxUnit.DeciwattPerSquareMeter)]
+        [InlineData("en-US", "dW/mm²", HeatFluxUnit.DeciwattPerSquareMillimeter)]
         [InlineData("en-US", "kcal/(h·m²)", HeatFluxUnit.KilocaloriePerHourSquareMeter)]
         [InlineData("en-US", "kcal/(s·cm²)", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)]
         [InlineData("en-US", "kW/m²", HeatFluxUnit.KilowattPerSquareMeter)]
+        [InlineData("en-US", "kW/mm²", HeatFluxUnit.KilowattPerSquareMillimeter)]
         [InlineData("en-US", "µW/m²", HeatFluxUnit.MicrowattPerSquareMeter)]
+        [InlineData("en-US", "µW/mm²", HeatFluxUnit.MicrowattPerSquareMillimeter)]
         [InlineData("en-US", "mW/m²", HeatFluxUnit.MilliwattPerSquareMeter)]
+        [InlineData("en-US", "mW/mm²", HeatFluxUnit.MilliwattPerSquareMillimeter)]
         [InlineData("en-US", "nW/m²", HeatFluxUnit.NanowattPerSquareMeter)]
+        [InlineData("en-US", "nW/mm²", HeatFluxUnit.NanowattPerSquareMillimeter)]
         [InlineData("en-US", "lbf/(ft·s)", HeatFluxUnit.PoundForcePerFootSecond)]
         [InlineData("en-US", "lb/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("en-US", "lbm/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("en-US", "W/ft²", HeatFluxUnit.WattPerSquareFoot)]
         [InlineData("en-US", "W/in²", HeatFluxUnit.WattPerSquareInch)]
         [InlineData("en-US", "W/m²", HeatFluxUnit.WattPerSquareMeter)]
+        [InlineData("en-US", "W/mm²", HeatFluxUnit.WattPerSquareMillimeter)]
         public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, HeatFluxUnit expectedUnit)
         {
             using var _ = new CultureScope(culture);
@@ -588,19 +750,26 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "BTU/(s·in²)", HeatFluxUnit.BtuPerSecondSquareInch)]
         [InlineData("en-US", "cal/(s·cm²)", HeatFluxUnit.CaloriePerSecondSquareCentimeter)]
         [InlineData("en-US", "cW/m²", HeatFluxUnit.CentiwattPerSquareMeter)]
+        [InlineData("en-US", "cW/mm²", HeatFluxUnit.CentiwattPerSquareMillimeter)]
         [InlineData("en-US", "dW/m²", HeatFluxUnit.DeciwattPerSquareMeter)]
+        [InlineData("en-US", "dW/mm²", HeatFluxUnit.DeciwattPerSquareMillimeter)]
         [InlineData("en-US", "kcal/(h·m²)", HeatFluxUnit.KilocaloriePerHourSquareMeter)]
         [InlineData("en-US", "kcal/(s·cm²)", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter)]
         [InlineData("en-US", "kW/m²", HeatFluxUnit.KilowattPerSquareMeter)]
+        [InlineData("en-US", "kW/mm²", HeatFluxUnit.KilowattPerSquareMillimeter)]
         [InlineData("en-US", "µW/m²", HeatFluxUnit.MicrowattPerSquareMeter)]
+        [InlineData("en-US", "µW/mm²", HeatFluxUnit.MicrowattPerSquareMillimeter)]
         [InlineData("en-US", "mW/m²", HeatFluxUnit.MilliwattPerSquareMeter)]
+        [InlineData("en-US", "mW/mm²", HeatFluxUnit.MilliwattPerSquareMillimeter)]
         [InlineData("en-US", "nW/m²", HeatFluxUnit.NanowattPerSquareMeter)]
+        [InlineData("en-US", "nW/mm²", HeatFluxUnit.NanowattPerSquareMillimeter)]
         [InlineData("en-US", "lbf/(ft·s)", HeatFluxUnit.PoundForcePerFootSecond)]
         [InlineData("en-US", "lb/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("en-US", "lbm/s³", HeatFluxUnit.PoundPerSecondCubed)]
         [InlineData("en-US", "W/ft²", HeatFluxUnit.WattPerSquareFoot)]
         [InlineData("en-US", "W/in²", HeatFluxUnit.WattPerSquareInch)]
         [InlineData("en-US", "W/m²", HeatFluxUnit.WattPerSquareMeter)]
+        [InlineData("en-US", "W/mm²", HeatFluxUnit.WattPerSquareMillimeter)]
         public void TryParseUnit_WithCulture(string culture, string abbreviation, HeatFluxUnit expectedUnit)
         {
             Assert.True(HeatFlux.TryParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture), out HeatFluxUnit parsedUnit));
@@ -614,18 +783,25 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, HeatFl
         [InlineData("en-US", HeatFluxUnit.BtuPerSecondSquareInch, "BTU/(s·in²)")]
         [InlineData("en-US", HeatFluxUnit.CaloriePerSecondSquareCentimeter, "cal/(s·cm²)")]
         [InlineData("en-US", HeatFluxUnit.CentiwattPerSquareMeter, "cW/m²")]
+        [InlineData("en-US", HeatFluxUnit.CentiwattPerSquareMillimeter, "cW/mm²")]
         [InlineData("en-US", HeatFluxUnit.DeciwattPerSquareMeter, "dW/m²")]
+        [InlineData("en-US", HeatFluxUnit.DeciwattPerSquareMillimeter, "dW/mm²")]
         [InlineData("en-US", HeatFluxUnit.KilocaloriePerHourSquareMeter, "kcal/(h·m²)")]
         [InlineData("en-US", HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, "kcal/(s·cm²)")]
         [InlineData("en-US", HeatFluxUnit.KilowattPerSquareMeter, "kW/m²")]
+        [InlineData("en-US", HeatFluxUnit.KilowattPerSquareMillimeter, "kW/mm²")]
         [InlineData("en-US", HeatFluxUnit.MicrowattPerSquareMeter, "µW/m²")]
+        [InlineData("en-US", HeatFluxUnit.MicrowattPerSquareMillimeter, "µW/mm²")]
         [InlineData("en-US", HeatFluxUnit.MilliwattPerSquareMeter, "mW/m²")]
+        [InlineData("en-US", HeatFluxUnit.MilliwattPerSquareMillimeter, "mW/mm²")]
         [InlineData("en-US", HeatFluxUnit.NanowattPerSquareMeter, "nW/m²")]
+        [InlineData("en-US", HeatFluxUnit.NanowattPerSquareMillimeter, "nW/mm²")]
         [InlineData("en-US", HeatFluxUnit.PoundForcePerFootSecond, "lbf/(ft·s)")]
         [InlineData("en-US", HeatFluxUnit.PoundPerSecondCubed, "lb/s³")]
         [InlineData("en-US", HeatFluxUnit.WattPerSquareFoot, "W/ft²")]
         [InlineData("en-US", HeatFluxUnit.WattPerSquareInch, "W/in²")]
         [InlineData("en-US", HeatFluxUnit.WattPerSquareMeter, "W/m²")]
+        [InlineData("en-US", HeatFluxUnit.WattPerSquareMillimeter, "W/mm²")]
         public void GetAbbreviationForCulture(string culture, HeatFluxUnit unit, string expectedAbbreviation)
         {
             var defaultAbbreviation = HeatFlux.GetAbbreviation(unit, CultureInfo.GetCultureInfo(culture));
@@ -675,6 +851,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(HeatFluxUnit uni
                 var quantity = HeatFlux.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -698,49 +875,58 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(HeatFluxUnit unit)
                 IQuantity<HeatFluxUnit> quantityToConvert = quantity;
                 IQuantity<HeatFluxUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            HeatFlux wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, HeatFlux.FromBtusPerHourSquareFoot(wattpersquaremeter.BtusPerHourSquareFoot).WattsPerSquareMeter, BtusPerHourSquareFootTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromBtusPerMinuteSquareFoot(wattpersquaremeter.BtusPerMinuteSquareFoot).WattsPerSquareMeter, BtusPerMinuteSquareFootTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromBtusPerSecondSquareFoot(wattpersquaremeter.BtusPerSecondSquareFoot).WattsPerSquareMeter, BtusPerSecondSquareFootTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromBtusPerSecondSquareInch(wattpersquaremeter.BtusPerSecondSquareInch).WattsPerSquareMeter, BtusPerSecondSquareInchTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromCaloriesPerSecondSquareCentimeter(wattpersquaremeter.CaloriesPerSecondSquareCentimeter).WattsPerSquareMeter, CaloriesPerSecondSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromCentiwattsPerSquareMeter(wattpersquaremeter.CentiwattsPerSquareMeter).WattsPerSquareMeter, CentiwattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromDeciwattsPerSquareMeter(wattpersquaremeter.DeciwattsPerSquareMeter).WattsPerSquareMeter, DeciwattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromKilocaloriesPerHourSquareMeter(wattpersquaremeter.KilocaloriesPerHourSquareMeter).WattsPerSquareMeter, KilocaloriesPerHourSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(wattpersquaremeter.KilocaloriesPerSecondSquareCentimeter).WattsPerSquareMeter, KilocaloriesPerSecondSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromKilowattsPerSquareMeter(wattpersquaremeter.KilowattsPerSquareMeter).WattsPerSquareMeter, KilowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromMicrowattsPerSquareMeter(wattpersquaremeter.MicrowattsPerSquareMeter).WattsPerSquareMeter, MicrowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromMilliwattsPerSquareMeter(wattpersquaremeter.MilliwattsPerSquareMeter).WattsPerSquareMeter, MilliwattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromNanowattsPerSquareMeter(wattpersquaremeter.NanowattsPerSquareMeter).WattsPerSquareMeter, NanowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromPoundsForcePerFootSecond(wattpersquaremeter.PoundsForcePerFootSecond).WattsPerSquareMeter, PoundsForcePerFootSecondTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromPoundsPerSecondCubed(wattpersquaremeter.PoundsPerSecondCubed).WattsPerSquareMeter, PoundsPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromWattsPerSquareFoot(wattpersquaremeter.WattsPerSquareFoot).WattsPerSquareMeter, WattsPerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromWattsPerSquareInch(wattpersquaremeter.WattsPerSquareInch).WattsPerSquareMeter, WattsPerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, HeatFlux.FromWattsPerSquareMeter(wattpersquaremeter.WattsPerSquareMeter).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
+            HeatFlux wattpersquaremeter = HeatFlux.FromWattsPerSquareMeter(3);
+            Assert.Equal(3, HeatFlux.FromBtusPerHourSquareFoot(wattpersquaremeter.BtusPerHourSquareFoot).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromBtusPerMinuteSquareFoot(wattpersquaremeter.BtusPerMinuteSquareFoot).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromBtusPerSecondSquareFoot(wattpersquaremeter.BtusPerSecondSquareFoot).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromBtusPerSecondSquareInch(wattpersquaremeter.BtusPerSecondSquareInch).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromCaloriesPerSecondSquareCentimeter(wattpersquaremeter.CaloriesPerSecondSquareCentimeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromCentiwattsPerSquareMeter(wattpersquaremeter.CentiwattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromCentiwattsPerSquareMillimeter(wattpersquaremeter.CentiwattsPerSquareMillimeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromDeciwattsPerSquareMeter(wattpersquaremeter.DeciwattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromDeciwattsPerSquareMillimeter(wattpersquaremeter.DeciwattsPerSquareMillimeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromKilocaloriesPerHourSquareMeter(wattpersquaremeter.KilocaloriesPerHourSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(wattpersquaremeter.KilocaloriesPerSecondSquareCentimeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromKilowattsPerSquareMeter(wattpersquaremeter.KilowattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromKilowattsPerSquareMillimeter(wattpersquaremeter.KilowattsPerSquareMillimeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromMicrowattsPerSquareMeter(wattpersquaremeter.MicrowattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromMicrowattsPerSquareMillimeter(wattpersquaremeter.MicrowattsPerSquareMillimeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromMilliwattsPerSquareMeter(wattpersquaremeter.MilliwattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromMilliwattsPerSquareMillimeter(wattpersquaremeter.MilliwattsPerSquareMillimeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromNanowattsPerSquareMeter(wattpersquaremeter.NanowattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromNanowattsPerSquareMillimeter(wattpersquaremeter.NanowattsPerSquareMillimeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromPoundsForcePerFootSecond(wattpersquaremeter.PoundsForcePerFootSecond).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromPoundsPerSecondCubed(wattpersquaremeter.PoundsPerSecondCubed).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromWattsPerSquareFoot(wattpersquaremeter.WattsPerSquareFoot).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromWattsPerSquareInch(wattpersquaremeter.WattsPerSquareInch).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromWattsPerSquareMeter(wattpersquaremeter.WattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, HeatFlux.FromWattsPerSquareMillimeter(wattpersquaremeter.WattsPerSquareMillimeter).WattsPerSquareMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             HeatFlux v = HeatFlux.FromWattsPerSquareMeter(1);
-            AssertEx.EqualTolerance(-1, -v.WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (HeatFlux.FromWattsPerSquareMeter(3)-v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (HeatFlux.FromWattsPerSquareMeter(10)/5).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, HeatFlux.FromWattsPerSquareMeter(10)/HeatFlux.FromWattsPerSquareMeter(5), WattsPerSquareMeterTolerance);
+            Assert.Equal(-1, -v.WattsPerSquareMeter);
+            Assert.Equal(2, (HeatFlux.FromWattsPerSquareMeter(3) - v).WattsPerSquareMeter);
+            Assert.Equal(2, (v + v).WattsPerSquareMeter);
+            Assert.Equal(10, (v * 10).WattsPerSquareMeter);
+            Assert.Equal(10, (10 * v).WattsPerSquareMeter);
+            Assert.Equal(2, (HeatFlux.FromWattsPerSquareMeter(10) / 5).WattsPerSquareMeter);
+            Assert.Equal(2, HeatFlux.FromWattsPerSquareMeter(10) / HeatFlux.FromWattsPerSquareMeter(5));
         }
 
         [Fact]
@@ -786,8 +972,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, HeatFluxUnit.WattPerSquareMeter, 1, HeatFluxUnit.WattPerSquareMeter, true)]  // Same value and unit.
         [InlineData(1, HeatFluxUnit.WattPerSquareMeter, 2, HeatFluxUnit.WattPerSquareMeter, false)] // Different value.
-        [InlineData(2, HeatFluxUnit.WattPerSquareMeter, 1, HeatFluxUnit.BtuPerHourSquareFoot, false)] // Different value and unit.
-        [InlineData(1, HeatFluxUnit.WattPerSquareMeter, 1, HeatFluxUnit.BtuPerHourSquareFoot, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, HeatFluxUnit unitA, double valueB, HeatFluxUnit unitB, bool expectEqual)
         {
             var a = new HeatFlux(valueA, unitA);
@@ -847,8 +1031,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = HeatFlux.FromWattsPerSquareMeter(firstValue);
             var otherQuantity = HeatFlux.FromWattsPerSquareMeter(secondValue);
             HeatFlux maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, HeatFlux.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -867,7 +1051,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<HeatFluxUnit>();
+            var units = EnumHelper.GetValues<HeatFluxUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -880,6 +1064,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(HeatFlux.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(HeatFlux.Info.Units, HeatFlux.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, HeatFlux.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -890,18 +1086,25 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
             Assert.Equal("1 BTU/(s·in²)", new HeatFlux(1, HeatFluxUnit.BtuPerSecondSquareInch).ToString());
             Assert.Equal("1 cal/(s·cm²)", new HeatFlux(1, HeatFluxUnit.CaloriePerSecondSquareCentimeter).ToString());
             Assert.Equal("1 cW/m²", new HeatFlux(1, HeatFluxUnit.CentiwattPerSquareMeter).ToString());
+            Assert.Equal("1 cW/mm²", new HeatFlux(1, HeatFluxUnit.CentiwattPerSquareMillimeter).ToString());
             Assert.Equal("1 dW/m²", new HeatFlux(1, HeatFluxUnit.DeciwattPerSquareMeter).ToString());
+            Assert.Equal("1 dW/mm²", new HeatFlux(1, HeatFluxUnit.DeciwattPerSquareMillimeter).ToString());
             Assert.Equal("1 kcal/(h·m²)", new HeatFlux(1, HeatFluxUnit.KilocaloriePerHourSquareMeter).ToString());
             Assert.Equal("1 kcal/(s·cm²)", new HeatFlux(1, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter).ToString());
             Assert.Equal("1 kW/m²", new HeatFlux(1, HeatFluxUnit.KilowattPerSquareMeter).ToString());
+            Assert.Equal("1 kW/mm²", new HeatFlux(1, HeatFluxUnit.KilowattPerSquareMillimeter).ToString());
             Assert.Equal("1 µW/m²", new HeatFlux(1, HeatFluxUnit.MicrowattPerSquareMeter).ToString());
+            Assert.Equal("1 µW/mm²", new HeatFlux(1, HeatFluxUnit.MicrowattPerSquareMillimeter).ToString());
             Assert.Equal("1 mW/m²", new HeatFlux(1, HeatFluxUnit.MilliwattPerSquareMeter).ToString());
+            Assert.Equal("1 mW/mm²", new HeatFlux(1, HeatFluxUnit.MilliwattPerSquareMillimeter).ToString());
             Assert.Equal("1 nW/m²", new HeatFlux(1, HeatFluxUnit.NanowattPerSquareMeter).ToString());
+            Assert.Equal("1 nW/mm²", new HeatFlux(1, HeatFluxUnit.NanowattPerSquareMillimeter).ToString());
             Assert.Equal("1 lbf/(ft·s)", new HeatFlux(1, HeatFluxUnit.PoundForcePerFootSecond).ToString());
             Assert.Equal("1 lb/s³", new HeatFlux(1, HeatFluxUnit.PoundPerSecondCubed).ToString());
             Assert.Equal("1 W/ft²", new HeatFlux(1, HeatFluxUnit.WattPerSquareFoot).ToString());
             Assert.Equal("1 W/in²", new HeatFlux(1, HeatFluxUnit.WattPerSquareInch).ToString());
             Assert.Equal("1 W/m²", new HeatFlux(1, HeatFluxUnit.WattPerSquareMeter).ToString());
+            Assert.Equal("1 W/mm²", new HeatFlux(1, HeatFluxUnit.WattPerSquareMillimeter).ToString());
         }
 
         [Fact]
@@ -916,38 +1119,25 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 BTU/(s·in²)", new HeatFlux(1, HeatFluxUnit.BtuPerSecondSquareInch).ToString(swedishCulture));
             Assert.Equal("1 cal/(s·cm²)", new HeatFlux(1, HeatFluxUnit.CaloriePerSecondSquareCentimeter).ToString(swedishCulture));
             Assert.Equal("1 cW/m²", new HeatFlux(1, HeatFluxUnit.CentiwattPerSquareMeter).ToString(swedishCulture));
+            Assert.Equal("1 cW/mm²", new HeatFlux(1, HeatFluxUnit.CentiwattPerSquareMillimeter).ToString(swedishCulture));
             Assert.Equal("1 dW/m²", new HeatFlux(1, HeatFluxUnit.DeciwattPerSquareMeter).ToString(swedishCulture));
+            Assert.Equal("1 dW/mm²", new HeatFlux(1, HeatFluxUnit.DeciwattPerSquareMillimeter).ToString(swedishCulture));
             Assert.Equal("1 kcal/(h·m²)", new HeatFlux(1, HeatFluxUnit.KilocaloriePerHourSquareMeter).ToString(swedishCulture));
             Assert.Equal("1 kcal/(s·cm²)", new HeatFlux(1, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter).ToString(swedishCulture));
             Assert.Equal("1 kW/m²", new HeatFlux(1, HeatFluxUnit.KilowattPerSquareMeter).ToString(swedishCulture));
+            Assert.Equal("1 kW/mm²", new HeatFlux(1, HeatFluxUnit.KilowattPerSquareMillimeter).ToString(swedishCulture));
             Assert.Equal("1 µW/m²", new HeatFlux(1, HeatFluxUnit.MicrowattPerSquareMeter).ToString(swedishCulture));
+            Assert.Equal("1 µW/mm²", new HeatFlux(1, HeatFluxUnit.MicrowattPerSquareMillimeter).ToString(swedishCulture));
             Assert.Equal("1 mW/m²", new HeatFlux(1, HeatFluxUnit.MilliwattPerSquareMeter).ToString(swedishCulture));
+            Assert.Equal("1 mW/mm²", new HeatFlux(1, HeatFluxUnit.MilliwattPerSquareMillimeter).ToString(swedishCulture));
             Assert.Equal("1 nW/m²", new HeatFlux(1, HeatFluxUnit.NanowattPerSquareMeter).ToString(swedishCulture));
+            Assert.Equal("1 nW/mm²", new HeatFlux(1, HeatFluxUnit.NanowattPerSquareMillimeter).ToString(swedishCulture));
             Assert.Equal("1 lbf/(ft·s)", new HeatFlux(1, HeatFluxUnit.PoundForcePerFootSecond).ToString(swedishCulture));
             Assert.Equal("1 lb/s³", new HeatFlux(1, HeatFluxUnit.PoundPerSecondCubed).ToString(swedishCulture));
             Assert.Equal("1 W/ft²", new HeatFlux(1, HeatFluxUnit.WattPerSquareFoot).ToString(swedishCulture));
             Assert.Equal("1 W/in²", new HeatFlux(1, HeatFluxUnit.WattPerSquareInch).ToString(swedishCulture));
             Assert.Equal("1 W/m²", new HeatFlux(1, HeatFluxUnit.WattPerSquareMeter).ToString(swedishCulture));
-        }
-
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 W/m²", new HeatFlux(0.123456, HeatFluxUnit.WattPerSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 W/m²", new HeatFlux(0.123456, HeatFluxUnit.WattPerSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 W/m²", new HeatFlux(0.123456, HeatFluxUnit.WattPerSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 W/m²", new HeatFlux(0.123456, HeatFluxUnit.WattPerSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 W/m²", new HeatFlux(0.123456, HeatFluxUnit.WattPerSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 W/m²", new HeatFlux(0.123456, HeatFluxUnit.WattPerSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 W/m²", new HeatFlux(0.123456, HeatFluxUnit.WattPerSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 W/m²", new HeatFlux(0.123456, HeatFluxUnit.WattPerSquareMeter).ToString("s4", culture));
+            Assert.Equal("1 W/mm²", new HeatFlux(1, HeatFluxUnit.WattPerSquareMillimeter).ToString(swedishCulture));
         }
 
         [Theory]
@@ -976,7 +1166,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = HeatFlux.FromWattsPerSquareMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(HeatFlux), quantity.As(HeatFlux.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/HeatTransferCoefficientTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/HeatTransferCoefficientTestsBase.g.cs
index 94683fce44..dabea6c7e7 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/HeatTransferCoefficientTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/HeatTransferCoefficientTestsBase.g.cs
@@ -41,6 +41,7 @@ namespace UnitsNet.Tests
     public abstract partial class HeatTransferCoefficientTestsBase : QuantityTestsBase
     {
         protected abstract double BtusPerHourSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin { get; }
+        protected abstract double BtusPerSecondSquareInchDegreeFahrenheitInOneWattPerSquareMeterKelvin { get; }
         protected abstract double CaloriesPerHourSquareMeterDegreeCelsiusInOneWattPerSquareMeterKelvin { get; }
         protected abstract double KilocaloriesPerHourSquareMeterDegreeCelsiusInOneWattPerSquareMeterKelvin { get; }
         protected abstract double WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin { get; }
@@ -48,6 +49,7 @@ public abstract partial class HeatTransferCoefficientTestsBase : QuantityTestsBa
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double BtusPerHourSquareFootDegreeFahrenheitTolerance { get { return 1e-5; } }
+        protected virtual double BtusPerSecondSquareInchDegreeFahrenheitTolerance { get { return 1e-5; } }
         protected virtual double CaloriesPerHourSquareMeterDegreeCelsiusTolerance { get { return 1e-5; } }
         protected virtual double KilocaloriesPerHourSquareMeterDegreeCelsiusTolerance { get { return 1e-5; } }
         protected virtual double WattsPerSquareMeterCelsiusTolerance { get { return 1e-5; } }
@@ -59,6 +61,7 @@ public abstract partial class HeatTransferCoefficientTestsBase : QuantityTestsBa
             return unit switch
             {
                 HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit => (BtusPerHourSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin, BtusPerHourSquareFootDegreeFahrenheitTolerance),
+                HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit => (BtusPerSecondSquareInchDegreeFahrenheitInOneWattPerSquareMeterKelvin, BtusPerSecondSquareInchDegreeFahrenheitTolerance),
                 HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius => (CaloriesPerHourSquareMeterDegreeCelsiusInOneWattPerSquareMeterKelvin, CaloriesPerHourSquareMeterDegreeCelsiusTolerance),
                 HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius => (KilocaloriesPerHourSquareMeterDegreeCelsiusInOneWattPerSquareMeterKelvin, KilocaloriesPerHourSquareMeterDegreeCelsiusTolerance),
                 HeatTransferCoefficientUnit.WattPerSquareMeterCelsius => (WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin, WattsPerSquareMeterCelsiusTolerance),
@@ -70,6 +73,7 @@ public abstract partial class HeatTransferCoefficientTestsBase : QuantityTestsBa
         public static IEnumerable<object[]> UnitTypes = new List<object[]>
         {
             new object[] { HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit },
+            new object[] { HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit },
             new object[] { HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius },
             new object[] { HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius },
             new object[] { HeatTransferCoefficientUnit.WattPerSquareMeterCelsius },
@@ -141,11 +145,26 @@ public void HeatTransferCoefficient_QuantityInfo_ReturnsQuantityInfoDescribingQu
             Assert.Equal(quantityInfo, ((IQuantity<HeatTransferCoefficientUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void HeatTransferCoefficientInfo_CreateWithCustomUnitInfos()
+        {
+            HeatTransferCoefficientUnit[] expectedUnits = [HeatTransferCoefficientUnit.WattPerSquareMeterKelvin];
+
+            HeatTransferCoefficient.HeatTransferCoefficientInfo quantityInfo = HeatTransferCoefficient.HeatTransferCoefficientInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("HeatTransferCoefficient", quantityInfo.Name);
+            Assert.Equal(HeatTransferCoefficient.Zero, quantityInfo.Zero);
+            Assert.Equal(HeatTransferCoefficient.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void WattPerSquareMeterKelvinToHeatTransferCoefficientUnits()
         {
             HeatTransferCoefficient wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
             AssertEx.EqualTolerance(BtusPerHourSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.BtusPerHourSquareFootDegreeFahrenheit, BtusPerHourSquareFootDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(BtusPerSecondSquareInchDegreeFahrenheitInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.BtusPerSecondSquareInchDegreeFahrenheit, BtusPerSecondSquareInchDegreeFahrenheitTolerance);
             AssertEx.EqualTolerance(CaloriesPerHourSquareMeterDegreeCelsiusInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.CaloriesPerHourSquareMeterDegreeCelsius, CaloriesPerHourSquareMeterDegreeCelsiusTolerance);
             AssertEx.EqualTolerance(KilocaloriesPerHourSquareMeterDegreeCelsiusInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.KilocaloriesPerHourSquareMeterDegreeCelsius, KilocaloriesPerHourSquareMeterDegreeCelsiusTolerance);
             AssertEx.EqualTolerance(WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.WattsPerSquareMeterCelsius, WattsPerSquareMeterCelsiusTolerance);
@@ -186,6 +205,7 @@ public void As()
         {
             var wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
             AssertEx.EqualTolerance(BtusPerHourSquareFootDegreeFahrenheitInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit), BtusPerHourSquareFootDegreeFahrenheitTolerance);
+            AssertEx.EqualTolerance(BtusPerSecondSquareInchDegreeFahrenheitInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit), BtusPerSecondSquareInchDegreeFahrenheitTolerance);
             AssertEx.EqualTolerance(CaloriesPerHourSquareMeterDegreeCelsiusInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius), CaloriesPerHourSquareMeterDegreeCelsiusTolerance);
             AssertEx.EqualTolerance(KilocaloriesPerHourSquareMeterDegreeCelsiusInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius), KilocaloriesPerHourSquareMeterDegreeCelsiusTolerance);
             AssertEx.EqualTolerance(WattsPerSquareMeterCelsiusInOneWattPerSquareMeterKelvin, wattpersquaremeterkelvin.As(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius), WattsPerSquareMeterCelsiusTolerance);
@@ -233,26 +253,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = HeatTransferCoefficient.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            HeatTransferCoefficient convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                HeatTransferCoefficient quantityToConvert = quantity;
+
+                HeatTransferCoefficient convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<HeatTransferCoefficientUnit> quantityToConvert = quantity;
+
+                IQuantity<HeatTransferCoefficientUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new HeatTransferCoefficient(value: 1, unit: HeatTransferCoefficient.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new HeatTransferCoefficient(value: 1, unit: HeatTransferCoefficient.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<HeatTransferCoefficientUnit> quantity = new HeatTransferCoefficient(value: 1, unit: HeatTransferCoefficient.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new HeatTransferCoefficient(value: 1, unit: HeatTransferCoefficient.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new HeatTransferCoefficient(value: 1, unit: HeatTransferCoefficient.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new HeatTransferCoefficient(value: 1, unit: HeatTransferCoefficient.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<HeatTransferCoefficientUnit> quantity = new HeatTransferCoefficient(value: 1, unit: HeatTransferCoefficient.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new HeatTransferCoefficient(value: 1, unit: HeatTransferCoefficient.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -260,6 +323,10 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 Btu/(ft²·h·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, 4.2)]
         [InlineData("en-US", "4.2 Btu/(hr·ft²·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, 4.2)]
         [InlineData("en-US", "4.2 Btu/(ft²·hr·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, 4.2)]
+        [InlineData("en-US", "4.2 Btu/(s·in²·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit, 4.2)]
+        [InlineData("en-US", "4.2 Btu/(in²·s·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit, 4.2)]
+        [InlineData("en-US", "4.2 Btu/(s*in^2*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit, 4.2)]
+        [InlineData("en-US", "4.2 Btu/(in^2*s*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit, 4.2)]
         [InlineData("en-US", "4.2 kcal/(h·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 kcal/(m²·h·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 kcal/(hr·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, 4.2)]
@@ -270,7 +337,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 kkcal/(m²·hr·°C)", HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 W/(m²·°C)", HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, 4.2)]
         [InlineData("en-US", "4.2 W/(m²·K)", HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, 4.2)]
-        public void Parse(string culture, string quantityString, HeatTransferCoefficientUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, HeatTransferCoefficientUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = HeatTransferCoefficient.Parse(quantityString);
@@ -283,6 +350,10 @@ public void Parse(string culture, string quantityString, HeatTransferCoefficient
         [InlineData("en-US", "4.2 Btu/(ft²·h·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, 4.2)]
         [InlineData("en-US", "4.2 Btu/(hr·ft²·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, 4.2)]
         [InlineData("en-US", "4.2 Btu/(ft²·hr·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, 4.2)]
+        [InlineData("en-US", "4.2 Btu/(s·in²·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit, 4.2)]
+        [InlineData("en-US", "4.2 Btu/(in²·s·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit, 4.2)]
+        [InlineData("en-US", "4.2 Btu/(s*in^2*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit, 4.2)]
+        [InlineData("en-US", "4.2 Btu/(in^2*s*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit, 4.2)]
         [InlineData("en-US", "4.2 kcal/(h·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 kcal/(m²·h·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 kcal/(hr·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, 4.2)]
@@ -293,7 +364,7 @@ public void Parse(string culture, string quantityString, HeatTransferCoefficient
         [InlineData("en-US", "4.2 kkcal/(m²·hr·°C)", HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 W/(m²·°C)", HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, 4.2)]
         [InlineData("en-US", "4.2 W/(m²·K)", HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, 4.2)]
-        public void TryParse(string culture, string quantityString, HeatTransferCoefficientUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, HeatTransferCoefficientUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(HeatTransferCoefficient.TryParse(quantityString, out HeatTransferCoefficient parsed));
@@ -306,6 +377,10 @@ public void TryParse(string culture, string quantityString, HeatTransferCoeffici
         [InlineData("Btu/(ft²·h·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("Btu/(hr·ft²·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("Btu/(ft²·hr·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
+        [InlineData("Btu/(s·in²·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(in²·s·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(s*in^2*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(in^2*s*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
         [InlineData("kcal/(h·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("kcal/(m²·h·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("kcal/(hr·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
@@ -329,6 +404,10 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, HeatTrans
         [InlineData("Btu/(ft²·h·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("Btu/(hr·ft²·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("Btu/(ft²·hr·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
+        [InlineData("Btu/(s·in²·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(in²·s·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(s*in^2*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(in^2*s*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
         [InlineData("kcal/(h·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("kcal/(m²·h·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("kcal/(hr·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
@@ -352,6 +431,10 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "Btu/(ft²·h·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("en-US", "Btu/(hr·ft²·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("en-US", "Btu/(ft²·hr·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(s·in²·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(in²·s·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(s*in^2*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(in^2*s*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
         [InlineData("en-US", "kcal/(h·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("en-US", "kcal/(m²·h·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("en-US", "kcal/(hr·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
@@ -374,6 +457,10 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, He
         [InlineData("en-US", "Btu/(ft²·h·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("en-US", "Btu/(hr·ft²·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("en-US", "Btu/(ft²·hr·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(s·in²·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(in²·s·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(s*in^2*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(in^2*s*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
         [InlineData("en-US", "kcal/(h·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("en-US", "kcal/(m²·h·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("en-US", "kcal/(hr·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
@@ -395,6 +482,10 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, HeatTrans
         [InlineData("Btu/(ft²·h·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("Btu/(hr·ft²·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("Btu/(ft²·hr·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
+        [InlineData("Btu/(s·in²·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(in²·s·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(s*in^2*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(in^2*s*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
         [InlineData("kcal/(h·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("kcal/(m²·h·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("kcal/(hr·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
@@ -418,6 +509,10 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, HeatTr
         [InlineData("Btu/(ft²·h·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("Btu/(hr·ft²·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("Btu/(ft²·hr·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
+        [InlineData("Btu/(s·in²·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(in²·s·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(s*in^2*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("Btu/(in^2*s*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
         [InlineData("kcal/(h·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("kcal/(m²·h·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("kcal/(hr·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
@@ -441,6 +536,10 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "Btu/(ft²·h·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("en-US", "Btu/(hr·ft²·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("en-US", "Btu/(ft²·hr·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(s·in²·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(in²·s·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(s*in^2*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(in^2*s*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
         [InlineData("en-US", "kcal/(h·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("en-US", "kcal/(m²·h·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("en-US", "kcal/(hr·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
@@ -463,6 +562,10 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "Btu/(ft²·h·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("en-US", "Btu/(hr·ft²·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
         [InlineData("en-US", "Btu/(ft²·hr·°F)", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(s·in²·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(in²·s·°F)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(s*in^2*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
+        [InlineData("en-US", "Btu/(in^2*s*degF)", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit)]
         [InlineData("en-US", "kcal/(h·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("en-US", "kcal/(m²·h·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
         [InlineData("en-US", "kcal/(hr·m²·°C)", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius)]
@@ -481,6 +584,7 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, HeatTr
 
         [Theory]
         [InlineData("en-US", HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, "Btu/(h·ft²·°F)")]
+        [InlineData("en-US", HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit, "Btu/(s·in²·°F)")]
         [InlineData("en-US", HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, "kcal/(h·m²·°C)")]
         [InlineData("en-US", HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius, "kkcal/(h·m²·°C)")]
         [InlineData("en-US", HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, "W/(m²·°C)")]
@@ -534,6 +638,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(HeatTransferCoef
                 var quantity = HeatTransferCoefficient.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -557,36 +662,39 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(HeatTransferCoeffic
                 IQuantity<HeatTransferCoefficientUnit> quantityToConvert = quantity;
                 IQuantity<HeatTransferCoefficientUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            HeatTransferCoefficient wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
-            AssertEx.EqualTolerance(1, HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(wattpersquaremeterkelvin.BtusPerHourSquareFootDegreeFahrenheit).WattsPerSquareMeterKelvin, BtusPerHourSquareFootDegreeFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(wattpersquaremeterkelvin.CaloriesPerHourSquareMeterDegreeCelsius).WattsPerSquareMeterKelvin, CaloriesPerHourSquareMeterDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(wattpersquaremeterkelvin.KilocaloriesPerHourSquareMeterDegreeCelsius).WattsPerSquareMeterKelvin, KilocaloriesPerHourSquareMeterDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(wattpersquaremeterkelvin.WattsPerSquareMeterCelsius).WattsPerSquareMeterKelvin, WattsPerSquareMeterCelsiusTolerance);
-            AssertEx.EqualTolerance(1, HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(wattpersquaremeterkelvin.WattsPerSquareMeterKelvin).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
+            HeatTransferCoefficient wattpersquaremeterkelvin = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(3);
+            Assert.Equal(3, HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(wattpersquaremeterkelvin.BtusPerHourSquareFootDegreeFahrenheit).WattsPerSquareMeterKelvin);
+            Assert.Equal(3, HeatTransferCoefficient.FromBtusPerSecondSquareInchDegreeFahrenheit(wattpersquaremeterkelvin.BtusPerSecondSquareInchDegreeFahrenheit).WattsPerSquareMeterKelvin);
+            Assert.Equal(3, HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(wattpersquaremeterkelvin.CaloriesPerHourSquareMeterDegreeCelsius).WattsPerSquareMeterKelvin);
+            Assert.Equal(3, HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(wattpersquaremeterkelvin.KilocaloriesPerHourSquareMeterDegreeCelsius).WattsPerSquareMeterKelvin);
+            Assert.Equal(3, HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(wattpersquaremeterkelvin.WattsPerSquareMeterCelsius).WattsPerSquareMeterKelvin);
+            Assert.Equal(3, HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(wattpersquaremeterkelvin.WattsPerSquareMeterKelvin).WattsPerSquareMeterKelvin);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             HeatTransferCoefficient v = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1);
-            AssertEx.EqualTolerance(-1, -v.WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(3)-v).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (v + v).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
-            AssertEx.EqualTolerance(10, (v*10).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
-            AssertEx.EqualTolerance(10, (10*v).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(10)/5).WattsPerSquareMeterKelvin, WattsPerSquareMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(10)/HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(5), WattsPerSquareMeterKelvinTolerance);
+            Assert.Equal(-1, -v.WattsPerSquareMeterKelvin);
+            Assert.Equal(2, (HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(3) - v).WattsPerSquareMeterKelvin);
+            Assert.Equal(2, (v + v).WattsPerSquareMeterKelvin);
+            Assert.Equal(10, (v * 10).WattsPerSquareMeterKelvin);
+            Assert.Equal(10, (10 * v).WattsPerSquareMeterKelvin);
+            Assert.Equal(2, (HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(10) / 5).WattsPerSquareMeterKelvin);
+            Assert.Equal(2, HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(10) / HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(5));
         }
 
         [Fact]
@@ -632,8 +740,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, 1, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, true)]  // Same value and unit.
         [InlineData(1, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, 2, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, false)] // Different value.
-        [InlineData(2, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, 1, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, false)] // Different value and unit.
-        [InlineData(1, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, 1, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, HeatTransferCoefficientUnit unitA, double valueB, HeatTransferCoefficientUnit unitB, bool expectEqual)
         {
             var a = new HeatTransferCoefficient(valueA, unitA);
@@ -693,8 +799,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(firstValue);
             var otherQuantity = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(secondValue);
             HeatTransferCoefficient maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, HeatTransferCoefficient.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -713,7 +819,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<HeatTransferCoefficientUnit>();
+            var units = EnumHelper.GetValues<HeatTransferCoefficientUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -726,11 +832,24 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(HeatTransferCoefficient.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(HeatTransferCoefficient.Info.Units, HeatTransferCoefficient.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, HeatTransferCoefficient.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
             using var _ = new CultureScope("en-US");
             Assert.Equal("1 Btu/(h·ft²·°F)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit).ToString());
+            Assert.Equal("1 Btu/(s·in²·°F)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit).ToString());
             Assert.Equal("1 kcal/(h·m²·°C)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius).ToString());
             Assert.Equal("1 kkcal/(h·m²·°C)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius).ToString());
             Assert.Equal("1 W/(m²·°C)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius).ToString());
@@ -744,32 +863,13 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
 
             Assert.Equal("1 Btu/(h·ft²·°F)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit).ToString(swedishCulture));
+            Assert.Equal("1 Btu/(s·in²·°F)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit).ToString(swedishCulture));
             Assert.Equal("1 kcal/(h·m²·°C)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius).ToString(swedishCulture));
             Assert.Equal("1 kkcal/(h·m²·°C)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius).ToString(swedishCulture));
             Assert.Equal("1 W/(m²·°C)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius).ToString(swedishCulture));
             Assert.Equal("1 W/(m²·K)", new HeatTransferCoefficient(1, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 W/(m²·K)", new HeatTransferCoefficient(0.123456, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin).ToString("s1"));
-            Assert.Equal("0.12 W/(m²·K)", new HeatTransferCoefficient(0.123456, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin).ToString("s2"));
-            Assert.Equal("0.123 W/(m²·K)", new HeatTransferCoefficient(0.123456, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin).ToString("s3"));
-            Assert.Equal("0.1235 W/(m²·K)", new HeatTransferCoefficient(0.123456, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 W/(m²·K)", new HeatTransferCoefficient(0.123456, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin).ToString("s1", culture));
-            Assert.Equal("0.12 W/(m²·K)", new HeatTransferCoefficient(0.123456, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin).ToString("s2", culture));
-            Assert.Equal("0.123 W/(m²·K)", new HeatTransferCoefficient(0.123456, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin).ToString("s3", culture));
-            Assert.Equal("0.1235 W/(m²·K)", new HeatTransferCoefficient(0.123456, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -796,7 +896,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(HeatTransferCoefficient), quantity.As(HeatTransferCoefficient.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs
index 032f7f109f..4cca935684 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/IlluminanceTestsBase.g.cs
@@ -137,6 +137,20 @@ public void Illuminance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<IlluminanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void IlluminanceInfo_CreateWithCustomUnitInfos()
+        {
+            IlluminanceUnit[] expectedUnits = [IlluminanceUnit.Lux];
+
+            Illuminance.IlluminanceInfo quantityInfo = Illuminance.IlluminanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Illuminance", quantityInfo.Name);
+            Assert.Equal(Illuminance.Zero, quantityInfo.Zero);
+            Assert.Equal(Illuminance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void LuxToIlluminanceUnits()
         {
@@ -227,26 +241,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Illuminance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Illuminance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Illuminance quantityToConvert = quantity;
+
+                Illuminance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<IlluminanceUnit> quantityToConvert = quantity;
+
+                IQuantity<IlluminanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Illuminance(value: 1, unit: Illuminance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Illuminance(value: 1, unit: Illuminance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<IlluminanceUnit> quantity = new Illuminance(value: 1, unit: Illuminance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Illuminance(value: 1, unit: Illuminance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Illuminance(value: 1, unit: Illuminance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Illuminance(value: 1, unit: Illuminance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<IlluminanceUnit> quantity = new Illuminance(value: 1, unit: Illuminance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Illuminance(value: 1, unit: Illuminance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -254,7 +311,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 lx", IlluminanceUnit.Lux, 4.2)]
         [InlineData("en-US", "4.2 Mlx", IlluminanceUnit.Megalux, 4.2)]
         [InlineData("en-US", "4.2 mlx", IlluminanceUnit.Millilux, 4.2)]
-        public void Parse(string culture, string quantityString, IlluminanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, IlluminanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Illuminance.Parse(quantityString);
@@ -267,7 +324,7 @@ public void Parse(string culture, string quantityString, IlluminanceUnit expecte
         [InlineData("en-US", "4.2 lx", IlluminanceUnit.Lux, 4.2)]
         [InlineData("en-US", "4.2 Mlx", IlluminanceUnit.Megalux, 4.2)]
         [InlineData("en-US", "4.2 mlx", IlluminanceUnit.Millilux, 4.2)]
-        public void TryParse(string culture, string quantityString, IlluminanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, IlluminanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Illuminance.TryParse(quantityString, out Illuminance parsed));
@@ -427,6 +484,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(IlluminanceUnit
                 var quantity = Illuminance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -450,35 +508,37 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(IlluminanceUnit uni
                 IQuantity<IlluminanceUnit> quantityToConvert = quantity;
                 IQuantity<IlluminanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Illuminance lux = Illuminance.FromLux(1);
-            AssertEx.EqualTolerance(1, Illuminance.FromKilolux(lux.Kilolux).Lux, KiloluxTolerance);
-            AssertEx.EqualTolerance(1, Illuminance.FromLux(lux.Lux).Lux, LuxTolerance);
-            AssertEx.EqualTolerance(1, Illuminance.FromMegalux(lux.Megalux).Lux, MegaluxTolerance);
-            AssertEx.EqualTolerance(1, Illuminance.FromMillilux(lux.Millilux).Lux, MilliluxTolerance);
+            Illuminance lux = Illuminance.FromLux(3);
+            Assert.Equal(3, Illuminance.FromKilolux(lux.Kilolux).Lux);
+            Assert.Equal(3, Illuminance.FromLux(lux.Lux).Lux);
+            Assert.Equal(3, Illuminance.FromMegalux(lux.Megalux).Lux);
+            Assert.Equal(3, Illuminance.FromMillilux(lux.Millilux).Lux);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Illuminance v = Illuminance.FromLux(1);
-            AssertEx.EqualTolerance(-1, -v.Lux, LuxTolerance);
-            AssertEx.EqualTolerance(2, (Illuminance.FromLux(3)-v).Lux, LuxTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Lux, LuxTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Lux, LuxTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Lux, LuxTolerance);
-            AssertEx.EqualTolerance(2, (Illuminance.FromLux(10)/5).Lux, LuxTolerance);
-            AssertEx.EqualTolerance(2, Illuminance.FromLux(10)/Illuminance.FromLux(5), LuxTolerance);
+            Assert.Equal(-1, -v.Lux);
+            Assert.Equal(2, (Illuminance.FromLux(3) - v).Lux);
+            Assert.Equal(2, (v + v).Lux);
+            Assert.Equal(10, (v * 10).Lux);
+            Assert.Equal(10, (10 * v).Lux);
+            Assert.Equal(2, (Illuminance.FromLux(10) / 5).Lux);
+            Assert.Equal(2, Illuminance.FromLux(10) / Illuminance.FromLux(5));
         }
 
         [Fact]
@@ -524,8 +584,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, IlluminanceUnit.Lux, 1, IlluminanceUnit.Lux, true)]  // Same value and unit.
         [InlineData(1, IlluminanceUnit.Lux, 2, IlluminanceUnit.Lux, false)] // Different value.
-        [InlineData(2, IlluminanceUnit.Lux, 1, IlluminanceUnit.Kilolux, false)] // Different value and unit.
-        [InlineData(1, IlluminanceUnit.Lux, 1, IlluminanceUnit.Kilolux, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, IlluminanceUnit unitA, double valueB, IlluminanceUnit unitB, bool expectEqual)
         {
             var a = new Illuminance(valueA, unitA);
@@ -585,8 +643,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Illuminance.FromLux(firstValue);
             var otherQuantity = Illuminance.FromLux(secondValue);
             Illuminance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Illuminance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -605,7 +663,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<IlluminanceUnit>();
+            var units = EnumHelper.GetValues<IlluminanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -618,6 +676,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Illuminance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Illuminance.Info.Units, Illuminance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Illuminance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -640,26 +710,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 mlx", new Illuminance(1, IlluminanceUnit.Millilux).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 lx", new Illuminance(0.123456, IlluminanceUnit.Lux).ToString("s1"));
-            Assert.Equal("0.12 lx", new Illuminance(0.123456, IlluminanceUnit.Lux).ToString("s2"));
-            Assert.Equal("0.123 lx", new Illuminance(0.123456, IlluminanceUnit.Lux).ToString("s3"));
-            Assert.Equal("0.1235 lx", new Illuminance(0.123456, IlluminanceUnit.Lux).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 lx", new Illuminance(0.123456, IlluminanceUnit.Lux).ToString("s1", culture));
-            Assert.Equal("0.12 lx", new Illuminance(0.123456, IlluminanceUnit.Lux).ToString("s2", culture));
-            Assert.Equal("0.123 lx", new Illuminance(0.123456, IlluminanceUnit.Lux).ToString("s3", culture));
-            Assert.Equal("0.1235 lx", new Illuminance(0.123456, IlluminanceUnit.Lux).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -686,7 +736,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Illuminance.FromLux(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Illuminance), quantity.As(Illuminance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ImpulseTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ImpulseTestsBase.g.cs
index 4387a54912..0cc5b53db3 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ImpulseTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ImpulseTestsBase.g.cs
@@ -173,6 +173,20 @@ public void Impulse_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<ImpulseUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ImpulseInfo_CreateWithCustomUnitInfos()
+        {
+            ImpulseUnit[] expectedUnits = [ImpulseUnit.NewtonSecond];
+
+            Impulse.ImpulseInfo quantityInfo = Impulse.ImpulseInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Impulse", quantityInfo.Name);
+            Assert.Equal(Impulse.Zero, quantityInfo.Zero);
+            Assert.Equal(Impulse.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void NewtonSecondToImpulseUnits()
         {
@@ -281,26 +295,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Impulse.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Impulse convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Impulse quantityToConvert = quantity;
+
+                Impulse convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ImpulseUnit> quantityToConvert = quantity;
+
+                IQuantity<ImpulseUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Impulse(value: 1, unit: Impulse.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Impulse(value: 1, unit: Impulse.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ImpulseUnit> quantity = new Impulse(value: 1, unit: Impulse.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Impulse(value: 1, unit: Impulse.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Impulse(value: 1, unit: Impulse.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Impulse(value: 1, unit: Impulse.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ImpulseUnit> quantity = new Impulse(value: 1, unit: Impulse.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Impulse(value: 1, unit: Impulse.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -317,7 +374,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 lb·ft/s", ImpulseUnit.PoundFootPerSecond, 4.2)]
         [InlineData("en-US", "4.2 lbf·s", ImpulseUnit.PoundForceSecond, 4.2)]
         [InlineData("en-US", "4.2 slug·ft/s", ImpulseUnit.SlugFootPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, ImpulseUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ImpulseUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Impulse.Parse(quantityString);
@@ -339,7 +396,7 @@ public void Parse(string culture, string quantityString, ImpulseUnit expectedUni
         [InlineData("en-US", "4.2 lb·ft/s", ImpulseUnit.PoundFootPerSecond, 4.2)]
         [InlineData("en-US", "4.2 lbf·s", ImpulseUnit.PoundForceSecond, 4.2)]
         [InlineData("en-US", "4.2 slug·ft/s", ImpulseUnit.SlugFootPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, ImpulseUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ImpulseUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Impulse.TryParse(quantityString, out Impulse parsed));
@@ -580,6 +637,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ImpulseUnit unit
                 var quantity = Impulse.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -603,44 +661,46 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ImpulseUnit unit)
                 IQuantity<ImpulseUnit> quantityToConvert = quantity;
                 IQuantity<ImpulseUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Impulse newtonsecond = Impulse.FromNewtonSeconds(1);
-            AssertEx.EqualTolerance(1, Impulse.FromCentinewtonSeconds(newtonsecond.CentinewtonSeconds).NewtonSeconds, CentinewtonSecondsTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromDecanewtonSeconds(newtonsecond.DecanewtonSeconds).NewtonSeconds, DecanewtonSecondsTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromDecinewtonSeconds(newtonsecond.DecinewtonSeconds).NewtonSeconds, DecinewtonSecondsTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromKilogramMetersPerSecond(newtonsecond.KilogramMetersPerSecond).NewtonSeconds, KilogramMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromKilonewtonSeconds(newtonsecond.KilonewtonSeconds).NewtonSeconds, KilonewtonSecondsTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromMeganewtonSeconds(newtonsecond.MeganewtonSeconds).NewtonSeconds, MeganewtonSecondsTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromMicronewtonSeconds(newtonsecond.MicronewtonSeconds).NewtonSeconds, MicronewtonSecondsTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromMillinewtonSeconds(newtonsecond.MillinewtonSeconds).NewtonSeconds, MillinewtonSecondsTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromNanonewtonSeconds(newtonsecond.NanonewtonSeconds).NewtonSeconds, NanonewtonSecondsTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromNewtonSeconds(newtonsecond.NewtonSeconds).NewtonSeconds, NewtonSecondsTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromPoundFeetPerSecond(newtonsecond.PoundFeetPerSecond).NewtonSeconds, PoundFeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromPoundForceSeconds(newtonsecond.PoundForceSeconds).NewtonSeconds, PoundForceSecondsTolerance);
-            AssertEx.EqualTolerance(1, Impulse.FromSlugFeetPerSecond(newtonsecond.SlugFeetPerSecond).NewtonSeconds, SlugFeetPerSecondTolerance);
+            Impulse newtonsecond = Impulse.FromNewtonSeconds(3);
+            Assert.Equal(3, Impulse.FromCentinewtonSeconds(newtonsecond.CentinewtonSeconds).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromDecanewtonSeconds(newtonsecond.DecanewtonSeconds).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromDecinewtonSeconds(newtonsecond.DecinewtonSeconds).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromKilogramMetersPerSecond(newtonsecond.KilogramMetersPerSecond).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromKilonewtonSeconds(newtonsecond.KilonewtonSeconds).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromMeganewtonSeconds(newtonsecond.MeganewtonSeconds).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromMicronewtonSeconds(newtonsecond.MicronewtonSeconds).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromMillinewtonSeconds(newtonsecond.MillinewtonSeconds).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromNanonewtonSeconds(newtonsecond.NanonewtonSeconds).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromNewtonSeconds(newtonsecond.NewtonSeconds).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromPoundFeetPerSecond(newtonsecond.PoundFeetPerSecond).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromPoundForceSeconds(newtonsecond.PoundForceSeconds).NewtonSeconds);
+            Assert.Equal(3, Impulse.FromSlugFeetPerSecond(newtonsecond.SlugFeetPerSecond).NewtonSeconds);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Impulse v = Impulse.FromNewtonSeconds(1);
-            AssertEx.EqualTolerance(-1, -v.NewtonSeconds, NewtonSecondsTolerance);
-            AssertEx.EqualTolerance(2, (Impulse.FromNewtonSeconds(3)-v).NewtonSeconds, NewtonSecondsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).NewtonSeconds, NewtonSecondsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).NewtonSeconds, NewtonSecondsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).NewtonSeconds, NewtonSecondsTolerance);
-            AssertEx.EqualTolerance(2, (Impulse.FromNewtonSeconds(10)/5).NewtonSeconds, NewtonSecondsTolerance);
-            AssertEx.EqualTolerance(2, Impulse.FromNewtonSeconds(10)/Impulse.FromNewtonSeconds(5), NewtonSecondsTolerance);
+            Assert.Equal(-1, -v.NewtonSeconds);
+            Assert.Equal(2, (Impulse.FromNewtonSeconds(3) - v).NewtonSeconds);
+            Assert.Equal(2, (v + v).NewtonSeconds);
+            Assert.Equal(10, (v * 10).NewtonSeconds);
+            Assert.Equal(10, (10 * v).NewtonSeconds);
+            Assert.Equal(2, (Impulse.FromNewtonSeconds(10) / 5).NewtonSeconds);
+            Assert.Equal(2, Impulse.FromNewtonSeconds(10) / Impulse.FromNewtonSeconds(5));
         }
 
         [Fact]
@@ -686,8 +746,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ImpulseUnit.NewtonSecond, 1, ImpulseUnit.NewtonSecond, true)]  // Same value and unit.
         [InlineData(1, ImpulseUnit.NewtonSecond, 2, ImpulseUnit.NewtonSecond, false)] // Different value.
-        [InlineData(2, ImpulseUnit.NewtonSecond, 1, ImpulseUnit.CentinewtonSecond, false)] // Different value and unit.
-        [InlineData(1, ImpulseUnit.NewtonSecond, 1, ImpulseUnit.CentinewtonSecond, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ImpulseUnit unitA, double valueB, ImpulseUnit unitB, bool expectEqual)
         {
             var a = new Impulse(valueA, unitA);
@@ -747,8 +805,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Impulse.FromNewtonSeconds(firstValue);
             var otherQuantity = Impulse.FromNewtonSeconds(secondValue);
             Impulse maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Impulse.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -767,7 +825,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ImpulseUnit>();
+            var units = EnumHelper.GetValues<ImpulseUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -780,6 +838,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Impulse.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Impulse.Info.Units, Impulse.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Impulse.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -820,26 +890,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 slug·ft/s", new Impulse(1, ImpulseUnit.SlugFootPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 N·s", new Impulse(0.123456, ImpulseUnit.NewtonSecond).ToString("s1"));
-            Assert.Equal("0.12 N·s", new Impulse(0.123456, ImpulseUnit.NewtonSecond).ToString("s2"));
-            Assert.Equal("0.123 N·s", new Impulse(0.123456, ImpulseUnit.NewtonSecond).ToString("s3"));
-            Assert.Equal("0.1235 N·s", new Impulse(0.123456, ImpulseUnit.NewtonSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 N·s", new Impulse(0.123456, ImpulseUnit.NewtonSecond).ToString("s1", culture));
-            Assert.Equal("0.12 N·s", new Impulse(0.123456, ImpulseUnit.NewtonSecond).ToString("s2", culture));
-            Assert.Equal("0.123 N·s", new Impulse(0.123456, ImpulseUnit.NewtonSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 N·s", new Impulse(0.123456, ImpulseUnit.NewtonSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -866,7 +916,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Impulse.FromNewtonSeconds(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Impulse), quantity.As(Impulse.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs
index 1d46f8d8d3..6645972b3f 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs
@@ -256,6 +256,20 @@ public void Information_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<InformationUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void InformationInfo_CreateWithCustomUnitInfos()
+        {
+            InformationUnit[] expectedUnits = [InformationUnit.Bit];
+
+            Information.InformationInfo quantityInfo = Information.InformationInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Information", quantityInfo.Name);
+            Assert.Equal(Information.Zero, quantityInfo.Zero);
+            Assert.Equal(Information.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void BitToInformationUnits()
         {
@@ -396,12 +410,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new Information(value: 1, unit: InformationUnit.Bit);
+            Assert.Multiple(() =>
+            {
+                var quantity = new Information(value: 1, unit: InformationUnit.Bit);
+
+                Information convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(InformationUnit.Bit, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<InformationUnit> quantity = new Information(value: 1, unit: InformationUnit.Bit);
+
+                IQuantity<InformationUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(InformationUnit.Bit, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new Information(value: 1, unit: InformationUnit.Bit);
 
-            Information convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(InformationUnit.Bit, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(InformationUnit.Bit, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -463,7 +496,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [InlineData("en-US", "4.2 Tb", InformationUnit.Terabit, 4.2)]
         [InlineData("en-US", "4.2 TB", InformationUnit.Terabyte, 4.2)]
         [InlineData("en-US", "4.2 To", InformationUnit.Teraoctet, 4.2)]
-        public void Parse(string culture, string quantityString, InformationUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, InformationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Information.Parse(quantityString);
@@ -511,7 +544,7 @@ public void Parse(string culture, string quantityString, InformationUnit expecte
         [InlineData("en-US", "4.2 Tb", InformationUnit.Terabit, 4.2)]
         [InlineData("en-US", "4.2 TB", InformationUnit.Terabyte, 4.2)]
         [InlineData("en-US", "4.2 To", InformationUnit.Teraoctet, 4.2)]
-        public void TryParse(string culture, string quantityString, InformationUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, InformationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Information.TryParse(quantityString, out Information parsed));
@@ -986,6 +1019,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(InformationUnit
                 var quantity = Information.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1009,70 +1043,72 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(InformationUnit uni
                 IQuantity<InformationUnit> quantityToConvert = quantity;
                 IQuantity<InformationUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Information bit = Information.FromBits(1);
-            AssertEx.EqualTolerance(1, Information.FromBits(bit.Bits).Bits, BitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromBytes(bit.Bytes).Bits, BytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromExabits(bit.Exabits).Bits, ExabitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromExabytes(bit.Exabytes).Bits, ExabytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromExaoctets(bit.Exaoctets).Bits, ExaoctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromExbibits(bit.Exbibits).Bits, ExbibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromExbibytes(bit.Exbibytes).Bits, ExbibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromExbioctets(bit.Exbioctets).Bits, ExbioctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromGibibits(bit.Gibibits).Bits, GibibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromGibibytes(bit.Gibibytes).Bits, GibibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromGibioctets(bit.Gibioctets).Bits, GibioctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromGigabits(bit.Gigabits).Bits, GigabitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromGigabytes(bit.Gigabytes).Bits, GigabytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromGigaoctets(bit.Gigaoctets).Bits, GigaoctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromKibibits(bit.Kibibits).Bits, KibibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromKibibytes(bit.Kibibytes).Bits, KibibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromKibioctets(bit.Kibioctets).Bits, KibioctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromKilobits(bit.Kilobits).Bits, KilobitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromKilobytes(bit.Kilobytes).Bits, KilobytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromKilooctets(bit.Kilooctets).Bits, KilooctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromMebibits(bit.Mebibits).Bits, MebibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromMebibytes(bit.Mebibytes).Bits, MebibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromMebioctets(bit.Mebioctets).Bits, MebioctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromMegabits(bit.Megabits).Bits, MegabitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromMegabytes(bit.Megabytes).Bits, MegabytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromMegaoctets(bit.Megaoctets).Bits, MegaoctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromOctets(bit.Octets).Bits, OctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromPebibits(bit.Pebibits).Bits, PebibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromPebibytes(bit.Pebibytes).Bits, PebibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromPebioctets(bit.Pebioctets).Bits, PebioctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromPetabits(bit.Petabits).Bits, PetabitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromPetabytes(bit.Petabytes).Bits, PetabytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromPetaoctets(bit.Petaoctets).Bits, PetaoctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromTebibits(bit.Tebibits).Bits, TebibitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromTebibytes(bit.Tebibytes).Bits, TebibytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromTebioctets(bit.Tebioctets).Bits, TebioctetsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromTerabits(bit.Terabits).Bits, TerabitsTolerance);
-            AssertEx.EqualTolerance(1, Information.FromTerabytes(bit.Terabytes).Bits, TerabytesTolerance);
-            AssertEx.EqualTolerance(1, Information.FromTeraoctets(bit.Teraoctets).Bits, TeraoctetsTolerance);
+            Information bit = Information.FromBits(3);
+            Assert.Equal(3, Information.FromBits(bit.Bits).Bits);
+            Assert.Equal(3, Information.FromBytes(bit.Bytes).Bits);
+            Assert.Equal(3, Information.FromExabits(bit.Exabits).Bits);
+            Assert.Equal(3, Information.FromExabytes(bit.Exabytes).Bits);
+            Assert.Equal(3, Information.FromExaoctets(bit.Exaoctets).Bits);
+            Assert.Equal(3, Information.FromExbibits(bit.Exbibits).Bits);
+            Assert.Equal(3, Information.FromExbibytes(bit.Exbibytes).Bits);
+            Assert.Equal(3, Information.FromExbioctets(bit.Exbioctets).Bits);
+            Assert.Equal(3, Information.FromGibibits(bit.Gibibits).Bits);
+            Assert.Equal(3, Information.FromGibibytes(bit.Gibibytes).Bits);
+            Assert.Equal(3, Information.FromGibioctets(bit.Gibioctets).Bits);
+            Assert.Equal(3, Information.FromGigabits(bit.Gigabits).Bits);
+            Assert.Equal(3, Information.FromGigabytes(bit.Gigabytes).Bits);
+            Assert.Equal(3, Information.FromGigaoctets(bit.Gigaoctets).Bits);
+            Assert.Equal(3, Information.FromKibibits(bit.Kibibits).Bits);
+            Assert.Equal(3, Information.FromKibibytes(bit.Kibibytes).Bits);
+            Assert.Equal(3, Information.FromKibioctets(bit.Kibioctets).Bits);
+            Assert.Equal(3, Information.FromKilobits(bit.Kilobits).Bits);
+            Assert.Equal(3, Information.FromKilobytes(bit.Kilobytes).Bits);
+            Assert.Equal(3, Information.FromKilooctets(bit.Kilooctets).Bits);
+            Assert.Equal(3, Information.FromMebibits(bit.Mebibits).Bits);
+            Assert.Equal(3, Information.FromMebibytes(bit.Mebibytes).Bits);
+            Assert.Equal(3, Information.FromMebioctets(bit.Mebioctets).Bits);
+            Assert.Equal(3, Information.FromMegabits(bit.Megabits).Bits);
+            Assert.Equal(3, Information.FromMegabytes(bit.Megabytes).Bits);
+            Assert.Equal(3, Information.FromMegaoctets(bit.Megaoctets).Bits);
+            Assert.Equal(3, Information.FromOctets(bit.Octets).Bits);
+            Assert.Equal(3, Information.FromPebibits(bit.Pebibits).Bits);
+            Assert.Equal(3, Information.FromPebibytes(bit.Pebibytes).Bits);
+            Assert.Equal(3, Information.FromPebioctets(bit.Pebioctets).Bits);
+            Assert.Equal(3, Information.FromPetabits(bit.Petabits).Bits);
+            Assert.Equal(3, Information.FromPetabytes(bit.Petabytes).Bits);
+            Assert.Equal(3, Information.FromPetaoctets(bit.Petaoctets).Bits);
+            Assert.Equal(3, Information.FromTebibits(bit.Tebibits).Bits);
+            Assert.Equal(3, Information.FromTebibytes(bit.Tebibytes).Bits);
+            Assert.Equal(3, Information.FromTebioctets(bit.Tebioctets).Bits);
+            Assert.Equal(3, Information.FromTerabits(bit.Terabits).Bits);
+            Assert.Equal(3, Information.FromTerabytes(bit.Terabytes).Bits);
+            Assert.Equal(3, Information.FromTeraoctets(bit.Teraoctets).Bits);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Information v = Information.FromBits(1);
-            AssertEx.EqualTolerance(-1, -v.Bits, BitsTolerance);
-            AssertEx.EqualTolerance(2, (Information.FromBits(3)-v).Bits, BitsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Bits, BitsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Bits, BitsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Bits, BitsTolerance);
-            AssertEx.EqualTolerance(2, (Information.FromBits(10)/5).Bits, BitsTolerance);
-            AssertEx.EqualTolerance(2, Information.FromBits(10)/Information.FromBits(5), BitsTolerance);
+            Assert.Equal(-1, -v.Bits);
+            Assert.Equal(2, (Information.FromBits(3) - v).Bits);
+            Assert.Equal(2, (v + v).Bits);
+            Assert.Equal(10, (v * 10).Bits);
+            Assert.Equal(10, (10 * v).Bits);
+            Assert.Equal(2, (Information.FromBits(10) / 5).Bits);
+            Assert.Equal(2, Information.FromBits(10) / Information.FromBits(5));
         }
 
         [Fact]
@@ -1118,8 +1154,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, InformationUnit.Bit, 1, InformationUnit.Bit, true)]  // Same value and unit.
         [InlineData(1, InformationUnit.Bit, 2, InformationUnit.Bit, false)] // Different value.
-        [InlineData(2, InformationUnit.Bit, 1, InformationUnit.Byte, false)] // Different value and unit.
-        [InlineData(1, InformationUnit.Bit, 1, InformationUnit.Byte, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, InformationUnit unitA, double valueB, InformationUnit unitB, bool expectEqual)
         {
             var a = new Information(valueA, unitA);
@@ -1179,8 +1213,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Information.FromBits(firstValue);
             var otherQuantity = Information.FromBits(secondValue);
             Information maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Information.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1199,7 +1233,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<InformationUnit>();
+            var units = EnumHelper.GetValues<InformationUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1212,6 +1246,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Information.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Information.Info.Units, Information.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Information.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1304,26 +1350,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 To", new Information(1, InformationUnit.Teraoctet).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 b", new Information(0.123456, InformationUnit.Bit).ToString("s1"));
-            Assert.Equal("0.12 b", new Information(0.123456, InformationUnit.Bit).ToString("s2"));
-            Assert.Equal("0.123 b", new Information(0.123456, InformationUnit.Bit).ToString("s3"));
-            Assert.Equal("0.1235 b", new Information(0.123456, InformationUnit.Bit).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 b", new Information(0.123456, InformationUnit.Bit).ToString("s1", culture));
-            Assert.Equal("0.12 b", new Information(0.123456, InformationUnit.Bit).ToString("s2", culture));
-            Assert.Equal("0.123 b", new Information(0.123456, InformationUnit.Bit).ToString("s3", culture));
-            Assert.Equal("0.1235 b", new Information(0.123456, InformationUnit.Bit).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1350,7 +1376,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Information.FromBits(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Information), quantity.As(Information.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/IrradianceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/IrradianceTestsBase.g.cs
index f1e60d0038..a6a96662c5 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/IrradianceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/IrradianceTestsBase.g.cs
@@ -177,6 +177,20 @@ public void Irradiance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<IrradianceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void IrradianceInfo_CreateWithCustomUnitInfos()
+        {
+            IrradianceUnit[] expectedUnits = [IrradianceUnit.WattPerSquareMeter];
+
+            Irradiance.IrradianceInfo quantityInfo = Irradiance.IrradianceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Irradiance", quantityInfo.Name);
+            Assert.Equal(Irradiance.Zero, quantityInfo.Zero);
+            Assert.Equal(Irradiance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void WattPerSquareMeterToIrradianceUnits()
         {
@@ -287,26 +301,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Irradiance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Irradiance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Irradiance quantityToConvert = quantity;
+
+                Irradiance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<IrradianceUnit> quantityToConvert = quantity;
+
+                IQuantity<IrradianceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Irradiance(value: 1, unit: Irradiance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Irradiance(value: 1, unit: Irradiance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<IrradianceUnit> quantity = new Irradiance(value: 1, unit: Irradiance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Irradiance(value: 1, unit: Irradiance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Irradiance(value: 1, unit: Irradiance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Irradiance(value: 1, unit: Irradiance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<IrradianceUnit> quantity = new Irradiance(value: 1, unit: Irradiance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Irradiance(value: 1, unit: Irradiance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -324,7 +381,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 pW/m²", IrradianceUnit.PicowattPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 W/cm²", IrradianceUnit.WattPerSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 W/m²", IrradianceUnit.WattPerSquareMeter, 4.2)]
-        public void Parse(string culture, string quantityString, IrradianceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, IrradianceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Irradiance.Parse(quantityString);
@@ -347,7 +404,7 @@ public void Parse(string culture, string quantityString, IrradianceUnit expected
         [InlineData("en-US", "4.2 pW/m²", IrradianceUnit.PicowattPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 W/cm²", IrradianceUnit.WattPerSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 W/m²", IrradianceUnit.WattPerSquareMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, IrradianceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, IrradianceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Irradiance.TryParse(quantityString, out Irradiance parsed));
@@ -597,6 +654,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(IrradianceUnit u
                 var quantity = Irradiance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -620,45 +678,47 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(IrradianceUnit unit
                 IQuantity<IrradianceUnit> quantityToConvert = quantity;
                 IQuantity<IrradianceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Irradiance wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, Irradiance.FromKilowattsPerSquareCentimeter(wattpersquaremeter.KilowattsPerSquareCentimeter).WattsPerSquareMeter, KilowattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromKilowattsPerSquareMeter(wattpersquaremeter.KilowattsPerSquareMeter).WattsPerSquareMeter, KilowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMegawattsPerSquareCentimeter(wattpersquaremeter.MegawattsPerSquareCentimeter).WattsPerSquareMeter, MegawattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMegawattsPerSquareMeter(wattpersquaremeter.MegawattsPerSquareMeter).WattsPerSquareMeter, MegawattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMicrowattsPerSquareCentimeter(wattpersquaremeter.MicrowattsPerSquareCentimeter).WattsPerSquareMeter, MicrowattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMicrowattsPerSquareMeter(wattpersquaremeter.MicrowattsPerSquareMeter).WattsPerSquareMeter, MicrowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMilliwattsPerSquareCentimeter(wattpersquaremeter.MilliwattsPerSquareCentimeter).WattsPerSquareMeter, MilliwattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromMilliwattsPerSquareMeter(wattpersquaremeter.MilliwattsPerSquareMeter).WattsPerSquareMeter, MilliwattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromNanowattsPerSquareCentimeter(wattpersquaremeter.NanowattsPerSquareCentimeter).WattsPerSquareMeter, NanowattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromNanowattsPerSquareMeter(wattpersquaremeter.NanowattsPerSquareMeter).WattsPerSquareMeter, NanowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromPicowattsPerSquareCentimeter(wattpersquaremeter.PicowattsPerSquareCentimeter).WattsPerSquareMeter, PicowattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromPicowattsPerSquareMeter(wattpersquaremeter.PicowattsPerSquareMeter).WattsPerSquareMeter, PicowattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromWattsPerSquareCentimeter(wattpersquaremeter.WattsPerSquareCentimeter).WattsPerSquareMeter, WattsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiance.FromWattsPerSquareMeter(wattpersquaremeter.WattsPerSquareMeter).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
+            Irradiance wattpersquaremeter = Irradiance.FromWattsPerSquareMeter(3);
+            Assert.Equal(3, Irradiance.FromKilowattsPerSquareCentimeter(wattpersquaremeter.KilowattsPerSquareCentimeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromKilowattsPerSquareMeter(wattpersquaremeter.KilowattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromMegawattsPerSquareCentimeter(wattpersquaremeter.MegawattsPerSquareCentimeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromMegawattsPerSquareMeter(wattpersquaremeter.MegawattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromMicrowattsPerSquareCentimeter(wattpersquaremeter.MicrowattsPerSquareCentimeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromMicrowattsPerSquareMeter(wattpersquaremeter.MicrowattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromMilliwattsPerSquareCentimeter(wattpersquaremeter.MilliwattsPerSquareCentimeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromMilliwattsPerSquareMeter(wattpersquaremeter.MilliwattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromNanowattsPerSquareCentimeter(wattpersquaremeter.NanowattsPerSquareCentimeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromNanowattsPerSquareMeter(wattpersquaremeter.NanowattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromPicowattsPerSquareCentimeter(wattpersquaremeter.PicowattsPerSquareCentimeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromPicowattsPerSquareMeter(wattpersquaremeter.PicowattsPerSquareMeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromWattsPerSquareCentimeter(wattpersquaremeter.WattsPerSquareCentimeter).WattsPerSquareMeter);
+            Assert.Equal(3, Irradiance.FromWattsPerSquareMeter(wattpersquaremeter.WattsPerSquareMeter).WattsPerSquareMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Irradiance v = Irradiance.FromWattsPerSquareMeter(1);
-            AssertEx.EqualTolerance(-1, -v.WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (Irradiance.FromWattsPerSquareMeter(3)-v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (Irradiance.FromWattsPerSquareMeter(10)/5).WattsPerSquareMeter, WattsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, Irradiance.FromWattsPerSquareMeter(10)/Irradiance.FromWattsPerSquareMeter(5), WattsPerSquareMeterTolerance);
+            Assert.Equal(-1, -v.WattsPerSquareMeter);
+            Assert.Equal(2, (Irradiance.FromWattsPerSquareMeter(3) - v).WattsPerSquareMeter);
+            Assert.Equal(2, (v + v).WattsPerSquareMeter);
+            Assert.Equal(10, (v * 10).WattsPerSquareMeter);
+            Assert.Equal(10, (10 * v).WattsPerSquareMeter);
+            Assert.Equal(2, (Irradiance.FromWattsPerSquareMeter(10) / 5).WattsPerSquareMeter);
+            Assert.Equal(2, Irradiance.FromWattsPerSquareMeter(10) / Irradiance.FromWattsPerSquareMeter(5));
         }
 
         [Fact]
@@ -704,8 +764,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, IrradianceUnit.WattPerSquareMeter, 1, IrradianceUnit.WattPerSquareMeter, true)]  // Same value and unit.
         [InlineData(1, IrradianceUnit.WattPerSquareMeter, 2, IrradianceUnit.WattPerSquareMeter, false)] // Different value.
-        [InlineData(2, IrradianceUnit.WattPerSquareMeter, 1, IrradianceUnit.KilowattPerSquareCentimeter, false)] // Different value and unit.
-        [InlineData(1, IrradianceUnit.WattPerSquareMeter, 1, IrradianceUnit.KilowattPerSquareCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, IrradianceUnit unitA, double valueB, IrradianceUnit unitB, bool expectEqual)
         {
             var a = new Irradiance(valueA, unitA);
@@ -765,8 +823,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Irradiance.FromWattsPerSquareMeter(firstValue);
             var otherQuantity = Irradiance.FromWattsPerSquareMeter(secondValue);
             Irradiance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Irradiance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -785,7 +843,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<IrradianceUnit>();
+            var units = EnumHelper.GetValues<IrradianceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -798,6 +856,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Irradiance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Irradiance.Info.Units, Irradiance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Irradiance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -840,26 +910,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 W/m²", new Irradiance(1, IrradianceUnit.WattPerSquareMeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 W/m²", new Irradiance(0.123456, IrradianceUnit.WattPerSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 W/m²", new Irradiance(0.123456, IrradianceUnit.WattPerSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 W/m²", new Irradiance(0.123456, IrradianceUnit.WattPerSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 W/m²", new Irradiance(0.123456, IrradianceUnit.WattPerSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 W/m²", new Irradiance(0.123456, IrradianceUnit.WattPerSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 W/m²", new Irradiance(0.123456, IrradianceUnit.WattPerSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 W/m²", new Irradiance(0.123456, IrradianceUnit.WattPerSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 W/m²", new Irradiance(0.123456, IrradianceUnit.WattPerSquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -886,7 +936,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Irradiance.FromWattsPerSquareMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Irradiance), quantity.As(Irradiance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/IrradiationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/IrradiationTestsBase.g.cs
index 32139d5345..2903d21251 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/IrradiationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/IrradiationTestsBase.g.cs
@@ -157,6 +157,20 @@ public void Irradiation_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<IrradiationUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void IrradiationInfo_CreateWithCustomUnitInfos()
+        {
+            IrradiationUnit[] expectedUnits = [IrradiationUnit.JoulePerSquareMeter];
+
+            Irradiation.IrradiationInfo quantityInfo = Irradiation.IrradiationInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Irradiation", quantityInfo.Name);
+            Assert.Equal(Irradiation.Zero, quantityInfo.Zero);
+            Assert.Equal(Irradiation.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void JoulePerSquareMeterToIrradiationUnits()
         {
@@ -257,26 +271,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Irradiation.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Irradiation convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Irradiation quantityToConvert = quantity;
+
+                Irradiation convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<IrradiationUnit> quantityToConvert = quantity;
+
+                IQuantity<IrradiationUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Irradiation(value: 1, unit: Irradiation.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Irradiation(value: 1, unit: Irradiation.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<IrradiationUnit> quantity = new Irradiation(value: 1, unit: Irradiation.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Irradiation(value: 1, unit: Irradiation.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Irradiation(value: 1, unit: Irradiation.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Irradiation(value: 1, unit: Irradiation.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<IrradiationUnit> quantity = new Irradiation(value: 1, unit: Irradiation.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Irradiation(value: 1, unit: Irradiation.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -289,7 +346,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 kWh/m²", IrradiationUnit.KilowattHourPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 mJ/cm²", IrradiationUnit.MillijoulePerSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 Wh/m²", IrradiationUnit.WattHourPerSquareMeter, 4.2)]
-        public void Parse(string culture, string quantityString, IrradiationUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, IrradiationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Irradiation.Parse(quantityString);
@@ -307,7 +364,7 @@ public void Parse(string culture, string quantityString, IrradiationUnit expecte
         [InlineData("en-US", "4.2 kWh/m²", IrradiationUnit.KilowattHourPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 mJ/cm²", IrradiationUnit.MillijoulePerSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 Wh/m²", IrradiationUnit.WattHourPerSquareMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, IrradiationUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, IrradiationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Irradiation.TryParse(quantityString, out Irradiation parsed));
@@ -512,6 +569,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(IrradiationUnit
                 var quantity = Irradiation.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -535,40 +593,42 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(IrradiationUnit uni
                 IQuantity<IrradiationUnit> quantityToConvert = quantity;
                 IQuantity<IrradiationUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Irradiation joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, Irradiation.FromBtusPerSquareFoot(joulepersquaremeter.BtusPerSquareFoot).JoulesPerSquareMeter, BtusPerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromJoulesPerSquareCentimeter(joulepersquaremeter.JoulesPerSquareCentimeter).JoulesPerSquareMeter, JoulesPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromJoulesPerSquareMeter(joulepersquaremeter.JoulesPerSquareMeter).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromJoulesPerSquareMillimeter(joulepersquaremeter.JoulesPerSquareMillimeter).JoulesPerSquareMeter, JoulesPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromKilobtusPerSquareFoot(joulepersquaremeter.KilobtusPerSquareFoot).JoulesPerSquareMeter, KilobtusPerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromKilojoulesPerSquareMeter(joulepersquaremeter.KilojoulesPerSquareMeter).JoulesPerSquareMeter, KilojoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromKilowattHoursPerSquareMeter(joulepersquaremeter.KilowattHoursPerSquareMeter).JoulesPerSquareMeter, KilowattHoursPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromMillijoulesPerSquareCentimeter(joulepersquaremeter.MillijoulesPerSquareCentimeter).JoulesPerSquareMeter, MillijoulesPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Irradiation.FromWattHoursPerSquareMeter(joulepersquaremeter.WattHoursPerSquareMeter).JoulesPerSquareMeter, WattHoursPerSquareMeterTolerance);
+            Irradiation joulepersquaremeter = Irradiation.FromJoulesPerSquareMeter(3);
+            Assert.Equal(3, Irradiation.FromBtusPerSquareFoot(joulepersquaremeter.BtusPerSquareFoot).JoulesPerSquareMeter);
+            Assert.Equal(3, Irradiation.FromJoulesPerSquareCentimeter(joulepersquaremeter.JoulesPerSquareCentimeter).JoulesPerSquareMeter);
+            Assert.Equal(3, Irradiation.FromJoulesPerSquareMeter(joulepersquaremeter.JoulesPerSquareMeter).JoulesPerSquareMeter);
+            Assert.Equal(3, Irradiation.FromJoulesPerSquareMillimeter(joulepersquaremeter.JoulesPerSquareMillimeter).JoulesPerSquareMeter);
+            Assert.Equal(3, Irradiation.FromKilobtusPerSquareFoot(joulepersquaremeter.KilobtusPerSquareFoot).JoulesPerSquareMeter);
+            Assert.Equal(3, Irradiation.FromKilojoulesPerSquareMeter(joulepersquaremeter.KilojoulesPerSquareMeter).JoulesPerSquareMeter);
+            Assert.Equal(3, Irradiation.FromKilowattHoursPerSquareMeter(joulepersquaremeter.KilowattHoursPerSquareMeter).JoulesPerSquareMeter);
+            Assert.Equal(3, Irradiation.FromMillijoulesPerSquareCentimeter(joulepersquaremeter.MillijoulesPerSquareCentimeter).JoulesPerSquareMeter);
+            Assert.Equal(3, Irradiation.FromWattHoursPerSquareMeter(joulepersquaremeter.WattHoursPerSquareMeter).JoulesPerSquareMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Irradiation v = Irradiation.FromJoulesPerSquareMeter(1);
-            AssertEx.EqualTolerance(-1, -v.JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (Irradiation.FromJoulesPerSquareMeter(3)-v).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (Irradiation.FromJoulesPerSquareMeter(10)/5).JoulesPerSquareMeter, JoulesPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, Irradiation.FromJoulesPerSquareMeter(10)/Irradiation.FromJoulesPerSquareMeter(5), JoulesPerSquareMeterTolerance);
+            Assert.Equal(-1, -v.JoulesPerSquareMeter);
+            Assert.Equal(2, (Irradiation.FromJoulesPerSquareMeter(3) - v).JoulesPerSquareMeter);
+            Assert.Equal(2, (v + v).JoulesPerSquareMeter);
+            Assert.Equal(10, (v * 10).JoulesPerSquareMeter);
+            Assert.Equal(10, (10 * v).JoulesPerSquareMeter);
+            Assert.Equal(2, (Irradiation.FromJoulesPerSquareMeter(10) / 5).JoulesPerSquareMeter);
+            Assert.Equal(2, Irradiation.FromJoulesPerSquareMeter(10) / Irradiation.FromJoulesPerSquareMeter(5));
         }
 
         [Fact]
@@ -614,8 +674,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, IrradiationUnit.JoulePerSquareMeter, 1, IrradiationUnit.JoulePerSquareMeter, true)]  // Same value and unit.
         [InlineData(1, IrradiationUnit.JoulePerSquareMeter, 2, IrradiationUnit.JoulePerSquareMeter, false)] // Different value.
-        [InlineData(2, IrradiationUnit.JoulePerSquareMeter, 1, IrradiationUnit.BtuPerSquareFoot, false)] // Different value and unit.
-        [InlineData(1, IrradiationUnit.JoulePerSquareMeter, 1, IrradiationUnit.BtuPerSquareFoot, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, IrradiationUnit unitA, double valueB, IrradiationUnit unitB, bool expectEqual)
         {
             var a = new Irradiation(valueA, unitA);
@@ -675,8 +733,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Irradiation.FromJoulesPerSquareMeter(firstValue);
             var otherQuantity = Irradiation.FromJoulesPerSquareMeter(secondValue);
             Irradiation maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Irradiation.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -695,7 +753,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<IrradiationUnit>();
+            var units = EnumHelper.GetValues<IrradiationUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -708,6 +766,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Irradiation.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Irradiation.Info.Units, Irradiation.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Irradiation.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -740,26 +810,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 Wh/m²", new Irradiation(1, IrradiationUnit.WattHourPerSquareMeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 J/m²", new Irradiation(0.123456, IrradiationUnit.JoulePerSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 J/m²", new Irradiation(0.123456, IrradiationUnit.JoulePerSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 J/m²", new Irradiation(0.123456, IrradiationUnit.JoulePerSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 J/m²", new Irradiation(0.123456, IrradiationUnit.JoulePerSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 J/m²", new Irradiation(0.123456, IrradiationUnit.JoulePerSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 J/m²", new Irradiation(0.123456, IrradiationUnit.JoulePerSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 J/m²", new Irradiation(0.123456, IrradiationUnit.JoulePerSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 J/m²", new Irradiation(0.123456, IrradiationUnit.JoulePerSquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -786,7 +836,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Irradiation.FromJoulesPerSquareMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Irradiation), quantity.As(Irradiation.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/JerkTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/JerkTestsBase.g.cs
index 9bf5edc18a..f78cee7553 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/JerkTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/JerkTestsBase.g.cs
@@ -165,6 +165,20 @@ public void Jerk_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<JerkUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void JerkInfo_CreateWithCustomUnitInfos()
+        {
+            JerkUnit[] expectedUnits = [JerkUnit.MeterPerSecondCubed];
+
+            Jerk.JerkInfo quantityInfo = Jerk.JerkInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Jerk", quantityInfo.Name);
+            Assert.Equal(Jerk.Zero, quantityInfo.Zero);
+            Assert.Equal(Jerk.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void MeterPerSecondCubedToJerkUnits()
         {
@@ -269,26 +283,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Jerk.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Jerk convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Jerk quantityToConvert = quantity;
+
+                Jerk convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<JerkUnit> quantityToConvert = quantity;
+
+                IQuantity<JerkUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Jerk(value: 1, unit: Jerk.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Jerk(value: 1, unit: Jerk.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<JerkUnit> quantity = new Jerk(value: 1, unit: Jerk.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Jerk(value: 1, unit: Jerk.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Jerk(value: 1, unit: Jerk.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Jerk(value: 1, unit: Jerk.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<JerkUnit> quantity = new Jerk(value: 1, unit: Jerk.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Jerk(value: 1, unit: Jerk.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -314,7 +371,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 мg/s", JerkUnit.MillistandardGravitiesPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 нм/с³", JerkUnit.NanometerPerSecondCubed, 4.2)]
         [InlineData("ru-RU", "4,2 g/s", JerkUnit.StandardGravitiesPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, JerkUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, JerkUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Jerk.Parse(quantityString);
@@ -345,7 +402,7 @@ public void Parse(string culture, string quantityString, JerkUnit expectedUnit,
         [InlineData("ru-RU", "4,2 мg/s", JerkUnit.MillistandardGravitiesPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 нм/с³", JerkUnit.NanometerPerSecondCubed, 4.2)]
         [InlineData("ru-RU", "4,2 g/s", JerkUnit.StandardGravitiesPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, JerkUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, JerkUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Jerk.TryParse(quantityString, out Jerk parsed));
@@ -623,6 +680,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(JerkUnit unit)
                 var quantity = Jerk.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -646,42 +704,44 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(JerkUnit unit)
                 IQuantity<JerkUnit> quantityToConvert = quantity;
                 IQuantity<JerkUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Jerk meterpersecondcubed = Jerk.FromMetersPerSecondCubed(1);
-            AssertEx.EqualTolerance(1, Jerk.FromCentimetersPerSecondCubed(meterpersecondcubed.CentimetersPerSecondCubed).MetersPerSecondCubed, CentimetersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, Jerk.FromDecimetersPerSecondCubed(meterpersecondcubed.DecimetersPerSecondCubed).MetersPerSecondCubed, DecimetersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, Jerk.FromFeetPerSecondCubed(meterpersecondcubed.FeetPerSecondCubed).MetersPerSecondCubed, FeetPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, Jerk.FromInchesPerSecondCubed(meterpersecondcubed.InchesPerSecondCubed).MetersPerSecondCubed, InchesPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, Jerk.FromKilometersPerSecondCubed(meterpersecondcubed.KilometersPerSecondCubed).MetersPerSecondCubed, KilometersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, Jerk.FromMetersPerSecondCubed(meterpersecondcubed.MetersPerSecondCubed).MetersPerSecondCubed, MetersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, Jerk.FromMicrometersPerSecondCubed(meterpersecondcubed.MicrometersPerSecondCubed).MetersPerSecondCubed, MicrometersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, Jerk.FromMillimetersPerSecondCubed(meterpersecondcubed.MillimetersPerSecondCubed).MetersPerSecondCubed, MillimetersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, Jerk.FromMillistandardGravitiesPerSecond(meterpersecondcubed.MillistandardGravitiesPerSecond).MetersPerSecondCubed, MillistandardGravitiesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Jerk.FromNanometersPerSecondCubed(meterpersecondcubed.NanometersPerSecondCubed).MetersPerSecondCubed, NanometersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(1, Jerk.FromStandardGravitiesPerSecond(meterpersecondcubed.StandardGravitiesPerSecond).MetersPerSecondCubed, StandardGravitiesPerSecondTolerance);
+            Jerk meterpersecondcubed = Jerk.FromMetersPerSecondCubed(3);
+            Assert.Equal(3, Jerk.FromCentimetersPerSecondCubed(meterpersecondcubed.CentimetersPerSecondCubed).MetersPerSecondCubed);
+            Assert.Equal(3, Jerk.FromDecimetersPerSecondCubed(meterpersecondcubed.DecimetersPerSecondCubed).MetersPerSecondCubed);
+            Assert.Equal(3, Jerk.FromFeetPerSecondCubed(meterpersecondcubed.FeetPerSecondCubed).MetersPerSecondCubed);
+            Assert.Equal(3, Jerk.FromInchesPerSecondCubed(meterpersecondcubed.InchesPerSecondCubed).MetersPerSecondCubed);
+            Assert.Equal(3, Jerk.FromKilometersPerSecondCubed(meterpersecondcubed.KilometersPerSecondCubed).MetersPerSecondCubed);
+            Assert.Equal(3, Jerk.FromMetersPerSecondCubed(meterpersecondcubed.MetersPerSecondCubed).MetersPerSecondCubed);
+            Assert.Equal(3, Jerk.FromMicrometersPerSecondCubed(meterpersecondcubed.MicrometersPerSecondCubed).MetersPerSecondCubed);
+            Assert.Equal(3, Jerk.FromMillimetersPerSecondCubed(meterpersecondcubed.MillimetersPerSecondCubed).MetersPerSecondCubed);
+            Assert.Equal(3, Jerk.FromMillistandardGravitiesPerSecond(meterpersecondcubed.MillistandardGravitiesPerSecond).MetersPerSecondCubed);
+            Assert.Equal(3, Jerk.FromNanometersPerSecondCubed(meterpersecondcubed.NanometersPerSecondCubed).MetersPerSecondCubed);
+            Assert.Equal(3, Jerk.FromStandardGravitiesPerSecond(meterpersecondcubed.StandardGravitiesPerSecond).MetersPerSecondCubed);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Jerk v = Jerk.FromMetersPerSecondCubed(1);
-            AssertEx.EqualTolerance(-1, -v.MetersPerSecondCubed, MetersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(2, (Jerk.FromMetersPerSecondCubed(3)-v).MetersPerSecondCubed, MetersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(2, (v + v).MetersPerSecondCubed, MetersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(10, (v*10).MetersPerSecondCubed, MetersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(10, (10*v).MetersPerSecondCubed, MetersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(2, (Jerk.FromMetersPerSecondCubed(10)/5).MetersPerSecondCubed, MetersPerSecondCubedTolerance);
-            AssertEx.EqualTolerance(2, Jerk.FromMetersPerSecondCubed(10)/Jerk.FromMetersPerSecondCubed(5), MetersPerSecondCubedTolerance);
+            Assert.Equal(-1, -v.MetersPerSecondCubed);
+            Assert.Equal(2, (Jerk.FromMetersPerSecondCubed(3) - v).MetersPerSecondCubed);
+            Assert.Equal(2, (v + v).MetersPerSecondCubed);
+            Assert.Equal(10, (v * 10).MetersPerSecondCubed);
+            Assert.Equal(10, (10 * v).MetersPerSecondCubed);
+            Assert.Equal(2, (Jerk.FromMetersPerSecondCubed(10) / 5).MetersPerSecondCubed);
+            Assert.Equal(2, Jerk.FromMetersPerSecondCubed(10) / Jerk.FromMetersPerSecondCubed(5));
         }
 
         [Fact]
@@ -727,8 +787,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, JerkUnit.MeterPerSecondCubed, 1, JerkUnit.MeterPerSecondCubed, true)]  // Same value and unit.
         [InlineData(1, JerkUnit.MeterPerSecondCubed, 2, JerkUnit.MeterPerSecondCubed, false)] // Different value.
-        [InlineData(2, JerkUnit.MeterPerSecondCubed, 1, JerkUnit.CentimeterPerSecondCubed, false)] // Different value and unit.
-        [InlineData(1, JerkUnit.MeterPerSecondCubed, 1, JerkUnit.CentimeterPerSecondCubed, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, JerkUnit unitA, double valueB, JerkUnit unitB, bool expectEqual)
         {
             var a = new Jerk(valueA, unitA);
@@ -788,8 +846,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Jerk.FromMetersPerSecondCubed(firstValue);
             var otherQuantity = Jerk.FromMetersPerSecondCubed(secondValue);
             Jerk maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Jerk.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -808,7 +866,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<JerkUnit>();
+            var units = EnumHelper.GetValues<JerkUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -821,6 +879,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Jerk.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Jerk.Info.Units, Jerk.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Jerk.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -857,26 +927,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 g/s", new Jerk(1, JerkUnit.StandardGravitiesPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m/s³", new Jerk(0.123456, JerkUnit.MeterPerSecondCubed).ToString("s1"));
-            Assert.Equal("0.12 m/s³", new Jerk(0.123456, JerkUnit.MeterPerSecondCubed).ToString("s2"));
-            Assert.Equal("0.123 m/s³", new Jerk(0.123456, JerkUnit.MeterPerSecondCubed).ToString("s3"));
-            Assert.Equal("0.1235 m/s³", new Jerk(0.123456, JerkUnit.MeterPerSecondCubed).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m/s³", new Jerk(0.123456, JerkUnit.MeterPerSecondCubed).ToString("s1", culture));
-            Assert.Equal("0.12 m/s³", new Jerk(0.123456, JerkUnit.MeterPerSecondCubed).ToString("s2", culture));
-            Assert.Equal("0.123 m/s³", new Jerk(0.123456, JerkUnit.MeterPerSecondCubed).ToString("s3", culture));
-            Assert.Equal("0.1235 m/s³", new Jerk(0.123456, JerkUnit.MeterPerSecondCubed).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -903,7 +953,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Jerk.FromMetersPerSecondCubed(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Jerk), quantity.As(Jerk.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs
index 3692bbe175..f4b978b544 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/KinematicViscosityTestsBase.g.cs
@@ -157,6 +157,20 @@ public void KinematicViscosity_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
             Assert.Equal(quantityInfo, ((IQuantity<KinematicViscosityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void KinematicViscosityInfo_CreateWithCustomUnitInfos()
+        {
+            KinematicViscosityUnit[] expectedUnits = [KinematicViscosityUnit.SquareMeterPerSecond];
+
+            KinematicViscosity.KinematicViscosityInfo quantityInfo = KinematicViscosity.KinematicViscosityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("KinematicViscosity", quantityInfo.Name);
+            Assert.Equal(KinematicViscosity.Zero, quantityInfo.Zero);
+            Assert.Equal(KinematicViscosity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SquareMeterPerSecondToKinematicViscosityUnits()
         {
@@ -257,26 +271,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = KinematicViscosity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            KinematicViscosity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                KinematicViscosity quantityToConvert = quantity;
+
+                KinematicViscosity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<KinematicViscosityUnit> quantityToConvert = quantity;
+
+                IQuantity<KinematicViscosityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new KinematicViscosity(value: 1, unit: KinematicViscosity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new KinematicViscosity(value: 1, unit: KinematicViscosity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<KinematicViscosityUnit> quantity = new KinematicViscosity(value: 1, unit: KinematicViscosity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new KinematicViscosity(value: 1, unit: KinematicViscosity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new KinematicViscosity(value: 1, unit: KinematicViscosity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new KinematicViscosity(value: 1, unit: KinematicViscosity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<KinematicViscosityUnit> quantity = new KinematicViscosity(value: 1, unit: KinematicViscosity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new KinematicViscosity(value: 1, unit: KinematicViscosity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -297,7 +354,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 нСт", KinematicViscosityUnit.Nanostokes, 4.2)]
         [InlineData("ru-RU", "4,2 м²/с", KinematicViscosityUnit.SquareMeterPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 Ст", KinematicViscosityUnit.Stokes, 4.2)]
-        public void Parse(string culture, string quantityString, KinematicViscosityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, KinematicViscosityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = KinematicViscosity.Parse(quantityString);
@@ -323,7 +380,7 @@ public void Parse(string culture, string quantityString, KinematicViscosityUnit
         [InlineData("ru-RU", "4,2 нСт", KinematicViscosityUnit.Nanostokes, 4.2)]
         [InlineData("ru-RU", "4,2 м²/с", KinematicViscosityUnit.SquareMeterPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 Ст", KinematicViscosityUnit.Stokes, 4.2)]
-        public void TryParse(string culture, string quantityString, KinematicViscosityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, KinematicViscosityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(KinematicViscosity.TryParse(quantityString, out KinematicViscosity parsed));
@@ -568,6 +625,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(KinematicViscosi
                 var quantity = KinematicViscosity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -591,40 +649,42 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(KinematicViscosityU
                 IQuantity<KinematicViscosityUnit> quantityToConvert = quantity;
                 IQuantity<KinematicViscosityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromCentistokes(squaremeterpersecond.Centistokes).SquareMetersPerSecond, CentistokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromDecistokes(squaremeterpersecond.Decistokes).SquareMetersPerSecond, DecistokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromKilostokes(squaremeterpersecond.Kilostokes).SquareMetersPerSecond, KilostokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromMicrostokes(squaremeterpersecond.Microstokes).SquareMetersPerSecond, MicrostokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromMillistokes(squaremeterpersecond.Millistokes).SquareMetersPerSecond, MillistokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromNanostokes(squaremeterpersecond.Nanostokes).SquareMetersPerSecond, NanostokesTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromSquareFeetPerSecond(squaremeterpersecond.SquareFeetPerSecond).SquareMetersPerSecond, SquareFeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromSquareMetersPerSecond(squaremeterpersecond.SquareMetersPerSecond).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, KinematicViscosity.FromStokes(squaremeterpersecond.Stokes).SquareMetersPerSecond, StokesTolerance);
+            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(3);
+            Assert.Equal(3, KinematicViscosity.FromCentistokes(squaremeterpersecond.Centistokes).SquareMetersPerSecond);
+            Assert.Equal(3, KinematicViscosity.FromDecistokes(squaremeterpersecond.Decistokes).SquareMetersPerSecond);
+            Assert.Equal(3, KinematicViscosity.FromKilostokes(squaremeterpersecond.Kilostokes).SquareMetersPerSecond);
+            Assert.Equal(3, KinematicViscosity.FromMicrostokes(squaremeterpersecond.Microstokes).SquareMetersPerSecond);
+            Assert.Equal(3, KinematicViscosity.FromMillistokes(squaremeterpersecond.Millistokes).SquareMetersPerSecond);
+            Assert.Equal(3, KinematicViscosity.FromNanostokes(squaremeterpersecond.Nanostokes).SquareMetersPerSecond);
+            Assert.Equal(3, KinematicViscosity.FromSquareFeetPerSecond(squaremeterpersecond.SquareFeetPerSecond).SquareMetersPerSecond);
+            Assert.Equal(3, KinematicViscosity.FromSquareMetersPerSecond(squaremeterpersecond.SquareMetersPerSecond).SquareMetersPerSecond);
+            Assert.Equal(3, KinematicViscosity.FromStokes(squaremeterpersecond.Stokes).SquareMetersPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             KinematicViscosity v = KinematicViscosity.FromSquareMetersPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (KinematicViscosity.FromSquareMetersPerSecond(3)-v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (KinematicViscosity.FromSquareMetersPerSecond(10)/5).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, KinematicViscosity.FromSquareMetersPerSecond(10)/KinematicViscosity.FromSquareMetersPerSecond(5), SquareMetersPerSecondTolerance);
+            Assert.Equal(-1, -v.SquareMetersPerSecond);
+            Assert.Equal(2, (KinematicViscosity.FromSquareMetersPerSecond(3) - v).SquareMetersPerSecond);
+            Assert.Equal(2, (v + v).SquareMetersPerSecond);
+            Assert.Equal(10, (v * 10).SquareMetersPerSecond);
+            Assert.Equal(10, (10 * v).SquareMetersPerSecond);
+            Assert.Equal(2, (KinematicViscosity.FromSquareMetersPerSecond(10) / 5).SquareMetersPerSecond);
+            Assert.Equal(2, KinematicViscosity.FromSquareMetersPerSecond(10) / KinematicViscosity.FromSquareMetersPerSecond(5));
         }
 
         [Fact]
@@ -670,8 +730,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, KinematicViscosityUnit.SquareMeterPerSecond, 1, KinematicViscosityUnit.SquareMeterPerSecond, true)]  // Same value and unit.
         [InlineData(1, KinematicViscosityUnit.SquareMeterPerSecond, 2, KinematicViscosityUnit.SquareMeterPerSecond, false)] // Different value.
-        [InlineData(2, KinematicViscosityUnit.SquareMeterPerSecond, 1, KinematicViscosityUnit.Centistokes, false)] // Different value and unit.
-        [InlineData(1, KinematicViscosityUnit.SquareMeterPerSecond, 1, KinematicViscosityUnit.Centistokes, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, KinematicViscosityUnit unitA, double valueB, KinematicViscosityUnit unitB, bool expectEqual)
         {
             var a = new KinematicViscosity(valueA, unitA);
@@ -731,8 +789,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = KinematicViscosity.FromSquareMetersPerSecond(firstValue);
             var otherQuantity = KinematicViscosity.FromSquareMetersPerSecond(secondValue);
             KinematicViscosity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, KinematicViscosity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -751,7 +809,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<KinematicViscosityUnit>();
+            var units = EnumHelper.GetValues<KinematicViscosityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -764,6 +822,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(KinematicViscosity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(KinematicViscosity.Info.Units, KinematicViscosity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, KinematicViscosity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -796,26 +866,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 St", new KinematicViscosity(1, KinematicViscosityUnit.Stokes).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m²/s", new KinematicViscosity(0.123456, KinematicViscosityUnit.SquareMeterPerSecond).ToString("s1"));
-            Assert.Equal("0.12 m²/s", new KinematicViscosity(0.123456, KinematicViscosityUnit.SquareMeterPerSecond).ToString("s2"));
-            Assert.Equal("0.123 m²/s", new KinematicViscosity(0.123456, KinematicViscosityUnit.SquareMeterPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 m²/s", new KinematicViscosity(0.123456, KinematicViscosityUnit.SquareMeterPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m²/s", new KinematicViscosity(0.123456, KinematicViscosityUnit.SquareMeterPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 m²/s", new KinematicViscosity(0.123456, KinematicViscosityUnit.SquareMeterPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 m²/s", new KinematicViscosity(0.123456, KinematicViscosityUnit.SquareMeterPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 m²/s", new KinematicViscosity(0.123456, KinematicViscosityUnit.SquareMeterPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -842,7 +892,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = KinematicViscosity.FromSquareMetersPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(KinematicViscosity), quantity.As(KinematicViscosity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LeakRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LeakRateTestsBase.g.cs
index 244629383e..2ec854c24e 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LeakRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LeakRateTestsBase.g.cs
@@ -137,6 +137,20 @@ public void LeakRate_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<LeakRateUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void LeakRateInfo_CreateWithCustomUnitInfos()
+        {
+            LeakRateUnit[] expectedUnits = [LeakRateUnit.PascalCubicMeterPerSecond];
+
+            LeakRate.LeakRateInfo quantityInfo = LeakRate.LeakRateInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("LeakRate", quantityInfo.Name);
+            Assert.Equal(LeakRate.Zero, quantityInfo.Zero);
+            Assert.Equal(LeakRate.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void PascalCubicMeterPerSecondToLeakRateUnits()
         {
@@ -227,26 +241,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = LeakRate.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            LeakRate convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                LeakRate quantityToConvert = quantity;
+
+                LeakRate convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<LeakRateUnit> quantityToConvert = quantity;
+
+                IQuantity<LeakRateUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new LeakRate(value: 1, unit: LeakRate.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new LeakRate(value: 1, unit: LeakRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<LeakRateUnit> quantity = new LeakRate(value: 1, unit: LeakRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new LeakRate(value: 1, unit: LeakRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new LeakRate(value: 1, unit: LeakRate.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new LeakRate(value: 1, unit: LeakRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<LeakRateUnit> quantity = new LeakRate(value: 1, unit: LeakRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new LeakRate(value: 1, unit: LeakRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -254,7 +311,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mbar·l/s", LeakRateUnit.MillibarLiterPerSecond, 4.2)]
         [InlineData("en-US", "4.2 Pa·m³/s", LeakRateUnit.PascalCubicMeterPerSecond, 4.2)]
         [InlineData("en-US", "4.2 Torr·l/s", LeakRateUnit.TorrLiterPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, LeakRateUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, LeakRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = LeakRate.Parse(quantityString);
@@ -267,7 +324,7 @@ public void Parse(string culture, string quantityString, LeakRateUnit expectedUn
         [InlineData("en-US", "4.2 mbar·l/s", LeakRateUnit.MillibarLiterPerSecond, 4.2)]
         [InlineData("en-US", "4.2 Pa·m³/s", LeakRateUnit.PascalCubicMeterPerSecond, 4.2)]
         [InlineData("en-US", "4.2 Torr·l/s", LeakRateUnit.TorrLiterPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, LeakRateUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, LeakRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(LeakRate.TryParse(quantityString, out LeakRate parsed));
@@ -427,6 +484,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(LeakRateUnit uni
                 var quantity = LeakRate.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -450,35 +508,37 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(LeakRateUnit unit)
                 IQuantity<LeakRateUnit> quantityToConvert = quantity;
                 IQuantity<LeakRateUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            LeakRate pascalcubicmeterpersecond = LeakRate.FromPascalCubicMetersPerSecond(1);
-            AssertEx.EqualTolerance(1, LeakRate.FromAtmCubicCentimetersPerSecond(pascalcubicmeterpersecond.AtmCubicCentimetersPerSecond).PascalCubicMetersPerSecond, AtmCubicCentimetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, LeakRate.FromMillibarLitersPerSecond(pascalcubicmeterpersecond.MillibarLitersPerSecond).PascalCubicMetersPerSecond, MillibarLitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, LeakRate.FromPascalCubicMetersPerSecond(pascalcubicmeterpersecond.PascalCubicMetersPerSecond).PascalCubicMetersPerSecond, PascalCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, LeakRate.FromTorrLitersPerSecond(pascalcubicmeterpersecond.TorrLitersPerSecond).PascalCubicMetersPerSecond, TorrLitersPerSecondTolerance);
+            LeakRate pascalcubicmeterpersecond = LeakRate.FromPascalCubicMetersPerSecond(3);
+            Assert.Equal(3, LeakRate.FromAtmCubicCentimetersPerSecond(pascalcubicmeterpersecond.AtmCubicCentimetersPerSecond).PascalCubicMetersPerSecond);
+            Assert.Equal(3, LeakRate.FromMillibarLitersPerSecond(pascalcubicmeterpersecond.MillibarLitersPerSecond).PascalCubicMetersPerSecond);
+            Assert.Equal(3, LeakRate.FromPascalCubicMetersPerSecond(pascalcubicmeterpersecond.PascalCubicMetersPerSecond).PascalCubicMetersPerSecond);
+            Assert.Equal(3, LeakRate.FromTorrLitersPerSecond(pascalcubicmeterpersecond.TorrLitersPerSecond).PascalCubicMetersPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             LeakRate v = LeakRate.FromPascalCubicMetersPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.PascalCubicMetersPerSecond, PascalCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (LeakRate.FromPascalCubicMetersPerSecond(3)-v).PascalCubicMetersPerSecond, PascalCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).PascalCubicMetersPerSecond, PascalCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).PascalCubicMetersPerSecond, PascalCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).PascalCubicMetersPerSecond, PascalCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (LeakRate.FromPascalCubicMetersPerSecond(10)/5).PascalCubicMetersPerSecond, PascalCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, LeakRate.FromPascalCubicMetersPerSecond(10)/LeakRate.FromPascalCubicMetersPerSecond(5), PascalCubicMetersPerSecondTolerance);
+            Assert.Equal(-1, -v.PascalCubicMetersPerSecond);
+            Assert.Equal(2, (LeakRate.FromPascalCubicMetersPerSecond(3) - v).PascalCubicMetersPerSecond);
+            Assert.Equal(2, (v + v).PascalCubicMetersPerSecond);
+            Assert.Equal(10, (v * 10).PascalCubicMetersPerSecond);
+            Assert.Equal(10, (10 * v).PascalCubicMetersPerSecond);
+            Assert.Equal(2, (LeakRate.FromPascalCubicMetersPerSecond(10) / 5).PascalCubicMetersPerSecond);
+            Assert.Equal(2, LeakRate.FromPascalCubicMetersPerSecond(10) / LeakRate.FromPascalCubicMetersPerSecond(5));
         }
 
         [Fact]
@@ -524,8 +584,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, LeakRateUnit.PascalCubicMeterPerSecond, 1, LeakRateUnit.PascalCubicMeterPerSecond, true)]  // Same value and unit.
         [InlineData(1, LeakRateUnit.PascalCubicMeterPerSecond, 2, LeakRateUnit.PascalCubicMeterPerSecond, false)] // Different value.
-        [InlineData(2, LeakRateUnit.PascalCubicMeterPerSecond, 1, LeakRateUnit.AtmCubicCentimeterPerSecond, false)] // Different value and unit.
-        [InlineData(1, LeakRateUnit.PascalCubicMeterPerSecond, 1, LeakRateUnit.AtmCubicCentimeterPerSecond, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, LeakRateUnit unitA, double valueB, LeakRateUnit unitB, bool expectEqual)
         {
             var a = new LeakRate(valueA, unitA);
@@ -585,8 +643,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = LeakRate.FromPascalCubicMetersPerSecond(firstValue);
             var otherQuantity = LeakRate.FromPascalCubicMetersPerSecond(secondValue);
             LeakRate maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, LeakRate.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -605,7 +663,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<LeakRateUnit>();
+            var units = EnumHelper.GetValues<LeakRateUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -618,6 +676,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(LeakRate.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(LeakRate.Info.Units, LeakRate.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, LeakRate.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -640,26 +710,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 Torr·l/s", new LeakRate(1, LeakRateUnit.TorrLiterPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Pa·m³/s", new LeakRate(0.123456, LeakRateUnit.PascalCubicMeterPerSecond).ToString("s1"));
-            Assert.Equal("0.12 Pa·m³/s", new LeakRate(0.123456, LeakRateUnit.PascalCubicMeterPerSecond).ToString("s2"));
-            Assert.Equal("0.123 Pa·m³/s", new LeakRate(0.123456, LeakRateUnit.PascalCubicMeterPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 Pa·m³/s", new LeakRate(0.123456, LeakRateUnit.PascalCubicMeterPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Pa·m³/s", new LeakRate(0.123456, LeakRateUnit.PascalCubicMeterPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 Pa·m³/s", new LeakRate(0.123456, LeakRateUnit.PascalCubicMeterPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 Pa·m³/s", new LeakRate(0.123456, LeakRateUnit.PascalCubicMeterPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 Pa·m³/s", new LeakRate(0.123456, LeakRateUnit.PascalCubicMeterPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -686,7 +736,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = LeakRate.FromPascalCubicMetersPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(LeakRate), quantity.As(LeakRate.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs
index 85dba00fd2..4747f3c4fb 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LengthTestsBase.g.cs
@@ -289,6 +289,20 @@ public void Length_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<LengthUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void LengthInfo_CreateWithCustomUnitInfos()
+        {
+            LengthUnit[] expectedUnits = [LengthUnit.Meter];
+
+            Length.LengthInfo quantityInfo = Length.LengthInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Length", quantityInfo.Name);
+            Assert.Equal(Length.Zero, quantityInfo.Zero);
+            Assert.Equal(Length.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void MeterToLengthUnits()
         {
@@ -455,26 +469,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Length.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Length convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Length quantityToConvert = quantity;
+
+                Length convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<LengthUnit> quantityToConvert = quantity;
+
+                IQuantity<LengthUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Length(value: 1, unit: Length.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Length(value: 1, unit: Length.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<LengthUnit> quantity = new Length(value: 1, unit: Length.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Length(value: 1, unit: Length.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Length(value: 1, unit: Length.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Length(value: 1, unit: Length.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<LengthUnit> quantity = new Length(value: 1, unit: Length.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Length(value: 1, unit: Length.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -566,7 +623,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("zh-CN", "4.2 毫米", LengthUnit.Millimeter, 4.2)]
         [InlineData("zh-CN", "4.2 皮米", LengthUnit.Picometer, 4.2)]
         [InlineData("zh-CN", "4.2 码", LengthUnit.Yard, 4.2)]
-        public void Parse(string culture, string quantityString, LengthUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, LengthUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Length.Parse(quantityString);
@@ -673,7 +730,7 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("zh-CN", "4.2 毫米", LengthUnit.Millimeter, 4.2)]
         [InlineData("zh-CN", "4.2 皮米", LengthUnit.Picometer, 4.2)]
         [InlineData("zh-CN", "4.2 码", LengthUnit.Yard, 4.2)]
-        public void TryParse(string culture, string quantityString, LengthUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, LengthUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Length.TryParse(quantityString, out Length parsed));
@@ -1457,6 +1514,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(LengthUnit unit)
                 var quantity = Length.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1480,73 +1538,75 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(LengthUnit unit)
                 IQuantity<LengthUnit> quantityToConvert = quantity;
                 IQuantity<LengthUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Length meter = Length.FromMeters(1);
-            AssertEx.EqualTolerance(1, Length.FromAngstroms(meter.Angstroms).Meters, AngstromsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromAstronomicalUnits(meter.AstronomicalUnits).Meters, AstronomicalUnitsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromCentimeters(meter.Centimeters).Meters, CentimetersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromChains(meter.Chains).Meters, ChainsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromDataMiles(meter.DataMiles).Meters, DataMilesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromDecameters(meter.Decameters).Meters, DecametersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromDecimeters(meter.Decimeters).Meters, DecimetersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromDtpPicas(meter.DtpPicas).Meters, DtpPicasTolerance);
-            AssertEx.EqualTolerance(1, Length.FromDtpPoints(meter.DtpPoints).Meters, DtpPointsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromFathoms(meter.Fathoms).Meters, FathomsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromFemtometers(meter.Femtometers).Meters, FemtometersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromFeet(meter.Feet).Meters, FeetTolerance);
-            AssertEx.EqualTolerance(1, Length.FromGigameters(meter.Gigameters).Meters, GigametersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromHands(meter.Hands).Meters, HandsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromHectometers(meter.Hectometers).Meters, HectometersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromInches(meter.Inches).Meters, InchesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromKilofeet(meter.Kilofeet).Meters, KilofeetTolerance);
-            AssertEx.EqualTolerance(1, Length.FromKilolightYears(meter.KilolightYears).Meters, KilolightYearsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromKilometers(meter.Kilometers).Meters, KilometersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromKiloparsecs(meter.Kiloparsecs).Meters, KiloparsecsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromKiloyards(meter.Kiloyards).Meters, KiloyardsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromLightYears(meter.LightYears).Meters, LightYearsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMegalightYears(meter.MegalightYears).Meters, MegalightYearsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMegameters(meter.Megameters).Meters, MegametersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMegaparsecs(meter.Megaparsecs).Meters, MegaparsecsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMeters(meter.Meters).Meters, MetersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMicroinches(meter.Microinches).Meters, MicroinchesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMicrometers(meter.Micrometers).Meters, MicrometersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMils(meter.Mils).Meters, MilsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMiles(meter.Miles).Meters, MilesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromMillimeters(meter.Millimeters).Meters, MillimetersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromNanometers(meter.Nanometers).Meters, NanometersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromNauticalMiles(meter.NauticalMiles).Meters, NauticalMilesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromParsecs(meter.Parsecs).Meters, ParsecsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromPicometers(meter.Picometers).Meters, PicometersTolerance);
-            AssertEx.EqualTolerance(1, Length.FromPrinterPicas(meter.PrinterPicas).Meters, PrinterPicasTolerance);
-            AssertEx.EqualTolerance(1, Length.FromPrinterPoints(meter.PrinterPoints).Meters, PrinterPointsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromShackles(meter.Shackles).Meters, ShacklesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromSolarRadiuses(meter.SolarRadiuses).Meters, SolarRadiusesTolerance);
-            AssertEx.EqualTolerance(1, Length.FromTwips(meter.Twips).Meters, TwipsTolerance);
-            AssertEx.EqualTolerance(1, Length.FromUsSurveyFeet(meter.UsSurveyFeet).Meters, UsSurveyFeetTolerance);
-            AssertEx.EqualTolerance(1, Length.FromYards(meter.Yards).Meters, YardsTolerance);
+            Length meter = Length.FromMeters(3);
+            Assert.Equal(3, Length.FromAngstroms(meter.Angstroms).Meters);
+            Assert.Equal(3, Length.FromAstronomicalUnits(meter.AstronomicalUnits).Meters);
+            Assert.Equal(3, Length.FromCentimeters(meter.Centimeters).Meters);
+            Assert.Equal(3, Length.FromChains(meter.Chains).Meters);
+            Assert.Equal(3, Length.FromDataMiles(meter.DataMiles).Meters);
+            Assert.Equal(3, Length.FromDecameters(meter.Decameters).Meters);
+            Assert.Equal(3, Length.FromDecimeters(meter.Decimeters).Meters);
+            Assert.Equal(3, Length.FromDtpPicas(meter.DtpPicas).Meters);
+            Assert.Equal(3, Length.FromDtpPoints(meter.DtpPoints).Meters);
+            Assert.Equal(3, Length.FromFathoms(meter.Fathoms).Meters);
+            Assert.Equal(3, Length.FromFemtometers(meter.Femtometers).Meters);
+            Assert.Equal(3, Length.FromFeet(meter.Feet).Meters);
+            Assert.Equal(3, Length.FromGigameters(meter.Gigameters).Meters);
+            Assert.Equal(3, Length.FromHands(meter.Hands).Meters);
+            Assert.Equal(3, Length.FromHectometers(meter.Hectometers).Meters);
+            Assert.Equal(3, Length.FromInches(meter.Inches).Meters);
+            Assert.Equal(3, Length.FromKilofeet(meter.Kilofeet).Meters);
+            Assert.Equal(3, Length.FromKilolightYears(meter.KilolightYears).Meters);
+            Assert.Equal(3, Length.FromKilometers(meter.Kilometers).Meters);
+            Assert.Equal(3, Length.FromKiloparsecs(meter.Kiloparsecs).Meters);
+            Assert.Equal(3, Length.FromKiloyards(meter.Kiloyards).Meters);
+            Assert.Equal(3, Length.FromLightYears(meter.LightYears).Meters);
+            Assert.Equal(3, Length.FromMegalightYears(meter.MegalightYears).Meters);
+            Assert.Equal(3, Length.FromMegameters(meter.Megameters).Meters);
+            Assert.Equal(3, Length.FromMegaparsecs(meter.Megaparsecs).Meters);
+            Assert.Equal(3, Length.FromMeters(meter.Meters).Meters);
+            Assert.Equal(3, Length.FromMicroinches(meter.Microinches).Meters);
+            Assert.Equal(3, Length.FromMicrometers(meter.Micrometers).Meters);
+            Assert.Equal(3, Length.FromMils(meter.Mils).Meters);
+            Assert.Equal(3, Length.FromMiles(meter.Miles).Meters);
+            Assert.Equal(3, Length.FromMillimeters(meter.Millimeters).Meters);
+            Assert.Equal(3, Length.FromNanometers(meter.Nanometers).Meters);
+            Assert.Equal(3, Length.FromNauticalMiles(meter.NauticalMiles).Meters);
+            Assert.Equal(3, Length.FromParsecs(meter.Parsecs).Meters);
+            Assert.Equal(3, Length.FromPicometers(meter.Picometers).Meters);
+            Assert.Equal(3, Length.FromPrinterPicas(meter.PrinterPicas).Meters);
+            Assert.Equal(3, Length.FromPrinterPoints(meter.PrinterPoints).Meters);
+            Assert.Equal(3, Length.FromShackles(meter.Shackles).Meters);
+            Assert.Equal(3, Length.FromSolarRadiuses(meter.SolarRadiuses).Meters);
+            Assert.Equal(3, Length.FromTwips(meter.Twips).Meters);
+            Assert.Equal(3, Length.FromUsSurveyFeet(meter.UsSurveyFeet).Meters);
+            Assert.Equal(3, Length.FromYards(meter.Yards).Meters);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Length v = Length.FromMeters(1);
-            AssertEx.EqualTolerance(-1, -v.Meters, MetersTolerance);
-            AssertEx.EqualTolerance(2, (Length.FromMeters(3)-v).Meters, MetersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Meters, MetersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Meters, MetersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Meters, MetersTolerance);
-            AssertEx.EqualTolerance(2, (Length.FromMeters(10)/5).Meters, MetersTolerance);
-            AssertEx.EqualTolerance(2, Length.FromMeters(10)/Length.FromMeters(5), MetersTolerance);
+            Assert.Equal(-1, -v.Meters);
+            Assert.Equal(2, (Length.FromMeters(3) - v).Meters);
+            Assert.Equal(2, (v + v).Meters);
+            Assert.Equal(10, (v * 10).Meters);
+            Assert.Equal(10, (10 * v).Meters);
+            Assert.Equal(2, (Length.FromMeters(10) / 5).Meters);
+            Assert.Equal(2, Length.FromMeters(10) / Length.FromMeters(5));
         }
 
         [Fact]
@@ -1592,8 +1652,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, LengthUnit.Meter, 1, LengthUnit.Meter, true)]  // Same value and unit.
         [InlineData(1, LengthUnit.Meter, 2, LengthUnit.Meter, false)] // Different value.
-        [InlineData(2, LengthUnit.Meter, 1, LengthUnit.Angstrom, false)] // Different value and unit.
-        [InlineData(1, LengthUnit.Meter, 1, LengthUnit.Angstrom, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, LengthUnit unitA, double valueB, LengthUnit unitB, bool expectEqual)
         {
             var a = new Length(valueA, unitA);
@@ -1653,8 +1711,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Length.FromMeters(firstValue);
             var otherQuantity = Length.FromMeters(secondValue);
             Length maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Length.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1673,7 +1731,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<LengthUnit>();
+            var units = EnumHelper.GetValues<LengthUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1686,6 +1744,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Length.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Length.Info.Units, Length.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Length.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1784,26 +1854,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 yd", new Length(1, LengthUnit.Yard).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m", new Length(0.123456, LengthUnit.Meter).ToString("s1"));
-            Assert.Equal("0.12 m", new Length(0.123456, LengthUnit.Meter).ToString("s2"));
-            Assert.Equal("0.123 m", new Length(0.123456, LengthUnit.Meter).ToString("s3"));
-            Assert.Equal("0.1235 m", new Length(0.123456, LengthUnit.Meter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m", new Length(0.123456, LengthUnit.Meter).ToString("s1", culture));
-            Assert.Equal("0.12 m", new Length(0.123456, LengthUnit.Meter).ToString("s2", culture));
-            Assert.Equal("0.123 m", new Length(0.123456, LengthUnit.Meter).ToString("s3", culture));
-            Assert.Equal("0.1235 m", new Length(0.123456, LengthUnit.Meter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1830,7 +1880,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Length.FromMeters(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Length), quantity.As(Length.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LevelTestsBase.g.cs
index 82674f5d14..cad9796a30 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LevelTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LevelTestsBase.g.cs
@@ -108,6 +108,20 @@ public void Level_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<LevelUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void LevelInfo_CreateWithCustomUnitInfos()
+        {
+            LevelUnit[] expectedUnits = [LevelUnit.Decibel];
+
+            Level.LevelInfo quantityInfo = Level.LevelInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Level", quantityInfo.Name);
+            Assert.Equal(Level.Zero, quantityInfo.Zero);
+            Assert.Equal(Level.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void DecibelToLevelUnits()
         {
@@ -174,12 +188,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new Level(value: 1, unit: LevelUnit.Decibel);
+            Assert.Multiple(() =>
+            {
+                var quantity = new Level(value: 1, unit: LevelUnit.Decibel);
+
+                Level convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(LevelUnit.Decibel, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<LevelUnit> quantity = new Level(value: 1, unit: LevelUnit.Decibel);
+
+                IQuantity<LevelUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(LevelUnit.Decibel, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new Level(value: 1, unit: LevelUnit.Decibel);
 
-            Level convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(LevelUnit.Decibel, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(LevelUnit.Decibel, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -204,7 +237,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Theory]
         [InlineData("en-US", "4.2 dB", LevelUnit.Decibel, 4.2)]
         [InlineData("en-US", "4.2 Np", LevelUnit.Neper, 4.2)]
-        public void Parse(string culture, string quantityString, LevelUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, LevelUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Level.Parse(quantityString);
@@ -215,7 +248,7 @@ public void Parse(string culture, string quantityString, LevelUnit expectedUnit,
         [Theory]
         [InlineData("en-US", "4.2 dB", LevelUnit.Decibel, 4.2)]
         [InlineData("en-US", "4.2 Np", LevelUnit.Neper, 4.2)]
-        public void TryParse(string culture, string quantityString, LevelUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, LevelUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Level.TryParse(quantityString, out Level parsed));
@@ -357,6 +390,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(LevelUnit unit)
                 var quantity = Level.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -380,33 +414,35 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(LevelUnit unit)
                 IQuantity<LevelUnit> quantityToConvert = quantity;
                 IQuantity<LevelUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Level decibel = Level.FromDecibels(1);
-            AssertEx.EqualTolerance(1, Level.FromDecibels(decibel.Decibels).Decibels, DecibelsTolerance);
-            AssertEx.EqualTolerance(1, Level.FromNepers(decibel.Nepers).Decibels, NepersTolerance);
+            Level decibel = Level.FromDecibels(3);
+            Assert.Equal(3, Level.FromDecibels(decibel.Decibels).Decibels);
+            Assert.Equal(3, Level.FromNepers(decibel.Nepers).Decibels);
         }
 
         [Fact]
         public void LogarithmicArithmeticOperators()
         {
             Level v = Level.FromDecibels(40);
-            AssertEx.EqualTolerance(-40, -v.Decibels, NepersTolerance);
+            Assert.Equal(-40, -v.Decibels);
             AssertLogarithmicAddition();
             AssertLogarithmicSubtraction();
-            AssertEx.EqualTolerance(50, (v*10).Decibels, NepersTolerance);
-            AssertEx.EqualTolerance(50, (10*v).Decibels, NepersTolerance);
-            AssertEx.EqualTolerance(35, (v/5).Decibels, NepersTolerance);
-            AssertEx.EqualTolerance(35, v/Level.FromDecibels(5), NepersTolerance);
+            Assert.Equal(50, (v * 10).Decibels);
+            Assert.Equal(50, (10 * v).Decibels);
+            Assert.Equal(35, (v / 5).Decibels);
+            Assert.Equal(35, v / Level.FromDecibels(5));
         }
 
         protected abstract void AssertLogarithmicAddition();
@@ -456,8 +492,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, LevelUnit.Decibel, 1, LevelUnit.Decibel, true)]  // Same value and unit.
         [InlineData(1, LevelUnit.Decibel, 2, LevelUnit.Decibel, false)] // Different value.
-        [InlineData(2, LevelUnit.Decibel, 1, LevelUnit.Neper, false)] // Different value and unit.
-        [InlineData(1, LevelUnit.Decibel, 1, LevelUnit.Neper, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, LevelUnit unitA, double valueB, LevelUnit unitB, bool expectEqual)
         {
             var a = new Level(valueA, unitA);
@@ -517,8 +551,8 @@ public void Equals_Logarithmic_WithTolerance(double firstValue, double secondVal
             var quantity = Level.FromDecibels(firstValue);
             var otherQuantity = Level.FromDecibels(secondValue);
             Level maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Level.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, largerTolerance));
@@ -539,7 +573,7 @@ public void Equals_Logarithmic_WithNegativeTolerance_DoesNotThrowArgumentOutOfRa
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<LevelUnit>();
+            var units = EnumHelper.GetValues<LevelUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -552,6 +586,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Level.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Level.Info.Units, Level.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Level.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -570,26 +616,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 Np", new Level(1, LevelUnit.Neper).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 dB", new Level(0.123456, LevelUnit.Decibel).ToString("s1"));
-            Assert.Equal("0.12 dB", new Level(0.123456, LevelUnit.Decibel).ToString("s2"));
-            Assert.Equal("0.123 dB", new Level(0.123456, LevelUnit.Decibel).ToString("s3"));
-            Assert.Equal("0.1235 dB", new Level(0.123456, LevelUnit.Decibel).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 dB", new Level(0.123456, LevelUnit.Decibel).ToString("s1", culture));
-            Assert.Equal("0.12 dB", new Level(0.123456, LevelUnit.Decibel).ToString("s2", culture));
-            Assert.Equal("0.123 dB", new Level(0.123456, LevelUnit.Decibel).ToString("s3", culture));
-            Assert.Equal("0.1235 dB", new Level(0.123456, LevelUnit.Decibel).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -616,7 +642,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Level.FromDecibels(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Level), quantity.As(Level.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs
index 2c915411ce..5821d007b6 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearDensityTestsBase.g.cs
@@ -193,6 +193,20 @@ public void LinearDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<LinearDensityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void LinearDensityInfo_CreateWithCustomUnitInfos()
+        {
+            LinearDensityUnit[] expectedUnits = [LinearDensityUnit.KilogramPerMeter];
+
+            LinearDensity.LinearDensityInfo quantityInfo = LinearDensity.LinearDensityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("LinearDensity", quantityInfo.Name);
+            Assert.Equal(LinearDensity.Zero, quantityInfo.Zero);
+            Assert.Equal(LinearDensity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KilogramPerMeterToLinearDensityUnits()
         {
@@ -311,26 +325,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = LinearDensity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            LinearDensity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                LinearDensity quantityToConvert = quantity;
+
+                LinearDensity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<LinearDensityUnit> quantityToConvert = quantity;
+
+                IQuantity<LinearDensityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new LinearDensity(value: 1, unit: LinearDensity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new LinearDensity(value: 1, unit: LinearDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<LinearDensityUnit> quantity = new LinearDensity(value: 1, unit: LinearDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new LinearDensity(value: 1, unit: LinearDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new LinearDensity(value: 1, unit: LinearDensity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new LinearDensity(value: 1, unit: LinearDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<LinearDensityUnit> quantity = new LinearDensity(value: 1, unit: LinearDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new LinearDensity(value: 1, unit: LinearDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -352,7 +409,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mg/mm", LinearDensityUnit.MilligramPerMillimeter, 4.2)]
         [InlineData("en-US", "4.2 lb/ft", LinearDensityUnit.PoundPerFoot, 4.2)]
         [InlineData("en-US", "4.2 lb/in", LinearDensityUnit.PoundPerInch, 4.2)]
-        public void Parse(string culture, string quantityString, LinearDensityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, LinearDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = LinearDensity.Parse(quantityString);
@@ -379,7 +436,7 @@ public void Parse(string culture, string quantityString, LinearDensityUnit expec
         [InlineData("en-US", "4.2 mg/mm", LinearDensityUnit.MilligramPerMillimeter, 4.2)]
         [InlineData("en-US", "4.2 lb/ft", LinearDensityUnit.PoundPerFoot, 4.2)]
         [InlineData("en-US", "4.2 lb/in", LinearDensityUnit.PoundPerInch, 4.2)]
-        public void TryParse(string culture, string quantityString, LinearDensityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, LinearDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(LinearDensity.TryParse(quantityString, out LinearDensity parsed));
@@ -665,6 +722,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(LinearDensityUni
                 var quantity = LinearDensity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -688,49 +746,51 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(LinearDensityUnit u
                 IQuantity<LinearDensityUnit> quantityToConvert = quantity;
                 IQuantity<LinearDensityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            LinearDensity kilogrampermeter = LinearDensity.FromKilogramsPerMeter(1);
-            AssertEx.EqualTolerance(1, LinearDensity.FromGramsPerCentimeter(kilogrampermeter.GramsPerCentimeter).KilogramsPerMeter, GramsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromGramsPerFoot(kilogrampermeter.GramsPerFoot).KilogramsPerMeter, GramsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromGramsPerMeter(kilogrampermeter.GramsPerMeter).KilogramsPerMeter, GramsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromGramsPerMillimeter(kilogrampermeter.GramsPerMillimeter).KilogramsPerMeter, GramsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromKilogramsPerCentimeter(kilogrampermeter.KilogramsPerCentimeter).KilogramsPerMeter, KilogramsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromKilogramsPerFoot(kilogrampermeter.KilogramsPerFoot).KilogramsPerMeter, KilogramsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromKilogramsPerMeter(kilogrampermeter.KilogramsPerMeter).KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromKilogramsPerMillimeter(kilogrampermeter.KilogramsPerMillimeter).KilogramsPerMeter, KilogramsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMicrogramsPerCentimeter(kilogrampermeter.MicrogramsPerCentimeter).KilogramsPerMeter, MicrogramsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMicrogramsPerFoot(kilogrampermeter.MicrogramsPerFoot).KilogramsPerMeter, MicrogramsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMicrogramsPerMeter(kilogrampermeter.MicrogramsPerMeter).KilogramsPerMeter, MicrogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMicrogramsPerMillimeter(kilogrampermeter.MicrogramsPerMillimeter).KilogramsPerMeter, MicrogramsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMilligramsPerCentimeter(kilogrampermeter.MilligramsPerCentimeter).KilogramsPerMeter, MilligramsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMilligramsPerFoot(kilogrampermeter.MilligramsPerFoot).KilogramsPerMeter, MilligramsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMilligramsPerMeter(kilogrampermeter.MilligramsPerMeter).KilogramsPerMeter, MilligramsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromMilligramsPerMillimeter(kilogrampermeter.MilligramsPerMillimeter).KilogramsPerMeter, MilligramsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromPoundsPerFoot(kilogrampermeter.PoundsPerFoot).KilogramsPerMeter, PoundsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearDensity.FromPoundsPerInch(kilogrampermeter.PoundsPerInch).KilogramsPerMeter, PoundsPerInchTolerance);
+            LinearDensity kilogrampermeter = LinearDensity.FromKilogramsPerMeter(3);
+            Assert.Equal(3, LinearDensity.FromGramsPerCentimeter(kilogrampermeter.GramsPerCentimeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromGramsPerFoot(kilogrampermeter.GramsPerFoot).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromGramsPerMeter(kilogrampermeter.GramsPerMeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromGramsPerMillimeter(kilogrampermeter.GramsPerMillimeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromKilogramsPerCentimeter(kilogrampermeter.KilogramsPerCentimeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromKilogramsPerFoot(kilogrampermeter.KilogramsPerFoot).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromKilogramsPerMeter(kilogrampermeter.KilogramsPerMeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromKilogramsPerMillimeter(kilogrampermeter.KilogramsPerMillimeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromMicrogramsPerCentimeter(kilogrampermeter.MicrogramsPerCentimeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromMicrogramsPerFoot(kilogrampermeter.MicrogramsPerFoot).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromMicrogramsPerMeter(kilogrampermeter.MicrogramsPerMeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromMicrogramsPerMillimeter(kilogrampermeter.MicrogramsPerMillimeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromMilligramsPerCentimeter(kilogrampermeter.MilligramsPerCentimeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromMilligramsPerFoot(kilogrampermeter.MilligramsPerFoot).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromMilligramsPerMeter(kilogrampermeter.MilligramsPerMeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromMilligramsPerMillimeter(kilogrampermeter.MilligramsPerMillimeter).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromPoundsPerFoot(kilogrampermeter.PoundsPerFoot).KilogramsPerMeter);
+            Assert.Equal(3, LinearDensity.FromPoundsPerInch(kilogrampermeter.PoundsPerInch).KilogramsPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             LinearDensity v = LinearDensity.FromKilogramsPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (LinearDensity.FromKilogramsPerMeter(3)-v).KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (LinearDensity.FromKilogramsPerMeter(10)/5).KilogramsPerMeter, KilogramsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, LinearDensity.FromKilogramsPerMeter(10)/LinearDensity.FromKilogramsPerMeter(5), KilogramsPerMeterTolerance);
+            Assert.Equal(-1, -v.KilogramsPerMeter);
+            Assert.Equal(2, (LinearDensity.FromKilogramsPerMeter(3) - v).KilogramsPerMeter);
+            Assert.Equal(2, (v + v).KilogramsPerMeter);
+            Assert.Equal(10, (v * 10).KilogramsPerMeter);
+            Assert.Equal(10, (10 * v).KilogramsPerMeter);
+            Assert.Equal(2, (LinearDensity.FromKilogramsPerMeter(10) / 5).KilogramsPerMeter);
+            Assert.Equal(2, LinearDensity.FromKilogramsPerMeter(10) / LinearDensity.FromKilogramsPerMeter(5));
         }
 
         [Fact]
@@ -776,8 +836,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, LinearDensityUnit.KilogramPerMeter, 1, LinearDensityUnit.KilogramPerMeter, true)]  // Same value and unit.
         [InlineData(1, LinearDensityUnit.KilogramPerMeter, 2, LinearDensityUnit.KilogramPerMeter, false)] // Different value.
-        [InlineData(2, LinearDensityUnit.KilogramPerMeter, 1, LinearDensityUnit.GramPerCentimeter, false)] // Different value and unit.
-        [InlineData(1, LinearDensityUnit.KilogramPerMeter, 1, LinearDensityUnit.GramPerCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, LinearDensityUnit unitA, double valueB, LinearDensityUnit unitB, bool expectEqual)
         {
             var a = new LinearDensity(valueA, unitA);
@@ -837,8 +895,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = LinearDensity.FromKilogramsPerMeter(firstValue);
             var otherQuantity = LinearDensity.FromKilogramsPerMeter(secondValue);
             LinearDensity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, LinearDensity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -857,7 +915,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<LinearDensityUnit>();
+            var units = EnumHelper.GetValues<LinearDensityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -870,6 +928,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(LinearDensity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(LinearDensity.Info.Units, LinearDensity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, LinearDensity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -920,26 +990,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 lb/in", new LinearDensity(1, LinearDensityUnit.PoundPerInch).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 kg/m", new LinearDensity(0.123456, LinearDensityUnit.KilogramPerMeter).ToString("s1"));
-            Assert.Equal("0.12 kg/m", new LinearDensity(0.123456, LinearDensityUnit.KilogramPerMeter).ToString("s2"));
-            Assert.Equal("0.123 kg/m", new LinearDensity(0.123456, LinearDensityUnit.KilogramPerMeter).ToString("s3"));
-            Assert.Equal("0.1235 kg/m", new LinearDensity(0.123456, LinearDensityUnit.KilogramPerMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 kg/m", new LinearDensity(0.123456, LinearDensityUnit.KilogramPerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 kg/m", new LinearDensity(0.123456, LinearDensityUnit.KilogramPerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 kg/m", new LinearDensity(0.123456, LinearDensityUnit.KilogramPerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 kg/m", new LinearDensity(0.123456, LinearDensityUnit.KilogramPerMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -966,7 +1016,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = LinearDensity.FromKilogramsPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(LinearDensity), quantity.As(LinearDensity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs
index bf9050a371..4379977ec2 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs
@@ -221,6 +221,20 @@ public void LinearPowerDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
             Assert.Equal(quantityInfo, ((IQuantity<LinearPowerDensityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void LinearPowerDensityInfo_CreateWithCustomUnitInfos()
+        {
+            LinearPowerDensityUnit[] expectedUnits = [LinearPowerDensityUnit.WattPerMeter];
+
+            LinearPowerDensity.LinearPowerDensityInfo quantityInfo = LinearPowerDensity.LinearPowerDensityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("LinearPowerDensity", quantityInfo.Name);
+            Assert.Equal(LinearPowerDensity.Zero, quantityInfo.Zero);
+            Assert.Equal(LinearPowerDensity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void WattPerMeterToLinearPowerDensityUnits()
         {
@@ -353,26 +367,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = LinearPowerDensity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            LinearPowerDensity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                LinearPowerDensity quantityToConvert = quantity;
+
+                LinearPowerDensity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<LinearPowerDensityUnit> quantityToConvert = quantity;
+
+                IQuantity<LinearPowerDensityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new LinearPowerDensity(value: 1, unit: LinearPowerDensity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new LinearPowerDensity(value: 1, unit: LinearPowerDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<LinearPowerDensityUnit> quantity = new LinearPowerDensity(value: 1, unit: LinearPowerDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new LinearPowerDensity(value: 1, unit: LinearPowerDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new LinearPowerDensity(value: 1, unit: LinearPowerDensity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new LinearPowerDensity(value: 1, unit: LinearPowerDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<LinearPowerDensityUnit> quantity = new LinearPowerDensity(value: 1, unit: LinearPowerDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new LinearPowerDensity(value: 1, unit: LinearPowerDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -401,7 +458,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 W/in", LinearPowerDensityUnit.WattPerInch, 4.2)]
         [InlineData("en-US", "4.2 W/m", LinearPowerDensityUnit.WattPerMeter, 4.2)]
         [InlineData("en-US", "4.2 W/mm", LinearPowerDensityUnit.WattPerMillimeter, 4.2)]
-        public void Parse(string culture, string quantityString, LinearPowerDensityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, LinearPowerDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = LinearPowerDensity.Parse(quantityString);
@@ -435,7 +492,7 @@ public void Parse(string culture, string quantityString, LinearPowerDensityUnit
         [InlineData("en-US", "4.2 W/in", LinearPowerDensityUnit.WattPerInch, 4.2)]
         [InlineData("en-US", "4.2 W/m", LinearPowerDensityUnit.WattPerMeter, 4.2)]
         [InlineData("en-US", "4.2 W/mm", LinearPowerDensityUnit.WattPerMillimeter, 4.2)]
-        public void TryParse(string culture, string quantityString, LinearPowerDensityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, LinearPowerDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(LinearPowerDensity.TryParse(quantityString, out LinearPowerDensity parsed));
@@ -784,6 +841,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(LinearPowerDensi
                 var quantity = LinearPowerDensity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -807,56 +865,58 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(LinearPowerDensityU
                 IQuantity<LinearPowerDensityUnit> quantityToConvert = quantity;
                 IQuantity<LinearPowerDensityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerCentimeter(wattpermeter.GigawattsPerCentimeter).WattsPerMeter, GigawattsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerFoot(wattpermeter.GigawattsPerFoot).WattsPerMeter, GigawattsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerInch(wattpermeter.GigawattsPerInch).WattsPerMeter, GigawattsPerInchTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerMeter(wattpermeter.GigawattsPerMeter).WattsPerMeter, GigawattsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerMillimeter(wattpermeter.GigawattsPerMillimeter).WattsPerMeter, GigawattsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerCentimeter(wattpermeter.KilowattsPerCentimeter).WattsPerMeter, KilowattsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerFoot(wattpermeter.KilowattsPerFoot).WattsPerMeter, KilowattsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerInch(wattpermeter.KilowattsPerInch).WattsPerMeter, KilowattsPerInchTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerMeter(wattpermeter.KilowattsPerMeter).WattsPerMeter, KilowattsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerMillimeter(wattpermeter.KilowattsPerMillimeter).WattsPerMeter, KilowattsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerCentimeter(wattpermeter.MegawattsPerCentimeter).WattsPerMeter, MegawattsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerFoot(wattpermeter.MegawattsPerFoot).WattsPerMeter, MegawattsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerInch(wattpermeter.MegawattsPerInch).WattsPerMeter, MegawattsPerInchTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerMeter(wattpermeter.MegawattsPerMeter).WattsPerMeter, MegawattsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerMillimeter(wattpermeter.MegawattsPerMillimeter).WattsPerMeter, MegawattsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerCentimeter(wattpermeter.MilliwattsPerCentimeter).WattsPerMeter, MilliwattsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerFoot(wattpermeter.MilliwattsPerFoot).WattsPerMeter, MilliwattsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerInch(wattpermeter.MilliwattsPerInch).WattsPerMeter, MilliwattsPerInchTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerMeter(wattpermeter.MilliwattsPerMeter).WattsPerMeter, MilliwattsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerMillimeter(wattpermeter.MilliwattsPerMillimeter).WattsPerMeter, MilliwattsPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerCentimeter(wattpermeter.WattsPerCentimeter).WattsPerMeter, WattsPerCentimeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerFoot(wattpermeter.WattsPerFoot).WattsPerMeter, WattsPerFootTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerInch(wattpermeter.WattsPerInch).WattsPerMeter, WattsPerInchTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerMeter(wattpermeter.WattsPerMeter).WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerMillimeter(wattpermeter.WattsPerMillimeter).WattsPerMeter, WattsPerMillimeterTolerance);
+            LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(3);
+            Assert.Equal(3, LinearPowerDensity.FromGigawattsPerCentimeter(wattpermeter.GigawattsPerCentimeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromGigawattsPerFoot(wattpermeter.GigawattsPerFoot).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromGigawattsPerInch(wattpermeter.GigawattsPerInch).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromGigawattsPerMeter(wattpermeter.GigawattsPerMeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromGigawattsPerMillimeter(wattpermeter.GigawattsPerMillimeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromKilowattsPerCentimeter(wattpermeter.KilowattsPerCentimeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromKilowattsPerFoot(wattpermeter.KilowattsPerFoot).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromKilowattsPerInch(wattpermeter.KilowattsPerInch).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromKilowattsPerMeter(wattpermeter.KilowattsPerMeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromKilowattsPerMillimeter(wattpermeter.KilowattsPerMillimeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromMegawattsPerCentimeter(wattpermeter.MegawattsPerCentimeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromMegawattsPerFoot(wattpermeter.MegawattsPerFoot).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromMegawattsPerInch(wattpermeter.MegawattsPerInch).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromMegawattsPerMeter(wattpermeter.MegawattsPerMeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromMegawattsPerMillimeter(wattpermeter.MegawattsPerMillimeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromMilliwattsPerCentimeter(wattpermeter.MilliwattsPerCentimeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromMilliwattsPerFoot(wattpermeter.MilliwattsPerFoot).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromMilliwattsPerInch(wattpermeter.MilliwattsPerInch).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromMilliwattsPerMeter(wattpermeter.MilliwattsPerMeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromMilliwattsPerMillimeter(wattpermeter.MilliwattsPerMillimeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromWattsPerCentimeter(wattpermeter.WattsPerCentimeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromWattsPerFoot(wattpermeter.WattsPerFoot).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromWattsPerInch(wattpermeter.WattsPerInch).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromWattsPerMeter(wattpermeter.WattsPerMeter).WattsPerMeter);
+            Assert.Equal(3, LinearPowerDensity.FromWattsPerMillimeter(wattpermeter.WattsPerMillimeter).WattsPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             LinearPowerDensity v = LinearPowerDensity.FromWattsPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (LinearPowerDensity.FromWattsPerMeter(3)-v).WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (LinearPowerDensity.FromWattsPerMeter(10)/5).WattsPerMeter, WattsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, LinearPowerDensity.FromWattsPerMeter(10)/LinearPowerDensity.FromWattsPerMeter(5), WattsPerMeterTolerance);
+            Assert.Equal(-1, -v.WattsPerMeter);
+            Assert.Equal(2, (LinearPowerDensity.FromWattsPerMeter(3) - v).WattsPerMeter);
+            Assert.Equal(2, (v + v).WattsPerMeter);
+            Assert.Equal(10, (v * 10).WattsPerMeter);
+            Assert.Equal(10, (10 * v).WattsPerMeter);
+            Assert.Equal(2, (LinearPowerDensity.FromWattsPerMeter(10) / 5).WattsPerMeter);
+            Assert.Equal(2, LinearPowerDensity.FromWattsPerMeter(10) / LinearPowerDensity.FromWattsPerMeter(5));
         }
 
         [Fact]
@@ -902,8 +962,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, LinearPowerDensityUnit.WattPerMeter, 1, LinearPowerDensityUnit.WattPerMeter, true)]  // Same value and unit.
         [InlineData(1, LinearPowerDensityUnit.WattPerMeter, 2, LinearPowerDensityUnit.WattPerMeter, false)] // Different value.
-        [InlineData(2, LinearPowerDensityUnit.WattPerMeter, 1, LinearPowerDensityUnit.GigawattPerCentimeter, false)] // Different value and unit.
-        [InlineData(1, LinearPowerDensityUnit.WattPerMeter, 1, LinearPowerDensityUnit.GigawattPerCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, LinearPowerDensityUnit unitA, double valueB, LinearPowerDensityUnit unitB, bool expectEqual)
         {
             var a = new LinearPowerDensity(valueA, unitA);
@@ -963,8 +1021,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = LinearPowerDensity.FromWattsPerMeter(firstValue);
             var otherQuantity = LinearPowerDensity.FromWattsPerMeter(secondValue);
             LinearPowerDensity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, LinearPowerDensity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -983,7 +1041,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<LinearPowerDensityUnit>();
+            var units = EnumHelper.GetValues<LinearPowerDensityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -996,6 +1054,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(LinearPowerDensity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(LinearPowerDensity.Info.Units, LinearPowerDensity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, LinearPowerDensity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1060,26 +1130,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 W/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerMillimeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s1"));
-            Assert.Equal("0.12 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s2"));
-            Assert.Equal("0.123 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s3"));
-            Assert.Equal("0.1235 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1106,7 +1156,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = LinearPowerDensity.FromWattsPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(LinearPowerDensity), quantity.As(LinearPowerDensity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminanceTestsBase.g.cs
index 591c951b4f..4d4b151f41 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminanceTestsBase.g.cs
@@ -161,6 +161,20 @@ public void Luminance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<LuminanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void LuminanceInfo_CreateWithCustomUnitInfos()
+        {
+            LuminanceUnit[] expectedUnits = [LuminanceUnit.CandelaPerSquareMeter];
+
+            Luminance.LuminanceInfo quantityInfo = Luminance.LuminanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Luminance", quantityInfo.Name);
+            Assert.Equal(Luminance.Zero, quantityInfo.Zero);
+            Assert.Equal(Luminance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CandelaPerSquareMeterToLuminanceUnits()
         {
@@ -263,26 +277,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Luminance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Luminance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Luminance quantityToConvert = quantity;
+
+                Luminance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<LuminanceUnit> quantityToConvert = quantity;
+
+                IQuantity<LuminanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Luminance(value: 1, unit: Luminance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Luminance(value: 1, unit: Luminance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<LuminanceUnit> quantity = new Luminance(value: 1, unit: Luminance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Luminance(value: 1, unit: Luminance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Luminance(value: 1, unit: Luminance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Luminance(value: 1, unit: Luminance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<LuminanceUnit> quantity = new Luminance(value: 1, unit: Luminance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Luminance(value: 1, unit: Luminance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -296,7 +353,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mCd/m²", LuminanceUnit.MillicandelaPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 nCd/m²", LuminanceUnit.NanocandelaPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 nt", LuminanceUnit.Nit, 4.2)]
-        public void Parse(string culture, string quantityString, LuminanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, LuminanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Luminance.Parse(quantityString);
@@ -315,7 +372,7 @@ public void Parse(string culture, string quantityString, LuminanceUnit expectedU
         [InlineData("en-US", "4.2 mCd/m²", LuminanceUnit.MillicandelaPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 nCd/m²", LuminanceUnit.NanocandelaPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 nt", LuminanceUnit.Nit, 4.2)]
-        public void TryParse(string culture, string quantityString, LuminanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, LuminanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Luminance.TryParse(quantityString, out Luminance parsed));
@@ -529,6 +586,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(LuminanceUnit un
                 var quantity = Luminance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -552,41 +610,43 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(LuminanceUnit unit)
                 IQuantity<LuminanceUnit> quantityToConvert = quantity;
                 IQuantity<LuminanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Luminance candelapersquaremeter = Luminance.FromCandelasPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, Luminance.FromCandelasPerSquareFoot(candelapersquaremeter.CandelasPerSquareFoot).CandelasPerSquareMeter, CandelasPerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, Luminance.FromCandelasPerSquareInch(candelapersquaremeter.CandelasPerSquareInch).CandelasPerSquareMeter, CandelasPerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, Luminance.FromCandelasPerSquareMeter(candelapersquaremeter.CandelasPerSquareMeter).CandelasPerSquareMeter, CandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Luminance.FromCenticandelasPerSquareMeter(candelapersquaremeter.CenticandelasPerSquareMeter).CandelasPerSquareMeter, CenticandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Luminance.FromDecicandelasPerSquareMeter(candelapersquaremeter.DecicandelasPerSquareMeter).CandelasPerSquareMeter, DecicandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Luminance.FromKilocandelasPerSquareMeter(candelapersquaremeter.KilocandelasPerSquareMeter).CandelasPerSquareMeter, KilocandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Luminance.FromMicrocandelasPerSquareMeter(candelapersquaremeter.MicrocandelasPerSquareMeter).CandelasPerSquareMeter, MicrocandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Luminance.FromMillicandelasPerSquareMeter(candelapersquaremeter.MillicandelasPerSquareMeter).CandelasPerSquareMeter, MillicandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Luminance.FromNanocandelasPerSquareMeter(candelapersquaremeter.NanocandelasPerSquareMeter).CandelasPerSquareMeter, NanocandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Luminance.FromNits(candelapersquaremeter.Nits).CandelasPerSquareMeter, NitsTolerance);
+            Luminance candelapersquaremeter = Luminance.FromCandelasPerSquareMeter(3);
+            Assert.Equal(3, Luminance.FromCandelasPerSquareFoot(candelapersquaremeter.CandelasPerSquareFoot).CandelasPerSquareMeter);
+            Assert.Equal(3, Luminance.FromCandelasPerSquareInch(candelapersquaremeter.CandelasPerSquareInch).CandelasPerSquareMeter);
+            Assert.Equal(3, Luminance.FromCandelasPerSquareMeter(candelapersquaremeter.CandelasPerSquareMeter).CandelasPerSquareMeter);
+            Assert.Equal(3, Luminance.FromCenticandelasPerSquareMeter(candelapersquaremeter.CenticandelasPerSquareMeter).CandelasPerSquareMeter);
+            Assert.Equal(3, Luminance.FromDecicandelasPerSquareMeter(candelapersquaremeter.DecicandelasPerSquareMeter).CandelasPerSquareMeter);
+            Assert.Equal(3, Luminance.FromKilocandelasPerSquareMeter(candelapersquaremeter.KilocandelasPerSquareMeter).CandelasPerSquareMeter);
+            Assert.Equal(3, Luminance.FromMicrocandelasPerSquareMeter(candelapersquaremeter.MicrocandelasPerSquareMeter).CandelasPerSquareMeter);
+            Assert.Equal(3, Luminance.FromMillicandelasPerSquareMeter(candelapersquaremeter.MillicandelasPerSquareMeter).CandelasPerSquareMeter);
+            Assert.Equal(3, Luminance.FromNanocandelasPerSquareMeter(candelapersquaremeter.NanocandelasPerSquareMeter).CandelasPerSquareMeter);
+            Assert.Equal(3, Luminance.FromNits(candelapersquaremeter.Nits).CandelasPerSquareMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Luminance v = Luminance.FromCandelasPerSquareMeter(1);
-            AssertEx.EqualTolerance(-1, -v.CandelasPerSquareMeter, CandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (Luminance.FromCandelasPerSquareMeter(3)-v).CandelasPerSquareMeter, CandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).CandelasPerSquareMeter, CandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).CandelasPerSquareMeter, CandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).CandelasPerSquareMeter, CandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (Luminance.FromCandelasPerSquareMeter(10)/5).CandelasPerSquareMeter, CandelasPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, Luminance.FromCandelasPerSquareMeter(10)/Luminance.FromCandelasPerSquareMeter(5), CandelasPerSquareMeterTolerance);
+            Assert.Equal(-1, -v.CandelasPerSquareMeter);
+            Assert.Equal(2, (Luminance.FromCandelasPerSquareMeter(3) - v).CandelasPerSquareMeter);
+            Assert.Equal(2, (v + v).CandelasPerSquareMeter);
+            Assert.Equal(10, (v * 10).CandelasPerSquareMeter);
+            Assert.Equal(10, (10 * v).CandelasPerSquareMeter);
+            Assert.Equal(2, (Luminance.FromCandelasPerSquareMeter(10) / 5).CandelasPerSquareMeter);
+            Assert.Equal(2, Luminance.FromCandelasPerSquareMeter(10) / Luminance.FromCandelasPerSquareMeter(5));
         }
 
         [Fact]
@@ -632,8 +692,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, LuminanceUnit.CandelaPerSquareMeter, 1, LuminanceUnit.CandelaPerSquareMeter, true)]  // Same value and unit.
         [InlineData(1, LuminanceUnit.CandelaPerSquareMeter, 2, LuminanceUnit.CandelaPerSquareMeter, false)] // Different value.
-        [InlineData(2, LuminanceUnit.CandelaPerSquareMeter, 1, LuminanceUnit.CandelaPerSquareFoot, false)] // Different value and unit.
-        [InlineData(1, LuminanceUnit.CandelaPerSquareMeter, 1, LuminanceUnit.CandelaPerSquareFoot, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, LuminanceUnit unitA, double valueB, LuminanceUnit unitB, bool expectEqual)
         {
             var a = new Luminance(valueA, unitA);
@@ -693,8 +751,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Luminance.FromCandelasPerSquareMeter(firstValue);
             var otherQuantity = Luminance.FromCandelasPerSquareMeter(secondValue);
             Luminance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Luminance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -713,7 +771,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<LuminanceUnit>();
+            var units = EnumHelper.GetValues<LuminanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -726,6 +784,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Luminance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Luminance.Info.Units, Luminance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Luminance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -760,26 +830,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 nt", new Luminance(1, LuminanceUnit.Nit).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Cd/m²", new Luminance(0.123456, LuminanceUnit.CandelaPerSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 Cd/m²", new Luminance(0.123456, LuminanceUnit.CandelaPerSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 Cd/m²", new Luminance(0.123456, LuminanceUnit.CandelaPerSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 Cd/m²", new Luminance(0.123456, LuminanceUnit.CandelaPerSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Cd/m²", new Luminance(0.123456, LuminanceUnit.CandelaPerSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 Cd/m²", new Luminance(0.123456, LuminanceUnit.CandelaPerSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 Cd/m²", new Luminance(0.123456, LuminanceUnit.CandelaPerSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 Cd/m²", new Luminance(0.123456, LuminanceUnit.CandelaPerSquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -806,7 +856,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Luminance.FromCandelasPerSquareMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Luminance), quantity.As(Luminance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminosityTestsBase.g.cs
index 4b14438b18..a73bf0c2d0 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminosityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminosityTestsBase.g.cs
@@ -177,6 +177,20 @@ public void Luminosity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<LuminosityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void LuminosityInfo_CreateWithCustomUnitInfos()
+        {
+            LuminosityUnit[] expectedUnits = [LuminosityUnit.Watt];
+
+            Luminosity.LuminosityInfo quantityInfo = Luminosity.LuminosityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Luminosity", quantityInfo.Name);
+            Assert.Equal(Luminosity.Zero, quantityInfo.Zero);
+            Assert.Equal(Luminosity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void WattToLuminosityUnits()
         {
@@ -287,26 +301,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Luminosity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Luminosity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Luminosity quantityToConvert = quantity;
+
+                Luminosity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<LuminosityUnit> quantityToConvert = quantity;
+
+                IQuantity<LuminosityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Luminosity(value: 1, unit: Luminosity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Luminosity(value: 1, unit: Luminosity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<LuminosityUnit> quantity = new Luminosity(value: 1, unit: Luminosity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Luminosity(value: 1, unit: Luminosity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Luminosity(value: 1, unit: Luminosity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Luminosity(value: 1, unit: Luminosity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<LuminosityUnit> quantity = new Luminosity(value: 1, unit: Luminosity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Luminosity(value: 1, unit: Luminosity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -324,7 +381,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 L⊙", LuminosityUnit.SolarLuminosity, 4.2)]
         [InlineData("en-US", "4.2 TW", LuminosityUnit.Terawatt, 4.2)]
         [InlineData("en-US", "4.2 W", LuminosityUnit.Watt, 4.2)]
-        public void Parse(string culture, string quantityString, LuminosityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, LuminosityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Luminosity.Parse(quantityString);
@@ -347,7 +404,7 @@ public void Parse(string culture, string quantityString, LuminosityUnit expected
         [InlineData("en-US", "4.2 L⊙", LuminosityUnit.SolarLuminosity, 4.2)]
         [InlineData("en-US", "4.2 TW", LuminosityUnit.Terawatt, 4.2)]
         [InlineData("en-US", "4.2 W", LuminosityUnit.Watt, 4.2)]
-        public void TryParse(string culture, string quantityString, LuminosityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, LuminosityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Luminosity.TryParse(quantityString, out Luminosity parsed));
@@ -597,6 +654,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(LuminosityUnit u
                 var quantity = Luminosity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -620,45 +678,47 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(LuminosityUnit unit
                 IQuantity<LuminosityUnit> quantityToConvert = quantity;
                 IQuantity<LuminosityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Luminosity watt = Luminosity.FromWatts(1);
-            AssertEx.EqualTolerance(1, Luminosity.FromDecawatts(watt.Decawatts).Watts, DecawattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromDeciwatts(watt.Deciwatts).Watts, DeciwattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromFemtowatts(watt.Femtowatts).Watts, FemtowattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromGigawatts(watt.Gigawatts).Watts, GigawattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromKilowatts(watt.Kilowatts).Watts, KilowattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromMegawatts(watt.Megawatts).Watts, MegawattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromMicrowatts(watt.Microwatts).Watts, MicrowattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromMilliwatts(watt.Milliwatts).Watts, MilliwattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromNanowatts(watt.Nanowatts).Watts, NanowattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromPetawatts(watt.Petawatts).Watts, PetawattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromPicowatts(watt.Picowatts).Watts, PicowattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromSolarLuminosities(watt.SolarLuminosities).Watts, SolarLuminositiesTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromTerawatts(watt.Terawatts).Watts, TerawattsTolerance);
-            AssertEx.EqualTolerance(1, Luminosity.FromWatts(watt.Watts).Watts, WattsTolerance);
+            Luminosity watt = Luminosity.FromWatts(3);
+            Assert.Equal(3, Luminosity.FromDecawatts(watt.Decawatts).Watts);
+            Assert.Equal(3, Luminosity.FromDeciwatts(watt.Deciwatts).Watts);
+            Assert.Equal(3, Luminosity.FromFemtowatts(watt.Femtowatts).Watts);
+            Assert.Equal(3, Luminosity.FromGigawatts(watt.Gigawatts).Watts);
+            Assert.Equal(3, Luminosity.FromKilowatts(watt.Kilowatts).Watts);
+            Assert.Equal(3, Luminosity.FromMegawatts(watt.Megawatts).Watts);
+            Assert.Equal(3, Luminosity.FromMicrowatts(watt.Microwatts).Watts);
+            Assert.Equal(3, Luminosity.FromMilliwatts(watt.Milliwatts).Watts);
+            Assert.Equal(3, Luminosity.FromNanowatts(watt.Nanowatts).Watts);
+            Assert.Equal(3, Luminosity.FromPetawatts(watt.Petawatts).Watts);
+            Assert.Equal(3, Luminosity.FromPicowatts(watt.Picowatts).Watts);
+            Assert.Equal(3, Luminosity.FromSolarLuminosities(watt.SolarLuminosities).Watts);
+            Assert.Equal(3, Luminosity.FromTerawatts(watt.Terawatts).Watts);
+            Assert.Equal(3, Luminosity.FromWatts(watt.Watts).Watts);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Luminosity v = Luminosity.FromWatts(1);
-            AssertEx.EqualTolerance(-1, -v.Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, (Luminosity.FromWatts(3)-v).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, (Luminosity.FromWatts(10)/5).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, Luminosity.FromWatts(10)/Luminosity.FromWatts(5), WattsTolerance);
+            Assert.Equal(-1, -v.Watts);
+            Assert.Equal(2, (Luminosity.FromWatts(3) - v).Watts);
+            Assert.Equal(2, (v + v).Watts);
+            Assert.Equal(10, (v * 10).Watts);
+            Assert.Equal(10, (10 * v).Watts);
+            Assert.Equal(2, (Luminosity.FromWatts(10) / 5).Watts);
+            Assert.Equal(2, Luminosity.FromWatts(10) / Luminosity.FromWatts(5));
         }
 
         [Fact]
@@ -704,8 +764,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, LuminosityUnit.Watt, 1, LuminosityUnit.Watt, true)]  // Same value and unit.
         [InlineData(1, LuminosityUnit.Watt, 2, LuminosityUnit.Watt, false)] // Different value.
-        [InlineData(2, LuminosityUnit.Watt, 1, LuminosityUnit.Decawatt, false)] // Different value and unit.
-        [InlineData(1, LuminosityUnit.Watt, 1, LuminosityUnit.Decawatt, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, LuminosityUnit unitA, double valueB, LuminosityUnit unitB, bool expectEqual)
         {
             var a = new Luminosity(valueA, unitA);
@@ -765,8 +823,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Luminosity.FromWatts(firstValue);
             var otherQuantity = Luminosity.FromWatts(secondValue);
             Luminosity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Luminosity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -785,7 +843,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<LuminosityUnit>();
+            var units = EnumHelper.GetValues<LuminosityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -798,6 +856,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Luminosity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Luminosity.Info.Units, Luminosity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Luminosity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -840,26 +910,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 W", new Luminosity(1, LuminosityUnit.Watt).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 W", new Luminosity(0.123456, LuminosityUnit.Watt).ToString("s1"));
-            Assert.Equal("0.12 W", new Luminosity(0.123456, LuminosityUnit.Watt).ToString("s2"));
-            Assert.Equal("0.123 W", new Luminosity(0.123456, LuminosityUnit.Watt).ToString("s3"));
-            Assert.Equal("0.1235 W", new Luminosity(0.123456, LuminosityUnit.Watt).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 W", new Luminosity(0.123456, LuminosityUnit.Watt).ToString("s1", culture));
-            Assert.Equal("0.12 W", new Luminosity(0.123456, LuminosityUnit.Watt).ToString("s2", culture));
-            Assert.Equal("0.123 W", new Luminosity(0.123456, LuminosityUnit.Watt).ToString("s3", culture));
-            Assert.Equal("0.1235 W", new Luminosity(0.123456, LuminosityUnit.Watt).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -886,7 +936,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Luminosity.FromWatts(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Luminosity), quantity.As(Luminosity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs
index 32b414cdc9..4aaeab2738 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousFluxTestsBase.g.cs
@@ -125,6 +125,20 @@ public void LuminousFlux_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<LuminousFluxUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void LuminousFluxInfo_CreateWithCustomUnitInfos()
+        {
+            LuminousFluxUnit[] expectedUnits = [LuminousFluxUnit.Lumen];
+
+            LuminousFlux.LuminousFluxInfo quantityInfo = LuminousFlux.LuminousFluxInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("LuminousFlux", quantityInfo.Name);
+            Assert.Equal(LuminousFlux.Zero, quantityInfo.Zero);
+            Assert.Equal(LuminousFlux.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void LumenToLuminousFluxUnits()
         {
@@ -209,31 +223,74 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = LuminousFlux.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            LuminousFlux convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                LuminousFlux quantityToConvert = quantity;
+
+                LuminousFlux convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<LuminousFluxUnit> quantityToConvert = quantity;
+
+                IQuantity<LuminousFluxUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new LuminousFlux(value: 1, unit: LuminousFlux.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new LuminousFlux(value: 1, unit: LuminousFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<LuminousFluxUnit> quantity = new LuminousFlux(value: 1, unit: LuminousFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new LuminousFlux(value: 1, unit: LuminousFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new LuminousFlux(value: 1, unit: LuminousFlux.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new LuminousFlux(value: 1, unit: LuminousFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<LuminousFluxUnit> quantity = new LuminousFlux(value: 1, unit: LuminousFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new LuminousFlux(value: 1, unit: LuminousFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 lm", LuminousFluxUnit.Lumen, 4.2)]
-        public void Parse(string culture, string quantityString, LuminousFluxUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, LuminousFluxUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = LuminousFlux.Parse(quantityString);
@@ -243,7 +300,7 @@ public void Parse(string culture, string quantityString, LuminousFluxUnit expect
 
         [Theory]
         [InlineData("en-US", "4.2 lm", LuminousFluxUnit.Lumen, 4.2)]
-        public void TryParse(string culture, string quantityString, LuminousFluxUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, LuminousFluxUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(LuminousFlux.TryParse(quantityString, out LuminousFlux parsed));
@@ -376,6 +433,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(LuminousFluxUnit
                 var quantity = LuminousFlux.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -399,32 +457,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(LuminousFluxUnit un
                 IQuantity<LuminousFluxUnit> quantityToConvert = quantity;
                 IQuantity<LuminousFluxUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            LuminousFlux lumen = LuminousFlux.FromLumens(1);
-            AssertEx.EqualTolerance(1, LuminousFlux.FromLumens(lumen.Lumens).Lumens, LumensTolerance);
+            LuminousFlux lumen = LuminousFlux.FromLumens(3);
+            Assert.Equal(3, LuminousFlux.FromLumens(lumen.Lumens).Lumens);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             LuminousFlux v = LuminousFlux.FromLumens(1);
-            AssertEx.EqualTolerance(-1, -v.Lumens, LumensTolerance);
-            AssertEx.EqualTolerance(2, (LuminousFlux.FromLumens(3)-v).Lumens, LumensTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Lumens, LumensTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Lumens, LumensTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Lumens, LumensTolerance);
-            AssertEx.EqualTolerance(2, (LuminousFlux.FromLumens(10)/5).Lumens, LumensTolerance);
-            AssertEx.EqualTolerance(2, LuminousFlux.FromLumens(10)/LuminousFlux.FromLumens(5), LumensTolerance);
+            Assert.Equal(-1, -v.Lumens);
+            Assert.Equal(2, (LuminousFlux.FromLumens(3) - v).Lumens);
+            Assert.Equal(2, (v + v).Lumens);
+            Assert.Equal(10, (v * 10).Lumens);
+            Assert.Equal(10, (10 * v).Lumens);
+            Assert.Equal(2, (LuminousFlux.FromLumens(10) / 5).Lumens);
+            Assert.Equal(2, LuminousFlux.FromLumens(10) / LuminousFlux.FromLumens(5));
         }
 
         [Fact]
@@ -470,7 +530,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, LuminousFluxUnit.Lumen, 1, LuminousFluxUnit.Lumen, true)]  // Same value and unit.
         [InlineData(1, LuminousFluxUnit.Lumen, 2, LuminousFluxUnit.Lumen, false)] // Different value.
-        [InlineData(2, LuminousFluxUnit.Lumen, 1, LuminousFluxUnit.Lumen, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, LuminousFluxUnit unitA, double valueB, LuminousFluxUnit unitB, bool expectEqual)
         {
             var a = new LuminousFlux(valueA, unitA);
@@ -530,8 +589,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = LuminousFlux.FromLumens(firstValue);
             var otherQuantity = LuminousFlux.FromLumens(secondValue);
             LuminousFlux maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, LuminousFlux.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -550,7 +609,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<LuminousFluxUnit>();
+            var units = EnumHelper.GetValues<LuminousFluxUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -564,39 +623,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 lm", new LuminousFlux(1, LuminousFluxUnit.Lumen).ToString());
+            Assert.Equal(LuminousFlux.Info.Units, LuminousFlux.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 lm", new LuminousFlux(1, LuminousFluxUnit.Lumen).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, LuminousFlux.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 lm", new LuminousFlux(0.123456, LuminousFluxUnit.Lumen).ToString("s1"));
-            Assert.Equal("0.12 lm", new LuminousFlux(0.123456, LuminousFluxUnit.Lumen).ToString("s2"));
-            Assert.Equal("0.123 lm", new LuminousFlux(0.123456, LuminousFluxUnit.Lumen).ToString("s3"));
-            Assert.Equal("0.1235 lm", new LuminousFlux(0.123456, LuminousFluxUnit.Lumen).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 lm", new LuminousFlux(1, LuminousFluxUnit.Lumen).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 lm", new LuminousFlux(0.123456, LuminousFluxUnit.Lumen).ToString("s1", culture));
-            Assert.Equal("0.12 lm", new LuminousFlux(0.123456, LuminousFluxUnit.Lumen).ToString("s2", culture));
-            Assert.Equal("0.123 lm", new LuminousFlux(0.123456, LuminousFluxUnit.Lumen).ToString("s3", culture));
-            Assert.Equal("0.1235 lm", new LuminousFlux(0.123456, LuminousFluxUnit.Lumen).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 lm", new LuminousFlux(1, LuminousFluxUnit.Lumen).ToString(swedishCulture));
         }
 
         [Theory]
@@ -625,7 +676,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = LuminousFlux.FromLumens(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(LuminousFlux), quantity.As(LuminousFlux.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs
index cad3063579..b07965bf64 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LuminousIntensityTestsBase.g.cs
@@ -125,6 +125,20 @@ public void LuminousIntensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
             Assert.Equal(quantityInfo, ((IQuantity<LuminousIntensityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void LuminousIntensityInfo_CreateWithCustomUnitInfos()
+        {
+            LuminousIntensityUnit[] expectedUnits = [LuminousIntensityUnit.Candela];
+
+            LuminousIntensity.LuminousIntensityInfo quantityInfo = LuminousIntensity.LuminousIntensityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("LuminousIntensity", quantityInfo.Name);
+            Assert.Equal(LuminousIntensity.Zero, quantityInfo.Zero);
+            Assert.Equal(LuminousIntensity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CandelaToLuminousIntensityUnits()
         {
@@ -209,31 +223,74 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = LuminousIntensity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            LuminousIntensity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                LuminousIntensity quantityToConvert = quantity;
+
+                LuminousIntensity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<LuminousIntensityUnit> quantityToConvert = quantity;
+
+                IQuantity<LuminousIntensityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new LuminousIntensity(value: 1, unit: LuminousIntensity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new LuminousIntensity(value: 1, unit: LuminousIntensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<LuminousIntensityUnit> quantity = new LuminousIntensity(value: 1, unit: LuminousIntensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new LuminousIntensity(value: 1, unit: LuminousIntensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new LuminousIntensity(value: 1, unit: LuminousIntensity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new LuminousIntensity(value: 1, unit: LuminousIntensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<LuminousIntensityUnit> quantity = new LuminousIntensity(value: 1, unit: LuminousIntensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new LuminousIntensity(value: 1, unit: LuminousIntensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 cd", LuminousIntensityUnit.Candela, 4.2)]
-        public void Parse(string culture, string quantityString, LuminousIntensityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, LuminousIntensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = LuminousIntensity.Parse(quantityString);
@@ -243,7 +300,7 @@ public void Parse(string culture, string quantityString, LuminousIntensityUnit e
 
         [Theory]
         [InlineData("en-US", "4.2 cd", LuminousIntensityUnit.Candela, 4.2)]
-        public void TryParse(string culture, string quantityString, LuminousIntensityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, LuminousIntensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(LuminousIntensity.TryParse(quantityString, out LuminousIntensity parsed));
@@ -376,6 +433,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(LuminousIntensit
                 var quantity = LuminousIntensity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -399,32 +457,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(LuminousIntensityUn
                 IQuantity<LuminousIntensityUnit> quantityToConvert = quantity;
                 IQuantity<LuminousIntensityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            LuminousIntensity candela = LuminousIntensity.FromCandela(1);
-            AssertEx.EqualTolerance(1, LuminousIntensity.FromCandela(candela.Candela).Candela, CandelaTolerance);
+            LuminousIntensity candela = LuminousIntensity.FromCandela(3);
+            Assert.Equal(3, LuminousIntensity.FromCandela(candela.Candela).Candela);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             LuminousIntensity v = LuminousIntensity.FromCandela(1);
-            AssertEx.EqualTolerance(-1, -v.Candela, CandelaTolerance);
-            AssertEx.EqualTolerance(2, (LuminousIntensity.FromCandela(3)-v).Candela, CandelaTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Candela, CandelaTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Candela, CandelaTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Candela, CandelaTolerance);
-            AssertEx.EqualTolerance(2, (LuminousIntensity.FromCandela(10)/5).Candela, CandelaTolerance);
-            AssertEx.EqualTolerance(2, LuminousIntensity.FromCandela(10)/LuminousIntensity.FromCandela(5), CandelaTolerance);
+            Assert.Equal(-1, -v.Candela);
+            Assert.Equal(2, (LuminousIntensity.FromCandela(3) - v).Candela);
+            Assert.Equal(2, (v + v).Candela);
+            Assert.Equal(10, (v * 10).Candela);
+            Assert.Equal(10, (10 * v).Candela);
+            Assert.Equal(2, (LuminousIntensity.FromCandela(10) / 5).Candela);
+            Assert.Equal(2, LuminousIntensity.FromCandela(10) / LuminousIntensity.FromCandela(5));
         }
 
         [Fact]
@@ -470,7 +530,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, LuminousIntensityUnit.Candela, 1, LuminousIntensityUnit.Candela, true)]  // Same value and unit.
         [InlineData(1, LuminousIntensityUnit.Candela, 2, LuminousIntensityUnit.Candela, false)] // Different value.
-        [InlineData(2, LuminousIntensityUnit.Candela, 1, LuminousIntensityUnit.Candela, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, LuminousIntensityUnit unitA, double valueB, LuminousIntensityUnit unitB, bool expectEqual)
         {
             var a = new LuminousIntensity(valueA, unitA);
@@ -530,8 +589,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = LuminousIntensity.FromCandela(firstValue);
             var otherQuantity = LuminousIntensity.FromCandela(secondValue);
             LuminousIntensity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, LuminousIntensity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -550,7 +609,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<LuminousIntensityUnit>();
+            var units = EnumHelper.GetValues<LuminousIntensityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -564,39 +623,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 cd", new LuminousIntensity(1, LuminousIntensityUnit.Candela).ToString());
+            Assert.Equal(LuminousIntensity.Info.Units, LuminousIntensity.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 cd", new LuminousIntensity(1, LuminousIntensityUnit.Candela).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, LuminousIntensity.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 cd", new LuminousIntensity(0.123456, LuminousIntensityUnit.Candela).ToString("s1"));
-            Assert.Equal("0.12 cd", new LuminousIntensity(0.123456, LuminousIntensityUnit.Candela).ToString("s2"));
-            Assert.Equal("0.123 cd", new LuminousIntensity(0.123456, LuminousIntensityUnit.Candela).ToString("s3"));
-            Assert.Equal("0.1235 cd", new LuminousIntensity(0.123456, LuminousIntensityUnit.Candela).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 cd", new LuminousIntensity(1, LuminousIntensityUnit.Candela).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 cd", new LuminousIntensity(0.123456, LuminousIntensityUnit.Candela).ToString("s1", culture));
-            Assert.Equal("0.12 cd", new LuminousIntensity(0.123456, LuminousIntensityUnit.Candela).ToString("s2", culture));
-            Assert.Equal("0.123 cd", new LuminousIntensity(0.123456, LuminousIntensityUnit.Candela).ToString("s3", culture));
-            Assert.Equal("0.1235 cd", new LuminousIntensity(0.123456, LuminousIntensityUnit.Candela).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 cd", new LuminousIntensity(1, LuminousIntensityUnit.Candela).ToString(swedishCulture));
         }
 
         [Theory]
@@ -625,7 +676,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = LuminousIntensity.FromCandela(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(LuminousIntensity), quantity.As(LuminousIntensity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFieldTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFieldTestsBase.g.cs
index b41a87c1e6..736898ed86 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFieldTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFieldTestsBase.g.cs
@@ -145,6 +145,20 @@ public void MagneticField_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MagneticFieldUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MagneticFieldInfo_CreateWithCustomUnitInfos()
+        {
+            MagneticFieldUnit[] expectedUnits = [MagneticFieldUnit.Tesla];
+
+            MagneticField.MagneticFieldInfo quantityInfo = MagneticField.MagneticFieldInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MagneticField", quantityInfo.Name);
+            Assert.Equal(MagneticField.Zero, quantityInfo.Zero);
+            Assert.Equal(MagneticField.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void TeslaToMagneticFieldUnits()
         {
@@ -239,26 +253,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = MagneticField.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            MagneticField convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                MagneticField quantityToConvert = quantity;
+
+                MagneticField convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MagneticFieldUnit> quantityToConvert = quantity;
+
+                IQuantity<MagneticFieldUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new MagneticField(value: 1, unit: MagneticField.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MagneticField(value: 1, unit: MagneticField.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MagneticFieldUnit> quantity = new MagneticField(value: 1, unit: MagneticField.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MagneticField(value: 1, unit: MagneticField.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new MagneticField(value: 1, unit: MagneticField.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MagneticField(value: 1, unit: MagneticField.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MagneticFieldUnit> quantity = new MagneticField(value: 1, unit: MagneticField.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MagneticField(value: 1, unit: MagneticField.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -268,7 +325,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mT", MagneticFieldUnit.Millitesla, 4.2)]
         [InlineData("en-US", "4.2 nT", MagneticFieldUnit.Nanotesla, 4.2)]
         [InlineData("en-US", "4.2 T", MagneticFieldUnit.Tesla, 4.2)]
-        public void Parse(string culture, string quantityString, MagneticFieldUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MagneticFieldUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MagneticField.Parse(quantityString);
@@ -283,7 +340,7 @@ public void Parse(string culture, string quantityString, MagneticFieldUnit expec
         [InlineData("en-US", "4.2 mT", MagneticFieldUnit.Millitesla, 4.2)]
         [InlineData("en-US", "4.2 nT", MagneticFieldUnit.Nanotesla, 4.2)]
         [InlineData("en-US", "4.2 T", MagneticFieldUnit.Tesla, 4.2)]
-        public void TryParse(string culture, string quantityString, MagneticFieldUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MagneticFieldUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MagneticField.TryParse(quantityString, out MagneticField parsed));
@@ -461,6 +518,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MagneticFieldUni
                 var quantity = MagneticField.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -484,37 +542,39 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MagneticFieldUnit u
                 IQuantity<MagneticFieldUnit> quantityToConvert = quantity;
                 IQuantity<MagneticFieldUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MagneticField tesla = MagneticField.FromTeslas(1);
-            AssertEx.EqualTolerance(1, MagneticField.FromGausses(tesla.Gausses).Teslas, GaussesTolerance);
-            AssertEx.EqualTolerance(1, MagneticField.FromMicroteslas(tesla.Microteslas).Teslas, MicroteslasTolerance);
-            AssertEx.EqualTolerance(1, MagneticField.FromMilligausses(tesla.Milligausses).Teslas, MilligaussesTolerance);
-            AssertEx.EqualTolerance(1, MagneticField.FromMilliteslas(tesla.Milliteslas).Teslas, MilliteslasTolerance);
-            AssertEx.EqualTolerance(1, MagneticField.FromNanoteslas(tesla.Nanoteslas).Teslas, NanoteslasTolerance);
-            AssertEx.EqualTolerance(1, MagneticField.FromTeslas(tesla.Teslas).Teslas, TeslasTolerance);
+            MagneticField tesla = MagneticField.FromTeslas(3);
+            Assert.Equal(3, MagneticField.FromGausses(tesla.Gausses).Teslas);
+            Assert.Equal(3, MagneticField.FromMicroteslas(tesla.Microteslas).Teslas);
+            Assert.Equal(3, MagneticField.FromMilligausses(tesla.Milligausses).Teslas);
+            Assert.Equal(3, MagneticField.FromMilliteslas(tesla.Milliteslas).Teslas);
+            Assert.Equal(3, MagneticField.FromNanoteslas(tesla.Nanoteslas).Teslas);
+            Assert.Equal(3, MagneticField.FromTeslas(tesla.Teslas).Teslas);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MagneticField v = MagneticField.FromTeslas(1);
-            AssertEx.EqualTolerance(-1, -v.Teslas, TeslasTolerance);
-            AssertEx.EqualTolerance(2, (MagneticField.FromTeslas(3)-v).Teslas, TeslasTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Teslas, TeslasTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Teslas, TeslasTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Teslas, TeslasTolerance);
-            AssertEx.EqualTolerance(2, (MagneticField.FromTeslas(10)/5).Teslas, TeslasTolerance);
-            AssertEx.EqualTolerance(2, MagneticField.FromTeslas(10)/MagneticField.FromTeslas(5), TeslasTolerance);
+            Assert.Equal(-1, -v.Teslas);
+            Assert.Equal(2, (MagneticField.FromTeslas(3) - v).Teslas);
+            Assert.Equal(2, (v + v).Teslas);
+            Assert.Equal(10, (v * 10).Teslas);
+            Assert.Equal(10, (10 * v).Teslas);
+            Assert.Equal(2, (MagneticField.FromTeslas(10) / 5).Teslas);
+            Assert.Equal(2, MagneticField.FromTeslas(10) / MagneticField.FromTeslas(5));
         }
 
         [Fact]
@@ -560,8 +620,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MagneticFieldUnit.Tesla, 1, MagneticFieldUnit.Tesla, true)]  // Same value and unit.
         [InlineData(1, MagneticFieldUnit.Tesla, 2, MagneticFieldUnit.Tesla, false)] // Different value.
-        [InlineData(2, MagneticFieldUnit.Tesla, 1, MagneticFieldUnit.Gauss, false)] // Different value and unit.
-        [InlineData(1, MagneticFieldUnit.Tesla, 1, MagneticFieldUnit.Gauss, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MagneticFieldUnit unitA, double valueB, MagneticFieldUnit unitB, bool expectEqual)
         {
             var a = new MagneticField(valueA, unitA);
@@ -621,8 +679,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MagneticField.FromTeslas(firstValue);
             var otherQuantity = MagneticField.FromTeslas(secondValue);
             MagneticField maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MagneticField.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -641,7 +699,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MagneticFieldUnit>();
+            var units = EnumHelper.GetValues<MagneticFieldUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -654,6 +712,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(MagneticField.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(MagneticField.Info.Units, MagneticField.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, MagneticField.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -680,26 +750,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 T", new MagneticField(1, MagneticFieldUnit.Tesla).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 T", new MagneticField(0.123456, MagneticFieldUnit.Tesla).ToString("s1"));
-            Assert.Equal("0.12 T", new MagneticField(0.123456, MagneticFieldUnit.Tesla).ToString("s2"));
-            Assert.Equal("0.123 T", new MagneticField(0.123456, MagneticFieldUnit.Tesla).ToString("s3"));
-            Assert.Equal("0.1235 T", new MagneticField(0.123456, MagneticFieldUnit.Tesla).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 T", new MagneticField(0.123456, MagneticFieldUnit.Tesla).ToString("s1", culture));
-            Assert.Equal("0.12 T", new MagneticField(0.123456, MagneticFieldUnit.Tesla).ToString("s2", culture));
-            Assert.Equal("0.123 T", new MagneticField(0.123456, MagneticFieldUnit.Tesla).ToString("s3", culture));
-            Assert.Equal("0.1235 T", new MagneticField(0.123456, MagneticFieldUnit.Tesla).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -726,7 +776,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MagneticField.FromTeslas(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MagneticField), quantity.As(MagneticField.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFluxTestsBase.g.cs
index 714b6a3f69..46151b5b0c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFluxTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MagneticFluxTestsBase.g.cs
@@ -125,6 +125,20 @@ public void MagneticFlux_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MagneticFluxUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MagneticFluxInfo_CreateWithCustomUnitInfos()
+        {
+            MagneticFluxUnit[] expectedUnits = [MagneticFluxUnit.Weber];
+
+            MagneticFlux.MagneticFluxInfo quantityInfo = MagneticFlux.MagneticFluxInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MagneticFlux", quantityInfo.Name);
+            Assert.Equal(MagneticFlux.Zero, quantityInfo.Zero);
+            Assert.Equal(MagneticFlux.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void WeberToMagneticFluxUnits()
         {
@@ -209,31 +223,74 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = MagneticFlux.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            MagneticFlux convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                MagneticFlux quantityToConvert = quantity;
+
+                MagneticFlux convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MagneticFluxUnit> quantityToConvert = quantity;
+
+                IQuantity<MagneticFluxUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new MagneticFlux(value: 1, unit: MagneticFlux.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MagneticFlux(value: 1, unit: MagneticFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MagneticFluxUnit> quantity = new MagneticFlux(value: 1, unit: MagneticFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MagneticFlux(value: 1, unit: MagneticFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new MagneticFlux(value: 1, unit: MagneticFlux.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MagneticFlux(value: 1, unit: MagneticFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MagneticFluxUnit> quantity = new MagneticFlux(value: 1, unit: MagneticFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MagneticFlux(value: 1, unit: MagneticFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 Wb", MagneticFluxUnit.Weber, 4.2)]
-        public void Parse(string culture, string quantityString, MagneticFluxUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MagneticFluxUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MagneticFlux.Parse(quantityString);
@@ -243,7 +300,7 @@ public void Parse(string culture, string quantityString, MagneticFluxUnit expect
 
         [Theory]
         [InlineData("en-US", "4.2 Wb", MagneticFluxUnit.Weber, 4.2)]
-        public void TryParse(string culture, string quantityString, MagneticFluxUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MagneticFluxUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MagneticFlux.TryParse(quantityString, out MagneticFlux parsed));
@@ -376,6 +433,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MagneticFluxUnit
                 var quantity = MagneticFlux.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -399,32 +457,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MagneticFluxUnit un
                 IQuantity<MagneticFluxUnit> quantityToConvert = quantity;
                 IQuantity<MagneticFluxUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MagneticFlux weber = MagneticFlux.FromWebers(1);
-            AssertEx.EqualTolerance(1, MagneticFlux.FromWebers(weber.Webers).Webers, WebersTolerance);
+            MagneticFlux weber = MagneticFlux.FromWebers(3);
+            Assert.Equal(3, MagneticFlux.FromWebers(weber.Webers).Webers);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MagneticFlux v = MagneticFlux.FromWebers(1);
-            AssertEx.EqualTolerance(-1, -v.Webers, WebersTolerance);
-            AssertEx.EqualTolerance(2, (MagneticFlux.FromWebers(3)-v).Webers, WebersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Webers, WebersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Webers, WebersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Webers, WebersTolerance);
-            AssertEx.EqualTolerance(2, (MagneticFlux.FromWebers(10)/5).Webers, WebersTolerance);
-            AssertEx.EqualTolerance(2, MagneticFlux.FromWebers(10)/MagneticFlux.FromWebers(5), WebersTolerance);
+            Assert.Equal(-1, -v.Webers);
+            Assert.Equal(2, (MagneticFlux.FromWebers(3) - v).Webers);
+            Assert.Equal(2, (v + v).Webers);
+            Assert.Equal(10, (v * 10).Webers);
+            Assert.Equal(10, (10 * v).Webers);
+            Assert.Equal(2, (MagneticFlux.FromWebers(10) / 5).Webers);
+            Assert.Equal(2, MagneticFlux.FromWebers(10) / MagneticFlux.FromWebers(5));
         }
 
         [Fact]
@@ -470,7 +530,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MagneticFluxUnit.Weber, 1, MagneticFluxUnit.Weber, true)]  // Same value and unit.
         [InlineData(1, MagneticFluxUnit.Weber, 2, MagneticFluxUnit.Weber, false)] // Different value.
-        [InlineData(2, MagneticFluxUnit.Weber, 1, MagneticFluxUnit.Weber, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MagneticFluxUnit unitA, double valueB, MagneticFluxUnit unitB, bool expectEqual)
         {
             var a = new MagneticFlux(valueA, unitA);
@@ -530,8 +589,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MagneticFlux.FromWebers(firstValue);
             var otherQuantity = MagneticFlux.FromWebers(secondValue);
             MagneticFlux maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MagneticFlux.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -550,7 +609,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MagneticFluxUnit>();
+            var units = EnumHelper.GetValues<MagneticFluxUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -564,39 +623,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 Wb", new MagneticFlux(1, MagneticFluxUnit.Weber).ToString());
+            Assert.Equal(MagneticFlux.Info.Units, MagneticFlux.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 Wb", new MagneticFlux(1, MagneticFluxUnit.Weber).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, MagneticFlux.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Wb", new MagneticFlux(0.123456, MagneticFluxUnit.Weber).ToString("s1"));
-            Assert.Equal("0.12 Wb", new MagneticFlux(0.123456, MagneticFluxUnit.Weber).ToString("s2"));
-            Assert.Equal("0.123 Wb", new MagneticFlux(0.123456, MagneticFluxUnit.Weber).ToString("s3"));
-            Assert.Equal("0.1235 Wb", new MagneticFlux(0.123456, MagneticFluxUnit.Weber).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 Wb", new MagneticFlux(1, MagneticFluxUnit.Weber).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Wb", new MagneticFlux(0.123456, MagneticFluxUnit.Weber).ToString("s1", culture));
-            Assert.Equal("0.12 Wb", new MagneticFlux(0.123456, MagneticFluxUnit.Weber).ToString("s2", culture));
-            Assert.Equal("0.123 Wb", new MagneticFlux(0.123456, MagneticFluxUnit.Weber).ToString("s3", culture));
-            Assert.Equal("0.1235 Wb", new MagneticFlux(0.123456, MagneticFluxUnit.Weber).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 Wb", new MagneticFlux(1, MagneticFluxUnit.Weber).ToString(swedishCulture));
         }
 
         [Theory]
@@ -625,7 +676,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MagneticFlux.FromWebers(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MagneticFlux), quantity.As(MagneticFlux.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MagnetizationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MagnetizationTestsBase.g.cs
index ffb6e8d0be..749f9357b7 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MagnetizationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MagnetizationTestsBase.g.cs
@@ -125,6 +125,20 @@ public void Magnetization_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MagnetizationUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MagnetizationInfo_CreateWithCustomUnitInfos()
+        {
+            MagnetizationUnit[] expectedUnits = [MagnetizationUnit.AmperePerMeter];
+
+            Magnetization.MagnetizationInfo quantityInfo = Magnetization.MagnetizationInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Magnetization", quantityInfo.Name);
+            Assert.Equal(Magnetization.Zero, quantityInfo.Zero);
+            Assert.Equal(Magnetization.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void AmperePerMeterToMagnetizationUnits()
         {
@@ -209,31 +223,74 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Magnetization.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Magnetization convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Magnetization quantityToConvert = quantity;
+
+                Magnetization convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MagnetizationUnit> quantityToConvert = quantity;
+
+                IQuantity<MagnetizationUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Magnetization(value: 1, unit: Magnetization.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Magnetization(value: 1, unit: Magnetization.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MagnetizationUnit> quantity = new Magnetization(value: 1, unit: Magnetization.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Magnetization(value: 1, unit: Magnetization.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Magnetization(value: 1, unit: Magnetization.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Magnetization(value: 1, unit: Magnetization.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MagnetizationUnit> quantity = new Magnetization(value: 1, unit: Magnetization.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Magnetization(value: 1, unit: Magnetization.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 A/m", MagnetizationUnit.AmperePerMeter, 4.2)]
-        public void Parse(string culture, string quantityString, MagnetizationUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MagnetizationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Magnetization.Parse(quantityString);
@@ -243,7 +300,7 @@ public void Parse(string culture, string quantityString, MagnetizationUnit expec
 
         [Theory]
         [InlineData("en-US", "4.2 A/m", MagnetizationUnit.AmperePerMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, MagnetizationUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MagnetizationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Magnetization.TryParse(quantityString, out Magnetization parsed));
@@ -376,6 +433,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MagnetizationUni
                 var quantity = Magnetization.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -399,32 +457,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MagnetizationUnit u
                 IQuantity<MagnetizationUnit> quantityToConvert = quantity;
                 IQuantity<MagnetizationUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Magnetization amperepermeter = Magnetization.FromAmperesPerMeter(1);
-            AssertEx.EqualTolerance(1, Magnetization.FromAmperesPerMeter(amperepermeter.AmperesPerMeter).AmperesPerMeter, AmperesPerMeterTolerance);
+            Magnetization amperepermeter = Magnetization.FromAmperesPerMeter(3);
+            Assert.Equal(3, Magnetization.FromAmperesPerMeter(amperepermeter.AmperesPerMeter).AmperesPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Magnetization v = Magnetization.FromAmperesPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.AmperesPerMeter, AmperesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Magnetization.FromAmperesPerMeter(3)-v).AmperesPerMeter, AmperesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).AmperesPerMeter, AmperesPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).AmperesPerMeter, AmperesPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).AmperesPerMeter, AmperesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Magnetization.FromAmperesPerMeter(10)/5).AmperesPerMeter, AmperesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, Magnetization.FromAmperesPerMeter(10)/Magnetization.FromAmperesPerMeter(5), AmperesPerMeterTolerance);
+            Assert.Equal(-1, -v.AmperesPerMeter);
+            Assert.Equal(2, (Magnetization.FromAmperesPerMeter(3) - v).AmperesPerMeter);
+            Assert.Equal(2, (v + v).AmperesPerMeter);
+            Assert.Equal(10, (v * 10).AmperesPerMeter);
+            Assert.Equal(10, (10 * v).AmperesPerMeter);
+            Assert.Equal(2, (Magnetization.FromAmperesPerMeter(10) / 5).AmperesPerMeter);
+            Assert.Equal(2, Magnetization.FromAmperesPerMeter(10) / Magnetization.FromAmperesPerMeter(5));
         }
 
         [Fact]
@@ -470,7 +530,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MagnetizationUnit.AmperePerMeter, 1, MagnetizationUnit.AmperePerMeter, true)]  // Same value and unit.
         [InlineData(1, MagnetizationUnit.AmperePerMeter, 2, MagnetizationUnit.AmperePerMeter, false)] // Different value.
-        [InlineData(2, MagnetizationUnit.AmperePerMeter, 1, MagnetizationUnit.AmperePerMeter, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MagnetizationUnit unitA, double valueB, MagnetizationUnit unitB, bool expectEqual)
         {
             var a = new Magnetization(valueA, unitA);
@@ -530,8 +589,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Magnetization.FromAmperesPerMeter(firstValue);
             var otherQuantity = Magnetization.FromAmperesPerMeter(secondValue);
             Magnetization maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Magnetization.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -550,7 +609,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MagnetizationUnit>();
+            var units = EnumHelper.GetValues<MagnetizationUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -564,39 +623,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 A/m", new Magnetization(1, MagnetizationUnit.AmperePerMeter).ToString());
+            Assert.Equal(Magnetization.Info.Units, Magnetization.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 A/m", new Magnetization(1, MagnetizationUnit.AmperePerMeter).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, Magnetization.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 A/m", new Magnetization(0.123456, MagnetizationUnit.AmperePerMeter).ToString("s1"));
-            Assert.Equal("0.12 A/m", new Magnetization(0.123456, MagnetizationUnit.AmperePerMeter).ToString("s2"));
-            Assert.Equal("0.123 A/m", new Magnetization(0.123456, MagnetizationUnit.AmperePerMeter).ToString("s3"));
-            Assert.Equal("0.1235 A/m", new Magnetization(0.123456, MagnetizationUnit.AmperePerMeter).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 A/m", new Magnetization(1, MagnetizationUnit.AmperePerMeter).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 A/m", new Magnetization(0.123456, MagnetizationUnit.AmperePerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 A/m", new Magnetization(0.123456, MagnetizationUnit.AmperePerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 A/m", new Magnetization(0.123456, MagnetizationUnit.AmperePerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 A/m", new Magnetization(0.123456, MagnetizationUnit.AmperePerMeter).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 A/m", new Magnetization(1, MagnetizationUnit.AmperePerMeter).ToString(swedishCulture));
         }
 
         [Theory]
@@ -625,7 +676,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Magnetization.FromAmperesPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Magnetization), quantity.As(Magnetization.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs
index ea4ccb7413..bbe90ea58d 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs
@@ -317,6 +317,20 @@ public void MassConcentration_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
             Assert.Equal(quantityInfo, ((IQuantity<MassConcentrationUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MassConcentrationInfo_CreateWithCustomUnitInfos()
+        {
+            MassConcentrationUnit[] expectedUnits = [MassConcentrationUnit.KilogramPerCubicMeter];
+
+            MassConcentration.MassConcentrationInfo quantityInfo = MassConcentration.MassConcentrationInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MassConcentration", quantityInfo.Name);
+            Assert.Equal(MassConcentration.Zero, quantityInfo.Zero);
+            Assert.Equal(MassConcentration.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KilogramPerCubicMeterToMassConcentrationUnits()
         {
@@ -497,26 +511,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = MassConcentration.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            MassConcentration convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                MassConcentration quantityToConvert = quantity;
+
+                MassConcentration convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MassConcentrationUnit> quantityToConvert = quantity;
+
+                IQuantity<MassConcentrationUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new MassConcentration(value: 1, unit: MassConcentration.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MassConcentration(value: 1, unit: MassConcentration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MassConcentrationUnit> quantity = new MassConcentration(value: 1, unit: MassConcentration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MassConcentration(value: 1, unit: MassConcentration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new MassConcentration(value: 1, unit: MassConcentration.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MassConcentration(value: 1, unit: MassConcentration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MassConcentrationUnit> quantity = new MassConcentration(value: 1, unit: MassConcentration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MassConcentration(value: 1, unit: MassConcentration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -573,7 +630,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 кг/м³", MassConcentrationUnit.KilogramPerCubicMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мкг/м³", MassConcentrationUnit.MicrogramPerCubicMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мг/м³", MassConcentrationUnit.MilligramPerCubicMeter, 4.2)]
-        public void Parse(string culture, string quantityString, MassConcentrationUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MassConcentrationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MassConcentration.Parse(quantityString);
@@ -635,7 +692,7 @@ public void Parse(string culture, string quantityString, MassConcentrationUnit e
         [InlineData("ru-RU", "4,2 кг/м³", MassConcentrationUnit.KilogramPerCubicMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мкг/м³", MassConcentrationUnit.MicrogramPerCubicMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мг/м³", MassConcentrationUnit.MilligramPerCubicMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, MassConcentrationUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MassConcentrationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MassConcentration.TryParse(quantityString, out MassConcentration parsed));
@@ -1220,6 +1277,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MassConcentratio
                 var quantity = MassConcentration.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1243,80 +1301,82 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MassConcentrationUn
                 IQuantity<MassConcentrationUnit> quantityToConvert = quantity;
                 IQuantity<MassConcentrationUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MassConcentration kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, MassConcentration.FromCentigramsPerDeciliter(kilogrampercubicmeter.CentigramsPerDeciliter).KilogramsPerCubicMeter, CentigramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromCentigramsPerLiter(kilogrampercubicmeter.CentigramsPerLiter).KilogramsPerCubicMeter, CentigramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromCentigramsPerMicroliter(kilogrampercubicmeter.CentigramsPerMicroliter).KilogramsPerCubicMeter, CentigramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromCentigramsPerMilliliter(kilogrampercubicmeter.CentigramsPerMilliliter).KilogramsPerCubicMeter, CentigramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromDecigramsPerDeciliter(kilogrampercubicmeter.DecigramsPerDeciliter).KilogramsPerCubicMeter, DecigramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromDecigramsPerLiter(kilogrampercubicmeter.DecigramsPerLiter).KilogramsPerCubicMeter, DecigramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromDecigramsPerMicroliter(kilogrampercubicmeter.DecigramsPerMicroliter).KilogramsPerCubicMeter, DecigramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromDecigramsPerMilliliter(kilogrampercubicmeter.DecigramsPerMilliliter).KilogramsPerCubicMeter, DecigramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerCubicCentimeter(kilogrampercubicmeter.GramsPerCubicCentimeter).KilogramsPerCubicMeter, GramsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerCubicMeter(kilogrampercubicmeter.GramsPerCubicMeter).KilogramsPerCubicMeter, GramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerCubicMillimeter(kilogrampercubicmeter.GramsPerCubicMillimeter).KilogramsPerCubicMeter, GramsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerDeciliter(kilogrampercubicmeter.GramsPerDeciliter).KilogramsPerCubicMeter, GramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerLiter(kilogrampercubicmeter.GramsPerLiter).KilogramsPerCubicMeter, GramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerMicroliter(kilogrampercubicmeter.GramsPerMicroliter).KilogramsPerCubicMeter, GramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromGramsPerMilliliter(kilogrampercubicmeter.GramsPerMilliliter).KilogramsPerCubicMeter, GramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilogramsPerCubicCentimeter(kilogrampercubicmeter.KilogramsPerCubicCentimeter).KilogramsPerCubicMeter, KilogramsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilogramsPerCubicMeter(kilogrampercubicmeter.KilogramsPerCubicMeter).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilogramsPerCubicMillimeter(kilogrampercubicmeter.KilogramsPerCubicMillimeter).KilogramsPerCubicMeter, KilogramsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilogramsPerLiter(kilogrampercubicmeter.KilogramsPerLiter).KilogramsPerCubicMeter, KilogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilopoundsPerCubicFoot(kilogrampercubicmeter.KilopoundsPerCubicFoot).KilogramsPerCubicMeter, KilopoundsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromKilopoundsPerCubicInch(kilogrampercubicmeter.KilopoundsPerCubicInch).KilogramsPerCubicMeter, KilopoundsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMicrogramsPerCubicMeter(kilogrampercubicmeter.MicrogramsPerCubicMeter).KilogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMicrogramsPerDeciliter(kilogrampercubicmeter.MicrogramsPerDeciliter).KilogramsPerCubicMeter, MicrogramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMicrogramsPerLiter(kilogrampercubicmeter.MicrogramsPerLiter).KilogramsPerCubicMeter, MicrogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMicrogramsPerMicroliter(kilogrampercubicmeter.MicrogramsPerMicroliter).KilogramsPerCubicMeter, MicrogramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMicrogramsPerMilliliter(kilogrampercubicmeter.MicrogramsPerMilliliter).KilogramsPerCubicMeter, MicrogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMilligramsPerCubicMeter(kilogrampercubicmeter.MilligramsPerCubicMeter).KilogramsPerCubicMeter, MilligramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMilligramsPerDeciliter(kilogrampercubicmeter.MilligramsPerDeciliter).KilogramsPerCubicMeter, MilligramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMilligramsPerLiter(kilogrampercubicmeter.MilligramsPerLiter).KilogramsPerCubicMeter, MilligramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMilligramsPerMicroliter(kilogrampercubicmeter.MilligramsPerMicroliter).KilogramsPerCubicMeter, MilligramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromMilligramsPerMilliliter(kilogrampercubicmeter.MilligramsPerMilliliter).KilogramsPerCubicMeter, MilligramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerDeciliter(kilogrampercubicmeter.NanogramsPerDeciliter).KilogramsPerCubicMeter, NanogramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerLiter(kilogrampercubicmeter.NanogramsPerLiter).KilogramsPerCubicMeter, NanogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerMicroliter(kilogrampercubicmeter.NanogramsPerMicroliter).KilogramsPerCubicMeter, NanogramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerMilliliter(kilogrampercubicmeter.NanogramsPerMilliliter).KilogramsPerCubicMeter, NanogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromOuncesPerImperialGallon(kilogrampercubicmeter.OuncesPerImperialGallon).KilogramsPerCubicMeter, OuncesPerImperialGallonTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromOuncesPerUSGallon(kilogrampercubicmeter.OuncesPerUSGallon).KilogramsPerCubicMeter, OuncesPerUSGallonTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerDeciliter(kilogrampercubicmeter.PicogramsPerDeciliter).KilogramsPerCubicMeter, PicogramsPerDeciliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter, PicogramsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerMicroliter(kilogrampercubicmeter.PicogramsPerMicroliter).KilogramsPerCubicMeter, PicogramsPerMicroliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerMilliliter(kilogrampercubicmeter.PicogramsPerMilliliter).KilogramsPerCubicMeter, PicogramsPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPoundsPerCubicFoot(kilogrampercubicmeter.PoundsPerCubicFoot).KilogramsPerCubicMeter, PoundsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPoundsPerCubicInch(kilogrampercubicmeter.PoundsPerCubicInch).KilogramsPerCubicMeter, PoundsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPoundsPerImperialGallon(kilogrampercubicmeter.PoundsPerImperialGallon).KilogramsPerCubicMeter, PoundsPerImperialGallonTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromPoundsPerUSGallon(kilogrampercubicmeter.PoundsPerUSGallon).KilogramsPerCubicMeter, PoundsPerUSGallonTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromSlugsPerCubicFoot(kilogrampercubicmeter.SlugsPerCubicFoot).KilogramsPerCubicMeter, SlugsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromTonnesPerCubicCentimeter(kilogrampercubicmeter.TonnesPerCubicCentimeter).KilogramsPerCubicMeter, TonnesPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromTonnesPerCubicMeter(kilogrampercubicmeter.TonnesPerCubicMeter).KilogramsPerCubicMeter, TonnesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, MassConcentration.FromTonnesPerCubicMillimeter(kilogrampercubicmeter.TonnesPerCubicMillimeter).KilogramsPerCubicMeter, TonnesPerCubicMillimeterTolerance);
+            MassConcentration kilogrampercubicmeter = MassConcentration.FromKilogramsPerCubicMeter(3);
+            Assert.Equal(3, MassConcentration.FromCentigramsPerDeciliter(kilogrampercubicmeter.CentigramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromCentigramsPerLiter(kilogrampercubicmeter.CentigramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromCentigramsPerMicroliter(kilogrampercubicmeter.CentigramsPerMicroliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromCentigramsPerMilliliter(kilogrampercubicmeter.CentigramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromDecigramsPerDeciliter(kilogrampercubicmeter.DecigramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromDecigramsPerLiter(kilogrampercubicmeter.DecigramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromDecigramsPerMicroliter(kilogrampercubicmeter.DecigramsPerMicroliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromDecigramsPerMilliliter(kilogrampercubicmeter.DecigramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromGramsPerCubicCentimeter(kilogrampercubicmeter.GramsPerCubicCentimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromGramsPerCubicMeter(kilogrampercubicmeter.GramsPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromGramsPerCubicMillimeter(kilogrampercubicmeter.GramsPerCubicMillimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromGramsPerDeciliter(kilogrampercubicmeter.GramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromGramsPerLiter(kilogrampercubicmeter.GramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromGramsPerMicroliter(kilogrampercubicmeter.GramsPerMicroliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromGramsPerMilliliter(kilogrampercubicmeter.GramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromKilogramsPerCubicCentimeter(kilogrampercubicmeter.KilogramsPerCubicCentimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromKilogramsPerCubicMeter(kilogrampercubicmeter.KilogramsPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromKilogramsPerCubicMillimeter(kilogrampercubicmeter.KilogramsPerCubicMillimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromKilogramsPerLiter(kilogrampercubicmeter.KilogramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromKilopoundsPerCubicFoot(kilogrampercubicmeter.KilopoundsPerCubicFoot).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromKilopoundsPerCubicInch(kilogrampercubicmeter.KilopoundsPerCubicInch).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromMicrogramsPerCubicMeter(kilogrampercubicmeter.MicrogramsPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromMicrogramsPerDeciliter(kilogrampercubicmeter.MicrogramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromMicrogramsPerLiter(kilogrampercubicmeter.MicrogramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromMicrogramsPerMicroliter(kilogrampercubicmeter.MicrogramsPerMicroliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromMicrogramsPerMilliliter(kilogrampercubicmeter.MicrogramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromMilligramsPerCubicMeter(kilogrampercubicmeter.MilligramsPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromMilligramsPerDeciliter(kilogrampercubicmeter.MilligramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromMilligramsPerLiter(kilogrampercubicmeter.MilligramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromMilligramsPerMicroliter(kilogrampercubicmeter.MilligramsPerMicroliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromMilligramsPerMilliliter(kilogrampercubicmeter.MilligramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromNanogramsPerDeciliter(kilogrampercubicmeter.NanogramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromNanogramsPerLiter(kilogrampercubicmeter.NanogramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromNanogramsPerMicroliter(kilogrampercubicmeter.NanogramsPerMicroliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromNanogramsPerMilliliter(kilogrampercubicmeter.NanogramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromOuncesPerImperialGallon(kilogrampercubicmeter.OuncesPerImperialGallon).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromOuncesPerUSGallon(kilogrampercubicmeter.OuncesPerUSGallon).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromPicogramsPerDeciliter(kilogrampercubicmeter.PicogramsPerDeciliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromPicogramsPerMicroliter(kilogrampercubicmeter.PicogramsPerMicroliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromPicogramsPerMilliliter(kilogrampercubicmeter.PicogramsPerMilliliter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromPoundsPerCubicFoot(kilogrampercubicmeter.PoundsPerCubicFoot).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromPoundsPerCubicInch(kilogrampercubicmeter.PoundsPerCubicInch).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromPoundsPerImperialGallon(kilogrampercubicmeter.PoundsPerImperialGallon).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromPoundsPerUSGallon(kilogrampercubicmeter.PoundsPerUSGallon).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromSlugsPerCubicFoot(kilogrampercubicmeter.SlugsPerCubicFoot).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromTonnesPerCubicCentimeter(kilogrampercubicmeter.TonnesPerCubicCentimeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromTonnesPerCubicMeter(kilogrampercubicmeter.TonnesPerCubicMeter).KilogramsPerCubicMeter);
+            Assert.Equal(3, MassConcentration.FromTonnesPerCubicMillimeter(kilogrampercubicmeter.TonnesPerCubicMillimeter).KilogramsPerCubicMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MassConcentration v = MassConcentration.FromKilogramsPerCubicMeter(1);
-            AssertEx.EqualTolerance(-1, -v.KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (MassConcentration.FromKilogramsPerCubicMeter(3)-v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (MassConcentration.FromKilogramsPerCubicMeter(10)/5).KilogramsPerCubicMeter, KilogramsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, MassConcentration.FromKilogramsPerCubicMeter(10)/MassConcentration.FromKilogramsPerCubicMeter(5), KilogramsPerCubicMeterTolerance);
+            Assert.Equal(-1, -v.KilogramsPerCubicMeter);
+            Assert.Equal(2, (MassConcentration.FromKilogramsPerCubicMeter(3) - v).KilogramsPerCubicMeter);
+            Assert.Equal(2, (v + v).KilogramsPerCubicMeter);
+            Assert.Equal(10, (v * 10).KilogramsPerCubicMeter);
+            Assert.Equal(10, (10 * v).KilogramsPerCubicMeter);
+            Assert.Equal(2, (MassConcentration.FromKilogramsPerCubicMeter(10) / 5).KilogramsPerCubicMeter);
+            Assert.Equal(2, MassConcentration.FromKilogramsPerCubicMeter(10) / MassConcentration.FromKilogramsPerCubicMeter(5));
         }
 
         [Fact]
@@ -1362,8 +1422,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MassConcentrationUnit.KilogramPerCubicMeter, 1, MassConcentrationUnit.KilogramPerCubicMeter, true)]  // Same value and unit.
         [InlineData(1, MassConcentrationUnit.KilogramPerCubicMeter, 2, MassConcentrationUnit.KilogramPerCubicMeter, false)] // Different value.
-        [InlineData(2, MassConcentrationUnit.KilogramPerCubicMeter, 1, MassConcentrationUnit.CentigramPerDeciliter, false)] // Different value and unit.
-        [InlineData(1, MassConcentrationUnit.KilogramPerCubicMeter, 1, MassConcentrationUnit.CentigramPerDeciliter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MassConcentrationUnit unitA, double valueB, MassConcentrationUnit unitB, bool expectEqual)
         {
             var a = new MassConcentration(valueA, unitA);
@@ -1423,8 +1481,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MassConcentration.FromKilogramsPerCubicMeter(firstValue);
             var otherQuantity = MassConcentration.FromKilogramsPerCubicMeter(secondValue);
             MassConcentration maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MassConcentration.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1443,7 +1501,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MassConcentrationUnit>();
+            var units = EnumHelper.GetValues<MassConcentrationUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1456,6 +1514,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(MassConcentration.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(MassConcentration.Info.Units, MassConcentration.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, MassConcentration.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1568,26 +1638,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 t/mm³", new MassConcentration(1, MassConcentrationUnit.TonnePerCubicMillimeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 kg/m³", new MassConcentration(0.123456, MassConcentrationUnit.KilogramPerCubicMeter).ToString("s1"));
-            Assert.Equal("0.12 kg/m³", new MassConcentration(0.123456, MassConcentrationUnit.KilogramPerCubicMeter).ToString("s2"));
-            Assert.Equal("0.123 kg/m³", new MassConcentration(0.123456, MassConcentrationUnit.KilogramPerCubicMeter).ToString("s3"));
-            Assert.Equal("0.1235 kg/m³", new MassConcentration(0.123456, MassConcentrationUnit.KilogramPerCubicMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 kg/m³", new MassConcentration(0.123456, MassConcentrationUnit.KilogramPerCubicMeter).ToString("s1", culture));
-            Assert.Equal("0.12 kg/m³", new MassConcentration(0.123456, MassConcentrationUnit.KilogramPerCubicMeter).ToString("s2", culture));
-            Assert.Equal("0.123 kg/m³", new MassConcentration(0.123456, MassConcentrationUnit.KilogramPerCubicMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 kg/m³", new MassConcentration(0.123456, MassConcentrationUnit.KilogramPerCubicMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1614,7 +1664,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MassConcentration.FromKilogramsPerCubicMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MassConcentration), quantity.As(MassConcentration.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs
index 6fe7c26333..a4f9d0b9c2 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFlowTestsBase.g.cs
@@ -253,6 +253,20 @@ public void MassFlow_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MassFlowUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MassFlowInfo_CreateWithCustomUnitInfos()
+        {
+            MassFlowUnit[] expectedUnits = [MassFlowUnit.GramPerSecond];
+
+            MassFlow.MassFlowInfo quantityInfo = MassFlow.MassFlowInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MassFlow", quantityInfo.Name);
+            Assert.Equal(MassFlow.Zero, quantityInfo.Zero);
+            Assert.Equal(MassFlow.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void GramPerSecondToMassFlowUnits()
         {
@@ -401,26 +415,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = MassFlow.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            MassFlow convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                MassFlow quantityToConvert = quantity;
+
+                MassFlow convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MassFlowUnit> quantityToConvert = quantity;
+
+                IQuantity<MassFlowUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new MassFlow(value: 1, unit: MassFlow.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MassFlow(value: 1, unit: MassFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MassFlowUnit> quantity = new MassFlow(value: 1, unit: MassFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MassFlow(value: 1, unit: MassFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new MassFlow(value: 1, unit: MassFlow.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MassFlow(value: 1, unit: MassFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MassFlowUnit> quantity = new MassFlow(value: 1, unit: MassFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MassFlow(value: 1, unit: MassFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -468,7 +525,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 t/h", MassFlowUnit.TonnePerHour, 4.2)]
         [InlineData("ru-RU", "4,2 кг/ч", MassFlowUnit.KilogramPerHour, 4.2)]
         [InlineData("ru-RU", "4,2 кг/мин", MassFlowUnit.KilogramPerMinute, 4.2)]
-        public void Parse(string culture, string quantityString, MassFlowUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MassFlowUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MassFlow.Parse(quantityString);
@@ -521,7 +578,7 @@ public void Parse(string culture, string quantityString, MassFlowUnit expectedUn
         [InlineData("en-US", "4.2 t/h", MassFlowUnit.TonnePerHour, 4.2)]
         [InlineData("ru-RU", "4,2 кг/ч", MassFlowUnit.KilogramPerHour, 4.2)]
         [InlineData("ru-RU", "4,2 кг/мин", MassFlowUnit.KilogramPerMinute, 4.2)]
-        public void TryParse(string culture, string quantityString, MassFlowUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MassFlowUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MassFlow.TryParse(quantityString, out MassFlow parsed));
@@ -1024,6 +1081,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MassFlowUnit uni
                 var quantity = MassFlow.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1047,64 +1105,66 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MassFlowUnit unit)
                 IQuantity<MassFlowUnit> quantityToConvert = quantity;
                 IQuantity<MassFlowUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MassFlow grampersecond = MassFlow.FromGramsPerSecond(1);
-            AssertEx.EqualTolerance(1, MassFlow.FromCentigramsPerDay(grampersecond.CentigramsPerDay).GramsPerSecond, CentigramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromCentigramsPerSecond(grampersecond.CentigramsPerSecond).GramsPerSecond, CentigramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromDecagramsPerDay(grampersecond.DecagramsPerDay).GramsPerSecond, DecagramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromDecagramsPerSecond(grampersecond.DecagramsPerSecond).GramsPerSecond, DecagramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromDecigramsPerDay(grampersecond.DecigramsPerDay).GramsPerSecond, DecigramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromDecigramsPerSecond(grampersecond.DecigramsPerSecond).GramsPerSecond, DecigramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromGramsPerDay(grampersecond.GramsPerDay).GramsPerSecond, GramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromGramsPerHour(grampersecond.GramsPerHour).GramsPerSecond, GramsPerHourTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromGramsPerSecond(grampersecond.GramsPerSecond).GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromHectogramsPerDay(grampersecond.HectogramsPerDay).GramsPerSecond, HectogramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromHectogramsPerSecond(grampersecond.HectogramsPerSecond).GramsPerSecond, HectogramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromKilogramsPerDay(grampersecond.KilogramsPerDay).GramsPerSecond, KilogramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromKilogramsPerHour(grampersecond.KilogramsPerHour).GramsPerSecond, KilogramsPerHourTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromKilogramsPerMinute(grampersecond.KilogramsPerMinute).GramsPerSecond, KilogramsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromKilogramsPerSecond(grampersecond.KilogramsPerSecond).GramsPerSecond, KilogramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMegagramsPerDay(grampersecond.MegagramsPerDay).GramsPerSecond, MegagramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMegapoundsPerDay(grampersecond.MegapoundsPerDay).GramsPerSecond, MegapoundsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMegapoundsPerHour(grampersecond.MegapoundsPerHour).GramsPerSecond, MegapoundsPerHourTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMegapoundsPerMinute(grampersecond.MegapoundsPerMinute).GramsPerSecond, MegapoundsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMegapoundsPerSecond(grampersecond.MegapoundsPerSecond).GramsPerSecond, MegapoundsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMicrogramsPerDay(grampersecond.MicrogramsPerDay).GramsPerSecond, MicrogramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMicrogramsPerSecond(grampersecond.MicrogramsPerSecond).GramsPerSecond, MicrogramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMilligramsPerDay(grampersecond.MilligramsPerDay).GramsPerSecond, MilligramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromMilligramsPerSecond(grampersecond.MilligramsPerSecond).GramsPerSecond, MilligramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromNanogramsPerDay(grampersecond.NanogramsPerDay).GramsPerSecond, NanogramsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromNanogramsPerSecond(grampersecond.NanogramsPerSecond).GramsPerSecond, NanogramsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromPoundsPerDay(grampersecond.PoundsPerDay).GramsPerSecond, PoundsPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromPoundsPerHour(grampersecond.PoundsPerHour).GramsPerSecond, PoundsPerHourTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromPoundsPerMinute(grampersecond.PoundsPerMinute).GramsPerSecond, PoundsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromPoundsPerSecond(grampersecond.PoundsPerSecond).GramsPerSecond, PoundsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromShortTonsPerHour(grampersecond.ShortTonsPerHour).GramsPerSecond, ShortTonsPerHourTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromTonnesPerDay(grampersecond.TonnesPerDay).GramsPerSecond, TonnesPerDayTolerance);
-            AssertEx.EqualTolerance(1, MassFlow.FromTonnesPerHour(grampersecond.TonnesPerHour).GramsPerSecond, TonnesPerHourTolerance);
+            MassFlow grampersecond = MassFlow.FromGramsPerSecond(3);
+            Assert.Equal(3, MassFlow.FromCentigramsPerDay(grampersecond.CentigramsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromCentigramsPerSecond(grampersecond.CentigramsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromDecagramsPerDay(grampersecond.DecagramsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromDecagramsPerSecond(grampersecond.DecagramsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromDecigramsPerDay(grampersecond.DecigramsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromDecigramsPerSecond(grampersecond.DecigramsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromGramsPerDay(grampersecond.GramsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromGramsPerHour(grampersecond.GramsPerHour).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromGramsPerSecond(grampersecond.GramsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromHectogramsPerDay(grampersecond.HectogramsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromHectogramsPerSecond(grampersecond.HectogramsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromKilogramsPerDay(grampersecond.KilogramsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromKilogramsPerHour(grampersecond.KilogramsPerHour).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromKilogramsPerMinute(grampersecond.KilogramsPerMinute).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromKilogramsPerSecond(grampersecond.KilogramsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromMegagramsPerDay(grampersecond.MegagramsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromMegapoundsPerDay(grampersecond.MegapoundsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromMegapoundsPerHour(grampersecond.MegapoundsPerHour).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromMegapoundsPerMinute(grampersecond.MegapoundsPerMinute).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromMegapoundsPerSecond(grampersecond.MegapoundsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromMicrogramsPerDay(grampersecond.MicrogramsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromMicrogramsPerSecond(grampersecond.MicrogramsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromMilligramsPerDay(grampersecond.MilligramsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromMilligramsPerSecond(grampersecond.MilligramsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromNanogramsPerDay(grampersecond.NanogramsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromNanogramsPerSecond(grampersecond.NanogramsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromPoundsPerDay(grampersecond.PoundsPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromPoundsPerHour(grampersecond.PoundsPerHour).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromPoundsPerMinute(grampersecond.PoundsPerMinute).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromPoundsPerSecond(grampersecond.PoundsPerSecond).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromShortTonsPerHour(grampersecond.ShortTonsPerHour).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromTonnesPerDay(grampersecond.TonnesPerDay).GramsPerSecond);
+            Assert.Equal(3, MassFlow.FromTonnesPerHour(grampersecond.TonnesPerHour).GramsPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MassFlow v = MassFlow.FromGramsPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (MassFlow.FromGramsPerSecond(3)-v).GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (MassFlow.FromGramsPerSecond(10)/5).GramsPerSecond, GramsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, MassFlow.FromGramsPerSecond(10)/MassFlow.FromGramsPerSecond(5), GramsPerSecondTolerance);
+            Assert.Equal(-1, -v.GramsPerSecond);
+            Assert.Equal(2, (MassFlow.FromGramsPerSecond(3) - v).GramsPerSecond);
+            Assert.Equal(2, (v + v).GramsPerSecond);
+            Assert.Equal(10, (v * 10).GramsPerSecond);
+            Assert.Equal(10, (10 * v).GramsPerSecond);
+            Assert.Equal(2, (MassFlow.FromGramsPerSecond(10) / 5).GramsPerSecond);
+            Assert.Equal(2, MassFlow.FromGramsPerSecond(10) / MassFlow.FromGramsPerSecond(5));
         }
 
         [Fact]
@@ -1150,8 +1210,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MassFlowUnit.GramPerSecond, 1, MassFlowUnit.GramPerSecond, true)]  // Same value and unit.
         [InlineData(1, MassFlowUnit.GramPerSecond, 2, MassFlowUnit.GramPerSecond, false)] // Different value.
-        [InlineData(2, MassFlowUnit.GramPerSecond, 1, MassFlowUnit.CentigramPerDay, false)] // Different value and unit.
-        [InlineData(1, MassFlowUnit.GramPerSecond, 1, MassFlowUnit.CentigramPerDay, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MassFlowUnit unitA, double valueB, MassFlowUnit unitB, bool expectEqual)
         {
             var a = new MassFlow(valueA, unitA);
@@ -1211,8 +1269,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MassFlow.FromGramsPerSecond(firstValue);
             var otherQuantity = MassFlow.FromGramsPerSecond(secondValue);
             MassFlow maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MassFlow.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1231,7 +1289,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MassFlowUnit>();
+            var units = EnumHelper.GetValues<MassFlowUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1244,6 +1302,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(MassFlow.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(MassFlow.Info.Units, MassFlow.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, MassFlow.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1324,26 +1394,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 t/h", new MassFlow(1, MassFlowUnit.TonnePerHour).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 g/s", new MassFlow(0.123456, MassFlowUnit.GramPerSecond).ToString("s1"));
-            Assert.Equal("0.12 g/s", new MassFlow(0.123456, MassFlowUnit.GramPerSecond).ToString("s2"));
-            Assert.Equal("0.123 g/s", new MassFlow(0.123456, MassFlowUnit.GramPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 g/s", new MassFlow(0.123456, MassFlowUnit.GramPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 g/s", new MassFlow(0.123456, MassFlowUnit.GramPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 g/s", new MassFlow(0.123456, MassFlowUnit.GramPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 g/s", new MassFlow(0.123456, MassFlowUnit.GramPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 g/s", new MassFlow(0.123456, MassFlowUnit.GramPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1370,7 +1420,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MassFlow.FromGramsPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MassFlow), quantity.As(MassFlow.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs
index 8349116945..58a0ca930b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFluxTestsBase.g.cs
@@ -169,6 +169,20 @@ public void MassFlux_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MassFluxUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MassFluxInfo_CreateWithCustomUnitInfos()
+        {
+            MassFluxUnit[] expectedUnits = [MassFluxUnit.KilogramPerSecondPerSquareMeter];
+
+            MassFlux.MassFluxInfo quantityInfo = MassFlux.MassFluxInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MassFlux", quantityInfo.Name);
+            Assert.Equal(MassFlux.Zero, quantityInfo.Zero);
+            Assert.Equal(MassFlux.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KilogramPerSecondPerSquareMeterToMassFluxUnits()
         {
@@ -275,26 +289,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = MassFlux.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            MassFlux convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                MassFlux quantityToConvert = quantity;
+
+                MassFlux convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MassFluxUnit> quantityToConvert = quantity;
+
+                IQuantity<MassFluxUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new MassFlux(value: 1, unit: MassFlux.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MassFlux(value: 1, unit: MassFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MassFluxUnit> quantity = new MassFlux(value: 1, unit: MassFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MassFlux(value: 1, unit: MassFlux.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new MassFlux(value: 1, unit: MassFlux.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MassFlux(value: 1, unit: MassFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MassFluxUnit> quantity = new MassFlux(value: 1, unit: MassFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MassFlux(value: 1, unit: MassFlux.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -310,7 +367,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 kg·s⁻¹·cm⁻²", MassFluxUnit.KilogramPerSecondPerSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 kg·s⁻¹·m⁻²", MassFluxUnit.KilogramPerSecondPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 kg·s⁻¹·mm⁻²", MassFluxUnit.KilogramPerSecondPerSquareMillimeter, 4.2)]
-        public void Parse(string culture, string quantityString, MassFluxUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MassFluxUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MassFlux.Parse(quantityString);
@@ -331,7 +388,7 @@ public void Parse(string culture, string quantityString, MassFluxUnit expectedUn
         [InlineData("en-US", "4.2 kg·s⁻¹·cm⁻²", MassFluxUnit.KilogramPerSecondPerSquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 kg·s⁻¹·m⁻²", MassFluxUnit.KilogramPerSecondPerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 kg·s⁻¹·mm⁻²", MassFluxUnit.KilogramPerSecondPerSquareMillimeter, 4.2)]
-        public void TryParse(string culture, string quantityString, MassFluxUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MassFluxUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MassFlux.TryParse(quantityString, out MassFlux parsed));
@@ -563,6 +620,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MassFluxUnit uni
                 var quantity = MassFlux.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -586,43 +644,45 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MassFluxUnit unit)
                 IQuantity<MassFluxUnit> quantityToConvert = quantity;
                 IQuantity<MassFluxUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MassFlux kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerHourPerSquareCentimeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, GramsPerHourPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerHourPerSquareMeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareMeter).KilogramsPerSecondPerSquareMeter, GramsPerHourPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerHourPerSquareMillimeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, GramsPerHourPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerSecondPerSquareCentimeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, GramsPerSecondPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerSecondPerSquareMeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter, GramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromGramsPerSecondPerSquareMillimeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, GramsPerSecondPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerHourPerSquareCentimeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerHourPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerHourPerSquareMeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareMeter).KilogramsPerSecondPerSquareMeter, KilogramsPerHourPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerHourPerSquareMillimeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerHourPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerSecondPerSquareCentimeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareCentimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerSecondPerSquareMeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, MassFlux.FromKilogramsPerSecondPerSquareMillimeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareMillimeter).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMillimeterTolerance);
+            MassFlux kilogrampersecondpersquaremeter = MassFlux.FromKilogramsPerSecondPerSquareMeter(3);
+            Assert.Equal(3, MassFlux.FromGramsPerHourPerSquareCentimeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareCentimeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromGramsPerHourPerSquareMeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareMeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromGramsPerHourPerSquareMillimeter(kilogrampersecondpersquaremeter.GramsPerHourPerSquareMillimeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromGramsPerSecondPerSquareCentimeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareCentimeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromGramsPerSecondPerSquareMeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromGramsPerSecondPerSquareMillimeter(kilogrampersecondpersquaremeter.GramsPerSecondPerSquareMillimeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromKilogramsPerHourPerSquareCentimeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareCentimeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromKilogramsPerHourPerSquareMeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareMeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromKilogramsPerHourPerSquareMillimeter(kilogrampersecondpersquaremeter.KilogramsPerHourPerSquareMillimeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromKilogramsPerSecondPerSquareCentimeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareCentimeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromKilogramsPerSecondPerSquareMeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareMeter).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(3, MassFlux.FromKilogramsPerSecondPerSquareMillimeter(kilogrampersecondpersquaremeter.KilogramsPerSecondPerSquareMillimeter).KilogramsPerSecondPerSquareMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MassFlux v = MassFlux.FromKilogramsPerSecondPerSquareMeter(1);
-            AssertEx.EqualTolerance(-1, -v.KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (MassFlux.FromKilogramsPerSecondPerSquareMeter(3)-v).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (MassFlux.FromKilogramsPerSecondPerSquareMeter(10)/5).KilogramsPerSecondPerSquareMeter, KilogramsPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, MassFlux.FromKilogramsPerSecondPerSquareMeter(10)/MassFlux.FromKilogramsPerSecondPerSquareMeter(5), KilogramsPerSecondPerSquareMeterTolerance);
+            Assert.Equal(-1, -v.KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(2, (MassFlux.FromKilogramsPerSecondPerSquareMeter(3) - v).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(2, (v + v).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(10, (v * 10).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(10, (10 * v).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(2, (MassFlux.FromKilogramsPerSecondPerSquareMeter(10) / 5).KilogramsPerSecondPerSquareMeter);
+            Assert.Equal(2, MassFlux.FromKilogramsPerSecondPerSquareMeter(10) / MassFlux.FromKilogramsPerSecondPerSquareMeter(5));
         }
 
         [Fact]
@@ -668,8 +728,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MassFluxUnit.KilogramPerSecondPerSquareMeter, 1, MassFluxUnit.KilogramPerSecondPerSquareMeter, true)]  // Same value and unit.
         [InlineData(1, MassFluxUnit.KilogramPerSecondPerSquareMeter, 2, MassFluxUnit.KilogramPerSecondPerSquareMeter, false)] // Different value.
-        [InlineData(2, MassFluxUnit.KilogramPerSecondPerSquareMeter, 1, MassFluxUnit.GramPerHourPerSquareCentimeter, false)] // Different value and unit.
-        [InlineData(1, MassFluxUnit.KilogramPerSecondPerSquareMeter, 1, MassFluxUnit.GramPerHourPerSquareCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MassFluxUnit unitA, double valueB, MassFluxUnit unitB, bool expectEqual)
         {
             var a = new MassFlux(valueA, unitA);
@@ -729,8 +787,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MassFlux.FromKilogramsPerSecondPerSquareMeter(firstValue);
             var otherQuantity = MassFlux.FromKilogramsPerSecondPerSquareMeter(secondValue);
             MassFlux maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MassFlux.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -749,7 +807,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MassFluxUnit>();
+            var units = EnumHelper.GetValues<MassFluxUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -762,6 +820,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(MassFlux.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(MassFlux.Info.Units, MassFlux.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, MassFlux.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -800,26 +870,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 kg·s⁻¹·mm⁻²", new MassFlux(1, MassFluxUnit.KilogramPerSecondPerSquareMillimeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 kg·s⁻¹·m⁻²", new MassFlux(0.123456, MassFluxUnit.KilogramPerSecondPerSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 kg·s⁻¹·m⁻²", new MassFlux(0.123456, MassFluxUnit.KilogramPerSecondPerSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 kg·s⁻¹·m⁻²", new MassFlux(0.123456, MassFluxUnit.KilogramPerSecondPerSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 kg·s⁻¹·m⁻²", new MassFlux(0.123456, MassFluxUnit.KilogramPerSecondPerSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 kg·s⁻¹·m⁻²", new MassFlux(0.123456, MassFluxUnit.KilogramPerSecondPerSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 kg·s⁻¹·m⁻²", new MassFlux(0.123456, MassFluxUnit.KilogramPerSecondPerSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 kg·s⁻¹·m⁻²", new MassFlux(0.123456, MassFluxUnit.KilogramPerSecondPerSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 kg·s⁻¹·m⁻²", new MassFlux(0.123456, MassFluxUnit.KilogramPerSecondPerSquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -846,7 +896,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MassFlux.FromKilogramsPerSecondPerSquareMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MassFlux), quantity.As(MassFlux.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs
index 008e2ebdd4..e9f0449a7f 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassFractionTestsBase.g.cs
@@ -196,6 +196,20 @@ public void MassFraction_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MassFractionUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MassFractionInfo_CreateWithCustomUnitInfos()
+        {
+            MassFractionUnit[] expectedUnits = [MassFractionUnit.DecimalFraction];
+
+            MassFraction.MassFractionInfo quantityInfo = MassFraction.MassFractionInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MassFraction", quantityInfo.Name);
+            Assert.Equal(MassFraction.Zero, quantityInfo.Zero);
+            Assert.Equal(MassFraction.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void DecimalFractionToMassFractionUnits()
         {
@@ -306,12 +320,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new MassFraction(value: 1, unit: MassFractionUnit.DecimalFraction);
+            Assert.Multiple(() =>
+            {
+                var quantity = new MassFraction(value: 1, unit: MassFractionUnit.DecimalFraction);
+
+                MassFraction convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(MassFractionUnit.DecimalFraction, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MassFractionUnit> quantity = new MassFraction(value: 1, unit: MassFractionUnit.DecimalFraction);
+
+                IQuantity<MassFractionUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(MassFractionUnit.DecimalFraction, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new MassFraction(value: 1, unit: MassFractionUnit.DecimalFraction);
 
-            MassFraction convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(MassFractionUnit.DecimalFraction, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(MassFractionUnit.DecimalFraction, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -359,7 +392,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [InlineData("en-US", "4.2 ppt", MassFractionUnit.PartPerTrillion, 4.2)]
         [InlineData("en-US", "4.2 %", MassFractionUnit.Percent, 4.2)]
         [InlineData("en-US", "4.2 % (w/w)", MassFractionUnit.Percent, 4.2)]
-        public void Parse(string culture, string quantityString, MassFractionUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MassFractionUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MassFraction.Parse(quantityString);
@@ -393,7 +426,7 @@ public void Parse(string culture, string quantityString, MassFractionUnit expect
         [InlineData("en-US", "4.2 ppt", MassFractionUnit.PartPerTrillion, 4.2)]
         [InlineData("en-US", "4.2 %", MassFractionUnit.Percent, 4.2)]
         [InlineData("en-US", "4.2 % (w/w)", MassFractionUnit.Percent, 4.2)]
-        public void TryParse(string culture, string quantityString, MassFractionUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MassFractionUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MassFraction.TryParse(quantityString, out MassFraction parsed));
@@ -741,6 +774,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MassFractionUnit
                 var quantity = MassFraction.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -764,55 +798,57 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MassFractionUnit un
                 IQuantity<MassFractionUnit> quantityToConvert = quantity;
                 IQuantity<MassFractionUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MassFraction decimalfraction = MassFraction.FromDecimalFractions(1);
-            AssertEx.EqualTolerance(1, MassFraction.FromCentigramsPerGram(decimalfraction.CentigramsPerGram).DecimalFractions, CentigramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromCentigramsPerKilogram(decimalfraction.CentigramsPerKilogram).DecimalFractions, CentigramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromDecagramsPerGram(decimalfraction.DecagramsPerGram).DecimalFractions, DecagramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromDecagramsPerKilogram(decimalfraction.DecagramsPerKilogram).DecimalFractions, DecagramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromDecigramsPerGram(decimalfraction.DecigramsPerGram).DecimalFractions, DecigramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromDecigramsPerKilogram(decimalfraction.DecigramsPerKilogram).DecimalFractions, DecigramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromGramsPerGram(decimalfraction.GramsPerGram).DecimalFractions, GramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromGramsPerKilogram(decimalfraction.GramsPerKilogram).DecimalFractions, GramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromHectogramsPerGram(decimalfraction.HectogramsPerGram).DecimalFractions, HectogramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromHectogramsPerKilogram(decimalfraction.HectogramsPerKilogram).DecimalFractions, HectogramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromKilogramsPerGram(decimalfraction.KilogramsPerGram).DecimalFractions, KilogramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromKilogramsPerKilogram(decimalfraction.KilogramsPerKilogram).DecimalFractions, KilogramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromMicrogramsPerGram(decimalfraction.MicrogramsPerGram).DecimalFractions, MicrogramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromMicrogramsPerKilogram(decimalfraction.MicrogramsPerKilogram).DecimalFractions, MicrogramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromMilligramsPerGram(decimalfraction.MilligramsPerGram).DecimalFractions, MilligramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromMilligramsPerKilogram(decimalfraction.MilligramsPerKilogram).DecimalFractions, MilligramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromNanogramsPerGram(decimalfraction.NanogramsPerGram).DecimalFractions, NanogramsPerGramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromNanogramsPerKilogram(decimalfraction.NanogramsPerKilogram).DecimalFractions, NanogramsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance);
-            AssertEx.EqualTolerance(1, MassFraction.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance);
+            MassFraction decimalfraction = MassFraction.FromDecimalFractions(3);
+            Assert.Equal(3, MassFraction.FromCentigramsPerGram(decimalfraction.CentigramsPerGram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromCentigramsPerKilogram(decimalfraction.CentigramsPerKilogram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromDecagramsPerGram(decimalfraction.DecagramsPerGram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromDecagramsPerKilogram(decimalfraction.DecagramsPerKilogram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromDecigramsPerGram(decimalfraction.DecigramsPerGram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromDecigramsPerKilogram(decimalfraction.DecigramsPerKilogram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromGramsPerGram(decimalfraction.GramsPerGram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromGramsPerKilogram(decimalfraction.GramsPerKilogram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromHectogramsPerGram(decimalfraction.HectogramsPerGram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromHectogramsPerKilogram(decimalfraction.HectogramsPerKilogram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromKilogramsPerGram(decimalfraction.KilogramsPerGram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromKilogramsPerKilogram(decimalfraction.KilogramsPerKilogram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromMicrogramsPerGram(decimalfraction.MicrogramsPerGram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromMicrogramsPerKilogram(decimalfraction.MicrogramsPerKilogram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromMilligramsPerGram(decimalfraction.MilligramsPerGram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromMilligramsPerKilogram(decimalfraction.MilligramsPerKilogram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromNanogramsPerGram(decimalfraction.NanogramsPerGram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromNanogramsPerKilogram(decimalfraction.NanogramsPerKilogram).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions);
+            Assert.Equal(3, MassFraction.FromPercent(decimalfraction.Percent).DecimalFractions);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MassFraction v = MassFraction.FromDecimalFractions(1);
-            AssertEx.EqualTolerance(-1, -v.DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (MassFraction.FromDecimalFractions(3)-v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (MassFraction.FromDecimalFractions(10)/5).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, MassFraction.FromDecimalFractions(10)/MassFraction.FromDecimalFractions(5), DecimalFractionsTolerance);
+            Assert.Equal(-1, -v.DecimalFractions);
+            Assert.Equal(2, (MassFraction.FromDecimalFractions(3) - v).DecimalFractions);
+            Assert.Equal(2, (v + v).DecimalFractions);
+            Assert.Equal(10, (v * 10).DecimalFractions);
+            Assert.Equal(10, (10 * v).DecimalFractions);
+            Assert.Equal(2, (MassFraction.FromDecimalFractions(10) / 5).DecimalFractions);
+            Assert.Equal(2, MassFraction.FromDecimalFractions(10) / MassFraction.FromDecimalFractions(5));
         }
 
         [Fact]
@@ -858,8 +894,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MassFractionUnit.DecimalFraction, 1, MassFractionUnit.DecimalFraction, true)]  // Same value and unit.
         [InlineData(1, MassFractionUnit.DecimalFraction, 2, MassFractionUnit.DecimalFraction, false)] // Different value.
-        [InlineData(2, MassFractionUnit.DecimalFraction, 1, MassFractionUnit.CentigramPerGram, false)] // Different value and unit.
-        [InlineData(1, MassFractionUnit.DecimalFraction, 1, MassFractionUnit.CentigramPerGram, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MassFractionUnit unitA, double valueB, MassFractionUnit unitB, bool expectEqual)
         {
             var a = new MassFraction(valueA, unitA);
@@ -919,8 +953,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MassFraction.FromDecimalFractions(firstValue);
             var otherQuantity = MassFraction.FromDecimalFractions(secondValue);
             MassFraction maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MassFraction.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -939,7 +973,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MassFractionUnit>();
+            var units = EnumHelper.GetValues<MassFractionUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -952,6 +986,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(MassFraction.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(MassFraction.Info.Units, MassFraction.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, MassFraction.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1014,26 +1060,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 %", new MassFraction(1, MassFractionUnit.Percent).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1", new MassFraction(0.123456, MassFractionUnit.DecimalFraction).ToString("s1"));
-            Assert.Equal("0.12", new MassFraction(0.123456, MassFractionUnit.DecimalFraction).ToString("s2"));
-            Assert.Equal("0.123", new MassFraction(0.123456, MassFractionUnit.DecimalFraction).ToString("s3"));
-            Assert.Equal("0.1235", new MassFraction(0.123456, MassFractionUnit.DecimalFraction).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1", new MassFraction(0.123456, MassFractionUnit.DecimalFraction).ToString("s1", culture));
-            Assert.Equal("0.12", new MassFraction(0.123456, MassFractionUnit.DecimalFraction).ToString("s2", culture));
-            Assert.Equal("0.123", new MassFraction(0.123456, MassFractionUnit.DecimalFraction).ToString("s3", culture));
-            Assert.Equal("0.1235", new MassFraction(0.123456, MassFractionUnit.DecimalFraction).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1060,7 +1086,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MassFraction.FromDecimalFractions(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MassFraction), quantity.As(MassFraction.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassMomentOfInertiaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassMomentOfInertiaTestsBase.g.cs
index b74e630e2b..6d641bd138 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassMomentOfInertiaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassMomentOfInertiaTestsBase.g.cs
@@ -233,6 +233,20 @@ public void MassMomentOfInertia_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
             Assert.Equal(quantityInfo, ((IQuantity<MassMomentOfInertiaUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MassMomentOfInertiaInfo_CreateWithCustomUnitInfos()
+        {
+            MassMomentOfInertiaUnit[] expectedUnits = [MassMomentOfInertiaUnit.KilogramSquareMeter];
+
+            MassMomentOfInertia.MassMomentOfInertiaInfo quantityInfo = MassMomentOfInertia.MassMomentOfInertiaInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MassMomentOfInertia", quantityInfo.Name);
+            Assert.Equal(MassMomentOfInertia.Zero, quantityInfo.Zero);
+            Assert.Equal(MassMomentOfInertia.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KilogramSquareMeterToMassMomentOfInertiaUnits()
         {
@@ -371,26 +385,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = MassMomentOfInertia.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            MassMomentOfInertia convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                MassMomentOfInertia quantityToConvert = quantity;
+
+                MassMomentOfInertia convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MassMomentOfInertiaUnit> quantityToConvert = quantity;
+
+                IQuantity<MassMomentOfInertiaUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new MassMomentOfInertia(value: 1, unit: MassMomentOfInertia.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MassMomentOfInertia(value: 1, unit: MassMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MassMomentOfInertiaUnit> quantity = new MassMomentOfInertia(value: 1, unit: MassMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MassMomentOfInertia(value: 1, unit: MassMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new MassMomentOfInertia(value: 1, unit: MassMomentOfInertia.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MassMomentOfInertia(value: 1, unit: MassMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MassMomentOfInertiaUnit> quantity = new MassMomentOfInertia(value: 1, unit: MassMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MassMomentOfInertia(value: 1, unit: MassMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -422,7 +479,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 t·dm²", MassMomentOfInertiaUnit.TonneSquareDecimeter, 4.2)]
         [InlineData("en-US", "4.2 t·m²", MassMomentOfInertiaUnit.TonneSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 t·mm²", MassMomentOfInertiaUnit.TonneSquareMillimeter, 4.2)]
-        public void Parse(string culture, string quantityString, MassMomentOfInertiaUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MassMomentOfInertiaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MassMomentOfInertia.Parse(quantityString);
@@ -459,7 +516,7 @@ public void Parse(string culture, string quantityString, MassMomentOfInertiaUnit
         [InlineData("en-US", "4.2 t·dm²", MassMomentOfInertiaUnit.TonneSquareDecimeter, 4.2)]
         [InlineData("en-US", "4.2 t·m²", MassMomentOfInertiaUnit.TonneSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 t·mm²", MassMomentOfInertiaUnit.TonneSquareMillimeter, 4.2)]
-        public void TryParse(string culture, string quantityString, MassMomentOfInertiaUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MassMomentOfInertiaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MassMomentOfInertia.TryParse(quantityString, out MassMomentOfInertia parsed));
@@ -835,6 +892,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MassMomentOfIner
                 var quantity = MassMomentOfInertia.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -858,59 +916,61 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MassMomentOfInertia
                 IQuantity<MassMomentOfInertiaUnit> quantityToConvert = quantity;
                 IQuantity<MassMomentOfInertiaUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(1);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromGramSquareCentimeters(kilogramsquaremeter.GramSquareCentimeters).KilogramSquareMeters, GramSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromGramSquareDecimeters(kilogramsquaremeter.GramSquareDecimeters).KilogramSquareMeters, GramSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromGramSquareMeters(kilogramsquaremeter.GramSquareMeters).KilogramSquareMeters, GramSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromGramSquareMillimeters(kilogramsquaremeter.GramSquareMillimeters).KilogramSquareMeters, GramSquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilogramSquareCentimeters(kilogramsquaremeter.KilogramSquareCentimeters).KilogramSquareMeters, KilogramSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilogramSquareDecimeters(kilogramsquaremeter.KilogramSquareDecimeters).KilogramSquareMeters, KilogramSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilogramSquareMeters(kilogramsquaremeter.KilogramSquareMeters).KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilogramSquareMillimeters(kilogramsquaremeter.KilogramSquareMillimeters).KilogramSquareMeters, KilogramSquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilotonneSquareCentimeters(kilogramsquaremeter.KilotonneSquareCentimeters).KilogramSquareMeters, KilotonneSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilotonneSquareDecimeters(kilogramsquaremeter.KilotonneSquareDecimeters).KilogramSquareMeters, KilotonneSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilotonneSquareMeters(kilogramsquaremeter.KilotonneSquareMeters).KilogramSquareMeters, KilotonneSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromKilotonneSquareMillimeters(kilogramsquaremeter.KilotonneSquareMillimeters).KilogramSquareMeters, KilotonneSquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMegatonneSquareCentimeters(kilogramsquaremeter.MegatonneSquareCentimeters).KilogramSquareMeters, MegatonneSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMegatonneSquareDecimeters(kilogramsquaremeter.MegatonneSquareDecimeters).KilogramSquareMeters, MegatonneSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMegatonneSquareMeters(kilogramsquaremeter.MegatonneSquareMeters).KilogramSquareMeters, MegatonneSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMegatonneSquareMillimeters(kilogramsquaremeter.MegatonneSquareMillimeters).KilogramSquareMeters, MegatonneSquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMilligramSquareCentimeters(kilogramsquaremeter.MilligramSquareCentimeters).KilogramSquareMeters, MilligramSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMilligramSquareDecimeters(kilogramsquaremeter.MilligramSquareDecimeters).KilogramSquareMeters, MilligramSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMilligramSquareMeters(kilogramsquaremeter.MilligramSquareMeters).KilogramSquareMeters, MilligramSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromMilligramSquareMillimeters(kilogramsquaremeter.MilligramSquareMillimeters).KilogramSquareMeters, MilligramSquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromPoundSquareFeet(kilogramsquaremeter.PoundSquareFeet).KilogramSquareMeters, PoundSquareFeetTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromPoundSquareInches(kilogramsquaremeter.PoundSquareInches).KilogramSquareMeters, PoundSquareInchesTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromSlugSquareFeet(kilogramsquaremeter.SlugSquareFeet).KilogramSquareMeters, SlugSquareFeetTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromSlugSquareInches(kilogramsquaremeter.SlugSquareInches).KilogramSquareMeters, SlugSquareInchesTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromTonneSquareCentimeters(kilogramsquaremeter.TonneSquareCentimeters).KilogramSquareMeters, TonneSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromTonneSquareDecimeters(kilogramsquaremeter.TonneSquareDecimeters).KilogramSquareMeters, TonneSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromTonneSquareMeters(kilogramsquaremeter.TonneSquareMeters).KilogramSquareMeters, TonneSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, MassMomentOfInertia.FromTonneSquareMillimeters(kilogramsquaremeter.TonneSquareMillimeters).KilogramSquareMeters, TonneSquareMillimetersTolerance);
+            MassMomentOfInertia kilogramsquaremeter = MassMomentOfInertia.FromKilogramSquareMeters(3);
+            Assert.Equal(3, MassMomentOfInertia.FromGramSquareCentimeters(kilogramsquaremeter.GramSquareCentimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromGramSquareDecimeters(kilogramsquaremeter.GramSquareDecimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromGramSquareMeters(kilogramsquaremeter.GramSquareMeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromGramSquareMillimeters(kilogramsquaremeter.GramSquareMillimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromKilogramSquareCentimeters(kilogramsquaremeter.KilogramSquareCentimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromKilogramSquareDecimeters(kilogramsquaremeter.KilogramSquareDecimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromKilogramSquareMeters(kilogramsquaremeter.KilogramSquareMeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromKilogramSquareMillimeters(kilogramsquaremeter.KilogramSquareMillimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromKilotonneSquareCentimeters(kilogramsquaremeter.KilotonneSquareCentimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromKilotonneSquareDecimeters(kilogramsquaremeter.KilotonneSquareDecimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromKilotonneSquareMeters(kilogramsquaremeter.KilotonneSquareMeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromKilotonneSquareMillimeters(kilogramsquaremeter.KilotonneSquareMillimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromMegatonneSquareCentimeters(kilogramsquaremeter.MegatonneSquareCentimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromMegatonneSquareDecimeters(kilogramsquaremeter.MegatonneSquareDecimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromMegatonneSquareMeters(kilogramsquaremeter.MegatonneSquareMeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromMegatonneSquareMillimeters(kilogramsquaremeter.MegatonneSquareMillimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromMilligramSquareCentimeters(kilogramsquaremeter.MilligramSquareCentimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromMilligramSquareDecimeters(kilogramsquaremeter.MilligramSquareDecimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromMilligramSquareMeters(kilogramsquaremeter.MilligramSquareMeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromMilligramSquareMillimeters(kilogramsquaremeter.MilligramSquareMillimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromPoundSquareFeet(kilogramsquaremeter.PoundSquareFeet).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromPoundSquareInches(kilogramsquaremeter.PoundSquareInches).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromSlugSquareFeet(kilogramsquaremeter.SlugSquareFeet).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromSlugSquareInches(kilogramsquaremeter.SlugSquareInches).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromTonneSquareCentimeters(kilogramsquaremeter.TonneSquareCentimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromTonneSquareDecimeters(kilogramsquaremeter.TonneSquareDecimeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromTonneSquareMeters(kilogramsquaremeter.TonneSquareMeters).KilogramSquareMeters);
+            Assert.Equal(3, MassMomentOfInertia.FromTonneSquareMillimeters(kilogramsquaremeter.TonneSquareMillimeters).KilogramSquareMeters);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MassMomentOfInertia v = MassMomentOfInertia.FromKilogramSquareMeters(1);
-            AssertEx.EqualTolerance(-1, -v.KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (MassMomentOfInertia.FromKilogramSquareMeters(3)-v).KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (MassMomentOfInertia.FromKilogramSquareMeters(10)/5).KilogramSquareMeters, KilogramSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, MassMomentOfInertia.FromKilogramSquareMeters(10)/MassMomentOfInertia.FromKilogramSquareMeters(5), KilogramSquareMetersTolerance);
+            Assert.Equal(-1, -v.KilogramSquareMeters);
+            Assert.Equal(2, (MassMomentOfInertia.FromKilogramSquareMeters(3) - v).KilogramSquareMeters);
+            Assert.Equal(2, (v + v).KilogramSquareMeters);
+            Assert.Equal(10, (v * 10).KilogramSquareMeters);
+            Assert.Equal(10, (10 * v).KilogramSquareMeters);
+            Assert.Equal(2, (MassMomentOfInertia.FromKilogramSquareMeters(10) / 5).KilogramSquareMeters);
+            Assert.Equal(2, MassMomentOfInertia.FromKilogramSquareMeters(10) / MassMomentOfInertia.FromKilogramSquareMeters(5));
         }
 
         [Fact]
@@ -956,8 +1016,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MassMomentOfInertiaUnit.KilogramSquareMeter, 1, MassMomentOfInertiaUnit.KilogramSquareMeter, true)]  // Same value and unit.
         [InlineData(1, MassMomentOfInertiaUnit.KilogramSquareMeter, 2, MassMomentOfInertiaUnit.KilogramSquareMeter, false)] // Different value.
-        [InlineData(2, MassMomentOfInertiaUnit.KilogramSquareMeter, 1, MassMomentOfInertiaUnit.GramSquareCentimeter, false)] // Different value and unit.
-        [InlineData(1, MassMomentOfInertiaUnit.KilogramSquareMeter, 1, MassMomentOfInertiaUnit.GramSquareCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MassMomentOfInertiaUnit unitA, double valueB, MassMomentOfInertiaUnit unitB, bool expectEqual)
         {
             var a = new MassMomentOfInertia(valueA, unitA);
@@ -1017,8 +1075,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MassMomentOfInertia.FromKilogramSquareMeters(firstValue);
             var otherQuantity = MassMomentOfInertia.FromKilogramSquareMeters(secondValue);
             MassMomentOfInertia maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MassMomentOfInertia.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1037,7 +1095,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MassMomentOfInertiaUnit>();
+            var units = EnumHelper.GetValues<MassMomentOfInertiaUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1050,6 +1108,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(MassMomentOfInertia.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(MassMomentOfInertia.Info.Units, MassMomentOfInertia.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, MassMomentOfInertia.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1120,26 +1190,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 t·mm²", new MassMomentOfInertia(1, MassMomentOfInertiaUnit.TonneSquareMillimeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 kg·m²", new MassMomentOfInertia(0.123456, MassMomentOfInertiaUnit.KilogramSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 kg·m²", new MassMomentOfInertia(0.123456, MassMomentOfInertiaUnit.KilogramSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 kg·m²", new MassMomentOfInertia(0.123456, MassMomentOfInertiaUnit.KilogramSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 kg·m²", new MassMomentOfInertia(0.123456, MassMomentOfInertiaUnit.KilogramSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 kg·m²", new MassMomentOfInertia(0.123456, MassMomentOfInertiaUnit.KilogramSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 kg·m²", new MassMomentOfInertia(0.123456, MassMomentOfInertiaUnit.KilogramSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 kg·m²", new MassMomentOfInertia(0.123456, MassMomentOfInertiaUnit.KilogramSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 kg·m²", new MassMomentOfInertia(0.123456, MassMomentOfInertiaUnit.KilogramSquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1166,7 +1216,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MassMomentOfInertia.FromKilogramSquareMeters(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MassMomentOfInertia), quantity.As(MassMomentOfInertia.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs
index fd4e45305a..ef5a902110 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassTestsBase.g.cs
@@ -245,6 +245,20 @@ public void Mass_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MassUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MassInfo_CreateWithCustomUnitInfos()
+        {
+            MassUnit[] expectedUnits = [MassUnit.Kilogram];
+
+            Mass.MassInfo quantityInfo = Mass.MassInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Mass", quantityInfo.Name);
+            Assert.Equal(Mass.Zero, quantityInfo.Zero);
+            Assert.Equal(Mass.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KilogramToMassUnits()
         {
@@ -389,26 +403,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Mass.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Mass convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Mass quantityToConvert = quantity;
+
+                Mass convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MassUnit> quantityToConvert = quantity;
+
+                IQuantity<MassUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Mass(value: 1, unit: Mass.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Mass(value: 1, unit: Mass.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MassUnit> quantity = new Mass(value: 1, unit: Mass.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Mass(value: 1, unit: Mass.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Mass(value: 1, unit: Mass.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Mass(value: 1, unit: Mass.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MassUnit> quantity = new Mass(value: 1, unit: Mass.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Mass(value: 1, unit: Mass.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -493,7 +550,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("zh-CN", "4.2 磅", MassUnit.Pound, 4.2)]
         [InlineData("zh-CN", "4.2 短吨", MassUnit.ShortTon, 4.2)]
         [InlineData("zh-CN", "4.2 吨", MassUnit.Tonne, 4.2)]
-        public void Parse(string culture, string quantityString, MassUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MassUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Mass.Parse(quantityString);
@@ -590,7 +647,7 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("zh-CN", "4.2 磅", MassUnit.Pound, 4.2)]
         [InlineData("zh-CN", "4.2 短吨", MassUnit.ShortTon, 4.2)]
         [InlineData("zh-CN", "4.2 吨", MassUnit.Tonne, 4.2)]
-        public void TryParse(string culture, string quantityString, MassUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MassUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Mass.TryParse(quantityString, out Mass parsed));
@@ -1297,6 +1354,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MassUnit unit)
                 var quantity = Mass.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1320,62 +1378,64 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MassUnit unit)
                 IQuantity<MassUnit> quantityToConvert = quantity;
                 IQuantity<MassUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Mass kilogram = Mass.FromKilograms(1);
-            AssertEx.EqualTolerance(1, Mass.FromCentigrams(kilogram.Centigrams).Kilograms, CentigramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromDaltons(kilogram.Daltons).Kilograms, DaltonsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromDecagrams(kilogram.Decagrams).Kilograms, DecagramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromDecigrams(kilogram.Decigrams).Kilograms, DecigramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromEarthMasses(kilogram.EarthMasses).Kilograms, EarthMassesTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromFemtograms(kilogram.Femtograms).Kilograms, FemtogramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromGigadaltons(kilogram.Gigadaltons).Kilograms, GigadaltonsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromGrains(kilogram.Grains).Kilograms, GrainsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromGrams(kilogram.Grams).Kilograms, GramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromHectograms(kilogram.Hectograms).Kilograms, HectogramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromKilodaltons(kilogram.Kilodaltons).Kilograms, KilodaltonsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromKilograms(kilogram.Kilograms).Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromKilopounds(kilogram.Kilopounds).Kilograms, KilopoundsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromKilotonnes(kilogram.Kilotonnes).Kilograms, KilotonnesTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromLongHundredweight(kilogram.LongHundredweight).Kilograms, LongHundredweightTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromLongTons(kilogram.LongTons).Kilograms, LongTonsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromMegadaltons(kilogram.Megadaltons).Kilograms, MegadaltonsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromMegapounds(kilogram.Megapounds).Kilograms, MegapoundsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromMegatonnes(kilogram.Megatonnes).Kilograms, MegatonnesTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromMicrograms(kilogram.Micrograms).Kilograms, MicrogramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromMilligrams(kilogram.Milligrams).Kilograms, MilligramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromNanograms(kilogram.Nanograms).Kilograms, NanogramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromOunces(kilogram.Ounces).Kilograms, OuncesTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromPicograms(kilogram.Picograms).Kilograms, PicogramsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromPounds(kilogram.Pounds).Kilograms, PoundsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromShortHundredweight(kilogram.ShortHundredweight).Kilograms, ShortHundredweightTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromShortTons(kilogram.ShortTons).Kilograms, ShortTonsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromSlugs(kilogram.Slugs).Kilograms, SlugsTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromSolarMasses(kilogram.SolarMasses).Kilograms, SolarMassesTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromStone(kilogram.Stone).Kilograms, StoneTolerance);
-            AssertEx.EqualTolerance(1, Mass.FromTonnes(kilogram.Tonnes).Kilograms, TonnesTolerance);
+            Mass kilogram = Mass.FromKilograms(3);
+            Assert.Equal(3, Mass.FromCentigrams(kilogram.Centigrams).Kilograms);
+            Assert.Equal(3, Mass.FromDaltons(kilogram.Daltons).Kilograms);
+            Assert.Equal(3, Mass.FromDecagrams(kilogram.Decagrams).Kilograms);
+            Assert.Equal(3, Mass.FromDecigrams(kilogram.Decigrams).Kilograms);
+            Assert.Equal(3, Mass.FromEarthMasses(kilogram.EarthMasses).Kilograms);
+            Assert.Equal(3, Mass.FromFemtograms(kilogram.Femtograms).Kilograms);
+            Assert.Equal(3, Mass.FromGigadaltons(kilogram.Gigadaltons).Kilograms);
+            Assert.Equal(3, Mass.FromGrains(kilogram.Grains).Kilograms);
+            Assert.Equal(3, Mass.FromGrams(kilogram.Grams).Kilograms);
+            Assert.Equal(3, Mass.FromHectograms(kilogram.Hectograms).Kilograms);
+            Assert.Equal(3, Mass.FromKilodaltons(kilogram.Kilodaltons).Kilograms);
+            Assert.Equal(3, Mass.FromKilograms(kilogram.Kilograms).Kilograms);
+            Assert.Equal(3, Mass.FromKilopounds(kilogram.Kilopounds).Kilograms);
+            Assert.Equal(3, Mass.FromKilotonnes(kilogram.Kilotonnes).Kilograms);
+            Assert.Equal(3, Mass.FromLongHundredweight(kilogram.LongHundredweight).Kilograms);
+            Assert.Equal(3, Mass.FromLongTons(kilogram.LongTons).Kilograms);
+            Assert.Equal(3, Mass.FromMegadaltons(kilogram.Megadaltons).Kilograms);
+            Assert.Equal(3, Mass.FromMegapounds(kilogram.Megapounds).Kilograms);
+            Assert.Equal(3, Mass.FromMegatonnes(kilogram.Megatonnes).Kilograms);
+            Assert.Equal(3, Mass.FromMicrograms(kilogram.Micrograms).Kilograms);
+            Assert.Equal(3, Mass.FromMilligrams(kilogram.Milligrams).Kilograms);
+            Assert.Equal(3, Mass.FromNanograms(kilogram.Nanograms).Kilograms);
+            Assert.Equal(3, Mass.FromOunces(kilogram.Ounces).Kilograms);
+            Assert.Equal(3, Mass.FromPicograms(kilogram.Picograms).Kilograms);
+            Assert.Equal(3, Mass.FromPounds(kilogram.Pounds).Kilograms);
+            Assert.Equal(3, Mass.FromShortHundredweight(kilogram.ShortHundredweight).Kilograms);
+            Assert.Equal(3, Mass.FromShortTons(kilogram.ShortTons).Kilograms);
+            Assert.Equal(3, Mass.FromSlugs(kilogram.Slugs).Kilograms);
+            Assert.Equal(3, Mass.FromSolarMasses(kilogram.SolarMasses).Kilograms);
+            Assert.Equal(3, Mass.FromStone(kilogram.Stone).Kilograms);
+            Assert.Equal(3, Mass.FromTonnes(kilogram.Tonnes).Kilograms);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Mass v = Mass.FromKilograms(1);
-            AssertEx.EqualTolerance(-1, -v.Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(2, (Mass.FromKilograms(3)-v).Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(2, (Mass.FromKilograms(10)/5).Kilograms, KilogramsTolerance);
-            AssertEx.EqualTolerance(2, Mass.FromKilograms(10)/Mass.FromKilograms(5), KilogramsTolerance);
+            Assert.Equal(-1, -v.Kilograms);
+            Assert.Equal(2, (Mass.FromKilograms(3) - v).Kilograms);
+            Assert.Equal(2, (v + v).Kilograms);
+            Assert.Equal(10, (v * 10).Kilograms);
+            Assert.Equal(10, (10 * v).Kilograms);
+            Assert.Equal(2, (Mass.FromKilograms(10) / 5).Kilograms);
+            Assert.Equal(2, Mass.FromKilograms(10) / Mass.FromKilograms(5));
         }
 
         [Fact]
@@ -1421,8 +1481,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MassUnit.Kilogram, 1, MassUnit.Kilogram, true)]  // Same value and unit.
         [InlineData(1, MassUnit.Kilogram, 2, MassUnit.Kilogram, false)] // Different value.
-        [InlineData(2, MassUnit.Kilogram, 1, MassUnit.Centigram, false)] // Different value and unit.
-        [InlineData(1, MassUnit.Kilogram, 1, MassUnit.Centigram, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MassUnit unitA, double valueB, MassUnit unitB, bool expectEqual)
         {
             var a = new Mass(valueA, unitA);
@@ -1482,8 +1540,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Mass.FromKilograms(firstValue);
             var otherQuantity = Mass.FromKilograms(secondValue);
             Mass maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Mass.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1502,7 +1560,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MassUnit>();
+            var units = EnumHelper.GetValues<MassUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1515,6 +1573,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Mass.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Mass.Info.Units, Mass.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Mass.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1591,26 +1661,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 t", new Mass(1, MassUnit.Tonne).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 kg", new Mass(0.123456, MassUnit.Kilogram).ToString("s1"));
-            Assert.Equal("0.12 kg", new Mass(0.123456, MassUnit.Kilogram).ToString("s2"));
-            Assert.Equal("0.123 kg", new Mass(0.123456, MassUnit.Kilogram).ToString("s3"));
-            Assert.Equal("0.1235 kg", new Mass(0.123456, MassUnit.Kilogram).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 kg", new Mass(0.123456, MassUnit.Kilogram).ToString("s1", culture));
-            Assert.Equal("0.12 kg", new Mass(0.123456, MassUnit.Kilogram).ToString("s2", culture));
-            Assert.Equal("0.123 kg", new Mass(0.123456, MassUnit.Kilogram).ToString("s3", culture));
-            Assert.Equal("0.1235 kg", new Mass(0.123456, MassUnit.Kilogram).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1637,7 +1687,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Mass.FromKilograms(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Mass), quantity.As(Mass.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolalityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolalityTestsBase.g.cs
index 55f36ca488..463f47139f 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolalityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolalityTestsBase.g.cs
@@ -133,6 +133,20 @@ public void Molality_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MolalityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MolalityInfo_CreateWithCustomUnitInfos()
+        {
+            MolalityUnit[] expectedUnits = [MolalityUnit.MolePerKilogram];
+
+            Molality.MolalityInfo quantityInfo = Molality.MolalityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Molality", quantityInfo.Name);
+            Assert.Equal(Molality.Zero, quantityInfo.Zero);
+            Assert.Equal(Molality.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void MolePerKilogramToMolalityUnits()
         {
@@ -221,33 +235,76 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Molality.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Molality convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Molality quantityToConvert = quantity;
+
+                Molality convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MolalityUnit> quantityToConvert = quantity;
+
+                IQuantity<MolalityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Molality(value: 1, unit: Molality.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Molality(value: 1, unit: Molality.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolalityUnit> quantity = new Molality(value: 1, unit: Molality.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Molality(value: 1, unit: Molality.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Molality(value: 1, unit: Molality.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Molality(value: 1, unit: Molality.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolalityUnit> quantity = new Molality(value: 1, unit: Molality.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Molality(value: 1, unit: Molality.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 mmol/kg", MolalityUnit.MillimolePerKilogram, 4.2)]
         [InlineData("en-US", "4.2 mol/g", MolalityUnit.MolePerGram, 4.2)]
         [InlineData("en-US", "4.2 mol/kg", MolalityUnit.MolePerKilogram, 4.2)]
-        public void Parse(string culture, string quantityString, MolalityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MolalityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Molality.Parse(quantityString);
@@ -259,7 +316,7 @@ public void Parse(string culture, string quantityString, MolalityUnit expectedUn
         [InlineData("en-US", "4.2 mmol/kg", MolalityUnit.MillimolePerKilogram, 4.2)]
         [InlineData("en-US", "4.2 mol/g", MolalityUnit.MolePerGram, 4.2)]
         [InlineData("en-US", "4.2 mol/kg", MolalityUnit.MolePerKilogram, 4.2)]
-        public void TryParse(string culture, string quantityString, MolalityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MolalityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Molality.TryParse(quantityString, out Molality parsed));
@@ -410,6 +467,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MolalityUnit uni
                 var quantity = Molality.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -433,34 +491,36 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MolalityUnit unit)
                 IQuantity<MolalityUnit> quantityToConvert = quantity;
                 IQuantity<MolalityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Molality moleperkilogram = Molality.FromMolesPerKilogram(1);
-            AssertEx.EqualTolerance(1, Molality.FromMillimolesPerKilogram(moleperkilogram.MillimolesPerKilogram).MolesPerKilogram, MillimolesPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, Molality.FromMolesPerGram(moleperkilogram.MolesPerGram).MolesPerKilogram, MolesPerGramTolerance);
-            AssertEx.EqualTolerance(1, Molality.FromMolesPerKilogram(moleperkilogram.MolesPerKilogram).MolesPerKilogram, MolesPerKilogramTolerance);
+            Molality moleperkilogram = Molality.FromMolesPerKilogram(3);
+            Assert.Equal(3, Molality.FromMillimolesPerKilogram(moleperkilogram.MillimolesPerKilogram).MolesPerKilogram);
+            Assert.Equal(3, Molality.FromMolesPerGram(moleperkilogram.MolesPerGram).MolesPerKilogram);
+            Assert.Equal(3, Molality.FromMolesPerKilogram(moleperkilogram.MolesPerKilogram).MolesPerKilogram);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Molality v = Molality.FromMolesPerKilogram(1);
-            AssertEx.EqualTolerance(-1, -v.MolesPerKilogram, MolesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (Molality.FromMolesPerKilogram(3)-v).MolesPerKilogram, MolesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (v + v).MolesPerKilogram, MolesPerKilogramTolerance);
-            AssertEx.EqualTolerance(10, (v*10).MolesPerKilogram, MolesPerKilogramTolerance);
-            AssertEx.EqualTolerance(10, (10*v).MolesPerKilogram, MolesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (Molality.FromMolesPerKilogram(10)/5).MolesPerKilogram, MolesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, Molality.FromMolesPerKilogram(10)/Molality.FromMolesPerKilogram(5), MolesPerKilogramTolerance);
+            Assert.Equal(-1, -v.MolesPerKilogram);
+            Assert.Equal(2, (Molality.FromMolesPerKilogram(3) - v).MolesPerKilogram);
+            Assert.Equal(2, (v + v).MolesPerKilogram);
+            Assert.Equal(10, (v * 10).MolesPerKilogram);
+            Assert.Equal(10, (10 * v).MolesPerKilogram);
+            Assert.Equal(2, (Molality.FromMolesPerKilogram(10) / 5).MolesPerKilogram);
+            Assert.Equal(2, Molality.FromMolesPerKilogram(10) / Molality.FromMolesPerKilogram(5));
         }
 
         [Fact]
@@ -506,8 +566,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MolalityUnit.MolePerKilogram, 1, MolalityUnit.MolePerKilogram, true)]  // Same value and unit.
         [InlineData(1, MolalityUnit.MolePerKilogram, 2, MolalityUnit.MolePerKilogram, false)] // Different value.
-        [InlineData(2, MolalityUnit.MolePerKilogram, 1, MolalityUnit.MillimolePerKilogram, false)] // Different value and unit.
-        [InlineData(1, MolalityUnit.MolePerKilogram, 1, MolalityUnit.MillimolePerKilogram, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MolalityUnit unitA, double valueB, MolalityUnit unitB, bool expectEqual)
         {
             var a = new Molality(valueA, unitA);
@@ -567,8 +625,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Molality.FromMolesPerKilogram(firstValue);
             var otherQuantity = Molality.FromMolesPerKilogram(secondValue);
             Molality maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Molality.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -587,7 +645,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MolalityUnit>();
+            var units = EnumHelper.GetValues<MolalityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -600,6 +658,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Molality.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Molality.Info.Units, Molality.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Molality.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -620,26 +690,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 mol/kg", new Molality(1, MolalityUnit.MolePerKilogram).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 mol/kg", new Molality(0.123456, MolalityUnit.MolePerKilogram).ToString("s1"));
-            Assert.Equal("0.12 mol/kg", new Molality(0.123456, MolalityUnit.MolePerKilogram).ToString("s2"));
-            Assert.Equal("0.123 mol/kg", new Molality(0.123456, MolalityUnit.MolePerKilogram).ToString("s3"));
-            Assert.Equal("0.1235 mol/kg", new Molality(0.123456, MolalityUnit.MolePerKilogram).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 mol/kg", new Molality(0.123456, MolalityUnit.MolePerKilogram).ToString("s1", culture));
-            Assert.Equal("0.12 mol/kg", new Molality(0.123456, MolalityUnit.MolePerKilogram).ToString("s2", culture));
-            Assert.Equal("0.123 mol/kg", new Molality(0.123456, MolalityUnit.MolePerKilogram).ToString("s3", culture));
-            Assert.Equal("0.1235 mol/kg", new Molality(0.123456, MolalityUnit.MolePerKilogram).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -666,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Molality.FromMolesPerKilogram(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Molality), quantity.As(Molality.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs
index d418c52438..d8ec3d4058 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEnergyTestsBase.g.cs
@@ -133,6 +133,20 @@ public void MolarEnergy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MolarEnergyUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MolarEnergyInfo_CreateWithCustomUnitInfos()
+        {
+            MolarEnergyUnit[] expectedUnits = [MolarEnergyUnit.JoulePerMole];
+
+            MolarEnergy.MolarEnergyInfo quantityInfo = MolarEnergy.MolarEnergyInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MolarEnergy", quantityInfo.Name);
+            Assert.Equal(MolarEnergy.Zero, quantityInfo.Zero);
+            Assert.Equal(MolarEnergy.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void JoulePerMoleToMolarEnergyUnits()
         {
@@ -221,33 +235,76 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = MolarEnergy.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            MolarEnergy convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                MolarEnergy quantityToConvert = quantity;
+
+                MolarEnergy convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MolarEnergyUnit> quantityToConvert = quantity;
+
+                IQuantity<MolarEnergyUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new MolarEnergy(value: 1, unit: MolarEnergy.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MolarEnergy(value: 1, unit: MolarEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolarEnergyUnit> quantity = new MolarEnergy(value: 1, unit: MolarEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MolarEnergy(value: 1, unit: MolarEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new MolarEnergy(value: 1, unit: MolarEnergy.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MolarEnergy(value: 1, unit: MolarEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolarEnergyUnit> quantity = new MolarEnergy(value: 1, unit: MolarEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MolarEnergy(value: 1, unit: MolarEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 J/mol", MolarEnergyUnit.JoulePerMole, 4.2)]
         [InlineData("en-US", "4.2 kJ/mol", MolarEnergyUnit.KilojoulePerMole, 4.2)]
         [InlineData("en-US", "4.2 MJ/mol", MolarEnergyUnit.MegajoulePerMole, 4.2)]
-        public void Parse(string culture, string quantityString, MolarEnergyUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MolarEnergyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MolarEnergy.Parse(quantityString);
@@ -259,7 +316,7 @@ public void Parse(string culture, string quantityString, MolarEnergyUnit expecte
         [InlineData("en-US", "4.2 J/mol", MolarEnergyUnit.JoulePerMole, 4.2)]
         [InlineData("en-US", "4.2 kJ/mol", MolarEnergyUnit.KilojoulePerMole, 4.2)]
         [InlineData("en-US", "4.2 MJ/mol", MolarEnergyUnit.MegajoulePerMole, 4.2)]
-        public void TryParse(string culture, string quantityString, MolarEnergyUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MolarEnergyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MolarEnergy.TryParse(quantityString, out MolarEnergy parsed));
@@ -410,6 +467,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MolarEnergyUnit
                 var quantity = MolarEnergy.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -433,34 +491,36 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MolarEnergyUnit uni
                 IQuantity<MolarEnergyUnit> quantityToConvert = quantity;
                 IQuantity<MolarEnergyUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MolarEnergy joulepermole = MolarEnergy.FromJoulesPerMole(1);
-            AssertEx.EqualTolerance(1, MolarEnergy.FromJoulesPerMole(joulepermole.JoulesPerMole).JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarEnergy.FromKilojoulesPerMole(joulepermole.KilojoulesPerMole).JoulesPerMole, KilojoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarEnergy.FromMegajoulesPerMole(joulepermole.MegajoulesPerMole).JoulesPerMole, MegajoulesPerMoleTolerance);
+            MolarEnergy joulepermole = MolarEnergy.FromJoulesPerMole(3);
+            Assert.Equal(3, MolarEnergy.FromJoulesPerMole(joulepermole.JoulesPerMole).JoulesPerMole);
+            Assert.Equal(3, MolarEnergy.FromKilojoulesPerMole(joulepermole.KilojoulesPerMole).JoulesPerMole);
+            Assert.Equal(3, MolarEnergy.FromMegajoulesPerMole(joulepermole.MegajoulesPerMole).JoulesPerMole);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MolarEnergy v = MolarEnergy.FromJoulesPerMole(1);
-            AssertEx.EqualTolerance(-1, -v.JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(2, (MolarEnergy.FromJoulesPerMole(3)-v).JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(2, (v + v).JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(10, (v*10).JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(10, (10*v).JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(2, (MolarEnergy.FromJoulesPerMole(10)/5).JoulesPerMole, JoulesPerMoleTolerance);
-            AssertEx.EqualTolerance(2, MolarEnergy.FromJoulesPerMole(10)/MolarEnergy.FromJoulesPerMole(5), JoulesPerMoleTolerance);
+            Assert.Equal(-1, -v.JoulesPerMole);
+            Assert.Equal(2, (MolarEnergy.FromJoulesPerMole(3) - v).JoulesPerMole);
+            Assert.Equal(2, (v + v).JoulesPerMole);
+            Assert.Equal(10, (v * 10).JoulesPerMole);
+            Assert.Equal(10, (10 * v).JoulesPerMole);
+            Assert.Equal(2, (MolarEnergy.FromJoulesPerMole(10) / 5).JoulesPerMole);
+            Assert.Equal(2, MolarEnergy.FromJoulesPerMole(10) / MolarEnergy.FromJoulesPerMole(5));
         }
 
         [Fact]
@@ -506,8 +566,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MolarEnergyUnit.JoulePerMole, 1, MolarEnergyUnit.JoulePerMole, true)]  // Same value and unit.
         [InlineData(1, MolarEnergyUnit.JoulePerMole, 2, MolarEnergyUnit.JoulePerMole, false)] // Different value.
-        [InlineData(2, MolarEnergyUnit.JoulePerMole, 1, MolarEnergyUnit.KilojoulePerMole, false)] // Different value and unit.
-        [InlineData(1, MolarEnergyUnit.JoulePerMole, 1, MolarEnergyUnit.KilojoulePerMole, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MolarEnergyUnit unitA, double valueB, MolarEnergyUnit unitB, bool expectEqual)
         {
             var a = new MolarEnergy(valueA, unitA);
@@ -567,8 +625,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MolarEnergy.FromJoulesPerMole(firstValue);
             var otherQuantity = MolarEnergy.FromJoulesPerMole(secondValue);
             MolarEnergy maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MolarEnergy.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -587,7 +645,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MolarEnergyUnit>();
+            var units = EnumHelper.GetValues<MolarEnergyUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -600,6 +658,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(MolarEnergy.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(MolarEnergy.Info.Units, MolarEnergy.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, MolarEnergy.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -620,26 +690,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 MJ/mol", new MolarEnergy(1, MolarEnergyUnit.MegajoulePerMole).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 J/mol", new MolarEnergy(0.123456, MolarEnergyUnit.JoulePerMole).ToString("s1"));
-            Assert.Equal("0.12 J/mol", new MolarEnergy(0.123456, MolarEnergyUnit.JoulePerMole).ToString("s2"));
-            Assert.Equal("0.123 J/mol", new MolarEnergy(0.123456, MolarEnergyUnit.JoulePerMole).ToString("s3"));
-            Assert.Equal("0.1235 J/mol", new MolarEnergy(0.123456, MolarEnergyUnit.JoulePerMole).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 J/mol", new MolarEnergy(0.123456, MolarEnergyUnit.JoulePerMole).ToString("s1", culture));
-            Assert.Equal("0.12 J/mol", new MolarEnergy(0.123456, MolarEnergyUnit.JoulePerMole).ToString("s2", culture));
-            Assert.Equal("0.123 J/mol", new MolarEnergy(0.123456, MolarEnergyUnit.JoulePerMole).ToString("s3", culture));
-            Assert.Equal("0.1235 J/mol", new MolarEnergy(0.123456, MolarEnergyUnit.JoulePerMole).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -666,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MolarEnergy.FromJoulesPerMole(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MolarEnergy), quantity.As(MolarEnergy.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEntropyTestsBase.g.cs
index 07465bdcb4..d7b2deff8a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEntropyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarEntropyTestsBase.g.cs
@@ -133,6 +133,20 @@ public void MolarEntropy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MolarEntropyUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MolarEntropyInfo_CreateWithCustomUnitInfos()
+        {
+            MolarEntropyUnit[] expectedUnits = [MolarEntropyUnit.JoulePerMoleKelvin];
+
+            MolarEntropy.MolarEntropyInfo quantityInfo = MolarEntropy.MolarEntropyInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MolarEntropy", quantityInfo.Name);
+            Assert.Equal(MolarEntropy.Zero, quantityInfo.Zero);
+            Assert.Equal(MolarEntropy.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void JoulePerMoleKelvinToMolarEntropyUnits()
         {
@@ -221,33 +235,76 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = MolarEntropy.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            MolarEntropy convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                MolarEntropy quantityToConvert = quantity;
+
+                MolarEntropy convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MolarEntropyUnit> quantityToConvert = quantity;
+
+                IQuantity<MolarEntropyUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new MolarEntropy(value: 1, unit: MolarEntropy.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MolarEntropy(value: 1, unit: MolarEntropy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolarEntropyUnit> quantity = new MolarEntropy(value: 1, unit: MolarEntropy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MolarEntropy(value: 1, unit: MolarEntropy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new MolarEntropy(value: 1, unit: MolarEntropy.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MolarEntropy(value: 1, unit: MolarEntropy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolarEntropyUnit> quantity = new MolarEntropy(value: 1, unit: MolarEntropy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MolarEntropy(value: 1, unit: MolarEntropy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 J/(mol·K)", MolarEntropyUnit.JoulePerMoleKelvin, 4.2)]
         [InlineData("en-US", "4.2 kJ/(mol·K)", MolarEntropyUnit.KilojoulePerMoleKelvin, 4.2)]
         [InlineData("en-US", "4.2 MJ/(mol·K)", MolarEntropyUnit.MegajoulePerMoleKelvin, 4.2)]
-        public void Parse(string culture, string quantityString, MolarEntropyUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MolarEntropyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MolarEntropy.Parse(quantityString);
@@ -259,7 +316,7 @@ public void Parse(string culture, string quantityString, MolarEntropyUnit expect
         [InlineData("en-US", "4.2 J/(mol·K)", MolarEntropyUnit.JoulePerMoleKelvin, 4.2)]
         [InlineData("en-US", "4.2 kJ/(mol·K)", MolarEntropyUnit.KilojoulePerMoleKelvin, 4.2)]
         [InlineData("en-US", "4.2 MJ/(mol·K)", MolarEntropyUnit.MegajoulePerMoleKelvin, 4.2)]
-        public void TryParse(string culture, string quantityString, MolarEntropyUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MolarEntropyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MolarEntropy.TryParse(quantityString, out MolarEntropy parsed));
@@ -410,6 +467,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MolarEntropyUnit
                 var quantity = MolarEntropy.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -433,34 +491,36 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MolarEntropyUnit un
                 IQuantity<MolarEntropyUnit> quantityToConvert = quantity;
                 IQuantity<MolarEntropyUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MolarEntropy joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(1);
-            AssertEx.EqualTolerance(1, MolarEntropy.FromJoulesPerMoleKelvin(joulepermolekelvin.JoulesPerMoleKelvin).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(1, MolarEntropy.FromKilojoulesPerMoleKelvin(joulepermolekelvin.KilojoulesPerMoleKelvin).JoulesPerMoleKelvin, KilojoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(1, MolarEntropy.FromMegajoulesPerMoleKelvin(joulepermolekelvin.MegajoulesPerMoleKelvin).JoulesPerMoleKelvin, MegajoulesPerMoleKelvinTolerance);
+            MolarEntropy joulepermolekelvin = MolarEntropy.FromJoulesPerMoleKelvin(3);
+            Assert.Equal(3, MolarEntropy.FromJoulesPerMoleKelvin(joulepermolekelvin.JoulesPerMoleKelvin).JoulesPerMoleKelvin);
+            Assert.Equal(3, MolarEntropy.FromKilojoulesPerMoleKelvin(joulepermolekelvin.KilojoulesPerMoleKelvin).JoulesPerMoleKelvin);
+            Assert.Equal(3, MolarEntropy.FromMegajoulesPerMoleKelvin(joulepermolekelvin.MegajoulesPerMoleKelvin).JoulesPerMoleKelvin);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MolarEntropy v = MolarEntropy.FromJoulesPerMoleKelvin(1);
-            AssertEx.EqualTolerance(-1, -v.JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(2, (MolarEntropy.FromJoulesPerMoleKelvin(3)-v).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(2, (v + v).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(10, (v*10).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(10, (10*v).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(2, (MolarEntropy.FromJoulesPerMoleKelvin(10)/5).JoulesPerMoleKelvin, JoulesPerMoleKelvinTolerance);
-            AssertEx.EqualTolerance(2, MolarEntropy.FromJoulesPerMoleKelvin(10)/MolarEntropy.FromJoulesPerMoleKelvin(5), JoulesPerMoleKelvinTolerance);
+            Assert.Equal(-1, -v.JoulesPerMoleKelvin);
+            Assert.Equal(2, (MolarEntropy.FromJoulesPerMoleKelvin(3) - v).JoulesPerMoleKelvin);
+            Assert.Equal(2, (v + v).JoulesPerMoleKelvin);
+            Assert.Equal(10, (v * 10).JoulesPerMoleKelvin);
+            Assert.Equal(10, (10 * v).JoulesPerMoleKelvin);
+            Assert.Equal(2, (MolarEntropy.FromJoulesPerMoleKelvin(10) / 5).JoulesPerMoleKelvin);
+            Assert.Equal(2, MolarEntropy.FromJoulesPerMoleKelvin(10) / MolarEntropy.FromJoulesPerMoleKelvin(5));
         }
 
         [Fact]
@@ -506,8 +566,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MolarEntropyUnit.JoulePerMoleKelvin, 1, MolarEntropyUnit.JoulePerMoleKelvin, true)]  // Same value and unit.
         [InlineData(1, MolarEntropyUnit.JoulePerMoleKelvin, 2, MolarEntropyUnit.JoulePerMoleKelvin, false)] // Different value.
-        [InlineData(2, MolarEntropyUnit.JoulePerMoleKelvin, 1, MolarEntropyUnit.KilojoulePerMoleKelvin, false)] // Different value and unit.
-        [InlineData(1, MolarEntropyUnit.JoulePerMoleKelvin, 1, MolarEntropyUnit.KilojoulePerMoleKelvin, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MolarEntropyUnit unitA, double valueB, MolarEntropyUnit unitB, bool expectEqual)
         {
             var a = new MolarEntropy(valueA, unitA);
@@ -567,8 +625,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MolarEntropy.FromJoulesPerMoleKelvin(firstValue);
             var otherQuantity = MolarEntropy.FromJoulesPerMoleKelvin(secondValue);
             MolarEntropy maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MolarEntropy.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -587,7 +645,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MolarEntropyUnit>();
+            var units = EnumHelper.GetValues<MolarEntropyUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -600,6 +658,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(MolarEntropy.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(MolarEntropy.Info.Units, MolarEntropy.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, MolarEntropy.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -620,26 +690,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 MJ/(mol·K)", new MolarEntropy(1, MolarEntropyUnit.MegajoulePerMoleKelvin).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 J/(mol·K)", new MolarEntropy(0.123456, MolarEntropyUnit.JoulePerMoleKelvin).ToString("s1"));
-            Assert.Equal("0.12 J/(mol·K)", new MolarEntropy(0.123456, MolarEntropyUnit.JoulePerMoleKelvin).ToString("s2"));
-            Assert.Equal("0.123 J/(mol·K)", new MolarEntropy(0.123456, MolarEntropyUnit.JoulePerMoleKelvin).ToString("s3"));
-            Assert.Equal("0.1235 J/(mol·K)", new MolarEntropy(0.123456, MolarEntropyUnit.JoulePerMoleKelvin).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 J/(mol·K)", new MolarEntropy(0.123456, MolarEntropyUnit.JoulePerMoleKelvin).ToString("s1", culture));
-            Assert.Equal("0.12 J/(mol·K)", new MolarEntropy(0.123456, MolarEntropyUnit.JoulePerMoleKelvin).ToString("s2", culture));
-            Assert.Equal("0.123 J/(mol·K)", new MolarEntropy(0.123456, MolarEntropyUnit.JoulePerMoleKelvin).ToString("s3", culture));
-            Assert.Equal("0.1235 J/(mol·K)", new MolarEntropy(0.123456, MolarEntropyUnit.JoulePerMoleKelvin).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -666,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MolarEntropy.FromJoulesPerMoleKelvin(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MolarEntropy), quantity.As(MolarEntropy.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarFlowTestsBase.g.cs
index 38f030aa1a..02f518d9a7 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarFlowTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarFlowTestsBase.g.cs
@@ -157,6 +157,20 @@ public void MolarFlow_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MolarFlowUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MolarFlowInfo_CreateWithCustomUnitInfos()
+        {
+            MolarFlowUnit[] expectedUnits = [MolarFlowUnit.MolePerSecond];
+
+            MolarFlow.MolarFlowInfo quantityInfo = MolarFlow.MolarFlowInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MolarFlow", quantityInfo.Name);
+            Assert.Equal(MolarFlow.Zero, quantityInfo.Zero);
+            Assert.Equal(MolarFlow.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void MolePerSecondToMolarFlowUnits()
         {
@@ -257,39 +271,82 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = MolarFlow.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            MolarFlow convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                MolarFlow quantityToConvert = quantity;
+
+                MolarFlow convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MolarFlowUnit> quantityToConvert = quantity;
+
+                IQuantity<MolarFlowUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new MolarFlow(value: 1, unit: MolarFlow.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MolarFlow(value: 1, unit: MolarFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolarFlowUnit> quantity = new MolarFlow(value: 1, unit: MolarFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MolarFlow(value: 1, unit: MolarFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new MolarFlow(value: 1, unit: MolarFlow.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MolarFlow(value: 1, unit: MolarFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolarFlowUnit> quantity = new MolarFlow(value: 1, unit: MolarFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MolarFlow(value: 1, unit: MolarFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
-        [InlineData("en-US", "4.2 kkmol/h", MolarFlowUnit.KilomolePerHour, 4.2)]
+        [InlineData("en-US", "4.2 kmol/h", MolarFlowUnit.KilomolePerHour, 4.2)]
         [InlineData("en-US", "4.2 kmol/min", MolarFlowUnit.KilomolePerMinute, 4.2)]
         [InlineData("en-US", "4.2 kmol/s", MolarFlowUnit.KilomolePerSecond, 4.2)]
-        [InlineData("en-US", "4.2 kmol/h", MolarFlowUnit.MolePerHour, 4.2)]
+        [InlineData("en-US", "4.2 mol/h", MolarFlowUnit.MolePerHour, 4.2)]
         [InlineData("en-US", "4.2 mol/min", MolarFlowUnit.MolePerMinute, 4.2)]
         [InlineData("en-US", "4.2 mol/s", MolarFlowUnit.MolePerSecond, 4.2)]
         [InlineData("en-US", "4.2 lbmol/h", MolarFlowUnit.PoundMolePerHour, 4.2)]
         [InlineData("en-US", "4.2 lbmol/min", MolarFlowUnit.PoundMolePerMinute, 4.2)]
         [InlineData("en-US", "4.2 lbmol/s", MolarFlowUnit.PoundMolePerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, MolarFlowUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MolarFlowUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MolarFlow.Parse(quantityString);
@@ -298,16 +355,16 @@ public void Parse(string culture, string quantityString, MolarFlowUnit expectedU
         }
 
         [Theory]
-        [InlineData("en-US", "4.2 kkmol/h", MolarFlowUnit.KilomolePerHour, 4.2)]
+        [InlineData("en-US", "4.2 kmol/h", MolarFlowUnit.KilomolePerHour, 4.2)]
         [InlineData("en-US", "4.2 kmol/min", MolarFlowUnit.KilomolePerMinute, 4.2)]
         [InlineData("en-US", "4.2 kmol/s", MolarFlowUnit.KilomolePerSecond, 4.2)]
-        [InlineData("en-US", "4.2 kmol/h", MolarFlowUnit.MolePerHour, 4.2)]
+        [InlineData("en-US", "4.2 mol/h", MolarFlowUnit.MolePerHour, 4.2)]
         [InlineData("en-US", "4.2 mol/min", MolarFlowUnit.MolePerMinute, 4.2)]
         [InlineData("en-US", "4.2 mol/s", MolarFlowUnit.MolePerSecond, 4.2)]
         [InlineData("en-US", "4.2 lbmol/h", MolarFlowUnit.PoundMolePerHour, 4.2)]
         [InlineData("en-US", "4.2 lbmol/min", MolarFlowUnit.PoundMolePerMinute, 4.2)]
         [InlineData("en-US", "4.2 lbmol/s", MolarFlowUnit.PoundMolePerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, MolarFlowUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MolarFlowUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MolarFlow.TryParse(quantityString, out MolarFlow parsed));
@@ -316,10 +373,10 @@ public void TryParse(string culture, string quantityString, MolarFlowUnit expect
         }
 
         [Theory]
-        [InlineData("kkmol/h", MolarFlowUnit.KilomolePerHour)]
+        [InlineData("kmol/h", MolarFlowUnit.KilomolePerHour)]
         [InlineData("kmol/min", MolarFlowUnit.KilomolePerMinute)]
         [InlineData("kmol/s", MolarFlowUnit.KilomolePerSecond)]
-        [InlineData("kmol/h", MolarFlowUnit.MolePerHour)]
+        [InlineData("mol/h", MolarFlowUnit.MolePerHour)]
         [InlineData("mol/min", MolarFlowUnit.MolePerMinute)]
         [InlineData("mol/s", MolarFlowUnit.MolePerSecond)]
         [InlineData("lbmol/h", MolarFlowUnit.PoundMolePerHour)]
@@ -334,10 +391,10 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, MolarFlow
         }
 
         [Theory]
-        [InlineData("kkmol/h", MolarFlowUnit.KilomolePerHour)]
+        [InlineData("kmol/h", MolarFlowUnit.KilomolePerHour)]
         [InlineData("kmol/min", MolarFlowUnit.KilomolePerMinute)]
         [InlineData("kmol/s", MolarFlowUnit.KilomolePerSecond)]
-        [InlineData("kmol/h", MolarFlowUnit.MolePerHour)]
+        [InlineData("mol/h", MolarFlowUnit.MolePerHour)]
         [InlineData("mol/min", MolarFlowUnit.MolePerMinute)]
         [InlineData("mol/s", MolarFlowUnit.MolePerSecond)]
         [InlineData("lbmol/h", MolarFlowUnit.PoundMolePerHour)]
@@ -352,10 +409,10 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         }
 
         [Theory]
-        [InlineData("en-US", "kkmol/h", MolarFlowUnit.KilomolePerHour)]
+        [InlineData("en-US", "kmol/h", MolarFlowUnit.KilomolePerHour)]
         [InlineData("en-US", "kmol/min", MolarFlowUnit.KilomolePerMinute)]
         [InlineData("en-US", "kmol/s", MolarFlowUnit.KilomolePerSecond)]
-        [InlineData("en-US", "kmol/h", MolarFlowUnit.MolePerHour)]
+        [InlineData("en-US", "mol/h", MolarFlowUnit.MolePerHour)]
         [InlineData("en-US", "mol/min", MolarFlowUnit.MolePerMinute)]
         [InlineData("en-US", "mol/s", MolarFlowUnit.MolePerSecond)]
         [InlineData("en-US", "lbmol/h", MolarFlowUnit.PoundMolePerHour)]
@@ -369,10 +426,10 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Mo
         }
 
         [Theory]
-        [InlineData("en-US", "kkmol/h", MolarFlowUnit.KilomolePerHour)]
+        [InlineData("en-US", "kmol/h", MolarFlowUnit.KilomolePerHour)]
         [InlineData("en-US", "kmol/min", MolarFlowUnit.KilomolePerMinute)]
         [InlineData("en-US", "kmol/s", MolarFlowUnit.KilomolePerSecond)]
-        [InlineData("en-US", "kmol/h", MolarFlowUnit.MolePerHour)]
+        [InlineData("en-US", "mol/h", MolarFlowUnit.MolePerHour)]
         [InlineData("en-US", "mol/min", MolarFlowUnit.MolePerMinute)]
         [InlineData("en-US", "mol/s", MolarFlowUnit.MolePerSecond)]
         [InlineData("en-US", "lbmol/h", MolarFlowUnit.PoundMolePerHour)]
@@ -385,10 +442,10 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, MolarFlow
         }
 
         [Theory]
-        [InlineData("kkmol/h", MolarFlowUnit.KilomolePerHour)]
+        [InlineData("kmol/h", MolarFlowUnit.KilomolePerHour)]
         [InlineData("kmol/min", MolarFlowUnit.KilomolePerMinute)]
         [InlineData("kmol/s", MolarFlowUnit.KilomolePerSecond)]
-        [InlineData("kmol/h", MolarFlowUnit.MolePerHour)]
+        [InlineData("mol/h", MolarFlowUnit.MolePerHour)]
         [InlineData("mol/min", MolarFlowUnit.MolePerMinute)]
         [InlineData("mol/s", MolarFlowUnit.MolePerSecond)]
         [InlineData("lbmol/h", MolarFlowUnit.PoundMolePerHour)]
@@ -403,10 +460,10 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, MolarF
         }
 
         [Theory]
-        [InlineData("kkmol/h", MolarFlowUnit.KilomolePerHour)]
+        [InlineData("kmol/h", MolarFlowUnit.KilomolePerHour)]
         [InlineData("kmol/min", MolarFlowUnit.KilomolePerMinute)]
         [InlineData("kmol/s", MolarFlowUnit.KilomolePerSecond)]
-        [InlineData("kmol/h", MolarFlowUnit.MolePerHour)]
+        [InlineData("mol/h", MolarFlowUnit.MolePerHour)]
         [InlineData("mol/min", MolarFlowUnit.MolePerMinute)]
         [InlineData("mol/s", MolarFlowUnit.MolePerSecond)]
         [InlineData("lbmol/h", MolarFlowUnit.PoundMolePerHour)]
@@ -421,10 +478,10 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         }
 
         [Theory]
-        [InlineData("en-US", "kkmol/h", MolarFlowUnit.KilomolePerHour)]
+        [InlineData("en-US", "kmol/h", MolarFlowUnit.KilomolePerHour)]
         [InlineData("en-US", "kmol/min", MolarFlowUnit.KilomolePerMinute)]
         [InlineData("en-US", "kmol/s", MolarFlowUnit.KilomolePerSecond)]
-        [InlineData("en-US", "kmol/h", MolarFlowUnit.MolePerHour)]
+        [InlineData("en-US", "mol/h", MolarFlowUnit.MolePerHour)]
         [InlineData("en-US", "mol/min", MolarFlowUnit.MolePerMinute)]
         [InlineData("en-US", "mol/s", MolarFlowUnit.MolePerSecond)]
         [InlineData("en-US", "lbmol/h", MolarFlowUnit.PoundMolePerHour)]
@@ -438,10 +495,10 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         }
 
         [Theory]
-        [InlineData("en-US", "kkmol/h", MolarFlowUnit.KilomolePerHour)]
+        [InlineData("en-US", "kmol/h", MolarFlowUnit.KilomolePerHour)]
         [InlineData("en-US", "kmol/min", MolarFlowUnit.KilomolePerMinute)]
         [InlineData("en-US", "kmol/s", MolarFlowUnit.KilomolePerSecond)]
-        [InlineData("en-US", "kmol/h", MolarFlowUnit.MolePerHour)]
+        [InlineData("en-US", "mol/h", MolarFlowUnit.MolePerHour)]
         [InlineData("en-US", "mol/min", MolarFlowUnit.MolePerMinute)]
         [InlineData("en-US", "mol/s", MolarFlowUnit.MolePerSecond)]
         [InlineData("en-US", "lbmol/h", MolarFlowUnit.PoundMolePerHour)]
@@ -454,10 +511,10 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, MolarF
         }
 
         [Theory]
-        [InlineData("en-US", MolarFlowUnit.KilomolePerHour, "kkmol/h")]
+        [InlineData("en-US", MolarFlowUnit.KilomolePerHour, "kmol/h")]
         [InlineData("en-US", MolarFlowUnit.KilomolePerMinute, "kmol/min")]
         [InlineData("en-US", MolarFlowUnit.KilomolePerSecond, "kmol/s")]
-        [InlineData("en-US", MolarFlowUnit.MolePerHour, "kmol/h")]
+        [InlineData("en-US", MolarFlowUnit.MolePerHour, "mol/h")]
         [InlineData("en-US", MolarFlowUnit.MolePerMinute, "mol/min")]
         [InlineData("en-US", MolarFlowUnit.MolePerSecond, "mol/s")]
         [InlineData("en-US", MolarFlowUnit.PoundMolePerHour, "lbmol/h")]
@@ -512,6 +569,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MolarFlowUnit un
                 var quantity = MolarFlow.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -535,40 +593,42 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MolarFlowUnit unit)
                 IQuantity<MolarFlowUnit> quantityToConvert = quantity;
                 IQuantity<MolarFlowUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MolarFlow molepersecond = MolarFlow.FromMolesPerSecond(1);
-            AssertEx.EqualTolerance(1, MolarFlow.FromKilomolesPerHour(molepersecond.KilomolesPerHour).MolesPerSecond, KilomolesPerHourTolerance);
-            AssertEx.EqualTolerance(1, MolarFlow.FromKilomolesPerMinute(molepersecond.KilomolesPerMinute).MolesPerSecond, KilomolesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, MolarFlow.FromKilomolesPerSecond(molepersecond.KilomolesPerSecond).MolesPerSecond, KilomolesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MolarFlow.FromMolesPerHour(molepersecond.MolesPerHour).MolesPerSecond, MolesPerHourTolerance);
-            AssertEx.EqualTolerance(1, MolarFlow.FromMolesPerMinute(molepersecond.MolesPerMinute).MolesPerSecond, MolesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, MolarFlow.FromMolesPerSecond(molepersecond.MolesPerSecond).MolesPerSecond, MolesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, MolarFlow.FromPoundMolesPerHour(molepersecond.PoundMolesPerHour).MolesPerSecond, PoundMolesPerHourTolerance);
-            AssertEx.EqualTolerance(1, MolarFlow.FromPoundMolesPerMinute(molepersecond.PoundMolesPerMinute).MolesPerSecond, PoundMolesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, MolarFlow.FromPoundMolesPerSecond(molepersecond.PoundMolesPerSecond).MolesPerSecond, PoundMolesPerSecondTolerance);
+            MolarFlow molepersecond = MolarFlow.FromMolesPerSecond(3);
+            Assert.Equal(3, MolarFlow.FromKilomolesPerHour(molepersecond.KilomolesPerHour).MolesPerSecond);
+            Assert.Equal(3, MolarFlow.FromKilomolesPerMinute(molepersecond.KilomolesPerMinute).MolesPerSecond);
+            Assert.Equal(3, MolarFlow.FromKilomolesPerSecond(molepersecond.KilomolesPerSecond).MolesPerSecond);
+            Assert.Equal(3, MolarFlow.FromMolesPerHour(molepersecond.MolesPerHour).MolesPerSecond);
+            Assert.Equal(3, MolarFlow.FromMolesPerMinute(molepersecond.MolesPerMinute).MolesPerSecond);
+            Assert.Equal(3, MolarFlow.FromMolesPerSecond(molepersecond.MolesPerSecond).MolesPerSecond);
+            Assert.Equal(3, MolarFlow.FromPoundMolesPerHour(molepersecond.PoundMolesPerHour).MolesPerSecond);
+            Assert.Equal(3, MolarFlow.FromPoundMolesPerMinute(molepersecond.PoundMolesPerMinute).MolesPerSecond);
+            Assert.Equal(3, MolarFlow.FromPoundMolesPerSecond(molepersecond.PoundMolesPerSecond).MolesPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MolarFlow v = MolarFlow.FromMolesPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.MolesPerSecond, MolesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (MolarFlow.FromMolesPerSecond(3)-v).MolesPerSecond, MolesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).MolesPerSecond, MolesPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).MolesPerSecond, MolesPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).MolesPerSecond, MolesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (MolarFlow.FromMolesPerSecond(10)/5).MolesPerSecond, MolesPerSecondTolerance);
-            AssertEx.EqualTolerance(2, MolarFlow.FromMolesPerSecond(10)/MolarFlow.FromMolesPerSecond(5), MolesPerSecondTolerance);
+            Assert.Equal(-1, -v.MolesPerSecond);
+            Assert.Equal(2, (MolarFlow.FromMolesPerSecond(3) - v).MolesPerSecond);
+            Assert.Equal(2, (v + v).MolesPerSecond);
+            Assert.Equal(10, (v * 10).MolesPerSecond);
+            Assert.Equal(10, (10 * v).MolesPerSecond);
+            Assert.Equal(2, (MolarFlow.FromMolesPerSecond(10) / 5).MolesPerSecond);
+            Assert.Equal(2, MolarFlow.FromMolesPerSecond(10) / MolarFlow.FromMolesPerSecond(5));
         }
 
         [Fact]
@@ -614,8 +674,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MolarFlowUnit.MolePerSecond, 1, MolarFlowUnit.MolePerSecond, true)]  // Same value and unit.
         [InlineData(1, MolarFlowUnit.MolePerSecond, 2, MolarFlowUnit.MolePerSecond, false)] // Different value.
-        [InlineData(2, MolarFlowUnit.MolePerSecond, 1, MolarFlowUnit.KilomolePerHour, false)] // Different value and unit.
-        [InlineData(1, MolarFlowUnit.MolePerSecond, 1, MolarFlowUnit.KilomolePerHour, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MolarFlowUnit unitA, double valueB, MolarFlowUnit unitB, bool expectEqual)
         {
             var a = new MolarFlow(valueA, unitA);
@@ -675,8 +733,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MolarFlow.FromMolesPerSecond(firstValue);
             var otherQuantity = MolarFlow.FromMolesPerSecond(secondValue);
             MolarFlow maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MolarFlow.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -695,7 +753,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MolarFlowUnit>();
+            var units = EnumHelper.GetValues<MolarFlowUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -708,14 +766,26 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(MolarFlow.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(MolarFlow.Info.Units, MolarFlow.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, MolarFlow.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
             using var _ = new CultureScope("en-US");
-            Assert.Equal("1 kkmol/h", new MolarFlow(1, MolarFlowUnit.KilomolePerHour).ToString());
+            Assert.Equal("1 kmol/h", new MolarFlow(1, MolarFlowUnit.KilomolePerHour).ToString());
             Assert.Equal("1 kmol/min", new MolarFlow(1, MolarFlowUnit.KilomolePerMinute).ToString());
             Assert.Equal("1 kmol/s", new MolarFlow(1, MolarFlowUnit.KilomolePerSecond).ToString());
-            Assert.Equal("1 kmol/h", new MolarFlow(1, MolarFlowUnit.MolePerHour).ToString());
+            Assert.Equal("1 mol/h", new MolarFlow(1, MolarFlowUnit.MolePerHour).ToString());
             Assert.Equal("1 mol/min", new MolarFlow(1, MolarFlowUnit.MolePerMinute).ToString());
             Assert.Equal("1 mol/s", new MolarFlow(1, MolarFlowUnit.MolePerSecond).ToString());
             Assert.Equal("1 lbmol/h", new MolarFlow(1, MolarFlowUnit.PoundMolePerHour).ToString());
@@ -729,10 +799,10 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
             var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
 
-            Assert.Equal("1 kkmol/h", new MolarFlow(1, MolarFlowUnit.KilomolePerHour).ToString(swedishCulture));
+            Assert.Equal("1 kmol/h", new MolarFlow(1, MolarFlowUnit.KilomolePerHour).ToString(swedishCulture));
             Assert.Equal("1 kmol/min", new MolarFlow(1, MolarFlowUnit.KilomolePerMinute).ToString(swedishCulture));
             Assert.Equal("1 kmol/s", new MolarFlow(1, MolarFlowUnit.KilomolePerSecond).ToString(swedishCulture));
-            Assert.Equal("1 kmol/h", new MolarFlow(1, MolarFlowUnit.MolePerHour).ToString(swedishCulture));
+            Assert.Equal("1 mol/h", new MolarFlow(1, MolarFlowUnit.MolePerHour).ToString(swedishCulture));
             Assert.Equal("1 mol/min", new MolarFlow(1, MolarFlowUnit.MolePerMinute).ToString(swedishCulture));
             Assert.Equal("1 mol/s", new MolarFlow(1, MolarFlowUnit.MolePerSecond).ToString(swedishCulture));
             Assert.Equal("1 lbmol/h", new MolarFlow(1, MolarFlowUnit.PoundMolePerHour).ToString(swedishCulture));
@@ -740,26 +810,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 lbmol/s", new MolarFlow(1, MolarFlowUnit.PoundMolePerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 mol/s", new MolarFlow(0.123456, MolarFlowUnit.MolePerSecond).ToString("s1"));
-            Assert.Equal("0.12 mol/s", new MolarFlow(0.123456, MolarFlowUnit.MolePerSecond).ToString("s2"));
-            Assert.Equal("0.123 mol/s", new MolarFlow(0.123456, MolarFlowUnit.MolePerSecond).ToString("s3"));
-            Assert.Equal("0.1235 mol/s", new MolarFlow(0.123456, MolarFlowUnit.MolePerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 mol/s", new MolarFlow(0.123456, MolarFlowUnit.MolePerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 mol/s", new MolarFlow(0.123456, MolarFlowUnit.MolePerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 mol/s", new MolarFlow(0.123456, MolarFlowUnit.MolePerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 mol/s", new MolarFlow(0.123456, MolarFlowUnit.MolePerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -786,7 +836,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MolarFlow.FromMolesPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MolarFlow), quantity.As(MolarFlow.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs
index 0e16d4b1fa..9fd4482452 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarMassTestsBase.g.cs
@@ -53,6 +53,7 @@ public abstract partial class MolarMassTestsBase : QuantityTestsBase
         protected abstract double MilligramsPerMoleInOneKilogramPerMole { get; }
         protected abstract double NanogramsPerMoleInOneKilogramPerMole { get; }
         protected abstract double PoundsPerMoleInOneKilogramPerMole { get; }
+        protected abstract double PoundsPerPoundMoleInOneKilogramPerMole { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double CentigramsPerMoleTolerance { get { return 1e-5; } }
@@ -68,6 +69,7 @@ public abstract partial class MolarMassTestsBase : QuantityTestsBase
         protected virtual double MilligramsPerMoleTolerance { get { return 1e-5; } }
         protected virtual double NanogramsPerMoleTolerance { get { return 1e-5; } }
         protected virtual double PoundsPerMoleTolerance { get { return 1e-5; } }
+        protected virtual double PoundsPerPoundMoleTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(MolarMassUnit unit)
@@ -87,6 +89,7 @@ public abstract partial class MolarMassTestsBase : QuantityTestsBase
                 MolarMassUnit.MilligramPerMole => (MilligramsPerMoleInOneKilogramPerMole, MilligramsPerMoleTolerance),
                 MolarMassUnit.NanogramPerMole => (NanogramsPerMoleInOneKilogramPerMole, NanogramsPerMoleTolerance),
                 MolarMassUnit.PoundPerMole => (PoundsPerMoleInOneKilogramPerMole, PoundsPerMoleTolerance),
+                MolarMassUnit.PoundPerPoundMole => (PoundsPerPoundMoleInOneKilogramPerMole, PoundsPerPoundMoleTolerance),
                 _ => throw new NotSupportedException()
             };
         }
@@ -106,6 +109,7 @@ public abstract partial class MolarMassTestsBase : QuantityTestsBase
             new object[] { MolarMassUnit.MilligramPerMole },
             new object[] { MolarMassUnit.NanogramPerMole },
             new object[] { MolarMassUnit.PoundPerMole },
+            new object[] { MolarMassUnit.PoundPerPoundMole },
         };
 
         [Fact]
@@ -173,6 +177,20 @@ public void MolarMass_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MolarMassUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MolarMassInfo_CreateWithCustomUnitInfos()
+        {
+            MolarMassUnit[] expectedUnits = [MolarMassUnit.KilogramPerMole];
+
+            MolarMass.MolarMassInfo quantityInfo = MolarMass.MolarMassInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("MolarMass", quantityInfo.Name);
+            Assert.Equal(MolarMass.Zero, quantityInfo.Zero);
+            Assert.Equal(MolarMass.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KilogramPerMoleToMolarMassUnits()
         {
@@ -190,6 +208,7 @@ public void KilogramPerMoleToMolarMassUnits()
             AssertEx.EqualTolerance(MilligramsPerMoleInOneKilogramPerMole, kilogrampermole.MilligramsPerMole, MilligramsPerMoleTolerance);
             AssertEx.EqualTolerance(NanogramsPerMoleInOneKilogramPerMole, kilogrampermole.NanogramsPerMole, NanogramsPerMoleTolerance);
             AssertEx.EqualTolerance(PoundsPerMoleInOneKilogramPerMole, kilogrampermole.PoundsPerMole, PoundsPerMoleTolerance);
+            AssertEx.EqualTolerance(PoundsPerPoundMoleInOneKilogramPerMole, kilogrampermole.PoundsPerPoundMole, PoundsPerPoundMoleTolerance);
         }
 
         [Fact]
@@ -238,6 +257,7 @@ public void As()
             AssertEx.EqualTolerance(MilligramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.MilligramPerMole), MilligramsPerMoleTolerance);
             AssertEx.EqualTolerance(NanogramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.NanogramPerMole), NanogramsPerMoleTolerance);
             AssertEx.EqualTolerance(PoundsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.PoundPerMole), PoundsPerMoleTolerance);
+            AssertEx.EqualTolerance(PoundsPerPoundMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.PoundPerPoundMole), PoundsPerPoundMoleTolerance);
         }
 
         [Fact]
@@ -281,26 +301,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = MolarMass.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            MolarMass convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                MolarMass quantityToConvert = quantity;
+
+                MolarMass convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MolarMassUnit> quantityToConvert = quantity;
+
+                IQuantity<MolarMassUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new MolarMass(value: 1, unit: MolarMass.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MolarMass(value: 1, unit: MolarMass.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolarMassUnit> quantity = new MolarMass(value: 1, unit: MolarMass.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MolarMass(value: 1, unit: MolarMass.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new MolarMass(value: 1, unit: MolarMass.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new MolarMass(value: 1, unit: MolarMass.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolarMassUnit> quantity = new MolarMass(value: 1, unit: MolarMass.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new MolarMass(value: 1, unit: MolarMass.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -317,6 +380,8 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mg/mol", MolarMassUnit.MilligramPerMole, 4.2)]
         [InlineData("en-US", "4.2 ng/mol", MolarMassUnit.NanogramPerMole, 4.2)]
         [InlineData("en-US", "4.2 lb/mol", MolarMassUnit.PoundPerMole, 4.2)]
+        [InlineData("en-US", "4.2 lb/lbmol", MolarMassUnit.PoundPerPoundMole, 4.2)]
+        [InlineData("en-US", "4.2 lbm/lbmol", MolarMassUnit.PoundPerPoundMole, 4.2)]
         [InlineData("ru-RU", "4,2 сг/моль", MolarMassUnit.CentigramPerMole, 4.2)]
         [InlineData("ru-RU", "4,2 даг/моль", MolarMassUnit.DecagramPerMole, 4.2)]
         [InlineData("ru-RU", "4,2 дг/моль", MolarMassUnit.DecigramPerMole, 4.2)]
@@ -329,7 +394,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 мг/моль", MolarMassUnit.MilligramPerMole, 4.2)]
         [InlineData("ru-RU", "4,2 нг/моль", MolarMassUnit.NanogramPerMole, 4.2)]
         [InlineData("ru-RU", "4,2 фунт/моль", MolarMassUnit.PoundPerMole, 4.2)]
-        public void Parse(string culture, string quantityString, MolarMassUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MolarMassUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = MolarMass.Parse(quantityString);
@@ -351,6 +416,8 @@ public void Parse(string culture, string quantityString, MolarMassUnit expectedU
         [InlineData("en-US", "4.2 mg/mol", MolarMassUnit.MilligramPerMole, 4.2)]
         [InlineData("en-US", "4.2 ng/mol", MolarMassUnit.NanogramPerMole, 4.2)]
         [InlineData("en-US", "4.2 lb/mol", MolarMassUnit.PoundPerMole, 4.2)]
+        [InlineData("en-US", "4.2 lb/lbmol", MolarMassUnit.PoundPerPoundMole, 4.2)]
+        [InlineData("en-US", "4.2 lbm/lbmol", MolarMassUnit.PoundPerPoundMole, 4.2)]
         [InlineData("ru-RU", "4,2 сг/моль", MolarMassUnit.CentigramPerMole, 4.2)]
         [InlineData("ru-RU", "4,2 даг/моль", MolarMassUnit.DecagramPerMole, 4.2)]
         [InlineData("ru-RU", "4,2 дг/моль", MolarMassUnit.DecigramPerMole, 4.2)]
@@ -363,7 +430,7 @@ public void Parse(string culture, string quantityString, MolarMassUnit expectedU
         [InlineData("ru-RU", "4,2 мг/моль", MolarMassUnit.MilligramPerMole, 4.2)]
         [InlineData("ru-RU", "4,2 нг/моль", MolarMassUnit.NanogramPerMole, 4.2)]
         [InlineData("ru-RU", "4,2 фунт/моль", MolarMassUnit.PoundPerMole, 4.2)]
-        public void TryParse(string culture, string quantityString, MolarMassUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MolarMassUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(MolarMass.TryParse(quantityString, out MolarMass parsed));
@@ -385,6 +452,8 @@ public void TryParse(string culture, string quantityString, MolarMassUnit expect
         [InlineData("mg/mol", MolarMassUnit.MilligramPerMole)]
         [InlineData("ng/mol", MolarMassUnit.NanogramPerMole)]
         [InlineData("lb/mol", MolarMassUnit.PoundPerMole)]
+        [InlineData("lb/lbmol", MolarMassUnit.PoundPerPoundMole)]
+        [InlineData("lbm/lbmol", MolarMassUnit.PoundPerPoundMole)]
         public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, MolarMassUnit expectedUnit)
         {
             // Fallback culture "en-US" is always localized
@@ -407,6 +476,8 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, MolarMass
         [InlineData("mg/mol", MolarMassUnit.MilligramPerMole)]
         [InlineData("ng/mol", MolarMassUnit.NanogramPerMole)]
         [InlineData("lb/mol", MolarMassUnit.PoundPerMole)]
+        [InlineData("lb/lbmol", MolarMassUnit.PoundPerPoundMole)]
+        [InlineData("lbm/lbmol", MolarMassUnit.PoundPerPoundMole)]
         public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, MolarMassUnit expectedUnit)
         {
             // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing.
@@ -429,6 +500,8 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "mg/mol", MolarMassUnit.MilligramPerMole)]
         [InlineData("en-US", "ng/mol", MolarMassUnit.NanogramPerMole)]
         [InlineData("en-US", "lb/mol", MolarMassUnit.PoundPerMole)]
+        [InlineData("en-US", "lb/lbmol", MolarMassUnit.PoundPerPoundMole)]
+        [InlineData("en-US", "lbm/lbmol", MolarMassUnit.PoundPerPoundMole)]
         [InlineData("ru-RU", "сг/моль", MolarMassUnit.CentigramPerMole)]
         [InlineData("ru-RU", "даг/моль", MolarMassUnit.DecagramPerMole)]
         [InlineData("ru-RU", "дг/моль", MolarMassUnit.DecigramPerMole)]
@@ -462,6 +535,8 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Mo
         [InlineData("en-US", "mg/mol", MolarMassUnit.MilligramPerMole)]
         [InlineData("en-US", "ng/mol", MolarMassUnit.NanogramPerMole)]
         [InlineData("en-US", "lb/mol", MolarMassUnit.PoundPerMole)]
+        [InlineData("en-US", "lb/lbmol", MolarMassUnit.PoundPerPoundMole)]
+        [InlineData("en-US", "lbm/lbmol", MolarMassUnit.PoundPerPoundMole)]
         [InlineData("ru-RU", "сг/моль", MolarMassUnit.CentigramPerMole)]
         [InlineData("ru-RU", "даг/моль", MolarMassUnit.DecagramPerMole)]
         [InlineData("ru-RU", "дг/моль", MolarMassUnit.DecigramPerMole)]
@@ -494,6 +569,8 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, MolarMass
         [InlineData("mg/mol", MolarMassUnit.MilligramPerMole)]
         [InlineData("ng/mol", MolarMassUnit.NanogramPerMole)]
         [InlineData("lb/mol", MolarMassUnit.PoundPerMole)]
+        [InlineData("lb/lbmol", MolarMassUnit.PoundPerPoundMole)]
+        [InlineData("lbm/lbmol", MolarMassUnit.PoundPerPoundMole)]
         public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, MolarMassUnit expectedUnit)
         {
             // Fallback culture "en-US" is always localized
@@ -516,6 +593,8 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, MolarM
         [InlineData("mg/mol", MolarMassUnit.MilligramPerMole)]
         [InlineData("ng/mol", MolarMassUnit.NanogramPerMole)]
         [InlineData("lb/mol", MolarMassUnit.PoundPerMole)]
+        [InlineData("lb/lbmol", MolarMassUnit.PoundPerPoundMole)]
+        [InlineData("lbm/lbmol", MolarMassUnit.PoundPerPoundMole)]
         public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, MolarMassUnit expectedUnit)
         {
             // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing.
@@ -538,6 +617,8 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "mg/mol", MolarMassUnit.MilligramPerMole)]
         [InlineData("en-US", "ng/mol", MolarMassUnit.NanogramPerMole)]
         [InlineData("en-US", "lb/mol", MolarMassUnit.PoundPerMole)]
+        [InlineData("en-US", "lb/lbmol", MolarMassUnit.PoundPerPoundMole)]
+        [InlineData("en-US", "lbm/lbmol", MolarMassUnit.PoundPerPoundMole)]
         [InlineData("ru-RU", "сг/моль", MolarMassUnit.CentigramPerMole)]
         [InlineData("ru-RU", "даг/моль", MolarMassUnit.DecagramPerMole)]
         [InlineData("ru-RU", "дг/моль", MolarMassUnit.DecigramPerMole)]
@@ -571,6 +652,8 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "mg/mol", MolarMassUnit.MilligramPerMole)]
         [InlineData("en-US", "ng/mol", MolarMassUnit.NanogramPerMole)]
         [InlineData("en-US", "lb/mol", MolarMassUnit.PoundPerMole)]
+        [InlineData("en-US", "lb/lbmol", MolarMassUnit.PoundPerPoundMole)]
+        [InlineData("en-US", "lbm/lbmol", MolarMassUnit.PoundPerPoundMole)]
         [InlineData("ru-RU", "сг/моль", MolarMassUnit.CentigramPerMole)]
         [InlineData("ru-RU", "даг/моль", MolarMassUnit.DecagramPerMole)]
         [InlineData("ru-RU", "дг/моль", MolarMassUnit.DecigramPerMole)]
@@ -603,6 +686,7 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, MolarM
         [InlineData("en-US", MolarMassUnit.MilligramPerMole, "mg/mol")]
         [InlineData("en-US", MolarMassUnit.NanogramPerMole, "ng/mol")]
         [InlineData("en-US", MolarMassUnit.PoundPerMole, "lb/mol")]
+        [InlineData("en-US", MolarMassUnit.PoundPerPoundMole, "lb/lbmol")]
         [InlineData("ru-RU", MolarMassUnit.CentigramPerMole, "сг/моль")]
         [InlineData("ru-RU", MolarMassUnit.DecagramPerMole, "даг/моль")]
         [InlineData("ru-RU", MolarMassUnit.DecigramPerMole, "дг/моль")]
@@ -664,6 +748,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MolarMassUnit un
                 var quantity = MolarMass.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -687,44 +772,47 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MolarMassUnit unit)
                 IQuantity<MolarMassUnit> quantityToConvert = quantity;
                 IQuantity<MolarMassUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1);
-            AssertEx.EqualTolerance(1, MolarMass.FromCentigramsPerMole(kilogrampermole.CentigramsPerMole).KilogramsPerMole, CentigramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromDecagramsPerMole(kilogrampermole.DecagramsPerMole).KilogramsPerMole, DecagramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromDecigramsPerMole(kilogrampermole.DecigramsPerMole).KilogramsPerMole, DecigramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromGramsPerMole(kilogrampermole.GramsPerMole).KilogramsPerMole, GramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromHectogramsPerMole(kilogrampermole.HectogramsPerMole).KilogramsPerMole, HectogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromKilogramsPerKilomole(kilogrampermole.KilogramsPerKilomole).KilogramsPerMole, KilogramsPerKilomoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromKilogramsPerMole(kilogrampermole.KilogramsPerMole).KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromKilopoundsPerMole(kilogrampermole.KilopoundsPerMole).KilogramsPerMole, KilopoundsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromMegapoundsPerMole(kilogrampermole.MegapoundsPerMole).KilogramsPerMole, MegapoundsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromMicrogramsPerMole(kilogrampermole.MicrogramsPerMole).KilogramsPerMole, MicrogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromMilligramsPerMole(kilogrampermole.MilligramsPerMole).KilogramsPerMole, MilligramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromNanogramsPerMole(kilogrampermole.NanogramsPerMole).KilogramsPerMole, NanogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(1, MolarMass.FromPoundsPerMole(kilogrampermole.PoundsPerMole).KilogramsPerMole, PoundsPerMoleTolerance);
+            MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(3);
+            Assert.Equal(3, MolarMass.FromCentigramsPerMole(kilogrampermole.CentigramsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromDecagramsPerMole(kilogrampermole.DecagramsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromDecigramsPerMole(kilogrampermole.DecigramsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromGramsPerMole(kilogrampermole.GramsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromHectogramsPerMole(kilogrampermole.HectogramsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromKilogramsPerKilomole(kilogrampermole.KilogramsPerKilomole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromKilogramsPerMole(kilogrampermole.KilogramsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromKilopoundsPerMole(kilogrampermole.KilopoundsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromMegapoundsPerMole(kilogrampermole.MegapoundsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromMicrogramsPerMole(kilogrampermole.MicrogramsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromMilligramsPerMole(kilogrampermole.MilligramsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromNanogramsPerMole(kilogrampermole.NanogramsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromPoundsPerMole(kilogrampermole.PoundsPerMole).KilogramsPerMole);
+            Assert.Equal(3, MolarMass.FromPoundsPerPoundMole(kilogrampermole.PoundsPerPoundMole).KilogramsPerMole);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             MolarMass v = MolarMass.FromKilogramsPerMole(1);
-            AssertEx.EqualTolerance(-1, -v.KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(2, (MolarMass.FromKilogramsPerMole(3)-v).KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(2, (MolarMass.FromKilogramsPerMole(10)/5).KilogramsPerMole, KilogramsPerMoleTolerance);
-            AssertEx.EqualTolerance(2, MolarMass.FromKilogramsPerMole(10)/MolarMass.FromKilogramsPerMole(5), KilogramsPerMoleTolerance);
+            Assert.Equal(-1, -v.KilogramsPerMole);
+            Assert.Equal(2, (MolarMass.FromKilogramsPerMole(3) - v).KilogramsPerMole);
+            Assert.Equal(2, (v + v).KilogramsPerMole);
+            Assert.Equal(10, (v * 10).KilogramsPerMole);
+            Assert.Equal(10, (10 * v).KilogramsPerMole);
+            Assert.Equal(2, (MolarMass.FromKilogramsPerMole(10) / 5).KilogramsPerMole);
+            Assert.Equal(2, MolarMass.FromKilogramsPerMole(10) / MolarMass.FromKilogramsPerMole(5));
         }
 
         [Fact]
@@ -770,8 +858,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MolarMassUnit.KilogramPerMole, 1, MolarMassUnit.KilogramPerMole, true)]  // Same value and unit.
         [InlineData(1, MolarMassUnit.KilogramPerMole, 2, MolarMassUnit.KilogramPerMole, false)] // Different value.
-        [InlineData(2, MolarMassUnit.KilogramPerMole, 1, MolarMassUnit.CentigramPerMole, false)] // Different value and unit.
-        [InlineData(1, MolarMassUnit.KilogramPerMole, 1, MolarMassUnit.CentigramPerMole, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MolarMassUnit unitA, double valueB, MolarMassUnit unitB, bool expectEqual)
         {
             var a = new MolarMass(valueA, unitA);
@@ -831,8 +917,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = MolarMass.FromKilogramsPerMole(firstValue);
             var otherQuantity = MolarMass.FromKilogramsPerMole(secondValue);
             MolarMass maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, MolarMass.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -851,7 +937,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MolarMassUnit>();
+            var units = EnumHelper.GetValues<MolarMassUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -864,6 +950,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(MolarMass.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(MolarMass.Info.Units, MolarMass.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, MolarMass.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -881,6 +979,7 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
             Assert.Equal("1 mg/mol", new MolarMass(1, MolarMassUnit.MilligramPerMole).ToString());
             Assert.Equal("1 ng/mol", new MolarMass(1, MolarMassUnit.NanogramPerMole).ToString());
             Assert.Equal("1 lb/mol", new MolarMass(1, MolarMassUnit.PoundPerMole).ToString());
+            Assert.Equal("1 lb/lbmol", new MolarMass(1, MolarMassUnit.PoundPerPoundMole).ToString());
         }
 
         [Fact]
@@ -902,26 +1001,7 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 mg/mol", new MolarMass(1, MolarMassUnit.MilligramPerMole).ToString(swedishCulture));
             Assert.Equal("1 ng/mol", new MolarMass(1, MolarMassUnit.NanogramPerMole).ToString(swedishCulture));
             Assert.Equal("1 lb/mol", new MolarMass(1, MolarMassUnit.PoundPerMole).ToString(swedishCulture));
-        }
-
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 kg/mol", new MolarMass(0.123456, MolarMassUnit.KilogramPerMole).ToString("s1"));
-            Assert.Equal("0.12 kg/mol", new MolarMass(0.123456, MolarMassUnit.KilogramPerMole).ToString("s2"));
-            Assert.Equal("0.123 kg/mol", new MolarMass(0.123456, MolarMassUnit.KilogramPerMole).ToString("s3"));
-            Assert.Equal("0.1235 kg/mol", new MolarMass(0.123456, MolarMassUnit.KilogramPerMole).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 kg/mol", new MolarMass(0.123456, MolarMassUnit.KilogramPerMole).ToString("s1", culture));
-            Assert.Equal("0.12 kg/mol", new MolarMass(0.123456, MolarMassUnit.KilogramPerMole).ToString("s2", culture));
-            Assert.Equal("0.123 kg/mol", new MolarMass(0.123456, MolarMassUnit.KilogramPerMole).ToString("s3", culture));
-            Assert.Equal("0.1235 kg/mol", new MolarMass(0.123456, MolarMassUnit.KilogramPerMole).ToString("s4", culture));
+            Assert.Equal("1 lb/lbmol", new MolarMass(1, MolarMassUnit.PoundPerPoundMole).ToString(swedishCulture));
         }
 
         [Theory]
@@ -950,7 +1030,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = MolarMass.FromKilogramsPerMole(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(MolarMass), quantity.As(MolarMass.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs
index fcab87357e..67daa45930 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MolarityTestsBase.g.cs
@@ -165,6 +165,20 @@ public void Molarity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<MolarityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void MolarityInfo_CreateWithCustomUnitInfos()
+        {
+            MolarityUnit[] expectedUnits = [MolarityUnit.MolePerCubicMeter];
+
+            Molarity.MolarityInfo quantityInfo = Molarity.MolarityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Molarity", quantityInfo.Name);
+            Assert.Equal(Molarity.Zero, quantityInfo.Zero);
+            Assert.Equal(Molarity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void MolePerCubicMeterToMolarityUnits()
         {
@@ -269,26 +283,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Molarity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Molarity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Molarity quantityToConvert = quantity;
+
+                Molarity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<MolarityUnit> quantityToConvert = quantity;
+
+                IQuantity<MolarityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Molarity(value: 1, unit: Molarity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Molarity(value: 1, unit: Molarity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolarityUnit> quantity = new Molarity(value: 1, unit: Molarity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Molarity(value: 1, unit: Molarity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Molarity(value: 1, unit: Molarity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Molarity(value: 1, unit: Molarity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<MolarityUnit> quantity = new Molarity(value: 1, unit: Molarity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Molarity(value: 1, unit: Molarity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -311,7 +368,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 pmol/l", MolarityUnit.PicomolePerLiter, 4.2)]
         [InlineData("en-US", "4.2 pM", MolarityUnit.PicomolePerLiter, 4.2)]
         [InlineData("en-US", "4.2 lbmol/ft³", MolarityUnit.PoundMolePerCubicFoot, 4.2)]
-        public void Parse(string culture, string quantityString, MolarityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, MolarityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Molarity.Parse(quantityString);
@@ -339,7 +396,7 @@ public void Parse(string culture, string quantityString, MolarityUnit expectedUn
         [InlineData("en-US", "4.2 pmol/l", MolarityUnit.PicomolePerLiter, 4.2)]
         [InlineData("en-US", "4.2 pM", MolarityUnit.PicomolePerLiter, 4.2)]
         [InlineData("en-US", "4.2 lbmol/ft³", MolarityUnit.PoundMolePerCubicFoot, 4.2)]
-        public void TryParse(string culture, string quantityString, MolarityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, MolarityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Molarity.TryParse(quantityString, out Molarity parsed));
@@ -626,6 +683,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(MolarityUnit uni
                 var quantity = Molarity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -649,42 +707,44 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(MolarityUnit unit)
                 IQuantity<MolarityUnit> quantityToConvert = quantity;
                 IQuantity<MolarityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Molarity molepercubicmeter = Molarity.FromMolesPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, Molarity.FromCentimolesPerLiter(molepercubicmeter.CentimolesPerLiter).MolesPerCubicMeter, CentimolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromDecimolesPerLiter(molepercubicmeter.DecimolesPerLiter).MolesPerCubicMeter, DecimolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromFemtomolesPerLiter(molepercubicmeter.FemtomolesPerLiter).MolesPerCubicMeter, FemtomolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromKilomolesPerCubicMeter(molepercubicmeter.KilomolesPerCubicMeter).MolesPerCubicMeter, KilomolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromMicromolesPerLiter(molepercubicmeter.MicromolesPerLiter).MolesPerCubicMeter, MicromolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromMillimolesPerLiter(molepercubicmeter.MillimolesPerLiter).MolesPerCubicMeter, MillimolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromMolesPerCubicMeter(molepercubicmeter.MolesPerCubicMeter).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromMolesPerLiter(molepercubicmeter.MolesPerLiter).MolesPerCubicMeter, MolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromNanomolesPerLiter(molepercubicmeter.NanomolesPerLiter).MolesPerCubicMeter, NanomolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromPicomolesPerLiter(molepercubicmeter.PicomolesPerLiter).MolesPerCubicMeter, PicomolesPerLiterTolerance);
-            AssertEx.EqualTolerance(1, Molarity.FromPoundMolesPerCubicFoot(molepercubicmeter.PoundMolesPerCubicFoot).MolesPerCubicMeter, PoundMolesPerCubicFootTolerance);
+            Molarity molepercubicmeter = Molarity.FromMolesPerCubicMeter(3);
+            Assert.Equal(3, Molarity.FromCentimolesPerLiter(molepercubicmeter.CentimolesPerLiter).MolesPerCubicMeter);
+            Assert.Equal(3, Molarity.FromDecimolesPerLiter(molepercubicmeter.DecimolesPerLiter).MolesPerCubicMeter);
+            Assert.Equal(3, Molarity.FromFemtomolesPerLiter(molepercubicmeter.FemtomolesPerLiter).MolesPerCubicMeter);
+            Assert.Equal(3, Molarity.FromKilomolesPerCubicMeter(molepercubicmeter.KilomolesPerCubicMeter).MolesPerCubicMeter);
+            Assert.Equal(3, Molarity.FromMicromolesPerLiter(molepercubicmeter.MicromolesPerLiter).MolesPerCubicMeter);
+            Assert.Equal(3, Molarity.FromMillimolesPerLiter(molepercubicmeter.MillimolesPerLiter).MolesPerCubicMeter);
+            Assert.Equal(3, Molarity.FromMolesPerCubicMeter(molepercubicmeter.MolesPerCubicMeter).MolesPerCubicMeter);
+            Assert.Equal(3, Molarity.FromMolesPerLiter(molepercubicmeter.MolesPerLiter).MolesPerCubicMeter);
+            Assert.Equal(3, Molarity.FromNanomolesPerLiter(molepercubicmeter.NanomolesPerLiter).MolesPerCubicMeter);
+            Assert.Equal(3, Molarity.FromPicomolesPerLiter(molepercubicmeter.PicomolesPerLiter).MolesPerCubicMeter);
+            Assert.Equal(3, Molarity.FromPoundMolesPerCubicFoot(molepercubicmeter.PoundMolesPerCubicFoot).MolesPerCubicMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Molarity v = Molarity.FromMolesPerCubicMeter(1);
-            AssertEx.EqualTolerance(-1, -v.MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (Molarity.FromMolesPerCubicMeter(3)-v).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (Molarity.FromMolesPerCubicMeter(10)/5).MolesPerCubicMeter, MolesPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, Molarity.FromMolesPerCubicMeter(10)/Molarity.FromMolesPerCubicMeter(5), MolesPerCubicMeterTolerance);
+            Assert.Equal(-1, -v.MolesPerCubicMeter);
+            Assert.Equal(2, (Molarity.FromMolesPerCubicMeter(3) - v).MolesPerCubicMeter);
+            Assert.Equal(2, (v + v).MolesPerCubicMeter);
+            Assert.Equal(10, (v * 10).MolesPerCubicMeter);
+            Assert.Equal(10, (10 * v).MolesPerCubicMeter);
+            Assert.Equal(2, (Molarity.FromMolesPerCubicMeter(10) / 5).MolesPerCubicMeter);
+            Assert.Equal(2, Molarity.FromMolesPerCubicMeter(10) / Molarity.FromMolesPerCubicMeter(5));
         }
 
         [Fact]
@@ -730,8 +790,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, MolarityUnit.MolePerCubicMeter, 1, MolarityUnit.MolePerCubicMeter, true)]  // Same value and unit.
         [InlineData(1, MolarityUnit.MolePerCubicMeter, 2, MolarityUnit.MolePerCubicMeter, false)] // Different value.
-        [InlineData(2, MolarityUnit.MolePerCubicMeter, 1, MolarityUnit.CentimolePerLiter, false)] // Different value and unit.
-        [InlineData(1, MolarityUnit.MolePerCubicMeter, 1, MolarityUnit.CentimolePerLiter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, MolarityUnit unitA, double valueB, MolarityUnit unitB, bool expectEqual)
         {
             var a = new Molarity(valueA, unitA);
@@ -791,8 +849,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Molarity.FromMolesPerCubicMeter(firstValue);
             var otherQuantity = Molarity.FromMolesPerCubicMeter(secondValue);
             Molarity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Molarity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -811,7 +869,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<MolarityUnit>();
+            var units = EnumHelper.GetValues<MolarityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -824,6 +882,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Molarity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Molarity.Info.Units, Molarity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Molarity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -860,26 +930,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 lbmol/ft³", new Molarity(1, MolarityUnit.PoundMolePerCubicFoot).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 mol/m³", new Molarity(0.123456, MolarityUnit.MolePerCubicMeter).ToString("s1"));
-            Assert.Equal("0.12 mol/m³", new Molarity(0.123456, MolarityUnit.MolePerCubicMeter).ToString("s2"));
-            Assert.Equal("0.123 mol/m³", new Molarity(0.123456, MolarityUnit.MolePerCubicMeter).ToString("s3"));
-            Assert.Equal("0.1235 mol/m³", new Molarity(0.123456, MolarityUnit.MolePerCubicMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 mol/m³", new Molarity(0.123456, MolarityUnit.MolePerCubicMeter).ToString("s1", culture));
-            Assert.Equal("0.12 mol/m³", new Molarity(0.123456, MolarityUnit.MolePerCubicMeter).ToString("s2", culture));
-            Assert.Equal("0.123 mol/m³", new Molarity(0.123456, MolarityUnit.MolePerCubicMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 mol/m³", new Molarity(0.123456, MolarityUnit.MolePerCubicMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -906,7 +956,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Molarity.FromMolesPerCubicMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Molarity), quantity.As(Molarity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PermeabilityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PermeabilityTestsBase.g.cs
index 4853e2bd39..6c43597631 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PermeabilityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PermeabilityTestsBase.g.cs
@@ -125,6 +125,20 @@ public void Permeability_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<PermeabilityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void PermeabilityInfo_CreateWithCustomUnitInfos()
+        {
+            PermeabilityUnit[] expectedUnits = [PermeabilityUnit.HenryPerMeter];
+
+            Permeability.PermeabilityInfo quantityInfo = Permeability.PermeabilityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Permeability", quantityInfo.Name);
+            Assert.Equal(Permeability.Zero, quantityInfo.Zero);
+            Assert.Equal(Permeability.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void HenryPerMeterToPermeabilityUnits()
         {
@@ -209,31 +223,74 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Permeability.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Permeability convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Permeability quantityToConvert = quantity;
+
+                Permeability convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<PermeabilityUnit> quantityToConvert = quantity;
+
+                IQuantity<PermeabilityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Permeability(value: 1, unit: Permeability.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Permeability(value: 1, unit: Permeability.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<PermeabilityUnit> quantity = new Permeability(value: 1, unit: Permeability.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Permeability(value: 1, unit: Permeability.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Permeability(value: 1, unit: Permeability.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Permeability(value: 1, unit: Permeability.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<PermeabilityUnit> quantity = new Permeability(value: 1, unit: Permeability.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Permeability(value: 1, unit: Permeability.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 H/m", PermeabilityUnit.HenryPerMeter, 4.2)]
-        public void Parse(string culture, string quantityString, PermeabilityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, PermeabilityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Permeability.Parse(quantityString);
@@ -243,7 +300,7 @@ public void Parse(string culture, string quantityString, PermeabilityUnit expect
 
         [Theory]
         [InlineData("en-US", "4.2 H/m", PermeabilityUnit.HenryPerMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, PermeabilityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, PermeabilityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Permeability.TryParse(quantityString, out Permeability parsed));
@@ -376,6 +433,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(PermeabilityUnit
                 var quantity = Permeability.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -399,32 +457,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(PermeabilityUnit un
                 IQuantity<PermeabilityUnit> quantityToConvert = quantity;
                 IQuantity<PermeabilityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Permeability henrypermeter = Permeability.FromHenriesPerMeter(1);
-            AssertEx.EqualTolerance(1, Permeability.FromHenriesPerMeter(henrypermeter.HenriesPerMeter).HenriesPerMeter, HenriesPerMeterTolerance);
+            Permeability henrypermeter = Permeability.FromHenriesPerMeter(3);
+            Assert.Equal(3, Permeability.FromHenriesPerMeter(henrypermeter.HenriesPerMeter).HenriesPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Permeability v = Permeability.FromHenriesPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.HenriesPerMeter, HenriesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Permeability.FromHenriesPerMeter(3)-v).HenriesPerMeter, HenriesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).HenriesPerMeter, HenriesPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).HenriesPerMeter, HenriesPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).HenriesPerMeter, HenriesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Permeability.FromHenriesPerMeter(10)/5).HenriesPerMeter, HenriesPerMeterTolerance);
-            AssertEx.EqualTolerance(2, Permeability.FromHenriesPerMeter(10)/Permeability.FromHenriesPerMeter(5), HenriesPerMeterTolerance);
+            Assert.Equal(-1, -v.HenriesPerMeter);
+            Assert.Equal(2, (Permeability.FromHenriesPerMeter(3) - v).HenriesPerMeter);
+            Assert.Equal(2, (v + v).HenriesPerMeter);
+            Assert.Equal(10, (v * 10).HenriesPerMeter);
+            Assert.Equal(10, (10 * v).HenriesPerMeter);
+            Assert.Equal(2, (Permeability.FromHenriesPerMeter(10) / 5).HenriesPerMeter);
+            Assert.Equal(2, Permeability.FromHenriesPerMeter(10) / Permeability.FromHenriesPerMeter(5));
         }
 
         [Fact]
@@ -470,7 +530,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, PermeabilityUnit.HenryPerMeter, 1, PermeabilityUnit.HenryPerMeter, true)]  // Same value and unit.
         [InlineData(1, PermeabilityUnit.HenryPerMeter, 2, PermeabilityUnit.HenryPerMeter, false)] // Different value.
-        [InlineData(2, PermeabilityUnit.HenryPerMeter, 1, PermeabilityUnit.HenryPerMeter, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, PermeabilityUnit unitA, double valueB, PermeabilityUnit unitB, bool expectEqual)
         {
             var a = new Permeability(valueA, unitA);
@@ -530,8 +589,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Permeability.FromHenriesPerMeter(firstValue);
             var otherQuantity = Permeability.FromHenriesPerMeter(secondValue);
             Permeability maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Permeability.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -550,7 +609,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<PermeabilityUnit>();
+            var units = EnumHelper.GetValues<PermeabilityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -564,39 +623,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 H/m", new Permeability(1, PermeabilityUnit.HenryPerMeter).ToString());
+            Assert.Equal(Permeability.Info.Units, Permeability.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 H/m", new Permeability(1, PermeabilityUnit.HenryPerMeter).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, Permeability.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 H/m", new Permeability(0.123456, PermeabilityUnit.HenryPerMeter).ToString("s1"));
-            Assert.Equal("0.12 H/m", new Permeability(0.123456, PermeabilityUnit.HenryPerMeter).ToString("s2"));
-            Assert.Equal("0.123 H/m", new Permeability(0.123456, PermeabilityUnit.HenryPerMeter).ToString("s3"));
-            Assert.Equal("0.1235 H/m", new Permeability(0.123456, PermeabilityUnit.HenryPerMeter).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 H/m", new Permeability(1, PermeabilityUnit.HenryPerMeter).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 H/m", new Permeability(0.123456, PermeabilityUnit.HenryPerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 H/m", new Permeability(0.123456, PermeabilityUnit.HenryPerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 H/m", new Permeability(0.123456, PermeabilityUnit.HenryPerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 H/m", new Permeability(0.123456, PermeabilityUnit.HenryPerMeter).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 H/m", new Permeability(1, PermeabilityUnit.HenryPerMeter).ToString(swedishCulture));
         }
 
         [Theory]
@@ -625,7 +676,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Permeability.FromHenriesPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Permeability), quantity.As(Permeability.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PermittivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PermittivityTestsBase.g.cs
index f2dc863436..fc162ba9a4 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PermittivityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PermittivityTestsBase.g.cs
@@ -125,6 +125,20 @@ public void Permittivity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<PermittivityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void PermittivityInfo_CreateWithCustomUnitInfos()
+        {
+            PermittivityUnit[] expectedUnits = [PermittivityUnit.FaradPerMeter];
+
+            Permittivity.PermittivityInfo quantityInfo = Permittivity.PermittivityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Permittivity", quantityInfo.Name);
+            Assert.Equal(Permittivity.Zero, quantityInfo.Zero);
+            Assert.Equal(Permittivity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void FaradPerMeterToPermittivityUnits()
         {
@@ -209,31 +223,74 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Permittivity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Permittivity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Permittivity quantityToConvert = quantity;
+
+                Permittivity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<PermittivityUnit> quantityToConvert = quantity;
+
+                IQuantity<PermittivityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Permittivity(value: 1, unit: Permittivity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Permittivity(value: 1, unit: Permittivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<PermittivityUnit> quantity = new Permittivity(value: 1, unit: Permittivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Permittivity(value: 1, unit: Permittivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Permittivity(value: 1, unit: Permittivity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Permittivity(value: 1, unit: Permittivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<PermittivityUnit> quantity = new Permittivity(value: 1, unit: Permittivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Permittivity(value: 1, unit: Permittivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 F/m", PermittivityUnit.FaradPerMeter, 4.2)]
-        public void Parse(string culture, string quantityString, PermittivityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, PermittivityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Permittivity.Parse(quantityString);
@@ -243,7 +300,7 @@ public void Parse(string culture, string quantityString, PermittivityUnit expect
 
         [Theory]
         [InlineData("en-US", "4.2 F/m", PermittivityUnit.FaradPerMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, PermittivityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, PermittivityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Permittivity.TryParse(quantityString, out Permittivity parsed));
@@ -376,6 +433,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(PermittivityUnit
                 var quantity = Permittivity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -399,32 +457,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(PermittivityUnit un
                 IQuantity<PermittivityUnit> quantityToConvert = quantity;
                 IQuantity<PermittivityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Permittivity faradpermeter = Permittivity.FromFaradsPerMeter(1);
-            AssertEx.EqualTolerance(1, Permittivity.FromFaradsPerMeter(faradpermeter.FaradsPerMeter).FaradsPerMeter, FaradsPerMeterTolerance);
+            Permittivity faradpermeter = Permittivity.FromFaradsPerMeter(3);
+            Assert.Equal(3, Permittivity.FromFaradsPerMeter(faradpermeter.FaradsPerMeter).FaradsPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Permittivity v = Permittivity.FromFaradsPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.FaradsPerMeter, FaradsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Permittivity.FromFaradsPerMeter(3)-v).FaradsPerMeter, FaradsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).FaradsPerMeter, FaradsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).FaradsPerMeter, FaradsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).FaradsPerMeter, FaradsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (Permittivity.FromFaradsPerMeter(10)/5).FaradsPerMeter, FaradsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, Permittivity.FromFaradsPerMeter(10)/Permittivity.FromFaradsPerMeter(5), FaradsPerMeterTolerance);
+            Assert.Equal(-1, -v.FaradsPerMeter);
+            Assert.Equal(2, (Permittivity.FromFaradsPerMeter(3) - v).FaradsPerMeter);
+            Assert.Equal(2, (v + v).FaradsPerMeter);
+            Assert.Equal(10, (v * 10).FaradsPerMeter);
+            Assert.Equal(10, (10 * v).FaradsPerMeter);
+            Assert.Equal(2, (Permittivity.FromFaradsPerMeter(10) / 5).FaradsPerMeter);
+            Assert.Equal(2, Permittivity.FromFaradsPerMeter(10) / Permittivity.FromFaradsPerMeter(5));
         }
 
         [Fact]
@@ -470,7 +530,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, PermittivityUnit.FaradPerMeter, 1, PermittivityUnit.FaradPerMeter, true)]  // Same value and unit.
         [InlineData(1, PermittivityUnit.FaradPerMeter, 2, PermittivityUnit.FaradPerMeter, false)] // Different value.
-        [InlineData(2, PermittivityUnit.FaradPerMeter, 1, PermittivityUnit.FaradPerMeter, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, PermittivityUnit unitA, double valueB, PermittivityUnit unitB, bool expectEqual)
         {
             var a = new Permittivity(valueA, unitA);
@@ -530,8 +589,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Permittivity.FromFaradsPerMeter(firstValue);
             var otherQuantity = Permittivity.FromFaradsPerMeter(secondValue);
             Permittivity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Permittivity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -550,7 +609,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<PermittivityUnit>();
+            var units = EnumHelper.GetValues<PermittivityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -564,39 +623,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 F/m", new Permittivity(1, PermittivityUnit.FaradPerMeter).ToString());
+            Assert.Equal(Permittivity.Info.Units, Permittivity.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 F/m", new Permittivity(1, PermittivityUnit.FaradPerMeter).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, Permittivity.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 F/m", new Permittivity(0.123456, PermittivityUnit.FaradPerMeter).ToString("s1"));
-            Assert.Equal("0.12 F/m", new Permittivity(0.123456, PermittivityUnit.FaradPerMeter).ToString("s2"));
-            Assert.Equal("0.123 F/m", new Permittivity(0.123456, PermittivityUnit.FaradPerMeter).ToString("s3"));
-            Assert.Equal("0.1235 F/m", new Permittivity(0.123456, PermittivityUnit.FaradPerMeter).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 F/m", new Permittivity(1, PermittivityUnit.FaradPerMeter).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 F/m", new Permittivity(0.123456, PermittivityUnit.FaradPerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 F/m", new Permittivity(0.123456, PermittivityUnit.FaradPerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 F/m", new Permittivity(0.123456, PermittivityUnit.FaradPerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 F/m", new Permittivity(0.123456, PermittivityUnit.FaradPerMeter).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 F/m", new Permittivity(1, PermittivityUnit.FaradPerMeter).ToString(swedishCulture));
         }
 
         [Theory]
@@ -625,7 +676,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Permittivity.FromFaradsPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Permittivity), quantity.As(Permittivity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PorousMediumPermeabilityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PorousMediumPermeabilityTestsBase.g.cs
index 734b29d9f6..8914cbb07a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PorousMediumPermeabilityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PorousMediumPermeabilityTestsBase.g.cs
@@ -141,6 +141,20 @@ public void PorousMediumPermeability_QuantityInfo_ReturnsQuantityInfoDescribingQ
             Assert.Equal(quantityInfo, ((IQuantity<PorousMediumPermeabilityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void PorousMediumPermeabilityInfo_CreateWithCustomUnitInfos()
+        {
+            PorousMediumPermeabilityUnit[] expectedUnits = [PorousMediumPermeabilityUnit.SquareMeter];
+
+            PorousMediumPermeability.PorousMediumPermeabilityInfo quantityInfo = PorousMediumPermeability.PorousMediumPermeabilityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("PorousMediumPermeability", quantityInfo.Name);
+            Assert.Equal(PorousMediumPermeability.Zero, quantityInfo.Zero);
+            Assert.Equal(PorousMediumPermeability.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SquareMeterToPorousMediumPermeabilityUnits()
         {
@@ -233,26 +247,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = PorousMediumPermeability.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            PorousMediumPermeability convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                PorousMediumPermeability quantityToConvert = quantity;
+
+                PorousMediumPermeability convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<PorousMediumPermeabilityUnit> quantityToConvert = quantity;
+
+                IQuantity<PorousMediumPermeabilityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new PorousMediumPermeability(value: 1, unit: PorousMediumPermeability.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new PorousMediumPermeability(value: 1, unit: PorousMediumPermeability.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<PorousMediumPermeabilityUnit> quantity = new PorousMediumPermeability(value: 1, unit: PorousMediumPermeability.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new PorousMediumPermeability(value: 1, unit: PorousMediumPermeability.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new PorousMediumPermeability(value: 1, unit: PorousMediumPermeability.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new PorousMediumPermeability(value: 1, unit: PorousMediumPermeability.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<PorousMediumPermeabilityUnit> quantity = new PorousMediumPermeability(value: 1, unit: PorousMediumPermeability.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new PorousMediumPermeability(value: 1, unit: PorousMediumPermeability.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -261,7 +318,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mD", PorousMediumPermeabilityUnit.Millidarcy, 4.2)]
         [InlineData("en-US", "4.2 cm²", PorousMediumPermeabilityUnit.SquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 m²", PorousMediumPermeabilityUnit.SquareMeter, 4.2)]
-        public void Parse(string culture, string quantityString, PorousMediumPermeabilityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, PorousMediumPermeabilityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = PorousMediumPermeability.Parse(quantityString);
@@ -275,7 +332,7 @@ public void Parse(string culture, string quantityString, PorousMediumPermeabilit
         [InlineData("en-US", "4.2 mD", PorousMediumPermeabilityUnit.Millidarcy, 4.2)]
         [InlineData("en-US", "4.2 cm²", PorousMediumPermeabilityUnit.SquareCentimeter, 4.2)]
         [InlineData("en-US", "4.2 m²", PorousMediumPermeabilityUnit.SquareMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, PorousMediumPermeabilityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, PorousMediumPermeabilityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(PorousMediumPermeability.TryParse(quantityString, out PorousMediumPermeability parsed));
@@ -444,6 +501,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(PorousMediumPerm
                 var quantity = PorousMediumPermeability.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -467,36 +525,38 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(PorousMediumPermeab
                 IQuantity<PorousMediumPermeabilityUnit> quantityToConvert = quantity;
                 IQuantity<PorousMediumPermeabilityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            PorousMediumPermeability squaremeter = PorousMediumPermeability.FromSquareMeters(1);
-            AssertEx.EqualTolerance(1, PorousMediumPermeability.FromDarcys(squaremeter.Darcys).SquareMeters, DarcysTolerance);
-            AssertEx.EqualTolerance(1, PorousMediumPermeability.FromMicrodarcys(squaremeter.Microdarcys).SquareMeters, MicrodarcysTolerance);
-            AssertEx.EqualTolerance(1, PorousMediumPermeability.FromMillidarcys(squaremeter.Millidarcys).SquareMeters, MillidarcysTolerance);
-            AssertEx.EqualTolerance(1, PorousMediumPermeability.FromSquareCentimeters(squaremeter.SquareCentimeters).SquareMeters, SquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, PorousMediumPermeability.FromSquareMeters(squaremeter.SquareMeters).SquareMeters, SquareMetersTolerance);
+            PorousMediumPermeability squaremeter = PorousMediumPermeability.FromSquareMeters(3);
+            Assert.Equal(3, PorousMediumPermeability.FromDarcys(squaremeter.Darcys).SquareMeters);
+            Assert.Equal(3, PorousMediumPermeability.FromMicrodarcys(squaremeter.Microdarcys).SquareMeters);
+            Assert.Equal(3, PorousMediumPermeability.FromMillidarcys(squaremeter.Millidarcys).SquareMeters);
+            Assert.Equal(3, PorousMediumPermeability.FromSquareCentimeters(squaremeter.SquareCentimeters).SquareMeters);
+            Assert.Equal(3, PorousMediumPermeability.FromSquareMeters(squaremeter.SquareMeters).SquareMeters);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             PorousMediumPermeability v = PorousMediumPermeability.FromSquareMeters(1);
-            AssertEx.EqualTolerance(-1, -v.SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (PorousMediumPermeability.FromSquareMeters(3)-v).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (PorousMediumPermeability.FromSquareMeters(10)/5).SquareMeters, SquareMetersTolerance);
-            AssertEx.EqualTolerance(2, PorousMediumPermeability.FromSquareMeters(10)/PorousMediumPermeability.FromSquareMeters(5), SquareMetersTolerance);
+            Assert.Equal(-1, -v.SquareMeters);
+            Assert.Equal(2, (PorousMediumPermeability.FromSquareMeters(3) - v).SquareMeters);
+            Assert.Equal(2, (v + v).SquareMeters);
+            Assert.Equal(10, (v * 10).SquareMeters);
+            Assert.Equal(10, (10 * v).SquareMeters);
+            Assert.Equal(2, (PorousMediumPermeability.FromSquareMeters(10) / 5).SquareMeters);
+            Assert.Equal(2, PorousMediumPermeability.FromSquareMeters(10) / PorousMediumPermeability.FromSquareMeters(5));
         }
 
         [Fact]
@@ -542,8 +602,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, PorousMediumPermeabilityUnit.SquareMeter, 1, PorousMediumPermeabilityUnit.SquareMeter, true)]  // Same value and unit.
         [InlineData(1, PorousMediumPermeabilityUnit.SquareMeter, 2, PorousMediumPermeabilityUnit.SquareMeter, false)] // Different value.
-        [InlineData(2, PorousMediumPermeabilityUnit.SquareMeter, 1, PorousMediumPermeabilityUnit.Darcy, false)] // Different value and unit.
-        [InlineData(1, PorousMediumPermeabilityUnit.SquareMeter, 1, PorousMediumPermeabilityUnit.Darcy, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, PorousMediumPermeabilityUnit unitA, double valueB, PorousMediumPermeabilityUnit unitB, bool expectEqual)
         {
             var a = new PorousMediumPermeability(valueA, unitA);
@@ -603,8 +661,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = PorousMediumPermeability.FromSquareMeters(firstValue);
             var otherQuantity = PorousMediumPermeability.FromSquareMeters(secondValue);
             PorousMediumPermeability maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, PorousMediumPermeability.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -623,7 +681,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<PorousMediumPermeabilityUnit>();
+            var units = EnumHelper.GetValues<PorousMediumPermeabilityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -636,6 +694,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(PorousMediumPermeability.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(PorousMediumPermeability.Info.Units, PorousMediumPermeability.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, PorousMediumPermeability.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -660,26 +730,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 m²", new PorousMediumPermeability(1, PorousMediumPermeabilityUnit.SquareMeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m²", new PorousMediumPermeability(0.123456, PorousMediumPermeabilityUnit.SquareMeter).ToString("s1"));
-            Assert.Equal("0.12 m²", new PorousMediumPermeability(0.123456, PorousMediumPermeabilityUnit.SquareMeter).ToString("s2"));
-            Assert.Equal("0.123 m²", new PorousMediumPermeability(0.123456, PorousMediumPermeabilityUnit.SquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 m²", new PorousMediumPermeability(0.123456, PorousMediumPermeabilityUnit.SquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m²", new PorousMediumPermeability(0.123456, PorousMediumPermeabilityUnit.SquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 m²", new PorousMediumPermeability(0.123456, PorousMediumPermeabilityUnit.SquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 m²", new PorousMediumPermeability(0.123456, PorousMediumPermeabilityUnit.SquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 m²", new PorousMediumPermeability(0.123456, PorousMediumPermeabilityUnit.SquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -706,7 +756,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = PorousMediumPermeability.FromSquareMeters(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(PorousMediumPermeability), quantity.As(PorousMediumPermeability.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerDensityTestsBase.g.cs
index b9bd40cd73..db99a2a2be 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerDensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerDensityTestsBase.g.cs
@@ -40,6 +40,8 @@ namespace UnitsNet.Tests
 // ReSharper disable once PartialTypeWithSinglePart
     public abstract partial class PowerDensityTestsBase : QuantityTestsBase
     {
+        protected abstract double BtusPerSecondCubicFootInOneWattPerCubicMeter { get; }
+        protected abstract double BtusPerSecondCubicInchInOneWattPerCubicMeter { get; }
         protected abstract double DecawattsPerCubicFootInOneWattPerCubicMeter { get; }
         protected abstract double DecawattsPerCubicInchInOneWattPerCubicMeter { get; }
         protected abstract double DecawattsPerCubicMeterInOneWattPerCubicMeter { get; }
@@ -86,6 +88,8 @@ public abstract partial class PowerDensityTestsBase : QuantityTestsBase
         protected abstract double WattsPerLiterInOneWattPerCubicMeter { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double BtusPerSecondCubicFootTolerance { get { return 1e-5; } }
+        protected virtual double BtusPerSecondCubicInchTolerance { get { return 1e-5; } }
         protected virtual double DecawattsPerCubicFootTolerance { get { return 1e-5; } }
         protected virtual double DecawattsPerCubicInchTolerance { get { return 1e-5; } }
         protected virtual double DecawattsPerCubicMeterTolerance { get { return 1e-5; } }
@@ -136,6 +140,8 @@ public abstract partial class PowerDensityTestsBase : QuantityTestsBase
         {
             return unit switch
             {
+                PowerDensityUnit.BtuPerSecondCubicFoot => (BtusPerSecondCubicFootInOneWattPerCubicMeter, BtusPerSecondCubicFootTolerance),
+                PowerDensityUnit.BtuPerSecondCubicInch => (BtusPerSecondCubicInchInOneWattPerCubicMeter, BtusPerSecondCubicInchTolerance),
                 PowerDensityUnit.DecawattPerCubicFoot => (DecawattsPerCubicFootInOneWattPerCubicMeter, DecawattsPerCubicFootTolerance),
                 PowerDensityUnit.DecawattPerCubicInch => (DecawattsPerCubicInchInOneWattPerCubicMeter, DecawattsPerCubicInchTolerance),
                 PowerDensityUnit.DecawattPerCubicMeter => (DecawattsPerCubicMeterInOneWattPerCubicMeter, DecawattsPerCubicMeterTolerance),
@@ -186,6 +192,8 @@ public abstract partial class PowerDensityTestsBase : QuantityTestsBase
 
         public static IEnumerable<object[]> UnitTypes = new List<object[]>
         {
+            new object[] { PowerDensityUnit.BtuPerSecondCubicFoot },
+            new object[] { PowerDensityUnit.BtuPerSecondCubicInch },
             new object[] { PowerDensityUnit.DecawattPerCubicFoot },
             new object[] { PowerDensityUnit.DecawattPerCubicInch },
             new object[] { PowerDensityUnit.DecawattPerCubicMeter },
@@ -297,10 +305,26 @@ public void PowerDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<PowerDensityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void PowerDensityInfo_CreateWithCustomUnitInfos()
+        {
+            PowerDensityUnit[] expectedUnits = [PowerDensityUnit.WattPerCubicMeter];
+
+            PowerDensity.PowerDensityInfo quantityInfo = PowerDensity.PowerDensityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("PowerDensity", quantityInfo.Name);
+            Assert.Equal(PowerDensity.Zero, quantityInfo.Zero);
+            Assert.Equal(PowerDensity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void WattPerCubicMeterToPowerDensityUnits()
         {
             PowerDensity wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
+            AssertEx.EqualTolerance(BtusPerSecondCubicFootInOneWattPerCubicMeter, wattpercubicmeter.BtusPerSecondCubicFoot, BtusPerSecondCubicFootTolerance);
+            AssertEx.EqualTolerance(BtusPerSecondCubicInchInOneWattPerCubicMeter, wattpercubicmeter.BtusPerSecondCubicInch, BtusPerSecondCubicInchTolerance);
             AssertEx.EqualTolerance(DecawattsPerCubicFootInOneWattPerCubicMeter, wattpercubicmeter.DecawattsPerCubicFoot, DecawattsPerCubicFootTolerance);
             AssertEx.EqualTolerance(DecawattsPerCubicInchInOneWattPerCubicMeter, wattpercubicmeter.DecawattsPerCubicInch, DecawattsPerCubicInchTolerance);
             AssertEx.EqualTolerance(DecawattsPerCubicMeterInOneWattPerCubicMeter, wattpercubicmeter.DecawattsPerCubicMeter, DecawattsPerCubicMeterTolerance);
@@ -380,6 +404,8 @@ public void FromWattsPerCubicMeter_WithNanValue_DoNotThrowsArgumentException()
         public void As()
         {
             var wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
+            AssertEx.EqualTolerance(BtusPerSecondCubicFootInOneWattPerCubicMeter, wattpercubicmeter.As(PowerDensityUnit.BtuPerSecondCubicFoot), BtusPerSecondCubicFootTolerance);
+            AssertEx.EqualTolerance(BtusPerSecondCubicInchInOneWattPerCubicMeter, wattpercubicmeter.As(PowerDensityUnit.BtuPerSecondCubicInch), BtusPerSecondCubicInchTolerance);
             AssertEx.EqualTolerance(DecawattsPerCubicFootInOneWattPerCubicMeter, wattpercubicmeter.As(PowerDensityUnit.DecawattPerCubicFoot), DecawattsPerCubicFootTolerance);
             AssertEx.EqualTolerance(DecawattsPerCubicInchInOneWattPerCubicMeter, wattpercubicmeter.As(PowerDensityUnit.DecawattPerCubicInch), DecawattsPerCubicInchTolerance);
             AssertEx.EqualTolerance(DecawattsPerCubicMeterInOneWattPerCubicMeter, wattpercubicmeter.As(PowerDensityUnit.DecawattPerCubicMeter), DecawattsPerCubicMeterTolerance);
@@ -467,29 +493,74 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = PowerDensity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            PowerDensity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                PowerDensity quantityToConvert = quantity;
+
+                PowerDensity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<PowerDensityUnit> quantityToConvert = quantity;
+
+                IQuantity<PowerDensityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new PowerDensity(value: 1, unit: PowerDensity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new PowerDensity(value: 1, unit: PowerDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<PowerDensityUnit> quantity = new PowerDensity(value: 1, unit: PowerDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new PowerDensity(value: 1, unit: PowerDensity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new PowerDensity(value: 1, unit: PowerDensity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new PowerDensity(value: 1, unit: PowerDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<PowerDensityUnit> quantity = new PowerDensity(value: 1, unit: PowerDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new PowerDensity(value: 1, unit: PowerDensity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
+        [InlineData("en-US", "4.2 BTU/(s·ft³)", PowerDensityUnit.BtuPerSecondCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 BTU/(s·in³)", PowerDensityUnit.BtuPerSecondCubicInch, 4.2)]
         [InlineData("en-US", "4.2 daW/ft³", PowerDensityUnit.DecawattPerCubicFoot, 4.2)]
         [InlineData("en-US", "4.2 daW/in³", PowerDensityUnit.DecawattPerCubicInch, 4.2)]
         [InlineData("en-US", "4.2 daW/m³", PowerDensityUnit.DecawattPerCubicMeter, 4.2)]
@@ -534,7 +605,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 W/in³", PowerDensityUnit.WattPerCubicInch, 4.2)]
         [InlineData("en-US", "4.2 W/m³", PowerDensityUnit.WattPerCubicMeter, 4.2)]
         [InlineData("en-US", "4.2 W/l", PowerDensityUnit.WattPerLiter, 4.2)]
-        public void Parse(string culture, string quantityString, PowerDensityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, PowerDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = PowerDensity.Parse(quantityString);
@@ -543,6 +614,8 @@ public void Parse(string culture, string quantityString, PowerDensityUnit expect
         }
 
         [Theory]
+        [InlineData("en-US", "4.2 BTU/(s·ft³)", PowerDensityUnit.BtuPerSecondCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 BTU/(s·in³)", PowerDensityUnit.BtuPerSecondCubicInch, 4.2)]
         [InlineData("en-US", "4.2 daW/ft³", PowerDensityUnit.DecawattPerCubicFoot, 4.2)]
         [InlineData("en-US", "4.2 daW/in³", PowerDensityUnit.DecawattPerCubicInch, 4.2)]
         [InlineData("en-US", "4.2 daW/m³", PowerDensityUnit.DecawattPerCubicMeter, 4.2)]
@@ -587,7 +660,7 @@ public void Parse(string culture, string quantityString, PowerDensityUnit expect
         [InlineData("en-US", "4.2 W/in³", PowerDensityUnit.WattPerCubicInch, 4.2)]
         [InlineData("en-US", "4.2 W/m³", PowerDensityUnit.WattPerCubicMeter, 4.2)]
         [InlineData("en-US", "4.2 W/l", PowerDensityUnit.WattPerLiter, 4.2)]
-        public void TryParse(string culture, string quantityString, PowerDensityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, PowerDensityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(PowerDensity.TryParse(quantityString, out PowerDensity parsed));
@@ -596,6 +669,8 @@ public void TryParse(string culture, string quantityString, PowerDensityUnit exp
         }
 
         [Theory]
+        [InlineData("BTU/(s·ft³)", PowerDensityUnit.BtuPerSecondCubicFoot)]
+        [InlineData("BTU/(s·in³)", PowerDensityUnit.BtuPerSecondCubicInch)]
         [InlineData("daW/ft³", PowerDensityUnit.DecawattPerCubicFoot)]
         [InlineData("daW/in³", PowerDensityUnit.DecawattPerCubicInch)]
         [InlineData("daW/m³", PowerDensityUnit.DecawattPerCubicMeter)]
@@ -649,6 +724,8 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, PowerDens
         }
 
         [Theory]
+        [InlineData("BTU/(s·ft³)", PowerDensityUnit.BtuPerSecondCubicFoot)]
+        [InlineData("BTU/(s·in³)", PowerDensityUnit.BtuPerSecondCubicInch)]
         [InlineData("daW/ft³", PowerDensityUnit.DecawattPerCubicFoot)]
         [InlineData("daW/in³", PowerDensityUnit.DecawattPerCubicInch)]
         [InlineData("daW/m³", PowerDensityUnit.DecawattPerCubicMeter)]
@@ -702,6 +779,8 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         }
 
         [Theory]
+        [InlineData("en-US", "BTU/(s·ft³)", PowerDensityUnit.BtuPerSecondCubicFoot)]
+        [InlineData("en-US", "BTU/(s·in³)", PowerDensityUnit.BtuPerSecondCubicInch)]
         [InlineData("en-US", "daW/ft³", PowerDensityUnit.DecawattPerCubicFoot)]
         [InlineData("en-US", "daW/in³", PowerDensityUnit.DecawattPerCubicInch)]
         [InlineData("en-US", "daW/m³", PowerDensityUnit.DecawattPerCubicMeter)]
@@ -754,6 +833,8 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Po
         }
 
         [Theory]
+        [InlineData("en-US", "BTU/(s·ft³)", PowerDensityUnit.BtuPerSecondCubicFoot)]
+        [InlineData("en-US", "BTU/(s·in³)", PowerDensityUnit.BtuPerSecondCubicInch)]
         [InlineData("en-US", "daW/ft³", PowerDensityUnit.DecawattPerCubicFoot)]
         [InlineData("en-US", "daW/in³", PowerDensityUnit.DecawattPerCubicInch)]
         [InlineData("en-US", "daW/m³", PowerDensityUnit.DecawattPerCubicMeter)]
@@ -805,6 +886,8 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, PowerDens
         }
 
         [Theory]
+        [InlineData("BTU/(s·ft³)", PowerDensityUnit.BtuPerSecondCubicFoot)]
+        [InlineData("BTU/(s·in³)", PowerDensityUnit.BtuPerSecondCubicInch)]
         [InlineData("daW/ft³", PowerDensityUnit.DecawattPerCubicFoot)]
         [InlineData("daW/in³", PowerDensityUnit.DecawattPerCubicInch)]
         [InlineData("daW/m³", PowerDensityUnit.DecawattPerCubicMeter)]
@@ -858,6 +941,8 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, PowerD
         }
 
         [Theory]
+        [InlineData("BTU/(s·ft³)", PowerDensityUnit.BtuPerSecondCubicFoot)]
+        [InlineData("BTU/(s·in³)", PowerDensityUnit.BtuPerSecondCubicInch)]
         [InlineData("daW/ft³", PowerDensityUnit.DecawattPerCubicFoot)]
         [InlineData("daW/in³", PowerDensityUnit.DecawattPerCubicInch)]
         [InlineData("daW/m³", PowerDensityUnit.DecawattPerCubicMeter)]
@@ -911,6 +996,8 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         }
 
         [Theory]
+        [InlineData("en-US", "BTU/(s·ft³)", PowerDensityUnit.BtuPerSecondCubicFoot)]
+        [InlineData("en-US", "BTU/(s·in³)", PowerDensityUnit.BtuPerSecondCubicInch)]
         [InlineData("en-US", "daW/ft³", PowerDensityUnit.DecawattPerCubicFoot)]
         [InlineData("en-US", "daW/in³", PowerDensityUnit.DecawattPerCubicInch)]
         [InlineData("en-US", "daW/m³", PowerDensityUnit.DecawattPerCubicMeter)]
@@ -963,6 +1050,8 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         }
 
         [Theory]
+        [InlineData("en-US", "BTU/(s·ft³)", PowerDensityUnit.BtuPerSecondCubicFoot)]
+        [InlineData("en-US", "BTU/(s·in³)", PowerDensityUnit.BtuPerSecondCubicInch)]
         [InlineData("en-US", "daW/ft³", PowerDensityUnit.DecawattPerCubicFoot)]
         [InlineData("en-US", "daW/in³", PowerDensityUnit.DecawattPerCubicInch)]
         [InlineData("en-US", "daW/m³", PowerDensityUnit.DecawattPerCubicMeter)]
@@ -1014,6 +1103,8 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, PowerD
         }
 
         [Theory]
+        [InlineData("en-US", PowerDensityUnit.BtuPerSecondCubicFoot, "BTU/(s·ft³)")]
+        [InlineData("en-US", PowerDensityUnit.BtuPerSecondCubicInch, "BTU/(s·in³)")]
         [InlineData("en-US", PowerDensityUnit.DecawattPerCubicFoot, "daW/ft³")]
         [InlineData("en-US", PowerDensityUnit.DecawattPerCubicInch, "daW/in³")]
         [InlineData("en-US", PowerDensityUnit.DecawattPerCubicMeter, "daW/m³")]
@@ -1107,6 +1198,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(PowerDensityUnit
                 var quantity = PowerDensity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1130,75 +1222,79 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(PowerDensityUnit un
                 IQuantity<PowerDensityUnit> quantityToConvert = quantity;
                 IQuantity<PowerDensityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            PowerDensity wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDecawattsPerCubicFoot(wattpercubicmeter.DecawattsPerCubicFoot).WattsPerCubicMeter, DecawattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDecawattsPerCubicInch(wattpercubicmeter.DecawattsPerCubicInch).WattsPerCubicMeter, DecawattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDecawattsPerCubicMeter(wattpercubicmeter.DecawattsPerCubicMeter).WattsPerCubicMeter, DecawattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDecawattsPerLiter(wattpercubicmeter.DecawattsPerLiter).WattsPerCubicMeter, DecawattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDeciwattsPerCubicFoot(wattpercubicmeter.DeciwattsPerCubicFoot).WattsPerCubicMeter, DeciwattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDeciwattsPerCubicInch(wattpercubicmeter.DeciwattsPerCubicInch).WattsPerCubicMeter, DeciwattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDeciwattsPerCubicMeter(wattpercubicmeter.DeciwattsPerCubicMeter).WattsPerCubicMeter, DeciwattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromDeciwattsPerLiter(wattpercubicmeter.DeciwattsPerLiter).WattsPerCubicMeter, DeciwattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromGigawattsPerCubicFoot(wattpercubicmeter.GigawattsPerCubicFoot).WattsPerCubicMeter, GigawattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromGigawattsPerCubicInch(wattpercubicmeter.GigawattsPerCubicInch).WattsPerCubicMeter, GigawattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromGigawattsPerCubicMeter(wattpercubicmeter.GigawattsPerCubicMeter).WattsPerCubicMeter, GigawattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromGigawattsPerLiter(wattpercubicmeter.GigawattsPerLiter).WattsPerCubicMeter, GigawattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromKilowattsPerCubicFoot(wattpercubicmeter.KilowattsPerCubicFoot).WattsPerCubicMeter, KilowattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromKilowattsPerCubicInch(wattpercubicmeter.KilowattsPerCubicInch).WattsPerCubicMeter, KilowattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromKilowattsPerCubicMeter(wattpercubicmeter.KilowattsPerCubicMeter).WattsPerCubicMeter, KilowattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromKilowattsPerLiter(wattpercubicmeter.KilowattsPerLiter).WattsPerCubicMeter, KilowattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMegawattsPerCubicFoot(wattpercubicmeter.MegawattsPerCubicFoot).WattsPerCubicMeter, MegawattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMegawattsPerCubicInch(wattpercubicmeter.MegawattsPerCubicInch).WattsPerCubicMeter, MegawattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMegawattsPerCubicMeter(wattpercubicmeter.MegawattsPerCubicMeter).WattsPerCubicMeter, MegawattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMegawattsPerLiter(wattpercubicmeter.MegawattsPerLiter).WattsPerCubicMeter, MegawattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMicrowattsPerCubicFoot(wattpercubicmeter.MicrowattsPerCubicFoot).WattsPerCubicMeter, MicrowattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMicrowattsPerCubicInch(wattpercubicmeter.MicrowattsPerCubicInch).WattsPerCubicMeter, MicrowattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMicrowattsPerCubicMeter(wattpercubicmeter.MicrowattsPerCubicMeter).WattsPerCubicMeter, MicrowattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMicrowattsPerLiter(wattpercubicmeter.MicrowattsPerLiter).WattsPerCubicMeter, MicrowattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMilliwattsPerCubicFoot(wattpercubicmeter.MilliwattsPerCubicFoot).WattsPerCubicMeter, MilliwattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMilliwattsPerCubicInch(wattpercubicmeter.MilliwattsPerCubicInch).WattsPerCubicMeter, MilliwattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMilliwattsPerCubicMeter(wattpercubicmeter.MilliwattsPerCubicMeter).WattsPerCubicMeter, MilliwattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromMilliwattsPerLiter(wattpercubicmeter.MilliwattsPerLiter).WattsPerCubicMeter, MilliwattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromNanowattsPerCubicFoot(wattpercubicmeter.NanowattsPerCubicFoot).WattsPerCubicMeter, NanowattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromNanowattsPerCubicInch(wattpercubicmeter.NanowattsPerCubicInch).WattsPerCubicMeter, NanowattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromNanowattsPerCubicMeter(wattpercubicmeter.NanowattsPerCubicMeter).WattsPerCubicMeter, NanowattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromNanowattsPerLiter(wattpercubicmeter.NanowattsPerLiter).WattsPerCubicMeter, NanowattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromPicowattsPerCubicFoot(wattpercubicmeter.PicowattsPerCubicFoot).WattsPerCubicMeter, PicowattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromPicowattsPerCubicInch(wattpercubicmeter.PicowattsPerCubicInch).WattsPerCubicMeter, PicowattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromPicowattsPerCubicMeter(wattpercubicmeter.PicowattsPerCubicMeter).WattsPerCubicMeter, PicowattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromPicowattsPerLiter(wattpercubicmeter.PicowattsPerLiter).WattsPerCubicMeter, PicowattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromTerawattsPerCubicFoot(wattpercubicmeter.TerawattsPerCubicFoot).WattsPerCubicMeter, TerawattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromTerawattsPerCubicInch(wattpercubicmeter.TerawattsPerCubicInch).WattsPerCubicMeter, TerawattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromTerawattsPerCubicMeter(wattpercubicmeter.TerawattsPerCubicMeter).WattsPerCubicMeter, TerawattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromTerawattsPerLiter(wattpercubicmeter.TerawattsPerLiter).WattsPerCubicMeter, TerawattsPerLiterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromWattsPerCubicFoot(wattpercubicmeter.WattsPerCubicFoot).WattsPerCubicMeter, WattsPerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromWattsPerCubicInch(wattpercubicmeter.WattsPerCubicInch).WattsPerCubicMeter, WattsPerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromWattsPerCubicMeter(wattpercubicmeter.WattsPerCubicMeter).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, PowerDensity.FromWattsPerLiter(wattpercubicmeter.WattsPerLiter).WattsPerCubicMeter, WattsPerLiterTolerance);
+            PowerDensity wattpercubicmeter = PowerDensity.FromWattsPerCubicMeter(3);
+            Assert.Equal(3, PowerDensity.FromBtusPerSecondCubicFoot(wattpercubicmeter.BtusPerSecondCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromBtusPerSecondCubicInch(wattpercubicmeter.BtusPerSecondCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromDecawattsPerCubicFoot(wattpercubicmeter.DecawattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromDecawattsPerCubicInch(wattpercubicmeter.DecawattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromDecawattsPerCubicMeter(wattpercubicmeter.DecawattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromDecawattsPerLiter(wattpercubicmeter.DecawattsPerLiter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromDeciwattsPerCubicFoot(wattpercubicmeter.DeciwattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromDeciwattsPerCubicInch(wattpercubicmeter.DeciwattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromDeciwattsPerCubicMeter(wattpercubicmeter.DeciwattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromDeciwattsPerLiter(wattpercubicmeter.DeciwattsPerLiter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromGigawattsPerCubicFoot(wattpercubicmeter.GigawattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromGigawattsPerCubicInch(wattpercubicmeter.GigawattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromGigawattsPerCubicMeter(wattpercubicmeter.GigawattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromGigawattsPerLiter(wattpercubicmeter.GigawattsPerLiter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromKilowattsPerCubicFoot(wattpercubicmeter.KilowattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromKilowattsPerCubicInch(wattpercubicmeter.KilowattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromKilowattsPerCubicMeter(wattpercubicmeter.KilowattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromKilowattsPerLiter(wattpercubicmeter.KilowattsPerLiter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMegawattsPerCubicFoot(wattpercubicmeter.MegawattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMegawattsPerCubicInch(wattpercubicmeter.MegawattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMegawattsPerCubicMeter(wattpercubicmeter.MegawattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMegawattsPerLiter(wattpercubicmeter.MegawattsPerLiter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMicrowattsPerCubicFoot(wattpercubicmeter.MicrowattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMicrowattsPerCubicInch(wattpercubicmeter.MicrowattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMicrowattsPerCubicMeter(wattpercubicmeter.MicrowattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMicrowattsPerLiter(wattpercubicmeter.MicrowattsPerLiter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMilliwattsPerCubicFoot(wattpercubicmeter.MilliwattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMilliwattsPerCubicInch(wattpercubicmeter.MilliwattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMilliwattsPerCubicMeter(wattpercubicmeter.MilliwattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromMilliwattsPerLiter(wattpercubicmeter.MilliwattsPerLiter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromNanowattsPerCubicFoot(wattpercubicmeter.NanowattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromNanowattsPerCubicInch(wattpercubicmeter.NanowattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromNanowattsPerCubicMeter(wattpercubicmeter.NanowattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromNanowattsPerLiter(wattpercubicmeter.NanowattsPerLiter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromPicowattsPerCubicFoot(wattpercubicmeter.PicowattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromPicowattsPerCubicInch(wattpercubicmeter.PicowattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromPicowattsPerCubicMeter(wattpercubicmeter.PicowattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromPicowattsPerLiter(wattpercubicmeter.PicowattsPerLiter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromTerawattsPerCubicFoot(wattpercubicmeter.TerawattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromTerawattsPerCubicInch(wattpercubicmeter.TerawattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromTerawattsPerCubicMeter(wattpercubicmeter.TerawattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromTerawattsPerLiter(wattpercubicmeter.TerawattsPerLiter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromWattsPerCubicFoot(wattpercubicmeter.WattsPerCubicFoot).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromWattsPerCubicInch(wattpercubicmeter.WattsPerCubicInch).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromWattsPerCubicMeter(wattpercubicmeter.WattsPerCubicMeter).WattsPerCubicMeter);
+            Assert.Equal(3, PowerDensity.FromWattsPerLiter(wattpercubicmeter.WattsPerLiter).WattsPerCubicMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             PowerDensity v = PowerDensity.FromWattsPerCubicMeter(1);
-            AssertEx.EqualTolerance(-1, -v.WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (PowerDensity.FromWattsPerCubicMeter(3)-v).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (PowerDensity.FromWattsPerCubicMeter(10)/5).WattsPerCubicMeter, WattsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, PowerDensity.FromWattsPerCubicMeter(10)/PowerDensity.FromWattsPerCubicMeter(5), WattsPerCubicMeterTolerance);
+            Assert.Equal(-1, -v.WattsPerCubicMeter);
+            Assert.Equal(2, (PowerDensity.FromWattsPerCubicMeter(3) - v).WattsPerCubicMeter);
+            Assert.Equal(2, (v + v).WattsPerCubicMeter);
+            Assert.Equal(10, (v * 10).WattsPerCubicMeter);
+            Assert.Equal(10, (10 * v).WattsPerCubicMeter);
+            Assert.Equal(2, (PowerDensity.FromWattsPerCubicMeter(10) / 5).WattsPerCubicMeter);
+            Assert.Equal(2, PowerDensity.FromWattsPerCubicMeter(10) / PowerDensity.FromWattsPerCubicMeter(5));
         }
 
         [Fact]
@@ -1244,8 +1340,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, PowerDensityUnit.WattPerCubicMeter, 1, PowerDensityUnit.WattPerCubicMeter, true)]  // Same value and unit.
         [InlineData(1, PowerDensityUnit.WattPerCubicMeter, 2, PowerDensityUnit.WattPerCubicMeter, false)] // Different value.
-        [InlineData(2, PowerDensityUnit.WattPerCubicMeter, 1, PowerDensityUnit.DecawattPerCubicFoot, false)] // Different value and unit.
-        [InlineData(1, PowerDensityUnit.WattPerCubicMeter, 1, PowerDensityUnit.DecawattPerCubicFoot, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, PowerDensityUnit unitA, double valueB, PowerDensityUnit unitB, bool expectEqual)
         {
             var a = new PowerDensity(valueA, unitA);
@@ -1305,8 +1399,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = PowerDensity.FromWattsPerCubicMeter(firstValue);
             var otherQuantity = PowerDensity.FromWattsPerCubicMeter(secondValue);
             PowerDensity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, PowerDensity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1325,7 +1419,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<PowerDensityUnit>();
+            var units = EnumHelper.GetValues<PowerDensityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1338,10 +1432,24 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(PowerDensity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(PowerDensity.Info.Units, PowerDensity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, PowerDensity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
             using var _ = new CultureScope("en-US");
+            Assert.Equal("1 BTU/(s·ft³)", new PowerDensity(1, PowerDensityUnit.BtuPerSecondCubicFoot).ToString());
+            Assert.Equal("1 BTU/(s·in³)", new PowerDensity(1, PowerDensityUnit.BtuPerSecondCubicInch).ToString());
             Assert.Equal("1 daW/ft³", new PowerDensity(1, PowerDensityUnit.DecawattPerCubicFoot).ToString());
             Assert.Equal("1 daW/in³", new PowerDensity(1, PowerDensityUnit.DecawattPerCubicInch).ToString());
             Assert.Equal("1 daW/m³", new PowerDensity(1, PowerDensityUnit.DecawattPerCubicMeter).ToString());
@@ -1394,6 +1502,8 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
             var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
 
+            Assert.Equal("1 BTU/(s·ft³)", new PowerDensity(1, PowerDensityUnit.BtuPerSecondCubicFoot).ToString(swedishCulture));
+            Assert.Equal("1 BTU/(s·in³)", new PowerDensity(1, PowerDensityUnit.BtuPerSecondCubicInch).ToString(swedishCulture));
             Assert.Equal("1 daW/ft³", new PowerDensity(1, PowerDensityUnit.DecawattPerCubicFoot).ToString(swedishCulture));
             Assert.Equal("1 daW/in³", new PowerDensity(1, PowerDensityUnit.DecawattPerCubicInch).ToString(swedishCulture));
             Assert.Equal("1 daW/m³", new PowerDensity(1, PowerDensityUnit.DecawattPerCubicMeter).ToString(swedishCulture));
@@ -1440,26 +1550,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 W/l", new PowerDensity(1, PowerDensityUnit.WattPerLiter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 W/m³", new PowerDensity(0.123456, PowerDensityUnit.WattPerCubicMeter).ToString("s1"));
-            Assert.Equal("0.12 W/m³", new PowerDensity(0.123456, PowerDensityUnit.WattPerCubicMeter).ToString("s2"));
-            Assert.Equal("0.123 W/m³", new PowerDensity(0.123456, PowerDensityUnit.WattPerCubicMeter).ToString("s3"));
-            Assert.Equal("0.1235 W/m³", new PowerDensity(0.123456, PowerDensityUnit.WattPerCubicMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 W/m³", new PowerDensity(0.123456, PowerDensityUnit.WattPerCubicMeter).ToString("s1", culture));
-            Assert.Equal("0.12 W/m³", new PowerDensity(0.123456, PowerDensityUnit.WattPerCubicMeter).ToString("s2", culture));
-            Assert.Equal("0.123 W/m³", new PowerDensity(0.123456, PowerDensityUnit.WattPerCubicMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 W/m³", new PowerDensity(0.123456, PowerDensityUnit.WattPerCubicMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1486,7 +1576,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = PowerDensity.FromWattsPerCubicMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(PowerDensity), quantity.As(PowerDensity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerRatioTestsBase.g.cs
index e3d5bbafb4..8a14a39f6c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerRatioTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerRatioTestsBase.g.cs
@@ -108,6 +108,20 @@ public void PowerRatio_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<PowerRatioUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void PowerRatioInfo_CreateWithCustomUnitInfos()
+        {
+            PowerRatioUnit[] expectedUnits = [PowerRatioUnit.DecibelWatt];
+
+            PowerRatio.PowerRatioInfo quantityInfo = PowerRatio.PowerRatioInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("PowerRatio", quantityInfo.Name);
+            Assert.Equal(PowerRatio.Zero, quantityInfo.Zero);
+            Assert.Equal(PowerRatio.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void DecibelWattToPowerRatioUnits()
         {
@@ -174,12 +188,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new PowerRatio(value: 1, unit: PowerRatioUnit.DecibelWatt);
+            Assert.Multiple(() =>
+            {
+                var quantity = new PowerRatio(value: 1, unit: PowerRatioUnit.DecibelWatt);
+
+                PowerRatio convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(PowerRatioUnit.DecibelWatt, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<PowerRatioUnit> quantity = new PowerRatio(value: 1, unit: PowerRatioUnit.DecibelWatt);
+
+                IQuantity<PowerRatioUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(PowerRatioUnit.DecibelWatt, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new PowerRatio(value: 1, unit: PowerRatioUnit.DecibelWatt);
 
-            PowerRatio convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(PowerRatioUnit.DecibelWatt, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(PowerRatioUnit.DecibelWatt, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -205,7 +238,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [InlineData("en-US", "4.2 dBmW", PowerRatioUnit.DecibelMilliwatt, 4.2)]
         [InlineData("en-US", "4.2 dBm", PowerRatioUnit.DecibelMilliwatt, 4.2)]
         [InlineData("en-US", "4.2 dBW", PowerRatioUnit.DecibelWatt, 4.2)]
-        public void Parse(string culture, string quantityString, PowerRatioUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, PowerRatioUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = PowerRatio.Parse(quantityString);
@@ -217,7 +250,7 @@ public void Parse(string culture, string quantityString, PowerRatioUnit expected
         [InlineData("en-US", "4.2 dBmW", PowerRatioUnit.DecibelMilliwatt, 4.2)]
         [InlineData("en-US", "4.2 dBm", PowerRatioUnit.DecibelMilliwatt, 4.2)]
         [InlineData("en-US", "4.2 dBW", PowerRatioUnit.DecibelWatt, 4.2)]
-        public void TryParse(string culture, string quantityString, PowerRatioUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, PowerRatioUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(PowerRatio.TryParse(quantityString, out PowerRatio parsed));
@@ -367,6 +400,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(PowerRatioUnit u
                 var quantity = PowerRatio.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -390,33 +424,35 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(PowerRatioUnit unit
                 IQuantity<PowerRatioUnit> quantityToConvert = quantity;
                 IQuantity<PowerRatioUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1);
-            AssertEx.EqualTolerance(1, PowerRatio.FromDecibelMilliwatts(decibelwatt.DecibelMilliwatts).DecibelWatts, DecibelMilliwattsTolerance);
-            AssertEx.EqualTolerance(1, PowerRatio.FromDecibelWatts(decibelwatt.DecibelWatts).DecibelWatts, DecibelWattsTolerance);
+            PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(3);
+            Assert.Equal(3, PowerRatio.FromDecibelMilliwatts(decibelwatt.DecibelMilliwatts).DecibelWatts);
+            Assert.Equal(3, PowerRatio.FromDecibelWatts(decibelwatt.DecibelWatts).DecibelWatts);
         }
 
         [Fact]
         public void LogarithmicArithmeticOperators()
         {
             PowerRatio v = PowerRatio.FromDecibelWatts(40);
-            AssertEx.EqualTolerance(-40, -v.DecibelWatts, DecibelWattsTolerance);
+            Assert.Equal(-40, -v.DecibelWatts);
             AssertLogarithmicAddition();
             AssertLogarithmicSubtraction();
-            AssertEx.EqualTolerance(50, (v*10).DecibelWatts, DecibelWattsTolerance);
-            AssertEx.EqualTolerance(50, (10*v).DecibelWatts, DecibelWattsTolerance);
-            AssertEx.EqualTolerance(35, (v/5).DecibelWatts, DecibelWattsTolerance);
-            AssertEx.EqualTolerance(35, v/PowerRatio.FromDecibelWatts(5), DecibelWattsTolerance);
+            Assert.Equal(50, (v * 10).DecibelWatts);
+            Assert.Equal(50, (10 * v).DecibelWatts);
+            Assert.Equal(35, (v / 5).DecibelWatts);
+            Assert.Equal(35, v / PowerRatio.FromDecibelWatts(5));
         }
 
         protected abstract void AssertLogarithmicAddition();
@@ -466,8 +502,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, PowerRatioUnit.DecibelWatt, 1, PowerRatioUnit.DecibelWatt, true)]  // Same value and unit.
         [InlineData(1, PowerRatioUnit.DecibelWatt, 2, PowerRatioUnit.DecibelWatt, false)] // Different value.
-        [InlineData(2, PowerRatioUnit.DecibelWatt, 1, PowerRatioUnit.DecibelMilliwatt, false)] // Different value and unit.
-        [InlineData(1, PowerRatioUnit.DecibelWatt, 1, PowerRatioUnit.DecibelMilliwatt, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, PowerRatioUnit unitA, double valueB, PowerRatioUnit unitB, bool expectEqual)
         {
             var a = new PowerRatio(valueA, unitA);
@@ -527,8 +561,8 @@ public void Equals_Logarithmic_WithTolerance(double firstValue, double secondVal
             var quantity = PowerRatio.FromDecibelWatts(firstValue);
             var otherQuantity = PowerRatio.FromDecibelWatts(secondValue);
             PowerRatio maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, PowerRatio.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, largerTolerance));
@@ -549,7 +583,7 @@ public void Equals_Logarithmic_WithNegativeTolerance_DoesNotThrowArgumentOutOfRa
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<PowerRatioUnit>();
+            var units = EnumHelper.GetValues<PowerRatioUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -562,6 +596,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(PowerRatio.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(PowerRatio.Info.Units, PowerRatio.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, PowerRatio.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -580,26 +626,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 dBW", new PowerRatio(1, PowerRatioUnit.DecibelWatt).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 dBW", new PowerRatio(0.123456, PowerRatioUnit.DecibelWatt).ToString("s1"));
-            Assert.Equal("0.12 dBW", new PowerRatio(0.123456, PowerRatioUnit.DecibelWatt).ToString("s2"));
-            Assert.Equal("0.123 dBW", new PowerRatio(0.123456, PowerRatioUnit.DecibelWatt).ToString("s3"));
-            Assert.Equal("0.1235 dBW", new PowerRatio(0.123456, PowerRatioUnit.DecibelWatt).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 dBW", new PowerRatio(0.123456, PowerRatioUnit.DecibelWatt).ToString("s1", culture));
-            Assert.Equal("0.12 dBW", new PowerRatio(0.123456, PowerRatioUnit.DecibelWatt).ToString("s2", culture));
-            Assert.Equal("0.123 dBW", new PowerRatio(0.123456, PowerRatioUnit.DecibelWatt).ToString("s3", culture));
-            Assert.Equal("0.1235 dBW", new PowerRatio(0.123456, PowerRatioUnit.DecibelWatt).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -626,7 +652,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = PowerRatio.FromDecibelWatts(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(PowerRatio), quantity.As(PowerRatio.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs
index 1920ba333f..01e2d5e3e8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs
@@ -229,6 +229,20 @@ public void Power_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<PowerUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void PowerInfo_CreateWithCustomUnitInfos()
+        {
+            PowerUnit[] expectedUnits = [PowerUnit.Watt];
+
+            Power.PowerInfo quantityInfo = Power.PowerInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Power", quantityInfo.Name);
+            Assert.Equal(Power.Zero, quantityInfo.Zero);
+            Assert.Equal(Power.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void WattToPowerUnits()
         {
@@ -365,26 +379,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Power.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Power convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Power quantityToConvert = quantity;
+
+                Power convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<PowerUnit> quantityToConvert = quantity;
+
+                IQuantity<PowerUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Power(value: 1, unit: Power.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Power(value: 1, unit: Power.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<PowerUnit> quantity = new Power(value: 1, unit: Power.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Power(value: 1, unit: Power.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Power(value: 1, unit: Power.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Power(value: 1, unit: Power.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<PowerUnit> quantity = new Power(value: 1, unit: Power.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Power(value: 1, unit: Power.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -418,7 +475,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 TW", PowerUnit.Terawatt, 4.2)]
         [InlineData("en-US", "4.2 TR", PowerUnit.TonOfRefrigeration, 4.2)]
         [InlineData("en-US", "4.2 W", PowerUnit.Watt, 4.2)]
-        public void Parse(string culture, string quantityString, PowerUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, PowerUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Power.Parse(quantityString);
@@ -457,7 +514,7 @@ public void Parse(string culture, string quantityString, PowerUnit expectedUnit,
         [InlineData("en-US", "4.2 TW", PowerUnit.Terawatt, 4.2)]
         [InlineData("en-US", "4.2 TR", PowerUnit.TonOfRefrigeration, 4.2)]
         [InlineData("en-US", "4.2 W", PowerUnit.Watt, 4.2)]
-        public void TryParse(string culture, string quantityString, PowerUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, PowerUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Power.TryParse(quantityString, out Power parsed));
@@ -848,6 +905,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(PowerUnit unit)
                 var quantity = Power.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -871,58 +929,60 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(PowerUnit unit)
                 IQuantity<PowerUnit> quantityToConvert = quantity;
                 IQuantity<PowerUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Power watt = Power.FromWatts(1);
-            AssertEx.EqualTolerance(1, Power.FromBoilerHorsepower(watt.BoilerHorsepower).Watts, BoilerHorsepowerTolerance);
-            AssertEx.EqualTolerance(1, Power.FromBritishThermalUnitsPerHour(watt.BritishThermalUnitsPerHour).Watts, BritishThermalUnitsPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromDecawatts(watt.Decawatts).Watts, DecawattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromDeciwatts(watt.Deciwatts).Watts, DeciwattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromElectricalHorsepower(watt.ElectricalHorsepower).Watts, ElectricalHorsepowerTolerance);
-            AssertEx.EqualTolerance(1, Power.FromFemtowatts(watt.Femtowatts).Watts, FemtowattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromGigajoulesPerHour(watt.GigajoulesPerHour).Watts, GigajoulesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromGigawatts(watt.Gigawatts).Watts, GigawattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromHydraulicHorsepower(watt.HydraulicHorsepower).Watts, HydraulicHorsepowerTolerance);
-            AssertEx.EqualTolerance(1, Power.FromJoulesPerHour(watt.JoulesPerHour).Watts, JoulesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromKilobritishThermalUnitsPerHour(watt.KilobritishThermalUnitsPerHour).Watts, KilobritishThermalUnitsPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromKilojoulesPerHour(watt.KilojoulesPerHour).Watts, KilojoulesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromKilowatts(watt.Kilowatts).Watts, KilowattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMechanicalHorsepower(watt.MechanicalHorsepower).Watts, MechanicalHorsepowerTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMegabritishThermalUnitsPerHour(watt.MegabritishThermalUnitsPerHour).Watts, MegabritishThermalUnitsPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMegajoulesPerHour(watt.MegajoulesPerHour).Watts, MegajoulesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMegawatts(watt.Megawatts).Watts, MegawattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMetricHorsepower(watt.MetricHorsepower).Watts, MetricHorsepowerTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMicrowatts(watt.Microwatts).Watts, MicrowattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMillijoulesPerHour(watt.MillijoulesPerHour).Watts, MillijoulesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Power.FromMilliwatts(watt.Milliwatts).Watts, MilliwattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromNanowatts(watt.Nanowatts).Watts, NanowattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromPetawatts(watt.Petawatts).Watts, PetawattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromPicowatts(watt.Picowatts).Watts, PicowattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromTerawatts(watt.Terawatts).Watts, TerawattsTolerance);
-            AssertEx.EqualTolerance(1, Power.FromTonsOfRefrigeration(watt.TonsOfRefrigeration).Watts, TonsOfRefrigerationTolerance);
-            AssertEx.EqualTolerance(1, Power.FromWatts(watt.Watts).Watts, WattsTolerance);
+            Power watt = Power.FromWatts(3);
+            Assert.Equal(3, Power.FromBoilerHorsepower(watt.BoilerHorsepower).Watts);
+            Assert.Equal(3, Power.FromBritishThermalUnitsPerHour(watt.BritishThermalUnitsPerHour).Watts);
+            Assert.Equal(3, Power.FromDecawatts(watt.Decawatts).Watts);
+            Assert.Equal(3, Power.FromDeciwatts(watt.Deciwatts).Watts);
+            Assert.Equal(3, Power.FromElectricalHorsepower(watt.ElectricalHorsepower).Watts);
+            Assert.Equal(3, Power.FromFemtowatts(watt.Femtowatts).Watts);
+            Assert.Equal(3, Power.FromGigajoulesPerHour(watt.GigajoulesPerHour).Watts);
+            Assert.Equal(3, Power.FromGigawatts(watt.Gigawatts).Watts);
+            Assert.Equal(3, Power.FromHydraulicHorsepower(watt.HydraulicHorsepower).Watts);
+            Assert.Equal(3, Power.FromJoulesPerHour(watt.JoulesPerHour).Watts);
+            Assert.Equal(3, Power.FromKilobritishThermalUnitsPerHour(watt.KilobritishThermalUnitsPerHour).Watts);
+            Assert.Equal(3, Power.FromKilojoulesPerHour(watt.KilojoulesPerHour).Watts);
+            Assert.Equal(3, Power.FromKilowatts(watt.Kilowatts).Watts);
+            Assert.Equal(3, Power.FromMechanicalHorsepower(watt.MechanicalHorsepower).Watts);
+            Assert.Equal(3, Power.FromMegabritishThermalUnitsPerHour(watt.MegabritishThermalUnitsPerHour).Watts);
+            Assert.Equal(3, Power.FromMegajoulesPerHour(watt.MegajoulesPerHour).Watts);
+            Assert.Equal(3, Power.FromMegawatts(watt.Megawatts).Watts);
+            Assert.Equal(3, Power.FromMetricHorsepower(watt.MetricHorsepower).Watts);
+            Assert.Equal(3, Power.FromMicrowatts(watt.Microwatts).Watts);
+            Assert.Equal(3, Power.FromMillijoulesPerHour(watt.MillijoulesPerHour).Watts);
+            Assert.Equal(3, Power.FromMilliwatts(watt.Milliwatts).Watts);
+            Assert.Equal(3, Power.FromNanowatts(watt.Nanowatts).Watts);
+            Assert.Equal(3, Power.FromPetawatts(watt.Petawatts).Watts);
+            Assert.Equal(3, Power.FromPicowatts(watt.Picowatts).Watts);
+            Assert.Equal(3, Power.FromTerawatts(watt.Terawatts).Watts);
+            Assert.Equal(3, Power.FromTonsOfRefrigeration(watt.TonsOfRefrigeration).Watts);
+            Assert.Equal(3, Power.FromWatts(watt.Watts).Watts);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Power v = Power.FromWatts(1);
-            AssertEx.EqualTolerance(-1, -v.Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, (Power.FromWatts(3)-v).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, (Power.FromWatts(10)/5).Watts, WattsTolerance);
-            AssertEx.EqualTolerance(2, Power.FromWatts(10)/Power.FromWatts(5), WattsTolerance);
+            Assert.Equal(-1, -v.Watts);
+            Assert.Equal(2, (Power.FromWatts(3) - v).Watts);
+            Assert.Equal(2, (v + v).Watts);
+            Assert.Equal(10, (v * 10).Watts);
+            Assert.Equal(10, (10 * v).Watts);
+            Assert.Equal(2, (Power.FromWatts(10) / 5).Watts);
+            Assert.Equal(2, Power.FromWatts(10) / Power.FromWatts(5));
         }
 
         [Fact]
@@ -968,8 +1028,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, PowerUnit.Watt, 1, PowerUnit.Watt, true)]  // Same value and unit.
         [InlineData(1, PowerUnit.Watt, 2, PowerUnit.Watt, false)] // Different value.
-        [InlineData(2, PowerUnit.Watt, 1, PowerUnit.BoilerHorsepower, false)] // Different value and unit.
-        [InlineData(1, PowerUnit.Watt, 1, PowerUnit.BoilerHorsepower, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, PowerUnit unitA, double valueB, PowerUnit unitB, bool expectEqual)
         {
             var a = new Power(valueA, unitA);
@@ -1029,8 +1087,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Power.FromWatts(firstValue);
             var otherQuantity = Power.FromWatts(secondValue);
             Power maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Power.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1049,7 +1107,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<PowerUnit>();
+            var units = EnumHelper.GetValues<PowerUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1062,6 +1120,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Power.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Power.Info.Units, Power.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Power.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1130,26 +1200,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 W", new Power(1, PowerUnit.Watt).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 W", new Power(0.123456, PowerUnit.Watt).ToString("s1"));
-            Assert.Equal("0.12 W", new Power(0.123456, PowerUnit.Watt).ToString("s2"));
-            Assert.Equal("0.123 W", new Power(0.123456, PowerUnit.Watt).ToString("s3"));
-            Assert.Equal("0.1235 W", new Power(0.123456, PowerUnit.Watt).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 W", new Power(0.123456, PowerUnit.Watt).ToString("s1", culture));
-            Assert.Equal("0.12 W", new Power(0.123456, PowerUnit.Watt).ToString("s2", culture));
-            Assert.Equal("0.123 W", new Power(0.123456, PowerUnit.Watt).ToString("s3", culture));
-            Assert.Equal("0.1235 W", new Power(0.123456, PowerUnit.Watt).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1176,7 +1226,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Power.FromWatts(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Power), quantity.As(Power.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs
index bd759a52f0..6000cc4790 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs
@@ -193,6 +193,20 @@ public void PressureChangeRate_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
             Assert.Equal(quantityInfo, ((IQuantity<PressureChangeRateUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void PressureChangeRateInfo_CreateWithCustomUnitInfos()
+        {
+            PressureChangeRateUnit[] expectedUnits = [PressureChangeRateUnit.PascalPerSecond];
+
+            PressureChangeRate.PressureChangeRateInfo quantityInfo = PressureChangeRate.PressureChangeRateInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("PressureChangeRate", quantityInfo.Name);
+            Assert.Equal(PressureChangeRate.Zero, quantityInfo.Zero);
+            Assert.Equal(PressureChangeRate.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void PascalPerSecondToPressureChangeRateUnits()
         {
@@ -311,26 +325,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = PressureChangeRate.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            PressureChangeRate convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                PressureChangeRate quantityToConvert = quantity;
+
+                PressureChangeRate convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<PressureChangeRateUnit> quantityToConvert = quantity;
+
+                IQuantity<PressureChangeRateUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new PressureChangeRate(value: 1, unit: PressureChangeRate.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new PressureChangeRate(value: 1, unit: PressureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<PressureChangeRateUnit> quantity = new PressureChangeRate(value: 1, unit: PressureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new PressureChangeRate(value: 1, unit: PressureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new PressureChangeRate(value: 1, unit: PressureChangeRate.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new PressureChangeRate(value: 1, unit: PressureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<PressureChangeRateUnit> quantity = new PressureChangeRate(value: 1, unit: PressureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new PressureChangeRate(value: 1, unit: PressureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -382,7 +439,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 lb/in²/мин", PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 psi/с", PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 lb/in²/с", PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, PressureChangeRateUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, PressureChangeRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = PressureChangeRate.Parse(quantityString);
@@ -439,7 +496,7 @@ public void Parse(string culture, string quantityString, PressureChangeRateUnit
         [InlineData("ru-RU", "4,2 lb/in²/мин", PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 psi/с", PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 lb/in²/с", PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, PressureChangeRateUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, PressureChangeRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(PressureChangeRate.TryParse(quantityString, out PressureChangeRate parsed));
@@ -887,6 +944,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(PressureChangeRa
                 var quantity = PressureChangeRate.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -910,49 +968,51 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(PressureChangeRateU
                 IQuantity<PressureChangeRateUnit> quantityToConvert = quantity;
                 IQuantity<PressureChangeRateUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromAtmospheresPerSecond(pascalpersecond.AtmospheresPerSecond).PascalsPerSecond, AtmospheresPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromBarsPerMinute(pascalpersecond.BarsPerMinute).PascalsPerSecond, BarsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromBarsPerSecond(pascalpersecond.BarsPerSecond).PascalsPerSecond, BarsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopascalsPerMinute(pascalpersecond.KilopascalsPerMinute).PascalsPerSecond, KilopascalsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopascalsPerSecond(pascalpersecond.KilopascalsPerSecond).PascalsPerSecond, KilopascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(pascalpersecond.KilopoundsForcePerSquareInchPerMinute).PascalsPerSecond, KilopoundsForcePerSquareInchPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(pascalpersecond.KilopoundsForcePerSquareInchPerSecond).PascalsPerSecond, KilopoundsForcePerSquareInchPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapascalsPerMinute(pascalpersecond.MegapascalsPerMinute).PascalsPerSecond, MegapascalsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapascalsPerSecond(pascalpersecond.MegapascalsPerSecond).PascalsPerSecond, MegapascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(pascalpersecond.MegapoundsForcePerSquareInchPerMinute).PascalsPerSecond, MegapoundsForcePerSquareInchPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(pascalpersecond.MegapoundsForcePerSquareInchPerSecond).PascalsPerSecond, MegapoundsForcePerSquareInchPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromMillibarsPerMinute(pascalpersecond.MillibarsPerMinute).PascalsPerSecond, MillibarsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromMillibarsPerSecond(pascalpersecond.MillibarsPerSecond).PascalsPerSecond, MillibarsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromMillimetersOfMercuryPerSecond(pascalpersecond.MillimetersOfMercuryPerSecond).PascalsPerSecond, MillimetersOfMercuryPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromPascalsPerMinute(pascalpersecond.PascalsPerMinute).PascalsPerSecond, PascalsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromPascalsPerSecond(pascalpersecond.PascalsPerSecond).PascalsPerSecond, PascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(pascalpersecond.PoundsForcePerSquareInchPerMinute).PascalsPerSecond, PoundsForcePerSquareInchPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(pascalpersecond.PoundsForcePerSquareInchPerSecond).PascalsPerSecond, PoundsForcePerSquareInchPerSecondTolerance);
+            PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(3);
+            Assert.Equal(3, PressureChangeRate.FromAtmospheresPerSecond(pascalpersecond.AtmospheresPerSecond).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromBarsPerMinute(pascalpersecond.BarsPerMinute).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromBarsPerSecond(pascalpersecond.BarsPerSecond).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromKilopascalsPerMinute(pascalpersecond.KilopascalsPerMinute).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromKilopascalsPerSecond(pascalpersecond.KilopascalsPerSecond).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(pascalpersecond.KilopoundsForcePerSquareInchPerMinute).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(pascalpersecond.KilopoundsForcePerSquareInchPerSecond).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromMegapascalsPerMinute(pascalpersecond.MegapascalsPerMinute).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromMegapascalsPerSecond(pascalpersecond.MegapascalsPerSecond).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(pascalpersecond.MegapoundsForcePerSquareInchPerMinute).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(pascalpersecond.MegapoundsForcePerSquareInchPerSecond).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromMillibarsPerMinute(pascalpersecond.MillibarsPerMinute).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromMillibarsPerSecond(pascalpersecond.MillibarsPerSecond).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromMillimetersOfMercuryPerSecond(pascalpersecond.MillimetersOfMercuryPerSecond).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromPascalsPerMinute(pascalpersecond.PascalsPerMinute).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromPascalsPerSecond(pascalpersecond.PascalsPerSecond).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(pascalpersecond.PoundsForcePerSquareInchPerMinute).PascalsPerSecond);
+            Assert.Equal(3, PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(pascalpersecond.PoundsForcePerSquareInchPerSecond).PascalsPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             PressureChangeRate v = PressureChangeRate.FromPascalsPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.PascalsPerSecond, PascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (PressureChangeRate.FromPascalsPerSecond(3)-v).PascalsPerSecond, PascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).PascalsPerSecond, PascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).PascalsPerSecond, PascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).PascalsPerSecond, PascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (PressureChangeRate.FromPascalsPerSecond(10)/5).PascalsPerSecond, PascalsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, PressureChangeRate.FromPascalsPerSecond(10)/PressureChangeRate.FromPascalsPerSecond(5), PascalsPerSecondTolerance);
+            Assert.Equal(-1, -v.PascalsPerSecond);
+            Assert.Equal(2, (PressureChangeRate.FromPascalsPerSecond(3) - v).PascalsPerSecond);
+            Assert.Equal(2, (v + v).PascalsPerSecond);
+            Assert.Equal(10, (v * 10).PascalsPerSecond);
+            Assert.Equal(10, (10 * v).PascalsPerSecond);
+            Assert.Equal(2, (PressureChangeRate.FromPascalsPerSecond(10) / 5).PascalsPerSecond);
+            Assert.Equal(2, PressureChangeRate.FromPascalsPerSecond(10) / PressureChangeRate.FromPascalsPerSecond(5));
         }
 
         [Fact]
@@ -998,8 +1058,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, PressureChangeRateUnit.PascalPerSecond, 1, PressureChangeRateUnit.PascalPerSecond, true)]  // Same value and unit.
         [InlineData(1, PressureChangeRateUnit.PascalPerSecond, 2, PressureChangeRateUnit.PascalPerSecond, false)] // Different value.
-        [InlineData(2, PressureChangeRateUnit.PascalPerSecond, 1, PressureChangeRateUnit.AtmospherePerSecond, false)] // Different value and unit.
-        [InlineData(1, PressureChangeRateUnit.PascalPerSecond, 1, PressureChangeRateUnit.AtmospherePerSecond, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, PressureChangeRateUnit unitA, double valueB, PressureChangeRateUnit unitB, bool expectEqual)
         {
             var a = new PressureChangeRate(valueA, unitA);
@@ -1059,8 +1117,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = PressureChangeRate.FromPascalsPerSecond(firstValue);
             var otherQuantity = PressureChangeRate.FromPascalsPerSecond(secondValue);
             PressureChangeRate maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, PressureChangeRate.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1079,7 +1137,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<PressureChangeRateUnit>();
+            var units = EnumHelper.GetValues<PressureChangeRateUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1092,6 +1150,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(PressureChangeRate.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(PressureChangeRate.Info.Units, PressureChangeRate.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, PressureChangeRate.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1142,26 +1212,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 psi/s", new PressureChangeRate(1, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Pa/s", new PressureChangeRate(0.123456, PressureChangeRateUnit.PascalPerSecond).ToString("s1"));
-            Assert.Equal("0.12 Pa/s", new PressureChangeRate(0.123456, PressureChangeRateUnit.PascalPerSecond).ToString("s2"));
-            Assert.Equal("0.123 Pa/s", new PressureChangeRate(0.123456, PressureChangeRateUnit.PascalPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 Pa/s", new PressureChangeRate(0.123456, PressureChangeRateUnit.PascalPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Pa/s", new PressureChangeRate(0.123456, PressureChangeRateUnit.PascalPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 Pa/s", new PressureChangeRate(0.123456, PressureChangeRateUnit.PascalPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 Pa/s", new PressureChangeRate(0.123456, PressureChangeRateUnit.PascalPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 Pa/s", new PressureChangeRate(0.123456, PressureChangeRateUnit.PascalPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1188,7 +1238,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = PressureChangeRate.FromPascalsPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(PressureChangeRate), quantity.As(PressureChangeRate.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs
index fbb8444297..d51281ba09 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs
@@ -71,6 +71,8 @@ public abstract partial class PressureTestsBase : QuantityTestsBase
         protected abstract double MicrobarsInOnePascal { get; }
         protected abstract double MicropascalsInOnePascal { get; }
         protected abstract double MillibarsInOnePascal { get; }
+        protected abstract double MilligramsForcePerSquareFootInOnePascal { get; }
+        protected abstract double MilligramsForcePerSquareMeterInOnePascal { get; }
         protected abstract double MillimetersOfMercuryInOnePascal { get; }
         protected abstract double MillimetersOfWaterColumnInOnePascal { get; }
         protected abstract double MillipascalsInOnePascal { get; }
@@ -121,6 +123,8 @@ public abstract partial class PressureTestsBase : QuantityTestsBase
         protected virtual double MicrobarsTolerance { get { return 1e-5; } }
         protected virtual double MicropascalsTolerance { get { return 1e-5; } }
         protected virtual double MillibarsTolerance { get { return 1e-5; } }
+        protected virtual double MilligramsForcePerSquareFootTolerance { get { return 1e-5; } }
+        protected virtual double MilligramsForcePerSquareMeterTolerance { get { return 1e-5; } }
         protected virtual double MillimetersOfMercuryTolerance { get { return 1e-5; } }
         protected virtual double MillimetersOfWaterColumnTolerance { get { return 1e-5; } }
         protected virtual double MillipascalsTolerance { get { return 1e-5; } }
@@ -175,6 +179,8 @@ public abstract partial class PressureTestsBase : QuantityTestsBase
                 PressureUnit.Microbar => (MicrobarsInOnePascal, MicrobarsTolerance),
                 PressureUnit.Micropascal => (MicropascalsInOnePascal, MicropascalsTolerance),
                 PressureUnit.Millibar => (MillibarsInOnePascal, MillibarsTolerance),
+                PressureUnit.MilligramForcePerSquareFoot => (MilligramsForcePerSquareFootInOnePascal, MilligramsForcePerSquareFootTolerance),
+                PressureUnit.MilligramForcePerSquareMeter => (MilligramsForcePerSquareMeterInOnePascal, MilligramsForcePerSquareMeterTolerance),
                 PressureUnit.MillimeterOfMercury => (MillimetersOfMercuryInOnePascal, MillimetersOfMercuryTolerance),
                 PressureUnit.MillimeterOfWaterColumn => (MillimetersOfWaterColumnInOnePascal, MillimetersOfWaterColumnTolerance),
                 PressureUnit.Millipascal => (MillipascalsInOnePascal, MillipascalsTolerance),
@@ -229,6 +235,8 @@ public abstract partial class PressureTestsBase : QuantityTestsBase
             new object[] { PressureUnit.Microbar },
             new object[] { PressureUnit.Micropascal },
             new object[] { PressureUnit.Millibar },
+            new object[] { PressureUnit.MilligramForcePerSquareFoot },
+            new object[] { PressureUnit.MilligramForcePerSquareMeter },
             new object[] { PressureUnit.MillimeterOfMercury },
             new object[] { PressureUnit.MillimeterOfWaterColumn },
             new object[] { PressureUnit.Millipascal },
@@ -313,6 +321,20 @@ public void Pressure_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<PressureUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void PressureInfo_CreateWithCustomUnitInfos()
+        {
+            PressureUnit[] expectedUnits = [PressureUnit.Pascal];
+
+            Pressure.PressureInfo quantityInfo = Pressure.PressureInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Pressure", quantityInfo.Name);
+            Assert.Equal(Pressure.Zero, quantityInfo.Zero);
+            Assert.Equal(Pressure.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void PascalToPressureUnits()
         {
@@ -348,6 +370,8 @@ public void PascalToPressureUnits()
             AssertEx.EqualTolerance(MicrobarsInOnePascal, pascal.Microbars, MicrobarsTolerance);
             AssertEx.EqualTolerance(MicropascalsInOnePascal, pascal.Micropascals, MicropascalsTolerance);
             AssertEx.EqualTolerance(MillibarsInOnePascal, pascal.Millibars, MillibarsTolerance);
+            AssertEx.EqualTolerance(MilligramsForcePerSquareFootInOnePascal, pascal.MilligramsForcePerSquareFoot, MilligramsForcePerSquareFootTolerance);
+            AssertEx.EqualTolerance(MilligramsForcePerSquareMeterInOnePascal, pascal.MilligramsForcePerSquareMeter, MilligramsForcePerSquareMeterTolerance);
             AssertEx.EqualTolerance(MillimetersOfMercuryInOnePascal, pascal.MillimetersOfMercury, MillimetersOfMercuryTolerance);
             AssertEx.EqualTolerance(MillimetersOfWaterColumnInOnePascal, pascal.MillimetersOfWaterColumn, MillimetersOfWaterColumnTolerance);
             AssertEx.EqualTolerance(MillipascalsInOnePascal, pascal.Millipascals, MillipascalsTolerance);
@@ -431,6 +455,8 @@ public void As()
             AssertEx.EqualTolerance(MicrobarsInOnePascal, pascal.As(PressureUnit.Microbar), MicrobarsTolerance);
             AssertEx.EqualTolerance(MicropascalsInOnePascal, pascal.As(PressureUnit.Micropascal), MicropascalsTolerance);
             AssertEx.EqualTolerance(MillibarsInOnePascal, pascal.As(PressureUnit.Millibar), MillibarsTolerance);
+            AssertEx.EqualTolerance(MilligramsForcePerSquareFootInOnePascal, pascal.As(PressureUnit.MilligramForcePerSquareFoot), MilligramsForcePerSquareFootTolerance);
+            AssertEx.EqualTolerance(MilligramsForcePerSquareMeterInOnePascal, pascal.As(PressureUnit.MilligramForcePerSquareMeter), MilligramsForcePerSquareMeterTolerance);
             AssertEx.EqualTolerance(MillimetersOfMercuryInOnePascal, pascal.As(PressureUnit.MillimeterOfMercury), MillimetersOfMercuryTolerance);
             AssertEx.EqualTolerance(MillimetersOfWaterColumnInOnePascal, pascal.As(PressureUnit.MillimeterOfWaterColumn), MillimetersOfWaterColumnTolerance);
             AssertEx.EqualTolerance(MillipascalsInOnePascal, pascal.As(PressureUnit.Millipascal), MillipascalsTolerance);
@@ -491,26 +517,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Pressure.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Pressure convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Pressure quantityToConvert = quantity;
+
+                Pressure convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<PressureUnit> quantityToConvert = quantity;
+
+                IQuantity<PressureUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Pressure(value: 1, unit: Pressure.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Pressure(value: 1, unit: Pressure.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<PressureUnit> quantity = new Pressure(value: 1, unit: Pressure.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Pressure(value: 1, unit: Pressure.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Pressure(value: 1, unit: Pressure.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Pressure(value: 1, unit: Pressure.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<PressureUnit> quantity = new Pressure(value: 1, unit: Pressure.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Pressure(value: 1, unit: Pressure.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -554,6 +623,8 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 µbar", PressureUnit.Microbar, 4.2)]
         [InlineData("en-US", "4.2 µPa", PressureUnit.Micropascal, 4.2)]
         [InlineData("en-US", "4.2 mbar", PressureUnit.Millibar, 4.2)]
+        [InlineData("en-US", "4.2 mgf/ft²", PressureUnit.MilligramForcePerSquareFoot, 4.2)]
+        [InlineData("en-US", "4.2 mgf/m²", PressureUnit.MilligramForcePerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 mmHg", PressureUnit.MillimeterOfMercury, 4.2)]
         [InlineData("en-US", "4.2 mmH₂O", PressureUnit.MillimeterOfWaterColumn, 4.2)]
         [InlineData("en-US", "4.2 mmH2O", PressureUnit.MillimeterOfWaterColumn, 4.2)]
@@ -600,6 +671,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 мкбар", PressureUnit.Microbar, 4.2)]
         [InlineData("ru-RU", "4,2 мкПа", PressureUnit.Micropascal, 4.2)]
         [InlineData("ru-RU", "4,2 мбар", PressureUnit.Millibar, 4.2)]
+        [InlineData("ru-RU", "4,2 мгс/м²", PressureUnit.MilligramForcePerSquareMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мм рт.ст.", PressureUnit.MillimeterOfMercury, 4.2)]
         [InlineData("ru-RU", "4,2 мПа", PressureUnit.Millipascal, 4.2)]
         [InlineData("ru-RU", "4,2 мторр", PressureUnit.Millitorr, 4.2)]
@@ -611,7 +683,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 lb/in²", PressureUnit.PoundForcePerSquareInch, 4.2)]
         [InlineData("ru-RU", "4,2 ат", PressureUnit.TechnicalAtmosphere, 4.2)]
         [InlineData("ru-RU", "4,2 торр", PressureUnit.Torr, 4.2)]
-        public void Parse(string culture, string quantityString, PressureUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, PressureUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Pressure.Parse(quantityString);
@@ -660,6 +732,8 @@ public void Parse(string culture, string quantityString, PressureUnit expectedUn
         [InlineData("en-US", "4.2 µbar", PressureUnit.Microbar, 4.2)]
         [InlineData("en-US", "4.2 µPa", PressureUnit.Micropascal, 4.2)]
         [InlineData("en-US", "4.2 mbar", PressureUnit.Millibar, 4.2)]
+        [InlineData("en-US", "4.2 mgf/ft²", PressureUnit.MilligramForcePerSquareFoot, 4.2)]
+        [InlineData("en-US", "4.2 mgf/m²", PressureUnit.MilligramForcePerSquareMeter, 4.2)]
         [InlineData("en-US", "4.2 mmHg", PressureUnit.MillimeterOfMercury, 4.2)]
         [InlineData("en-US", "4.2 mmH₂O", PressureUnit.MillimeterOfWaterColumn, 4.2)]
         [InlineData("en-US", "4.2 mmH2O", PressureUnit.MillimeterOfWaterColumn, 4.2)]
@@ -706,6 +780,7 @@ public void Parse(string culture, string quantityString, PressureUnit expectedUn
         [InlineData("ru-RU", "4,2 мкбар", PressureUnit.Microbar, 4.2)]
         [InlineData("ru-RU", "4,2 мкПа", PressureUnit.Micropascal, 4.2)]
         [InlineData("ru-RU", "4,2 мбар", PressureUnit.Millibar, 4.2)]
+        [InlineData("ru-RU", "4,2 мгс/м²", PressureUnit.MilligramForcePerSquareMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мм рт.ст.", PressureUnit.MillimeterOfMercury, 4.2)]
         [InlineData("ru-RU", "4,2 мПа", PressureUnit.Millipascal, 4.2)]
         [InlineData("ru-RU", "4,2 мторр", PressureUnit.Millitorr, 4.2)]
@@ -717,7 +792,7 @@ public void Parse(string culture, string quantityString, PressureUnit expectedUn
         [InlineData("ru-RU", "4,2 lb/in²", PressureUnit.PoundForcePerSquareInch, 4.2)]
         [InlineData("ru-RU", "4,2 ат", PressureUnit.TechnicalAtmosphere, 4.2)]
         [InlineData("ru-RU", "4,2 торр", PressureUnit.Torr, 4.2)]
-        public void TryParse(string culture, string quantityString, PressureUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, PressureUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Pressure.TryParse(quantityString, out Pressure parsed));
@@ -766,6 +841,8 @@ public void TryParse(string culture, string quantityString, PressureUnit expecte
         [InlineData("µbar", PressureUnit.Microbar)]
         [InlineData("µPa", PressureUnit.Micropascal)]
         [InlineData("mbar", PressureUnit.Millibar)]
+        [InlineData("mgf/ft²", PressureUnit.MilligramForcePerSquareFoot)]
+        [InlineData("mgf/m²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("mmHg", PressureUnit.MillimeterOfMercury)]
         [InlineData("mmH₂O", PressureUnit.MillimeterOfWaterColumn)]
         [InlineData("mmH2O", PressureUnit.MillimeterOfWaterColumn)]
@@ -838,6 +915,8 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, PressureU
         [InlineData("µbar", PressureUnit.Microbar)]
         [InlineData("µPa", PressureUnit.Micropascal)]
         [InlineData("mbar", PressureUnit.Millibar)]
+        [InlineData("mgf/ft²", PressureUnit.MilligramForcePerSquareFoot)]
+        [InlineData("mgf/m²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("mmHg", PressureUnit.MillimeterOfMercury)]
         [InlineData("mmH₂O", PressureUnit.MillimeterOfWaterColumn)]
         [InlineData("mmH2O", PressureUnit.MillimeterOfWaterColumn)]
@@ -910,6 +989,8 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "µbar", PressureUnit.Microbar)]
         [InlineData("en-US", "µPa", PressureUnit.Micropascal)]
         [InlineData("en-US", "mbar", PressureUnit.Millibar)]
+        [InlineData("en-US", "mgf/ft²", PressureUnit.MilligramForcePerSquareFoot)]
+        [InlineData("en-US", "mgf/m²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("en-US", "mmHg", PressureUnit.MillimeterOfMercury)]
         [InlineData("en-US", "mmH₂O", PressureUnit.MillimeterOfWaterColumn)]
         [InlineData("en-US", "mmH2O", PressureUnit.MillimeterOfWaterColumn)]
@@ -956,6 +1037,7 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("ru-RU", "мкбар", PressureUnit.Microbar)]
         [InlineData("ru-RU", "мкПа", PressureUnit.Micropascal)]
         [InlineData("ru-RU", "мбар", PressureUnit.Millibar)]
+        [InlineData("ru-RU", "мгс/м²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("ru-RU", "мм рт.ст.", PressureUnit.MillimeterOfMercury)]
         [InlineData("ru-RU", "мПа", PressureUnit.Millipascal)]
         [InlineData("ru-RU", "мторр", PressureUnit.Millitorr)]
@@ -1015,6 +1097,8 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Pr
         [InlineData("en-US", "µbar", PressureUnit.Microbar)]
         [InlineData("en-US", "µPa", PressureUnit.Micropascal)]
         [InlineData("en-US", "mbar", PressureUnit.Millibar)]
+        [InlineData("en-US", "mgf/ft²", PressureUnit.MilligramForcePerSquareFoot)]
+        [InlineData("en-US", "mgf/m²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("en-US", "mmHg", PressureUnit.MillimeterOfMercury)]
         [InlineData("en-US", "mmH₂O", PressureUnit.MillimeterOfWaterColumn)]
         [InlineData("en-US", "mmH2O", PressureUnit.MillimeterOfWaterColumn)]
@@ -1061,6 +1145,7 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Pr
         [InlineData("ru-RU", "мкбар", PressureUnit.Microbar)]
         [InlineData("ru-RU", "мкПа", PressureUnit.Micropascal)]
         [InlineData("ru-RU", "мбар", PressureUnit.Millibar)]
+        [InlineData("ru-RU", "мгс/м²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("ru-RU", "мм рт.ст.", PressureUnit.MillimeterOfMercury)]
         [InlineData("ru-RU", "мПа", PressureUnit.Millipascal)]
         [InlineData("ru-RU", "мторр", PressureUnit.Millitorr)]
@@ -1119,6 +1204,8 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, PressureU
         [InlineData("µbar", PressureUnit.Microbar)]
         [InlineData("µPa", PressureUnit.Micropascal)]
         [InlineData("mbar", PressureUnit.Millibar)]
+        [InlineData("mgf/ft²", PressureUnit.MilligramForcePerSquareFoot)]
+        [InlineData("mgf/m²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("mmHg", PressureUnit.MillimeterOfMercury)]
         [InlineData("mmH₂O", PressureUnit.MillimeterOfWaterColumn)]
         [InlineData("mmH2O", PressureUnit.MillimeterOfWaterColumn)]
@@ -1191,6 +1278,8 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Pressu
         [InlineData("µbar", PressureUnit.Microbar)]
         [InlineData("µPa", PressureUnit.Micropascal)]
         [InlineData("mbar", PressureUnit.Millibar)]
+        [InlineData("mgf/ft²", PressureUnit.MilligramForcePerSquareFoot)]
+        [InlineData("mgf/m²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("mmHg", PressureUnit.MillimeterOfMercury)]
         [InlineData("mmH₂O", PressureUnit.MillimeterOfWaterColumn)]
         [InlineData("mmH2O", PressureUnit.MillimeterOfWaterColumn)]
@@ -1263,6 +1352,8 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "µbar", PressureUnit.Microbar)]
         [InlineData("en-US", "µPa", PressureUnit.Micropascal)]
         [InlineData("en-US", "mbar", PressureUnit.Millibar)]
+        [InlineData("en-US", "mgf/ft²", PressureUnit.MilligramForcePerSquareFoot)]
+        [InlineData("en-US", "mgf/m²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("en-US", "mmHg", PressureUnit.MillimeterOfMercury)]
         [InlineData("en-US", "mmH₂O", PressureUnit.MillimeterOfWaterColumn)]
         [InlineData("en-US", "mmH2O", PressureUnit.MillimeterOfWaterColumn)]
@@ -1309,6 +1400,7 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("ru-RU", "мкбар", PressureUnit.Microbar)]
         [InlineData("ru-RU", "мкПа", PressureUnit.Micropascal)]
         [InlineData("ru-RU", "мбар", PressureUnit.Millibar)]
+        [InlineData("ru-RU", "мгс/м²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("ru-RU", "мм рт.ст.", PressureUnit.MillimeterOfMercury)]
         [InlineData("ru-RU", "мПа", PressureUnit.Millipascal)]
         [InlineData("ru-RU", "мторр", PressureUnit.Millitorr)]
@@ -1368,6 +1460,8 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "µbar", PressureUnit.Microbar)]
         [InlineData("en-US", "µPa", PressureUnit.Micropascal)]
         [InlineData("en-US", "mbar", PressureUnit.Millibar)]
+        [InlineData("en-US", "mgf/ft²", PressureUnit.MilligramForcePerSquareFoot)]
+        [InlineData("en-US", "mgf/m²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("en-US", "mmHg", PressureUnit.MillimeterOfMercury)]
         [InlineData("en-US", "mmH₂O", PressureUnit.MillimeterOfWaterColumn)]
         [InlineData("en-US", "mmH2O", PressureUnit.MillimeterOfWaterColumn)]
@@ -1414,6 +1508,7 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("ru-RU", "мкбар", PressureUnit.Microbar)]
         [InlineData("ru-RU", "мкПа", PressureUnit.Micropascal)]
         [InlineData("ru-RU", "мбар", PressureUnit.Millibar)]
+        [InlineData("ru-RU", "мгс/м²", PressureUnit.MilligramForcePerSquareMeter)]
         [InlineData("ru-RU", "мм рт.ст.", PressureUnit.MillimeterOfMercury)]
         [InlineData("ru-RU", "мПа", PressureUnit.Millipascal)]
         [InlineData("ru-RU", "мторр", PressureUnit.Millitorr)]
@@ -1463,6 +1558,8 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Pressu
         [InlineData("en-US", PressureUnit.Microbar, "µbar")]
         [InlineData("en-US", PressureUnit.Micropascal, "µPa")]
         [InlineData("en-US", PressureUnit.Millibar, "mbar")]
+        [InlineData("en-US", PressureUnit.MilligramForcePerSquareFoot, "mgf/ft²")]
+        [InlineData("en-US", PressureUnit.MilligramForcePerSquareMeter, "mgf/m²")]
         [InlineData("en-US", PressureUnit.MillimeterOfMercury, "mmHg")]
         [InlineData("en-US", PressureUnit.MillimeterOfWaterColumn, "mmH₂O")]
         [InlineData("en-US", PressureUnit.Millipascal, "mPa")]
@@ -1502,6 +1599,7 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Pressu
         [InlineData("ru-RU", PressureUnit.Microbar, "мкбар")]
         [InlineData("ru-RU", PressureUnit.Micropascal, "мкПа")]
         [InlineData("ru-RU", PressureUnit.Millibar, "мбар")]
+        [InlineData("ru-RU", PressureUnit.MilligramForcePerSquareMeter, "мгс/м²")]
         [InlineData("ru-RU", PressureUnit.MillimeterOfMercury, "мм рт.ст.")]
         [InlineData("ru-RU", PressureUnit.Millipascal, "мПа")]
         [InlineData("ru-RU", PressureUnit.Millitorr, "мторр")]
@@ -1561,6 +1659,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(PressureUnit uni
                 var quantity = Pressure.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1584,79 +1683,83 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(PressureUnit unit)
                 IQuantity<PressureUnit> quantityToConvert = quantity;
                 IQuantity<PressureUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Pressure pascal = Pressure.FromPascals(1);
-            AssertEx.EqualTolerance(1, Pressure.FromAtmospheres(pascal.Atmospheres).Pascals, AtmospheresTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromBars(pascal.Bars).Pascals, BarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromCentibars(pascal.Centibars).Pascals, CentibarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromCentimetersOfWaterColumn(pascal.CentimetersOfWaterColumn).Pascals, CentimetersOfWaterColumnTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromDecapascals(pascal.Decapascals).Pascals, DecapascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromDecibars(pascal.Decibars).Pascals, DecibarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromDynesPerSquareCentimeter(pascal.DynesPerSquareCentimeter).Pascals, DynesPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromFeetOfHead(pascal.FeetOfHead).Pascals, FeetOfHeadTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromGigapascals(pascal.Gigapascals).Pascals, GigapascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromHectopascals(pascal.Hectopascals).Pascals, HectopascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromInchesOfMercury(pascal.InchesOfMercury).Pascals, InchesOfMercuryTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromInchesOfWaterColumn(pascal.InchesOfWaterColumn).Pascals, InchesOfWaterColumnTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilobars(pascal.Kilobars).Pascals, KilobarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilogramsForcePerSquareCentimeter(pascal.KilogramsForcePerSquareCentimeter).Pascals, KilogramsForcePerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilogramsForcePerSquareMeter(pascal.KilogramsForcePerSquareMeter).Pascals, KilogramsForcePerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilogramsForcePerSquareMillimeter(pascal.KilogramsForcePerSquareMillimeter).Pascals, KilogramsForcePerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilonewtonsPerSquareCentimeter(pascal.KilonewtonsPerSquareCentimeter).Pascals, KilonewtonsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilonewtonsPerSquareMeter(pascal.KilonewtonsPerSquareMeter).Pascals, KilonewtonsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilonewtonsPerSquareMillimeter(pascal.KilonewtonsPerSquareMillimeter).Pascals, KilonewtonsPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilopascals(pascal.Kilopascals).Pascals, KilopascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilopoundsForcePerSquareFoot(pascal.KilopoundsForcePerSquareFoot).Pascals, KilopoundsForcePerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilopoundsForcePerSquareInch(pascal.KilopoundsForcePerSquareInch).Pascals, KilopoundsForcePerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromKilopoundsForcePerSquareMil(pascal.KilopoundsForcePerSquareMil).Pascals, KilopoundsForcePerSquareMilTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMegabars(pascal.Megabars).Pascals, MegabarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMeganewtonsPerSquareMeter(pascal.MeganewtonsPerSquareMeter).Pascals, MeganewtonsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMegapascals(pascal.Megapascals).Pascals, MegapascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMetersOfHead(pascal.MetersOfHead).Pascals, MetersOfHeadTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMetersOfWaterColumn(pascal.MetersOfWaterColumn).Pascals, MetersOfWaterColumnTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMicrobars(pascal.Microbars).Pascals, MicrobarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMicropascals(pascal.Micropascals).Pascals, MicropascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMillibars(pascal.Millibars).Pascals, MillibarsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMillimetersOfMercury(pascal.MillimetersOfMercury).Pascals, MillimetersOfMercuryTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMillimetersOfWaterColumn(pascal.MillimetersOfWaterColumn).Pascals, MillimetersOfWaterColumnTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMillipascals(pascal.Millipascals).Pascals, MillipascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromMillitorrs(pascal.Millitorrs).Pascals, MillitorrsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromNewtonsPerSquareCentimeter(pascal.NewtonsPerSquareCentimeter).Pascals, NewtonsPerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromNewtonsPerSquareMeter(pascal.NewtonsPerSquareMeter).Pascals, NewtonsPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromNewtonsPerSquareMillimeter(pascal.NewtonsPerSquareMillimeter).Pascals, NewtonsPerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromPascals(pascal.Pascals).Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromPoundsForcePerSquareFoot(pascal.PoundsForcePerSquareFoot).Pascals, PoundsForcePerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromPoundsForcePerSquareInch(pascal.PoundsForcePerSquareInch).Pascals, PoundsForcePerSquareInchTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromPoundsForcePerSquareMil(pascal.PoundsForcePerSquareMil).Pascals, PoundsForcePerSquareMilTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromPoundsPerInchSecondSquared(pascal.PoundsPerInchSecondSquared).Pascals, PoundsPerInchSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromTechnicalAtmospheres(pascal.TechnicalAtmospheres).Pascals, TechnicalAtmospheresTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromTonnesForcePerSquareCentimeter(pascal.TonnesForcePerSquareCentimeter).Pascals, TonnesForcePerSquareCentimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromTonnesForcePerSquareMeter(pascal.TonnesForcePerSquareMeter).Pascals, TonnesForcePerSquareMeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromTonnesForcePerSquareMillimeter(pascal.TonnesForcePerSquareMillimeter).Pascals, TonnesForcePerSquareMillimeterTolerance);
-            AssertEx.EqualTolerance(1, Pressure.FromTorrs(pascal.Torrs).Pascals, TorrsTolerance);
+            Pressure pascal = Pressure.FromPascals(3);
+            Assert.Equal(3, Pressure.FromAtmospheres(pascal.Atmospheres).Pascals);
+            Assert.Equal(3, Pressure.FromBars(pascal.Bars).Pascals);
+            Assert.Equal(3, Pressure.FromCentibars(pascal.Centibars).Pascals);
+            Assert.Equal(3, Pressure.FromCentimetersOfWaterColumn(pascal.CentimetersOfWaterColumn).Pascals);
+            Assert.Equal(3, Pressure.FromDecapascals(pascal.Decapascals).Pascals);
+            Assert.Equal(3, Pressure.FromDecibars(pascal.Decibars).Pascals);
+            Assert.Equal(3, Pressure.FromDynesPerSquareCentimeter(pascal.DynesPerSquareCentimeter).Pascals);
+            Assert.Equal(3, Pressure.FromFeetOfHead(pascal.FeetOfHead).Pascals);
+            Assert.Equal(3, Pressure.FromGigapascals(pascal.Gigapascals).Pascals);
+            Assert.Equal(3, Pressure.FromHectopascals(pascal.Hectopascals).Pascals);
+            Assert.Equal(3, Pressure.FromInchesOfMercury(pascal.InchesOfMercury).Pascals);
+            Assert.Equal(3, Pressure.FromInchesOfWaterColumn(pascal.InchesOfWaterColumn).Pascals);
+            Assert.Equal(3, Pressure.FromKilobars(pascal.Kilobars).Pascals);
+            Assert.Equal(3, Pressure.FromKilogramsForcePerSquareCentimeter(pascal.KilogramsForcePerSquareCentimeter).Pascals);
+            Assert.Equal(3, Pressure.FromKilogramsForcePerSquareMeter(pascal.KilogramsForcePerSquareMeter).Pascals);
+            Assert.Equal(3, Pressure.FromKilogramsForcePerSquareMillimeter(pascal.KilogramsForcePerSquareMillimeter).Pascals);
+            Assert.Equal(3, Pressure.FromKilonewtonsPerSquareCentimeter(pascal.KilonewtonsPerSquareCentimeter).Pascals);
+            Assert.Equal(3, Pressure.FromKilonewtonsPerSquareMeter(pascal.KilonewtonsPerSquareMeter).Pascals);
+            Assert.Equal(3, Pressure.FromKilonewtonsPerSquareMillimeter(pascal.KilonewtonsPerSquareMillimeter).Pascals);
+            Assert.Equal(3, Pressure.FromKilopascals(pascal.Kilopascals).Pascals);
+            Assert.Equal(3, Pressure.FromKilopoundsForcePerSquareFoot(pascal.KilopoundsForcePerSquareFoot).Pascals);
+            Assert.Equal(3, Pressure.FromKilopoundsForcePerSquareInch(pascal.KilopoundsForcePerSquareInch).Pascals);
+            Assert.Equal(3, Pressure.FromKilopoundsForcePerSquareMil(pascal.KilopoundsForcePerSquareMil).Pascals);
+            Assert.Equal(3, Pressure.FromMegabars(pascal.Megabars).Pascals);
+            Assert.Equal(3, Pressure.FromMeganewtonsPerSquareMeter(pascal.MeganewtonsPerSquareMeter).Pascals);
+            Assert.Equal(3, Pressure.FromMegapascals(pascal.Megapascals).Pascals);
+            Assert.Equal(3, Pressure.FromMetersOfHead(pascal.MetersOfHead).Pascals);
+            Assert.Equal(3, Pressure.FromMetersOfWaterColumn(pascal.MetersOfWaterColumn).Pascals);
+            Assert.Equal(3, Pressure.FromMicrobars(pascal.Microbars).Pascals);
+            Assert.Equal(3, Pressure.FromMicropascals(pascal.Micropascals).Pascals);
+            Assert.Equal(3, Pressure.FromMillibars(pascal.Millibars).Pascals);
+            Assert.Equal(3, Pressure.FromMilligramsForcePerSquareFoot(pascal.MilligramsForcePerSquareFoot).Pascals);
+            Assert.Equal(3, Pressure.FromMilligramsForcePerSquareMeter(pascal.MilligramsForcePerSquareMeter).Pascals);
+            Assert.Equal(3, Pressure.FromMillimetersOfMercury(pascal.MillimetersOfMercury).Pascals);
+            Assert.Equal(3, Pressure.FromMillimetersOfWaterColumn(pascal.MillimetersOfWaterColumn).Pascals);
+            Assert.Equal(3, Pressure.FromMillipascals(pascal.Millipascals).Pascals);
+            Assert.Equal(3, Pressure.FromMillitorrs(pascal.Millitorrs).Pascals);
+            Assert.Equal(3, Pressure.FromNewtonsPerSquareCentimeter(pascal.NewtonsPerSquareCentimeter).Pascals);
+            Assert.Equal(3, Pressure.FromNewtonsPerSquareMeter(pascal.NewtonsPerSquareMeter).Pascals);
+            Assert.Equal(3, Pressure.FromNewtonsPerSquareMillimeter(pascal.NewtonsPerSquareMillimeter).Pascals);
+            Assert.Equal(3, Pressure.FromPascals(pascal.Pascals).Pascals);
+            Assert.Equal(3, Pressure.FromPoundsForcePerSquareFoot(pascal.PoundsForcePerSquareFoot).Pascals);
+            Assert.Equal(3, Pressure.FromPoundsForcePerSquareInch(pascal.PoundsForcePerSquareInch).Pascals);
+            Assert.Equal(3, Pressure.FromPoundsForcePerSquareMil(pascal.PoundsForcePerSquareMil).Pascals);
+            Assert.Equal(3, Pressure.FromPoundsPerInchSecondSquared(pascal.PoundsPerInchSecondSquared).Pascals);
+            Assert.Equal(3, Pressure.FromTechnicalAtmospheres(pascal.TechnicalAtmospheres).Pascals);
+            Assert.Equal(3, Pressure.FromTonnesForcePerSquareCentimeter(pascal.TonnesForcePerSquareCentimeter).Pascals);
+            Assert.Equal(3, Pressure.FromTonnesForcePerSquareMeter(pascal.TonnesForcePerSquareMeter).Pascals);
+            Assert.Equal(3, Pressure.FromTonnesForcePerSquareMillimeter(pascal.TonnesForcePerSquareMillimeter).Pascals);
+            Assert.Equal(3, Pressure.FromTorrs(pascal.Torrs).Pascals);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Pressure v = Pressure.FromPascals(1);
-            AssertEx.EqualTolerance(-1, -v.Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(2, (Pressure.FromPascals(3)-v).Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(2, (Pressure.FromPascals(10)/5).Pascals, PascalsTolerance);
-            AssertEx.EqualTolerance(2, Pressure.FromPascals(10)/Pressure.FromPascals(5), PascalsTolerance);
+            Assert.Equal(-1, -v.Pascals);
+            Assert.Equal(2, (Pressure.FromPascals(3) - v).Pascals);
+            Assert.Equal(2, (v + v).Pascals);
+            Assert.Equal(10, (v * 10).Pascals);
+            Assert.Equal(10, (10 * v).Pascals);
+            Assert.Equal(2, (Pressure.FromPascals(10) / 5).Pascals);
+            Assert.Equal(2, Pressure.FromPascals(10) / Pressure.FromPascals(5));
         }
 
         [Fact]
@@ -1702,8 +1805,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, PressureUnit.Pascal, 1, PressureUnit.Pascal, true)]  // Same value and unit.
         [InlineData(1, PressureUnit.Pascal, 2, PressureUnit.Pascal, false)] // Different value.
-        [InlineData(2, PressureUnit.Pascal, 1, PressureUnit.Atmosphere, false)] // Different value and unit.
-        [InlineData(1, PressureUnit.Pascal, 1, PressureUnit.Atmosphere, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, PressureUnit unitA, double valueB, PressureUnit unitB, bool expectEqual)
         {
             var a = new Pressure(valueA, unitA);
@@ -1763,8 +1864,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Pressure.FromPascals(firstValue);
             var otherQuantity = Pressure.FromPascals(secondValue);
             Pressure maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Pressure.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1783,7 +1884,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<PressureUnit>();
+            var units = EnumHelper.GetValues<PressureUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1796,6 +1897,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Pressure.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Pressure.Info.Units, Pressure.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Pressure.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1831,6 +1944,8 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
             Assert.Equal("1 µbar", new Pressure(1, PressureUnit.Microbar).ToString());
             Assert.Equal("1 µPa", new Pressure(1, PressureUnit.Micropascal).ToString());
             Assert.Equal("1 mbar", new Pressure(1, PressureUnit.Millibar).ToString());
+            Assert.Equal("1 mgf/ft²", new Pressure(1, PressureUnit.MilligramForcePerSquareFoot).ToString());
+            Assert.Equal("1 mgf/m²", new Pressure(1, PressureUnit.MilligramForcePerSquareMeter).ToString());
             Assert.Equal("1 mmHg", new Pressure(1, PressureUnit.MillimeterOfMercury).ToString());
             Assert.Equal("1 mmH₂O", new Pressure(1, PressureUnit.MillimeterOfWaterColumn).ToString());
             Assert.Equal("1 mPa", new Pressure(1, PressureUnit.Millipascal).ToString());
@@ -1887,6 +2002,8 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 µbar", new Pressure(1, PressureUnit.Microbar).ToString(swedishCulture));
             Assert.Equal("1 µPa", new Pressure(1, PressureUnit.Micropascal).ToString(swedishCulture));
             Assert.Equal("1 mbar", new Pressure(1, PressureUnit.Millibar).ToString(swedishCulture));
+            Assert.Equal("1 mgf/ft²", new Pressure(1, PressureUnit.MilligramForcePerSquareFoot).ToString(swedishCulture));
+            Assert.Equal("1 mgf/m²", new Pressure(1, PressureUnit.MilligramForcePerSquareMeter).ToString(swedishCulture));
             Assert.Equal("1 mmHg", new Pressure(1, PressureUnit.MillimeterOfMercury).ToString(swedishCulture));
             Assert.Equal("1 mmH₂O", new Pressure(1, PressureUnit.MillimeterOfWaterColumn).ToString(swedishCulture));
             Assert.Equal("1 mPa", new Pressure(1, PressureUnit.Millipascal).ToString(swedishCulture));
@@ -1906,26 +2023,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 torr", new Pressure(1, PressureUnit.Torr).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Pa", new Pressure(0.123456, PressureUnit.Pascal).ToString("s1"));
-            Assert.Equal("0.12 Pa", new Pressure(0.123456, PressureUnit.Pascal).ToString("s2"));
-            Assert.Equal("0.123 Pa", new Pressure(0.123456, PressureUnit.Pascal).ToString("s3"));
-            Assert.Equal("0.1235 Pa", new Pressure(0.123456, PressureUnit.Pascal).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Pa", new Pressure(0.123456, PressureUnit.Pascal).ToString("s1", culture));
-            Assert.Equal("0.12 Pa", new Pressure(0.123456, PressureUnit.Pascal).ToString("s2", culture));
-            Assert.Equal("0.123 Pa", new Pressure(0.123456, PressureUnit.Pascal).ToString("s3", culture));
-            Assert.Equal("0.1235 Pa", new Pressure(0.123456, PressureUnit.Pascal).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1952,7 +2049,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Pressure.FromPascals(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Pressure), quantity.As(Pressure.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseRateTestsBase.g.cs
index e0ece9c4e8..90660e7f5b 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseRateTestsBase.g.cs
@@ -161,6 +161,20 @@ public void RadiationEquivalentDoseRate_QuantityInfo_ReturnsQuantityInfoDescribi
             Assert.Equal(quantityInfo, ((IQuantity<RadiationEquivalentDoseRateUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RadiationEquivalentDoseRateInfo_CreateWithCustomUnitInfos()
+        {
+            RadiationEquivalentDoseRateUnit[] expectedUnits = [RadiationEquivalentDoseRateUnit.SievertPerSecond];
+
+            RadiationEquivalentDoseRate.RadiationEquivalentDoseRateInfo quantityInfo = RadiationEquivalentDoseRate.RadiationEquivalentDoseRateInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("RadiationEquivalentDoseRate", quantityInfo.Name);
+            Assert.Equal(RadiationEquivalentDoseRate.Zero, quantityInfo.Zero);
+            Assert.Equal(RadiationEquivalentDoseRate.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SievertPerSecondToRadiationEquivalentDoseRateUnits()
         {
@@ -263,26 +277,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = RadiationEquivalentDoseRate.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            RadiationEquivalentDoseRate convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                RadiationEquivalentDoseRate quantityToConvert = quantity;
+
+                RadiationEquivalentDoseRate convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RadiationEquivalentDoseRateUnit> quantityToConvert = quantity;
+
+                IQuantity<RadiationEquivalentDoseRateUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new RadiationEquivalentDoseRate(value: 1, unit: RadiationEquivalentDoseRate.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RadiationEquivalentDoseRate(value: 1, unit: RadiationEquivalentDoseRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<RadiationEquivalentDoseRateUnit> quantity = new RadiationEquivalentDoseRate(value: 1, unit: RadiationEquivalentDoseRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RadiationEquivalentDoseRate(value: 1, unit: RadiationEquivalentDoseRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new RadiationEquivalentDoseRate(value: 1, unit: RadiationEquivalentDoseRate.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RadiationEquivalentDoseRate(value: 1, unit: RadiationEquivalentDoseRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<RadiationEquivalentDoseRateUnit> quantity = new RadiationEquivalentDoseRate(value: 1, unit: RadiationEquivalentDoseRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RadiationEquivalentDoseRate(value: 1, unit: RadiationEquivalentDoseRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -304,7 +361,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 нЗв/с", RadiationEquivalentDoseRateUnit.NanosievertPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 Зв/ч", RadiationEquivalentDoseRateUnit.SievertPerHour, 4.2)]
         [InlineData("ru-RU", "4,2 Зв/с", RadiationEquivalentDoseRateUnit.SievertPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, RadiationEquivalentDoseRateUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RadiationEquivalentDoseRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = RadiationEquivalentDoseRate.Parse(quantityString);
@@ -331,7 +388,7 @@ public void Parse(string culture, string quantityString, RadiationEquivalentDose
         [InlineData("ru-RU", "4,2 нЗв/с", RadiationEquivalentDoseRateUnit.NanosievertPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 Зв/ч", RadiationEquivalentDoseRateUnit.SievertPerHour, 4.2)]
         [InlineData("ru-RU", "4,2 Зв/с", RadiationEquivalentDoseRateUnit.SievertPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, RadiationEquivalentDoseRateUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RadiationEquivalentDoseRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(RadiationEquivalentDoseRate.TryParse(quantityString, out RadiationEquivalentDoseRate parsed));
@@ -585,6 +642,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RadiationEquival
                 var quantity = RadiationEquivalentDoseRate.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -608,41 +666,43 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RadiationEquivalent
                 IQuantity<RadiationEquivalentDoseRateUnit> quantityToConvert = quantity;
                 IQuantity<RadiationEquivalentDoseRateUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            RadiationEquivalentDoseRate sievertpersecond = RadiationEquivalentDoseRate.FromSievertsPerSecond(1);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDoseRate.FromMicrosievertsPerHour(sievertpersecond.MicrosievertsPerHour).SievertsPerSecond, MicrosievertsPerHourTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(sievertpersecond.MicrosievertsPerSecond).SievertsPerSecond, MicrosievertsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(sievertpersecond.MilliroentgensEquivalentManPerHour).SievertsPerSecond, MilliroentgensEquivalentManPerHourTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDoseRate.FromMillisievertsPerHour(sievertpersecond.MillisievertsPerHour).SievertsPerSecond, MillisievertsPerHourTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDoseRate.FromMillisievertsPerSecond(sievertpersecond.MillisievertsPerSecond).SievertsPerSecond, MillisievertsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDoseRate.FromNanosievertsPerHour(sievertpersecond.NanosievertsPerHour).SievertsPerSecond, NanosievertsPerHourTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDoseRate.FromNanosievertsPerSecond(sievertpersecond.NanosievertsPerSecond).SievertsPerSecond, NanosievertsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(sievertpersecond.RoentgensEquivalentManPerHour).SievertsPerSecond, RoentgensEquivalentManPerHourTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDoseRate.FromSievertsPerHour(sievertpersecond.SievertsPerHour).SievertsPerSecond, SievertsPerHourTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDoseRate.FromSievertsPerSecond(sievertpersecond.SievertsPerSecond).SievertsPerSecond, SievertsPerSecondTolerance);
+            RadiationEquivalentDoseRate sievertpersecond = RadiationEquivalentDoseRate.FromSievertsPerSecond(3);
+            Assert.Equal(3, RadiationEquivalentDoseRate.FromMicrosievertsPerHour(sievertpersecond.MicrosievertsPerHour).SievertsPerSecond);
+            Assert.Equal(3, RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(sievertpersecond.MicrosievertsPerSecond).SievertsPerSecond);
+            Assert.Equal(3, RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(sievertpersecond.MilliroentgensEquivalentManPerHour).SievertsPerSecond);
+            Assert.Equal(3, RadiationEquivalentDoseRate.FromMillisievertsPerHour(sievertpersecond.MillisievertsPerHour).SievertsPerSecond);
+            Assert.Equal(3, RadiationEquivalentDoseRate.FromMillisievertsPerSecond(sievertpersecond.MillisievertsPerSecond).SievertsPerSecond);
+            Assert.Equal(3, RadiationEquivalentDoseRate.FromNanosievertsPerHour(sievertpersecond.NanosievertsPerHour).SievertsPerSecond);
+            Assert.Equal(3, RadiationEquivalentDoseRate.FromNanosievertsPerSecond(sievertpersecond.NanosievertsPerSecond).SievertsPerSecond);
+            Assert.Equal(3, RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(sievertpersecond.RoentgensEquivalentManPerHour).SievertsPerSecond);
+            Assert.Equal(3, RadiationEquivalentDoseRate.FromSievertsPerHour(sievertpersecond.SievertsPerHour).SievertsPerSecond);
+            Assert.Equal(3, RadiationEquivalentDoseRate.FromSievertsPerSecond(sievertpersecond.SievertsPerSecond).SievertsPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             RadiationEquivalentDoseRate v = RadiationEquivalentDoseRate.FromSievertsPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.SievertsPerSecond, SievertsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (RadiationEquivalentDoseRate.FromSievertsPerSecond(3)-v).SievertsPerSecond, SievertsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).SievertsPerSecond, SievertsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).SievertsPerSecond, SievertsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).SievertsPerSecond, SievertsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (RadiationEquivalentDoseRate.FromSievertsPerSecond(10)/5).SievertsPerSecond, SievertsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, RadiationEquivalentDoseRate.FromSievertsPerSecond(10)/RadiationEquivalentDoseRate.FromSievertsPerSecond(5), SievertsPerSecondTolerance);
+            Assert.Equal(-1, -v.SievertsPerSecond);
+            Assert.Equal(2, (RadiationEquivalentDoseRate.FromSievertsPerSecond(3) - v).SievertsPerSecond);
+            Assert.Equal(2, (v + v).SievertsPerSecond);
+            Assert.Equal(10, (v * 10).SievertsPerSecond);
+            Assert.Equal(10, (10 * v).SievertsPerSecond);
+            Assert.Equal(2, (RadiationEquivalentDoseRate.FromSievertsPerSecond(10) / 5).SievertsPerSecond);
+            Assert.Equal(2, RadiationEquivalentDoseRate.FromSievertsPerSecond(10) / RadiationEquivalentDoseRate.FromSievertsPerSecond(5));
         }
 
         [Fact]
@@ -688,8 +748,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RadiationEquivalentDoseRateUnit.SievertPerSecond, 1, RadiationEquivalentDoseRateUnit.SievertPerSecond, true)]  // Same value and unit.
         [InlineData(1, RadiationEquivalentDoseRateUnit.SievertPerSecond, 2, RadiationEquivalentDoseRateUnit.SievertPerSecond, false)] // Different value.
-        [InlineData(2, RadiationEquivalentDoseRateUnit.SievertPerSecond, 1, RadiationEquivalentDoseRateUnit.MicrosievertPerHour, false)] // Different value and unit.
-        [InlineData(1, RadiationEquivalentDoseRateUnit.SievertPerSecond, 1, RadiationEquivalentDoseRateUnit.MicrosievertPerHour, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RadiationEquivalentDoseRateUnit unitA, double valueB, RadiationEquivalentDoseRateUnit unitB, bool expectEqual)
         {
             var a = new RadiationEquivalentDoseRate(valueA, unitA);
@@ -749,8 +807,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = RadiationEquivalentDoseRate.FromSievertsPerSecond(firstValue);
             var otherQuantity = RadiationEquivalentDoseRate.FromSievertsPerSecond(secondValue);
             RadiationEquivalentDoseRate maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, RadiationEquivalentDoseRate.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -769,7 +827,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RadiationEquivalentDoseRateUnit>();
+            var units = EnumHelper.GetValues<RadiationEquivalentDoseRateUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -782,6 +840,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(RadiationEquivalentDoseRate.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(RadiationEquivalentDoseRate.Info.Units, RadiationEquivalentDoseRate.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, RadiationEquivalentDoseRate.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -816,26 +886,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 Sv/s", new RadiationEquivalentDoseRate(1, RadiationEquivalentDoseRateUnit.SievertPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Sv/s", new RadiationEquivalentDoseRate(0.123456, RadiationEquivalentDoseRateUnit.SievertPerSecond).ToString("s1"));
-            Assert.Equal("0.12 Sv/s", new RadiationEquivalentDoseRate(0.123456, RadiationEquivalentDoseRateUnit.SievertPerSecond).ToString("s2"));
-            Assert.Equal("0.123 Sv/s", new RadiationEquivalentDoseRate(0.123456, RadiationEquivalentDoseRateUnit.SievertPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 Sv/s", new RadiationEquivalentDoseRate(0.123456, RadiationEquivalentDoseRateUnit.SievertPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Sv/s", new RadiationEquivalentDoseRate(0.123456, RadiationEquivalentDoseRateUnit.SievertPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 Sv/s", new RadiationEquivalentDoseRate(0.123456, RadiationEquivalentDoseRateUnit.SievertPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 Sv/s", new RadiationEquivalentDoseRate(0.123456, RadiationEquivalentDoseRateUnit.SievertPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 Sv/s", new RadiationEquivalentDoseRate(0.123456, RadiationEquivalentDoseRateUnit.SievertPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -862,7 +912,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = RadiationEquivalentDoseRate.FromSievertsPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(RadiationEquivalentDoseRate), quantity.As(RadiationEquivalentDoseRate.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseTestsBase.g.cs
index 829adc0123..0fcc4ddc7f 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationEquivalentDoseTestsBase.g.cs
@@ -145,6 +145,20 @@ public void RadiationEquivalentDose_QuantityInfo_ReturnsQuantityInfoDescribingQu
             Assert.Equal(quantityInfo, ((IQuantity<RadiationEquivalentDoseUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RadiationEquivalentDoseInfo_CreateWithCustomUnitInfos()
+        {
+            RadiationEquivalentDoseUnit[] expectedUnits = [RadiationEquivalentDoseUnit.Sievert];
+
+            RadiationEquivalentDose.RadiationEquivalentDoseInfo quantityInfo = RadiationEquivalentDose.RadiationEquivalentDoseInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("RadiationEquivalentDose", quantityInfo.Name);
+            Assert.Equal(RadiationEquivalentDose.Zero, quantityInfo.Zero);
+            Assert.Equal(RadiationEquivalentDose.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SievertToRadiationEquivalentDoseUnits()
         {
@@ -239,26 +253,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = RadiationEquivalentDose.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            RadiationEquivalentDose convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                RadiationEquivalentDose quantityToConvert = quantity;
+
+                RadiationEquivalentDose convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RadiationEquivalentDoseUnit> quantityToConvert = quantity;
+
+                IQuantity<RadiationEquivalentDoseUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new RadiationEquivalentDose(value: 1, unit: RadiationEquivalentDose.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RadiationEquivalentDose(value: 1, unit: RadiationEquivalentDose.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<RadiationEquivalentDoseUnit> quantity = new RadiationEquivalentDose(value: 1, unit: RadiationEquivalentDose.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RadiationEquivalentDose(value: 1, unit: RadiationEquivalentDose.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new RadiationEquivalentDose(value: 1, unit: RadiationEquivalentDose.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RadiationEquivalentDose(value: 1, unit: RadiationEquivalentDose.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<RadiationEquivalentDoseUnit> quantity = new RadiationEquivalentDose(value: 1, unit: RadiationEquivalentDose.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RadiationEquivalentDose(value: 1, unit: RadiationEquivalentDose.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -272,7 +329,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 мЗв", RadiationEquivalentDoseUnit.Millisievert, 4.2)]
         [InlineData("ru-RU", "4,2 нЗв", RadiationEquivalentDoseUnit.Nanosievert, 4.2)]
         [InlineData("ru-RU", "4,2 Зв", RadiationEquivalentDoseUnit.Sievert, 4.2)]
-        public void Parse(string culture, string quantityString, RadiationEquivalentDoseUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RadiationEquivalentDoseUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = RadiationEquivalentDose.Parse(quantityString);
@@ -291,7 +348,7 @@ public void Parse(string culture, string quantityString, RadiationEquivalentDose
         [InlineData("ru-RU", "4,2 мЗв", RadiationEquivalentDoseUnit.Millisievert, 4.2)]
         [InlineData("ru-RU", "4,2 нЗв", RadiationEquivalentDoseUnit.Nanosievert, 4.2)]
         [InlineData("ru-RU", "4,2 Зв", RadiationEquivalentDoseUnit.Sievert, 4.2)]
-        public void TryParse(string culture, string quantityString, RadiationEquivalentDoseUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RadiationEquivalentDoseUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(RadiationEquivalentDose.TryParse(quantityString, out RadiationEquivalentDose parsed));
@@ -489,6 +546,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RadiationEquival
                 var quantity = RadiationEquivalentDose.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -512,37 +570,39 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RadiationEquivalent
                 IQuantity<RadiationEquivalentDoseUnit> quantityToConvert = quantity;
                 IQuantity<RadiationEquivalentDoseUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            RadiationEquivalentDose sievert = RadiationEquivalentDose.FromSieverts(1);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDose.FromMicrosieverts(sievert.Microsieverts).Sieverts, MicrosievertsTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDose.FromMilliroentgensEquivalentMan(sievert.MilliroentgensEquivalentMan).Sieverts, MilliroentgensEquivalentManTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDose.FromMillisieverts(sievert.Millisieverts).Sieverts, MillisievertsTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDose.FromNanosieverts(sievert.Nanosieverts).Sieverts, NanosievertsTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDose.FromRoentgensEquivalentMan(sievert.RoentgensEquivalentMan).Sieverts, RoentgensEquivalentManTolerance);
-            AssertEx.EqualTolerance(1, RadiationEquivalentDose.FromSieverts(sievert.Sieverts).Sieverts, SievertsTolerance);
+            RadiationEquivalentDose sievert = RadiationEquivalentDose.FromSieverts(3);
+            Assert.Equal(3, RadiationEquivalentDose.FromMicrosieverts(sievert.Microsieverts).Sieverts);
+            Assert.Equal(3, RadiationEquivalentDose.FromMilliroentgensEquivalentMan(sievert.MilliroentgensEquivalentMan).Sieverts);
+            Assert.Equal(3, RadiationEquivalentDose.FromMillisieverts(sievert.Millisieverts).Sieverts);
+            Assert.Equal(3, RadiationEquivalentDose.FromNanosieverts(sievert.Nanosieverts).Sieverts);
+            Assert.Equal(3, RadiationEquivalentDose.FromRoentgensEquivalentMan(sievert.RoentgensEquivalentMan).Sieverts);
+            Assert.Equal(3, RadiationEquivalentDose.FromSieverts(sievert.Sieverts).Sieverts);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             RadiationEquivalentDose v = RadiationEquivalentDose.FromSieverts(1);
-            AssertEx.EqualTolerance(-1, -v.Sieverts, SievertsTolerance);
-            AssertEx.EqualTolerance(2, (RadiationEquivalentDose.FromSieverts(3)-v).Sieverts, SievertsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Sieverts, SievertsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Sieverts, SievertsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Sieverts, SievertsTolerance);
-            AssertEx.EqualTolerance(2, (RadiationEquivalentDose.FromSieverts(10)/5).Sieverts, SievertsTolerance);
-            AssertEx.EqualTolerance(2, RadiationEquivalentDose.FromSieverts(10)/RadiationEquivalentDose.FromSieverts(5), SievertsTolerance);
+            Assert.Equal(-1, -v.Sieverts);
+            Assert.Equal(2, (RadiationEquivalentDose.FromSieverts(3) - v).Sieverts);
+            Assert.Equal(2, (v + v).Sieverts);
+            Assert.Equal(10, (v * 10).Sieverts);
+            Assert.Equal(10, (10 * v).Sieverts);
+            Assert.Equal(2, (RadiationEquivalentDose.FromSieverts(10) / 5).Sieverts);
+            Assert.Equal(2, RadiationEquivalentDose.FromSieverts(10) / RadiationEquivalentDose.FromSieverts(5));
         }
 
         [Fact]
@@ -588,8 +648,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RadiationEquivalentDoseUnit.Sievert, 1, RadiationEquivalentDoseUnit.Sievert, true)]  // Same value and unit.
         [InlineData(1, RadiationEquivalentDoseUnit.Sievert, 2, RadiationEquivalentDoseUnit.Sievert, false)] // Different value.
-        [InlineData(2, RadiationEquivalentDoseUnit.Sievert, 1, RadiationEquivalentDoseUnit.Microsievert, false)] // Different value and unit.
-        [InlineData(1, RadiationEquivalentDoseUnit.Sievert, 1, RadiationEquivalentDoseUnit.Microsievert, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RadiationEquivalentDoseUnit unitA, double valueB, RadiationEquivalentDoseUnit unitB, bool expectEqual)
         {
             var a = new RadiationEquivalentDose(valueA, unitA);
@@ -649,8 +707,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = RadiationEquivalentDose.FromSieverts(firstValue);
             var otherQuantity = RadiationEquivalentDose.FromSieverts(secondValue);
             RadiationEquivalentDose maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, RadiationEquivalentDose.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -669,7 +727,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RadiationEquivalentDoseUnit>();
+            var units = EnumHelper.GetValues<RadiationEquivalentDoseUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -682,6 +740,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(RadiationEquivalentDose.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(RadiationEquivalentDose.Info.Units, RadiationEquivalentDose.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, RadiationEquivalentDose.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -708,26 +778,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 Sv", new RadiationEquivalentDose(1, RadiationEquivalentDoseUnit.Sievert).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Sv", new RadiationEquivalentDose(0.123456, RadiationEquivalentDoseUnit.Sievert).ToString("s1"));
-            Assert.Equal("0.12 Sv", new RadiationEquivalentDose(0.123456, RadiationEquivalentDoseUnit.Sievert).ToString("s2"));
-            Assert.Equal("0.123 Sv", new RadiationEquivalentDose(0.123456, RadiationEquivalentDoseUnit.Sievert).ToString("s3"));
-            Assert.Equal("0.1235 Sv", new RadiationEquivalentDose(0.123456, RadiationEquivalentDoseUnit.Sievert).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Sv", new RadiationEquivalentDose(0.123456, RadiationEquivalentDoseUnit.Sievert).ToString("s1", culture));
-            Assert.Equal("0.12 Sv", new RadiationEquivalentDose(0.123456, RadiationEquivalentDoseUnit.Sievert).ToString("s2", culture));
-            Assert.Equal("0.123 Sv", new RadiationEquivalentDose(0.123456, RadiationEquivalentDoseUnit.Sievert).ToString("s3", culture));
-            Assert.Equal("0.1235 Sv", new RadiationEquivalentDose(0.123456, RadiationEquivalentDoseUnit.Sievert).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -754,7 +804,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = RadiationEquivalentDose.FromSieverts(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(RadiationEquivalentDose), quantity.As(RadiationEquivalentDose.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationExposureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationExposureTestsBase.g.cs
index e517befb98..4e376d0f88 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationExposureTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RadiationExposureTestsBase.g.cs
@@ -153,6 +153,20 @@ public void RadiationExposure_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
             Assert.Equal(quantityInfo, ((IQuantity<RadiationExposureUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RadiationExposureInfo_CreateWithCustomUnitInfos()
+        {
+            RadiationExposureUnit[] expectedUnits = [RadiationExposureUnit.CoulombPerKilogram];
+
+            RadiationExposure.RadiationExposureInfo quantityInfo = RadiationExposure.RadiationExposureInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("RadiationExposure", quantityInfo.Name);
+            Assert.Equal(RadiationExposure.Zero, quantityInfo.Zero);
+            Assert.Equal(RadiationExposure.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CoulombPerKilogramToRadiationExposureUnits()
         {
@@ -251,26 +265,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = RadiationExposure.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            RadiationExposure convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                RadiationExposure quantityToConvert = quantity;
+
+                RadiationExposure convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RadiationExposureUnit> quantityToConvert = quantity;
+
+                IQuantity<RadiationExposureUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new RadiationExposure(value: 1, unit: RadiationExposure.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RadiationExposure(value: 1, unit: RadiationExposure.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<RadiationExposureUnit> quantity = new RadiationExposure(value: 1, unit: RadiationExposure.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RadiationExposure(value: 1, unit: RadiationExposure.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new RadiationExposure(value: 1, unit: RadiationExposure.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RadiationExposure(value: 1, unit: RadiationExposure.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<RadiationExposureUnit> quantity = new RadiationExposure(value: 1, unit: RadiationExposure.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RadiationExposure(value: 1, unit: RadiationExposure.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -282,7 +339,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 nC/kg", RadiationExposureUnit.NanocoulombPerKilogram, 4.2)]
         [InlineData("en-US", "4.2 pC/kg", RadiationExposureUnit.PicocoulombPerKilogram, 4.2)]
         [InlineData("en-US", "4.2 R", RadiationExposureUnit.Roentgen, 4.2)]
-        public void Parse(string culture, string quantityString, RadiationExposureUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RadiationExposureUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = RadiationExposure.Parse(quantityString);
@@ -299,7 +356,7 @@ public void Parse(string culture, string quantityString, RadiationExposureUnit e
         [InlineData("en-US", "4.2 nC/kg", RadiationExposureUnit.NanocoulombPerKilogram, 4.2)]
         [InlineData("en-US", "4.2 pC/kg", RadiationExposureUnit.PicocoulombPerKilogram, 4.2)]
         [InlineData("en-US", "4.2 R", RadiationExposureUnit.Roentgen, 4.2)]
-        public void TryParse(string culture, string quantityString, RadiationExposureUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RadiationExposureUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(RadiationExposure.TryParse(quantityString, out RadiationExposure parsed));
@@ -495,6 +552,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RadiationExposur
                 var quantity = RadiationExposure.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -518,39 +576,41 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RadiationExposureUn
                 IQuantity<RadiationExposureUnit> quantityToConvert = quantity;
                 IQuantity<RadiationExposureUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            RadiationExposure coulombperkilogram = RadiationExposure.FromCoulombsPerKilogram(1);
-            AssertEx.EqualTolerance(1, RadiationExposure.FromCoulombsPerKilogram(coulombperkilogram.CoulombsPerKilogram).CoulombsPerKilogram, CoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, RadiationExposure.FromMicrocoulombsPerKilogram(coulombperkilogram.MicrocoulombsPerKilogram).CoulombsPerKilogram, MicrocoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, RadiationExposure.FromMicroroentgens(coulombperkilogram.Microroentgens).CoulombsPerKilogram, MicroroentgensTolerance);
-            AssertEx.EqualTolerance(1, RadiationExposure.FromMillicoulombsPerKilogram(coulombperkilogram.MillicoulombsPerKilogram).CoulombsPerKilogram, MillicoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, RadiationExposure.FromMilliroentgens(coulombperkilogram.Milliroentgens).CoulombsPerKilogram, MilliroentgensTolerance);
-            AssertEx.EqualTolerance(1, RadiationExposure.FromNanocoulombsPerKilogram(coulombperkilogram.NanocoulombsPerKilogram).CoulombsPerKilogram, NanocoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, RadiationExposure.FromPicocoulombsPerKilogram(coulombperkilogram.PicocoulombsPerKilogram).CoulombsPerKilogram, PicocoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, RadiationExposure.FromRoentgens(coulombperkilogram.Roentgens).CoulombsPerKilogram, RoentgensTolerance);
+            RadiationExposure coulombperkilogram = RadiationExposure.FromCoulombsPerKilogram(3);
+            Assert.Equal(3, RadiationExposure.FromCoulombsPerKilogram(coulombperkilogram.CoulombsPerKilogram).CoulombsPerKilogram);
+            Assert.Equal(3, RadiationExposure.FromMicrocoulombsPerKilogram(coulombperkilogram.MicrocoulombsPerKilogram).CoulombsPerKilogram);
+            Assert.Equal(3, RadiationExposure.FromMicroroentgens(coulombperkilogram.Microroentgens).CoulombsPerKilogram);
+            Assert.Equal(3, RadiationExposure.FromMillicoulombsPerKilogram(coulombperkilogram.MillicoulombsPerKilogram).CoulombsPerKilogram);
+            Assert.Equal(3, RadiationExposure.FromMilliroentgens(coulombperkilogram.Milliroentgens).CoulombsPerKilogram);
+            Assert.Equal(3, RadiationExposure.FromNanocoulombsPerKilogram(coulombperkilogram.NanocoulombsPerKilogram).CoulombsPerKilogram);
+            Assert.Equal(3, RadiationExposure.FromPicocoulombsPerKilogram(coulombperkilogram.PicocoulombsPerKilogram).CoulombsPerKilogram);
+            Assert.Equal(3, RadiationExposure.FromRoentgens(coulombperkilogram.Roentgens).CoulombsPerKilogram);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             RadiationExposure v = RadiationExposure.FromCoulombsPerKilogram(1);
-            AssertEx.EqualTolerance(-1, -v.CoulombsPerKilogram, CoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (RadiationExposure.FromCoulombsPerKilogram(3)-v).CoulombsPerKilogram, CoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (v + v).CoulombsPerKilogram, CoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(10, (v*10).CoulombsPerKilogram, CoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(10, (10*v).CoulombsPerKilogram, CoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (RadiationExposure.FromCoulombsPerKilogram(10)/5).CoulombsPerKilogram, CoulombsPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, RadiationExposure.FromCoulombsPerKilogram(10)/RadiationExposure.FromCoulombsPerKilogram(5), CoulombsPerKilogramTolerance);
+            Assert.Equal(-1, -v.CoulombsPerKilogram);
+            Assert.Equal(2, (RadiationExposure.FromCoulombsPerKilogram(3) - v).CoulombsPerKilogram);
+            Assert.Equal(2, (v + v).CoulombsPerKilogram);
+            Assert.Equal(10, (v * 10).CoulombsPerKilogram);
+            Assert.Equal(10, (10 * v).CoulombsPerKilogram);
+            Assert.Equal(2, (RadiationExposure.FromCoulombsPerKilogram(10) / 5).CoulombsPerKilogram);
+            Assert.Equal(2, RadiationExposure.FromCoulombsPerKilogram(10) / RadiationExposure.FromCoulombsPerKilogram(5));
         }
 
         [Fact]
@@ -596,8 +656,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RadiationExposureUnit.CoulombPerKilogram, 1, RadiationExposureUnit.CoulombPerKilogram, true)]  // Same value and unit.
         [InlineData(1, RadiationExposureUnit.CoulombPerKilogram, 2, RadiationExposureUnit.CoulombPerKilogram, false)] // Different value.
-        [InlineData(2, RadiationExposureUnit.CoulombPerKilogram, 1, RadiationExposureUnit.MicrocoulombPerKilogram, false)] // Different value and unit.
-        [InlineData(1, RadiationExposureUnit.CoulombPerKilogram, 1, RadiationExposureUnit.MicrocoulombPerKilogram, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RadiationExposureUnit unitA, double valueB, RadiationExposureUnit unitB, bool expectEqual)
         {
             var a = new RadiationExposure(valueA, unitA);
@@ -657,8 +715,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = RadiationExposure.FromCoulombsPerKilogram(firstValue);
             var otherQuantity = RadiationExposure.FromCoulombsPerKilogram(secondValue);
             RadiationExposure maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, RadiationExposure.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -677,7 +735,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RadiationExposureUnit>();
+            var units = EnumHelper.GetValues<RadiationExposureUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -690,6 +748,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(RadiationExposure.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(RadiationExposure.Info.Units, RadiationExposure.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, RadiationExposure.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -720,26 +790,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 R", new RadiationExposure(1, RadiationExposureUnit.Roentgen).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 C/kg", new RadiationExposure(0.123456, RadiationExposureUnit.CoulombPerKilogram).ToString("s1"));
-            Assert.Equal("0.12 C/kg", new RadiationExposure(0.123456, RadiationExposureUnit.CoulombPerKilogram).ToString("s2"));
-            Assert.Equal("0.123 C/kg", new RadiationExposure(0.123456, RadiationExposureUnit.CoulombPerKilogram).ToString("s3"));
-            Assert.Equal("0.1235 C/kg", new RadiationExposure(0.123456, RadiationExposureUnit.CoulombPerKilogram).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 C/kg", new RadiationExposure(0.123456, RadiationExposureUnit.CoulombPerKilogram).ToString("s1", culture));
-            Assert.Equal("0.12 C/kg", new RadiationExposure(0.123456, RadiationExposureUnit.CoulombPerKilogram).ToString("s2", culture));
-            Assert.Equal("0.123 C/kg", new RadiationExposure(0.123456, RadiationExposureUnit.CoulombPerKilogram).ToString("s3", culture));
-            Assert.Equal("0.1235 C/kg", new RadiationExposure(0.123456, RadiationExposureUnit.CoulombPerKilogram).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -766,7 +816,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = RadiationExposure.FromCoulombsPerKilogram(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(RadiationExposure), quantity.As(RadiationExposure.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RadioactivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RadioactivityTestsBase.g.cs
index 54161e1834..c1fea080c2 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RadioactivityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RadioactivityTestsBase.g.cs
@@ -237,6 +237,20 @@ public void Radioactivity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<RadioactivityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RadioactivityInfo_CreateWithCustomUnitInfos()
+        {
+            RadioactivityUnit[] expectedUnits = [RadioactivityUnit.Becquerel];
+
+            Radioactivity.RadioactivityInfo quantityInfo = Radioactivity.RadioactivityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Radioactivity", quantityInfo.Name);
+            Assert.Equal(Radioactivity.Zero, quantityInfo.Zero);
+            Assert.Equal(Radioactivity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void BecquerelToRadioactivityUnits()
         {
@@ -377,26 +391,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Radioactivity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Radioactivity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Radioactivity quantityToConvert = quantity;
+
+                Radioactivity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RadioactivityUnit> quantityToConvert = quantity;
+
+                IQuantity<RadioactivityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Radioactivity(value: 1, unit: Radioactivity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Radioactivity(value: 1, unit: Radioactivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<RadioactivityUnit> quantity = new Radioactivity(value: 1, unit: Radioactivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Radioactivity(value: 1, unit: Radioactivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Radioactivity(value: 1, unit: Radioactivity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Radioactivity(value: 1, unit: Radioactivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<RadioactivityUnit> quantity = new Radioactivity(value: 1, unit: Radioactivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Radioactivity(value: 1, unit: Radioactivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -458,7 +515,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 ТБк", RadioactivityUnit.Terabecquerel, 4.2)]
         [InlineData("ru-RU", "4,2 ТКи", RadioactivityUnit.Teracurie, 4.2)]
         [InlineData("ru-RU", "4,2 ТРд", RadioactivityUnit.Terarutherford, 4.2)]
-        public void Parse(string culture, string quantityString, RadioactivityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RadioactivityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Radioactivity.Parse(quantityString);
@@ -525,7 +582,7 @@ public void Parse(string culture, string quantityString, RadioactivityUnit expec
         [InlineData("ru-RU", "4,2 ТБк", RadioactivityUnit.Terabecquerel, 4.2)]
         [InlineData("ru-RU", "4,2 ТКи", RadioactivityUnit.Teracurie, 4.2)]
         [InlineData("ru-RU", "4,2 ТРд", RadioactivityUnit.Terarutherford, 4.2)]
-        public void TryParse(string culture, string quantityString, RadioactivityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RadioactivityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Radioactivity.TryParse(quantityString, out Radioactivity parsed));
@@ -1055,6 +1112,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RadioactivityUni
                 var quantity = Radioactivity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1078,60 +1136,62 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RadioactivityUnit u
                 IQuantity<RadioactivityUnit> quantityToConvert = quantity;
                 IQuantity<RadioactivityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Radioactivity becquerel = Radioactivity.FromBecquerels(1);
-            AssertEx.EqualTolerance(1, Radioactivity.FromBecquerels(becquerel.Becquerels).Becquerels, BecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromCuries(becquerel.Curies).Becquerels, CuriesTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromExabecquerels(becquerel.Exabecquerels).Becquerels, ExabecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromGigabecquerels(becquerel.Gigabecquerels).Becquerels, GigabecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromGigacuries(becquerel.Gigacuries).Becquerels, GigacuriesTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromGigarutherfords(becquerel.Gigarutherfords).Becquerels, GigarutherfordsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromKilobecquerels(becquerel.Kilobecquerels).Becquerels, KilobecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromKilocuries(becquerel.Kilocuries).Becquerels, KilocuriesTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromKilorutherfords(becquerel.Kilorutherfords).Becquerels, KilorutherfordsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromMegabecquerels(becquerel.Megabecquerels).Becquerels, MegabecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromMegacuries(becquerel.Megacuries).Becquerels, MegacuriesTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromMegarutherfords(becquerel.Megarutherfords).Becquerels, MegarutherfordsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromMicrobecquerels(becquerel.Microbecquerels).Becquerels, MicrobecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromMicrocuries(becquerel.Microcuries).Becquerels, MicrocuriesTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromMicrorutherfords(becquerel.Microrutherfords).Becquerels, MicrorutherfordsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromMillibecquerels(becquerel.Millibecquerels).Becquerels, MillibecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromMillicuries(becquerel.Millicuries).Becquerels, MillicuriesTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromMillirutherfords(becquerel.Millirutherfords).Becquerels, MillirutherfordsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromNanobecquerels(becquerel.Nanobecquerels).Becquerels, NanobecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromNanocuries(becquerel.Nanocuries).Becquerels, NanocuriesTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromNanorutherfords(becquerel.Nanorutherfords).Becquerels, NanorutherfordsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromPetabecquerels(becquerel.Petabecquerels).Becquerels, PetabecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromPicobecquerels(becquerel.Picobecquerels).Becquerels, PicobecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromPicocuries(becquerel.Picocuries).Becquerels, PicocuriesTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromPicorutherfords(becquerel.Picorutherfords).Becquerels, PicorutherfordsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromRutherfords(becquerel.Rutherfords).Becquerels, RutherfordsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromTerabecquerels(becquerel.Terabecquerels).Becquerels, TerabecquerelsTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromTeracuries(becquerel.Teracuries).Becquerels, TeracuriesTolerance);
-            AssertEx.EqualTolerance(1, Radioactivity.FromTerarutherfords(becquerel.Terarutherfords).Becquerels, TerarutherfordsTolerance);
+            Radioactivity becquerel = Radioactivity.FromBecquerels(3);
+            Assert.Equal(3, Radioactivity.FromBecquerels(becquerel.Becquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromCuries(becquerel.Curies).Becquerels);
+            Assert.Equal(3, Radioactivity.FromExabecquerels(becquerel.Exabecquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromGigabecquerels(becquerel.Gigabecquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromGigacuries(becquerel.Gigacuries).Becquerels);
+            Assert.Equal(3, Radioactivity.FromGigarutherfords(becquerel.Gigarutherfords).Becquerels);
+            Assert.Equal(3, Radioactivity.FromKilobecquerels(becquerel.Kilobecquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromKilocuries(becquerel.Kilocuries).Becquerels);
+            Assert.Equal(3, Radioactivity.FromKilorutherfords(becquerel.Kilorutherfords).Becquerels);
+            Assert.Equal(3, Radioactivity.FromMegabecquerels(becquerel.Megabecquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromMegacuries(becquerel.Megacuries).Becquerels);
+            Assert.Equal(3, Radioactivity.FromMegarutherfords(becquerel.Megarutherfords).Becquerels);
+            Assert.Equal(3, Radioactivity.FromMicrobecquerels(becquerel.Microbecquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromMicrocuries(becquerel.Microcuries).Becquerels);
+            Assert.Equal(3, Radioactivity.FromMicrorutherfords(becquerel.Microrutherfords).Becquerels);
+            Assert.Equal(3, Radioactivity.FromMillibecquerels(becquerel.Millibecquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromMillicuries(becquerel.Millicuries).Becquerels);
+            Assert.Equal(3, Radioactivity.FromMillirutherfords(becquerel.Millirutherfords).Becquerels);
+            Assert.Equal(3, Radioactivity.FromNanobecquerels(becquerel.Nanobecquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromNanocuries(becquerel.Nanocuries).Becquerels);
+            Assert.Equal(3, Radioactivity.FromNanorutherfords(becquerel.Nanorutherfords).Becquerels);
+            Assert.Equal(3, Radioactivity.FromPetabecquerels(becquerel.Petabecquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromPicobecquerels(becquerel.Picobecquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromPicocuries(becquerel.Picocuries).Becquerels);
+            Assert.Equal(3, Radioactivity.FromPicorutherfords(becquerel.Picorutherfords).Becquerels);
+            Assert.Equal(3, Radioactivity.FromRutherfords(becquerel.Rutherfords).Becquerels);
+            Assert.Equal(3, Radioactivity.FromTerabecquerels(becquerel.Terabecquerels).Becquerels);
+            Assert.Equal(3, Radioactivity.FromTeracuries(becquerel.Teracuries).Becquerels);
+            Assert.Equal(3, Radioactivity.FromTerarutherfords(becquerel.Terarutherfords).Becquerels);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Radioactivity v = Radioactivity.FromBecquerels(1);
-            AssertEx.EqualTolerance(-1, -v.Becquerels, BecquerelsTolerance);
-            AssertEx.EqualTolerance(2, (Radioactivity.FromBecquerels(3)-v).Becquerels, BecquerelsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Becquerels, BecquerelsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Becquerels, BecquerelsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Becquerels, BecquerelsTolerance);
-            AssertEx.EqualTolerance(2, (Radioactivity.FromBecquerels(10)/5).Becquerels, BecquerelsTolerance);
-            AssertEx.EqualTolerance(2, Radioactivity.FromBecquerels(10)/Radioactivity.FromBecquerels(5), BecquerelsTolerance);
+            Assert.Equal(-1, -v.Becquerels);
+            Assert.Equal(2, (Radioactivity.FromBecquerels(3) - v).Becquerels);
+            Assert.Equal(2, (v + v).Becquerels);
+            Assert.Equal(10, (v * 10).Becquerels);
+            Assert.Equal(10, (10 * v).Becquerels);
+            Assert.Equal(2, (Radioactivity.FromBecquerels(10) / 5).Becquerels);
+            Assert.Equal(2, Radioactivity.FromBecquerels(10) / Radioactivity.FromBecquerels(5));
         }
 
         [Fact]
@@ -1177,8 +1237,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RadioactivityUnit.Becquerel, 1, RadioactivityUnit.Becquerel, true)]  // Same value and unit.
         [InlineData(1, RadioactivityUnit.Becquerel, 2, RadioactivityUnit.Becquerel, false)] // Different value.
-        [InlineData(2, RadioactivityUnit.Becquerel, 1, RadioactivityUnit.Curie, false)] // Different value and unit.
-        [InlineData(1, RadioactivityUnit.Becquerel, 1, RadioactivityUnit.Curie, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RadioactivityUnit unitA, double valueB, RadioactivityUnit unitB, bool expectEqual)
         {
             var a = new Radioactivity(valueA, unitA);
@@ -1238,8 +1296,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Radioactivity.FromBecquerels(firstValue);
             var otherQuantity = Radioactivity.FromBecquerels(secondValue);
             Radioactivity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Radioactivity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1258,7 +1316,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RadioactivityUnit>();
+            var units = EnumHelper.GetValues<RadioactivityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1271,6 +1329,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Radioactivity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Radioactivity.Info.Units, Radioactivity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Radioactivity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1343,26 +1413,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 TRd", new Radioactivity(1, RadioactivityUnit.Terarutherford).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Bq", new Radioactivity(0.123456, RadioactivityUnit.Becquerel).ToString("s1"));
-            Assert.Equal("0.12 Bq", new Radioactivity(0.123456, RadioactivityUnit.Becquerel).ToString("s2"));
-            Assert.Equal("0.123 Bq", new Radioactivity(0.123456, RadioactivityUnit.Becquerel).ToString("s3"));
-            Assert.Equal("0.1235 Bq", new Radioactivity(0.123456, RadioactivityUnit.Becquerel).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Bq", new Radioactivity(0.123456, RadioactivityUnit.Becquerel).ToString("s1", culture));
-            Assert.Equal("0.12 Bq", new Radioactivity(0.123456, RadioactivityUnit.Becquerel).ToString("s2", culture));
-            Assert.Equal("0.123 Bq", new Radioactivity(0.123456, RadioactivityUnit.Becquerel).ToString("s3", culture));
-            Assert.Equal("0.1235 Bq", new Radioactivity(0.123456, RadioactivityUnit.Becquerel).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1389,7 +1439,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Radioactivity.FromBecquerels(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Radioactivity), quantity.As(Radioactivity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RatioChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RatioChangeRateTestsBase.g.cs
index 31d7ddf70a..b0fefde7d4 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RatioChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RatioChangeRateTestsBase.g.cs
@@ -129,6 +129,20 @@ public void RatioChangeRate_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<RatioChangeRateUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RatioChangeRateInfo_CreateWithCustomUnitInfos()
+        {
+            RatioChangeRateUnit[] expectedUnits = [RatioChangeRateUnit.DecimalFractionPerSecond];
+
+            RatioChangeRate.RatioChangeRateInfo quantityInfo = RatioChangeRate.RatioChangeRateInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("RatioChangeRate", quantityInfo.Name);
+            Assert.Equal(RatioChangeRate.Zero, quantityInfo.Zero);
+            Assert.Equal(RatioChangeRate.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void DecimalFractionPerSecondToRatioChangeRateUnits()
         {
@@ -215,32 +229,75 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = RatioChangeRate.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            RatioChangeRate convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                RatioChangeRate quantityToConvert = quantity;
+
+                RatioChangeRate convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RatioChangeRateUnit> quantityToConvert = quantity;
+
+                IQuantity<RatioChangeRateUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new RatioChangeRate(value: 1, unit: RatioChangeRate.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RatioChangeRate(value: 1, unit: RatioChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<RatioChangeRateUnit> quantity = new RatioChangeRate(value: 1, unit: RatioChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RatioChangeRate(value: 1, unit: RatioChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new RatioChangeRate(value: 1, unit: RatioChangeRate.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RatioChangeRate(value: 1, unit: RatioChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<RatioChangeRateUnit> quantity = new RatioChangeRate(value: 1, unit: RatioChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RatioChangeRate(value: 1, unit: RatioChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 /s", RatioChangeRateUnit.DecimalFractionPerSecond, 4.2)]
         [InlineData("en-US", "4.2 %/s", RatioChangeRateUnit.PercentPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, RatioChangeRateUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RatioChangeRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = RatioChangeRate.Parse(quantityString);
@@ -251,7 +308,7 @@ public void Parse(string culture, string quantityString, RatioChangeRateUnit exp
         [Theory]
         [InlineData("en-US", "4.2 /s", RatioChangeRateUnit.DecimalFractionPerSecond, 4.2)]
         [InlineData("en-US", "4.2 %/s", RatioChangeRateUnit.PercentPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, RatioChangeRateUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RatioChangeRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(RatioChangeRate.TryParse(quantityString, out RatioChangeRate parsed));
@@ -393,6 +450,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RatioChangeRateU
                 var quantity = RatioChangeRate.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -416,33 +474,35 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RatioChangeRateUnit
                 IQuantity<RatioChangeRateUnit> quantityToConvert = quantity;
                 IQuantity<RatioChangeRateUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            RatioChangeRate decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(1);
-            AssertEx.EqualTolerance(1, RatioChangeRate.FromDecimalFractionsPerSecond(decimalfractionpersecond.DecimalFractionsPerSecond).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RatioChangeRate.FromPercentsPerSecond(decimalfractionpersecond.PercentsPerSecond).DecimalFractionsPerSecond, PercentsPerSecondTolerance);
+            RatioChangeRate decimalfractionpersecond = RatioChangeRate.FromDecimalFractionsPerSecond(3);
+            Assert.Equal(3, RatioChangeRate.FromDecimalFractionsPerSecond(decimalfractionpersecond.DecimalFractionsPerSecond).DecimalFractionsPerSecond);
+            Assert.Equal(3, RatioChangeRate.FromPercentsPerSecond(decimalfractionpersecond.PercentsPerSecond).DecimalFractionsPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             RatioChangeRate v = RatioChangeRate.FromDecimalFractionsPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (RatioChangeRate.FromDecimalFractionsPerSecond(3)-v).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (RatioChangeRate.FromDecimalFractionsPerSecond(10)/5).DecimalFractionsPerSecond, DecimalFractionsPerSecondTolerance);
-            AssertEx.EqualTolerance(2, RatioChangeRate.FromDecimalFractionsPerSecond(10)/RatioChangeRate.FromDecimalFractionsPerSecond(5), DecimalFractionsPerSecondTolerance);
+            Assert.Equal(-1, -v.DecimalFractionsPerSecond);
+            Assert.Equal(2, (RatioChangeRate.FromDecimalFractionsPerSecond(3) - v).DecimalFractionsPerSecond);
+            Assert.Equal(2, (v + v).DecimalFractionsPerSecond);
+            Assert.Equal(10, (v * 10).DecimalFractionsPerSecond);
+            Assert.Equal(10, (10 * v).DecimalFractionsPerSecond);
+            Assert.Equal(2, (RatioChangeRate.FromDecimalFractionsPerSecond(10) / 5).DecimalFractionsPerSecond);
+            Assert.Equal(2, RatioChangeRate.FromDecimalFractionsPerSecond(10) / RatioChangeRate.FromDecimalFractionsPerSecond(5));
         }
 
         [Fact]
@@ -488,8 +548,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RatioChangeRateUnit.DecimalFractionPerSecond, 1, RatioChangeRateUnit.DecimalFractionPerSecond, true)]  // Same value and unit.
         [InlineData(1, RatioChangeRateUnit.DecimalFractionPerSecond, 2, RatioChangeRateUnit.DecimalFractionPerSecond, false)] // Different value.
-        [InlineData(2, RatioChangeRateUnit.DecimalFractionPerSecond, 1, RatioChangeRateUnit.PercentPerSecond, false)] // Different value and unit.
-        [InlineData(1, RatioChangeRateUnit.DecimalFractionPerSecond, 1, RatioChangeRateUnit.PercentPerSecond, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RatioChangeRateUnit unitA, double valueB, RatioChangeRateUnit unitB, bool expectEqual)
         {
             var a = new RatioChangeRate(valueA, unitA);
@@ -549,8 +607,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = RatioChangeRate.FromDecimalFractionsPerSecond(firstValue);
             var otherQuantity = RatioChangeRate.FromDecimalFractionsPerSecond(secondValue);
             RatioChangeRate maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, RatioChangeRate.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -569,7 +627,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RatioChangeRateUnit>();
+            var units = EnumHelper.GetValues<RatioChangeRateUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -582,6 +640,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(RatioChangeRate.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(RatioChangeRate.Info.Units, RatioChangeRate.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, RatioChangeRate.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -600,26 +670,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 %/s", new RatioChangeRate(1, RatioChangeRateUnit.PercentPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 /s", new RatioChangeRate(0.123456, RatioChangeRateUnit.DecimalFractionPerSecond).ToString("s1"));
-            Assert.Equal("0.12 /s", new RatioChangeRate(0.123456, RatioChangeRateUnit.DecimalFractionPerSecond).ToString("s2"));
-            Assert.Equal("0.123 /s", new RatioChangeRate(0.123456, RatioChangeRateUnit.DecimalFractionPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 /s", new RatioChangeRate(0.123456, RatioChangeRateUnit.DecimalFractionPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 /s", new RatioChangeRate(0.123456, RatioChangeRateUnit.DecimalFractionPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 /s", new RatioChangeRate(0.123456, RatioChangeRateUnit.DecimalFractionPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 /s", new RatioChangeRate(0.123456, RatioChangeRateUnit.DecimalFractionPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 /s", new RatioChangeRate(0.123456, RatioChangeRateUnit.DecimalFractionPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -646,7 +696,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = RatioChangeRate.FromDecimalFractionsPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(RatioChangeRate), quantity.As(RatioChangeRate.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs
index f50b4c3fbd..e04eb10ca2 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs
@@ -124,6 +124,20 @@ public void Ratio_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<RatioUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RatioInfo_CreateWithCustomUnitInfos()
+        {
+            RatioUnit[] expectedUnits = [RatioUnit.DecimalFraction];
+
+            Ratio.RatioInfo quantityInfo = Ratio.RatioInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Ratio", quantityInfo.Name);
+            Assert.Equal(Ratio.Zero, quantityInfo.Zero);
+            Assert.Equal(Ratio.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void DecimalFractionToRatioUnits()
         {
@@ -198,12 +212,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new Ratio(value: 1, unit: RatioUnit.DecimalFraction);
+            Assert.Multiple(() =>
+            {
+                var quantity = new Ratio(value: 1, unit: RatioUnit.DecimalFraction);
+
+                Ratio convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(RatioUnit.DecimalFraction, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RatioUnit> quantity = new Ratio(value: 1, unit: RatioUnit.DecimalFraction);
+
+                IQuantity<RatioUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(RatioUnit.DecimalFraction, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new Ratio(value: 1, unit: RatioUnit.DecimalFraction);
 
-            Ratio convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(RatioUnit.DecimalFraction, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(RatioUnit.DecimalFraction, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -232,7 +265,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [InlineData("en-US", "4.2 ‰", RatioUnit.PartPerThousand, 4.2)]
         [InlineData("en-US", "4.2 ppt", RatioUnit.PartPerTrillion, 4.2)]
         [InlineData("en-US", "4.2 %", RatioUnit.Percent, 4.2)]
-        public void Parse(string culture, string quantityString, RatioUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RatioUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Ratio.Parse(quantityString);
@@ -247,7 +280,7 @@ public void Parse(string culture, string quantityString, RatioUnit expectedUnit,
         [InlineData("en-US", "4.2 ‰", RatioUnit.PartPerThousand, 4.2)]
         [InlineData("en-US", "4.2 ppt", RatioUnit.PartPerTrillion, 4.2)]
         [InlineData("en-US", "4.2 %", RatioUnit.Percent, 4.2)]
-        public void TryParse(string culture, string quantityString, RatioUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RatioUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Ratio.TryParse(quantityString, out Ratio parsed));
@@ -425,6 +458,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RatioUnit unit)
                 var quantity = Ratio.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -448,37 +482,39 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RatioUnit unit)
                 IQuantity<RatioUnit> quantityToConvert = quantity;
                 IQuantity<RatioUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Ratio decimalfraction = Ratio.FromDecimalFractions(1);
-            AssertEx.EqualTolerance(1, Ratio.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(1, Ratio.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance);
-            AssertEx.EqualTolerance(1, Ratio.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance);
-            AssertEx.EqualTolerance(1, Ratio.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance);
-            AssertEx.EqualTolerance(1, Ratio.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance);
-            AssertEx.EqualTolerance(1, Ratio.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance);
+            Ratio decimalfraction = Ratio.FromDecimalFractions(3);
+            Assert.Equal(3, Ratio.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions);
+            Assert.Equal(3, Ratio.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions);
+            Assert.Equal(3, Ratio.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions);
+            Assert.Equal(3, Ratio.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions);
+            Assert.Equal(3, Ratio.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions);
+            Assert.Equal(3, Ratio.FromPercent(decimalfraction.Percent).DecimalFractions);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Ratio v = Ratio.FromDecimalFractions(1);
-            AssertEx.EqualTolerance(-1, -v.DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (Ratio.FromDecimalFractions(3)-v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (Ratio.FromDecimalFractions(10)/5).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, Ratio.FromDecimalFractions(10)/Ratio.FromDecimalFractions(5), DecimalFractionsTolerance);
+            Assert.Equal(-1, -v.DecimalFractions);
+            Assert.Equal(2, (Ratio.FromDecimalFractions(3) - v).DecimalFractions);
+            Assert.Equal(2, (v + v).DecimalFractions);
+            Assert.Equal(10, (v * 10).DecimalFractions);
+            Assert.Equal(10, (10 * v).DecimalFractions);
+            Assert.Equal(2, (Ratio.FromDecimalFractions(10) / 5).DecimalFractions);
+            Assert.Equal(2, Ratio.FromDecimalFractions(10) / Ratio.FromDecimalFractions(5));
         }
 
         [Fact]
@@ -524,8 +560,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RatioUnit.DecimalFraction, 1, RatioUnit.DecimalFraction, true)]  // Same value and unit.
         [InlineData(1, RatioUnit.DecimalFraction, 2, RatioUnit.DecimalFraction, false)] // Different value.
-        [InlineData(2, RatioUnit.DecimalFraction, 1, RatioUnit.PartPerBillion, false)] // Different value and unit.
-        [InlineData(1, RatioUnit.DecimalFraction, 1, RatioUnit.PartPerBillion, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RatioUnit unitA, double valueB, RatioUnit unitB, bool expectEqual)
         {
             var a = new Ratio(valueA, unitA);
@@ -585,8 +619,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Ratio.FromDecimalFractions(firstValue);
             var otherQuantity = Ratio.FromDecimalFractions(secondValue);
             Ratio maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Ratio.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -605,7 +639,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RatioUnit>();
+            var units = EnumHelper.GetValues<RatioUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -618,6 +652,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Ratio.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Ratio.Info.Units, Ratio.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Ratio.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -644,26 +690,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 %", new Ratio(1, RatioUnit.Percent).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1", new Ratio(0.123456, RatioUnit.DecimalFraction).ToString("s1"));
-            Assert.Equal("0.12", new Ratio(0.123456, RatioUnit.DecimalFraction).ToString("s2"));
-            Assert.Equal("0.123", new Ratio(0.123456, RatioUnit.DecimalFraction).ToString("s3"));
-            Assert.Equal("0.1235", new Ratio(0.123456, RatioUnit.DecimalFraction).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1", new Ratio(0.123456, RatioUnit.DecimalFraction).ToString("s1", culture));
-            Assert.Equal("0.12", new Ratio(0.123456, RatioUnit.DecimalFraction).ToString("s2", culture));
-            Assert.Equal("0.123", new Ratio(0.123456, RatioUnit.DecimalFraction).ToString("s3", culture));
-            Assert.Equal("0.1235", new Ratio(0.123456, RatioUnit.DecimalFraction).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -690,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Ratio.FromDecimalFractions(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Ratio), quantity.As(Ratio.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs
index 1cdff726ea..46d60753ee 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs
@@ -165,6 +165,20 @@ public void ReciprocalArea_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<ReciprocalAreaUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ReciprocalAreaInfo_CreateWithCustomUnitInfos()
+        {
+            ReciprocalAreaUnit[] expectedUnits = [ReciprocalAreaUnit.InverseSquareMeter];
+
+            ReciprocalArea.ReciprocalAreaInfo quantityInfo = ReciprocalArea.ReciprocalAreaInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ReciprocalArea", quantityInfo.Name);
+            Assert.Equal(ReciprocalArea.Zero, quantityInfo.Zero);
+            Assert.Equal(ReciprocalArea.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void InverseSquareMeterToReciprocalAreaUnits()
         {
@@ -269,26 +283,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ReciprocalArea.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ReciprocalArea convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ReciprocalArea quantityToConvert = quantity;
+
+                ReciprocalArea convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ReciprocalAreaUnit> quantityToConvert = quantity;
+
+                IQuantity<ReciprocalAreaUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ReciprocalArea(value: 1, unit: ReciprocalArea.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ReciprocalArea(value: 1, unit: ReciprocalArea.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ReciprocalAreaUnit> quantity = new ReciprocalArea(value: 1, unit: ReciprocalArea.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ReciprocalArea(value: 1, unit: ReciprocalArea.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ReciprocalArea(value: 1, unit: ReciprocalArea.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ReciprocalArea(value: 1, unit: ReciprocalArea.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ReciprocalAreaUnit> quantity = new ReciprocalArea(value: 1, unit: ReciprocalArea.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ReciprocalArea(value: 1, unit: ReciprocalArea.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -303,7 +360,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 mm⁻²", ReciprocalAreaUnit.InverseSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 yd⁻²", ReciprocalAreaUnit.InverseSquareYard, 4.2)]
         [InlineData("en-US", "4.2 ft⁻² (US)", ReciprocalAreaUnit.InverseUsSurveySquareFoot, 4.2)]
-        public void Parse(string culture, string quantityString, ReciprocalAreaUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ReciprocalAreaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ReciprocalArea.Parse(quantityString);
@@ -323,7 +380,7 @@ public void Parse(string culture, string quantityString, ReciprocalAreaUnit expe
         [InlineData("en-US", "4.2 mm⁻²", ReciprocalAreaUnit.InverseSquareMillimeter, 4.2)]
         [InlineData("en-US", "4.2 yd⁻²", ReciprocalAreaUnit.InverseSquareYard, 4.2)]
         [InlineData("en-US", "4.2 ft⁻² (US)", ReciprocalAreaUnit.InverseUsSurveySquareFoot, 4.2)]
-        public void TryParse(string culture, string quantityString, ReciprocalAreaUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ReciprocalAreaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ReciprocalArea.TryParse(quantityString, out ReciprocalArea parsed));
@@ -546,6 +603,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ReciprocalAreaUn
                 var quantity = ReciprocalArea.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -569,42 +627,44 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ReciprocalAreaUnit
                 IQuantity<ReciprocalAreaUnit> quantityToConvert = quantity;
                 IQuantity<ReciprocalAreaUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareCentimeters(inversesquaremeter.InverseSquareCentimeters).InverseSquareMeters, InverseSquareCentimetersTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareDecimeters(inversesquaremeter.InverseSquareDecimeters).InverseSquareMeters, InverseSquareDecimetersTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareFeet(inversesquaremeter.InverseSquareFeet).InverseSquareMeters, InverseSquareFeetTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareInches(inversesquaremeter.InverseSquareInches).InverseSquareMeters, InverseSquareInchesTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareKilometers(inversesquaremeter.InverseSquareKilometers).InverseSquareMeters, InverseSquareKilometersTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMeters(inversesquaremeter.InverseSquareMeters).InverseSquareMeters, InverseSquareMetersTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMicrometers(inversesquaremeter.InverseSquareMicrometers).InverseSquareMeters, InverseSquareMicrometersTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMiles(inversesquaremeter.InverseSquareMiles).InverseSquareMeters, InverseSquareMilesTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMillimeters(inversesquaremeter.InverseSquareMillimeters).InverseSquareMeters, InverseSquareMillimetersTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareYards(inversesquaremeter.InverseSquareYards).InverseSquareMeters, InverseSquareYardsTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseUsSurveySquareFeet(inversesquaremeter.InverseUsSurveySquareFeet).InverseSquareMeters, InverseUsSurveySquareFeetTolerance);
+            ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(3);
+            Assert.Equal(3, ReciprocalArea.FromInverseSquareCentimeters(inversesquaremeter.InverseSquareCentimeters).InverseSquareMeters);
+            Assert.Equal(3, ReciprocalArea.FromInverseSquareDecimeters(inversesquaremeter.InverseSquareDecimeters).InverseSquareMeters);
+            Assert.Equal(3, ReciprocalArea.FromInverseSquareFeet(inversesquaremeter.InverseSquareFeet).InverseSquareMeters);
+            Assert.Equal(3, ReciprocalArea.FromInverseSquareInches(inversesquaremeter.InverseSquareInches).InverseSquareMeters);
+            Assert.Equal(3, ReciprocalArea.FromInverseSquareKilometers(inversesquaremeter.InverseSquareKilometers).InverseSquareMeters);
+            Assert.Equal(3, ReciprocalArea.FromInverseSquareMeters(inversesquaremeter.InverseSquareMeters).InverseSquareMeters);
+            Assert.Equal(3, ReciprocalArea.FromInverseSquareMicrometers(inversesquaremeter.InverseSquareMicrometers).InverseSquareMeters);
+            Assert.Equal(3, ReciprocalArea.FromInverseSquareMiles(inversesquaremeter.InverseSquareMiles).InverseSquareMeters);
+            Assert.Equal(3, ReciprocalArea.FromInverseSquareMillimeters(inversesquaremeter.InverseSquareMillimeters).InverseSquareMeters);
+            Assert.Equal(3, ReciprocalArea.FromInverseSquareYards(inversesquaremeter.InverseSquareYards).InverseSquareMeters);
+            Assert.Equal(3, ReciprocalArea.FromInverseUsSurveySquareFeet(inversesquaremeter.InverseUsSurveySquareFeet).InverseSquareMeters);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ReciprocalArea v = ReciprocalArea.FromInverseSquareMeters(1);
-            AssertEx.EqualTolerance(-1, -v.InverseSquareMeters, InverseSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (ReciprocalArea.FromInverseSquareMeters(3)-v).InverseSquareMeters, InverseSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).InverseSquareMeters, InverseSquareMetersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).InverseSquareMeters, InverseSquareMetersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).InverseSquareMeters, InverseSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, (ReciprocalArea.FromInverseSquareMeters(10)/5).InverseSquareMeters, InverseSquareMetersTolerance);
-            AssertEx.EqualTolerance(2, ReciprocalArea.FromInverseSquareMeters(10)/ReciprocalArea.FromInverseSquareMeters(5), InverseSquareMetersTolerance);
+            Assert.Equal(-1, -v.InverseSquareMeters);
+            Assert.Equal(2, (ReciprocalArea.FromInverseSquareMeters(3) - v).InverseSquareMeters);
+            Assert.Equal(2, (v + v).InverseSquareMeters);
+            Assert.Equal(10, (v * 10).InverseSquareMeters);
+            Assert.Equal(10, (10 * v).InverseSquareMeters);
+            Assert.Equal(2, (ReciprocalArea.FromInverseSquareMeters(10) / 5).InverseSquareMeters);
+            Assert.Equal(2, ReciprocalArea.FromInverseSquareMeters(10) / ReciprocalArea.FromInverseSquareMeters(5));
         }
 
         [Fact]
@@ -650,8 +710,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ReciprocalAreaUnit.InverseSquareMeter, 1, ReciprocalAreaUnit.InverseSquareMeter, true)]  // Same value and unit.
         [InlineData(1, ReciprocalAreaUnit.InverseSquareMeter, 2, ReciprocalAreaUnit.InverseSquareMeter, false)] // Different value.
-        [InlineData(2, ReciprocalAreaUnit.InverseSquareMeter, 1, ReciprocalAreaUnit.InverseSquareCentimeter, false)] // Different value and unit.
-        [InlineData(1, ReciprocalAreaUnit.InverseSquareMeter, 1, ReciprocalAreaUnit.InverseSquareCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ReciprocalAreaUnit unitA, double valueB, ReciprocalAreaUnit unitB, bool expectEqual)
         {
             var a = new ReciprocalArea(valueA, unitA);
@@ -711,8 +769,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ReciprocalArea.FromInverseSquareMeters(firstValue);
             var otherQuantity = ReciprocalArea.FromInverseSquareMeters(secondValue);
             ReciprocalArea maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ReciprocalArea.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -731,7 +789,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ReciprocalAreaUnit>();
+            var units = EnumHelper.GetValues<ReciprocalAreaUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -744,6 +802,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ReciprocalArea.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ReciprocalArea.Info.Units, ReciprocalArea.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ReciprocalArea.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -780,26 +850,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 ft⁻² (US)", new ReciprocalArea(1, ReciprocalAreaUnit.InverseUsSurveySquareFoot).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -826,7 +876,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ReciprocalArea.FromInverseSquareMeters(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ReciprocalArea), quantity.As(ReciprocalArea.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalLengthTestsBase.g.cs
index 3ad6ec30de..fc32656d5d 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalLengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalLengthTestsBase.g.cs
@@ -161,6 +161,20 @@ public void ReciprocalLength_QuantityInfo_ReturnsQuantityInfoDescribingQuantity(
             Assert.Equal(quantityInfo, ((IQuantity<ReciprocalLengthUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ReciprocalLengthInfo_CreateWithCustomUnitInfos()
+        {
+            ReciprocalLengthUnit[] expectedUnits = [ReciprocalLengthUnit.InverseMeter];
+
+            ReciprocalLength.ReciprocalLengthInfo quantityInfo = ReciprocalLength.ReciprocalLengthInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ReciprocalLength", quantityInfo.Name);
+            Assert.Equal(ReciprocalLength.Zero, quantityInfo.Zero);
+            Assert.Equal(ReciprocalLength.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void InverseMeterToReciprocalLengthUnits()
         {
@@ -263,26 +277,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ReciprocalLength.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ReciprocalLength convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ReciprocalLength quantityToConvert = quantity;
+
+                ReciprocalLength convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ReciprocalLengthUnit> quantityToConvert = quantity;
+
+                IQuantity<ReciprocalLengthUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ReciprocalLength(value: 1, unit: ReciprocalLength.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ReciprocalLength(value: 1, unit: ReciprocalLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ReciprocalLengthUnit> quantity = new ReciprocalLength(value: 1, unit: ReciprocalLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ReciprocalLength(value: 1, unit: ReciprocalLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ReciprocalLength(value: 1, unit: ReciprocalLength.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ReciprocalLength(value: 1, unit: ReciprocalLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ReciprocalLengthUnit> quantity = new ReciprocalLength(value: 1, unit: ReciprocalLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ReciprocalLength(value: 1, unit: ReciprocalLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -306,7 +363,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 1/ftUS", ReciprocalLengthUnit.InverseUsSurveyFoot, 4.2)]
         [InlineData("en-US", "4.2 yd⁻¹", ReciprocalLengthUnit.InverseYard, 4.2)]
         [InlineData("en-US", "4.2 1/yd", ReciprocalLengthUnit.InverseYard, 4.2)]
-        public void Parse(string culture, string quantityString, ReciprocalLengthUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ReciprocalLengthUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ReciprocalLength.Parse(quantityString);
@@ -335,7 +392,7 @@ public void Parse(string culture, string quantityString, ReciprocalLengthUnit ex
         [InlineData("en-US", "4.2 1/ftUS", ReciprocalLengthUnit.InverseUsSurveyFoot, 4.2)]
         [InlineData("en-US", "4.2 yd⁻¹", ReciprocalLengthUnit.InverseYard, 4.2)]
         [InlineData("en-US", "4.2 1/yd", ReciprocalLengthUnit.InverseYard, 4.2)]
-        public void TryParse(string culture, string quantityString, ReciprocalLengthUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ReciprocalLengthUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ReciprocalLength.TryParse(quantityString, out ReciprocalLength parsed));
@@ -629,6 +686,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ReciprocalLength
                 var quantity = ReciprocalLength.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -652,41 +710,43 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ReciprocalLengthUni
                 IQuantity<ReciprocalLengthUnit> quantityToConvert = quantity;
                 IQuantity<ReciprocalLengthUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ReciprocalLength inversemeter = ReciprocalLength.FromInverseMeters(1);
-            AssertEx.EqualTolerance(1, ReciprocalLength.FromInverseCentimeters(inversemeter.InverseCentimeters).InverseMeters, InverseCentimetersTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalLength.FromInverseFeet(inversemeter.InverseFeet).InverseMeters, InverseFeetTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalLength.FromInverseInches(inversemeter.InverseInches).InverseMeters, InverseInchesTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalLength.FromInverseMeters(inversemeter.InverseMeters).InverseMeters, InverseMetersTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalLength.FromInverseMicroinches(inversemeter.InverseMicroinches).InverseMeters, InverseMicroinchesTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalLength.FromInverseMils(inversemeter.InverseMils).InverseMeters, InverseMilsTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalLength.FromInverseMiles(inversemeter.InverseMiles).InverseMeters, InverseMilesTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalLength.FromInverseMillimeters(inversemeter.InverseMillimeters).InverseMeters, InverseMillimetersTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalLength.FromInverseUsSurveyFeet(inversemeter.InverseUsSurveyFeet).InverseMeters, InverseUsSurveyFeetTolerance);
-            AssertEx.EqualTolerance(1, ReciprocalLength.FromInverseYards(inversemeter.InverseYards).InverseMeters, InverseYardsTolerance);
+            ReciprocalLength inversemeter = ReciprocalLength.FromInverseMeters(3);
+            Assert.Equal(3, ReciprocalLength.FromInverseCentimeters(inversemeter.InverseCentimeters).InverseMeters);
+            Assert.Equal(3, ReciprocalLength.FromInverseFeet(inversemeter.InverseFeet).InverseMeters);
+            Assert.Equal(3, ReciprocalLength.FromInverseInches(inversemeter.InverseInches).InverseMeters);
+            Assert.Equal(3, ReciprocalLength.FromInverseMeters(inversemeter.InverseMeters).InverseMeters);
+            Assert.Equal(3, ReciprocalLength.FromInverseMicroinches(inversemeter.InverseMicroinches).InverseMeters);
+            Assert.Equal(3, ReciprocalLength.FromInverseMils(inversemeter.InverseMils).InverseMeters);
+            Assert.Equal(3, ReciprocalLength.FromInverseMiles(inversemeter.InverseMiles).InverseMeters);
+            Assert.Equal(3, ReciprocalLength.FromInverseMillimeters(inversemeter.InverseMillimeters).InverseMeters);
+            Assert.Equal(3, ReciprocalLength.FromInverseUsSurveyFeet(inversemeter.InverseUsSurveyFeet).InverseMeters);
+            Assert.Equal(3, ReciprocalLength.FromInverseYards(inversemeter.InverseYards).InverseMeters);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ReciprocalLength v = ReciprocalLength.FromInverseMeters(1);
-            AssertEx.EqualTolerance(-1, -v.InverseMeters, InverseMetersTolerance);
-            AssertEx.EqualTolerance(2, (ReciprocalLength.FromInverseMeters(3)-v).InverseMeters, InverseMetersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).InverseMeters, InverseMetersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).InverseMeters, InverseMetersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).InverseMeters, InverseMetersTolerance);
-            AssertEx.EqualTolerance(2, (ReciprocalLength.FromInverseMeters(10)/5).InverseMeters, InverseMetersTolerance);
-            AssertEx.EqualTolerance(2, ReciprocalLength.FromInverseMeters(10)/ReciprocalLength.FromInverseMeters(5), InverseMetersTolerance);
+            Assert.Equal(-1, -v.InverseMeters);
+            Assert.Equal(2, (ReciprocalLength.FromInverseMeters(3) - v).InverseMeters);
+            Assert.Equal(2, (v + v).InverseMeters);
+            Assert.Equal(10, (v * 10).InverseMeters);
+            Assert.Equal(10, (10 * v).InverseMeters);
+            Assert.Equal(2, (ReciprocalLength.FromInverseMeters(10) / 5).InverseMeters);
+            Assert.Equal(2, ReciprocalLength.FromInverseMeters(10) / ReciprocalLength.FromInverseMeters(5));
         }
 
         [Fact]
@@ -732,8 +792,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ReciprocalLengthUnit.InverseMeter, 1, ReciprocalLengthUnit.InverseMeter, true)]  // Same value and unit.
         [InlineData(1, ReciprocalLengthUnit.InverseMeter, 2, ReciprocalLengthUnit.InverseMeter, false)] // Different value.
-        [InlineData(2, ReciprocalLengthUnit.InverseMeter, 1, ReciprocalLengthUnit.InverseCentimeter, false)] // Different value and unit.
-        [InlineData(1, ReciprocalLengthUnit.InverseMeter, 1, ReciprocalLengthUnit.InverseCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ReciprocalLengthUnit unitA, double valueB, ReciprocalLengthUnit unitB, bool expectEqual)
         {
             var a = new ReciprocalLength(valueA, unitA);
@@ -793,8 +851,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ReciprocalLength.FromInverseMeters(firstValue);
             var otherQuantity = ReciprocalLength.FromInverseMeters(secondValue);
             ReciprocalLength maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ReciprocalLength.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -813,7 +871,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ReciprocalLengthUnit>();
+            var units = EnumHelper.GetValues<ReciprocalLengthUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -826,6 +884,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ReciprocalLength.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ReciprocalLength.Info.Units, ReciprocalLength.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ReciprocalLength.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -860,26 +930,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 yd⁻¹", new ReciprocalLength(1, ReciprocalLengthUnit.InverseYard).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m⁻¹", new ReciprocalLength(0.123456, ReciprocalLengthUnit.InverseMeter).ToString("s1"));
-            Assert.Equal("0.12 m⁻¹", new ReciprocalLength(0.123456, ReciprocalLengthUnit.InverseMeter).ToString("s2"));
-            Assert.Equal("0.123 m⁻¹", new ReciprocalLength(0.123456, ReciprocalLengthUnit.InverseMeter).ToString("s3"));
-            Assert.Equal("0.1235 m⁻¹", new ReciprocalLength(0.123456, ReciprocalLengthUnit.InverseMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m⁻¹", new ReciprocalLength(0.123456, ReciprocalLengthUnit.InverseMeter).ToString("s1", culture));
-            Assert.Equal("0.12 m⁻¹", new ReciprocalLength(0.123456, ReciprocalLengthUnit.InverseMeter).ToString("s2", culture));
-            Assert.Equal("0.123 m⁻¹", new ReciprocalLength(0.123456, ReciprocalLengthUnit.InverseMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 m⁻¹", new ReciprocalLength(0.123456, ReciprocalLengthUnit.InverseMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -906,7 +956,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ReciprocalLength.FromInverseMeters(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ReciprocalLength), quantity.As(ReciprocalLength.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RelativeHumidityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RelativeHumidityTestsBase.g.cs
index 7f73c3343d..76eb6c55fc 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RelativeHumidityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RelativeHumidityTestsBase.g.cs
@@ -104,6 +104,20 @@ public void RelativeHumidity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity(
             Assert.Equal(quantityInfo, ((IQuantity<RelativeHumidityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RelativeHumidityInfo_CreateWithCustomUnitInfos()
+        {
+            RelativeHumidityUnit[] expectedUnits = [RelativeHumidityUnit.Percent];
+
+            RelativeHumidity.RelativeHumidityInfo quantityInfo = RelativeHumidity.RelativeHumidityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("RelativeHumidity", quantityInfo.Name);
+            Assert.Equal(RelativeHumidity.Zero, quantityInfo.Zero);
+            Assert.Equal(RelativeHumidity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void PercentToRelativeHumidityUnits()
         {
@@ -168,12 +182,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new RelativeHumidity(value: 1, unit: RelativeHumidityUnit.Percent);
+            Assert.Multiple(() =>
+            {
+                var quantity = new RelativeHumidity(value: 1, unit: RelativeHumidityUnit.Percent);
+
+                RelativeHumidity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(RelativeHumidityUnit.Percent, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RelativeHumidityUnit> quantity = new RelativeHumidity(value: 1, unit: RelativeHumidityUnit.Percent);
+
+                IQuantity<RelativeHumidityUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(RelativeHumidityUnit.Percent, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new RelativeHumidity(value: 1, unit: RelativeHumidityUnit.Percent);
 
-            RelativeHumidity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(RelativeHumidityUnit.Percent, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(RelativeHumidityUnit.Percent, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -197,7 +230,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
 
         [Theory]
         [InlineData("en-US", "4.2 %RH", RelativeHumidityUnit.Percent, 4.2)]
-        public void Parse(string culture, string quantityString, RelativeHumidityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RelativeHumidityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = RelativeHumidity.Parse(quantityString);
@@ -207,7 +240,7 @@ public void Parse(string culture, string quantityString, RelativeHumidityUnit ex
 
         [Theory]
         [InlineData("en-US", "4.2 %RH", RelativeHumidityUnit.Percent, 4.2)]
-        public void TryParse(string culture, string quantityString, RelativeHumidityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RelativeHumidityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(RelativeHumidity.TryParse(quantityString, out RelativeHumidity parsed));
@@ -340,6 +373,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RelativeHumidity
                 var quantity = RelativeHumidity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -363,32 +397,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RelativeHumidityUni
                 IQuantity<RelativeHumidityUnit> quantityToConvert = quantity;
                 IQuantity<RelativeHumidityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            RelativeHumidity percent = RelativeHumidity.FromPercent(1);
-            AssertEx.EqualTolerance(1, RelativeHumidity.FromPercent(percent.Percent).Percent, PercentTolerance);
+            RelativeHumidity percent = RelativeHumidity.FromPercent(3);
+            Assert.Equal(3, RelativeHumidity.FromPercent(percent.Percent).Percent);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             RelativeHumidity v = RelativeHumidity.FromPercent(1);
-            AssertEx.EqualTolerance(-1, -v.Percent, PercentTolerance);
-            AssertEx.EqualTolerance(2, (RelativeHumidity.FromPercent(3)-v).Percent, PercentTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Percent, PercentTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Percent, PercentTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Percent, PercentTolerance);
-            AssertEx.EqualTolerance(2, (RelativeHumidity.FromPercent(10)/5).Percent, PercentTolerance);
-            AssertEx.EqualTolerance(2, RelativeHumidity.FromPercent(10)/RelativeHumidity.FromPercent(5), PercentTolerance);
+            Assert.Equal(-1, -v.Percent);
+            Assert.Equal(2, (RelativeHumidity.FromPercent(3) - v).Percent);
+            Assert.Equal(2, (v + v).Percent);
+            Assert.Equal(10, (v * 10).Percent);
+            Assert.Equal(10, (10 * v).Percent);
+            Assert.Equal(2, (RelativeHumidity.FromPercent(10) / 5).Percent);
+            Assert.Equal(2, RelativeHumidity.FromPercent(10) / RelativeHumidity.FromPercent(5));
         }
 
         [Fact]
@@ -434,7 +470,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RelativeHumidityUnit.Percent, 1, RelativeHumidityUnit.Percent, true)]  // Same value and unit.
         [InlineData(1, RelativeHumidityUnit.Percent, 2, RelativeHumidityUnit.Percent, false)] // Different value.
-        [InlineData(2, RelativeHumidityUnit.Percent, 1, RelativeHumidityUnit.Percent, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RelativeHumidityUnit unitA, double valueB, RelativeHumidityUnit unitB, bool expectEqual)
         {
             var a = new RelativeHumidity(valueA, unitA);
@@ -494,8 +529,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = RelativeHumidity.FromPercent(firstValue);
             var otherQuantity = RelativeHumidity.FromPercent(secondValue);
             RelativeHumidity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, RelativeHumidity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -514,7 +549,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RelativeHumidityUnit>();
+            var units = EnumHelper.GetValues<RelativeHumidityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -528,39 +563,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 %RH", new RelativeHumidity(1, RelativeHumidityUnit.Percent).ToString());
+            Assert.Equal(RelativeHumidity.Info.Units, RelativeHumidity.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 %RH", new RelativeHumidity(1, RelativeHumidityUnit.Percent).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, RelativeHumidity.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 %RH", new RelativeHumidity(0.123456, RelativeHumidityUnit.Percent).ToString("s1"));
-            Assert.Equal("0.12 %RH", new RelativeHumidity(0.123456, RelativeHumidityUnit.Percent).ToString("s2"));
-            Assert.Equal("0.123 %RH", new RelativeHumidity(0.123456, RelativeHumidityUnit.Percent).ToString("s3"));
-            Assert.Equal("0.1235 %RH", new RelativeHumidity(0.123456, RelativeHumidityUnit.Percent).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 %RH", new RelativeHumidity(1, RelativeHumidityUnit.Percent).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 %RH", new RelativeHumidity(0.123456, RelativeHumidityUnit.Percent).ToString("s1", culture));
-            Assert.Equal("0.12 %RH", new RelativeHumidity(0.123456, RelativeHumidityUnit.Percent).ToString("s2", culture));
-            Assert.Equal("0.123 %RH", new RelativeHumidity(0.123456, RelativeHumidityUnit.Percent).ToString("s3", culture));
-            Assert.Equal("0.1235 %RH", new RelativeHumidity(0.123456, RelativeHumidityUnit.Percent).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 %RH", new RelativeHumidity(1, RelativeHumidityUnit.Percent).ToString(swedishCulture));
         }
 
         [Theory]
@@ -589,7 +616,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = RelativeHumidity.FromPercent(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(RelativeHumidity), quantity.As(RelativeHumidity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalAccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalAccelerationTestsBase.g.cs
index 37b6c2b9fd..feed1b8974 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalAccelerationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalAccelerationTestsBase.g.cs
@@ -137,6 +137,20 @@ public void RotationalAcceleration_QuantityInfo_ReturnsQuantityInfoDescribingQua
             Assert.Equal(quantityInfo, ((IQuantity<RotationalAccelerationUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RotationalAccelerationInfo_CreateWithCustomUnitInfos()
+        {
+            RotationalAccelerationUnit[] expectedUnits = [RotationalAccelerationUnit.RadianPerSecondSquared];
+
+            RotationalAcceleration.RotationalAccelerationInfo quantityInfo = RotationalAcceleration.RotationalAccelerationInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("RotationalAcceleration", quantityInfo.Name);
+            Assert.Equal(RotationalAcceleration.Zero, quantityInfo.Zero);
+            Assert.Equal(RotationalAcceleration.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void RadianPerSecondSquaredToRotationalAccelerationUnits()
         {
@@ -227,26 +241,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = RotationalAcceleration.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            RotationalAcceleration convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                RotationalAcceleration quantityToConvert = quantity;
+
+                RotationalAcceleration convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RotationalAccelerationUnit> quantityToConvert = quantity;
+
+                IQuantity<RotationalAccelerationUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new RotationalAcceleration(value: 1, unit: RotationalAcceleration.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RotationalAcceleration(value: 1, unit: RotationalAcceleration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<RotationalAccelerationUnit> quantity = new RotationalAcceleration(value: 1, unit: RotationalAcceleration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RotationalAcceleration(value: 1, unit: RotationalAcceleration.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new RotationalAcceleration(value: 1, unit: RotationalAcceleration.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RotationalAcceleration(value: 1, unit: RotationalAcceleration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<RotationalAccelerationUnit> quantity = new RotationalAcceleration(value: 1, unit: RotationalAcceleration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RotationalAcceleration(value: 1, unit: RotationalAcceleration.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -255,7 +312,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 rad/s²", RotationalAccelerationUnit.RadianPerSecondSquared, 4.2)]
         [InlineData("en-US", "4.2 rpm/s", RotationalAccelerationUnit.RevolutionPerMinutePerSecond, 4.2)]
         [InlineData("en-US", "4.2 r/s²", RotationalAccelerationUnit.RevolutionPerSecondSquared, 4.2)]
-        public void Parse(string culture, string quantityString, RotationalAccelerationUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RotationalAccelerationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = RotationalAcceleration.Parse(quantityString);
@@ -269,7 +326,7 @@ public void Parse(string culture, string quantityString, RotationalAccelerationU
         [InlineData("en-US", "4.2 rad/s²", RotationalAccelerationUnit.RadianPerSecondSquared, 4.2)]
         [InlineData("en-US", "4.2 rpm/s", RotationalAccelerationUnit.RevolutionPerMinutePerSecond, 4.2)]
         [InlineData("en-US", "4.2 r/s²", RotationalAccelerationUnit.RevolutionPerSecondSquared, 4.2)]
-        public void TryParse(string culture, string quantityString, RotationalAccelerationUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RotationalAccelerationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(RotationalAcceleration.TryParse(quantityString, out RotationalAcceleration parsed));
@@ -437,6 +494,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RotationalAccele
                 var quantity = RotationalAcceleration.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -460,35 +518,37 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RotationalAccelerat
                 IQuantity<RotationalAccelerationUnit> quantityToConvert = quantity;
                 IQuantity<RotationalAccelerationUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(1);
-            AssertEx.EqualTolerance(1, RotationalAcceleration.FromDegreesPerSecondSquared(radianpersecondsquared.DegreesPerSecondSquared).RadiansPerSecondSquared, DegreesPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, RotationalAcceleration.FromRadiansPerSecondSquared(radianpersecondsquared.RadiansPerSecondSquared).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, RotationalAcceleration.FromRevolutionsPerMinutePerSecond(radianpersecondsquared.RevolutionsPerMinutePerSecond).RadiansPerSecondSquared, RevolutionsPerMinutePerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalAcceleration.FromRevolutionsPerSecondSquared(radianpersecondsquared.RevolutionsPerSecondSquared).RadiansPerSecondSquared, RevolutionsPerSecondSquaredTolerance);
+            RotationalAcceleration radianpersecondsquared = RotationalAcceleration.FromRadiansPerSecondSquared(3);
+            Assert.Equal(3, RotationalAcceleration.FromDegreesPerSecondSquared(radianpersecondsquared.DegreesPerSecondSquared).RadiansPerSecondSquared);
+            Assert.Equal(3, RotationalAcceleration.FromRadiansPerSecondSquared(radianpersecondsquared.RadiansPerSecondSquared).RadiansPerSecondSquared);
+            Assert.Equal(3, RotationalAcceleration.FromRevolutionsPerMinutePerSecond(radianpersecondsquared.RevolutionsPerMinutePerSecond).RadiansPerSecondSquared);
+            Assert.Equal(3, RotationalAcceleration.FromRevolutionsPerSecondSquared(radianpersecondsquared.RevolutionsPerSecondSquared).RadiansPerSecondSquared);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             RotationalAcceleration v = RotationalAcceleration.FromRadiansPerSecondSquared(1);
-            AssertEx.EqualTolerance(-1, -v.RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (RotationalAcceleration.FromRadiansPerSecondSquared(3)-v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (v + v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(10, (v*10).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(10, (10*v).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (RotationalAcceleration.FromRadiansPerSecondSquared(10)/5).RadiansPerSecondSquared, RadiansPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, RotationalAcceleration.FromRadiansPerSecondSquared(10)/RotationalAcceleration.FromRadiansPerSecondSquared(5), RadiansPerSecondSquaredTolerance);
+            Assert.Equal(-1, -v.RadiansPerSecondSquared);
+            Assert.Equal(2, (RotationalAcceleration.FromRadiansPerSecondSquared(3) - v).RadiansPerSecondSquared);
+            Assert.Equal(2, (v + v).RadiansPerSecondSquared);
+            Assert.Equal(10, (v * 10).RadiansPerSecondSquared);
+            Assert.Equal(10, (10 * v).RadiansPerSecondSquared);
+            Assert.Equal(2, (RotationalAcceleration.FromRadiansPerSecondSquared(10) / 5).RadiansPerSecondSquared);
+            Assert.Equal(2, RotationalAcceleration.FromRadiansPerSecondSquared(10) / RotationalAcceleration.FromRadiansPerSecondSquared(5));
         }
 
         [Fact]
@@ -534,8 +594,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RotationalAccelerationUnit.RadianPerSecondSquared, 1, RotationalAccelerationUnit.RadianPerSecondSquared, true)]  // Same value and unit.
         [InlineData(1, RotationalAccelerationUnit.RadianPerSecondSquared, 2, RotationalAccelerationUnit.RadianPerSecondSquared, false)] // Different value.
-        [InlineData(2, RotationalAccelerationUnit.RadianPerSecondSquared, 1, RotationalAccelerationUnit.DegreePerSecondSquared, false)] // Different value and unit.
-        [InlineData(1, RotationalAccelerationUnit.RadianPerSecondSquared, 1, RotationalAccelerationUnit.DegreePerSecondSquared, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RotationalAccelerationUnit unitA, double valueB, RotationalAccelerationUnit unitB, bool expectEqual)
         {
             var a = new RotationalAcceleration(valueA, unitA);
@@ -595,8 +653,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(firstValue);
             var otherQuantity = RotationalAcceleration.FromRadiansPerSecondSquared(secondValue);
             RotationalAcceleration maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, RotationalAcceleration.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -615,7 +673,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RotationalAccelerationUnit>();
+            var units = EnumHelper.GetValues<RotationalAccelerationUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -628,6 +686,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(RotationalAcceleration.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(RotationalAcceleration.Info.Units, RotationalAcceleration.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, RotationalAcceleration.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -650,26 +720,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 r/s²", new RotationalAcceleration(1, RotationalAccelerationUnit.RevolutionPerSecondSquared).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 rad/s²", new RotationalAcceleration(0.123456, RotationalAccelerationUnit.RadianPerSecondSquared).ToString("s1"));
-            Assert.Equal("0.12 rad/s²", new RotationalAcceleration(0.123456, RotationalAccelerationUnit.RadianPerSecondSquared).ToString("s2"));
-            Assert.Equal("0.123 rad/s²", new RotationalAcceleration(0.123456, RotationalAccelerationUnit.RadianPerSecondSquared).ToString("s3"));
-            Assert.Equal("0.1235 rad/s²", new RotationalAcceleration(0.123456, RotationalAccelerationUnit.RadianPerSecondSquared).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 rad/s²", new RotationalAcceleration(0.123456, RotationalAccelerationUnit.RadianPerSecondSquared).ToString("s1", culture));
-            Assert.Equal("0.12 rad/s²", new RotationalAcceleration(0.123456, RotationalAccelerationUnit.RadianPerSecondSquared).ToString("s2", culture));
-            Assert.Equal("0.123 rad/s²", new RotationalAcceleration(0.123456, RotationalAccelerationUnit.RadianPerSecondSquared).ToString("s3", culture));
-            Assert.Equal("0.1235 rad/s²", new RotationalAcceleration(0.123456, RotationalAccelerationUnit.RadianPerSecondSquared).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -696,7 +746,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = RotationalAcceleration.FromRadiansPerSecondSquared(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(RotationalAcceleration), quantity.As(RotationalAcceleration.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs
index f96bcd6abd..c2ccaffca4 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalSpeedTestsBase.g.cs
@@ -173,6 +173,20 @@ public void RotationalSpeed_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<RotationalSpeedUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RotationalSpeedInfo_CreateWithCustomUnitInfos()
+        {
+            RotationalSpeedUnit[] expectedUnits = [RotationalSpeedUnit.RadianPerSecond];
+
+            RotationalSpeed.RotationalSpeedInfo quantityInfo = RotationalSpeed.RotationalSpeedInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("RotationalSpeed", quantityInfo.Name);
+            Assert.Equal(RotationalSpeed.Zero, quantityInfo.Zero);
+            Assert.Equal(RotationalSpeed.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void RadianPerSecondToRotationalSpeedUnits()
         {
@@ -281,26 +295,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = RotationalSpeed.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            RotationalSpeed convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                RotationalSpeed quantityToConvert = quantity;
+
+                RotationalSpeed convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RotationalSpeedUnit> quantityToConvert = quantity;
+
+                IQuantity<RotationalSpeedUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new RotationalSpeed(value: 1, unit: RotationalSpeed.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RotationalSpeed(value: 1, unit: RotationalSpeed.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<RotationalSpeedUnit> quantity = new RotationalSpeed(value: 1, unit: RotationalSpeed.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RotationalSpeed(value: 1, unit: RotationalSpeed.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new RotationalSpeed(value: 1, unit: RotationalSpeed.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RotationalSpeed(value: 1, unit: RotationalSpeed.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<RotationalSpeedUnit> quantity = new RotationalSpeed(value: 1, unit: RotationalSpeed.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RotationalSpeed(value: 1, unit: RotationalSpeed.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -335,7 +392,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 рад/с", RotationalSpeedUnit.RadianPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 об/мин", RotationalSpeedUnit.RevolutionPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 об/с", RotationalSpeedUnit.RevolutionPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, RotationalSpeedUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RotationalSpeedUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = RotationalSpeed.Parse(quantityString);
@@ -375,7 +432,7 @@ public void Parse(string culture, string quantityString, RotationalSpeedUnit exp
         [InlineData("ru-RU", "4,2 рад/с", RotationalSpeedUnit.RadianPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 об/мин", RotationalSpeedUnit.RevolutionPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 об/с", RotationalSpeedUnit.RevolutionPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, RotationalSpeedUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RotationalSpeedUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(RotationalSpeed.TryParse(quantityString, out RotationalSpeed parsed));
@@ -724,6 +781,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RotationalSpeedU
                 var quantity = RotationalSpeed.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -747,44 +805,46 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RotationalSpeedUnit
                 IQuantity<RotationalSpeedUnit> quantityToConvert = quantity;
                 IQuantity<RotationalSpeedUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromCentiradiansPerSecond(radianpersecond.CentiradiansPerSecond).RadiansPerSecond, CentiradiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromDeciradiansPerSecond(radianpersecond.DeciradiansPerSecond).RadiansPerSecond, DeciradiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromDegreesPerMinute(radianpersecond.DegreesPerMinute).RadiansPerSecond, DegreesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromDegreesPerSecond(radianpersecond.DegreesPerSecond).RadiansPerSecond, DegreesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromMicrodegreesPerSecond(radianpersecond.MicrodegreesPerSecond).RadiansPerSecond, MicrodegreesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromMicroradiansPerSecond(radianpersecond.MicroradiansPerSecond).RadiansPerSecond, MicroradiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromMillidegreesPerSecond(radianpersecond.MillidegreesPerSecond).RadiansPerSecond, MillidegreesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromMilliradiansPerSecond(radianpersecond.MilliradiansPerSecond).RadiansPerSecond, MilliradiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromNanodegreesPerSecond(radianpersecond.NanodegreesPerSecond).RadiansPerSecond, NanodegreesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromNanoradiansPerSecond(radianpersecond.NanoradiansPerSecond).RadiansPerSecond, NanoradiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromRadiansPerSecond(radianpersecond.RadiansPerSecond).RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromRevolutionsPerMinute(radianpersecond.RevolutionsPerMinute).RadiansPerSecond, RevolutionsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, RotationalSpeed.FromRevolutionsPerSecond(radianpersecond.RevolutionsPerSecond).RadiansPerSecond, RevolutionsPerSecondTolerance);
+            RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(3);
+            Assert.Equal(3, RotationalSpeed.FromCentiradiansPerSecond(radianpersecond.CentiradiansPerSecond).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromDeciradiansPerSecond(radianpersecond.DeciradiansPerSecond).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromDegreesPerMinute(radianpersecond.DegreesPerMinute).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromDegreesPerSecond(radianpersecond.DegreesPerSecond).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromMicrodegreesPerSecond(radianpersecond.MicrodegreesPerSecond).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromMicroradiansPerSecond(radianpersecond.MicroradiansPerSecond).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromMillidegreesPerSecond(radianpersecond.MillidegreesPerSecond).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromMilliradiansPerSecond(radianpersecond.MilliradiansPerSecond).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromNanodegreesPerSecond(radianpersecond.NanodegreesPerSecond).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromNanoradiansPerSecond(radianpersecond.NanoradiansPerSecond).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromRadiansPerSecond(radianpersecond.RadiansPerSecond).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromRevolutionsPerMinute(radianpersecond.RevolutionsPerMinute).RadiansPerSecond);
+            Assert.Equal(3, RotationalSpeed.FromRevolutionsPerSecond(radianpersecond.RevolutionsPerSecond).RadiansPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             RotationalSpeed v = RotationalSpeed.FromRadiansPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (RotationalSpeed.FromRadiansPerSecond(3)-v).RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (RotationalSpeed.FromRadiansPerSecond(10)/5).RadiansPerSecond, RadiansPerSecondTolerance);
-            AssertEx.EqualTolerance(2, RotationalSpeed.FromRadiansPerSecond(10)/RotationalSpeed.FromRadiansPerSecond(5), RadiansPerSecondTolerance);
+            Assert.Equal(-1, -v.RadiansPerSecond);
+            Assert.Equal(2, (RotationalSpeed.FromRadiansPerSecond(3) - v).RadiansPerSecond);
+            Assert.Equal(2, (v + v).RadiansPerSecond);
+            Assert.Equal(10, (v * 10).RadiansPerSecond);
+            Assert.Equal(10, (10 * v).RadiansPerSecond);
+            Assert.Equal(2, (RotationalSpeed.FromRadiansPerSecond(10) / 5).RadiansPerSecond);
+            Assert.Equal(2, RotationalSpeed.FromRadiansPerSecond(10) / RotationalSpeed.FromRadiansPerSecond(5));
         }
 
         [Fact]
@@ -830,8 +890,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RotationalSpeedUnit.RadianPerSecond, 1, RotationalSpeedUnit.RadianPerSecond, true)]  // Same value and unit.
         [InlineData(1, RotationalSpeedUnit.RadianPerSecond, 2, RotationalSpeedUnit.RadianPerSecond, false)] // Different value.
-        [InlineData(2, RotationalSpeedUnit.RadianPerSecond, 1, RotationalSpeedUnit.CentiradianPerSecond, false)] // Different value and unit.
-        [InlineData(1, RotationalSpeedUnit.RadianPerSecond, 1, RotationalSpeedUnit.CentiradianPerSecond, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RotationalSpeedUnit unitA, double valueB, RotationalSpeedUnit unitB, bool expectEqual)
         {
             var a = new RotationalSpeed(valueA, unitA);
@@ -891,8 +949,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = RotationalSpeed.FromRadiansPerSecond(firstValue);
             var otherQuantity = RotationalSpeed.FromRadiansPerSecond(secondValue);
             RotationalSpeed maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, RotationalSpeed.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -911,7 +969,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RotationalSpeedUnit>();
+            var units = EnumHelper.GetValues<RotationalSpeedUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -924,6 +982,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(RotationalSpeed.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(RotationalSpeed.Info.Units, RotationalSpeed.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, RotationalSpeed.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -964,26 +1034,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 r/s", new RotationalSpeed(1, RotationalSpeedUnit.RevolutionPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 rad/s", new RotationalSpeed(0.123456, RotationalSpeedUnit.RadianPerSecond).ToString("s1"));
-            Assert.Equal("0.12 rad/s", new RotationalSpeed(0.123456, RotationalSpeedUnit.RadianPerSecond).ToString("s2"));
-            Assert.Equal("0.123 rad/s", new RotationalSpeed(0.123456, RotationalSpeedUnit.RadianPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 rad/s", new RotationalSpeed(0.123456, RotationalSpeedUnit.RadianPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 rad/s", new RotationalSpeed(0.123456, RotationalSpeedUnit.RadianPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 rad/s", new RotationalSpeed(0.123456, RotationalSpeedUnit.RadianPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 rad/s", new RotationalSpeed(0.123456, RotationalSpeedUnit.RadianPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 rad/s", new RotationalSpeed(0.123456, RotationalSpeedUnit.RadianPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1010,7 +1060,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = RotationalSpeed.FromRadiansPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(RotationalSpeed), quantity.As(RotationalSpeed.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs
index ca708ff30a..0201f21fa9 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessPerLengthTestsBase.g.cs
@@ -141,6 +141,20 @@ public void RotationalStiffnessPerLength_QuantityInfo_ReturnsQuantityInfoDescrib
             Assert.Equal(quantityInfo, ((IQuantity<RotationalStiffnessPerLengthUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RotationalStiffnessPerLengthInfo_CreateWithCustomUnitInfos()
+        {
+            RotationalStiffnessPerLengthUnit[] expectedUnits = [RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter];
+
+            RotationalStiffnessPerLength.RotationalStiffnessPerLengthInfo quantityInfo = RotationalStiffnessPerLength.RotationalStiffnessPerLengthInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("RotationalStiffnessPerLength", quantityInfo.Name);
+            Assert.Equal(RotationalStiffnessPerLength.Zero, quantityInfo.Zero);
+            Assert.Equal(RotationalStiffnessPerLength.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void NewtonMeterPerRadianPerMeterToRotationalStiffnessPerLengthUnits()
         {
@@ -233,26 +247,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = RotationalStiffnessPerLength.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            RotationalStiffnessPerLength convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                RotationalStiffnessPerLength quantityToConvert = quantity;
+
+                RotationalStiffnessPerLength convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RotationalStiffnessPerLengthUnit> quantityToConvert = quantity;
+
+                IQuantity<RotationalStiffnessPerLengthUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new RotationalStiffnessPerLength(value: 1, unit: RotationalStiffnessPerLength.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RotationalStiffnessPerLength(value: 1, unit: RotationalStiffnessPerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<RotationalStiffnessPerLengthUnit> quantity = new RotationalStiffnessPerLength(value: 1, unit: RotationalStiffnessPerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RotationalStiffnessPerLength(value: 1, unit: RotationalStiffnessPerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new RotationalStiffnessPerLength(value: 1, unit: RotationalStiffnessPerLength.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RotationalStiffnessPerLength(value: 1, unit: RotationalStiffnessPerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<RotationalStiffnessPerLengthUnit> quantity = new RotationalStiffnessPerLength(value: 1, unit: RotationalStiffnessPerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RotationalStiffnessPerLength(value: 1, unit: RotationalStiffnessPerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -269,7 +326,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 N·m/rad/m", RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, 4.2)]
         [InlineData("en-US", "4.2 Nm/rad/m", RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, 4.2)]
         [InlineData("en-US", "4.2 lbf·ft/deg/ft", RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, 4.2)]
-        public void Parse(string culture, string quantityString, RotationalStiffnessPerLengthUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RotationalStiffnessPerLengthUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = RotationalStiffnessPerLength.Parse(quantityString);
@@ -291,7 +348,7 @@ public void Parse(string culture, string quantityString, RotationalStiffnessPerL
         [InlineData("en-US", "4.2 N·m/rad/m", RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, 4.2)]
         [InlineData("en-US", "4.2 Nm/rad/m", RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, 4.2)]
         [InlineData("en-US", "4.2 lbf·ft/deg/ft", RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, 4.2)]
-        public void TryParse(string culture, string quantityString, RotationalStiffnessPerLengthUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RotationalStiffnessPerLengthUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(RotationalStiffnessPerLength.TryParse(quantityString, out RotationalStiffnessPerLength parsed));
@@ -524,6 +581,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RotationalStiffn
                 var quantity = RotationalStiffnessPerLength.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -547,36 +605,38 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RotationalStiffness
                 IQuantity<RotationalStiffnessPerLengthUnit> quantityToConvert = quantity;
                 IQuantity<RotationalStiffnessPerLengthUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            RotationalStiffnessPerLength newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
-            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.KilonewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, KilonewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(newtonmeterperradianpermeter.KilopoundForceFeetPerDegreesPerFeet).NewtonMetersPerRadianPerMeter, KilopoundForceFeetPerDegreesPerFeetTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.MeganewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, MeganewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.NewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(newtonmeterperradianpermeter.PoundForceFeetPerDegreesPerFeet).NewtonMetersPerRadianPerMeter, PoundForceFeetPerDegreesPerFeetTolerance);
+            RotationalStiffnessPerLength newtonmeterperradianpermeter = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(3);
+            Assert.Equal(3, RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.KilonewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter);
+            Assert.Equal(3, RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(newtonmeterperradianpermeter.KilopoundForceFeetPerDegreesPerFeet).NewtonMetersPerRadianPerMeter);
+            Assert.Equal(3, RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.MeganewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter);
+            Assert.Equal(3, RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(newtonmeterperradianpermeter.NewtonMetersPerRadianPerMeter).NewtonMetersPerRadianPerMeter);
+            Assert.Equal(3, RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(newtonmeterperradianpermeter.PoundForceFeetPerDegreesPerFeet).NewtonMetersPerRadianPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             RotationalStiffnessPerLength v = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(3)-v).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(10)/5).NewtonMetersPerRadianPerMeter, NewtonMetersPerRadianPerMeterTolerance);
-            AssertEx.EqualTolerance(2, RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(10)/RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(5), NewtonMetersPerRadianPerMeterTolerance);
+            Assert.Equal(-1, -v.NewtonMetersPerRadianPerMeter);
+            Assert.Equal(2, (RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(3) - v).NewtonMetersPerRadianPerMeter);
+            Assert.Equal(2, (v + v).NewtonMetersPerRadianPerMeter);
+            Assert.Equal(10, (v * 10).NewtonMetersPerRadianPerMeter);
+            Assert.Equal(10, (10 * v).NewtonMetersPerRadianPerMeter);
+            Assert.Equal(2, (RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(10) / 5).NewtonMetersPerRadianPerMeter);
+            Assert.Equal(2, RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(10) / RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(5));
         }
 
         [Fact]
@@ -622,8 +682,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, 1, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, true)]  // Same value and unit.
         [InlineData(1, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, 2, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, false)] // Different value.
-        [InlineData(2, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, 1, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, false)] // Different value and unit.
-        [InlineData(1, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, 1, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RotationalStiffnessPerLengthUnit unitA, double valueB, RotationalStiffnessPerLengthUnit unitB, bool expectEqual)
         {
             var a = new RotationalStiffnessPerLength(valueA, unitA);
@@ -683,8 +741,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(firstValue);
             var otherQuantity = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(secondValue);
             RotationalStiffnessPerLength maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, RotationalStiffnessPerLength.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -703,7 +761,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RotationalStiffnessPerLengthUnit>();
+            var units = EnumHelper.GetValues<RotationalStiffnessPerLengthUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -716,6 +774,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(RotationalStiffnessPerLength.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(RotationalStiffnessPerLength.Info.Units, RotationalStiffnessPerLength.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, RotationalStiffnessPerLength.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -740,26 +810,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 lbf·ft/deg/ft", new RotationalStiffnessPerLength(1, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 N·m/rad/m", new RotationalStiffnessPerLength(0.123456, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter).ToString("s1"));
-            Assert.Equal("0.12 N·m/rad/m", new RotationalStiffnessPerLength(0.123456, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter).ToString("s2"));
-            Assert.Equal("0.123 N·m/rad/m", new RotationalStiffnessPerLength(0.123456, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter).ToString("s3"));
-            Assert.Equal("0.1235 N·m/rad/m", new RotationalStiffnessPerLength(0.123456, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 N·m/rad/m", new RotationalStiffnessPerLength(0.123456, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 N·m/rad/m", new RotationalStiffnessPerLength(0.123456, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 N·m/rad/m", new RotationalStiffnessPerLength(0.123456, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 N·m/rad/m", new RotationalStiffnessPerLength(0.123456, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -786,7 +836,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(RotationalStiffnessPerLength), quantity.As(RotationalStiffnessPerLength.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs
index 8e541e6f10..7c85a9de34 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs
@@ -257,6 +257,20 @@ public void RotationalStiffness_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
             Assert.Equal(quantityInfo, ((IQuantity<RotationalStiffnessUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void RotationalStiffnessInfo_CreateWithCustomUnitInfos()
+        {
+            RotationalStiffnessUnit[] expectedUnits = [RotationalStiffnessUnit.NewtonMeterPerRadian];
+
+            RotationalStiffness.RotationalStiffnessInfo quantityInfo = RotationalStiffness.RotationalStiffnessInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("RotationalStiffness", quantityInfo.Name);
+            Assert.Equal(RotationalStiffness.Zero, quantityInfo.Zero);
+            Assert.Equal(RotationalStiffness.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void NewtonMeterPerRadianToRotationalStiffnessUnits()
         {
@@ -407,26 +421,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = RotationalStiffness.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            RotationalStiffness convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                RotationalStiffness quantityToConvert = quantity;
+
+                RotationalStiffness convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<RotationalStiffnessUnit> quantityToConvert = quantity;
+
+                IQuantity<RotationalStiffnessUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new RotationalStiffness(value: 1, unit: RotationalStiffness.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RotationalStiffness(value: 1, unit: RotationalStiffness.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<RotationalStiffnessUnit> quantity = new RotationalStiffness(value: 1, unit: RotationalStiffness.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RotationalStiffness(value: 1, unit: RotationalStiffness.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new RotationalStiffness(value: 1, unit: RotationalStiffness.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new RotationalStiffness(value: 1, unit: RotationalStiffness.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<RotationalStiffnessUnit> quantity = new RotationalStiffness(value: 1, unit: RotationalStiffness.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new RotationalStiffness(value: 1, unit: RotationalStiffness.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -537,7 +594,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 Nmm/rad", RotationalStiffnessUnit.NewtonMillimeterPerRadian, 4.2)]
         [InlineData("en-US", "4.2 lbf·ft/rad", RotationalStiffnessUnit.PoundForceFeetPerRadian, 4.2)]
         [InlineData("en-US", "4.2 lbf·ft/deg", RotationalStiffnessUnit.PoundForceFootPerDegrees, 4.2)]
-        public void Parse(string culture, string quantityString, RotationalStiffnessUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, RotationalStiffnessUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = RotationalStiffness.Parse(quantityString);
@@ -653,7 +710,7 @@ public void Parse(string culture, string quantityString, RotationalStiffnessUnit
         [InlineData("en-US", "4.2 Nmm/rad", RotationalStiffnessUnit.NewtonMillimeterPerRadian, 4.2)]
         [InlineData("en-US", "4.2 lbf·ft/rad", RotationalStiffnessUnit.PoundForceFeetPerRadian, 4.2)]
         [InlineData("en-US", "4.2 lbf·ft/deg", RotationalStiffnessUnit.PoundForceFootPerDegrees, 4.2)]
-        public void TryParse(string culture, string quantityString, RotationalStiffnessUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, RotationalStiffnessUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(RotationalStiffness.TryParse(quantityString, out RotationalStiffness parsed));
@@ -1667,6 +1724,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(RotationalStiffn
                 var quantity = RotationalStiffness.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1690,65 +1748,67 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(RotationalStiffness
                 IQuantity<RotationalStiffnessUnit> quantityToConvert = quantity;
                 IQuantity<RotationalStiffnessUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromCentinewtonMetersPerDegree(newtonmeterperradian.CentinewtonMetersPerDegree).NewtonMetersPerRadian, CentinewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromCentinewtonMillimetersPerDegree(newtonmeterperradian.CentinewtonMillimetersPerDegree).NewtonMetersPerRadian, CentinewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromCentinewtonMillimetersPerRadian(newtonmeterperradian.CentinewtonMillimetersPerRadian).NewtonMetersPerRadian, CentinewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecanewtonMetersPerDegree(newtonmeterperradian.DecanewtonMetersPerDegree).NewtonMetersPerRadian, DecanewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecanewtonMillimetersPerDegree(newtonmeterperradian.DecanewtonMillimetersPerDegree).NewtonMetersPerRadian, DecanewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecanewtonMillimetersPerRadian(newtonmeterperradian.DecanewtonMillimetersPerRadian).NewtonMetersPerRadian, DecanewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecinewtonMetersPerDegree(newtonmeterperradian.DecinewtonMetersPerDegree).NewtonMetersPerRadian, DecinewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecinewtonMillimetersPerDegree(newtonmeterperradian.DecinewtonMillimetersPerDegree).NewtonMetersPerRadian, DecinewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromDecinewtonMillimetersPerRadian(newtonmeterperradian.DecinewtonMillimetersPerRadian).NewtonMetersPerRadian, DecinewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilonewtonMetersPerDegree(newtonmeterperradian.KilonewtonMetersPerDegree).NewtonMetersPerRadian, KilonewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilonewtonMetersPerRadian(newtonmeterperradian.KilonewtonMetersPerRadian).NewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilonewtonMillimetersPerDegree(newtonmeterperradian.KilonewtonMillimetersPerDegree).NewtonMetersPerRadian, KilonewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilonewtonMillimetersPerRadian(newtonmeterperradian.KilonewtonMillimetersPerRadian).NewtonMetersPerRadian, KilonewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilopoundForceFeetPerDegrees(newtonmeterperradian.KilopoundForceFeetPerDegrees).NewtonMetersPerRadian, KilopoundForceFeetPerDegreesTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilopoundForceFeetPerRadian(newtonmeterperradian.KilopoundForceFeetPerRadian).NewtonMetersPerRadian, KilopoundForceFeetPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMeganewtonMetersPerDegree(newtonmeterperradian.MeganewtonMetersPerDegree).NewtonMetersPerRadian, MeganewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMeganewtonMetersPerRadian(newtonmeterperradian.MeganewtonMetersPerRadian).NewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMeganewtonMillimetersPerDegree(newtonmeterperradian.MeganewtonMillimetersPerDegree).NewtonMetersPerRadian, MeganewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMeganewtonMillimetersPerRadian(newtonmeterperradian.MeganewtonMillimetersPerRadian).NewtonMetersPerRadian, MeganewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMicronewtonMetersPerDegree(newtonmeterperradian.MicronewtonMetersPerDegree).NewtonMetersPerRadian, MicronewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMicronewtonMillimetersPerDegree(newtonmeterperradian.MicronewtonMillimetersPerDegree).NewtonMetersPerRadian, MicronewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMicronewtonMillimetersPerRadian(newtonmeterperradian.MicronewtonMillimetersPerRadian).NewtonMetersPerRadian, MicronewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMillinewtonMetersPerDegree(newtonmeterperradian.MillinewtonMetersPerDegree).NewtonMetersPerRadian, MillinewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMillinewtonMillimetersPerDegree(newtonmeterperradian.MillinewtonMillimetersPerDegree).NewtonMetersPerRadian, MillinewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromMillinewtonMillimetersPerRadian(newtonmeterperradian.MillinewtonMillimetersPerRadian).NewtonMetersPerRadian, MillinewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNanonewtonMetersPerDegree(newtonmeterperradian.NanonewtonMetersPerDegree).NewtonMetersPerRadian, NanonewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNanonewtonMillimetersPerDegree(newtonmeterperradian.NanonewtonMillimetersPerDegree).NewtonMetersPerRadian, NanonewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNanonewtonMillimetersPerRadian(newtonmeterperradian.NanonewtonMillimetersPerRadian).NewtonMetersPerRadian, NanonewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNewtonMetersPerDegree(newtonmeterperradian.NewtonMetersPerDegree).NewtonMetersPerRadian, NewtonMetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNewtonMetersPerRadian(newtonmeterperradian.NewtonMetersPerRadian).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNewtonMillimetersPerDegree(newtonmeterperradian.NewtonMillimetersPerDegree).NewtonMetersPerRadian, NewtonMillimetersPerDegreeTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromNewtonMillimetersPerRadian(newtonmeterperradian.NewtonMillimetersPerRadian).NewtonMetersPerRadian, NewtonMillimetersPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromPoundForceFeetPerRadian(newtonmeterperradian.PoundForceFeetPerRadian).NewtonMetersPerRadian, PoundForceFeetPerRadianTolerance);
-            AssertEx.EqualTolerance(1, RotationalStiffness.FromPoundForceFeetPerDegrees(newtonmeterperradian.PoundForceFeetPerDegrees).NewtonMetersPerRadian, PoundForceFeetPerDegreesTolerance);
+            RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(3);
+            Assert.Equal(3, RotationalStiffness.FromCentinewtonMetersPerDegree(newtonmeterperradian.CentinewtonMetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromCentinewtonMillimetersPerDegree(newtonmeterperradian.CentinewtonMillimetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromCentinewtonMillimetersPerRadian(newtonmeterperradian.CentinewtonMillimetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromDecanewtonMetersPerDegree(newtonmeterperradian.DecanewtonMetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromDecanewtonMillimetersPerDegree(newtonmeterperradian.DecanewtonMillimetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromDecanewtonMillimetersPerRadian(newtonmeterperradian.DecanewtonMillimetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromDecinewtonMetersPerDegree(newtonmeterperradian.DecinewtonMetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromDecinewtonMillimetersPerDegree(newtonmeterperradian.DecinewtonMillimetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromDecinewtonMillimetersPerRadian(newtonmeterperradian.DecinewtonMillimetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromKilonewtonMetersPerDegree(newtonmeterperradian.KilonewtonMetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromKilonewtonMetersPerRadian(newtonmeterperradian.KilonewtonMetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromKilonewtonMillimetersPerDegree(newtonmeterperradian.KilonewtonMillimetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromKilonewtonMillimetersPerRadian(newtonmeterperradian.KilonewtonMillimetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromKilopoundForceFeetPerDegrees(newtonmeterperradian.KilopoundForceFeetPerDegrees).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromKilopoundForceFeetPerRadian(newtonmeterperradian.KilopoundForceFeetPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromMeganewtonMetersPerDegree(newtonmeterperradian.MeganewtonMetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromMeganewtonMetersPerRadian(newtonmeterperradian.MeganewtonMetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromMeganewtonMillimetersPerDegree(newtonmeterperradian.MeganewtonMillimetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromMeganewtonMillimetersPerRadian(newtonmeterperradian.MeganewtonMillimetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromMicronewtonMetersPerDegree(newtonmeterperradian.MicronewtonMetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromMicronewtonMillimetersPerDegree(newtonmeterperradian.MicronewtonMillimetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromMicronewtonMillimetersPerRadian(newtonmeterperradian.MicronewtonMillimetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromMillinewtonMetersPerDegree(newtonmeterperradian.MillinewtonMetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromMillinewtonMillimetersPerDegree(newtonmeterperradian.MillinewtonMillimetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromMillinewtonMillimetersPerRadian(newtonmeterperradian.MillinewtonMillimetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromNanonewtonMetersPerDegree(newtonmeterperradian.NanonewtonMetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromNanonewtonMillimetersPerDegree(newtonmeterperradian.NanonewtonMillimetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromNanonewtonMillimetersPerRadian(newtonmeterperradian.NanonewtonMillimetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromNewtonMetersPerDegree(newtonmeterperradian.NewtonMetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromNewtonMetersPerRadian(newtonmeterperradian.NewtonMetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromNewtonMillimetersPerDegree(newtonmeterperradian.NewtonMillimetersPerDegree).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromNewtonMillimetersPerRadian(newtonmeterperradian.NewtonMillimetersPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromPoundForceFeetPerRadian(newtonmeterperradian.PoundForceFeetPerRadian).NewtonMetersPerRadian);
+            Assert.Equal(3, RotationalStiffness.FromPoundForceFeetPerDegrees(newtonmeterperradian.PoundForceFeetPerDegrees).NewtonMetersPerRadian);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             RotationalStiffness v = RotationalStiffness.FromNewtonMetersPerRadian(1);
-            AssertEx.EqualTolerance(-1, -v.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(2, (RotationalStiffness.FromNewtonMetersPerRadian(3)-v).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(2, (v + v).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(10, (v*10).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(10, (10*v).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(2, (RotationalStiffness.FromNewtonMetersPerRadian(10)/5).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            AssertEx.EqualTolerance(2, RotationalStiffness.FromNewtonMetersPerRadian(10)/RotationalStiffness.FromNewtonMetersPerRadian(5), NewtonMetersPerRadianTolerance);
+            Assert.Equal(-1, -v.NewtonMetersPerRadian);
+            Assert.Equal(2, (RotationalStiffness.FromNewtonMetersPerRadian(3) - v).NewtonMetersPerRadian);
+            Assert.Equal(2, (v + v).NewtonMetersPerRadian);
+            Assert.Equal(10, (v * 10).NewtonMetersPerRadian);
+            Assert.Equal(10, (10 * v).NewtonMetersPerRadian);
+            Assert.Equal(2, (RotationalStiffness.FromNewtonMetersPerRadian(10) / 5).NewtonMetersPerRadian);
+            Assert.Equal(2, RotationalStiffness.FromNewtonMetersPerRadian(10) / RotationalStiffness.FromNewtonMetersPerRadian(5));
         }
 
         [Fact]
@@ -1794,8 +1854,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, RotationalStiffnessUnit.NewtonMeterPerRadian, 1, RotationalStiffnessUnit.NewtonMeterPerRadian, true)]  // Same value and unit.
         [InlineData(1, RotationalStiffnessUnit.NewtonMeterPerRadian, 2, RotationalStiffnessUnit.NewtonMeterPerRadian, false)] // Different value.
-        [InlineData(2, RotationalStiffnessUnit.NewtonMeterPerRadian, 1, RotationalStiffnessUnit.CentinewtonMeterPerDegree, false)] // Different value and unit.
-        [InlineData(1, RotationalStiffnessUnit.NewtonMeterPerRadian, 1, RotationalStiffnessUnit.CentinewtonMeterPerDegree, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, RotationalStiffnessUnit unitA, double valueB, RotationalStiffnessUnit unitB, bool expectEqual)
         {
             var a = new RotationalStiffness(valueA, unitA);
@@ -1855,8 +1913,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = RotationalStiffness.FromNewtonMetersPerRadian(firstValue);
             var otherQuantity = RotationalStiffness.FromNewtonMetersPerRadian(secondValue);
             RotationalStiffness maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, RotationalStiffness.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1875,7 +1933,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<RotationalStiffnessUnit>();
+            var units = EnumHelper.GetValues<RotationalStiffnessUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1888,6 +1946,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(RotationalStiffness.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(RotationalStiffness.Info.Units, RotationalStiffness.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, RotationalStiffness.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1970,26 +2040,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 lbf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.PoundForceFootPerDegrees).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 N·m/rad", new RotationalStiffness(0.123456, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString("s1"));
-            Assert.Equal("0.12 N·m/rad", new RotationalStiffness(0.123456, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString("s2"));
-            Assert.Equal("0.123 N·m/rad", new RotationalStiffness(0.123456, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString("s3"));
-            Assert.Equal("0.1235 N·m/rad", new RotationalStiffness(0.123456, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 N·m/rad", new RotationalStiffness(0.123456, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString("s1", culture));
-            Assert.Equal("0.12 N·m/rad", new RotationalStiffness(0.123456, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString("s2", culture));
-            Assert.Equal("0.123 N·m/rad", new RotationalStiffness(0.123456, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString("s3", culture));
-            Assert.Equal("0.1235 N·m/rad", new RotationalStiffness(0.123456, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -2016,7 +2066,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = RotationalStiffness.FromNewtonMetersPerRadian(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(RotationalStiffness), quantity.As(RotationalStiffness.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ScalarTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ScalarTestsBase.g.cs
index f1adb3c098..268219df04 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ScalarTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ScalarTestsBase.g.cs
@@ -104,6 +104,20 @@ public void Scalar_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<ScalarUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ScalarInfo_CreateWithCustomUnitInfos()
+        {
+            ScalarUnit[] expectedUnits = [ScalarUnit.Amount];
+
+            Scalar.ScalarInfo quantityInfo = Scalar.ScalarInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Scalar", quantityInfo.Name);
+            Assert.Equal(Scalar.Zero, quantityInfo.Zero);
+            Assert.Equal(Scalar.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void AmountToScalarUnits()
         {
@@ -168,12 +182,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new Scalar(value: 1, unit: ScalarUnit.Amount);
+            Assert.Multiple(() =>
+            {
+                var quantity = new Scalar(value: 1, unit: ScalarUnit.Amount);
+
+                Scalar convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(ScalarUnit.Amount, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ScalarUnit> quantity = new Scalar(value: 1, unit: ScalarUnit.Amount);
+
+                IQuantity<ScalarUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(ScalarUnit.Amount, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new Scalar(value: 1, unit: ScalarUnit.Amount);
 
-            Scalar convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(ScalarUnit.Amount, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(ScalarUnit.Amount, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -197,7 +230,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
 
         [Theory]
         [InlineData("en-US", "4.2 ", ScalarUnit.Amount, 4.2)]
-        public void Parse(string culture, string quantityString, ScalarUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ScalarUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Scalar.Parse(quantityString);
@@ -207,7 +240,7 @@ public void Parse(string culture, string quantityString, ScalarUnit expectedUnit
 
         [Theory]
         [InlineData("en-US", "4.2 ", ScalarUnit.Amount, 4.2)]
-        public void TryParse(string culture, string quantityString, ScalarUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ScalarUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Scalar.TryParse(quantityString, out Scalar parsed));
@@ -340,6 +373,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ScalarUnit unit)
                 var quantity = Scalar.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -363,32 +397,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ScalarUnit unit)
                 IQuantity<ScalarUnit> quantityToConvert = quantity;
                 IQuantity<ScalarUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Scalar amount = Scalar.FromAmount(1);
-            AssertEx.EqualTolerance(1, Scalar.FromAmount(amount.Amount).Amount, AmountTolerance);
+            Scalar amount = Scalar.FromAmount(3);
+            Assert.Equal(3, Scalar.FromAmount(amount.Amount).Amount);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Scalar v = Scalar.FromAmount(1);
-            AssertEx.EqualTolerance(-1, -v.Amount, AmountTolerance);
-            AssertEx.EqualTolerance(2, (Scalar.FromAmount(3)-v).Amount, AmountTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Amount, AmountTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Amount, AmountTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Amount, AmountTolerance);
-            AssertEx.EqualTolerance(2, (Scalar.FromAmount(10)/5).Amount, AmountTolerance);
-            AssertEx.EqualTolerance(2, Scalar.FromAmount(10)/Scalar.FromAmount(5), AmountTolerance);
+            Assert.Equal(-1, -v.Amount);
+            Assert.Equal(2, (Scalar.FromAmount(3) - v).Amount);
+            Assert.Equal(2, (v + v).Amount);
+            Assert.Equal(10, (v * 10).Amount);
+            Assert.Equal(10, (10 * v).Amount);
+            Assert.Equal(2, (Scalar.FromAmount(10) / 5).Amount);
+            Assert.Equal(2, Scalar.FromAmount(10) / Scalar.FromAmount(5));
         }
 
         [Fact]
@@ -434,7 +470,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ScalarUnit.Amount, 1, ScalarUnit.Amount, true)]  // Same value and unit.
         [InlineData(1, ScalarUnit.Amount, 2, ScalarUnit.Amount, false)] // Different value.
-        [InlineData(2, ScalarUnit.Amount, 1, ScalarUnit.Amount, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ScalarUnit unitA, double valueB, ScalarUnit unitB, bool expectEqual)
         {
             var a = new Scalar(valueA, unitA);
@@ -494,8 +529,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Scalar.FromAmount(firstValue);
             var otherQuantity = Scalar.FromAmount(secondValue);
             Scalar maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Scalar.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -514,7 +549,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ScalarUnit>();
+            var units = EnumHelper.GetValues<ScalarUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -528,39 +563,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1", new Scalar(1, ScalarUnit.Amount).ToString());
+            Assert.Equal(Scalar.Info.Units, Scalar.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1", new Scalar(1, ScalarUnit.Amount).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, Scalar.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1", new Scalar(0.123456, ScalarUnit.Amount).ToString("s1"));
-            Assert.Equal("0.12", new Scalar(0.123456, ScalarUnit.Amount).ToString("s2"));
-            Assert.Equal("0.123", new Scalar(0.123456, ScalarUnit.Amount).ToString("s3"));
-            Assert.Equal("0.1235", new Scalar(0.123456, ScalarUnit.Amount).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1", new Scalar(1, ScalarUnit.Amount).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1", new Scalar(0.123456, ScalarUnit.Amount).ToString("s1", culture));
-            Assert.Equal("0.12", new Scalar(0.123456, ScalarUnit.Amount).ToString("s2", culture));
-            Assert.Equal("0.123", new Scalar(0.123456, ScalarUnit.Amount).ToString("s3", culture));
-            Assert.Equal("0.1235", new Scalar(0.123456, ScalarUnit.Amount).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1", new Scalar(1, ScalarUnit.Amount).ToString(swedishCulture));
         }
 
         [Theory]
@@ -589,7 +616,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Scalar.FromAmount(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Scalar), quantity.As(Scalar.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SolidAngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SolidAngleTestsBase.g.cs
index eb6a58dbfe..37965785fa 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SolidAngleTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SolidAngleTestsBase.g.cs
@@ -104,6 +104,20 @@ public void SolidAngle_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<SolidAngleUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void SolidAngleInfo_CreateWithCustomUnitInfos()
+        {
+            SolidAngleUnit[] expectedUnits = [SolidAngleUnit.Steradian];
+
+            SolidAngle.SolidAngleInfo quantityInfo = SolidAngle.SolidAngleInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("SolidAngle", quantityInfo.Name);
+            Assert.Equal(SolidAngle.Zero, quantityInfo.Zero);
+            Assert.Equal(SolidAngle.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SteradianToSolidAngleUnits()
         {
@@ -168,12 +182,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new SolidAngle(value: 1, unit: SolidAngleUnit.Steradian);
+            Assert.Multiple(() =>
+            {
+                var quantity = new SolidAngle(value: 1, unit: SolidAngleUnit.Steradian);
+
+                SolidAngle convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(SolidAngleUnit.Steradian, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<SolidAngleUnit> quantity = new SolidAngle(value: 1, unit: SolidAngleUnit.Steradian);
+
+                IQuantity<SolidAngleUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(SolidAngleUnit.Steradian, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new SolidAngle(value: 1, unit: SolidAngleUnit.Steradian);
 
-            SolidAngle convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(SolidAngleUnit.Steradian, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(SolidAngleUnit.Steradian, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -197,7 +230,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
 
         [Theory]
         [InlineData("en-US", "4.2 sr", SolidAngleUnit.Steradian, 4.2)]
-        public void Parse(string culture, string quantityString, SolidAngleUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, SolidAngleUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = SolidAngle.Parse(quantityString);
@@ -207,7 +240,7 @@ public void Parse(string culture, string quantityString, SolidAngleUnit expected
 
         [Theory]
         [InlineData("en-US", "4.2 sr", SolidAngleUnit.Steradian, 4.2)]
-        public void TryParse(string culture, string quantityString, SolidAngleUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, SolidAngleUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(SolidAngle.TryParse(quantityString, out SolidAngle parsed));
@@ -340,6 +373,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(SolidAngleUnit u
                 var quantity = SolidAngle.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -363,32 +397,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(SolidAngleUnit unit
                 IQuantity<SolidAngleUnit> quantityToConvert = quantity;
                 IQuantity<SolidAngleUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            SolidAngle steradian = SolidAngle.FromSteradians(1);
-            AssertEx.EqualTolerance(1, SolidAngle.FromSteradians(steradian.Steradians).Steradians, SteradiansTolerance);
+            SolidAngle steradian = SolidAngle.FromSteradians(3);
+            Assert.Equal(3, SolidAngle.FromSteradians(steradian.Steradians).Steradians);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             SolidAngle v = SolidAngle.FromSteradians(1);
-            AssertEx.EqualTolerance(-1, -v.Steradians, SteradiansTolerance);
-            AssertEx.EqualTolerance(2, (SolidAngle.FromSteradians(3)-v).Steradians, SteradiansTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Steradians, SteradiansTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Steradians, SteradiansTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Steradians, SteradiansTolerance);
-            AssertEx.EqualTolerance(2, (SolidAngle.FromSteradians(10)/5).Steradians, SteradiansTolerance);
-            AssertEx.EqualTolerance(2, SolidAngle.FromSteradians(10)/SolidAngle.FromSteradians(5), SteradiansTolerance);
+            Assert.Equal(-1, -v.Steradians);
+            Assert.Equal(2, (SolidAngle.FromSteradians(3) - v).Steradians);
+            Assert.Equal(2, (v + v).Steradians);
+            Assert.Equal(10, (v * 10).Steradians);
+            Assert.Equal(10, (10 * v).Steradians);
+            Assert.Equal(2, (SolidAngle.FromSteradians(10) / 5).Steradians);
+            Assert.Equal(2, SolidAngle.FromSteradians(10) / SolidAngle.FromSteradians(5));
         }
 
         [Fact]
@@ -434,7 +470,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, SolidAngleUnit.Steradian, 1, SolidAngleUnit.Steradian, true)]  // Same value and unit.
         [InlineData(1, SolidAngleUnit.Steradian, 2, SolidAngleUnit.Steradian, false)] // Different value.
-        [InlineData(2, SolidAngleUnit.Steradian, 1, SolidAngleUnit.Steradian, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, SolidAngleUnit unitA, double valueB, SolidAngleUnit unitB, bool expectEqual)
         {
             var a = new SolidAngle(valueA, unitA);
@@ -494,8 +529,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = SolidAngle.FromSteradians(firstValue);
             var otherQuantity = SolidAngle.FromSteradians(secondValue);
             SolidAngle maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, SolidAngle.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -514,7 +549,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<SolidAngleUnit>();
+            var units = EnumHelper.GetValues<SolidAngleUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -528,39 +563,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 sr", new SolidAngle(1, SolidAngleUnit.Steradian).ToString());
+            Assert.Equal(SolidAngle.Info.Units, SolidAngle.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 sr", new SolidAngle(1, SolidAngleUnit.Steradian).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, SolidAngle.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 sr", new SolidAngle(0.123456, SolidAngleUnit.Steradian).ToString("s1"));
-            Assert.Equal("0.12 sr", new SolidAngle(0.123456, SolidAngleUnit.Steradian).ToString("s2"));
-            Assert.Equal("0.123 sr", new SolidAngle(0.123456, SolidAngleUnit.Steradian).ToString("s3"));
-            Assert.Equal("0.1235 sr", new SolidAngle(0.123456, SolidAngleUnit.Steradian).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 sr", new SolidAngle(1, SolidAngleUnit.Steradian).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 sr", new SolidAngle(0.123456, SolidAngleUnit.Steradian).ToString("s1", culture));
-            Assert.Equal("0.12 sr", new SolidAngle(0.123456, SolidAngleUnit.Steradian).ToString("s2", culture));
-            Assert.Equal("0.123 sr", new SolidAngle(0.123456, SolidAngleUnit.Steradian).ToString("s3", culture));
-            Assert.Equal("0.1235 sr", new SolidAngle(0.123456, SolidAngleUnit.Steradian).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 sr", new SolidAngle(1, SolidAngleUnit.Steradian).ToString(swedishCulture));
         }
 
         [Theory]
@@ -589,7 +616,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = SolidAngle.FromSteradians(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(SolidAngle), quantity.As(SolidAngle.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs
index ef7090b04d..15291242f8 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEnergyTestsBase.g.cs
@@ -241,6 +241,20 @@ public void SpecificEnergy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<SpecificEnergyUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void SpecificEnergyInfo_CreateWithCustomUnitInfos()
+        {
+            SpecificEnergyUnit[] expectedUnits = [SpecificEnergyUnit.JoulePerKilogram];
+
+            SpecificEnergy.SpecificEnergyInfo quantityInfo = SpecificEnergy.SpecificEnergyInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("SpecificEnergy", quantityInfo.Name);
+            Assert.Equal(SpecificEnergy.Zero, quantityInfo.Zero);
+            Assert.Equal(SpecificEnergy.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void JoulePerKilogramToSpecificEnergyUnits()
         {
@@ -383,26 +397,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = SpecificEnergy.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            SpecificEnergy convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                SpecificEnergy quantityToConvert = quantity;
+
+                SpecificEnergy convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<SpecificEnergyUnit> quantityToConvert = quantity;
+
+                IQuantity<SpecificEnergyUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new SpecificEnergy(value: 1, unit: SpecificEnergy.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new SpecificEnergy(value: 1, unit: SpecificEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpecificEnergyUnit> quantity = new SpecificEnergy(value: 1, unit: SpecificEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new SpecificEnergy(value: 1, unit: SpecificEnergy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new SpecificEnergy(value: 1, unit: SpecificEnergy.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new SpecificEnergy(value: 1, unit: SpecificEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpecificEnergyUnit> quantity = new SpecificEnergy(value: 1, unit: SpecificEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new SpecificEnergy(value: 1, unit: SpecificEnergy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -436,7 +493,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 Wd/t", SpecificEnergyUnit.WattDayPerTonne, 4.2)]
         [InlineData("en-US", "4.2 Wh/kg", SpecificEnergyUnit.WattHourPerKilogram, 4.2)]
         [InlineData("en-US", "4.2 Wh/lbs", SpecificEnergyUnit.WattHourPerPound, 4.2)]
-        public void Parse(string culture, string quantityString, SpecificEnergyUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, SpecificEnergyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = SpecificEnergy.Parse(quantityString);
@@ -475,7 +532,7 @@ public void Parse(string culture, string quantityString, SpecificEnergyUnit expe
         [InlineData("en-US", "4.2 Wd/t", SpecificEnergyUnit.WattDayPerTonne, 4.2)]
         [InlineData("en-US", "4.2 Wh/kg", SpecificEnergyUnit.WattHourPerKilogram, 4.2)]
         [InlineData("en-US", "4.2 Wh/lbs", SpecificEnergyUnit.WattHourPerPound, 4.2)]
-        public void TryParse(string culture, string quantityString, SpecificEnergyUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, SpecificEnergyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(SpecificEnergy.TryParse(quantityString, out SpecificEnergy parsed));
@@ -869,6 +926,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(SpecificEnergyUn
                 var quantity = SpecificEnergy.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -892,61 +950,63 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(SpecificEnergyUnit
                 IQuantity<SpecificEnergyUnit> quantityToConvert = quantity;
                 IQuantity<SpecificEnergyUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromBtuPerPound(jouleperkilogram.BtuPerPound).JoulesPerKilogram, BtuPerPoundTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromCaloriesPerGram(jouleperkilogram.CaloriesPerGram).JoulesPerKilogram, CaloriesPerGramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromGigawattDaysPerKilogram(jouleperkilogram.GigawattDaysPerKilogram).JoulesPerKilogram, GigawattDaysPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromGigawattDaysPerShortTon(jouleperkilogram.GigawattDaysPerShortTon).JoulesPerKilogram, GigawattDaysPerShortTonTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromGigawattDaysPerTonne(jouleperkilogram.GigawattDaysPerTonne).JoulesPerKilogram, GigawattDaysPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromGigawattHoursPerKilogram(jouleperkilogram.GigawattHoursPerKilogram).JoulesPerKilogram, GigawattHoursPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromGigawattHoursPerPound(jouleperkilogram.GigawattHoursPerPound).JoulesPerKilogram, GigawattHoursPerPoundTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromJoulesPerKilogram(jouleperkilogram.JoulesPerKilogram).JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilocaloriesPerGram(jouleperkilogram.KilocaloriesPerGram).JoulesPerKilogram, KilocaloriesPerGramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilojoulesPerKilogram(jouleperkilogram.KilojoulesPerKilogram).JoulesPerKilogram, KilojoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilowattDaysPerKilogram(jouleperkilogram.KilowattDaysPerKilogram).JoulesPerKilogram, KilowattDaysPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilowattDaysPerShortTon(jouleperkilogram.KilowattDaysPerShortTon).JoulesPerKilogram, KilowattDaysPerShortTonTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilowattDaysPerTonne(jouleperkilogram.KilowattDaysPerTonne).JoulesPerKilogram, KilowattDaysPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilowattHoursPerKilogram(jouleperkilogram.KilowattHoursPerKilogram).JoulesPerKilogram, KilowattHoursPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromKilowattHoursPerPound(jouleperkilogram.KilowattHoursPerPound).JoulesPerKilogram, KilowattHoursPerPoundTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegajoulesPerKilogram(jouleperkilogram.MegajoulesPerKilogram).JoulesPerKilogram, MegajoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegajoulesPerTonne(jouleperkilogram.MegajoulesPerTonne).JoulesPerKilogram, MegajoulesPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegawattDaysPerKilogram(jouleperkilogram.MegawattDaysPerKilogram).JoulesPerKilogram, MegawattDaysPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegawattDaysPerShortTon(jouleperkilogram.MegawattDaysPerShortTon).JoulesPerKilogram, MegawattDaysPerShortTonTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegawattDaysPerTonne(jouleperkilogram.MegawattDaysPerTonne).JoulesPerKilogram, MegawattDaysPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegawattHoursPerKilogram(jouleperkilogram.MegawattHoursPerKilogram).JoulesPerKilogram, MegawattHoursPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromMegawattHoursPerPound(jouleperkilogram.MegawattHoursPerPound).JoulesPerKilogram, MegawattHoursPerPoundTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromTerawattDaysPerKilogram(jouleperkilogram.TerawattDaysPerKilogram).JoulesPerKilogram, TerawattDaysPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromTerawattDaysPerShortTon(jouleperkilogram.TerawattDaysPerShortTon).JoulesPerKilogram, TerawattDaysPerShortTonTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromTerawattDaysPerTonne(jouleperkilogram.TerawattDaysPerTonne).JoulesPerKilogram, TerawattDaysPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromWattDaysPerKilogram(jouleperkilogram.WattDaysPerKilogram).JoulesPerKilogram, WattDaysPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromWattDaysPerShortTon(jouleperkilogram.WattDaysPerShortTon).JoulesPerKilogram, WattDaysPerShortTonTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromWattDaysPerTonne(jouleperkilogram.WattDaysPerTonne).JoulesPerKilogram, WattDaysPerTonneTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromWattHoursPerKilogram(jouleperkilogram.WattHoursPerKilogram).JoulesPerKilogram, WattHoursPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificEnergy.FromWattHoursPerPound(jouleperkilogram.WattHoursPerPound).JoulesPerKilogram, WattHoursPerPoundTolerance);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(3);
+            Assert.Equal(3, SpecificEnergy.FromBtuPerPound(jouleperkilogram.BtuPerPound).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromCaloriesPerGram(jouleperkilogram.CaloriesPerGram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromGigawattDaysPerKilogram(jouleperkilogram.GigawattDaysPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromGigawattDaysPerShortTon(jouleperkilogram.GigawattDaysPerShortTon).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromGigawattDaysPerTonne(jouleperkilogram.GigawattDaysPerTonne).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromGigawattHoursPerKilogram(jouleperkilogram.GigawattHoursPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromGigawattHoursPerPound(jouleperkilogram.GigawattHoursPerPound).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromJoulesPerKilogram(jouleperkilogram.JoulesPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromKilocaloriesPerGram(jouleperkilogram.KilocaloriesPerGram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromKilojoulesPerKilogram(jouleperkilogram.KilojoulesPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromKilowattDaysPerKilogram(jouleperkilogram.KilowattDaysPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromKilowattDaysPerShortTon(jouleperkilogram.KilowattDaysPerShortTon).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromKilowattDaysPerTonne(jouleperkilogram.KilowattDaysPerTonne).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromKilowattHoursPerKilogram(jouleperkilogram.KilowattHoursPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromKilowattHoursPerPound(jouleperkilogram.KilowattHoursPerPound).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromMegajoulesPerKilogram(jouleperkilogram.MegajoulesPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromMegajoulesPerTonne(jouleperkilogram.MegajoulesPerTonne).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromMegawattDaysPerKilogram(jouleperkilogram.MegawattDaysPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromMegawattDaysPerShortTon(jouleperkilogram.MegawattDaysPerShortTon).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromMegawattDaysPerTonne(jouleperkilogram.MegawattDaysPerTonne).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromMegawattHoursPerKilogram(jouleperkilogram.MegawattHoursPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromMegawattHoursPerPound(jouleperkilogram.MegawattHoursPerPound).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromTerawattDaysPerKilogram(jouleperkilogram.TerawattDaysPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromTerawattDaysPerShortTon(jouleperkilogram.TerawattDaysPerShortTon).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromTerawattDaysPerTonne(jouleperkilogram.TerawattDaysPerTonne).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromWattDaysPerKilogram(jouleperkilogram.WattDaysPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromWattDaysPerShortTon(jouleperkilogram.WattDaysPerShortTon).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromWattDaysPerTonne(jouleperkilogram.WattDaysPerTonne).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromWattHoursPerKilogram(jouleperkilogram.WattHoursPerKilogram).JoulesPerKilogram);
+            Assert.Equal(3, SpecificEnergy.FromWattHoursPerPound(jouleperkilogram.WattHoursPerPound).JoulesPerKilogram);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             SpecificEnergy v = SpecificEnergy.FromJoulesPerKilogram(1);
-            AssertEx.EqualTolerance(-1, -v.JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (SpecificEnergy.FromJoulesPerKilogram(3)-v).JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (v + v).JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(10, (v*10).JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(10, (10*v).JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (SpecificEnergy.FromJoulesPerKilogram(10)/5).JoulesPerKilogram, JoulesPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, SpecificEnergy.FromJoulesPerKilogram(10)/SpecificEnergy.FromJoulesPerKilogram(5), JoulesPerKilogramTolerance);
+            Assert.Equal(-1, -v.JoulesPerKilogram);
+            Assert.Equal(2, (SpecificEnergy.FromJoulesPerKilogram(3) - v).JoulesPerKilogram);
+            Assert.Equal(2, (v + v).JoulesPerKilogram);
+            Assert.Equal(10, (v * 10).JoulesPerKilogram);
+            Assert.Equal(10, (10 * v).JoulesPerKilogram);
+            Assert.Equal(2, (SpecificEnergy.FromJoulesPerKilogram(10) / 5).JoulesPerKilogram);
+            Assert.Equal(2, SpecificEnergy.FromJoulesPerKilogram(10) / SpecificEnergy.FromJoulesPerKilogram(5));
         }
 
         [Fact]
@@ -992,8 +1052,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, SpecificEnergyUnit.JoulePerKilogram, 1, SpecificEnergyUnit.JoulePerKilogram, true)]  // Same value and unit.
         [InlineData(1, SpecificEnergyUnit.JoulePerKilogram, 2, SpecificEnergyUnit.JoulePerKilogram, false)] // Different value.
-        [InlineData(2, SpecificEnergyUnit.JoulePerKilogram, 1, SpecificEnergyUnit.BtuPerPound, false)] // Different value and unit.
-        [InlineData(1, SpecificEnergyUnit.JoulePerKilogram, 1, SpecificEnergyUnit.BtuPerPound, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, SpecificEnergyUnit unitA, double valueB, SpecificEnergyUnit unitB, bool expectEqual)
         {
             var a = new SpecificEnergy(valueA, unitA);
@@ -1053,8 +1111,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = SpecificEnergy.FromJoulesPerKilogram(firstValue);
             var otherQuantity = SpecificEnergy.FromJoulesPerKilogram(secondValue);
             SpecificEnergy maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, SpecificEnergy.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1073,7 +1131,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<SpecificEnergyUnit>();
+            var units = EnumHelper.GetValues<SpecificEnergyUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1086,6 +1144,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(SpecificEnergy.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(SpecificEnergy.Info.Units, SpecificEnergy.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, SpecificEnergy.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1160,26 +1230,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 Wh/lbs", new SpecificEnergy(1, SpecificEnergyUnit.WattHourPerPound).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 J/kg", new SpecificEnergy(0.123456, SpecificEnergyUnit.JoulePerKilogram).ToString("s1"));
-            Assert.Equal("0.12 J/kg", new SpecificEnergy(0.123456, SpecificEnergyUnit.JoulePerKilogram).ToString("s2"));
-            Assert.Equal("0.123 J/kg", new SpecificEnergy(0.123456, SpecificEnergyUnit.JoulePerKilogram).ToString("s3"));
-            Assert.Equal("0.1235 J/kg", new SpecificEnergy(0.123456, SpecificEnergyUnit.JoulePerKilogram).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 J/kg", new SpecificEnergy(0.123456, SpecificEnergyUnit.JoulePerKilogram).ToString("s1", culture));
-            Assert.Equal("0.12 J/kg", new SpecificEnergy(0.123456, SpecificEnergyUnit.JoulePerKilogram).ToString("s2", culture));
-            Assert.Equal("0.123 J/kg", new SpecificEnergy(0.123456, SpecificEnergyUnit.JoulePerKilogram).ToString("s3", culture));
-            Assert.Equal("0.1235 J/kg", new SpecificEnergy(0.123456, SpecificEnergyUnit.JoulePerKilogram).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1206,7 +1256,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = SpecificEnergy.FromJoulesPerKilogram(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(SpecificEnergy), quantity.As(SpecificEnergy.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs
index 5695566514..862d623c58 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificEntropyTestsBase.g.cs
@@ -157,6 +157,20 @@ public void SpecificEntropy_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<SpecificEntropyUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void SpecificEntropyInfo_CreateWithCustomUnitInfos()
+        {
+            SpecificEntropyUnit[] expectedUnits = [SpecificEntropyUnit.JoulePerKilogramKelvin];
+
+            SpecificEntropy.SpecificEntropyInfo quantityInfo = SpecificEntropy.SpecificEntropyInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("SpecificEntropy", quantityInfo.Name);
+            Assert.Equal(SpecificEntropy.Zero, quantityInfo.Zero);
+            Assert.Equal(SpecificEntropy.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void JoulePerKilogramKelvinToSpecificEntropyUnits()
         {
@@ -257,26 +271,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = SpecificEntropy.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            SpecificEntropy convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                SpecificEntropy quantityToConvert = quantity;
+
+                SpecificEntropy convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<SpecificEntropyUnit> quantityToConvert = quantity;
+
+                IQuantity<SpecificEntropyUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new SpecificEntropy(value: 1, unit: SpecificEntropy.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new SpecificEntropy(value: 1, unit: SpecificEntropy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpecificEntropyUnit> quantity = new SpecificEntropy(value: 1, unit: SpecificEntropy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new SpecificEntropy(value: 1, unit: SpecificEntropy.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new SpecificEntropy(value: 1, unit: SpecificEntropy.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new SpecificEntropy(value: 1, unit: SpecificEntropy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpecificEntropyUnit> quantity = new SpecificEntropy(value: 1, unit: SpecificEntropy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new SpecificEntropy(value: 1, unit: SpecificEntropy.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -290,7 +347,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 kJ/kg·K", SpecificEntropyUnit.KilojoulePerKilogramKelvin, 4.2)]
         [InlineData("en-US", "4.2 MJ/kg·°C", SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 MJ/kg·K", SpecificEntropyUnit.MegajoulePerKilogramKelvin, 4.2)]
-        public void Parse(string culture, string quantityString, SpecificEntropyUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, SpecificEntropyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = SpecificEntropy.Parse(quantityString);
@@ -309,7 +366,7 @@ public void Parse(string culture, string quantityString, SpecificEntropyUnit exp
         [InlineData("en-US", "4.2 kJ/kg·K", SpecificEntropyUnit.KilojoulePerKilogramKelvin, 4.2)]
         [InlineData("en-US", "4.2 MJ/kg·°C", SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 MJ/kg·K", SpecificEntropyUnit.MegajoulePerKilogramKelvin, 4.2)]
-        public void TryParse(string culture, string quantityString, SpecificEntropyUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, SpecificEntropyUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(SpecificEntropy.TryParse(quantityString, out SpecificEntropy parsed));
@@ -522,6 +579,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(SpecificEntropyU
                 var quantity = SpecificEntropy.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -545,40 +603,42 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(SpecificEntropyUnit
                 IQuantity<SpecificEntropyUnit> quantityToConvert = quantity;
                 IQuantity<SpecificEntropyUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            SpecificEntropy jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromBtusPerPoundFahrenheit(jouleperkilogramkelvin.BtusPerPoundFahrenheit).JoulesPerKilogramKelvin, BtusPerPoundFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromCaloriesPerGramKelvin(jouleperkilogramkelvin.CaloriesPerGramKelvin).JoulesPerKilogramKelvin, CaloriesPerGramKelvinTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.JoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin, JoulesPerKilogramDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromJoulesPerKilogramKelvin(jouleperkilogramkelvin.JoulesPerKilogramKelvin).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromKilocaloriesPerGramKelvin(jouleperkilogramkelvin.KilocaloriesPerGramKelvin).JoulesPerKilogramKelvin, KilocaloriesPerGramKelvinTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.KilojoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin, KilojoulesPerKilogramDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromKilojoulesPerKilogramKelvin(jouleperkilogramkelvin.KilojoulesPerKilogramKelvin).JoulesPerKilogramKelvin, KilojoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.MegajoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin, MegajoulesPerKilogramDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, SpecificEntropy.FromMegajoulesPerKilogramKelvin(jouleperkilogramkelvin.MegajoulesPerKilogramKelvin).JoulesPerKilogramKelvin, MegajoulesPerKilogramKelvinTolerance);
+            SpecificEntropy jouleperkilogramkelvin = SpecificEntropy.FromJoulesPerKilogramKelvin(3);
+            Assert.Equal(3, SpecificEntropy.FromBtusPerPoundFahrenheit(jouleperkilogramkelvin.BtusPerPoundFahrenheit).JoulesPerKilogramKelvin);
+            Assert.Equal(3, SpecificEntropy.FromCaloriesPerGramKelvin(jouleperkilogramkelvin.CaloriesPerGramKelvin).JoulesPerKilogramKelvin);
+            Assert.Equal(3, SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.JoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin);
+            Assert.Equal(3, SpecificEntropy.FromJoulesPerKilogramKelvin(jouleperkilogramkelvin.JoulesPerKilogramKelvin).JoulesPerKilogramKelvin);
+            Assert.Equal(3, SpecificEntropy.FromKilocaloriesPerGramKelvin(jouleperkilogramkelvin.KilocaloriesPerGramKelvin).JoulesPerKilogramKelvin);
+            Assert.Equal(3, SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.KilojoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin);
+            Assert.Equal(3, SpecificEntropy.FromKilojoulesPerKilogramKelvin(jouleperkilogramkelvin.KilojoulesPerKilogramKelvin).JoulesPerKilogramKelvin);
+            Assert.Equal(3, SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(jouleperkilogramkelvin.MegajoulesPerKilogramDegreeCelsius).JoulesPerKilogramKelvin);
+            Assert.Equal(3, SpecificEntropy.FromMegajoulesPerKilogramKelvin(jouleperkilogramkelvin.MegajoulesPerKilogramKelvin).JoulesPerKilogramKelvin);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             SpecificEntropy v = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
-            AssertEx.EqualTolerance(-1, -v.JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(2, (SpecificEntropy.FromJoulesPerKilogramKelvin(3)-v).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(2, (v + v).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(10, (v*10).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(10, (10*v).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(2, (SpecificEntropy.FromJoulesPerKilogramKelvin(10)/5).JoulesPerKilogramKelvin, JoulesPerKilogramKelvinTolerance);
-            AssertEx.EqualTolerance(2, SpecificEntropy.FromJoulesPerKilogramKelvin(10)/SpecificEntropy.FromJoulesPerKilogramKelvin(5), JoulesPerKilogramKelvinTolerance);
+            Assert.Equal(-1, -v.JoulesPerKilogramKelvin);
+            Assert.Equal(2, (SpecificEntropy.FromJoulesPerKilogramKelvin(3) - v).JoulesPerKilogramKelvin);
+            Assert.Equal(2, (v + v).JoulesPerKilogramKelvin);
+            Assert.Equal(10, (v * 10).JoulesPerKilogramKelvin);
+            Assert.Equal(10, (10 * v).JoulesPerKilogramKelvin);
+            Assert.Equal(2, (SpecificEntropy.FromJoulesPerKilogramKelvin(10) / 5).JoulesPerKilogramKelvin);
+            Assert.Equal(2, SpecificEntropy.FromJoulesPerKilogramKelvin(10) / SpecificEntropy.FromJoulesPerKilogramKelvin(5));
         }
 
         [Fact]
@@ -624,8 +684,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, SpecificEntropyUnit.JoulePerKilogramKelvin, 1, SpecificEntropyUnit.JoulePerKilogramKelvin, true)]  // Same value and unit.
         [InlineData(1, SpecificEntropyUnit.JoulePerKilogramKelvin, 2, SpecificEntropyUnit.JoulePerKilogramKelvin, false)] // Different value.
-        [InlineData(2, SpecificEntropyUnit.JoulePerKilogramKelvin, 1, SpecificEntropyUnit.BtuPerPoundFahrenheit, false)] // Different value and unit.
-        [InlineData(1, SpecificEntropyUnit.JoulePerKilogramKelvin, 1, SpecificEntropyUnit.BtuPerPoundFahrenheit, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, SpecificEntropyUnit unitA, double valueB, SpecificEntropyUnit unitB, bool expectEqual)
         {
             var a = new SpecificEntropy(valueA, unitA);
@@ -685,8 +743,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = SpecificEntropy.FromJoulesPerKilogramKelvin(firstValue);
             var otherQuantity = SpecificEntropy.FromJoulesPerKilogramKelvin(secondValue);
             SpecificEntropy maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, SpecificEntropy.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -705,7 +763,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<SpecificEntropyUnit>();
+            var units = EnumHelper.GetValues<SpecificEntropyUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -718,6 +776,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(SpecificEntropy.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(SpecificEntropy.Info.Units, SpecificEntropy.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, SpecificEntropy.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -750,26 +820,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 MJ/kg·K", new SpecificEntropy(1, SpecificEntropyUnit.MegajoulePerKilogramKelvin).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 J/kg·K", new SpecificEntropy(0.123456, SpecificEntropyUnit.JoulePerKilogramKelvin).ToString("s1"));
-            Assert.Equal("0.12 J/kg·K", new SpecificEntropy(0.123456, SpecificEntropyUnit.JoulePerKilogramKelvin).ToString("s2"));
-            Assert.Equal("0.123 J/kg·K", new SpecificEntropy(0.123456, SpecificEntropyUnit.JoulePerKilogramKelvin).ToString("s3"));
-            Assert.Equal("0.1235 J/kg·K", new SpecificEntropy(0.123456, SpecificEntropyUnit.JoulePerKilogramKelvin).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 J/kg·K", new SpecificEntropy(0.123456, SpecificEntropyUnit.JoulePerKilogramKelvin).ToString("s1", culture));
-            Assert.Equal("0.12 J/kg·K", new SpecificEntropy(0.123456, SpecificEntropyUnit.JoulePerKilogramKelvin).ToString("s2", culture));
-            Assert.Equal("0.123 J/kg·K", new SpecificEntropy(0.123456, SpecificEntropyUnit.JoulePerKilogramKelvin).ToString("s3", culture));
-            Assert.Equal("0.1235 J/kg·K", new SpecificEntropy(0.123456, SpecificEntropyUnit.JoulePerKilogramKelvin).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -796,7 +846,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = SpecificEntropy.FromJoulesPerKilogramKelvin(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(SpecificEntropy), quantity.As(SpecificEntropy.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificFuelConsumptionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificFuelConsumptionTestsBase.g.cs
index ecae77e791..23cce9f5a9 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificFuelConsumptionTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificFuelConsumptionTestsBase.g.cs
@@ -137,6 +137,20 @@ public void SpecificFuelConsumption_QuantityInfo_ReturnsQuantityInfoDescribingQu
             Assert.Equal(quantityInfo, ((IQuantity<SpecificFuelConsumptionUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void SpecificFuelConsumptionInfo_CreateWithCustomUnitInfos()
+        {
+            SpecificFuelConsumptionUnit[] expectedUnits = [SpecificFuelConsumptionUnit.GramPerKilonewtonSecond];
+
+            SpecificFuelConsumption.SpecificFuelConsumptionInfo quantityInfo = SpecificFuelConsumption.SpecificFuelConsumptionInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("SpecificFuelConsumption", quantityInfo.Name);
+            Assert.Equal(SpecificFuelConsumption.Zero, quantityInfo.Zero);
+            Assert.Equal(SpecificFuelConsumption.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void GramPerKilonewtonSecondToSpecificFuelConsumptionUnits()
         {
@@ -227,26 +241,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = SpecificFuelConsumption.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            SpecificFuelConsumption convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                SpecificFuelConsumption quantityToConvert = quantity;
+
+                SpecificFuelConsumption convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<SpecificFuelConsumptionUnit> quantityToConvert = quantity;
+
+                IQuantity<SpecificFuelConsumptionUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new SpecificFuelConsumption(value: 1, unit: SpecificFuelConsumption.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new SpecificFuelConsumption(value: 1, unit: SpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpecificFuelConsumptionUnit> quantity = new SpecificFuelConsumption(value: 1, unit: SpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new SpecificFuelConsumption(value: 1, unit: SpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new SpecificFuelConsumption(value: 1, unit: SpecificFuelConsumption.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new SpecificFuelConsumption(value: 1, unit: SpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpecificFuelConsumptionUnit> quantity = new SpecificFuelConsumption(value: 1, unit: SpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new SpecificFuelConsumption(value: 1, unit: SpecificFuelConsumption.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -254,7 +311,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 kg/(kgf·h)", SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour, 4.2)]
         [InlineData("en-US", "4.2 kg/(kN·s)", SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond, 4.2)]
         [InlineData("en-US", "4.2 lb/(lbf·h)", SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour, 4.2)]
-        public void Parse(string culture, string quantityString, SpecificFuelConsumptionUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, SpecificFuelConsumptionUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = SpecificFuelConsumption.Parse(quantityString);
@@ -267,7 +324,7 @@ public void Parse(string culture, string quantityString, SpecificFuelConsumption
         [InlineData("en-US", "4.2 kg/(kgf·h)", SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour, 4.2)]
         [InlineData("en-US", "4.2 kg/(kN·s)", SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond, 4.2)]
         [InlineData("en-US", "4.2 lb/(lbf·h)", SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour, 4.2)]
-        public void TryParse(string culture, string quantityString, SpecificFuelConsumptionUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, SpecificFuelConsumptionUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(SpecificFuelConsumption.TryParse(quantityString, out SpecificFuelConsumption parsed));
@@ -427,6 +484,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(SpecificFuelCons
                 var quantity = SpecificFuelConsumption.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -450,35 +508,37 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(SpecificFuelConsump
                 IQuantity<SpecificFuelConsumptionUnit> quantityToConvert = quantity;
                 IQuantity<SpecificFuelConsumptionUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            SpecificFuelConsumption gramperkilonewtonsecond = SpecificFuelConsumption.FromGramsPerKilonewtonSecond(1);
-            AssertEx.EqualTolerance(1, SpecificFuelConsumption.FromGramsPerKilonewtonSecond(gramperkilonewtonsecond.GramsPerKilonewtonSecond).GramsPerKilonewtonSecond, GramsPerKilonewtonSecondTolerance);
-            AssertEx.EqualTolerance(1, SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(gramperkilonewtonsecond.KilogramsPerKilogramForceHour).GramsPerKilonewtonSecond, KilogramsPerKilogramForceHourTolerance);
-            AssertEx.EqualTolerance(1, SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(gramperkilonewtonsecond.KilogramsPerKilonewtonSecond).GramsPerKilonewtonSecond, KilogramsPerKilonewtonSecondTolerance);
-            AssertEx.EqualTolerance(1, SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(gramperkilonewtonsecond.PoundsMassPerPoundForceHour).GramsPerKilonewtonSecond, PoundsMassPerPoundForceHourTolerance);
+            SpecificFuelConsumption gramperkilonewtonsecond = SpecificFuelConsumption.FromGramsPerKilonewtonSecond(3);
+            Assert.Equal(3, SpecificFuelConsumption.FromGramsPerKilonewtonSecond(gramperkilonewtonsecond.GramsPerKilonewtonSecond).GramsPerKilonewtonSecond);
+            Assert.Equal(3, SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(gramperkilonewtonsecond.KilogramsPerKilogramForceHour).GramsPerKilonewtonSecond);
+            Assert.Equal(3, SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(gramperkilonewtonsecond.KilogramsPerKilonewtonSecond).GramsPerKilonewtonSecond);
+            Assert.Equal(3, SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(gramperkilonewtonsecond.PoundsMassPerPoundForceHour).GramsPerKilonewtonSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             SpecificFuelConsumption v = SpecificFuelConsumption.FromGramsPerKilonewtonSecond(1);
-            AssertEx.EqualTolerance(-1, -v.GramsPerKilonewtonSecond, GramsPerKilonewtonSecondTolerance);
-            AssertEx.EqualTolerance(2, (SpecificFuelConsumption.FromGramsPerKilonewtonSecond(3)-v).GramsPerKilonewtonSecond, GramsPerKilonewtonSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).GramsPerKilonewtonSecond, GramsPerKilonewtonSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).GramsPerKilonewtonSecond, GramsPerKilonewtonSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).GramsPerKilonewtonSecond, GramsPerKilonewtonSecondTolerance);
-            AssertEx.EqualTolerance(2, (SpecificFuelConsumption.FromGramsPerKilonewtonSecond(10)/5).GramsPerKilonewtonSecond, GramsPerKilonewtonSecondTolerance);
-            AssertEx.EqualTolerance(2, SpecificFuelConsumption.FromGramsPerKilonewtonSecond(10)/SpecificFuelConsumption.FromGramsPerKilonewtonSecond(5), GramsPerKilonewtonSecondTolerance);
+            Assert.Equal(-1, -v.GramsPerKilonewtonSecond);
+            Assert.Equal(2, (SpecificFuelConsumption.FromGramsPerKilonewtonSecond(3) - v).GramsPerKilonewtonSecond);
+            Assert.Equal(2, (v + v).GramsPerKilonewtonSecond);
+            Assert.Equal(10, (v * 10).GramsPerKilonewtonSecond);
+            Assert.Equal(10, (10 * v).GramsPerKilonewtonSecond);
+            Assert.Equal(2, (SpecificFuelConsumption.FromGramsPerKilonewtonSecond(10) / 5).GramsPerKilonewtonSecond);
+            Assert.Equal(2, SpecificFuelConsumption.FromGramsPerKilonewtonSecond(10) / SpecificFuelConsumption.FromGramsPerKilonewtonSecond(5));
         }
 
         [Fact]
@@ -524,8 +584,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, 1, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, true)]  // Same value and unit.
         [InlineData(1, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, 2, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, false)] // Different value.
-        [InlineData(2, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, 1, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour, false)] // Different value and unit.
-        [InlineData(1, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, 1, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, SpecificFuelConsumptionUnit unitA, double valueB, SpecificFuelConsumptionUnit unitB, bool expectEqual)
         {
             var a = new SpecificFuelConsumption(valueA, unitA);
@@ -585,8 +643,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = SpecificFuelConsumption.FromGramsPerKilonewtonSecond(firstValue);
             var otherQuantity = SpecificFuelConsumption.FromGramsPerKilonewtonSecond(secondValue);
             SpecificFuelConsumption maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, SpecificFuelConsumption.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -605,7 +663,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<SpecificFuelConsumptionUnit>();
+            var units = EnumHelper.GetValues<SpecificFuelConsumptionUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -618,6 +676,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(SpecificFuelConsumption.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(SpecificFuelConsumption.Info.Units, SpecificFuelConsumption.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, SpecificFuelConsumption.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -640,26 +710,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 lb/(lbf·h)", new SpecificFuelConsumption(1, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 g/(kN·s)", new SpecificFuelConsumption(0.123456, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond).ToString("s1"));
-            Assert.Equal("0.12 g/(kN·s)", new SpecificFuelConsumption(0.123456, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond).ToString("s2"));
-            Assert.Equal("0.123 g/(kN·s)", new SpecificFuelConsumption(0.123456, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond).ToString("s3"));
-            Assert.Equal("0.1235 g/(kN·s)", new SpecificFuelConsumption(0.123456, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 g/(kN·s)", new SpecificFuelConsumption(0.123456, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond).ToString("s1", culture));
-            Assert.Equal("0.12 g/(kN·s)", new SpecificFuelConsumption(0.123456, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond).ToString("s2", culture));
-            Assert.Equal("0.123 g/(kN·s)", new SpecificFuelConsumption(0.123456, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 g/(kN·s)", new SpecificFuelConsumption(0.123456, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -686,7 +736,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = SpecificFuelConsumption.FromGramsPerKilonewtonSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(SpecificFuelConsumption), quantity.As(SpecificFuelConsumption.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs
index e9341cce8a..358ef9b100 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificVolumeTestsBase.g.cs
@@ -42,12 +42,12 @@ public abstract partial class SpecificVolumeTestsBase : QuantityTestsBase
     {
         protected abstract double CubicFeetPerPoundInOneCubicMeterPerKilogram { get; }
         protected abstract double CubicMetersPerKilogramInOneCubicMeterPerKilogram { get; }
-        protected abstract double MillicubicMetersPerKilogramInOneCubicMeterPerKilogram { get; }
+        protected abstract double CubicMillimetersPerKilogramInOneCubicMeterPerKilogram { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double CubicFeetPerPoundTolerance { get { return 1e-5; } }
         protected virtual double CubicMetersPerKilogramTolerance { get { return 1e-5; } }
-        protected virtual double MillicubicMetersPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double CubicMillimetersPerKilogramTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(SpecificVolumeUnit unit)
@@ -56,7 +56,7 @@ public abstract partial class SpecificVolumeTestsBase : QuantityTestsBase
             {
                 SpecificVolumeUnit.CubicFootPerPound => (CubicFeetPerPoundInOneCubicMeterPerKilogram, CubicFeetPerPoundTolerance),
                 SpecificVolumeUnit.CubicMeterPerKilogram => (CubicMetersPerKilogramInOneCubicMeterPerKilogram, CubicMetersPerKilogramTolerance),
-                SpecificVolumeUnit.MillicubicMeterPerKilogram => (MillicubicMetersPerKilogramInOneCubicMeterPerKilogram, MillicubicMetersPerKilogramTolerance),
+                SpecificVolumeUnit.CubicMillimeterPerKilogram => (CubicMillimetersPerKilogramInOneCubicMeterPerKilogram, CubicMillimetersPerKilogramTolerance),
                 _ => throw new NotSupportedException()
             };
         }
@@ -65,7 +65,7 @@ public abstract partial class SpecificVolumeTestsBase : QuantityTestsBase
         {
             new object[] { SpecificVolumeUnit.CubicFootPerPound },
             new object[] { SpecificVolumeUnit.CubicMeterPerKilogram },
-            new object[] { SpecificVolumeUnit.MillicubicMeterPerKilogram },
+            new object[] { SpecificVolumeUnit.CubicMillimeterPerKilogram },
         };
 
         [Fact]
@@ -133,13 +133,27 @@ public void SpecificVolume_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<SpecificVolumeUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void SpecificVolumeInfo_CreateWithCustomUnitInfos()
+        {
+            SpecificVolumeUnit[] expectedUnits = [SpecificVolumeUnit.CubicMeterPerKilogram];
+
+            SpecificVolume.SpecificVolumeInfo quantityInfo = SpecificVolume.SpecificVolumeInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("SpecificVolume", quantityInfo.Name);
+            Assert.Equal(SpecificVolume.Zero, quantityInfo.Zero);
+            Assert.Equal(SpecificVolume.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CubicMeterPerKilogramToSpecificVolumeUnits()
         {
             SpecificVolume cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
             AssertEx.EqualTolerance(CubicFeetPerPoundInOneCubicMeterPerKilogram, cubicmeterperkilogram.CubicFeetPerPound, CubicFeetPerPoundTolerance);
             AssertEx.EqualTolerance(CubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(MillicubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.MillicubicMetersPerKilogram, MillicubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(CubicMillimetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.CubicMillimetersPerKilogram, CubicMillimetersPerKilogramTolerance);
         }
 
         [Fact]
@@ -177,7 +191,7 @@ public void As()
             var cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
             AssertEx.EqualTolerance(CubicFeetPerPoundInOneCubicMeterPerKilogram, cubicmeterperkilogram.As(SpecificVolumeUnit.CubicFootPerPound), CubicFeetPerPoundTolerance);
             AssertEx.EqualTolerance(CubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.As(SpecificVolumeUnit.CubicMeterPerKilogram), CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(MillicubicMetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.As(SpecificVolumeUnit.MillicubicMeterPerKilogram), MillicubicMetersPerKilogramTolerance);
+            AssertEx.EqualTolerance(CubicMillimetersPerKilogramInOneCubicMeterPerKilogram, cubicmeterperkilogram.As(SpecificVolumeUnit.CubicMillimeterPerKilogram), CubicMillimetersPerKilogramTolerance);
         }
 
         [Fact]
@@ -221,33 +235,76 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = SpecificVolume.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            SpecificVolume convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                SpecificVolume quantityToConvert = quantity;
+
+                SpecificVolume convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<SpecificVolumeUnit> quantityToConvert = quantity;
+
+                IQuantity<SpecificVolumeUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new SpecificVolume(value: 1, unit: SpecificVolume.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new SpecificVolume(value: 1, unit: SpecificVolume.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpecificVolumeUnit> quantity = new SpecificVolume(value: 1, unit: SpecificVolume.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new SpecificVolume(value: 1, unit: SpecificVolume.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new SpecificVolume(value: 1, unit: SpecificVolume.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new SpecificVolume(value: 1, unit: SpecificVolume.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpecificVolumeUnit> quantity = new SpecificVolume(value: 1, unit: SpecificVolume.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new SpecificVolume(value: 1, unit: SpecificVolume.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 ft³/lb", SpecificVolumeUnit.CubicFootPerPound, 4.2)]
         [InlineData("en-US", "4.2 m³/kg", SpecificVolumeUnit.CubicMeterPerKilogram, 4.2)]
-        [InlineData("en-US", "4.2 mm³/kg", SpecificVolumeUnit.MillicubicMeterPerKilogram, 4.2)]
-        public void Parse(string culture, string quantityString, SpecificVolumeUnit expectedUnit, double expectedValue)
+        [InlineData("en-US", "4.2 mm³/kg", SpecificVolumeUnit.CubicMillimeterPerKilogram, 4.2)]
+        public void Parse(string culture, string quantityString, SpecificVolumeUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = SpecificVolume.Parse(quantityString);
@@ -258,8 +315,8 @@ public void Parse(string culture, string quantityString, SpecificVolumeUnit expe
         [Theory]
         [InlineData("en-US", "4.2 ft³/lb", SpecificVolumeUnit.CubicFootPerPound, 4.2)]
         [InlineData("en-US", "4.2 m³/kg", SpecificVolumeUnit.CubicMeterPerKilogram, 4.2)]
-        [InlineData("en-US", "4.2 mm³/kg", SpecificVolumeUnit.MillicubicMeterPerKilogram, 4.2)]
-        public void TryParse(string culture, string quantityString, SpecificVolumeUnit expectedUnit, double expectedValue)
+        [InlineData("en-US", "4.2 mm³/kg", SpecificVolumeUnit.CubicMillimeterPerKilogram, 4.2)]
+        public void TryParse(string culture, string quantityString, SpecificVolumeUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(SpecificVolume.TryParse(quantityString, out SpecificVolume parsed));
@@ -270,7 +327,7 @@ public void TryParse(string culture, string quantityString, SpecificVolumeUnit e
         [Theory]
         [InlineData("ft³/lb", SpecificVolumeUnit.CubicFootPerPound)]
         [InlineData("m³/kg", SpecificVolumeUnit.CubicMeterPerKilogram)]
-        [InlineData("mm³/kg", SpecificVolumeUnit.MillicubicMeterPerKilogram)]
+        [InlineData("mm³/kg", SpecificVolumeUnit.CubicMillimeterPerKilogram)]
         public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, SpecificVolumeUnit expectedUnit)
         {
             // Fallback culture "en-US" is always localized
@@ -282,7 +339,7 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, SpecificV
         [Theory]
         [InlineData("ft³/lb", SpecificVolumeUnit.CubicFootPerPound)]
         [InlineData("m³/kg", SpecificVolumeUnit.CubicMeterPerKilogram)]
-        [InlineData("mm³/kg", SpecificVolumeUnit.MillicubicMeterPerKilogram)]
+        [InlineData("mm³/kg", SpecificVolumeUnit.CubicMillimeterPerKilogram)]
         public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, SpecificVolumeUnit expectedUnit)
         {
             // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing.
@@ -294,7 +351,7 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [Theory]
         [InlineData("en-US", "ft³/lb", SpecificVolumeUnit.CubicFootPerPound)]
         [InlineData("en-US", "m³/kg", SpecificVolumeUnit.CubicMeterPerKilogram)]
-        [InlineData("en-US", "mm³/kg", SpecificVolumeUnit.MillicubicMeterPerKilogram)]
+        [InlineData("en-US", "mm³/kg", SpecificVolumeUnit.CubicMillimeterPerKilogram)]
         public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, SpecificVolumeUnit expectedUnit)
         {
             using var _ = new CultureScope(culture);
@@ -305,7 +362,7 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Sp
         [Theory]
         [InlineData("en-US", "ft³/lb", SpecificVolumeUnit.CubicFootPerPound)]
         [InlineData("en-US", "m³/kg", SpecificVolumeUnit.CubicMeterPerKilogram)]
-        [InlineData("en-US", "mm³/kg", SpecificVolumeUnit.MillicubicMeterPerKilogram)]
+        [InlineData("en-US", "mm³/kg", SpecificVolumeUnit.CubicMillimeterPerKilogram)]
         public void ParseUnit_WithCulture(string culture, string abbreviation, SpecificVolumeUnit expectedUnit)
         {
             SpecificVolumeUnit parsedUnit = SpecificVolume.ParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture));
@@ -315,7 +372,7 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, SpecificV
         [Theory]
         [InlineData("ft³/lb", SpecificVolumeUnit.CubicFootPerPound)]
         [InlineData("m³/kg", SpecificVolumeUnit.CubicMeterPerKilogram)]
-        [InlineData("mm³/kg", SpecificVolumeUnit.MillicubicMeterPerKilogram)]
+        [InlineData("mm³/kg", SpecificVolumeUnit.CubicMillimeterPerKilogram)]
         public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, SpecificVolumeUnit expectedUnit)
         {
             // Fallback culture "en-US" is always localized
@@ -327,7 +384,7 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Specif
         [Theory]
         [InlineData("ft³/lb", SpecificVolumeUnit.CubicFootPerPound)]
         [InlineData("m³/kg", SpecificVolumeUnit.CubicMeterPerKilogram)]
-        [InlineData("mm³/kg", SpecificVolumeUnit.MillicubicMeterPerKilogram)]
+        [InlineData("mm³/kg", SpecificVolumeUnit.CubicMillimeterPerKilogram)]
         public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, SpecificVolumeUnit expectedUnit)
         {
             // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing.
@@ -339,7 +396,7 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [Theory]
         [InlineData("en-US", "ft³/lb", SpecificVolumeUnit.CubicFootPerPound)]
         [InlineData("en-US", "m³/kg", SpecificVolumeUnit.CubicMeterPerKilogram)]
-        [InlineData("en-US", "mm³/kg", SpecificVolumeUnit.MillicubicMeterPerKilogram)]
+        [InlineData("en-US", "mm³/kg", SpecificVolumeUnit.CubicMillimeterPerKilogram)]
         public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, SpecificVolumeUnit expectedUnit)
         {
             using var _ = new CultureScope(culture);
@@ -350,7 +407,7 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [Theory]
         [InlineData("en-US", "ft³/lb", SpecificVolumeUnit.CubicFootPerPound)]
         [InlineData("en-US", "m³/kg", SpecificVolumeUnit.CubicMeterPerKilogram)]
-        [InlineData("en-US", "mm³/kg", SpecificVolumeUnit.MillicubicMeterPerKilogram)]
+        [InlineData("en-US", "mm³/kg", SpecificVolumeUnit.CubicMillimeterPerKilogram)]
         public void TryParseUnit_WithCulture(string culture, string abbreviation, SpecificVolumeUnit expectedUnit)
         {
             Assert.True(SpecificVolume.TryParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture), out SpecificVolumeUnit parsedUnit));
@@ -360,7 +417,7 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Specif
         [Theory]
         [InlineData("en-US", SpecificVolumeUnit.CubicFootPerPound, "ft³/lb")]
         [InlineData("en-US", SpecificVolumeUnit.CubicMeterPerKilogram, "m³/kg")]
-        [InlineData("en-US", SpecificVolumeUnit.MillicubicMeterPerKilogram, "mm³/kg")]
+        [InlineData("en-US", SpecificVolumeUnit.CubicMillimeterPerKilogram, "mm³/kg")]
         public void GetAbbreviationForCulture(string culture, SpecificVolumeUnit unit, string expectedAbbreviation)
         {
             var defaultAbbreviation = SpecificVolume.GetAbbreviation(unit, CultureInfo.GetCultureInfo(culture));
@@ -410,6 +467,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(SpecificVolumeUn
                 var quantity = SpecificVolume.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -433,34 +491,36 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(SpecificVolumeUnit
                 IQuantity<SpecificVolumeUnit> quantityToConvert = quantity;
                 IQuantity<SpecificVolumeUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            SpecificVolume cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(1);
-            AssertEx.EqualTolerance(1, SpecificVolume.FromCubicFeetPerPound(cubicmeterperkilogram.CubicFeetPerPound).CubicMetersPerKilogram, CubicFeetPerPoundTolerance);
-            AssertEx.EqualTolerance(1, SpecificVolume.FromCubicMetersPerKilogram(cubicmeterperkilogram.CubicMetersPerKilogram).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(1, SpecificVolume.FromMillicubicMetersPerKilogram(cubicmeterperkilogram.MillicubicMetersPerKilogram).CubicMetersPerKilogram, MillicubicMetersPerKilogramTolerance);
+            SpecificVolume cubicmeterperkilogram = SpecificVolume.FromCubicMetersPerKilogram(3);
+            Assert.Equal(3, SpecificVolume.FromCubicFeetPerPound(cubicmeterperkilogram.CubicFeetPerPound).CubicMetersPerKilogram);
+            Assert.Equal(3, SpecificVolume.FromCubicMetersPerKilogram(cubicmeterperkilogram.CubicMetersPerKilogram).CubicMetersPerKilogram);
+            Assert.Equal(3, SpecificVolume.FromCubicMillimetersPerKilogram(cubicmeterperkilogram.CubicMillimetersPerKilogram).CubicMetersPerKilogram);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             SpecificVolume v = SpecificVolume.FromCubicMetersPerKilogram(1);
-            AssertEx.EqualTolerance(-1, -v.CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (SpecificVolume.FromCubicMetersPerKilogram(3)-v).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (v + v).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(10, (v*10).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(10, (10*v).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, (SpecificVolume.FromCubicMetersPerKilogram(10)/5).CubicMetersPerKilogram, CubicMetersPerKilogramTolerance);
-            AssertEx.EqualTolerance(2, SpecificVolume.FromCubicMetersPerKilogram(10)/SpecificVolume.FromCubicMetersPerKilogram(5), CubicMetersPerKilogramTolerance);
+            Assert.Equal(-1, -v.CubicMetersPerKilogram);
+            Assert.Equal(2, (SpecificVolume.FromCubicMetersPerKilogram(3) - v).CubicMetersPerKilogram);
+            Assert.Equal(2, (v + v).CubicMetersPerKilogram);
+            Assert.Equal(10, (v * 10).CubicMetersPerKilogram);
+            Assert.Equal(10, (10 * v).CubicMetersPerKilogram);
+            Assert.Equal(2, (SpecificVolume.FromCubicMetersPerKilogram(10) / 5).CubicMetersPerKilogram);
+            Assert.Equal(2, SpecificVolume.FromCubicMetersPerKilogram(10) / SpecificVolume.FromCubicMetersPerKilogram(5));
         }
 
         [Fact]
@@ -506,8 +566,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, SpecificVolumeUnit.CubicMeterPerKilogram, 1, SpecificVolumeUnit.CubicMeterPerKilogram, true)]  // Same value and unit.
         [InlineData(1, SpecificVolumeUnit.CubicMeterPerKilogram, 2, SpecificVolumeUnit.CubicMeterPerKilogram, false)] // Different value.
-        [InlineData(2, SpecificVolumeUnit.CubicMeterPerKilogram, 1, SpecificVolumeUnit.CubicFootPerPound, false)] // Different value and unit.
-        [InlineData(1, SpecificVolumeUnit.CubicMeterPerKilogram, 1, SpecificVolumeUnit.CubicFootPerPound, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, SpecificVolumeUnit unitA, double valueB, SpecificVolumeUnit unitB, bool expectEqual)
         {
             var a = new SpecificVolume(valueA, unitA);
@@ -567,8 +625,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = SpecificVolume.FromCubicMetersPerKilogram(firstValue);
             var otherQuantity = SpecificVolume.FromCubicMetersPerKilogram(secondValue);
             SpecificVolume maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, SpecificVolume.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -587,7 +645,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<SpecificVolumeUnit>();
+            var units = EnumHelper.GetValues<SpecificVolumeUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -600,13 +658,25 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(SpecificVolume.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(SpecificVolume.Info.Units, SpecificVolume.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, SpecificVolume.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
             using var _ = new CultureScope("en-US");
             Assert.Equal("1 ft³/lb", new SpecificVolume(1, SpecificVolumeUnit.CubicFootPerPound).ToString());
             Assert.Equal("1 m³/kg", new SpecificVolume(1, SpecificVolumeUnit.CubicMeterPerKilogram).ToString());
-            Assert.Equal("1 mm³/kg", new SpecificVolume(1, SpecificVolumeUnit.MillicubicMeterPerKilogram).ToString());
+            Assert.Equal("1 mm³/kg", new SpecificVolume(1, SpecificVolumeUnit.CubicMillimeterPerKilogram).ToString());
         }
 
         [Fact]
@@ -617,27 +687,7 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
 
             Assert.Equal("1 ft³/lb", new SpecificVolume(1, SpecificVolumeUnit.CubicFootPerPound).ToString(swedishCulture));
             Assert.Equal("1 m³/kg", new SpecificVolume(1, SpecificVolumeUnit.CubicMeterPerKilogram).ToString(swedishCulture));
-            Assert.Equal("1 mm³/kg", new SpecificVolume(1, SpecificVolumeUnit.MillicubicMeterPerKilogram).ToString(swedishCulture));
-        }
-
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m³/kg", new SpecificVolume(0.123456, SpecificVolumeUnit.CubicMeterPerKilogram).ToString("s1"));
-            Assert.Equal("0.12 m³/kg", new SpecificVolume(0.123456, SpecificVolumeUnit.CubicMeterPerKilogram).ToString("s2"));
-            Assert.Equal("0.123 m³/kg", new SpecificVolume(0.123456, SpecificVolumeUnit.CubicMeterPerKilogram).ToString("s3"));
-            Assert.Equal("0.1235 m³/kg", new SpecificVolume(0.123456, SpecificVolumeUnit.CubicMeterPerKilogram).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m³/kg", new SpecificVolume(0.123456, SpecificVolumeUnit.CubicMeterPerKilogram).ToString("s1", culture));
-            Assert.Equal("0.12 m³/kg", new SpecificVolume(0.123456, SpecificVolumeUnit.CubicMeterPerKilogram).ToString("s2", culture));
-            Assert.Equal("0.123 m³/kg", new SpecificVolume(0.123456, SpecificVolumeUnit.CubicMeterPerKilogram).ToString("s3", culture));
-            Assert.Equal("0.1235 m³/kg", new SpecificVolume(0.123456, SpecificVolumeUnit.CubicMeterPerKilogram).ToString("s4", culture));
+            Assert.Equal("1 mm³/kg", new SpecificVolume(1, SpecificVolumeUnit.CubicMillimeterPerKilogram).ToString(swedishCulture));
         }
 
         [Theory]
@@ -666,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = SpecificVolume.FromCubicMetersPerKilogram(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(SpecificVolume), quantity.As(SpecificVolume.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs
index 44dcf36ee8..0a4d41a76a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpecificWeightTestsBase.g.cs
@@ -189,6 +189,20 @@ public void SpecificWeight_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<SpecificWeightUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void SpecificWeightInfo_CreateWithCustomUnitInfos()
+        {
+            SpecificWeightUnit[] expectedUnits = [SpecificWeightUnit.NewtonPerCubicMeter];
+
+            SpecificWeight.SpecificWeightInfo quantityInfo = SpecificWeight.SpecificWeightInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("SpecificWeight", quantityInfo.Name);
+            Assert.Equal(SpecificWeight.Zero, quantityInfo.Zero);
+            Assert.Equal(SpecificWeight.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void NewtonPerCubicMeterToSpecificWeightUnits()
         {
@@ -305,26 +319,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = SpecificWeight.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            SpecificWeight convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                SpecificWeight quantityToConvert = quantity;
+
+                SpecificWeight convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<SpecificWeightUnit> quantityToConvert = quantity;
+
+                IQuantity<SpecificWeightUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new SpecificWeight(value: 1, unit: SpecificWeight.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new SpecificWeight(value: 1, unit: SpecificWeight.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpecificWeightUnit> quantity = new SpecificWeight(value: 1, unit: SpecificWeight.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new SpecificWeight(value: 1, unit: SpecificWeight.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new SpecificWeight(value: 1, unit: SpecificWeight.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new SpecificWeight(value: 1, unit: SpecificWeight.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpecificWeightUnit> quantity = new SpecificWeight(value: 1, unit: SpecificWeight.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new SpecificWeight(value: 1, unit: SpecificWeight.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -345,7 +402,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 tf/cm³", SpecificWeightUnit.TonneForcePerCubicCentimeter, 4.2)]
         [InlineData("en-US", "4.2 tf/m³", SpecificWeightUnit.TonneForcePerCubicMeter, 4.2)]
         [InlineData("en-US", "4.2 tf/mm³", SpecificWeightUnit.TonneForcePerCubicMillimeter, 4.2)]
-        public void Parse(string culture, string quantityString, SpecificWeightUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, SpecificWeightUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = SpecificWeight.Parse(quantityString);
@@ -371,7 +428,7 @@ public void Parse(string culture, string quantityString, SpecificWeightUnit expe
         [InlineData("en-US", "4.2 tf/cm³", SpecificWeightUnit.TonneForcePerCubicCentimeter, 4.2)]
         [InlineData("en-US", "4.2 tf/m³", SpecificWeightUnit.TonneForcePerCubicMeter, 4.2)]
         [InlineData("en-US", "4.2 tf/mm³", SpecificWeightUnit.TonneForcePerCubicMillimeter, 4.2)]
-        public void TryParse(string culture, string quantityString, SpecificWeightUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, SpecificWeightUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(SpecificWeight.TryParse(quantityString, out SpecificWeight parsed));
@@ -648,6 +705,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(SpecificWeightUn
                 var quantity = SpecificWeight.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -671,48 +729,50 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(SpecificWeightUnit
                 IQuantity<SpecificWeightUnit> quantityToConvert = quantity;
                 IQuantity<SpecificWeightUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilogramsForcePerCubicCentimeter(newtonpercubicmeter.KilogramsForcePerCubicCentimeter).NewtonsPerCubicMeter, KilogramsForcePerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilogramsForcePerCubicMeter(newtonpercubicmeter.KilogramsForcePerCubicMeter).NewtonsPerCubicMeter, KilogramsForcePerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilogramsForcePerCubicMillimeter(newtonpercubicmeter.KilogramsForcePerCubicMillimeter).NewtonsPerCubicMeter, KilogramsForcePerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilonewtonsPerCubicCentimeter(newtonpercubicmeter.KilonewtonsPerCubicCentimeter).NewtonsPerCubicMeter, KilonewtonsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilonewtonsPerCubicMeter(newtonpercubicmeter.KilonewtonsPerCubicMeter).NewtonsPerCubicMeter, KilonewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilonewtonsPerCubicMillimeter(newtonpercubicmeter.KilonewtonsPerCubicMillimeter).NewtonsPerCubicMeter, KilonewtonsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilopoundsForcePerCubicFoot(newtonpercubicmeter.KilopoundsForcePerCubicFoot).NewtonsPerCubicMeter, KilopoundsForcePerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromKilopoundsForcePerCubicInch(newtonpercubicmeter.KilopoundsForcePerCubicInch).NewtonsPerCubicMeter, KilopoundsForcePerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromMeganewtonsPerCubicMeter(newtonpercubicmeter.MeganewtonsPerCubicMeter).NewtonsPerCubicMeter, MeganewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromNewtonsPerCubicCentimeter(newtonpercubicmeter.NewtonsPerCubicCentimeter).NewtonsPerCubicMeter, NewtonsPerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromNewtonsPerCubicMeter(newtonpercubicmeter.NewtonsPerCubicMeter).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromNewtonsPerCubicMillimeter(newtonpercubicmeter.NewtonsPerCubicMillimeter).NewtonsPerCubicMeter, NewtonsPerCubicMillimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromPoundsForcePerCubicFoot(newtonpercubicmeter.PoundsForcePerCubicFoot).NewtonsPerCubicMeter, PoundsForcePerCubicFootTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromPoundsForcePerCubicInch(newtonpercubicmeter.PoundsForcePerCubicInch).NewtonsPerCubicMeter, PoundsForcePerCubicInchTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromTonnesForcePerCubicCentimeter(newtonpercubicmeter.TonnesForcePerCubicCentimeter).NewtonsPerCubicMeter, TonnesForcePerCubicCentimeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromTonnesForcePerCubicMeter(newtonpercubicmeter.TonnesForcePerCubicMeter).NewtonsPerCubicMeter, TonnesForcePerCubicMeterTolerance);
-            AssertEx.EqualTolerance(1, SpecificWeight.FromTonnesForcePerCubicMillimeter(newtonpercubicmeter.TonnesForcePerCubicMillimeter).NewtonsPerCubicMeter, TonnesForcePerCubicMillimeterTolerance);
+            SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(3);
+            Assert.Equal(3, SpecificWeight.FromKilogramsForcePerCubicCentimeter(newtonpercubicmeter.KilogramsForcePerCubicCentimeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromKilogramsForcePerCubicMeter(newtonpercubicmeter.KilogramsForcePerCubicMeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromKilogramsForcePerCubicMillimeter(newtonpercubicmeter.KilogramsForcePerCubicMillimeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromKilonewtonsPerCubicCentimeter(newtonpercubicmeter.KilonewtonsPerCubicCentimeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromKilonewtonsPerCubicMeter(newtonpercubicmeter.KilonewtonsPerCubicMeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromKilonewtonsPerCubicMillimeter(newtonpercubicmeter.KilonewtonsPerCubicMillimeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromKilopoundsForcePerCubicFoot(newtonpercubicmeter.KilopoundsForcePerCubicFoot).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromKilopoundsForcePerCubicInch(newtonpercubicmeter.KilopoundsForcePerCubicInch).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromMeganewtonsPerCubicMeter(newtonpercubicmeter.MeganewtonsPerCubicMeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromNewtonsPerCubicCentimeter(newtonpercubicmeter.NewtonsPerCubicCentimeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromNewtonsPerCubicMeter(newtonpercubicmeter.NewtonsPerCubicMeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromNewtonsPerCubicMillimeter(newtonpercubicmeter.NewtonsPerCubicMillimeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromPoundsForcePerCubicFoot(newtonpercubicmeter.PoundsForcePerCubicFoot).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromPoundsForcePerCubicInch(newtonpercubicmeter.PoundsForcePerCubicInch).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromTonnesForcePerCubicCentimeter(newtonpercubicmeter.TonnesForcePerCubicCentimeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromTonnesForcePerCubicMeter(newtonpercubicmeter.TonnesForcePerCubicMeter).NewtonsPerCubicMeter);
+            Assert.Equal(3, SpecificWeight.FromTonnesForcePerCubicMillimeter(newtonpercubicmeter.TonnesForcePerCubicMillimeter).NewtonsPerCubicMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             SpecificWeight v = SpecificWeight.FromNewtonsPerCubicMeter(1);
-            AssertEx.EqualTolerance(-1, -v.NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (SpecificWeight.FromNewtonsPerCubicMeter(3)-v).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, (SpecificWeight.FromNewtonsPerCubicMeter(10)/5).NewtonsPerCubicMeter, NewtonsPerCubicMeterTolerance);
-            AssertEx.EqualTolerance(2, SpecificWeight.FromNewtonsPerCubicMeter(10)/SpecificWeight.FromNewtonsPerCubicMeter(5), NewtonsPerCubicMeterTolerance);
+            Assert.Equal(-1, -v.NewtonsPerCubicMeter);
+            Assert.Equal(2, (SpecificWeight.FromNewtonsPerCubicMeter(3) - v).NewtonsPerCubicMeter);
+            Assert.Equal(2, (v + v).NewtonsPerCubicMeter);
+            Assert.Equal(10, (v * 10).NewtonsPerCubicMeter);
+            Assert.Equal(10, (10 * v).NewtonsPerCubicMeter);
+            Assert.Equal(2, (SpecificWeight.FromNewtonsPerCubicMeter(10) / 5).NewtonsPerCubicMeter);
+            Assert.Equal(2, SpecificWeight.FromNewtonsPerCubicMeter(10) / SpecificWeight.FromNewtonsPerCubicMeter(5));
         }
 
         [Fact]
@@ -758,8 +818,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, SpecificWeightUnit.NewtonPerCubicMeter, 1, SpecificWeightUnit.NewtonPerCubicMeter, true)]  // Same value and unit.
         [InlineData(1, SpecificWeightUnit.NewtonPerCubicMeter, 2, SpecificWeightUnit.NewtonPerCubicMeter, false)] // Different value.
-        [InlineData(2, SpecificWeightUnit.NewtonPerCubicMeter, 1, SpecificWeightUnit.KilogramForcePerCubicCentimeter, false)] // Different value and unit.
-        [InlineData(1, SpecificWeightUnit.NewtonPerCubicMeter, 1, SpecificWeightUnit.KilogramForcePerCubicCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, SpecificWeightUnit unitA, double valueB, SpecificWeightUnit unitB, bool expectEqual)
         {
             var a = new SpecificWeight(valueA, unitA);
@@ -819,8 +877,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = SpecificWeight.FromNewtonsPerCubicMeter(firstValue);
             var otherQuantity = SpecificWeight.FromNewtonsPerCubicMeter(secondValue);
             SpecificWeight maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, SpecificWeight.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -839,7 +897,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<SpecificWeightUnit>();
+            var units = EnumHelper.GetValues<SpecificWeightUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -852,6 +910,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(SpecificWeight.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(SpecificWeight.Info.Units, SpecificWeight.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, SpecificWeight.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -900,26 +970,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 tf/mm³", new SpecificWeight(1, SpecificWeightUnit.TonneForcePerCubicMillimeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 N/m³", new SpecificWeight(0.123456, SpecificWeightUnit.NewtonPerCubicMeter).ToString("s1"));
-            Assert.Equal("0.12 N/m³", new SpecificWeight(0.123456, SpecificWeightUnit.NewtonPerCubicMeter).ToString("s2"));
-            Assert.Equal("0.123 N/m³", new SpecificWeight(0.123456, SpecificWeightUnit.NewtonPerCubicMeter).ToString("s3"));
-            Assert.Equal("0.1235 N/m³", new SpecificWeight(0.123456, SpecificWeightUnit.NewtonPerCubicMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 N/m³", new SpecificWeight(0.123456, SpecificWeightUnit.NewtonPerCubicMeter).ToString("s1", culture));
-            Assert.Equal("0.12 N/m³", new SpecificWeight(0.123456, SpecificWeightUnit.NewtonPerCubicMeter).ToString("s2", culture));
-            Assert.Equal("0.123 N/m³", new SpecificWeight(0.123456, SpecificWeightUnit.NewtonPerCubicMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 N/m³", new SpecificWeight(0.123456, SpecificWeightUnit.NewtonPerCubicMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -946,7 +996,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = SpecificWeight.FromNewtonsPerCubicMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(SpecificWeight), quantity.As(SpecificWeight.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs
index dbde8909f0..db8fb71f44 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs
@@ -253,6 +253,20 @@ public void Speed_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<SpeedUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void SpeedInfo_CreateWithCustomUnitInfos()
+        {
+            SpeedUnit[] expectedUnits = [SpeedUnit.MeterPerSecond];
+
+            Speed.SpeedInfo quantityInfo = Speed.SpeedInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Speed", quantityInfo.Name);
+            Assert.Equal(Speed.Zero, quantityInfo.Zero);
+            Assert.Equal(Speed.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void MeterPerSecondToSpeedUnits()
         {
@@ -401,26 +415,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Speed.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Speed convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Speed quantityToConvert = quantity;
+
+                Speed convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<SpeedUnit> quantityToConvert = quantity;
+
+                IQuantity<SpeedUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Speed(value: 1, unit: Speed.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Speed(value: 1, unit: Speed.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpeedUnit> quantity = new Speed(value: 1, unit: Speed.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Speed(value: 1, unit: Speed.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Speed(value: 1, unit: Speed.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Speed(value: 1, unit: Speed.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<SpeedUnit> quantity = new Speed(value: 1, unit: Speed.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Speed(value: 1, unit: Speed.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -487,7 +544,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 мм/с", SpeedUnit.MillimeterPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 нм/мин", SpeedUnit.NanometerPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 нм/с", SpeedUnit.NanometerPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, SpeedUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, SpeedUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Speed.Parse(quantityString);
@@ -559,7 +616,7 @@ public void Parse(string culture, string quantityString, SpeedUnit expectedUnit,
         [InlineData("ru-RU", "4,2 мм/с", SpeedUnit.MillimeterPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 нм/мин", SpeedUnit.NanometerPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 нм/с", SpeedUnit.NanometerPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, SpeedUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, SpeedUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Speed.TryParse(quantityString, out Speed parsed));
@@ -1148,6 +1205,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(SpeedUnit unit)
                 var quantity = Speed.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1171,64 +1229,66 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(SpeedUnit unit)
                 IQuantity<SpeedUnit> quantityToConvert = quantity;
                 IQuantity<SpeedUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Speed meterpersecond = Speed.FromMetersPerSecond(1);
-            AssertEx.EqualTolerance(1, Speed.FromCentimetersPerHour(meterpersecond.CentimetersPerHour).MetersPerSecond, CentimetersPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromCentimetersPerMinute(meterpersecond.CentimetersPerMinute).MetersPerSecond, CentimetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromCentimetersPerSecond(meterpersecond.CentimetersPerSecond).MetersPerSecond, CentimetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromDecimetersPerMinute(meterpersecond.DecimetersPerMinute).MetersPerSecond, DecimetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromDecimetersPerSecond(meterpersecond.DecimetersPerSecond).MetersPerSecond, DecimetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromFeetPerHour(meterpersecond.FeetPerHour).MetersPerSecond, FeetPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromFeetPerMinute(meterpersecond.FeetPerMinute).MetersPerSecond, FeetPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromFeetPerSecond(meterpersecond.FeetPerSecond).MetersPerSecond, FeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromInchesPerHour(meterpersecond.InchesPerHour).MetersPerSecond, InchesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromInchesPerMinute(meterpersecond.InchesPerMinute).MetersPerSecond, InchesPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromInchesPerSecond(meterpersecond.InchesPerSecond).MetersPerSecond, InchesPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromKilometersPerHour(meterpersecond.KilometersPerHour).MetersPerSecond, KilometersPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromKilometersPerMinute(meterpersecond.KilometersPerMinute).MetersPerSecond, KilometersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromKilometersPerSecond(meterpersecond.KilometersPerSecond).MetersPerSecond, KilometersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromKnots(meterpersecond.Knots).MetersPerSecond, KnotsTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMach(meterpersecond.Mach).MetersPerSecond, MachTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMetersPerHour(meterpersecond.MetersPerHour).MetersPerSecond, MetersPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMetersPerMinute(meterpersecond.MetersPerMinute).MetersPerSecond, MetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMetersPerSecond(meterpersecond.MetersPerSecond).MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMicrometersPerMinute(meterpersecond.MicrometersPerMinute).MetersPerSecond, MicrometersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMicrometersPerSecond(meterpersecond.MicrometersPerSecond).MetersPerSecond, MicrometersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMilesPerHour(meterpersecond.MilesPerHour).MetersPerSecond, MilesPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMillimetersPerHour(meterpersecond.MillimetersPerHour).MetersPerSecond, MillimetersPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMillimetersPerMinute(meterpersecond.MillimetersPerMinute).MetersPerSecond, MillimetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromMillimetersPerSecond(meterpersecond.MillimetersPerSecond).MetersPerSecond, MillimetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromNanometersPerMinute(meterpersecond.NanometersPerMinute).MetersPerSecond, NanometersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromNanometersPerSecond(meterpersecond.NanometersPerSecond).MetersPerSecond, NanometersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromUsSurveyFeetPerHour(meterpersecond.UsSurveyFeetPerHour).MetersPerSecond, UsSurveyFeetPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromUsSurveyFeetPerMinute(meterpersecond.UsSurveyFeetPerMinute).MetersPerSecond, UsSurveyFeetPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromUsSurveyFeetPerSecond(meterpersecond.UsSurveyFeetPerSecond).MetersPerSecond, UsSurveyFeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromYardsPerHour(meterpersecond.YardsPerHour).MetersPerSecond, YardsPerHourTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromYardsPerMinute(meterpersecond.YardsPerMinute).MetersPerSecond, YardsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Speed.FromYardsPerSecond(meterpersecond.YardsPerSecond).MetersPerSecond, YardsPerSecondTolerance);
+            Speed meterpersecond = Speed.FromMetersPerSecond(3);
+            Assert.Equal(3, Speed.FromCentimetersPerHour(meterpersecond.CentimetersPerHour).MetersPerSecond);
+            Assert.Equal(3, Speed.FromCentimetersPerMinute(meterpersecond.CentimetersPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromCentimetersPerSecond(meterpersecond.CentimetersPerSecond).MetersPerSecond);
+            Assert.Equal(3, Speed.FromDecimetersPerMinute(meterpersecond.DecimetersPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromDecimetersPerSecond(meterpersecond.DecimetersPerSecond).MetersPerSecond);
+            Assert.Equal(3, Speed.FromFeetPerHour(meterpersecond.FeetPerHour).MetersPerSecond);
+            Assert.Equal(3, Speed.FromFeetPerMinute(meterpersecond.FeetPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromFeetPerSecond(meterpersecond.FeetPerSecond).MetersPerSecond);
+            Assert.Equal(3, Speed.FromInchesPerHour(meterpersecond.InchesPerHour).MetersPerSecond);
+            Assert.Equal(3, Speed.FromInchesPerMinute(meterpersecond.InchesPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromInchesPerSecond(meterpersecond.InchesPerSecond).MetersPerSecond);
+            Assert.Equal(3, Speed.FromKilometersPerHour(meterpersecond.KilometersPerHour).MetersPerSecond);
+            Assert.Equal(3, Speed.FromKilometersPerMinute(meterpersecond.KilometersPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromKilometersPerSecond(meterpersecond.KilometersPerSecond).MetersPerSecond);
+            Assert.Equal(3, Speed.FromKnots(meterpersecond.Knots).MetersPerSecond);
+            Assert.Equal(3, Speed.FromMach(meterpersecond.Mach).MetersPerSecond);
+            Assert.Equal(3, Speed.FromMetersPerHour(meterpersecond.MetersPerHour).MetersPerSecond);
+            Assert.Equal(3, Speed.FromMetersPerMinute(meterpersecond.MetersPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromMetersPerSecond(meterpersecond.MetersPerSecond).MetersPerSecond);
+            Assert.Equal(3, Speed.FromMicrometersPerMinute(meterpersecond.MicrometersPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromMicrometersPerSecond(meterpersecond.MicrometersPerSecond).MetersPerSecond);
+            Assert.Equal(3, Speed.FromMilesPerHour(meterpersecond.MilesPerHour).MetersPerSecond);
+            Assert.Equal(3, Speed.FromMillimetersPerHour(meterpersecond.MillimetersPerHour).MetersPerSecond);
+            Assert.Equal(3, Speed.FromMillimetersPerMinute(meterpersecond.MillimetersPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromMillimetersPerSecond(meterpersecond.MillimetersPerSecond).MetersPerSecond);
+            Assert.Equal(3, Speed.FromNanometersPerMinute(meterpersecond.NanometersPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromNanometersPerSecond(meterpersecond.NanometersPerSecond).MetersPerSecond);
+            Assert.Equal(3, Speed.FromUsSurveyFeetPerHour(meterpersecond.UsSurveyFeetPerHour).MetersPerSecond);
+            Assert.Equal(3, Speed.FromUsSurveyFeetPerMinute(meterpersecond.UsSurveyFeetPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromUsSurveyFeetPerSecond(meterpersecond.UsSurveyFeetPerSecond).MetersPerSecond);
+            Assert.Equal(3, Speed.FromYardsPerHour(meterpersecond.YardsPerHour).MetersPerSecond);
+            Assert.Equal(3, Speed.FromYardsPerMinute(meterpersecond.YardsPerMinute).MetersPerSecond);
+            Assert.Equal(3, Speed.FromYardsPerSecond(meterpersecond.YardsPerSecond).MetersPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Speed v = Speed.FromMetersPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (Speed.FromMetersPerSecond(3)-v).MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (Speed.FromMetersPerSecond(10)/5).MetersPerSecond, MetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, Speed.FromMetersPerSecond(10)/Speed.FromMetersPerSecond(5), MetersPerSecondTolerance);
+            Assert.Equal(-1, -v.MetersPerSecond);
+            Assert.Equal(2, (Speed.FromMetersPerSecond(3) - v).MetersPerSecond);
+            Assert.Equal(2, (v + v).MetersPerSecond);
+            Assert.Equal(10, (v * 10).MetersPerSecond);
+            Assert.Equal(10, (10 * v).MetersPerSecond);
+            Assert.Equal(2, (Speed.FromMetersPerSecond(10) / 5).MetersPerSecond);
+            Assert.Equal(2, Speed.FromMetersPerSecond(10) / Speed.FromMetersPerSecond(5));
         }
 
         [Fact]
@@ -1274,8 +1334,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, SpeedUnit.MeterPerSecond, 1, SpeedUnit.MeterPerSecond, true)]  // Same value and unit.
         [InlineData(1, SpeedUnit.MeterPerSecond, 2, SpeedUnit.MeterPerSecond, false)] // Different value.
-        [InlineData(2, SpeedUnit.MeterPerSecond, 1, SpeedUnit.CentimeterPerHour, false)] // Different value and unit.
-        [InlineData(1, SpeedUnit.MeterPerSecond, 1, SpeedUnit.CentimeterPerHour, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, SpeedUnit unitA, double valueB, SpeedUnit unitB, bool expectEqual)
         {
             var a = new Speed(valueA, unitA);
@@ -1335,8 +1393,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Speed.FromMetersPerSecond(firstValue);
             var otherQuantity = Speed.FromMetersPerSecond(secondValue);
             Speed maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Speed.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1355,7 +1413,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<SpeedUnit>();
+            var units = EnumHelper.GetValues<SpeedUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1368,6 +1426,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Speed.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Speed.Info.Units, Speed.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Speed.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1448,26 +1518,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 yd/s", new Speed(1, SpeedUnit.YardPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m/s", new Speed(0.123456, SpeedUnit.MeterPerSecond).ToString("s1"));
-            Assert.Equal("0.12 m/s", new Speed(0.123456, SpeedUnit.MeterPerSecond).ToString("s2"));
-            Assert.Equal("0.123 m/s", new Speed(0.123456, SpeedUnit.MeterPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 m/s", new Speed(0.123456, SpeedUnit.MeterPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m/s", new Speed(0.123456, SpeedUnit.MeterPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 m/s", new Speed(0.123456, SpeedUnit.MeterPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 m/s", new Speed(0.123456, SpeedUnit.MeterPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 m/s", new Speed(0.123456, SpeedUnit.MeterPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1494,7 +1544,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Speed.FromMetersPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Speed), quantity.As(Speed.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/StandardVolumeFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/StandardVolumeFlowTestsBase.g.cs
index bd761f4515..4d7bd4b554 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/StandardVolumeFlowTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/StandardVolumeFlowTestsBase.g.cs
@@ -157,6 +157,20 @@ public void StandardVolumeFlow_QuantityInfo_ReturnsQuantityInfoDescribingQuantit
             Assert.Equal(quantityInfo, ((IQuantity<StandardVolumeFlowUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void StandardVolumeFlowInfo_CreateWithCustomUnitInfos()
+        {
+            StandardVolumeFlowUnit[] expectedUnits = [StandardVolumeFlowUnit.StandardCubicMeterPerSecond];
+
+            StandardVolumeFlow.StandardVolumeFlowInfo quantityInfo = StandardVolumeFlow.StandardVolumeFlowInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("StandardVolumeFlow", quantityInfo.Name);
+            Assert.Equal(StandardVolumeFlow.Zero, quantityInfo.Zero);
+            Assert.Equal(StandardVolumeFlow.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void StandardCubicMeterPerSecondToStandardVolumeFlowUnits()
         {
@@ -257,26 +271,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = StandardVolumeFlow.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            StandardVolumeFlow convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                StandardVolumeFlow quantityToConvert = quantity;
+
+                StandardVolumeFlow convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<StandardVolumeFlowUnit> quantityToConvert = quantity;
+
+                IQuantity<StandardVolumeFlowUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new StandardVolumeFlow(value: 1, unit: StandardVolumeFlow.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new StandardVolumeFlow(value: 1, unit: StandardVolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<StandardVolumeFlowUnit> quantity = new StandardVolumeFlow(value: 1, unit: StandardVolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new StandardVolumeFlow(value: 1, unit: StandardVolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new StandardVolumeFlow(value: 1, unit: StandardVolumeFlow.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new StandardVolumeFlow(value: 1, unit: StandardVolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<StandardVolumeFlowUnit> quantity = new StandardVolumeFlow(value: 1, unit: StandardVolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new StandardVolumeFlow(value: 1, unit: StandardVolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -289,7 +346,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 Sm³/min", StandardVolumeFlowUnit.StandardCubicMeterPerMinute, 4.2)]
         [InlineData("en-US", "4.2 Sm³/s", StandardVolumeFlowUnit.StandardCubicMeterPerSecond, 4.2)]
         [InlineData("en-US", "4.2 slm", StandardVolumeFlowUnit.StandardLiterPerMinute, 4.2)]
-        public void Parse(string culture, string quantityString, StandardVolumeFlowUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, StandardVolumeFlowUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = StandardVolumeFlow.Parse(quantityString);
@@ -307,7 +364,7 @@ public void Parse(string culture, string quantityString, StandardVolumeFlowUnit
         [InlineData("en-US", "4.2 Sm³/min", StandardVolumeFlowUnit.StandardCubicMeterPerMinute, 4.2)]
         [InlineData("en-US", "4.2 Sm³/s", StandardVolumeFlowUnit.StandardCubicMeterPerSecond, 4.2)]
         [InlineData("en-US", "4.2 slm", StandardVolumeFlowUnit.StandardLiterPerMinute, 4.2)]
-        public void TryParse(string culture, string quantityString, StandardVolumeFlowUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, StandardVolumeFlowUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(StandardVolumeFlow.TryParse(quantityString, out StandardVolumeFlow parsed));
@@ -512,6 +569,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(StandardVolumeFl
                 var quantity = StandardVolumeFlow.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -535,40 +593,42 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(StandardVolumeFlowU
                 IQuantity<StandardVolumeFlowUnit> quantityToConvert = quantity;
                 IQuantity<StandardVolumeFlowUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            StandardVolumeFlow standardcubicmeterpersecond = StandardVolumeFlow.FromStandardCubicMetersPerSecond(1);
-            AssertEx.EqualTolerance(1, StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(standardcubicmeterpersecond.StandardCubicCentimetersPerMinute).StandardCubicMetersPerSecond, StandardCubicCentimetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, StandardVolumeFlow.FromStandardCubicFeetPerHour(standardcubicmeterpersecond.StandardCubicFeetPerHour).StandardCubicMetersPerSecond, StandardCubicFeetPerHourTolerance);
-            AssertEx.EqualTolerance(1, StandardVolumeFlow.FromStandardCubicFeetPerMinute(standardcubicmeterpersecond.StandardCubicFeetPerMinute).StandardCubicMetersPerSecond, StandardCubicFeetPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, StandardVolumeFlow.FromStandardCubicFeetPerSecond(standardcubicmeterpersecond.StandardCubicFeetPerSecond).StandardCubicMetersPerSecond, StandardCubicFeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, StandardVolumeFlow.FromStandardCubicMetersPerDay(standardcubicmeterpersecond.StandardCubicMetersPerDay).StandardCubicMetersPerSecond, StandardCubicMetersPerDayTolerance);
-            AssertEx.EqualTolerance(1, StandardVolumeFlow.FromStandardCubicMetersPerHour(standardcubicmeterpersecond.StandardCubicMetersPerHour).StandardCubicMetersPerSecond, StandardCubicMetersPerHourTolerance);
-            AssertEx.EqualTolerance(1, StandardVolumeFlow.FromStandardCubicMetersPerMinute(standardcubicmeterpersecond.StandardCubicMetersPerMinute).StandardCubicMetersPerSecond, StandardCubicMetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, StandardVolumeFlow.FromStandardCubicMetersPerSecond(standardcubicmeterpersecond.StandardCubicMetersPerSecond).StandardCubicMetersPerSecond, StandardCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, StandardVolumeFlow.FromStandardLitersPerMinute(standardcubicmeterpersecond.StandardLitersPerMinute).StandardCubicMetersPerSecond, StandardLitersPerMinuteTolerance);
+            StandardVolumeFlow standardcubicmeterpersecond = StandardVolumeFlow.FromStandardCubicMetersPerSecond(3);
+            Assert.Equal(3, StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(standardcubicmeterpersecond.StandardCubicCentimetersPerMinute).StandardCubicMetersPerSecond);
+            Assert.Equal(3, StandardVolumeFlow.FromStandardCubicFeetPerHour(standardcubicmeterpersecond.StandardCubicFeetPerHour).StandardCubicMetersPerSecond);
+            Assert.Equal(3, StandardVolumeFlow.FromStandardCubicFeetPerMinute(standardcubicmeterpersecond.StandardCubicFeetPerMinute).StandardCubicMetersPerSecond);
+            Assert.Equal(3, StandardVolumeFlow.FromStandardCubicFeetPerSecond(standardcubicmeterpersecond.StandardCubicFeetPerSecond).StandardCubicMetersPerSecond);
+            Assert.Equal(3, StandardVolumeFlow.FromStandardCubicMetersPerDay(standardcubicmeterpersecond.StandardCubicMetersPerDay).StandardCubicMetersPerSecond);
+            Assert.Equal(3, StandardVolumeFlow.FromStandardCubicMetersPerHour(standardcubicmeterpersecond.StandardCubicMetersPerHour).StandardCubicMetersPerSecond);
+            Assert.Equal(3, StandardVolumeFlow.FromStandardCubicMetersPerMinute(standardcubicmeterpersecond.StandardCubicMetersPerMinute).StandardCubicMetersPerSecond);
+            Assert.Equal(3, StandardVolumeFlow.FromStandardCubicMetersPerSecond(standardcubicmeterpersecond.StandardCubicMetersPerSecond).StandardCubicMetersPerSecond);
+            Assert.Equal(3, StandardVolumeFlow.FromStandardLitersPerMinute(standardcubicmeterpersecond.StandardLitersPerMinute).StandardCubicMetersPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             StandardVolumeFlow v = StandardVolumeFlow.FromStandardCubicMetersPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.StandardCubicMetersPerSecond, StandardCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (StandardVolumeFlow.FromStandardCubicMetersPerSecond(3)-v).StandardCubicMetersPerSecond, StandardCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).StandardCubicMetersPerSecond, StandardCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).StandardCubicMetersPerSecond, StandardCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).StandardCubicMetersPerSecond, StandardCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (StandardVolumeFlow.FromStandardCubicMetersPerSecond(10)/5).StandardCubicMetersPerSecond, StandardCubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, StandardVolumeFlow.FromStandardCubicMetersPerSecond(10)/StandardVolumeFlow.FromStandardCubicMetersPerSecond(5), StandardCubicMetersPerSecondTolerance);
+            Assert.Equal(-1, -v.StandardCubicMetersPerSecond);
+            Assert.Equal(2, (StandardVolumeFlow.FromStandardCubicMetersPerSecond(3) - v).StandardCubicMetersPerSecond);
+            Assert.Equal(2, (v + v).StandardCubicMetersPerSecond);
+            Assert.Equal(10, (v * 10).StandardCubicMetersPerSecond);
+            Assert.Equal(10, (10 * v).StandardCubicMetersPerSecond);
+            Assert.Equal(2, (StandardVolumeFlow.FromStandardCubicMetersPerSecond(10) / 5).StandardCubicMetersPerSecond);
+            Assert.Equal(2, StandardVolumeFlow.FromStandardCubicMetersPerSecond(10) / StandardVolumeFlow.FromStandardCubicMetersPerSecond(5));
         }
 
         [Fact]
@@ -614,8 +674,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, 1, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, true)]  // Same value and unit.
         [InlineData(1, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, 2, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, false)] // Different value.
-        [InlineData(2, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, 1, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute, false)] // Different value and unit.
-        [InlineData(1, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, 1, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, StandardVolumeFlowUnit unitA, double valueB, StandardVolumeFlowUnit unitB, bool expectEqual)
         {
             var a = new StandardVolumeFlow(valueA, unitA);
@@ -675,8 +733,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = StandardVolumeFlow.FromStandardCubicMetersPerSecond(firstValue);
             var otherQuantity = StandardVolumeFlow.FromStandardCubicMetersPerSecond(secondValue);
             StandardVolumeFlow maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, StandardVolumeFlow.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -695,7 +753,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<StandardVolumeFlowUnit>();
+            var units = EnumHelper.GetValues<StandardVolumeFlowUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -708,6 +766,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(StandardVolumeFlow.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(StandardVolumeFlow.Info.Units, StandardVolumeFlow.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, StandardVolumeFlow.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -740,26 +810,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 slm", new StandardVolumeFlow(1, StandardVolumeFlowUnit.StandardLiterPerMinute).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 Sm³/s", new StandardVolumeFlow(0.123456, StandardVolumeFlowUnit.StandardCubicMeterPerSecond).ToString("s1"));
-            Assert.Equal("0.12 Sm³/s", new StandardVolumeFlow(0.123456, StandardVolumeFlowUnit.StandardCubicMeterPerSecond).ToString("s2"));
-            Assert.Equal("0.123 Sm³/s", new StandardVolumeFlow(0.123456, StandardVolumeFlowUnit.StandardCubicMeterPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 Sm³/s", new StandardVolumeFlow(0.123456, StandardVolumeFlowUnit.StandardCubicMeterPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 Sm³/s", new StandardVolumeFlow(0.123456, StandardVolumeFlowUnit.StandardCubicMeterPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 Sm³/s", new StandardVolumeFlow(0.123456, StandardVolumeFlowUnit.StandardCubicMeterPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 Sm³/s", new StandardVolumeFlow(0.123456, StandardVolumeFlowUnit.StandardCubicMeterPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 Sm³/s", new StandardVolumeFlow(0.123456, StandardVolumeFlowUnit.StandardCubicMeterPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -786,7 +836,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = StandardVolumeFlow.FromStandardCubicMetersPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(StandardVolumeFlow), quantity.As(StandardVolumeFlow.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs
index 8dd9f6749d..9a933303b9 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureChangeRateTestsBase.g.cs
@@ -189,6 +189,20 @@ public void TemperatureChangeRate_QuantityInfo_ReturnsQuantityInfoDescribingQuan
             Assert.Equal(quantityInfo, ((IQuantity<TemperatureChangeRateUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void TemperatureChangeRateInfo_CreateWithCustomUnitInfos()
+        {
+            TemperatureChangeRateUnit[] expectedUnits = [TemperatureChangeRateUnit.DegreeCelsiusPerSecond];
+
+            TemperatureChangeRate.TemperatureChangeRateInfo quantityInfo = TemperatureChangeRate.TemperatureChangeRateInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("TemperatureChangeRate", quantityInfo.Name);
+            Assert.Equal(TemperatureChangeRate.Zero, quantityInfo.Zero);
+            Assert.Equal(TemperatureChangeRate.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void DegreeCelsiusPerSecondToTemperatureChangeRateUnits()
         {
@@ -305,26 +319,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = TemperatureChangeRate.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            TemperatureChangeRate convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                TemperatureChangeRate quantityToConvert = quantity;
+
+                TemperatureChangeRate convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<TemperatureChangeRateUnit> quantityToConvert = quantity;
+
+                IQuantity<TemperatureChangeRateUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new TemperatureChangeRate(value: 1, unit: TemperatureChangeRate.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new TemperatureChangeRate(value: 1, unit: TemperatureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<TemperatureChangeRateUnit> quantity = new TemperatureChangeRate(value: 1, unit: TemperatureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new TemperatureChangeRate(value: 1, unit: TemperatureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new TemperatureChangeRate(value: 1, unit: TemperatureChangeRate.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new TemperatureChangeRate(value: 1, unit: TemperatureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<TemperatureChangeRateUnit> quantity = new TemperatureChangeRate(value: 1, unit: TemperatureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new TemperatureChangeRate(value: 1, unit: TemperatureChangeRate.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -345,7 +402,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 µ°C/s", TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, 4.2)]
         [InlineData("en-US", "4.2 m°C/s", TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, 4.2)]
         [InlineData("en-US", "4.2 n°C/s", TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, TemperatureChangeRateUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, TemperatureChangeRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = TemperatureChangeRate.Parse(quantityString);
@@ -371,7 +428,7 @@ public void Parse(string culture, string quantityString, TemperatureChangeRateUn
         [InlineData("en-US", "4.2 µ°C/s", TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, 4.2)]
         [InlineData("en-US", "4.2 m°C/s", TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, 4.2)]
         [InlineData("en-US", "4.2 n°C/s", TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, TemperatureChangeRateUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, TemperatureChangeRateUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(TemperatureChangeRate.TryParse(quantityString, out TemperatureChangeRate parsed));
@@ -648,6 +705,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(TemperatureChang
                 var quantity = TemperatureChangeRate.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -671,48 +729,50 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(TemperatureChangeRa
                 IQuantity<TemperatureChangeRateUnit> quantityToConvert = quantity;
                 IQuantity<TemperatureChangeRateUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(degreecelsiuspersecond.CentidegreesCelsiusPerSecond).DegreesCelsiusPerSecond, CentidegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(degreecelsiuspersecond.DecadegreesCelsiusPerSecond).DegreesCelsiusPerSecond, DecadegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(degreecelsiuspersecond.DecidegreesCelsiusPerSecond).DegreesCelsiusPerSecond, DecidegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesCelsiusPerHour(degreecelsiuspersecond.DegreesCelsiusPerHour).DegreesCelsiusPerSecond, DegreesCelsiusPerHourTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesCelsiusPerMinute(degreecelsiuspersecond.DegreesCelsiusPerMinute).DegreesCelsiusPerSecond, DegreesCelsiusPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesCelsiusPerSecond(degreecelsiuspersecond.DegreesCelsiusPerSecond).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesFahrenheitPerHour(degreecelsiuspersecond.DegreesFahrenheitPerHour).DegreesCelsiusPerSecond, DegreesFahrenheitPerHourTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesFahrenheitPerMinute(degreecelsiuspersecond.DegreesFahrenheitPerMinute).DegreesCelsiusPerSecond, DegreesFahrenheitPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesFahrenheitPerSecond(degreecelsiuspersecond.DegreesFahrenheitPerSecond).DegreesCelsiusPerSecond, DegreesFahrenheitPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesKelvinPerHour(degreecelsiuspersecond.DegreesKelvinPerHour).DegreesCelsiusPerSecond, DegreesKelvinPerHourTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesKelvinPerMinute(degreecelsiuspersecond.DegreesKelvinPerMinute).DegreesCelsiusPerSecond, DegreesKelvinPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromDegreesKelvinPerSecond(degreecelsiuspersecond.DegreesKelvinPerSecond).DegreesCelsiusPerSecond, DegreesKelvinPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(degreecelsiuspersecond.HectodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, HectodegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(degreecelsiuspersecond.KilodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, KilodegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(degreecelsiuspersecond.MicrodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, MicrodegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(degreecelsiuspersecond.MillidegreesCelsiusPerSecond).DegreesCelsiusPerSecond, MillidegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(1, TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(degreecelsiuspersecond.NanodegreesCelsiusPerSecond).DegreesCelsiusPerSecond, NanodegreesCelsiusPerSecondTolerance);
+            TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(3);
+            Assert.Equal(3, TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(degreecelsiuspersecond.CentidegreesCelsiusPerSecond).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(degreecelsiuspersecond.DecadegreesCelsiusPerSecond).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(degreecelsiuspersecond.DecidegreesCelsiusPerSecond).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDegreesCelsiusPerHour(degreecelsiuspersecond.DegreesCelsiusPerHour).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDegreesCelsiusPerMinute(degreecelsiuspersecond.DegreesCelsiusPerMinute).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDegreesCelsiusPerSecond(degreecelsiuspersecond.DegreesCelsiusPerSecond).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDegreesFahrenheitPerHour(degreecelsiuspersecond.DegreesFahrenheitPerHour).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDegreesFahrenheitPerMinute(degreecelsiuspersecond.DegreesFahrenheitPerMinute).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDegreesFahrenheitPerSecond(degreecelsiuspersecond.DegreesFahrenheitPerSecond).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDegreesKelvinPerHour(degreecelsiuspersecond.DegreesKelvinPerHour).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDegreesKelvinPerMinute(degreecelsiuspersecond.DegreesKelvinPerMinute).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromDegreesKelvinPerSecond(degreecelsiuspersecond.DegreesKelvinPerSecond).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(degreecelsiuspersecond.HectodegreesCelsiusPerSecond).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(degreecelsiuspersecond.KilodegreesCelsiusPerSecond).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(degreecelsiuspersecond.MicrodegreesCelsiusPerSecond).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(degreecelsiuspersecond.MillidegreesCelsiusPerSecond).DegreesCelsiusPerSecond);
+            Assert.Equal(3, TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(degreecelsiuspersecond.NanodegreesCelsiusPerSecond).DegreesCelsiusPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             TemperatureChangeRate v = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (TemperatureChangeRate.FromDegreesCelsiusPerSecond(3)-v).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (TemperatureChangeRate.FromDegreesCelsiusPerSecond(10)/5).DegreesCelsiusPerSecond, DegreesCelsiusPerSecondTolerance);
-            AssertEx.EqualTolerance(2, TemperatureChangeRate.FromDegreesCelsiusPerSecond(10)/TemperatureChangeRate.FromDegreesCelsiusPerSecond(5), DegreesCelsiusPerSecondTolerance);
+            Assert.Equal(-1, -v.DegreesCelsiusPerSecond);
+            Assert.Equal(2, (TemperatureChangeRate.FromDegreesCelsiusPerSecond(3) - v).DegreesCelsiusPerSecond);
+            Assert.Equal(2, (v + v).DegreesCelsiusPerSecond);
+            Assert.Equal(10, (v * 10).DegreesCelsiusPerSecond);
+            Assert.Equal(10, (10 * v).DegreesCelsiusPerSecond);
+            Assert.Equal(2, (TemperatureChangeRate.FromDegreesCelsiusPerSecond(10) / 5).DegreesCelsiusPerSecond);
+            Assert.Equal(2, TemperatureChangeRate.FromDegreesCelsiusPerSecond(10) / TemperatureChangeRate.FromDegreesCelsiusPerSecond(5));
         }
 
         [Fact]
@@ -758,8 +818,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, 1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, true)]  // Same value and unit.
         [InlineData(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, 2, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, false)] // Different value.
-        [InlineData(2, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, 1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, false)] // Different value and unit.
-        [InlineData(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, 1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, TemperatureChangeRateUnit unitA, double valueB, TemperatureChangeRateUnit unitB, bool expectEqual)
         {
             var a = new TemperatureChangeRate(valueA, unitA);
@@ -819,8 +877,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = TemperatureChangeRate.FromDegreesCelsiusPerSecond(firstValue);
             var otherQuantity = TemperatureChangeRate.FromDegreesCelsiusPerSecond(secondValue);
             TemperatureChangeRate maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, TemperatureChangeRate.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -839,7 +897,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<TemperatureChangeRateUnit>();
+            var units = EnumHelper.GetValues<TemperatureChangeRateUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -852,6 +910,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(TemperatureChangeRate.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(TemperatureChangeRate.Info.Units, TemperatureChangeRate.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, TemperatureChangeRate.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -900,26 +970,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 n°C/s", new TemperatureChangeRate(1, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 °C/s", new TemperatureChangeRate(0.123456, TemperatureChangeRateUnit.DegreeCelsiusPerSecond).ToString("s1"));
-            Assert.Equal("0.12 °C/s", new TemperatureChangeRate(0.123456, TemperatureChangeRateUnit.DegreeCelsiusPerSecond).ToString("s2"));
-            Assert.Equal("0.123 °C/s", new TemperatureChangeRate(0.123456, TemperatureChangeRateUnit.DegreeCelsiusPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 °C/s", new TemperatureChangeRate(0.123456, TemperatureChangeRateUnit.DegreeCelsiusPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 °C/s", new TemperatureChangeRate(0.123456, TemperatureChangeRateUnit.DegreeCelsiusPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 °C/s", new TemperatureChangeRate(0.123456, TemperatureChangeRateUnit.DegreeCelsiusPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 °C/s", new TemperatureChangeRate(0.123456, TemperatureChangeRateUnit.DegreeCelsiusPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 °C/s", new TemperatureChangeRate(0.123456, TemperatureChangeRateUnit.DegreeCelsiusPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -946,7 +996,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(TemperatureChangeRate), quantity.As(TemperatureChangeRate.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs
index 54b76d43b4..afe73d6b47 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureDeltaTestsBase.g.cs
@@ -157,6 +157,20 @@ public void TemperatureDelta_QuantityInfo_ReturnsQuantityInfoDescribingQuantity(
             Assert.Equal(quantityInfo, ((IQuantity<TemperatureDeltaUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void TemperatureDeltaInfo_CreateWithCustomUnitInfos()
+        {
+            TemperatureDeltaUnit[] expectedUnits = [TemperatureDeltaUnit.Kelvin];
+
+            TemperatureDelta.TemperatureDeltaInfo quantityInfo = TemperatureDelta.TemperatureDeltaInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("TemperatureDelta", quantityInfo.Name);
+            Assert.Equal(TemperatureDelta.Zero, quantityInfo.Zero);
+            Assert.Equal(TemperatureDelta.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KelvinToTemperatureDeltaUnits()
         {
@@ -257,26 +271,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = TemperatureDelta.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            TemperatureDelta convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                TemperatureDelta quantityToConvert = quantity;
+
+                TemperatureDelta convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<TemperatureDeltaUnit> quantityToConvert = quantity;
+
+                IQuantity<TemperatureDeltaUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new TemperatureDelta(value: 1, unit: TemperatureDelta.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new TemperatureDelta(value: 1, unit: TemperatureDelta.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<TemperatureDeltaUnit> quantity = new TemperatureDelta(value: 1, unit: TemperatureDelta.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new TemperatureDelta(value: 1, unit: TemperatureDelta.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new TemperatureDelta(value: 1, unit: TemperatureDelta.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new TemperatureDelta(value: 1, unit: TemperatureDelta.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<TemperatureDeltaUnit> quantity = new TemperatureDelta(value: 1, unit: TemperatureDelta.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new TemperatureDelta(value: 1, unit: TemperatureDelta.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -289,7 +346,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 ∆°Rø", TemperatureDeltaUnit.DegreeRoemer, 4.2)]
         [InlineData("en-US", "4.2 ∆K", TemperatureDeltaUnit.Kelvin, 4.2)]
         [InlineData("en-US", "4.2 ∆m°C", TemperatureDeltaUnit.MillidegreeCelsius, 4.2)]
-        public void Parse(string culture, string quantityString, TemperatureDeltaUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, TemperatureDeltaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = TemperatureDelta.Parse(quantityString);
@@ -307,7 +364,7 @@ public void Parse(string culture, string quantityString, TemperatureDeltaUnit ex
         [InlineData("en-US", "4.2 ∆°Rø", TemperatureDeltaUnit.DegreeRoemer, 4.2)]
         [InlineData("en-US", "4.2 ∆K", TemperatureDeltaUnit.Kelvin, 4.2)]
         [InlineData("en-US", "4.2 ∆m°C", TemperatureDeltaUnit.MillidegreeCelsius, 4.2)]
-        public void TryParse(string culture, string quantityString, TemperatureDeltaUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, TemperatureDeltaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(TemperatureDelta.TryParse(quantityString, out TemperatureDelta parsed));
@@ -512,6 +569,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(TemperatureDelta
                 var quantity = TemperatureDelta.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -535,40 +593,42 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(TemperatureDeltaUni
                 IQuantity<TemperatureDeltaUnit> quantityToConvert = quantity;
                 IQuantity<TemperatureDeltaUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            TemperatureDelta kelvin = TemperatureDelta.FromKelvins(1);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(1, TemperatureDelta.FromMillidegreesCelsius(kelvin.MillidegreesCelsius).Kelvins, MillidegreesCelsiusTolerance);
+            TemperatureDelta kelvin = TemperatureDelta.FromKelvins(3);
+            Assert.Equal(3, TemperatureDelta.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins);
+            Assert.Equal(3, TemperatureDelta.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins);
+            Assert.Equal(3, TemperatureDelta.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins);
+            Assert.Equal(3, TemperatureDelta.FromDegreesNewton(kelvin.DegreesNewton).Kelvins);
+            Assert.Equal(3, TemperatureDelta.FromDegreesRankine(kelvin.DegreesRankine).Kelvins);
+            Assert.Equal(3, TemperatureDelta.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins);
+            Assert.Equal(3, TemperatureDelta.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins);
+            Assert.Equal(3, TemperatureDelta.FromKelvins(kelvin.Kelvins).Kelvins);
+            Assert.Equal(3, TemperatureDelta.FromMillidegreesCelsius(kelvin.MillidegreesCelsius).Kelvins);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             TemperatureDelta v = TemperatureDelta.FromKelvins(1);
-            AssertEx.EqualTolerance(-1, -v.Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(2, (TemperatureDelta.FromKelvins(3)-v).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(2, (TemperatureDelta.FromKelvins(10)/5).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(2, TemperatureDelta.FromKelvins(10)/TemperatureDelta.FromKelvins(5), KelvinsTolerance);
+            Assert.Equal(-1, -v.Kelvins);
+            Assert.Equal(2, (TemperatureDelta.FromKelvins(3) - v).Kelvins);
+            Assert.Equal(2, (v + v).Kelvins);
+            Assert.Equal(10, (v * 10).Kelvins);
+            Assert.Equal(10, (10 * v).Kelvins);
+            Assert.Equal(2, (TemperatureDelta.FromKelvins(10) / 5).Kelvins);
+            Assert.Equal(2, TemperatureDelta.FromKelvins(10) / TemperatureDelta.FromKelvins(5));
         }
 
         [Fact]
@@ -614,8 +674,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, TemperatureDeltaUnit.Kelvin, 1, TemperatureDeltaUnit.Kelvin, true)]  // Same value and unit.
         [InlineData(1, TemperatureDeltaUnit.Kelvin, 2, TemperatureDeltaUnit.Kelvin, false)] // Different value.
-        [InlineData(2, TemperatureDeltaUnit.Kelvin, 1, TemperatureDeltaUnit.DegreeCelsius, false)] // Different value and unit.
-        [InlineData(1, TemperatureDeltaUnit.Kelvin, 1, TemperatureDeltaUnit.DegreeCelsius, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, TemperatureDeltaUnit unitA, double valueB, TemperatureDeltaUnit unitB, bool expectEqual)
         {
             var a = new TemperatureDelta(valueA, unitA);
@@ -675,8 +733,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = TemperatureDelta.FromKelvins(firstValue);
             var otherQuantity = TemperatureDelta.FromKelvins(secondValue);
             TemperatureDelta maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, TemperatureDelta.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -695,7 +753,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<TemperatureDeltaUnit>();
+            var units = EnumHelper.GetValues<TemperatureDeltaUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -708,6 +766,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(TemperatureDelta.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(TemperatureDelta.Info.Units, TemperatureDelta.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, TemperatureDelta.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -740,26 +810,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 ∆m°C", new TemperatureDelta(1, TemperatureDeltaUnit.MillidegreeCelsius).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 ∆K", new TemperatureDelta(0.123456, TemperatureDeltaUnit.Kelvin).ToString("s1"));
-            Assert.Equal("0.12 ∆K", new TemperatureDelta(0.123456, TemperatureDeltaUnit.Kelvin).ToString("s2"));
-            Assert.Equal("0.123 ∆K", new TemperatureDelta(0.123456, TemperatureDeltaUnit.Kelvin).ToString("s3"));
-            Assert.Equal("0.1235 ∆K", new TemperatureDelta(0.123456, TemperatureDeltaUnit.Kelvin).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 ∆K", new TemperatureDelta(0.123456, TemperatureDeltaUnit.Kelvin).ToString("s1", culture));
-            Assert.Equal("0.12 ∆K", new TemperatureDelta(0.123456, TemperatureDeltaUnit.Kelvin).ToString("s2", culture));
-            Assert.Equal("0.123 ∆K", new TemperatureDelta(0.123456, TemperatureDeltaUnit.Kelvin).ToString("s3", culture));
-            Assert.Equal("0.1235 ∆K", new TemperatureDelta(0.123456, TemperatureDeltaUnit.Kelvin).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -786,7 +836,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = TemperatureDelta.FromKelvins(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(TemperatureDelta), quantity.As(TemperatureDelta.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureGradientTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureGradientTestsBase.g.cs
index b770d73168..9bc7ae9902 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureGradientTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureGradientTestsBase.g.cs
@@ -137,6 +137,20 @@ public void TemperatureGradient_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
             Assert.Equal(quantityInfo, ((IQuantity<TemperatureGradientUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void TemperatureGradientInfo_CreateWithCustomUnitInfos()
+        {
+            TemperatureGradientUnit[] expectedUnits = [TemperatureGradientUnit.KelvinPerMeter];
+
+            TemperatureGradient.TemperatureGradientInfo quantityInfo = TemperatureGradient.TemperatureGradientInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("TemperatureGradient", quantityInfo.Name);
+            Assert.Equal(TemperatureGradient.Zero, quantityInfo.Zero);
+            Assert.Equal(TemperatureGradient.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KelvinPerMeterToTemperatureGradientUnits()
         {
@@ -227,26 +241,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = TemperatureGradient.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            TemperatureGradient convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                TemperatureGradient quantityToConvert = quantity;
+
+                TemperatureGradient convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<TemperatureGradientUnit> quantityToConvert = quantity;
+
+                IQuantity<TemperatureGradientUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new TemperatureGradient(value: 1, unit: TemperatureGradient.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new TemperatureGradient(value: 1, unit: TemperatureGradient.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<TemperatureGradientUnit> quantity = new TemperatureGradient(value: 1, unit: TemperatureGradient.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new TemperatureGradient(value: 1, unit: TemperatureGradient.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new TemperatureGradient(value: 1, unit: TemperatureGradient.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new TemperatureGradient(value: 1, unit: TemperatureGradient.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<TemperatureGradientUnit> quantity = new TemperatureGradient(value: 1, unit: TemperatureGradient.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new TemperatureGradient(value: 1, unit: TemperatureGradient.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -254,7 +311,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 ∆°C/m", TemperatureGradientUnit.DegreeCelsiusPerMeter, 4.2)]
         [InlineData("en-US", "4.2 ∆°F/ft", TemperatureGradientUnit.DegreeFahrenheitPerFoot, 4.2)]
         [InlineData("en-US", "4.2 ∆°K/m", TemperatureGradientUnit.KelvinPerMeter, 4.2)]
-        public void Parse(string culture, string quantityString, TemperatureGradientUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, TemperatureGradientUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = TemperatureGradient.Parse(quantityString);
@@ -267,7 +324,7 @@ public void Parse(string culture, string quantityString, TemperatureGradientUnit
         [InlineData("en-US", "4.2 ∆°C/m", TemperatureGradientUnit.DegreeCelsiusPerMeter, 4.2)]
         [InlineData("en-US", "4.2 ∆°F/ft", TemperatureGradientUnit.DegreeFahrenheitPerFoot, 4.2)]
         [InlineData("en-US", "4.2 ∆°K/m", TemperatureGradientUnit.KelvinPerMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, TemperatureGradientUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, TemperatureGradientUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(TemperatureGradient.TryParse(quantityString, out TemperatureGradient parsed));
@@ -427,6 +484,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(TemperatureGradi
                 var quantity = TemperatureGradient.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -450,35 +508,37 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(TemperatureGradient
                 IQuantity<TemperatureGradientUnit> quantityToConvert = quantity;
                 IQuantity<TemperatureGradientUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            TemperatureGradient kelvinpermeter = TemperatureGradient.FromKelvinsPerMeter(1);
-            AssertEx.EqualTolerance(1, TemperatureGradient.FromDegreesCelsiusPerKilometer(kelvinpermeter.DegreesCelsiusPerKilometer).KelvinsPerMeter, DegreesCelsiusPerKilometerTolerance);
-            AssertEx.EqualTolerance(1, TemperatureGradient.FromDegreesCelsiusPerMeter(kelvinpermeter.DegreesCelsiusPerMeter).KelvinsPerMeter, DegreesCelsiusPerMeterTolerance);
-            AssertEx.EqualTolerance(1, TemperatureGradient.FromDegreesFahrenheitPerFoot(kelvinpermeter.DegreesFahrenheitPerFoot).KelvinsPerMeter, DegreesFahrenheitPerFootTolerance);
-            AssertEx.EqualTolerance(1, TemperatureGradient.FromKelvinsPerMeter(kelvinpermeter.KelvinsPerMeter).KelvinsPerMeter, KelvinsPerMeterTolerance);
+            TemperatureGradient kelvinpermeter = TemperatureGradient.FromKelvinsPerMeter(3);
+            Assert.Equal(3, TemperatureGradient.FromDegreesCelsiusPerKilometer(kelvinpermeter.DegreesCelsiusPerKilometer).KelvinsPerMeter);
+            Assert.Equal(3, TemperatureGradient.FromDegreesCelsiusPerMeter(kelvinpermeter.DegreesCelsiusPerMeter).KelvinsPerMeter);
+            Assert.Equal(3, TemperatureGradient.FromDegreesFahrenheitPerFoot(kelvinpermeter.DegreesFahrenheitPerFoot).KelvinsPerMeter);
+            Assert.Equal(3, TemperatureGradient.FromKelvinsPerMeter(kelvinpermeter.KelvinsPerMeter).KelvinsPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             TemperatureGradient v = TemperatureGradient.FromKelvinsPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.KelvinsPerMeter, KelvinsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (TemperatureGradient.FromKelvinsPerMeter(3)-v).KelvinsPerMeter, KelvinsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KelvinsPerMeter, KelvinsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KelvinsPerMeter, KelvinsPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KelvinsPerMeter, KelvinsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (TemperatureGradient.FromKelvinsPerMeter(10)/5).KelvinsPerMeter, KelvinsPerMeterTolerance);
-            AssertEx.EqualTolerance(2, TemperatureGradient.FromKelvinsPerMeter(10)/TemperatureGradient.FromKelvinsPerMeter(5), KelvinsPerMeterTolerance);
+            Assert.Equal(-1, -v.KelvinsPerMeter);
+            Assert.Equal(2, (TemperatureGradient.FromKelvinsPerMeter(3) - v).KelvinsPerMeter);
+            Assert.Equal(2, (v + v).KelvinsPerMeter);
+            Assert.Equal(10, (v * 10).KelvinsPerMeter);
+            Assert.Equal(10, (10 * v).KelvinsPerMeter);
+            Assert.Equal(2, (TemperatureGradient.FromKelvinsPerMeter(10) / 5).KelvinsPerMeter);
+            Assert.Equal(2, TemperatureGradient.FromKelvinsPerMeter(10) / TemperatureGradient.FromKelvinsPerMeter(5));
         }
 
         [Fact]
@@ -524,8 +584,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, TemperatureGradientUnit.KelvinPerMeter, 1, TemperatureGradientUnit.KelvinPerMeter, true)]  // Same value and unit.
         [InlineData(1, TemperatureGradientUnit.KelvinPerMeter, 2, TemperatureGradientUnit.KelvinPerMeter, false)] // Different value.
-        [InlineData(2, TemperatureGradientUnit.KelvinPerMeter, 1, TemperatureGradientUnit.DegreeCelsiusPerKilometer, false)] // Different value and unit.
-        [InlineData(1, TemperatureGradientUnit.KelvinPerMeter, 1, TemperatureGradientUnit.DegreeCelsiusPerKilometer, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, TemperatureGradientUnit unitA, double valueB, TemperatureGradientUnit unitB, bool expectEqual)
         {
             var a = new TemperatureGradient(valueA, unitA);
@@ -585,8 +643,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = TemperatureGradient.FromKelvinsPerMeter(firstValue);
             var otherQuantity = TemperatureGradient.FromKelvinsPerMeter(secondValue);
             TemperatureGradient maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, TemperatureGradient.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -605,7 +663,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<TemperatureGradientUnit>();
+            var units = EnumHelper.GetValues<TemperatureGradientUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -618,6 +676,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(TemperatureGradient.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(TemperatureGradient.Info.Units, TemperatureGradient.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, TemperatureGradient.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -640,26 +710,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 ∆°K/m", new TemperatureGradient(1, TemperatureGradientUnit.KelvinPerMeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 ∆°K/m", new TemperatureGradient(0.123456, TemperatureGradientUnit.KelvinPerMeter).ToString("s1"));
-            Assert.Equal("0.12 ∆°K/m", new TemperatureGradient(0.123456, TemperatureGradientUnit.KelvinPerMeter).ToString("s2"));
-            Assert.Equal("0.123 ∆°K/m", new TemperatureGradient(0.123456, TemperatureGradientUnit.KelvinPerMeter).ToString("s3"));
-            Assert.Equal("0.1235 ∆°K/m", new TemperatureGradient(0.123456, TemperatureGradientUnit.KelvinPerMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 ∆°K/m", new TemperatureGradient(0.123456, TemperatureGradientUnit.KelvinPerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 ∆°K/m", new TemperatureGradient(0.123456, TemperatureGradientUnit.KelvinPerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 ∆°K/m", new TemperatureGradient(0.123456, TemperatureGradientUnit.KelvinPerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 ∆°K/m", new TemperatureGradient(0.123456, TemperatureGradientUnit.KelvinPerMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -686,7 +736,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = TemperatureGradient.FromKelvinsPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(TemperatureGradient), quantity.As(TemperatureGradient.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureTestsBase.g.cs
index 84bad27648..eeff35dd3e 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TemperatureTestsBase.g.cs
@@ -161,6 +161,20 @@ public void Temperature_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<TemperatureUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void TemperatureInfo_CreateWithCustomUnitInfos()
+        {
+            TemperatureUnit[] expectedUnits = [TemperatureUnit.Kelvin];
+
+            Temperature.TemperatureInfo quantityInfo = Temperature.TemperatureInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Temperature", quantityInfo.Name);
+            Assert.Equal(Temperature.Zero, quantityInfo.Zero);
+            Assert.Equal(Temperature.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KelvinToTemperatureUnits()
         {
@@ -263,26 +277,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Temperature.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Temperature convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Temperature quantityToConvert = quantity;
+
+                Temperature convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<TemperatureUnit> quantityToConvert = quantity;
+
+                IQuantity<TemperatureUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Temperature(value: 1, unit: Temperature.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Temperature(value: 1, unit: Temperature.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<TemperatureUnit> quantity = new Temperature(value: 1, unit: Temperature.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Temperature(value: 1, unit: Temperature.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Temperature(value: 1, unit: Temperature.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Temperature(value: 1, unit: Temperature.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<TemperatureUnit> quantity = new Temperature(value: 1, unit: Temperature.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Temperature(value: 1, unit: Temperature.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -296,7 +353,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 K", TemperatureUnit.Kelvin, 4.2)]
         [InlineData("en-US", "4.2 m°C", TemperatureUnit.MillidegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 T⊙", TemperatureUnit.SolarTemperature, 4.2)]
-        public void Parse(string culture, string quantityString, TemperatureUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, TemperatureUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Temperature.Parse(quantityString);
@@ -315,7 +372,7 @@ public void Parse(string culture, string quantityString, TemperatureUnit expecte
         [InlineData("en-US", "4.2 K", TemperatureUnit.Kelvin, 4.2)]
         [InlineData("en-US", "4.2 m°C", TemperatureUnit.MillidegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 T⊙", TemperatureUnit.SolarTemperature, 4.2)]
-        public void TryParse(string culture, string quantityString, TemperatureUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, TemperatureUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Temperature.TryParse(quantityString, out Temperature parsed));
@@ -529,6 +586,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(TemperatureUnit
                 var quantity = Temperature.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -552,28 +610,30 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(TemperatureUnit uni
                 IQuantity<TemperatureUnit> quantityToConvert = quantity;
                 IQuantity<TemperatureUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Temperature kelvin = Temperature.FromKelvins(1);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins, DegreesCelsiusTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins, DegreesDelisleTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins, DegreesFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesNewton(kelvin.DegreesNewton).Kelvins, DegreesNewtonTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesRankine(kelvin.DegreesRankine).Kelvins, DegreesRankineTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins, DegreesReaumurTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins, DegreesRoemerTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromKelvins(kelvin.Kelvins).Kelvins, KelvinsTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromMillidegreesCelsius(kelvin.MillidegreesCelsius).Kelvins, MillidegreesCelsiusTolerance);
-            AssertEx.EqualTolerance(1, Temperature.FromSolarTemperatures(kelvin.SolarTemperatures).Kelvins, SolarTemperaturesTolerance);
+            Temperature kelvin = Temperature.FromKelvins(3);
+            Assert.Equal(3, Temperature.FromDegreesCelsius(kelvin.DegreesCelsius).Kelvins);
+            Assert.Equal(3, Temperature.FromDegreesDelisle(kelvin.DegreesDelisle).Kelvins);
+            Assert.Equal(3, Temperature.FromDegreesFahrenheit(kelvin.DegreesFahrenheit).Kelvins);
+            Assert.Equal(3, Temperature.FromDegreesNewton(kelvin.DegreesNewton).Kelvins);
+            Assert.Equal(3, Temperature.FromDegreesRankine(kelvin.DegreesRankine).Kelvins);
+            Assert.Equal(3, Temperature.FromDegreesReaumur(kelvin.DegreesReaumur).Kelvins);
+            Assert.Equal(3, Temperature.FromDegreesRoemer(kelvin.DegreesRoemer).Kelvins);
+            Assert.Equal(3, Temperature.FromKelvins(kelvin.Kelvins).Kelvins);
+            Assert.Equal(3, Temperature.FromMillidegreesCelsius(kelvin.MillidegreesCelsius).Kelvins);
+            Assert.Equal(3, Temperature.FromSolarTemperatures(kelvin.SolarTemperatures).Kelvins);
         }
 
 
@@ -620,8 +680,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, TemperatureUnit.Kelvin, 1, TemperatureUnit.Kelvin, true)]  // Same value and unit.
         [InlineData(1, TemperatureUnit.Kelvin, 2, TemperatureUnit.Kelvin, false)] // Different value.
-        [InlineData(2, TemperatureUnit.Kelvin, 1, TemperatureUnit.DegreeCelsius, false)] // Different value and unit.
-        [InlineData(1, TemperatureUnit.Kelvin, 1, TemperatureUnit.DegreeCelsius, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, TemperatureUnit unitA, double valueB, TemperatureUnit unitB, bool expectEqual)
         {
             var a = new Temperature(valueA, unitA);
@@ -681,8 +739,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Temperature.FromKelvins(firstValue);
             var otherQuantity = Temperature.FromKelvins(secondValue);
             TemperatureDelta maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, TemperatureDelta.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -701,7 +759,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<TemperatureUnit>();
+            var units = EnumHelper.GetValues<TemperatureUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -714,6 +772,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Temperature.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Temperature.Info.Units, Temperature.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Temperature.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -748,26 +818,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 T⊙", new Temperature(1, TemperatureUnit.SolarTemperature).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 K", new Temperature(0.123456, TemperatureUnit.Kelvin).ToString("s1"));
-            Assert.Equal("0.12 K", new Temperature(0.123456, TemperatureUnit.Kelvin).ToString("s2"));
-            Assert.Equal("0.123 K", new Temperature(0.123456, TemperatureUnit.Kelvin).ToString("s3"));
-            Assert.Equal("0.1235 K", new Temperature(0.123456, TemperatureUnit.Kelvin).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 K", new Temperature(0.123456, TemperatureUnit.Kelvin).ToString("s1", culture));
-            Assert.Equal("0.12 K", new Temperature(0.123456, TemperatureUnit.Kelvin).ToString("s2", culture));
-            Assert.Equal("0.123 K", new Temperature(0.123456, TemperatureUnit.Kelvin).ToString("s3", culture));
-            Assert.Equal("0.1235 K", new Temperature(0.123456, TemperatureUnit.Kelvin).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -794,7 +844,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Temperature.FromKelvins(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Temperature), quantity.As(Temperature.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
     }
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalConductivityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalConductivityTestsBase.g.cs
index c104c056cf..8baeaa7b07 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalConductivityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalConductivityTestsBase.g.cs
@@ -41,10 +41,12 @@ namespace UnitsNet.Tests
     public abstract partial class ThermalConductivityTestsBase : QuantityTestsBase
     {
         protected abstract double BtusPerHourFootFahrenheitInOneWattPerMeterKelvin { get; }
+        protected abstract double BtusPerSecondInchFahrenheitInOneWattPerMeterKelvin { get; }
         protected abstract double WattsPerMeterKelvinInOneWattPerMeterKelvin { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double BtusPerHourFootFahrenheitTolerance { get { return 1e-5; } }
+        protected virtual double BtusPerSecondInchFahrenheitTolerance { get { return 1e-5; } }
         protected virtual double WattsPerMeterKelvinTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
@@ -53,6 +55,7 @@ public abstract partial class ThermalConductivityTestsBase : QuantityTestsBase
             return unit switch
             {
                 ThermalConductivityUnit.BtuPerHourFootFahrenheit => (BtusPerHourFootFahrenheitInOneWattPerMeterKelvin, BtusPerHourFootFahrenheitTolerance),
+                ThermalConductivityUnit.BtuPerSecondInchFahrenheit => (BtusPerSecondInchFahrenheitInOneWattPerMeterKelvin, BtusPerSecondInchFahrenheitTolerance),
                 ThermalConductivityUnit.WattPerMeterKelvin => (WattsPerMeterKelvinInOneWattPerMeterKelvin, WattsPerMeterKelvinTolerance),
                 _ => throw new NotSupportedException()
             };
@@ -61,6 +64,7 @@ public abstract partial class ThermalConductivityTestsBase : QuantityTestsBase
         public static IEnumerable<object[]> UnitTypes = new List<object[]>
         {
             new object[] { ThermalConductivityUnit.BtuPerHourFootFahrenheit },
+            new object[] { ThermalConductivityUnit.BtuPerSecondInchFahrenheit },
             new object[] { ThermalConductivityUnit.WattPerMeterKelvin },
         };
 
@@ -129,11 +133,26 @@ public void ThermalConductivity_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
             Assert.Equal(quantityInfo, ((IQuantity<ThermalConductivityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ThermalConductivityInfo_CreateWithCustomUnitInfos()
+        {
+            ThermalConductivityUnit[] expectedUnits = [ThermalConductivityUnit.WattPerMeterKelvin];
+
+            ThermalConductivity.ThermalConductivityInfo quantityInfo = ThermalConductivity.ThermalConductivityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ThermalConductivity", quantityInfo.Name);
+            Assert.Equal(ThermalConductivity.Zero, quantityInfo.Zero);
+            Assert.Equal(ThermalConductivity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void WattPerMeterKelvinToThermalConductivityUnits()
         {
             ThermalConductivity wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
             AssertEx.EqualTolerance(BtusPerHourFootFahrenheitInOneWattPerMeterKelvin, wattpermeterkelvin.BtusPerHourFootFahrenheit, BtusPerHourFootFahrenheitTolerance);
+            AssertEx.EqualTolerance(BtusPerSecondInchFahrenheitInOneWattPerMeterKelvin, wattpermeterkelvin.BtusPerSecondInchFahrenheit, BtusPerSecondInchFahrenheitTolerance);
             AssertEx.EqualTolerance(WattsPerMeterKelvinInOneWattPerMeterKelvin, wattpermeterkelvin.WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
         }
 
@@ -171,6 +190,7 @@ public void As()
         {
             var wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
             AssertEx.EqualTolerance(BtusPerHourFootFahrenheitInOneWattPerMeterKelvin, wattpermeterkelvin.As(ThermalConductivityUnit.BtuPerHourFootFahrenheit), BtusPerHourFootFahrenheitTolerance);
+            AssertEx.EqualTolerance(BtusPerSecondInchFahrenheitInOneWattPerMeterKelvin, wattpermeterkelvin.As(ThermalConductivityUnit.BtuPerSecondInchFahrenheit), BtusPerSecondInchFahrenheitTolerance);
             AssertEx.EqualTolerance(WattsPerMeterKelvinInOneWattPerMeterKelvin, wattpermeterkelvin.As(ThermalConductivityUnit.WattPerMeterKelvin), WattsPerMeterKelvinTolerance);
         }
 
@@ -215,32 +235,76 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ThermalConductivity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ThermalConductivity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ThermalConductivity quantityToConvert = quantity;
+
+                ThermalConductivity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ThermalConductivityUnit> quantityToConvert = quantity;
+
+                IQuantity<ThermalConductivityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ThermalConductivity(value: 1, unit: ThermalConductivity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ThermalConductivity(value: 1, unit: ThermalConductivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ThermalConductivityUnit> quantity = new ThermalConductivity(value: 1, unit: ThermalConductivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ThermalConductivity(value: 1, unit: ThermalConductivity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ThermalConductivity(value: 1, unit: ThermalConductivity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ThermalConductivity(value: 1, unit: ThermalConductivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ThermalConductivityUnit> quantity = new ThermalConductivity(value: 1, unit: ThermalConductivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ThermalConductivity(value: 1, unit: ThermalConductivity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 BTU/(h·ft·°F)", ThermalConductivityUnit.BtuPerHourFootFahrenheit, 4.2)]
+        [InlineData("en-US", "4.2 BTU/(s·in·°F)", ThermalConductivityUnit.BtuPerSecondInchFahrenheit, 4.2)]
         [InlineData("en-US", "4.2 W/(m·K)", ThermalConductivityUnit.WattPerMeterKelvin, 4.2)]
-        public void Parse(string culture, string quantityString, ThermalConductivityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ThermalConductivityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ThermalConductivity.Parse(quantityString);
@@ -250,8 +314,9 @@ public void Parse(string culture, string quantityString, ThermalConductivityUnit
 
         [Theory]
         [InlineData("en-US", "4.2 BTU/(h·ft·°F)", ThermalConductivityUnit.BtuPerHourFootFahrenheit, 4.2)]
+        [InlineData("en-US", "4.2 BTU/(s·in·°F)", ThermalConductivityUnit.BtuPerSecondInchFahrenheit, 4.2)]
         [InlineData("en-US", "4.2 W/(m·K)", ThermalConductivityUnit.WattPerMeterKelvin, 4.2)]
-        public void TryParse(string culture, string quantityString, ThermalConductivityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ThermalConductivityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ThermalConductivity.TryParse(quantityString, out ThermalConductivity parsed));
@@ -261,6 +326,7 @@ public void TryParse(string culture, string quantityString, ThermalConductivityU
 
         [Theory]
         [InlineData("BTU/(h·ft·°F)", ThermalConductivityUnit.BtuPerHourFootFahrenheit)]
+        [InlineData("BTU/(s·in·°F)", ThermalConductivityUnit.BtuPerSecondInchFahrenheit)]
         [InlineData("W/(m·K)", ThermalConductivityUnit.WattPerMeterKelvin)]
         public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, ThermalConductivityUnit expectedUnit)
         {
@@ -272,6 +338,7 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, ThermalCo
 
         [Theory]
         [InlineData("BTU/(h·ft·°F)", ThermalConductivityUnit.BtuPerHourFootFahrenheit)]
+        [InlineData("BTU/(s·in·°F)", ThermalConductivityUnit.BtuPerSecondInchFahrenheit)]
         [InlineData("W/(m·K)", ThermalConductivityUnit.WattPerMeterKelvin)]
         public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, ThermalConductivityUnit expectedUnit)
         {
@@ -283,6 +350,7 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
 
         [Theory]
         [InlineData("en-US", "BTU/(h·ft·°F)", ThermalConductivityUnit.BtuPerHourFootFahrenheit)]
+        [InlineData("en-US", "BTU/(s·in·°F)", ThermalConductivityUnit.BtuPerSecondInchFahrenheit)]
         [InlineData("en-US", "W/(m·K)", ThermalConductivityUnit.WattPerMeterKelvin)]
         public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, ThermalConductivityUnit expectedUnit)
         {
@@ -293,6 +361,7 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Th
 
         [Theory]
         [InlineData("en-US", "BTU/(h·ft·°F)", ThermalConductivityUnit.BtuPerHourFootFahrenheit)]
+        [InlineData("en-US", "BTU/(s·in·°F)", ThermalConductivityUnit.BtuPerSecondInchFahrenheit)]
         [InlineData("en-US", "W/(m·K)", ThermalConductivityUnit.WattPerMeterKelvin)]
         public void ParseUnit_WithCulture(string culture, string abbreviation, ThermalConductivityUnit expectedUnit)
         {
@@ -302,6 +371,7 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, ThermalCo
 
         [Theory]
         [InlineData("BTU/(h·ft·°F)", ThermalConductivityUnit.BtuPerHourFootFahrenheit)]
+        [InlineData("BTU/(s·in·°F)", ThermalConductivityUnit.BtuPerSecondInchFahrenheit)]
         [InlineData("W/(m·K)", ThermalConductivityUnit.WattPerMeterKelvin)]
         public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, ThermalConductivityUnit expectedUnit)
         {
@@ -313,6 +383,7 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Therma
 
         [Theory]
         [InlineData("BTU/(h·ft·°F)", ThermalConductivityUnit.BtuPerHourFootFahrenheit)]
+        [InlineData("BTU/(s·in·°F)", ThermalConductivityUnit.BtuPerSecondInchFahrenheit)]
         [InlineData("W/(m·K)", ThermalConductivityUnit.WattPerMeterKelvin)]
         public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, ThermalConductivityUnit expectedUnit)
         {
@@ -324,6 +395,7 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
 
         [Theory]
         [InlineData("en-US", "BTU/(h·ft·°F)", ThermalConductivityUnit.BtuPerHourFootFahrenheit)]
+        [InlineData("en-US", "BTU/(s·in·°F)", ThermalConductivityUnit.BtuPerSecondInchFahrenheit)]
         [InlineData("en-US", "W/(m·K)", ThermalConductivityUnit.WattPerMeterKelvin)]
         public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, ThermalConductivityUnit expectedUnit)
         {
@@ -334,6 +406,7 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
 
         [Theory]
         [InlineData("en-US", "BTU/(h·ft·°F)", ThermalConductivityUnit.BtuPerHourFootFahrenheit)]
+        [InlineData("en-US", "BTU/(s·in·°F)", ThermalConductivityUnit.BtuPerSecondInchFahrenheit)]
         [InlineData("en-US", "W/(m·K)", ThermalConductivityUnit.WattPerMeterKelvin)]
         public void TryParseUnit_WithCulture(string culture, string abbreviation, ThermalConductivityUnit expectedUnit)
         {
@@ -343,6 +416,7 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Therma
 
         [Theory]
         [InlineData("en-US", ThermalConductivityUnit.BtuPerHourFootFahrenheit, "BTU/(h·ft·°F)")]
+        [InlineData("en-US", ThermalConductivityUnit.BtuPerSecondInchFahrenheit, "BTU/(s·in·°F)")]
         [InlineData("en-US", ThermalConductivityUnit.WattPerMeterKelvin, "W/(m·K)")]
         public void GetAbbreviationForCulture(string culture, ThermalConductivityUnit unit, string expectedAbbreviation)
         {
@@ -393,6 +467,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ThermalConductiv
                 var quantity = ThermalConductivity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -416,33 +491,36 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ThermalConductivity
                 IQuantity<ThermalConductivityUnit> quantityToConvert = quantity;
                 IQuantity<ThermalConductivityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ThermalConductivity wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(1);
-            AssertEx.EqualTolerance(1, ThermalConductivity.FromBtusPerHourFootFahrenheit(wattpermeterkelvin.BtusPerHourFootFahrenheit).WattsPerMeterKelvin, BtusPerHourFootFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, ThermalConductivity.FromWattsPerMeterKelvin(wattpermeterkelvin.WattsPerMeterKelvin).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
+            ThermalConductivity wattpermeterkelvin = ThermalConductivity.FromWattsPerMeterKelvin(3);
+            Assert.Equal(3, ThermalConductivity.FromBtusPerHourFootFahrenheit(wattpermeterkelvin.BtusPerHourFootFahrenheit).WattsPerMeterKelvin);
+            Assert.Equal(3, ThermalConductivity.FromBtusPerSecondInchFahrenheit(wattpermeterkelvin.BtusPerSecondInchFahrenheit).WattsPerMeterKelvin);
+            Assert.Equal(3, ThermalConductivity.FromWattsPerMeterKelvin(wattpermeterkelvin.WattsPerMeterKelvin).WattsPerMeterKelvin);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ThermalConductivity v = ThermalConductivity.FromWattsPerMeterKelvin(1);
-            AssertEx.EqualTolerance(-1, -v.WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (ThermalConductivity.FromWattsPerMeterKelvin(3)-v).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (v + v).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
-            AssertEx.EqualTolerance(10, (v*10).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
-            AssertEx.EqualTolerance(10, (10*v).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (ThermalConductivity.FromWattsPerMeterKelvin(10)/5).WattsPerMeterKelvin, WattsPerMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, ThermalConductivity.FromWattsPerMeterKelvin(10)/ThermalConductivity.FromWattsPerMeterKelvin(5), WattsPerMeterKelvinTolerance);
+            Assert.Equal(-1, -v.WattsPerMeterKelvin);
+            Assert.Equal(2, (ThermalConductivity.FromWattsPerMeterKelvin(3) - v).WattsPerMeterKelvin);
+            Assert.Equal(2, (v + v).WattsPerMeterKelvin);
+            Assert.Equal(10, (v * 10).WattsPerMeterKelvin);
+            Assert.Equal(10, (10 * v).WattsPerMeterKelvin);
+            Assert.Equal(2, (ThermalConductivity.FromWattsPerMeterKelvin(10) / 5).WattsPerMeterKelvin);
+            Assert.Equal(2, ThermalConductivity.FromWattsPerMeterKelvin(10) / ThermalConductivity.FromWattsPerMeterKelvin(5));
         }
 
         [Fact]
@@ -488,8 +566,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ThermalConductivityUnit.WattPerMeterKelvin, 1, ThermalConductivityUnit.WattPerMeterKelvin, true)]  // Same value and unit.
         [InlineData(1, ThermalConductivityUnit.WattPerMeterKelvin, 2, ThermalConductivityUnit.WattPerMeterKelvin, false)] // Different value.
-        [InlineData(2, ThermalConductivityUnit.WattPerMeterKelvin, 1, ThermalConductivityUnit.BtuPerHourFootFahrenheit, false)] // Different value and unit.
-        [InlineData(1, ThermalConductivityUnit.WattPerMeterKelvin, 1, ThermalConductivityUnit.BtuPerHourFootFahrenheit, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ThermalConductivityUnit unitA, double valueB, ThermalConductivityUnit unitB, bool expectEqual)
         {
             var a = new ThermalConductivity(valueA, unitA);
@@ -549,8 +625,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ThermalConductivity.FromWattsPerMeterKelvin(firstValue);
             var otherQuantity = ThermalConductivity.FromWattsPerMeterKelvin(secondValue);
             ThermalConductivity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ThermalConductivity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -569,7 +645,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ThermalConductivityUnit>();
+            var units = EnumHelper.GetValues<ThermalConductivityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -582,11 +658,24 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ThermalConductivity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ThermalConductivity.Info.Units, ThermalConductivity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ThermalConductivity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
             using var _ = new CultureScope("en-US");
             Assert.Equal("1 BTU/(h·ft·°F)", new ThermalConductivity(1, ThermalConductivityUnit.BtuPerHourFootFahrenheit).ToString());
+            Assert.Equal("1 BTU/(s·in·°F)", new ThermalConductivity(1, ThermalConductivityUnit.BtuPerSecondInchFahrenheit).ToString());
             Assert.Equal("1 W/(m·K)", new ThermalConductivity(1, ThermalConductivityUnit.WattPerMeterKelvin).ToString());
         }
 
@@ -597,29 +686,10 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
 
             Assert.Equal("1 BTU/(h·ft·°F)", new ThermalConductivity(1, ThermalConductivityUnit.BtuPerHourFootFahrenheit).ToString(swedishCulture));
+            Assert.Equal("1 BTU/(s·in·°F)", new ThermalConductivity(1, ThermalConductivityUnit.BtuPerSecondInchFahrenheit).ToString(swedishCulture));
             Assert.Equal("1 W/(m·K)", new ThermalConductivity(1, ThermalConductivityUnit.WattPerMeterKelvin).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 W/(m·K)", new ThermalConductivity(0.123456, ThermalConductivityUnit.WattPerMeterKelvin).ToString("s1"));
-            Assert.Equal("0.12 W/(m·K)", new ThermalConductivity(0.123456, ThermalConductivityUnit.WattPerMeterKelvin).ToString("s2"));
-            Assert.Equal("0.123 W/(m·K)", new ThermalConductivity(0.123456, ThermalConductivityUnit.WattPerMeterKelvin).ToString("s3"));
-            Assert.Equal("0.1235 W/(m·K)", new ThermalConductivity(0.123456, ThermalConductivityUnit.WattPerMeterKelvin).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 W/(m·K)", new ThermalConductivity(0.123456, ThermalConductivityUnit.WattPerMeterKelvin).ToString("s1", culture));
-            Assert.Equal("0.12 W/(m·K)", new ThermalConductivity(0.123456, ThermalConductivityUnit.WattPerMeterKelvin).ToString("s2", culture));
-            Assert.Equal("0.123 W/(m·K)", new ThermalConductivity(0.123456, ThermalConductivityUnit.WattPerMeterKelvin).ToString("s3", culture));
-            Assert.Equal("0.1235 W/(m·K)", new ThermalConductivity(0.123456, ThermalConductivityUnit.WattPerMeterKelvin).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -646,7 +716,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ThermalConductivity.FromWattsPerMeterKelvin(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ThermalConductivity), quantity.As(ThermalConductivity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalInsulanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalInsulanceTestsBase.g.cs
index 922f4109ea..b29af1a25e 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalInsulanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalInsulanceTestsBase.g.cs
@@ -149,6 +149,20 @@ public void ThermalInsulance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity(
             Assert.Equal(quantityInfo, ((IQuantity<ThermalInsulanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ThermalInsulanceInfo_CreateWithCustomUnitInfos()
+        {
+            ThermalInsulanceUnit[] expectedUnits = [ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt];
+
+            ThermalInsulance.ThermalInsulanceInfo quantityInfo = ThermalInsulance.ThermalInsulanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ThermalInsulance", quantityInfo.Name);
+            Assert.Equal(ThermalInsulance.Zero, quantityInfo.Zero);
+            Assert.Equal(ThermalInsulance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void SquareMeterKelvinPerKilowattToThermalInsulanceUnits()
         {
@@ -245,26 +259,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ThermalInsulance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ThermalInsulance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ThermalInsulance quantityToConvert = quantity;
+
+                ThermalInsulance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ThermalInsulanceUnit> quantityToConvert = quantity;
+
+                IQuantity<ThermalInsulanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ThermalInsulance(value: 1, unit: ThermalInsulance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ThermalInsulance(value: 1, unit: ThermalInsulance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ThermalInsulanceUnit> quantity = new ThermalInsulance(value: 1, unit: ThermalInsulance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ThermalInsulance(value: 1, unit: ThermalInsulance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ThermalInsulance(value: 1, unit: ThermalInsulance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ThermalInsulance(value: 1, unit: ThermalInsulance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ThermalInsulanceUnit> quantity = new ThermalInsulance(value: 1, unit: ThermalInsulance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ThermalInsulance(value: 1, unit: ThermalInsulance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -275,7 +332,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 m²K/kW", ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, 4.2)]
         [InlineData("en-US", "4.2 m²K/W", ThermalInsulanceUnit.SquareMeterKelvinPerWatt, 4.2)]
         [InlineData("en-US", "4.2 mm²K/W", ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt, 4.2)]
-        public void Parse(string culture, string quantityString, ThermalInsulanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ThermalInsulanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ThermalInsulance.Parse(quantityString);
@@ -291,7 +348,7 @@ public void Parse(string culture, string quantityString, ThermalInsulanceUnit ex
         [InlineData("en-US", "4.2 m²K/kW", ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, 4.2)]
         [InlineData("en-US", "4.2 m²K/W", ThermalInsulanceUnit.SquareMeterKelvinPerWatt, 4.2)]
         [InlineData("en-US", "4.2 mm²K/W", ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt, 4.2)]
-        public void TryParse(string culture, string quantityString, ThermalInsulanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ThermalInsulanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ThermalInsulance.TryParse(quantityString, out ThermalInsulance parsed));
@@ -478,6 +535,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ThermalInsulance
                 var quantity = ThermalInsulance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -501,38 +559,40 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ThermalInsulanceUni
                 IQuantity<ThermalInsulanceUnit> quantityToConvert = quantity;
                 IQuantity<ThermalInsulanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ThermalInsulance squaremeterkelvinperkilowatt = ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(1);
-            AssertEx.EqualTolerance(1, ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(squaremeterkelvinperkilowatt.HourSquareFeetDegreesFahrenheitPerBtu).SquareMeterKelvinsPerKilowatt, HourSquareFeetDegreesFahrenheitPerBtuTolerance);
-            AssertEx.EqualTolerance(1, ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(squaremeterkelvinperkilowatt.SquareCentimeterHourDegreesCelsiusPerKilocalorie).SquareMeterKelvinsPerKilowatt, SquareCentimeterHourDegreesCelsiusPerKilocalorieTolerance);
-            AssertEx.EqualTolerance(1, ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(squaremeterkelvinperkilowatt.SquareCentimeterKelvinsPerWatt).SquareMeterKelvinsPerKilowatt, SquareCentimeterKelvinsPerWattTolerance);
-            AssertEx.EqualTolerance(1, ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(squaremeterkelvinperkilowatt.SquareMeterDegreesCelsiusPerWatt).SquareMeterKelvinsPerKilowatt, SquareMeterDegreesCelsiusPerWattTolerance);
-            AssertEx.EqualTolerance(1, ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(squaremeterkelvinperkilowatt.SquareMeterKelvinsPerKilowatt).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
-            AssertEx.EqualTolerance(1, ThermalInsulance.FromSquareMeterKelvinsPerWatt(squaremeterkelvinperkilowatt.SquareMeterKelvinsPerWatt).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerWattTolerance);
-            AssertEx.EqualTolerance(1, ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(squaremeterkelvinperkilowatt.SquareMillimeterKelvinsPerWatt).SquareMeterKelvinsPerKilowatt, SquareMillimeterKelvinsPerWattTolerance);
+            ThermalInsulance squaremeterkelvinperkilowatt = ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(3);
+            Assert.Equal(3, ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(squaremeterkelvinperkilowatt.HourSquareFeetDegreesFahrenheitPerBtu).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(3, ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(squaremeterkelvinperkilowatt.SquareCentimeterHourDegreesCelsiusPerKilocalorie).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(3, ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(squaremeterkelvinperkilowatt.SquareCentimeterKelvinsPerWatt).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(3, ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(squaremeterkelvinperkilowatt.SquareMeterDegreesCelsiusPerWatt).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(3, ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(squaremeterkelvinperkilowatt.SquareMeterKelvinsPerKilowatt).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(3, ThermalInsulance.FromSquareMeterKelvinsPerWatt(squaremeterkelvinperkilowatt.SquareMeterKelvinsPerWatt).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(3, ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(squaremeterkelvinperkilowatt.SquareMillimeterKelvinsPerWatt).SquareMeterKelvinsPerKilowatt);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ThermalInsulance v = ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(1);
-            AssertEx.EqualTolerance(-1, -v.SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
-            AssertEx.EqualTolerance(2, (ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(3)-v).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
-            AssertEx.EqualTolerance(2, (v + v).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
-            AssertEx.EqualTolerance(10, (v*10).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
-            AssertEx.EqualTolerance(10, (10*v).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
-            AssertEx.EqualTolerance(2, (ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(10)/5).SquareMeterKelvinsPerKilowatt, SquareMeterKelvinsPerKilowattTolerance);
-            AssertEx.EqualTolerance(2, ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(10)/ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(5), SquareMeterKelvinsPerKilowattTolerance);
+            Assert.Equal(-1, -v.SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(2, (ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(3) - v).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(2, (v + v).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(10, (v * 10).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(10, (10 * v).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(2, (ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(10) / 5).SquareMeterKelvinsPerKilowatt);
+            Assert.Equal(2, ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(10) / ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(5));
         }
 
         [Fact]
@@ -578,8 +638,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, 1, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, true)]  // Same value and unit.
         [InlineData(1, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, 2, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, false)] // Different value.
-        [InlineData(2, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, 1, ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, false)] // Different value and unit.
-        [InlineData(1, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, 1, ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ThermalInsulanceUnit unitA, double valueB, ThermalInsulanceUnit unitB, bool expectEqual)
         {
             var a = new ThermalInsulance(valueA, unitA);
@@ -639,8 +697,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(firstValue);
             var otherQuantity = ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(secondValue);
             ThermalInsulance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ThermalInsulance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -659,7 +717,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ThermalInsulanceUnit>();
+            var units = EnumHelper.GetValues<ThermalInsulanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -672,6 +730,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ThermalInsulance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ThermalInsulance.Info.Units, ThermalInsulance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ThermalInsulance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -700,26 +770,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 mm²K/W", new ThermalInsulance(1, ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m²K/kW", new ThermalInsulance(0.123456, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt).ToString("s1"));
-            Assert.Equal("0.12 m²K/kW", new ThermalInsulance(0.123456, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt).ToString("s2"));
-            Assert.Equal("0.123 m²K/kW", new ThermalInsulance(0.123456, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt).ToString("s3"));
-            Assert.Equal("0.1235 m²K/kW", new ThermalInsulance(0.123456, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m²K/kW", new ThermalInsulance(0.123456, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt).ToString("s1", culture));
-            Assert.Equal("0.12 m²K/kW", new ThermalInsulance(0.123456, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt).ToString("s2", culture));
-            Assert.Equal("0.123 m²K/kW", new ThermalInsulance(0.123456, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt).ToString("s3", culture));
-            Assert.Equal("0.1235 m²K/kW", new ThermalInsulance(0.123456, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -746,7 +796,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ThermalInsulance), quantity.As(ThermalInsulance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalResistanceTestsBase.g.cs
index 692a181530..8b76a7d96c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalResistanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ThermalResistanceTestsBase.g.cs
@@ -129,6 +129,20 @@ public void ThermalResistance_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
             Assert.Equal(quantityInfo, ((IQuantity<ThermalResistanceUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void ThermalResistanceInfo_CreateWithCustomUnitInfos()
+        {
+            ThermalResistanceUnit[] expectedUnits = [ThermalResistanceUnit.KelvinPerWatt];
+
+            ThermalResistance.ThermalResistanceInfo quantityInfo = ThermalResistance.ThermalResistanceInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("ThermalResistance", quantityInfo.Name);
+            Assert.Equal(ThermalResistance.Zero, quantityInfo.Zero);
+            Assert.Equal(ThermalResistance.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void KelvinPerWattToThermalResistanceUnits()
         {
@@ -215,32 +229,75 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = ThermalResistance.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            ThermalResistance convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                ThermalResistance quantityToConvert = quantity;
+
+                ThermalResistance convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<ThermalResistanceUnit> quantityToConvert = quantity;
+
+                IQuantity<ThermalResistanceUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new ThermalResistance(value: 1, unit: ThermalResistance.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ThermalResistance(value: 1, unit: ThermalResistance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<ThermalResistanceUnit> quantity = new ThermalResistance(value: 1, unit: ThermalResistance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ThermalResistance(value: 1, unit: ThermalResistance.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new ThermalResistance(value: 1, unit: ThermalResistance.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new ThermalResistance(value: 1, unit: ThermalResistance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<ThermalResistanceUnit> quantity = new ThermalResistance(value: 1, unit: ThermalResistance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new ThermalResistance(value: 1, unit: ThermalResistance.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 °C/W", ThermalResistanceUnit.DegreeCelsiusPerWatt, 4.2)]
         [InlineData("en-US", "4.2 K/W", ThermalResistanceUnit.KelvinPerWatt, 4.2)]
-        public void Parse(string culture, string quantityString, ThermalResistanceUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, ThermalResistanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = ThermalResistance.Parse(quantityString);
@@ -251,7 +308,7 @@ public void Parse(string culture, string quantityString, ThermalResistanceUnit e
         [Theory]
         [InlineData("en-US", "4.2 °C/W", ThermalResistanceUnit.DegreeCelsiusPerWatt, 4.2)]
         [InlineData("en-US", "4.2 K/W", ThermalResistanceUnit.KelvinPerWatt, 4.2)]
-        public void TryParse(string culture, string quantityString, ThermalResistanceUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, ThermalResistanceUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(ThermalResistance.TryParse(quantityString, out ThermalResistance parsed));
@@ -393,6 +450,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(ThermalResistanc
                 var quantity = ThermalResistance.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -416,33 +474,35 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(ThermalResistanceUn
                 IQuantity<ThermalResistanceUnit> quantityToConvert = quantity;
                 IQuantity<ThermalResistanceUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            ThermalResistance kelvinperwatt = ThermalResistance.FromKelvinsPerWatt(1);
-            AssertEx.EqualTolerance(1, ThermalResistance.FromDegreesCelsiusPerWatt(kelvinperwatt.DegreesCelsiusPerWatt).KelvinsPerWatt, DegreesCelsiusPerWattTolerance);
-            AssertEx.EqualTolerance(1, ThermalResistance.FromKelvinsPerWatt(kelvinperwatt.KelvinsPerWatt).KelvinsPerWatt, KelvinsPerWattTolerance);
+            ThermalResistance kelvinperwatt = ThermalResistance.FromKelvinsPerWatt(3);
+            Assert.Equal(3, ThermalResistance.FromDegreesCelsiusPerWatt(kelvinperwatt.DegreesCelsiusPerWatt).KelvinsPerWatt);
+            Assert.Equal(3, ThermalResistance.FromKelvinsPerWatt(kelvinperwatt.KelvinsPerWatt).KelvinsPerWatt);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             ThermalResistance v = ThermalResistance.FromKelvinsPerWatt(1);
-            AssertEx.EqualTolerance(-1, -v.KelvinsPerWatt, KelvinsPerWattTolerance);
-            AssertEx.EqualTolerance(2, (ThermalResistance.FromKelvinsPerWatt(3)-v).KelvinsPerWatt, KelvinsPerWattTolerance);
-            AssertEx.EqualTolerance(2, (v + v).KelvinsPerWatt, KelvinsPerWattTolerance);
-            AssertEx.EqualTolerance(10, (v*10).KelvinsPerWatt, KelvinsPerWattTolerance);
-            AssertEx.EqualTolerance(10, (10*v).KelvinsPerWatt, KelvinsPerWattTolerance);
-            AssertEx.EqualTolerance(2, (ThermalResistance.FromKelvinsPerWatt(10)/5).KelvinsPerWatt, KelvinsPerWattTolerance);
-            AssertEx.EqualTolerance(2, ThermalResistance.FromKelvinsPerWatt(10)/ThermalResistance.FromKelvinsPerWatt(5), KelvinsPerWattTolerance);
+            Assert.Equal(-1, -v.KelvinsPerWatt);
+            Assert.Equal(2, (ThermalResistance.FromKelvinsPerWatt(3) - v).KelvinsPerWatt);
+            Assert.Equal(2, (v + v).KelvinsPerWatt);
+            Assert.Equal(10, (v * 10).KelvinsPerWatt);
+            Assert.Equal(10, (10 * v).KelvinsPerWatt);
+            Assert.Equal(2, (ThermalResistance.FromKelvinsPerWatt(10) / 5).KelvinsPerWatt);
+            Assert.Equal(2, ThermalResistance.FromKelvinsPerWatt(10) / ThermalResistance.FromKelvinsPerWatt(5));
         }
 
         [Fact]
@@ -488,8 +548,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, ThermalResistanceUnit.KelvinPerWatt, 1, ThermalResistanceUnit.KelvinPerWatt, true)]  // Same value and unit.
         [InlineData(1, ThermalResistanceUnit.KelvinPerWatt, 2, ThermalResistanceUnit.KelvinPerWatt, false)] // Different value.
-        [InlineData(2, ThermalResistanceUnit.KelvinPerWatt, 1, ThermalResistanceUnit.DegreeCelsiusPerWatt, false)] // Different value and unit.
-        [InlineData(1, ThermalResistanceUnit.KelvinPerWatt, 1, ThermalResistanceUnit.DegreeCelsiusPerWatt, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, ThermalResistanceUnit unitA, double valueB, ThermalResistanceUnit unitB, bool expectEqual)
         {
             var a = new ThermalResistance(valueA, unitA);
@@ -549,8 +607,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = ThermalResistance.FromKelvinsPerWatt(firstValue);
             var otherQuantity = ThermalResistance.FromKelvinsPerWatt(secondValue);
             ThermalResistance maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, ThermalResistance.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -569,7 +627,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<ThermalResistanceUnit>();
+            var units = EnumHelper.GetValues<ThermalResistanceUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -582,6 +640,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(ThermalResistance.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(ThermalResistance.Info.Units, ThermalResistance.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, ThermalResistance.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -600,26 +670,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 K/W", new ThermalResistance(1, ThermalResistanceUnit.KelvinPerWatt).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 K/W", new ThermalResistance(0.123456, ThermalResistanceUnit.KelvinPerWatt).ToString("s1"));
-            Assert.Equal("0.12 K/W", new ThermalResistance(0.123456, ThermalResistanceUnit.KelvinPerWatt).ToString("s2"));
-            Assert.Equal("0.123 K/W", new ThermalResistance(0.123456, ThermalResistanceUnit.KelvinPerWatt).ToString("s3"));
-            Assert.Equal("0.1235 K/W", new ThermalResistance(0.123456, ThermalResistanceUnit.KelvinPerWatt).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 K/W", new ThermalResistance(0.123456, ThermalResistanceUnit.KelvinPerWatt).ToString("s1", culture));
-            Assert.Equal("0.12 K/W", new ThermalResistance(0.123456, ThermalResistanceUnit.KelvinPerWatt).ToString("s2", culture));
-            Assert.Equal("0.123 K/W", new ThermalResistance(0.123456, ThermalResistanceUnit.KelvinPerWatt).ToString("s3", culture));
-            Assert.Equal("0.1235 K/W", new ThermalResistance(0.123456, ThermalResistanceUnit.KelvinPerWatt).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -646,7 +696,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = ThermalResistance.FromKelvinsPerWatt(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(ThermalResistance), quantity.As(ThermalResistance.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs
index 3965db12a5..ae23da6c32 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs
@@ -59,6 +59,8 @@ public abstract partial class TorqueTestsBase : QuantityTestsBase
         protected abstract double NewtonCentimetersInOneNewtonMeter { get; }
         protected abstract double NewtonMetersInOneNewtonMeter { get; }
         protected abstract double NewtonMillimetersInOneNewtonMeter { get; }
+        protected abstract double OunceForceFeetInOneNewtonMeter { get; }
+        protected abstract double OunceForceInchesInOneNewtonMeter { get; }
         protected abstract double PoundalFeetInOneNewtonMeter { get; }
         protected abstract double PoundForceFeetInOneNewtonMeter { get; }
         protected abstract double PoundForceInchesInOneNewtonMeter { get; }
@@ -86,6 +88,8 @@ public abstract partial class TorqueTestsBase : QuantityTestsBase
         protected virtual double NewtonCentimetersTolerance { get { return 1e-5; } }
         protected virtual double NewtonMetersTolerance { get { return 1e-5; } }
         protected virtual double NewtonMillimetersTolerance { get { return 1e-5; } }
+        protected virtual double OunceForceFeetTolerance { get { return 1e-5; } }
+        protected virtual double OunceForceInchesTolerance { get { return 1e-5; } }
         protected virtual double PoundalFeetTolerance { get { return 1e-5; } }
         protected virtual double PoundForceFeetTolerance { get { return 1e-5; } }
         protected virtual double PoundForceInchesTolerance { get { return 1e-5; } }
@@ -117,6 +121,8 @@ public abstract partial class TorqueTestsBase : QuantityTestsBase
                 TorqueUnit.NewtonCentimeter => (NewtonCentimetersInOneNewtonMeter, NewtonCentimetersTolerance),
                 TorqueUnit.NewtonMeter => (NewtonMetersInOneNewtonMeter, NewtonMetersTolerance),
                 TorqueUnit.NewtonMillimeter => (NewtonMillimetersInOneNewtonMeter, NewtonMillimetersTolerance),
+                TorqueUnit.OunceForceFoot => (OunceForceFeetInOneNewtonMeter, OunceForceFeetTolerance),
+                TorqueUnit.OunceForceInch => (OunceForceInchesInOneNewtonMeter, OunceForceInchesTolerance),
                 TorqueUnit.PoundalFoot => (PoundalFeetInOneNewtonMeter, PoundalFeetTolerance),
                 TorqueUnit.PoundForceFoot => (PoundForceFeetInOneNewtonMeter, PoundForceFeetTolerance),
                 TorqueUnit.PoundForceInch => (PoundForceInchesInOneNewtonMeter, PoundForceInchesTolerance),
@@ -148,6 +154,8 @@ public abstract partial class TorqueTestsBase : QuantityTestsBase
             new object[] { TorqueUnit.NewtonCentimeter },
             new object[] { TorqueUnit.NewtonMeter },
             new object[] { TorqueUnit.NewtonMillimeter },
+            new object[] { TorqueUnit.OunceForceFoot },
+            new object[] { TorqueUnit.OunceForceInch },
             new object[] { TorqueUnit.PoundalFoot },
             new object[] { TorqueUnit.PoundForceFoot },
             new object[] { TorqueUnit.PoundForceInch },
@@ -221,6 +229,20 @@ public void Torque_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<TorqueUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void TorqueInfo_CreateWithCustomUnitInfos()
+        {
+            TorqueUnit[] expectedUnits = [TorqueUnit.NewtonMeter];
+
+            Torque.TorqueInfo quantityInfo = Torque.TorqueInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Torque", quantityInfo.Name);
+            Assert.Equal(Torque.Zero, quantityInfo.Zero);
+            Assert.Equal(Torque.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void NewtonMeterToTorqueUnits()
         {
@@ -244,6 +266,8 @@ public void NewtonMeterToTorqueUnits()
             AssertEx.EqualTolerance(NewtonCentimetersInOneNewtonMeter, newtonmeter.NewtonCentimeters, NewtonCentimetersTolerance);
             AssertEx.EqualTolerance(NewtonMetersInOneNewtonMeter, newtonmeter.NewtonMeters, NewtonMetersTolerance);
             AssertEx.EqualTolerance(NewtonMillimetersInOneNewtonMeter, newtonmeter.NewtonMillimeters, NewtonMillimetersTolerance);
+            AssertEx.EqualTolerance(OunceForceFeetInOneNewtonMeter, newtonmeter.OunceForceFeet, OunceForceFeetTolerance);
+            AssertEx.EqualTolerance(OunceForceInchesInOneNewtonMeter, newtonmeter.OunceForceInches, OunceForceInchesTolerance);
             AssertEx.EqualTolerance(PoundalFeetInOneNewtonMeter, newtonmeter.PoundalFeet, PoundalFeetTolerance);
             AssertEx.EqualTolerance(PoundForceFeetInOneNewtonMeter, newtonmeter.PoundForceFeet, PoundForceFeetTolerance);
             AssertEx.EqualTolerance(PoundForceInchesInOneNewtonMeter, newtonmeter.PoundForceInches, PoundForceInchesTolerance);
@@ -304,6 +328,8 @@ public void As()
             AssertEx.EqualTolerance(NewtonCentimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonCentimeter), NewtonCentimetersTolerance);
             AssertEx.EqualTolerance(NewtonMetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonMeter), NewtonMetersTolerance);
             AssertEx.EqualTolerance(NewtonMillimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonMillimeter), NewtonMillimetersTolerance);
+            AssertEx.EqualTolerance(OunceForceFeetInOneNewtonMeter, newtonmeter.As(TorqueUnit.OunceForceFoot), OunceForceFeetTolerance);
+            AssertEx.EqualTolerance(OunceForceInchesInOneNewtonMeter, newtonmeter.As(TorqueUnit.OunceForceInch), OunceForceInchesTolerance);
             AssertEx.EqualTolerance(PoundalFeetInOneNewtonMeter, newtonmeter.As(TorqueUnit.PoundalFoot), PoundalFeetTolerance);
             AssertEx.EqualTolerance(PoundForceFeetInOneNewtonMeter, newtonmeter.As(TorqueUnit.PoundForceFoot), PoundForceFeetTolerance);
             AssertEx.EqualTolerance(PoundForceInchesInOneNewtonMeter, newtonmeter.As(TorqueUnit.PoundForceInch), PoundForceInchesTolerance);
@@ -353,26 +379,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Torque.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Torque convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Torque quantityToConvert = quantity;
+
+                Torque convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<TorqueUnit> quantityToConvert = quantity;
+
+                IQuantity<TorqueUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Torque(value: 1, unit: Torque.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Torque(value: 1, unit: Torque.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<TorqueUnit> quantity = new Torque(value: 1, unit: Torque.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Torque(value: 1, unit: Torque.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Torque(value: 1, unit: Torque.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Torque(value: 1, unit: Torque.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<TorqueUnit> quantity = new Torque(value: 1, unit: Torque.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Torque(value: 1, unit: Torque.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -391,20 +460,45 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 MN·m", TorqueUnit.MeganewtonMeter, 4.2)]
         [InlineData("en-US", "4.2 MN·mm", TorqueUnit.MeganewtonMillimeter, 4.2)]
         [InlineData("en-US", "4.2 Mlbf·ft", TorqueUnit.MegapoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 Mlb·ft", TorqueUnit.MegapoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 Mlbf-ft", TorqueUnit.MegapoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 Mlb-ft", TorqueUnit.MegapoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 Mft-lb", TorqueUnit.MegapoundForceFoot, 4.2)]
         [InlineData("en-US", "4.2 Mlbf·in", TorqueUnit.MegapoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 Mlb·in", TorqueUnit.MegapoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 Mlbf-in", TorqueUnit.MegapoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 Mlb-in", TorqueUnit.MegapoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 Min-lb", TorqueUnit.MegapoundForceInch, 4.2)]
         [InlineData("en-US", "4.2 N·cm", TorqueUnit.NewtonCentimeter, 4.2)]
         [InlineData("en-US", "4.2 N·m", TorqueUnit.NewtonMeter, 4.2)]
         [InlineData("en-US", "4.2 N·mm", TorqueUnit.NewtonMillimeter, 4.2)]
+        [InlineData("en-US", "4.2 ozf·ft", TorqueUnit.OunceForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 oz·ft", TorqueUnit.OunceForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 ozf-ft", TorqueUnit.OunceForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 oz-ft", TorqueUnit.OunceForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 ozf·in", TorqueUnit.OunceForceInch, 4.2)]
+        [InlineData("en-US", "4.2 oz·in", TorqueUnit.OunceForceInch, 4.2)]
+        [InlineData("en-US", "4.2 ozf-in", TorqueUnit.OunceForceInch, 4.2)]
+        [InlineData("en-US", "4.2 oz-in", TorqueUnit.OunceForceInch, 4.2)]
+        [InlineData("en-US", "4.2 in-oz", TorqueUnit.OunceForceInch, 4.2)]
         [InlineData("en-US", "4.2 pdl·ft", TorqueUnit.PoundalFoot, 4.2)]
         [InlineData("en-US", "4.2 lbf·ft", TorqueUnit.PoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 lb·ft", TorqueUnit.PoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 lbf-ft", TorqueUnit.PoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 lb-ft", TorqueUnit.PoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 ft-lb", TorqueUnit.PoundForceFoot, 4.2)]
         [InlineData("en-US", "4.2 lbf·in", TorqueUnit.PoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 lb·in", TorqueUnit.PoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 lbf-in", TorqueUnit.PoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 lb-in", TorqueUnit.PoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 in-lb", TorqueUnit.PoundForceInch, 4.2)]
         [InlineData("en-US", "4.2 tf·cm", TorqueUnit.TonneForceCentimeter, 4.2)]
         [InlineData("en-US", "4.2 tf·m", TorqueUnit.TonneForceMeter, 4.2)]
         [InlineData("en-US", "4.2 tf·mm", TorqueUnit.TonneForceMillimeter, 4.2)]
         [InlineData("ru-RU", "4,2 кН·м", TorqueUnit.KilonewtonMeter, 4.2)]
         [InlineData("ru-RU", "4,2 МН·м", TorqueUnit.MeganewtonMeter, 4.2)]
         [InlineData("ru-RU", "4,2 Н·м", TorqueUnit.NewtonMeter, 4.2)]
-        public void Parse(string culture, string quantityString, TorqueUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, TorqueUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Torque.Parse(quantityString);
@@ -428,20 +522,45 @@ public void Parse(string culture, string quantityString, TorqueUnit expectedUnit
         [InlineData("en-US", "4.2 MN·m", TorqueUnit.MeganewtonMeter, 4.2)]
         [InlineData("en-US", "4.2 MN·mm", TorqueUnit.MeganewtonMillimeter, 4.2)]
         [InlineData("en-US", "4.2 Mlbf·ft", TorqueUnit.MegapoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 Mlb·ft", TorqueUnit.MegapoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 Mlbf-ft", TorqueUnit.MegapoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 Mlb-ft", TorqueUnit.MegapoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 Mft-lb", TorqueUnit.MegapoundForceFoot, 4.2)]
         [InlineData("en-US", "4.2 Mlbf·in", TorqueUnit.MegapoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 Mlb·in", TorqueUnit.MegapoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 Mlbf-in", TorqueUnit.MegapoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 Mlb-in", TorqueUnit.MegapoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 Min-lb", TorqueUnit.MegapoundForceInch, 4.2)]
         [InlineData("en-US", "4.2 N·cm", TorqueUnit.NewtonCentimeter, 4.2)]
         [InlineData("en-US", "4.2 N·m", TorqueUnit.NewtonMeter, 4.2)]
         [InlineData("en-US", "4.2 N·mm", TorqueUnit.NewtonMillimeter, 4.2)]
+        [InlineData("en-US", "4.2 ozf·ft", TorqueUnit.OunceForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 oz·ft", TorqueUnit.OunceForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 ozf-ft", TorqueUnit.OunceForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 oz-ft", TorqueUnit.OunceForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 ozf·in", TorqueUnit.OunceForceInch, 4.2)]
+        [InlineData("en-US", "4.2 oz·in", TorqueUnit.OunceForceInch, 4.2)]
+        [InlineData("en-US", "4.2 ozf-in", TorqueUnit.OunceForceInch, 4.2)]
+        [InlineData("en-US", "4.2 oz-in", TorqueUnit.OunceForceInch, 4.2)]
+        [InlineData("en-US", "4.2 in-oz", TorqueUnit.OunceForceInch, 4.2)]
         [InlineData("en-US", "4.2 pdl·ft", TorqueUnit.PoundalFoot, 4.2)]
         [InlineData("en-US", "4.2 lbf·ft", TorqueUnit.PoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 lb·ft", TorqueUnit.PoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 lbf-ft", TorqueUnit.PoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 lb-ft", TorqueUnit.PoundForceFoot, 4.2)]
+        [InlineData("en-US", "4.2 ft-lb", TorqueUnit.PoundForceFoot, 4.2)]
         [InlineData("en-US", "4.2 lbf·in", TorqueUnit.PoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 lb·in", TorqueUnit.PoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 lbf-in", TorqueUnit.PoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 lb-in", TorqueUnit.PoundForceInch, 4.2)]
+        [InlineData("en-US", "4.2 in-lb", TorqueUnit.PoundForceInch, 4.2)]
         [InlineData("en-US", "4.2 tf·cm", TorqueUnit.TonneForceCentimeter, 4.2)]
         [InlineData("en-US", "4.2 tf·m", TorqueUnit.TonneForceMeter, 4.2)]
         [InlineData("en-US", "4.2 tf·mm", TorqueUnit.TonneForceMillimeter, 4.2)]
         [InlineData("ru-RU", "4,2 кН·м", TorqueUnit.KilonewtonMeter, 4.2)]
         [InlineData("ru-RU", "4,2 МН·м", TorqueUnit.MeganewtonMeter, 4.2)]
         [InlineData("ru-RU", "4,2 Н·м", TorqueUnit.NewtonMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, TorqueUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, TorqueUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Torque.TryParse(quantityString, out Torque parsed));
@@ -465,13 +584,38 @@ public void TryParse(string culture, string quantityString, TorqueUnit expectedU
         [InlineData("MN·m", TorqueUnit.MeganewtonMeter)]
         [InlineData("MN·mm", TorqueUnit.MeganewtonMillimeter)]
         [InlineData("Mlbf·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlb·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlbf-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlb-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mft-lb", TorqueUnit.MegapoundForceFoot)]
         [InlineData("Mlbf·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlb·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlbf-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlb-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Min-lb", TorqueUnit.MegapoundForceInch)]
         [InlineData("N·cm", TorqueUnit.NewtonCentimeter)]
         [InlineData("N·m", TorqueUnit.NewtonMeter)]
         [InlineData("N·mm", TorqueUnit.NewtonMillimeter)]
+        [InlineData("ozf·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("oz·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("ozf-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("oz-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("ozf·in", TorqueUnit.OunceForceInch)]
+        [InlineData("oz·in", TorqueUnit.OunceForceInch)]
+        [InlineData("ozf-in", TorqueUnit.OunceForceInch)]
+        [InlineData("oz-in", TorqueUnit.OunceForceInch)]
+        [InlineData("in-oz", TorqueUnit.OunceForceInch)]
         [InlineData("pdl·ft", TorqueUnit.PoundalFoot)]
         [InlineData("lbf·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lb·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lbf-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lb-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("ft-lb", TorqueUnit.PoundForceFoot)]
         [InlineData("lbf·in", TorqueUnit.PoundForceInch)]
+        [InlineData("lb·in", TorqueUnit.PoundForceInch)]
+        [InlineData("lbf-in", TorqueUnit.PoundForceInch)]
+        [InlineData("lb-in", TorqueUnit.PoundForceInch)]
+        [InlineData("in-lb", TorqueUnit.PoundForceInch)]
         [InlineData("tf·cm", TorqueUnit.TonneForceCentimeter)]
         [InlineData("tf·m", TorqueUnit.TonneForceMeter)]
         [InlineData("tf·mm", TorqueUnit.TonneForceMillimeter)]
@@ -499,13 +643,38 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, TorqueUni
         [InlineData("MN·m", TorqueUnit.MeganewtonMeter)]
         [InlineData("MN·mm", TorqueUnit.MeganewtonMillimeter)]
         [InlineData("Mlbf·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlb·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlbf-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlb-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mft-lb", TorqueUnit.MegapoundForceFoot)]
         [InlineData("Mlbf·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlb·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlbf-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlb-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Min-lb", TorqueUnit.MegapoundForceInch)]
         [InlineData("N·cm", TorqueUnit.NewtonCentimeter)]
         [InlineData("N·m", TorqueUnit.NewtonMeter)]
         [InlineData("N·mm", TorqueUnit.NewtonMillimeter)]
+        [InlineData("ozf·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("oz·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("ozf-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("oz-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("ozf·in", TorqueUnit.OunceForceInch)]
+        [InlineData("oz·in", TorqueUnit.OunceForceInch)]
+        [InlineData("ozf-in", TorqueUnit.OunceForceInch)]
+        [InlineData("oz-in", TorqueUnit.OunceForceInch)]
+        [InlineData("in-oz", TorqueUnit.OunceForceInch)]
         [InlineData("pdl·ft", TorqueUnit.PoundalFoot)]
         [InlineData("lbf·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lb·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lbf-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lb-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("ft-lb", TorqueUnit.PoundForceFoot)]
         [InlineData("lbf·in", TorqueUnit.PoundForceInch)]
+        [InlineData("lb·in", TorqueUnit.PoundForceInch)]
+        [InlineData("lbf-in", TorqueUnit.PoundForceInch)]
+        [InlineData("lb-in", TorqueUnit.PoundForceInch)]
+        [InlineData("in-lb", TorqueUnit.PoundForceInch)]
         [InlineData("tf·cm", TorqueUnit.TonneForceCentimeter)]
         [InlineData("tf·m", TorqueUnit.TonneForceMeter)]
         [InlineData("tf·mm", TorqueUnit.TonneForceMillimeter)]
@@ -533,13 +702,38 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "MN·m", TorqueUnit.MeganewtonMeter)]
         [InlineData("en-US", "MN·mm", TorqueUnit.MeganewtonMillimeter)]
         [InlineData("en-US", "Mlbf·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlb·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlbf-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlb-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mft-lb", TorqueUnit.MegapoundForceFoot)]
         [InlineData("en-US", "Mlbf·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlb·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlbf-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlb-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Min-lb", TorqueUnit.MegapoundForceInch)]
         [InlineData("en-US", "N·cm", TorqueUnit.NewtonCentimeter)]
         [InlineData("en-US", "N·m", TorqueUnit.NewtonMeter)]
         [InlineData("en-US", "N·mm", TorqueUnit.NewtonMillimeter)]
+        [InlineData("en-US", "ozf·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "oz·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "ozf-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "oz-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "ozf·in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "oz·in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "ozf-in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "oz-in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "in-oz", TorqueUnit.OunceForceInch)]
         [InlineData("en-US", "pdl·ft", TorqueUnit.PoundalFoot)]
         [InlineData("en-US", "lbf·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lb·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lbf-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lb-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "ft-lb", TorqueUnit.PoundForceFoot)]
         [InlineData("en-US", "lbf·in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lb·in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lbf-in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lb-in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "in-lb", TorqueUnit.PoundForceInch)]
         [InlineData("en-US", "tf·cm", TorqueUnit.TonneForceCentimeter)]
         [InlineData("en-US", "tf·m", TorqueUnit.TonneForceMeter)]
         [InlineData("en-US", "tf·mm", TorqueUnit.TonneForceMillimeter)]
@@ -569,13 +763,38 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, To
         [InlineData("en-US", "MN·m", TorqueUnit.MeganewtonMeter)]
         [InlineData("en-US", "MN·mm", TorqueUnit.MeganewtonMillimeter)]
         [InlineData("en-US", "Mlbf·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlb·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlbf-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlb-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mft-lb", TorqueUnit.MegapoundForceFoot)]
         [InlineData("en-US", "Mlbf·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlb·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlbf-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlb-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Min-lb", TorqueUnit.MegapoundForceInch)]
         [InlineData("en-US", "N·cm", TorqueUnit.NewtonCentimeter)]
         [InlineData("en-US", "N·m", TorqueUnit.NewtonMeter)]
         [InlineData("en-US", "N·mm", TorqueUnit.NewtonMillimeter)]
+        [InlineData("en-US", "ozf·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "oz·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "ozf-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "oz-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "ozf·in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "oz·in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "ozf-in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "oz-in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "in-oz", TorqueUnit.OunceForceInch)]
         [InlineData("en-US", "pdl·ft", TorqueUnit.PoundalFoot)]
         [InlineData("en-US", "lbf·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lb·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lbf-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lb-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "ft-lb", TorqueUnit.PoundForceFoot)]
         [InlineData("en-US", "lbf·in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lb·in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lbf-in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lb-in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "in-lb", TorqueUnit.PoundForceInch)]
         [InlineData("en-US", "tf·cm", TorqueUnit.TonneForceCentimeter)]
         [InlineData("en-US", "tf·m", TorqueUnit.TonneForceMeter)]
         [InlineData("en-US", "tf·mm", TorqueUnit.TonneForceMillimeter)]
@@ -604,13 +823,38 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, TorqueUni
         [InlineData("MN·m", TorqueUnit.MeganewtonMeter)]
         [InlineData("MN·mm", TorqueUnit.MeganewtonMillimeter)]
         [InlineData("Mlbf·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlb·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlbf-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlb-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mft-lb", TorqueUnit.MegapoundForceFoot)]
         [InlineData("Mlbf·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlb·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlbf-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlb-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Min-lb", TorqueUnit.MegapoundForceInch)]
         [InlineData("N·cm", TorqueUnit.NewtonCentimeter)]
         [InlineData("N·m", TorqueUnit.NewtonMeter)]
         [InlineData("N·mm", TorqueUnit.NewtonMillimeter)]
+        [InlineData("ozf·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("oz·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("ozf-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("oz-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("ozf·in", TorqueUnit.OunceForceInch)]
+        [InlineData("oz·in", TorqueUnit.OunceForceInch)]
+        [InlineData("ozf-in", TorqueUnit.OunceForceInch)]
+        [InlineData("oz-in", TorqueUnit.OunceForceInch)]
+        [InlineData("in-oz", TorqueUnit.OunceForceInch)]
         [InlineData("pdl·ft", TorqueUnit.PoundalFoot)]
         [InlineData("lbf·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lb·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lbf-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lb-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("ft-lb", TorqueUnit.PoundForceFoot)]
         [InlineData("lbf·in", TorqueUnit.PoundForceInch)]
+        [InlineData("lb·in", TorqueUnit.PoundForceInch)]
+        [InlineData("lbf-in", TorqueUnit.PoundForceInch)]
+        [InlineData("lb-in", TorqueUnit.PoundForceInch)]
+        [InlineData("in-lb", TorqueUnit.PoundForceInch)]
         [InlineData("tf·cm", TorqueUnit.TonneForceCentimeter)]
         [InlineData("tf·m", TorqueUnit.TonneForceMeter)]
         [InlineData("tf·mm", TorqueUnit.TonneForceMillimeter)]
@@ -638,13 +882,38 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Torque
         [InlineData("MN·m", TorqueUnit.MeganewtonMeter)]
         [InlineData("MN·mm", TorqueUnit.MeganewtonMillimeter)]
         [InlineData("Mlbf·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlb·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlbf-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mlb-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("Mft-lb", TorqueUnit.MegapoundForceFoot)]
         [InlineData("Mlbf·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlb·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlbf-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Mlb-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("Min-lb", TorqueUnit.MegapoundForceInch)]
         [InlineData("N·cm", TorqueUnit.NewtonCentimeter)]
         [InlineData("N·m", TorqueUnit.NewtonMeter)]
         [InlineData("N·mm", TorqueUnit.NewtonMillimeter)]
+        [InlineData("ozf·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("oz·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("ozf-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("oz-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("ozf·in", TorqueUnit.OunceForceInch)]
+        [InlineData("oz·in", TorqueUnit.OunceForceInch)]
+        [InlineData("ozf-in", TorqueUnit.OunceForceInch)]
+        [InlineData("oz-in", TorqueUnit.OunceForceInch)]
+        [InlineData("in-oz", TorqueUnit.OunceForceInch)]
         [InlineData("pdl·ft", TorqueUnit.PoundalFoot)]
         [InlineData("lbf·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lb·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lbf-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("lb-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("ft-lb", TorqueUnit.PoundForceFoot)]
         [InlineData("lbf·in", TorqueUnit.PoundForceInch)]
+        [InlineData("lb·in", TorqueUnit.PoundForceInch)]
+        [InlineData("lbf-in", TorqueUnit.PoundForceInch)]
+        [InlineData("lb-in", TorqueUnit.PoundForceInch)]
+        [InlineData("in-lb", TorqueUnit.PoundForceInch)]
         [InlineData("tf·cm", TorqueUnit.TonneForceCentimeter)]
         [InlineData("tf·m", TorqueUnit.TonneForceMeter)]
         [InlineData("tf·mm", TorqueUnit.TonneForceMillimeter)]
@@ -672,13 +941,38 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "MN·m", TorqueUnit.MeganewtonMeter)]
         [InlineData("en-US", "MN·mm", TorqueUnit.MeganewtonMillimeter)]
         [InlineData("en-US", "Mlbf·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlb·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlbf-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlb-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mft-lb", TorqueUnit.MegapoundForceFoot)]
         [InlineData("en-US", "Mlbf·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlb·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlbf-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlb-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Min-lb", TorqueUnit.MegapoundForceInch)]
         [InlineData("en-US", "N·cm", TorqueUnit.NewtonCentimeter)]
         [InlineData("en-US", "N·m", TorqueUnit.NewtonMeter)]
         [InlineData("en-US", "N·mm", TorqueUnit.NewtonMillimeter)]
+        [InlineData("en-US", "ozf·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "oz·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "ozf-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "oz-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "ozf·in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "oz·in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "ozf-in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "oz-in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "in-oz", TorqueUnit.OunceForceInch)]
         [InlineData("en-US", "pdl·ft", TorqueUnit.PoundalFoot)]
         [InlineData("en-US", "lbf·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lb·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lbf-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lb-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "ft-lb", TorqueUnit.PoundForceFoot)]
         [InlineData("en-US", "lbf·in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lb·in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lbf-in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lb-in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "in-lb", TorqueUnit.PoundForceInch)]
         [InlineData("en-US", "tf·cm", TorqueUnit.TonneForceCentimeter)]
         [InlineData("en-US", "tf·m", TorqueUnit.TonneForceMeter)]
         [InlineData("en-US", "tf·mm", TorqueUnit.TonneForceMillimeter)]
@@ -708,13 +1002,38 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "MN·m", TorqueUnit.MeganewtonMeter)]
         [InlineData("en-US", "MN·mm", TorqueUnit.MeganewtonMillimeter)]
         [InlineData("en-US", "Mlbf·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlb·ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlbf-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mlb-ft", TorqueUnit.MegapoundForceFoot)]
+        [InlineData("en-US", "Mft-lb", TorqueUnit.MegapoundForceFoot)]
         [InlineData("en-US", "Mlbf·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlb·in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlbf-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Mlb-in", TorqueUnit.MegapoundForceInch)]
+        [InlineData("en-US", "Min-lb", TorqueUnit.MegapoundForceInch)]
         [InlineData("en-US", "N·cm", TorqueUnit.NewtonCentimeter)]
         [InlineData("en-US", "N·m", TorqueUnit.NewtonMeter)]
         [InlineData("en-US", "N·mm", TorqueUnit.NewtonMillimeter)]
+        [InlineData("en-US", "ozf·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "oz·ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "ozf-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "oz-ft", TorqueUnit.OunceForceFoot)]
+        [InlineData("en-US", "ozf·in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "oz·in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "ozf-in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "oz-in", TorqueUnit.OunceForceInch)]
+        [InlineData("en-US", "in-oz", TorqueUnit.OunceForceInch)]
         [InlineData("en-US", "pdl·ft", TorqueUnit.PoundalFoot)]
         [InlineData("en-US", "lbf·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lb·ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lbf-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "lb-ft", TorqueUnit.PoundForceFoot)]
+        [InlineData("en-US", "ft-lb", TorqueUnit.PoundForceFoot)]
         [InlineData("en-US", "lbf·in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lb·in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lbf-in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "lb-in", TorqueUnit.PoundForceInch)]
+        [InlineData("en-US", "in-lb", TorqueUnit.PoundForceInch)]
         [InlineData("en-US", "tf·cm", TorqueUnit.TonneForceCentimeter)]
         [InlineData("en-US", "tf·m", TorqueUnit.TonneForceMeter)]
         [InlineData("en-US", "tf·mm", TorqueUnit.TonneForceMillimeter)]
@@ -747,6 +1066,8 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Torque
         [InlineData("en-US", TorqueUnit.NewtonCentimeter, "N·cm")]
         [InlineData("en-US", TorqueUnit.NewtonMeter, "N·m")]
         [InlineData("en-US", TorqueUnit.NewtonMillimeter, "N·mm")]
+        [InlineData("en-US", TorqueUnit.OunceForceFoot, "ozf·ft")]
+        [InlineData("en-US", TorqueUnit.OunceForceInch, "ozf·in")]
         [InlineData("en-US", TorqueUnit.PoundalFoot, "pdl·ft")]
         [InlineData("en-US", TorqueUnit.PoundForceFoot, "lbf·ft")]
         [InlineData("en-US", TorqueUnit.PoundForceInch, "lbf·in")]
@@ -805,6 +1126,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(TorqueUnit unit)
                 var quantity = Torque.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -828,56 +1150,60 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(TorqueUnit unit)
                 IQuantity<TorqueUnit> quantityToConvert = quantity;
                 IQuantity<TorqueUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Torque newtonmeter = Torque.FromNewtonMeters(1);
-            AssertEx.EqualTolerance(1, Torque.FromGramForceCentimeters(newtonmeter.GramForceCentimeters).NewtonMeters, GramForceCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromGramForceMeters(newtonmeter.GramForceMeters).NewtonMeters, GramForceMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromGramForceMillimeters(newtonmeter.GramForceMillimeters).NewtonMeters, GramForceMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilogramForceCentimeters(newtonmeter.KilogramForceCentimeters).NewtonMeters, KilogramForceCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilogramForceMeters(newtonmeter.KilogramForceMeters).NewtonMeters, KilogramForceMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilogramForceMillimeters(newtonmeter.KilogramForceMillimeters).NewtonMeters, KilogramForceMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilonewtonCentimeters(newtonmeter.KilonewtonCentimeters).NewtonMeters, KilonewtonCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilonewtonMeters(newtonmeter.KilonewtonMeters).NewtonMeters, KilonewtonMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilonewtonMillimeters(newtonmeter.KilonewtonMillimeters).NewtonMeters, KilonewtonMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilopoundForceFeet(newtonmeter.KilopoundForceFeet).NewtonMeters, KilopoundForceFeetTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromKilopoundForceInches(newtonmeter.KilopoundForceInches).NewtonMeters, KilopoundForceInchesTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromMeganewtonCentimeters(newtonmeter.MeganewtonCentimeters).NewtonMeters, MeganewtonCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromMeganewtonMeters(newtonmeter.MeganewtonMeters).NewtonMeters, MeganewtonMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromMeganewtonMillimeters(newtonmeter.MeganewtonMillimeters).NewtonMeters, MeganewtonMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromMegapoundForceFeet(newtonmeter.MegapoundForceFeet).NewtonMeters, MegapoundForceFeetTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromMegapoundForceInches(newtonmeter.MegapoundForceInches).NewtonMeters, MegapoundForceInchesTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromNewtonCentimeters(newtonmeter.NewtonCentimeters).NewtonMeters, NewtonCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromNewtonMeters(newtonmeter.NewtonMeters).NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromNewtonMillimeters(newtonmeter.NewtonMillimeters).NewtonMeters, NewtonMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromPoundalFeet(newtonmeter.PoundalFeet).NewtonMeters, PoundalFeetTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromPoundForceFeet(newtonmeter.PoundForceFeet).NewtonMeters, PoundForceFeetTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromPoundForceInches(newtonmeter.PoundForceInches).NewtonMeters, PoundForceInchesTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromTonneForceCentimeters(newtonmeter.TonneForceCentimeters).NewtonMeters, TonneForceCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromTonneForceMeters(newtonmeter.TonneForceMeters).NewtonMeters, TonneForceMetersTolerance);
-            AssertEx.EqualTolerance(1, Torque.FromTonneForceMillimeters(newtonmeter.TonneForceMillimeters).NewtonMeters, TonneForceMillimetersTolerance);
+            Torque newtonmeter = Torque.FromNewtonMeters(3);
+            Assert.Equal(3, Torque.FromGramForceCentimeters(newtonmeter.GramForceCentimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromGramForceMeters(newtonmeter.GramForceMeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromGramForceMillimeters(newtonmeter.GramForceMillimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromKilogramForceCentimeters(newtonmeter.KilogramForceCentimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromKilogramForceMeters(newtonmeter.KilogramForceMeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromKilogramForceMillimeters(newtonmeter.KilogramForceMillimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromKilonewtonCentimeters(newtonmeter.KilonewtonCentimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromKilonewtonMeters(newtonmeter.KilonewtonMeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromKilonewtonMillimeters(newtonmeter.KilonewtonMillimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromKilopoundForceFeet(newtonmeter.KilopoundForceFeet).NewtonMeters);
+            Assert.Equal(3, Torque.FromKilopoundForceInches(newtonmeter.KilopoundForceInches).NewtonMeters);
+            Assert.Equal(3, Torque.FromMeganewtonCentimeters(newtonmeter.MeganewtonCentimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromMeganewtonMeters(newtonmeter.MeganewtonMeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromMeganewtonMillimeters(newtonmeter.MeganewtonMillimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromMegapoundForceFeet(newtonmeter.MegapoundForceFeet).NewtonMeters);
+            Assert.Equal(3, Torque.FromMegapoundForceInches(newtonmeter.MegapoundForceInches).NewtonMeters);
+            Assert.Equal(3, Torque.FromNewtonCentimeters(newtonmeter.NewtonCentimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromNewtonMeters(newtonmeter.NewtonMeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromNewtonMillimeters(newtonmeter.NewtonMillimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromOunceForceFeet(newtonmeter.OunceForceFeet).NewtonMeters);
+            Assert.Equal(3, Torque.FromOunceForceInches(newtonmeter.OunceForceInches).NewtonMeters);
+            Assert.Equal(3, Torque.FromPoundalFeet(newtonmeter.PoundalFeet).NewtonMeters);
+            Assert.Equal(3, Torque.FromPoundForceFeet(newtonmeter.PoundForceFeet).NewtonMeters);
+            Assert.Equal(3, Torque.FromPoundForceInches(newtonmeter.PoundForceInches).NewtonMeters);
+            Assert.Equal(3, Torque.FromTonneForceCentimeters(newtonmeter.TonneForceCentimeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromTonneForceMeters(newtonmeter.TonneForceMeters).NewtonMeters);
+            Assert.Equal(3, Torque.FromTonneForceMillimeters(newtonmeter.TonneForceMillimeters).NewtonMeters);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Torque v = Torque.FromNewtonMeters(1);
-            AssertEx.EqualTolerance(-1, -v.NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(2, (Torque.FromNewtonMeters(3)-v).NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(2, (Torque.FromNewtonMeters(10)/5).NewtonMeters, NewtonMetersTolerance);
-            AssertEx.EqualTolerance(2, Torque.FromNewtonMeters(10)/Torque.FromNewtonMeters(5), NewtonMetersTolerance);
+            Assert.Equal(-1, -v.NewtonMeters);
+            Assert.Equal(2, (Torque.FromNewtonMeters(3) - v).NewtonMeters);
+            Assert.Equal(2, (v + v).NewtonMeters);
+            Assert.Equal(10, (v * 10).NewtonMeters);
+            Assert.Equal(10, (10 * v).NewtonMeters);
+            Assert.Equal(2, (Torque.FromNewtonMeters(10) / 5).NewtonMeters);
+            Assert.Equal(2, Torque.FromNewtonMeters(10) / Torque.FromNewtonMeters(5));
         }
 
         [Fact]
@@ -923,8 +1249,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, TorqueUnit.NewtonMeter, 1, TorqueUnit.NewtonMeter, true)]  // Same value and unit.
         [InlineData(1, TorqueUnit.NewtonMeter, 2, TorqueUnit.NewtonMeter, false)] // Different value.
-        [InlineData(2, TorqueUnit.NewtonMeter, 1, TorqueUnit.GramForceCentimeter, false)] // Different value and unit.
-        [InlineData(1, TorqueUnit.NewtonMeter, 1, TorqueUnit.GramForceCentimeter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, TorqueUnit unitA, double valueB, TorqueUnit unitB, bool expectEqual)
         {
             var a = new Torque(valueA, unitA);
@@ -984,8 +1308,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Torque.FromNewtonMeters(firstValue);
             var otherQuantity = Torque.FromNewtonMeters(secondValue);
             Torque maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Torque.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1004,7 +1328,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<TorqueUnit>();
+            var units = EnumHelper.GetValues<TorqueUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1017,6 +1341,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Torque.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Torque.Info.Units, Torque.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Torque.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -1040,6 +1376,8 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
             Assert.Equal("1 N·cm", new Torque(1, TorqueUnit.NewtonCentimeter).ToString());
             Assert.Equal("1 N·m", new Torque(1, TorqueUnit.NewtonMeter).ToString());
             Assert.Equal("1 N·mm", new Torque(1, TorqueUnit.NewtonMillimeter).ToString());
+            Assert.Equal("1 ozf·ft", new Torque(1, TorqueUnit.OunceForceFoot).ToString());
+            Assert.Equal("1 ozf·in", new Torque(1, TorqueUnit.OunceForceInch).ToString());
             Assert.Equal("1 pdl·ft", new Torque(1, TorqueUnit.PoundalFoot).ToString());
             Assert.Equal("1 lbf·ft", new Torque(1, TorqueUnit.PoundForceFoot).ToString());
             Assert.Equal("1 lbf·in", new Torque(1, TorqueUnit.PoundForceInch).ToString());
@@ -1073,6 +1411,8 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 N·cm", new Torque(1, TorqueUnit.NewtonCentimeter).ToString(swedishCulture));
             Assert.Equal("1 N·m", new Torque(1, TorqueUnit.NewtonMeter).ToString(swedishCulture));
             Assert.Equal("1 N·mm", new Torque(1, TorqueUnit.NewtonMillimeter).ToString(swedishCulture));
+            Assert.Equal("1 ozf·ft", new Torque(1, TorqueUnit.OunceForceFoot).ToString(swedishCulture));
+            Assert.Equal("1 ozf·in", new Torque(1, TorqueUnit.OunceForceInch).ToString(swedishCulture));
             Assert.Equal("1 pdl·ft", new Torque(1, TorqueUnit.PoundalFoot).ToString(swedishCulture));
             Assert.Equal("1 lbf·ft", new Torque(1, TorqueUnit.PoundForceFoot).ToString(swedishCulture));
             Assert.Equal("1 lbf·in", new Torque(1, TorqueUnit.PoundForceInch).ToString(swedishCulture));
@@ -1081,26 +1421,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 tf·mm", new Torque(1, TorqueUnit.TonneForceMillimeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 N·m", new Torque(0.123456, TorqueUnit.NewtonMeter).ToString("s1"));
-            Assert.Equal("0.12 N·m", new Torque(0.123456, TorqueUnit.NewtonMeter).ToString("s2"));
-            Assert.Equal("0.123 N·m", new Torque(0.123456, TorqueUnit.NewtonMeter).ToString("s3"));
-            Assert.Equal("0.1235 N·m", new Torque(0.123456, TorqueUnit.NewtonMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 N·m", new Torque(0.123456, TorqueUnit.NewtonMeter).ToString("s1", culture));
-            Assert.Equal("0.12 N·m", new Torque(0.123456, TorqueUnit.NewtonMeter).ToString("s2", culture));
-            Assert.Equal("0.123 N·m", new Torque(0.123456, TorqueUnit.NewtonMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 N·m", new Torque(0.123456, TorqueUnit.NewtonMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -1127,7 +1447,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Torque.FromNewtonMeters(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Torque), quantity.As(Torque.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TurbidityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TurbidityTestsBase.g.cs
index 638583c83e..ca2d3e770d 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TurbidityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TurbidityTestsBase.g.cs
@@ -104,6 +104,20 @@ public void Turbidity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<TurbidityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void TurbidityInfo_CreateWithCustomUnitInfos()
+        {
+            TurbidityUnit[] expectedUnits = [TurbidityUnit.NTU];
+
+            Turbidity.TurbidityInfo quantityInfo = Turbidity.TurbidityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Turbidity", quantityInfo.Name);
+            Assert.Equal(Turbidity.Zero, quantityInfo.Zero);
+            Assert.Equal(Turbidity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void NTUToTurbidityUnits()
         {
@@ -168,12 +182,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new Turbidity(value: 1, unit: TurbidityUnit.NTU);
+            Assert.Multiple(() =>
+            {
+                var quantity = new Turbidity(value: 1, unit: TurbidityUnit.NTU);
+
+                Turbidity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(TurbidityUnit.NTU, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<TurbidityUnit> quantity = new Turbidity(value: 1, unit: TurbidityUnit.NTU);
+
+                IQuantity<TurbidityUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(TurbidityUnit.NTU, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new Turbidity(value: 1, unit: TurbidityUnit.NTU);
 
-            Turbidity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(TurbidityUnit.NTU, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(TurbidityUnit.NTU, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -197,7 +230,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
 
         [Theory]
         [InlineData("en-US", "4.2 NTU", TurbidityUnit.NTU, 4.2)]
-        public void Parse(string culture, string quantityString, TurbidityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, TurbidityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Turbidity.Parse(quantityString);
@@ -207,7 +240,7 @@ public void Parse(string culture, string quantityString, TurbidityUnit expectedU
 
         [Theory]
         [InlineData("en-US", "4.2 NTU", TurbidityUnit.NTU, 4.2)]
-        public void TryParse(string culture, string quantityString, TurbidityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, TurbidityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Turbidity.TryParse(quantityString, out Turbidity parsed));
@@ -340,6 +373,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(TurbidityUnit un
                 var quantity = Turbidity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -363,32 +397,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(TurbidityUnit unit)
                 IQuantity<TurbidityUnit> quantityToConvert = quantity;
                 IQuantity<TurbidityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Turbidity ntu = Turbidity.FromNTU(1);
-            AssertEx.EqualTolerance(1, Turbidity.FromNTU(ntu.NTU).NTU, NTUTolerance);
+            Turbidity ntu = Turbidity.FromNTU(3);
+            Assert.Equal(3, Turbidity.FromNTU(ntu.NTU).NTU);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Turbidity v = Turbidity.FromNTU(1);
-            AssertEx.EqualTolerance(-1, -v.NTU, NTUTolerance);
-            AssertEx.EqualTolerance(2, (Turbidity.FromNTU(3)-v).NTU, NTUTolerance);
-            AssertEx.EqualTolerance(2, (v + v).NTU, NTUTolerance);
-            AssertEx.EqualTolerance(10, (v*10).NTU, NTUTolerance);
-            AssertEx.EqualTolerance(10, (10*v).NTU, NTUTolerance);
-            AssertEx.EqualTolerance(2, (Turbidity.FromNTU(10)/5).NTU, NTUTolerance);
-            AssertEx.EqualTolerance(2, Turbidity.FromNTU(10)/Turbidity.FromNTU(5), NTUTolerance);
+            Assert.Equal(-1, -v.NTU);
+            Assert.Equal(2, (Turbidity.FromNTU(3) - v).NTU);
+            Assert.Equal(2, (v + v).NTU);
+            Assert.Equal(10, (v * 10).NTU);
+            Assert.Equal(10, (10 * v).NTU);
+            Assert.Equal(2, (Turbidity.FromNTU(10) / 5).NTU);
+            Assert.Equal(2, Turbidity.FromNTU(10) / Turbidity.FromNTU(5));
         }
 
         [Fact]
@@ -434,7 +470,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, TurbidityUnit.NTU, 1, TurbidityUnit.NTU, true)]  // Same value and unit.
         [InlineData(1, TurbidityUnit.NTU, 2, TurbidityUnit.NTU, false)] // Different value.
-        [InlineData(2, TurbidityUnit.NTU, 1, TurbidityUnit.NTU, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, TurbidityUnit unitA, double valueB, TurbidityUnit unitB, bool expectEqual)
         {
             var a = new Turbidity(valueA, unitA);
@@ -494,8 +529,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Turbidity.FromNTU(firstValue);
             var otherQuantity = Turbidity.FromNTU(secondValue);
             Turbidity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Turbidity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -514,7 +549,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<TurbidityUnit>();
+            var units = EnumHelper.GetValues<TurbidityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -528,39 +563,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 NTU", new Turbidity(1, TurbidityUnit.NTU).ToString());
+            Assert.Equal(Turbidity.Info.Units, Turbidity.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 NTU", new Turbidity(1, TurbidityUnit.NTU).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, Turbidity.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 NTU", new Turbidity(0.123456, TurbidityUnit.NTU).ToString("s1"));
-            Assert.Equal("0.12 NTU", new Turbidity(0.123456, TurbidityUnit.NTU).ToString("s2"));
-            Assert.Equal("0.123 NTU", new Turbidity(0.123456, TurbidityUnit.NTU).ToString("s3"));
-            Assert.Equal("0.1235 NTU", new Turbidity(0.123456, TurbidityUnit.NTU).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 NTU", new Turbidity(1, TurbidityUnit.NTU).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 NTU", new Turbidity(0.123456, TurbidityUnit.NTU).ToString("s1", culture));
-            Assert.Equal("0.12 NTU", new Turbidity(0.123456, TurbidityUnit.NTU).ToString("s2", culture));
-            Assert.Equal("0.123 NTU", new Turbidity(0.123456, TurbidityUnit.NTU).ToString("s3", culture));
-            Assert.Equal("0.1235 NTU", new Turbidity(0.123456, TurbidityUnit.NTU).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 NTU", new Turbidity(1, TurbidityUnit.NTU).ToString(swedishCulture));
         }
 
         [Theory]
@@ -589,7 +616,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Turbidity.FromNTU(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Turbidity), quantity.As(Turbidity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VitaminATestsBase.g.cs
index 5bad1cea21..98f344feaf 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VitaminATestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VitaminATestsBase.g.cs
@@ -104,6 +104,20 @@ public void VitaminA_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<VitaminAUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void VitaminAInfo_CreateWithCustomUnitInfos()
+        {
+            VitaminAUnit[] expectedUnits = [VitaminAUnit.InternationalUnit];
+
+            VitaminA.VitaminAInfo quantityInfo = VitaminA.VitaminAInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("VitaminA", quantityInfo.Name);
+            Assert.Equal(VitaminA.Zero, quantityInfo.Zero);
+            Assert.Equal(VitaminA.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void InternationalUnitToVitaminAUnits()
         {
@@ -168,12 +182,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new VitaminA(value: 1, unit: VitaminAUnit.InternationalUnit);
+            Assert.Multiple(() =>
+            {
+                var quantity = new VitaminA(value: 1, unit: VitaminAUnit.InternationalUnit);
+
+                VitaminA convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(VitaminAUnit.InternationalUnit, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<VitaminAUnit> quantity = new VitaminA(value: 1, unit: VitaminAUnit.InternationalUnit);
+
+                IQuantity<VitaminAUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(VitaminAUnit.InternationalUnit, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new VitaminA(value: 1, unit: VitaminAUnit.InternationalUnit);
 
-            VitaminA convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(VitaminAUnit.InternationalUnit, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(VitaminAUnit.InternationalUnit, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -197,7 +230,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
 
         [Theory]
         [InlineData("en-US", "4.2 IU", VitaminAUnit.InternationalUnit, 4.2)]
-        public void Parse(string culture, string quantityString, VitaminAUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, VitaminAUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = VitaminA.Parse(quantityString);
@@ -207,7 +240,7 @@ public void Parse(string culture, string quantityString, VitaminAUnit expectedUn
 
         [Theory]
         [InlineData("en-US", "4.2 IU", VitaminAUnit.InternationalUnit, 4.2)]
-        public void TryParse(string culture, string quantityString, VitaminAUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, VitaminAUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(VitaminA.TryParse(quantityString, out VitaminA parsed));
@@ -340,6 +373,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(VitaminAUnit uni
                 var quantity = VitaminA.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -363,32 +397,34 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(VitaminAUnit unit)
                 IQuantity<VitaminAUnit> quantityToConvert = quantity;
                 IQuantity<VitaminAUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            VitaminA internationalunit = VitaminA.FromInternationalUnits(1);
-            AssertEx.EqualTolerance(1, VitaminA.FromInternationalUnits(internationalunit.InternationalUnits).InternationalUnits, InternationalUnitsTolerance);
+            VitaminA internationalunit = VitaminA.FromInternationalUnits(3);
+            Assert.Equal(3, VitaminA.FromInternationalUnits(internationalunit.InternationalUnits).InternationalUnits);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             VitaminA v = VitaminA.FromInternationalUnits(1);
-            AssertEx.EqualTolerance(-1, -v.InternationalUnits, InternationalUnitsTolerance);
-            AssertEx.EqualTolerance(2, (VitaminA.FromInternationalUnits(3)-v).InternationalUnits, InternationalUnitsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).InternationalUnits, InternationalUnitsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).InternationalUnits, InternationalUnitsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).InternationalUnits, InternationalUnitsTolerance);
-            AssertEx.EqualTolerance(2, (VitaminA.FromInternationalUnits(10)/5).InternationalUnits, InternationalUnitsTolerance);
-            AssertEx.EqualTolerance(2, VitaminA.FromInternationalUnits(10)/VitaminA.FromInternationalUnits(5), InternationalUnitsTolerance);
+            Assert.Equal(-1, -v.InternationalUnits);
+            Assert.Equal(2, (VitaminA.FromInternationalUnits(3) - v).InternationalUnits);
+            Assert.Equal(2, (v + v).InternationalUnits);
+            Assert.Equal(10, (v * 10).InternationalUnits);
+            Assert.Equal(10, (10 * v).InternationalUnits);
+            Assert.Equal(2, (VitaminA.FromInternationalUnits(10) / 5).InternationalUnits);
+            Assert.Equal(2, VitaminA.FromInternationalUnits(10) / VitaminA.FromInternationalUnits(5));
         }
 
         [Fact]
@@ -434,7 +470,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, VitaminAUnit.InternationalUnit, 1, VitaminAUnit.InternationalUnit, true)]  // Same value and unit.
         [InlineData(1, VitaminAUnit.InternationalUnit, 2, VitaminAUnit.InternationalUnit, false)] // Different value.
-        [InlineData(2, VitaminAUnit.InternationalUnit, 1, VitaminAUnit.InternationalUnit, false)] // Different value and unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, VitaminAUnit unitA, double valueB, VitaminAUnit unitB, bool expectEqual)
         {
             var a = new VitaminA(valueA, unitA);
@@ -494,8 +529,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = VitaminA.FromInternationalUnits(firstValue);
             var otherQuantity = VitaminA.FromInternationalUnits(secondValue);
             VitaminA maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, VitaminA.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -514,7 +549,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<VitaminAUnit>();
+            var units = EnumHelper.GetValues<VitaminAUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -528,39 +563,31 @@ public void BaseDimensionsShouldNeverBeNull()
         }
 
         [Fact]
-        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
+        public void Units_ReturnsTheQuantityInfoUnits()
         {
-            using var _ = new CultureScope("en-US");
-            Assert.Equal("1 IU", new VitaminA(1, VitaminAUnit.InternationalUnit).ToString());
+            Assert.Equal(VitaminA.Info.Units, VitaminA.Units);
         }
 
         [Fact]
-        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
         {
-            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
-            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
-
-            Assert.Equal("1 IU", new VitaminA(1, VitaminAUnit.InternationalUnit).ToString(swedishCulture));
+            Assert.Equal(UnitConverter.Default, VitaminA.DefaultConversionFunctions);
         }
 
         [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
+        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 IU", new VitaminA(0.123456, VitaminAUnit.InternationalUnit).ToString("s1"));
-            Assert.Equal("0.12 IU", new VitaminA(0.123456, VitaminAUnit.InternationalUnit).ToString("s2"));
-            Assert.Equal("0.123 IU", new VitaminA(0.123456, VitaminAUnit.InternationalUnit).ToString("s3"));
-            Assert.Equal("0.1235 IU", new VitaminA(0.123456, VitaminAUnit.InternationalUnit).ToString("s4"));
+            using var _ = new CultureScope("en-US");
+            Assert.Equal("1 IU", new VitaminA(1, VitaminAUnit.InternationalUnit).ToString());
         }
 
         [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
+        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
         {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 IU", new VitaminA(0.123456, VitaminAUnit.InternationalUnit).ToString("s1", culture));
-            Assert.Equal("0.12 IU", new VitaminA(0.123456, VitaminAUnit.InternationalUnit).ToString("s2", culture));
-            Assert.Equal("0.123 IU", new VitaminA(0.123456, VitaminAUnit.InternationalUnit).ToString("s3", culture));
-            Assert.Equal("0.1235 IU", new VitaminA(0.123456, VitaminAUnit.InternationalUnit).ToString("s4", culture));
+            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
+            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
+
+            Assert.Equal("1 IU", new VitaminA(1, VitaminAUnit.InternationalUnit).ToString(swedishCulture));
         }
 
         [Theory]
@@ -589,7 +616,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = VitaminA.FromInternationalUnits(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(VitaminA), quantity.As(VitaminA.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs
index fb80a74bc2..8ba6b6387a 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs
@@ -180,6 +180,20 @@ public void VolumeConcentration_QuantityInfo_ReturnsQuantityInfoDescribingQuanti
             Assert.Equal(quantityInfo, ((IQuantity<VolumeConcentrationUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void VolumeConcentrationInfo_CreateWithCustomUnitInfos()
+        {
+            VolumeConcentrationUnit[] expectedUnits = [VolumeConcentrationUnit.DecimalFraction];
+
+            VolumeConcentration.VolumeConcentrationInfo quantityInfo = VolumeConcentration.VolumeConcentrationInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("VolumeConcentration", quantityInfo.Name);
+            Assert.Equal(VolumeConcentration.Zero, quantityInfo.Zero);
+            Assert.Equal(VolumeConcentration.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void DecimalFractionToVolumeConcentrationUnits()
         {
@@ -282,12 +296,31 @@ public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [Fact]
         public void ToUnit_UnitSystem_ReturnsValueInDimensionlessUnit()
         {
-            var quantity = new VolumeConcentration(value: 1, unit: VolumeConcentrationUnit.DecimalFraction);
+            Assert.Multiple(() =>
+            {
+                var quantity = new VolumeConcentration(value: 1, unit: VolumeConcentrationUnit.DecimalFraction);
+
+                VolumeConcentration convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(VolumeConcentrationUnit.DecimalFraction, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<VolumeConcentrationUnit> quantity = new VolumeConcentration(value: 1, unit: VolumeConcentrationUnit.DecimalFraction);
+
+                IQuantity<VolumeConcentrationUnit> convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(VolumeConcentrationUnit.DecimalFraction, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantity = new VolumeConcentration(value: 1, unit: VolumeConcentrationUnit.DecimalFraction);
 
-            VolumeConcentration convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+                IQuantity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(VolumeConcentrationUnit.DecimalFraction, convertedQuantity.Unit);
-            Assert.Equal(quantity.Value, convertedQuantity.Value);
+                Assert.Equal(VolumeConcentrationUnit.DecimalFraction, convertedQuantity.Unit);
+                Assert.Equal(quantity.Value, convertedQuantity.Value);
+            });
         }
 
         [Fact]
@@ -331,7 +364,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         [InlineData("en-US", "4.2 % (v/v)", VolumeConcentrationUnit.Percent, 4.2)]
         [InlineData("en-US", "4.2 pl/l", VolumeConcentrationUnit.PicoliterPerLiter, 4.2)]
         [InlineData("en-US", "4.2 pl/ml", VolumeConcentrationUnit.PicoliterPerMilliliter, 4.2)]
-        public void Parse(string culture, string quantityString, VolumeConcentrationUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, VolumeConcentrationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = VolumeConcentration.Parse(quantityString);
@@ -361,7 +394,7 @@ public void Parse(string culture, string quantityString, VolumeConcentrationUnit
         [InlineData("en-US", "4.2 % (v/v)", VolumeConcentrationUnit.Percent, 4.2)]
         [InlineData("en-US", "4.2 pl/l", VolumeConcentrationUnit.PicoliterPerLiter, 4.2)]
         [InlineData("en-US", "4.2 pl/ml", VolumeConcentrationUnit.PicoliterPerMilliliter, 4.2)]
-        public void TryParse(string culture, string quantityString, VolumeConcentrationUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, VolumeConcentrationUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(VolumeConcentration.TryParse(quantityString, out VolumeConcentration parsed));
@@ -673,6 +706,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(VolumeConcentrat
                 var quantity = VolumeConcentration.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -696,51 +730,53 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(VolumeConcentration
                 IQuantity<VolumeConcentrationUnit> quantityToConvert = quantity;
                 IQuantity<VolumeConcentrationUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromCentilitersPerLiter(decimalfraction.CentilitersPerLiter).DecimalFractions, CentilitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromCentilitersPerMilliliter(decimalfraction.CentilitersPerMilliliter).DecimalFractions, CentilitersPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromDecilitersPerLiter(decimalfraction.DecilitersPerLiter).DecimalFractions, DecilitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromDecilitersPerMilliliter(decimalfraction.DecilitersPerMilliliter).DecimalFractions, DecilitersPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromLitersPerLiter(decimalfraction.LitersPerLiter).DecimalFractions, LitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromLitersPerMilliliter(decimalfraction.LitersPerMilliliter).DecimalFractions, LitersPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromMicrolitersPerLiter(decimalfraction.MicrolitersPerLiter).DecimalFractions, MicrolitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromMicrolitersPerMilliliter(decimalfraction.MicrolitersPerMilliliter).DecimalFractions, MicrolitersPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromMillilitersPerLiter(decimalfraction.MillilitersPerLiter).DecimalFractions, MillilitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromMillilitersPerMilliliter(decimalfraction.MillilitersPerMilliliter).DecimalFractions, MillilitersPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromNanolitersPerLiter(decimalfraction.NanolitersPerLiter).DecimalFractions, NanolitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromNanolitersPerMilliliter(decimalfraction.NanolitersPerMilliliter).DecimalFractions, NanolitersPerMilliliterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPicolitersPerLiter(decimalfraction.PicolitersPerLiter).DecimalFractions, PicolitersPerLiterTolerance);
-            AssertEx.EqualTolerance(1, VolumeConcentration.FromPicolitersPerMilliliter(decimalfraction.PicolitersPerMilliliter).DecimalFractions, PicolitersPerMilliliterTolerance);
+            VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(3);
+            Assert.Equal(3, VolumeConcentration.FromCentilitersPerLiter(decimalfraction.CentilitersPerLiter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromCentilitersPerMilliliter(decimalfraction.CentilitersPerMilliliter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromDecilitersPerLiter(decimalfraction.DecilitersPerLiter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromDecilitersPerMilliliter(decimalfraction.DecilitersPerMilliliter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromLitersPerLiter(decimalfraction.LitersPerLiter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromLitersPerMilliliter(decimalfraction.LitersPerMilliliter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromMicrolitersPerLiter(decimalfraction.MicrolitersPerLiter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromMicrolitersPerMilliliter(decimalfraction.MicrolitersPerMilliliter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromMillilitersPerLiter(decimalfraction.MillilitersPerLiter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromMillilitersPerMilliliter(decimalfraction.MillilitersPerMilliliter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromNanolitersPerLiter(decimalfraction.NanolitersPerLiter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromNanolitersPerMilliliter(decimalfraction.NanolitersPerMilliliter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromPercent(decimalfraction.Percent).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromPicolitersPerLiter(decimalfraction.PicolitersPerLiter).DecimalFractions);
+            Assert.Equal(3, VolumeConcentration.FromPicolitersPerMilliliter(decimalfraction.PicolitersPerMilliliter).DecimalFractions);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             VolumeConcentration v = VolumeConcentration.FromDecimalFractions(1);
-            AssertEx.EqualTolerance(-1, -v.DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (VolumeConcentration.FromDecimalFractions(3)-v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (v + v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(10, (v*10).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(10, (10*v).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, (VolumeConcentration.FromDecimalFractions(10)/5).DecimalFractions, DecimalFractionsTolerance);
-            AssertEx.EqualTolerance(2, VolumeConcentration.FromDecimalFractions(10)/VolumeConcentration.FromDecimalFractions(5), DecimalFractionsTolerance);
+            Assert.Equal(-1, -v.DecimalFractions);
+            Assert.Equal(2, (VolumeConcentration.FromDecimalFractions(3) - v).DecimalFractions);
+            Assert.Equal(2, (v + v).DecimalFractions);
+            Assert.Equal(10, (v * 10).DecimalFractions);
+            Assert.Equal(10, (10 * v).DecimalFractions);
+            Assert.Equal(2, (VolumeConcentration.FromDecimalFractions(10) / 5).DecimalFractions);
+            Assert.Equal(2, VolumeConcentration.FromDecimalFractions(10) / VolumeConcentration.FromDecimalFractions(5));
         }
 
         [Fact]
@@ -786,8 +822,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, VolumeConcentrationUnit.DecimalFraction, 1, VolumeConcentrationUnit.DecimalFraction, true)]  // Same value and unit.
         [InlineData(1, VolumeConcentrationUnit.DecimalFraction, 2, VolumeConcentrationUnit.DecimalFraction, false)] // Different value.
-        [InlineData(2, VolumeConcentrationUnit.DecimalFraction, 1, VolumeConcentrationUnit.CentiliterPerLiter, false)] // Different value and unit.
-        [InlineData(1, VolumeConcentrationUnit.DecimalFraction, 1, VolumeConcentrationUnit.CentiliterPerLiter, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, VolumeConcentrationUnit unitA, double valueB, VolumeConcentrationUnit unitB, bool expectEqual)
         {
             var a = new VolumeConcentration(valueA, unitA);
@@ -847,8 +881,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = VolumeConcentration.FromDecimalFractions(firstValue);
             var otherQuantity = VolumeConcentration.FromDecimalFractions(secondValue);
             VolumeConcentration maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, VolumeConcentration.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -867,7 +901,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<VolumeConcentrationUnit>();
+            var units = EnumHelper.GetValues<VolumeConcentrationUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -880,6 +914,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(VolumeConcentration.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(VolumeConcentration.Info.Units, VolumeConcentration.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, VolumeConcentration.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -934,26 +980,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 pl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.PicoliterPerMilliliter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1", new VolumeConcentration(0.123456, VolumeConcentrationUnit.DecimalFraction).ToString("s1"));
-            Assert.Equal("0.12", new VolumeConcentration(0.123456, VolumeConcentrationUnit.DecimalFraction).ToString("s2"));
-            Assert.Equal("0.123", new VolumeConcentration(0.123456, VolumeConcentrationUnit.DecimalFraction).ToString("s3"));
-            Assert.Equal("0.1235", new VolumeConcentration(0.123456, VolumeConcentrationUnit.DecimalFraction).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1", new VolumeConcentration(0.123456, VolumeConcentrationUnit.DecimalFraction).ToString("s1", culture));
-            Assert.Equal("0.12", new VolumeConcentration(0.123456, VolumeConcentrationUnit.DecimalFraction).ToString("s2", culture));
-            Assert.Equal("0.123", new VolumeConcentration(0.123456, VolumeConcentrationUnit.DecimalFraction).ToString("s3", culture));
-            Assert.Equal("0.1235", new VolumeConcentration(0.123456, VolumeConcentrationUnit.DecimalFraction).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -980,7 +1006,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = VolumeConcentration.FromDecimalFractions(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(VolumeConcentration), quantity.As(VolumeConcentration.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowPerAreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowPerAreaTestsBase.g.cs
index c641a62702..14984d9106 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowPerAreaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowPerAreaTestsBase.g.cs
@@ -129,6 +129,20 @@ public void VolumeFlowPerArea_QuantityInfo_ReturnsQuantityInfoDescribingQuantity
             Assert.Equal(quantityInfo, ((IQuantity<VolumeFlowPerAreaUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void VolumeFlowPerAreaInfo_CreateWithCustomUnitInfos()
+        {
+            VolumeFlowPerAreaUnit[] expectedUnits = [VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter];
+
+            VolumeFlowPerArea.VolumeFlowPerAreaInfo quantityInfo = VolumeFlowPerArea.VolumeFlowPerAreaInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("VolumeFlowPerArea", quantityInfo.Name);
+            Assert.Equal(VolumeFlowPerArea.Zero, quantityInfo.Zero);
+            Assert.Equal(VolumeFlowPerArea.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CubicMeterPerSecondPerSquareMeterToVolumeFlowPerAreaUnits()
         {
@@ -215,32 +229,75 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = VolumeFlowPerArea.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            VolumeFlowPerArea convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                VolumeFlowPerArea quantityToConvert = quantity;
+
+                VolumeFlowPerArea convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<VolumeFlowPerAreaUnit> quantityToConvert = quantity;
+
+                IQuantity<VolumeFlowPerAreaUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new VolumeFlowPerArea(value: 1, unit: VolumeFlowPerArea.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new VolumeFlowPerArea(value: 1, unit: VolumeFlowPerArea.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<VolumeFlowPerAreaUnit> quantity = new VolumeFlowPerArea(value: 1, unit: VolumeFlowPerArea.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new VolumeFlowPerArea(value: 1, unit: VolumeFlowPerArea.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new VolumeFlowPerArea(value: 1, unit: VolumeFlowPerArea.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new VolumeFlowPerArea(value: 1, unit: VolumeFlowPerArea.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<VolumeFlowPerAreaUnit> quantity = new VolumeFlowPerArea(value: 1, unit: VolumeFlowPerArea.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new VolumeFlowPerArea(value: 1, unit: VolumeFlowPerArea.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
         [InlineData("en-US", "4.2 CFM/ft²", VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot, 4.2)]
         [InlineData("en-US", "4.2 m³/(s·m²)", VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, 4.2)]
-        public void Parse(string culture, string quantityString, VolumeFlowPerAreaUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, VolumeFlowPerAreaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = VolumeFlowPerArea.Parse(quantityString);
@@ -251,7 +308,7 @@ public void Parse(string culture, string quantityString, VolumeFlowPerAreaUnit e
         [Theory]
         [InlineData("en-US", "4.2 CFM/ft²", VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot, 4.2)]
         [InlineData("en-US", "4.2 m³/(s·m²)", VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, 4.2)]
-        public void TryParse(string culture, string quantityString, VolumeFlowPerAreaUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, VolumeFlowPerAreaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(VolumeFlowPerArea.TryParse(quantityString, out VolumeFlowPerArea parsed));
@@ -393,6 +450,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(VolumeFlowPerAre
                 var quantity = VolumeFlowPerArea.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -416,33 +474,35 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(VolumeFlowPerAreaUn
                 IQuantity<VolumeFlowPerAreaUnit> quantityToConvert = quantity;
                 IQuantity<VolumeFlowPerAreaUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            VolumeFlowPerArea cubicmeterpersecondpersquaremeter = VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(1);
-            AssertEx.EqualTolerance(1, VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(cubicmeterpersecondpersquaremeter.CubicFeetPerMinutePerSquareFoot).CubicMetersPerSecondPerSquareMeter, CubicFeetPerMinutePerSquareFootTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(cubicmeterpersecondpersquaremeter.CubicMetersPerSecondPerSquareMeter).CubicMetersPerSecondPerSquareMeter, CubicMetersPerSecondPerSquareMeterTolerance);
+            VolumeFlowPerArea cubicmeterpersecondpersquaremeter = VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(3);
+            Assert.Equal(3, VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(cubicmeterpersecondpersquaremeter.CubicFeetPerMinutePerSquareFoot).CubicMetersPerSecondPerSquareMeter);
+            Assert.Equal(3, VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(cubicmeterpersecondpersquaremeter.CubicMetersPerSecondPerSquareMeter).CubicMetersPerSecondPerSquareMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             VolumeFlowPerArea v = VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(1);
-            AssertEx.EqualTolerance(-1, -v.CubicMetersPerSecondPerSquareMeter, CubicMetersPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(3)-v).CubicMetersPerSecondPerSquareMeter, CubicMetersPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).CubicMetersPerSecondPerSquareMeter, CubicMetersPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).CubicMetersPerSecondPerSquareMeter, CubicMetersPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).CubicMetersPerSecondPerSquareMeter, CubicMetersPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, (VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(10)/5).CubicMetersPerSecondPerSquareMeter, CubicMetersPerSecondPerSquareMeterTolerance);
-            AssertEx.EqualTolerance(2, VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(10)/VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(5), CubicMetersPerSecondPerSquareMeterTolerance);
+            Assert.Equal(-1, -v.CubicMetersPerSecondPerSquareMeter);
+            Assert.Equal(2, (VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(3) - v).CubicMetersPerSecondPerSquareMeter);
+            Assert.Equal(2, (v + v).CubicMetersPerSecondPerSquareMeter);
+            Assert.Equal(10, (v * 10).CubicMetersPerSecondPerSquareMeter);
+            Assert.Equal(10, (10 * v).CubicMetersPerSecondPerSquareMeter);
+            Assert.Equal(2, (VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(10) / 5).CubicMetersPerSecondPerSquareMeter);
+            Assert.Equal(2, VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(10) / VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(5));
         }
 
         [Fact]
@@ -488,8 +548,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, 1, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, true)]  // Same value and unit.
         [InlineData(1, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, 2, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, false)] // Different value.
-        [InlineData(2, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, 1, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot, false)] // Different value and unit.
-        [InlineData(1, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, 1, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, VolumeFlowPerAreaUnit unitA, double valueB, VolumeFlowPerAreaUnit unitB, bool expectEqual)
         {
             var a = new VolumeFlowPerArea(valueA, unitA);
@@ -549,8 +607,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(firstValue);
             var otherQuantity = VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(secondValue);
             VolumeFlowPerArea maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, VolumeFlowPerArea.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -569,7 +627,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<VolumeFlowPerAreaUnit>();
+            var units = EnumHelper.GetValues<VolumeFlowPerAreaUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -582,6 +640,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(VolumeFlowPerArea.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(VolumeFlowPerArea.Info.Units, VolumeFlowPerArea.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, VolumeFlowPerArea.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -600,26 +670,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 m³/(s·m²)", new VolumeFlowPerArea(1, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m³/(s·m²)", new VolumeFlowPerArea(0.123456, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter).ToString("s1"));
-            Assert.Equal("0.12 m³/(s·m²)", new VolumeFlowPerArea(0.123456, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter).ToString("s2"));
-            Assert.Equal("0.123 m³/(s·m²)", new VolumeFlowPerArea(0.123456, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter).ToString("s3"));
-            Assert.Equal("0.1235 m³/(s·m²)", new VolumeFlowPerArea(0.123456, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m³/(s·m²)", new VolumeFlowPerArea(0.123456, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter).ToString("s1", culture));
-            Assert.Equal("0.12 m³/(s·m²)", new VolumeFlowPerArea(0.123456, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter).ToString("s2", culture));
-            Assert.Equal("0.123 m³/(s·m²)", new VolumeFlowPerArea(0.123456, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 m³/(s·m²)", new VolumeFlowPerArea(0.123456, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -646,7 +696,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(VolumeFlowPerArea), quantity.As(VolumeFlowPerArea.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs
index 43e705c946..fbe80403a5 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs
@@ -53,10 +53,13 @@ public abstract partial class VolumeFlowTestsBase : QuantityTestsBase
         protected abstract double CubicFeetPerHourInOneCubicMeterPerSecond { get; }
         protected abstract double CubicFeetPerMinuteInOneCubicMeterPerSecond { get; }
         protected abstract double CubicFeetPerSecondInOneCubicMeterPerSecond { get; }
+        protected abstract double CubicInchesPerMinuteInOneCubicMeterPerSecond { get; }
+        protected abstract double CubicInchesPerSecondInOneCubicMeterPerSecond { get; }
         protected abstract double CubicMetersPerDayInOneCubicMeterPerSecond { get; }
         protected abstract double CubicMetersPerHourInOneCubicMeterPerSecond { get; }
         protected abstract double CubicMetersPerMinuteInOneCubicMeterPerSecond { get; }
         protected abstract double CubicMetersPerSecondInOneCubicMeterPerSecond { get; }
+        protected abstract double CubicMillimetersPerMinuteInOneCubicMeterPerSecond { get; }
         protected abstract double CubicMillimetersPerSecondInOneCubicMeterPerSecond { get; }
         protected abstract double CubicYardsPerDayInOneCubicMeterPerSecond { get; }
         protected abstract double CubicYardsPerHourInOneCubicMeterPerSecond { get; }
@@ -130,10 +133,13 @@ public abstract partial class VolumeFlowTestsBase : QuantityTestsBase
         protected virtual double CubicFeetPerHourTolerance { get { return 1e-5; } }
         protected virtual double CubicFeetPerMinuteTolerance { get { return 1e-5; } }
         protected virtual double CubicFeetPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double CubicInchesPerMinuteTolerance { get { return 1e-5; } }
+        protected virtual double CubicInchesPerSecondTolerance { get { return 1e-5; } }
         protected virtual double CubicMetersPerDayTolerance { get { return 1e-5; } }
         protected virtual double CubicMetersPerHourTolerance { get { return 1e-5; } }
         protected virtual double CubicMetersPerMinuteTolerance { get { return 1e-5; } }
         protected virtual double CubicMetersPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double CubicMillimetersPerMinuteTolerance { get { return 1e-5; } }
         protected virtual double CubicMillimetersPerSecondTolerance { get { return 1e-5; } }
         protected virtual double CubicYardsPerDayTolerance { get { return 1e-5; } }
         protected virtual double CubicYardsPerHourTolerance { get { return 1e-5; } }
@@ -211,10 +217,13 @@ public abstract partial class VolumeFlowTestsBase : QuantityTestsBase
                 VolumeFlowUnit.CubicFootPerHour => (CubicFeetPerHourInOneCubicMeterPerSecond, CubicFeetPerHourTolerance),
                 VolumeFlowUnit.CubicFootPerMinute => (CubicFeetPerMinuteInOneCubicMeterPerSecond, CubicFeetPerMinuteTolerance),
                 VolumeFlowUnit.CubicFootPerSecond => (CubicFeetPerSecondInOneCubicMeterPerSecond, CubicFeetPerSecondTolerance),
+                VolumeFlowUnit.CubicInchPerMinute => (CubicInchesPerMinuteInOneCubicMeterPerSecond, CubicInchesPerMinuteTolerance),
+                VolumeFlowUnit.CubicInchPerSecond => (CubicInchesPerSecondInOneCubicMeterPerSecond, CubicInchesPerSecondTolerance),
                 VolumeFlowUnit.CubicMeterPerDay => (CubicMetersPerDayInOneCubicMeterPerSecond, CubicMetersPerDayTolerance),
                 VolumeFlowUnit.CubicMeterPerHour => (CubicMetersPerHourInOneCubicMeterPerSecond, CubicMetersPerHourTolerance),
                 VolumeFlowUnit.CubicMeterPerMinute => (CubicMetersPerMinuteInOneCubicMeterPerSecond, CubicMetersPerMinuteTolerance),
                 VolumeFlowUnit.CubicMeterPerSecond => (CubicMetersPerSecondInOneCubicMeterPerSecond, CubicMetersPerSecondTolerance),
+                VolumeFlowUnit.CubicMillimeterPerMinute => (CubicMillimetersPerMinuteInOneCubicMeterPerSecond, CubicMillimetersPerMinuteTolerance),
                 VolumeFlowUnit.CubicMillimeterPerSecond => (CubicMillimetersPerSecondInOneCubicMeterPerSecond, CubicMillimetersPerSecondTolerance),
                 VolumeFlowUnit.CubicYardPerDay => (CubicYardsPerDayInOneCubicMeterPerSecond, CubicYardsPerDayTolerance),
                 VolumeFlowUnit.CubicYardPerHour => (CubicYardsPerHourInOneCubicMeterPerSecond, CubicYardsPerHourTolerance),
@@ -292,10 +301,13 @@ public abstract partial class VolumeFlowTestsBase : QuantityTestsBase
             new object[] { VolumeFlowUnit.CubicFootPerHour },
             new object[] { VolumeFlowUnit.CubicFootPerMinute },
             new object[] { VolumeFlowUnit.CubicFootPerSecond },
+            new object[] { VolumeFlowUnit.CubicInchPerMinute },
+            new object[] { VolumeFlowUnit.CubicInchPerSecond },
             new object[] { VolumeFlowUnit.CubicMeterPerDay },
             new object[] { VolumeFlowUnit.CubicMeterPerHour },
             new object[] { VolumeFlowUnit.CubicMeterPerMinute },
             new object[] { VolumeFlowUnit.CubicMeterPerSecond },
+            new object[] { VolumeFlowUnit.CubicMillimeterPerMinute },
             new object[] { VolumeFlowUnit.CubicMillimeterPerSecond },
             new object[] { VolumeFlowUnit.CubicYardPerDay },
             new object[] { VolumeFlowUnit.CubicYardPerHour },
@@ -421,6 +433,20 @@ public void VolumeFlow_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<VolumeFlowUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void VolumeFlowInfo_CreateWithCustomUnitInfos()
+        {
+            VolumeFlowUnit[] expectedUnits = [VolumeFlowUnit.CubicMeterPerSecond];
+
+            VolumeFlow.VolumeFlowInfo quantityInfo = VolumeFlow.VolumeFlowInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("VolumeFlow", quantityInfo.Name);
+            Assert.Equal(VolumeFlow.Zero, quantityInfo.Zero);
+            Assert.Equal(VolumeFlow.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CubicMeterPerSecondToVolumeFlowUnits()
         {
@@ -438,10 +464,13 @@ public void CubicMeterPerSecondToVolumeFlowUnits()
             AssertEx.EqualTolerance(CubicFeetPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.CubicFeetPerHour, CubicFeetPerHourTolerance);
             AssertEx.EqualTolerance(CubicFeetPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.CubicFeetPerMinute, CubicFeetPerMinuteTolerance);
             AssertEx.EqualTolerance(CubicFeetPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.CubicFeetPerSecond, CubicFeetPerSecondTolerance);
+            AssertEx.EqualTolerance(CubicInchesPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.CubicInchesPerMinute, CubicInchesPerMinuteTolerance);
+            AssertEx.EqualTolerance(CubicInchesPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.CubicInchesPerSecond, CubicInchesPerSecondTolerance);
             AssertEx.EqualTolerance(CubicMetersPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.CubicMetersPerDay, CubicMetersPerDayTolerance);
             AssertEx.EqualTolerance(CubicMetersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.CubicMetersPerHour, CubicMetersPerHourTolerance);
             AssertEx.EqualTolerance(CubicMetersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.CubicMetersPerMinute, CubicMetersPerMinuteTolerance);
             AssertEx.EqualTolerance(CubicMetersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.CubicMetersPerSecond, CubicMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(CubicMillimetersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.CubicMillimetersPerMinute, CubicMillimetersPerMinuteTolerance);
             AssertEx.EqualTolerance(CubicMillimetersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.CubicMillimetersPerSecond, CubicMillimetersPerSecondTolerance);
             AssertEx.EqualTolerance(CubicYardsPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.CubicYardsPerDay, CubicYardsPerDayTolerance);
             AssertEx.EqualTolerance(CubicYardsPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.CubicYardsPerHour, CubicYardsPerHourTolerance);
@@ -548,10 +577,13 @@ public void As()
             AssertEx.EqualTolerance(CubicFeetPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicFootPerHour), CubicFeetPerHourTolerance);
             AssertEx.EqualTolerance(CubicFeetPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicFootPerMinute), CubicFeetPerMinuteTolerance);
             AssertEx.EqualTolerance(CubicFeetPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicFootPerSecond), CubicFeetPerSecondTolerance);
+            AssertEx.EqualTolerance(CubicInchesPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicInchPerMinute), CubicInchesPerMinuteTolerance);
+            AssertEx.EqualTolerance(CubicInchesPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicInchPerSecond), CubicInchesPerSecondTolerance);
             AssertEx.EqualTolerance(CubicMetersPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicMeterPerDay), CubicMetersPerDayTolerance);
             AssertEx.EqualTolerance(CubicMetersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicMeterPerHour), CubicMetersPerHourTolerance);
             AssertEx.EqualTolerance(CubicMetersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicMeterPerMinute), CubicMetersPerMinuteTolerance);
             AssertEx.EqualTolerance(CubicMetersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicMeterPerSecond), CubicMetersPerSecondTolerance);
+            AssertEx.EqualTolerance(CubicMillimetersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicMillimeterPerMinute), CubicMillimetersPerMinuteTolerance);
             AssertEx.EqualTolerance(CubicMillimetersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicMillimeterPerSecond), CubicMillimetersPerSecondTolerance);
             AssertEx.EqualTolerance(CubicYardsPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicYardPerDay), CubicYardsPerDayTolerance);
             AssertEx.EqualTolerance(CubicYardsPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicYardPerHour), CubicYardsPerHourTolerance);
@@ -653,26 +685,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = VolumeFlow.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            VolumeFlow convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                VolumeFlow quantityToConvert = quantity;
+
+                VolumeFlow convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<VolumeFlowUnit> quantityToConvert = quantity;
+
+                IQuantity<VolumeFlowUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new VolumeFlow(value: 1, unit: VolumeFlow.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new VolumeFlow(value: 1, unit: VolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<VolumeFlowUnit> quantity = new VolumeFlow(value: 1, unit: VolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new VolumeFlow(value: 1, unit: VolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new VolumeFlow(value: 1, unit: VolumeFlow.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new VolumeFlow(value: 1, unit: VolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<VolumeFlowUnit> quantity = new VolumeFlow(value: 1, unit: VolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new VolumeFlow(value: 1, unit: VolumeFlow.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -696,10 +771,13 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 ft³/min", VolumeFlowUnit.CubicFootPerMinute, 4.2)]
         [InlineData("en-US", "4.2 CFM", VolumeFlowUnit.CubicFootPerMinute, 4.2)]
         [InlineData("en-US", "4.2 ft³/s", VolumeFlowUnit.CubicFootPerSecond, 4.2)]
+        [InlineData("en-US", "4.2 in³/min", VolumeFlowUnit.CubicInchPerMinute, 4.2)]
+        [InlineData("en-US", "4.2 in³/s", VolumeFlowUnit.CubicInchPerSecond, 4.2)]
         [InlineData("en-US", "4.2 m³/d", VolumeFlowUnit.CubicMeterPerDay, 4.2)]
         [InlineData("en-US", "4.2 m³/h", VolumeFlowUnit.CubicMeterPerHour, 4.2)]
         [InlineData("en-US", "4.2 m³/min", VolumeFlowUnit.CubicMeterPerMinute, 4.2)]
         [InlineData("en-US", "4.2 m³/s", VolumeFlowUnit.CubicMeterPerSecond, 4.2)]
+        [InlineData("en-US", "4.2 mm³/min", VolumeFlowUnit.CubicMillimeterPerMinute, 4.2)]
         [InlineData("en-US", "4.2 mm³/s", VolumeFlowUnit.CubicMillimeterPerSecond, 4.2)]
         [InlineData("en-US", "4.2 cy/day", VolumeFlowUnit.CubicYardPerDay, 4.2)]
         [InlineData("en-US", "4.2 yd³/h", VolumeFlowUnit.CubicYardPerHour, 4.2)]
@@ -818,6 +896,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 м³/ч", VolumeFlowUnit.CubicMeterPerHour, 4.2)]
         [InlineData("ru-RU", "4,2 м³/мин", VolumeFlowUnit.CubicMeterPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 м³/с", VolumeFlowUnit.CubicMeterPerSecond, 4.2)]
+        [InlineData("ru-RU", "4,2 мм³/мин", VolumeFlowUnit.CubicMillimeterPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 мм³/с", VolumeFlowUnit.CubicMillimeterPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 дал/ч", VolumeFlowUnit.DecaliterPerHour, 4.2)]
         [InlineData("ru-RU", "4,2 дал/мин", VolumeFlowUnit.DecaliterPerMinute, 4.2)]
@@ -846,7 +925,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 нл/ч", VolumeFlowUnit.NanoliterPerHour, 4.2)]
         [InlineData("ru-RU", "4,2 нл/мин", VolumeFlowUnit.NanoliterPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 нл/c", VolumeFlowUnit.NanoliterPerSecond, 4.2)]
-        public void Parse(string culture, string quantityString, VolumeFlowUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, VolumeFlowUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = VolumeFlow.Parse(quantityString);
@@ -875,10 +954,13 @@ public void Parse(string culture, string quantityString, VolumeFlowUnit expected
         [InlineData("en-US", "4.2 ft³/min", VolumeFlowUnit.CubicFootPerMinute, 4.2)]
         [InlineData("en-US", "4.2 CFM", VolumeFlowUnit.CubicFootPerMinute, 4.2)]
         [InlineData("en-US", "4.2 ft³/s", VolumeFlowUnit.CubicFootPerSecond, 4.2)]
+        [InlineData("en-US", "4.2 in³/min", VolumeFlowUnit.CubicInchPerMinute, 4.2)]
+        [InlineData("en-US", "4.2 in³/s", VolumeFlowUnit.CubicInchPerSecond, 4.2)]
         [InlineData("en-US", "4.2 m³/d", VolumeFlowUnit.CubicMeterPerDay, 4.2)]
         [InlineData("en-US", "4.2 m³/h", VolumeFlowUnit.CubicMeterPerHour, 4.2)]
         [InlineData("en-US", "4.2 m³/min", VolumeFlowUnit.CubicMeterPerMinute, 4.2)]
         [InlineData("en-US", "4.2 m³/s", VolumeFlowUnit.CubicMeterPerSecond, 4.2)]
+        [InlineData("en-US", "4.2 mm³/min", VolumeFlowUnit.CubicMillimeterPerMinute, 4.2)]
         [InlineData("en-US", "4.2 mm³/s", VolumeFlowUnit.CubicMillimeterPerSecond, 4.2)]
         [InlineData("en-US", "4.2 cy/day", VolumeFlowUnit.CubicYardPerDay, 4.2)]
         [InlineData("en-US", "4.2 yd³/h", VolumeFlowUnit.CubicYardPerHour, 4.2)]
@@ -997,6 +1079,7 @@ public void Parse(string culture, string quantityString, VolumeFlowUnit expected
         [InlineData("ru-RU", "4,2 м³/ч", VolumeFlowUnit.CubicMeterPerHour, 4.2)]
         [InlineData("ru-RU", "4,2 м³/мин", VolumeFlowUnit.CubicMeterPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 м³/с", VolumeFlowUnit.CubicMeterPerSecond, 4.2)]
+        [InlineData("ru-RU", "4,2 мм³/мин", VolumeFlowUnit.CubicMillimeterPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 мм³/с", VolumeFlowUnit.CubicMillimeterPerSecond, 4.2)]
         [InlineData("ru-RU", "4,2 дал/ч", VolumeFlowUnit.DecaliterPerHour, 4.2)]
         [InlineData("ru-RU", "4,2 дал/мин", VolumeFlowUnit.DecaliterPerMinute, 4.2)]
@@ -1025,7 +1108,7 @@ public void Parse(string culture, string quantityString, VolumeFlowUnit expected
         [InlineData("ru-RU", "4,2 нл/ч", VolumeFlowUnit.NanoliterPerHour, 4.2)]
         [InlineData("ru-RU", "4,2 нл/мин", VolumeFlowUnit.NanoliterPerMinute, 4.2)]
         [InlineData("ru-RU", "4,2 нл/c", VolumeFlowUnit.NanoliterPerSecond, 4.2)]
-        public void TryParse(string culture, string quantityString, VolumeFlowUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, VolumeFlowUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(VolumeFlow.TryParse(quantityString, out VolumeFlow parsed));
@@ -1054,10 +1137,13 @@ public void TryParse(string culture, string quantityString, VolumeFlowUnit expec
         [InlineData("ft³/min", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("CFM", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("ft³/s", VolumeFlowUnit.CubicFootPerSecond)]
+        [InlineData("in³/min", VolumeFlowUnit.CubicInchPerMinute)]
+        [InlineData("in³/s", VolumeFlowUnit.CubicInchPerSecond)]
         [InlineData("m³/d", VolumeFlowUnit.CubicMeterPerDay)]
         [InlineData("m³/h", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("m³/min", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("m³/s", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("mm³/min", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("mm³/s", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("cy/day", VolumeFlowUnit.CubicYardPerDay)]
         [InlineData("yd³/h", VolumeFlowUnit.CubicYardPerHour)]
@@ -1197,10 +1283,13 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeFlo
         [InlineData("ft³/min", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("CFM", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("ft³/s", VolumeFlowUnit.CubicFootPerSecond)]
+        [InlineData("in³/min", VolumeFlowUnit.CubicInchPerMinute)]
+        [InlineData("in³/s", VolumeFlowUnit.CubicInchPerSecond)]
         [InlineData("m³/d", VolumeFlowUnit.CubicMeterPerDay)]
         [InlineData("m³/h", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("m³/min", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("m³/s", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("mm³/min", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("mm³/s", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("cy/day", VolumeFlowUnit.CubicYardPerDay)]
         [InlineData("yd³/h", VolumeFlowUnit.CubicYardPerHour)]
@@ -1340,10 +1429,13 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "ft³/min", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("en-US", "CFM", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("en-US", "ft³/s", VolumeFlowUnit.CubicFootPerSecond)]
+        [InlineData("en-US", "in³/min", VolumeFlowUnit.CubicInchPerMinute)]
+        [InlineData("en-US", "in³/s", VolumeFlowUnit.CubicInchPerSecond)]
         [InlineData("en-US", "m³/d", VolumeFlowUnit.CubicMeterPerDay)]
         [InlineData("en-US", "m³/h", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("en-US", "m³/min", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("en-US", "m³/s", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("en-US", "mm³/min", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("en-US", "mm³/s", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("en-US", "cy/day", VolumeFlowUnit.CubicYardPerDay)]
         [InlineData("en-US", "yd³/h", VolumeFlowUnit.CubicYardPerHour)]
@@ -1462,6 +1554,7 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("ru-RU", "м³/ч", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("ru-RU", "м³/мин", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("ru-RU", "м³/с", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("ru-RU", "мм³/мин", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("ru-RU", "мм³/с", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("ru-RU", "дал/ч", VolumeFlowUnit.DecaliterPerHour)]
         [InlineData("ru-RU", "дал/мин", VolumeFlowUnit.DecaliterPerMinute)]
@@ -1518,10 +1611,13 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo
         [InlineData("en-US", "ft³/min", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("en-US", "CFM", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("en-US", "ft³/s", VolumeFlowUnit.CubicFootPerSecond)]
+        [InlineData("en-US", "in³/min", VolumeFlowUnit.CubicInchPerMinute)]
+        [InlineData("en-US", "in³/s", VolumeFlowUnit.CubicInchPerSecond)]
         [InlineData("en-US", "m³/d", VolumeFlowUnit.CubicMeterPerDay)]
         [InlineData("en-US", "m³/h", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("en-US", "m³/min", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("en-US", "m³/s", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("en-US", "mm³/min", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("en-US", "mm³/s", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("en-US", "cy/day", VolumeFlowUnit.CubicYardPerDay)]
         [InlineData("en-US", "yd³/h", VolumeFlowUnit.CubicYardPerHour)]
@@ -1640,6 +1736,7 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo
         [InlineData("ru-RU", "м³/ч", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("ru-RU", "м³/мин", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("ru-RU", "м³/с", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("ru-RU", "мм³/мин", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("ru-RU", "мм³/с", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("ru-RU", "дал/ч", VolumeFlowUnit.DecaliterPerHour)]
         [InlineData("ru-RU", "дал/мин", VolumeFlowUnit.DecaliterPerMinute)]
@@ -1695,10 +1792,13 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, VolumeFlo
         [InlineData("ft³/min", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("CFM", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("ft³/s", VolumeFlowUnit.CubicFootPerSecond)]
+        [InlineData("in³/min", VolumeFlowUnit.CubicInchPerMinute)]
+        [InlineData("in³/s", VolumeFlowUnit.CubicInchPerSecond)]
         [InlineData("m³/d", VolumeFlowUnit.CubicMeterPerDay)]
         [InlineData("m³/h", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("m³/min", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("m³/s", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("mm³/min", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("mm³/s", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("cy/day", VolumeFlowUnit.CubicYardPerDay)]
         [InlineData("yd³/h", VolumeFlowUnit.CubicYardPerHour)]
@@ -1838,10 +1938,13 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Volume
         [InlineData("ft³/min", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("CFM", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("ft³/s", VolumeFlowUnit.CubicFootPerSecond)]
+        [InlineData("in³/min", VolumeFlowUnit.CubicInchPerMinute)]
+        [InlineData("in³/s", VolumeFlowUnit.CubicInchPerSecond)]
         [InlineData("m³/d", VolumeFlowUnit.CubicMeterPerDay)]
         [InlineData("m³/h", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("m³/min", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("m³/s", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("mm³/min", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("mm³/s", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("cy/day", VolumeFlowUnit.CubicYardPerDay)]
         [InlineData("yd³/h", VolumeFlowUnit.CubicYardPerHour)]
@@ -1981,10 +2084,13 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "ft³/min", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("en-US", "CFM", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("en-US", "ft³/s", VolumeFlowUnit.CubicFootPerSecond)]
+        [InlineData("en-US", "in³/min", VolumeFlowUnit.CubicInchPerMinute)]
+        [InlineData("en-US", "in³/s", VolumeFlowUnit.CubicInchPerSecond)]
         [InlineData("en-US", "m³/d", VolumeFlowUnit.CubicMeterPerDay)]
         [InlineData("en-US", "m³/h", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("en-US", "m³/min", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("en-US", "m³/s", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("en-US", "mm³/min", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("en-US", "mm³/s", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("en-US", "cy/day", VolumeFlowUnit.CubicYardPerDay)]
         [InlineData("en-US", "yd³/h", VolumeFlowUnit.CubicYardPerHour)]
@@ -2103,6 +2209,7 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("ru-RU", "м³/ч", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("ru-RU", "м³/мин", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("ru-RU", "м³/с", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("ru-RU", "мм³/мин", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("ru-RU", "мм³/с", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("ru-RU", "дал/ч", VolumeFlowUnit.DecaliterPerHour)]
         [InlineData("ru-RU", "дал/мин", VolumeFlowUnit.DecaliterPerMinute)]
@@ -2159,10 +2266,13 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "ft³/min", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("en-US", "CFM", VolumeFlowUnit.CubicFootPerMinute)]
         [InlineData("en-US", "ft³/s", VolumeFlowUnit.CubicFootPerSecond)]
+        [InlineData("en-US", "in³/min", VolumeFlowUnit.CubicInchPerMinute)]
+        [InlineData("en-US", "in³/s", VolumeFlowUnit.CubicInchPerSecond)]
         [InlineData("en-US", "m³/d", VolumeFlowUnit.CubicMeterPerDay)]
         [InlineData("en-US", "m³/h", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("en-US", "m³/min", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("en-US", "m³/s", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("en-US", "mm³/min", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("en-US", "mm³/s", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("en-US", "cy/day", VolumeFlowUnit.CubicYardPerDay)]
         [InlineData("en-US", "yd³/h", VolumeFlowUnit.CubicYardPerHour)]
@@ -2281,6 +2391,7 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("ru-RU", "м³/ч", VolumeFlowUnit.CubicMeterPerHour)]
         [InlineData("ru-RU", "м³/мин", VolumeFlowUnit.CubicMeterPerMinute)]
         [InlineData("ru-RU", "м³/с", VolumeFlowUnit.CubicMeterPerSecond)]
+        [InlineData("ru-RU", "мм³/мин", VolumeFlowUnit.CubicMillimeterPerMinute)]
         [InlineData("ru-RU", "мм³/с", VolumeFlowUnit.CubicMillimeterPerSecond)]
         [InlineData("ru-RU", "дал/ч", VolumeFlowUnit.DecaliterPerHour)]
         [InlineData("ru-RU", "дал/мин", VolumeFlowUnit.DecaliterPerMinute)]
@@ -2329,10 +2440,13 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Volume
         [InlineData("en-US", VolumeFlowUnit.CubicFootPerHour, "ft³/h")]
         [InlineData("en-US", VolumeFlowUnit.CubicFootPerMinute, "ft³/min")]
         [InlineData("en-US", VolumeFlowUnit.CubicFootPerSecond, "ft³/s")]
+        [InlineData("en-US", VolumeFlowUnit.CubicInchPerMinute, "in³/min")]
+        [InlineData("en-US", VolumeFlowUnit.CubicInchPerSecond, "in³/s")]
         [InlineData("en-US", VolumeFlowUnit.CubicMeterPerDay, "m³/d")]
         [InlineData("en-US", VolumeFlowUnit.CubicMeterPerHour, "m³/h")]
         [InlineData("en-US", VolumeFlowUnit.CubicMeterPerMinute, "m³/min")]
         [InlineData("en-US", VolumeFlowUnit.CubicMeterPerSecond, "m³/s")]
+        [InlineData("en-US", VolumeFlowUnit.CubicMillimeterPerMinute, "mm³/min")]
         [InlineData("en-US", VolumeFlowUnit.CubicMillimeterPerSecond, "mm³/s")]
         [InlineData("en-US", VolumeFlowUnit.CubicYardPerDay, "cy/day")]
         [InlineData("en-US", VolumeFlowUnit.CubicYardPerHour, "yd³/h")]
@@ -2399,6 +2513,7 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Volume
         [InlineData("ru-RU", VolumeFlowUnit.CubicMeterPerHour, "м³/ч")]
         [InlineData("ru-RU", VolumeFlowUnit.CubicMeterPerMinute, "м³/мин")]
         [InlineData("ru-RU", VolumeFlowUnit.CubicMeterPerSecond, "м³/с")]
+        [InlineData("ru-RU", VolumeFlowUnit.CubicMillimeterPerMinute, "мм³/мин")]
         [InlineData("ru-RU", VolumeFlowUnit.CubicMillimeterPerSecond, "мм³/с")]
         [InlineData("ru-RU", VolumeFlowUnit.DecaliterPerHour, "дал/ч")]
         [InlineData("ru-RU", VolumeFlowUnit.DecaliterPerMinute, "дал/мин")]
@@ -2476,6 +2591,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(VolumeFlowUnit u
                 var quantity = VolumeFlow.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -2499,106 +2615,111 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(VolumeFlowUnit unit
                 IQuantity<VolumeFlowUnit> quantityToConvert = quantity;
                 IQuantity<VolumeFlowUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            VolumeFlow cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(1);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromAcreFeetPerDay(cubicmeterpersecond.AcreFeetPerDay).CubicMetersPerSecond, AcreFeetPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromAcreFeetPerHour(cubicmeterpersecond.AcreFeetPerHour).CubicMetersPerSecond, AcreFeetPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromAcreFeetPerMinute(cubicmeterpersecond.AcreFeetPerMinute).CubicMetersPerSecond, AcreFeetPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromAcreFeetPerSecond(cubicmeterpersecond.AcreFeetPerSecond).CubicMetersPerSecond, AcreFeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCentilitersPerDay(cubicmeterpersecond.CentilitersPerDay).CubicMetersPerSecond, CentilitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCentilitersPerHour(cubicmeterpersecond.CentilitersPerHour).CubicMetersPerSecond, CentilitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCentilitersPerMinute(cubicmeterpersecond.CentilitersPerMinute).CubicMetersPerSecond, CentilitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCentilitersPerSecond(cubicmeterpersecond.CentilitersPerSecond).CubicMetersPerSecond, CentilitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicCentimetersPerMinute(cubicmeterpersecond.CubicCentimetersPerMinute).CubicMetersPerSecond, CubicCentimetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicDecimetersPerMinute(cubicmeterpersecond.CubicDecimetersPerMinute).CubicMetersPerSecond, CubicDecimetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicFeetPerHour(cubicmeterpersecond.CubicFeetPerHour).CubicMetersPerSecond, CubicFeetPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicFeetPerMinute(cubicmeterpersecond.CubicFeetPerMinute).CubicMetersPerSecond, CubicFeetPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicFeetPerSecond(cubicmeterpersecond.CubicFeetPerSecond).CubicMetersPerSecond, CubicFeetPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicMetersPerDay(cubicmeterpersecond.CubicMetersPerDay).CubicMetersPerSecond, CubicMetersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicMetersPerHour(cubicmeterpersecond.CubicMetersPerHour).CubicMetersPerSecond, CubicMetersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicMetersPerMinute(cubicmeterpersecond.CubicMetersPerMinute).CubicMetersPerSecond, CubicMetersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicMetersPerSecond(cubicmeterpersecond.CubicMetersPerSecond).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicMillimetersPerSecond(cubicmeterpersecond.CubicMillimetersPerSecond).CubicMetersPerSecond, CubicMillimetersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerDay(cubicmeterpersecond.CubicYardsPerDay).CubicMetersPerSecond, CubicYardsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerHour(cubicmeterpersecond.CubicYardsPerHour).CubicMetersPerSecond, CubicYardsPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerMinute(cubicmeterpersecond.CubicYardsPerMinute).CubicMetersPerSecond, CubicYardsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerSecond(cubicmeterpersecond.CubicYardsPerSecond).CubicMetersPerSecond, CubicYardsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecalitersPerDay(cubicmeterpersecond.DecalitersPerDay).CubicMetersPerSecond, DecalitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecalitersPerHour(cubicmeterpersecond.DecalitersPerHour).CubicMetersPerSecond, DecalitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecalitersPerMinute(cubicmeterpersecond.DecalitersPerMinute).CubicMetersPerSecond, DecalitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecalitersPerSecond(cubicmeterpersecond.DecalitersPerSecond).CubicMetersPerSecond, DecalitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerDay(cubicmeterpersecond.DecilitersPerDay).CubicMetersPerSecond, DecilitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerHour(cubicmeterpersecond.DecilitersPerHour).CubicMetersPerSecond, DecilitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerMinute(cubicmeterpersecond.DecilitersPerMinute).CubicMetersPerSecond, DecilitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerSecond(cubicmeterpersecond.DecilitersPerSecond).CubicMetersPerSecond, DecilitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromHectolitersPerDay(cubicmeterpersecond.HectolitersPerDay).CubicMetersPerSecond, HectolitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromHectolitersPerHour(cubicmeterpersecond.HectolitersPerHour).CubicMetersPerSecond, HectolitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromHectolitersPerMinute(cubicmeterpersecond.HectolitersPerMinute).CubicMetersPerSecond, HectolitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromHectolitersPerSecond(cubicmeterpersecond.HectolitersPerSecond).CubicMetersPerSecond, HectolitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromKilolitersPerDay(cubicmeterpersecond.KilolitersPerDay).CubicMetersPerSecond, KilolitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromKilolitersPerHour(cubicmeterpersecond.KilolitersPerHour).CubicMetersPerSecond, KilolitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromKilolitersPerMinute(cubicmeterpersecond.KilolitersPerMinute).CubicMetersPerSecond, KilolitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromKilolitersPerSecond(cubicmeterpersecond.KilolitersPerSecond).CubicMetersPerSecond, KilolitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromKilousGallonsPerMinute(cubicmeterpersecond.KilousGallonsPerMinute).CubicMetersPerSecond, KilousGallonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromLitersPerDay(cubicmeterpersecond.LitersPerDay).CubicMetersPerSecond, LitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromLitersPerHour(cubicmeterpersecond.LitersPerHour).CubicMetersPerSecond, LitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromLitersPerMinute(cubicmeterpersecond.LitersPerMinute).CubicMetersPerSecond, LitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromLitersPerSecond(cubicmeterpersecond.LitersPerSecond).CubicMetersPerSecond, LitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMegalitersPerDay(cubicmeterpersecond.MegalitersPerDay).CubicMetersPerSecond, MegalitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMegalitersPerHour(cubicmeterpersecond.MegalitersPerHour).CubicMetersPerSecond, MegalitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMegalitersPerMinute(cubicmeterpersecond.MegalitersPerMinute).CubicMetersPerSecond, MegalitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMegalitersPerSecond(cubicmeterpersecond.MegalitersPerSecond).CubicMetersPerSecond, MegalitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMegaukGallonsPerDay(cubicmeterpersecond.MegaukGallonsPerDay).CubicMetersPerSecond, MegaukGallonsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMegaukGallonsPerSecond(cubicmeterpersecond.MegaukGallonsPerSecond).CubicMetersPerSecond, MegaukGallonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMegausGallonsPerDay(cubicmeterpersecond.MegausGallonsPerDay).CubicMetersPerSecond, MegausGallonsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMicrolitersPerDay(cubicmeterpersecond.MicrolitersPerDay).CubicMetersPerSecond, MicrolitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMicrolitersPerHour(cubicmeterpersecond.MicrolitersPerHour).CubicMetersPerSecond, MicrolitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMicrolitersPerMinute(cubicmeterpersecond.MicrolitersPerMinute).CubicMetersPerSecond, MicrolitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMicrolitersPerSecond(cubicmeterpersecond.MicrolitersPerSecond).CubicMetersPerSecond, MicrolitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMillilitersPerDay(cubicmeterpersecond.MillilitersPerDay).CubicMetersPerSecond, MillilitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMillilitersPerHour(cubicmeterpersecond.MillilitersPerHour).CubicMetersPerSecond, MillilitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMillilitersPerMinute(cubicmeterpersecond.MillilitersPerMinute).CubicMetersPerSecond, MillilitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMillilitersPerSecond(cubicmeterpersecond.MillilitersPerSecond).CubicMetersPerSecond, MillilitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromMillionUsGallonsPerDay(cubicmeterpersecond.MillionUsGallonsPerDay).CubicMetersPerSecond, MillionUsGallonsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromNanolitersPerDay(cubicmeterpersecond.NanolitersPerDay).CubicMetersPerSecond, NanolitersPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromNanolitersPerHour(cubicmeterpersecond.NanolitersPerHour).CubicMetersPerSecond, NanolitersPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromNanolitersPerMinute(cubicmeterpersecond.NanolitersPerMinute).CubicMetersPerSecond, NanolitersPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromNanolitersPerSecond(cubicmeterpersecond.NanolitersPerSecond).CubicMetersPerSecond, NanolitersPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromOilBarrelsPerDay(cubicmeterpersecond.OilBarrelsPerDay).CubicMetersPerSecond, OilBarrelsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromOilBarrelsPerHour(cubicmeterpersecond.OilBarrelsPerHour).CubicMetersPerSecond, OilBarrelsPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromOilBarrelsPerMinute(cubicmeterpersecond.OilBarrelsPerMinute).CubicMetersPerSecond, OilBarrelsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromOilBarrelsPerSecond(cubicmeterpersecond.OilBarrelsPerSecond).CubicMetersPerSecond, OilBarrelsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUkGallonsPerDay(cubicmeterpersecond.UkGallonsPerDay).CubicMetersPerSecond, UkGallonsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUkGallonsPerHour(cubicmeterpersecond.UkGallonsPerHour).CubicMetersPerSecond, UkGallonsPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUkGallonsPerMinute(cubicmeterpersecond.UkGallonsPerMinute).CubicMetersPerSecond, UkGallonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUkGallonsPerSecond(cubicmeterpersecond.UkGallonsPerSecond).CubicMetersPerSecond, UkGallonsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUsGallonsPerDay(cubicmeterpersecond.UsGallonsPerDay).CubicMetersPerSecond, UsGallonsPerDayTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUsGallonsPerHour(cubicmeterpersecond.UsGallonsPerHour).CubicMetersPerSecond, UsGallonsPerHourTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUsGallonsPerMinute(cubicmeterpersecond.UsGallonsPerMinute).CubicMetersPerSecond, UsGallonsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, VolumeFlow.FromUsGallonsPerSecond(cubicmeterpersecond.UsGallonsPerSecond).CubicMetersPerSecond, UsGallonsPerSecondTolerance);
+            VolumeFlow cubicmeterpersecond = VolumeFlow.FromCubicMetersPerSecond(3);
+            Assert.Equal(3, VolumeFlow.FromAcreFeetPerDay(cubicmeterpersecond.AcreFeetPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromAcreFeetPerHour(cubicmeterpersecond.AcreFeetPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromAcreFeetPerMinute(cubicmeterpersecond.AcreFeetPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromAcreFeetPerSecond(cubicmeterpersecond.AcreFeetPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCentilitersPerDay(cubicmeterpersecond.CentilitersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCentilitersPerHour(cubicmeterpersecond.CentilitersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCentilitersPerMinute(cubicmeterpersecond.CentilitersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCentilitersPerSecond(cubicmeterpersecond.CentilitersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicCentimetersPerMinute(cubicmeterpersecond.CubicCentimetersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicDecimetersPerMinute(cubicmeterpersecond.CubicDecimetersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicFeetPerHour(cubicmeterpersecond.CubicFeetPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicFeetPerMinute(cubicmeterpersecond.CubicFeetPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicFeetPerSecond(cubicmeterpersecond.CubicFeetPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicInchesPerMinute(cubicmeterpersecond.CubicInchesPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicInchesPerSecond(cubicmeterpersecond.CubicInchesPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicMetersPerDay(cubicmeterpersecond.CubicMetersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicMetersPerHour(cubicmeterpersecond.CubicMetersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicMetersPerMinute(cubicmeterpersecond.CubicMetersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicMetersPerSecond(cubicmeterpersecond.CubicMetersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicMillimetersPerMinute(cubicmeterpersecond.CubicMillimetersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicMillimetersPerSecond(cubicmeterpersecond.CubicMillimetersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicYardsPerDay(cubicmeterpersecond.CubicYardsPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicYardsPerHour(cubicmeterpersecond.CubicYardsPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicYardsPerMinute(cubicmeterpersecond.CubicYardsPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromCubicYardsPerSecond(cubicmeterpersecond.CubicYardsPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromDecalitersPerDay(cubicmeterpersecond.DecalitersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromDecalitersPerHour(cubicmeterpersecond.DecalitersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromDecalitersPerMinute(cubicmeterpersecond.DecalitersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromDecalitersPerSecond(cubicmeterpersecond.DecalitersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromDecilitersPerDay(cubicmeterpersecond.DecilitersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromDecilitersPerHour(cubicmeterpersecond.DecilitersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromDecilitersPerMinute(cubicmeterpersecond.DecilitersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromDecilitersPerSecond(cubicmeterpersecond.DecilitersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromHectolitersPerDay(cubicmeterpersecond.HectolitersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromHectolitersPerHour(cubicmeterpersecond.HectolitersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromHectolitersPerMinute(cubicmeterpersecond.HectolitersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromHectolitersPerSecond(cubicmeterpersecond.HectolitersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromKilolitersPerDay(cubicmeterpersecond.KilolitersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromKilolitersPerHour(cubicmeterpersecond.KilolitersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromKilolitersPerMinute(cubicmeterpersecond.KilolitersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromKilolitersPerSecond(cubicmeterpersecond.KilolitersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromKilousGallonsPerMinute(cubicmeterpersecond.KilousGallonsPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromLitersPerDay(cubicmeterpersecond.LitersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromLitersPerHour(cubicmeterpersecond.LitersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromLitersPerMinute(cubicmeterpersecond.LitersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromLitersPerSecond(cubicmeterpersecond.LitersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMegalitersPerDay(cubicmeterpersecond.MegalitersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMegalitersPerHour(cubicmeterpersecond.MegalitersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMegalitersPerMinute(cubicmeterpersecond.MegalitersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMegalitersPerSecond(cubicmeterpersecond.MegalitersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMegaukGallonsPerDay(cubicmeterpersecond.MegaukGallonsPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMegaukGallonsPerSecond(cubicmeterpersecond.MegaukGallonsPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMegausGallonsPerDay(cubicmeterpersecond.MegausGallonsPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMicrolitersPerDay(cubicmeterpersecond.MicrolitersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMicrolitersPerHour(cubicmeterpersecond.MicrolitersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMicrolitersPerMinute(cubicmeterpersecond.MicrolitersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMicrolitersPerSecond(cubicmeterpersecond.MicrolitersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMillilitersPerDay(cubicmeterpersecond.MillilitersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMillilitersPerHour(cubicmeterpersecond.MillilitersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMillilitersPerMinute(cubicmeterpersecond.MillilitersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMillilitersPerSecond(cubicmeterpersecond.MillilitersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromMillionUsGallonsPerDay(cubicmeterpersecond.MillionUsGallonsPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromNanolitersPerDay(cubicmeterpersecond.NanolitersPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromNanolitersPerHour(cubicmeterpersecond.NanolitersPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromNanolitersPerMinute(cubicmeterpersecond.NanolitersPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromNanolitersPerSecond(cubicmeterpersecond.NanolitersPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromOilBarrelsPerDay(cubicmeterpersecond.OilBarrelsPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromOilBarrelsPerHour(cubicmeterpersecond.OilBarrelsPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromOilBarrelsPerMinute(cubicmeterpersecond.OilBarrelsPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromOilBarrelsPerSecond(cubicmeterpersecond.OilBarrelsPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromUkGallonsPerDay(cubicmeterpersecond.UkGallonsPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromUkGallonsPerHour(cubicmeterpersecond.UkGallonsPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromUkGallonsPerMinute(cubicmeterpersecond.UkGallonsPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromUkGallonsPerSecond(cubicmeterpersecond.UkGallonsPerSecond).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromUsGallonsPerDay(cubicmeterpersecond.UsGallonsPerDay).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromUsGallonsPerHour(cubicmeterpersecond.UsGallonsPerHour).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromUsGallonsPerMinute(cubicmeterpersecond.UsGallonsPerMinute).CubicMetersPerSecond);
+            Assert.Equal(3, VolumeFlow.FromUsGallonsPerSecond(cubicmeterpersecond.UsGallonsPerSecond).CubicMetersPerSecond);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             VolumeFlow v = VolumeFlow.FromCubicMetersPerSecond(1);
-            AssertEx.EqualTolerance(-1, -v.CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (VolumeFlow.FromCubicMetersPerSecond(3)-v).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (v + v).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (v*10).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(10, (10*v).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, (VolumeFlow.FromCubicMetersPerSecond(10)/5).CubicMetersPerSecond, CubicMetersPerSecondTolerance);
-            AssertEx.EqualTolerance(2, VolumeFlow.FromCubicMetersPerSecond(10)/VolumeFlow.FromCubicMetersPerSecond(5), CubicMetersPerSecondTolerance);
+            Assert.Equal(-1, -v.CubicMetersPerSecond);
+            Assert.Equal(2, (VolumeFlow.FromCubicMetersPerSecond(3) - v).CubicMetersPerSecond);
+            Assert.Equal(2, (v + v).CubicMetersPerSecond);
+            Assert.Equal(10, (v * 10).CubicMetersPerSecond);
+            Assert.Equal(10, (10 * v).CubicMetersPerSecond);
+            Assert.Equal(2, (VolumeFlow.FromCubicMetersPerSecond(10) / 5).CubicMetersPerSecond);
+            Assert.Equal(2, VolumeFlow.FromCubicMetersPerSecond(10) / VolumeFlow.FromCubicMetersPerSecond(5));
         }
 
         [Fact]
@@ -2644,8 +2765,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, VolumeFlowUnit.CubicMeterPerSecond, 1, VolumeFlowUnit.CubicMeterPerSecond, true)]  // Same value and unit.
         [InlineData(1, VolumeFlowUnit.CubicMeterPerSecond, 2, VolumeFlowUnit.CubicMeterPerSecond, false)] // Different value.
-        [InlineData(2, VolumeFlowUnit.CubicMeterPerSecond, 1, VolumeFlowUnit.AcreFootPerDay, false)] // Different value and unit.
-        [InlineData(1, VolumeFlowUnit.CubicMeterPerSecond, 1, VolumeFlowUnit.AcreFootPerDay, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, VolumeFlowUnit unitA, double valueB, VolumeFlowUnit unitB, bool expectEqual)
         {
             var a = new VolumeFlow(valueA, unitA);
@@ -2705,8 +2824,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = VolumeFlow.FromCubicMetersPerSecond(firstValue);
             var otherQuantity = VolumeFlow.FromCubicMetersPerSecond(secondValue);
             VolumeFlow maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, VolumeFlow.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -2725,7 +2844,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<VolumeFlowUnit>();
+            var units = EnumHelper.GetValues<VolumeFlowUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -2738,6 +2857,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(VolumeFlow.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(VolumeFlow.Info.Units, VolumeFlow.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, VolumeFlow.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -2755,10 +2886,13 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
             Assert.Equal("1 ft³/h", new VolumeFlow(1, VolumeFlowUnit.CubicFootPerHour).ToString());
             Assert.Equal("1 ft³/min", new VolumeFlow(1, VolumeFlowUnit.CubicFootPerMinute).ToString());
             Assert.Equal("1 ft³/s", new VolumeFlow(1, VolumeFlowUnit.CubicFootPerSecond).ToString());
+            Assert.Equal("1 in³/min", new VolumeFlow(1, VolumeFlowUnit.CubicInchPerMinute).ToString());
+            Assert.Equal("1 in³/s", new VolumeFlow(1, VolumeFlowUnit.CubicInchPerSecond).ToString());
             Assert.Equal("1 m³/d", new VolumeFlow(1, VolumeFlowUnit.CubicMeterPerDay).ToString());
             Assert.Equal("1 m³/h", new VolumeFlow(1, VolumeFlowUnit.CubicMeterPerHour).ToString());
             Assert.Equal("1 m³/min", new VolumeFlow(1, VolumeFlowUnit.CubicMeterPerMinute).ToString());
             Assert.Equal("1 m³/s", new VolumeFlow(1, VolumeFlowUnit.CubicMeterPerSecond).ToString());
+            Assert.Equal("1 mm³/min", new VolumeFlow(1, VolumeFlowUnit.CubicMillimeterPerMinute).ToString());
             Assert.Equal("1 mm³/s", new VolumeFlow(1, VolumeFlowUnit.CubicMillimeterPerSecond).ToString());
             Assert.Equal("1 cy/day", new VolumeFlow(1, VolumeFlowUnit.CubicYardPerDay).ToString());
             Assert.Equal("1 yd³/h", new VolumeFlow(1, VolumeFlowUnit.CubicYardPerHour).ToString());
@@ -2838,10 +2972,13 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 ft³/h", new VolumeFlow(1, VolumeFlowUnit.CubicFootPerHour).ToString(swedishCulture));
             Assert.Equal("1 ft³/min", new VolumeFlow(1, VolumeFlowUnit.CubicFootPerMinute).ToString(swedishCulture));
             Assert.Equal("1 ft³/s", new VolumeFlow(1, VolumeFlowUnit.CubicFootPerSecond).ToString(swedishCulture));
+            Assert.Equal("1 in³/min", new VolumeFlow(1, VolumeFlowUnit.CubicInchPerMinute).ToString(swedishCulture));
+            Assert.Equal("1 in³/s", new VolumeFlow(1, VolumeFlowUnit.CubicInchPerSecond).ToString(swedishCulture));
             Assert.Equal("1 m³/d", new VolumeFlow(1, VolumeFlowUnit.CubicMeterPerDay).ToString(swedishCulture));
             Assert.Equal("1 m³/h", new VolumeFlow(1, VolumeFlowUnit.CubicMeterPerHour).ToString(swedishCulture));
             Assert.Equal("1 m³/min", new VolumeFlow(1, VolumeFlowUnit.CubicMeterPerMinute).ToString(swedishCulture));
             Assert.Equal("1 m³/s", new VolumeFlow(1, VolumeFlowUnit.CubicMeterPerSecond).ToString(swedishCulture));
+            Assert.Equal("1 mm³/min", new VolumeFlow(1, VolumeFlowUnit.CubicMillimeterPerMinute).ToString(swedishCulture));
             Assert.Equal("1 mm³/s", new VolumeFlow(1, VolumeFlowUnit.CubicMillimeterPerSecond).ToString(swedishCulture));
             Assert.Equal("1 cy/day", new VolumeFlow(1, VolumeFlowUnit.CubicYardPerDay).ToString(swedishCulture));
             Assert.Equal("1 yd³/h", new VolumeFlow(1, VolumeFlowUnit.CubicYardPerHour).ToString(swedishCulture));
@@ -2902,26 +3039,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 gal (U.S.)/s", new VolumeFlow(1, VolumeFlowUnit.UsGallonPerSecond).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m³/s", new VolumeFlow(0.123456, VolumeFlowUnit.CubicMeterPerSecond).ToString("s1"));
-            Assert.Equal("0.12 m³/s", new VolumeFlow(0.123456, VolumeFlowUnit.CubicMeterPerSecond).ToString("s2"));
-            Assert.Equal("0.123 m³/s", new VolumeFlow(0.123456, VolumeFlowUnit.CubicMeterPerSecond).ToString("s3"));
-            Assert.Equal("0.1235 m³/s", new VolumeFlow(0.123456, VolumeFlowUnit.CubicMeterPerSecond).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m³/s", new VolumeFlow(0.123456, VolumeFlowUnit.CubicMeterPerSecond).ToString("s1", culture));
-            Assert.Equal("0.12 m³/s", new VolumeFlow(0.123456, VolumeFlowUnit.CubicMeterPerSecond).ToString("s2", culture));
-            Assert.Equal("0.123 m³/s", new VolumeFlow(0.123456, VolumeFlowUnit.CubicMeterPerSecond).ToString("s3", culture));
-            Assert.Equal("0.1235 m³/s", new VolumeFlow(0.123456, VolumeFlowUnit.CubicMeterPerSecond).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -2948,7 +3065,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = VolumeFlow.FromCubicMetersPerSecond(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(VolumeFlow), quantity.As(VolumeFlow.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumePerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumePerLengthTestsBase.g.cs
index b02a80a5ac..5028b757e1 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumePerLengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumePerLengthTestsBase.g.cs
@@ -157,6 +157,20 @@ public void VolumePerLength_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<VolumePerLengthUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void VolumePerLengthInfo_CreateWithCustomUnitInfos()
+        {
+            VolumePerLengthUnit[] expectedUnits = [VolumePerLengthUnit.CubicMeterPerMeter];
+
+            VolumePerLength.VolumePerLengthInfo quantityInfo = VolumePerLength.VolumePerLengthInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("VolumePerLength", quantityInfo.Name);
+            Assert.Equal(VolumePerLength.Zero, quantityInfo.Zero);
+            Assert.Equal(VolumePerLength.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CubicMeterPerMeterToVolumePerLengthUnits()
         {
@@ -257,26 +271,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = VolumePerLength.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            VolumePerLength convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                VolumePerLength quantityToConvert = quantity;
+
+                VolumePerLength convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<VolumePerLengthUnit> quantityToConvert = quantity;
+
+                IQuantity<VolumePerLengthUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new VolumePerLength(value: 1, unit: VolumePerLength.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new VolumePerLength(value: 1, unit: VolumePerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<VolumePerLengthUnit> quantity = new VolumePerLength(value: 1, unit: VolumePerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new VolumePerLength(value: 1, unit: VolumePerLength.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new VolumePerLength(value: 1, unit: VolumePerLength.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new VolumePerLength(value: 1, unit: VolumePerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<VolumePerLengthUnit> quantity = new VolumePerLength(value: 1, unit: VolumePerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new VolumePerLength(value: 1, unit: VolumePerLength.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -289,7 +346,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 l/mm", VolumePerLengthUnit.LiterPerMillimeter, 4.2)]
         [InlineData("en-US", "4.2 bbl/ft", VolumePerLengthUnit.OilBarrelPerFoot, 4.2)]
         [InlineData("en-US", "4.2 gal (U.S.)/mi", VolumePerLengthUnit.UsGallonPerMile, 4.2)]
-        public void Parse(string culture, string quantityString, VolumePerLengthUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, VolumePerLengthUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = VolumePerLength.Parse(quantityString);
@@ -307,7 +364,7 @@ public void Parse(string culture, string quantityString, VolumePerLengthUnit exp
         [InlineData("en-US", "4.2 l/mm", VolumePerLengthUnit.LiterPerMillimeter, 4.2)]
         [InlineData("en-US", "4.2 bbl/ft", VolumePerLengthUnit.OilBarrelPerFoot, 4.2)]
         [InlineData("en-US", "4.2 gal (U.S.)/mi", VolumePerLengthUnit.UsGallonPerMile, 4.2)]
-        public void TryParse(string culture, string quantityString, VolumePerLengthUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, VolumePerLengthUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(VolumePerLength.TryParse(quantityString, out VolumePerLength parsed));
@@ -512,6 +569,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(VolumePerLengthU
                 var quantity = VolumePerLength.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -535,40 +593,42 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(VolumePerLengthUnit
                 IQuantity<VolumePerLengthUnit> quantityToConvert = quantity;
                 IQuantity<VolumePerLengthUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromCubicMetersPerMeter(cubicmeterpermeter.CubicMetersPerMeter).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromCubicYardsPerFoot(cubicmeterpermeter.CubicYardsPerFoot).CubicMetersPerMeter, CubicYardsPerFootTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromCubicYardsPerUsSurveyFoot(cubicmeterpermeter.CubicYardsPerUsSurveyFoot).CubicMetersPerMeter, CubicYardsPerUsSurveyFootTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromImperialGallonsPerMile(cubicmeterpermeter.ImperialGallonsPerMile).CubicMetersPerMeter, ImperialGallonsPerMileTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromLitersPerKilometer(cubicmeterpermeter.LitersPerKilometer).CubicMetersPerMeter, LitersPerKilometerTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromLitersPerMeter(cubicmeterpermeter.LitersPerMeter).CubicMetersPerMeter, LitersPerMeterTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromLitersPerMillimeter(cubicmeterpermeter.LitersPerMillimeter).CubicMetersPerMeter, LitersPerMillimeterTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromOilBarrelsPerFoot(cubicmeterpermeter.OilBarrelsPerFoot).CubicMetersPerMeter, OilBarrelsPerFootTolerance);
-            AssertEx.EqualTolerance(1, VolumePerLength.FromUsGallonsPerMile(cubicmeterpermeter.UsGallonsPerMile).CubicMetersPerMeter, UsGallonsPerMileTolerance);
+            VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(3);
+            Assert.Equal(3, VolumePerLength.FromCubicMetersPerMeter(cubicmeterpermeter.CubicMetersPerMeter).CubicMetersPerMeter);
+            Assert.Equal(3, VolumePerLength.FromCubicYardsPerFoot(cubicmeterpermeter.CubicYardsPerFoot).CubicMetersPerMeter);
+            Assert.Equal(3, VolumePerLength.FromCubicYardsPerUsSurveyFoot(cubicmeterpermeter.CubicYardsPerUsSurveyFoot).CubicMetersPerMeter);
+            Assert.Equal(3, VolumePerLength.FromImperialGallonsPerMile(cubicmeterpermeter.ImperialGallonsPerMile).CubicMetersPerMeter);
+            Assert.Equal(3, VolumePerLength.FromLitersPerKilometer(cubicmeterpermeter.LitersPerKilometer).CubicMetersPerMeter);
+            Assert.Equal(3, VolumePerLength.FromLitersPerMeter(cubicmeterpermeter.LitersPerMeter).CubicMetersPerMeter);
+            Assert.Equal(3, VolumePerLength.FromLitersPerMillimeter(cubicmeterpermeter.LitersPerMillimeter).CubicMetersPerMeter);
+            Assert.Equal(3, VolumePerLength.FromOilBarrelsPerFoot(cubicmeterpermeter.OilBarrelsPerFoot).CubicMetersPerMeter);
+            Assert.Equal(3, VolumePerLength.FromUsGallonsPerMile(cubicmeterpermeter.UsGallonsPerMile).CubicMetersPerMeter);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             VolumePerLength v = VolumePerLength.FromCubicMetersPerMeter(1);
-            AssertEx.EqualTolerance(-1, -v.CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (VolumePerLength.FromCubicMetersPerMeter(3)-v).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (v + v).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (v*10).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(10, (10*v).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(2, (VolumePerLength.FromCubicMetersPerMeter(10)/5).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
-            AssertEx.EqualTolerance(2, VolumePerLength.FromCubicMetersPerMeter(10)/VolumePerLength.FromCubicMetersPerMeter(5), CubicMetersPerMeterTolerance);
+            Assert.Equal(-1, -v.CubicMetersPerMeter);
+            Assert.Equal(2, (VolumePerLength.FromCubicMetersPerMeter(3) - v).CubicMetersPerMeter);
+            Assert.Equal(2, (v + v).CubicMetersPerMeter);
+            Assert.Equal(10, (v * 10).CubicMetersPerMeter);
+            Assert.Equal(10, (10 * v).CubicMetersPerMeter);
+            Assert.Equal(2, (VolumePerLength.FromCubicMetersPerMeter(10) / 5).CubicMetersPerMeter);
+            Assert.Equal(2, VolumePerLength.FromCubicMetersPerMeter(10) / VolumePerLength.FromCubicMetersPerMeter(5));
         }
 
         [Fact]
@@ -614,8 +674,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, VolumePerLengthUnit.CubicMeterPerMeter, 1, VolumePerLengthUnit.CubicMeterPerMeter, true)]  // Same value and unit.
         [InlineData(1, VolumePerLengthUnit.CubicMeterPerMeter, 2, VolumePerLengthUnit.CubicMeterPerMeter, false)] // Different value.
-        [InlineData(2, VolumePerLengthUnit.CubicMeterPerMeter, 1, VolumePerLengthUnit.CubicYardPerFoot, false)] // Different value and unit.
-        [InlineData(1, VolumePerLengthUnit.CubicMeterPerMeter, 1, VolumePerLengthUnit.CubicYardPerFoot, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, VolumePerLengthUnit unitA, double valueB, VolumePerLengthUnit unitB, bool expectEqual)
         {
             var a = new VolumePerLength(valueA, unitA);
@@ -675,8 +733,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = VolumePerLength.FromCubicMetersPerMeter(firstValue);
             var otherQuantity = VolumePerLength.FromCubicMetersPerMeter(secondValue);
             VolumePerLength maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, VolumePerLength.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -695,7 +753,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<VolumePerLengthUnit>();
+            var units = EnumHelper.GetValues<VolumePerLengthUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -708,6 +766,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(VolumePerLength.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(VolumePerLength.Info.Units, VolumePerLength.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, VolumePerLength.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -740,26 +810,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 gal (U.S.)/mi", new VolumePerLength(1, VolumePerLengthUnit.UsGallonPerMile).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m³/m", new VolumePerLength(0.123456, VolumePerLengthUnit.CubicMeterPerMeter).ToString("s1"));
-            Assert.Equal("0.12 m³/m", new VolumePerLength(0.123456, VolumePerLengthUnit.CubicMeterPerMeter).ToString("s2"));
-            Assert.Equal("0.123 m³/m", new VolumePerLength(0.123456, VolumePerLengthUnit.CubicMeterPerMeter).ToString("s3"));
-            Assert.Equal("0.1235 m³/m", new VolumePerLength(0.123456, VolumePerLengthUnit.CubicMeterPerMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m³/m", new VolumePerLength(0.123456, VolumePerLengthUnit.CubicMeterPerMeter).ToString("s1", culture));
-            Assert.Equal("0.12 m³/m", new VolumePerLength(0.123456, VolumePerLengthUnit.CubicMeterPerMeter).ToString("s2", culture));
-            Assert.Equal("0.123 m³/m", new VolumePerLength(0.123456, VolumePerLengthUnit.CubicMeterPerMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 m³/m", new VolumePerLength(0.123456, VolumePerLengthUnit.CubicMeterPerMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -786,7 +836,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = VolumePerLength.FromCubicMetersPerMeter(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(VolumePerLength), quantity.As(VolumePerLength.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs
index 554bf4995a..72e1626005 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeTestsBase.g.cs
@@ -59,22 +59,18 @@ public abstract partial class VolumeTestsBase : QuantityTestsBase
         protected abstract double DecausGallonsInOneCubicMeter { get; }
         protected abstract double DecilitersInOneCubicMeter { get; }
         protected abstract double DeciusGallonsInOneCubicMeter { get; }
-        protected abstract double HectocubicFeetInOneCubicMeter { get; }
-        protected abstract double HectocubicMetersInOneCubicMeter { get; }
         protected abstract double HectolitersInOneCubicMeter { get; }
         protected abstract double HectousGallonsInOneCubicMeter { get; }
+        protected abstract double HundredCubicFeetInOneCubicMeter { get; }
         protected abstract double ImperialBeerBarrelsInOneCubicMeter { get; }
         protected abstract double ImperialGallonsInOneCubicMeter { get; }
         protected abstract double ImperialOuncesInOneCubicMeter { get; }
         protected abstract double ImperialPintsInOneCubicMeter { get; }
         protected abstract double ImperialQuartsInOneCubicMeter { get; }
-        protected abstract double KilocubicFeetInOneCubicMeter { get; }
-        protected abstract double KilocubicMetersInOneCubicMeter { get; }
         protected abstract double KiloimperialGallonsInOneCubicMeter { get; }
         protected abstract double KilolitersInOneCubicMeter { get; }
         protected abstract double KilousGallonsInOneCubicMeter { get; }
         protected abstract double LitersInOneCubicMeter { get; }
-        protected abstract double MegacubicFeetInOneCubicMeter { get; }
         protected abstract double MegaimperialGallonsInOneCubicMeter { get; }
         protected abstract double MegalitersInOneCubicMeter { get; }
         protected abstract double MegausGallonsInOneCubicMeter { get; }
@@ -83,8 +79,11 @@ public abstract partial class VolumeTestsBase : QuantityTestsBase
         protected abstract double MetricTeaspoonsInOneCubicMeter { get; }
         protected abstract double MicrolitersInOneCubicMeter { get; }
         protected abstract double MillilitersInOneCubicMeter { get; }
+        protected abstract double MillionCubicFeetInOneCubicMeter { get; }
         protected abstract double NanolitersInOneCubicMeter { get; }
         protected abstract double OilBarrelsInOneCubicMeter { get; }
+        protected abstract double ThousandCubicFeetInOneCubicMeter { get; }
+        protected abstract double ThousandCubicMetersInOneCubicMeter { get; }
         protected abstract double UkTablespoonsInOneCubicMeter { get; }
         protected abstract double UsBeerBarrelsInOneCubicMeter { get; }
         protected abstract double UsCustomaryCupsInOneCubicMeter { get; }
@@ -116,22 +115,18 @@ public abstract partial class VolumeTestsBase : QuantityTestsBase
         protected virtual double DecausGallonsTolerance { get { return 1e-5; } }
         protected virtual double DecilitersTolerance { get { return 1e-5; } }
         protected virtual double DeciusGallonsTolerance { get { return 1e-5; } }
-        protected virtual double HectocubicFeetTolerance { get { return 1e-5; } }
-        protected virtual double HectocubicMetersTolerance { get { return 1e-5; } }
         protected virtual double HectolitersTolerance { get { return 1e-5; } }
         protected virtual double HectousGallonsTolerance { get { return 1e-5; } }
+        protected virtual double HundredCubicFeetTolerance { get { return 1e-5; } }
         protected virtual double ImperialBeerBarrelsTolerance { get { return 1e-5; } }
         protected virtual double ImperialGallonsTolerance { get { return 1e-5; } }
         protected virtual double ImperialOuncesTolerance { get { return 1e-5; } }
         protected virtual double ImperialPintsTolerance { get { return 1e-5; } }
         protected virtual double ImperialQuartsTolerance { get { return 1e-5; } }
-        protected virtual double KilocubicFeetTolerance { get { return 1e-5; } }
-        protected virtual double KilocubicMetersTolerance { get { return 1e-5; } }
         protected virtual double KiloimperialGallonsTolerance { get { return 1e-5; } }
         protected virtual double KilolitersTolerance { get { return 1e-5; } }
         protected virtual double KilousGallonsTolerance { get { return 1e-5; } }
         protected virtual double LitersTolerance { get { return 1e-5; } }
-        protected virtual double MegacubicFeetTolerance { get { return 1e-5; } }
         protected virtual double MegaimperialGallonsTolerance { get { return 1e-5; } }
         protected virtual double MegalitersTolerance { get { return 1e-5; } }
         protected virtual double MegausGallonsTolerance { get { return 1e-5; } }
@@ -140,8 +135,11 @@ public abstract partial class VolumeTestsBase : QuantityTestsBase
         protected virtual double MetricTeaspoonsTolerance { get { return 1e-5; } }
         protected virtual double MicrolitersTolerance { get { return 1e-5; } }
         protected virtual double MillilitersTolerance { get { return 1e-5; } }
+        protected virtual double MillionCubicFeetTolerance { get { return 1e-5; } }
         protected virtual double NanolitersTolerance { get { return 1e-5; } }
         protected virtual double OilBarrelsTolerance { get { return 1e-5; } }
+        protected virtual double ThousandCubicFeetTolerance { get { return 1e-5; } }
+        protected virtual double ThousandCubicMetersTolerance { get { return 1e-5; } }
         protected virtual double UkTablespoonsTolerance { get { return 1e-5; } }
         protected virtual double UsBeerBarrelsTolerance { get { return 1e-5; } }
         protected virtual double UsCustomaryCupsTolerance { get { return 1e-5; } }
@@ -177,22 +175,18 @@ public abstract partial class VolumeTestsBase : QuantityTestsBase
                 VolumeUnit.DecausGallon => (DecausGallonsInOneCubicMeter, DecausGallonsTolerance),
                 VolumeUnit.Deciliter => (DecilitersInOneCubicMeter, DecilitersTolerance),
                 VolumeUnit.DeciusGallon => (DeciusGallonsInOneCubicMeter, DeciusGallonsTolerance),
-                VolumeUnit.HectocubicFoot => (HectocubicFeetInOneCubicMeter, HectocubicFeetTolerance),
-                VolumeUnit.HectocubicMeter => (HectocubicMetersInOneCubicMeter, HectocubicMetersTolerance),
                 VolumeUnit.Hectoliter => (HectolitersInOneCubicMeter, HectolitersTolerance),
                 VolumeUnit.HectousGallon => (HectousGallonsInOneCubicMeter, HectousGallonsTolerance),
+                VolumeUnit.HundredCubicFoot => (HundredCubicFeetInOneCubicMeter, HundredCubicFeetTolerance),
                 VolumeUnit.ImperialBeerBarrel => (ImperialBeerBarrelsInOneCubicMeter, ImperialBeerBarrelsTolerance),
                 VolumeUnit.ImperialGallon => (ImperialGallonsInOneCubicMeter, ImperialGallonsTolerance),
                 VolumeUnit.ImperialOunce => (ImperialOuncesInOneCubicMeter, ImperialOuncesTolerance),
                 VolumeUnit.ImperialPint => (ImperialPintsInOneCubicMeter, ImperialPintsTolerance),
                 VolumeUnit.ImperialQuart => (ImperialQuartsInOneCubicMeter, ImperialQuartsTolerance),
-                VolumeUnit.KilocubicFoot => (KilocubicFeetInOneCubicMeter, KilocubicFeetTolerance),
-                VolumeUnit.KilocubicMeter => (KilocubicMetersInOneCubicMeter, KilocubicMetersTolerance),
                 VolumeUnit.KiloimperialGallon => (KiloimperialGallonsInOneCubicMeter, KiloimperialGallonsTolerance),
                 VolumeUnit.Kiloliter => (KilolitersInOneCubicMeter, KilolitersTolerance),
                 VolumeUnit.KilousGallon => (KilousGallonsInOneCubicMeter, KilousGallonsTolerance),
                 VolumeUnit.Liter => (LitersInOneCubicMeter, LitersTolerance),
-                VolumeUnit.MegacubicFoot => (MegacubicFeetInOneCubicMeter, MegacubicFeetTolerance),
                 VolumeUnit.MegaimperialGallon => (MegaimperialGallonsInOneCubicMeter, MegaimperialGallonsTolerance),
                 VolumeUnit.Megaliter => (MegalitersInOneCubicMeter, MegalitersTolerance),
                 VolumeUnit.MegausGallon => (MegausGallonsInOneCubicMeter, MegausGallonsTolerance),
@@ -201,8 +195,11 @@ public abstract partial class VolumeTestsBase : QuantityTestsBase
                 VolumeUnit.MetricTeaspoon => (MetricTeaspoonsInOneCubicMeter, MetricTeaspoonsTolerance),
                 VolumeUnit.Microliter => (MicrolitersInOneCubicMeter, MicrolitersTolerance),
                 VolumeUnit.Milliliter => (MillilitersInOneCubicMeter, MillilitersTolerance),
+                VolumeUnit.MillionCubicFoot => (MillionCubicFeetInOneCubicMeter, MillionCubicFeetTolerance),
                 VolumeUnit.Nanoliter => (NanolitersInOneCubicMeter, NanolitersTolerance),
                 VolumeUnit.OilBarrel => (OilBarrelsInOneCubicMeter, OilBarrelsTolerance),
+                VolumeUnit.ThousandCubicFoot => (ThousandCubicFeetInOneCubicMeter, ThousandCubicFeetTolerance),
+                VolumeUnit.ThousandCubicMeter => (ThousandCubicMetersInOneCubicMeter, ThousandCubicMetersTolerance),
                 VolumeUnit.UkTablespoon => (UkTablespoonsInOneCubicMeter, UkTablespoonsTolerance),
                 VolumeUnit.UsBeerBarrel => (UsBeerBarrelsInOneCubicMeter, UsBeerBarrelsTolerance),
                 VolumeUnit.UsCustomaryCup => (UsCustomaryCupsInOneCubicMeter, UsCustomaryCupsTolerance),
@@ -238,22 +235,18 @@ public abstract partial class VolumeTestsBase : QuantityTestsBase
             new object[] { VolumeUnit.DecausGallon },
             new object[] { VolumeUnit.Deciliter },
             new object[] { VolumeUnit.DeciusGallon },
-            new object[] { VolumeUnit.HectocubicFoot },
-            new object[] { VolumeUnit.HectocubicMeter },
             new object[] { VolumeUnit.Hectoliter },
             new object[] { VolumeUnit.HectousGallon },
+            new object[] { VolumeUnit.HundredCubicFoot },
             new object[] { VolumeUnit.ImperialBeerBarrel },
             new object[] { VolumeUnit.ImperialGallon },
             new object[] { VolumeUnit.ImperialOunce },
             new object[] { VolumeUnit.ImperialPint },
             new object[] { VolumeUnit.ImperialQuart },
-            new object[] { VolumeUnit.KilocubicFoot },
-            new object[] { VolumeUnit.KilocubicMeter },
             new object[] { VolumeUnit.KiloimperialGallon },
             new object[] { VolumeUnit.Kiloliter },
             new object[] { VolumeUnit.KilousGallon },
             new object[] { VolumeUnit.Liter },
-            new object[] { VolumeUnit.MegacubicFoot },
             new object[] { VolumeUnit.MegaimperialGallon },
             new object[] { VolumeUnit.Megaliter },
             new object[] { VolumeUnit.MegausGallon },
@@ -262,8 +255,11 @@ public abstract partial class VolumeTestsBase : QuantityTestsBase
             new object[] { VolumeUnit.MetricTeaspoon },
             new object[] { VolumeUnit.Microliter },
             new object[] { VolumeUnit.Milliliter },
+            new object[] { VolumeUnit.MillionCubicFoot },
             new object[] { VolumeUnit.Nanoliter },
             new object[] { VolumeUnit.OilBarrel },
+            new object[] { VolumeUnit.ThousandCubicFoot },
+            new object[] { VolumeUnit.ThousandCubicMeter },
             new object[] { VolumeUnit.UkTablespoon },
             new object[] { VolumeUnit.UsBeerBarrel },
             new object[] { VolumeUnit.UsCustomaryCup },
@@ -341,6 +337,20 @@ public void Volume_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
             Assert.Equal(quantityInfo, ((IQuantity<VolumeUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void VolumeInfo_CreateWithCustomUnitInfos()
+        {
+            VolumeUnit[] expectedUnits = [VolumeUnit.CubicMeter];
+
+            Volume.VolumeInfo quantityInfo = Volume.VolumeInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("Volume", quantityInfo.Name);
+            Assert.Equal(Volume.Zero, quantityInfo.Zero);
+            Assert.Equal(Volume.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void CubicMeterToVolumeUnits()
         {
@@ -364,22 +374,18 @@ public void CubicMeterToVolumeUnits()
             AssertEx.EqualTolerance(DecausGallonsInOneCubicMeter, cubicmeter.DecausGallons, DecausGallonsTolerance);
             AssertEx.EqualTolerance(DecilitersInOneCubicMeter, cubicmeter.Deciliters, DecilitersTolerance);
             AssertEx.EqualTolerance(DeciusGallonsInOneCubicMeter, cubicmeter.DeciusGallons, DeciusGallonsTolerance);
-            AssertEx.EqualTolerance(HectocubicFeetInOneCubicMeter, cubicmeter.HectocubicFeet, HectocubicFeetTolerance);
-            AssertEx.EqualTolerance(HectocubicMetersInOneCubicMeter, cubicmeter.HectocubicMeters, HectocubicMetersTolerance);
             AssertEx.EqualTolerance(HectolitersInOneCubicMeter, cubicmeter.Hectoliters, HectolitersTolerance);
             AssertEx.EqualTolerance(HectousGallonsInOneCubicMeter, cubicmeter.HectousGallons, HectousGallonsTolerance);
+            AssertEx.EqualTolerance(HundredCubicFeetInOneCubicMeter, cubicmeter.HundredCubicFeet, HundredCubicFeetTolerance);
             AssertEx.EqualTolerance(ImperialBeerBarrelsInOneCubicMeter, cubicmeter.ImperialBeerBarrels, ImperialBeerBarrelsTolerance);
             AssertEx.EqualTolerance(ImperialGallonsInOneCubicMeter, cubicmeter.ImperialGallons, ImperialGallonsTolerance);
             AssertEx.EqualTolerance(ImperialOuncesInOneCubicMeter, cubicmeter.ImperialOunces, ImperialOuncesTolerance);
             AssertEx.EqualTolerance(ImperialPintsInOneCubicMeter, cubicmeter.ImperialPints, ImperialPintsTolerance);
             AssertEx.EqualTolerance(ImperialQuartsInOneCubicMeter, cubicmeter.ImperialQuarts, ImperialQuartsTolerance);
-            AssertEx.EqualTolerance(KilocubicFeetInOneCubicMeter, cubicmeter.KilocubicFeet, KilocubicFeetTolerance);
-            AssertEx.EqualTolerance(KilocubicMetersInOneCubicMeter, cubicmeter.KilocubicMeters, KilocubicMetersTolerance);
             AssertEx.EqualTolerance(KiloimperialGallonsInOneCubicMeter, cubicmeter.KiloimperialGallons, KiloimperialGallonsTolerance);
             AssertEx.EqualTolerance(KilolitersInOneCubicMeter, cubicmeter.Kiloliters, KilolitersTolerance);
             AssertEx.EqualTolerance(KilousGallonsInOneCubicMeter, cubicmeter.KilousGallons, KilousGallonsTolerance);
             AssertEx.EqualTolerance(LitersInOneCubicMeter, cubicmeter.Liters, LitersTolerance);
-            AssertEx.EqualTolerance(MegacubicFeetInOneCubicMeter, cubicmeter.MegacubicFeet, MegacubicFeetTolerance);
             AssertEx.EqualTolerance(MegaimperialGallonsInOneCubicMeter, cubicmeter.MegaimperialGallons, MegaimperialGallonsTolerance);
             AssertEx.EqualTolerance(MegalitersInOneCubicMeter, cubicmeter.Megaliters, MegalitersTolerance);
             AssertEx.EqualTolerance(MegausGallonsInOneCubicMeter, cubicmeter.MegausGallons, MegausGallonsTolerance);
@@ -388,8 +394,11 @@ public void CubicMeterToVolumeUnits()
             AssertEx.EqualTolerance(MetricTeaspoonsInOneCubicMeter, cubicmeter.MetricTeaspoons, MetricTeaspoonsTolerance);
             AssertEx.EqualTolerance(MicrolitersInOneCubicMeter, cubicmeter.Microliters, MicrolitersTolerance);
             AssertEx.EqualTolerance(MillilitersInOneCubicMeter, cubicmeter.Milliliters, MillilitersTolerance);
+            AssertEx.EqualTolerance(MillionCubicFeetInOneCubicMeter, cubicmeter.MillionCubicFeet, MillionCubicFeetTolerance);
             AssertEx.EqualTolerance(NanolitersInOneCubicMeter, cubicmeter.Nanoliters, NanolitersTolerance);
             AssertEx.EqualTolerance(OilBarrelsInOneCubicMeter, cubicmeter.OilBarrels, OilBarrelsTolerance);
+            AssertEx.EqualTolerance(ThousandCubicFeetInOneCubicMeter, cubicmeter.ThousandCubicFeet, ThousandCubicFeetTolerance);
+            AssertEx.EqualTolerance(ThousandCubicMetersInOneCubicMeter, cubicmeter.ThousandCubicMeters, ThousandCubicMetersTolerance);
             AssertEx.EqualTolerance(UkTablespoonsInOneCubicMeter, cubicmeter.UkTablespoons, UkTablespoonsTolerance);
             AssertEx.EqualTolerance(UsBeerBarrelsInOneCubicMeter, cubicmeter.UsBeerBarrels, UsBeerBarrelsTolerance);
             AssertEx.EqualTolerance(UsCustomaryCupsInOneCubicMeter, cubicmeter.UsCustomaryCups, UsCustomaryCupsTolerance);
@@ -454,22 +463,18 @@ public void As()
             AssertEx.EqualTolerance(DecausGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.DecausGallon), DecausGallonsTolerance);
             AssertEx.EqualTolerance(DecilitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Deciliter), DecilitersTolerance);
             AssertEx.EqualTolerance(DeciusGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.DeciusGallon), DeciusGallonsTolerance);
-            AssertEx.EqualTolerance(HectocubicFeetInOneCubicMeter, cubicmeter.As(VolumeUnit.HectocubicFoot), HectocubicFeetTolerance);
-            AssertEx.EqualTolerance(HectocubicMetersInOneCubicMeter, cubicmeter.As(VolumeUnit.HectocubicMeter), HectocubicMetersTolerance);
             AssertEx.EqualTolerance(HectolitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Hectoliter), HectolitersTolerance);
             AssertEx.EqualTolerance(HectousGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.HectousGallon), HectousGallonsTolerance);
+            AssertEx.EqualTolerance(HundredCubicFeetInOneCubicMeter, cubicmeter.As(VolumeUnit.HundredCubicFoot), HundredCubicFeetTolerance);
             AssertEx.EqualTolerance(ImperialBeerBarrelsInOneCubicMeter, cubicmeter.As(VolumeUnit.ImperialBeerBarrel), ImperialBeerBarrelsTolerance);
             AssertEx.EqualTolerance(ImperialGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.ImperialGallon), ImperialGallonsTolerance);
             AssertEx.EqualTolerance(ImperialOuncesInOneCubicMeter, cubicmeter.As(VolumeUnit.ImperialOunce), ImperialOuncesTolerance);
             AssertEx.EqualTolerance(ImperialPintsInOneCubicMeter, cubicmeter.As(VolumeUnit.ImperialPint), ImperialPintsTolerance);
             AssertEx.EqualTolerance(ImperialQuartsInOneCubicMeter, cubicmeter.As(VolumeUnit.ImperialQuart), ImperialQuartsTolerance);
-            AssertEx.EqualTolerance(KilocubicFeetInOneCubicMeter, cubicmeter.As(VolumeUnit.KilocubicFoot), KilocubicFeetTolerance);
-            AssertEx.EqualTolerance(KilocubicMetersInOneCubicMeter, cubicmeter.As(VolumeUnit.KilocubicMeter), KilocubicMetersTolerance);
             AssertEx.EqualTolerance(KiloimperialGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.KiloimperialGallon), KiloimperialGallonsTolerance);
             AssertEx.EqualTolerance(KilolitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Kiloliter), KilolitersTolerance);
             AssertEx.EqualTolerance(KilousGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.KilousGallon), KilousGallonsTolerance);
             AssertEx.EqualTolerance(LitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Liter), LitersTolerance);
-            AssertEx.EqualTolerance(MegacubicFeetInOneCubicMeter, cubicmeter.As(VolumeUnit.MegacubicFoot), MegacubicFeetTolerance);
             AssertEx.EqualTolerance(MegaimperialGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.MegaimperialGallon), MegaimperialGallonsTolerance);
             AssertEx.EqualTolerance(MegalitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Megaliter), MegalitersTolerance);
             AssertEx.EqualTolerance(MegausGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.MegausGallon), MegausGallonsTolerance);
@@ -478,8 +483,11 @@ public void As()
             AssertEx.EqualTolerance(MetricTeaspoonsInOneCubicMeter, cubicmeter.As(VolumeUnit.MetricTeaspoon), MetricTeaspoonsTolerance);
             AssertEx.EqualTolerance(MicrolitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Microliter), MicrolitersTolerance);
             AssertEx.EqualTolerance(MillilitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Milliliter), MillilitersTolerance);
+            AssertEx.EqualTolerance(MillionCubicFeetInOneCubicMeter, cubicmeter.As(VolumeUnit.MillionCubicFoot), MillionCubicFeetTolerance);
             AssertEx.EqualTolerance(NanolitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Nanoliter), NanolitersTolerance);
             AssertEx.EqualTolerance(OilBarrelsInOneCubicMeter, cubicmeter.As(VolumeUnit.OilBarrel), OilBarrelsTolerance);
+            AssertEx.EqualTolerance(ThousandCubicFeetInOneCubicMeter, cubicmeter.As(VolumeUnit.ThousandCubicFoot), ThousandCubicFeetTolerance);
+            AssertEx.EqualTolerance(ThousandCubicMetersInOneCubicMeter, cubicmeter.As(VolumeUnit.ThousandCubicMeter), ThousandCubicMetersTolerance);
             AssertEx.EqualTolerance(UkTablespoonsInOneCubicMeter, cubicmeter.As(VolumeUnit.UkTablespoon), UkTablespoonsTolerance);
             AssertEx.EqualTolerance(UsBeerBarrelsInOneCubicMeter, cubicmeter.As(VolumeUnit.UsBeerBarrel), UsBeerBarrelsTolerance);
             AssertEx.EqualTolerance(UsCustomaryCupsInOneCubicMeter, cubicmeter.As(VolumeUnit.UsCustomaryCup), UsCustomaryCupsTolerance);
@@ -533,26 +541,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = Volume.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            Volume convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                Volume quantityToConvert = quantity;
+
+                Volume convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<VolumeUnit> quantityToConvert = quantity;
+
+                IQuantity<VolumeUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new Volume(value: 1, unit: Volume.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Volume(value: 1, unit: Volume.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<VolumeUnit> quantity = new Volume(value: 1, unit: Volume.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Volume(value: 1, unit: Volume.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new Volume(value: 1, unit: Volume.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new Volume(value: 1, unit: Volume.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<VolumeUnit> quantity = new Volume(value: 1, unit: Volume.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new Volume(value: 1, unit: Volume.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -567,7 +618,9 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 cm³", VolumeUnit.CubicCentimeter, 4.2)]
         [InlineData("en-US", "4.2 dm³", VolumeUnit.CubicDecimeter, 4.2)]
         [InlineData("en-US", "4.2 ft³", VolumeUnit.CubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 hm³", VolumeUnit.CubicHectometer, 4.2)]
         [InlineData("en-US", "4.2 in³", VolumeUnit.CubicInch, 4.2)]
+        [InlineData("en-US", "4.2 km³", VolumeUnit.CubicKilometer, 4.2)]
         [InlineData("en-US", "4.2 m³", VolumeUnit.CubicMeter, 4.2)]
         [InlineData("en-US", "4.2 µm³", VolumeUnit.CubicMicrometer, 4.2)]
         [InlineData("en-US", "4.2 mi³", VolumeUnit.CubicMile, 4.2)]
@@ -577,9 +630,10 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 dagal (U.S.)", VolumeUnit.DecausGallon, 4.2)]
         [InlineData("en-US", "4.2 dl", VolumeUnit.Deciliter, 4.2)]
         [InlineData("en-US", "4.2 dgal (U.S.)", VolumeUnit.DeciusGallon, 4.2)]
-        [InlineData("en-US", "4.2 hft³", VolumeUnit.HectocubicFoot, 4.2)]
         [InlineData("en-US", "4.2 hl", VolumeUnit.Hectoliter, 4.2)]
         [InlineData("en-US", "4.2 hgal (U.S.)", VolumeUnit.HectousGallon, 4.2)]
+        [InlineData("en-US", "4.2 Ccf", VolumeUnit.HundredCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 hft³", VolumeUnit.HundredCubicFoot, 4.2)]
         [InlineData("en-US", "4.2 bl (imp.)", VolumeUnit.ImperialBeerBarrel, 4.2)]
         [InlineData("en-US", "4.2 gal (imp.)", VolumeUnit.ImperialGallon, 4.2)]
         [InlineData("en-US", "4.2 oz (imp.)", VolumeUnit.ImperialOunce, 4.2)]
@@ -588,12 +642,10 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 pt", VolumeUnit.ImperialPint, 4.2)]
         [InlineData("en-US", "4.2 p", VolumeUnit.ImperialPint, 4.2)]
         [InlineData("en-US", "4.2 qt (imp.)", VolumeUnit.ImperialQuart, 4.2)]
-        [InlineData("en-US", "4.2 kft³", VolumeUnit.KilocubicFoot, 4.2)]
         [InlineData("en-US", "4.2 kgal (imp.)", VolumeUnit.KiloimperialGallon, 4.2)]
         [InlineData("en-US", "4.2 kl", VolumeUnit.Kiloliter, 4.2)]
         [InlineData("en-US", "4.2 kgal (U.S.)", VolumeUnit.KilousGallon, 4.2)]
         [InlineData("en-US", "4.2 l", VolumeUnit.Liter, 4.2)]
-        [InlineData("en-US", "4.2 Mft³", VolumeUnit.MegacubicFoot, 4.2)]
         [InlineData("en-US", "4.2 Mgal (imp.)", VolumeUnit.MegaimperialGallon, 4.2)]
         [InlineData("en-US", "4.2 Ml", VolumeUnit.Megaliter, 4.2)]
         [InlineData("en-US", "4.2 Mgal (U.S.)", VolumeUnit.MegausGallon, 4.2)]
@@ -614,8 +666,16 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 teaspoon", VolumeUnit.MetricTeaspoon, 4.2)]
         [InlineData("en-US", "4.2 µl", VolumeUnit.Microliter, 4.2)]
         [InlineData("en-US", "4.2 ml", VolumeUnit.Milliliter, 4.2)]
+        [InlineData("en-US", "4.2 MMcf", VolumeUnit.MillionCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 Mft³", VolumeUnit.MillionCubicFoot, 4.2)]
         [InlineData("en-US", "4.2 nl", VolumeUnit.Nanoliter, 4.2)]
         [InlineData("en-US", "4.2 bbl", VolumeUnit.OilBarrel, 4.2)]
+        [InlineData("en-US", "4.2 Mcf", VolumeUnit.ThousandCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 kcf", VolumeUnit.ThousandCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 kft³", VolumeUnit.ThousandCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 10³·m³", VolumeUnit.ThousandCubicMeter, 4.2)]
+        [InlineData("en-US", "4.2 kcm", VolumeUnit.ThousandCubicMeter, 4.2)]
+        [InlineData("en-US", "4.2 Kcm", VolumeUnit.ThousandCubicMeter, 4.2)]
         [InlineData("en-US", "4.2 tablespoon (U.K.)", VolumeUnit.UkTablespoon, 4.2)]
         [InlineData("en-US", "4.2 bl (U.S.)", VolumeUnit.UsBeerBarrel, 4.2)]
         [InlineData("en-US", "4.2 cup (U.S. customary)", VolumeUnit.UsCustomaryCup, 4.2)]
@@ -633,7 +693,9 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 см³", VolumeUnit.CubicCentimeter, 4.2)]
         [InlineData("ru-RU", "4,2 дм³", VolumeUnit.CubicDecimeter, 4.2)]
         [InlineData("ru-RU", "4,2 фут³", VolumeUnit.CubicFoot, 4.2)]
+        [InlineData("ru-RU", "4,2 гм³", VolumeUnit.CubicHectometer, 4.2)]
         [InlineData("ru-RU", "4,2 дюйм³", VolumeUnit.CubicInch, 4.2)]
+        [InlineData("ru-RU", "4,2 км³", VolumeUnit.CubicKilometer, 4.2)]
         [InlineData("ru-RU", "4,2 м³", VolumeUnit.CubicMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мкм³", VolumeUnit.CubicMicrometer, 4.2)]
         [InlineData("ru-RU", "4,2 миля³", VolumeUnit.CubicMile, 4.2)]
@@ -643,17 +705,14 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 даАмериканский галлон", VolumeUnit.DecausGallon, 4.2)]
         [InlineData("ru-RU", "4,2 дл", VolumeUnit.Deciliter, 4.2)]
         [InlineData("ru-RU", "4,2 дАмериканский галлон", VolumeUnit.DeciusGallon, 4.2)]
-        [InlineData("ru-RU", "4,2 гфут³", VolumeUnit.HectocubicFoot, 4.2)]
         [InlineData("ru-RU", "4,2 гл", VolumeUnit.Hectoliter, 4.2)]
         [InlineData("ru-RU", "4,2 гАмериканский галлон", VolumeUnit.HectousGallon, 4.2)]
         [InlineData("ru-RU", "4,2 Английский галлон", VolumeUnit.ImperialGallon, 4.2)]
         [InlineData("ru-RU", "4,2 Английская унция", VolumeUnit.ImperialOunce, 4.2)]
-        [InlineData("ru-RU", "4,2 кфут³", VolumeUnit.KilocubicFoot, 4.2)]
         [InlineData("ru-RU", "4,2 кАнглийский галлон", VolumeUnit.KiloimperialGallon, 4.2)]
         [InlineData("ru-RU", "4,2 кл", VolumeUnit.Kiloliter, 4.2)]
         [InlineData("ru-RU", "4,2 кАмериканский галлон", VolumeUnit.KilousGallon, 4.2)]
         [InlineData("ru-RU", "4,2 л", VolumeUnit.Liter, 4.2)]
-        [InlineData("ru-RU", "4,2 Мфут³", VolumeUnit.MegacubicFoot, 4.2)]
         [InlineData("ru-RU", "4,2 МАнглийский галлон", VolumeUnit.MegaimperialGallon, 4.2)]
         [InlineData("ru-RU", "4,2 Мл", VolumeUnit.Megaliter, 4.2)]
         [InlineData("ru-RU", "4,2 МАмериканский галлон", VolumeUnit.MegausGallon, 4.2)]
@@ -662,7 +721,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("ru-RU", "4,2 нл", VolumeUnit.Nanoliter, 4.2)]
         [InlineData("ru-RU", "4,2 Американский галлон", VolumeUnit.UsGallon, 4.2)]
         [InlineData("ru-RU", "4,2 Американская унция", VolumeUnit.UsOunce, 4.2)]
-        public void Parse(string culture, string quantityString, VolumeUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, VolumeUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = Volume.Parse(quantityString);
@@ -670,16 +729,6 @@ public void Parse(string culture, string quantityString, VolumeUnit expectedUnit
             Assert.Equal(expectedValue, parsed.Value);
         }
 
-        [Theory]
-        [InlineData("en-US", "1 hm³")] // [CubicHectometer, HectocubicMeter] 
-        [InlineData("en-US", "1 km³")] // [CubicKilometer, KilocubicMeter] 
-        [InlineData("ru-RU", "1 гм³")] // [CubicHectometer, HectocubicMeter] 
-        [InlineData("ru-RU", "1 км³")] // [CubicKilometer, KilocubicMeter] 
-        public void ParseWithAmbiguousAbbreviation(string culture, string quantityString)
-        {
-            Assert.Throws<AmbiguousUnitParseException>(() => Volume.Parse(quantityString, CultureInfo.GetCultureInfo(culture)));
-        }
-
         [Theory]
         [InlineData("en-US", "4.2 ac-ft", VolumeUnit.AcreFoot, 4.2)]
         [InlineData("en-US", "4.2 acre-foot", VolumeUnit.AcreFoot, 4.2)]
@@ -692,7 +741,9 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("en-US", "4.2 cm³", VolumeUnit.CubicCentimeter, 4.2)]
         [InlineData("en-US", "4.2 dm³", VolumeUnit.CubicDecimeter, 4.2)]
         [InlineData("en-US", "4.2 ft³", VolumeUnit.CubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 hm³", VolumeUnit.CubicHectometer, 4.2)]
         [InlineData("en-US", "4.2 in³", VolumeUnit.CubicInch, 4.2)]
+        [InlineData("en-US", "4.2 km³", VolumeUnit.CubicKilometer, 4.2)]
         [InlineData("en-US", "4.2 m³", VolumeUnit.CubicMeter, 4.2)]
         [InlineData("en-US", "4.2 µm³", VolumeUnit.CubicMicrometer, 4.2)]
         [InlineData("en-US", "4.2 mi³", VolumeUnit.CubicMile, 4.2)]
@@ -702,9 +753,10 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("en-US", "4.2 dagal (U.S.)", VolumeUnit.DecausGallon, 4.2)]
         [InlineData("en-US", "4.2 dl", VolumeUnit.Deciliter, 4.2)]
         [InlineData("en-US", "4.2 dgal (U.S.)", VolumeUnit.DeciusGallon, 4.2)]
-        [InlineData("en-US", "4.2 hft³", VolumeUnit.HectocubicFoot, 4.2)]
         [InlineData("en-US", "4.2 hl", VolumeUnit.Hectoliter, 4.2)]
         [InlineData("en-US", "4.2 hgal (U.S.)", VolumeUnit.HectousGallon, 4.2)]
+        [InlineData("en-US", "4.2 Ccf", VolumeUnit.HundredCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 hft³", VolumeUnit.HundredCubicFoot, 4.2)]
         [InlineData("en-US", "4.2 bl (imp.)", VolumeUnit.ImperialBeerBarrel, 4.2)]
         [InlineData("en-US", "4.2 gal (imp.)", VolumeUnit.ImperialGallon, 4.2)]
         [InlineData("en-US", "4.2 oz (imp.)", VolumeUnit.ImperialOunce, 4.2)]
@@ -713,12 +765,10 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("en-US", "4.2 pt", VolumeUnit.ImperialPint, 4.2)]
         [InlineData("en-US", "4.2 p", VolumeUnit.ImperialPint, 4.2)]
         [InlineData("en-US", "4.2 qt (imp.)", VolumeUnit.ImperialQuart, 4.2)]
-        [InlineData("en-US", "4.2 kft³", VolumeUnit.KilocubicFoot, 4.2)]
         [InlineData("en-US", "4.2 kgal (imp.)", VolumeUnit.KiloimperialGallon, 4.2)]
         [InlineData("en-US", "4.2 kl", VolumeUnit.Kiloliter, 4.2)]
         [InlineData("en-US", "4.2 kgal (U.S.)", VolumeUnit.KilousGallon, 4.2)]
         [InlineData("en-US", "4.2 l", VolumeUnit.Liter, 4.2)]
-        [InlineData("en-US", "4.2 Mft³", VolumeUnit.MegacubicFoot, 4.2)]
         [InlineData("en-US", "4.2 Mgal (imp.)", VolumeUnit.MegaimperialGallon, 4.2)]
         [InlineData("en-US", "4.2 Ml", VolumeUnit.Megaliter, 4.2)]
         [InlineData("en-US", "4.2 Mgal (U.S.)", VolumeUnit.MegausGallon, 4.2)]
@@ -739,8 +789,16 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("en-US", "4.2 teaspoon", VolumeUnit.MetricTeaspoon, 4.2)]
         [InlineData("en-US", "4.2 µl", VolumeUnit.Microliter, 4.2)]
         [InlineData("en-US", "4.2 ml", VolumeUnit.Milliliter, 4.2)]
+        [InlineData("en-US", "4.2 MMcf", VolumeUnit.MillionCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 Mft³", VolumeUnit.MillionCubicFoot, 4.2)]
         [InlineData("en-US", "4.2 nl", VolumeUnit.Nanoliter, 4.2)]
         [InlineData("en-US", "4.2 bbl", VolumeUnit.OilBarrel, 4.2)]
+        [InlineData("en-US", "4.2 Mcf", VolumeUnit.ThousandCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 kcf", VolumeUnit.ThousandCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 kft³", VolumeUnit.ThousandCubicFoot, 4.2)]
+        [InlineData("en-US", "4.2 10³·m³", VolumeUnit.ThousandCubicMeter, 4.2)]
+        [InlineData("en-US", "4.2 kcm", VolumeUnit.ThousandCubicMeter, 4.2)]
+        [InlineData("en-US", "4.2 Kcm", VolumeUnit.ThousandCubicMeter, 4.2)]
         [InlineData("en-US", "4.2 tablespoon (U.K.)", VolumeUnit.UkTablespoon, 4.2)]
         [InlineData("en-US", "4.2 bl (U.S.)", VolumeUnit.UsBeerBarrel, 4.2)]
         [InlineData("en-US", "4.2 cup (U.S. customary)", VolumeUnit.UsCustomaryCup, 4.2)]
@@ -758,7 +816,9 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("ru-RU", "4,2 см³", VolumeUnit.CubicCentimeter, 4.2)]
         [InlineData("ru-RU", "4,2 дм³", VolumeUnit.CubicDecimeter, 4.2)]
         [InlineData("ru-RU", "4,2 фут³", VolumeUnit.CubicFoot, 4.2)]
+        [InlineData("ru-RU", "4,2 гм³", VolumeUnit.CubicHectometer, 4.2)]
         [InlineData("ru-RU", "4,2 дюйм³", VolumeUnit.CubicInch, 4.2)]
+        [InlineData("ru-RU", "4,2 км³", VolumeUnit.CubicKilometer, 4.2)]
         [InlineData("ru-RU", "4,2 м³", VolumeUnit.CubicMeter, 4.2)]
         [InlineData("ru-RU", "4,2 мкм³", VolumeUnit.CubicMicrometer, 4.2)]
         [InlineData("ru-RU", "4,2 миля³", VolumeUnit.CubicMile, 4.2)]
@@ -768,17 +828,14 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("ru-RU", "4,2 даАмериканский галлон", VolumeUnit.DecausGallon, 4.2)]
         [InlineData("ru-RU", "4,2 дл", VolumeUnit.Deciliter, 4.2)]
         [InlineData("ru-RU", "4,2 дАмериканский галлон", VolumeUnit.DeciusGallon, 4.2)]
-        [InlineData("ru-RU", "4,2 гфут³", VolumeUnit.HectocubicFoot, 4.2)]
         [InlineData("ru-RU", "4,2 гл", VolumeUnit.Hectoliter, 4.2)]
         [InlineData("ru-RU", "4,2 гАмериканский галлон", VolumeUnit.HectousGallon, 4.2)]
         [InlineData("ru-RU", "4,2 Английский галлон", VolumeUnit.ImperialGallon, 4.2)]
         [InlineData("ru-RU", "4,2 Английская унция", VolumeUnit.ImperialOunce, 4.2)]
-        [InlineData("ru-RU", "4,2 кфут³", VolumeUnit.KilocubicFoot, 4.2)]
         [InlineData("ru-RU", "4,2 кАнглийский галлон", VolumeUnit.KiloimperialGallon, 4.2)]
         [InlineData("ru-RU", "4,2 кл", VolumeUnit.Kiloliter, 4.2)]
         [InlineData("ru-RU", "4,2 кАмериканский галлон", VolumeUnit.KilousGallon, 4.2)]
         [InlineData("ru-RU", "4,2 л", VolumeUnit.Liter, 4.2)]
-        [InlineData("ru-RU", "4,2 Мфут³", VolumeUnit.MegacubicFoot, 4.2)]
         [InlineData("ru-RU", "4,2 МАнглийский галлон", VolumeUnit.MegaimperialGallon, 4.2)]
         [InlineData("ru-RU", "4,2 Мл", VolumeUnit.Megaliter, 4.2)]
         [InlineData("ru-RU", "4,2 МАмериканский галлон", VolumeUnit.MegausGallon, 4.2)]
@@ -787,7 +844,7 @@ public void ParseWithAmbiguousAbbreviation(string culture, string quantityString
         [InlineData("ru-RU", "4,2 нл", VolumeUnit.Nanoliter, 4.2)]
         [InlineData("ru-RU", "4,2 Американский галлон", VolumeUnit.UsGallon, 4.2)]
         [InlineData("ru-RU", "4,2 Американская унция", VolumeUnit.UsOunce, 4.2)]
-        public void TryParse(string culture, string quantityString, VolumeUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, VolumeUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(Volume.TryParse(quantityString, out Volume parsed));
@@ -795,16 +852,6 @@ public void TryParse(string culture, string quantityString, VolumeUnit expectedU
             Assert.Equal(expectedValue, parsed.Value);
         }
 
-        [Theory]
-        [InlineData("en-US", "1 hm³")] // [CubicHectometer, HectocubicMeter] 
-        [InlineData("en-US", "1 km³")] // [CubicKilometer, KilocubicMeter] 
-        [InlineData("ru-RU", "1 гм³")] // [CubicHectometer, HectocubicMeter] 
-        [InlineData("ru-RU", "1 км³")] // [CubicKilometer, KilocubicMeter] 
-        public void TryParseWithAmbiguousAbbreviation(string culture, string quantityString)
-        {
-            Assert.False(Volume.TryParse(quantityString, CultureInfo.GetCultureInfo(culture), out _));
-        }
-
         [Theory]
         [InlineData("ac-ft", VolumeUnit.AcreFoot)]
         [InlineData("acre-foot", VolumeUnit.AcreFoot)]
@@ -817,7 +864,9 @@ public void TryParseWithAmbiguousAbbreviation(string culture, string quantityStr
         [InlineData("cm³", VolumeUnit.CubicCentimeter)]
         [InlineData("dm³", VolumeUnit.CubicDecimeter)]
         [InlineData("ft³", VolumeUnit.CubicFoot)]
+        [InlineData("hm³", VolumeUnit.CubicHectometer)]
         [InlineData("in³", VolumeUnit.CubicInch)]
+        [InlineData("km³", VolumeUnit.CubicKilometer)]
         [InlineData("m³", VolumeUnit.CubicMeter)]
         [InlineData("µm³", VolumeUnit.CubicMicrometer)]
         [InlineData("mi³", VolumeUnit.CubicMile)]
@@ -827,9 +876,10 @@ public void TryParseWithAmbiguousAbbreviation(string culture, string quantityStr
         [InlineData("dagal (U.S.)", VolumeUnit.DecausGallon)]
         [InlineData("dl", VolumeUnit.Deciliter)]
         [InlineData("dgal (U.S.)", VolumeUnit.DeciusGallon)]
-        [InlineData("hft³", VolumeUnit.HectocubicFoot)]
         [InlineData("hl", VolumeUnit.Hectoliter)]
         [InlineData("hgal (U.S.)", VolumeUnit.HectousGallon)]
+        [InlineData("Ccf", VolumeUnit.HundredCubicFoot)]
+        [InlineData("hft³", VolumeUnit.HundredCubicFoot)]
         [InlineData("bl (imp.)", VolumeUnit.ImperialBeerBarrel)]
         [InlineData("gal (imp.)", VolumeUnit.ImperialGallon)]
         [InlineData("oz (imp.)", VolumeUnit.ImperialOunce)]
@@ -838,12 +888,10 @@ public void TryParseWithAmbiguousAbbreviation(string culture, string quantityStr
         [InlineData("pt", VolumeUnit.ImperialPint)]
         [InlineData("p", VolumeUnit.ImperialPint)]
         [InlineData("qt (imp.)", VolumeUnit.ImperialQuart)]
-        [InlineData("kft³", VolumeUnit.KilocubicFoot)]
         [InlineData("kgal (imp.)", VolumeUnit.KiloimperialGallon)]
         [InlineData("kl", VolumeUnit.Kiloliter)]
         [InlineData("kgal (U.S.)", VolumeUnit.KilousGallon)]
         [InlineData("l", VolumeUnit.Liter)]
-        [InlineData("Mft³", VolumeUnit.MegacubicFoot)]
         [InlineData("Mgal (imp.)", VolumeUnit.MegaimperialGallon)]
         [InlineData("Ml", VolumeUnit.Megaliter)]
         [InlineData("Mgal (U.S.)", VolumeUnit.MegausGallon)]
@@ -864,8 +912,16 @@ public void TryParseWithAmbiguousAbbreviation(string culture, string quantityStr
         [InlineData("teaspoon", VolumeUnit.MetricTeaspoon)]
         [InlineData("µl", VolumeUnit.Microliter)]
         [InlineData("ml", VolumeUnit.Milliliter)]
+        [InlineData("MMcf", VolumeUnit.MillionCubicFoot)]
+        [InlineData("Mft³", VolumeUnit.MillionCubicFoot)]
         [InlineData("nl", VolumeUnit.Nanoliter)]
         [InlineData("bbl", VolumeUnit.OilBarrel)]
+        [InlineData("Mcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("kcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("kft³", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("10³·m³", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("kcm", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("Kcm", VolumeUnit.ThousandCubicMeter)]
         [InlineData("tablespoon (U.K.)", VolumeUnit.UkTablespoon)]
         [InlineData("bl (U.S.)", VolumeUnit.UsBeerBarrel)]
         [InlineData("cup (U.S. customary)", VolumeUnit.UsCustomaryCup)]
@@ -896,7 +952,9 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeUni
         [InlineData("cm³", VolumeUnit.CubicCentimeter)]
         [InlineData("dm³", VolumeUnit.CubicDecimeter)]
         [InlineData("ft³", VolumeUnit.CubicFoot)]
+        [InlineData("hm³", VolumeUnit.CubicHectometer)]
         [InlineData("in³", VolumeUnit.CubicInch)]
+        [InlineData("km³", VolumeUnit.CubicKilometer)]
         [InlineData("m³", VolumeUnit.CubicMeter)]
         [InlineData("µm³", VolumeUnit.CubicMicrometer)]
         [InlineData("mi³", VolumeUnit.CubicMile)]
@@ -906,9 +964,10 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeUni
         [InlineData("dagal (U.S.)", VolumeUnit.DecausGallon)]
         [InlineData("dl", VolumeUnit.Deciliter)]
         [InlineData("dgal (U.S.)", VolumeUnit.DeciusGallon)]
-        [InlineData("hft³", VolumeUnit.HectocubicFoot)]
         [InlineData("hl", VolumeUnit.Hectoliter)]
         [InlineData("hgal (U.S.)", VolumeUnit.HectousGallon)]
+        [InlineData("Ccf", VolumeUnit.HundredCubicFoot)]
+        [InlineData("hft³", VolumeUnit.HundredCubicFoot)]
         [InlineData("bl (imp.)", VolumeUnit.ImperialBeerBarrel)]
         [InlineData("gal (imp.)", VolumeUnit.ImperialGallon)]
         [InlineData("oz (imp.)", VolumeUnit.ImperialOunce)]
@@ -917,12 +976,10 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeUni
         [InlineData("pt", VolumeUnit.ImperialPint)]
         [InlineData("p", VolumeUnit.ImperialPint)]
         [InlineData("qt (imp.)", VolumeUnit.ImperialQuart)]
-        [InlineData("kft³", VolumeUnit.KilocubicFoot)]
         [InlineData("kgal (imp.)", VolumeUnit.KiloimperialGallon)]
         [InlineData("kl", VolumeUnit.Kiloliter)]
         [InlineData("kgal (U.S.)", VolumeUnit.KilousGallon)]
         [InlineData("l", VolumeUnit.Liter)]
-        [InlineData("Mft³", VolumeUnit.MegacubicFoot)]
         [InlineData("Mgal (imp.)", VolumeUnit.MegaimperialGallon)]
         [InlineData("Ml", VolumeUnit.Megaliter)]
         [InlineData("Mgal (U.S.)", VolumeUnit.MegausGallon)]
@@ -943,8 +1000,16 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeUni
         [InlineData("teaspoon", VolumeUnit.MetricTeaspoon)]
         [InlineData("µl", VolumeUnit.Microliter)]
         [InlineData("ml", VolumeUnit.Milliliter)]
+        [InlineData("MMcf", VolumeUnit.MillionCubicFoot)]
+        [InlineData("Mft³", VolumeUnit.MillionCubicFoot)]
         [InlineData("nl", VolumeUnit.Nanoliter)]
         [InlineData("bbl", VolumeUnit.OilBarrel)]
+        [InlineData("Mcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("kcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("kft³", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("10³·m³", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("kcm", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("Kcm", VolumeUnit.ThousandCubicMeter)]
         [InlineData("tablespoon (U.K.)", VolumeUnit.UkTablespoon)]
         [InlineData("bl (U.S.)", VolumeUnit.UsBeerBarrel)]
         [InlineData("cup (U.S. customary)", VolumeUnit.UsCustomaryCup)]
@@ -975,7 +1040,9 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "cm³", VolumeUnit.CubicCentimeter)]
         [InlineData("en-US", "dm³", VolumeUnit.CubicDecimeter)]
         [InlineData("en-US", "ft³", VolumeUnit.CubicFoot)]
+        [InlineData("en-US", "hm³", VolumeUnit.CubicHectometer)]
         [InlineData("en-US", "in³", VolumeUnit.CubicInch)]
+        [InlineData("en-US", "km³", VolumeUnit.CubicKilometer)]
         [InlineData("en-US", "m³", VolumeUnit.CubicMeter)]
         [InlineData("en-US", "µm³", VolumeUnit.CubicMicrometer)]
         [InlineData("en-US", "mi³", VolumeUnit.CubicMile)]
@@ -985,9 +1052,10 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "dagal (U.S.)", VolumeUnit.DecausGallon)]
         [InlineData("en-US", "dl", VolumeUnit.Deciliter)]
         [InlineData("en-US", "dgal (U.S.)", VolumeUnit.DeciusGallon)]
-        [InlineData("en-US", "hft³", VolumeUnit.HectocubicFoot)]
         [InlineData("en-US", "hl", VolumeUnit.Hectoliter)]
         [InlineData("en-US", "hgal (U.S.)", VolumeUnit.HectousGallon)]
+        [InlineData("en-US", "Ccf", VolumeUnit.HundredCubicFoot)]
+        [InlineData("en-US", "hft³", VolumeUnit.HundredCubicFoot)]
         [InlineData("en-US", "bl (imp.)", VolumeUnit.ImperialBeerBarrel)]
         [InlineData("en-US", "gal (imp.)", VolumeUnit.ImperialGallon)]
         [InlineData("en-US", "oz (imp.)", VolumeUnit.ImperialOunce)]
@@ -996,12 +1064,10 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "pt", VolumeUnit.ImperialPint)]
         [InlineData("en-US", "p", VolumeUnit.ImperialPint)]
         [InlineData("en-US", "qt (imp.)", VolumeUnit.ImperialQuart)]
-        [InlineData("en-US", "kft³", VolumeUnit.KilocubicFoot)]
         [InlineData("en-US", "kgal (imp.)", VolumeUnit.KiloimperialGallon)]
         [InlineData("en-US", "kl", VolumeUnit.Kiloliter)]
         [InlineData("en-US", "kgal (U.S.)", VolumeUnit.KilousGallon)]
         [InlineData("en-US", "l", VolumeUnit.Liter)]
-        [InlineData("en-US", "Mft³", VolumeUnit.MegacubicFoot)]
         [InlineData("en-US", "Mgal (imp.)", VolumeUnit.MegaimperialGallon)]
         [InlineData("en-US", "Ml", VolumeUnit.Megaliter)]
         [InlineData("en-US", "Mgal (U.S.)", VolumeUnit.MegausGallon)]
@@ -1022,8 +1088,16 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("en-US", "teaspoon", VolumeUnit.MetricTeaspoon)]
         [InlineData("en-US", "µl", VolumeUnit.Microliter)]
         [InlineData("en-US", "ml", VolumeUnit.Milliliter)]
+        [InlineData("en-US", "MMcf", VolumeUnit.MillionCubicFoot)]
+        [InlineData("en-US", "Mft³", VolumeUnit.MillionCubicFoot)]
         [InlineData("en-US", "nl", VolumeUnit.Nanoliter)]
         [InlineData("en-US", "bbl", VolumeUnit.OilBarrel)]
+        [InlineData("en-US", "Mcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "kcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "kft³", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "10³·m³", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("en-US", "kcm", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("en-US", "Kcm", VolumeUnit.ThousandCubicMeter)]
         [InlineData("en-US", "tablespoon (U.K.)", VolumeUnit.UkTablespoon)]
         [InlineData("en-US", "bl (U.S.)", VolumeUnit.UsBeerBarrel)]
         [InlineData("en-US", "cup (U.S. customary)", VolumeUnit.UsCustomaryCup)]
@@ -1041,7 +1115,9 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("ru-RU", "см³", VolumeUnit.CubicCentimeter)]
         [InlineData("ru-RU", "дм³", VolumeUnit.CubicDecimeter)]
         [InlineData("ru-RU", "фут³", VolumeUnit.CubicFoot)]
+        [InlineData("ru-RU", "гм³", VolumeUnit.CubicHectometer)]
         [InlineData("ru-RU", "дюйм³", VolumeUnit.CubicInch)]
+        [InlineData("ru-RU", "км³", VolumeUnit.CubicKilometer)]
         [InlineData("ru-RU", "м³", VolumeUnit.CubicMeter)]
         [InlineData("ru-RU", "мкм³", VolumeUnit.CubicMicrometer)]
         [InlineData("ru-RU", "миля³", VolumeUnit.CubicMile)]
@@ -1051,17 +1127,14 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
         [InlineData("ru-RU", "даАмериканский галлон", VolumeUnit.DecausGallon)]
         [InlineData("ru-RU", "дл", VolumeUnit.Deciliter)]
         [InlineData("ru-RU", "дАмериканский галлон", VolumeUnit.DeciusGallon)]
-        [InlineData("ru-RU", "гфут³", VolumeUnit.HectocubicFoot)]
         [InlineData("ru-RU", "гл", VolumeUnit.Hectoliter)]
         [InlineData("ru-RU", "гАмериканский галлон", VolumeUnit.HectousGallon)]
         [InlineData("ru-RU", "Английский галлон", VolumeUnit.ImperialGallon)]
         [InlineData("ru-RU", "Английская унция", VolumeUnit.ImperialOunce)]
-        [InlineData("ru-RU", "кфут³", VolumeUnit.KilocubicFoot)]
         [InlineData("ru-RU", "кАнглийский галлон", VolumeUnit.KiloimperialGallon)]
         [InlineData("ru-RU", "кл", VolumeUnit.Kiloliter)]
         [InlineData("ru-RU", "кАмериканский галлон", VolumeUnit.KilousGallon)]
         [InlineData("ru-RU", "л", VolumeUnit.Liter)]
-        [InlineData("ru-RU", "Мфут³", VolumeUnit.MegacubicFoot)]
         [InlineData("ru-RU", "МАнглийский галлон", VolumeUnit.MegaimperialGallon)]
         [InlineData("ru-RU", "Мл", VolumeUnit.Megaliter)]
         [InlineData("ru-RU", "МАмериканский галлон", VolumeUnit.MegausGallon)]
@@ -1089,7 +1162,9 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo
         [InlineData("en-US", "cm³", VolumeUnit.CubicCentimeter)]
         [InlineData("en-US", "dm³", VolumeUnit.CubicDecimeter)]
         [InlineData("en-US", "ft³", VolumeUnit.CubicFoot)]
+        [InlineData("en-US", "hm³", VolumeUnit.CubicHectometer)]
         [InlineData("en-US", "in³", VolumeUnit.CubicInch)]
+        [InlineData("en-US", "km³", VolumeUnit.CubicKilometer)]
         [InlineData("en-US", "m³", VolumeUnit.CubicMeter)]
         [InlineData("en-US", "µm³", VolumeUnit.CubicMicrometer)]
         [InlineData("en-US", "mi³", VolumeUnit.CubicMile)]
@@ -1099,9 +1174,10 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo
         [InlineData("en-US", "dagal (U.S.)", VolumeUnit.DecausGallon)]
         [InlineData("en-US", "dl", VolumeUnit.Deciliter)]
         [InlineData("en-US", "dgal (U.S.)", VolumeUnit.DeciusGallon)]
-        [InlineData("en-US", "hft³", VolumeUnit.HectocubicFoot)]
         [InlineData("en-US", "hl", VolumeUnit.Hectoliter)]
         [InlineData("en-US", "hgal (U.S.)", VolumeUnit.HectousGallon)]
+        [InlineData("en-US", "Ccf", VolumeUnit.HundredCubicFoot)]
+        [InlineData("en-US", "hft³", VolumeUnit.HundredCubicFoot)]
         [InlineData("en-US", "bl (imp.)", VolumeUnit.ImperialBeerBarrel)]
         [InlineData("en-US", "gal (imp.)", VolumeUnit.ImperialGallon)]
         [InlineData("en-US", "oz (imp.)", VolumeUnit.ImperialOunce)]
@@ -1110,12 +1186,10 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo
         [InlineData("en-US", "pt", VolumeUnit.ImperialPint)]
         [InlineData("en-US", "p", VolumeUnit.ImperialPint)]
         [InlineData("en-US", "qt (imp.)", VolumeUnit.ImperialQuart)]
-        [InlineData("en-US", "kft³", VolumeUnit.KilocubicFoot)]
         [InlineData("en-US", "kgal (imp.)", VolumeUnit.KiloimperialGallon)]
         [InlineData("en-US", "kl", VolumeUnit.Kiloliter)]
         [InlineData("en-US", "kgal (U.S.)", VolumeUnit.KilousGallon)]
         [InlineData("en-US", "l", VolumeUnit.Liter)]
-        [InlineData("en-US", "Mft³", VolumeUnit.MegacubicFoot)]
         [InlineData("en-US", "Mgal (imp.)", VolumeUnit.MegaimperialGallon)]
         [InlineData("en-US", "Ml", VolumeUnit.Megaliter)]
         [InlineData("en-US", "Mgal (U.S.)", VolumeUnit.MegausGallon)]
@@ -1136,8 +1210,16 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo
         [InlineData("en-US", "teaspoon", VolumeUnit.MetricTeaspoon)]
         [InlineData("en-US", "µl", VolumeUnit.Microliter)]
         [InlineData("en-US", "ml", VolumeUnit.Milliliter)]
+        [InlineData("en-US", "MMcf", VolumeUnit.MillionCubicFoot)]
+        [InlineData("en-US", "Mft³", VolumeUnit.MillionCubicFoot)]
         [InlineData("en-US", "nl", VolumeUnit.Nanoliter)]
         [InlineData("en-US", "bbl", VolumeUnit.OilBarrel)]
+        [InlineData("en-US", "Mcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "kcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "kft³", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "10³·m³", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("en-US", "kcm", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("en-US", "Kcm", VolumeUnit.ThousandCubicMeter)]
         [InlineData("en-US", "tablespoon (U.K.)", VolumeUnit.UkTablespoon)]
         [InlineData("en-US", "bl (U.S.)", VolumeUnit.UsBeerBarrel)]
         [InlineData("en-US", "cup (U.S. customary)", VolumeUnit.UsCustomaryCup)]
@@ -1155,7 +1237,9 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo
         [InlineData("ru-RU", "см³", VolumeUnit.CubicCentimeter)]
         [InlineData("ru-RU", "дм³", VolumeUnit.CubicDecimeter)]
         [InlineData("ru-RU", "фут³", VolumeUnit.CubicFoot)]
+        [InlineData("ru-RU", "гм³", VolumeUnit.CubicHectometer)]
         [InlineData("ru-RU", "дюйм³", VolumeUnit.CubicInch)]
+        [InlineData("ru-RU", "км³", VolumeUnit.CubicKilometer)]
         [InlineData("ru-RU", "м³", VolumeUnit.CubicMeter)]
         [InlineData("ru-RU", "мкм³", VolumeUnit.CubicMicrometer)]
         [InlineData("ru-RU", "миля³", VolumeUnit.CubicMile)]
@@ -1165,17 +1249,14 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo
         [InlineData("ru-RU", "даАмериканский галлон", VolumeUnit.DecausGallon)]
         [InlineData("ru-RU", "дл", VolumeUnit.Deciliter)]
         [InlineData("ru-RU", "дАмериканский галлон", VolumeUnit.DeciusGallon)]
-        [InlineData("ru-RU", "гфут³", VolumeUnit.HectocubicFoot)]
         [InlineData("ru-RU", "гл", VolumeUnit.Hectoliter)]
         [InlineData("ru-RU", "гАмериканский галлон", VolumeUnit.HectousGallon)]
         [InlineData("ru-RU", "Английский галлон", VolumeUnit.ImperialGallon)]
         [InlineData("ru-RU", "Английская унция", VolumeUnit.ImperialOunce)]
-        [InlineData("ru-RU", "кфут³", VolumeUnit.KilocubicFoot)]
         [InlineData("ru-RU", "кАнглийский галлон", VolumeUnit.KiloimperialGallon)]
         [InlineData("ru-RU", "кл", VolumeUnit.Kiloliter)]
         [InlineData("ru-RU", "кАмериканский галлон", VolumeUnit.KilousGallon)]
         [InlineData("ru-RU", "л", VolumeUnit.Liter)]
-        [InlineData("ru-RU", "Мфут³", VolumeUnit.MegacubicFoot)]
         [InlineData("ru-RU", "МАнглийский галлон", VolumeUnit.MegaimperialGallon)]
         [InlineData("ru-RU", "Мл", VolumeUnit.Megaliter)]
         [InlineData("ru-RU", "МАмериканский галлон", VolumeUnit.MegausGallon)]
@@ -1190,16 +1271,6 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, VolumeUni
             Assert.Equal(expectedUnit, parsedUnit);
         }
 
-        [Theory]
-        [InlineData("en-US", "hm³")] // [CubicHectometer, HectocubicMeter]
-        [InlineData("en-US", "km³")] // [CubicKilometer, KilocubicMeter]
-        [InlineData("ru-RU", "гм³")] // [CubicHectometer, HectocubicMeter]
-        [InlineData("ru-RU", "км³")] // [CubicKilometer, KilocubicMeter]
-        public void ParseUnitWithAmbiguousAbbreviation(string culture, string abbreviation)
-        {
-            Assert.Throws<AmbiguousUnitParseException>(() => Volume.ParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture)));
-        }
-
         [Theory]
         [InlineData("ac-ft", VolumeUnit.AcreFoot)]
         [InlineData("acre-foot", VolumeUnit.AcreFoot)]
@@ -1212,7 +1283,9 @@ public void ParseUnitWithAmbiguousAbbreviation(string culture, string abbreviati
         [InlineData("cm³", VolumeUnit.CubicCentimeter)]
         [InlineData("dm³", VolumeUnit.CubicDecimeter)]
         [InlineData("ft³", VolumeUnit.CubicFoot)]
+        [InlineData("hm³", VolumeUnit.CubicHectometer)]
         [InlineData("in³", VolumeUnit.CubicInch)]
+        [InlineData("km³", VolumeUnit.CubicKilometer)]
         [InlineData("m³", VolumeUnit.CubicMeter)]
         [InlineData("µm³", VolumeUnit.CubicMicrometer)]
         [InlineData("mi³", VolumeUnit.CubicMile)]
@@ -1222,9 +1295,10 @@ public void ParseUnitWithAmbiguousAbbreviation(string culture, string abbreviati
         [InlineData("dagal (U.S.)", VolumeUnit.DecausGallon)]
         [InlineData("dl", VolumeUnit.Deciliter)]
         [InlineData("dgal (U.S.)", VolumeUnit.DeciusGallon)]
-        [InlineData("hft³", VolumeUnit.HectocubicFoot)]
         [InlineData("hl", VolumeUnit.Hectoliter)]
         [InlineData("hgal (U.S.)", VolumeUnit.HectousGallon)]
+        [InlineData("Ccf", VolumeUnit.HundredCubicFoot)]
+        [InlineData("hft³", VolumeUnit.HundredCubicFoot)]
         [InlineData("bl (imp.)", VolumeUnit.ImperialBeerBarrel)]
         [InlineData("gal (imp.)", VolumeUnit.ImperialGallon)]
         [InlineData("oz (imp.)", VolumeUnit.ImperialOunce)]
@@ -1233,12 +1307,10 @@ public void ParseUnitWithAmbiguousAbbreviation(string culture, string abbreviati
         [InlineData("pt", VolumeUnit.ImperialPint)]
         [InlineData("p", VolumeUnit.ImperialPint)]
         [InlineData("qt (imp.)", VolumeUnit.ImperialQuart)]
-        [InlineData("kft³", VolumeUnit.KilocubicFoot)]
         [InlineData("kgal (imp.)", VolumeUnit.KiloimperialGallon)]
         [InlineData("kl", VolumeUnit.Kiloliter)]
         [InlineData("kgal (U.S.)", VolumeUnit.KilousGallon)]
         [InlineData("l", VolumeUnit.Liter)]
-        [InlineData("Mft³", VolumeUnit.MegacubicFoot)]
         [InlineData("Mgal (imp.)", VolumeUnit.MegaimperialGallon)]
         [InlineData("Ml", VolumeUnit.Megaliter)]
         [InlineData("Mgal (U.S.)", VolumeUnit.MegausGallon)]
@@ -1259,8 +1331,16 @@ public void ParseUnitWithAmbiguousAbbreviation(string culture, string abbreviati
         [InlineData("teaspoon", VolumeUnit.MetricTeaspoon)]
         [InlineData("µl", VolumeUnit.Microliter)]
         [InlineData("ml", VolumeUnit.Milliliter)]
+        [InlineData("MMcf", VolumeUnit.MillionCubicFoot)]
+        [InlineData("Mft³", VolumeUnit.MillionCubicFoot)]
         [InlineData("nl", VolumeUnit.Nanoliter)]
         [InlineData("bbl", VolumeUnit.OilBarrel)]
+        [InlineData("Mcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("kcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("kft³", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("10³·m³", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("kcm", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("Kcm", VolumeUnit.ThousandCubicMeter)]
         [InlineData("tablespoon (U.K.)", VolumeUnit.UkTablespoon)]
         [InlineData("bl (U.S.)", VolumeUnit.UsBeerBarrel)]
         [InlineData("cup (U.S. customary)", VolumeUnit.UsCustomaryCup)]
@@ -1291,7 +1371,9 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Volume
         [InlineData("cm³", VolumeUnit.CubicCentimeter)]
         [InlineData("dm³", VolumeUnit.CubicDecimeter)]
         [InlineData("ft³", VolumeUnit.CubicFoot)]
+        [InlineData("hm³", VolumeUnit.CubicHectometer)]
         [InlineData("in³", VolumeUnit.CubicInch)]
+        [InlineData("km³", VolumeUnit.CubicKilometer)]
         [InlineData("m³", VolumeUnit.CubicMeter)]
         [InlineData("µm³", VolumeUnit.CubicMicrometer)]
         [InlineData("mi³", VolumeUnit.CubicMile)]
@@ -1301,9 +1383,10 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Volume
         [InlineData("dagal (U.S.)", VolumeUnit.DecausGallon)]
         [InlineData("dl", VolumeUnit.Deciliter)]
         [InlineData("dgal (U.S.)", VolumeUnit.DeciusGallon)]
-        [InlineData("hft³", VolumeUnit.HectocubicFoot)]
         [InlineData("hl", VolumeUnit.Hectoliter)]
         [InlineData("hgal (U.S.)", VolumeUnit.HectousGallon)]
+        [InlineData("Ccf", VolumeUnit.HundredCubicFoot)]
+        [InlineData("hft³", VolumeUnit.HundredCubicFoot)]
         [InlineData("bl (imp.)", VolumeUnit.ImperialBeerBarrel)]
         [InlineData("gal (imp.)", VolumeUnit.ImperialGallon)]
         [InlineData("oz (imp.)", VolumeUnit.ImperialOunce)]
@@ -1312,12 +1395,10 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Volume
         [InlineData("pt", VolumeUnit.ImperialPint)]
         [InlineData("p", VolumeUnit.ImperialPint)]
         [InlineData("qt (imp.)", VolumeUnit.ImperialQuart)]
-        [InlineData("kft³", VolumeUnit.KilocubicFoot)]
         [InlineData("kgal (imp.)", VolumeUnit.KiloimperialGallon)]
         [InlineData("kl", VolumeUnit.Kiloliter)]
         [InlineData("kgal (U.S.)", VolumeUnit.KilousGallon)]
         [InlineData("l", VolumeUnit.Liter)]
-        [InlineData("Mft³", VolumeUnit.MegacubicFoot)]
         [InlineData("Mgal (imp.)", VolumeUnit.MegaimperialGallon)]
         [InlineData("Ml", VolumeUnit.Megaliter)]
         [InlineData("Mgal (U.S.)", VolumeUnit.MegausGallon)]
@@ -1338,8 +1419,16 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Volume
         [InlineData("teaspoon", VolumeUnit.MetricTeaspoon)]
         [InlineData("µl", VolumeUnit.Microliter)]
         [InlineData("ml", VolumeUnit.Milliliter)]
+        [InlineData("MMcf", VolumeUnit.MillionCubicFoot)]
+        [InlineData("Mft³", VolumeUnit.MillionCubicFoot)]
         [InlineData("nl", VolumeUnit.Nanoliter)]
         [InlineData("bbl", VolumeUnit.OilBarrel)]
+        [InlineData("Mcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("kcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("kft³", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("10³·m³", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("kcm", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("Kcm", VolumeUnit.ThousandCubicMeter)]
         [InlineData("tablespoon (U.K.)", VolumeUnit.UkTablespoon)]
         [InlineData("bl (U.S.)", VolumeUnit.UsBeerBarrel)]
         [InlineData("cup (U.S. customary)", VolumeUnit.UsCustomaryCup)]
@@ -1370,7 +1459,9 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "cm³", VolumeUnit.CubicCentimeter)]
         [InlineData("en-US", "dm³", VolumeUnit.CubicDecimeter)]
         [InlineData("en-US", "ft³", VolumeUnit.CubicFoot)]
+        [InlineData("en-US", "hm³", VolumeUnit.CubicHectometer)]
         [InlineData("en-US", "in³", VolumeUnit.CubicInch)]
+        [InlineData("en-US", "km³", VolumeUnit.CubicKilometer)]
         [InlineData("en-US", "m³", VolumeUnit.CubicMeter)]
         [InlineData("en-US", "µm³", VolumeUnit.CubicMicrometer)]
         [InlineData("en-US", "mi³", VolumeUnit.CubicMile)]
@@ -1380,9 +1471,10 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "dagal (U.S.)", VolumeUnit.DecausGallon)]
         [InlineData("en-US", "dl", VolumeUnit.Deciliter)]
         [InlineData("en-US", "dgal (U.S.)", VolumeUnit.DeciusGallon)]
-        [InlineData("en-US", "hft³", VolumeUnit.HectocubicFoot)]
         [InlineData("en-US", "hl", VolumeUnit.Hectoliter)]
         [InlineData("en-US", "hgal (U.S.)", VolumeUnit.HectousGallon)]
+        [InlineData("en-US", "Ccf", VolumeUnit.HundredCubicFoot)]
+        [InlineData("en-US", "hft³", VolumeUnit.HundredCubicFoot)]
         [InlineData("en-US", "bl (imp.)", VolumeUnit.ImperialBeerBarrel)]
         [InlineData("en-US", "gal (imp.)", VolumeUnit.ImperialGallon)]
         [InlineData("en-US", "oz (imp.)", VolumeUnit.ImperialOunce)]
@@ -1391,12 +1483,10 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "pt", VolumeUnit.ImperialPint)]
         [InlineData("en-US", "p", VolumeUnit.ImperialPint)]
         [InlineData("en-US", "qt (imp.)", VolumeUnit.ImperialQuart)]
-        [InlineData("en-US", "kft³", VolumeUnit.KilocubicFoot)]
         [InlineData("en-US", "kgal (imp.)", VolumeUnit.KiloimperialGallon)]
         [InlineData("en-US", "kl", VolumeUnit.Kiloliter)]
         [InlineData("en-US", "kgal (U.S.)", VolumeUnit.KilousGallon)]
         [InlineData("en-US", "l", VolumeUnit.Liter)]
-        [InlineData("en-US", "Mft³", VolumeUnit.MegacubicFoot)]
         [InlineData("en-US", "Mgal (imp.)", VolumeUnit.MegaimperialGallon)]
         [InlineData("en-US", "Ml", VolumeUnit.Megaliter)]
         [InlineData("en-US", "Mgal (U.S.)", VolumeUnit.MegausGallon)]
@@ -1417,8 +1507,16 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("en-US", "teaspoon", VolumeUnit.MetricTeaspoon)]
         [InlineData("en-US", "µl", VolumeUnit.Microliter)]
         [InlineData("en-US", "ml", VolumeUnit.Milliliter)]
+        [InlineData("en-US", "MMcf", VolumeUnit.MillionCubicFoot)]
+        [InlineData("en-US", "Mft³", VolumeUnit.MillionCubicFoot)]
         [InlineData("en-US", "nl", VolumeUnit.Nanoliter)]
         [InlineData("en-US", "bbl", VolumeUnit.OilBarrel)]
+        [InlineData("en-US", "Mcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "kcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "kft³", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "10³·m³", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("en-US", "kcm", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("en-US", "Kcm", VolumeUnit.ThousandCubicMeter)]
         [InlineData("en-US", "tablespoon (U.K.)", VolumeUnit.UkTablespoon)]
         [InlineData("en-US", "bl (U.S.)", VolumeUnit.UsBeerBarrel)]
         [InlineData("en-US", "cup (U.S. customary)", VolumeUnit.UsCustomaryCup)]
@@ -1436,7 +1534,9 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("ru-RU", "см³", VolumeUnit.CubicCentimeter)]
         [InlineData("ru-RU", "дм³", VolumeUnit.CubicDecimeter)]
         [InlineData("ru-RU", "фут³", VolumeUnit.CubicFoot)]
+        [InlineData("ru-RU", "гм³", VolumeUnit.CubicHectometer)]
         [InlineData("ru-RU", "дюйм³", VolumeUnit.CubicInch)]
+        [InlineData("ru-RU", "км³", VolumeUnit.CubicKilometer)]
         [InlineData("ru-RU", "м³", VolumeUnit.CubicMeter)]
         [InlineData("ru-RU", "мкм³", VolumeUnit.CubicMicrometer)]
         [InlineData("ru-RU", "миля³", VolumeUnit.CubicMile)]
@@ -1446,17 +1546,14 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
         [InlineData("ru-RU", "даАмериканский галлон", VolumeUnit.DecausGallon)]
         [InlineData("ru-RU", "дл", VolumeUnit.Deciliter)]
         [InlineData("ru-RU", "дАмериканский галлон", VolumeUnit.DeciusGallon)]
-        [InlineData("ru-RU", "гфут³", VolumeUnit.HectocubicFoot)]
         [InlineData("ru-RU", "гл", VolumeUnit.Hectoliter)]
         [InlineData("ru-RU", "гАмериканский галлон", VolumeUnit.HectousGallon)]
         [InlineData("ru-RU", "Английский галлон", VolumeUnit.ImperialGallon)]
         [InlineData("ru-RU", "Английская унция", VolumeUnit.ImperialOunce)]
-        [InlineData("ru-RU", "кфут³", VolumeUnit.KilocubicFoot)]
         [InlineData("ru-RU", "кАнглийский галлон", VolumeUnit.KiloimperialGallon)]
         [InlineData("ru-RU", "кл", VolumeUnit.Kiloliter)]
         [InlineData("ru-RU", "кАмериканский галлон", VolumeUnit.KilousGallon)]
         [InlineData("ru-RU", "л", VolumeUnit.Liter)]
-        [InlineData("ru-RU", "Мфут³", VolumeUnit.MegacubicFoot)]
         [InlineData("ru-RU", "МАнглийский галлон", VolumeUnit.MegaimperialGallon)]
         [InlineData("ru-RU", "Мл", VolumeUnit.Megaliter)]
         [InlineData("ru-RU", "МАмериканский галлон", VolumeUnit.MegausGallon)]
@@ -1484,7 +1581,9 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "cm³", VolumeUnit.CubicCentimeter)]
         [InlineData("en-US", "dm³", VolumeUnit.CubicDecimeter)]
         [InlineData("en-US", "ft³", VolumeUnit.CubicFoot)]
+        [InlineData("en-US", "hm³", VolumeUnit.CubicHectometer)]
         [InlineData("en-US", "in³", VolumeUnit.CubicInch)]
+        [InlineData("en-US", "km³", VolumeUnit.CubicKilometer)]
         [InlineData("en-US", "m³", VolumeUnit.CubicMeter)]
         [InlineData("en-US", "µm³", VolumeUnit.CubicMicrometer)]
         [InlineData("en-US", "mi³", VolumeUnit.CubicMile)]
@@ -1494,9 +1593,10 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "dagal (U.S.)", VolumeUnit.DecausGallon)]
         [InlineData("en-US", "dl", VolumeUnit.Deciliter)]
         [InlineData("en-US", "dgal (U.S.)", VolumeUnit.DeciusGallon)]
-        [InlineData("en-US", "hft³", VolumeUnit.HectocubicFoot)]
         [InlineData("en-US", "hl", VolumeUnit.Hectoliter)]
         [InlineData("en-US", "hgal (U.S.)", VolumeUnit.HectousGallon)]
+        [InlineData("en-US", "Ccf", VolumeUnit.HundredCubicFoot)]
+        [InlineData("en-US", "hft³", VolumeUnit.HundredCubicFoot)]
         [InlineData("en-US", "bl (imp.)", VolumeUnit.ImperialBeerBarrel)]
         [InlineData("en-US", "gal (imp.)", VolumeUnit.ImperialGallon)]
         [InlineData("en-US", "oz (imp.)", VolumeUnit.ImperialOunce)]
@@ -1505,12 +1605,10 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "pt", VolumeUnit.ImperialPint)]
         [InlineData("en-US", "p", VolumeUnit.ImperialPint)]
         [InlineData("en-US", "qt (imp.)", VolumeUnit.ImperialQuart)]
-        [InlineData("en-US", "kft³", VolumeUnit.KilocubicFoot)]
         [InlineData("en-US", "kgal (imp.)", VolumeUnit.KiloimperialGallon)]
         [InlineData("en-US", "kl", VolumeUnit.Kiloliter)]
         [InlineData("en-US", "kgal (U.S.)", VolumeUnit.KilousGallon)]
         [InlineData("en-US", "l", VolumeUnit.Liter)]
-        [InlineData("en-US", "Mft³", VolumeUnit.MegacubicFoot)]
         [InlineData("en-US", "Mgal (imp.)", VolumeUnit.MegaimperialGallon)]
         [InlineData("en-US", "Ml", VolumeUnit.Megaliter)]
         [InlineData("en-US", "Mgal (U.S.)", VolumeUnit.MegausGallon)]
@@ -1531,8 +1629,16 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("en-US", "teaspoon", VolumeUnit.MetricTeaspoon)]
         [InlineData("en-US", "µl", VolumeUnit.Microliter)]
         [InlineData("en-US", "ml", VolumeUnit.Milliliter)]
+        [InlineData("en-US", "MMcf", VolumeUnit.MillionCubicFoot)]
+        [InlineData("en-US", "Mft³", VolumeUnit.MillionCubicFoot)]
         [InlineData("en-US", "nl", VolumeUnit.Nanoliter)]
         [InlineData("en-US", "bbl", VolumeUnit.OilBarrel)]
+        [InlineData("en-US", "Mcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "kcf", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "kft³", VolumeUnit.ThousandCubicFoot)]
+        [InlineData("en-US", "10³·m³", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("en-US", "kcm", VolumeUnit.ThousandCubicMeter)]
+        [InlineData("en-US", "Kcm", VolumeUnit.ThousandCubicMeter)]
         [InlineData("en-US", "tablespoon (U.K.)", VolumeUnit.UkTablespoon)]
         [InlineData("en-US", "bl (U.S.)", VolumeUnit.UsBeerBarrel)]
         [InlineData("en-US", "cup (U.S. customary)", VolumeUnit.UsCustomaryCup)]
@@ -1550,7 +1656,9 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("ru-RU", "см³", VolumeUnit.CubicCentimeter)]
         [InlineData("ru-RU", "дм³", VolumeUnit.CubicDecimeter)]
         [InlineData("ru-RU", "фут³", VolumeUnit.CubicFoot)]
+        [InlineData("ru-RU", "гм³", VolumeUnit.CubicHectometer)]
         [InlineData("ru-RU", "дюйм³", VolumeUnit.CubicInch)]
+        [InlineData("ru-RU", "км³", VolumeUnit.CubicKilometer)]
         [InlineData("ru-RU", "м³", VolumeUnit.CubicMeter)]
         [InlineData("ru-RU", "мкм³", VolumeUnit.CubicMicrometer)]
         [InlineData("ru-RU", "миля³", VolumeUnit.CubicMile)]
@@ -1560,17 +1668,14 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
         [InlineData("ru-RU", "даАмериканский галлон", VolumeUnit.DecausGallon)]
         [InlineData("ru-RU", "дл", VolumeUnit.Deciliter)]
         [InlineData("ru-RU", "дАмериканский галлон", VolumeUnit.DeciusGallon)]
-        [InlineData("ru-RU", "гфут³", VolumeUnit.HectocubicFoot)]
         [InlineData("ru-RU", "гл", VolumeUnit.Hectoliter)]
         [InlineData("ru-RU", "гАмериканский галлон", VolumeUnit.HectousGallon)]
         [InlineData("ru-RU", "Английский галлон", VolumeUnit.ImperialGallon)]
         [InlineData("ru-RU", "Английская унция", VolumeUnit.ImperialOunce)]
-        [InlineData("ru-RU", "кфут³", VolumeUnit.KilocubicFoot)]
         [InlineData("ru-RU", "кАнглийский галлон", VolumeUnit.KiloimperialGallon)]
         [InlineData("ru-RU", "кл", VolumeUnit.Kiloliter)]
         [InlineData("ru-RU", "кАмериканский галлон", VolumeUnit.KilousGallon)]
         [InlineData("ru-RU", "л", VolumeUnit.Liter)]
-        [InlineData("ru-RU", "Мфут³", VolumeUnit.MegacubicFoot)]
         [InlineData("ru-RU", "МАнглийский галлон", VolumeUnit.MegaimperialGallon)]
         [InlineData("ru-RU", "Мл", VolumeUnit.Megaliter)]
         [InlineData("ru-RU", "МАмериканский галлон", VolumeUnit.MegausGallon)]
@@ -1585,16 +1690,6 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Volume
             Assert.Equal(expectedUnit, parsedUnit);
         }
 
-        [Theory]
-        [InlineData("en-US", "hm³")] // [CubicHectometer, HectocubicMeter]
-        [InlineData("en-US", "km³")] // [CubicKilometer, KilocubicMeter]
-        [InlineData("ru-RU", "гм³")] // [CubicHectometer, HectocubicMeter]
-        [InlineData("ru-RU", "км³")] // [CubicKilometer, KilocubicMeter]
-        public void TryParseUnitWithAmbiguousAbbreviation(string culture, string abbreviation)
-        {
-            Assert.False(Volume.TryParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture), out _));
-        }
-
         [Theory]
         [InlineData("en-US", VolumeUnit.AcreFoot, "ac-ft")]
         [InlineData("en-US", VolumeUnit.AuTablespoon, "tablespoon (A.U.)")]
@@ -1615,22 +1710,18 @@ public void TryParseUnitWithAmbiguousAbbreviation(string culture, string abbrevi
         [InlineData("en-US", VolumeUnit.DecausGallon, "dagal (U.S.)")]
         [InlineData("en-US", VolumeUnit.Deciliter, "dl")]
         [InlineData("en-US", VolumeUnit.DeciusGallon, "dgal (U.S.)")]
-        [InlineData("en-US", VolumeUnit.HectocubicFoot, "hft³")]
-        [InlineData("en-US", VolumeUnit.HectocubicMeter, "hm³")]
         [InlineData("en-US", VolumeUnit.Hectoliter, "hl")]
         [InlineData("en-US", VolumeUnit.HectousGallon, "hgal (U.S.)")]
+        [InlineData("en-US", VolumeUnit.HundredCubicFoot, "Ccf")]
         [InlineData("en-US", VolumeUnit.ImperialBeerBarrel, "bl (imp.)")]
         [InlineData("en-US", VolumeUnit.ImperialGallon, "gal (imp.)")]
         [InlineData("en-US", VolumeUnit.ImperialOunce, "oz (imp.)")]
         [InlineData("en-US", VolumeUnit.ImperialPint, "pt (imp.)")]
         [InlineData("en-US", VolumeUnit.ImperialQuart, "qt (imp.)")]
-        [InlineData("en-US", VolumeUnit.KilocubicFoot, "kft³")]
-        [InlineData("en-US", VolumeUnit.KilocubicMeter, "km³")]
         [InlineData("en-US", VolumeUnit.KiloimperialGallon, "kgal (imp.)")]
         [InlineData("en-US", VolumeUnit.Kiloliter, "kl")]
         [InlineData("en-US", VolumeUnit.KilousGallon, "kgal (U.S.)")]
         [InlineData("en-US", VolumeUnit.Liter, "l")]
-        [InlineData("en-US", VolumeUnit.MegacubicFoot, "Mft³")]
         [InlineData("en-US", VolumeUnit.MegaimperialGallon, "Mgal (imp.)")]
         [InlineData("en-US", VolumeUnit.Megaliter, "Ml")]
         [InlineData("en-US", VolumeUnit.MegausGallon, "Mgal (U.S.)")]
@@ -1639,8 +1730,11 @@ public void TryParseUnitWithAmbiguousAbbreviation(string culture, string abbrevi
         [InlineData("en-US", VolumeUnit.MetricTeaspoon, "tsp")]
         [InlineData("en-US", VolumeUnit.Microliter, "µl")]
         [InlineData("en-US", VolumeUnit.Milliliter, "ml")]
+        [InlineData("en-US", VolumeUnit.MillionCubicFoot, "MMcf")]
         [InlineData("en-US", VolumeUnit.Nanoliter, "nl")]
         [InlineData("en-US", VolumeUnit.OilBarrel, "bbl")]
+        [InlineData("en-US", VolumeUnit.ThousandCubicFoot, "Mcf")]
+        [InlineData("en-US", VolumeUnit.ThousandCubicMeter, "10³·m³")]
         [InlineData("en-US", VolumeUnit.UkTablespoon, "tablespoon (U.K.)")]
         [InlineData("en-US", VolumeUnit.UsBeerBarrel, "bl (U.S.)")]
         [InlineData("en-US", VolumeUnit.UsCustomaryCup, "cup (U.S. customary)")]
@@ -1668,19 +1762,14 @@ public void TryParseUnitWithAmbiguousAbbreviation(string culture, string abbrevi
         [InlineData("ru-RU", VolumeUnit.DecausGallon, "даАмериканский галлон")]
         [InlineData("ru-RU", VolumeUnit.Deciliter, "дл")]
         [InlineData("ru-RU", VolumeUnit.DeciusGallon, "дАмериканский галлон")]
-        [InlineData("ru-RU", VolumeUnit.HectocubicFoot, "гфут³")]
-        [InlineData("ru-RU", VolumeUnit.HectocubicMeter, "гм³")]
         [InlineData("ru-RU", VolumeUnit.Hectoliter, "гл")]
         [InlineData("ru-RU", VolumeUnit.HectousGallon, "гАмериканский галлон")]
         [InlineData("ru-RU", VolumeUnit.ImperialGallon, "Английский галлон")]
         [InlineData("ru-RU", VolumeUnit.ImperialOunce, "Английская унция")]
-        [InlineData("ru-RU", VolumeUnit.KilocubicFoot, "кфут³")]
-        [InlineData("ru-RU", VolumeUnit.KilocubicMeter, "км³")]
         [InlineData("ru-RU", VolumeUnit.KiloimperialGallon, "кАнглийский галлон")]
         [InlineData("ru-RU", VolumeUnit.Kiloliter, "кл")]
         [InlineData("ru-RU", VolumeUnit.KilousGallon, "кАмериканский галлон")]
         [InlineData("ru-RU", VolumeUnit.Liter, "л")]
-        [InlineData("ru-RU", VolumeUnit.MegacubicFoot, "Мфут³")]
         [InlineData("ru-RU", VolumeUnit.MegaimperialGallon, "МАнглийский галлон")]
         [InlineData("ru-RU", VolumeUnit.Megaliter, "Мл")]
         [InlineData("ru-RU", VolumeUnit.MegausGallon, "МАмериканский галлон")]
@@ -1738,6 +1827,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(VolumeUnit unit)
                 var quantity = Volume.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -1761,86 +1851,87 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(VolumeUnit unit)
                 IQuantity<VolumeUnit> quantityToConvert = quantity;
                 IQuantity<VolumeUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Volume cubicmeter = Volume.FromCubicMeters(1);
-            AssertEx.EqualTolerance(1, Volume.FromAcreFeet(cubicmeter.AcreFeet).CubicMeters, AcreFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromAuTablespoons(cubicmeter.AuTablespoons).CubicMeters, AuTablespoonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromBoardFeet(cubicmeter.BoardFeet).CubicMeters, BoardFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCentiliters(cubicmeter.Centiliters).CubicMeters, CentilitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicCentimeters(cubicmeter.CubicCentimeters).CubicMeters, CubicCentimetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicDecimeters(cubicmeter.CubicDecimeters).CubicMeters, CubicDecimetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicFeet(cubicmeter.CubicFeet).CubicMeters, CubicFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicHectometers(cubicmeter.CubicHectometers).CubicMeters, CubicHectometersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicInches(cubicmeter.CubicInches).CubicMeters, CubicInchesTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicKilometers(cubicmeter.CubicKilometers).CubicMeters, CubicKilometersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicMeters(cubicmeter.CubicMeters).CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicMicrometers(cubicmeter.CubicMicrometers).CubicMeters, CubicMicrometersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicMiles(cubicmeter.CubicMiles).CubicMeters, CubicMilesTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicMillimeters(cubicmeter.CubicMillimeters).CubicMeters, CubicMillimetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromCubicYards(cubicmeter.CubicYards).CubicMeters, CubicYardsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromDecaliters(cubicmeter.Decaliters).CubicMeters, DecalitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromDecausGallons(cubicmeter.DecausGallons).CubicMeters, DecausGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromDeciliters(cubicmeter.Deciliters).CubicMeters, DecilitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromDeciusGallons(cubicmeter.DeciusGallons).CubicMeters, DeciusGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromHectocubicFeet(cubicmeter.HectocubicFeet).CubicMeters, HectocubicFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromHectocubicMeters(cubicmeter.HectocubicMeters).CubicMeters, HectocubicMetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromHectoliters(cubicmeter.Hectoliters).CubicMeters, HectolitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromHectousGallons(cubicmeter.HectousGallons).CubicMeters, HectousGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromImperialBeerBarrels(cubicmeter.ImperialBeerBarrels).CubicMeters, ImperialBeerBarrelsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromImperialGallons(cubicmeter.ImperialGallons).CubicMeters, ImperialGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromImperialOunces(cubicmeter.ImperialOunces).CubicMeters, ImperialOuncesTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromImperialPints(cubicmeter.ImperialPints).CubicMeters, ImperialPintsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromImperialQuarts(cubicmeter.ImperialQuarts).CubicMeters, ImperialQuartsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromKilocubicFeet(cubicmeter.KilocubicFeet).CubicMeters, KilocubicFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromKilocubicMeters(cubicmeter.KilocubicMeters).CubicMeters, KilocubicMetersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromKiloimperialGallons(cubicmeter.KiloimperialGallons).CubicMeters, KiloimperialGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromKiloliters(cubicmeter.Kiloliters).CubicMeters, KilolitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromKilousGallons(cubicmeter.KilousGallons).CubicMeters, KilousGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromLiters(cubicmeter.Liters).CubicMeters, LitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMegacubicFeet(cubicmeter.MegacubicFeet).CubicMeters, MegacubicFeetTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMegaimperialGallons(cubicmeter.MegaimperialGallons).CubicMeters, MegaimperialGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMegaliters(cubicmeter.Megaliters).CubicMeters, MegalitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMegausGallons(cubicmeter.MegausGallons).CubicMeters, MegausGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMetricCups(cubicmeter.MetricCups).CubicMeters, MetricCupsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMetricTablespoons(cubicmeter.MetricTablespoons).CubicMeters, MetricTablespoonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMetricTeaspoons(cubicmeter.MetricTeaspoons).CubicMeters, MetricTeaspoonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMicroliters(cubicmeter.Microliters).CubicMeters, MicrolitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromMilliliters(cubicmeter.Milliliters).CubicMeters, MillilitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromNanoliters(cubicmeter.Nanoliters).CubicMeters, NanolitersTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromOilBarrels(cubicmeter.OilBarrels).CubicMeters, OilBarrelsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUkTablespoons(cubicmeter.UkTablespoons).CubicMeters, UkTablespoonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsBeerBarrels(cubicmeter.UsBeerBarrels).CubicMeters, UsBeerBarrelsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsCustomaryCups(cubicmeter.UsCustomaryCups).CubicMeters, UsCustomaryCupsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsGallons(cubicmeter.UsGallons).CubicMeters, UsGallonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsLegalCups(cubicmeter.UsLegalCups).CubicMeters, UsLegalCupsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsOunces(cubicmeter.UsOunces).CubicMeters, UsOuncesTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsPints(cubicmeter.UsPints).CubicMeters, UsPintsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsQuarts(cubicmeter.UsQuarts).CubicMeters, UsQuartsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsTablespoons(cubicmeter.UsTablespoons).CubicMeters, UsTablespoonsTolerance);
-            AssertEx.EqualTolerance(1, Volume.FromUsTeaspoons(cubicmeter.UsTeaspoons).CubicMeters, UsTeaspoonsTolerance);
+            Volume cubicmeter = Volume.FromCubicMeters(3);
+            Assert.Equal(3, Volume.FromAcreFeet(cubicmeter.AcreFeet).CubicMeters);
+            Assert.Equal(3, Volume.FromAuTablespoons(cubicmeter.AuTablespoons).CubicMeters);
+            Assert.Equal(3, Volume.FromBoardFeet(cubicmeter.BoardFeet).CubicMeters);
+            Assert.Equal(3, Volume.FromCentiliters(cubicmeter.Centiliters).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicCentimeters(cubicmeter.CubicCentimeters).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicDecimeters(cubicmeter.CubicDecimeters).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicFeet(cubicmeter.CubicFeet).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicHectometers(cubicmeter.CubicHectometers).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicInches(cubicmeter.CubicInches).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicKilometers(cubicmeter.CubicKilometers).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicMeters(cubicmeter.CubicMeters).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicMicrometers(cubicmeter.CubicMicrometers).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicMiles(cubicmeter.CubicMiles).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicMillimeters(cubicmeter.CubicMillimeters).CubicMeters);
+            Assert.Equal(3, Volume.FromCubicYards(cubicmeter.CubicYards).CubicMeters);
+            Assert.Equal(3, Volume.FromDecaliters(cubicmeter.Decaliters).CubicMeters);
+            Assert.Equal(3, Volume.FromDecausGallons(cubicmeter.DecausGallons).CubicMeters);
+            Assert.Equal(3, Volume.FromDeciliters(cubicmeter.Deciliters).CubicMeters);
+            Assert.Equal(3, Volume.FromDeciusGallons(cubicmeter.DeciusGallons).CubicMeters);
+            Assert.Equal(3, Volume.FromHectoliters(cubicmeter.Hectoliters).CubicMeters);
+            Assert.Equal(3, Volume.FromHectousGallons(cubicmeter.HectousGallons).CubicMeters);
+            Assert.Equal(3, Volume.FromHundredCubicFeet(cubicmeter.HundredCubicFeet).CubicMeters);
+            Assert.Equal(3, Volume.FromImperialBeerBarrels(cubicmeter.ImperialBeerBarrels).CubicMeters);
+            Assert.Equal(3, Volume.FromImperialGallons(cubicmeter.ImperialGallons).CubicMeters);
+            Assert.Equal(3, Volume.FromImperialOunces(cubicmeter.ImperialOunces).CubicMeters);
+            Assert.Equal(3, Volume.FromImperialPints(cubicmeter.ImperialPints).CubicMeters);
+            Assert.Equal(3, Volume.FromImperialQuarts(cubicmeter.ImperialQuarts).CubicMeters);
+            Assert.Equal(3, Volume.FromKiloimperialGallons(cubicmeter.KiloimperialGallons).CubicMeters);
+            Assert.Equal(3, Volume.FromKiloliters(cubicmeter.Kiloliters).CubicMeters);
+            Assert.Equal(3, Volume.FromKilousGallons(cubicmeter.KilousGallons).CubicMeters);
+            Assert.Equal(3, Volume.FromLiters(cubicmeter.Liters).CubicMeters);
+            Assert.Equal(3, Volume.FromMegaimperialGallons(cubicmeter.MegaimperialGallons).CubicMeters);
+            Assert.Equal(3, Volume.FromMegaliters(cubicmeter.Megaliters).CubicMeters);
+            Assert.Equal(3, Volume.FromMegausGallons(cubicmeter.MegausGallons).CubicMeters);
+            Assert.Equal(3, Volume.FromMetricCups(cubicmeter.MetricCups).CubicMeters);
+            Assert.Equal(3, Volume.FromMetricTablespoons(cubicmeter.MetricTablespoons).CubicMeters);
+            Assert.Equal(3, Volume.FromMetricTeaspoons(cubicmeter.MetricTeaspoons).CubicMeters);
+            Assert.Equal(3, Volume.FromMicroliters(cubicmeter.Microliters).CubicMeters);
+            Assert.Equal(3, Volume.FromMilliliters(cubicmeter.Milliliters).CubicMeters);
+            Assert.Equal(3, Volume.FromMillionCubicFeet(cubicmeter.MillionCubicFeet).CubicMeters);
+            Assert.Equal(3, Volume.FromNanoliters(cubicmeter.Nanoliters).CubicMeters);
+            Assert.Equal(3, Volume.FromOilBarrels(cubicmeter.OilBarrels).CubicMeters);
+            Assert.Equal(3, Volume.FromThousandCubicFeet(cubicmeter.ThousandCubicFeet).CubicMeters);
+            Assert.Equal(3, Volume.FromThousandCubicMeters(cubicmeter.ThousandCubicMeters).CubicMeters);
+            Assert.Equal(3, Volume.FromUkTablespoons(cubicmeter.UkTablespoons).CubicMeters);
+            Assert.Equal(3, Volume.FromUsBeerBarrels(cubicmeter.UsBeerBarrels).CubicMeters);
+            Assert.Equal(3, Volume.FromUsCustomaryCups(cubicmeter.UsCustomaryCups).CubicMeters);
+            Assert.Equal(3, Volume.FromUsGallons(cubicmeter.UsGallons).CubicMeters);
+            Assert.Equal(3, Volume.FromUsLegalCups(cubicmeter.UsLegalCups).CubicMeters);
+            Assert.Equal(3, Volume.FromUsOunces(cubicmeter.UsOunces).CubicMeters);
+            Assert.Equal(3, Volume.FromUsPints(cubicmeter.UsPints).CubicMeters);
+            Assert.Equal(3, Volume.FromUsQuarts(cubicmeter.UsQuarts).CubicMeters);
+            Assert.Equal(3, Volume.FromUsTablespoons(cubicmeter.UsTablespoons).CubicMeters);
+            Assert.Equal(3, Volume.FromUsTeaspoons(cubicmeter.UsTeaspoons).CubicMeters);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             Volume v = Volume.FromCubicMeters(1);
-            AssertEx.EqualTolerance(-1, -v.CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(2, (Volume.FromCubicMeters(3)-v).CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(2, (v + v).CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(10, (v*10).CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(10, (10*v).CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(2, (Volume.FromCubicMeters(10)/5).CubicMeters, CubicMetersTolerance);
-            AssertEx.EqualTolerance(2, Volume.FromCubicMeters(10)/Volume.FromCubicMeters(5), CubicMetersTolerance);
+            Assert.Equal(-1, -v.CubicMeters);
+            Assert.Equal(2, (Volume.FromCubicMeters(3) - v).CubicMeters);
+            Assert.Equal(2, (v + v).CubicMeters);
+            Assert.Equal(10, (v * 10).CubicMeters);
+            Assert.Equal(10, (10 * v).CubicMeters);
+            Assert.Equal(2, (Volume.FromCubicMeters(10) / 5).CubicMeters);
+            Assert.Equal(2, Volume.FromCubicMeters(10) / Volume.FromCubicMeters(5));
         }
 
         [Fact]
@@ -1886,8 +1977,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, VolumeUnit.CubicMeter, 1, VolumeUnit.CubicMeter, true)]  // Same value and unit.
         [InlineData(1, VolumeUnit.CubicMeter, 2, VolumeUnit.CubicMeter, false)] // Different value.
-        [InlineData(2, VolumeUnit.CubicMeter, 1, VolumeUnit.AcreFoot, false)] // Different value and unit.
-        [InlineData(1, VolumeUnit.CubicMeter, 1, VolumeUnit.AcreFoot, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, VolumeUnit unitA, double valueB, VolumeUnit unitB, bool expectEqual)
         {
             var a = new Volume(valueA, unitA);
@@ -1947,8 +2036,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = Volume.FromCubicMeters(firstValue);
             var otherQuantity = Volume.FromCubicMeters(secondValue);
             Volume maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, Volume.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -1967,7 +2056,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<VolumeUnit>();
+            var units = EnumHelper.GetValues<VolumeUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -1980,6 +2069,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(Volume.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(Volume.Info.Units, Volume.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, Volume.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -2003,22 +2104,18 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
             Assert.Equal("1 dagal (U.S.)", new Volume(1, VolumeUnit.DecausGallon).ToString());
             Assert.Equal("1 dl", new Volume(1, VolumeUnit.Deciliter).ToString());
             Assert.Equal("1 dgal (U.S.)", new Volume(1, VolumeUnit.DeciusGallon).ToString());
-            Assert.Equal("1 hft³", new Volume(1, VolumeUnit.HectocubicFoot).ToString());
-            Assert.Equal("1 hm³", new Volume(1, VolumeUnit.HectocubicMeter).ToString());
             Assert.Equal("1 hl", new Volume(1, VolumeUnit.Hectoliter).ToString());
             Assert.Equal("1 hgal (U.S.)", new Volume(1, VolumeUnit.HectousGallon).ToString());
+            Assert.Equal("1 Ccf", new Volume(1, VolumeUnit.HundredCubicFoot).ToString());
             Assert.Equal("1 bl (imp.)", new Volume(1, VolumeUnit.ImperialBeerBarrel).ToString());
             Assert.Equal("1 gal (imp.)", new Volume(1, VolumeUnit.ImperialGallon).ToString());
             Assert.Equal("1 oz (imp.)", new Volume(1, VolumeUnit.ImperialOunce).ToString());
             Assert.Equal("1 pt (imp.)", new Volume(1, VolumeUnit.ImperialPint).ToString());
             Assert.Equal("1 qt (imp.)", new Volume(1, VolumeUnit.ImperialQuart).ToString());
-            Assert.Equal("1 kft³", new Volume(1, VolumeUnit.KilocubicFoot).ToString());
-            Assert.Equal("1 km³", new Volume(1, VolumeUnit.KilocubicMeter).ToString());
             Assert.Equal("1 kgal (imp.)", new Volume(1, VolumeUnit.KiloimperialGallon).ToString());
             Assert.Equal("1 kl", new Volume(1, VolumeUnit.Kiloliter).ToString());
             Assert.Equal("1 kgal (U.S.)", new Volume(1, VolumeUnit.KilousGallon).ToString());
             Assert.Equal("1 l", new Volume(1, VolumeUnit.Liter).ToString());
-            Assert.Equal("1 Mft³", new Volume(1, VolumeUnit.MegacubicFoot).ToString());
             Assert.Equal("1 Mgal (imp.)", new Volume(1, VolumeUnit.MegaimperialGallon).ToString());
             Assert.Equal("1 Ml", new Volume(1, VolumeUnit.Megaliter).ToString());
             Assert.Equal("1 Mgal (U.S.)", new Volume(1, VolumeUnit.MegausGallon).ToString());
@@ -2027,8 +2124,11 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
             Assert.Equal("1 tsp", new Volume(1, VolumeUnit.MetricTeaspoon).ToString());
             Assert.Equal("1 µl", new Volume(1, VolumeUnit.Microliter).ToString());
             Assert.Equal("1 ml", new Volume(1, VolumeUnit.Milliliter).ToString());
+            Assert.Equal("1 MMcf", new Volume(1, VolumeUnit.MillionCubicFoot).ToString());
             Assert.Equal("1 nl", new Volume(1, VolumeUnit.Nanoliter).ToString());
             Assert.Equal("1 bbl", new Volume(1, VolumeUnit.OilBarrel).ToString());
+            Assert.Equal("1 Mcf", new Volume(1, VolumeUnit.ThousandCubicFoot).ToString());
+            Assert.Equal("1 10³·m³", new Volume(1, VolumeUnit.ThousandCubicMeter).ToString());
             Assert.Equal("1 tablespoon (U.K.)", new Volume(1, VolumeUnit.UkTablespoon).ToString());
             Assert.Equal("1 bl (U.S.)", new Volume(1, VolumeUnit.UsBeerBarrel).ToString());
             Assert.Equal("1 cup (U.S. customary)", new Volume(1, VolumeUnit.UsCustomaryCup).ToString());
@@ -2066,22 +2166,18 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 dagal (U.S.)", new Volume(1, VolumeUnit.DecausGallon).ToString(swedishCulture));
             Assert.Equal("1 dl", new Volume(1, VolumeUnit.Deciliter).ToString(swedishCulture));
             Assert.Equal("1 dgal (U.S.)", new Volume(1, VolumeUnit.DeciusGallon).ToString(swedishCulture));
-            Assert.Equal("1 hft³", new Volume(1, VolumeUnit.HectocubicFoot).ToString(swedishCulture));
-            Assert.Equal("1 hm³", new Volume(1, VolumeUnit.HectocubicMeter).ToString(swedishCulture));
             Assert.Equal("1 hl", new Volume(1, VolumeUnit.Hectoliter).ToString(swedishCulture));
             Assert.Equal("1 hgal (U.S.)", new Volume(1, VolumeUnit.HectousGallon).ToString(swedishCulture));
+            Assert.Equal("1 Ccf", new Volume(1, VolumeUnit.HundredCubicFoot).ToString(swedishCulture));
             Assert.Equal("1 bl (imp.)", new Volume(1, VolumeUnit.ImperialBeerBarrel).ToString(swedishCulture));
             Assert.Equal("1 gal (imp.)", new Volume(1, VolumeUnit.ImperialGallon).ToString(swedishCulture));
             Assert.Equal("1 oz (imp.)", new Volume(1, VolumeUnit.ImperialOunce).ToString(swedishCulture));
             Assert.Equal("1 pt (imp.)", new Volume(1, VolumeUnit.ImperialPint).ToString(swedishCulture));
             Assert.Equal("1 qt (imp.)", new Volume(1, VolumeUnit.ImperialQuart).ToString(swedishCulture));
-            Assert.Equal("1 kft³", new Volume(1, VolumeUnit.KilocubicFoot).ToString(swedishCulture));
-            Assert.Equal("1 km³", new Volume(1, VolumeUnit.KilocubicMeter).ToString(swedishCulture));
             Assert.Equal("1 kgal (imp.)", new Volume(1, VolumeUnit.KiloimperialGallon).ToString(swedishCulture));
             Assert.Equal("1 kl", new Volume(1, VolumeUnit.Kiloliter).ToString(swedishCulture));
             Assert.Equal("1 kgal (U.S.)", new Volume(1, VolumeUnit.KilousGallon).ToString(swedishCulture));
             Assert.Equal("1 l", new Volume(1, VolumeUnit.Liter).ToString(swedishCulture));
-            Assert.Equal("1 Mft³", new Volume(1, VolumeUnit.MegacubicFoot).ToString(swedishCulture));
             Assert.Equal("1 Mgal (imp.)", new Volume(1, VolumeUnit.MegaimperialGallon).ToString(swedishCulture));
             Assert.Equal("1 Ml", new Volume(1, VolumeUnit.Megaliter).ToString(swedishCulture));
             Assert.Equal("1 Mgal (U.S.)", new Volume(1, VolumeUnit.MegausGallon).ToString(swedishCulture));
@@ -2090,8 +2186,11 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 tsp", new Volume(1, VolumeUnit.MetricTeaspoon).ToString(swedishCulture));
             Assert.Equal("1 µl", new Volume(1, VolumeUnit.Microliter).ToString(swedishCulture));
             Assert.Equal("1 ml", new Volume(1, VolumeUnit.Milliliter).ToString(swedishCulture));
+            Assert.Equal("1 MMcf", new Volume(1, VolumeUnit.MillionCubicFoot).ToString(swedishCulture));
             Assert.Equal("1 nl", new Volume(1, VolumeUnit.Nanoliter).ToString(swedishCulture));
             Assert.Equal("1 bbl", new Volume(1, VolumeUnit.OilBarrel).ToString(swedishCulture));
+            Assert.Equal("1 Mcf", new Volume(1, VolumeUnit.ThousandCubicFoot).ToString(swedishCulture));
+            Assert.Equal("1 10³·m³", new Volume(1, VolumeUnit.ThousandCubicMeter).ToString(swedishCulture));
             Assert.Equal("1 tablespoon (U.K.)", new Volume(1, VolumeUnit.UkTablespoon).ToString(swedishCulture));
             Assert.Equal("1 bl (U.S.)", new Volume(1, VolumeUnit.UsBeerBarrel).ToString(swedishCulture));
             Assert.Equal("1 cup (U.S. customary)", new Volume(1, VolumeUnit.UsCustomaryCup).ToString(swedishCulture));
@@ -2104,26 +2203,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 teaspoon (U.S.)", new Volume(1, VolumeUnit.UsTeaspoon).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m³", new Volume(0.123456, VolumeUnit.CubicMeter).ToString("s1"));
-            Assert.Equal("0.12 m³", new Volume(0.123456, VolumeUnit.CubicMeter).ToString("s2"));
-            Assert.Equal("0.123 m³", new Volume(0.123456, VolumeUnit.CubicMeter).ToString("s3"));
-            Assert.Equal("0.1235 m³", new Volume(0.123456, VolumeUnit.CubicMeter).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m³", new Volume(0.123456, VolumeUnit.CubicMeter).ToString("s1", culture));
-            Assert.Equal("0.12 m³", new Volume(0.123456, VolumeUnit.CubicMeter).ToString("s2", culture));
-            Assert.Equal("0.123 m³", new Volume(0.123456, VolumeUnit.CubicMeter).ToString("s3", culture));
-            Assert.Equal("0.1235 m³", new Volume(0.123456, VolumeUnit.CubicMeter).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -2150,7 +2229,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = Volume.FromCubicMeters(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(Volume), quantity.As(Volume.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumetricHeatCapacityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumetricHeatCapacityTestsBase.g.cs
index ebb7461584..98eb8352d6 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumetricHeatCapacityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumetricHeatCapacityTestsBase.g.cs
@@ -157,6 +157,20 @@ public void VolumetricHeatCapacity_QuantityInfo_ReturnsQuantityInfoDescribingQua
             Assert.Equal(quantityInfo, ((IQuantity<VolumetricHeatCapacityUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void VolumetricHeatCapacityInfo_CreateWithCustomUnitInfos()
+        {
+            VolumetricHeatCapacityUnit[] expectedUnits = [VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin];
+
+            VolumetricHeatCapacity.VolumetricHeatCapacityInfo quantityInfo = VolumetricHeatCapacity.VolumetricHeatCapacityInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("VolumetricHeatCapacity", quantityInfo.Name);
+            Assert.Equal(VolumetricHeatCapacity.Zero, quantityInfo.Zero);
+            Assert.Equal(VolumetricHeatCapacity.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void JoulePerCubicMeterKelvinToVolumetricHeatCapacityUnits()
         {
@@ -257,26 +271,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = VolumetricHeatCapacity.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            VolumetricHeatCapacity convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                VolumetricHeatCapacity quantityToConvert = quantity;
+
+                VolumetricHeatCapacity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<VolumetricHeatCapacityUnit> quantityToConvert = quantity;
+
+                IQuantity<VolumetricHeatCapacityUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new VolumetricHeatCapacity(value: 1, unit: VolumetricHeatCapacity.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new VolumetricHeatCapacity(value: 1, unit: VolumetricHeatCapacity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<VolumetricHeatCapacityUnit> quantity = new VolumetricHeatCapacity(value: 1, unit: VolumetricHeatCapacity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new VolumetricHeatCapacity(value: 1, unit: VolumetricHeatCapacity.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new VolumetricHeatCapacity(value: 1, unit: VolumetricHeatCapacity.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new VolumetricHeatCapacity(value: 1, unit: VolumetricHeatCapacity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<VolumetricHeatCapacityUnit> quantity = new VolumetricHeatCapacity(value: 1, unit: VolumetricHeatCapacity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new VolumetricHeatCapacity(value: 1, unit: VolumetricHeatCapacity.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -289,7 +346,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 kJ/(m³·K)", VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin, 4.2)]
         [InlineData("en-US", "4.2 MJ/(m³·°C)", VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 MJ/(m³·K)", VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin, 4.2)]
-        public void Parse(string culture, string quantityString, VolumetricHeatCapacityUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, VolumetricHeatCapacityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = VolumetricHeatCapacity.Parse(quantityString);
@@ -307,7 +364,7 @@ public void Parse(string culture, string quantityString, VolumetricHeatCapacityU
         [InlineData("en-US", "4.2 kJ/(m³·K)", VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin, 4.2)]
         [InlineData("en-US", "4.2 MJ/(m³·°C)", VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius, 4.2)]
         [InlineData("en-US", "4.2 MJ/(m³·K)", VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin, 4.2)]
-        public void TryParse(string culture, string quantityString, VolumetricHeatCapacityUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, VolumetricHeatCapacityUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(VolumetricHeatCapacity.TryParse(quantityString, out VolumetricHeatCapacity parsed));
@@ -512,6 +569,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(VolumetricHeatCa
                 var quantity = VolumetricHeatCapacity.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -535,40 +593,42 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(VolumetricHeatCapac
                 IQuantity<VolumetricHeatCapacityUnit> quantityToConvert = quantity;
                 IQuantity<VolumetricHeatCapacityUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            VolumetricHeatCapacity joulepercubicmeterkelvin = VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(1);
-            AssertEx.EqualTolerance(1, VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(joulepercubicmeterkelvin.BtusPerCubicFootDegreeFahrenheit).JoulesPerCubicMeterKelvin, BtusPerCubicFootDegreeFahrenheitTolerance);
-            AssertEx.EqualTolerance(1, VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(joulepercubicmeterkelvin.CaloriesPerCubicCentimeterDegreeCelsius).JoulesPerCubicMeterKelvin, CaloriesPerCubicCentimeterDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(joulepercubicmeterkelvin.JoulesPerCubicMeterDegreeCelsius).JoulesPerCubicMeterKelvin, JoulesPerCubicMeterDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(joulepercubicmeterkelvin.JoulesPerCubicMeterKelvin).JoulesPerCubicMeterKelvin, JoulesPerCubicMeterKelvinTolerance);
-            AssertEx.EqualTolerance(1, VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(joulepercubicmeterkelvin.KilocaloriesPerCubicCentimeterDegreeCelsius).JoulesPerCubicMeterKelvin, KilocaloriesPerCubicCentimeterDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(joulepercubicmeterkelvin.KilojoulesPerCubicMeterDegreeCelsius).JoulesPerCubicMeterKelvin, KilojoulesPerCubicMeterDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(joulepercubicmeterkelvin.KilojoulesPerCubicMeterKelvin).JoulesPerCubicMeterKelvin, KilojoulesPerCubicMeterKelvinTolerance);
-            AssertEx.EqualTolerance(1, VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(joulepercubicmeterkelvin.MegajoulesPerCubicMeterDegreeCelsius).JoulesPerCubicMeterKelvin, MegajoulesPerCubicMeterDegreeCelsiusTolerance);
-            AssertEx.EqualTolerance(1, VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(joulepercubicmeterkelvin.MegajoulesPerCubicMeterKelvin).JoulesPerCubicMeterKelvin, MegajoulesPerCubicMeterKelvinTolerance);
+            VolumetricHeatCapacity joulepercubicmeterkelvin = VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(3);
+            Assert.Equal(3, VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(joulepercubicmeterkelvin.BtusPerCubicFootDegreeFahrenheit).JoulesPerCubicMeterKelvin);
+            Assert.Equal(3, VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(joulepercubicmeterkelvin.CaloriesPerCubicCentimeterDegreeCelsius).JoulesPerCubicMeterKelvin);
+            Assert.Equal(3, VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(joulepercubicmeterkelvin.JoulesPerCubicMeterDegreeCelsius).JoulesPerCubicMeterKelvin);
+            Assert.Equal(3, VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(joulepercubicmeterkelvin.JoulesPerCubicMeterKelvin).JoulesPerCubicMeterKelvin);
+            Assert.Equal(3, VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(joulepercubicmeterkelvin.KilocaloriesPerCubicCentimeterDegreeCelsius).JoulesPerCubicMeterKelvin);
+            Assert.Equal(3, VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(joulepercubicmeterkelvin.KilojoulesPerCubicMeterDegreeCelsius).JoulesPerCubicMeterKelvin);
+            Assert.Equal(3, VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(joulepercubicmeterkelvin.KilojoulesPerCubicMeterKelvin).JoulesPerCubicMeterKelvin);
+            Assert.Equal(3, VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(joulepercubicmeterkelvin.MegajoulesPerCubicMeterDegreeCelsius).JoulesPerCubicMeterKelvin);
+            Assert.Equal(3, VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(joulepercubicmeterkelvin.MegajoulesPerCubicMeterKelvin).JoulesPerCubicMeterKelvin);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             VolumetricHeatCapacity v = VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(1);
-            AssertEx.EqualTolerance(-1, -v.JoulesPerCubicMeterKelvin, JoulesPerCubicMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(3)-v).JoulesPerCubicMeterKelvin, JoulesPerCubicMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (v + v).JoulesPerCubicMeterKelvin, JoulesPerCubicMeterKelvinTolerance);
-            AssertEx.EqualTolerance(10, (v*10).JoulesPerCubicMeterKelvin, JoulesPerCubicMeterKelvinTolerance);
-            AssertEx.EqualTolerance(10, (10*v).JoulesPerCubicMeterKelvin, JoulesPerCubicMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, (VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(10)/5).JoulesPerCubicMeterKelvin, JoulesPerCubicMeterKelvinTolerance);
-            AssertEx.EqualTolerance(2, VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(10)/VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(5), JoulesPerCubicMeterKelvinTolerance);
+            Assert.Equal(-1, -v.JoulesPerCubicMeterKelvin);
+            Assert.Equal(2, (VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(3) - v).JoulesPerCubicMeterKelvin);
+            Assert.Equal(2, (v + v).JoulesPerCubicMeterKelvin);
+            Assert.Equal(10, (v * 10).JoulesPerCubicMeterKelvin);
+            Assert.Equal(10, (10 * v).JoulesPerCubicMeterKelvin);
+            Assert.Equal(2, (VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(10) / 5).JoulesPerCubicMeterKelvin);
+            Assert.Equal(2, VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(10) / VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(5));
         }
 
         [Fact]
@@ -614,8 +674,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, 1, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, true)]  // Same value and unit.
         [InlineData(1, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, 2, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, false)] // Different value.
-        [InlineData(2, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, 1, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit, false)] // Different value and unit.
-        [InlineData(1, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, 1, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, VolumetricHeatCapacityUnit unitA, double valueB, VolumetricHeatCapacityUnit unitB, bool expectEqual)
         {
             var a = new VolumetricHeatCapacity(valueA, unitA);
@@ -675,8 +733,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(firstValue);
             var otherQuantity = VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(secondValue);
             VolumetricHeatCapacity maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, VolumetricHeatCapacity.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -695,7 +753,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<VolumetricHeatCapacityUnit>();
+            var units = EnumHelper.GetValues<VolumetricHeatCapacityUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -708,6 +766,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(VolumetricHeatCapacity.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(VolumetricHeatCapacity.Info.Units, VolumetricHeatCapacity.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, VolumetricHeatCapacity.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -740,26 +810,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 MJ/(m³·K)", new VolumetricHeatCapacity(1, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 J/(m³·K)", new VolumetricHeatCapacity(0.123456, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin).ToString("s1"));
-            Assert.Equal("0.12 J/(m³·K)", new VolumetricHeatCapacity(0.123456, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin).ToString("s2"));
-            Assert.Equal("0.123 J/(m³·K)", new VolumetricHeatCapacity(0.123456, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin).ToString("s3"));
-            Assert.Equal("0.1235 J/(m³·K)", new VolumetricHeatCapacity(0.123456, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 J/(m³·K)", new VolumetricHeatCapacity(0.123456, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin).ToString("s1", culture));
-            Assert.Equal("0.12 J/(m³·K)", new VolumetricHeatCapacity(0.123456, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin).ToString("s2", culture));
-            Assert.Equal("0.123 J/(m³·K)", new VolumetricHeatCapacity(0.123456, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin).ToString("s3", culture));
-            Assert.Equal("0.1235 J/(m³·K)", new VolumetricHeatCapacity(0.123456, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -786,7 +836,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(VolumetricHeatCapacity), quantity.As(VolumetricHeatCapacity.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/WarpingMomentOfInertiaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/WarpingMomentOfInertiaTestsBase.g.cs
index 66c3fbb2bb..094e09f33c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/WarpingMomentOfInertiaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/WarpingMomentOfInertiaTestsBase.g.cs
@@ -145,6 +145,20 @@ public void WarpingMomentOfInertia_QuantityInfo_ReturnsQuantityInfoDescribingQua
             Assert.Equal(quantityInfo, ((IQuantity<WarpingMomentOfInertiaUnit>)quantity).QuantityInfo);
         }
 
+        [Fact]
+        public void WarpingMomentOfInertiaInfo_CreateWithCustomUnitInfos()
+        {
+            WarpingMomentOfInertiaUnit[] expectedUnits = [WarpingMomentOfInertiaUnit.MeterToTheSixth];
+
+            WarpingMomentOfInertia.WarpingMomentOfInertiaInfo quantityInfo = WarpingMomentOfInertia.WarpingMomentOfInertiaInfo.CreateDefault(mappings => mappings.SelectUnits(expectedUnits));
+
+            Assert.Equal("WarpingMomentOfInertia", quantityInfo.Name);
+            Assert.Equal(WarpingMomentOfInertia.Zero, quantityInfo.Zero);
+            Assert.Equal(WarpingMomentOfInertia.BaseUnit, quantityInfo.BaseUnitInfo.Value);
+            Assert.Equal(expectedUnits, quantityInfo.Units);
+            Assert.Equal(expectedUnits, quantityInfo.UnitInfos.Select(x => x.Value));
+        }
+
         [Fact]
         public void MeterToTheSixthToWarpingMomentOfInertiaUnits()
         {
@@ -239,26 +253,69 @@ public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
             var expectedUnit = WarpingMomentOfInertia.Info.GetDefaultUnit(UnitSystem.SI);
             var expectedValue = quantity.As(expectedUnit);
 
-            WarpingMomentOfInertia convertedQuantity = quantity.ToUnit(UnitSystem.SI);
+            Assert.Multiple(() =>
+            {
+                WarpingMomentOfInertia quantityToConvert = quantity;
+
+                WarpingMomentOfInertia convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity<WarpingMomentOfInertiaUnit> quantityToConvert = quantity;
+
+                IQuantity<WarpingMomentOfInertiaUnit> convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
+
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            }, () =>
+            {
+                IQuantity quantityToConvert = quantity;
+
+                IQuantity convertedQuantity = quantityToConvert.ToUnit(UnitSystem.SI);
 
-            Assert.Equal(expectedUnit, convertedQuantity.Unit);
-            Assert.Equal(expectedValue, convertedQuantity.Value);
+                Assert.Equal(expectedUnit, convertedQuantity.Unit);
+                Assert.Equal(expectedValue, convertedQuantity.Value);
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull()
         {
             UnitSystem nullUnitSystem = null!;
-            var quantity = new WarpingMomentOfInertia(value: 1, unit: WarpingMomentOfInertia.BaseUnit);
-            Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new WarpingMomentOfInertia(value: 1, unit: WarpingMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity<WarpingMomentOfInertiaUnit> quantity = new WarpingMomentOfInertia(value: 1, unit: WarpingMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new WarpingMomentOfInertia(value: 1, unit: WarpingMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentNullException>(() => quantity.ToUnit(nullUnitSystem));
+            });
         }
 
         [Fact]
         public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         {
             var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits);
-            var quantity = new WarpingMomentOfInertia(value: 1, unit: WarpingMomentOfInertia.BaseUnit);
-            Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            Assert.Multiple(() =>
+            {
+                var quantity = new WarpingMomentOfInertia(value: 1, unit: WarpingMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity<WarpingMomentOfInertiaUnit> quantity = new WarpingMomentOfInertia(value: 1, unit: WarpingMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            }, () =>
+            {
+                IQuantity quantity = new WarpingMomentOfInertia(value: 1, unit: WarpingMomentOfInertia.BaseUnit);
+                Assert.Throws<ArgumentException>(() => quantity.ToUnit(unsupportedUnitSystem));
+            });
         }
 
         [Theory]
@@ -268,7 +325,7 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
         [InlineData("en-US", "4.2 in⁶", WarpingMomentOfInertiaUnit.InchToTheSixth, 4.2)]
         [InlineData("en-US", "4.2 m⁶", WarpingMomentOfInertiaUnit.MeterToTheSixth, 4.2)]
         [InlineData("en-US", "4.2 mm⁶", WarpingMomentOfInertiaUnit.MillimeterToTheSixth, 4.2)]
-        public void Parse(string culture, string quantityString, WarpingMomentOfInertiaUnit expectedUnit, double expectedValue)
+        public void Parse(string culture, string quantityString, WarpingMomentOfInertiaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             var parsed = WarpingMomentOfInertia.Parse(quantityString);
@@ -283,7 +340,7 @@ public void Parse(string culture, string quantityString, WarpingMomentOfInertiaU
         [InlineData("en-US", "4.2 in⁶", WarpingMomentOfInertiaUnit.InchToTheSixth, 4.2)]
         [InlineData("en-US", "4.2 m⁶", WarpingMomentOfInertiaUnit.MeterToTheSixth, 4.2)]
         [InlineData("en-US", "4.2 mm⁶", WarpingMomentOfInertiaUnit.MillimeterToTheSixth, 4.2)]
-        public void TryParse(string culture, string quantityString, WarpingMomentOfInertiaUnit expectedUnit, double expectedValue)
+        public void TryParse(string culture, string quantityString, WarpingMomentOfInertiaUnit expectedUnit, decimal expectedValue)
         {
             using var _ = new CultureScope(culture);
             Assert.True(WarpingMomentOfInertia.TryParse(quantityString, out WarpingMomentOfInertia parsed));
@@ -461,6 +518,7 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(WarpingMomentOfI
                 var quantity = WarpingMomentOfInertia.From(3.0, fromUnit);
                 var converted = quantity.ToUnit(unit);
                 Assert.Equal(converted.Unit, unit);
+                Assert.Equal(quantity, converted);
             });
         }
 
@@ -484,37 +542,39 @@ public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(WarpingMomentOfIner
                 IQuantity<WarpingMomentOfInertiaUnit> quantityToConvert = quantity;
                 IQuantity<WarpingMomentOfInertiaUnit> convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             }, () =>
             {
                 IQuantity quantityToConvert = quantity;
                 IQuantity convertedQuantity = quantityToConvert.ToUnit(unit);
                 Assert.Equal(unit, convertedQuantity.Unit);
+                Assert.Equal(expectedQuantity, convertedQuantity);
             });
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            WarpingMomentOfInertia metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(1);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromCentimetersToTheSixth(metertothesixth.CentimetersToTheSixth).MetersToTheSixth, CentimetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromDecimetersToTheSixth(metertothesixth.DecimetersToTheSixth).MetersToTheSixth, DecimetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromFeetToTheSixth(metertothesixth.FeetToTheSixth).MetersToTheSixth, FeetToTheSixthTolerance);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromInchesToTheSixth(metertothesixth.InchesToTheSixth).MetersToTheSixth, InchesToTheSixthTolerance);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromMetersToTheSixth(metertothesixth.MetersToTheSixth).MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(1, WarpingMomentOfInertia.FromMillimetersToTheSixth(metertothesixth.MillimetersToTheSixth).MetersToTheSixth, MillimetersToTheSixthTolerance);
+            WarpingMomentOfInertia metertothesixth = WarpingMomentOfInertia.FromMetersToTheSixth(3);
+            Assert.Equal(3, WarpingMomentOfInertia.FromCentimetersToTheSixth(metertothesixth.CentimetersToTheSixth).MetersToTheSixth);
+            Assert.Equal(3, WarpingMomentOfInertia.FromDecimetersToTheSixth(metertothesixth.DecimetersToTheSixth).MetersToTheSixth);
+            Assert.Equal(3, WarpingMomentOfInertia.FromFeetToTheSixth(metertothesixth.FeetToTheSixth).MetersToTheSixth);
+            Assert.Equal(3, WarpingMomentOfInertia.FromInchesToTheSixth(metertothesixth.InchesToTheSixth).MetersToTheSixth);
+            Assert.Equal(3, WarpingMomentOfInertia.FromMetersToTheSixth(metertothesixth.MetersToTheSixth).MetersToTheSixth);
+            Assert.Equal(3, WarpingMomentOfInertia.FromMillimetersToTheSixth(metertothesixth.MillimetersToTheSixth).MetersToTheSixth);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
             WarpingMomentOfInertia v = WarpingMomentOfInertia.FromMetersToTheSixth(1);
-            AssertEx.EqualTolerance(-1, -v.MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(2, (WarpingMomentOfInertia.FromMetersToTheSixth(3)-v).MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(2, (v + v).MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(10, (v*10).MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(10, (10*v).MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(2, (WarpingMomentOfInertia.FromMetersToTheSixth(10)/5).MetersToTheSixth, MetersToTheSixthTolerance);
-            AssertEx.EqualTolerance(2, WarpingMomentOfInertia.FromMetersToTheSixth(10)/WarpingMomentOfInertia.FromMetersToTheSixth(5), MetersToTheSixthTolerance);
+            Assert.Equal(-1, -v.MetersToTheSixth);
+            Assert.Equal(2, (WarpingMomentOfInertia.FromMetersToTheSixth(3) - v).MetersToTheSixth);
+            Assert.Equal(2, (v + v).MetersToTheSixth);
+            Assert.Equal(10, (v * 10).MetersToTheSixth);
+            Assert.Equal(10, (10 * v).MetersToTheSixth);
+            Assert.Equal(2, (WarpingMomentOfInertia.FromMetersToTheSixth(10) / 5).MetersToTheSixth);
+            Assert.Equal(2, WarpingMomentOfInertia.FromMetersToTheSixth(10) / WarpingMomentOfInertia.FromMetersToTheSixth(5));
         }
 
         [Fact]
@@ -560,8 +620,6 @@ public void CompareToThrowsOnNull()
         [Theory]
         [InlineData(1, WarpingMomentOfInertiaUnit.MeterToTheSixth, 1, WarpingMomentOfInertiaUnit.MeterToTheSixth, true)]  // Same value and unit.
         [InlineData(1, WarpingMomentOfInertiaUnit.MeterToTheSixth, 2, WarpingMomentOfInertiaUnit.MeterToTheSixth, false)] // Different value.
-        [InlineData(2, WarpingMomentOfInertiaUnit.MeterToTheSixth, 1, WarpingMomentOfInertiaUnit.CentimeterToTheSixth, false)] // Different value and unit.
-        [InlineData(1, WarpingMomentOfInertiaUnit.MeterToTheSixth, 1, WarpingMomentOfInertiaUnit.CentimeterToTheSixth, false)] // Different unit.
         public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, WarpingMomentOfInertiaUnit unitA, double valueB, WarpingMomentOfInertiaUnit unitB, bool expectEqual)
         {
             var a = new WarpingMomentOfInertia(valueA, unitA);
@@ -621,8 +679,8 @@ public void Equals_WithTolerance(double firstValue, double secondValue)
             var quantity = WarpingMomentOfInertia.FromMetersToTheSixth(firstValue);
             var otherQuantity = WarpingMomentOfInertia.FromMetersToTheSixth(secondValue);
             WarpingMomentOfInertia maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-            var largerTolerance = maxTolerance * 1.1;
-            var smallerTolerance = maxTolerance / 1.1;
+            var largerTolerance = maxTolerance * 1.1m;
+            var smallerTolerance = maxTolerance / 1.1m;
             Assert.True(quantity.Equals(quantity, WarpingMomentOfInertia.Zero));
             Assert.True(quantity.Equals(quantity, maxTolerance));
             Assert.True(quantity.Equals(otherQuantity, maxTolerance));
@@ -641,7 +699,7 @@ public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
         [Fact]
         public void HasAtLeastOneAbbreviationSpecified()
         {
-            var units = Enum.GetValues<WarpingMomentOfInertiaUnit>();
+            var units = EnumHelper.GetValues<WarpingMomentOfInertiaUnit>();
             foreach (var unit in units)
             {
                 var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit);
@@ -654,6 +712,18 @@ public void BaseDimensionsShouldNeverBeNull()
             Assert.False(WarpingMomentOfInertia.BaseDimensions is null);
         }
 
+        [Fact]
+        public void Units_ReturnsTheQuantityInfoUnits()
+        {
+            Assert.Equal(WarpingMomentOfInertia.Info.Units, WarpingMomentOfInertia.Units);
+        }
+
+        [Fact]
+        public void DefaultConversionFunctions_ReturnsTheDefaultUnitConverter()
+        {
+            Assert.Equal(UnitConverter.Default, WarpingMomentOfInertia.DefaultConversionFunctions);
+        }
+
         [Fact]
         public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
         {
@@ -680,26 +750,6 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 mm⁶", new WarpingMomentOfInertia(1, WarpingMomentOfInertiaUnit.MillimeterToTheSixth).ToString(swedishCulture));
         }
 
-        [Fact]
-        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
-        {
-            var _ = new CultureScope(CultureInfo.InvariantCulture);
-            Assert.Equal("0.1 m⁶", new WarpingMomentOfInertia(0.123456, WarpingMomentOfInertiaUnit.MeterToTheSixth).ToString("s1"));
-            Assert.Equal("0.12 m⁶", new WarpingMomentOfInertia(0.123456, WarpingMomentOfInertiaUnit.MeterToTheSixth).ToString("s2"));
-            Assert.Equal("0.123 m⁶", new WarpingMomentOfInertia(0.123456, WarpingMomentOfInertiaUnit.MeterToTheSixth).ToString("s3"));
-            Assert.Equal("0.1235 m⁶", new WarpingMomentOfInertia(0.123456, WarpingMomentOfInertiaUnit.MeterToTheSixth).ToString("s4"));
-        }
-
-        [Fact]
-        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
-        {
-            var culture = CultureInfo.InvariantCulture;
-            Assert.Equal("0.1 m⁶", new WarpingMomentOfInertia(0.123456, WarpingMomentOfInertiaUnit.MeterToTheSixth).ToString("s1", culture));
-            Assert.Equal("0.12 m⁶", new WarpingMomentOfInertia(0.123456, WarpingMomentOfInertiaUnit.MeterToTheSixth).ToString("s2", culture));
-            Assert.Equal("0.123 m⁶", new WarpingMomentOfInertia(0.123456, WarpingMomentOfInertiaUnit.MeterToTheSixth).ToString("s3", culture));
-            Assert.Equal("0.1235 m⁶", new WarpingMomentOfInertia(0.123456, WarpingMomentOfInertiaUnit.MeterToTheSixth).ToString("s4", culture));
-        }
-
         [Theory]
         [InlineData(null)]
         [InlineData("en-US")]
@@ -726,7 +776,8 @@ public void ToString_NullProvider_EqualsCurrentCulture(string format)
         public void GetHashCode_Equals()
         {
             var quantity = WarpingMomentOfInertia.FromMetersToTheSixth(1.0);
-            Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode());
+            var expected = Comparison.GetHashCode(typeof(WarpingMomentOfInertia), quantity.As(WarpingMomentOfInertia.BaseUnit));
+            Assert.Equal(expected, quantity.GetHashCode());
         }
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedQuantityCodeTests.cs b/UnitsNet.Tests/GeneratedQuantityCodeTests.cs
index 19b0af3ebe..82e598637f 100644
--- a/UnitsNet.Tests/GeneratedQuantityCodeTests.cs
+++ b/UnitsNet.Tests/GeneratedQuantityCodeTests.cs
@@ -1,6 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using Xunit;
 
 namespace UnitsNet.Tests
@@ -13,20 +14,88 @@ namespace UnitsNet.Tests
     public class GeneratedQuantityCodeTests
     {
         /// <summary>
-        ///     Types with <see cref="double" /> as internal representation. This is the majority of units, such as
-        ///     <see cref="Length" />.
+        ///     Types with <see cref="QuantityValue" /> as internal representation. 
         /// </summary>
-        public class QuantitiesWithDouble
+        public class QuantitiesWithFractions
         {
             [Fact]
             public void LengthEquals_GivenMaxError_ReturnsTrueIfWithinError()
             {
                 Assert.True(Length.FromMeters(1).Equals(Length.FromMeters(1), Length.Zero), "Equal values have zero difference.");
-                Assert.True(Length.FromMeters(1).Equals(Length.FromMeters(1), Length.FromMillimeters(1e-5)), "Using a max difference value should not change that fact.");
+                Assert.True(Length.FromMeters(1).Equals(Length.FromMeters(1), Length.FromMillimeters(1e-5m)), "Using a max difference value should not change that fact.");
 
-                Assert.False(Length.FromMeters(1 + 0.39).Equals(Length.FromMeters(1.39), Length.Zero),
-                    "Example of floating precision arithmetic that produces slightly different results.");
-                Assert.True(Length.FromMeters(1 + 0.39).Equals(Length.FromMeters(1.39), Length.FromMillimeters(1e-5)), "But the difference is very small");
+                Assert.True(Length.FromMeters(1 + 0.39).Equals(Length.FromMeters(1.39)),
+                    "Example of floating precision arithmetic that would originally produces slightly different results is now correct:" +
+                    "this is due to the implicit rounding (15 significant digits) that is applied when constructing from double.");
+                
+                Assert.True(Length.FromMeters((1 + 0.39) / double.MaxValue).Equals(Length.FromMeters(1.39 / double.MaxValue)),
+                    "This is also true for very small values as they would be rounded the same way.");
+                
+                Assert.False((1.39 / double.MaxValue).Equals(Length.FromMeters(1.39 / double.MaxValue).Value.ToDouble()),
+                    "The conversion back to double is not guaranteed to round-trip");
+            }
+            
+            [Fact]
+            public void QuantityValueComparisonEqualsAbsolute_ReturnsTrueIfWithinError()
+            {
+                Assert.True(Comparison.EqualsAbsolute(1, 1, 0));
+                Assert.True(Comparison.EqualsAbsolute(1, 1, 0.001m));
+                Assert.True(Comparison.EqualsAbsolute(1, 0.9999m, 0.001m));
+                Assert.False(Comparison.EqualsAbsolute(1, 0.99m, 0.001m));
+                Assert.False(Comparison.EqualsAbsolute(1, 0, 0.001m));
+            }
+
+            [Fact]
+            public void QuantityValueComparisonEqualsAbsolute_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
+            {
+                Assert.Throws<ArgumentOutOfRangeException>(() => Comparison.EqualsAbsolute(1, 1, -1));
+            }
+            
+            [Fact]
+            public void QuantityValueComparisonEquals_GivenAbsoluteTolerance_ReturnsTrueIfWithinError()
+            {
+                Assert.True(Comparison.Equals(1, 1, 0, ComparisonType.Absolute));
+                Assert.True(Comparison.Equals(1, 1, 0.001m, ComparisonType.Absolute));
+                Assert.True(Comparison.Equals(1, 0.9999m, 0.001m, ComparisonType.Absolute));
+                Assert.False(Comparison.Equals(1, 0.99m, 0.001m, ComparisonType.Absolute));
+                Assert.False(Comparison.Equals(1, 0, 0.001m, ComparisonType.Absolute));
+            }
+
+            [Fact]
+            public void QuantityValueComparisonEquals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
+            {
+                Assert.Throws<ArgumentOutOfRangeException>(() => Comparison.Equals(1, 1, -1, ComparisonType.Absolute));
+                Assert.Throws<ArgumentOutOfRangeException>(() => Comparison.Equals(1, 1, -1, ComparisonType.Relative));
+            }
+
+            [Fact]
+            public void QuantityValueComparisonEquals_WithInvalidComparisonType_ThrowsArgumentOutOfRangeException()
+            {
+                Assert.Throws<InvalidOperationException>(() => Comparison.Equals(1, 1, 1, (ComparisonType)(-1)));
+            }
+            
+            [Fact]
+            public void QuantityValueComparisonEqualsRelative_ReturnsTrueIfWithinError()
+            {
+                Assert.True(Comparison.EqualsRelative(1, 1, 1e-5m));
+                Assert.False(Comparison.EqualsRelative(1, 0, 1e-5m));
+                Assert.True(Comparison.EqualsRelative(100, 120, 0.3m));
+                Assert.False(Comparison.EqualsRelative(100, 120, 0.1m));
+            }
+            
+            [Fact]
+            public void QuantityValueComparisonEqualsRelative_WithNegativeTolerance_ThrowsArgumentOutOfRangeException()
+            {
+                Assert.Throws<ArgumentOutOfRangeException>(() => Comparison.EqualsRelative(1, 1, -1));
+            }
+
+            [Fact]
+            public void QuantityValueComparisonEquals_GivenRelativeTolerance_ReturnsTrueIfWithinError()
+            {
+                Assert.True(Comparison.Equals(1, 1, 1e-5m, ComparisonType.Relative));
+                Assert.False(Comparison.Equals(1, 0, 1e-5m, ComparisonType.Relative));
+                Assert.True(Comparison.Equals(100, 120, 0.3m, ComparisonType.Relative));
+                Assert.False(Comparison.Equals(100, 120, 0.1m, ComparisonType.Relative));
             }
 
             [Fact]
@@ -64,16 +133,16 @@ public void HasMultiplicationOperator_GivenTwoQuantities_ReturnsTrueIfDimensions
             {
                 foreach (var firstQuantity in Quantity.Infos)
                 {
-                    foreach (var divisor in GetMultipliers(firstQuantity.ValueType))
+                    foreach (var divisor in GetMultipliers(firstQuantity.QuantityType))
                     {
-                        var secondQuantity = Quantity.Infos.FirstOrDefault(x => x.ValueType == divisor);
+                        var secondQuantity = Quantity.Infos.FirstOrDefault(x => x.QuantityType == divisor);
                         if (secondQuantity == null)
                         {
                             continue; // scalers
                         }
                         var resultDimensions = firstQuantity.BaseDimensions * secondQuantity.BaseDimensions;
-                        var resultingType = GetMultiplicationResult(firstQuantity.ValueType, secondQuantity.ValueType);
-                        var resultQuantity = Quantity.Infos.FirstOrDefault(x => x.ValueType == resultingType);
+                        var resultingType = GetMultiplicationResult(firstQuantity.QuantityType, secondQuantity.QuantityType);
+                        var resultQuantity = Quantity.Infos.FirstOrDefault(x => x.QuantityType == resultingType);
                         if (resultQuantity == null)
                         {
                             continue; // scalers
@@ -96,8 +165,8 @@ public void HasDivisionOperator_GivenTwoQuantities_ReturnsTrueIfDimensionsDivisi
                             continue; // scalers
                         }
                         var resultDimensions = firstQuantity.BaseDimensions / secondQuantity.BaseDimensions;
-                        var resultingType = GetDivisionResult(firstQuantity.ValueType, secondQuantity.ValueType);
-                        var resultQuantity = Quantity.Infos.FirstOrDefault(x => x.ValueType == resultingType);
+                        var resultingType = GetDivisionResult(firstQuantity.QuantityType, secondQuantity.QuantityType);
+                        var resultQuantity = Quantity.Infos.FirstOrDefault(x => x.QuantityType == resultingType);
                         if (resultQuantity == null)
                         {
                             continue; // scalers
@@ -107,6 +176,33 @@ public void HasDivisionOperator_GivenTwoQuantities_ReturnsTrueIfDimensionsDivisi
                 }
             }
 
+            public static IEnumerable<object[]> QuantitiesToMultiply { get; } = Quantity.Infos.SelectMany(s => GetMultipliers(s.QuantityType)
+                .Where(multiplier=>
+                {
+                    if (!Quantity.ByName.ContainsKey(multiplier.Name)) return false;
+                    Type? multiplicationResult = GetMultiplicationResult(s.QuantityType, multiplier);
+                    return multiplicationResult != null && Quantity.ByName.ContainsKey(multiplicationResult.Name);
+                }).Select(type => type.Name).Select(typeName => new[] { s.Name, typeName })).ToArray();
+
+            [Theory(Skip = "Currently failing due to ElectricCurrent, MolarFlow, TemperatureGradient and FuelEfficiency")]
+            [MemberData(nameof(QuantitiesToMultiply))]
+            public void MultiplyingTwoQuantities_ReturnsQuantityInSIUnits(string leftName, string rightName)
+            {
+                var firstQuantity = Quantity.ByName[leftName];
+                var secondQuantity = Quantity.ByName[rightName];
+
+                IQuantity result = Multiply(firstQuantity.BaseUnitInfo.From(1), secondQuantity.BaseUnitInfo.From(1));
+                if (result.QuantityInfo.BaseDimensions.IsDimensionless())
+                {
+                    Assert.Equal(result.QuantityInfo.BaseUnitInfo.Value, result.Unit);
+                }
+                // excluding results that don't have a valid base unit such as FuelEfficiency
+                else if(result.QuantityInfo.UnitInfos.Any(unit => unit.BaseUnits.IsSubsetOf(UnitSystem.SI.BaseUnits)))
+                {
+                    Assert.True(result.QuantityInfo[result.Unit].BaseUnits.IsSubsetOf(UnitSystem.SI.BaseUnits));
+                }
+            }
+
             private static bool HasMultiplicationOperator(Type t, Type operandType)
             {
                 var operation = t.GetMethod("op_Multiply", new[] { t, operandType });
@@ -142,6 +238,23 @@ private static IEnumerable<Type> GetDivisors(Type t)
                 return t.GetMethods().Where(x => x.IsSpecialName && x.Name == "op_Division" && x.CustomAttributes.All(a => a.AttributeType != typeof(ObsoleteAttribute)))
                     .SelectMany(x => x.GetParameters().Skip(1).Select(p => p.ParameterType));
             }
+            
+            private static IQuantity Multiply(IQuantity left, IQuantity right)
+            {
+                var leftType = left.GetType();
+                var rightType = right.GetType();
+                var multiplyMethod = GetMultiplyMethod(leftType, rightType);
+                return (IQuantity)multiplyMethod.Invoke(null, new object[] { left, right })!;
+            }
+            private static MethodInfo GetMultiplyMethod(Type selfType, Type otherType)
+            {
+                return selfType.GetMethods(BindingFlags.Static | BindingFlags.Public)
+                    .FirstOrDefault(m => m.Name == "op_Multiply" &&
+                                         m.GetParameters().Length == 2 &&
+                                         m.GetParameters()[0].ParameterType == selfType &&
+                                         m.GetParameters()[1].ParameterType == otherType)!;
+            }
+
         }
     }
 }
diff --git a/UnitsNet.Tests/GenericMathExtensionsTests.cs b/UnitsNet.Tests/GenericMathExtensionsTests.cs
index a35bf44e47..96f7293ff8 100644
--- a/UnitsNet.Tests/GenericMathExtensionsTests.cs
+++ b/UnitsNet.Tests/GenericMathExtensionsTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.Tests/GlobalUsings.cs b/UnitsNet.Tests/GlobalUsings.cs
index 535396ed9d..2acb28d1c6 100644
--- a/UnitsNet.Tests/GlobalUsings.cs
+++ b/UnitsNet.Tests/GlobalUsings.cs
@@ -1,3 +1,3 @@
-global using Xunit;
+global using Xunit;
 global using UnitsNet.Units;
 
diff --git a/UnitsNet.Tests/Helpers/TypeDescriptorContext.cs b/UnitsNet.Tests/Helpers/TypeDescriptorContext.cs
index 35c4ad79d4..e04596fcaf 100644
--- a/UnitsNet.Tests/Helpers/TypeDescriptorContext.cs
+++ b/UnitsNet.Tests/Helpers/TypeDescriptorContext.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/InterUnitConversionTests.cs b/UnitsNet.Tests/InterUnitConversionTests.cs
index d19bd70de0..6b42b6bd2e 100644
--- a/UnitsNet.Tests/InterUnitConversionTests.cs
+++ b/UnitsNet.Tests/InterUnitConversionTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using Xunit;
diff --git a/UnitsNet.Tests/LinearQuantityExtensionsTest.cs b/UnitsNet.Tests/LinearQuantityExtensionsTest.cs
index 0f24f1b316..45c75b0b5f 100644
--- a/UnitsNet.Tests/LinearQuantityExtensionsTest.cs
+++ b/UnitsNet.Tests/LinearQuantityExtensionsTest.cs
@@ -1,14 +1,15 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
+using UnitsNet.Tests.CustomQuantities;
+
 namespace UnitsNet.Tests;
 
 public class LinearQuantityExtensionsTest
 {
     [Theory]
     [InlineData(2.0, 2.0, 0.1, true)]
-    // [InlineData(2.0, 2.1, 0.1, true)] // should be equal but fails due to rounding
-    [InlineData(2.0, 2.1, 0.10001, true)]
+    [InlineData(2.0, 2.1, 0.1, true)]
     [InlineData(2.0, 2.2, 0.1, false)]
     [InlineData(2.0, 2.0, 0.0, true)]
     [InlineData(2.0, 2.1, 0.0, false)]
@@ -23,7 +24,7 @@ public void Equals_WithTolerance_ReturnsExpectedResult(double value1, double val
         Assert.Equal(expected, result);
     }
 
-    [Fact(Skip = "Fails due to rounding")]
+    [Fact]
     public void Equals_WithToleranceAtTheLimit_ReturnsTrue()
     {
         var quantity = Length.FromMeters(1);
@@ -46,8 +47,7 @@ public void Equals_WithToleranceAtTheLimit_ReturnsTrue()
 
     [Theory]
     [InlineData(2.0, 2.0, 0.1, true)]
-    // [InlineData(2.0, 2.1, 0.1, true)]  // should be equal but fails due to rounding
-    [InlineData(2.0, 2.1, 0.10001, true)] 
+    [InlineData(2.0, 2.1, 0.1, true)]
     [InlineData(2.0, 2.2, 0.1, false)]
     [InlineData(2.0, 2.0, 0.0, true)]
     [InlineData(2.0, 2.1, 0.0, false)]
@@ -68,12 +68,26 @@ public void Equals_WithNullOther_ReturnsFalse()
         var quantity = Length.FromMeters(2.0);
         var tolerance = Length.FromMeters(0.1);
 
+        // since 'other' is not a reference type, this ends up calling the IQuantity overload
         var result = quantity.Equals(null, tolerance);
 
         Assert.False(result);
     }
-    
-    [Fact(Skip = "Currently throws a StackOverflowException")]
+
+    [Fact]
+    public void Equals_TQuantity_WithNullOther_ReturnsFalse()
+    {
+        var quantity = new ClassOfLinearQuantity(2, ClassOfLinearQuantityUnit.ATon);
+        var tolerance = new ClassOfLinearQuantity(0.1m, ClassOfLinearQuantityUnit.Some);
+        ClassOfLinearQuantity? nullOther = null;
+
+        // since 'other' is a reference type, this is calling the TQuantity overload
+        var result = quantity.Equals(nullOther, tolerance);
+
+        Assert.False(result);
+    }
+
+    [Fact]
     public void Equals_TQuantity_WithUnknownUnits_ThrowsUnitNotFoundException()
     {
         var quantity = Length.FromMeters(1);
@@ -83,7 +97,7 @@ public void Equals_TQuantity_WithUnknownUnits_ThrowsUnitNotFoundException()
         Assert.Throws<UnitNotFoundException>(() => quantity.Equals(quantity, invalidQuantity));
     }
 
-    [Fact(Skip = "Currently throws a StackOverflowException")]
+    [Fact]
     public void Equals_IQuantity_WithUnknownUnits_ThrowsUnitNotFoundException()
     {
         var quantity = Length.FromMeters(1);
diff --git a/UnitsNet.Tests/LogarithmicQuantityExtensionsTest.cs b/UnitsNet.Tests/LogarithmicQuantityExtensionsTest.cs
index 3407d45ea0..43ae441b02 100644
--- a/UnitsNet.Tests/LogarithmicQuantityExtensionsTest.cs
+++ b/UnitsNet.Tests/LogarithmicQuantityExtensionsTest.cs
@@ -1,11 +1,24 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
+using UnitsNet.Tests.CustomQuantities;
+using UnitsNet.InternalHelpers;
 
 namespace UnitsNet.Tests;
 
 public class LogarithmicQuantityExtensionsTest
 {
+    [Theory]
+    [InlineData(8, 3, 2)]
+    [InlineData(-8, 3, -2)]
+    [InlineData(-16, 2, double.NaN)]
+    public void MathHelper_RootN_ReturnsExpectedRoot(double number, int n, double expected)
+    {
+        double actual = MathHelper.RootN(number, n);
+
+        Assert.Equal(expected, actual);
+    }
+
     [Theory]
     [InlineData(1, 2)]
     [InlineData(100, 110)]
@@ -15,8 +28,8 @@ public void Equals_TQuantity_ComparesInLinearSpace(double firstValue, double sec
         var quantity = PowerRatio.FromDecibelWatts(firstValue);
         var otherQuantity = PowerRatio.FromDecibelWatts(secondValue);
         PowerRatio maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-        PowerRatio largerTolerance = maxTolerance * 1.1;
-        PowerRatio smallerTolerance = maxTolerance / 1.1;
+        PowerRatio largerTolerance = maxTolerance * 1.1m;
+        PowerRatio smallerTolerance = maxTolerance / 1.1m;
         Assert.True(quantity.Equals(quantity, PowerRatio.Zero));
         Assert.True(quantity.Equals(quantity, maxTolerance));
         Assert.True(quantity.Equals(otherQuantity, largerTolerance));
@@ -34,8 +47,8 @@ public void Equals_IQuantity_ComparesInLinearSpace(double firstValue, double sec
         var quantity = PowerRatio.FromDecibelWatts(firstValue);
         var otherQuantity = PowerRatio.FromDecibelWatts(secondValue);
         PowerRatio maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity;
-        PowerRatio largerTolerance = maxTolerance * 1.1;
-        PowerRatio smallerTolerance = maxTolerance / 1.1;
+        PowerRatio largerTolerance = maxTolerance * 1.1m;
+        PowerRatio smallerTolerance = maxTolerance / 1.1m;
         Assert.True(quantity.Equals((IQuantity)quantity, PowerRatio.Zero));
         Assert.True(quantity.Equals((IQuantity)quantity, maxTolerance));
         Assert.True(quantity.Equals((IQuantity)otherQuantity, largerTolerance));
@@ -49,10 +62,27 @@ public void Equals_NullQuantity_ReturnsFalse()
     {
         var quantity = PowerRatio.FromDecibelWatts(1);
         var tolerance = PowerRatio.FromDecibelWatts(1);
-        Assert.False(quantity.Equals(null, tolerance));
+
+        // since 'other' is not a reference type, this ends up calling the IQuantity overload
+        var result = quantity.Equals(null, tolerance);
+        
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void Equals_TQuantity_WithNullOther_ReturnsFalse()
+    {
+        var quantity = new ClassOfLogarithmicQuantity(2, ClassOfLogarithmicQuantityUnit.ATon);
+        var tolerance = new ClassOfLogarithmicQuantity(0.1m, ClassOfLogarithmicQuantityUnit.Some);
+        ClassOfLogarithmicQuantity? nullOther = null;
+
+        // since 'other' is a reference type, this is calling the TQuantity overload
+        var result = quantity.Equals(nullOther, tolerance);
+
+        Assert.False(result);
     }
-    
-    [Fact(Skip = "Currently throws a StackOverflowException")]
+
+    [Fact]
     public void Equals_TQuantity_WithUnknownUnits_ThrowsUnitNotFoundException()
     {
         var quantity = PowerRatio.FromDecibelWatts(1);
@@ -61,8 +91,8 @@ public void Equals_TQuantity_WithUnknownUnits_ThrowsUnitNotFoundException()
         Assert.Throws<UnitNotFoundException>(() => quantity.Equals(invalidQuantity, quantity));
         Assert.Throws<UnitNotFoundException>(() => quantity.Equals(quantity, invalidQuantity));
     }
-    
-    [Fact(Skip = "Currently throws a StackOverflowException")]
+
+    [Fact]
     public void Equals_IQuantity_WithUnknownUnits_ThrowsUnitNotFoundException()
     {
         var quantity = PowerRatio.FromDecibelWatts(1);
@@ -151,7 +181,7 @@ public void Sum_SingleQuantity_ReturnsCorrectSum(double value, PowerRatioUnit un
 
         PowerRatio result = quantities.Sum();
 
-        Assert.Equal(quantity.Value, result.Value, 1e-5);
+        Assert.Equal(quantity.Value, result.Value);
         Assert.Equal(quantity.Unit, result.Unit);
     }
 
@@ -167,8 +197,8 @@ public void Sum_SingleQuantity_WithSelector_ReturnsCorrectSum(double value, Powe
         IEnumerable<PowerRatio> quantities = new List<PowerRatio> { quantity };
 
         PowerRatio result = quantities.Sum(x => x);
-        
-        Assert.Equal(quantity.Value, result.Value, 1e-5);
+
+        Assert.Equal(quantity.Value, result.Value);
         Assert.Equal(quantity.Unit, result.Unit);
     }
 
@@ -196,7 +226,7 @@ public void Sum_ReturnsCorrectSum(double value1, PowerRatioUnit unit1, double va
 
         PowerRatio result = quantities.Sum();
 
-        Assert.Equal(expectedValue.Value, result.Value, 1e-5);
+        Assert.Equal(expectedValue, result);
         Assert.Equal(unit1, result.Unit);
     }
 
@@ -223,8 +253,8 @@ public void Sum_WithSelector_ReturnsCorrectSum(double value1, PowerRatioUnit uni
         PowerRatio expectedValue = quantity1 + quantity2;
 
         PowerRatio result = quantities.Sum(x => x);
-        
-        Assert.Equal(expectedValue.Value, result.Value, 1e-5);
+
+        Assert.Equal(expectedValue, result);
         Assert.Equal(unit1, result.Unit);
     }
 
@@ -251,8 +281,8 @@ public void Sum_WithSelectorAndUnit_ReturnsCorrectSum(double value1, PowerRatioU
         PowerRatio expectedValue = quantity1 + quantity2;
 
         PowerRatio result = quantities.Sum(x => x, unit1);
-        
-        Assert.Equal(expectedValue.Value, result.Value, 1e-5);
+
+        Assert.Equal(expectedValue, result);
         Assert.Equal(unit1, result.Unit);
     }
 
@@ -261,7 +291,7 @@ public void ArithmeticMean_ThrowsOnEmptyCollection()
     {
         PowerRatio[] quantities = [];
 
-        Assert.Throws<InvalidOperationException>(() => LogarithmicQuantityExtensions.ArithmeticMean(quantities));
+        Assert.Throws<InvalidOperationException>(() => quantities.ArithmeticMean(15));
     }
 
     [Fact]
@@ -285,7 +315,7 @@ public void ArithmeticMean_WithNullSequence_ThrowsArgumentNullException()
     {
         PowerRatio[] quantities = null!;
 
-        Assert.Throws<ArgumentNullException>(() => LogarithmicQuantityExtensions.ArithmeticMean(quantities));
+        Assert.Throws<ArgumentNullException>(() => quantities.ArithmeticMean(15));
     }
 
     [Fact]
@@ -293,7 +323,7 @@ public void ArithmeticMean_WithNullSequenceAndUnit_ThrowsArgumentNullException()
     {
         PowerRatio[] quantities = null!;
 
-        Assert.Throws<ArgumentNullException>(() => LogarithmicQuantityExtensions.ArithmeticMean(quantities, PowerRatioUnit.DecibelWatt));
+        Assert.Throws<ArgumentNullException>(() => quantities.ArithmeticMean(PowerRatioUnit.DecibelWatt, 15));
     }
 
     [Fact]
@@ -315,9 +345,9 @@ public void ArithmeticMean_SingleQuantity_ReturnsCorrectMean(double value, Power
         var quantity = new PowerRatio(value, unit);
         IEnumerable<PowerRatio> quantities = new List<PowerRatio> { quantity };
 
-        PowerRatio result = LogarithmicQuantityExtensions.ArithmeticMean(quantities);
+        PowerRatio result = quantities.ArithmeticMean(15);
 
-        Assert.Equal(quantity.Value, result.Value, 1e-5);
+        Assert.Equal(quantity.Value, result.Value);
         Assert.Equal(quantity.Unit, result.Unit);
     }
 
@@ -333,8 +363,8 @@ public void ArithmeticMean_SingleQuantity_WithSelector_ReturnsCorrectMean(double
         IEnumerable<PowerRatio> quantities = new List<PowerRatio> { quantity };
 
         PowerRatio result = quantities.ArithmeticMean(x => x);
-        
-        Assert.Equal(quantity.Value, result.Value, 1e-5);
+
+        Assert.Equal(quantity.Value, result.Value);
         Assert.Equal(quantity.Unit, result.Unit);
     }
 
@@ -358,13 +388,13 @@ public void ArithmeticMean_ReturnsCorrectMean(double value1, PowerRatioUnit unit
         var quantity1 = new PowerRatio(value1, unit1);
         var quantity2 = new PowerRatio(value2, unit2);
         IEnumerable<PowerRatio> quantities = new List<PowerRatio> { quantity1, quantity2 };
-        var scalingFactor = PowerRatio.LogarithmicScalingFactor;
-        var expectedValue =
+        QuantityValue scalingFactor = PowerRatio.LogarithmicScalingFactor;
+        QuantityValue expectedValue =
             ((quantity1.Value.ToLinearSpace(scalingFactor) + quantity2.As(unit1).ToLinearSpace(scalingFactor)) / 2).ToLogSpace(scalingFactor);
 
-        PowerRatio result = LogarithmicQuantityExtensions.ArithmeticMean(quantities);
+        PowerRatio result = quantities.ArithmeticMean(15);
 
-        Assert.Equal(expectedValue, result.Value, 1e-5);
+        Assert.Equal(expectedValue, result.Value);
         Assert.Equal(unit1, result.Unit);
     }
 
@@ -388,13 +418,13 @@ public void ArithmeticMean_WithSelector_ReturnsCorrectMean(double value1, PowerR
         var quantity1 = new PowerRatio(value1, unit1);
         var quantity2 = new PowerRatio(value2, unit2);
         IEnumerable<PowerRatio> quantities = new List<PowerRatio> { quantity1, quantity2 };
-        var scalingFactor = PowerRatio.LogarithmicScalingFactor;
-        var expectedValue =
+        QuantityValue scalingFactor = PowerRatio.LogarithmicScalingFactor;
+        QuantityValue expectedValue =
             ((quantity1.Value.ToLinearSpace(scalingFactor) + quantity2.As(unit1).ToLinearSpace(scalingFactor)) / 2).ToLogSpace(scalingFactor);
 
         PowerRatio result = quantities.ArithmeticMean(x => x);
 
-        Assert.Equal(expectedValue, result.Value, 1e-5);
+        Assert.Equal(expectedValue, result.Value);
         Assert.Equal(unit1, result.Unit);
     }
 
@@ -418,13 +448,13 @@ public void ArithmeticMean_WithSelectorAndUnit_ReturnsCorrectMean(double value1,
         var quantity1 = new PowerRatio(value1, unit1);
         var quantity2 = new PowerRatio(value2, unit2);
         IEnumerable<PowerRatio> quantities = new List<PowerRatio> { quantity1, quantity2 };
-        var scalingFactor = PowerRatio.LogarithmicScalingFactor;
-        var expectedValue =
+        QuantityValue scalingFactor = PowerRatio.LogarithmicScalingFactor;
+        QuantityValue expectedValue =
             ((quantity1.Value.ToLinearSpace(scalingFactor) + quantity2.As(unit1).ToLinearSpace(scalingFactor)) / 2).ToLogSpace(scalingFactor);
 
         PowerRatio result = quantities.ArithmeticMean(x => x, unit1);
 
-        Assert.Equal(expectedValue, result.Value, 1e-5);
+        Assert.Equal(expectedValue, result.Value);
         Assert.Equal(unit1, result.Unit);
     }
 
@@ -489,7 +519,7 @@ public void GeometricMean_SingleQuantity_ReturnsCorrectMean(double value, PowerR
 
         PowerRatio result = quantities.GeometricMean();
 
-        Assert.Equal(quantity.Value, result.Value, 1e-5);
+        Assert.Equal(quantity.Value, result.Value);
         Assert.Equal(quantity.Unit, result.Unit);
     }
 
@@ -506,7 +536,7 @@ public void GeometricMean_SingleQuantity_WithSelector_ReturnsCorrectMean(double
 
         PowerRatio result = quantities.GeometricMean(x => x);
 
-        Assert.Equal(quantity.Value, result.Value, 1e-5);
+        Assert.Equal(quantity.Value, result.Value);
         Assert.Equal(quantity.Unit, result.Unit);
     }
 
@@ -530,11 +560,11 @@ public void GeometricMean_ReturnsCorrectMean(double value1, PowerRatioUnit unit1
         var quantity1 = new PowerRatio(value1, unit1);
         var quantity2 = new PowerRatio(value2, unit2);
         IEnumerable<PowerRatio> quantities = new List<PowerRatio> { quantity1, quantity2 };
-        var expectedValue = double.RootN(quantity1.Value + quantity2.As(unit1), 2);
+        var expectedValue = QuantityValue.RootN(quantity1.Value + quantity2.As(unit1), 2);
 
         PowerRatio result = quantities.GeometricMean();
 
-        Assert.Equal(expectedValue, result.Value, 1e-5);
+        Assert.Equal(expectedValue, result.Value);
         Assert.Equal(unit1, result.Unit);
     }
 
@@ -558,11 +588,11 @@ public void GeometricMean_WithSelector_ReturnsCorrectMean(double value1, PowerRa
         var quantity1 = new PowerRatio(value1, unit1);
         var quantity2 = new PowerRatio(value2, unit2);
         IEnumerable<PowerRatio> quantities = new List<PowerRatio> { quantity1, quantity2 };
-        var expectedValue = double.RootN(quantity1.Value + quantity2.As(unit1), 2);
+        var expectedValue = QuantityValue.RootN(quantity1.Value + quantity2.As(unit1), 2);
 
         PowerRatio result = quantities.GeometricMean(x => x);
 
-        Assert.Equal(expectedValue, result.Value, 1e-5);
+        Assert.Equal(expectedValue, result.Value);
         Assert.Equal(unit1, result.Unit);
     }
 
@@ -586,11 +616,11 @@ public void GeometricMean_WithUnitAndSelector_ReturnsCorrectMean(double value1,
         var quantity1 = new PowerRatio(value1, unit1);
         var quantity2 = new PowerRatio(value2, unit2);
         IEnumerable<PowerRatio> quantities = new List<PowerRatio> { quantity1, quantity2 };
-        var expectedValue = double.RootN(quantity1.Value + quantity2.As(unit1), 2);
+        var expectedValue = QuantityValue.RootN(quantity1.Value + quantity2.As(unit1), 2);
 
         PowerRatio result = quantities.GeometricMean(x => x, unit1);
 
-        Assert.Equal(expectedValue, result.Value, 1e-5);
+        Assert.Equal(expectedValue, result.Value);
         Assert.Equal(unit1, result.Unit);
     }
 }
diff --git a/UnitsNet.Tests/QuantityConversionOptionsTest.cs b/UnitsNet.Tests/QuantityConversionOptionsTest.cs
new file mode 100644
index 0000000000..2101b78a39
--- /dev/null
+++ b/UnitsNet.Tests/QuantityConversionOptionsTest.cs
@@ -0,0 +1,146 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.Tests;
+
+public class QuantityConversionOptionsTest
+{
+    [Fact]
+    public void CustomConversions_ShouldBeEmpty_WhenInitialized()
+    {
+        var options = new QuantityConversionOptions();
+        Assert.Empty(options.CustomConversions);
+    }
+
+    [Fact]
+    public void ConversionUnits_ShouldBeEmpty_WhenInitialized()
+    {
+        var options = new QuantityConversionOptions();
+        Assert.Empty(options.ConversionUnits);
+    }
+
+    [Fact]
+    public void CustomConversionFunctions_ShouldBeEmpty_WhenInitialized()
+    {
+        var options = new QuantityConversionOptions();
+        Assert.Empty(options.CustomConversionFunctions);
+    }
+
+    [Fact]
+    public void SetCustomConversion_ShouldAddConversionMapping()
+    {
+        var expectedConversion = QuantityConversionMapping.Create<Length, Mass>();
+        var options = new QuantityConversionOptions();
+        options.SetCustomConversion<Length, Mass>();
+        Assert.Single(options.CustomConversions, expectedConversion);
+    }
+
+    [Fact]
+    public void SetConversionUnits_ShouldAddUnitConversionMapping()
+    {
+        var options = new QuantityConversionOptions();
+        options.SetConversionUnits(LengthUnit.Meter, MassUnit.Kilogram);
+
+        Assert.Contains(options.ConversionUnits, mapping =>
+            mapping.FromUnitKey.UnitEnumType == typeof(LengthUnit) && mapping.ToUnitKey.UnitEnumType == typeof(MassUnit));
+    }
+
+    [Fact]
+    public void SetCustomConversionFunction_ShouldAddConversionFunction()
+    {
+        var options = new QuantityConversionOptions();
+        ConvertValueDelegate conversionFunction = value => value * 2;
+        options.SetCustomConversion(LengthUnit.Meter, MassUnit.Kilogram, conversionFunction);
+
+        var key = new UnitConversionMapping(UnitKey.ForUnit(LengthUnit.Meter), UnitKey.ForUnit(MassUnit.Kilogram));
+        Assert.True(options.CustomConversionFunctions.ContainsKey(key));
+        Assert.Equal(conversionFunction, options.CustomConversionFunctions[key]);
+    }
+
+    [Fact]
+    public void SetCustomConversion_ShouldThrowException_WhenSameType()
+    {
+        var options = new QuantityConversionOptions();
+        Assert.Throws<InvalidConversionException>(() => options.SetCustomConversion<Length, Length>());
+    }
+
+    [Fact]
+    public void SetConversionUnits_ShouldThrowException_WhenSameUnit()
+    {
+        var options = new QuantityConversionOptions();
+        Assert.Throws<InvalidConversionException>(() => options.SetConversionUnits(LengthUnit.Meter, LengthUnit.Centimeter));
+    }
+
+    [Fact]
+    public void SetCustomConversion_ShouldThrowException_WhenSameUnit()
+    {
+        var options = new QuantityConversionOptions();
+        Assert.Throws<InvalidConversionException>(() => options.SetCustomConversion(LengthUnit.Meter, LengthUnit.Centimeter, 2));
+    }
+
+    [Fact]
+    public void SetCustomConversionFunction_ShouldThrowException_WhenSameUnit()
+    {
+        var options = new QuantityConversionOptions();
+        ConvertValueDelegate conversionFunction = value => value * 2;
+        Assert.Throws<InvalidConversionException>(() => options.SetCustomConversion(LengthUnit.Meter, LengthUnit.Centimeter, conversionFunction));
+    }
+
+    [Fact]
+    public void SetCustomConversion_ShouldBeCommutative()
+    {
+        var options = new QuantityConversionOptions();
+        options.SetCustomConversion<Length, Mass>();
+
+        Assert.Contains(QuantityConversionMapping.Create<Mass, Length>(), options.CustomConversions);
+    }
+
+    [Fact]
+    public void SetConversionUnits_ShouldMapBothDirections_WhenMapBothDirectionsIsTrue()
+    {
+        var options = new QuantityConversionOptions();
+        options.SetConversionUnits(LengthUnit.Meter, MassUnit.Kilogram, true);
+        Assert.Contains(UnitConversionMapping.Create(MassUnit.Kilogram, LengthUnit.Meter), options.ConversionUnits);
+    }
+    
+    [Fact]
+    public void SetConversionUnits_ShouldNotMapBothDirections_WhenMapBothDirectionsIsFalse()
+    {
+        var options = new QuantityConversionOptions();
+        options.SetConversionUnits(LengthUnit.Meter, MassUnit.Kilogram, false);
+        Assert.DoesNotContain(UnitConversionMapping.Create(MassUnit.Kilogram, LengthUnit.Meter), options.ConversionUnits);
+    }
+
+    [Fact]
+    public void SetCustomConversion_ShouldMapBothDirections_WhenMapBothDirectionsIsTrue()
+    {
+        var options = new QuantityConversionOptions();
+        options.SetCustomConversion(LengthUnit.Meter, MassUnit.Kilogram, 2, true);
+
+        Assert.Contains(new UnitConversionMapping(UnitKey.ForUnit(LengthUnit.Meter), UnitKey.ForUnit(MassUnit.Kilogram)), options.CustomConversionFunctions);
+        Assert.Contains(new UnitConversionMapping(UnitKey.ForUnit(MassUnit.Kilogram), UnitKey.ForUnit(LengthUnit.Meter)), options.CustomConversionFunctions);
+    }
+    
+    [Fact]
+    public void SetCustomConversion_ShouldNotMapBothDirections_WhenMapBothDirectionsIsFalse()
+    {
+        var options = new QuantityConversionOptions();
+        options.SetCustomConversion(LengthUnit.Meter, MassUnit.Kilogram, 2, false);
+        
+        Assert.Contains(new UnitConversionMapping(UnitKey.ForUnit(LengthUnit.Meter), UnitKey.ForUnit(MassUnit.Kilogram)), options.CustomConversionFunctions);
+        Assert.DoesNotContain(new UnitConversionMapping(UnitKey.ForUnit(MassUnit.Kilogram), UnitKey.ForUnit(LengthUnit.Meter)), options.CustomConversionFunctions);
+    }
+
+    [Fact]
+    public void SetCustomConversionFunction_ShouldNotBeCommutative()
+    {
+        var options = new QuantityConversionOptions();
+        options.SetCustomConversion(LengthUnit.Meter, MassUnit.Kilogram, value => value * 2);
+
+        Assert.DoesNotContain(new UnitConversionMapping(UnitKey.ForUnit(MassUnit.Kilogram), UnitKey.ForUnit(LengthUnit.Meter)), options.CustomConversionFunctions);
+    }
+}
diff --git a/UnitsNet.Tests/QuantityConversionsBuilderExtensionsTests.cs b/UnitsNet.Tests/QuantityConversionsBuilderExtensionsTests.cs
new file mode 100644
index 0000000000..ec2565a677
--- /dev/null
+++ b/UnitsNet.Tests/QuantityConversionsBuilderExtensionsTests.cs
@@ -0,0 +1,1263 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.Tests;
+
+public class QuantityConversionsBuilderExtensionsTests
+{
+    [Fact]
+    public void QuantityInfoLookup_GetQuantityConversions_ReturnsConversionsForQuantitiesPresentInTheLookup()
+    {
+        var quantityInfoLookup = new QuantityInfoLookup([Area.Info, ReciprocalArea.Info]);
+        IEnumerable<QuantityConversionMapping> quantityConversionMappings = Quantity.DefaultProvider.Conversions;
+
+        QuantityConversion[] conversions = quantityInfoLookup.GetQuantityConversions(quantityConversionMappings).ToArray();
+
+        Assert.Single(conversions);
+        Assert.Equal(Area.Info, conversions[0].LeftQuantity);
+        Assert.Equal(ReciprocalArea.Info, conversions[0].RightQuantity);
+    }
+
+    [Fact]
+    public void QuantityInfoLookup_GetQuantityConversionMappingOptions_WithCustomConversion_ReturnsTheExpectedConversion()
+    {
+        var quantityInfoLookup = new QuantityInfoLookup([Mass.Info, Volume.Info]);
+        QuantityConversionOptions conversionOptions = new QuantityConversionOptions().SetCustomConversion<Mass, Volume>();
+
+        Dictionary<QuantityConversion, QuantityConversionMappingOptions> mappingOptions = quantityInfoLookup.GetQuantityConversionMappingOptions(conversionOptions);
+
+        Assert.Empty(mappingOptions); // no QuantityConversionMappingOptions required
+    }
+
+    [Fact]
+    public void QuantityInfoLookup_GetQuantityConversionMappingOptions_WithCustomUnitMapping_ReturnsTheExpectedConversion()
+    {
+        var quantityInfoLookup = new QuantityInfoLookup([Mass.Info, Volume.Info]);
+        QuantityConversionOptions conversionOptions = new QuantityConversionOptions()
+            .SetCustomConversion<Mass, Volume>()
+            .SetConversionUnits(Mass.BaseUnit, Volume.BaseUnit);
+        var mappingKey = new QuantityConversion(Mass.Info, Volume.Info);
+
+        Dictionary<QuantityConversion, QuantityConversionMappingOptions> mappingOptions = quantityInfoLookup.GetQuantityConversionMappingOptions(conversionOptions);
+
+        Assert.Single(mappingOptions);
+        Assert.Contains(mappingKey, mappingOptions);
+        Assert.Empty(mappingOptions[mappingKey].ConversionExpressions);
+        Assert.Single(mappingOptions[mappingKey].CustomUnitMappings);
+        Assert.Contains(mappingOptions[mappingKey].CustomUnitMappings, pair =>
+            pair.Key == UnitConversionMapping.Create(Mass.BaseUnit, Volume.BaseUnit) &&
+            pair.Value.SourceUnit == Mass.Info.BaseUnitInfo &&
+            pair.Value.TargetUnit == Volume.Info.BaseUnitInfo);
+    }
+
+    [Fact]
+    public void QuantityInfoLookup_GetQuantityConversionMappingOptions_WithCustomUnitMappingAndConversionFunction_ReturnsTheExpectedConversion()
+    {
+        var quantityInfoLookup = new QuantityInfoLookup([Mass.Info, Volume.Info]);
+        var conversionExpression = new ConversionExpression(coefficient: 1);
+        QuantityConversionOptions conversionOptions = new QuantityConversionOptions()
+            .SetCustomConversion<Mass, Volume>()
+            .SetConversionUnits(MassUnit.Gram, VolumeUnit.Liter)
+            .SetCustomConversion(Mass.BaseUnit, Volume.BaseUnit, conversionExpression);
+        var mappingKey = new QuantityConversion(Mass.Info, Volume.Info);
+
+        Dictionary<QuantityConversion, QuantityConversionMappingOptions> mappingOptions = quantityInfoLookup.GetQuantityConversionMappingOptions(conversionOptions);
+
+        Assert.Single(mappingOptions);
+        Assert.Contains(mappingKey, mappingOptions);
+        Assert.Single(mappingOptions[mappingKey].ConversionExpressions);
+        Assert.Contains(mappingOptions[mappingKey].ConversionExpressions, pair =>
+            pair.Key == UnitConversionMapping.Create(Mass.BaseUnit, Volume.BaseUnit) &&
+            pair.Value.SourceUnit == Mass.Info.BaseUnitInfo &&
+            pair.Value.TargetUnit == Volume.Info.BaseUnitInfo &&
+            pair.Value.ConversionExpression == conversionExpression);
+        Assert.Single(mappingOptions[mappingKey].CustomUnitMappings);
+        Assert.Contains(mappingOptions[mappingKey].CustomUnitMappings, pair =>
+            pair.Key == UnitConversionMapping.Create(MassUnit.Gram, VolumeUnit.Liter) &&
+            pair.Value.SourceUnit == Mass.Info[MassUnit.Gram] &&
+            pair.Value.TargetUnit == Volume.Info[VolumeUnit.Liter]);
+    }
+
+    [Fact]
+    public void QuantityInfoLookup_GetQuantityConversionMappingOptions_IgnoresConversionsForQuantitiesNotPresentInTheLookup()
+    {
+        var quantityInfoLookup = new QuantityInfoLookup([Area.Info, ReciprocalArea.Info]);
+        Assert.Multiple(() =>
+        {
+            Assert.Empty(quantityInfoLookup.GetQuantityConversionMappingOptions(new QuantityConversionOptions()
+                .SetConversionUnits(Mass.BaseUnit, Volume.BaseUnit)));
+        }, () =>
+        {
+            Assert.Empty(quantityInfoLookup.GetQuantityConversionMappingOptions(new QuantityConversionOptions()
+                .SetCustomConversion(Mass.BaseUnit, Volume.BaseUnit, 1)));
+        }, () =>
+        {
+            Assert.Empty(quantityInfoLookup.GetQuantityConversionMappingOptions(new QuantityConversionOptions()
+                .SetCustomConversion<Mass, Volume>()
+                .SetConversionUnits(Mass.BaseUnit, Volume.BaseUnit)
+                .SetCustomConversion(Mass.BaseUnit, Volume.BaseUnit, 1)));
+        });
+    }
+
+    [Fact]
+    public void DefaultQuantityInfoLookup_GetQuantityConversions_ReturnsAllDefaultConversions()
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+
+        QuantityConversion[] quantityConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+
+        Assert.Equal(conversionMappings.Count, quantityConversions.Length);
+        Assert.All(conversionMappings.Zip(quantityConversions, (mapping, conversion) => (mapping, conversion)), tuple =>
+        {
+            (QuantityConversionMapping mapping, QuantityConversion conversion) = tuple;
+            Assert.Equal(mapping.FirstQuantityType, conversion.LeftQuantity.QuantityType);
+            Assert.Equal(mapping.SecondQuantityType, conversion.RightQuantity.QuantityType);
+        });
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void NoCaching_ReturnsNoConversions(bool reduceConstants)
+    {
+        IEnumerable<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+
+        IEnumerable<QuantityConversion> conversions = UnitsNetSetup.Default.Quantities.GetQuantityConversions(conversionMappings);
+
+        Assert.Empty(conversions.GetConversionFunctions(ConversionCachingMode.None, reduceConstants));
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void BaseOnlyCaching_ReturnsBaseUnitConversions(bool reduceConstants)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+
+        // there are currently 32 conversions here
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.BaseOnly, reduceConstants)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.All(defaultConversions, conversion =>
+        {
+            Assert.Multiple(
+                () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+        });
+    }
+
+    private static void ConversionsWithBaseUnits_ConvertToTargetQuantity(Dictionary<QuantityConversionKey, QuantityConversionFunction> conversionExpressions,
+        QuantityInfo fromQuantityInfo, QuantityInfo toQuantityInfo)
+    {
+        Assert.All(fromQuantityInfo.UnitInfos, fromUnit =>
+        {
+            var conversionKey = new QuantityConversionKey(fromUnit.UnitKey, toQuantityInfo.UnitType);
+            UnitInfo[] matchingTargetUnits = toQuantityInfo.UnitInfos
+                .Where(targetUnit => targetUnit.BaseUnits == fromUnit.BaseUnits)
+                .ToArray();
+            if (fromUnit.BaseUnits != BaseUnits.Undefined && matchingTargetUnits.Length > 0)
+            {
+                QuantityValue valueToConvert = 123.45m;
+                Assert.Contains(conversionKey, conversionExpressions);
+
+                QuantityConversionFunction conversionFunction = conversionExpressions[conversionKey];
+                // Base-only caching stores one cross-quantity conversion per source unit and target quantity type,
+                // using one compatible target unit as an anchor. Conversions to other target units are completed
+                // afterwards by regular within-quantity conversion. For example, Hertz and PerSecond both declare
+                // Second as their underlying time unit in BaseUnits, but the (DurationUnit.Second, Frequency) cache
+                // key can only target one of them. PerSecond remains reachable through Hertz, so the selected anchor
+                // only needs to be one of the compatible target units.
+                Assert.Contains(conversionFunction.TargetUnit, matchingTargetUnits.Select(targetUnit => targetUnit.UnitKey));
+
+                UnitInfo targetUnit = matchingTargetUnits.Single(unit => unit.UnitKey == conversionFunction.TargetUnit);
+                QuantityValue expectedValue = toQuantityInfo.ConvertFrom(valueToConvert, fromUnit).As(targetUnit.Value);
+                Assert.Equal(expectedValue, conversionFunction.Convert(valueToConvert));
+            }
+            else
+            {
+                Assert.DoesNotContain(conversionKey, conversionExpressions);
+            }
+        });
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void AllCaching_ReturnsAllUnitConversions(bool reduceConstants)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        // there are currently 156 conversions here
+        var expectedNumberOfConversions = defaultConversions.Sum(x => x.LeftQuantity.UnitInfos.Count + x.RightQuantity.UnitInfos.Count);
+
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.All, reduceConstants)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.All(defaultConversions, conversion =>
+        {
+            Assert.Multiple(
+                () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+        });
+        Assert.Equal(expectedNumberOfConversions, conversionExpressions.Count);
+    }
+
+    private static void ConversionsWithAllUnits_ConvertToTargetQuantity(Dictionary<QuantityConversionKey, QuantityConversionFunction> conversionExpressions,
+        QuantityInfo fromQuantityInfo, QuantityInfo toQuantityInfo)
+    {
+        Assert.All(fromQuantityInfo.UnitInfos, fromUnit =>
+        {
+            var conversionKey = new QuantityConversionKey(fromUnit.UnitKey, toQuantityInfo.UnitType);
+            QuantityValue valueToConvert = 123.45m;
+            IQuantity expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnit);
+
+            Assert.Contains(conversionKey, conversionExpressions);
+            QuantityConversionFunction conversionFunction = conversionExpressions[conversionKey];
+            QuantityValue convertedValue = conversionFunction.Convert(valueToConvert);
+            Assert.Equal(expectedQuantity, toQuantityInfo.From(convertedValue, (Enum)conversionFunction.TargetUnit));
+        });
+    }
+
+    [Theory]
+    [InlineData(true,  typeof(Density), true)]
+    [InlineData(true,  typeof(Density), false)]
+    [InlineData(false,  typeof(Density), true)]
+    [InlineData(false, typeof(Density), false)]
+    [InlineData(true,  typeof(SpecificVolume), true)]
+    [InlineData(true,  typeof(SpecificVolume), false)]
+    [InlineData(false,  typeof(SpecificVolume), true)]
+    [InlineData(false, typeof(SpecificVolume), false)]
+    public void AllCaching_WithSpecificNoneOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction, Type customizedType,
+        bool customConstantsReduction)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        // when removing the Density (with it's 56 units) the number of conversions drops from 156 to 100 (there are only 3 units of SpecificVolume which are all cached)
+        var expectedNumberOfConversions = defaultConversions
+            .Sum(x => (x.LeftQuantity.QuantityType == customizedType ? 0 : x.LeftQuantity.UnitInfos.Count) + (x.RightQuantity.QuantityType == customizedType ? 0 : x.RightQuantity.UnitInfos.Count));
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions> { [customizedType] = new(ConversionCachingMode.None, customConstantsReduction) };
+
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.All, defaultConstantsReduction, customCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.Multiple(() => Assert.Equal(expectedNumberOfConversions, conversionExpressions.Count), () =>
+        {
+            Assert.All(defaultConversions, conversion =>
+            {
+                if (conversion.LeftQuantity.QuantityType == customizedType)
+                {
+                    Assert.Multiple(() => { ContainsNoConversionsFor(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                        () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+                }
+                else if (conversion.RightQuantity.QuantityType == customizedType)
+                {
+                    Assert.Multiple(() => { ContainsNoConversionsFor(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); },
+                        () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); });
+                }
+                else
+                {
+                    Assert.Multiple(
+                        () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                        () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+                }
+            });
+        });
+    }
+    [Theory]
+    [InlineData(true,  true, false)]
+    [InlineData(true,   false, false)]
+    [InlineData(false,  true, false)]
+    [InlineData(false, false, false)]
+    [InlineData(true,  true, true)]
+    [InlineData(true,   false, true)]
+    [InlineData(false,  true, true)]
+    [InlineData(false, false, true)]
+    public void AllCaching_WithSpecificNoneOptionsForBoth_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool densityConstantsReduction, bool specificVolumeConstantsReduction)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        // when removing the Density (with its 56 units) and the SpecificVolume (with its 3 units) the number of conversions drops from 156 to 97
+        var expectedNumberOfConversions = defaultConversions
+            .Where(conversion => conversion != new QuantityConversion(Density.Info, SpecificVolume.Info))
+            .Sum(conversion => conversion.LeftQuantity.UnitInfos.Count + conversion.RightQuantity.UnitInfos.Count);
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions>
+        {
+            [typeof(Density)] = new(ConversionCachingMode.None, densityConstantsReduction),
+            [typeof(SpecificVolume)] = new(ConversionCachingMode.None, specificVolumeConstantsReduction)
+        };
+
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.All, defaultConstantsReduction, customCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.Multiple(() => Assert.Equal(expectedNumberOfConversions, conversionExpressions.Count), () =>
+        {
+            Assert.All(defaultConversions, conversion =>
+            {
+                if (conversion.LeftQuantity.QuantityType == typeof(Density) || conversion.LeftQuantity.QuantityType == typeof(SpecificVolume))
+                {
+                    Assert.Multiple(() => { ContainsNoConversionsFor(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                        () => { ContainsNoConversionsFor(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+                }
+                else
+                {
+                    Assert.Multiple(
+                        () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                        () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+                }
+            });
+        });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void AllCaching_WithSpecificBaseOnlyOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool densityConstantsReduction)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(ConversionCachingMode.BaseOnly, densityConstantsReduction) };
+
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.All, defaultConstantsReduction, customCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.All(defaultConversions, conversion =>
+        {
+            if (conversion.LeftQuantity.QuantityType == typeof(Density))
+            {
+                Assert.Multiple(
+                    () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+            }
+            else
+            {
+                Assert.Multiple(
+                    () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+            }
+        });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void AllCaching_WithSpecificAllOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool densityConstantsReduction)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        // the only difference is in the constants reduction parameter (there should still be 156 conversions here)
+        var expectedNumberOfConversions = defaultConversions.Sum(x => x.LeftQuantity.UnitInfos.Count + x.RightQuantity.UnitInfos.Count);
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(ConversionCachingMode.All, densityConstantsReduction) };
+
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.All, defaultConstantsReduction, customCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.All(defaultConversions, conversion =>
+        {
+            Assert.Multiple(
+                () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+        });
+        Assert.Equal(expectedNumberOfConversions, conversionExpressions.Count);
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void BaseOnlyCaching_WithSpecificNoneOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool densityConstantsReduction)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(ConversionCachingMode.None, densityConstantsReduction) };
+
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.BaseOnly, defaultConstantsReduction, customCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.All(defaultConversions, conversion =>
+        {
+            if (conversion.LeftQuantity.QuantityType == typeof(Density))
+            {
+                Assert.Multiple(() => { ContainsNoConversionsFor(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+            }
+            else
+            {
+                Assert.Multiple(
+                    () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+            }
+        });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void BaseOnlyCaching_WithSpecificBaseOnlyOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool densityConstantsReduction)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(ConversionCachingMode.BaseOnly, densityConstantsReduction) };
+
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.BaseOnly, defaultConstantsReduction, customCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.All(defaultConversions, conversion =>
+        {
+            Assert.Multiple(
+                    () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+        });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void BaseOnlyCaching_WithSpecificAllOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool densityConstantsReduction)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(ConversionCachingMode.All, densityConstantsReduction) };
+
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.BaseOnly, defaultConstantsReduction, customCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.All(defaultConversions, conversion =>
+        {
+            if (conversion.LeftQuantity.QuantityType == typeof(Density))
+            {
+                Assert.Multiple(
+                    () => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+            }
+            else
+            {
+                Assert.Multiple(
+                    () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+            }
+        });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void NoCaching_WithSpecificAllOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool densityConstantsReduction)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        // 56 units of Density
+        var expectedNumberOfConversions = Density.Info.UnitInfos.Count;
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(ConversionCachingMode.All, densityConstantsReduction) };
+
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.None, defaultConstantsReduction, customCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.All(defaultConversions, conversion =>
+        {
+            if (conversion.LeftQuantity.QuantityType == typeof(Density))
+            {
+                Assert.Multiple(() => { ConversionsWithAllUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ContainsNoConversionsFor(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+            }
+            else
+            {
+                Assert.Multiple(
+                    () => { ContainsNoConversionsFor(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ContainsNoConversionsFor(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+            }
+        });
+        Assert.Equal(expectedNumberOfConversions, conversionExpressions.Count);
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void NoCaching_WithSpecificBaseOnlyOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool densityConstantsReduction)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(ConversionCachingMode.BaseOnly, densityConstantsReduction) };
+
+        // there are currently only 3 conversions here (3 density units matching the 3 units of specific volume)
+        var conversionExpressions = defaultConversions.GetConversionFunctions(ConversionCachingMode.None, defaultConstantsReduction, customCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.All(defaultConversions, conversion =>
+        {
+            if (conversion.LeftQuantity.QuantityType == typeof(Density))
+            {
+                Assert.Multiple(
+                    () => { ConversionsWithBaseUnits_ConvertToTargetQuantity(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ContainsNoConversionsFor(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+            }
+            else
+            {
+                Assert.Multiple(() => { ContainsNoConversionsFor(conversionExpressions, conversion.LeftQuantity, conversion.RightQuantity); },
+                    () => { ContainsNoConversionsFor(conversionExpressions, conversion.RightQuantity, conversion.LeftQuantity); });
+            }
+        });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void NoCaching_WithSpecificNoneOptions_ReturnsNoUnitConversions(bool defaultConstantsReduction,
+        bool densityConstantsReduction)
+    {
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings).ToArray();
+        var customQuantityOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(ConversionCachingMode.None, densityConstantsReduction) };
+
+        Assert.Empty(defaultConversions.GetConversionFunctions(ConversionCachingMode.None, defaultConstantsReduction, customQuantityOptions));
+    }
+
+    private static void ContainsNoConversionsFor(Dictionary<QuantityConversionKey, QuantityConversionFunction> conversionExpressions,
+        QuantityInfo fromQuantityInfo, QuantityInfo toQuantityInfo)
+    {
+        Assert.All(fromQuantityInfo.UnitInfos, fromUnit =>
+        {
+            var conversionKey = new QuantityConversionKey(fromUnit.UnitKey, toQuantityInfo.UnitType);
+            Assert.DoesNotContain(conversionKey, conversionExpressions);
+        });
+    }
+
+    [Theory]
+    [InlineData(ConversionCachingMode.All, true)]
+    [InlineData(ConversionCachingMode.BaseOnly, true)]
+    [InlineData(ConversionCachingMode.BaseOnly, false)] // the conversions from/to the base units are already reduced by the CodeGen
+    public void ReduceConstants_ReturnsUnitConversionsWithReducedCoefficients(ConversionCachingMode cachingMode, bool reduceConstants)
+    {
+        // Arrange
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings);
+
+        // Act
+        IEnumerable<ConvertValueDelegate> conversionExpressions = defaultConversions.GetConversionFunctions(cachingMode, reduceConstants)
+            .Select(pair => pair.Value.Convert);
+
+        // Assert
+        Assert.All(conversionExpressions, valueDelegate => Assert.True(IsReduced(valueDelegate(QuantityValue.One))));
+    }
+
+    private static bool IsReduced(QuantityValue value)
+    {
+        (BigInteger numerator, BigInteger denominator) = value;
+        return BigInteger.GreatestCommonDivisor(numerator, denominator) == BigInteger.One;
+    }
+
+    [Theory]
+    [InlineData(ConversionCachingMode.None, true, ConversionCachingMode.None, true)]
+    [InlineData(ConversionCachingMode.None, true, ConversionCachingMode.BaseOnly, true)]
+    [InlineData(ConversionCachingMode.None, true, ConversionCachingMode.All, true)]
+    [InlineData(ConversionCachingMode.None, false, ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.None, false, ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.None, false, ConversionCachingMode.All, false)]
+    [InlineData(ConversionCachingMode.BaseOnly, true, ConversionCachingMode.None, true)]
+    [InlineData(ConversionCachingMode.BaseOnly, true, ConversionCachingMode.BaseOnly, true)]
+    [InlineData(ConversionCachingMode.BaseOnly, true, ConversionCachingMode.All, true)]
+    [InlineData(ConversionCachingMode.BaseOnly, false, ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.BaseOnly, false, ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.BaseOnly, false, ConversionCachingMode.All, false)]
+    [InlineData(ConversionCachingMode.All, true, ConversionCachingMode.None, true)]
+    [InlineData(ConversionCachingMode.All, true, ConversionCachingMode.BaseOnly, true)]
+    [InlineData(ConversionCachingMode.All, true, ConversionCachingMode.All, true)]
+    [InlineData(ConversionCachingMode.All, false, ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.All, false, ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.All, false, ConversionCachingMode.All, false)]
+    public void GetConversionFunctions_WithCustomConversionsAndCustomCachingOptions_ReturnsUnitConversionsThatIncludeTheCustomConversions(
+        ConversionCachingMode defaultCachingMode, bool defaultConstantsReduction,
+        ConversionCachingMode densityCachingMode, bool densityConstantsReduction)
+    {
+        // Arrange
+        var customConversionFromDensity = new CustomQuantityConversionExpressionMapping(
+            Density.Info[DensityUnit.KilogramPerCubicMeter],
+            SpecificVolume.Info[SpecificVolumeUnit.CubicMeterPerKilogram],
+            new ConversionExpression(coefficient: 2, exponent: -1));
+
+        var customConversionFromSpecificVolume = new CustomQuantityConversionExpressionMapping(
+            SpecificVolume.Info[SpecificVolumeUnit.CubicMeterPerKilogram],
+            Density.Info[DensityUnit.KilogramPerCubicMeter],
+            new ConversionExpression(coefficient: new QuantityValue(1, 2), exponent: -1));
+
+        var conversionMappingOptions = new QuantityConversionMappingOptions
+        {
+            ConversionExpressions =
+            {
+                {
+                    new UnitConversionMapping(customConversionFromDensity.SourceUnit.UnitKey, customConversionFromDensity.TargetUnit.UnitKey),
+                    customConversionFromDensity
+                },
+                {
+                    new UnitConversionMapping(customConversionFromSpecificVolume.SourceUnit.UnitKey, customConversionFromSpecificVolume.TargetUnit.UnitKey),
+                    customConversionFromSpecificVolume
+                }
+            }
+        };
+        var conversionOptions = new Dictionary<QuantityConversion, QuantityConversionMappingOptions>
+        {
+            { new QuantityConversion(Density.Info, SpecificVolume.Info), conversionMappingOptions }
+        };
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(densityCachingMode, densityConstantsReduction) };
+        IEnumerable<QuantityConversion> defaultConversions = UnitsNetSetup.Default.Quantities.GetQuantityConversions(Quantity.DefaultProvider.Conversions);
+
+        // Act
+        var conversionExpressions = defaultConversions.GetConversionFunctions(conversionOptions, defaultCachingMode, defaultConstantsReduction, customCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        // Assert
+        Assert.Multiple(() =>
+            {
+                // the returned result contains all our custom conversions
+                Assert.All(conversionMappingOptions.ConversionExpressions, pair =>
+                {
+                    UnitConversionMapping unitConversionKey = pair.Key;
+                    CustomQuantityConversionExpressionMapping expressionMapping = pair.Value;
+                    ConversionExpression conversionExpression = expressionMapping.ConversionExpression;
+                    var conversionKey = new QuantityConversionKey(unitConversionKey.FromUnitKey, unitConversionKey.ToUnitKey.UnitEnumType);
+                    Assert.Contains(conversionKey, conversionExpressions);
+                    Assert.Equal(expressionMapping.TargetUnit.UnitKey, conversionExpressions[conversionKey].TargetUnit);
+                    Assert.Equal(conversionExpression.Evaluate(10), conversionExpressions[conversionKey].Convert(10));
+                });
+            },
+            () =>
+            {
+                // all generated conversions from a DensityUnit are a function of the custom conversion expressions in our customConversionFromDensity
+                Assert.All(conversionExpressions.Where(x => x.Key.FromUnit.UnitEnumType == typeof(DensityUnit)),
+                    pair =>
+                    {
+                        QuantityConversionKey conversionKey = pair.Key;
+                        QuantityConversionFunction conversionFunction = pair.Value;
+
+                        UnitInfo<Density, DensityUnit> sourceUnit = Density.Info[conversionKey.FromUnit.ToUnit<DensityUnit>()];
+                        UnitInfo<SpecificVolume, SpecificVolumeUnit> targetUnit =
+                            SpecificVolume.Info[conversionFunction.TargetUnit.ToUnit<SpecificVolumeUnit>()];
+                        QuantityValue valueToConvert = 10;
+                        QuantityValue valueInSourceConversionUnit = customConversionFromDensity.SourceUnit.GetValueFrom(valueToConvert, sourceUnit);
+                        QuantityValue valueInTargetConversionUnit = customConversionFromDensity.ConversionExpression.Evaluate(valueInSourceConversionUnit);
+                        QuantityValue expectedValue = targetUnit.GetValueFrom(valueInTargetConversionUnit, customConversionFromDensity.TargetUnit);
+
+                        Assert.Equal(expectedValue, conversionFunction.Convert(valueToConvert));
+                        if (densityConstantsReduction)
+                        {
+                            Assert.True(IsReduced(conversionFunction.Convert(1)));
+                        }
+                    });
+            },
+            () =>
+            {
+                // all generated conversions from a SpecificVolumeUnit are a function of the custom conversion expressions in our customConversionFromSpecificVolume
+                Assert.All(conversionExpressions.Where(x => x.Key.FromUnit.UnitEnumType == typeof(SpecificVolumeUnit)),
+                    pair =>
+                    {
+                        QuantityConversionKey conversionKey = pair.Key;
+                        QuantityConversionFunction conversionFunction = pair.Value;
+
+                        UnitInfo<SpecificVolume, SpecificVolumeUnit> sourceUnit = SpecificVolume.Info[conversionKey.FromUnit.ToUnit<SpecificVolumeUnit>()];
+                        UnitInfo<Density, DensityUnit> targetUnit = Density.Info[conversionFunction.TargetUnit.ToUnit<DensityUnit>()];
+                        QuantityValue valueToConvert = 10;
+                        QuantityValue valueInSourceConversionUnit = customConversionFromSpecificVolume.SourceUnit.GetValueFrom(valueToConvert, sourceUnit);
+                        QuantityValue valueInTargetConversionUnit =
+                            customConversionFromSpecificVolume.ConversionExpression.Evaluate(valueInSourceConversionUnit);
+                        QuantityValue expectedValue = targetUnit.GetValueFrom(valueInTargetConversionUnit, customConversionFromSpecificVolume.TargetUnit);
+
+                        Assert.Equal(expectedValue, conversionFunction.Convert(valueToConvert));
+                        if (defaultConstantsReduction)
+                        {
+                            Assert.True(IsReduced(conversionFunction.Convert(1)));
+                        }
+                    });
+            }
+        );
+    }
+
+    [Theory]
+    [InlineData(ConversionCachingMode.None, true)]
+    [InlineData(ConversionCachingMode.BaseOnly, true)]
+    [InlineData(ConversionCachingMode.All, true)]
+    [InlineData(ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.All, false)]
+    public void GetConversionFunctions_WithUnitConversionMappings_ReturnsTheSpecifiedConversions(ConversionCachingMode conversionCachingMode, bool reduceConstants)
+    {
+        // Arrange
+        var conversionMappingOptions = new QuantityConversionMappingOptions
+        {
+            CustomUnitMappings =
+            {
+                {
+                    new UnitConversionMapping(DensityUnit.GramPerLiter, SpecificVolumeUnit.CubicMeterPerKilogram),
+                    new CustomQuantityConversionUnitMapping(Density.Info[DensityUnit.GramPerLiter],
+                        SpecificVolume.Info[SpecificVolumeUnit.CubicMeterPerKilogram])
+                },
+                {
+                    new UnitConversionMapping(DensityUnit.GramPerCubicCentimeter, SpecificVolumeUnit.CubicFootPerPound),
+                    new CustomQuantityConversionUnitMapping(Density.Info[DensityUnit.GramPerCubicCentimeter],
+                        SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound])
+                },
+                {
+                    new UnitConversionMapping(DensityUnit.NanogramPerMilliliter, SpecificVolumeUnit.CubicFootPerPound),
+                    new CustomQuantityConversionUnitMapping(Density.Info[DensityUnit.NanogramPerMilliliter],
+                        SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound])
+                },
+                {
+                    new UnitConversionMapping(SpecificVolumeUnit.CubicFootPerPound, DensityUnit.NanogramPerMilliliter),
+                    new CustomQuantityConversionUnitMapping(SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound],
+                        Density.Info[DensityUnit.NanogramPerMilliliter])
+                },
+                {
+                    new UnitConversionMapping(SpecificVolumeUnit.CubicMeterPerKilogram, DensityUnit.MilligramPerMilliliter),
+                    new CustomQuantityConversionUnitMapping(SpecificVolume.Info[SpecificVolumeUnit.CubicMeterPerKilogram],
+                        Density.Info[DensityUnit.MilligramPerMilliliter])
+                },
+            }
+        };
+        var conversionOptions = new Dictionary<QuantityConversion, QuantityConversionMappingOptions>()
+        {
+            {
+                new QuantityConversion(Density.Info, SpecificVolume.Info),
+                conversionMappingOptions
+            }
+        };
+        IEnumerable<QuantityConversion> defaultConversions = UnitsNetSetup.Default.Quantities.GetQuantityConversions(Quantity.DefaultProvider.Conversions);
+        var emptyCachingOptions = new Dictionary<Type, ConversionCacheOptions>();
+
+        // Act
+        var conversionExpressions = defaultConversions.GetConversionFunctions(conversionOptions, conversionCachingMode, reduceConstants, emptyCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        // Assert
+        Assert.All(conversionMappingOptions.CustomUnitMappings, mapping =>
+        {
+            UnitInfo fromUnit = mapping.Value.SourceUnit;
+            UnitInfo toUnit = mapping.Value.TargetUnit;
+            QuantityValue valueToConvert = 123.45m;
+            QuantityValue expectedValue = toUnit.QuantityInfo.ConvertFrom(valueToConvert, fromUnit).As(toUnit.Value);
+            var conversionKey = new QuantityConversionKey(fromUnit.UnitKey, toUnit.QuantityInfo.UnitType);
+            Assert.Contains(conversionKey, conversionExpressions);
+            Assert.Equal(expectedValue, conversionExpressions[conversionKey].Convert(valueToConvert));
+            Assert.Equal(toUnit.UnitKey, conversionExpressions[conversionKey].TargetUnit);
+            // this maybe a bit redundant but that's the only covering line for the ResultType property (its only used for the default equality contract)
+            Assert.Equal(conversionKey.ResultType, conversionExpressions[conversionKey].TargetUnit.UnitEnumType);
+            if (reduceConstants)
+            {
+                Assert.True(IsReduced(conversionExpressions[conversionKey].Convert(1)));
+            }
+        });
+
+        if (conversionCachingMode == ConversionCachingMode.None)
+        {
+            Assert.Equal(conversionMappingOptions.CustomUnitMappings.Count, conversionExpressions.Count);
+        }
+    }
+
+    [Theory]
+    [InlineData(ConversionCachingMode.None, true)]
+    [InlineData(ConversionCachingMode.BaseOnly, true)]
+    [InlineData(ConversionCachingMode.All, true)]
+    [InlineData(ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.All, false)]
+    public void GetConversionFunctions_WithUnitConversionMappingsAndCustomFunctions_ReturnsTheMergedConversions(ConversionCachingMode conversionCachingMode, bool reduceConstants)
+    {
+        // Arrange
+        var customConversionFromDensity = new CustomQuantityConversionExpressionMapping(
+            Density.Info[DensityUnit.PoundPerCubicFoot],
+            SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound],
+            new ConversionExpression(coefficient: 2, exponent: -1));
+        var customConversionFromSpecificVolume = new CustomQuantityConversionExpressionMapping(
+            SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound],
+            Density.Info[DensityUnit.PoundPerCubicFoot],
+            new ConversionExpression(coefficient: new QuantityValue(1, 2), exponent: -1));
+        var conversionMappingOptions = new QuantityConversionMappingOptions
+        {
+            ConversionExpressions =
+            {
+                {
+                    new UnitConversionMapping(customConversionFromDensity.SourceUnit.UnitKey, customConversionFromDensity.TargetUnit.UnitKey),
+                    customConversionFromDensity
+                },
+                {
+                    new UnitConversionMapping(customConversionFromSpecificVolume.SourceUnit.UnitKey, customConversionFromSpecificVolume.TargetUnit.UnitKey),
+                    customConversionFromSpecificVolume
+                }
+            },
+            CustomUnitMappings =
+            {
+                {
+                    new UnitConversionMapping(DensityUnit.GramPerLiter, SpecificVolumeUnit.CubicMeterPerKilogram), new CustomQuantityConversionUnitMapping(
+                        Density.Info[DensityUnit.GramPerLiter],
+                        SpecificVolume.Info[SpecificVolumeUnit.CubicMeterPerKilogram])
+                },
+                {
+                    new UnitConversionMapping(DensityUnit.NanogramPerMilliliter, SpecificVolumeUnit.CubicFootPerPound), new CustomQuantityConversionUnitMapping(
+                        Density.Info[DensityUnit.NanogramPerMilliliter],
+                        SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound])
+                }
+            }
+        };
+        var conversionOptions = new Dictionary<QuantityConversion, QuantityConversionMappingOptions>
+        {
+            { new QuantityConversion(Density.Info, SpecificVolume.Info), conversionMappingOptions }
+        };
+        IEnumerable<QuantityConversion> defaultConversions = UnitsNetSetup.Default.Quantities.GetQuantityConversions(Quantity.DefaultProvider.Conversions);
+        var emptyCachingOptions = new Dictionary<Type, ConversionCacheOptions>();
+
+        // Act
+        var conversionExpressions = defaultConversions.GetConversionFunctions(conversionOptions, conversionCachingMode, reduceConstants, emptyCachingOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        // Assert
+        Assert.Multiple(() =>
+        {
+            Assert.All(conversionMappingOptions.ConversionExpressions, pair =>
+            {
+                var conversionKey = new QuantityConversionKey(pair.Key.FromUnitKey, pair.Key.ToUnitKey.UnitEnumType);
+                Assert.True(conversionExpressions.ContainsKey(conversionKey));
+                Assert.Equal(pair.Value.ConversionExpression.Evaluate(10), conversionExpressions[conversionKey].Convert(10));
+            });
+        }, () =>
+        {
+            Assert.All(conversionMappingOptions.CustomUnitMappings, pair =>
+            {
+                var conversionKey = new QuantityConversionKey(pair.Key.FromUnitKey, pair.Key.ToUnitKey.UnitEnumType);
+                UnitInfo sourceUnit = pair.Value.SourceUnit;
+                UnitInfo targetUnit = pair.Value.TargetUnit;
+                QuantityValue valueToConvert = 10;
+                QuantityValue valueInSourceConversionUnit = customConversionFromDensity.SourceUnit.GetValueFrom(valueToConvert, sourceUnit);
+                QuantityValue valueInTargetConversionUnit = customConversionFromDensity.ConversionExpression.Evaluate(valueInSourceConversionUnit);
+                QuantityValue expectedValue = targetUnit.GetValueFrom(valueInTargetConversionUnit, customConversionFromDensity.TargetUnit);
+                Assert.True(conversionExpressions.ContainsKey(conversionKey));
+                Assert.Equal(expectedValue, conversionExpressions[conversionKey].Convert(valueToConvert));
+                if (reduceConstants)
+                {
+                    Assert.True(IsReduced(conversionExpressions[conversionKey].Convert(1)));
+                }
+            });
+        });
+
+        if (conversionCachingMode == ConversionCachingMode.None)
+        {
+            Assert.Equal(Density.Units.Count + SpecificVolume.Units.Count,
+                conversionExpressions.Count); // an expression is provided for each of the units (irrespective of the caching mode)
+        }
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void GetConversionFunctions_WithInvalidConversionDimensions_And_Caching_None_ReturnsEmpty(bool reduceConstants)
+    {
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversionMapping> defaultConversionMappings = Quantity.DefaultProvider.Conversions;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(defaultConversionMappings)
+            .Append(new QuantityConversion(Mass.Info, Volume.Info)).ToList();
+
+        Assert.Empty(defaultConversions.GetConversionFunctions(ConversionCachingMode.None, reduceConstants));
+    }
+
+    [Theory]
+    [InlineData(ConversionCachingMode.BaseOnly, true)]
+    [InlineData(ConversionCachingMode.All, true)]
+    [InlineData(ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.All, false)]
+    public void GetConversionFunctions_WithInvalidConversionDimensions_And_Caching_ThrowsInvalidConversionException(ConversionCachingMode cachingMode, bool reduceConstants)
+    {
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IEnumerable<QuantityConversionMapping> defaultConversionMappings = Quantity.DefaultProvider.Conversions;
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(defaultConversionMappings)
+            .Append(new QuantityConversion(Mass.Info, Volume.Info)).ToList();
+
+        Assert.Throws<InvalidConversionException>(() => defaultConversions.GetConversionFunctions(cachingMode, reduceConstants).ToList());
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void GetConversionFunctions_WithNoMatchingBaseUnits_And_Caching_BaseOnly_ReturnsEmpty(bool reduceConstants)
+    {
+        // we simulate a target quantity without any base units
+        var densityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+            unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+        IEnumerable<QuantityConversion> defaultConversions = [new(densityInfo, SpecificVolume.Info)];
+
+        Assert.Empty(defaultConversions.GetConversionFunctions(ConversionCachingMode.BaseOnly, reduceConstants));
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void GetConversionFunctions_WithNoMatchingBaseUnits_And_Caching_All_ThrowsInvalidConversionException(bool reduceConstants)
+    {
+        // we simulate a target quantity without any base units
+        var densityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+            unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+        IEnumerable<QuantityConversion> defaultConversions = [new(densityInfo, SpecificVolume.Info)];
+
+        Assert.Throws<InvalidConversionException>(() => defaultConversions.GetConversionFunctions(ConversionCachingMode.All, reduceConstants).ToList());
+    }
+
+    // [Theory]
+    // [InlineData(ConversionCachingMode.None, true, ConversionCachingMode.None, false)]
+    // [InlineData(ConversionCachingMode.BaseOnly, true, ConversionCachingMode.None, false)]
+    // [InlineData(ConversionCachingMode.All, true, ConversionCachingMode.None, false)]
+    // [InlineData(ConversionCachingMode.None, false, ConversionCachingMode.None, false)]
+    // [InlineData(ConversionCachingMode.BaseOnly, false, ConversionCachingMode.None, false)]
+    // [InlineData(ConversionCachingMode.All, false, ConversionCachingMode.None, false)]
+    // public void GetConversionFunctions_WithUnitConversionMappings_WithInvalidDimensions_ThrowsInvalidConversionException(ConversionCachingMode cachingMode, bool defaultConstantsReduction,
+    //     ConversionCachingMode massCachingMode,  bool massConstantsReduction)
+    // {
+    //     QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.QuantityInfoLookup;
+    //     IEnumerable<QuantityConversionMapping> defaultConversionMappings = Quantity.DefaultProvider.Conversions;
+    //     IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(defaultConversionMappings)
+    //         .Append(new QuantityConversion(Mass.Info, Volume.Info)).ToList();
+    //     var conversionMappingOptions = new QuantityConversionMappingOptions
+    //     {
+    //         CustomUnitMappings =
+    //         {
+    //             {
+    //                 new UnitConversionMapping(Mass.BaseUnit, Volume.BaseUnit), new CustomQuantityConversionUnitMapping(Mass.Info.BaseUnitInfo, Volume.Info.BaseUnitInfo)
+    //             }
+    //         }
+    //     };
+    //     var conversionOptions = new Dictionary<QuantityConversion, QuantityConversionMappingOptions>
+    //     {
+    //         { new QuantityConversion(Mass.Info, Volume.Info), conversionMappingOptions }
+    //     };
+    //
+    //     var customCachingOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Mass)] = new(massCachingMode, massConstantsReduction) };
+    //
+    //     Assert.Throws<InvalidConversionException>(() => defaultConversions.GetConversionFunctions(conversionOptions, cachingMode, defaultConstantsReduction, customCachingOptions).ToList());
+    // }
+
+    // [Theory]
+    // [InlineData(ConversionCachingMode.None, true, ConversionCachingMode.None, false)]
+    // [InlineData(ConversionCachingMode.BaseOnly, true, ConversionCachingMode.None, false)]
+    // [InlineData(ConversionCachingMode.All, true, ConversionCachingMode.None, false)]
+    // [InlineData(ConversionCachingMode.None, false, ConversionCachingMode.None, false)]
+    // [InlineData(ConversionCachingMode.BaseOnly, false, ConversionCachingMode.None, false)]
+    // [InlineData(ConversionCachingMode.All, false, ConversionCachingMode.None, false)]
+    // public void GetConversionFunctions_WithUnitConversionMappings_WithNoBaseUnits_ThrowsInvalidConversionException(ConversionCachingMode cachingMode, bool defaultConstantsReduction,
+    //     ConversionCachingMode massCachingMode,  bool massConstantsReduction)
+    // {
+    //     // we simulate a target quantity without any base units
+    //     var densityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+    //         unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+    //     IEnumerable<QuantityConversion> defaultConversions = [new(densityInfo, SpecificVolume.Info)];
+    //
+    //     var conversionMappingOptions = new QuantityConversionMappingOptions
+    //     {
+    //         CustomUnitMappings =
+    //         {
+    //             {
+    //                 new UnitConversionMapping(Density.BaseUnit, SpecificVolume.BaseUnit), new CustomQuantityConversionUnitMapping(densityInfo.BaseUnitInfo, SpecificVolume.Info.BaseUnitInfo)
+    //             }
+    //         }
+    //     };
+    //     var conversionOptions = new Dictionary<QuantityConversion, QuantityConversionMappingOptions>
+    //     {
+    //         { new QuantityConversion(densityInfo, SpecificVolume.Info), conversionMappingOptions }
+    //     };
+    //
+    //     var customCachingOptions = new Dictionary<Type, ConversionCacheOptions>
+    //     {
+    //         [typeof(Mass)] = new(massCachingMode, massConstantsReduction)
+    //     };
+    //
+    //     Assert.Throws<InvalidConversionException>(() => defaultConversions.GetConversionFunctions(conversionOptions, cachingMode, defaultConstantsReduction, customCachingOptions).ToList());
+    // }
+
+    [Theory]
+    [InlineData(ConversionCachingMode.None, true, ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.BaseOnly, true, ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.All, true, ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.None, false, ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.BaseOnly, false, ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.All, false, ConversionCachingMode.None, false)]
+    [InlineData(ConversionCachingMode.None, true, ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.BaseOnly, true, ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.All, true, ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.None, false, ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.BaseOnly, false, ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.All, false, ConversionCachingMode.BaseOnly, false)]
+    [InlineData(ConversionCachingMode.All, true, ConversionCachingMode.All, false)]
+    [InlineData(ConversionCachingMode.None, false, ConversionCachingMode.All, false)]
+    [InlineData(ConversionCachingMode.BaseOnly, false, ConversionCachingMode.All, false)]
+    [InlineData(ConversionCachingMode.All, false, ConversionCachingMode.All, false)]
+    public void GetConversionFunctions_WithUnitConversionMappings_WithNoBaseUnits_ThrowsInvalidConversionException(ConversionCachingMode cachingMode, bool defaultConstantsReduction,
+        ConversionCachingMode massCachingMode,  bool massConstantsReduction)
+    {
+        // we simulate a target quantity without any base units
+        var densityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+            unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+        IEnumerable<QuantityConversion> defaultConversions = [new(densityInfo, SpecificVolume.Info)];
+
+        var conversionMappingOptions = new QuantityConversionMappingOptions
+        {
+            CustomUnitMappings =
+            {
+                // {
+                //     new UnitConversionMapping(Density.BaseUnit, SpecificVolume.BaseUnit), new CustomQuantityConversionUnitMapping(densityInfo.BaseUnitInfo, SpecificVolume.Info.BaseUnitInfo)
+                // },
+                {
+                    new UnitConversionMapping(SpecificVolume.BaseUnit, Density.BaseUnit), new CustomQuantityConversionUnitMapping(SpecificVolume.Info.BaseUnitInfo, densityInfo.BaseUnitInfo)
+                }
+            }
+        };
+        var conversionOptions = new Dictionary<QuantityConversion, QuantityConversionMappingOptions>
+        {
+            { new QuantityConversion(densityInfo, SpecificVolume.Info), conversionMappingOptions }
+        };
+
+        var customCachingOptions = new Dictionary<Type, ConversionCacheOptions>
+        {
+            [typeof(Density)] = new(cachingMode, defaultConstantsReduction),
+            [typeof(SpecificVolume)] = new(massCachingMode, massConstantsReduction)
+        };
+
+        Assert.Throws<InvalidConversionException>(() => defaultConversions.GetConversionFunctions(conversionOptions, ConversionCachingMode.All, true, customCachingOptions).ToList());
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void GetConversionFunctions_WithInvalidCachingMode_ThrowsArgumentException(bool reduceConstants)
+    {
+        QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.Quantities;
+        IReadOnlyCollection<QuantityConversionMapping> conversionMappings = Quantity.DefaultProvider.Conversions;
+        const ConversionCachingMode invalidCachingMode = (ConversionCachingMode)(-1);
+        IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(conversionMappings);
+
+        Assert.Multiple(() =>
+                Assert.Throws<ArgumentOutOfRangeException>(() => defaultConversions.GetConversionFunctions(invalidCachingMode, reduceConstants)),
+            () =>
+            {
+                var emptyOptions = new Dictionary<Type, ConversionCacheOptions>();
+                Assert.Throws<ArgumentOutOfRangeException>(() => defaultConversions.GetConversionFunctions(invalidCachingMode, reduceConstants, emptyOptions)
+                    .ToList());
+            },
+            () =>
+            {
+                var validOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new() };
+                Assert.Throws<ArgumentOutOfRangeException>(() => defaultConversions.GetConversionFunctions(invalidCachingMode, reduceConstants, validOptions)
+                    .ToList());
+            },
+            () =>
+            {
+                var invalidOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(invalidCachingMode) };
+                Assert.Throws<ArgumentOutOfRangeException>(() => defaultConversions.GetConversionFunctions(default, reduceConstants, invalidOptions)
+                    .ToList());
+            },
+            () =>
+            {
+                var invalidOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Density)] = new(invalidCachingMode) };
+                var conversionMappingOptions = new QuantityConversionMappingOptions
+                {
+                    CustomUnitMappings =
+                    {
+                        {
+                            new UnitConversionMapping(DensityUnit.GramPerLiter, SpecificVolumeUnit.CubicMeterPerKilogram), new CustomQuantityConversionUnitMapping(
+                                Density.Info[DensityUnit.GramPerLiter],
+                                SpecificVolume.Info[SpecificVolumeUnit.CubicMeterPerKilogram])
+                        },
+                        {
+                            new UnitConversionMapping(DensityUnit.NanogramPerMilliliter, SpecificVolumeUnit.CubicFootPerPound), new CustomQuantityConversionUnitMapping(
+                                Density.Info[DensityUnit.NanogramPerMilliliter],
+                                SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound])
+                        }
+                    }
+                };
+                var conversionOptions = new Dictionary<QuantityConversion, QuantityConversionMappingOptions>
+                {
+                    { new QuantityConversion(Density.Info, SpecificVolume.Info), conversionMappingOptions }
+                };
+
+                Assert.Throws<ArgumentOutOfRangeException>(() => defaultConversions.GetConversionFunctions(conversionOptions, default, reduceConstants, invalidOptions)
+                    .ToList());
+            });
+    }
+
+
+    // [Theory]
+    // [InlineData(true)]
+    // [InlineData(false)]
+    // public void GetConversionFunctions_WithInvalidConversionDimensions_And_CachingOptions_None_ReturnsEmpty(bool reduceConstants)
+    // {
+    //     QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.QuantityInfoLookup;
+    //     IEnumerable<QuantityConversionMapping> defaultConversionMappings = Quantity.DefaultProvider.Conversions;
+    //     IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(defaultConversionMappings)
+    //         .Append(new QuantityConversion(Mass.Info, Volume.Info)).ToList();
+    //     var customCachingOptions = new Dictionary<Type, ConversionCacheOptions>
+    //     {
+    //         [typeof(Mass)] = new(ConversionCachingMode.None, reduceConstants),
+    //         [typeof(Volume)] = new(ConversionCachingMode.None, reduceConstants)
+    //     };
+    //
+    //     var conversions = defaultConversions.GetConversionFunctions(ConversionCachingMode.All, reduceConstants, customCachingOptions)
+    //         .ToDictionary(pair => pair.Key, pair => pair.Value);
+    //
+    //     Assert.NotEmpty(conversions);
+    //     Assert.False(conversions.ContainsKey(new QuantityConversionKey(Mass.BaseUnit, typeof(Volume))));
+    // }
+    //
+    // [Theory]
+    // [InlineData(ConversionCachingMode.BaseOnly, true)]
+    // [InlineData(ConversionCachingMode.All, true)]
+    // [InlineData(ConversionCachingMode.BaseOnly, false)]
+    // [InlineData(ConversionCachingMode.All, false)]
+    // public void GetConversionFunctions_WithInvalidConversionDimensions_And_CachingOptions_ThrowsInvalidConversionException(ConversionCachingMode cachingMode, bool reduceConstants)
+    // {
+    //     QuantityInfoLookup quantityInfoLookup = UnitsNetSetup.Default.QuantityInfoLookup;
+    //     IEnumerable<QuantityConversionMapping> defaultConversionMappings = Quantity.DefaultProvider.Conversions;
+    //     IEnumerable<QuantityConversion> defaultConversions = quantityInfoLookup.GetQuantityConversions(defaultConversionMappings)
+    //         .Append(new QuantityConversion(Mass.Info, Volume.Info)).ToList();
+    //     var customCachingOptions = new Dictionary<Type, ConversionCacheOptions>
+    //     {
+    //         [typeof(Mass)] = new(cachingMode, reduceConstants),
+    //         [typeof(Volume)] = new(cachingMode, reduceConstants)
+    //     };
+    //
+    //     Assert.Throws<InvalidConversionException>(() => defaultConversions.GetConversionFunctions(ConversionCachingMode.None, reduceConstants, customCachingOptions).ToList());
+    // }
+    //
+    // [Theory]
+    // [InlineData(true)]
+    // [InlineData(false)]
+    // public void GetConversionFunctions_WithNoMatchingBaseUnits_And_CachingOptions_BaseOnly_ReturnsEmpty(bool reduceConstants)
+    // {
+    //     // we simulate a target quantity without any base units
+    //     var densityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+    //         unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+    //     IEnumerable<QuantityConversion> defaultConversions = [new(densityInfo, SpecificVolume.Info)];
+    //     var customCachingOptions = new Dictionary<Type, ConversionCacheOptions>
+    //     {
+    //         [typeof(Density)] = new(ConversionCachingMode.BaseOnly, reduceConstants),
+    //         [typeof(SpecificVolume)] = new(ConversionCachingMode.BaseOnly, reduceConstants)
+    //     };
+    //
+    //     Assert.Empty(defaultConversions.GetConversionFunctions(ConversionCachingMode.None, reduceConstants, customCachingOptions));
+    // }
+    //
+    // [Theory]
+    // [InlineData(true)]
+    // [InlineData(false)]
+    // public void GetConversionFunctions_WithNoMatchingBaseUnits_And_CachingOptions_All_ThrowsInvalidConversionException(bool reduceConstants)
+    // {
+    //     // we simulate a target quantity without any base units
+    //     var densityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+    //         unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+    //     IEnumerable<QuantityConversion> defaultConversions = [new(densityInfo, SpecificVolume.Info)];
+    //     var customCachingOptions = new Dictionary<Type, ConversionCacheOptions>
+    //     {
+    //         [typeof(Density)] = new(ConversionCachingMode.All, reduceConstants),
+    //         [typeof(SpecificVolume)] = new(ConversionCachingMode.All, reduceConstants)
+    //     };
+    //
+    //     Assert.Throws<InvalidConversionException>(() => defaultConversions.GetConversionFunctions(ConversionCachingMode.None, reduceConstants, customCachingOptions).ToList());
+    // }
+
+
+    [Theory]
+    [InlineData(AreaUnit.SquareMeter, ReciprocalAreaUnit.InverseSquareMeter, 1)]
+    [InlineData(AreaUnit.SquareCentimeter, ReciprocalAreaUnit.InverseSquareCentimeter, 1)]
+    [InlineData(AreaUnit.SquareFoot, ReciprocalAreaUnit.InverseSquareFoot, 1)]
+    [InlineData(AreaUnit.Acre, ReciprocalAreaUnit.InverseSquareKilometer, 247.1053814671653)]
+    public void GetQuantityConversionFrom_QuantityWithInverseDimensions_ReturnsTheClosestMatchingUnit(AreaUnit fromUnit, ReciprocalAreaUnit expectedUnit, double expectedCoefficient)
+    {
+        QuantityConversionFunction conversionFunction = ReciprocalArea.Info.GetQuantityConversionFrom(Area.Info[fromUnit]);
+
+        Assert.Equal(expectedUnit, conversionFunction.TargetUnit.ToUnit<ReciprocalAreaUnit>());
+        Assert.Equal(expectedCoefficient, conversionFunction.Convert(QuantityValue.One).ToDouble(), 14);
+    }
+
+    [Theory]
+    [InlineData(MassConcentrationUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerCubicMeter, 1)]
+    [InlineData(MassConcentrationUnit.GramPerCubicMeter, DensityUnit.GramPerCubicMeter, 1)]
+    [InlineData(MassConcentrationUnit.PoundPerCubicFoot, DensityUnit.PoundPerCubicFoot, 1)]
+    [InlineData(MassConcentrationUnit.GramPerLiter, DensityUnit.GramPerLiter, 1)]
+    [InlineData(MassConcentrationUnit.PoundPerUSGallon, DensityUnit.PoundPerUSGallon, 1)]
+    public void GetQuantityConversionFrom_QuantityWithSameDimensions_ReturnsTheClosestMatchingUnit(MassConcentrationUnit fromUnit, DensityUnit expectedUnit, double expectedCoefficient)
+    {
+        var expectedValue = QuantityValue.FromDoubleRounded(expectedCoefficient);
+        QuantityConversionFunction conversionFunction = Density.Info.GetQuantityConversionFrom(MassConcentration.Info[fromUnit]);
+
+        Assert.Equal(expectedUnit, conversionFunction.TargetUnit.ToUnit<DensityUnit>());
+        Assert.Equal(expectedValue, conversionFunction.Convert(QuantityValue.One));
+    }
+
+    [Theory]
+    [InlineData(MassFractionUnit.DecimalFraction, RatioUnit.DecimalFraction, 1)]
+    [InlineData(MassFractionUnit.Percent, RatioUnit.Percent, 1)]
+    [InlineData(MassFractionUnit.PartPerMillion, RatioUnit.PartPerMillion, 1)]
+    [InlineData(MassFractionUnit.GramPerKilogram, RatioUnit.PartPerThousand, 1)]
+    [InlineData(MassFractionUnit.HectogramPerGram, RatioUnit.DecimalFraction, 100)]
+    public void GetQuantityConversionFrom_DimensionlessQuantity_ReturnsTheClosestMatchingUnit(MassFractionUnit fromUnit, RatioUnit expectedUnit, double expectedCoefficient)
+    {
+        var expectedValue = QuantityValue.FromDoubleRounded(expectedCoefficient);
+        QuantityConversionFunction conversionFunction = Ratio.Info.GetQuantityConversionFrom(MassFraction.Info[fromUnit]);
+
+        Assert.Equal(expectedUnit, conversionFunction.TargetUnit.ToUnit<RatioUnit>());
+        Assert.Equal(expectedValue, conversionFunction.Convert(QuantityValue.One));
+    }
+
+    [Fact]
+    public void GetQuantityConversionFrom_QuantityWithIncompatibleBaseDimensions_ThrowsInvalidConversionException()
+    {
+        Assert.Throws<InvalidConversionException>(() => Mass.Info.GetQuantityConversionFrom(Volume.Info.BaseUnitInfo));
+    }
+
+    [Fact]
+    public void GetQuantityConversionFrom_QuantityWithIncompatibleBaseUnits_ThrowsInvalidConversionException()
+    {
+        UnitInfo sourceUnitInfo = MassConcentration.Info.BaseUnitInfo;
+        // we simulate a target quantity without any base units
+        var targetQuantityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+            unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+
+        Assert.Throws<InvalidConversionException>(() => targetQuantityInfo.GetQuantityConversionFrom(sourceUnitInfo));
+    }
+}
diff --git a/UnitsNet.Tests/QuantityFormatterTests.cs b/UnitsNet.Tests/QuantityFormatterTests.cs
index d0c6ba02e3..a025426923 100644
--- a/UnitsNet.Tests/QuantityFormatterTests.cs
+++ b/UnitsNet.Tests/QuantityFormatterTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -95,7 +95,7 @@ public static void StandardNumericFormatStrings_Equals_ValueWithFormatStringAndA
         {
             var length = Length.FromMeters(123456789.987654321);
 
-            var expected = string.Format(CultureInfo.CurrentCulture, $"{{0:{format}}} {{1:a}}", length.Value, length);
+            var expected = $"{length.Value.ToString(format, CultureInfo.CurrentCulture)} {Length.GetAbbreviation(length.Unit)}";
             Assert.Equal(expected, QuantityFormatter.Default.Format(length, format));
         }
 
@@ -106,6 +106,10 @@ public static void StandardNumericFormatStrings_Equals_ValueWithFormatStringAndA
         [InlineData("v")]
         [InlineData("Q")]
         [InlineData("q")]
+        [InlineData("A")]
+        [InlineData("a0")]
+        [InlineData("S")]
+        [InlineData("s2")]
         [InlineData("C")]
         [InlineData("C0")]
         [InlineData("C1")]
@@ -173,7 +177,7 @@ public static void CustomNumericFormatStrings_Equals_ValueWithFormatStringAndAbb
         {
             var length = Length.FromMeters(123456789.987654321);
 
-            var expected = string.Format(CultureInfo.CurrentCulture, $"{{0:{format}}} {{1:a}}", length.Value, length);
+            var expected = $"{length.Value.ToString(format, CultureInfo.CurrentCulture)} {Length.GetAbbreviation(length.Unit)}";
             Assert.Equal(expected, QuantityFormatter.Default.Format(length, format));
         }
 
@@ -196,5 +200,6 @@ public void Format_WithFormatParameter_FormatsWithCurrentCulture()
             var actual = QuantityFormatter.Format(length, "G");
             Assert.Equal(expected, actual);
         }
+
     }
 }
diff --git a/UnitsNet.Tests/QuantityIFormattableTests.cs b/UnitsNet.Tests/QuantityIFormattableTests.cs
index a214cc6392..1423c81162 100644
--- a/UnitsNet.Tests/QuantityIFormattableTests.cs
+++ b/UnitsNet.Tests/QuantityIFormattableTests.cs
@@ -1,8 +1,11 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using System.Linq;
+using System.Reflection;
 using UnitsNet.Units;
 using Xunit;
 
@@ -17,33 +20,57 @@ public class QuantityIFormattableTests
         private static readonly CultureInfo RussianCulture = CultureInfo.GetCultureInfo("ru-RU");
 
         [Fact]
-        public void GFormatStringEqualsToString()
+        public void FormattingApisIdentifyNumericFormatSyntax()
         {
-            Assert.Equal(MyLength.ToString("G"), MyLength.ToString());
+            MethodInfo quantityToString = typeof(Length).GetMethod(
+                nameof(Length.ToString),
+                [typeof(string), typeof(IFormatProvider)])!;
+            MethodInfo quantityValueToString = typeof(QuantityValue).GetMethod(
+                nameof(QuantityValue.ToString),
+                [typeof(string), typeof(IFormatProvider)])!;
+            MethodInfo formatter = typeof(QuantityFormatter)
+                .GetMethods()
+                .Single(method => method.Name == nameof(QuantityFormatter.Format) && method is { IsStatic: false, IsGenericMethod: true });
+
+            AssertNumericFormat(quantityToString.GetParameters()[0]);
+            AssertNumericFormat(quantityValueToString.GetParameters()[0]);
+            AssertNumericFormat(formatter.GetParameters()[1]);
+            Assert.Equal(
+                StringSyntaxAttribute.NumericFormat,
+                typeof(DisplayAsUnitAttribute).GetProperty(nameof(DisplayAsUnitAttribute.Format))!
+                    .GetCustomAttribute<StringSyntaxAttribute>()?.Syntax);
         }
 
-        [Fact]
-        public void EmptyOrNullFormatStringEqualsGFormat()
+        private static void AssertNumericFormat(ParameterInfo parameter)
         {
-            Assert.Equal(MyLength.ToString("G"), MyLength.ToString(string.Empty));
-            Assert.Equal(MyLength.ToString("G"), MyLength.ToString(format: null));
+            StringSyntaxAttribute? syntax = parameter.GetCustomAttribute<StringSyntaxAttribute>();
+            Assert.Equal(StringSyntaxAttribute.NumericFormat, syntax?.Syntax);
         }
 
         [Fact]
-        public void AFormatGetsAbbreviations()
+        public void GFormatStringEqualsToString()
         {
-            UnitAbbreviationsCache cache = UnitsNetSetup.Default.UnitAbbreviations;
-            Assert.Equal(cache.GetDefaultAbbreviation(MyLength.Unit, CultureInfo.InvariantCulture), MyLength.ToString("a", CultureInfo.InvariantCulture));
-            Assert.Equal(cache.GetDefaultAbbreviation(MyLength.Unit, CultureInfo.InvariantCulture), MyLength.ToString("a0", CultureInfo.InvariantCulture));
-
-            Assert.Equal(cache.GetUnitAbbreviations(MyLength.Unit, CultureInfo.InvariantCulture)[1], MyLength.ToString("a1", CultureInfo.InvariantCulture));
-            Assert.Equal(cache.GetUnitAbbreviations(MyLength.Unit, CultureInfo.InvariantCulture)[2], MyLength.ToString("a2", CultureInfo.InvariantCulture));
+            Assert.Equal(MyLength.ToString("G"), MyLength.ToString());
         }
 
         [Fact]
-        public void AFormatWithInvalidIndexThrowsFormatException()
+        public void EmptyOrNullFormatStringEqualsGFormat()
         {
-            Assert.Throws<FormatException>(() => MyLength.ToString("a100"));
+            Assert.Equal(MyLength.ToString("G"), MyLength.ToString(format: string.Empty));
+            Assert.Equal(MyLength.ToString("G"), MyLength.ToString(format: null!));
+        }
+
+        [Theory]
+        [InlineData("a")]
+        [InlineData("A0")]
+        [InlineData("s")]
+        [InlineData("S2")]
+        public void RemovedQuantitySpecificFormatThrowsWithMigrationGuidance(string format)
+        {
+            FormatException exception = Assert.Throws<FormatException>(
+                () => MyLength.ToString(format, CultureInfo.InvariantCulture));
+
+            Assert.Contains("no longer supported", exception.Message, StringComparison.Ordinal);
         }
 
         [Fact]
@@ -51,14 +78,14 @@ public void UnsupportedFormatStringThrowsException()
         {
             Assert.Throws<FormatException>(() => MyLength.ToString("z"));
         }
-
+        
         // The default, parameterless ToString() method represents the result with all significant digits, without a group separator.
         [Theory]
-#if NET
-        [InlineData(double.MinValue, "-1.7976931348623157E+308 m")]
-#else
+        #if NET
+        [InlineData(double.MinValue, "-1.797693134862315E+308 m")]
+        #else
         [InlineData(double.MinValue, "-1.79769313486232E+308 m")]
-#endif
+        #endif
         [InlineData(-0.819999999999, "-0.819999999999 m")]
         [InlineData(-0.111234, "-0.111234 m")]
         [InlineData(-0.1, "-0.1 m")]
@@ -70,16 +97,17 @@ public void UnsupportedFormatStringThrowsException()
         [InlineData(0.1, "0.1 m")]
         [InlineData(0.111234, "0.111234 m")]
         [InlineData(0.819999999999, "0.819999999999 m")]
-#if NET
-        [InlineData(double.MaxValue, "1.7976931348623157E+308 m")]
-#else
+        #if NET
+        [InlineData(double.MaxValue, "1.797693134862315E+308 m")]
+        #else
         [InlineData(double.MaxValue, "1.79769313486232E+308 m")]
-#endif
+        #endif
         public void DefaultToStringFormatting(double value, string expected)
         {
             string actual = Length.FromMeters(value).ToString(AmericanCulture);
             Assert.Equal(expected, actual);
         }
+
         [Theory]
         [InlineData("de-DE")]
         [InlineData("da-DK")]
@@ -98,24 +126,6 @@ public void RadixPointCultureFormatting(string cultureName)
             Assert.Equal($"0{ds}12 m", Length.FromMeters(0.12).ToString(culture));
         }
 
-        [Theory]
-        [InlineData("de-DE")]
-        [InlineData("da-DK")]
-        [InlineData("es-AR")]
-        [InlineData("es-ES")]
-        [InlineData("it-IT")]
-        [InlineData("en-CA")]
-        [InlineData("en-US")]
-        [InlineData("ar-EG")]
-        [InlineData("en-GB")]
-        [InlineData("es-MX")]
-        public void ToString_SFormat_DecimalSeparator_ForCulture(string cultureName)
-        {
-            CultureInfo culture = CultureInfo.GetCultureInfo(cultureName);
-            string ds = culture.NumberFormat.NumberDecimalSeparator;
-            Assert.Equal($"0{ds}12 m", Length.FromMeters(0.12).ToString("s2", culture));
-        }
-
         [Theory]
         [InlineData("en-CA")]
         [InlineData("en-GB")]
@@ -135,27 +145,6 @@ public void ToString_WithCultureWithoutGroupingSeparator(string cultureName)
             Assert.Equal("1111 m", Length.FromMeters(1111).ToString(culture));
         }
 
-        [Theory]
-        [InlineData("en-CA")]
-        [InlineData("en-GB")]
-        [InlineData("en-US")]
-        [InlineData("ar-EG")]
-        [InlineData("es-MX")]
-        [InlineData("nn-NO")]
-        [InlineData("fr-FR")]
-        [InlineData("de-DE")]
-        [InlineData("da-DK")]
-        [InlineData("es-AR")]
-        [InlineData("es-ES")]
-        [InlineData("it-IT")]
-        public void ToString_SFormat_UsesGroupingSeparator_ForCulture(string cultureName)
-        {
-            CultureInfo culture = CultureInfo.GetCultureInfo(cultureName);
-            string gs = culture.NumberFormat.NumberGroupSeparator;
-
-            Assert.Equal($"1{gs}111 m", Length.FromMeters(1111).ToString("S", culture));
-        }
-
         [Theory]
         [InlineData("en-CA")]
         [InlineData("en-GB")]
@@ -173,7 +162,7 @@ public void FeetInches_UseGroupingSeparator_ForCulture(string cultureName)
         {
             CultureInfo culture = CultureInfo.GetCultureInfo(cultureName);
             string gs = culture.NumberFormat.NumberGroupSeparator;
-
+            
             // Feet/Inch and Stone/Pound combinations are only used (customarily) in the US, UK and maybe Ireland - all English speaking countries.
             // FeetInches returns a whole number of feet, with the remainder expressed (rounded) in inches. Same for StonePounds.
             Assert.Equal($"3{gs}333 st 7 lb", Mass.FromStonePounds(3333, 7).StonePounds.ToString(culture));
@@ -196,80 +185,12 @@ public void StonePounds_UseGroupingSeparator_ForCulture(string cultureName)
         {
             CultureInfo culture = CultureInfo.GetCultureInfo(cultureName);
             string gs = culture.NumberFormat.NumberGroupSeparator;
-
+            
             // Feet/Inch and Stone/Pound combinations are only used (customarily) in the US, UK and maybe Ireland - all English speaking countries.
             // FeetInches returns a whole number of feet, with the remainder expressed (rounded) in inches. Same for StonePounds.
             Assert.Equal($"3{gs}333 st 7 lb", Mass.FromStonePounds(3333, 7).StonePounds.ToString(culture));
         }
-
-        // Due to rounding, the values will result in the same string representation regardless of the number of significant digits (up to a certain point)
-        [Theory]
-        [InlineData(-0.819999999999, "S", "-0.819999999999 m")]
-        [InlineData(-0.819999999999, "s2", "-0.82 m")]
-        [InlineData(-0.819999999999, "s4", "-0.82 m")]
-        [InlineData(-0.8, "s4", "-0.8 m")]
-        [InlineData(0.819999999999, "S", "0.819999999999 m")]
-        [InlineData(0.819999999999, "s", "0.819999999999 m")]
-        [InlineData(0.819999999999, "s2", "0.82 m")]
-        [InlineData(0.819999999999, "s4", "0.82 m")]
-        [InlineData(0.8, "s4", "0.8 m")]
-        [InlineData(0.00299999999, "s2", "0.003 m")]
-        [InlineData(0.00299999999, "s4", "0.003 m")]
-        [InlineData(0.0003000001, "s2", "3e-04 m")]
-        [InlineData(0.0003000001, "s4", "3e-04 m")]
-        public void ToString_SFormat_RoundsToSignificantDigitsAfterRadix(double value,
-            string significantDigitsAfterRadixFormatString, string expected)
-        {
-            string actual = Length.FromMeters(value).ToString(significantDigitsAfterRadixFormatString, AmericanCulture);
-            Assert.Equal(expected, actual);
-        }
-
-        // Any value in the interval (-inf ≤ x < 1e-03] is formatted in scientific notation
-        [Theory]
-        [InlineData(double.MinValue, "-1.8e+308 m")]
-        [InlineData(1.23e-120, "1.23e-120 m")]
-        [InlineData(0.0000111, "1.11e-05 m")]
-        [InlineData(1.99e-4, "1.99e-04 m")]
-        public void ToString_SFormat_BelowMilli_UsesScientificNotation(double value, string expected)
-        {
-            string actual = Length.FromMeters(value).ToString("s2", AmericanCulture);
-            Assert.Equal(expected, actual);
-        }
-
-        // Any value in the interval [1e-03 ≤ x < 1e+03] is formatted in fixed point notation.
-        [Theory]
-        [InlineData(1e-3, "0.001 m")]
-        [InlineData(1.1, "1.1 m")]
-        [InlineData(999.99, "999.99 m")]
-        public void ToString_SFormat_BetweenMilliAndKilo_UsesFixedPointFormat(double value, string expected)
-        {
-            string actual = Length.FromMeters(value).ToString("s2",AmericanCulture);
-            Assert.Equal(expected, actual);
-        }
-
-        // Any value in the interval [1e+03 ≤ x < 1e+06] is formatted in fixed point notation with digit grouping.
-        [Theory]
-        [InlineData(1000, "1,000 m")]
-        [InlineData(11000, "11,000 m")]
-        [InlineData(111000, "111,000 m")]
-        [InlineData(999999.99, "999,999.99 m")]
-        public void ToString_SFormat_From1e3To1e5_UsesFixedPointFormatWithDigitGrouping(double value, string expected)
-        {
-            string actual = Length.FromMeters(value).ToString("s2",AmericanCulture);
-            Assert.Equal(expected, actual);
-        }
-
-        // Any value in the interval [1e+06 ≤ x ≤ +inf) is formatted in scientific notation.
-        [Theory]
-        [InlineData(1e6, "1e+06 m")]
-        [InlineData(11100000, "1.11e+07 m")]
-        [InlineData(double.MaxValue, "1.8e+308 m")]
-        public void ToString_SFormat_Above1e6_UsesScientificNotation(double value, string expected)
-        {
-            string actual = Length.FromMeters(value).ToString("s2",AmericanCulture);
-            Assert.Equal(expected, actual);
-        }
-
+        
         [Fact]
         public void AllUnitsImplementToStringForInvariantCulture()
         {
@@ -323,6 +244,5 @@ public void ToString_WithRussianCulture()
             Assert.Equal("1 Н·м", Torque.FromNewtonMeters(1).ToUnit(TorqueUnit.NewtonMeter).ToString(RussianCulture));
             Assert.Equal("1 м³", Volume.FromCubicMeters(1).ToUnit(VolumeUnit.CubicMeter).ToString(RussianCulture));
         }
-
     }
 }
diff --git a/UnitsNet.Tests/QuantityInfoTest.cs b/UnitsNet.Tests/QuantityInfoTest.cs
index 623bea64c2..cef3be548f 100644
--- a/UnitsNet.Tests/QuantityInfoTest.cs
+++ b/UnitsNet.Tests/QuantityInfoTest.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Diagnostics.CodeAnalysis;
@@ -16,7 +16,7 @@ public void Constructor_AssignsProperties()
         UnitDefinition<LengthUnit>[] expectedUnitInfos =
         [
             new(LengthUnit.Centimeter, "Centimeters", new BaseUnits(LengthUnit.Centimeter)),
-            new(LengthUnit.Kilometer, "Kilometers", new BaseUnits(LengthUnit.Kilometer))
+            new(LengthUnit.Kilometer, "Kilometers", new BaseUnits(LengthUnit.Kilometer), 100)
         ];
         const LengthUnit expectedBaseUnit = LengthUnit.Centimeter;
         var expectedZero = Length.FromCentimeters(10);
@@ -56,6 +56,8 @@ public void Constructor_AssignsProperties()
                 Assert.Equal(expectedUnitInfos[0].Name, firstUnitInfo.Name);
                 Assert.Equal(expectedUnitInfos[0].PluralName, firstUnitInfo.PluralName);
                 Assert.Equal(expectedUnitInfos[0].BaseUnits, firstUnitInfo.BaseUnits);
+                Assert.Equal(expectedUnitInfos[0].ConversionFromBase, firstUnitInfo.ConversionFromBase);
+                Assert.Equal(expectedUnitInfos[0].ConversionToBase, firstUnitInfo.ConversionToBase);
                 Assert.Equal(quantityInfo, firstUnitInfo.QuantityInfo);
             }, secondUnitInfo =>
             {
@@ -63,6 +65,8 @@ public void Constructor_AssignsProperties()
                 Assert.Equal(expectedUnitInfos[1].Name, secondUnitInfo.Name);
                 Assert.Equal(expectedUnitInfos[1].PluralName, secondUnitInfo.PluralName);
                 Assert.Equal(expectedUnitInfos[1].BaseUnits, secondUnitInfo.BaseUnits);
+                Assert.Equal(expectedUnitInfos[1].ConversionFromBase, secondUnitInfo.ConversionFromBase);
+                Assert.Equal(expectedUnitInfos[1].ConversionToBase, secondUnitInfo.ConversionToBase);
                 Assert.Equal(quantityInfo, secondUnitInfo.QuantityInfo);
             });
         }, () =>
@@ -105,8 +109,8 @@ public void Constructor_AssignsPropertiesForCustomQuantity()
         UnitDefinition<HowMuchUnit>[] expectedUnitInfos =
         [
             new(HowMuchUnit.Some, "Some", BaseUnits.Undefined),
-            new(HowMuchUnit.ATon, "Tons", BaseUnits.Undefined),
-            new(HowMuchUnit.AShitTon, "ShitTons", BaseUnits.Undefined)
+            new(HowMuchUnit.ATon, "Tons", BaseUnits.Undefined, new QuantityValue(1, 10)),
+            new(HowMuchUnit.AShitTon, "ShitTons", BaseUnits.Undefined, new QuantityValue(1, 100))
         ];
         const HowMuchUnit expectedBaseUnit = HowMuchUnit.Some;
         var expectedZero = new HowMuch(10, HowMuchUnit.Some);
@@ -125,6 +129,8 @@ public void Constructor_AssignsPropertiesForCustomQuantity()
             Assert.Equal(expectedUnitInfos[0].Name, firstUnitInfo.Name);
             Assert.Equal(expectedUnitInfos[0].PluralName, firstUnitInfo.PluralName);
             Assert.Equal(expectedUnitInfos[0].BaseUnits, firstUnitInfo.BaseUnits);
+            Assert.Equal(expectedUnitInfos[0].ConversionFromBase, firstUnitInfo.ConversionFromBase);
+            Assert.Equal(expectedUnitInfos[0].ConversionToBase, firstUnitInfo.ConversionToBase);
             Assert.Equal(quantityInfo, firstUnitInfo.QuantityInfo);
         }, secondUnitInfo =>
         {
@@ -132,6 +138,8 @@ public void Constructor_AssignsPropertiesForCustomQuantity()
             Assert.Equal(expectedUnitInfos[1].Name, secondUnitInfo.Name);
             Assert.Equal(expectedUnitInfos[1].PluralName, secondUnitInfo.PluralName);
             Assert.Equal(expectedUnitInfos[1].BaseUnits, secondUnitInfo.BaseUnits);
+            Assert.Equal(expectedUnitInfos[1].ConversionFromBase, secondUnitInfo.ConversionFromBase);
+            Assert.Equal(expectedUnitInfos[1].ConversionToBase, secondUnitInfo.ConversionToBase);
             Assert.Equal(quantityInfo, secondUnitInfo.QuantityInfo);
         }, thirdUnitInfo =>
         {
@@ -139,6 +147,8 @@ public void Constructor_AssignsPropertiesForCustomQuantity()
             Assert.Equal(expectedUnitInfos[2].Name, thirdUnitInfo.Name);
             Assert.Equal(expectedUnitInfos[2].PluralName, thirdUnitInfo.PluralName);
             Assert.Equal(expectedUnitInfos[2].BaseUnits, thirdUnitInfo.BaseUnits);
+            Assert.Equal(expectedUnitInfos[2].ConversionFromBase, thirdUnitInfo.ConversionFromBase);
+            Assert.Equal(expectedUnitInfos[2].ConversionToBase, thirdUnitInfo.ConversionToBase);
             Assert.Equal(quantityInfo, thirdUnitInfo.QuantityInfo);
         });
         Assert.Equal(expectedZero, quantityInfo.Zero);
@@ -167,7 +177,9 @@ public void Constructor_WithoutZero_UsesZeroBaseUnit()
             expectedBaseUnit == unitInfo.Value &&
             expectedUnitInfos[0].Name == unitInfo.Name &&
             expectedUnitInfos[0].PluralName == unitInfo.PluralName &&
-            expectedUnitInfos[0].BaseUnits == unitInfo.BaseUnits
+            expectedUnitInfos[0].BaseUnits == unitInfo.BaseUnits &&
+            expectedUnitInfos[0].ConversionFromBase == unitInfo.ConversionFromBase &&
+            expectedUnitInfos[0].ConversionToBase == unitInfo.ConversionToBase
         );
         Assert.Equal(expectedBaseDimensions, quantityInfo.BaseDimensions);
         Assert.Null(quantityInfo.UnitAbbreviations);
@@ -195,7 +207,9 @@ public void Constructor_WithoutName_UsesDefaultQuantityTypeName()
             expectedBaseUnit == firstUnitInfo.Value &&
             expectedUnitInfos[0].Name == firstUnitInfo.Name &&
             expectedUnitInfos[0].PluralName == firstUnitInfo.PluralName &&
-            expectedUnitInfos[0].BaseUnits == firstUnitInfo.BaseUnits
+            expectedUnitInfos[0].BaseUnits == firstUnitInfo.BaseUnits &&
+            expectedUnitInfos[0].ConversionFromBase == firstUnitInfo.ConversionFromBase &&
+            expectedUnitInfos[0].ConversionToBase == firstUnitInfo.ConversionToBase
         );
         Assert.Equal(expectedBaseDimensions, quantityInfo.BaseDimensions);
         Assert.Equal(abbreviations, quantityInfo.UnitAbbreviations);
@@ -227,8 +241,8 @@ public void Constructor_GivenANullUnitInfo_ThrowsArgumentNullException()
         Assert.Throws<ArgumentNullException>(() => new QuantityInfo<Length, LengthUnit>(nameof(Length),
             LengthUnit.Meter, collectionContainingANull, Length.BaseDimensions, Length.From));
 #else
-            Assert.Throws<NullReferenceException>(() => new QuantityInfo<Length, LengthUnit>(nameof(Length),
-                LengthUnit.Meter, collectionContainingANull, Length.BaseDimensions, Length.From));
+        Assert.Throws<NullReferenceException>(() => new QuantityInfo<Length, LengthUnit>(nameof(Length),
+            LengthUnit.Meter, collectionContainingANull, Length.BaseDimensions, Length.From));
 #endif
     }
 
@@ -532,13 +546,14 @@ public void UntypedIndexer_WithUnknownUnitKeyValue_ThrowsInvalidOperationExcepti
     [InlineData(2, MassUnit.Milligram)]
     public void From_ValueAndUnit_ReturnsTheExpectedQuantity(double value, MassUnit unit)
     {
+        var expectedValue = QuantityValue.FromDoubleRounded(value);
         Assert.Multiple(() =>
         {
             QuantityInfo<Mass, MassUnit> quantityInfo = Mass.Info;
 
             Mass quantity = quantityInfo.From(value, unit);
 
-            Assert.Equal(value, quantity.Value);
+            Assert.Equal(expectedValue, quantity.Value);
             Assert.Equal(unit, quantity.Unit);
         }, () =>
         {
@@ -546,7 +561,7 @@ public void From_ValueAndUnit_ReturnsTheExpectedQuantity(double value, MassUnit
 
             IQuantity<MassUnit> quantity = quantityInfo.From(value, unit);
 
-            Assert.Equal(value, quantity.Value);
+            Assert.Equal(expectedValue, quantity.Value);
             Assert.Equal(unit, quantity.Unit);
         }, () =>
         {
@@ -554,7 +569,7 @@ public void From_ValueAndUnit_ReturnsTheExpectedQuantity(double value, MassUnit
 
             IQuantity quantity = quantityInfo.From(value, unit);
 
-            Assert.Equal(value, quantity.Value);
+            Assert.Equal(expectedValue, quantity.Value);
             Assert.Equal(unit, quantity.Unit);
         });
     }
@@ -564,11 +579,12 @@ public void From_ValueAndUnit_ReturnsTheExpectedQuantity(double value, MassUnit
     [InlineData(2, MassUnit.Milligram)]
     public void From_ValueAndUnitKey_WithSameUnitType_ReturnsTheExpectedQuantity(double value, MassUnit unit)
     {
+        var expectedValue = QuantityValue.FromDoubleRounded(value);
         IQuantityInstanceInfo<Mass> quantityInfo = Mass.Info;
 
         Mass quantity = quantityInfo.Create(value, UnitKey.ForUnit(unit));
 
-        Assert.Equal(value, quantity.Value);
+        Assert.Equal(expectedValue, quantity.Value);
         Assert.Equal(unit, quantity.Unit);
     }
 
@@ -577,11 +593,12 @@ public void From_ValueAndUnitKey_WithSameUnitType_ReturnsTheExpectedQuantity(dou
     [InlineData(2, MassUnit.Milligram)]
     public void From_ValueAnEnum_WithSameUnitType_ReturnsTheExpectedQuantity(double value, Enum unit)
     {
+        var expectedValue = QuantityValue.FromDoubleRounded(value);
         QuantityInfo<Mass, MassUnit> quantityInfo = Mass.Info;
 
         IQuantity quantity = quantityInfo.From(value, unit);
 
-        Assert.Equal(value, quantity.Value);
+        Assert.Equal(expectedValue, quantity.Value);
         Assert.Equal(unit, quantity.Unit);
     }
 
@@ -611,7 +628,6 @@ public void ToString_ReturnsTheQuantityName()
     }
 
 #if NET
-
     [Fact]
     public void Constructor_WithoutDelegate_UsesTheDefaultQuantityFrom()
     {
@@ -634,7 +650,9 @@ public void Constructor_WithoutDelegate_UsesTheDefaultQuantityFrom()
             expectedBaseUnit == firstUnitInfo.Value &&
             expectedUnitInfos[0].Name == firstUnitInfo.Name &&
             expectedUnitInfos[0].PluralName == firstUnitInfo.PluralName &&
-            expectedUnitInfos[0].BaseUnits == firstUnitInfo.BaseUnits
+            expectedUnitInfos[0].BaseUnits == firstUnitInfo.BaseUnits &&
+            expectedUnitInfos[0].ConversionFromBase == firstUnitInfo.ConversionFromBase &&
+            expectedUnitInfos[0].ConversionToBase == firstUnitInfo.ConversionToBase
         );
         Assert.Equal(expectedBaseDimensions, quantityInfo.BaseDimensions);
         Assert.Equal(abbreviations, quantityInfo.UnitAbbreviations);
@@ -661,7 +679,9 @@ public void Constructor_WithoutNameOrDelegate_UsesTheDefaultQuantityNameAndFrom(
             expectedBaseUnit == firstUnitInfo.Value &&
             expectedUnitInfos[0].Name == firstUnitInfo.Name &&
             expectedUnitInfos[0].PluralName == firstUnitInfo.PluralName &&
-            expectedUnitInfos[0].BaseUnits == firstUnitInfo.BaseUnits
+            expectedUnitInfos[0].BaseUnits == firstUnitInfo.BaseUnits &&
+            expectedUnitInfos[0].ConversionFromBase == firstUnitInfo.ConversionFromBase &&
+            expectedUnitInfos[0].ConversionToBase == firstUnitInfo.ConversionToBase
         );
         Assert.Equal(expectedBaseDimensions, quantityInfo.BaseDimensions);
         Assert.Equal(abbreviations, quantityInfo.UnitAbbreviations);
diff --git a/UnitsNet.Tests/QuantityParserTests.cs b/UnitsNet.Tests/QuantityParserTests.cs
index e63f29fdb7..c9fbef0a3e 100644
--- a/UnitsNet.Tests/QuantityParserTests.cs
+++ b/UnitsNet.Tests/QuantityParserTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Globalization;
diff --git a/UnitsNet.Tests/QuantityTest.cs b/UnitsNet.Tests/QuantityTest.cs
index b074f9df99..fda56a39c5 100644
--- a/UnitsNet.Tests/QuantityTest.cs
+++ b/UnitsNet.Tests/QuantityTest.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Globalization;
@@ -38,7 +38,7 @@ public void TryFrom_GivenNullUnit_ReturnsFalse()
             Enum? nullUnit = null;
             Assert.False(Quantity.TryFrom(1, nullUnit, out IQuantity? _));
         }
-
+        
         [Fact]
         public void TryFrom_GivenUnknownUnitType_ReturnsFalse()
         {
diff --git a/UnitsNet.Tests/QuantityTests.ToString.cs b/UnitsNet.Tests/QuantityTests.ToString.cs
index 65faccd6aa..e699c9d76b 100644
--- a/UnitsNet.Tests/QuantityTests.ToString.cs
+++ b/UnitsNet.Tests/QuantityTests.ToString.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/QuantityTests.cs b/UnitsNet.Tests/QuantityTests.cs
index c3ad83bd97..0d9f718541 100644
--- a/UnitsNet.Tests/QuantityTests.cs
+++ b/UnitsNet.Tests/QuantityTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Globalization;
@@ -18,6 +18,80 @@ public void GetHashCodeForDifferentQuantitiesWithSameValuesAreNotEqual()
             Assert.NotEqual(length.GetHashCode(), area.GetHashCode());
         }
 
+        // [Theory]
+        // [InlineData("10 m", "9.89 m" , "0.1 m", false)] // +/- 0.1m absolute tolerance and some additional margin tolerate rounding errors in test case.
+        // [InlineData("10 m", "9.91 m" , "0.1 m", true)]
+        // [InlineData("10 m", "10.09 m", "0.1 m", true)]
+        // [InlineData("10 m", "1009 cm", "0.1 m", true)]  // Different unit, still equal.
+        // [InlineData("10 m", "10.11 m", "0.1 m", false)]
+        // [InlineData("10 m", "8.9 m"  , "0.1 m", false)] // +/- 1m relative tolerance (10%) and some additional margin tolerate rounding errors in test case.
+        // public void Equals_IGenericEquatableQuantity(string q1String, string q2String, string toleranceString, bool expectedEqual)
+        // {
+        //     // This interfaces implements .NET generic math interfaces.
+        //     IQuantity<Length, LengthUnit> q1 = ParseLength(q1String);
+        //     IQuantity<Length, LengthUnit> q2 = ParseLength(q2String);
+        //     IQuantity<Length, LengthUnit> tolerance = ParseLength(toleranceString);
+        //
+        //     Assert.Equal(expectedEqual, q1.Equals(q2, tolerance));
+        // }
+        //
+        // [Theory]
+        // [InlineData("10 m", "9.89 m" , "0.1 m", false)] // +/- 0.1m absolute tolerance and some additional margin tolerate rounding errors in test case.
+        // [InlineData("10 m", "9.91 m" , "0.1 m", true)]
+        // [InlineData("10 m", "10.09 m", "0.1 m", true)]
+        // [InlineData("10 m", "1009 cm", "0.1 m", true)]  // Different unit, still equal.
+        // [InlineData("10 m", "10.11 m", "0.1 m", false)]
+        // [InlineData("10 m", "8.9 m"  , "0.1 m", false)] // +/- 1m relative tolerance (10%) and some additional margin tolerate rounding errors in test case.
+        // public void Equals_IQuantity(string q1String, string q2String, string toleranceString, bool expectedEqual)
+        // {
+        //     IQuantity q1 = ParseLength(q1String);
+        //     IQuantity q2 = ParseLength(q2String);
+        //     IQuantity tolerance = ParseLength(toleranceString);
+        //
+        //     Assert.NotEqual(q1, q2); // Strict equality should not be equal.
+        //     Assert.Equal(expectedEqual, q1.Equals(q2, tolerance));
+        // }
+        //
+        // [Fact]
+        // public void Equals_IQuantity_OtherIsNull_ReturnsFalse()
+        // {
+        //     IQuantity q1 = ParseLength("10 m");
+        //     IQuantity? q2 = null;
+        //     IQuantity tolerance = ParseLength("0.1 m");
+        //
+        //     Assert.False(q1.Equals(q2, tolerance));
+        // }
+        //
+        // [Fact]
+        // public void Equals_IQuantity_OtherIsDifferentType_ReturnsFalse()
+        // {
+        //     IQuantity q1 = ParseLength("10 m");
+        //     IQuantity q2 = Mass.FromKilograms(10);
+        //     IQuantity tolerance = Mass.FromKilograms(0.1);
+        //
+        //     Assert.False(q1.Equals(q2, tolerance));
+        // }
+        //
+        // [Fact]
+        // public void Equals_IQuantity_ToleranceIsDifferentType_Throws()
+        // {
+        //     IQuantity q1 = ParseLength("10 m");
+        //     IQuantity q2 = ParseLength("10 m");
+        //     IQuantity tolerance = Mass.FromKilograms(0.1);
+        //
+        //     Assert.Throws<ArgumentException>(() => q1.Equals(q2, tolerance));
+        // }
+        //
+        // [Fact]
+        // public void Equals_GenericEquatableIQuantity_OtherIsNull_ReturnsFalse()
+        // {
+        //     IQuantity<Length, LengthUnit> q1 = ParseLength("10 m");
+        //     IQuantity<Length, LengthUnit>? q2 = null;
+        //     IQuantity<Length, LengthUnit> tolerance = ParseLength("0.1 m");
+        //
+        //     Assert.False(q1.Equals(q2, tolerance));
+        // }
+
         [Fact]
         public void TryFrom_ValidQuantityNameAndUnitName_ReturnsTrueAndQuantity()
         {
@@ -160,10 +234,5 @@ public void AllowSpecialValue()
                 Assert.Fail("Special double values (NaN, -Inf, +Inf) must be allowed.");
             }
         }
-
-        private static Length ParseLength(string str)
-        {
-            return Length.Parse(str, CultureInfo.InvariantCulture);
-        }
     }
 }
diff --git a/UnitsNet.Tests/QuantityTypeConverterTest.cs b/UnitsNet.Tests/QuantityTypeConverterTest.cs
index 13ba43058d..c503f76593 100644
--- a/UnitsNet.Tests/QuantityTypeConverterTest.cs
+++ b/UnitsNet.Tests/QuantityTypeConverterTest.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.ComponentModel;
@@ -71,8 +71,9 @@ public void CanConvertTo_GivenSomeTypes(Type value, bool expectedResult)
         [InlineData("1m", 1, Units.LengthUnit.Meter)]
         [InlineData("1", 1, Units.LengthUnit.Meter)]
         [InlineData("1km", 1, Units.LengthUnit.Kilometer)]
-        public void ConvertFrom_GivenQuantityStringAndContextWithNoAttributes_ReturnsQuantityWithBaseUnitIfNotSpecified(string str, double expectedValue, Enum expectedUnit)
+        public void ConvertFrom_GivenQuantityStringAndContextWithNoAttributes_ReturnsQuantityWithBaseUnitIfNotSpecified(string str, double expected, Enum expectedUnit)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var converter = new QuantityTypeConverter<Length>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
 
@@ -87,8 +88,9 @@ public void ConvertFrom_GivenQuantityStringAndContextWithNoAttributes_ReturnsQua
         [InlineData("1m", 1, Units.LengthUnit.Meter)]
         [InlineData("1", 1, Units.LengthUnit.Centimeter)]
         [InlineData("1km", 1, Units.LengthUnit.Kilometer)]
-        public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAttribute_ReturnsQuantityWithGivenDefaultUnitIfNotSpecified(string str, double expectedValue, Enum expectedUnit)
+        public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAttribute_ReturnsQuantityWithGivenDefaultUnitIfNotSpecified(string str, double expected, Enum expectedUnit)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var converter = new QuantityTypeConverter<Length>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
             {
@@ -106,8 +108,9 @@ public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAttribute_Re
         [InlineData("1m", 1, Units.LengthUnit.Meter)]
         [InlineData("1", 0.01, Units.LengthUnit.Meter)]
         [InlineData("1km", 1000, Units.LengthUnit.Meter)]
-        public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAndConvertToUnitAttributes_ReturnsQuantityConvertedToUnit(string str, double expectedValue, Enum expectedUnit)
+        public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAndConvertToUnitAttributes_ReturnsQuantityConvertedToUnit(string str, double expected, Enum expectedUnit)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             var converter = new QuantityTypeConverter<Length>();
             ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
             {
@@ -127,9 +130,10 @@ public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAndConvertTo
         [InlineData(double.NaN)]
         [InlineData(double.PositiveInfinity)]
         [InlineData(double.NegativeInfinity)]
-        public void ConvertFrom_GivenQuantityStringAndNullCulture_ReturnsQuantityConvertedToUnit(double expectedValue)
+        public void ConvertFrom_GivenQuantityStringAndNullCulture_ReturnsQuantityConvertedToUnit(double expected)
         {
-            var str = expectedValue.ToString(CultureInfo.CurrentCulture) + "mm";
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            var str = expected.ToString(CultureInfo.CurrentCulture) + "mm";
             var converter = new QuantityTypeConverter<Length>();
 
             var convertedValue = (Length)converter.ConvertFrom(null, null, str)!;
diff --git a/UnitsNet.Tests/Serialization/CustomSerializationTests.cs b/UnitsNet.Tests/Serialization/CustomSerializationTests.cs
index becb73871e..aa05d55c29 100644
--- a/UnitsNet.Tests/Serialization/CustomSerializationTests.cs
+++ b/UnitsNet.Tests/Serialization/CustomSerializationTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using UnitsNet.Units;
diff --git a/UnitsNet.Tests/Serialization/Json/DefaultDataContractJsonSerializerTests.cs b/UnitsNet.Tests/Serialization/Json/DefaultDataContractJsonSerializerTests.cs
index 3f4eaaea1e..b27a33e59c 100644
--- a/UnitsNet.Tests/Serialization/Json/DefaultDataContractJsonSerializerTests.cs
+++ b/UnitsNet.Tests/Serialization/Json/DefaultDataContractJsonSerializerTests.cs
@@ -1,13 +1,10 @@
-using System;
-using System.Globalization;
-using System.IO;
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Json;
 using UnitsNet.Units;
-using Xunit;
 
 namespace UnitsNet.Tests.Serialization.Json
 {
+    
     /// <summary>
     ///     These tests demonstrate the default behavior of the DataContractJsonSerializer when dealing with quantities
     ///     <remarks>
@@ -21,7 +18,7 @@ public class DefaultDataContractJsonSerializerTests : SerializationTestsBase<str
     {
         protected override string SerializeObject(object obj)
         {
-            var serializer = new DataContractJsonSerializer(obj.GetType());
+            var serializer = new DataContractJsonSerializer(obj.GetType(), new DataContractJsonSerializerSettings(){SerializeReadOnlyTypes = true});
             using var stream = new MemoryStream();
             serializer.WriteObject(stream, obj);
             stream.Position = 0;
@@ -29,12 +26,12 @@ protected override string SerializeObject(object obj)
             return streamReader.ReadToEnd();
         }
 
-        protected override T DeserializeObject<T>(string xml)
+        protected override T DeserializeObject<T>(string json)
         {
             var serializer = new DataContractJsonSerializer(typeof(T));
             using var stream = new MemoryStream();
             using var writer = new StreamWriter(stream);
-            writer.Write(xml);
+            writer.Write(json);
             writer.Flush();
             stream.Position = 0;
             return (T)(serializer.ReadObject(stream) ?? throw new InvalidOperationException("Read 'null' from stream."));
@@ -43,11 +40,11 @@ protected override T DeserializeObject<T>(string xml)
         #region Serialization tests
 
         [Fact]
-        public void DoubleQuantity_SerializedWithDoubleValueAndunitInt()
+        public void Quantity_SerializedWithNumeratorAndDenominatorValueAndIntegerUnit()
         {
             var quantity = new Mass(1.20, MassUnit.Milligram);
             var unitInt = (int)quantity.Unit;
-            var expectedJson = $"{{\"Value\":1.2,\"Unit\":{unitInt}}}";
+            var expectedJson = $$$"""{"Value":{"N":{"_bits":null,"_sign":12},"D":{"_bits":null,"_sign":10}},"Unit":{{{unitInt}}}}""";
 
             var json = SerializeObject(quantity);
 
@@ -59,33 +56,20 @@ public void DoubleQuantity_SerializedWithDoubleValueAndunitInt()
         #region Deserialization tests
 
         [Fact]
-        public void DoubleQuantity_DeserializedFromDoubleValueAndunitInt()
+        public void Quantity_DeserializedFromValueAndIntegerUnit()
         {
             var expectedUnit = MassUnit.Milligram;
             var unitInt = (int)expectedUnit;
-            var json = $"{{\"Value\":1.2,\"Unit\":{unitInt}}}";
+            var json = $$$"""{"Value":{"N":{"_bits":null,"_sign":12},"D":{"_bits":null,"_sign":10}},"Unit":{{{unitInt}}}}""";
 
             var quantity = DeserializeObject<Mass>(json);
 
-            Assert.Equal(1.2, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
             Assert.Equal(expectedUnit, quantity.Unit);
         }
 
         [Fact]
-        public void DoubleQuantity_DeserializedFromQuotedDoubleValueAndunitInt()
-        {
-            var expectedUnit = MassUnit.Milligram;
-            var unitInt = (int)expectedUnit;
-            var json = $"{{\"Value\":\"1.2\",\"Unit\":{unitInt}}}";
-
-            var quantity = DeserializeObject<Mass>(json);
-
-            Assert.Equal(1.2, quantity.Value);
-            Assert.Equal(expectedUnit, quantity.Unit);
-        }
-
-        [Fact]
-        public void DoubleZeroQuantity_DeserializedFromunitIntAndNoValue()
+        public void ZeroQuantity_DeserializedFromIntegerUnitAndNoValue()
         {
             var expectedUnit = MassUnit.Milligram;
             var unitInt = (int)expectedUnit;
@@ -103,7 +87,7 @@ public void InterfaceObject_IncludesTypeInformation()
             var unit = InformationUnit.Exabyte;
             var unitInt = (int)unit;
             var testObject = new TestInterfaceObject { Quantity = new Information(1.2, unit) };
-            var expectedJson = $"{{\"Quantity\":{{\"__type\":\"Information:#UnitsNet\",\"Value\":1.2,\"Unit\":{unitInt}}}}}";
+            var expectedJson = $$$"""{"Quantity":{"__type":"Information:#UnitsNet","Value":{"N":{"_bits":null,"_sign":12},"D":{"_bits":null,"_sign":10}},"Unit":{{{unitInt}}}}}""";
 
             var json = SerializeObject(testObject);
 
@@ -111,41 +95,22 @@ public void InterfaceObject_IncludesTypeInformation()
         }
 
         [Fact]
-        public void DoubleBaseUnitQuantity_DeserializedFromValueAndNoUnit()
+        public void BaseUnitQuantity_DeserializedFromValueAndNoUnit()
         {
-            var json = "{\"Value\":1.2}";
+            var json = """{"Value":{"N":{"_bits":null,"_sign":12},"D":{"_bits":null,"_sign":10}}""";
 
             var quantity = DeserializeObject<Mass>(json);
 
-            Assert.Equal(1.2, quantity.Value);
-            Assert.Equal(Mass.BaseUnit, quantity.Unit);
-        }
-
-        [Fact]
-        public void DoubleZeroBaseQuantity_DeserializedFromEmptyInput()
-        {
-            var json = "{}";
-
-            var quantity = DeserializeObject<Mass>(json);
-
-            Assert.Equal(0, quantity.Value);
+            Assert.Equal(1.2m, quantity.Value);
             Assert.Equal(Mass.BaseUnit, quantity.Unit);
         }
 
         [Fact]
-        public void InterfaceObject_WithMissingKnownTypeInformation_ThrowsSerializationException()
-        {
-            var testObject = new TestInterfaceObject { Quantity = new Volume(1.2, VolumeUnit.Microliter) };
-
-            Assert.Throws<SerializationException>(() => SerializeObject(testObject));
-        }
-
-        [Fact]
-        public void DecimalZeroQuantity_DeserializedFromUnitIntAndNoValue()
+        public void ZeroQuantity_DeserializedFromUnitIntAndNoValue()
         {
             var expectedUnit = InformationUnit.Exabyte;
             var unitInt = (int)expectedUnit;
-            var json = $"{{\"Unit\":{unitInt}}}";
+            var json = $$"""{"Unit":{{unitInt}}}""";
 
             var quantity = DeserializeObject<Information>(json);
 
@@ -154,14 +119,22 @@ public void DecimalZeroQuantity_DeserializedFromUnitIntAndNoValue()
         }
 
         [Fact]
-        public void DecimalZeroBaseQuantity_DeserializedFromEmptyInput()
+        public void ZeroBaseQuantity_DeserializedFromEmptyInput()
         {
             var json = "{}";
 
-            var quantity = DeserializeObject<Information>(json);
+            var quantity = DeserializeObject<Mass>(json);
 
             Assert.Equal(0, quantity.Value);
-            Assert.Equal(Information.BaseUnit, quantity.Unit);
+            Assert.Equal(Mass.BaseUnit, quantity.Unit);
+        }
+
+        [Fact]
+        public void InterfaceObject_WithMissingKnownTypeInformation_ThrowsSerializationException()
+        {
+            var testObject = new TestInterfaceObject { Quantity = new Volume(1.2, VolumeUnit.Microliter) };
+
+            Assert.Throws<SerializationException>(() => SerializeObject(testObject));
         }
 
         #endregion
diff --git a/UnitsNet.Tests/Serialization/Json/DefaultDataContractJsonSerializerWithSurrogateProviderTests.cs b/UnitsNet.Tests/Serialization/Json/DefaultDataContractJsonSerializerWithSurrogateProviderTests.cs
new file mode 100644
index 0000000000..207a8047ce
--- /dev/null
+++ b/UnitsNet.Tests/Serialization/Json/DefaultDataContractJsonSerializerWithSurrogateProviderTests.cs
@@ -0,0 +1,177 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Json;
+using UnitsNet.Serialization;
+using UnitsNet.Units;
+
+namespace UnitsNet.Tests.Serialization.Json;
+
+/// <summary>
+///     These tests demonstrate the default behavior of the DataContractJsonSerializer when dealing with quantities
+///     <remarks>
+///         <para>Note that the produced schema is different from the one generated using the UnitsNet.Json package</para>
+///         <para>
+///             The default schema can easily be modified using a converter, a.k.a. DataContractSurrogate (.NET Framework)
+///         </para>
+///     </remarks>
+/// </summary>
+#pragma warning disable xUnit1000
+// these tests no longer pass due to the surrogate provider not being passed downstream:
+// https://github.com/dotnet/runtime/issues/100553
+internal class DefaultDataContractJsonSerializerWithSurrogateProviderTests : SerializationTestsBase<string>
+#pragma warning restore xUnit1000
+{
+    // I tried using the IXmlSerializable interface but that is also broken: the contract generation with the svcutil seems to only work with .NET Framework
+    // https://github.com/dotnet/wcf/issues/5638
+    // anyway, this is how the DataContractJsonSerializer formats an IXmlSerializable...
+    private const string OnePointTwoJson =
+        """
+        "<QuantityValue xmlns=\"http:\/\/schemas.datacontract.org\/2004\/07\/UnitsNet\"><N>12<\/N><D>10<\/D><\/QuantityValue>"
+        """;
+        
+    protected override string SerializeObject(object obj)
+    {
+        var serializer = new DataContractJsonSerializer(obj.GetType(), new DataContractJsonSerializerSettings(){SerializeReadOnlyTypes = true});
+#if NET
+        serializer.SetSerializationSurrogateProvider(QuantityValueSurrogateSerializationProvider.Instance); // this doesn't work as expected because of https://github.com/dotnet/runtime/issues/100553
+#else
+        // TODO in case the linked issue is fixed, we could consider providing the old surrogate types (netstandard doesn't support the same interface)
+#endif
+        using var stream = new MemoryStream();
+        serializer.WriteObject(stream, obj);
+        stream.Position = 0;
+        using var streamReader = new StreamReader(stream);
+        return streamReader.ReadToEnd();
+    }
+
+    protected override T DeserializeObject<T>(string json)
+    {
+        var serializer = new DataContractJsonSerializer(typeof(T));
+#if NET
+        serializer.SetSerializationSurrogateProvider(QuantityValueSurrogateSerializationProvider.Instance); // this doesn't work as expected because of https://github.com/dotnet/runtime/issues/100553
+#else
+        // TODO in case the linked issue is fixed, we could consider providing the old surrogate types (netstandard doesn't support the same interface)
+#endif
+        using var stream = new MemoryStream();
+        using var writer = new StreamWriter(stream);
+        writer.Write(json);
+        writer.Flush();
+        stream.Position = 0;
+        return (T)(serializer.ReadObject(stream) ?? throw new InvalidOperationException("Read 'null' from stream."));
+    }
+
+    #region Serialization tests
+
+    [Fact]
+    public void DoubleQuantity_SerializedWithDoubleValueAndunitInt()
+    {
+        var quantity = new Mass(1.20, MassUnit.Milligram);
+        var unitInt = (int)quantity.Unit;
+        var expectedJson = $$"""{"Value":"QuantityValue":{"N":"12","D":10"},"Unit":{{unitInt}}}""";
+
+        var json = SerializeObject(quantity);
+
+        Assert.Equal(expectedJson, json);
+    }
+
+    #endregion
+
+    #region Deserialization tests
+
+    [Fact]
+    public void DoubleQuantity_DeserializedFromXmlValueAndIntegerUnit()
+    {
+        var expectedUnit = MassUnit.Milligram;
+        var unitInt = (int)expectedUnit;
+        var json = $$"""{"Value":"QuantityValue":{"N":"12","D":10"},"Unit":{{unitInt}}}""";
+
+        var quantity = DeserializeObject<Mass>(json);
+
+        Assert.Equal(1.2m, quantity.Value);
+        Assert.Equal(expectedUnit, quantity.Unit);
+    }
+
+    [Fact]
+    public void DoubleZeroQuantity_DeserializedFromIntegerUnitAndNoValue()
+    {
+        var expectedUnit = MassUnit.Milligram;
+        var unitInt = (int)expectedUnit;
+        var json = $"{{\"Unit\":{unitInt}}}";
+
+        var quantity = DeserializeObject<Mass>(json);
+
+        Assert.Equal(0, quantity.Value);
+        Assert.Equal(expectedUnit, quantity.Unit);
+    }
+
+    [Fact]
+    public void InterfaceObject_IncludesTypeInformation()
+    {
+        var unit = InformationUnit.Exabyte;
+        var unitInt = (int)unit;
+        var testObject = new TestInterfaceObject { Quantity = new Information(1.2, unit) };
+        var expectedJson = $$$"""{"Quantity":{"__type":"Information:#UnitsNet","Value":"QuantityValue":{"N":"12","D":10"},"Unit":{{{unitInt}}}}}""";
+
+        var json = SerializeObject(testObject);
+
+        Assert.Equal(expectedJson, json);
+    }
+
+    [Fact]
+    public void DoubleBaseUnitQuantity_DeserializedFromXmlValueAndNoUnit()
+    {
+        var json = """{"Value":"QuantityValue":{"N":"12","D":10"}""";
+
+        var quantity = DeserializeObject<Mass>(json);
+
+        Assert.Equal(1.2m, quantity.Value);
+        Assert.Equal(Mass.BaseUnit, quantity.Unit);
+    }
+
+    [Fact]
+    public void DoubleZeroBaseQuantity_DeserializedFromEmptyInput()
+    {
+        var json = "{}";
+
+        var quantity = DeserializeObject<Mass>(json);
+
+        Assert.Equal(0, quantity.Value);
+        Assert.Equal(Mass.BaseUnit, quantity.Unit);
+    }
+
+    [Fact]
+    public void InterfaceObject_WithMissingKnownTypeInformation_ThrowsSerializationException()
+    {
+        var testObject = new TestInterfaceObject { Quantity = new Volume(1.2, VolumeUnit.Microliter) };
+
+        Assert.Throws<SerializationException>(() => SerializeObject(testObject));
+    }
+
+    [Fact]
+    public void DecimalZeroQuantity_DeserializedFromUnitIntAndNoValue()
+    {
+        var expectedUnit = InformationUnit.Exabyte;
+        var unitInt = (int)expectedUnit;
+        var json = $$"""{"Unit":{{unitInt}}}""";
+
+        var quantity = DeserializeObject<Information>(json);
+
+        Assert.Equal(0, quantity.Value);
+        Assert.Equal(expectedUnit, quantity.Unit);
+    }
+
+    [Fact]
+    public void DecimalZeroBaseQuantity_DeserializedFromEmptyInput()
+    {
+        var json = "{}";
+
+        var quantity = DeserializeObject<Information>(json);
+
+        Assert.Equal(0, quantity.Value);
+        Assert.Equal(Information.BaseUnit, quantity.Unit);
+    }
+
+    #endregion
+}
diff --git a/UnitsNet.Tests/Serialization/SerializationTestsBase.cs b/UnitsNet.Tests/Serialization/SerializationTestsBase.cs
index 4a8e99e772..f22493c771 100644
--- a/UnitsNet.Tests/Serialization/SerializationTestsBase.cs
+++ b/UnitsNet.Tests/Serialization/SerializationTestsBase.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -31,6 +31,8 @@ public abstract class SerializationTestsBase<TPayload>
         [InlineData(1.0)]
         [InlineData(0)]
         [InlineData(-1.0)]
+        [InlineData(1.2)]
+        [InlineData(-1.2)]
         [InlineData(1E+36)]
         [InlineData(1E-36)]
         [InlineData(-1E+36)]
diff --git a/UnitsNet.Tests/Serialization/TestInterfaceObject.cs b/UnitsNet.Tests/Serialization/TestInterfaceObject.cs
index f18965dd59..92d93b4033 100644
--- a/UnitsNet.Tests/Serialization/TestInterfaceObject.cs
+++ b/UnitsNet.Tests/Serialization/TestInterfaceObject.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Runtime.Serialization;
diff --git a/UnitsNet.Tests/Serialization/Xml/DataContractSerializerTests.cs b/UnitsNet.Tests/Serialization/Xml/DataContractSerializerTests.cs
index f37b32293c..22f3f59207 100644
--- a/UnitsNet.Tests/Serialization/Xml/DataContractSerializerTests.cs
+++ b/UnitsNet.Tests/Serialization/Xml/DataContractSerializerTests.cs
@@ -1,8 +1,5 @@
-using System;
-using System.IO;
 using System.Runtime.Serialization;
 using UnitsNet.Units;
-using Xunit;
 
 namespace UnitsNet.Tests.Serialization.Xml
 {
@@ -14,6 +11,8 @@ public class DataContractSerializerTests : SerializationTestsBase<string>
     {
         private const string XmlSchema = "xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\"";
         private const string Namespace = "xmlns=\"http://schemas.datacontract.org/2004/07/UnitsNet\"";
+        private const string NumericsNamespace = "\"http://schemas.datacontract.org/2004/07/System.Numerics\"";
+        private const string ArraysNamespace = "\"http://schemas.microsoft.com/2003/10/Serialization/Arrays\"";
 
         protected override string SerializeObject(object obj)
         {
@@ -37,23 +36,42 @@ protected override T DeserializeObject<T>(string xml)
         }
 
         [Fact]
-        public void DoubleQuantity_SerializedWithValueAndMemberName()
+        public void Quantity_SerializedWithValueAndMemberName()
         {
             var quantity = new Mass(1.20, MassUnit.Milligram);
-            var expectedXml = $"<Mass {Namespace} {XmlSchema}><Value>1.2</Value><Unit>Milligram</Unit></Mass>";
+            var numeratorFormat = $"<N xmlns:a={NumericsNamespace}><a:_bits i:nil=\"true\" xmlns:b={ArraysNamespace}/><a:_sign>12</a:_sign></N>";
+            var denominatorFormat = $"<D xmlns:a={NumericsNamespace}><a:_bits i:nil=\"true\" xmlns:b={ArraysNamespace}/><a:_sign>10</a:_sign></D>";
+            var expectedXml = $"<Mass {Namespace} {XmlSchema}><Value>{numeratorFormat}{denominatorFormat}</Value><Unit>Milligram</Unit></Mass>";
 
             var xml = SerializeObject(quantity);
 
             Assert.Equal(expectedXml, xml);
         }
 
+        [Fact]
+        public void IntegerQuantity_SerializedWithBothNumeratorAndDenominatorValueAndMemberName()
+        {
+            var quantity = new Mass(42, MassUnit.Milligram);
+            var numeratorFormat = $"<N xmlns:a={NumericsNamespace}><a:_bits i:nil=\"true\" xmlns:b={ArraysNamespace}/><a:_sign>42</a:_sign></N>";
+            var denominatorFormat = $"<D xmlns:a={NumericsNamespace}><a:_bits i:nil=\"true\" xmlns:b={ArraysNamespace}/><a:_sign>1</a:_sign></D>";
+            var expectedXml = $"<Mass {Namespace} {XmlSchema}><Value>{numeratorFormat}{denominatorFormat}</Value><Unit>Milligram</Unit></Mass>";
+            
+            var xml = SerializeObject(quantity);
+
+            Assert.Equal(expectedXml, xml);
+        }
+
         [Fact]
         public void InterfaceObject_IncludesTypeInformation()
         {
             var testObject = new TestInterfaceObject { Quantity = new Information(1.20, InformationUnit.Exabyte) };
 
             var quantityNamespace = "xmlns:a=\"http://schemas.datacontract.org/2004/07/UnitsNet\""; // there is an extra 'a' compared to Namespace
-            var expectedQuantityXml = $"<Quantity i:type=\"a:Information\" {quantityNamespace}><a:Value>1.2</a:Value><a:Unit>Exabyte</a:Unit></Quantity>";
+            
+            var numeratorFormat = "<a:N xmlns:b=\"http://schemas.datacontract.org/2004/07/System.Numerics\"><b:_bits i:nil=\"true\" xmlns:c=\"http://schemas.microsoft.com/2003/10/Serialization/Arrays\"/><b:_sign>12</b:_sign></a:N>";
+            var denominatorFormat = "<a:D xmlns:b=\"http://schemas.datacontract.org/2004/07/System.Numerics\"><b:_bits i:nil=\"true\" xmlns:c=\"http://schemas.microsoft.com/2003/10/Serialization/Arrays\"/><b:_sign>10</b:_sign></a:D>";
+            
+            var expectedQuantityXml = $"<Quantity i:type=\"a:Information\" {quantityNamespace}><a:Value>{numeratorFormat}{denominatorFormat}</a:Value><a:Unit>Exabyte</a:Unit></Quantity>";
             var expectedXml = $"<TestInterfaceObject xmlns=\"http://schemas.datacontract.org/2004/07/UnitsNet.Tests.Serialization\" {XmlSchema}>{expectedQuantityXml}</TestInterfaceObject>";
 
             var xml = SerializeObject(testObject);
diff --git a/UnitsNet.Tests/Serialization/Xml/DataContractSerializerWithSurrogateProviderTests.cs b/UnitsNet.Tests/Serialization/Xml/DataContractSerializerWithSurrogateProviderTests.cs
new file mode 100644
index 0000000000..c8fee791fb
--- /dev/null
+++ b/UnitsNet.Tests/Serialization/Xml/DataContractSerializerWithSurrogateProviderTests.cs
@@ -0,0 +1,86 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Runtime.Serialization;
+using UnitsNet.Serialization;
+using UnitsNet.Units;
+
+namespace UnitsNet.Tests.Serialization.Xml;
+
+/// <summary>
+///     These tests demonstrate the behavior of the DataContractSerializer (the default WCF serializer) + QuantityValueSurrogateSerializationProvider, when dealing with
+///     quantities.
+/// </summary>
+/// <remarks>Unlike the default serializer, here we store the BigInteger types as strings instead of "sign + bytes."</remarks>
+public class DataContractSerializerWithSurrogateProviderTests : SerializationTestsBase<string>
+{
+    private const string XmlSchema = "xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\"";
+    private const string Namespace = "xmlns=\"http://schemas.datacontract.org/2004/07/UnitsNet\"";
+
+    protected override string SerializeObject(object obj)
+    {
+        var serializer = new DataContractSerializer(obj.GetType());
+        serializer.SetSerializationSurrogateProvider(QuantityValueSurrogateSerializationProvider.Instance);
+        using var stream = new MemoryStream();
+        serializer.WriteObject(stream, obj);
+        stream.Position = 0;
+        using var streamReader = new StreamReader(stream);
+        return streamReader.ReadToEnd();
+    }
+
+    protected override T DeserializeObject<T>(string xml)
+    {
+        var serializer = new DataContractSerializer(typeof(T));
+        serializer.SetSerializationSurrogateProvider(QuantityValueSurrogateSerializationProvider.Instance);
+        using var stream = new MemoryStream();
+        using var writer = new StreamWriter(stream);
+        writer.Write(xml);
+        writer.Flush();
+        stream.Position = 0;
+        return (T)(serializer.ReadObject(stream) ?? throw new InvalidOperationException("Read 'null' from stream."));
+    }
+
+    [Fact]
+    public void DoubleQuantity_SerializedWithValueAndMemberName()
+    {
+        var quantity = new Mass(1.20, MassUnit.Milligram);
+        var expectedXml = $"<Mass {Namespace} {XmlSchema}><Value><N>12</N><D>10</D></Value><Unit>Milligram</Unit></Mass>";
+
+        var xml = SerializeObject(quantity);
+
+        Assert.Equal(expectedXml, xml);
+    }
+
+    [Fact]
+    public void IntegerQuantity_SerializedWithNumeratorOnlyValueAndMemberName()
+    {
+        var quantity = new Mass(42, MassUnit.Milligram);
+        var expectedXml = $"<Mass {Namespace} {XmlSchema}><Value><N>42</N></Value><Unit>Milligram</Unit></Mass>";
+
+        var xml = SerializeObject(quantity);
+
+        Assert.Equal(expectedXml, xml);
+    }
+
+    [Fact]
+    public void InterfaceObject_IncludesTypeInformation()
+    {
+        var testObject = new TestInterfaceObject { Quantity = new Information(1.20, InformationUnit.Exabyte) };
+
+        var quantityNamespace = "xmlns:a=\"http://schemas.datacontract.org/2004/07/UnitsNet\""; // there is an extra 'a' compared to Namespace
+        var expectedQuantityXml = $"<Quantity i:type=\"a:Information\" {quantityNamespace}><a:Value><a:N>12</a:N><a:D>10</a:D></a:Value><a:Unit>Exabyte</a:Unit></Quantity>";
+        var expectedXml = $"<TestInterfaceObject xmlns=\"http://schemas.datacontract.org/2004/07/UnitsNet.Tests.Serialization\" {XmlSchema}>{expectedQuantityXml}</TestInterfaceObject>";
+
+        var xml = SerializeObject(testObject);
+
+        Assert.Equal(expectedXml, xml);
+    }
+
+    [Fact]
+    public void InterfaceObject_WithMissingKnownTypeInformation_ThrowsSerializationException()
+    {
+        var testObject = new TestInterfaceObject { Quantity = new Volume(1.2, VolumeUnit.Microliter) };
+
+        Assert.Throws<SerializationException>(() => SerializeObject(testObject));
+    }
+}
diff --git a/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs b/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
index d029208eb4..fecac0d3c1 100644
--- a/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
+++ b/UnitsNet.Tests/UnitAbbreviationsCacheTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -48,6 +48,63 @@ public void CreateDefault_ReturnsAnAbbreviationCacheWithDefaultQuantityInfoLooku
             Assert.Equal("g", unitAbbreviationCache.GetUnitAbbreviations(MassUnit.Gram, AmericanCulture)[0]);
             Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.GetUnitAbbreviations(HowMuchUnit.Some));
         }
+        
+        [Fact]
+        public void CreateDefault_WithConfigureAction_ReturnsAnAbbreviationCacheWithNewQuantityInfoLookup()
+        {
+            var unitAbbreviationCache = UnitAbbreviationsCache.CreateDefault(configuration => configuration.WithAdditionalQuantities([HowMuch.Info]));
+
+            Assert.NotEqual(UnitsNetSetup.Default.Quantities, unitAbbreviationCache.Quantities);
+            Assert.Equal("g", unitAbbreviationCache.GetUnitAbbreviations(MassUnit.Gram, AmericanCulture)[0]);
+            Assert.Empty(unitAbbreviationCache.GetUnitAbbreviations(HowMuchUnit.Some, AmericanCulture));
+        }
+        
+        [Fact]
+        public void Create_WithQuantitiesAndConfigureAction_ReturnsAnAbbreviationCacheWithNewQuantityInfoLookup()
+        {
+            var unitAbbreviationCache = UnitAbbreviationsCache.Create([Mass.Info, HowMuch.Info],
+                configuration =>
+                    configuration.Configure(() => Mass.MassInfo.CreateDefault(mappings => mappings.SelectUnits(MassUnit.Kilogram, MassUnit.Gram))));
+
+            Assert.NotEqual(UnitsNetSetup.Default.Quantities, unitAbbreviationCache.Quantities);
+            Assert.Equal("g", unitAbbreviationCache.GetUnitAbbreviations(MassUnit.Gram, AmericanCulture)[0]);
+            Assert.Empty(unitAbbreviationCache.GetUnitAbbreviations(HowMuchUnit.Some, AmericanCulture));
+            Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.GetUnitAbbreviations(MassUnit.EarthMass));
+        }
+
+        [Fact]
+        public void CreateDefault_WithAdditionalQuantity_ReturnsCacheWithExtendedQuantityInfoLookup()
+        {
+            var unitAbbreviationCache = UnitAbbreviationsCache.CreateDefault(selector => selector.WithAdditionalQuantities([HowMuch.Info]));
+
+            Assert.NotEqual(UnitsNetSetup.Default.Quantities, unitAbbreviationCache.Quantities);
+            Assert.Equal("g", unitAbbreviationCache.GetUnitAbbreviations(MassUnit.Gram, AmericanCulture)[0]);
+            Assert.Empty(unitAbbreviationCache.GetUnitAbbreviations(HowMuchUnit.Some, AmericanCulture));
+        }
+
+        [Fact]
+        public void Create_WithBaseAndAdditionalQuantities_ReturnsConfiguredCache()
+        {
+            var unitAbbreviationCache = UnitAbbreviationsCache.Create([Mass.Info],
+                selector => selector.WithAdditionalQuantities([HowMuch.Info]));
+
+            Assert.Equal([Mass.Info, HowMuch.Info], unitAbbreviationCache.Quantities.Infos);
+            Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.GetUnitAbbreviations(LengthUnit.Meter));
+        }
+
+        [Fact]
+        public void FactoryMethods_WithNullArguments_ThrowArgumentNullException()
+        {
+            Assert.Multiple(checks:
+            [
+                () => Assert.Equal("configureQuantities",
+                    Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.CreateDefault(null!)).ParamName),
+                () => Assert.Equal("defaultQuantities",
+                    Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Create(null!, _ => { })).ParamName),
+                () => Assert.Equal("configureQuantities",
+                    Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Create([Mass.Info], null!)).ParamName)
+            ]);
+        }
 
         [Fact]
         public void UnitAbbreviationsCache_Default_ReturnsInstanceFromUnitsNetSetup()
@@ -81,13 +138,102 @@ public void GetUnitAbbreviationsReturnsTheExpectedAbbreviationWhenConstructedWit
             Assert.Equal("g", unitAbbreviationCache.GetUnitAbbreviations(MassUnit.Gram, AmericanCulture)[0]);
         }
 
+        [Fact]
+        public void UnitInfoOverloads_WithUnitOutsideConfiguredQuantities_ThrowUnitNotFoundException()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache([Mass.Info]);
+            UnitInfo lengthUnitInfo = Length.Info[LengthUnit.Meter];
+
+            Assert.Multiple(checks:
+            [
+                () => Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.GetUnitAbbreviations(lengthUnitInfo, AmericanCulture)),
+                () => Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.GetDefaultAbbreviation(lengthUnitInfo, AmericanCulture)),
+                () => Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.MapUnitToAbbreviation(lengthUnitInfo, AmericanCulture, "m")),
+                () => Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.MapUnitToDefaultAbbreviation(lengthUnitInfo, AmericanCulture, "m"))
+            ]);
+        }
+
+        [Fact]
+        public void GetDefaultAbbreviation_WithQuantityAndUnitNames_ReturnsTheExpectedAbbreviation()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache([Length.Info]);
+
+            string abbreviation = unitAbbreviationCache.GetDefaultAbbreviation("Length", "Millimeter", AmericanCulture);
+
+            Assert.Equal("mm", abbreviation);
+        }
+
+        [Fact]
+        public void GetUnitAbbreviations_WithQuantityAndUnitNames_ReturnsTheExpectedAbbreviations()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache([Area.Info]);
+
+            var abbreviations = unitAbbreviationCache.GetUnitAbbreviations("Area", "SquareMeter", AmericanCulture);
+
+            Assert.Contains("m²", abbreviations);
+        }
+
+        [Fact]
+        public void QuantityAndUnitNameOverloads_AreCaseInsensitive()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache([Length.Info]);
+
+            string abbreviation = unitAbbreviationCache.GetDefaultAbbreviation("length", "millimeter", AmericanCulture);
+
+            Assert.Equal("mm", abbreviation);
+        }
+
+        [Fact]
+        public void QuantityAndUnitNameOverloads_UseConfiguredQuantityLookup()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache([Mass.Info]);
+
+            Assert.Multiple(checks:
+            [
+                () => Assert.Equal("g", unitAbbreviationCache.GetDefaultAbbreviation("Mass", "Gram", AmericanCulture)),
+                () => Assert.Throws<QuantityNotFoundException>(() => unitAbbreviationCache.GetDefaultAbbreviation("Length", "Meter", AmericanCulture)),
+                () => Assert.Throws<QuantityNotFoundException>(() => unitAbbreviationCache.GetUnitAbbreviations("Length", "Meter", AmericanCulture))
+            ]);
+        }
+
+        [Fact]
+        public void QuantityAndUnitNameOverloads_WithInvalidNames_ThrowExpectedExceptions()
+        {
+            var unitAbbreviationCache = new UnitAbbreviationsCache([Length.Info]);
+
+            Assert.Multiple(checks:
+            [
+                () => Assert.Throws<QuantityNotFoundException>(() => unitAbbreviationCache.GetDefaultAbbreviation("InvalidQuantity", "Meter", AmericanCulture)),
+                () => Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.GetDefaultAbbreviation("Length", "InvalidUnit", AmericanCulture)),
+                () => Assert.Throws<QuantityNotFoundException>(() => unitAbbreviationCache.GetUnitAbbreviations("InvalidQuantity", "Meter", AmericanCulture)),
+                () => Assert.Throws<UnitNotFoundException>(() => unitAbbreviationCache.GetUnitAbbreviations("Length", "InvalidUnit", AmericanCulture))
+            ]);
+        }
+
+        [Fact]
+        public void QuantityAndUnitNameOverloads_WithNullNames_ThrowArgumentNullException()
+        {
+            Assert.Multiple(checks:
+            [
+                () => Assert.Equal("quantityName",
+                    Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.GetDefaultAbbreviation(null!, "Meter")).ParamName),
+                () => Assert.Equal("unitName",
+                    Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.GetDefaultAbbreviation("Length", null!)).ParamName),
+                () => Assert.Equal("quantityName",
+                    Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.GetUnitAbbreviations(null!, "Meter")).ParamName),
+                () => Assert.Equal("unitName",
+                    Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.GetUnitAbbreviations("Length", null!)).ParamName)
+            ]);
+        }
+
         [Fact]
         public void GetDefaultAbbreviationReturnsTheExpectedAbbreviationWhenConstructedWithTheSpecificQuantityInfo()
         {
             Assert.Multiple(checks:
             [
                 () => { Assert.Equal("g", new UnitAbbreviationsCache([Mass.Info]).GetDefaultAbbreviation(MassUnit.Gram, AmericanCulture)); },
-                () => { Assert.Equal("g", new UnitAbbreviationsCache([Mass.Info]).GetDefaultAbbreviation(typeof(MassUnit), (int)MassUnit.Gram, AmericanCulture)); }
+                () => { Assert.Equal("g", new UnitAbbreviationsCache([Mass.Info]).GetDefaultAbbreviation(typeof(MassUnit), (int)MassUnit.Gram, AmericanCulture)); },
+                () => { Assert.Equal("g", new UnitAbbreviationsCache([Mass.Info]).GetDefaultAbbreviation(Mass.Info[MassUnit.Gram])); }
             ]);
         }
 
@@ -133,6 +279,14 @@ public void GetDefaultAbbreviation_WithNullUnitType_ThrowsArgumentNullException(
             Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.GetDefaultAbbreviation(null!, 1));
         }
 
+        [Fact]
+        public void GetDefaultAbbreviation_WithNullUnitInfo_ThrowsArgumentNullException()
+        {
+            var result = Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.GetDefaultAbbreviation((UnitInfo)null!));
+
+            Assert.Equal("unitInfo", result.ParamName);
+        }
+
         [Fact]
         public void GetDefaultAbbreviationThrowsUnitNotFoundExceptionIfNoneExist()
         {
@@ -230,6 +384,14 @@ public void MapUnitToDefaultAbbreviation_GivenUnitTypeValueAndCulture_SetsDefaul
             Assert.Equal("m^2", cache.GetDefaultAbbreviation(AreaUnit.SquareMeter, AmericanCulture));
         }
 
+        [Fact]
+        public void MapUnitToDefaultAbbreviation_WithNullUnitInfo_ThrowsArgumentNullException()
+        {
+            var result = Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.MapUnitToDefaultAbbreviation((UnitInfo)null!, AmericanCulture, "x"));
+
+            Assert.Equal("unitInfo", result.ParamName);
+        }
+
         [Fact]
         public void MapUnitToDefaultAbbreviation_GivenCustomAbbreviation_SetsAbbreviationUsedByQuantityToString()
         {
@@ -253,6 +415,22 @@ public void MapUnitToAbbreviation_GivenUnitTypeAndValue_AddsTheAbbreviationForUn
             Assert.DoesNotContain("zz", cache.GetUnitAbbreviations(MassUnit.Gram, AmericanCulture));
         }
 
+        [Fact]
+        public void MapUnitToAbbreviation_WithNullUnitInfo_ThrowsArgumentNullException()
+        {
+            var result = Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.MapUnitToAbbreviation((UnitInfo)null!, AmericanCulture, "x"));
+
+            Assert.Equal("unitInfo", result.ParamName);
+        }
+
+        [Fact]
+        public void GetUnitAbbreviations_WithNullUnitInfo_ThrowsArgumentNullException()
+        {
+            var result = Assert.Throws<ArgumentNullException>(() => UnitAbbreviationsCache.Default.GetUnitAbbreviations((UnitInfo)null!, AmericanCulture));
+
+            Assert.Equal("unitInfo", result.ParamName);
+        }
+
         [Fact]
         public void MapUnitToAbbreviation_DoesNotInsertDuplicates()
         {
diff --git a/UnitsNet.Tests/UnitConversionsBuilderExtensionsTests.cs b/UnitsNet.Tests/UnitConversionsBuilderExtensionsTests.cs
new file mode 100644
index 0000000000..f6659f9b82
--- /dev/null
+++ b/UnitsNet.Tests/UnitConversionsBuilderExtensionsTests.cs
@@ -0,0 +1,464 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using Xunit;
+
+namespace UnitsNet.Tests;
+
+public class UnitConversionsBuilderExtensionsTests
+{
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void NoCaching_ReturnsNoConversions(bool reduceConstants)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+        Assert.Empty(quantities.GetUnitConversionFunctions(ConversionCachingMode.None, reduceConstants));
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void BaseOnlyCaching_ReturnsBaseUnitConversions(bool reduceConstants)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+        // 2 * (27 - 1) (Mass) + 2 * (54 - 1) (Volume) = 52 + 106 = 158 conversions (the Volume has the 3rd hightest number of units: (VolumeFlow, 75), (Density, 56))
+        // Quantity.Infos.Sum(info => 2 * (info.UnitInfos.Count - 1)) => 2880
+        var expectedNumberOfConversions = quantities.Sum(info => 2 * (info.UnitInfos.Count - 1));
+
+        var unitConversions = quantities.GetUnitConversionFunctions(ConversionCachingMode.BaseOnly, reduceConstants)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.Multiple(() => Assert.Equal(expectedNumberOfConversions, unitConversions.Count), () =>
+        {
+            Assert.All(quantities, quantity =>
+            {
+                UnitInfo baseUnit = quantity.BaseUnitInfo;
+                Assert.All(quantity.UnitInfos, fromUnit =>
+                {
+                    Assert.All(quantity.UnitInfos, toUnit =>
+                    {
+                        var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                        if ((fromUnit == baseUnit || toUnit == baseUnit) && fromUnit != toUnit)
+                        {
+                            QuantityValue valueToConvert = 123.45m;
+                            QuantityValue expectedValue = toUnit.GetValueFrom(valueToConvert, fromUnit);
+                            Assert.Contains(conversionKey, unitConversions);
+                            Assert.Equal(expectedValue, unitConversions[conversionKey](valueToConvert));
+                        }
+                        else
+                        {
+                            Assert.DoesNotContain(conversionKey, unitConversions);
+                        }
+                    });
+                });
+            });
+        });
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void AllCaching_ReturnsAllUnitConversions(bool reduceConstants)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+        // 27 * 26 (Mass) + 54 * 53 (Volume) = 702 + 2862 = 3564 conversions (the Volume has the 3rd hightest number of units: (VolumeFlow, 75), (Density, 56))
+        // Quantity.Infos.Sum(info => info.UnitInfos.Count * (info.UnitInfos.Count - 1)) =>	40114
+        var expectedNumberOfConversions = quantities.Sum(info => info.UnitInfos.Count * (info.UnitInfos.Count - 1));
+
+        var unitConversions = quantities.GetUnitConversionFunctions(ConversionCachingMode.All, reduceConstants)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.Multiple(() => Assert.Equal(expectedNumberOfConversions, unitConversions.Count), () =>
+        {
+            Assert.All(quantities, quantity =>
+            {
+                Assert.All(quantity.UnitInfos, fromUnit =>
+                {
+                    Assert.All(quantity.UnitInfos, toUnit =>
+                    {
+                        var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                        if (fromUnit != toUnit)
+                        {
+                            QuantityValue valueToConvert = 123.45m;
+                            QuantityValue expectedValue = toUnit.GetValueFrom(valueToConvert, fromUnit);
+                            Assert.Contains(conversionKey, unitConversions);
+                            Assert.Equal(expectedValue, unitConversions[conversionKey](valueToConvert));
+                        }
+                        else
+                        {
+                            Assert.DoesNotContain(conversionKey, unitConversions);
+                        }
+                    });
+                });
+            });
+        });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void AllCaching_WithSpecificNoneOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool volumeConstantsReduction)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+        var expectedNumberOfConversions = Mass.Info.UnitInfos.Count * (Mass.Info.UnitInfos.Count - 1);
+        var customQuantityOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Volume)] = new(ConversionCachingMode.None, volumeConstantsReduction) };
+        
+        var unitConversions = quantities.GetUnitConversionFunctions(ConversionCachingMode.All, defaultConstantsReduction, customQuantityOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.Multiple(() => Assert.Equal(expectedNumberOfConversions, unitConversions.Count),
+            () =>
+            {
+                Assert.All(Mass.Info.UnitInfos, fromUnit =>
+                {
+                    Assert.All(Mass.Info.UnitInfos, toUnit =>
+                    {
+                        var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                        if (fromUnit != toUnit)
+                        {
+                            QuantityValue valueToConvert = 123.45m;
+                            QuantityValue expectedValue = toUnit.GetValueFrom(valueToConvert, fromUnit);
+                            Assert.Contains(conversionKey, unitConversions);
+                            Assert.Equal(expectedValue, unitConversions[conversionKey](valueToConvert));
+                        }
+                        else
+                        {
+                            Assert.DoesNotContain(conversionKey, unitConversions);
+                        }
+                    });
+                });
+            },
+            () =>
+            {
+                Assert.All(Volume.Info.UnitInfos,
+                    fromUnit =>
+                    {
+                        Assert.All(Volume.Info.UnitInfos,
+                            toUnit => { Assert.DoesNotContain(UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey), unitConversions); });
+                    });
+            });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void AllCaching_WithSpecificBaseOnlyOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool volumeConstantsReduction)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+        var expectedNumberOfConversions = Mass.Info.UnitInfos.Count * (Mass.Info.UnitInfos.Count - 1) + 2 * (Volume.Info.UnitInfos.Count - 1);
+        var customQuantityOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Volume)] = new(ConversionCachingMode.BaseOnly, volumeConstantsReduction) };
+        
+        var unitConversions = quantities.GetUnitConversionFunctions(ConversionCachingMode.All, defaultConstantsReduction, customQuantityOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.Multiple(() => Assert.Equal(expectedNumberOfConversions, unitConversions.Count),
+            () =>
+            {
+                Assert.All(Mass.Info.UnitInfos, fromUnit =>
+                {
+                    Assert.All(Mass.Info.UnitInfos, toUnit =>
+                    {
+                        var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                        if (fromUnit != toUnit)
+                        {
+                            QuantityValue valueToConvert = 123.45m;
+                            QuantityValue expectedValue = toUnit.GetValueFrom(valueToConvert, fromUnit);
+                            Assert.Contains(conversionKey, unitConversions);
+                            Assert.Equal(expectedValue, unitConversions[conversionKey](valueToConvert));
+                        }
+                        else
+                        {
+                            Assert.DoesNotContain(conversionKey, unitConversions);
+                        }
+                    });
+                });
+            },
+            () =>
+            {
+                Assert.All(Volume.Info.UnitInfos, fromUnit =>
+                {
+                    UnitInfo baseUnit = Volume.Info.BaseUnitInfo;
+                    Assert.All(Volume.Info.UnitInfos, toUnit =>
+                    {
+                        var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                        if ((fromUnit == baseUnit || toUnit == baseUnit) && fromUnit != toUnit)
+                        {
+                            QuantityValue valueToConvert = 123.45m;
+                            QuantityValue expectedValue = toUnit.GetValueFrom(valueToConvert, fromUnit);
+                            Assert.Contains(conversionKey, unitConversions);
+                            Assert.Equal(expectedValue, unitConversions[conversionKey](valueToConvert));
+                        }
+                        else
+                        {
+                            Assert.DoesNotContain(conversionKey, unitConversions);
+                        }
+                    });
+                });
+            });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void BaseOnlyCaching_WithSpecificAllOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool volumeConstantsReduction)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+        var expectedNumberOfConversions = Mass.Info.UnitInfos.Count * (Mass.Info.UnitInfos.Count - 1) + 2 * (Volume.Info.UnitInfos.Count - 1);
+        var customQuantityOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Mass)] = new(ConversionCachingMode.All, volumeConstantsReduction) };
+        
+        var unitConversions = quantities.GetUnitConversionFunctions(ConversionCachingMode.BaseOnly, defaultConstantsReduction, customQuantityOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.Multiple(() => Assert.Equal(expectedNumberOfConversions, unitConversions.Count),
+            () =>
+            {
+                Assert.All(Mass.Info.UnitInfos, fromUnit =>
+                {
+                    Assert.All(Mass.Info.UnitInfos, toUnit =>
+                    {
+                        var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                        if (fromUnit != toUnit)
+                        {
+                            QuantityValue valueToConvert = 123.45m;
+                            QuantityValue expectedValue = toUnit.GetValueFrom(valueToConvert, fromUnit);
+                            Assert.Contains(conversionKey, unitConversions);
+                            Assert.Equal(expectedValue, unitConversions[conversionKey](valueToConvert));
+                        }
+                        else
+                        {
+                            Assert.DoesNotContain(conversionKey, unitConversions);
+                        }
+                    });
+                });
+            }, () =>
+            {
+                Assert.All(Volume.Info.UnitInfos, fromUnit =>
+                {
+                    UnitInfo baseUnit = Volume.Info.BaseUnitInfo;
+                    Assert.All(Volume.Info.UnitInfos, toUnit =>
+                    {
+                        var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                        if ((fromUnit == baseUnit || toUnit == baseUnit) && fromUnit != toUnit)
+                        {
+                            QuantityValue valueToConvert = 123.45m;
+                            QuantityValue expectedValue = toUnit.GetValueFrom(valueToConvert, fromUnit);
+                            Assert.Contains(conversionKey, unitConversions);
+                            Assert.Equal(expectedValue, unitConversions[conversionKey](valueToConvert));
+                        }
+                        else
+                        {
+                            Assert.DoesNotContain(conversionKey, unitConversions);
+                        }
+                    });
+                });
+            });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void BaseOnlyCaching_WithSpecificNoneOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool volumeConstantsReduction)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+        var expectedNumberOfConversions = 2 * (Volume.Info.UnitInfos.Count - 1);
+        var customQuantityOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Mass)] = new(ConversionCachingMode.None, volumeConstantsReduction) };
+
+        var unitConversions = quantities.GetUnitConversionFunctions(ConversionCachingMode.BaseOnly, defaultConstantsReduction, customQuantityOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.Multiple(() => Assert.Equal(expectedNumberOfConversions, unitConversions.Count), () =>
+        {
+            Assert.All(Mass.Info.UnitInfos,
+                fromUnit =>
+                {
+                    Assert.All(Mass.Info.UnitInfos,
+                        toUnit => { Assert.DoesNotContain(UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey), unitConversions); });
+                });
+        }, () =>
+        {
+            Assert.All(Volume.Info.UnitInfos, fromUnit =>
+            {
+                UnitInfo baseUnit = Volume.Info.BaseUnitInfo;
+                Assert.All(Volume.Info.UnitInfos, toUnit =>
+                {
+                    var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                    if ((fromUnit == baseUnit || toUnit == baseUnit) && fromUnit != toUnit)
+                    {
+                        QuantityValue valueToConvert = 123.45m;
+                        QuantityValue expectedValue = toUnit.GetValueFrom(valueToConvert, fromUnit);
+                        Assert.Contains(conversionKey, unitConversions);
+                        Assert.Equal(expectedValue, unitConversions[conversionKey](valueToConvert));
+                    }
+                    else
+                    {
+                        Assert.DoesNotContain(conversionKey, unitConversions);
+                    }
+                });
+            });
+        });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void NoCaching_WithSpecificAllOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool volumeConstantsReduction)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+        var expectedNumberOfConversions = Volume.Info.UnitInfos.Count * (Volume.Info.UnitInfos.Count - 1);
+        var customQuantityOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Volume)] = new(ConversionCachingMode.All, volumeConstantsReduction) };
+        
+        var unitConversions = quantities.GetUnitConversionFunctions(ConversionCachingMode.None, defaultConstantsReduction, customQuantityOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.Multiple(() => Assert.Equal(expectedNumberOfConversions, unitConversions.Count),
+            () =>
+        {
+            Assert.All(Mass.Info.UnitInfos, fromUnit =>
+            {
+                Assert.All(Mass.Info.UnitInfos, toUnit =>
+                {
+                    var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                    Assert.DoesNotContain(conversionKey, unitConversions);
+                });
+            });
+        }, () =>
+        {
+            Assert.All(Volume.Info.UnitInfos, fromUnit =>
+            {
+                Assert.All(Volume.Info.UnitInfos, toUnit =>
+                {
+                    var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                    if (fromUnit != toUnit)
+                    {
+                        QuantityValue valueToConvert = 123.45m;
+                        QuantityValue expectedValue = toUnit.GetValueFrom(valueToConvert, fromUnit);
+                        Assert.Contains(conversionKey, unitConversions);
+                        Assert.Equal(expectedValue, unitConversions[conversionKey](valueToConvert));
+                    }
+                    else
+                    {
+                        Assert.DoesNotContain(conversionKey, unitConversions);
+                    }
+                });
+            });
+        });
+    }
+
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void NoCaching_WithSpecificBaseOnlyOptions_ReturnsSpecifiedUnitConversions(bool defaultConstantsReduction,
+        bool volumeConstantsReduction)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+        var expectedNumberOfConversions = 2 * (Volume.Info.UnitInfos.Count - 1);
+        var customQuantityOptions =
+            new Dictionary<Type, ConversionCacheOptions> { [typeof(Volume)] = new(ConversionCachingMode.BaseOnly, volumeConstantsReduction) };
+
+        var unitConversions = quantities.GetUnitConversionFunctions(ConversionCachingMode.None, defaultConstantsReduction, customQuantityOptions)
+            .ToDictionary(pair => pair.Key, pair => pair.Value);
+
+        Assert.Multiple(() => Assert.Equal(expectedNumberOfConversions, unitConversions.Count), () =>
+        {
+            Assert.All(Mass.Info.UnitInfos, fromUnit =>
+            {
+                Assert.All(Mass.Info.UnitInfos, toUnit =>
+                {
+                    var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                    Assert.DoesNotContain(conversionKey, unitConversions);
+                });
+            });
+        }, () =>
+        {
+            Assert.All(Volume.Info.UnitInfos, fromUnit =>
+            {
+                UnitInfo baseUnit = Volume.Info.BaseUnitInfo;
+                Assert.All(Volume.Info.UnitInfos, toUnit =>
+                {
+                    var conversionKey = UnitConversionKey.Create(fromUnit.UnitKey, toUnit.UnitKey);
+                    if ((fromUnit == baseUnit || toUnit == baseUnit) && fromUnit != toUnit)
+                    {
+                        QuantityValue valueToConvert = 123.45m;
+                        QuantityValue expectedValue = toUnit.GetValueFrom(valueToConvert, fromUnit);
+                        Assert.Contains(conversionKey, unitConversions);
+                        Assert.Equal(expectedValue, unitConversions[conversionKey](valueToConvert));
+                    }
+                    else
+                    {
+                        Assert.DoesNotContain(conversionKey, unitConversions);
+                    }
+                });
+            });
+        });
+    }
+    
+    [Theory]
+    [InlineData(ConversionCachingMode.All, true)]
+    [InlineData(ConversionCachingMode.BaseOnly, true)]
+    [InlineData(ConversionCachingMode.BaseOnly, false)] // the conversions from/to the base units are already reduced by the CodeGen
+    public void ReduceConstants_ReturnsUnitConversionsWithReducedCoefficients(ConversionCachingMode cachingMode, bool reduceConstants)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+
+        IEnumerable<ConvertValueDelegate> unitConversions = quantities.GetUnitConversionFunctions(cachingMode, reduceConstants).Select(pair => pair.Value);
+
+        Assert.All(unitConversions, valueDelegate => Assert.True(IsReduced(valueDelegate(QuantityValue.One))));
+    }
+
+    private static bool IsReduced(QuantityValue value)
+    {
+        (BigInteger numerator, BigInteger denominator) = value;
+        return BigInteger.GreatestCommonDivisor(numerator, denominator) == BigInteger.One;
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void GetUnitConversionFunctions_WithInvalidCachingMode_ThrowsArgumentException(bool reduceConstants)
+    {
+        var quantities = new QuantityInfo[] { Mass.Info, Volume.Info };
+        const ConversionCachingMode invalidCachingMode = (ConversionCachingMode)(-1);
+        Assert.Multiple(() =>
+                Assert.Throws<ArgumentOutOfRangeException>(() => quantities.GetUnitConversionFunctions(invalidCachingMode, reduceConstants)),
+            () =>
+            {
+                var emptyOptions = new Dictionary<Type, ConversionCacheOptions>();
+                Assert.Throws<ArgumentOutOfRangeException>(() => quantities.GetUnitConversionFunctions(invalidCachingMode, reduceConstants, emptyOptions)
+                    .ToList());
+            },
+            () =>
+            {
+                var validOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Mass)] = new() };
+                Assert.Throws<ArgumentOutOfRangeException>(() => quantities.GetUnitConversionFunctions(invalidCachingMode, reduceConstants, validOptions)
+                    .ToList());
+            },
+            () =>
+            {
+                var invalidOptions = new Dictionary<Type, ConversionCacheOptions> { [typeof(Mass)] = new(invalidCachingMode) };
+                Assert.Throws<ArgumentOutOfRangeException>(() => quantities.GetUnitConversionFunctions(default, reduceConstants, invalidOptions)
+                    .ToList());
+            });
+    }
+}
diff --git a/UnitsNet.Tests/UnitConverterTest.cs b/UnitsNet.Tests/UnitConverterTest.cs
index 17ffdb2305..ea058651ff 100644
--- a/UnitsNet.Tests/UnitConverterTest.cs
+++ b/UnitsNet.Tests/UnitConverterTest.cs
@@ -1,7 +1,10 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
+using System;
+using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
 using UnitsNet.Tests.CustomQuantities;
 using UnitsNet.Units;
 using Xunit;
@@ -10,117 +13,699 @@ namespace UnitsNet.Tests
 {
     public class UnitConverterTest
     {
-        [Fact]
-        public void CopyConstructorCopiesCoversionFunctions()
+        /// <summary>
+        ///     Generates a collection of <see cref="QuantityConverterBuildOptions" /> instances with all combinations of
+        ///     constructor parameter values.
+        /// </summary>
+        /// <returns>
+        ///     An <see cref="IEnumerable{T}" /> of <see cref="QuantityConverterBuildOptions" /> containing all possible
+        ///     configurations
+        ///     of freezing, caching modes, and constant reduction options.
+        /// </returns>
+        private static IEnumerable<QuantityConverterBuildOptions> GetQuantityConverterBuildOptions()
+        {
+            bool[] frozenOptions = [true, false];
+            ConversionCachingMode[] cachingOptions = [ConversionCachingMode.None, ConversionCachingMode.BaseOnly, ConversionCachingMode.All];
+            bool[] reductionOptions = [true, false];
+            return frozenOptions.SelectMany(freeze => cachingOptions.SelectMany(cachingMode => reductionOptions.Select(reduce =>
+                new QuantityConverterBuildOptions(freeze, cachingMode, reduce))));
+        }
+
+        /// <summary>
+        ///     Gets the test data for the unit converter tests.
+        /// </summary>
+        /// <value>
+        ///     A collection of tuples containing:
+        ///     <list type="bullet">
+        ///         <item>
+        ///             <description>A <see cref="bool" /> indicating whether to freeze the conversion.</description>
+        ///         </item>
+        ///         <item>
+        ///             <description>A <see cref="ConversionCachingMode" /> specifying the caching mode.</description>
+        ///         </item>
+        ///         <item>
+        ///             <description>A <see cref="bool" /> indicating whether to reduce constants.</description>
+        ///         </item>
+        ///     </list>
+        /// </value>
+        public static TheoryData<bool, ConversionCachingMode, bool> ConverterTestOptions =>
+            new()
+            {
+                { true, ConversionCachingMode.None, true },
+                { true, ConversionCachingMode.BaseOnly, true },
+                { true, ConversionCachingMode.All, true },
+                { false, ConversionCachingMode.None, true },
+                { false, ConversionCachingMode.BaseOnly, true },
+                { false, ConversionCachingMode.All, true },
+                { true, ConversionCachingMode.None, false },
+                { true, ConversionCachingMode.BaseOnly, false },
+                { true, ConversionCachingMode.All, false },
+                { false, ConversionCachingMode.None, false },
+                { false, ConversionCachingMode.BaseOnly, false },
+                { false, ConversionCachingMode.All, false }
+            };
+        
+        // [Fact]
+        // public void CopyConstructorCopiesCoversionFunctions()
+        // {
+        //     Length ConversionFunction(Length from) => Length.FromInches(18);
+        //
+        //     var unitConverter = new UnitConverter();
+        //     unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch, ConversionFunction);
+        //
+        //     var copiedUnitConverter = new UnitConverter(unitConverter);
+        //     var foundConversionFunction = copiedUnitConverter.GetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch);
+        //     Assert.NotNull(foundConversionFunction);
+        // }
+
+        // [Fact]
+        // public void CustomConversionWithSameQuantityType()
+        // {
+        //     Length ConversionFunction(Length from) => Length.FromInches(18);
+        //
+        //     var unitConverter = new UnitConverter();
+        //     unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch, ConversionFunction);
+        //
+        //     var foundConversionFunction = unitConverter.GetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch);
+        //     var converted = foundConversionFunction(Length.FromMeters(1.0));
+        //
+        //     Assert.Equal(Length.FromInches(18), converted);
+        // }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void GetConversionFunction_WithSameQuantityType(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
         {
-            Length ConversionFunction(Length from) => Length.FromInches(18);
+            var unitParser = new UnitParser([Length.Info]);
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var unitConverter = UnitConverter.Create(unitParser, convertOptions);
+
+            Assert.Multiple(() =>
+            {
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(LengthUnit.Meter, LengthUnit.Meter);
+                QuantityValue converted = conversionFunction(1);
+
+                Assert.Equal(1, converted);
+            }, () =>
+            {
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(LengthUnit.Centimeter, LengthUnit.Meter);
+                QuantityValue converted = conversionFunction(10);
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch, ConversionFunction);
+                Assert.Equal(0.1m, converted);
+            }, () =>
+            {
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(LengthUnit.Meter, LengthUnit.Centimeter);
+                QuantityValue converted = conversionFunction(1);
 
-            var copiedUnitConverter = new UnitConverter(unitConverter);
-            var foundConversionFunction = copiedUnitConverter.GetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch);
-            Assert.NotNull(foundConversionFunction);
+                Assert.Equal(100, converted);
+            }, () =>
+            {
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(LengthUnit.Millimeter, LengthUnit.Centimeter);
+                QuantityValue converted = conversionFunction(10);
+
+                Assert.Equal(1, converted);
+            }, () =>
+            {
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(LengthUnit.Inch, LengthUnit.Inch);
+                QuantityValue converted = conversionFunction(1);
+
+                Assert.Equal(1, converted);
+            });
         }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryGetConversionFunction_WithSameQuantityType_ReturnsTrue(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var unitParser = new UnitParser([Length.Info]);
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var unitConverter = UnitConverter.Create(unitParser, convertOptions);
 
-        [Fact]
-        public void CustomConversionWithSameQuantityType()
+            Assert.Multiple(() =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Meter, LengthUnit.Meter, out ConvertValueDelegate? conversionFunction);
+                Assert.True(success);
+                Assert.Equal(1, conversionFunction!(1));
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Centimeter, LengthUnit.Meter, out ConvertValueDelegate? conversionFunction);
+                Assert.True(success);
+                Assert.Equal(0.1m, conversionFunction!(10));
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Meter, LengthUnit.Centimeter, out ConvertValueDelegate? conversionFunction);
+                Assert.True(success);
+                Assert.Equal(100, conversionFunction!(1));
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Millimeter, LengthUnit.Centimeter, out ConvertValueDelegate? conversionFunction);
+                Assert.True(success);
+                Assert.Equal(1, conversionFunction!(10));
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Inch, LengthUnit.Inch, out ConvertValueDelegate? conversionFunction);
+                Assert.True(success);
+                Assert.Equal(1, conversionFunction!(1));
+            });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void GetConversionFunction_WithCustomUnitConversion(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
         {
-            Length ConversionFunction(Length from) => Length.FromInches(18);
+            var customLengthInfo = Length.LengthInfo.CreateDefault(unitDefinitions =>
+                unitDefinitions.Configure(LengthUnit.Inch, definition => definition.WithConversionFactorFromBase(18)));
+
+            var unitParser = new UnitParser([customLengthInfo]);
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var unitConverter = UnitConverter.Create(unitParser, convertOptions);
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch, ConversionFunction);
+            Assert.Multiple(() =>
+            {
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(LengthUnit.Meter, LengthUnit.Inch);
+                QuantityValue converted = conversionFunction(1);
 
-            var foundConversionFunction = unitConverter.GetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch);
-            var converted = foundConversionFunction(Length.FromMeters(1.0));
+                Assert.Equal(18, converted);
+            }, () =>
+            {
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(LengthUnit.Inch, LengthUnit.Meter);
+                QuantityValue converted = conversionFunction(18);
 
-            Assert.Equal(Length.FromInches(18), converted);
+                Assert.Equal(1, converted);
+            }, () =>
+            {
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(LengthUnit.Meter, LengthUnit.Meter);
+                QuantityValue converted = conversionFunction(18);
+
+                Assert.Equal(18, converted);
+            }, () =>
+            {
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(LengthUnit.Inch, LengthUnit.Inch);
+                QuantityValue converted = conversionFunction(18);
+
+                Assert.Equal(18, converted);
+            }, () =>
+            {
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(LengthUnit.Meter, LengthUnit.Centimeter);
+                QuantityValue converted = conversionFunction(18);
+
+                Assert.Equal(1800, converted);
+            });
         }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryGetConversionFunction_WithCustomUnitConversion_ReturnsTrue(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var customLengthInfo = Length.LengthInfo.CreateDefault(unitDefinitions =>
+                unitDefinitions.Configure(LengthUnit.Inch, definition => definition.WithConversionFactorFromBase(18)));
 
-        [Fact]
-        public void CustomConversionWithSameQuantityTypeByTypeParam()
+            var unitParser = new UnitParser([customLengthInfo]);
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var unitConverter = UnitConverter.Create(unitParser, convertOptions);
+
+            Assert.Multiple(() =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, out ConvertValueDelegate? conversionFunction);
+                Assert.True(success);
+                Assert.Equal(18, conversionFunction!(1));
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Inch, LengthUnit.Meter, out ConvertValueDelegate? conversionFunction);
+                Assert.True(success);
+                Assert.Equal(1, conversionFunction!(18));
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Meter, LengthUnit.Meter, out ConvertValueDelegate? conversionFunction);
+                Assert.True(success);
+                Assert.Equal(18, conversionFunction!(18));
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Inch, LengthUnit.Inch, out ConvertValueDelegate? conversionFunction);
+                Assert.True(success);
+                Assert.Equal(18, conversionFunction!(18));
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Meter, LengthUnit.Centimeter, out ConvertValueDelegate? conversionFunction);
+                Assert.True(success);
+                Assert.Equal(1800, conversionFunction!(18));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_WithCustomBuiltInUnitDefinition_UsesConfiguredConversion(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
         {
-            Length ConversionFunction(Length from) => Length.FromInches(18);
+            var customPressureInfo = Pressure.PressureInfo.CreateDefault(unitDefinitions =>
+                unitDefinitions.Configure(PressureUnit.InchOfWaterColumn, definition => definition.WithConversionFactorFromBase(999)));
+
+            var unitParser = new UnitParser([customPressureInfo]);
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var unitConverter = UnitConverter.Create(unitParser, convertOptions);
+
+            var pressure = Pressure.FromPascals(1);
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction(LengthUnit.Meter, LengthUnit.Inch, (ConversionFunction<Length>) ConversionFunction);
+            Assert.Multiple(() =>
+            {
+                QuantityValue convertedValue = unitConverter.ConvertValue(1, PressureUnit.Pascal, PressureUnit.InchOfWaterColumn);
 
-            var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Length), LengthUnit.Meter, typeof(Length), LengthUnit.Inch);
-            var converted = foundConversionFunction(Length.FromMeters(1.0));
+                Assert.Equal(999, convertedValue);
+            }, () =>
+            {
+                QuantityValue convertedValue = unitConverter.ConvertValue(999, PressureUnit.InchOfWaterColumn, PressureUnit.Pascal);
 
-            Assert.Equal(Length.FromInches(18), converted);
+                Assert.Equal(1, convertedValue);
+            }, () =>
+            {
+                QuantityValue convertedValue = pressure.As(PressureUnit.InchOfWaterColumn, unitConverter);
+
+                Assert.Equal(999, convertedValue);
+            }, () =>
+            {
+                var convertedQuantity = pressure.ToUnit(PressureUnit.InchOfWaterColumn, unitConverter);
+
+                Assert.Equal(999, convertedQuantity.Value);
+            });
         }
+        
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void GetConversionFunction_WithUnknownUnit_ThrowsUnitNotFoundException(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var unitParser = new UnitParser([Length.Info, Mass.Info]);
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var unitConverter = UnitConverter.Create(unitParser, convertOptions);
 
-        [Fact]
-        public void CustomConversionWithDifferentQuantityTypes()
+            Assert.Multiple(() =>
+                {
+                    Assert.Throws<UnitNotFoundException>(() => unitConverter.GetConversionFunction(LengthUnit.Meter, (LengthUnit)(-1)));
+                },
+                () =>
+                {
+                    Assert.Throws<UnitNotFoundException>(() => unitConverter.GetConversionFunction((LengthUnit)(-1), LengthUnit.Meter));
+                },
+                () =>
+                {
+                    Assert.Throws<UnitNotFoundException>(() => unitConverter.GetConversionFunction(MassUnit.Kilogram, (LengthUnit)(-1)));
+                },
+                () =>
+                {
+                    Assert.Throws<UnitNotFoundException>(() => unitConverter.GetConversionFunction((LengthUnit)(-1), MassUnit.Kilogram));
+                },
+                () =>
+                {
+                    Assert.Throws<UnitNotFoundException>(() => unitConverter.GetConversionFunction(VolumeUnit.Milliliter, (LengthUnit)(-1)));
+                },
+                () =>
+                {
+                    Assert.Throws<UnitNotFoundException>(() => unitConverter.GetConversionFunction((LengthUnit)(-1), VolumeUnit.Milliliter));
+                });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryGetConversionFunction_WithUnknownUnit_ReturnsFalse(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
         {
-            IQuantity ConversionFunction(IQuantity from) => Length.FromInches(18);
+            var unitParser = new UnitParser([Length.Info, Mass.Info]);
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var unitConverter = UnitConverter.Create(unitParser, convertOptions);
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch, ConversionFunction);
+            Assert.Multiple(() =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Meter, (LengthUnit)(-1), out ConvertValueDelegate? conversionFunction);
+                Assert.False(success);
+                Assert.Null(conversionFunction);
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction((LengthUnit)(-1), LengthUnit.Meter, out ConvertValueDelegate? conversionFunction);
+                Assert.False(success);
+                Assert.Null(conversionFunction);
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(MassUnit.Kilogram, (LengthUnit)(-1), out ConvertValueDelegate? conversionFunction);
+                Assert.False(success);
+                Assert.Null(conversionFunction);
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction((LengthUnit)(-1), MassUnit.Kilogram, out ConvertValueDelegate? conversionFunction);
+                Assert.False(success);
+                Assert.Null(conversionFunction);
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(VolumeUnit.Milliliter, (LengthUnit)(-1), out ConvertValueDelegate? conversionFunction);
+                Assert.False(success);
+                Assert.Null(conversionFunction);
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction((LengthUnit)(-1), VolumeUnit.Milliliter, out ConvertValueDelegate? conversionFunction);
+                Assert.False(success);
+                Assert.Null(conversionFunction);
+            });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void GetConversionFunction_WithIncompatibleQuantities_ThrowsInvalidConversionException(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var unitParser = new UnitParser([Length.Info, Mass.Info]);
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var unitConverter = UnitConverter.Create(unitParser, convertOptions);
 
-            var foundConversionFunction = unitConverter.GetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch);
-            var converted = foundConversionFunction(Mass.FromGrains(100));
+            Assert.Multiple(() =>
+                {
+                    Assert.Throws<InvalidConversionException>(() => unitConverter.GetConversionFunction(LengthUnit.Meter, MassUnit.Kilogram));
+                },
+                () =>
+                {
+                    Assert.Throws<InvalidConversionException>(() => unitConverter.GetConversionFunction(MassUnit.Kilogram, LengthUnit.Meter));
+                });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryGetConversionFunction_WithInvalidUnit_ReturnsFalse(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var unitParser = new UnitParser([Length.Info, Mass.Info]);
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var unitConverter = UnitConverter.Create(unitParser, convertOptions);
 
-            Assert.Equal(Length.FromInches(18), converted);
+            Assert.Multiple(() =>
+            {
+                var success = unitConverter.TryGetConversionFunction(LengthUnit.Meter, MassUnit.Kilogram, out ConvertValueDelegate? conversionFunction);
+                Assert.False(success);
+                Assert.Null(conversionFunction);
+            }, () =>
+            {
+                var success = unitConverter.TryGetConversionFunction(MassUnit.Kilogram, LengthUnit.Meter, out ConvertValueDelegate? conversionFunction);
+                Assert.False(success);
+                Assert.Null(conversionFunction);
+            });
         }
+        
+        [Theory]
+        [InlineData(1, LengthUnit.Meter, ReciprocalLengthUnit.InverseMeter, 1)]
+        [InlineData(1, LengthUnit.Centimeter, ReciprocalLengthUnit.InverseCentimeter, 1)]
+        [InlineData(1, LengthUnit.Centimeter, ReciprocalLengthUnit.InverseMillimeter, 0.1)]
+        [InlineData(1, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, 10)]
+        [InlineData(10, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, 1)]
+        [InlineData(-10, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, -1)]
+        [InlineData(0, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, double.PositiveInfinity)]
+        [InlineData(double.PositiveInfinity, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, 0)]
+        [InlineData(double.NegativeInfinity, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, 0)]
+        [InlineData(double.NaN, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, double.NaN)]
+        public void GetConversionFunction_WithCompatibleQuantityType(double fromValue, LengthUnit fromUnit, ReciprocalLengthUnit toUnit, double expected)
+        {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            IEnumerable<QuantityConverterBuildOptions> converterOptions = GetQuantityConverterBuildOptions();
 
-        [Fact]
-        public void CustomConversionWithDifferentQuantityTypesByTypeParam()
+            Assert.All(converterOptions, options =>
+            {
+                var unitConverter = UnitConverter.Create(new UnitParser([Length.Info, ReciprocalLength.Info]), options);
+
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(fromUnit, toUnit);
+                QuantityValue converted = conversionFunction(fromValue);
+
+                Assert.Equal(expectedValue, converted);
+            });
+        }
+        
+        [Theory]
+        [InlineData(1, LengthUnit.Meter, ReciprocalLengthUnit.InverseMeter, 1)]
+        [InlineData(1, LengthUnit.Centimeter, ReciprocalLengthUnit.InverseCentimeter, 1)]
+        [InlineData(1, LengthUnit.Centimeter, ReciprocalLengthUnit.InverseMillimeter, 0.1)]
+        [InlineData(1, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, 10)]
+        [InlineData(10, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, 1)]
+        [InlineData(-10, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, -1)]
+        [InlineData(0, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, double.PositiveInfinity)]
+        [InlineData(double.PositiveInfinity, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, 0)]
+        [InlineData(double.NegativeInfinity, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, 0)]
+        [InlineData(double.NaN, LengthUnit.Millimeter, ReciprocalLengthUnit.InverseCentimeter, double.NaN)]
+        public void TryGetConversionFunction_WithCompatibleQuantityType(double fromValue, LengthUnit fromUnit, ReciprocalLengthUnit toUnit, double expected)
         {
-            IQuantity ConversionFunction(IQuantity from) => Length.FromInches(18);
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            IEnumerable<QuantityConverterBuildOptions> converterOptions = GetQuantityConverterBuildOptions();
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction<Mass, Length>(MassUnit.Grain, LengthUnit.Inch, ConversionFunction);
+            Assert.All(converterOptions, options =>
+            {
+                var unitConverter = UnitConverter.Create(new UnitParser([Length.Info, ReciprocalLength.Info]), options);
 
-            var foundConversionFunction = unitConverter.GetConversionFunction(typeof(Mass), MassUnit.Grain, typeof(Length), LengthUnit.Inch);
-            var converted = foundConversionFunction(Mass.FromGrains(100));
+                var success = unitConverter.TryGetConversionFunction(fromUnit, toUnit, out ConvertValueDelegate? conversionFunction);
+                
+                Assert.True(success);
+                Assert.Equal(expectedValue, conversionFunction!(fromValue));
+            });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConversionToSameUnit_ReturnsSameQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var unitConverter = UnitConverter.Create(new UnitParser([]), convertOptions);
+
+            ConvertValueDelegate foundConversionFunction = unitConverter.GetConversionFunction(HowMuchUnit.ATon, HowMuchUnit.ATon);
+            QuantityValue converted = foundConversionFunction(39); 
 
-            Assert.Equal(Length.FromInches(18), converted);
+            Assert.Equal(39, converted);
         }
 
-        [Fact]
-        public void TryCustomConversionForOilBarrelsToUsGallons()
+        [Theory]
+        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.Some, 1)]
+        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.ATon, 0.1)]
+        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.AShitTon, 0.01)]
+        [InlineData(1, HowMuchUnit.ATon, HowMuchUnit.Some, 10)]
+        [InlineData(1, HowMuchUnit.AShitTon, HowMuchUnit.Some, 100)]
+        public void ConversionForUnitsOfCustomQuantity(double fromValue, HowMuchUnit fromUnit, HowMuchUnit toUnit, double expected)
         {
-            Volume ConversionFunction(Volume from) => Volume.FromUsGallons(from.Value * 42);
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            IEnumerable<QuantityConverterBuildOptions> converterOptions = GetQuantityConverterBuildOptions();
 
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.OilBarrel, VolumeUnit.UsGallon, ConversionFunction);
+            Assert.All(converterOptions, options =>
+            {
+                var unitConverter = UnitConverter.Create(new UnitParser([HowMuch.Info]), options);
 
-            var foundConversionFunction = unitConverter.GetConversionFunction<Volume>(VolumeUnit.OilBarrel, VolumeUnit.UsGallon);
-            var converted = foundConversionFunction(Volume.FromOilBarrels(1));
+                ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(fromUnit, toUnit);
+                QuantityValue converted = conversionFunction(fromValue);
 
-            Assert.Equal(Volume.FromUsGallons(42), converted);
+                Assert.Equal(expectedValue, converted);
+            });
         }
 
-        [Fact]
-        public void ConversionToSameUnit_ReturnsSameQuantity()
+        [Theory]
+        [InlineData(1, MassUnit.Tonne, HowMuchUnit.ATon, 1)]
+        [InlineData(1000, MassUnit.Kilogram, HowMuchUnit.ATon, 1)]
+        [InlineData(100, MassUnit.Kilogram, HowMuchUnit.Some, 1)]
+        [InlineData(10000, MassUnit.Kilogram, HowMuchUnit.AShitTon, 1)]
+        public void GetConversionFunction_WithCustomConversionForDifferentQuantities(double fromValue, MassUnit fromUnit, HowMuchUnit toUnit,
+            double expected)
         {
-            var unitConverter = new UnitConverter();
+            var expectedFromValue = QuantityValue.FromDoubleRounded(fromValue);
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            IEnumerable<QuantityConverterBuildOptions> converterOptions = GetQuantityConverterBuildOptions();
 
-            var foundConversionFunction = unitConverter.GetConversionFunction<HowMuch>(HowMuchUnit.ATon, HowMuchUnit.ATon);
-            var converted = foundConversionFunction(new HowMuch(39, HowMuchUnit.Some)); // Intentionally pass the wrong unit here, to test that the exact same quantity is returned
+            Assert.All(converterOptions, options =>
+            {
+                var unitConverter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]),
+                    options.WithImplicitConversionOptions(conversionOptions =>
+                        // since the dimensions of the two quantities are compatible and there is at least one pair of units that have the same BaseUnits (in our case these are the Mass.Tonne and HowMuch.ATon)
+                        // we don't have to specify a conversion expression (it is assumed that "1 Tonne" is equal to "1 ATon")
+                        conversionOptions.SetCustomConversion<Mass, HowMuch>()));
 
-            Assert.Equal(39, converted.Value);
-            Assert.Equal(HowMuchUnit.Some, converted.Unit);
+                Assert.Multiple(() =>
+                    {
+                        ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(fromUnit, toUnit);
+                        QuantityValue converted = conversionFunction(fromValue);
+                        Assert.Equal(expectedValue, converted);
+                    },
+                    () =>
+                    {
+                        ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(toUnit, fromUnit);
+                        QuantityValue converted = conversionFunction(expectedValue);
+                        Assert.Equal(expectedFromValue, converted);
+                    });
+            });
         }
 
         [Theory]
-        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.Some, 1)]
-        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.ATon, 2)]
-        [InlineData(1, HowMuchUnit.Some, HowMuchUnit.AShitTon, 10)]
-        public void ConversionForUnitsOfCustomQuantity(double fromValue, HowMuchUnit fromUnit, HowMuchUnit toUnit, double expectedValue)
+        [InlineData(1, MassUnit.Tonne, HowMuchUnit.ATon, 1)]
+        [InlineData(1000, MassUnit.Kilogram, HowMuchUnit.ATon, 1)]
+        [InlineData(100, MassUnit.Kilogram, HowMuchUnit.Some, 1)]
+        [InlineData(10000, MassUnit.Kilogram, HowMuchUnit.AShitTon, 1)]
+        public void TryGetConversionFunction_WithCustomConversionForDifferentQuantities(double fromValue, MassUnit fromUnit, HowMuchUnit toUnit,
+            double expected)
+        {
+            var expectedFromValue = QuantityValue.FromDoubleRounded(fromValue);
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            IEnumerable<QuantityConverterBuildOptions> converterOptions = GetQuantityConverterBuildOptions();
+
+            Assert.All(converterOptions, options =>
+            {
+                var unitConverter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]),
+                    options.WithImplicitConversionOptions(conversionOptions =>
+                        // since the dimensions of the two quantities are compatible and there is at least one pair of units that have the same BaseUnits (in our case these are the Mass.Tonne and HowMuch.ATon)
+                        // we don't have to specify a conversion expression (it is assumed that "1 Tonne" is equal to "1 ATon")
+                        conversionOptions.SetCustomConversion<Mass, HowMuch>()));
+
+                Assert.Multiple(() =>
+                    {
+                        var success = unitConverter.TryGetConversionFunction(fromUnit, toUnit, out ConvertValueDelegate? conversionFunction);
+                        Assert.True(success);
+                        Assert.Equal(expectedValue, conversionFunction!(fromValue));
+                    },
+                    () =>
+                    {
+                        var success = unitConverter.TryGetConversionFunction(toUnit, fromUnit, out ConvertValueDelegate? conversionFunction);
+                        Assert.True(success);
+                        Assert.Equal(expectedFromValue, conversionFunction!(expectedValue));
+                    });
+            });
+        }
+
+        [Theory]
+        [InlineData(1, VolumeUnit.Liter, HowMuchUnit.Some, 1)]
+        [InlineData(1000, VolumeUnit.Milliliter, HowMuchUnit.Some, 1)]
+        [InlineData(10, VolumeUnit.Liter, HowMuchUnit.ATon, 1)]
+        [InlineData(1, VolumeUnit.Kiloliter, HowMuchUnit.AShitTon, 10)]
+        public void GetConversionFunction_WithCustomConversionExpressionForDifferentQuantities(double fromValue, VolumeUnit fromUnit, HowMuchUnit toUnit,
+            double expected)
         {
-            // Intentionally don't map conversion Some->Some, it is not necessary
-            var unitConverter = new UnitConverter();
-            unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Some, HowMuchUnit.ATon, x => new HowMuch((double)x.Value * 2, HowMuchUnit.ATon));
-            unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Some, HowMuchUnit.AShitTon, x => new HowMuch((double)x.Value * 10, HowMuchUnit.AShitTon));
+            var expectedFromValue = QuantityValue.FromDoubleRounded(fromValue);
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            IEnumerable<QuantityConverterBuildOptions> converterOptions = GetQuantityConverterBuildOptions();
 
-            var foundConversionFunction = unitConverter.GetConversionFunction<HowMuch>(fromUnit, toUnit);
-            var converted = foundConversionFunction(new HowMuch(fromValue, fromUnit));
+            Assert.All(converterOptions, options =>
+            {
+                var unitConverter = UnitConverter.Create(new UnitParser([Volume.Info, HowMuch.Info]),
+                    options.WithImplicitConversionOptions(conversionOptions =>
+                        conversionOptions
+                            // since the dimensions / base units are incompatible we have to explicitly specify a conversion expression
+                            .SetCustomConversion<Volume, HowMuch>() 
+                            .SetCustomConversion(VolumeUnit.Liter, HowMuchUnit.Some, QuantityValue.One, true)));
 
-            Assert.Equal(expectedValue, converted.Value);
-            Assert.Equal(toUnit, converted.Unit);
+                Assert.Multiple(() =>
+                    {
+                        ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(fromUnit, toUnit);
+                        QuantityValue converted = conversionFunction(fromValue);
+                        Assert.Equal(expectedValue, converted);
+                    },
+                    () =>
+                    {
+                        ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(toUnit, fromUnit);
+                        QuantityValue converted = conversionFunction(expectedValue);
+                        Assert.Equal(expectedFromValue, converted);
+                    });
+            });
+        }
+
+        [Theory]
+        [InlineData(1, VolumeUnit.Liter, HowMuchUnit.Some, 1)]
+        [InlineData(1000, VolumeUnit.Milliliter, HowMuchUnit.Some, 1)]
+        [InlineData(10, VolumeUnit.Liter, HowMuchUnit.ATon, 1)]
+        [InlineData(1, VolumeUnit.Kiloliter, HowMuchUnit.AShitTon, 10)]
+        public void TryGetConversionFunction_WithCustomConversionExpressionForDifferentQuantities(double fromValue, VolumeUnit fromUnit, HowMuchUnit toUnit,
+            double expected)
+        {
+            var expectedFromValue = QuantityValue.FromDoubleRounded(fromValue);
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            IEnumerable<QuantityConverterBuildOptions> converterOptions = GetQuantityConverterBuildOptions();
+
+            Assert.All(converterOptions, options =>
+            {
+                var unitConverter = UnitConverter.Create(new UnitParser([Volume.Info, HowMuch.Info]),
+                    options.WithImplicitConversionOptions(conversionOptions =>
+                        conversionOptions
+                            // since the dimensions / base units are incompatible we have to explicitly specify a conversion expression
+                            .SetCustomConversion<Volume, HowMuch>() 
+                            .SetCustomConversion(VolumeUnit.Liter, HowMuchUnit.Some, QuantityValue.One, true)));
+
+                Assert.Multiple(() =>
+                    {
+                        var success = unitConverter.TryGetConversionFunction(fromUnit, toUnit, out ConvertValueDelegate? conversionFunction);
+                        Assert.True(success);
+                        Assert.Equal(expectedValue, conversionFunction!(fromValue));
+                    },
+                    () =>
+                    {
+                        var success = unitConverter.TryGetConversionFunction(toUnit, fromUnit, out ConvertValueDelegate? conversionFunction);
+                        Assert.True(success);
+                        Assert.Equal(expectedFromValue, conversionFunction!(expectedValue));
+                    });
+            });
+        }
+
+        [Theory]
+        [InlineData(1, MassFractionUnit.DecimalFraction, RatioUnit.DecimalFraction, 1)]
+        [InlineData(1, MassFractionUnit.DecimalFraction, RatioUnit.PartPerThousand, 1000)]
+        [InlineData(100, MassFractionUnit.Percent, RatioUnit.DecimalFraction, 1)]
+        [InlineData(1, MassFractionUnit.GramPerKilogram, RatioUnit.PartPerThousand, 1)]
+        public void GetConversionFunction_WithCustomConversionForDifferentDimensionlessQuantities(double fromValue, MassFractionUnit fromUnit, RatioUnit toUnit,
+            double expected)
+        {
+            var expectedFromValue = QuantityValue.FromDoubleRounded(fromValue);
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            IEnumerable<QuantityConverterBuildOptions> converterOptions = GetQuantityConverterBuildOptions();
+
+            Assert.All(converterOptions, options =>
+            {
+                var unitConverter = UnitConverter.Create(new UnitParser([MassFraction.Info, Ratio.Info]),
+                    options.WithImplicitConversionOptions(conversionOptions =>
+                        // since both quantities are dimensionless it is assumed that the quantities can be converted using their BaseUnit (i.e. the DecimalFraction)
+                        conversionOptions.SetCustomConversion<MassFraction, Ratio>()));
+
+                Assert.Multiple(() =>
+                    {
+                        ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(fromUnit, toUnit);
+                        QuantityValue converted = conversionFunction(fromValue);
+                        Assert.Equal(expectedValue, converted);
+                    },
+                    () =>
+                    {
+                        ConvertValueDelegate conversionFunction = unitConverter.GetConversionFunction(toUnit, fromUnit);
+                        QuantityValue converted = conversionFunction(expectedValue);
+                        Assert.Equal(expectedFromValue, converted);
+                    });
+            });
+        }
+
+        [Theory]
+        [InlineData(1, MassFractionUnit.DecimalFraction, RatioUnit.DecimalFraction, 1)]
+        [InlineData(1, MassFractionUnit.DecimalFraction, RatioUnit.PartPerThousand, 1000)]
+        [InlineData(100, MassFractionUnit.Percent, RatioUnit.DecimalFraction, 1)]
+        [InlineData(1, MassFractionUnit.GramPerKilogram, RatioUnit.PartPerThousand, 1)]
+        public void TryGetConversionFunction_WithCustomConversionForDifferentDimensionlessQuantities(double fromValue, MassFractionUnit fromUnit, RatioUnit toUnit,
+            double expected)
+        {
+            var expectedFromValue = QuantityValue.FromDoubleRounded(fromValue);
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            IEnumerable<QuantityConverterBuildOptions> converterOptions = GetQuantityConverterBuildOptions();
+
+            Assert.All(converterOptions, options =>
+            {
+                var unitConverter = UnitConverter.Create(new UnitParser([MassFraction.Info, Ratio.Info]),
+                    options.WithImplicitConversionOptions(conversionOptions =>
+                        // since both quantities are dimensionless it is assumed that the quantities can be converted using their BaseUnit (i.e. the DecimalFraction)
+                        conversionOptions.SetCustomConversion<MassFraction, Ratio>()));
+
+                Assert.Multiple(() =>
+                    {
+                        var success = unitConverter.TryGetConversionFunction(fromUnit, toUnit, out ConvertValueDelegate? conversionFunction);
+                        Assert.True(success);
+                        Assert.Equal(expectedValue, conversionFunction!(fromValue));
+                    },
+                    () =>
+                    {
+                        var success = unitConverter.TryGetConversionFunction(toUnit, fromUnit, out ConvertValueDelegate? conversionFunction);
+                        Assert.True(success);
+                        Assert.Equal(expectedFromValue, conversionFunction!(expectedValue));
+                    });
+            });
         }
 
         [Theory]
@@ -129,8 +714,9 @@ public void ConversionForUnitsOfCustomQuantity(double fromValue, HowMuchUnit fro
         [InlineData(100, 1, "Length", "Meter", "Centimeter")]
         [InlineData(1, 1000, "Mass", "Gram", "Kilogram")]
         [InlineData(1000, 1, "ElectricCurrent", "Kiloampere", "Ampere")]
-        public void ConvertByName_ConvertsTheValueToGivenUnit(double expectedValue, double inputValue, string quantityTypeName, string fromUnit, string toUnit)
+        public void ConvertByName_ConvertsTheValueToGivenUnit(double expected, double inputValue, string quantityTypeName, string fromUnit, string toUnit)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             Assert.Equal(expectedValue, UnitConverter.ConvertByName(inputValue, quantityTypeName, fromUnit, toUnit));
         }
 
@@ -167,8 +753,7 @@ public void ConvertByName_ThrowsUnitNotFoundExceptionOnUnknownFromOrToUnit(doubl
         [InlineData(1, "Length", "Meter", "UnknownToUnit")]
         public void TryConvertByName_ReturnsFalseForInvalidInput(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
         {
-            Assert.False(UnitConverter.TryConvertByName(inputValue, quantityTypeName, fromUnit, toUnit, out double result));
-            Assert.Equal(0, result);
+            Assert.False(UnitConverter.TryConvertByName(inputValue, quantityTypeName, fromUnit, toUnit, out _));
         }
 
         [Theory]
@@ -176,46 +761,95 @@ public void TryConvertByName_ReturnsFalseForInvalidInput(double inputValue, stri
         [InlineData(100, 1, "Length", "Meter", "Centimeter")]
         [InlineData(1, 1000, "Mass", "Gram", "Kilogram")]
         [InlineData(1000, 1, "ElectricCurrent", "Kiloampere", "Ampere")]
-        public void TryConvertByName_ReturnsTrueOnSuccessAndOutputsResult(double expectedValue, double inputValue, string quantityTypeName, string fromUnit,
+        public void TryConvertByName_ReturnsTrueOnSuccessAndOutputsResult(double expected, double inputValue, string quantityTypeName, string fromUnit,
             string toUnit)
         {
-            Assert.True(UnitConverter.TryConvertByName(inputValue, quantityTypeName, fromUnit, toUnit, out double result), "TryConvertByName() return value.");
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            Assert.True(UnitConverter.TryConvertByName(inputValue, quantityTypeName, fromUnit, toUnit, out QuantityValue result));
             Assert.Equal(expectedValue, result);
         }
 
+        [Theory]
+        [InlineData(0, 0, "Length", "Meter", "Centimeter")] // base -> non-base (zero)
+        [InlineData(100, 1, "Length", "Meter", "Centimeter")] // base -> non-base
+        [InlineData(10, 1, "Length", "Centimeter", "Millimeter")] // non-base -> non-base
+        [InlineData(1, 1, "Mass", "Gram", "Gram")] // same-units (non-base)
+        [InlineData(1, 1000, "Mass", "Gram", "Kilogram")] // non-base -> base
+        [InlineData(2000, 2, "Mass", "Gram", "Milligram")] // non-base -> non-base
+        public void TryConvertValueByName_ReturnsTrueOnSuccessAndOutputsResult(double expected, double inputValue, string quantityTypeName, string fromUnit,
+            string toUnit)
+        {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            Assert.Multiple(() =>
+            {
+                var converter = new UnitConverter(UnitParser.Default);
+
+                Assert.True(converter.TryConvertValueByName(inputValue, quantityTypeName, fromUnit, toUnit, out QuantityValue result));
+                Assert.Equal(expectedValue, result);
+            }, () =>
+            {
+                var converter = UnitConverter.Create(UnitParser.Default,
+                    new QuantityConverterBuildOptions(defaultCachingMode: ConversionCachingMode.None, freeze: false));
+
+                Assert.True(converter.TryConvertValueByName(inputValue, quantityTypeName, fromUnit, toUnit, out QuantityValue result));
+                Assert.Equal(expectedValue, result);
+            }, () =>
+            {
+                var converter = UnitConverter.Create(UnitParser.Default,
+                    new QuantityConverterBuildOptions(defaultCachingMode: ConversionCachingMode.None, freeze: true)
+                        .WithCustomCachingOptions<Length>(new ConversionCacheOptions()));
+
+                Assert.True(converter.TryConvertValueByName(inputValue, quantityTypeName, fromUnit, toUnit, out QuantityValue result));
+                Assert.Equal(expectedValue, result);
+            });
+        }
+
         [Theory]
         [InlineData(0, 0, "Length", "m", "cm")]
+        [InlineData(1, 1, "Length", "cm", "cm")]
         [InlineData(100, 1, "Length", "m", "cm")]
         [InlineData(1, 1000, "Mass", "g", "kg")]
         [InlineData(1000, 1, "ElectricCurrent", "kA", "A")]
-        public void ConvertByAbbreviation_ConvertsTheValueToGivenUnit(double expectedValue, double inputValue, string quantityTypeName, string fromUnit, string toUnit)
+        public void ConvertByAbbreviation_ConvertsTheValueToGivenUnit(double expected, double inputValue, string quantityTypeName, string fromUnit,
+            string toUnit)
         {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
             Assert.Equal(expectedValue, UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
+            Assert.Equal(expectedValue, UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, CultureInfo.InvariantCulture));
+            Assert.Equal(expectedValue, UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, "en-US"));
         }
 
         [Theory]
         [InlineData(1, "UnknownQuantity", "m", "cm")]
-        public void ConvertByAbbreviation_ThrowsQuantityNotFoundExceptionOnUnknownQuantity( double inputValue, string quantityTypeName, string fromUnit, string toUnit)
+        public void ConvertByAbbreviation_ThrowsUnitNotFoundExceptionOnUnknownQuantity(double inputValue, string quantityTypeName, string fromUnit,
+            string toUnit)
         {
             Assert.Throws<QuantityNotFoundException>(() => UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
+            Assert.Throws<QuantityNotFoundException>(() => UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, CultureInfo.InvariantCulture));
+            Assert.Throws<QuantityNotFoundException>(() => UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, "en-US"));
         }
 
         [Theory]
         [InlineData(1, "Length", "UnknownFromUnit", "cm")]
         [InlineData(1, "Length", "m", "UnknownToUnit")]
-        public void ConvertByAbbreviation_ThrowsUnitNotFoundExceptionOnUnknownFromOrToUnitAbbreviation(double inputValue, string quantityTypeName, string fromUnit, string toUnit)
+        public void ConvertByAbbreviation_ThrowsUnitNotFoundExceptionOnUnknownFromOrToUnitAbbreviation(double inputValue, string quantityTypeName,
+            string fromUnit, string toUnit)
         {
             Assert.Throws<UnitNotFoundException>(() => UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit));
+            Assert.Throws<UnitNotFoundException>(() => UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, CultureInfo.InvariantCulture));
+            Assert.Throws<UnitNotFoundException>(() => UnitConverter.ConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, "en-US"));
         }
 
         [Theory]
         [InlineData(1, "UnknownQuantity", "m", "cm", "en-US")]
         [InlineData(1, "Length", "UnknownFromUnit", "cm", "en-US")]
         [InlineData(1, "Length", "m", "UnknownToUnit", "en-US")]
-        public void TryConvertByAbbreviation_ReturnsFalseForInvalidInput(double inputValue, string quantityTypeName, string fromUnit, string toUnit, string culture)
+        public void TryConvertByAbbreviation_ReturnsFalseForInvalidInput(double inputValue, string quantityTypeName, string fromUnit, string toUnit,
+            string culture)
         {
-            Assert.False(UnitConverter.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out double result, culture));
-            Assert.Equal(0, result);
+            Assert.False(UnitConverter.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, null, out _));
+            Assert.False(UnitConverter.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, CultureInfo.GetCultureInfo(culture), out _));
+            Assert.False(UnitConverter.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out _, culture));
         }
 
         [Theory]
@@ -223,10 +857,2638 @@ public void TryConvertByAbbreviation_ReturnsFalseForInvalidInput(double inputVal
         [InlineData(100, 1, "Length", "m", "cm", "en-US")]
         [InlineData(1, 1000, "Mass", "g", "kg", "en-US")]
         [InlineData(1000, 1, "ElectricCurrent", "kA", "A", "en-US")]
-        public void TryConvertByAbbreviation_ReturnsTrueOnSuccessAndOutputsResult(double expectedValue, double inputValue, string quantityTypeName, string fromUnit, string toUnit, string culture)
+        public void TryConvertByAbbreviation_ReturnsTrueOnSuccessAndOutputsResult(double expected, double inputValue, string quantityTypeName,
+            string fromUnit, string toUnit, string culture)
+        {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            Assert.Multiple(
+            () =>
+            {
+                Assert.True(UnitConverter.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, CultureInfo.GetCultureInfo(culture), out QuantityValue result), "TryConvertByAbbreviation() return value.");
+                Assert.Equal(expectedValue, result);
+            },
+            () =>
+            {
+                Assert.True(UnitConverter.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out QuantityValue result, culture), "TryConvertByAbbreviation() return value.");
+                Assert.Equal(expectedValue, result); 
+            });
+        }
+
+        [Theory] 
+        // note: this test is culture-dependant, however using the international units should work with any "CurrentCulture"
+        [InlineData(0, 0, "Length", "m", "cm")]
+        [InlineData(1, 1, "Length", "cm", "cm")]
+        [InlineData(100, 1, "Length", "m", "cm")]
+        [InlineData(1, 1000, "Mass", "g", "kg")]
+        [InlineData(1000, 1, "ElectricCurrent", "kA", "A")]
+        public void TryConvertByAbbreviation_WithDefaultCulture_ReturnsTrueOnSuccessAndOutputsResult(double expected, double inputValue, string quantityTypeName,
+            string fromUnit, string toUnit)
+        {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            Assert.True(UnitConverter.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out QuantityValue result));
+            Assert.Equal(expectedValue, result);
+        }
+
+        [Theory] 
+        // note: this test is culture-dependant, however using the international units should work with any "CurrentCulture"
+        [InlineData(0, 0, "Length", "m", "cm")]
+        [InlineData(1, 1, "Length", "cm", "cm")]
+        [InlineData(100, 1, "Length", "m", "cm")]
+        [InlineData(1, 1000, "Mass", "g", "kg")]
+        [InlineData(1000, 1, "ElectricCurrent", "kA", "A")]
+        public void TryConvertValueByAbbreviation_ReturnsTrueOnSuccessAndOutputsResult(double expected, double inputValue, string quantityTypeName,
+            string fromUnit, string toUnit)
+        {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            UnitParser unitParser = UnitParser.Default;
+            Assert.Multiple(() =>
+            {
+                var converter = new UnitConverter(unitParser);
+
+                Assert.True(converter.TryConvertValueByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out QuantityValue result));
+                Assert.Equal(expectedValue, result);
+            }, () =>
+            {
+                var converter = UnitConverter.Create(unitParser, new QuantityConverterBuildOptions(defaultCachingMode: ConversionCachingMode.None, freeze: false));
+
+                Assert.True(converter.TryConvertValueByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out QuantityValue result));
+                Assert.Equal(expectedValue, result);
+            }, () =>
+            {
+                var converter = UnitConverter.Create(unitParser, new QuantityConverterBuildOptions(defaultCachingMode: ConversionCachingMode.None, freeze: true)
+                    .WithCustomCachingOptions<Length>(new ConversionCacheOptions(cachingMode: ConversionCachingMode.All)));
+
+                Assert.True(converter.TryConvertValueByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out QuantityValue result));
+                Assert.Equal(expectedValue, result);
+            });
+        }
+
+        [Theory]
+        [InlineData(0, 0, LengthUnit.Meter, LengthUnit.Centimeter)] // base -> non-base (zero)
+        [InlineData(100, 1, LengthUnit.Meter, LengthUnit.Centimeter)]  // base -> non-base
+        [InlineData(1, 1, LengthUnit.Centimeter, LengthUnit.Centimeter)] // same units (non-base)
+        [InlineData(1, 1000, MassUnit.Gram, MassUnit.Kilogram)]     // non-base -> base
+        [InlineData(1000, 1, MassUnit.Gram, MassUnit.Milligram)]    // non-base -> non-base
+        [InlineData(1000, 1, ElectricCurrentUnit.Kiloampere, ElectricCurrentUnit.Ampere)]
+        [InlineData(0.1, 10, AreaUnit.SquareCentimeter, ReciprocalAreaUnit.InverseSquareCentimeter)] // inverse relationship
+        public void Convert_ReturnsTrueOnSuccessAndOutputsResult(double expected, double inputValue, Enum fromUnit, Enum toUnit)
+        {
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            QuantityValue convertedValue = UnitConverter.Convert(inputValue, fromUnit, toUnit);
+            Assert.Equal(expectedValue, convertedValue);
+        }
+        
+        [Theory]
+        [InlineData(0, 0, LengthUnit.Meter, LengthUnit.Centimeter)] // base -> non-base (zero)
+        [InlineData(100, 1, LengthUnit.Meter, LengthUnit.Centimeter)]  // base -> non-base
+        [InlineData(1, 1, LengthUnit.Centimeter, LengthUnit.Centimeter)] // same units (non-base)
+        [InlineData(1, 1000, MassUnit.Gram, MassUnit.Kilogram)]     // non-base -> base
+        [InlineData(1000, 1, MassUnit.Gram, MassUnit.Milligram)]    // non-base -> non-base
+        [InlineData(1000, 1, ElectricCurrentUnit.Kiloampere, ElectricCurrentUnit.Ampere)]
+        [InlineData(0.1, 10, AreaUnit.SquareCentimeter, ReciprocalAreaUnit.InverseSquareCentimeter)] // inverse relationship
+        public void TryConvert_ReturnsTrueOnSuccessAndOutputsResult(double expected, double inputValue, Enum fromUnit, Enum toUnit)
         {
-            Assert.True(UnitConverter.TryConvertByAbbreviation(inputValue, quantityTypeName, fromUnit, toUnit, out double result, culture), "TryConvertByAbbreviation() return value.");
+            var expectedValue = QuantityValue.FromDoubleRounded(expected);
+            Assert.True(UnitConverter.TryConvert(inputValue, fromUnit, toUnit, out QuantityValue result));
             Assert.Equal(expectedValue, result);
         }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_ShouldConvertValueToUnitWithinSameQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(UnitParser.Default, convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.All(Quantity.Infos, quantityInfo =>
+            {
+                Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                {
+                    Enum fromUnit = fromUnitInfo.Value;
+                    Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                    {
+                        Enum toUnit = toUnitInfo.Value;
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                        QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                        Assert.Equal(expectedValue, convertedValue);
+                    });
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldConvertValueToUnitWithinSameQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(UnitParser.Default, convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.All(Quantity.Infos, quantityInfo =>
+            {
+                Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                {
+                    Enum fromUnit = fromUnitInfo.Value;
+                    Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                    {
+                        Enum toUnit = toUnitInfo.Value;
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                        var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+
+                        Assert.True(success);
+                        Assert.Equal(expectedValue, convertedValue);
+                    });
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_ShouldConvertValueToUnitWithinSameGenericQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(UnitParser.Default, convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            QuantityInfo<Mass, MassUnit> quantityInfo = Mass.Info;
+            Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+            {
+                MassUnit fromUnit = fromUnitInfo.Value;
+                Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                {
+                    MassUnit toUnit = toUnitInfo.Value;
+                    QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                    QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                    Assert.Equal(expectedValue, convertedValue);
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldConvertValueToUnitWithinSameGenericQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(UnitParser.Default, convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            QuantityInfo<Mass, MassUnit> quantityInfo = Mass.Info;
+            Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+            {
+                MassUnit fromUnit = fromUnitInfo.Value;
+                Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                {
+                    MassUnit toUnit = toUnitInfo.Value;
+                    QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                    var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValueFromUnit);
+
+                    Assert.True(success);
+                    Assert.Equal(expectedValue, convertedValueFromUnit);
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_ShouldConvertQuantityToUnitWithinSameQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(UnitParser.Default, convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.All(Quantity.Infos, quantityInfo =>
+            {
+                Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                {
+                    IQuantity quantityToConvert = fromUnitInfo.From(valueToConvert);
+                    Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                    {
+                        Enum toUnit = toUnitInfo.Value;
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                        IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                        Assert.IsType(quantityInfo.QuantityType, convertedQuantity);
+                        Assert.Equal(toUnit, convertedQuantity.Unit);
+                        Assert.Equal(expectedValue, convertedQuantity.Value);
+                    });
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_ShouldConvertQuantityToUnitWithinSameQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(UnitParser.Default, convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.All(Quantity.Infos, quantityInfo =>
+            {
+                Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                {
+                    IQuantity quantityToConvert = fromUnitInfo.From(valueToConvert);
+                    Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                    {
+                        Enum toUnit = toUnitInfo.Value;
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                        var success = converter.TryConvertTo(quantityToConvert, toUnit, out IQuantity? convertedQuantity);
+
+                        Assert.True(success);
+                        Assert.IsType(quantityInfo.QuantityType, convertedQuantity);
+                        Assert.Equal(toUnit, convertedQuantity.Unit);
+                        Assert.Equal(expectedValue, convertedQuantity.Value);
+                    });
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_ShouldConvertQuantityToUnitWithinSameConcreteQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(UnitParser.Default, convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            QuantityInfo<Temperature, TemperatureUnit> quantityInfo = Temperature.Info;
+            Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+            {
+                Temperature quantityToConvert = fromUnitInfo.From(valueToConvert);
+                Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                {
+                    TemperatureUnit toUnit = toUnitInfo.Value;
+                    QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                    Temperature convertedQuantity = converter.ConvertToUnit(quantityToConvert, toUnit);
+
+                    Assert.Equal(toUnit, convertedQuantity.Unit);
+                    Assert.Equal(expectedValue, convertedQuantity.Value);
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_ShouldConvertQuantityToUnitWithinSameConcreteQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(UnitParser.Default, convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            QuantityInfo<Temperature, TemperatureUnit> quantityInfo = Temperature.Info;
+            Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+            {
+                Temperature quantityToConvert = fromUnitInfo.From(valueToConvert);
+                Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                {
+                    TemperatureUnit toUnit = toUnitInfo.Value;
+                    QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                    var success = converter.TryConvertToUnit(quantityToConvert, toUnit, out Temperature convertedQuantity);
+
+                    Assert.True(success);
+                    Assert.Equal(toUnit, convertedQuantity.Unit);
+                    Assert.Equal(expectedValue, convertedQuantity.Value);
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldConvertQuantityToUnitWithinSameConcreteQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(UnitParser.Default, convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            QuantityInfo<Temperature, TemperatureUnit> quantityInfo = Temperature.Info;
+            Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+            {
+                Temperature quantityToConvert = fromUnitInfo.From(valueToConvert);
+                Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                {
+                    TemperatureUnit toUnit = toUnitInfo.Value;
+                    QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                    var success = converter.TryConvertValue(quantityToConvert, toUnit, out QuantityValue convertedValue);
+
+                    Assert.True(success);
+                    Assert.Equal(expectedValue, convertedValue);
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_ShouldThrowUnitNotFoundExceptionForUnknownUnits(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Length.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.Throws<UnitNotFoundException>(() => converter.ConvertValue(valueToConvert, MassUnit.Gram, MassUnit.Milligram));
+                },
+                () =>
+                {
+                    Assert.Throws<UnitNotFoundException>(() => converter.ConvertValue(new Mass(valueToConvert, MassUnit.Gram), MassUnit.Milligram));
+                },
+                () =>
+                {
+                    Assert.Throws<UnitNotFoundException>(() => converter.ConvertValue(valueToConvert, Mass.BaseUnit, Length.BaseUnit));
+                    Assert.Throws<UnitNotFoundException>(() => converter.ConvertValue(valueToConvert, Length.BaseUnit, Mass.BaseUnit));
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldReturnFalseForUnknownUnits(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Length.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.False(converter.TryConvertValue(valueToConvert, MassUnit.Gram, MassUnit.Milligram, out _));
+                },
+                () =>
+                {
+                    Assert.False(converter.TryConvertValue(new Mass(valueToConvert, MassUnit.Gram), MassUnit.Milligram, out _));
+                },
+                () =>
+                {
+                    Assert.False(converter.TryConvertValue(valueToConvert, Mass.BaseUnit, Length.BaseUnit, out _));
+                    Assert.False(converter.TryConvertValue(valueToConvert, Length.BaseUnit, Mass.BaseUnit, out _));
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_ShouldThrowUnitNotFoundExceptionForUnknownUnits(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Length.Info]), convertOptions);
+
+            Assert.Multiple(() =>
+                {
+                    var quantityToConvert = new Mass(1, MassUnit.Gram);
+                    Assert.Throws<UnitNotFoundException>(() => converter.ConvertToUnit(quantityToConvert, MassUnit.Milligram));
+                },
+                () =>
+                {
+                    IQuantity quantityToConvert = new Mass(1, MassUnit.Gram);
+                    Assert.Throws<UnitNotFoundException>(() => converter.ConvertTo(quantityToConvert, MassUnit.Milligram));
+                },
+                () =>
+                {
+                    var quantityToConvert = new Length(1, LengthUnit.Meter);
+                    Assert.Throws<UnitNotFoundException>(() => converter.ConvertTo(quantityToConvert, MassUnit.Milligram));
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_ShouldReturnFalseForUnknownUnits(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Length.Info]), convertOptions);
+            
+            Assert.Multiple(() =>
+                {
+                    var quantityToConvert = new Mass(1, MassUnit.Gram);
+                    var success = converter.TryConvertToUnit(quantityToConvert, MassUnit.Milligram, out Mass _);
+                    Assert.False(success);
+                },
+                () =>
+                {
+                    IQuantity quantityToConvert = new Mass(1, MassUnit.Gram);
+                    var success = converter.TryConvertTo(quantityToConvert, MassUnit.Milligram, out IQuantity? _);
+                    Assert.False(success);
+                },
+                () =>
+                {
+                    var quantityToConvert = new Length(1, LengthUnit.Meter);
+                    var success = converter.TryConvertTo(quantityToConvert, MassUnit.Milligram, out IQuantity? _);
+                    Assert.False(success);
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_UnknownRelation_Throws_InvalidConversionException(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Length.Info, Mass.Info]), convertOptions);
+
+            Assert.Multiple(() =>
+                {
+                    // left to right
+                    Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(Length.Zero, MassUnit.Milligram));
+                },
+                () =>
+                {
+                    // right to left
+                    Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(Mass.Zero, LengthUnit.Meter));
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_UnknownRelation_ReturnsFalse(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Length.Info, Mass.Info]), convertOptions);
+
+            Assert.Multiple(() =>
+                {
+                    var success = converter.TryConvertTo(Length.Zero, MassUnit.Milligram, out IQuantity? _);
+                    Assert.False(success);
+                },
+                () =>
+                {
+                    var success = converter.TryConvertTo(Mass.Zero, LengthUnit.Meter, out IQuantity? _);
+                    Assert.False(success);
+                });
+        }
+
+        [Theory]
+        [InlineData( true,true)]
+        [InlineData( true,false)]
+        [InlineData(false,true)]
+        [InlineData(false,false)]
+        public void ConvertTo_QuantityWithIncompatibleDimensions_Throws_InvalidConversionException(bool freeze, bool reduceConstants)
+        {
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, ConversionCachingMode.None, reduceConstants)
+                // no conversion expressions can be determined using the base dimensions (a conversion function needs to be explicitly provided)
+                .WithImplicitConversionOptions(options => options.SetCustomConversion<Length, Mass>());
+            var converter = UnitConverter.Create(new UnitParser([Length.Info, Mass.Info]), convertOptions);
+
+            Assert.Multiple(() =>
+                {
+                    // left to right
+                    Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(Length.Zero, MassUnit.Milligram));
+                },
+                () =>
+                {
+                    // right to left
+                    Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(Mass.Zero, LengthUnit.Meter));
+                });
+        }
+
+        [Theory]
+        [InlineData( true,true)]
+        [InlineData( true,false)]
+        [InlineData(false,true)]
+        [InlineData(false,false)]
+        public void TryConvertTo_QuantityWithIncompatibleDimensions_ReturnsFalse(bool freeze, bool reduceConstants)
+        {
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, ConversionCachingMode.None, reduceConstants)
+                // no conversion expressions can be determined using the base dimensions (a conversion function needs to be explicitly provided)
+                .WithImplicitConversionOptions(options => options.SetCustomConversion<Length, Mass>());
+            var converter = UnitConverter.Create(new UnitParser([Length.Info, Mass.Info]), convertOptions);
+
+            Assert.Multiple(() =>
+                {
+                    var success = converter.TryConvertTo(Length.Zero, MassUnit.Milligram, out IQuantity? _);
+                    Assert.False(success);
+                },
+                () =>
+                {
+                    var success = converter.TryConvertTo(Mass.Zero, LengthUnit.Meter, out IQuantity? _);
+                    Assert.False(success);
+                });
+        }
+
+        [Theory]
+        [InlineData( true,true)]
+        [InlineData( true,false)]
+        [InlineData(false,true)]
+        [InlineData(false,false)]
+        public void ConvertTo_QuantityWithoutBaseUnits_Throws_InvalidConversionException(bool freeze, bool reduceConstants)
+        {
+            // we simulate a target quantity without any base units
+            var densityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+                unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, ConversionCachingMode.None, reduceConstants)
+                // no conversion expressions can be determined without the base units (a conversion function needs to be explicitly provided)
+                .WithImplicitConversionOptions(options => options.SetCustomConversion<Density, MassConcentration>());
+            var converter = UnitConverter.Create(new UnitParser([densityInfo, MassConcentration.Info]), convertOptions);
+
+            Assert.Multiple(() =>
+                {
+                    // left to right
+                    Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(Density.Zero, MassConcentrationUnit.KilogramPerCubicMeter));
+                },
+                () =>
+                {
+                    // right to left
+                    Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(MassConcentration.Zero, DensityUnit.KilogramPerCubicMeter));
+                });
+        }
+
+        [Theory]
+        [InlineData( true,true)]
+        [InlineData( true,false)]
+        [InlineData(false,true)]
+        [InlineData(false,false)]
+        public void TryConvertTo_QuantityWithoutBaseUnits_ReturnsFalse(bool freeze, bool reduceConstants)
+        {
+            // we simulate a target quantity without any base units
+            var densityInfo = Density.DensityInfo.CreateDefault(unitInfos =>
+                unitInfos.Select(x => new UnitDefinition<DensityUnit>(x.Value, x.PluralName, BaseUnits.Undefined)));
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, ConversionCachingMode.None, reduceConstants)
+                // no conversion expressions can be determined without the base units (a conversion function needs to be explicitly provided)
+                .WithImplicitConversionOptions(options => options.SetCustomConversion<Density, MassConcentration>());
+            var converter = UnitConverter.Create(new UnitParser([densityInfo, MassConcentration.Info]), convertOptions);
+
+            Assert.Multiple(() =>
+                {
+                    var success = converter.TryConvertTo(Density.Zero, MassConcentrationUnit.KilogramPerCubicMeter, out IQuantity? _);
+                    Assert.False(success);
+                },
+                () =>
+                {
+                    var success = converter.TryConvertTo(MassConcentration.Zero, DensityUnit.KilogramPerCubicMeter, out IQuantity? _);
+                    Assert.False(success);
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_ShouldConvertValueForCustomQuantityToUnitWithinSameQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    QuantityInfo<Mass, MassUnit> quantityInfo = Mass.Info;
+                    Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                    {
+                        MassUnit fromUnit = fromUnitInfo.Value;
+                        Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    QuantityInfo quantityInfo = HowMuch.Info;
+                    Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                    {
+                        Enum fromUnit = fromUnitInfo.Value;
+                        Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            Enum toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldConvertValueForCustomQuantityToUnitWithinSameQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    QuantityInfo<Mass, MassUnit> quantityInfo = Mass.Info;
+                    Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                    {
+                        MassUnit fromUnit = fromUnitInfo.Value;
+                        Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    QuantityInfo quantityInfo = HowMuch.Info;
+                    Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                    {
+                        Enum fromUnit = fromUnitInfo.Value;
+                        Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            Enum toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_ShouldConvertCustomQuantityToUnitWithinSameQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    QuantityInfo<Mass, MassUnit> quantityInfo = Mass.Info;
+                    Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                    {
+                        Mass quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                            Mass convertedQuantity = converter.ConvertToUnit(quantityToConvert, toUnit);
+
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                },
+                () =>
+                {
+                    QuantityInfo quantityInfo = HowMuch.Info;
+                    Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                    {
+                        IQuantity quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            Enum toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                            IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                            Assert.IsType<HowMuch>(convertedQuantity);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_ShouldConvertCustomQuantityToUnitWithinSameQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    QuantityInfo<Mass, MassUnit> quantityInfo = Mass.Info;
+                    Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                    {
+                        Mass quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                            var success = converter.TryConvertToUnit(quantityToConvert, toUnit, out Mass convertedQuantity);
+
+                            Assert.True(success);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                },
+                () =>
+                {
+                    QuantityInfo quantityInfo = HowMuch.Info;
+                    Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+                    {
+                        IQuantity quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            Enum toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                            var success = converter.TryConvertTo(quantityToConvert, toUnit, out IQuantity? convertedQuantity);
+
+                            Assert.True(success);
+                            Assert.IsType<HowMuch>(convertedQuantity);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_ShouldConvertCustomQuantityToUnitWithinSameQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            QuantityInfo<Mass, MassUnit> quantityInfo = Mass.Info;
+            Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+            {
+                Mass quantityToConvert = fromUnitInfo.From(valueToConvert);
+                Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                {
+                    MassUnit toUnit = toUnitInfo.Value;
+                    QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                    QuantityValue convertedValue = converter.ConvertValue(quantityToConvert, toUnit);
+
+                    Assert.Equal(expectedValue, convertedValue);
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldConvertCustomQuantityToUnitWithinSameQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            QuantityInfo<Mass, MassUnit> quantityInfo = Mass.Info;
+            Assert.All(quantityInfo.UnitInfos, fromUnitInfo =>
+            {
+                Mass quantityToConvert = fromUnitInfo.From(valueToConvert);
+                Assert.All(quantityInfo.UnitInfos, toUnitInfo =>
+                {
+                    MassUnit toUnit = toUnitInfo.Value;
+                    QuantityValue expectedValue = toUnitInfo.GetValueFrom(valueToConvert, fromUnitInfo);
+
+                    var success = converter.TryConvertValue(quantityToConvert, toUnit, out QuantityValue convertedValue);
+
+                    Assert.True(success);
+                    Assert.Equal(expectedValue, convertedValue);
+                });
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_ShouldConvertValueToUnitOfAnotherQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Density.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<SpecificVolume, SpecificVolumeUnit> toQuantityInfo = SpecificVolume.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                            SpecificVolume expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(SpecificVolume.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<Density, DensityUnit> toQuantityInfo = Density.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            Density expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldConvertValueToUnitOfAnotherQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Density.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<SpecificVolume, SpecificVolumeUnit> toQuantityInfo = SpecificVolume.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                            SpecificVolume expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValueFromUnit);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValueFromUnit);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(SpecificVolume.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<Density, DensityUnit> toQuantityInfo = Density.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            Density expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValueFromUnit);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValueFromUnit);
+                        });
+                    });
+                });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_ShouldConvertValueToUnitOfAnotherQuantityWithCustomConversion(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options => 
+                    // since the dimensions of the two quantities are compatible and there is at least one pair of units that have the same BaseUnits (in our case these are the Mass.Tonne and HowMuch.ATon)
+                    // we don't have to specify a conversion expression (it is assumed that "1 Tonne" is equal to "1 ATon")
+                    options.SetCustomConversion<Mass, HowMuch>());
+            var converter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Mass.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        MassUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo toQuantityInfo = HowMuch.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            Enum toUnit = toUnitInfo.Value;
+                            IQuantity expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(HowMuch.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        Enum fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<Mass, MassUnit> toQuantityInfo = Mass.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassUnit toUnit = toUnitInfo.Value;
+                            Mass expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldConvertValueToUnitOfAnotherQuantityWithCustomConversion(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options => 
+                    // since the dimensions of the two quantities are compatible and there is at least one pair of units that have the same BaseUnits (in our case these are the Mass.Tonne and HowMuch.ATon)
+                    // we don't have to specify a conversion expression (it is assumed that "1 Tonne" is equal to "1 ATon")
+                    options.SetCustomConversion<Mass, HowMuch>());
+            var converter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Mass.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        MassUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo toQuantityInfo = HowMuch.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            Enum toUnit = toUnitInfo.Value;
+                            IQuantity expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValueFromUnit);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValueFromUnit);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(HowMuch.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        Enum fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<Mass, MassUnit> toQuantityInfo = Mass.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassUnit toUnit = toUnitInfo.Value;
+                            Mass expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValueFromUnit);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValueFromUnit);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_ShouldConvertValueToUnitOfAnotherQuantityWithCustomConversion(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options => 
+                    // since the dimensions of the two quantities are compatible and there is at least one pair of units that have the same BaseUnits (in our case these are the Mass.Tonne and HowMuch.ATon)
+                    // we don't have to specify a conversion expression (it is assumed that "1 Tonne" is equal to "1 ATon")
+                    options.SetCustomConversion<Mass, HowMuch>());
+            var converter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Mass.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        var quantityToConvert = new Mass(valueToConvert, fromUnitInfo.Value);
+                        QuantityInfo toQuantityInfo = HowMuch.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            Enum toUnit = toUnitInfo.Value;
+                            IQuantity expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(HowMuch.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        var quantityToConvert = new HowMuch(valueToConvert, fromUnitInfo.Value);
+                        QuantityInfo<Mass, MassUnit> toQuantityInfo = Mass.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassUnit toUnit = toUnitInfo.Value;
+                            Mass expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_ShouldConvertValueToUnitOfAnotherQuantityWithCustomConversion(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options => 
+                    // since the dimensions of the two quantities are compatible and there is at least one pair of units that have the same BaseUnits (in our case these are the Mass.Tonne and HowMuch.ATon)
+                    // we don't have to specify a conversion expression (it is assumed that "1 Tonne" is equal to "1 ATon")
+                    options.SetCustomConversion<Mass, HowMuch>());
+            var converter = UnitConverter.Create(new UnitParser([Mass.Info, HowMuch.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Mass.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        var quantityToConvert = new Mass(valueToConvert, fromUnitInfo.Value);
+                        QuantityInfo toQuantityInfo = HowMuch.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            Enum toUnit = toUnitInfo.Value;
+                            IQuantity expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            var success = converter.TryConvertTo(quantityToConvert, toUnit, out IQuantity? convertedQuantity);
+
+                            Assert.True(success);
+                            Assert.Equal(toUnit, convertedQuantity!.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(HowMuch.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        var quantityToConvert = new HowMuch(valueToConvert, fromUnitInfo.Value);
+                        QuantityInfo<Mass, MassUnit> toQuantityInfo = Mass.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassUnit toUnit = toUnitInfo.Value;
+                            Mass expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            var success = converter.TryConvertTo(quantityToConvert, toUnit, out IQuantity? convertedQuantity);
+
+                            Assert.True(success);
+                            Assert.Equal(toUnit, convertedQuantity!.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_ShouldConvertValueToUnitOfAnotherQuantityWithCustomConversionViaBase(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            // unlike the conversion between HowMuch and Mass where HowMuch.BaseUnitInfo.BaseUnits == Undefined
+            // here we have: Density.BaseUnitInfo.BaseUnits == MassConcentration.BaseUnitInfo.BaseUnits (an optimized scenario)
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options => 
+                    // since the dimensions of the two quantities are compatible and there is at least one pair of units that have the same BaseUnits
+                    // we don't have to specify a conversion expression (it is assumed that "1 Density.BaseUnit" is equal to "1 MassConcentration.BaseUnit")
+                    options.SetCustomConversion<Density, MassConcentration>());
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, MassConcentration.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Density.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<MassConcentration, MassConcentrationUnit> toQuantityInfo = MassConcentration.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassConcentrationUnit toUnit = toUnitInfo.Value;
+                            MassConcentration expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(MassConcentration.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        MassConcentrationUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<Density, DensityUnit> toQuantityInfo = Density.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            Density expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldConvertValueToUnitOfAnotherQuantityWithCustomConversionViaBase(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            // unlike the conversion between HowMuch and Mass where HowMuch.BaseUnitInfo.BaseUnits == Undefined
+            // here we have: Density.BaseUnitInfo.BaseUnits == MassConcentration.BaseUnitInfo.BaseUnits (an optimized scenario)
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options => 
+                    // since the dimensions of the two quantities are compatible and there is at least one pair of units that have the same BaseUnits
+                    // we don't have to specify a conversion expression (it is assumed that "1 Density.BaseUnit" is equal to "1 MassConcentration.BaseUnit")
+                    options.SetCustomConversion<Density, MassConcentration>());
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, MassConcentration.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Density.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<MassConcentration, MassConcentrationUnit> toQuantityInfo = MassConcentration.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassConcentrationUnit toUnit = toUnitInfo.Value;
+                            MassConcentration expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValueFromUnit);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValueFromUnit);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(MassConcentration.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        MassConcentrationUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<Density, DensityUnit> toQuantityInfo = Density.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            Density expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValueFromUnit);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValueFromUnit);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_ShouldConvertValueToUnitOfAnotherDimensionlessQuantityWithCustomConversion(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options => 
+                    // since both quantities are dimensionless it is assumed that the quantities can be converted using their BaseUnit (i.e. the DecimalFraction)
+                    options.SetCustomConversion<MassFraction, Ratio>());
+            var converter = UnitConverter.Create(new UnitParser([MassFraction.Info, Ratio.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(MassFraction.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        MassFractionUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<Ratio, RatioUnit> toQuantityInfo = Ratio.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            RatioUnit toUnit = toUnitInfo.Value;
+                            Ratio expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(Ratio.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        RatioUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<MassFraction, MassFractionUnit> toQuantityInfo = MassFraction.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassFractionUnit toUnit = toUnitInfo.Value;
+                            MassFraction expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldConvertValueToUnitOfAnotherDimensionlessQuantityWithCustomConversion(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options => 
+                    // since both quantities are dimensionless it is assumed that the quantities can be converted using their BaseUnit (i.e. the DecimalFraction)
+                    options.SetCustomConversion<MassFraction, Ratio>());
+            var converter = UnitConverter.Create(new UnitParser([MassFraction.Info, Ratio.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(MassFraction.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        MassFractionUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<Ratio, RatioUnit> toQuantityInfo = Ratio.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            RatioUnit toUnit = toUnitInfo.Value;
+                            Ratio expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(Ratio.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        RatioUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<MassFraction, MassFractionUnit> toQuantityInfo = MassFraction.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            MassFractionUnit toUnit = toUnitInfo.Value;
+                            MassFraction expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, toQuantityInfo[expectedQuantity.Unit]);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+                            
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_ShouldConvertValueToUnitOfAnotherQuantityWithCustomConversionExpression(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options => options
+                    // since the dimensions / base units are incompatible we have to explicitly specify a conversion expression
+                    .SetCustomConversion<Volume, HowMuch>()
+                    .SetCustomConversion(VolumeUnit.Liter, HowMuchUnit.Some, QuantityValue.One, true));
+            var converter = UnitConverter.Create(new UnitParser([Volume.Info, HowMuch.Info]), convertOptions);
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Volume.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        VolumeUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo toQuantityInfo = HowMuch.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            Enum toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(Volume.Info[VolumeUnit.Liter].GetValueFrom(valueToConvert, fromUnitInfo), toQuantityInfo[HowMuchUnit.Some]);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(HowMuch.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        Enum fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<Volume, VolumeUnit> toQuantityInfo = Volume.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            VolumeUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(HowMuch.Info[HowMuchUnit.Some].GetValueFrom(valueToConvert, fromUnitInfo), toQuantityInfo[VolumeUnit.Liter]);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_ShouldConvertValueToUnitOfAnotherQuantityWithCustomConversionExpression(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options => options
+                    // since the dimensions / base units are incompatible we have to explicitly specify a conversion expression
+                    .SetCustomConversion<Volume, HowMuch>()
+                    .SetCustomConversion(VolumeUnit.Liter, HowMuchUnit.Some, QuantityValue.One, true));
+            var converter = UnitConverter.Create(new UnitParser([Volume.Info, HowMuch.Info]), convertOptions);
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Volume.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        VolumeUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo toQuantityInfo = HowMuch.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            Enum toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(Volume.Info[VolumeUnit.Liter].GetValueFrom(valueToConvert, fromUnitInfo), toQuantityInfo[HowMuchUnit.Some]);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(HowMuch.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        Enum fromUnit = fromUnitInfo.Value;
+                        QuantityInfo<Volume, VolumeUnit> toQuantityInfo = Volume.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            VolumeUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(HowMuch.Info[HowMuchUnit.Some].GetValueFrom(valueToConvert, fromUnitInfo), toQuantityInfo[VolumeUnit.Liter]);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+                            
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_ShouldConvertQuantityToUnitOfAnotherQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Density.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        Density quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        QuantityInfo<SpecificVolume, SpecificVolumeUnit> toQuantityInfo = SpecificVolume.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                            SpecificVolume expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                            // note that passing a unit of another quantity forces us into the IQuantity overload
+                            IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                            Assert.Equal(expectedQuantity, convertedQuantity);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(SpecificVolume.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        SpecificVolume quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        QuantityInfo<Density, DensityUnit> toQuantityInfo = Density.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            Density expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                            // note that passing a unit of another quantity forces us into the IQuantity overload
+                            IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                            Assert.Equal(expectedQuantity, convertedQuantity);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_ShouldConvertQuantityToUnitOfAnotherQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Density.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        Density quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        QuantityInfo<SpecificVolume, SpecificVolumeUnit> toQuantityInfo = SpecificVolume.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                            SpecificVolume expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                            // note that passing a unit of another quantity forces us into the IQuantity overload
+                            IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                            Assert.Equal(expectedQuantity, convertedQuantity);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                        });
+                    });
+                },
+                () =>
+                {
+                    Assert.All(SpecificVolume.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        SpecificVolume quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        QuantityInfo<Density, DensityUnit> toQuantityInfo = Density.Info;
+                        Assert.All(toQuantityInfo.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            Density expectedQuantity = toQuantityInfo.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                            // note that passing a unit of another quantity forces us into the IQuantity overload
+                            IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                            Assert.Equal(expectedQuantity, convertedQuantity);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                        });
+                    });
+                });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_WithCustomConversionExpression_ShouldConvertValueToUnitOfAnotherQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var customConversionFromDensity = new ConversionExpression(new QuantityValue(-1, 2));
+            var customConversionFromSpecificVolume = new ConversionExpression(-2);
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options =>
+                {
+                    options.SetCustomConversion(DensityUnit.MicrogramPerLiter, SpecificVolumeUnit.CubicFootPerPound, customConversionFromDensity);
+                    options.SetCustomConversion(SpecificVolumeUnit.CubicFootPerPound, DensityUnit.MicrogramPerLiter, customConversionFromSpecificVolume);
+                });
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            UnitInfo<Density, DensityUnit> customDensityInfo = Density.Info[DensityUnit.MicrogramPerLiter];
+            UnitInfo<SpecificVolume, SpecificVolumeUnit> customSpecificVolumeInfo = SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound];
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    // when the left unit is the customDensityInfo
+                    DensityUnit fromUnit = customDensityInfo.Value;
+                    Assert.All(SpecificVolume.Info.UnitInfos, toUnitInfo =>
+                    {
+                        SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                        // (123.45, customDensityInfo) => (-123.45/2, customSpecificVolumeInfo) => ConvertValue((-123.45/2, customSpecificVolumeInfo), toUnitInfo)
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromDensity.Evaluate(valueToConvert), customSpecificVolumeInfo);
+
+                        QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                        Assert.Equal(expectedValue, convertedValue);
+                    });
+                },
+                () =>
+                {
+                    // all other density units are also converted using our custom conversion expression
+                    Assert.All(Density.Info.UnitInfos.Where(info => info != customDensityInfo), fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        Assert.All(SpecificVolume.Info.UnitInfos, toUnitInfo =>
+                        {
+                            SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromDensity.Evaluate(customDensityInfo.GetValueFrom(valueToConvert, fromUnitInfo)), customSpecificVolumeInfo);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    // when the left unit is the customSpecificVolumeInfo
+                    SpecificVolumeUnit fromUnit = customSpecificVolumeInfo.Value;
+                    Assert.All(Density.Info.UnitInfos, toUnitInfo =>
+                    {
+                        DensityUnit toUnit = toUnitInfo.Value;
+                        // (123.45, customSpecificVolumeInfo) => (-123.45 * 2, customDensityInfo) => ConvertValue((-123.45 * 2, customDensityInfo), toUnitInfo)
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromSpecificVolume.Evaluate(valueToConvert), customDensityInfo);
+
+                        QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                        Assert.Equal(expectedValue, convertedValue);
+                    });
+                }, () =>
+                {
+                    // all other specific-volume units are also converted using our custom conversion expression
+                    Assert.All(SpecificVolume.Info.UnitInfos.Where(info => info != customSpecificVolumeInfo), fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        Assert.All(Density.Info.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromSpecificVolume.Evaluate(customSpecificVolumeInfo.GetValueFrom(valueToConvert, fromUnitInfo)), customDensityInfo);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertValue_WithCustomConversionFunction_ShouldConvertValueToUnitOfAnotherQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            // note: unlike the ConversionExpression, the overload using a lambda function won't be able to create the same "single-operation" conversions (there is always going to be an extra call to the NestedFunction)
+            ConvertValueDelegate customConversionFromDensity = value => -value / 2;
+            ConvertValueDelegate customConversionFromSpecificVolume = value => -value * 2;
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options =>
+                {
+                    options.SetCustomConversion(DensityUnit.MicrogramPerLiter, SpecificVolumeUnit.CubicFootPerPound, customConversionFromDensity);
+                    options.SetCustomConversion(SpecificVolumeUnit.CubicFootPerPound, DensityUnit.MicrogramPerLiter, customConversionFromSpecificVolume);
+                });
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            UnitInfo<Density, DensityUnit> customDensityInfo = Density.Info[DensityUnit.MicrogramPerLiter];
+            UnitInfo<SpecificVolume, SpecificVolumeUnit> customSpecificVolumeInfo = SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound];
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    // when the left unit is the customDensityInfo
+                    DensityUnit fromUnit = customDensityInfo.Value;
+                    Assert.All(SpecificVolume.Info.UnitInfos, toUnitInfo =>
+                    {
+                        SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                        // (123.45, customDensityInfo) => (-123.45/2, customSpecificVolumeInfo) => ConvertValue((-123.45/2, customSpecificVolumeInfo), toUnitInfo)
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromDensity(valueToConvert), customSpecificVolumeInfo);
+
+                        QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                        Assert.Equal(expectedValue, convertedValue);
+                    });
+                },
+                () =>
+                {
+                    // all other density units are also converted using our custom conversion function
+                    Assert.All(Density.Info.UnitInfos.Where(info => info != customDensityInfo), fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        Assert.All(SpecificVolume.Info.UnitInfos, toUnitInfo =>
+                        {
+                            SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromDensity(customDensityInfo.GetValueFrom(valueToConvert, fromUnitInfo)), customSpecificVolumeInfo);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    // when the left unit is the customSpecificVolumeInfo
+                    SpecificVolumeUnit fromUnit = customSpecificVolumeInfo.Value;
+                    Assert.All(Density.Info.UnitInfos, toUnitInfo =>
+                    {
+                        DensityUnit toUnit = toUnitInfo.Value;
+                        // (123.45, customSpecificVolumeInfo) => (-123.45 * 2, customDensityInfo) => ConvertValue((-123.45 * 2, customDensityInfo), toUnitInfo)
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromSpecificVolume(valueToConvert), customDensityInfo);
+
+                        QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                        Assert.Equal(expectedValue, convertedValue);
+                    });
+                }, () =>
+                {
+                    // all other specific-volume units are also converted using our custom conversion function
+                    Assert.All(SpecificVolume.Info.UnitInfos.Where(info => info != customSpecificVolumeInfo), fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        Assert.All(Density.Info.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromSpecificVolume(customSpecificVolumeInfo.GetValueFrom(valueToConvert, fromUnitInfo)), customDensityInfo);
+
+                            QuantityValue convertedValue = converter.ConvertValue(valueToConvert, fromUnit, toUnit);
+
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertValue_WithCustomConversionExpression_ShouldConvertValueToUnitOfAnotherQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var customConversionFromDensity = new ConversionExpression(new QuantityValue(-1, 2));
+            var customConversionFromSpecificVolume = new ConversionExpression(-2);
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options =>
+                {
+                    options.SetCustomConversion(DensityUnit.MicrogramPerLiter, SpecificVolumeUnit.CubicFootPerPound, customConversionFromDensity);
+                    options.SetCustomConversion(SpecificVolumeUnit.CubicFootPerPound, DensityUnit.MicrogramPerLiter, customConversionFromSpecificVolume);
+                });
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            UnitInfo<Density, DensityUnit> customDensityInfo = Density.Info[DensityUnit.MicrogramPerLiter];
+            UnitInfo<SpecificVolume, SpecificVolumeUnit> customSpecificVolumeInfo = SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound];
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    // when the left unit is the customDensityInfo
+                    DensityUnit fromUnit = customDensityInfo.Value;
+                    Assert.All(SpecificVolume.Info.UnitInfos, toUnitInfo =>
+                    {
+                        SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                        // (123.45, customDensityInfo) => (-123.45/2, customSpecificVolumeInfo) => ConvertValue((-123.45/2, customSpecificVolumeInfo), toUnitInfo)
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromDensity.Evaluate(valueToConvert), customSpecificVolumeInfo);
+
+                        var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+
+                        Assert.True(success);
+                        Assert.Equal(expectedValue, convertedValue);
+                    });
+                },
+                () =>
+                {
+                    // all other density units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(Density.Info.UnitInfos.Where(info => info != customDensityInfo), fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        Assert.All(SpecificVolume.Info.UnitInfos, toUnitInfo =>
+                        {
+                            SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromDensity.Evaluate(customDensityInfo.GetValueFrom(valueToConvert, fromUnitInfo)), customSpecificVolumeInfo);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                },
+                () =>
+                {
+                    // when the left unit is the customSpecificVolumeInfo
+                    SpecificVolumeUnit fromUnit = customSpecificVolumeInfo.Value;
+                    Assert.All(Density.Info.UnitInfos, toUnitInfo =>
+                    {
+                        DensityUnit toUnit = toUnitInfo.Value;
+                        // (123.45, customSpecificVolumeInfo) => (-123.45 * 2, customDensityInfo) => ConvertValue((-123.45 * 2, customDensityInfo), toUnitInfo)
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromSpecificVolume.Evaluate(valueToConvert), customDensityInfo);
+
+                        var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+
+                        Assert.True(success);
+                        Assert.Equal(expectedValue, convertedValue);
+                    });
+                }, () =>
+                {
+                    // all other specific-volume units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(SpecificVolume.Info.UnitInfos.Where(info => info != customSpecificVolumeInfo), fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        Assert.All(Density.Info.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromSpecificVolume.Evaluate(customSpecificVolumeInfo.GetValueFrom(valueToConvert, fromUnitInfo)), customDensityInfo);
+
+                            var success = converter.TryConvertValue(valueToConvert, fromUnit, toUnit, out QuantityValue convertedValue);
+
+                            Assert.True(success);
+                            Assert.Equal(expectedValue, convertedValue);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_WithCustomConversionExpression_ShouldConvertQuantityToUnitOfAnotherQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var customConversionFromDensity = new ConversionExpression(new QuantityValue(-1, 2));
+            var customConversionFromSpecificVolume = new ConversionExpression(-2);
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options =>
+                {
+                    options.SetCustomConversion(DensityUnit.MicrogramPerLiter, SpecificVolumeUnit.CubicFootPerPound, customConversionFromDensity);
+                    options.SetCustomConversion(SpecificVolumeUnit.CubicFootPerPound, DensityUnit.MicrogramPerLiter, customConversionFromSpecificVolume);
+                });
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            UnitInfo<Density, DensityUnit> customDensityInfo = Density.Info[DensityUnit.MicrogramPerLiter];
+            UnitInfo<SpecificVolume, SpecificVolumeUnit> customSpecificVolumeInfo = SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound];
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    // when the left unit is the customDensityInfo
+                    Density quantityToConvert = customDensityInfo.From(valueToConvert);
+                    Assert.All(SpecificVolume.Info.UnitInfos, toUnitInfo =>
+                    {
+                        SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                        // (123.45, customDensityInfo) => (-123.45/2, customSpecificVolumeInfo) => ConvertValue((-123.45/2, customSpecificVolumeInfo), toUnitInfo)
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromDensity.Evaluate(valueToConvert), customSpecificVolumeInfo);
+
+                        IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                        Assert.IsType<SpecificVolume>(convertedQuantity);
+                        Assert.Equal(toUnit, convertedQuantity.Unit);
+                        Assert.Equal(expectedValue, convertedQuantity.Value);
+                    });
+                },
+                () =>
+                {
+                    // all other density units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(Density.Info.UnitInfos.Where(info => info != customDensityInfo), fromUnitInfo =>
+                    {
+                        Density quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        Assert.All(SpecificVolume.Info.UnitInfos, toUnitInfo =>
+                        {
+                            SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                            SpecificVolume expectedQuantity = customSpecificVolumeInfo.From(customConversionFromDensity.Evaluate(customDensityInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, customSpecificVolumeInfo);
+
+                            IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                            Assert.IsType<SpecificVolume>(convertedQuantity);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                },
+                () =>
+                {
+                    // when the left unit is the customSpecificVolumeInfo
+                    SpecificVolume quantityToConvert = customSpecificVolumeInfo.From(valueToConvert);
+                    Assert.All(Density.Info.UnitInfos, toUnitInfo =>
+                    {
+                        DensityUnit toUnit = toUnitInfo.Value;
+                        // (123.45, customSpecificVolumeInfo) => (-123.45 * 2, customDensityInfo) => ConvertValue((-123.45 * 2, customDensityInfo), toUnitInfo)
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromSpecificVolume.Evaluate(valueToConvert), customDensityInfo);
+
+                        IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                        Assert.IsType<Density>(convertedQuantity);
+                        Assert.Equal(toUnit, convertedQuantity.Unit);
+                        Assert.Equal(expectedValue, convertedQuantity.Value);
+                    });
+                }, () =>
+                {
+                    // all other specific-volume units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(SpecificVolume.Info.UnitInfos.Where(info => info != customSpecificVolumeInfo), fromUnitInfo =>
+                    {
+                        SpecificVolume quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        Assert.All(Density.Info.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            Density expectedQuantity = customDensityInfo.From(customConversionFromSpecificVolume.Evaluate(customSpecificVolumeInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, customDensityInfo);
+
+                            IQuantity convertedQuantity = converter.ConvertTo(quantityToConvert, toUnit);
+
+                            Assert.IsType<Density>(convertedQuantity);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_WithCustomConversionExpression_ShouldConvertQuantityToUnitOfAnotherQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var customConversionFromDensity = new ConversionExpression(new QuantityValue(-1, 2));
+            var customConversionFromSpecificVolume = new ConversionExpression(-2);
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options =>
+                {
+                    options.SetCustomConversion(DensityUnit.MicrogramPerLiter, SpecificVolumeUnit.CubicFootPerPound, customConversionFromDensity);
+                    options.SetCustomConversion(SpecificVolumeUnit.CubicFootPerPound, DensityUnit.MicrogramPerLiter, customConversionFromSpecificVolume);
+                });
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            UnitInfo<Density, DensityUnit> customDensityInfo = Density.Info[DensityUnit.MicrogramPerLiter];
+            UnitInfo<SpecificVolume, SpecificVolumeUnit> customSpecificVolumeInfo = SpecificVolume.Info[SpecificVolumeUnit.CubicFootPerPound];
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    // when the left unit is the customDensityInfo
+                    Density quantityToConvert = customDensityInfo.From(valueToConvert);
+                    Assert.All(SpecificVolume.Info.UnitInfos, toUnitInfo =>
+                    {
+                        SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                        // (123.45, customDensityInfo) => (-123.45/2, customSpecificVolumeInfo) => ConvertValue((-123.45/2, customSpecificVolumeInfo), toUnitInfo)
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromDensity.Evaluate(valueToConvert), customSpecificVolumeInfo);
+                        
+                        var success = converter.TryConvertTo(quantityToConvert, toUnit, out IQuantity? convertedQuantity);
+
+                        Assert.True(success);
+                        Assert.IsType<SpecificVolume>(convertedQuantity);
+                        Assert.Equal(toUnit, convertedQuantity.Unit);
+                        Assert.Equal(expectedValue, convertedQuantity.Value);
+                    });
+                },
+                () =>
+                {
+                    // all other density units are also converted using our custom conversion expression
+                    Assert.All(Density.Info.UnitInfos.Where(info => info != customDensityInfo), fromUnitInfo =>
+                    {
+                        Density quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        Assert.All(SpecificVolume.Info.UnitInfos, toUnitInfo =>
+                        {
+                            SpecificVolumeUnit toUnit = toUnitInfo.Value;
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromDensity.Evaluate(customDensityInfo.GetValueFrom(valueToConvert, fromUnitInfo)), customSpecificVolumeInfo);
+                            
+                            var success = converter.TryConvertTo(quantityToConvert, toUnit, out IQuantity? convertedQuantity);
+
+                            Assert.True(success);
+                            Assert.IsType<SpecificVolume>(convertedQuantity);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                },
+                () =>
+                {
+                    // when the left unit is the customSpecificVolumeInfo
+                    SpecificVolume quantityToConvert = customSpecificVolumeInfo.From(valueToConvert);
+                    Assert.All(Density.Info.UnitInfos, toUnitInfo =>
+                    {
+                        DensityUnit toUnit = toUnitInfo.Value;
+                        // (123.45, customSpecificVolumeInfo) => (-123.45 * 2, customDensityInfo) => ConvertValue((-123.45 * 2, customDensityInfo), toUnitInfo)
+                        QuantityValue expectedValue = toUnitInfo.GetValueFrom(customConversionFromSpecificVolume.Evaluate(valueToConvert), customDensityInfo);
+                        
+                        var success = converter.TryConvertTo(quantityToConvert, toUnit, out IQuantity? convertedQuantity);
+
+                        Assert.True(success);
+                        Assert.IsType<Density>(convertedQuantity);
+                        Assert.Equal(toUnit, convertedQuantity.Unit);
+                        Assert.Equal(expectedValue, convertedQuantity.Value);
+                    });
+                }, () =>
+                {
+                    // all other specific-volume units are also converted using our custom conversion expression
+                    Assert.All(SpecificVolume.Info.UnitInfos.Where(info => info != customSpecificVolumeInfo), fromUnitInfo =>
+                    {
+                        SpecificVolume quantityToConvert = fromUnitInfo.From(valueToConvert);
+                        Assert.All(Density.Info.UnitInfos, toUnitInfo =>
+                        {
+                            DensityUnit toUnit = toUnitInfo.Value;
+                            Density expectedQuantity = customDensityInfo.From(customConversionFromSpecificVolume.Evaluate(customSpecificVolumeInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                            QuantityValue expectedValue = toUnitInfo.GetValueFrom(expectedQuantity.Value, customDensityInfo);
+                            
+                            var success = converter.TryConvertTo(quantityToConvert, toUnit, out IQuantity? convertedQuantity);
+
+                            Assert.True(success);
+                            Assert.IsType<Density>(convertedQuantity);
+                            Assert.Equal(toUnit, convertedQuantity.Unit);
+                            Assert.Equal(expectedValue, convertedQuantity.Value);
+                        });
+                    });
+                });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_TargetQuantityInfo_ShouldConvertQuantityToTargetQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Density.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        SpecificVolume expectedQuantity = SpecificVolume.Info.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                        SpecificVolume convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, SpecificVolume.Info);
+
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                },
+                () =>
+                {
+                    Assert.All(SpecificVolume.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        Density expectedQuantity = Density.Info.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                        Density convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, Density.Info);
+
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                });
+        }
+       
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_TargetIQuantityInfo_ShouldConvertQuantityToTargetIQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Density.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo targetQuantityInfo = SpecificVolume.Info;
+                        SpecificVolume expectedQuantity = SpecificVolume.Info.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                        IQuantity convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, targetQuantityInfo);
+
+                        Assert.IsType<SpecificVolume>(convertedQuantity);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                },
+                () =>
+                {
+                    Assert.All(SpecificVolume.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo targetQuantityInfo = Density.Info;
+                        Density expectedQuantity = Density.Info.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                        IQuantity convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, targetQuantityInfo);
+
+                        Assert.IsType<Density>(convertedQuantity);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_TargetQuantityInfo_FromUnknownUnit_ShouldThrow_UnitNotFoundException(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info]), convertOptions);
+            
+            Assert.Throws<UnitNotFoundException>(() => converter.ConvertTo(1, SpecificVolumeUnit.CubicMeterPerKilogram, Density.Info));
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_TargetQuantityInfo_FromUnknownQuantity_ShouldThrow_InvalidConversionException(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info]), convertOptions);
+            
+            Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(1, DensityUnit.KilogramPerCubicMeter, SpecificVolume.Info));
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_TargetIQuantityInfo_FromUnknownUnit_ShouldThrow_UnitNotFoundException(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info]), convertOptions);
+            QuantityInfo targetQuantityInfo = Density.Info;
+            
+            Assert.Throws<UnitNotFoundException>(() => converter.ConvertTo(1, SpecificVolumeUnit.CubicMeterPerKilogram, targetQuantityInfo));
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_TargetIQuantityInfo_FromUnknownQuantity_ShouldThrow_InvalidConversionException(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info]), convertOptions);
+            QuantityInfo targetQuantityInfo = SpecificVolume.Info;
+            
+            Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(1, DensityUnit.KilogramPerCubicMeter, targetQuantityInfo));
+        }
+
+        [Fact]
+        public void ConvertTo_TargetQuantityInfo_WithUnsupportedConversion_ShouldThrow_InvalidConversionException()
+        {
+            QuantityConversionOptions invalidConversionOptions = new QuantityConversionOptions().SetCustomConversion<Density, Mass>();
+            // converter options with a custom conversion which cannot be deduced from the dimensions of the quantities (an explicit conversion function is required)
+            Assert.All(GetQuantityConverterBuildOptions().Where(x => x.DefaultCachingMode == ConversionCachingMode.None)
+                    .Select(options => options.WithImplicitConversionOptions(invalidConversionOptions)),
+                convertOptions =>
+                {
+                    // this is not ideal, but since we aren't creating any conversion functions: no exception is thrown from the Create method
+                    var converter = UnitConverter.Create(new UnitParser([Density.Info, Mass.Info]), convertOptions);
+                    // the invalid conversion is only detected when attempting to convert "on the fly"
+                    Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(1, DensityUnit.KilogramPerCubicMeter, Mass.Info));
+                    Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(1, MassUnit.Gram, Density.Info));
+                });
+        }
+
+        [Fact]
+        public void ConvertTo_TargetIQuantityInfo_WithUnsupportedConversion_ShouldThrow_InvalidConversionException()
+        {
+            QuantityConversionOptions invalidConversionOptions = new QuantityConversionOptions().SetCustomConversion<Density, Mass>();
+            // converter options with a custom conversion which cannot be deduced from the dimensions of the quantities (an explicit conversion function is required)
+            Assert.All(GetQuantityConverterBuildOptions().Where(x => x.DefaultCachingMode == ConversionCachingMode.None)
+                    .Select(options => options.WithImplicitConversionOptions(invalidConversionOptions)),
+                convertOptions =>
+                {
+                    // this is not ideal, but since we aren't creating any conversion functions: no exception is thrown from the Create method
+                    var converter = UnitConverter.Create(new UnitParser([Density.Info, Mass.Info]), convertOptions);
+                    // the invalid conversion is only detected when attempting to convert "on the fly"
+                    Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(1, DensityUnit.KilogramPerCubicMeter, (QuantityInfo)Mass.Info));
+                    Assert.Throws<InvalidConversionException>(() => converter.ConvertTo(1, MassUnit.Gram, (QuantityInfo)Density.Info));
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void Create_WithCachingAndUnsupportedConversionUnits_ShouldThrow_InvalidConversionException(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            // converter options with a custom conversion unit-mapping which cannot be deduced from the dimensions of the quantities (an explicit conversion function is required)
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(conversionOptions => conversionOptions
+                    .SetCustomConversion<Density, Mass>() // this is optional
+                    .SetConversionUnits(DensityUnit.KilogramPerCubicMeter, MassUnit.Kilogram));
+
+            Assert.Throws<InvalidConversionException>(() => UnitConverter.Create(new UnitParser([Density.Info, Mass.Info]), convertOptions));
+        }
+
+        [Fact]
+        public void Create_WithCachingAndUnsupportedConversion_ShouldThrow_InvalidConversionException()
+        {
+            // converter options with a custom conversion which cannot be deduced from the dimensions of the quantities (an explicit conversion function is required)
+            Assert.All(GetQuantityConverterBuildOptions().Where(x => x.DefaultCachingMode != ConversionCachingMode.None)
+                    .Select(options => options.WithImplicitConversionOptions(conversionOptions => conversionOptions.SetCustomConversion<Density, Mass>())),
+                convertOptions =>
+                {
+                    Assert.Throws<InvalidConversionException>(() => UnitConverter.Create(new UnitParser([Density.Info, Mass.Info]), convertOptions));
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_TargetQuantityInfo_FromUnknownUnit_ReturnFalse(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info]), convertOptions);
+
+            var success = converter.TryConvertTo(1, SpecificVolumeUnit.CubicMeterPerKilogram, Density.Info, out _);
+                        
+            Assert.False(success);
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_TargetIQuantityInfo_FromUnknownUnit_ReturnFalse(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info]), convertOptions);
+
+            var success = converter.TryConvertTo(1, SpecificVolumeUnit.CubicMeterPerKilogram, (QuantityInfo)Density.Info, out _);
+                        
+            Assert.False(success);
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_TargetQuantityInfo_FromUnknownQuantity_ReturnFalse(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info]), convertOptions);
+
+            var success = converter.TryConvertTo(1, DensityUnit.KilogramPerCubicMeter, SpecificVolume.Info, out _);
+                        
+            Assert.False(success);
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_TargetIQuantityInfo_FromUnknownQuantity_ReturnFalse(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info]), convertOptions);
+
+            var success = converter.TryConvertTo(1, DensityUnit.KilogramPerCubicMeter, (QuantityInfo)SpecificVolume.Info, out _);
+                        
+            Assert.False(success);
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_TargetQuantityInfo_WithUnknownRelation_ReturnFalse(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, MassConcentration.Info]), convertOptions);
+
+            Assert.False(converter.TryConvertTo(1, DensityUnit.KilogramPerCubicMeter, MassConcentration.Info, out _));
+            Assert.False(converter.TryConvertTo(1, MassConcentrationUnit.KilogramPerCubicMeter, Density.Info, out _));
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_TargetIQuantityInfo_WithUnknownRelation_ReturnFalse(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, MassConcentration.Info]), convertOptions);
+
+            Assert.False(converter.TryConvertTo(1, DensityUnit.KilogramPerCubicMeter, (QuantityInfo)MassConcentration.Info, out _));
+            Assert.False(converter.TryConvertTo(1, MassConcentrationUnit.KilogramPerCubicMeter, (QuantityInfo)Density.Info, out _));
+        }
+
+        [Fact]
+        public void TryConvertTo_TargetQuantityInfo_WithUnsupportedConversion_ShouldReturnFalse()
+        {
+            Assert.All(GetQuantityConverterBuildOptions().Where(x => x.DefaultCachingMode == ConversionCachingMode.None)
+                    .Select(options => options.WithImplicitConversionOptions(conversionOptions => conversionOptions.SetCustomConversion<Density, Mass>())),
+                convertOptions =>
+                {
+                    // this is not ideal, but since we aren't creating any conversion functions: no exception is thrown from the Create method
+                    var converter = UnitConverter.Create(new UnitParser([Density.Info, Mass.Info]), convertOptions);
+                    // all subsequent attempts to use the invalid conversions would fail
+                    Assert.Multiple(() =>
+                    {
+                        var success = converter.TryConvertTo(1, MassUnit.Kilogram, Density.Info, out _);
+
+                        Assert.False(success);
+                    }, () =>
+                    {
+                        var success = converter.TryConvertTo(1, DensityUnit.KilogramPerLiter, Mass.Info, out _);
+
+                        Assert.False(success);
+                    });
+                });
+        }
+
+        [Fact]
+        public void TryConvertTo_TargetIQuantityInfo_WithUnsupportedConversion_ShouldReturnFalse()
+        {
+            Assert.All(GetQuantityConverterBuildOptions().Where(x => x.DefaultCachingMode == ConversionCachingMode.None)
+                    .Select(options => options.WithImplicitConversionOptions(conversionOptions => conversionOptions.SetCustomConversion<Density, Mass>())),
+                convertOptions =>
+                {
+                    // this is not ideal, but since we aren't creating any conversion functions: no exception is thrown from the Create method
+                    var converter = UnitConverter.Create(new UnitParser([Density.Info, Mass.Info]), convertOptions);
+                    // all subsequent attempts to use the invalid conversions would fail
+                    Assert.Multiple(() =>
+                    {
+                        var success = converter.TryConvertTo(1, MassUnit.Kilogram, (QuantityInfo)Density.Info, out _);
+
+                        Assert.False(success);
+                    }, () =>
+                    {
+                        var success = converter.TryConvertTo(1, DensityUnit.KilogramPerLiter, (QuantityInfo)Mass.Info, out _);
+
+                        Assert.False(success);
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_TargetQuantityInfo_ShouldConvertQuantityToTargetQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Density.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        SpecificVolume expectedQuantity = SpecificVolume.Info.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                        var success = converter.TryConvertTo(valueToConvert, fromUnit, SpecificVolume.Info, out SpecificVolume convertedQuantity);
+
+                        Assert.True(success);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                },
+                () =>
+                {
+                    Assert.All(SpecificVolume.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        Density expectedQuantity = Density.Info.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                        var success = converter.TryConvertTo(valueToConvert, fromUnit, Density.Info, out Density convertedQuantity);
+                        
+                        Assert.True(success);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                });
+        }
+       
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_TargetIQuantityInfo_ShouldConvertQuantityToTargetIQuantity(bool freeze, ConversionCachingMode cachingMode, bool reduceConstants)
+        {
+            var convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants);
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    Assert.All(Density.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo targetQuantityInfo = SpecificVolume.Info;
+                        SpecificVolume expectedQuantity = SpecificVolume.Info.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                        var success = converter.TryConvertTo(valueToConvert, fromUnit, targetQuantityInfo, out IQuantity? convertedQuantity);
+
+                        Assert.True(success);
+                        Assert.IsType<SpecificVolume>(convertedQuantity);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                },
+                () =>
+                {
+                    Assert.All(SpecificVolume.Info.UnitInfos, fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo targetQuantityInfo = Density.Info;
+                        Density expectedQuantity = Density.Info.ConvertFrom(valueToConvert, fromUnitInfo);
+
+                        var success = converter.TryConvertTo(valueToConvert, fromUnit, targetQuantityInfo, out IQuantity? convertedQuantity);
+                        
+                        Assert.True(success);
+                        Assert.IsType<Density>(convertedQuantity);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                });
+        }
+        
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_TargetQuantityInfo_WithCustomConversionExpression_ShouldConvertQuantityToTargetQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            DensityUnit customDensityUnit = DensityUnit.MicrogramPerLiter;
+            SpecificVolumeUnit customSpecificVolumeUnit = SpecificVolumeUnit.CubicFootPerPound;
+            var customConversionFromDensity = new ConversionExpression(new QuantityValue(-1, 2));
+            var customConversionFromSpecificVolume = new ConversionExpression(-2);
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options =>
+                {
+                    options.SetCustomConversion(customDensityUnit, customSpecificVolumeUnit, customConversionFromDensity);
+                    options.SetCustomConversion(customSpecificVolumeUnit, customDensityUnit, customConversionFromSpecificVolume);
+                });
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            UnitInfo<Density, DensityUnit> customDensityInfo = Density.Info[customDensityUnit];
+            UnitInfo<SpecificVolume, SpecificVolumeUnit> customSpecificVolumeInfo = SpecificVolume.Info[customSpecificVolumeUnit];
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    // when the left unit is the customDensityInfo
+                    DensityUnit fromUnit = customDensityInfo.Value;
+                    // (123.45, customDensityInfo) => (-123.45/2, customSpecificVolumeInfo) => ConvertValue((-123.45/2, customSpecificVolumeInfo), toUnitInfo)
+                    QuantityValue expectedValue = customSpecificVolumeInfo.GetValueFrom(customConversionFromDensity.Evaluate(valueToConvert), customSpecificVolumeInfo);
+                   
+                    SpecificVolume convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, SpecificVolume.Info);
+
+                    Assert.Equal(customSpecificVolumeUnit, convertedQuantity.Unit);
+                    Assert.Equal(expectedValue, convertedQuantity.Value);
+                },
+                () =>
+                {
+                    // all other density units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(Density.Info.UnitInfos.Where(info => info != customDensityInfo), fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        SpecificVolume expectedQuantity = customSpecificVolumeInfo.From(customConversionFromDensity.Evaluate(customDensityInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                        
+                        SpecificVolume convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, SpecificVolume.Info);
+
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                },
+                () =>
+                {
+                    // when the left unit is the customSpecificVolumeInfo
+                    SpecificVolumeUnit fromUnit = customSpecificVolumeInfo.Value;
+                    // (123.45, customSpecificVolumeInfo) => (-123.45 * 2, customDensityInfo) => ConvertValue((-123.45 * 2, customDensityInfo), toUnitInfo)
+                    QuantityValue expectedValue = customDensityInfo.GetValueFrom(customConversionFromSpecificVolume.Evaluate(valueToConvert), customDensityInfo);
+
+                    Density convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, Density.Info);
+
+                    Assert.Equal(customDensityUnit, convertedQuantity.Unit);
+                    Assert.Equal(expectedValue, convertedQuantity.Value);
+                }, () =>
+                {
+                    // all other specific-volume units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(SpecificVolume.Info.UnitInfos.Where(info => info != customSpecificVolumeInfo), fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        Density expectedQuantity = customDensityInfo.From(customConversionFromSpecificVolume.Evaluate(customSpecificVolumeInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                            
+                        Density convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, Density.Info);
+
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void ConvertTo_TargetIQuantityInfo_WithCustomConversionExpression_ShouldConvertQuantityToTargetIQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            DensityUnit customDensityUnit = DensityUnit.MicrogramPerLiter;
+            SpecificVolumeUnit customSpecificVolumeUnit = SpecificVolumeUnit.CubicFootPerPound;
+            var customConversionFromDensity = new ConversionExpression(new QuantityValue(-1, 2));
+            var customConversionFromSpecificVolume = new ConversionExpression(-2);
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options =>
+                {
+                    options.SetCustomConversion(customDensityUnit, customSpecificVolumeUnit, customConversionFromDensity);
+                    options.SetCustomConversion(customSpecificVolumeUnit, customDensityUnit, customConversionFromSpecificVolume);
+                });
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            UnitInfo<Density, DensityUnit> customDensityInfo = Density.Info[customDensityUnit];
+            UnitInfo<SpecificVolume, SpecificVolumeUnit> customSpecificVolumeInfo = SpecificVolume.Info[customSpecificVolumeUnit];
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    // when the left unit is the customDensityInfo
+                    DensityUnit fromUnit = customDensityInfo.Value;
+                    QuantityInfo targetQuantityInfo = SpecificVolume.Info;
+                    // (123.45, customDensityInfo) => (-123.45/2, customSpecificVolumeInfo) => ConvertValue((-123.45/2, customSpecificVolumeInfo), toUnitInfo)
+                    QuantityValue expectedValue = customSpecificVolumeInfo.GetValueFrom(customConversionFromDensity.Evaluate(valueToConvert), customSpecificVolumeInfo);
+
+                    IQuantity convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, targetQuantityInfo);
+                    
+                    Assert.IsType<SpecificVolume>(convertedQuantity);
+                    Assert.Equal(customSpecificVolumeUnit, convertedQuantity.Unit);
+                    Assert.Equal(expectedValue, convertedQuantity.Value);
+                },
+                () =>
+                {
+                    // all other density units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(Density.Info.UnitInfos.Where(info => info != customDensityInfo), fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo targetQuantityInfo = SpecificVolume.Info;
+                        SpecificVolume expectedQuantity = customSpecificVolumeInfo.From(customConversionFromDensity.Evaluate(customDensityInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                        
+                        IQuantity convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, targetQuantityInfo);
+                        
+                        Assert.IsType<SpecificVolume>(convertedQuantity);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                },
+                () =>
+                {
+                    // when the left unit is the customSpecificVolumeInfo
+                    SpecificVolumeUnit fromUnit = customSpecificVolumeInfo.Value;
+                    QuantityInfo targetQuantityInfo = Density.Info;
+                    // (123.45, customSpecificVolumeInfo) => (-123.45 * 2, customDensityInfo) => ConvertValue((-123.45 * 2, customDensityInfo), toUnitInfo)
+                    QuantityValue expectedValue = customDensityInfo.GetValueFrom(customConversionFromSpecificVolume.Evaluate(valueToConvert), customDensityInfo);
+
+                    IQuantity convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, targetQuantityInfo);
+                    
+                    Assert.IsType<Density>(convertedQuantity);
+                    Assert.Equal(customDensityUnit, convertedQuantity.Unit);
+                    Assert.Equal(expectedValue, convertedQuantity.Value);
+                }, () =>
+                {
+                    // all other specific-volume units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(SpecificVolume.Info.UnitInfos.Where(info => info != customSpecificVolumeInfo), fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo targetQuantityInfo = Density.Info;
+                        Density expectedQuantity = customDensityInfo.From(customConversionFromSpecificVolume.Evaluate(customSpecificVolumeInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                            
+                        IQuantity convertedQuantity = converter.ConvertTo(valueToConvert, fromUnit, targetQuantityInfo);
+                        
+                        Assert.IsType<Density>(convertedQuantity);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_TargetQuantityInfo_WithCustomConversionExpression_ShouldConvertQuantityToTargetQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            DensityUnit customDensityUnit = DensityUnit.MicrogramPerLiter;
+            SpecificVolumeUnit customSpecificVolumeUnit = SpecificVolumeUnit.CubicFootPerPound;
+            var customConversionFromDensity = new ConversionExpression(new QuantityValue(-1, 2));
+            var customConversionFromSpecificVolume = new ConversionExpression(-2);
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options =>
+                {
+                    options.SetCustomConversion(customDensityUnit, customSpecificVolumeUnit, customConversionFromDensity);
+                    options.SetCustomConversion(customSpecificVolumeUnit, customDensityUnit, customConversionFromSpecificVolume);
+                });
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            UnitInfo<Density, DensityUnit> customDensityInfo = Density.Info[customDensityUnit];
+            UnitInfo<SpecificVolume, SpecificVolumeUnit> customSpecificVolumeInfo = SpecificVolume.Info[customSpecificVolumeUnit];
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    // when the left unit is the customDensityInfo
+                    DensityUnit fromUnit = customDensityInfo.Value;
+                    // (123.45, customDensityInfo) => (-123.45/2, customSpecificVolumeInfo) => ConvertValue((-123.45/2, customSpecificVolumeInfo), toUnitInfo)
+                    QuantityValue expectedValue = customSpecificVolumeInfo.GetValueFrom(customConversionFromDensity.Evaluate(valueToConvert), customSpecificVolumeInfo);
+                   
+                    var success = converter.TryConvertTo(valueToConvert, fromUnit, SpecificVolume.Info, out SpecificVolume convertedQuantity);
+
+                    Assert.True(success);
+                    Assert.Equal(customSpecificVolumeUnit, convertedQuantity.Unit);
+                    Assert.Equal(expectedValue, convertedQuantity.Value);
+                },
+                () =>
+                {
+                    // all other density units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(Density.Info.UnitInfos.Where(info => info != customDensityInfo), fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        SpecificVolume expectedQuantity = customSpecificVolumeInfo.From(customConversionFromDensity.Evaluate(customDensityInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                        
+                        var success = converter.TryConvertTo(valueToConvert, fromUnit, SpecificVolume.Info, out SpecificVolume convertedQuantity);
+
+                        Assert.True(success);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                },
+                () =>
+                {
+                    // when the left unit is the customSpecificVolumeInfo
+                    SpecificVolumeUnit fromUnit = customSpecificVolumeInfo.Value;
+                    // (123.45, customSpecificVolumeInfo) => (-123.45 * 2, customDensityInfo) => ConvertValue((-123.45 * 2, customDensityInfo), toUnitInfo)
+                    QuantityValue expectedValue = customDensityInfo.GetValueFrom(customConversionFromSpecificVolume.Evaluate(valueToConvert), customDensityInfo);
+
+                    var success = converter.TryConvertTo(valueToConvert, fromUnit, Density.Info, out Density convertedQuantity);
+                    
+                    Assert.True(success);
+                    Assert.Equal(customDensityUnit, convertedQuantity.Unit);
+                    Assert.Equal(expectedValue, convertedQuantity.Value);
+                }, () =>
+                {
+                    // all other specific-volume units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(SpecificVolume.Info.UnitInfos.Where(info => info != customSpecificVolumeInfo), fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        Density expectedQuantity = customDensityInfo.From(customConversionFromSpecificVolume.Evaluate(customSpecificVolumeInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                            
+                        var success = converter.TryConvertTo(valueToConvert, fromUnit, Density.Info, out Density convertedQuantity);
+                    
+                        Assert.True(success);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                });
+        }
+
+        [Theory]
+        [MemberData(nameof(ConverterTestOptions))]
+        public void TryConvertTo_TargetIQuantityInfo_WithCustomConversionExpression_ShouldConvertQuantityToTargetIQuantity(bool freeze, ConversionCachingMode cachingMode,
+            bool reduceConstants)
+        {
+            DensityUnit customDensityUnit = DensityUnit.MicrogramPerLiter;
+            SpecificVolumeUnit customSpecificVolumeUnit = SpecificVolumeUnit.CubicFootPerPound;
+            var customConversionFromDensity = new ConversionExpression(new QuantityValue(-1, 2));
+            var customConversionFromSpecificVolume = new ConversionExpression(-2);
+            QuantityConverterBuildOptions convertOptions = new QuantityConverterBuildOptions(freeze, cachingMode, reduceConstants)
+                .WithImplicitConversionOptions(options =>
+                {
+                    options.SetCustomConversion(customDensityUnit, customSpecificVolumeUnit, customConversionFromDensity);
+                    options.SetCustomConversion(customSpecificVolumeUnit, customDensityUnit, customConversionFromSpecificVolume);
+                });
+            var converter = UnitConverter.Create(new UnitParser([Density.Info, SpecificVolume.Info]), convertOptions);
+
+            UnitInfo<Density, DensityUnit> customDensityInfo = Density.Info[customDensityUnit];
+            UnitInfo<SpecificVolume, SpecificVolumeUnit> customSpecificVolumeInfo = SpecificVolume.Info[customSpecificVolumeUnit];
+            QuantityValue valueToConvert = 123.45m;
+            Assert.Multiple(() =>
+                {
+                    // when the left unit is the customDensityInfo
+                    DensityUnit fromUnit = customDensityInfo.Value;
+                    QuantityInfo targetQuantityInfo = SpecificVolume.Info;
+                    // (123.45, customDensityInfo) => (-123.45/2, customSpecificVolumeInfo) => ConvertValue((-123.45/2, customSpecificVolumeInfo), toUnitInfo)
+                    QuantityValue expectedValue = customSpecificVolumeInfo.GetValueFrom(customConversionFromDensity.Evaluate(valueToConvert), customSpecificVolumeInfo);
+
+                    var success = converter.TryConvertTo(valueToConvert, fromUnit, targetQuantityInfo, out IQuantity? convertedQuantity);
+
+                    Assert.True(success);
+                    Assert.IsType<SpecificVolume>(convertedQuantity);
+                    Assert.Equal(customSpecificVolumeUnit, convertedQuantity.Unit);
+                    Assert.Equal(expectedValue, convertedQuantity.Value);
+                },
+                () =>
+                {
+                    // all other density units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(Density.Info.UnitInfos.Where(info => info != customDensityInfo), fromUnitInfo =>
+                    {
+                        DensityUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo targetQuantityInfo = SpecificVolume.Info;
+                        SpecificVolume expectedQuantity = customSpecificVolumeInfo.From(customConversionFromDensity.Evaluate(customDensityInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                        
+                        var success = converter.TryConvertTo(valueToConvert, fromUnit, targetQuantityInfo, out IQuantity? convertedQuantity);
+
+                        Assert.True(success);
+                        Assert.IsType<SpecificVolume>(convertedQuantity);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                },
+                () =>
+                {
+                    // when the left unit is the customSpecificVolumeInfo
+                    SpecificVolumeUnit fromUnit = customSpecificVolumeInfo.Value;
+                    QuantityInfo targetQuantityInfo = Density.Info;
+                    // (123.45, customSpecificVolumeInfo) => (-123.45 * 2, customDensityInfo) => ConvertValue((-123.45 * 2, customDensityInfo), toUnitInfo)
+                    QuantityValue expectedValue = customDensityInfo.GetValueFrom(customConversionFromSpecificVolume.Evaluate(valueToConvert), customDensityInfo);
+
+                    var success = converter.TryConvertTo(valueToConvert, fromUnit, targetQuantityInfo, out IQuantity? convertedQuantity);
+
+                    Assert.True(success);
+                    Assert.IsType<Density>(convertedQuantity);
+                    Assert.Equal(customDensityUnit, convertedQuantity.Unit);
+                    Assert.Equal(expectedValue, convertedQuantity.Value);
+                }, () =>
+                {
+                    // all other specific-volume units are also converted using our custom conversion expression (possibly resulting in a different unit)
+                    Assert.All(SpecificVolume.Info.UnitInfos.Where(info => info != customSpecificVolumeInfo), fromUnitInfo =>
+                    {
+                        SpecificVolumeUnit fromUnit = fromUnitInfo.Value;
+                        QuantityInfo targetQuantityInfo = Density.Info;
+                        Density expectedQuantity = customDensityInfo.From(customConversionFromSpecificVolume.Evaluate(customSpecificVolumeInfo.GetValueFrom(valueToConvert, fromUnitInfo)));
+                            
+                        var success = converter.TryConvertTo(valueToConvert, fromUnit, targetQuantityInfo, out IQuantity? convertedQuantity);
+
+                        Assert.True(success);
+                        Assert.IsType<Density>(convertedQuantity);
+                        Assert.Equal(expectedQuantity, convertedQuantity);
+                    });
+                });
+        }
     }
 }
diff --git a/UnitsNet.Tests/UnitDefinitionTest.cs b/UnitsNet.Tests/UnitDefinitionTest.cs
new file mode 100644
index 0000000000..a6f2181c66
--- /dev/null
+++ b/UnitsNet.Tests/UnitDefinitionTest.cs
@@ -0,0 +1,107 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.Tests;
+
+public class UnitDefinitionTest
+{
+    [Theory]
+    [InlineData(LengthUnit.Meter, "Meters")]
+    [InlineData(LengthUnit.Centimeter, "Centimeters")]
+    [InlineData(LengthUnit.Millimeter, "Millimeters")]
+    public void Constructor_BaseUnit_InitializesWithoutConversionOrSingularName(LengthUnit value, string pluralName)
+    {
+        var baseUnits = new BaseUnits(value);
+        var unitDefinition = new UnitDefinition<LengthUnit>(value, pluralName, baseUnits);
+
+        Assert.Equal(value, unitDefinition.Value);
+        Assert.Equal(value.ToString(), unitDefinition.Name);
+        Assert.Equal(pluralName, unitDefinition.PluralName);
+        Assert.Equal(baseUnits, unitDefinition.BaseUnits);
+        Assert.Equal(QuantityValue.One, unitDefinition.ConversionFromBase.Evaluate(1));
+        Assert.Equal(QuantityValue.One, unitDefinition.ConversionToBase.Evaluate(1));
+    }
+
+    [Theory]
+    [InlineData(LengthUnit.Meter, "Meter", "Meters")]
+    [InlineData(LengthUnit.Centimeter, "Centimeter", "Centimeters")]
+    [InlineData(LengthUnit.Millimeter, "Millimeter", "Millimeters")]
+    public void Constructor_BaseUnit_InitializesWithoutConversion(LengthUnit value, string singularName, string pluralName)
+    {
+        var baseUnits = new BaseUnits(value);
+        var unitDefinition = new UnitDefinition<LengthUnit>(value, singularName, pluralName, baseUnits);
+
+        Assert.Equal(value, unitDefinition.Value);
+        Assert.Equal(singularName, unitDefinition.Name);
+        Assert.Equal(pluralName, unitDefinition.PluralName);
+        Assert.Equal(baseUnits, unitDefinition.BaseUnits);
+        Assert.Equal(QuantityValue.One, unitDefinition.ConversionFromBase.Evaluate(1));
+        Assert.Equal(QuantityValue.One, unitDefinition.ConversionToBase.Evaluate(1));
+    }
+
+    [Theory]
+    [InlineData(LengthUnit.Meter, "Meters", 1.0, 1.0)]
+    [InlineData(LengthUnit.Centimeter, "Centimeters", 0.01, 100.0)]
+    [InlineData(LengthUnit.Millimeter, "Millimeters", 0.001, 1000.0)]
+    public void Constructor_WithConversionValues_InitializesCorrectly(LengthUnit value, string pluralName, double conversionCoefficientFromBase,
+        double conversionCoefficientToBase)
+    {
+        var baseUnits = new BaseUnits();
+        QuantityValue conversionFromBase = conversionCoefficientFromBase;
+        QuantityValue conversionToBase = conversionCoefficientToBase;
+
+        var unitDefinition = new UnitDefinition<LengthUnit>(value, pluralName, baseUnits, conversionFromBase, conversionToBase);
+
+        Assert.Equal(value, unitDefinition.Value);
+        Assert.Equal(value.ToString(), unitDefinition.Name);
+        Assert.Equal(pluralName, unitDefinition.PluralName);
+        Assert.Equal(baseUnits, unitDefinition.BaseUnits);
+        Assert.Equal(conversionFromBase, unitDefinition.ConversionFromBase.Evaluate(QuantityValue.One));
+        Assert.Equal(conversionToBase, unitDefinition.ConversionToBase.Evaluate(QuantityValue.One));
+    }
+
+
+    [Theory]
+    [InlineData(LengthUnit.Meter, "Meter", "Meters", 1.0, 1.0)]
+    [InlineData(LengthUnit.Centimeter, "Centimeter", "Centimeters", 0.01, 100.0)]
+    [InlineData(LengthUnit.Millimeter, "Millimeter", "Millimeters", 0.001, 1000.0)]
+    public void Constructor_WithSingularNameAndConversionValues_InitializesCorrectly(LengthUnit value, string singularName, string pluralName,
+        double conversionCoefficientFromBase,
+        double conversionCoefficientToBase)
+    {
+        var baseUnits = new BaseUnits();
+        QuantityValue conversionFromBase = conversionCoefficientFromBase;
+        QuantityValue conversionToBase = conversionCoefficientToBase;
+
+        var unitDefinition = new UnitDefinition<LengthUnit>(value, singularName, pluralName, baseUnits, conversionFromBase, conversionToBase);
+
+        Assert.Equal(value, unitDefinition.Value);
+        Assert.Equal(singularName, unitDefinition.Name);
+        Assert.Equal(pluralName, unitDefinition.PluralName);
+        Assert.Equal(baseUnits, unitDefinition.BaseUnits);
+        Assert.Equal(conversionFromBase, unitDefinition.ConversionFromBase.Evaluate(QuantityValue.One));
+        Assert.Equal(conversionToBase, unitDefinition.ConversionToBase.Evaluate(QuantityValue.One));
+    }
+
+    [Fact]
+    public void Constructor_WithNullSingularName_ThrowsArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => new UnitDefinition<LengthUnit>(LengthUnit.Meter, null!, "Meters", BaseUnits.Undefined));
+    }
+
+    [Fact]
+    public void Constructor_WithNullPluralName_ThrowsArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => new UnitDefinition<LengthUnit>(LengthUnit.Meter, "Meter", null!, BaseUnits.Undefined));
+    }
+
+    [Fact]
+    public void Constructor_WithNullBaseUnits_ThrowsArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => new UnitDefinition<LengthUnit>(LengthUnit.Meter, "Meter", "Meters", null!));
+    }
+}
diff --git a/UnitsNet.Tests/UnitInfoTests.cs b/UnitsNet.Tests/UnitInfoTests.cs
index 1b428c442d..93305b36b4 100644
--- a/UnitsNet.Tests/UnitInfoTests.cs
+++ b/UnitsNet.Tests/UnitInfoTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet.Tests;
diff --git a/UnitsNet.Tests/UnitKeyTest.cs b/UnitsNet.Tests/UnitKeyTest.cs
index 469bed03b8..7966401655 100644
--- a/UnitsNet.Tests/UnitKeyTest.cs
+++ b/UnitsNet.Tests/UnitKeyTest.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet.Tests/UnitMathTests.cs b/UnitsNet.Tests/UnitMathTests.cs
index 67509044fd..51014f4a11 100644
--- a/UnitsNet.Tests/UnitMathTests.cs
+++ b/UnitsNet.Tests/UnitMathTests.cs
@@ -1,5 +1,6 @@
-using System;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using UnitsNet.Units;
 using Xunit;
 
@@ -48,7 +49,7 @@ public void AverageOfEmptySourceThrowsException()
         [Fact]
         public void AverageOfLengthsCalculatesCorrectly()
         {
-            var units = new[] {Length.FromMeters(1), Length.FromCentimeters(50)};
+            var units = new[] { Length.FromMeters(1), Length.FromCentimeters(50) };
 
             Length average = units.Average(LengthUnit.Centimeter);
 
@@ -61,11 +62,10 @@ public void AverageOfLengthsWithNullSelectorThrowsException()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length>("1", Length.FromMeters(1)), new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
             };
-
-            Assert.Throws<ArgumentNullException>(() => units.Average((Func<KeyValuePair<string, Length>, Length>) null!, LengthUnit.Centimeter));
+            
+            Assert.Throws<ArgumentNullException>(() => units.Average((Func<KeyValuePair<string, Length>, Length>)null!, LengthUnit.Centimeter));
         }
 
         [Fact]
@@ -73,8 +73,7 @@ public void AverageOfLengthsWithSelectorCalculatesCorrectly()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length>("1", Length.FromMeters(1)), new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
             };
 
             Length average = units.Average(x => x.Value, LengthUnit.Centimeter);
@@ -93,6 +92,7 @@ public void MaxOfTwoLengthsReturnsTheLargestValue()
 
             Assert.Equal(1, max.Value);
             Assert.Equal(LengthUnit.Meter, max.Unit);
+            Assert.Equal(max, UnitMath.Max(secondValue, firstValue));
         }
 
         [Fact]
@@ -105,6 +105,7 @@ public void MinOfTwoLengthsReturnsTheSmallestValue()
 
             Assert.Equal(50, min.Value);
             Assert.Equal(LengthUnit.Centimeter, min.Unit);
+            Assert.Equal(min, UnitMath.Min(secondValue, firstValue));
         }
 
         [Fact]
@@ -120,7 +121,7 @@ public void SumOfEmptySourceReturnsZero()
         [Fact]
         public void SumOfLengthsCalculatesCorrectly()
         {
-            var units = new[] {Length.FromMeters(1), Length.FromCentimeters(50)};
+            var units = new[] { Length.FromMeters(1), Length.FromCentimeters(50) };
 
             Length sum = units.Sum(LengthUnit.Centimeter);
 
@@ -133,11 +134,10 @@ public void SumOfLengthsWithNullSelectorThrowsException()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length>("1", Length.FromMeters(1)), new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
             };
 
-            Assert.Throws<ArgumentNullException>(() => units.Sum((Func<KeyValuePair<string, Length>, Length>) null!, LengthUnit.Centimeter));
+            Assert.Throws<ArgumentNullException>(() => units.Sum((Func<KeyValuePair<string, Length>, Length>)null!, LengthUnit.Centimeter));
         }
 
         [Fact]
@@ -145,8 +145,7 @@ public void SumOfLengthsWithSelectorCalculatesCorrectly()
         {
             var units = new[]
             {
-                new KeyValuePair<string, Length>("1", Length.FromMeters(1)),
-                new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
+                new KeyValuePair<string, Length>("1", Length.FromMeters(1)), new KeyValuePair<string, Length>("2", Length.FromCentimeters(50))
             };
 
             Length sum = units.Sum(x => x.Value, LengthUnit.Centimeter);
diff --git a/UnitsNet.Tests/UnitParserTests.cs b/UnitsNet.Tests/UnitParserTests.cs
index e168f08aeb..cbc7642032 100644
--- a/UnitsNet.Tests/UnitParserTests.cs
+++ b/UnitsNet.Tests/UnitParserTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Globalization;
@@ -35,6 +35,60 @@ public void CreateDefault_CreatesNewAbbreviationsCacheWithDefaultQuantities()
         Assert.NotEqual(UnitAbbreviationsCache.Default, unitParser.Abbreviations);
         Assert.Equal(UnitsNetSetup.Default.Quantities, unitParser.Quantities);
     }
+
+    [Fact]
+    public void CreateDefault_WithAdditionalQuantity_CreatesParserWithExtendedCatalog()
+    {
+        var unitParser = UnitParser.CreateDefault(selector => selector.WithAdditionalQuantities([HowMuch.Info]));
+
+        Assert.Contains(HowMuch.Info, unitParser.Quantities.Infos);
+    }
+
+    [Fact]
+    public void CreateDefault_WithConfiguredQuantityAndAbbreviation_ParsesExternalQuantityUnit()
+    {
+        var unitParser = UnitParser.CreateDefault(
+            selector => selector.WithAdditionalQuantities([HowMuch.Info]),
+            abbreviations => abbreviations.MapUnitToAbbreviation(HowMuchUnit.Some, "some"));
+
+        Assert.Equal(HowMuchUnit.Some, unitParser.Parse<HowMuchUnit>("some"));
+    }
+
+    [Fact]
+    public void Create_WithBaseAndAdditionalQuantities_CreatesParserWithSelectedCatalog()
+    {
+        var unitParser = UnitParser.Create([Mass.Info],
+            selector => selector.WithAdditionalQuantities([HowMuch.Info]));
+
+        Assert.Equal([Mass.Info, HowMuch.Info], unitParser.Quantities.Infos);
+    }
+
+    [Fact]
+    public void Create_WithConfiguredAbbreviation_ParsesExternalQuantityUnit()
+    {
+        var unitParser = UnitParser.Create([HowMuch.Info], _ => { },
+            abbreviations => abbreviations.MapUnitToAbbreviation(HowMuchUnit.Some, "some"));
+
+        Assert.Equal(HowMuchUnit.Some, unitParser.Parse<HowMuchUnit>("some"));
+    }
+
+    [Fact]
+    public void FactoryMethods_WithNullArguments_ThrowArgumentNullException()
+    {
+        Assert.Multiple(checks:
+        [
+            () => Assert.Equal("configureQuantities",
+                Assert.Throws<ArgumentNullException>(() => UnitParser.CreateDefault((Action<QuantitiesSelector>)null!)).ParamName),
+            () => Assert.Equal("configureAbbreviations",
+                Assert.Throws<ArgumentNullException>(() => UnitParser.CreateDefault(_ => { }, null!)).ParamName),
+            () => Assert.Equal("defaultQuantities",
+                Assert.Throws<ArgumentNullException>(() => UnitParser.Create(null!, _ => { })).ParamName),
+            () => Assert.Equal("configureQuantities",
+                Assert.Throws<ArgumentNullException>(() => UnitParser.Create([Mass.Info], null!)).ParamName),
+            () => Assert.Equal("configureAbbreviations",
+                Assert.Throws<ArgumentNullException>(() => UnitParser.Create([Mass.Info], _ => { }, null!)).ParamName)
+        ]);
+    }
         
     [Theory]
     [InlineData("m^^2", AreaUnit.SquareMeter)]
diff --git a/UnitsNet.Tests/UnitSystemTests.cs b/UnitsNet.Tests/UnitSystemTests.cs
index 4b21aac342..7f12918e91 100644
--- a/UnitsNet.Tests/UnitSystemTests.cs
+++ b/UnitsNet.Tests/UnitSystemTests.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -34,11 +34,20 @@ public void ConstructorThrowsArgumentNullExceptionForNullBaseUnits()
         [InlineData(LengthUnit.Meter, MassUnit.Kilogram, DurationUnit.Second, ElectricCurrentUnit.Ampere, null, AmountOfSubstanceUnit.Mole, LuminousIntensityUnit.Candela)]
         [InlineData(LengthUnit.Meter, MassUnit.Kilogram, DurationUnit.Second, ElectricCurrentUnit.Ampere, TemperatureUnit.Kelvin, null, LuminousIntensityUnit.Candela)]
         [InlineData(LengthUnit.Meter, MassUnit.Kilogram, DurationUnit.Second, ElectricCurrentUnit.Ampere, TemperatureUnit.Kelvin, AmountOfSubstanceUnit.Mole, null)]
-        public void ConstructorThrowsArgumentExceptionWithUndefinedUnits(LengthUnit? length, MassUnit? mass, DurationUnit? time, ElectricCurrentUnit? current,
+        [InlineData(LengthUnit.Meter, null, null, null, null, null, null)]
+        public void ConstructorSupportsPartialDimensions(LengthUnit? length, MassUnit? mass, DurationUnit? time, ElectricCurrentUnit? current,
             TemperatureUnit? temperature, AmountOfSubstanceUnit? amount, LuminousIntensityUnit? luminousIntensity)
         {
             var baseUnits = new BaseUnits(length, mass, time, current, temperature, amount, luminousIntensity);
-            Assert.Throws<ArgumentException>(() => new UnitSystem(baseUnits));
+            var unitSystem = new UnitSystem(baseUnits);
+
+            Assert.Equal(baseUnits, unitSystem.BaseUnits);
+        }
+
+        [Fact]
+        public void ConstructorThrowsArgumentExceptionWithUndefinedUnits()
+        {
+            Assert.Throws<ArgumentException>(() => new UnitSystem(BaseUnits.Undefined));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/UnitsNet.Tests.csproj b/UnitsNet.Tests/UnitsNet.Tests.csproj
index 0ab93c024c..2227ebebff 100644
--- a/UnitsNet.Tests/UnitsNet.Tests.csproj
+++ b/UnitsNet.Tests/UnitsNet.Tests.csproj
@@ -1,7 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
+    <TargetFrameworks>net10.0</TargetFrameworks>
+    <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(TargetFrameworks);net48</TargetFrameworks>
     <LangVersion>latest</LangVersion>
     <ImplicitUsings>enable</ImplicitUsings>
     <IsTestProject>true</IsTestProject>
@@ -31,11 +32,17 @@
     <PackageReference Include="xunit.runner.visualstudio">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
+    </PackageReference>		
+    <PackageReference Include="JetBrains.Annotations" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\UnitsNet\UnitsNet.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Using Include="Xunit" />
+    <Using Include="UnitsNet.Units" />
+  </ItemGroup>
+
 </Project>
diff --git a/UnitsNet.Tests/UnitsNet.Tests.csproj.DotSettings b/UnitsNet.Tests/UnitsNet.Tests.csproj.DotSettings
index 0b0edaecd0..5b5bbe549d 100644
--- a/UnitsNet.Tests/UnitsNet.Tests.csproj.DotSettings
+++ b/UnitsNet.Tests/UnitsNet.Tests.csproj.DotSettings
@@ -1,2 +1,2 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/UnitsNet.Tests/UnitsNetSetupTests.cs b/UnitsNet.Tests/UnitsNetSetupTests.cs
new file mode 100644
index 0000000000..cc7364b019
--- /dev/null
+++ b/UnitsNet.Tests/UnitsNetSetupTests.cs
@@ -0,0 +1,69 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.Tests.CustomQuantities;
+using UnitsNet.Units;
+
+namespace UnitsNet.Tests;
+
+public class UnitsNetSetupTests
+{
+    [Fact]
+    public void Create_WithSelectedQuantities_WiresIsolatedComponentsToSameCatalog()
+    {
+        UnitsNetSetup setup = UnitsNetSetup.Create(builder => builder.WithQuantities([Mass.Info]));
+
+        Assert.Equal([Mass.Info], setup.Quantities.Infos);
+        Assert.Same(setup.Quantities, setup.UnitAbbreviations.Quantities);
+        Assert.Same(setup.UnitAbbreviations, setup.UnitParser.Abbreviations);
+        Assert.NotSame(UnitsNetSetup.Default, setup);
+        Assert.Throws<UnitNotFoundException>(() => setup.Quantities.GetQuantityByUnitType(typeof(LengthUnit)));
+    }
+
+    [Fact]
+    public void Create_WithAdditionalQuantities_AppendsToSelectedCatalog()
+    {
+        UnitsNetSetup setup = UnitsNetSetup.Create(builder => builder
+            .WithQuantities([Mass.Info])
+            .WithAdditionalQuantities([HowMuch.Info]));
+
+        Assert.Equal([Mass.Info, HowMuch.Info], setup.Quantities.Infos);
+    }
+
+    [Fact]
+    public void Create_WithSelectedAndAdditionalQuantities_AppendsToSelectedCatalog()
+    {
+        UnitsNetSetup setup = UnitsNetSetup.Create(builder => builder.WithQuantities([Mass.Info],
+            selector => selector.WithAdditionalQuantities([HowMuch.Info])));
+
+        Assert.Equal([Mass.Info, HowMuch.Info], setup.Quantities.Infos);
+    }
+
+    [Fact]
+    public void FactoryMethods_WithNullArguments_ThrowArgumentNullException()
+    {
+        var builder = new UnitsNetSetup.DefaultConfigurationBuilder();
+
+        Assert.Multiple(checks:
+        [
+            () => Assert.Equal("configuration",
+                Assert.Throws<ArgumentNullException>(() => UnitsNetSetup.Create(null!)).ParamName),
+            () => Assert.Equal("quantities",
+                Assert.Throws<ArgumentNullException>(() => builder.WithQuantities((IEnumerable<QuantityInfo>)null!)).ParamName),
+            () => Assert.Equal("quantities",
+                Assert.Throws<ArgumentNullException>(() => builder.WithQuantities((Func<IEnumerable<QuantityInfo>>)null!)).ParamName),
+            () => Assert.Equal("quantities",
+                Assert.Throws<ArgumentNullException>(() => builder.WithQuantities((IEnumerable<QuantityInfo>)null!, _ => { })).ParamName),
+            () => Assert.Equal("configureQuantities",
+                Assert.Throws<ArgumentNullException>(() => builder.WithQuantities(() => [Mass.Info], null!)).ParamName)
+        ]);
+    }
+
+    [Fact]
+    public void Builder_WithQuantitiesTwice_ThrowsInvalidOperationException()
+    {
+        Assert.Throws<InvalidOperationException>(() => UnitsNetSetup.Create(builder => builder
+            .WithQuantities([Mass.Info])
+            .WithQuantities([Length.Info])));
+    }
+}
diff --git a/UnitsNet.sln.DotSettings b/UnitsNet.sln.DotSettings
index 9a50f67d77..2fa3e1e6d0 100644
--- a/UnitsNet.sln.DotSettings
+++ b/UnitsNet.sln.DotSettings
@@ -1,4 +1,4 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeInspection/CodeAnnotations/NamespacesWithAnnotations/=JetBrains_002EAnnotations/@EntryIndexedValue">True</s:Boolean>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=EnforceForeachStatementBraces/@EntryIndexedValue">SUGGESTION</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=EnforceIfStatementBraces/@EntryIndexedValue">SUGGESTION</s:String>
@@ -50,6 +50,4 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Formattable/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Gullberg/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=inheritdoc/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=netnanoframework/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=nfproj/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=paramref/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
diff --git a/UnitsNet.slnx b/UnitsNet.slnx
index 954149d514..2a28e31d84 100644
--- a/UnitsNet.slnx
+++ b/UnitsNet.slnx
@@ -9,13 +9,12 @@
     <File Path=".editorconfig" />
     <File Path=".gitattributes" />
     <File Path=".gitignore" />
-    <File Path="azure-pipelines.yml" />
-    <File Path="build-all-targets.bat" />
     <File Path="build.bat" />
     <File Path="clean.bat" />
     <File Path="CODE_OF_CONDUCT.md" />
     <File Path="CONTRIBUTING.md" />
     <File Path="Directory.Build.props" />
+    <File Path="Directory.Build.targets" />
     <File Path="Directory.Packages.props" />
     <File Path="generate-code.bat" />
     <File Path="init.bat" />
@@ -29,7 +28,6 @@
   </Folder>
   <Folder Name="/_Files/Build/">
     <File Path="Build/build-functions.psm1" />
-    <File Path="Build/build-pack-nano-nugets.psm1" />
     <File Path="Build/build.ps1" />
     <File Path="Build/bump-version-json.bat" />
     <File Path="Build/bump-version-json.sh" />
@@ -46,12 +44,16 @@
   </Folder>
   <Project Path="CodeGen/CodeGen.csproj" />
   <Project Path="UnitsNet.Benchmark/UnitsNet.Benchmark.csproj" />
+  <Project Path="UnitsNet.GlobalSetup.DefaultFirst.Tests/UnitsNet.GlobalSetup.DefaultFirst.Tests.csproj" />
+  <Project Path="UnitsNet.GlobalSetup.Tests/UnitsNet.GlobalSetup.Tests.csproj" />
   <Project Path="UnitsNet.NumberExtensions.CS14.Tests\UnitsNet.NumberExtensions.CS14.Tests.csproj" Type="Classic C#" />
   <Project Path="UnitsNet.NumberExtensions.CS14\UnitsNet.NumberExtensions.CS14.csproj" Type="Classic C#" />
   <Project Path="UnitsNet.NumberExtensions.Tests/UnitsNet.NumberExtensions.Tests.csproj" />
   <Project Path="UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj" />
   <Project Path="UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj" />
   <Project Path="UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj" />
+  <Project Path="UnitsNet.Serialization.SystemTextJson.Tests/UnitsNet.Serialization.SystemTextJson.Tests.csproj" />
+  <Project Path="UnitsNet.Serialization.SystemTextJson/UnitsNet.Serialization.SystemTextJson.csproj" />
   <Project Path="UnitsNet.Tests/UnitsNet.Tests.csproj" />
   <Project Path="UnitsNet/UnitsNet.csproj" />
-</Solution>
\ No newline at end of file
+</Solution>
diff --git a/UnitsNet/AssemblyInfo.cs b/UnitsNet/AssemblyInfo.cs
index d897374117..7c91cbdef9 100644
--- a/UnitsNet/AssemblyInfo.cs
+++ b/UnitsNet/AssemblyInfo.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet/BaseDimensions.cs b/UnitsNet/BaseDimensions.cs
index ec79f133ad..fc4ae9504b 100644
--- a/UnitsNet/BaseDimensions.cs
+++ b/UnitsNet/BaseDimensions.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet/BaseUnits.cs b/UnitsNet/BaseUnits.cs
index 5f16a8fc08..34fca77270 100644
--- a/UnitsNet/BaseUnits.cs
+++ b/UnitsNet/BaseUnits.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet/Comparison.cs b/UnitsNet/Comparison.cs
index 3c38a83672..2b4f828bd1 100644
--- a/UnitsNet/Comparison.cs
+++ b/UnitsNet/Comparison.cs
@@ -1,142 +1,140 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
 
-namespace UnitsNet
+namespace UnitsNet;
+
+/// <summary>
+///     Helper methods to perform relative and absolute comparison.
+/// </summary>
+public static class Comparison
 {
     /// <summary>
-    ///     Helper methods to perform relative and absolute comparison.
+    ///     <para>
+    ///         Checks if two values are equal with a given relative or absolute tolerance.
+    ///     </para>
+    ///     <para>
+    ///         Relative tolerance is defined as the maximum allowable absolute difference between
+    ///         <paramref name="referenceValue" /> and
+    ///         <paramref name="otherValue" /> as a percentage of <paramref name="referenceValue" />. A relative tolerance of
+    ///         0.01 means the
+    ///         absolute difference of <paramref name="referenceValue" /> and <paramref name="otherValue" /> must be within +/-
+    ///         1%.
+    ///         <example>
+    ///             In this example, the two values will be equal if the value of b is within +/- 1% of a.
+    ///             <code>
+    ///     Equals(a, b, 0.01, ComparisonType.Relative);
+    ///     </code>
+    ///         </example>
+    ///     </para>
+    ///     <para>
+    ///         Absolute tolerance is defined as the maximum allowable absolute difference between
+    ///         <paramref name="referenceValue" /> and
+    ///         <paramref name="otherValue" /> as a fixed number.
+    ///         <example>
+    ///             In this example, the two values will be equal if abs(<paramref name="referenceValue" /> -
+    ///             <paramref name="otherValue" />) &lt;= 0.01
+    ///             <code>
+    ///     Equals(a, b, 0.01, ComparisonType.Absolute);
+    ///     </code>
+    ///         </example>
+    ///     </para>
     /// </summary>
-    public static class Comparison
+    /// <param name="referenceValue">
+    ///     The reference value. If using relative tolerance, it is the value which the relative
+    ///     tolerance will be calculated against.
+    /// </param>
+    /// <param name="otherValue">The value to compare to.</param>
+    /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
+    /// <param name="comparisonType">Whether the tolerance is absolute or relative.</param>
+    /// <returns>True if the two values are equal within the given tolerance, otherwise false.</returns>
+    /// <exception cref="ArgumentOutOfRangeException"> Thrown when the <paramref name="tolerance"/> is negative.</exception>
+    public static bool Equals(QuantityValue referenceValue, QuantityValue otherValue, QuantityValue tolerance, ComparisonType comparisonType)
     {
-        /// <summary>
-        ///     <para>
-        ///         Checks if two values are equal with a given relative or absolute tolerance.
-        ///     </para>
-        ///     <para>
-        ///         Relative tolerance is defined as the maximum allowable absolute difference between
-        ///         <paramref name="referenceValue" /> and
-        ///         <paramref name="otherValue" /> as a percentage of <paramref name="referenceValue" />. A relative tolerance of
-        ///         0.01 means the
-        ///         absolute difference of <paramref name="referenceValue" /> and <paramref name="otherValue" /> must be within +/-
-        ///         1%.
-        ///         <example>
-        ///             In this example, the two values will be equal if the value of b is within +/- 1% of a.
-        ///             <code>
-        ///     Equals(a, b, 0.01, ComparisonType.Relative);
-        ///     </code>
-        ///         </example>
-        ///     </para>
-        ///     <para>
-        ///         Absolute tolerance is defined as the maximum allowable absolute difference between
-        ///         <paramref name="referenceValue" /> and
-        ///         <paramref name="otherValue" /> as a fixed number.
-        ///         <example>
-        ///             In this example, the two values will be equal if abs(<paramref name="referenceValue" /> -
-        ///             <paramref name="otherValue" />) &lt;= 0.01
-        ///             <code>
-        ///     Equals(a, b, 0.01, ComparisonType.Absolute);
-        ///     </code>
-        ///         </example>
-        ///     </para>
-        /// </summary>
-        /// <param name="referenceValue">
-        ///     The reference value. If using relative tolerance, it is the value which the relative
-        ///     tolerance will be calculated against.
-        /// </param>
-        /// <param name="otherValue">The value to compare to.</param>
-        /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
-        /// <param name="comparisonType">Whether the tolerance is absolute or relative.</param>
-        /// <returns></returns>
-        public static bool Equals(double referenceValue, double otherValue, double tolerance, ComparisonType comparisonType)
+        return comparisonType switch
         {
-            if (tolerance < 0)
-                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
-
-            switch (comparisonType)
-            {
-                case ComparisonType.Relative:
-                    return EqualsRelative(referenceValue, otherValue, tolerance);
-                case ComparisonType.Absolute:
-                    return EqualsAbsolute(referenceValue, otherValue, tolerance);
-                default:
-                    throw new InvalidOperationException("The given ComparisonType is not supported.");
-            }
-        }
+            ComparisonType.Relative => EqualsRelative(referenceValue, otherValue, tolerance),
+            ComparisonType.Absolute => EqualsAbsolute(referenceValue, otherValue, tolerance),
+            _ => throw new InvalidOperationException("The given ComparisonType is not supported.")
+        };
+    }
 
-        /// <summary>
-        ///     Checks if two values are equal with a given relative tolerance.
-        ///     <para>
-        ///         Relative tolerance is defined as the maximum allowable absolute difference between
-        ///         <paramref name="referenceValue" /> and
-        ///         <paramref name="otherValue" /> as a percentage of <paramref name="referenceValue" />. A relative tolerance of
-        ///         0.01 means the
-        ///         absolute difference of <paramref name="referenceValue" /> and <paramref name="otherValue" /> must be within +/-
-        ///         1%.
-        ///         <example>
-        ///             In this example, the two values will be equal if the value of b is within +/- 1% of a.
-        ///             <code>
-        ///     EqualsRelative(a, b, 0.01);
-        ///     </code>
-        ///         </example>
-        ///     </para>
-        /// </summary>
-        /// <param name="referenceValue">The reference value which the tolerance will be calculated against.</param>
-        /// <param name="otherValue">The value to compare to.</param>
-        /// <param name="tolerance">The relative tolerance. Must be greater than or equal to 0.</param>
-        /// <returns>True if the two values are equal within the given relative tolerance, otherwise false.</returns>
-        public static bool EqualsRelative(double referenceValue, double otherValue, double tolerance)
+    /// <summary>
+    ///     Checks if two values are equal with a given relative tolerance.
+    ///     <para>
+    ///         Relative tolerance is defined as the maximum allowable absolute difference between
+    ///         <paramref name="referenceValue" /> and
+    ///         <paramref name="otherValue" /> as a percentage of <paramref name="referenceValue" />. A relative tolerance of
+    ///         0.01 means the
+    ///         absolute difference of <paramref name="referenceValue" /> and <paramref name="otherValue" /> must be within +/-
+    ///         1%.
+    ///         <example>
+    ///             In this example, the two values will be equal if the value of b is within +/- 1% of a.
+    ///             <code>
+    ///     EqualsRelative(a, b, 0.01);
+    ///     </code>
+    ///         </example>
+    ///     </para>
+    /// </summary>
+    /// <param name="referenceValue">The reference value which the tolerance will be calculated against.</param>
+    /// <param name="otherValue">The value to compare to.</param>
+    /// <param name="tolerance">The relative tolerance. Must be greater than or equal to 0.</param>
+    /// <returns>True if the two values are equal within the given relative tolerance, otherwise false.</returns>
+    /// <exception cref="ArgumentOutOfRangeException"> Thrown when the <paramref name="tolerance"/> is negative.</exception>
+    public static bool EqualsRelative(QuantityValue referenceValue, QuantityValue otherValue, QuantityValue tolerance)
+    {
+        if (QuantityValue.IsNegative(tolerance))
         {
-            if (tolerance < 0)
-                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
-
-            var maxVariation = Math.Abs(referenceValue * tolerance);
-            return Math.Abs(referenceValue - otherValue) <= maxVariation;
+            throw ExceptionHelper.CreateArgumentOutOfRangeExceptionForNegativeTolerance(nameof(tolerance));
         }
+        
+        var maxVariation = QuantityValue.Abs(referenceValue) * tolerance;
+        return QuantityValue.Abs(referenceValue - otherValue) <= maxVariation;
+    }
 
-        /// <summary>
-        ///     Checks if two values are equal with a given absolute tolerance.
-        ///     <para>
-        ///         Absolute tolerance is defined as the maximum allowable absolute difference between <paramref name="value1" />
-        ///         and
-        ///         <paramref name="value2" /> as a fixed number.
-        ///         <example>
-        ///             In this example, the two values will be equal if abs(<paramref name="value1" /> -
-        ///             <paramref name="value2" />) &lt;= 0.01
-        ///             <code>
-        ///     Equals(a, b, 0.01, ComparisonType.Absolute);
-        ///     </code>
-        ///         </example>
-        ///     </para>
-        /// </summary>
-        /// <param name="value1">The first value.</param>
-        /// <param name="value2">The second value.</param>
-        /// <param name="tolerance">The absolute tolerance. Must be greater than or equal to 0.</param>
-        /// <returns>True if the two values are equal within the given absolute tolerance, otherwise false.</returns>
-        public static bool EqualsAbsolute(double value1, double value2, double tolerance)
+    /// <summary>
+    ///     Checks if two values are equal with a given absolute tolerance.
+    ///     <para>
+    ///         Absolute tolerance is defined as the maximum allowable absolute difference between <paramref name="value1" />
+    ///         and
+    ///         <paramref name="value2" /> as a fixed number.
+    ///         <example>
+    ///             In this example, the two values will be equal if abs(<paramref name="value1" /> -
+    ///             <paramref name="value2" />) &lt;= 0.01
+    ///             <code>
+    ///     Equals(a, b, 0.01, ComparisonType.Absolute);
+    ///     </code>
+    ///         </example>
+    ///     </para>
+    /// </summary>
+    /// <param name="value1">The first value.</param>
+    /// <param name="value2">The second value.</param>
+    /// <param name="tolerance">The absolute tolerance. Must be greater than or equal to 0.</param>
+    /// <returns>True if the two values are equal within the given absolute tolerance, otherwise false.</returns>
+    /// <exception cref="ArgumentOutOfRangeException"> Thrown when the <paramref name="tolerance"/> is negative.</exception>
+    public static bool EqualsAbsolute(QuantityValue value1, QuantityValue value2, QuantityValue tolerance)
+    {
+        if (QuantityValue.IsNegative(tolerance))
         {
-            if (tolerance < 0)
-                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
-
-            return Math.Abs(value1 - value2) <= tolerance;
+            throw ExceptionHelper.CreateArgumentOutOfRangeExceptionForNegativeTolerance(nameof(tolerance));
         }
 
-        internal static int GetHashCode<TUnit>(TUnit unit, double value)
-            where TUnit : struct, Enum
-        {
+        return QuantityValue.Abs(value1 - value2) <= tolerance;
+    }
+
+    internal static int GetHashCode(Type type, QuantityValue value)
+    {
 #if NET7_0_OR_GREATER
-            return HashCode.Combine(typeof(TUnit), unit, value);
-#else
-            unchecked
-            {
-                var hash = 17;
-                hash = hash * 23 + typeof(TUnit).GetHashCode();
-                hash = hash * 23 + unit.GetHashCode();
-                hash = hash * 23 + value.GetHashCode();
-                return hash;
-            }
-#endif
+        return HashCode.Combine(type, value);
+        #else
+        unchecked
+        {
+            var hash = 17;
+            hash = hash * 23 + type.GetHashCode();
+            hash = hash * 23 + value.GetHashCode();
+            return hash;
         }
+#endif
     }
 }
diff --git a/UnitsNet/ComparisonType.cs b/UnitsNet/ComparisonType.cs
index 18f76cfdd3..ec3a78706f 100644
--- a/UnitsNet/ComparisonType.cs
+++ b/UnitsNet/ComparisonType.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet
diff --git a/UnitsNet/CompiledLambdas.cs b/UnitsNet/CompiledLambdas.cs
index 56790cadaa..2ba42e971d 100644
--- a/UnitsNet/CompiledLambdas.cs
+++ b/UnitsNet/CompiledLambdas.cs
@@ -1,8 +1,9 @@
-using System;
+using System;
 using System.Linq.Expressions;
 
 namespace UnitsNet
 {
+#if COMPILED_LAMBDAS_ENABLED
     /// <summary>
     /// Compiled lambda expressions that can be invoked with generic run-time parameters. This is used for performance as
     /// it is far faster than reflection based alternatives.
@@ -309,4 +310,5 @@ private static Func<TLeft, TRight, TResult> CreateBinaryFunction<TLeft, TRight,
             return lambda.Compile();
         }
     }
+#endif
 }
diff --git a/UnitsNet/CustomCode/Compatibility/StringSyntaxAttribute.cs b/UnitsNet/CustomCode/Compatibility/StringSyntaxAttribute.cs
new file mode 100644
index 0000000000..60951f107d
--- /dev/null
+++ b/UnitsNet/CustomCode/Compatibility/StringSyntaxAttribute.cs
@@ -0,0 +1,36 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+#if NETSTANDARD2_0
+
+namespace System.Diagnostics.CodeAnalysis;
+
+/// <summary>Describes the syntax used by a string.</summary>
+[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
+internal sealed class StringSyntaxAttribute : Attribute
+{
+    /// <summary>The syntax identifier for numeric format strings.</summary>
+    public const string NumericFormat = nameof(NumericFormat);
+
+    /// <summary>Creates an attribute describing <paramref name="syntax" />.</summary>
+    public StringSyntaxAttribute(string syntax)
+    {
+        Syntax = syntax;
+        Arguments = [];
+    }
+
+    /// <summary>Creates an attribute describing <paramref name="syntax" /> with additional arguments.</summary>
+    public StringSyntaxAttribute(string syntax, params object?[] arguments)
+    {
+        Syntax = syntax;
+        Arguments = arguments;
+    }
+
+    /// <summary>Gets the syntax identifier.</summary>
+    public string Syntax { get; }
+
+    /// <summary>Gets optional syntax-specific arguments.</summary>
+    public object?[] Arguments { get; }
+}
+
+#endif
diff --git a/UnitsNet/CustomCode/Debug/QuantityDebugProxy.cs b/UnitsNet/CustomCode/Debug/QuantityDebugProxy.cs
new file mode 100644
index 0000000000..0399a5bd48
--- /dev/null
+++ b/UnitsNet/CustomCode/Debug/QuantityDebugProxy.cs
@@ -0,0 +1,273 @@
+using System.Globalization;
+
+namespace UnitsNet.Debug;
+
+/// <summary>
+///     Serves as a debug display proxy for a quantity, providing a convenient way to view various components of the
+///     quantity during debugging.
+/// </summary>
+/// <remarks>
+///     This struct provides a structured view of a quantity's components such as abbreviation, unit, value, and convertor
+///     during debugging.
+///     Each component is represented by a nested struct, which can be expanded in the debugger to inspect its properties.
+/// </remarks>
+public readonly struct QuantityDebugProxy: IFormattable
+{
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private readonly IQuantity _quantity;
+
+    /// <summary>
+    ///     Serves as a debug display proxy for a quantity, providing a convenient way to view various components of the
+    ///     quantity during debugging.
+    /// </summary>
+    /// <remarks>
+    ///     This struct provides a structured view of a quantity's components such as abbreviation, unit, value, and convertor
+    ///     during debugging.
+    ///     Each component is represented by a nested struct, which can be expanded in the debugger to inspect its properties.
+    /// </remarks>
+    public QuantityDebugProxy(IQuantity quantity)
+    {
+        _quantity = quantity;
+    }
+
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    internal UnitsNetSetup Configuration => GetConfiguration(QuantityInfo);
+
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    internal QuantityInfo QuantityInfo
+    {
+#pragma warning disable CS0618 // Type or member is obsolete
+        get => _quantity.QuantityInfo;
+#pragma warning restore CS0618 // Type or member is obsolete
+    }
+
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    internal UnitKey UnitKey
+    {
+        get => _quantity.UnitKey;
+    }
+
+    internal QuantityDebugProxy ConvertTo(UnitInfo unit)
+    {
+        return new QuantityDebugProxy(ConvertToUnit(unit));
+    }
+    
+    internal IQuantity ConvertToUnit(UnitInfo unit)
+    {
+        return Configuration.UnitConverter.ConvertTo(_quantity, unit.UnitKey);
+    }
+    
+    internal IQuantity ConvertToQuantity(QuantityInfo targetQuantity)
+    {
+        return Configuration.UnitConverter.ConvertTo(_quantity.Value, _quantity.UnitKey, targetQuantity);
+    }
+
+    /// <summary>
+    ///     Gets the quantity information, which includes details about the quantity's definition
+    ///     and its associated configuration.
+    /// </summary>
+    /// <value>
+    ///     An instance of <see cref="QuantityInformation" /> that provides metadata and context
+    ///     for the quantity represented by this <see cref="QuantityDebugProxy" />.
+    /// </value>
+    public QuantityInformation Quantity
+    {
+        get => new(this);
+    }
+    
+    /// <summary>
+    ///     Gets information about the unit associated with the quantity.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides detailed information about the unit, including its name, abbreviation, and other metadata.
+    /// </remarks>
+    public UnitInformation Unit
+    {
+        get => new(this, QuantityInfo[_quantity.UnitKey]);
+    }
+    
+    /// <summary>
+    ///     Gets the display representation of the unit abbreviation for the quantity.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides a formatted display of the unit abbreviation based on the quantity and configuration.
+    /// </remarks>
+    /// <value>
+    ///     An <see cref="UnitsNet.Debug.UnitAbbreviation" /> instance representing the unit abbreviation.
+    /// </value>
+    public UnitAbbreviation UnitAbbreviation
+    {
+        get => new(this);
+    }
+
+    /// <summary>
+    ///     Gets the numeric value of the quantity represented by this instance.
+    /// </summary>
+    /// <remarks>
+    ///     This property retrieves the underlying numeric value of the quantity,
+    ///     which is represented as a <see cref="QuantityValue" />. It provides a way
+    ///     to access the raw value of the quantity without any associated unit or formatting.
+    /// </remarks>
+    /// <value>
+    ///     The numeric value of the quantity.
+    /// </value>
+    public QuantityValue Value
+    {
+        get => _quantity.Value;
+    }
+
+    /// <summary>
+    ///     Gets the display formats for the value of the quantity.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides access to various string formats that can be used to represent
+    ///     the value of the quantity in different ways, depending on the configuration and context.
+    /// </remarks>
+    public QuantityFormats ValueFormats => new(this);
+
+    /// <summary>
+    ///     Returns a string representation of the quantity using the configured formatter.
+    /// </summary>
+    /// <remarks>
+    ///     This method utilizes the <see cref="UnitsNetSetup.Formatter" /> to format the quantity.
+    ///     The output is typically intended for debugging or display purposes and adheres to the
+    ///     formatting rules defined in the current configuration.
+    /// </remarks>
+    /// <returns>
+    ///     A string representation of the quantity.
+    /// </returns>
+    public override string ToString()
+    {
+        return ToString(DefaultFormatSpecifier);
+    }
+
+    /// <summary>
+    ///     Returns a string representation of the quantity debug proxy, formatted according to the specified format string.
+    /// </summary>
+    /// <param name="format">
+    ///     A format string that specifies how the quantity should be formatted. If <c>null</c>, the default format specifier
+    ///     is used.
+    /// </param>
+    /// <returns>
+    ///     A string representation of the quantity debug proxy, formatted according to the specified format string.
+    /// </returns>
+    /// <remarks>
+    ///     This method provides a way to customize the string representation of the quantity debug proxy for debugging
+    ///     purposes.
+    /// </remarks>
+    public string ToString(string format)
+    {
+        return ToString(format, DefaultFormatProvider);
+    }
+
+    /// <summary>
+    ///     Converts the quantity to its string representation using the specified format and format provider.
+    /// </summary>
+    /// <param name="format">
+    ///     A standard or custom format string that determines how the quantity is formatted.
+    ///     If <c>null</c>, a default format is used.
+    /// </param>
+    /// <param name="formatProvider">
+    ///     An object that provides culture-specific formatting information. If <c>null</c>, the current culture is used.
+    /// </param>
+    /// <returns>
+    ///     A string representation of the quantity, formatted according to the specified format and format provider.
+    /// </returns>
+    /// <remarks>
+    ///     This method utilizes the <see cref="QuantityFormatter" /> to format the quantity.
+    ///     The resulting string typically includes the quantity's value and its unit abbreviation.
+    /// </remarks>
+    public string ToString(string? format, IFormatProvider? formatProvider)
+    {
+        return Configuration.Formatter.Format(_quantity, format, formatProvider);
+    }
+
+    /// <summary>
+    ///     The default display format string used for debugging quantities.
+    /// </summary>
+    /// <remarks>
+    ///     This constant defines the format string applied to quantities when displayed in the debugger.
+    ///     It utilizes the <see cref="QuantityFormats" /> to format the quantity's value and unit
+    ///     in a concise and human-readable manner.
+    /// </remarks>
+    public const string DisplayFormat = "{UnitsNet.Debug.QuantityDebugProxy.Format(this), nq}";
+
+    private static UnitsNetSetup GetConfiguration(QuantityInfo quantityInfo)
+    {
+        // we want to avoid initializing the default configuration from the debug proxy (e.g. when debugging the configuration initialization)
+        if (UnitsNetSetup.DefaultConfiguration.IsValueCreated)
+        {
+            // we could check for UnitsNetSetup.Default.QuantityInfoLookup.ByName.ContainsKey(quantity.QuantityInfo.Name)
+            // but that would cause the initialization of the lazy dictionary and would hide potential issues with quantities that are not part of the default configuration
+            return UnitsNetSetup.Default;
+        }
+        
+        return UnitsNetSetup.Create(builder => builder.WithQuantities([quantityInfo]));
+    }
+
+    /// <summary>
+    ///     The default format string used for debugging representations of quantities.
+    /// </summary>
+    /// <remarks>
+    ///     This format string is applied when no specific format is provided during the formatting
+    ///     of a quantity for debugging purposes. The default value is "G", which represents the general format.
+    /// </remarks>
+    public static string DefaultFormatSpecifier { get; set; } = "G";
+
+    /// <summary>
+    ///     Gets or sets the default format provider used for formatting quantities in debug scenarios.
+    /// </summary>
+    /// <remarks>
+    ///     This field determines the culture-specific formatting rules applied when formatting quantities.
+    ///     If set to <c>null</c>, the default culture of the current thread is used.
+    /// </remarks>
+    public static CultureInfo DefaultFormatProvider { get; set; } = CultureInfo.CurrentCulture;
+
+    /// <summary>
+    ///     Formats the specified quantity into its string representation using the provided format.
+    /// </summary>
+    /// <param name="quantity">
+    ///     The quantity to be formatted. This includes its value and associated unit.
+    /// </param>
+    /// <param name="format">
+    ///     A standard or custom format string that determines how the quantity is formatted.
+    ///     If <c>null</c>, a default format is used.
+    /// </param>
+    /// <param name="formatProvider">An optional format provider to use.</param>
+    /// <returns>
+    ///     A string representation of the quantity, formatted according to the specified format.
+    /// </returns>
+    /// <remarks>
+    ///     This method creates a <see cref="QuantityDebugProxy" /> instance for the given quantity
+    ///     and utilizes its <see cref="QuantityDebugProxy.ToString(string?, IFormatProvider?)" /> method
+    ///     to generate the formatted string.
+    /// </remarks>
+    public static string Format<TQuantity>(TQuantity quantity, string? format = null, IFormatProvider? formatProvider = null)
+        where TQuantity : IQuantity
+    {
+        try
+        {
+#pragma warning disable CS0618 // Type or member is obsolete
+            UnitsNetSetup configuration = GetConfiguration(quantity.QuantityInfo);
+#pragma warning restore CS0618 // Type or member is obsolete
+            return configuration.Formatter.Format(quantity, format ?? DefaultFormatSpecifier, formatProvider ?? DefaultFormatProvider);
+        }
+        catch (Exception)
+        {
+            // the debugger's inline evaluator that comes with the resharper extension fails to evaluate some expressions
+            // see https://youtrack.jetbrains.com/issue/RSRP-499956/Local-Variable-Inline-Evaluation-Fails-for-System.Type
+            // and https://youtrack.jetbrains.com/issue/RSRP-502262/Cannot-evaluate-expressions-with-DebuggerTypeProxy-and-DebuggerDisplay
+            try
+            {
+#pragma warning disable CS0618 // Type or member is obsolete
+                QuantityInfo quantityInfo = quantity.QuantityInfo;
+#pragma warning restore CS0618 // Type or member is obsolete
+                return $"{{{quantity.Value} {quantityInfo[quantity.UnitKey].PluralName}}}";
+            }
+            catch (Exception)
+            {
+                return $"{{{quantity.Value} {quantity.UnitKey}}}";
+            }
+        }
+    }
+}
diff --git a/UnitsNet/CustomCode/Debug/QuantityFormats.cs b/UnitsNet/CustomCode/Debug/QuantityFormats.cs
new file mode 100644
index 0000000000..f35b510072
--- /dev/null
+++ b/UnitsNet/CustomCode/Debug/QuantityFormats.cs
@@ -0,0 +1,161 @@
+using System.ComponentModel;
+
+namespace UnitsNet.Debug;
+
+/// <summary>
+///     Represents a display of string formats for a quantity, providing formatted string representations
+///     such as general and short formats.
+/// </summary>
+/// <remarks>
+///     This struct is used to format and display quantities in various string representations,
+///     leveraging the configuration provided by <see cref="UnitsNetSetup" />.
+/// </remarks>
+[DebuggerDisplay("{ToString()}")]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public readonly struct QuantityFormats
+{
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private readonly QuantityDebugProxy _quantityProxy;
+
+    internal QuantityFormats(QuantityDebugProxy quantityProxy)
+    {
+        _quantityProxy = quantityProxy;
+    }
+
+    /// <summary>
+    ///     Gets the general string representation of the quantity using the default general format specifier ("G").
+    /// </summary>
+    /// <value>
+    ///     A string representing the quantity in a general format.
+    /// </value>
+    /// <remarks>
+    ///     This property utilizes the <see cref="UnitsNet.QuantityFormatter" /> to format the quantity
+    ///     with the general format specifier defined by <see cref="GeneralFormatSpecifier" />.
+    /// </remarks>
+    public string GeneralFormat
+    {
+        get => _quantityProxy.ToString(GeneralFormatSpecifier);
+    }
+
+    /// <summary>
+    ///     Gets the scientific format representation of the quantity.
+    /// </summary>
+    /// <remarks>
+    ///     The scientific format uses the "E" format specifier, which represents the quantity
+    ///     in exponential notation, suitable for displaying very large or very small values.
+    /// </remarks>
+    public string ScientificFormat
+    {
+        get => _quantityProxy.ToString(ScientificFormatSpecifier);
+    }
+
+    /// <summary>
+    ///     Gets the fixed-point format representation of the quantity.
+    /// </summary>
+    /// <remarks>
+    ///     This property formats the quantity using the fixed-point format specifier ("F").
+    ///     It provides a string representation of the quantity with a fixed number of decimal places.
+    /// </remarks>
+    /// <value>
+    ///     A string representing the quantity in fixed-point format.
+    /// </value>
+    public string FixedPointFormat
+    {
+        get => _quantityProxy.ToString(FixedPointFormatSpecifier);
+    }
+
+    /// <summary>
+    ///     Gets the number format representation of the quantity.
+    /// </summary>
+    /// <remarks>
+    ///     This property formats the quantity using the "N" format specifier, which typically represents
+    ///     a numeric format with thousands separators and a fixed number of decimal places, depending on
+    ///     the current culture settings.
+    /// </remarks>
+    /// <value>
+    ///     A string representing the quantity in the number format.
+    /// </value>
+    public string NumberFormat
+    {
+        get => _quantityProxy.ToString(NumberFormatSpecifier);
+    }
+
+    /// <summary>
+    ///     Gets the short format string representation of the quantity.
+    /// </summary>
+    /// <remarks>
+    ///     The short format is typically a concise representation of the quantity,
+    ///     formatted using the "s" format specifier. This is useful for scenarios
+    ///     where a compact display of the quantity is required.
+    /// </remarks>
+    /// <returns>
+    ///     A string representing the quantity in its short format.
+    /// </returns>
+    public string ShortFormat
+    {
+        get => _quantityProxy.ToString(ShortFormatSpecifier);
+    }
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        return _quantityProxy.ToString();
+    }
+
+    /// <summary>
+    ///     The default format specifier used for general formatting of quantities.
+    /// </summary>
+    /// <remarks>
+    ///     This field defines the format string "G", which represents the general format for quantities.
+    ///     It is primarily used to provide a consistent and human-readable representation of quantities
+    ///     when no specific format is explicitly provided.
+    /// </remarks>
+    public static string GeneralFormatSpecifier { get; set; } = "G";
+
+    /// <summary>
+    ///     The default format specifier used for scientific formatting of quantities.
+    /// </summary>
+    /// <remarks>
+    ///     This field defines the format string "E", which represents the scientific format for quantities.
+    ///     It is primarily used to display quantities in exponential notation, providing a concise representation
+    ///     of very large or very small values.
+    /// </remarks>
+    public static string ScientificFormatSpecifier { get; set; } = "E";
+
+    /// <summary>
+    ///     The default format specifier used for fixed-point formatting of quantities.
+    /// </summary>
+    /// <remarks>
+    ///     This field defines the format string "F", which represents the fixed-point format for quantities.
+    ///     It is primarily used to display quantities with a fixed number of decimal places, ensuring precision
+    ///     and consistency in numerical representation.
+    /// </remarks>
+    public static string FixedPointFormatSpecifier { get; set; } = "F";
+
+    /// <summary>
+    ///     The default format specifier used for fixed-point formatting of quantities.
+    /// </summary>
+    /// <remarks>
+    ///     This field defines the format string "F", which represents the fixed-point format for quantities.
+    ///     It is primarily used to display quantities with a fixed number of decimal places, ensuring precision
+    ///     and consistency in numerical representation.
+    /// </remarks>
+    /// <summary>
+    ///     The default format specifier used for numeric formatting of quantities.
+    /// </summary>
+    /// <remarks>
+    ///     This field defines the format string "N", which represents the numeric format for quantities.
+    ///     It is used to display quantities with a standard numeric representation, including grouping
+    ///     separators and a configurable number of decimal places.
+    /// </remarks>
+    public static string NumberFormatSpecifier { get; set; } = "N";
+
+    /// <summary>
+    ///     Specifies the format string used to represent a quantity in a short format.
+    /// </summary>
+    /// <remarks>
+    ///     The short format specifier is typically used to produce a concise representation
+    ///     of a quantity, often including only the numerical value and a minimal unit abbreviation.
+    /// </remarks>
+    public static string ShortFormatSpecifier { get; set; } = "S";
+}
diff --git a/UnitsNet/CustomCode/Debug/QuantityInformation.cs b/UnitsNet/CustomCode/Debug/QuantityInformation.cs
new file mode 100644
index 0000000000..06c841b373
--- /dev/null
+++ b/UnitsNet/CustomCode/Debug/QuantityInformation.cs
@@ -0,0 +1,197 @@
+using System.ComponentModel;
+using System.Linq;
+
+namespace UnitsNet.Debug;
+
+/// <summary>
+///     Represents detailed information about a quantity, including its definition, unit conversions, and quantity
+///     conversions.
+/// </summary>
+/// <remarks>
+///     This struct is primarily used for debugging purposes to provide a comprehensive view of a quantity's components.
+///     It includes the quantity's definition, available unit conversions, and possible quantity conversions.
+/// </remarks>
+[DebuggerDisplay("{Definition.Name, nq}")]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public readonly struct QuantityInformation
+{
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private readonly QuantityDebugProxy _quantityProxy;
+
+    internal QuantityInformation(QuantityDebugProxy quantityProxy)
+    {
+        _quantityProxy = quantityProxy;
+        Definition = quantityProxy.QuantityInfo;
+    }
+
+    /// <summary>
+    ///     Gets the definition of the quantity, which includes its name, base unit, and other metadata.
+    /// </summary>
+    /// <remarks>
+    ///     The <see cref="QuantityInfo{TQuantity, TUnit}" /> provides detailed information about the quantity,
+    ///     such as its name, available units, and base dimensions. This property is useful for understanding
+    ///     the structure and characteristics of the quantity.
+    /// </remarks>
+    // [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+    public QuantityInfo Definition { get; }
+
+    /// <summary>
+    ///     Gets the array of unit conversions available for the quantity.
+    /// </summary>
+    /// <remarks>
+    ///     Each element in the array represents a conversion of the quantity to a specific unit,
+    ///     including its value in that unit, unit details, and formatted string representation.
+    ///     This property provides a detailed view of how the quantity can be expressed in different units.
+    /// </remarks>
+    public ConvertedQuantity[] UnitConversions
+    {
+        get
+        {
+            QuantityDebugProxy quantityProxy = _quantityProxy;
+            return Definition.UnitInfos.Select(unitInfo => new ConvertedQuantity(quantityProxy, unitInfo)).ToArray();
+        }
+    }
+
+    /// <summary>
+    ///     Gets the array of quantity conversions available for the current quantity.
+    /// </summary>
+    /// <remarks>
+    ///     Each <see cref="QuantityConversion" /> represents a possible transformation from the current quantity
+    ///     to another quantity type, enabling conversions between different quantity types within the UnitsNet library.
+    /// </remarks>
+    public QuantityConversion[] QuantityConversions
+    {
+        get
+        {
+            QuantityDebugProxy quantityProxy = _quantityProxy;
+            return _quantityProxy.Configuration.UnitConverter.QuantityConversions.GetConversionsFrom(Definition)
+                .Select(targetQuantity => new QuantityConversion(quantityProxy, targetQuantity)).ToArray();
+        }
+    }
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        return Definition.Name;
+    }
+}
+
+/// <summary>
+///     Represents a converted quantity, which includes the value of the quantity in a specific unit,
+///     its associated unit information, and its abbreviation display.
+/// </summary>
+/// <remarks>
+///     This struct is used to provide detailed information about a quantity converted to a specific unit,
+///     including its value, unit details, and formatted string representation.
+/// </remarks>
+[DebuggerDisplay("{ToString(), nq}")]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public readonly struct ConvertedQuantity
+{
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private readonly QuantityDebugProxy _quantityProxy;
+
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private readonly UnitInfo _targetUnit;
+
+    internal ConvertedQuantity(QuantityDebugProxy quantityProxy, UnitInfo targetUnit)
+    {
+        _quantityProxy = quantityProxy;
+        _targetUnit = targetUnit;
+    }
+
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private QuantityDebugProxy Converted
+    {
+        get => _quantityProxy.ConvertTo(_targetUnit);
+    }
+
+    /// <summary>
+    ///     Gets detailed information about the unit associated with the converted quantity.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides metadata about the unit, including its definition and possible conversions.
+    ///     It is useful for accessing unit-related details and performing operations within the context of the converted
+    ///     quantity.
+    /// </remarks>
+    public UnitInformation Unit
+    {
+        get => new(_quantityProxy, _targetUnit);
+    }
+
+    /// <summary>
+    ///     Gets the display information for the unit abbreviation of the converted quantity.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides access to the default and parseable abbreviations for the unit of the converted quantity.
+    ///     It allows for consistent and localized representation of unit abbreviations.
+    /// </remarks>
+    public UnitAbbreviation UnitAbbreviation
+    {
+        get => new(Converted);
+    }
+
+    /// <summary>
+    ///     Gets the numerical value of the converted quantity in its specific unit.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides the raw numerical representation of the quantity after it has been converted
+    ///     to the specified unit. It is useful for calculations or comparisons involving the converted quantity.
+    /// </remarks>
+    public QuantityValue Value
+    {
+        get => Converted.Value;
+    }
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        return Converted.ToString();
+    }
+}
+
+/// <summary>
+///     Represents a conversion between two quantities, allowing for the transformation of a quantity's value
+///     from one unit system to another. This struct is used to facilitate conversions between different
+///     quantity types within the context of the UnitsNet library.
+/// </summary>
+[DebuggerDisplay("{ToString()}")]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public readonly struct QuantityConversion
+{
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private readonly QuantityDebugProxy _quantityProxy;
+
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private readonly QuantityInfo _targetQuantity;
+
+    internal QuantityConversion(QuantityDebugProxy quantityProxy, QuantityInfo targetQuantity)
+    {
+        _quantityProxy = quantityProxy;
+        _targetQuantity = targetQuantity;
+    }
+
+    /// <summary>
+    ///     Gets the converted quantity as an <see cref="IQuantity" /> instance.
+    ///     This property performs the conversion of the original quantity to the target quantity type
+    ///     using the specified unit conversion logic.
+    /// </summary>
+    /// <value>
+    ///     The converted quantity represented as an <see cref="IQuantity" />.
+    /// </value>
+    /// <remarks>
+    ///     This property utilizes the <see cref="UnitConverter" /> to transform the value and unit of the original quantity
+    ///     into the corresponding representation in the target quantity type.
+    /// </remarks>
+    [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+    public IQuantity Quantity
+    {
+        get => _quantityProxy.ConvertToQuantity(_targetQuantity);
+    }
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        return _targetQuantity.ToString();
+    }
+}
diff --git a/UnitsNet/CustomCode/Debug/UnitAbbreviation.cs b/UnitsNet/CustomCode/Debug/UnitAbbreviation.cs
new file mode 100644
index 0000000000..b14f71bd9a
--- /dev/null
+++ b/UnitsNet/CustomCode/Debug/UnitAbbreviation.cs
@@ -0,0 +1,146 @@
+using System.ComponentModel;
+using System.Globalization;
+using System.Linq;
+
+namespace UnitsNet.Debug;
+
+/// <summary>
+///     Represents the display information for unit abbreviations associated with a specific quantity.
+/// </summary>
+/// <remarks>
+///     This struct provides access to default and parseable abbreviations for units, as well as the default abbreviation
+///     for the current unit of the quantity.
+/// </remarks>
+[DebuggerDisplay("{DefaultAbbreviation}")]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public readonly struct UnitAbbreviation
+{
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private readonly QuantityDebugProxy _quantityProxy;
+
+    internal UnitAbbreviation(QuantityDebugProxy quantityProxy)
+    {
+        _quantityProxy = quantityProxy;
+        Abbreviations = quantityProxy.Configuration.UnitAbbreviations.GetUnitAbbreviations(quantityProxy.UnitKey, QuantityDebugProxy.DefaultFormatProvider);
+    }
+
+    /// <summary>
+    ///     Gets the default abbreviation for the current unit of the quantity.
+    /// </summary>
+    /// <remarks>
+    ///     The default abbreviation is determined based on the unit key of the quantity and the configured unit abbreviations
+    ///     cache.
+    /// </remarks>
+    /// <value>
+    ///     A <see cref="string" /> representing the default abbreviation for the current unit.
+    /// </value>
+    /// <exception cref="UnitNotFoundException">
+    ///     Thrown when no unit information is found for the specified unit key.
+    /// </exception>
+    /// <exception cref="InvalidOperationException">
+    ///     Thrown when no abbreviations are mapped for the specified unit.
+    /// </exception>
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    public string DefaultAbbreviation
+    {
+        get => Abbreviations[0];
+    }
+
+    /// <summary>
+    ///     Gets a read-only list of unit abbreviations associated with the current quantity.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides all abbreviations that can represent the unit of the current quantity.
+    ///     These abbreviations are culture-sensitive and may vary depending on the localization settings.
+    /// </remarks>
+    /// <value>
+    ///     A read-only list of strings representing the unit abbreviations.
+    /// </value>
+    /// <exception cref="UnitNotFoundException">
+    ///     Thrown when no unit information is found for the specified unit key.
+    /// </exception>
+    [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+    public IReadOnlyList<string> Abbreviations { get; }
+
+    /// <summary>
+    ///     Gets the collection of parseable unit abbreviations for the associated quantity.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides an array of <see cref="UnitsNet.Debug.UnitAbbreviations" /> objects,
+    ///     each representing the abbreviations that can be parsed for a specific unit of the quantity.
+    /// </remarks>
+    public UnitAbbreviations[] UnitAbbreviations
+    {
+        get
+        {
+            QuantityDebugProxy quantityProxy = _quantityProxy;
+            return quantityProxy.QuantityInfo.UnitInfos.Select(targetUnit => new UnitAbbreviations(quantityProxy, targetUnit)).ToArray();
+        }
+    }
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        return DefaultAbbreviation;
+    }
+}
+
+/// <summary>
+///     Represents a collection of unit abbreviations for a specific unit of a quantity.
+/// </summary>
+/// <remarks>
+///     This struct provides access to the unit's abbreviations and allows conversion of the quantity to the specified
+///     unit.
+/// </remarks>
+[DebuggerDisplay("{ToString(), nq}")]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public readonly struct UnitAbbreviations
+{
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private QuantityDebugProxy QuantityProxy { get; }
+
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private UnitInfo TargetUnit { get; }
+
+    internal UnitAbbreviations(QuantityDebugProxy quantityProxy, UnitInfo targetUnit)
+    {
+        QuantityProxy = quantityProxy;
+        TargetUnit = targetUnit;
+    }
+
+    /// <summary>
+    ///     Gets a debug proxy representation of the quantity associated with the current unit.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides a converted view of the quantity in the context of the specified unit,
+    ///     enabling detailed inspection of its components during debugging.
+    /// </remarks>
+    [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+    public QuantityDebugProxy Quantity
+    {
+        get => QuantityProxy.ConvertTo(TargetUnit);
+    }
+
+    /// <summary>
+    ///     Gets the list of abbreviations associated with the target unit.
+    /// </summary>
+    /// <remarks>
+    ///     The abbreviations are retrieved from the <see cref="UnitAbbreviationsCache" /> configured in the
+    ///     <see cref="QuantityDebugProxy" />. These abbreviations are culture-sensitive and may vary based on the
+    ///     current culture or a fallback culture.
+    /// </remarks>
+    /// <value>
+    ///     A read-only list of strings representing the abbreviations for the target unit.
+    /// </value>
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    public IReadOnlyList<string> Abbreviations
+    {
+        get => QuantityProxy.Configuration.UnitAbbreviations.GetAbbreviationsWithFallbackCulture(TargetUnit, QuantityDebugProxy.DefaultFormatProvider ?? CultureInfo.CurrentCulture);
+    }
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        return string.Join(", ", Abbreviations.Select(x => $"\"{x}\""));
+    }
+}
diff --git a/UnitsNet/CustomCode/Debug/UnitInformation.cs b/UnitsNet/CustomCode/Debug/UnitInformation.cs
new file mode 100644
index 0000000000..ae8985bd0e
--- /dev/null
+++ b/UnitsNet/CustomCode/Debug/UnitInformation.cs
@@ -0,0 +1,106 @@
+using System.ComponentModel;
+using System.Linq;
+
+namespace UnitsNet.Debug;
+
+/// <summary>
+///     Represents information about a specific unit within a quantity.
+/// </summary>
+/// <remarks>
+///     This struct provides details about a unit, including its definition and possible conversions.
+///     It is used to encapsulate unit-related metadata and operations within the context of a quantity.
+/// </remarks>
+[DebuggerDisplay("{Definition.Name, nq}")]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public readonly struct UnitInformation
+{
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private readonly QuantityDebugProxy _quantityProxy;
+
+    internal UnitInformation(QuantityDebugProxy quantityProxy, UnitInfo unitInfo)
+    {
+        _quantityProxy = quantityProxy;
+        Definition = unitInfo;
+    }
+
+    /// <summary>
+    ///     Gets the definition of the unit, including its metadata and associated details.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides access to the unit's definition, which includes its name, value, and other metadata.
+    ///     It is useful for retrieving information about the specific unit represented within the context of a quantity.
+    /// </remarks>
+    // [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+    public UnitInfo Definition { get; }
+
+    /// <summary>
+    ///     Gets the collection of unit conversions associated with the current unit.
+    /// </summary>
+    /// <remarks>
+    ///     Each <see cref="UnitConversion" /> in the collection represents a possible conversion
+    ///     from the current unit to another unit within the same quantity.
+    ///     This property is useful for enumerating all available conversions for a unit.
+    /// </remarks>
+    public UnitConversion[] UnitConversions
+    {
+        get
+        {
+            QuantityDebugProxy quantityProxy = _quantityProxy;
+            return quantityProxy.QuantityInfo.UnitInfos.Select(unit => new UnitConversion(quantityProxy, unit)).ToArray();
+        }
+    }
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        return Definition.ToString();
+    }
+}
+
+/// <summary>
+///     Represents a unit conversion for a specific quantity and unit type.
+/// </summary>
+/// <remarks>
+///     This struct provides functionality to convert a quantity to a specific unit and retrieve its display
+///     representation.
+///     It is primarily used internally within the <see cref="QuantityDebugProxy" /> struct.
+/// </remarks>
+[DebuggerDisplay("{TargetUnit.Value, nq}")]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public readonly struct UnitConversion
+{
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private QuantityDebugProxy QuantityProxy { get; }
+
+    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+    private UnitInfo TargetUnit { get; }
+
+    internal UnitConversion(QuantityDebugProxy quantityProxy, UnitInfo targetUnit)
+    {
+        QuantityProxy = quantityProxy;
+        TargetUnit = targetUnit;
+    }
+
+    /// <summary>
+    ///     Gets the quantity representation after converting to the specified unit.
+    /// </summary>
+    /// <remarks>
+    ///     This property provides a <see cref="QuantityDebugProxy" /> instance that represents the quantity
+    ///     converted to the unit specified by the <see cref="UnitConversion" />.
+    ///     It utilizes the <see cref="UnitConverter" /> for the conversion process.
+    /// </remarks>
+    /// <value>
+    ///     A <see cref="QuantityDebugProxy" /> instance representing the converted quantity.
+    /// </value>
+    [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+    public QuantityDebugProxy Quantity
+    {
+        get => QuantityProxy.ConvertTo(TargetUnit);
+    }
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        return TargetUnit.ToString();
+    }
+}
diff --git a/UnitsNet/CustomCode/Quantities/AmountOfSubstance.extra.cs b/UnitsNet/CustomCode/Quantities/AmountOfSubstance.extra.cs
index 83b85777cf..561cadf8d2 100644
--- a/UnitsNet/CustomCode/Quantities/AmountOfSubstance.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/AmountOfSubstance.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 // ReSharper disable once CheckNamespace
@@ -22,16 +22,15 @@ public partial struct AmountOfSubstance
         ///     is planned to take effect on 20 May 2019. The value of the constant will be fixed to exactly 6.02214076×1023 mol−1.
         ///     See here: https://www.bipm.org/utils/common/pdf/CGPM-2018/26th-CGPM-Resolutions.pdf
         /// </remarks>
-        public static double AvogadroConstant { get; } = 6.02214076e23;
+        public static QuantityValue AvogadroConstant { get; } = 6.02214076e23m;
 
         /// <summary>
         /// Calculates the number of particles (atoms or molecules) in this amount of substance using the <see cref="AvogadroConstant"/>.
         /// </summary>
         /// <returns>The number of particles (atoms or molecules) in this amount of substance.</returns>
-        public double NumberOfParticles()
+        public QuantityValue NumberOfParticles()
         {
-            var moles = ToUnit(AmountOfSubstanceUnit.Mole);
-            return AvogadroConstant * moles.Value;
+            return AvogadroConstant * this.As(AmountOfSubstanceUnit.Mole);
         }
 
         /// <summary>Get <see cref="AmountOfSubstance" /> from <see cref="Mass" /> and a given <see cref="MolarMass" />.</summary>
diff --git a/UnitsNet/CustomCode/Quantities/AmplitudeRatio.extra.cs b/UnitsNet/CustomCode/Quantities/AmplitudeRatio.extra.cs
index cc0a3cfcdf..71efeffa13 100644
--- a/UnitsNet/CustomCode/Quantities/AmplitudeRatio.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/AmplitudeRatio.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -15,43 +15,57 @@ public partial struct AmplitudeRatio
         ///     resistance.
         /// </summary>
         /// <param name="voltage">The electric potential referenced to one volt.</param>
-        public AmplitudeRatio(ElectricPotential voltage)
+        /// <param name="significantDigits">The number of significant digits to use in the calculation. Default is 15.</param>
+        /// <exception cref="T:System.ArgumentOutOfRangeException">
+        ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+        /// </exception>
+        public AmplitudeRatio(ElectricPotential voltage, byte significantDigits = 15)
             : this()
         {
-            if (voltage.Volts <= 0)
+            if (!QuantityValue.IsPositive(voltage.Value))
+            {
                 throw new ArgumentOutOfRangeException(
                     nameof(voltage),
                     "The base-10 logarithm of a number ≤ 0 is undefined. Voltage must be greater than 0 V.");
+            }
 
             // E(dBV) = 20*log10(value(V)/reference(V))
-            _value = 20 * Math.Log10(voltage.Volts / 1);
+            _value = voltage.Volts.ToLogSpace(LogarithmicScalingFactor, significantDigits);
             _unit = AmplitudeRatioUnit.DecibelVolt;
         }
 
         /// <summary>
         ///     Gets an <see cref="ElectricPotential" /> from this <see cref="AmplitudeRatio" />.
         /// </summary>
+        /// <param name="significantDigits">The number of significant digits to use in the calculation. Default is 15.</param>
+        /// <exception cref="T:System.ArgumentOutOfRangeException">
+        ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+        /// </exception>
         /// <remarks>
         ///     Provides a nicer syntax for converting an amplitude ratio back to a voltage.
         ///     <example>
         ///         <c>var voltage = voltageRatio.ToElectricPotential();</c>
         ///     </example>
         /// </remarks>
-        public ElectricPotential ToElectricPotential()
+        public ElectricPotential ToElectricPotential(byte significantDigits = 15)
         {
             // E(V) = 1V * 10^(E(dBV)/20)
-            return ElectricPotential.FromVolts( Math.Pow( 10, DecibelVolts / 20 ) );
+            return ElectricPotential.FromVolts(DecibelVolts.ToLinearSpace(LogarithmicScalingFactor, significantDigits));
         }
 
         /// <summary>
         ///     Converts this <see cref="AmplitudeRatio" /> to a <see cref="PowerRatio" />.
         /// </summary>
         /// <param name="impedance">The input impedance of the load. This is usually 50, 75 or 600 ohms.</param>
+        /// <param name="significantDigits">The number of significant digits to use in the calculation. Default is 15.</param>
+        /// <exception cref="T:System.ArgumentOutOfRangeException">
+        ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+        /// </exception>
         /// <remarks>http://www.maximintegrated.com/en/app-notes/index.mvp/id/808</remarks>
-        public PowerRatio ToPowerRatio( ElectricResistance impedance )
+        public PowerRatio ToPowerRatio(ElectricResistance impedance, byte significantDigits = 15)
         {
             // P(dBW) = E(dBV) - 10*log10(Z(Ω)/1)
-            return PowerRatio.FromDecibelWatts( DecibelVolts - 10 * Math.Log10( impedance.Ohms / 1 ) );
+            return PowerRatio.FromDecibelWatts(DecibelVolts - impedance.Ohms.ToLogSpace(LogarithmicScalingFactor / 2, significantDigits));
         }
 
         #region Static Methods
@@ -61,9 +75,13 @@ public PowerRatio ToPowerRatio( ElectricResistance impedance )
         ///     <see cref="ElectricPotential" />.
         /// </summary>
         /// <param name="voltage">The voltage (electric potential) relative to one volt RMS.</param>
-        public static AmplitudeRatio FromElectricPotential(ElectricPotential voltage)
+        /// <param name="significantDigits">The number of significant digits to use in the calculation. Default is 15.</param>
+        /// <exception cref="T:System.ArgumentOutOfRangeException">
+        ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+        /// </exception>
+        public static AmplitudeRatio FromElectricPotential(ElectricPotential voltage, byte significantDigits = 15)
         {
-            return new AmplitudeRatio(voltage);
+            return new AmplitudeRatio(voltage, significantDigits);
         }
 
         #endregion
diff --git a/UnitsNet/CustomCode/Quantities/Area.extra.cs b/UnitsNet/CustomCode/Quantities/Area.extra.cs
index 3a9d28e973..06cbb80c6c 100644
--- a/UnitsNet/CustomCode/Quantities/Area.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Area.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -12,14 +12,14 @@ public partial struct Area
         /// <summary>Get circle area from a diameter.</summary>
         public static Area FromCircleDiameter(Length diameter)
         {
-            var radius = Length.FromMeters(diameter.Meters / 2d);
+            var radius = Length.FromMeters(diameter.Meters / 2);
             return FromCircleRadius(radius);
         }
 
         /// <summary>Get circle area from a radius.</summary>
         public static Area FromCircleRadius(Length radius)
         {
-            return FromSquareMeters(Math.PI * radius.Meters * radius.Meters);
+            return FromSquareMeters(QuantityValue.PI * radius.Meters * radius.Meters);
         }
 
         #endregion
diff --git a/UnitsNet/CustomCode/Quantities/Duration.extra.cs b/UnitsNet/CustomCode/Quantities/Duration.extra.cs
index b72b51285a..7c212bd70d 100644
--- a/UnitsNet/CustomCode/Quantities/Duration.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Duration.extra.cs
@@ -1,102 +1,108 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
-using UnitsNet.Units;
+using System.Numerics;
 
-namespace UnitsNet
+namespace UnitsNet;
+
+public partial struct Duration
 {
-    public partial struct Duration
+    /// <summary>
+    ///     Convert a Duration to a TimeSpan.
+    /// </summary>
+    /// <exception cref="ArgumentOutOfRangeException">
+    ///     Throws if the duration exceeds the <see cref="TimeSpan" />.<see cref="TimeSpan.MaxValue" /> or
+    ///     <see cref="TimeSpan.MinValue" />, which would cause it to roll over from positive to negative and vice versa.
+    /// </exception>
+    /// <returns>The TimeSpan with the same time as the duration</returns>
+    public TimeSpan ToTimeSpan()
     {
-        /// <summary>
-        ///     Convert a Duration to a TimeSpan.
-        /// </summary>
-        /// <exception cref="ArgumentOutOfRangeException">
-        ///     Throws if the duration exceeds the <see cref="TimeSpan"/>.<see cref="TimeSpan.MaxValue"/> or
-        ///     <see cref="TimeSpan.MinValue"/>, which would cause it to roll over from positive to negative and vice versa.
-        /// </exception>
-        /// <returns>The TimeSpan with the same time as the duration</returns>
-        public TimeSpan ToTimeSpan()
+        var ticks = (BigInteger)(Seconds * TimeSpan.TicksPerSecond);
+        if (ticks > TimeSpan.MaxValue.Ticks)
         {
-            if (Seconds > TimeSpan.MaxValue.TotalSeconds) throw new ArgumentOutOfRangeException(nameof(Seconds),
-                    "The duration is too large for a TimeSpan, which would roll over from positive to negative.");
-
-            if (Seconds < TimeSpan.MinValue.TotalSeconds) throw new ArgumentOutOfRangeException(nameof(Seconds),
-                    "The duration is too small for a TimeSpan, which would roll over from negative to positive.");
-
-            return TimeSpan.FromTicks((long)(Seconds * TimeSpan.TicksPerSecond));
+            throw new ArgumentOutOfRangeException(nameof(ticks),
+                "The duration is too large for a TimeSpan, which would roll over from positive to negative.");
         }
 
-        /// <summary>Get <see cref="DateTime"/> from <see cref="DateTime"/> plus <see cref="Duration"/>.</summary>
-        public static DateTime operator +(DateTime time, Duration duration)
+        if (ticks < TimeSpan.MinValue.Ticks)
         {
-            return time.AddSeconds(duration.Seconds);
+            throw new ArgumentOutOfRangeException(nameof(ticks),
+                "The duration is too small for a TimeSpan, which would roll over from negative to positive.");
         }
 
-        /// <summary>Get <see cref="DateTime"/> from <see cref="DateTime"/> minus <see cref="Duration"/>.</summary>
-        public static DateTime operator -(DateTime time, Duration duration)
-        {
-            return time.AddSeconds(-duration.Seconds);
-        }
+        return TimeSpan.FromTicks((long)ticks);
+    }
 
-        /// <summary>Implicitly cast <see cref="Duration"/> to <see cref="TimeSpan"/>.</summary>
-        public static implicit operator TimeSpan(Duration duration)
-        {
-            return duration.ToTimeSpan();
-        }
+    /// <summary>Get <see cref="DateTime" /> from <see cref="DateTime" /> plus <see cref="Duration" />.</summary>
+    public static DateTime operator +(DateTime time, Duration duration)
+    {
+        return time + duration.ToTimeSpan();
+    }
 
-        /// <summary>Implicitly cast <see cref="TimeSpan"/> to <see cref="Duration"/>.</summary>
-        public static implicit operator Duration(TimeSpan duration)
-        {
-            return FromSeconds(duration.TotalSeconds);
-        }
+    /// <summary>Get <see cref="DateTime" /> from <see cref="DateTime" /> minus <see cref="Duration" />.</summary>
+    public static DateTime operator -(DateTime time, Duration duration)
+    {
+        return time - duration.ToTimeSpan();
+    }
 
-        /// <summary>True if <see cref="Duration"/> is less than <see cref="TimeSpan"/>.</summary>
-        public static bool operator <(Duration duration, TimeSpan timeSpan)
-        {
-            return duration.Seconds < timeSpan.TotalSeconds;
-        }
+    /// <summary>Implicitly cast <see cref="Duration" /> to <see cref="TimeSpan" />.</summary>
+    public static implicit operator TimeSpan(Duration duration)
+    {
+        return duration.ToTimeSpan();
+    }
 
-        /// <summary>True if <see cref="Duration"/> is greater than <see cref="TimeSpan"/>.</summary>
-        public static bool operator >(Duration duration, TimeSpan timeSpan)
-        {
-            return duration.Seconds > timeSpan.TotalSeconds;
-        }
+    /// <summary>Implicitly cast <see cref="TimeSpan" /> to <see cref="Duration" />.</summary>
+    public static implicit operator Duration(TimeSpan duration)
+    {
+        return FromSeconds(new QuantityValue(duration.Ticks, TimeSpan.TicksPerSecond));
+    }
 
-        /// <summary>True if <see cref="Duration"/> is less than or equal to <see cref="TimeSpan"/>.</summary>
-        public static bool operator <=(Duration duration, TimeSpan timeSpan)
-        {
-            return duration.Seconds <= timeSpan.TotalSeconds;
-        }
+    /// <summary>True if <see cref="Duration" /> is less than <see cref="TimeSpan" />.</summary>
+    public static bool operator <(Duration duration, TimeSpan timeSpan)
+    {
+        return duration.Seconds * TimeSpan.TicksPerSecond < timeSpan.Ticks;
+    }
 
-        /// <summary>True if <see cref="Duration"/> is greater than or equal to <see cref="TimeSpan"/>.</summary>
-        public static bool operator >=(Duration duration, TimeSpan timeSpan)
-        {
-            return duration.Seconds >= timeSpan.TotalSeconds;
-        }
+    /// <summary>True if <see cref="Duration" /> is greater than <see cref="TimeSpan" />.</summary>
+    public static bool operator >(Duration duration, TimeSpan timeSpan)
+    {
+        return duration.Seconds * TimeSpan.TicksPerSecond > timeSpan.Ticks;
+    }
 
-        /// <summary>True if <see cref="TimeSpan"/> is less than <see cref="Duration"/>.</summary>
-        public static bool operator <(TimeSpan timeSpan, Duration duration)
-        {
-            return timeSpan.TotalSeconds < duration.Seconds;
-        }
+    /// <summary>True if <see cref="Duration" /> is less than or equal to <see cref="TimeSpan" />.</summary>
+    public static bool operator <=(Duration duration, TimeSpan timeSpan)
+    {
+        return duration.Seconds * TimeSpan.TicksPerSecond <= timeSpan.Ticks;
+    }
 
-        /// <summary>True if <see cref="TimeSpan"/> is greater than <see cref="Duration"/>.</summary>
-        public static bool operator >(TimeSpan timeSpan, Duration duration)
-        {
-            return timeSpan.TotalSeconds > duration.Seconds;
-        }
+    /// <summary>True if <see cref="Duration" /> is greater than or equal to <see cref="TimeSpan" />.</summary>
+    public static bool operator >=(Duration duration, TimeSpan timeSpan)
+    {
+        return duration.Seconds * TimeSpan.TicksPerSecond >= timeSpan.Ticks;
+    }
 
-        /// <summary>True if <see cref="TimeSpan"/> is less than or equal to <see cref="Duration"/>.</summary>
-        public static bool operator <=(TimeSpan timeSpan, Duration duration)
-        {
-            return timeSpan.TotalSeconds <= duration.Seconds;
-        }
+    /// <summary>True if <see cref="TimeSpan" /> is less than <see cref="Duration" />.</summary>
+    public static bool operator <(TimeSpan timeSpan, Duration duration)
+    {
+        return timeSpan.Ticks < duration.Seconds * TimeSpan.TicksPerSecond;
+    }
 
-        /// <summary>True if <see cref="TimeSpan"/> is greater than or equal to <see cref="Duration"/>.</summary>
-        public static bool operator >=(TimeSpan timeSpan, Duration duration)
-        {
-            return timeSpan.TotalSeconds >= duration.Seconds;
-        }
+    /// <summary>True if <see cref="TimeSpan" /> is greater than <see cref="Duration" />.</summary>
+    public static bool operator >(TimeSpan timeSpan, Duration duration)
+    {
+        return timeSpan.Ticks > duration.Seconds * TimeSpan.TicksPerSecond;
+    }
+
+    /// <summary>True if <see cref="TimeSpan" /> is less than or equal to <see cref="Duration" />.</summary>
+    public static bool operator <=(TimeSpan timeSpan, Duration duration)
+    {
+        return timeSpan.Ticks <= duration.Seconds * TimeSpan.TicksPerSecond;
+    }
+
+    /// <summary>True if <see cref="TimeSpan" /> is greater than or equal to <see cref="Duration" />.</summary>
+    public static bool operator >=(TimeSpan timeSpan, Duration duration)
+    {
+        return timeSpan.Ticks >= duration.Seconds * TimeSpan.TicksPerSecond;
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/ElectricApparentPower.extra.cs b/UnitsNet/CustomCode/Quantities/ElectricApparentPower.extra.cs
index 743f2c1524..abdade030e 100644
--- a/UnitsNet/CustomCode/Quantities/ElectricApparentPower.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/ElectricApparentPower.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet/CustomCode/Quantities/ElectricPotential.extra.cs b/UnitsNet/CustomCode/Quantities/ElectricPotential.extra.cs
index 5a807c63c5..1a7a275e98 100644
--- a/UnitsNet/CustomCode/Quantities/ElectricPotential.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/ElectricPotential.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet
diff --git a/UnitsNet/CustomCode/Quantities/EnergyDensity.extra.cs b/UnitsNet/CustomCode/Quantities/EnergyDensity.extra.cs
index 811267d7f9..fd65aaa409 100644
--- a/UnitsNet/CustomCode/Quantities/EnergyDensity.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/EnergyDensity.extra.cs
@@ -1,4 +1,4 @@
-using UnitsNet.Units;
+using UnitsNet.Units;
 
 namespace UnitsNet
 {
@@ -17,7 +17,7 @@ public partial struct EnergyDensity
         ///     </para>
         /// </param>
         /// <param name = "conversionFactor">
-        ///     The <see cref = "double" /> that specifies the ratio of a natural gas volume in the standard condition to the natural gas volume in the operating condition.
+        ///     The <see cref = "Ratio" /> that specifies the ratio of a natural gas volume in the standard condition to the natural gas volume in the operating condition.
         ///     <para>
         ///         This value is normally shown on the invoice, otherwise it is to be requested from the supplier. For a rough approximation, a value of 100% for natural gas can be assumed.
         ///     </para>
@@ -28,9 +28,9 @@ public partial struct EnergyDensity
         /// <returns>
         ///     An <see cref = "Energy" /> that specifies the combustion energy of natural gas as consumed by the heating system.
         /// </returns>
-        public static Energy CombustionEnergy ( EnergyDensity energyDensity, Volume volume, Ratio conversionFactor )
+        public static Energy CombustionEnergy(EnergyDensity energyDensity, Volume volume, Ratio conversionFactor)
         {
-            return Energy.FromJoules ( (energyDensity * volume).As ( EnergyUnit.Joule ) * conversionFactor.DecimalFractions );
+            return Energy.FromJoules((energyDensity * volume).As(EnergyUnit.Joule) * conversionFactor.DecimalFractions);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/Force.extra.cs b/UnitsNet/CustomCode/Quantities/Force.extra.cs
index d729d18b18..6d01fb84f2 100644
--- a/UnitsNet/CustomCode/Quantities/Force.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Force.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using UnitsNet.Units;
@@ -10,7 +10,7 @@ public partial struct Force
         /// <summary>Get <see cref="Force"/> from <see cref="Pressure"/> divided by <see cref="Area"/>.</summary>
         public static Force FromPressureByArea(Pressure p, Area area)
         {
-            double newtons = p.Pascals * area.SquareMeters;
+            QuantityValue newtons = p.Pascals * area.SquareMeters;
             return new Force(newtons, ForceUnit.Newton);
         }
 
diff --git a/UnitsNet/CustomCode/Quantities/Length.extra.cs b/UnitsNet/CustomCode/Quantities/Length.extra.cs
index 138d9e9f7f..34c2e8bc8c 100644
--- a/UnitsNet/CustomCode/Quantities/Length.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Length.extra.cs
@@ -1,8 +1,9 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Text.RegularExpressions;
 using System.Threading;
 using UnitsNet.Units;
@@ -11,7 +12,7 @@ namespace UnitsNet
 {
     public partial struct Length
     {
-        private const double InchesInOneFoot = 12;
+        private static readonly QuantityValue InchesInOneFoot = 12;
 
         /// <summary>
         ///     Converts the length to a customary feet/inches combination.
@@ -20,18 +21,15 @@ public FeetInches FeetInches
         {
             get
             {
-                var inInches = Inches;
-                var feet = Math.Truncate(inInches / InchesInOneFoot);
-                var inches = inInches % InchesInOneFoot;
-
-                return new FeetInches(feet, inches);
+                QuantityValue totalInches = Inches;
+                return new FeetInches((BigInteger) (totalInches / InchesInOneFoot), totalInches % InchesInOneFoot);
             }
         }
 
         /// <summary>
         ///     Get length from combination of feet and inches.
         /// </summary>
-        public static Length FromFeetInches(double feet, double inches)
+        public static Length FromFeetInches(QuantityValue feet, QuantityValue inches)
         {
             return FromInches(InchesInOneFoot*feet + inches);
         }
@@ -82,7 +80,7 @@ public static bool TryParseFeetInches(string? str, out Length result, IFormatPro
             if (TryParse(str, formatProvider, out result))
                 return true;
 
-            var quantityParser = UnitsNetSetup.Default.QuantityParser;
+            QuantityParser quantityParser = QuantityParser.Default;
             string footRegex = quantityParser.CreateRegexPatternForUnit(LengthUnit.Foot, formatProvider, matchEntireString: false);
             string inchRegex = quantityParser.CreateRegexPatternForUnit(LengthUnit.Inch, formatProvider, matchEntireString: false);
 
@@ -122,7 +120,7 @@ public sealed class FeetInches
         /// <summary>
         ///     Construct from feet and inches.
         /// </summary>
-        public FeetInches(double feet, double inches)
+        public FeetInches(BigInteger feet, QuantityValue inches)
         {
             Feet = feet;
             Inches = inches;
@@ -131,12 +129,12 @@ public FeetInches(double feet, double inches)
         /// <summary>
         ///     The feet value it was constructed with.
         /// </summary>
-        public double Feet { get; }
+        public BigInteger Feet { get; }
 
         /// <summary>
         ///     The inches value it was constructed with.
         /// </summary>
-        public double Inches { get; }
+        public QuantityValue Inches { get; }
 
         /// <inheritdoc cref="ToString(IFormatProvider)"/>
         public override string ToString()
@@ -154,14 +152,17 @@ public override string ToString()
         /// </param>
         public string ToString(IFormatProvider? cultureInfo)
         {
-            cultureInfo = cultureInfo ?? CultureInfo.CurrentCulture;
+            if (cultureInfo is not CultureInfo unitLocalizationCulture)
+            {
+                cultureInfo = unitLocalizationCulture = CultureInfo.CurrentCulture;
+            }
 
-            var footUnit = Length.GetAbbreviation(LengthUnit.Foot, cultureInfo);
-            var inchUnit = Length.GetAbbreviation(LengthUnit.Inch, cultureInfo);
+            var footUnit = Length.GetAbbreviation(LengthUnit.Foot, unitLocalizationCulture);
+            var inchUnit = Length.GetAbbreviation(LengthUnit.Inch, unitLocalizationCulture);
 
             // Note that it isn't customary to use fractions - one wouldn't say "I am 5 feet and 4.5 inches".
             // So inches are rounded when converting from base units to feet/inches.
-            return string.Format(cultureInfo, "{0:n0} {1} {2:n0} {3}", Feet, footUnit, Math.Round(Inches), inchUnit);
+            return string.Format(cultureInfo, "{0:n0} {1} {2:n0} {3}", Feet, footUnit, Math.Round(Inches.ToDouble()), inchUnit);
         }
 
         /// <summary>
@@ -189,9 +190,10 @@ public string ToArchitecturalString(int fractionDenominator)
             {
                 throw new ArgumentOutOfRangeException(nameof(fractionDenominator), "Denominator for fractional inch must be greater than zero.");
             }
-
-            var inchTrunc = (int)Math.Truncate(Inches);
-            var numerator = (int)Math.Round((Inches - inchTrunc) * fractionDenominator);
+            
+            // TODO this could probably be done better with the fractions
+            var inchTrunc = (int)Math.Truncate(Inches.ToDouble());
+            var numerator = (int)Math.Round((Inches - inchTrunc).ToDouble() * fractionDenominator); 
 
             if (numerator == fractionDenominator)
             {
@@ -208,7 +210,7 @@ public string ToArchitecturalString(int fractionDenominator)
 
             if (numerator > 0)
             {
-                int GreatestCommonDivisor(int a, int b)
+                static int GreatestCommonDivisor(int a, int b)
                 {
                     while (a != 0 && b != 0)
                     {
diff --git a/UnitsNet/CustomCode/Quantities/Level.extra.cs b/UnitsNet/CustomCode/Quantities/Level.extra.cs
index a7b1a82825..4ca60d2151 100644
--- a/UnitsNet/CustomCode/Quantities/Level.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Level.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -14,20 +14,26 @@ public partial struct Level
         /// </summary>
         /// <param name="quantity">The quantity.</param>
         /// <param name="reference">The reference value that <paramref name="quantity" /> is compared to.</param>
-        public Level(double quantity, double reference)
+        /// <param name="significantDigits">The number of significant digits to use in the calculation. Default is 15.</param>
+        /// <exception cref="T:System.ArgumentOutOfRangeException">
+        ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+        /// </exception>
+        public Level(double quantity, double reference, byte significantDigits = 15)
             : this()
         {
-            string errorMessage =
-                $"The base-10 logarithm of a number ≤ 0 is undefined ({quantity}/{reference}).";
+            var errorMessage = $"The base-10 logarithm of a number ≤ 0 is undefined ({quantity}/{reference}).";
 
-            // ReSharper disable CompareOfFloatsByEqualityOperator
-            if (quantity == 0 || quantity < 0 && reference > 0)
+            if (quantity == 0 || (quantity < 0 && reference > 0))
+            {
                 throw new ArgumentOutOfRangeException(nameof(quantity), errorMessage);
-            if (reference == 0 || quantity > 0 && reference < 0)
+            }
+
+            if (reference == 0 || (quantity > 0 && reference < 0))
+            {
                 throw new ArgumentOutOfRangeException(nameof(reference), errorMessage);
-            // ReSharper restore CompareOfFloatsByEqualityOperator
+            }
 
-            _value = 10*Math.Log10(quantity/reference);
+            _value = QuantityValue.FromDoubleRounded(10 * Math.Log10(quantity / reference), significantDigits);
             _unit = LevelUnit.Decibel;
         }
     }
diff --git a/UnitsNet/CustomCode/Quantities/Mass.extra.cs b/UnitsNet/CustomCode/Quantities/Mass.extra.cs
index 906feca314..9cfc5739a3 100644
--- a/UnitsNet/CustomCode/Quantities/Mass.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Mass.extra.cs
@@ -1,10 +1,14 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
 using System.Threading;
 using System.Globalization;
+using System.Numerics;
 using UnitsNet.Units;
+#if NET
+using System.Text.Json.Serialization;
+#endif
 
 namespace UnitsNet
 {
@@ -20,19 +24,22 @@ public static Mass FromGravitationalForce(Force f)
         ///     StonePounds related code makes it easier to work with Stone/Pound combination, which are customarily used in the UK
         ///     to express body weight. For example, someone weighs 11 stone 4 pounds (about 72 kilograms).
         /// </summary>
-        private const double StonesInOnePound = 14.0;
+        private static readonly QuantityValue StonesInOnePound = 14;
 
         /// <summary>
         ///     Converts the mass to a customary stone/pounds combination.
         /// </summary>
+#if NET
+        [JsonIgnore]
+#endif
         public StonePounds StonePounds
         {
             get
             {
-                var inPounds = Pounds;
+                QuantityValue inPounds = Pounds;
 
-                var stones = Math.Truncate(inPounds / StonesInOnePound);
-                var pounds = inPounds % StonesInOnePound;
+                var stones = (BigInteger)(inPounds / StonesInOnePound); // BigInteger division returns the quotient (equivalent to Math.Truncate)
+                QuantityValue pounds = inPounds % StonesInOnePound;
 
                 return new StonePounds(stones, pounds);
             }
@@ -41,7 +48,7 @@ public StonePounds StonePounds
         /// <summary>
         ///     Get Mass from combination of stone and pounds.
         /// </summary>
-        public static Mass FromStonePounds(double stone, double pounds)
+        public static Mass FromStonePounds(QuantityValue stone, QuantityValue pounds)
         {
             return FromPounds(StonesInOnePound*stone + pounds);
         }
@@ -56,7 +63,7 @@ public sealed class StonePounds
         /// <summary>
         ///     Construct from stone and pounds.
         /// </summary>
-        public StonePounds(double stone, double pounds)
+        public StonePounds(QuantityValue stone, QuantityValue pounds)
         {
             Stone = stone;
             Pounds = pounds;
@@ -65,12 +72,12 @@ public StonePounds(double stone, double pounds)
         /// <summary>
         ///     The stone value it was created with.
         /// </summary>
-        public double Stone { get; }
+        public QuantityValue Stone { get; }
 
         /// <summary>
         ///     The pounds value it was created with.
         /// </summary>
-        public double Pounds { get; }
+        public QuantityValue Pounds { get; }
 
         /// <inheritdoc cref="ToString(IFormatProvider)"/>
         public override string ToString()
@@ -88,14 +95,17 @@ public override string ToString()
         /// </param>
         public string ToString(IFormatProvider? cultureInfo)
         {
-            cultureInfo = cultureInfo ?? CultureInfo.CurrentCulture;
+            if (cultureInfo is not CultureInfo unitLocalizationCulture)
+            {
+                cultureInfo = unitLocalizationCulture = CultureInfo.CurrentCulture;
+            }
 
-            var stoneUnit = Mass.GetAbbreviation(MassUnit.Stone, cultureInfo);
-            var poundUnit = Mass.GetAbbreviation(MassUnit.Pound, cultureInfo);
+            var stoneUnit = Mass.GetAbbreviation(MassUnit.Stone, unitLocalizationCulture);
+            var poundUnit = Mass.GetAbbreviation(MassUnit.Pound, unitLocalizationCulture);
 
             // Note that it isn't customary to use fractions - one wouldn't say "I am 11 stone and 4.5 pounds".
             // So pounds are rounded here.
-            return string.Format(cultureInfo, "{0:n0} {1} {2:n0} {3}", Stone, stoneUnit, Math.Round(Pounds), poundUnit);
+            return string.Format(cultureInfo, "{0:n0} {1} {2:n0} {3}", Stone, stoneUnit, Math.Round(Pounds.ToDouble()), poundUnit);
         }
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/MassConcentration.extra.cs b/UnitsNet/CustomCode/Quantities/MassConcentration.extra.cs
index 569c228523..3cff4a229b 100644
--- a/UnitsNet/CustomCode/Quantities/MassConcentration.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/MassConcentration.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet
diff --git a/UnitsNet/CustomCode/Quantities/MassFraction.extra.cs b/UnitsNet/CustomCode/Quantities/MassFraction.extra.cs
index b7c1112740..43ee0045d3 100644
--- a/UnitsNet/CustomCode/Quantities/MassFraction.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/MassFraction.extra.cs
@@ -1,4 +1,4 @@
-using UnitsNet.Units;
+using UnitsNet.Units;
 
 namespace UnitsNet
 {
diff --git a/UnitsNet/CustomCode/Quantities/Molarity.extra.cs b/UnitsNet/CustomCode/Quantities/Molarity.extra.cs
index 32203f21f7..bd45e8da89 100644
--- a/UnitsNet/CustomCode/Quantities/Molarity.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Molarity.extra.cs
@@ -1,4 +1,4 @@
-using UnitsNet.Units;
+using UnitsNet.Units;
 
 namespace UnitsNet
 {
diff --git a/UnitsNet/CustomCode/Quantities/Power.extra.cs b/UnitsNet/CustomCode/Quantities/Power.extra.cs
index b16eec0c63..e5c73cf382 100644
--- a/UnitsNet/CustomCode/Quantities/Power.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Power.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet/CustomCode/Quantities/PowerRatio.extra.cs b/UnitsNet/CustomCode/Quantities/PowerRatio.extra.cs
index e4c4f07fe6..a4bef694ca 100644
--- a/UnitsNet/CustomCode/Quantities/PowerRatio.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/PowerRatio.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -12,16 +12,21 @@ public partial struct PowerRatio
         ///     Initializes a new instance of the <see cref="PowerRatio" /> struct from the specified power referenced to one watt.
         /// </summary>
         /// <param name="power">The power relative to one watt.</param>
-
-        public PowerRatio(Power power)
+        /// <param name="significantDigits">The number of significant digits to use in the calculation. Default is 15.</param>
+        /// <exception cref="T:System.ArgumentOutOfRangeException">
+        ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+        /// </exception>
+        public PowerRatio(Power power, byte significantDigits = 15)
             : this()
         {
-            if (power.Watts <= 0)
+            if (!QuantityValue.IsPositive(power.Value))
+            {
                 throw new ArgumentOutOfRangeException(
                     nameof(power), "The base-10 logarithm of a number ≤ 0 is undefined. Power must be greater than 0 W.");
+            }
 
             // P(dBW) = 10*log10(value(W)/reference(W))
-            _value = 10 * Math.Log10((double)power.Watts);
+            _value = power.Watts.ToLogSpace(LogarithmicScalingFactor, significantDigits);
             _unit = PowerRatioUnit.DecibelWatt;
         }
 
@@ -34,20 +39,24 @@ public PowerRatio(Power power)
         ///         <c>var power = powerRatio.ToPower();</c>
         ///     </example>
         /// </remarks>
-        public Power ToPower()
+        public Power ToPower(byte significantDigits = 15)
         {
             // P(W) = 1W * 10^(P(dBW)/10)
-            return Power.FromWatts(Math.Pow(10, DecibelWatts / 10));
+            return Power.FromWatts(DecibelWatts.ToLinearSpace(LogarithmicScalingFactor, significantDigits));
         }
 
         /// <summary>
         ///     Gets a <see cref="AmplitudeRatio" /> from this <see cref="PowerRatio" />.
         /// </summary>
         /// <param name="impedance">The input impedance of the load. This is usually 50, 75 or 600 ohms.</param>
-        public AmplitudeRatio ToAmplitudeRatio(ElectricResistance impedance)
+        /// <param name="significantDigits">The number of significant digits to use in the calculation. Default is 15.</param>
+        /// <exception cref="T:System.ArgumentOutOfRangeException">
+        ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+        /// </exception>
+        public AmplitudeRatio ToAmplitudeRatio(ElectricResistance impedance, byte significantDigits = 15)
         {
             // E(dBV) = 10*log10(Z(Ω)/1) + P(dBW)
-            return AmplitudeRatio.FromDecibelVolts(10 * Math.Log10(impedance.Ohms / 1) + DecibelWatts);
+            return AmplitudeRatio.FromDecibelVolts(impedance.Ohms.ToLogSpace(LogarithmicScalingFactor, significantDigits) + DecibelWatts);
         }
 
         #region Static Methods
@@ -56,9 +65,13 @@ public AmplitudeRatio ToAmplitudeRatio(ElectricResistance impedance)
         ///     Gets a <see cref="PowerRatio" /> from a <see cref="Power" /> relative to one watt.
         /// </summary>
         /// <param name="power">The power relative to one watt.</param>
-        public static PowerRatio FromPower(Power power)
+        /// <param name="significantDigits">The number of significant digits to use in the calculation. Default is 15.</param>
+        /// <exception cref="T:System.ArgumentOutOfRangeException">
+        ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+        /// </exception>
+        public static PowerRatio FromPower(Power power, byte significantDigits = 15)
         {
-            return new PowerRatio(power);
+            return new PowerRatio(power, significantDigits);
         }
 
         #endregion
diff --git a/UnitsNet/CustomCode/Quantities/Pressure.extra.cs b/UnitsNet/CustomCode/Quantities/Pressure.extra.cs
index 00bf97d060..98d869eabf 100644
--- a/UnitsNet/CustomCode/Quantities/Pressure.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Pressure.extra.cs
@@ -1,4 +1,3 @@
-using System;
 using UnitsNet.Units;
 
 namespace UnitsNet;
@@ -9,28 +8,38 @@ public partial struct Pressure
     ///     Calculates the pressure at a given elevation.
     /// </summary>
     /// <param name="elevation">The elevation for which to calculate the pressure.</param>
+    /// <param name="significantDigits">The number of significant digits to use in the calculation. Default is 13.</param>
+    /// <exception cref="T:System.ArgumentOutOfRangeException">
+    ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+    /// </exception>
     /// <returns>A Pressure struct representing the pressure at the given elevation.</returns>
     /// <remarks>
     ///     The calculation is based on the formula for pressure altitude from Wikipedia:
     ///     https://en.wikipedia.org/wiki/Pressure_altitude
     /// </remarks>
-    public static Pressure FromElevation(Length elevation)
+    public static Pressure FromElevation(Length elevation, byte significantDigits = 13)
     {
         // Millibars = 1013.25 * (1 - (Length (Feet) / 145366.45)) ^ (1 / 0.190284)
-        return new Pressure(1013.25 * Math.Pow(1 - elevation.Feet / 145366.45, 1 / 0.190284), PressureUnit.Millibar);
+        return new Pressure(QuantityValue.FromDoubleRounded(1013.25 * Math.Pow(1 - elevation.Feet.ToDouble() / 145366.45, 1 / 0.190284), significantDigits),
+            PressureUnit.Millibar);
     }
 
     /// <summary>
     ///     Converts the pressure to an equivalent elevation or altitude.
     /// </summary>
+    /// <param name="significantDigits">The number of significant digits to round the result to. Default is 15.</param>
+    /// <exception cref="T:System.ArgumentOutOfRangeException">
+    ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+    /// </exception>
     /// <returns>A <see cref="Length" /> object representing the equivalent elevation or altitude.</returns>
     /// <remarks>
     ///     The conversion is based on the formula for pressure altitude as described on Wikipedia
     ///     (https://en.wikipedia.org/wiki/Pressure_altitude).
     /// </remarks>
-    public Length ToElevation()
+    public Length ToElevation(byte significantDigits = 15)
     {
         // Length (Feet) = 145366.45 * (1 - (Millibars / 1013.25) ^ 0.190284)
-        return new Length(145366.45 * (1 - Math.Pow(Millibars / 1013.25, 0.190284)), LengthUnit.Foot);
+        return new Length(QuantityValue.FromDoubleRounded(145366.45 * (1 - Math.Pow(Millibars.ToDouble() / 1013.25, 0.190284)), significantDigits),
+            LengthUnit.Foot);
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/Temperature.extra.cs b/UnitsNet/CustomCode/Quantities/Temperature.extra.cs
index a105bfd9d1..99388c1ca7 100644
--- a/UnitsNet/CustomCode/Quantities/Temperature.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Temperature.extra.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet
diff --git a/UnitsNet/CustomCode/Quantities/VolumeConcentration.extra.cs b/UnitsNet/CustomCode/Quantities/VolumeConcentration.extra.cs
index 205acf77e3..eb4af76104 100644
--- a/UnitsNet/CustomCode/Quantities/VolumeConcentration.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/VolumeConcentration.extra.cs
@@ -1,4 +1,4 @@
-using UnitsNet.Units;
+using UnitsNet.Units;
 
 namespace UnitsNet
 {
diff --git a/UnitsNet/CustomCode/Quantity.cs b/UnitsNet/CustomCode/Quantity.cs
index c2be09ea11..666d57b493 100644
--- a/UnitsNet/CustomCode/Quantity.cs
+++ b/UnitsNet/CustomCode/Quantity.cs
@@ -1,4 +1,4 @@
-using System.Globalization;
+using System.Globalization;
 
 namespace UnitsNet
 {
@@ -35,7 +35,7 @@ public static bool TryGetUnitInfo(UnitKey unitEnum, [NotNullWhen(true)] out Unit
         {
             return Quantities.TryGetUnitInfo(unitEnum, out unitInfo);
         }
-
+        
         /// <summary>
         ///     Dynamically constructs a quantity from a numeric value and a unit enum value.
         /// </summary>
@@ -43,7 +43,7 @@ public static bool TryGetUnitInfo(UnitKey unitEnum, [NotNullWhen(true)] out Unit
         /// <param name="unit">Unit enum value.</param>
         /// <returns>An <see cref="IQuantity"/> object.</returns>
         /// <exception cref="UnitNotFoundException">Unit value is not a known unit enum type.</exception>
-        public static IQuantity From(double value, UnitKey unit)
+        public static IQuantity From(QuantityValue value, UnitKey unit)
         {
             return Quantities.From(value, unit);
         }
@@ -61,7 +61,7 @@ public static IQuantity From(double value, UnitKey unit)
         /// <exception cref="UnitNotFoundException">
         ///     Thrown when no unit is found for the specified quantity name and unit name.
         /// </exception>
-        public static IQuantity From(double value, string quantityName, string unitName)
+        public static IQuantity From(QuantityValue value, string quantityName, string unitName)
         {
             return Quantities.GetUnitByName(quantityName, unitName).From(value);
         }
@@ -74,14 +74,14 @@ public static IQuantity From(double value, string quantityName, string unitName)
         ///     Unit abbreviation matching is case-insensitive.<br/>
         ///     <br/>
         ///     This will fail if more than one unit across all quantities share the same unit abbreviation.<br/>
-        ///     Prefer <see cref="From(double,UnitKey)"/> or <see cref="From(double,string,string)"/> instead.
+        ///     Prefer <see cref="From(QuantityValue,UnitKey)"/> or <see cref="From(QuantityValue,string,string)"/> instead.
         /// </remarks>
         /// <param name="value">Numeric value.</param>
         /// <param name="unitAbbreviation">Unit abbreviation, such as "kg" for <see cref="MassUnit.Kilogram"/>.</param>
         /// <returns>An <see cref="IQuantity"/> object.</returns>
         /// <exception cref="UnitNotFoundException">Unit abbreviation is not known.</exception>
         /// <exception cref="AmbiguousUnitParseException">Multiple units found matching the given unit abbreviation.</exception>
-        public static IQuantity FromUnitAbbreviation(double value, string unitAbbreviation) => FromUnitAbbreviation(null, value, unitAbbreviation);
+        public static IQuantity FromUnitAbbreviation(QuantityValue value, string unitAbbreviation) => FromUnitAbbreviation(null, value, unitAbbreviation);
 
         /// <summary>
         ///     Dynamically construct a quantity from a numeric value and a unit abbreviation.
@@ -91,17 +91,17 @@ public static IQuantity From(double value, string quantityName, string unitName)
         ///     Unit abbreviation matching is case-insensitive.<br/>
         ///     <br/>
         ///     This will fail if more than one unit across all quantities share the same unit abbreviation.<br/>
-        ///     Prefer <see cref="From(double,UnitKey)"/> or <see cref="From(double,string,string)"/> instead.
+        ///     Prefer <see cref="From(QuantityValue,UnitKey)"/> or <see cref="From(QuantityValue,string,string)"/> instead.
         /// </remarks>
-        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="culture">The localization culture. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="value">Numeric value.</param>
         /// <param name="unitAbbreviation">Unit abbreviation, such as "kg" for <see cref="MassUnit.Kilogram"/>.</param>
         /// <returns>An <see cref="IQuantity"/> object.</returns>
         /// <exception cref="UnitNotFoundException">Unit abbreviation is not known.</exception>
         /// <exception cref="AmbiguousUnitParseException">Multiple units found matching the given unit abbreviation.</exception>
-        public static IQuantity FromUnitAbbreviation(IFormatProvider? formatProvider, double value, string unitAbbreviation)
+        public static IQuantity FromUnitAbbreviation(IFormatProvider? culture, QuantityValue value, string unitAbbreviation)
         {
-            return UnitParser.FromUnitAbbreviation(value, unitAbbreviation, formatProvider);
+            return UnitParser.FromUnitAbbreviation(value, unitAbbreviation, culture);
         }
 
         /// <summary>
@@ -112,7 +112,7 @@ public static IQuantity FromUnitAbbreviation(IFormatProvider? formatProvider, do
         /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
         /// <param name="quantity">The constructed quantity, if successful, otherwise null.</param>
         /// <returns><c>True</c> if successful with <paramref name="quantity"/> assigned the value, otherwise <c>false</c>.</returns>
-        public static bool TryFrom(double value, string quantityName, string unitName, [NotNullWhen(true)] out IQuantity? quantity)
+        public static bool TryFrom(QuantityValue value, string quantityName, string unitName, [NotNullWhen(true)] out IQuantity? quantity)
         {
             if (!Quantities.TryGetUnitByName(quantityName, unitName, out UnitInfo? unitInfo))
             {
@@ -136,7 +136,7 @@ public static bool TryFrom(double value, string quantityName, string unitName, [
         /// <returns>
         ///     <c>true</c> if the quantity was successfully created; otherwise, <c>false</c>.
         /// </returns>
-        public static bool TryFrom(double value, Enum? unit, [NotNullWhen(true)] out IQuantity? quantity)
+        public static bool TryFrom(QuantityValue value, Enum? unit, [NotNullWhen(true)] out IQuantity? quantity)
         {
             return Quantities.TryFrom(value, unit, out quantity);
         }
@@ -149,14 +149,14 @@ public static bool TryFrom(double value, Enum? unit, [NotNullWhen(true)] out IQu
         ///     Unit abbreviation matching is case-insensitive.<br/>
         ///     <br/>
         ///     This will fail if more than one unit across all quantities share the same unit abbreviation.<br/>
-        ///     Prefer <see cref="From(double,UnitKey)"/> or <see cref="From(double,string,string)"/> instead.
+        ///     Prefer <see cref="From(QuantityValue,UnitKey)"/> or <see cref="From(QuantityValue,string,string)"/> instead.
         /// </remarks>
         /// <param name="value">Numeric value.</param>
         /// <param name="unitAbbreviation">Unit abbreviation, such as "kg" for <see cref="MassUnit.Kilogram"/>.</param>
         /// <param name="quantity">The quantity if successful, otherwise null.</param>
         /// <returns>True if successful.</returns>
         /// <exception cref="ArgumentException">Unit value is not a known unit enum type.</exception>
-        public static bool TryFromUnitAbbreviation(double value, string unitAbbreviation, [NotNullWhen(true)] out IQuantity? quantity) =>
+        public static bool TryFromUnitAbbreviation(QuantityValue value, string unitAbbreviation, [NotNullWhen(true)] out IQuantity? quantity) =>
             TryFromUnitAbbreviation(null, value, unitAbbreviation, out quantity);
 
         /// <summary>
@@ -167,7 +167,7 @@ public static bool TryFromUnitAbbreviation(double value, string unitAbbreviation
         ///     Unit abbreviation matching is case-insensitive.<br/>
         ///     <br/>
         ///     This will fail if more than one unit across all quantities share the same unit abbreviation.<br/>
-        ///     Prefer <see cref="From(double,UnitKey)"/> or <see cref="From(double,string,string)"/> instead.
+        ///     Prefer <see cref="From(QuantityValue,UnitKey)"/> or <see cref="From(QuantityValue,string,string)"/> instead.
         /// </remarks>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="value">Numeric value.</param>
@@ -175,7 +175,7 @@ public static bool TryFromUnitAbbreviation(double value, string unitAbbreviation
         /// <param name="quantity">The quantity if successful, otherwise null.</param>
         /// <returns>True if successful.</returns>
         /// <exception cref="ArgumentException">Unit value is not a known unit enum type.</exception>
-        public static bool TryFromUnitAbbreviation(IFormatProvider? formatProvider, double value, string unitAbbreviation, [NotNullWhen(true)] out IQuantity? quantity)
+        public static bool TryFromUnitAbbreviation(IFormatProvider? formatProvider, QuantityValue value, string unitAbbreviation, [NotNullWhen(true)] out IQuantity? quantity)
         {
             if (UnitParser.TryGetUnitFromAbbreviation(unitAbbreviation, formatProvider, out UnitInfo? unitInfo))
             {
diff --git a/UnitsNet/CustomCode/QuantityConverters/Builder/ConversionCacheOptions.cs b/UnitsNet/CustomCode/QuantityConverters/Builder/ConversionCacheOptions.cs
new file mode 100644
index 0000000000..3da8b85184
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/Builder/ConversionCacheOptions.cs
@@ -0,0 +1,41 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet;
+
+/// <summary>
+///     Provides options for configuring the caching behavior of unit conversions in the <see cref="UnitConverter" />.
+/// </summary>
+public sealed record ConversionCacheOptions
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="ConversionCacheOptions" /> class.
+    /// </summary>
+    /// <param name="cachingMode">
+    ///     The caching mode to be used for unit conversions. Default is
+    ///     <see cref="ConversionCachingMode.All" />.
+    /// </param>
+    /// <param name="reduceConstants">Indicates whether to reduce constants during conversions. Default is <c>true</c>.</param>
+    public ConversionCacheOptions(ConversionCachingMode cachingMode = ConversionCachingMode.All, bool reduceConstants = true)
+    {
+        CachingMode = cachingMode;
+        ReduceConstants = reduceConstants;
+    }
+
+    /// <summary>
+    ///     Gets the caching mode for unit conversions with this quantity.
+    /// </summary>
+    /// <value>
+    ///     The caching mode determines how unit conversions are cached.
+    /// </value>
+    public ConversionCachingMode CachingMode { get; }
+
+    /// <summary>
+    ///     Gets a value indicating whether constant values should be reduced when initializing the unit conversions.
+    /// </summary>
+    /// <remarks>
+    ///     When set to <c>true</c>, constant values in unit conversions are reduced to their simplest form.
+    ///     This can help improve performance and reduce memory usage.
+    /// </remarks>
+    public bool ReduceConstants { get; }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/Builder/ConversionCachingMode.cs b/UnitsNet/CustomCode/QuantityConverters/Builder/ConversionCachingMode.cs
new file mode 100644
index 0000000000..4e41b6b547
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/Builder/ConversionCachingMode.cs
@@ -0,0 +1,34 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet;
+
+/// <summary>
+///     Specifies the caching modes available for unit conversions in the <see cref="UnitConverter" />.
+/// </summary>
+/// <summary>
+///     No caching is applied.
+/// </summary>
+/// <summary>
+///     Only base unit conversions are cached.
+/// </summary>
+/// <summary>
+///     All unit conversions are cached.
+/// </summary>
+public enum ConversionCachingMode
+{
+    /// <summary>
+    ///     No caching is applied.
+    /// </summary>
+    None,
+
+    /// <summary>
+    ///     Only base unit conversions are cached.
+    /// </summary>
+    BaseOnly,
+
+    /// <summary>
+    ///     All unit conversions are cached.
+    /// </summary>
+    All
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversion.cs b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversion.cs
new file mode 100644
index 0000000000..ed428050c5
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversion.cs
@@ -0,0 +1,56 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Diagnostics;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents an implicit conversion between two quantity types.
+/// </summary>
+/// <remarks>
+///     This record is used to define implicit conversions between different quantity types in the UnitsNet library.
+///     The conversion is considered commutative, meaning that a conversion from type A to type B is equivalent to a
+///     conversion from type B to type A.
+/// </remarks>
+[DebuggerDisplay("{LeftQuantity.Name,nq} <-> {RightQuantity.Name,nq}")]
+internal readonly record struct QuantityConversion
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityConversion" /> struct.
+    /// </summary>
+    /// <param name="leftQuantity">The quantity information for first quantity in the conversion.</param>
+    /// <param name="rightQuantity">The quantity information for the second quantity of the conversion.</param>
+    /// <remarks>
+    ///     This constructor sets up the implicit conversion between two quantity types,
+    ///     ensuring that the conversion is commutative.
+    /// </remarks>
+    public QuantityConversion(QuantityInfo leftQuantity, QuantityInfo rightQuantity)
+    {
+        LeftQuantity = leftQuantity;
+        RightQuantity = rightQuantity;
+    }
+
+    public QuantityInfo LeftQuantity { get; }
+    public QuantityInfo RightQuantity { get; }
+
+    public bool Equals(QuantityConversion other)
+    {
+        return (LeftQuantity.Equals(other.LeftQuantity) && RightQuantity.Equals(other.RightQuantity)) ||
+               (LeftQuantity.Equals(other.RightQuantity) && RightQuantity.Equals(other.LeftQuantity));
+    }
+
+    public override int GetHashCode()
+    {
+        var hash1 = LeftQuantity.GetHashCode();
+        var hash2 = RightQuantity.GetHashCode();
+        // Use a commutative hash code combination to ensure (X1, X2) and (X2, X1) produce the same hash code
+        return hash1 ^ hash2;
+    }
+
+    public void Deconstruct(out QuantityInfo leftQuantity, out QuantityInfo rightQuantity)
+    {
+        leftQuantity = LeftQuantity;
+        rightQuantity = RightQuantity;
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversionMapping.cs b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversionMapping.cs
new file mode 100644
index 0000000000..9095ce5ce2
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversionMapping.cs
@@ -0,0 +1,66 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Diagnostics;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents an implicit conversion between two quantity types, represented by their unique
+///     <see cref="QuantityInfo.QuantityType" />.
+/// </summary>
+/// <remarks>
+///     This record is used to define implicit conversions between different quantity types in the UnitsNet library.
+///     The conversion is considered commutative, meaning that a conversion from type A to type B is equivalent to a
+///     conversion from type B to type A.
+/// </remarks>
+[DebuggerDisplay("{FirstQuantityType.Name,nq} <-> {SecondQuantityType.Name,nq}")]
+internal readonly record struct QuantityConversionMapping
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityConversionMapping" /> struct, representing an implicit
+    ///     conversion
+    ///     between two quantity types.
+    /// </summary>
+    /// <param name="firstQuantityType">The type of the first quantity involved in the conversion.</param>
+    /// <param name="secondQuantityType">The type of the second quantity involved in the conversion.</param>
+    internal QuantityConversionMapping(Type firstQuantityType, Type secondQuantityType)
+    {
+        FirstQuantityType = firstQuantityType;
+        SecondQuantityType = secondQuantityType;
+    }
+
+    public Type FirstQuantityType { get; }
+    public Type SecondQuantityType { get; }
+
+    /// <summary>
+    ///     Creates an implicit conversion between two quantity types.
+    /// </summary>
+    /// <typeparam name="TFirstQuantity">The type of the first quantity.</typeparam>
+    /// <typeparam name="TSecondQuantity">The type of the second quantity.</typeparam>
+    /// <returns>
+    ///     An <see cref="QuantityConversionMapping" /> instance representing the conversion between the specified quantity
+    ///     types.
+    /// </returns>
+    public static QuantityConversionMapping Create<TFirstQuantity, TSecondQuantity>()
+        where TFirstQuantity : IQuantity
+        where TSecondQuantity : IQuantity
+    {
+        return new QuantityConversionMapping(typeof(TFirstQuantity), typeof(TSecondQuantity));
+    }
+
+    public bool Equals(QuantityConversionMapping other)
+    {
+        return (FirstQuantityType == other.FirstQuantityType && SecondQuantityType == other.SecondQuantityType) ||
+               (FirstQuantityType == other.SecondQuantityType && SecondQuantityType == other.FirstQuantityType);
+    }
+
+    public override int GetHashCode()
+    {
+        var hash1 = FirstQuantityType.GetHashCode();
+        var hash2 = SecondQuantityType.GetHashCode();
+        // Use a commutative hash code combination to ensure (X1, X2) and (X2, X1) produce the same hash code
+        return hash1 ^ hash2;
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversionOptions.cs b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversionOptions.cs
new file mode 100644
index 0000000000..3fb7172763
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversionOptions.cs
@@ -0,0 +1,215 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+
+namespace UnitsNet;
+
+internal record CustomQuantityConversionUnitMapping
+{
+    public CustomQuantityConversionUnitMapping(UnitInfo sourceUnit, UnitInfo targetUnit)
+    {
+        SourceUnit = sourceUnit;
+        TargetUnit = targetUnit;
+    }
+
+    public UnitInfo SourceUnit { get; }
+    public UnitInfo TargetUnit { get; }
+}
+
+internal record CustomQuantityConversionExpressionMapping
+{
+    public CustomQuantityConversionExpressionMapping(UnitInfo sourceUnit, UnitInfo targetUnit, ConversionExpression conversionExpression)
+    {
+        TargetUnit = targetUnit;
+        ConversionExpression = conversionExpression;
+        SourceUnit = sourceUnit;
+    }
+
+    public UnitInfo SourceUnit { get; }
+    public UnitInfo TargetUnit { get; }
+    public ConversionExpression ConversionExpression { get; }
+}
+
+internal sealed class QuantityConversionMappingOptions
+{
+    internal Dictionary<UnitConversionMapping, CustomQuantityConversionUnitMapping> CustomUnitMappings { get; } = [];
+    internal Dictionary<UnitConversionMapping, CustomQuantityConversionExpressionMapping> ConversionExpressions { get; } = [];
+}
+
+/// <summary>
+///     Represents options for configuring implicit conversions between different quantities and units.
+///     This class allows the specification of custom conversions and conversion units to be used during implicit
+///     conversions.
+/// </summary>
+public sealed class QuantityConversionOptions
+{
+    internal HashSet<QuantityConversionMapping> CustomConversions { get; } = [];
+
+    internal HashSet<UnitConversionMapping> ConversionUnits { get; } = [];
+    
+    internal Dictionary<UnitConversionMapping, ConversionExpression> CustomConversionFunctions { get; } = new();
+
+    /// <summary>
+    ///     Adds a custom conversion between two quantities to the implicit conversion options.
+    /// </summary>
+    /// <typeparam name="TFromQuantity">The type of the quantity to convert from.</typeparam>
+    /// <typeparam name="TToQuantity">The type of the quantity to convert to.</typeparam>
+    /// <returns>
+    ///     The current instance of <see cref="QuantityConversionOptions" /> with the specified custom conversion configured.
+    /// </returns>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when attempting to map conversion units for different quantities using the same quantity type.
+    /// </exception>
+    /// <remarks>
+    ///     The association is created in both directions.
+    /// </remarks>
+    public QuantityConversionOptions SetCustomConversion<TFromQuantity, TToQuantity>()
+        where TFromQuantity : IQuantity
+        where TToQuantity : IQuantity
+    {
+        if (typeof(TFromQuantity) == typeof(TToQuantity))
+        {
+            throw new InvalidConversionException(
+                $"Mapping conversion units for different quantities using the same quantity type ({typeof(TFromQuantity).Name}) is not allowed.");
+        }
+
+        CustomConversions.Add(QuantityConversionMapping.Create<TFromQuantity, TToQuantity>());
+        return this;
+    }
+
+    /// <summary>
+    ///     Configures the implicit conversion options by specifying the units to be used for conversion.
+    /// </summary>
+    /// <typeparam name="TFromUnit">The type of the unit to convert from, which must be a struct and an enumeration.</typeparam>
+    /// <typeparam name="TToUnit">The type of the unit to convert to, which must be a struct and an enumeration.</typeparam>
+    /// <param name="fromUnit">The unit to convert from.</param>
+    /// <param name="toUnit">The unit to convert to.</param>
+    /// <param name="mapBothDirections">
+    ///     A boolean value indicating whether the conversion should be bidirectional. If true, the conversion
+    ///     will be configured in both directions.
+    /// </param>
+    /// <returns>
+    ///     The current instance of <see cref="QuantityConversionOptions" /> with the specified conversion units
+    ///     configured.
+    /// </returns>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when attempting to map conversion units for different quantities using the same unit type.
+    /// </exception>
+    public QuantityConversionOptions SetConversionUnits<TFromUnit, TToUnit>(TFromUnit fromUnit, TToUnit toUnit, bool mapBothDirections = false)
+        where TFromUnit : struct, Enum
+        where TToUnit : struct, Enum
+    {
+        if (typeof(TFromUnit) == typeof(TToUnit))
+        {
+            throw new InvalidConversionException(
+                $"Mapping conversion units for different quantities using the same unit type ({typeof(TFromUnit).Name}) is not allowed.");
+        }
+
+        var fromUnitConversionKey = UnitConversionMapping.Create(fromUnit, toUnit);
+        ConversionUnits.Add(fromUnitConversionKey);
+        if (mapBothDirections)
+        {
+            ConversionUnits.Add(new UnitConversionMapping(fromUnitConversionKey.ToUnitKey, fromUnitConversionKey.FromUnitKey));
+        }
+
+        return this;
+    }
+
+    /// <summary>
+    ///     Adds a custom conversion function between two specified units.
+    /// </summary>
+    /// <typeparam name="TFromUnit">The type of the source unit, which must be a struct and an enumeration.</typeparam>
+    /// <typeparam name="TToUnit">The type of the target unit, which must be a struct and an enumeration.</typeparam>
+    /// <param name="fromUnit">The source unit to convert from.</param>
+    /// <param name="toUnit">The target unit to convert to.</param>
+    /// <param name="conversionFunction">The function that performs the conversion from the source unit to the target unit.</param>
+    /// <returns>The current <see cref="QuantityConversionOptions" /> instance with the custom conversion added.</returns>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when attempting to map conversion units for different quantities using the same unit type.
+    /// </exception>
+    /// <remarks>
+    ///     This method allows you to define a custom conversion function between two units, enabling precise control over the
+    ///     conversion process.
+    /// </remarks>
+    public QuantityConversionOptions SetCustomConversion<TFromUnit, TToUnit>(TFromUnit fromUnit, TToUnit toUnit, ConvertValueDelegate conversionFunction)
+        where TFromUnit : struct, Enum
+        where TToUnit : struct, Enum
+    {
+        return SetCustomConversion(fromUnit, toUnit, new ConversionExpression(QuantityValue.One, conversionFunction));
+    }
+
+    /// <summary>
+    ///     Adds a custom conversion function between two specified units.
+    /// </summary>
+    /// <typeparam name="TFromUnit">The type of the source unit, which must be a struct and an enumeration.</typeparam>
+    /// <typeparam name="TToUnit">The type of the target unit, which must be a struct and an enumeration.</typeparam>
+    /// <param name="fromUnit">The source unit to convert from.</param>
+    /// <param name="toUnit">The target unit to convert to.</param>
+    /// <param name="conversionFunction">The function that performs the conversion from the source unit to the target unit.</param>
+    /// <returns>The current <see cref="QuantityConversionOptions" /> instance with the custom conversion added.</returns>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when attempting to map conversion units for different quantities using the same unit type.
+    /// </exception>
+    /// <remarks>
+    ///     This method allows you to define a custom conversion function between two units, enabling precise control over the
+    ///     conversion process.
+    /// </remarks>
+    public QuantityConversionOptions SetCustomConversion<TFromUnit, TToUnit>(TFromUnit fromUnit, TToUnit toUnit, ConversionExpression conversionFunction)
+        where TFromUnit : struct, Enum
+        where TToUnit : struct, Enum
+    {
+        if (typeof(TFromUnit) == typeof(TToUnit))
+        {
+            throw new InvalidConversionException(
+                $"Mapping conversion units for different quantities using the same unit type ({typeof(TFromUnit).Name}) is not allowed.");
+        }
+
+        var fromUnitKey = UnitKey.ForUnit(fromUnit);
+        var toUnitKey = UnitKey.ForUnit(toUnit);
+        CustomConversionFunctions[new UnitConversionMapping(fromUnitKey, toUnitKey)] = conversionFunction;
+        return this;
+    }
+    
+    /// <summary>
+    ///     Adds a custom conversion function between two specified units.
+    /// </summary>
+    /// <typeparam name="TFromUnit">The type of the source unit, which must be a struct and an enumeration.</typeparam>
+    /// <typeparam name="TToUnit">The type of the target unit, which must be a struct and an enumeration.</typeparam>
+    /// <param name="fromUnit">The source unit to convert from.</param>
+    /// <param name="toUnit">The target unit to convert to.</param>
+    /// <param name="conversionCoefficient">The used to performs the conversion from the source unit to the target unit.</param>
+    /// <param name="mapBothDirections">
+    ///     A boolean value indicating whether the conversion should be bidirectional. If true, the conversion
+    ///     will be configured in both directions, by creating an expression with the reciprocal coefficient.
+    /// </param>
+    /// <returns>The current <see cref="QuantityConversionOptions" /> instance with the custom conversion added.</returns>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when attempting to map conversion units for different quantities using the same unit type.
+    /// </exception>
+    /// <remarks>
+    ///     This method allows you to define a custom conversion function between two units, enabling precise control over the
+    ///     conversion process.
+    /// </remarks>
+    public QuantityConversionOptions SetCustomConversion<TFromUnit, TToUnit>(TFromUnit fromUnit, TToUnit toUnit, QuantityValue conversionCoefficient, bool mapBothDirections = false)
+        where TFromUnit : struct, Enum
+        where TToUnit : struct, Enum
+    {
+        if (typeof(TFromUnit) == typeof(TToUnit))
+        {
+            throw new InvalidConversionException(
+                $"Mapping conversion units for different quantities using the same unit type ({typeof(TFromUnit).Name}) is not allowed.");
+        }
+
+        var fromUnitKey = UnitKey.ForUnit(fromUnit);
+        var toUnitKey = UnitKey.ForUnit(toUnit);
+        CustomConversionFunctions[new UnitConversionMapping(fromUnitKey, toUnitKey)] = conversionCoefficient;
+        if (mapBothDirections)
+        {
+            CustomConversionFunctions[new UnitConversionMapping(toUnitKey, fromUnitKey)] = QuantityValue.Inverse(conversionCoefficient);
+        }
+        
+        return this;
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversionsBuilderExtensions.cs b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversionsBuilderExtensions.cs
new file mode 100644
index 0000000000..17620f1735
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/QuantityConversionsBuilderExtensions.cs
@@ -0,0 +1,779 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+using ConversionEntry = System.Collections.Generic.KeyValuePair<UnitsNet.QuantityConversionKey, UnitsNet.QuantityConversionFunction>;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Provides extension methods for building implicit conversions for quantities.
+/// </summary>
+internal static class QuantityConversionsBuilderExtensions
+{
+    /// <summary>
+    ///     Retrieves a collection of quantity conversions based on the provided conversion mappings.
+    /// </summary>
+    /// <param name="quantities">The lookup containing quantity information.</param>
+    /// <param name="conversionMappings">The mappings defining the conversions between quantity types.</param>
+    /// <returns>
+    ///     An enumerable collection of <see cref="QuantityConversion" /> representing the implicit conversions between
+    ///     quantities.
+    /// </returns>
+    public static IEnumerable<QuantityConversion> GetQuantityConversions(this QuantityInfoLookup quantities,
+        IEnumerable<QuantityConversionMapping> conversionMappings)
+    {
+        foreach (QuantityConversionMapping conversionMapping in conversionMappings)
+        {
+            if (quantities.TryGetQuantityInfo(conversionMapping.FirstQuantityType, out QuantityInfo? fromQuantity) &&
+                quantities.TryGetQuantityInfo(conversionMapping.SecondQuantityType, out QuantityInfo? toQuantity))
+            {
+                yield return new QuantityConversion(fromQuantity, toQuantity);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Retrieves a dictionary of custom quantity conversion mapping options based on the specified custom conversion
+    ///     options.
+    /// </summary>
+    /// <param name="quantities">The lookup containing information about available quantities and their units.</param>
+    /// <param name="customOptions">The custom conversion options that define specific conversion functions and units.</param>
+    /// <returns>
+    ///     A dictionary where each key is a <see cref="UnitsNet.QuantityConversion" /> representing a conversion between two
+    ///     quantities,
+    ///     and each value is a <see cref="UnitsNet.QuantityConversionMappingOptions" /> containing the mapping options for that
+    ///     conversion.
+    /// </returns>
+    /// <remarks>
+    ///     This method processes custom conversion functions and units specified in <paramref name="customOptions" /> to build
+    ///     a comprehensive set of conversion mappings. It ensures that only valid conversions, where both source and target
+    ///     units
+    ///     are recognized, are included in the resulting dictionary.
+    /// </remarks>
+    internal static Dictionary<QuantityConversion, QuantityConversionMappingOptions> GetQuantityConversionMappingOptions(this QuantityInfoLookup quantities,
+        QuantityConversionOptions customOptions)
+    {
+        var conversionOptions = new Dictionary<QuantityConversion, QuantityConversionMappingOptions>();
+
+        foreach (KeyValuePair<UnitConversionMapping, ConversionExpression> customConversion in customOptions.CustomConversionFunctions)
+        {
+            UnitConversionMapping unitConversionMapping = customConversion.Key;
+            if (!quantities.TryGetUnitInfo(unitConversionMapping.FromUnitKey, out UnitInfo? fromUnitInfo) ||
+                !quantities.TryGetUnitInfo(unitConversionMapping.ToUnitKey, out UnitInfo? toUnitInfo))
+            {
+                continue;
+            }
+
+            var conversionMapping = new QuantityConversion(fromUnitInfo.QuantityInfo, toUnitInfo.QuantityInfo);
+            if (!conversionOptions.TryGetValue(conversionMapping, out QuantityConversionMappingOptions? conversionMappingOptions))
+            {
+                conversionMappingOptions = conversionOptions[conversionMapping] = new QuantityConversionMappingOptions();
+            }
+
+            conversionMappingOptions.ConversionExpressions.Add(unitConversionMapping,
+                new CustomQuantityConversionExpressionMapping(fromUnitInfo, toUnitInfo, customConversion.Value));
+        }
+
+        foreach (UnitConversionMapping unitConversionMapping in customOptions.ConversionUnits)
+        {
+            if (!quantities.TryGetUnitInfo(unitConversionMapping.FromUnitKey, out UnitInfo? fromUnitInfo) ||
+                !quantities.TryGetUnitInfo(unitConversionMapping.ToUnitKey, out UnitInfo? toUnitInfo))
+            {
+                continue;
+            }
+
+            var conversionMapping = new QuantityConversion(fromUnitInfo.QuantityInfo, toUnitInfo.QuantityInfo);
+            if (!conversionOptions.TryGetValue(conversionMapping, out QuantityConversionMappingOptions? conversionMappingOptions))
+            {
+                conversionMappingOptions = conversionOptions[conversionMapping] = new QuantityConversionMappingOptions();
+                conversionMappingOptions.CustomUnitMappings.Add(unitConversionMapping, new CustomQuantityConversionUnitMapping(fromUnitInfo, toUnitInfo));
+            }
+            else if (!conversionMappingOptions.ConversionExpressions.ContainsKey(unitConversionMapping))
+            {
+                conversionMappingOptions.CustomUnitMappings.Add(unitConversionMapping, new CustomQuantityConversionUnitMapping(fromUnitInfo, toUnitInfo));
+            }
+        }
+
+        return conversionOptions;
+    }
+
+    /// <summary>
+    ///     Retrieves conversion expressions for a collection of quantity conversions based on the specified caching mode and
+    ///     constant reduction option.
+    /// </summary>
+    /// <param name="conversions">The collection of quantity conversions to process.</param>
+    /// <param name="cachingMode">The caching mode to use for the conversions.</param>
+    /// <param name="reduceConstants">Indicates whether to reduce constants in the conversion expressions.</param>
+    /// <returns>
+    ///     An enumerable collection of key-value pairs, where the key is a <see cref="QuantityConversionKey" /> and the
+    ///     value is a <see cref="QuantityConversionFunction" />.
+    /// </returns>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when an invalid caching mode is specified.</exception>
+    public static IEnumerable<ConversionEntry> GetConversionFunctions(this IEnumerable<QuantityConversion> conversions,
+        ConversionCachingMode cachingMode, bool reduceConstants = true)
+    {
+        return cachingMode switch
+        {
+            ConversionCachingMode.None => [],
+            ConversionCachingMode.BaseOnly => conversions.SelectMany(conversion => conversion.GetConversionsWithBaseUnits()),
+            ConversionCachingMode.All => conversions.SelectMany(conversion => conversion.GetConversionsWithAllUnits(reduceConstants)),
+            _ => throw new ArgumentOutOfRangeException()
+        };
+    }
+
+    /// <summary>
+    ///     Retrieves conversion expressions for a given set of quantity conversions, applying custom caching options if
+    ///     provided.
+    /// </summary>
+    /// <param name="conversions">The collection of quantity conversions to process.</param>
+    /// <param name="defaultCachingMode">The default caching mode to use if no custom options are specified.</param>
+    /// <param name="defaultConstantsReduction">Indicates whether to reduce constants by default.</param>
+    /// <param name="customCachingOptions">A dictionary of custom caching options keyed by quantity type.</param>
+    /// <returns>
+    ///     An enumerable of key-value pairs, where the key is a <see cref="QuantityConversionKey" /> and the value is a
+    ///     <see cref="QuantityConversionFunction" />.
+    /// </returns>
+    public static IEnumerable<ConversionEntry> GetConversionFunctions(this IEnumerable<QuantityConversion> conversions,
+        ConversionCachingMode defaultCachingMode, bool defaultConstantsReduction,
+        IReadOnlyDictionary<Type, ConversionCacheOptions> customCachingOptions)
+    {
+        return customCachingOptions.Count == 0
+            ? conversions.GetConversionFunctions(defaultCachingMode, defaultConstantsReduction)
+            : conversions.SelectMany(conversion => conversion.GetConversionFunctions(defaultCachingMode, defaultConstantsReduction, customCachingOptions));
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionFunctions(this QuantityConversion conversion, ConversionCachingMode defaultCachingMode, bool defaultConstantsReduction,
+        IReadOnlyDictionary<Type, ConversionCacheOptions> customCachingOptions)
+    {
+        (QuantityInfo leftQuantity, QuantityInfo rightQuantity) = conversion;
+        if (customCachingOptions.TryGetValue(leftQuantity.QuantityType, out ConversionCacheOptions? leftCacheOptions) &&
+            (leftCacheOptions.CachingMode != defaultCachingMode || leftCacheOptions.ReduceConstants != defaultConstantsReduction))
+        {
+            if (customCachingOptions.TryGetValue(rightQuantity.QuantityType, out ConversionCacheOptions? rightCacheOptions))
+            {
+                return leftCacheOptions == rightCacheOptions
+                    ? conversion.GetQuantityConversions(leftCacheOptions.CachingMode, leftCacheOptions.ReduceConstants)
+                    : leftQuantity.GetConversionsTo(rightQuantity, leftCacheOptions.CachingMode, leftCacheOptions.ReduceConstants)
+                        .Concat(rightQuantity.GetConversionsTo(leftQuantity, rightCacheOptions.CachingMode, rightCacheOptions.ReduceConstants));
+            }
+
+            return leftQuantity.GetConversionsTo(rightQuantity, leftCacheOptions.CachingMode, leftCacheOptions.ReduceConstants)
+                .Concat(rightQuantity.GetConversionsTo(leftQuantity, defaultCachingMode, defaultConstantsReduction));
+        }
+        else if (customCachingOptions.TryGetValue(rightQuantity.QuantityType, out ConversionCacheOptions? rightCacheOptions) &&
+                 (rightCacheOptions.CachingMode != defaultCachingMode || rightCacheOptions.ReduceConstants != defaultConstantsReduction))
+        {
+            return leftQuantity.GetConversionsTo(rightQuantity, defaultCachingMode, defaultConstantsReduction)
+                .Concat(rightQuantity.GetConversionsTo(leftQuantity, rightCacheOptions.CachingMode, rightCacheOptions.ReduceConstants));
+        }
+        else // using the default options
+        {
+            return conversion.GetQuantityConversions(defaultCachingMode, defaultConstantsReduction);
+        }
+    }
+
+    /// <summary>
+    ///     Retrieves conversion expressions for a given set of quantity conversions.
+    /// </summary>
+    /// <param name="conversions">The collection of quantity conversions to process.</param>
+    /// <param name="customUnitConversions">A dictionary containing custom unit conversions.</param>
+    /// <param name="defaultCachingMode">The default caching mode to use if no custom caching options are provided.</param>
+    /// <param name="defaultConstantsReduction">A flag indicating whether constants reduction should be applied by default.</param>
+    /// <param name="customCachingOptions">A dictionary containing custom caching options for specific types.</param>
+    /// <returns>
+    ///     An enumerable collection of key-value pairs, where each key is a <see cref="QuantityConversionKey" /> and each
+    ///     value is a <see cref="QuantityConversionFunction" />.
+    /// </returns>
+    public static IEnumerable<ConversionEntry> GetConversionFunctions(this IEnumerable<QuantityConversion> conversions,
+        IReadOnlyDictionary<QuantityConversion, QuantityConversionMappingOptions> customUnitConversions,
+        ConversionCachingMode defaultCachingMode, bool defaultConstantsReduction,
+        IReadOnlyDictionary<Type, ConversionCacheOptions> customCachingOptions)
+    {
+        if (customUnitConversions.Count == 0)
+        {
+            return conversions.GetConversionFunctions(defaultCachingMode, defaultConstantsReduction, customCachingOptions);
+        }
+
+        return conversions.SelectMany(conversion => customUnitConversions.TryGetValue(conversion, out QuantityConversionMappingOptions? conversionMappingOptions)
+            ? conversion.GetConversionFunctions(conversionMappingOptions, defaultCachingMode, defaultConstantsReduction, customCachingOptions)
+            : conversion.GetConversionFunctions(defaultCachingMode, defaultConstantsReduction, customCachingOptions));
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionFunctions(this QuantityConversion conversion, QuantityConversionMappingOptions customUnitConversions,
+        ConversionCachingMode defaultCachingMode, bool defaultConstantsReduction, IReadOnlyDictionary<Type, ConversionCacheOptions> customCachingOptions)
+    {
+        (QuantityInfo leftQuantity, QuantityInfo rightQuantity) = conversion;
+        if (customCachingOptions.TryGetValue(leftQuantity.QuantityType, out ConversionCacheOptions? leftCacheOptions) &&
+            (leftCacheOptions.CachingMode != defaultCachingMode || leftCacheOptions.ReduceConstants != defaultConstantsReduction))
+        {
+            if (customCachingOptions.TryGetValue(rightQuantity.QuantityType, out ConversionCacheOptions? rightCacheOptions))
+            {
+                return leftCacheOptions == rightCacheOptions
+                    ? conversion.GetQuantityConversions(customUnitConversions, leftCacheOptions.CachingMode, leftCacheOptions.ReduceConstants)
+                    : leftQuantity.GetConversionsTo(rightQuantity, customUnitConversions, leftCacheOptions.CachingMode, leftCacheOptions.ReduceConstants)
+                        .Concat(rightQuantity.GetConversionsTo(leftQuantity, customUnitConversions, rightCacheOptions.CachingMode,
+                            rightCacheOptions.ReduceConstants));
+            }
+
+            return leftQuantity.GetConversionsTo(rightQuantity, customUnitConversions, leftCacheOptions.CachingMode, leftCacheOptions.ReduceConstants)
+                .Concat(rightQuantity.GetConversionsTo(leftQuantity, customUnitConversions, defaultCachingMode, defaultConstantsReduction));
+        }
+        else if (customCachingOptions.TryGetValue(rightQuantity.QuantityType, out ConversionCacheOptions? rightCacheOptions) &&
+                 (rightCacheOptions.CachingMode != defaultCachingMode || rightCacheOptions.ReduceConstants != defaultConstantsReduction))
+        {
+            return leftQuantity.GetConversionsTo(rightQuantity, customUnitConversions, defaultCachingMode, defaultConstantsReduction)
+                .Concat(rightQuantity.GetConversionsTo(leftQuantity, customUnitConversions, rightCacheOptions.CachingMode, rightCacheOptions.ReduceConstants));
+        }
+        else // using the default options
+        {
+            return conversion.GetQuantityConversions(customUnitConversions, defaultCachingMode, defaultConstantsReduction);
+        }
+    }
+
+    private static IEnumerable<ConversionEntry> GetQuantityConversions(this QuantityConversion conversion, ConversionCachingMode cachingMode, bool reduceConstants)
+    {
+        return cachingMode switch
+        {
+            ConversionCachingMode.None => [],
+            ConversionCachingMode.BaseOnly => conversion.GetConversionsWithBaseUnits(),
+            ConversionCachingMode.All => conversion.GetConversionsWithAllUnits(reduceConstants),
+            _ => throw new ArgumentOutOfRangeException()
+        };
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsTo(this QuantityInfo fromQuantity, QuantityInfo toQuantity, ConversionCachingMode cachingMode, bool reduceConstants)
+    {
+        return cachingMode switch
+        {
+            ConversionCachingMode.None => [],
+            ConversionCachingMode.BaseOnly => fromQuantity.GetConversionsWithBaseUnits(toQuantity),
+            ConversionCachingMode.All => fromQuantity.GetConversionsWithAllUnits(toQuantity, reduceConstants),
+            _ => throw new ArgumentOutOfRangeException()
+        };
+    }
+
+    private static IEnumerable<ConversionEntry> GetQuantityConversions(this QuantityConversion conversion, QuantityConversionMappingOptions customUnitConversions, ConversionCachingMode cachingMode, bool reduceConstants)
+    {
+        return conversion.LeftQuantity.GetConversionsTo(conversion.RightQuantity, customUnitConversions, cachingMode, reduceConstants)
+            .Concat(conversion.RightQuantity.GetConversionsTo(conversion.LeftQuantity, customUnitConversions, cachingMode, reduceConstants));
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsTo(this QuantityInfo fromQuantity, QuantityInfo toQuantity, QuantityConversionMappingOptions customUnitConversions,
+        ConversionCachingMode cachingMode, bool reduceConstants)
+    {
+        // filter the customUnitConversions for specified conversion direction
+        Type sourceUnitType = fromQuantity.UnitType;
+        var unitMappings = customUnitConversions.CustomUnitMappings.Where(x => x.Key.FromUnitKey.UnitEnumType == sourceUnitType)
+            .ToDictionary(x => x.Key.FromUnitKey, pair => pair.Value);
+        var conversionExpressions = customUnitConversions.ConversionExpressions.Where(x => x.Key.FromUnitKey.UnitEnumType == sourceUnitType)
+            .ToDictionary(x => x.Key.FromUnitKey, pair => pair.Value);
+        // if there are any custom conversionExpressions we ignore the caching mode and calculate an expression for all units
+        if (conversionExpressions.Count != 0)
+        {
+            return fromQuantity.GetConversionsWithAllUnits(toQuantity, unitMappings, conversionExpressions, reduceConstants);
+        }
+
+        return cachingMode switch
+        {
+            ConversionCachingMode.None => fromQuantity.GetConversionsWithCustomUnits(toQuantity, unitMappings, reduceConstants),
+            ConversionCachingMode.BaseOnly => fromQuantity.GetConversionsWithBaseUnits(toQuantity, unitMappings, reduceConstants),
+            ConversionCachingMode.All => fromQuantity.GetConversionsWithAllUnits(toQuantity, unitMappings, conversionExpressions, reduceConstants),
+            _ => throw new ArgumentOutOfRangeException()
+        };
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsWithBaseUnits(this QuantityConversion conversion)
+    {
+        (QuantityInfo leftQuantity, QuantityInfo rightQuantity) = conversion;
+        ConvertValueDelegate conversionDelegate = leftQuantity.BaseDimensions.GetConversionDelegate(rightQuantity.BaseDimensions);
+        return conversion.LeftQuantity.GetConversionsWithBaseUnits(conversion.RightQuantity, conversionDelegate)
+            .Concat(conversion.RightQuantity.GetConversionsWithBaseUnits(conversion.LeftQuantity, conversionDelegate));
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsWithBaseUnits(this QuantityInfo fromQuantity, QuantityInfo toQuantity)
+    {
+        return fromQuantity.GetConversionsWithBaseUnits(toQuantity, fromQuantity.BaseDimensions.GetConversionDelegate(toQuantity.BaseDimensions));
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsWithBaseUnits(this QuantityInfo fromQuantity, QuantityInfo toQuantity, ConvertValueDelegate conversionExpression)
+    {
+        foreach (UnitInfo fromUnit in fromQuantity.UnitInfos)
+        {
+            if (fromUnit.BaseUnits == BaseUnits.Undefined || !toQuantity.UnitInfos.TryGetUnitWithBase(fromUnit.BaseUnits, out UnitInfo? toUnit))
+            {
+                continue;
+            }
+
+            var conversionKey = new QuantityConversionKey(fromUnit.UnitKey, toQuantity.UnitType);
+            var conversionResult = new QuantityConversionFunction(conversionExpression, toUnit.UnitKey);
+            yield return new ConversionEntry(conversionKey, conversionResult);
+        }
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsWithAllUnits(this QuantityConversion conversion, bool reduceConstants = true)
+    {
+        ConversionExpression conversionExpression = conversion.LeftQuantity.BaseDimensions.GetConversionExpression(conversion.RightQuantity.BaseDimensions);
+
+        return conversion.LeftQuantity.GetConversionsWithAllUnits(conversion.RightQuantity, conversionExpression, reduceConstants)
+            .Concat(conversion.RightQuantity.GetConversionsWithAllUnits(conversion.LeftQuantity, conversionExpression, reduceConstants));
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsWithAllUnits(this QuantityInfo fromQuantity, QuantityInfo toQuantity, bool reduceConstants = true)
+    {
+        return fromQuantity.GetConversionsWithAllUnits(toQuantity, fromQuantity.BaseDimensions.GetConversionExpression(toQuantity.BaseDimensions), reduceConstants);
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsWithAllUnits(this QuantityInfo fromQuantity, QuantityInfo toQuantity, ConversionExpression conversionExpression,
+        bool reduceConstants = true)
+    {
+        foreach (UnitInfo fromUnit in fromQuantity.UnitInfos)
+        {
+            if (toQuantity.TryGetConversionFrom(fromUnit, conversionExpression, reduceConstants, out QuantityConversionFunction conversionFunction))
+            {
+                yield return new ConversionEntry(new QuantityConversionKey(fromUnit.UnitKey, conversionFunction.TargetUnit.UnitEnumType), conversionFunction);
+            }
+            else
+            {
+                throw InvalidConversionException.CreateIncompatibleUnitsException(fromUnit, toQuantity);
+            }
+        }
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsWithCustomUnits(this QuantityInfo fromQuantity, QuantityInfo toQuantity,
+        Dictionary<UnitKey, CustomQuantityConversionUnitMapping> unitMappings,
+        bool reduceConstants)
+    {
+        Type targetUnitType = toQuantity.UnitType;
+        ConversionExpression conversionWithBaseUnits = fromQuantity.BaseDimensions.GetConversionExpression(toQuantity.BaseDimensions);
+        foreach (KeyValuePair<UnitKey, CustomQuantityConversionUnitMapping> unitMapping in unitMappings)
+        {
+            // a custom target unit was specified for the conversion (without specifying an expression)
+            UnitKey fromUnitKey = unitMapping.Key;
+            UnitInfo fromUnit = unitMapping.Value.SourceUnit;
+            UnitInfo targetUnit = unitMapping.Value.TargetUnit;
+            ConversionExpression expressionForUnits = conversionWithBaseUnits.GetExpressionForUnits(fromUnit, targetUnit, reduceConstants);
+            var conversionKey = new QuantityConversionKey(fromUnitKey, targetUnitType);
+            yield return new ConversionEntry(conversionKey, new QuantityConversionFunction(expressionForUnits, targetUnit.UnitKey));
+        }
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsWithBaseUnits(this QuantityInfo fromQuantity, QuantityInfo toQuantity,
+        Dictionary<UnitKey, CustomQuantityConversionUnitMapping> unitMappings,
+        bool reduceConstants)
+    {
+        // no conversion functions provided: constructing the expressions using the BaseDimensions
+        Type targetUnitType = toQuantity.UnitType;
+        ConversionExpression conversionWithBaseUnits = fromQuantity.BaseDimensions.GetConversionExpression(toQuantity.BaseDimensions);
+        IReadOnlyList<UnitInfo> unitInfos = fromQuantity.UnitInfos;
+        var nbUnits = unitInfos.Count;
+        for (var i = 0; i < nbUnits; i++)
+        {
+            UnitInfo fromUnit = unitInfos[i];
+            var conversionKey = new QuantityConversionKey(fromUnit.UnitKey, targetUnitType);
+            if (unitMappings.TryGetValue(conversionKey.FromUnit, out CustomQuantityConversionUnitMapping? customQuantityConversion))
+            {
+                // a custom target unit was specified for the conversion (without specifying an expression)
+                UnitInfo targetUnit = customQuantityConversion.TargetUnit;
+                ConversionExpression expressionForUnits = conversionWithBaseUnits.GetExpressionForUnits(fromUnit, targetUnit, reduceConstants);
+                yield return new ConversionEntry(conversionKey, new QuantityConversionFunction(expressionForUnits, targetUnit.UnitKey));
+            }
+            else if (fromUnit.BaseUnits != BaseUnits.Undefined)
+            {
+                if (toQuantity.TryGetConversionFrom(fromUnit, conversionWithBaseUnits, reduceConstants, out QuantityConversionFunction conversionFunction))
+                {
+                    yield return new ConversionEntry(conversionKey, conversionFunction);
+                }
+                else
+                {
+                    throw InvalidConversionException.CreateIncompatibleUnitsException(fromUnit, toQuantity);
+                }
+            }
+        }
+    }
+
+    private static IEnumerable<ConversionEntry> GetConversionsWithAllUnits(this QuantityInfo fromQuantity, QuantityInfo toQuantity,
+        Dictionary<UnitKey, CustomQuantityConversionUnitMapping> unitMappings,
+        Dictionary<UnitKey, CustomQuantityConversionExpressionMapping> conversionExpressions,
+        bool reduceConstants)
+    {
+        // there are two supported scenarios:
+        // 1. the two quantities have compatible BaseDimensions (i.e. equal or inverse) and there are units with compatible BaseUnits
+        // 2. the conversionOptions provide at least one conversion expression that can be used as the "conversion base" for the rest of the units
+        IReadOnlyList<UnitInfo> fromQuantityUnits = fromQuantity.UnitInfos;
+        var fromQuantityUnitsCount = fromQuantityUnits.Count;
+        if (conversionExpressions.Count == 0)
+        {
+            // 1. no conversion functions provided: constructing the expressions using the BaseDimensions
+            ConversionExpression conversionWithBaseUnits = fromQuantity.BaseDimensions.GetConversionExpression(toQuantity.BaseDimensions);
+            for (var i = 0; i < fromQuantityUnitsCount; i++)
+            {
+                UnitInfo fromUnit = fromQuantityUnits[i];
+                var conversionKey = new QuantityConversionKey(fromUnit.UnitKey, toQuantity.UnitType);
+                if (unitMappings.TryGetValue(conversionKey.FromUnit, out CustomQuantityConversionUnitMapping? customQuantityConversion))
+                {
+                    // a custom target unit was specified for the conversion (without specifying an expression)
+                    UnitInfo targetUnit = customQuantityConversion.TargetUnit;
+                    ConversionExpression expressionForUnits = conversionWithBaseUnits.GetExpressionForUnits(fromUnit, targetUnit, reduceConstants);
+                    yield return new ConversionEntry(conversionKey, new QuantityConversionFunction(expressionForUnits, targetUnit.UnitKey));
+                }
+                else if (toQuantity.TryGetConversionFrom(fromUnit, conversionWithBaseUnits, reduceConstants, out QuantityConversionFunction conversionFunction))
+                {
+                    yield return new ConversionEntry(conversionKey, conversionFunction);
+                }
+                else
+                {
+                    throw InvalidConversionException.CreateIncompatibleUnitsException(fromUnit, toQuantity);
+                }
+            }
+        }
+        else
+        {
+            // 2. an explicit conversion function was provided and will be used as the base for the rest of the units
+            CustomQuantityConversionExpressionMapping customConversion = conversionExpressions.First().Value;
+            UnitInfo sourceConversionBase = customConversion.SourceUnit;
+            UnitInfo targetConversionBase = customConversion.TargetUnit;
+            ConversionExpression conversionWithBase = customConversion.ConversionExpression;
+            for (var i = 0; i < fromQuantityUnitsCount; i++)
+            {
+                UnitInfo fromUnit = fromQuantityUnits[i];
+                var conversionKey = new QuantityConversionKey(fromUnit.UnitKey, toQuantity.UnitType);
+                if (unitMappings.TryGetValue(conversionKey.FromUnit, out CustomQuantityConversionUnitMapping? unitMapping))
+                {
+                    // a custom target unit was specified for the conversion (without specifying an expression)
+                    ConversionExpression conversionToSourceBase = fromUnit.GetUnitConversionExpressionTo(sourceConversionBase, false);
+                    ConversionExpression conversionToTargetBase = conversionWithBase.Evaluate(conversionToSourceBase);
+                    ConversionExpression conversionToTargetUnit = targetConversionBase.GetUnitConversionExpressionTo(unitMapping.TargetUnit, false);
+                    ConversionExpression conversionToTarget = conversionToTargetUnit.Evaluate(conversionToTargetBase, reduceConstants);
+                    yield return new ConversionEntry(conversionKey, new QuantityConversionFunction(conversionToTarget, unitMapping.TargetUnit.UnitKey));
+                }
+                else if (conversionExpressions.TryGetValue(conversionKey.FromUnit, out CustomQuantityConversionExpressionMapping? expressionMapping))
+                {
+                    // a custom target unit was specified for the conversion (including the corresponding expression)
+                    var conversionFunction = new QuantityConversionFunction(expressionMapping.ConversionExpression, expressionMapping.TargetUnit.UnitKey);
+                    yield return new ConversionEntry(conversionKey, conversionFunction);
+                }
+                else
+                {
+                    // nothing was specified for the conversion: automatically select the target unit
+                    ConversionExpression conversionToSourceBase = fromUnit.GetUnitConversionExpressionTo(sourceConversionBase, false);
+                    ConversionExpression conversionToTargetBase = conversionWithBase.Evaluate(conversionToSourceBase, reduceConstants);
+                    QuantityConversionFunction conversion = toQuantity.GetConversionWithBase(targetConversionBase, conversionToTargetBase, reduceConstants);
+                    yield return new ConversionEntry(conversionKey, conversion);
+                }
+            }
+        }
+    }
+
+    private static ConversionExpression GetConversionExpression(this BaseDimensions fromDimensions, BaseDimensions toDimensions)
+    {
+        if (fromDimensions.IsInverseOf(toDimensions))
+        {
+            return new ConversionExpression(coefficient: 1, exponent: -1);
+        }
+
+        if (fromDimensions == toDimensions)
+        {
+            return QuantityValue.One;
+        }
+
+        // note: technically we could to attempt to work with the powers, but currently there aren't any such cases
+        throw InvalidConversionException.CreateIncompatibleDimensionsException(fromDimensions, toDimensions);
+    }
+
+    private static bool TryGetConversionExpression(this BaseDimensions fromDimensions, BaseDimensions toDimensions, out ConversionExpression conversionExpression)
+    {
+        if (fromDimensions.IsInverseOf(toDimensions))
+        {
+            conversionExpression = new ConversionExpression(coefficient: 1, exponent: -1);
+            return true;
+        }
+
+        if (fromDimensions == toDimensions)
+        {
+            conversionExpression = QuantityValue.One;
+            return true;
+        }
+
+        // note: technically we could to attempt to work with the powers, but currently there aren't any such cases
+        conversionExpression = default;
+        return false;
+    }
+
+    private static ConvertValueDelegate GetConversionDelegate(this BaseDimensions fromDimensions, BaseDimensions toDimensions)
+    {
+        if (fromDimensions.IsInverseOf(toDimensions))
+        {
+            return QuantityValue.Inverse;
+        }
+
+        if (fromDimensions == toDimensions)
+        {
+            return value => value;
+        }
+
+        // note: technically we could to attempt to work with the powers, but currently there aren't any such cases
+        throw InvalidConversionException.CreateIncompatibleDimensionsException(fromDimensions, toDimensions);
+    }
+
+    /// <summary>
+    ///     Retrieves a conversion expression for converting to a target quantity from the unit of another quantity type.
+    /// </summary>
+    /// <param name="toQuantity">The target quantity information.</param>
+    /// <param name="fromUnit">The source unit information.</param>
+    /// <param name="reduceConstants">Indicates whether to reduce constants in the conversion expression. Default is true.</param>
+    /// <returns>A <see cref="QuantityConversionFunction" /> representing the conversion expression and the target unit key.</returns>
+    /// <exception cref="InvalidConversionException">Thrown when no matching base units are found for the conversion operation.</exception>
+    /// <remarks>
+    ///     This method is optimized for selecting the target unit that is closest in magnitude to the
+    ///     <paramref name="fromUnit" />.
+    /// </remarks>
+    public static QuantityConversionFunction GetQuantityConversionFrom(this QuantityInfo toQuantity, UnitInfo fromUnit, bool reduceConstants = true)
+    {
+        QuantityInfo fromQuantityInfo = fromUnit.QuantityInfo;
+        ConversionExpression conversionExpression = fromQuantityInfo.BaseDimensions.GetConversionExpression(toQuantity.BaseDimensions);
+
+        if (toQuantity.TryGetConversionFrom(fromUnit, conversionExpression, reduceConstants, out QuantityConversionFunction conversionFunction))
+        {
+            return conversionFunction;
+        }
+
+        throw InvalidConversionException.CreateIncompatibleUnitsException(fromUnit, toQuantity);
+    }
+
+    /// <summary>
+    ///     Attempts to get a quantity conversion expression from the specified unit to the target quantity.
+    /// </summary>
+    /// <param name="toQuantity">The target quantity information.</param>
+    /// <param name="fromUnit">The source unit information.</param>
+    /// <param name="reduceConstants">Indicates whether to reduce constants in the conversion expression.</param>
+    /// <param name="conversionFunction">
+    ///     When this method returns, contains the quantity conversion function if the conversion was successful; otherwise,
+    ///     <c>null</c>.
+    ///     This parameter is passed uninitialized.
+    /// </param>
+    /// <returns><c>true</c> if the conversion expression was successfully retrieved; otherwise, <c>false</c>.</returns>
+    public static bool TryGetQuantityConversionFrom(this QuantityInfo toQuantity, UnitInfo fromUnit, bool reduceConstants,
+        out QuantityConversionFunction conversionFunction)
+    {
+        if (fromUnit.QuantityInfo.BaseDimensions.TryGetConversionExpression(toQuantity.BaseDimensions, out ConversionExpression conversionExpression))
+        {
+            return toQuantity.TryGetConversionFrom(fromUnit, conversionExpression, reduceConstants, out conversionFunction);
+        }
+
+        conversionFunction = default;
+        return false;
+    }
+
+    private static bool TryGetConversionFrom(this QuantityInfo toQuantity, UnitInfo fromUnit, ConversionExpression conversionWithBase, bool reduceConstants,
+        out QuantityConversionFunction conversionFunction)
+    {
+        QuantityInfo fromQuantityInfo = fromUnit.QuantityInfo;
+        if (fromUnit.BaseUnits != BaseUnits.Undefined)
+        {
+            if (toQuantity.UnitInfos.TryGetUnitWithBase(fromUnit.BaseUnits, out UnitInfo? matchingBaseUnit))
+            {
+                conversionFunction = new QuantityConversionFunction(conversionWithBase, matchingBaseUnit.UnitKey);
+                return true;
+            }
+        }
+
+        if (fromQuantityInfo.TryGetSIBaseUnit(out UnitInfo? sourceSI) && toQuantity.TryGetSIBaseUnit(out UnitInfo? targetSI))
+        {
+            ConversionExpression conversionToSI = fromUnit.GetUnitConversionExpressionTo(sourceSI, false);
+            ConversionExpression fromUnitToTargetSI = conversionWithBase.Evaluate(conversionToSI, reduceConstants);
+            conversionFunction = toQuantity.GetConversionWithBase(targetSI, fromUnitToTargetSI, reduceConstants);
+            return true;
+        }
+
+        // one of the quantities doesn't have any SI units: attempt find an exactly matching base
+        IReadOnlyList<UnitInfo> fromQuantityUnits = fromQuantityInfo.UnitInfos;
+        var fromQuantityUnitsCount = fromQuantityUnits.Count;
+        for (var i = 0; i < fromQuantityUnitsCount; i++)
+        {
+            UnitInfo sourceUnit = fromQuantityUnits[i];
+            if (sourceUnit.BaseUnits == BaseUnits.Undefined || sourceUnit.BaseUnits == fromUnit.BaseUnits)
+            {
+                continue;
+            }
+
+            if (!toQuantity.UnitInfos.TryGetUnitWithBase(sourceUnit.BaseUnits, out UnitInfo? matchingUnit))
+            {
+                continue;
+            }
+
+            ConversionExpression conversionToUnit = fromUnit.GetUnitConversionExpressionTo(sourceUnit, false);
+            ConversionExpression fromUnitToMatchingUnit = conversionWithBase.Evaluate(conversionToUnit, reduceConstants);
+            conversionFunction = toQuantity.GetConversionWithBase(matchingUnit, fromUnitToMatchingUnit, reduceConstants);
+            return true;
+        }
+
+        conversionFunction = default;
+        return false;
+    }
+
+    private static QuantityConversionFunction GetConversionWithBase(this QuantityInfo quantity, UnitInfo baseUnit, ConversionExpression conversionToBase,
+        bool reduceConstants)
+    {
+        UnitInfo currentlySelectedUnit = baseUnit;
+        ConversionExpression conversionToSelectedUnit = conversionToBase;
+        QuantityValue currentFactor = GetFactorMagnitude(conversionToBase.Coefficient);
+        if (currentFactor == QuantityValue.One)
+        {
+            return new QuantityConversionFunction(conversionToBase, baseUnit.UnitKey);
+        }
+
+        IReadOnlyList<UnitInfo> unitInfos = quantity.UnitInfos;
+        var nbUnits = unitInfos.Count;
+        for (var i = 0; i < nbUnits; i++)
+        {
+            UnitInfo toUnitInfo = unitInfos[i];
+            if (toUnitInfo == baseUnit)
+            {
+                continue;
+            }
+
+            ConversionExpression fromBaseToUnitConversion = baseUnit.GetUnitConversionExpressionTo(toUnitInfo, false);
+            ConversionExpression expressionToUnit = fromBaseToUnitConversion.Evaluate(conversionToBase, reduceConstants);
+            QuantityValue expressionFactor = GetFactorMagnitude(expressionToUnit.Coefficient);
+            if (expressionFactor >= currentFactor)
+            {
+                continue;
+            }
+
+            currentlySelectedUnit = toUnitInfo;
+            conversionToSelectedUnit = expressionToUnit;
+            currentFactor = expressionFactor;
+            if (currentFactor == QuantityValue.One)
+            {
+                break; // found the best possible option
+            }
+        }
+
+        return new QuantityConversionFunction(conversionToSelectedUnit, currentlySelectedUnit.UnitKey);
+
+        static QuantityValue GetFactorMagnitude(QuantityValue conversionFactor)
+        {
+            conversionFactor = QuantityValue.Abs(conversionFactor);
+            return conversionFactor < QuantityValue.One ? QuantityValue.Inverse(conversionFactor) : conversionFactor;
+        }
+    }
+
+    /// <summary>
+    ///     Gets the conversion expression to convert a quantity from the specified unit of the source quantity type to the
+    ///     specified unit of the target quantity type.
+    /// </summary>
+    /// <param name="fromUnitInfo">The unit information of the source quantity type.</param>
+    /// <param name="toUnitInfo">The unit information of the target quantity type.</param>
+    /// <param name="reduceConstants">
+    ///     A boolean value indicating whether to reduce constants in the conversion expression.
+    ///     Default is true.
+    /// </param>
+    /// <returns>
+    ///     A <see cref="ConversionExpression" /> representing the conversion from the specified unit of the source quantity
+    ///     type to the specified unit of the target quantity type.
+    /// </returns>
+    /// <exception cref="InvalidOperationException">Thrown when no matching base units are found for the conversion operation.</exception>
+    public static ConversionExpression GetQuantityConversionExpressionTo(this UnitInfo fromUnitInfo, UnitInfo toUnitInfo, bool reduceConstants = true)
+    {
+        ConversionExpression conversionWithBaseUnits = fromUnitInfo.QuantityInfo.BaseDimensions.GetConversionExpression(toUnitInfo.QuantityInfo.BaseDimensions);
+        return conversionWithBaseUnits.GetExpressionForUnits(fromUnitInfo, toUnitInfo, reduceConstants);
+    }
+
+    private static ConversionExpression GetExpressionForUnits(this ConversionExpression conversionWithBaseUnits, UnitInfo fromUnitInfo, UnitInfo toUnitInfo,
+        bool reduceConstants)
+    {
+        if (fromUnitInfo.BaseUnits != BaseUnits.Undefined && fromUnitInfo.BaseUnits == toUnitInfo.BaseUnits)
+        {
+            return conversionWithBaseUnits;
+        }
+
+        QuantityInfo fromQuantityInfo = fromUnitInfo.QuantityInfo;
+        QuantityInfo toQuantityInfo = toUnitInfo.QuantityInfo;
+        if (fromQuantityInfo.TryGetSIBaseUnit(out UnitInfo? sourceSI) && toQuantityInfo.TryGetSIBaseUnit(out UnitInfo? targetSI))
+        {
+            ConversionExpression fromUnitToTargetSI = conversionWithBaseUnits.Evaluate(fromUnitInfo.GetUnitConversionExpressionTo(sourceSI));
+            ConversionExpression fromUnitToTargetUnit = targetSI.GetUnitConversionExpressionTo(toUnitInfo).Evaluate(fromUnitToTargetSI, reduceConstants);
+            return fromUnitToTargetUnit;
+        }
+
+        IReadOnlyList<UnitInfo> fromQuantityUnits = fromQuantityInfo.UnitInfos;
+        var fromQuantityUnitsCount = fromQuantityUnits.Count;
+        for (var i = 0; i < fromQuantityUnitsCount; i++)
+        {
+            UnitInfo sourceUnit = fromQuantityUnits[i];
+            if (sourceUnit.BaseUnits == BaseUnits.Undefined || !toQuantityInfo.UnitInfos.TryGetUnitWithBase(sourceUnit.BaseUnits, out UnitInfo? matchingUnit))
+            {
+                continue;
+            }
+
+            ConversionExpression fromUnitToMatchingUnit = conversionWithBaseUnits.Evaluate(fromUnitInfo.GetUnitConversionExpressionTo(sourceUnit, false));
+            ConversionExpression fromUnitToTargetUnit = matchingUnit.GetUnitConversionExpressionTo(toUnitInfo, false).Evaluate(fromUnitToMatchingUnit, true);
+            return fromUnitToTargetUnit;
+        }
+
+        throw InvalidConversionException.CreateIncompatibleUnitsException(fromUnitInfo, toQuantityInfo);
+    }
+
+    /// <summary>
+    ///     Attempts to get the conversion expression to convert a quantity from the specified unit of the source quantity type
+    ///     to the specified unit of the target quantity type.
+    /// </summary>
+    /// <param name="fromUnitInfo">The unit information of the source quantity type.</param>
+    /// <param name="toUnitInfo">The unit information of the target quantity type.</param>
+    /// <param name="reduceConstants">
+    ///     A boolean value indicating whether to reduce constants in the conversion expression.
+    ///     Default is true.
+    /// </param>
+    /// <param name="conversionExpression">
+    ///     When this method returns, contains the conversion expression from the specified unit of the source quantity type
+    ///     to the specified unit of the target quantity type, if the conversion is successful; otherwise, null.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the conversion expression was successfully retrieved; otherwise, <c>false</c>.
+    /// </returns>
+    /// <exception cref="InvalidOperationException">Thrown when no matching base units are found for the conversion operation.</exception>
+    public static bool TryGetQuantityConversionExpressionTo(this UnitInfo fromUnitInfo, UnitInfo toUnitInfo, bool reduceConstants, [NotNullWhen(true)] out ConversionExpression? conversionExpression)
+    {
+        QuantityInfo fromQuantityInfo = fromUnitInfo.QuantityInfo;
+        QuantityInfo toQuantityInfo = toUnitInfo.QuantityInfo;
+
+        if (!fromQuantityInfo.BaseDimensions.TryGetConversionExpression(toQuantityInfo.BaseDimensions, out ConversionExpression quantityConversionExpression))
+        {
+            conversionExpression = null;
+            return false;
+        }
+
+        if (fromUnitInfo.BaseUnits != BaseUnits.Undefined && fromUnitInfo.BaseUnits == toUnitInfo.BaseUnits)
+        {
+            conversionExpression = quantityConversionExpression;
+            return true;
+        }
+
+        if (fromQuantityInfo.TryGetSIBaseUnit(out UnitInfo? sourceSI) && toQuantityInfo.TryGetSIBaseUnit(out UnitInfo? targetSI))
+        {
+            ConversionExpression fromUnitToTargetSI = quantityConversionExpression.Evaluate(fromUnitInfo.GetUnitConversionExpressionTo(sourceSI));
+            conversionExpression = targetSI.GetUnitConversionExpressionTo(toUnitInfo).Evaluate(fromUnitToTargetSI, reduceConstants);
+            return true;
+        }
+
+        IReadOnlyList<UnitInfo> fromQuantityUnits = fromQuantityInfo.UnitInfos;
+        var fromQuantityUnitsCount = fromQuantityUnits.Count;
+        for (var i = 0; i < fromQuantityUnitsCount; i++)
+        {
+            UnitInfo sourceUnit = fromQuantityUnits[i];
+            if (sourceUnit.BaseUnits == BaseUnits.Undefined || !toQuantityInfo.UnitInfos.TryGetUnitWithBase(sourceUnit.BaseUnits, out UnitInfo? matchingUnit))
+            {
+                continue;
+            }
+
+            ConversionExpression fromUnitToMatchingUnit = quantityConversionExpression.Evaluate(fromUnitInfo.GetUnitConversionExpressionTo(sourceUnit, false));
+            conversionExpression = matchingUnit.GetUnitConversionExpressionTo(toUnitInfo, false).Evaluate(fromUnitToMatchingUnit, true);
+            return true;
+        }
+
+        conversionExpression = null;
+        return false;
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/UnitConversionMapping.cs b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/UnitConversionMapping.cs
new file mode 100644
index 0000000000..4849e9c3a0
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConversions/UnitConversionMapping.cs
@@ -0,0 +1,47 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Diagnostics;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents the mapping-key used for converting between the units of two different quantities.
+/// </summary>
+[DebuggerDisplay("{FromUnitKey,nq} -> {ToUnitKey,nq}")]
+internal readonly record struct UnitConversionMapping
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitConversionMapping" /> struct with the specified source and target
+    ///     unit keys.
+    /// </summary>
+    /// <param name="FromUnitKey">The key representing the source unit for the conversion.</param>
+    /// <param name="ToUnitKey">The key representing the target unit for the conversion.</param>
+    public UnitConversionMapping(UnitKey FromUnitKey, UnitKey ToUnitKey)
+    {
+        this.FromUnitKey = FromUnitKey;
+        this.ToUnitKey = ToUnitKey;
+    }
+
+    public UnitKey FromUnitKey { get; }
+    public UnitKey ToUnitKey { get; }
+
+    /// <summary>
+    ///     Creates a new instance of <see cref="UnitConversionKey" /> using the specified units.
+    /// </summary>
+    /// <typeparam name="TSourceUnit">The type of the source units, which must be a struct and an enum</typeparam>
+    /// <typeparam name="TTargetUnit">The type of the target units, which must be a struct and an enum.</typeparam>
+    /// <param name="fromUnit">The unit of the quantity to convert from.</param>
+    /// <param name="toUnit">The unit to convert to.</param>
+    /// <returns>
+    ///     A new <see cref="UnitConversionMapping" /> representing the conversion from <paramref name="fromUnit" /> to
+    ///     <paramref name="toUnit" />.
+    /// </returns>
+    public static UnitConversionMapping Create<TSourceUnit, TTargetUnit>(TSourceUnit fromUnit, TTargetUnit toUnit)
+        where TSourceUnit : struct, Enum
+        where TTargetUnit : struct, Enum
+    {
+        return new UnitConversionMapping(UnitKey.ForUnit(fromUnit), UnitKey.ForUnit(toUnit));
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConverterBuildOptions.cs b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConverterBuildOptions.cs
new file mode 100644
index 0000000000..8331c07ea2
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/Builder/QuantityConverterBuildOptions.cs
@@ -0,0 +1,165 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Provides options for building a <see cref="UnitConverter" /> instance.
+/// </summary>
+/// <remarks>
+///     This class allows configuring various settings related to unit conversion, such as caching modes,
+///     constant reduction, and custom caching options for specific quantity types.
+/// </remarks>
+public sealed class QuantityConverterBuildOptions
+{
+    private readonly Dictionary<Type, ConversionCacheOptions> _customQuantityOptions = [];
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityConverterBuildOptions" /> class.
+    /// </summary>
+    /// <param name="freeze">Indicates whether the build options should be frozen, preventing further modifications.</param>
+    /// <param name="defaultCachingMode">Specifies the default caching mode for unit conversions.</param>
+    /// <param name="reduceConstants">Indicates whether constant reduction should be applied during unit conversions.</param>
+    public QuantityConverterBuildOptions(bool freeze = false, ConversionCachingMode defaultCachingMode = ConversionCachingMode.None,
+        bool reduceConstants = true)
+    {
+        Freeze = freeze;
+        DefaultCachingMode = defaultCachingMode;
+        ReduceConstants = reduceConstants;
+    }
+
+    /// <summary>
+    ///     Gets a value indicating whether the quantity converter is frozen, preventing any further modifications.
+    /// </summary>
+    public bool Freeze { get; private set; }
+
+    /// <summary>
+    ///     Gets the default caching mode for unit conversions.
+    /// </summary>
+    /// <value>
+    ///     The default caching mode, which determines how unit conversions are cached.
+    /// </value>
+    public ConversionCachingMode DefaultCachingMode { get; private set; }
+
+    /// <summary>
+    ///     Gets a value indicating whether constant values should be reduced during unit conversions.
+    /// </summary>
+    /// <remarks>
+    ///     When set to <c>true</c>, constant values in unit conversions are reduced to their simplest form.
+    ///     This can help improve performance and reduce memory usage.
+    /// </remarks>
+    public bool ReduceConstants { get; private set; }
+
+    internal IReadOnlyDictionary<Type, ConversionCacheOptions> CustomQuantityOptions
+    {
+        get => _customQuantityOptions;
+    }
+
+    internal QuantityConversionOptions? QuantityConversionOptions { get; private set; }
+
+#if OPTIONS_ACCEPTED
+// TODO add tests for  these
+    /// <summary>
+    ///     Enables or disables dynamic caching for unit conversions.
+    /// </summary>
+    /// <param name="dynamicCachingEnabled">If set to <c>true</c>, dynamic caching is enabled; otherwise, it is disabled.</param>
+    /// <returns>
+    ///     The current <see cref="QuantityConverterBuildOptions" /> instance with the updated dynamic
+    ///     caching setting.
+    /// </returns>
+    public QuantityConverterBuildOptions WithDynamicCachingEnabled(bool dynamicCachingEnabled = true)
+    {
+        Freeze = !dynamicCachingEnabled;
+        return this;
+    }
+
+    /// <summary>
+    ///     Sets the default caching mode for unit conversions.
+    /// </summary>
+    /// <param name="defaultCachingMode">The default caching mode to be used for unit conversions.</param>
+    /// <returns>
+    ///     The current <see cref="QuantityConverterBuildOptions" /> instance with the updated default
+    ///     caching mode.
+    /// </returns>
+    public QuantityConverterBuildOptions WithDefaultCachingMode(ConversionCachingMode defaultCachingMode)
+    {
+        DefaultCachingMode = defaultCachingMode;
+        return this;
+    }
+
+    /// <summary>
+    ///     Enables or disables the reduction of constants during unit conversions.
+    /// </summary>
+    /// <param name="reduceConstants">
+    ///     If set to <c>true</c>, constants will be reduced during conversions; otherwise, they will
+    ///     not be reduced.
+    /// </param>
+    /// <returns>
+    ///     The current <see cref="QuantityConverterBuildOptions" /> instance with the updated constant
+    ///     reduction setting.
+    /// </returns>
+    public QuantityConverterBuildOptions WithConstantsReduction(bool reduceConstants = true)
+    {
+        ReduceConstants = reduceConstants;
+        return this;
+    }
+#endif
+
+    /// <summary>
+    ///     Configures custom caching options for a specific quantity type.
+    /// </summary>
+    /// <typeparam name="TQuantity">The type of the quantity for which to set custom caching options.</typeparam>
+    /// <param name="quantityCacheOptions">The caching options to be applied to the specified quantity type.</param>
+    /// <returns>
+    ///     The current <see cref="QuantityConverterBuildOptions" /> instance with the updated custom
+    ///     caching options.
+    /// </returns>
+    public QuantityConverterBuildOptions WithCustomCachingOptions<TQuantity>(ConversionCacheOptions quantityCacheOptions)
+        where TQuantity : IQuantity
+    {
+        _customQuantityOptions.Add(typeof(TQuantity), quantityCacheOptions);
+        return this;
+    }
+
+    /// <summary>
+    ///     Configures the implicit conversion options for the <see cref="QuantityConverterBuildOptions" /> instance.
+    /// </summary>
+    /// <param name="quantityConversionOptions">
+    ///     The <see cref="QuantityConversionOptions" /> instance that specifies the implicit conversion settings.
+    /// </param>
+    /// <returns>
+    ///     The current <see cref="QuantityConverterBuildOptions" /> instance with the updated implicit conversion options.
+    /// </returns>
+    /// <remarks>
+    ///     This method allows setting custom implicit conversion rules and units to be used during quantity conversions.
+    /// </remarks>
+    public QuantityConverterBuildOptions WithImplicitConversionOptions(QuantityConversionOptions quantityConversionOptions)
+    {
+        QuantityConversionOptions = quantityConversionOptions;
+        return this;
+    }
+
+    /// <summary>
+    ///     Configures implicit conversion options for the <see cref="QuantityConverterBuildOptions" />.
+    /// </summary>
+    /// <param name="implicitConversions">
+    ///     An action to configure the <see cref="QuantityConversionOptions" />.
+    /// </param>
+    /// <returns>
+    ///     The current instance of <see cref="QuantityConverterBuildOptions" /> with the updated implicit conversion options.
+    /// </returns>
+    /// <remarks>
+    ///     This method allows you to specify custom implicit conversions between different quantities and units.
+    ///     It initializes the <see cref="QuantityConversionOptions" /> if it is not already set and applies the provided
+    ///     configuration action to it.
+    /// </remarks>
+    public QuantityConverterBuildOptions WithImplicitConversionOptions(Action<QuantityConversionOptions> implicitConversions)
+    {
+        QuantityConversionOptions ??= new QuantityConversionOptions();
+        implicitConversions(QuantityConversionOptions);
+        return this;
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/Builder/UnitConversions/UnitConversionsBuilderExtensions.cs b/UnitsNet/CustomCode/QuantityConverters/Builder/UnitConversions/UnitConversionsBuilderExtensions.cs
new file mode 100644
index 0000000000..050350187d
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/Builder/UnitConversions/UnitConversionsBuilderExtensions.cs
@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnitsNet;
+
+internal static class UnitConversionsBuilderExtensions
+{
+    /// <summary>
+    /// Retrieves a collection of conversion expressions for the specified quantities.
+    /// </summary>
+    /// <param name="quantities">The collection of quantities for which to get conversion expressions.</param>
+    /// <param name="cachingMode">The caching mode to use for the conversion expressions.</param>
+    /// <param name="reduceConstants">A boolean value indicating whether to reduce constants in the conversion expressions. Defaults to true.</param>
+    /// <returns>An enumerable collection of key-value pairs where the key is a <see cref="UnitConversionKey"/> and the value is a <see cref="ConvertValueDelegate"/> representing the conversion expression.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when an invalid caching mode is specified.</exception>
+    public static IEnumerable<KeyValuePair<UnitConversionKey, ConvertValueDelegate>> GetUnitConversionFunctions(this IEnumerable<QuantityInfo> quantities, ConversionCachingMode cachingMode, bool reduceConstants = true)
+    {
+        return cachingMode switch
+        {
+            ConversionCachingMode.None => [],
+            ConversionCachingMode.BaseOnly => quantities.SelectMany(GetBaseConversions),
+            ConversionCachingMode.All => quantities.SelectMany(x => GetExpandedConversions(x, reduceConstants)),
+            _ => throw new ArgumentOutOfRangeException()
+        };
+    }
+
+    /// <summary>
+    /// Retrieves the conversion expressions for the specified quantities, considering the provided caching mode, 
+    /// constant reduction option, and custom quantity options.
+    /// </summary>
+    /// <param name="quantities">The collection of quantity information objects.</param>
+    /// <param name="defaultCachingMode">The default caching mode to use if no custom options are specified.</param>
+    /// <param name="defaultConstantsReduction">Indicates whether to reduce constants by default.</param>
+    /// <param name="customQuantityOptions">A dictionary of custom quantity options, keyed by quantity type.</param>
+    /// <returns>An enumerable of key-value pairs, where the key is a <see cref="UnitConversionKey"/> and the value is a <see cref="ConvertValueDelegate"/>.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when an invalid caching mode is encountered.</exception>
+    public static IEnumerable<KeyValuePair<UnitConversionKey, ConvertValueDelegate>> GetUnitConversionFunctions(this IEnumerable<QuantityInfo> quantities, ConversionCachingMode defaultCachingMode, bool defaultConstantsReduction,
+        IReadOnlyDictionary<Type, ConversionCacheOptions> customQuantityOptions)
+    {
+        if (customQuantityOptions.Count == 0)
+        {
+            return quantities.GetUnitConversionFunctions(defaultCachingMode, defaultConstantsReduction);
+        }
+
+        return quantities.SelectMany(quantityInfo =>
+            customQuantityOptions.TryGetValue(quantityInfo.QuantityType, out ConversionCacheOptions? customCacheOptions)
+                ? customCacheOptions.CachingMode switch
+                {
+                    ConversionCachingMode.None => [],
+                    ConversionCachingMode.BaseOnly => GetBaseConversions(quantityInfo),
+                    ConversionCachingMode.All => GetExpandedConversions(quantityInfo, customCacheOptions.ReduceConstants),
+                    _ => throw new ArgumentOutOfRangeException()
+                }
+                : defaultCachingMode switch
+                {
+                    ConversionCachingMode.None => [],
+                    ConversionCachingMode.BaseOnly => GetBaseConversions(quantityInfo),
+                    ConversionCachingMode.All => GetExpandedConversions(quantityInfo, defaultConstantsReduction),
+                    _ => throw new ArgumentOutOfRangeException()
+                });
+    }
+
+    private static IEnumerable<KeyValuePair<UnitConversionKey, ConvertValueDelegate>> GetExpandedConversions(QuantityInfo quantityInfo, bool reduceConstants)
+    {
+        UnitInfo baseUnit = quantityInfo.BaseUnitInfo;
+        UnitKey baseUnitKey = baseUnit.UnitKey;
+        IReadOnlyList<UnitInfo> unitInfos = quantityInfo.UnitInfos;
+        var nbUnits = unitInfos.Count;
+        for (var i = 0; i < nbUnits; i++)
+        {
+            UnitInfo fromUnit = unitInfos[i];
+            if (fromUnit == baseUnit)
+            {
+                foreach (KeyValuePair<UnitConversionKey, ConvertValueDelegate> keyValuePair in GetConversionsWithBase(quantityInfo, baseUnit, baseUnitKey))
+                {
+                    yield return keyValuePair;
+                }
+            }
+            else
+            {
+                UnitKey fromUnitKey = fromUnit.UnitKey;
+                // yield return new UnitConversionMapping(UnitConversionKey.ToSelf(fromUnitKey), value => value);
+                for (var p = 0; p < nbUnits; p++)
+                {
+                    if (i == p) continue;
+                    UnitInfo toUnit = unitInfos[p];
+                    if (toUnit == baseUnit)
+                    {
+                        continue;
+                    }
+
+                    var conversionKey = UnitConversionKey.Create(fromUnitKey, toUnit.UnitKey);
+                    ConversionExpression conversion = toUnit.ConversionFromBase.Evaluate(fromUnit.ConversionToBase, reduceConstants);
+                    yield return new KeyValuePair<UnitConversionKey, ConvertValueDelegate>(conversionKey, conversion);
+                }
+            }
+        }
+    }
+
+    private static IEnumerable<KeyValuePair<UnitConversionKey, ConvertValueDelegate>> GetBaseConversions(QuantityInfo quantityInfo)
+    {
+        return GetConversionsWithBase(quantityInfo, quantityInfo.BaseUnitInfo, quantityInfo.BaseUnitInfo.UnitKey);
+    }
+
+    private static IEnumerable<KeyValuePair<UnitConversionKey, ConvertValueDelegate>> GetConversionsWithBase(QuantityInfo quantityInfo, UnitInfo baseUnit, UnitKey baseUnitKey)
+    {
+        IReadOnlyList<UnitInfo> unitInfos = quantityInfo.UnitInfos;
+        var nbUnits = unitInfos.Count;
+        for (var i = 0; i < nbUnits; i++)
+        {
+            UnitInfo unit = unitInfos[i];
+            if (unit == baseUnit)
+            {
+                continue; // yield return new UnitConversionMapping(UnitConversionKey.ToSelf(baseUnitKey), value => value);
+            }
+
+            UnitKey unitKey = unit.UnitKey;
+            yield return new KeyValuePair<UnitConversionKey, ConvertValueDelegate>(UnitConversionKey.Create(baseUnitKey, unitKey), unit.ConversionFromBase);
+            yield return new KeyValuePair<UnitConversionKey, ConvertValueDelegate>(UnitConversionKey.Create(unitKey, baseUnitKey), unit.ConversionToBase);
+        }
+    }
+    
+    /// <summary>
+    ///     Gets the conversion expression between two units.
+    /// </summary>
+    /// <param name="fromUnitInfo">The unit information of the source unit.</param>
+    /// <param name="toUnitInfo">The unit information of the target unit.</param>
+    /// <param name="reduceConstants">
+    ///     Indicates whether to reduce constants in the conversion expression. Defaults to
+    ///     <c>true</c>.
+    /// </param>
+    /// <returns>A <see cref="ConversionExpression" /> representing the conversion from the source unit to the target unit.</returns>
+    /// <remarks>
+    ///     If the source unit is the base unit, the conversion from the base unit to the target unit is returned.
+    ///     If the target unit is the base unit, the conversion from the source unit to the base unit is returned.
+    ///     Otherwise, the conversion is evaluated using the conversion expressions from the source unit to the base unit and
+    ///     from the base unit to the target unit.
+    /// </remarks>
+    internal static ConversionExpression GetUnitConversionExpressionTo(this UnitInfo fromUnitInfo, UnitInfo toUnitInfo, bool reduceConstants = true)
+    {
+        // if we're here, then units are very likely to be different
+        UnitInfo baseUnit = fromUnitInfo.QuantityInfo.BaseUnitInfo;
+        if (fromUnitInfo == baseUnit)
+        {
+            return toUnitInfo.ConversionFromBase;
+        }
+
+        if (toUnitInfo == baseUnit)
+        {
+            return fromUnitInfo.ConversionToBase;
+        }
+
+        return toUnitInfo.ConversionFromBase.Evaluate(fromUnitInfo.ConversionToBase, reduceConstants);
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/DynamicQuantityConverter.cs b/UnitsNet/CustomCode/QuantityConverters/DynamicQuantityConverter.cs
new file mode 100644
index 0000000000..001f78e2cd
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/DynamicQuantityConverter.cs
@@ -0,0 +1,456 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Collections.Concurrent;
+
+namespace UnitsNet;
+
+internal sealed class DynamicQuantityConverter : UnitConverter
+{
+    private readonly ConcurrentDictionary<UnitConversionKey, ConvertValueDelegate> _unitConversions;
+    private readonly ConcurrentDictionary<QuantityConversionKey, QuantityConversionFunction> _quantityConversions;
+    private readonly Func<UnitConversionKey, ConvertValueDelegate> _unitConversionExpressionFactory;
+    private readonly bool _reduceConstants;
+
+    public DynamicQuantityConverter(UnitParser unitParser,
+        IEnumerable<QuantityConversion> quantityConversions,
+        IEnumerable<KeyValuePair<UnitConversionKey, ConvertValueDelegate>> unitConversionFunctions,
+        IEnumerable<KeyValuePair<QuantityConversionKey, QuantityConversionFunction>> quantityConversionFunctions, bool reduceConstants)
+        : base(unitParser, quantityConversions)
+    {
+        _reduceConstants = reduceConstants;
+        _unitConversions = new ConcurrentDictionary<UnitConversionKey, ConvertValueDelegate>(unitConversionFunctions);
+        _quantityConversions = new ConcurrentDictionary<QuantityConversionKey, QuantityConversionFunction>(quantityConversionFunctions);
+        _unitConversionExpressionFactory = GetConversionExpression;
+    }
+
+    public override bool TryConvertValue<TUnit>(QuantityValue value, TUnit fromUnit, TUnit toUnit, out QuantityValue convertedValue)
+    {
+        return TryConvertValue(value, UnitConversionKey.Create(fromUnit, toUnit), out convertedValue);
+    }
+
+    public override bool TryConvertValue(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey, out QuantityValue convertedValue)
+    {
+        return fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType
+            ? TryConvertValue(value, UnitConversionKey.Create(fromUnitKey, toUnitKey), out convertedValue)
+            : TryConvertValueFromOneQuantityToAnother(value, fromUnitKey, toUnitKey, out convertedValue);
+    }
+
+    private bool TryConvertValue(QuantityValue value, UnitConversionKey conversionKey, out QuantityValue convertedValue)
+    {
+        if (conversionKey.HasSameUnits)
+        {
+            convertedValue = value;
+            return true;
+        }
+
+        if (_unitConversions.TryGetValue(conversionKey, out ConvertValueDelegate? cachedConversion))
+        {
+            convertedValue = cachedConversion(value);
+            return true;
+        }
+
+        if (TryGetUnitInfo(conversionKey.FromUnitKey, out UnitInfo? fromUnitInfo) &&
+            TryGetUnitInfo(new UnitKey(conversionKey.FromUnitKey.UnitEnumType, conversionKey.ToUnitValue), out UnitInfo? toUnitInfo))
+        {
+            cachedConversion = _unitConversions.GetOrAdd(conversionKey, fromUnitInfo.GetUnitConversionExpressionTo(toUnitInfo, _reduceConstants));
+            convertedValue = cachedConversion(value);
+            return true;
+        }
+
+        convertedValue = default;
+        return false;
+    }
+
+    private bool TryConvertValueFromOneQuantityToAnother(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey, out QuantityValue convertedValue)
+    {
+        var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitKey.UnitEnumType);
+        if (_quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction conversionFunction))
+        {
+            return TryConvertValue(conversionFunction.Convert(value), new UnitConversionKey(conversionFunction.TargetUnit, toUnitKey.UnitEnumValue),
+                out convertedValue);
+        }
+
+        if (TryGetUnitInfo(fromUnitKey, out UnitInfo? fromUnitInfo) && TryGetUnitInfo(toUnitKey, out UnitInfo? toUnitInfo))
+        {
+            return TryConvertValueFromOneQuantityToAnother(value, fromUnitInfo, toUnitInfo, out convertedValue);
+        }
+
+        convertedValue = default;
+        return false;
+    }
+
+    protected override bool TryConvertValueInternal(QuantityValue value, UnitInfo fromUnitInfo, UnitInfo toUnitInfo, out QuantityValue convertedValue)
+    {
+        if (fromUnitInfo == toUnitInfo)
+        {
+            // TODO see about this: the only possible route in is from TryConvertValueByName
+            convertedValue = value;
+            return true;
+        }
+
+        UnitKey fromUnitKey = fromUnitInfo.UnitKey;
+        UnitKey toUnitKey = toUnitInfo.UnitKey;
+        if (fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType)
+        {
+            ConvertValueDelegate conversionDelegate = GetOrAdd(UnitConversionKey.Create(fromUnitKey, toUnitKey), fromUnitInfo, toUnitInfo);
+            convertedValue = conversionDelegate(value);
+            return true;
+        }
+
+        var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitKey.UnitEnumType);
+        if (!_quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction conversionFunction))
+        {
+            if (ConversionDefined(fromUnitInfo.QuantityInfo, toUnitInfo.QuantityInfo) &&
+                fromUnitInfo.TryGetQuantityConversionExpressionTo(toUnitInfo, _reduceConstants, out ConversionExpression? conversionExpression))
+            {
+                conversionFunction = _quantityConversions.GetOrAdd(defaultConversionKey, new QuantityConversionFunction(conversionExpression, toUnitKey));
+            }
+            else
+            {
+                convertedValue = default;
+                return false;
+            }
+        }
+
+        if (conversionFunction.TargetUnit == toUnitKey)
+        {
+            convertedValue = conversionFunction.Convert(value);
+            return true;
+        }
+        
+        ConvertValueDelegate targetToUnitConversion = GetOrAddConversionTo(UnitConversionKey.Create(conversionFunction.TargetUnit, toUnitKey), toUnitInfo);
+        convertedValue = targetToUnitConversion(conversionFunction.Convert(value));
+        return true;
+    }
+
+    public override QuantityValue ConvertValue<TUnit>(QuantityValue value, TUnit fromUnit, TUnit toUnit)
+    {
+        return ConvertValue(value, UnitConversionKey.Create(fromUnit, toUnit));
+    }
+
+    public override QuantityValue ConvertValue(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey)
+    {
+        return fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType
+            ? ConvertValue(value, UnitConversionKey.Create(fromUnitKey, toUnitKey))
+            : ConvertValueFromOneQuantityToAnother(value, fromUnitKey, toUnitKey);
+    }
+
+    private QuantityValue ConvertValue(QuantityValue value, UnitConversionKey conversionKey)
+    {
+        if (conversionKey.HasSameUnits)
+        {
+            return value;
+        }
+        
+        ConvertValueDelegate conversion = _unitConversions.GetOrAdd(conversionKey, _unitConversionExpressionFactory);
+        return conversion(value);
+    }
+
+    private QuantityValue ConvertValueFromOneQuantityToAnother(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey)
+    {
+        var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitKey.UnitEnumType);
+        if (_quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction defaultConversion))
+        {
+            return defaultConversion.TargetUnit.UnitEnumValue == toUnitKey.UnitEnumValue
+                ? defaultConversion.Convert(value)
+                : ConvertValue(defaultConversion.Convert(value), UnitConversionKey.Create(defaultConversion.TargetUnit, toUnitKey));
+        }
+
+        UnitInfo fromUnitInfo = GetUnitInfo(fromUnitKey);
+        UnitInfo toUnitInfo = GetUnitInfo(toUnitKey);
+
+        ConvertValueDelegate conversionExpression = GetConversionFromOneQuantityToAnother(fromUnitInfo, toUnitInfo, _reduceConstants);
+        QuantityValue convertedValue = conversionExpression(value);
+        _quantityConversions.TryAdd(defaultConversionKey, new QuantityConversionFunction(conversionExpression, toUnitKey));
+        return convertedValue;
+    }
+
+    protected override QuantityValue ConvertValueInternal(QuantityValue value, UnitInfo fromUnitInfo, UnitInfo toUnitInfo)
+    {
+        if (fromUnitInfo == toUnitInfo)
+        {
+            return value;
+        }
+
+        UnitKey fromUnitKey = fromUnitInfo.UnitKey;
+        UnitKey toUnitKey = toUnitInfo.UnitKey;
+        if (fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType)
+        {
+            ConvertValueDelegate conversionDelegate = GetOrAdd(UnitConversionKey.Create(fromUnitKey, toUnitKey), fromUnitInfo, toUnitInfo);
+            return conversionDelegate(value);
+        }
+
+        QuantityConversionFunction conversionFunction = GetOrAdd(new QuantityConversionKey(fromUnitKey, toUnitKey.UnitEnumType), fromUnitInfo, toUnitInfo);
+        if (conversionFunction.TargetUnit.UnitEnumValue == toUnitKey.UnitEnumValue)
+        {
+            return conversionFunction.Convert(value);
+        }
+        
+        ConvertValueDelegate targetToUnitConversion = GetOrAddConversionTo(UnitConversionKey.Create(conversionFunction.TargetUnit, toUnitKey), toUnitInfo);
+        return targetToUnitConversion(conversionFunction.Convert(value));
+    }
+
+    public override ConvertValueDelegate GetConversionFunction(UnitKey fromUnitKey, UnitKey toUnitKey)
+    {
+        if (fromUnitKey == toUnitKey)
+        {
+            return value => value;
+        }
+        
+        if (fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType)
+        {
+            return _unitConversions.GetOrAdd(UnitConversionKey.Create(fromUnitKey, toUnitKey), _unitConversionExpressionFactory);
+        }
+
+        UnitInfo fromUnitInfo = GetUnitInfo(fromUnitKey);
+        UnitInfo toUnitInfo = GetUnitInfo(toUnitKey);
+        var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitInfo.QuantityInfo.UnitType);
+        if (!_quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction defaultConversion))
+        {
+            return GetConversionFromOneQuantityToAnother(fromUnitInfo, toUnitInfo);
+        }
+
+        if (defaultConversion.TargetUnit == toUnitKey)
+        {
+            return defaultConversion.Convert;
+        }
+
+        // TODO should we be caching the result? (GetOrAddConversionTo)
+        // TODO the resulting expression might not be fully reduced if _reduceConstants is false
+        if(!_unitConversions.TryGetValue(UnitConversionKey.Create(defaultConversion.TargetUnit, toUnitKey), out ConvertValueDelegate? conversionToTarget))
+        {
+            conversionToTarget = GetUnitInfo(defaultConversion.TargetUnit).GetUnitConversionExpressionTo(toUnitInfo);
+        }
+        
+        return value => conversionToTarget(defaultConversion.Convert(value));
+    }
+
+    public override bool TryGetConversionFunction(UnitKey fromUnitKey, UnitKey toUnitKey, [NotNullWhen(true)] out ConvertValueDelegate? conversionFunction)
+    {
+        if (fromUnitKey == toUnitKey)
+        {
+            conversionFunction = value => value;
+            return true;
+        }
+
+        if (fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType)
+        {
+            var conversionKey = UnitConversionKey.Create(fromUnitKey, toUnitKey);
+            if (_unitConversions.TryGetValue(conversionKey, out conversionFunction))
+            {
+                return true;
+            }
+
+            if (TryGetUnitInfo(fromUnitKey, out UnitInfo? fromUnitInfo) && TryGetUnitInfo(toUnitKey, out UnitInfo? toUnitInfo))
+            {
+                conversionFunction = _unitConversions.GetOrAdd(conversionKey, fromUnitInfo.GetUnitConversionExpressionTo(toUnitInfo, _reduceConstants));
+                return true;
+            }
+        }
+        else if (TryGetUnitInfo(fromUnitKey, out UnitInfo? fromUnitInfo) && TryGetUnitInfo(toUnitKey, out UnitInfo? toUnitInfo))
+        {
+            var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitInfo.QuantityInfo.UnitType);
+            if (!_quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction defaultConversion))
+            {
+                return TryGetConversionFromOneQuantityToAnother(fromUnitInfo, toUnitInfo, out conversionFunction);
+            }
+
+            if (defaultConversion.TargetUnit == toUnitKey)
+            {
+                conversionFunction = defaultConversion.Convert;
+                return true;
+            }
+            
+            // TODO should we be caching the result? (GetOrAddConversionTo)
+            // TODO the resulting expression might not be fully reduced if _reduceConstants is false
+            if(!_unitConversions.TryGetValue(UnitConversionKey.Create(defaultConversion.TargetUnit, toUnitKey), out ConvertValueDelegate? conversionToTarget))
+            {
+                conversionToTarget = GetUnitInfo(defaultConversion.TargetUnit).GetUnitConversionExpressionTo(toUnitInfo);
+            }
+            
+            conversionFunction = value => conversionToTarget(defaultConversion.Convert(value));
+            return true;
+        }
+
+        conversionFunction = null;
+        return false;
+    }
+
+    public override bool TryConvertTo<TSourceUnit, TTargetQuantity, TTargetUnit>(QuantityValue value, TSourceUnit fromUnit,
+        QuantityInfo<TTargetQuantity, TTargetUnit> targetQuantityInfo,
+        [NotNullWhen(true)] out TTargetQuantity? convertedQuantity)
+        where TTargetQuantity : default
+    {
+        var conversionKey = QuantityConversionKey.Create<TSourceUnit, TTargetUnit>(fromUnit);
+        if (_quantityConversions.TryGetValue(conversionKey, out QuantityConversionFunction conversionFunction))
+        {
+            convertedQuantity = targetQuantityInfo.From(conversionFunction.Convert(value), conversionFunction.TargetUnit.ToUnit<TTargetUnit>());
+            return true;
+        }
+
+        if (!TryGetUnitInfo(conversionKey.FromUnit, out UnitInfo? fromUnitInfo))
+        {
+            convertedQuantity = default;
+            return false;
+        }
+
+        if (ConversionDefined(fromUnitInfo.QuantityInfo, targetQuantityInfo) &&
+            targetQuantityInfo.TryGetQuantityConversionFrom(fromUnitInfo, _reduceConstants, out QuantityConversionFunction conversionConstructed))
+        {
+            conversionFunction = _quantityConversions.GetOrAdd(conversionKey, conversionConstructed);
+            convertedQuantity = targetQuantityInfo.From(conversionFunction.Convert(value), conversionFunction.TargetUnit.ToUnit<TTargetUnit>());
+            return true;
+        }
+
+        convertedQuantity = default;
+        return false;
+    }
+
+    public override bool TryConvertTo(QuantityValue value, UnitKey fromUnitKey, QuantityInfo targetQuantityInfo,
+        [NotNullWhen(true)] out IQuantity? convertedQuantity)
+    {
+        var conversionKey = new QuantityConversionKey(fromUnitKey, targetQuantityInfo.UnitType);
+        if (_quantityConversions.TryGetValue(conversionKey, out QuantityConversionFunction conversionFunction))
+        {
+            convertedQuantity = targetQuantityInfo.From(conversionFunction.Convert(value), conversionFunction.TargetUnit);
+            return true;
+        }
+
+        if (!TryGetUnitInfo(conversionKey.FromUnit, out UnitInfo? fromUnitInfo))
+        {
+            convertedQuantity = null;
+            return false;
+        }
+
+        if (ConversionDefined(fromUnitInfo.QuantityInfo, targetQuantityInfo) &&
+            targetQuantityInfo.TryGetQuantityConversionFrom(fromUnitInfo, _reduceConstants, out QuantityConversionFunction conversionConstructed))
+        {
+            conversionFunction = _quantityConversions.GetOrAdd(conversionKey, conversionConstructed);
+            convertedQuantity = targetQuantityInfo.From(conversionFunction.Convert(value), conversionFunction.TargetUnit);
+            return true;
+        }
+
+        convertedQuantity = null;
+        return false;
+    }
+
+    public override TTargetQuantity ConvertTo<TSourceUnit, TTargetQuantity, TTargetUnit>(QuantityValue value, TSourceUnit fromUnit,
+        QuantityInfo<TTargetQuantity, TTargetUnit> targetQuantityInfo)
+    {
+        var conversionKey = QuantityConversionKey.Create<TSourceUnit, TTargetUnit>(fromUnit);
+        QuantityConversionFunction conversionFunction = GetOrAdd(conversionKey, targetQuantityInfo);
+        return targetQuantityInfo.From(conversionFunction.Convert(value), conversionFunction.TargetUnit.ToUnit<TTargetUnit>());
+    }
+
+    public override IQuantity ConvertTo(QuantityValue value, UnitKey fromUnitKey, QuantityInfo targetQuantityInfo)
+    {
+        var conversionKey = new QuantityConversionKey(fromUnitKey, targetQuantityInfo.UnitType);
+        QuantityConversionFunction conversionFunction = GetOrAdd(conversionKey, targetQuantityInfo);
+        return targetQuantityInfo.From(conversionFunction.Convert(value), conversionFunction.TargetUnit);
+    }
+    
+    private ConvertValueDelegate GetConversionExpression(UnitConversionKey conversionKey)
+    {
+        UnitInfo fromUnitInfo = GetUnitInfo(conversionKey.FromUnitKey);
+        UnitInfo toUnitInfo = GetUnitInfo(new UnitKey(conversionKey.FromUnitKey.UnitEnumType, conversionKey.ToUnitValue));
+        return fromUnitInfo.GetUnitConversionExpressionTo(toUnitInfo, _reduceConstants);
+    }
+    
+    private ConvertValueDelegate GetOrAdd(UnitConversionKey conversionKey, UnitInfo fromUnitInfo, UnitInfo toUnitInfo)
+    {
+#if NET
+        return _unitConversions.GetOrAdd(conversionKey, CreateConversionExpressionForUnits, (fromUnitInfo, toUnitInfo, _reduceConstants));    
+        static ConvertValueDelegate CreateConversionExpressionForUnits(UnitConversionKey key, ValueTuple<UnitInfo, UnitInfo, bool> conversion)
+        {
+            return conversion.Item1.GetUnitConversionExpressionTo(conversion.Item2, conversion.Item3);
+        }
+#else
+        // intentionally not using the factory overload here, as it causes an extra allocation for the Func
+        return _unitConversions.TryGetValue(conversionKey, out ConvertValueDelegate? conversionFunction)
+            ? conversionFunction
+            : _unitConversions.GetOrAdd(conversionKey, fromUnitInfo.GetUnitConversionExpressionTo(toUnitInfo, _reduceConstants));
+#endif
+    }
+
+    private ConvertValueDelegate GetOrAddConversionTo(UnitConversionKey conversionKey, UnitInfo toUnitInfo)
+    {
+#if NET
+        return _unitConversions.GetOrAdd(conversionKey, CreateConversionExpressionForUnit, (this, toUnitInfo));
+        static ConvertValueDelegate CreateConversionExpressionForUnit(UnitConversionKey key, ValueTuple<DynamicQuantityConverter, UnitInfo> conversion)
+        {
+            DynamicQuantityConverter converter = conversion.Item1;
+            UnitInfo fromUnitInfo = converter.GetUnitInfo(key.FromUnitKey);
+            UnitInfo toUnitInfo = conversion.Item2;
+            return fromUnitInfo.GetUnitConversionExpressionTo(toUnitInfo, converter._reduceConstants);
+        }
+#else
+        // intentionally not using the factory overload here, as it causes an extra allocation for the Func
+        if (!_unitConversions.TryGetValue(conversionKey, out ConvertValueDelegate? targetToUnitConversion))
+        {
+            UnitInfo fromUnitInfo = GetUnitInfo(conversionKey.FromUnitKey);
+            targetToUnitConversion = _unitConversions.GetOrAdd(conversionKey, fromUnitInfo.GetUnitConversionExpressionTo(toUnitInfo, _reduceConstants));
+        }
+        
+        return targetToUnitConversion;
+#endif
+    }
+
+    private QuantityConversionFunction GetOrAdd(QuantityConversionKey conversionKey, UnitInfo fromUnitInfo, UnitInfo toUnitInfo)
+    {
+#if NET
+        return _quantityConversions.GetOrAdd(conversionKey, CreateConversionExpressionForUnits, (fromUnitInfo, toUnitInfo, this));    
+        static QuantityConversionFunction CreateConversionExpressionForUnits(QuantityConversionKey key, ValueTuple<UnitInfo, UnitInfo, DynamicQuantityConverter> conversion)
+        {
+            UnitInfo fromUnitInfo = conversion.Item1;
+            UnitInfo toUnitInfo = conversion.Item2;
+            DynamicQuantityConverter converter = conversion.Item3;
+            ConversionExpression conversionExpression = converter.GetConversionFromOneQuantityToAnother(fromUnitInfo, toUnitInfo, converter._reduceConstants);
+            return new QuantityConversionFunction(conversionExpression, toUnitInfo.UnitKey);
+        }
+#else
+        // intentionally not using the factory overload here, as it causes an extra allocation for the Func
+        if (_quantityConversions.TryGetValue(conversionKey, out QuantityConversionFunction conversionFunction))
+        {
+            return conversionFunction;
+        }
+
+        ConversionExpression conversionExpression = GetConversionFromOneQuantityToAnother(fromUnitInfo, toUnitInfo, _reduceConstants);
+        return _quantityConversions.GetOrAdd(conversionKey, new QuantityConversionFunction(conversionExpression, toUnitInfo.UnitKey));
+#endif
+    }
+
+    private QuantityConversionFunction GetOrAdd(QuantityConversionKey conversionKey, QuantityInfo targetQuantityInfo)
+    {
+#if NET
+        return _quantityConversions.GetOrAdd(conversionKey, CreateConversionFunction, (this, targetQuantityInfo));
+        static QuantityConversionFunction CreateConversionFunction(QuantityConversionKey key, ValueTuple<DynamicQuantityConverter, QuantityInfo> conversion)
+        {
+            DynamicQuantityConverter converter = conversion.Item1;
+            QuantityInfo targetQuantityInfo = conversion.Item2;
+            UnitInfo fromUnitInfo = converter.GetUnitInfo(key.FromUnit);
+            if (!converter.ConversionDefined(fromUnitInfo.QuantityInfo, targetQuantityInfo))
+            {
+                throw InvalidConversionException.CreateImplicitConversionException(fromUnitInfo.QuantityInfo, targetQuantityInfo);
+            }
+            
+            return targetQuantityInfo.GetQuantityConversionFrom(fromUnitInfo, converter._reduceConstants);
+        }
+#else
+        // intentionally not using the factory overload here, as it causes an extra allocation for the Func
+        if (_quantityConversions.TryGetValue(conversionKey, out QuantityConversionFunction existingConversion))
+        {
+            return existingConversion;
+        }
+
+        UnitInfo fromUnitInfo = GetUnitInfo(conversionKey.FromUnit);
+        if (!ConversionDefined(fromUnitInfo.QuantityInfo, targetQuantityInfo))
+        {
+            throw InvalidConversionException.CreateImplicitConversionException(fromUnitInfo.QuantityInfo, targetQuantityInfo);
+        }
+        
+        QuantityConversionFunction conversionFunction = targetQuantityInfo.GetQuantityConversionFrom(fromUnitInfo, _reduceConstants);
+        return _quantityConversions.GetOrAdd(conversionKey, conversionFunction);
+#endif
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/FrozenQuantityConverter.cs b/UnitsNet/CustomCode/QuantityConverters/FrozenQuantityConverter.cs
new file mode 100644
index 0000000000..91cc179507
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/FrozenQuantityConverter.cs
@@ -0,0 +1,330 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+#if NET
+using System.Collections.Frozen;
+#else
+using System.Linq;
+#endif
+
+namespace UnitsNet;
+
+internal sealed class FrozenQuantityConverter : UnitConverter
+{
+#if NET
+    private readonly FrozenDictionary<UnitConversionKey, ConvertValueDelegate> _unitConversions;
+    private readonly FrozenDictionary<QuantityConversionKey, QuantityConversionFunction> _quantityConversions;
+#else
+    private readonly Dictionary<UnitConversionKey, ConvertValueDelegate> _unitConversions;
+    private readonly Dictionary<QuantityConversionKey, QuantityConversionFunction> _quantityConversions;
+#endif
+
+    public FrozenQuantityConverter(UnitParser unitParser,
+        IEnumerable<QuantityConversion> quantityConversions,
+        IEnumerable<KeyValuePair<UnitConversionKey, ConvertValueDelegate>> unitConversionFunctions,
+        IEnumerable<KeyValuePair<QuantityConversionKey, QuantityConversionFunction>> quantityConversionFunctions)
+        : base(unitParser, quantityConversions)
+    {
+#if NET
+        _unitConversions = unitConversionFunctions.ToFrozenDictionary();
+        _quantityConversions = quantityConversionFunctions.ToFrozenDictionary();
+#else
+        _unitConversions = unitConversionFunctions.ToDictionary(pair => pair.Key, pair => pair.Value);
+        _quantityConversions = quantityConversionFunctions.ToDictionary(pair => pair.Key, pair => pair.Value);
+#endif
+    }
+
+    public override bool TryConvertValue<TUnit>(QuantityValue value, TUnit fromUnit, TUnit toUnit, out QuantityValue convertedValue)
+    {
+        return TryConvertValue(value, UnitConversionKey.Create(fromUnit, toUnit), out convertedValue);
+    }
+
+    public override bool TryConvertValue(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey, out QuantityValue convertedValue)
+    {
+        return fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType
+            ? TryConvertValue(value, UnitConversionKey.Create(fromUnitKey, toUnitKey), out convertedValue)
+            : TryConvertValueFromOneQuantityToAnother(value, fromUnitKey, toUnitKey, out convertedValue);
+    }
+
+    private bool TryConvertValue(QuantityValue value, UnitConversionKey conversionKey, out QuantityValue convertedValue)
+    {
+        if (conversionKey.HasSameUnits)
+        {
+            convertedValue = value;
+            return true;
+        }
+
+        if (_unitConversions.TryGetValue(conversionKey, out ConvertValueDelegate? cachedConversion))
+        {
+            convertedValue = cachedConversion(value);
+            return true;
+        }
+
+        if (TryGetUnitInfo(conversionKey.FromUnitKey, out UnitInfo? fromUnitInfo) &&
+            TryGetUnitInfo(new UnitKey(conversionKey.FromUnitKey.UnitEnumType, conversionKey.ToUnitValue), out UnitInfo? toUnitInfo))
+        {
+            convertedValue = toUnitInfo.GetValueFrom(value, fromUnitInfo);
+            return true;
+        }
+
+        convertedValue = default;
+        return false;
+    }
+    
+    private bool TryConvertValueFromOneQuantityToAnother(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey, out QuantityValue convertedValue)
+    {
+        var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitKey.UnitEnumType);
+        if (_quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction conversionFunction))
+        {
+            return TryConvertValue(conversionFunction.Convert(value), new UnitConversionKey(conversionFunction.TargetUnit, toUnitKey.UnitEnumValue), out convertedValue);
+        }
+        
+        if (TryGetUnitInfo(fromUnitKey, out UnitInfo? fromUnitInfo) && TryGetUnitInfo(toUnitKey, out UnitInfo? toUnitInfo))
+        {
+            return TryConvertValueFromOneQuantityToAnother(value, fromUnitInfo, toUnitInfo, out convertedValue);
+        }
+
+        convertedValue = default;
+        return false;
+    }
+
+    protected override bool TryConvertValueInternal(QuantityValue value, UnitInfo fromUnitInfo, UnitInfo toUnitInfo, out QuantityValue convertedValue)
+    {
+        if (fromUnitInfo == toUnitInfo)
+        {
+            // TODO see about this: the only possible route in is from TryConvertValueByName
+            convertedValue = value;
+            return true;
+        }
+
+        UnitKey fromUnitKey = fromUnitInfo.UnitKey;
+        UnitKey toUnitKey = toUnitInfo.UnitKey;
+        if (fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType)
+        {
+            convertedValue = _unitConversions.TryGetValue(UnitConversionKey.Create(fromUnitKey, toUnitKey), out ConvertValueDelegate? cachedConversion)
+                ? cachedConversion(value)
+                : toUnitInfo.GetValueFrom(value, fromUnitInfo);
+            return true;
+        }
+        
+        var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitKey.UnitEnumType);
+        if (!_quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction defaultConversion))
+        {
+            return TryConvertValueFromOneQuantityToAnother(value, fromUnitInfo, toUnitInfo, out convertedValue);
+        }
+
+        if (defaultConversion.TargetUnit == toUnitKey)
+        {
+            convertedValue = defaultConversion.Convert(value);
+            return true;
+        }
+
+        QuantityValue valueInDefaultUnit = defaultConversion.Convert(value);
+        convertedValue = _unitConversions.TryGetValue(UnitConversionKey.Create(defaultConversion.TargetUnit, toUnitKey), out ConvertValueDelegate? toTargetUnitConversion)
+                ? toTargetUnitConversion(valueInDefaultUnit)
+                : toUnitInfo.GetValueFrom(valueInDefaultUnit, GetUnitInfo(defaultConversion.TargetUnit));
+        return true;
+    }
+
+    public override QuantityValue ConvertValue<TUnit>(QuantityValue value, TUnit fromUnit, TUnit toUnit)
+    {
+        var conversionKey = UnitConversionKey.Create(fromUnit, toUnit);
+        return ConvertValue(value, conversionKey);
+    }
+
+    public override QuantityValue ConvertValue(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey)
+    {
+        return fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType
+            ? ConvertValue(value, UnitConversionKey.Create(fromUnitKey, toUnitKey))
+            : ConvertValueFromOneQuantityToAnother(value, fromUnitKey, toUnitKey);
+    }
+
+    private QuantityValue ConvertValue(QuantityValue value, UnitConversionKey conversionKey)
+    {
+        if (conversionKey.HasSameUnits)
+        {
+            return value;
+        }
+
+        if (_unitConversions.TryGetValue(conversionKey, out ConvertValueDelegate? cachedConversion))
+        {
+            return cachedConversion(value);
+        }
+
+        UnitInfo fromUnitInfo = GetUnitInfo(conversionKey.FromUnitKey);
+        UnitInfo toUnitInfo = GetUnitInfo(new UnitKey(conversionKey.FromUnitKey.UnitEnumType, conversionKey.ToUnitValue));
+        return toUnitInfo.GetValueFrom(value, fromUnitInfo);
+    }
+    
+    private QuantityValue ConvertValueFromOneQuantityToAnother(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey)
+    {
+        var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitKey.UnitEnumType);
+        return _quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction defaultConversionFunction)
+            ? ConvertValue(defaultConversionFunction.Convert(value), new UnitConversionKey(defaultConversionFunction.TargetUnit, toUnitKey.UnitEnumValue))
+            : ConvertValueFromOneQuantityToAnother(value, GetUnitInfo(fromUnitKey), GetUnitInfo(toUnitKey));
+    }
+
+    protected override QuantityValue ConvertValueInternal(QuantityValue value, UnitInfo fromUnitInfo, UnitInfo toUnitInfo)
+    {
+        if (fromUnitInfo == toUnitInfo)
+        {
+            return value;
+        }
+
+        UnitKey fromUnitKey = fromUnitInfo.UnitKey;
+        UnitKey toUnitKey = toUnitInfo.UnitKey;
+        if (fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType)
+        {
+            return _unitConversions.TryGetValue(UnitConversionKey.Create(fromUnitKey, toUnitKey), out ConvertValueDelegate? cachedConversion)
+                ? cachedConversion(value)
+                : toUnitInfo.GetValueFrom(value, fromUnitInfo);
+        }
+
+        var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitInfo.QuantityInfo.UnitType);
+        if (!_quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction defaultConversion))
+        {
+            return ConvertValueFromOneQuantityToAnother(value, fromUnitInfo, toUnitInfo);
+        }
+        
+        if (defaultConversion.TargetUnit == toUnitKey)
+        {
+            return defaultConversion.Convert(value);
+        }
+        
+        QuantityValue valueInDefaultUnit = defaultConversion.Convert(value);
+        return _unitConversions.TryGetValue(UnitConversionKey.Create(defaultConversion.TargetUnit, toUnitKey), out ConvertValueDelegate? toTargetUnitConversion)
+            ? toTargetUnitConversion(valueInDefaultUnit)
+            : toUnitInfo.GetValueFrom(valueInDefaultUnit, GetUnitInfo(defaultConversion.TargetUnit));
+    }
+
+    public override ConvertValueDelegate GetConversionFunction(UnitKey fromUnitKey, UnitKey toUnitKey)
+    {
+        if (fromUnitKey == toUnitKey)
+        {
+            return value => value;
+        }
+
+        if (fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType)
+        {
+            return _unitConversions.TryGetValue(UnitConversionKey.Create(fromUnitKey, toUnitKey), out ConvertValueDelegate? conversionFunction)
+                ? conversionFunction
+                : GetUnitInfo(fromUnitKey).GetUnitConversionExpressionTo(GetUnitInfo(toUnitKey));
+        }
+
+        UnitInfo fromUnitInfo = GetUnitInfo(fromUnitKey);
+        UnitInfo toUnitInfo = GetUnitInfo(toUnitKey);
+        var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitInfo.QuantityInfo.UnitType);
+        if (_quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction defaultConversion))
+        {
+            if (defaultConversion.TargetUnit == toUnitKey)
+            {
+                return defaultConversion.Convert;
+            }
+
+            ConvertValueDelegate conversionToTarget =
+                _unitConversions.TryGetValue(UnitConversionKey.Create(defaultConversion.TargetUnit, toUnitKey), out ConvertValueDelegate? conversionFunction)
+                    ? conversionFunction
+                    : GetUnitInfo(defaultConversion.TargetUnit).GetUnitConversionExpressionTo(toUnitInfo);
+            return value => conversionToTarget(defaultConversion.Convert(value));
+        }
+
+        return GetConversionFromOneQuantityToAnother(fromUnitInfo, toUnitInfo);
+    }
+
+    public override bool TryGetConversionFunction(UnitKey fromUnitKey, UnitKey toUnitKey, [NotNullWhen(true)] out ConvertValueDelegate? conversionFunction)
+    {
+        if (fromUnitKey == toUnitKey)
+        {
+            conversionFunction = value => value;
+            return true;
+        }
+
+        if (fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType)
+        {
+            if (_unitConversions.TryGetValue(UnitConversionKey.Create(fromUnitKey, toUnitKey), out conversionFunction))
+            {
+                return true;
+            }
+
+            if (TryGetUnitInfo(fromUnitKey, out UnitInfo? fromUnitInfo) && TryGetUnitInfo(toUnitKey, out UnitInfo? toUnitInfo))
+            {
+                conversionFunction = fromUnitInfo.GetUnitConversionExpressionTo(toUnitInfo);
+                return true;
+            }
+        }
+        else if (TryGetUnitInfo(fromUnitKey, out UnitInfo? fromUnitInfo) && TryGetUnitInfo(toUnitKey, out UnitInfo? toUnitInfo))
+        {
+            var defaultConversionKey = new QuantityConversionKey(fromUnitKey, toUnitInfo.QuantityInfo.UnitType);
+            if (!_quantityConversions.TryGetValue(defaultConversionKey, out QuantityConversionFunction defaultConversion))
+            {
+                return TryGetConversionFromOneQuantityToAnother(fromUnitInfo, toUnitInfo, out conversionFunction);
+            }
+
+            if (defaultConversion.TargetUnit == toUnitKey)
+            {
+                conversionFunction = defaultConversion.Convert;
+                return true;
+            }
+
+            ConvertValueDelegate conversionToTarget =
+                _unitConversions.TryGetValue(UnitConversionKey.Create(defaultConversion.TargetUnit, toUnitKey), out ConvertValueDelegate? conversion)
+                    ? conversion
+                    : GetUnitInfo(defaultConversion.TargetUnit).GetUnitConversionExpressionTo(toUnitInfo);
+            conversionFunction = value => conversionToTarget(defaultConversion.Convert(value));
+            return true;
+        }
+
+        conversionFunction = null;
+        return false;
+    }
+
+    public override TTargetQuantity ConvertTo<TSourceUnit, TTargetQuantity, TTargetUnit>(QuantityValue value, TSourceUnit fromUnit, QuantityInfo<TTargetQuantity, TTargetUnit> targetQuantityInfo)
+    {
+        if (_quantityConversions.TryGetValue(QuantityConversionKey.Create<TSourceUnit, TTargetUnit>(fromUnit), out QuantityConversionFunction conversionFunction))
+        {
+            return targetQuantityInfo.From(conversionFunction.Convert(value), conversionFunction.TargetUnit.ToUnit<TTargetUnit>());
+        }
+        
+        return base.ConvertTo(value, fromUnit, targetQuantityInfo);
+    }
+
+    public override IQuantity ConvertTo(QuantityValue value, UnitKey fromUnitKey, QuantityInfo targetQuantityInfo)
+    {
+        if (_quantityConversions.TryGetValue(new QuantityConversionKey(fromUnitKey, targetQuantityInfo.UnitType),
+                out QuantityConversionFunction conversionFunction))
+        {
+            return targetQuantityInfo.From(conversionFunction.Convert(value), conversionFunction.TargetUnit);
+        }
+
+        return base.ConvertTo(value, fromUnitKey, targetQuantityInfo);
+    }
+
+
+    public override bool TryConvertTo<TSourceUnit, TTargetQuantity, TTargetUnit>(QuantityValue value, TSourceUnit fromUnit,
+        QuantityInfo<TTargetQuantity, TTargetUnit> targetQuantityInfo,
+        [NotNullWhen(true)] out TTargetQuantity? convertedQuantity)
+        where TTargetQuantity : default
+    {
+        if (_quantityConversions.TryGetValue(QuantityConversionKey.Create<TSourceUnit, TTargetUnit>(fromUnit),
+                out QuantityConversionFunction conversionFunction))
+        {
+            convertedQuantity = targetQuantityInfo.From(conversionFunction.Convert(value), conversionFunction.TargetUnit.ToUnit<TTargetUnit>());
+            return true;
+        }
+
+        return base.TryConvertTo(value, fromUnit, targetQuantityInfo, out convertedQuantity);
+    }
+
+    public override bool TryConvertTo(QuantityValue value, UnitKey fromUnitKey, QuantityInfo targetQuantityInfo,
+        [NotNullWhen(true)] out IQuantity? convertedQuantity)
+    {
+        if (_quantityConversions.TryGetValue(new QuantityConversionKey(fromUnitKey, targetQuantityInfo.UnitType),
+                out QuantityConversionFunction conversionFunction))
+        {
+            convertedQuantity = targetQuantityInfo.From(conversionFunction.Convert(value), conversionFunction.TargetUnit);
+            return true;
+        }
+
+        return base.TryConvertTo(value, fromUnitKey, targetQuantityInfo, out convertedQuantity);
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/NoCachingConverter.cs b/UnitsNet/CustomCode/QuantityConverters/NoCachingConverter.cs
new file mode 100644
index 0000000000..280360643d
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/NoCachingConverter.cs
@@ -0,0 +1,14 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet;
+
+/// <inheritdoc />
+public sealed class NoCachingConverter : UnitConverter
+{
+    /// <inheritdoc />
+    public NoCachingConverter(UnitParser unitParser)
+        : base(unitParser)
+    {
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/QuantityConversionFunction.cs b/UnitsNet/CustomCode/QuantityConverters/QuantityConversionFunction.cs
new file mode 100644
index 0000000000..fd60c4acd7
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/QuantityConversionFunction.cs
@@ -0,0 +1,30 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Diagnostics;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents the result of a quantity conversion, including the conversion delegate and the target unit.
+/// </summary>
+[DebuggerDisplay("{TargetUnit.GetDebuggerDisplay(),nq}")]
+internal readonly record struct QuantityConversionFunction
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityConversionFunction" /> struct.
+    /// </summary>
+    /// <param name="conversionFunction">The delegate that performs the conversion.</param>
+    /// <param name="targetUnit">The unit to which the quantity is converted.</param>
+    public QuantityConversionFunction(ConvertValueDelegate conversionFunction, UnitKey targetUnit)
+    {
+        Convert = conversionFunction;
+        TargetUnit = targetUnit;
+    }
+
+    /// <summary>The delegate that performs the conversion.</summary>
+    public ConvertValueDelegate Convert { get; }
+
+    /// <summary>The unit to which the quantity is converted.</summary>
+    public UnitKey TargetUnit { get; }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/QuantityConversionKey.cs b/UnitsNet/CustomCode/QuantityConverters/QuantityConversionKey.cs
new file mode 100644
index 0000000000..94a21d43f2
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/QuantityConversionKey.cs
@@ -0,0 +1,46 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Diagnostics;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents the mapping-key used for converting between the units of two different quantities.
+/// </summary>
+[DebuggerDisplay("{FromUnit.GetDebuggerDisplay(),nq} -> {ResultType.Name,nq}")]
+internal readonly record struct QuantityConversionKey
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityConversionKey" /> struct.
+    /// </summary>
+    /// <param name="FromUnit">The unit key representing the source unit of the conversion.</param>
+    /// <param name="ResultType">The type representing the target quantity of the conversion.</param>
+    public QuantityConversionKey(UnitKey FromUnit, Type ResultType)
+    {
+        this.FromUnit = FromUnit;
+        this.ResultType = ResultType;
+    }
+
+    public UnitKey FromUnit { get; }
+    public Type ResultType { get; }
+
+    /// <summary>
+    ///     Creates a new instance of <see cref="QuantityConversionKey" /> using the specified source unit and target unit
+    ///     type.
+    /// </summary>
+    /// <typeparam name="TSourceUnit">The type of the source units, which must be a struct and an enum.</typeparam>
+    /// <typeparam name="TTargetUnit">The type of the target units, which must be a struct and an enum.</typeparam>
+    /// <param name="fromUnit">The unit of the quantity to convert from.</param>
+    /// <returns>
+    ///     A new <see cref="QuantityConversionKey" /> representing the conversion from <paramref name="fromUnit" /> to the
+    ///     type <typeparamref name="TTargetUnit" />.
+    /// </returns>
+    public static QuantityConversionKey Create<TSourceUnit, TTargetUnit>(TSourceUnit fromUnit)
+        where TSourceUnit : struct, Enum
+        where TTargetUnit : struct, Enum
+    {
+        return new QuantityConversionKey(UnitKey.ForUnit(fromUnit), typeof(TTargetUnit));
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityConverters/UnitConversionKey.cs b/UnitsNet/CustomCode/QuantityConverters/UnitConversionKey.cs
new file mode 100644
index 0000000000..056425f882
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityConverters/UnitConversionKey.cs
@@ -0,0 +1,70 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents the mapping-key used for converting between the units of the same quantity.
+/// </summary>
+internal readonly record struct UnitConversionKey
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitConversionKey" /> struct with the specified source unit key and
+    ///     target unit value.
+    /// </summary>
+    /// <param name="FromUnitKey">The key representing the source unit for the conversion.</param>
+    /// <param name="ToUnitValue">The integer value representing the target unit for the conversion.</param>
+    public UnitConversionKey(UnitKey FromUnitKey, int ToUnitValue)
+    {
+        this.FromUnitKey = FromUnitKey;
+        this.ToUnitValue = ToUnitValue;
+    }
+
+    /// <summary>
+    ///     Gets a value indicating whether the conversion is to the same unit.
+    /// </summary>
+    /// <value>
+    ///     <c>true</c> if the conversion is to the same unit; otherwise, <c>false</c>.
+    /// </value>
+    public bool HasSameUnits
+    {
+        get => FromUnitKey.UnitEnumValue == ToUnitValue;
+    }
+
+    public UnitKey FromUnitKey { get; }
+    public int ToUnitValue { get; }
+
+    /// <summary>
+    ///     Creates a new instance of <see cref="UnitConversionKey" /> using the specified units.
+    /// </summary>
+    /// <typeparam name="TUnit">The type of the units, which must be a struct and an enum.</typeparam>
+    /// <param name="fromUnit">The unit of the quantity to convert from.</param>
+    /// <param name="toUnit">The unit to convert to.</param>
+    /// <returns>
+    ///     A new <see cref="UnitConversionKey" /> representing the conversion from <paramref name="fromUnit" /> to
+    ///     <paramref name="toUnit" />.
+    /// </returns>
+    public static UnitConversionKey Create<TUnit>(TUnit fromUnit, TUnit toUnit)
+        where TUnit : struct, Enum
+    {
+        return new UnitConversionKey(UnitKey.ForUnit(fromUnit), Unsafe.As<TUnit, int>(ref toUnit));
+    }
+
+    /// <summary>
+    ///     Creates a new instance of <see cref="UnitConversionKey" /> using the specified units.
+    /// </summary>
+    /// <param name="fromUnitKey">The unit of the quantity to convert from.</param>
+    /// <param name="toUnitKey">The unit to convert to.</param>
+    /// <returns>
+    ///     A new <see cref="UnitConversionKey" /> representing the conversion from
+    ///     <paramref name="fromUnitKey" /> to
+    ///     <paramref name="toUnitKey" />.
+    /// </returns>
+    public static UnitConversionKey Create(UnitKey fromUnitKey, UnitKey toUnitKey)
+    {
+        return new UnitConversionKey(fromUnitKey, toUnitKey.UnitEnumValue);
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityInfo/Builder/IQuantityInfoBuilder.cs b/UnitsNet/CustomCode/QuantityInfo/Builder/IQuantityInfoBuilder.cs
new file mode 100644
index 0000000000..5f39c98489
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityInfo/Builder/IQuantityInfoBuilder.cs
@@ -0,0 +1,28 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents a builder interface for constructing instances of <see cref="QuantityInfo" />.
+/// </summary>
+/// <remarks>
+///     This interface defines a contract for creating <see cref="QuantityInfo" /> objects, allowing for customization
+///     and configuration of quantity metadata. It is primarily used in scenarios where quantity information needs to
+///     be dynamically constructed or overridden.
+/// </remarks>
+internal interface IQuantityInfoBuilder
+{
+    /// <summary>
+    ///     Builds and returns an instance of <see cref="QuantityInfo" />.
+    /// </summary>
+    /// <returns>
+    ///     A constructed <see cref="QuantityInfo" /> instance containing metadata about a specific quantity.
+    /// </returns>
+    /// <remarks>
+    ///     This method is used to finalize the construction of a <see cref="QuantityInfo" /> object,
+    ///     encapsulating all configured properties and metadata. It is typically invoked after setting up
+    ///     the desired configuration for a quantity.
+    /// </remarks>
+    QuantityInfo Build();
+}
diff --git a/UnitsNet/CustomCode/QuantityInfo/Builder/QuantitiesInfoBuilder.cs b/UnitsNet/CustomCode/QuantityInfo/Builder/QuantitiesInfoBuilder.cs
new file mode 100644
index 0000000000..0241211f67
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityInfo/Builder/QuantitiesInfoBuilder.cs
@@ -0,0 +1,106 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents a builder for configuring and creating custom quantity information.
+/// </summary>
+/// <remarks>
+///     This class provides methods to configure specific quantities with custom configurations
+///     and to create or retrieve quantity information based on the provided configurations.
+///     It is primarily used internally to manage and customize quantity information.
+/// </remarks>
+internal sealed class QuantitiesInfoBuilder
+{
+    private readonly Dictionary<Type, IQuantityInfoBuilder> _quantityCustomizations = new();
+
+    /// <summary>
+    ///     Configures a custom quantity by associating it with a delegate that creates its custom configuration.
+    /// </summary>
+    /// <typeparam name="TQuantity">
+    ///     The type of the quantity to configure. Must implement
+    ///     <see cref="IQuantity{TQuantity, TUnit}" />.
+    /// </typeparam>
+    /// <typeparam name="TUnit">The type of the unit associated with the quantity. Must be an enumeration.</typeparam>
+    /// <param name="createCustomConfigurationDelegate">
+    ///     A delegate that creates and returns a custom configuration for the specified quantity.
+    /// </param>
+    /// <returns>The current instance of <see cref="QuantitiesInfoBuilder" /> to allow method chaining.</returns>
+    /// <remarks>
+    ///     This method is used to define custom configurations for specific quantities, enabling fine-grained control
+    ///     over their behavior and properties. The provided delegate is invoked to generate the configuration.
+    /// </remarks>
+    internal QuantitiesInfoBuilder ConfigureQuantity<TQuantity, TUnit>(Func<QuantityInfo<TQuantity, TUnit>> createCustomConfigurationDelegate)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        _quantityCustomizations.Add(typeof(TQuantity), new QuantityInfoBuilder<TQuantity, TUnit>(createCustomConfigurationDelegate));
+        return this;
+    }
+
+    /// <summary>
+    ///     Creates a <see cref="QuantityInfo" /> instance based on the provided default configuration or returns the default
+    ///     configuration
+    ///     if no customizations are available for the specified quantity type.
+    /// </summary>
+    /// <param name="defaultConfiguration">
+    ///     The default <see cref="QuantityInfo" /> configuration to use if no customizations are found.
+    /// </param>
+    /// <returns>
+    ///     A <see cref="QuantityInfo" /> instance representing either the customized configuration or the provided default
+    ///     configuration.
+    /// </returns>
+    /// <remarks>
+    ///     This method checks if a custom configuration exists for the quantity type specified in the
+    ///     <paramref name="defaultConfiguration" />.
+    ///     If a customization is found, it builds and returns the customized <see cref="QuantityInfo" />.
+    ///     Otherwise, it returns the provided <paramref name="defaultConfiguration" />.
+    /// </remarks>
+    public QuantityInfo CreateOrDefault(QuantityInfo defaultConfiguration)
+    {
+        return _quantityCustomizations.TryGetValue(defaultConfiguration.QuantityType, out IQuantityInfoBuilder? builder)
+            ? builder.Build()
+            : defaultConfiguration;
+    }
+
+    /// <summary>
+    ///     Creates or retrieves a <see cref="QuantityInfo{TQuantity, TUnit}" /> instance based on the provided default
+    ///     configuration
+    ///     or any custom configuration previously defined for the specified quantity type.
+    /// </summary>
+    /// <typeparam name="TQuantity">
+    ///     The type of the quantity for which the <see cref="QuantityInfo{TQuantity, TUnit}" /> is being created or retrieved.
+    /// </typeparam>
+    /// <typeparam name="TUnit">
+    ///     The type of the unit associated with the quantity. Must be an enumeration.
+    /// </typeparam>
+    /// <param name="defaultConfiguration">
+    ///     A delegate that provides the default configuration for the <see cref="QuantityInfo{TQuantity, TUnit}" />
+    ///     if no custom configuration is available.
+    /// </param>
+    /// <returns>
+    ///     A <see cref="QuantityInfo{TQuantity, TUnit}" /> instance, either from a custom configuration if available,
+    ///     or from the provided default configuration.
+    /// </returns>
+    /// <remarks>
+    ///     This method checks if a custom configuration exists for the specified quantity type. If found, it uses the custom
+    ///     configuration to create the <see cref="QuantityInfo{TQuantity, TUnit}" />. Otherwise, it falls back to the
+    ///     <paramref name="defaultConfiguration" /> delegate to create the default configuration.
+    /// </remarks>
+    public QuantityInfo<TQuantity, TUnit> CreateOrDefault<TQuantity, TUnit>(Func<QuantityInfo<TQuantity, TUnit>> defaultConfiguration)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        if (_quantityCustomizations.TryGetValue(typeof(TQuantity), out IQuantityInfoBuilder? builder) &&
+            builder is QuantityInfoBuilder<TQuantity, TUnit> specificBuilder)
+        {
+            return specificBuilder.Build();
+        }
+        
+        return defaultConfiguration();
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityInfo/Builder/QuantitiesSelector.cs b/UnitsNet/CustomCode/QuantityInfo/Builder/QuantitiesSelector.cs
new file mode 100644
index 0000000000..fe5ab61919
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityInfo/Builder/QuantitiesSelector.cs
@@ -0,0 +1,108 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Linq;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Selects the quantities used to construct an isolated UnitsNet component or setup.
+/// </summary>
+public sealed class QuantitiesSelector
+{
+    private readonly Func<IEnumerable<QuantityInfo>> _defaultQuantities;
+    private IEnumerable<QuantityInfo>? _additionalQuantities;
+    private QuantitiesInfoBuilder? _quantitiesInfoBuilder;
+
+    internal QuantitiesSelector(Func<IEnumerable<QuantityInfo>> defaultQuantities)
+    {
+        _defaultQuantities = defaultQuantities ?? throw new ArgumentNullException(nameof(defaultQuantities));
+    }
+
+    /// <summary>
+    ///     Appends external quantity definitions to the current selection.
+    /// </summary>
+    /// <param name="quantities">The quantity definitions to append.</param>
+    /// <returns>This selector, for method chaining.</returns>
+    public QuantitiesSelector WithAdditionalQuantities(IEnumerable<QuantityInfo> quantities)
+    {
+        if (quantities is null) throw new ArgumentNullException(nameof(quantities));
+
+        _additionalQuantities = _additionalQuantities?.Concat(quantities) ?? quantities;
+        return this;
+    }
+
+    internal IEnumerable<QuantityInfo> GetQuantityInfos()
+    {
+        IEnumerable<QuantityInfo> quantities = _defaultQuantities();
+        if (_additionalQuantities is not null)
+        {
+            quantities = quantities.Concat(_additionalQuantities);
+        }
+
+        if (_quantitiesInfoBuilder is not null)
+        {
+            quantities = quantities.Select(_quantitiesInfoBuilder.CreateOrDefault);
+        }
+
+        return quantities;
+    }
+
+    /// <summary>
+    ///     Configures a specific quantity with a custom configuration.
+    /// </summary>
+    /// <typeparam name="TQuantity">The type of the quantity to configure.</typeparam>
+    /// <typeparam name="TUnit">The type of the unit associated with the quantity.</typeparam>
+    /// <param name="createCustomConfigurationDelegate">
+    ///     A delegate that creates a custom configuration for the specified quantity.
+    /// </param>
+    /// <returns>The current instance of <see cref="QuantitiesSelector" /> to allow for method chaining.</returns>
+    /// <remarks>
+    ///     This method allows for the customization of a specific quantity by providing a delegate that creates
+    ///     a custom configuration. It initializes the <see cref="QuantitiesInfoBuilder" /> if it is not already initialized
+    ///     and uses it to configure the quantity.
+    /// </remarks>
+    public QuantitiesSelector Configure<TQuantity, TUnit>(Func<QuantityInfo<TQuantity, TUnit>> createCustomConfigurationDelegate)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        if (createCustomConfigurationDelegate is null) throw new ArgumentNullException(nameof(createCustomConfigurationDelegate));
+
+        _quantitiesInfoBuilder ??= new QuantitiesInfoBuilder();
+        _quantitiesInfoBuilder.ConfigureQuantity(createCustomConfigurationDelegate);
+        return this;
+    }
+
+    /// <summary>
+    ///     Creates a quantity information instance using the provided default configuration or a custom configuration
+    ///     if available.
+    /// </summary>
+    /// <typeparam name="TQuantity">
+    ///     The type of the quantity, which must implement <see cref="IQuantity{TSelf, TUnitType}" />.
+    /// </typeparam>
+    /// <typeparam name="TUnit">
+    ///     The type of the unit, which must be a struct and an enumeration.
+    /// </typeparam>
+    /// <param name="defaultConfiguration">
+    ///     A delegate that provides the default configuration for creating the <see cref="QuantityInfo{TQuantity, TUnit}" />.
+    /// </param>
+    /// <returns>
+    ///     An instance of <see cref="QuantityInfo{TQuantity, TUnit}" /> created using either the default configuration
+    ///     or a custom configuration if available.
+    /// </returns>
+    /// <remarks>
+    ///     This method checks if a custom configuration is available through the <see cref="QuantitiesInfoBuilder" />.
+    ///     If no custom configuration is available, it falls back to the provided default configuration.
+    /// </remarks>
+    /// <exception cref="ArgumentNullException">
+    ///     Thrown if the <paramref name="defaultConfiguration" /> is <c>null</c>.
+    /// </exception>
+    internal QuantityInfo<TQuantity, TUnit> CreateOrDefault<TQuantity, TUnit>(Func<QuantityInfo<TQuantity, TUnit>> defaultConfiguration)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        if (defaultConfiguration is null) throw new ArgumentNullException(nameof(defaultConfiguration));
+
+        return _quantitiesInfoBuilder is null ? defaultConfiguration() : _quantitiesInfoBuilder.CreateOrDefault(defaultConfiguration);
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityInfo/Builder/QuantityInfoBuilder.cs b/UnitsNet/CustomCode/QuantityInfo/Builder/QuantityInfoBuilder.cs
new file mode 100644
index 0000000000..f0c94e1baa
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityInfo/Builder/QuantityInfoBuilder.cs
@@ -0,0 +1,55 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents a builder for creating instances of <see cref="QuantityInfo{TQuantity, TUnit}" />.
+/// </summary>
+/// <typeparam name="TQuantity">
+///     The type of the quantity being built, which must implement <see cref="IQuantity{TQuantity, TUnit}" />.
+/// </typeparam>
+/// <typeparam name="TUnit">
+///     The type of the unit associated with the quantity, which must be an enumeration.
+/// </typeparam>
+/// <remarks>
+///     This class provides a mechanism to lazily construct a <see cref="QuantityInfo{TQuantity, TUnit}" /> instance
+///     using a factory method. It is primarily used to configure and retrieve quantity metadata.
+/// </remarks>
+internal sealed class QuantityInfoBuilder<TQuantity, TUnit> : IQuantityInfoBuilder
+    where TQuantity : IQuantity<TQuantity, TUnit>
+    where TUnit : struct, Enum
+{
+    private readonly Lazy<QuantityInfo<TQuantity, TUnit>> _quantityInfo;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="QuantityInfoBuilder{TQuantity, TUnit}" /> class.
+    /// </summary>
+    /// <param name="factory">
+    /// A factory method that lazily creates an instance of <see cref="QuantityInfo{TQuantity, TUnit}" />.
+    /// </param>
+    /// <exception cref="ArgumentNullException">
+    /// Thrown if the <paramref name="factory" /> parameter is <c>null</c>.
+    /// </exception>
+    /// <remarks>
+    /// This constructor allows for the deferred creation of a <see cref="QuantityInfo{TQuantity, TUnit}" /> instance,
+    /// enabling efficient configuration and retrieval of quantity metadata.
+    /// </remarks>
+    public QuantityInfoBuilder(Func<QuantityInfo<TQuantity, TUnit>> factory)
+    {
+        _quantityInfo = new Lazy<QuantityInfo<TQuantity, TUnit>>(factory);
+    }
+
+    QuantityInfo IQuantityInfoBuilder.Build()
+    {
+        return Build();
+    }
+
+    /// <inheritdoc cref="IQuantityInfoBuilder.Build"/>
+    public QuantityInfo<TQuantity, TUnit> Build()
+    {
+        return _quantityInfo.Value;
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityInfo/Builder/QuantityInfoBuilderExtensions.cs b/UnitsNet/CustomCode/QuantityInfo/Builder/QuantityInfoBuilderExtensions.cs
new file mode 100644
index 0000000000..780782992d
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityInfo/Builder/QuantityInfoBuilderExtensions.cs
@@ -0,0 +1,118 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Linq;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Provides extension methods for building and configuring unit mappings within the UnitsNet library.
+/// </summary>
+public static class QuantityInfoBuilderExtensions
+{
+    /// <summary>
+    ///     Filters the collection of unit mappings to include only the specified units.
+    /// </summary>
+    /// <typeparam name="TUnitDefinition">The type of the unit definition.</typeparam>
+    /// <typeparam name="TUnit">The type of the unit enumeration, such as <see cref="LengthUnit"/>.</typeparam>
+    /// <param name="unitMappings">The collection of unit mappings to filter, such as the ones provided by <see cref="Length.LengthInfo.GetDefaultMappings"/>.</param>
+    /// <param name="units">The units to include in the filtered collection.</param>
+    /// <returns>An enumerable collection of unit definitions that includes only the specified units.</returns>
+    public static IEnumerable<TUnitDefinition> SelectUnits<TUnitDefinition, TUnit>(this IEnumerable<TUnitDefinition> unitMappings, params IEnumerable<TUnit> units)
+        where TUnitDefinition : IUnitDefinition<TUnit>
+        where TUnit : struct, Enum
+    {
+        return unitMappings.Where(x => units.Contains(x.Value));
+    }
+
+    /// <summary>
+    ///     Filters the collection of unit mappings to exclude the specified units.
+    /// </summary>
+    /// <typeparam name="TUnitDefinition">The type of the unit definition.</typeparam>
+    /// <typeparam name="TUnit">The type of the unit enumeration, such as <see cref="LengthUnit"/>.</typeparam>
+    /// <param name="unitMappings">The collection of unit mappings to filter, such as the ones provided by <see cref="Length.LengthInfo.GetDefaultMappings"/>.</param>
+    /// <param name="units">The units to exclude from the filtered collection.</param>
+    /// <returns>An enumerable collection of unit definitions that excludes the specified units.</returns>
+    public static IEnumerable<TUnitDefinition> ExcludeUnits<TUnitDefinition, TUnit>(this IEnumerable<TUnitDefinition> unitMappings, params IEnumerable<TUnit> units)
+        where TUnitDefinition : IUnitDefinition<TUnit>
+        where TUnit : struct, Enum
+    {
+        return unitMappings.Where(x => !units.Contains(x.Value));
+    }
+
+    /// <summary>
+    ///     Configures a specific unit within a collection of unit mappings.
+    /// </summary>
+    /// <typeparam name="TUnit">The type of the unit enumeration.</typeparam>
+    /// <typeparam name="TUnitDefinition"></typeparam>
+    /// <param name="unitMappings">The collection of unit mappings to configure, such as the ones provided by <see cref="Length.LengthInfo.GetDefaultMappings"/>.</param>
+    /// <param name="unit">The unit to configure, such as <see cref="LengthUnit"/>.</param>
+    /// <param name="unitConfiguration">A function that defines the configuration for the specified unit.</param>
+    /// <returns>An enumerable collection of unit definitions with the specified unit configured.</returns>
+    public static IEnumerable<TUnitDefinition> Configure<TUnitDefinition, TUnit>(this IEnumerable<TUnitDefinition> unitMappings, TUnit unit,
+        Func<TUnitDefinition, TUnitDefinition> unitConfiguration)
+        where TUnitDefinition : IUnitDefinition<TUnit>
+        where TUnit : struct, Enum
+    {
+        #if NET
+        EqualityComparer<TUnit> comparer = EqualityComparer<TUnit>.Default;
+        #else
+        UnitEqualityComparer<TUnit> comparer = UnitEqualityComparer<TUnit>.Default;
+        #endif
+        foreach (TUnitDefinition unitMapping in unitMappings)
+        {
+            if (comparer.Equals(unitMapping.Value, unit))
+            {
+                yield return unitConfiguration(unitMapping);
+            }
+            else
+            {
+                yield return unitMapping;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Creates a new unit definition by specifying a new conversion factor from the base unit.
+    /// </summary>
+    /// <typeparam name="TUnit">The type of the unit enumeration, such as <see cref="LengthUnit"/>.</typeparam>
+    /// <param name="unitDefinition">The unit definition to which the conversion factor will be added.</param>
+    /// <param name="conversionFromBase">The conversion factor from the base unit to the specified unit.</param>
+    /// <returns>A new <see cref="UnitDefinition{TUnit}" /> instance with the specified conversion factor from the base unit.</returns>
+    public static UnitDefinition<TUnit> WithConversionFactorFromBase<TUnit>(this IUnitDefinition<TUnit> unitDefinition, QuantityValue conversionFromBase)
+        where TUnit : struct, Enum
+    {
+        return new UnitDefinition<TUnit>(unitDefinition.Value, unitDefinition.Name, unitDefinition.PluralName, unitDefinition.BaseUnits, conversionFromBase);
+    }
+
+    /// <summary>
+    ///     Creates a new unit definition by specifying a new conversion factor to the base unit.
+    /// </summary>
+    /// <typeparam name="TUnit">The type of the unit enumeration.</typeparam>
+    /// <param name="unitDefinition">The unit definition to which the conversion factor will be added.</param>
+    /// <param name="conversionToBase">The conversion factor to the base unit from the specified unit.</param>
+    /// <returns>A new <see cref="UnitDefinition{TUnit}" /> instance with the specified conversion factor to the base unit.</returns>
+    public static UnitDefinition<TUnit> WithConversionFactorToBase<TUnit>(this IUnitDefinition<TUnit> unitDefinition, QuantityValue conversionToBase)
+        where TUnit : struct, Enum
+    {
+        return new UnitDefinition<TUnit>(unitDefinition.Value, unitDefinition.Name, unitDefinition.PluralName, unitDefinition.BaseUnits,
+            QuantityValue.Inverse(conversionToBase), conversionToBase);
+    }
+
+    /// <summary>
+    ///     Creates a new unit definition by specifying conversion expressions for both conversion from the base unit and
+    ///     conversion to the base unit.
+    /// </summary>
+    /// <typeparam name="TUnit">The type of the unit enumeration.</typeparam>
+    /// <param name="unitDefinition">The unit definition to which the conversion expressions will be added.</param>
+    /// <param name="conversionFromBase">The conversion expression from the base unit to the specified unit.</param>
+    /// <param name="conversionToBase">The conversion expression from the specified unit to the base unit.</param>
+    /// <returns>A new <see cref="UnitDefinition{TUnit}" /> instance with the specified conversion expressions.</returns>
+    public static UnitDefinition<TUnit> WithConversionExpression<TUnit>(this IUnitDefinition<TUnit> unitDefinition, ConversionExpression conversionFromBase,
+        ConversionExpression conversionToBase)
+        where TUnit : struct, Enum
+    {
+        return new UnitDefinition<TUnit>(unitDefinition.Value, unitDefinition.Name, unitDefinition.PluralName, unitDefinition.BaseUnits, conversionFromBase,
+            conversionToBase);
+    }
+}
diff --git a/UnitsNet/CustomCode/QuantityInfo/QuantityInfoExtensions.cs b/UnitsNet/CustomCode/QuantityInfo/QuantityInfoExtensions.cs
index 19642cd76f..952be7ad75 100644
--- a/UnitsNet/CustomCode/QuantityInfo/QuantityInfoExtensions.cs
+++ b/UnitsNet/CustomCode/QuantityInfo/QuantityInfoExtensions.cs
@@ -1,5 +1,9 @@
-using System;
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using UnitsNet.Units;
 
@@ -29,19 +33,18 @@ public static IEnumerable<QuantityInfo> GetQuantitiesWithBaseDimensions(this IEn
     /// <summary>
     ///     Retrieves the default unit for a specified quantity and unit system.
     /// </summary>
+    /// <typeparam name="TQuantity">The type of the quantity, which implements <see cref="IQuantity{TSelf, TUnitType}" />.</typeparam>
     /// <typeparam name="TUnit">The type of the unit, which is a value type and an enumeration.</typeparam>
     /// <param name="quantityInfo">
-    ///     The <see cref="QuantityInfo{TUnit}" /> instance containing information about the
+    ///     The <see cref="QuantityInfo{TQuantity, TUnit}" /> instance containing information about the
     ///     quantity.
     /// </param>
     /// <param name="unitSystem">The <see cref="UnitSystem" /> for which the default unit is to be retrieved.</param>
     /// <returns>The default unit of type <typeparamref name="TUnit" /> for the specified quantity and unit system.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="unitSystem" /> is <c>null</c>.</exception>
     /// <exception cref="ArgumentException">Thrown when no units are found for the given <paramref name="unitSystem" />.</exception>
-    /// <example>
-    ///     <code>Length.Info.GetDefaultUnit(UnitSystem.SI)</code>
-    /// </example>
-    internal static TUnit GetDefaultUnit<TUnit>(this QuantityInfo<TUnit> quantityInfo, UnitSystem unitSystem)
+    internal static TUnit GetDefaultUnit<TQuantity, TUnit>(this QuantityInfo<TQuantity, TUnit> quantityInfo, UnitSystem unitSystem)
+        where TQuantity : IQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
         if (unitSystem is null)
@@ -54,9 +57,9 @@ internal static TUnit GetDefaultUnit<TUnit>(this QuantityInfo<TUnit> quantityInf
             return quantityInfo.BaseUnitInfo.Value;
         }
 
-        IEnumerable<UnitInfo<TUnit>> unitInfos = quantityInfo.GetUnitInfosFor(unitSystem.BaseUnits);
+        IEnumerable<UnitInfo<TQuantity, TUnit>> unitInfos = quantityInfo.GetUnitInfosFor(unitSystem.BaseUnits);
 
-        UnitInfo<TUnit>? firstUnitInfo = unitInfos.FirstOrDefault();
+        UnitInfo<TQuantity, TUnit>? firstUnitInfo = unitInfos.FirstOrDefault();
         if (firstUnitInfo == null)
         {
             throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
@@ -98,4 +101,462 @@ internal static UnitInfo GetDefaultUnit(this QuantityInfo quantityInfo, UnitSyst
 
         return firstUnitInfo;
     }
+
+    /// <summary>
+    ///     Retrieves the default unit for a specified quantity and unit system.
+    /// </summary>
+    /// <param name="quantityInfo">
+    ///     The <see cref="QuantityInfo{TQuantity, TUnit}" /> instance containing information about the
+    ///     quantity.
+    /// </param>
+    /// <param name="unitSystem">The <see cref="UnitSystem" /> for which the default unit is to be retrieved.</param>
+    /// <returns>The default unit information for the specified quantity and unit system.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="unitSystem" /> is <c>null</c>.</exception>
+    /// <exception cref="ArgumentException">Thrown when no units are found for the given <paramref name="unitSystem" />.</exception>
+    internal static UnitInfo<TUnit> GetDefaultUnit<TUnit>(this QuantityInfo<TUnit> quantityInfo, UnitSystem unitSystem)
+        where TUnit : struct, Enum
+    {
+        if (unitSystem is null)
+        {
+            throw new ArgumentNullException(nameof(unitSystem));
+        }
+
+        if (quantityInfo.BaseDimensions.IsDimensionless())
+        {
+            return quantityInfo.BaseUnitInfo;
+        }
+
+        IEnumerable<UnitInfo<TUnit>> unitInfos = quantityInfo.GetUnitInfosFor(unitSystem.BaseUnits);
+
+        UnitInfo<TUnit>? firstUnitInfo = unitInfos.FirstOrDefault();
+        if (firstUnitInfo == null)
+        {
+            throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem));
+        }
+
+        return firstUnitInfo;
+    }
+
+    /// <summary>
+    ///     Attempts to find a unit that matches the specified base units from a collection of units.
+    /// </summary>
+    /// <typeparam name="TUnitInfo">The type of the unit information, which must implement <see cref="UnitInfo" />.</typeparam>
+    /// <param name="units">The collection of units to search through.</param>
+    /// <param name="baseUnits">The base units to match against.</param>
+    /// <param name="matchingUnit">
+    ///     When this method returns, contains the unit that matches the specified base units, if found;
+    ///     otherwise, the default value for the type of the <paramref name="matchingUnit" /> parameter.
+    ///     This parameter is passed uninitialized.
+    /// </param>
+    /// <returns><c>true</c> if a unit matching the specified base units is found; otherwise, <c>false</c>.</returns>
+    internal static bool TryGetUnitWithBase<TUnitInfo>(this IReadOnlyList<TUnitInfo> units, BaseUnits baseUnits, [NotNullWhen(true)] out TUnitInfo? matchingUnit)
+        where TUnitInfo : UnitInfo
+    {
+        var nbUnits = units.Count;
+        for (var i = 0; i < nbUnits; i++)
+        {
+            TUnitInfo unitInfo = units[i];
+            if (unitInfo.BaseUnits == baseUnits)
+            {
+                matchingUnit = unitInfo;
+                return true;
+            }
+        }
+
+        matchingUnit = null;
+        return false;
+    }
+
+    /// <summary>
+    ///     Converts a value from one unit to another unit within the same quantity.
+    /// </summary>
+    /// <param name="toUnit">The target unit information to which the value will be converted.</param>
+    /// <param name="value">The value to be converted.</param>
+    /// <param name="fromUnit">The source unit information from which the value will be converted.</param>
+    /// <returns>The converted value in the target unit.</returns>
+    /// <remarks>
+    ///     Since we cannot constrain the units to be of the same quantity, I think it is better to keep this overload
+    ///     internal.
+    /// </remarks>
+    internal static QuantityValue GetValueFrom(this UnitInfo toUnit, QuantityValue value, UnitInfo fromUnit)
+    {
+        if (fromUnit == toUnit)
+        {
+            return value;
+        }
+
+        UnitInfo baseUnit = toUnit.QuantityInfo.BaseUnitInfo;
+        if (toUnit == baseUnit)
+        {
+            return fromUnit.ConversionToBase.Evaluate(value);
+        }
+
+        if (fromUnit == baseUnit)
+        {
+            return toUnit.ConversionFromBase.Evaluate(value);
+        }
+
+        QuantityValue valueInBase = fromUnit.ConversionToBase.Evaluate(value);
+        return toUnit.ConversionFromBase.Evaluate(valueInBase);
+    }
+
+    /// <summary>
+    ///     Converts a given value from a specified unit to the base unit of the quantity.
+    /// </summary>
+    /// <param name="fromUnit">The unit from which the value is to be converted.</param>
+    /// <param name="value">The value to be converted.</param>
+    /// <returns>The value converted to the base unit of the quantity.</returns>
+    internal static QuantityValue ConvertValueToBaseUnit(this UnitInfo fromUnit, QuantityValue value)
+    {
+        return fromUnit == fromUnit.QuantityInfo.BaseUnitInfo ? value : fromUnit.ConversionToBase.Evaluate(value);
+    }
+
+    /// <summary>
+    ///     Converts a value from the base unit to the specified unit.
+    /// </summary>
+    /// <param name="toUnit">The unit to convert the value to.</param>
+    /// <param name="value">The value in the base unit to be converted.</param>
+    /// <returns>The converted value in the specified unit.</returns>
+    internal static QuantityValue ConvertValueFromBaseUnit(this UnitInfo toUnit, QuantityValue value)
+    {
+        return toUnit == toUnit.QuantityInfo.BaseUnitInfo ? value : toUnit.ConversionFromBase.Evaluate(value);
+    }
+
+    /// <summary>
+    ///     Retrieves the quantities that are connected to the specified <paramref name="quantityInfo" />
+    ///     through the provided collection of <see cref="QuantityConversion" /> instances.
+    /// </summary>
+    /// <param name="conversions">
+    ///     The collection of <see cref="QuantityConversion" /> instances to search for conversions.
+    /// </param>
+    /// <param name="quantityInfo">
+    ///     The <see cref="QuantityInfo" /> for which to find connected quantities.
+    /// </param>
+    /// <returns>
+    ///     An enumerable of <see cref="QuantityInfo" /> instances that are connected to the specified
+    ///     <paramref name="quantityInfo" /> through the provided conversions.
+    /// </returns>
+    internal static IEnumerable<QuantityInfo> GetConversionsFrom(this IEnumerable<QuantityConversion> conversions, QuantityInfo quantityInfo)
+    {
+        foreach (QuantityConversion conversion in conversions)
+        {
+            if (conversion.LeftQuantity == quantityInfo)
+            {
+                yield return conversion.RightQuantity;
+            }
+            else if (conversion.RightQuantity == quantityInfo)
+            {
+                yield return conversion.LeftQuantity;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Attempts to retrieve the SI base unit for the specified quantity.
+    /// </summary>
+    /// <param name="quantityInfo">The quantity information to search within.</param>
+    /// <param name="matchingUnitInfo">
+    ///     When this method returns, contains the SI base unit if found; otherwise, <c>null</c>.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the SI base unit is found; otherwise, <c>false</c>.
+    /// </returns>
+    internal static bool TryGetSIBaseUnit(this QuantityInfo quantityInfo, [NotNullWhen(true)] out UnitInfo? matchingUnitInfo)
+    {
+        if (quantityInfo.BaseDimensions.IsDimensionless() ||
+            quantityInfo.BaseUnitInfo.BaseUnits.IsSubsetOf(UnitSystem.SI.BaseUnits)) // this should be the default case
+        {
+            matchingUnitInfo = quantityInfo.BaseUnitInfo;
+            return true;
+        }
+
+        return quantityInfo.UnitInfos.TryGetUnitWithBase(UnitSystem.SI.BaseUnits, out matchingUnitInfo);
+    }
+    
+    /// <summary>
+    ///     Attempts to convert a quantity value from a source unit to a target quantity type and unit.
+    /// </summary>
+    /// <typeparam name="TTargetQuantity">The target quantity type.</typeparam>
+    /// <typeparam name="TTargetUnit">The target unit type.</typeparam>
+    /// <param name="sourceUnit">The source unit information.</param>
+    /// <param name="sourceValue">The source quantity value.</param>
+    /// <param name="targetQuantityInfo">The target quantity information.</param>
+    /// <param name="result">
+    ///     When this method returns, contains the converted quantity value if the conversion succeeded,
+    ///     or the default value of <typeparamref name="TTargetQuantity" /> if the conversion failed.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the conversion succeeded; otherwise, <c>false</c>.
+    /// </returns>
+    internal static bool TryConvertFrom<TTargetQuantity, TTargetUnit>(this QuantityInfo<TTargetQuantity, TTargetUnit> targetQuantityInfo,
+        QuantityValue sourceValue, UnitInfo sourceUnit, [NotNullWhen(true)] out TTargetQuantity? result)
+        where TTargetQuantity : IQuantity<TTargetQuantity, TTargetUnit>
+        where TTargetUnit : struct, Enum
+    {
+        ConvertValueDelegate conversionExpression;
+        QuantityInfo sourceQuantityInfo = sourceUnit.QuantityInfo;
+        if (sourceQuantityInfo.BaseDimensions.IsInverseOf(targetQuantityInfo.BaseDimensions))
+        {
+            conversionExpression = QuantityValue.Inverse;
+        }
+        else if (sourceQuantityInfo.BaseDimensions == targetQuantityInfo.BaseDimensions)
+        {
+            if (targetQuantityInfo.BaseDimensions.IsDimensionless())
+            {
+                QuantityValue dimensionlessValue = sourceUnit.ConvertValueToBaseUnit(sourceValue);
+                result = targetQuantityInfo.From(dimensionlessValue, targetQuantityInfo.BaseUnitInfo.Value);
+                return true;
+            }
+
+            conversionExpression = value => value;
+        }
+        else
+        {
+            result = default;
+            return false;
+        }
+
+        UnitInfo sourceBaseUnit = sourceQuantityInfo.BaseUnitInfo;
+        if (sourceUnit.BaseUnits != BaseUnits.Undefined && sourceUnit.BaseUnits != sourceBaseUnit.BaseUnits)
+        {
+            if (targetQuantityInfo.UnitInfos.TryGetUnitWithBase(sourceUnit.BaseUnits, out UnitInfo<TTargetQuantity, TTargetUnit>? targetUnit))
+            {
+                result = targetUnit.From(conversionExpression(sourceValue));
+                return true;
+            }
+        }
+
+        if (sourceBaseUnit.BaseUnits != BaseUnits.Undefined)
+        {
+            // attempt to convert via the base (typically SI) unit
+            if (targetQuantityInfo.BaseUnitInfo.BaseUnits == sourceBaseUnit.BaseUnits)
+            {
+                QuantityValue convertedValue = conversionExpression(sourceUnit.ConvertValueToBaseUnit(sourceValue));
+                result = targetQuantityInfo.BaseUnitInfo.From(convertedValue);
+                return true;
+            }
+
+            // attempt to find another unit that matches the source base
+            if (targetQuantityInfo.UnitInfos.TryGetUnitWithBase(sourceBaseUnit.BaseUnits, out UnitInfo<TTargetQuantity, TTargetUnit>? targetUnit))
+            {
+                QuantityValue convertedValue = conversionExpression(sourceUnit.ConvertValueToBaseUnit(sourceValue));
+                result = targetUnit.From(convertedValue);
+                return true;
+            }
+        }
+
+        // no compatible units found with either the sourceUnit or the sourceBaseUnit: looking for intersections with any of the other units
+        IReadOnlyList<UnitInfo> sourceUnits = sourceQuantityInfo.UnitInfos;
+        var nbSourceUnits = sourceUnits.Count;
+        for (var i = 0; i < nbSourceUnits; i++)
+        {
+            UnitInfo otherUnit = sourceUnits[i];
+            if (otherUnit.BaseUnits == BaseUnits.Undefined ||
+                otherUnit.BaseUnits == sourceUnit.BaseUnits ||
+                otherUnit.BaseUnits == sourceBaseUnit.BaseUnits)
+            {
+                continue;
+            }
+
+            if (targetQuantityInfo.UnitInfos.TryGetUnitWithBase(otherUnit.BaseUnits, out UnitInfo<TTargetQuantity, TTargetUnit>? targetUnit))
+            {
+                QuantityValue convertedValue = conversionExpression(otherUnit.GetValueFrom(sourceValue, sourceUnit));
+                result = targetUnit.From(convertedValue);
+                return true;
+            }
+        }
+
+        result = default;
+        return false;
+    }
+    
+    /// <summary>
+    ///     Converts a quantity value from a source unit to a target quantity.
+    /// </summary>
+    /// <param name="targetQuantityInfo">The target quantity information.</param>
+    /// <param name="sourceValue">The value of the source quantity.</param>
+    /// <param name="sourceUnit">The unit of the source quantity.</param>
+    /// <returns>The converted quantity.</returns>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when the dimensions of the source quantity are not compatible with the dimensions of the target quantity,
+    ///     or when no compatible base units are found for the conversion.
+    /// </exception>
+    internal static TTargetQuantity ConvertFrom<TTargetQuantity, TTargetUnit>(this QuantityInfo<TTargetQuantity, TTargetUnit> targetQuantityInfo, QuantityValue sourceValue, UnitInfo sourceUnit)
+        where TTargetQuantity : IQuantity<TTargetQuantity, TTargetUnit>
+        where TTargetUnit : struct, Enum
+    {
+        if(targetQuantityInfo.TryConvertFrom(sourceValue, sourceUnit, out TTargetQuantity? convertedValue))
+        {
+            return convertedValue;
+        }
+
+        QuantityInfo sourceQuantityInfo = sourceUnit.QuantityInfo;
+        if (sourceQuantityInfo.BaseDimensions != targetQuantityInfo.BaseDimensions &&
+            !sourceQuantityInfo.BaseDimensions.IsInverseOf(targetQuantityInfo.BaseDimensions))
+        {
+            throw InvalidConversionException.CreateIncompatibleDimensionsException(sourceQuantityInfo, targetQuantityInfo);
+        }
+        
+        throw InvalidConversionException.CreateIncompatibleUnitsException(sourceUnit, targetQuantityInfo);
+    }
+    
+    /// <summary>
+    ///     Attempts to convert a quantity value from one unit to another within the specified target quantity information.
+    /// </summary>
+    /// <param name="sourceUnit">The source unit information.</param>
+    /// <param name="sourceValue">The value in the source unit to be converted.</param>
+    /// <param name="targetQuantityInfo">The target quantity information to which the value should be converted.</param>
+    /// <param name="result">
+    ///     When this method returns, contains the converted quantity if the conversion succeeded, or <c>null</c> if the
+    ///     conversion failed.
+    ///     This parameter is passed uninitialized.
+    /// </param>
+    /// <returns><c>true</c> if the conversion succeeded; otherwise, <c>false</c>.</returns>
+    internal static bool TryConvertFrom(this QuantityInfo targetQuantityInfo, QuantityValue sourceValue,
+        UnitInfo sourceUnit, [NotNullWhen(true)] out IQuantity? result)
+    {
+        ConvertValueDelegate conversionExpression;
+        QuantityInfo sourceQuantityInfo = sourceUnit.QuantityInfo;
+        if (sourceQuantityInfo.BaseDimensions.IsInverseOf(targetQuantityInfo.BaseDimensions))
+        {
+            conversionExpression = QuantityValue.Inverse;
+        }
+        else if (sourceQuantityInfo.BaseDimensions == targetQuantityInfo.BaseDimensions)
+        {
+            if (targetQuantityInfo.BaseDimensions.IsDimensionless())
+            {
+                QuantityValue dimensionlessValue = sourceUnit.ConvertValueToBaseUnit(sourceValue);
+                result = targetQuantityInfo.BaseUnitInfo.From(dimensionlessValue);
+                return true;
+            }
+
+            conversionExpression = value => value;
+        }
+        else
+        {
+            result = null;
+            return false;
+        }
+
+        UnitInfo sourceBaseUnit = sourceQuantityInfo.BaseUnitInfo;
+        if (sourceUnit.BaseUnits != BaseUnits.Undefined && sourceUnit.BaseUnits != sourceBaseUnit.BaseUnits)
+        {
+            if (targetQuantityInfo.UnitInfos.TryGetUnitWithBase(sourceUnit.BaseUnits, out UnitInfo? targetUnit))
+            {
+                result = targetUnit.From(conversionExpression(sourceValue));
+                return true;
+            }
+        }
+
+        if (sourceBaseUnit.BaseUnits != BaseUnits.Undefined)
+        {
+            // attempt to convert via the base (typically SI) unit
+            if (targetQuantityInfo.BaseUnitInfo.BaseUnits == sourceBaseUnit.BaseUnits)
+            {
+                QuantityValue convertedValue = conversionExpression(sourceUnit.ConvertValueToBaseUnit(sourceValue));
+                result = targetQuantityInfo.BaseUnitInfo.From(convertedValue);
+                return true;
+            }
+
+            // attempt to find another unit that matches the source base
+            if (targetQuantityInfo.UnitInfos.TryGetUnitWithBase(sourceBaseUnit.BaseUnits, out UnitInfo? targetUnit))
+            {
+                QuantityValue convertedValue = conversionExpression(sourceUnit.ConvertValueToBaseUnit(sourceValue));
+                result = targetUnit.From(convertedValue);
+                return true;
+            }
+        }
+
+        // no compatible units found with either the sourceUnit or the sourceBaseUnit: looking for intersections with any of the other units
+        IReadOnlyList<UnitInfo> sourceUnits = sourceQuantityInfo.UnitInfos;
+        var nbSourceUnits = sourceUnits.Count;
+        for (var i = 0; i < nbSourceUnits; i++)
+        {
+            UnitInfo otherUnit = sourceUnits[i];
+            if (otherUnit.BaseUnits == BaseUnits.Undefined ||
+                otherUnit.BaseUnits == sourceUnit.BaseUnits ||
+                otherUnit.BaseUnits == sourceBaseUnit.BaseUnits)
+            {
+                continue;
+            }
+
+            if (targetQuantityInfo.UnitInfos.TryGetUnitWithBase(otherUnit.BaseUnits, out UnitInfo? targetUnit))
+            {
+                QuantityValue convertedValue = conversionExpression(otherUnit.GetValueFrom(sourceValue, sourceUnit));
+                result = targetUnit.From(convertedValue);
+                return true;
+            }
+        }
+
+        result = null;
+        return false;
+    }
+
+    /// <summary>
+    ///     Converts a quantity value from a source unit to a target quantity.
+    /// </summary>
+    /// <param name="targetQuantityInfo">The target quantity information.</param>
+    /// <param name="sourceValue">The value of the source quantity.</param>
+    /// <param name="sourceUnit">The unit of the source quantity.</param>
+    /// <returns>The converted quantity.</returns>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when the dimensions of the source quantity are not compatible with the dimensions of the target quantity,
+    ///     or when no compatible base units are found for the conversion.
+    /// </exception>
+    internal static IQuantity ConvertFrom(this QuantityInfo targetQuantityInfo, QuantityValue sourceValue, UnitInfo sourceUnit)
+    {
+        if(targetQuantityInfo.TryConvertFrom(sourceValue, sourceUnit, out IQuantity? convertedValue))
+        {
+            return convertedValue;
+        }
+
+        QuantityInfo sourceQuantityInfo = sourceUnit.QuantityInfo;
+        if (sourceQuantityInfo.BaseDimensions != targetQuantityInfo.BaseDimensions &&
+            !sourceQuantityInfo.BaseDimensions.IsInverseOf(targetQuantityInfo.BaseDimensions))
+        {
+            throw InvalidConversionException.CreateIncompatibleDimensionsException(sourceQuantityInfo, targetQuantityInfo);
+        }
+
+        throw InvalidConversionException.CreateIncompatibleUnitsException(sourceUnit, targetQuantityInfo);
+    }
+
+    internal static bool IsInverseOf(this BaseDimensions first, BaseDimensions second)
+    {
+        if (first.Amount != -second.Amount)
+        {
+            return false;
+        }
+
+        if (first.Current != -second.Current)
+        {
+            return false;
+        }
+
+        if (first.Length != -second.Length)
+        {
+            return false;
+        }
+
+        if (first.Mass != -second.Mass)
+        {
+            return false;
+        }
+
+        if (first.LuminousIntensity != -second.LuminousIntensity)
+        {
+            return false;
+        }
+
+        if (first.Temperature != -second.Temperature)
+        {
+            return false;
+        }
+
+        if (first.Time != -second.Time)
+        {
+            return false;
+        }
+
+        return !first.IsDimensionless();
+    }
 }
diff --git a/UnitsNet/CustomCode/QuantityInfo/Units/ConversionExpression.cs b/UnitsNet/CustomCode/QuantityInfo/Units/ConversionExpression.cs
new file mode 100644
index 0000000000..d40c7585c2
--- /dev/null
+++ b/UnitsNet/CustomCode/QuantityInfo/Units/ConversionExpression.cs
@@ -0,0 +1,400 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents a method that converts a <see cref="QuantityValue" />.
+/// </summary>
+/// <param name="sourceValue">The source value to be converted.</param>
+/// <returns>The converted <see cref="QuantityValue" />.</returns>
+public delegate QuantityValue ConvertValueDelegate(QuantityValue sourceValue);
+
+/// <summary>
+///     Represents a conversion function, expressed as an equation of the form:
+///     <code>
+/// f(x) = a * g(x)^n + b
+///     </code>
+///     where:
+///     <c>a</c> and <c>b</c> are constants of type <see cref="QuantityValue" />.
+///     <c>g(x)</c> is an optional custom function applied to the input <c>x</c> (of type <see cref="QuantityValue" />).
+///     <c>n</c> is an integer exponent.
+/// </summary>
+/// <remarks>
+///     Note: In order for the equality contract to work properly, <c>f(x)</c> should be invertible. Irrational functions,
+///     such as <c>sqrt</c>, should be handled with care, ensuring consistent rounding precision is used.
+///     <para>
+///         For all quantities shipped with UnitsNet, <c>g(x)</c> defaults to <c>x</c> and the exponent <c>n</c> is either
+///         1 or -1.
+///     </para>
+///     <para>
+///         Conversions from degrees to radians are currently handled using an approximation of PI to the 16th digit.
+///     </para>
+/// </remarks>
+public readonly record struct ConversionExpression
+{
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="ConversionExpression" /> struct.
+    /// </summary>
+    /// <param name="coefficient">
+    ///     The coefficient <c>a</c> in the conversion equation.
+    /// </param>
+    /// <param name="nestedFunction">
+    ///     An optional custom function <c>g(x)</c> applied to the input.
+    /// </param>
+    /// <param name="exponent">
+    ///     The exponent <c>n</c> in the conversion equation.
+    /// </param>
+    /// <param name="constantTerm">
+    ///     The constant term <c>b</c> in the conversion equation.
+    /// </param>
+    public ConversionExpression(QuantityValue coefficient, ConvertValueDelegate? nestedFunction = null, int exponent = 1, QuantityValue constantTerm = default)
+    {
+        Coefficient = coefficient;
+        Exponent = exponent;
+        ConstantTerm = constantTerm;
+        NestedFunction = nestedFunction;
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitsNet.ConversionExpression" /> struct with the specified
+    ///     coefficient and constant term.
+    /// </summary>
+    /// <param name="coefficient">The coefficient <c>a</c> in the conversion equation.</param>
+    /// <param name="constantTerm">The constant term <c>b</c> in the conversion equation.</param>
+    public ConversionExpression(QuantityValue coefficient, QuantityValue constantTerm)
+        : this(coefficient, null, 1, constantTerm)
+    {
+    }
+
+    /// <summary>
+    ///     Gets the coefficient <c>a</c> in the conversion expression.
+    /// </summary>
+    /// <value>
+    ///     The coefficient <c>a</c> of type <see cref="QuantityValue" />.
+    /// </value>
+    /// <remarks>
+    ///     This coefficient is used in the conversion function:
+    ///     <code>
+    /// f(x) = a * g(x)^n + b
+    /// </code>
+    /// </remarks>
+    public QuantityValue Coefficient { get; }
+
+    /// <summary>
+    ///     Gets an optional custom function applied to the input <see cref="QuantityValue" />.
+    /// </summary>
+    /// <remarks>
+    ///     This function, if provided, is represented as <c>g(x)</c> in the conversion equation:
+    ///     <code>
+    /// f(x) = a * g(x)^n + b
+    /// </code>
+    ///     where <c>a</c> and <c>b</c> are constants, and <c>n</c> is an integer exponent.
+    ///     If the function is not specified, <c>g(x)</c> defaults to <c>x</c>.
+    /// </remarks>
+    public ConvertValueDelegate? NestedFunction { get; }
+
+    /// <summary>
+    ///     Gets the integer exponent <c>n</c> in the conversion function equation.
+    /// </summary>
+    /// <remarks>
+    ///     The exponent is used in the equation:
+    ///     <code>
+    /// f(x) = a * g(x)^n + b
+    /// </code>
+    ///     where <c>n</c> is the exponent applied to the optional custom function <c>g(x)</c>.
+    /// </remarks>
+    public int Exponent { get; }
+
+    /// <summary>
+    ///     Gets the constant term <c>b</c> in the conversion expression equation.
+    /// </summary>
+    /// <value>
+    ///     The constant term of type <see cref="QuantityValue" />.
+    /// </value>
+    /// <remarks>
+    ///     This term represents the constant offset added to the result of the conversion function.
+    /// </remarks>
+    public QuantityValue ConstantTerm { get; }
+
+    /// <summary>
+    ///     Evaluates the conversion expression for a given input value.
+    /// </summary>
+    /// <param name="value">The input value to be converted.</param>
+    /// <returns>The result of the conversion expression.</returns>
+    /// <remarks>
+    ///     The conversion expression is evaluated as:
+    ///     <code>
+    /// f(x) = a * g(x)^n + b
+    /// </code>
+    ///     where:
+    ///     <list type="bullet">
+    ///         <item>
+    ///             <description><c>a</c> is the <see cref="Coefficient" />.</description>
+    ///         </item>
+    ///         <item>
+    ///             <description>
+    ///                 <c>g(x)</c> is the <see cref="NestedFunction" /> applied to the input
+    ///                 <paramref name="value" />.
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <description><c>n</c> is the <see cref="Exponent" />.</description>
+    ///         </item>
+    ///         <item>
+    ///             <description><c>b</c> is the <see cref="ConstantTerm" />.</description>
+    ///         </item>
+    ///     </list>
+    ///     If <see cref="NestedFunction" /> is null, <c>g(x)</c> defaults to <paramref name="value" />.
+    /// </remarks>
+    public QuantityValue Evaluate(QuantityValue value)
+    {
+        QuantityValue x = NestedFunction?.Invoke(value) ?? value;
+        return Exponent switch
+        {
+            1 => Coefficient * x + ConstantTerm,
+            -1 => Coefficient * QuantityValue.Inverse(x) + ConstantTerm,
+            _ => Coefficient * QuantityValue.Pow(x, Exponent) + ConstantTerm
+        };
+    }
+
+    /// <summary>
+    ///     Evaluates the current <see cref="ConversionExpression" /> using the specified intermediate expression.
+    /// </summary>
+    /// <param name="intermediateExpression">The intermediate <see cref="ConversionExpression" /> to be evaluated.</param>
+    /// <param name="reduceConstants">
+    ///     A boolean value indicating whether to reduce constants during the evaluation.
+    ///     If true, the constants in the expressions will be reduced.
+    /// </param>
+    /// <returns>A new <see cref="ConversionExpression" /> that represents the result of the evaluation.</returns>
+    /// <remarks>
+    ///     The evaluation combines the coefficients, constant terms, and exponents of the current and intermediate
+    ///     expressions.
+    ///     If either expression has a nested function, the resulting expression will include a nested function that combines
+    ///     them.
+    /// </remarks>
+    public ConversionExpression Evaluate(ConversionExpression intermediateExpression, bool reduceConstants = false)
+    {
+        if (NestedFunction is { } thisNestedFunction)
+        {
+            return new ConversionExpression(Coefficient, value => thisNestedFunction(intermediateExpression.Evaluate(value)), Exponent, ConstantTerm);
+        }
+
+        if (reduceConstants)
+        {
+            return Exponent switch
+            {
+                1 => new ConversionExpression(QuantityValue.Reduce(Coefficient * intermediateExpression.Coefficient), intermediateExpression.NestedFunction,
+                    intermediateExpression.Exponent, QuantityValue.Reduce(ConstantTerm + Coefficient * intermediateExpression.ConstantTerm)),
+                -1 when intermediateExpression.ConstantTerm == QuantityValue.Zero => new ConversionExpression(
+                    QuantityValue.Reduce(Coefficient * QuantityValue.Inverse(intermediateExpression.Coefficient)), intermediateExpression.NestedFunction,
+                    -intermediateExpression.Exponent,
+                    ConstantTerm),
+                _ => new ConversionExpression(Coefficient, intermediateExpression.Evaluate, Exponent, ConstantTerm)
+            };
+        }
+
+        return Exponent switch
+        {
+            1 => new ConversionExpression(Coefficient * intermediateExpression.Coefficient, intermediateExpression.NestedFunction,
+                intermediateExpression.Exponent, ConstantTerm + Coefficient * intermediateExpression.ConstantTerm),
+            -1 when intermediateExpression.ConstantTerm == QuantityValue.Zero => new ConversionExpression(
+                Coefficient * QuantityValue.Inverse(intermediateExpression.Coefficient), intermediateExpression.NestedFunction,
+                -intermediateExpression.Exponent,
+                ConstantTerm),
+            _ => new ConversionExpression(Coefficient, intermediateExpression.Evaluate, Exponent, ConstantTerm)
+        };
+    }
+
+    /// <summary>
+    ///     Implicitly converts a <see cref="QuantityValue" /> to a <see cref="ConversionExpression" />.
+    /// </summary>
+    /// <param name="coefficient">The coefficient of type <see cref="QuantityValue" /> to be converted.</param>
+    /// <returns>A new instance of <see cref="ConversionExpression" /> initialized with the specified coefficient.</returns>
+    public static implicit operator ConversionExpression(QuantityValue coefficient)
+    {
+        return new ConversionExpression(coefficient);
+    }
+
+    /// <summary>
+    ///     Implicitly converts a <see cref="QuantityValue" /> to a <see cref="ConversionExpression" />.
+    /// </summary>
+    /// <param name="coefficient">The coefficient of type <see cref="QuantityValue" /> to be converted.</param>
+    /// <returns>A new instance of <see cref="ConversionExpression" /> initialized with the specified coefficient.</returns>
+    public static implicit operator ConversionExpression(int coefficient)
+    {
+        return new ConversionExpression(coefficient);
+    }
+
+    /// <summary>
+    ///     Implicitly converts a <see cref="QuantityValue" /> to a <see cref="ConversionExpression" />.
+    /// </summary>
+    /// <param name="coefficient">The coefficient of type <see cref="QuantityValue" /> to be converted.</param>
+    /// <returns>A new instance of <see cref="ConversionExpression" /> initialized with the specified coefficient.</returns>
+    public static implicit operator ConversionExpression(long coefficient)
+    {
+        return new ConversionExpression(coefficient);
+    }
+
+    /// <summary>
+    ///     Implicitly converts a <see cref="ConversionExpression" /> to a <see cref="Func{QuantityValue,QuantityValue}" />.
+    /// </summary>
+    /// <param name="expression">The <see cref="ConversionExpression" /> to convert.</param>
+    /// <returns>
+    ///     A function that takes a <see cref="QuantityValue" /> and returns a <see cref="QuantityValue" /> based on the
+    ///     conversion expression.
+    /// </returns>
+    public static implicit operator ConvertValueDelegate(ConversionExpression expression)
+    {
+        QuantityValue coefficient = expression.Coefficient;
+        var exponent = expression.Exponent;
+        ConvertValueDelegate? nestedFunction = expression.NestedFunction;
+        QuantityValue constantTerm = expression.ConstantTerm;
+        switch (exponent)
+        {
+            case 1:
+            {
+                if (nestedFunction is null)
+                {
+                    if (coefficient == QuantityValue.One)
+                    {
+                        // scaleFunction = value => value;
+                        return constantTerm == QuantityValue.Zero ? value => value : value => value + constantTerm;
+                    }
+
+                    // scaleFunction = value => value * coefficient;
+                    return constantTerm == QuantityValue.Zero
+                        ? value => value * coefficient
+                        : value => value * coefficient + constantTerm;
+                }
+
+                if (coefficient == QuantityValue.One)
+                {
+                    // scaleFunction = nestedFunction;
+                    return constantTerm == QuantityValue.Zero
+                        ? nestedFunction
+                        : value => nestedFunction(value) + constantTerm;
+                }
+
+                // scaleFunction = value => nestedFunction(value) * coefficient;
+                return constantTerm == QuantityValue.Zero
+                    ? value => nestedFunction(value) * coefficient
+                    : value => nestedFunction(value) * coefficient + constantTerm;
+            }
+            case -1:
+            {
+                if (nestedFunction is null)
+                {
+                    if (coefficient == QuantityValue.One)
+                    {
+                        // scaleFunction = QuantityValue.Inverse;
+                        return constantTerm == QuantityValue.Zero ? QuantityValue.Inverse : value => QuantityValue.Inverse(value) + constantTerm;
+                    }
+
+                    // scaleFunction = value => QuantityValue.Inverse(value) * coefficient;
+                    return constantTerm == QuantityValue.Zero
+                        ? value => QuantityValue.Inverse(value) * coefficient
+                        : value => QuantityValue.Inverse(value) * coefficient + constantTerm;
+                }
+
+                if (coefficient == QuantityValue.One)
+                {
+                    // scaleFunction = QuantityValue.Inverse(expression.NestedFunction);
+                    return constantTerm == QuantityValue.Zero
+                        ? value => QuantityValue.Inverse(nestedFunction(value))
+                        : value => QuantityValue.Inverse(nestedFunction(value)) + constantTerm;
+                }
+
+                // scaleFunction = value => QuantityValue.Inverse(nestedFunction(value)) * coefficient;
+                return constantTerm == QuantityValue.Zero
+                    ? value => QuantityValue.Inverse(nestedFunction(value)) * coefficient
+                    : value => QuantityValue.Inverse(nestedFunction(value)) * coefficient + constantTerm;
+            }
+            default:
+            {
+                if (nestedFunction is null)
+                {
+                    if (coefficient == QuantityValue.One)
+                    {
+                        // scaleFunction = value => QuantityValue.Pow(value, exponent);
+                        return constantTerm == QuantityValue.Zero
+                            ? value => QuantityValue.Pow(value, exponent)
+                            : value => QuantityValue.Pow(value, exponent) + constantTerm;
+                    }
+
+                    // scaleFunction = value => QuantityValue.Pow(value, exponent) * coefficient;
+                    return constantTerm == QuantityValue.Zero
+                        ? value => QuantityValue.Pow(value, exponent) * coefficient
+                        : value => QuantityValue.Pow(value, exponent) * coefficient + constantTerm;
+                }
+
+                if (coefficient == QuantityValue.One)
+                {
+                    // scaleFunction = QuantityValue.Pow(nestedFunction, exponent);
+                    return constantTerm == QuantityValue.Zero
+                        ? value => QuantityValue.Pow(nestedFunction(value), exponent)
+                        : value => QuantityValue.Pow(nestedFunction(value), exponent) + constantTerm;
+                }
+
+                // scaleFunction = value => QuantityValue.Pow(nestedFunction(value), exponent) * coefficient;
+                return constantTerm == QuantityValue.Zero
+                    ? value => QuantityValue.Pow(nestedFunction(value), exponent) * coefficient
+                    : value => QuantityValue.Pow(nestedFunction(value), exponent) * coefficient + constantTerm;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Negates the given <see cref="ConversionExpression" />.
+    /// </summary>
+    /// <param name="expression">The <see cref="ConversionExpression" /> to negate.</param>
+    /// <returns>A new <see cref="ConversionExpression" /> with negated values.</returns>
+    public static ConversionExpression operator -(ConversionExpression expression)
+    {
+        return new ConversionExpression(-expression.Coefficient, expression.NestedFunction, expression.Exponent, -expression.ConstantTerm);
+    }
+
+    #region ToString
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        var x = NestedFunction is null ? "x" : "g(x)";
+        var coefficient = Coefficient.ToString(CultureInfo.InvariantCulture);
+        var firstTerm = Exponent switch
+        {
+            1 => Coefficient == QuantityValue.One ? x : Coefficient == -1 ? $"-{x}" : $"{coefficient} * {x}",
+            -1 => Coefficient == QuantityValue.One ? $"1 / {x}" : Coefficient == -1 ? $"-1 / {x}" : $"{coefficient} / {x}",
+            _ => Coefficient == QuantityValue.One ? $"{x}^{Exponent}" : Coefficient == -1 ? $"-{x}^{Exponent}" : $"{coefficient} * {x}^{Exponent}"
+        };
+
+        if (ConstantTerm == QuantityValue.Zero)
+        {
+            return firstTerm;
+        }
+
+        QuantityValue absoluteConstantTerm = QuantityValue.Abs(ConstantTerm);
+        return ConstantTerm > 0
+            ? firstTerm + " + " + absoluteConstantTerm.ToString(CultureInfo.InvariantCulture)
+            : firstTerm + " - " + absoluteConstantTerm.ToString(CultureInfo.InvariantCulture);
+    }
+
+    private bool PrintMembers(StringBuilder builder)
+    {
+        builder.Append($"Coefficient = {Coefficient}, ");
+        builder.Append($"Exponent = {Exponent}, ");
+        builder.Append($"ConstantTerm = {ConstantTerm}");
+        if (NestedFunction != null)
+        {
+            builder.Append($", NestedFunction = {NestedFunction.Method.Name}");
+        }
+
+        return true;
+    }
+
+    #endregion
+}
diff --git a/UnitsNet/CustomCode/QuantityInfo/Units/UnitDefinition.cs b/UnitsNet/CustomCode/QuantityInfo/Units/UnitDefinition.cs
index 4919be5115..f0af1cdbbd 100644
--- a/UnitsNet/CustomCode/QuantityInfo/Units/UnitDefinition.cs
+++ b/UnitsNet/CustomCode/QuantityInfo/Units/UnitDefinition.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -26,6 +26,33 @@ public UnitDefinition(TUnit value, string pluralName, BaseUnits baseUnits)
     /// <summary>
     ///     Initializes a new instance of the <see cref="UnitDefinition{TUnit}" /> class.
     /// </summary>
+    /// <param name="value">The enum value for this unit, for example <see cref="LengthUnit.Meter" />.</param>
+    /// <param name="pluralName">The plural name of the unit, such as "Centimeters".</param>
+    /// <param name="baseUnits">The <see cref="BaseUnits" /> for this unit.</param>
+    /// <param name="conversionFromBase">The conversion expression from the base unit to this unit.</param>
+    /// <param name="conversionToBase">The conversion expression from this unit to the base unit.</param>
+    public UnitDefinition(TUnit value, string pluralName, BaseUnits baseUnits,
+        ConversionExpression conversionFromBase,
+        ConversionExpression conversionToBase)
+        : this(value, value.ToString(), pluralName, baseUnits, conversionFromBase, conversionToBase)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitDefinition{TUnit}" /> class.
+    /// </summary>
+    /// <param name="value">The enum value for this unit, for example <see cref="LengthUnit.Meter" />.</param>
+    /// <param name="pluralName">The plural name of the unit, such as "Centimeters".</param>
+    /// <param name="baseUnits">The <see cref="BaseUnits" /> for this unit.</param>
+    /// <param name="conversionFromBase">The conversion coefficient from the base unit to this unit.</param>
+    public UnitDefinition(TUnit value, string pluralName, BaseUnits baseUnits, QuantityValue conversionFromBase)
+        : this(value, value.ToString(), pluralName, baseUnits, conversionFromBase)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitDefinition{TUnit}" /> class for the base unit.
+    /// </summary>
     /// <param name="value">The enum value representing the unit, for example <see cref="LengthUnit.Meter" />.</param>
     /// <param name="singularName">The singular name of the unit, such as "Centimeter".</param>
     /// <param name="pluralName">The plural name of the unit, such as "Centimeters".</param>
@@ -35,11 +62,50 @@ public UnitDefinition(TUnit value, string pluralName, BaseUnits baseUnits)
     ///     <paramref name="baseUnits" /> is <c>null</c>.
     /// </exception>
     public UnitDefinition(TUnit value, string singularName, string pluralName, BaseUnits baseUnits)
+        : this(value, singularName, pluralName, baseUnits, QuantityValue.One, QuantityValue.One)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitDefinition{TUnit}" /> class.
+    /// </summary>
+    /// <param name="value">The enum value representing the unit, for example <see cref="LengthUnit.Meter" />.</param>
+    /// <param name="singularName">The singular name of the unit, such as "Centimeter".</param>
+    /// <param name="pluralName">The plural name of the unit, such as "Centimeters".</param>
+    /// <param name="baseUnits">The <see cref="BaseUnits" /> associated with this unit.</param>
+    /// <param name="conversionFromBase">The conversion coefficient from the base unit to this unit.</param>
+    /// <exception cref="ArgumentNullException">
+    ///     Thrown when <paramref name="value" />, <paramref name="singularName" />, <paramref name="pluralName" />, or
+    ///     <paramref name="baseUnits" /> is <c>null</c>.
+    /// </exception>
+    public UnitDefinition(TUnit value, string singularName, string pluralName, BaseUnits baseUnits, QuantityValue conversionFromBase)
+        : this(value, singularName, pluralName, baseUnits, conversionFromBase, QuantityValue.Inverse(conversionFromBase))
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="UnitDefinition{TUnit}" /> class.
+    /// </summary>
+    /// <param name="value">The enum value representing the unit, for example <see cref="LengthUnit.Meter" />.</param>
+    /// <param name="singularName">The singular name of the unit, such as "Centimeter".</param>
+    /// <param name="pluralName">The plural name of the unit, such as "Centimeters".</param>
+    /// <param name="baseUnits">The <see cref="BaseUnits" /> associated with this unit.</param>
+    /// <param name="conversionFromBase">The conversion expression from the base unit to this unit.</param>
+    /// <param name="conversionToBase">The conversion expression from this unit to the base unit.</param>
+    /// <exception cref="ArgumentNullException">
+    ///     Thrown when <paramref name="value" />, <paramref name="singularName" />, <paramref name="pluralName" />, or
+    ///     <paramref name="baseUnits" /> is <c>null</c>.
+    /// </exception>
+    public UnitDefinition(TUnit value, string singularName, string pluralName, BaseUnits baseUnits,
+        ConversionExpression conversionFromBase,
+        ConversionExpression conversionToBase)
     {
         Value = value;
         Name = singularName ?? throw new ArgumentNullException(nameof(singularName));
         PluralName = pluralName ?? throw new ArgumentNullException(nameof(pluralName));
         BaseUnits = baseUnits ?? throw new ArgumentNullException(nameof(baseUnits));
+        ConversionFromBase = conversionFromBase;
+        ConversionToBase = conversionToBase;
     }
 
     /// <summary>
@@ -61,4 +127,10 @@ public UnitDefinition(TUnit value, string singularName, string pluralName, BaseU
     ///     Gets the <see cref="BaseUnits" /> for this unit.
     /// </summary>
     public BaseUnits BaseUnits { get; }
+
+    /// <inheritdoc />
+    public ConversionExpression ConversionFromBase { get; }
+
+    /// <inheritdoc />
+    public ConversionExpression ConversionToBase { get; }
 }
diff --git a/UnitsNet/CustomCode/QuantityInfo/Units/UnitEqualityComparer.cs b/UnitsNet/CustomCode/QuantityInfo/Units/UnitEqualityComparer.cs
index 99f99e8c20..18caf848b7 100644
--- a/UnitsNet/CustomCode/QuantityInfo/Units/UnitEqualityComparer.cs
+++ b/UnitsNet/CustomCode/QuantityInfo/Units/UnitEqualityComparer.cs
@@ -1,4 +1,4 @@
-#if NETSTANDARD2_0
+#if NETSTANDARD2_0
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
diff --git a/UnitsNet/CustomCode/QuantityParser.cs b/UnitsNet/CustomCode/QuantityParser.cs
index d542a2e59f..ff9b2ee4db 100644
--- a/UnitsNet/CustomCode/QuantityParser.cs
+++ b/UnitsNet/CustomCode/QuantityParser.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Globalization;
@@ -17,7 +17,7 @@ namespace UnitsNet;
 ///     The type of unit enum that belongs to this quantity, such as <see cref="LengthUnit" /> for
 ///     <see cref="Length" />.
 /// </typeparam>
-public delegate TQuantity QuantityFromDelegate<out TQuantity, in TUnitType>(double value, TUnitType fromUnit)
+public delegate TQuantity QuantityFromDelegate<out TQuantity, in TUnitType>(QuantityValue value, TUnitType fromUnit)
     where TQuantity : IQuantity
     where TUnitType : struct, Enum;
 
@@ -200,7 +200,7 @@ private TQuantity ParseWithRegex<TQuantity, TUnitType>(string valueString, strin
         where TQuantity : IQuantity
         where TUnitType : struct, Enum
     {
-        var value = double.Parse(valueString, ParseNumberStyles, formatProvider);
+        var value = QuantityValue.Parse(valueString, ParseNumberStyles, formatProvider);
         TUnitType parsedUnit = _unitParser.Parse<TUnitType>(unitString, formatProvider);
         return fromDelegate(value, parsedUnit);
     }
@@ -211,7 +211,7 @@ private TQuantity ParseWithRegex<TQuantity, TUnitType>(string valueString, strin
     /// <exception cref="UnitsNetException">Error parsing string.</exception>
     private IQuantity ParseWithRegex(string valueString, string unitString, IReadOnlyList<UnitInfo> units, IFormatProvider? formatProvider)
     {
-        var value = double.Parse(valueString, ParseNumberStyles, formatProvider);
+        var value = QuantityValue.Parse(valueString, ParseNumberStyles, formatProvider);
         UnitInfo unitInfo = _unitParser.Parse(unitString, units, formatProvider);
         return unitInfo.From(value);
     }
@@ -227,7 +227,7 @@ private bool TryParseWithRegex<TQuantity, TUnitType>(string? valueString, string
     {
         result = default;
 
-        if (!double.TryParse(valueString, ParseNumberStyles, formatProvider, out var value))
+        if (!QuantityValue.TryParse(valueString, ParseNumberStyles, formatProvider, out QuantityValue value))
         {
             return false;
         }
@@ -250,7 +250,7 @@ private bool TryParseWithRegex(string? valueString, string? unitString, IReadOnl
     {
         result = null;
 
-        if (!double.TryParse(valueString, ParseNumberStyles, formatProvider, out var value))
+        if (!QuantityValue.TryParse(valueString, ParseNumberStyles, formatProvider, out QuantityValue value))
         {
             return false;
         }
diff --git a/UnitsNet/CustomCode/UnitAbbreviationsCache.cs b/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
index 073cb50f03..9650f09bb2 100644
--- a/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
+++ b/UnitsNet/CustomCode/UnitAbbreviationsCache.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Collections.Concurrent;
@@ -85,6 +85,27 @@ public static UnitAbbreviationsCache CreateDefault()
             return new UnitAbbreviationsCache();
         }
 
+        /// <summary>
+        ///     Creates a cache for the built-in quantities and any additions made by <paramref name="configureQuantities" />.
+        /// </summary>
+        /// <param name="configureQuantities">Configures the selected quantities.</param>
+        /// <returns>A cache mapped to the configured quantity selection.</returns>
+        public static UnitAbbreviationsCache CreateDefault(Action<QuantitiesSelector> configureQuantities)
+        {
+            return Create(Quantity.DefaultProvider.Quantities, configureQuantities);
+        }
+
+        /// <summary>
+        ///     Creates a cache for a configured selection based on <paramref name="defaultQuantities" />.
+        /// </summary>
+        /// <param name="defaultQuantities">The initial quantity definitions.</param>
+        /// <param name="configureQuantities">Configures the selected quantities.</param>
+        /// <returns>A cache mapped to the configured quantity selection.</returns>
+        public static UnitAbbreviationsCache Create(IEnumerable<QuantityInfo> defaultQuantities, Action<QuantitiesSelector> configureQuantities)
+        {
+            return new UnitAbbreviationsCache(QuantityInfoLookup.Create(defaultQuantities, configureQuantities));
+        }
+
         #region MapUnitToAbbreviation overloads
 
         /// <summary>
@@ -105,7 +126,7 @@ public void MapUnitToAbbreviation<TUnitType>(TUnitType unit, params IEnumerable<
             MapUnitToAbbreviation(UnitKey.ForUnit(unit), abbreviations);
         }
 
-        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>>
+        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>
         /// <param name="unitType">The unit enum type.</param>
         /// <param name="unitValue">The unit enum value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
@@ -121,7 +142,7 @@ public void MapUnitToAbbreviation(Type unitType, int unitValue, IFormatProvider?
             MapUnitToAbbreviation(UnitKey.Create(unitType, unitValue), formatProvider, abbreviations);
         }
 
-        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>>
+        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>
         /// <param name="unitKey">The unit key value.</param>
         /// <param name="abbreviations">Unit abbreviations to add.</param>
         public void MapUnitToAbbreviation(UnitKey unitKey, params IEnumerable<string> abbreviations)
@@ -129,7 +150,7 @@ public void MapUnitToAbbreviation(UnitKey unitKey, params IEnumerable<string> ab
             MapUnitToAbbreviation(unitKey, CultureInfo.CurrentCulture, abbreviations);
         }
 
-        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>>
+        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>
         /// <param name="unit">The unit enum value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="abbreviations">Unit abbreviations to add.</param>
@@ -140,13 +161,22 @@ public void MapUnitToAbbreviation<TUnitType>(TUnitType unit, IFormatProvider? fo
             MapUnitToAbbreviation(UnitKey.ForUnit(unit), formatProvider, abbreviations);
         }
         
-        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>>
+        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>
         /// <param name="unitKey">The unit key value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="abbreviations">Unit abbreviations to add.</param>
         public void MapUnitToAbbreviation(UnitKey unitKey, IFormatProvider? formatProvider, params IEnumerable<string> abbreviations)
         {
-            PerformAbbreviationMapping(unitKey, formatProvider, false, abbreviations);
+            MapUnitToAbbreviation(Quantities.GetUnitInfo(unitKey), formatProvider, abbreviations);
+        }
+
+        /// <inheritdoc cref="MapUnitToAbbreviation{TUnitType}(TUnitType,IEnumerable{string})"/>
+        /// <param name="unitInfo">The info representing the unit.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="abbreviations">Unit abbreviations to add.</param>
+        public void MapUnitToAbbreviation(UnitInfo unitInfo, IFormatProvider? formatProvider, params IEnumerable<string> abbreviations)
+        {
+            AddAbbreviation(GetConfiguredUnitInfo(unitInfo), formatProvider, false, abbreviations);
         }
 
         #endregion
@@ -171,7 +201,7 @@ public void MapUnitToDefaultAbbreviation<TUnitType>(TUnitType unit, string abbre
             MapUnitToDefaultAbbreviation(UnitKey.ForUnit(unit), abbreviation);
         }
 
-        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>>
+        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>
         /// <param name="unitKey">The unit key value.</param>
         /// <param name="abbreviation">Unit abbreviations to add as default.</param>
         public void MapUnitToDefaultAbbreviation(UnitKey unitKey, string abbreviation)
@@ -179,7 +209,7 @@ public void MapUnitToDefaultAbbreviation(UnitKey unitKey, string abbreviation)
             MapUnitToDefaultAbbreviation(unitKey, CultureInfo.CurrentCulture, abbreviation);
         }
 
-        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>>
+        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>
         /// <param name="unit">The unit enum value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="abbreviation">Unit abbreviation to add as default.</param>
@@ -190,7 +220,7 @@ public void MapUnitToDefaultAbbreviation<TUnitType>(TUnitType unit, IFormatProvi
             MapUnitToDefaultAbbreviation(UnitKey.ForUnit(unit), formatProvider, abbreviation);
         }
 
-        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>>
+        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>
         /// <param name="unitType">The unit enum type.</param>
         /// <param name="unitValue">The unit enum value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
@@ -206,22 +236,26 @@ public void MapUnitToDefaultAbbreviation(Type unitType, int unitValue, IFormatPr
             MapUnitToDefaultAbbreviation(UnitKey.Create(unitType, unitValue), formatProvider, abbreviation);
         }
 
-        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>>
+        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>
         /// <param name="unitKey">The unit key value.</param>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="abbreviation">Unit abbreviation to add as default.</param>
         public void MapUnitToDefaultAbbreviation(UnitKey unitKey, IFormatProvider? formatProvider, string abbreviation)
         {
-            PerformAbbreviationMapping(unitKey, formatProvider, true, abbreviation);
+            MapUnitToDefaultAbbreviation(Quantities.GetUnitInfo(unitKey), formatProvider, abbreviation);
         }
 
-        #endregion
-
-        private void PerformAbbreviationMapping(UnitKey unitKey, IFormatProvider? formatProvider, bool setAsDefault, params IEnumerable<string> abbreviations)
+        /// <inheritdoc cref="MapUnitToDefaultAbbreviation{TUnitType}(TUnitType,string)"/>
+        /// <param name="unitInfo">The info representing the unit.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="abbreviation">Unit abbreviation to add as default.</param>
+        public void MapUnitToDefaultAbbreviation(UnitInfo unitInfo, IFormatProvider? formatProvider, string abbreviation)
         {
-            AddAbbreviation(Quantities.GetUnitInfo(unitKey), formatProvider, setAsDefault, abbreviations);
+            AddAbbreviation(GetConfiguredUnitInfo(unitInfo), formatProvider, true, abbreviation);
         }
-        
+
+        #endregion
+
         /// <summary>
         ///     Gets the default abbreviation for a given unit type and its numeric enum value.
         ///     If a unit has more than one abbreviation defined, then it returns the first one.
@@ -282,10 +316,49 @@ public string GetDefaultAbbreviation(Type unitType, int unitValue, IFormatProvid
         /// </exception>
         public string GetDefaultAbbreviation(UnitKey unitKey, IFormatProvider? formatProvider = null)
         {
-            IReadOnlyList<string> abbreviations = GetUnitAbbreviations(unitKey, formatProvider);
+            return GetDefaultAbbreviation(Quantities.GetUnitInfo(unitKey), formatProvider);
+        }
+
+        /// <inheritdoc cref="GetDefaultAbbreviation{TUnitType}" />
+        /// <param name="quantityName">The invariant quantity name, such as "Length". This parameter does not support localization.</param>
+        /// <param name="unitName">The invariant unit name, such as "Meter". This parameter does not support localization.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <exception cref="ArgumentNullException">
+        ///     Thrown when <paramref name="quantityName" /> or <paramref name="unitName" /> is null.
+        /// </exception>
+        /// <exception cref="QuantityNotFoundException">
+        ///     Thrown when no quantity information is found for the specified
+        ///     <paramref name="quantityName" />.
+        /// </exception>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="quantityName" /> and <paramref name="unitName" />.
+        /// </exception>
+        /// <exception cref="InvalidOperationException">
+        ///     Thrown when no abbreviations are mapped for the specified unit.
+        /// </exception>
+        public string GetDefaultAbbreviation(string quantityName, string unitName, IFormatProvider? formatProvider = null)
+        {
+            return GetDefaultAbbreviation(GetConfiguredUnitInfo(quantityName, unitName), formatProvider);
+        }
+
+        /// <inheritdoc cref="GetDefaultAbbreviation{TUnitType}" />
+        /// <param name="unitInfo">The info representing the unit.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="unitInfo" />.
+        /// </exception>
+        /// <exception cref="InvalidOperationException">
+        ///     Thrown when no abbreviations are mapped for the specified unit.
+        /// </exception>
+        public string GetDefaultAbbreviation(UnitInfo unitInfo, IFormatProvider? formatProvider = null)
+        {
+            unitInfo = GetConfiguredUnitInfo(unitInfo);
+            IReadOnlyList<string> abbreviations = GetUnitAbbreviations(unitInfo, formatProvider);
             if (abbreviations.Count == 0)
             {
-                throw new InvalidOperationException($"No abbreviations were found for {unitKey.UnitEnumType.Name}.{(Enum)unitKey}. Make sure that the unit abbreviations are mapped.");
+                throw new InvalidOperationException($"No abbreviations were found for {unitInfo.QuantityInfo.Name}.{unitInfo.Name}. Make sure that the unit abbreviations are mapped.");
             }
 
             return abbreviations[0];
@@ -342,12 +415,51 @@ public IReadOnlyList<string> GetUnitAbbreviations(Type unitType, int unitValue,
         /// </exception>
         public IReadOnlyList<string> GetUnitAbbreviations(UnitKey unitKey, IFormatProvider? formatProvider = null)
         {
+            return GetUnitAbbreviations(Quantities.GetUnitInfo(unitKey), formatProvider);
+        }
+
+        /// <summary>
+        /// Retrieves the unit abbreviations for a specified quantity and unit name with an optional format provider.
+        /// </summary>
+        /// <param name="quantityName">The invariant quantity name, such as "Length". This parameter does not support localization.</param>
+        /// <param name="unitName">The invariant unit name, such as "Meter". This parameter does not support localization.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <returns>A read-only collection of unit abbreviation strings.</returns>
+        /// <exception cref="ArgumentNullException">
+        ///     Thrown when <paramref name="quantityName" /> or <paramref name="unitName" /> is null.
+        /// </exception>
+        /// <exception cref="QuantityNotFoundException">
+        ///     Thrown when no quantity information is found for the specified
+        ///     <paramref name="quantityName" />.
+        /// </exception>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="quantityName" /> and <paramref name="unitName" />.
+        /// </exception>
+        public IReadOnlyList<string> GetUnitAbbreviations(string quantityName, string unitName, IFormatProvider? formatProvider = null)
+        {
+            return GetUnitAbbreviations(GetConfiguredUnitInfo(quantityName, unitName), formatProvider);
+        }
+
+        /// <summary>
+        /// Retrieves the unit abbreviations for a specified unit info and optional format provider.
+        /// </summary>
+        /// <param name="unitInfo">The unit info object representing the unit.</param>
+        /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <returns>A read-only collection of unit abbreviation strings.</returns>
+        /// <exception cref="UnitNotFoundException">
+        ///     Thrown when no unit information is found for the specified
+        ///     <paramref name="unitInfo" />.
+        /// </exception>
+        public IReadOnlyList<string> GetUnitAbbreviations(UnitInfo unitInfo, IFormatProvider? formatProvider = null)
+        {
+            unitInfo = GetConfiguredUnitInfo(unitInfo);
             if (formatProvider is not CultureInfo culture)
             {
                 culture = CultureInfo.CurrentCulture;
             }
 
-            return GetAbbreviationsWithFallbackCulture(Quantities.GetUnitInfo(unitKey), culture);
+            return GetAbbreviationsWithFallbackCulture(unitInfo, culture);
         }
 
         /// <summary>
@@ -400,6 +512,20 @@ public IReadOnlyList<string> GetAllUnitAbbreviationsForQuantity(Type unitEnumTyp
             return allAbbreviations;
         }
 
+        private UnitInfo GetConfiguredUnitInfo(UnitInfo unitInfo)
+        {
+            if (unitInfo is null) throw new ArgumentNullException(nameof(unitInfo));
+            return Quantities.GetUnitInfo(unitInfo.UnitKey);
+        }
+
+        private UnitInfo GetConfiguredUnitInfo(string quantityName, string unitName)
+        {
+            if (quantityName is null) throw new ArgumentNullException(nameof(quantityName));
+            if (unitName is null) throw new ArgumentNullException(nameof(unitName));
+
+            return Quantities.GetUnitByName(quantityName, unitName);
+        }
+
         /// <summary>
         ///    Get all abbreviations for the given unit and culture.
         /// </summary>
diff --git a/UnitsNet/CustomCode/UnitKey.cs b/UnitsNet/CustomCode/UnitKey.cs
index 64079dcf24..9e6a09a29d 100644
--- a/UnitsNet/CustomCode/UnitKey.cs
+++ b/UnitsNet/CustomCode/UnitKey.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 
diff --git a/UnitsNet/CustomCode/UnitParser.cs b/UnitsNet/CustomCode/UnitParser.cs
index b403d86782..b3a0e4f70d 100644
--- a/UnitsNet/CustomCode/UnitParser.cs
+++ b/UnitsNet/CustomCode/UnitParser.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Globalization;
@@ -82,6 +82,55 @@ public static UnitParser CreateDefault()
         return new UnitParser(UnitAbbreviationsCache.CreateDefault());
     }
 
+    /// <summary>
+    ///     Creates a parser for the built-in quantities and any additions made by <paramref name="configureQuantities" />.
+    /// </summary>
+    /// <param name="configureQuantities">Configures the selected quantities.</param>
+    /// <returns>A parser for the configured quantity selection.</returns>
+    public static UnitParser CreateDefault(Action<QuantitiesSelector> configureQuantities)
+    {
+        return new UnitParser(UnitAbbreviationsCache.CreateDefault(configureQuantities));
+    }
+
+    /// <summary>
+    ///     Creates a parser for the built-in quantities, with configurable quantities and abbreviations.
+    /// </summary>
+    /// <param name="configureQuantities">Configures the selected quantities.</param>
+    /// <param name="configureAbbreviations">Configures abbreviations before constructing the parser.</param>
+    /// <returns>A parser for the configured quantities and abbreviations.</returns>
+    public static UnitParser CreateDefault(Action<QuantitiesSelector> configureQuantities, Action<UnitAbbreviationsCache> configureAbbreviations)
+    {
+        return Create(Quantity.DefaultProvider.Quantities, configureQuantities, configureAbbreviations);
+    }
+
+    /// <summary>
+    ///     Creates a parser for a configured selection based on <paramref name="defaultQuantities" />.
+    /// </summary>
+    /// <param name="defaultQuantities">The initial quantity definitions.</param>
+    /// <param name="configureQuantities">Configures the selected quantities.</param>
+    /// <returns>A parser for the configured quantity selection.</returns>
+    public static UnitParser Create(IEnumerable<QuantityInfo> defaultQuantities, Action<QuantitiesSelector> configureQuantities)
+    {
+        return new UnitParser(UnitAbbreviationsCache.Create(defaultQuantities, configureQuantities));
+    }
+
+    /// <summary>
+    ///     Creates a parser for a base catalog, with configurable quantities and abbreviations.
+    /// </summary>
+    /// <param name="defaultQuantities">The initial quantity definitions.</param>
+    /// <param name="configureQuantities">Configures the selected quantities.</param>
+    /// <param name="configureAbbreviations">Configures abbreviations before constructing the parser.</param>
+    /// <returns>A parser for the configured quantities and abbreviations.</returns>
+    public static UnitParser Create(IEnumerable<QuantityInfo> defaultQuantities, Action<QuantitiesSelector> configureQuantities,
+        Action<UnitAbbreviationsCache> configureAbbreviations)
+    {
+        if (configureAbbreviations is null) throw new ArgumentNullException(nameof(configureAbbreviations));
+
+        var unitAbbreviations = UnitAbbreviationsCache.Create(defaultQuantities, configureQuantities);
+        configureAbbreviations(unitAbbreviations);
+        return new UnitParser(unitAbbreviations);
+    }
+
     /// <summary>
     ///     Parses a unit abbreviation for a given unit enumeration type.
     ///     Example: Parse&lt;LengthUnit&gt;("km") => LengthUnit.Kilometer
@@ -725,7 +774,7 @@ public bool TryGetUnitFromAbbreviation([NotNullWhen(true)]string? unitAbbreviati
     /// <returns>An <see cref="IQuantity" /> object.</returns>
     /// <exception cref="UnitNotFoundException">Unit abbreviation is not known.</exception>
     /// <exception cref="AmbiguousUnitParseException">Multiple units found matching the given unit abbreviation.</exception>
-    internal IQuantity FromUnitAbbreviation(double value, string unitAbbreviation, IFormatProvider? formatProvider)
+    internal IQuantity FromUnitAbbreviation(QuantityValue value, string unitAbbreviation, IFormatProvider? formatProvider)
     {
         return GetUnitFromAbbreviation(unitAbbreviation, formatProvider).From(value);
     }
diff --git a/UnitsNet/CustomCode/Units/PressureReference.cs b/UnitsNet/CustomCode/Units/PressureReference.cs
index 7918f67d87..2a85f4a93b 100644
--- a/UnitsNet/CustomCode/Units/PressureReference.cs
+++ b/UnitsNet/CustomCode/Units/PressureReference.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by \generate-code.bat.
 //
diff --git a/UnitsNet/CustomCode/UnitsNetSetup.cs b/UnitsNet/CustomCode/UnitsNetSetup.cs
index e524434b5d..b3b5826a3b 100644
--- a/UnitsNet/CustomCode/UnitsNetSetup.cs
+++ b/UnitsNet/CustomCode/UnitsNetSetup.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet;
@@ -14,32 +14,250 @@ namespace UnitsNet;
 /// </summary>
 public sealed class UnitsNetSetup
 {
-    static UnitsNetSetup()
+    /// <summary>
+    ///     Synchronizes the default builder swap and creation checks with the value creation already synchronized by <see cref="Lazy{T}" />.
+    /// </summary>
+    private static readonly object DefaultConfigurationLock = new();
+    private static DefaultConfigurationBuilder _defaultConfigurationBuilder = new();
+    internal static readonly Lazy<UnitsNetSetup> DefaultConfiguration = new(BuildDefault);
+
+    /// <summary>
+    ///     Builds a UnitsNet setup by selecting built-in or external quantity definitions.
+    /// </summary>
+    public sealed class DefaultConfigurationBuilder
     {
-        IReadOnlyCollection<QuantityInfo> quantityInfos = Quantity.DefaultProvider.Quantities;
+        private QuantitiesSelector? _quantitiesSelector;
+
+        private QuantityConverterBuildOptions _quantityConverterOptions = new();
+
+        // TODO see about allowing eager loading
+        // private AbbreviationsCachingMode AbbreviationsCaching { get; set; } = AbbreviationsCachingMode.Lazy;
+        // TODO see about caching the regex associated with the UnitParser
+        // private UnitsCachingMode UnitParserCaching { get; set; } = UnitsCachingMode.Lazy;
+
+        /// <summary>
+        ///     Uses the specified quantities as the setup's base catalog.
+        /// </summary>
+        /// <param name="quantities">The quantity definitions to use.</param>
+        /// <returns>This builder, for method chaining.</returns>
+        public DefaultConfigurationBuilder WithQuantities(IEnumerable<QuantityInfo> quantities)
+        {
+            if (quantities is null) throw new ArgumentNullException(nameof(quantities));
+            return WithQuantities(() => quantities);
+        }
+
+        /// <summary>
+        ///     Uses quantities returned by <paramref name="quantities" /> as the setup's base catalog.
+        /// </summary>
+        /// <param name="quantities">Provides the quantity definitions to use.</param>
+        /// <returns>This builder, for method chaining.</returns>
+        public DefaultConfigurationBuilder WithQuantities(Func<IEnumerable<QuantityInfo>> quantities)
+        {
+            if (quantities is null) throw new ArgumentNullException(nameof(quantities));
+            if (_quantitiesSelector is not null) throw new InvalidOperationException("The base quantity selection is already configured.");
+
+            _quantitiesSelector = new QuantitiesSelector(quantities);
+            return this;
+        }
+
+        /// <summary>
+        ///     Uses the specified quantities as the setup's base catalog and configures that selection.
+        /// </summary>
+        /// <param name="quantities">The quantity definitions to use.</param>
+        /// <param name="configureQuantities">Configures the selected quantities.</param>
+        /// <returns>This builder, for method chaining.</returns>
+        public DefaultConfigurationBuilder WithQuantities(IEnumerable<QuantityInfo> quantities, Action<QuantitiesSelector> configureQuantities)
+        {
+            if (quantities is null) throw new ArgumentNullException(nameof(quantities));
+            return WithQuantities(() => quantities, configureQuantities);
+        }
 
-        // note: in order to support the ConvertByAbbreviation, the unit converter should require a UnitParser in the constructor
-        var unitConverter = UnitConverter.CreateDefault();
+        /// <summary>
+        ///     Uses quantities returned by <paramref name="quantities" /> as the setup's base catalog and configures that selection.
+        /// </summary>
+        /// <param name="quantities">Provides the quantity definitions to use.</param>
+        /// <param name="configureQuantities">Configures the selected quantities.</param>
+        /// <returns>This builder, for method chaining.</returns>
+        public DefaultConfigurationBuilder WithQuantities(Func<IEnumerable<QuantityInfo>> quantities, Action<QuantitiesSelector> configureQuantities)
+        {
+            if (configureQuantities is null) throw new ArgumentNullException(nameof(configureQuantities));
 
-        Default = new UnitsNetSetup(quantityInfos, unitConverter);
+            WithQuantities(quantities);
+            configureQuantities(_quantitiesSelector!);
+            return this;
+        }
+
+        /// <summary>
+        ///     Appends external quantity definitions to the current selection.
+        /// </summary>
+        /// <param name="quantities">The quantity definitions to append.</param>
+        /// <returns>This builder, for method chaining.</returns>
+        public DefaultConfigurationBuilder WithAdditionalQuantities(IEnumerable<QuantityInfo> quantities)
+        {
+            _quantitiesSelector ??= new QuantitiesSelector(() => Quantity.DefaultProvider.Quantities);
+            _quantitiesSelector.WithAdditionalQuantities(quantities);
+            return this;
+        }
+
+        /// <summary>
+        ///     Appends the list of default quantities with a custom set of definitions.
+        ///     Adds additional quantities to the default configuration. These quantities are not part of the library by default
+        ///     and are appended to the default list of quantities.
+        /// </summary>
+        /// <param name="quantities">The quantities to add to the default configuration.</param>
+        /// <param name="configureQuantities">An action to configure the selected quantities.</param>
+        /// <returns>
+        ///     The <see cref="UnitsNet.UnitsNetSetup.DefaultConfigurationBuilder" /> instance with the additional quantities
+        ///     added.
+        /// </returns>
+        /// <exception cref="System.InvalidOperationException">Thrown if the list of quantities to use is already specified.</exception>
+        public DefaultConfigurationBuilder WithAdditionalQuantities(IEnumerable<QuantityInfo> quantities, Action<QuantitiesSelector> configureQuantities)
+        {
+            if (configureQuantities is null) throw new ArgumentNullException(nameof(configureQuantities));
+
+            _quantitiesSelector ??= new QuantitiesSelector(() => Quantity.DefaultProvider.Quantities);
+            configureQuantities(_quantitiesSelector.WithAdditionalQuantities(quantities));
+            return this;
+        }
+        
+        /// <summary>
+        ///     Configures a custom quantity for the default configuration.
+        /// </summary>
+        /// <typeparam name="TQuantity">The type of the quantity to configure.</typeparam>
+        /// <typeparam name="TUnit">The type of the unit associated with the quantity, which must be an enumeration.</typeparam>
+        /// <param name="createCustomConfigurationDelegate">
+        ///     A delegate that creates a custom configuration for the quantity.
+        /// </param>
+        /// <returns>The current instance of <see cref="UnitsNet.UnitsNetSetup.DefaultConfigurationBuilder" /> for method chaining.</returns>
+        public DefaultConfigurationBuilder ConfigureQuantity<TQuantity, TUnit>(Func<QuantityInfo<TQuantity, TUnit>> createCustomConfigurationDelegate)
+            where TQuantity : IQuantity<TQuantity, TUnit>
+            where TUnit : struct, Enum
+        {
+            _quantitiesSelector ??= new QuantitiesSelector(() => Quantity.DefaultProvider.Quantities);
+            _quantitiesSelector.Configure(createCustomConfigurationDelegate);
+            return this;
+        }
+
+        /// <summary>
+        ///     Configures the quantity converter options for the UnitsNet setup.
+        /// </summary>
+        /// <param name="converterBuildOptions">
+        ///     The options to use for building the quantity converter, including settings for caching,
+        ///     constants reduction, and custom quantity options.
+        /// </param>
+        /// <returns>
+        ///     The <see cref="UnitsNetSetup.DefaultConfigurationBuilder" /> instance for chaining further configuration.
+        /// </returns>
+        public DefaultConfigurationBuilder WithConverterOptions(QuantityConverterBuildOptions converterBuildOptions)
+        {
+            _quantityConverterOptions = converterBuildOptions ?? throw new ArgumentNullException(nameof(converterBuildOptions));
+            return this;
+        }
+
+        internal QuantityInfo<TQuantity, TUnit> CreateQuantityInfoOrDefault<TQuantity, TUnit>(Func<QuantityInfo<TQuantity, TUnit>> defaultConfiguration)
+            where TQuantity : IQuantity<TQuantity, TUnit>
+            where TUnit : struct, Enum
+        {
+            return _quantitiesSelector is null ? defaultConfiguration() : _quantitiesSelector.CreateOrDefault(defaultConfiguration);
+        }
+
+        internal UnitsNetSetup Build()
+        {
+            QuantityInfoLookup quantitiesLookup = _quantitiesSelector is null
+                ? new QuantityInfoLookup(Quantity.DefaultProvider.Quantities)
+                : QuantityInfoLookup.Create(_quantitiesSelector);
+
+            var unitAbbreviations = new UnitAbbreviationsCache(quantitiesLookup);
+            var formatter = new QuantityFormatter(unitAbbreviations);
+            var unitParser = new UnitParser(unitAbbreviations);
+            var quantityParser = new QuantityParser(unitParser);
+            var unitConverter = UnitConverter.Create(unitParser, _quantityConverterOptions);
+            return new UnitsNetSetup(quantitiesLookup, unitAbbreviations, formatter, unitParser, quantityParser, unitConverter);
+        }
+    }
+
+    private static UnitsNetSetup BuildDefault()
+    {
+        lock (DefaultConfigurationLock)
+        {
+            return _defaultConfigurationBuilder.Build();
+        }
     }
 
     /// <summary>
-    ///     Create a new UnitsNet setup with the given quantities, their units and unit conversion functions between units.
+    ///     Creates an isolated setup without changing <see cref="Default" />.
     /// </summary>
-    /// <param name="quantityInfos">The quantities and their units to support for unit conversions, Parse() and ToString().</param>
-    /// <param name="unitConverter">The unit converter instance.</param>
-    public UnitsNetSetup(IEnumerable<QuantityInfo> quantityInfos, UnitConverter unitConverter)
+    /// <param name="configuration">Configures the quantities included in the setup.</param>
+    /// <returns>A configured UnitsNet setup.</returns>
+    public static UnitsNetSetup Create(Action<DefaultConfigurationBuilder> configuration)
+    {
+        if (configuration is null) throw new ArgumentNullException(nameof(configuration));
+
+        var builder = new DefaultConfigurationBuilder();
+        configuration(builder);
+        return builder.Build();
+    }
+
+    /// <summary>
+    ///     Initializes the default (static) quantity information, such as <see cref="Length.Info" />.
+    ///     This method is only called by the static initializer of the generated quantities.
+    ///     It allows for optional customizations to the default configuration.
+    /// </summary>
+    /// <typeparam name="TQuantity">The type of the quantity.</typeparam>
+    /// <typeparam name="TUnit">The type of the unit, which must be a struct and an enumeration.</typeparam>
+    /// <param name="defaultConfiguration">A function that returns the default configuration for the quantity info.</param>
+    /// <returns>A <see cref="QuantityInfo{TQuantity, TUnit}" /> instance configured with the provided default configuration.</returns>
+    /// <remarks>
+    ///     By using this method, any customizations to the default unit definitions are taken into account by the unit
+    ///     converter, parser, formatter, the debug proxy, etc.
+    /// </remarks>
+    internal static QuantityInfo<TQuantity, TUnit> CreateQuantityInfo<TQuantity, TUnit>(Func<QuantityInfo<TQuantity, TUnit>> defaultConfiguration)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        return _defaultConfigurationBuilder.CreateQuantityInfoOrDefault(defaultConfiguration);
+    }
+
+    /// <summary>
+    ///     Configures and creates the global default setup before its first use.
+    /// </summary>
+    /// <param name="configuration">Configures the quantities included in the default setup.</param>
+    /// <returns>The configured global default setup.</returns>
+    /// <exception cref="InvalidOperationException">The default setup has already been created.</exception>
+    /// <seealso cref="Default" />
+    public static UnitsNetSetup ConfigureDefaults(Action<DefaultConfigurationBuilder> configuration)
+    {
+        if (configuration is null) throw new ArgumentNullException(nameof(configuration));
+
+        lock (DefaultConfigurationLock)
+        {
+            if (DefaultConfiguration.IsValueCreated)
+            {
+                throw new InvalidOperationException("The default configuration cannot be changed after it has been created.");
+            }
+
+            var builder = new DefaultConfigurationBuilder();
+            configuration(builder);
+
+            if (DefaultConfiguration.IsValueCreated)
+            {
+                throw new InvalidOperationException("The default configuration was created while it was being configured.");
+            }
+
+            _defaultConfigurationBuilder = builder;
+            return DefaultConfiguration.Value;
+        }
+    }
+
+    private UnitsNetSetup(QuantityInfoLookup quantitiesLookup, UnitAbbreviationsCache unitAbbreviations, QuantityFormatter formatter, UnitParser unitParser,
+        QuantityParser quantityParser, UnitConverter unitConverter)
     {
-        var quantityInfoLookup = new QuantityInfoLookup(quantityInfos);
-        var unitAbbreviations = new UnitAbbreviationsCache(quantityInfoLookup);
-
-        UnitConverter = unitConverter;
-        UnitAbbreviations = unitAbbreviations;
-        Formatter = new QuantityFormatter(unitAbbreviations);
-        UnitParser = new UnitParser(unitAbbreviations);
-        QuantityParser = new QuantityParser(unitAbbreviations);
-        Quantities = quantityInfoLookup;
+        Quantities = quantitiesLookup ?? throw new ArgumentNullException(nameof(quantitiesLookup));
+        UnitAbbreviations = unitAbbreviations ?? throw new ArgumentNullException(nameof(unitAbbreviations));
+        Formatter = formatter ?? throw new ArgumentNullException(nameof(formatter));
+        UnitParser = unitParser ?? throw new ArgumentNullException(nameof(unitParser));
+        QuantityParser = quantityParser ?? throw new ArgumentNullException(nameof(quantityParser));
+        UnitConverter = unitConverter ?? throw new ArgumentNullException(nameof(unitConverter));
     }
 
     /// <summary>
@@ -48,11 +266,14 @@ public UnitsNetSetup(IEnumerable<QuantityInfo> quantityInfos, UnitConverter unit
     ///     provided.
     /// </summary>
     /// <remarks>
+    ///     Call <see cref="ConfigureDefaults" /> before first accessing this property to select a different quantity catalog.<br />
+    ///     <br />
     ///     Manipulating this instance, such as adding new units or changing default unit abbreviations, will affect most
     ///     usages of UnitsNet in the
     ///     current AppDomain since the typical use is via static members and not providing a setup instance.
     /// </remarks>
-    public static UnitsNetSetup Default { get; }
+    /// <seealso cref="ConfigureDefaults" />
+    public static UnitsNetSetup Default => DefaultConfiguration.Value;
 
     /// <summary>
     ///     Converts between units of a quantity, such as from meters to centimeters of a given length.
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.ArithmeticOperations.cs b/UnitsNet/CustomCode/Value/QuantityValue.ArithmeticOperations.cs
new file mode 100644
index 0000000000..8bbd6fd223
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.ArithmeticOperations.cs
@@ -0,0 +1,393 @@
+using System.Numerics;
+
+namespace UnitsNet;
+
+public readonly partial struct QuantityValue
+{
+    /// <summary>
+    ///     Adds two QuantityValue instances.
+    /// </summary>
+    /// <param name="a">The first QuantityValue.</param>
+    /// <param name="b">The second QuantityValue.</param>
+    /// <returns>The sum of the two QuantityValue instances.</returns>
+    public static QuantityValue operator +(QuantityValue a, QuantityValue b)
+    {
+        var numerator1 = a.Numerator;
+        if (numerator1.IsZero)
+        {
+            // `a` is either NaN (NaN + b == NaN) or Zero (0 + b == b)
+            return a.Denominator.IsZero ? a : b;
+        }
+
+        var numerator2 = b.Numerator;
+        if (numerator2.IsZero)
+        {
+            // 'b' is either NaN (a + NaN == NaN) or Zero (a + 0 == a)
+            return b.Denominator.IsZero ? b : a;
+        }
+
+        // both fractions are non-zero numbers
+        var denominator1 = a.Denominator;
+        var denominator2 = b.Denominator;
+
+        if (denominator1.IsZero)
+        {
+            // `a` is (+/-) Infinity
+            if (!denominator2.IsZero)
+            {
+                return a; // Inf + b = Inf
+            }
+
+            // adding infinities
+            return (numerator1.Sign + numerator2.Sign) switch
+            {
+                2 => PositiveInfinity,
+                -2 => NegativeInfinity,
+                _ => NaN
+            };
+        }
+
+        if (denominator2.IsZero)
+        {
+            return b; // (+/-) Infinity
+        }
+
+        // both values are non-zero
+        if (denominator1 == denominator2)
+        {
+            return new QuantityValue(numerator1 + numerator2, denominator1);
+        }
+
+        if (denominator1.IsOne)
+        {
+            return new QuantityValue(numerator1 * denominator2 + numerator2, denominator2);
+        }
+
+        if (denominator2.IsOne)
+        {
+            return new QuantityValue(numerator1 + numerator2 * denominator1, denominator1);
+        }
+
+        var gcd = BigInteger.GreatestCommonDivisor(denominator1, denominator2);
+        if (gcd.IsOne)
+        {
+            return new QuantityValue(numerator1 * denominator2 + numerator2 * denominator1, denominator1 * denominator2);
+        }
+
+        if (gcd == denominator1)
+        {
+            return new QuantityValue(denominator2 / gcd * numerator1 + numerator2, denominator2);
+        }
+
+        if (gcd == denominator2)
+        {
+            return new QuantityValue(numerator1 + denominator1 / gcd * numerator2, denominator1);
+        }
+
+        var thisMultiplier = denominator1 / gcd;
+        var otherMultiplier = denominator2 / gcd;
+
+        var calculatedNumerator = numerator1 * otherMultiplier + numerator2 * thisMultiplier;
+        var leastCommonMultiple = thisMultiplier * denominator2;
+
+        return new QuantityValue(calculatedNumerator, leastCommonMultiple);
+    }
+
+    /// <summary>
+    ///     Increments the QuantityValue by one.
+    /// </summary>
+    /// <param name="value">The QuantityValue to be incremented.</param>
+    /// <returns>A new QuantityValue that represents the original value incremented by one.</returns>
+    public static QuantityValue operator ++(QuantityValue value)
+    {
+        return value + One;
+    }
+
+    /// <summary>
+    ///     Subtracts one QuantityValue from another.
+    /// </summary>
+    /// <param name="a">The QuantityValue to subtract from.</param>
+    /// <param name="b">The QuantityValue to subtract.</param>
+    /// <returns>The difference between the two QuantityValue instances.</returns>
+    public static QuantityValue operator -(QuantityValue a, QuantityValue b)
+    {
+        return a + -b;
+    }
+
+    /// <summary>
+    ///     Returns the same value for the given QuantityValue. This unary plus operator doesn't change the value.
+    /// </summary>
+    /// <param name="value">The QuantityValue to return.</param>
+    /// <returns>The same QuantityValue that was passed in.</returns>
+    public static QuantityValue operator +(QuantityValue value)
+    {
+        return value;
+    }
+
+    /// <summary>
+    ///     Returns the negated value of the operand
+    /// </summary>
+    /// <param name="v">Value to negate</param>
+    /// <returns>-v</returns>
+    public static QuantityValue operator -(QuantityValue v)
+    {
+        return new QuantityValue(-v.Numerator, v.Denominator);
+    }
+
+    /// <summary>
+    ///     Decrements the value of the specified QuantityValue by one.
+    /// </summary>
+    /// <param name="value">The QuantityValue to decrement.</param>
+    /// <returns>A new QuantityValue that is the value of the input QuantityValue minus one.</returns>
+    public static QuantityValue operator --(QuantityValue value)
+    {
+        return value - One;
+    }
+
+    /// <summary>
+    ///     Multiplies two QuantityValue instances.
+    /// </summary>
+    /// <param name="a">The first QuantityValue.</param>
+    /// <param name="b">The second QuantityValue.</param>
+    /// <returns>The product of the two QuantityValue instances.</returns>
+    public static QuantityValue operator *(QuantityValue a, QuantityValue b)
+    {
+        // we want to skip the multiplications if we know the result is going to be 0/b or a/0
+        var numerator1 = a.Numerator;
+        var denominator1 = a.Denominator;
+        if (denominator1.IsZero)
+        {
+            // `a` is NaN or Infinity
+            return new QuantityValue(numerator1.Sign * b.Numerator.Sign, BigInteger.Zero);
+        }
+
+        var numerator2 = b.Numerator;
+        var denominator2 = b.Denominator;
+        if (denominator2.IsZero)
+        {
+            // 'b' is NaN or Infinity
+            return new QuantityValue(numerator1.Sign * numerator2.Sign, BigInteger.Zero);
+        }
+
+        if (numerator1.IsZero || numerator2.IsZero)
+        {
+            return Zero;
+        }
+
+        return new QuantityValue(MultiplyTerms(numerator1, numerator2), MultiplyTerms(denominator1, denominator2));
+    }
+
+    private static BigInteger MultiplyTerms(BigInteger a, BigInteger b)
+    {
+        if (a.IsOne)
+        {
+            return b;
+        }
+
+        return b.IsOne ? a : a * b;
+    }
+
+    /// <summary>
+    ///     Divides one QuantityValue by another.
+    /// </summary>
+    /// <param name="a">The QuantityValue to divide.</param>
+    /// <param name="b">The QuantityValue to divide by.</param>
+    /// <returns>The quotient of the two QuantityValue instances.</returns>
+    public static QuantityValue operator /(QuantityValue a, QuantityValue b)
+    {
+        // we want to skip the multiplications if we know the result is going to be 0/b or a/0
+        var numerator2 = b.Numerator;
+        var denominator2 = b.Denominator;
+        if (denominator2.IsZero)
+        {
+            // dividing by NaN or Infinity produces NaN or Zero
+            return numerator2.IsZero || a.Denominator.IsZero ? NaN : Zero;
+        }
+
+        var numerator1 = a.Numerator;
+        var denominator1 = a.Denominator;
+        if (denominator1.IsZero)
+        {
+            // `a` is NaN or Infinity
+            return numerator1.Sign switch
+            {
+                // +/- Infinity divided by a number
+                1 => numerator2.Sign < 0 ? NegativeInfinity : PositiveInfinity,
+                -1 => numerator2.Sign < 0 ? PositiveInfinity : NegativeInfinity,
+                // NaN divided by a number
+                _ => NaN
+            };
+        }
+
+        if (numerator1.IsZero)
+        {
+            return numerator2.IsZero ? NaN : Zero;
+        }
+
+        if (numerator2.IsZero)
+        {
+            return new QuantityValue(numerator1.Sign, BigInteger.Zero);
+        }
+
+        // adjust the signs such that the divisor is positive (prevent a negative sign in the resulting denominator)
+        if (numerator2.Sign == -1)
+        {
+            numerator1 = -numerator1;
+            numerator2 = -numerator2;
+        }
+
+        // attempt to reduce the denominators
+        switch (denominator1.CompareTo(denominator2))
+        {
+            case 1:
+            {
+                if (denominator2.IsOne)
+                {
+                    // {123/10} / {456/1}
+                    return new QuantityValue(numerator1,
+                        numerator2.IsOne ? denominator1 : denominator1 * numerator2);
+                }
+
+                var gcd = BigInteger.GreatestCommonDivisor(denominator1, denominator2);
+                if (gcd == denominator2)
+                {
+                    denominator1 /= denominator2;
+                    return new QuantityValue(numerator1,
+                        numerator2.IsOne ? denominator1 : denominator1 * numerator2);
+                }
+
+                if (!gcd.IsOne)
+                {
+                    denominator1 /= gcd;
+                    denominator2 /= gcd;
+                }
+
+                var numerator = numerator1.IsOne
+                    ? denominator2
+                    : numerator1 == BigInteger.MinusOne
+                        ? -denominator2
+                        : numerator1 * denominator2;
+
+                var denominator = numerator2.IsOne
+                    ? denominator1
+                    : denominator1 * numerator2;
+
+                return new QuantityValue(numerator, denominator);
+            }
+            case -1:
+            {
+                if (denominator1.IsOne)
+                {
+                    // {123/1} / {456/10}
+                    return new QuantityValue(
+                        numerator1.IsOne ? denominator2 : numerator1 == BigInteger.MinusOne ? -denominator2 : numerator1 * denominator2,
+                        numerator2);
+                }
+
+                var gcd = BigInteger.GreatestCommonDivisor(denominator2, denominator1);
+                if (gcd == denominator1)
+                {
+                    denominator2 /= denominator1;
+                    return new QuantityValue(
+                        numerator1.IsOne ? denominator2 : numerator1 == BigInteger.MinusOne ? -denominator2 : numerator1 * denominator2,
+                        numerator2);
+                }
+
+                if (!gcd.IsOne)
+                {
+                    denominator1 /= gcd;
+                    denominator2 /= gcd;
+                }
+
+                var numerator = numerator1.IsOne
+                    ? denominator2
+                    : numerator1 == BigInteger.MinusOne
+                        ? -denominator2
+                        : numerator1 * denominator2;
+
+                var denominator = numerator2.IsOne
+                    ? denominator1
+                    : denominator1 * numerator2;
+
+                return new QuantityValue(numerator, denominator);
+            }
+            default:
+            {
+                return new QuantityValue(numerator1, numerator2);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Returns the remainder of dividing one QuantityValue by another.
+    /// </summary>
+    /// <param name="a">The QuantityValue to divide.</param>
+    /// <param name="b">The QuantityValue to divide by.</param>
+    /// <returns>The remainder of the division of the two QuantityValue instances.</returns>
+    public static QuantityValue operator %(QuantityValue a, QuantityValue b)
+    {
+        var numerator1 = a.Numerator;
+        var denominator1 = a.Denominator;
+        var numerator2 = b.Numerator;
+        var denominator2 = b.Denominator;
+
+        if (numerator2.IsZero)
+        {
+            return NaN; // x / 0 == NaN
+        }
+
+        if (numerator1.IsZero)
+        {
+            return denominator1.IsZero
+                ? NaN // 0 / NaN == NaN
+                : Zero; // 0 / x == 0 (where x != 0)
+        }
+
+        if (denominator1.IsZero)
+        {
+            // a/0 (infinity)
+            return NaN;
+        }
+
+        if (denominator2.IsZero)
+        {
+            // a % infinity
+            return a;
+        }
+
+        if (denominator1 == denominator2)
+        {
+            return new QuantityValue(numerator1 % numerator2, denominator1);
+        }
+
+        var gcd = BigInteger.GreatestCommonDivisor(denominator1, denominator2);
+        if (gcd.IsOne)
+        {
+            return new QuantityValue(
+                numerator1 * denominator2 % (numerator2 * denominator1),
+                denominator1 * denominator2);
+        }
+
+        if (gcd == denominator1)
+        {
+            return new QuantityValue(denominator2 / gcd * numerator1 % numerator2, denominator2);
+        }
+
+        if (gcd == denominator2)
+        {
+            return new QuantityValue(numerator1 % (denominator1 / gcd * numerator2), denominator1);
+        }
+
+        var thisMultiplier = denominator1 / gcd;
+        var otherMultiplier = denominator2 / gcd;
+
+        var leastCommonMultiple = thisMultiplier * denominator2;
+
+        var numerator = numerator1 * otherMultiplier;
+        var denominator = numerator2 * thisMultiplier;
+
+        var remainder = numerator % denominator;
+
+        return new QuantityValue(remainder, leastCommonMultiple);
+    }
+}
\ No newline at end of file
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.ComparisonOperations.cs b/UnitsNet/CustomCode/Value/QuantityValue.ComparisonOperations.cs
new file mode 100644
index 0000000000..7a2211b5e6
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.ComparisonOperations.cs
@@ -0,0 +1,360 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Numerics;
+
+namespace UnitsNet;
+
+public partial struct QuantityValue
+{
+    /// <summary>
+    ///     Greater-than operator
+    /// </summary>
+    public static bool operator >(QuantityValue a, QuantityValue b)
+    {
+        return a.CompareTo(b) > 0 && !IsNaN(a) && !IsNaN(b);
+    }
+
+    /// <summary>
+    ///     Less-than operator
+    /// </summary>
+    public static bool operator <(QuantityValue a, QuantityValue b)
+    {
+        return a.CompareTo(b) < 0 && !IsNaN(a) && !IsNaN(b);
+    }
+
+    /// <summary>
+    ///     Greater-than-or-equal operator
+    /// </summary>
+    public static bool operator >=(QuantityValue a, QuantityValue b)
+    {
+        return a.CompareTo(b) >= 0 && !IsNaN(a) && !IsNaN(b);
+    }
+
+    /// <summary>
+    ///     Less-than-or-equal operator
+    /// </summary>
+    public static bool operator <=(QuantityValue a, QuantityValue b)
+    {
+        return a.CompareTo(b) <= 0 && !IsNaN(a) && !IsNaN(b);
+    }
+
+    /// <summary>
+    ///     Compares this QuantityValue instance to another QuantityValue instance.
+    /// </summary>
+    /// <param name="other">The QuantityValue to compare with this instance.</param>
+    /// <returns>
+    ///     A value indicating the relative order of the QuantityValue instances being compared.
+    ///     Less than zero: This instance is less than the other instance.
+    ///     Zero: This instance is equal to the other instance.
+    ///     Greater than zero: This instance is greater than the other instance.
+    /// </returns>
+    public int CompareTo(QuantityValue other)
+    {
+        var numerator1 = Numerator;
+        var denominator1 = Denominator;
+        var numerator2 = other.Numerator;
+        var denominator2 = other.Denominator;
+
+        if (denominator1 == denominator2)
+        {
+            if (!denominator1.IsZero)
+            {
+                return numerator1.CompareTo(numerator2); // finite numbers: {-1/2} < {1/2}
+            }
+
+            if (numerator1.IsZero)
+            {
+                return numerator2.IsZero ? 0 : -1; // NaN and anything else
+            }
+
+            if (numerator2.IsZero)
+            {
+                return 1; // other is NaN
+            }
+
+            // comparing infinities
+            return numerator1.Sign.CompareTo(numerator2.Sign);
+        }
+
+        if (denominator1.IsZero)
+        {
+            return numerator1.Sign switch
+            {
+                1 => 1, // PositiveInfinity -> 1
+                _ => -1 // NaN or NegativeInfinity -> -1
+            };
+        }
+
+        if (denominator2.IsZero)
+        {
+            return numerator2.Sign switch
+            {
+                1 => -1, // PositiveInfinity -> -1
+                _ => 1 // NaN or NegativeInfinity -> 1
+            };
+        }
+
+        var firstNumeratorSign = numerator1.Sign;
+        var secondNumeratorSign = numerator2.Sign;
+
+        if (firstNumeratorSign != secondNumeratorSign)
+        {
+            return firstNumeratorSign.CompareTo(secondNumeratorSign);
+        }
+
+        if (firstNumeratorSign == 0)
+        {
+            return 0; // both fractions are zeros
+        }
+
+        // both values are non-zero fractions with different denominators
+        if (denominator1 < denominator2)
+        {
+            // reverse the comparison from x.CompareTo(y) to y.CompareTo(x)
+            return firstNumeratorSign == 1
+                ? -ComparePositiveTerms(numerator2, denominator2, numerator1, denominator1)
+                : -CompareNegativeTerms(numerator2, denominator2, numerator1, denominator1);
+        }
+
+        return firstNumeratorSign == 1
+            ? ComparePositiveTerms(numerator1, denominator1, numerator2, denominator2)
+            : CompareNegativeTerms(numerator1, denominator1, numerator2, denominator2);
+
+        static int ComparePositiveTerms(BigInteger numerator1, BigInteger denominator1, BigInteger numerator2, BigInteger denominator2)
+        {
+            // From here [denominator1 > denominator2 > 0] applies
+
+            // example: {10/10} and {1/1} or {10/100} and {1/10}
+            if (numerator1 <= numerator2)
+            {
+                return -1; // expecting: 0 < numerator2 < numerator1
+            }
+
+            if (numerator2.IsOne)
+            {
+                if (denominator2.IsOne)
+                {
+                    // {n1/d1}.CompareTo({1/1})
+                    return numerator1.CompareTo(denominator1);
+                }
+
+                // {n1/d1}.CompareTo({1/d2}) => {(n1*d2)/d1}.CompareTo(1) => (n1*d2).CompareTo(d1)
+                return (numerator1 * denominator2).CompareTo(denominator1);
+            }
+
+            if (denominator2.IsOne)
+            {
+                // {n1/d1}.CompareTo({n2/1}) => (n1).CompareTo((n2*d1))
+                return numerator1.CompareTo(numerator2 * denominator1);
+            }
+
+            /* Comparing the positive term ratios:
+             * {9/7} / {4/3} = {(1 + 2/7) / (1 + 1/3)} = {27/28}
+             *               => ((1).CompareTo(1)) == 0 and ((2/7).CompareTo(1/3)) == -1
+             * Given that:
+             * {a/b} / {c/d} = {a/b} * {d/c} = {(a*d)/(c*b)} = {a/c} * {d/b} = {a/c} / {b/d}
+             * we can also write:
+             * {9/4} / {7/3} = {(2 + 1/4) / (2 + 1/3)} = {27/28}
+             *               => ((2).CompareTo(2)) == 0 and ((1/4).CompareTo(1/3)) == -1
+             */
+
+            var denominatorQuotient = BigInteger.DivRem(denominator1, denominator2, out var remainderDenominators);
+            if (remainderDenominators.IsZero)
+            {
+                /* Example:
+                 * {7/4} / {3/2}         =
+                 * {7/3} / {4/2}         =
+                 * {(2 + 1/3) / (2 + 0)} =
+                 * {7/3} / 2             = {7/6}
+                 *                       => (7).CompareTo(3*2) == 1
+                 */
+                return numerator1.CompareTo(numerator2 * denominatorQuotient);
+            }
+
+            var numeratorQuotient = BigInteger.DivRem(numerator1, numerator2, out var remainderNumerators);
+            // if the fractions are equal: numeratorQuotient should be equal to denominatorQuotient
+            var quotientComparison = numeratorQuotient.CompareTo(denominatorQuotient);
+            if (quotientComparison != 0)
+            {
+                return quotientComparison;
+            }
+
+            // if the fractions are equal: {remainderNumerators / numerator2} should be equal to {remainderDenominators / denominator2}
+            if (remainderNumerators.IsZero)
+            {
+                /* Example:
+                 * {6/5} / {3/2}   =
+                 * {6/3} / {5/2}   =
+                 * {2 / (2 + 1/2)} =
+                 * {2 / (3/2)}     = {4/3}
+                 */
+                return -1; // when both values are 0 the fractions are equal
+            }
+
+            return (remainderNumerators * denominator2).CompareTo(remainderDenominators * numerator2);
+        }
+
+        static int CompareNegativeTerms(BigInteger numerator1, BigInteger denominator1, BigInteger numerator2, BigInteger denominator2)
+        {
+            // From here [denominator1 > denominator2 > 0] applies
+
+            // example: {-10/10} and {-1/1} or {-10/100} and {-1/10}
+            if (numerator1 >= numerator2)
+            {
+                return 1; // expecting: numerator1 < numerator2 < 0
+            }
+
+            if (numerator2 == BigInteger.MinusOne)
+            {
+                return denominator2.IsOne ? numerator1.CompareTo(-denominator1) : denominator1.CompareTo(numerator1 * -denominator2);
+            }
+
+            if (denominator2.IsOne)
+            {
+                return numerator1.CompareTo(numerator2 * denominator1);
+            }
+
+            /* Comparing the negative term ratios, example:
+             * {-9/7} / {-4/3} = {(-1 + -2/7) / (-1 + -1/3)} = {27/28}
+             *                 => ((-1).CompareTo(-1)) == 0 and ((-2/7).CompareTo(-1/3)) == 1
+             * Given that:
+             * {a/b} / {c/d} = {a/b} * {d/c} = {(a*d)/(c*b)} = {a/c} * {d/b} = {a/c} / {b/d}
+             * we can also write:
+             * {-9/4} / {-7/3} = {(-2 + -1/4) / (-2 - 1/3)} = {27/28}
+             *                 => ((-2).CompareTo(-2)) == 0 and ((-1/4).CompareTo(-1/3)) == 1
+             */
+            var denominatorQuotient = BigInteger.DivRem(denominator1, denominator2, out var remainderDenominators);
+            if (remainderDenominators.IsZero)
+            {
+                // {-7/4} / {-3/2} = {(2 + 1/3) / 2} = {(7/3)/2} = {7/6}
+                return numerator1.CompareTo(numerator2 * denominatorQuotient);
+            }
+
+            var numeratorQuotient = BigInteger.DivRem(numerator1, numerator2, out var remainderNumerators);
+            // if the fractions are equal: numeratorQuotient should be equal to denominatorQuotient
+            var quotientComparison = numeratorQuotient.CompareTo(denominatorQuotient);
+            if (quotientComparison != 0)
+            {
+                return -quotientComparison;
+            }
+
+            // if the fractions are equal: {remainderNumerators / numerator2} should be equal to {remainderDenominators / denominator2}
+            if (remainderNumerators.IsZero)
+            {
+                return 1; // when both values are 0 the fractions are equal
+            }
+
+            return (remainderNumerators * denominator2).CompareTo(remainderDenominators * numerator2);
+        }
+    }
+
+    /// <summary>
+    ///     Compares this QuantityValue instance to another object.
+    /// </summary>
+    /// <param name="obj">The object to compare with this instance.</param>
+    /// <returns>
+    ///     A value indicating the relative order of the QuantityValue instances being compared.
+    ///     Less than zero: This instance is less than the other instance.
+    ///     Zero: This instance is equal to the other instance.
+    ///     Greater than zero: This instance is greater than the other instance.
+    /// </returns>
+    public int CompareTo(object? obj)
+    {
+        return obj switch
+        {
+            null => 1,
+            QuantityValue other => CompareTo(other),
+            _ => throw new ArgumentException($"Object must be of type {nameof(QuantityValue)}")
+        };
+    }
+
+    /// <summary>
+    ///     Returns the <see cref="QuantityValue" /> with the maximum magnitude from the two provided values.
+    /// </summary>
+    /// <param name="x">The first <see cref="QuantityValue" /> to compare.</param>
+    /// <param name="y">The second <see cref="QuantityValue" /> to compare.</param>
+    /// <returns>The <see cref="QuantityValue" /> with the maximum magnitude.</returns>
+    public static QuantityValue MaxMagnitude(QuantityValue x, QuantityValue y)
+    {
+        if (IsNaN(x))
+        {
+            return x;
+        }
+
+        if (IsNaN(y))
+        {
+            return y;
+        }
+
+        // note: unlike the <= operator, CompareTo with NaN returns NaN
+        var comparison = Abs(x).CompareTo(Abs(y));
+        return comparison switch
+        {
+            1 => x,
+            -1 => y,
+            _ => IsNegative(x) ? y : x
+        };
+    }
+
+    /// <summary>
+    ///     Compares two values to compute which has the greater magnitude and returning the other value if an input is
+    ///     <c>NaN</c>.
+    /// </summary>
+    /// <param name="x">The value to compare with <paramref name="y" />.</param>
+    /// <param name="y">The value to compare with <paramref name="x" />.</param>
+    /// <returns>
+    ///     <paramref name="x" /> if it is greater than <paramref name="y" />; otherwise, <paramref name="y" />.
+    /// </returns>
+    public static QuantityValue MaxMagnitudeNumber(QuantityValue x, QuantityValue y)
+    {
+        if (IsNaN(x))
+        {
+            return y;
+        }
+
+        if (IsNaN(y))
+        {
+            return x;
+        }
+
+        var comparison = Abs(x).CompareTo(Abs(y));
+        return comparison switch
+        {
+            1 => x,
+            -1 => y,
+            _ => IsNegative(x) ? y : x
+        };
+    }
+
+    /// <summary>
+    ///     Returns the QuantityValue with the smallest magnitude from the two provided QuantityValues.
+    /// </summary>
+    /// <param name="x">The first QuantityValue to compare.</param>
+    /// <param name="y">The second QuantityValue to compare.</param>
+    /// <returns>The QuantityValue with the smallest magnitude.</returns>
+    public static QuantityValue MinMagnitude(QuantityValue x, QuantityValue y)
+    {
+        var comparison = Abs(x).CompareTo(Abs(y));
+        return comparison switch
+        {
+            -1 => x,
+            1 => y,
+            _ => IsNegative(x) ? x : y
+        };
+    }
+
+    /// <summary>
+    ///     Compares two values to compute which has the lesser magnitude and returning the other value if an input is
+    ///     <c>NaN</c>.
+    /// </summary>
+    /// <param name="x">The value to compare with <paramref name="y" />.</param>
+    /// <param name="y">The value to compare with <paramref name="x" />.</param>
+    /// <returns>
+    ///     <paramref name="x" /> if it is less than <paramref name="y" />; otherwise, <paramref name="y" />.
+    /// </returns>
+    public static QuantityValue MinMagnitudeNumber(QuantityValue x, QuantityValue y)
+    {
+        return IsNaN(x) ? y : IsNaN(y) ? x : MinMagnitude(x, y);
+    }
+}
\ No newline at end of file
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.ConvertFromNumber.cs b/UnitsNet/CustomCode/Value/QuantityValue.ConvertFromNumber.cs
new file mode 100644
index 0000000000..4102e573b7
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.ConvertFromNumber.cs
@@ -0,0 +1,521 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Numerics;
+#if NET
+using System.Runtime.CompilerServices;
+#endif
+
+namespace UnitsNet;
+
+public partial struct QuantityValue
+{
+    /// <summary>Implicit cast from <see cref="byte" /> to <see cref="QuantityValue" />.</summary>
+    public static implicit operator QuantityValue(byte value)
+    {
+        return new QuantityValue(value, BigInteger.One);
+    }
+
+    /// <summary>Implicit cast from <see cref="sbyte" /> to <see cref="QuantityValue" />.</summary>
+    [CLSCompliant(false)]
+    public static implicit operator QuantityValue(sbyte value)
+    {
+        return new QuantityValue(value);
+    }
+
+    /// <summary>Implicit cast from <see cref="short" /> to <see cref="QuantityValue" />.</summary>
+    public static implicit operator QuantityValue(short value)
+    {
+        return new QuantityValue(value);
+    }
+
+    /// <summary>Implicit cast from <see cref="ushort" /> to <see cref="QuantityValue" />.</summary>
+    [CLSCompliant(false)]
+    public static implicit operator QuantityValue(ushort value)
+    {
+        return new QuantityValue(value);
+    }
+
+    /// <summary>Implicit cast from <see cref="int" /> to <see cref="QuantityValue" />.</summary>
+    public static implicit operator QuantityValue(int value)
+    {
+        return new QuantityValue(value);
+    }
+
+    /// <summary>Implicit cast from <see cref="uint" /> to <see cref="QuantityValue" />.</summary>
+    [CLSCompliant(false)]
+    public static implicit operator QuantityValue(uint value)
+    {
+        return new QuantityValue(value);
+    }
+
+    /// <summary>Implicit cast from <see cref="long" /> to <see cref="QuantityValue" />.</summary>
+    public static implicit operator QuantityValue(long value)
+    {
+        return new QuantityValue(value);
+    }
+
+    /// <summary>Implicit cast from <see cref="ulong" /> to <see cref="QuantityValue" />.</summary>
+    [CLSCompliant(false)]
+    public static implicit operator QuantityValue(ulong value)
+    {
+        return new QuantityValue(value);
+    }
+
+    /// <summary>Implicit cast from <see cref="float" /> to <see cref="QuantityValue" />.</summary>
+    public static implicit operator QuantityValue(float value)
+    {
+        return FromDoubleRounded(value);
+    }
+
+    /// <summary>Implicit cast from <see cref="double" /> to <see cref="QuantityValue" />.</summary>
+    public static implicit operator QuantityValue(double value)
+    {
+        return FromDoubleRounded(value);
+    }
+
+    /// <summary>Implicit cast from <see cref="decimal" /> to <see cref="QuantityValue" />.</summary>
+    public static implicit operator QuantityValue(decimal value)
+    {
+        return new QuantityValue(value);
+    }
+
+    /// <summary>Implicit cast from <see cref="QuantityValue" /> to <see cref="BigInteger" />.</summary>
+    public static implicit operator QuantityValue(BigInteger value)
+    {
+        return new QuantityValue(value);
+    }
+
+    /// <summary>
+    ///     Creates a new instance of <see cref="QuantityValue" /> from the specified numerator and denominator.
+    /// </summary>
+    /// <param name="numerator">The numerator of the fraction representing the quantity value.</param>
+    /// <param name="denominator">
+    ///     The denominator of the fraction representing the quantity value.
+    ///     If the denominator is negative, both the numerator and denominator are negated to ensure a canonical
+    ///     representation.
+    /// </param>
+    /// <returns>
+    ///     A <see cref="QuantityValue" /> instance representing the fraction defined by the given numerator and denominator.
+    /// </returns>
+    public static QuantityValue FromTerms(BigInteger numerator, BigInteger denominator)
+    {
+        return denominator.Sign < 0 ? new QuantityValue(-numerator, -denominator) : new QuantityValue(numerator, denominator);
+    }
+
+    /// <summary>
+    ///     Creates a new instance of the <see cref="QuantityValue" /> struct with the specified number and a power of ten exponent.
+    /// </summary>
+    /// <param name="number">The number to multiply.</param>
+    /// <param name="powerOfTen">
+    ///     The power of ten to adjust the value. A positive exponent multiplies the number by 10 raised to the power,
+    ///     while a negative exponent multiplies the denominator by 10 raised to the absolute value of the power.
+    /// </param>
+    /// <returns>
+    ///     A new <see cref="QuantityValue" /> instance representing the specified value, corresponding to the scientific
+    ///     notation: number * 10 ^ powerOfTen.
+    /// </returns>
+    /// <remarks>
+    ///     This constructor enables precise representation of values using a fraction and a power of ten, 
+    ///     corresponding to the scientific notation: number * 10 ^ powerOfTen.
+    /// </remarks>
+    public static QuantityValue FromPowerOfTen(BigInteger number, int powerOfTen)
+    {
+        return new QuantityValue(number, BigInteger.One, powerOfTen);
+    }
+
+    /// <summary>
+    ///     Creates a new instance of the <see cref="QuantityValue" /> struct with the specified numerator, denominator,
+    ///     and a power of ten exponent.
+    /// </summary>
+    /// <param name="numerator">The numerator of the fraction representing the value.</param>
+    /// <param name="denominator">The denominator of the fraction representing the value.</param>
+    /// <param name="powerOfTen">
+    ///     The power of ten to adjust the value. A positive exponent multiplies the numerator by 10 raised to the power,
+    ///     while a negative exponent multiplies the denominator by 10 raised to the absolute value of the power.
+    /// </param>
+    /// <returns>
+    ///     A new <see cref="QuantityValue" /> instance representing the specified value, corresponding to the scientific
+    ///     notation: (numerator/denominator) * 10 ^ powerOfTen.
+    /// </returns>
+    /// <remarks>
+    ///     This constructor enables precise representation of values using a fraction and a power of ten, 
+    ///     corresponding to the scientific notation: (numerator/denominator) * 10 ^ powerOfTen.
+    /// </remarks>
+    public static QuantityValue FromPowerOfTen(BigInteger numerator, BigInteger denominator, int powerOfTen)
+    {
+        return denominator.Sign < 0 ? new QuantityValue(-numerator, -denominator, powerOfTen) : new QuantityValue(numerator, denominator, powerOfTen);
+    }
+
+    /// <summary>
+    ///     Converts a floating point value to a QuantityValue. The value is rounded if possible.
+    /// </summary>
+    /// <param name="value">The floating point value to convert.</param>
+    /// <param name="nbSignificantDigits"></param>
+    /// <exception cref="T:System.ArgumentOutOfRangeException">
+    ///     Thrown when the number of significant digits is less than 1 or greater than 17.
+    /// </exception>
+    /// <returns>A QuantityValue representing the rounded floating point value.</returns>
+    /// <remarks>
+    ///     The double data type stores its values as 64-bit floating point numbers in accordance with the IEC 60559:1989 (IEEE
+    ///     754) standard for binary floating-point arithmetic.
+    ///     However, the double data type cannot precisely store some numbers. For instance, 1/10, which is accurately
+    ///     represented by .1 as a decimal fraction, is represented by .0001100110011... as a binary fraction, with the pattern
+    ///     0011 repeating indefinitely.
+    ///     In such cases, the floating-point value provides an approximate representation of the number.
+    ///     <para>
+    ///         This method can be used to avoid large numbers in the numerator and denominator while also making it safe to
+    ///         use in comparison operations with other values.
+    ///         <code>
+    /// QuantityValue value = QuantityValue.FromDoubleRounded(0.1, 15); // returns {1/10}, which is exactly 0.1
+    /// </code>
+    ///     </para>
+    /// </remarks>
+    /// <example>
+    ///     <code>
+    /// QuantityValue qv = QuantityValue.FromDoubleRounded(0.1);
+    /// // Output: 1/10, which is exactly 0.1
+    /// </code>
+    /// </example>
+    public static QuantityValue FromDoubleRounded(double value, byte nbSignificantDigits = 15)
+    {
+        if (nbSignificantDigits is < 1 or > 17)
+        {
+            throw new ArgumentOutOfRangeException(nameof(nbSignificantDigits), nbSignificantDigits, "The number of significant digits must be between 1 and 17 (inclusive).");
+        }
+
+        switch (value)
+        {
+            case 0d:
+                return Zero;
+            case double.NaN:
+                return NaN;
+            case double.PositiveInfinity:
+                return PositiveInfinity;
+            case double.NegativeInfinity:
+                return NegativeInfinity;
+        }
+
+        // Determine the number of decimal places to keep
+        var magnitude = Math.Floor(Math.Log10(Math.Abs(value)));
+        if (magnitude > nbSignificantDigits)
+        {
+            var digitsToKeep = new BigInteger(value / Math.Pow(10, magnitude - nbSignificantDigits));
+            return new QuantityValue(digitsToKeep * PowerOfTen((int)magnitude - nbSignificantDigits));
+        }
+
+        // "decimal" values
+        var truncatedValue = Math.Truncate(value);
+        var integerPart = new BigInteger(truncatedValue);
+
+        var decimalPlaces = Math.Min(-(int)magnitude + nbSignificantDigits - 1, 308);
+        var scaleFactor = Math.Pow(10, decimalPlaces);
+        // Get the fractional part
+        var fractionalPart = (long)Math.Round((value - truncatedValue) * scaleFactor);
+        if (fractionalPart == 0) // rounded to integer
+        {
+            return new QuantityValue(integerPart);
+        }
+
+        // reduce the insignificant trailing zeros from the fractional part before converting it to BigInteger
+        while (fractionalPart % 10 == 0)
+        {
+            fractionalPart /= 10;
+            decimalPlaces--;
+        }
+
+        var denominator = PowerOfTen(decimalPlaces);
+        var numerator = integerPart.IsZero ? fractionalPart : integerPart * denominator + fractionalPart;
+        return new QuantityValue(numerator, denominator);
+    }
+
+#if NET7_0_OR_GREATER
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    static bool INumberBase<QuantityValue>.TryConvertFromChecked<TOther>(TOther value, out QuantityValue result)
+    {
+        if (TryConvertFrom(value, out result))
+        {
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Complex))
+        {
+            // Complex numbers with an imaginary part can't be represented as a "real number"
+            // so we will convert it to NaN for the floating-point types,
+            // since that's what Sqrt(-1) (which is `new Complex(0, 1)`) results in.
+            result = FromDoubleRounded(double.CreateChecked(value));
+            return true;
+        }
+
+        result = default;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    static bool INumberBase<QuantityValue>.TryConvertFromSaturating<TOther>(TOther value, out QuantityValue result)
+    {
+        if (TryConvertFrom(value, out result))
+        {
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Complex))
+        {
+            result = FromDoubleRounded(double.CreateSaturating(value));
+            return true;
+        }
+
+        result = default;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    static bool INumberBase<QuantityValue>.TryConvertFromTruncating<TOther>(TOther value, out QuantityValue result)
+    {
+        if (TryConvertFrom(value, out result))
+        {
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Complex))
+        {
+            result = FromDoubleRounded(double.CreateTruncating(value));
+            return true;
+        }
+
+        result = default;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool TryConvertFrom<TOther>(TOther value, out QuantityValue result) where TOther : INumberBase<TOther>
+    {
+        if (typeof(TOther) == typeof(decimal))
+        {
+            var num = (decimal)(object)value;
+            result = num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(double))
+        {
+            var num = (double)(object)value;
+            result = num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(float))
+        {
+            var actualValue = (float)(object)value;
+            result = actualValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Half))
+        {
+            var actualValue = (Half)(object)value;
+            result = (float)actualValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(BigInteger))
+        {
+            var num = (BigInteger)(object)value;
+            result = num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Int128))
+        {
+            var num = (Int128)(object)value;
+            result = (BigInteger)num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(UInt128))
+        {
+            var num = (UInt128)(object)value;
+            result = (BigInteger)num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(long))
+        {
+            var num = (long)(object)value;
+            result = num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(ulong))
+        {
+            var num = (ulong)(object)value;
+            result = num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(int))
+        {
+            long num = (int)(object)value;
+            result = num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(uint))
+        {
+            var num = (uint)(object)value;
+            result = num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(nint))
+        {
+            var num = (nint)(object)value;
+            result = num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(UIntPtr))
+        {
+            var num = (UIntPtr)(object)value;
+            result = num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(short))
+        {
+            var num = (short)(object)value;
+            result = (BigInteger)num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(ushort))
+        {
+            var num = (ushort)(object)value;
+            result = (decimal)num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(char))
+        {
+            var ch = (char)(object)value;
+            result = (decimal)ch;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(byte))
+        {
+            var num = (byte)(object)value;
+            result = num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(sbyte))
+        {
+            var num = (sbyte)(object)value;
+            result = num;
+            return true;
+        }
+
+        result = default;
+        return false;
+    }
+
+    /// <summary>
+    ///     Creates a <see cref="QuantityValue" /> instance from the specified value, throwing an exception if the value
+    ///     cannot be represented within the range of <see cref="QuantityValue" />.
+    /// </summary>
+    /// <typeparam name="TOther">The type of the input value.</typeparam>
+    /// <param name="value">The value to convert to a <see cref="QuantityValue" />.</param>
+    /// <returns>A <see cref="QuantityValue" /> instance representing the specified value.</returns>
+    /// <exception cref="NotSupportedException">
+    ///     Thrown if the conversion from <typeparamref name="TOther" /> to <see cref="QuantityValue" /> is not supported.
+    /// </exception>
+    /// <exception cref="OverflowException">
+    ///     Thrown if the specified value is outside the representable range of <see cref="QuantityValue" />.
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static QuantityValue CreateChecked<TOther>(TOther value) where TOther : INumberBase<TOther>
+    {
+        QuantityValue result;
+        if (typeof(TOther) == typeof(QuantityValue))
+            result = (QuantityValue)(object)value;
+        else if (!TryConvertChecked(value, out result) && !TOther.TryConvertToChecked(value, out result))
+            throw new NotSupportedException($"Cannot create a {nameof(QuantityValue)} from the given value of type {typeof(TOther)}.");
+        return result;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static bool TryConvertChecked<TSource, TTarget>(TSource source, out TTarget? result)
+            where TSource : INumberBase<TSource>
+            where TTarget : INumberBase<TTarget>
+        {
+            return TTarget.TryConvertFromChecked(source, out result);
+        }
+    }
+
+    /// <summary>
+    ///     Creates a new instance of <see cref="QuantityValue" /> from the specified value, saturating the value if it falls
+    ///     outside the representable range of <see cref="QuantityValue" />.
+    /// </summary>
+    /// <typeparam name="TOther">The type of the input value.</typeparam>
+    /// <param name="value">The value to be converted into a <see cref="QuantityValue" />.</param>
+    /// <returns>
+    ///     A <see cref="QuantityValue" /> instance created from the specified value. If the value is outside the representable
+    ///     range, it is saturated to the nearest representable value.
+    /// </returns>
+    /// <exception cref="NotSupportedException">
+    ///     Thrown if the conversion from <typeparamref name="TOther" /> to <see cref="QuantityValue" /> is not supported.
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static QuantityValue CreateSaturating<TOther>(TOther value) where TOther : INumberBase<TOther>
+    {
+        QuantityValue result;
+        if (typeof(TOther) == typeof(QuantityValue))
+            result = (QuantityValue)(object)value;
+        else if (!TryConvertSaturating(value, out result) && !TOther.TryConvertToSaturating(value, out result))
+            throw new NotSupportedException($"Cannot create a {nameof(QuantityValue)} from the given value of type {typeof(TOther)}.");
+        return result;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static bool TryConvertSaturating<TSource, TTarget>(TSource source, out TTarget? result)
+            where TSource : INumberBase<TSource>
+            where TTarget : INumberBase<TTarget>
+        {
+            return TTarget.TryConvertFromSaturating(source, out result);
+        }
+    }
+    
+    /// <summary>
+    ///     Creates a <see cref="QuantityValue" /> instance from the specified value, truncating any values that fall outside
+    ///     the representable range of <see cref="QuantityValue" />.
+    /// </summary>
+    /// <typeparam name="TOther">The type of the input value.</typeparam>
+    /// <param name="value">The value to convert to a <see cref="QuantityValue" />.</param>
+    /// <returns>
+    ///     A <see cref="QuantityValue" /> instance created from the specified value, with truncation applied if the value
+    ///     exceeds the representable range.
+    /// </returns>
+    /// <exception cref="NotSupportedException">
+    ///     Thrown if the conversion from <typeparamref name="TOther" /> to <see cref="QuantityValue" /> is not supported.
+    /// </exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static QuantityValue CreateTruncating<TOther>(TOther value) where TOther : INumberBase<TOther>
+    {
+        QuantityValue result;
+        if (typeof(TOther) == typeof(QuantityValue))
+            result = (QuantityValue)(object)value;
+        else if (!TryConvertTruncating(value, out result) && !TOther.TryConvertToTruncating(value, out result))
+            throw new NotSupportedException($"Cannot create a {nameof(QuantityValue)} from the given value of type {typeof(TOther)}.");
+        return result;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static bool TryConvertTruncating<TSource, TTarget>(TSource source, out TTarget? result)
+            where TSource : INumberBase<TSource>
+            where TTarget : INumberBase<TTarget>
+        {
+            return TTarget.TryConvertFromTruncating(source, out result);
+        }
+    }
+#endif
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.ConvertFromString.cs b/UnitsNet/CustomCode/Value/QuantityValue.ConvertFromString.cs
new file mode 100644
index 0000000000..eb1f624c4a
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.ConvertFromString.cs
@@ -0,0 +1,1311 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Numerics;
+
+namespace UnitsNet;
+
+public partial struct QuantityValue
+{
+    private const NumberStyles DefaultNumberStyles = NumberStyles.Integer | NumberStyles.Number | NumberStyles.Float;
+
+    /// <summary>
+    ///     Parses a string representation of a quantity value into a QuantityValue object.
+    /// </summary>
+    /// <param name="s">The string representation of the quantity value.</param>
+    /// <param name="provider">
+    ///     A NumberStyles value that indicates the style elements that can be present in
+    ///     valueString.
+    /// </param>
+    /// <returns>A QuantityValue object that represents the parsed string.</returns>
+    /// <exception cref="System.ArgumentNullException">Thrown when the provided string argument is null.</exception>
+    /// <exception cref="System.FormatException">
+    ///     Thrown when the format of the provided string argument is invalid and cannot
+    ///     be successfully parsed into a QuantityValue.
+    /// </exception>
+    public static QuantityValue Parse(string s, IFormatProvider? provider)
+    {
+        return Parse(s, DefaultNumberStyles, provider);
+    }
+
+    /// <summary>
+    ///     Parses a string representation of a quantity value into a QuantityValue object.
+    /// </summary>
+    /// <param name="s">The string representation of the quantity value.</param>
+    /// <param name="style">
+    ///     A NumberStyles value that indicates the style elements that can be present in
+    ///     valueString.
+    /// </param>
+    /// <param name="provider">
+    ///     An IFormatProvider that supplies culture-specific formatting information about
+    ///     valueString.
+    /// </param>
+    /// <returns>A QuantityValue object that represents the parsed string.</returns>
+    /// <exception cref="System.ArgumentNullException">Thrown when the provided string argument is null.</exception>
+    /// <exception cref="System.FormatException">
+    ///     Thrown when the format of the provided string argument is invalid and cannot
+    ///     be successfully parsed into a QuantityValue.
+    /// </exception>
+    public static QuantityValue Parse(string s, NumberStyles style, IFormatProvider? provider)
+    {
+        if (TryParse(s, style, provider, out var valueParsed))
+        {
+            return valueParsed;
+        }
+
+        throw new FormatException(
+            $"The format of the provided string argument '{s}' is invalid and cannot be successfully parsed into a QuantityValue.");
+    }
+
+    /// <summary>
+    ///     Tries to convert the string representation of a quantity value to its QuantityValue equivalent, and returns a value
+    ///     that indicates whether the conversion succeeded.
+    /// </summary>
+    /// <param name="s">A string containing a quantity value to convert.</param>
+    /// <param name="provider">An object that supplies culture-specific formatting information about s.</param>
+    /// <param name="result">
+    ///     When this method returns, contains the QuantityValue equivalent to the quantity value contained in
+    ///     s, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is null
+    ///     or is not of the correct format. This parameter is passed uninitialized; any value originally supplied in result
+    ///     will be overwritten.
+    /// </param>
+    /// <returns>true if s was converted successfully; otherwise, false.</returns>
+    public static bool TryParse(string? s, IFormatProvider? provider, out QuantityValue result)
+    {
+        return TryParse(s, DefaultNumberStyles, provider, out result);
+    }
+
+#if NET
+    /// <inheritdoc />
+    public static QuantityValue Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+    {
+        return Parse(s, DefaultNumberStyles, provider);
+    }
+
+    /// <inheritdoc />
+    public static QuantityValue Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider)
+    {
+        if (TryParse(s, style, provider, out var quantityValue))
+        {
+            return quantityValue;
+        }
+
+        throw new FormatException(
+            $"The format of the provided string argument '{s}' is invalid and cannot be successfully parsed into a QuantityValue.");
+    }
+
+    /// <inheritdoc />
+    public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out QuantityValue result)
+    {
+        return TryParse(s, DefaultNumberStyles, provider, out result);
+    }
+    
+    /// <inheritdoc />
+    public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out QuantityValue result)
+    {
+        return TryParse(s.AsSpan(), style, provider, out result);
+    }
+
+    /// <summary>
+    ///     Attempts to parse a ReadOnlySpan of characters into a QuantityValue.
+    /// </summary>
+    /// <param name="value">
+    ///     The input string to parse. The numerator and denominator must be separated by a '/' (slash) character.
+    ///     For example, "3/4". If the string is not in this format, the parsing behavior is influenced by the
+    ///     <paramref name="numberStyles" /> and <paramref name="formatProvider" /> parameters.
+    /// </param>
+    /// <param name="numberStyles">
+    ///     A bitwise combination of number styles permitted in the input string. This is relevant when the string
+    ///     is not in the numerator/denominator format. For instance, <see cref="NumberStyles.Float" /> allows decimal
+    ///     points and scientific notation.
+    /// </param>
+    /// <param name="formatProvider">
+    ///     An <see cref="IFormatProvider" /> that supplies culture-specific information used to parse the input string.
+    ///     This is relevant when the string is not in the numerator/denominator format. For example,
+    ///     <c>CultureInfo.GetCultureInfo("en-US")</c> for US English culture.
+    /// </param>
+    /// <param name="quantityValue">
+    ///     When this method returns, contains the parsed QuantityValue if the operation was successful; otherwise,
+    ///     it contains the default value of <see cref="QuantityValue" />.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the input string is well-formed and could be parsed into a QuantityValue; otherwise, <c>false</c>.
+    /// </returns>
+    /// <remarks>
+    ///     The <paramref name="numberStyles" /> parameter allows you to specify which number styles are allowed in the input
+    ///     string while the <paramref name="formatProvider" /> parameter provides culture-specific formatting information.
+    ///     <para>
+    ///         Here are some examples of how to use the
+    ///         <see cref="TryParse(ReadOnlySpan{char}, NumberStyles, IFormatProvider, out QuantityValue)" /> method:
+    ///         <example>
+    ///             <code>
+    /// QuantityValue.TryParse("3/4", NumberStyles.Any, CultureInfo.GetCultureInfo("en-US"), true, out var QuantityValue);
+    ///         </code>
+    ///             This example parses the string "3/4" into a <see cref="QuantityValue" /> object with a numerator of 3 and a
+    ///             denominator of 4.
+    ///             <code>
+    /// QuantityValue.TryParse("1.25", NumberStyles.Number, CultureInfo.GetCultureInfo("en-US"), true, out var QuantityValue);
+    ///         </code>
+    ///             This example parses the string "1.25" into a <see cref="QuantityValue" /> object with a numerator of 5 and
+    ///             a
+    ///             denominator of 4.
+    ///             <code>
+    /// QuantityValue.TryParse("1,234.56", NumberStyles.Number, CultureInfo.GetCultureInfo("en-US"), false, out var QuantityValue);
+    ///         </code>
+    ///             This example parses the string "1,234.56" into a <see cref="QuantityValue" /> object with a numerator of
+    ///             12345
+    ///             and a
+    ///             denominator of 100.
+    ///             <code>
+    /// QuantityValue.TryParse("1.23e-2", NumberStyles.Float, CultureInfo.GetCultureInfo("en-US"), false, out var QuantityValue);
+    ///         </code>
+    ///             This example parses the string "1.23e-2" into a <see cref="QuantityValue" /> object with a numerator of 123
+    ///             and
+    ///             a
+    ///             denominator of 10000.
+    ///         </example>
+    ///     </para>
+    /// </remarks>
+    public static bool TryParse(ReadOnlySpan<char> value, NumberStyles numberStyles, IFormatProvider? formatProvider, out QuantityValue quantityValue)
+    {
+        if (value.IsEmpty)
+        {
+            return CannotParse(out quantityValue);
+        }
+        
+        var numberFormatInfo = NumberFormatInfo.GetInstance(formatProvider);
+
+        if (value.Length == 1)
+        {
+            if (!byte.TryParse(value, numberStyles, formatProvider, out var singleDigit))
+            {
+                if (value.SequenceEqual(numberFormatInfo.PositiveInfinitySymbol))
+                {
+                    quantityValue = PositiveInfinity;
+                    return true;
+                }
+
+                if (value.SequenceEqual(numberFormatInfo.NegativeInfinitySymbol))
+                {
+                    quantityValue = NegativeInfinity;
+                    return true;
+                }
+
+                if (value.SequenceEqual(numberFormatInfo.NaNSymbol))
+                {
+                    quantityValue = NaN;
+                    return true;
+                }
+
+                return CannotParse(out quantityValue);
+            }
+
+            quantityValue = singleDigit;
+            return true;
+        }
+
+        // TODO see if we want to support this
+#if FRACTION_PARSING_ENABLED
+        var ranges = new Span<Range>(new Range[2]);
+        var nbRangesFilled = value.Split(ranges, '/');
+
+        if (nbRangesFilled == 2)
+        {
+            var numeratorValue = value[ranges[0]];
+            var denominatorValue = value[ranges[1]];
+
+            var withoutDecimalPoint = numberStyles & ~NumberStyles.AllowDecimalPoint;
+            if (!BigInteger.TryParse(
+                    numeratorValue,
+                    withoutDecimalPoint,
+                    formatProvider,
+                    out var numerator)
+                || !BigInteger.TryParse(
+                    denominatorValue,
+                    withoutDecimalPoint,
+                    formatProvider,
+                    out var denominator))
+            {
+                return CannotParse(out quantityValue);
+            }
+
+            quantityValue = FromTerms(numerator, denominator);
+            return true;
+        }
+#endif
+
+        // parsing a number using to the selected NumberStyles: e.g. " $ 12345.1234321e-4- " should result in -1.23451234321 with NumberStyles.Any
+        // check for any of the special symbols (these cannot be combined with anything else)
+        if (value.SequenceEqual(numberFormatInfo.NaNSymbol.AsSpan()))
+        {
+            quantityValue = NaN;
+            return true;
+        }
+
+        if (value.SequenceEqual(numberFormatInfo.PositiveInfinitySymbol.AsSpan()))
+        {
+            quantityValue = PositiveInfinity;
+            return true;
+        }
+
+        if (value.SequenceEqual(numberFormatInfo.NegativeInfinitySymbol.AsSpan()))
+        {
+            quantityValue = NegativeInfinity;
+            return true;
+        }
+
+        var currencyAllowed = (numberStyles & NumberStyles.AllowCurrencySymbol) != 0;
+        // there "special" rules regarding the white-spaces after a leading currency symbol is detected
+        var currencyDetected = false;
+        ReadOnlySpan<char> currencySymbol;
+        if (currencyAllowed)
+        {
+            currencySymbol = numberFormatInfo.CurrencySymbol.AsSpan();
+            if (currencySymbol.IsEmpty)
+            {
+                currencyAllowed = false;
+                numberStyles &= ~NumberStyles.AllowCurrencySymbol; // no currency symbol available
+            }
+        }
+        else
+        {
+            currencySymbol = [];
+        }
+
+        // note: decimal.TryParse relies on the CurrencySymbol (when currency is detected)
+        var decimalsAllowed = (numberStyles & NumberStyles.AllowDecimalPoint) != 0;
+        var decimalSeparator = decimalsAllowed ? numberFormatInfo.NumberDecimalSeparator.AsSpan() : [];
+
+        var startIndex = 0;
+        var endIndex = value.Length;
+        var isNegative = false;
+
+        // examine the leading characters
+        do
+        {
+            var character = value[startIndex];
+            if (char.IsDigit(character))
+            {
+                break;
+            }
+
+            if (char.IsWhiteSpace(character))
+            {
+                if ((numberStyles & NumberStyles.AllowLeadingWhite) == 0)
+                {
+                    return CannotParse(out quantityValue);
+                }
+
+                startIndex++;
+                continue;
+            }
+
+            if (character == '(')
+            {
+                if ((numberStyles & NumberStyles.AllowParentheses) == 0)
+                {
+                    return CannotParse(out quantityValue); // not allowed
+                }
+
+                if (startIndex == endIndex - 1)
+                {
+                    return CannotParse(out quantityValue); // not enough characters
+                }
+
+                startIndex++; // consume the current character
+                isNegative = true; // the closing parenthesis will be validated in the backwards iteration
+
+                if (currencyDetected)
+                {
+                    // any number of white-spaces are allowed following a leading currency symbol (but no other signs)
+                    numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                      NumberStyles.AllowTrailingSign |
+                                      NumberStyles.AllowHexSpecifier);
+                }
+                else if (currencyAllowed && value[startIndex..].StartsWith(currencySymbol))
+                {
+                    // there can be no more currency symbols but there could be more white-spaces (we skip and continue) 
+                    currencyDetected = true;
+                    startIndex += currencySymbol.Length;
+                    numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                      NumberStyles.AllowTrailingSign |
+                                      NumberStyles.AllowCurrencySymbol |
+                                      NumberStyles.AllowHexSpecifier);
+                }
+                else
+                {
+                    // if next character is a white space the format should be rejected
+                    numberStyles &= ~(NumberStyles.AllowLeadingWhite |
+                                      NumberStyles.AllowLeadingSign |
+                                      NumberStyles.AllowTrailingSign |
+                                      NumberStyles.AllowHexSpecifier);
+                    break;
+                }
+
+                continue;
+            }
+
+            if ((numberStyles & NumberStyles.AllowLeadingSign) != 0)
+            {
+                if (numberFormatInfo.NegativeSign.AsSpan() is { IsEmpty: false } negativeSign && value[startIndex..].StartsWith(negativeSign))
+                {
+                    isNegative = true;
+                    startIndex += negativeSign.Length;
+                    if (currencyDetected)
+                    {
+                        // any number of white-spaces are allowed following a leading currency symbol (but no other signs)
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowHexSpecifier);
+                    }
+                    else if (currencyAllowed && value[startIndex..].StartsWith(currencySymbol))
+                    {
+                        // there can be no more currency symbols but there could be more white-spaces (we skip and continue) 
+                        currencyDetected = true;
+                        startIndex += currencySymbol.Length;
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowCurrencySymbol |
+                                          NumberStyles.AllowHexSpecifier);
+                    }
+                    else
+                    {
+                        // if next character is a white space the format should be rejected
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowLeadingWhite |
+                                          NumberStyles.AllowHexSpecifier);
+                        break;
+                    }
+
+                    continue;
+                }
+
+                if (numberFormatInfo.PositiveSign.AsSpan() is { IsEmpty: false } positiveSign && value[startIndex..].StartsWith(positiveSign))
+                {
+                    isNegative = false;
+                    startIndex += positiveSign.Length;
+                    if (currencyDetected)
+                    {
+                        // any number of white-spaces are allowed following a leading currency symbol (but no other signs)
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowHexSpecifier);
+                    }
+                    else if (currencyAllowed && value[startIndex..].StartsWith(currencySymbol))
+                    {
+                        // there can be no more currency symbols but there could be more white-spaces (we skip and continue) 
+                        currencyDetected = true;
+                        startIndex += currencySymbol.Length;
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowCurrencySymbol |
+                                          NumberStyles.AllowHexSpecifier);
+                    }
+                    else
+                    {
+                        // if next character is a white space the format should be rejected
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowLeadingWhite |
+                                          NumberStyles.AllowHexSpecifier);
+                        break;
+                    }
+
+                    continue;
+                }
+            }
+
+            if (currencyAllowed && !currencyDetected && value[startIndex..].StartsWith(currencySymbol))
+            {
+                // there can be no more currency symbols but there could be more white-spaces (we skip and continue)
+                currencyDetected = true;
+                numberStyles &= ~NumberStyles.AllowCurrencySymbol;
+                startIndex += currencySymbol.Length;
+                continue;
+            }
+
+            if (decimalsAllowed && value[startIndex..].StartsWith(decimalSeparator))
+            {
+                break; // decimal string with no leading zeros
+            }
+
+            // this is either an expected hex string or an invalid format
+            return (numberStyles & NumberStyles.AllowHexSpecifier) != 0
+                ? TryParseInteger(value[startIndex..endIndex], numberStyles & ~NumberStyles.AllowTrailingSign,
+                    formatProvider, isNegative, out quantityValue)
+                : CannotParse(out quantityValue); // unexpected character
+        } while (startIndex < endIndex);
+
+        if (startIndex >= endIndex)
+        {
+            return CannotParse(out quantityValue);
+        }
+
+        if (isNegative)
+        {
+            numberStyles &= ~(NumberStyles.AllowLeadingWhite |
+                              NumberStyles.AllowLeadingSign);
+        }
+        else
+        {
+            numberStyles &= ~(NumberStyles.AllowLeadingWhite |
+                              NumberStyles.AllowLeadingSign |
+                              NumberStyles.AllowParentheses);
+        }
+
+        // examine the trailing characters
+        do
+        {
+            var character = value[endIndex - 1];
+            if (char.IsDigit(character))
+            {
+                break;
+            }
+
+            if (char.IsWhiteSpace(character))
+            {
+                if ((numberStyles & NumberStyles.AllowTrailingWhite) == 0)
+                {
+                    return CannotParse(out quantityValue);
+                }
+
+                endIndex--;
+                continue;
+            }
+
+            if (character == ')')
+            {
+                if ((numberStyles & NumberStyles.AllowParentheses) == 0)
+                {
+                    return CannotParse(out quantityValue); // not allowed
+                }
+
+                numberStyles &= ~(NumberStyles.AllowParentheses | NumberStyles.AllowCurrencySymbol);
+                endIndex--;
+                continue;
+            }
+
+            if ((numberStyles & NumberStyles.AllowTrailingSign) != 0)
+            {
+                if (numberFormatInfo.NegativeSign.AsSpan() is { IsEmpty: false } negativeSign && value[..endIndex].EndsWith(negativeSign))
+                {
+                    isNegative = true;
+                    numberStyles &= ~(NumberStyles.AllowTrailingSign | NumberStyles.AllowHexSpecifier);
+                    endIndex -= negativeSign.Length;
+                    continue;
+                }
+
+                if (numberFormatInfo.PositiveSign.AsSpan() is { IsEmpty: false } positiveSign && value[..endIndex].EndsWith(positiveSign))
+                {
+                    isNegative = false;
+                    numberStyles &= ~(NumberStyles.AllowTrailingSign | NumberStyles.AllowHexSpecifier);
+                    endIndex -= positiveSign.Length;
+                    continue;
+                }
+            }
+
+            if (currencyAllowed && !currencyDetected && value[..endIndex].EndsWith(currencySymbol))
+            {
+                // there can be no more currency symbols but there could be more white-spaces (we skip and continue)
+                currencyDetected = true;
+                numberStyles &= ~NumberStyles.AllowCurrencySymbol;
+                endIndex -= currencySymbol.Length;
+                continue;
+            }
+
+            if (decimalsAllowed && value[..endIndex].EndsWith(decimalSeparator))
+            {
+                break;
+            }
+
+            // this is either an expected hex string or an invalid format
+            return (numberStyles & NumberStyles.AllowHexSpecifier) != 0
+                ? TryParseInteger(value[startIndex..endIndex], numberStyles & ~NumberStyles.AllowTrailingSign,
+                    formatProvider, isNegative, out quantityValue)
+                : CannotParse(out quantityValue); // unexpected character
+        } while (startIndex < endIndex);
+
+        if (startIndex >= endIndex)
+        {
+            return CannotParse(out quantityValue); // not enough characters
+        }
+
+        if (isNegative && (numberStyles & NumberStyles.AllowParentheses) != 0)
+        {
+            return CannotParse(out quantityValue); // failed to find a closing parentheses
+        }
+
+        numberStyles &= ~(NumberStyles.AllowTrailingWhite |
+                          NumberStyles.AllowTrailingSign |
+                          NumberStyles.AllowCurrencySymbol);
+        // at this point value[startIndex, endIndex] should correspond to the number without the sign (or the format is invalid)
+        var unsignedValue = value[startIndex..endIndex];
+
+        if (unsignedValue.Length == 1)
+        {
+            // this can only be a single digit (integer)
+            return TryParseInteger(unsignedValue, numberStyles, formatProvider, isNegative, out quantityValue);
+        }
+
+        if ((numberStyles & NumberStyles.AllowExponent) != 0)
+        {
+            return TryParseWithExponent(unsignedValue, numberStyles, numberFormatInfo, isNegative, out quantityValue);
+        }
+
+        return decimalsAllowed
+            ? TryParseDecimalNumber(unsignedValue, numberStyles, numberFormatInfo, isNegative, out quantityValue)
+            : TryParseInteger(unsignedValue, numberStyles, formatProvider, isNegative, out quantityValue);
+    }
+
+    private static bool TryParseWithExponent(ReadOnlySpan<char> value, NumberStyles parseNumberStyles,
+        NumberFormatInfo numberFormatInfo, bool isNegative, out QuantityValue quantityValue)
+    {
+        // 1. try to find the exponent character (extracting the left and right sides)
+        parseNumberStyles &= ~NumberStyles.AllowExponent;
+        if (!TrySplitAny(value, ['E', 'e'], out ReadOnlySpan<char> coefficientSpan, out ReadOnlySpan<char> exponentSpan))
+        {
+            // no exponent found
+            return (parseNumberStyles & NumberStyles.AllowDecimalPoint) != 0
+                ? TryParseDecimalNumber(value, parseNumberStyles, numberFormatInfo, isNegative, out quantityValue)
+                : TryParseInteger(value, parseNumberStyles, numberFormatInfo, isNegative, out quantityValue);
+        }
+
+        // 2. try to parse the exponent (w.r.t. the scientific notation format)
+        if (!int.TryParse(exponentSpan, NumberStyles.AllowLeadingSign | NumberStyles.Integer, numberFormatInfo,
+                out var exponent))
+        {
+            return CannotParse(out quantityValue);
+        }
+
+        // 3. try to parse the coefficient (w.r.t. the decimal separator allowance)
+        if (coefficientSpan.Length == 1 || (parseNumberStyles & NumberStyles.AllowDecimalPoint) == 0)
+        {
+            if (!TryParseInteger(coefficientSpan, parseNumberStyles, numberFormatInfo, isNegative, out quantityValue))
+            {
+                return false;
+            }
+        }
+        else
+        {
+            if (!TryParseDecimalNumber(coefficientSpan, parseNumberStyles, numberFormatInfo, isNegative, out quantityValue))
+            {
+                return false;
+            }
+        }
+
+        // 4. multiply the coefficient by 10 to the power of the exponent
+        quantityValue = new QuantityValue(quantityValue.Numerator, quantityValue.Denominator, exponent);
+        return true;
+    }
+
+    private static bool TryParseDecimalNumber(ReadOnlySpan<char> value, NumberStyles parseNumberStyles,
+        NumberFormatInfo numberFormatInfo, bool isNegative, out QuantityValue quantityValue)
+    {
+        // 1. try to find the decimal separator (extracting the left and right sides)
+        if (!TrySplit(value, numberFormatInfo.NumberDecimalSeparator, out ReadOnlySpan<char> integerSpan, out ReadOnlySpan<char> fractionalSpan))
+        {
+            return TryParseInteger(value, parseNumberStyles, numberFormatInfo, isNegative, out quantityValue);
+        }
+        
+        // 2. validate the format of the string after the radix
+        if (fractionalSpan.IsEmpty)
+        {
+            // after excluding the sign, the input was reduced to just an integer part (e.g. "1 234.")
+            return TryParseInteger(integerSpan, parseNumberStyles, numberFormatInfo, isNegative, out quantityValue);
+        }
+
+        if ((parseNumberStyles & NumberStyles.AllowThousands) != 0)
+        {
+            if (fractionalSpan.Contains(numberFormatInfo.NumberGroupSeparator, StringComparison.Ordinal))
+            {
+                return CannotParse(out quantityValue); // number group separator detected in the fractional part (e.g. "1.2 34")
+            }
+        }
+
+        // 3. extract the value of the string corresponding to the number without the decimal separator: "0.123 " should return "0123"
+        var integerString = string.Concat(integerSpan, fractionalSpan);
+        if (!BigInteger.TryParse(integerString, parseNumberStyles, numberFormatInfo, out var numerator))
+        {
+            return CannotParse(out quantityValue);
+        }
+
+        if (numerator.IsZero)
+        {
+            quantityValue = Zero;
+            return true;
+        }
+
+        if (isNegative)
+        {
+            numerator = -numerator;
+        }
+
+        // 4. construct the fractional part using the corresponding decimal power for the denominator
+        var nbDecimals = fractionalSpan.Length;
+        BigInteger denominator = PowerOfTen(nbDecimals);
+        quantityValue = new QuantityValue(numerator, denominator);
+        return true;
+    }
+
+    private static bool TryParseInteger(ReadOnlySpan<char> value, NumberStyles parseNumberStyles,
+        IFormatProvider? formatProvider, bool isNegative, out QuantityValue quantityValue)
+    {
+        if (!BigInteger.TryParse(value, parseNumberStyles, formatProvider, out var bigInteger))
+        {
+            return CannotParse(out quantityValue);
+        }
+
+        quantityValue = isNegative ? -bigInteger : bigInteger;
+        return true;
+    }
+    
+    private static bool TrySplit(ReadOnlySpan<char> span, ReadOnlySpan<char> separator, out ReadOnlySpan<char> firstSpan, out ReadOnlySpan<char> secondSpan)
+    {
+        var separatorIndex = span.IndexOf(separator);
+            
+        if (separatorIndex < 0)
+        {
+            firstSpan = span;
+            secondSpan = ReadOnlySpan<char>.Empty;
+            return false;
+        }
+        
+        firstSpan = span[..separatorIndex];
+        secondSpan = span[(separatorIndex + separator.Length)..];
+        return true;
+    }
+    
+    private static bool TrySplitAny(ReadOnlySpan<char> span, ReadOnlySpan<char> separators, out ReadOnlySpan<char> firstSpan, out ReadOnlySpan<char> secondSpan)
+    {
+        var separatorIndex = span.IndexOfAny(separators);
+            
+        if (separatorIndex < 0)
+        {
+            firstSpan = span;
+            secondSpan = ReadOnlySpan<char>.Empty;
+            return false;
+        }
+        
+        firstSpan = span[..separatorIndex];
+        secondSpan = span[(separatorIndex + 1)..];
+        return true;
+    }
+#else
+    /// <summary>
+    ///     Attempts to parse a string of characters into a QuantityValue, and returns a value
+    ///     that indicates whether the conversion succeeded.
+    /// </summary>
+    /// <param name="value">
+    ///     The input string to parse. The numerator and denominator must be separated by a '/' (slash) character.
+    ///     For example, "3/4". If the string is not in this format, the parsing behavior is influenced by the
+    ///     <paramref name="numberStyles" /> and <paramref name="formatProvider" /> parameters.
+    /// </param>
+    /// <param name="numberStyles">
+    ///     A bitwise combination of number styles permitted in the input string. This is relevant when the string
+    ///     is not in the numerator/denominator format. For instance, <see cref="NumberStyles.Float" /> allows decimal
+    ///     points and scientific notation.
+    /// </param>
+    /// <param name="formatProvider">
+    ///     An <see cref="IFormatProvider" /> that supplies culture-specific information used to parse the input string.
+    ///     This is relevant when the string is not in the numerator/denominator format. For example,
+    ///     <c>CultureInfo.GetCultureInfo("en-US")</c> for US English culture.
+    /// </param>
+    /// <param name="quantityValue">
+    ///     When this method returns, contains the parsed fraction if the operation was successful; otherwise,
+    ///     it contains the default value of <see cref="QuantityValue" />.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the input string is well-formed and could be parsed into a fraction; otherwise, <c>false</c>.
+    /// </returns>
+    /// <remarks>
+    ///     The <paramref name="numberStyles" /> parameter allows you to specify which number styles are allowed in the input
+    ///     string.
+    ///     For example, <see cref="NumberStyles.Float" /> allows decimal points and scientific notation.
+    ///     The <paramref name="formatProvider" /> parameter provides culture-specific formatting information.
+    ///     For example, you can use <c>CultureInfo.GetCultureInfo("en-US")</c> for US English culture.
+    ///     Here are some examples of how to use the
+    ///     <see cref="TryParse(string, NumberStyles, IFormatProvider, out QuantityValue)" /> method:
+    ///     <example>
+    ///         <code>
+    /// QuantityValue.TryParse("3/4", NumberStyles.Any, CultureInfo.GetCultureInfo("en-US"), true, out var fraction);
+    /// </code>
+    ///         This example parses the string "3/4" into a <see cref="QuantityValue" /> object with a numerator of 3 and a
+    ///         denominator of 4.
+    ///         <code>
+    /// QuantityValue.TryParse("1.25", NumberStyles.Number, CultureInfo.GetCultureInfo("en-US"), true, out var fraction);
+    /// </code>
+    ///         This example parses the string "1.25" into a <see cref="QuantityValue" /> object with a numerator of 5 and a
+    ///         denominator of 4.
+    ///         <code>
+    /// QuantityValue.TryParse("1.23e-2", NumberStyles.Float, CultureInfo.GetCultureInfo("en-US"), true, out var fraction);
+    /// </code>
+    ///         This example parses the string "1.23e-2" into a <see cref="QuantityValue" /> object with a numerator of 123 and
+    ///         a
+    ///         denominator of 10000.
+    ///     </example>
+    /// </remarks>
+    public static bool TryParse(string? value, NumberStyles numberStyles, IFormatProvider? formatProvider, out QuantityValue quantityValue)
+    {
+        if (string.IsNullOrEmpty(value))
+        {
+            return CannotParse(out quantityValue);
+        }
+        
+        var numberFormatInfo = NumberFormatInfo.GetInstance(formatProvider);
+
+        if (value!.Length == 1)
+        {
+            if (!byte.TryParse(value, numberStyles, formatProvider, out var singleDigit))
+            {
+                if (value == numberFormatInfo.PositiveInfinitySymbol)
+                {
+                    quantityValue = PositiveInfinity;
+                    return true;
+                }
+
+                if (value == numberFormatInfo.NegativeInfinitySymbol)
+                {
+                    quantityValue = NegativeInfinity;
+                    return true;
+                }
+
+                if (value == numberFormatInfo.NaNSymbol)
+                {
+                    quantityValue = NaN;
+                    return true;
+                }
+
+                return CannotParse(out quantityValue);
+            }
+
+            quantityValue = new QuantityValue(singleDigit);
+            return true;
+        }
+
+        // TODO see if we want to support this
+#if FRACTION_PARSING_ENABLED
+        var components = value.Split('/');
+        if (components.Length >= 2)
+        {
+            var numeratorString = components[0];
+            var denominatorString = components[1];
+
+            var withoutDecimalPoint = numberStyles & ~NumberStyles.AllowDecimalPoint;
+            if (!BigInteger.TryParse(
+                    numeratorString,
+                    withoutDecimalPoint,
+                    formatProvider,
+                    out var numerator)
+                || !BigInteger.TryParse(
+                    denominatorString,
+                    withoutDecimalPoint,
+                    formatProvider,
+                    out var denominator))
+            {
+                return CannotParse(out quantityValue);
+            }
+
+            quantityValue = FromTerms(numerator, denominator);
+            return true;
+        }
+#endif
+
+        // parsing a number using to the selected NumberStyles: e.g. " $ 12345.1234321e-4- " should result in -1.23451234321 with NumberStyles.Any
+        // check for any of the special symbols (these cannot be combined with anything else)
+        if (value == numberFormatInfo.NaNSymbol)
+        {
+            quantityValue = NaN;
+            return true;
+        }
+
+        if (value == numberFormatInfo.PositiveInfinitySymbol)
+        {
+            quantityValue = PositiveInfinity;
+            return true;
+        }
+
+        if (value == numberFormatInfo.NegativeInfinitySymbol)
+        {
+            quantityValue = NegativeInfinity;
+            return true;
+        }
+
+        var currencyAllowed = (numberStyles & NumberStyles.AllowCurrencySymbol) != 0;
+
+        // there "special" rules regarding the white-spaces after a leading currency symbol is detected
+        var currencyDetected = false;
+
+        var currencySymbol = numberFormatInfo.CurrencySymbol;
+        if (currencyAllowed && string.IsNullOrEmpty(currencySymbol))
+        {
+            numberStyles &= ~NumberStyles.AllowCurrencySymbol; // no currency symbol available
+            currencyAllowed = false;
+        }
+
+        // note: decimal.TryParse relies on the CurrencySymbol (when currency is detected)
+        var decimalSeparator = numberFormatInfo.NumberDecimalSeparator;
+        var decimalsAllowed = (numberStyles & NumberStyles.AllowDecimalPoint) != 0;
+
+        var startIndex = 0;
+        var endIndex = value.Length;
+        var isNegative = false;
+
+        // examine the leading characters
+        do
+        {
+            var character = value[startIndex];
+            if (char.IsDigit(character))
+            {
+                break;
+            }
+
+            if (char.IsWhiteSpace(character))
+            {
+                if ((numberStyles & NumberStyles.AllowLeadingWhite) == 0)
+                {
+                    return CannotParse(out quantityValue);
+                }
+
+                startIndex++;
+                continue;
+            }
+
+            if (character == '(')
+            {
+                if ((numberStyles & NumberStyles.AllowParentheses) == 0)
+                {
+                    return CannotParse(out quantityValue); // not allowed
+                }
+
+                if (startIndex == endIndex - 1)
+                {
+                    return CannotParse(out quantityValue); // not enough characters
+                }
+
+                startIndex++; // consume the current character
+                isNegative = true; // the closing parenthesis will be validated in the backwards iteration
+
+                if (currencyDetected)
+                {
+                    // any number of white-spaces are allowed following a leading currency symbol (but no other signs)
+                    numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                      NumberStyles.AllowTrailingSign |
+                                      NumberStyles.AllowHexSpecifier);
+                }
+                else if (currencyAllowed && StartsWith(value, currencySymbol, startIndex))
+                {
+                    // there can be no more currency symbols but there could be more white-spaces (we skip and continue) 
+                    currencyDetected = true;
+                    startIndex += currencySymbol.Length;
+                    numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                      NumberStyles.AllowTrailingSign |
+                                      NumberStyles.AllowCurrencySymbol |
+                                      NumberStyles.AllowHexSpecifier);
+                }
+                else
+                {
+                    // if next character is a white space the format should be rejected
+                    numberStyles &= ~(NumberStyles.AllowLeadingWhite |
+                                      NumberStyles.AllowLeadingSign |
+                                      NumberStyles.AllowTrailingSign |
+                                      NumberStyles.AllowHexSpecifier);
+                    break;
+                }
+
+                continue;
+            }
+
+            if ((numberStyles & NumberStyles.AllowLeadingSign) != 0)
+            {
+                if (numberFormatInfo.NegativeSign is { Length: > 0 } negativeSign &&
+                    StartsWith(value, negativeSign, startIndex))
+                {
+                    isNegative = true;
+                    startIndex += negativeSign.Length;
+                    if (currencyDetected)
+                    {
+                        // any number of white-spaces are allowed following a leading currency symbol (but no other signs)
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowHexSpecifier);
+                    }
+                    else if (currencyAllowed && StartsWith(value, currencySymbol, startIndex))
+                    {
+                        // there can be no more currency symbols but there could be more white-spaces (we skip and continue) 
+                        currencyDetected = true;
+                        startIndex += currencySymbol.Length;
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowCurrencySymbol |
+                                          NumberStyles.AllowHexSpecifier);
+                    }
+                    else
+                    {
+                        // if next character is a white space the format should be rejected
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowLeadingWhite |
+                                          NumberStyles.AllowHexSpecifier);
+                        break;
+                    }
+
+                    continue;
+                }
+
+                if (numberFormatInfo.PositiveSign is { Length: > 0 } positiveSign &&
+                    StartsWith(value, positiveSign, startIndex))
+                {
+                    isNegative = false;
+                    startIndex += positiveSign.Length;
+                    if (currencyDetected)
+                    {
+                        // any number of white-spaces are allowed following a leading currency symbol (but no other signs)
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowHexSpecifier);
+                    }
+                    else if (currencyAllowed && StartsWith(value, currencySymbol, startIndex))
+                    {
+                        // there can be no more currency symbols but there could be more white-spaces (we skip and continue) 
+                        currencyDetected = true;
+                        startIndex += currencySymbol.Length;
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowCurrencySymbol |
+                                          NumberStyles.AllowHexSpecifier);
+                    }
+                    else
+                    {
+                        // if next character is a white space the format should be rejected
+                        numberStyles &= ~(NumberStyles.AllowLeadingSign |
+                                          NumberStyles.AllowTrailingSign |
+                                          NumberStyles.AllowParentheses |
+                                          NumberStyles.AllowLeadingWhite |
+                                          NumberStyles.AllowHexSpecifier);
+                        break;
+                    }
+
+                    continue;
+                }
+            }
+
+            if (currencyAllowed && !currencyDetected && StartsWith(value, currencySymbol, startIndex))
+            {
+                // there can be no more currency symbols but there could be more white-spaces (we skip and continue)
+                currencyDetected = true;
+                numberStyles &= ~NumberStyles.AllowCurrencySymbol;
+                startIndex += currencySymbol.Length;
+                continue;
+            }
+
+            if (decimalsAllowed && StartsWith(value, decimalSeparator, startIndex))
+            {
+                break; // decimal string with no leading zeros
+            }
+
+            // this is either an expected hex string or an invalid format
+            return (numberStyles & NumberStyles.AllowHexSpecifier) != 0
+                ? TryParseInteger(value, numberStyles & ~NumberStyles.AllowTrailingSign, formatProvider, startIndex,
+                    endIndex, isNegative, out quantityValue)
+                : CannotParse(out quantityValue); // unexpected character
+        } while (startIndex < endIndex);
+
+        if (startIndex >= endIndex)
+        {
+            return CannotParse(out quantityValue);
+        }
+
+        if (isNegative)
+        {
+            numberStyles &= ~(NumberStyles.AllowLeadingWhite |
+                              NumberStyles.AllowLeadingSign);
+        }
+        else
+        {
+            numberStyles &= ~(NumberStyles.AllowLeadingWhite |
+                              NumberStyles.AllowLeadingSign |
+                              NumberStyles.AllowParentheses);
+        }
+
+        // examine the trailing characters
+        do
+        {
+            var character = value[endIndex - 1];
+            if (char.IsDigit(character))
+            {
+                break;
+            }
+
+            if (char.IsWhiteSpace(character))
+            {
+                if ((numberStyles & NumberStyles.AllowTrailingWhite) == 0)
+                {
+                    return CannotParse(out quantityValue);
+                }
+
+                endIndex--;
+                continue;
+            }
+
+            if (character == ')')
+            {
+                if ((numberStyles & NumberStyles.AllowParentheses) == 0)
+                {
+                    return CannotParse(out quantityValue); // not allowed
+                }
+
+                numberStyles &= ~(NumberStyles.AllowParentheses | NumberStyles.AllowCurrencySymbol);
+                endIndex--;
+                continue;
+            }
+
+            if ((numberStyles & NumberStyles.AllowTrailingSign) != 0)
+            {
+                if (numberFormatInfo.NegativeSign is { Length: > 0 } negativeSign &&
+                    EndsWith(value, negativeSign, endIndex))
+                {
+                    isNegative = true;
+                    numberStyles &= ~(NumberStyles.AllowTrailingSign | NumberStyles.AllowHexSpecifier);
+                    endIndex -= negativeSign.Length;
+                    continue;
+                }
+
+                if (numberFormatInfo.PositiveSign is { Length: > 0 } positiveSign &&
+                    EndsWith(value, positiveSign, endIndex))
+                {
+                    isNegative = false;
+                    numberStyles &= ~(NumberStyles.AllowTrailingSign | NumberStyles.AllowHexSpecifier);
+                    endIndex -= positiveSign.Length;
+                    continue;
+                }
+            }
+
+            if (currencyAllowed && !currencyDetected && EndsWith(value, currencySymbol, endIndex))
+            {
+                // there can be no more currency symbols but there could be more white-spaces (we skip and continue)
+                currencyDetected = true;
+                numberStyles &= ~NumberStyles.AllowCurrencySymbol;
+                endIndex -= currencySymbol.Length;
+                continue;
+            }
+
+            if (decimalsAllowed && EndsWith(value, decimalSeparator, endIndex))
+            {
+                break;
+            }
+
+            // this is either an expected hex string or an invalid format
+            return (numberStyles & NumberStyles.AllowHexSpecifier) != 0
+                ? TryParseInteger(value, numberStyles & ~NumberStyles.AllowTrailingSign, formatProvider, startIndex,
+                    endIndex, isNegative, out quantityValue)
+                : CannotParse(out quantityValue); // unexpected character
+        } while (startIndex < endIndex);
+
+        if (startIndex >= endIndex)
+        {
+            return CannotParse(out quantityValue); // not enough characters
+        }
+
+        if (isNegative && (numberStyles & NumberStyles.AllowParentheses) != 0)
+        {
+            return CannotParse(out quantityValue); // failed to find a closing parentheses
+        }
+
+        numberStyles &= ~(NumberStyles.AllowTrailingWhite |
+                          NumberStyles.AllowTrailingSign |
+                          NumberStyles.AllowCurrencySymbol);
+        // at this point value[startIndex, endIndex] should correspond to the number without the sign (or the format is invalid)
+
+        if (startIndex == endIndex - 1)
+        {
+            // this can only be a single digit (integer)
+            return TryParseInteger(value, numberStyles, formatProvider, startIndex, endIndex, isNegative, out quantityValue);
+        }
+
+        if ((numberStyles & NumberStyles.AllowExponent) != 0)
+        {
+            return TryParseWithExponent(value, numberStyles, numberFormatInfo, startIndex, endIndex, isNegative, out quantityValue);
+        }
+
+        return decimalsAllowed
+            ? TryParseDecimalNumber(value, numberStyles, numberFormatInfo, startIndex, endIndex, isNegative, out quantityValue)
+            : TryParseInteger(value, numberStyles, formatProvider, startIndex, endIndex, isNegative, out quantityValue);
+
+        static bool StartsWith(string fractionString, string testString, int startIndex)
+        {
+            var stringLength = testString.Length;
+            if (fractionString.Length - startIndex < stringLength)
+            {
+                return false;
+            }
+
+            for (var i = 0; i < stringLength; i++)
+            {
+                if (testString[i] != fractionString[startIndex + i])
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        static bool EndsWith(string fractionString, string testString, int endIndex)
+        {
+            return endIndex >= testString.Length && StartsWith(fractionString, testString, endIndex - testString.Length);
+        }
+    }
+
+    private static bool TryParseWithExponent(string valueString, NumberStyles parseNumberStyles,
+        NumberFormatInfo numberFormatInfo,
+        int startIndex, int endIndex, bool isNegative, out QuantityValue quantityValue)
+    {
+        // 1. try to find the exponent character index
+        parseNumberStyles &= ~NumberStyles.AllowExponent;
+        var exponentIndex = valueString.IndexOfAny(['e', 'E'], startIndex + 1, endIndex - startIndex - 1);
+        if (exponentIndex == -1)
+        {
+            // no exponent found
+            return (parseNumberStyles & NumberStyles.AllowDecimalPoint) != 0
+                ? TryParseDecimalNumber(valueString, parseNumberStyles, numberFormatInfo, startIndex, endIndex,
+                    isNegative, out quantityValue)
+                : TryParseInteger(valueString, parseNumberStyles, numberFormatInfo, startIndex, endIndex, isNegative,
+                    out quantityValue);
+        }
+
+        // 2. try to parse the exponent (w.r.t. the scientific notation format)
+        var exponentString = valueString.Substring(exponentIndex + 1, endIndex - exponentIndex - 1);
+        if (!int.TryParse(exponentString, NumberStyles.AllowLeadingSign | NumberStyles.Integer, numberFormatInfo,
+                out var exponent))
+        {
+            return CannotParse(out quantityValue);
+        }
+
+        // 3. try to parse the coefficient (w.r.t. the decimal separator allowance)
+        if (startIndex == endIndex - 1 || (parseNumberStyles & NumberStyles.AllowDecimalPoint) == 0)
+        {
+            if (!TryParseInteger(valueString, parseNumberStyles, numberFormatInfo, startIndex, exponentIndex,
+                    isNegative, out quantityValue))
+            {
+                return false;
+            }
+        }
+        else
+        {
+            if (!TryParseDecimalNumber(valueString, parseNumberStyles, numberFormatInfo, startIndex, exponentIndex, isNegative, out quantityValue))
+            {
+                return false;
+            }
+        }
+
+        // 4. multiply the coefficient by 10 to the power of the exponent
+        quantityValue = new QuantityValue(quantityValue.Numerator, quantityValue.Denominator, exponent);
+        return true;
+    }
+
+    private static bool TryParseDecimalNumber(string valueString, NumberStyles parseNumberStyles, NumberFormatInfo numberFormatInfo,
+        int startIndex, int endIndex, bool isNegative, out QuantityValue fraction)
+    {
+        // 1. find the position of the decimal separator (if any)
+        var decimalSeparatorIndex = valueString.IndexOf(numberFormatInfo.NumberDecimalSeparator, startIndex,
+            endIndex - startIndex, StringComparison.Ordinal);
+        if (decimalSeparatorIndex == -1)
+        {
+            return TryParseInteger(valueString, parseNumberStyles, numberFormatInfo, startIndex, endIndex, isNegative,
+                out fraction);
+        }
+
+        // 2. validate the format of the string after the radix
+        var decimalSeparatorLength = numberFormatInfo.NumberDecimalSeparator.Length;
+        if (startIndex + decimalSeparatorLength == endIndex)
+        {
+            // after excluding the sign, the input was reduced to just the decimal separator (with nothing on either sides)
+            return CannotParse(out fraction);
+        }
+
+        if ((parseNumberStyles & NumberStyles.AllowThousands) != 0)
+        {
+            if (valueString.IndexOf(numberFormatInfo.NumberGroupSeparator,
+                    decimalSeparatorIndex + decimalSeparatorLength, StringComparison.Ordinal) != -1)
+            {
+                return CannotParse(out fraction);
+            }
+        }
+
+        // 3. extract the value of the string corresponding to the number without the decimal separator: " 0.123 " should return "0123"
+        var integerString = string.Concat(
+            valueString.Substring(startIndex, decimalSeparatorIndex - startIndex),
+            valueString.Substring(decimalSeparatorIndex + decimalSeparatorLength,
+                endIndex - decimalSeparatorIndex - decimalSeparatorLength));
+
+        if (!BigInteger.TryParse(integerString, parseNumberStyles, numberFormatInfo, out var numerator))
+        {
+            return CannotParse(out fraction);
+        }
+
+        if (numerator.IsZero)
+        {
+            fraction = Zero;
+            return true;
+        }
+
+        if (isNegative)
+        {
+            numerator = -numerator;
+        }
+
+        var nbDecimals = endIndex - decimalSeparatorIndex - decimalSeparatorLength;
+        if (nbDecimals == 0)
+        {
+            fraction = new QuantityValue(numerator);
+            return true;
+        }
+
+        // 4. construct the fractional part using the corresponding decimal power for the denominator
+        var denominator = PowerOfTen(nbDecimals);
+        fraction = new QuantityValue(numerator, denominator);
+        return true;
+    }
+
+    private static bool TryParseInteger(string valueString, NumberStyles parseNumberStyles,
+        IFormatProvider? formatProvider,
+        int startIndex, int endIndex, bool isNegative, out QuantityValue fraction)
+    {
+        if (!BigInteger.TryParse(valueString.Substring(startIndex, endIndex - startIndex), parseNumberStyles,
+                formatProvider, out var bigInteger))
+        {
+            return CannotParse(out fraction);
+        }
+
+        fraction = new QuantityValue(isNegative ? -bigInteger : bigInteger);
+        return true;
+    }
+#endif
+
+
+    /// <summary>
+    ///     Sets the out parameter to the default value of QuantityValue and returns false.
+    ///     This method is used when the parsing of a string to a QuantityValue fails.
+    /// </summary>
+    /// <param name="quantityValue">The QuantityValue object that will be set to its default value.</param>
+    /// <returns>Always returns false.</returns>
+    private static bool CannotParse(out QuantityValue quantityValue)
+    {
+        quantityValue = default;
+        return false;
+    }
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.ConvertToNumber.cs b/UnitsNet/CustomCode/Value/QuantityValue.ConvertToNumber.cs
new file mode 100644
index 0000000000..4710d69dbb
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.ConvertToNumber.cs
@@ -0,0 +1,829 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Numerics;
+#if NET7_0_OR_GREATER
+using System.Diagnostics.CodeAnalysis;
+#endif
+
+namespace UnitsNet;
+
+public partial struct QuantityValue
+{
+    private static readonly BigInteger MaxDecimal = new(decimal.MaxValue);
+    private static readonly BigInteger MinDecimal = -MaxDecimal;
+    private static readonly BigInteger MaxDouble = new(double.MaxValue);
+    private static readonly BigInteger MinDouble = -MaxDouble;
+
+    /// <summary>The implicit cast from <see cref="QuantityValue" /> to <see cref="double" /> is lossy.</summary>
+    public static implicit operator double(QuantityValue value)
+    {
+        return value.ToDouble();
+    }
+
+    /// <summary>
+    ///     Converts the quantity value to the closest double-precision floating point number.
+    /// </summary>
+    /// <returns>
+    ///     A double-precision floating point representation of the quantity value, which may be NaN, positive infinity, or
+    ///     negative infinity.
+    /// </returns>
+    public double ToDouble()
+    {
+        var numerator = Numerator;
+        var denominator = Denominator;
+        if (denominator.IsZero)
+        {
+            return numerator.Sign switch
+            {
+                1 => double.PositiveInfinity,
+                -1 => double.NegativeInfinity,
+                _ => double.NaN
+            };
+        }
+
+        if (numerator.IsZero)
+        {
+            return 0;
+        }
+
+        if (denominator.IsOne)
+        {
+            return (double)numerator;
+        }
+
+        var convertedNumerator = (double)numerator;
+        if (double.IsPositiveInfinity(convertedNumerator))
+        {
+            if (denominator > MaxDouble)
+            {
+                // both terms need to be rounded
+                numerator = numerator * MaxDouble / denominator;
+                denominator = MaxDouble;
+                if (numerator <= MaxDouble)
+                {
+                    // both terms are now within range
+                    return (double)numerator / (double)denominator;
+                }
+            }
+
+            var withoutDecimalPlaces = (double)BigInteger.DivRem(numerator, denominator, out var remainder);
+            if (double.IsPositiveInfinity(withoutDecimalPlaces))
+            {
+                return double.PositiveInfinity;
+            }
+
+            return remainder.IsZero ? withoutDecimalPlaces : withoutDecimalPlaces + (double)remainder / (double)denominator;
+        }
+
+        if (double.IsNegativeInfinity(convertedNumerator))
+        {
+            if (denominator > MaxDouble)
+            {
+                // both terms need to be rounded
+                numerator = numerator * MaxDouble / denominator;
+                denominator = MaxDouble;
+                if (numerator >= MinDouble)
+                {
+                    // both terms are now within range
+                    return (double)numerator / (double)denominator;
+                }
+            }
+
+            var withoutDecimalPlaces = (double)BigInteger.DivRem(numerator, denominator, out var remainder);
+            if (double.IsNegativeInfinity(withoutDecimalPlaces))
+            {
+                return double.NegativeInfinity;
+            }
+
+            return remainder.IsZero ? withoutDecimalPlaces : withoutDecimalPlaces + (double)remainder / (double)denominator;
+        }
+
+        var convertedDenominator = (double)denominator;
+        if (double.IsPositiveInfinity(convertedDenominator))
+        {
+            // since both terms are non-zero and the numerator is smaller (in magnitude) to the denominator
+            // the resulting number would be in the range [-1,1] (exclusive)
+            // we want to flip the operation: x = a/b -> 1/x = b/a
+            var decimalPart = (double)BigInteger.DivRem(denominator, numerator, out var remainder);
+            if (double.IsInfinity(decimalPart))
+            {
+                return 0;
+            }
+
+            return remainder.IsZero ? 1 / decimalPart : 1 / (decimalPart + (double)remainder / (double)numerator);
+        }
+
+        return convertedNumerator / convertedDenominator;
+    }
+
+    /// <summary>Explicit cast from <see cref="QuantityValue" /> to <see cref="decimal" />.</summary>
+    public static explicit operator decimal(QuantityValue value)
+    {
+        return value.ToDecimal();
+    }
+
+    /// <summary>
+    ///     Converts the current <see cref="QuantityValue" /> to its <see cref="decimal" /> equivalent.
+    /// </summary>
+    /// <returns>
+    ///     A <see cref="decimal" /> that represents the value of the current <see cref="QuantityValue" />.
+    /// </returns>
+    /// <exception cref="OverflowException">
+    ///     Thrown when the denominator of the underlying fraction is zero (case of PositiveInfinity, NegativeInfinity or NaN)
+    ///     or when the resulting number is outside the range of the <see cref="decimal" /> type.
+    /// </exception>
+    public decimal ToDecimal()
+    {
+        var numerator = Numerator;
+        var denominator = Denominator;
+        if (denominator.IsZero)
+        {
+            throw new OverflowException();
+        }
+
+        if (numerator.IsZero)
+        {
+            return decimal.Zero;
+        }
+
+        if (denominator.IsOne)
+        {
+            return (decimal)numerator;
+        }
+
+        if (numerator > MaxDecimal)
+        {
+            if (denominator > MaxDecimal)
+            {
+                // both terms need to be rounded
+                numerator = numerator * MaxDecimal / denominator;
+                denominator = MaxDecimal;
+                if (numerator <= MaxDecimal)
+                {
+                    // both terms are now within range
+                    return (decimal)numerator / (decimal)denominator;
+                }
+            }
+
+            var withoutDecimalPlaces = (decimal)BigInteger.DivRem(numerator, denominator, out var remainder);
+            return remainder.IsZero ? withoutDecimalPlaces : withoutDecimalPlaces + (decimal)remainder / (decimal)denominator;
+        }
+
+        if (numerator < MinDecimal)
+        {
+            if (denominator > MaxDecimal)
+            {
+                // both terms need to be rounded
+                numerator = numerator * MaxDecimal / denominator;
+                denominator = MaxDecimal;
+                if (numerator >= MinDecimal)
+                {
+                    // both terms are now within range
+                    return (decimal)numerator / (decimal)denominator;
+                }
+            }
+
+            var withoutDecimalPlaces = (decimal)BigInteger.DivRem(numerator, denominator, out var remainder);
+            return remainder.IsZero ? withoutDecimalPlaces : withoutDecimalPlaces + (decimal)remainder / (decimal)denominator;
+        }
+
+        if (denominator > MaxDecimal)
+        {
+            // since both terms are non-zero and the numerator is smaller (in magnitude) to the denominator
+            // the resulting number would be in the range [-1,1] (exclusive)
+            // we want to flip the operation: x = a/b -> 1/x = b/a
+            var decimalPart = BigInteger.DivRem(denominator, numerator, out var remainder);
+            return remainder.IsZero ? 1m / (decimal)decimalPart : 1m / ((decimal)decimalPart + (decimal)remainder / (decimal)numerator);
+        }
+
+        return (decimal)numerator / (decimal)denominator;
+    }
+
+    /// <summary>
+    ///     Converts the fraction to a decimal number. If the fraction cannot be represented as a decimal due to its
+    ///     size, the method will return the closest possible decimal representation (either decimal.MaxValue or
+    ///     decimal.MinValue).
+    /// </summary>
+    /// <returns>
+    ///     The decimal representation of the fraction. If the fraction is too large to represent as a decimal, returns
+    ///     decimal.MaxValue. If the fraction is too small to represent as a decimal, returns decimal.MinValue.
+    /// </returns>
+    /// <remarks>If the fraction is NaN (the numerator and the denominator are both zero), the method will return decimal.Zero.</remarks>
+    public decimal ToDecimalSaturating()
+    {
+        var numerator = Numerator;
+        var denominator = Denominator;
+        if (denominator.IsZero)
+        {
+            return numerator.Sign switch
+            {
+                1 => decimal.MaxValue,
+                -1 => decimal.MinValue,
+                _ => decimal.Zero
+            };
+        }
+        
+        if (numerator.IsZero)
+        {
+            return decimal.Zero;
+        }
+
+        if (denominator.IsOne)
+        {
+            if (numerator > MaxDecimal)
+            {
+                return decimal.MaxValue;
+            }
+
+            if (numerator < MinDecimal)
+            {
+                return decimal.MinValue;
+            }
+
+            return (decimal)numerator;
+        }
+
+        if (numerator > MaxDecimal)
+        {
+            if (denominator > MaxDecimal)
+            {
+                // both terms need to be rounded
+                numerator = numerator * MaxDecimal / denominator;
+                denominator = MaxDecimal;
+                if (numerator <= MaxDecimal)
+                {
+                    // both terms are now within range
+                    return (decimal)numerator / (decimal)denominator;
+                }
+            }
+
+            var withoutDecimalPlaces = BigInteger.DivRem(numerator, denominator, out BigInteger remainder);
+            if (withoutDecimalPlaces > MaxDecimal)
+            {
+                return decimal.MaxValue;
+            }
+
+            return remainder.IsZero ? (decimal)withoutDecimalPlaces : (decimal)withoutDecimalPlaces + (decimal)remainder / (decimal)denominator;
+        }
+
+        if (numerator < MinDecimal)
+        {
+            if (denominator > MaxDecimal)
+            {
+                // both terms need to be rounded
+                numerator = numerator * MaxDecimal / denominator;
+                denominator = MaxDecimal;
+                if (numerator >= MinDecimal)
+                {
+                    // both terms are now within range
+                    return (decimal)numerator / (decimal)denominator;
+                }
+            }
+
+            var withoutDecimalPlaces = BigInteger.DivRem(numerator, denominator, out BigInteger remainder);
+            if (withoutDecimalPlaces < MinDecimal)
+            {
+                return decimal.MinValue;
+            }
+
+            return remainder.IsZero ? (decimal)withoutDecimalPlaces : (decimal)withoutDecimalPlaces + (decimal)remainder / (decimal)denominator;
+        }
+
+        if (denominator > MaxDecimal)
+        {
+            // since both terms are non-zero and the numerator is smaller (in magnitude) to the denominator
+            // the resulting number would be in the range [-1,1] (exclusive)
+            // we want to flip the operation: x = a/b -> 1/x = b/a
+            var decimalPart = BigInteger.DivRem(denominator, numerator, out BigInteger remainder);
+            if (decimalPart < MinDecimal || decimalPart > MaxDecimal)
+            {
+                return decimal.Zero;
+            }
+
+            return remainder.IsZero ? 1m / (decimal)decimalPart : 1m / ((decimal)decimalPart + (decimal)remainder / (decimal)numerator);
+        }
+
+        return (decimal)numerator / (decimal)denominator;
+    }
+
+    /// <summary>Explicit cast from <see cref="QuantityValue" /> to <see cref="float" />.</summary>
+    public static explicit operator float(QuantityValue value)
+    {
+        return (float)(double)value;
+    }
+
+    /// <summary>Explicit cast from <see cref="QuantityValue" /> to <see cref="BigInteger" />.</summary>
+    public static explicit operator BigInteger(QuantityValue value)
+    {
+        var numerator = value.Numerator;
+        var denominator = value.Denominator;
+        if (denominator.IsZero)
+        {
+            throw new OverflowException("The big integer type cannot represent NaN or Infinity");
+        }
+        
+        return denominator.IsOne ? numerator : numerator / denominator;
+    }
+
+    /// <summary>Explicit cast from <see cref="QuantityValue" /> to <see cref="long" />.</summary>
+    public static explicit operator long(QuantityValue value)
+    {
+        return (long)(BigInteger)value;
+    }
+
+    /// <summary>Explicit cast from <see cref="QuantityValue" /> to <see cref="ulong" />.</summary>
+    [CLSCompliant(false)]
+    public static explicit operator ulong(QuantityValue value)
+    {
+        return (ulong)(BigInteger)value;
+    }
+
+    /// <summary>Explicit cast from <see cref="QuantityValue" /> to <see cref="int" />.</summary>
+    public static explicit operator int(QuantityValue value)
+    {
+        return (int)(BigInteger)value;
+    }
+
+    /// <summary>Explicit cast from <see cref="QuantityValue" /> to <see cref="uint" />.</summary>
+    [CLSCompliant(false)]
+    public static explicit operator uint(QuantityValue value)
+    {
+        return (uint)(BigInteger)value;
+    }
+
+    /// <summary>Explicit cast from <see cref="QuantityValue" /> to <see cref="short" />.</summary>
+    public static explicit operator short(QuantityValue value)
+    {
+        return (short)(BigInteger)value;
+    }
+
+    /// <summary>Explicit cast from <see cref="QuantityValue" /> to <see cref="ushort" />.</summary>
+    [CLSCompliant(false)]
+    public static explicit operator ushort(QuantityValue value)
+    {
+        return (ushort)(BigInteger)value;
+    }
+
+    /// <summary>Explicit cast from <see cref="QuantityValue" /> to <see cref="byte" />.</summary>
+    public static explicit operator byte(QuantityValue value)
+    {
+        return (byte)(BigInteger)value;
+    }
+
+#if NET7_0_OR_GREATER
+    /// <summary>
+    ///     Converts the given QuantityValue to a Half precision floating point number.
+    /// </summary>
+    /// <param name="value">The QuantityValue to convert.</param>
+    /// <returns>The converted Half precision floating point number.</returns>
+    /// <exception cref="OverflowException">Thrown when the QuantityValue is too large to fit in a Half.</exception>
+    public static explicit operator Half(QuantityValue value)
+    {
+        return (Half)value.ToDouble();
+    }
+
+    /// <summary>
+    ///     Converts the given QuantityValue to an Int128.
+    /// </summary>
+    /// <param name="value">The QuantityValue to convert.</param>
+    /// <returns>The converted Int128.</returns>
+    /// <exception cref="OverflowException">Thrown when the QuantityValue is too large to fit in an Int128.</exception>
+    public static explicit operator Int128(QuantityValue value)
+    {
+        return (Int128)(BigInteger)value;
+    }
+
+    /// <summary>
+    ///     Converts the given Fraction to an UInt128.
+    /// </summary>
+    /// <param name="value">The Fraction to convert.</param>
+    /// <returns>The converted UInt128.</returns>
+    /// <exception cref="OverflowException">Thrown when the Fraction is too large to fit in an UInt128.</exception>
+    [CLSCompliant(false)]
+    public static explicit operator UInt128(QuantityValue value)
+    {
+        return (UInt128)(BigInteger)value;
+    }
+
+    static bool INumberBase<QuantityValue>.TryConvertToChecked<TOther>(QuantityValue value, [MaybeNullWhen(false)] out TOther result)
+    {
+        if (typeof(TOther) == typeof(decimal))
+        {
+            var convertedValue = value.ToDecimal();
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(double))
+        {
+            var convertedValue = value.ToDouble();
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Complex))
+        {
+            Complex convertedValue = value.ToDouble();
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(float))
+        {
+            var convertedValue = (float)value.ToDouble();
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Half))
+        {
+            var convertedValue = (Half)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(BigInteger))
+        {
+            var convertedValue = (BigInteger)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Int128))
+        {
+            var convertedValue = (Int128)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(UInt128))
+        {
+            var convertedValue = (UInt128)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(long))
+        {
+            var convertedValue = (long)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(ulong))
+        {
+            var convertedValue = (ulong)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(int))
+        {
+            var num = (int)value;
+            result = (TOther)(object)num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(uint))
+        {
+            var convertedValue = (uint)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(nint))
+        {
+            var convertedValue = (nint)(BigInteger)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(UIntPtr))
+        {
+            var convertedValue = (UIntPtr)(BigInteger)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(short))
+        {
+            var convertedValue = (short)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(ushort))
+        {
+            var convertedValue = (ushort)(BigInteger)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(char)) {
+            var convertedValue = (char)(BigInteger)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+        
+        if (typeof(TOther) == typeof(byte))
+        {
+            var convertedValue = (byte)(BigInteger)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(sbyte))
+        {
+            var num = (sbyte)value;
+            result = (TOther)(object)num;
+            return true;
+        }
+
+        result = default;
+        return false;
+    }
+
+    static bool INumberBase<QuantityValue>.TryConvertToSaturating<TOther>(QuantityValue value, [MaybeNullWhen(false)] out TOther result)
+    {
+        if (typeof(TOther) == typeof(decimal))
+        {
+            var convertedValue = value.ToDecimalSaturating();
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(double))
+        {
+            var convertedValue = value.ToDouble();
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Complex))
+        {
+            Complex convertedValue = value.ToDouble();
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(float))
+        {
+            var convertedValue = (float)value.ToDouble();
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Half))
+        {
+            var convertedValue = (Half)value;
+            result = (TOther)(object)convertedValue;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(BigInteger))
+        {
+            if (IsFinite(value))
+            {
+                result = (TOther)(object)(BigInteger)value;
+                return true;
+            }
+
+            if (value.Numerator.IsZero)
+            {
+                result = TOther.Zero;
+            }
+            else
+            {
+                throw new OverflowException();
+            }
+
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Int128))
+        {
+            return ConvertFromBigInteger<Int128>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(UInt128))
+        {
+            return ConvertFromBigInteger<UInt128>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(long))
+        {
+            return ConvertFromBigInteger<long>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(ulong))
+        {
+            return ConvertFromBigInteger<ulong>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(int))
+        {
+            return ConvertFromBigInteger<int>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(uint))
+        {
+            return ConvertFromBigInteger<uint>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(nint))
+        {
+            return ConvertFromBigInteger<nint>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(UIntPtr))
+        {
+            return ConvertFromBigInteger<UIntPtr>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(short))
+        {
+            return ConvertFromBigInteger<short>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(ushort))
+        {
+            return ConvertFromBigInteger<ushort>(value, out result);
+        }
+        
+        if (typeof(TOther) == typeof(char)) {
+            return ConvertFromBigInteger<char>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(byte))
+        {
+            return ConvertFromBigInteger<byte>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(sbyte))
+        {
+            return ConvertFromBigInteger<sbyte>(value, out result);
+        }
+
+        result = default;
+        return false;
+
+        static bool ConvertFromBigInteger<TNumber>(QuantityValue value, out TOther convertedValue) where TNumber : INumberBase<TNumber>, IMinMaxValue<TNumber>
+        {
+            if (IsFinite(value))
+            {
+                convertedValue = TOther.CreateSaturating((BigInteger)value);
+            }
+            else
+            {
+                convertedValue = value.Numerator.Sign switch
+                {
+                    1 => (TOther)(object)TNumber.MaxValue,
+                    -1 => (TOther)(object)TNumber.MinValue,
+                    _ => (TOther)(object)TNumber.Zero
+                };
+            }
+
+            return true;
+        }
+    }
+
+    static bool INumberBase<QuantityValue>.TryConvertToTruncating<TOther>(QuantityValue value, [MaybeNullWhen(false)] out TOther result)
+    {
+        if (typeof(TOther) == typeof(decimal))
+        {
+            var num = value.ToDecimalSaturating();
+            result = (TOther)(object)num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(double))
+        {
+            var num = value.ToDouble();
+            result = (TOther)(object)num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Complex))
+        {
+            Complex num = value.ToDouble();
+            result = (TOther)(object)num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(float))
+        {
+            var num = (float)value.ToDouble();
+            result = (TOther)(object)num;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Half))
+        {
+            var half = (Half)value;
+            result = (TOther)(object)half;
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(BigInteger))
+        {
+            if (IsFinite(value))
+            {
+                result = (TOther)(object)(BigInteger)value;
+            }
+            else if (value.Numerator.IsZero)
+            {
+                result = TOther.Zero;
+            }
+            else
+            {
+                throw new OverflowException();
+            }
+
+            return true;
+        }
+
+        if (typeof(TOther) == typeof(Int128))
+        {
+            return ConvertFromBigInteger<Int128>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(UInt128))
+        {
+            return ConvertFromBigInteger<UInt128>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(long))
+        {
+            return ConvertFromBigInteger<long>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(ulong))
+        {
+            return ConvertFromBigInteger<ulong>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(int))
+        {
+            return ConvertFromBigInteger<int>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(uint))
+        {
+            return ConvertFromBigInteger<uint>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(nint))
+        {
+            return ConvertFromBigInteger<nint>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(UIntPtr))
+        {
+            return ConvertFromBigInteger<UIntPtr>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(short))
+        {
+            return ConvertFromBigInteger<short>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(ushort))
+        {
+            return ConvertFromBigInteger<ushort>(value, out result);
+        }
+        
+        if (typeof(TOther) == typeof(char)) {
+            return ConvertFromBigInteger<char>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(byte))
+        {
+            return ConvertFromBigInteger<byte>(value, out result);
+        }
+
+        if (typeof(TOther) == typeof(sbyte))
+        {
+            return ConvertFromBigInteger<sbyte>(value, out result);
+        }
+
+        result = default;
+        return false;
+
+        static bool ConvertFromBigInteger<TNumber>(QuantityValue value, out TOther convertedValue) where TNumber : INumberBase<TNumber>, IMinMaxValue<TNumber>
+        {
+            convertedValue = IsFinite(value)
+                ? TOther.CreateTruncating((BigInteger)value)
+                : value.Numerator.Sign switch
+                {
+                    1 => (TOther)(object)TNumber.MaxValue,
+                    -1 => (TOther)(object)TNumber.MinValue,
+                    _ => (TOther)(object)TNumber.Zero
+                };
+
+            return true;
+        }
+    }
+
+#endif
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.ConvertToString.cs b/UnitsNet/CustomCode/Value/QuantityValue.ConvertToString.cs
new file mode 100644
index 0000000000..22f7914b0e
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.ConvertToString.cs
@@ -0,0 +1,3398 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Globalization;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+#if !NET
+using System.Text;
+#endif
+
+namespace UnitsNet;
+
+public partial struct QuantityValue
+{
+    /// <summary>Returns the string representation of the numeric value.</summary>
+    public override string ToString()
+    {
+        return ToString("G");
+    }
+
+    /// <summary>
+    ///     Returns the string representation of the numeric value, formatted using the given standard numeric format string
+    /// </summary>
+    /// <param name="format">
+    ///     A standard numeric format string (must be valid for either double or decimal, depending on the
+    ///     base type)
+    /// </param>
+    /// <returns>The string representation</returns>
+    public string ToString([StringSyntax(StringSyntaxAttribute.NumericFormat)] string format)
+    {
+        return ToString(format, NumberFormatInfo.CurrentInfo);
+    }
+
+    /// <summary>
+    ///     Returns the string representation of the numeric value, formatted using the given standard numeric format string
+    /// </summary>
+    /// <param name="formatProvider">The culture to use</param>
+    /// <returns>The string representation</returns>
+    public string ToString(IFormatProvider? formatProvider)
+    {
+        return ToString(null, formatProvider);
+    }
+
+    /// <summary>
+    ///     Returns the string representation of the underlying value
+    /// </summary>
+    /// <param name="format">
+    ///     Standard format specifiers. Because the underlying value can be double or decimal, the meaning can
+    ///     vary
+    /// </param>
+    /// <param name="formatProvider">Culture specific settings</param>
+    /// <returns>A string representation of the number</returns>
+    /// <remarks>
+    ///     This method supports the following format strings:
+    ///     <list type="bullet">
+    ///         <item>
+    ///             <description>
+    ///                 <see
+    ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-general-g-format-specifier">
+    ///                     'G'
+    ///                     or 'g'
+    ///                 </see>
+    ///                 : General format. Example: 400/3 formatted with 'G2' gives "1.3E+02".
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <description>
+    ///                 <see
+    ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-fixed-point-f-format-specifier">
+    ///                     'F'
+    ///                     or 'f'
+    ///                 </see>
+    ///                 : Fixed-point format. Example: 12345/10 formatted with 'F2' gives "1234.50".
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <description>
+    ///                 <see
+    ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-number-n-format-specifier">
+    ///                     'N'
+    ///                     or 'n'
+    ///                 </see>
+    ///                 : Standard Numeric format. Example: 1234567/1000 formatted with 'N2' gives "1,234.57".
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <description>
+    ///                 <see
+    ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-exponential-e-format-specifier">
+    ///                     'E'
+    ///                     or 'e'
+    ///                 </see>
+    ///                 : Scientific format. Example: 1234567/1000 formatted with 'E2' gives "1.23E+003".
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <description>
+    ///                 <see
+    ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-percent-p-format-specifier">
+    ///                     'P'
+    ///                     or 'p'
+    ///                 </see>
+    ///                 : Percent format. Example: 2/3 formatted with 'P2' gives "66.67 %".
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <description>
+    ///                 <see
+    ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-currency-c-format-specifier">
+    ///                     'C'
+    ///                     or 'c'
+    ///                 </see>
+    ///                 : Currency format. Example: 1234567/1000 formatted with 'C2' gives "$1,234.57".
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <description>
+    ///                 <see
+    ///                     href="https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings#RFormatString">
+    ///                     'R'
+    ///                     or 'r'
+    ///                 </see>
+    ///                 : Round-trip format. Example: 1234567/1000 formatted with 'R' gives "1234.567".
+    ///             </description>
+    ///         </item>
+    ///     </list>
+    ///     Note: The 'R' format and custom formats do not support precision specifiers and are handed over to the `double`
+    ///     type for formatting, which may result in a loss of precision.
+    ///     For more information about the formatter, see the
+    ///     <see href="https://github.com/danm-de/Fractions?tab=readme-ov-file#decimalnotationformatter">
+    ///         DecimalNotationFormatter
+    ///         section
+    ///     </see>
+    ///     in the GitHub README.
+    /// </remarks>
+    public string ToString(
+        [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+        IFormatProvider? formatProvider)
+    {
+        return DecimalNotationFormatter.Format(this, format, formatProvider);
+    }
+
+#if NET7_0_OR_GREATER
+    /// <inheritdoc />
+    public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+    {
+        return DecimalNotationFormatter.TryFormat(destination, out charsWritten, this, format, provider);
+    }
+#endif
+
+#if NET
+
+    /// <summary>
+    ///     Provides functionality to format the value of a QuantityValue object into a decimal string representation following
+    ///     the
+    ///     standard numeric formats, as implemented by the double type.
+    /// </summary>
+    private static class DecimalNotationFormatter
+    {
+        /// <summary>
+        ///     <list type="bullet">
+        ///         <item>
+        ///             On .NET Framework and .NET Core up to .NET Core 2.0, the runtime selects the result with the greater least
+        ///             significant digit (that is, using <see cref="MidpointRounding.AwayFromZero" />).
+        ///         </item>
+        ///         <item>
+        ///             On .NET Core 2.1 and later, the runtime selects the result with an even least significant digit (that is,
+        ///             using  <see cref="MidpointRounding.ToEven" />).
+        ///         </item>
+        ///     </list>
+        /// </summary>
+        private const MidpointRounding DefaultMidpointRoundingMode = MidpointRounding.AwayFromZero;
+
+        /// <summary>
+        ///     The default precision used for the general format specifier (G)
+        /// </summary>
+        private const int DefaultGeneralFormatPrecision = 16;
+
+        /// <summary>
+        ///     The default precision used for the exponential (scientific) format specifier (E)
+        /// </summary>
+        private const int DefaultScientificFormatPrecision = 6;
+
+        private const int StackLimit = 250; // Safe limit for stackalloc (512 chars)
+
+
+        private static readonly double Log10Of2 = Math.Log10(2);
+
+
+        /// <summary>
+        ///     Formats the value of the specified Fraction as a string using the specified format.
+        /// </summary>
+        /// <param name="format">A standard or custom numeric format string.</param>
+        /// <param name="fraction">The Fraction object to be formatted.</param>
+        /// <param name="formatProvider">An object that supplies culture-specific formatting information.</param>
+        /// <returns>
+        ///     The string representation of the value of the Fraction object as specified by the format and formatProvider
+        ///     parameters.
+        /// </returns>
+        /// <remarks>
+        ///     This method supports the following format strings:
+        ///     <list type="bullet">
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-general-g-format-specifier">
+        ///                     'G'
+        ///                     or 'g'
+        ///                 </see>
+        ///                 : General format. Example: 400/3 formatted with 'G2' gives "1.3E+02".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-fixed-point-f-format-specifier">
+        ///                     'F'
+        ///                     or 'f'
+        ///                 </see>
+        ///                 : Fixed-point format. Example: 12345/10 formatted with 'F2' gives "1234.50".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-number-n-format-specifier">
+        ///                     'N'
+        ///                     or 'n'
+        ///                 </see>
+        ///                 : Standard Numeric format. Example: 1234567/1000 formatted with 'N2' gives "1,234.57".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-exponential-e-format-specifier">
+        ///                     'E'
+        ///                     or 'e'
+        ///                 </see>
+        ///                 : Scientific format. Example: 1234567/1000 formatted with 'E2' gives "1.23E+003".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-percent-p-format-specifier">
+        ///                     'P'
+        ///                     or 'p'
+        ///                 </see>
+        ///                 : Percent format. Example: 2/3 formatted with 'P2' gives "66.67 %".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-currency-c-format-specifier">
+        ///                     'C'
+        ///                     or 'c'
+        ///                 </see>
+        ///                 : Currency format. Example: 1234567/1000 formatted with 'C2' gives "$1,234.57".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings#RFormatString">
+        ///                     'R'
+        ///                     or 'r'
+        ///                 </see>
+        ///                 : Round-trip format. Example: 1234567/1000 formatted with 'R' gives "1234.567".
+        ///             </description>
+        ///         </item>
+        ///     </list>
+        ///     Note: The 'R' format and custom formats do not support precision specifiers and are handed over to the `double`
+        ///     type for formatting, which may result in a loss of precision.
+        ///     For more information about the formatter, see the
+        ///     <see href="https://github.com/danm-de/Fractions?tab=readme-ov-file#decimalnotationformatter">
+        ///         DecimalNotationFormatter
+        ///         section
+        ///     </see>
+        ///     in the GitHub README.
+        /// </remarks>
+        public static string Format(QuantityValue fraction, string? format, IFormatProvider? formatProvider)
+        {
+            var numberFormatInfo = NumberFormatInfo.GetInstance(formatProvider);
+            BigInteger numerator = fraction.Numerator;
+            BigInteger denominator = fraction.Denominator;
+            if (denominator.Sign == 0)
+            {
+                return numerator.Sign switch
+                {
+                    1 => numberFormatInfo.PositiveInfinitySymbol,
+                    -1 => numberFormatInfo.NegativeInfinitySymbol,
+                    _ => numberFormatInfo.NaNSymbol
+                };
+            }
+
+            if (string.IsNullOrEmpty(format))
+            {
+                return FormatGeneral(numerator, denominator, "G", numberFormatInfo);
+            }
+
+            if (format[0] is 'S' or 's' &&
+                (format.Length == 1 || int.TryParse(format.AsSpan(1), NumberStyles.Integer, CultureInfo.InvariantCulture, out _)))
+            {
+                throw new FormatException(
+                    $"The \"{format}\" significant-digits format is no longer supported; use a standard or custom numeric format string.");
+            }
+
+            var formatCharacter = format[0];
+            return formatCharacter switch
+            {
+                'G' or 'g' => FormatGeneral(numerator, denominator, format, numberFormatInfo),
+                'F' or 'f' => FormatWithFixedPointFormat(numerator, denominator, format, numberFormatInfo),
+                'N' or 'n' => FormatWithStandardNumericFormat(numerator, denominator, format, numberFormatInfo),
+                'E' or 'e' => FormatWithScientificFormat(numerator, denominator, format, numberFormatInfo),
+                'P' or 'p' => FormatWithPercentFormat(numerator, denominator, format, numberFormatInfo),
+                'C' or 'c' => FormatWithCurrencyFormat(numerator, denominator, format, numberFormatInfo),
+                _ => // 'R', 'r' and the custom formats are handed over to the double (possible loss of precision)
+                    fraction.ToDouble().ToString(format, numberFormatInfo)
+            };
+        }
+
+        public static bool TryFormat(Span<char> destination, out int charsWritten, QuantityValue fraction, ReadOnlySpan<char> format, IFormatProvider? formatProvider)
+        {
+            var numberFormatInfo = NumberFormatInfo.GetInstance(formatProvider);
+            BigInteger numerator = fraction.Numerator;
+            BigInteger denominator = fraction.Denominator;
+            if (denominator.Sign == 0)
+            {
+                charsWritten = 0;
+                switch (numerator.Sign)
+                {
+                    case 1:
+                        if (!numberFormatInfo.PositiveInfinitySymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = numberFormatInfo.PositiveInfinitySymbol.Length;
+                        return true;
+                    case -1:
+                        if (!numberFormatInfo.NegativeInfinitySymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = numberFormatInfo.NegativeInfinitySymbol.Length;
+                        return true;
+                    default:
+                        if (!numberFormatInfo.NaNSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = numberFormatInfo.NaNSymbol.Length;
+                        return true;
+                }
+            }
+
+            if (format.IsEmpty)
+            {
+                return TryFormatGeneral(destination, out charsWritten, numerator, denominator, "G", numberFormatInfo);
+            }
+
+            if (format[0] is 'S' or 's' &&
+                (format.Length == 1 || int.TryParse(format[1..], NumberStyles.Integer, CultureInfo.InvariantCulture, out _)))
+            {
+                throw new FormatException(
+                    $"The \"{format.ToString()}\" significant-digits format is no longer supported; use a standard or custom numeric format string.");
+            }
+
+            var formatCharacter = format[0];
+            return formatCharacter switch
+            {
+                'G' or 'g' => TryFormatGeneral(destination, out charsWritten, numerator, denominator, format, numberFormatInfo),
+                'F' or 'f' => TryFormatWithFixedPointFormat(destination, out charsWritten, numerator, denominator, format, numberFormatInfo),
+                'N' or 'n' => TryFormatWithStandardNumericFormat(destination, out charsWritten, numerator, denominator, format, numberFormatInfo),
+                'E' or 'e' => TryFormatWithScientificFormat(destination, out charsWritten, numerator, denominator, format, numberFormatInfo),
+                'P' or 'p' => TryFormatWithPercentFormat(destination, out charsWritten, numerator, denominator, format, numberFormatInfo),
+                'C' or 'c' => TryFormatWithCurrencyFormat(destination, out charsWritten, numerator, denominator, format, numberFormatInfo),
+                _ => // 'R', 'r' and the custom formats are handed over to the double (possible loss of precision)
+                    fraction.ToDouble().TryFormat(destination, out charsWritten, format, numberFormatInfo)
+            };
+        }
+
+        private static bool TryGetPrecisionDigits(ReadOnlySpan<char> format, int defaultPrecision, out int maxNbDecimals)
+        {
+            if (format.Length == 1)
+            {
+                // The number of digits is not specified, use default precision.
+                maxNbDecimals = defaultPrecision;
+                return true;
+            }
+
+            if (int.TryParse(format[1..], NumberStyles.Integer, CultureInfo.InvariantCulture, out maxNbDecimals))
+            {
+                return true;
+            }
+
+            // Seems to be some kind of custom format we do not understand, fallback to default precision.
+            maxNbDecimals = defaultPrecision;
+            return false;
+        }
+
+        /// <summary>
+        ///     The fixed-point ("F") format specifier converts a number to a string of the form "-ddd.ddd…" where each "d"
+        ///     indicates a digit (0-9). The string starts with a minus sign if the number is negative.
+        /// </summary>
+        /// <remarks>
+        ///     The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted, the
+        ///     current <see cref="NumberFormatInfo.NumberDecimalDigits" /> property supplies the numeric precision.
+        /// </remarks>
+        private static string FormatWithFixedPointFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.ToString(format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.NumberDecimalDigits, out var maxNbDecimalsAfterRadix))
+            {
+                // not a valid "F" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            Span<char> buffer = stackalloc char[StackLimit]; // Use stack memory
+            int charsWritten;
+            while (!TryFormatWithFixedPointFormat(buffer, out charsWritten, numerator, denominator, format, formatProvider, maxNbDecimalsAfterRadix))
+            {
+                buffer = new char[buffer.Length * 2]; // Use heap if needed
+            }
+
+            return new string(buffer[..charsWritten]);
+        }
+
+        private static bool TryFormatWithFixedPointFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, ReadOnlySpan<char> format,
+            NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.NumberDecimalDigits, out var maxNbDecimalsAfterRadix))
+            {
+                // not a valid "F" format: assuming a custom format
+                return TryFormatWithCustomFormat(destination, out charsWritten, numerator, denominator, format, formatProvider);
+            }
+
+            return TryFormatWithFixedPointFormat(destination, out charsWritten, numerator, denominator, format, formatProvider, maxNbDecimalsAfterRadix);
+        }
+
+        private static bool TryFormatWithFixedPointFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, ReadOnlySpan<char> format,
+            NumberFormatInfo formatProvider, int maxNbDecimalsAfterRadix)
+        {
+            if (maxNbDecimalsAfterRadix == 0)
+            {
+                var roundedValue = RoundToBigInteger(numerator, denominator, DefaultMidpointRoundingMode);
+                return roundedValue.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            var (roundedNumerator, roundedDenominator) = Round(numerator, denominator, maxNbDecimalsAfterRadix, DefaultMidpointRoundingMode);
+
+            switch (roundedNumerator.Sign)
+            {
+                case 0:
+                    return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+                case 1:
+                    return TryAppendDecimals(destination, out charsWritten, roundedNumerator, roundedDenominator, formatProvider, maxNbDecimalsAfterRadix, "F0");
+                default:
+                {
+                    if (!formatProvider.NegativeSign.TryCopyTo(destination))
+                    {
+                        charsWritten = 0;
+                        return false;
+                    }
+
+                    charsWritten = formatProvider.NegativeSign.Length;
+
+                    roundedNumerator = -roundedNumerator;
+                    if (!TryAppendDecimals(destination[charsWritten..], out var digitsWritten, roundedNumerator, roundedDenominator, formatProvider, maxNbDecimalsAfterRadix, "F0"))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += digitsWritten;
+                    return true;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     The numeric ("N") format specifier converts a number to a string of the form "-d,ddd,ddd.ddd…", where "-"
+        ///     indicates
+        ///     a negative number symbol if required, "d" indicates a digit (0-9), "," indicates a group separator, and "."
+        ///     indicates a decimal point symbol.
+        /// </summary>
+        /// <remarks>
+        ///     The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted, the
+        ///     current <see cref="NumberFormatInfo.NumberDecimalDigits" /> property supplies the numeric precision.
+        /// </remarks>
+        private static string FormatWithStandardNumericFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.ToString(format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.NumberDecimalDigits, out var maxNbDecimals))
+            {
+                // not a valid "N" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            Span<char> buffer = stackalloc char[StackLimit]; // Use stack memory
+            int charsWritten;
+            while (!TryFormatWithStandardNumericFormat(buffer, out charsWritten, numerator, denominator, format, formatProvider, maxNbDecimals))
+            {
+                buffer = new char[buffer.Length * 2]; // Use heap if needed
+            }
+
+            return new string(buffer[..charsWritten]);
+        }
+
+        private static bool TryFormatWithStandardNumericFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator,
+            ReadOnlySpan<char> format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.NumberDecimalDigits, out var maxNbDecimals))
+            {
+                // not a valid "N" format: assuming a custom format
+                return TryFormatWithCustomFormat(destination, out charsWritten, numerator, denominator, format, formatProvider);
+            }
+
+            return TryFormatWithStandardNumericFormat(destination, out charsWritten, numerator, denominator, format, formatProvider, maxNbDecimals);
+        }
+
+        private static bool TryFormatWithStandardNumericFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator,
+            ReadOnlySpan<char> format,
+            NumberFormatInfo formatProvider, int maxNbDecimals)
+        {
+            if (maxNbDecimals == 0)
+            {
+                var roundedValue = RoundToBigInteger(numerator, denominator, DefaultMidpointRoundingMode);
+                return roundedValue.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            var (roundedNumerator, roundedDenominator) = Round(numerator, denominator, maxNbDecimals, DefaultMidpointRoundingMode);
+            switch (roundedNumerator.Sign)
+            {
+                case 0:
+                    return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+                case 1:
+                    return TryAppendDecimals(destination, out charsWritten, roundedNumerator, roundedDenominator, formatProvider, maxNbDecimals, "N0");
+                default:
+                    if (!TryAppendLeadingNegativePattern(destination, out charsWritten, formatProvider.NegativeSign, formatProvider.NumberNegativePattern))
+                    {
+                        return false;
+                    }
+
+                    roundedNumerator = -roundedNumerator;
+                    if (!TryAppendDecimals(destination[charsWritten..], out var decimalsWritten, roundedNumerator, roundedDenominator, formatProvider, maxNbDecimals, "N0"))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += decimalsWritten;
+                    if (!TryAppendTrailingNegativePattern(destination[charsWritten..], out var trailingCharsWritten, formatProvider.NegativeSign,
+                            formatProvider.NumberNegativePattern))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += trailingCharsWritten;
+                    return true;
+            }
+
+            static bool TryAppendLeadingNegativePattern(Span<char> destination, out int charsWritten, string negativeSignSymbol, int pattern)
+            {
+                charsWritten = 0;
+                switch (pattern)
+                {
+                    case 0: // (n) : leading is '('
+                        if (destination.IsEmpty)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = '(';
+                        charsWritten = 1;
+                        return true;
+                    case 1: // -n : leading is negativeSignSymbol
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        return true;
+                    case 2: // - n : leading is negativeSignSymbol + ' '
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        if (charsWritten == destination.Length)
+                        {
+                            return false;
+                        }
+
+                        destination[charsWritten] = ' ';
+                        charsWritten++;
+                        return true;
+                    default: //"n-" and "n -" : no leading addition
+                        return true;
+                }
+            }
+
+            static bool TryAppendTrailingNegativePattern(Span<char> destination, out int charsWritten, string negativeSignSymbol, int pattern)
+            {
+                charsWritten = 0;
+                switch (pattern)
+                {
+                    case 0: // (n) : trailing is ')'
+                        if (destination.IsEmpty)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ')';
+                        charsWritten = 1;
+                        return true;
+                    case 3: // n- : trailing is negativeSignSymbol
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        return true;
+                    case 4: // n - : trailing is ' ' + negativeSignSymbol
+                        if (destination.IsEmpty)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ' ';
+                        charsWritten = 1;
+                        if (!negativeSignSymbol.TryCopyTo(destination[charsWritten..]))
+                        {
+                            return false;
+                        }
+
+                        charsWritten += negativeSignSymbol.Length;
+                        return true;
+                    default: // -n and - n cases are handled in leading function
+                        return true;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     The percent ("P") format specifier multiplies a number by 100 and converts it to a string that represents a
+        ///     percentage.
+        /// </summary>
+        /// <remarks>
+        ///     The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted,
+        ///     the default numeric precision supplied by the current <see cref="NumberFormatInfo.PercentDecimalDigits" /> property
+        ///     is used.
+        /// </remarks>
+        private static string FormatWithPercentFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.ToString(format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.PercentDecimalDigits, out var maxNbDecimals))
+            {
+                // not a valid "P" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            Span<char> buffer = stackalloc char[StackLimit]; // Use stack memory
+            int charsWritten;
+            while (!TryFormatWithPercentFormat(buffer, out charsWritten, numerator, denominator, format, formatProvider, maxNbDecimals))
+            {
+                buffer = new char[buffer.Length * 2]; // Use heap if needed
+            }
+
+            return new string(buffer[..charsWritten]);
+        }
+
+        private static bool TryFormatWithPercentFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, ReadOnlySpan<char> format,
+            NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.PercentDecimalDigits, out var maxNbDecimals))
+            {
+                // not a valid "P" format: assuming a custom format
+                return TryFormatWithCustomFormat(destination, out charsWritten, numerator, denominator, format, formatProvider);
+            }
+
+            return TryFormatWithPercentFormat(destination, out charsWritten, numerator, denominator, format, formatProvider, maxNbDecimals);
+        }
+
+        private static bool TryFormatWithPercentFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, ReadOnlySpan<char> format,
+            NumberFormatInfo formatProvider, int maxNbDecimals)
+        {
+            if (maxNbDecimals == 0)
+            {
+                var roundedValue = RoundToBigInteger(100 * numerator, denominator, DefaultMidpointRoundingMode);
+                if (roundedValue.IsZero)
+                {
+                    return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+                }
+
+                var percentFormatInfo = new NumberFormatInfo
+                {
+                    NumberDecimalSeparator = formatProvider.PercentDecimalSeparator,
+                    NumberGroupSeparator = formatProvider.PercentGroupSeparator,
+                    NumberGroupSizes = formatProvider.PercentGroupSizes,
+                    NativeDigits = formatProvider.NativeDigits,
+                    DigitSubstitution = formatProvider.DigitSubstitution
+                };
+
+                if (roundedValue.Sign >= 0)
+                {
+                    if (!TryAppendLeadingPositivePercentPattern(destination, out charsWritten, formatProvider.PercentSymbol, formatProvider.PercentPositivePattern))
+                    {
+                        return false;
+                    }
+
+                    if (!roundedValue.TryFormat(destination[charsWritten..], out var decimalsWritten, "N0", percentFormatInfo))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += decimalsWritten;
+
+                    if (!TryAppendTrailingPositivePercentPattern(destination[charsWritten..], out var trailingCharsWritten, formatProvider.PercentSymbol,
+                            formatProvider.PercentPositivePattern))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += trailingCharsWritten;
+                }
+                else
+                {
+                    if (!TryAppendLeadingNegativePercentPattern(destination, out charsWritten, formatProvider.PercentSymbol, formatProvider.NegativeSign,
+                            formatProvider.PercentNegativePattern))
+                    {
+                        return false;
+                    }
+
+                    roundedValue = -roundedValue;
+                    if (!roundedValue.TryFormat(destination[charsWritten..], out var decimalsWritten, "N0", percentFormatInfo))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += decimalsWritten;
+
+                    if (!TryAppendTrailingNegativePercentPattern(destination[charsWritten..], out var trailingCharsWritten, formatProvider.PercentSymbol,
+                            formatProvider.NegativeSign,
+                            formatProvider.PercentNegativePattern))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += trailingCharsWritten;
+                }
+            }
+            else
+            {
+                var (roundedNumerator, roundedDenominator) = Round(numerator * 100, denominator, maxNbDecimals, DefaultMidpointRoundingMode);
+                if (roundedNumerator.IsZero)
+                {
+                    return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+                }
+
+                var percentFormatInfo = new NumberFormatInfo
+                {
+                    NumberDecimalSeparator = formatProvider.PercentDecimalSeparator,
+                    NumberGroupSeparator = formatProvider.PercentGroupSeparator,
+                    NumberGroupSizes = formatProvider.PercentGroupSizes,
+                    NativeDigits = formatProvider.NativeDigits,
+                    DigitSubstitution = formatProvider.DigitSubstitution
+                };
+
+                if (roundedNumerator.Sign > 0)
+                {
+                    if (!TryAppendLeadingPositivePercentPattern(destination, out charsWritten, formatProvider.PercentSymbol, formatProvider.PercentPositivePattern))
+                    {
+                        return false;
+                    }
+
+                    if (!TryAppendDecimals(destination[charsWritten..], out var decimalsWritten, roundedNumerator, roundedDenominator, percentFormatInfo, maxNbDecimals, "N0"))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += decimalsWritten;
+
+                    if (!TryAppendTrailingPositivePercentPattern(destination[charsWritten..], out var trailingCharsWritten, formatProvider.PercentSymbol,
+                            formatProvider.PercentPositivePattern))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += trailingCharsWritten;
+                }
+                else
+                {
+                    if (!TryAppendLeadingNegativePercentPattern(destination, out charsWritten, formatProvider.PercentSymbol, formatProvider.NegativeSign,
+                            formatProvider.PercentNegativePattern))
+                    {
+                        return false;
+                    }
+
+                    roundedNumerator = -roundedNumerator;
+                    if (!TryAppendDecimals(destination[charsWritten..], out var decimalsWritten, roundedNumerator, roundedDenominator, percentFormatInfo, maxNbDecimals, "N0"))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += decimalsWritten;
+
+                    if (!TryAppendTrailingNegativePercentPattern(destination[charsWritten..], out var trailingCharsWritten, formatProvider.PercentSymbol,
+                            formatProvider.NegativeSign, formatProvider.PercentNegativePattern))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += trailingCharsWritten;
+                }
+            }
+
+            return true;
+
+            static bool TryAppendLeadingPositivePercentPattern(Span<char> destination, out int charsWritten, string percentSymbol, int pattern)
+            {
+                charsWritten = 0;
+                switch (pattern)
+                {
+                    case 0: // n % : no leading addition
+                    case 1: // n%  : no leading addition
+                        return true;
+                    case 2: // %n  : leading is percentSymbol only
+                        if (!percentSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = percentSymbol.Length;
+                        return true;
+                    default: // % n : leading is percentSymbol + ' '
+                        if (!percentSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = percentSymbol.Length;
+                        if (destination.Length == charsWritten)
+                        {
+                            return false;
+                        }
+
+                        destination[charsWritten] = ' ';
+                        charsWritten++;
+                        return true;
+                }
+            }
+
+            static bool TryAppendTrailingPositivePercentPattern(Span<char> destination, out int charsWritten, string percentSymbol, int pattern)
+            {
+                charsWritten = 0;
+                switch (pattern)
+                {
+                    case 0: // n % : trailing is ' ' + percentSymbol
+                        if (destination.IsEmpty)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ' ';
+                        charsWritten = 1;
+                        if (!percentSymbol.TryCopyTo(destination[charsWritten..]))
+                        {
+                            return false;
+                        }
+
+                        charsWritten += percentSymbol.Length;
+                        return true;
+                    case 1: // n%  : trailing is percentSymbol only
+                        if (!percentSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = percentSymbol.Length;
+                        return true;
+                    default: // "%n" and "% n" : no trailing addition
+                        return true;
+                }
+            }
+
+            static bool TryAppendLeadingNegativePercentPattern(Span<char> destination, out int charsWritten, string percentSymbol, string negativeSignSymbol, int pattern)
+            {
+                charsWritten = 0;
+                switch (pattern)
+                {
+                    case 0: // -n %
+                    case 1: // -n%
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        return true;
+                    case 2: // -%n
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        if (!percentSymbol.TryCopyTo(destination[charsWritten..]))
+                        {
+                            return false;
+                        }
+
+                        charsWritten += percentSymbol.Length;
+                        return true;
+                    case 3: // %-n
+                        if (!percentSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = percentSymbol.Length;
+                        if (!negativeSignSymbol.TryCopyTo(destination[charsWritten..]))
+                        {
+                            return false;
+                        }
+
+                        charsWritten += negativeSignSymbol.Length;
+                        return true;
+                    case 4: // %n-
+                        if (!percentSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = percentSymbol.Length;
+                        return true;
+                    case 5: // n-%
+                    case 6: // n%-
+                        return true;
+                    case 7: // -% n
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        if (!percentSymbol.TryCopyTo(destination[charsWritten..]))
+                        {
+                            return false;
+                        }
+
+                        charsWritten += percentSymbol.Length;
+                        if (charsWritten == destination.Length)
+                        {
+                            return false;
+                        }
+
+                        destination[charsWritten] = ' ';
+                        charsWritten++;
+                        return true;
+                    case 8: // n %-
+                        return true;
+                    case 9: // % n-
+                        if (!percentSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = percentSymbol.Length;
+                        if (charsWritten == destination.Length)
+                        {
+                            return false;
+                        }
+
+                        destination[charsWritten] = ' ';
+                        charsWritten++;
+                        return true;
+                    case 10: // % -n
+                        if (!percentSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = percentSymbol.Length;
+                        if (charsWritten == destination.Length)
+                        {
+                            return false;
+                        }
+
+                        destination[charsWritten] = ' ';
+                        charsWritten++;
+
+                        if (!negativeSignSymbol.TryCopyTo(destination[charsWritten..]))
+                        {
+                            return false;
+                        }
+
+                        charsWritten += negativeSignSymbol.Length;
+                        return true;
+                    default: // n- %
+                        // No leading part required for other patterns
+                        return true;
+                }
+            }
+
+            static bool TryAppendTrailingNegativePercentPattern(Span<char> destination, out int charsWritten, string percentSymbol, string negativeSignSymbol, int pattern)
+            {
+                charsWritten = 0;
+                switch (pattern)
+                {
+                    case 0: // -n %: trailing is " " + percentSymbol
+                        if (destination.IsEmpty)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ' ';
+                        charsWritten = 1;
+                        if (!percentSymbol.TryCopyTo(destination[charsWritten..]))
+                        {
+                            return false;
+                        }
+
+                        charsWritten += percentSymbol.Length;
+                        return true;
+                    case 1: // -n%: trailing is percentSymbol
+                        if (!percentSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = percentSymbol.Length;
+                        return true;
+                    case 2: // -%n: no trailing addition
+                    case 3: // %-n: no trailing addition
+                        return true;
+                    case 4: // %n-: trailing is negativeSignSymbol
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        return true;
+                    case 5: // n-%: trailing is negativeSignSymbol + percentSymbol
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        if (!percentSymbol.TryCopyTo(destination[charsWritten..]))
+                        {
+                            return false;
+                        }
+
+                        charsWritten += percentSymbol.Length;
+                        return true;
+                    case 6: // n%-: trailing is percentSymbol + negativeSignSymbol
+                        if (!percentSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = percentSymbol.Length;
+                        if (!negativeSignSymbol.TryCopyTo(destination[charsWritten..]))
+                        {
+                            return false;
+                        }
+
+                        charsWritten += negativeSignSymbol.Length;
+                        return true;
+                    case 7: // -% n: no trailing addition
+                        return true;
+                    case 8: // n %-: trailing is " " + percentSymbol + negativeSignSymbol
+                        if (destination.Length < 1 + percentSymbol.Length + negativeSignSymbol.Length)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ' ';
+                        charsWritten = 1;
+                        percentSymbol.CopyTo(destination[charsWritten..]);
+                        charsWritten += percentSymbol.Length;
+                        negativeSignSymbol.CopyTo(destination[charsWritten..]);
+                        charsWritten += negativeSignSymbol.Length;
+                        return true;
+                    case 9: // % n-: trailing is negativeSignSymbol
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        return true;
+                    case 10: // % -n: no trailing addition
+                        return true;
+                    default: // n- %: trailing is negativeSignSymbol + " " + percentSymbol
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        if (destination.Length == charsWritten)
+                        {
+                            return false;
+                        }
+
+                        destination[charsWritten] = ' ';
+                        charsWritten++;
+                        if (!percentSymbol.TryCopyTo(destination[charsWritten..]))
+                        {
+                            return false;
+                        }
+
+                        charsWritten += percentSymbol.Length;
+                        return true;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     The "C" (or currency) format specifier converts a number to a string that represents a currency amount. The
+        ///     precision specifier indicates the desired number of decimal places in the result string. If the precision specifier
+        ///     is omitted, the default precision is defined by the <see cref="NumberFormatInfo.CurrencyDecimalDigits" /> property.
+        /// </summary>
+        /// <remarks>
+        ///     If the value to be formatted has more than the specified or default number of decimal places, the fractional
+        ///     value is rounded in the result string. If the value to the right of the number of specified decimal places is 5 or
+        ///     greater, the last digit in the result string is rounded away from zero.
+        /// </remarks>
+        private static string FormatWithCurrencyFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.ToString(format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.CurrencyDecimalDigits, out var maxNbDecimals))
+            {
+                // not a valid "C" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            Span<char> buffer = stackalloc char[StackLimit]; // Use stack memory
+            int charsWritten;
+            while (!TryFormatWithCurrencyFormat(buffer, out charsWritten, numerator, denominator, format, formatProvider, maxNbDecimals))
+            {
+                buffer = new char[buffer.Length * 2]; // Use heap if needed
+            }
+
+            return new string(buffer[..charsWritten]);
+        }
+
+        private static bool TryFormatWithCurrencyFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, ReadOnlySpan<char> format,
+            NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.CurrencyDecimalDigits, out var maxNbDecimals))
+            {
+                // not a valid "C" format: assuming a custom format
+                return TryFormatWithCustomFormat(destination, out charsWritten, numerator, denominator, format, formatProvider);
+            }
+
+            return TryFormatWithCurrencyFormat(destination, out charsWritten, numerator, denominator, format, formatProvider, maxNbDecimals);
+        }
+
+        private static bool TryFormatWithCurrencyFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, ReadOnlySpan<char> format,
+            NumberFormatInfo formatProvider,
+            int maxNbDecimals)
+        {
+            if (maxNbDecimals == 0)
+            {
+                var roundedValue = RoundToBigInteger(numerator, denominator, DefaultMidpointRoundingMode);
+                return roundedValue.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            var (roundedNumerator, roundedDenominator) = Round(numerator, denominator, maxNbDecimals, DefaultMidpointRoundingMode);
+            if (roundedNumerator.IsZero)
+            {
+                return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            var currencyFormatInfo = new NumberFormatInfo
+            {
+                NumberDecimalSeparator = formatProvider.CurrencyDecimalSeparator,
+                NumberGroupSeparator = formatProvider.CurrencyGroupSeparator,
+                NumberGroupSizes = formatProvider.CurrencyGroupSizes,
+                NativeDigits = formatProvider.NativeDigits,
+                DigitSubstitution = formatProvider.DigitSubstitution
+            };
+
+            if (roundedNumerator.Sign > 0)
+            {
+                if (!TryAppendLeadingSymbolsWithPositivePattern(destination, out charsWritten, formatProvider.CurrencySymbol, formatProvider.CurrencyPositivePattern))
+                {
+                    return false;
+                }
+
+                if (!TryAppendDecimals(destination[charsWritten..], out var decimalsWritten, roundedNumerator, roundedDenominator, currencyFormatInfo, maxNbDecimals, "N0"))
+                {
+                    return false;
+                }
+
+                charsWritten += decimalsWritten;
+                if (!TryAppendTrailingSymbolsWithPositivePattern(destination[charsWritten..], out var trailingCharsWritten, formatProvider.CurrencySymbol,
+                        formatProvider.CurrencyPositivePattern))
+                {
+                    return false;
+                }
+
+                charsWritten += trailingCharsWritten;
+            }
+            else
+            {
+                if (!TryAppendLeadingSymbolsWithNegativePattern(destination, out charsWritten, formatProvider.CurrencySymbol, formatProvider.NegativeSign,
+                        formatProvider.CurrencyNegativePattern))
+                {
+                    return false;
+                }
+
+                roundedNumerator = -roundedNumerator;
+                if (!TryAppendDecimals(destination[charsWritten..], out var decimalsWritten, roundedNumerator, roundedDenominator, currencyFormatInfo, maxNbDecimals, "N0"))
+                {
+                    return false;
+                }
+
+                charsWritten += decimalsWritten;
+                if (!TryAppendTrailingSymbolsWithNegativePattern(destination[charsWritten..], out var trailingCharsWritten, formatProvider.CurrencySymbol,
+                        formatProvider.NegativeSign,
+                        formatProvider.CurrencyNegativePattern))
+                {
+                    return false;
+                }
+
+                charsWritten += trailingCharsWritten;
+            }
+
+            return true;
+
+            static bool TryAppendLeadingSymbolsWithPositivePattern(Span<char> destination, out int charsWritten, string currencySymbol, int pattern)
+            {
+                charsWritten = 0;
+                switch (pattern)
+                {
+                    case 0: // $n
+                        if (!currencySymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = currencySymbol.Length;
+                        return true;
+                    case 1: // n$
+                        return true;
+                    case 2: // $ n
+                        if (destination.Length < currencySymbol.Length + 1)
+                        {
+                            return false;
+                        }
+
+                        currencySymbol.CopyTo(destination);
+                        destination[currencySymbol.Length] = ' ';
+                        charsWritten = currencySymbol.Length + 1;
+                        return true;
+                    default: // n $
+                        return true;
+                }
+            }
+
+            static bool TryAppendTrailingSymbolsWithPositivePattern(Span<char> destination, out int charsWritten, string currencySymbol, int pattern)
+            {
+                charsWritten = 0;
+                switch (pattern)
+                {
+                    case 0: // $n
+                        return true;
+                    case 1: // n$
+                        if (!currencySymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = currencySymbol.Length;
+                        return true;
+                    case 2: // $ n
+                        return true;
+                    default: // n $
+                        if (destination.Length < currencySymbol.Length + 1)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ' ';
+                        currencySymbol.CopyTo(destination[1..]);
+                        charsWritten = currencySymbol.Length + 1;
+                        return true;
+                }
+            }
+
+            static bool TryAppendLeadingSymbolsWithNegativePattern(Span<char> destination, out int charsWritten, string currencySymbol, string negativeSignSymbol, int pattern)
+            {
+                charsWritten = 0;
+                switch (pattern)
+                {
+                    case 0: // ($n)
+                        if (destination.Length < currencySymbol.Length + 3)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = '(';
+                        currencySymbol.CopyTo(destination[1..]);
+                        charsWritten = currencySymbol.Length + 1;
+                        return true;
+                    case 1: // -$n
+                        if (destination.Length < currencySymbol.Length + negativeSignSymbol.Length + 1)
+                        {
+                            return false;
+                        }
+
+                        negativeSignSymbol.CopyTo(destination);
+                        currencySymbol.CopyTo(destination[negativeSignSymbol.Length..]);
+                        charsWritten = negativeSignSymbol.Length + currencySymbol.Length;
+                        return true;
+                    case 2: // $-n
+                        if (destination.Length < currencySymbol.Length + negativeSignSymbol.Length + 1)
+                        {
+                            return false;
+                        }
+
+                        currencySymbol.CopyTo(destination);
+                        negativeSignSymbol.CopyTo(destination[currencySymbol.Length..]);
+                        charsWritten = currencySymbol.Length + negativeSignSymbol.Length;
+                        return true;
+                    case 3: // $n-
+                        if (destination.Length < currencySymbol.Length + negativeSignSymbol.Length + 1)
+                        {
+                            return false;
+                        }
+
+                        currencySymbol.CopyTo(destination);
+                        charsWritten = currencySymbol.Length;
+                        return true;
+                    case 4: // (n$)
+                        if (destination.Length < currencySymbol.Length + 3)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = '(';
+                        charsWritten = 1;
+                        return true;
+                    case 5: // -n$
+                        if (destination.Length < currencySymbol.Length + negativeSignSymbol.Length + 1)
+                        {
+                            return false;
+                        }
+
+                        negativeSignSymbol.CopyTo(destination);
+                        charsWritten = negativeSignSymbol.Length;
+                        return true;
+                    case 6: // n-$
+                    case 7: // n$-
+                        return true;
+                    case 8: // -n $
+                        if (destination.Length < currencySymbol.Length + negativeSignSymbol.Length + 2)
+                        {
+                            return false;
+                        }
+
+                        negativeSignSymbol.CopyTo(destination);
+                        charsWritten = negativeSignSymbol.Length;
+                        return true;
+                    case 9: // -$ n
+                        if (destination.Length < negativeSignSymbol.Length + currencySymbol.Length + 2)
+                        {
+                            return false;
+                        }
+
+                        negativeSignSymbol.CopyTo(destination);
+                        currencySymbol.CopyTo(destination[negativeSignSymbol.Length..]);
+                        destination[negativeSignSymbol.Length + currencySymbol.Length] = ' ';
+                        charsWritten = negativeSignSymbol.Length + currencySymbol.Length + 1;
+                        return true;
+                    case 10: // n $-
+                        return true;
+                    case 11: // $ n-
+                        if (destination.Length < currencySymbol.Length + negativeSignSymbol.Length + 2)
+                        {
+                            return false;
+                        }
+
+                        currencySymbol.CopyTo(destination);
+                        destination[currencySymbol.Length] = ' ';
+                        charsWritten = currencySymbol.Length + 1;
+                        return true;
+                    case 12: // $ -n
+                        if (destination.Length < currencySymbol.Length + negativeSignSymbol.Length + 2)
+                        {
+                            return false;
+                        }
+
+                        currencySymbol.CopyTo(destination);
+                        destination[currencySymbol.Length] = ' ';
+                        negativeSignSymbol.CopyTo(destination[(currencySymbol.Length + 1)..]);
+                        charsWritten = currencySymbol.Length + negativeSignSymbol.Length + 1;
+                        return true;
+                    case 13: // n- $
+                        return true;
+                    case 14: // ($ n)
+                        if (destination.Length < currencySymbol.Length + 4)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = '(';
+                        currencySymbol.CopyTo(destination[1..]);
+                        destination[currencySymbol.Length + 1] = ' ';
+                        charsWritten = currencySymbol.Length + 2;
+                        return true;
+                    case 15: // (n $)
+                        if (destination.Length < currencySymbol.Length + 4)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = '(';
+                        charsWritten = 1;
+                        return true;
+                    default: // $- n
+                        if (destination.Length < currencySymbol.Length + negativeSignSymbol.Length + 2)
+                        {
+                            return false;
+                        }
+
+                        currencySymbol.CopyTo(destination);
+                        negativeSignSymbol.CopyTo(destination[currencySymbol.Length..]);
+                        destination[currencySymbol.Length + negativeSignSymbol.Length] = ' ';
+                        charsWritten = currencySymbol.Length + negativeSignSymbol.Length + 1;
+                        return true;
+                }
+            }
+
+            static bool TryAppendTrailingSymbolsWithNegativePattern(Span<char> destination, out int charsWritten, string currencySymbol, string negativeSignSymbol, int pattern)
+            {
+                charsWritten = 0;
+                switch (pattern)
+                {
+                    case 0: // ($n)
+                        if (destination.IsEmpty)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ')';
+                        charsWritten = 1;
+                        return true;
+                    case 1: // -$n
+                        return true;
+                    case 2: // $-n
+                        return true;
+                    case 3: // $n-
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        return true;
+                    case 4: // (n$)
+                        if (destination.Length < currencySymbol.Length + 1)
+                        {
+                            return false;
+                        }
+
+                        currencySymbol.CopyTo(destination);
+                        destination[currencySymbol.Length] = ')';
+                        charsWritten = currencySymbol.Length + 1;
+                        return true;
+                    case 5: // -n$
+                        if (!currencySymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = currencySymbol.Length;
+                        return true;
+                    case 6: // n-$
+                        if (destination.Length < negativeSignSymbol.Length + currencySymbol.Length)
+                        {
+                            return false;
+                        }
+
+                        negativeSignSymbol.CopyTo(destination);
+                        currencySymbol.CopyTo(destination[negativeSignSymbol.Length..]);
+                        charsWritten = negativeSignSymbol.Length + currencySymbol.Length;
+                        return true;
+                    case 7: // n$-
+                        if (destination.Length < currencySymbol.Length + negativeSignSymbol.Length)
+                        {
+                            return false;
+                        }
+
+                        currencySymbol.CopyTo(destination);
+                        negativeSignSymbol.CopyTo(destination[currencySymbol.Length..]);
+                        charsWritten = currencySymbol.Length + negativeSignSymbol.Length;
+                        return true;
+                    case 8: // -n $
+                        if (destination.Length < currencySymbol.Length + 1)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ' ';
+                        currencySymbol.CopyTo(destination[1..]);
+                        charsWritten = currencySymbol.Length + 1;
+                        return true;
+                    case 9: // -$ n
+                        return true;
+                    case 10: // n $-
+                        if (destination.Length < 1 + currencySymbol.Length + negativeSignSymbol.Length)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ' ';
+                        currencySymbol.CopyTo(destination[1..]);
+                        negativeSignSymbol.CopyTo(destination[(currencySymbol.Length + 1)..]);
+                        charsWritten = 1 + currencySymbol.Length + negativeSignSymbol.Length;
+                        return true;
+                    case 11: // $ n-
+                        if (!negativeSignSymbol.TryCopyTo(destination))
+                        {
+                            return false;
+                        }
+
+                        charsWritten = negativeSignSymbol.Length;
+                        return true;
+                    case 12: // $ -n
+                        return true;
+                    case 13: // n- $
+                        if (destination.Length < negativeSignSymbol.Length + 1 + currencySymbol.Length)
+                        {
+                            return false;
+                        }
+
+                        negativeSignSymbol.CopyTo(destination);
+                        destination[negativeSignSymbol.Length] = ' ';
+                        currencySymbol.CopyTo(destination[(negativeSignSymbol.Length + 1)..]);
+                        charsWritten = negativeSignSymbol.Length + 1 + currencySymbol.Length;
+                        return true;
+                    case 14: // ($ n)
+                        if (destination.IsEmpty)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ')';
+                        charsWritten = 1;
+                        return true;
+                    case 15: // (n $)
+                        if (destination.Length < currencySymbol.Length + 2)
+                        {
+                            return false;
+                        }
+
+                        destination[0] = ' ';
+                        currencySymbol.CopyTo(destination[1..]);
+                        destination[1 + currencySymbol.Length] = ')';
+                        charsWritten = 1 + currencySymbol.Length + 1;
+                        return true;
+                    default: // $- n
+                        return true;
+                }
+            }
+        }
+
+        /// <summary>
+        ///     Exponential format specifier (E)
+        ///     The exponential ("E") format specifier converts a number to a string of the form "-d.ddd…E+ddd" or "-d.ddd…e+ddd",
+        ///     where each "d" indicates a digit (0-9). The string starts with a minus sign if the number is negative. Exactly one
+        ///     digit always precedes the decimal point.
+        /// </summary>
+        /// <remarks>
+        ///     The precision specifier indicates the desired number of digits after the decimal point. If the precision specifier
+        ///     is omitted, a default of six digits after the decimal point is used.
+        ///     The case of the format specifier indicates whether to prefix the exponent with an "E" or an "e". The exponent
+        ///     always consists of a plus or minus sign and a minimum of three digits. The exponent is padded with zeros to meet
+        ///     this minimum, if required.
+        /// </remarks>
+        private static string FormatWithScientificFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.ToString(format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, DefaultScientificFormatPrecision, out var maxNbDecimals))
+            {
+                // not a valid "E" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            // worst case: -1.23E+123456
+            var significantDigitsLength = maxNbDecimals + 1;
+            // assuming a maximum exponent equal to 10^999999
+            var exponentDigitsLength = 1 + int.Max(formatProvider.NegativeSign.Length, formatProvider.PositiveSign.Length) + 6;
+            var maxLength = formatProvider.NegativeSign.Length + formatProvider.NumberDecimalSeparator.Length + significantDigitsLength + exponentDigitsLength;
+
+            var buffer = maxLength <= StackLimit
+                ? stackalloc char[maxLength] // Use stack memory
+                : new char[maxLength]; // Use heap if needed
+
+            TryFormatWithScientificFormat(buffer, out var charsWritten, numerator, denominator, formatProvider, maxNbDecimals, format[0]);
+            return new string(buffer[..charsWritten]);
+        }
+
+        private static bool TryFormatWithScientificFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, ReadOnlySpan<char> format,
+            NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, DefaultScientificFormatPrecision, out var maxNbDecimals))
+            {
+                // not a valid "E" format: assuming a custom format
+                return TryFormatWithCustomFormat(destination, out charsWritten, numerator, denominator, format, formatProvider);
+            }
+
+            return TryFormatWithScientificFormat(destination, out charsWritten, numerator, denominator, formatProvider, maxNbDecimals, format[0]);
+        }
+
+        private static bool TryFormatWithScientificFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator,
+            NumberFormatInfo formatProvider, int maxNbDecimals, char exponentSymbol)
+        {
+            charsWritten = 0;
+            if (numerator.Sign < 0)
+            {
+                if (!formatProvider.NegativeSign.TryCopyTo(destination))
+                {
+                    return false;
+                }
+
+                charsWritten += formatProvider.NegativeSign.Length;
+                numerator = -numerator;
+            }
+
+            var exponent = GetExponentPower(numerator, denominator, out var exponentTerm);
+            var mantissa = exponent switch
+            {
+                0 => Round(numerator, denominator, maxNbDecimals, DefaultMidpointRoundingMode),
+                > 0 => Round(numerator, denominator * exponentTerm, maxNbDecimals, DefaultMidpointRoundingMode),
+                _ => Round(numerator * exponentTerm, denominator, maxNbDecimals, DefaultMidpointRoundingMode)
+            };
+
+            if (mantissa.Denominator.IsOne)
+            {
+                Span<char> formatSpan = stackalloc char[11]; // "F" + up to 10 digits
+                formatSpan[0] = 'F';
+                maxNbDecimals.TryFormat(formatSpan[1..], out var formatCharsWritten, default, CultureInfo.InvariantCulture);
+                if (!mantissa.Numerator.TryFormat(destination[charsWritten..], out var written, formatSpan[..(formatCharsWritten + 1)], formatProvider))
+                {
+                    return false;
+                }
+
+                charsWritten += written;
+            }
+            else
+            {
+                if (!TryAppendDecimals(destination[charsWritten..], out var written, mantissa.Numerator, mantissa.Denominator, formatProvider, maxNbDecimals, "F0"))
+                {
+                    return false;
+                }
+
+                charsWritten += written;
+            }
+
+            if (charsWritten == destination.Length)
+            {
+                return false;
+            }
+
+            destination[charsWritten] = exponentSymbol;
+            charsWritten++;
+            if (exponent >= 0)
+            {
+                if (!formatProvider.PositiveSign.TryCopyTo(destination[charsWritten..]))
+                {
+                    return false;
+                }
+
+                charsWritten += formatProvider.PositiveSign.Length;
+            }
+
+            // note: for the standard numeric types this is fixed to "D3" (but we could go higher)
+            ReadOnlySpan<char> exponentFormat = exponent < 1000 ? "D3" : Span<char>.Empty;
+            if (!exponent.TryFormat(destination[charsWritten..], out var exponentCharsWritten, exponentFormat, formatProvider))
+            {
+                return false;
+            }
+
+            charsWritten += exponentCharsWritten;
+            return true;
+        }
+
+        /// <summary>
+        ///     The general ("G") format specifier converts a number to the more compact of either fixed-point or scientific
+        ///     notation, depending on the type of the number and whether a precision specifier is present.
+        /// </summary>
+        /// <remarks>
+        ///     The precision specifier
+        ///     defines the maximum number of significant digits that can appear in the result string. If the precision specifier
+        ///     is omitted or zero, the type of the number determines the default precision.
+        /// </remarks>
+        private static string FormatGeneral(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, DefaultGeneralFormatPrecision, out var maxNbDecimals))
+            {
+                // not a valid "G" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            if (maxNbDecimals == 0)
+            {
+                maxNbDecimals = DefaultGeneralFormatPrecision;
+            }
+
+            // worst case: -1.23E+123456
+            var significantDigitsLength = maxNbDecimals;
+            // assuming a maximum exponent equal to 10^999999
+            var exponentDigitsLength = 1 + int.Max(formatProvider.NegativeSign.Length, formatProvider.PositiveSign.Length) + 6;
+            var maxLength = formatProvider.NegativeSign.Length + formatProvider.NumberDecimalSeparator.Length + significantDigitsLength + exponentDigitsLength;
+
+            var buffer = maxLength <= StackLimit
+                ? stackalloc char[maxLength] // Use stack memory
+                : new char[maxLength]; // Use heap if needed
+
+            TryFormatGeneral(buffer, out var charsWritten, numerator, denominator, formatProvider, maxNbDecimals, format[0] is 'g');
+            return new string(buffer[..charsWritten]);
+        }
+
+        private static bool TryFormatGeneral(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, ReadOnlySpan<char> format,
+            NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.TryFormat(destination, out charsWritten, format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, DefaultGeneralFormatPrecision, out var maxNbDecimals))
+            {
+                // not a valid "G" format: assuming a custom format
+                return TryFormatWithCustomFormat(destination, out charsWritten, numerator, denominator, format, formatProvider);
+            }
+
+            if (maxNbDecimals == 0)
+            {
+                maxNbDecimals = DefaultGeneralFormatPrecision;
+            }
+
+            return TryFormatGeneral(destination, out charsWritten, numerator, denominator, formatProvider, maxNbDecimals, format[0] == 'g');
+        }
+
+        private static bool TryFormatGeneral(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, NumberFormatInfo formatProvider,
+            int maxNbDecimals, bool lowerCase)
+        {
+            charsWritten = 0;
+            if (numerator.Sign < 0)
+            {
+                if (!formatProvider.NegativeSign.TryCopyTo(destination))
+                {
+                    return false;
+                }
+
+                charsWritten += formatProvider.NegativeSign.Length;
+                numerator = -numerator;
+            }
+
+            var exponent = GetExponentPower(numerator, denominator, out var exponentTerm);
+
+            if (exponent == maxNbDecimals - 1)
+            {
+                // integral result: both 123400 (1.234e5) and 123400.01 (1.234001e+005) result in "123400" with the "G6" format
+                var roundedValue = RoundToBigInteger(numerator, denominator, DefaultMidpointRoundingMode);
+                if (!roundedValue.TryFormat(destination[charsWritten..], out var written))
+                {
+                    return false;
+                }
+
+                charsWritten += written;
+                return true;
+            }
+
+            if (exponent > maxNbDecimals - 1)
+            {
+                // we are required to shorten down a number of the form 123400 (1.234E+05)
+                if (maxNbDecimals == 1)
+                {
+                    var roundedValue = RoundToBigInteger(numerator, denominator * exponentTerm, DefaultMidpointRoundingMode);
+                    if (!roundedValue.TryFormat(destination[charsWritten..], out var written))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += written;
+                }
+                else
+                {
+                    var mantissa = Round(numerator, denominator * exponentTerm, maxNbDecimals - 1, DefaultMidpointRoundingMode);
+                    if (!TryAppendSignificantDecimals(destination[charsWritten..], out var written, mantissa, formatProvider, maxNbDecimals - 1, "F0"))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += written;
+                }
+
+                if (!TryAppendExponentWithSignificantDigits(destination[charsWritten..], out var exponentCharsWritten, exponent, formatProvider, lowerCase ? 'e' : 'E'))
+                {
+                    return false;
+                }
+
+                charsWritten += exponentCharsWritten;
+                return true;
+            }
+
+            if (exponent <= -5)
+            {
+                // the largest value would have the form: 1.23e-5 (0.0000123)
+                var mantissa = Round(numerator * exponentTerm, denominator, maxNbDecimals - 1, DefaultMidpointRoundingMode);
+                if (!TryAppendSignificantDecimals(destination[charsWritten..], out var written, mantissa, formatProvider, maxNbDecimals - 1, "F0"))
+                {
+                    return false;
+                }
+
+                charsWritten += written;
+                if (!TryAppendExponentWithSignificantDigits(destination[charsWritten..], out written, exponent, formatProvider, lowerCase ? 'e' : 'E'))
+                {
+                    return false;
+                }
+
+                charsWritten += written;
+            }
+            else
+            {
+                // the smallest value would have the form: 1.23e-4 (0.000123)
+                var roundedDecimal = Round(numerator, denominator, maxNbDecimals - exponent - 1, DefaultMidpointRoundingMode);
+                if (!TryAppendSignificantDecimals(destination[charsWritten..], out var written, roundedDecimal, formatProvider, maxNbDecimals - exponent - 1, "F0"))
+                {
+                    return false;
+                }
+
+                charsWritten += written;
+            }
+
+            return true;
+        }
+
+        private static string FormatWithCustomFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            return new QuantityValue(numerator, denominator).ToDouble().ToString(format, formatProvider);
+        }
+
+        private static bool TryFormatWithCustomFormat(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, ReadOnlySpan<char> format,
+            NumberFormatInfo formatProvider)
+        {
+            return new QuantityValue(numerator, denominator).ToDouble().TryFormat(destination, out charsWritten, format, formatProvider);
+        }
+
+        /// <summary>
+        ///     Attempts to append the decimal representation of a fraction to the specified destination span.
+        /// </summary>
+        /// <param name="destination">
+        ///     The <see cref="Span{T}" /> of characters to which the decimal representation will be appended.
+        /// </param>
+        /// <param name="charsWritten">
+        ///     When this method returns, contains the number of characters written to the <paramref name="destination" />.
+        /// </param>
+        /// <param name="numerator">
+        ///     The numerator of the fraction.
+        /// </param>
+        /// <param name="denominator">
+        ///     The denominator of the fraction. It should be a power of 10, corresponding to the specified
+        ///     <paramref name="nbDecimals" />.
+        /// </param>
+        /// <param name="formatProvider">
+        ///     The <see cref="NumberFormatInfo" /> that provides culture-specific formatting information.
+        /// </param>
+        /// <param name="nbDecimals">
+        ///     The maximum number of decimal places to include in the representation.
+        /// </param>
+        /// <param name="quotientFormat">
+        ///     An optional format string for formatting the quotient part of the fraction. Defaults to <c>"F0"</c>.
+        /// </param>
+        /// <returns>
+        ///     <c>true</c> if the decimal representation was successfully appended to the <paramref name="destination" />;
+        ///     otherwise, <c>false</c>.
+        /// </returns>
+        /// <remarks>
+        ///     This method calculates the decimal representation of the given fraction by dividing the numerator
+        ///     by the denominator and appending the result to the <paramref name="destination" />. It ensures that the specified
+        ///     number of decimal places is respected by padding with "0" if necessary.
+        ///     <para>
+        ///         The fraction must represent a value with a denominator that is a power of 10, corresponding to the specified
+        ///         <paramref name="nbDecimals" />.
+        ///     </para>
+        /// </remarks>
+        private static bool TryAppendDecimals(Span<char> destination, out int charsWritten, BigInteger numerator, BigInteger denominator, NumberFormatInfo formatProvider,
+            int nbDecimals, ReadOnlySpan<char> quotientFormat)
+        {
+            if (denominator <= long.MaxValue / 10 && numerator <= long.MaxValue && numerator >= long.MinValue)
+            {
+                return TryAppendDecimals(destination, out charsWritten, (long)numerator, (long)denominator, formatProvider, nbDecimals, quotientFormat);
+            }
+
+            var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
+
+            if (!quotient.TryFormat(destination, out charsWritten, quotientFormat, formatProvider))
+            {
+                return false;
+            }
+
+            if (!formatProvider.NumberDecimalSeparator.TryCopyTo(destination[charsWritten..]))
+            {
+                return false;
+            }
+
+            charsWritten += formatProvider.NumberDecimalSeparator.Length;
+
+            var decimalsAdded = 0;
+            while (!remainder.IsZero && decimalsAdded++ < nbDecimals - 1)
+            {
+                if (charsWritten == destination.Length)
+                {
+                    return false;
+                }
+
+                denominator = PreviousPowerOfTen(denominator, nbDecimals - decimalsAdded + 1);
+                var digit = (char)('0' + (int)BigInteger.DivRem(remainder, denominator, out remainder));
+                destination[charsWritten] = digit;
+                charsWritten ++;
+            }
+
+            if (remainder.IsZero)
+            {
+                var zerosRemaining = nbDecimals - decimalsAdded;
+                if (charsWritten + zerosRemaining > destination.Length)
+                {
+                    return false;
+                }
+
+                destination.Slice(charsWritten, zerosRemaining).Fill('0');
+                charsWritten += zerosRemaining;
+            }
+            else if (charsWritten == destination.Length)
+            {
+                return false;
+            }
+            else
+            {
+                var digit = (char)('0' + (int)remainder);
+                destination[charsWritten] = digit;
+                charsWritten ++;
+            }
+
+            return true;
+        }
+
+        private static bool TryAppendDecimals(Span<char> destination, out int charsWritten, long numerator, long denominator, NumberFormatInfo formatProvider,
+            int nbDecimals, ReadOnlySpan<char> quotientFormat)
+        {
+            var (quotient, remainder) = long.DivRem(numerator, denominator);
+
+            if (!quotient.TryFormat(destination, out charsWritten, quotientFormat, formatProvider))
+            {
+                return false;
+            }
+
+            if (!formatProvider.NumberDecimalSeparator.TryCopyTo(destination[charsWritten..]))
+            {
+                return false;
+            }
+
+            charsWritten += formatProvider.NumberDecimalSeparator.Length;
+
+            var decimalsAdded = 0;
+            while (remainder != 0 && decimalsAdded++ < nbDecimals)
+            {
+                if (charsWritten == destination.Length)
+                {
+                    return false;
+                }
+
+                (var digit, remainder) = long.DivRem(remainder * 10, denominator);
+                destination[charsWritten] = (char)(digit + '0');
+                charsWritten++;
+            }
+
+            if (remainder == 0)
+            {
+                var zerosRemaining = nbDecimals - decimalsAdded;
+                if (charsWritten + zerosRemaining > destination.Length)
+                {
+                    return false;
+                }
+
+                destination.Slice(charsWritten, zerosRemaining).Fill('0');
+                charsWritten += zerosRemaining;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        ///     Attempts to append the significant decimal digits of a fractional number to the specified destination span.
+        /// </summary>
+        /// <param name="destination">
+        ///     The <see cref="Span{T}" /> of characters to which the significant decimal digits will be appended.
+        /// </param>
+        /// <param name="charsWritten">
+        ///     When this method returns, contains the number of characters written to the <paramref name="destination" />.
+        /// </param>
+        /// <param name="decimalFraction">
+        ///     The fractional number whose significant decimal digits are to be appended.
+        ///     The denominator of this fraction must be a power of 10, corresponding to the <paramref name="maxNbDecimals" />.
+        /// </param>
+        /// <param name="formatProvider">
+        ///     The <see cref="NumberFormatInfo" /> that provides culture-specific formatting information.
+        /// </param>
+        /// <param name="maxNbDecimals">
+        ///     The maximum number of decimal digits to append.
+        /// </param>
+        /// <param name="quotientFormat">
+        ///     An optional format string that specifies the format of the quotient.
+        /// </param>
+        /// <returns>
+        ///     <see langword="true" /> if the significant decimal digits were successfully appended; otherwise,
+        ///     <see langword="false" />.
+        /// </returns>
+        /// <remarks>
+        ///     This method calculates and appends the significant decimal digits of the given fractional number.
+        ///     It ensures that the number of appended decimal digits does not exceed the specified maximum.
+        ///     <para>
+        ///         The <paramref name="decimalFraction" /> must represent a value with a denominator that is a power of 10,
+        ///         equal to the specified <paramref name="maxNbDecimals" />.
+        ///     </para>
+        ///     <para>
+        ///         The method writes the quotient to the <paramref name="destination" /> span using the specified
+        ///         <paramref name="quotientFormat" /> and appends the decimal separator followed by the significant decimal
+        ///         digits.
+        ///     </para>
+        /// </remarks>
+        private static bool TryAppendSignificantDecimals(Span<char> destination, out int charsWritten, QuantityValue decimalFraction, NumberFormatInfo formatProvider,
+            int maxNbDecimals, ReadOnlySpan<char> quotientFormat)
+        {
+            var numerator = decimalFraction.Numerator;
+            var denominator = decimalFraction.Denominator;
+            if (denominator <= long.MaxValue / 10 && numerator <= long.MaxValue && numerator >= long.MinValue)
+            {
+                return TryAppendSignificantDecimals(destination, out charsWritten, (long)numerator, (long)denominator, formatProvider, maxNbDecimals, quotientFormat);
+            }
+
+            var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
+
+            if (!quotient.TryFormat(destination, out charsWritten, quotientFormat, formatProvider))
+            {
+                return false;
+            }
+
+            if (remainder.IsZero)
+            {
+                return true;
+            }
+
+            if (!formatProvider.NumberDecimalSeparator.TryCopyTo(destination[charsWritten..]))
+            {
+                return false;
+            }
+
+            charsWritten += formatProvider.NumberDecimalSeparator.Length;
+
+            var decimalsRemaining = maxNbDecimals;
+            do
+            {
+                if (charsWritten == destination.Length)
+                {
+                    return false;
+                }
+
+                denominator = PreviousPowerOfTen(denominator, decimalsRemaining);
+                var digit = (char)('0' + (int)BigInteger.DivRem(remainder, denominator, out remainder));
+                destination[charsWritten] = digit;
+                charsWritten ++;
+                decimalsRemaining--;
+            } while (!remainder.IsZero && decimalsRemaining > 0);
+
+            return true;
+        }
+
+        private static bool TryAppendSignificantDecimals(Span<char> destination, out int charsWritten, long numerator, long denominator, NumberFormatInfo formatProvider,
+            int maxNbDecimals, ReadOnlySpan<char> quotientFormat)
+        {
+            var (quotient, remainder) = long.DivRem(numerator, denominator);
+
+            if (!quotient.TryFormat(destination, out charsWritten, quotientFormat, formatProvider))
+            {
+                return false;
+            }
+
+            if (remainder == 0)
+            {
+                return true;
+            }
+
+            if (!formatProvider.NumberDecimalSeparator.TryCopyTo(destination[charsWritten..]))
+            {
+                return false;
+            }
+
+            charsWritten += formatProvider.NumberDecimalSeparator.Length;
+
+            var decimalsRemaining = maxNbDecimals;
+            do
+            {
+                if (charsWritten == destination.Length)
+                {
+                    return false;
+                }
+
+                (var digit, remainder) = long.DivRem(remainder * 10, denominator);
+                destination[charsWritten++] = (char)(digit + '0');
+                decimalsRemaining--;
+            } while (remainder != 0 && decimalsRemaining > 0);
+
+            return true;
+        }
+
+        private static bool TryAppendExponentWithSignificantDigits(Span<char> destination, out int charsWritten, int exponent,
+            NumberFormatInfo formatProvider, char exponentSymbol)
+        {
+            charsWritten = 0;
+            if (destination.IsEmpty)
+            {
+                return false;
+            }
+
+            destination[0] = exponentSymbol;
+            charsWritten++;
+            switch (exponent)
+            {
+                case <= -1000:
+                {
+                    if (!exponent.TryFormat(destination[charsWritten..], out var written, default, formatProvider))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += written;
+                    return true;
+                }
+                case <= 0:
+                {
+                    if (!exponent.TryFormat(destination[charsWritten..], out var written, "D2", formatProvider))
+                    {
+                        return false;
+                    }
+
+                    charsWritten += written;
+                    return true;
+                }
+            }
+
+            // exponent > 0
+            if (!formatProvider.PositiveSign.TryCopyTo(destination[charsWritten..]))
+            {
+                return false;
+            }
+
+            charsWritten += formatProvider.PositiveSign.Length;
+            ReadOnlySpan<char> exponentFormat = exponent switch
+            {
+                < 100 => "D2",
+                < 1000 => "D3",
+                _ => Span<char>.Empty
+            };
+
+            if (!exponent.TryFormat(destination[charsWritten..], out var exponentCharsWritten, exponentFormat, formatProvider))
+            {
+                return false;
+            }
+
+            charsWritten += exponentCharsWritten;
+            return true;
+        }
+
+        /// <summary>
+        ///     Calculates the exponent power for the given fraction terms.
+        /// </summary>
+        /// <param name="numerator">The numerator of the fraction.</param>
+        /// <param name="denominator">The denominator of the fraction.</param>
+        /// <param name="powerOfTen">
+        ///     Output parameter that returns the power of ten that corresponds to the calculated exponent
+        ///     power.
+        /// </param>
+        /// <returns>The exponent power for the given fraction.</returns>
+        /// <remarks>It is expected that both terms have the same sign (i.e. the Fraction is positive)</remarks>
+        private static int GetExponentPower(BigInteger numerator, BigInteger denominator, out BigInteger powerOfTen)
+        {
+            // Preconditions: numerator > 0, denominator > 0.
+            var numLen = numerator.GetBitLength();
+            var denLen = denominator.GetBitLength();
+            // If the two numbers have equal bit-length, then their ratio is in [1,2) if numerator >= denominator,
+            // or in (0,1) if numerator < denominator. In these cases the scientific exponent is fixed.
+            if (numLen == denLen)
+            {
+                if (numerator >= denominator)
+                {
+                    powerOfTen = BigInteger.One; // 10^0
+                    return 0;
+                }
+
+                // When numerator < denominator, ratio < 1, and normalization requires multiplying by 10 once.
+                powerOfTen = Ten; // 10^1, leading to an exponent of -1.
+                return -1;
+            }
+
+            if (numLen > denLen)
+            {
+                // Case: number >= 1, so the scientific exponent is positive.
+                // The adjusted candidate uses (diffBits - 1) because an L-bit number is at least 2^(L-1).
+                var diffBits = numLen - denLen;
+                var exponent = (int)Math.Floor((diffBits - 1) * Log10Of2) + 1;
+                powerOfTen = PowerOfTen(exponent);
+
+                // Adjustment: if our candidate powerOfTen is too high,
+                // then the quotient doesn't reach that many digits.
+                if (numerator >= denominator * powerOfTen)
+                {
+                    return exponent;
+                }
+
+                powerOfTen = PreviousPowerOfTen(powerOfTen, exponent);
+                return exponent - 1;
+            }
+            else
+            {
+                // Case: number < 1, so the scientific exponent is negative.
+                // We need the smallest k such that numerator * 10^k >= denominator.
+                var diffBits = denLen - numLen;
+                var exponent = (int)Math.Ceiling(diffBits * Log10Of2) - 1;
+                powerOfTen = PowerOfTen(exponent);
+
+                // First, check if one fewer factor of Ten would suffice.
+                if (numerator * powerOfTen >= denominator)
+                {
+                    return -exponent;
+                }
+
+                // Select the next guess as 10^exponent
+                powerOfTen = NextPowerOfTen(powerOfTen, exponent++);
+
+                // Then, check if our candidate is too low.
+                if (numerator * powerOfTen < denominator)
+                {
+                    powerOfTen = NextPowerOfTen(powerOfTen, exponent++);
+                }
+
+                // For numbers < 1, the scientific exponent is -k.
+                return -exponent;
+            }
+        }
+
+        private static BigInteger PreviousPowerOfTen(BigInteger powerOfTen, int exponent)
+        {
+            return exponent <= PowersOfTen.Length ? PowersOfTen[exponent - 1] : powerOfTen / Ten;
+        }
+
+        private static BigInteger NextPowerOfTen(BigInteger powerOfTen, int exponent)
+        {
+            return exponent + 1 < PowersOfTen.Length ? PowersOfTen[exponent + 1] : powerOfTen * Ten;
+        }
+    }
+
+#else
+    /// <summary>
+    ///     Provides functionality to format the value of a QuantityValue object into a decimal string representation following
+    ///     the
+    ///     standard numeric formats, as implemented by the double type.
+    /// </summary>
+    private static class DecimalNotationFormatter
+    {
+        /// <summary>
+        ///     <list type="bullet">
+        ///         <item>
+        ///             On .NET Framework and .NET Core up to .NET Core 2.0, the runtime selects the result with the greater least
+        ///             significant digit (that is, using <see cref="MidpointRounding.AwayFromZero" />).
+        ///         </item>
+        ///         <item>
+        ///             On .NET Core 2.1 and later, the runtime selects the result with an even least significant digit (that is,
+        ///             using  <see cref="MidpointRounding.ToEven" />).
+        ///         </item>
+        ///     </list>
+        /// </summary>
+        private const MidpointRounding DefaultMidpointRoundingMode = MidpointRounding.AwayFromZero;
+
+        /// <summary>
+        ///     The default precision used for the general format specifier (G)
+        /// </summary>
+        private const int DefaultGeneralFormatPrecision =
+#if NETCOREAPP2_0_OR_GREATER
+            16;
+#else
+            15;
+#endif
+
+        /// <summary>
+        ///     The default precision used for the exponential (scientific) format specifier (E)
+        /// </summary>
+        private const int DefaultScientificFormatPrecision = 6;
+
+        private static readonly double Log10Of2 = Math.Log10(2);
+
+
+        /// <summary>
+        ///     Formats the value of the specified Fraction as a string using the specified format.
+        /// </summary>
+        /// <param name="format">A standard or custom numeric format string.</param>
+        /// <param name="fraction">The Fraction object to be formatted.</param>
+        /// <param name="formatProvider">An object that supplies culture-specific formatting information.</param>
+        /// <returns>
+        ///     The string representation of the value of the Fraction object as specified by the format and formatProvider
+        ///     parameters.
+        /// </returns>
+        /// <remarks>
+        ///     This method supports the following format strings:
+        ///     <list type="bullet">
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-general-g-format-specifier">
+        ///                     'G'
+        ///                     or 'g'
+        ///                 </see>
+        ///                 : General format. Example: 400/3 formatted with 'G2' gives "1.3E+02".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-fixed-point-f-format-specifier">
+        ///                     'F'
+        ///                     or 'f'
+        ///                 </see>
+        ///                 : Fixed-point format. Example: 12345/10 formatted with 'F2' gives "1234.50".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-number-n-format-specifier">
+        ///                     'N'
+        ///                     or 'n'
+        ///                 </see>
+        ///                 : Standard Numeric format. Example: 1234567/1000 formatted with 'N2' gives "1,234.57".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-exponential-e-format-specifier">
+        ///                     'E'
+        ///                     or 'e'
+        ///                 </see>
+        ///                 : Scientific format. Example: 1234567/1000 formatted with 'E2' gives "1.23E+003".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-percent-p-format-specifier">
+        ///                     'P'
+        ///                     or 'p'
+        ///                 </see>
+        ///                 : Percent format. Example: 2/3 formatted with 'P2' gives "66.67 %".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://docs.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings#the-currency-c-format-specifier">
+        ///                     'C'
+        ///                     or 'c'
+        ///                 </see>
+        ///                 : Currency format. Example: 1234567/1000 formatted with 'C2' gives "$1,234.57".
+        ///             </description>
+        ///         </item>
+        ///         <item>
+        ///             <description>
+        ///                 <see
+        ///                     href="https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings#RFormatString">
+        ///                     'R'
+        ///                     or 'r'
+        ///                 </see>
+        ///                 : Round-trip format. Example: 1234567/1000 formatted with 'R' gives "1234.567".
+        ///             </description>
+        ///         </item>
+        ///     </list>
+        ///     Note: The 'R' format and custom formats do not support precision specifiers and are handed over to the `double`
+        ///     type for formatting, which may result in a loss of precision.
+        ///     For more information about the formatter, see the
+        ///     <see href="https://github.com/danm-de/Fractions?tab=readme-ov-file#decimalnotationformatter">
+        ///         DecimalNotationFormatter
+        ///         section
+        ///     </see>
+        ///     in the GitHub README.
+        /// </remarks>
+        public static string Format(QuantityValue fraction, string? format, IFormatProvider? formatProvider)
+        {
+            formatProvider ??= CultureInfo.CurrentCulture;
+            var numberFormatInfo = (NumberFormatInfo)formatProvider.GetFormat(typeof(NumberFormatInfo))!;
+
+            var numerator = fraction.Numerator;
+            var denominator = fraction.Denominator;
+            if (denominator.Sign == 0)
+            {
+                return numerator.Sign switch
+                {
+                    1 => numberFormatInfo.PositiveInfinitySymbol,
+                    -1 => numberFormatInfo.NegativeInfinitySymbol,
+                    _ => numberFormatInfo.NaNSymbol
+                };
+            }
+
+            if (string.IsNullOrEmpty(format))
+            {
+                return FormatGeneral(numerator, denominator, "G", numberFormatInfo);
+            }
+
+            if (format![0] is 'S' or 's' &&
+                (format.Length == 1 || int.TryParse(format.Substring(1), NumberStyles.Integer, CultureInfo.InvariantCulture, out _)))
+            {
+                throw new FormatException(
+                    $"The \"{format}\" significant-digits format is no longer supported; use a standard or custom numeric format string.");
+            }
+
+            var formatCharacter = format[0];
+            return formatCharacter switch
+            {
+                'G' or 'g' => FormatGeneral(numerator, denominator, format, numberFormatInfo),
+                'F' or 'f' => FormatWithFixedPointFormat(numerator, denominator, format, numberFormatInfo),
+                'N' or 'n' => FormatWithStandardNumericFormat(numerator, denominator, format, numberFormatInfo),
+                'E' or 'e' => FormatWithScientificFormat(numerator, denominator, format, numberFormatInfo),
+                'P' or 'p' => FormatWithPercentFormat(numerator, denominator, format, numberFormatInfo),
+                'C' or 'c' => FormatWithCurrencyFormat(numerator, denominator, format, numberFormatInfo),
+                _ => // 'R', 'r' and the custom formats are handed over to the double (possible loss of precision)
+                    fraction.ToDouble().ToString(format, formatProvider)
+            };
+        }
+
+        private static bool TryGetPrecisionDigits(string format, int defaultPrecision, out int maxNbDecimals)
+        {
+            if (format.Length == 1)
+            {
+                // The number of digits is not specified, use default precision.
+                maxNbDecimals = defaultPrecision;
+                return true;
+            }
+
+#if NET
+            if (int.TryParse(format.AsSpan(1), NumberStyles.Integer, CultureInfo.InvariantCulture, out maxNbDecimals))
+            {
+                return true;
+            }
+#else
+            if (int.TryParse(format.Substring(1), NumberStyles.Integer, CultureInfo.InvariantCulture, out maxNbDecimals))
+            {
+                return true;
+            }
+#endif
+
+            // Seems to be some kind of custom format we do not understand, fallback to default precision.
+            maxNbDecimals = defaultPrecision;
+            return false;
+        }
+
+        /// <summary>
+        ///     The fixed-point ("F") format specifier converts a number to a string of the form "-ddd.ddd…" where each "d"
+        ///     indicates a digit (0-9). The string starts with a minus sign if the number is negative.
+        /// </summary>
+        /// <remarks>
+        ///     The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted, the
+        ///     current <see cref="NumberFormatInfo.NumberDecimalDigits" /> property supplies the numeric precision.
+        /// </remarks>
+        private static string FormatWithFixedPointFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.ToString(format, formatProvider)!;
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.NumberDecimalDigits, out var maxNbDecimalsAfterRadix))
+            {
+                // not a valid "F" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            if (maxNbDecimalsAfterRadix == 0)
+            {
+                return RoundToBigInteger(numerator, denominator, DefaultMidpointRoundingMode).ToString(format, formatProvider)!;
+            }
+
+            var (roundedNumerator, roundedDenominator) = Round(numerator, denominator, maxNbDecimalsAfterRadix, DefaultMidpointRoundingMode);
+            bool isPositive;
+            switch (roundedNumerator.Sign)
+            {
+                case 0:
+                    return 0.ToString(format, formatProvider);
+                case 1:
+                    isPositive = true;
+                    break;
+                default:
+                    isPositive = false;
+                    roundedNumerator = -roundedNumerator;
+                    break;
+            }
+
+            var sb = new StringBuilder(12 + maxNbDecimalsAfterRadix);
+            if (!isPositive)
+            {
+                sb.Append(formatProvider.NegativeSign);
+            }
+
+            return AppendDecimals(sb, roundedNumerator, roundedDenominator, formatProvider, maxNbDecimalsAfterRadix).ToString();
+        }
+
+        /// <summary>
+        ///     The numeric ("N") format specifier converts a number to a string of the form "-d,ddd,ddd.ddd…", where "-"
+        ///     indicates
+        ///     a negative number symbol if required, "d" indicates a digit (0-9), "," indicates a group separator, and "."
+        ///     indicates a decimal point symbol.
+        /// </summary>
+        /// <remarks>
+        ///     The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted, the
+        ///     current <see cref="NumberFormatInfo.NumberDecimalDigits" /> property supplies the numeric precision.
+        /// </remarks>
+        private static string FormatWithStandardNumericFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.ToString(format, formatProvider)!;
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.NumberDecimalDigits, out var maxNbDecimals))
+            {
+                // not a valid "N" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            if (maxNbDecimals == 0)
+            {
+                var roundedValue = RoundToBigInteger(numerator, denominator, DefaultMidpointRoundingMode);
+                return roundedValue.ToString(format, formatProvider)!;
+            }
+
+            var (roundedNumerator, roundedDenominator) = Round(numerator, denominator, maxNbDecimals, DefaultMidpointRoundingMode);
+            bool isPositive;
+            switch (roundedNumerator.Sign)
+            {
+                case 0:
+                    return 0.ToString(format, formatProvider);
+                case 1:
+                    isPositive = true;
+                    break;
+                default:
+                    isPositive = false;
+                    roundedNumerator = -roundedNumerator;
+                    break;
+            }
+
+            var sb = AppendDecimals(new StringBuilder(6 + maxNbDecimals), roundedNumerator, roundedDenominator, formatProvider, maxNbDecimals, "N0");
+            return isPositive
+                ? sb.ToString()
+                : WithNegativeSign(sb, formatProvider.NegativeSign, formatProvider.NumberNegativePattern);
+
+            static string WithNegativeSign(StringBuilder sb, string negativeSignSymbol, int pattern)
+            {
+                return pattern switch
+                {
+                    0 => // (n)
+                        sb.Insert(0, '(').Append(')').ToString(),
+                    1 => // -n
+                        sb.Insert(0, negativeSignSymbol).ToString(),
+                    2 => // - n
+                        sb.Insert(0, negativeSignSymbol + ' ').ToString(),
+                    3 => // n-
+                        sb.Append(negativeSignSymbol).ToString(),
+                    _ => // n -
+                        sb.Append(' ').Append(negativeSignSymbol).ToString()
+                };
+            }
+        }
+
+        /// <summary>
+        ///     The percent ("P") format specifier multiplies a number by 100 and converts it to a string that represents a
+        ///     percentage.
+        /// </summary>
+        /// <remarks>
+        ///     The precision specifier indicates the desired number of decimal places. If the precision specifier is omitted,
+        ///     the default numeric precision supplied by the current <see cref="NumberFormatInfo.PercentDecimalDigits" /> property
+        ///     is used.
+        /// </remarks>
+        private static string FormatWithPercentFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.ToString(format, formatProvider)!;
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.PercentDecimalDigits, out var maxNbDecimals))
+            {
+                // not a valid "P" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            StringBuilder sb;
+            bool isPositive;
+            if (maxNbDecimals == 0)
+            {
+                var roundedValue = RoundToBigInteger(numerator * 100, denominator, DefaultMidpointRoundingMode);
+                switch (roundedValue.Sign)
+                {
+                    case 0:
+                        return 0.ToString(format, formatProvider);
+                    case 1:
+                        isPositive = true;
+                        break;
+                    default:
+                        isPositive = false;
+                        roundedValue = -roundedValue;
+                        break;
+                }
+
+                var percentFormatInfo = new NumberFormatInfo
+                {
+                    NumberDecimalSeparator = formatProvider.PercentDecimalSeparator,
+                    NumberGroupSeparator = formatProvider.PercentGroupSeparator,
+                    NumberGroupSizes = formatProvider.PercentGroupSizes,
+                    NativeDigits = formatProvider.NativeDigits,
+                    DigitSubstitution = formatProvider.DigitSubstitution
+                };
+                sb = new StringBuilder(roundedValue.ToString("N0", percentFormatInfo));
+            }
+            else
+            {
+                var (roundedNumerator, roundedDenominator) = Round(numerator * 100, denominator, maxNbDecimals, DefaultMidpointRoundingMode);
+                switch (roundedNumerator.Sign)
+                {
+                    case 0:
+                        return 0.ToString(format, formatProvider);
+                    case 1:
+                        isPositive = true;
+                        break;
+                    default:
+                        isPositive = false;
+                        roundedNumerator = -roundedNumerator;
+                        break;
+                }
+
+                var percentFormatInfo = new NumberFormatInfo
+                {
+                    NumberDecimalSeparator = formatProvider.PercentDecimalSeparator,
+                    NumberGroupSeparator = formatProvider.PercentGroupSeparator,
+                    NumberGroupSizes = formatProvider.PercentGroupSizes,
+                    NativeDigits = formatProvider.NativeDigits,
+                    DigitSubstitution = formatProvider.DigitSubstitution
+                };
+                sb = AppendDecimals(new StringBuilder(8 + maxNbDecimals), roundedNumerator, roundedDenominator, percentFormatInfo, maxNbDecimals, "N0");
+            }
+
+            return isPositive
+                ? WithPositiveSign(sb, formatProvider.PercentSymbol, formatProvider.PercentPositivePattern)
+                : WithNegativeSign(sb, formatProvider.PercentSymbol, formatProvider.NegativeSign, formatProvider.PercentNegativePattern);
+
+            static string WithPositiveSign(StringBuilder sb, string percentSymbol, int pattern)
+            {
+                return pattern switch
+                {
+                    0 => // n %
+                        sb.Append(' ').Append(percentSymbol).ToString(),
+                    1 => // n%
+                        sb.Append(percentSymbol).ToString(),
+                    2 => // %n
+                        sb.Insert(0, percentSymbol).ToString(),
+                    _ => // % n
+                        sb.Insert(0, percentSymbol + ' ').ToString()
+                };
+            }
+
+            static string WithNegativeSign(StringBuilder sb, string percentSymbol, string negativeSignSymbol, int pattern)
+            {
+                return pattern switch
+                {
+                    0 => // -n %
+                        sb.Insert(0, negativeSignSymbol).Append(' ').Append(percentSymbol).ToString(),
+                    1 => // -n%
+                        sb.Insert(0, negativeSignSymbol).Append(percentSymbol).ToString(),
+                    2 => // -%n
+                        sb.Insert(0, negativeSignSymbol + percentSymbol).ToString(),
+                    3 => // %-n
+                        sb.Insert(0, percentSymbol + negativeSignSymbol).ToString(),
+                    4 => // %n-
+                        sb.Insert(0, percentSymbol).Append(negativeSignSymbol).ToString(),
+                    5 => // n-%
+                        sb.Append(negativeSignSymbol).Append(percentSymbol).ToString(),
+                    6 => // n%-
+                        sb.Append(percentSymbol).Append(negativeSignSymbol).ToString(),
+                    7 => // -% n
+                        sb.Insert(0, negativeSignSymbol + percentSymbol + ' ').ToString(),
+                    8 => // n %-
+                        sb.Append(' ').Append(percentSymbol).Append(negativeSignSymbol).ToString(),
+                    9 => // % n-
+                        sb.Insert(0, percentSymbol + ' ').Append(negativeSignSymbol).ToString(),
+                    10 => // % -n
+                        sb.Insert(0, percentSymbol + ' ').Insert(2, negativeSignSymbol).ToString(),
+                    _ => // n- %
+                        sb.Append(negativeSignSymbol).Append(' ').Append(percentSymbol).ToString()
+                };
+            }
+        }
+
+
+        /// <summary>
+        ///     The "C" (or currency) format specifier converts a number to a string that represents a currency amount. The
+        ///     precision specifier indicates the desired number of decimal places in the result string. If the precision specifier
+        ///     is omitted, the default precision is defined by the <see cref="NumberFormatInfo.CurrencyDecimalDigits" /> property.
+        /// </summary>
+        /// <remarks>
+        ///     If the value to be formatted has more than the specified or default number of decimal places, the fractional
+        ///     value is rounded in the result string. If the value to the right of the number of specified decimal places is 5 or
+        ///     greater, the last digit in the result string is rounded away from zero.
+        /// </remarks>
+        private static string FormatWithCurrencyFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.ToString(format, formatProvider)!;
+            }
+
+            if (!TryGetPrecisionDigits(format, formatProvider.CurrencyDecimalDigits, out var maxNbDecimals))
+            {
+                // not a valid "C" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            if (maxNbDecimals == 0)
+            {
+                var roundedValue = RoundToBigInteger(numerator, denominator, DefaultMidpointRoundingMode);
+                return roundedValue.ToString(format, formatProvider)!;
+            }
+
+            var (roundedNumerator, roundedDenominator) = Round(numerator, denominator, maxNbDecimals, DefaultMidpointRoundingMode);
+
+            bool isPositive;
+            switch (roundedNumerator.Sign)
+            {
+                case 0:
+                    return 0.ToString(format, formatProvider);
+                case 1:
+                    isPositive = true;
+                    break;
+                default:
+                    isPositive = false;
+                    roundedNumerator = -roundedNumerator;
+                    break;
+            }
+
+            var currencyFormatInfo = new NumberFormatInfo
+            {
+                NumberDecimalSeparator = formatProvider.CurrencyDecimalSeparator,
+                NumberGroupSeparator = formatProvider.CurrencyGroupSeparator,
+                NumberGroupSizes = formatProvider.CurrencyGroupSizes,
+                NativeDigits = formatProvider.NativeDigits,
+                DigitSubstitution = formatProvider.DigitSubstitution
+            };
+
+            var sb = AppendDecimals(new StringBuilder(8 + maxNbDecimals), roundedNumerator, roundedDenominator, currencyFormatInfo, maxNbDecimals, "N0");
+            return isPositive
+                ? WithPositiveSign(sb, formatProvider.CurrencySymbol, formatProvider.CurrencyPositivePattern)
+                : WithNegativeSign(sb, formatProvider.CurrencySymbol, formatProvider.NegativeSign,
+                    formatProvider.CurrencyNegativePattern);
+
+            static string WithPositiveSign(StringBuilder sb, string currencySymbol, int pattern)
+            {
+                return pattern switch
+                {
+                    0 => // $n
+                        sb.Insert(0, currencySymbol).ToString(),
+                    1 => // n$
+                        sb.Append(currencySymbol).ToString(),
+                    2 => // $ n
+                        sb.Insert(0, currencySymbol + ' ').ToString(),
+                    _ => // n $
+                        sb.Append(' ').Append(currencySymbol).ToString()
+                };
+            }
+
+            static string WithNegativeSign(StringBuilder sb, string currencySymbol, string negativeSignSymbol,
+                int pattern)
+            {
+                return pattern switch
+                {
+                    0 => // ($n)
+                        sb.Insert(0, '(').Insert(1, currencySymbol).Append(')').ToString(),
+                    1 => // -$n
+                        sb.Insert(0, negativeSignSymbol + currencySymbol).ToString(),
+                    2 => // $-n
+                        sb.Insert(0, currencySymbol + negativeSignSymbol).ToString(),
+                    3 => // $n-
+                        sb.Insert(0, currencySymbol).Append(negativeSignSymbol).ToString(),
+                    4 => // (n$)
+                        sb.Insert(0, '(').Append(currencySymbol).Append(')').ToString(),
+                    5 => // -n$
+                        sb.Insert(0, negativeSignSymbol).Append(currencySymbol).ToString(),
+                    6 => // n-$
+                        sb.Append(negativeSignSymbol).Append(currencySymbol).ToString(),
+                    7 => // n$-
+                        sb.Append(currencySymbol).Append(negativeSignSymbol).ToString(),
+                    8 => // -n $
+                        sb.Insert(0, negativeSignSymbol).Append(' ').Append(currencySymbol).ToString(),
+                    9 => // -$ n
+                        sb.Insert(0, negativeSignSymbol + currencySymbol + ' ').ToString(),
+                    10 => // n $-
+                        sb.Append(' ').Append(currencySymbol).Append(negativeSignSymbol).ToString(),
+                    11 => // $ n-
+                        sb.Insert(0, currencySymbol + ' ').Append(negativeSignSymbol).ToString(),
+                    12 => // $ -n
+                        sb.Insert(0, currencySymbol + ' ' + negativeSignSymbol).ToString(),
+                    13 => // n- $
+                        sb.Append(negativeSignSymbol).Append(' ').Append(currencySymbol).ToString(),
+                    14 => // ($ n)
+                        sb.Insert(0, '(').Insert(1, currencySymbol + ' ').Append(')').ToString(),
+#if NETSTANDARD
+                    _ => // (n $)
+                        sb.Insert(0, '(').Append(' ').Append(currencySymbol).Append(')').ToString(),
+#else
+                    15 => // (n $)
+                        sb.Insert(0, '(').Append(' ').Append(currencySymbol).Append(')').ToString(),
+                    _ => // $- n
+                        sb.Insert(0, currencySymbol + negativeSignSymbol + ' ').ToString(),
+#endif
+                };
+            }
+        }
+
+        /// <summary>
+        ///     Exponential format specifier (E)
+        ///     The exponential ("E") format specifier converts a number to a string of the form "-d.ddd…E+ddd" or "-d.ddd…e+ddd",
+        ///     where each "d" indicates a digit (0-9). The string starts with a minus sign if the number is negative. Exactly one
+        ///     digit always precedes the decimal point.
+        /// </summary>
+        /// <remarks>
+        ///     The precision specifier indicates the desired number of digits after the decimal point. If the precision specifier
+        ///     is omitted, a default of six digits after the decimal point is used.
+        ///     The case of the format specifier indicates whether to prefix the exponent with an "E" or an "e". The exponent
+        ///     always consists of a plus or minus sign and a minimum of three digits. The exponent is padded with zeros to meet
+        ///     this minimum, if required.
+        /// </remarks>
+        private static string FormatWithScientificFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (denominator.IsOne)
+            {
+                return numerator.ToString(format, formatProvider)!;
+            }
+
+            if (!TryGetPrecisionDigits(format, DefaultScientificFormatPrecision, out var maxNbDecimals))
+            {
+                // not a valid "E" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            var sb = new StringBuilder(DefaultScientificFormatPrecision + maxNbDecimals);
+
+            if (numerator.Sign < 0)
+            {
+                sb.Append(formatProvider.NegativeSign);
+                numerator = -numerator;
+            }
+
+            var exponent = GetExponentPower(numerator, denominator, out var exponentTerm);
+            var mantissa = exponent switch
+            {
+                0 => Round(numerator, denominator, maxNbDecimals, DefaultMidpointRoundingMode),
+                > 0 => Round(numerator, denominator * exponentTerm, maxNbDecimals, DefaultMidpointRoundingMode),
+                _ => Round(numerator * exponentTerm, denominator, maxNbDecimals, DefaultMidpointRoundingMode)
+            };
+
+            if (mantissa.Denominator.IsOne)
+            {
+                sb.Append(mantissa.Numerator.ToString($"F{maxNbDecimals}", formatProvider));
+            }
+            else
+            {
+                AppendDecimals(sb, mantissa.Numerator, mantissa.Denominator, formatProvider, maxNbDecimals);
+            }
+
+            return WithAppendedExponent(sb, exponent, formatProvider, format[0]);
+
+            static string WithAppendedExponent(StringBuilder sb, int exponent, NumberFormatInfo numberFormat,
+                char exponentSymbol)
+            {
+                return exponent >= 0
+                    ? sb.Append(exponentSymbol).Append(numberFormat.PositiveSign)
+                        .Append(exponent.ToString("D3", numberFormat)).ToString()
+                    : sb.Append(exponentSymbol).Append(exponent.ToString("D3", numberFormat)).ToString();
+            }
+        }
+
+        /// <summary>
+        ///     The general ("G") format specifier converts a number to the more compact of either fixed-point or scientific
+        ///     notation, depending on the type of the number and whether a precision specifier is present.
+        /// </summary>
+        /// <remarks>
+        ///     The precision specifier
+        ///     defines the maximum number of significant digits that can appear in the result string. If the precision specifier
+        ///     is omitted or zero, the type of the number determines the default precision.
+        /// </remarks>
+        private static string FormatGeneral(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            if (numerator.IsZero)
+            {
+                return 0.ToString(format, formatProvider);
+            }
+
+            if (!TryGetPrecisionDigits(format, DefaultGeneralFormatPrecision, out var maxNbDecimals))
+            {
+                // not a valid "G" format: assuming a custom format
+                return FormatWithCustomFormat(numerator, denominator, format, formatProvider);
+            }
+
+            if (maxNbDecimals == 0)
+            {
+                maxNbDecimals = DefaultGeneralFormatPrecision;
+            }
+
+            var sb = new StringBuilder(3 + maxNbDecimals);
+
+            if (numerator.Sign < 0)
+            {
+                sb.Append(formatProvider.NegativeSign);
+                numerator = -numerator;
+            }
+
+            var exponent = GetExponentPower(numerator, denominator, out var exponentTerm);
+
+            if (exponent == maxNbDecimals - 1)
+            {
+                // integral result: both 123400 (1.234e5) and 123400.01 (1.234001e+005) result in "123400" with the "G6" format
+                return sb.Append(RoundToBigInteger(numerator, denominator, DefaultMidpointRoundingMode)).ToString();
+            }
+
+            if (exponent > maxNbDecimals - 1)
+            {
+                // we are required to shorten down a number of the form 123400 (1.234E+05)
+                if (maxNbDecimals == 1)
+                {
+                    sb.Append(RoundToBigInteger(numerator, denominator * exponentTerm, DefaultMidpointRoundingMode));
+                }
+                else
+                {
+                    var mantissa = Round(numerator, denominator * exponentTerm, maxNbDecimals - 1, DefaultMidpointRoundingMode);
+                    AppendSignificantDecimals(sb, mantissa, formatProvider, maxNbDecimals - 1);
+                }
+
+                return AppendExponentWithSignificantDigits(sb, exponent, formatProvider, format[0] is 'g' ? 'e' : 'E').ToString();
+            }
+
+            if (exponent <= -5)
+            {
+                // the largest value would have the form: 1.23e-5 (0.0000123)
+                var mantissa = Round(numerator * exponentTerm, denominator, maxNbDecimals - 1, DefaultMidpointRoundingMode);
+                AppendSignificantDecimals(sb, mantissa, formatProvider, maxNbDecimals - 1);
+                return AppendExponentWithSignificantDigits(sb, exponent, formatProvider, format[0] is 'g' ? 'e' : 'E')
+                    .ToString();
+            }
+
+            // the smallest value would have the form: 1.23e-4 (0.000123)
+            var roundedDecimal = Round(numerator, denominator, maxNbDecimals - exponent - 1, DefaultMidpointRoundingMode);
+            return AppendSignificantDecimals(sb, roundedDecimal, formatProvider, maxNbDecimals - exponent - 1)
+                .ToString();
+        }
+
+        private static string FormatWithCustomFormat(BigInteger numerator, BigInteger denominator, string format, NumberFormatInfo formatProvider)
+        {
+            return new QuantityValue(numerator, denominator).ToDouble().ToString(format, formatProvider);
+        }
+
+        /// <summary>
+        ///     Appends the decimal representation of a fraction to the specified <see cref="StringBuilder" />.
+        /// </summary>
+        /// <param name="sb">The <see cref="StringBuilder" /> to which the decimal representation will be appended.</param>
+        /// <param name="numerator">The numerator of the fraction.</param>
+        /// <param name="denominator">
+        ///     The denominator of the fraction: should be a power of 10, equal to the specified
+        ///     <paramref name="nbDecimals" />
+        /// </param>
+        /// <param name="formatProvider">The <see cref="NumberFormatInfo" /> that provides culture-specific formatting information.</param>
+        /// <param name="nbDecimals">The maximum number of decimal places to include in the representation.</param>
+        /// <param name="quotientFormat">
+        ///     An optional format string for formatting the quotient part of the fraction.
+        ///     Defaults to <c>"F0"</c>.
+        /// </param>
+        /// <returns>The <see cref="StringBuilder" /> with the appended decimal representation.</returns>
+        /// <remarks>
+        ///     This method calculates the decimal representation of the given fraction by dividing the numerator
+        ///     by the denominator and appending the result to the <paramref name="sb" />, padding with "0" to ensure the specified
+        ///     number of decimal places is respected.
+        ///     <para>
+        ///         The fraction must represent a value with a denominator that is a power of 10, equal to the specified
+        ///         <paramref name="nbDecimals" />.
+        ///     </para>
+        /// </remarks>
+        private static StringBuilder AppendDecimals(StringBuilder sb, BigInteger numerator, BigInteger denominator, NumberFormatInfo formatProvider,
+            int nbDecimals, string quotientFormat = "F0")
+        {
+            if (denominator <= long.MaxValue / 10 && numerator <= long.MaxValue && numerator >= long.MinValue)
+            {
+                return AppendDecimals(sb, (long)numerator, (long)denominator, formatProvider, nbDecimals, quotientFormat);
+            }
+
+            var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
+
+            sb.Append(quotient.ToString(quotientFormat, formatProvider)).Append(formatProvider.NumberDecimalSeparator);
+
+            var decimalsAdded = 0;
+            while (!remainder.IsZero && decimalsAdded++ < nbDecimals - 1)
+            {
+                denominator = PreviousPowerOfTen(denominator, nbDecimals - decimalsAdded + 1);
+                var digit = (char)('0' + (int)BigInteger.DivRem(remainder, denominator, out remainder));
+                sb.Append(digit);
+            }
+
+            if (remainder.IsZero)
+            {
+                sb.Append('0', nbDecimals - decimalsAdded);
+            }
+            else
+            {
+                sb.Append((char)('0' + (int)remainder));
+            }
+
+            return sb;
+        }
+
+        private static StringBuilder AppendDecimals(StringBuilder sb, long numerator, long denominator, NumberFormatInfo formatProvider,
+            int nbDecimals, string quotientFormat = "F0")
+        {
+            var quotient = numerator / denominator;
+            var remainder = numerator % denominator;
+
+            sb.Append(quotient.ToString(quotientFormat, formatProvider)).Append(formatProvider.NumberDecimalSeparator);
+
+            var decimalsAdded = 0;
+            while (remainder != 0 && decimalsAdded++ < nbDecimals)
+            {
+                sb.Append((char)('0' + remainder * 10 / denominator));
+                remainder = remainder * 10 % denominator;
+            }
+
+            if (remainder == 0)
+            {
+                sb.Append('0', nbDecimals - decimalsAdded);
+            }
+
+            return sb;
+        }
+
+        /// <summary>
+        ///     Appends the significant decimal digits of a fractional number to the specified <see cref="StringBuilder" />.
+        /// </summary>
+        /// <param name="sb">The <see cref="StringBuilder" /> to which the significant decimal digits will be appended.</param>
+        /// <param name="decimalFraction">
+        ///     The fractional number whose significant decimal digits are to be appended.
+        ///     The denominator of this fraction must be a power of 10, corresponding to the <paramref name="maxNbDecimals" />.
+        /// </param>
+        /// <param name="formatProvider">The <see cref="NumberFormatInfo" /> that provides culture-specific formatting information.</param>
+        /// <param name="maxNbDecimals">The maximum number of decimal digits to append.</param>
+        /// <param name="quotientFormat">
+        ///     An optional format string that specifies the format of the quotient. Defaults to "F0".
+        /// </param>
+        /// <returns>
+        ///     The <see cref="StringBuilder" /> instance with the appended significant decimal digits.
+        /// </returns>
+        /// <remarks>
+        ///     This method calculates and appends the significant decimal digits of the given fractional number.
+        ///     It ensures that the number of appended decimal digits does not exceed the specified maximum.
+        ///     <para>
+        ///         The <paramref name="decimalFraction" /> must represent a value with a denominator that is a power of 10,
+        ///         equal to the specified <paramref name="maxNbDecimals" />.
+        ///     </para>
+        /// </remarks>
+        private static StringBuilder AppendSignificantDecimals(StringBuilder sb, QuantityValue decimalFraction, NumberFormatInfo formatProvider,
+            int maxNbDecimals, string quotientFormat = "F0")
+        {
+            var numerator = decimalFraction.Numerator;
+            var denominator = decimalFraction.Denominator;
+            if (denominator <= long.MaxValue / 10 && numerator <= long.MaxValue && numerator >= long.MinValue)
+            {
+                return AppendSignificantDecimals(sb, (long)numerator, (long)denominator, formatProvider, maxNbDecimals, quotientFormat);
+            }
+
+            var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
+
+            sb.Append(quotient.ToString(quotientFormat, formatProvider));
+
+            if (remainder.IsZero)
+            {
+                return sb;
+            }
+
+            sb.Append(formatProvider.NumberDecimalSeparator);
+
+            var decimalsRemaining = maxNbDecimals;
+            do
+            {
+                denominator = PreviousPowerOfTen(denominator, decimalsRemaining);
+                var digit = (char)('0' + (int)BigInteger.DivRem(remainder, denominator, out remainder));
+                sb.Append(digit);
+                decimalsRemaining--;
+            } while (!remainder.IsZero && decimalsRemaining > 0);
+
+            return sb;
+        }
+
+        private static StringBuilder AppendSignificantDecimals(StringBuilder sb, long numerator, long denominator, NumberFormatInfo formatProvider,
+            int maxNbDecimals, string quotientFormat = "F0")
+        {
+            var quotient = numerator / denominator;
+            var remainder = numerator % denominator;
+
+            sb.Append(quotient.ToString(quotientFormat, formatProvider));
+
+            if (remainder == 0)
+            {
+                return sb;
+            }
+
+            sb.Append(formatProvider.NumberDecimalSeparator);
+
+            var decimalsRemaining = maxNbDecimals;
+            do
+            {
+                sb.Append((char)('0' + remainder * 10 / denominator));
+                remainder = remainder * 10 % denominator;
+                decimalsRemaining--;
+            } while (remainder != 0 && decimalsRemaining > 0);
+
+            return sb;
+        }
+
+        private static StringBuilder AppendExponentWithSignificantDigits(StringBuilder sb, int exponent, NumberFormatInfo formatProvider, char exponentSymbol)
+        {
+            return exponent switch
+            {
+                <= -1000 => sb.Append(exponentSymbol).Append(exponent.ToString(formatProvider)),
+                <= 0 => sb.Append(exponentSymbol).Append(exponent.ToString("D2", formatProvider)),
+                < 100 => sb.Append(exponentSymbol).Append(formatProvider.PositiveSign)
+                    .Append(exponent.ToString("D2", formatProvider)),
+                < 1000 => sb.Append(exponentSymbol).Append(formatProvider.PositiveSign)
+                    .Append(exponent.ToString("D3", formatProvider)),
+                _ => sb.Append(exponentSymbol).Append(formatProvider.PositiveSign).Append(exponent.ToString(formatProvider))
+            };
+        }
+
+        /// <summary>
+        ///     Calculates the exponent power for the given fraction terms.
+        /// </summary>
+        /// <param name="numerator">The numerator of the fraction.</param>
+        /// <param name="denominator">The denominator of the fraction.</param>
+        /// <param name="powerOfTen">
+        ///     Output parameter that returns the power of ten that corresponds to the calculated exponent
+        ///     power.
+        /// </param>
+        /// <returns>The exponent power for the given fraction.</returns>
+        /// <remarks>It is expected that both terms have the same sign (i.e. the Fraction is positive)</remarks>
+        private static int GetExponentPower(BigInteger numerator, BigInteger denominator, out BigInteger powerOfTen)
+        {
+            // Preconditions: numerator > 0, denominator > 0.
+#if NET
+            var numLen = numerator.GetBitLength();
+            var denLen = denominator.GetBitLength();
+#else
+            var numLen = GetBitLength(numerator);
+            var denLen = GetBitLength(denominator);
+#endif
+            // If the two numbers have equal bit-length, then their ratio is in [1,2) if numerator >= denominator,
+            // or in (0,1) if numerator < denominator. In these cases the scientific exponent is fixed.
+            if (numLen == denLen)
+            {
+                if (numerator >= denominator)
+                {
+                    powerOfTen = BigInteger.One; // 10^0
+                    return 0;
+                }
+
+                // When numerator < denominator, ratio < 1, and normalization requires multiplying by 10 once.
+                powerOfTen = Ten; // 10^1, leading to an exponent of -1.
+                return -1;
+            }
+
+            if (numLen > denLen)
+            {
+                // Case: number >= 1, so the scientific exponent is positive.
+                // The adjusted candidate uses (diffBits - 1) because an L-bit number is at least 2^(L-1).
+                var diffBits = numLen - denLen;
+                var exponent = (int)Math.Floor((diffBits - 1) * Log10Of2) + 1;
+                powerOfTen = PowerOfTen(exponent);
+
+                // Adjustment: if our candidate powerOfTen is too high,
+                // then the quotient doesn't reach that many digits.
+                if (numerator >= denominator * powerOfTen)
+                {
+                    return exponent;
+                }
+
+                powerOfTen = PreviousPowerOfTen(powerOfTen, exponent);
+                return exponent - 1;
+            }
+            else
+            {
+                // Case: number < 1, so the scientific exponent is negative.
+                // We need the smallest k such that numerator * 10^k >= denominator.
+                var diffBits = denLen - numLen;
+                var exponent = (int)Math.Ceiling(diffBits * Log10Of2) - 1;
+                powerOfTen = PowerOfTen(exponent);
+
+                // First, check if one fewer factor of Ten would suffice.
+                if (numerator * powerOfTen >= denominator)
+                {
+                    return -exponent;
+                }
+
+                // Select the next guess as 10^exponent
+                powerOfTen = NextPowerOfTen(powerOfTen, exponent++);
+
+                // Then, check if our candidate is too low.
+                if (numerator * powerOfTen < denominator)
+                {
+                    powerOfTen = NextPowerOfTen(powerOfTen, exponent++);
+                }
+
+                // For numbers < 1, the scientific exponent is -k.
+                return -exponent;
+            }
+
+#if NETSTANDARD
+            static long GetBitLength(BigInteger value)
+            {
+                // Using BigInteger.Log(value, 2) avoids creating a byte array.
+                // Note: For value > 0 this returns a double that we floor and add 1.
+                return (long)Math.Floor(BigInteger.Log(value, 2)) + 1;
+            }
+#endif
+        }
+
+        private static BigInteger PreviousPowerOfTen(BigInteger powerOfTen, int exponent)
+        {
+            return exponent <= PowersOfTen.Length ? PowersOfTen[exponent - 1] : powerOfTen / Ten;
+        }
+
+        private static BigInteger NextPowerOfTen(BigInteger powerOfTen, int exponent)
+        {
+            return exponent + 1 < PowersOfTen.Length ? PowersOfTen[exponent + 1] : powerOfTen * Ten;
+        }
+    }
+
+
+#endif
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.ConvertToType.cs b/UnitsNet/CustomCode/Value/QuantityValue.ConvertToType.cs
new file mode 100644
index 0000000000..8cb0930749
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.ConvertToType.cs
@@ -0,0 +1,156 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet;
+
+public partial struct QuantityValue
+{
+    #region Implementation of IConvertible
+
+    TypeCode IConvertible.GetTypeCode()
+    {
+        return TypeCode.Object;
+    }
+
+    bool IConvertible.ToBoolean(IFormatProvider? provider)
+    {
+        throw ExceptionHelper.CreateInvalidCastException<QuantityValue, char>();
+    }
+
+    byte IConvertible.ToByte(IFormatProvider? provider)
+    {
+        return (byte)this;
+    }
+
+    char IConvertible.ToChar(IFormatProvider? provider)
+    {
+        throw ExceptionHelper.CreateInvalidCastException<QuantityValue, char>();
+    }
+
+    DateTime IConvertible.ToDateTime(IFormatProvider? provider)
+    {
+        throw ExceptionHelper.CreateInvalidCastException<QuantityValue, DateTime>();
+    }
+
+    decimal IConvertible.ToDecimal(IFormatProvider? provider)
+    {
+        return ToDecimal();
+    }
+
+    double IConvertible.ToDouble(IFormatProvider? provider)
+    {
+        return ToDouble();
+    }
+
+    short IConvertible.ToInt16(IFormatProvider? provider)
+    {
+        return (short)this;
+    }
+
+    int IConvertible.ToInt32(IFormatProvider? provider)
+    {
+        return (int)this;
+    }
+
+    long IConvertible.ToInt64(IFormatProvider? provider)
+    {
+        return (long)this;
+    }
+
+    sbyte IConvertible.ToSByte(IFormatProvider? provider)
+    {
+        return (sbyte)this;
+    }
+
+    float IConvertible.ToSingle(IFormatProvider? provider)
+    {
+        return (float)this;
+    }
+
+    ushort IConvertible.ToUInt16(IFormatProvider? provider)
+    {
+        return (ushort)this;
+    }
+
+    uint IConvertible.ToUInt32(IFormatProvider? provider)
+    {
+        return (uint)this;
+    }
+
+    ulong IConvertible.ToUInt64(IFormatProvider? provider)
+    {
+        return (ulong)this;
+    }
+
+    object IConvertible.ToType(Type conversionType, IFormatProvider? provider)
+    {
+        if (conversionType == null)
+        {
+            throw new ArgumentNullException(nameof(conversionType));
+        }
+
+        if (conversionType == typeof(string))
+        {
+            return ToString(provider);
+        }
+
+        if (conversionType == typeof(double))
+        {
+            return ToDouble();
+        }
+
+        if (conversionType == typeof(decimal))
+        {
+            return ToDecimal();
+        }
+
+        if (conversionType == typeof(float))
+        {
+            return (float)this;
+        }
+
+        if (conversionType == typeof(long))
+        {
+            return (long)this;
+        }
+
+        if (conversionType == typeof(ulong))
+        {
+            return (ulong)this;
+        }
+
+        if (conversionType == typeof(int))
+        {
+            return (int)this;
+        }
+
+        if (conversionType == typeof(uint))
+        {
+            return (uint)this;
+        }
+
+        if (conversionType == typeof(short))
+        {
+            return (short)this;
+        }
+
+        if (conversionType == typeof(ushort))
+        {
+            return (ushort)this;
+        }
+
+        if (conversionType == typeof(byte))
+        {
+            return (byte)this;
+        }
+
+        if (conversionType == typeof(sbyte))
+        {
+            return (sbyte)this;
+        }
+
+        throw ExceptionHelper.CreateInvalidCastException<QuantityValue>(conversionType);
+    }
+
+    #endregion
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.DebugView.cs b/UnitsNet/CustomCode/Value/QuantityValue.DebugView.cs
new file mode 100644
index 0000000000..4b30e1e6cd
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.DebugView.cs
@@ -0,0 +1,56 @@
+using System.Globalization;
+
+namespace UnitsNet;
+
+public partial struct QuantityValue
+{
+    internal readonly struct QuantityValueDebugView(QuantityValue value)
+    {
+        public BigInteger A => value.Numerator;
+        public BigInteger B => value.Denominator;
+        public bool IsReduced => A.IsZero || B.IsZero || BigInteger.GreatestCommonDivisor(A, B).IsOne;
+#if NET
+        public long NbBits => A.GetBitLength() + B.GetBitLength();
+#else
+        public long NbBits => (A.IsZero ? 0 : (int)BigInteger.Log(BigInteger.Abs(A), 2) + 1) +
+                              (B.IsZero ? 0 : (int)(BigInteger.Log(B, 2) + 1));
+#endif
+        public StringFormatsView StringFormats => new(value);
+        public NumericFormatsView ValueFormats => new(value);
+
+        [DebuggerDisplay("{ShortFormat}")]
+        internal readonly struct StringFormatsView(QuantityValue value)
+        {
+            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+            private readonly QuantityValue _value = value;
+
+            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+            private readonly CultureInfo _currentCulture = CultureInfo.CurrentCulture;
+
+            public string GeneralFormat => _value.ToString("G", _currentCulture);
+
+            public string ShortFormat => _value.ToString("G6", _currentCulture);
+
+            public string SimplifiedFraction
+            {
+                get
+                {
+                    (BigInteger numerator, BigInteger denominator) = Reduce(_value);
+                    return $"{numerator}/{denominator}";
+                }
+            }
+        }
+
+        [DebuggerDisplay("{Double}")]
+        internal readonly struct NumericFormatsView(QuantityValue value)
+        {
+            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+            private readonly QuantityValue _value = value;
+
+            public int Integer => (int)_value;
+            public long Long => (long)_value;
+            public decimal Decimal => _value.ToDecimal();
+            public double Double => _value.ToDouble();
+        }
+    }
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.Equality.cs b/UnitsNet/CustomCode/Value/QuantityValue.Equality.cs
new file mode 100644
index 0000000000..800c600874
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.Equality.cs
@@ -0,0 +1,200 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace UnitsNet;
+
+public partial struct QuantityValue
+{
+    /// <summary>
+    ///     Determines whether this QuantityValue instance is equal to another QuantityValue instance.
+    /// </summary>
+    /// <param name="other">The QuantityValue to compare with this instance.</param>
+    /// <returns>True if the two QuantityValue instances are equal, false otherwise.</returns>
+    public bool Equals(QuantityValue other)
+    {
+        var numerator1 = Numerator;
+        var denominator1 = Denominator;
+        var numerator2 = other.Numerator;
+        var denominator2 = other.Denominator;
+        
+        if (denominator1 == denominator2)
+        {
+            return denominator1.IsZero
+                ? numerator1.Sign == numerator2.Sign // both fractions represent infinities
+                : numerator1 == numerator2;
+        }
+
+        if (denominator1.IsZero || denominator2.IsZero)
+        {
+            // either x or y is NaN or infinity.
+            return false;
+        }
+
+        if (numerator1.IsZero)
+        {
+            return numerator2.IsZero; // if TRUE, both values are 0
+        }
+
+        if (numerator2.IsZero)
+        {
+            return false;
+        }
+
+        var firstNumeratorSign = numerator1.Sign;
+        var secondNumeratorSign = numerator2.Sign;
+        if (firstNumeratorSign != secondNumeratorSign)
+        {
+            return false; // different signs
+        }
+
+        // both values are non-zero fractions with different denominators
+        if (denominator1 < denominator2)
+        {
+            // reverse the comparison from x == y to y == x
+            Swap(ref numerator1, ref numerator2);
+            Swap(ref denominator1, ref denominator2);
+        }
+
+        // from here [denominator1 > denominator2 > 0] applies
+        if (firstNumeratorSign == 1)
+        {
+            // both fractions are greater than 0 (positive)
+
+            // After the swap, [numerator1 > numerator2 > 0] is expected if both fractions were equal.
+            // example: {10/10} and {1/1} or {10/100} and {1/10}
+            if (numerator1 <= numerator2)
+            {
+                return false;
+            }
+
+            if (numerator2.IsOne)
+            {
+                return denominator2.IsOne
+                    ? numerator1 == denominator1 // if equal, then {n/n} == {1/1}
+                    : numerator1 * denominator2 == denominator1; // if equal, then {a/(a*b)} == {1/b}
+            }
+        }
+        else
+        {
+            // both fractions are less than 0 (negative)
+
+            // After the swap, [numerator1 < numerator2 < 0] is expected if both fractions were equal.
+            // example: {-10/10} and {-1/1} or {-10/100} and {-1/10}
+            if (numerator1 >= numerator2)
+            {
+                return false;
+            }
+
+            if (numerator2 == BigInteger.MinusOne)
+            {
+                return denominator2.IsOne
+                    ? numerator1 == -denominator1 // if equal, then {-a/a} == {-1/1}
+                    : numerator1 * -denominator2 == denominator1; // if equal, then {a/(a*-b)} == {-1/b}
+            }
+        }
+
+        if (denominator2.IsOne)
+        {
+            return numerator1 == numerator2 * denominator1; // if equal, then {(b*a)/a} == {b/1}
+        }
+
+        /*
+         * The following algorithm checks whether both fractions have the same ratio between numerator and denominator.
+         *
+         * Assumed that
+         * x = {n1/d1}
+         * y = {n2/d2}
+         *
+         * If x / y == 1 then x == y.
+         *
+         * This gives us:
+         * {n1/d1} / {n2/d2} == {(n1*d2) / (d1*n2)} == {n1/n2} / {d2/d1}
+         *
+         * If both fractions are equal their ratio is exactly 1:
+         * {n1/n2} / {d2/d1} == 1
+         * And from this it follows:
+         * {n1/n2} == {d1/d2}
+         */
+
+        var numeratorQuotient = BigInteger.DivRem(numerator1, numerator2, out var remainderNumerators);
+        var denominatorQuotient = BigInteger.DivRem(denominator1, denominator2, out var remainderDenominators);
+
+        // If the fractions are equal: numeratorQuotient should be equal to denominatorQuotient.
+        if (numeratorQuotient != denominatorQuotient)
+        {
+            return false;
+        }
+
+        // if the fractions are equal: {remainderNumerators / numerator2} should be equal to {remainderDenominators / denominator2}
+        if (remainderDenominators.IsZero)
+        {
+            return remainderNumerators.IsZero; // if equal, then both values must be 0 
+        }
+
+        if (remainderNumerators.IsZero)
+        {
+            return false; // if equal, then both values must be 0 
+        }
+
+        /*
+         * Since the decimal places disappear when dividing integer data types, the formula must be converted into a multiplication:
+         * {rN / n2} == {rD / d2}
+         * can be written as:
+         * (rN * d2) == (rD * n2)
+         */
+        return remainderNumerators * denominator2 == remainderDenominators * numerator2;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void Swap(ref BigInteger a, ref BigInteger b)
+    {
+        (a, b) = (b, a);
+    }
+
+    /// <summary>
+    ///     Determines whether this QuantityValue instance is equal to another object.
+    /// </summary>
+    /// <param name="obj">The object to compare with this instance.</param>
+    /// <returns>True if the object is a QuantityValue instance and is equal to this instance, false otherwise.</returns>
+    public override bool Equals(object? obj)
+    {
+        return obj is QuantityValue other && Equals(other);
+    }
+
+    /// <summary>
+    ///     Returns the hash code for this QuantityValue instance.
+    /// </summary>
+    /// <returns>The hash code.</returns>
+    public override int GetHashCode()
+    {
+        var fraction = Reduce(this);
+        unchecked {
+            return (fraction.Denominator.GetHashCode() * 397) ^ fraction.Numerator.GetHashCode();
+        }
+    }
+
+    /// <summary>
+    ///     Compares two QuantityValue instances for equality.
+    /// </summary>
+    /// <param name="a">The first QuantityValue.</param>
+    /// <param name="b">The second QuantityValue.</param>
+    /// <returns>True if the two QuantityValue instances are equal, false otherwise.</returns>
+    public static bool operator ==(QuantityValue a, QuantityValue b)
+    {
+        return a.Equals(b) && !IsNaN(a) && !IsNaN(b);
+    }
+
+    /// <summary>
+    ///     Compares two QuantityValue instances for inequality.
+    /// </summary>
+    /// <param name="a">The first QuantityValue.</param>
+    /// <param name="b">The second QuantityValue.</param>
+    /// <returns>True if the two QuantityValue instances are not equal, false otherwise.</returns>
+    public static bool operator !=(QuantityValue a, QuantityValue b)
+    {
+        return !a.Equals(b) || IsNaN(a) || IsNaN(b);
+    }
+}
\ No newline at end of file
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.Fraction.cs b/UnitsNet/CustomCode/Value/QuantityValue.Fraction.cs
new file mode 100644
index 0000000000..d6c9336daa
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.Fraction.cs
@@ -0,0 +1,70 @@
+using System.Numerics;
+
+namespace UnitsNet;
+
+public readonly partial struct QuantityValue
+{
+    /// <summary>
+    ///     Deconstructs the QuantityValue object into its numerator and denominator components.
+    /// </summary>
+    /// <param name="numerator">Output parameter for the numerator component.</param>
+    /// <param name="denominator">Output parameter for the denominator component.</param>
+    public void Deconstruct(out BigInteger numerator, out BigInteger denominator)
+    {
+        numerator = Numerator;
+        denominator = Denominator;
+    }
+
+    /// <summary>
+    ///     Calculates and returns the reciprocal of the specified <see cref="QuantityValue" />.
+    /// </summary>
+    /// <param name="value">A <see cref="QuantityValue" /> whose reciprocal is to be calculated.</param>
+    /// <returns>A new <see cref="QuantityValue" /> that is the reciprocal of the input value.</returns>
+    /// <remarks>
+    ///     In mathematics, a multiplicative inverse or reciprocal for a number x, denoted by 1/x or x^-1, is a
+    ///     number
+    ///     which when multiplied by x yields the multiplicative identity, 1. The multiplicative inverse of a fraction a/b is
+    ///     b/a. For the multiplicative inverse of a real number, divide 1 by the number. For example, the reciprocal of 5 is
+    ///     one fifth (1/5 or 0.2), and the reciprocal of 0.25 is 1 divided by 0.25, or 4.
+    /// </remarks>
+    public static QuantityValue Inverse(QuantityValue value)
+    {
+        return FromTerms(value.Denominator, value.Numerator);
+    }
+
+    /// <summary>
+    ///     Reduces the specified <see cref="QuantityValue" /> to its simplest form.
+    /// </summary>
+    /// <param name="value">The <see cref="QuantityValue" /> to be reduced.</param>
+    /// <returns>A new <see cref="QuantityValue" /> that is the reduced form of the input value.</returns>
+    public static QuantityValue Reduce(QuantityValue value)
+    {
+        var numerator = value.Numerator;
+        var denominator = value.Denominator;
+        if (denominator.IsZero)
+        {
+            return numerator.Sign switch
+            {
+                1 => PositiveInfinity,
+                -1 => NegativeInfinity,
+                _ => NaN
+            };
+        }
+
+        if (numerator.IsZero)
+        {
+            return Zero;
+        }
+
+        if (numerator.IsOne || denominator.IsOne || numerator == BigInteger.MinusOne)
+        {
+            return new QuantityValue(numerator, denominator);
+        }
+
+        var gcd = BigInteger.GreatestCommonDivisor(numerator, denominator);
+
+        return gcd.IsOne
+            ? new QuantityValue(numerator, denominator)
+            : new QuantityValue(numerator / gcd, denominator / gcd);
+    }
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.Number.cs b/UnitsNet/CustomCode/Value/QuantityValue.Number.cs
new file mode 100644
index 0000000000..d78047a0a8
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.Number.cs
@@ -0,0 +1,379 @@
+using System.Numerics;
+
+namespace UnitsNet;
+
+public readonly partial struct QuantityValue
+{
+    /// <summary>
+    ///     Gets the QuantityValue representing the value zero.
+    /// </summary>
+    public static QuantityValue Zero { get; } = new(BigInteger.Zero);
+
+    /// <summary>
+    ///     Gets the QuantityValue representing the number one.
+    /// </summary>
+    public static QuantityValue One { get; } = new(BigInteger.One);
+
+    /// <summary>
+    /// Gets the constant value representing negative one (-1) as a <see cref="QuantityValue"/>.
+    /// </summary>
+    /// <remarks>
+    /// This property is useful for operations requiring a predefined representation of negative one
+    /// in the context of <see cref="QuantityValue"/> arithmetic or comparisons.
+    /// </remarks>
+    public static QuantityValue MinusOne { get; } = new(BigInteger.MinusOne);
+
+    /// <summary>
+    ///     The value representing the positive infinity.
+    /// </summary>
+    public static QuantityValue PositiveInfinity { get; } = new(BigInteger.One, BigInteger.Zero);
+
+    /// <summary>
+    ///     The value representing the negative infinity.
+    /// </summary>
+    public static QuantityValue NegativeInfinity { get; } = new(BigInteger.MinusOne, BigInteger.Zero);
+
+    /// <summary>
+    ///     The value representing the result of dividing zero by zero.
+    /// </summary>
+    public static QuantityValue NaN { get; } = new(BigInteger.Zero, BigInteger.Zero);
+
+    /// <summary>
+    ///     Represents the PI constant as a rational fraction, representing the number 3.141592653589793.
+    /// </summary>
+    /// <remarks>This is equivalent to calling <code>FromDoubleRounded(Math.PI, 16)</code></remarks>
+    public static readonly QuantityValue PI = new(3141592653589793, 1000000000000000);
+
+    internal static readonly BigInteger Ten = new(10); // TODO see about this one
+
+
+#if NET7_0_OR_GREATER
+    static int INumberBase<QuantityValue>.Radix => 10;
+    static QuantityValue ISignedNumber<QuantityValue>.NegativeOne => MinusOne;
+    static QuantityValue IAdditiveIdentity<QuantityValue, QuantityValue>.AdditiveIdentity => Zero;
+    static QuantityValue IMultiplicativeIdentity<QuantityValue, QuantityValue>.MultiplicativeIdentity => One;
+
+    static bool INumberBase<QuantityValue>.IsNormal(QuantityValue value)
+    {
+        return IsFinite(value);
+    }
+
+    static bool INumberBase<QuantityValue>.IsRealNumber(QuantityValue value)
+    {
+        return !IsNaN(value);
+    }
+
+    static bool INumberBase<QuantityValue>.IsComplexNumber(QuantityValue value)
+    {
+        return false;
+    }
+
+    static bool INumberBase<QuantityValue>.IsImaginaryNumber(QuantityValue value)
+    {
+        return false;
+    }
+
+    static bool INumberBase<QuantityValue>.IsSubnormal(QuantityValue value)
+    {
+        return false;
+    }
+
+#endif
+
+    /// <summary>
+    ///     Determines whether the given QuantityValue is in canonical form.
+    /// </summary>
+    /// <param name="value">The QuantityValue to check.</param>
+    /// <returns>True if the QuantityValue is in canonical form, otherwise false.</returns>
+    /// <remarks>
+    ///     A QuantityValue is considered to be in canonical form if its denominator is one,
+    ///     or if its numerator and denominator are coprime numbers (their greatest common divisor is one).
+    /// </remarks>
+    public static bool IsCanonical(QuantityValue value)
+    {
+        var (numerator, denominator) = value;
+        if (denominator.IsOne)
+        {
+            return true;
+        }
+
+        if (numerator.IsZero)
+        {
+            return denominator.IsZero; // if we want to consider NaN as "canonical"
+        }
+
+        if (denominator.IsZero)
+        {
+            return numerator.IsOne || numerator == BigInteger.MinusOne;
+        }
+
+        return BigInteger.GreatestCommonDivisor(numerator, denominator).IsOne;
+    }
+
+    /// <summary>
+    ///     Determines whether the given <see cref="QuantityValue" /> has a finite decimal expansion.
+    /// </summary>
+    /// <param name="value">The <see cref="QuantityValue" /> to evaluate.</param>
+    /// <returns>
+    ///     <c>true</c> if the <paramref name="value" /> has a finite decimal expansion; otherwise, <c>false</c>.
+    /// </returns>
+    /// <remarks>
+    ///     A <see cref="QuantityValue" /> has a finite decimal expansion if its denominator, when reduced to its lowest terms,
+    ///     is composed only of the prime factors 2 and/or 5.
+    /// </remarks>
+    public static bool HasFiniteDecimalExpansion(QuantityValue value)
+    {
+        BigInteger denominator = Reduce(value).Denominator;
+        return HasNonDecimalFactors(denominator);
+    }
+
+    /// <summary>
+    /// Determines whether the given denominator contains factors other than 2 and 5, 
+    /// which are the prime factors of decimal numbers.
+    /// </summary>
+    /// <param name="denominator">The denominator to check for non-decimal factors.</param>
+    /// <returns>
+    /// <see langword="true"/> if the denominator contains only factors of 2 and 5; 
+    /// otherwise, <see langword="false"/>.
+    /// </returns>
+    /// <remarks>
+    /// This method is used to verify if a number has a finite decimal expansion 
+    /// by analyzing its denominator in reduced fractional form.
+    /// </remarks>
+    public static bool HasNonDecimalFactors(BigInteger denominator)
+    {
+        if (denominator.IsOne)
+        {
+            return true;
+        }
+
+        if (denominator.IsZero)
+        {
+            return false;
+        }
+
+        BigInteger divisor = Ten;
+        while (true)
+        {
+            var quotient = BigInteger.DivRem(denominator, divisor, out BigInteger remainder);
+            if (remainder.IsZero)
+            {
+                if (quotient.IsOne)
+                {
+                    return true;
+                }
+
+                denominator = quotient;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        divisor = 5;
+        while (true)
+        {
+            var quotient = BigInteger.DivRem(denominator, divisor, out BigInteger remainder);
+            if (remainder.IsZero)
+            {
+                if (quotient.IsOne)
+                {
+                    return true;
+                }
+
+                denominator = quotient;
+            }
+            else
+            {
+                break;
+            }
+        }
+        
+        divisor = 2;
+        while (true)
+        {
+            var quotient = BigInteger.DivRem(denominator, divisor, out BigInteger remainder);
+            if (remainder.IsZero)
+            {
+                if (quotient.IsOne)
+                {
+                    return true;
+                }
+
+                denominator = quotient;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>Determines if a value represents an even integral number.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is an even integer; otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsEvenInteger(QuantityValue value)
+    {
+        var (numerator, denominator) = value;
+        if (denominator.IsOne)
+        {
+            return numerator.IsEven;
+        }
+
+        if (denominator.IsZero)
+        {
+            return false;
+        }
+
+        // TODO see about first checking the magnitudes
+        var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
+        return remainder.IsZero && quotient.IsEven;
+    }
+
+    /// <summary>Determines if a value is finite.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is finite; otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsFinite(QuantityValue value)
+    {
+        return !value.Denominator.IsZero;
+    }
+
+    /// <summary>Determines if a value is infinite.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is infinite; otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsInfinity(QuantityValue value)
+    {
+        return value.Denominator.IsZero && !value.Numerator.IsZero;
+    }
+
+    /// <summary>Determines if a value represents an integral number.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is an integer; otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsInteger(QuantityValue value)
+    {
+        var denominator = value.Denominator;
+        if (denominator.IsOne)
+        {
+            return true;
+        }
+
+        if (denominator.IsZero)
+        {
+            return false;
+        }
+
+        var numerator = BigInteger.Abs(value.Numerator);
+        if (numerator.IsZero)
+        {
+            return true;
+        }
+
+        return numerator >= denominator && (numerator % denominator).IsZero;
+    }
+
+    /// <summary>Determines if a value is NaN.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is NaN; otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsNaN(QuantityValue value)
+    {
+        return value.Denominator.IsZero && value.Numerator.IsZero;
+    }
+
+    /// <summary>Determines if a value represents a negative real number.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> represents negative zero or a negative real number; otherwise,
+    ///     <see langword="false" />.
+    /// </returns>
+    public static bool IsNegative(QuantityValue value)
+    {
+        return value.Numerator.Sign < 0;
+    }
+
+    /// <summary>Determines if a value is negative infinity.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is negative infinity; otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsNegativeInfinity(QuantityValue value)
+    {
+        return value.Denominator.IsZero && value.Numerator.Sign < 0;
+    }
+
+    /// <summary>Determines if a value represents an odd integral number.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is an odd integer; otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsOddInteger(QuantityValue value)
+    {
+        var (numerator, denominator) = value;
+        if (denominator.IsOne)
+        {
+            return !numerator.IsEven;
+        }
+
+        if (denominator.IsZero)
+        {
+            return false;
+        }
+
+        // TODO see about first checking the magnitudes
+        var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
+        return remainder.IsZero && !quotient.IsEven;
+    }
+
+    /// <summary>Determines if a value represents zero or a positive real number.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> represents (positive) zero or a positive real number;
+    ///     otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsPositive(QuantityValue value)
+    {
+        return value.Numerator.Sign > 0;
+    }
+
+    /// <summary>Determines if a value is positive infinity.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is positive infinity; otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsPositiveInfinity(QuantityValue value)
+    {
+        return value.Denominator.IsZero && value.Numerator.Sign > 0;
+    }
+
+    /// <summary>Determines if a value is zero.</summary>
+    /// <param name="value">The value to be checked.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is zero; otherwise, <see langword="false" />.
+    /// </returns>
+    public static bool IsZero(QuantityValue value)
+    {
+        return value.Numerator.IsZero && !value.Denominator.IsZero;
+    }
+
+    /// <summary>
+    ///     Returns the absolute value of a specified <see cref="QuantityValue" />.
+    /// </summary>
+    /// <param name="value">A <see cref="QuantityValue" />.</param>
+    /// <returns>The absolute value of <paramref name="value" />.</returns>
+    public static QuantityValue Abs(QuantityValue value)
+    {
+        return new QuantityValue(BigInteger.Abs(value.Numerator), value.Denominator);
+    }
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.PowerMath.cs b/UnitsNet/CustomCode/Value/QuantityValue.PowerMath.cs
new file mode 100644
index 0000000000..a8ed0248ed
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.PowerMath.cs
@@ -0,0 +1,409 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace UnitsNet;
+
+public readonly partial struct QuantityValue
+{
+    internal static readonly BigInteger[] PowersOfTen = [
+        BigInteger.One, // 10^0 = 1
+        new(10), // 10^1 = 10
+        new(100), // 10^2 = 100
+        new(1000), // 10^3 = 1,000
+        new(10000), // 10^4 = 10,000
+        new(100000), // 10^5 = 100,000
+        new(1000000), // 10^6 = 1,000,000
+        new(10000000), // 10^7 = 10,000,000
+        new(100000000), // 10^8 = 100,000,000
+        new(1000000000), // 10^9 = 1,000,000,000
+        new(10000000000), // 10^10 = 10,000,000,000
+        new(100000000000), // 10^11 = 100,000,000,000
+        new(1000000000000), // 10^12 = 1,000,000,000,000
+        new(10000000000000), // 10^13 = 10,000,000,000,000
+        new(100000000000000), // 10^14 = 100,000,000,000,000
+        new(1000000000000000), // 10^15 = 1,000,000,000,000,000
+        new(10000000000000000), // 10^16 = 10,000,000,000,000,000
+        new(100000000000000000), // 10^17 = 100,000,000,000,000,000
+        new(1000000000000000000) // 10^18 = 1,000,000,000,000,000,000
+    ];
+
+    /// <summary>
+    ///     Computes the power of ten for a given exponent.
+    /// </summary>
+    /// <param name="exponent">The exponent to which ten is raised.</param>
+    /// <returns>
+    ///     A <see cref="BigInteger" /> representing 10 raised to the power of <paramref name="exponent" />.
+    /// </returns>
+    /// <remarks>
+    ///     If the <paramref name="exponent" /> is within the precomputed range, the result is retrieved from a cached array
+    ///     for better performance. Otherwise, <see cref="BigInteger.Pow(BigInteger, int)" /> is used to calculate the result.
+    /// </remarks>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal static BigInteger PowerOfTen(int exponent)
+    {
+        if (exponent < PowersOfTen.Length)
+        {
+            return PowersOfTen[exponent];
+        }
+
+        var maxExponent = PowersOfTen.Length - 1;
+        if (exponent > 3 * maxExponent)
+        {
+            return BigInteger.Pow(Ten, exponent); // the exponent is > 54
+        }
+
+        var maxPowerOfTen = PowersOfTen[maxExponent];
+        var result = maxPowerOfTen;
+        exponent -= maxExponent; // the exponent no more than 2 * maxExponent (36)
+        if (exponent > maxExponent)
+        {
+            result *= maxPowerOfTen;
+            exponent -= maxExponent; // the exponent is no more than maxExponent (18)
+        }
+
+        if (exponent == maxExponent)
+        {
+            return result * maxPowerOfTen;
+        }
+
+        return result * PowersOfTen[exponent];
+    }
+    
+    /// <summary>
+    ///     Raises a QuantityValue to the specified power.
+    /// </summary>
+    /// <param name="x">The QuantityValue to raise to the power.</param>
+    /// <param name="power">The power to raise the QuantityValue to.</param>
+    /// <returns>The QuantityValue raised to the specified power.</returns>
+    public static QuantityValue Pow(QuantityValue x, int power)
+    {
+        BigInteger numerator, denominator;
+        switch (power)
+        {
+            case > 0:
+                (numerator, denominator) = x;
+                break;
+            case < 0 when IsZero(x):
+                return PositiveInfinity;
+            case < 0:
+                power = -power;
+                (numerator, denominator) = Inverse(x);
+                break;
+            default:
+                // x^0 == 1
+                return One;
+        }
+
+        return new QuantityValue(
+            BigInteger.Pow(numerator, power),
+            BigInteger.Pow(denominator, power));
+    }
+
+    /// <summary>
+    ///     Calculates the square root of a given QuantityValue.
+    /// </summary>
+    /// <param name="x">The QuantityValue for which to calculate the square root.</param>
+    /// <param name="accuracy">The number of significant digits of accuracy for the square root calculation. Default is 30.</param>
+    /// <returns>A new QuantityValue that is the square root of the input QuantityValue.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when the accuracy is less than or equal to zero.</exception>
+    /// <remarks>
+    ///     The implementation is based on the work by
+    ///     <see href="https://github.com/SunsetQuest/NewtonPlus-Fast-BigInteger-and-BigFloat-Square-Root">SunsetQuest</see>.
+    ///     <para>
+    ///         It uses the Babylonian method of computing square roots, making sure that the relative difference with the true
+    ///         value is smaller than 1/10^accuracy.
+    ///     </para>
+    ///     <para>
+    ///         Note: the resulting value is not rounded and may contain additional digits (up to 20%), which have a relatively
+    ///         high likelihood of being correct, however no strong guarantees can be made.
+    ///     </para>
+    /// </remarks>
+    public static QuantityValue Sqrt(QuantityValue x, int accuracy = 30)
+    {
+        if (accuracy <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(accuracy), "The accuracy must be a positive integer.");
+        }
+
+        if (IsNaN(x) || IsNegative(x))
+        {
+            return NaN;
+        }
+
+        if (x.Numerator.IsZero || x.Denominator.IsZero) // IsZero || IsInfinity)
+        {
+            return x;
+        }
+
+        if (x.Numerator == x.Denominator)
+        {
+            return One;
+        }
+
+        // BigInteger square root implementation based on https://github.com/SunsetQuest/NewtonPlus-Fast-BigInteger-and-BigFloat-Square-Root
+        return GetSqrtWithPrecision(Reduce(x), accuracy * 4);
+
+        static QuantityValue GetSqrtWithPrecision(QuantityValue fraction, int precisionBits)
+        {
+            // BigFloatingPoint square root implementation based on https://github.com/SunsetQuest/NewtonPlus-Fast-BigInteger-and-BigFloat-Square-Root/blob/master/BigFloatingPointSquareRoot.cs
+            var (numerator, numeratorShift) = SqrtWithShift(fraction.Numerator, precisionBits);
+            var (denominator, denominatorShift) = SqrtWithShift(fraction.Denominator, precisionBits);
+            var shift = numeratorShift - denominatorShift;
+            switch (shift)
+            {
+                case < 0:
+                    denominator >>= shift;
+                    break;
+                case > 0:
+                    numerator >>= -shift;
+                    break;
+            }
+
+            return new QuantityValue(numerator, denominator);
+        }
+
+        static (BigInteger val, int shift) SqrtWithShift(BigInteger x, int precisionBits)
+        {
+            if (x.IsOne)
+            {
+                return (x, 0);
+            }
+
+            if (x < 144838757784765629) // 1.448e17 = ~1<<57
+            {
+                var longX = (ulong)x;
+                var vInt = (uint)Math.Sqrt(longX);
+                if (vInt * vInt == longX)
+                {
+                    return (vInt, 0);
+                }
+            }
+#if NET
+            var totalLen = (int)x.GetBitLength();
+#else
+            var totalLen = (int)BigInteger.Log(x, 2);
+#endif
+
+            var needToShiftInputBy = 2 * precisionBits - totalLen - (totalLen & 1);
+            var val = SqrtBigInt(x << needToShiftInputBy);
+            var retShift = (totalLen + (totalLen > 0 ? 1 : 0)) / 2 - precisionBits;
+            return (val, retShift);
+        }
+
+        static BigInteger SqrtBigInt(BigInteger x)
+        {
+            // BigInteger square root implementation based on https://github.com/SunsetQuest/NewtonPlus-Fast-BigInteger-and-BigFloat-Square-Root/blob/master/BigIntegerSquareRoot.cs
+            if (x < 144838757784765629) // 1.448e17 = ~1<<57
+            {
+                var vInt = (uint)Math.Sqrt((ulong)x);
+                return vInt;
+            }
+
+            var xAsDub = (double)x;
+            if (xAsDub < 8.5e37) //   8.5e37 is V<sup>2</sup>long.max * long.max
+            {
+                var vInt = (ulong)Math.Sqrt(xAsDub);
+                BigInteger v = (vInt + (ulong)(x / vInt)) >> 1;
+                return v;
+            }
+
+            if (xAsDub < 4.3322e127)
+            {
+                var v = (BigInteger)Math.Sqrt(xAsDub);
+                v = (v + x / v) >> 1;
+                if (xAsDub > 2e63)
+                {
+                    v = (v + x / v) >> 1;
+                }
+
+                return v;
+            }
+
+#if NET
+            var xLen = (int)x.GetBitLength();
+#else
+            var xLen = (int)BigInteger.Log(x, 2) + 1;
+#endif
+            var wantedPrecision = (xLen + 1) / 2;
+            var xLenMod = xLen + (xLen & 1) + 1;
+
+            //////// Do the first Sqrt on hardware ////////
+            var tempX = (long)(x >> (xLenMod - 63));
+            var tempSqrt1 = Math.Sqrt(tempX);
+            var valLong = (ulong)BitConverter.DoubleToInt64Bits(tempSqrt1) & 0x1fffffffffffffL;
+            if (valLong == 0)
+            {
+                valLong = 1UL << 53;
+            }
+
+            ////////  Classic Newton Iterations ////////
+            var val = ((BigInteger)valLong << 52) + (x >> (xLenMod - 3 * 53)) / valLong;
+
+            val = (val << (106 - 1)) + (x >> (xLenMod - 3 * 106)) / val;
+            val = (val << (212 - 1)) + (x >> (xLenMod - 3 * 212)) / val;
+            var size = 424;
+            
+            if (xAsDub > 4e254) // 1 << 845
+            {
+#if NET
+                var numOfNewtonSteps = BitOperations.Log2((uint)(wantedPrecision / size)) + 2;
+#else
+                var numOfNewtonSteps = (int)Math.Log((uint)(wantedPrecision / size), 2) + 2;
+#endif
+
+                //////  Apply Starting Size  ////////
+                var startingSize = (wantedPrecision >> numOfNewtonSteps) + 2;
+                var needToShiftBy = size - startingSize;
+                val >>= needToShiftBy;
+                size = startingSize;
+                do {
+                    ////////  Newton Plus Iterations  ////////
+                    var shiftX = xLenMod - 3 * size;
+                    var valSqrd = (val * val) << (size - 1);
+                    var valSU = (x >> shiftX) - valSqrd;
+                    val = (val << size) + valSU / val;
+                    size <<= 1;
+                } while (size < wantedPrecision);
+            }
+            
+            ////////  Shrink result to wanted Precision  ////////
+            val >>= size - wantedPrecision;
+            
+            return val;
+        }
+    }
+
+    /// <summary>
+    ///     Raises a <see cref="QuantityValue" /> to the power of another <see cref="QuantityValue" /> with a specified
+    ///     accuracy.
+    /// </summary>
+    /// <param name="number">The base <see cref="QuantityValue" /> to be raised to a power.</param>
+    /// <param name="power">The exponent <see cref="QuantityValue" />.</param>
+    /// <param name="accuracy">The number of decimal places of accuracy for the square root calculation. Default is 30.</param>
+    /// <returns>
+    ///     A new <see cref="QuantityValue" /> representing the result of raising <paramref name="number" /> to the power
+    ///     of <paramref name="power" />.
+    /// </returns>
+    /// <remarks>
+    ///     Uses Babylonian Method of computing square roots: increasing the accuracy would result in longer calculation
+    ///     times.
+    /// </remarks>
+    internal static QuantityValue Pow(QuantityValue number, QuantityValue power, int accuracy = 30)
+    {
+        if (power == One)
+        {
+            return number;
+        }
+
+        if (number == One)
+        {
+            return number;
+        }
+
+        power = Reduce(power);
+        var denominator = power.Denominator;
+        if (denominator.IsOne)
+        {
+            return Round(Pow(number, (int)power), accuracy);
+        }
+
+        var numeratorRaised = Pow(number, (int)power.Numerator);
+        return RootN(numeratorRaised, (int)denominator, accuracy);
+    }
+
+    /// <summary>
+    ///     Calculates the n-th root of a given <see cref="QuantityValue" /> with a specified accuracy.
+    /// </summary>
+    /// <param name="number">The <see cref="QuantityValue" /> for which to calculate the root.</param>
+    /// <param name="n">The degree of the root.</param>
+    /// <param name="accuracy">The number of decimal places of accuracy for the square root calculation. Default is 15.</param>
+    /// <returns>The n-th root of the given <see cref="QuantityValue" />.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="accuracy" /> is less than or equal to zero.</exception>
+    internal static QuantityValue RootN(QuantityValue number, int n, int accuracy = 15)
+    {
+        if (accuracy <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(accuracy), accuracy, "The accuracy must be positive");
+        }
+
+        if (n == 0)
+        {
+            return NaN;
+        }
+
+        if (n == 1)
+        {
+            return Round(number, accuracy);
+        }
+
+        if (number == One || IsNaN(number))
+        {
+            return number;
+        }
+
+        if (IsZero(number))
+        {
+            return n < 0 ? PositiveInfinity : number;
+        }
+
+        if (IsPositiveInfinity(number))
+        {
+            return n < 0 ? Zero : PositiveInfinity;
+        }
+
+        if (IsNegativeInfinity(number))
+        {
+            if ((n & 1) == 0) // is even integer
+            {
+                return NaN;
+            }
+
+            return n < 0 ? Zero : number;
+        }
+
+        if (n > 0)
+        {
+            if (IsPositive(number))
+            {
+                return Root(number, n, accuracy);
+            }
+
+            if ((n & 1) == 0) // is even integer
+            {
+                return NaN;
+            }
+
+            return -Root(-number, n, accuracy);
+        }
+
+        // n < 0
+        if (IsPositive(number))
+        {
+            return Root(Inverse(number), -n, accuracy);
+        }
+
+        if ((n & 1) == 0) // is even integer
+        {
+            return NaN;
+        }
+
+        return -Root(-Inverse(number), -n, accuracy);
+
+        static QuantityValue Root(QuantityValue number, int n, int accuracy)
+        {
+            var precision = PowerOfTen(accuracy);
+            // Initial guess
+            var x = FromDoubleRounded(Math.Pow(number.ToDouble(), 1.0 / n), (byte)Math.Min(accuracy, 17));
+            QuantityValue xPrev;
+            var minChange = new QuantityValue(1, precision);
+            do
+            {
+                xPrev = x;
+                x = ((n - 1) * x + number / Pow(x, n - 1)) / n;
+            } while (Abs(x - xPrev) > minChange);
+
+            return Round(x, accuracy);
+        }
+    }
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.Rounding.cs b/UnitsNet/CustomCode/Value/QuantityValue.Rounding.cs
new file mode 100644
index 0000000000..8b8ee880cd
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.Rounding.cs
@@ -0,0 +1,158 @@
+using System.Numerics;
+
+namespace UnitsNet;
+
+public readonly partial struct QuantityValue
+{
+    /// <summary>
+    ///     Rounds the given QuantityValue to the specified number of digits.
+    /// </summary>
+    /// <param name="x">The QuantityValue to be rounded.</param>
+    /// <param name="nbDigits">The number of decimal places in the return value.</param>
+    /// <returns>A new QuantityValue that is the nearest number with the specified number of digits.</returns>
+    public static QuantityValue Round(QuantityValue x, int nbDigits)
+    {
+        return Round(x, nbDigits, MidpointRounding.ToEven);
+    }
+
+    /// <summary>
+    ///     Rounds the given QuantityValue to the specified precision using the specified rounding strategy.
+    /// </summary>
+    /// <param name="x">The QuantityValue to be rounded.</param>
+    /// <param name="decimals">The number of significant decimal places (precision) in the return value.</param>
+    /// <param name="mode">Specifies the strategy that mathematical rounding methods should use to round a number.</param>
+    /// <returns>
+    ///     The number that <paramref name="x" /> is rounded to using the <paramref name="mode" /> rounding strategy and
+    ///     with a precision of <paramref name="decimals" />. If the precision of <paramref name="x" /> is less than
+    ///     <paramref name="decimals" />, <paramref name="x" /> is returned unchanged.
+    /// </returns>
+    /// <exception cref="ArgumentOutOfRangeException">If <paramref name="decimals" /> is less than 0</exception>
+    public static QuantityValue Round(QuantityValue x, int decimals, MidpointRounding mode)
+    {
+#if NET
+        ArgumentOutOfRangeException.ThrowIfNegative(decimals);
+#else
+        if (decimals < 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(decimals));
+        }
+#endif
+        return Round(x.Numerator, x.Denominator, decimals, mode);
+    }
+
+    internal static QuantityValue Round(BigInteger numerator, BigInteger denominator, int decimals, MidpointRounding mode)
+    {
+        if (numerator.IsZero)
+        {
+            return new QuantityValue(numerator, denominator);
+        }
+
+        if (denominator.IsOne || denominator.IsZero)
+        {
+            return new QuantityValue(numerator, denominator);
+        }
+
+        var factor = PowerOfTen(decimals);
+        var roundedNumerator = RoundToBigInteger(numerator * factor, denominator, mode);
+        return new QuantityValue(roundedNumerator, factor);
+    }
+
+    /// <summary>
+    ///     Rounds the given QuantityValue to the specified precision using the specified rounding strategy.
+    /// </summary>
+    /// <param name="fraction">The QuantityValue to be rounded.</param>
+    /// <param name="mode">Specifies the strategy that mathematical rounding methods should use to round a number.</param>
+    /// <returns>
+    ///     The number as <see cref="BigInteger" /> that <paramref name="fraction" /> is rounded to using the
+    ///     <paramref name="mode" /> rounding strategy.
+    /// </returns>
+    /// <exception cref="OverflowException">Thrown when the input is <see cref="NaN"/>, <see cref="PositiveInfinity"/> or <see cref="NegativeInfinity"/>.</exception>
+    public static BigInteger Round(QuantityValue fraction, MidpointRounding mode)
+    {
+        return RoundToBigInteger(fraction.Numerator, fraction.Denominator, mode);
+    }
+
+    /// <summary>
+    ///     Rounds the given QuantityValue to the specified precision using the specified rounding strategy.
+    /// </summary>
+    /// <param name="numerator">The numerator of the fraction to be rounded.</param>
+    /// <param name="denominator">The denominator of the fraction to be rounded.</param>
+    /// <param name="mode">Specifies the strategy that mathematical rounding methods should use to round a number.</param>
+    /// <returns>The number rounded to using the <paramref name="mode" /> rounding strategy.</returns>
+    /// <exception cref="OverflowException">Thrown when given Zero for the denominator.</exception>
+    private static BigInteger RoundToBigInteger(BigInteger numerator, BigInteger denominator, MidpointRounding mode)
+    {
+        if (denominator.IsZero)
+        {
+            throw new OverflowException();
+        }
+
+        if (numerator.IsZero || denominator.IsOne)
+        {
+            return numerator;
+        }
+
+        return mode switch
+        {
+            MidpointRounding.AwayFromZero => RoundAwayFromZero(numerator, denominator),
+            MidpointRounding.ToEven => RoundToEven(numerator, denominator),
+#if NET
+            MidpointRounding.ToZero => BigInteger.Divide(numerator, denominator),
+            MidpointRounding.ToPositiveInfinity => RoundToPositiveInfinity(numerator, denominator),
+            MidpointRounding.ToNegativeInfinity => RoundToNegativeInfinity(numerator, denominator),
+#endif
+            _ => throw new ArgumentOutOfRangeException(nameof(mode))
+        };
+
+        static BigInteger RoundAwayFromZero(BigInteger numerator, BigInteger denominator)
+        {
+            var halfDenominator = denominator >> 1;
+            return numerator.Sign == 1
+                ? BigInteger.Divide(numerator + halfDenominator, denominator)
+                : BigInteger.Divide(numerator - halfDenominator, denominator);
+        }
+
+        static BigInteger RoundToEven(BigInteger numerator, BigInteger denominator)
+        {
+            var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
+            if (remainder.IsZero)
+            {
+                return quotient;
+            }
+
+            if (numerator.Sign == 1)
+            {
+                // Both values are positive
+                var midpoint = remainder << 1;
+                if (midpoint > denominator || (midpoint == denominator && !quotient.IsEven))
+                {
+                    return quotient + BigInteger.One;
+                }
+            }
+            else
+            {
+                // For negative values
+                var midpoint = -remainder << 1;
+                if (midpoint > denominator || (midpoint == denominator && !quotient.IsEven))
+                {
+                    return quotient - BigInteger.One;
+                }
+            }
+
+            return quotient;
+        }
+#if NET
+        static BigInteger RoundToPositiveInfinity(BigInteger numerator, BigInteger denominator)
+        {
+            var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
+            return remainder.Sign == 1 ? quotient + BigInteger.One : quotient;
+        }
+
+        static BigInteger RoundToNegativeInfinity(BigInteger numerator, BigInteger denominator)
+        {
+            var quotient = BigInteger.DivRem(numerator, denominator, out var remainder);
+            return remainder.Sign == -1 ? quotient - BigInteger.One : quotient;
+        }
+#endif
+    }
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValue.cs b/UnitsNet/CustomCode/Value/QuantityValue.cs
new file mode 100644
index 0000000000..500a4a0980
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValue.cs
@@ -0,0 +1,201 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Numerics;
+using System.Runtime.Serialization;
+#if NET
+using System.Buffers.Binary;
+#endif
+
+namespace UnitsNet;
+
+/// <summary>
+///     Represents a numeric value used in the UnitsNet library to provide precise representation of numbers
+///     with unbounded scale and precision, unlike standard numeric types such as <see cref="double" /> or
+///     <see cref="decimal" />.
+/// </summary>
+/// <remarks>
+///     This implementation is derived from the Fractions library: <see href="https://github.com/danm-de/Fractions" />.
+///     Internally, it uses a fraction represented by two <see cref="System.Numerics.BigInteger" /> values
+///     (numerator and denominator) to ensure arbitrary precision without loss of accuracy.
+/// </remarks>
+/// <example>
+///     The <see cref="QuantityValue" /> struct can be used to represent precise numeric values for unit conversions
+///     and calculations in the UnitsNet library.
+/// </example>
+[DataContract]
+[Serializable]
+[TypeConverter(typeof(QuantityValueTypeConverter))]
+[DebuggerDisplay("{ToString(System.Globalization.CultureInfo.CurrentCulture), nq}")]
+[DebuggerTypeProxy(typeof(QuantityValueDebugView))]
+public readonly partial struct QuantityValue :
+#if NET7_0_OR_GREATER
+    INumber<QuantityValue>, ISignedNumber<QuantityValue>, IConvertible
+#else
+    IFormattable, IConvertible, IEquatable<QuantityValue>, IComparable<QuantityValue>, IComparable
+#endif
+{
+    
+    [DataMember(Name = "N", Order = 1)]
+    private readonly BigInteger _numerator;
+    
+    [DataMember(Name = "D", Order = 2)]
+    private readonly BigInteger? _denominator;
+
+    /// <summary>
+    ///     Gets the numerator of the fraction representing the <see cref="QuantityValue" />.
+    /// </summary>
+    /// <remarks>
+    ///     The numerator is a <see cref="System.Numerics.BigInteger" /> that, together with the denominator,
+    ///     defines the value of the fraction stored in this <see cref="QuantityValue" />.
+    /// </remarks>
+    internal BigInteger Numerator => _numerator;
+
+    /// <summary>
+    ///     Gets the denominator of the fraction representing the value of this <see cref="QuantityValue" />.
+    /// </summary>
+    /// <remarks>
+    ///     The denominator is part of the internal fractional representation of the value, which ensures
+    ///     high precision and supports arbitrary values without loss of accuracy.
+    /// </remarks>
+    internal BigInteger Denominator => _denominator.GetValueOrDefault(BigInteger.One);
+
+
+    /// <summary>
+    ///     Construct using a value <paramref name="numerator" /> and <paramref name="denominator" />.
+    /// </summary>
+    /// <param name="numerator">Numerator</param>
+    /// <param name="denominator">Denominator</param>
+    internal QuantityValue(BigInteger numerator, BigInteger denominator)
+    {
+        _numerator = numerator;
+        _denominator = denominator;
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValue"/> struct with the specified numerator, denominator, 
+    ///     and a power of ten exponent.
+    /// </summary>
+    /// <param name="numerator">The numerator of the fraction representing the value.</param>
+    /// <param name="denominator">The denominator of the fraction representing the value.</param>
+    /// <param name="powerOfTen">
+    ///     The power of ten to adjust the value. A positive exponent multiplies the numerator by 10 raised to the power, 
+    ///     while a negative exponent multiplies the denominator by 10 raised to the absolute value of the power.
+    /// </param>
+    /// <remarks>
+    ///     This constructor enables precise representation of values using a fraction and a power of ten, 
+    ///     corresponding to the scientific notation: (numerator/denominator) * 10 ^ powerOfTen.
+    /// </remarks>
+    internal QuantityValue(BigInteger numerator, BigInteger denominator, int powerOfTen)
+    {
+        if (powerOfTen > 0)
+        {
+            _numerator = numerator * PowerOfTen(powerOfTen);
+            _denominator = denominator;
+        }
+        else
+        {
+            _numerator = numerator;
+            _denominator = denominator * PowerOfTen(-powerOfTen);
+        }
+    }
+
+    /// <summary>
+    ///     Creates a normalized fraction using a signed 32bit integer.
+    /// </summary>
+    /// <param name="value">integer value that will be used for the numerator. The denominator will be 1.</param>
+    public QuantityValue(int value)
+    {
+        _numerator = new BigInteger(value);
+        _denominator = BigInteger.One;
+    }
+
+    /// <summary>
+    ///     Creates a normalized fraction using a signed 64bit integer.
+    /// </summary>
+    /// <param name="value">integer value that will be used for the numerator. The denominator will be 1.</param>
+    public QuantityValue(long value)
+    {
+        _numerator = new BigInteger(value);
+        _denominator = BigInteger.One;
+    }
+
+    /// <summary>
+    ///     Creates a normalized fraction using a unsigned 32bit integer.
+    /// </summary>
+    /// <param name="value">integer value that will be used for the numerator. The denominator will be 1.</param>
+    [CLSCompliant(false)]
+    public QuantityValue(uint value)
+    {
+        _numerator = new BigInteger(value);
+        _denominator = BigInteger.One;
+    }
+
+    /// <summary>
+    ///     Creates a normalized fraction using a unsigned 64bit integer.
+    /// </summary>
+    /// <param name="value">integer value that will be used for the numerator. The denominator will be 1.</param>
+    [CLSCompliant(false)]
+    public QuantityValue(ulong value)
+    {
+        _numerator = new BigInteger(value);
+        _denominator = BigInteger.One;
+    }
+
+    /// <summary>
+    ///     Creates a normalized fraction using a big integer.
+    /// </summary>
+    /// <param name="value">big integer value that will be used for the numerator. The denominator will be 1.</param>
+    public QuantityValue(BigInteger value)
+    {
+        _numerator = value;
+        _denominator = BigInteger.One;
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="QuantityValue" /> struct using a <see cref="decimal" /> value.
+    /// </summary>
+    /// <param name="value">The decimal value to initialize the <see cref="QuantityValue" /> with.</param>
+    /// <remarks>
+    ///     This constructor converts the provided <paramref name="value" /> into a fraction represented by a numerator
+    ///     and a denominator using <see cref="BigInteger" /> for precise representation without loss of precision.
+    /// </remarks>
+    public QuantityValue(decimal value)
+    {
+#if NET
+        Span<int> bits = stackalloc int[4];
+        decimal.GetBits(value, bits);
+        Span<byte> buffer = stackalloc byte[16];
+        // Assume BitConverter.IsLittleEndian = true
+        BinaryPrimitives.WriteInt32LittleEndian(buffer[..4], bits[0]);
+        BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(4, 4), bits[1]);
+        BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(8, 4), bits[2]);
+        BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(12, 4), bits[3]);
+        var exp = buffer[14];
+        var positiveSign = (buffer[15] & 0x80) == 0;
+        // Pass false to the isBigEndian parameter
+        var numerator = new BigInteger(buffer[..13]);
+#else
+        var bits = decimal.GetBits(value);
+        var low = BitConverter.GetBytes(bits[0]);
+        var middle = BitConverter.GetBytes(bits[1]);
+        var high = BitConverter.GetBytes(bits[2]);
+        var scale = BitConverter.GetBytes(bits[3]);
+
+        var exp = scale[2];
+        var positiveSign = (scale[3] & 0x80) == 0;
+
+        // value = 0x00,high,middle,low / 10^exp
+        var numerator = new BigInteger([
+            low[0], low[1], low[2], low[3],
+            middle[0], middle[1], middle[2], middle[3],
+            high[0], high[1], high[2], high[3],
+            0x00
+        ]);
+#endif
+        _numerator = positiveSign ? numerator : -numerator;
+        _denominator = PowerOfTen(exp);
+    }
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValueExtensions.cs b/UnitsNet/CustomCode/Value/QuantityValueExtensions.cs
new file mode 100644
index 0000000000..4c4caf1da7
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValueExtensions.cs
@@ -0,0 +1,139 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Provides extension methods for performing operations on <see cref="QuantityValue" /> instances.
+/// </summary>
+public static class QuantityValueExtensions
+{
+    /// <summary>
+    ///     Sums a collection of <see cref="QuantityValue" /> instances.
+    /// </summary>
+    /// <param name="values">The collection of <see cref="QuantityValue" /> instances to sum.</param>
+    /// <returns>The sum of the <see cref="QuantityValue" /> instances.</returns>
+    public static QuantityValue Sum(this IEnumerable<QuantityValue> values)
+    {
+        return values.Aggregate(QuantityValue.Zero, (total, value) => total + value);
+    }
+
+    /// <summary>
+    ///     Calculates the average of a collection of <see cref="QuantityValue" /> instances.
+    /// </summary>
+    /// <param name="values">The collection of <see cref="QuantityValue" /> instances to average.</param>
+    /// <returns>The average of the <see cref="QuantityValue" /> instances.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the sequence contains no elements.</exception>
+    public static QuantityValue Average(this IEnumerable<QuantityValue> values)
+    {
+        using IEnumerator<QuantityValue> e = values.GetEnumerator();
+        if (!e.MoveNext())
+        {
+            throw new InvalidOperationException("Sequence contains no elements");
+            // throw ExceptionHelper.CreateInvalidOperationOnEmptyCollectionException();
+        }
+
+        QuantityValue sum = e.Current;
+        if (!e.MoveNext())
+        {
+            return sum;
+        }
+
+        long count = 1;
+        do
+        {
+            sum += e.Current;
+            count++;
+        } while (e.MoveNext());
+
+        return sum / count;
+    }
+
+    /// <summary>
+    ///     Converts a logarithmic value to its linear space equivalent.
+    /// </summary>
+    /// <param name="logValue">The logarithmic value to be converted.</param>
+    /// <param name="scalingFactor">The scaling factor used in the conversion. Default is 10.</param>
+    /// <returns>The linear space equivalent of the logarithmic value.</returns>
+    /// <remarks>
+    ///     Most logarithmic operators need a simple scaling factor of 10. However, certain units such as the power ratio
+    ///     need to use 20 instead.
+    /// </remarks>
+    internal static double ToLinearSpace(this QuantityValue logValue, QuantityValue scalingFactor)
+    {
+        return Math.Pow(10, (logValue / scalingFactor).ToDouble());
+    }
+    
+    internal static QuantityValue ToLinearSpace(this QuantityValue logValue, QuantityValue scalingFactor, byte significantDigits)
+    {
+        return QuantityValue.FromDoubleRounded(logValue.ToLinearSpace(scalingFactor), significantDigits);
+    }
+
+    /// <summary>
+    ///     Converts a linear value to its logarithmic space equivalent.
+    /// </summary>
+    /// <param name="value">The linear value to convert.</param>
+    /// <param name="scalingFactor">The scaling factor to apply. Default is 10.</param>
+    /// <param name="significantDigits">The number of significant digits to retain in the result. Default is 15.</param>
+    /// <returns>The logarithmic space equivalent of the input value.</returns>
+    /// <remarks>
+    ///     Most logarithmic operators need a simple scaling factor of 10. However, certain units such as the power ratio
+    ///     need to use 20 instead.
+    /// </remarks>
+    internal static QuantityValue ToLogSpace(this double value, QuantityValue scalingFactor, byte significantDigits = 15)
+    {
+        return scalingFactor * QuantityValue.FromDoubleRounded(Math.Log10(value), significantDigits);
+    }
+
+    /// <inheritdoc cref="ToLogSpace(double,UnitsNet.QuantityValue,byte)"/>
+    internal static QuantityValue ToLogSpace(this QuantityValue value, QuantityValue scalingFactor, byte significantDigits = 15)
+    {
+        return value.ToDouble().ToLogSpace(scalingFactor, significantDigits);
+    }
+
+    /// <summary>
+    ///     Adds two <see cref="QuantityValue" /> instances using logarithmic scaling.
+    /// </summary>
+    /// <param name="leftValue">The first <see cref="QuantityValue" /> to add.</param>
+    /// <param name="rightValue">The second <see cref="QuantityValue" /> to add.</param>
+    /// <param name="scalingFactor">The scaling factor to use for the logarithmic scaling. Default is 10.</param>
+    /// <param name="significantDigits">The number of significant digits to use for the result. Default is 15.</param>
+    /// <returns>The sum of the two <see cref="QuantityValue" /> instances, scaled logarithmically.</returns>
+    /// <remarks>
+    ///     Formula: scalingFactor * log10(10^(thisValue/scalingFactor) + 10^(otherValue/scalingFactor))
+    ///     <para>
+    ///         Most logarithmic operators need a simple scaling factor of 10. However, certain units such as the power ratio
+    ///         need to use 20 instead.
+    ///     </para>
+    /// </remarks>
+    internal static QuantityValue AddWithLogScaling(QuantityValue leftValue, QuantityValue rightValue, QuantityValue scalingFactor, byte significantDigits = 15)
+    {
+        return (leftValue.ToLinearSpace(scalingFactor) + rightValue.ToLinearSpace(scalingFactor))
+            .ToLogSpace(scalingFactor, significantDigits);
+    }
+
+    /// <summary>
+    ///     Subtract two <see cref="QuantityValue" /> instances using logarithmic scaling.
+    /// </summary>
+    /// <param name="leftValue">The <see cref="QuantityValue" /> to subtract from.</param>
+    /// <param name="rightValue">The <see cref="QuantityValue" /> to subtract.</param>
+    /// <param name="scalingFactor">The scaling factor to use for the logarithmic scaling. Default is 10.</param>
+    /// <param name="significantDigits">The number of significant digits to use for the result. Default is 15.</param>
+    /// <returns>The sum of the two <see cref="QuantityValue" /> instances, scaled logarithmically.</returns>
+    /// <remarks>
+    ///     Formula: scalingFactor * log10(10^(thisValue/scalingFactor) - 10^(otherValue/scalingFactor))
+    ///     <para>
+    ///         Most logarithmic operators need a simple scaling factor of 10. However, certain units such as the power ratio
+    ///         need to use 20 instead.
+    ///     </para>
+    /// </remarks>
+    internal static QuantityValue SubtractWithLogScaling(QuantityValue leftValue, QuantityValue rightValue, QuantityValue scalingFactor, byte significantDigits = 15)
+    {
+        return (leftValue.ToLinearSpace(scalingFactor) - rightValue.ToLinearSpace(scalingFactor))
+            .ToLogSpace(scalingFactor, significantDigits);
+    }
+}
diff --git a/UnitsNet/CustomCode/Value/QuantityValueTypeConverter.cs b/UnitsNet/CustomCode/Value/QuantityValueTypeConverter.cs
new file mode 100644
index 0000000000..98039faea3
--- /dev/null
+++ b/UnitsNet/CustomCode/Value/QuantityValueTypeConverter.cs
@@ -0,0 +1,95 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.ComponentModel;
+using System.Globalization;
+using System.Numerics;
+
+namespace UnitsNet;
+
+/// <summary>
+///     Provides a type converter to convert object data types to and from various other data types for QuantityValue.
+/// </summary>
+/// <remarks>
+///     This class inherits from the <see cref="TypeConverter" /> class and provides methods to
+///     convert
+///     objects of one type to another type within the context of QuantityValue. It is used for type conversions required
+///     for
+///     property values, data binding, and other services.
+/// </remarks>
+public class QuantityValueTypeConverter : TypeConverter
+{
+    /// <inheritdoc />
+    public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destinationType)
+    {
+        return destinationType switch
+        {
+            _ when destinationType == typeof(string) => true,
+            _ when destinationType == typeof(int) => true,
+            _ when destinationType == typeof(long) => true,
+            _ when destinationType == typeof(decimal) => true,
+            _ when destinationType == typeof(double) => true,
+            _ when destinationType == typeof(QuantityValue) => true,
+            _ when destinationType == typeof(BigInteger) => true,
+            _ => false
+        };
+    }
+
+    /// <inheritdoc />
+    public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType)
+    {
+        return sourceType switch
+        {
+            _ when sourceType == typeof(string) => true,
+            _ when sourceType == typeof(int) => true,
+            _ when sourceType == typeof(long) => true,
+            _ when sourceType == typeof(decimal) => true,
+            _ when sourceType == typeof(double) => true,
+            _ when sourceType == typeof(QuantityValue) => true,
+            _ when sourceType == typeof(BigInteger) => true,
+            _ => false
+        };
+    }
+
+    /// <inheritdoc />
+    public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType)
+    {
+        if (value is QuantityValue quantityValue)
+        {
+            return destinationType switch
+            {
+                _ when destinationType == typeof(string) => quantityValue.ToString(culture),
+                _ when destinationType == typeof(int) => (int)quantityValue,
+                _ when destinationType == typeof(long) => (long)quantityValue,
+                _ when destinationType == typeof(decimal) => quantityValue.ToDecimal(),
+                _ when destinationType == typeof(double) => quantityValue.ToDouble(),
+                _ when destinationType == typeof(BigInteger) => (BigInteger)quantityValue,
+                _ when destinationType == typeof(QuantityValue) => quantityValue,
+                _ => base.ConvertTo(context, culture, value, destinationType)
+            };
+        }
+
+        return base.ConvertTo(context, culture, value, destinationType);
+    }
+
+    /// <inheritdoc />
+    public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object? value)
+    {
+        if (value is null)
+        {
+            return QuantityValue.Zero;
+        }
+
+        return value switch
+        {
+            string s => QuantityValue.Parse(s, culture),
+            int i => new QuantityValue(i),
+            long l => new QuantityValue(l),
+            decimal d => new QuantityValue(d),
+            double dbl => QuantityValue.FromDoubleRounded(dbl),
+            BigInteger bigInteger => new QuantityValue(bigInteger),
+            QuantityValue quantityValue => quantityValue,
+            _ => base.ConvertFrom(context, culture, value)
+        };
+    }
+}
\ No newline at end of file
diff --git a/UnitsNet/CustomCode/Wrappers/ReferencePressure.cs b/UnitsNet/CustomCode/Wrappers/ReferencePressure.cs
index 84d4e5e276..69c51c48ca 100644
--- a/UnitsNet/CustomCode/Wrappers/ReferencePressure.cs
+++ b/UnitsNet/CustomCode/Wrappers/ReferencePressure.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -29,7 +29,7 @@ public struct ReferencePressure
         /// </summary>
         public Pressure AtmosphericPressure { get; set; }
 
-        private static readonly Pressure DefaultAtmosphericPressure = new Pressure(1, PressureUnit.Atmosphere);
+        private static readonly Pressure DefaultAtmosphericPressure = new(1, PressureUnit.Atmosphere);
 
         /// <summary>
         ///     Gets a list of <see cref="PressureReference" /> options: <see cref="PressureReference.Gauge" />,
@@ -98,26 +98,26 @@ public ReferencePressure(Pressure pressure, PressureReference reference, Pressur
         ///     Get Gauge <see cref="UnitsNet.Pressure" />.
         ///     It references pressure level above Atmospheric pressure.
         /// </summary>
-        public Pressure Gauge => As(PressureReference.Gauge);
+        public readonly Pressure Gauge => As(PressureReference.Gauge);
 
         /// <summary>
         ///     Get Absolute <see cref="UnitsNet.Pressure" />.
         ///     It is zero-referenced pressure to the perfect vacuum.
         /// </summary>
-        public Pressure Absolute => As(PressureReference.Absolute);
+        public readonly Pressure Absolute => As(PressureReference.Absolute);
 
         /// <summary>
         ///     Get Vacuum <see cref="UnitsNet.Pressure" />.
         ///     It is a negative Gauge pressure when Absolute pressure is below Atmospheric pressure.
         /// </summary>
-        public Pressure Vacuum => As(PressureReference.Vacuum);
+        public readonly Pressure Vacuum => As(PressureReference.Vacuum);
 
         /// <summary>
         ///     Converts <see cref="ReferencePressure" /> to <see cref="UnitsNet.Pressure" /> at <see cref="PressureReference" />
         /// </summary>
         /// <param name="reference">The <see cref="PressureReference" /> to convert <see cref="ReferencePressure" /> to.</param>
         /// <returns>The <see cref="UnitsNet.Pressure" /> at the specified <see cref="PressureReference" /></returns>
-        private Pressure As(PressureReference reference)
+        private readonly Pressure As(PressureReference reference)
         {
             var converted = AsBaseNumericType(reference);
 
@@ -129,7 +129,7 @@ private Pressure As(PressureReference reference)
         /// </summary>
         /// <param name="reference">The <see cref="PressureReference" /> to convert <see cref="ReferencePressure" /> to.</param>
         /// <returns>The value of pressure at <see cref="PressureReference" /></returns>
-        private double AsBaseNumericType(PressureReference reference)
+        private readonly QuantityValue AsBaseNumericType(PressureReference reference)
         {
             var baseReferenceValue = AsBaseReference();
 
@@ -140,14 +140,13 @@ private double AsBaseNumericType(PressureReference reference)
 
             var negatingValue = Reference == PressureReference.Vacuum ? -1 : 1;
 
-            switch (reference)
+            return reference switch
             {
-                case PressureReference.Absolute: return baseReferenceValue;
-                case PressureReference.Gauge: return baseReferenceValue - AtmosphericPressure.ToUnit(Pressure.Unit).Value;
-                case PressureReference.Vacuum: return AtmosphericPressure.ToUnit(Pressure.Unit).Value - negatingValue * baseReferenceValue;
-                default:
-                    throw new NotImplementedException($"Can't convert {Reference} to {reference}.");
-            }
+                PressureReference.Absolute => baseReferenceValue,
+                PressureReference.Gauge => baseReferenceValue - AtmosphericPressure.ToUnit(Pressure.Unit).Value,
+                PressureReference.Vacuum => AtmosphericPressure.ToUnit(Pressure.Unit).Value - negatingValue * baseReferenceValue,
+                _ => throw new NotImplementedException($"Can't convert {Reference} to {reference}.")
+            };
         }
 
         /// <summary>
@@ -155,7 +154,7 @@ private double AsBaseNumericType(PressureReference reference)
         ///     <see cref="BaseReference" />
         /// </summary>
         /// <returns>The value of pressure at the <see cref="BaseReference" /></returns>
-        private double AsBaseReference()
+        private readonly QuantityValue AsBaseReference()
         {
             switch (Reference)
             {
diff --git a/UnitsNet/Exceptions/AmbiguousUnitParseException.cs b/UnitsNet/Exceptions/AmbiguousUnitParseException.cs
index 521b6c8f0b..29415b59dc 100644
--- a/UnitsNet/Exceptions/AmbiguousUnitParseException.cs
+++ b/UnitsNet/Exceptions/AmbiguousUnitParseException.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet/Exceptions/ExceptionHelper.cs b/UnitsNet/Exceptions/ExceptionHelper.cs
index 8e8969e0f6..811b843ab1 100644
--- a/UnitsNet/Exceptions/ExceptionHelper.cs
+++ b/UnitsNet/Exceptions/ExceptionHelper.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace UnitsNet;
 
diff --git a/UnitsNet/Exceptions/InvalidConversionException.cs b/UnitsNet/Exceptions/InvalidConversionException.cs
new file mode 100644
index 0000000000..17b76fa27e
--- /dev/null
+++ b/UnitsNet/Exceptions/InvalidConversionException.cs
@@ -0,0 +1,48 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+
+namespace UnitsNet;
+
+/// <summary>
+///     The conversion to the specified is not supported. This is typically thrown for dynamic conversions,
+///     such as <see cref="UnitConverter.ConvertByName" />.
+/// </summary>
+public class InvalidConversionException : UnitsNetException
+{
+    /// <inheritdoc />
+    public InvalidConversionException()
+    {
+    }
+
+    /// <inheritdoc />
+    public InvalidConversionException(string message) : base(message)
+    {
+    }
+
+    /// <inheritdoc />
+    public InvalidConversionException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+
+    internal static InvalidConversionException CreateImplicitConversionException(QuantityInfo sourceQuantity, QuantityInfo targetQuantity)
+    {
+        return new InvalidConversionException($"No implicit conversion exists for the quantities: source = '{sourceQuantity}', target = '{targetQuantity}'");
+    }
+
+    internal static InvalidConversionException CreateIncompatibleDimensionsException(BaseDimensions sourceDimensions, BaseDimensions targetDimensions)
+    {
+        return new InvalidConversionException($"The conversion expression cannot be determined from the base dimensions: source = '{sourceDimensions}', target = '{targetDimensions}'");
+    }
+
+    internal static InvalidConversionException CreateIncompatibleDimensionsException(QuantityInfo sourceQuantityInfo, QuantityInfo targetQuantityInfo)
+    {
+        return new InvalidConversionException($"The dimensions of the source quantity '{sourceQuantityInfo}' are not compatible with the dimensions of the target quantity '{targetQuantityInfo}'.");
+    }
+
+    internal static InvalidConversionException CreateIncompatibleUnitsException(UnitInfo sourceUnitInfo, QuantityInfo targetQuantityInfo)
+    {
+        return new InvalidConversionException($"No compatible base units found for the conversion from '{sourceUnitInfo}' to '{targetQuantityInfo}'");
+    }
+}
diff --git a/UnitsNet/Exceptions/QuantityNotFoundException.cs b/UnitsNet/Exceptions/QuantityNotFoundException.cs
index dbd088b93c..c6dd864a71 100644
--- a/UnitsNet/Exceptions/QuantityNotFoundException.cs
+++ b/UnitsNet/Exceptions/QuantityNotFoundException.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet/Exceptions/UnitsNetException.cs b/UnitsNet/Exceptions/UnitsNetException.cs
index a517b700c2..06d0e5521a 100644
--- a/UnitsNet/Exceptions/UnitsNetException.cs
+++ b/UnitsNet/Exceptions/UnitsNetException.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -10,6 +10,11 @@ namespace UnitsNet
     /// </summary>
     public class UnitsNetException : Exception
     {
+        /// <summary>
+        ///     Key used in <see cref="Exception.Data" /> for stable UnitsNet error codes.
+        /// </summary>
+        public const string ErrorCodeDataKey = "errorCode";
+
         /// <inheritdoc />
         public UnitsNetException()
         {
diff --git a/UnitsNet/Extensions/AffineQuantityExtensions.cs b/UnitsNet/Extensions/AffineQuantityExtensions.cs
index 3477b5b47e..3eaebd6495 100644
--- a/UnitsNet/Extensions/AffineQuantityExtensions.cs
+++ b/UnitsNet/Extensions/AffineQuantityExtensions.cs
@@ -1,10 +1,6 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
-#if NET
-using System.Numerics;
-#endif
-
 namespace UnitsNet;
 
 /// <summary>
@@ -62,13 +58,13 @@ private static bool EqualsAbsolute<TQuantity, TOffset>(this TQuantity quantity,
         where TQuantity : IAffineQuantity<TQuantity, TOffset>, ISubtractionOperators<TQuantity, TQuantity, TOffset>
         where TOffset : IQuantityOfType<TOffset>, IAdditiveIdentity<TOffset, TOffset>
     {
-        if (double.IsNegative(tolerance.Value))
+        if (QuantityValue.IsNegative(tolerance.Value))
         {
             throw ExceptionHelper.CreateArgumentOutOfRangeExceptionForNegativeTolerance(nameof(tolerance));
         }
 
         TOffset difference = quantity - other;
-        return double.Abs(difference.Value) <= tolerance.GetValue(difference.UnitKey);
+        return QuantityValue.Abs(difference.Value) <= tolerance.GetValue(difference.UnitKey);
     }
 #else
     /// <summary>
@@ -99,13 +95,13 @@ private static bool EqualsAbsolute<TQuantity, TOffset>(this TQuantity quantity,
     /// </remarks>
     public static bool Equals(this Temperature quantity, Temperature other, TemperatureDelta tolerance)
     {
-        if (tolerance.Value < 0)
+        if (QuantityValue.IsNegative(tolerance.Value))
         {
             throw ExceptionHelper.CreateArgumentOutOfRangeExceptionForNegativeTolerance(nameof(tolerance));
         }
 
         TemperatureDelta difference = quantity - other;
-        return Math.Abs(difference.Value) <= tolerance.GetValue(UnitKey.ForUnit(difference.Unit));
+        return QuantityValue.Abs(difference.Value) <= tolerance.GetValue(UnitKey.ForUnit(difference.Unit));
     }
 
     /// <inheritdoc cref="Equals(UnitsNet.Temperature,UnitsNet.Temperature,UnitsNet.TemperatureDelta)" />
diff --git a/UnitsNet/Extensions/LinearQuantityExtensions.cs b/UnitsNet/Extensions/LinearQuantityExtensions.cs
index d6183625c9..b530f6e0e3 100644
--- a/UnitsNet/Extensions/LinearQuantityExtensions.cs
+++ b/UnitsNet/Extensions/LinearQuantityExtensions.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Linq;
@@ -88,14 +88,14 @@ public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> quantities)
             {
                 return default!;
             }
-
+            
             return (TQuantity)UnitsNetSetup.Default.Quantities.GetQuantityInfo(typeof(TQuantity)).Zero;
 #endif
         }
 
         TQuantity firstQuantity = enumerator.Current!;
         UnitKey resultUnit = firstQuantity.UnitKey;
-        var sumOfValues = firstQuantity.Value;
+        QuantityValue sumOfValues = firstQuantity.Value;
         while (enumerator.MoveNext())
         {
             sumOfValues += enumerator.Current!.GetValue(resultUnit);
@@ -107,7 +107,7 @@ public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> quantities)
         return firstQuantity.QuantityInfo.Create(sumOfValues, resultUnit);
 #endif
     }
-
+    
     /// <summary>
     ///     Computes the sum of a sequence of quantities by applying a specified selector function to each element of the
     ///     sequence.
@@ -141,28 +141,32 @@ public static TQuantity Sum<TSource, TQuantity>(this IEnumerable<TSource> source
     ///     when most of the quantities in the sequence are expected to be in the target unit.
     /// </remarks>
     public static TQuantity Sum<TQuantity, TUnit>(this IEnumerable<TQuantity> quantities, TUnit unit)
-        where TQuantity : ILinearQuantity<TQuantity>, IQuantity<TQuantity, TUnit>
+        where TQuantity : ILinearQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
         using IEnumerator<TQuantity> enumerator = quantities.GetEnumerator();
         if (!enumerator.MoveNext())
         {
 #if NET
-            return TQuantity.From(0, unit);
+            return TQuantity.From(QuantityValue.Zero, unit);
 #else
-            return (TQuantity)Quantity.From(0, UnitKey.ForUnit(unit));
+            return (TQuantity)Quantity.From(QuantityValue.Zero, UnitKey.ForUnit(unit));
 #endif
         }
 
         var unitKey = UnitKey.ForUnit(unit);
         TQuantity firstQuantity = enumerator.Current!;
-        var resultValue = firstQuantity.GetValue(unitKey);
+        QuantityValue resultValue = firstQuantity.GetValue(unitKey);
         while (enumerator.MoveNext())
         {
             resultValue += enumerator.Current!.GetValue(unitKey);
         }
 
+#if NET
+        return TQuantity.From(resultValue, unit);
+#else
         return firstQuantity.QuantityInfo.From(resultValue, unit);
+#endif
     }
 
     /// <summary>
@@ -178,7 +182,7 @@ public static TQuantity Sum<TQuantity, TUnit>(this IEnumerable<TQuantity> quanti
     /// <returns>The sum of the projected quantities in the specified unit.</returns>
     /// <exception cref="ArgumentNullException">Thrown if the source or selector is null.</exception>
     public static TQuantity Sum<TSource, TQuantity, TUnit>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, TUnit targetUnit)
-        where TQuantity : ILinearQuantity<TQuantity>, IQuantity<TQuantity, TUnit>
+        where TQuantity : ILinearQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
         return source.Select(selector).Sum(targetUnit);
@@ -231,7 +235,7 @@ public static TQuantity Average<TSource, TQuantity>(this IEnumerable<TSource> so
     ///     when most of the quantities in the sequence are expected to be in the target unit.
     /// </remarks>
     public static TQuantity Average<TQuantity, TUnit>(this IEnumerable<TQuantity> quantities, TUnit targetUnit)
-        where TQuantity : ILinearQuantity<TQuantity>, IQuantity<TQuantity, TUnit>
+        where TQuantity : ILinearQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
         return quantities.ArithmeticMean(targetUnit);
@@ -250,7 +254,7 @@ public static TQuantity Average<TQuantity, TUnit>(this IEnumerable<TQuantity> qu
     /// <returns>The average of the projected quantities in the specified unit.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     public static TQuantity Average<TSource, TQuantity, TUnit>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, TUnit targetUnit)
-        where TQuantity : ILinearQuantity<TQuantity>, IQuantity<TQuantity, TUnit>
+        where TQuantity : ILinearQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
         return source.Select(selector).Average(targetUnit);
@@ -275,9 +279,9 @@ public static TQuantity Abs<TQuantity>(this TQuantity value)
         where TQuantity : ILinearQuantity<TQuantity>
     {
 #if NET
-        return TQuantity.Create(Math.Abs(value.Value), value.UnitKey);
+        return TQuantity.Create(QuantityValue.Abs(value.Value), value.UnitKey);
 #else
-        return value.QuantityInfo.Create(Math.Abs(value.Value), value.UnitKey);
+        return value.QuantityInfo.Create(QuantityValue.Abs(value.Value), value.UnitKey);
 #endif
     }
 }
diff --git a/UnitsNet/Extensions/LogarithmicQuantityExtensions.cs b/UnitsNet/Extensions/LogarithmicQuantityExtensions.cs
index 7f28720e05..5364fde592 100644
--- a/UnitsNet/Extensions/LogarithmicQuantityExtensions.cs
+++ b/UnitsNet/Extensions/LogarithmicQuantityExtensions.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Linq;
@@ -11,25 +11,6 @@ namespace UnitsNet;
 /// </summary>
 public static class LogarithmicQuantityExtensions
 {
-    internal static double ToLinearSpace(this double logValue, double scalingFactor)
-    {
-        return Math.Pow(10, logValue / scalingFactor);
-    }
-
-    internal static double ToLogSpace(this double value, double scalingFactor)
-    {
-        return scalingFactor * Math.Log10(value);
-    }
-
-    private static double RootN(double number, int n)
-    {
-#if NET
-        return double.RootN(number, n);
-#else
-        return Math.Pow(number, 1.0 / n);
-#endif
-    }
-
     /// <inheritdoc cref="EqualsAbsolute{TQuantity,TOther,TTolerance}" />
     public static bool Equals<TQuantity, TOther, TTolerance>(this TQuantity quantity, TOther? other, TTolerance tolerance)
         where TQuantity : ILogarithmicQuantity<TQuantity>
@@ -86,9 +67,9 @@ private static bool EqualsAbsolute<TQuantity, TOther, TTolerance>(this TQuantity
     {
         UnitKey quantityUnit = quantity.UnitKey;
 #if NET
-        var scalingFactor = TQuantity.LogarithmicScalingFactor;
+        QuantityValue scalingFactor = TQuantity.LogarithmicScalingFactor;
 #else
-        var scalingFactor = quantity.LogarithmicScalingFactor;
+        QuantityValue scalingFactor = quantity.LogarithmicScalingFactor;
 #endif
         var valueInLinearSpace = quantity.Value.ToLinearSpace(scalingFactor);
         var otherValueInLinearSpace = other.GetValue(quantityUnit).ToLinearSpace(scalingFactor);
@@ -101,13 +82,14 @@ private static bool EqualsAbsolute<TQuantity, TOther, TTolerance>(this TQuantity
     /// </summary>
     /// <typeparam name="TQuantity">The type of the logarithmic quantity.</typeparam>
     /// <param name="quantities">The sequence of logarithmic quantities to sum.</param>
+    /// <param name="significantDigits">The number of significant digits to retain in the result. Default is 15.</param>
     /// <returns>The sum of the logarithmic quantities in the unit of the first element in the sequence.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     When the sequence is not empty, each quantity is converted to linear space (in the unit of the first element),
     ///     summed, and then the result is converted back to logarithmic space using the same unit.
     /// </remarks>
-    public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> quantities)
+    public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> quantities, byte significantDigits = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity>
     {
         if (quantities is null)
@@ -123,9 +105,9 @@ public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> quantities)
 
         TQuantity firstQuantity = enumerator.Current!;
 #if NET
-        var logarithmicScalingFactor = TQuantity.LogarithmicScalingFactor;
+        QuantityValue logarithmicScalingFactor = TQuantity.LogarithmicScalingFactor;
 #else
-        var logarithmicScalingFactor = firstQuantity.LogarithmicScalingFactor;
+        QuantityValue logarithmicScalingFactor = firstQuantity.LogarithmicScalingFactor;
 #endif
         UnitKey resultUnit = firstQuantity.UnitKey;
         var resultValue = firstQuantity.Value.ToLinearSpace(logarithmicScalingFactor);
@@ -134,9 +116,9 @@ public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> quantities)
             resultValue += enumerator.Current!.GetValue(resultUnit).ToLinearSpace(logarithmicScalingFactor);
         }
 #if NET
-        return TQuantity.Create(resultValue.ToLogSpace(logarithmicScalingFactor), resultUnit);
+        return TQuantity.Create(resultValue.ToLogSpace(logarithmicScalingFactor, significantDigits), resultUnit);
 #else
-        return firstQuantity.QuantityInfo.Create(resultValue.ToLogSpace(logarithmicScalingFactor), resultUnit);
+        return firstQuantity.QuantityInfo.Create(resultValue.ToLogSpace(logarithmicScalingFactor, significantDigits), resultUnit);
 #endif
     }
 
@@ -149,16 +131,17 @@ public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> quantities)
     /// <typeparam name="TQuantity">The type of the quantity elements in the source sequence.</typeparam>
     /// <param name="source">A sequence of quantities to calculate the sum of.</param>
     /// <param name="selector">A function to transform each element of the source sequence into a quantity.</param>
+    /// <param name="significantDigits">The number of significant digits to retain in the result. Default is 15.</param>
     /// <returns>The sum of the logarithmic quantities in the unit of the first element in the sequence.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     When the sequence is not empty, each quantity is converted to linear space (in the unit of the first element),
     ///     summed, and then the result is converted back to logarithmic space using the same unit.
     /// </remarks>
-    public static TQuantity Sum<TSource, TQuantity>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector)
+    public static TQuantity Sum<TSource, TQuantity>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, byte significantDigits = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity>
     {
-        return source.Select(selector).Sum();
+        return source.Select(selector).Sum(significantDigits);
     }
 
     /// <summary>
@@ -169,13 +152,14 @@ public static TQuantity Sum<TSource, TQuantity>(this IEnumerable<TSource> source
     /// <typeparam name="TUnit">The unit type of the logarithmic quantity.</typeparam>
     /// <param name="quantities">The sequence of logarithmic quantities to sum.</param>
     /// <param name="targetUnit">The unit in which to express the sum.</param>
+    /// <param name="significantDigits">The number of significant digits to retain in the result. Default is 15.</param>
     /// <returns>The sum of the logarithmic quantities in the specified unit.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     This method converts each logarithmic quantity to linear space, sums them, and then converts the result back to
     ///     logarithmic space.
     /// </remarks>
-    public static TQuantity Sum<TQuantity, TUnit>(this IEnumerable<TQuantity> quantities, TUnit targetUnit)
+    public static TQuantity Sum<TQuantity, TUnit>(this IEnumerable<TQuantity> quantities, TUnit targetUnit, byte significantDigits = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
@@ -193,9 +177,9 @@ public static TQuantity Sum<TQuantity, TUnit>(this IEnumerable<TQuantity> quanti
         var unitKey = UnitKey.ForUnit(targetUnit);
         TQuantity firstQuantity = enumerator.Current!;
 #if NET
-        var logarithmicScalingFactor = TQuantity.LogarithmicScalingFactor;
+        QuantityValue logarithmicScalingFactor = TQuantity.LogarithmicScalingFactor;
 #else
-        var logarithmicScalingFactor = firstQuantity.LogarithmicScalingFactor;
+        QuantityValue logarithmicScalingFactor = firstQuantity.LogarithmicScalingFactor;
 #endif
         var sumInLinearSpace = firstQuantity.GetValue(unitKey).ToLinearSpace(logarithmicScalingFactor);
         while (enumerator.MoveNext())
@@ -203,7 +187,11 @@ public static TQuantity Sum<TQuantity, TUnit>(this IEnumerable<TQuantity> quanti
             sumInLinearSpace += enumerator.Current!.GetValue(unitKey).ToLinearSpace(logarithmicScalingFactor);
         }
 
-        return firstQuantity.QuantityInfo.From(sumInLinearSpace.ToLogSpace(logarithmicScalingFactor), targetUnit);
+#if NET
+        return TQuantity.From(sumInLinearSpace.ToLogSpace(logarithmicScalingFactor, significantDigits), targetUnit);
+#else
+        return firstQuantity.QuantityInfo.From(sumInLinearSpace.ToLogSpace(logarithmicScalingFactor, significantDigits), targetUnit);
+#endif
     }
 
     /// <summary>
@@ -217,17 +205,19 @@ public static TQuantity Sum<TQuantity, TUnit>(this IEnumerable<TQuantity> quanti
     /// <param name="source">A sequence of quantities to calculate the sum of.</param>
     /// <param name="selector">A function to transform each element of the source sequence into a quantity.</param>
     /// <param name="targetUnit">The desired unit type for the resulting quantity</param>
+    /// <param name="significantDigits">The number of significant digits to retain in the result. Default is 15.</param>
     /// <returns>The sum of the projected quantities in the specified unit.</returns>
     /// <exception cref="ArgumentNullException">Thrown if the source or selector is null.</exception>
     /// <remarks>
     ///     This method converts each logarithmic quantity to linear space, sums them, and then converts the result back to
     ///     logarithmic space.
     /// </remarks>
-    public static TQuantity Sum<TSource, TQuantity, TUnit>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, TUnit targetUnit)
+    public static TQuantity Sum<TSource, TQuantity, TUnit>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, TUnit targetUnit,
+        byte significantDigits = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
-        return source.Select(selector).Sum(targetUnit);
+        return source.Select(selector).Sum(targetUnit, significantDigits);
     }
 
     /// <summary>
@@ -235,13 +225,14 @@ public static TQuantity Sum<TSource, TQuantity, TUnit>(this IEnumerable<TSource>
     /// </summary>
     /// <typeparam name="TQuantity">The type of the logarithmic quantity.</typeparam>
     /// <param name="quantities">The sequence of logarithmic quantities to average.</param>
+    /// <param name="significantDigits">The number of significant digits to retain in the result. Default is 15.</param>
     /// <returns>The average of the logarithmic quantities in the unit of the first element in the sequence.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     When the sequence is not empty, each quantity is converted to linear space (in the unit of the first element),
     ///     averaged, and then the result is converted back to logarithmic space using the same unit.
     /// </remarks>
-    public static TQuantity ArithmeticMean<TQuantity>(this IEnumerable<TQuantity> quantities)
+    public static TQuantity ArithmeticMean<TQuantity>(this IEnumerable<TQuantity> quantities, byte significantDigits = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity>
     {
         if (quantities is null)
@@ -257,9 +248,9 @@ public static TQuantity ArithmeticMean<TQuantity>(this IEnumerable<TQuantity> qu
 
         TQuantity firstQuantity = enumerator.Current!;
 #if NET
-        var logarithmicScalingFactor = TQuantity.LogarithmicScalingFactor;
+        QuantityValue logarithmicScalingFactor = TQuantity.LogarithmicScalingFactor;
 #else
-        var logarithmicScalingFactor = firstQuantity.LogarithmicScalingFactor;
+        QuantityValue logarithmicScalingFactor = firstQuantity.LogarithmicScalingFactor;
 #endif
         UnitKey resultUnit = firstQuantity.UnitKey;
         var sumInLinearSpace = firstQuantity.Value.ToLinearSpace(logarithmicScalingFactor);
@@ -272,9 +263,9 @@ public static TQuantity ArithmeticMean<TQuantity>(this IEnumerable<TQuantity> qu
 
         var avgInLinearSpace = sumInLinearSpace / nbQuantities;
 #if NET
-        return TQuantity.Create(avgInLinearSpace.ToLogSpace(logarithmicScalingFactor), resultUnit);
+        return TQuantity.Create(avgInLinearSpace.ToLogSpace(logarithmicScalingFactor, significantDigits), resultUnit);
 #else
-        return firstQuantity.QuantityInfo.Create(avgInLinearSpace.ToLogSpace(logarithmicScalingFactor), resultUnit);
+        return firstQuantity.QuantityInfo.Create(avgInLinearSpace.ToLogSpace(logarithmicScalingFactor, significantDigits), resultUnit);
 #endif
     }
 
@@ -286,16 +277,17 @@ public static TQuantity ArithmeticMean<TQuantity>(this IEnumerable<TQuantity> qu
     /// <typeparam name="TQuantity">The type of the quantity elements in the source sequence.</typeparam>
     /// <param name="source">A sequence of quantities to calculate the sum of.</param>
     /// <param name="selector">A function to transform each element of the source sequence into a quantity.</param>
+    /// <param name="significantDigits">The number of significant digits to retain in the result. Default is 15.</param>
     /// <returns>The average of the logarithmic quantities in the unit of the first element in the sequence.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     When the sequence is not empty, each quantity is converted to linear space (in the unit of the first element),
     ///     averaged, and then the result is converted back to logarithmic space using the same unit.
     /// </remarks>
-    public static TQuantity ArithmeticMean<TSource, TQuantity>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector)
+    public static TQuantity ArithmeticMean<TSource, TQuantity>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, byte significantDigits = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity>
     {
-        return ArithmeticMean(source.Select(selector));
+        return source.Select(selector).ArithmeticMean(significantDigits);
     }
 
     /// <summary>
@@ -305,13 +297,14 @@ public static TQuantity ArithmeticMean<TSource, TQuantity>(this IEnumerable<TSou
     /// <typeparam name="TUnit">The unit type of the logarithmic quantity.</typeparam>
     /// <param name="quantities">The sequence of logarithmic quantities to sum.</param>
     /// <param name="unit">The unit in which to express the sum.</param>
+    /// <param name="significantDigits">The number of significant digits to retain in the result. Default is 15.</param>
     /// <returns>The arithmetic mean of the logarithmic quantities in the specified unit.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     When the sequence is not empty, each quantity is converted to linear space (in the specified unit),
     ///     averaged, and then the result is converted back to logarithmic space using the same unit.
     /// </remarks>
-    public static TQuantity ArithmeticMean<TQuantity, TUnit>(this IEnumerable<TQuantity> quantities, TUnit unit)
+    public static TQuantity ArithmeticMean<TQuantity, TUnit>(this IEnumerable<TQuantity> quantities, TUnit unit, byte significantDigits = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
@@ -329,9 +322,9 @@ public static TQuantity ArithmeticMean<TQuantity, TUnit>(this IEnumerable<TQuant
         var unitKey = UnitKey.ForUnit(unit);
         TQuantity firstQuantity = enumerator.Current!;
 #if NET
-        var logarithmicScalingFactor = TQuantity.LogarithmicScalingFactor;
+        QuantityValue logarithmicScalingFactor = TQuantity.LogarithmicScalingFactor;
 #else
-        var logarithmicScalingFactor = firstQuantity.LogarithmicScalingFactor;
+        QuantityValue logarithmicScalingFactor = firstQuantity.LogarithmicScalingFactor;
 #endif
         var sumInLinearSpace = firstQuantity.GetValue(unitKey).ToLinearSpace(logarithmicScalingFactor);
         var nbQuantities = 1;
@@ -342,7 +335,11 @@ public static TQuantity ArithmeticMean<TQuantity, TUnit>(this IEnumerable<TQuant
         }
 
         var avgInLinearSpace = sumInLinearSpace / nbQuantities;
-        return firstQuantity.QuantityInfo.From(avgInLinearSpace.ToLogSpace(logarithmicScalingFactor), unit);
+#if NET
+        return TQuantity.From(avgInLinearSpace.ToLogSpace(logarithmicScalingFactor, significantDigits), unit);
+#else
+        return firstQuantity.QuantityInfo.From(avgInLinearSpace.ToLogSpace(logarithmicScalingFactor, significantDigits), unit);
+#endif
     }
 
     /// <summary>
@@ -356,17 +353,19 @@ public static TQuantity ArithmeticMean<TQuantity, TUnit>(this IEnumerable<TQuant
     /// <param name="source">A sequence of quantities to calculate the sum of.</param>
     /// <param name="selector">A function to transform each element of the source sequence into a quantity.</param>
     /// <param name="targetUnit">The desired unit type for the resulting quantity.</param>
+    /// <param name="significantDigits">The number of significant digits to retain in the result. Default is 15.</param>
     /// <returns>The arithmetic mean of the logarithmic quantities in the specified unit.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     When the sequence is not empty, each quantity is converted to linear space (in the specified unit),
     ///     averaged, and then the result is converted back to logarithmic space using the same unit.
     /// </remarks>
-    public static TQuantity ArithmeticMean<TSource, TQuantity, TUnit>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, TUnit targetUnit)
+    public static TQuantity ArithmeticMean<TSource, TQuantity, TUnit>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, TUnit targetUnit,
+        byte significantDigits = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
-        return ArithmeticMean(source.Select(selector), targetUnit);
+        return source.Select(selector).ArithmeticMean(targetUnit, significantDigits);
     }
 
     /// <summary>
@@ -374,13 +373,17 @@ public static TQuantity ArithmeticMean<TSource, TQuantity, TUnit>(this IEnumerab
     /// </summary>
     /// <typeparam name="TQuantity">The type of the logarithmic quantity.</typeparam>
     /// <param name="quantities">The sequence of logarithmic quantities to average.</param>
+    /// <param name="accuracy">
+    ///     The accuracy for the square root calculation, expressed as number of significant digits. Default
+    ///     is 15.
+    /// </param>
     /// <returns>The geometric mean of the logarithmic quantities in the unit of the first element in the sequence.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     When the sequence is not empty, calculates the n-th root of the product of the quantities, which for the
     ///     logarithmic quantities is equal to the sum the values, converted in unit of the first element.
     /// </remarks>
-    public static TQuantity GeometricMean<TQuantity>(this IEnumerable<TQuantity> quantities)
+    public static TQuantity GeometricMean<TQuantity>(this IEnumerable<TQuantity> quantities, int accuracy = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity>
     {
         if (quantities is null)
@@ -396,7 +399,7 @@ public static TQuantity GeometricMean<TQuantity>(this IEnumerable<TQuantity> qua
 
         TQuantity firstQuantity = enumerator.Current!;
         UnitKey resultUnit = firstQuantity.UnitKey;
-        var sumInLogSpace = firstQuantity.Value;
+        QuantityValue sumInLogSpace = firstQuantity.Value;
         var nbQuantities = 1;
         while (enumerator.MoveNext())
         {
@@ -404,7 +407,7 @@ public static TQuantity GeometricMean<TQuantity>(this IEnumerable<TQuantity> qua
             nbQuantities++;
         }
 
-        var geometricMean = RootN(sumInLogSpace, nbQuantities);
+        var geometricMean = QuantityValue.RootN(sumInLogSpace, nbQuantities, accuracy);
 #if NET
         return TQuantity.Create(geometricMean, resultUnit);
 #else
@@ -421,18 +424,20 @@ public static TQuantity GeometricMean<TQuantity>(this IEnumerable<TQuantity> qua
     /// <typeparam name="TQuantity">The type of the quantity elements in the source sequence.</typeparam>
     /// <param name="source">A sequence of quantities to calculate the sum of.</param>
     /// <param name="selector">A function to transform each element of the source sequence into a quantity.</param>
+    /// <param name="accuracy">The number of significant digits to retain in the result. Default is 15.</param>
     /// <returns>The geometric mean of the logarithmic quantities in the unit of the first element in the sequence.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     When the sequence is not empty, calculates the n-th root of the product of the quantities, which for the
     ///     logarithmic quantities is equal to the sum the values, converted in unit of the first element.
     /// </remarks>
-    public static TQuantity GeometricMean<TSource, TQuantity>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector)
+    public static TQuantity GeometricMean<TSource, TQuantity>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, int accuracy = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity>
     {
-        return source.Select(selector).GeometricMean();
+        return source.Select(selector).GeometricMean(accuracy);
     }
 
+
     /// <summary>
     ///     Computes the geometric mean of a sequence of logarithmic quantities, such as PowerRatio and AmplitudeRatio, using
     ///     the specified unit.
@@ -441,13 +446,14 @@ public static TQuantity GeometricMean<TSource, TQuantity>(this IEnumerable<TSour
     /// <typeparam name="TUnit">The type of the unit of the quantities.</typeparam>
     /// <param name="quantities">The sequence of logarithmic quantities to average.</param>
     /// <param name="targetUnit">The desired unit type for the resulting quantity.</param>
+    /// <param name="accuracy">The number of decimal places of accuracy for the square root calculation. Default is 15.</param>
     /// <returns>The geometric mean of the logarithmic quantities in the unit of the first element in the sequence.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     When the sequence is not empty, calculates the n-th root of the product of the quantities, which for the
     ///     logarithmic quantities is equal to the sum the values, converted in unit of the first element.
     /// </remarks>
-    public static TQuantity GeometricMean<TQuantity, TUnit>(this IEnumerable<TQuantity> quantities, TUnit targetUnit)
+    public static TQuantity GeometricMean<TQuantity, TUnit>(this IEnumerable<TQuantity> quantities, TUnit targetUnit, int accuracy = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
@@ -464,7 +470,7 @@ public static TQuantity GeometricMean<TQuantity, TUnit>(this IEnumerable<TQuanti
 
         var unitKey = UnitKey.ForUnit(targetUnit);
         TQuantity firstQuantity = enumerator.Current!;
-        var sumInLogSpace = firstQuantity.GetValue(unitKey);
+        QuantityValue sumInLogSpace = firstQuantity.GetValue(unitKey);
         var nbQuantities = 1;
         while (enumerator.MoveNext())
         {
@@ -472,8 +478,12 @@ public static TQuantity GeometricMean<TQuantity, TUnit>(this IEnumerable<TQuanti
             nbQuantities++;
         }
 
-        var geometricMean = RootN(sumInLogSpace, nbQuantities);
+        var geometricMean = QuantityValue.RootN(sumInLogSpace, nbQuantities, accuracy);
+#if NET
+        return TQuantity.From(geometricMean, unitKey.ToUnit<TUnit>());
+#else
         return firstQuantity.QuantityInfo.From(geometricMean, unitKey.ToUnit<TUnit>());
+#endif
     }
 
     /// <summary>
@@ -487,16 +497,18 @@ public static TQuantity GeometricMean<TQuantity, TUnit>(this IEnumerable<TQuanti
     /// <param name="source">A sequence of quantities to calculate the sum of.</param>
     /// <param name="selector">A function to transform each element of the source sequence into a quantity.</param>
     /// <param name="targetUnit">The desired unit type for the resulting quantity.</param>
+    /// <param name="accuracy">The number of decimal places of accuracy for the square root calculation. Default is 15.</param>
     /// <returns>The arithmetic mean of the logarithmic quantities in the specified unit.</returns>
     /// <exception cref="InvalidOperationException">Thrown when the sequence is empty.</exception>
     /// <remarks>
     ///     When the sequence is not empty, calculates the n-th root of the product of the quantities, which for the
     ///     logarithmic quantities is equal to the sum the values, converted in unit of the first element.
     /// </remarks>
-    public static TQuantity GeometricMean<TSource, TQuantity, TUnit>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, TUnit targetUnit)
+    public static TQuantity GeometricMean<TSource, TQuantity, TUnit>(this IEnumerable<TSource> source, Func<TSource, TQuantity> selector, TUnit targetUnit,
+        int accuracy = 15)
         where TQuantity : ILogarithmicQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
-        return source.Select(selector).GeometricMean(targetUnit);
+        return source.Select(selector).GeometricMean(targetUnit, accuracy);
     }
 }
diff --git a/UnitsNet/Extensions/QuantityExtensions.cs b/UnitsNet/Extensions/QuantityExtensions.cs
index 229907569d..0e8f40255f 100644
--- a/UnitsNet/Extensions/QuantityExtensions.cs
+++ b/UnitsNet/Extensions/QuantityExtensions.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Globalization;
@@ -11,6 +11,30 @@ namespace UnitsNet;
 /// </summary>
 public static class QuantityExtensions
 {
+    /// <summary>
+    ///     Gets the <see cref="UnitsNet.QuantityInfo"/> for the given quantity instance, looked up via
+    ///     <see cref="UnitsNetSetup.Default"/>.
+    /// </summary>
+    /// <remarks>
+    ///     Use the static <c>TSelf.Info</c> directly when you have a typed quantity reference for the best performance.
+    ///     This extension is convenient when working with an <see cref="IQuantity"/> reference where the concrete
+    ///     type is not known at compile time.
+    /// </remarks>
+    /// <param name="quantity">The quantity instance.</param>
+    /// <returns>The <see cref="UnitsNet.QuantityInfo"/> registered in <see cref="UnitsNetSetup.Default"/> for the quantity's runtime type.</returns>
+    public static QuantityInfo GetQuantityInfo(this IQuantity quantity)
+    {
+        return UnitsNetSetup.Default.Quantities.GetQuantityInfo(quantity.GetType());
+    }
+
+    /// <inheritdoc cref="GetQuantityInfo(IQuantity)"/>
+    /// <typeparam name="TUnit">The unit enum type of the quantity.</typeparam>
+    public static QuantityInfo<TUnit> GetQuantityInfo<TUnit>(this IQuantity<TUnit> quantity)
+        where TUnit : struct, Enum
+    {
+        return (QuantityInfo<TUnit>)UnitsNetSetup.Default.Quantities.GetQuantityInfo(quantity.GetType());
+    }
+
     /// <summary>
     ///     Gets the <see cref="UnitInfo"/> for the unit this quantity was constructed with.
     /// </summary>
@@ -24,7 +48,7 @@ public static class QuantityExtensions
     /// <returns>The <see cref="UnitInfo"/> for the quantity's unit.</returns>
     public static UnitInfo GetUnitInfo(this IQuantity quantity)
     {
-        return quantity.QuantityInfo[quantity.UnitKey];
+        return quantity.GetQuantityInfo()[quantity.UnitKey];
     }
 
     /// <summary>
@@ -44,70 +68,142 @@ public static UnitInfo<TQuantity, TUnit> GetUnitInfo<TQuantity, TUnit>(this IQua
         where TQuantity : IQuantity<TQuantity, TUnit>
         where TUnit : struct, Enum
     {
-        return quantity.QuantityInfo[quantity.Unit];
+#if NET
+        return TQuantity.Info[quantity.Unit];
+#else
+        // Azure CI build failed on binding QuantityInfo through IQuantity<TUnit>, so cast to expose the fully typed indexer.
+        // This is likely a .NET SDK version compatibility thing, did not bother looking closer at it.
+        QuantityInfo<TQuantity, TUnit> quantityInfo = quantity.QuantityInfo;
+        return quantityInfo[quantity.Unit];
+#endif
     }
 
-    /// <inheritdoc cref="IQuantity.As(UnitKey)" />
-    /// <remarks>This should be using UnitConverter.Default.ConvertValue(quantity, toUnit) </remarks>
-    internal static double GetValue<TQuantity>(this TQuantity quantity, UnitKey toUnit)
+    /// <inheritdoc cref="UnitConverter.ConvertValue(QuantityValue,UnitKey,UnitKey)" />
+    internal static QuantityValue GetValue<TQuantity>(this TQuantity quantity, UnitKey toUnit)
         where TQuantity : IQuantity
     {
-        return quantity.As(toUnit);
+        return UnitConverter.Default.ConvertValue(quantity, toUnit);
+    }
+
+    /// <inheritdoc cref="UnitConverter.ConvertValue(QuantityValue,UnitKey,UnitKey)" />
+    internal static QuantityValue ConvertValue<TQuantity>(this UnitConverter converter, TQuantity quantity, UnitKey toUnit)
+        where TQuantity : IQuantity
+    {
+        return converter.ConvertValue(quantity.Value, quantity.UnitKey, toUnit);
+    }
+
+    /// <inheritdoc cref="UnitConverter.ConvertToUnit{TQuantity,TUnit}" />
+    internal static TQuantity ConvertToUnit<TQuantity>(this UnitConverter converter, TQuantity quantity, UnitKey toUnit)
+        where TQuantity : IQuantityOfType<TQuantity>
+    {
+        QuantityValue convertedValue = converter.ConvertValue(quantity.Value, quantity.UnitKey, toUnit);
+#if NET
+        return TQuantity.Create(convertedValue, toUnit);
+#else
+        return quantity.QuantityInfo.Create(convertedValue, toUnit);
+#endif
+    }
+    
+    /// <inheritdoc cref="UnitConverter.ConvertValue{TQuantity,TUnit}" />
+    public static QuantityValue As<TQuantity, TUnit>(this TQuantity quantity, TUnit unit)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        return UnitConverter.Default.ConvertValue(quantity, unit);
+    }
+
+    /// <inheritdoc cref="UnitConverter.ConvertValue{TQuantity,TUnit}" />
+    /// <param name="quantity">The quantity to convert.</param>
+    /// <param name="unit">The target unit.</param>
+    /// <param name="unitConverter">The converter to use.</param>
+    public static QuantityValue As<TQuantity, TUnit>(this TQuantity quantity, TUnit unit, UnitConverter unitConverter)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        if (unitConverter is null)
+        {
+            throw new ArgumentNullException(nameof(unitConverter));
+        }
+
+        return unitConverter.ConvertValue(quantity, unit);
     }
 
     /// <summary>
-    ///     Converts the quantity to a value in the unit determined by the specified <see cref="UnitSystem" />.
-    ///     If multiple units are found for the given <see cref="UnitSystem" />, the first match will be used.
+    ///     Gets the value in the unit determined by the given <see cref="UnitSystem" />. If multiple units were found for the
+    ///     given <see cref="UnitSystem" />,
+    ///     the first match will be used.
     /// </summary>
-    /// <typeparam name="TQuantity">The type of the quantity being converted.</typeparam>
-    /// <param name="quantity">The quantity to convert.</param>
-    /// <param name="unitSystem">The <see cref="UnitSystem" /> to which the quantity value should be converted.</param>
-    /// <returns>The value of the quantity in the specified unit system.</returns>
-    /// <exception cref="ArgumentNullException">
-    ///     Thrown if <paramref name="unitSystem" /> is <c>null</c>.
-    /// </exception>
-    /// <exception cref="InvalidOperationException">
-    ///     Thrown if no matching unit is found for the given <see cref="UnitSystem" />.
-    /// </exception>
-    public static double As<TQuantity>(this TQuantity quantity, UnitSystem unitSystem)
+    /// <param name="quantity"></param>
+    /// <param name="unitSystem">The <see cref="UnitSystem" /> to convert the quantity value to.</param>
+    /// <returns>The converted value.</returns>
+    public static QuantityValue As<TQuantity>(this TQuantity quantity, UnitSystem unitSystem)
         where TQuantity : IQuantity
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         return quantity.GetValue(quantity.QuantityInfo.GetDefaultUnit(unitSystem).UnitKey);
+#pragma warning restore CS0618 // Type or member is obsolete
     }
 
-    /// <summary>
-    ///     Converts the specified quantity to a new quantity with a unit determined by the given <see cref="UnitSystem" />.
-    /// </summary>
-    /// <typeparam name="TQuantity">
-    ///     The type of the quantity to be converted. Must implement <see cref="IQuantityOfType{TQuantity}" />.
-    /// </typeparam>
-    /// <param name="quantity">The quantity to convert.</param>
-    /// <param name="unitSystem">The <see cref="UnitSystem" /> used to determine the target unit.</param>
-    /// <returns>
-    ///     A new quantity of type <typeparamref name="TQuantity" /> with the unit determined by the specified
-    ///     <see cref="UnitSystem" />.
-    /// </returns>
-    /// <remarks>
-    ///     If multiple units are associated with the given <see cref="UnitSystem" />, the first matching unit will be used.
-    /// </remarks>
-    /// <exception cref="ArgumentNullException">
-    ///     Thrown if <paramref name="unitSystem" /> is <c>null</c>.
-    /// </exception>
-    /// <exception cref="InvalidOperationException">
-    ///     Thrown if no matching unit is found for the specified <see cref="UnitSystem" />.
-    /// </exception>
+    /// <inheritdoc cref="UnitConverter.ConvertToUnit{TQuantity,TUnit}" />
+    public static TQuantity ToUnit<TQuantity, TUnit>(this TQuantity quantity, TUnit unit)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        return UnitConverter.Default.ConvertToUnit(quantity, unit);
+    }
+
+    /// <inheritdoc cref="UnitConverter.ConvertToUnit{TQuantity,TUnit}" />
+    public static TQuantity ToUnit<TQuantity, TUnit>(this TQuantity quantity, TUnit unit, UnitConverter unitConverter)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        if (unitConverter is null)
+        {
+            throw new ArgumentNullException(nameof(unitConverter));
+        }
+
+        return unitConverter.ConvertToUnit(quantity, unit);
+    }
+
+    /// <inheritdoc cref="UnitConverter.ConvertToUnit{TQuantity,TUnit}" />
     public static TQuantity ToUnit<TQuantity>(this TQuantity quantity, UnitSystem unitSystem)
         where TQuantity : IQuantityOfType<TQuantity>
     {
 #if NET
-        QuantityInfo quantityInfo = quantity.QuantityInfo;
-        UnitKey unitKey = quantityInfo.GetDefaultUnit(unitSystem).UnitKey;
-        return TQuantity.Create(quantity.As(unitKey), unitKey);
+        QuantityInfo quantityInfo = TQuantity.Info;
 #else
         QuantityInfo quantityInfo = ((IQuantity)quantity).QuantityInfo;
-        UnitKey unitKey = quantityInfo.GetDefaultUnit(unitSystem).UnitKey;
-        return quantity.QuantityInfo.Create(quantity.As(unitKey), unitKey);
 #endif
+        return UnitConverter.Default.ConvertToUnit(quantity, quantityInfo.GetDefaultUnit(unitSystem).UnitKey);
+    }
+    
+    /// <inheritdoc cref="UnitConverter.ConvertValue(QuantityValue,UnitKey,UnitKey)" />
+    [Obsolete("This method will be removed in the next major update. Consider using the UnitConverter.Default.ConvertValue(quantity, unit) method instead.")]
+    public static QuantityValue As(this IQuantity quantity, UnitKey unit)
+    {
+        return UnitConverter.Default.ConvertValue(quantity, unit);
+    }
+    
+    /// <inheritdoc cref="UnitConverter.ConvertTo{TQuantity}" />
+    [Obsolete("This method will be removed in the next major update. Consider using the UnitConverter.Default.ConvertTo(quantity, unit) method instead.")]
+    public static IQuantity ToUnit(this IQuantity quantity, UnitKey unit)
+    {
+         return UnitConverter.Default.ConvertTo(quantity, unit);
+    }
+    
+    /// <summary>
+    ///     Converts this <see cref="IQuantity{TUnitType}"/> to an <see cref="IQuantity{TUnitType}"/> in the given <paramref name="unit"/>.
+    /// </summary>
+    /// <param name="quantity">The quantity to convert.</param>
+    /// <param name="unit">The unit value.</param>
+    /// <exception cref="UnitNotFoundException">Thrown when the <paramref name="unit" /> is not recognized.</exception>
+    /// <returns>A new <see cref="IQuantity{TUnitType}"/> in the given <paramref name="unit"/>.</returns>
+    [Obsolete("This method will be removed in the next major update. Consider using the UnitConverter.Default.ConvertToUnit(quantity, unit) method instead.")]
+    public static IQuantity<TUnit> ToUnit<TUnit>(this IQuantity<TUnit> quantity, TUnit unit)
+        where TUnit : struct, Enum
+    {
+        QuantityValue convertedValue = UnitConverter.Default.ConvertValue(quantity.Value, quantity.Unit, unit);
+        return quantity.QuantityInfo.From(convertedValue, unit);
     }
 
     /// <summary>
@@ -127,12 +223,10 @@ public static TQuantity ToUnit<TQuantity>(this TQuantity quantity, UnitSystem un
     /// <exception cref="InvalidOperationException">
     ///     Thrown if no matching unit is found for the specified <see cref="UnitSystem" />.
     /// </exception>
-    [Obsolete("This method will be removed from the interface in the next major update.")]
+    [Obsolete("This method will be removed in the next major update. Consider using the UnitConverter.Default.ConvertTo(quantity, unit) method instead.")]
     public static IQuantity ToUnit(this IQuantity quantity, UnitSystem unitSystem)
     {
-         QuantityInfo quantityInfo = quantity.QuantityInfo;
-         UnitKey unitKey = quantityInfo.GetDefaultUnit(unitSystem).UnitKey;
-         return quantityInfo.From(quantity.As(unitKey), unitKey);
+         return UnitConverter.Default.ConvertTo(quantity, quantity.QuantityInfo.GetDefaultUnit(unitSystem).UnitKey);
     }
 
     /// <summary>
@@ -152,13 +246,14 @@ public static IQuantity ToUnit(this IQuantity quantity, UnitSystem unitSystem)
     /// <exception cref="InvalidOperationException">
     ///     Thrown if no matching unit is found for the specified <see cref="UnitSystem" />.
     /// </exception>
-    [Obsolete("This method will be removed from the interface in the next major update.")]
+    [Obsolete("This method will be removed in the next major update. Consider using the UnitConverter.Default.ConvertToUnit(quantity, unit) method instead.")]
     public static IQuantity<TUnit> ToUnit<TUnit>(this IQuantity<TUnit> quantity, UnitSystem unitSystem)
         where TUnit : struct, Enum
     {
          QuantityInfo<TUnit> quantityInfo = quantity.QuantityInfo;
-         TUnit unit = quantityInfo.GetDefaultUnit(unitSystem);
-         return quantityInfo.From(quantity.As(unit), unit);
+         UnitInfo<TUnit> targetUnitInfo = quantityInfo.GetDefaultUnit(unitSystem);
+         QuantityValue convertedValue = UnitConverter.Default.ConvertValue(quantity.Value, quantity.Unit, targetUnitInfo.Value);
+         return quantityInfo.From(convertedValue, targetUnitInfo.Value);
     }
 
     /// <summary>
@@ -193,7 +288,9 @@ public static string ToString<TQuantity>(this TQuantity quantity, IFormatProvide
     ///     If <c>null</c> or empty, the default format is used.
     /// </param>
     /// <returns>A string representation of the quantity.</returns>
-    public static string ToString<TQuantity>(this TQuantity quantity, string? format)
+    public static string ToString<TQuantity>(
+        this TQuantity quantity,
+        [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format)
         where TQuantity : IQuantity, IFormattable
     {
         return quantity.ToString(format, null);
@@ -223,7 +320,7 @@ internal static TQuantity ArithmeticMean<TQuantity>(this IEnumerable<TQuantity>
 
         TQuantity firstQuantity = enumerator.Current!;
         UnitKey resultUnit = firstQuantity.UnitKey;
-        var sumOfValues = firstQuantity.Value;
+        QuantityValue sumOfValues = firstQuantity.Value;
         var nbValues = 1;
         while (enumerator.MoveNext())
         {
@@ -269,7 +366,7 @@ internal static TQuantity ArithmeticMean<TQuantity, TUnit>(this IEnumerable<TQua
 
         TQuantity firstQuantity = enumerator.Current!;
         var unitKey = UnitKey.ForUnit(unit);
-        var sumOfValues = firstQuantity.GetValue(unitKey);
+        QuantityValue sumOfValues = firstQuantity.GetValue(unitKey);
         var nbValues = 1;
         while (enumerator.MoveNext())
         {
@@ -277,6 +374,10 @@ internal static TQuantity ArithmeticMean<TQuantity, TUnit>(this IEnumerable<TQua
             nbValues++;
         }
 
+#if NET
+        return TQuantity.From(sumOfValues / nbValues, unit);
+#else
         return firstQuantity.QuantityInfo.From(sumOfValues / nbValues, unit);
+#endif
     }
 }
diff --git a/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs b/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
index d9f4ac2066..f4fd3d7330 100644
--- a/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Absorbed_dose
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct AbsorbedDoseOfIonizingRadiation :
-        IArithmeticQuantity<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiationUnit>,
+        ILinearQuantity<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiationUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiation, double>,
+        IDivisionOperators<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiation, QuantityValue>,
+        IMultiplyOperators<AbsorbedDoseOfIonizingRadiation, Area, DoseAreaProduct>,
         IComparisonOperators<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiation, bool>,
         IParsable<AbsorbedDoseOfIonizingRadiation>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static AbsorbedDoseOfIonizingRadiationInfo CreateDefault(Func<IEnumerable
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="AbsorbedDoseOfIonizingRadiation"/> is [T^-2][L^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="AbsorbedDoseOfIonizingRadiation"/> is T^-2L^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 0, -2, 0, 0, 0, 0);
 
@@ -120,31 +120,61 @@ public static AbsorbedDoseOfIonizingRadiationInfo CreateDefault(Func<IEnumerable
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{AbsorbedDoseOfIonizingRadiationUnit}"/> representing the default unit mappings for AbsorbedDoseOfIonizingRadiation.</returns>
             public static IEnumerable<UnitDefinition<AbsorbedDoseOfIonizingRadiationUnit>> GetDefaultMappings()
             {
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Centigray, "Centigray", "Centigrays", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Second));
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Decigray, "Decigray", "Decigrays", BaseUnits.Undefined);
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Femtogray, "Femtogray", "Femtograys", BaseUnits.Undefined);
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Gigagray, "Gigagray", "Gigagrays", BaseUnits.Undefined);
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Centigray, "Centigray", "Centigrays", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Second),
+                     100
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Decigray, "Decigray", "Decigrays", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Femtogray, "Femtogray", "Femtograys", BaseUnits.Undefined,
+                     1000000000000000
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Gigagray, "Gigagray", "Gigagrays", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
                 yield return new (AbsorbedDoseOfIonizingRadiationUnit.Gray, "Gray", "Grays", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Kilogray, "Kilogray", "Kilograys", BaseUnits.Undefined);
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Kilorad, "Kilorad", "Kilorads", BaseUnits.Undefined);
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Megagray, "Megagray", "Megagrays", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second));
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Megarad, "Megarad", "Megarads", BaseUnits.Undefined);
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Microgray, "Microgray", "Micrograys", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second));
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Milligray, "Milligray", "Milligrays", BaseUnits.Undefined);
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Millirad, "Millirad", "Millirads", BaseUnits.Undefined);
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Nanogray, "Nanogray", "Nanograys", BaseUnits.Undefined);
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Petagray, "Petagray", "Petagrays", BaseUnits.Undefined);
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Picogray, "Picogray", "Picograys", new BaseUnits(length: LengthUnit.Micrometer, time: DurationUnit.Second));
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Rad, "Rad", "Rads", BaseUnits.Undefined);
-                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Teragray, "Teragray", "Teragrays", new BaseUnits(length: LengthUnit.Megameter, time: DurationUnit.Second));
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Kilogray, "Kilogray", "Kilograys", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Kilorad, "Kilorad", "Kilorads", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Megagray, "Megagray", "Megagrays", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Megarad, "Megarad", "Megarads", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Microgray, "Microgray", "Micrograys", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Milligray, "Milligray", "Milligrays", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Millirad, "Millirad", "Millirads", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Nanogray, "Nanogray", "Nanograys", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Petagray, "Petagray", "Petagrays", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000)
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Picogray, "Picogray", "Picograys", new BaseUnits(length: LengthUnit.Micrometer, time: DurationUnit.Second),
+                     1000000000000
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Rad, "Rad", "Rads", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (AbsorbedDoseOfIonizingRadiationUnit.Teragray, "Teragray", "Teragrays", new BaseUnits(length: LengthUnit.Megameter, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000000)
+                );
             }
         }
 
         static AbsorbedDoseOfIonizingRadiation()
         {
-            Info = AbsorbedDoseOfIonizingRadiationInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(AbsorbedDoseOfIonizingRadiationInfo.CreateDefault);
         }
 
         /// <summary>
@@ -152,7 +182,7 @@ static AbsorbedDoseOfIonizingRadiation()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public AbsorbedDoseOfIonizingRadiation(double value, AbsorbedDoseOfIonizingRadiationUnit unit)
+        public AbsorbedDoseOfIonizingRadiation(QuantityValue value, AbsorbedDoseOfIonizingRadiationUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -166,7 +196,7 @@ public AbsorbedDoseOfIonizingRadiation(double value, AbsorbedDoseOfIonizingRadia
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public AbsorbedDoseOfIonizingRadiation(double value, UnitSystem unitSystem)
+        public AbsorbedDoseOfIonizingRadiation(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -177,7 +207,8 @@ public AbsorbedDoseOfIonizingRadiation(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="AbsorbedDoseOfIonizingRadiation" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiationUnit> Info { get; }
@@ -206,10 +237,8 @@ public AbsorbedDoseOfIonizingRadiation(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public AbsorbedDoseOfIonizingRadiationUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -243,140 +272,94 @@ public AbsorbedDoseOfIonizingRadiation(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Centigray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Centigray"/>
         /// </summary>
-        public double Centigrays => As(AbsorbedDoseOfIonizingRadiationUnit.Centigray);
+        public QuantityValue Centigrays => this.As(AbsorbedDoseOfIonizingRadiationUnit.Centigray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Decigray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Decigray"/>
         /// </summary>
-        public double Decigrays => As(AbsorbedDoseOfIonizingRadiationUnit.Decigray);
+        public QuantityValue Decigrays => this.As(AbsorbedDoseOfIonizingRadiationUnit.Decigray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Femtogray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Femtogray"/>
         /// </summary>
-        public double Femtograys => As(AbsorbedDoseOfIonizingRadiationUnit.Femtogray);
+        public QuantityValue Femtograys => this.As(AbsorbedDoseOfIonizingRadiationUnit.Femtogray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gigagray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gigagray"/>
         /// </summary>
-        public double Gigagrays => As(AbsorbedDoseOfIonizingRadiationUnit.Gigagray);
+        public QuantityValue Gigagrays => this.As(AbsorbedDoseOfIonizingRadiationUnit.Gigagray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gray"/>
         /// </summary>
-        public double Grays => As(AbsorbedDoseOfIonizingRadiationUnit.Gray);
+        public QuantityValue Grays => this.As(AbsorbedDoseOfIonizingRadiationUnit.Gray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilogray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilogray"/>
         /// </summary>
-        public double Kilograys => As(AbsorbedDoseOfIonizingRadiationUnit.Kilogray);
+        public QuantityValue Kilograys => this.As(AbsorbedDoseOfIonizingRadiationUnit.Kilogray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilorad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilorad"/>
         /// </summary>
-        public double Kilorads => As(AbsorbedDoseOfIonizingRadiationUnit.Kilorad);
+        public QuantityValue Kilorads => this.As(AbsorbedDoseOfIonizingRadiationUnit.Kilorad);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megagray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megagray"/>
         /// </summary>
-        public double Megagrays => As(AbsorbedDoseOfIonizingRadiationUnit.Megagray);
+        public QuantityValue Megagrays => this.As(AbsorbedDoseOfIonizingRadiationUnit.Megagray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megarad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megarad"/>
         /// </summary>
-        public double Megarads => As(AbsorbedDoseOfIonizingRadiationUnit.Megarad);
+        public QuantityValue Megarads => this.As(AbsorbedDoseOfIonizingRadiationUnit.Megarad);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Microgray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Microgray"/>
         /// </summary>
-        public double Micrograys => As(AbsorbedDoseOfIonizingRadiationUnit.Microgray);
+        public QuantityValue Micrograys => this.As(AbsorbedDoseOfIonizingRadiationUnit.Microgray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Milligray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Milligray"/>
         /// </summary>
-        public double Milligrays => As(AbsorbedDoseOfIonizingRadiationUnit.Milligray);
+        public QuantityValue Milligrays => this.As(AbsorbedDoseOfIonizingRadiationUnit.Milligray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Millirad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Millirad"/>
         /// </summary>
-        public double Millirads => As(AbsorbedDoseOfIonizingRadiationUnit.Millirad);
+        public QuantityValue Millirads => this.As(AbsorbedDoseOfIonizingRadiationUnit.Millirad);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Nanogray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Nanogray"/>
         /// </summary>
-        public double Nanograys => As(AbsorbedDoseOfIonizingRadiationUnit.Nanogray);
+        public QuantityValue Nanograys => this.As(AbsorbedDoseOfIonizingRadiationUnit.Nanogray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Petagray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Petagray"/>
         /// </summary>
-        public double Petagrays => As(AbsorbedDoseOfIonizingRadiationUnit.Petagray);
+        public QuantityValue Petagrays => this.As(AbsorbedDoseOfIonizingRadiationUnit.Petagray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Picogray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Picogray"/>
         /// </summary>
-        public double Picograys => As(AbsorbedDoseOfIonizingRadiationUnit.Picogray);
+        public QuantityValue Picograys => this.As(AbsorbedDoseOfIonizingRadiationUnit.Picogray);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Rad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Rad"/>
         /// </summary>
-        public double Rads => As(AbsorbedDoseOfIonizingRadiationUnit.Rad);
+        public QuantityValue Rads => this.As(AbsorbedDoseOfIonizingRadiationUnit.Rad);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Teragray"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AbsorbedDoseOfIonizingRadiationUnit.Teragray"/>
         /// </summary>
-        public double Teragrays => As(AbsorbedDoseOfIonizingRadiationUnit.Teragray);
+        public QuantityValue Teragrays => this.As(AbsorbedDoseOfIonizingRadiationUnit.Teragray);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: AbsorbedDoseOfIonizingRadiationUnit -> BaseUnit
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Centigray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Decigray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Femtogray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gigagray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Kilogray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Kilorad, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Megagray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Megarad, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Microgray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Milligray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Millirad, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Nanogray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Petagray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Picogray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Rad, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Teragray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gray));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Gray, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> AbsorbedDoseOfIonizingRadiationUnit
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Centigray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Centigray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Decigray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Decigray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Femtogray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Femtogray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Gigagray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Gigagray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Kilogray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Kilogray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Kilorad, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Kilorad));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Megagray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Megagray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Megarad, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Megarad));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Microgray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Microgray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Milligray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Milligray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Millirad, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Millirad));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Nanogray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Nanogray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Petagray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Petagray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Picogray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Picogray));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Rad, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Rad));
-            unitConverter.SetConversionFunction<AbsorbedDoseOfIonizingRadiation>(AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Teragray, quantity => quantity.ToUnit(AbsorbedDoseOfIonizingRadiationUnit.Teragray));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -405,7 +388,7 @@ public static string GetAbbreviation(AbsorbedDoseOfIonizingRadiationUnit unit, I
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Centigray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromCentigrays(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromCentigrays(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Centigray);
         }
@@ -413,7 +396,7 @@ public static AbsorbedDoseOfIonizingRadiation FromCentigrays(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Decigray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromDecigrays(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromDecigrays(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Decigray);
         }
@@ -421,7 +404,7 @@ public static AbsorbedDoseOfIonizingRadiation FromDecigrays(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Femtogray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromFemtograys(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromFemtograys(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Femtogray);
         }
@@ -429,7 +412,7 @@ public static AbsorbedDoseOfIonizingRadiation FromFemtograys(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gigagray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromGigagrays(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromGigagrays(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Gigagray);
         }
@@ -437,7 +420,7 @@ public static AbsorbedDoseOfIonizingRadiation FromGigagrays(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromGrays(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromGrays(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Gray);
         }
@@ -445,7 +428,7 @@ public static AbsorbedDoseOfIonizingRadiation FromGrays(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilogray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromKilograys(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromKilograys(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Kilogray);
         }
@@ -453,7 +436,7 @@ public static AbsorbedDoseOfIonizingRadiation FromKilograys(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilorad"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromKilorads(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromKilorads(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Kilorad);
         }
@@ -461,7 +444,7 @@ public static AbsorbedDoseOfIonizingRadiation FromKilorads(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megagray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromMegagrays(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromMegagrays(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Megagray);
         }
@@ -469,7 +452,7 @@ public static AbsorbedDoseOfIonizingRadiation FromMegagrays(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megarad"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromMegarads(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromMegarads(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Megarad);
         }
@@ -477,7 +460,7 @@ public static AbsorbedDoseOfIonizingRadiation FromMegarads(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Microgray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromMicrograys(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromMicrograys(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Microgray);
         }
@@ -485,7 +468,7 @@ public static AbsorbedDoseOfIonizingRadiation FromMicrograys(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Milligray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromMilligrays(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromMilligrays(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Milligray);
         }
@@ -493,7 +476,7 @@ public static AbsorbedDoseOfIonizingRadiation FromMilligrays(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Millirad"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromMillirads(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromMillirads(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Millirad);
         }
@@ -501,7 +484,7 @@ public static AbsorbedDoseOfIonizingRadiation FromMillirads(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Nanogray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromNanograys(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromNanograys(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Nanogray);
         }
@@ -509,7 +492,7 @@ public static AbsorbedDoseOfIonizingRadiation FromNanograys(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Petagray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromPetagrays(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromPetagrays(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Petagray);
         }
@@ -517,7 +500,7 @@ public static AbsorbedDoseOfIonizingRadiation FromPetagrays(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Picogray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromPicograys(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromPicograys(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Picogray);
         }
@@ -525,7 +508,7 @@ public static AbsorbedDoseOfIonizingRadiation FromPicograys(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Rad"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromRads(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromRads(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Rad);
         }
@@ -533,7 +516,7 @@ public static AbsorbedDoseOfIonizingRadiation FromRads(double value)
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Teragray"/>.
         /// </summary>
-        public static AbsorbedDoseOfIonizingRadiation FromTeragrays(double value)
+        public static AbsorbedDoseOfIonizingRadiation FromTeragrays(QuantityValue value)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Teragray);
         }
@@ -544,7 +527,7 @@ public static AbsorbedDoseOfIonizingRadiation FromTeragrays(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>AbsorbedDoseOfIonizingRadiation unit value.</returns>
-        public static AbsorbedDoseOfIonizingRadiation From(double value, AbsorbedDoseOfIonizingRadiationUnit fromUnit)
+        public static AbsorbedDoseOfIonizingRadiation From(QuantityValue value, AbsorbedDoseOfIonizingRadiationUnit fromUnit)
         {
             return new AbsorbedDoseOfIonizingRadiation(value, fromUnit);
         }
@@ -605,10 +588,7 @@ public static AbsorbedDoseOfIonizingRadiation Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static AbsorbedDoseOfIonizingRadiation Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiationUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiationUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -636,11 +616,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out AbsorbedDoseOfIo
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out AbsorbedDoseOfIonizingRadiation result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiationUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiationUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -661,7 +637,7 @@ public static AbsorbedDoseOfIonizingRadiationUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -672,7 +648,7 @@ public static AbsorbedDoseOfIonizingRadiationUnit ParseUnit(string str, IFormatP
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AbsorbedDoseOfIonizingRadiationUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.AbsorbedDoseOfIonizingRadiationUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out AbsorbedDoseOfIonizingRadiationUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -687,7 +663,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AbsorbedDose
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out AbsorbedDoseOfIonizingRadiationUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -706,137 +682,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="AbsorbedDoseOfIonizingRadiation"/> from adding two <see cref="AbsorbedDoseOfIonizingRadiation"/>.</summary>
         public static AbsorbedDoseOfIonizingRadiation operator +(AbsorbedDoseOfIonizingRadiation left, AbsorbedDoseOfIonizingRadiation right)
         {
-            return new AbsorbedDoseOfIonizingRadiation(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new AbsorbedDoseOfIonizingRadiation(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="AbsorbedDoseOfIonizingRadiation"/> from subtracting two <see cref="AbsorbedDoseOfIonizingRadiation"/>.</summary>
         public static AbsorbedDoseOfIonizingRadiation operator -(AbsorbedDoseOfIonizingRadiation left, AbsorbedDoseOfIonizingRadiation right)
         {
-            return new AbsorbedDoseOfIonizingRadiation(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new AbsorbedDoseOfIonizingRadiation(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="AbsorbedDoseOfIonizingRadiation"/> from multiplying value and <see cref="AbsorbedDoseOfIonizingRadiation"/>.</summary>
-        public static AbsorbedDoseOfIonizingRadiation operator *(double left, AbsorbedDoseOfIonizingRadiation right)
+        public static AbsorbedDoseOfIonizingRadiation operator *(QuantityValue left, AbsorbedDoseOfIonizingRadiation right)
         {
             return new AbsorbedDoseOfIonizingRadiation(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="AbsorbedDoseOfIonizingRadiation"/> from multiplying value and <see cref="AbsorbedDoseOfIonizingRadiation"/>.</summary>
-        public static AbsorbedDoseOfIonizingRadiation operator *(AbsorbedDoseOfIonizingRadiation left, double right)
+        public static AbsorbedDoseOfIonizingRadiation operator *(AbsorbedDoseOfIonizingRadiation left, QuantityValue right)
         {
             return new AbsorbedDoseOfIonizingRadiation(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="AbsorbedDoseOfIonizingRadiation"/> from dividing <see cref="AbsorbedDoseOfIonizingRadiation"/> by value.</summary>
-        public static AbsorbedDoseOfIonizingRadiation operator /(AbsorbedDoseOfIonizingRadiation left, double right)
+        public static AbsorbedDoseOfIonizingRadiation operator /(AbsorbedDoseOfIonizingRadiation left, QuantityValue right)
         {
             return new AbsorbedDoseOfIonizingRadiation(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="AbsorbedDoseOfIonizingRadiation"/> by <see cref="AbsorbedDoseOfIonizingRadiation"/>.</summary>
-        public static double operator /(AbsorbedDoseOfIonizingRadiation left, AbsorbedDoseOfIonizingRadiation right)
+        public static QuantityValue operator /(AbsorbedDoseOfIonizingRadiation left, AbsorbedDoseOfIonizingRadiation right)
         {
             return left.Grays / right.Grays;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="DoseAreaProduct"/> from <see cref="AbsorbedDoseOfIonizingRadiation"/> * <see cref="Area"/>.</summary>
+        public static DoseAreaProduct operator *(AbsorbedDoseOfIonizingRadiation absorbedDoseOfIonizingRadiation, Area area)
+        {
+            return DoseAreaProduct.FromGraySquareMeters(absorbedDoseOfIonizingRadiation.Grays * area.SquareMeters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(AbsorbedDoseOfIonizingRadiation left, AbsorbedDoseOfIonizingRadiation right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(AbsorbedDoseOfIonizingRadiation left, AbsorbedDoseOfIonizingRadiation right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(AbsorbedDoseOfIonizingRadiation left, AbsorbedDoseOfIonizingRadiation right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(AbsorbedDoseOfIonizingRadiation left, AbsorbedDoseOfIonizingRadiation right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="AbsorbedDoseOfIonizingRadiation"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(AbsorbedDoseOfIonizingRadiation other, AbsorbedDoseOfIonizingRadiation tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="AbsorbedDoseOfIonizingRadiation"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(AbsorbedDoseOfIonizingRadiation)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(AbsorbedDoseOfIonizingRadiation left, AbsorbedDoseOfIonizingRadiation right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="AbsorbedDoseOfIonizingRadiation"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(AbsorbedDoseOfIonizingRadiation other, AbsorbedDoseOfIonizingRadiation tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="AbsorbedDoseOfIonizingRadiation"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(AbsorbedDoseOfIonizingRadiation,AbsorbedDoseOfIonizingRadiation)"/>.
+        ///     See that operator (and <see cref="Equals(AbsorbedDoseOfIonizingRadiation)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(AbsorbedDoseOfIonizingRadiation left, AbsorbedDoseOfIonizingRadiation right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="AbsorbedDoseOfIonizingRadiation"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(AbsorbedDoseOfIonizingRadiation other, AbsorbedDoseOfIonizingRadiation tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="AbsorbedDoseOfIonizingRadiation"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="AbsorbedDoseOfIonizingRadiation"/>.
+        ///     When <paramref name="obj"/> is a <see cref="AbsorbedDoseOfIonizingRadiation"/>, this method delegates to
+        ///     <see cref="Equals(AbsorbedDoseOfIonizingRadiation)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is AbsorbedDoseOfIonizingRadiation otherQuantity))
+            if (obj is not AbsorbedDoseOfIonizingRadiation otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="AbsorbedDoseOfIonizingRadiation"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(AbsorbedDoseOfIonizingRadiation other, AbsorbedDoseOfIonizingRadiation tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="AbsorbedDoseOfIonizingRadiation"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(AbsorbedDoseOfIonizingRadiation other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current AbsorbedDoseOfIonizingRadiation.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(AbsorbedDoseOfIonizingRadiation), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="AbsorbedDoseOfIonizingRadiation"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(AbsorbedDoseOfIonizingRadiation)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is AbsorbedDoseOfIonizingRadiation otherQuantity)) throw new ArgumentException("Expected type AbsorbedDoseOfIonizingRadiation.", nameof(obj));
+            if (obj is not AbsorbedDoseOfIonizingRadiation otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<AbsorbedDoseOfIonizingRadiation>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="AbsorbedDoseOfIonizingRadiation"/> with another <see cref="AbsorbedDoseOfIonizingRadiation"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="AbsorbedDoseOfIonizingRadiation"/> with another <see cref="AbsorbedDoseOfIonizingRadiation"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -848,161 +848,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(AbsorbedDoseOfIonizingRadiation other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(AbsorbedDoseOfIonizingRadiationUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<AbsorbedDoseOfIonizingRadiationUnit>());
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this AbsorbedDoseOfIonizingRadiation to another AbsorbedDoseOfIonizingRadiation with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A AbsorbedDoseOfIonizingRadiation with the specified unit.</returns>
-        public AbsorbedDoseOfIonizingRadiation ToUnit(AbsorbedDoseOfIonizingRadiationUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="AbsorbedDoseOfIonizingRadiation"/> to another <see cref="AbsorbedDoseOfIonizingRadiation"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A AbsorbedDoseOfIonizingRadiation with the specified unit.</returns>
-        public AbsorbedDoseOfIonizingRadiation ToUnit(AbsorbedDoseOfIonizingRadiationUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(AbsorbedDoseOfIonizingRadiation), Unit, typeof(AbsorbedDoseOfIonizingRadiation), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (AbsorbedDoseOfIonizingRadiation)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="AbsorbedDoseOfIonizingRadiation"/> to another <see cref="AbsorbedDoseOfIonizingRadiation"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="AbsorbedDoseOfIonizingRadiation"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(AbsorbedDoseOfIonizingRadiationUnit unit, [NotNullWhen(true)] out AbsorbedDoseOfIonizingRadiation? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            AbsorbedDoseOfIonizingRadiation? convertedOrNull = (Unit, unit) switch
-            {
-                // AbsorbedDoseOfIonizingRadiationUnit -> BaseUnit
-                (AbsorbedDoseOfIonizingRadiationUnit.Centigray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e-2d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Decigray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e-1d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Femtogray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e-15d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gigagray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e9d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Kilogray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e3d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Kilorad, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value / 100) * 1e3d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Megagray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e6d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Megarad, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value / 100) * 1e6d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Microgray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e-6d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Milligray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e-3d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Millirad, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value / 100) * 1e-3d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Nanogray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e-9d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Petagray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e15d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Picogray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e-12d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Rad, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation(_value / 100, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Teragray, AbsorbedDoseOfIonizingRadiationUnit.Gray) => new AbsorbedDoseOfIonizingRadiation((_value) * 1e12d, AbsorbedDoseOfIonizingRadiationUnit.Gray),
-
-                // BaseUnit -> AbsorbedDoseOfIonizingRadiationUnit
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Centigray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e-2d, AbsorbedDoseOfIonizingRadiationUnit.Centigray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Decigray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e-1d, AbsorbedDoseOfIonizingRadiationUnit.Decigray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Femtogray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e-15d, AbsorbedDoseOfIonizingRadiationUnit.Femtogray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Gigagray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e9d, AbsorbedDoseOfIonizingRadiationUnit.Gigagray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Kilogray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e3d, AbsorbedDoseOfIonizingRadiationUnit.Kilogray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Kilorad) => new AbsorbedDoseOfIonizingRadiation((_value * 100) / 1e3d, AbsorbedDoseOfIonizingRadiationUnit.Kilorad),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Megagray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e6d, AbsorbedDoseOfIonizingRadiationUnit.Megagray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Megarad) => new AbsorbedDoseOfIonizingRadiation((_value * 100) / 1e6d, AbsorbedDoseOfIonizingRadiationUnit.Megarad),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Microgray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e-6d, AbsorbedDoseOfIonizingRadiationUnit.Microgray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Milligray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e-3d, AbsorbedDoseOfIonizingRadiationUnit.Milligray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Millirad) => new AbsorbedDoseOfIonizingRadiation((_value * 100) / 1e-3d, AbsorbedDoseOfIonizingRadiationUnit.Millirad),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Nanogray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e-9d, AbsorbedDoseOfIonizingRadiationUnit.Nanogray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Petagray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e15d, AbsorbedDoseOfIonizingRadiationUnit.Petagray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Picogray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e-12d, AbsorbedDoseOfIonizingRadiationUnit.Picogray),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Rad) => new AbsorbedDoseOfIonizingRadiation(_value * 100, AbsorbedDoseOfIonizingRadiationUnit.Rad),
-                (AbsorbedDoseOfIonizingRadiationUnit.Gray, AbsorbedDoseOfIonizingRadiationUnit.Teragray) => new AbsorbedDoseOfIonizingRadiation((_value) / 1e12d, AbsorbedDoseOfIonizingRadiationUnit.Teragray),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not AbsorbedDoseOfIonizingRadiationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AbsorbedDoseOfIonizingRadiationUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is AbsorbedDoseOfIonizingRadiationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AbsorbedDoseOfIonizingRadiationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<AbsorbedDoseOfIonizingRadiationUnit> IQuantity<AbsorbedDoseOfIonizingRadiationUnit>.ToUnit(AbsorbedDoseOfIonizingRadiationUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1016,11 +864,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
index 83b6c6add3..debceb5f65 100644
--- a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,14 +33,17 @@ namespace UnitsNet
     ///     Acceleration, in physics, is the rate at which the velocity of an object changes over time. An object's acceleration is the net result of any and all forces acting on the object, as described by Newton's Second Law. The SI unit for acceleration is the Meter per second squared (m/s²). Accelerations are vector quantities (they have magnitude and direction) and add according to the parallelogram law. As a vector, the calculated net force is equal to the product of the object's mass (a scalar quantity) and the acceleration.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Acceleration :
-        IArithmeticQuantity<Acceleration, AccelerationUnit>,
+        ILinearQuantity<Acceleration, AccelerationUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Acceleration, Acceleration, double>,
+        IDivisionOperators<Acceleration, Acceleration, QuantityValue>,
         IDivisionOperators<Acceleration, Jerk, Duration>,
         IMultiplyOperators<Acceleration, Mass, Force>,
+        IMultiplyOperators<Acceleration, LinearDensity, ForcePerLength>,
         IDivisionOperators<Acceleration, Duration, Jerk>,
+        IMultiplyOperators<Acceleration, AreaDensity, Pressure>,
         IMultiplyOperators<Acceleration, Density, SpecificWeight>,
         IMultiplyOperators<Acceleration, Duration, Speed>,
         IComparisonOperators<Acceleration, Acceleration, bool>,
@@ -57,7 +58,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -107,7 +108,7 @@ public static AccelerationInfo CreateDefault(Func<IEnumerable<UnitDefinition<Acc
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Acceleration"/> is [T^-2][L].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Acceleration"/> is T^-2L.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 0, -2, 0, 0, 0, 0);
 
@@ -122,28 +123,52 @@ public static AccelerationInfo CreateDefault(Func<IEnumerable<UnitDefinition<Acc
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{AccelerationUnit}"/> representing the default unit mappings for Acceleration.</returns>
             public static IEnumerable<UnitDefinition<AccelerationUnit>> GetDefaultMappings()
             {
-                yield return new (AccelerationUnit.CentimeterPerSecondSquared, "CentimeterPerSecondSquared", "CentimetersPerSecondSquared", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Second));
-                yield return new (AccelerationUnit.DecimeterPerSecondSquared, "DecimeterPerSecondSquared", "DecimetersPerSecondSquared", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Second));
-                yield return new (AccelerationUnit.FootPerSecondSquared, "FootPerSecondSquared", "FeetPerSecondSquared", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second));
-                yield return new (AccelerationUnit.InchPerSecondSquared, "InchPerSecondSquared", "InchesPerSecondSquared", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Second));
-                yield return new (AccelerationUnit.KilometerPerSecondSquared, "KilometerPerSecondSquared", "KilometersPerSecondSquared", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second));
-                yield return new (AccelerationUnit.KnotPerHour, "KnotPerHour", "KnotsPerHour", new BaseUnits(length: LengthUnit.NauticalMile, time: DurationUnit.Hour));
-                yield return new (AccelerationUnit.KnotPerMinute, "KnotPerMinute", "KnotsPerMinute", new BaseUnits(length: LengthUnit.NauticalMile, time: DurationUnit.Minute));
-                yield return new (AccelerationUnit.KnotPerSecond, "KnotPerSecond", "KnotsPerSecond", new BaseUnits(length: LengthUnit.NauticalMile, time: DurationUnit.Second));
+                yield return new (AccelerationUnit.CentimeterPerSecondSquared, "CentimeterPerSecondSquared", "CentimetersPerSecondSquared", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Second),
+                     100
+                );
+                yield return new (AccelerationUnit.DecimeterPerSecondSquared, "DecimeterPerSecondSquared", "DecimetersPerSecondSquared", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (AccelerationUnit.FootPerSecondSquared, "FootPerSecondSquared", "FeetPerSecondSquared", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second),
+                     new QuantityValue(1250, 381)
+                );
+                yield return new (AccelerationUnit.InchPerSecondSquared, "InchPerSecondSquared", "InchesPerSecondSquared", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Second),
+                     new QuantityValue(5000, 127)
+                );
+                yield return new (AccelerationUnit.KilometerPerSecondSquared, "KilometerPerSecondSquared", "KilometersPerSecondSquared", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (AccelerationUnit.KnotPerHour, "KnotPerHour", "KnotsPerHour", new BaseUnits(length: LengthUnit.NauticalMile, time: DurationUnit.Hour),
+                     new QuantityValue(3240000, 463)
+                );
+                yield return new (AccelerationUnit.KnotPerMinute, "KnotPerMinute", "KnotsPerMinute", new BaseUnits(length: LengthUnit.NauticalMile, time: DurationUnit.Minute),
+                     new QuantityValue(54000, 463)
+                );
+                yield return new (AccelerationUnit.KnotPerSecond, "KnotPerSecond", "KnotsPerSecond", new BaseUnits(length: LengthUnit.NauticalMile, time: DurationUnit.Second),
+                     new QuantityValue(900, 463)
+                );
                 yield return new (AccelerationUnit.MeterPerSecondSquared, "MeterPerSecondSquared", "MetersPerSecondSquared", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (AccelerationUnit.MicrometerPerSecondSquared, "MicrometerPerSecondSquared", "MicrometersPerSecondSquared", new BaseUnits(length: LengthUnit.Micrometer, time: DurationUnit.Second));
-                yield return new (AccelerationUnit.MillimeterPerSecondSquared, "MillimeterPerSecondSquared", "MillimetersPerSecondSquared", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second));
-                yield return new (AccelerationUnit.MillistandardGravity, "MillistandardGravity", "MillistandardGravity", BaseUnits.Undefined);
-                yield return new (AccelerationUnit.NanometerPerSecondSquared, "NanometerPerSecondSquared", "NanometersPerSecondSquared", new BaseUnits(length: LengthUnit.Nanometer, time: DurationUnit.Second));
-                yield return new (AccelerationUnit.StandardGravity, "StandardGravity", "StandardGravity", BaseUnits.Undefined);
+                yield return new (AccelerationUnit.MicrometerPerSecondSquared, "MicrometerPerSecondSquared", "MicrometersPerSecondSquared", new BaseUnits(length: LengthUnit.Micrometer, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (AccelerationUnit.MillimeterPerSecondSquared, "MillimeterPerSecondSquared", "MillimetersPerSecondSquared", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (AccelerationUnit.MillistandardGravity, "MillistandardGravity", "MillistandardGravity", BaseUnits.Undefined,
+                     new QuantityValue(20000000, 196133)
+                );
+                yield return new (AccelerationUnit.NanometerPerSecondSquared, "NanometerPerSecondSquared", "NanometersPerSecondSquared", new BaseUnits(length: LengthUnit.Nanometer, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (AccelerationUnit.StandardGravity, "StandardGravity", "StandardGravity", BaseUnits.Undefined,
+                     new QuantityValue(20000, 196133)
+                );
             }
         }
 
         static Acceleration()
         {
-            Info = AccelerationInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(AccelerationInfo.CreateDefault);
         }
 
         /// <summary>
@@ -151,7 +176,7 @@ static Acceleration()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Acceleration(double value, AccelerationUnit unit)
+        public Acceleration(QuantityValue value, AccelerationUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -165,7 +190,7 @@ public Acceleration(double value, AccelerationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Acceleration(double value, UnitSystem unitSystem)
+        public Acceleration(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -176,7 +201,8 @@ public Acceleration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Acceleration" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Acceleration, AccelerationUnit> Info { get; }
@@ -205,10 +231,8 @@ public Acceleration(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public AccelerationUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -242,119 +266,79 @@ public Acceleration(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.CentimeterPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.CentimeterPerSecondSquared"/>
         /// </summary>
-        public double CentimetersPerSecondSquared => As(AccelerationUnit.CentimeterPerSecondSquared);
+        public QuantityValue CentimetersPerSecondSquared => this.As(AccelerationUnit.CentimeterPerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.DecimeterPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.DecimeterPerSecondSquared"/>
         /// </summary>
-        public double DecimetersPerSecondSquared => As(AccelerationUnit.DecimeterPerSecondSquared);
+        public QuantityValue DecimetersPerSecondSquared => this.As(AccelerationUnit.DecimeterPerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.FootPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.FootPerSecondSquared"/>
         /// </summary>
-        public double FeetPerSecondSquared => As(AccelerationUnit.FootPerSecondSquared);
+        public QuantityValue FeetPerSecondSquared => this.As(AccelerationUnit.FootPerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.InchPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.InchPerSecondSquared"/>
         /// </summary>
-        public double InchesPerSecondSquared => As(AccelerationUnit.InchPerSecondSquared);
+        public QuantityValue InchesPerSecondSquared => this.As(AccelerationUnit.InchPerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.KilometerPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.KilometerPerSecondSquared"/>
         /// </summary>
-        public double KilometersPerSecondSquared => As(AccelerationUnit.KilometerPerSecondSquared);
+        public QuantityValue KilometersPerSecondSquared => this.As(AccelerationUnit.KilometerPerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.KnotPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.KnotPerHour"/>
         /// </summary>
-        public double KnotsPerHour => As(AccelerationUnit.KnotPerHour);
+        public QuantityValue KnotsPerHour => this.As(AccelerationUnit.KnotPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.KnotPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.KnotPerMinute"/>
         /// </summary>
-        public double KnotsPerMinute => As(AccelerationUnit.KnotPerMinute);
+        public QuantityValue KnotsPerMinute => this.As(AccelerationUnit.KnotPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.KnotPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.KnotPerSecond"/>
         /// </summary>
-        public double KnotsPerSecond => As(AccelerationUnit.KnotPerSecond);
+        public QuantityValue KnotsPerSecond => this.As(AccelerationUnit.KnotPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.MeterPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.MeterPerSecondSquared"/>
         /// </summary>
-        public double MetersPerSecondSquared => As(AccelerationUnit.MeterPerSecondSquared);
+        public QuantityValue MetersPerSecondSquared => this.As(AccelerationUnit.MeterPerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.MicrometerPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.MicrometerPerSecondSquared"/>
         /// </summary>
-        public double MicrometersPerSecondSquared => As(AccelerationUnit.MicrometerPerSecondSquared);
+        public QuantityValue MicrometersPerSecondSquared => this.As(AccelerationUnit.MicrometerPerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.MillimeterPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.MillimeterPerSecondSquared"/>
         /// </summary>
-        public double MillimetersPerSecondSquared => As(AccelerationUnit.MillimeterPerSecondSquared);
+        public QuantityValue MillimetersPerSecondSquared => this.As(AccelerationUnit.MillimeterPerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.MillistandardGravity"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.MillistandardGravity"/>
         /// </summary>
-        public double MillistandardGravity => As(AccelerationUnit.MillistandardGravity);
+        public QuantityValue MillistandardGravity => this.As(AccelerationUnit.MillistandardGravity);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.NanometerPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.NanometerPerSecondSquared"/>
         /// </summary>
-        public double NanometersPerSecondSquared => As(AccelerationUnit.NanometerPerSecondSquared);
+        public QuantityValue NanometersPerSecondSquared => this.As(AccelerationUnit.NanometerPerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AccelerationUnit.StandardGravity"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AccelerationUnit.StandardGravity"/>
         /// </summary>
-        public double StandardGravity => As(AccelerationUnit.StandardGravity);
+        public QuantityValue StandardGravity => this.As(AccelerationUnit.StandardGravity);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: AccelerationUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.CentimeterPerSecondSquared, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.DecimeterPerSecondSquared, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.FootPerSecondSquared, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.InchPerSecondSquared, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.KilometerPerSecondSquared, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.KnotPerHour, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.KnotPerMinute, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.KnotPerSecond, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MicrometerPerSecondSquared, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MillimeterPerSecondSquared, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MillistandardGravity, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.NanometerPerSecondSquared, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.StandardGravity, AccelerationUnit.MeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MeterPerSecondSquared));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.MeterPerSecondSquared, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> AccelerationUnit
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.CentimeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.CentimeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.DecimeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.DecimeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.FootPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.FootPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.InchPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.InchPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.KilometerPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.KilometerPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.KnotPerHour, quantity => quantity.ToUnit(AccelerationUnit.KnotPerHour));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.KnotPerMinute, quantity => quantity.ToUnit(AccelerationUnit.KnotPerMinute));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.KnotPerSecond, quantity => quantity.ToUnit(AccelerationUnit.KnotPerSecond));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.MicrometerPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MicrometerPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.MillimeterPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.MillimeterPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.MillistandardGravity, quantity => quantity.ToUnit(AccelerationUnit.MillistandardGravity));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.NanometerPerSecondSquared, quantity => quantity.ToUnit(AccelerationUnit.NanometerPerSecondSquared));
-            unitConverter.SetConversionFunction<Acceleration>(AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.StandardGravity, quantity => quantity.ToUnit(AccelerationUnit.StandardGravity));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -383,7 +367,7 @@ public static string GetAbbreviation(AccelerationUnit unit, IFormatProvider? pro
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.CentimeterPerSecondSquared"/>.
         /// </summary>
-        public static Acceleration FromCentimetersPerSecondSquared(double value)
+        public static Acceleration FromCentimetersPerSecondSquared(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.CentimeterPerSecondSquared);
         }
@@ -391,7 +375,7 @@ public static Acceleration FromCentimetersPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.DecimeterPerSecondSquared"/>.
         /// </summary>
-        public static Acceleration FromDecimetersPerSecondSquared(double value)
+        public static Acceleration FromDecimetersPerSecondSquared(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.DecimeterPerSecondSquared);
         }
@@ -399,7 +383,7 @@ public static Acceleration FromDecimetersPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.FootPerSecondSquared"/>.
         /// </summary>
-        public static Acceleration FromFeetPerSecondSquared(double value)
+        public static Acceleration FromFeetPerSecondSquared(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.FootPerSecondSquared);
         }
@@ -407,7 +391,7 @@ public static Acceleration FromFeetPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.InchPerSecondSquared"/>.
         /// </summary>
-        public static Acceleration FromInchesPerSecondSquared(double value)
+        public static Acceleration FromInchesPerSecondSquared(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.InchPerSecondSquared);
         }
@@ -415,7 +399,7 @@ public static Acceleration FromInchesPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KilometerPerSecondSquared"/>.
         /// </summary>
-        public static Acceleration FromKilometersPerSecondSquared(double value)
+        public static Acceleration FromKilometersPerSecondSquared(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.KilometerPerSecondSquared);
         }
@@ -423,7 +407,7 @@ public static Acceleration FromKilometersPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerHour"/>.
         /// </summary>
-        public static Acceleration FromKnotsPerHour(double value)
+        public static Acceleration FromKnotsPerHour(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.KnotPerHour);
         }
@@ -431,7 +415,7 @@ public static Acceleration FromKnotsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerMinute"/>.
         /// </summary>
-        public static Acceleration FromKnotsPerMinute(double value)
+        public static Acceleration FromKnotsPerMinute(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.KnotPerMinute);
         }
@@ -439,7 +423,7 @@ public static Acceleration FromKnotsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerSecond"/>.
         /// </summary>
-        public static Acceleration FromKnotsPerSecond(double value)
+        public static Acceleration FromKnotsPerSecond(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.KnotPerSecond);
         }
@@ -447,7 +431,7 @@ public static Acceleration FromKnotsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MeterPerSecondSquared"/>.
         /// </summary>
-        public static Acceleration FromMetersPerSecondSquared(double value)
+        public static Acceleration FromMetersPerSecondSquared(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.MeterPerSecondSquared);
         }
@@ -455,7 +439,7 @@ public static Acceleration FromMetersPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MicrometerPerSecondSquared"/>.
         /// </summary>
-        public static Acceleration FromMicrometersPerSecondSquared(double value)
+        public static Acceleration FromMicrometersPerSecondSquared(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.MicrometerPerSecondSquared);
         }
@@ -463,7 +447,7 @@ public static Acceleration FromMicrometersPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MillimeterPerSecondSquared"/>.
         /// </summary>
-        public static Acceleration FromMillimetersPerSecondSquared(double value)
+        public static Acceleration FromMillimetersPerSecondSquared(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.MillimeterPerSecondSquared);
         }
@@ -471,7 +455,7 @@ public static Acceleration FromMillimetersPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MillistandardGravity"/>.
         /// </summary>
-        public static Acceleration FromMillistandardGravity(double value)
+        public static Acceleration FromMillistandardGravity(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.MillistandardGravity);
         }
@@ -479,7 +463,7 @@ public static Acceleration FromMillistandardGravity(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.NanometerPerSecondSquared"/>.
         /// </summary>
-        public static Acceleration FromNanometersPerSecondSquared(double value)
+        public static Acceleration FromNanometersPerSecondSquared(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.NanometerPerSecondSquared);
         }
@@ -487,7 +471,7 @@ public static Acceleration FromNanometersPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.StandardGravity"/>.
         /// </summary>
-        public static Acceleration FromStandardGravity(double value)
+        public static Acceleration FromStandardGravity(QuantityValue value)
         {
             return new Acceleration(value, AccelerationUnit.StandardGravity);
         }
@@ -498,7 +482,7 @@ public static Acceleration FromStandardGravity(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Acceleration unit value.</returns>
-        public static Acceleration From(double value, AccelerationUnit fromUnit)
+        public static Acceleration From(QuantityValue value, AccelerationUnit fromUnit)
         {
             return new Acceleration(value, fromUnit);
         }
@@ -559,10 +543,7 @@ public static Acceleration Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Acceleration Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Acceleration, AccelerationUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Acceleration, AccelerationUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -590,11 +571,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Acceleration res
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Acceleration result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Acceleration, AccelerationUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Acceleration, AccelerationUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -615,7 +592,7 @@ public static AccelerationUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -626,7 +603,7 @@ public static AccelerationUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AccelerationUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.AccelerationUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out AccelerationUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -641,7 +618,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Acceleration
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out AccelerationUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -660,35 +637,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Acceleration"/> from adding two <see cref="Acceleration"/>.</summary>
         public static Acceleration operator +(Acceleration left, Acceleration right)
         {
-            return new Acceleration(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Acceleration(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Acceleration"/> from subtracting two <see cref="Acceleration"/>.</summary>
         public static Acceleration operator -(Acceleration left, Acceleration right)
         {
-            return new Acceleration(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Acceleration(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Acceleration"/> from multiplying value and <see cref="Acceleration"/>.</summary>
-        public static Acceleration operator *(double left, Acceleration right)
+        public static Acceleration operator *(QuantityValue left, Acceleration right)
         {
             return new Acceleration(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Acceleration"/> from multiplying value and <see cref="Acceleration"/>.</summary>
-        public static Acceleration operator *(Acceleration left, double right)
+        public static Acceleration operator *(Acceleration left, QuantityValue right)
         {
             return new Acceleration(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Acceleration"/> from dividing <see cref="Acceleration"/> by value.</summary>
-        public static Acceleration operator /(Acceleration left, double right)
+        public static Acceleration operator /(Acceleration left, QuantityValue right)
         {
             return new Acceleration(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Acceleration"/> by <see cref="Acceleration"/>.</summary>
-        public static double operator /(Acceleration left, Acceleration right)
+        public static QuantityValue operator /(Acceleration left, Acceleration right)
         {
             return left.MetersPerSecondSquared / right.MetersPerSecondSquared;
         }
@@ -709,12 +686,24 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Force.FromNewtons(acceleration.MetersPerSecondSquared * mass.Kilograms);
         }
 
+        /// <summary>Get <see cref="ForcePerLength"/> from <see cref="Acceleration"/> * <see cref="LinearDensity"/>.</summary>
+        public static ForcePerLength operator *(Acceleration acceleration, LinearDensity linearDensity)
+        {
+            return ForcePerLength.FromNewtonsPerMeter(acceleration.MetersPerSecondSquared * linearDensity.KilogramsPerMeter);
+        }
+
         /// <summary>Get <see cref="Jerk"/> from <see cref="Acceleration"/> / <see cref="Duration"/>.</summary>
         public static Jerk operator /(Acceleration acceleration, Duration duration)
         {
             return Jerk.FromMetersPerSecondCubed(acceleration.MetersPerSecondSquared / duration.Seconds);
         }
 
+        /// <summary>Get <see cref="Pressure"/> from <see cref="Acceleration"/> * <see cref="AreaDensity"/>.</summary>
+        public static Pressure operator *(Acceleration acceleration, AreaDensity areaDensity)
+        {
+            return Pressure.FromPascals(acceleration.MetersPerSecondSquared * areaDensity.KilogramsPerSquareMeter);
+        }
+
         /// <summary>Get <see cref="SpecificWeight"/> from <see cref="Acceleration"/> * <see cref="Density"/>.</summary>
         public static SpecificWeight operator *(Acceleration acceleration, Density density)
         {
@@ -734,97 +723,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Acceleration left, Acceleration right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Acceleration left, Acceleration right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Acceleration left, Acceleration right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Acceleration left, Acceleration right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Acceleration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Acceleration other, Acceleration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Acceleration"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Acceleration)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Acceleration left, Acceleration right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Acceleration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Acceleration other, Acceleration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Acceleration"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Acceleration,Acceleration)"/>.
+        ///     See that operator (and <see cref="Equals(Acceleration)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Acceleration left, Acceleration right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Acceleration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Acceleration other, Acceleration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Acceleration"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Acceleration"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Acceleration"/>, this method delegates to
+        ///     <see cref="Equals(Acceleration)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Acceleration otherQuantity))
+            if (obj is not Acceleration otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Acceleration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Acceleration other, Acceleration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Acceleration"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Acceleration other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Acceleration.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Acceleration), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Acceleration"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Acceleration)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Acceleration otherQuantity)) throw new ArgumentException("Expected type Acceleration.", nameof(obj));
+            if (obj is not Acceleration otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Acceleration>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Acceleration"/> with another <see cref="Acceleration"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Acceleration"/> with another <see cref="Acceleration"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -836,155 +839,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Acceleration other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(AccelerationUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<AccelerationUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Acceleration to another Acceleration with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Acceleration with the specified unit.</returns>
-        public Acceleration ToUnit(AccelerationUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Acceleration"/> to another <see cref="Acceleration"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Acceleration with the specified unit.</returns>
-        public Acceleration ToUnit(AccelerationUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Acceleration), Unit, typeof(Acceleration), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Acceleration)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Acceleration"/> to another <see cref="Acceleration"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Acceleration"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(AccelerationUnit unit, [NotNullWhen(true)] out Acceleration? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Acceleration? convertedOrNull = (Unit, unit) switch
-            {
-                // AccelerationUnit -> BaseUnit
-                (AccelerationUnit.CentimeterPerSecondSquared, AccelerationUnit.MeterPerSecondSquared) => new Acceleration((_value) * 1e-2d, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.DecimeterPerSecondSquared, AccelerationUnit.MeterPerSecondSquared) => new Acceleration((_value) * 1e-1d, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.FootPerSecondSquared, AccelerationUnit.MeterPerSecondSquared) => new Acceleration(_value * 0.304800, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.InchPerSecondSquared, AccelerationUnit.MeterPerSecondSquared) => new Acceleration(_value * 0.0254, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.KilometerPerSecondSquared, AccelerationUnit.MeterPerSecondSquared) => new Acceleration((_value) * 1e3d, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.KnotPerHour, AccelerationUnit.MeterPerSecondSquared) => new Acceleration(_value * (1852.0 / 3600.0) / 3600, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.KnotPerMinute, AccelerationUnit.MeterPerSecondSquared) => new Acceleration(_value * (1852.0 / 3600.0) / 60, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.KnotPerSecond, AccelerationUnit.MeterPerSecondSquared) => new Acceleration(_value * (1852.0 / 3600.0), AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.MicrometerPerSecondSquared, AccelerationUnit.MeterPerSecondSquared) => new Acceleration((_value) * 1e-6d, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.MillimeterPerSecondSquared, AccelerationUnit.MeterPerSecondSquared) => new Acceleration((_value) * 1e-3d, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.MillistandardGravity, AccelerationUnit.MeterPerSecondSquared) => new Acceleration((_value * 9.80665) * 1e-3d, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.NanometerPerSecondSquared, AccelerationUnit.MeterPerSecondSquared) => new Acceleration((_value) * 1e-9d, AccelerationUnit.MeterPerSecondSquared),
-                (AccelerationUnit.StandardGravity, AccelerationUnit.MeterPerSecondSquared) => new Acceleration(_value * 9.80665, AccelerationUnit.MeterPerSecondSquared),
-
-                // BaseUnit -> AccelerationUnit
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.CentimeterPerSecondSquared) => new Acceleration((_value) / 1e-2d, AccelerationUnit.CentimeterPerSecondSquared),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.DecimeterPerSecondSquared) => new Acceleration((_value) / 1e-1d, AccelerationUnit.DecimeterPerSecondSquared),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.FootPerSecondSquared) => new Acceleration(_value / 0.304800, AccelerationUnit.FootPerSecondSquared),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.InchPerSecondSquared) => new Acceleration(_value / 0.0254, AccelerationUnit.InchPerSecondSquared),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.KilometerPerSecondSquared) => new Acceleration((_value) / 1e3d, AccelerationUnit.KilometerPerSecondSquared),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.KnotPerHour) => new Acceleration(_value * 3600 / (1852.0 / 3600.0), AccelerationUnit.KnotPerHour),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.KnotPerMinute) => new Acceleration(_value * 60 / (1852.0 / 3600.0), AccelerationUnit.KnotPerMinute),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.KnotPerSecond) => new Acceleration(_value / (1852.0 / 3600.0), AccelerationUnit.KnotPerSecond),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.MicrometerPerSecondSquared) => new Acceleration((_value) / 1e-6d, AccelerationUnit.MicrometerPerSecondSquared),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.MillimeterPerSecondSquared) => new Acceleration((_value) / 1e-3d, AccelerationUnit.MillimeterPerSecondSquared),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.MillistandardGravity) => new Acceleration((_value / 9.80665) / 1e-3d, AccelerationUnit.MillistandardGravity),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.NanometerPerSecondSquared) => new Acceleration((_value) / 1e-9d, AccelerationUnit.NanometerPerSecondSquared),
-                (AccelerationUnit.MeterPerSecondSquared, AccelerationUnit.StandardGravity) => new Acceleration(_value / 9.80665, AccelerationUnit.StandardGravity),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not AccelerationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AccelerationUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is AccelerationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AccelerationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<AccelerationUnit> IQuantity<AccelerationUnit>.ToUnit(AccelerationUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -998,11 +855,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
index 939a52084e..11f278d0af 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Mole is the amount of substance containing Avagadro's Number (6.02 x 10 ^ 23) of real particles such as molecules,atoms, ions or radicals.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct AmountOfSubstance :
-        IArithmeticQuantity<AmountOfSubstance, AmountOfSubstanceUnit>,
+        ILinearQuantity<AmountOfSubstance, AmountOfSubstanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<AmountOfSubstance, AmountOfSubstance, double>,
+        IDivisionOperators<AmountOfSubstance, AmountOfSubstance, QuantityValue>,
         IDivisionOperators<AmountOfSubstance, MolarFlow, Duration>,
         IMultiplyOperators<AmountOfSubstance, MolarEnergy, Energy>,
         IMultiplyOperators<AmountOfSubstance, MolarMass, Mass>,
@@ -58,7 +57,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -108,7 +107,7 @@ public static AmountOfSubstanceInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="AmountOfSubstance"/> is [N].
+            ///     The <see cref="BaseDimensions" /> for <see cref="AmountOfSubstance"/> is N.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, 0, 0, 0, 1, 0);
 
@@ -123,31 +122,61 @@ public static AmountOfSubstanceInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{AmountOfSubstanceUnit}"/> representing the default unit mappings for AmountOfSubstance.</returns>
             public static IEnumerable<UnitDefinition<AmountOfSubstanceUnit>> GetDefaultMappings()
             {
-                yield return new (AmountOfSubstanceUnit.Centimole, "Centimole", "Centimoles", new BaseUnits(amount: AmountOfSubstanceUnit.Centimole));
-                yield return new (AmountOfSubstanceUnit.CentipoundMole, "CentipoundMole", "CentipoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.CentipoundMole));
-                yield return new (AmountOfSubstanceUnit.Decimole, "Decimole", "Decimoles", new BaseUnits(amount: AmountOfSubstanceUnit.Decimole));
-                yield return new (AmountOfSubstanceUnit.DecipoundMole, "DecipoundMole", "DecipoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.DecipoundMole));
-                yield return new (AmountOfSubstanceUnit.Femtomole, "Femtomole", "Femtomoles", new BaseUnits(amount: AmountOfSubstanceUnit.Femtomole));
-                yield return new (AmountOfSubstanceUnit.Kilomole, "Kilomole", "Kilomoles", new BaseUnits(amount: AmountOfSubstanceUnit.Kilomole));
-                yield return new (AmountOfSubstanceUnit.KilopoundMole, "KilopoundMole", "KilopoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.KilopoundMole));
-                yield return new (AmountOfSubstanceUnit.Megamole, "Megamole", "Megamoles", new BaseUnits(amount: AmountOfSubstanceUnit.Megamole));
-                yield return new (AmountOfSubstanceUnit.Micromole, "Micromole", "Micromoles", new BaseUnits(amount: AmountOfSubstanceUnit.Micromole));
-                yield return new (AmountOfSubstanceUnit.MicropoundMole, "MicropoundMole", "MicropoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.MicropoundMole));
-                yield return new (AmountOfSubstanceUnit.Millimole, "Millimole", "Millimoles", new BaseUnits(amount: AmountOfSubstanceUnit.Millimole));
-                yield return new (AmountOfSubstanceUnit.MillipoundMole, "MillipoundMole", "MillipoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.MillipoundMole));
+                yield return new (AmountOfSubstanceUnit.Centimole, "Centimole", "Centimoles", new BaseUnits(amount: AmountOfSubstanceUnit.Centimole),
+                     100
+                );
+                yield return new (AmountOfSubstanceUnit.CentipoundMole, "CentipoundMole", "CentipoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.CentipoundMole),
+                     new QuantityValue(10000000, 45359237)
+                );
+                yield return new (AmountOfSubstanceUnit.Decimole, "Decimole", "Decimoles", new BaseUnits(amount: AmountOfSubstanceUnit.Decimole),
+                     10
+                );
+                yield return new (AmountOfSubstanceUnit.DecipoundMole, "DecipoundMole", "DecipoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.DecipoundMole),
+                     new QuantityValue(1000000, 45359237)
+                );
+                yield return new (AmountOfSubstanceUnit.Femtomole, "Femtomole", "Femtomoles", new BaseUnits(amount: AmountOfSubstanceUnit.Femtomole),
+                     1000000000000000
+                );
+                yield return new (AmountOfSubstanceUnit.Kilomole, "Kilomole", "Kilomoles", new BaseUnits(amount: AmountOfSubstanceUnit.Kilomole),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (AmountOfSubstanceUnit.KilopoundMole, "KilopoundMole", "KilopoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.KilopoundMole),
+                     new QuantityValue(100, 45359237)
+                );
+                yield return new (AmountOfSubstanceUnit.Megamole, "Megamole", "Megamoles", new BaseUnits(amount: AmountOfSubstanceUnit.Megamole),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (AmountOfSubstanceUnit.Micromole, "Micromole", "Micromoles", new BaseUnits(amount: AmountOfSubstanceUnit.Micromole),
+                     1000000
+                );
+                yield return new (AmountOfSubstanceUnit.MicropoundMole, "MicropoundMole", "MicropoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.MicropoundMole),
+                     new QuantityValue(100000000000, 45359237)
+                );
+                yield return new (AmountOfSubstanceUnit.Millimole, "Millimole", "Millimoles", new BaseUnits(amount: AmountOfSubstanceUnit.Millimole),
+                     1000
+                );
+                yield return new (AmountOfSubstanceUnit.MillipoundMole, "MillipoundMole", "MillipoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.MillipoundMole),
+                     new QuantityValue(100000000, 45359237)
+                );
                 yield return new (AmountOfSubstanceUnit.Mole, "Mole", "Moles", new BaseUnits(amount: AmountOfSubstanceUnit.Mole));
-                yield return new (AmountOfSubstanceUnit.Nanomole, "Nanomole", "Nanomoles", new BaseUnits(amount: AmountOfSubstanceUnit.Nanomole));
-                yield return new (AmountOfSubstanceUnit.NanopoundMole, "NanopoundMole", "NanopoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.NanopoundMole));
-                yield return new (AmountOfSubstanceUnit.Picomole, "Picomole", "Picomoles", new BaseUnits(amount: AmountOfSubstanceUnit.Picomole));
-                yield return new (AmountOfSubstanceUnit.PoundMole, "PoundMole", "PoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.PoundMole));
+                yield return new (AmountOfSubstanceUnit.Nanomole, "Nanomole", "Nanomoles", new BaseUnits(amount: AmountOfSubstanceUnit.Nanomole),
+                     1000000000
+                );
+                yield return new (AmountOfSubstanceUnit.NanopoundMole, "NanopoundMole", "NanopoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.NanopoundMole),
+                     new QuantityValue(100000000000000, 45359237)
+                );
+                yield return new (AmountOfSubstanceUnit.Picomole, "Picomole", "Picomoles", new BaseUnits(amount: AmountOfSubstanceUnit.Picomole),
+                     1000000000000
+                );
+                yield return new (AmountOfSubstanceUnit.PoundMole, "PoundMole", "PoundMoles", new BaseUnits(amount: AmountOfSubstanceUnit.PoundMole),
+                     new QuantityValue(100000, 45359237)
+                );
             }
         }
 
         static AmountOfSubstance()
         {
-            Info = AmountOfSubstanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(AmountOfSubstanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -155,7 +184,7 @@ static AmountOfSubstance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public AmountOfSubstance(double value, AmountOfSubstanceUnit unit)
+        public AmountOfSubstance(QuantityValue value, AmountOfSubstanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -169,7 +198,7 @@ public AmountOfSubstance(double value, AmountOfSubstanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public AmountOfSubstance(double value, UnitSystem unitSystem)
+        public AmountOfSubstance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -180,7 +209,8 @@ public AmountOfSubstance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="AmountOfSubstance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<AmountOfSubstance, AmountOfSubstanceUnit> Info { get; }
@@ -209,10 +239,8 @@ public AmountOfSubstance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public AmountOfSubstanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -246,140 +274,94 @@ public AmountOfSubstance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Centimole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Centimole"/>
         /// </summary>
-        public double Centimoles => As(AmountOfSubstanceUnit.Centimole);
+        public QuantityValue Centimoles => this.As(AmountOfSubstanceUnit.Centimole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.CentipoundMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.CentipoundMole"/>
         /// </summary>
-        public double CentipoundMoles => As(AmountOfSubstanceUnit.CentipoundMole);
+        public QuantityValue CentipoundMoles => this.As(AmountOfSubstanceUnit.CentipoundMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Decimole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Decimole"/>
         /// </summary>
-        public double Decimoles => As(AmountOfSubstanceUnit.Decimole);
+        public QuantityValue Decimoles => this.As(AmountOfSubstanceUnit.Decimole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.DecipoundMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.DecipoundMole"/>
         /// </summary>
-        public double DecipoundMoles => As(AmountOfSubstanceUnit.DecipoundMole);
+        public QuantityValue DecipoundMoles => this.As(AmountOfSubstanceUnit.DecipoundMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Femtomole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Femtomole"/>
         /// </summary>
-        public double Femtomoles => As(AmountOfSubstanceUnit.Femtomole);
+        public QuantityValue Femtomoles => this.As(AmountOfSubstanceUnit.Femtomole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Kilomole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Kilomole"/>
         /// </summary>
-        public double Kilomoles => As(AmountOfSubstanceUnit.Kilomole);
+        public QuantityValue Kilomoles => this.As(AmountOfSubstanceUnit.Kilomole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.KilopoundMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.KilopoundMole"/>
         /// </summary>
-        public double KilopoundMoles => As(AmountOfSubstanceUnit.KilopoundMole);
+        public QuantityValue KilopoundMoles => this.As(AmountOfSubstanceUnit.KilopoundMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Megamole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Megamole"/>
         /// </summary>
-        public double Megamoles => As(AmountOfSubstanceUnit.Megamole);
+        public QuantityValue Megamoles => this.As(AmountOfSubstanceUnit.Megamole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Micromole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Micromole"/>
         /// </summary>
-        public double Micromoles => As(AmountOfSubstanceUnit.Micromole);
+        public QuantityValue Micromoles => this.As(AmountOfSubstanceUnit.Micromole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.MicropoundMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.MicropoundMole"/>
         /// </summary>
-        public double MicropoundMoles => As(AmountOfSubstanceUnit.MicropoundMole);
+        public QuantityValue MicropoundMoles => this.As(AmountOfSubstanceUnit.MicropoundMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Millimole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Millimole"/>
         /// </summary>
-        public double Millimoles => As(AmountOfSubstanceUnit.Millimole);
+        public QuantityValue Millimoles => this.As(AmountOfSubstanceUnit.Millimole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.MillipoundMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.MillipoundMole"/>
         /// </summary>
-        public double MillipoundMoles => As(AmountOfSubstanceUnit.MillipoundMole);
+        public QuantityValue MillipoundMoles => this.As(AmountOfSubstanceUnit.MillipoundMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Mole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Mole"/>
         /// </summary>
-        public double Moles => As(AmountOfSubstanceUnit.Mole);
+        public QuantityValue Moles => this.As(AmountOfSubstanceUnit.Mole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Nanomole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Nanomole"/>
         /// </summary>
-        public double Nanomoles => As(AmountOfSubstanceUnit.Nanomole);
+        public QuantityValue Nanomoles => this.As(AmountOfSubstanceUnit.Nanomole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.NanopoundMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.NanopoundMole"/>
         /// </summary>
-        public double NanopoundMoles => As(AmountOfSubstanceUnit.NanopoundMole);
+        public QuantityValue NanopoundMoles => this.As(AmountOfSubstanceUnit.NanopoundMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Picomole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.Picomole"/>
         /// </summary>
-        public double Picomoles => As(AmountOfSubstanceUnit.Picomole);
+        public QuantityValue Picomoles => this.As(AmountOfSubstanceUnit.Picomole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.PoundMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmountOfSubstanceUnit.PoundMole"/>
         /// </summary>
-        public double PoundMoles => As(AmountOfSubstanceUnit.PoundMole);
+        public QuantityValue PoundMoles => this.As(AmountOfSubstanceUnit.PoundMole);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: AmountOfSubstanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Centimole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.CentipoundMole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Decimole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.DecipoundMole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Femtomole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Kilomole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.KilopoundMole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Megamole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Micromole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.MicropoundMole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Millimole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.MillipoundMole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Nanomole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.NanopoundMole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Picomole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.PoundMole, AmountOfSubstanceUnit.Mole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Mole));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Mole, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> AmountOfSubstanceUnit
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Centimole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Centimole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.CentipoundMole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.CentipoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Decimole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Decimole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.DecipoundMole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.DecipoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Femtomole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Femtomole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Kilomole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Kilomole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.KilopoundMole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.KilopoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Megamole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Megamole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Micromole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Micromole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.MicropoundMole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.MicropoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Millimole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Millimole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.MillipoundMole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.MillipoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Nanomole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Nanomole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.NanopoundMole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.NanopoundMole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Picomole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.Picomole));
-            unitConverter.SetConversionFunction<AmountOfSubstance>(AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.PoundMole, quantity => quantity.ToUnit(AmountOfSubstanceUnit.PoundMole));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -408,7 +390,7 @@ public static string GetAbbreviation(AmountOfSubstanceUnit unit, IFormatProvider
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Centimole"/>.
         /// </summary>
-        public static AmountOfSubstance FromCentimoles(double value)
+        public static AmountOfSubstance FromCentimoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.Centimole);
         }
@@ -416,7 +398,7 @@ public static AmountOfSubstance FromCentimoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.CentipoundMole"/>.
         /// </summary>
-        public static AmountOfSubstance FromCentipoundMoles(double value)
+        public static AmountOfSubstance FromCentipoundMoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.CentipoundMole);
         }
@@ -424,7 +406,7 @@ public static AmountOfSubstance FromCentipoundMoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Decimole"/>.
         /// </summary>
-        public static AmountOfSubstance FromDecimoles(double value)
+        public static AmountOfSubstance FromDecimoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.Decimole);
         }
@@ -432,7 +414,7 @@ public static AmountOfSubstance FromDecimoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.DecipoundMole"/>.
         /// </summary>
-        public static AmountOfSubstance FromDecipoundMoles(double value)
+        public static AmountOfSubstance FromDecipoundMoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.DecipoundMole);
         }
@@ -440,7 +422,7 @@ public static AmountOfSubstance FromDecipoundMoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Femtomole"/>.
         /// </summary>
-        public static AmountOfSubstance FromFemtomoles(double value)
+        public static AmountOfSubstance FromFemtomoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.Femtomole);
         }
@@ -448,7 +430,7 @@ public static AmountOfSubstance FromFemtomoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Kilomole"/>.
         /// </summary>
-        public static AmountOfSubstance FromKilomoles(double value)
+        public static AmountOfSubstance FromKilomoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.Kilomole);
         }
@@ -456,7 +438,7 @@ public static AmountOfSubstance FromKilomoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.KilopoundMole"/>.
         /// </summary>
-        public static AmountOfSubstance FromKilopoundMoles(double value)
+        public static AmountOfSubstance FromKilopoundMoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.KilopoundMole);
         }
@@ -464,7 +446,7 @@ public static AmountOfSubstance FromKilopoundMoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Megamole"/>.
         /// </summary>
-        public static AmountOfSubstance FromMegamoles(double value)
+        public static AmountOfSubstance FromMegamoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.Megamole);
         }
@@ -472,7 +454,7 @@ public static AmountOfSubstance FromMegamoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Micromole"/>.
         /// </summary>
-        public static AmountOfSubstance FromMicromoles(double value)
+        public static AmountOfSubstance FromMicromoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.Micromole);
         }
@@ -480,7 +462,7 @@ public static AmountOfSubstance FromMicromoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.MicropoundMole"/>.
         /// </summary>
-        public static AmountOfSubstance FromMicropoundMoles(double value)
+        public static AmountOfSubstance FromMicropoundMoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.MicropoundMole);
         }
@@ -488,7 +470,7 @@ public static AmountOfSubstance FromMicropoundMoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Millimole"/>.
         /// </summary>
-        public static AmountOfSubstance FromMillimoles(double value)
+        public static AmountOfSubstance FromMillimoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.Millimole);
         }
@@ -496,7 +478,7 @@ public static AmountOfSubstance FromMillimoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.MillipoundMole"/>.
         /// </summary>
-        public static AmountOfSubstance FromMillipoundMoles(double value)
+        public static AmountOfSubstance FromMillipoundMoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.MillipoundMole);
         }
@@ -504,7 +486,7 @@ public static AmountOfSubstance FromMillipoundMoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Mole"/>.
         /// </summary>
-        public static AmountOfSubstance FromMoles(double value)
+        public static AmountOfSubstance FromMoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.Mole);
         }
@@ -512,7 +494,7 @@ public static AmountOfSubstance FromMoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Nanomole"/>.
         /// </summary>
-        public static AmountOfSubstance FromNanomoles(double value)
+        public static AmountOfSubstance FromNanomoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.Nanomole);
         }
@@ -520,7 +502,7 @@ public static AmountOfSubstance FromNanomoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.NanopoundMole"/>.
         /// </summary>
-        public static AmountOfSubstance FromNanopoundMoles(double value)
+        public static AmountOfSubstance FromNanopoundMoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.NanopoundMole);
         }
@@ -528,7 +510,7 @@ public static AmountOfSubstance FromNanopoundMoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Picomole"/>.
         /// </summary>
-        public static AmountOfSubstance FromPicomoles(double value)
+        public static AmountOfSubstance FromPicomoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.Picomole);
         }
@@ -536,7 +518,7 @@ public static AmountOfSubstance FromPicomoles(double value)
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.PoundMole"/>.
         /// </summary>
-        public static AmountOfSubstance FromPoundMoles(double value)
+        public static AmountOfSubstance FromPoundMoles(QuantityValue value)
         {
             return new AmountOfSubstance(value, AmountOfSubstanceUnit.PoundMole);
         }
@@ -547,7 +529,7 @@ public static AmountOfSubstance FromPoundMoles(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>AmountOfSubstance unit value.</returns>
-        public static AmountOfSubstance From(double value, AmountOfSubstanceUnit fromUnit)
+        public static AmountOfSubstance From(QuantityValue value, AmountOfSubstanceUnit fromUnit)
         {
             return new AmountOfSubstance(value, fromUnit);
         }
@@ -608,10 +590,7 @@ public static AmountOfSubstance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static AmountOfSubstance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<AmountOfSubstance, AmountOfSubstanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<AmountOfSubstance, AmountOfSubstanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -639,11 +618,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out AmountOfSubstanc
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out AmountOfSubstance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<AmountOfSubstance, AmountOfSubstanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<AmountOfSubstance, AmountOfSubstanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -664,7 +639,7 @@ public static AmountOfSubstanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -675,7 +650,7 @@ public static AmountOfSubstanceUnit ParseUnit(string str, IFormatProvider? provi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AmountOfSubstanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.AmountOfSubstanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out AmountOfSubstanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -690,7 +665,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AmountOfSubs
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out AmountOfSubstanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -709,35 +684,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="AmountOfSubstance"/> from adding two <see cref="AmountOfSubstance"/>.</summary>
         public static AmountOfSubstance operator +(AmountOfSubstance left, AmountOfSubstance right)
         {
-            return new AmountOfSubstance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new AmountOfSubstance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="AmountOfSubstance"/> from subtracting two <see cref="AmountOfSubstance"/>.</summary>
         public static AmountOfSubstance operator -(AmountOfSubstance left, AmountOfSubstance right)
         {
-            return new AmountOfSubstance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new AmountOfSubstance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="AmountOfSubstance"/> from multiplying value and <see cref="AmountOfSubstance"/>.</summary>
-        public static AmountOfSubstance operator *(double left, AmountOfSubstance right)
+        public static AmountOfSubstance operator *(QuantityValue left, AmountOfSubstance right)
         {
             return new AmountOfSubstance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="AmountOfSubstance"/> from multiplying value and <see cref="AmountOfSubstance"/>.</summary>
-        public static AmountOfSubstance operator *(AmountOfSubstance left, double right)
+        public static AmountOfSubstance operator *(AmountOfSubstance left, QuantityValue right)
         {
             return new AmountOfSubstance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="AmountOfSubstance"/> from dividing <see cref="AmountOfSubstance"/> by value.</summary>
-        public static AmountOfSubstance operator /(AmountOfSubstance left, double right)
+        public static AmountOfSubstance operator /(AmountOfSubstance left, QuantityValue right)
         {
             return new AmountOfSubstance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="AmountOfSubstance"/> by <see cref="AmountOfSubstance"/>.</summary>
-        public static double operator /(AmountOfSubstance left, AmountOfSubstance right)
+        public static QuantityValue operator /(AmountOfSubstance left, AmountOfSubstance right)
         {
             return left.Moles / right.Moles;
         }
@@ -789,97 +764,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(AmountOfSubstance left, AmountOfSubstance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(AmountOfSubstance left, AmountOfSubstance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(AmountOfSubstance left, AmountOfSubstance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(AmountOfSubstance left, AmountOfSubstance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="AmountOfSubstance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(AmountOfSubstance other, AmountOfSubstance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="AmountOfSubstance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(AmountOfSubstance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(AmountOfSubstance left, AmountOfSubstance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="AmountOfSubstance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(AmountOfSubstance other, AmountOfSubstance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="AmountOfSubstance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(AmountOfSubstance,AmountOfSubstance)"/>.
+        ///     See that operator (and <see cref="Equals(AmountOfSubstance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(AmountOfSubstance left, AmountOfSubstance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="AmountOfSubstance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(AmountOfSubstance other, AmountOfSubstance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="AmountOfSubstance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="AmountOfSubstance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="AmountOfSubstance"/>, this method delegates to
+        ///     <see cref="Equals(AmountOfSubstance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is AmountOfSubstance otherQuantity))
+            if (obj is not AmountOfSubstance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="AmountOfSubstance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(AmountOfSubstance other, AmountOfSubstance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="AmountOfSubstance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(AmountOfSubstance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current AmountOfSubstance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(AmountOfSubstance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="AmountOfSubstance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(AmountOfSubstance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is AmountOfSubstance otherQuantity)) throw new ArgumentException("Expected type AmountOfSubstance.", nameof(obj));
+            if (obj is not AmountOfSubstance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<AmountOfSubstance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="AmountOfSubstance"/> with another <see cref="AmountOfSubstance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="AmountOfSubstance"/> with another <see cref="AmountOfSubstance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -891,161 +880,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(AmountOfSubstance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(AmountOfSubstanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<AmountOfSubstanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this AmountOfSubstance to another AmountOfSubstance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A AmountOfSubstance with the specified unit.</returns>
-        public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="AmountOfSubstance"/> to another <see cref="AmountOfSubstance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A AmountOfSubstance with the specified unit.</returns>
-        public AmountOfSubstance ToUnit(AmountOfSubstanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(AmountOfSubstance), Unit, typeof(AmountOfSubstance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (AmountOfSubstance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="AmountOfSubstance"/> to another <see cref="AmountOfSubstance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="AmountOfSubstance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(AmountOfSubstanceUnit unit, [NotNullWhen(true)] out AmountOfSubstance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            AmountOfSubstance? convertedOrNull = (Unit, unit) switch
-            {
-                // AmountOfSubstanceUnit -> BaseUnit
-                (AmountOfSubstanceUnit.Centimole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value) * 1e-2d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.CentipoundMole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value * 453.59237) * 1e-2d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.Decimole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value) * 1e-1d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.DecipoundMole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value * 453.59237) * 1e-1d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.Femtomole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value) * 1e-15d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.Kilomole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value) * 1e3d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.KilopoundMole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value * 453.59237) * 1e3d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.Megamole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value) * 1e6d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.Micromole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value) * 1e-6d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.MicropoundMole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value * 453.59237) * 1e-6d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.Millimole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value) * 1e-3d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.MillipoundMole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value * 453.59237) * 1e-3d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.Nanomole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value) * 1e-9d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.NanopoundMole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value * 453.59237) * 1e-9d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.Picomole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance((_value) * 1e-12d, AmountOfSubstanceUnit.Mole),
-                (AmountOfSubstanceUnit.PoundMole, AmountOfSubstanceUnit.Mole) => new AmountOfSubstance(_value * 453.59237, AmountOfSubstanceUnit.Mole),
-
-                // BaseUnit -> AmountOfSubstanceUnit
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Centimole) => new AmountOfSubstance((_value) / 1e-2d, AmountOfSubstanceUnit.Centimole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.CentipoundMole) => new AmountOfSubstance((_value / 453.59237) / 1e-2d, AmountOfSubstanceUnit.CentipoundMole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Decimole) => new AmountOfSubstance((_value) / 1e-1d, AmountOfSubstanceUnit.Decimole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.DecipoundMole) => new AmountOfSubstance((_value / 453.59237) / 1e-1d, AmountOfSubstanceUnit.DecipoundMole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Femtomole) => new AmountOfSubstance((_value) / 1e-15d, AmountOfSubstanceUnit.Femtomole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Kilomole) => new AmountOfSubstance((_value) / 1e3d, AmountOfSubstanceUnit.Kilomole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.KilopoundMole) => new AmountOfSubstance((_value / 453.59237) / 1e3d, AmountOfSubstanceUnit.KilopoundMole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Megamole) => new AmountOfSubstance((_value) / 1e6d, AmountOfSubstanceUnit.Megamole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Micromole) => new AmountOfSubstance((_value) / 1e-6d, AmountOfSubstanceUnit.Micromole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.MicropoundMole) => new AmountOfSubstance((_value / 453.59237) / 1e-6d, AmountOfSubstanceUnit.MicropoundMole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Millimole) => new AmountOfSubstance((_value) / 1e-3d, AmountOfSubstanceUnit.Millimole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.MillipoundMole) => new AmountOfSubstance((_value / 453.59237) / 1e-3d, AmountOfSubstanceUnit.MillipoundMole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Nanomole) => new AmountOfSubstance((_value) / 1e-9d, AmountOfSubstanceUnit.Nanomole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.NanopoundMole) => new AmountOfSubstance((_value / 453.59237) / 1e-9d, AmountOfSubstanceUnit.NanopoundMole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.Picomole) => new AmountOfSubstance((_value) / 1e-12d, AmountOfSubstanceUnit.Picomole),
-                (AmountOfSubstanceUnit.Mole, AmountOfSubstanceUnit.PoundMole) => new AmountOfSubstance(_value / 453.59237, AmountOfSubstanceUnit.PoundMole),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not AmountOfSubstanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmountOfSubstanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is AmountOfSubstanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmountOfSubstanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<AmountOfSubstanceUnit> IQuantity<AmountOfSubstanceUnit>.ToUnit(AmountOfSubstanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1059,11 +896,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
index 0db3066f16..285feba890 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     The strength of a signal expressed in decibels (dB) relative to one volt RMS.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct AmplitudeRatio :
         ILogarithmicQuantity<AmplitudeRatio, AmplitudeRatioUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<AmplitudeRatio, AmplitudeRatio, double>,
+        IDivisionOperators<AmplitudeRatio, AmplitudeRatio, QuantityValue>,
         IComparisonOperators<AmplitudeRatio, AmplitudeRatio, bool>,
         IParsable<AmplitudeRatio>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -117,18 +116,25 @@ public static AmplitudeRatioInfo CreateDefault(Func<IEnumerable<UnitDefinition<A
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{AmplitudeRatioUnit}"/> representing the default unit mappings for AmplitudeRatio.</returns>
             public static IEnumerable<UnitDefinition<AmplitudeRatioUnit>> GetDefaultMappings()
             {
-                yield return new (AmplitudeRatioUnit.DecibelMicrovolt, "DecibelMicrovolt", "DecibelMicrovolts", BaseUnits.Undefined);
-                yield return new (AmplitudeRatioUnit.DecibelMillivolt, "DecibelMillivolt", "DecibelMillivolts", BaseUnits.Undefined);
-                yield return new (AmplitudeRatioUnit.DecibelUnloaded, "DecibelUnloaded", "DecibelsUnloaded", BaseUnits.Undefined);
+                yield return new (AmplitudeRatioUnit.DecibelMicrovolt, "DecibelMicrovolt", "DecibelMicrovolts", BaseUnits.Undefined,
+                     new ConversionExpression(coefficient: 1, constantTerm: 120),
+                     new ConversionExpression(coefficient: 1, constantTerm: -120)
+                );
+                yield return new (AmplitudeRatioUnit.DecibelMillivolt, "DecibelMillivolt", "DecibelMillivolts", BaseUnits.Undefined,
+                     new ConversionExpression(coefficient: 1, constantTerm: 60),
+                     new ConversionExpression(coefficient: 1, constantTerm: -60)
+                );
+                yield return new (AmplitudeRatioUnit.DecibelUnloaded, "DecibelUnloaded", "DecibelsUnloaded", BaseUnits.Undefined,
+                     new ConversionExpression(coefficient: 1, constantTerm: new QuantityValue(2218487499, 1000000000)),
+                     new ConversionExpression(coefficient: 1, constantTerm: new QuantityValue(-2218487499, 1000000000))
+                );
                 yield return new (AmplitudeRatioUnit.DecibelVolt, "DecibelVolt", "DecibelVolts", BaseUnits.Undefined);
             }
         }
 
         static AmplitudeRatio()
         {
-            Info = AmplitudeRatioInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(AmplitudeRatioInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +142,7 @@ static AmplitudeRatio()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public AmplitudeRatio(double value, AmplitudeRatioUnit unit)
+        public AmplitudeRatio(QuantityValue value, AmplitudeRatioUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -147,7 +153,8 @@ public AmplitudeRatio(double value, AmplitudeRatioUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="AmplitudeRatio" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<AmplitudeRatio, AmplitudeRatioUnit> Info { get; }
@@ -173,16 +180,14 @@ public AmplitudeRatio(double value, AmplitudeRatioUnit unit)
         public static AmplitudeRatio Zero => Info.Zero;
 
         /// <inheritdoc />
-        public static double LogarithmicScalingFactor {get;} = 20;
+        public static QuantityValue LogarithmicScalingFactor {get;} = 20;
 
         #endregion
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public AmplitudeRatioUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -210,7 +215,7 @@ public AmplitudeRatio(double value, AmplitudeRatioUnit unit)
 #endif
 
 #if NETSTANDARD2_0
-        double ILogarithmicQuantity<AmplitudeRatio>.LogarithmicScalingFactor => LogarithmicScalingFactor;
+        QuantityValue ILogarithmicQuantity<AmplitudeRatio>.LogarithmicScalingFactor => LogarithmicScalingFactor;
 #endif
 
         #endregion
@@ -220,49 +225,29 @@ public AmplitudeRatio(double value, AmplitudeRatioUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelMicrovolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelMicrovolt"/>
         /// </summary>
-        public double DecibelMicrovolts => As(AmplitudeRatioUnit.DecibelMicrovolt);
+        public QuantityValue DecibelMicrovolts => this.As(AmplitudeRatioUnit.DecibelMicrovolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelMillivolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelMillivolt"/>
         /// </summary>
-        public double DecibelMillivolts => As(AmplitudeRatioUnit.DecibelMillivolt);
+        public QuantityValue DecibelMillivolts => this.As(AmplitudeRatioUnit.DecibelMillivolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelUnloaded"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelUnloaded"/>
         /// </summary>
-        public double DecibelsUnloaded => As(AmplitudeRatioUnit.DecibelUnloaded);
+        public QuantityValue DecibelsUnloaded => this.As(AmplitudeRatioUnit.DecibelUnloaded);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelVolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AmplitudeRatioUnit.DecibelVolt"/>
         /// </summary>
-        public double DecibelVolts => As(AmplitudeRatioUnit.DecibelVolt);
+        public QuantityValue DecibelVolts => this.As(AmplitudeRatioUnit.DecibelVolt);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: AmplitudeRatioUnit -> BaseUnit
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatioUnit.DecibelMicrovolt, AmplitudeRatioUnit.DecibelVolt, quantity => quantity.ToUnit(AmplitudeRatioUnit.DecibelVolt));
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatioUnit.DecibelMillivolt, AmplitudeRatioUnit.DecibelVolt, quantity => quantity.ToUnit(AmplitudeRatioUnit.DecibelVolt));
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatioUnit.DecibelUnloaded, AmplitudeRatioUnit.DecibelVolt, quantity => quantity.ToUnit(AmplitudeRatioUnit.DecibelVolt));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatioUnit.DecibelVolt, AmplitudeRatioUnit.DecibelVolt, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> AmplitudeRatioUnit
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatioUnit.DecibelVolt, AmplitudeRatioUnit.DecibelMicrovolt, quantity => quantity.ToUnit(AmplitudeRatioUnit.DecibelMicrovolt));
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatioUnit.DecibelVolt, AmplitudeRatioUnit.DecibelMillivolt, quantity => quantity.ToUnit(AmplitudeRatioUnit.DecibelMillivolt));
-            unitConverter.SetConversionFunction<AmplitudeRatio>(AmplitudeRatioUnit.DecibelVolt, AmplitudeRatioUnit.DecibelUnloaded, quantity => quantity.ToUnit(AmplitudeRatioUnit.DecibelUnloaded));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -291,7 +276,7 @@ public static string GetAbbreviation(AmplitudeRatioUnit unit, IFormatProvider? p
         /// <summary>
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelMicrovolt"/>.
         /// </summary>
-        public static AmplitudeRatio FromDecibelMicrovolts(double value)
+        public static AmplitudeRatio FromDecibelMicrovolts(QuantityValue value)
         {
             return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMicrovolt);
         }
@@ -299,7 +284,7 @@ public static AmplitudeRatio FromDecibelMicrovolts(double value)
         /// <summary>
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelMillivolt"/>.
         /// </summary>
-        public static AmplitudeRatio FromDecibelMillivolts(double value)
+        public static AmplitudeRatio FromDecibelMillivolts(QuantityValue value)
         {
             return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMillivolt);
         }
@@ -307,7 +292,7 @@ public static AmplitudeRatio FromDecibelMillivolts(double value)
         /// <summary>
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelUnloaded"/>.
         /// </summary>
-        public static AmplitudeRatio FromDecibelsUnloaded(double value)
+        public static AmplitudeRatio FromDecibelsUnloaded(QuantityValue value)
         {
             return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelUnloaded);
         }
@@ -315,7 +300,7 @@ public static AmplitudeRatio FromDecibelsUnloaded(double value)
         /// <summary>
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelVolt"/>.
         /// </summary>
-        public static AmplitudeRatio FromDecibelVolts(double value)
+        public static AmplitudeRatio FromDecibelVolts(QuantityValue value)
         {
             return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelVolt);
         }
@@ -326,7 +311,7 @@ public static AmplitudeRatio FromDecibelVolts(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>AmplitudeRatio unit value.</returns>
-        public static AmplitudeRatio From(double value, AmplitudeRatioUnit fromUnit)
+        public static AmplitudeRatio From(QuantityValue value, AmplitudeRatioUnit fromUnit)
         {
             return new AmplitudeRatio(value, fromUnit);
         }
@@ -387,10 +372,7 @@ public static AmplitudeRatio Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static AmplitudeRatio Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<AmplitudeRatio, AmplitudeRatioUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<AmplitudeRatio, AmplitudeRatioUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -418,11 +400,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out AmplitudeRatio r
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out AmplitudeRatio result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<AmplitudeRatio, AmplitudeRatioUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<AmplitudeRatio, AmplitudeRatioUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -443,7 +421,7 @@ public static AmplitudeRatioUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -454,7 +432,7 @@ public static AmplitudeRatioUnit ParseUnit(string str, IFormatProvider? provider
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AmplitudeRatioUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.AmplitudeRatioUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out AmplitudeRatioUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -469,7 +447,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AmplitudeRat
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out AmplitudeRatioUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -480,53 +458,51 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         #region Logarithmic Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static AmplitudeRatio operator -(AmplitudeRatio right)
+        public static AmplitudeRatio operator -(AmplitudeRatio quantity)
         {
-            return new AmplitudeRatio(-right.Value, right.Unit);
+            return new AmplitudeRatio(-quantity.Value, quantity.Unit);
         }
 
         /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic addition of two <see cref="AmplitudeRatio"/>.</summary>
+        /// <remarks>This operation involves a conversion of the values to linear space, which is not guaranteed to produce an exact value.
+        /// <para>The final result is rounded to 15 significant digits.</para>
+        /// </remarks>
         public static AmplitudeRatio operator +(AmplitudeRatio left, AmplitudeRatio right)
         {
-            // Logarithmic addition
-            // Formula: 20 * log10(10^(x/20) + 10^(y/20))
-            return new AmplitudeRatio(20 * Math.Log10(Math.Pow(10, left.Value / 20) + Math.Pow(10, right.ToUnit(left.Unit).Value / 20)), left.Unit);
+            return new AmplitudeRatio(QuantityValueExtensions.AddWithLogScaling(left.Value, right.As(left.Unit), LogarithmicScalingFactor), left.Unit);
         }
 
         /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic subtraction of two <see cref="AmplitudeRatio"/>.</summary>
+        /// <remarks>This operation involves a conversion of the values to linear space, which is not guaranteed to produce an exact value.
+        /// <para>The final result is rounded to 15 significant digits.</para>
+        /// </remarks>
         public static AmplitudeRatio operator -(AmplitudeRatio left, AmplitudeRatio right)
         {
-            // Logarithmic subtraction
-            // Formula: 20 * log10(10^(x/20) - 10^(y/20))
-            return new AmplitudeRatio(20 * Math.Log10(Math.Pow(10, left.Value / 20) - Math.Pow(10, right.ToUnit(left.Unit).Value / 20)), left.Unit);
+            return new AmplitudeRatio(QuantityValueExtensions.SubtractWithLogScaling(left.Value, right.As(left.Unit), LogarithmicScalingFactor), left.Unit);
         }
 
         /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic multiplication of value and <see cref="AmplitudeRatio"/>.</summary>
-        public static AmplitudeRatio operator *(double left, AmplitudeRatio right)
+        public static AmplitudeRatio operator *(QuantityValue left, AmplitudeRatio right)
         {
-            // Logarithmic multiplication = addition
             return new AmplitudeRatio(left + right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic multiplication of value and <see cref="AmplitudeRatio"/>.</summary>
-        public static AmplitudeRatio operator *(AmplitudeRatio left, double right)
+        public static AmplitudeRatio operator *(AmplitudeRatio left, QuantityValue right)
         {
-            // Logarithmic multiplication = addition
             return new AmplitudeRatio(left.Value + right, left.Unit);
         }
 
         /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic division of <see cref="AmplitudeRatio"/> by value.</summary>
-        public static AmplitudeRatio operator /(AmplitudeRatio left, double right)
+        public static AmplitudeRatio operator /(AmplitudeRatio left, QuantityValue right)
         {
-            // Logarithmic division = subtraction
             return new AmplitudeRatio(left.Value - right, left.Unit);
         }
 
         /// <summary>Get ratio value from logarithmic division of <see cref="AmplitudeRatio"/> by <see cref="AmplitudeRatio"/>.</summary>
-        public static double operator /(AmplitudeRatio left, AmplitudeRatio right)
+        public static QuantityValue operator /(AmplitudeRatio left, AmplitudeRatio right)
         {
-            // Logarithmic division = subtraction
-            return Convert.ToDouble(left.Value - right.ToUnit(left.Unit).Value);
+            return left.Value - right.As(left.Unit);
         }
 
         #endregion
@@ -536,97 +512,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(AmplitudeRatio left, AmplitudeRatio right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(AmplitudeRatio left, AmplitudeRatio right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(AmplitudeRatio left, AmplitudeRatio right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(AmplitudeRatio left, AmplitudeRatio right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="AmplitudeRatio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(AmplitudeRatio other, AmplitudeRatio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="AmplitudeRatio"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(AmplitudeRatio)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(AmplitudeRatio left, AmplitudeRatio right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="AmplitudeRatio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(AmplitudeRatio other, AmplitudeRatio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="AmplitudeRatio"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(AmplitudeRatio,AmplitudeRatio)"/>.
+        ///     See that operator (and <see cref="Equals(AmplitudeRatio)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(AmplitudeRatio left, AmplitudeRatio right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="AmplitudeRatio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(AmplitudeRatio other, AmplitudeRatio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="AmplitudeRatio"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="AmplitudeRatio"/>.
+        ///     When <paramref name="obj"/> is a <see cref="AmplitudeRatio"/>, this method delegates to
+        ///     <see cref="Equals(AmplitudeRatio)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is AmplitudeRatio otherQuantity))
+            if (obj is not AmplitudeRatio otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="AmplitudeRatio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(AmplitudeRatio other, AmplitudeRatio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="AmplitudeRatio"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(AmplitudeRatio other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current AmplitudeRatio.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(AmplitudeRatio), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="AmplitudeRatio"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(AmplitudeRatio)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is AmplitudeRatio otherQuantity)) throw new ArgumentException("Expected type AmplitudeRatio.", nameof(obj));
+            if (obj is not AmplitudeRatio otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<AmplitudeRatio>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="AmplitudeRatio"/> with another <see cref="AmplitudeRatio"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="AmplitudeRatio"/> with another <see cref="AmplitudeRatio"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -638,137 +628,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(AmplitudeRatio other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(AmplitudeRatioUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<AmplitudeRatioUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this AmplitudeRatio to another AmplitudeRatio with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A AmplitudeRatio with the specified unit.</returns>
-        public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="AmplitudeRatio"/> to another <see cref="AmplitudeRatio"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A AmplitudeRatio with the specified unit.</returns>
-        public AmplitudeRatio ToUnit(AmplitudeRatioUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(AmplitudeRatio), Unit, typeof(AmplitudeRatio), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (AmplitudeRatio)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="AmplitudeRatio"/> to another <see cref="AmplitudeRatio"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="AmplitudeRatio"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(AmplitudeRatioUnit unit, [NotNullWhen(true)] out AmplitudeRatio? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            AmplitudeRatio? convertedOrNull = (Unit, unit) switch
-            {
-                // AmplitudeRatioUnit -> BaseUnit
-                (AmplitudeRatioUnit.DecibelMicrovolt, AmplitudeRatioUnit.DecibelVolt) => new AmplitudeRatio(_value - 120, AmplitudeRatioUnit.DecibelVolt),
-                (AmplitudeRatioUnit.DecibelMillivolt, AmplitudeRatioUnit.DecibelVolt) => new AmplitudeRatio(_value - 60, AmplitudeRatioUnit.DecibelVolt),
-                (AmplitudeRatioUnit.DecibelUnloaded, AmplitudeRatioUnit.DecibelVolt) => new AmplitudeRatio(_value - 2.218487499, AmplitudeRatioUnit.DecibelVolt),
-
-                // BaseUnit -> AmplitudeRatioUnit
-                (AmplitudeRatioUnit.DecibelVolt, AmplitudeRatioUnit.DecibelMicrovolt) => new AmplitudeRatio(_value + 120, AmplitudeRatioUnit.DecibelMicrovolt),
-                (AmplitudeRatioUnit.DecibelVolt, AmplitudeRatioUnit.DecibelMillivolt) => new AmplitudeRatio(_value + 60, AmplitudeRatioUnit.DecibelMillivolt),
-                (AmplitudeRatioUnit.DecibelVolt, AmplitudeRatioUnit.DecibelUnloaded) => new AmplitudeRatio(_value + 2.218487499, AmplitudeRatioUnit.DecibelUnloaded),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not AmplitudeRatioUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmplitudeRatioUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is AmplitudeRatioUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmplitudeRatioUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<AmplitudeRatioUnit> IQuantity<AmplitudeRatioUnit>.ToUnit(AmplitudeRatioUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -780,11 +644,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
index bb2822e031..f41544faa7 100644
--- a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     In geometry, an angle is the figure formed by two rays, called the sides of the angle, sharing a common endpoint, called the vertex of the angle.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Angle :
-        IArithmeticQuantity<Angle, AngleUnit>,
+        ILinearQuantity<Angle, AngleUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Angle, Angle, double>,
+        IDivisionOperators<Angle, Angle, QuantityValue>,
         IDivisionOperators<Angle, RotationalSpeed, Duration>,
         IDivisionOperators<Angle, Duration, RotationalSpeed>,
         IMultiplyOperators<Angle, RotationalStiffness, Torque>,
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -120,29 +119,55 @@ public static AngleInfo CreateDefault(Func<IEnumerable<UnitDefinition<AngleUnit>
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{AngleUnit}"/> representing the default unit mappings for Angle.</returns>
             public static IEnumerable<UnitDefinition<AngleUnit>> GetDefaultMappings()
             {
-                yield return new (AngleUnit.Arcminute, "Arcminute", "Arcminutes", BaseUnits.Undefined);
-                yield return new (AngleUnit.Arcsecond, "Arcsecond", "Arcseconds", BaseUnits.Undefined);
-                yield return new (AngleUnit.Centiradian, "Centiradian", "Centiradians", BaseUnits.Undefined);
-                yield return new (AngleUnit.Deciradian, "Deciradian", "Deciradians", BaseUnits.Undefined);
-                yield return new (AngleUnit.Degree, "Degree", "Degrees", BaseUnits.Undefined);
-                yield return new (AngleUnit.Gradian, "Gradian", "Gradians", BaseUnits.Undefined);
-                yield return new (AngleUnit.Microdegree, "Microdegree", "Microdegrees", BaseUnits.Undefined);
-                yield return new (AngleUnit.Microradian, "Microradian", "Microradians", BaseUnits.Undefined);
-                yield return new (AngleUnit.Millidegree, "Millidegree", "Millidegrees", BaseUnits.Undefined);
-                yield return new (AngleUnit.Milliradian, "Milliradian", "Milliradians", BaseUnits.Undefined);
-                yield return new (AngleUnit.Nanodegree, "Nanodegree", "Nanodegrees", BaseUnits.Undefined);
-                yield return new (AngleUnit.Nanoradian, "Nanoradian", "Nanoradians", BaseUnits.Undefined);
-                yield return new (AngleUnit.NatoMil, "NatoMil", "NatoMils", BaseUnits.Undefined);
+                yield return new (AngleUnit.Arcminute, "Arcminute", "Arcminutes", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(108) * QuantityValue.PowerOfTen(17), 3141592653589793)
+                );
+                yield return new (AngleUnit.Arcsecond, "Arcsecond", "Arcseconds", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(648) * QuantityValue.PowerOfTen(18), 3141592653589793)
+                );
+                yield return new (AngleUnit.Centiradian, "Centiradian", "Centiradians", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (AngleUnit.Deciradian, "Deciradian", "Deciradians", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (AngleUnit.Degree, "Degree", "Degrees", BaseUnits.Undefined,
+                     new QuantityValue(180000000000000000, 3141592653589793)
+                );
+                yield return new (AngleUnit.Gradian, "Gradian", "Gradians", BaseUnits.Undefined,
+                     new QuantityValue(200000000000000000, 3141592653589793)
+                );
+                yield return new (AngleUnit.Microdegree, "Microdegree", "Microdegrees", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(18) * QuantityValue.PowerOfTen(22), 3141592653589793)
+                );
+                yield return new (AngleUnit.Microradian, "Microradian", "Microradians", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (AngleUnit.Millidegree, "Millidegree", "Millidegrees", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(18) * QuantityValue.PowerOfTen(19), 3141592653589793)
+                );
+                yield return new (AngleUnit.Milliradian, "Milliradian", "Milliradians", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (AngleUnit.Nanodegree, "Nanodegree", "Nanodegrees", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(18) * QuantityValue.PowerOfTen(25), 3141592653589793)
+                );
+                yield return new (AngleUnit.Nanoradian, "Nanoradian", "Nanoradians", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (AngleUnit.NatoMil, "NatoMil", "NatoMils", BaseUnits.Undefined,
+                     new QuantityValue(3200000000000000000, 3141592653589793)
+                );
                 yield return new (AngleUnit.Radian, "Radian", "Radians", BaseUnits.Undefined);
-                yield return new (AngleUnit.Revolution, "Revolution", "Revolutions", BaseUnits.Undefined);
+                yield return new (AngleUnit.Revolution, "Revolution", "Revolutions", BaseUnits.Undefined,
+                     new QuantityValue(500000000000000, 3141592653589793)
+                );
             }
         }
 
         static Angle()
         {
-            Info = AngleInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(AngleInfo.CreateDefault);
         }
 
         /// <summary>
@@ -150,7 +175,7 @@ static Angle()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Angle(double value, AngleUnit unit)
+        public Angle(QuantityValue value, AngleUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -161,7 +186,8 @@ public Angle(double value, AngleUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Angle" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Angle, AngleUnit> Info { get; }
@@ -190,10 +216,8 @@ public Angle(double value, AngleUnit unit)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public AngleUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,126 +251,84 @@ public Angle(double value, AngleUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Arcminute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Arcminute"/>
         /// </summary>
-        public double Arcminutes => As(AngleUnit.Arcminute);
+        public QuantityValue Arcminutes => this.As(AngleUnit.Arcminute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Arcsecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Arcsecond"/>
         /// </summary>
-        public double Arcseconds => As(AngleUnit.Arcsecond);
+        public QuantityValue Arcseconds => this.As(AngleUnit.Arcsecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Centiradian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Centiradian"/>
         /// </summary>
-        public double Centiradians => As(AngleUnit.Centiradian);
+        public QuantityValue Centiradians => this.As(AngleUnit.Centiradian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Deciradian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Deciradian"/>
         /// </summary>
-        public double Deciradians => As(AngleUnit.Deciradian);
+        public QuantityValue Deciradians => this.As(AngleUnit.Deciradian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Degree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Degree"/>
         /// </summary>
-        public double Degrees => As(AngleUnit.Degree);
+        public QuantityValue Degrees => this.As(AngleUnit.Degree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Gradian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Gradian"/>
         /// </summary>
-        public double Gradians => As(AngleUnit.Gradian);
+        public QuantityValue Gradians => this.As(AngleUnit.Gradian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Microdegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Microdegree"/>
         /// </summary>
-        public double Microdegrees => As(AngleUnit.Microdegree);
+        public QuantityValue Microdegrees => this.As(AngleUnit.Microdegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Microradian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Microradian"/>
         /// </summary>
-        public double Microradians => As(AngleUnit.Microradian);
+        public QuantityValue Microradians => this.As(AngleUnit.Microradian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Millidegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Millidegree"/>
         /// </summary>
-        public double Millidegrees => As(AngleUnit.Millidegree);
+        public QuantityValue Millidegrees => this.As(AngleUnit.Millidegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Milliradian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Milliradian"/>
         /// </summary>
-        public double Milliradians => As(AngleUnit.Milliradian);
+        public QuantityValue Milliradians => this.As(AngleUnit.Milliradian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Nanodegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Nanodegree"/>
         /// </summary>
-        public double Nanodegrees => As(AngleUnit.Nanodegree);
+        public QuantityValue Nanodegrees => this.As(AngleUnit.Nanodegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Nanoradian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Nanoradian"/>
         /// </summary>
-        public double Nanoradians => As(AngleUnit.Nanoradian);
+        public QuantityValue Nanoradians => this.As(AngleUnit.Nanoradian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.NatoMil"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.NatoMil"/>
         /// </summary>
-        public double NatoMils => As(AngleUnit.NatoMil);
+        public QuantityValue NatoMils => this.As(AngleUnit.NatoMil);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Radian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Radian"/>
         /// </summary>
-        public double Radians => As(AngleUnit.Radian);
+        public QuantityValue Radians => this.As(AngleUnit.Radian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AngleUnit.Revolution"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AngleUnit.Revolution"/>
         /// </summary>
-        public double Revolutions => As(AngleUnit.Revolution);
+        public QuantityValue Revolutions => this.As(AngleUnit.Revolution);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: AngleUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Arcminute, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Arcsecond, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Centiradian, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Deciradian, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Degree, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Gradian, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Microdegree, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Microradian, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Millidegree, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Milliradian, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Nanodegree, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Nanoradian, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.NatoMil, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Revolution, AngleUnit.Radian, quantity => quantity.ToUnit(AngleUnit.Radian));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Radian, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> AngleUnit
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Arcminute, quantity => quantity.ToUnit(AngleUnit.Arcminute));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Arcsecond, quantity => quantity.ToUnit(AngleUnit.Arcsecond));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Centiradian, quantity => quantity.ToUnit(AngleUnit.Centiradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Deciradian, quantity => quantity.ToUnit(AngleUnit.Deciradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Degree, quantity => quantity.ToUnit(AngleUnit.Degree));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Gradian, quantity => quantity.ToUnit(AngleUnit.Gradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Microdegree, quantity => quantity.ToUnit(AngleUnit.Microdegree));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Microradian, quantity => quantity.ToUnit(AngleUnit.Microradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Millidegree, quantity => quantity.ToUnit(AngleUnit.Millidegree));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Milliradian, quantity => quantity.ToUnit(AngleUnit.Milliradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Nanodegree, quantity => quantity.ToUnit(AngleUnit.Nanodegree));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Nanoradian, quantity => quantity.ToUnit(AngleUnit.Nanoradian));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.NatoMil, quantity => quantity.ToUnit(AngleUnit.NatoMil));
-            unitConverter.SetConversionFunction<Angle>(AngleUnit.Radian, AngleUnit.Revolution, quantity => quantity.ToUnit(AngleUnit.Revolution));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -375,7 +357,7 @@ public static string GetAbbreviation(AngleUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Arcminute"/>.
         /// </summary>
-        public static Angle FromArcminutes(double value)
+        public static Angle FromArcminutes(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Arcminute);
         }
@@ -383,7 +365,7 @@ public static Angle FromArcminutes(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Arcsecond"/>.
         /// </summary>
-        public static Angle FromArcseconds(double value)
+        public static Angle FromArcseconds(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Arcsecond);
         }
@@ -391,7 +373,7 @@ public static Angle FromArcseconds(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Centiradian"/>.
         /// </summary>
-        public static Angle FromCentiradians(double value)
+        public static Angle FromCentiradians(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Centiradian);
         }
@@ -399,7 +381,7 @@ public static Angle FromCentiradians(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Deciradian"/>.
         /// </summary>
-        public static Angle FromDeciradians(double value)
+        public static Angle FromDeciradians(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Deciradian);
         }
@@ -407,7 +389,7 @@ public static Angle FromDeciradians(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Degree"/>.
         /// </summary>
-        public static Angle FromDegrees(double value)
+        public static Angle FromDegrees(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Degree);
         }
@@ -415,7 +397,7 @@ public static Angle FromDegrees(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Gradian"/>.
         /// </summary>
-        public static Angle FromGradians(double value)
+        public static Angle FromGradians(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Gradian);
         }
@@ -423,7 +405,7 @@ public static Angle FromGradians(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Microdegree"/>.
         /// </summary>
-        public static Angle FromMicrodegrees(double value)
+        public static Angle FromMicrodegrees(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Microdegree);
         }
@@ -431,7 +413,7 @@ public static Angle FromMicrodegrees(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Microradian"/>.
         /// </summary>
-        public static Angle FromMicroradians(double value)
+        public static Angle FromMicroradians(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Microradian);
         }
@@ -439,7 +421,7 @@ public static Angle FromMicroradians(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Millidegree"/>.
         /// </summary>
-        public static Angle FromMillidegrees(double value)
+        public static Angle FromMillidegrees(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Millidegree);
         }
@@ -447,7 +429,7 @@ public static Angle FromMillidegrees(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Milliradian"/>.
         /// </summary>
-        public static Angle FromMilliradians(double value)
+        public static Angle FromMilliradians(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Milliradian);
         }
@@ -455,7 +437,7 @@ public static Angle FromMilliradians(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Nanodegree"/>.
         /// </summary>
-        public static Angle FromNanodegrees(double value)
+        public static Angle FromNanodegrees(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Nanodegree);
         }
@@ -463,7 +445,7 @@ public static Angle FromNanodegrees(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Nanoradian"/>.
         /// </summary>
-        public static Angle FromNanoradians(double value)
+        public static Angle FromNanoradians(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Nanoradian);
         }
@@ -471,7 +453,7 @@ public static Angle FromNanoradians(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.NatoMil"/>.
         /// </summary>
-        public static Angle FromNatoMils(double value)
+        public static Angle FromNatoMils(QuantityValue value)
         {
             return new Angle(value, AngleUnit.NatoMil);
         }
@@ -479,7 +461,7 @@ public static Angle FromNatoMils(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Radian"/>.
         /// </summary>
-        public static Angle FromRadians(double value)
+        public static Angle FromRadians(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Radian);
         }
@@ -487,7 +469,7 @@ public static Angle FromRadians(double value)
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Revolution"/>.
         /// </summary>
-        public static Angle FromRevolutions(double value)
+        public static Angle FromRevolutions(QuantityValue value)
         {
             return new Angle(value, AngleUnit.Revolution);
         }
@@ -498,7 +480,7 @@ public static Angle FromRevolutions(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Angle unit value.</returns>
-        public static Angle From(double value, AngleUnit fromUnit)
+        public static Angle From(QuantityValue value, AngleUnit fromUnit)
         {
             return new Angle(value, fromUnit);
         }
@@ -559,10 +541,7 @@ public static Angle Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Angle Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Angle, AngleUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Angle, AngleUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -590,11 +569,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Angle result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Angle result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Angle, AngleUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Angle, AngleUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -615,7 +590,7 @@ public static AngleUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -626,7 +601,7 @@ public static AngleUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AngleUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.AngleUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out AngleUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -641,7 +616,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AngleUnit un
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out AngleUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -660,35 +635,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Angle"/> from adding two <see cref="Angle"/>.</summary>
         public static Angle operator +(Angle left, Angle right)
         {
-            return new Angle(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Angle(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Angle"/> from subtracting two <see cref="Angle"/>.</summary>
         public static Angle operator -(Angle left, Angle right)
         {
-            return new Angle(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Angle(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Angle"/> from multiplying value and <see cref="Angle"/>.</summary>
-        public static Angle operator *(double left, Angle right)
+        public static Angle operator *(QuantityValue left, Angle right)
         {
             return new Angle(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Angle"/> from multiplying value and <see cref="Angle"/>.</summary>
-        public static Angle operator *(Angle left, double right)
+        public static Angle operator *(Angle left, QuantityValue right)
         {
             return new Angle(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Angle"/> from dividing <see cref="Angle"/> by value.</summary>
-        public static Angle operator /(Angle left, double right)
+        public static Angle operator /(Angle left, QuantityValue right)
         {
             return new Angle(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Angle"/> by <see cref="Angle"/>.</summary>
-        public static double operator /(Angle left, Angle right)
+        public static QuantityValue operator /(Angle left, Angle right)
         {
             return left.Radians / right.Radians;
         }
@@ -722,97 +697,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Angle left, Angle right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Angle left, Angle right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Angle left, Angle right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Angle left, Angle right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Angle"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Angle other, Angle tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Angle"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Angle)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Angle left, Angle right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Angle"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Angle other, Angle tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Angle"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Angle,Angle)"/>.
+        ///     See that operator (and <see cref="Equals(Angle)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Angle left, Angle right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Angle"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Angle other, Angle tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Angle"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Angle"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Angle"/>, this method delegates to
+        ///     <see cref="Equals(Angle)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Angle otherQuantity))
+            if (obj is not Angle otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Angle"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Angle other, Angle tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Angle"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Angle other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Angle.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Angle), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Angle"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Angle)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Angle otherQuantity)) throw new ArgumentException("Expected type Angle.", nameof(obj));
+            if (obj is not Angle otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Angle>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Angle"/> with another <see cref="Angle"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Angle"/> with another <see cref="Angle"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -824,157 +813,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Angle other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(AngleUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<AngleUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Angle to another Angle with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Angle with the specified unit.</returns>
-        public Angle ToUnit(AngleUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Angle"/> to another <see cref="Angle"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Angle with the specified unit.</returns>
-        public Angle ToUnit(AngleUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Angle), Unit, typeof(Angle), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Angle)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="Angle"/> to another <see cref="Angle"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Angle"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(AngleUnit unit, [NotNullWhen(true)] out Angle? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Angle? convertedOrNull = (Unit, unit) switch
-            {
-                // AngleUnit -> BaseUnit
-                (AngleUnit.Arcminute, AngleUnit.Radian) => new Angle(_value * Math.PI / (60 * 180), AngleUnit.Radian),
-                (AngleUnit.Arcsecond, AngleUnit.Radian) => new Angle(_value * Math.PI / (3600 * 180), AngleUnit.Radian),
-                (AngleUnit.Centiradian, AngleUnit.Radian) => new Angle((_value) * 1e-2d, AngleUnit.Radian),
-                (AngleUnit.Deciradian, AngleUnit.Radian) => new Angle((_value) * 1e-1d, AngleUnit.Radian),
-                (AngleUnit.Degree, AngleUnit.Radian) => new Angle(_value * Math.PI / 180, AngleUnit.Radian),
-                (AngleUnit.Gradian, AngleUnit.Radian) => new Angle(_value * Math.PI / 200, AngleUnit.Radian),
-                (AngleUnit.Microdegree, AngleUnit.Radian) => new Angle((_value * Math.PI / 180) * 1e-6d, AngleUnit.Radian),
-                (AngleUnit.Microradian, AngleUnit.Radian) => new Angle((_value) * 1e-6d, AngleUnit.Radian),
-                (AngleUnit.Millidegree, AngleUnit.Radian) => new Angle((_value * Math.PI / 180) * 1e-3d, AngleUnit.Radian),
-                (AngleUnit.Milliradian, AngleUnit.Radian) => new Angle((_value) * 1e-3d, AngleUnit.Radian),
-                (AngleUnit.Nanodegree, AngleUnit.Radian) => new Angle((_value * Math.PI / 180) * 1e-9d, AngleUnit.Radian),
-                (AngleUnit.Nanoradian, AngleUnit.Radian) => new Angle((_value) * 1e-9d, AngleUnit.Radian),
-                (AngleUnit.NatoMil, AngleUnit.Radian) => new Angle(_value * Math.PI / 3200, AngleUnit.Radian),
-                (AngleUnit.Revolution, AngleUnit.Radian) => new Angle(_value * 2 * Math.PI, AngleUnit.Radian),
-
-                // BaseUnit -> AngleUnit
-                (AngleUnit.Radian, AngleUnit.Arcminute) => new Angle(_value * 60 * 180 / Math.PI, AngleUnit.Arcminute),
-                (AngleUnit.Radian, AngleUnit.Arcsecond) => new Angle(_value * 3600 * 180 / Math.PI, AngleUnit.Arcsecond),
-                (AngleUnit.Radian, AngleUnit.Centiradian) => new Angle((_value) / 1e-2d, AngleUnit.Centiradian),
-                (AngleUnit.Radian, AngleUnit.Deciradian) => new Angle((_value) / 1e-1d, AngleUnit.Deciradian),
-                (AngleUnit.Radian, AngleUnit.Degree) => new Angle(_value * 180 / Math.PI, AngleUnit.Degree),
-                (AngleUnit.Radian, AngleUnit.Gradian) => new Angle(_value * 200 / Math.PI, AngleUnit.Gradian),
-                (AngleUnit.Radian, AngleUnit.Microdegree) => new Angle((_value * 180 / Math.PI) / 1e-6d, AngleUnit.Microdegree),
-                (AngleUnit.Radian, AngleUnit.Microradian) => new Angle((_value) / 1e-6d, AngleUnit.Microradian),
-                (AngleUnit.Radian, AngleUnit.Millidegree) => new Angle((_value * 180 / Math.PI) / 1e-3d, AngleUnit.Millidegree),
-                (AngleUnit.Radian, AngleUnit.Milliradian) => new Angle((_value) / 1e-3d, AngleUnit.Milliradian),
-                (AngleUnit.Radian, AngleUnit.Nanodegree) => new Angle((_value * 180 / Math.PI) / 1e-9d, AngleUnit.Nanodegree),
-                (AngleUnit.Radian, AngleUnit.Nanoradian) => new Angle((_value) / 1e-9d, AngleUnit.Nanoradian),
-                (AngleUnit.Radian, AngleUnit.NatoMil) => new Angle(_value * 3200 / Math.PI, AngleUnit.NatoMil),
-                (AngleUnit.Radian, AngleUnit.Revolution) => new Angle(_value / (2 * Math.PI), AngleUnit.Revolution),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not AngleUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AngleUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is AngleUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AngleUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<AngleUnit> IQuantity<AngleUnit>.ToUnit(AngleUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -988,11 +829,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Area.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
index 971074a1b1..0db6e3a84a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Area.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,16 @@ namespace UnitsNet
     ///     Area is a quantity that expresses the extent of a two-dimensional surface or shape, or planar lamina, in the plane. Area can be understood as the amount of material with a given thickness that would be necessary to fashion a model of the shape, or the amount of paint necessary to cover the surface with a single coat.[1] It is the two-dimensional analog of the length of a curve (a one-dimensional concept) or the volume of a solid (a three-dimensional concept).
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Area :
-        IArithmeticQuantity<Area, AreaUnit>,
+        ILinearQuantity<Area, AreaUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Area, Area, double>,
+        IDivisionOperators<Area, Area, QuantityValue>,
+        IMultiplyOperators<Area, Area, AreaMomentOfInertia>,
+        IMultiplyOperators<Area, AbsorbedDoseOfIonizingRadiation, DoseAreaProduct>,
+        IMultiplyOperators<Area, ElectricSurfaceChargeDensity, ElectricCharge>,
+        IMultiplyOperators<Area, ElectricCurrentDensity, ElectricCurrent>,
         IMultiplyOperators<Area, Pressure, Force>,
         IMultiplyOperators<Area, SpecificWeight, ForcePerLength>,
         IMultiplyOperators<Area, ReciprocalLength, Length>,
@@ -47,6 +50,7 @@ namespace UnitsNet
         IMultiplyOperators<Area, Density, LinearDensity>,
         IMultiplyOperators<Area, Illuminance, LuminousFlux>,
         IMultiplyOperators<Area, Luminance, LuminousIntensity>,
+        IMultiplyOperators<Area, MagneticField, MagneticFlux>,
         IMultiplyOperators<Area, AreaDensity, Mass>,
         IMultiplyOperators<Area, MassFlux, MassFlow>,
         IMultiplyOperators<Area, HeatFlux, Power>,
@@ -56,6 +60,7 @@ namespace UnitsNet
         IMultiplyOperators<Area, Length, Volume>,
         IDivisionOperators<Area, ReciprocalLength, Volume>,
         IMultiplyOperators<Area, Speed, VolumeFlow>,
+        IMultiplyOperators<Area, VolumeFlowPerArea, VolumeFlow>,
         IComparisonOperators<Area, Area, bool>,
         IParsable<Area>,
 #endif
@@ -68,7 +73,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -118,7 +123,7 @@ public static AreaInfo CreateDefault(Func<IEnumerable<UnitDefinition<AreaUnit>>,
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Area"/> is [L^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Area"/> is L^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
 
@@ -133,28 +138,52 @@ public static AreaInfo CreateDefault(Func<IEnumerable<UnitDefinition<AreaUnit>>,
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{AreaUnit}"/> representing the default unit mappings for Area.</returns>
             public static IEnumerable<UnitDefinition<AreaUnit>> GetDefaultMappings()
             {
-                yield return new (AreaUnit.Acre, "Acre", "Acres", BaseUnits.Undefined);
-                yield return new (AreaUnit.Hectare, "Hectare", "Hectares", BaseUnits.Undefined);
-                yield return new (AreaUnit.SquareCentimeter, "SquareCentimeter", "SquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter));
-                yield return new (AreaUnit.SquareDecimeter, "SquareDecimeter", "SquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter));
-                yield return new (AreaUnit.SquareFoot, "SquareFoot", "SquareFeet", new BaseUnits(length: LengthUnit.Foot));
-                yield return new (AreaUnit.SquareInch, "SquareInch", "SquareInches", new BaseUnits(length: LengthUnit.Inch));
-                yield return new (AreaUnit.SquareKilometer, "SquareKilometer", "SquareKilometers", new BaseUnits(length: LengthUnit.Kilometer));
+                yield return new (AreaUnit.Acre, "Acre", "Acres", BaseUnits.Undefined,
+                     new QuantityValue(78125, 316160658)
+                );
+                yield return new (AreaUnit.Hectare, "Hectare", "Hectares", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (AreaUnit.SquareCentimeter, "SquareCentimeter", "SquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter),
+                     10000
+                );
+                yield return new (AreaUnit.SquareDecimeter, "SquareDecimeter", "SquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter),
+                     100
+                );
+                yield return new (AreaUnit.SquareFoot, "SquareFoot", "SquareFeet", new BaseUnits(length: LengthUnit.Foot),
+                     new QuantityValue(1562500, 145161)
+                );
+                yield return new (AreaUnit.SquareInch, "SquareInch", "SquareInches", new BaseUnits(length: LengthUnit.Inch),
+                     new QuantityValue(25000000, 16129)
+                );
+                yield return new (AreaUnit.SquareKilometer, "SquareKilometer", "SquareKilometers", new BaseUnits(length: LengthUnit.Kilometer),
+                     new QuantityValue(1, 1000000)
+                );
                 yield return new (AreaUnit.SquareMeter, "SquareMeter", "SquareMeters", new BaseUnits(length: LengthUnit.Meter));
-                yield return new (AreaUnit.SquareMicrometer, "SquareMicrometer", "SquareMicrometers", new BaseUnits(length: LengthUnit.Micrometer));
-                yield return new (AreaUnit.SquareMile, "SquareMile", "SquareMiles", new BaseUnits(length: LengthUnit.Mile));
-                yield return new (AreaUnit.SquareMillimeter, "SquareMillimeter", "SquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter));
-                yield return new (AreaUnit.SquareNauticalMile, "SquareNauticalMile", "SquareNauticalMiles", BaseUnits.Undefined);
-                yield return new (AreaUnit.SquareYard, "SquareYard", "SquareYards", new BaseUnits(length: LengthUnit.Yard));
-                yield return new (AreaUnit.UsSurveySquareFoot, "UsSurveySquareFoot", "UsSurveySquareFeet", new BaseUnits(length: LengthUnit.UsSurveyFoot));
+                yield return new (AreaUnit.SquareMicrometer, "SquareMicrometer", "SquareMicrometers", new BaseUnits(length: LengthUnit.Micrometer),
+                     1000000000000
+                );
+                yield return new (AreaUnit.SquareMile, "SquareMile", "SquareMiles", new BaseUnits(length: LengthUnit.Mile),
+                     new QuantityValue(15625, 40468564224)
+                );
+                yield return new (AreaUnit.SquareMillimeter, "SquareMillimeter", "SquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter),
+                     1000000
+                );
+                yield return new (AreaUnit.SquareNauticalMile, "SquareNauticalMile", "SquareNauticalMiles", BaseUnits.Undefined,
+                     new QuantityValue(1, 3429904)
+                );
+                yield return new (AreaUnit.SquareYard, "SquareYard", "SquareYards", new BaseUnits(length: LengthUnit.Yard),
+                     new QuantityValue(1562500, 1306449)
+                );
+                yield return new (AreaUnit.UsSurveySquareFoot, "UsSurveySquareFoot", "UsSurveySquareFeet", new BaseUnits(length: LengthUnit.UsSurveyFoot),
+                     new QuantityValue(15499969, 1440000)
+                );
             }
         }
 
         static Area()
         {
-            Info = AreaInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(AreaInfo.CreateDefault);
         }
 
         /// <summary>
@@ -162,7 +191,7 @@ static Area()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Area(double value, AreaUnit unit)
+        public Area(QuantityValue value, AreaUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -176,7 +205,7 @@ public Area(double value, AreaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Area(double value, UnitSystem unitSystem)
+        public Area(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -187,7 +216,8 @@ public Area(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Area" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Area, AreaUnit> Info { get; }
@@ -216,10 +246,8 @@ public Area(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public AreaUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -253,119 +281,79 @@ public Area(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.Acre"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.Acre"/>
         /// </summary>
-        public double Acres => As(AreaUnit.Acre);
+        public QuantityValue Acres => this.As(AreaUnit.Acre);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.Hectare"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.Hectare"/>
         /// </summary>
-        public double Hectares => As(AreaUnit.Hectare);
+        public QuantityValue Hectares => this.As(AreaUnit.Hectare);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareCentimeter"/>
         /// </summary>
-        public double SquareCentimeters => As(AreaUnit.SquareCentimeter);
+        public QuantityValue SquareCentimeters => this.As(AreaUnit.SquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareDecimeter"/>
         /// </summary>
-        public double SquareDecimeters => As(AreaUnit.SquareDecimeter);
+        public QuantityValue SquareDecimeters => this.As(AreaUnit.SquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareFoot"/>
         /// </summary>
-        public double SquareFeet => As(AreaUnit.SquareFoot);
+        public QuantityValue SquareFeet => this.As(AreaUnit.SquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareInch"/>
         /// </summary>
-        public double SquareInches => As(AreaUnit.SquareInch);
+        public QuantityValue SquareInches => this.As(AreaUnit.SquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareKilometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareKilometer"/>
         /// </summary>
-        public double SquareKilometers => As(AreaUnit.SquareKilometer);
+        public QuantityValue SquareKilometers => this.As(AreaUnit.SquareKilometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareMeter"/>
         /// </summary>
-        public double SquareMeters => As(AreaUnit.SquareMeter);
+        public QuantityValue SquareMeters => this.As(AreaUnit.SquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareMicrometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareMicrometer"/>
         /// </summary>
-        public double SquareMicrometers => As(AreaUnit.SquareMicrometer);
+        public QuantityValue SquareMicrometers => this.As(AreaUnit.SquareMicrometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareMile"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareMile"/>
         /// </summary>
-        public double SquareMiles => As(AreaUnit.SquareMile);
+        public QuantityValue SquareMiles => this.As(AreaUnit.SquareMile);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareMillimeter"/>
         /// </summary>
-        public double SquareMillimeters => As(AreaUnit.SquareMillimeter);
+        public QuantityValue SquareMillimeters => this.As(AreaUnit.SquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareNauticalMile"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareNauticalMile"/>
         /// </summary>
-        public double SquareNauticalMiles => As(AreaUnit.SquareNauticalMile);
+        public QuantityValue SquareNauticalMiles => this.As(AreaUnit.SquareNauticalMile);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.SquareYard"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.SquareYard"/>
         /// </summary>
-        public double SquareYards => As(AreaUnit.SquareYard);
+        public QuantityValue SquareYards => this.As(AreaUnit.SquareYard);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaUnit.UsSurveySquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaUnit.UsSurveySquareFoot"/>
         /// </summary>
-        public double UsSurveySquareFeet => As(AreaUnit.UsSurveySquareFoot);
+        public QuantityValue UsSurveySquareFeet => this.As(AreaUnit.UsSurveySquareFoot);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: AreaUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Area>(AreaUnit.Acre, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.Hectare, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareCentimeter, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareDecimeter, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareFoot, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareInch, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareKilometer, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMicrometer, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMile, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMillimeter, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareNauticalMile, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareYard, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.UsSurveySquareFoot, AreaUnit.SquareMeter, quantity => quantity.ToUnit(AreaUnit.SquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> AreaUnit
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.Acre, quantity => quantity.ToUnit(AreaUnit.Acre));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.Hectare, quantity => quantity.ToUnit(AreaUnit.Hectare));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareCentimeter, quantity => quantity.ToUnit(AreaUnit.SquareCentimeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareDecimeter, quantity => quantity.ToUnit(AreaUnit.SquareDecimeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareFoot, quantity => quantity.ToUnit(AreaUnit.SquareFoot));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareInch, quantity => quantity.ToUnit(AreaUnit.SquareInch));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareKilometer, quantity => quantity.ToUnit(AreaUnit.SquareKilometer));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareMicrometer, quantity => quantity.ToUnit(AreaUnit.SquareMicrometer));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareMile, quantity => quantity.ToUnit(AreaUnit.SquareMile));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareMillimeter, quantity => quantity.ToUnit(AreaUnit.SquareMillimeter));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareNauticalMile, quantity => quantity.ToUnit(AreaUnit.SquareNauticalMile));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.SquareYard, quantity => quantity.ToUnit(AreaUnit.SquareYard));
-            unitConverter.SetConversionFunction<Area>(AreaUnit.SquareMeter, AreaUnit.UsSurveySquareFoot, quantity => quantity.ToUnit(AreaUnit.UsSurveySquareFoot));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -394,7 +382,7 @@ public static string GetAbbreviation(AreaUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.Acre"/>.
         /// </summary>
-        public static Area FromAcres(double value)
+        public static Area FromAcres(QuantityValue value)
         {
             return new Area(value, AreaUnit.Acre);
         }
@@ -402,7 +390,7 @@ public static Area FromAcres(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.Hectare"/>.
         /// </summary>
-        public static Area FromHectares(double value)
+        public static Area FromHectares(QuantityValue value)
         {
             return new Area(value, AreaUnit.Hectare);
         }
@@ -410,7 +398,7 @@ public static Area FromHectares(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareCentimeter"/>.
         /// </summary>
-        public static Area FromSquareCentimeters(double value)
+        public static Area FromSquareCentimeters(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareCentimeter);
         }
@@ -418,7 +406,7 @@ public static Area FromSquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareDecimeter"/>.
         /// </summary>
-        public static Area FromSquareDecimeters(double value)
+        public static Area FromSquareDecimeters(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareDecimeter);
         }
@@ -426,7 +414,7 @@ public static Area FromSquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareFoot"/>.
         /// </summary>
-        public static Area FromSquareFeet(double value)
+        public static Area FromSquareFeet(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareFoot);
         }
@@ -434,7 +422,7 @@ public static Area FromSquareFeet(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareInch"/>.
         /// </summary>
-        public static Area FromSquareInches(double value)
+        public static Area FromSquareInches(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareInch);
         }
@@ -442,7 +430,7 @@ public static Area FromSquareInches(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareKilometer"/>.
         /// </summary>
-        public static Area FromSquareKilometers(double value)
+        public static Area FromSquareKilometers(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareKilometer);
         }
@@ -450,7 +438,7 @@ public static Area FromSquareKilometers(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMeter"/>.
         /// </summary>
-        public static Area FromSquareMeters(double value)
+        public static Area FromSquareMeters(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareMeter);
         }
@@ -458,7 +446,7 @@ public static Area FromSquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMicrometer"/>.
         /// </summary>
-        public static Area FromSquareMicrometers(double value)
+        public static Area FromSquareMicrometers(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareMicrometer);
         }
@@ -466,7 +454,7 @@ public static Area FromSquareMicrometers(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMile"/>.
         /// </summary>
-        public static Area FromSquareMiles(double value)
+        public static Area FromSquareMiles(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareMile);
         }
@@ -474,7 +462,7 @@ public static Area FromSquareMiles(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMillimeter"/>.
         /// </summary>
-        public static Area FromSquareMillimeters(double value)
+        public static Area FromSquareMillimeters(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareMillimeter);
         }
@@ -482,7 +470,7 @@ public static Area FromSquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareNauticalMile"/>.
         /// </summary>
-        public static Area FromSquareNauticalMiles(double value)
+        public static Area FromSquareNauticalMiles(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareNauticalMile);
         }
@@ -490,7 +478,7 @@ public static Area FromSquareNauticalMiles(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareYard"/>.
         /// </summary>
-        public static Area FromSquareYards(double value)
+        public static Area FromSquareYards(QuantityValue value)
         {
             return new Area(value, AreaUnit.SquareYard);
         }
@@ -498,7 +486,7 @@ public static Area FromSquareYards(double value)
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.UsSurveySquareFoot"/>.
         /// </summary>
-        public static Area FromUsSurveySquareFeet(double value)
+        public static Area FromUsSurveySquareFeet(QuantityValue value)
         {
             return new Area(value, AreaUnit.UsSurveySquareFoot);
         }
@@ -509,7 +497,7 @@ public static Area FromUsSurveySquareFeet(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Area unit value.</returns>
-        public static Area From(double value, AreaUnit fromUnit)
+        public static Area From(QuantityValue value, AreaUnit fromUnit)
         {
             return new Area(value, fromUnit);
         }
@@ -570,10 +558,7 @@ public static Area Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Area Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Area, AreaUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Area, AreaUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -601,11 +586,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Area result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Area result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Area, AreaUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Area, AreaUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -626,7 +607,7 @@ public static AreaUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -637,7 +618,7 @@ public static AreaUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AreaUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.AreaUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out AreaUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -652,7 +633,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AreaUnit uni
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out AreaUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -671,35 +652,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Area"/> from adding two <see cref="Area"/>.</summary>
         public static Area operator +(Area left, Area right)
         {
-            return new Area(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Area(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Area"/> from subtracting two <see cref="Area"/>.</summary>
         public static Area operator -(Area left, Area right)
         {
-            return new Area(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Area(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Area"/> from multiplying value and <see cref="Area"/>.</summary>
-        public static Area operator *(double left, Area right)
+        public static Area operator *(QuantityValue left, Area right)
         {
             return new Area(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Area"/> from multiplying value and <see cref="Area"/>.</summary>
-        public static Area operator *(Area left, double right)
+        public static Area operator *(Area left, QuantityValue right)
         {
             return new Area(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Area"/> from dividing <see cref="Area"/> by value.</summary>
-        public static Area operator /(Area left, double right)
+        public static Area operator /(Area left, QuantityValue right)
         {
             return new Area(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Area"/> by <see cref="Area"/>.</summary>
-        public static double operator /(Area left, Area right)
+        public static QuantityValue operator /(Area left, Area right)
         {
             return left.SquareMeters / right.SquareMeters;
         }
@@ -712,7 +693,31 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <returns>The corresponding inverse quantity, <see cref="ReciprocalArea"/>.</returns>
         public ReciprocalArea Inverse()
         {
-            return ReciprocalArea.FromInverseSquareMeters(1 / SquareMeters);
+            return UnitConverter.Default.ConvertTo(Value, Unit, ReciprocalArea.Info);
+        }
+
+        /// <summary>Get <see cref="AreaMomentOfInertia"/> from <see cref="Area"/> * <see cref="Area"/>.</summary>
+        public static AreaMomentOfInertia operator *(Area left, Area right)
+        {
+            return AreaMomentOfInertia.FromMetersToTheFourth(left.SquareMeters * right.SquareMeters);
+        }
+
+        /// <summary>Get <see cref="DoseAreaProduct"/> from <see cref="Area"/> * <see cref="AbsorbedDoseOfIonizingRadiation"/>.</summary>
+        public static DoseAreaProduct operator *(Area area, AbsorbedDoseOfIonizingRadiation absorbedDoseOfIonizingRadiation)
+        {
+            return DoseAreaProduct.FromGraySquareMeters(area.SquareMeters * absorbedDoseOfIonizingRadiation.Grays);
+        }
+
+        /// <summary>Get <see cref="ElectricCharge"/> from <see cref="Area"/> * <see cref="ElectricSurfaceChargeDensity"/>.</summary>
+        public static ElectricCharge operator *(Area area, ElectricSurfaceChargeDensity electricSurfaceChargeDensity)
+        {
+            return ElectricCharge.FromCoulombs(area.SquareMeters * electricSurfaceChargeDensity.CoulombsPerSquareMeter);
+        }
+
+        /// <summary>Get <see cref="ElectricCurrent"/> from <see cref="Area"/> * <see cref="ElectricCurrentDensity"/>.</summary>
+        public static ElectricCurrent operator *(Area area, ElectricCurrentDensity electricCurrentDensity)
+        {
+            return ElectricCurrent.FromAmperes(area.SquareMeters * electricCurrentDensity.AmperesPerSquareMeter);
         }
 
         /// <summary>Get <see cref="Force"/> from <see cref="Area"/> * <see cref="Pressure"/>.</summary>
@@ -757,6 +762,12 @@ public ReciprocalArea Inverse()
             return LuminousIntensity.FromCandela(area.SquareMeters * luminance.CandelasPerSquareMeter);
         }
 
+        /// <summary>Get <see cref="MagneticFlux"/> from <see cref="Area"/> * <see cref="MagneticField"/>.</summary>
+        public static MagneticFlux operator *(Area area, MagneticField magneticField)
+        {
+            return MagneticFlux.FromWebers(area.SquareMeters * magneticField.Teslas);
+        }
+
         /// <summary>Get <see cref="Mass"/> from <see cref="Area"/> * <see cref="AreaDensity"/>.</summary>
         public static Mass operator *(Area area, AreaDensity areaDensity)
         {
@@ -811,6 +822,12 @@ public ReciprocalArea Inverse()
             return VolumeFlow.FromCubicMetersPerSecond(area.SquareMeters * speed.MetersPerSecond);
         }
 
+        /// <summary>Get <see cref="VolumeFlow"/> from <see cref="Area"/> * <see cref="VolumeFlowPerArea"/>.</summary>
+        public static VolumeFlow operator *(Area area, VolumeFlowPerArea volumeFlowPerArea)
+        {
+            return VolumeFlow.FromCubicMetersPerSecond(area.SquareMeters * volumeFlowPerArea.CubicMetersPerSecondPerSquareMeter);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -818,97 +835,111 @@ public ReciprocalArea Inverse()
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Area left, Area right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Area left, Area right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Area left, Area right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Area left, Area right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Area"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Area other, Area tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Area"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Area)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Area left, Area right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Area"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Area other, Area tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Area"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Area,Area)"/>.
+        ///     See that operator (and <see cref="Equals(Area)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Area left, Area right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Area"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Area other, Area tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Area"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Area"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Area"/>, this method delegates to
+        ///     <see cref="Equals(Area)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Area otherQuantity))
+            if (obj is not Area otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Area"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Area other, Area tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Area"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Area other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Area.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Area), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Area"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Area)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Area otherQuantity)) throw new ArgumentException("Expected type Area.", nameof(obj));
+            if (obj is not Area otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Area>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Area"/> with another <see cref="Area"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Area"/> with another <see cref="Area"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -920,157 +951,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Area other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(AreaUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<AreaUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Area to another Area with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Area with the specified unit.</returns>
-        public Area ToUnit(AreaUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Area"/> to another <see cref="Area"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Area with the specified unit.</returns>
-        public Area ToUnit(AreaUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Area), Unit, typeof(Area), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Area)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Area"/> to another <see cref="Area"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Area"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(AreaUnit unit, [NotNullWhen(true)] out Area? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Area? convertedOrNull = (Unit, unit) switch
-            {
-                // AreaUnit -> BaseUnit
-                (AreaUnit.Acre, AreaUnit.SquareMeter) => new Area(_value * 4046.8564224, AreaUnit.SquareMeter),
-                (AreaUnit.Hectare, AreaUnit.SquareMeter) => new Area(_value * 1e4, AreaUnit.SquareMeter),
-                (AreaUnit.SquareCentimeter, AreaUnit.SquareMeter) => new Area(_value * 1e-4, AreaUnit.SquareMeter),
-                (AreaUnit.SquareDecimeter, AreaUnit.SquareMeter) => new Area(_value * 1e-2, AreaUnit.SquareMeter),
-                (AreaUnit.SquareFoot, AreaUnit.SquareMeter) => new Area(_value * 9.290304e-2, AreaUnit.SquareMeter),
-                (AreaUnit.SquareInch, AreaUnit.SquareMeter) => new Area(_value * 0.00064516, AreaUnit.SquareMeter),
-                (AreaUnit.SquareKilometer, AreaUnit.SquareMeter) => new Area(_value * 1e6, AreaUnit.SquareMeter),
-                (AreaUnit.SquareMicrometer, AreaUnit.SquareMeter) => new Area(_value * 1e-12, AreaUnit.SquareMeter),
-                (AreaUnit.SquareMile, AreaUnit.SquareMeter) => new Area(_value * 1609.344 * 1609.344, AreaUnit.SquareMeter),
-                (AreaUnit.SquareMillimeter, AreaUnit.SquareMeter) => new Area(_value * 1e-6, AreaUnit.SquareMeter),
-                (AreaUnit.SquareNauticalMile, AreaUnit.SquareMeter) => new Area(_value * 3429904, AreaUnit.SquareMeter),
-                (AreaUnit.SquareYard, AreaUnit.SquareMeter) => new Area(_value * 0.9144 * 0.9144, AreaUnit.SquareMeter),
-                (AreaUnit.UsSurveySquareFoot, AreaUnit.SquareMeter) => new Area(_value * (1200.0 / 3937.0) * (1200.0 / 3937.0), AreaUnit.SquareMeter),
-
-                // BaseUnit -> AreaUnit
-                (AreaUnit.SquareMeter, AreaUnit.Acre) => new Area(_value / 4046.8564224, AreaUnit.Acre),
-                (AreaUnit.SquareMeter, AreaUnit.Hectare) => new Area(_value / 1e4, AreaUnit.Hectare),
-                (AreaUnit.SquareMeter, AreaUnit.SquareCentimeter) => new Area(_value / 1e-4, AreaUnit.SquareCentimeter),
-                (AreaUnit.SquareMeter, AreaUnit.SquareDecimeter) => new Area(_value / 1e-2, AreaUnit.SquareDecimeter),
-                (AreaUnit.SquareMeter, AreaUnit.SquareFoot) => new Area(_value / 9.290304e-2, AreaUnit.SquareFoot),
-                (AreaUnit.SquareMeter, AreaUnit.SquareInch) => new Area(_value / 0.00064516, AreaUnit.SquareInch),
-                (AreaUnit.SquareMeter, AreaUnit.SquareKilometer) => new Area(_value / 1e6, AreaUnit.SquareKilometer),
-                (AreaUnit.SquareMeter, AreaUnit.SquareMicrometer) => new Area(_value / 1e-12, AreaUnit.SquareMicrometer),
-                (AreaUnit.SquareMeter, AreaUnit.SquareMile) => new Area(_value / 1609.344 / 1609.344, AreaUnit.SquareMile),
-                (AreaUnit.SquareMeter, AreaUnit.SquareMillimeter) => new Area(_value / 1e-6, AreaUnit.SquareMillimeter),
-                (AreaUnit.SquareMeter, AreaUnit.SquareNauticalMile) => new Area(_value / 3429904, AreaUnit.SquareNauticalMile),
-                (AreaUnit.SquareMeter, AreaUnit.SquareYard) => new Area(_value / 0.9144 / 0.9144, AreaUnit.SquareYard),
-                (AreaUnit.SquareMeter, AreaUnit.UsSurveySquareFoot) => new Area(_value / (1200.0 / 3937.0) / (1200.0 / 3937.0), AreaUnit.UsSurveySquareFoot),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not AreaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is AreaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<AreaUnit> IQuantity<AreaUnit>.ToUnit(AreaUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -1082,11 +967,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
index 2b662909c4..5e304a5a93 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,12 +33,17 @@ namespace UnitsNet
     ///     The area density of a two-dimensional object is calculated as the mass per unit area. For paper this is also called grammage.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct AreaDensity :
-        IArithmeticQuantity<AreaDensity, AreaDensityUnit>,
+        ILinearQuantity<AreaDensity, AreaDensityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<AreaDensity, AreaDensity, double>,
+        IDivisionOperators<AreaDensity, AreaDensity, QuantityValue>,
+        IDivisionOperators<AreaDensity, Length, Density>,
+        IDivisionOperators<AreaDensity, Density, Length>,
+        IMultiplyOperators<AreaDensity, Length, LinearDensity>,
         IMultiplyOperators<AreaDensity, Area, Mass>,
+        IMultiplyOperators<AreaDensity, Acceleration, Pressure>,
         IComparisonOperators<AreaDensity, AreaDensity, bool>,
         IParsable<AreaDensity>,
 #endif
@@ -53,7 +56,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +106,7 @@ public static AreaDensityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Area
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="AreaDensity"/> is [L^-2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="AreaDensity"/> is L^-2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 1, 0, 0, 0, 0, 0);
 
@@ -118,17 +121,25 @@ public static AreaDensityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Area
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{AreaDensityUnit}"/> representing the default unit mappings for AreaDensity.</returns>
             public static IEnumerable<UnitDefinition<AreaDensityUnit>> GetDefaultMappings()
             {
-                yield return new (AreaDensityUnit.GramPerSquareMeter, "GramPerSquareMeter", "GramsPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram));
+                yield return new (AreaDensityUnit.GramPerSquareMeter, "GramPerSquareMeter", "GramsPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram),
+                     1000
+                );
                 yield return new (AreaDensityUnit.KilogramPerSquareMeter, "KilogramPerSquareMeter", "KilogramsPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram));
-                yield return new (AreaDensityUnit.MilligramPerSquareMeter, "MilligramPerSquareMeter", "MilligramsPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram));
+                yield return new (AreaDensityUnit.MilligramPerSquareMeter, "MilligramPerSquareMeter", "MilligramsPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram),
+                     1000000
+                );
+                yield return new (AreaDensityUnit.PoundPerSquareFoot, "PoundPerSquareFoot", "PoundsPerSquareFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound),
+                     new QuantityValue(9290304, 45359237)
+                );
+                yield return new (AreaDensityUnit.PoundPerThousandSquareFeet, "PoundPerThousandSquareFeet", "PoundsPerThousandSquareFeet", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound),
+                     new QuantityValue(9290304000, 45359237)
+                );
             }
         }
 
         static AreaDensity()
         {
-            Info = AreaDensityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(AreaDensityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +147,7 @@ static AreaDensity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public AreaDensity(double value, AreaDensityUnit unit)
+        public AreaDensity(QuantityValue value, AreaDensityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -150,7 +161,7 @@ public AreaDensity(double value, AreaDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public AreaDensity(double value, UnitSystem unitSystem)
+        public AreaDensity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -161,7 +172,8 @@ public AreaDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="AreaDensity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<AreaDensity, AreaDensityUnit> Info { get; }
@@ -190,10 +202,8 @@ public AreaDensity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public AreaDensityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,41 +237,33 @@ public AreaDensity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaDensityUnit.GramPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaDensityUnit.GramPerSquareMeter"/>
         /// </summary>
-        public double GramsPerSquareMeter => As(AreaDensityUnit.GramPerSquareMeter);
+        public QuantityValue GramsPerSquareMeter => this.As(AreaDensityUnit.GramPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaDensityUnit.KilogramPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaDensityUnit.KilogramPerSquareMeter"/>
         /// </summary>
-        public double KilogramsPerSquareMeter => As(AreaDensityUnit.KilogramPerSquareMeter);
+        public QuantityValue KilogramsPerSquareMeter => this.As(AreaDensityUnit.KilogramPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaDensityUnit.MilligramPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaDensityUnit.MilligramPerSquareMeter"/>
         /// </summary>
-        public double MilligramsPerSquareMeter => As(AreaDensityUnit.MilligramPerSquareMeter);
-
-        #endregion
+        public QuantityValue MilligramsPerSquareMeter => this.As(AreaDensityUnit.MilligramPerSquareMeter);
 
-        #region Static Methods
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaDensityUnit.PoundPerSquareFoot"/>
+        /// </summary>
+        public QuantityValue PoundsPerSquareFoot => this.As(AreaDensityUnit.PoundPerSquareFoot);
 
         /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaDensityUnit.PoundPerThousandSquareFeet"/>
         /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: AreaDensityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<AreaDensity>(AreaDensityUnit.GramPerSquareMeter, AreaDensityUnit.KilogramPerSquareMeter, quantity => quantity.ToUnit(AreaDensityUnit.KilogramPerSquareMeter));
-            unitConverter.SetConversionFunction<AreaDensity>(AreaDensityUnit.MilligramPerSquareMeter, AreaDensityUnit.KilogramPerSquareMeter, quantity => quantity.ToUnit(AreaDensityUnit.KilogramPerSquareMeter));
+        public QuantityValue PoundsPerThousandSquareFeet => this.As(AreaDensityUnit.PoundPerThousandSquareFeet);
 
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<AreaDensity>(AreaDensityUnit.KilogramPerSquareMeter, AreaDensityUnit.KilogramPerSquareMeter, quantity => quantity);
+        #endregion
 
-            // Register in unit converter: BaseUnit -> AreaDensityUnit
-            unitConverter.SetConversionFunction<AreaDensity>(AreaDensityUnit.KilogramPerSquareMeter, AreaDensityUnit.GramPerSquareMeter, quantity => quantity.ToUnit(AreaDensityUnit.GramPerSquareMeter));
-            unitConverter.SetConversionFunction<AreaDensity>(AreaDensityUnit.KilogramPerSquareMeter, AreaDensityUnit.MilligramPerSquareMeter, quantity => quantity.ToUnit(AreaDensityUnit.MilligramPerSquareMeter));
-        }
+        #region Static Methods
 
         /// <summary>
         ///     Get unit abbreviation string.
@@ -291,7 +293,7 @@ public static string GetAbbreviation(AreaDensityUnit unit, IFormatProvider? prov
         /// <summary>
         ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.GramPerSquareMeter"/>.
         /// </summary>
-        public static AreaDensity FromGramsPerSquareMeter(double value)
+        public static AreaDensity FromGramsPerSquareMeter(QuantityValue value)
         {
             return new AreaDensity(value, AreaDensityUnit.GramPerSquareMeter);
         }
@@ -299,7 +301,7 @@ public static AreaDensity FromGramsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.KilogramPerSquareMeter"/>.
         /// </summary>
-        public static AreaDensity FromKilogramsPerSquareMeter(double value)
+        public static AreaDensity FromKilogramsPerSquareMeter(QuantityValue value)
         {
             return new AreaDensity(value, AreaDensityUnit.KilogramPerSquareMeter);
         }
@@ -307,18 +309,34 @@ public static AreaDensity FromKilogramsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.MilligramPerSquareMeter"/>.
         /// </summary>
-        public static AreaDensity FromMilligramsPerSquareMeter(double value)
+        public static AreaDensity FromMilligramsPerSquareMeter(QuantityValue value)
         {
             return new AreaDensity(value, AreaDensityUnit.MilligramPerSquareMeter);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.PoundPerSquareFoot"/>.
+        /// </summary>
+        public static AreaDensity FromPoundsPerSquareFoot(QuantityValue value)
+        {
+            return new AreaDensity(value, AreaDensityUnit.PoundPerSquareFoot);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.PoundPerThousandSquareFeet"/>.
+        /// </summary>
+        public static AreaDensity FromPoundsPerThousandSquareFeet(QuantityValue value)
+        {
+            return new AreaDensity(value, AreaDensityUnit.PoundPerThousandSquareFeet);
+        }
+
         /// <summary>
         ///     Dynamically convert from value and unit enum <see cref="AreaDensityUnit" /> to <see cref="AreaDensity" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>AreaDensity unit value.</returns>
-        public static AreaDensity From(double value, AreaDensityUnit fromUnit)
+        public static AreaDensity From(QuantityValue value, AreaDensityUnit fromUnit)
         {
             return new AreaDensity(value, fromUnit);
         }
@@ -379,10 +397,7 @@ public static AreaDensity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static AreaDensity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<AreaDensity, AreaDensityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<AreaDensity, AreaDensityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -410,11 +425,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out AreaDensity resu
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out AreaDensity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<AreaDensity, AreaDensityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<AreaDensity, AreaDensityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -435,7 +446,7 @@ public static AreaDensityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -446,7 +457,7 @@ public static AreaDensityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AreaDensityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.AreaDensityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out AreaDensityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -461,7 +472,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AreaDensityU
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out AreaDensityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -480,35 +491,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="AreaDensity"/> from adding two <see cref="AreaDensity"/>.</summary>
         public static AreaDensity operator +(AreaDensity left, AreaDensity right)
         {
-            return new AreaDensity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new AreaDensity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="AreaDensity"/> from subtracting two <see cref="AreaDensity"/>.</summary>
         public static AreaDensity operator -(AreaDensity left, AreaDensity right)
         {
-            return new AreaDensity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new AreaDensity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="AreaDensity"/> from multiplying value and <see cref="AreaDensity"/>.</summary>
-        public static AreaDensity operator *(double left, AreaDensity right)
+        public static AreaDensity operator *(QuantityValue left, AreaDensity right)
         {
             return new AreaDensity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="AreaDensity"/> from multiplying value and <see cref="AreaDensity"/>.</summary>
-        public static AreaDensity operator *(AreaDensity left, double right)
+        public static AreaDensity operator *(AreaDensity left, QuantityValue right)
         {
             return new AreaDensity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="AreaDensity"/> from dividing <see cref="AreaDensity"/> by value.</summary>
-        public static AreaDensity operator /(AreaDensity left, double right)
+        public static AreaDensity operator /(AreaDensity left, QuantityValue right)
         {
             return new AreaDensity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="AreaDensity"/> by <see cref="AreaDensity"/>.</summary>
-        public static double operator /(AreaDensity left, AreaDensity right)
+        public static QuantityValue operator /(AreaDensity left, AreaDensity right)
         {
             return left.KilogramsPerSquareMeter / right.KilogramsPerSquareMeter;
         }
@@ -517,12 +528,36 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="Density"/> from <see cref="AreaDensity"/> / <see cref="Length"/>.</summary>
+        public static Density operator /(AreaDensity areaDensity, Length length)
+        {
+            return Density.FromKilogramsPerCubicMeter(areaDensity.KilogramsPerSquareMeter / length.Meters);
+        }
+
+        /// <summary>Get <see cref="Length"/> from <see cref="AreaDensity"/> / <see cref="Density"/>.</summary>
+        public static Length operator /(AreaDensity areaDensity, Density density)
+        {
+            return Length.FromMeters(areaDensity.KilogramsPerSquareMeter / density.KilogramsPerCubicMeter);
+        }
+
+        /// <summary>Get <see cref="LinearDensity"/> from <see cref="AreaDensity"/> * <see cref="Length"/>.</summary>
+        public static LinearDensity operator *(AreaDensity areaDensity, Length length)
+        {
+            return LinearDensity.FromKilogramsPerMeter(areaDensity.KilogramsPerSquareMeter * length.Meters);
+        }
+
         /// <summary>Get <see cref="Mass"/> from <see cref="AreaDensity"/> * <see cref="Area"/>.</summary>
         public static Mass operator *(AreaDensity areaDensity, Area area)
         {
             return Mass.FromKilograms(areaDensity.KilogramsPerSquareMeter * area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="Pressure"/> from <see cref="AreaDensity"/> * <see cref="Acceleration"/>.</summary>
+        public static Pressure operator *(AreaDensity areaDensity, Acceleration acceleration)
+        {
+            return Pressure.FromPascals(areaDensity.KilogramsPerSquareMeter * acceleration.MetersPerSecondSquared);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -530,97 +565,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(AreaDensity left, AreaDensity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(AreaDensity left, AreaDensity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(AreaDensity left, AreaDensity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(AreaDensity left, AreaDensity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="AreaDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(AreaDensity other, AreaDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="AreaDensity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(AreaDensity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(AreaDensity left, AreaDensity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="AreaDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(AreaDensity other, AreaDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="AreaDensity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(AreaDensity,AreaDensity)"/>.
+        ///     See that operator (and <see cref="Equals(AreaDensity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(AreaDensity left, AreaDensity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="AreaDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(AreaDensity other, AreaDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="AreaDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="AreaDensity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="AreaDensity"/>, this method delegates to
+        ///     <see cref="Equals(AreaDensity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is AreaDensity otherQuantity))
+            if (obj is not AreaDensity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="AreaDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(AreaDensity other, AreaDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="AreaDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(AreaDensity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current AreaDensity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(AreaDensity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="AreaDensity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(AreaDensity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is AreaDensity otherQuantity)) throw new ArgumentException("Expected type AreaDensity.", nameof(obj));
+            if (obj is not AreaDensity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<AreaDensity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="AreaDensity"/> with another <see cref="AreaDensity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="AreaDensity"/> with another <see cref="AreaDensity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -632,135 +681,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(AreaDensity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(AreaDensityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<AreaDensityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this AreaDensity to another AreaDensity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A AreaDensity with the specified unit.</returns>
-        public AreaDensity ToUnit(AreaDensityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="AreaDensity"/> to another <see cref="AreaDensity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A AreaDensity with the specified unit.</returns>
-        public AreaDensity ToUnit(AreaDensityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(AreaDensity), Unit, typeof(AreaDensity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (AreaDensity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="AreaDensity"/> to another <see cref="AreaDensity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="AreaDensity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(AreaDensityUnit unit, [NotNullWhen(true)] out AreaDensity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            AreaDensity? convertedOrNull = (Unit, unit) switch
-            {
-                // AreaDensityUnit -> BaseUnit
-                (AreaDensityUnit.GramPerSquareMeter, AreaDensityUnit.KilogramPerSquareMeter) => new AreaDensity(_value / 1000, AreaDensityUnit.KilogramPerSquareMeter),
-                (AreaDensityUnit.MilligramPerSquareMeter, AreaDensityUnit.KilogramPerSquareMeter) => new AreaDensity(_value / 1000000, AreaDensityUnit.KilogramPerSquareMeter),
-
-                // BaseUnit -> AreaDensityUnit
-                (AreaDensityUnit.KilogramPerSquareMeter, AreaDensityUnit.GramPerSquareMeter) => new AreaDensity(_value * 1000, AreaDensityUnit.GramPerSquareMeter),
-                (AreaDensityUnit.KilogramPerSquareMeter, AreaDensityUnit.MilligramPerSquareMeter) => new AreaDensity(_value * 1000000, AreaDensityUnit.MilligramPerSquareMeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not AreaDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaDensityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is AreaDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<AreaDensityUnit> IQuantity<AreaDensityUnit>.ToUnit(AreaDensityUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -772,11 +697,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
index 77fd67fa9f..9d040c557d 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     A geometric property of an area that reflects how its points are distributed with regard to an axis.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct AreaMomentOfInertia :
-        IArithmeticQuantity<AreaMomentOfInertia, AreaMomentOfInertiaUnit>,
+        ILinearQuantity<AreaMomentOfInertia, AreaMomentOfInertiaUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<AreaMomentOfInertia, AreaMomentOfInertia, double>,
+        IDivisionOperators<AreaMomentOfInertia, AreaMomentOfInertia, QuantityValue>,
+        IDivisionOperators<AreaMomentOfInertia, Area, Area>,
         IDivisionOperators<AreaMomentOfInertia, Volume, Length>,
         IDivisionOperators<AreaMomentOfInertia, Length, Volume>,
         IComparisonOperators<AreaMomentOfInertia, AreaMomentOfInertia, bool>,
@@ -54,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -104,7 +104,7 @@ public static AreaMomentOfInertiaInfo CreateDefault(Func<IEnumerable<UnitDefinit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="AreaMomentOfInertia"/> is [L^4].
+            ///     The <see cref="BaseDimensions" /> for <see cref="AreaMomentOfInertia"/> is L^4.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(4, 0, 0, 0, 0, 0, 0);
 
@@ -119,20 +119,28 @@ public static AreaMomentOfInertiaInfo CreateDefault(Func<IEnumerable<UnitDefinit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{AreaMomentOfInertiaUnit}"/> representing the default unit mappings for AreaMomentOfInertia.</returns>
             public static IEnumerable<UnitDefinition<AreaMomentOfInertiaUnit>> GetDefaultMappings()
             {
-                yield return new (AreaMomentOfInertiaUnit.CentimeterToTheFourth, "CentimeterToTheFourth", "CentimetersToTheFourth", new BaseUnits(length: LengthUnit.Centimeter));
-                yield return new (AreaMomentOfInertiaUnit.DecimeterToTheFourth, "DecimeterToTheFourth", "DecimetersToTheFourth", new BaseUnits(length: LengthUnit.Decimeter));
-                yield return new (AreaMomentOfInertiaUnit.FootToTheFourth, "FootToTheFourth", "FeetToTheFourth", new BaseUnits(length: LengthUnit.Foot));
-                yield return new (AreaMomentOfInertiaUnit.InchToTheFourth, "InchToTheFourth", "InchesToTheFourth", new BaseUnits(length: LengthUnit.Inch));
+                yield return new (AreaMomentOfInertiaUnit.CentimeterToTheFourth, "CentimeterToTheFourth", "CentimetersToTheFourth", new BaseUnits(length: LengthUnit.Centimeter),
+                     100000000
+                );
+                yield return new (AreaMomentOfInertiaUnit.DecimeterToTheFourth, "DecimeterToTheFourth", "DecimetersToTheFourth", new BaseUnits(length: LengthUnit.Decimeter),
+                     10000
+                );
+                yield return new (AreaMomentOfInertiaUnit.FootToTheFourth, "FootToTheFourth", "FeetToTheFourth", new BaseUnits(length: LengthUnit.Foot),
+                     new QuantityValue(2441406250000, 21071715921)
+                );
+                yield return new (AreaMomentOfInertiaUnit.InchToTheFourth, "InchToTheFourth", "InchesToTheFourth", new BaseUnits(length: LengthUnit.Inch),
+                     new QuantityValue(625000000000000, 260144641)
+                );
                 yield return new (AreaMomentOfInertiaUnit.MeterToTheFourth, "MeterToTheFourth", "MetersToTheFourth", new BaseUnits(length: LengthUnit.Meter));
-                yield return new (AreaMomentOfInertiaUnit.MillimeterToTheFourth, "MillimeterToTheFourth", "MillimetersToTheFourth", new BaseUnits(length: LengthUnit.Millimeter));
+                yield return new (AreaMomentOfInertiaUnit.MillimeterToTheFourth, "MillimeterToTheFourth", "MillimetersToTheFourth", new BaseUnits(length: LengthUnit.Millimeter),
+                     1000000000000
+                );
             }
         }
 
         static AreaMomentOfInertia()
         {
-            Info = AreaMomentOfInertiaInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(AreaMomentOfInertiaInfo.CreateDefault);
         }
 
         /// <summary>
@@ -140,7 +148,7 @@ static AreaMomentOfInertia()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public AreaMomentOfInertia(double value, AreaMomentOfInertiaUnit unit)
+        public AreaMomentOfInertia(QuantityValue value, AreaMomentOfInertiaUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -154,7 +162,7 @@ public AreaMomentOfInertia(double value, AreaMomentOfInertiaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public AreaMomentOfInertia(double value, UnitSystem unitSystem)
+        public AreaMomentOfInertia(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -165,7 +173,8 @@ public AreaMomentOfInertia(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="AreaMomentOfInertia" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<AreaMomentOfInertia, AreaMomentOfInertiaUnit> Info { get; }
@@ -194,10 +203,8 @@ public AreaMomentOfInertia(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public AreaMomentOfInertiaUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -231,63 +238,39 @@ public AreaMomentOfInertia(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.CentimeterToTheFourth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.CentimeterToTheFourth"/>
         /// </summary>
-        public double CentimetersToTheFourth => As(AreaMomentOfInertiaUnit.CentimeterToTheFourth);
+        public QuantityValue CentimetersToTheFourth => this.As(AreaMomentOfInertiaUnit.CentimeterToTheFourth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.DecimeterToTheFourth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.DecimeterToTheFourth"/>
         /// </summary>
-        public double DecimetersToTheFourth => As(AreaMomentOfInertiaUnit.DecimeterToTheFourth);
+        public QuantityValue DecimetersToTheFourth => this.As(AreaMomentOfInertiaUnit.DecimeterToTheFourth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.FootToTheFourth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.FootToTheFourth"/>
         /// </summary>
-        public double FeetToTheFourth => As(AreaMomentOfInertiaUnit.FootToTheFourth);
+        public QuantityValue FeetToTheFourth => this.As(AreaMomentOfInertiaUnit.FootToTheFourth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.InchToTheFourth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.InchToTheFourth"/>
         /// </summary>
-        public double InchesToTheFourth => As(AreaMomentOfInertiaUnit.InchToTheFourth);
+        public QuantityValue InchesToTheFourth => this.As(AreaMomentOfInertiaUnit.InchToTheFourth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.MeterToTheFourth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.MeterToTheFourth"/>
         /// </summary>
-        public double MetersToTheFourth => As(AreaMomentOfInertiaUnit.MeterToTheFourth);
+        public QuantityValue MetersToTheFourth => this.As(AreaMomentOfInertiaUnit.MeterToTheFourth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.MillimeterToTheFourth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaMomentOfInertiaUnit.MillimeterToTheFourth"/>
         /// </summary>
-        public double MillimetersToTheFourth => As(AreaMomentOfInertiaUnit.MillimeterToTheFourth);
+        public QuantityValue MillimetersToTheFourth => this.As(AreaMomentOfInertiaUnit.MillimeterToTheFourth);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: AreaMomentOfInertiaUnit -> BaseUnit
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.CentimeterToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth, quantity => quantity.ToUnit(AreaMomentOfInertiaUnit.MeterToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.DecimeterToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth, quantity => quantity.ToUnit(AreaMomentOfInertiaUnit.MeterToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.FootToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth, quantity => quantity.ToUnit(AreaMomentOfInertiaUnit.MeterToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.InchToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth, quantity => quantity.ToUnit(AreaMomentOfInertiaUnit.MeterToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.MillimeterToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth, quantity => quantity.ToUnit(AreaMomentOfInertiaUnit.MeterToTheFourth));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> AreaMomentOfInertiaUnit
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.CentimeterToTheFourth, quantity => quantity.ToUnit(AreaMomentOfInertiaUnit.CentimeterToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.DecimeterToTheFourth, quantity => quantity.ToUnit(AreaMomentOfInertiaUnit.DecimeterToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.FootToTheFourth, quantity => quantity.ToUnit(AreaMomentOfInertiaUnit.FootToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.InchToTheFourth, quantity => quantity.ToUnit(AreaMomentOfInertiaUnit.InchToTheFourth));
-            unitConverter.SetConversionFunction<AreaMomentOfInertia>(AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.MillimeterToTheFourth, quantity => quantity.ToUnit(AreaMomentOfInertiaUnit.MillimeterToTheFourth));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -316,7 +299,7 @@ public static string GetAbbreviation(AreaMomentOfInertiaUnit unit, IFormatProvid
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.CentimeterToTheFourth"/>.
         /// </summary>
-        public static AreaMomentOfInertia FromCentimetersToTheFourth(double value)
+        public static AreaMomentOfInertia FromCentimetersToTheFourth(QuantityValue value)
         {
             return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.CentimeterToTheFourth);
         }
@@ -324,7 +307,7 @@ public static AreaMomentOfInertia FromCentimetersToTheFourth(double value)
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.DecimeterToTheFourth"/>.
         /// </summary>
-        public static AreaMomentOfInertia FromDecimetersToTheFourth(double value)
+        public static AreaMomentOfInertia FromDecimetersToTheFourth(QuantityValue value)
         {
             return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.DecimeterToTheFourth);
         }
@@ -332,7 +315,7 @@ public static AreaMomentOfInertia FromDecimetersToTheFourth(double value)
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.FootToTheFourth"/>.
         /// </summary>
-        public static AreaMomentOfInertia FromFeetToTheFourth(double value)
+        public static AreaMomentOfInertia FromFeetToTheFourth(QuantityValue value)
         {
             return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.FootToTheFourth);
         }
@@ -340,7 +323,7 @@ public static AreaMomentOfInertia FromFeetToTheFourth(double value)
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.InchToTheFourth"/>.
         /// </summary>
-        public static AreaMomentOfInertia FromInchesToTheFourth(double value)
+        public static AreaMomentOfInertia FromInchesToTheFourth(QuantityValue value)
         {
             return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.InchToTheFourth);
         }
@@ -348,7 +331,7 @@ public static AreaMomentOfInertia FromInchesToTheFourth(double value)
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.MeterToTheFourth"/>.
         /// </summary>
-        public static AreaMomentOfInertia FromMetersToTheFourth(double value)
+        public static AreaMomentOfInertia FromMetersToTheFourth(QuantityValue value)
         {
             return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MeterToTheFourth);
         }
@@ -356,7 +339,7 @@ public static AreaMomentOfInertia FromMetersToTheFourth(double value)
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.MillimeterToTheFourth"/>.
         /// </summary>
-        public static AreaMomentOfInertia FromMillimetersToTheFourth(double value)
+        public static AreaMomentOfInertia FromMillimetersToTheFourth(QuantityValue value)
         {
             return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MillimeterToTheFourth);
         }
@@ -367,7 +350,7 @@ public static AreaMomentOfInertia FromMillimetersToTheFourth(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>AreaMomentOfInertia unit value.</returns>
-        public static AreaMomentOfInertia From(double value, AreaMomentOfInertiaUnit fromUnit)
+        public static AreaMomentOfInertia From(QuantityValue value, AreaMomentOfInertiaUnit fromUnit)
         {
             return new AreaMomentOfInertia(value, fromUnit);
         }
@@ -428,10 +411,7 @@ public static AreaMomentOfInertia Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static AreaMomentOfInertia Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<AreaMomentOfInertia, AreaMomentOfInertiaUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<AreaMomentOfInertia, AreaMomentOfInertiaUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -459,11 +439,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out AreaMomentOfIner
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out AreaMomentOfInertia result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<AreaMomentOfInertia, AreaMomentOfInertiaUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<AreaMomentOfInertia, AreaMomentOfInertiaUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -484,7 +460,7 @@ public static AreaMomentOfInertiaUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -495,7 +471,7 @@ public static AreaMomentOfInertiaUnit ParseUnit(string str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.AreaMomentOfInertiaUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.AreaMomentOfInertiaUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out AreaMomentOfInertiaUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -510,7 +486,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out AreaMomentOf
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out AreaMomentOfInertiaUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -529,35 +505,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="AreaMomentOfInertia"/> from adding two <see cref="AreaMomentOfInertia"/>.</summary>
         public static AreaMomentOfInertia operator +(AreaMomentOfInertia left, AreaMomentOfInertia right)
         {
-            return new AreaMomentOfInertia(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new AreaMomentOfInertia(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="AreaMomentOfInertia"/> from subtracting two <see cref="AreaMomentOfInertia"/>.</summary>
         public static AreaMomentOfInertia operator -(AreaMomentOfInertia left, AreaMomentOfInertia right)
         {
-            return new AreaMomentOfInertia(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new AreaMomentOfInertia(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="AreaMomentOfInertia"/> from multiplying value and <see cref="AreaMomentOfInertia"/>.</summary>
-        public static AreaMomentOfInertia operator *(double left, AreaMomentOfInertia right)
+        public static AreaMomentOfInertia operator *(QuantityValue left, AreaMomentOfInertia right)
         {
             return new AreaMomentOfInertia(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="AreaMomentOfInertia"/> from multiplying value and <see cref="AreaMomentOfInertia"/>.</summary>
-        public static AreaMomentOfInertia operator *(AreaMomentOfInertia left, double right)
+        public static AreaMomentOfInertia operator *(AreaMomentOfInertia left, QuantityValue right)
         {
             return new AreaMomentOfInertia(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="AreaMomentOfInertia"/> from dividing <see cref="AreaMomentOfInertia"/> by value.</summary>
-        public static AreaMomentOfInertia operator /(AreaMomentOfInertia left, double right)
+        public static AreaMomentOfInertia operator /(AreaMomentOfInertia left, QuantityValue right)
         {
             return new AreaMomentOfInertia(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="AreaMomentOfInertia"/> by <see cref="AreaMomentOfInertia"/>.</summary>
-        public static double operator /(AreaMomentOfInertia left, AreaMomentOfInertia right)
+        public static QuantityValue operator /(AreaMomentOfInertia left, AreaMomentOfInertia right)
         {
             return left.MetersToTheFourth / right.MetersToTheFourth;
         }
@@ -566,6 +542,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="Area"/> from <see cref="AreaMomentOfInertia"/> / <see cref="Area"/>.</summary>
+        public static Area operator /(AreaMomentOfInertia areaMomentOfInertia, Area area)
+        {
+            return Area.FromSquareMeters(areaMomentOfInertia.MetersToTheFourth / area.SquareMeters);
+        }
+
         /// <summary>Get <see cref="Length"/> from <see cref="AreaMomentOfInertia"/> / <see cref="Volume"/>.</summary>
         public static Length operator /(AreaMomentOfInertia areaMomentOfInertia, Volume volume)
         {
@@ -585,97 +567,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(AreaMomentOfInertia left, AreaMomentOfInertia right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(AreaMomentOfInertia left, AreaMomentOfInertia right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(AreaMomentOfInertia left, AreaMomentOfInertia right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(AreaMomentOfInertia left, AreaMomentOfInertia right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="AreaMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(AreaMomentOfInertia other, AreaMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="AreaMomentOfInertia"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(AreaMomentOfInertia)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(AreaMomentOfInertia left, AreaMomentOfInertia right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="AreaMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(AreaMomentOfInertia other, AreaMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="AreaMomentOfInertia"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(AreaMomentOfInertia,AreaMomentOfInertia)"/>.
+        ///     See that operator (and <see cref="Equals(AreaMomentOfInertia)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(AreaMomentOfInertia left, AreaMomentOfInertia right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="AreaMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(AreaMomentOfInertia other, AreaMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="AreaMomentOfInertia"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="AreaMomentOfInertia"/>.
+        ///     When <paramref name="obj"/> is a <see cref="AreaMomentOfInertia"/>, this method delegates to
+        ///     <see cref="Equals(AreaMomentOfInertia)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is AreaMomentOfInertia otherQuantity))
+            if (obj is not AreaMomentOfInertia otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="AreaMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(AreaMomentOfInertia other, AreaMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="AreaMomentOfInertia"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(AreaMomentOfInertia other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current AreaMomentOfInertia.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(AreaMomentOfInertia), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="AreaMomentOfInertia"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(AreaMomentOfInertia)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is AreaMomentOfInertia otherQuantity)) throw new ArgumentException("Expected type AreaMomentOfInertia.", nameof(obj));
+            if (obj is not AreaMomentOfInertia otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<AreaMomentOfInertia>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="AreaMomentOfInertia"/> with another <see cref="AreaMomentOfInertia"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="AreaMomentOfInertia"/> with another <see cref="AreaMomentOfInertia"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -687,141 +683,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(AreaMomentOfInertia other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(AreaMomentOfInertiaUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<AreaMomentOfInertiaUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this AreaMomentOfInertia to another AreaMomentOfInertia with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A AreaMomentOfInertia with the specified unit.</returns>
-        public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="AreaMomentOfInertia"/> to another <see cref="AreaMomentOfInertia"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A AreaMomentOfInertia with the specified unit.</returns>
-        public AreaMomentOfInertia ToUnit(AreaMomentOfInertiaUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(AreaMomentOfInertia), Unit, typeof(AreaMomentOfInertia), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (AreaMomentOfInertia)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="AreaMomentOfInertia"/> to another <see cref="AreaMomentOfInertia"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="AreaMomentOfInertia"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(AreaMomentOfInertiaUnit unit, [NotNullWhen(true)] out AreaMomentOfInertia? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            AreaMomentOfInertia? convertedOrNull = (Unit, unit) switch
-            {
-                // AreaMomentOfInertiaUnit -> BaseUnit
-                (AreaMomentOfInertiaUnit.CentimeterToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth) => new AreaMomentOfInertia(_value / 1e8, AreaMomentOfInertiaUnit.MeterToTheFourth),
-                (AreaMomentOfInertiaUnit.DecimeterToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth) => new AreaMomentOfInertia(_value / 1e4, AreaMomentOfInertiaUnit.MeterToTheFourth),
-                (AreaMomentOfInertiaUnit.FootToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth) => new AreaMomentOfInertia(_value * 0.0086309748412416, AreaMomentOfInertiaUnit.MeterToTheFourth),
-                (AreaMomentOfInertiaUnit.InchToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth) => new AreaMomentOfInertia(_value * 0.0000004162314256, AreaMomentOfInertiaUnit.MeterToTheFourth),
-                (AreaMomentOfInertiaUnit.MillimeterToTheFourth, AreaMomentOfInertiaUnit.MeterToTheFourth) => new AreaMomentOfInertia(_value / 1e12, AreaMomentOfInertiaUnit.MeterToTheFourth),
-
-                // BaseUnit -> AreaMomentOfInertiaUnit
-                (AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.CentimeterToTheFourth) => new AreaMomentOfInertia(_value * 1e8, AreaMomentOfInertiaUnit.CentimeterToTheFourth),
-                (AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.DecimeterToTheFourth) => new AreaMomentOfInertia(_value * 1e4, AreaMomentOfInertiaUnit.DecimeterToTheFourth),
-                (AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.FootToTheFourth) => new AreaMomentOfInertia(_value / 0.0086309748412416, AreaMomentOfInertiaUnit.FootToTheFourth),
-                (AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.InchToTheFourth) => new AreaMomentOfInertia(_value / 0.0000004162314256, AreaMomentOfInertiaUnit.InchToTheFourth),
-                (AreaMomentOfInertiaUnit.MeterToTheFourth, AreaMomentOfInertiaUnit.MillimeterToTheFourth) => new AreaMomentOfInertia(_value * 1e12, AreaMomentOfInertiaUnit.MillimeterToTheFourth),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not AreaMomentOfInertiaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is AreaMomentOfInertiaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<AreaMomentOfInertiaUnit> IQuantity<AreaMomentOfInertiaUnit>.ToUnit(AreaMomentOfInertiaUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -833,11 +699,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaPerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaPerLength.g.cs
new file mode 100644
index 0000000000..cab8674135
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Quantities/AreaPerLength.g.cs
@@ -0,0 +1,702 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System.Globalization;
+using System.Resources;
+using System.Runtime.Serialization;
+using UnitsNet.Debug;
+
+#nullable enable
+
+// ReSharper disable once CheckNamespace
+
+namespace UnitsNet
+{
+    /// <inheritdoc />
+    /// <summary>
+    ///     The magnitude of area per unit length, typically used in structural engineering to specify distributed reinforcement.
+    /// </summary>
+    [DataContract]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
+    public readonly partial struct AreaPerLength :
+        ILinearQuantity<AreaPerLength, AreaPerLengthUnit>,
+#if NET7_0_OR_GREATER
+        IDivisionOperators<AreaPerLength, AreaPerLength, QuantityValue>,
+        IMultiplyOperators<AreaPerLength, Length, Area>,
+        IComparisonOperators<AreaPerLength, AreaPerLength, bool>,
+        IParsable<AreaPerLength>,
+#endif
+        IComparable,
+        IComparable<AreaPerLength>,
+        IEquatable<AreaPerLength>,
+        IFormattable
+    {
+        /// <summary>
+        ///     The numeric value this quantity was constructed with.
+        /// </summary>
+        [DataMember(Name = "Value", Order = 1)]
+        private readonly QuantityValue _value;
+
+        /// <summary>
+        ///     The unit this quantity was constructed with.
+        /// </summary>
+        [DataMember(Name = "Unit", Order = 2)]
+        private readonly AreaPerLengthUnit? _unit;
+
+        /// <summary>
+        ///     Provides detailed information about the <see cref="AreaPerLength"/> quantity, including its name, base unit, unit mappings, base dimensions, and conversion functions.
+        /// </summary>
+        public sealed class AreaPerLengthInfo: QuantityInfo<AreaPerLength, AreaPerLengthUnit>
+        {
+            /// <inheritdoc />
+            public AreaPerLengthInfo(string name, AreaPerLengthUnit baseUnit, IEnumerable<IUnitDefinition<AreaPerLengthUnit>> unitMappings, AreaPerLength zero, BaseDimensions baseDimensions,
+                QuantityFromDelegate<AreaPerLength, AreaPerLengthUnit> fromDelegate, ResourceManager? unitAbbreviations)
+                : base(name, baseUnit, unitMappings, zero, baseDimensions, fromDelegate, unitAbbreviations)
+            {
+            }
+
+            /// <inheritdoc />
+            public AreaPerLengthInfo(string name, AreaPerLengthUnit baseUnit, IEnumerable<IUnitDefinition<AreaPerLengthUnit>> unitMappings, AreaPerLength zero, BaseDimensions baseDimensions)
+                : this(name, baseUnit, unitMappings, zero, baseDimensions, AreaPerLength.From, new ResourceManager("UnitsNet.GeneratedCode.Resources.AreaPerLength", typeof(AreaPerLength).Assembly))
+            {
+            }
+
+            /// <summary>
+            ///     Creates a new instance of the <see cref="AreaPerLengthInfo"/> class with the default settings for the AreaPerLength quantity.
+            /// </summary>
+            /// <returns>A new instance of the <see cref="AreaPerLengthInfo"/> class with the default settings.</returns>
+            public static AreaPerLengthInfo CreateDefault()
+            {
+                return new AreaPerLengthInfo(nameof(AreaPerLength), DefaultBaseUnit, GetDefaultMappings(), new AreaPerLength(0, DefaultBaseUnit), DefaultBaseDimensions);
+            }
+
+            /// <summary>
+            ///     Creates a new instance of the <see cref="AreaPerLengthInfo"/> class with the default settings for the AreaPerLength quantity and a callback for customizing the default unit mappings.
+            /// </summary>
+            /// <param name="customizeUnits">
+            ///     A callback function for customizing the default unit mappings.
+            /// </param>
+            /// <returns>
+            ///     A new instance of the <see cref="AreaPerLengthInfo"/> class with the default settings.
+            /// </returns>
+            public static AreaPerLengthInfo CreateDefault(Func<IEnumerable<UnitDefinition<AreaPerLengthUnit>>, IEnumerable<IUnitDefinition<AreaPerLengthUnit>>> customizeUnits)
+            {
+                return new AreaPerLengthInfo(nameof(AreaPerLength), DefaultBaseUnit, customizeUnits(GetDefaultMappings()), new AreaPerLength(0, DefaultBaseUnit), DefaultBaseDimensions);
+            }
+
+            /// <summary>
+            ///     The <see cref="BaseDimensions" /> for <see cref="AreaPerLength"/> is L.
+            /// </summary>
+            public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 0, 0, 0, 0, 0, 0);
+
+            /// <summary>
+            ///     The default base unit of AreaPerLength is SquareMeterPerMeter. All conversions, as defined in the <see cref="GetDefaultMappings"/>, go via this value.
+            /// </summary>
+            public static AreaPerLengthUnit DefaultBaseUnit { get; } = AreaPerLengthUnit.SquareMeterPerMeter;
+
+            /// <summary>
+            ///     Retrieves the default mappings for <see cref="AreaPerLengthUnit"/>.
+            /// </summary>
+            /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{AreaPerLengthUnit}"/> representing the default unit mappings for AreaPerLength.</returns>
+            public static IEnumerable<UnitDefinition<AreaPerLengthUnit>> GetDefaultMappings()
+            {
+                yield return new (AreaPerLengthUnit.SquareCentimeterPerMeter, "SquareCentimeterPerMeter", "SquareCentimetersPerMeter", BaseUnits.Undefined,
+                     10000
+                );
+                yield return new (AreaPerLengthUnit.SquareFootPerFoot, "SquareFootPerFoot", "SquareFeetPerFoot", BaseUnits.Undefined,
+                     new QuantityValue(1250, 381)
+                );
+                yield return new (AreaPerLengthUnit.SquareInchPerFoot, "SquareInchPerFoot", "SquareInchesPerFoot", BaseUnits.Undefined,
+                     new QuantityValue(60000, 127)
+                );
+                yield return new (AreaPerLengthUnit.SquareInchPerInch, "SquareInchPerInch", "SquareInchesPerInch", BaseUnits.Undefined,
+                     new QuantityValue(5000, 127)
+                );
+                yield return new (AreaPerLengthUnit.SquareMeterPerMeter, "SquareMeterPerMeter", "SquareMetersPerMeter", new BaseUnits(length: LengthUnit.Meter));
+                yield return new (AreaPerLengthUnit.SquareMillimeterPerMeter, "SquareMillimeterPerMeter", "SquareMillimetersPerMeter", BaseUnits.Undefined,
+                     1000000
+                );
+            }
+        }
+
+        static AreaPerLength()
+        {
+            Info = UnitsNetSetup.CreateQuantityInfo(AreaPerLengthInfo.CreateDefault);
+        }
+
+        /// <summary>
+        ///     Creates the quantity with the given numeric value and unit.
+        /// </summary>
+        /// <param name="value">The numeric value to construct this quantity with.</param>
+        /// <param name="unit">The unit representation to construct this quantity with.</param>
+        public AreaPerLength(QuantityValue value, AreaPerLengthUnit unit)
+        {
+            _value = value;
+            _unit = unit;
+        }
+
+        /// <summary>
+        /// Creates an instance of the quantity with the given numeric value in units compatible with the given <see cref="UnitSystem"/>.
+        /// If multiple compatible units were found, the first match is used.
+        /// </summary>
+        /// <param name="value">The numeric value to construct this quantity with.</param>
+        /// <param name="unitSystem">The unit system to create the quantity with.</param>
+        /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
+        /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
+        public AreaPerLength(QuantityValue value, UnitSystem unitSystem)
+        {
+            _value = value;
+            _unit = Info.GetDefaultUnit(unitSystem);
+        }
+
+        #region Static Properties
+
+        /// <summary>
+        ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="AreaPerLength" /> instances.
+        /// </summary>
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
+
+        /// <inheritdoc cref="IQuantity.QuantityInfo"/>
+        public static QuantityInfo<AreaPerLength, AreaPerLengthUnit> Info { get; }
+
+        /// <summary>
+        ///     The <see cref="BaseDimensions" /> of this quantity.
+        /// </summary>
+        public static BaseDimensions BaseDimensions => Info.BaseDimensions;
+
+        /// <summary>
+        ///     The base unit of AreaPerLength, which is SquareMeterPerMeter. All conversions go via this value.
+        /// </summary>
+        public static AreaPerLengthUnit BaseUnit => Info.BaseUnitInfo.Value;
+
+        /// <summary>
+        ///     All units of measurement for the AreaPerLength quantity.
+        /// </summary>
+        public static IReadOnlyCollection<AreaPerLengthUnit> Units => Info.Units;
+
+        /// <summary>
+        ///     Gets an instance of this quantity with a value of 0 in the base unit SquareMeterPerMeter.
+        /// </summary>
+        public static AreaPerLength Zero => Info.Zero;
+
+        #endregion
+
+        #region Properties
+
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
+
+        /// <inheritdoc />
+        public AreaPerLengthUnit Unit => _unit.GetValueOrDefault(BaseUnit);
+
+        /// <inheritdoc />
+        public QuantityInfo<AreaPerLength, AreaPerLengthUnit> QuantityInfo => Info;
+
+        #region Explicit implementations
+
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        UnitKey IQuantity.UnitKey => UnitKey.ForUnit(Unit);
+
+#if NETSTANDARD2_0
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        IQuantityInstanceInfo<AreaPerLength> IQuantityOfType<AreaPerLength>.QuantityInfo => Info;
+
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        QuantityInfo<AreaPerLengthUnit> IQuantity<AreaPerLengthUnit>.QuantityInfo => Info;
+
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        QuantityInfo IQuantity.QuantityInfo => Info;
+
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        Enum IQuantity.Unit => Unit;
+#endif
+
+        #endregion
+
+        #endregion
+
+        #region Conversion Properties
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaPerLengthUnit.SquareCentimeterPerMeter"/>
+        /// </summary>
+        public QuantityValue SquareCentimetersPerMeter => this.As(AreaPerLengthUnit.SquareCentimeterPerMeter);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaPerLengthUnit.SquareFootPerFoot"/>
+        /// </summary>
+        public QuantityValue SquareFeetPerFoot => this.As(AreaPerLengthUnit.SquareFootPerFoot);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaPerLengthUnit.SquareInchPerFoot"/>
+        /// </summary>
+        public QuantityValue SquareInchesPerFoot => this.As(AreaPerLengthUnit.SquareInchPerFoot);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaPerLengthUnit.SquareInchPerInch"/>
+        /// </summary>
+        public QuantityValue SquareInchesPerInch => this.As(AreaPerLengthUnit.SquareInchPerInch);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaPerLengthUnit.SquareMeterPerMeter"/>
+        /// </summary>
+        public QuantityValue SquareMetersPerMeter => this.As(AreaPerLengthUnit.SquareMeterPerMeter);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="AreaPerLengthUnit.SquareMillimeterPerMeter"/>
+        /// </summary>
+        public QuantityValue SquareMillimetersPerMeter => this.As(AreaPerLengthUnit.SquareMillimeterPerMeter);
+
+        #endregion
+
+        #region Static Methods
+
+        /// <summary>
+        ///     Get unit abbreviation string.
+        /// </summary>
+        /// <param name="unit">Unit to get abbreviation for.</param>
+        /// <returns>Unit abbreviation string.</returns>
+        public static string GetAbbreviation(AreaPerLengthUnit unit)
+        {
+            return GetAbbreviation(unit, null);
+        }
+
+        /// <summary>
+        ///     Get unit abbreviation string.
+        /// </summary>
+        /// <param name="unit">Unit to get abbreviation for.</param>
+        /// <returns>Unit abbreviation string.</returns>
+        /// <param name="provider">Format to use for localization. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        public static string GetAbbreviation(AreaPerLengthUnit unit, IFormatProvider? provider)
+        {
+            return UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit, provider);
+        }
+
+        #endregion
+
+        #region Static Factory Methods
+
+        /// <summary>
+        ///     Creates a <see cref="AreaPerLength"/> from <see cref="AreaPerLengthUnit.SquareCentimeterPerMeter"/>.
+        /// </summary>
+        public static AreaPerLength FromSquareCentimetersPerMeter(QuantityValue value)
+        {
+            return new AreaPerLength(value, AreaPerLengthUnit.SquareCentimeterPerMeter);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="AreaPerLength"/> from <see cref="AreaPerLengthUnit.SquareFootPerFoot"/>.
+        /// </summary>
+        public static AreaPerLength FromSquareFeetPerFoot(QuantityValue value)
+        {
+            return new AreaPerLength(value, AreaPerLengthUnit.SquareFootPerFoot);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="AreaPerLength"/> from <see cref="AreaPerLengthUnit.SquareInchPerFoot"/>.
+        /// </summary>
+        public static AreaPerLength FromSquareInchesPerFoot(QuantityValue value)
+        {
+            return new AreaPerLength(value, AreaPerLengthUnit.SquareInchPerFoot);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="AreaPerLength"/> from <see cref="AreaPerLengthUnit.SquareInchPerInch"/>.
+        /// </summary>
+        public static AreaPerLength FromSquareInchesPerInch(QuantityValue value)
+        {
+            return new AreaPerLength(value, AreaPerLengthUnit.SquareInchPerInch);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="AreaPerLength"/> from <see cref="AreaPerLengthUnit.SquareMeterPerMeter"/>.
+        /// </summary>
+        public static AreaPerLength FromSquareMetersPerMeter(QuantityValue value)
+        {
+            return new AreaPerLength(value, AreaPerLengthUnit.SquareMeterPerMeter);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="AreaPerLength"/> from <see cref="AreaPerLengthUnit.SquareMillimeterPerMeter"/>.
+        /// </summary>
+        public static AreaPerLength FromSquareMillimetersPerMeter(QuantityValue value)
+        {
+            return new AreaPerLength(value, AreaPerLengthUnit.SquareMillimeterPerMeter);
+        }
+
+        /// <summary>
+        ///     Dynamically convert from value and unit enum <see cref="AreaPerLengthUnit" /> to <see cref="AreaPerLength" />.
+        /// </summary>
+        /// <param name="value">Value to convert from.</param>
+        /// <param name="fromUnit">Unit to convert from.</param>
+        /// <returns>AreaPerLength unit value.</returns>
+        public static AreaPerLength From(QuantityValue value, AreaPerLengthUnit fromUnit)
+        {
+            return new AreaPerLength(value, fromUnit);
+        }
+
+        #endregion
+
+        #region Static Parse Methods
+
+        /// <summary>
+        ///     Parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
+        /// </summary>
+        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
+        /// <example>
+        ///     Length.Parse("5.5 m", CultureInfo.GetCultureInfo("en-US"));
+        /// </example>
+        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
+        /// <exception cref="ArgumentException">
+        ///     Expected string to have one or two pairs of quantity and unit in the format
+        ///     "&lt;quantity&gt; &lt;unit&gt;". Eg. "5.5 m" or "1ft 2in"
+        /// </exception>
+        /// <exception cref="AmbiguousUnitParseException">
+        ///     More than one unit is represented by the specified unit abbreviation.
+        ///     Example: Volume.Parse("1 cup") will throw, because it can refer to any of
+        ///     <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
+        /// </exception>
+        /// <exception cref="UnitsNetException">
+        ///     If anything else goes wrong, typically due to a bug or unhandled case.
+        ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
+        ///     Units.NET exceptions from other exceptions.
+        /// </exception>
+        public static AreaPerLength Parse(string str)
+        {
+            return Parse(str, null);
+        }
+
+        /// <summary>
+        ///     Parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
+        /// </summary>
+        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
+        /// <example>
+        ///     Length.Parse("5.5 m", CultureInfo.GetCultureInfo("en-US"));
+        /// </example>
+        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
+        /// <exception cref="ArgumentException">
+        ///     Expected string to have one or two pairs of quantity and unit in the format
+        ///     "&lt;quantity&gt; &lt;unit&gt;". Eg. "5.5 m" or "1ft 2in"
+        /// </exception>
+        /// <exception cref="AmbiguousUnitParseException">
+        ///     More than one unit is represented by the specified unit abbreviation.
+        ///     Example: Volume.Parse("1 cup") will throw, because it can refer to any of
+        ///     <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
+        /// </exception>
+        /// <exception cref="UnitsNetException">
+        ///     If anything else goes wrong, typically due to a bug or unhandled case.
+        ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
+        ///     Units.NET exceptions from other exceptions.
+        /// </exception>
+        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        public static AreaPerLength Parse(string str, IFormatProvider? provider)
+        {
+            return QuantityParser.Default.Parse<AreaPerLength, AreaPerLengthUnit>(str, provider, From);
+        }
+
+        /// <summary>
+        ///     Try to parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
+        /// </summary>
+        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
+        /// <param name="result">Resulting unit quantity if successful.</param>
+        /// <example>
+        ///     Length.Parse("5.5 m", CultureInfo.GetCultureInfo("en-US"));
+        /// </example>
+        public static bool TryParse([NotNullWhen(true)]string? str, out AreaPerLength result)
+        {
+            return TryParse(str, null, out result);
+        }
+
+        /// <summary>
+        ///     Try to parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
+        /// </summary>
+        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
+        /// <param name="result">Resulting unit quantity if successful.</param>
+        /// <returns>True if successful, otherwise false.</returns>
+        /// <example>
+        ///     Length.Parse("5.5 m", CultureInfo.GetCultureInfo("en-US"));
+        /// </example>
+        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out AreaPerLength result)
+        {
+            return QuantityParser.Default.TryParse<AreaPerLength, AreaPerLengthUnit>(str, provider, From, out result);
+        }
+
+        /// <summary>
+        ///     Parse a unit string.
+        /// </summary>
+        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
+        /// <example>
+        ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
+        /// </example>
+        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
+        /// <exception cref="UnitsNetException">Error parsing string.</exception>
+        public static AreaPerLengthUnit ParseUnit(string str)
+        {
+            return ParseUnit(str, null);
+        }
+
+        /// <summary>
+        ///     Parse a unit string.
+        /// </summary>
+        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <example>
+        ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
+        /// </example>
+        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
+        /// <exception cref="UnitsNetException">Error parsing string.</exception>
+        public static AreaPerLengthUnit ParseUnit(string str, IFormatProvider? provider)
+        {
+            return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
+        }
+
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.AreaPerLengthUnit)"/>
+        public static bool TryParseUnit([NotNullWhen(true)]string? str, out AreaPerLengthUnit unit)
+        {
+            return TryParseUnit(str, null, out unit);
+        }
+
+        /// <summary>
+        ///     Parse a unit string.
+        /// </summary>
+        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
+        /// <param name="unit">The parsed unit if successful.</param>
+        /// <returns>True if successful, otherwise false.</returns>
+        /// <example>
+        ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
+        /// </example>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out AreaPerLengthUnit unit)
+        {
+            return UnitParser.Default.TryParse(str, Info, provider, out unit);
+        }
+
+        #endregion
+
+        #region Arithmetic Operators
+
+        /// <summary>Negate the value.</summary>
+        public static AreaPerLength operator -(AreaPerLength right)
+        {
+            return new AreaPerLength(-right.Value, right.Unit);
+        }
+
+        /// <summary>Get <see cref="AreaPerLength"/> from adding two <see cref="AreaPerLength"/>.</summary>
+        public static AreaPerLength operator +(AreaPerLength left, AreaPerLength right)
+        {
+            return new AreaPerLength(left.Value + right.As(left.Unit), left.Unit);
+        }
+
+        /// <summary>Get <see cref="AreaPerLength"/> from subtracting two <see cref="AreaPerLength"/>.</summary>
+        public static AreaPerLength operator -(AreaPerLength left, AreaPerLength right)
+        {
+            return new AreaPerLength(left.Value - right.As(left.Unit), left.Unit);
+        }
+
+        /// <summary>Get <see cref="AreaPerLength"/> from multiplying value and <see cref="AreaPerLength"/>.</summary>
+        public static AreaPerLength operator *(QuantityValue left, AreaPerLength right)
+        {
+            return new AreaPerLength(left * right.Value, right.Unit);
+        }
+
+        /// <summary>Get <see cref="AreaPerLength"/> from multiplying value and <see cref="AreaPerLength"/>.</summary>
+        public static AreaPerLength operator *(AreaPerLength left, QuantityValue right)
+        {
+            return new AreaPerLength(left.Value * right, left.Unit);
+        }
+
+        /// <summary>Get <see cref="AreaPerLength"/> from dividing <see cref="AreaPerLength"/> by value.</summary>
+        public static AreaPerLength operator /(AreaPerLength left, QuantityValue right)
+        {
+            return new AreaPerLength(left.Value / right, left.Unit);
+        }
+
+        /// <summary>Get ratio value from dividing <see cref="AreaPerLength"/> by <see cref="AreaPerLength"/>.</summary>
+        public static QuantityValue operator /(AreaPerLength left, AreaPerLength right)
+        {
+            return left.SquareMetersPerMeter / right.SquareMetersPerMeter;
+        }
+
+        #endregion
+
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Area"/> from <see cref="AreaPerLength"/> * <see cref="Length"/>.</summary>
+        public static Area operator *(AreaPerLength areaPerLength, Length length)
+        {
+            return Area.FromSquareMeters(areaPerLength.SquareMetersPerMeter * length.Meters);
+        }
+
+        #endregion
+
+        #region Equality / IComparable
+
+        /// <summary>Returns true if less or equal to.</summary>
+        public static bool operator <=(AreaPerLength left, AreaPerLength right)
+        {
+            return left.Value <= right.As(left.Unit);
+        }
+
+        /// <summary>Returns true if greater than or equal to.</summary>
+        public static bool operator >=(AreaPerLength left, AreaPerLength right)
+        {
+            return left.Value >= right.As(left.Unit);
+        }
+
+        /// <summary>Returns true if less than.</summary>
+        public static bool operator <(AreaPerLength left, AreaPerLength right)
+        {
+            return left.Value < right.As(left.Unit);
+        }
+
+        /// <summary>Returns true if greater than.</summary>
+        public static bool operator >(AreaPerLength left, AreaPerLength right)
+        {
+            return left.Value > right.As(left.Unit);
+        }
+
+        /// <summary>
+        ///     Determines whether two <see cref="AreaPerLength"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(AreaPerLength)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
+        public static bool operator ==(AreaPerLength left, AreaPerLength right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        ///     Determines whether two <see cref="AreaPerLength"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(AreaPerLength,AreaPerLength)"/>.
+        ///     See that operator (and <see cref="Equals(AreaPerLength)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
+        public static bool operator !=(AreaPerLength left, AreaPerLength right)
+        {
+            return !(left == right);
+        }
+
+        /// <inheritdoc />
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="AreaPerLength"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="AreaPerLength"/>.
+        ///     When <paramref name="obj"/> is a <see cref="AreaPerLength"/>, this method delegates to
+        ///     <see cref="Equals(AreaPerLength)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
+        public override bool Equals(object? obj)
+        {
+            if (obj is not AreaPerLength otherQuantity)
+                return false;
+
+            return Equals(otherQuantity);
+        }
+
+        /// <inheritdoc />
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="AreaPerLength"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
+        public bool Equals(AreaPerLength other)
+        {
+            return _value.Equals(other.As(this.Unit));
+        }
+
+        /// <summary>
+        ///     Returns the hash code for this instance.
+        /// </summary>
+        /// <returns>A hash code for the current AreaPerLength.</returns>
+        public override int GetHashCode()
+        {
+            return Comparison.GetHashCode(typeof(AreaPerLength), this.As(BaseUnit));
+        }
+
+        /// <inheritdoc  cref="CompareTo(AreaPerLength)" />
+        /// <param name="obj">An object to compare with this instance.</param>
+        /// <exception cref="T:System.ArgumentException">
+        ///    <paramref name="obj" /> is not the same type as this instance.
+        /// </exception>
+        public int CompareTo(object? obj)
+        {
+            if (obj is not AreaPerLength otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<AreaPerLength>(obj, nameof(obj));
+
+            return CompareTo(otherQuantity);
+        }
+
+        /// <summary>
+        ///     Compares the current <see cref="AreaPerLength"/> with another <see cref="AreaPerLength"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
+        /// <param name="other">A quantity to compare with this instance.</param>
+        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
+        ///     <list type="table">
+        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
+        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="other" /> in the sort order.</description></item>
+        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="other" />.</description></item>
+        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="other" /> in the sort order.</description></item>
+        ///     </list>
+        /// </returns>
+        public int CompareTo(AreaPerLength other)
+        {
+            return _value.CompareTo(other.As(this.Unit));
+        }
+
+        #endregion
+
+        #region ToString Methods
+
+        /// <summary>
+        ///     Gets the default string representation of value and unit.
+        /// </summary>
+        /// <returns>String representation.</returns>
+        public override string ToString()
+        {
+            return ToString(null, null);
+        }
+
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
+        /// <summary>
+        /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
+        /// </summary>
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
+        {
+            return QuantityFormatter.Default.Format(this, format, provider);
+        }
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
index ef08cdfb3d..c94befb97b 100644
--- a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,15 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Bit_rate
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct BitRate :
-        IArithmeticQuantity<BitRate, BitRateUnit>,
+        ILinearQuantity<BitRate, BitRateUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<BitRate, BitRate, double>,
+        IDivisionOperators<BitRate, BitRate, QuantityValue>,
+        IDivisionOperators<BitRate, Information, Frequency>,
+        IMultiplyOperators<BitRate, Duration, Information>,
+        IDivisionOperators<BitRate, Frequency, Information>,
         IComparisonOperators<BitRate, BitRate, bool>,
         IParsable<BitRate>,
 #endif
@@ -55,7 +57,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +107,7 @@ public static BitRateInfo CreateDefault(Func<IEnumerable<UnitDefinition<BitRateU
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="BitRate"/> is [T^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="BitRate"/> is T^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, -1, 0, 0, 0, 0);
 
@@ -121,52 +123,126 @@ public static BitRateInfo CreateDefault(Func<IEnumerable<UnitDefinition<BitRateU
             public static IEnumerable<UnitDefinition<BitRateUnit>> GetDefaultMappings()
             {
                 yield return new (BitRateUnit.BitPerSecond, "BitPerSecond", "BitsPerSecond", new BaseUnits(time: DurationUnit.Second));
-                yield return new (BitRateUnit.BytePerSecond, "BytePerSecond", "BytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.ExabitPerSecond, "ExabitPerSecond", "ExabitsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.ExabytePerSecond, "ExabytePerSecond", "ExabytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.ExaoctetPerSecond, "ExaoctetPerSecond", "ExaoctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.ExbibitPerSecond, "ExbibitPerSecond", "ExbibitsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.ExbibytePerSecond, "ExbibytePerSecond", "ExbibytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.ExbioctetPerSecond, "ExbioctetPerSecond", "ExbioctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.GibibitPerSecond, "GibibitPerSecond", "GibibitsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.GibibytePerSecond, "GibibytePerSecond", "GibibytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.GibioctetPerSecond, "GibioctetPerSecond", "GibioctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.GigabitPerSecond, "GigabitPerSecond", "GigabitsPerSecond", new BaseUnits(time: DurationUnit.Nanosecond));
-                yield return new (BitRateUnit.GigabytePerSecond, "GigabytePerSecond", "GigabytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.GigaoctetPerSecond, "GigaoctetPerSecond", "GigaoctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.KibibitPerSecond, "KibibitPerSecond", "KibibitsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.KibibytePerSecond, "KibibytePerSecond", "KibibytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.KibioctetPerSecond, "KibioctetPerSecond", "KibioctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.KilobitPerSecond, "KilobitPerSecond", "KilobitsPerSecond", new BaseUnits(time: DurationUnit.Millisecond));
-                yield return new (BitRateUnit.KilobytePerSecond, "KilobytePerSecond", "KilobytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.KilooctetPerSecond, "KilooctetPerSecond", "KilooctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.MebibitPerSecond, "MebibitPerSecond", "MebibitsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.MebibytePerSecond, "MebibytePerSecond", "MebibytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.MebioctetPerSecond, "MebioctetPerSecond", "MebioctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.MegabitPerSecond, "MegabitPerSecond", "MegabitsPerSecond", new BaseUnits(time: DurationUnit.Microsecond));
-                yield return new (BitRateUnit.MegabytePerSecond, "MegabytePerSecond", "MegabytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.MegaoctetPerSecond, "MegaoctetPerSecond", "MegaoctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.OctetPerSecond, "OctetPerSecond", "OctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.PebibitPerSecond, "PebibitPerSecond", "PebibitsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.PebibytePerSecond, "PebibytePerSecond", "PebibytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.PebioctetPerSecond, "PebioctetPerSecond", "PebioctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.PetabitPerSecond, "PetabitPerSecond", "PetabitsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.PetabytePerSecond, "PetabytePerSecond", "PetabytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.PetaoctetPerSecond, "PetaoctetPerSecond", "PetaoctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.TebibitPerSecond, "TebibitPerSecond", "TebibitsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.TebibytePerSecond, "TebibytePerSecond", "TebibytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.TebioctetPerSecond, "TebioctetPerSecond", "TebioctetsPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.TerabitPerSecond, "TerabitPerSecond", "TerabitsPerSecond", new BaseUnits(time: DurationUnit.Picosecond));
-                yield return new (BitRateUnit.TerabytePerSecond, "TerabytePerSecond", "TerabytesPerSecond", BaseUnits.Undefined);
-                yield return new (BitRateUnit.TeraoctetPerSecond, "TeraoctetPerSecond", "TeraoctetsPerSecond", BaseUnits.Undefined);
+                yield return new (BitRateUnit.BytePerSecond, "BytePerSecond", "BytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8)
+                );
+                yield return new (BitRateUnit.ExabitPerSecond, "ExabitPerSecond", "ExabitsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000000)
+                );
+                yield return new (BitRateUnit.ExabytePerSecond, "ExabytePerSecond", "ExabytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000000000)
+                );
+                yield return new (BitRateUnit.ExaoctetPerSecond, "ExaoctetPerSecond", "ExaoctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000000000)
+                );
+                yield return new (BitRateUnit.ExbibitPerSecond, "ExbibitPerSecond", "ExbibitsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 1152921504606846976)
+                );
+                yield return new (BitRateUnit.ExbibytePerSecond, "ExbibytePerSecond", "ExbibytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, BigInteger.Pow(2, 63))
+                );
+                yield return new (BitRateUnit.ExbioctetPerSecond, "ExbioctetPerSecond", "ExbioctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, BigInteger.Pow(2, 63))
+                );
+                yield return new (BitRateUnit.GibibitPerSecond, "GibibitPerSecond", "GibibitsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 1073741824)
+                );
+                yield return new (BitRateUnit.GibibytePerSecond, "GibibytePerSecond", "GibibytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8589934592)
+                );
+                yield return new (BitRateUnit.GibioctetPerSecond, "GibioctetPerSecond", "GibioctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8589934592)
+                );
+                yield return new (BitRateUnit.GigabitPerSecond, "GigabitPerSecond", "GigabitsPerSecond", new BaseUnits(time: DurationUnit.Nanosecond),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (BitRateUnit.GigabytePerSecond, "GigabytePerSecond", "GigabytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000)
+                );
+                yield return new (BitRateUnit.GigaoctetPerSecond, "GigaoctetPerSecond", "GigaoctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000)
+                );
+                yield return new (BitRateUnit.KibibitPerSecond, "KibibitPerSecond", "KibibitsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 1024)
+                );
+                yield return new (BitRateUnit.KibibytePerSecond, "KibibytePerSecond", "KibibytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8192)
+                );
+                yield return new (BitRateUnit.KibioctetPerSecond, "KibioctetPerSecond", "KibioctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8192)
+                );
+                yield return new (BitRateUnit.KilobitPerSecond, "KilobitPerSecond", "KilobitsPerSecond", new BaseUnits(time: DurationUnit.Millisecond),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (BitRateUnit.KilobytePerSecond, "KilobytePerSecond", "KilobytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000)
+                );
+                yield return new (BitRateUnit.KilooctetPerSecond, "KilooctetPerSecond", "KilooctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000)
+                );
+                yield return new (BitRateUnit.MebibitPerSecond, "MebibitPerSecond", "MebibitsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 1048576)
+                );
+                yield return new (BitRateUnit.MebibytePerSecond, "MebibytePerSecond", "MebibytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8388608)
+                );
+                yield return new (BitRateUnit.MebioctetPerSecond, "MebioctetPerSecond", "MebioctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8388608)
+                );
+                yield return new (BitRateUnit.MegabitPerSecond, "MegabitPerSecond", "MegabitsPerSecond", new BaseUnits(time: DurationUnit.Microsecond),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (BitRateUnit.MegabytePerSecond, "MegabytePerSecond", "MegabytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000)
+                );
+                yield return new (BitRateUnit.MegaoctetPerSecond, "MegaoctetPerSecond", "MegaoctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000)
+                );
+                yield return new (BitRateUnit.OctetPerSecond, "OctetPerSecond", "OctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8)
+                );
+                yield return new (BitRateUnit.PebibitPerSecond, "PebibitPerSecond", "PebibitsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 1125899906842624)
+                );
+                yield return new (BitRateUnit.PebibytePerSecond, "PebibytePerSecond", "PebibytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 9007199254740992)
+                );
+                yield return new (BitRateUnit.PebioctetPerSecond, "PebioctetPerSecond", "PebioctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 9007199254740992)
+                );
+                yield return new (BitRateUnit.PetabitPerSecond, "PetabitPerSecond", "PetabitsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000)
+                );
+                yield return new (BitRateUnit.PetabytePerSecond, "PetabytePerSecond", "PetabytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000000)
+                );
+                yield return new (BitRateUnit.PetaoctetPerSecond, "PetaoctetPerSecond", "PetaoctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000000)
+                );
+                yield return new (BitRateUnit.TebibitPerSecond, "TebibitPerSecond", "TebibitsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 1099511627776)
+                );
+                yield return new (BitRateUnit.TebibytePerSecond, "TebibytePerSecond", "TebibytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8796093022208)
+                );
+                yield return new (BitRateUnit.TebioctetPerSecond, "TebioctetPerSecond", "TebioctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8796093022208)
+                );
+                yield return new (BitRateUnit.TerabitPerSecond, "TerabitPerSecond", "TerabitsPerSecond", new BaseUnits(time: DurationUnit.Picosecond),
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (BitRateUnit.TerabytePerSecond, "TerabytePerSecond", "TerabytesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000)
+                );
+                yield return new (BitRateUnit.TeraoctetPerSecond, "TeraoctetPerSecond", "TeraoctetsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000)
+                );
             }
         }
 
         static BitRate()
         {
-            Info = BitRateInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(BitRateInfo.CreateDefault);
         }
 
         /// <summary>
@@ -174,7 +250,7 @@ static BitRate()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public BitRate(double value, BitRateUnit unit)
+        public BitRate(QuantityValue value, BitRateUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -188,7 +264,7 @@ public BitRate(double value, BitRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public BitRate(double value, UnitSystem unitSystem)
+        public BitRate(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -199,7 +275,8 @@ public BitRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="BitRate" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<BitRate, BitRateUnit> Info { get; }
@@ -228,10 +305,8 @@ public BitRate(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public BitRateUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -265,294 +340,204 @@ public BitRate(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.BitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.BitPerSecond"/>
         /// </summary>
-        public double BitsPerSecond => As(BitRateUnit.BitPerSecond);
+        public QuantityValue BitsPerSecond => this.As(BitRateUnit.BitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.BytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.BytePerSecond"/>
         /// </summary>
-        public double BytesPerSecond => As(BitRateUnit.BytePerSecond);
+        public QuantityValue BytesPerSecond => this.As(BitRateUnit.BytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExabitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.ExabitPerSecond"/>
         /// </summary>
-        public double ExabitsPerSecond => As(BitRateUnit.ExabitPerSecond);
+        public QuantityValue ExabitsPerSecond => this.As(BitRateUnit.ExabitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExabytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.ExabytePerSecond"/>
         /// </summary>
-        public double ExabytesPerSecond => As(BitRateUnit.ExabytePerSecond);
+        public QuantityValue ExabytesPerSecond => this.As(BitRateUnit.ExabytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExaoctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.ExaoctetPerSecond"/>
         /// </summary>
-        public double ExaoctetsPerSecond => As(BitRateUnit.ExaoctetPerSecond);
+        public QuantityValue ExaoctetsPerSecond => this.As(BitRateUnit.ExaoctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExbibitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.ExbibitPerSecond"/>
         /// </summary>
-        public double ExbibitsPerSecond => As(BitRateUnit.ExbibitPerSecond);
+        public QuantityValue ExbibitsPerSecond => this.As(BitRateUnit.ExbibitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExbibytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.ExbibytePerSecond"/>
         /// </summary>
-        public double ExbibytesPerSecond => As(BitRateUnit.ExbibytePerSecond);
+        public QuantityValue ExbibytesPerSecond => this.As(BitRateUnit.ExbibytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.ExbioctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.ExbioctetPerSecond"/>
         /// </summary>
-        public double ExbioctetsPerSecond => As(BitRateUnit.ExbioctetPerSecond);
+        public QuantityValue ExbioctetsPerSecond => this.As(BitRateUnit.ExbioctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GibibitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.GibibitPerSecond"/>
         /// </summary>
-        public double GibibitsPerSecond => As(BitRateUnit.GibibitPerSecond);
+        public QuantityValue GibibitsPerSecond => this.As(BitRateUnit.GibibitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GibibytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.GibibytePerSecond"/>
         /// </summary>
-        public double GibibytesPerSecond => As(BitRateUnit.GibibytePerSecond);
+        public QuantityValue GibibytesPerSecond => this.As(BitRateUnit.GibibytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GibioctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.GibioctetPerSecond"/>
         /// </summary>
-        public double GibioctetsPerSecond => As(BitRateUnit.GibioctetPerSecond);
+        public QuantityValue GibioctetsPerSecond => this.As(BitRateUnit.GibioctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GigabitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.GigabitPerSecond"/>
         /// </summary>
-        public double GigabitsPerSecond => As(BitRateUnit.GigabitPerSecond);
+        public QuantityValue GigabitsPerSecond => this.As(BitRateUnit.GigabitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GigabytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.GigabytePerSecond"/>
         /// </summary>
-        public double GigabytesPerSecond => As(BitRateUnit.GigabytePerSecond);
+        public QuantityValue GigabytesPerSecond => this.As(BitRateUnit.GigabytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.GigaoctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.GigaoctetPerSecond"/>
         /// </summary>
-        public double GigaoctetsPerSecond => As(BitRateUnit.GigaoctetPerSecond);
+        public QuantityValue GigaoctetsPerSecond => this.As(BitRateUnit.GigaoctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KibibitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.KibibitPerSecond"/>
         /// </summary>
-        public double KibibitsPerSecond => As(BitRateUnit.KibibitPerSecond);
+        public QuantityValue KibibitsPerSecond => this.As(BitRateUnit.KibibitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KibibytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.KibibytePerSecond"/>
         /// </summary>
-        public double KibibytesPerSecond => As(BitRateUnit.KibibytePerSecond);
+        public QuantityValue KibibytesPerSecond => this.As(BitRateUnit.KibibytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KibioctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.KibioctetPerSecond"/>
         /// </summary>
-        public double KibioctetsPerSecond => As(BitRateUnit.KibioctetPerSecond);
+        public QuantityValue KibioctetsPerSecond => this.As(BitRateUnit.KibioctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KilobitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.KilobitPerSecond"/>
         /// </summary>
-        public double KilobitsPerSecond => As(BitRateUnit.KilobitPerSecond);
+        public QuantityValue KilobitsPerSecond => this.As(BitRateUnit.KilobitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KilobytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.KilobytePerSecond"/>
         /// </summary>
-        public double KilobytesPerSecond => As(BitRateUnit.KilobytePerSecond);
+        public QuantityValue KilobytesPerSecond => this.As(BitRateUnit.KilobytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.KilooctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.KilooctetPerSecond"/>
         /// </summary>
-        public double KilooctetsPerSecond => As(BitRateUnit.KilooctetPerSecond);
+        public QuantityValue KilooctetsPerSecond => this.As(BitRateUnit.KilooctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MebibitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.MebibitPerSecond"/>
         /// </summary>
-        public double MebibitsPerSecond => As(BitRateUnit.MebibitPerSecond);
+        public QuantityValue MebibitsPerSecond => this.As(BitRateUnit.MebibitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MebibytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.MebibytePerSecond"/>
         /// </summary>
-        public double MebibytesPerSecond => As(BitRateUnit.MebibytePerSecond);
+        public QuantityValue MebibytesPerSecond => this.As(BitRateUnit.MebibytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MebioctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.MebioctetPerSecond"/>
         /// </summary>
-        public double MebioctetsPerSecond => As(BitRateUnit.MebioctetPerSecond);
+        public QuantityValue MebioctetsPerSecond => this.As(BitRateUnit.MebioctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MegabitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.MegabitPerSecond"/>
         /// </summary>
-        public double MegabitsPerSecond => As(BitRateUnit.MegabitPerSecond);
+        public QuantityValue MegabitsPerSecond => this.As(BitRateUnit.MegabitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MegabytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.MegabytePerSecond"/>
         /// </summary>
-        public double MegabytesPerSecond => As(BitRateUnit.MegabytePerSecond);
+        public QuantityValue MegabytesPerSecond => this.As(BitRateUnit.MegabytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.MegaoctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.MegaoctetPerSecond"/>
         /// </summary>
-        public double MegaoctetsPerSecond => As(BitRateUnit.MegaoctetPerSecond);
+        public QuantityValue MegaoctetsPerSecond => this.As(BitRateUnit.MegaoctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.OctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.OctetPerSecond"/>
         /// </summary>
-        public double OctetsPerSecond => As(BitRateUnit.OctetPerSecond);
+        public QuantityValue OctetsPerSecond => this.As(BitRateUnit.OctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PebibitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.PebibitPerSecond"/>
         /// </summary>
-        public double PebibitsPerSecond => As(BitRateUnit.PebibitPerSecond);
+        public QuantityValue PebibitsPerSecond => this.As(BitRateUnit.PebibitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PebibytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.PebibytePerSecond"/>
         /// </summary>
-        public double PebibytesPerSecond => As(BitRateUnit.PebibytePerSecond);
+        public QuantityValue PebibytesPerSecond => this.As(BitRateUnit.PebibytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PebioctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.PebioctetPerSecond"/>
         /// </summary>
-        public double PebioctetsPerSecond => As(BitRateUnit.PebioctetPerSecond);
+        public QuantityValue PebioctetsPerSecond => this.As(BitRateUnit.PebioctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PetabitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.PetabitPerSecond"/>
         /// </summary>
-        public double PetabitsPerSecond => As(BitRateUnit.PetabitPerSecond);
+        public QuantityValue PetabitsPerSecond => this.As(BitRateUnit.PetabitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PetabytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.PetabytePerSecond"/>
         /// </summary>
-        public double PetabytesPerSecond => As(BitRateUnit.PetabytePerSecond);
+        public QuantityValue PetabytesPerSecond => this.As(BitRateUnit.PetabytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.PetaoctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.PetaoctetPerSecond"/>
         /// </summary>
-        public double PetaoctetsPerSecond => As(BitRateUnit.PetaoctetPerSecond);
+        public QuantityValue PetaoctetsPerSecond => this.As(BitRateUnit.PetaoctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TebibitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.TebibitPerSecond"/>
         /// </summary>
-        public double TebibitsPerSecond => As(BitRateUnit.TebibitPerSecond);
+        public QuantityValue TebibitsPerSecond => this.As(BitRateUnit.TebibitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TebibytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.TebibytePerSecond"/>
         /// </summary>
-        public double TebibytesPerSecond => As(BitRateUnit.TebibytePerSecond);
+        public QuantityValue TebibytesPerSecond => this.As(BitRateUnit.TebibytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TebioctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.TebioctetPerSecond"/>
         /// </summary>
-        public double TebioctetsPerSecond => As(BitRateUnit.TebioctetPerSecond);
+        public QuantityValue TebioctetsPerSecond => this.As(BitRateUnit.TebioctetPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TerabitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.TerabitPerSecond"/>
         /// </summary>
-        public double TerabitsPerSecond => As(BitRateUnit.TerabitPerSecond);
+        public QuantityValue TerabitsPerSecond => this.As(BitRateUnit.TerabitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TerabytePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.TerabytePerSecond"/>
         /// </summary>
-        public double TerabytesPerSecond => As(BitRateUnit.TerabytePerSecond);
+        public QuantityValue TerabytesPerSecond => this.As(BitRateUnit.TerabytePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BitRateUnit.TeraoctetPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BitRateUnit.TeraoctetPerSecond"/>
         /// </summary>
-        public double TeraoctetsPerSecond => As(BitRateUnit.TeraoctetPerSecond);
+        public QuantityValue TeraoctetsPerSecond => this.As(BitRateUnit.TeraoctetPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: BitRateUnit -> BaseUnit
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.ExabitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.ExabytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.ExaoctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.ExbibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.ExbibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.ExbioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.GibibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.GibibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.GibioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.GigabitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.GigabytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.GigaoctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.KibibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.KibibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.KibioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.KilobitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.KilobytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.KilooctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.MebibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.MebibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.MebioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.MegabitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.MegabytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.MegaoctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.OctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.PebibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.PebibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.PebioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.PetabitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.PetabytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.PetaoctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.TebibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.TebibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.TebioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.TerabitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.TerabytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.TeraoctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> BitRateUnit
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.BytePerSecond, quantity => quantity.ToUnit(BitRateUnit.BytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.ExabitPerSecond, quantity => quantity.ToUnit(BitRateUnit.ExabitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.ExabytePerSecond, quantity => quantity.ToUnit(BitRateUnit.ExabytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.ExaoctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.ExaoctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.ExbibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.ExbibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.ExbibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.ExbibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.ExbioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.ExbioctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.GibibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.GibibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.GibibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.GibibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.GibioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.GibioctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.GigabitPerSecond, quantity => quantity.ToUnit(BitRateUnit.GigabitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.GigabytePerSecond, quantity => quantity.ToUnit(BitRateUnit.GigabytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.GigaoctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.GigaoctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.KibibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.KibibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.KibibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.KibibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.KibioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.KibioctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.KilobitPerSecond, quantity => quantity.ToUnit(BitRateUnit.KilobitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.KilobytePerSecond, quantity => quantity.ToUnit(BitRateUnit.KilobytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.KilooctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.KilooctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.MebibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.MebibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.MebibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.MebibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.MebioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.MebioctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.MegabitPerSecond, quantity => quantity.ToUnit(BitRateUnit.MegabitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.MegabytePerSecond, quantity => quantity.ToUnit(BitRateUnit.MegabytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.MegaoctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.MegaoctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.OctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.OctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.PebibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.PebibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.PebibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.PebibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.PebioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.PebioctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.PetabitPerSecond, quantity => quantity.ToUnit(BitRateUnit.PetabitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.PetabytePerSecond, quantity => quantity.ToUnit(BitRateUnit.PetabytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.PetaoctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.PetaoctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.TebibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.TebibitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.TebibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.TebibytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.TebioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.TebioctetPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.TerabitPerSecond, quantity => quantity.ToUnit(BitRateUnit.TerabitPerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.TerabytePerSecond, quantity => quantity.ToUnit(BitRateUnit.TerabytePerSecond));
-            unitConverter.SetConversionFunction<BitRate>(BitRateUnit.BitPerSecond, BitRateUnit.TeraoctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.TeraoctetPerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -581,7 +566,7 @@ public static string GetAbbreviation(BitRateUnit unit, IFormatProvider? provider
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.BitPerSecond"/>.
         /// </summary>
-        public static BitRate FromBitsPerSecond(double value)
+        public static BitRate FromBitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.BitPerSecond);
         }
@@ -589,7 +574,7 @@ public static BitRate FromBitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.BytePerSecond"/>.
         /// </summary>
-        public static BitRate FromBytesPerSecond(double value)
+        public static BitRate FromBytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.BytePerSecond);
         }
@@ -597,7 +582,7 @@ public static BitRate FromBytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExabitPerSecond"/>.
         /// </summary>
-        public static BitRate FromExabitsPerSecond(double value)
+        public static BitRate FromExabitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.ExabitPerSecond);
         }
@@ -605,7 +590,7 @@ public static BitRate FromExabitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExabytePerSecond"/>.
         /// </summary>
-        public static BitRate FromExabytesPerSecond(double value)
+        public static BitRate FromExabytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.ExabytePerSecond);
         }
@@ -613,7 +598,7 @@ public static BitRate FromExabytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExaoctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromExaoctetsPerSecond(double value)
+        public static BitRate FromExaoctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.ExaoctetPerSecond);
         }
@@ -621,7 +606,7 @@ public static BitRate FromExaoctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExbibitPerSecond"/>.
         /// </summary>
-        public static BitRate FromExbibitsPerSecond(double value)
+        public static BitRate FromExbibitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.ExbibitPerSecond);
         }
@@ -629,7 +614,7 @@ public static BitRate FromExbibitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExbibytePerSecond"/>.
         /// </summary>
-        public static BitRate FromExbibytesPerSecond(double value)
+        public static BitRate FromExbibytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.ExbibytePerSecond);
         }
@@ -637,7 +622,7 @@ public static BitRate FromExbibytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExbioctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromExbioctetsPerSecond(double value)
+        public static BitRate FromExbioctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.ExbioctetPerSecond);
         }
@@ -645,7 +630,7 @@ public static BitRate FromExbioctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GibibitPerSecond"/>.
         /// </summary>
-        public static BitRate FromGibibitsPerSecond(double value)
+        public static BitRate FromGibibitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.GibibitPerSecond);
         }
@@ -653,7 +638,7 @@ public static BitRate FromGibibitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GibibytePerSecond"/>.
         /// </summary>
-        public static BitRate FromGibibytesPerSecond(double value)
+        public static BitRate FromGibibytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.GibibytePerSecond);
         }
@@ -661,7 +646,7 @@ public static BitRate FromGibibytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GibioctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromGibioctetsPerSecond(double value)
+        public static BitRate FromGibioctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.GibioctetPerSecond);
         }
@@ -669,7 +654,7 @@ public static BitRate FromGibioctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GigabitPerSecond"/>.
         /// </summary>
-        public static BitRate FromGigabitsPerSecond(double value)
+        public static BitRate FromGigabitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.GigabitPerSecond);
         }
@@ -677,7 +662,7 @@ public static BitRate FromGigabitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GigabytePerSecond"/>.
         /// </summary>
-        public static BitRate FromGigabytesPerSecond(double value)
+        public static BitRate FromGigabytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.GigabytePerSecond);
         }
@@ -685,7 +670,7 @@ public static BitRate FromGigabytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GigaoctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromGigaoctetsPerSecond(double value)
+        public static BitRate FromGigaoctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.GigaoctetPerSecond);
         }
@@ -693,7 +678,7 @@ public static BitRate FromGigaoctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KibibitPerSecond"/>.
         /// </summary>
-        public static BitRate FromKibibitsPerSecond(double value)
+        public static BitRate FromKibibitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.KibibitPerSecond);
         }
@@ -701,7 +686,7 @@ public static BitRate FromKibibitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KibibytePerSecond"/>.
         /// </summary>
-        public static BitRate FromKibibytesPerSecond(double value)
+        public static BitRate FromKibibytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.KibibytePerSecond);
         }
@@ -709,7 +694,7 @@ public static BitRate FromKibibytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KibioctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromKibioctetsPerSecond(double value)
+        public static BitRate FromKibioctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.KibioctetPerSecond);
         }
@@ -717,7 +702,7 @@ public static BitRate FromKibioctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KilobitPerSecond"/>.
         /// </summary>
-        public static BitRate FromKilobitsPerSecond(double value)
+        public static BitRate FromKilobitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.KilobitPerSecond);
         }
@@ -725,7 +710,7 @@ public static BitRate FromKilobitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KilobytePerSecond"/>.
         /// </summary>
-        public static BitRate FromKilobytesPerSecond(double value)
+        public static BitRate FromKilobytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.KilobytePerSecond);
         }
@@ -733,7 +718,7 @@ public static BitRate FromKilobytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KilooctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromKilooctetsPerSecond(double value)
+        public static BitRate FromKilooctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.KilooctetPerSecond);
         }
@@ -741,7 +726,7 @@ public static BitRate FromKilooctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MebibitPerSecond"/>.
         /// </summary>
-        public static BitRate FromMebibitsPerSecond(double value)
+        public static BitRate FromMebibitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.MebibitPerSecond);
         }
@@ -749,7 +734,7 @@ public static BitRate FromMebibitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MebibytePerSecond"/>.
         /// </summary>
-        public static BitRate FromMebibytesPerSecond(double value)
+        public static BitRate FromMebibytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.MebibytePerSecond);
         }
@@ -757,7 +742,7 @@ public static BitRate FromMebibytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MebioctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromMebioctetsPerSecond(double value)
+        public static BitRate FromMebioctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.MebioctetPerSecond);
         }
@@ -765,7 +750,7 @@ public static BitRate FromMebioctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MegabitPerSecond"/>.
         /// </summary>
-        public static BitRate FromMegabitsPerSecond(double value)
+        public static BitRate FromMegabitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.MegabitPerSecond);
         }
@@ -773,7 +758,7 @@ public static BitRate FromMegabitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MegabytePerSecond"/>.
         /// </summary>
-        public static BitRate FromMegabytesPerSecond(double value)
+        public static BitRate FromMegabytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.MegabytePerSecond);
         }
@@ -781,7 +766,7 @@ public static BitRate FromMegabytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MegaoctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromMegaoctetsPerSecond(double value)
+        public static BitRate FromMegaoctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.MegaoctetPerSecond);
         }
@@ -789,7 +774,7 @@ public static BitRate FromMegaoctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.OctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromOctetsPerSecond(double value)
+        public static BitRate FromOctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.OctetPerSecond);
         }
@@ -797,7 +782,7 @@ public static BitRate FromOctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PebibitPerSecond"/>.
         /// </summary>
-        public static BitRate FromPebibitsPerSecond(double value)
+        public static BitRate FromPebibitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.PebibitPerSecond);
         }
@@ -805,7 +790,7 @@ public static BitRate FromPebibitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PebibytePerSecond"/>.
         /// </summary>
-        public static BitRate FromPebibytesPerSecond(double value)
+        public static BitRate FromPebibytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.PebibytePerSecond);
         }
@@ -813,7 +798,7 @@ public static BitRate FromPebibytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PebioctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromPebioctetsPerSecond(double value)
+        public static BitRate FromPebioctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.PebioctetPerSecond);
         }
@@ -821,7 +806,7 @@ public static BitRate FromPebioctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PetabitPerSecond"/>.
         /// </summary>
-        public static BitRate FromPetabitsPerSecond(double value)
+        public static BitRate FromPetabitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.PetabitPerSecond);
         }
@@ -829,7 +814,7 @@ public static BitRate FromPetabitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PetabytePerSecond"/>.
         /// </summary>
-        public static BitRate FromPetabytesPerSecond(double value)
+        public static BitRate FromPetabytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.PetabytePerSecond);
         }
@@ -837,7 +822,7 @@ public static BitRate FromPetabytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PetaoctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromPetaoctetsPerSecond(double value)
+        public static BitRate FromPetaoctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.PetaoctetPerSecond);
         }
@@ -845,7 +830,7 @@ public static BitRate FromPetaoctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TebibitPerSecond"/>.
         /// </summary>
-        public static BitRate FromTebibitsPerSecond(double value)
+        public static BitRate FromTebibitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.TebibitPerSecond);
         }
@@ -853,7 +838,7 @@ public static BitRate FromTebibitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TebibytePerSecond"/>.
         /// </summary>
-        public static BitRate FromTebibytesPerSecond(double value)
+        public static BitRate FromTebibytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.TebibytePerSecond);
         }
@@ -861,7 +846,7 @@ public static BitRate FromTebibytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TebioctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromTebioctetsPerSecond(double value)
+        public static BitRate FromTebioctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.TebioctetPerSecond);
         }
@@ -869,7 +854,7 @@ public static BitRate FromTebioctetsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TerabitPerSecond"/>.
         /// </summary>
-        public static BitRate FromTerabitsPerSecond(double value)
+        public static BitRate FromTerabitsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.TerabitPerSecond);
         }
@@ -877,7 +862,7 @@ public static BitRate FromTerabitsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TerabytePerSecond"/>.
         /// </summary>
-        public static BitRate FromTerabytesPerSecond(double value)
+        public static BitRate FromTerabytesPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.TerabytePerSecond);
         }
@@ -885,7 +870,7 @@ public static BitRate FromTerabytesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TeraoctetPerSecond"/>.
         /// </summary>
-        public static BitRate FromTeraoctetsPerSecond(double value)
+        public static BitRate FromTeraoctetsPerSecond(QuantityValue value)
         {
             return new BitRate(value, BitRateUnit.TeraoctetPerSecond);
         }
@@ -896,7 +881,7 @@ public static BitRate FromTeraoctetsPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>BitRate unit value.</returns>
-        public static BitRate From(double value, BitRateUnit fromUnit)
+        public static BitRate From(QuantityValue value, BitRateUnit fromUnit)
         {
             return new BitRate(value, fromUnit);
         }
@@ -957,10 +942,7 @@ public static BitRate Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static BitRate Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<BitRate, BitRateUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<BitRate, BitRateUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -988,11 +970,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out BitRate result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out BitRate result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<BitRate, BitRateUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<BitRate, BitRateUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -1013,7 +991,7 @@ public static BitRateUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1024,7 +1002,7 @@ public static BitRateUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.BitRateUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.BitRateUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out BitRateUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1039,7 +1017,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out BitRateUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out BitRateUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1058,137 +1036,173 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="BitRate"/> from adding two <see cref="BitRate"/>.</summary>
         public static BitRate operator +(BitRate left, BitRate right)
         {
-            return new BitRate(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new BitRate(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="BitRate"/> from subtracting two <see cref="BitRate"/>.</summary>
         public static BitRate operator -(BitRate left, BitRate right)
         {
-            return new BitRate(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new BitRate(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="BitRate"/> from multiplying value and <see cref="BitRate"/>.</summary>
-        public static BitRate operator *(double left, BitRate right)
+        public static BitRate operator *(QuantityValue left, BitRate right)
         {
             return new BitRate(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="BitRate"/> from multiplying value and <see cref="BitRate"/>.</summary>
-        public static BitRate operator *(BitRate left, double right)
+        public static BitRate operator *(BitRate left, QuantityValue right)
         {
             return new BitRate(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="BitRate"/> from dividing <see cref="BitRate"/> by value.</summary>
-        public static BitRate operator /(BitRate left, double right)
+        public static BitRate operator /(BitRate left, QuantityValue right)
         {
             return new BitRate(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="BitRate"/> by <see cref="BitRate"/>.</summary>
-        public static double operator /(BitRate left, BitRate right)
+        public static QuantityValue operator /(BitRate left, BitRate right)
         {
             return left.BitsPerSecond / right.BitsPerSecond;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Frequency"/> from <see cref="BitRate"/> / <see cref="Information"/>.</summary>
+        public static Frequency operator /(BitRate bitRate, Information information)
+        {
+            return Frequency.FromPerSecond(bitRate.BitsPerSecond / information.Bits);
+        }
+
+        /// <summary>Get <see cref="Information"/> from <see cref="BitRate"/> * <see cref="Duration"/>.</summary>
+        public static Information operator *(BitRate bitRate, Duration duration)
+        {
+            return Information.FromBits(bitRate.BitsPerSecond * duration.Seconds);
+        }
+
+        /// <summary>Get <see cref="Information"/> from <see cref="BitRate"/> / <see cref="Frequency"/>.</summary>
+        public static Information operator /(BitRate bitRate, Frequency frequency)
+        {
+            return Information.FromBits(bitRate.BitsPerSecond / frequency.PerSecond);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(BitRate left, BitRate right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(BitRate left, BitRate right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(BitRate left, BitRate right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(BitRate left, BitRate right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="BitRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(BitRate other, BitRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="BitRate"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(BitRate)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(BitRate left, BitRate right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="BitRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(BitRate other, BitRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="BitRate"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(BitRate,BitRate)"/>.
+        ///     See that operator (and <see cref="Equals(BitRate)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(BitRate left, BitRate right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="BitRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(BitRate other, BitRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="BitRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="BitRate"/>.
+        ///     When <paramref name="obj"/> is a <see cref="BitRate"/>, this method delegates to
+        ///     <see cref="Equals(BitRate)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is BitRate otherQuantity))
+            if (obj is not BitRate otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="BitRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(BitRate other, BitRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="BitRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(BitRate other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current BitRate.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(BitRate), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="BitRate"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(BitRate)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is BitRate otherQuantity)) throw new ArgumentException("Expected type BitRate.", nameof(obj));
+            if (obj is not BitRate otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<BitRate>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="BitRate"/> with another <see cref="BitRate"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="BitRate"/> with another <see cref="BitRate"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1200,205 +1214,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(BitRate other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(BitRateUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<BitRateUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this BitRate to another BitRate with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A BitRate with the specified unit.</returns>
-        public BitRate ToUnit(BitRateUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="BitRate"/> to another <see cref="BitRate"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A BitRate with the specified unit.</returns>
-        public BitRate ToUnit(BitRateUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(BitRate), Unit, typeof(BitRate), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (BitRate)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="BitRate"/> to another <see cref="BitRate"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="BitRate"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(BitRateUnit unit, [NotNullWhen(true)] out BitRate? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            BitRate? convertedOrNull = (Unit, unit) switch
-            {
-                // BitRateUnit -> BaseUnit
-                (BitRateUnit.BytePerSecond, BitRateUnit.BitPerSecond) => new BitRate(_value * 8, BitRateUnit.BitPerSecond),
-                (BitRateUnit.ExabitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e18d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.ExabytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e18d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.ExaoctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e18d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.ExbibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.ExbibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.ExbioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.GibibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * (1024d * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.GibibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.GibioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.GigabitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e9d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.GigabytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e9d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.GigaoctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e9d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.KibibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1024d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.KibibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1024d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.KibioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1024d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.KilobitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e3d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.KilobytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e3d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.KilooctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e3d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.MebibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * (1024d * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.MebibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.MebioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.MegabitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e6d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.MegabytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e6d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.MegaoctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e6d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.OctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate(_value * 8, BitRateUnit.BitPerSecond),
-                (BitRateUnit.PebibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.PebibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.PebioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.PetabitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e15d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.PetabytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e15d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.PetaoctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e15d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.TebibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * (1024d * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.TebibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.TebioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond),
-                (BitRateUnit.TerabitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e12d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.TerabytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e12d, BitRateUnit.BitPerSecond),
-                (BitRateUnit.TeraoctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e12d, BitRateUnit.BitPerSecond),
-
-                // BaseUnit -> BitRateUnit
-                (BitRateUnit.BitPerSecond, BitRateUnit.BytePerSecond) => new BitRate(_value / 8, BitRateUnit.BytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.ExabitPerSecond) => new BitRate((_value) / 1e18d, BitRateUnit.ExabitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.ExabytePerSecond) => new BitRate((_value / 8) / 1e18d, BitRateUnit.ExabytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.ExaoctetPerSecond) => new BitRate((_value / 8) / 1e18d, BitRateUnit.ExaoctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.ExbibitPerSecond) => new BitRate((_value) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.ExbibitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.ExbibytePerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.ExbibytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.ExbioctetPerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.ExbioctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.GibibitPerSecond) => new BitRate((_value) / (1024d * 1024 * 1024), BitRateUnit.GibibitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.GibibytePerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024), BitRateUnit.GibibytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.GibioctetPerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024), BitRateUnit.GibioctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.GigabitPerSecond) => new BitRate((_value) / 1e9d, BitRateUnit.GigabitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.GigabytePerSecond) => new BitRate((_value / 8) / 1e9d, BitRateUnit.GigabytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.GigaoctetPerSecond) => new BitRate((_value / 8) / 1e9d, BitRateUnit.GigaoctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.KibibitPerSecond) => new BitRate((_value) / 1024d, BitRateUnit.KibibitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.KibibytePerSecond) => new BitRate((_value / 8) / 1024d, BitRateUnit.KibibytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.KibioctetPerSecond) => new BitRate((_value / 8) / 1024d, BitRateUnit.KibioctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.KilobitPerSecond) => new BitRate((_value) / 1e3d, BitRateUnit.KilobitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.KilobytePerSecond) => new BitRate((_value / 8) / 1e3d, BitRateUnit.KilobytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.KilooctetPerSecond) => new BitRate((_value / 8) / 1e3d, BitRateUnit.KilooctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.MebibitPerSecond) => new BitRate((_value) / (1024d * 1024), BitRateUnit.MebibitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.MebibytePerSecond) => new BitRate((_value / 8) / (1024d * 1024), BitRateUnit.MebibytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.MebioctetPerSecond) => new BitRate((_value / 8) / (1024d * 1024), BitRateUnit.MebioctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.MegabitPerSecond) => new BitRate((_value) / 1e6d, BitRateUnit.MegabitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.MegabytePerSecond) => new BitRate((_value / 8) / 1e6d, BitRateUnit.MegabytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.MegaoctetPerSecond) => new BitRate((_value / 8) / 1e6d, BitRateUnit.MegaoctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.OctetPerSecond) => new BitRate(_value / 8, BitRateUnit.OctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.PebibitPerSecond) => new BitRate((_value) / (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.PebibitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.PebibytePerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.PebibytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.PebioctetPerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.PebioctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.PetabitPerSecond) => new BitRate((_value) / 1e15d, BitRateUnit.PetabitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.PetabytePerSecond) => new BitRate((_value / 8) / 1e15d, BitRateUnit.PetabytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.PetaoctetPerSecond) => new BitRate((_value / 8) / 1e15d, BitRateUnit.PetaoctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.TebibitPerSecond) => new BitRate((_value) / (1024d * 1024 * 1024 * 1024), BitRateUnit.TebibitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.TebibytePerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024), BitRateUnit.TebibytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.TebioctetPerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024), BitRateUnit.TebioctetPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.TerabitPerSecond) => new BitRate((_value) / 1e12d, BitRateUnit.TerabitPerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.TerabytePerSecond) => new BitRate((_value / 8) / 1e12d, BitRateUnit.TerabytePerSecond),
-                (BitRateUnit.BitPerSecond, BitRateUnit.TeraoctetPerSecond) => new BitRate((_value / 8) / 1e12d, BitRateUnit.TeraoctetPerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not BitRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BitRateUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is BitRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BitRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<BitRateUnit> IQuantity<BitRateUnit>.ToUnit(BitRateUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1412,11 +1230,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
index fc7b253fa6..c50c4dc245 100644
--- a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,13 +33,14 @@ namespace UnitsNet
     ///     Brake specific fuel consumption (BSFC) is a measure of the fuel efficiency of any prime mover that burns fuel and produces rotational, or shaft, power. It is typically used for comparing the efficiency of internal combustion engines with a shaft output.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct BrakeSpecificFuelConsumption :
-        IArithmeticQuantity<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit>,
+        ILinearQuantity<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumption, double>,
+        IDivisionOperators<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumption, QuantityValue>,
         IMultiplyOperators<BrakeSpecificFuelConsumption, Power, MassFlow>,
-        IMultiplyOperators<BrakeSpecificFuelConsumption, SpecificEnergy, double>,
+        IMultiplyOperators<BrakeSpecificFuelConsumption, SpecificEnergy, QuantityValue>,
         IComparisonOperators<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumption, bool>,
         IParsable<BrakeSpecificFuelConsumption>,
 #endif
@@ -54,7 +53,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -104,7 +103,7 @@ public static BrakeSpecificFuelConsumptionInfo CreateDefault(Func<IEnumerable<Un
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="BrakeSpecificFuelConsumption"/> is [T^2][L^-2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="BrakeSpecificFuelConsumption"/> is T^2L^-2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 0, 2, 0, 0, 0, 0);
 
@@ -119,17 +118,19 @@ public static BrakeSpecificFuelConsumptionInfo CreateDefault(Func<IEnumerable<Un
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{BrakeSpecificFuelConsumptionUnit}"/> representing the default unit mappings for BrakeSpecificFuelConsumption.</returns>
             public static IEnumerable<UnitDefinition<BrakeSpecificFuelConsumptionUnit>> GetDefaultMappings()
             {
-                yield return new (BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, "GramPerKiloWattHour", "GramsPerKiloWattHour", BaseUnits.Undefined);
+                yield return new (BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, "GramPerKiloWattHour", "GramsPerKiloWattHour", BaseUnits.Undefined,
+                     3600000000
+                );
                 yield return new (BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, "KilogramPerJoule", "KilogramsPerJoule", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, "PoundPerMechanicalHorsepowerHour", "PoundsPerMechanicalHorsepowerHour", BaseUnits.Undefined);
+                yield return new (BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, "PoundPerMechanicalHorsepowerHour", "PoundsPerMechanicalHorsepowerHour", BaseUnits.Undefined,
+                     new QuantityValue(191751395532579, 32399455)
+                );
             }
         }
 
         static BrakeSpecificFuelConsumption()
         {
-            Info = BrakeSpecificFuelConsumptionInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(BrakeSpecificFuelConsumptionInfo.CreateDefault);
         }
 
         /// <summary>
@@ -137,7 +138,7 @@ static BrakeSpecificFuelConsumption()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public BrakeSpecificFuelConsumption(double value, BrakeSpecificFuelConsumptionUnit unit)
+        public BrakeSpecificFuelConsumption(QuantityValue value, BrakeSpecificFuelConsumptionUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -151,7 +152,7 @@ public BrakeSpecificFuelConsumption(double value, BrakeSpecificFuelConsumptionUn
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public BrakeSpecificFuelConsumption(double value, UnitSystem unitSystem)
+        public BrakeSpecificFuelConsumption(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -162,7 +163,8 @@ public BrakeSpecificFuelConsumption(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="BrakeSpecificFuelConsumption" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit> Info { get; }
@@ -191,10 +193,8 @@ public BrakeSpecificFuelConsumption(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public BrakeSpecificFuelConsumptionUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -228,42 +228,24 @@ public BrakeSpecificFuelConsumption(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour"/>
         /// </summary>
-        public double GramsPerKiloWattHour => As(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
+        public QuantityValue GramsPerKiloWattHour => this.As(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BrakeSpecificFuelConsumptionUnit.KilogramPerJoule"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BrakeSpecificFuelConsumptionUnit.KilogramPerJoule"/>
         /// </summary>
-        public double KilogramsPerJoule => As(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
+        public QuantityValue KilogramsPerJoule => this.As(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour"/>
         /// </summary>
-        public double PoundsPerMechanicalHorsepowerHour => As(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
+        public QuantityValue PoundsPerMechanicalHorsepowerHour => this.As(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: BrakeSpecificFuelConsumptionUnit -> BaseUnit
-            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption>(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, quantity => quantity.ToUnit(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
-            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption>(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, quantity => quantity.ToUnit(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption>(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> BrakeSpecificFuelConsumptionUnit
-            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption>(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, quantity => quantity.ToUnit(BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour));
-            unitConverter.SetConversionFunction<BrakeSpecificFuelConsumption>(BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, quantity => quantity.ToUnit(BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -292,7 +274,7 @@ public static string GetAbbreviation(BrakeSpecificFuelConsumptionUnit unit, IFor
         /// <summary>
         ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour"/>.
         /// </summary>
-        public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(double value)
+        public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(QuantityValue value)
         {
             return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
         }
@@ -300,7 +282,7 @@ public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(double value
         /// <summary>
         ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.KilogramPerJoule"/>.
         /// </summary>
-        public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(double value)
+        public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(QuantityValue value)
         {
             return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
         }
@@ -308,7 +290,7 @@ public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(double value)
         /// <summary>
         ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour"/>.
         /// </summary>
-        public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour(double value)
+        public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour(QuantityValue value)
         {
             return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
         }
@@ -319,7 +301,7 @@ public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>BrakeSpecificFuelConsumption unit value.</returns>
-        public static BrakeSpecificFuelConsumption From(double value, BrakeSpecificFuelConsumptionUnit fromUnit)
+        public static BrakeSpecificFuelConsumption From(QuantityValue value, BrakeSpecificFuelConsumptionUnit fromUnit)
         {
             return new BrakeSpecificFuelConsumption(value, fromUnit);
         }
@@ -380,10 +362,7 @@ public static BrakeSpecificFuelConsumption Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static BrakeSpecificFuelConsumption Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -411,11 +390,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out BrakeSpecificFue
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out BrakeSpecificFuelConsumption result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -436,7 +411,7 @@ public static BrakeSpecificFuelConsumptionUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -447,7 +422,7 @@ public static BrakeSpecificFuelConsumptionUnit ParseUnit(string str, IFormatProv
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.BrakeSpecificFuelConsumptionUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.BrakeSpecificFuelConsumptionUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out BrakeSpecificFuelConsumptionUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -462,7 +437,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out BrakeSpecifi
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out BrakeSpecificFuelConsumptionUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -481,35 +456,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from adding two <see cref="BrakeSpecificFuelConsumption"/>.</summary>
         public static BrakeSpecificFuelConsumption operator +(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
         {
-            return new BrakeSpecificFuelConsumption(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new BrakeSpecificFuelConsumption(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from subtracting two <see cref="BrakeSpecificFuelConsumption"/>.</summary>
         public static BrakeSpecificFuelConsumption operator -(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
         {
-            return new BrakeSpecificFuelConsumption(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new BrakeSpecificFuelConsumption(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from multiplying value and <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static BrakeSpecificFuelConsumption operator *(double left, BrakeSpecificFuelConsumption right)
+        public static BrakeSpecificFuelConsumption operator *(QuantityValue left, BrakeSpecificFuelConsumption right)
         {
             return new BrakeSpecificFuelConsumption(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from multiplying value and <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static BrakeSpecificFuelConsumption operator *(BrakeSpecificFuelConsumption left, double right)
+        public static BrakeSpecificFuelConsumption operator *(BrakeSpecificFuelConsumption left, QuantityValue right)
         {
             return new BrakeSpecificFuelConsumption(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from dividing <see cref="BrakeSpecificFuelConsumption"/> by value.</summary>
-        public static BrakeSpecificFuelConsumption operator /(BrakeSpecificFuelConsumption left, double right)
+        public static BrakeSpecificFuelConsumption operator /(BrakeSpecificFuelConsumption left, QuantityValue right)
         {
             return new BrakeSpecificFuelConsumption(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="BrakeSpecificFuelConsumption"/> by <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static double operator /(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
+        public static QuantityValue operator /(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
         {
             return left.KilogramsPerJoule / right.KilogramsPerJoule;
         }
@@ -524,16 +499,16 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return MassFlow.FromKilogramsPerSecond(brakeSpecificFuelConsumption.KilogramsPerJoule * power.Watts);
         }
 
-        /// <summary>Get <see cref="SpecificEnergy"/> from <see cref="double"/> / <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static SpecificEnergy operator /(double value, BrakeSpecificFuelConsumption brakeSpecificFuelConsumption)
+        /// <summary>Get <see cref="QuantityValue"/> from <see cref="BrakeSpecificFuelConsumption"/> * <see cref="SpecificEnergy"/>.</summary>
+        public static QuantityValue operator *(BrakeSpecificFuelConsumption brakeSpecificFuelConsumption, SpecificEnergy specificEnergy)
         {
-            return SpecificEnergy.FromJoulesPerKilogram(value / brakeSpecificFuelConsumption.KilogramsPerJoule);
+            return brakeSpecificFuelConsumption.KilogramsPerJoule * specificEnergy.JoulesPerKilogram;
         }
 
-        /// <summary>Get <see cref="double"/> from <see cref="BrakeSpecificFuelConsumption"/> * <see cref="SpecificEnergy"/>.</summary>
-        public static double operator *(BrakeSpecificFuelConsumption brakeSpecificFuelConsumption, SpecificEnergy specificEnergy)
+        /// <summary>Get <see cref="SpecificEnergy"/> from <see cref="QuantityValue"/> / <see cref="BrakeSpecificFuelConsumption"/>.</summary>
+        public static SpecificEnergy operator /(QuantityValue value, BrakeSpecificFuelConsumption brakeSpecificFuelConsumption)
         {
-            return brakeSpecificFuelConsumption.KilogramsPerJoule * specificEnergy.JoulesPerKilogram;
+            return SpecificEnergy.FromJoulesPerKilogram(value / brakeSpecificFuelConsumption.KilogramsPerJoule);
         }
 
         #endregion
@@ -543,97 +518,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="BrakeSpecificFuelConsumption"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(BrakeSpecificFuelConsumption other, BrakeSpecificFuelConsumption tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="BrakeSpecificFuelConsumption"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(BrakeSpecificFuelConsumption)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="BrakeSpecificFuelConsumption"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(BrakeSpecificFuelConsumption other, BrakeSpecificFuelConsumption tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="BrakeSpecificFuelConsumption"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(BrakeSpecificFuelConsumption,BrakeSpecificFuelConsumption)"/>.
+        ///     See that operator (and <see cref="Equals(BrakeSpecificFuelConsumption)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(BrakeSpecificFuelConsumption left, BrakeSpecificFuelConsumption right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="BrakeSpecificFuelConsumption"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(BrakeSpecificFuelConsumption other, BrakeSpecificFuelConsumption tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="BrakeSpecificFuelConsumption"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="BrakeSpecificFuelConsumption"/>.
+        ///     When <paramref name="obj"/> is a <see cref="BrakeSpecificFuelConsumption"/>, this method delegates to
+        ///     <see cref="Equals(BrakeSpecificFuelConsumption)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is BrakeSpecificFuelConsumption otherQuantity))
+            if (obj is not BrakeSpecificFuelConsumption otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="BrakeSpecificFuelConsumption"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(BrakeSpecificFuelConsumption other, BrakeSpecificFuelConsumption tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="BrakeSpecificFuelConsumption"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(BrakeSpecificFuelConsumption other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current BrakeSpecificFuelConsumption.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(BrakeSpecificFuelConsumption), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="BrakeSpecificFuelConsumption"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(BrakeSpecificFuelConsumption)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is BrakeSpecificFuelConsumption otherQuantity)) throw new ArgumentException("Expected type BrakeSpecificFuelConsumption.", nameof(obj));
+            if (obj is not BrakeSpecificFuelConsumption otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<BrakeSpecificFuelConsumption>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="BrakeSpecificFuelConsumption"/> with another <see cref="BrakeSpecificFuelConsumption"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="BrakeSpecificFuelConsumption"/> with another <see cref="BrakeSpecificFuelConsumption"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -645,133 +634,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(BrakeSpecificFuelConsumption other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(BrakeSpecificFuelConsumptionUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<BrakeSpecificFuelConsumptionUnit>());
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this BrakeSpecificFuelConsumption to another BrakeSpecificFuelConsumption with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A BrakeSpecificFuelConsumption with the specified unit.</returns>
-        public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="BrakeSpecificFuelConsumption"/> to another <see cref="BrakeSpecificFuelConsumption"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A BrakeSpecificFuelConsumption with the specified unit.</returns>
-        public BrakeSpecificFuelConsumption ToUnit(BrakeSpecificFuelConsumptionUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(BrakeSpecificFuelConsumption), Unit, typeof(BrakeSpecificFuelConsumption), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (BrakeSpecificFuelConsumption)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="BrakeSpecificFuelConsumption"/> to another <see cref="BrakeSpecificFuelConsumption"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="BrakeSpecificFuelConsumption"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(BrakeSpecificFuelConsumptionUnit unit, [NotNullWhen(true)] out BrakeSpecificFuelConsumption? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            BrakeSpecificFuelConsumption? convertedOrNull = (Unit, unit) switch
-            {
-                // BrakeSpecificFuelConsumptionUnit -> BaseUnit
-                (BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule) => new BrakeSpecificFuelConsumption(_value / 3.6e9, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule),
-                (BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule) => new BrakeSpecificFuelConsumption(_value * (0.45359237 / (76.0402249 * 9.80665))/3600, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule),
-
-                // BaseUnit -> BrakeSpecificFuelConsumptionUnit
-                (BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour) => new BrakeSpecificFuelConsumption(_value * 3.6e9, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour),
-                (BrakeSpecificFuelConsumptionUnit.KilogramPerJoule, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour) => new BrakeSpecificFuelConsumption(_value * 3600 / (0.45359237 / (76.0402249 * 9.80665)), BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not BrakeSpecificFuelConsumptionUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BrakeSpecificFuelConsumptionUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is BrakeSpecificFuelConsumptionUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BrakeSpecificFuelConsumptionUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<BrakeSpecificFuelConsumptionUnit> IQuantity<BrakeSpecificFuelConsumptionUnit>.ToUnit(BrakeSpecificFuelConsumptionUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -785,11 +650,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
index 25671ba248..f9f8add9d4 100644
--- a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     A unit that represents a fractional change in size in response to a change in temperature.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct CoefficientOfThermalExpansion :
-        IArithmeticQuantity<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit>,
+        ILinearQuantity<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<CoefficientOfThermalExpansion, CoefficientOfThermalExpansion, double>,
+        IDivisionOperators<CoefficientOfThermalExpansion, CoefficientOfThermalExpansion, QuantityValue>,
         IMultiplyOperators<CoefficientOfThermalExpansion, TemperatureDelta, Ratio>,
         IComparisonOperators<CoefficientOfThermalExpansion, CoefficientOfThermalExpansion, bool>,
         IParsable<CoefficientOfThermalExpansion>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static CoefficientOfThermalExpansionInfo CreateDefault(Func<IEnumerable<U
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="CoefficientOfThermalExpansion"/> is [Θ^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="CoefficientOfThermalExpansion"/> is Θ^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, 0, 0, -1, 0, 0);
 
@@ -118,20 +117,28 @@ public static CoefficientOfThermalExpansionInfo CreateDefault(Func<IEnumerable<U
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{CoefficientOfThermalExpansionUnit}"/> representing the default unit mappings for CoefficientOfThermalExpansion.</returns>
             public static IEnumerable<UnitDefinition<CoefficientOfThermalExpansionUnit>> GetDefaultMappings()
             {
-                yield return new (CoefficientOfThermalExpansionUnit.PerDegreeCelsius, "PerDegreeCelsius", "PerDegreeCelsius", new BaseUnits(temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit, "PerDegreeFahrenheit", "PerDegreeFahrenheit", new BaseUnits(temperature: TemperatureUnit.DegreeFahrenheit));
+                yield return new (CoefficientOfThermalExpansionUnit.PerDegreeCelsius, "PerDegreeCelsius", "PerDegreeCelsius", new BaseUnits(temperature: TemperatureUnit.DegreeCelsius),
+                     1
+                );
+                yield return new (CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit, "PerDegreeFahrenheit", "PerDegreeFahrenheit", new BaseUnits(temperature: TemperatureUnit.DegreeFahrenheit),
+                     new QuantityValue(5, 9)
+                );
                 yield return new (CoefficientOfThermalExpansionUnit.PerKelvin, "PerKelvin", "PerKelvin", new BaseUnits(temperature: TemperatureUnit.Kelvin));
-                yield return new (CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius, "PpmPerDegreeCelsius", "PpmPerDegreeCelsius", BaseUnits.Undefined);
-                yield return new (CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit, "PpmPerDegreeFahrenheit", "PpmPerDegreeFahrenheit", BaseUnits.Undefined);
-                yield return new (CoefficientOfThermalExpansionUnit.PpmPerKelvin, "PpmPerKelvin", "PpmPerKelvin", BaseUnits.Undefined);
+                yield return new (CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius, "PpmPerDegreeCelsius", "PpmPerDegreeCelsius", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit, "PpmPerDegreeFahrenheit", "PpmPerDegreeFahrenheit", BaseUnits.Undefined,
+                     new QuantityValue(5000000, 9)
+                );
+                yield return new (CoefficientOfThermalExpansionUnit.PpmPerKelvin, "PpmPerKelvin", "PpmPerKelvin", BaseUnits.Undefined,
+                     1000000
+                );
             }
         }
 
         static CoefficientOfThermalExpansion()
         {
-            Info = CoefficientOfThermalExpansionInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(CoefficientOfThermalExpansionInfo.CreateDefault);
         }
 
         /// <summary>
@@ -139,7 +146,7 @@ static CoefficientOfThermalExpansion()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public CoefficientOfThermalExpansion(double value, CoefficientOfThermalExpansionUnit unit)
+        public CoefficientOfThermalExpansion(QuantityValue value, CoefficientOfThermalExpansionUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -153,7 +160,7 @@ public CoefficientOfThermalExpansion(double value, CoefficientOfThermalExpansion
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public CoefficientOfThermalExpansion(double value, UnitSystem unitSystem)
+        public CoefficientOfThermalExpansion(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -164,7 +171,8 @@ public CoefficientOfThermalExpansion(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="CoefficientOfThermalExpansion" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit> Info { get; }
@@ -193,10 +201,8 @@ public CoefficientOfThermalExpansion(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public CoefficientOfThermalExpansionUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -230,63 +236,39 @@ public CoefficientOfThermalExpansion(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PerDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PerDegreeCelsius"/>
         /// </summary>
-        public double PerDegreeCelsius => As(CoefficientOfThermalExpansionUnit.PerDegreeCelsius);
+        public QuantityValue PerDegreeCelsius => this.As(CoefficientOfThermalExpansionUnit.PerDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit"/>
         /// </summary>
-        public double PerDegreeFahrenheit => As(CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit);
+        public QuantityValue PerDegreeFahrenheit => this.As(CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PerKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PerKelvin"/>
         /// </summary>
-        public double PerKelvin => As(CoefficientOfThermalExpansionUnit.PerKelvin);
+        public QuantityValue PerKelvin => this.As(CoefficientOfThermalExpansionUnit.PerKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius"/>
         /// </summary>
-        public double PpmPerDegreeCelsius => As(CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius);
+        public QuantityValue PpmPerDegreeCelsius => this.As(CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit"/>
         /// </summary>
-        public double PpmPerDegreeFahrenheit => As(CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit);
+        public QuantityValue PpmPerDegreeFahrenheit => this.As(CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PpmPerKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CoefficientOfThermalExpansionUnit.PpmPerKelvin"/>
         /// </summary>
-        public double PpmPerKelvin => As(CoefficientOfThermalExpansionUnit.PpmPerKelvin);
+        public QuantityValue PpmPerKelvin => this.As(CoefficientOfThermalExpansionUnit.PpmPerKelvin);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: CoefficientOfThermalExpansionUnit -> BaseUnit
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PerDegreeCelsius, CoefficientOfThermalExpansionUnit.PerKelvin, quantity => quantity.ToUnit(CoefficientOfThermalExpansionUnit.PerKelvin));
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit, CoefficientOfThermalExpansionUnit.PerKelvin, quantity => quantity.ToUnit(CoefficientOfThermalExpansionUnit.PerKelvin));
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius, CoefficientOfThermalExpansionUnit.PerKelvin, quantity => quantity.ToUnit(CoefficientOfThermalExpansionUnit.PerKelvin));
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit, CoefficientOfThermalExpansionUnit.PerKelvin, quantity => quantity.ToUnit(CoefficientOfThermalExpansionUnit.PerKelvin));
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PpmPerKelvin, CoefficientOfThermalExpansionUnit.PerKelvin, quantity => quantity.ToUnit(CoefficientOfThermalExpansionUnit.PerKelvin));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PerKelvin, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> CoefficientOfThermalExpansionUnit
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PerDegreeCelsius, quantity => quantity.ToUnit(CoefficientOfThermalExpansionUnit.PerDegreeCelsius));
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit, quantity => quantity.ToUnit(CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit));
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius, quantity => quantity.ToUnit(CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius));
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit, quantity => quantity.ToUnit(CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit));
-            unitConverter.SetConversionFunction<CoefficientOfThermalExpansion>(CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PpmPerKelvin, quantity => quantity.ToUnit(CoefficientOfThermalExpansionUnit.PpmPerKelvin));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -315,7 +297,7 @@ public static string GetAbbreviation(CoefficientOfThermalExpansionUnit unit, IFo
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerDegreeCelsius"/>.
         /// </summary>
-        public static CoefficientOfThermalExpansion FromPerDegreeCelsius(double value)
+        public static CoefficientOfThermalExpansion FromPerDegreeCelsius(QuantityValue value)
         {
             return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PerDegreeCelsius);
         }
@@ -323,7 +305,7 @@ public static CoefficientOfThermalExpansion FromPerDegreeCelsius(double value)
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit"/>.
         /// </summary>
-        public static CoefficientOfThermalExpansion FromPerDegreeFahrenheit(double value)
+        public static CoefficientOfThermalExpansion FromPerDegreeFahrenheit(QuantityValue value)
         {
             return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit);
         }
@@ -331,7 +313,7 @@ public static CoefficientOfThermalExpansion FromPerDegreeFahrenheit(double value
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerKelvin"/>.
         /// </summary>
-        public static CoefficientOfThermalExpansion FromPerKelvin(double value)
+        public static CoefficientOfThermalExpansion FromPerKelvin(QuantityValue value)
         {
             return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PerKelvin);
         }
@@ -339,7 +321,7 @@ public static CoefficientOfThermalExpansion FromPerKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius"/>.
         /// </summary>
-        public static CoefficientOfThermalExpansion FromPpmPerDegreeCelsius(double value)
+        public static CoefficientOfThermalExpansion FromPpmPerDegreeCelsius(QuantityValue value)
         {
             return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius);
         }
@@ -347,7 +329,7 @@ public static CoefficientOfThermalExpansion FromPpmPerDegreeCelsius(double value
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit"/>.
         /// </summary>
-        public static CoefficientOfThermalExpansion FromPpmPerDegreeFahrenheit(double value)
+        public static CoefficientOfThermalExpansion FromPpmPerDegreeFahrenheit(QuantityValue value)
         {
             return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit);
         }
@@ -355,7 +337,7 @@ public static CoefficientOfThermalExpansion FromPpmPerDegreeFahrenheit(double va
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerKelvin"/>.
         /// </summary>
-        public static CoefficientOfThermalExpansion FromPpmPerKelvin(double value)
+        public static CoefficientOfThermalExpansion FromPpmPerKelvin(QuantityValue value)
         {
             return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PpmPerKelvin);
         }
@@ -366,7 +348,7 @@ public static CoefficientOfThermalExpansion FromPpmPerKelvin(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>CoefficientOfThermalExpansion unit value.</returns>
-        public static CoefficientOfThermalExpansion From(double value, CoefficientOfThermalExpansionUnit fromUnit)
+        public static CoefficientOfThermalExpansion From(QuantityValue value, CoefficientOfThermalExpansionUnit fromUnit)
         {
             return new CoefficientOfThermalExpansion(value, fromUnit);
         }
@@ -427,10 +409,7 @@ public static CoefficientOfThermalExpansion Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static CoefficientOfThermalExpansion Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -458,11 +437,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out CoefficientOfThe
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out CoefficientOfThermalExpansion result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -483,7 +458,7 @@ public static CoefficientOfThermalExpansionUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -494,7 +469,7 @@ public static CoefficientOfThermalExpansionUnit ParseUnit(string str, IFormatPro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.CoefficientOfThermalExpansionUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.CoefficientOfThermalExpansionUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out CoefficientOfThermalExpansionUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -509,7 +484,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out CoefficientO
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out CoefficientOfThermalExpansionUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -528,35 +503,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="CoefficientOfThermalExpansion"/> from adding two <see cref="CoefficientOfThermalExpansion"/>.</summary>
         public static CoefficientOfThermalExpansion operator +(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
         {
-            return new CoefficientOfThermalExpansion(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new CoefficientOfThermalExpansion(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="CoefficientOfThermalExpansion"/> from subtracting two <see cref="CoefficientOfThermalExpansion"/>.</summary>
         public static CoefficientOfThermalExpansion operator -(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
         {
-            return new CoefficientOfThermalExpansion(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new CoefficientOfThermalExpansion(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="CoefficientOfThermalExpansion"/> from multiplying value and <see cref="CoefficientOfThermalExpansion"/>.</summary>
-        public static CoefficientOfThermalExpansion operator *(double left, CoefficientOfThermalExpansion right)
+        public static CoefficientOfThermalExpansion operator *(QuantityValue left, CoefficientOfThermalExpansion right)
         {
             return new CoefficientOfThermalExpansion(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="CoefficientOfThermalExpansion"/> from multiplying value and <see cref="CoefficientOfThermalExpansion"/>.</summary>
-        public static CoefficientOfThermalExpansion operator *(CoefficientOfThermalExpansion left, double right)
+        public static CoefficientOfThermalExpansion operator *(CoefficientOfThermalExpansion left, QuantityValue right)
         {
             return new CoefficientOfThermalExpansion(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="CoefficientOfThermalExpansion"/> from dividing <see cref="CoefficientOfThermalExpansion"/> by value.</summary>
-        public static CoefficientOfThermalExpansion operator /(CoefficientOfThermalExpansion left, double right)
+        public static CoefficientOfThermalExpansion operator /(CoefficientOfThermalExpansion left, QuantityValue right)
         {
             return new CoefficientOfThermalExpansion(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="CoefficientOfThermalExpansion"/> by <see cref="CoefficientOfThermalExpansion"/>.</summary>
-        public static double operator /(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
+        public static QuantityValue operator /(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
         {
             return left.PerKelvin / right.PerKelvin;
         }
@@ -578,97 +553,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="CoefficientOfThermalExpansion"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(CoefficientOfThermalExpansion other, CoefficientOfThermalExpansion tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="CoefficientOfThermalExpansion"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(CoefficientOfThermalExpansion)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="CoefficientOfThermalExpansion"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(CoefficientOfThermalExpansion other, CoefficientOfThermalExpansion tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="CoefficientOfThermalExpansion"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(CoefficientOfThermalExpansion,CoefficientOfThermalExpansion)"/>.
+        ///     See that operator (and <see cref="Equals(CoefficientOfThermalExpansion)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(CoefficientOfThermalExpansion left, CoefficientOfThermalExpansion right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="CoefficientOfThermalExpansion"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(CoefficientOfThermalExpansion other, CoefficientOfThermalExpansion tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="CoefficientOfThermalExpansion"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="CoefficientOfThermalExpansion"/>.
+        ///     When <paramref name="obj"/> is a <see cref="CoefficientOfThermalExpansion"/>, this method delegates to
+        ///     <see cref="Equals(CoefficientOfThermalExpansion)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is CoefficientOfThermalExpansion otherQuantity))
+            if (obj is not CoefficientOfThermalExpansion otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="CoefficientOfThermalExpansion"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(CoefficientOfThermalExpansion other, CoefficientOfThermalExpansion tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="CoefficientOfThermalExpansion"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(CoefficientOfThermalExpansion other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current CoefficientOfThermalExpansion.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(CoefficientOfThermalExpansion), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="CoefficientOfThermalExpansion"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(CoefficientOfThermalExpansion)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is CoefficientOfThermalExpansion otherQuantity)) throw new ArgumentException("Expected type CoefficientOfThermalExpansion.", nameof(obj));
+            if (obj is not CoefficientOfThermalExpansion otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<CoefficientOfThermalExpansion>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="CoefficientOfThermalExpansion"/> with another <see cref="CoefficientOfThermalExpansion"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="CoefficientOfThermalExpansion"/> with another <see cref="CoefficientOfThermalExpansion"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -680,139 +669,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(CoefficientOfThermalExpansion other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(CoefficientOfThermalExpansionUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<CoefficientOfThermalExpansionUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this CoefficientOfThermalExpansion to another CoefficientOfThermalExpansion with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A CoefficientOfThermalExpansion with the specified unit.</returns>
-        public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="CoefficientOfThermalExpansion"/> to another <see cref="CoefficientOfThermalExpansion"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A CoefficientOfThermalExpansion with the specified unit.</returns>
-        public CoefficientOfThermalExpansion ToUnit(CoefficientOfThermalExpansionUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(CoefficientOfThermalExpansion), Unit, typeof(CoefficientOfThermalExpansion), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (CoefficientOfThermalExpansion)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="CoefficientOfThermalExpansion"/> to another <see cref="CoefficientOfThermalExpansion"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="CoefficientOfThermalExpansion"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(CoefficientOfThermalExpansionUnit unit, [NotNullWhen(true)] out CoefficientOfThermalExpansion? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            CoefficientOfThermalExpansion? convertedOrNull = (Unit, unit) switch
-            {
-                // CoefficientOfThermalExpansionUnit -> BaseUnit
-                (CoefficientOfThermalExpansionUnit.PerDegreeCelsius, CoefficientOfThermalExpansionUnit.PerKelvin) => new CoefficientOfThermalExpansion(_value, CoefficientOfThermalExpansionUnit.PerKelvin),
-                (CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit, CoefficientOfThermalExpansionUnit.PerKelvin) => new CoefficientOfThermalExpansion(_value * 9 / 5, CoefficientOfThermalExpansionUnit.PerKelvin),
-                (CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius, CoefficientOfThermalExpansionUnit.PerKelvin) => new CoefficientOfThermalExpansion(_value / 1e6, CoefficientOfThermalExpansionUnit.PerKelvin),
-                (CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit, CoefficientOfThermalExpansionUnit.PerKelvin) => new CoefficientOfThermalExpansion(_value * 9 / 5e6, CoefficientOfThermalExpansionUnit.PerKelvin),
-                (CoefficientOfThermalExpansionUnit.PpmPerKelvin, CoefficientOfThermalExpansionUnit.PerKelvin) => new CoefficientOfThermalExpansion(_value / 1e6, CoefficientOfThermalExpansionUnit.PerKelvin),
-
-                // BaseUnit -> CoefficientOfThermalExpansionUnit
-                (CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PerDegreeCelsius) => new CoefficientOfThermalExpansion(_value, CoefficientOfThermalExpansionUnit.PerDegreeCelsius),
-                (CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit) => new CoefficientOfThermalExpansion(_value * 5 / 9, CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit),
-                (CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius) => new CoefficientOfThermalExpansion(_value * 1e6, CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius),
-                (CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit) => new CoefficientOfThermalExpansion(_value * 5e6 / 9, CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit),
-                (CoefficientOfThermalExpansionUnit.PerKelvin, CoefficientOfThermalExpansionUnit.PpmPerKelvin) => new CoefficientOfThermalExpansion(_value * 1e6, CoefficientOfThermalExpansionUnit.PpmPerKelvin),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not CoefficientOfThermalExpansionUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CoefficientOfThermalExpansionUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is CoefficientOfThermalExpansionUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CoefficientOfThermalExpansionUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<CoefficientOfThermalExpansionUnit> IQuantity<CoefficientOfThermalExpansionUnit>.ToUnit(CoefficientOfThermalExpansionUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -826,11 +685,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
index 6aafee49bf..2a24174364 100644
--- a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Compressibility :
-        IArithmeticQuantity<Compressibility, CompressibilityUnit>,
+        ILinearQuantity<Compressibility, CompressibilityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Compressibility, Compressibility, double>,
+        IDivisionOperators<Compressibility, Compressibility, QuantityValue>,
+        IMultiplyOperators<Compressibility, Pressure, Ratio>,
         IComparisonOperators<Compressibility, Compressibility, bool>,
         IParsable<Compressibility>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static CompressibilityInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Compressibility"/> is [T^2][L][M^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Compressibility"/> is T^2LM^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, -1, 2, 0, 0, 0, 0);
 
@@ -117,21 +117,31 @@ public static CompressibilityInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{CompressibilityUnit}"/> representing the default unit mappings for Compressibility.</returns>
             public static IEnumerable<UnitDefinition<CompressibilityUnit>> GetDefaultMappings()
             {
-                yield return new (CompressibilityUnit.InverseAtmosphere, "InverseAtmosphere", "InverseAtmospheres", BaseUnits.Undefined);
-                yield return new (CompressibilityUnit.InverseBar, "InverseBar", "InverseBars", BaseUnits.Undefined);
-                yield return new (CompressibilityUnit.InverseKilopascal, "InverseKilopascal", "InverseKilopascals", BaseUnits.Undefined);
-                yield return new (CompressibilityUnit.InverseMegapascal, "InverseMegapascal", "InverseMegapascals", BaseUnits.Undefined);
-                yield return new (CompressibilityUnit.InverseMillibar, "InverseMillibar", "InverseMillibars", BaseUnits.Undefined);
+                yield return new (CompressibilityUnit.InverseAtmosphere, "InverseAtmosphere", "InverseAtmospheres", BaseUnits.Undefined,
+                     101325
+                );
+                yield return new (CompressibilityUnit.InverseBar, "InverseBar", "InverseBars", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (CompressibilityUnit.InverseKilopascal, "InverseKilopascal", "InverseKilopascals", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (CompressibilityUnit.InverseMegapascal, "InverseMegapascal", "InverseMegapascals", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (CompressibilityUnit.InverseMillibar, "InverseMillibar", "InverseMillibars", BaseUnits.Undefined,
+                     100
+                );
                 yield return new (CompressibilityUnit.InversePascal, "InversePascal", "InversePascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (CompressibilityUnit.InversePoundForcePerSquareInch, "InversePoundForcePerSquareInch", "InversePoundsForcePerSquareInch", BaseUnits.Undefined);
+                yield return new (CompressibilityUnit.InversePoundForcePerSquareInch, "InversePoundForcePerSquareInch", "InversePoundsForcePerSquareInch", BaseUnits.Undefined,
+                     new QuantityValue(6894757293168361, 1000000000000)
+                );
             }
         }
 
         static Compressibility()
         {
-            Info = CompressibilityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(CompressibilityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -139,7 +149,7 @@ static Compressibility()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Compressibility(double value, CompressibilityUnit unit)
+        public Compressibility(QuantityValue value, CompressibilityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -153,7 +163,7 @@ public Compressibility(double value, CompressibilityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Compressibility(double value, UnitSystem unitSystem)
+        public Compressibility(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -164,7 +174,8 @@ public Compressibility(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Compressibility" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Compressibility, CompressibilityUnit> Info { get; }
@@ -193,10 +204,8 @@ public Compressibility(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public CompressibilityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -230,70 +239,44 @@ public Compressibility(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseAtmosphere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseAtmosphere"/>
         /// </summary>
-        public double InverseAtmospheres => As(CompressibilityUnit.InverseAtmosphere);
+        public QuantityValue InverseAtmospheres => this.As(CompressibilityUnit.InverseAtmosphere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseBar"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseBar"/>
         /// </summary>
-        public double InverseBars => As(CompressibilityUnit.InverseBar);
+        public QuantityValue InverseBars => this.As(CompressibilityUnit.InverseBar);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseKilopascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseKilopascal"/>
         /// </summary>
-        public double InverseKilopascals => As(CompressibilityUnit.InverseKilopascal);
+        public QuantityValue InverseKilopascals => this.As(CompressibilityUnit.InverseKilopascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseMegapascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseMegapascal"/>
         /// </summary>
-        public double InverseMegapascals => As(CompressibilityUnit.InverseMegapascal);
+        public QuantityValue InverseMegapascals => this.As(CompressibilityUnit.InverseMegapascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseMillibar"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CompressibilityUnit.InverseMillibar"/>
         /// </summary>
-        public double InverseMillibars => As(CompressibilityUnit.InverseMillibar);
+        public QuantityValue InverseMillibars => this.As(CompressibilityUnit.InverseMillibar);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InversePascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CompressibilityUnit.InversePascal"/>
         /// </summary>
-        public double InversePascals => As(CompressibilityUnit.InversePascal);
+        public QuantityValue InversePascals => this.As(CompressibilityUnit.InversePascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="CompressibilityUnit.InversePoundForcePerSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="CompressibilityUnit.InversePoundForcePerSquareInch"/>
         /// </summary>
-        public double InversePoundsForcePerSquareInch => As(CompressibilityUnit.InversePoundForcePerSquareInch);
+        public QuantityValue InversePoundsForcePerSquareInch => this.As(CompressibilityUnit.InversePoundForcePerSquareInch);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: CompressibilityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InverseAtmosphere, CompressibilityUnit.InversePascal, quantity => quantity.ToUnit(CompressibilityUnit.InversePascal));
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InverseBar, CompressibilityUnit.InversePascal, quantity => quantity.ToUnit(CompressibilityUnit.InversePascal));
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InverseKilopascal, CompressibilityUnit.InversePascal, quantity => quantity.ToUnit(CompressibilityUnit.InversePascal));
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InverseMegapascal, CompressibilityUnit.InversePascal, quantity => quantity.ToUnit(CompressibilityUnit.InversePascal));
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InverseMillibar, CompressibilityUnit.InversePascal, quantity => quantity.ToUnit(CompressibilityUnit.InversePascal));
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InversePoundForcePerSquareInch, CompressibilityUnit.InversePascal, quantity => quantity.ToUnit(CompressibilityUnit.InversePascal));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InversePascal, CompressibilityUnit.InversePascal, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> CompressibilityUnit
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InversePascal, CompressibilityUnit.InverseAtmosphere, quantity => quantity.ToUnit(CompressibilityUnit.InverseAtmosphere));
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InversePascal, CompressibilityUnit.InverseBar, quantity => quantity.ToUnit(CompressibilityUnit.InverseBar));
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InversePascal, CompressibilityUnit.InverseKilopascal, quantity => quantity.ToUnit(CompressibilityUnit.InverseKilopascal));
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InversePascal, CompressibilityUnit.InverseMegapascal, quantity => quantity.ToUnit(CompressibilityUnit.InverseMegapascal));
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InversePascal, CompressibilityUnit.InverseMillibar, quantity => quantity.ToUnit(CompressibilityUnit.InverseMillibar));
-            unitConverter.SetConversionFunction<Compressibility>(CompressibilityUnit.InversePascal, CompressibilityUnit.InversePoundForcePerSquareInch, quantity => quantity.ToUnit(CompressibilityUnit.InversePoundForcePerSquareInch));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -322,7 +305,7 @@ public static string GetAbbreviation(CompressibilityUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseAtmosphere"/>.
         /// </summary>
-        public static Compressibility FromInverseAtmospheres(double value)
+        public static Compressibility FromInverseAtmospheres(QuantityValue value)
         {
             return new Compressibility(value, CompressibilityUnit.InverseAtmosphere);
         }
@@ -330,7 +313,7 @@ public static Compressibility FromInverseAtmospheres(double value)
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseBar"/>.
         /// </summary>
-        public static Compressibility FromInverseBars(double value)
+        public static Compressibility FromInverseBars(QuantityValue value)
         {
             return new Compressibility(value, CompressibilityUnit.InverseBar);
         }
@@ -338,7 +321,7 @@ public static Compressibility FromInverseBars(double value)
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseKilopascal"/>.
         /// </summary>
-        public static Compressibility FromInverseKilopascals(double value)
+        public static Compressibility FromInverseKilopascals(QuantityValue value)
         {
             return new Compressibility(value, CompressibilityUnit.InverseKilopascal);
         }
@@ -346,7 +329,7 @@ public static Compressibility FromInverseKilopascals(double value)
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseMegapascal"/>.
         /// </summary>
-        public static Compressibility FromInverseMegapascals(double value)
+        public static Compressibility FromInverseMegapascals(QuantityValue value)
         {
             return new Compressibility(value, CompressibilityUnit.InverseMegapascal);
         }
@@ -354,7 +337,7 @@ public static Compressibility FromInverseMegapascals(double value)
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseMillibar"/>.
         /// </summary>
-        public static Compressibility FromInverseMillibars(double value)
+        public static Compressibility FromInverseMillibars(QuantityValue value)
         {
             return new Compressibility(value, CompressibilityUnit.InverseMillibar);
         }
@@ -362,7 +345,7 @@ public static Compressibility FromInverseMillibars(double value)
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InversePascal"/>.
         /// </summary>
-        public static Compressibility FromInversePascals(double value)
+        public static Compressibility FromInversePascals(QuantityValue value)
         {
             return new Compressibility(value, CompressibilityUnit.InversePascal);
         }
@@ -370,7 +353,7 @@ public static Compressibility FromInversePascals(double value)
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InversePoundForcePerSquareInch"/>.
         /// </summary>
-        public static Compressibility FromInversePoundsForcePerSquareInch(double value)
+        public static Compressibility FromInversePoundsForcePerSquareInch(QuantityValue value)
         {
             return new Compressibility(value, CompressibilityUnit.InversePoundForcePerSquareInch);
         }
@@ -381,7 +364,7 @@ public static Compressibility FromInversePoundsForcePerSquareInch(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Compressibility unit value.</returns>
-        public static Compressibility From(double value, CompressibilityUnit fromUnit)
+        public static Compressibility From(QuantityValue value, CompressibilityUnit fromUnit)
         {
             return new Compressibility(value, fromUnit);
         }
@@ -442,10 +425,7 @@ public static Compressibility Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Compressibility Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Compressibility, CompressibilityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Compressibility, CompressibilityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -473,11 +453,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Compressibility
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Compressibility result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Compressibility, CompressibilityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Compressibility, CompressibilityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -498,7 +474,7 @@ public static CompressibilityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -509,7 +485,7 @@ public static CompressibilityUnit ParseUnit(string str, IFormatProvider? provide
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.CompressibilityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.CompressibilityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out CompressibilityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -524,7 +500,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Compressibil
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out CompressibilityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -543,137 +519,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Compressibility"/> from adding two <see cref="Compressibility"/>.</summary>
         public static Compressibility operator +(Compressibility left, Compressibility right)
         {
-            return new Compressibility(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Compressibility(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Compressibility"/> from subtracting two <see cref="Compressibility"/>.</summary>
         public static Compressibility operator -(Compressibility left, Compressibility right)
         {
-            return new Compressibility(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Compressibility(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Compressibility"/> from multiplying value and <see cref="Compressibility"/>.</summary>
-        public static Compressibility operator *(double left, Compressibility right)
+        public static Compressibility operator *(QuantityValue left, Compressibility right)
         {
             return new Compressibility(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Compressibility"/> from multiplying value and <see cref="Compressibility"/>.</summary>
-        public static Compressibility operator *(Compressibility left, double right)
+        public static Compressibility operator *(Compressibility left, QuantityValue right)
         {
             return new Compressibility(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Compressibility"/> from dividing <see cref="Compressibility"/> by value.</summary>
-        public static Compressibility operator /(Compressibility left, double right)
+        public static Compressibility operator /(Compressibility left, QuantityValue right)
         {
             return new Compressibility(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Compressibility"/> by <see cref="Compressibility"/>.</summary>
-        public static double operator /(Compressibility left, Compressibility right)
+        public static QuantityValue operator /(Compressibility left, Compressibility right)
         {
             return left.InversePascals / right.InversePascals;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Ratio"/> from <see cref="Compressibility"/> * <see cref="Pressure"/>.</summary>
+        public static Ratio operator *(Compressibility compressibility, Pressure pressure)
+        {
+            return Ratio.FromDecimalFractions(compressibility.InversePascals * pressure.Pascals);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Compressibility left, Compressibility right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Compressibility left, Compressibility right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Compressibility left, Compressibility right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Compressibility left, Compressibility right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Compressibility"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Compressibility other, Compressibility tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Compressibility"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Compressibility)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Compressibility left, Compressibility right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Compressibility"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Compressibility other, Compressibility tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Compressibility"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Compressibility,Compressibility)"/>.
+        ///     See that operator (and <see cref="Equals(Compressibility)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Compressibility left, Compressibility right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Compressibility"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Compressibility other, Compressibility tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Compressibility"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Compressibility"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Compressibility"/>, this method delegates to
+        ///     <see cref="Equals(Compressibility)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Compressibility otherQuantity))
+            if (obj is not Compressibility otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Compressibility"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Compressibility other, Compressibility tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Compressibility"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Compressibility other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Compressibility.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Compressibility), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Compressibility"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Compressibility)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Compressibility otherQuantity)) throw new ArgumentException("Expected type Compressibility.", nameof(obj));
+            if (obj is not Compressibility otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Compressibility>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Compressibility"/> with another <see cref="Compressibility"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Compressibility"/> with another <see cref="Compressibility"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -685,141 +685,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Compressibility other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(CompressibilityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<CompressibilityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Compressibility to another Compressibility with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Compressibility with the specified unit.</returns>
-        public Compressibility ToUnit(CompressibilityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Compressibility"/> to another <see cref="Compressibility"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Compressibility with the specified unit.</returns>
-        public Compressibility ToUnit(CompressibilityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Compressibility), Unit, typeof(Compressibility), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Compressibility)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Compressibility"/> to another <see cref="Compressibility"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Compressibility"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(CompressibilityUnit unit, [NotNullWhen(true)] out Compressibility? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Compressibility? convertedOrNull = (Unit, unit) switch
-            {
-                // CompressibilityUnit -> BaseUnit
-                (CompressibilityUnit.InverseAtmosphere, CompressibilityUnit.InversePascal) => new Compressibility(_value * 101325, CompressibilityUnit.InversePascal),
-                (CompressibilityUnit.InverseBar, CompressibilityUnit.InversePascal) => new Compressibility(_value * 1e5, CompressibilityUnit.InversePascal),
-                (CompressibilityUnit.InverseKilopascal, CompressibilityUnit.InversePascal) => new Compressibility(_value * 1e3, CompressibilityUnit.InversePascal),
-                (CompressibilityUnit.InverseMegapascal, CompressibilityUnit.InversePascal) => new Compressibility(_value * 1e6, CompressibilityUnit.InversePascal),
-                (CompressibilityUnit.InverseMillibar, CompressibilityUnit.InversePascal) => new Compressibility(_value * 100, CompressibilityUnit.InversePascal),
-                (CompressibilityUnit.InversePoundForcePerSquareInch, CompressibilityUnit.InversePascal) => new Compressibility(_value * 6.894757293168361e3, CompressibilityUnit.InversePascal),
-
-                // BaseUnit -> CompressibilityUnit
-                (CompressibilityUnit.InversePascal, CompressibilityUnit.InverseAtmosphere) => new Compressibility(_value / 101325, CompressibilityUnit.InverseAtmosphere),
-                (CompressibilityUnit.InversePascal, CompressibilityUnit.InverseBar) => new Compressibility(_value / 1e5, CompressibilityUnit.InverseBar),
-                (CompressibilityUnit.InversePascal, CompressibilityUnit.InverseKilopascal) => new Compressibility(_value / 1e3, CompressibilityUnit.InverseKilopascal),
-                (CompressibilityUnit.InversePascal, CompressibilityUnit.InverseMegapascal) => new Compressibility(_value / 1e6, CompressibilityUnit.InverseMegapascal),
-                (CompressibilityUnit.InversePascal, CompressibilityUnit.InverseMillibar) => new Compressibility(_value / 100, CompressibilityUnit.InverseMillibar),
-                (CompressibilityUnit.InversePascal, CompressibilityUnit.InversePoundForcePerSquareInch) => new Compressibility(_value / 6.894757293168361e3, CompressibilityUnit.InversePoundForcePerSquareInch),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not CompressibilityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CompressibilityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is CompressibilityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CompressibilityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity<CompressibilityUnit> IQuantity<CompressibilityUnit>.ToUnit(CompressibilityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -833,11 +701,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
index 43aa68b621..c934fdc2d3 100644
--- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     http://en.wikipedia.org/wiki/Density
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Density :
-        IArithmeticQuantity<Density, DensityUnit>,
+        ILinearQuantity<Density, DensityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Density, Density, double>,
+        IDivisionOperators<Density, Density, QuantityValue>,
+        IMultiplyOperators<Density, Length, AreaDensity>,
         IMultiplyOperators<Density, KinematicViscosity, DynamicViscosity>,
         IMultiplyOperators<Density, Area, LinearDensity>,
         IMultiplyOperators<Density, Volume, Mass>,
@@ -62,7 +62,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -112,7 +112,7 @@ public static DensityInfo CreateDefault(Func<IEnumerable<UnitDefinition<DensityU
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Density"/> is [L^-3][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Density"/> is L^-3M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-3, 1, 0, 0, 0, 0, 0);
 
@@ -127,70 +127,178 @@ public static DensityInfo CreateDefault(Func<IEnumerable<UnitDefinition<DensityU
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{DensityUnit}"/> representing the default unit mappings for Density.</returns>
             public static IEnumerable<UnitDefinition<DensityUnit>> GetDefaultMappings()
             {
-                yield return new (DensityUnit.CentigramPerDeciliter, "CentigramPerDeciliter", "CentigramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (DensityUnit.CentigramPerLiter, "CentigramPerLiter", "CentigramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Centigram));
-                yield return new (DensityUnit.CentigramPerMilliliter, "CentigramPerMilliliter", "CentigramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Centigram));
-                yield return new (DensityUnit.DecigramPerDeciliter, "DecigramPerDeciliter", "DecigramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (DensityUnit.DecigramPerLiter, "DecigramPerLiter", "DecigramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Decigram));
-                yield return new (DensityUnit.DecigramPerMilliliter, "DecigramPerMilliliter", "DecigramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Decigram));
-                yield return new (DensityUnit.FemtogramPerDeciliter, "FemtogramPerDeciliter", "FemtogramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (DensityUnit.FemtogramPerLiter, "FemtogramPerLiter", "FemtogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Femtogram));
-                yield return new (DensityUnit.FemtogramPerMilliliter, "FemtogramPerMilliliter", "FemtogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Femtogram));
-                yield return new (DensityUnit.GramPerCubicCentimeter, "GramPerCubicCentimeter", "GramsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram));
-                yield return new (DensityUnit.GramPerCubicFoot, "GramPerCubicFoot", "GramsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Gram));
-                yield return new (DensityUnit.GramPerCubicInch, "GramPerCubicInch", "GramsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Gram));
-                yield return new (DensityUnit.GramPerCubicMeter, "GramPerCubicMeter", "GramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram));
-                yield return new (DensityUnit.GramPerCubicMillimeter, "GramPerCubicMillimeter", "GramsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram));
-                yield return new (DensityUnit.GramPerDeciliter, "GramPerDeciliter", "GramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (DensityUnit.GramPerLiter, "GramPerLiter", "GramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Gram));
-                yield return new (DensityUnit.GramPerMilliliter, "GramPerMilliliter", "GramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram));
-                yield return new (DensityUnit.KilogramPerCubicCentimeter, "KilogramPerCubicCentimeter", "KilogramsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram));
+                yield return new (DensityUnit.CentigramPerDeciliter, "CentigramPerDeciliter", "CentigramsPerDeciliter", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (DensityUnit.CentigramPerLiter, "CentigramPerLiter", "CentigramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Centigram),
+                     100
+                );
+                yield return new (DensityUnit.CentigramPerMilliliter, "CentigramPerMilliliter", "CentigramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Centigram),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (DensityUnit.DecigramPerDeciliter, "DecigramPerDeciliter", "DecigramsPerDeciliter", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (DensityUnit.DecigramPerLiter, "DecigramPerLiter", "DecigramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Decigram),
+                     10
+                );
+                yield return new (DensityUnit.DecigramPerMilliliter, "DecigramPerMilliliter", "DecigramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Decigram),
+                     new QuantityValue(1, 100)
+                );
+                yield return new (DensityUnit.FemtogramPerDeciliter, "FemtogramPerDeciliter", "FemtogramsPerDeciliter", BaseUnits.Undefined,
+                     100000000000000
+                );
+                yield return new (DensityUnit.FemtogramPerLiter, "FemtogramPerLiter", "FemtogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Femtogram),
+                     1000000000000000
+                );
+                yield return new (DensityUnit.FemtogramPerMilliliter, "FemtogramPerMilliliter", "FemtogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Femtogram),
+                     1000000000000
+                );
+                yield return new (DensityUnit.GramPerCubicCentimeter, "GramPerCubicCentimeter", "GramsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (DensityUnit.GramPerCubicFoot, "GramPerCubicFoot", "GramsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Gram),
+                     new QuantityValue(55306341, 1953125)
+                );
+                yield return new (DensityUnit.GramPerCubicInch, "GramPerCubicInch", "GramsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Gram),
+                     new QuantityValue(2048383, 125000000)
+                );
+                yield return new (DensityUnit.GramPerCubicMeter, "GramPerCubicMeter", "GramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram),
+                     1000
+                );
+                yield return new (DensityUnit.GramPerCubicMillimeter, "GramPerCubicMillimeter", "GramsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (DensityUnit.GramPerDeciliter, "GramPerDeciliter", "GramsPerDeciliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (DensityUnit.GramPerLiter, "GramPerLiter", "GramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Gram),
+                     1
+                );
+                yield return new (DensityUnit.GramPerMilliliter, "GramPerMilliliter", "GramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (DensityUnit.KilogramPerCubicCentimeter, "KilogramPerCubicCentimeter", "KilogramsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram),
+                     new QuantityValue(1, 1000000)
+                );
                 yield return new (DensityUnit.KilogramPerCubicMeter, "KilogramPerCubicMeter", "KilogramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram));
-                yield return new (DensityUnit.KilogramPerCubicMillimeter, "KilogramPerCubicMillimeter", "KilogramsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram));
-                yield return new (DensityUnit.KilogramPerLiter, "KilogramPerLiter", "KilogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram));
-                yield return new (DensityUnit.KilopoundPerCubicFoot, "KilopoundPerCubicFoot", "KilopoundsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Kilopound));
-                yield return new (DensityUnit.KilopoundPerCubicInch, "KilopoundPerCubicInch", "KilopoundsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Kilopound));
-                yield return new (DensityUnit.KilopoundPerCubicYard, "KilopoundPerCubicYard", "KilopoundsPerCubicYard", new BaseUnits(length: LengthUnit.Yard, mass: MassUnit.Kilopound));
-                yield return new (DensityUnit.MicrogramPerCubicMeter, "MicrogramPerCubicMeter", "MicrogramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram));
-                yield return new (DensityUnit.MicrogramPerDeciliter, "MicrogramPerDeciliter", "MicrogramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (DensityUnit.MicrogramPerLiter, "MicrogramPerLiter", "MicrogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Microgram));
-                yield return new (DensityUnit.MicrogramPerMilliliter, "MicrogramPerMilliliter", "MicrogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Microgram));
-                yield return new (DensityUnit.MilligramPerCubicMeter, "MilligramPerCubicMeter", "MilligramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram));
-                yield return new (DensityUnit.MilligramPerDeciliter, "MilligramPerDeciliter", "MilligramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (DensityUnit.MilligramPerLiter, "MilligramPerLiter", "MilligramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Milligram));
-                yield return new (DensityUnit.MilligramPerMilliliter, "MilligramPerMilliliter", "MilligramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Milligram));
-                yield return new (DensityUnit.NanogramPerDeciliter, "NanogramPerDeciliter", "NanogramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (DensityUnit.NanogramPerLiter, "NanogramPerLiter", "NanogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Nanogram));
-                yield return new (DensityUnit.NanogramPerMilliliter, "NanogramPerMilliliter", "NanogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Nanogram));
-                yield return new (DensityUnit.PicogramPerDeciliter, "PicogramPerDeciliter", "PicogramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (DensityUnit.PicogramPerLiter, "PicogramPerLiter", "PicogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Picogram));
-                yield return new (DensityUnit.PicogramPerMilliliter, "PicogramPerMilliliter", "PicogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Picogram));
-                yield return new (DensityUnit.PoundPerCubicCentimeter, "PoundPerCubicCentimeter", "PoundsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Pound));
-                yield return new (DensityUnit.PoundPerCubicFoot, "PoundPerCubicFoot", "PoundsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound));
-                yield return new (DensityUnit.PoundPerCubicInch, "PoundPerCubicInch", "PoundsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound));
-                yield return new (DensityUnit.PoundPerCubicMeter, "PoundPerCubicMeter", "PoundsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Pound));
-                yield return new (DensityUnit.PoundPerCubicMillimeter, "PoundPerCubicMillimeter", "PoundsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Pound));
-                yield return new (DensityUnit.PoundPerCubicYard, "PoundPerCubicYard", "PoundsPerCubicYard", new BaseUnits(length: LengthUnit.Yard, mass: MassUnit.Pound));
-                yield return new (DensityUnit.PoundPerImperialGallon, "PoundPerImperialGallon", "PoundsPerImperialGallon", BaseUnits.Undefined);
-                yield return new (DensityUnit.PoundPerUSGallon, "PoundPerUSGallon", "PoundsPerUSGallon", BaseUnits.Undefined);
-                yield return new (DensityUnit.SlugPerCubicCentimeter, "SlugPerCubicCentimeter", "SlugsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Slug));
-                yield return new (DensityUnit.SlugPerCubicFoot, "SlugPerCubicFoot", "SlugsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Slug));
-                yield return new (DensityUnit.SlugPerCubicInch, "SlugPerCubicInch", "SlugsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Slug));
-                yield return new (DensityUnit.SlugPerCubicMeter, "SlugPerCubicMeter", "SlugsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Slug));
-                yield return new (DensityUnit.SlugPerCubicMillimeter, "SlugPerCubicMillimeter", "SlugsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Slug));
-                yield return new (DensityUnit.TonnePerCubicCentimeter, "TonnePerCubicCentimeter", "TonnesPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Tonne));
-                yield return new (DensityUnit.TonnePerCubicFoot, "TonnePerCubicFoot", "TonnesPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Tonne));
-                yield return new (DensityUnit.TonnePerCubicInch, "TonnePerCubicInch", "TonnesPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Tonne));
-                yield return new (DensityUnit.TonnePerCubicMeter, "TonnePerCubicMeter", "TonnesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Tonne));
-                yield return new (DensityUnit.TonnePerCubicMillimeter, "TonnePerCubicMillimeter", "TonnesPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Tonne));
+                yield return new (DensityUnit.KilogramPerCubicMillimeter, "KilogramPerCubicMillimeter", "KilogramsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (DensityUnit.KilogramPerLiter, "KilogramPerLiter", "KilogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (DensityUnit.KilopoundPerCubicFoot, "KilopoundPerCubicFoot", "KilopoundsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Kilopound),
+                     new QuantityValue(221225364, 3543690390625)
+                );
+                yield return new (DensityUnit.KilopoundPerCubicInch, "KilopoundPerCubicInch", "KilopoundsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Kilopound),
+                     new QuantityValue(2048383, 56699046250000)
+                );
+                yield return new (DensityUnit.KilopoundPerCubicYard, "KilopoundPerCubicYard", "KilopoundsPerCubicYard", new BaseUnits(length: LengthUnit.Yard, mass: MassUnit.Kilopound),
+                     new QuantityValue(5973084828, 3543690390625)
+                );
+                yield return new (DensityUnit.MicrogramPerCubicMeter, "MicrogramPerCubicMeter", "MicrogramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram),
+                     1000000000
+                );
+                yield return new (DensityUnit.MicrogramPerDeciliter, "MicrogramPerDeciliter", "MicrogramsPerDeciliter", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (DensityUnit.MicrogramPerLiter, "MicrogramPerLiter", "MicrogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Microgram),
+                     1000000
+                );
+                yield return new (DensityUnit.MicrogramPerMilliliter, "MicrogramPerMilliliter", "MicrogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Microgram),
+                     1000
+                );
+                yield return new (DensityUnit.MilligramPerCubicMeter, "MilligramPerCubicMeter", "MilligramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram),
+                     1000000
+                );
+                yield return new (DensityUnit.MilligramPerDeciliter, "MilligramPerDeciliter", "MilligramsPerDeciliter", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (DensityUnit.MilligramPerLiter, "MilligramPerLiter", "MilligramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Milligram),
+                     1000
+                );
+                yield return new (DensityUnit.MilligramPerMilliliter, "MilligramPerMilliliter", "MilligramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Milligram),
+                     1
+                );
+                yield return new (DensityUnit.NanogramPerDeciliter, "NanogramPerDeciliter", "NanogramsPerDeciliter", BaseUnits.Undefined,
+                     100000000
+                );
+                yield return new (DensityUnit.NanogramPerLiter, "NanogramPerLiter", "NanogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Nanogram),
+                     1000000000
+                );
+                yield return new (DensityUnit.NanogramPerMilliliter, "NanogramPerMilliliter", "NanogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Nanogram),
+                     1000000
+                );
+                yield return new (DensityUnit.PicogramPerDeciliter, "PicogramPerDeciliter", "PicogramsPerDeciliter", BaseUnits.Undefined,
+                     100000000000
+                );
+                yield return new (DensityUnit.PicogramPerLiter, "PicogramPerLiter", "PicogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Picogram),
+                     1000000000000
+                );
+                yield return new (DensityUnit.PicogramPerMilliliter, "PicogramPerMilliliter", "PicogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Picogram),
+                     1000000000
+                );
+                yield return new (DensityUnit.PoundPerCubicCentimeter, "PoundPerCubicCentimeter", "PoundsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Pound),
+                     new QuantityValue(100, 45359237)
+                );
+                yield return new (DensityUnit.PoundPerCubicFoot, "PoundPerCubicFoot", "PoundsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound),
+                     new QuantityValue(1769802912, 28349523125)
+                );
+                yield return new (DensityUnit.PoundPerCubicInch, "PoundPerCubicInch", "PoundsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound),
+                     new QuantityValue(2048383, 56699046250)
+                );
+                yield return new (DensityUnit.PoundPerCubicMeter, "PoundPerCubicMeter", "PoundsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Pound),
+                     new QuantityValue(100000000, 45359237)
+                );
+                yield return new (DensityUnit.PoundPerCubicMillimeter, "PoundPerCubicMillimeter", "PoundsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Pound),
+                     new QuantityValue(1, 453592370)
+                );
+                yield return new (DensityUnit.PoundPerCubicYard, "PoundPerCubicYard", "PoundsPerCubicYard", new BaseUnits(length: LengthUnit.Yard, mass: MassUnit.Pound),
+                     new QuantityValue(47784678624, 28349523125)
+                );
+                yield return new (DensityUnit.PoundPerImperialGallon, "PoundPerImperialGallon", "PoundsPerImperialGallon", BaseUnits.Undefined,
+                     new QuantityValue(454609, 45359237)
+                );
+                yield return new (DensityUnit.PoundPerUSGallon, "PoundPerUSGallon", "PoundsPerUSGallon", BaseUnits.Undefined,
+                     new QuantityValue(6145149, 736351250)
+                );
+                yield return new (DensityUnit.SlugPerCubicCentimeter, "SlugPerCubicCentimeter", "SlugsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Slug),
+                     new QuantityValue(609600, 8896443230521)
+                );
+                yield return new (DensityUnit.SlugPerCubicFoot, "SlugPerCubicFoot", "SlugsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Slug),
+                     new QuantityValue(10788718551552, 5560277019075625)
+                );
+                yield return new (DensityUnit.SlugPerCubicInch, "SlugPerCubicInch", "SlugsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Slug),
+                     new QuantityValue(6243471384, 5560277019075625)
+                );
+                yield return new (DensityUnit.SlugPerCubicMeter, "SlugPerCubicMeter", "SlugsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Slug),
+                     new QuantityValue(609600000000, 8896443230521)
+                );
+                yield return new (DensityUnit.SlugPerCubicMillimeter, "SlugPerCubicMillimeter", "SlugsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Slug),
+                     new QuantityValue(3048, 44482216152605)
+                );
+                yield return new (DensityUnit.TonnePerCubicCentimeter, "TonnePerCubicCentimeter", "TonnesPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Tonne),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (DensityUnit.TonnePerCubicFoot, "TonnePerCubicFoot", "TonnesPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Tonne),
+                     new QuantityValue(55306341, 1953125000000)
+                );
+                yield return new (DensityUnit.TonnePerCubicInch, "TonnePerCubicInch", "TonnesPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Tonne),
+                     new QuantityValue(2048383, 125000000000000)
+                );
+                yield return new (DensityUnit.TonnePerCubicMeter, "TonnePerCubicMeter", "TonnesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Tonne),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (DensityUnit.TonnePerCubicMillimeter, "TonnePerCubicMillimeter", "TonnesPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Tonne),
+                     new QuantityValue(1, 1000000000000)
+                );
             }
         }
 
         static Density()
         {
-            Info = DensityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(DensityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -198,7 +306,7 @@ static Density()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Density(double value, DensityUnit unit)
+        public Density(QuantityValue value, DensityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -212,7 +320,7 @@ public Density(double value, DensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Density(double value, UnitSystem unitSystem)
+        public Density(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -223,7 +331,8 @@ public Density(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Density" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Density, DensityUnit> Info { get; }
@@ -252,10 +361,8 @@ public Density(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public DensityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -289,413 +396,289 @@ public Density(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.CentigramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.CentigramPerDeciliter"/>
         /// </summary>
-        public double CentigramsPerDeciliter => As(DensityUnit.CentigramPerDeciliter);
+        public QuantityValue CentigramsPerDeciliter => this.As(DensityUnit.CentigramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.CentigramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.CentigramPerLiter"/>
         /// </summary>
-        public double CentigramsPerLiter => As(DensityUnit.CentigramPerLiter);
+        public QuantityValue CentigramsPerLiter => this.As(DensityUnit.CentigramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.CentigramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.CentigramPerMilliliter"/>
         /// </summary>
-        public double CentigramsPerMilliliter => As(DensityUnit.CentigramPerMilliliter);
+        public QuantityValue CentigramsPerMilliliter => this.As(DensityUnit.CentigramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.DecigramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.DecigramPerDeciliter"/>
         /// </summary>
-        public double DecigramsPerDeciliter => As(DensityUnit.DecigramPerDeciliter);
+        public QuantityValue DecigramsPerDeciliter => this.As(DensityUnit.DecigramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.DecigramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.DecigramPerLiter"/>
         /// </summary>
-        public double DecigramsPerLiter => As(DensityUnit.DecigramPerLiter);
+        public QuantityValue DecigramsPerLiter => this.As(DensityUnit.DecigramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.DecigramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.DecigramPerMilliliter"/>
         /// </summary>
-        public double DecigramsPerMilliliter => As(DensityUnit.DecigramPerMilliliter);
+        public QuantityValue DecigramsPerMilliliter => this.As(DensityUnit.DecigramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.FemtogramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.FemtogramPerDeciliter"/>
         /// </summary>
-        public double FemtogramsPerDeciliter => As(DensityUnit.FemtogramPerDeciliter);
+        public QuantityValue FemtogramsPerDeciliter => this.As(DensityUnit.FemtogramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.FemtogramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.FemtogramPerLiter"/>
         /// </summary>
-        public double FemtogramsPerLiter => As(DensityUnit.FemtogramPerLiter);
+        public QuantityValue FemtogramsPerLiter => this.As(DensityUnit.FemtogramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.FemtogramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.FemtogramPerMilliliter"/>
         /// </summary>
-        public double FemtogramsPerMilliliter => As(DensityUnit.FemtogramPerMilliliter);
+        public QuantityValue FemtogramsPerMilliliter => this.As(DensityUnit.FemtogramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicCentimeter"/>
         /// </summary>
-        public double GramsPerCubicCentimeter => As(DensityUnit.GramPerCubicCentimeter);
+        public QuantityValue GramsPerCubicCentimeter => this.As(DensityUnit.GramPerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicFoot"/>
         /// </summary>
-        public double GramsPerCubicFoot => As(DensityUnit.GramPerCubicFoot);
+        public QuantityValue GramsPerCubicFoot => this.As(DensityUnit.GramPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicInch"/>
         /// </summary>
-        public double GramsPerCubicInch => As(DensityUnit.GramPerCubicInch);
+        public QuantityValue GramsPerCubicInch => this.As(DensityUnit.GramPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicMeter"/>
         /// </summary>
-        public double GramsPerCubicMeter => As(DensityUnit.GramPerCubicMeter);
+        public QuantityValue GramsPerCubicMeter => this.As(DensityUnit.GramPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.GramPerCubicMillimeter"/>
         /// </summary>
-        public double GramsPerCubicMillimeter => As(DensityUnit.GramPerCubicMillimeter);
+        public QuantityValue GramsPerCubicMillimeter => this.As(DensityUnit.GramPerCubicMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.GramPerDeciliter"/>
         /// </summary>
-        public double GramsPerDeciliter => As(DensityUnit.GramPerDeciliter);
+        public QuantityValue GramsPerDeciliter => this.As(DensityUnit.GramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.GramPerLiter"/>
         /// </summary>
-        public double GramsPerLiter => As(DensityUnit.GramPerLiter);
+        public QuantityValue GramsPerLiter => this.As(DensityUnit.GramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.GramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.GramPerMilliliter"/>
         /// </summary>
-        public double GramsPerMilliliter => As(DensityUnit.GramPerMilliliter);
+        public QuantityValue GramsPerMilliliter => this.As(DensityUnit.GramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerCubicCentimeter"/>
         /// </summary>
-        public double KilogramsPerCubicCentimeter => As(DensityUnit.KilogramPerCubicCentimeter);
+        public QuantityValue KilogramsPerCubicCentimeter => this.As(DensityUnit.KilogramPerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerCubicMeter"/>
         /// </summary>
-        public double KilogramsPerCubicMeter => As(DensityUnit.KilogramPerCubicMeter);
+        public QuantityValue KilogramsPerCubicMeter => this.As(DensityUnit.KilogramPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerCubicMillimeter"/>
         /// </summary>
-        public double KilogramsPerCubicMillimeter => As(DensityUnit.KilogramPerCubicMillimeter);
+        public QuantityValue KilogramsPerCubicMillimeter => this.As(DensityUnit.KilogramPerCubicMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.KilogramPerLiter"/>
         /// </summary>
-        public double KilogramsPerLiter => As(DensityUnit.KilogramPerLiter);
+        public QuantityValue KilogramsPerLiter => this.As(DensityUnit.KilogramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilopoundPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.KilopoundPerCubicFoot"/>
         /// </summary>
-        public double KilopoundsPerCubicFoot => As(DensityUnit.KilopoundPerCubicFoot);
+        public QuantityValue KilopoundsPerCubicFoot => this.As(DensityUnit.KilopoundPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilopoundPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.KilopoundPerCubicInch"/>
         /// </summary>
-        public double KilopoundsPerCubicInch => As(DensityUnit.KilopoundPerCubicInch);
+        public QuantityValue KilopoundsPerCubicInch => this.As(DensityUnit.KilopoundPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.KilopoundPerCubicYard"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.KilopoundPerCubicYard"/>
         /// </summary>
-        public double KilopoundsPerCubicYard => As(DensityUnit.KilopoundPerCubicYard);
+        public QuantityValue KilopoundsPerCubicYard => this.As(DensityUnit.KilopoundPerCubicYard);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerCubicMeter"/>
         /// </summary>
-        public double MicrogramsPerCubicMeter => As(DensityUnit.MicrogramPerCubicMeter);
+        public QuantityValue MicrogramsPerCubicMeter => this.As(DensityUnit.MicrogramPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerDeciliter"/>
         /// </summary>
-        public double MicrogramsPerDeciliter => As(DensityUnit.MicrogramPerDeciliter);
+        public QuantityValue MicrogramsPerDeciliter => this.As(DensityUnit.MicrogramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerLiter"/>
         /// </summary>
-        public double MicrogramsPerLiter => As(DensityUnit.MicrogramPerLiter);
+        public QuantityValue MicrogramsPerLiter => this.As(DensityUnit.MicrogramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.MicrogramPerMilliliter"/>
         /// </summary>
-        public double MicrogramsPerMilliliter => As(DensityUnit.MicrogramPerMilliliter);
+        public QuantityValue MicrogramsPerMilliliter => this.As(DensityUnit.MicrogramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerCubicMeter"/>
         /// </summary>
-        public double MilligramsPerCubicMeter => As(DensityUnit.MilligramPerCubicMeter);
+        public QuantityValue MilligramsPerCubicMeter => this.As(DensityUnit.MilligramPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerDeciliter"/>
         /// </summary>
-        public double MilligramsPerDeciliter => As(DensityUnit.MilligramPerDeciliter);
+        public QuantityValue MilligramsPerDeciliter => this.As(DensityUnit.MilligramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerLiter"/>
         /// </summary>
-        public double MilligramsPerLiter => As(DensityUnit.MilligramPerLiter);
+        public QuantityValue MilligramsPerLiter => this.As(DensityUnit.MilligramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.MilligramPerMilliliter"/>
         /// </summary>
-        public double MilligramsPerMilliliter => As(DensityUnit.MilligramPerMilliliter);
+        public QuantityValue MilligramsPerMilliliter => this.As(DensityUnit.MilligramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.NanogramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.NanogramPerDeciliter"/>
         /// </summary>
-        public double NanogramsPerDeciliter => As(DensityUnit.NanogramPerDeciliter);
+        public QuantityValue NanogramsPerDeciliter => this.As(DensityUnit.NanogramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.NanogramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.NanogramPerLiter"/>
         /// </summary>
-        public double NanogramsPerLiter => As(DensityUnit.NanogramPerLiter);
+        public QuantityValue NanogramsPerLiter => this.As(DensityUnit.NanogramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.NanogramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.NanogramPerMilliliter"/>
         /// </summary>
-        public double NanogramsPerMilliliter => As(DensityUnit.NanogramPerMilliliter);
+        public QuantityValue NanogramsPerMilliliter => this.As(DensityUnit.NanogramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PicogramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PicogramPerDeciliter"/>
         /// </summary>
-        public double PicogramsPerDeciliter => As(DensityUnit.PicogramPerDeciliter);
+        public QuantityValue PicogramsPerDeciliter => this.As(DensityUnit.PicogramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PicogramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PicogramPerLiter"/>
         /// </summary>
-        public double PicogramsPerLiter => As(DensityUnit.PicogramPerLiter);
+        public QuantityValue PicogramsPerLiter => this.As(DensityUnit.PicogramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PicogramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PicogramPerMilliliter"/>
         /// </summary>
-        public double PicogramsPerMilliliter => As(DensityUnit.PicogramPerMilliliter);
+        public QuantityValue PicogramsPerMilliliter => this.As(DensityUnit.PicogramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicCentimeter"/>
         /// </summary>
-        public double PoundsPerCubicCentimeter => As(DensityUnit.PoundPerCubicCentimeter);
+        public QuantityValue PoundsPerCubicCentimeter => this.As(DensityUnit.PoundPerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicFoot"/>
         /// </summary>
-        public double PoundsPerCubicFoot => As(DensityUnit.PoundPerCubicFoot);
+        public QuantityValue PoundsPerCubicFoot => this.As(DensityUnit.PoundPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicInch"/>
         /// </summary>
-        public double PoundsPerCubicInch => As(DensityUnit.PoundPerCubicInch);
+        public QuantityValue PoundsPerCubicInch => this.As(DensityUnit.PoundPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicMeter"/>
         /// </summary>
-        public double PoundsPerCubicMeter => As(DensityUnit.PoundPerCubicMeter);
+        public QuantityValue PoundsPerCubicMeter => this.As(DensityUnit.PoundPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicMillimeter"/>
         /// </summary>
-        public double PoundsPerCubicMillimeter => As(DensityUnit.PoundPerCubicMillimeter);
+        public QuantityValue PoundsPerCubicMillimeter => this.As(DensityUnit.PoundPerCubicMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicYard"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PoundPerCubicYard"/>
         /// </summary>
-        public double PoundsPerCubicYard => As(DensityUnit.PoundPerCubicYard);
+        public QuantityValue PoundsPerCubicYard => this.As(DensityUnit.PoundPerCubicYard);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerImperialGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PoundPerImperialGallon"/>
         /// </summary>
-        public double PoundsPerImperialGallon => As(DensityUnit.PoundPerImperialGallon);
+        public QuantityValue PoundsPerImperialGallon => this.As(DensityUnit.PoundPerImperialGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.PoundPerUSGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.PoundPerUSGallon"/>
         /// </summary>
-        public double PoundsPerUSGallon => As(DensityUnit.PoundPerUSGallon);
+        public QuantityValue PoundsPerUSGallon => this.As(DensityUnit.PoundPerUSGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicCentimeter"/>
         /// </summary>
-        public double SlugsPerCubicCentimeter => As(DensityUnit.SlugPerCubicCentimeter);
+        public QuantityValue SlugsPerCubicCentimeter => this.As(DensityUnit.SlugPerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicFoot"/>
         /// </summary>
-        public double SlugsPerCubicFoot => As(DensityUnit.SlugPerCubicFoot);
+        public QuantityValue SlugsPerCubicFoot => this.As(DensityUnit.SlugPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicInch"/>
         /// </summary>
-        public double SlugsPerCubicInch => As(DensityUnit.SlugPerCubicInch);
+        public QuantityValue SlugsPerCubicInch => this.As(DensityUnit.SlugPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicMeter"/>
         /// </summary>
-        public double SlugsPerCubicMeter => As(DensityUnit.SlugPerCubicMeter);
+        public QuantityValue SlugsPerCubicMeter => this.As(DensityUnit.SlugPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.SlugPerCubicMillimeter"/>
         /// </summary>
-        public double SlugsPerCubicMillimeter => As(DensityUnit.SlugPerCubicMillimeter);
+        public QuantityValue SlugsPerCubicMillimeter => this.As(DensityUnit.SlugPerCubicMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicCentimeter"/>
         /// </summary>
-        public double TonnesPerCubicCentimeter => As(DensityUnit.TonnePerCubicCentimeter);
+        public QuantityValue TonnesPerCubicCentimeter => this.As(DensityUnit.TonnePerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicFoot"/>
         /// </summary>
-        public double TonnesPerCubicFoot => As(DensityUnit.TonnePerCubicFoot);
+        public QuantityValue TonnesPerCubicFoot => this.As(DensityUnit.TonnePerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicInch"/>
         /// </summary>
-        public double TonnesPerCubicInch => As(DensityUnit.TonnePerCubicInch);
+        public QuantityValue TonnesPerCubicInch => this.As(DensityUnit.TonnePerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicMeter"/>
         /// </summary>
-        public double TonnesPerCubicMeter => As(DensityUnit.TonnePerCubicMeter);
+        public QuantityValue TonnesPerCubicMeter => this.As(DensityUnit.TonnePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DensityUnit.TonnePerCubicMillimeter"/>
         /// </summary>
-        public double TonnesPerCubicMillimeter => As(DensityUnit.TonnePerCubicMillimeter);
+        public QuantityValue TonnesPerCubicMillimeter => this.As(DensityUnit.TonnePerCubicMillimeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: DensityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Density>(DensityUnit.CentigramPerDeciliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.CentigramPerLiter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.CentigramPerMilliliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.DecigramPerDeciliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.DecigramPerLiter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.DecigramPerMilliliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.FemtogramPerDeciliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.FemtogramPerLiter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.FemtogramPerMilliliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerCubicCentimeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerCubicFoot, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerCubicInch, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerCubicMeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerCubicMillimeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerDeciliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerLiter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.GramPerMilliliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicCentimeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMillimeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerLiter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilopoundPerCubicFoot, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilopoundPerCubicInch, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilopoundPerCubicYard, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MicrogramPerCubicMeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MicrogramPerDeciliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MicrogramPerLiter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MicrogramPerMilliliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MilligramPerCubicMeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MilligramPerDeciliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MilligramPerLiter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.MilligramPerMilliliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.NanogramPerDeciliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.NanogramPerLiter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.NanogramPerMilliliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PicogramPerDeciliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PicogramPerLiter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PicogramPerMilliliter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerCubicCentimeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerCubicFoot, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerCubicInch, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerCubicMeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerCubicMillimeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerCubicYard, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerImperialGallon, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.PoundPerUSGallon, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.SlugPerCubicCentimeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.SlugPerCubicFoot, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.SlugPerCubicInch, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.SlugPerCubicMeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.SlugPerCubicMillimeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.TonnePerCubicCentimeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.TonnePerCubicFoot, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.TonnePerCubicInch, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.TonnePerCubicMeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.TonnePerCubicMillimeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerCubicMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> DensityUnit
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.CentigramPerDeciliter, quantity => quantity.ToUnit(DensityUnit.CentigramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.CentigramPerLiter, quantity => quantity.ToUnit(DensityUnit.CentigramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.CentigramPerMilliliter, quantity => quantity.ToUnit(DensityUnit.CentigramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.DecigramPerDeciliter, quantity => quantity.ToUnit(DensityUnit.DecigramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.DecigramPerLiter, quantity => quantity.ToUnit(DensityUnit.DecigramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.DecigramPerMilliliter, quantity => quantity.ToUnit(DensityUnit.DecigramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.FemtogramPerDeciliter, quantity => quantity.ToUnit(DensityUnit.FemtogramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.FemtogramPerLiter, quantity => quantity.ToUnit(DensityUnit.FemtogramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.FemtogramPerMilliliter, quantity => quantity.ToUnit(DensityUnit.FemtogramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerCubicCentimeter, quantity => quantity.ToUnit(DensityUnit.GramPerCubicCentimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerCubicFoot, quantity => quantity.ToUnit(DensityUnit.GramPerCubicFoot));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerCubicInch, quantity => quantity.ToUnit(DensityUnit.GramPerCubicInch));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.GramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerCubicMillimeter, quantity => quantity.ToUnit(DensityUnit.GramPerCubicMillimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerDeciliter, quantity => quantity.ToUnit(DensityUnit.GramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerLiter, quantity => quantity.ToUnit(DensityUnit.GramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerMilliliter, quantity => quantity.ToUnit(DensityUnit.GramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerCubicCentimeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicCentimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerCubicMillimeter, quantity => quantity.ToUnit(DensityUnit.KilogramPerCubicMillimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerLiter, quantity => quantity.ToUnit(DensityUnit.KilogramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.KilopoundPerCubicFoot, quantity => quantity.ToUnit(DensityUnit.KilopoundPerCubicFoot));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.KilopoundPerCubicInch, quantity => quantity.ToUnit(DensityUnit.KilopoundPerCubicInch));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.KilopoundPerCubicYard, quantity => quantity.ToUnit(DensityUnit.KilopoundPerCubicYard));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.MicrogramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.MicrogramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.MicrogramPerDeciliter, quantity => quantity.ToUnit(DensityUnit.MicrogramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.MicrogramPerLiter, quantity => quantity.ToUnit(DensityUnit.MicrogramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.MicrogramPerMilliliter, quantity => quantity.ToUnit(DensityUnit.MicrogramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.MilligramPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.MilligramPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.MilligramPerDeciliter, quantity => quantity.ToUnit(DensityUnit.MilligramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.MilligramPerLiter, quantity => quantity.ToUnit(DensityUnit.MilligramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.MilligramPerMilliliter, quantity => quantity.ToUnit(DensityUnit.MilligramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.NanogramPerDeciliter, quantity => quantity.ToUnit(DensityUnit.NanogramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.NanogramPerLiter, quantity => quantity.ToUnit(DensityUnit.NanogramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.NanogramPerMilliliter, quantity => quantity.ToUnit(DensityUnit.NanogramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PicogramPerDeciliter, quantity => quantity.ToUnit(DensityUnit.PicogramPerDeciliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PicogramPerLiter, quantity => quantity.ToUnit(DensityUnit.PicogramPerLiter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PicogramPerMilliliter, quantity => quantity.ToUnit(DensityUnit.PicogramPerMilliliter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicCentimeter, quantity => quantity.ToUnit(DensityUnit.PoundPerCubicCentimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicFoot, quantity => quantity.ToUnit(DensityUnit.PoundPerCubicFoot));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicInch, quantity => quantity.ToUnit(DensityUnit.PoundPerCubicInch));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.PoundPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicMillimeter, quantity => quantity.ToUnit(DensityUnit.PoundPerCubicMillimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicYard, quantity => quantity.ToUnit(DensityUnit.PoundPerCubicYard));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerImperialGallon, quantity => quantity.ToUnit(DensityUnit.PoundPerImperialGallon));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerUSGallon, quantity => quantity.ToUnit(DensityUnit.PoundPerUSGallon));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.SlugPerCubicCentimeter, quantity => quantity.ToUnit(DensityUnit.SlugPerCubicCentimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.SlugPerCubicFoot, quantity => quantity.ToUnit(DensityUnit.SlugPerCubicFoot));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.SlugPerCubicInch, quantity => quantity.ToUnit(DensityUnit.SlugPerCubicInch));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.SlugPerCubicMeter, quantity => quantity.ToUnit(DensityUnit.SlugPerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.SlugPerCubicMillimeter, quantity => quantity.ToUnit(DensityUnit.SlugPerCubicMillimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.TonnePerCubicCentimeter, quantity => quantity.ToUnit(DensityUnit.TonnePerCubicCentimeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.TonnePerCubicFoot, quantity => quantity.ToUnit(DensityUnit.TonnePerCubicFoot));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.TonnePerCubicInch, quantity => quantity.ToUnit(DensityUnit.TonnePerCubicInch));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.TonnePerCubicMeter, quantity => quantity.ToUnit(DensityUnit.TonnePerCubicMeter));
-            unitConverter.SetConversionFunction<Density>(DensityUnit.KilogramPerCubicMeter, DensityUnit.TonnePerCubicMillimeter, quantity => quantity.ToUnit(DensityUnit.TonnePerCubicMillimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -724,7 +707,7 @@ public static string GetAbbreviation(DensityUnit unit, IFormatProvider? provider
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerDeciliter"/>.
         /// </summary>
-        public static Density FromCentigramsPerDeciliter(double value)
+        public static Density FromCentigramsPerDeciliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.CentigramPerDeciliter);
         }
@@ -732,7 +715,7 @@ public static Density FromCentigramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerLiter"/>.
         /// </summary>
-        public static Density FromCentigramsPerLiter(double value)
+        public static Density FromCentigramsPerLiter(QuantityValue value)
         {
             return new Density(value, DensityUnit.CentigramPerLiter);
         }
@@ -740,7 +723,7 @@ public static Density FromCentigramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerMilliliter"/>.
         /// </summary>
-        public static Density FromCentigramsPerMilliliter(double value)
+        public static Density FromCentigramsPerMilliliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.CentigramPerMilliliter);
         }
@@ -748,7 +731,7 @@ public static Density FromCentigramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerDeciliter"/>.
         /// </summary>
-        public static Density FromDecigramsPerDeciliter(double value)
+        public static Density FromDecigramsPerDeciliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.DecigramPerDeciliter);
         }
@@ -756,7 +739,7 @@ public static Density FromDecigramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerLiter"/>.
         /// </summary>
-        public static Density FromDecigramsPerLiter(double value)
+        public static Density FromDecigramsPerLiter(QuantityValue value)
         {
             return new Density(value, DensityUnit.DecigramPerLiter);
         }
@@ -764,7 +747,7 @@ public static Density FromDecigramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerMilliliter"/>.
         /// </summary>
-        public static Density FromDecigramsPerMilliliter(double value)
+        public static Density FromDecigramsPerMilliliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.DecigramPerMilliliter);
         }
@@ -772,7 +755,7 @@ public static Density FromDecigramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerDeciliter"/>.
         /// </summary>
-        public static Density FromFemtogramsPerDeciliter(double value)
+        public static Density FromFemtogramsPerDeciliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.FemtogramPerDeciliter);
         }
@@ -780,7 +763,7 @@ public static Density FromFemtogramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerLiter"/>.
         /// </summary>
-        public static Density FromFemtogramsPerLiter(double value)
+        public static Density FromFemtogramsPerLiter(QuantityValue value)
         {
             return new Density(value, DensityUnit.FemtogramPerLiter);
         }
@@ -788,7 +771,7 @@ public static Density FromFemtogramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerMilliliter"/>.
         /// </summary>
-        public static Density FromFemtogramsPerMilliliter(double value)
+        public static Density FromFemtogramsPerMilliliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.FemtogramPerMilliliter);
         }
@@ -796,7 +779,7 @@ public static Density FromFemtogramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicCentimeter"/>.
         /// </summary>
-        public static Density FromGramsPerCubicCentimeter(double value)
+        public static Density FromGramsPerCubicCentimeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.GramPerCubicCentimeter);
         }
@@ -804,7 +787,7 @@ public static Density FromGramsPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicFoot"/>.
         /// </summary>
-        public static Density FromGramsPerCubicFoot(double value)
+        public static Density FromGramsPerCubicFoot(QuantityValue value)
         {
             return new Density(value, DensityUnit.GramPerCubicFoot);
         }
@@ -812,7 +795,7 @@ public static Density FromGramsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicInch"/>.
         /// </summary>
-        public static Density FromGramsPerCubicInch(double value)
+        public static Density FromGramsPerCubicInch(QuantityValue value)
         {
             return new Density(value, DensityUnit.GramPerCubicInch);
         }
@@ -820,7 +803,7 @@ public static Density FromGramsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicMeter"/>.
         /// </summary>
-        public static Density FromGramsPerCubicMeter(double value)
+        public static Density FromGramsPerCubicMeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.GramPerCubicMeter);
         }
@@ -828,7 +811,7 @@ public static Density FromGramsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicMillimeter"/>.
         /// </summary>
-        public static Density FromGramsPerCubicMillimeter(double value)
+        public static Density FromGramsPerCubicMillimeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.GramPerCubicMillimeter);
         }
@@ -836,7 +819,7 @@ public static Density FromGramsPerCubicMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerDeciliter"/>.
         /// </summary>
-        public static Density FromGramsPerDeciliter(double value)
+        public static Density FromGramsPerDeciliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.GramPerDeciliter);
         }
@@ -844,7 +827,7 @@ public static Density FromGramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerLiter"/>.
         /// </summary>
-        public static Density FromGramsPerLiter(double value)
+        public static Density FromGramsPerLiter(QuantityValue value)
         {
             return new Density(value, DensityUnit.GramPerLiter);
         }
@@ -852,7 +835,7 @@ public static Density FromGramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerMilliliter"/>.
         /// </summary>
-        public static Density FromGramsPerMilliliter(double value)
+        public static Density FromGramsPerMilliliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.GramPerMilliliter);
         }
@@ -860,7 +843,7 @@ public static Density FromGramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicCentimeter"/>.
         /// </summary>
-        public static Density FromKilogramsPerCubicCentimeter(double value)
+        public static Density FromKilogramsPerCubicCentimeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.KilogramPerCubicCentimeter);
         }
@@ -868,7 +851,7 @@ public static Density FromKilogramsPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicMeter"/>.
         /// </summary>
-        public static Density FromKilogramsPerCubicMeter(double value)
+        public static Density FromKilogramsPerCubicMeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.KilogramPerCubicMeter);
         }
@@ -876,7 +859,7 @@ public static Density FromKilogramsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicMillimeter"/>.
         /// </summary>
-        public static Density FromKilogramsPerCubicMillimeter(double value)
+        public static Density FromKilogramsPerCubicMillimeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.KilogramPerCubicMillimeter);
         }
@@ -884,7 +867,7 @@ public static Density FromKilogramsPerCubicMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerLiter"/>.
         /// </summary>
-        public static Density FromKilogramsPerLiter(double value)
+        public static Density FromKilogramsPerLiter(QuantityValue value)
         {
             return new Density(value, DensityUnit.KilogramPerLiter);
         }
@@ -892,7 +875,7 @@ public static Density FromKilogramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicFoot"/>.
         /// </summary>
-        public static Density FromKilopoundsPerCubicFoot(double value)
+        public static Density FromKilopoundsPerCubicFoot(QuantityValue value)
         {
             return new Density(value, DensityUnit.KilopoundPerCubicFoot);
         }
@@ -900,7 +883,7 @@ public static Density FromKilopoundsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicInch"/>.
         /// </summary>
-        public static Density FromKilopoundsPerCubicInch(double value)
+        public static Density FromKilopoundsPerCubicInch(QuantityValue value)
         {
             return new Density(value, DensityUnit.KilopoundPerCubicInch);
         }
@@ -908,7 +891,7 @@ public static Density FromKilopoundsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicYard"/>.
         /// </summary>
-        public static Density FromKilopoundsPerCubicYard(double value)
+        public static Density FromKilopoundsPerCubicYard(QuantityValue value)
         {
             return new Density(value, DensityUnit.KilopoundPerCubicYard);
         }
@@ -916,7 +899,7 @@ public static Density FromKilopoundsPerCubicYard(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerCubicMeter"/>.
         /// </summary>
-        public static Density FromMicrogramsPerCubicMeter(double value)
+        public static Density FromMicrogramsPerCubicMeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.MicrogramPerCubicMeter);
         }
@@ -924,7 +907,7 @@ public static Density FromMicrogramsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerDeciliter"/>.
         /// </summary>
-        public static Density FromMicrogramsPerDeciliter(double value)
+        public static Density FromMicrogramsPerDeciliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.MicrogramPerDeciliter);
         }
@@ -932,7 +915,7 @@ public static Density FromMicrogramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerLiter"/>.
         /// </summary>
-        public static Density FromMicrogramsPerLiter(double value)
+        public static Density FromMicrogramsPerLiter(QuantityValue value)
         {
             return new Density(value, DensityUnit.MicrogramPerLiter);
         }
@@ -940,7 +923,7 @@ public static Density FromMicrogramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerMilliliter"/>.
         /// </summary>
-        public static Density FromMicrogramsPerMilliliter(double value)
+        public static Density FromMicrogramsPerMilliliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.MicrogramPerMilliliter);
         }
@@ -948,7 +931,7 @@ public static Density FromMicrogramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerCubicMeter"/>.
         /// </summary>
-        public static Density FromMilligramsPerCubicMeter(double value)
+        public static Density FromMilligramsPerCubicMeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.MilligramPerCubicMeter);
         }
@@ -956,7 +939,7 @@ public static Density FromMilligramsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerDeciliter"/>.
         /// </summary>
-        public static Density FromMilligramsPerDeciliter(double value)
+        public static Density FromMilligramsPerDeciliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.MilligramPerDeciliter);
         }
@@ -964,7 +947,7 @@ public static Density FromMilligramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerLiter"/>.
         /// </summary>
-        public static Density FromMilligramsPerLiter(double value)
+        public static Density FromMilligramsPerLiter(QuantityValue value)
         {
             return new Density(value, DensityUnit.MilligramPerLiter);
         }
@@ -972,7 +955,7 @@ public static Density FromMilligramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerMilliliter"/>.
         /// </summary>
-        public static Density FromMilligramsPerMilliliter(double value)
+        public static Density FromMilligramsPerMilliliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.MilligramPerMilliliter);
         }
@@ -980,7 +963,7 @@ public static Density FromMilligramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerDeciliter"/>.
         /// </summary>
-        public static Density FromNanogramsPerDeciliter(double value)
+        public static Density FromNanogramsPerDeciliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.NanogramPerDeciliter);
         }
@@ -988,7 +971,7 @@ public static Density FromNanogramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerLiter"/>.
         /// </summary>
-        public static Density FromNanogramsPerLiter(double value)
+        public static Density FromNanogramsPerLiter(QuantityValue value)
         {
             return new Density(value, DensityUnit.NanogramPerLiter);
         }
@@ -996,7 +979,7 @@ public static Density FromNanogramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerMilliliter"/>.
         /// </summary>
-        public static Density FromNanogramsPerMilliliter(double value)
+        public static Density FromNanogramsPerMilliliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.NanogramPerMilliliter);
         }
@@ -1004,7 +987,7 @@ public static Density FromNanogramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerDeciliter"/>.
         /// </summary>
-        public static Density FromPicogramsPerDeciliter(double value)
+        public static Density FromPicogramsPerDeciliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.PicogramPerDeciliter);
         }
@@ -1012,7 +995,7 @@ public static Density FromPicogramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerLiter"/>.
         /// </summary>
-        public static Density FromPicogramsPerLiter(double value)
+        public static Density FromPicogramsPerLiter(QuantityValue value)
         {
             return new Density(value, DensityUnit.PicogramPerLiter);
         }
@@ -1020,7 +1003,7 @@ public static Density FromPicogramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerMilliliter"/>.
         /// </summary>
-        public static Density FromPicogramsPerMilliliter(double value)
+        public static Density FromPicogramsPerMilliliter(QuantityValue value)
         {
             return new Density(value, DensityUnit.PicogramPerMilliliter);
         }
@@ -1028,7 +1011,7 @@ public static Density FromPicogramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicCentimeter"/>.
         /// </summary>
-        public static Density FromPoundsPerCubicCentimeter(double value)
+        public static Density FromPoundsPerCubicCentimeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.PoundPerCubicCentimeter);
         }
@@ -1036,7 +1019,7 @@ public static Density FromPoundsPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicFoot"/>.
         /// </summary>
-        public static Density FromPoundsPerCubicFoot(double value)
+        public static Density FromPoundsPerCubicFoot(QuantityValue value)
         {
             return new Density(value, DensityUnit.PoundPerCubicFoot);
         }
@@ -1044,7 +1027,7 @@ public static Density FromPoundsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicInch"/>.
         /// </summary>
-        public static Density FromPoundsPerCubicInch(double value)
+        public static Density FromPoundsPerCubicInch(QuantityValue value)
         {
             return new Density(value, DensityUnit.PoundPerCubicInch);
         }
@@ -1052,7 +1035,7 @@ public static Density FromPoundsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicMeter"/>.
         /// </summary>
-        public static Density FromPoundsPerCubicMeter(double value)
+        public static Density FromPoundsPerCubicMeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.PoundPerCubicMeter);
         }
@@ -1060,7 +1043,7 @@ public static Density FromPoundsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicMillimeter"/>.
         /// </summary>
-        public static Density FromPoundsPerCubicMillimeter(double value)
+        public static Density FromPoundsPerCubicMillimeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.PoundPerCubicMillimeter);
         }
@@ -1068,7 +1051,7 @@ public static Density FromPoundsPerCubicMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicYard"/>.
         /// </summary>
-        public static Density FromPoundsPerCubicYard(double value)
+        public static Density FromPoundsPerCubicYard(QuantityValue value)
         {
             return new Density(value, DensityUnit.PoundPerCubicYard);
         }
@@ -1076,7 +1059,7 @@ public static Density FromPoundsPerCubicYard(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerImperialGallon"/>.
         /// </summary>
-        public static Density FromPoundsPerImperialGallon(double value)
+        public static Density FromPoundsPerImperialGallon(QuantityValue value)
         {
             return new Density(value, DensityUnit.PoundPerImperialGallon);
         }
@@ -1084,7 +1067,7 @@ public static Density FromPoundsPerImperialGallon(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerUSGallon"/>.
         /// </summary>
-        public static Density FromPoundsPerUSGallon(double value)
+        public static Density FromPoundsPerUSGallon(QuantityValue value)
         {
             return new Density(value, DensityUnit.PoundPerUSGallon);
         }
@@ -1092,7 +1075,7 @@ public static Density FromPoundsPerUSGallon(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicCentimeter"/>.
         /// </summary>
-        public static Density FromSlugsPerCubicCentimeter(double value)
+        public static Density FromSlugsPerCubicCentimeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.SlugPerCubicCentimeter);
         }
@@ -1100,7 +1083,7 @@ public static Density FromSlugsPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicFoot"/>.
         /// </summary>
-        public static Density FromSlugsPerCubicFoot(double value)
+        public static Density FromSlugsPerCubicFoot(QuantityValue value)
         {
             return new Density(value, DensityUnit.SlugPerCubicFoot);
         }
@@ -1108,7 +1091,7 @@ public static Density FromSlugsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicInch"/>.
         /// </summary>
-        public static Density FromSlugsPerCubicInch(double value)
+        public static Density FromSlugsPerCubicInch(QuantityValue value)
         {
             return new Density(value, DensityUnit.SlugPerCubicInch);
         }
@@ -1116,7 +1099,7 @@ public static Density FromSlugsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicMeter"/>.
         /// </summary>
-        public static Density FromSlugsPerCubicMeter(double value)
+        public static Density FromSlugsPerCubicMeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.SlugPerCubicMeter);
         }
@@ -1124,7 +1107,7 @@ public static Density FromSlugsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicMillimeter"/>.
         /// </summary>
-        public static Density FromSlugsPerCubicMillimeter(double value)
+        public static Density FromSlugsPerCubicMillimeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.SlugPerCubicMillimeter);
         }
@@ -1132,7 +1115,7 @@ public static Density FromSlugsPerCubicMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicCentimeter"/>.
         /// </summary>
-        public static Density FromTonnesPerCubicCentimeter(double value)
+        public static Density FromTonnesPerCubicCentimeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.TonnePerCubicCentimeter);
         }
@@ -1140,7 +1123,7 @@ public static Density FromTonnesPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicFoot"/>.
         /// </summary>
-        public static Density FromTonnesPerCubicFoot(double value)
+        public static Density FromTonnesPerCubicFoot(QuantityValue value)
         {
             return new Density(value, DensityUnit.TonnePerCubicFoot);
         }
@@ -1148,7 +1131,7 @@ public static Density FromTonnesPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicInch"/>.
         /// </summary>
-        public static Density FromTonnesPerCubicInch(double value)
+        public static Density FromTonnesPerCubicInch(QuantityValue value)
         {
             return new Density(value, DensityUnit.TonnePerCubicInch);
         }
@@ -1156,7 +1139,7 @@ public static Density FromTonnesPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicMeter"/>.
         /// </summary>
-        public static Density FromTonnesPerCubicMeter(double value)
+        public static Density FromTonnesPerCubicMeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.TonnePerCubicMeter);
         }
@@ -1164,7 +1147,7 @@ public static Density FromTonnesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicMillimeter"/>.
         /// </summary>
-        public static Density FromTonnesPerCubicMillimeter(double value)
+        public static Density FromTonnesPerCubicMillimeter(QuantityValue value)
         {
             return new Density(value, DensityUnit.TonnePerCubicMillimeter);
         }
@@ -1175,7 +1158,7 @@ public static Density FromTonnesPerCubicMillimeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Density unit value.</returns>
-        public static Density From(double value, DensityUnit fromUnit)
+        public static Density From(QuantityValue value, DensityUnit fromUnit)
         {
             return new Density(value, fromUnit);
         }
@@ -1236,10 +1219,7 @@ public static Density Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Density Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Density, DensityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Density, DensityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -1267,11 +1247,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Density result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Density result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Density, DensityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Density, DensityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -1292,7 +1268,7 @@ public static DensityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1303,7 +1279,7 @@ public static DensityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.DensityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.DensityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out DensityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1318,7 +1294,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out DensityUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out DensityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1337,35 +1313,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Density"/> from adding two <see cref="Density"/>.</summary>
         public static Density operator +(Density left, Density right)
         {
-            return new Density(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Density(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Density"/> from subtracting two <see cref="Density"/>.</summary>
         public static Density operator -(Density left, Density right)
         {
-            return new Density(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Density(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Density"/> from multiplying value and <see cref="Density"/>.</summary>
-        public static Density operator *(double left, Density right)
+        public static Density operator *(QuantityValue left, Density right)
         {
             return new Density(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Density"/> from multiplying value and <see cref="Density"/>.</summary>
-        public static Density operator *(Density left, double right)
+        public static Density operator *(Density left, QuantityValue right)
         {
             return new Density(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Density"/> from dividing <see cref="Density"/> by value.</summary>
-        public static Density operator /(Density left, double right)
+        public static Density operator /(Density left, QuantityValue right)
         {
             return new Density(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Density"/> by <see cref="Density"/>.</summary>
-        public static double operator /(Density left, Density right)
+        public static QuantityValue operator /(Density left, Density right)
         {
             return left.KilogramsPerCubicMeter / right.KilogramsPerCubicMeter;
         }
@@ -1378,7 +1354,13 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <returns>The corresponding inverse quantity, <see cref="SpecificVolume"/>.</returns>
         public SpecificVolume Inverse()
         {
-            return SpecificVolume.FromCubicMetersPerKilogram(1 / KilogramsPerCubicMeter);
+            return UnitConverter.Default.ConvertTo(Value, Unit, SpecificVolume.Info);
+        }
+
+        /// <summary>Get <see cref="AreaDensity"/> from <see cref="Density"/> * <see cref="Length"/>.</summary>
+        public static AreaDensity operator *(Density density, Length length)
+        {
+            return AreaDensity.FromKilogramsPerSquareMeter(density.KilogramsPerCubicMeter * length.Meters);
         }
 
         /// <summary>Get <see cref="DynamicViscosity"/> from <see cref="Density"/> * <see cref="KinematicViscosity"/>.</summary>
@@ -1430,97 +1412,111 @@ public SpecificVolume Inverse()
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Density left, Density right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Density left, Density right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Density left, Density right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Density left, Density right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Density"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Density other, Density tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Density"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Density)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Density left, Density right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Density"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Density other, Density tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Density"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Density,Density)"/>.
+        ///     See that operator (and <see cref="Equals(Density)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Density left, Density right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Density"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Density other, Density tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Density"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Density"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Density"/>, this method delegates to
+        ///     <see cref="Equals(Density)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Density otherQuantity))
+            if (obj is not Density otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Density"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Density other, Density tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Density"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Density other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Density.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Density), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Density"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Density)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Density otherQuantity)) throw new ArgumentException("Expected type Density.", nameof(obj));
+            if (obj is not Density otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Density>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Density"/> with another <see cref="Density"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Density"/> with another <see cref="Density"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1532,239 +1528,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Density other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(DensityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<DensityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Density to another Density with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Density with the specified unit.</returns>
-        public Density ToUnit(DensityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Density"/> to another <see cref="Density"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Density with the specified unit.</returns>
-        public Density ToUnit(DensityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Density), Unit, typeof(Density), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Density)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Density"/> to another <see cref="Density"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Density"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(DensityUnit unit, [NotNullWhen(true)] out Density? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Density? convertedOrNull = (Unit, unit) switch
-            {
-                // DensityUnit -> BaseUnit
-                (DensityUnit.CentigramPerDeciliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-1) * 1e-2d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.CentigramPerLiter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1) * 1e-2d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.CentigramPerMilliliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-3) * 1e-2d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.DecigramPerDeciliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-1) * 1e-1d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.DecigramPerLiter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1) * 1e-1d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.DecigramPerMilliliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-3) * 1e-1d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.FemtogramPerDeciliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-1) * 1e-15d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.FemtogramPerLiter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1) * 1e-15d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.FemtogramPerMilliliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-3) * 1e-15d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.GramPerCubicCentimeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value / 1e-3, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.GramPerCubicFoot, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.001 / 0.028316846592, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.GramPerCubicInch, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.001 / 1.6387064e-5, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.GramPerCubicMeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value / 1e3, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.GramPerCubicMillimeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value / 1e-6, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.GramPerDeciliter, DensityUnit.KilogramPerCubicMeter) => new Density(_value / 1e-1, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.GramPerLiter, DensityUnit.KilogramPerCubicMeter) => new Density(_value / 1, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.GramPerMilliliter, DensityUnit.KilogramPerCubicMeter) => new Density(_value / 1e-3, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.KilogramPerCubicCentimeter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-3) * 1e3d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.KilogramPerCubicMillimeter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-6) * 1e3d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.KilogramPerLiter, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 1e3, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.KilopoundPerCubicFoot, DensityUnit.KilogramPerCubicMeter) => new Density((_value * 0.45359237 / 0.028316846592) * 1e3d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.KilopoundPerCubicInch, DensityUnit.KilogramPerCubicMeter) => new Density((_value * 0.45359237 / 1.6387064e-5) * 1e3d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.KilopoundPerCubicYard, DensityUnit.KilogramPerCubicMeter) => new Density((_value * 0.45359237 / 0.764554857984) * 1e3d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.MicrogramPerCubicMeter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e3) * 1e-6d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.MicrogramPerDeciliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-1) * 1e-6d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.MicrogramPerLiter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1) * 1e-6d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.MicrogramPerMilliliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-3) * 1e-6d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.MilligramPerCubicMeter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e3) * 1e-3d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.MilligramPerDeciliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-1) * 1e-3d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.MilligramPerLiter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1) * 1e-3d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.MilligramPerMilliliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-3) * 1e-3d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.NanogramPerDeciliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-1) * 1e-9d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.NanogramPerLiter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1) * 1e-9d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.NanogramPerMilliliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-3) * 1e-9d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PicogramPerDeciliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-1) * 1e-12d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PicogramPerLiter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1) * 1e-12d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PicogramPerMilliliter, DensityUnit.KilogramPerCubicMeter) => new Density((_value / 1e-3) * 1e-12d, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PoundPerCubicCentimeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237e6, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PoundPerCubicFoot, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237 / 0.028316846592, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PoundPerCubicInch, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237 / 1.6387064e-5, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PoundPerCubicMeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PoundPerCubicMillimeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237e9, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PoundPerCubicYard, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237 / 0.764554857984, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PoundPerImperialGallon, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237 / 0.00454609, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.PoundPerUSGallon, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237 / 0.003785411784, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.SlugPerCubicCentimeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237e6 * 9.80665 / 0.3048, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.SlugPerCubicFoot, DensityUnit.KilogramPerCubicMeter) => new Density(_value * (0.45359237 * 9.80665) / (0.3048 * 0.028316846592), DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.SlugPerCubicInch, DensityUnit.KilogramPerCubicMeter) => new Density(_value * (0.45359237 * 9.80665) / (0.3048 * 1.6387064e-5), DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.SlugPerCubicMeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237 * 9.80665 / 0.3048, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.SlugPerCubicMillimeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 0.45359237e9 * 9.80665 / 0.3048, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.TonnePerCubicCentimeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value / 1e-9, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.TonnePerCubicFoot, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 1000 / 0.028316846592, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.TonnePerCubicInch, DensityUnit.KilogramPerCubicMeter) => new Density(_value * 1000 / 1.6387064e-5, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.TonnePerCubicMeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value / 0.001, DensityUnit.KilogramPerCubicMeter),
-                (DensityUnit.TonnePerCubicMillimeter, DensityUnit.KilogramPerCubicMeter) => new Density(_value / 1e-12, DensityUnit.KilogramPerCubicMeter),
-
-                // BaseUnit -> DensityUnit
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.CentigramPerDeciliter) => new Density((_value * 1e-1) / 1e-2d, DensityUnit.CentigramPerDeciliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.CentigramPerLiter) => new Density((_value * 1) / 1e-2d, DensityUnit.CentigramPerLiter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.CentigramPerMilliliter) => new Density((_value * 1e-3) / 1e-2d, DensityUnit.CentigramPerMilliliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.DecigramPerDeciliter) => new Density((_value * 1e-1) / 1e-1d, DensityUnit.DecigramPerDeciliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.DecigramPerLiter) => new Density((_value * 1) / 1e-1d, DensityUnit.DecigramPerLiter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.DecigramPerMilliliter) => new Density((_value * 1e-3) / 1e-1d, DensityUnit.DecigramPerMilliliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.FemtogramPerDeciliter) => new Density((_value * 1e-1) / 1e-15d, DensityUnit.FemtogramPerDeciliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.FemtogramPerLiter) => new Density((_value * 1) / 1e-15d, DensityUnit.FemtogramPerLiter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.FemtogramPerMilliliter) => new Density((_value * 1e-3) / 1e-15d, DensityUnit.FemtogramPerMilliliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerCubicCentimeter) => new Density(_value * 1e-3, DensityUnit.GramPerCubicCentimeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerCubicFoot) => new Density(_value * 0.028316846592 / 0.001, DensityUnit.GramPerCubicFoot),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerCubicInch) => new Density(_value * 1.6387064e-5 / 0.001, DensityUnit.GramPerCubicInch),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerCubicMeter) => new Density(_value * 1e3, DensityUnit.GramPerCubicMeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerCubicMillimeter) => new Density(_value * 1e-6, DensityUnit.GramPerCubicMillimeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerDeciliter) => new Density(_value * 1e-1, DensityUnit.GramPerDeciliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerLiter) => new Density(_value * 1, DensityUnit.GramPerLiter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.GramPerMilliliter) => new Density(_value * 1e-3, DensityUnit.GramPerMilliliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerCubicCentimeter) => new Density((_value * 1e-3) / 1e3d, DensityUnit.KilogramPerCubicCentimeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerCubicMillimeter) => new Density((_value * 1e-6) / 1e3d, DensityUnit.KilogramPerCubicMillimeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.KilogramPerLiter) => new Density(_value / 1e3, DensityUnit.KilogramPerLiter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.KilopoundPerCubicFoot) => new Density((_value * 0.028316846592 / 0.45359237) / 1e3d, DensityUnit.KilopoundPerCubicFoot),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.KilopoundPerCubicInch) => new Density((_value * 1.6387064e-5 / 0.45359237) / 1e3d, DensityUnit.KilopoundPerCubicInch),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.KilopoundPerCubicYard) => new Density((_value * 0.764554857984 / 0.45359237) / 1e3d, DensityUnit.KilopoundPerCubicYard),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.MicrogramPerCubicMeter) => new Density((_value * 1e3) / 1e-6d, DensityUnit.MicrogramPerCubicMeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.MicrogramPerDeciliter) => new Density((_value * 1e-1) / 1e-6d, DensityUnit.MicrogramPerDeciliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.MicrogramPerLiter) => new Density((_value * 1) / 1e-6d, DensityUnit.MicrogramPerLiter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.MicrogramPerMilliliter) => new Density((_value * 1e-3) / 1e-6d, DensityUnit.MicrogramPerMilliliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.MilligramPerCubicMeter) => new Density((_value * 1e3) / 1e-3d, DensityUnit.MilligramPerCubicMeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.MilligramPerDeciliter) => new Density((_value * 1e-1) / 1e-3d, DensityUnit.MilligramPerDeciliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.MilligramPerLiter) => new Density((_value * 1) / 1e-3d, DensityUnit.MilligramPerLiter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.MilligramPerMilliliter) => new Density((_value * 1e-3) / 1e-3d, DensityUnit.MilligramPerMilliliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.NanogramPerDeciliter) => new Density((_value * 1e-1) / 1e-9d, DensityUnit.NanogramPerDeciliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.NanogramPerLiter) => new Density((_value * 1) / 1e-9d, DensityUnit.NanogramPerLiter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.NanogramPerMilliliter) => new Density((_value * 1e-3) / 1e-9d, DensityUnit.NanogramPerMilliliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PicogramPerDeciliter) => new Density((_value * 1e-1) / 1e-12d, DensityUnit.PicogramPerDeciliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PicogramPerLiter) => new Density((_value * 1) / 1e-12d, DensityUnit.PicogramPerLiter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PicogramPerMilliliter) => new Density((_value * 1e-3) / 1e-12d, DensityUnit.PicogramPerMilliliter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicCentimeter) => new Density(_value / 0.45359237e6, DensityUnit.PoundPerCubicCentimeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicFoot) => new Density(_value * 0.028316846592 / 0.45359237, DensityUnit.PoundPerCubicFoot),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicInch) => new Density(_value * 1.6387064e-5 / 0.45359237, DensityUnit.PoundPerCubicInch),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicMeter) => new Density(_value / 0.45359237, DensityUnit.PoundPerCubicMeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicMillimeter) => new Density(_value / 0.45359237e9, DensityUnit.PoundPerCubicMillimeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerCubicYard) => new Density(_value * 0.764554857984 / 0.45359237, DensityUnit.PoundPerCubicYard),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerImperialGallon) => new Density(_value * 0.00454609 / 0.45359237, DensityUnit.PoundPerImperialGallon),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.PoundPerUSGallon) => new Density(_value * 0.003785411784 / 0.45359237, DensityUnit.PoundPerUSGallon),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.SlugPerCubicCentimeter) => new Density(_value * 0.3048 / (0.45359237e6 * 9.80665), DensityUnit.SlugPerCubicCentimeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.SlugPerCubicFoot) => new Density(_value * (0.3048 * 0.028316846592) / (0.45359237 * 9.80665), DensityUnit.SlugPerCubicFoot),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.SlugPerCubicInch) => new Density(_value * (0.3048 * 1.6387064e-5) / (0.45359237 * 9.80665), DensityUnit.SlugPerCubicInch),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.SlugPerCubicMeter) => new Density(_value * 0.3048 / (0.45359237 * 9.80665), DensityUnit.SlugPerCubicMeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.SlugPerCubicMillimeter) => new Density(_value * 0.3048 / (0.45359237e9 * 9.80665), DensityUnit.SlugPerCubicMillimeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.TonnePerCubicCentimeter) => new Density(_value * 1e-9, DensityUnit.TonnePerCubicCentimeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.TonnePerCubicFoot) => new Density(_value * 0.028316846592 / 1000, DensityUnit.TonnePerCubicFoot),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.TonnePerCubicInch) => new Density(_value * 1.6387064e-5 / 1000, DensityUnit.TonnePerCubicInch),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.TonnePerCubicMeter) => new Density(_value * 0.001, DensityUnit.TonnePerCubicMeter),
-                (DensityUnit.KilogramPerCubicMeter, DensityUnit.TonnePerCubicMillimeter) => new Density(_value * 1e-12, DensityUnit.TonnePerCubicMillimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not DensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DensityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is DensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<DensityUnit> IQuantity<DensityUnit>.ToUnit(DensityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1778,11 +1544,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/DoseAreaProduct.g.cs b/UnitsNet/GeneratedCode/Quantities/DoseAreaProduct.g.cs
index d2ee657131..21ced4f1b9 100644
--- a/UnitsNet/GeneratedCode/Quantities/DoseAreaProduct.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/DoseAreaProduct.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,14 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Dose_area_product
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct DoseAreaProduct :
-        IArithmeticQuantity<DoseAreaProduct, DoseAreaProductUnit>,
+        ILinearQuantity<DoseAreaProduct, DoseAreaProductUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<DoseAreaProduct, DoseAreaProduct, double>,
+        IDivisionOperators<DoseAreaProduct, DoseAreaProduct, QuantityValue>,
+        IDivisionOperators<DoseAreaProduct, Area, AbsorbedDoseOfIonizingRadiation>,
+        IDivisionOperators<DoseAreaProduct, AbsorbedDoseOfIonizingRadiation, Area>,
         IComparisonOperators<DoseAreaProduct, DoseAreaProduct, bool>,
         IParsable<DoseAreaProduct>,
 #endif
@@ -55,7 +56,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +106,7 @@ public static DoseAreaProductInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="DoseAreaProduct"/> is [T^-2][L^4].
+            ///     The <see cref="BaseDimensions" /> for <see cref="DoseAreaProduct"/> is T^-2L^4.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(4, 0, -2, 0, 0, 0, 0);
 
@@ -120,39 +121,85 @@ public static DoseAreaProductInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{DoseAreaProductUnit}"/> representing the default unit mappings for DoseAreaProduct.</returns>
             public static IEnumerable<UnitDefinition<DoseAreaProductUnit>> GetDefaultMappings()
             {
-                yield return new (DoseAreaProductUnit.CentigraySquareCentimeter, "CentigraySquareCentimeter", "CentigraySquareCentimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.CentigraySquareDecimeter, "CentigraySquareDecimeter", "CentigraySquareDecimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.CentigraySquareMeter, "CentigraySquareMeter", "CentigraySquareMeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.CentigraySquareMicrometer, "CentigraySquareMicrometer", "CentigraySquareMicrometers", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.CentigraySquareMillimeter, "CentigraySquareMillimeter", "CentigraySquareMillimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.DecigraySquareCentimeter, "DecigraySquareCentimeter", "DecigraySquareCentimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.DecigraySquareDecimeter, "DecigraySquareDecimeter", "DecigraySquareDecimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.DecigraySquareMeter, "DecigraySquareMeter", "DecigraySquareMeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.DecigraySquareMicrometer, "DecigraySquareMicrometer", "DecigraySquareMicrometers", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.DecigraySquareMillimeter, "DecigraySquareMillimeter", "DecigraySquareMillimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.GraySquareCentimeter, "GraySquareCentimeter", "GraySquareCentimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.GraySquareDecimeter, "GraySquareDecimeter", "GraySquareDecimeters", BaseUnits.Undefined);
+                yield return new (DoseAreaProductUnit.CentigraySquareCentimeter, "CentigraySquareCentimeter", "CentigraySquareCentimeters", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (DoseAreaProductUnit.CentigraySquareDecimeter, "CentigraySquareDecimeter", "CentigraySquareDecimeters", BaseUnits.Undefined,
+                     10000
+                );
+                yield return new (DoseAreaProductUnit.CentigraySquareMeter, "CentigraySquareMeter", "CentigraySquareMeters", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (DoseAreaProductUnit.CentigraySquareMicrometer, "CentigraySquareMicrometer", "CentigraySquareMicrometers", BaseUnits.Undefined,
+                     100000000000000
+                );
+                yield return new (DoseAreaProductUnit.CentigraySquareMillimeter, "CentigraySquareMillimeter", "CentigraySquareMillimeters", BaseUnits.Undefined,
+                     100000000
+                );
+                yield return new (DoseAreaProductUnit.DecigraySquareCentimeter, "DecigraySquareCentimeter", "DecigraySquareCentimeters", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (DoseAreaProductUnit.DecigraySquareDecimeter, "DecigraySquareDecimeter", "DecigraySquareDecimeters", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (DoseAreaProductUnit.DecigraySquareMeter, "DecigraySquareMeter", "DecigraySquareMeters", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (DoseAreaProductUnit.DecigraySquareMicrometer, "DecigraySquareMicrometer", "DecigraySquareMicrometers", BaseUnits.Undefined,
+                     10000000000000
+                );
+                yield return new (DoseAreaProductUnit.DecigraySquareMillimeter, "DecigraySquareMillimeter", "DecigraySquareMillimeters", BaseUnits.Undefined,
+                     10000000
+                );
+                yield return new (DoseAreaProductUnit.GraySquareCentimeter, "GraySquareCentimeter", "GraySquareCentimeters", BaseUnits.Undefined,
+                     10000
+                );
+                yield return new (DoseAreaProductUnit.GraySquareDecimeter, "GraySquareDecimeter", "GraySquareDecimeters", BaseUnits.Undefined,
+                     100
+                );
                 yield return new (DoseAreaProductUnit.GraySquareMeter, "GraySquareMeter", "GraySquareMeters", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (DoseAreaProductUnit.GraySquareMicrometer, "GraySquareMicrometer", "GraySquareMicrometers", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.GraySquareMillimeter, "GraySquareMillimeter", "GraySquareMillimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.MicrograySquareCentimeter, "MicrograySquareCentimeter", "MicrograySquareCentimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.MicrograySquareDecimeter, "MicrograySquareDecimeter", "MicrograySquareDecimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.MicrograySquareMeter, "MicrograySquareMeter", "MicrograySquareMeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.MicrograySquareMicrometer, "MicrograySquareMicrometer", "MicrograySquareMicrometers", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.MicrograySquareMillimeter, "MicrograySquareMillimeter", "MicrograySquareMillimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.MilligraySquareCentimeter, "MilligraySquareCentimeter", "MilligraySquareCentimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.MilligraySquareDecimeter, "MilligraySquareDecimeter", "MilligraySquareDecimeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.MilligraySquareMeter, "MilligraySquareMeter", "MilligraySquareMeters", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.MilligraySquareMicrometer, "MilligraySquareMicrometer", "MilligraySquareMicrometers", BaseUnits.Undefined);
-                yield return new (DoseAreaProductUnit.MilligraySquareMillimeter, "MilligraySquareMillimeter", "MilligraySquareMillimeters", BaseUnits.Undefined);
+                yield return new (DoseAreaProductUnit.GraySquareMicrometer, "GraySquareMicrometer", "GraySquareMicrometers", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (DoseAreaProductUnit.GraySquareMillimeter, "GraySquareMillimeter", "GraySquareMillimeters", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (DoseAreaProductUnit.MicrograySquareCentimeter, "MicrograySquareCentimeter", "MicrograySquareCentimeters", BaseUnits.Undefined,
+                     10000000000
+                );
+                yield return new (DoseAreaProductUnit.MicrograySquareDecimeter, "MicrograySquareDecimeter", "MicrograySquareDecimeters", BaseUnits.Undefined,
+                     100000000
+                );
+                yield return new (DoseAreaProductUnit.MicrograySquareMeter, "MicrograySquareMeter", "MicrograySquareMeters", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (DoseAreaProductUnit.MicrograySquareMicrometer, "MicrograySquareMicrometer", "MicrograySquareMicrometers", BaseUnits.Undefined,
+                     1000000000000000000
+                );
+                yield return new (DoseAreaProductUnit.MicrograySquareMillimeter, "MicrograySquareMillimeter", "MicrograySquareMillimeters", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (DoseAreaProductUnit.MilligraySquareCentimeter, "MilligraySquareCentimeter", "MilligraySquareCentimeters", BaseUnits.Undefined,
+                     10000000
+                );
+                yield return new (DoseAreaProductUnit.MilligraySquareDecimeter, "MilligraySquareDecimeter", "MilligraySquareDecimeters", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (DoseAreaProductUnit.MilligraySquareMeter, "MilligraySquareMeter", "MilligraySquareMeters", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (DoseAreaProductUnit.MilligraySquareMicrometer, "MilligraySquareMicrometer", "MilligraySquareMicrometers", BaseUnits.Undefined,
+                     1000000000000000
+                );
+                yield return new (DoseAreaProductUnit.MilligraySquareMillimeter, "MilligraySquareMillimeter", "MilligraySquareMillimeters", BaseUnits.Undefined,
+                     1000000000
+                );
             }
         }
 
         static DoseAreaProduct()
         {
-            Info = DoseAreaProductInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(DoseAreaProductInfo.CreateDefault);
         }
 
         /// <summary>
@@ -160,7 +207,7 @@ static DoseAreaProduct()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public DoseAreaProduct(double value, DoseAreaProductUnit unit)
+        public DoseAreaProduct(QuantityValue value, DoseAreaProductUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -174,7 +221,7 @@ public DoseAreaProduct(double value, DoseAreaProductUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public DoseAreaProduct(double value, UnitSystem unitSystem)
+        public DoseAreaProduct(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -185,7 +232,8 @@ public DoseAreaProduct(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="DoseAreaProduct" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<DoseAreaProduct, DoseAreaProductUnit> Info { get; }
@@ -214,10 +262,8 @@ public DoseAreaProduct(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public DoseAreaProductUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -251,196 +297,134 @@ public DoseAreaProduct(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareCentimeter"/>
         /// </summary>
-        public double CentigraySquareCentimeters => As(DoseAreaProductUnit.CentigraySquareCentimeter);
+        public QuantityValue CentigraySquareCentimeters => this.As(DoseAreaProductUnit.CentigraySquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareDecimeter"/>
         /// </summary>
-        public double CentigraySquareDecimeters => As(DoseAreaProductUnit.CentigraySquareDecimeter);
+        public QuantityValue CentigraySquareDecimeters => this.As(DoseAreaProductUnit.CentigraySquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareMeter"/>
         /// </summary>
-        public double CentigraySquareMeters => As(DoseAreaProductUnit.CentigraySquareMeter);
+        public QuantityValue CentigraySquareMeters => this.As(DoseAreaProductUnit.CentigraySquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareMicrometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareMicrometer"/>
         /// </summary>
-        public double CentigraySquareMicrometers => As(DoseAreaProductUnit.CentigraySquareMicrometer);
+        public QuantityValue CentigraySquareMicrometers => this.As(DoseAreaProductUnit.CentigraySquareMicrometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.CentigraySquareMillimeter"/>
         /// </summary>
-        public double CentigraySquareMillimeters => As(DoseAreaProductUnit.CentigraySquareMillimeter);
+        public QuantityValue CentigraySquareMillimeters => this.As(DoseAreaProductUnit.CentigraySquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareCentimeter"/>
         /// </summary>
-        public double DecigraySquareCentimeters => As(DoseAreaProductUnit.DecigraySquareCentimeter);
+        public QuantityValue DecigraySquareCentimeters => this.As(DoseAreaProductUnit.DecigraySquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareDecimeter"/>
         /// </summary>
-        public double DecigraySquareDecimeters => As(DoseAreaProductUnit.DecigraySquareDecimeter);
+        public QuantityValue DecigraySquareDecimeters => this.As(DoseAreaProductUnit.DecigraySquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareMeter"/>
         /// </summary>
-        public double DecigraySquareMeters => As(DoseAreaProductUnit.DecigraySquareMeter);
+        public QuantityValue DecigraySquareMeters => this.As(DoseAreaProductUnit.DecigraySquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareMicrometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareMicrometer"/>
         /// </summary>
-        public double DecigraySquareMicrometers => As(DoseAreaProductUnit.DecigraySquareMicrometer);
+        public QuantityValue DecigraySquareMicrometers => this.As(DoseAreaProductUnit.DecigraySquareMicrometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.DecigraySquareMillimeter"/>
         /// </summary>
-        public double DecigraySquareMillimeters => As(DoseAreaProductUnit.DecigraySquareMillimeter);
+        public QuantityValue DecigraySquareMillimeters => this.As(DoseAreaProductUnit.DecigraySquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareCentimeter"/>
         /// </summary>
-        public double GraySquareCentimeters => As(DoseAreaProductUnit.GraySquareCentimeter);
+        public QuantityValue GraySquareCentimeters => this.As(DoseAreaProductUnit.GraySquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareDecimeter"/>
         /// </summary>
-        public double GraySquareDecimeters => As(DoseAreaProductUnit.GraySquareDecimeter);
+        public QuantityValue GraySquareDecimeters => this.As(DoseAreaProductUnit.GraySquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareMeter"/>
         /// </summary>
-        public double GraySquareMeters => As(DoseAreaProductUnit.GraySquareMeter);
+        public QuantityValue GraySquareMeters => this.As(DoseAreaProductUnit.GraySquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareMicrometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareMicrometer"/>
         /// </summary>
-        public double GraySquareMicrometers => As(DoseAreaProductUnit.GraySquareMicrometer);
+        public QuantityValue GraySquareMicrometers => this.As(DoseAreaProductUnit.GraySquareMicrometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.GraySquareMillimeter"/>
         /// </summary>
-        public double GraySquareMillimeters => As(DoseAreaProductUnit.GraySquareMillimeter);
+        public QuantityValue GraySquareMillimeters => this.As(DoseAreaProductUnit.GraySquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareCentimeter"/>
         /// </summary>
-        public double MicrograySquareCentimeters => As(DoseAreaProductUnit.MicrograySquareCentimeter);
+        public QuantityValue MicrograySquareCentimeters => this.As(DoseAreaProductUnit.MicrograySquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareDecimeter"/>
         /// </summary>
-        public double MicrograySquareDecimeters => As(DoseAreaProductUnit.MicrograySquareDecimeter);
+        public QuantityValue MicrograySquareDecimeters => this.As(DoseAreaProductUnit.MicrograySquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareMeter"/>
         /// </summary>
-        public double MicrograySquareMeters => As(DoseAreaProductUnit.MicrograySquareMeter);
+        public QuantityValue MicrograySquareMeters => this.As(DoseAreaProductUnit.MicrograySquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareMicrometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareMicrometer"/>
         /// </summary>
-        public double MicrograySquareMicrometers => As(DoseAreaProductUnit.MicrograySquareMicrometer);
+        public QuantityValue MicrograySquareMicrometers => this.As(DoseAreaProductUnit.MicrograySquareMicrometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MicrograySquareMillimeter"/>
         /// </summary>
-        public double MicrograySquareMillimeters => As(DoseAreaProductUnit.MicrograySquareMillimeter);
+        public QuantityValue MicrograySquareMillimeters => this.As(DoseAreaProductUnit.MicrograySquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareCentimeter"/>
         /// </summary>
-        public double MilligraySquareCentimeters => As(DoseAreaProductUnit.MilligraySquareCentimeter);
+        public QuantityValue MilligraySquareCentimeters => this.As(DoseAreaProductUnit.MilligraySquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareDecimeter"/>
         /// </summary>
-        public double MilligraySquareDecimeters => As(DoseAreaProductUnit.MilligraySquareDecimeter);
+        public QuantityValue MilligraySquareDecimeters => this.As(DoseAreaProductUnit.MilligraySquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareMeter"/>
         /// </summary>
-        public double MilligraySquareMeters => As(DoseAreaProductUnit.MilligraySquareMeter);
+        public QuantityValue MilligraySquareMeters => this.As(DoseAreaProductUnit.MilligraySquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareMicrometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareMicrometer"/>
         /// </summary>
-        public double MilligraySquareMicrometers => As(DoseAreaProductUnit.MilligraySquareMicrometer);
+        public QuantityValue MilligraySquareMicrometers => this.As(DoseAreaProductUnit.MilligraySquareMicrometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DoseAreaProductUnit.MilligraySquareMillimeter"/>
         /// </summary>
-        public double MilligraySquareMillimeters => As(DoseAreaProductUnit.MilligraySquareMillimeter);
+        public QuantityValue MilligraySquareMillimeters => this.As(DoseAreaProductUnit.MilligraySquareMillimeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: DoseAreaProductUnit -> BaseUnit
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.CentigraySquareCentimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.CentigraySquareDecimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.CentigraySquareMeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.CentigraySquareMicrometer, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.CentigraySquareMillimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.DecigraySquareCentimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.DecigraySquareDecimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.DecigraySquareMeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.DecigraySquareMicrometer, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.DecigraySquareMillimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareCentimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareDecimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMicrometer, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMillimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.MicrograySquareCentimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.MicrograySquareDecimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.MicrograySquareMeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.MicrograySquareMicrometer, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.MicrograySquareMillimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.MilligraySquareCentimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.MilligraySquareDecimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.MilligraySquareMeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.MilligraySquareMicrometer, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.MilligraySquareMillimeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.GraySquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> DoseAreaProductUnit
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.CentigraySquareCentimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.CentigraySquareCentimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.CentigraySquareDecimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.CentigraySquareDecimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.CentigraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.CentigraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.CentigraySquareMicrometer, quantity => quantity.ToUnit(DoseAreaProductUnit.CentigraySquareMicrometer));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.CentigraySquareMillimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.CentigraySquareMillimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.DecigraySquareCentimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.DecigraySquareCentimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.DecigraySquareDecimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.DecigraySquareDecimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.DecigraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.DecigraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.DecigraySquareMicrometer, quantity => quantity.ToUnit(DoseAreaProductUnit.DecigraySquareMicrometer));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.DecigraySquareMillimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.DecigraySquareMillimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.GraySquareCentimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareCentimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.GraySquareDecimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareDecimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.GraySquareMicrometer, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMicrometer));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.GraySquareMillimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.GraySquareMillimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MicrograySquareCentimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.MicrograySquareCentimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MicrograySquareDecimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.MicrograySquareDecimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MicrograySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.MicrograySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MicrograySquareMicrometer, quantity => quantity.ToUnit(DoseAreaProductUnit.MicrograySquareMicrometer));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MicrograySquareMillimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.MicrograySquareMillimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MilligraySquareCentimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.MilligraySquareCentimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MilligraySquareDecimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.MilligraySquareDecimeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MilligraySquareMeter, quantity => quantity.ToUnit(DoseAreaProductUnit.MilligraySquareMeter));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MilligraySquareMicrometer, quantity => quantity.ToUnit(DoseAreaProductUnit.MilligraySquareMicrometer));
-            unitConverter.SetConversionFunction<DoseAreaProduct>(DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MilligraySquareMillimeter, quantity => quantity.ToUnit(DoseAreaProductUnit.MilligraySquareMillimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -469,7 +453,7 @@ public static string GetAbbreviation(DoseAreaProductUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.CentigraySquareCentimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromCentigraySquareCentimeters(double value)
+        public static DoseAreaProduct FromCentigraySquareCentimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.CentigraySquareCentimeter);
         }
@@ -477,7 +461,7 @@ public static DoseAreaProduct FromCentigraySquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.CentigraySquareDecimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromCentigraySquareDecimeters(double value)
+        public static DoseAreaProduct FromCentigraySquareDecimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.CentigraySquareDecimeter);
         }
@@ -485,7 +469,7 @@ public static DoseAreaProduct FromCentigraySquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.CentigraySquareMeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromCentigraySquareMeters(double value)
+        public static DoseAreaProduct FromCentigraySquareMeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.CentigraySquareMeter);
         }
@@ -493,7 +477,7 @@ public static DoseAreaProduct FromCentigraySquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.CentigraySquareMicrometer"/>.
         /// </summary>
-        public static DoseAreaProduct FromCentigraySquareMicrometers(double value)
+        public static DoseAreaProduct FromCentigraySquareMicrometers(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.CentigraySquareMicrometer);
         }
@@ -501,7 +485,7 @@ public static DoseAreaProduct FromCentigraySquareMicrometers(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.CentigraySquareMillimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromCentigraySquareMillimeters(double value)
+        public static DoseAreaProduct FromCentigraySquareMillimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.CentigraySquareMillimeter);
         }
@@ -509,7 +493,7 @@ public static DoseAreaProduct FromCentigraySquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.DecigraySquareCentimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromDecigraySquareCentimeters(double value)
+        public static DoseAreaProduct FromDecigraySquareCentimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.DecigraySquareCentimeter);
         }
@@ -517,7 +501,7 @@ public static DoseAreaProduct FromDecigraySquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.DecigraySquareDecimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromDecigraySquareDecimeters(double value)
+        public static DoseAreaProduct FromDecigraySquareDecimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.DecigraySquareDecimeter);
         }
@@ -525,7 +509,7 @@ public static DoseAreaProduct FromDecigraySquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.DecigraySquareMeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromDecigraySquareMeters(double value)
+        public static DoseAreaProduct FromDecigraySquareMeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.DecigraySquareMeter);
         }
@@ -533,7 +517,7 @@ public static DoseAreaProduct FromDecigraySquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.DecigraySquareMicrometer"/>.
         /// </summary>
-        public static DoseAreaProduct FromDecigraySquareMicrometers(double value)
+        public static DoseAreaProduct FromDecigraySquareMicrometers(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.DecigraySquareMicrometer);
         }
@@ -541,7 +525,7 @@ public static DoseAreaProduct FromDecigraySquareMicrometers(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.DecigraySquareMillimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromDecigraySquareMillimeters(double value)
+        public static DoseAreaProduct FromDecigraySquareMillimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.DecigraySquareMillimeter);
         }
@@ -549,7 +533,7 @@ public static DoseAreaProduct FromDecigraySquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.GraySquareCentimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromGraySquareCentimeters(double value)
+        public static DoseAreaProduct FromGraySquareCentimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.GraySquareCentimeter);
         }
@@ -557,7 +541,7 @@ public static DoseAreaProduct FromGraySquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.GraySquareDecimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromGraySquareDecimeters(double value)
+        public static DoseAreaProduct FromGraySquareDecimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.GraySquareDecimeter);
         }
@@ -565,7 +549,7 @@ public static DoseAreaProduct FromGraySquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.GraySquareMeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromGraySquareMeters(double value)
+        public static DoseAreaProduct FromGraySquareMeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.GraySquareMeter);
         }
@@ -573,7 +557,7 @@ public static DoseAreaProduct FromGraySquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.GraySquareMicrometer"/>.
         /// </summary>
-        public static DoseAreaProduct FromGraySquareMicrometers(double value)
+        public static DoseAreaProduct FromGraySquareMicrometers(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.GraySquareMicrometer);
         }
@@ -581,7 +565,7 @@ public static DoseAreaProduct FromGraySquareMicrometers(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.GraySquareMillimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromGraySquareMillimeters(double value)
+        public static DoseAreaProduct FromGraySquareMillimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.GraySquareMillimeter);
         }
@@ -589,7 +573,7 @@ public static DoseAreaProduct FromGraySquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MicrograySquareCentimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromMicrograySquareCentimeters(double value)
+        public static DoseAreaProduct FromMicrograySquareCentimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.MicrograySquareCentimeter);
         }
@@ -597,7 +581,7 @@ public static DoseAreaProduct FromMicrograySquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MicrograySquareDecimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromMicrograySquareDecimeters(double value)
+        public static DoseAreaProduct FromMicrograySquareDecimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.MicrograySquareDecimeter);
         }
@@ -605,7 +589,7 @@ public static DoseAreaProduct FromMicrograySquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MicrograySquareMeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromMicrograySquareMeters(double value)
+        public static DoseAreaProduct FromMicrograySquareMeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.MicrograySquareMeter);
         }
@@ -613,7 +597,7 @@ public static DoseAreaProduct FromMicrograySquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MicrograySquareMicrometer"/>.
         /// </summary>
-        public static DoseAreaProduct FromMicrograySquareMicrometers(double value)
+        public static DoseAreaProduct FromMicrograySquareMicrometers(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.MicrograySquareMicrometer);
         }
@@ -621,7 +605,7 @@ public static DoseAreaProduct FromMicrograySquareMicrometers(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MicrograySquareMillimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromMicrograySquareMillimeters(double value)
+        public static DoseAreaProduct FromMicrograySquareMillimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.MicrograySquareMillimeter);
         }
@@ -629,7 +613,7 @@ public static DoseAreaProduct FromMicrograySquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MilligraySquareCentimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromMilligraySquareCentimeters(double value)
+        public static DoseAreaProduct FromMilligraySquareCentimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.MilligraySquareCentimeter);
         }
@@ -637,7 +621,7 @@ public static DoseAreaProduct FromMilligraySquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MilligraySquareDecimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromMilligraySquareDecimeters(double value)
+        public static DoseAreaProduct FromMilligraySquareDecimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.MilligraySquareDecimeter);
         }
@@ -645,7 +629,7 @@ public static DoseAreaProduct FromMilligraySquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MilligraySquareMeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromMilligraySquareMeters(double value)
+        public static DoseAreaProduct FromMilligraySquareMeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.MilligraySquareMeter);
         }
@@ -653,7 +637,7 @@ public static DoseAreaProduct FromMilligraySquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MilligraySquareMicrometer"/>.
         /// </summary>
-        public static DoseAreaProduct FromMilligraySquareMicrometers(double value)
+        public static DoseAreaProduct FromMilligraySquareMicrometers(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.MilligraySquareMicrometer);
         }
@@ -661,7 +645,7 @@ public static DoseAreaProduct FromMilligraySquareMicrometers(double value)
         /// <summary>
         ///     Creates a <see cref="DoseAreaProduct"/> from <see cref="DoseAreaProductUnit.MilligraySquareMillimeter"/>.
         /// </summary>
-        public static DoseAreaProduct FromMilligraySquareMillimeters(double value)
+        public static DoseAreaProduct FromMilligraySquareMillimeters(QuantityValue value)
         {
             return new DoseAreaProduct(value, DoseAreaProductUnit.MilligraySquareMillimeter);
         }
@@ -672,7 +656,7 @@ public static DoseAreaProduct FromMilligraySquareMillimeters(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>DoseAreaProduct unit value.</returns>
-        public static DoseAreaProduct From(double value, DoseAreaProductUnit fromUnit)
+        public static DoseAreaProduct From(QuantityValue value, DoseAreaProductUnit fromUnit)
         {
             return new DoseAreaProduct(value, fromUnit);
         }
@@ -733,10 +717,7 @@ public static DoseAreaProduct Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static DoseAreaProduct Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<DoseAreaProduct, DoseAreaProductUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<DoseAreaProduct, DoseAreaProductUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -764,11 +745,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out DoseAreaProduct
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out DoseAreaProduct result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<DoseAreaProduct, DoseAreaProductUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<DoseAreaProduct, DoseAreaProductUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -789,7 +766,7 @@ public static DoseAreaProductUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -800,7 +777,7 @@ public static DoseAreaProductUnit ParseUnit(string str, IFormatProvider? provide
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.DoseAreaProductUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.DoseAreaProductUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out DoseAreaProductUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -815,7 +792,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out DoseAreaProd
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out DoseAreaProductUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -834,137 +811,167 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="DoseAreaProduct"/> from adding two <see cref="DoseAreaProduct"/>.</summary>
         public static DoseAreaProduct operator +(DoseAreaProduct left, DoseAreaProduct right)
         {
-            return new DoseAreaProduct(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new DoseAreaProduct(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="DoseAreaProduct"/> from subtracting two <see cref="DoseAreaProduct"/>.</summary>
         public static DoseAreaProduct operator -(DoseAreaProduct left, DoseAreaProduct right)
         {
-            return new DoseAreaProduct(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new DoseAreaProduct(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="DoseAreaProduct"/> from multiplying value and <see cref="DoseAreaProduct"/>.</summary>
-        public static DoseAreaProduct operator *(double left, DoseAreaProduct right)
+        public static DoseAreaProduct operator *(QuantityValue left, DoseAreaProduct right)
         {
             return new DoseAreaProduct(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="DoseAreaProduct"/> from multiplying value and <see cref="DoseAreaProduct"/>.</summary>
-        public static DoseAreaProduct operator *(DoseAreaProduct left, double right)
+        public static DoseAreaProduct operator *(DoseAreaProduct left, QuantityValue right)
         {
             return new DoseAreaProduct(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="DoseAreaProduct"/> from dividing <see cref="DoseAreaProduct"/> by value.</summary>
-        public static DoseAreaProduct operator /(DoseAreaProduct left, double right)
+        public static DoseAreaProduct operator /(DoseAreaProduct left, QuantityValue right)
         {
             return new DoseAreaProduct(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="DoseAreaProduct"/> by <see cref="DoseAreaProduct"/>.</summary>
-        public static double operator /(DoseAreaProduct left, DoseAreaProduct right)
+        public static QuantityValue operator /(DoseAreaProduct left, DoseAreaProduct right)
         {
             return left.GraySquareMeters / right.GraySquareMeters;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="DoseAreaProduct"/> / <see cref="Area"/>.</summary>
+        public static AbsorbedDoseOfIonizingRadiation operator /(DoseAreaProduct doseAreaProduct, Area area)
+        {
+            return AbsorbedDoseOfIonizingRadiation.FromGrays(doseAreaProduct.GraySquareMeters / area.SquareMeters);
+        }
+
+        /// <summary>Get <see cref="Area"/> from <see cref="DoseAreaProduct"/> / <see cref="AbsorbedDoseOfIonizingRadiation"/>.</summary>
+        public static Area operator /(DoseAreaProduct doseAreaProduct, AbsorbedDoseOfIonizingRadiation absorbedDoseOfIonizingRadiation)
+        {
+            return Area.FromSquareMeters(doseAreaProduct.GraySquareMeters / absorbedDoseOfIonizingRadiation.Grays);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(DoseAreaProduct left, DoseAreaProduct right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(DoseAreaProduct left, DoseAreaProduct right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(DoseAreaProduct left, DoseAreaProduct right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(DoseAreaProduct left, DoseAreaProduct right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="DoseAreaProduct"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(DoseAreaProduct other, DoseAreaProduct tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="DoseAreaProduct"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(DoseAreaProduct)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(DoseAreaProduct left, DoseAreaProduct right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="DoseAreaProduct"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(DoseAreaProduct other, DoseAreaProduct tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="DoseAreaProduct"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(DoseAreaProduct,DoseAreaProduct)"/>.
+        ///     See that operator (and <see cref="Equals(DoseAreaProduct)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(DoseAreaProduct left, DoseAreaProduct right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="DoseAreaProduct"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(DoseAreaProduct other, DoseAreaProduct tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="DoseAreaProduct"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="DoseAreaProduct"/>.
+        ///     When <paramref name="obj"/> is a <see cref="DoseAreaProduct"/>, this method delegates to
+        ///     <see cref="Equals(DoseAreaProduct)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is DoseAreaProduct otherQuantity))
+            if (obj is not DoseAreaProduct otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="DoseAreaProduct"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(DoseAreaProduct other, DoseAreaProduct tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="DoseAreaProduct"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(DoseAreaProduct other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current DoseAreaProduct.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(DoseAreaProduct), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="DoseAreaProduct"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(DoseAreaProduct)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is DoseAreaProduct otherQuantity)) throw new ArgumentException("Expected type DoseAreaProduct.", nameof(obj));
+            if (obj is not DoseAreaProduct otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<DoseAreaProduct>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="DoseAreaProduct"/> with another <see cref="DoseAreaProduct"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="DoseAreaProduct"/> with another <see cref="DoseAreaProduct"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -976,177 +983,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(DoseAreaProduct other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(DoseAreaProductUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<DoseAreaProductUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this DoseAreaProduct to another DoseAreaProduct with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A DoseAreaProduct with the specified unit.</returns>
-        public DoseAreaProduct ToUnit(DoseAreaProductUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="DoseAreaProduct"/> to another <see cref="DoseAreaProduct"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A DoseAreaProduct with the specified unit.</returns>
-        public DoseAreaProduct ToUnit(DoseAreaProductUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(DoseAreaProduct), Unit, typeof(DoseAreaProduct), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (DoseAreaProduct)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="DoseAreaProduct"/> to another <see cref="DoseAreaProduct"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="DoseAreaProduct"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(DoseAreaProductUnit unit, [NotNullWhen(true)] out DoseAreaProduct? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            DoseAreaProduct? convertedOrNull = (Unit, unit) switch
-            {
-                // DoseAreaProductUnit -> BaseUnit
-                (DoseAreaProductUnit.CentigraySquareCentimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 10000) * 1e-2d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.CentigraySquareDecimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 100) * 1e-2d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.CentigraySquareMeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value) * 1e-2d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.CentigraySquareMicrometer, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 1000000000000) * 1e-2d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.CentigraySquareMillimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 1000000) * 1e-2d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.DecigraySquareCentimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 10000) * 1e-1d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.DecigraySquareDecimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 100) * 1e-1d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.DecigraySquareMeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value) * 1e-1d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.DecigraySquareMicrometer, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 1000000000000) * 1e-1d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.DecigraySquareMillimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 1000000) * 1e-1d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.GraySquareCentimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct(_value / 10000, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.GraySquareDecimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct(_value / 100, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.GraySquareMicrometer, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct(_value / 1000000000000, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.GraySquareMillimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct(_value / 1000000, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.MicrograySquareCentimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 10000) * 1e-6d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.MicrograySquareDecimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 100) * 1e-6d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.MicrograySquareMeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value) * 1e-6d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.MicrograySquareMicrometer, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 1000000000000) * 1e-6d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.MicrograySquareMillimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 1000000) * 1e-6d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.MilligraySquareCentimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 10000) * 1e-3d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.MilligraySquareDecimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 100) * 1e-3d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.MilligraySquareMeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value) * 1e-3d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.MilligraySquareMicrometer, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 1000000000000) * 1e-3d, DoseAreaProductUnit.GraySquareMeter),
-                (DoseAreaProductUnit.MilligraySquareMillimeter, DoseAreaProductUnit.GraySquareMeter) => new DoseAreaProduct((_value / 1000000) * 1e-3d, DoseAreaProductUnit.GraySquareMeter),
-
-                // BaseUnit -> DoseAreaProductUnit
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.CentigraySquareCentimeter) => new DoseAreaProduct((_value * 10000) / 1e-2d, DoseAreaProductUnit.CentigraySquareCentimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.CentigraySquareDecimeter) => new DoseAreaProduct((_value * 100) / 1e-2d, DoseAreaProductUnit.CentigraySquareDecimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.CentigraySquareMeter) => new DoseAreaProduct((_value) / 1e-2d, DoseAreaProductUnit.CentigraySquareMeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.CentigraySquareMicrometer) => new DoseAreaProduct((_value * 1000000000000) / 1e-2d, DoseAreaProductUnit.CentigraySquareMicrometer),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.CentigraySquareMillimeter) => new DoseAreaProduct((_value * 1000000) / 1e-2d, DoseAreaProductUnit.CentigraySquareMillimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.DecigraySquareCentimeter) => new DoseAreaProduct((_value * 10000) / 1e-1d, DoseAreaProductUnit.DecigraySquareCentimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.DecigraySquareDecimeter) => new DoseAreaProduct((_value * 100) / 1e-1d, DoseAreaProductUnit.DecigraySquareDecimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.DecigraySquareMeter) => new DoseAreaProduct((_value) / 1e-1d, DoseAreaProductUnit.DecigraySquareMeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.DecigraySquareMicrometer) => new DoseAreaProduct((_value * 1000000000000) / 1e-1d, DoseAreaProductUnit.DecigraySquareMicrometer),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.DecigraySquareMillimeter) => new DoseAreaProduct((_value * 1000000) / 1e-1d, DoseAreaProductUnit.DecigraySquareMillimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.GraySquareCentimeter) => new DoseAreaProduct(_value * 10000, DoseAreaProductUnit.GraySquareCentimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.GraySquareDecimeter) => new DoseAreaProduct(_value * 100, DoseAreaProductUnit.GraySquareDecimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.GraySquareMicrometer) => new DoseAreaProduct(_value * 1000000000000, DoseAreaProductUnit.GraySquareMicrometer),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.GraySquareMillimeter) => new DoseAreaProduct(_value * 1000000, DoseAreaProductUnit.GraySquareMillimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MicrograySquareCentimeter) => new DoseAreaProduct((_value * 10000) / 1e-6d, DoseAreaProductUnit.MicrograySquareCentimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MicrograySquareDecimeter) => new DoseAreaProduct((_value * 100) / 1e-6d, DoseAreaProductUnit.MicrograySquareDecimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MicrograySquareMeter) => new DoseAreaProduct((_value) / 1e-6d, DoseAreaProductUnit.MicrograySquareMeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MicrograySquareMicrometer) => new DoseAreaProduct((_value * 1000000000000) / 1e-6d, DoseAreaProductUnit.MicrograySquareMicrometer),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MicrograySquareMillimeter) => new DoseAreaProduct((_value * 1000000) / 1e-6d, DoseAreaProductUnit.MicrograySquareMillimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MilligraySquareCentimeter) => new DoseAreaProduct((_value * 10000) / 1e-3d, DoseAreaProductUnit.MilligraySquareCentimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MilligraySquareDecimeter) => new DoseAreaProduct((_value * 100) / 1e-3d, DoseAreaProductUnit.MilligraySquareDecimeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MilligraySquareMeter) => new DoseAreaProduct((_value) / 1e-3d, DoseAreaProductUnit.MilligraySquareMeter),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MilligraySquareMicrometer) => new DoseAreaProduct((_value * 1000000000000) / 1e-3d, DoseAreaProductUnit.MilligraySquareMicrometer),
-                (DoseAreaProductUnit.GraySquareMeter, DoseAreaProductUnit.MilligraySquareMillimeter) => new DoseAreaProduct((_value * 1000000) / 1e-3d, DoseAreaProductUnit.MilligraySquareMillimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not DoseAreaProductUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DoseAreaProductUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is DoseAreaProductUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DoseAreaProductUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<DoseAreaProductUnit> IQuantity<DoseAreaProductUnit>.ToUnit(DoseAreaProductUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1160,11 +999,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
index 53509ba4eb..5a1dee5c57 100644
--- a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,23 +33,32 @@ namespace UnitsNet
     ///     Time is a dimension in which events can be ordered from the past through the present into the future, and also the measure of durations of events and the intervals between them.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Duration :
-        IArithmeticQuantity<Duration, DurationUnit>,
+        ILinearQuantity<Duration, DurationUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Duration, Duration, double>,
+        IDivisionOperators<Duration, Duration, QuantityValue>,
         IMultiplyOperators<Duration, Jerk, Acceleration>,
         IMultiplyOperators<Duration, MolarFlow, AmountOfSubstance>,
         IMultiplyOperators<Duration, RotationalSpeed, Angle>,
         IMultiplyOperators<Duration, KinematicViscosity, Area>,
+        IMultiplyOperators<Duration, ElectricApparentPower, ElectricApparentEnergy>,
         IMultiplyOperators<Duration, ElectricCurrent, ElectricCharge>,
         IMultiplyOperators<Duration, ElectricCurrentGradient, ElectricCurrent>,
+        IMultiplyOperators<Duration, ElectricPotentialChangeRate, ElectricPotential>,
+        IMultiplyOperators<Duration, ElectricReactivePower, ElectricReactiveEnergy>,
         IMultiplyOperators<Duration, Power, Energy>,
         IMultiplyOperators<Duration, ForceChangeRate, Force>,
+        IMultiplyOperators<Duration, Force, Impulse>,
+        IMultiplyOperators<Duration, BitRate, Information>,
+        IMultiplyOperators<Duration, Irradiance, Irradiation>,
         IMultiplyOperators<Duration, Speed, Length>,
         IMultiplyOperators<Duration, MassFlow, Mass>,
         IMultiplyOperators<Duration, PressureChangeRate, Pressure>,
         IMultiplyOperators<Duration, RadiationEquivalentDoseRate, RadiationEquivalentDose>,
+        IMultiplyOperators<Duration, RatioChangeRate, Ratio>,
+        IMultiplyOperators<Duration, RotationalAcceleration, RotationalSpeed>,
         IMultiplyOperators<Duration, Acceleration, Speed>,
         IMultiplyOperators<Duration, TemperatureChangeRate, TemperatureDelta>,
         IMultiplyOperators<Duration, VolumeFlow, Volume>,
@@ -67,7 +74,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -117,7 +124,7 @@ public static DurationInfo CreateDefault(Func<IEnumerable<UnitDefinition<Duratio
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Duration"/> is [T].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Duration"/> is T.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, 1, 0, 0, 0, 0);
 
@@ -132,27 +139,49 @@ public static DurationInfo CreateDefault(Func<IEnumerable<UnitDefinition<Duratio
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{DurationUnit}"/> representing the default unit mappings for Duration.</returns>
             public static IEnumerable<UnitDefinition<DurationUnit>> GetDefaultMappings()
             {
-                yield return new (DurationUnit.Day, "Day", "Days", new BaseUnits(time: DurationUnit.Day));
-                yield return new (DurationUnit.Hour, "Hour", "Hours", new BaseUnits(time: DurationUnit.Hour));
-                yield return new (DurationUnit.JulianYear, "JulianYear", "JulianYears", new BaseUnits(time: DurationUnit.JulianYear));
-                yield return new (DurationUnit.Microsecond, "Microsecond", "Microseconds", new BaseUnits(time: DurationUnit.Microsecond));
-                yield return new (DurationUnit.Millisecond, "Millisecond", "Milliseconds", new BaseUnits(time: DurationUnit.Millisecond));
-                yield return new (DurationUnit.Minute, "Minute", "Minutes", new BaseUnits(time: DurationUnit.Minute));
-                yield return new (DurationUnit.Month30, "Month30", "Months30", new BaseUnits(time: DurationUnit.Month30));
-                yield return new (DurationUnit.Nanosecond, "Nanosecond", "Nanoseconds", new BaseUnits(time: DurationUnit.Nanosecond));
-                yield return new (DurationUnit.Picosecond, "Picosecond", "Picoseconds", new BaseUnits(time: DurationUnit.Picosecond));
+                yield return new (DurationUnit.Day, "Day", "Days", new BaseUnits(time: DurationUnit.Day),
+                     new QuantityValue(1, 86400)
+                );
+                yield return new (DurationUnit.Hour, "Hour", "Hours", new BaseUnits(time: DurationUnit.Hour),
+                     new QuantityValue(1, 3600)
+                );
+                yield return new (DurationUnit.JulianYear, "JulianYear", "JulianYears", new BaseUnits(time: DurationUnit.JulianYear),
+                     new QuantityValue(1, 31557600)
+                );
+                yield return new (DurationUnit.Microsecond, "Microsecond", "Microseconds", new BaseUnits(time: DurationUnit.Microsecond),
+                     1000000
+                );
+                yield return new (DurationUnit.Millisecond, "Millisecond", "Milliseconds", new BaseUnits(time: DurationUnit.Millisecond),
+                     1000
+                );
+                yield return new (DurationUnit.Minute, "Minute", "Minutes", new BaseUnits(time: DurationUnit.Minute),
+                     new QuantityValue(1, 60)
+                );
+                yield return new (DurationUnit.Month30, "Month30", "Months30", new BaseUnits(time: DurationUnit.Month30),
+                     new QuantityValue(1, 2592000)
+                );
+                yield return new (DurationUnit.Nanosecond, "Nanosecond", "Nanoseconds", new BaseUnits(time: DurationUnit.Nanosecond),
+                     1000000000
+                );
+                yield return new (DurationUnit.Picosecond, "Picosecond", "Picoseconds", new BaseUnits(time: DurationUnit.Picosecond),
+                     1000000000000
+                );
                 yield return new (DurationUnit.Second, "Second", "Seconds", new BaseUnits(time: DurationUnit.Second));
-                yield return new (DurationUnit.Sol, "Sol", "Sols", new BaseUnits(time: DurationUnit.Sol));
-                yield return new (DurationUnit.Week, "Week", "Weeks", new BaseUnits(time: DurationUnit.Week));
-                yield return new (DurationUnit.Year365, "Year365", "Years365", new BaseUnits(time: DurationUnit.Year365));
+                yield return new (DurationUnit.Sol, "Sol", "Sols", new BaseUnits(time: DurationUnit.Sol),
+                     new QuantityValue(250, 22193811)
+                );
+                yield return new (DurationUnit.Week, "Week", "Weeks", new BaseUnits(time: DurationUnit.Week),
+                     new QuantityValue(1, 604800)
+                );
+                yield return new (DurationUnit.Year365, "Year365", "Years365", new BaseUnits(time: DurationUnit.Year365),
+                     new QuantityValue(1, 31536000)
+                );
             }
         }
 
         static Duration()
         {
-            Info = DurationInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(DurationInfo.CreateDefault);
         }
 
         /// <summary>
@@ -160,7 +189,7 @@ static Duration()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Duration(double value, DurationUnit unit)
+        public Duration(QuantityValue value, DurationUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -174,7 +203,7 @@ public Duration(double value, DurationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Duration(double value, UnitSystem unitSystem)
+        public Duration(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -185,7 +214,8 @@ public Duration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Duration" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Duration, DurationUnit> Info { get; }
@@ -214,10 +244,8 @@ public Duration(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public DurationUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -251,112 +279,74 @@ public Duration(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Day"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Day"/>
         /// </summary>
-        public double Days => As(DurationUnit.Day);
+        public QuantityValue Days => this.As(DurationUnit.Day);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Hour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Hour"/>
         /// </summary>
-        public double Hours => As(DurationUnit.Hour);
+        public QuantityValue Hours => this.As(DurationUnit.Hour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.JulianYear"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.JulianYear"/>
         /// </summary>
-        public double JulianYears => As(DurationUnit.JulianYear);
+        public QuantityValue JulianYears => this.As(DurationUnit.JulianYear);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Microsecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Microsecond"/>
         /// </summary>
-        public double Microseconds => As(DurationUnit.Microsecond);
+        public QuantityValue Microseconds => this.As(DurationUnit.Microsecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Millisecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Millisecond"/>
         /// </summary>
-        public double Milliseconds => As(DurationUnit.Millisecond);
+        public QuantityValue Milliseconds => this.As(DurationUnit.Millisecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Minute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Minute"/>
         /// </summary>
-        public double Minutes => As(DurationUnit.Minute);
+        public QuantityValue Minutes => this.As(DurationUnit.Minute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Month30"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Month30"/>
         /// </summary>
-        public double Months30 => As(DurationUnit.Month30);
+        public QuantityValue Months30 => this.As(DurationUnit.Month30);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Nanosecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Nanosecond"/>
         /// </summary>
-        public double Nanoseconds => As(DurationUnit.Nanosecond);
+        public QuantityValue Nanoseconds => this.As(DurationUnit.Nanosecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Picosecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Picosecond"/>
         /// </summary>
-        public double Picoseconds => As(DurationUnit.Picosecond);
+        public QuantityValue Picoseconds => this.As(DurationUnit.Picosecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Second"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Second"/>
         /// </summary>
-        public double Seconds => As(DurationUnit.Second);
+        public QuantityValue Seconds => this.As(DurationUnit.Second);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Sol"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Sol"/>
         /// </summary>
-        public double Sols => As(DurationUnit.Sol);
+        public QuantityValue Sols => this.As(DurationUnit.Sol);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Week"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Week"/>
         /// </summary>
-        public double Weeks => As(DurationUnit.Week);
+        public QuantityValue Weeks => this.As(DurationUnit.Week);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DurationUnit.Year365"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DurationUnit.Year365"/>
         /// </summary>
-        public double Years365 => As(DurationUnit.Year365);
+        public QuantityValue Years365 => this.As(DurationUnit.Year365);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: DurationUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Day, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Hour, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.JulianYear, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Microsecond, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Millisecond, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Minute, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Month30, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Nanosecond, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Picosecond, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Sol, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Week, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Year365, DurationUnit.Second, quantity => quantity.ToUnit(DurationUnit.Second));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Second, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> DurationUnit
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Day, quantity => quantity.ToUnit(DurationUnit.Day));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Hour, quantity => quantity.ToUnit(DurationUnit.Hour));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.JulianYear, quantity => quantity.ToUnit(DurationUnit.JulianYear));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Microsecond, quantity => quantity.ToUnit(DurationUnit.Microsecond));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Millisecond, quantity => quantity.ToUnit(DurationUnit.Millisecond));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Minute, quantity => quantity.ToUnit(DurationUnit.Minute));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Month30, quantity => quantity.ToUnit(DurationUnit.Month30));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Nanosecond, quantity => quantity.ToUnit(DurationUnit.Nanosecond));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Picosecond, quantity => quantity.ToUnit(DurationUnit.Picosecond));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Sol, quantity => quantity.ToUnit(DurationUnit.Sol));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Week, quantity => quantity.ToUnit(DurationUnit.Week));
-            unitConverter.SetConversionFunction<Duration>(DurationUnit.Second, DurationUnit.Year365, quantity => quantity.ToUnit(DurationUnit.Year365));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -385,7 +375,7 @@ public static string GetAbbreviation(DurationUnit unit, IFormatProvider? provide
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Day"/>.
         /// </summary>
-        public static Duration FromDays(double value)
+        public static Duration FromDays(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Day);
         }
@@ -393,7 +383,7 @@ public static Duration FromDays(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Hour"/>.
         /// </summary>
-        public static Duration FromHours(double value)
+        public static Duration FromHours(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Hour);
         }
@@ -401,7 +391,7 @@ public static Duration FromHours(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.JulianYear"/>.
         /// </summary>
-        public static Duration FromJulianYears(double value)
+        public static Duration FromJulianYears(QuantityValue value)
         {
             return new Duration(value, DurationUnit.JulianYear);
         }
@@ -409,7 +399,7 @@ public static Duration FromJulianYears(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Microsecond"/>.
         /// </summary>
-        public static Duration FromMicroseconds(double value)
+        public static Duration FromMicroseconds(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Microsecond);
         }
@@ -417,7 +407,7 @@ public static Duration FromMicroseconds(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Millisecond"/>.
         /// </summary>
-        public static Duration FromMilliseconds(double value)
+        public static Duration FromMilliseconds(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Millisecond);
         }
@@ -425,7 +415,7 @@ public static Duration FromMilliseconds(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Minute"/>.
         /// </summary>
-        public static Duration FromMinutes(double value)
+        public static Duration FromMinutes(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Minute);
         }
@@ -433,7 +423,7 @@ public static Duration FromMinutes(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Month30"/>.
         /// </summary>
-        public static Duration FromMonths30(double value)
+        public static Duration FromMonths30(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Month30);
         }
@@ -441,7 +431,7 @@ public static Duration FromMonths30(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Nanosecond"/>.
         /// </summary>
-        public static Duration FromNanoseconds(double value)
+        public static Duration FromNanoseconds(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Nanosecond);
         }
@@ -449,7 +439,7 @@ public static Duration FromNanoseconds(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Picosecond"/>.
         /// </summary>
-        public static Duration FromPicoseconds(double value)
+        public static Duration FromPicoseconds(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Picosecond);
         }
@@ -457,7 +447,7 @@ public static Duration FromPicoseconds(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Second"/>.
         /// </summary>
-        public static Duration FromSeconds(double value)
+        public static Duration FromSeconds(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Second);
         }
@@ -465,7 +455,7 @@ public static Duration FromSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Sol"/>.
         /// </summary>
-        public static Duration FromSols(double value)
+        public static Duration FromSols(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Sol);
         }
@@ -473,7 +463,7 @@ public static Duration FromSols(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Week"/>.
         /// </summary>
-        public static Duration FromWeeks(double value)
+        public static Duration FromWeeks(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Week);
         }
@@ -481,7 +471,7 @@ public static Duration FromWeeks(double value)
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Year365"/>.
         /// </summary>
-        public static Duration FromYears365(double value)
+        public static Duration FromYears365(QuantityValue value)
         {
             return new Duration(value, DurationUnit.Year365);
         }
@@ -492,7 +482,7 @@ public static Duration FromYears365(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Duration unit value.</returns>
-        public static Duration From(double value, DurationUnit fromUnit)
+        public static Duration From(QuantityValue value, DurationUnit fromUnit)
         {
             return new Duration(value, fromUnit);
         }
@@ -553,10 +543,7 @@ public static Duration Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Duration Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Duration, DurationUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Duration, DurationUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -584,11 +571,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Duration result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Duration result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Duration, DurationUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Duration, DurationUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -609,7 +592,7 @@ public static DurationUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -620,7 +603,7 @@ public static DurationUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.DurationUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.DurationUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out DurationUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -635,7 +618,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out DurationUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out DurationUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -654,35 +637,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Duration"/> from adding two <see cref="Duration"/>.</summary>
         public static Duration operator +(Duration left, Duration right)
         {
-            return new Duration(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Duration(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Duration"/> from subtracting two <see cref="Duration"/>.</summary>
         public static Duration operator -(Duration left, Duration right)
         {
-            return new Duration(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Duration(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Duration"/> from multiplying value and <see cref="Duration"/>.</summary>
-        public static Duration operator *(double left, Duration right)
+        public static Duration operator *(QuantityValue left, Duration right)
         {
             return new Duration(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Duration"/> from multiplying value and <see cref="Duration"/>.</summary>
-        public static Duration operator *(Duration left, double right)
+        public static Duration operator *(Duration left, QuantityValue right)
         {
             return new Duration(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Duration"/> from dividing <see cref="Duration"/> by value.</summary>
-        public static Duration operator /(Duration left, double right)
+        public static Duration operator /(Duration left, QuantityValue right)
         {
             return new Duration(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Duration"/> by <see cref="Duration"/>.</summary>
-        public static double operator /(Duration left, Duration right)
+        public static QuantityValue operator /(Duration left, Duration right)
         {
             return left.Seconds / right.Seconds;
         }
@@ -691,6 +674,13 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Calculates the inverse of this quantity.</summary>
+        /// <returns>The corresponding inverse quantity, <see cref="Frequency"/>.</returns>
+        public Frequency Inverse()
+        {
+            return UnitConverter.Default.ConvertTo(Value, Unit, Frequency.Info);
+        }
+
         /// <summary>Get <see cref="Acceleration"/> from <see cref="Duration"/> * <see cref="Jerk"/>.</summary>
         public static Acceleration operator *(Duration duration, Jerk jerk)
         {
@@ -715,6 +705,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Area.FromSquareMeters(duration.Seconds * kinematicViscosity.SquareMetersPerSecond);
         }
 
+        /// <summary>Get <see cref="ElectricApparentEnergy"/> from <see cref="Duration"/> * <see cref="ElectricApparentPower"/>.</summary>
+        public static ElectricApparentEnergy operator *(Duration duration, ElectricApparentPower electricApparentPower)
+        {
+            return ElectricApparentEnergy.FromVoltampereHours(duration.Hours * electricApparentPower.Voltamperes);
+        }
+
         /// <summary>Get <see cref="ElectricCharge"/> from <see cref="Duration"/> * <see cref="ElectricCurrent"/>.</summary>
         public static ElectricCharge operator *(Duration duration, ElectricCurrent electricCurrent)
         {
@@ -727,6 +723,18 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return ElectricCurrent.FromAmperes(duration.Seconds * electricCurrentGradient.AmperesPerSecond);
         }
 
+        /// <summary>Get <see cref="ElectricPotential"/> from <see cref="Duration"/> * <see cref="ElectricPotentialChangeRate"/>.</summary>
+        public static ElectricPotential operator *(Duration duration, ElectricPotentialChangeRate electricPotentialChangeRate)
+        {
+            return ElectricPotential.FromVolts(duration.Seconds * electricPotentialChangeRate.VoltsPerSecond);
+        }
+
+        /// <summary>Get <see cref="ElectricReactiveEnergy"/> from <see cref="Duration"/> * <see cref="ElectricReactivePower"/>.</summary>
+        public static ElectricReactiveEnergy operator *(Duration duration, ElectricReactivePower electricReactivePower)
+        {
+            return ElectricReactiveEnergy.FromVoltampereReactiveHours(duration.Hours * electricReactivePower.VoltamperesReactive);
+        }
+
         /// <summary>Get <see cref="Energy"/> from <see cref="Duration"/> * <see cref="Power"/>.</summary>
         public static Energy operator *(Duration duration, Power power)
         {
@@ -739,6 +747,24 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Force.FromNewtons(duration.Seconds * forceChangeRate.NewtonsPerSecond);
         }
 
+        /// <summary>Get <see cref="Impulse"/> from <see cref="Duration"/> * <see cref="Force"/>.</summary>
+        public static Impulse operator *(Duration duration, Force force)
+        {
+            return Impulse.FromNewtonSeconds(duration.Seconds * force.Newtons);
+        }
+
+        /// <summary>Get <see cref="Information"/> from <see cref="Duration"/> * <see cref="BitRate"/>.</summary>
+        public static Information operator *(Duration duration, BitRate bitRate)
+        {
+            return Information.FromBits(duration.Seconds * bitRate.BitsPerSecond);
+        }
+
+        /// <summary>Get <see cref="Irradiation"/> from <see cref="Duration"/> * <see cref="Irradiance"/>.</summary>
+        public static Irradiation operator *(Duration duration, Irradiance irradiance)
+        {
+            return Irradiation.FromJoulesPerSquareMeter(duration.Seconds * irradiance.WattsPerSquareMeter);
+        }
+
         /// <summary>Get <see cref="Length"/> from <see cref="Duration"/> * <see cref="Speed"/>.</summary>
         public static Length operator *(Duration duration, Speed speed)
         {
@@ -763,6 +789,18 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return RadiationEquivalentDose.FromSieverts(duration.Hours * radiationEquivalentDoseRate.SievertsPerHour);
         }
 
+        /// <summary>Get <see cref="Ratio"/> from <see cref="Duration"/> * <see cref="RatioChangeRate"/>.</summary>
+        public static Ratio operator *(Duration duration, RatioChangeRate ratioChangeRate)
+        {
+            return Ratio.FromDecimalFractions(duration.Seconds * ratioChangeRate.DecimalFractionsPerSecond);
+        }
+
+        /// <summary>Get <see cref="RotationalSpeed"/> from <see cref="Duration"/> * <see cref="RotationalAcceleration"/>.</summary>
+        public static RotationalSpeed operator *(Duration duration, RotationalAcceleration rotationalAcceleration)
+        {
+            return RotationalSpeed.FromRadiansPerSecond(duration.Seconds * rotationalAcceleration.RadiansPerSecondSquared);
+        }
+
         /// <summary>Get <see cref="Speed"/> from <see cref="Duration"/> * <see cref="Acceleration"/>.</summary>
         public static Speed operator *(Duration duration, Acceleration acceleration)
         {
@@ -788,97 +826,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Duration left, Duration right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Duration left, Duration right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Duration left, Duration right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Duration left, Duration right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Duration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Duration other, Duration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Duration"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Duration)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Duration left, Duration right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Duration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Duration other, Duration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Duration"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Duration,Duration)"/>.
+        ///     See that operator (and <see cref="Equals(Duration)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Duration left, Duration right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Duration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Duration other, Duration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Duration"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Duration"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Duration"/>, this method delegates to
+        ///     <see cref="Equals(Duration)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Duration otherQuantity))
+            if (obj is not Duration otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Duration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Duration other, Duration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Duration"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Duration other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Duration.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Duration), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Duration"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Duration)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Duration otherQuantity)) throw new ArgumentException("Expected type Duration.", nameof(obj));
+            if (obj is not Duration otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Duration>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Duration"/> with another <see cref="Duration"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Duration"/> with another <see cref="Duration"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -890,153 +942,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Duration other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(DurationUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<DurationUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Duration to another Duration with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Duration with the specified unit.</returns>
-        public Duration ToUnit(DurationUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="Duration"/> to another <see cref="Duration"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Duration with the specified unit.</returns>
-        public Duration ToUnit(DurationUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Duration), Unit, typeof(Duration), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Duration)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Duration"/> to another <see cref="Duration"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Duration"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(DurationUnit unit, [NotNullWhen(true)] out Duration? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Duration? convertedOrNull = (Unit, unit) switch
-            {
-                // DurationUnit -> BaseUnit
-                (DurationUnit.Day, DurationUnit.Second) => new Duration(_value * 24 * 3600, DurationUnit.Second),
-                (DurationUnit.Hour, DurationUnit.Second) => new Duration(_value * 3600, DurationUnit.Second),
-                (DurationUnit.JulianYear, DurationUnit.Second) => new Duration(_value * 365.25 * 24 * 3600, DurationUnit.Second),
-                (DurationUnit.Microsecond, DurationUnit.Second) => new Duration((_value) * 1e-6d, DurationUnit.Second),
-                (DurationUnit.Millisecond, DurationUnit.Second) => new Duration((_value) * 1e-3d, DurationUnit.Second),
-                (DurationUnit.Minute, DurationUnit.Second) => new Duration(_value * 60, DurationUnit.Second),
-                (DurationUnit.Month30, DurationUnit.Second) => new Duration(_value * 30 * 24 * 3600, DurationUnit.Second),
-                (DurationUnit.Nanosecond, DurationUnit.Second) => new Duration((_value) * 1e-9d, DurationUnit.Second),
-                (DurationUnit.Picosecond, DurationUnit.Second) => new Duration((_value) * 1e-12d, DurationUnit.Second),
-                (DurationUnit.Sol, DurationUnit.Second) => new Duration(_value * 88775.244, DurationUnit.Second),
-                (DurationUnit.Week, DurationUnit.Second) => new Duration(_value * 7 * 24 * 3600, DurationUnit.Second),
-                (DurationUnit.Year365, DurationUnit.Second) => new Duration(_value * 365 * 24 * 3600, DurationUnit.Second),
-
-                // BaseUnit -> DurationUnit
-                (DurationUnit.Second, DurationUnit.Day) => new Duration(_value / (24 * 3600), DurationUnit.Day),
-                (DurationUnit.Second, DurationUnit.Hour) => new Duration(_value / 3600, DurationUnit.Hour),
-                (DurationUnit.Second, DurationUnit.JulianYear) => new Duration(_value / (365.25 * 24 * 3600), DurationUnit.JulianYear),
-                (DurationUnit.Second, DurationUnit.Microsecond) => new Duration((_value) / 1e-6d, DurationUnit.Microsecond),
-                (DurationUnit.Second, DurationUnit.Millisecond) => new Duration((_value) / 1e-3d, DurationUnit.Millisecond),
-                (DurationUnit.Second, DurationUnit.Minute) => new Duration(_value / 60, DurationUnit.Minute),
-                (DurationUnit.Second, DurationUnit.Month30) => new Duration(_value / (30 * 24 * 3600), DurationUnit.Month30),
-                (DurationUnit.Second, DurationUnit.Nanosecond) => new Duration((_value) / 1e-9d, DurationUnit.Nanosecond),
-                (DurationUnit.Second, DurationUnit.Picosecond) => new Duration((_value) / 1e-12d, DurationUnit.Picosecond),
-                (DurationUnit.Second, DurationUnit.Sol) => new Duration(_value / 88775.244, DurationUnit.Sol),
-                (DurationUnit.Second, DurationUnit.Week) => new Duration(_value / (7 * 24 * 3600), DurationUnit.Week),
-                (DurationUnit.Second, DurationUnit.Year365) => new Duration(_value / (365 * 24 * 3600), DurationUnit.Year365),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not DurationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DurationUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is DurationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DurationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<DurationUnit> IQuantity<DurationUnit>.ToUnit(DurationUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1050,11 +958,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
index 7f0bc8028f..dde593ef6f 100644
--- a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Viscosity#Dynamic_.28shear.29_viscosity
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct DynamicViscosity :
-        IArithmeticQuantity<DynamicViscosity, DynamicViscosityUnit>,
+        ILinearQuantity<DynamicViscosity, DynamicViscosityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<DynamicViscosity, DynamicViscosity, double>,
+        IDivisionOperators<DynamicViscosity, DynamicViscosity, QuantityValue>,
         IDivisionOperators<DynamicViscosity, KinematicViscosity, Density>,
         IDivisionOperators<DynamicViscosity, Density, KinematicViscosity>,
         IComparisonOperators<DynamicViscosity, DynamicViscosity, bool>,
@@ -57,7 +56,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -107,7 +106,7 @@ public static DynamicViscosityInfo CreateDefault(Func<IEnumerable<UnitDefinition
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="DynamicViscosity"/> is [T^-1][L^-1][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="DynamicViscosity"/> is T^-1L^-1M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 1, -1, 0, 0, 0, 0);
 
@@ -122,24 +121,40 @@ public static DynamicViscosityInfo CreateDefault(Func<IEnumerable<UnitDefinition
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{DynamicViscosityUnit}"/> representing the default unit mappings for DynamicViscosity.</returns>
             public static IEnumerable<UnitDefinition<DynamicViscosityUnit>> GetDefaultMappings()
             {
-                yield return new (DynamicViscosityUnit.Centipoise, "Centipoise", "Centipoise", BaseUnits.Undefined);
-                yield return new (DynamicViscosityUnit.MicropascalSecond, "MicropascalSecond", "MicropascalSeconds", BaseUnits.Undefined);
-                yield return new (DynamicViscosityUnit.MillipascalSecond, "MillipascalSecond", "MillipascalSeconds", BaseUnits.Undefined);
+                yield return new (DynamicViscosityUnit.Centipoise, "Centipoise", "Centipoise", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (DynamicViscosityUnit.MicropascalSecond, "MicropascalSecond", "MicropascalSeconds", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (DynamicViscosityUnit.MillipascalSecond, "MillipascalSecond", "MillipascalSeconds", BaseUnits.Undefined,
+                     1000
+                );
                 yield return new (DynamicViscosityUnit.NewtonSecondPerMeterSquared, "NewtonSecondPerMeterSquared", "NewtonSecondsPerMeterSquared", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (DynamicViscosityUnit.PascalSecond, "PascalSecond", "PascalSeconds", BaseUnits.Undefined);
-                yield return new (DynamicViscosityUnit.Poise, "Poise", "Poise", BaseUnits.Undefined);
-                yield return new (DynamicViscosityUnit.PoundForceSecondPerSquareFoot, "PoundForceSecondPerSquareFoot", "PoundsForceSecondPerSquareFoot", BaseUnits.Undefined);
-                yield return new (DynamicViscosityUnit.PoundForceSecondPerSquareInch, "PoundForceSecondPerSquareInch", "PoundsForceSecondPerSquareInch", BaseUnits.Undefined);
-                yield return new (DynamicViscosityUnit.PoundPerFootSecond, "PoundPerFootSecond", "PoundsPerFootSecond", BaseUnits.Undefined);
-                yield return new (DynamicViscosityUnit.Reyn, "Reyn", "Reyns", BaseUnits.Undefined);
+                yield return new (DynamicViscosityUnit.PascalSecond, "PascalSecond", "PascalSeconds", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (DynamicViscosityUnit.Poise, "Poise", "Poise", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (DynamicViscosityUnit.PoundForceSecondPerSquareFoot, "PoundForceSecondPerSquareFoot", "PoundsForceSecondPerSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(185806080000, 8896443230521)
+                );
+                yield return new (DynamicViscosityUnit.PoundForceSecondPerSquareInch, "PoundForceSecondPerSquareInch", "PoundsForceSecondPerSquareInch", BaseUnits.Undefined,
+                     new QuantityValue(1290320000, 8896443230521)
+                );
+                yield return new (DynamicViscosityUnit.PoundPerFootSecond, "PoundPerFootSecond", "PoundsPerFootSecond", BaseUnits.Undefined,
+                     new QuantityValue(30480000, 45359237)
+                );
+                yield return new (DynamicViscosityUnit.Reyn, "Reyn", "Reyns", BaseUnits.Undefined,
+                     new QuantityValue(1290320000, 8896443230521)
+                );
             }
         }
 
         static DynamicViscosity()
         {
-            Info = DynamicViscosityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(DynamicViscosityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -147,7 +162,7 @@ static DynamicViscosity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public DynamicViscosity(double value, DynamicViscosityUnit unit)
+        public DynamicViscosity(QuantityValue value, DynamicViscosityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -161,7 +176,7 @@ public DynamicViscosity(double value, DynamicViscosityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public DynamicViscosity(double value, UnitSystem unitSystem)
+        public DynamicViscosity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -172,7 +187,8 @@ public DynamicViscosity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="DynamicViscosity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<DynamicViscosity, DynamicViscosityUnit> Info { get; }
@@ -201,10 +217,8 @@ public DynamicViscosity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public DynamicViscosityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -238,91 +252,59 @@ public DynamicViscosity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.Centipoise"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DynamicViscosityUnit.Centipoise"/>
         /// </summary>
-        public double Centipoise => As(DynamicViscosityUnit.Centipoise);
+        public QuantityValue Centipoise => this.As(DynamicViscosityUnit.Centipoise);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.MicropascalSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DynamicViscosityUnit.MicropascalSecond"/>
         /// </summary>
-        public double MicropascalSeconds => As(DynamicViscosityUnit.MicropascalSecond);
+        public QuantityValue MicropascalSeconds => this.As(DynamicViscosityUnit.MicropascalSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.MillipascalSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DynamicViscosityUnit.MillipascalSecond"/>
         /// </summary>
-        public double MillipascalSeconds => As(DynamicViscosityUnit.MillipascalSecond);
+        public QuantityValue MillipascalSeconds => this.As(DynamicViscosityUnit.MillipascalSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.NewtonSecondPerMeterSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DynamicViscosityUnit.NewtonSecondPerMeterSquared"/>
         /// </summary>
-        public double NewtonSecondsPerMeterSquared => As(DynamicViscosityUnit.NewtonSecondPerMeterSquared);
+        public QuantityValue NewtonSecondsPerMeterSquared => this.As(DynamicViscosityUnit.NewtonSecondPerMeterSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PascalSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PascalSecond"/>
         /// </summary>
-        public double PascalSeconds => As(DynamicViscosityUnit.PascalSecond);
+        public QuantityValue PascalSeconds => this.As(DynamicViscosityUnit.PascalSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.Poise"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DynamicViscosityUnit.Poise"/>
         /// </summary>
-        public double Poise => As(DynamicViscosityUnit.Poise);
+        public QuantityValue Poise => this.As(DynamicViscosityUnit.Poise);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareFoot"/>
         /// </summary>
-        public double PoundsForceSecondPerSquareFoot => As(DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
+        public QuantityValue PoundsForceSecondPerSquareFoot => this.As(DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareInch"/>
         /// </summary>
-        public double PoundsForceSecondPerSquareInch => As(DynamicViscosityUnit.PoundForceSecondPerSquareInch);
+        public QuantityValue PoundsForceSecondPerSquareInch => this.As(DynamicViscosityUnit.PoundForceSecondPerSquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PoundPerFootSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DynamicViscosityUnit.PoundPerFootSecond"/>
         /// </summary>
-        public double PoundsPerFootSecond => As(DynamicViscosityUnit.PoundPerFootSecond);
+        public QuantityValue PoundsPerFootSecond => this.As(DynamicViscosityUnit.PoundPerFootSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="DynamicViscosityUnit.Reyn"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="DynamicViscosityUnit.Reyn"/>
         /// </summary>
-        public double Reyns => As(DynamicViscosityUnit.Reyn);
+        public QuantityValue Reyns => this.As(DynamicViscosityUnit.Reyn);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: DynamicViscosityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.Centipoise, DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity => quantity.ToUnit(DynamicViscosityUnit.NewtonSecondPerMeterSquared));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.MicropascalSecond, DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity => quantity.ToUnit(DynamicViscosityUnit.NewtonSecondPerMeterSquared));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.MillipascalSecond, DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity => quantity.ToUnit(DynamicViscosityUnit.NewtonSecondPerMeterSquared));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.PascalSecond, DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity => quantity.ToUnit(DynamicViscosityUnit.NewtonSecondPerMeterSquared));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.Poise, DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity => quantity.ToUnit(DynamicViscosityUnit.NewtonSecondPerMeterSquared));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.PoundForceSecondPerSquareFoot, DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity => quantity.ToUnit(DynamicViscosityUnit.NewtonSecondPerMeterSquared));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.PoundForceSecondPerSquareInch, DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity => quantity.ToUnit(DynamicViscosityUnit.NewtonSecondPerMeterSquared));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.PoundPerFootSecond, DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity => quantity.ToUnit(DynamicViscosityUnit.NewtonSecondPerMeterSquared));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.Reyn, DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity => quantity.ToUnit(DynamicViscosityUnit.NewtonSecondPerMeterSquared));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.NewtonSecondPerMeterSquared, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> DynamicViscosityUnit
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.Centipoise, quantity => quantity.ToUnit(DynamicViscosityUnit.Centipoise));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.MicropascalSecond, quantity => quantity.ToUnit(DynamicViscosityUnit.MicropascalSecond));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.MillipascalSecond, quantity => quantity.ToUnit(DynamicViscosityUnit.MillipascalSecond));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.PascalSecond, quantity => quantity.ToUnit(DynamicViscosityUnit.PascalSecond));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.Poise, quantity => quantity.ToUnit(DynamicViscosityUnit.Poise));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.PoundForceSecondPerSquareFoot, quantity => quantity.ToUnit(DynamicViscosityUnit.PoundForceSecondPerSquareFoot));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.PoundForceSecondPerSquareInch, quantity => quantity.ToUnit(DynamicViscosityUnit.PoundForceSecondPerSquareInch));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.PoundPerFootSecond, quantity => quantity.ToUnit(DynamicViscosityUnit.PoundPerFootSecond));
-            unitConverter.SetConversionFunction<DynamicViscosity>(DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.Reyn, quantity => quantity.ToUnit(DynamicViscosityUnit.Reyn));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -351,7 +333,7 @@ public static string GetAbbreviation(DynamicViscosityUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Centipoise"/>.
         /// </summary>
-        public static DynamicViscosity FromCentipoise(double value)
+        public static DynamicViscosity FromCentipoise(QuantityValue value)
         {
             return new DynamicViscosity(value, DynamicViscosityUnit.Centipoise);
         }
@@ -359,7 +341,7 @@ public static DynamicViscosity FromCentipoise(double value)
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.MicropascalSecond"/>.
         /// </summary>
-        public static DynamicViscosity FromMicropascalSeconds(double value)
+        public static DynamicViscosity FromMicropascalSeconds(QuantityValue value)
         {
             return new DynamicViscosity(value, DynamicViscosityUnit.MicropascalSecond);
         }
@@ -367,7 +349,7 @@ public static DynamicViscosity FromMicropascalSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.MillipascalSecond"/>.
         /// </summary>
-        public static DynamicViscosity FromMillipascalSeconds(double value)
+        public static DynamicViscosity FromMillipascalSeconds(QuantityValue value)
         {
             return new DynamicViscosity(value, DynamicViscosityUnit.MillipascalSecond);
         }
@@ -375,7 +357,7 @@ public static DynamicViscosity FromMillipascalSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.NewtonSecondPerMeterSquared"/>.
         /// </summary>
-        public static DynamicViscosity FromNewtonSecondsPerMeterSquared(double value)
+        public static DynamicViscosity FromNewtonSecondsPerMeterSquared(QuantityValue value)
         {
             return new DynamicViscosity(value, DynamicViscosityUnit.NewtonSecondPerMeterSquared);
         }
@@ -383,7 +365,7 @@ public static DynamicViscosity FromNewtonSecondsPerMeterSquared(double value)
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PascalSecond"/>.
         /// </summary>
-        public static DynamicViscosity FromPascalSeconds(double value)
+        public static DynamicViscosity FromPascalSeconds(QuantityValue value)
         {
             return new DynamicViscosity(value, DynamicViscosityUnit.PascalSecond);
         }
@@ -391,7 +373,7 @@ public static DynamicViscosity FromPascalSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Poise"/>.
         /// </summary>
-        public static DynamicViscosity FromPoise(double value)
+        public static DynamicViscosity FromPoise(QuantityValue value)
         {
             return new DynamicViscosity(value, DynamicViscosityUnit.Poise);
         }
@@ -399,7 +381,7 @@ public static DynamicViscosity FromPoise(double value)
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareFoot"/>.
         /// </summary>
-        public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(double value)
+        public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(QuantityValue value)
         {
             return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
         }
@@ -407,7 +389,7 @@ public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareInch"/>.
         /// </summary>
-        public static DynamicViscosity FromPoundsForceSecondPerSquareInch(double value)
+        public static DynamicViscosity FromPoundsForceSecondPerSquareInch(QuantityValue value)
         {
             return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareInch);
         }
@@ -415,7 +397,7 @@ public static DynamicViscosity FromPoundsForceSecondPerSquareInch(double value)
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundPerFootSecond"/>.
         /// </summary>
-        public static DynamicViscosity FromPoundsPerFootSecond(double value)
+        public static DynamicViscosity FromPoundsPerFootSecond(QuantityValue value)
         {
             return new DynamicViscosity(value, DynamicViscosityUnit.PoundPerFootSecond);
         }
@@ -423,7 +405,7 @@ public static DynamicViscosity FromPoundsPerFootSecond(double value)
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Reyn"/>.
         /// </summary>
-        public static DynamicViscosity FromReyns(double value)
+        public static DynamicViscosity FromReyns(QuantityValue value)
         {
             return new DynamicViscosity(value, DynamicViscosityUnit.Reyn);
         }
@@ -434,7 +416,7 @@ public static DynamicViscosity FromReyns(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>DynamicViscosity unit value.</returns>
-        public static DynamicViscosity From(double value, DynamicViscosityUnit fromUnit)
+        public static DynamicViscosity From(QuantityValue value, DynamicViscosityUnit fromUnit)
         {
             return new DynamicViscosity(value, fromUnit);
         }
@@ -495,10 +477,7 @@ public static DynamicViscosity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static DynamicViscosity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<DynamicViscosity, DynamicViscosityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<DynamicViscosity, DynamicViscosityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -526,11 +505,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out DynamicViscosity
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out DynamicViscosity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<DynamicViscosity, DynamicViscosityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<DynamicViscosity, DynamicViscosityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -551,7 +526,7 @@ public static DynamicViscosityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -562,7 +537,7 @@ public static DynamicViscosityUnit ParseUnit(string str, IFormatProvider? provid
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.DynamicViscosityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.DynamicViscosityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out DynamicViscosityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -577,7 +552,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out DynamicVisco
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out DynamicViscosityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -596,35 +571,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="DynamicViscosity"/> from adding two <see cref="DynamicViscosity"/>.</summary>
         public static DynamicViscosity operator +(DynamicViscosity left, DynamicViscosity right)
         {
-            return new DynamicViscosity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new DynamicViscosity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="DynamicViscosity"/> from subtracting two <see cref="DynamicViscosity"/>.</summary>
         public static DynamicViscosity operator -(DynamicViscosity left, DynamicViscosity right)
         {
-            return new DynamicViscosity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new DynamicViscosity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="DynamicViscosity"/> from multiplying value and <see cref="DynamicViscosity"/>.</summary>
-        public static DynamicViscosity operator *(double left, DynamicViscosity right)
+        public static DynamicViscosity operator *(QuantityValue left, DynamicViscosity right)
         {
             return new DynamicViscosity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="DynamicViscosity"/> from multiplying value and <see cref="DynamicViscosity"/>.</summary>
-        public static DynamicViscosity operator *(DynamicViscosity left, double right)
+        public static DynamicViscosity operator *(DynamicViscosity left, QuantityValue right)
         {
             return new DynamicViscosity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="DynamicViscosity"/> from dividing <see cref="DynamicViscosity"/> by value.</summary>
-        public static DynamicViscosity operator /(DynamicViscosity left, double right)
+        public static DynamicViscosity operator /(DynamicViscosity left, QuantityValue right)
         {
             return new DynamicViscosity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="DynamicViscosity"/> by <see cref="DynamicViscosity"/>.</summary>
-        public static double operator /(DynamicViscosity left, DynamicViscosity right)
+        public static QuantityValue operator /(DynamicViscosity left, DynamicViscosity right)
         {
             return left.NewtonSecondsPerMeterSquared / right.NewtonSecondsPerMeterSquared;
         }
@@ -652,97 +627,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(DynamicViscosity left, DynamicViscosity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(DynamicViscosity left, DynamicViscosity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(DynamicViscosity left, DynamicViscosity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(DynamicViscosity left, DynamicViscosity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="DynamicViscosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(DynamicViscosity other, DynamicViscosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="DynamicViscosity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(DynamicViscosity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(DynamicViscosity left, DynamicViscosity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="DynamicViscosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(DynamicViscosity other, DynamicViscosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="DynamicViscosity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(DynamicViscosity,DynamicViscosity)"/>.
+        ///     See that operator (and <see cref="Equals(DynamicViscosity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(DynamicViscosity left, DynamicViscosity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="DynamicViscosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(DynamicViscosity other, DynamicViscosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="DynamicViscosity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="DynamicViscosity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="DynamicViscosity"/>, this method delegates to
+        ///     <see cref="Equals(DynamicViscosity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is DynamicViscosity otherQuantity))
+            if (obj is not DynamicViscosity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="DynamicViscosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(DynamicViscosity other, DynamicViscosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="DynamicViscosity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(DynamicViscosity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current DynamicViscosity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(DynamicViscosity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="DynamicViscosity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(DynamicViscosity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is DynamicViscosity otherQuantity)) throw new ArgumentException("Expected type DynamicViscosity.", nameof(obj));
+            if (obj is not DynamicViscosity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<DynamicViscosity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="DynamicViscosity"/> with another <see cref="DynamicViscosity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="DynamicViscosity"/> with another <see cref="DynamicViscosity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -754,147 +743,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(DynamicViscosity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(DynamicViscosityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<DynamicViscosityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this DynamicViscosity to another DynamicViscosity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A DynamicViscosity with the specified unit.</returns>
-        public DynamicViscosity ToUnit(DynamicViscosityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="DynamicViscosity"/> to another <see cref="DynamicViscosity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A DynamicViscosity with the specified unit.</returns>
-        public DynamicViscosity ToUnit(DynamicViscosityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(DynamicViscosity), Unit, typeof(DynamicViscosity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (DynamicViscosity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="DynamicViscosity"/> to another <see cref="DynamicViscosity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="DynamicViscosity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(DynamicViscosityUnit unit, [NotNullWhen(true)] out DynamicViscosity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            DynamicViscosity? convertedOrNull = (Unit, unit) switch
-            {
-                // DynamicViscosityUnit -> BaseUnit
-                (DynamicViscosityUnit.Centipoise, DynamicViscosityUnit.NewtonSecondPerMeterSquared) => new DynamicViscosity((_value / 10) * 1e-2d, DynamicViscosityUnit.NewtonSecondPerMeterSquared),
-                (DynamicViscosityUnit.MicropascalSecond, DynamicViscosityUnit.NewtonSecondPerMeterSquared) => new DynamicViscosity((_value) * 1e-6d, DynamicViscosityUnit.NewtonSecondPerMeterSquared),
-                (DynamicViscosityUnit.MillipascalSecond, DynamicViscosityUnit.NewtonSecondPerMeterSquared) => new DynamicViscosity((_value) * 1e-3d, DynamicViscosityUnit.NewtonSecondPerMeterSquared),
-                (DynamicViscosityUnit.PascalSecond, DynamicViscosityUnit.NewtonSecondPerMeterSquared) => new DynamicViscosity(_value, DynamicViscosityUnit.NewtonSecondPerMeterSquared),
-                (DynamicViscosityUnit.Poise, DynamicViscosityUnit.NewtonSecondPerMeterSquared) => new DynamicViscosity(_value / 10, DynamicViscosityUnit.NewtonSecondPerMeterSquared),
-                (DynamicViscosityUnit.PoundForceSecondPerSquareFoot, DynamicViscosityUnit.NewtonSecondPerMeterSquared) => new DynamicViscosity(_value * 4.4482216152605 / 9.290304e-2, DynamicViscosityUnit.NewtonSecondPerMeterSquared),
-                (DynamicViscosityUnit.PoundForceSecondPerSquareInch, DynamicViscosityUnit.NewtonSecondPerMeterSquared) => new DynamicViscosity(_value * 4.4482216152605 / 0.00064516, DynamicViscosityUnit.NewtonSecondPerMeterSquared),
-                (DynamicViscosityUnit.PoundPerFootSecond, DynamicViscosityUnit.NewtonSecondPerMeterSquared) => new DynamicViscosity(_value * 0.45359237 / 0.3048, DynamicViscosityUnit.NewtonSecondPerMeterSquared),
-                (DynamicViscosityUnit.Reyn, DynamicViscosityUnit.NewtonSecondPerMeterSquared) => new DynamicViscosity(_value * 4.4482216152605 / 0.00064516, DynamicViscosityUnit.NewtonSecondPerMeterSquared),
-
-                // BaseUnit -> DynamicViscosityUnit
-                (DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.Centipoise) => new DynamicViscosity((_value * 10) / 1e-2d, DynamicViscosityUnit.Centipoise),
-                (DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.MicropascalSecond) => new DynamicViscosity((_value) / 1e-6d, DynamicViscosityUnit.MicropascalSecond),
-                (DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.MillipascalSecond) => new DynamicViscosity((_value) / 1e-3d, DynamicViscosityUnit.MillipascalSecond),
-                (DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.PascalSecond) => new DynamicViscosity(_value, DynamicViscosityUnit.PascalSecond),
-                (DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.Poise) => new DynamicViscosity(_value * 10, DynamicViscosityUnit.Poise),
-                (DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.PoundForceSecondPerSquareFoot) => new DynamicViscosity(_value * 9.290304e-2 / 4.4482216152605, DynamicViscosityUnit.PoundForceSecondPerSquareFoot),
-                (DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.PoundForceSecondPerSquareInch) => new DynamicViscosity(_value * 0.00064516 / 4.4482216152605, DynamicViscosityUnit.PoundForceSecondPerSquareInch),
-                (DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.PoundPerFootSecond) => new DynamicViscosity(_value * 0.3048 / 0.45359237, DynamicViscosityUnit.PoundPerFootSecond),
-                (DynamicViscosityUnit.NewtonSecondPerMeterSquared, DynamicViscosityUnit.Reyn) => new DynamicViscosity(_value * 0.00064516 / 4.4482216152605, DynamicViscosityUnit.Reyn),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not DynamicViscosityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DynamicViscosityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is DynamicViscosityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DynamicViscosityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<DynamicViscosityUnit> IQuantity<DynamicViscosityUnit>.ToUnit(DynamicViscosityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -908,11 +759,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
index a0f4670b56..778fcfcbb9 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -39,11 +37,12 @@ namespace UnitsNet
     /// </remarks>
     [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")]
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricAdmittance :
-        IArithmeticQuantity<ElectricAdmittance, ElectricAdmittanceUnit>,
+        ILinearQuantity<ElectricAdmittance, ElectricAdmittanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricAdmittance, ElectricAdmittance, double>,
+        IDivisionOperators<ElectricAdmittance, ElectricAdmittance, QuantityValue>,
         IComparisonOperators<ElectricAdmittance, ElectricAdmittance, bool>,
         IParsable<ElectricAdmittance>,
 #endif
@@ -56,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -106,7 +105,7 @@ public static ElectricAdmittanceInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricAdmittance"/> is [T^3][L^-2][M^-1][I^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricAdmittance"/> is T^3L^-2M^-1I^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0);
 
@@ -121,30 +120,58 @@ public static ElectricAdmittanceInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricAdmittanceUnit}"/> representing the default unit mappings for ElectricAdmittance.</returns>
             public static IEnumerable<UnitDefinition<ElectricAdmittanceUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricAdmittanceUnit.Gigamho, "Gigamho", "Gigamhos", BaseUnits.Undefined);
-                yield return new (ElectricAdmittanceUnit.Gigasiemens, "Gigasiemens", "Gigasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricAdmittanceUnit.Kilomho, "Kilomho", "Kilomhos", BaseUnits.Undefined);
-                yield return new (ElectricAdmittanceUnit.Kilosiemens, "Kilosiemens", "Kilosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricAdmittanceUnit.Megamho, "Megamho", "Megamhos", BaseUnits.Undefined);
-                yield return new (ElectricAdmittanceUnit.Megasiemens, "Megasiemens", "Megasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricAdmittanceUnit.Mho, "Mho", "Mhos", BaseUnits.Undefined);
-                yield return new (ElectricAdmittanceUnit.Micromho, "Micromho", "Micromhos", BaseUnits.Undefined);
-                yield return new (ElectricAdmittanceUnit.Microsiemens, "Microsiemens", "Microsiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricAdmittanceUnit.Millimho, "Millimho", "Millimhos", BaseUnits.Undefined);
-                yield return new (ElectricAdmittanceUnit.Millisiemens, "Millisiemens", "Millisiemens", BaseUnits.Undefined);
-                yield return new (ElectricAdmittanceUnit.Nanomho, "Nanomho", "Nanomhos", BaseUnits.Undefined);
-                yield return new (ElectricAdmittanceUnit.Nanosiemens, "Nanosiemens", "Nanosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricAdmittanceUnit.Gigamho, "Gigamho", "Gigamhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricAdmittanceUnit.Gigasiemens, "Gigasiemens", "Gigasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricAdmittanceUnit.Kilomho, "Kilomho", "Kilomhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricAdmittanceUnit.Kilosiemens, "Kilosiemens", "Kilosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricAdmittanceUnit.Megamho, "Megamho", "Megamhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricAdmittanceUnit.Megasiemens, "Megasiemens", "Megasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricAdmittanceUnit.Mho, "Mho", "Mhos", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (ElectricAdmittanceUnit.Micromho, "Micromho", "Micromhos", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (ElectricAdmittanceUnit.Microsiemens, "Microsiemens", "Microsiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     1000000
+                );
+                yield return new (ElectricAdmittanceUnit.Millimho, "Millimho", "Millimhos", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (ElectricAdmittanceUnit.Millisiemens, "Millisiemens", "Millisiemens", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (ElectricAdmittanceUnit.Nanomho, "Nanomho", "Nanomhos", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (ElectricAdmittanceUnit.Nanosiemens, "Nanosiemens", "Nanosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere),
+                     1000000000
+                );
                 yield return new (ElectricAdmittanceUnit.Siemens, "Siemens", "Siemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricAdmittanceUnit.Teramho, "Teramho", "Teramhos", BaseUnits.Undefined);
-                yield return new (ElectricAdmittanceUnit.Terasiemens, "Terasiemens", "Terasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricAdmittanceUnit.Teramho, "Teramho", "Teramhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (ElectricAdmittanceUnit.Terasiemens, "Terasiemens", "Terasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000000)
+                );
             }
         }
 
         static ElectricAdmittance()
         {
-            Info = ElectricAdmittanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricAdmittanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -152,7 +179,7 @@ static ElectricAdmittance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricAdmittance(double value, ElectricAdmittanceUnit unit)
+        public ElectricAdmittance(QuantityValue value, ElectricAdmittanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -166,7 +193,7 @@ public ElectricAdmittance(double value, ElectricAdmittanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricAdmittance(double value, UnitSystem unitSystem)
+        public ElectricAdmittance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -177,7 +204,8 @@ public ElectricAdmittance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricAdmittance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricAdmittance, ElectricAdmittanceUnit> Info { get; }
@@ -206,10 +234,8 @@ public ElectricAdmittance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricAdmittanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -243,133 +269,89 @@ public ElectricAdmittance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Gigamho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Gigamho"/>
         /// </summary>
-        public double Gigamhos => As(ElectricAdmittanceUnit.Gigamho);
+        public QuantityValue Gigamhos => this.As(ElectricAdmittanceUnit.Gigamho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Gigasiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Gigasiemens"/>
         /// </summary>
-        public double Gigasiemens => As(ElectricAdmittanceUnit.Gigasiemens);
+        public QuantityValue Gigasiemens => this.As(ElectricAdmittanceUnit.Gigasiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Kilomho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Kilomho"/>
         /// </summary>
-        public double Kilomhos => As(ElectricAdmittanceUnit.Kilomho);
+        public QuantityValue Kilomhos => this.As(ElectricAdmittanceUnit.Kilomho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Kilosiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Kilosiemens"/>
         /// </summary>
-        public double Kilosiemens => As(ElectricAdmittanceUnit.Kilosiemens);
+        public QuantityValue Kilosiemens => this.As(ElectricAdmittanceUnit.Kilosiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Megamho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Megamho"/>
         /// </summary>
-        public double Megamhos => As(ElectricAdmittanceUnit.Megamho);
+        public QuantityValue Megamhos => this.As(ElectricAdmittanceUnit.Megamho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Megasiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Megasiemens"/>
         /// </summary>
-        public double Megasiemens => As(ElectricAdmittanceUnit.Megasiemens);
+        public QuantityValue Megasiemens => this.As(ElectricAdmittanceUnit.Megasiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Mho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Mho"/>
         /// </summary>
-        public double Mhos => As(ElectricAdmittanceUnit.Mho);
+        public QuantityValue Mhos => this.As(ElectricAdmittanceUnit.Mho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Micromho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Micromho"/>
         /// </summary>
-        public double Micromhos => As(ElectricAdmittanceUnit.Micromho);
+        public QuantityValue Micromhos => this.As(ElectricAdmittanceUnit.Micromho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Microsiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Microsiemens"/>
         /// </summary>
-        public double Microsiemens => As(ElectricAdmittanceUnit.Microsiemens);
+        public QuantityValue Microsiemens => this.As(ElectricAdmittanceUnit.Microsiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Millimho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Millimho"/>
         /// </summary>
-        public double Millimhos => As(ElectricAdmittanceUnit.Millimho);
+        public QuantityValue Millimhos => this.As(ElectricAdmittanceUnit.Millimho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Millisiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Millisiemens"/>
         /// </summary>
-        public double Millisiemens => As(ElectricAdmittanceUnit.Millisiemens);
+        public QuantityValue Millisiemens => this.As(ElectricAdmittanceUnit.Millisiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Nanomho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Nanomho"/>
         /// </summary>
-        public double Nanomhos => As(ElectricAdmittanceUnit.Nanomho);
+        public QuantityValue Nanomhos => this.As(ElectricAdmittanceUnit.Nanomho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Nanosiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Nanosiemens"/>
         /// </summary>
-        public double Nanosiemens => As(ElectricAdmittanceUnit.Nanosiemens);
+        public QuantityValue Nanosiemens => this.As(ElectricAdmittanceUnit.Nanosiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Siemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Siemens"/>
         /// </summary>
-        public double Siemens => As(ElectricAdmittanceUnit.Siemens);
+        public QuantityValue Siemens => this.As(ElectricAdmittanceUnit.Siemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Teramho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Teramho"/>
         /// </summary>
-        public double Teramhos => As(ElectricAdmittanceUnit.Teramho);
+        public QuantityValue Teramhos => this.As(ElectricAdmittanceUnit.Teramho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Terasiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricAdmittanceUnit.Terasiemens"/>
         /// </summary>
-        public double Terasiemens => As(ElectricAdmittanceUnit.Terasiemens);
+        public QuantityValue Terasiemens => this.As(ElectricAdmittanceUnit.Terasiemens);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricAdmittanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Gigamho, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Gigasiemens, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Kilomho, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Kilosiemens, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Megamho, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Megasiemens, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Mho, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Micromho, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Microsiemens, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Millimho, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Millisiemens, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Nanomho, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Nanosiemens, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Teramho, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Terasiemens, ElectricAdmittanceUnit.Siemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Siemens));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Siemens, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricAdmittanceUnit
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Gigamho, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Gigamho));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Gigasiemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Gigasiemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Kilomho, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Kilomho));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Kilosiemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Kilosiemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Megamho, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Megamho));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Megasiemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Megasiemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Mho, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Mho));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Micromho, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Micromho));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Microsiemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Microsiemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Millimho, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Millimho));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Millisiemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Millisiemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Nanomho, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Nanomho));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Nanosiemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Nanosiemens));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Teramho, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Teramho));
-            unitConverter.SetConversionFunction<ElectricAdmittance>(ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Terasiemens, quantity => quantity.ToUnit(ElectricAdmittanceUnit.Terasiemens));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -398,7 +380,7 @@ public static string GetAbbreviation(ElectricAdmittanceUnit unit, IFormatProvide
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Gigamho"/>.
         /// </summary>
-        public static ElectricAdmittance FromGigamhos(double value)
+        public static ElectricAdmittance FromGigamhos(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Gigamho);
         }
@@ -406,7 +388,7 @@ public static ElectricAdmittance FromGigamhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Gigasiemens"/>.
         /// </summary>
-        public static ElectricAdmittance FromGigasiemens(double value)
+        public static ElectricAdmittance FromGigasiemens(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Gigasiemens);
         }
@@ -414,7 +396,7 @@ public static ElectricAdmittance FromGigasiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Kilomho"/>.
         /// </summary>
-        public static ElectricAdmittance FromKilomhos(double value)
+        public static ElectricAdmittance FromKilomhos(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Kilomho);
         }
@@ -422,7 +404,7 @@ public static ElectricAdmittance FromKilomhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Kilosiemens"/>.
         /// </summary>
-        public static ElectricAdmittance FromKilosiemens(double value)
+        public static ElectricAdmittance FromKilosiemens(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Kilosiemens);
         }
@@ -430,7 +412,7 @@ public static ElectricAdmittance FromKilosiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Megamho"/>.
         /// </summary>
-        public static ElectricAdmittance FromMegamhos(double value)
+        public static ElectricAdmittance FromMegamhos(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Megamho);
         }
@@ -438,7 +420,7 @@ public static ElectricAdmittance FromMegamhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Megasiemens"/>.
         /// </summary>
-        public static ElectricAdmittance FromMegasiemens(double value)
+        public static ElectricAdmittance FromMegasiemens(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Megasiemens);
         }
@@ -446,7 +428,7 @@ public static ElectricAdmittance FromMegasiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Mho"/>.
         /// </summary>
-        public static ElectricAdmittance FromMhos(double value)
+        public static ElectricAdmittance FromMhos(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Mho);
         }
@@ -454,7 +436,7 @@ public static ElectricAdmittance FromMhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Micromho"/>.
         /// </summary>
-        public static ElectricAdmittance FromMicromhos(double value)
+        public static ElectricAdmittance FromMicromhos(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Micromho);
         }
@@ -462,7 +444,7 @@ public static ElectricAdmittance FromMicromhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Microsiemens"/>.
         /// </summary>
-        public static ElectricAdmittance FromMicrosiemens(double value)
+        public static ElectricAdmittance FromMicrosiemens(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Microsiemens);
         }
@@ -470,7 +452,7 @@ public static ElectricAdmittance FromMicrosiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Millimho"/>.
         /// </summary>
-        public static ElectricAdmittance FromMillimhos(double value)
+        public static ElectricAdmittance FromMillimhos(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Millimho);
         }
@@ -478,7 +460,7 @@ public static ElectricAdmittance FromMillimhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Millisiemens"/>.
         /// </summary>
-        public static ElectricAdmittance FromMillisiemens(double value)
+        public static ElectricAdmittance FromMillisiemens(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Millisiemens);
         }
@@ -486,7 +468,7 @@ public static ElectricAdmittance FromMillisiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Nanomho"/>.
         /// </summary>
-        public static ElectricAdmittance FromNanomhos(double value)
+        public static ElectricAdmittance FromNanomhos(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Nanomho);
         }
@@ -494,7 +476,7 @@ public static ElectricAdmittance FromNanomhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Nanosiemens"/>.
         /// </summary>
-        public static ElectricAdmittance FromNanosiemens(double value)
+        public static ElectricAdmittance FromNanosiemens(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Nanosiemens);
         }
@@ -502,7 +484,7 @@ public static ElectricAdmittance FromNanosiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Siemens"/>.
         /// </summary>
-        public static ElectricAdmittance FromSiemens(double value)
+        public static ElectricAdmittance FromSiemens(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Siemens);
         }
@@ -510,7 +492,7 @@ public static ElectricAdmittance FromSiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Teramho"/>.
         /// </summary>
-        public static ElectricAdmittance FromTeramhos(double value)
+        public static ElectricAdmittance FromTeramhos(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Teramho);
         }
@@ -518,7 +500,7 @@ public static ElectricAdmittance FromTeramhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Terasiemens"/>.
         /// </summary>
-        public static ElectricAdmittance FromTerasiemens(double value)
+        public static ElectricAdmittance FromTerasiemens(QuantityValue value)
         {
             return new ElectricAdmittance(value, ElectricAdmittanceUnit.Terasiemens);
         }
@@ -529,7 +511,7 @@ public static ElectricAdmittance FromTerasiemens(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricAdmittance unit value.</returns>
-        public static ElectricAdmittance From(double value, ElectricAdmittanceUnit fromUnit)
+        public static ElectricAdmittance From(QuantityValue value, ElectricAdmittanceUnit fromUnit)
         {
             return new ElectricAdmittance(value, fromUnit);
         }
@@ -590,10 +572,7 @@ public static ElectricAdmittance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricAdmittance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricAdmittance, ElectricAdmittanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricAdmittance, ElectricAdmittanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -621,11 +600,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricAdmittan
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricAdmittance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricAdmittance, ElectricAdmittanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricAdmittance, ElectricAdmittanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -646,7 +621,7 @@ public static ElectricAdmittanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -657,7 +632,7 @@ public static ElectricAdmittanceUnit ParseUnit(string str, IFormatProvider? prov
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricAdmittanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricAdmittanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricAdmittanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -672,7 +647,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricAdmi
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricAdmittanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -691,35 +666,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricAdmittance"/> from adding two <see cref="ElectricAdmittance"/>.</summary>
         public static ElectricAdmittance operator +(ElectricAdmittance left, ElectricAdmittance right)
         {
-            return new ElectricAdmittance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricAdmittance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricAdmittance"/> from subtracting two <see cref="ElectricAdmittance"/>.</summary>
         public static ElectricAdmittance operator -(ElectricAdmittance left, ElectricAdmittance right)
         {
-            return new ElectricAdmittance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricAdmittance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricAdmittance"/> from multiplying value and <see cref="ElectricAdmittance"/>.</summary>
-        public static ElectricAdmittance operator *(double left, ElectricAdmittance right)
+        public static ElectricAdmittance operator *(QuantityValue left, ElectricAdmittance right)
         {
             return new ElectricAdmittance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricAdmittance"/> from multiplying value and <see cref="ElectricAdmittance"/>.</summary>
-        public static ElectricAdmittance operator *(ElectricAdmittance left, double right)
+        public static ElectricAdmittance operator *(ElectricAdmittance left, QuantityValue right)
         {
             return new ElectricAdmittance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricAdmittance"/> from dividing <see cref="ElectricAdmittance"/> by value.</summary>
-        public static ElectricAdmittance operator /(ElectricAdmittance left, double right)
+        public static ElectricAdmittance operator /(ElectricAdmittance left, QuantityValue right)
         {
             return new ElectricAdmittance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricAdmittance"/> by <see cref="ElectricAdmittance"/>.</summary>
-        public static double operator /(ElectricAdmittance left, ElectricAdmittance right)
+        public static QuantityValue operator /(ElectricAdmittance left, ElectricAdmittance right)
         {
             return left.Siemens / right.Siemens;
         }
@@ -731,97 +706,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricAdmittance left, ElectricAdmittance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricAdmittance left, ElectricAdmittance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricAdmittance left, ElectricAdmittance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricAdmittance left, ElectricAdmittance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricAdmittance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricAdmittance other, ElectricAdmittance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricAdmittance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricAdmittance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricAdmittance left, ElectricAdmittance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricAdmittance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricAdmittance other, ElectricAdmittance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricAdmittance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricAdmittance,ElectricAdmittance)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricAdmittance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricAdmittance left, ElectricAdmittance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricAdmittance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricAdmittance other, ElectricAdmittance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricAdmittance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricAdmittance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricAdmittance"/>, this method delegates to
+        ///     <see cref="Equals(ElectricAdmittance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricAdmittance otherQuantity))
+            if (obj is not ElectricAdmittance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricAdmittance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricAdmittance other, ElectricAdmittance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricAdmittance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricAdmittance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricAdmittance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricAdmittance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricAdmittance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricAdmittance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricAdmittance otherQuantity)) throw new ArgumentException("Expected type ElectricAdmittance.", nameof(obj));
+            if (obj is not ElectricAdmittance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricAdmittance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricAdmittance"/> with another <see cref="ElectricAdmittance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricAdmittance"/> with another <see cref="ElectricAdmittance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -833,159 +822,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricAdmittance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricAdmittanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricAdmittanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricAdmittance to another ElectricAdmittance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricAdmittance with the specified unit.</returns>
-        public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricAdmittance"/> to another <see cref="ElectricAdmittance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricAdmittance with the specified unit.</returns>
-        public ElectricAdmittance ToUnit(ElectricAdmittanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricAdmittance), Unit, typeof(ElectricAdmittance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricAdmittance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricAdmittance"/> to another <see cref="ElectricAdmittance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricAdmittance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricAdmittanceUnit unit, [NotNullWhen(true)] out ElectricAdmittance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricAdmittance? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricAdmittanceUnit -> BaseUnit
-                (ElectricAdmittanceUnit.Gigamho, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e9d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Gigasiemens, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e9d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Kilomho, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e3d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Kilosiemens, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e3d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Megamho, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e6d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Megasiemens, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e6d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Mho, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance(_value, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Micromho, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e-6d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Microsiemens, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e-6d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Millimho, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e-3d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Millisiemens, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e-3d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Nanomho, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e-9d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Nanosiemens, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e-9d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Teramho, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e12d, ElectricAdmittanceUnit.Siemens),
-                (ElectricAdmittanceUnit.Terasiemens, ElectricAdmittanceUnit.Siemens) => new ElectricAdmittance((_value) * 1e12d, ElectricAdmittanceUnit.Siemens),
-
-                // BaseUnit -> ElectricAdmittanceUnit
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Gigamho) => new ElectricAdmittance((_value) / 1e9d, ElectricAdmittanceUnit.Gigamho),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Gigasiemens) => new ElectricAdmittance((_value) / 1e9d, ElectricAdmittanceUnit.Gigasiemens),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Kilomho) => new ElectricAdmittance((_value) / 1e3d, ElectricAdmittanceUnit.Kilomho),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Kilosiemens) => new ElectricAdmittance((_value) / 1e3d, ElectricAdmittanceUnit.Kilosiemens),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Megamho) => new ElectricAdmittance((_value) / 1e6d, ElectricAdmittanceUnit.Megamho),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Megasiemens) => new ElectricAdmittance((_value) / 1e6d, ElectricAdmittanceUnit.Megasiemens),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Mho) => new ElectricAdmittance(_value, ElectricAdmittanceUnit.Mho),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Micromho) => new ElectricAdmittance((_value) / 1e-6d, ElectricAdmittanceUnit.Micromho),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Microsiemens) => new ElectricAdmittance((_value) / 1e-6d, ElectricAdmittanceUnit.Microsiemens),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Millimho) => new ElectricAdmittance((_value) / 1e-3d, ElectricAdmittanceUnit.Millimho),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Millisiemens) => new ElectricAdmittance((_value) / 1e-3d, ElectricAdmittanceUnit.Millisiemens),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Nanomho) => new ElectricAdmittance((_value) / 1e-9d, ElectricAdmittanceUnit.Nanomho),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Nanosiemens) => new ElectricAdmittance((_value) / 1e-9d, ElectricAdmittanceUnit.Nanosiemens),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Teramho) => new ElectricAdmittance((_value) / 1e12d, ElectricAdmittanceUnit.Teramho),
-                (ElectricAdmittanceUnit.Siemens, ElectricAdmittanceUnit.Terasiemens) => new ElectricAdmittance((_value) / 1e12d, ElectricAdmittanceUnit.Terasiemens),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricAdmittanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricAdmittanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricAdmittanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricAdmittanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricAdmittanceUnit> IQuantity<ElectricAdmittanceUnit>.ToUnit(ElectricAdmittanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -999,11 +838,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs
index 299daa8292..b74b86ae15 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricApparentEnergy.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,14 @@ namespace UnitsNet
     ///     A unit for expressing the integral of apparent power over time, equal to the product of 1 volt-ampere and 1 hour, or to 3600 joules.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricApparentEnergy :
-        IArithmeticQuantity<ElectricApparentEnergy, ElectricApparentEnergyUnit>,
+        ILinearQuantity<ElectricApparentEnergy, ElectricApparentEnergyUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricApparentEnergy, ElectricApparentEnergy, double>,
+        IDivisionOperators<ElectricApparentEnergy, ElectricApparentEnergy, QuantityValue>,
+        IDivisionOperators<ElectricApparentEnergy, ElectricApparentPower, Duration>,
+        IDivisionOperators<ElectricApparentEnergy, Duration, ElectricApparentPower>,
         IComparisonOperators<ElectricApparentEnergy, ElectricApparentEnergy, bool>,
         IParsable<ElectricApparentEnergy>,
 #endif
@@ -52,7 +53,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +103,7 @@ public static ElectricApparentEnergyInfo CreateDefault(Func<IEnumerable<UnitDefi
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricApparentEnergy"/> is [T^-2][L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricApparentEnergy"/> is T^-2L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
 
@@ -117,17 +118,19 @@ public static ElectricApparentEnergyInfo CreateDefault(Func<IEnumerable<UnitDefi
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricApparentEnergyUnit}"/> representing the default unit mappings for ElectricApparentEnergy.</returns>
             public static IEnumerable<UnitDefinition<ElectricApparentEnergyUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricApparentEnergyUnit.KilovoltampereHour, "KilovoltampereHour", "KilovoltampereHours", BaseUnits.Undefined);
-                yield return new (ElectricApparentEnergyUnit.MegavoltampereHour, "MegavoltampereHour", "MegavoltampereHours", BaseUnits.Undefined);
+                yield return new (ElectricApparentEnergyUnit.KilovoltampereHour, "KilovoltampereHour", "KilovoltampereHours", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricApparentEnergyUnit.MegavoltampereHour, "MegavoltampereHour", "MegavoltampereHours", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
                 yield return new (ElectricApparentEnergyUnit.VoltampereHour, "VoltampereHour", "VoltampereHours", BaseUnits.Undefined);
             }
         }
 
         static ElectricApparentEnergy()
         {
-            Info = ElectricApparentEnergyInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricApparentEnergyInfo.CreateDefault);
         }
 
         /// <summary>
@@ -135,7 +138,7 @@ static ElectricApparentEnergy()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricApparentEnergy(double value, ElectricApparentEnergyUnit unit)
+        public ElectricApparentEnergy(QuantityValue value, ElectricApparentEnergyUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -149,7 +152,7 @@ public ElectricApparentEnergy(double value, ElectricApparentEnergyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricApparentEnergy(double value, UnitSystem unitSystem)
+        public ElectricApparentEnergy(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -160,7 +163,8 @@ public ElectricApparentEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricApparentEnergy" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricApparentEnergy, ElectricApparentEnergyUnit> Info { get; }
@@ -189,10 +193,8 @@ public ElectricApparentEnergy(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricApparentEnergyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -226,42 +228,24 @@ public ElectricApparentEnergy(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentEnergyUnit.KilovoltampereHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricApparentEnergyUnit.KilovoltampereHour"/>
         /// </summary>
-        public double KilovoltampereHours => As(ElectricApparentEnergyUnit.KilovoltampereHour);
+        public QuantityValue KilovoltampereHours => this.As(ElectricApparentEnergyUnit.KilovoltampereHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentEnergyUnit.MegavoltampereHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricApparentEnergyUnit.MegavoltampereHour"/>
         /// </summary>
-        public double MegavoltampereHours => As(ElectricApparentEnergyUnit.MegavoltampereHour);
+        public QuantityValue MegavoltampereHours => this.As(ElectricApparentEnergyUnit.MegavoltampereHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentEnergyUnit.VoltampereHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricApparentEnergyUnit.VoltampereHour"/>
         /// </summary>
-        public double VoltampereHours => As(ElectricApparentEnergyUnit.VoltampereHour);
+        public QuantityValue VoltampereHours => this.As(ElectricApparentEnergyUnit.VoltampereHour);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricApparentEnergyUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricApparentEnergy>(ElectricApparentEnergyUnit.KilovoltampereHour, ElectricApparentEnergyUnit.VoltampereHour, quantity => quantity.ToUnit(ElectricApparentEnergyUnit.VoltampereHour));
-            unitConverter.SetConversionFunction<ElectricApparentEnergy>(ElectricApparentEnergyUnit.MegavoltampereHour, ElectricApparentEnergyUnit.VoltampereHour, quantity => quantity.ToUnit(ElectricApparentEnergyUnit.VoltampereHour));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricApparentEnergy>(ElectricApparentEnergyUnit.VoltampereHour, ElectricApparentEnergyUnit.VoltampereHour, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricApparentEnergyUnit
-            unitConverter.SetConversionFunction<ElectricApparentEnergy>(ElectricApparentEnergyUnit.VoltampereHour, ElectricApparentEnergyUnit.KilovoltampereHour, quantity => quantity.ToUnit(ElectricApparentEnergyUnit.KilovoltampereHour));
-            unitConverter.SetConversionFunction<ElectricApparentEnergy>(ElectricApparentEnergyUnit.VoltampereHour, ElectricApparentEnergyUnit.MegavoltampereHour, quantity => quantity.ToUnit(ElectricApparentEnergyUnit.MegavoltampereHour));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -290,7 +274,7 @@ public static string GetAbbreviation(ElectricApparentEnergyUnit unit, IFormatPro
         /// <summary>
         ///     Creates a <see cref="ElectricApparentEnergy"/> from <see cref="ElectricApparentEnergyUnit.KilovoltampereHour"/>.
         /// </summary>
-        public static ElectricApparentEnergy FromKilovoltampereHours(double value)
+        public static ElectricApparentEnergy FromKilovoltampereHours(QuantityValue value)
         {
             return new ElectricApparentEnergy(value, ElectricApparentEnergyUnit.KilovoltampereHour);
         }
@@ -298,7 +282,7 @@ public static ElectricApparentEnergy FromKilovoltampereHours(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricApparentEnergy"/> from <see cref="ElectricApparentEnergyUnit.MegavoltampereHour"/>.
         /// </summary>
-        public static ElectricApparentEnergy FromMegavoltampereHours(double value)
+        public static ElectricApparentEnergy FromMegavoltampereHours(QuantityValue value)
         {
             return new ElectricApparentEnergy(value, ElectricApparentEnergyUnit.MegavoltampereHour);
         }
@@ -306,7 +290,7 @@ public static ElectricApparentEnergy FromMegavoltampereHours(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricApparentEnergy"/> from <see cref="ElectricApparentEnergyUnit.VoltampereHour"/>.
         /// </summary>
-        public static ElectricApparentEnergy FromVoltampereHours(double value)
+        public static ElectricApparentEnergy FromVoltampereHours(QuantityValue value)
         {
             return new ElectricApparentEnergy(value, ElectricApparentEnergyUnit.VoltampereHour);
         }
@@ -317,7 +301,7 @@ public static ElectricApparentEnergy FromVoltampereHours(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricApparentEnergy unit value.</returns>
-        public static ElectricApparentEnergy From(double value, ElectricApparentEnergyUnit fromUnit)
+        public static ElectricApparentEnergy From(QuantityValue value, ElectricApparentEnergyUnit fromUnit)
         {
             return new ElectricApparentEnergy(value, fromUnit);
         }
@@ -378,10 +362,7 @@ public static ElectricApparentEnergy Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricApparentEnergy Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricApparentEnergy, ElectricApparentEnergyUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricApparentEnergy, ElectricApparentEnergyUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -409,11 +390,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricApparent
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricApparentEnergy result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricApparentEnergy, ElectricApparentEnergyUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricApparentEnergy, ElectricApparentEnergyUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -434,7 +411,7 @@ public static ElectricApparentEnergyUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -445,7 +422,7 @@ public static ElectricApparentEnergyUnit ParseUnit(string str, IFormatProvider?
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricApparentEnergyUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricApparentEnergyUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricApparentEnergyUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -460,7 +437,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricAppa
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricApparentEnergyUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -479,137 +456,167 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricApparentEnergy"/> from adding two <see cref="ElectricApparentEnergy"/>.</summary>
         public static ElectricApparentEnergy operator +(ElectricApparentEnergy left, ElectricApparentEnergy right)
         {
-            return new ElectricApparentEnergy(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricApparentEnergy(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricApparentEnergy"/> from subtracting two <see cref="ElectricApparentEnergy"/>.</summary>
         public static ElectricApparentEnergy operator -(ElectricApparentEnergy left, ElectricApparentEnergy right)
         {
-            return new ElectricApparentEnergy(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricApparentEnergy(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricApparentEnergy"/> from multiplying value and <see cref="ElectricApparentEnergy"/>.</summary>
-        public static ElectricApparentEnergy operator *(double left, ElectricApparentEnergy right)
+        public static ElectricApparentEnergy operator *(QuantityValue left, ElectricApparentEnergy right)
         {
             return new ElectricApparentEnergy(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricApparentEnergy"/> from multiplying value and <see cref="ElectricApparentEnergy"/>.</summary>
-        public static ElectricApparentEnergy operator *(ElectricApparentEnergy left, double right)
+        public static ElectricApparentEnergy operator *(ElectricApparentEnergy left, QuantityValue right)
         {
             return new ElectricApparentEnergy(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricApparentEnergy"/> from dividing <see cref="ElectricApparentEnergy"/> by value.</summary>
-        public static ElectricApparentEnergy operator /(ElectricApparentEnergy left, double right)
+        public static ElectricApparentEnergy operator /(ElectricApparentEnergy left, QuantityValue right)
         {
             return new ElectricApparentEnergy(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricApparentEnergy"/> by <see cref="ElectricApparentEnergy"/>.</summary>
-        public static double operator /(ElectricApparentEnergy left, ElectricApparentEnergy right)
+        public static QuantityValue operator /(ElectricApparentEnergy left, ElectricApparentEnergy right)
         {
             return left.VoltampereHours / right.VoltampereHours;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Duration"/> from <see cref="ElectricApparentEnergy"/> / <see cref="ElectricApparentPower"/>.</summary>
+        public static Duration operator /(ElectricApparentEnergy electricApparentEnergy, ElectricApparentPower electricApparentPower)
+        {
+            return Duration.FromHours(electricApparentEnergy.VoltampereHours / electricApparentPower.Voltamperes);
+        }
+
+        /// <summary>Get <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentEnergy"/> / <see cref="Duration"/>.</summary>
+        public static ElectricApparentPower operator /(ElectricApparentEnergy electricApparentEnergy, Duration duration)
+        {
+            return ElectricApparentPower.FromVoltamperes(electricApparentEnergy.VoltampereHours / duration.Hours);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricApparentEnergy left, ElectricApparentEnergy right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricApparentEnergy left, ElectricApparentEnergy right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricApparentEnergy left, ElectricApparentEnergy right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricApparentEnergy left, ElectricApparentEnergy right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricApparentEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricApparentEnergy other, ElectricApparentEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricApparentEnergy"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricApparentEnergy)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricApparentEnergy left, ElectricApparentEnergy right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricApparentEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricApparentEnergy other, ElectricApparentEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricApparentEnergy"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricApparentEnergy,ElectricApparentEnergy)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricApparentEnergy)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricApparentEnergy left, ElectricApparentEnergy right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricApparentEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricApparentEnergy other, ElectricApparentEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricApparentEnergy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricApparentEnergy"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricApparentEnergy"/>, this method delegates to
+        ///     <see cref="Equals(ElectricApparentEnergy)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricApparentEnergy otherQuantity))
+            if (obj is not ElectricApparentEnergy otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricApparentEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricApparentEnergy other, ElectricApparentEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricApparentEnergy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricApparentEnergy other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricApparentEnergy.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricApparentEnergy), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricApparentEnergy"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricApparentEnergy)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricApparentEnergy otherQuantity)) throw new ArgumentException("Expected type ElectricApparentEnergy.", nameof(obj));
+            if (obj is not ElectricApparentEnergy otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricApparentEnergy>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricApparentEnergy"/> with another <see cref="ElectricApparentEnergy"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricApparentEnergy"/> with another <see cref="ElectricApparentEnergy"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -621,133 +628,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricApparentEnergy other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricApparentEnergyUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricApparentEnergyUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricApparentEnergy to another ElectricApparentEnergy with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricApparentEnergy with the specified unit.</returns>
-        public ElectricApparentEnergy ToUnit(ElectricApparentEnergyUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricApparentEnergy"/> to another <see cref="ElectricApparentEnergy"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricApparentEnergy with the specified unit.</returns>
-        public ElectricApparentEnergy ToUnit(ElectricApparentEnergyUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricApparentEnergy), Unit, typeof(ElectricApparentEnergy), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricApparentEnergy)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricApparentEnergy"/> to another <see cref="ElectricApparentEnergy"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricApparentEnergy"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricApparentEnergyUnit unit, [NotNullWhen(true)] out ElectricApparentEnergy? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricApparentEnergy? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricApparentEnergyUnit -> BaseUnit
-                (ElectricApparentEnergyUnit.KilovoltampereHour, ElectricApparentEnergyUnit.VoltampereHour) => new ElectricApparentEnergy((_value) * 1e3d, ElectricApparentEnergyUnit.VoltampereHour),
-                (ElectricApparentEnergyUnit.MegavoltampereHour, ElectricApparentEnergyUnit.VoltampereHour) => new ElectricApparentEnergy((_value) * 1e6d, ElectricApparentEnergyUnit.VoltampereHour),
-
-                // BaseUnit -> ElectricApparentEnergyUnit
-                (ElectricApparentEnergyUnit.VoltampereHour, ElectricApparentEnergyUnit.KilovoltampereHour) => new ElectricApparentEnergy((_value) / 1e3d, ElectricApparentEnergyUnit.KilovoltampereHour),
-                (ElectricApparentEnergyUnit.VoltampereHour, ElectricApparentEnergyUnit.MegavoltampereHour) => new ElectricApparentEnergy((_value) / 1e6d, ElectricApparentEnergyUnit.MegavoltampereHour),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricApparentEnergyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricApparentEnergyUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricApparentEnergyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricApparentEnergyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricApparentEnergyUnit> IQuantity<ElectricApparentEnergyUnit>.ToUnit(ElectricApparentEnergyUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -761,11 +644,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricApparentPower.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricApparentPower.g.cs
index 9eaa4f4fd6..cc39059cae 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricApparentPower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricApparentPower.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/AC_power#Active,_reactive,_apparent,_and_complex_power_in_sinusoidal_steady-state
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricApparentPower :
-        IArithmeticQuantity<ElectricApparentPower, ElectricApparentPowerUnit>,
+        ILinearQuantity<ElectricApparentPower, ElectricApparentPowerUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricApparentPower, ElectricApparentPower, double>,
+        IDivisionOperators<ElectricApparentPower, ElectricApparentPower, QuantityValue>,
+        IMultiplyOperators<ElectricApparentPower, Duration, ElectricApparentEnergy>,
         IComparisonOperators<ElectricApparentPower, ElectricApparentPower, bool>,
         IParsable<ElectricApparentPower>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static ElectricApparentPowerInfo CreateDefault(Func<IEnumerable<UnitDefin
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricApparentPower"/> is [T^-3][L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricApparentPower"/> is T^-3L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
 
@@ -120,20 +120,28 @@ public static ElectricApparentPowerInfo CreateDefault(Func<IEnumerable<UnitDefin
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricApparentPowerUnit}"/> representing the default unit mappings for ElectricApparentPower.</returns>
             public static IEnumerable<UnitDefinition<ElectricApparentPowerUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricApparentPowerUnit.Gigavoltampere, "Gigavoltampere", "Gigavoltamperes", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond));
-                yield return new (ElectricApparentPowerUnit.Kilovoltampere, "Kilovoltampere", "Kilovoltamperes", BaseUnits.Undefined);
-                yield return new (ElectricApparentPowerUnit.Megavoltampere, "Megavoltampere", "Megavoltamperes", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ElectricApparentPowerUnit.Microvoltampere, "Microvoltampere", "Microvoltamperes", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second));
-                yield return new (ElectricApparentPowerUnit.Millivoltampere, "Millivoltampere", "Millivoltamperes", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second));
+                yield return new (ElectricApparentPowerUnit.Gigavoltampere, "Gigavoltampere", "Gigavoltamperes", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricApparentPowerUnit.Kilovoltampere, "Kilovoltampere", "Kilovoltamperes", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricApparentPowerUnit.Megavoltampere, "Megavoltampere", "Megavoltamperes", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricApparentPowerUnit.Microvoltampere, "Microvoltampere", "Microvoltamperes", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (ElectricApparentPowerUnit.Millivoltampere, "Millivoltampere", "Millivoltamperes", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     1000
+                );
                 yield return new (ElectricApparentPowerUnit.Voltampere, "Voltampere", "Voltamperes", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
             }
         }
 
         static ElectricApparentPower()
         {
-            Info = ElectricApparentPowerInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricApparentPowerInfo.CreateDefault);
         }
 
         /// <summary>
@@ -141,7 +149,7 @@ static ElectricApparentPower()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricApparentPower(double value, ElectricApparentPowerUnit unit)
+        public ElectricApparentPower(QuantityValue value, ElectricApparentPowerUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -155,7 +163,7 @@ public ElectricApparentPower(double value, ElectricApparentPowerUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricApparentPower(double value, UnitSystem unitSystem)
+        public ElectricApparentPower(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -166,7 +174,8 @@ public ElectricApparentPower(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricApparentPower" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricApparentPower, ElectricApparentPowerUnit> Info { get; }
@@ -195,10 +204,8 @@ public ElectricApparentPower(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricApparentPowerUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -232,63 +239,39 @@ public ElectricApparentPower(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Gigavoltampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Gigavoltampere"/>
         /// </summary>
-        public double Gigavoltamperes => As(ElectricApparentPowerUnit.Gigavoltampere);
+        public QuantityValue Gigavoltamperes => this.As(ElectricApparentPowerUnit.Gigavoltampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Kilovoltampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Kilovoltampere"/>
         /// </summary>
-        public double Kilovoltamperes => As(ElectricApparentPowerUnit.Kilovoltampere);
+        public QuantityValue Kilovoltamperes => this.As(ElectricApparentPowerUnit.Kilovoltampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Megavoltampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Megavoltampere"/>
         /// </summary>
-        public double Megavoltamperes => As(ElectricApparentPowerUnit.Megavoltampere);
+        public QuantityValue Megavoltamperes => this.As(ElectricApparentPowerUnit.Megavoltampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Microvoltampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Microvoltampere"/>
         /// </summary>
-        public double Microvoltamperes => As(ElectricApparentPowerUnit.Microvoltampere);
+        public QuantityValue Microvoltamperes => this.As(ElectricApparentPowerUnit.Microvoltampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Millivoltampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Millivoltampere"/>
         /// </summary>
-        public double Millivoltamperes => As(ElectricApparentPowerUnit.Millivoltampere);
+        public QuantityValue Millivoltamperes => this.As(ElectricApparentPowerUnit.Millivoltampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Voltampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricApparentPowerUnit.Voltampere"/>
         /// </summary>
-        public double Voltamperes => As(ElectricApparentPowerUnit.Voltampere);
+        public QuantityValue Voltamperes => this.As(ElectricApparentPowerUnit.Voltampere);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricApparentPowerUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Gigavoltampere, ElectricApparentPowerUnit.Voltampere, quantity => quantity.ToUnit(ElectricApparentPowerUnit.Voltampere));
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Kilovoltampere, ElectricApparentPowerUnit.Voltampere, quantity => quantity.ToUnit(ElectricApparentPowerUnit.Voltampere));
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Megavoltampere, ElectricApparentPowerUnit.Voltampere, quantity => quantity.ToUnit(ElectricApparentPowerUnit.Voltampere));
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Microvoltampere, ElectricApparentPowerUnit.Voltampere, quantity => quantity.ToUnit(ElectricApparentPowerUnit.Voltampere));
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Millivoltampere, ElectricApparentPowerUnit.Voltampere, quantity => quantity.ToUnit(ElectricApparentPowerUnit.Voltampere));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Voltampere, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricApparentPowerUnit
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Gigavoltampere, quantity => quantity.ToUnit(ElectricApparentPowerUnit.Gigavoltampere));
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Kilovoltampere, quantity => quantity.ToUnit(ElectricApparentPowerUnit.Kilovoltampere));
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Megavoltampere, quantity => quantity.ToUnit(ElectricApparentPowerUnit.Megavoltampere));
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Microvoltampere, quantity => quantity.ToUnit(ElectricApparentPowerUnit.Microvoltampere));
-            unitConverter.SetConversionFunction<ElectricApparentPower>(ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Millivoltampere, quantity => quantity.ToUnit(ElectricApparentPowerUnit.Millivoltampere));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -317,7 +300,7 @@ public static string GetAbbreviation(ElectricApparentPowerUnit unit, IFormatProv
         /// <summary>
         ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Gigavoltampere"/>.
         /// </summary>
-        public static ElectricApparentPower FromGigavoltamperes(double value)
+        public static ElectricApparentPower FromGigavoltamperes(QuantityValue value)
         {
             return new ElectricApparentPower(value, ElectricApparentPowerUnit.Gigavoltampere);
         }
@@ -325,7 +308,7 @@ public static ElectricApparentPower FromGigavoltamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Kilovoltampere"/>.
         /// </summary>
-        public static ElectricApparentPower FromKilovoltamperes(double value)
+        public static ElectricApparentPower FromKilovoltamperes(QuantityValue value)
         {
             return new ElectricApparentPower(value, ElectricApparentPowerUnit.Kilovoltampere);
         }
@@ -333,7 +316,7 @@ public static ElectricApparentPower FromKilovoltamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Megavoltampere"/>.
         /// </summary>
-        public static ElectricApparentPower FromMegavoltamperes(double value)
+        public static ElectricApparentPower FromMegavoltamperes(QuantityValue value)
         {
             return new ElectricApparentPower(value, ElectricApparentPowerUnit.Megavoltampere);
         }
@@ -341,7 +324,7 @@ public static ElectricApparentPower FromMegavoltamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Microvoltampere"/>.
         /// </summary>
-        public static ElectricApparentPower FromMicrovoltamperes(double value)
+        public static ElectricApparentPower FromMicrovoltamperes(QuantityValue value)
         {
             return new ElectricApparentPower(value, ElectricApparentPowerUnit.Microvoltampere);
         }
@@ -349,7 +332,7 @@ public static ElectricApparentPower FromMicrovoltamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Millivoltampere"/>.
         /// </summary>
-        public static ElectricApparentPower FromMillivoltamperes(double value)
+        public static ElectricApparentPower FromMillivoltamperes(QuantityValue value)
         {
             return new ElectricApparentPower(value, ElectricApparentPowerUnit.Millivoltampere);
         }
@@ -357,7 +340,7 @@ public static ElectricApparentPower FromMillivoltamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricApparentPower"/> from <see cref="ElectricApparentPowerUnit.Voltampere"/>.
         /// </summary>
-        public static ElectricApparentPower FromVoltamperes(double value)
+        public static ElectricApparentPower FromVoltamperes(QuantityValue value)
         {
             return new ElectricApparentPower(value, ElectricApparentPowerUnit.Voltampere);
         }
@@ -368,7 +351,7 @@ public static ElectricApparentPower FromVoltamperes(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricApparentPower unit value.</returns>
-        public static ElectricApparentPower From(double value, ElectricApparentPowerUnit fromUnit)
+        public static ElectricApparentPower From(QuantityValue value, ElectricApparentPowerUnit fromUnit)
         {
             return new ElectricApparentPower(value, fromUnit);
         }
@@ -429,10 +412,7 @@ public static ElectricApparentPower Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricApparentPower Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricApparentPower, ElectricApparentPowerUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricApparentPower, ElectricApparentPowerUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -460,11 +440,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricApparent
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricApparentPower result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricApparentPower, ElectricApparentPowerUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricApparentPower, ElectricApparentPowerUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -485,7 +461,7 @@ public static ElectricApparentPowerUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -496,7 +472,7 @@ public static ElectricApparentPowerUnit ParseUnit(string str, IFormatProvider? p
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricApparentPowerUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricApparentPowerUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricApparentPowerUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -511,7 +487,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricAppa
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricApparentPowerUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -530,137 +506,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricApparentPower"/> from adding two <see cref="ElectricApparentPower"/>.</summary>
         public static ElectricApparentPower operator +(ElectricApparentPower left, ElectricApparentPower right)
         {
-            return new ElectricApparentPower(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricApparentPower(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricApparentPower"/> from subtracting two <see cref="ElectricApparentPower"/>.</summary>
         public static ElectricApparentPower operator -(ElectricApparentPower left, ElectricApparentPower right)
         {
-            return new ElectricApparentPower(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricApparentPower(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricApparentPower"/> from multiplying value and <see cref="ElectricApparentPower"/>.</summary>
-        public static ElectricApparentPower operator *(double left, ElectricApparentPower right)
+        public static ElectricApparentPower operator *(QuantityValue left, ElectricApparentPower right)
         {
             return new ElectricApparentPower(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricApparentPower"/> from multiplying value and <see cref="ElectricApparentPower"/>.</summary>
-        public static ElectricApparentPower operator *(ElectricApparentPower left, double right)
+        public static ElectricApparentPower operator *(ElectricApparentPower left, QuantityValue right)
         {
             return new ElectricApparentPower(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricApparentPower"/> from dividing <see cref="ElectricApparentPower"/> by value.</summary>
-        public static ElectricApparentPower operator /(ElectricApparentPower left, double right)
+        public static ElectricApparentPower operator /(ElectricApparentPower left, QuantityValue right)
         {
             return new ElectricApparentPower(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricApparentPower"/> by <see cref="ElectricApparentPower"/>.</summary>
-        public static double operator /(ElectricApparentPower left, ElectricApparentPower right)
+        public static QuantityValue operator /(ElectricApparentPower left, ElectricApparentPower right)
         {
             return left.Voltamperes / right.Voltamperes;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="ElectricApparentEnergy"/> from <see cref="ElectricApparentPower"/> * <see cref="Duration"/>.</summary>
+        public static ElectricApparentEnergy operator *(ElectricApparentPower electricApparentPower, Duration duration)
+        {
+            return ElectricApparentEnergy.FromVoltampereHours(electricApparentPower.Voltamperes * duration.Hours);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricApparentPower left, ElectricApparentPower right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricApparentPower left, ElectricApparentPower right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricApparentPower left, ElectricApparentPower right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricApparentPower left, ElectricApparentPower right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricApparentPower"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricApparentPower other, ElectricApparentPower tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricApparentPower"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricApparentPower)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricApparentPower left, ElectricApparentPower right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricApparentPower"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricApparentPower other, ElectricApparentPower tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricApparentPower"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricApparentPower,ElectricApparentPower)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricApparentPower)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricApparentPower left, ElectricApparentPower right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricApparentPower"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricApparentPower other, ElectricApparentPower tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricApparentPower"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricApparentPower"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricApparentPower"/>, this method delegates to
+        ///     <see cref="Equals(ElectricApparentPower)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricApparentPower otherQuantity))
+            if (obj is not ElectricApparentPower otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricApparentPower"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricApparentPower other, ElectricApparentPower tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricApparentPower"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricApparentPower other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricApparentPower.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricApparentPower), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricApparentPower"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricApparentPower)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricApparentPower otherQuantity)) throw new ArgumentException("Expected type ElectricApparentPower.", nameof(obj));
+            if (obj is not ElectricApparentPower otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricApparentPower>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricApparentPower"/> with another <see cref="ElectricApparentPower"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricApparentPower"/> with another <see cref="ElectricApparentPower"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -672,139 +672,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricApparentPower other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricApparentPowerUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricApparentPowerUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricApparentPower to another ElectricApparentPower with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricApparentPower with the specified unit.</returns>
-        public ElectricApparentPower ToUnit(ElectricApparentPowerUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricApparentPower"/> to another <see cref="ElectricApparentPower"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricApparentPower with the specified unit.</returns>
-        public ElectricApparentPower ToUnit(ElectricApparentPowerUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricApparentPower), Unit, typeof(ElectricApparentPower), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricApparentPower)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricApparentPower"/> to another <see cref="ElectricApparentPower"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricApparentPower"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricApparentPowerUnit unit, [NotNullWhen(true)] out ElectricApparentPower? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricApparentPower? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricApparentPowerUnit -> BaseUnit
-                (ElectricApparentPowerUnit.Gigavoltampere, ElectricApparentPowerUnit.Voltampere) => new ElectricApparentPower((_value) * 1e9d, ElectricApparentPowerUnit.Voltampere),
-                (ElectricApparentPowerUnit.Kilovoltampere, ElectricApparentPowerUnit.Voltampere) => new ElectricApparentPower((_value) * 1e3d, ElectricApparentPowerUnit.Voltampere),
-                (ElectricApparentPowerUnit.Megavoltampere, ElectricApparentPowerUnit.Voltampere) => new ElectricApparentPower((_value) * 1e6d, ElectricApparentPowerUnit.Voltampere),
-                (ElectricApparentPowerUnit.Microvoltampere, ElectricApparentPowerUnit.Voltampere) => new ElectricApparentPower((_value) * 1e-6d, ElectricApparentPowerUnit.Voltampere),
-                (ElectricApparentPowerUnit.Millivoltampere, ElectricApparentPowerUnit.Voltampere) => new ElectricApparentPower((_value) * 1e-3d, ElectricApparentPowerUnit.Voltampere),
-
-                // BaseUnit -> ElectricApparentPowerUnit
-                (ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Gigavoltampere) => new ElectricApparentPower((_value) / 1e9d, ElectricApparentPowerUnit.Gigavoltampere),
-                (ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Kilovoltampere) => new ElectricApparentPower((_value) / 1e3d, ElectricApparentPowerUnit.Kilovoltampere),
-                (ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Megavoltampere) => new ElectricApparentPower((_value) / 1e6d, ElectricApparentPowerUnit.Megavoltampere),
-                (ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Microvoltampere) => new ElectricApparentPower((_value) / 1e-6d, ElectricApparentPowerUnit.Microvoltampere),
-                (ElectricApparentPowerUnit.Voltampere, ElectricApparentPowerUnit.Millivoltampere) => new ElectricApparentPower((_value) / 1e-3d, ElectricApparentPowerUnit.Millivoltampere),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricApparentPowerUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricApparentPowerUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricApparentPowerUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricApparentPowerUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity<ElectricApparentPowerUnit> IQuantity<ElectricApparentPowerUnit>.ToUnit(ElectricApparentPowerUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -818,11 +688,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCapacitance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCapacitance.g.cs
index bb23cae42d..a639eddcae 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCapacitance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCapacitance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Capacitance
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricCapacitance :
-        IArithmeticQuantity<ElectricCapacitance, ElectricCapacitanceUnit>,
+        ILinearQuantity<ElectricCapacitance, ElectricCapacitanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricCapacitance, ElectricCapacitance, double>,
+        IDivisionOperators<ElectricCapacitance, ElectricCapacitance, QuantityValue>,
+        IMultiplyOperators<ElectricCapacitance, ElectricPotential, ElectricCharge>,
         IComparisonOperators<ElectricCapacitance, ElectricCapacitance, bool>,
         IParsable<ElectricCapacitance>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static ElectricCapacitanceInfo CreateDefault(Func<IEnumerable<UnitDefinit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricCapacitance"/> is [T^4][L^-2][M^-1][I^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricCapacitance"/> is T^4L^-2M^-1I^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, -1, 4, 2, 0, 0, 0);
 
@@ -121,20 +121,30 @@ public static ElectricCapacitanceInfo CreateDefault(Func<IEnumerable<UnitDefinit
             public static IEnumerable<UnitDefinition<ElectricCapacitanceUnit>> GetDefaultMappings()
             {
                 yield return new (ElectricCapacitanceUnit.Farad, "Farad", "Farads", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricCapacitanceUnit.Kilofarad, "Kilofarad", "Kilofarads", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricCapacitanceUnit.Megafarad, "Megafarad", "Megafarads", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricCapacitanceUnit.Microfarad, "Microfarad", "Microfarads", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricCapacitanceUnit.Millifarad, "Millifarad", "Millifarads", BaseUnits.Undefined);
-                yield return new (ElectricCapacitanceUnit.Nanofarad, "Nanofarad", "Nanofarads", BaseUnits.Undefined);
-                yield return new (ElectricCapacitanceUnit.Picofarad, "Picofarad", "Picofarads", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere));
+                yield return new (ElectricCapacitanceUnit.Kilofarad, "Kilofarad", "Kilofarads", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricCapacitanceUnit.Megafarad, "Megafarad", "Megafarads", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricCapacitanceUnit.Microfarad, "Microfarad", "Microfarads", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     1000000
+                );
+                yield return new (ElectricCapacitanceUnit.Millifarad, "Millifarad", "Millifarads", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (ElectricCapacitanceUnit.Nanofarad, "Nanofarad", "Nanofarads", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (ElectricCapacitanceUnit.Picofarad, "Picofarad", "Picofarads", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere),
+                     1000000000000
+                );
             }
         }
 
         static ElectricCapacitance()
         {
-            Info = ElectricCapacitanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricCapacitanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -142,7 +152,7 @@ static ElectricCapacitance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricCapacitance(double value, ElectricCapacitanceUnit unit)
+        public ElectricCapacitance(QuantityValue value, ElectricCapacitanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -156,7 +166,7 @@ public ElectricCapacitance(double value, ElectricCapacitanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricCapacitance(double value, UnitSystem unitSystem)
+        public ElectricCapacitance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -167,7 +177,8 @@ public ElectricCapacitance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricCapacitance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricCapacitance, ElectricCapacitanceUnit> Info { get; }
@@ -196,10 +207,8 @@ public ElectricCapacitance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricCapacitanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -233,70 +242,44 @@ public ElectricCapacitance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Farad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Farad"/>
         /// </summary>
-        public double Farads => As(ElectricCapacitanceUnit.Farad);
+        public QuantityValue Farads => this.As(ElectricCapacitanceUnit.Farad);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Kilofarad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Kilofarad"/>
         /// </summary>
-        public double Kilofarads => As(ElectricCapacitanceUnit.Kilofarad);
+        public QuantityValue Kilofarads => this.As(ElectricCapacitanceUnit.Kilofarad);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Megafarad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Megafarad"/>
         /// </summary>
-        public double Megafarads => As(ElectricCapacitanceUnit.Megafarad);
+        public QuantityValue Megafarads => this.As(ElectricCapacitanceUnit.Megafarad);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Microfarad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Microfarad"/>
         /// </summary>
-        public double Microfarads => As(ElectricCapacitanceUnit.Microfarad);
+        public QuantityValue Microfarads => this.As(ElectricCapacitanceUnit.Microfarad);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Millifarad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Millifarad"/>
         /// </summary>
-        public double Millifarads => As(ElectricCapacitanceUnit.Millifarad);
+        public QuantityValue Millifarads => this.As(ElectricCapacitanceUnit.Millifarad);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Nanofarad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Nanofarad"/>
         /// </summary>
-        public double Nanofarads => As(ElectricCapacitanceUnit.Nanofarad);
+        public QuantityValue Nanofarads => this.As(ElectricCapacitanceUnit.Nanofarad);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Picofarad"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCapacitanceUnit.Picofarad"/>
         /// </summary>
-        public double Picofarads => As(ElectricCapacitanceUnit.Picofarad);
+        public QuantityValue Picofarads => this.As(ElectricCapacitanceUnit.Picofarad);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricCapacitanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Kilofarad, ElectricCapacitanceUnit.Farad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Farad));
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Megafarad, ElectricCapacitanceUnit.Farad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Farad));
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Microfarad, ElectricCapacitanceUnit.Farad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Farad));
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Millifarad, ElectricCapacitanceUnit.Farad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Farad));
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Nanofarad, ElectricCapacitanceUnit.Farad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Farad));
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Picofarad, ElectricCapacitanceUnit.Farad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Farad));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Farad, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricCapacitanceUnit
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Kilofarad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Kilofarad));
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Megafarad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Megafarad));
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Microfarad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Microfarad));
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Millifarad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Millifarad));
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Nanofarad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Nanofarad));
-            unitConverter.SetConversionFunction<ElectricCapacitance>(ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Picofarad, quantity => quantity.ToUnit(ElectricCapacitanceUnit.Picofarad));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -325,7 +308,7 @@ public static string GetAbbreviation(ElectricCapacitanceUnit unit, IFormatProvid
         /// <summary>
         ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Farad"/>.
         /// </summary>
-        public static ElectricCapacitance FromFarads(double value)
+        public static ElectricCapacitance FromFarads(QuantityValue value)
         {
             return new ElectricCapacitance(value, ElectricCapacitanceUnit.Farad);
         }
@@ -333,7 +316,7 @@ public static ElectricCapacitance FromFarads(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Kilofarad"/>.
         /// </summary>
-        public static ElectricCapacitance FromKilofarads(double value)
+        public static ElectricCapacitance FromKilofarads(QuantityValue value)
         {
             return new ElectricCapacitance(value, ElectricCapacitanceUnit.Kilofarad);
         }
@@ -341,7 +324,7 @@ public static ElectricCapacitance FromKilofarads(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Megafarad"/>.
         /// </summary>
-        public static ElectricCapacitance FromMegafarads(double value)
+        public static ElectricCapacitance FromMegafarads(QuantityValue value)
         {
             return new ElectricCapacitance(value, ElectricCapacitanceUnit.Megafarad);
         }
@@ -349,7 +332,7 @@ public static ElectricCapacitance FromMegafarads(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Microfarad"/>.
         /// </summary>
-        public static ElectricCapacitance FromMicrofarads(double value)
+        public static ElectricCapacitance FromMicrofarads(QuantityValue value)
         {
             return new ElectricCapacitance(value, ElectricCapacitanceUnit.Microfarad);
         }
@@ -357,7 +340,7 @@ public static ElectricCapacitance FromMicrofarads(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Millifarad"/>.
         /// </summary>
-        public static ElectricCapacitance FromMillifarads(double value)
+        public static ElectricCapacitance FromMillifarads(QuantityValue value)
         {
             return new ElectricCapacitance(value, ElectricCapacitanceUnit.Millifarad);
         }
@@ -365,7 +348,7 @@ public static ElectricCapacitance FromMillifarads(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Nanofarad"/>.
         /// </summary>
-        public static ElectricCapacitance FromNanofarads(double value)
+        public static ElectricCapacitance FromNanofarads(QuantityValue value)
         {
             return new ElectricCapacitance(value, ElectricCapacitanceUnit.Nanofarad);
         }
@@ -373,7 +356,7 @@ public static ElectricCapacitance FromNanofarads(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCapacitance"/> from <see cref="ElectricCapacitanceUnit.Picofarad"/>.
         /// </summary>
-        public static ElectricCapacitance FromPicofarads(double value)
+        public static ElectricCapacitance FromPicofarads(QuantityValue value)
         {
             return new ElectricCapacitance(value, ElectricCapacitanceUnit.Picofarad);
         }
@@ -384,7 +367,7 @@ public static ElectricCapacitance FromPicofarads(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricCapacitance unit value.</returns>
-        public static ElectricCapacitance From(double value, ElectricCapacitanceUnit fromUnit)
+        public static ElectricCapacitance From(QuantityValue value, ElectricCapacitanceUnit fromUnit)
         {
             return new ElectricCapacitance(value, fromUnit);
         }
@@ -445,10 +428,7 @@ public static ElectricCapacitance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricCapacitance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricCapacitance, ElectricCapacitanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricCapacitance, ElectricCapacitanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -476,11 +456,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricCapacita
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricCapacitance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricCapacitance, ElectricCapacitanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricCapacitance, ElectricCapacitanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -501,7 +477,7 @@ public static ElectricCapacitanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -512,7 +488,7 @@ public static ElectricCapacitanceUnit ParseUnit(string str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricCapacitanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricCapacitanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCapacitanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -527,7 +503,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCapa
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricCapacitanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -546,137 +522,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricCapacitance"/> from adding two <see cref="ElectricCapacitance"/>.</summary>
         public static ElectricCapacitance operator +(ElectricCapacitance left, ElectricCapacitance right)
         {
-            return new ElectricCapacitance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricCapacitance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCapacitance"/> from subtracting two <see cref="ElectricCapacitance"/>.</summary>
         public static ElectricCapacitance operator -(ElectricCapacitance left, ElectricCapacitance right)
         {
-            return new ElectricCapacitance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricCapacitance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCapacitance"/> from multiplying value and <see cref="ElectricCapacitance"/>.</summary>
-        public static ElectricCapacitance operator *(double left, ElectricCapacitance right)
+        public static ElectricCapacitance operator *(QuantityValue left, ElectricCapacitance right)
         {
             return new ElectricCapacitance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCapacitance"/> from multiplying value and <see cref="ElectricCapacitance"/>.</summary>
-        public static ElectricCapacitance operator *(ElectricCapacitance left, double right)
+        public static ElectricCapacitance operator *(ElectricCapacitance left, QuantityValue right)
         {
             return new ElectricCapacitance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCapacitance"/> from dividing <see cref="ElectricCapacitance"/> by value.</summary>
-        public static ElectricCapacitance operator /(ElectricCapacitance left, double right)
+        public static ElectricCapacitance operator /(ElectricCapacitance left, QuantityValue right)
         {
             return new ElectricCapacitance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricCapacitance"/> by <see cref="ElectricCapacitance"/>.</summary>
-        public static double operator /(ElectricCapacitance left, ElectricCapacitance right)
+        public static QuantityValue operator /(ElectricCapacitance left, ElectricCapacitance right)
         {
             return left.Farads / right.Farads;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="ElectricCharge"/> from <see cref="ElectricCapacitance"/> * <see cref="ElectricPotential"/>.</summary>
+        public static ElectricCharge operator *(ElectricCapacitance electricCapacitance, ElectricPotential electricPotential)
+        {
+            return ElectricCharge.FromCoulombs(electricCapacitance.Farads * electricPotential.Volts);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricCapacitance left, ElectricCapacitance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricCapacitance left, ElectricCapacitance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricCapacitance left, ElectricCapacitance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricCapacitance left, ElectricCapacitance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricCapacitance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricCapacitance other, ElectricCapacitance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricCapacitance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricCapacitance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricCapacitance left, ElectricCapacitance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricCapacitance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricCapacitance other, ElectricCapacitance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricCapacitance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricCapacitance,ElectricCapacitance)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricCapacitance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricCapacitance left, ElectricCapacitance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricCapacitance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricCapacitance other, ElectricCapacitance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricCapacitance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricCapacitance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricCapacitance"/>, this method delegates to
+        ///     <see cref="Equals(ElectricCapacitance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricCapacitance otherQuantity))
+            if (obj is not ElectricCapacitance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricCapacitance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricCapacitance other, ElectricCapacitance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricCapacitance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricCapacitance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricCapacitance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricCapacitance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricCapacitance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricCapacitance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricCapacitance otherQuantity)) throw new ArgumentException("Expected type ElectricCapacitance.", nameof(obj));
+            if (obj is not ElectricCapacitance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricCapacitance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricCapacitance"/> with another <see cref="ElectricCapacitance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricCapacitance"/> with another <see cref="ElectricCapacitance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -688,141 +688,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricCapacitance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricCapacitanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricCapacitanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricCapacitance to another ElectricCapacitance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricCapacitance with the specified unit.</returns>
-        public ElectricCapacitance ToUnit(ElectricCapacitanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricCapacitance"/> to another <see cref="ElectricCapacitance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricCapacitance with the specified unit.</returns>
-        public ElectricCapacitance ToUnit(ElectricCapacitanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricCapacitance), Unit, typeof(ElectricCapacitance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricCapacitance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricCapacitance"/> to another <see cref="ElectricCapacitance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricCapacitance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricCapacitanceUnit unit, [NotNullWhen(true)] out ElectricCapacitance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricCapacitance? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricCapacitanceUnit -> BaseUnit
-                (ElectricCapacitanceUnit.Kilofarad, ElectricCapacitanceUnit.Farad) => new ElectricCapacitance((_value) * 1e3d, ElectricCapacitanceUnit.Farad),
-                (ElectricCapacitanceUnit.Megafarad, ElectricCapacitanceUnit.Farad) => new ElectricCapacitance((_value) * 1e6d, ElectricCapacitanceUnit.Farad),
-                (ElectricCapacitanceUnit.Microfarad, ElectricCapacitanceUnit.Farad) => new ElectricCapacitance((_value) * 1e-6d, ElectricCapacitanceUnit.Farad),
-                (ElectricCapacitanceUnit.Millifarad, ElectricCapacitanceUnit.Farad) => new ElectricCapacitance((_value) * 1e-3d, ElectricCapacitanceUnit.Farad),
-                (ElectricCapacitanceUnit.Nanofarad, ElectricCapacitanceUnit.Farad) => new ElectricCapacitance((_value) * 1e-9d, ElectricCapacitanceUnit.Farad),
-                (ElectricCapacitanceUnit.Picofarad, ElectricCapacitanceUnit.Farad) => new ElectricCapacitance((_value) * 1e-12d, ElectricCapacitanceUnit.Farad),
-
-                // BaseUnit -> ElectricCapacitanceUnit
-                (ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Kilofarad) => new ElectricCapacitance((_value) / 1e3d, ElectricCapacitanceUnit.Kilofarad),
-                (ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Megafarad) => new ElectricCapacitance((_value) / 1e6d, ElectricCapacitanceUnit.Megafarad),
-                (ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Microfarad) => new ElectricCapacitance((_value) / 1e-6d, ElectricCapacitanceUnit.Microfarad),
-                (ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Millifarad) => new ElectricCapacitance((_value) / 1e-3d, ElectricCapacitanceUnit.Millifarad),
-                (ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Nanofarad) => new ElectricCapacitance((_value) / 1e-9d, ElectricCapacitanceUnit.Nanofarad),
-                (ElectricCapacitanceUnit.Farad, ElectricCapacitanceUnit.Picofarad) => new ElectricCapacitance((_value) / 1e-12d, ElectricCapacitanceUnit.Picofarad),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricCapacitanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCapacitanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricCapacitanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCapacitanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity<ElectricCapacitanceUnit> IQuantity<ElectricCapacitanceUnit>.ToUnit(ElectricCapacitanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -836,11 +704,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
index 1a42c24f6c..c3af99af9e 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,14 +36,21 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Electric_charge
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricCharge :
-        IArithmeticQuantity<ElectricCharge, ElectricChargeUnit>,
+        ILinearQuantity<ElectricCharge, ElectricChargeUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricCharge, ElectricCharge, double>,
+        IDivisionOperators<ElectricCharge, ElectricCharge, QuantityValue>,
+        IDivisionOperators<ElectricCharge, ElectricSurfaceChargeDensity, Area>,
         IDivisionOperators<ElectricCharge, ElectricCurrent, Duration>,
+        IDivisionOperators<ElectricCharge, ElectricPotential, ElectricCapacitance>,
+        IDivisionOperators<ElectricCharge, Volume, ElectricChargeDensity>,
         IDivisionOperators<ElectricCharge, Duration, ElectricCurrent>,
+        IDivisionOperators<ElectricCharge, ElectricCapacitance, ElectricPotential>,
+        IDivisionOperators<ElectricCharge, Area, ElectricSurfaceChargeDensity>,
         IMultiplyOperators<ElectricCharge, ElectricPotential, Energy>,
+        IDivisionOperators<ElectricCharge, ElectricChargeDensity, Volume>,
         IComparisonOperators<ElectricCharge, ElectricCharge, bool>,
         IParsable<ElectricCharge>,
 #endif
@@ -58,7 +63,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -108,7 +113,7 @@ public static ElectricChargeInfo CreateDefault(Func<IEnumerable<UnitDefinition<E
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricCharge"/> is [T][I].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricCharge"/> is TI.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, 1, 1, 0, 0, 0);
 
@@ -123,25 +128,43 @@ public static ElectricChargeInfo CreateDefault(Func<IEnumerable<UnitDefinition<E
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricChargeUnit}"/> representing the default unit mappings for ElectricCharge.</returns>
             public static IEnumerable<UnitDefinition<ElectricChargeUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricChargeUnit.AmpereHour, "AmpereHour", "AmpereHours", new BaseUnits(time: DurationUnit.Hour, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricChargeUnit.AmpereHour, "AmpereHour", "AmpereHours", new BaseUnits(time: DurationUnit.Hour, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 3600)
+                );
                 yield return new (ElectricChargeUnit.Coulomb, "Coulomb", "Coulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricChargeUnit.KiloampereHour, "KiloampereHour", "KiloampereHours", new BaseUnits(time: DurationUnit.Hour, current: ElectricCurrentUnit.Kiloampere));
-                yield return new (ElectricChargeUnit.Kilocoulomb, "Kilocoulomb", "Kilocoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Kiloampere));
-                yield return new (ElectricChargeUnit.MegaampereHour, "MegaampereHour", "MegaampereHours", new BaseUnits(time: DurationUnit.Hour, current: ElectricCurrentUnit.Megaampere));
-                yield return new (ElectricChargeUnit.Megacoulomb, "Megacoulomb", "Megacoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Megaampere));
-                yield return new (ElectricChargeUnit.Microcoulomb, "Microcoulomb", "Microcoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere));
-                yield return new (ElectricChargeUnit.MilliampereHour, "MilliampereHour", "MilliampereHours", new BaseUnits(time: DurationUnit.Hour, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricChargeUnit.Millicoulomb, "Millicoulomb", "Millicoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricChargeUnit.Nanocoulomb, "Nanocoulomb", "Nanocoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Nanoampere));
-                yield return new (ElectricChargeUnit.Picocoulomb, "Picocoulomb", "Picocoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Picoampere));
+                yield return new (ElectricChargeUnit.KiloampereHour, "KiloampereHour", "KiloampereHours", new BaseUnits(time: DurationUnit.Hour, current: ElectricCurrentUnit.Kiloampere),
+                     new QuantityValue(1, 3600000)
+                );
+                yield return new (ElectricChargeUnit.Kilocoulomb, "Kilocoulomb", "Kilocoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Kiloampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricChargeUnit.MegaampereHour, "MegaampereHour", "MegaampereHours", new BaseUnits(time: DurationUnit.Hour, current: ElectricCurrentUnit.Megaampere),
+                     new QuantityValue(1, 3600000000)
+                );
+                yield return new (ElectricChargeUnit.Megacoulomb, "Megacoulomb", "Megacoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Megaampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricChargeUnit.Microcoulomb, "Microcoulomb", "Microcoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere),
+                     1000000
+                );
+                yield return new (ElectricChargeUnit.MilliampereHour, "MilliampereHour", "MilliampereHours", new BaseUnits(time: DurationUnit.Hour, current: ElectricCurrentUnit.Milliampere),
+                     new QuantityValue(5, 18)
+                );
+                yield return new (ElectricChargeUnit.Millicoulomb, "Millicoulomb", "Millicoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     1000
+                );
+                yield return new (ElectricChargeUnit.Nanocoulomb, "Nanocoulomb", "Nanocoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Nanoampere),
+                     1000000000
+                );
+                yield return new (ElectricChargeUnit.Picocoulomb, "Picocoulomb", "Picocoulombs", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Picoampere),
+                     1000000000000
+                );
             }
         }
 
         static ElectricCharge()
         {
-            Info = ElectricChargeInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricChargeInfo.CreateDefault);
         }
 
         /// <summary>
@@ -149,7 +172,7 @@ static ElectricCharge()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricCharge(double value, ElectricChargeUnit unit)
+        public ElectricCharge(QuantityValue value, ElectricChargeUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -163,7 +186,7 @@ public ElectricCharge(double value, ElectricChargeUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricCharge(double value, UnitSystem unitSystem)
+        public ElectricCharge(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -174,7 +197,8 @@ public ElectricCharge(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricCharge" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricCharge, ElectricChargeUnit> Info { get; }
@@ -203,10 +227,8 @@ public ElectricCharge(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricChargeUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -240,98 +262,64 @@ public ElectricCharge(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.AmpereHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.AmpereHour"/>
         /// </summary>
-        public double AmpereHours => As(ElectricChargeUnit.AmpereHour);
+        public QuantityValue AmpereHours => this.As(ElectricChargeUnit.AmpereHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Coulomb"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.Coulomb"/>
         /// </summary>
-        public double Coulombs => As(ElectricChargeUnit.Coulomb);
+        public QuantityValue Coulombs => this.As(ElectricChargeUnit.Coulomb);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.KiloampereHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.KiloampereHour"/>
         /// </summary>
-        public double KiloampereHours => As(ElectricChargeUnit.KiloampereHour);
+        public QuantityValue KiloampereHours => this.As(ElectricChargeUnit.KiloampereHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Kilocoulomb"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.Kilocoulomb"/>
         /// </summary>
-        public double Kilocoulombs => As(ElectricChargeUnit.Kilocoulomb);
+        public QuantityValue Kilocoulombs => this.As(ElectricChargeUnit.Kilocoulomb);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.MegaampereHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.MegaampereHour"/>
         /// </summary>
-        public double MegaampereHours => As(ElectricChargeUnit.MegaampereHour);
+        public QuantityValue MegaampereHours => this.As(ElectricChargeUnit.MegaampereHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Megacoulomb"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.Megacoulomb"/>
         /// </summary>
-        public double Megacoulombs => As(ElectricChargeUnit.Megacoulomb);
+        public QuantityValue Megacoulombs => this.As(ElectricChargeUnit.Megacoulomb);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Microcoulomb"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.Microcoulomb"/>
         /// </summary>
-        public double Microcoulombs => As(ElectricChargeUnit.Microcoulomb);
+        public QuantityValue Microcoulombs => this.As(ElectricChargeUnit.Microcoulomb);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.MilliampereHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.MilliampereHour"/>
         /// </summary>
-        public double MilliampereHours => As(ElectricChargeUnit.MilliampereHour);
+        public QuantityValue MilliampereHours => this.As(ElectricChargeUnit.MilliampereHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Millicoulomb"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.Millicoulomb"/>
         /// </summary>
-        public double Millicoulombs => As(ElectricChargeUnit.Millicoulomb);
+        public QuantityValue Millicoulombs => this.As(ElectricChargeUnit.Millicoulomb);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Nanocoulomb"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.Nanocoulomb"/>
         /// </summary>
-        public double Nanocoulombs => As(ElectricChargeUnit.Nanocoulomb);
+        public QuantityValue Nanocoulombs => this.As(ElectricChargeUnit.Nanocoulomb);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeUnit.Picocoulomb"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeUnit.Picocoulomb"/>
         /// </summary>
-        public double Picocoulombs => As(ElectricChargeUnit.Picocoulomb);
+        public QuantityValue Picocoulombs => this.As(ElectricChargeUnit.Picocoulomb);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricChargeUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.AmpereHour, ElectricChargeUnit.Coulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Coulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.KiloampereHour, ElectricChargeUnit.Coulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Coulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Kilocoulomb, ElectricChargeUnit.Coulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Coulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.MegaampereHour, ElectricChargeUnit.Coulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Coulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Megacoulomb, ElectricChargeUnit.Coulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Coulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Microcoulomb, ElectricChargeUnit.Coulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Coulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.MilliampereHour, ElectricChargeUnit.Coulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Coulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Millicoulomb, ElectricChargeUnit.Coulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Coulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Nanocoulomb, ElectricChargeUnit.Coulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Coulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Picocoulomb, ElectricChargeUnit.Coulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Coulomb));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.Coulomb, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricChargeUnit
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.AmpereHour, quantity => quantity.ToUnit(ElectricChargeUnit.AmpereHour));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.KiloampereHour, quantity => quantity.ToUnit(ElectricChargeUnit.KiloampereHour));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.Kilocoulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Kilocoulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.MegaampereHour, quantity => quantity.ToUnit(ElectricChargeUnit.MegaampereHour));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.Megacoulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Megacoulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.Microcoulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Microcoulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.MilliampereHour, quantity => quantity.ToUnit(ElectricChargeUnit.MilliampereHour));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.Millicoulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Millicoulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.Nanocoulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Nanocoulomb));
-            unitConverter.SetConversionFunction<ElectricCharge>(ElectricChargeUnit.Coulomb, ElectricChargeUnit.Picocoulomb, quantity => quantity.ToUnit(ElectricChargeUnit.Picocoulomb));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -360,7 +348,7 @@ public static string GetAbbreviation(ElectricChargeUnit unit, IFormatProvider? p
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.AmpereHour"/>.
         /// </summary>
-        public static ElectricCharge FromAmpereHours(double value)
+        public static ElectricCharge FromAmpereHours(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.AmpereHour);
         }
@@ -368,7 +356,7 @@ public static ElectricCharge FromAmpereHours(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Coulomb"/>.
         /// </summary>
-        public static ElectricCharge FromCoulombs(double value)
+        public static ElectricCharge FromCoulombs(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.Coulomb);
         }
@@ -376,7 +364,7 @@ public static ElectricCharge FromCoulombs(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.KiloampereHour"/>.
         /// </summary>
-        public static ElectricCharge FromKiloampereHours(double value)
+        public static ElectricCharge FromKiloampereHours(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.KiloampereHour);
         }
@@ -384,7 +372,7 @@ public static ElectricCharge FromKiloampereHours(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Kilocoulomb"/>.
         /// </summary>
-        public static ElectricCharge FromKilocoulombs(double value)
+        public static ElectricCharge FromKilocoulombs(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.Kilocoulomb);
         }
@@ -392,7 +380,7 @@ public static ElectricCharge FromKilocoulombs(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.MegaampereHour"/>.
         /// </summary>
-        public static ElectricCharge FromMegaampereHours(double value)
+        public static ElectricCharge FromMegaampereHours(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.MegaampereHour);
         }
@@ -400,7 +388,7 @@ public static ElectricCharge FromMegaampereHours(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Megacoulomb"/>.
         /// </summary>
-        public static ElectricCharge FromMegacoulombs(double value)
+        public static ElectricCharge FromMegacoulombs(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.Megacoulomb);
         }
@@ -408,7 +396,7 @@ public static ElectricCharge FromMegacoulombs(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Microcoulomb"/>.
         /// </summary>
-        public static ElectricCharge FromMicrocoulombs(double value)
+        public static ElectricCharge FromMicrocoulombs(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.Microcoulomb);
         }
@@ -416,7 +404,7 @@ public static ElectricCharge FromMicrocoulombs(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.MilliampereHour"/>.
         /// </summary>
-        public static ElectricCharge FromMilliampereHours(double value)
+        public static ElectricCharge FromMilliampereHours(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.MilliampereHour);
         }
@@ -424,7 +412,7 @@ public static ElectricCharge FromMilliampereHours(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Millicoulomb"/>.
         /// </summary>
-        public static ElectricCharge FromMillicoulombs(double value)
+        public static ElectricCharge FromMillicoulombs(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.Millicoulomb);
         }
@@ -432,7 +420,7 @@ public static ElectricCharge FromMillicoulombs(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Nanocoulomb"/>.
         /// </summary>
-        public static ElectricCharge FromNanocoulombs(double value)
+        public static ElectricCharge FromNanocoulombs(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.Nanocoulomb);
         }
@@ -440,7 +428,7 @@ public static ElectricCharge FromNanocoulombs(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Picocoulomb"/>.
         /// </summary>
-        public static ElectricCharge FromPicocoulombs(double value)
+        public static ElectricCharge FromPicocoulombs(QuantityValue value)
         {
             return new ElectricCharge(value, ElectricChargeUnit.Picocoulomb);
         }
@@ -451,7 +439,7 @@ public static ElectricCharge FromPicocoulombs(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricCharge unit value.</returns>
-        public static ElectricCharge From(double value, ElectricChargeUnit fromUnit)
+        public static ElectricCharge From(QuantityValue value, ElectricChargeUnit fromUnit)
         {
             return new ElectricCharge(value, fromUnit);
         }
@@ -512,10 +500,7 @@ public static ElectricCharge Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricCharge Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricCharge, ElectricChargeUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricCharge, ElectricChargeUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -543,11 +528,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricCharge r
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricCharge result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricCharge, ElectricChargeUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricCharge, ElectricChargeUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -568,7 +549,7 @@ public static ElectricChargeUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -579,7 +560,7 @@ public static ElectricChargeUnit ParseUnit(string str, IFormatProvider? provider
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricChargeUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricChargeUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricChargeUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -594,7 +575,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricChar
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricChargeUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -613,35 +594,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricCharge"/> from adding two <see cref="ElectricCharge"/>.</summary>
         public static ElectricCharge operator +(ElectricCharge left, ElectricCharge right)
         {
-            return new ElectricCharge(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricCharge(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCharge"/> from subtracting two <see cref="ElectricCharge"/>.</summary>
         public static ElectricCharge operator -(ElectricCharge left, ElectricCharge right)
         {
-            return new ElectricCharge(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricCharge(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCharge"/> from multiplying value and <see cref="ElectricCharge"/>.</summary>
-        public static ElectricCharge operator *(double left, ElectricCharge right)
+        public static ElectricCharge operator *(QuantityValue left, ElectricCharge right)
         {
             return new ElectricCharge(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCharge"/> from multiplying value and <see cref="ElectricCharge"/>.</summary>
-        public static ElectricCharge operator *(ElectricCharge left, double right)
+        public static ElectricCharge operator *(ElectricCharge left, QuantityValue right)
         {
             return new ElectricCharge(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCharge"/> from dividing <see cref="ElectricCharge"/> by value.</summary>
-        public static ElectricCharge operator /(ElectricCharge left, double right)
+        public static ElectricCharge operator /(ElectricCharge left, QuantityValue right)
         {
             return new ElectricCharge(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricCharge"/> by <see cref="ElectricCharge"/>.</summary>
-        public static double operator /(ElectricCharge left, ElectricCharge right)
+        public static QuantityValue operator /(ElectricCharge left, ElectricCharge right)
         {
             return left.Coulombs / right.Coulombs;
         }
@@ -650,24 +631,60 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="Area"/> from <see cref="ElectricCharge"/> / <see cref="ElectricSurfaceChargeDensity"/>.</summary>
+        public static Area operator /(ElectricCharge electricCharge, ElectricSurfaceChargeDensity electricSurfaceChargeDensity)
+        {
+            return Area.FromSquareMeters(electricCharge.Coulombs / electricSurfaceChargeDensity.CoulombsPerSquareMeter);
+        }
+
         /// <summary>Get <see cref="Duration"/> from <see cref="ElectricCharge"/> / <see cref="ElectricCurrent"/>.</summary>
         public static Duration operator /(ElectricCharge electricCharge, ElectricCurrent electricCurrent)
         {
             return Duration.FromHours(electricCharge.AmpereHours / electricCurrent.Amperes);
         }
 
+        /// <summary>Get <see cref="ElectricCapacitance"/> from <see cref="ElectricCharge"/> / <see cref="ElectricPotential"/>.</summary>
+        public static ElectricCapacitance operator /(ElectricCharge electricCharge, ElectricPotential electricPotential)
+        {
+            return ElectricCapacitance.FromFarads(electricCharge.Coulombs / electricPotential.Volts);
+        }
+
+        /// <summary>Get <see cref="ElectricChargeDensity"/> from <see cref="ElectricCharge"/> / <see cref="Volume"/>.</summary>
+        public static ElectricChargeDensity operator /(ElectricCharge electricCharge, Volume volume)
+        {
+            return ElectricChargeDensity.FromCoulombsPerCubicMeter(electricCharge.Coulombs / volume.CubicMeters);
+        }
+
         /// <summary>Get <see cref="ElectricCurrent"/> from <see cref="ElectricCharge"/> / <see cref="Duration"/>.</summary>
         public static ElectricCurrent operator /(ElectricCharge electricCharge, Duration duration)
         {
             return ElectricCurrent.FromAmperes(electricCharge.AmpereHours / duration.Hours);
         }
 
+        /// <summary>Get <see cref="ElectricPotential"/> from <see cref="ElectricCharge"/> / <see cref="ElectricCapacitance"/>.</summary>
+        public static ElectricPotential operator /(ElectricCharge electricCharge, ElectricCapacitance electricCapacitance)
+        {
+            return ElectricPotential.FromVolts(electricCharge.Coulombs / electricCapacitance.Farads);
+        }
+
+        /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricCharge"/> / <see cref="Area"/>.</summary>
+        public static ElectricSurfaceChargeDensity operator /(ElectricCharge electricCharge, Area area)
+        {
+            return ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(electricCharge.Coulombs / area.SquareMeters);
+        }
+
         /// <summary>Get <see cref="Energy"/> from <see cref="ElectricCharge"/> * <see cref="ElectricPotential"/>.</summary>
         public static Energy operator *(ElectricCharge electricCharge, ElectricPotential electricPotential)
         {
             return Energy.FromJoules(electricCharge.Coulombs * electricPotential.Volts);
         }
 
+        /// <summary>Get <see cref="Volume"/> from <see cref="ElectricCharge"/> / <see cref="ElectricChargeDensity"/>.</summary>
+        public static Volume operator /(ElectricCharge electricCharge, ElectricChargeDensity electricChargeDensity)
+        {
+            return Volume.FromCubicMeters(electricCharge.Coulombs / electricChargeDensity.CoulombsPerCubicMeter);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -675,97 +692,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricCharge left, ElectricCharge right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricCharge left, ElectricCharge right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricCharge left, ElectricCharge right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricCharge left, ElectricCharge right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricCharge"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricCharge other, ElectricCharge tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricCharge"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricCharge)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricCharge left, ElectricCharge right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricCharge"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricCharge other, ElectricCharge tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricCharge"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricCharge,ElectricCharge)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricCharge)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricCharge left, ElectricCharge right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricCharge"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricCharge other, ElectricCharge tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricCharge"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricCharge"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricCharge"/>, this method delegates to
+        ///     <see cref="Equals(ElectricCharge)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricCharge otherQuantity))
+            if (obj is not ElectricCharge otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricCharge"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricCharge other, ElectricCharge tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricCharge"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricCharge other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricCharge.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricCharge), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricCharge"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricCharge)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricCharge otherQuantity)) throw new ArgumentException("Expected type ElectricCharge.", nameof(obj));
+            if (obj is not ElectricCharge otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricCharge>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricCharge"/> with another <see cref="ElectricCharge"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricCharge"/> with another <see cref="ElectricCharge"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -777,149 +808,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricCharge other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricChargeUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricChargeUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricCharge to another ElectricCharge with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricCharge with the specified unit.</returns>
-        public ElectricCharge ToUnit(ElectricChargeUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricCharge"/> to another <see cref="ElectricCharge"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricCharge with the specified unit.</returns>
-        public ElectricCharge ToUnit(ElectricChargeUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricCharge), Unit, typeof(ElectricCharge), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricCharge)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricCharge"/> to another <see cref="ElectricCharge"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricCharge"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricChargeUnit unit, [NotNullWhen(true)] out ElectricCharge? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricCharge? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricChargeUnit -> BaseUnit
-                (ElectricChargeUnit.AmpereHour, ElectricChargeUnit.Coulomb) => new ElectricCharge(_value * 3600, ElectricChargeUnit.Coulomb),
-                (ElectricChargeUnit.KiloampereHour, ElectricChargeUnit.Coulomb) => new ElectricCharge((_value * 3600) * 1e3d, ElectricChargeUnit.Coulomb),
-                (ElectricChargeUnit.Kilocoulomb, ElectricChargeUnit.Coulomb) => new ElectricCharge((_value) * 1e3d, ElectricChargeUnit.Coulomb),
-                (ElectricChargeUnit.MegaampereHour, ElectricChargeUnit.Coulomb) => new ElectricCharge((_value * 3600) * 1e6d, ElectricChargeUnit.Coulomb),
-                (ElectricChargeUnit.Megacoulomb, ElectricChargeUnit.Coulomb) => new ElectricCharge((_value) * 1e6d, ElectricChargeUnit.Coulomb),
-                (ElectricChargeUnit.Microcoulomb, ElectricChargeUnit.Coulomb) => new ElectricCharge((_value) * 1e-6d, ElectricChargeUnit.Coulomb),
-                (ElectricChargeUnit.MilliampereHour, ElectricChargeUnit.Coulomb) => new ElectricCharge((_value * 3600) * 1e-3d, ElectricChargeUnit.Coulomb),
-                (ElectricChargeUnit.Millicoulomb, ElectricChargeUnit.Coulomb) => new ElectricCharge((_value) * 1e-3d, ElectricChargeUnit.Coulomb),
-                (ElectricChargeUnit.Nanocoulomb, ElectricChargeUnit.Coulomb) => new ElectricCharge((_value) * 1e-9d, ElectricChargeUnit.Coulomb),
-                (ElectricChargeUnit.Picocoulomb, ElectricChargeUnit.Coulomb) => new ElectricCharge((_value) * 1e-12d, ElectricChargeUnit.Coulomb),
-
-                // BaseUnit -> ElectricChargeUnit
-                (ElectricChargeUnit.Coulomb, ElectricChargeUnit.AmpereHour) => new ElectricCharge(_value / 3600, ElectricChargeUnit.AmpereHour),
-                (ElectricChargeUnit.Coulomb, ElectricChargeUnit.KiloampereHour) => new ElectricCharge((_value / 3600) / 1e3d, ElectricChargeUnit.KiloampereHour),
-                (ElectricChargeUnit.Coulomb, ElectricChargeUnit.Kilocoulomb) => new ElectricCharge((_value) / 1e3d, ElectricChargeUnit.Kilocoulomb),
-                (ElectricChargeUnit.Coulomb, ElectricChargeUnit.MegaampereHour) => new ElectricCharge((_value / 3600) / 1e6d, ElectricChargeUnit.MegaampereHour),
-                (ElectricChargeUnit.Coulomb, ElectricChargeUnit.Megacoulomb) => new ElectricCharge((_value) / 1e6d, ElectricChargeUnit.Megacoulomb),
-                (ElectricChargeUnit.Coulomb, ElectricChargeUnit.Microcoulomb) => new ElectricCharge((_value) / 1e-6d, ElectricChargeUnit.Microcoulomb),
-                (ElectricChargeUnit.Coulomb, ElectricChargeUnit.MilliampereHour) => new ElectricCharge((_value / 3600) / 1e-3d, ElectricChargeUnit.MilliampereHour),
-                (ElectricChargeUnit.Coulomb, ElectricChargeUnit.Millicoulomb) => new ElectricCharge((_value) / 1e-3d, ElectricChargeUnit.Millicoulomb),
-                (ElectricChargeUnit.Coulomb, ElectricChargeUnit.Nanocoulomb) => new ElectricCharge((_value) / 1e-9d, ElectricChargeUnit.Nanocoulomb),
-                (ElectricChargeUnit.Coulomb, ElectricChargeUnit.Picocoulomb) => new ElectricCharge((_value) / 1e-12d, ElectricChargeUnit.Picocoulomb),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricChargeUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricChargeUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricChargeUnit> IQuantity<ElectricChargeUnit>.ToUnit(ElectricChargeUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -933,11 +824,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
index 7c358b5237..ff23698f29 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Charge_density
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricChargeDensity :
-        IArithmeticQuantity<ElectricChargeDensity, ElectricChargeDensityUnit>,
+        ILinearQuantity<ElectricChargeDensity, ElectricChargeDensityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricChargeDensity, ElectricChargeDensity, double>,
+        IDivisionOperators<ElectricChargeDensity, ElectricChargeDensity, QuantityValue>,
+        IMultiplyOperators<ElectricChargeDensity, Volume, ElectricCharge>,
         IComparisonOperators<ElectricChargeDensity, ElectricChargeDensity, bool>,
         IParsable<ElectricChargeDensity>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static ElectricChargeDensityInfo CreateDefault(Func<IEnumerable<UnitDefin
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricChargeDensity"/> is [T][L^-3][I].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricChargeDensity"/> is TL^-3I.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-3, 0, 1, 1, 0, 0, 0);
 
@@ -126,9 +126,7 @@ public static IEnumerable<UnitDefinition<ElectricChargeDensityUnit>> GetDefaultM
 
         static ElectricChargeDensity()
         {
-            Info = ElectricChargeDensityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricChargeDensityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +134,7 @@ static ElectricChargeDensity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricChargeDensity(double value, ElectricChargeDensityUnit unit)
+        public ElectricChargeDensity(QuantityValue value, ElectricChargeDensityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -150,7 +148,7 @@ public ElectricChargeDensity(double value, ElectricChargeDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricChargeDensity(double value, UnitSystem unitSystem)
+        public ElectricChargeDensity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -161,7 +159,8 @@ public ElectricChargeDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricChargeDensity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricChargeDensity, ElectricChargeDensityUnit> Info { get; }
@@ -190,10 +189,8 @@ public ElectricChargeDensity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricChargeDensityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,28 +224,14 @@ public ElectricChargeDensity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricChargeDensityUnit.CoulombPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricChargeDensityUnit.CoulombPerCubicMeter"/>
         /// </summary>
-        public double CoulombsPerCubicMeter => As(ElectricChargeDensityUnit.CoulombPerCubicMeter);
+        public QuantityValue CoulombsPerCubicMeter => this.As(ElectricChargeDensityUnit.CoulombPerCubicMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricChargeDensityUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricChargeDensity>(ElectricChargeDensityUnit.CoulombPerCubicMeter, ElectricChargeDensityUnit.CoulombPerCubicMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricChargeDensityUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -277,7 +260,7 @@ public static string GetAbbreviation(ElectricChargeDensityUnit unit, IFormatProv
         /// <summary>
         ///     Creates a <see cref="ElectricChargeDensity"/> from <see cref="ElectricChargeDensityUnit.CoulombPerCubicMeter"/>.
         /// </summary>
-        public static ElectricChargeDensity FromCoulombsPerCubicMeter(double value)
+        public static ElectricChargeDensity FromCoulombsPerCubicMeter(QuantityValue value)
         {
             return new ElectricChargeDensity(value, ElectricChargeDensityUnit.CoulombPerCubicMeter);
         }
@@ -288,7 +271,7 @@ public static ElectricChargeDensity FromCoulombsPerCubicMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricChargeDensity unit value.</returns>
-        public static ElectricChargeDensity From(double value, ElectricChargeDensityUnit fromUnit)
+        public static ElectricChargeDensity From(QuantityValue value, ElectricChargeDensityUnit fromUnit)
         {
             return new ElectricChargeDensity(value, fromUnit);
         }
@@ -349,10 +332,7 @@ public static ElectricChargeDensity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricChargeDensity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricChargeDensity, ElectricChargeDensityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricChargeDensity, ElectricChargeDensityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -380,11 +360,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricChargeDe
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricChargeDensity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricChargeDensity, ElectricChargeDensityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricChargeDensity, ElectricChargeDensityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -405,7 +381,7 @@ public static ElectricChargeDensityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -416,7 +392,7 @@ public static ElectricChargeDensityUnit ParseUnit(string str, IFormatProvider? p
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricChargeDensityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricChargeDensityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricChargeDensityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -431,7 +407,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricChar
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricChargeDensityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -450,137 +426,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricChargeDensity"/> from adding two <see cref="ElectricChargeDensity"/>.</summary>
         public static ElectricChargeDensity operator +(ElectricChargeDensity left, ElectricChargeDensity right)
         {
-            return new ElectricChargeDensity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricChargeDensity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricChargeDensity"/> from subtracting two <see cref="ElectricChargeDensity"/>.</summary>
         public static ElectricChargeDensity operator -(ElectricChargeDensity left, ElectricChargeDensity right)
         {
-            return new ElectricChargeDensity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricChargeDensity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricChargeDensity"/> from multiplying value and <see cref="ElectricChargeDensity"/>.</summary>
-        public static ElectricChargeDensity operator *(double left, ElectricChargeDensity right)
+        public static ElectricChargeDensity operator *(QuantityValue left, ElectricChargeDensity right)
         {
             return new ElectricChargeDensity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricChargeDensity"/> from multiplying value and <see cref="ElectricChargeDensity"/>.</summary>
-        public static ElectricChargeDensity operator *(ElectricChargeDensity left, double right)
+        public static ElectricChargeDensity operator *(ElectricChargeDensity left, QuantityValue right)
         {
             return new ElectricChargeDensity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricChargeDensity"/> from dividing <see cref="ElectricChargeDensity"/> by value.</summary>
-        public static ElectricChargeDensity operator /(ElectricChargeDensity left, double right)
+        public static ElectricChargeDensity operator /(ElectricChargeDensity left, QuantityValue right)
         {
             return new ElectricChargeDensity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricChargeDensity"/> by <see cref="ElectricChargeDensity"/>.</summary>
-        public static double operator /(ElectricChargeDensity left, ElectricChargeDensity right)
+        public static QuantityValue operator /(ElectricChargeDensity left, ElectricChargeDensity right)
         {
             return left.CoulombsPerCubicMeter / right.CoulombsPerCubicMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="ElectricCharge"/> from <see cref="ElectricChargeDensity"/> * <see cref="Volume"/>.</summary>
+        public static ElectricCharge operator *(ElectricChargeDensity electricChargeDensity, Volume volume)
+        {
+            return ElectricCharge.FromCoulombs(electricChargeDensity.CoulombsPerCubicMeter * volume.CubicMeters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricChargeDensity left, ElectricChargeDensity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricChargeDensity left, ElectricChargeDensity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricChargeDensity left, ElectricChargeDensity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricChargeDensity left, ElectricChargeDensity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricChargeDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricChargeDensity other, ElectricChargeDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricChargeDensity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricChargeDensity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricChargeDensity left, ElectricChargeDensity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricChargeDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricChargeDensity other, ElectricChargeDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricChargeDensity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricChargeDensity,ElectricChargeDensity)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricChargeDensity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricChargeDensity left, ElectricChargeDensity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricChargeDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricChargeDensity other, ElectricChargeDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricChargeDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricChargeDensity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricChargeDensity"/>, this method delegates to
+        ///     <see cref="Equals(ElectricChargeDensity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricChargeDensity otherQuantity))
+            if (obj is not ElectricChargeDensity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricChargeDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricChargeDensity other, ElectricChargeDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricChargeDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricChargeDensity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricChargeDensity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricChargeDensity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricChargeDensity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricChargeDensity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricChargeDensity otherQuantity)) throw new ArgumentException("Expected type ElectricChargeDensity.", nameof(obj));
+            if (obj is not ElectricChargeDensity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricChargeDensity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricChargeDensity"/> with another <see cref="ElectricChargeDensity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricChargeDensity"/> with another <see cref="ElectricChargeDensity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -592,131 +592,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricChargeDensity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricChargeDensityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricChargeDensityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricChargeDensity to another ElectricChargeDensity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricChargeDensity with the specified unit.</returns>
-        public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricChargeDensity"/> to another <see cref="ElectricChargeDensity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricChargeDensity with the specified unit.</returns>
-        public ElectricChargeDensity ToUnit(ElectricChargeDensityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricChargeDensity), Unit, typeof(ElectricChargeDensity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricChargeDensity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricChargeDensity"/> to another <see cref="ElectricChargeDensity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricChargeDensity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricChargeDensityUnit unit, [NotNullWhen(true)] out ElectricChargeDensity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricChargeDensity? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricChargeDensityUnit -> BaseUnit
-
-                // BaseUnit -> ElectricChargeDensityUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricChargeDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeDensityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricChargeDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricChargeDensityUnit> IQuantity<ElectricChargeDensityUnit>.ToUnit(ElectricChargeDensityUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -728,11 +608,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
index f7a94f512f..9b34f2e776 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Electrical_resistance_and_conductance
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricConductance :
-        IArithmeticQuantity<ElectricConductance, ElectricConductanceUnit>,
+        ILinearQuantity<ElectricConductance, ElectricConductanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricConductance, ElectricConductance, double>,
+        IDivisionOperators<ElectricConductance, ElectricConductance, QuantityValue>,
+        IMultiplyOperators<ElectricConductance, ElectricPotential, ElectricCurrent>,
         IComparisonOperators<ElectricConductance, ElectricConductance, bool>,
         IParsable<ElectricConductance>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static ElectricConductanceInfo CreateDefault(Func<IEnumerable<UnitDefinit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricConductance"/> is [T^3][L^-2][M^-1][I^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricConductance"/> is T^3L^-2M^-1I^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0);
 
@@ -120,30 +120,58 @@ public static ElectricConductanceInfo CreateDefault(Func<IEnumerable<UnitDefinit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricConductanceUnit}"/> representing the default unit mappings for ElectricConductance.</returns>
             public static IEnumerable<UnitDefinition<ElectricConductanceUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricConductanceUnit.Gigamho, "Gigamho", "Gigamhos", BaseUnits.Undefined);
-                yield return new (ElectricConductanceUnit.Gigasiemens, "Gigasiemens", "Gigasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricConductanceUnit.Kilomho, "Kilomho", "Kilomhos", BaseUnits.Undefined);
-                yield return new (ElectricConductanceUnit.Kilosiemens, "Kilosiemens", "Kilosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricConductanceUnit.Megamho, "Megamho", "Megamhos", BaseUnits.Undefined);
-                yield return new (ElectricConductanceUnit.Megasiemens, "Megasiemens", "Megasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricConductanceUnit.Mho, "Mho", "Mhos", BaseUnits.Undefined);
-                yield return new (ElectricConductanceUnit.Micromho, "Micromho", "Micromhos", BaseUnits.Undefined);
-                yield return new (ElectricConductanceUnit.Microsiemens, "Microsiemens", "Microsiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricConductanceUnit.Millimho, "Millimho", "Millimhos", BaseUnits.Undefined);
-                yield return new (ElectricConductanceUnit.Millisiemens, "Millisiemens", "Millisiemens", BaseUnits.Undefined);
-                yield return new (ElectricConductanceUnit.Nanomho, "Nanomho", "Nanomhos", BaseUnits.Undefined);
-                yield return new (ElectricConductanceUnit.Nanosiemens, "Nanosiemens", "Nanosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricConductanceUnit.Gigamho, "Gigamho", "Gigamhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricConductanceUnit.Gigasiemens, "Gigasiemens", "Gigasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricConductanceUnit.Kilomho, "Kilomho", "Kilomhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricConductanceUnit.Kilosiemens, "Kilosiemens", "Kilosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricConductanceUnit.Megamho, "Megamho", "Megamhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricConductanceUnit.Megasiemens, "Megasiemens", "Megasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricConductanceUnit.Mho, "Mho", "Mhos", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (ElectricConductanceUnit.Micromho, "Micromho", "Micromhos", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (ElectricConductanceUnit.Microsiemens, "Microsiemens", "Microsiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     1000000
+                );
+                yield return new (ElectricConductanceUnit.Millimho, "Millimho", "Millimhos", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (ElectricConductanceUnit.Millisiemens, "Millisiemens", "Millisiemens", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (ElectricConductanceUnit.Nanomho, "Nanomho", "Nanomhos", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (ElectricConductanceUnit.Nanosiemens, "Nanosiemens", "Nanosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere),
+                     1000000000
+                );
                 yield return new (ElectricConductanceUnit.Siemens, "Siemens", "Siemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricConductanceUnit.Teramho, "Teramho", "Teramhos", BaseUnits.Undefined);
-                yield return new (ElectricConductanceUnit.Terasiemens, "Terasiemens", "Terasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricConductanceUnit.Teramho, "Teramho", "Teramhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (ElectricConductanceUnit.Terasiemens, "Terasiemens", "Terasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000000)
+                );
             }
         }
 
         static ElectricConductance()
         {
-            Info = ElectricConductanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricConductanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -151,7 +179,7 @@ static ElectricConductance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricConductance(double value, ElectricConductanceUnit unit)
+        public ElectricConductance(QuantityValue value, ElectricConductanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -165,7 +193,7 @@ public ElectricConductance(double value, ElectricConductanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricConductance(double value, UnitSystem unitSystem)
+        public ElectricConductance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -176,7 +204,8 @@ public ElectricConductance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricConductance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricConductance, ElectricConductanceUnit> Info { get; }
@@ -205,10 +234,8 @@ public ElectricConductance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricConductanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -242,133 +269,89 @@ public ElectricConductance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Gigamho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Gigamho"/>
         /// </summary>
-        public double Gigamhos => As(ElectricConductanceUnit.Gigamho);
+        public QuantityValue Gigamhos => this.As(ElectricConductanceUnit.Gigamho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Gigasiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Gigasiemens"/>
         /// </summary>
-        public double Gigasiemens => As(ElectricConductanceUnit.Gigasiemens);
+        public QuantityValue Gigasiemens => this.As(ElectricConductanceUnit.Gigasiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Kilomho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Kilomho"/>
         /// </summary>
-        public double Kilomhos => As(ElectricConductanceUnit.Kilomho);
+        public QuantityValue Kilomhos => this.As(ElectricConductanceUnit.Kilomho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Kilosiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Kilosiemens"/>
         /// </summary>
-        public double Kilosiemens => As(ElectricConductanceUnit.Kilosiemens);
+        public QuantityValue Kilosiemens => this.As(ElectricConductanceUnit.Kilosiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Megamho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Megamho"/>
         /// </summary>
-        public double Megamhos => As(ElectricConductanceUnit.Megamho);
+        public QuantityValue Megamhos => this.As(ElectricConductanceUnit.Megamho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Megasiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Megasiemens"/>
         /// </summary>
-        public double Megasiemens => As(ElectricConductanceUnit.Megasiemens);
+        public QuantityValue Megasiemens => this.As(ElectricConductanceUnit.Megasiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Mho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Mho"/>
         /// </summary>
-        public double Mhos => As(ElectricConductanceUnit.Mho);
+        public QuantityValue Mhos => this.As(ElectricConductanceUnit.Mho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Micromho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Micromho"/>
         /// </summary>
-        public double Micromhos => As(ElectricConductanceUnit.Micromho);
+        public QuantityValue Micromhos => this.As(ElectricConductanceUnit.Micromho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Microsiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Microsiemens"/>
         /// </summary>
-        public double Microsiemens => As(ElectricConductanceUnit.Microsiemens);
+        public QuantityValue Microsiemens => this.As(ElectricConductanceUnit.Microsiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Millimho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Millimho"/>
         /// </summary>
-        public double Millimhos => As(ElectricConductanceUnit.Millimho);
+        public QuantityValue Millimhos => this.As(ElectricConductanceUnit.Millimho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Millisiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Millisiemens"/>
         /// </summary>
-        public double Millisiemens => As(ElectricConductanceUnit.Millisiemens);
+        public QuantityValue Millisiemens => this.As(ElectricConductanceUnit.Millisiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Nanomho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Nanomho"/>
         /// </summary>
-        public double Nanomhos => As(ElectricConductanceUnit.Nanomho);
+        public QuantityValue Nanomhos => this.As(ElectricConductanceUnit.Nanomho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Nanosiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Nanosiemens"/>
         /// </summary>
-        public double Nanosiemens => As(ElectricConductanceUnit.Nanosiemens);
+        public QuantityValue Nanosiemens => this.As(ElectricConductanceUnit.Nanosiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Siemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Siemens"/>
         /// </summary>
-        public double Siemens => As(ElectricConductanceUnit.Siemens);
+        public QuantityValue Siemens => this.As(ElectricConductanceUnit.Siemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Teramho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Teramho"/>
         /// </summary>
-        public double Teramhos => As(ElectricConductanceUnit.Teramho);
+        public QuantityValue Teramhos => this.As(ElectricConductanceUnit.Teramho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Terasiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductanceUnit.Terasiemens"/>
         /// </summary>
-        public double Terasiemens => As(ElectricConductanceUnit.Terasiemens);
+        public QuantityValue Terasiemens => this.As(ElectricConductanceUnit.Terasiemens);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricConductanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Gigamho, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Gigasiemens, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Kilomho, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Kilosiemens, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Megamho, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Megasiemens, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Mho, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Micromho, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Microsiemens, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Millimho, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Millisiemens, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Nanomho, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Nanosiemens, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Teramho, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Terasiemens, ElectricConductanceUnit.Siemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Siemens));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Siemens, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricConductanceUnit
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Gigamho, quantity => quantity.ToUnit(ElectricConductanceUnit.Gigamho));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Gigasiemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Gigasiemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Kilomho, quantity => quantity.ToUnit(ElectricConductanceUnit.Kilomho));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Kilosiemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Kilosiemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Megamho, quantity => quantity.ToUnit(ElectricConductanceUnit.Megamho));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Megasiemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Megasiemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Mho, quantity => quantity.ToUnit(ElectricConductanceUnit.Mho));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Micromho, quantity => quantity.ToUnit(ElectricConductanceUnit.Micromho));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Microsiemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Microsiemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Millimho, quantity => quantity.ToUnit(ElectricConductanceUnit.Millimho));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Millisiemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Millisiemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Nanomho, quantity => quantity.ToUnit(ElectricConductanceUnit.Nanomho));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Nanosiemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Nanosiemens));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Teramho, quantity => quantity.ToUnit(ElectricConductanceUnit.Teramho));
-            unitConverter.SetConversionFunction<ElectricConductance>(ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Terasiemens, quantity => quantity.ToUnit(ElectricConductanceUnit.Terasiemens));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -397,7 +380,7 @@ public static string GetAbbreviation(ElectricConductanceUnit unit, IFormatProvid
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Gigamho"/>.
         /// </summary>
-        public static ElectricConductance FromGigamhos(double value)
+        public static ElectricConductance FromGigamhos(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Gigamho);
         }
@@ -405,7 +388,7 @@ public static ElectricConductance FromGigamhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Gigasiemens"/>.
         /// </summary>
-        public static ElectricConductance FromGigasiemens(double value)
+        public static ElectricConductance FromGigasiemens(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Gigasiemens);
         }
@@ -413,7 +396,7 @@ public static ElectricConductance FromGigasiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Kilomho"/>.
         /// </summary>
-        public static ElectricConductance FromKilomhos(double value)
+        public static ElectricConductance FromKilomhos(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Kilomho);
         }
@@ -421,7 +404,7 @@ public static ElectricConductance FromKilomhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Kilosiemens"/>.
         /// </summary>
-        public static ElectricConductance FromKilosiemens(double value)
+        public static ElectricConductance FromKilosiemens(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Kilosiemens);
         }
@@ -429,7 +412,7 @@ public static ElectricConductance FromKilosiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Megamho"/>.
         /// </summary>
-        public static ElectricConductance FromMegamhos(double value)
+        public static ElectricConductance FromMegamhos(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Megamho);
         }
@@ -437,7 +420,7 @@ public static ElectricConductance FromMegamhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Megasiemens"/>.
         /// </summary>
-        public static ElectricConductance FromMegasiemens(double value)
+        public static ElectricConductance FromMegasiemens(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Megasiemens);
         }
@@ -445,7 +428,7 @@ public static ElectricConductance FromMegasiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Mho"/>.
         /// </summary>
-        public static ElectricConductance FromMhos(double value)
+        public static ElectricConductance FromMhos(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Mho);
         }
@@ -453,7 +436,7 @@ public static ElectricConductance FromMhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Micromho"/>.
         /// </summary>
-        public static ElectricConductance FromMicromhos(double value)
+        public static ElectricConductance FromMicromhos(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Micromho);
         }
@@ -461,7 +444,7 @@ public static ElectricConductance FromMicromhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Microsiemens"/>.
         /// </summary>
-        public static ElectricConductance FromMicrosiemens(double value)
+        public static ElectricConductance FromMicrosiemens(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Microsiemens);
         }
@@ -469,7 +452,7 @@ public static ElectricConductance FromMicrosiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Millimho"/>.
         /// </summary>
-        public static ElectricConductance FromMillimhos(double value)
+        public static ElectricConductance FromMillimhos(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Millimho);
         }
@@ -477,7 +460,7 @@ public static ElectricConductance FromMillimhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Millisiemens"/>.
         /// </summary>
-        public static ElectricConductance FromMillisiemens(double value)
+        public static ElectricConductance FromMillisiemens(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Millisiemens);
         }
@@ -485,7 +468,7 @@ public static ElectricConductance FromMillisiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Nanomho"/>.
         /// </summary>
-        public static ElectricConductance FromNanomhos(double value)
+        public static ElectricConductance FromNanomhos(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Nanomho);
         }
@@ -493,7 +476,7 @@ public static ElectricConductance FromNanomhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Nanosiemens"/>.
         /// </summary>
-        public static ElectricConductance FromNanosiemens(double value)
+        public static ElectricConductance FromNanosiemens(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Nanosiemens);
         }
@@ -501,7 +484,7 @@ public static ElectricConductance FromNanosiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Siemens"/>.
         /// </summary>
-        public static ElectricConductance FromSiemens(double value)
+        public static ElectricConductance FromSiemens(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Siemens);
         }
@@ -509,7 +492,7 @@ public static ElectricConductance FromSiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Teramho"/>.
         /// </summary>
-        public static ElectricConductance FromTeramhos(double value)
+        public static ElectricConductance FromTeramhos(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Teramho);
         }
@@ -517,7 +500,7 @@ public static ElectricConductance FromTeramhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Terasiemens"/>.
         /// </summary>
-        public static ElectricConductance FromTerasiemens(double value)
+        public static ElectricConductance FromTerasiemens(QuantityValue value)
         {
             return new ElectricConductance(value, ElectricConductanceUnit.Terasiemens);
         }
@@ -528,7 +511,7 @@ public static ElectricConductance FromTerasiemens(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricConductance unit value.</returns>
-        public static ElectricConductance From(double value, ElectricConductanceUnit fromUnit)
+        public static ElectricConductance From(QuantityValue value, ElectricConductanceUnit fromUnit)
         {
             return new ElectricConductance(value, fromUnit);
         }
@@ -589,10 +572,7 @@ public static ElectricConductance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricConductance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricConductance, ElectricConductanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricConductance, ElectricConductanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -620,11 +600,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricConducta
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricConductance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricConductance, ElectricConductanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricConductance, ElectricConductanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -645,7 +621,7 @@ public static ElectricConductanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -656,7 +632,7 @@ public static ElectricConductanceUnit ParseUnit(string str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricConductanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricConductanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricConductanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -671,7 +647,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCond
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricConductanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -690,137 +666,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricConductance"/> from adding two <see cref="ElectricConductance"/>.</summary>
         public static ElectricConductance operator +(ElectricConductance left, ElectricConductance right)
         {
-            return new ElectricConductance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricConductance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricConductance"/> from subtracting two <see cref="ElectricConductance"/>.</summary>
         public static ElectricConductance operator -(ElectricConductance left, ElectricConductance right)
         {
-            return new ElectricConductance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricConductance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricConductance"/> from multiplying value and <see cref="ElectricConductance"/>.</summary>
-        public static ElectricConductance operator *(double left, ElectricConductance right)
+        public static ElectricConductance operator *(QuantityValue left, ElectricConductance right)
         {
             return new ElectricConductance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricConductance"/> from multiplying value and <see cref="ElectricConductance"/>.</summary>
-        public static ElectricConductance operator *(ElectricConductance left, double right)
+        public static ElectricConductance operator *(ElectricConductance left, QuantityValue right)
         {
             return new ElectricConductance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricConductance"/> from dividing <see cref="ElectricConductance"/> by value.</summary>
-        public static ElectricConductance operator /(ElectricConductance left, double right)
+        public static ElectricConductance operator /(ElectricConductance left, QuantityValue right)
         {
             return new ElectricConductance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricConductance"/> by <see cref="ElectricConductance"/>.</summary>
-        public static double operator /(ElectricConductance left, ElectricConductance right)
+        public static QuantityValue operator /(ElectricConductance left, ElectricConductance right)
         {
             return left.Siemens / right.Siemens;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="ElectricCurrent"/> from <see cref="ElectricConductance"/> * <see cref="ElectricPotential"/>.</summary>
+        public static ElectricCurrent operator *(ElectricConductance electricConductance, ElectricPotential electricPotential)
+        {
+            return ElectricCurrent.FromAmperes(electricConductance.Siemens * electricPotential.Volts);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricConductance left, ElectricConductance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricConductance left, ElectricConductance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricConductance left, ElectricConductance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricConductance left, ElectricConductance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricConductance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricConductance other, ElectricConductance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricConductance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricConductance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricConductance left, ElectricConductance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricConductance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricConductance other, ElectricConductance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricConductance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricConductance,ElectricConductance)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricConductance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricConductance left, ElectricConductance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricConductance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricConductance other, ElectricConductance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricConductance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricConductance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricConductance"/>, this method delegates to
+        ///     <see cref="Equals(ElectricConductance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricConductance otherQuantity))
+            if (obj is not ElectricConductance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricConductance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricConductance other, ElectricConductance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricConductance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricConductance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricConductance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricConductance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricConductance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricConductance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricConductance otherQuantity)) throw new ArgumentException("Expected type ElectricConductance.", nameof(obj));
+            if (obj is not ElectricConductance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricConductance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricConductance"/> with another <see cref="ElectricConductance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricConductance"/> with another <see cref="ElectricConductance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -832,159 +832,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricConductance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricConductanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricConductanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricConductance to another ElectricConductance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricConductance with the specified unit.</returns>
-        public ElectricConductance ToUnit(ElectricConductanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricConductance"/> to another <see cref="ElectricConductance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricConductance with the specified unit.</returns>
-        public ElectricConductance ToUnit(ElectricConductanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricConductance), Unit, typeof(ElectricConductance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricConductance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricConductance"/> to another <see cref="ElectricConductance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricConductance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricConductanceUnit unit, [NotNullWhen(true)] out ElectricConductance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricConductance? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricConductanceUnit -> BaseUnit
-                (ElectricConductanceUnit.Gigamho, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e9d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Gigasiemens, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e9d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Kilomho, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e3d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Kilosiemens, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e3d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Megamho, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e6d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Megasiemens, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e6d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Mho, ElectricConductanceUnit.Siemens) => new ElectricConductance(_value, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Micromho, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e-6d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Microsiemens, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e-6d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Millimho, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e-3d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Millisiemens, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e-3d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Nanomho, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e-9d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Nanosiemens, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e-9d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Teramho, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e12d, ElectricConductanceUnit.Siemens),
-                (ElectricConductanceUnit.Terasiemens, ElectricConductanceUnit.Siemens) => new ElectricConductance((_value) * 1e12d, ElectricConductanceUnit.Siemens),
-
-                // BaseUnit -> ElectricConductanceUnit
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Gigamho) => new ElectricConductance((_value) / 1e9d, ElectricConductanceUnit.Gigamho),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Gigasiemens) => new ElectricConductance((_value) / 1e9d, ElectricConductanceUnit.Gigasiemens),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Kilomho) => new ElectricConductance((_value) / 1e3d, ElectricConductanceUnit.Kilomho),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Kilosiemens) => new ElectricConductance((_value) / 1e3d, ElectricConductanceUnit.Kilosiemens),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Megamho) => new ElectricConductance((_value) / 1e6d, ElectricConductanceUnit.Megamho),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Megasiemens) => new ElectricConductance((_value) / 1e6d, ElectricConductanceUnit.Megasiemens),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Mho) => new ElectricConductance(_value, ElectricConductanceUnit.Mho),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Micromho) => new ElectricConductance((_value) / 1e-6d, ElectricConductanceUnit.Micromho),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Microsiemens) => new ElectricConductance((_value) / 1e-6d, ElectricConductanceUnit.Microsiemens),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Millimho) => new ElectricConductance((_value) / 1e-3d, ElectricConductanceUnit.Millimho),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Millisiemens) => new ElectricConductance((_value) / 1e-3d, ElectricConductanceUnit.Millisiemens),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Nanomho) => new ElectricConductance((_value) / 1e-9d, ElectricConductanceUnit.Nanomho),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Nanosiemens) => new ElectricConductance((_value) / 1e-9d, ElectricConductanceUnit.Nanosiemens),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Teramho) => new ElectricConductance((_value) / 1e12d, ElectricConductanceUnit.Teramho),
-                (ElectricConductanceUnit.Siemens, ElectricConductanceUnit.Terasiemens) => new ElectricConductance((_value) / 1e12d, ElectricConductanceUnit.Terasiemens),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricConductanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricConductanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricConductanceUnit> IQuantity<ElectricConductanceUnit>.ToUnit(ElectricConductanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -998,11 +848,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
index 42a8281ef0..491d5de364 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Electrical_resistivity_and_conductivity
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricConductivity :
-        IArithmeticQuantity<ElectricConductivity, ElectricConductivityUnit>,
+        ILinearQuantity<ElectricConductivity, ElectricConductivityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricConductivity, ElectricConductivity, double>,
+        IDivisionOperators<ElectricConductivity, ElectricConductivity, QuantityValue>,
         IComparisonOperators<ElectricConductivity, ElectricConductivity, bool>,
         IParsable<ElectricConductivity>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static ElectricConductivityInfo CreateDefault(Func<IEnumerable<UnitDefini
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricConductivity"/> is [T^3][L^-3][M^-1][I^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricConductivity"/> is T^3L^-3M^-1I^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-3, -1, 3, 2, 0, 0, 0);
 
@@ -120,20 +119,28 @@ public static ElectricConductivityInfo CreateDefault(Func<IEnumerable<UnitDefini
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricConductivityUnit}"/> representing the default unit mappings for ElectricConductivity.</returns>
             public static IEnumerable<UnitDefinition<ElectricConductivityUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricConductivityUnit.MicrosiemensPerCentimeter, "MicrosiemensPerCentimeter", "MicrosiemensPerCentimeter", BaseUnits.Undefined);
-                yield return new (ElectricConductivityUnit.MillisiemensPerCentimeter, "MillisiemensPerCentimeter", "MillisiemensPerCentimeter", BaseUnits.Undefined);
-                yield return new (ElectricConductivityUnit.SiemensPerCentimeter, "SiemensPerCentimeter", "SiemensPerCentimeter", BaseUnits.Undefined);
-                yield return new (ElectricConductivityUnit.SiemensPerFoot, "SiemensPerFoot", "SiemensPerFoot", BaseUnits.Undefined);
-                yield return new (ElectricConductivityUnit.SiemensPerInch, "SiemensPerInch", "SiemensPerInch", BaseUnits.Undefined);
+                yield return new (ElectricConductivityUnit.MicrosiemensPerCentimeter, "MicrosiemensPerCentimeter", "MicrosiemensPerCentimeter", BaseUnits.Undefined,
+                     10000
+                );
+                yield return new (ElectricConductivityUnit.MillisiemensPerCentimeter, "MillisiemensPerCentimeter", "MillisiemensPerCentimeter", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (ElectricConductivityUnit.SiemensPerCentimeter, "SiemensPerCentimeter", "SiemensPerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100)
+                );
+                yield return new (ElectricConductivityUnit.SiemensPerFoot, "SiemensPerFoot", "SiemensPerFoot", BaseUnits.Undefined,
+                     new QuantityValue(381, 1250)
+                );
+                yield return new (ElectricConductivityUnit.SiemensPerInch, "SiemensPerInch", "SiemensPerInch", BaseUnits.Undefined,
+                     new QuantityValue(127, 5000)
+                );
                 yield return new (ElectricConductivityUnit.SiemensPerMeter, "SiemensPerMeter", "SiemensPerMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
             }
         }
 
         static ElectricConductivity()
         {
-            Info = ElectricConductivityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricConductivityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -141,7 +148,7 @@ static ElectricConductivity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricConductivity(double value, ElectricConductivityUnit unit)
+        public ElectricConductivity(QuantityValue value, ElectricConductivityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -155,7 +162,7 @@ public ElectricConductivity(double value, ElectricConductivityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricConductivity(double value, UnitSystem unitSystem)
+        public ElectricConductivity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -166,7 +173,8 @@ public ElectricConductivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricConductivity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricConductivity, ElectricConductivityUnit> Info { get; }
@@ -195,10 +203,8 @@ public ElectricConductivity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricConductivityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -232,63 +238,39 @@ public ElectricConductivity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.MicrosiemensPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductivityUnit.MicrosiemensPerCentimeter"/>
         /// </summary>
-        public double MicrosiemensPerCentimeter => As(ElectricConductivityUnit.MicrosiemensPerCentimeter);
+        public QuantityValue MicrosiemensPerCentimeter => this.As(ElectricConductivityUnit.MicrosiemensPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.MillisiemensPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductivityUnit.MillisiemensPerCentimeter"/>
         /// </summary>
-        public double MillisiemensPerCentimeter => As(ElectricConductivityUnit.MillisiemensPerCentimeter);
+        public QuantityValue MillisiemensPerCentimeter => this.As(ElectricConductivityUnit.MillisiemensPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerCentimeter"/>
         /// </summary>
-        public double SiemensPerCentimeter => As(ElectricConductivityUnit.SiemensPerCentimeter);
+        public QuantityValue SiemensPerCentimeter => this.As(ElectricConductivityUnit.SiemensPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerFoot"/>
         /// </summary>
-        public double SiemensPerFoot => As(ElectricConductivityUnit.SiemensPerFoot);
+        public QuantityValue SiemensPerFoot => this.As(ElectricConductivityUnit.SiemensPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerInch"/>
         /// </summary>
-        public double SiemensPerInch => As(ElectricConductivityUnit.SiemensPerInch);
+        public QuantityValue SiemensPerInch => this.As(ElectricConductivityUnit.SiemensPerInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricConductivityUnit.SiemensPerMeter"/>
         /// </summary>
-        public double SiemensPerMeter => As(ElectricConductivityUnit.SiemensPerMeter);
+        public QuantityValue SiemensPerMeter => this.As(ElectricConductivityUnit.SiemensPerMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricConductivityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.MicrosiemensPerCentimeter, ElectricConductivityUnit.SiemensPerMeter, quantity => quantity.ToUnit(ElectricConductivityUnit.SiemensPerMeter));
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.MillisiemensPerCentimeter, ElectricConductivityUnit.SiemensPerMeter, quantity => quantity.ToUnit(ElectricConductivityUnit.SiemensPerMeter));
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerCentimeter, ElectricConductivityUnit.SiemensPerMeter, quantity => quantity.ToUnit(ElectricConductivityUnit.SiemensPerMeter));
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerFoot, ElectricConductivityUnit.SiemensPerMeter, quantity => quantity.ToUnit(ElectricConductivityUnit.SiemensPerMeter));
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerInch, ElectricConductivityUnit.SiemensPerMeter, quantity => quantity.ToUnit(ElectricConductivityUnit.SiemensPerMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.SiemensPerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricConductivityUnit
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.MicrosiemensPerCentimeter, quantity => quantity.ToUnit(ElectricConductivityUnit.MicrosiemensPerCentimeter));
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.MillisiemensPerCentimeter, quantity => quantity.ToUnit(ElectricConductivityUnit.MillisiemensPerCentimeter));
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.SiemensPerCentimeter, quantity => quantity.ToUnit(ElectricConductivityUnit.SiemensPerCentimeter));
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.SiemensPerFoot, quantity => quantity.ToUnit(ElectricConductivityUnit.SiemensPerFoot));
-            unitConverter.SetConversionFunction<ElectricConductivity>(ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.SiemensPerInch, quantity => quantity.ToUnit(ElectricConductivityUnit.SiemensPerInch));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -317,7 +299,7 @@ public static string GetAbbreviation(ElectricConductivityUnit unit, IFormatProvi
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.MicrosiemensPerCentimeter"/>.
         /// </summary>
-        public static ElectricConductivity FromMicrosiemensPerCentimeter(double value)
+        public static ElectricConductivity FromMicrosiemensPerCentimeter(QuantityValue value)
         {
             return new ElectricConductivity(value, ElectricConductivityUnit.MicrosiemensPerCentimeter);
         }
@@ -325,7 +307,7 @@ public static ElectricConductivity FromMicrosiemensPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.MillisiemensPerCentimeter"/>.
         /// </summary>
-        public static ElectricConductivity FromMillisiemensPerCentimeter(double value)
+        public static ElectricConductivity FromMillisiemensPerCentimeter(QuantityValue value)
         {
             return new ElectricConductivity(value, ElectricConductivityUnit.MillisiemensPerCentimeter);
         }
@@ -333,7 +315,7 @@ public static ElectricConductivity FromMillisiemensPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerCentimeter"/>.
         /// </summary>
-        public static ElectricConductivity FromSiemensPerCentimeter(double value)
+        public static ElectricConductivity FromSiemensPerCentimeter(QuantityValue value)
         {
             return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerCentimeter);
         }
@@ -341,7 +323,7 @@ public static ElectricConductivity FromSiemensPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerFoot"/>.
         /// </summary>
-        public static ElectricConductivity FromSiemensPerFoot(double value)
+        public static ElectricConductivity FromSiemensPerFoot(QuantityValue value)
         {
             return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerFoot);
         }
@@ -349,7 +331,7 @@ public static ElectricConductivity FromSiemensPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerInch"/>.
         /// </summary>
-        public static ElectricConductivity FromSiemensPerInch(double value)
+        public static ElectricConductivity FromSiemensPerInch(QuantityValue value)
         {
             return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerInch);
         }
@@ -357,7 +339,7 @@ public static ElectricConductivity FromSiemensPerInch(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerMeter"/>.
         /// </summary>
-        public static ElectricConductivity FromSiemensPerMeter(double value)
+        public static ElectricConductivity FromSiemensPerMeter(QuantityValue value)
         {
             return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerMeter);
         }
@@ -368,7 +350,7 @@ public static ElectricConductivity FromSiemensPerMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricConductivity unit value.</returns>
-        public static ElectricConductivity From(double value, ElectricConductivityUnit fromUnit)
+        public static ElectricConductivity From(QuantityValue value, ElectricConductivityUnit fromUnit)
         {
             return new ElectricConductivity(value, fromUnit);
         }
@@ -429,10 +411,7 @@ public static ElectricConductivity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricConductivity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricConductivity, ElectricConductivityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricConductivity, ElectricConductivityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -460,11 +439,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricConducti
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricConductivity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricConductivity, ElectricConductivityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricConductivity, ElectricConductivityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -485,7 +460,7 @@ public static ElectricConductivityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -496,7 +471,7 @@ public static ElectricConductivityUnit ParseUnit(string str, IFormatProvider? pr
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricConductivityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricConductivityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricConductivityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -511,7 +486,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCond
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricConductivityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -530,35 +505,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricConductivity"/> from adding two <see cref="ElectricConductivity"/>.</summary>
         public static ElectricConductivity operator +(ElectricConductivity left, ElectricConductivity right)
         {
-            return new ElectricConductivity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricConductivity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricConductivity"/> from subtracting two <see cref="ElectricConductivity"/>.</summary>
         public static ElectricConductivity operator -(ElectricConductivity left, ElectricConductivity right)
         {
-            return new ElectricConductivity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricConductivity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricConductivity"/> from multiplying value and <see cref="ElectricConductivity"/>.</summary>
-        public static ElectricConductivity operator *(double left, ElectricConductivity right)
+        public static ElectricConductivity operator *(QuantityValue left, ElectricConductivity right)
         {
             return new ElectricConductivity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricConductivity"/> from multiplying value and <see cref="ElectricConductivity"/>.</summary>
-        public static ElectricConductivity operator *(ElectricConductivity left, double right)
+        public static ElectricConductivity operator *(ElectricConductivity left, QuantityValue right)
         {
             return new ElectricConductivity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricConductivity"/> from dividing <see cref="ElectricConductivity"/> by value.</summary>
-        public static ElectricConductivity operator /(ElectricConductivity left, double right)
+        public static ElectricConductivity operator /(ElectricConductivity left, QuantityValue right)
         {
             return new ElectricConductivity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricConductivity"/> by <see cref="ElectricConductivity"/>.</summary>
-        public static double operator /(ElectricConductivity left, ElectricConductivity right)
+        public static QuantityValue operator /(ElectricConductivity left, ElectricConductivity right)
         {
             return left.SiemensPerMeter / right.SiemensPerMeter;
         }
@@ -571,7 +546,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <returns>The corresponding inverse quantity, <see cref="ElectricResistivity"/>.</returns>
         public ElectricResistivity Inverse()
         {
-            return ElectricResistivity.FromOhmMeters(1 / SiemensPerMeter);
+            return UnitConverter.Default.ConvertTo(Value, Unit, ElectricResistivity.Info);
         }
 
         #endregion
@@ -581,97 +556,111 @@ public ElectricResistivity Inverse()
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricConductivity left, ElectricConductivity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricConductivity left, ElectricConductivity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricConductivity left, ElectricConductivity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricConductivity left, ElectricConductivity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricConductivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricConductivity other, ElectricConductivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricConductivity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricConductivity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricConductivity left, ElectricConductivity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricConductivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricConductivity other, ElectricConductivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricConductivity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricConductivity,ElectricConductivity)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricConductivity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricConductivity left, ElectricConductivity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricConductivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricConductivity other, ElectricConductivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricConductivity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricConductivity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricConductivity"/>, this method delegates to
+        ///     <see cref="Equals(ElectricConductivity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricConductivity otherQuantity))
+            if (obj is not ElectricConductivity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricConductivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricConductivity other, ElectricConductivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricConductivity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricConductivity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricConductivity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricConductivity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricConductivity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricConductivity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricConductivity otherQuantity)) throw new ArgumentException("Expected type ElectricConductivity.", nameof(obj));
+            if (obj is not ElectricConductivity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricConductivity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricConductivity"/> with another <see cref="ElectricConductivity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricConductivity"/> with another <see cref="ElectricConductivity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -683,139 +672,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricConductivity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricConductivityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricConductivityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricConductivity to another ElectricConductivity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricConductivity with the specified unit.</returns>
-        public ElectricConductivity ToUnit(ElectricConductivityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="ElectricConductivity"/> to another <see cref="ElectricConductivity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricConductivity with the specified unit.</returns>
-        public ElectricConductivity ToUnit(ElectricConductivityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricConductivity), Unit, typeof(ElectricConductivity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricConductivity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricConductivity"/> to another <see cref="ElectricConductivity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricConductivity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricConductivityUnit unit, [NotNullWhen(true)] out ElectricConductivity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricConductivity? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricConductivityUnit -> BaseUnit
-                (ElectricConductivityUnit.MicrosiemensPerCentimeter, ElectricConductivityUnit.SiemensPerMeter) => new ElectricConductivity((_value * 1e2) * 1e-6d, ElectricConductivityUnit.SiemensPerMeter),
-                (ElectricConductivityUnit.MillisiemensPerCentimeter, ElectricConductivityUnit.SiemensPerMeter) => new ElectricConductivity((_value * 1e2) * 1e-3d, ElectricConductivityUnit.SiemensPerMeter),
-                (ElectricConductivityUnit.SiemensPerCentimeter, ElectricConductivityUnit.SiemensPerMeter) => new ElectricConductivity(_value * 1e2, ElectricConductivityUnit.SiemensPerMeter),
-                (ElectricConductivityUnit.SiemensPerFoot, ElectricConductivityUnit.SiemensPerMeter) => new ElectricConductivity(_value / 0.3048, ElectricConductivityUnit.SiemensPerMeter),
-                (ElectricConductivityUnit.SiemensPerInch, ElectricConductivityUnit.SiemensPerMeter) => new ElectricConductivity(_value / 2.54e-2, ElectricConductivityUnit.SiemensPerMeter),
-
-                // BaseUnit -> ElectricConductivityUnit
-                (ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.MicrosiemensPerCentimeter) => new ElectricConductivity((_value / 1e2) / 1e-6d, ElectricConductivityUnit.MicrosiemensPerCentimeter),
-                (ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.MillisiemensPerCentimeter) => new ElectricConductivity((_value / 1e2) / 1e-3d, ElectricConductivityUnit.MillisiemensPerCentimeter),
-                (ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.SiemensPerCentimeter) => new ElectricConductivity(_value / 1e2, ElectricConductivityUnit.SiemensPerCentimeter),
-                (ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.SiemensPerFoot) => new ElectricConductivity(_value * 0.3048, ElectricConductivityUnit.SiemensPerFoot),
-                (ElectricConductivityUnit.SiemensPerMeter, ElectricConductivityUnit.SiemensPerInch) => new ElectricConductivity(_value * 2.54e-2, ElectricConductivityUnit.SiemensPerInch),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricConductivityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductivityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricConductivityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductivityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricConductivityUnit> IQuantity<ElectricConductivityUnit>.ToUnit(ElectricConductivityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -829,11 +688,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
index 1328d94480..29db343b7d 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,15 +36,20 @@ namespace UnitsNet
     ///     If you want to map more parameters into the <c>ElectricCurrent</c> class (amps RMS, phase angle, etc.), create your own wrapper type such as a record or named tuple.
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricCurrent :
-        IArithmeticQuantity<ElectricCurrent, ElectricCurrentUnit>,
+        ILinearQuantity<ElectricCurrent, ElectricCurrentUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricCurrent, ElectricCurrent, double>,
+        IDivisionOperators<ElectricCurrent, ElectricCurrent, QuantityValue>,
+        IDivisionOperators<ElectricCurrent, ElectricCurrentDensity, Area>,
         IDivisionOperators<ElectricCurrent, ElectricCurrentGradient, Duration>,
         IMultiplyOperators<ElectricCurrent, Duration, ElectricCharge>,
+        IDivisionOperators<ElectricCurrent, ElectricPotential, ElectricConductance>,
+        IDivisionOperators<ElectricCurrent, Area, ElectricCurrentDensity>,
         IDivisionOperators<ElectricCurrent, Duration, ElectricCurrentGradient>,
         IMultiplyOperators<ElectricCurrent, ElectricResistance, ElectricPotential>,
+        IDivisionOperators<ElectricCurrent, ElectricConductance, ElectricPotential>,
         IMultiplyOperators<ElectricCurrent, ElectricPotential, Power>,
         IComparisonOperators<ElectricCurrent, ElectricCurrent, bool>,
         IParsable<ElectricCurrent>,
@@ -60,7 +63,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -110,7 +113,7 @@ public static ElectricCurrentInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricCurrent"/> is [I].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricCurrent"/> is I.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, 0, 1, 0, 0, 0);
 
@@ -126,22 +129,36 @@ public static ElectricCurrentInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             public static IEnumerable<UnitDefinition<ElectricCurrentUnit>> GetDefaultMappings()
             {
                 yield return new (ElectricCurrentUnit.Ampere, "Ampere", "Amperes", new BaseUnits(current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricCurrentUnit.Centiampere, "Centiampere", "Centiamperes", new BaseUnits(current: ElectricCurrentUnit.Centiampere));
-                yield return new (ElectricCurrentUnit.Femtoampere, "Femtoampere", "Femtoamperes", new BaseUnits(current: ElectricCurrentUnit.Femtoampere));
-                yield return new (ElectricCurrentUnit.Kiloampere, "Kiloampere", "Kiloamperes", new BaseUnits(current: ElectricCurrentUnit.Kiloampere));
-                yield return new (ElectricCurrentUnit.Megaampere, "Megaampere", "Megaamperes", new BaseUnits(current: ElectricCurrentUnit.Megaampere));
-                yield return new (ElectricCurrentUnit.Microampere, "Microampere", "Microamperes", new BaseUnits(current: ElectricCurrentUnit.Microampere));
-                yield return new (ElectricCurrentUnit.Milliampere, "Milliampere", "Milliamperes", new BaseUnits(current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricCurrentUnit.Nanoampere, "Nanoampere", "Nanoamperes", new BaseUnits(current: ElectricCurrentUnit.Nanoampere));
-                yield return new (ElectricCurrentUnit.Picoampere, "Picoampere", "Picoamperes", new BaseUnits(current: ElectricCurrentUnit.Picoampere));
+                yield return new (ElectricCurrentUnit.Centiampere, "Centiampere", "Centiamperes", new BaseUnits(current: ElectricCurrentUnit.Centiampere),
+                     100
+                );
+                yield return new (ElectricCurrentUnit.Femtoampere, "Femtoampere", "Femtoamperes", new BaseUnits(current: ElectricCurrentUnit.Femtoampere),
+                     1000000000000000
+                );
+                yield return new (ElectricCurrentUnit.Kiloampere, "Kiloampere", "Kiloamperes", new BaseUnits(current: ElectricCurrentUnit.Kiloampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricCurrentUnit.Megaampere, "Megaampere", "Megaamperes", new BaseUnits(current: ElectricCurrentUnit.Megaampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricCurrentUnit.Microampere, "Microampere", "Microamperes", new BaseUnits(current: ElectricCurrentUnit.Microampere),
+                     1000000
+                );
+                yield return new (ElectricCurrentUnit.Milliampere, "Milliampere", "Milliamperes", new BaseUnits(current: ElectricCurrentUnit.Milliampere),
+                     1000
+                );
+                yield return new (ElectricCurrentUnit.Nanoampere, "Nanoampere", "Nanoamperes", new BaseUnits(current: ElectricCurrentUnit.Nanoampere),
+                     1000000000
+                );
+                yield return new (ElectricCurrentUnit.Picoampere, "Picoampere", "Picoamperes", new BaseUnits(current: ElectricCurrentUnit.Picoampere),
+                     1000000000000
+                );
             }
         }
 
         static ElectricCurrent()
         {
-            Info = ElectricCurrentInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricCurrentInfo.CreateDefault);
         }
 
         /// <summary>
@@ -149,7 +166,7 @@ static ElectricCurrent()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricCurrent(double value, ElectricCurrentUnit unit)
+        public ElectricCurrent(QuantityValue value, ElectricCurrentUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -163,7 +180,7 @@ public ElectricCurrent(double value, ElectricCurrentUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricCurrent(double value, UnitSystem unitSystem)
+        public ElectricCurrent(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -174,7 +191,8 @@ public ElectricCurrent(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricCurrent" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricCurrent, ElectricCurrentUnit> Info { get; }
@@ -203,10 +221,8 @@ public ElectricCurrent(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricCurrentUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -240,84 +256,54 @@ public ElectricCurrent(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Ampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Ampere"/>
         /// </summary>
-        public double Amperes => As(ElectricCurrentUnit.Ampere);
+        public QuantityValue Amperes => this.As(ElectricCurrentUnit.Ampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Centiampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Centiampere"/>
         /// </summary>
-        public double Centiamperes => As(ElectricCurrentUnit.Centiampere);
+        public QuantityValue Centiamperes => this.As(ElectricCurrentUnit.Centiampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Femtoampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Femtoampere"/>
         /// </summary>
-        public double Femtoamperes => As(ElectricCurrentUnit.Femtoampere);
+        public QuantityValue Femtoamperes => this.As(ElectricCurrentUnit.Femtoampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Kiloampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Kiloampere"/>
         /// </summary>
-        public double Kiloamperes => As(ElectricCurrentUnit.Kiloampere);
+        public QuantityValue Kiloamperes => this.As(ElectricCurrentUnit.Kiloampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Megaampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Megaampere"/>
         /// </summary>
-        public double Megaamperes => As(ElectricCurrentUnit.Megaampere);
+        public QuantityValue Megaamperes => this.As(ElectricCurrentUnit.Megaampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Microampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Microampere"/>
         /// </summary>
-        public double Microamperes => As(ElectricCurrentUnit.Microampere);
+        public QuantityValue Microamperes => this.As(ElectricCurrentUnit.Microampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Milliampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Milliampere"/>
         /// </summary>
-        public double Milliamperes => As(ElectricCurrentUnit.Milliampere);
+        public QuantityValue Milliamperes => this.As(ElectricCurrentUnit.Milliampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Nanoampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Nanoampere"/>
         /// </summary>
-        public double Nanoamperes => As(ElectricCurrentUnit.Nanoampere);
+        public QuantityValue Nanoamperes => this.As(ElectricCurrentUnit.Nanoampere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Picoampere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentUnit.Picoampere"/>
         /// </summary>
-        public double Picoamperes => As(ElectricCurrentUnit.Picoampere);
+        public QuantityValue Picoamperes => this.As(ElectricCurrentUnit.Picoampere);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricCurrentUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Centiampere, ElectricCurrentUnit.Ampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Ampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Femtoampere, ElectricCurrentUnit.Ampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Ampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Kiloampere, ElectricCurrentUnit.Ampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Ampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Megaampere, ElectricCurrentUnit.Ampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Ampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Microampere, ElectricCurrentUnit.Ampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Ampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Milliampere, ElectricCurrentUnit.Ampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Ampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Nanoampere, ElectricCurrentUnit.Ampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Ampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Picoampere, ElectricCurrentUnit.Ampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Ampere));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Ampere, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricCurrentUnit
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Centiampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Centiampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Femtoampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Femtoampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Kiloampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Kiloampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Megaampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Megaampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Microampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Microampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Milliampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Milliampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Nanoampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Nanoampere));
-            unitConverter.SetConversionFunction<ElectricCurrent>(ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Picoampere, quantity => quantity.ToUnit(ElectricCurrentUnit.Picoampere));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -346,7 +332,7 @@ public static string GetAbbreviation(ElectricCurrentUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Ampere"/>.
         /// </summary>
-        public static ElectricCurrent FromAmperes(double value)
+        public static ElectricCurrent FromAmperes(QuantityValue value)
         {
             return new ElectricCurrent(value, ElectricCurrentUnit.Ampere);
         }
@@ -354,7 +340,7 @@ public static ElectricCurrent FromAmperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Centiampere"/>.
         /// </summary>
-        public static ElectricCurrent FromCentiamperes(double value)
+        public static ElectricCurrent FromCentiamperes(QuantityValue value)
         {
             return new ElectricCurrent(value, ElectricCurrentUnit.Centiampere);
         }
@@ -362,7 +348,7 @@ public static ElectricCurrent FromCentiamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Femtoampere"/>.
         /// </summary>
-        public static ElectricCurrent FromFemtoamperes(double value)
+        public static ElectricCurrent FromFemtoamperes(QuantityValue value)
         {
             return new ElectricCurrent(value, ElectricCurrentUnit.Femtoampere);
         }
@@ -370,7 +356,7 @@ public static ElectricCurrent FromFemtoamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Kiloampere"/>.
         /// </summary>
-        public static ElectricCurrent FromKiloamperes(double value)
+        public static ElectricCurrent FromKiloamperes(QuantityValue value)
         {
             return new ElectricCurrent(value, ElectricCurrentUnit.Kiloampere);
         }
@@ -378,7 +364,7 @@ public static ElectricCurrent FromKiloamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Megaampere"/>.
         /// </summary>
-        public static ElectricCurrent FromMegaamperes(double value)
+        public static ElectricCurrent FromMegaamperes(QuantityValue value)
         {
             return new ElectricCurrent(value, ElectricCurrentUnit.Megaampere);
         }
@@ -386,7 +372,7 @@ public static ElectricCurrent FromMegaamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Microampere"/>.
         /// </summary>
-        public static ElectricCurrent FromMicroamperes(double value)
+        public static ElectricCurrent FromMicroamperes(QuantityValue value)
         {
             return new ElectricCurrent(value, ElectricCurrentUnit.Microampere);
         }
@@ -394,7 +380,7 @@ public static ElectricCurrent FromMicroamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Milliampere"/>.
         /// </summary>
-        public static ElectricCurrent FromMilliamperes(double value)
+        public static ElectricCurrent FromMilliamperes(QuantityValue value)
         {
             return new ElectricCurrent(value, ElectricCurrentUnit.Milliampere);
         }
@@ -402,7 +388,7 @@ public static ElectricCurrent FromMilliamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Nanoampere"/>.
         /// </summary>
-        public static ElectricCurrent FromNanoamperes(double value)
+        public static ElectricCurrent FromNanoamperes(QuantityValue value)
         {
             return new ElectricCurrent(value, ElectricCurrentUnit.Nanoampere);
         }
@@ -410,7 +396,7 @@ public static ElectricCurrent FromNanoamperes(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Picoampere"/>.
         /// </summary>
-        public static ElectricCurrent FromPicoamperes(double value)
+        public static ElectricCurrent FromPicoamperes(QuantityValue value)
         {
             return new ElectricCurrent(value, ElectricCurrentUnit.Picoampere);
         }
@@ -421,7 +407,7 @@ public static ElectricCurrent FromPicoamperes(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricCurrent unit value.</returns>
-        public static ElectricCurrent From(double value, ElectricCurrentUnit fromUnit)
+        public static ElectricCurrent From(QuantityValue value, ElectricCurrentUnit fromUnit)
         {
             return new ElectricCurrent(value, fromUnit);
         }
@@ -482,10 +468,7 @@ public static ElectricCurrent Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricCurrent Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricCurrent, ElectricCurrentUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricCurrent, ElectricCurrentUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -513,11 +496,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricCurrent
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricCurrent result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricCurrent, ElectricCurrentUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricCurrent, ElectricCurrentUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -538,7 +517,7 @@ public static ElectricCurrentUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -549,7 +528,7 @@ public static ElectricCurrentUnit ParseUnit(string str, IFormatProvider? provide
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricCurrentUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricCurrentUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCurrentUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -564,7 +543,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCurr
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricCurrentUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -583,35 +562,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricCurrent"/> from adding two <see cref="ElectricCurrent"/>.</summary>
         public static ElectricCurrent operator +(ElectricCurrent left, ElectricCurrent right)
         {
-            return new ElectricCurrent(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricCurrent(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrent"/> from subtracting two <see cref="ElectricCurrent"/>.</summary>
         public static ElectricCurrent operator -(ElectricCurrent left, ElectricCurrent right)
         {
-            return new ElectricCurrent(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricCurrent(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrent"/> from multiplying value and <see cref="ElectricCurrent"/>.</summary>
-        public static ElectricCurrent operator *(double left, ElectricCurrent right)
+        public static ElectricCurrent operator *(QuantityValue left, ElectricCurrent right)
         {
             return new ElectricCurrent(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrent"/> from multiplying value and <see cref="ElectricCurrent"/>.</summary>
-        public static ElectricCurrent operator *(ElectricCurrent left, double right)
+        public static ElectricCurrent operator *(ElectricCurrent left, QuantityValue right)
         {
             return new ElectricCurrent(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrent"/> from dividing <see cref="ElectricCurrent"/> by value.</summary>
-        public static ElectricCurrent operator /(ElectricCurrent left, double right)
+        public static ElectricCurrent operator /(ElectricCurrent left, QuantityValue right)
         {
             return new ElectricCurrent(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricCurrent"/> by <see cref="ElectricCurrent"/>.</summary>
-        public static double operator /(ElectricCurrent left, ElectricCurrent right)
+        public static QuantityValue operator /(ElectricCurrent left, ElectricCurrent right)
         {
             return left.Amperes / right.Amperes;
         }
@@ -620,6 +599,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="Area"/> from <see cref="ElectricCurrent"/> / <see cref="ElectricCurrentDensity"/>.</summary>
+        public static Area operator /(ElectricCurrent electricCurrent, ElectricCurrentDensity electricCurrentDensity)
+        {
+            return Area.FromSquareMeters(electricCurrent.Amperes / electricCurrentDensity.AmperesPerSquareMeter);
+        }
+
         /// <summary>Get <see cref="Duration"/> from <see cref="ElectricCurrent"/> / <see cref="ElectricCurrentGradient"/>.</summary>
         public static Duration operator /(ElectricCurrent electricCurrent, ElectricCurrentGradient electricCurrentGradient)
         {
@@ -632,6 +617,18 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return ElectricCharge.FromAmpereHours(electricCurrent.Amperes * duration.Hours);
         }
 
+        /// <summary>Get <see cref="ElectricConductance"/> from <see cref="ElectricCurrent"/> / <see cref="ElectricPotential"/>.</summary>
+        public static ElectricConductance operator /(ElectricCurrent electricCurrent, ElectricPotential electricPotential)
+        {
+            return ElectricConductance.FromSiemens(electricCurrent.Amperes / electricPotential.Volts);
+        }
+
+        /// <summary>Get <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrent"/> / <see cref="Area"/>.</summary>
+        public static ElectricCurrentDensity operator /(ElectricCurrent electricCurrent, Area area)
+        {
+            return ElectricCurrentDensity.FromAmperesPerSquareMeter(electricCurrent.Amperes / area.SquareMeters);
+        }
+
         /// <summary>Get <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrent"/> / <see cref="Duration"/>.</summary>
         public static ElectricCurrentGradient operator /(ElectricCurrent electricCurrent, Duration duration)
         {
@@ -644,6 +641,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return ElectricPotential.FromVolts(electricCurrent.Amperes * electricResistance.Ohms);
         }
 
+        /// <summary>Get <see cref="ElectricPotential"/> from <see cref="ElectricCurrent"/> / <see cref="ElectricConductance"/>.</summary>
+        public static ElectricPotential operator /(ElectricCurrent electricCurrent, ElectricConductance electricConductance)
+        {
+            return ElectricPotential.FromVolts(electricCurrent.Amperes / electricConductance.Siemens);
+        }
+
         /// <summary>Get <see cref="Power"/> from <see cref="ElectricCurrent"/> * <see cref="ElectricPotential"/>.</summary>
         public static Power operator *(ElectricCurrent electricCurrent, ElectricPotential electricPotential)
         {
@@ -657,97 +660,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricCurrent left, ElectricCurrent right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricCurrent left, ElectricCurrent right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricCurrent left, ElectricCurrent right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricCurrent left, ElectricCurrent right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricCurrent"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricCurrent other, ElectricCurrent tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricCurrent"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricCurrent)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricCurrent left, ElectricCurrent right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricCurrent"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricCurrent other, ElectricCurrent tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricCurrent"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricCurrent,ElectricCurrent)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricCurrent)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricCurrent left, ElectricCurrent right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricCurrent"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricCurrent other, ElectricCurrent tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricCurrent"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricCurrent"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricCurrent"/>, this method delegates to
+        ///     <see cref="Equals(ElectricCurrent)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricCurrent otherQuantity))
+            if (obj is not ElectricCurrent otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricCurrent"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricCurrent other, ElectricCurrent tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricCurrent"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricCurrent other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricCurrent.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricCurrent), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricCurrent"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricCurrent)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricCurrent otherQuantity)) throw new ArgumentException("Expected type ElectricCurrent.", nameof(obj));
+            if (obj is not ElectricCurrent otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricCurrent>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricCurrent"/> with another <see cref="ElectricCurrent"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricCurrent"/> with another <see cref="ElectricCurrent"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -759,145 +776,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricCurrent other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricCurrentUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricCurrentUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricCurrent to another ElectricCurrent with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricCurrent with the specified unit.</returns>
-        public ElectricCurrent ToUnit(ElectricCurrentUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricCurrent"/> to another <see cref="ElectricCurrent"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricCurrent with the specified unit.</returns>
-        public ElectricCurrent ToUnit(ElectricCurrentUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricCurrent), Unit, typeof(ElectricCurrent), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricCurrent)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricCurrent"/> to another <see cref="ElectricCurrent"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricCurrent"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricCurrentUnit unit, [NotNullWhen(true)] out ElectricCurrent? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricCurrent? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricCurrentUnit -> BaseUnit
-                (ElectricCurrentUnit.Centiampere, ElectricCurrentUnit.Ampere) => new ElectricCurrent((_value) * 1e-2d, ElectricCurrentUnit.Ampere),
-                (ElectricCurrentUnit.Femtoampere, ElectricCurrentUnit.Ampere) => new ElectricCurrent((_value) * 1e-15d, ElectricCurrentUnit.Ampere),
-                (ElectricCurrentUnit.Kiloampere, ElectricCurrentUnit.Ampere) => new ElectricCurrent((_value) * 1e3d, ElectricCurrentUnit.Ampere),
-                (ElectricCurrentUnit.Megaampere, ElectricCurrentUnit.Ampere) => new ElectricCurrent((_value) * 1e6d, ElectricCurrentUnit.Ampere),
-                (ElectricCurrentUnit.Microampere, ElectricCurrentUnit.Ampere) => new ElectricCurrent((_value) * 1e-6d, ElectricCurrentUnit.Ampere),
-                (ElectricCurrentUnit.Milliampere, ElectricCurrentUnit.Ampere) => new ElectricCurrent((_value) * 1e-3d, ElectricCurrentUnit.Ampere),
-                (ElectricCurrentUnit.Nanoampere, ElectricCurrentUnit.Ampere) => new ElectricCurrent((_value) * 1e-9d, ElectricCurrentUnit.Ampere),
-                (ElectricCurrentUnit.Picoampere, ElectricCurrentUnit.Ampere) => new ElectricCurrent((_value) * 1e-12d, ElectricCurrentUnit.Ampere),
-
-                // BaseUnit -> ElectricCurrentUnit
-                (ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Centiampere) => new ElectricCurrent((_value) / 1e-2d, ElectricCurrentUnit.Centiampere),
-                (ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Femtoampere) => new ElectricCurrent((_value) / 1e-15d, ElectricCurrentUnit.Femtoampere),
-                (ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Kiloampere) => new ElectricCurrent((_value) / 1e3d, ElectricCurrentUnit.Kiloampere),
-                (ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Megaampere) => new ElectricCurrent((_value) / 1e6d, ElectricCurrentUnit.Megaampere),
-                (ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Microampere) => new ElectricCurrent((_value) / 1e-6d, ElectricCurrentUnit.Microampere),
-                (ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Milliampere) => new ElectricCurrent((_value) / 1e-3d, ElectricCurrentUnit.Milliampere),
-                (ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Nanoampere) => new ElectricCurrent((_value) / 1e-9d, ElectricCurrentUnit.Nanoampere),
-                (ElectricCurrentUnit.Ampere, ElectricCurrentUnit.Picoampere) => new ElectricCurrent((_value) / 1e-12d, ElectricCurrentUnit.Picoampere),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricCurrentUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricCurrentUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricCurrentUnit> IQuantity<ElectricCurrentUnit>.ToUnit(ElectricCurrentUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -911,11 +792,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
index 6952796ae2..c20bdef8e4 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Current_density
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricCurrentDensity :
-        IArithmeticQuantity<ElectricCurrentDensity, ElectricCurrentDensityUnit>,
+        ILinearQuantity<ElectricCurrentDensity, ElectricCurrentDensityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricCurrentDensity, ElectricCurrentDensity, double>,
+        IDivisionOperators<ElectricCurrentDensity, ElectricCurrentDensity, QuantityValue>,
+        IMultiplyOperators<ElectricCurrentDensity, Area, ElectricCurrent>,
         IComparisonOperators<ElectricCurrentDensity, ElectricCurrentDensity, bool>,
         IParsable<ElectricCurrentDensity>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static ElectricCurrentDensityInfo CreateDefault(Func<IEnumerable<UnitDefi
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricCurrentDensity"/> is [L^-2][I].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricCurrentDensity"/> is L^-2I.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 0, 0, 1, 0, 0, 0);
 
@@ -120,17 +120,19 @@ public static ElectricCurrentDensityInfo CreateDefault(Func<IEnumerable<UnitDefi
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricCurrentDensityUnit}"/> representing the default unit mappings for ElectricCurrentDensity.</returns>
             public static IEnumerable<UnitDefinition<ElectricCurrentDensityUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricCurrentDensityUnit.AmperePerSquareFoot, "AmperePerSquareFoot", "AmperesPerSquareFoot", new BaseUnits(length: LengthUnit.Foot, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricCurrentDensityUnit.AmperePerSquareInch, "AmperePerSquareInch", "AmperesPerSquareInch", new BaseUnits(length: LengthUnit.Inch, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricCurrentDensityUnit.AmperePerSquareFoot, "AmperePerSquareFoot", "AmperesPerSquareFoot", new BaseUnits(length: LengthUnit.Foot, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(145161, 1562500)
+                );
+                yield return new (ElectricCurrentDensityUnit.AmperePerSquareInch, "AmperePerSquareInch", "AmperesPerSquareInch", new BaseUnits(length: LengthUnit.Inch, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(16129, 25000000)
+                );
                 yield return new (ElectricCurrentDensityUnit.AmperePerSquareMeter, "AmperePerSquareMeter", "AmperesPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, current: ElectricCurrentUnit.Ampere));
             }
         }
 
         static ElectricCurrentDensity()
         {
-            Info = ElectricCurrentDensityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricCurrentDensityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -138,7 +140,7 @@ static ElectricCurrentDensity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricCurrentDensity(double value, ElectricCurrentDensityUnit unit)
+        public ElectricCurrentDensity(QuantityValue value, ElectricCurrentDensityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -152,7 +154,7 @@ public ElectricCurrentDensity(double value, ElectricCurrentDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricCurrentDensity(double value, UnitSystem unitSystem)
+        public ElectricCurrentDensity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -163,7 +165,8 @@ public ElectricCurrentDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricCurrentDensity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricCurrentDensity, ElectricCurrentDensityUnit> Info { get; }
@@ -192,10 +195,8 @@ public ElectricCurrentDensity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricCurrentDensityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -229,42 +230,24 @@ public ElectricCurrentDensity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentDensityUnit.AmperePerSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentDensityUnit.AmperePerSquareFoot"/>
         /// </summary>
-        public double AmperesPerSquareFoot => As(ElectricCurrentDensityUnit.AmperePerSquareFoot);
+        public QuantityValue AmperesPerSquareFoot => this.As(ElectricCurrentDensityUnit.AmperePerSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentDensityUnit.AmperePerSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentDensityUnit.AmperePerSquareInch"/>
         /// </summary>
-        public double AmperesPerSquareInch => As(ElectricCurrentDensityUnit.AmperePerSquareInch);
+        public QuantityValue AmperesPerSquareInch => this.As(ElectricCurrentDensityUnit.AmperePerSquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentDensityUnit.AmperePerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentDensityUnit.AmperePerSquareMeter"/>
         /// </summary>
-        public double AmperesPerSquareMeter => As(ElectricCurrentDensityUnit.AmperePerSquareMeter);
+        public QuantityValue AmperesPerSquareMeter => this.As(ElectricCurrentDensityUnit.AmperePerSquareMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricCurrentDensityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricCurrentDensity>(ElectricCurrentDensityUnit.AmperePerSquareFoot, ElectricCurrentDensityUnit.AmperePerSquareMeter, quantity => quantity.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareMeter));
-            unitConverter.SetConversionFunction<ElectricCurrentDensity>(ElectricCurrentDensityUnit.AmperePerSquareInch, ElectricCurrentDensityUnit.AmperePerSquareMeter, quantity => quantity.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricCurrentDensity>(ElectricCurrentDensityUnit.AmperePerSquareMeter, ElectricCurrentDensityUnit.AmperePerSquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricCurrentDensityUnit
-            unitConverter.SetConversionFunction<ElectricCurrentDensity>(ElectricCurrentDensityUnit.AmperePerSquareMeter, ElectricCurrentDensityUnit.AmperePerSquareFoot, quantity => quantity.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareFoot));
-            unitConverter.SetConversionFunction<ElectricCurrentDensity>(ElectricCurrentDensityUnit.AmperePerSquareMeter, ElectricCurrentDensityUnit.AmperePerSquareInch, quantity => quantity.ToUnit(ElectricCurrentDensityUnit.AmperePerSquareInch));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -293,7 +276,7 @@ public static string GetAbbreviation(ElectricCurrentDensityUnit unit, IFormatPro
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareFoot"/>.
         /// </summary>
-        public static ElectricCurrentDensity FromAmperesPerSquareFoot(double value)
+        public static ElectricCurrentDensity FromAmperesPerSquareFoot(QuantityValue value)
         {
             return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareFoot);
         }
@@ -301,7 +284,7 @@ public static ElectricCurrentDensity FromAmperesPerSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareInch"/>.
         /// </summary>
-        public static ElectricCurrentDensity FromAmperesPerSquareInch(double value)
+        public static ElectricCurrentDensity FromAmperesPerSquareInch(QuantityValue value)
         {
             return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareInch);
         }
@@ -309,7 +292,7 @@ public static ElectricCurrentDensity FromAmperesPerSquareInch(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareMeter"/>.
         /// </summary>
-        public static ElectricCurrentDensity FromAmperesPerSquareMeter(double value)
+        public static ElectricCurrentDensity FromAmperesPerSquareMeter(QuantityValue value)
         {
             return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareMeter);
         }
@@ -320,7 +303,7 @@ public static ElectricCurrentDensity FromAmperesPerSquareMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricCurrentDensity unit value.</returns>
-        public static ElectricCurrentDensity From(double value, ElectricCurrentDensityUnit fromUnit)
+        public static ElectricCurrentDensity From(QuantityValue value, ElectricCurrentDensityUnit fromUnit)
         {
             return new ElectricCurrentDensity(value, fromUnit);
         }
@@ -381,10 +364,7 @@ public static ElectricCurrentDensity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricCurrentDensity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricCurrentDensity, ElectricCurrentDensityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricCurrentDensity, ElectricCurrentDensityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -412,11 +392,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricCurrentD
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricCurrentDensity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricCurrentDensity, ElectricCurrentDensityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricCurrentDensity, ElectricCurrentDensityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -437,7 +413,7 @@ public static ElectricCurrentDensityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -448,7 +424,7 @@ public static ElectricCurrentDensityUnit ParseUnit(string str, IFormatProvider?
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricCurrentDensityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricCurrentDensityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCurrentDensityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -463,7 +439,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCurr
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricCurrentDensityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -482,137 +458,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricCurrentDensity"/> from adding two <see cref="ElectricCurrentDensity"/>.</summary>
         public static ElectricCurrentDensity operator +(ElectricCurrentDensity left, ElectricCurrentDensity right)
         {
-            return new ElectricCurrentDensity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricCurrentDensity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrentDensity"/> from subtracting two <see cref="ElectricCurrentDensity"/>.</summary>
         public static ElectricCurrentDensity operator -(ElectricCurrentDensity left, ElectricCurrentDensity right)
         {
-            return new ElectricCurrentDensity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricCurrentDensity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrentDensity"/> from multiplying value and <see cref="ElectricCurrentDensity"/>.</summary>
-        public static ElectricCurrentDensity operator *(double left, ElectricCurrentDensity right)
+        public static ElectricCurrentDensity operator *(QuantityValue left, ElectricCurrentDensity right)
         {
             return new ElectricCurrentDensity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrentDensity"/> from multiplying value and <see cref="ElectricCurrentDensity"/>.</summary>
-        public static ElectricCurrentDensity operator *(ElectricCurrentDensity left, double right)
+        public static ElectricCurrentDensity operator *(ElectricCurrentDensity left, QuantityValue right)
         {
             return new ElectricCurrentDensity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrentDensity"/> from dividing <see cref="ElectricCurrentDensity"/> by value.</summary>
-        public static ElectricCurrentDensity operator /(ElectricCurrentDensity left, double right)
+        public static ElectricCurrentDensity operator /(ElectricCurrentDensity left, QuantityValue right)
         {
             return new ElectricCurrentDensity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricCurrentDensity"/> by <see cref="ElectricCurrentDensity"/>.</summary>
-        public static double operator /(ElectricCurrentDensity left, ElectricCurrentDensity right)
+        public static QuantityValue operator /(ElectricCurrentDensity left, ElectricCurrentDensity right)
         {
             return left.AmperesPerSquareMeter / right.AmperesPerSquareMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentDensity"/> * <see cref="Area"/>.</summary>
+        public static ElectricCurrent operator *(ElectricCurrentDensity electricCurrentDensity, Area area)
+        {
+            return ElectricCurrent.FromAmperes(electricCurrentDensity.AmperesPerSquareMeter * area.SquareMeters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricCurrentDensity left, ElectricCurrentDensity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricCurrentDensity left, ElectricCurrentDensity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricCurrentDensity left, ElectricCurrentDensity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricCurrentDensity left, ElectricCurrentDensity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricCurrentDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricCurrentDensity other, ElectricCurrentDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricCurrentDensity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricCurrentDensity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricCurrentDensity left, ElectricCurrentDensity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricCurrentDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricCurrentDensity other, ElectricCurrentDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricCurrentDensity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricCurrentDensity,ElectricCurrentDensity)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricCurrentDensity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricCurrentDensity left, ElectricCurrentDensity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricCurrentDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricCurrentDensity other, ElectricCurrentDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricCurrentDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricCurrentDensity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricCurrentDensity"/>, this method delegates to
+        ///     <see cref="Equals(ElectricCurrentDensity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricCurrentDensity otherQuantity))
+            if (obj is not ElectricCurrentDensity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricCurrentDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricCurrentDensity other, ElectricCurrentDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricCurrentDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricCurrentDensity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricCurrentDensity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricCurrentDensity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricCurrentDensity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricCurrentDensity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricCurrentDensity otherQuantity)) throw new ArgumentException("Expected type ElectricCurrentDensity.", nameof(obj));
+            if (obj is not ElectricCurrentDensity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricCurrentDensity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricCurrentDensity"/> with another <see cref="ElectricCurrentDensity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricCurrentDensity"/> with another <see cref="ElectricCurrentDensity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -624,135 +624,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricCurrentDensity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricCurrentDensityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricCurrentDensityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricCurrentDensity to another ElectricCurrentDensity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricCurrentDensity with the specified unit.</returns>
-        public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricCurrentDensity"/> to another <see cref="ElectricCurrentDensity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricCurrentDensity with the specified unit.</returns>
-        public ElectricCurrentDensity ToUnit(ElectricCurrentDensityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricCurrentDensity), Unit, typeof(ElectricCurrentDensity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricCurrentDensity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricCurrentDensity"/> to another <see cref="ElectricCurrentDensity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricCurrentDensity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricCurrentDensityUnit unit, [NotNullWhen(true)] out ElectricCurrentDensity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricCurrentDensity? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricCurrentDensityUnit -> BaseUnit
-                (ElectricCurrentDensityUnit.AmperePerSquareFoot, ElectricCurrentDensityUnit.AmperePerSquareMeter) => new ElectricCurrentDensity(_value / 9.290304e-2, ElectricCurrentDensityUnit.AmperePerSquareMeter),
-                (ElectricCurrentDensityUnit.AmperePerSquareInch, ElectricCurrentDensityUnit.AmperePerSquareMeter) => new ElectricCurrentDensity(_value / 0.00064516, ElectricCurrentDensityUnit.AmperePerSquareMeter),
-
-                // BaseUnit -> ElectricCurrentDensityUnit
-                (ElectricCurrentDensityUnit.AmperePerSquareMeter, ElectricCurrentDensityUnit.AmperePerSquareFoot) => new ElectricCurrentDensity(_value * 9.290304e-2, ElectricCurrentDensityUnit.AmperePerSquareFoot),
-                (ElectricCurrentDensityUnit.AmperePerSquareMeter, ElectricCurrentDensityUnit.AmperePerSquareInch) => new ElectricCurrentDensity(_value * 0.00064516, ElectricCurrentDensityUnit.AmperePerSquareInch),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricCurrentDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentDensityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricCurrentDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricCurrentDensityUnit> IQuantity<ElectricCurrentDensityUnit>.ToUnit(ElectricCurrentDensityUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -764,11 +640,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
index 328c852d27..d218226373 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     In electromagnetism, the current gradient describes how the current changes in time.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricCurrentGradient :
-        IArithmeticQuantity<ElectricCurrentGradient, ElectricCurrentGradientUnit>,
+        ILinearQuantity<ElectricCurrentGradient, ElectricCurrentGradientUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricCurrentGradient, ElectricCurrentGradient, double>,
+        IDivisionOperators<ElectricCurrentGradient, ElectricCurrentGradient, QuantityValue>,
         IMultiplyOperators<ElectricCurrentGradient, Duration, ElectricCurrent>,
         IComparisonOperators<ElectricCurrentGradient, ElectricCurrentGradient, bool>,
         IParsable<ElectricCurrentGradient>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static ElectricCurrentGradientInfo CreateDefault(Func<IEnumerable<UnitDef
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricCurrentGradient"/> is [T^-1][I].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricCurrentGradient"/> is T^-1I.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, -1, 1, 0, 0, 0);
 
@@ -118,21 +117,31 @@ public static ElectricCurrentGradientInfo CreateDefault(Func<IEnumerable<UnitDef
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricCurrentGradientUnit}"/> representing the default unit mappings for ElectricCurrentGradient.</returns>
             public static IEnumerable<UnitDefinition<ElectricCurrentGradientUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricCurrentGradientUnit.AmperePerMicrosecond, "AmperePerMicrosecond", "AmperesPerMicrosecond", new BaseUnits(time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricCurrentGradientUnit.AmperePerMillisecond, "AmperePerMillisecond", "AmperesPerMillisecond", new BaseUnits(time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricCurrentGradientUnit.AmperePerMinute, "AmperePerMinute", "AmperesPerMinute", new BaseUnits(time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricCurrentGradientUnit.AmperePerNanosecond, "AmperePerNanosecond", "AmperesPerNanosecond", new BaseUnits(time: DurationUnit.Nanosecond, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricCurrentGradientUnit.AmperePerMicrosecond, "AmperePerMicrosecond", "AmperesPerMicrosecond", new BaseUnits(time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricCurrentGradientUnit.AmperePerMillisecond, "AmperePerMillisecond", "AmperesPerMillisecond", new BaseUnits(time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricCurrentGradientUnit.AmperePerMinute, "AmperePerMinute", "AmperesPerMinute", new BaseUnits(time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere),
+                     60
+                );
+                yield return new (ElectricCurrentGradientUnit.AmperePerNanosecond, "AmperePerNanosecond", "AmperesPerNanosecond", new BaseUnits(time: DurationUnit.Nanosecond, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000)
+                );
                 yield return new (ElectricCurrentGradientUnit.AmperePerSecond, "AmperePerSecond", "AmperesPerSecond", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricCurrentGradientUnit.MilliamperePerMinute, "MilliamperePerMinute", "MilliamperesPerMinute", new BaseUnits(time: DurationUnit.Minute, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricCurrentGradientUnit.MilliamperePerSecond, "MilliamperePerSecond", "MilliamperesPerSecond", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
+                yield return new (ElectricCurrentGradientUnit.MilliamperePerMinute, "MilliamperePerMinute", "MilliamperesPerMinute", new BaseUnits(time: DurationUnit.Minute, current: ElectricCurrentUnit.Milliampere),
+                     60000
+                );
+                yield return new (ElectricCurrentGradientUnit.MilliamperePerSecond, "MilliamperePerSecond", "MilliamperesPerSecond", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     1000
+                );
             }
         }
 
         static ElectricCurrentGradient()
         {
-            Info = ElectricCurrentGradientInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricCurrentGradientInfo.CreateDefault);
         }
 
         /// <summary>
@@ -140,7 +149,7 @@ static ElectricCurrentGradient()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricCurrentGradient(double value, ElectricCurrentGradientUnit unit)
+        public ElectricCurrentGradient(QuantityValue value, ElectricCurrentGradientUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -154,7 +163,7 @@ public ElectricCurrentGradient(double value, ElectricCurrentGradientUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricCurrentGradient(double value, UnitSystem unitSystem)
+        public ElectricCurrentGradient(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -165,7 +174,8 @@ public ElectricCurrentGradient(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricCurrentGradient" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricCurrentGradient, ElectricCurrentGradientUnit> Info { get; }
@@ -194,10 +204,8 @@ public ElectricCurrentGradient(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricCurrentGradientUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -231,70 +239,44 @@ public ElectricCurrentGradient(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerMicrosecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerMicrosecond"/>
         /// </summary>
-        public double AmperesPerMicrosecond => As(ElectricCurrentGradientUnit.AmperePerMicrosecond);
+        public QuantityValue AmperesPerMicrosecond => this.As(ElectricCurrentGradientUnit.AmperePerMicrosecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerMillisecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerMillisecond"/>
         /// </summary>
-        public double AmperesPerMillisecond => As(ElectricCurrentGradientUnit.AmperePerMillisecond);
+        public QuantityValue AmperesPerMillisecond => this.As(ElectricCurrentGradientUnit.AmperePerMillisecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerMinute"/>
         /// </summary>
-        public double AmperesPerMinute => As(ElectricCurrentGradientUnit.AmperePerMinute);
+        public QuantityValue AmperesPerMinute => this.As(ElectricCurrentGradientUnit.AmperePerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerNanosecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerNanosecond"/>
         /// </summary>
-        public double AmperesPerNanosecond => As(ElectricCurrentGradientUnit.AmperePerNanosecond);
+        public QuantityValue AmperesPerNanosecond => this.As(ElectricCurrentGradientUnit.AmperePerNanosecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.AmperePerSecond"/>
         /// </summary>
-        public double AmperesPerSecond => As(ElectricCurrentGradientUnit.AmperePerSecond);
+        public QuantityValue AmperesPerSecond => this.As(ElectricCurrentGradientUnit.AmperePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.MilliamperePerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.MilliamperePerMinute"/>
         /// </summary>
-        public double MilliamperesPerMinute => As(ElectricCurrentGradientUnit.MilliamperePerMinute);
+        public QuantityValue MilliamperesPerMinute => this.As(ElectricCurrentGradientUnit.MilliamperePerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.MilliamperePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricCurrentGradientUnit.MilliamperePerSecond"/>
         /// </summary>
-        public double MilliamperesPerSecond => As(ElectricCurrentGradientUnit.MilliamperePerSecond);
+        public QuantityValue MilliamperesPerSecond => this.As(ElectricCurrentGradientUnit.MilliamperePerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricCurrentGradientUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerMicrosecond, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerMillisecond, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerMinute, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerNanosecond, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.MilliamperePerMinute, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.MilliamperePerSecond, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricCurrentGradientUnit
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMicrosecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMillisecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerMillisecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMinute, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerMinute));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerNanosecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerNanosecond));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.MilliamperePerMinute, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.MilliamperePerMinute));
-            unitConverter.SetConversionFunction<ElectricCurrentGradient>(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.MilliamperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.MilliamperePerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -323,7 +305,7 @@ public static string GetAbbreviation(ElectricCurrentGradientUnit unit, IFormatPr
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMicrosecond"/>.
         /// </summary>
-        public static ElectricCurrentGradient FromAmperesPerMicrosecond(double value)
+        public static ElectricCurrentGradient FromAmperesPerMicrosecond(QuantityValue value)
         {
             return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMicrosecond);
         }
@@ -331,7 +313,7 @@ public static ElectricCurrentGradient FromAmperesPerMicrosecond(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMillisecond"/>.
         /// </summary>
-        public static ElectricCurrentGradient FromAmperesPerMillisecond(double value)
+        public static ElectricCurrentGradient FromAmperesPerMillisecond(QuantityValue value)
         {
             return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMillisecond);
         }
@@ -339,7 +321,7 @@ public static ElectricCurrentGradient FromAmperesPerMillisecond(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMinute"/>.
         /// </summary>
-        public static ElectricCurrentGradient FromAmperesPerMinute(double value)
+        public static ElectricCurrentGradient FromAmperesPerMinute(QuantityValue value)
         {
             return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMinute);
         }
@@ -347,7 +329,7 @@ public static ElectricCurrentGradient FromAmperesPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerNanosecond"/>.
         /// </summary>
-        public static ElectricCurrentGradient FromAmperesPerNanosecond(double value)
+        public static ElectricCurrentGradient FromAmperesPerNanosecond(QuantityValue value)
         {
             return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerNanosecond);
         }
@@ -355,7 +337,7 @@ public static ElectricCurrentGradient FromAmperesPerNanosecond(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerSecond"/>.
         /// </summary>
-        public static ElectricCurrentGradient FromAmperesPerSecond(double value)
+        public static ElectricCurrentGradient FromAmperesPerSecond(QuantityValue value)
         {
             return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerSecond);
         }
@@ -363,7 +345,7 @@ public static ElectricCurrentGradient FromAmperesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.MilliamperePerMinute"/>.
         /// </summary>
-        public static ElectricCurrentGradient FromMilliamperesPerMinute(double value)
+        public static ElectricCurrentGradient FromMilliamperesPerMinute(QuantityValue value)
         {
             return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.MilliamperePerMinute);
         }
@@ -371,7 +353,7 @@ public static ElectricCurrentGradient FromMilliamperesPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.MilliamperePerSecond"/>.
         /// </summary>
-        public static ElectricCurrentGradient FromMilliamperesPerSecond(double value)
+        public static ElectricCurrentGradient FromMilliamperesPerSecond(QuantityValue value)
         {
             return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.MilliamperePerSecond);
         }
@@ -382,7 +364,7 @@ public static ElectricCurrentGradient FromMilliamperesPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricCurrentGradient unit value.</returns>
-        public static ElectricCurrentGradient From(double value, ElectricCurrentGradientUnit fromUnit)
+        public static ElectricCurrentGradient From(QuantityValue value, ElectricCurrentGradientUnit fromUnit)
         {
             return new ElectricCurrentGradient(value, fromUnit);
         }
@@ -443,10 +425,7 @@ public static ElectricCurrentGradient Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricCurrentGradient Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricCurrentGradient, ElectricCurrentGradientUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricCurrentGradient, ElectricCurrentGradientUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -474,11 +453,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricCurrentG
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricCurrentGradient result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricCurrentGradient, ElectricCurrentGradientUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricCurrentGradient, ElectricCurrentGradientUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -499,7 +474,7 @@ public static ElectricCurrentGradientUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -510,7 +485,7 @@ public static ElectricCurrentGradientUnit ParseUnit(string str, IFormatProvider?
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricCurrentGradientUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricCurrentGradientUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCurrentGradientUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -525,7 +500,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricCurr
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricCurrentGradientUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -544,35 +519,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricCurrentGradient"/> from adding two <see cref="ElectricCurrentGradient"/>.</summary>
         public static ElectricCurrentGradient operator +(ElectricCurrentGradient left, ElectricCurrentGradient right)
         {
-            return new ElectricCurrentGradient(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricCurrentGradient(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrentGradient"/> from subtracting two <see cref="ElectricCurrentGradient"/>.</summary>
         public static ElectricCurrentGradient operator -(ElectricCurrentGradient left, ElectricCurrentGradient right)
         {
-            return new ElectricCurrentGradient(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricCurrentGradient(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrentGradient"/> from multiplying value and <see cref="ElectricCurrentGradient"/>.</summary>
-        public static ElectricCurrentGradient operator *(double left, ElectricCurrentGradient right)
+        public static ElectricCurrentGradient operator *(QuantityValue left, ElectricCurrentGradient right)
         {
             return new ElectricCurrentGradient(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrentGradient"/> from multiplying value and <see cref="ElectricCurrentGradient"/>.</summary>
-        public static ElectricCurrentGradient operator *(ElectricCurrentGradient left, double right)
+        public static ElectricCurrentGradient operator *(ElectricCurrentGradient left, QuantityValue right)
         {
             return new ElectricCurrentGradient(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricCurrentGradient"/> from dividing <see cref="ElectricCurrentGradient"/> by value.</summary>
-        public static ElectricCurrentGradient operator /(ElectricCurrentGradient left, double right)
+        public static ElectricCurrentGradient operator /(ElectricCurrentGradient left, QuantityValue right)
         {
             return new ElectricCurrentGradient(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricCurrentGradient"/> by <see cref="ElectricCurrentGradient"/>.</summary>
-        public static double operator /(ElectricCurrentGradient left, ElectricCurrentGradient right)
+        public static QuantityValue operator /(ElectricCurrentGradient left, ElectricCurrentGradient right)
         {
             return left.AmperesPerSecond / right.AmperesPerSecond;
         }
@@ -594,97 +569,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricCurrentGradient left, ElectricCurrentGradient right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricCurrentGradient left, ElectricCurrentGradient right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricCurrentGradient left, ElectricCurrentGradient right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricCurrentGradient left, ElectricCurrentGradient right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricCurrentGradient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricCurrentGradient other, ElectricCurrentGradient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricCurrentGradient"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricCurrentGradient)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricCurrentGradient left, ElectricCurrentGradient right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricCurrentGradient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricCurrentGradient other, ElectricCurrentGradient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricCurrentGradient"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricCurrentGradient,ElectricCurrentGradient)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricCurrentGradient)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricCurrentGradient left, ElectricCurrentGradient right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricCurrentGradient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricCurrentGradient other, ElectricCurrentGradient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricCurrentGradient"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricCurrentGradient"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricCurrentGradient"/>, this method delegates to
+        ///     <see cref="Equals(ElectricCurrentGradient)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricCurrentGradient otherQuantity))
+            if (obj is not ElectricCurrentGradient otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricCurrentGradient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricCurrentGradient other, ElectricCurrentGradient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricCurrentGradient"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricCurrentGradient other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricCurrentGradient.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricCurrentGradient), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricCurrentGradient"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricCurrentGradient)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricCurrentGradient otherQuantity)) throw new ArgumentException("Expected type ElectricCurrentGradient.", nameof(obj));
+            if (obj is not ElectricCurrentGradient otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricCurrentGradient>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricCurrentGradient"/> with another <see cref="ElectricCurrentGradient"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricCurrentGradient"/> with another <see cref="ElectricCurrentGradient"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -696,141 +685,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricCurrentGradient other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricCurrentGradientUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricCurrentGradientUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricCurrentGradient to another ElectricCurrentGradient with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricCurrentGradient with the specified unit.</returns>
-        public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="ElectricCurrentGradient"/> to another <see cref="ElectricCurrentGradient"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricCurrentGradient with the specified unit.</returns>
-        public ElectricCurrentGradient ToUnit(ElectricCurrentGradientUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricCurrentGradient), Unit, typeof(ElectricCurrentGradient), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricCurrentGradient)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricCurrentGradient"/> to another <see cref="ElectricCurrentGradient"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricCurrentGradient"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricCurrentGradientUnit unit, [NotNullWhen(true)] out ElectricCurrentGradient? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricCurrentGradient? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricCurrentGradientUnit -> BaseUnit
-                (ElectricCurrentGradientUnit.AmperePerMicrosecond, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient(_value * 1E6, ElectricCurrentGradientUnit.AmperePerSecond),
-                (ElectricCurrentGradientUnit.AmperePerMillisecond, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient(_value * 1E3, ElectricCurrentGradientUnit.AmperePerSecond),
-                (ElectricCurrentGradientUnit.AmperePerMinute, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient(_value / 60, ElectricCurrentGradientUnit.AmperePerSecond),
-                (ElectricCurrentGradientUnit.AmperePerNanosecond, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient(_value * 1E9, ElectricCurrentGradientUnit.AmperePerSecond),
-                (ElectricCurrentGradientUnit.MilliamperePerMinute, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient((_value / 60) * 1e-3d, ElectricCurrentGradientUnit.AmperePerSecond),
-                (ElectricCurrentGradientUnit.MilliamperePerSecond, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient((_value) * 1e-3d, ElectricCurrentGradientUnit.AmperePerSecond),
-
-                // BaseUnit -> ElectricCurrentGradientUnit
-                (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMicrosecond) => new ElectricCurrentGradient(_value / 1E6, ElectricCurrentGradientUnit.AmperePerMicrosecond),
-                (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMillisecond) => new ElectricCurrentGradient(_value / 1E3, ElectricCurrentGradientUnit.AmperePerMillisecond),
-                (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMinute) => new ElectricCurrentGradient(_value * 60, ElectricCurrentGradientUnit.AmperePerMinute),
-                (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerNanosecond) => new ElectricCurrentGradient(_value / 1E9, ElectricCurrentGradientUnit.AmperePerNanosecond),
-                (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.MilliamperePerMinute) => new ElectricCurrentGradient((_value * 60) / 1e-3d, ElectricCurrentGradientUnit.MilliamperePerMinute),
-                (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.MilliamperePerSecond) => new ElectricCurrentGradient((_value) / 1e-3d, ElectricCurrentGradientUnit.MilliamperePerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricCurrentGradientUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentGradientUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricCurrentGradientUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentGradientUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricCurrentGradientUnit> IQuantity<ElectricCurrentGradientUnit>.ToUnit(ElectricCurrentGradientUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -844,11 +701,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
index 0cffdfb99a..efb660104d 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Electric_field
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricField :
-        IArithmeticQuantity<ElectricField, ElectricFieldUnit>,
+        ILinearQuantity<ElectricField, ElectricFieldUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricField, ElectricField, double>,
+        IDivisionOperators<ElectricField, ElectricField, QuantityValue>,
+        IMultiplyOperators<ElectricField, Length, ElectricPotential>,
         IComparisonOperators<ElectricField, ElectricField, bool>,
         IParsable<ElectricField>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static ElectricFieldInfo CreateDefault(Func<IEnumerable<UnitDefinition<El
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricField"/> is [T^-3][L][M][I^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricField"/> is T^-3LMI^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 1, -3, -1, 0, 0, 0);
 
@@ -126,9 +126,7 @@ public static IEnumerable<UnitDefinition<ElectricFieldUnit>> GetDefaultMappings(
 
         static ElectricField()
         {
-            Info = ElectricFieldInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricFieldInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +134,7 @@ static ElectricField()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricField(double value, ElectricFieldUnit unit)
+        public ElectricField(QuantityValue value, ElectricFieldUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -150,7 +148,7 @@ public ElectricField(double value, ElectricFieldUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricField(double value, UnitSystem unitSystem)
+        public ElectricField(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -161,7 +159,8 @@ public ElectricField(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricField" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricField, ElectricFieldUnit> Info { get; }
@@ -190,10 +189,8 @@ public ElectricField(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricFieldUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,28 +224,14 @@ public ElectricField(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricFieldUnit.VoltPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricFieldUnit.VoltPerMeter"/>
         /// </summary>
-        public double VoltsPerMeter => As(ElectricFieldUnit.VoltPerMeter);
+        public QuantityValue VoltsPerMeter => this.As(ElectricFieldUnit.VoltPerMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricFieldUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricField>(ElectricFieldUnit.VoltPerMeter, ElectricFieldUnit.VoltPerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricFieldUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -277,7 +260,7 @@ public static string GetAbbreviation(ElectricFieldUnit unit, IFormatProvider? pr
         /// <summary>
         ///     Creates a <see cref="ElectricField"/> from <see cref="ElectricFieldUnit.VoltPerMeter"/>.
         /// </summary>
-        public static ElectricField FromVoltsPerMeter(double value)
+        public static ElectricField FromVoltsPerMeter(QuantityValue value)
         {
             return new ElectricField(value, ElectricFieldUnit.VoltPerMeter);
         }
@@ -288,7 +271,7 @@ public static ElectricField FromVoltsPerMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricField unit value.</returns>
-        public static ElectricField From(double value, ElectricFieldUnit fromUnit)
+        public static ElectricField From(QuantityValue value, ElectricFieldUnit fromUnit)
         {
             return new ElectricField(value, fromUnit);
         }
@@ -349,10 +332,7 @@ public static ElectricField Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricField Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricField, ElectricFieldUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricField, ElectricFieldUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -380,11 +360,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricField re
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricField result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricField, ElectricFieldUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricField, ElectricFieldUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -405,7 +381,7 @@ public static ElectricFieldUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -416,7 +392,7 @@ public static ElectricFieldUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricFieldUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricFieldUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricFieldUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -431,7 +407,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricFiel
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricFieldUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -450,137 +426,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricField"/> from adding two <see cref="ElectricField"/>.</summary>
         public static ElectricField operator +(ElectricField left, ElectricField right)
         {
-            return new ElectricField(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricField(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricField"/> from subtracting two <see cref="ElectricField"/>.</summary>
         public static ElectricField operator -(ElectricField left, ElectricField right)
         {
-            return new ElectricField(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricField(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricField"/> from multiplying value and <see cref="ElectricField"/>.</summary>
-        public static ElectricField operator *(double left, ElectricField right)
+        public static ElectricField operator *(QuantityValue left, ElectricField right)
         {
             return new ElectricField(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricField"/> from multiplying value and <see cref="ElectricField"/>.</summary>
-        public static ElectricField operator *(ElectricField left, double right)
+        public static ElectricField operator *(ElectricField left, QuantityValue right)
         {
             return new ElectricField(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricField"/> from dividing <see cref="ElectricField"/> by value.</summary>
-        public static ElectricField operator /(ElectricField left, double right)
+        public static ElectricField operator /(ElectricField left, QuantityValue right)
         {
             return new ElectricField(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricField"/> by <see cref="ElectricField"/>.</summary>
-        public static double operator /(ElectricField left, ElectricField right)
+        public static QuantityValue operator /(ElectricField left, ElectricField right)
         {
             return left.VoltsPerMeter / right.VoltsPerMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="ElectricPotential"/> from <see cref="ElectricField"/> * <see cref="Length"/>.</summary>
+        public static ElectricPotential operator *(ElectricField electricField, Length length)
+        {
+            return ElectricPotential.FromVolts(electricField.VoltsPerMeter * length.Meters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricField left, ElectricField right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricField left, ElectricField right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricField left, ElectricField right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricField left, ElectricField right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricField"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricField other, ElectricField tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricField"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricField)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricField left, ElectricField right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricField"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricField other, ElectricField tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricField"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricField,ElectricField)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricField)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricField left, ElectricField right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricField"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricField other, ElectricField tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricField"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricField"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricField"/>, this method delegates to
+        ///     <see cref="Equals(ElectricField)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricField otherQuantity))
+            if (obj is not ElectricField otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricField"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricField other, ElectricField tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricField"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricField other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricField.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricField), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricField"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricField)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricField otherQuantity)) throw new ArgumentException("Expected type ElectricField.", nameof(obj));
+            if (obj is not ElectricField otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricField>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricField"/> with another <see cref="ElectricField"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricField"/> with another <see cref="ElectricField"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -592,131 +592,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricField other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricFieldUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricFieldUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricField to another ElectricField with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricField with the specified unit.</returns>
-        public ElectricField ToUnit(ElectricFieldUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricField"/> to another <see cref="ElectricField"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricField with the specified unit.</returns>
-        public ElectricField ToUnit(ElectricFieldUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricField), Unit, typeof(ElectricField), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricField)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricField"/> to another <see cref="ElectricField"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricField"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricFieldUnit unit, [NotNullWhen(true)] out ElectricField? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricField? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricFieldUnit -> BaseUnit
-
-                // BaseUnit -> ElectricFieldUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricFieldUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricFieldUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricFieldUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricFieldUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricFieldUnit> IQuantity<ElectricFieldUnit>.ToUnit(ElectricFieldUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -728,11 +608,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricImpedance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricImpedance.g.cs
index 0664d9e4e5..71835b09c7 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricImpedance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricImpedance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -39,11 +37,12 @@ namespace UnitsNet
     /// </remarks>
     [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")]
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricImpedance :
-        IArithmeticQuantity<ElectricImpedance, ElectricImpedanceUnit>,
+        ILinearQuantity<ElectricImpedance, ElectricImpedanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricImpedance, ElectricImpedance, double>,
+        IDivisionOperators<ElectricImpedance, ElectricImpedance, QuantityValue>,
         IComparisonOperators<ElectricImpedance, ElectricImpedance, bool>,
         IParsable<ElectricImpedance>,
 #endif
@@ -56,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -106,7 +105,7 @@ public static ElectricImpedanceInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricImpedance"/> is [T^-3][L^2][M][I^-2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricImpedance"/> is T^-3L^2MI^-2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -3, -2, 0, 0, 0);
 
@@ -121,22 +120,34 @@ public static ElectricImpedanceInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricImpedanceUnit}"/> representing the default unit mappings for ElectricImpedance.</returns>
             public static IEnumerable<UnitDefinition<ElectricImpedanceUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricImpedanceUnit.Gigaohm, "Gigaohm", "Gigaohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricImpedanceUnit.Kiloohm, "Kiloohm", "Kiloohms", BaseUnits.Undefined);
-                yield return new (ElectricImpedanceUnit.Megaohm, "Megaohm", "Megaohms", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricImpedanceUnit.Microohm, "Microohm", "Microohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricImpedanceUnit.Milliohm, "Milliohm", "Milliohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricImpedanceUnit.Nanoohm, "Nanoohm", "Nanoohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricImpedanceUnit.Gigaohm, "Gigaohm", "Gigaohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricImpedanceUnit.Kiloohm, "Kiloohm", "Kiloohms", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricImpedanceUnit.Megaohm, "Megaohm", "Megaohms", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricImpedanceUnit.Microohm, "Microohm", "Microohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000
+                );
+                yield return new (ElectricImpedanceUnit.Milliohm, "Milliohm", "Milliohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000
+                );
+                yield return new (ElectricImpedanceUnit.Nanoohm, "Nanoohm", "Nanoohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000000
+                );
                 yield return new (ElectricImpedanceUnit.Ohm, "Ohm", "Ohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricImpedanceUnit.Teraohm, "Teraohm", "Teraohms", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricImpedanceUnit.Teraohm, "Teraohm", "Teraohms", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000000)
+                );
             }
         }
 
         static ElectricImpedance()
         {
-            Info = ElectricImpedanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricImpedanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -144,7 +155,7 @@ static ElectricImpedance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricImpedance(double value, ElectricImpedanceUnit unit)
+        public ElectricImpedance(QuantityValue value, ElectricImpedanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -158,7 +169,7 @@ public ElectricImpedance(double value, ElectricImpedanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricImpedance(double value, UnitSystem unitSystem)
+        public ElectricImpedance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -169,7 +180,8 @@ public ElectricImpedance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricImpedance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricImpedance, ElectricImpedanceUnit> Info { get; }
@@ -198,10 +210,8 @@ public ElectricImpedance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricImpedanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -235,77 +245,49 @@ public ElectricImpedance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Gigaohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Gigaohm"/>
         /// </summary>
-        public double Gigaohms => As(ElectricImpedanceUnit.Gigaohm);
+        public QuantityValue Gigaohms => this.As(ElectricImpedanceUnit.Gigaohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Kiloohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Kiloohm"/>
         /// </summary>
-        public double Kiloohms => As(ElectricImpedanceUnit.Kiloohm);
+        public QuantityValue Kiloohms => this.As(ElectricImpedanceUnit.Kiloohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Megaohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Megaohm"/>
         /// </summary>
-        public double Megaohms => As(ElectricImpedanceUnit.Megaohm);
+        public QuantityValue Megaohms => this.As(ElectricImpedanceUnit.Megaohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Microohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Microohm"/>
         /// </summary>
-        public double Microohms => As(ElectricImpedanceUnit.Microohm);
+        public QuantityValue Microohms => this.As(ElectricImpedanceUnit.Microohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Milliohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Milliohm"/>
         /// </summary>
-        public double Milliohms => As(ElectricImpedanceUnit.Milliohm);
+        public QuantityValue Milliohms => this.As(ElectricImpedanceUnit.Milliohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Nanoohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Nanoohm"/>
         /// </summary>
-        public double Nanoohms => As(ElectricImpedanceUnit.Nanoohm);
+        public QuantityValue Nanoohms => this.As(ElectricImpedanceUnit.Nanoohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Ohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Ohm"/>
         /// </summary>
-        public double Ohms => As(ElectricImpedanceUnit.Ohm);
+        public QuantityValue Ohms => this.As(ElectricImpedanceUnit.Ohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Teraohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricImpedanceUnit.Teraohm"/>
         /// </summary>
-        public double Teraohms => As(ElectricImpedanceUnit.Teraohm);
+        public QuantityValue Teraohms => this.As(ElectricImpedanceUnit.Teraohm);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricImpedanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Gigaohm, ElectricImpedanceUnit.Ohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Kiloohm, ElectricImpedanceUnit.Ohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Megaohm, ElectricImpedanceUnit.Ohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Microohm, ElectricImpedanceUnit.Ohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Milliohm, ElectricImpedanceUnit.Ohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Nanoohm, ElectricImpedanceUnit.Ohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Teraohm, ElectricImpedanceUnit.Ohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Ohm));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Ohm, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricImpedanceUnit
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Gigaohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Gigaohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Kiloohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Kiloohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Megaohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Megaohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Microohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Microohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Milliohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Milliohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Nanoohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Nanoohm));
-            unitConverter.SetConversionFunction<ElectricImpedance>(ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Teraohm, quantity => quantity.ToUnit(ElectricImpedanceUnit.Teraohm));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -334,7 +316,7 @@ public static string GetAbbreviation(ElectricImpedanceUnit unit, IFormatProvider
         /// <summary>
         ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Gigaohm"/>.
         /// </summary>
-        public static ElectricImpedance FromGigaohms(double value)
+        public static ElectricImpedance FromGigaohms(QuantityValue value)
         {
             return new ElectricImpedance(value, ElectricImpedanceUnit.Gigaohm);
         }
@@ -342,7 +324,7 @@ public static ElectricImpedance FromGigaohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Kiloohm"/>.
         /// </summary>
-        public static ElectricImpedance FromKiloohms(double value)
+        public static ElectricImpedance FromKiloohms(QuantityValue value)
         {
             return new ElectricImpedance(value, ElectricImpedanceUnit.Kiloohm);
         }
@@ -350,7 +332,7 @@ public static ElectricImpedance FromKiloohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Megaohm"/>.
         /// </summary>
-        public static ElectricImpedance FromMegaohms(double value)
+        public static ElectricImpedance FromMegaohms(QuantityValue value)
         {
             return new ElectricImpedance(value, ElectricImpedanceUnit.Megaohm);
         }
@@ -358,7 +340,7 @@ public static ElectricImpedance FromMegaohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Microohm"/>.
         /// </summary>
-        public static ElectricImpedance FromMicroohms(double value)
+        public static ElectricImpedance FromMicroohms(QuantityValue value)
         {
             return new ElectricImpedance(value, ElectricImpedanceUnit.Microohm);
         }
@@ -366,7 +348,7 @@ public static ElectricImpedance FromMicroohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Milliohm"/>.
         /// </summary>
-        public static ElectricImpedance FromMilliohms(double value)
+        public static ElectricImpedance FromMilliohms(QuantityValue value)
         {
             return new ElectricImpedance(value, ElectricImpedanceUnit.Milliohm);
         }
@@ -374,7 +356,7 @@ public static ElectricImpedance FromMilliohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Nanoohm"/>.
         /// </summary>
-        public static ElectricImpedance FromNanoohms(double value)
+        public static ElectricImpedance FromNanoohms(QuantityValue value)
         {
             return new ElectricImpedance(value, ElectricImpedanceUnit.Nanoohm);
         }
@@ -382,7 +364,7 @@ public static ElectricImpedance FromNanoohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Ohm"/>.
         /// </summary>
-        public static ElectricImpedance FromOhms(double value)
+        public static ElectricImpedance FromOhms(QuantityValue value)
         {
             return new ElectricImpedance(value, ElectricImpedanceUnit.Ohm);
         }
@@ -390,7 +372,7 @@ public static ElectricImpedance FromOhms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricImpedance"/> from <see cref="ElectricImpedanceUnit.Teraohm"/>.
         /// </summary>
-        public static ElectricImpedance FromTeraohms(double value)
+        public static ElectricImpedance FromTeraohms(QuantityValue value)
         {
             return new ElectricImpedance(value, ElectricImpedanceUnit.Teraohm);
         }
@@ -401,7 +383,7 @@ public static ElectricImpedance FromTeraohms(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricImpedance unit value.</returns>
-        public static ElectricImpedance From(double value, ElectricImpedanceUnit fromUnit)
+        public static ElectricImpedance From(QuantityValue value, ElectricImpedanceUnit fromUnit)
         {
             return new ElectricImpedance(value, fromUnit);
         }
@@ -462,10 +444,7 @@ public static ElectricImpedance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricImpedance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricImpedance, ElectricImpedanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricImpedance, ElectricImpedanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -493,11 +472,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricImpedanc
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricImpedance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricImpedance, ElectricImpedanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricImpedance, ElectricImpedanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -518,7 +493,7 @@ public static ElectricImpedanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -529,7 +504,7 @@ public static ElectricImpedanceUnit ParseUnit(string str, IFormatProvider? provi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricImpedanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricImpedanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricImpedanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -544,7 +519,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricImpe
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricImpedanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -563,35 +538,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricImpedance"/> from adding two <see cref="ElectricImpedance"/>.</summary>
         public static ElectricImpedance operator +(ElectricImpedance left, ElectricImpedance right)
         {
-            return new ElectricImpedance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricImpedance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricImpedance"/> from subtracting two <see cref="ElectricImpedance"/>.</summary>
         public static ElectricImpedance operator -(ElectricImpedance left, ElectricImpedance right)
         {
-            return new ElectricImpedance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricImpedance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricImpedance"/> from multiplying value and <see cref="ElectricImpedance"/>.</summary>
-        public static ElectricImpedance operator *(double left, ElectricImpedance right)
+        public static ElectricImpedance operator *(QuantityValue left, ElectricImpedance right)
         {
             return new ElectricImpedance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricImpedance"/> from multiplying value and <see cref="ElectricImpedance"/>.</summary>
-        public static ElectricImpedance operator *(ElectricImpedance left, double right)
+        public static ElectricImpedance operator *(ElectricImpedance left, QuantityValue right)
         {
             return new ElectricImpedance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricImpedance"/> from dividing <see cref="ElectricImpedance"/> by value.</summary>
-        public static ElectricImpedance operator /(ElectricImpedance left, double right)
+        public static ElectricImpedance operator /(ElectricImpedance left, QuantityValue right)
         {
             return new ElectricImpedance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricImpedance"/> by <see cref="ElectricImpedance"/>.</summary>
-        public static double operator /(ElectricImpedance left, ElectricImpedance right)
+        public static QuantityValue operator /(ElectricImpedance left, ElectricImpedance right)
         {
             return left.Ohms / right.Ohms;
         }
@@ -603,97 +578,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricImpedance left, ElectricImpedance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricImpedance left, ElectricImpedance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricImpedance left, ElectricImpedance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricImpedance left, ElectricImpedance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricImpedance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricImpedance other, ElectricImpedance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricImpedance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricImpedance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricImpedance left, ElectricImpedance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricImpedance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricImpedance other, ElectricImpedance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricImpedance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricImpedance,ElectricImpedance)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricImpedance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricImpedance left, ElectricImpedance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricImpedance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricImpedance other, ElectricImpedance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricImpedance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricImpedance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricImpedance"/>, this method delegates to
+        ///     <see cref="Equals(ElectricImpedance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricImpedance otherQuantity))
+            if (obj is not ElectricImpedance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricImpedance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricImpedance other, ElectricImpedance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricImpedance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricImpedance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricImpedance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricImpedance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricImpedance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricImpedance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricImpedance otherQuantity)) throw new ArgumentException("Expected type ElectricImpedance.", nameof(obj));
+            if (obj is not ElectricImpedance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricImpedance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricImpedance"/> with another <see cref="ElectricImpedance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricImpedance"/> with another <see cref="ElectricImpedance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -705,143 +694,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricImpedance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricImpedanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricImpedanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricImpedance to another ElectricImpedance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricImpedance with the specified unit.</returns>
-        public ElectricImpedance ToUnit(ElectricImpedanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="ElectricImpedance"/> to another <see cref="ElectricImpedance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricImpedance with the specified unit.</returns>
-        public ElectricImpedance ToUnit(ElectricImpedanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricImpedance), Unit, typeof(ElectricImpedance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricImpedance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricImpedance"/> to another <see cref="ElectricImpedance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricImpedance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricImpedanceUnit unit, [NotNullWhen(true)] out ElectricImpedance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricImpedance? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricImpedanceUnit -> BaseUnit
-                (ElectricImpedanceUnit.Gigaohm, ElectricImpedanceUnit.Ohm) => new ElectricImpedance((_value) * 1e9d, ElectricImpedanceUnit.Ohm),
-                (ElectricImpedanceUnit.Kiloohm, ElectricImpedanceUnit.Ohm) => new ElectricImpedance((_value) * 1e3d, ElectricImpedanceUnit.Ohm),
-                (ElectricImpedanceUnit.Megaohm, ElectricImpedanceUnit.Ohm) => new ElectricImpedance((_value) * 1e6d, ElectricImpedanceUnit.Ohm),
-                (ElectricImpedanceUnit.Microohm, ElectricImpedanceUnit.Ohm) => new ElectricImpedance((_value) * 1e-6d, ElectricImpedanceUnit.Ohm),
-                (ElectricImpedanceUnit.Milliohm, ElectricImpedanceUnit.Ohm) => new ElectricImpedance((_value) * 1e-3d, ElectricImpedanceUnit.Ohm),
-                (ElectricImpedanceUnit.Nanoohm, ElectricImpedanceUnit.Ohm) => new ElectricImpedance((_value) * 1e-9d, ElectricImpedanceUnit.Ohm),
-                (ElectricImpedanceUnit.Teraohm, ElectricImpedanceUnit.Ohm) => new ElectricImpedance((_value) * 1e12d, ElectricImpedanceUnit.Ohm),
-
-                // BaseUnit -> ElectricImpedanceUnit
-                (ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Gigaohm) => new ElectricImpedance((_value) / 1e9d, ElectricImpedanceUnit.Gigaohm),
-                (ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Kiloohm) => new ElectricImpedance((_value) / 1e3d, ElectricImpedanceUnit.Kiloohm),
-                (ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Megaohm) => new ElectricImpedance((_value) / 1e6d, ElectricImpedanceUnit.Megaohm),
-                (ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Microohm) => new ElectricImpedance((_value) / 1e-6d, ElectricImpedanceUnit.Microohm),
-                (ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Milliohm) => new ElectricImpedance((_value) / 1e-3d, ElectricImpedanceUnit.Milliohm),
-                (ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Nanoohm) => new ElectricImpedance((_value) / 1e-9d, ElectricImpedanceUnit.Nanoohm),
-                (ElectricImpedanceUnit.Ohm, ElectricImpedanceUnit.Teraohm) => new ElectricImpedance((_value) / 1e12d, ElectricImpedanceUnit.Teraohm),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricImpedanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricImpedanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricImpedanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricImpedanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricImpedanceUnit> IQuantity<ElectricImpedanceUnit>.ToUnit(ElectricImpedanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -855,11 +710,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
index b23b44fce0..0ed85fa627 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Inductance
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricInductance :
-        IArithmeticQuantity<ElectricInductance, ElectricInductanceUnit>,
+        ILinearQuantity<ElectricInductance, ElectricInductanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricInductance, ElectricInductance, double>,
+        IDivisionOperators<ElectricInductance, ElectricInductance, QuantityValue>,
         IComparisonOperators<ElectricInductance, ElectricInductance, bool>,
         IParsable<ElectricInductance>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static ElectricInductanceInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricInductance"/> is [T^-2][L^2][M][I^-2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricInductance"/> is T^-2L^2MI^-2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -2, -2, 0, 0, 0);
 
@@ -121,18 +120,24 @@ public static ElectricInductanceInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             public static IEnumerable<UnitDefinition<ElectricInductanceUnit>> GetDefaultMappings()
             {
                 yield return new (ElectricInductanceUnit.Henry, "Henry", "Henries", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricInductanceUnit.Microhenry, "Microhenry", "Microhenries", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricInductanceUnit.Millihenry, "Millihenry", "Millihenries", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricInductanceUnit.Nanohenry, "Nanohenry", "Nanohenries", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricInductanceUnit.Picohenry, "Picohenry", "Picohenries", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricInductanceUnit.Microhenry, "Microhenry", "Microhenries", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000
+                );
+                yield return new (ElectricInductanceUnit.Millihenry, "Millihenry", "Millihenries", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000
+                );
+                yield return new (ElectricInductanceUnit.Nanohenry, "Nanohenry", "Nanohenries", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000000
+                );
+                yield return new (ElectricInductanceUnit.Picohenry, "Picohenry", "Picohenries", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000000000
+                );
             }
         }
 
         static ElectricInductance()
         {
-            Info = ElectricInductanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricInductanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -140,7 +145,7 @@ static ElectricInductance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricInductance(double value, ElectricInductanceUnit unit)
+        public ElectricInductance(QuantityValue value, ElectricInductanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -154,7 +159,7 @@ public ElectricInductance(double value, ElectricInductanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricInductance(double value, UnitSystem unitSystem)
+        public ElectricInductance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -165,7 +170,8 @@ public ElectricInductance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricInductance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricInductance, ElectricInductanceUnit> Info { get; }
@@ -194,10 +200,8 @@ public ElectricInductance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricInductanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -231,56 +235,34 @@ public ElectricInductance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Henry"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Henry"/>
         /// </summary>
-        public double Henries => As(ElectricInductanceUnit.Henry);
+        public QuantityValue Henries => this.As(ElectricInductanceUnit.Henry);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Microhenry"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Microhenry"/>
         /// </summary>
-        public double Microhenries => As(ElectricInductanceUnit.Microhenry);
+        public QuantityValue Microhenries => this.As(ElectricInductanceUnit.Microhenry);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Millihenry"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Millihenry"/>
         /// </summary>
-        public double Millihenries => As(ElectricInductanceUnit.Millihenry);
+        public QuantityValue Millihenries => this.As(ElectricInductanceUnit.Millihenry);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Nanohenry"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Nanohenry"/>
         /// </summary>
-        public double Nanohenries => As(ElectricInductanceUnit.Nanohenry);
+        public QuantityValue Nanohenries => this.As(ElectricInductanceUnit.Nanohenry);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Picohenry"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricInductanceUnit.Picohenry"/>
         /// </summary>
-        public double Picohenries => As(ElectricInductanceUnit.Picohenry);
+        public QuantityValue Picohenries => this.As(ElectricInductanceUnit.Picohenry);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricInductanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Microhenry, ElectricInductanceUnit.Henry, quantity => quantity.ToUnit(ElectricInductanceUnit.Henry));
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Millihenry, ElectricInductanceUnit.Henry, quantity => quantity.ToUnit(ElectricInductanceUnit.Henry));
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Nanohenry, ElectricInductanceUnit.Henry, quantity => quantity.ToUnit(ElectricInductanceUnit.Henry));
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Picohenry, ElectricInductanceUnit.Henry, quantity => quantity.ToUnit(ElectricInductanceUnit.Henry));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Henry, ElectricInductanceUnit.Henry, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricInductanceUnit
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Henry, ElectricInductanceUnit.Microhenry, quantity => quantity.ToUnit(ElectricInductanceUnit.Microhenry));
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Henry, ElectricInductanceUnit.Millihenry, quantity => quantity.ToUnit(ElectricInductanceUnit.Millihenry));
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Henry, ElectricInductanceUnit.Nanohenry, quantity => quantity.ToUnit(ElectricInductanceUnit.Nanohenry));
-            unitConverter.SetConversionFunction<ElectricInductance>(ElectricInductanceUnit.Henry, ElectricInductanceUnit.Picohenry, quantity => quantity.ToUnit(ElectricInductanceUnit.Picohenry));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -309,7 +291,7 @@ public static string GetAbbreviation(ElectricInductanceUnit unit, IFormatProvide
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Henry"/>.
         /// </summary>
-        public static ElectricInductance FromHenries(double value)
+        public static ElectricInductance FromHenries(QuantityValue value)
         {
             return new ElectricInductance(value, ElectricInductanceUnit.Henry);
         }
@@ -317,7 +299,7 @@ public static ElectricInductance FromHenries(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Microhenry"/>.
         /// </summary>
-        public static ElectricInductance FromMicrohenries(double value)
+        public static ElectricInductance FromMicrohenries(QuantityValue value)
         {
             return new ElectricInductance(value, ElectricInductanceUnit.Microhenry);
         }
@@ -325,7 +307,7 @@ public static ElectricInductance FromMicrohenries(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Millihenry"/>.
         /// </summary>
-        public static ElectricInductance FromMillihenries(double value)
+        public static ElectricInductance FromMillihenries(QuantityValue value)
         {
             return new ElectricInductance(value, ElectricInductanceUnit.Millihenry);
         }
@@ -333,7 +315,7 @@ public static ElectricInductance FromMillihenries(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Nanohenry"/>.
         /// </summary>
-        public static ElectricInductance FromNanohenries(double value)
+        public static ElectricInductance FromNanohenries(QuantityValue value)
         {
             return new ElectricInductance(value, ElectricInductanceUnit.Nanohenry);
         }
@@ -341,7 +323,7 @@ public static ElectricInductance FromNanohenries(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Picohenry"/>.
         /// </summary>
-        public static ElectricInductance FromPicohenries(double value)
+        public static ElectricInductance FromPicohenries(QuantityValue value)
         {
             return new ElectricInductance(value, ElectricInductanceUnit.Picohenry);
         }
@@ -352,7 +334,7 @@ public static ElectricInductance FromPicohenries(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricInductance unit value.</returns>
-        public static ElectricInductance From(double value, ElectricInductanceUnit fromUnit)
+        public static ElectricInductance From(QuantityValue value, ElectricInductanceUnit fromUnit)
         {
             return new ElectricInductance(value, fromUnit);
         }
@@ -413,10 +395,7 @@ public static ElectricInductance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricInductance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricInductance, ElectricInductanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricInductance, ElectricInductanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -444,11 +423,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricInductan
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricInductance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricInductance, ElectricInductanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricInductance, ElectricInductanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -469,7 +444,7 @@ public static ElectricInductanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -480,7 +455,7 @@ public static ElectricInductanceUnit ParseUnit(string str, IFormatProvider? prov
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricInductanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricInductanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricInductanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -495,7 +470,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricIndu
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricInductanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -514,35 +489,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricInductance"/> from adding two <see cref="ElectricInductance"/>.</summary>
         public static ElectricInductance operator +(ElectricInductance left, ElectricInductance right)
         {
-            return new ElectricInductance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricInductance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricInductance"/> from subtracting two <see cref="ElectricInductance"/>.</summary>
         public static ElectricInductance operator -(ElectricInductance left, ElectricInductance right)
         {
-            return new ElectricInductance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricInductance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricInductance"/> from multiplying value and <see cref="ElectricInductance"/>.</summary>
-        public static ElectricInductance operator *(double left, ElectricInductance right)
+        public static ElectricInductance operator *(QuantityValue left, ElectricInductance right)
         {
             return new ElectricInductance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricInductance"/> from multiplying value and <see cref="ElectricInductance"/>.</summary>
-        public static ElectricInductance operator *(ElectricInductance left, double right)
+        public static ElectricInductance operator *(ElectricInductance left, QuantityValue right)
         {
             return new ElectricInductance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricInductance"/> from dividing <see cref="ElectricInductance"/> by value.</summary>
-        public static ElectricInductance operator /(ElectricInductance left, double right)
+        public static ElectricInductance operator /(ElectricInductance left, QuantityValue right)
         {
             return new ElectricInductance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricInductance"/> by <see cref="ElectricInductance"/>.</summary>
-        public static double operator /(ElectricInductance left, ElectricInductance right)
+        public static QuantityValue operator /(ElectricInductance left, ElectricInductance right)
         {
             return left.Henries / right.Henries;
         }
@@ -554,97 +529,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricInductance left, ElectricInductance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricInductance left, ElectricInductance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricInductance left, ElectricInductance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricInductance left, ElectricInductance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricInductance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricInductance other, ElectricInductance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricInductance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricInductance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricInductance left, ElectricInductance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricInductance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricInductance other, ElectricInductance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricInductance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricInductance,ElectricInductance)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricInductance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricInductance left, ElectricInductance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricInductance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricInductance other, ElectricInductance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricInductance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricInductance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricInductance"/>, this method delegates to
+        ///     <see cref="Equals(ElectricInductance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricInductance otherQuantity))
+            if (obj is not ElectricInductance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricInductance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricInductance other, ElectricInductance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricInductance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricInductance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricInductance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricInductance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricInductance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricInductance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricInductance otherQuantity)) throw new ArgumentException("Expected type ElectricInductance.", nameof(obj));
+            if (obj is not ElectricInductance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricInductance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricInductance"/> with another <see cref="ElectricInductance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricInductance"/> with another <see cref="ElectricInductance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -656,137 +645,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricInductance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricInductanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricInductanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricInductance to another ElectricInductance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricInductance with the specified unit.</returns>
-        public ElectricInductance ToUnit(ElectricInductanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="ElectricInductance"/> to another <see cref="ElectricInductance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricInductance with the specified unit.</returns>
-        public ElectricInductance ToUnit(ElectricInductanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricInductance), Unit, typeof(ElectricInductance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricInductance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricInductance"/> to another <see cref="ElectricInductance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricInductance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricInductanceUnit unit, [NotNullWhen(true)] out ElectricInductance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricInductance? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricInductanceUnit -> BaseUnit
-                (ElectricInductanceUnit.Microhenry, ElectricInductanceUnit.Henry) => new ElectricInductance((_value) * 1e-6d, ElectricInductanceUnit.Henry),
-                (ElectricInductanceUnit.Millihenry, ElectricInductanceUnit.Henry) => new ElectricInductance((_value) * 1e-3d, ElectricInductanceUnit.Henry),
-                (ElectricInductanceUnit.Nanohenry, ElectricInductanceUnit.Henry) => new ElectricInductance((_value) * 1e-9d, ElectricInductanceUnit.Henry),
-                (ElectricInductanceUnit.Picohenry, ElectricInductanceUnit.Henry) => new ElectricInductance((_value) * 1e-12d, ElectricInductanceUnit.Henry),
-
-                // BaseUnit -> ElectricInductanceUnit
-                (ElectricInductanceUnit.Henry, ElectricInductanceUnit.Microhenry) => new ElectricInductance((_value) / 1e-6d, ElectricInductanceUnit.Microhenry),
-                (ElectricInductanceUnit.Henry, ElectricInductanceUnit.Millihenry) => new ElectricInductance((_value) / 1e-3d, ElectricInductanceUnit.Millihenry),
-                (ElectricInductanceUnit.Henry, ElectricInductanceUnit.Nanohenry) => new ElectricInductance((_value) / 1e-9d, ElectricInductanceUnit.Nanohenry),
-                (ElectricInductanceUnit.Henry, ElectricInductanceUnit.Picohenry) => new ElectricInductance((_value) / 1e-12d, ElectricInductanceUnit.Picohenry),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricInductanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricInductanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricInductanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricInductanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricInductanceUnit> IQuantity<ElectricInductanceUnit>.ToUnit(ElectricInductanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -800,11 +661,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
index 82a074d2a1..f849778462 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,14 +36,21 @@ namespace UnitsNet
     ///     If you want to map more parameters into the <c>ElectricPotential</c> class (volts RMS, phase angle, etc.), create your own wrapper type such as a record or named tuple.
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricPotential :
-        IArithmeticQuantity<ElectricPotential, ElectricPotentialUnit>,
+        ILinearQuantity<ElectricPotential, ElectricPotentialUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricPotential, ElectricPotential, double>,
+        IDivisionOperators<ElectricPotential, ElectricPotential, QuantityValue>,
+        IDivisionOperators<ElectricPotential, ElectricPotentialChangeRate, Duration>,
+        IMultiplyOperators<ElectricPotential, ElectricCapacitance, ElectricCharge>,
+        IMultiplyOperators<ElectricPotential, ElectricConductance, ElectricCurrent>,
         IDivisionOperators<ElectricPotential, ElectricResistance, ElectricCurrent>,
+        IDivisionOperators<ElectricPotential, Length, ElectricField>,
+        IDivisionOperators<ElectricPotential, Duration, ElectricPotentialChangeRate>,
         IDivisionOperators<ElectricPotential, ElectricCurrent, ElectricResistance>,
         IMultiplyOperators<ElectricPotential, ElectricCharge, Energy>,
+        IDivisionOperators<ElectricPotential, ElectricField, Length>,
         IMultiplyOperators<ElectricPotential, ElectricCurrent, Power>,
         IComparisonOperators<ElectricPotential, ElectricPotential, bool>,
         IParsable<ElectricPotential>,
@@ -59,7 +64,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -109,7 +114,7 @@ public static ElectricPotentialInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricPotential"/> is [T^-3][L^2][M][I^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricPotential"/> is T^-3L^2MI^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -3, -1, 0, 0, 0);
 
@@ -124,20 +129,28 @@ public static ElectricPotentialInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricPotentialUnit}"/> representing the default unit mappings for ElectricPotential.</returns>
             public static IEnumerable<UnitDefinition<ElectricPotentialUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricPotentialUnit.Kilovolt, "Kilovolt", "Kilovolts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricPotentialUnit.Megavolt, "Megavolt", "Megavolts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere));
-                yield return new (ElectricPotentialUnit.Microvolt, "Microvolt", "Microvolts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialUnit.Millivolt, "Millivolt", "Millivolts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialUnit.Nanovolt, "Nanovolt", "Nanovolts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricPotentialUnit.Kilovolt, "Kilovolt", "Kilovolts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricPotentialUnit.Megavolt, "Megavolt", "Megavolts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricPotentialUnit.Microvolt, "Microvolt", "Microvolts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000
+                );
+                yield return new (ElectricPotentialUnit.Millivolt, "Millivolt", "Millivolts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000
+                );
+                yield return new (ElectricPotentialUnit.Nanovolt, "Nanovolt", "Nanovolts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000000
+                );
                 yield return new (ElectricPotentialUnit.Volt, "Volt", "Volts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
             }
         }
 
         static ElectricPotential()
         {
-            Info = ElectricPotentialInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricPotentialInfo.CreateDefault);
         }
 
         /// <summary>
@@ -145,7 +158,7 @@ static ElectricPotential()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricPotential(double value, ElectricPotentialUnit unit)
+        public ElectricPotential(QuantityValue value, ElectricPotentialUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -159,7 +172,7 @@ public ElectricPotential(double value, ElectricPotentialUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricPotential(double value, UnitSystem unitSystem)
+        public ElectricPotential(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -170,7 +183,8 @@ public ElectricPotential(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricPotential" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricPotential, ElectricPotentialUnit> Info { get; }
@@ -199,10 +213,8 @@ public ElectricPotential(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricPotentialUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -236,63 +248,39 @@ public ElectricPotential(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Kilovolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Kilovolt"/>
         /// </summary>
-        public double Kilovolts => As(ElectricPotentialUnit.Kilovolt);
+        public QuantityValue Kilovolts => this.As(ElectricPotentialUnit.Kilovolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Megavolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Megavolt"/>
         /// </summary>
-        public double Megavolts => As(ElectricPotentialUnit.Megavolt);
+        public QuantityValue Megavolts => this.As(ElectricPotentialUnit.Megavolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Microvolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Microvolt"/>
         /// </summary>
-        public double Microvolts => As(ElectricPotentialUnit.Microvolt);
+        public QuantityValue Microvolts => this.As(ElectricPotentialUnit.Microvolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Millivolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Millivolt"/>
         /// </summary>
-        public double Millivolts => As(ElectricPotentialUnit.Millivolt);
+        public QuantityValue Millivolts => this.As(ElectricPotentialUnit.Millivolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Nanovolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Nanovolt"/>
         /// </summary>
-        public double Nanovolts => As(ElectricPotentialUnit.Nanovolt);
+        public QuantityValue Nanovolts => this.As(ElectricPotentialUnit.Nanovolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Volt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialUnit.Volt"/>
         /// </summary>
-        public double Volts => As(ElectricPotentialUnit.Volt);
+        public QuantityValue Volts => this.As(ElectricPotentialUnit.Volt);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricPotentialUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Kilovolt, ElectricPotentialUnit.Volt, quantity => quantity.ToUnit(ElectricPotentialUnit.Volt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Megavolt, ElectricPotentialUnit.Volt, quantity => quantity.ToUnit(ElectricPotentialUnit.Volt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Microvolt, ElectricPotentialUnit.Volt, quantity => quantity.ToUnit(ElectricPotentialUnit.Volt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Millivolt, ElectricPotentialUnit.Volt, quantity => quantity.ToUnit(ElectricPotentialUnit.Volt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Nanovolt, ElectricPotentialUnit.Volt, quantity => quantity.ToUnit(ElectricPotentialUnit.Volt));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Volt, ElectricPotentialUnit.Volt, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricPotentialUnit
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Volt, ElectricPotentialUnit.Kilovolt, quantity => quantity.ToUnit(ElectricPotentialUnit.Kilovolt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Volt, ElectricPotentialUnit.Megavolt, quantity => quantity.ToUnit(ElectricPotentialUnit.Megavolt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Volt, ElectricPotentialUnit.Microvolt, quantity => quantity.ToUnit(ElectricPotentialUnit.Microvolt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Volt, ElectricPotentialUnit.Millivolt, quantity => quantity.ToUnit(ElectricPotentialUnit.Millivolt));
-            unitConverter.SetConversionFunction<ElectricPotential>(ElectricPotentialUnit.Volt, ElectricPotentialUnit.Nanovolt, quantity => quantity.ToUnit(ElectricPotentialUnit.Nanovolt));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -321,7 +309,7 @@ public static string GetAbbreviation(ElectricPotentialUnit unit, IFormatProvider
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Kilovolt"/>.
         /// </summary>
-        public static ElectricPotential FromKilovolts(double value)
+        public static ElectricPotential FromKilovolts(QuantityValue value)
         {
             return new ElectricPotential(value, ElectricPotentialUnit.Kilovolt);
         }
@@ -329,7 +317,7 @@ public static ElectricPotential FromKilovolts(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Megavolt"/>.
         /// </summary>
-        public static ElectricPotential FromMegavolts(double value)
+        public static ElectricPotential FromMegavolts(QuantityValue value)
         {
             return new ElectricPotential(value, ElectricPotentialUnit.Megavolt);
         }
@@ -337,7 +325,7 @@ public static ElectricPotential FromMegavolts(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Microvolt"/>.
         /// </summary>
-        public static ElectricPotential FromMicrovolts(double value)
+        public static ElectricPotential FromMicrovolts(QuantityValue value)
         {
             return new ElectricPotential(value, ElectricPotentialUnit.Microvolt);
         }
@@ -345,7 +333,7 @@ public static ElectricPotential FromMicrovolts(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Millivolt"/>.
         /// </summary>
-        public static ElectricPotential FromMillivolts(double value)
+        public static ElectricPotential FromMillivolts(QuantityValue value)
         {
             return new ElectricPotential(value, ElectricPotentialUnit.Millivolt);
         }
@@ -353,7 +341,7 @@ public static ElectricPotential FromMillivolts(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Nanovolt"/>.
         /// </summary>
-        public static ElectricPotential FromNanovolts(double value)
+        public static ElectricPotential FromNanovolts(QuantityValue value)
         {
             return new ElectricPotential(value, ElectricPotentialUnit.Nanovolt);
         }
@@ -361,7 +349,7 @@ public static ElectricPotential FromNanovolts(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Volt"/>.
         /// </summary>
-        public static ElectricPotential FromVolts(double value)
+        public static ElectricPotential FromVolts(QuantityValue value)
         {
             return new ElectricPotential(value, ElectricPotentialUnit.Volt);
         }
@@ -372,7 +360,7 @@ public static ElectricPotential FromVolts(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricPotential unit value.</returns>
-        public static ElectricPotential From(double value, ElectricPotentialUnit fromUnit)
+        public static ElectricPotential From(QuantityValue value, ElectricPotentialUnit fromUnit)
         {
             return new ElectricPotential(value, fromUnit);
         }
@@ -433,10 +421,7 @@ public static ElectricPotential Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricPotential Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricPotential, ElectricPotentialUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricPotential, ElectricPotentialUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -464,11 +449,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricPotentia
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricPotential result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricPotential, ElectricPotentialUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricPotential, ElectricPotentialUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -489,7 +470,7 @@ public static ElectricPotentialUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -500,7 +481,7 @@ public static ElectricPotentialUnit ParseUnit(string str, IFormatProvider? provi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricPotentialUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricPotentialUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricPotentialUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -515,7 +496,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricPote
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricPotentialUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -534,35 +515,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricPotential"/> from adding two <see cref="ElectricPotential"/>.</summary>
         public static ElectricPotential operator +(ElectricPotential left, ElectricPotential right)
         {
-            return new ElectricPotential(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricPotential(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricPotential"/> from subtracting two <see cref="ElectricPotential"/>.</summary>
         public static ElectricPotential operator -(ElectricPotential left, ElectricPotential right)
         {
-            return new ElectricPotential(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricPotential(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricPotential"/> from multiplying value and <see cref="ElectricPotential"/>.</summary>
-        public static ElectricPotential operator *(double left, ElectricPotential right)
+        public static ElectricPotential operator *(QuantityValue left, ElectricPotential right)
         {
             return new ElectricPotential(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricPotential"/> from multiplying value and <see cref="ElectricPotential"/>.</summary>
-        public static ElectricPotential operator *(ElectricPotential left, double right)
+        public static ElectricPotential operator *(ElectricPotential left, QuantityValue right)
         {
             return new ElectricPotential(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricPotential"/> from dividing <see cref="ElectricPotential"/> by value.</summary>
-        public static ElectricPotential operator /(ElectricPotential left, double right)
+        public static ElectricPotential operator /(ElectricPotential left, QuantityValue right)
         {
             return new ElectricPotential(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricPotential"/> by <see cref="ElectricPotential"/>.</summary>
-        public static double operator /(ElectricPotential left, ElectricPotential right)
+        public static QuantityValue operator /(ElectricPotential left, ElectricPotential right)
         {
             return left.Volts / right.Volts;
         }
@@ -571,12 +552,42 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="Duration"/> from <see cref="ElectricPotential"/> / <see cref="ElectricPotentialChangeRate"/>.</summary>
+        public static Duration operator /(ElectricPotential electricPotential, ElectricPotentialChangeRate electricPotentialChangeRate)
+        {
+            return Duration.FromSeconds(electricPotential.Volts / electricPotentialChangeRate.VoltsPerSecond);
+        }
+
+        /// <summary>Get <see cref="ElectricCharge"/> from <see cref="ElectricPotential"/> * <see cref="ElectricCapacitance"/>.</summary>
+        public static ElectricCharge operator *(ElectricPotential electricPotential, ElectricCapacitance electricCapacitance)
+        {
+            return ElectricCharge.FromCoulombs(electricPotential.Volts * electricCapacitance.Farads);
+        }
+
+        /// <summary>Get <see cref="ElectricCurrent"/> from <see cref="ElectricPotential"/> * <see cref="ElectricConductance"/>.</summary>
+        public static ElectricCurrent operator *(ElectricPotential electricPotential, ElectricConductance electricConductance)
+        {
+            return ElectricCurrent.FromAmperes(electricPotential.Volts * electricConductance.Siemens);
+        }
+
         /// <summary>Get <see cref="ElectricCurrent"/> from <see cref="ElectricPotential"/> / <see cref="ElectricResistance"/>.</summary>
         public static ElectricCurrent operator /(ElectricPotential electricPotential, ElectricResistance electricResistance)
         {
             return ElectricCurrent.FromAmperes(electricPotential.Volts / electricResistance.Ohms);
         }
 
+        /// <summary>Get <see cref="ElectricField"/> from <see cref="ElectricPotential"/> / <see cref="Length"/>.</summary>
+        public static ElectricField operator /(ElectricPotential electricPotential, Length length)
+        {
+            return ElectricField.FromVoltsPerMeter(electricPotential.Volts / length.Meters);
+        }
+
+        /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotential"/> / <see cref="Duration"/>.</summary>
+        public static ElectricPotentialChangeRate operator /(ElectricPotential electricPotential, Duration duration)
+        {
+            return ElectricPotentialChangeRate.FromVoltsPerSecond(electricPotential.Volts / duration.Seconds);
+        }
+
         /// <summary>Get <see cref="ElectricResistance"/> from <see cref="ElectricPotential"/> / <see cref="ElectricCurrent"/>.</summary>
         public static ElectricResistance operator /(ElectricPotential electricPotential, ElectricCurrent electricCurrent)
         {
@@ -589,6 +600,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Energy.FromJoules(electricPotential.Volts * electricCharge.Coulombs);
         }
 
+        /// <summary>Get <see cref="Length"/> from <see cref="ElectricPotential"/> / <see cref="ElectricField"/>.</summary>
+        public static Length operator /(ElectricPotential electricPotential, ElectricField electricField)
+        {
+            return Length.FromMeters(electricPotential.Volts / electricField.VoltsPerMeter);
+        }
+
         /// <summary>Get <see cref="Power"/> from <see cref="ElectricPotential"/> * <see cref="ElectricCurrent"/>.</summary>
         public static Power operator *(ElectricPotential electricPotential, ElectricCurrent electricCurrent)
         {
@@ -602,97 +619,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricPotential left, ElectricPotential right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricPotential left, ElectricPotential right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricPotential left, ElectricPotential right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricPotential left, ElectricPotential right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricPotential"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricPotential other, ElectricPotential tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricPotential"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricPotential)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricPotential left, ElectricPotential right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricPotential"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricPotential other, ElectricPotential tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricPotential"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricPotential,ElectricPotential)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricPotential)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricPotential left, ElectricPotential right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricPotential"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricPotential other, ElectricPotential tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricPotential"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricPotential"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricPotential"/>, this method delegates to
+        ///     <see cref="Equals(ElectricPotential)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricPotential otherQuantity))
+            if (obj is not ElectricPotential otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricPotential"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricPotential other, ElectricPotential tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricPotential"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricPotential other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricPotential.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricPotential), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricPotential"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricPotential)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricPotential otherQuantity)) throw new ArgumentException("Expected type ElectricPotential.", nameof(obj));
+            if (obj is not ElectricPotential otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricPotential>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricPotential"/> with another <see cref="ElectricPotential"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricPotential"/> with another <see cref="ElectricPotential"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -704,139 +735,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricPotential other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricPotentialUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricPotentialUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricPotential to another ElectricPotential with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricPotential with the specified unit.</returns>
-        public ElectricPotential ToUnit(ElectricPotentialUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricPotential"/> to another <see cref="ElectricPotential"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricPotential with the specified unit.</returns>
-        public ElectricPotential ToUnit(ElectricPotentialUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricPotential), Unit, typeof(ElectricPotential), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricPotential)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricPotential"/> to another <see cref="ElectricPotential"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricPotential"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricPotentialUnit unit, [NotNullWhen(true)] out ElectricPotential? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricPotential? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricPotentialUnit -> BaseUnit
-                (ElectricPotentialUnit.Kilovolt, ElectricPotentialUnit.Volt) => new ElectricPotential((_value) * 1e3d, ElectricPotentialUnit.Volt),
-                (ElectricPotentialUnit.Megavolt, ElectricPotentialUnit.Volt) => new ElectricPotential((_value) * 1e6d, ElectricPotentialUnit.Volt),
-                (ElectricPotentialUnit.Microvolt, ElectricPotentialUnit.Volt) => new ElectricPotential((_value) * 1e-6d, ElectricPotentialUnit.Volt),
-                (ElectricPotentialUnit.Millivolt, ElectricPotentialUnit.Volt) => new ElectricPotential((_value) * 1e-3d, ElectricPotentialUnit.Volt),
-                (ElectricPotentialUnit.Nanovolt, ElectricPotentialUnit.Volt) => new ElectricPotential((_value) * 1e-9d, ElectricPotentialUnit.Volt),
-
-                // BaseUnit -> ElectricPotentialUnit
-                (ElectricPotentialUnit.Volt, ElectricPotentialUnit.Kilovolt) => new ElectricPotential((_value) / 1e3d, ElectricPotentialUnit.Kilovolt),
-                (ElectricPotentialUnit.Volt, ElectricPotentialUnit.Megavolt) => new ElectricPotential((_value) / 1e6d, ElectricPotentialUnit.Megavolt),
-                (ElectricPotentialUnit.Volt, ElectricPotentialUnit.Microvolt) => new ElectricPotential((_value) / 1e-6d, ElectricPotentialUnit.Microvolt),
-                (ElectricPotentialUnit.Volt, ElectricPotentialUnit.Millivolt) => new ElectricPotential((_value) / 1e-3d, ElectricPotentialUnit.Millivolt),
-                (ElectricPotentialUnit.Volt, ElectricPotentialUnit.Nanovolt) => new ElectricPotential((_value) / 1e-9d, ElectricPotentialUnit.Nanovolt),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricPotentialUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricPotentialUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricPotentialUnit> IQuantity<ElectricPotentialUnit>.ToUnit(ElectricPotentialUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -850,11 +751,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
index 1ab1aff852..e175d42d45 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     ElectricPotential change rate is the ratio of the electric potential change to the time during which the change occurred (value of electric potential changes per unit time).
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricPotentialChangeRate :
-        IArithmeticQuantity<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit>,
+        ILinearQuantity<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricPotentialChangeRate, ElectricPotentialChangeRate, double>,
+        IDivisionOperators<ElectricPotentialChangeRate, ElectricPotentialChangeRate, QuantityValue>,
+        IMultiplyOperators<ElectricPotentialChangeRate, Duration, ElectricPotential>,
         IComparisonOperators<ElectricPotentialChangeRate, ElectricPotentialChangeRate, bool>,
         IParsable<ElectricPotentialChangeRate>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static ElectricPotentialChangeRateInfo CreateDefault(Func<IEnumerable<Uni
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricPotentialChangeRate"/> is [T^-4][L^2][M][I^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricPotentialChangeRate"/> is T^-4L^2MI^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -4, -1, 0, 0, 0);
 
@@ -117,34 +117,70 @@ public static ElectricPotentialChangeRateInfo CreateDefault(Func<IEnumerable<Uni
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricPotentialChangeRateUnit}"/> representing the default unit mappings for ElectricPotentialChangeRate.</returns>
             public static IEnumerable<UnitDefinition<ElectricPotentialChangeRateUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricPotentialChangeRateUnit.KilovoltPerHour, "KilovoltPerHour", "KilovoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, "KilovoltPerMicrosecond", "KilovoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricPotentialChangeRateUnit.KilovoltPerMinute, "KilovoltPerMinute", "KilovoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricPotentialChangeRateUnit.KilovoltPerSecond, "KilovoltPerSecond", "KilovoltsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricPotentialChangeRateUnit.MegavoltPerHour, "MegavoltPerHour", "MegavoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Microampere));
-                yield return new (ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, "MegavoltPerMicrosecond", "MegavoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Microampere));
-                yield return new (ElectricPotentialChangeRateUnit.MegavoltPerMinute, "MegavoltPerMinute", "MegavoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Microampere));
-                yield return new (ElectricPotentialChangeRateUnit.MegavoltPerSecond, "MegavoltPerSecond", "MegavoltsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere));
-                yield return new (ElectricPotentialChangeRateUnit.MicrovoltPerHour, "MicrovoltPerHour", "MicrovoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, "MicrovoltPerMicrosecond", "MicrovoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialChangeRateUnit.MicrovoltPerMinute, "MicrovoltPerMinute", "MicrovoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialChangeRateUnit.MicrovoltPerSecond, "MicrovoltPerSecond", "MicrovoltsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialChangeRateUnit.MillivoltPerHour, "MillivoltPerHour", "MillivoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, "MillivoltPerMicrosecond", "MillivoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialChangeRateUnit.MillivoltPerMinute, "MillivoltPerMinute", "MillivoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialChangeRateUnit.MillivoltPerSecond, "MillivoltPerSecond", "MillivoltsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialChangeRateUnit.VoltPerHour, "VoltPerHour", "VoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialChangeRateUnit.VoltPerMicrosecond, "VoltPerMicrosecond", "VoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricPotentialChangeRateUnit.VoltPerMinute, "VoltPerMinute", "VoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricPotentialChangeRateUnit.KilovoltPerHour, "KilovoltPerHour", "KilovoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Milliampere),
+                     new QuantityValue(18, 5)
+                );
+                yield return new (ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, "KilovoltPerMicrosecond", "KilovoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Milliampere),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricPotentialChangeRateUnit.KilovoltPerMinute, "KilovoltPerMinute", "KilovoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Milliampere),
+                     new QuantityValue(3, 50)
+                );
+                yield return new (ElectricPotentialChangeRateUnit.KilovoltPerSecond, "KilovoltPerSecond", "KilovoltsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MegavoltPerHour, "MegavoltPerHour", "MegavoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Microampere),
+                     new QuantityValue(9, 2500)
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, "MegavoltPerMicrosecond", "MegavoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Microampere),
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MegavoltPerMinute, "MegavoltPerMinute", "MegavoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Microampere),
+                     new QuantityValue(3, 50000)
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MegavoltPerSecond, "MegavoltPerSecond", "MegavoltsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MicrovoltPerHour, "MicrovoltPerHour", "MicrovoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Ampere),
+                     3600000000
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, "MicrovoltPerMicrosecond", "MicrovoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere),
+                     1
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MicrovoltPerMinute, "MicrovoltPerMinute", "MicrovoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere),
+                     60000000
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MicrovoltPerSecond, "MicrovoltPerSecond", "MicrovoltsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MillivoltPerHour, "MillivoltPerHour", "MillivoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Ampere),
+                     3600000
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, "MillivoltPerMicrosecond", "MillivoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MillivoltPerMinute, "MillivoltPerMinute", "MillivoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere),
+                     60000
+                );
+                yield return new (ElectricPotentialChangeRateUnit.MillivoltPerSecond, "MillivoltPerSecond", "MillivoltsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000
+                );
+                yield return new (ElectricPotentialChangeRateUnit.VoltPerHour, "VoltPerHour", "VoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Ampere),
+                     3600
+                );
+                yield return new (ElectricPotentialChangeRateUnit.VoltPerMicrosecond, "VoltPerMicrosecond", "VoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricPotentialChangeRateUnit.VoltPerMinute, "VoltPerMinute", "VoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere),
+                     60
+                );
                 yield return new (ElectricPotentialChangeRateUnit.VoltPerSecond, "VoltPerSecond", "VoltsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
             }
         }
 
         static ElectricPotentialChangeRate()
         {
-            Info = ElectricPotentialChangeRateInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricPotentialChangeRateInfo.CreateDefault);
         }
 
         /// <summary>
@@ -152,7 +188,7 @@ static ElectricPotentialChangeRate()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricPotentialChangeRate(double value, ElectricPotentialChangeRateUnit unit)
+        public ElectricPotentialChangeRate(QuantityValue value, ElectricPotentialChangeRateUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -166,7 +202,7 @@ public ElectricPotentialChangeRate(double value, ElectricPotentialChangeRateUnit
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricPotentialChangeRate(double value, UnitSystem unitSystem)
+        public ElectricPotentialChangeRate(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -177,7 +213,8 @@ public ElectricPotentialChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricPotentialChangeRate" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit> Info { get; }
@@ -206,10 +243,8 @@ public ElectricPotentialChangeRate(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricPotentialChangeRateUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -243,161 +278,109 @@ public ElectricPotentialChangeRate(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerHour"/>
         /// </summary>
-        public double KilovoltsPerHour => As(ElectricPotentialChangeRateUnit.KilovoltPerHour);
+        public QuantityValue KilovoltsPerHour => this.As(ElectricPotentialChangeRateUnit.KilovoltPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond"/>
         /// </summary>
-        public double KilovoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
+        public QuantityValue KilovoltsPerMicrosecond => this.As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMinute"/>
         /// </summary>
-        public double KilovoltsPerMinute => As(ElectricPotentialChangeRateUnit.KilovoltPerMinute);
+        public QuantityValue KilovoltsPerMinute => this.As(ElectricPotentialChangeRateUnit.KilovoltPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.KilovoltPerSecond"/>
         /// </summary>
-        public double KilovoltsPerSecond => As(ElectricPotentialChangeRateUnit.KilovoltPerSecond);
+        public QuantityValue KilovoltsPerSecond => this.As(ElectricPotentialChangeRateUnit.KilovoltPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerHour"/>
         /// </summary>
-        public double MegavoltsPerHour => As(ElectricPotentialChangeRateUnit.MegavoltPerHour);
+        public QuantityValue MegavoltsPerHour => this.As(ElectricPotentialChangeRateUnit.MegavoltPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond"/>
         /// </summary>
-        public double MegavoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
+        public QuantityValue MegavoltsPerMicrosecond => this.As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMinute"/>
         /// </summary>
-        public double MegavoltsPerMinute => As(ElectricPotentialChangeRateUnit.MegavoltPerMinute);
+        public QuantityValue MegavoltsPerMinute => this.As(ElectricPotentialChangeRateUnit.MegavoltPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MegavoltPerSecond"/>
         /// </summary>
-        public double MegavoltsPerSecond => As(ElectricPotentialChangeRateUnit.MegavoltPerSecond);
+        public QuantityValue MegavoltsPerSecond => this.As(ElectricPotentialChangeRateUnit.MegavoltPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerHour"/>
         /// </summary>
-        public double MicrovoltsPerHour => As(ElectricPotentialChangeRateUnit.MicrovoltPerHour);
+        public QuantityValue MicrovoltsPerHour => this.As(ElectricPotentialChangeRateUnit.MicrovoltPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond"/>
         /// </summary>
-        public double MicrovoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
+        public QuantityValue MicrovoltsPerMicrosecond => this.As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMinute"/>
         /// </summary>
-        public double MicrovoltsPerMinute => As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
+        public QuantityValue MicrovoltsPerMinute => this.As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerSecond"/>
         /// </summary>
-        public double MicrovoltsPerSecond => As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
+        public QuantityValue MicrovoltsPerSecond => this.As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerHour"/>
         /// </summary>
-        public double MillivoltsPerHour => As(ElectricPotentialChangeRateUnit.MillivoltPerHour);
+        public QuantityValue MillivoltsPerHour => this.As(ElectricPotentialChangeRateUnit.MillivoltPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond"/>
         /// </summary>
-        public double MillivoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
+        public QuantityValue MillivoltsPerMicrosecond => this.As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMinute"/>
         /// </summary>
-        public double MillivoltsPerMinute => As(ElectricPotentialChangeRateUnit.MillivoltPerMinute);
+        public QuantityValue MillivoltsPerMinute => this.As(ElectricPotentialChangeRateUnit.MillivoltPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.MillivoltPerSecond"/>
         /// </summary>
-        public double MillivoltsPerSecond => As(ElectricPotentialChangeRateUnit.MillivoltPerSecond);
+        public QuantityValue MillivoltsPerSecond => this.As(ElectricPotentialChangeRateUnit.MillivoltPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerHour"/>
         /// </summary>
-        public double VoltsPerHour => As(ElectricPotentialChangeRateUnit.VoltPerHour);
+        public QuantityValue VoltsPerHour => this.As(ElectricPotentialChangeRateUnit.VoltPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerMicrosecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerMicrosecond"/>
         /// </summary>
-        public double VoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
+        public QuantityValue VoltsPerMicrosecond => this.As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerMinute"/>
         /// </summary>
-        public double VoltsPerMinute => As(ElectricPotentialChangeRateUnit.VoltPerMinute);
+        public QuantityValue VoltsPerMinute => this.As(ElectricPotentialChangeRateUnit.VoltPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricPotentialChangeRateUnit.VoltPerSecond"/>
         /// </summary>
-        public double VoltsPerSecond => As(ElectricPotentialChangeRateUnit.VoltPerSecond);
+        public QuantityValue VoltsPerSecond => this.As(ElectricPotentialChangeRateUnit.VoltPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricPotentialChangeRateUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.KilovoltPerHour, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.KilovoltPerMinute, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.KilovoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MegavoltPerHour, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MegavoltPerMinute, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MegavoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MicrovoltPerHour, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MicrovoltPerMinute, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MicrovoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MillivoltPerHour, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MillivoltPerMinute, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.MillivoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerHour, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerMicrosecond, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerMinute, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricPotentialChangeRateUnit
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.KilovoltPerHour, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerHour));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.KilovoltPerMinute, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerMinute));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.KilovoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.KilovoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MegavoltPerHour, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerHour));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MegavoltPerMinute, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerMinute));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MegavoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MegavoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MicrovoltPerHour, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerHour));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MicrovoltPerMinute, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerMinute));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MicrovoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MicrovoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MillivoltPerHour, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerHour));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MillivoltPerMinute, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerMinute));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MillivoltPerSecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.MillivoltPerSecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerHour, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerHour));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerMicrosecond, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerMicrosecond));
-            unitConverter.SetConversionFunction<ElectricPotentialChangeRate>(ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerMinute, quantity => quantity.ToUnit(ElectricPotentialChangeRateUnit.VoltPerMinute));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -426,7 +409,7 @@ public static string GetAbbreviation(ElectricPotentialChangeRateUnit unit, IForm
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerHour"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromKilovoltsPerHour(double value)
+        public static ElectricPotentialChangeRate FromKilovoltsPerHour(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerHour);
         }
@@ -434,7 +417,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromKilovoltsPerMicrosecond(double value)
+        public static ElectricPotentialChangeRate FromKilovoltsPerMicrosecond(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
         }
@@ -442,7 +425,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMicrosecond(double val
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMinute"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromKilovoltsPerMinute(double value)
+        public static ElectricPotentialChangeRate FromKilovoltsPerMinute(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMinute);
         }
@@ -450,7 +433,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerSecond"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromKilovoltsPerSecond(double value)
+        public static ElectricPotentialChangeRate FromKilovoltsPerSecond(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerSecond);
         }
@@ -458,7 +441,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerHour"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMegavoltsPerHour(double value)
+        public static ElectricPotentialChangeRate FromMegavoltsPerHour(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerHour);
         }
@@ -466,7 +449,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMegavoltsPerMicrosecond(double value)
+        public static ElectricPotentialChangeRate FromMegavoltsPerMicrosecond(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
         }
@@ -474,7 +457,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMicrosecond(double val
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMinute"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMegavoltsPerMinute(double value)
+        public static ElectricPotentialChangeRate FromMegavoltsPerMinute(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMinute);
         }
@@ -482,7 +465,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerSecond"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMegavoltsPerSecond(double value)
+        public static ElectricPotentialChangeRate FromMegavoltsPerSecond(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerSecond);
         }
@@ -490,7 +473,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerHour"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerHour(double value)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerHour(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerHour);
         }
@@ -498,7 +481,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerMicrosecond(double value)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerMicrosecond(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
         }
@@ -506,7 +489,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMicrosecond(double va
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMinute"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerMinute(double value)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerMinute(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
         }
@@ -514,7 +497,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerSecond"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerSecond(double value)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerSecond(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
         }
@@ -522,7 +505,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerHour"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMillivoltsPerHour(double value)
+        public static ElectricPotentialChangeRate FromMillivoltsPerHour(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerHour);
         }
@@ -530,7 +513,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMillivoltsPerMicrosecond(double value)
+        public static ElectricPotentialChangeRate FromMillivoltsPerMicrosecond(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
         }
@@ -538,7 +521,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMicrosecond(double va
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMinute"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMillivoltsPerMinute(double value)
+        public static ElectricPotentialChangeRate FromMillivoltsPerMinute(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMinute);
         }
@@ -546,7 +529,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerSecond"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromMillivoltsPerSecond(double value)
+        public static ElectricPotentialChangeRate FromMillivoltsPerSecond(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerSecond);
         }
@@ -554,7 +537,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerHour"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromVoltsPerHour(double value)
+        public static ElectricPotentialChangeRate FromVoltsPerHour(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerHour);
         }
@@ -562,7 +545,7 @@ public static ElectricPotentialChangeRate FromVoltsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerMicrosecond"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromVoltsPerMicrosecond(double value)
+        public static ElectricPotentialChangeRate FromVoltsPerMicrosecond(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
         }
@@ -570,7 +553,7 @@ public static ElectricPotentialChangeRate FromVoltsPerMicrosecond(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerMinute"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromVoltsPerMinute(double value)
+        public static ElectricPotentialChangeRate FromVoltsPerMinute(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMinute);
         }
@@ -578,7 +561,7 @@ public static ElectricPotentialChangeRate FromVoltsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerSecond"/>.
         /// </summary>
-        public static ElectricPotentialChangeRate FromVoltsPerSecond(double value)
+        public static ElectricPotentialChangeRate FromVoltsPerSecond(QuantityValue value)
         {
             return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerSecond);
         }
@@ -589,7 +572,7 @@ public static ElectricPotentialChangeRate FromVoltsPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricPotentialChangeRate unit value.</returns>
-        public static ElectricPotentialChangeRate From(double value, ElectricPotentialChangeRateUnit fromUnit)
+        public static ElectricPotentialChangeRate From(QuantityValue value, ElectricPotentialChangeRateUnit fromUnit)
         {
             return new ElectricPotentialChangeRate(value, fromUnit);
         }
@@ -650,10 +633,7 @@ public static ElectricPotentialChangeRate Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricPotentialChangeRate Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -681,11 +661,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricPotentia
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricPotentialChangeRate result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -706,7 +682,7 @@ public static ElectricPotentialChangeRateUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -717,7 +693,7 @@ public static ElectricPotentialChangeRateUnit ParseUnit(string str, IFormatProvi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricPotentialChangeRateUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricPotentialChangeRateUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricPotentialChangeRateUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -732,7 +708,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricPote
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricPotentialChangeRateUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -751,137 +727,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from adding two <see cref="ElectricPotentialChangeRate"/>.</summary>
         public static ElectricPotentialChangeRate operator +(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
         {
-            return new ElectricPotentialChangeRate(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricPotentialChangeRate(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from subtracting two <see cref="ElectricPotentialChangeRate"/>.</summary>
         public static ElectricPotentialChangeRate operator -(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
         {
-            return new ElectricPotentialChangeRate(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricPotentialChangeRate(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from multiplying value and <see cref="ElectricPotentialChangeRate"/>.</summary>
-        public static ElectricPotentialChangeRate operator *(double left, ElectricPotentialChangeRate right)
+        public static ElectricPotentialChangeRate operator *(QuantityValue left, ElectricPotentialChangeRate right)
         {
             return new ElectricPotentialChangeRate(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from multiplying value and <see cref="ElectricPotentialChangeRate"/>.</summary>
-        public static ElectricPotentialChangeRate operator *(ElectricPotentialChangeRate left, double right)
+        public static ElectricPotentialChangeRate operator *(ElectricPotentialChangeRate left, QuantityValue right)
         {
             return new ElectricPotentialChangeRate(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricPotentialChangeRate"/> from dividing <see cref="ElectricPotentialChangeRate"/> by value.</summary>
-        public static ElectricPotentialChangeRate operator /(ElectricPotentialChangeRate left, double right)
+        public static ElectricPotentialChangeRate operator /(ElectricPotentialChangeRate left, QuantityValue right)
         {
             return new ElectricPotentialChangeRate(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricPotentialChangeRate"/> by <see cref="ElectricPotentialChangeRate"/>.</summary>
-        public static double operator /(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
+        public static QuantityValue operator /(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
         {
             return left.VoltsPerSecond / right.VoltsPerSecond;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="ElectricPotential"/> from <see cref="ElectricPotentialChangeRate"/> * <see cref="Duration"/>.</summary>
+        public static ElectricPotential operator *(ElectricPotentialChangeRate electricPotentialChangeRate, Duration duration)
+        {
+            return ElectricPotential.FromVolts(electricPotentialChangeRate.VoltsPerSecond * duration.Seconds);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricPotentialChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricPotentialChangeRate other, ElectricPotentialChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricPotentialChangeRate"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricPotentialChangeRate)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricPotentialChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricPotentialChangeRate other, ElectricPotentialChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricPotentialChangeRate"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricPotentialChangeRate,ElectricPotentialChangeRate)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricPotentialChangeRate)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricPotentialChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricPotentialChangeRate other, ElectricPotentialChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricPotentialChangeRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricPotentialChangeRate"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricPotentialChangeRate"/>, this method delegates to
+        ///     <see cref="Equals(ElectricPotentialChangeRate)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricPotentialChangeRate otherQuantity))
+            if (obj is not ElectricPotentialChangeRate otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricPotentialChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricPotentialChangeRate other, ElectricPotentialChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricPotentialChangeRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricPotentialChangeRate other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricPotentialChangeRate.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricPotentialChangeRate), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricPotentialChangeRate"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricPotentialChangeRate)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricPotentialChangeRate otherQuantity)) throw new ArgumentException("Expected type ElectricPotentialChangeRate.", nameof(obj));
+            if (obj is not ElectricPotentialChangeRate otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricPotentialChangeRate>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricPotentialChangeRate"/> with another <see cref="ElectricPotentialChangeRate"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricPotentialChangeRate"/> with another <see cref="ElectricPotentialChangeRate"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -893,167 +893,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricPotentialChangeRate other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricPotentialChangeRateUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricPotentialChangeRateUnit>());
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this ElectricPotentialChangeRate to another ElectricPotentialChangeRate with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricPotentialChangeRate with the specified unit.</returns>
-        public ElectricPotentialChangeRate ToUnit(ElectricPotentialChangeRateUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricPotentialChangeRate"/> to another <see cref="ElectricPotentialChangeRate"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricPotentialChangeRate with the specified unit.</returns>
-        public ElectricPotentialChangeRate ToUnit(ElectricPotentialChangeRateUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricPotentialChangeRate), Unit, typeof(ElectricPotentialChangeRate), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricPotentialChangeRate)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricPotentialChangeRate"/> to another <see cref="ElectricPotentialChangeRate"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricPotentialChangeRate"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricPotentialChangeRateUnit unit, [NotNullWhen(true)] out ElectricPotentialChangeRate? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricPotentialChangeRate? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricPotentialChangeRateUnit -> BaseUnit
-                (ElectricPotentialChangeRateUnit.KilovoltPerHour, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value / 3600) * 1e3d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value * 1E6) * 1e3d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.KilovoltPerMinute, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value / 60) * 1e3d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.KilovoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value) * 1e3d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MegavoltPerHour, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value / 3600) * 1e6d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value * 1E6) * 1e6d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MegavoltPerMinute, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value / 60) * 1e6d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MegavoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value) * 1e6d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MicrovoltPerHour, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value / 3600) * 1e-6d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value * 1E6) * 1e-6d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MicrovoltPerMinute, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value / 60) * 1e-6d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MicrovoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value) * 1e-6d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MillivoltPerHour, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value / 3600) * 1e-3d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value * 1E6) * 1e-3d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MillivoltPerMinute, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value / 60) * 1e-3d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.MillivoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate((_value) * 1e-3d, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.VoltPerHour, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate(_value / 3600, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.VoltPerMicrosecond, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate(_value * 1E6, ElectricPotentialChangeRateUnit.VoltPerSecond),
-                (ElectricPotentialChangeRateUnit.VoltPerMinute, ElectricPotentialChangeRateUnit.VoltPerSecond) => new ElectricPotentialChangeRate(_value / 60, ElectricPotentialChangeRateUnit.VoltPerSecond),
-
-                // BaseUnit -> ElectricPotentialChangeRateUnit
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.KilovoltPerHour) => new ElectricPotentialChangeRate((_value * 3600) / 1e3d, ElectricPotentialChangeRateUnit.KilovoltPerHour),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond) => new ElectricPotentialChangeRate((_value / 1E6) / 1e3d, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.KilovoltPerMinute) => new ElectricPotentialChangeRate((_value * 60) / 1e3d, ElectricPotentialChangeRateUnit.KilovoltPerMinute),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.KilovoltPerSecond) => new ElectricPotentialChangeRate((_value) / 1e3d, ElectricPotentialChangeRateUnit.KilovoltPerSecond),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MegavoltPerHour) => new ElectricPotentialChangeRate((_value * 3600) / 1e6d, ElectricPotentialChangeRateUnit.MegavoltPerHour),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond) => new ElectricPotentialChangeRate((_value / 1E6) / 1e6d, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MegavoltPerMinute) => new ElectricPotentialChangeRate((_value * 60) / 1e6d, ElectricPotentialChangeRateUnit.MegavoltPerMinute),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MegavoltPerSecond) => new ElectricPotentialChangeRate((_value) / 1e6d, ElectricPotentialChangeRateUnit.MegavoltPerSecond),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MicrovoltPerHour) => new ElectricPotentialChangeRate((_value * 3600) / 1e-6d, ElectricPotentialChangeRateUnit.MicrovoltPerHour),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond) => new ElectricPotentialChangeRate((_value / 1E6) / 1e-6d, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MicrovoltPerMinute) => new ElectricPotentialChangeRate((_value * 60) / 1e-6d, ElectricPotentialChangeRateUnit.MicrovoltPerMinute),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MicrovoltPerSecond) => new ElectricPotentialChangeRate((_value) / 1e-6d, ElectricPotentialChangeRateUnit.MicrovoltPerSecond),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MillivoltPerHour) => new ElectricPotentialChangeRate((_value * 3600) / 1e-3d, ElectricPotentialChangeRateUnit.MillivoltPerHour),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond) => new ElectricPotentialChangeRate((_value / 1E6) / 1e-3d, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MillivoltPerMinute) => new ElectricPotentialChangeRate((_value * 60) / 1e-3d, ElectricPotentialChangeRateUnit.MillivoltPerMinute),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.MillivoltPerSecond) => new ElectricPotentialChangeRate((_value) / 1e-3d, ElectricPotentialChangeRateUnit.MillivoltPerSecond),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerHour) => new ElectricPotentialChangeRate(_value * 3600, ElectricPotentialChangeRateUnit.VoltPerHour),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerMicrosecond) => new ElectricPotentialChangeRate(_value / 1E6, ElectricPotentialChangeRateUnit.VoltPerMicrosecond),
-                (ElectricPotentialChangeRateUnit.VoltPerSecond, ElectricPotentialChangeRateUnit.VoltPerMinute) => new ElectricPotentialChangeRate(_value * 60, ElectricPotentialChangeRateUnit.VoltPerMinute),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricPotentialChangeRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialChangeRateUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricPotentialChangeRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialChangeRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricPotentialChangeRateUnit> IQuantity<ElectricPotentialChangeRateUnit>.ToUnit(ElectricPotentialChangeRateUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1067,11 +909,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricReactance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricReactance.g.cs
index 0876ea916a..3559d695f0 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricReactance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricReactance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Electrical_reactance
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricReactance :
-        IArithmeticQuantity<ElectricReactance, ElectricReactanceUnit>,
+        ILinearQuantity<ElectricReactance, ElectricReactanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricReactance, ElectricReactance, double>,
+        IDivisionOperators<ElectricReactance, ElectricReactance, QuantityValue>,
         IComparisonOperators<ElectricReactance, ElectricReactance, bool>,
         IParsable<ElectricReactance>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static ElectricReactanceInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricReactance"/> is [T^-3][L^2][M][I^-2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricReactance"/> is T^-3L^2MI^-2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -3, -2, 0, 0, 0);
 
@@ -120,22 +119,34 @@ public static ElectricReactanceInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricReactanceUnit}"/> representing the default unit mappings for ElectricReactance.</returns>
             public static IEnumerable<UnitDefinition<ElectricReactanceUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricReactanceUnit.Gigaohm, "Gigaohm", "Gigaohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricReactanceUnit.Kiloohm, "Kiloohm", "Kiloohms", BaseUnits.Undefined);
-                yield return new (ElectricReactanceUnit.Megaohm, "Megaohm", "Megaohms", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricReactanceUnit.Microohm, "Microohm", "Microohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricReactanceUnit.Milliohm, "Milliohm", "Milliohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricReactanceUnit.Nanoohm, "Nanoohm", "Nanoohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricReactanceUnit.Gigaohm, "Gigaohm", "Gigaohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricReactanceUnit.Kiloohm, "Kiloohm", "Kiloohms", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricReactanceUnit.Megaohm, "Megaohm", "Megaohms", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricReactanceUnit.Microohm, "Microohm", "Microohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000
+                );
+                yield return new (ElectricReactanceUnit.Milliohm, "Milliohm", "Milliohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000
+                );
+                yield return new (ElectricReactanceUnit.Nanoohm, "Nanoohm", "Nanoohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000000
+                );
                 yield return new (ElectricReactanceUnit.Ohm, "Ohm", "Ohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricReactanceUnit.Teraohm, "Teraohm", "Teraohms", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricReactanceUnit.Teraohm, "Teraohm", "Teraohms", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000000)
+                );
             }
         }
 
         static ElectricReactance()
         {
-            Info = ElectricReactanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricReactanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -143,7 +154,7 @@ static ElectricReactance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricReactance(double value, ElectricReactanceUnit unit)
+        public ElectricReactance(QuantityValue value, ElectricReactanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -157,7 +168,7 @@ public ElectricReactance(double value, ElectricReactanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricReactance(double value, UnitSystem unitSystem)
+        public ElectricReactance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -168,7 +179,8 @@ public ElectricReactance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricReactance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricReactance, ElectricReactanceUnit> Info { get; }
@@ -197,10 +209,8 @@ public ElectricReactance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricReactanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -234,77 +244,49 @@ public ElectricReactance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Gigaohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Gigaohm"/>
         /// </summary>
-        public double Gigaohms => As(ElectricReactanceUnit.Gigaohm);
+        public QuantityValue Gigaohms => this.As(ElectricReactanceUnit.Gigaohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Kiloohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Kiloohm"/>
         /// </summary>
-        public double Kiloohms => As(ElectricReactanceUnit.Kiloohm);
+        public QuantityValue Kiloohms => this.As(ElectricReactanceUnit.Kiloohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Megaohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Megaohm"/>
         /// </summary>
-        public double Megaohms => As(ElectricReactanceUnit.Megaohm);
+        public QuantityValue Megaohms => this.As(ElectricReactanceUnit.Megaohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Microohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Microohm"/>
         /// </summary>
-        public double Microohms => As(ElectricReactanceUnit.Microohm);
+        public QuantityValue Microohms => this.As(ElectricReactanceUnit.Microohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Milliohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Milliohm"/>
         /// </summary>
-        public double Milliohms => As(ElectricReactanceUnit.Milliohm);
+        public QuantityValue Milliohms => this.As(ElectricReactanceUnit.Milliohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Nanoohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Nanoohm"/>
         /// </summary>
-        public double Nanoohms => As(ElectricReactanceUnit.Nanoohm);
+        public QuantityValue Nanoohms => this.As(ElectricReactanceUnit.Nanoohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Ohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Ohm"/>
         /// </summary>
-        public double Ohms => As(ElectricReactanceUnit.Ohm);
+        public QuantityValue Ohms => this.As(ElectricReactanceUnit.Ohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Teraohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactanceUnit.Teraohm"/>
         /// </summary>
-        public double Teraohms => As(ElectricReactanceUnit.Teraohm);
+        public QuantityValue Teraohms => this.As(ElectricReactanceUnit.Teraohm);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricReactanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Gigaohm, ElectricReactanceUnit.Ohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Kiloohm, ElectricReactanceUnit.Ohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Megaohm, ElectricReactanceUnit.Ohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Microohm, ElectricReactanceUnit.Ohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Milliohm, ElectricReactanceUnit.Ohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Nanoohm, ElectricReactanceUnit.Ohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Teraohm, ElectricReactanceUnit.Ohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Ohm));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Ohm, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricReactanceUnit
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Gigaohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Gigaohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Kiloohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Kiloohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Megaohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Megaohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Microohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Microohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Milliohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Milliohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Nanoohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Nanoohm));
-            unitConverter.SetConversionFunction<ElectricReactance>(ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Teraohm, quantity => quantity.ToUnit(ElectricReactanceUnit.Teraohm));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -333,7 +315,7 @@ public static string GetAbbreviation(ElectricReactanceUnit unit, IFormatProvider
         /// <summary>
         ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Gigaohm"/>.
         /// </summary>
-        public static ElectricReactance FromGigaohms(double value)
+        public static ElectricReactance FromGigaohms(QuantityValue value)
         {
             return new ElectricReactance(value, ElectricReactanceUnit.Gigaohm);
         }
@@ -341,7 +323,7 @@ public static ElectricReactance FromGigaohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Kiloohm"/>.
         /// </summary>
-        public static ElectricReactance FromKiloohms(double value)
+        public static ElectricReactance FromKiloohms(QuantityValue value)
         {
             return new ElectricReactance(value, ElectricReactanceUnit.Kiloohm);
         }
@@ -349,7 +331,7 @@ public static ElectricReactance FromKiloohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Megaohm"/>.
         /// </summary>
-        public static ElectricReactance FromMegaohms(double value)
+        public static ElectricReactance FromMegaohms(QuantityValue value)
         {
             return new ElectricReactance(value, ElectricReactanceUnit.Megaohm);
         }
@@ -357,7 +339,7 @@ public static ElectricReactance FromMegaohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Microohm"/>.
         /// </summary>
-        public static ElectricReactance FromMicroohms(double value)
+        public static ElectricReactance FromMicroohms(QuantityValue value)
         {
             return new ElectricReactance(value, ElectricReactanceUnit.Microohm);
         }
@@ -365,7 +347,7 @@ public static ElectricReactance FromMicroohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Milliohm"/>.
         /// </summary>
-        public static ElectricReactance FromMilliohms(double value)
+        public static ElectricReactance FromMilliohms(QuantityValue value)
         {
             return new ElectricReactance(value, ElectricReactanceUnit.Milliohm);
         }
@@ -373,7 +355,7 @@ public static ElectricReactance FromMilliohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Nanoohm"/>.
         /// </summary>
-        public static ElectricReactance FromNanoohms(double value)
+        public static ElectricReactance FromNanoohms(QuantityValue value)
         {
             return new ElectricReactance(value, ElectricReactanceUnit.Nanoohm);
         }
@@ -381,7 +363,7 @@ public static ElectricReactance FromNanoohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Ohm"/>.
         /// </summary>
-        public static ElectricReactance FromOhms(double value)
+        public static ElectricReactance FromOhms(QuantityValue value)
         {
             return new ElectricReactance(value, ElectricReactanceUnit.Ohm);
         }
@@ -389,7 +371,7 @@ public static ElectricReactance FromOhms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricReactance"/> from <see cref="ElectricReactanceUnit.Teraohm"/>.
         /// </summary>
-        public static ElectricReactance FromTeraohms(double value)
+        public static ElectricReactance FromTeraohms(QuantityValue value)
         {
             return new ElectricReactance(value, ElectricReactanceUnit.Teraohm);
         }
@@ -400,7 +382,7 @@ public static ElectricReactance FromTeraohms(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricReactance unit value.</returns>
-        public static ElectricReactance From(double value, ElectricReactanceUnit fromUnit)
+        public static ElectricReactance From(QuantityValue value, ElectricReactanceUnit fromUnit)
         {
             return new ElectricReactance(value, fromUnit);
         }
@@ -461,10 +443,7 @@ public static ElectricReactance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricReactance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricReactance, ElectricReactanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricReactance, ElectricReactanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -492,11 +471,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricReactanc
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricReactance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricReactance, ElectricReactanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricReactance, ElectricReactanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -517,7 +492,7 @@ public static ElectricReactanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -528,7 +503,7 @@ public static ElectricReactanceUnit ParseUnit(string str, IFormatProvider? provi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricReactanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricReactanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricReactanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -543,7 +518,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricReac
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricReactanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -562,35 +537,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricReactance"/> from adding two <see cref="ElectricReactance"/>.</summary>
         public static ElectricReactance operator +(ElectricReactance left, ElectricReactance right)
         {
-            return new ElectricReactance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricReactance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactance"/> from subtracting two <see cref="ElectricReactance"/>.</summary>
         public static ElectricReactance operator -(ElectricReactance left, ElectricReactance right)
         {
-            return new ElectricReactance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricReactance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactance"/> from multiplying value and <see cref="ElectricReactance"/>.</summary>
-        public static ElectricReactance operator *(double left, ElectricReactance right)
+        public static ElectricReactance operator *(QuantityValue left, ElectricReactance right)
         {
             return new ElectricReactance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactance"/> from multiplying value and <see cref="ElectricReactance"/>.</summary>
-        public static ElectricReactance operator *(ElectricReactance left, double right)
+        public static ElectricReactance operator *(ElectricReactance left, QuantityValue right)
         {
             return new ElectricReactance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactance"/> from dividing <see cref="ElectricReactance"/> by value.</summary>
-        public static ElectricReactance operator /(ElectricReactance left, double right)
+        public static ElectricReactance operator /(ElectricReactance left, QuantityValue right)
         {
             return new ElectricReactance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricReactance"/> by <see cref="ElectricReactance"/>.</summary>
-        public static double operator /(ElectricReactance left, ElectricReactance right)
+        public static QuantityValue operator /(ElectricReactance left, ElectricReactance right)
         {
             return left.Ohms / right.Ohms;
         }
@@ -602,97 +577,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricReactance left, ElectricReactance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricReactance left, ElectricReactance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricReactance left, ElectricReactance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricReactance left, ElectricReactance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricReactance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricReactance other, ElectricReactance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricReactance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricReactance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricReactance left, ElectricReactance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricReactance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricReactance other, ElectricReactance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricReactance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricReactance,ElectricReactance)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricReactance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricReactance left, ElectricReactance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricReactance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricReactance other, ElectricReactance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricReactance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricReactance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricReactance"/>, this method delegates to
+        ///     <see cref="Equals(ElectricReactance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricReactance otherQuantity))
+            if (obj is not ElectricReactance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricReactance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricReactance other, ElectricReactance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricReactance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricReactance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricReactance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricReactance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricReactance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricReactance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricReactance otherQuantity)) throw new ArgumentException("Expected type ElectricReactance.", nameof(obj));
+            if (obj is not ElectricReactance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricReactance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricReactance"/> with another <see cref="ElectricReactance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricReactance"/> with another <see cref="ElectricReactance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -704,143 +693,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricReactance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricReactanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricReactanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricReactance to another ElectricReactance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricReactance with the specified unit.</returns>
-        public ElectricReactance ToUnit(ElectricReactanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="ElectricReactance"/> to another <see cref="ElectricReactance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricReactance with the specified unit.</returns>
-        public ElectricReactance ToUnit(ElectricReactanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricReactance), Unit, typeof(ElectricReactance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricReactance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricReactance"/> to another <see cref="ElectricReactance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricReactance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricReactanceUnit unit, [NotNullWhen(true)] out ElectricReactance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricReactance? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricReactanceUnit -> BaseUnit
-                (ElectricReactanceUnit.Gigaohm, ElectricReactanceUnit.Ohm) => new ElectricReactance((_value) * 1e9d, ElectricReactanceUnit.Ohm),
-                (ElectricReactanceUnit.Kiloohm, ElectricReactanceUnit.Ohm) => new ElectricReactance((_value) * 1e3d, ElectricReactanceUnit.Ohm),
-                (ElectricReactanceUnit.Megaohm, ElectricReactanceUnit.Ohm) => new ElectricReactance((_value) * 1e6d, ElectricReactanceUnit.Ohm),
-                (ElectricReactanceUnit.Microohm, ElectricReactanceUnit.Ohm) => new ElectricReactance((_value) * 1e-6d, ElectricReactanceUnit.Ohm),
-                (ElectricReactanceUnit.Milliohm, ElectricReactanceUnit.Ohm) => new ElectricReactance((_value) * 1e-3d, ElectricReactanceUnit.Ohm),
-                (ElectricReactanceUnit.Nanoohm, ElectricReactanceUnit.Ohm) => new ElectricReactance((_value) * 1e-9d, ElectricReactanceUnit.Ohm),
-                (ElectricReactanceUnit.Teraohm, ElectricReactanceUnit.Ohm) => new ElectricReactance((_value) * 1e12d, ElectricReactanceUnit.Ohm),
-
-                // BaseUnit -> ElectricReactanceUnit
-                (ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Gigaohm) => new ElectricReactance((_value) / 1e9d, ElectricReactanceUnit.Gigaohm),
-                (ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Kiloohm) => new ElectricReactance((_value) / 1e3d, ElectricReactanceUnit.Kiloohm),
-                (ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Megaohm) => new ElectricReactance((_value) / 1e6d, ElectricReactanceUnit.Megaohm),
-                (ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Microohm) => new ElectricReactance((_value) / 1e-6d, ElectricReactanceUnit.Microohm),
-                (ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Milliohm) => new ElectricReactance((_value) / 1e-3d, ElectricReactanceUnit.Milliohm),
-                (ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Nanoohm) => new ElectricReactance((_value) / 1e-9d, ElectricReactanceUnit.Nanoohm),
-                (ElectricReactanceUnit.Ohm, ElectricReactanceUnit.Teraohm) => new ElectricReactance((_value) / 1e12d, ElectricReactanceUnit.Teraohm),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricReactanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricReactanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricReactanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricReactanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricReactanceUnit> IQuantity<ElectricReactanceUnit>.ToUnit(ElectricReactanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -854,11 +709,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs
index dde516150d..23a644d3f1 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricReactiveEnergy.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,14 @@ namespace UnitsNet
     ///     The volt-ampere reactive hour (expressed as varh) is the reactive power of one Volt-ampere reactive produced in one hour.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricReactiveEnergy :
-        IArithmeticQuantity<ElectricReactiveEnergy, ElectricReactiveEnergyUnit>,
+        ILinearQuantity<ElectricReactiveEnergy, ElectricReactiveEnergyUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricReactiveEnergy, ElectricReactiveEnergy, double>,
+        IDivisionOperators<ElectricReactiveEnergy, ElectricReactiveEnergy, QuantityValue>,
+        IDivisionOperators<ElectricReactiveEnergy, ElectricReactivePower, Duration>,
+        IDivisionOperators<ElectricReactiveEnergy, Duration, ElectricReactivePower>,
         IComparisonOperators<ElectricReactiveEnergy, ElectricReactiveEnergy, bool>,
         IParsable<ElectricReactiveEnergy>,
 #endif
@@ -52,7 +53,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +103,7 @@ public static ElectricReactiveEnergyInfo CreateDefault(Func<IEnumerable<UnitDefi
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricReactiveEnergy"/> is [T^-2][L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricReactiveEnergy"/> is T^-2L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
 
@@ -117,17 +118,19 @@ public static ElectricReactiveEnergyInfo CreateDefault(Func<IEnumerable<UnitDefi
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricReactiveEnergyUnit}"/> representing the default unit mappings for ElectricReactiveEnergy.</returns>
             public static IEnumerable<UnitDefinition<ElectricReactiveEnergyUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricReactiveEnergyUnit.KilovoltampereReactiveHour, "KilovoltampereReactiveHour", "KilovoltampereReactiveHours", BaseUnits.Undefined);
-                yield return new (ElectricReactiveEnergyUnit.MegavoltampereReactiveHour, "MegavoltampereReactiveHour", "MegavoltampereReactiveHours", BaseUnits.Undefined);
+                yield return new (ElectricReactiveEnergyUnit.KilovoltampereReactiveHour, "KilovoltampereReactiveHour", "KilovoltampereReactiveHours", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricReactiveEnergyUnit.MegavoltampereReactiveHour, "MegavoltampereReactiveHour", "MegavoltampereReactiveHours", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
                 yield return new (ElectricReactiveEnergyUnit.VoltampereReactiveHour, "VoltampereReactiveHour", "VoltampereReactiveHours", BaseUnits.Undefined);
             }
         }
 
         static ElectricReactiveEnergy()
         {
-            Info = ElectricReactiveEnergyInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricReactiveEnergyInfo.CreateDefault);
         }
 
         /// <summary>
@@ -135,7 +138,7 @@ static ElectricReactiveEnergy()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricReactiveEnergy(double value, ElectricReactiveEnergyUnit unit)
+        public ElectricReactiveEnergy(QuantityValue value, ElectricReactiveEnergyUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -149,7 +152,7 @@ public ElectricReactiveEnergy(double value, ElectricReactiveEnergyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricReactiveEnergy(double value, UnitSystem unitSystem)
+        public ElectricReactiveEnergy(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -160,7 +163,8 @@ public ElectricReactiveEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricReactiveEnergy" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricReactiveEnergy, ElectricReactiveEnergyUnit> Info { get; }
@@ -189,10 +193,8 @@ public ElectricReactiveEnergy(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricReactiveEnergyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -226,42 +228,24 @@ public ElectricReactiveEnergy(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactiveEnergyUnit.KilovoltampereReactiveHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactiveEnergyUnit.KilovoltampereReactiveHour"/>
         /// </summary>
-        public double KilovoltampereReactiveHours => As(ElectricReactiveEnergyUnit.KilovoltampereReactiveHour);
+        public QuantityValue KilovoltampereReactiveHours => this.As(ElectricReactiveEnergyUnit.KilovoltampereReactiveHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactiveEnergyUnit.MegavoltampereReactiveHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactiveEnergyUnit.MegavoltampereReactiveHour"/>
         /// </summary>
-        public double MegavoltampereReactiveHours => As(ElectricReactiveEnergyUnit.MegavoltampereReactiveHour);
+        public QuantityValue MegavoltampereReactiveHours => this.As(ElectricReactiveEnergyUnit.MegavoltampereReactiveHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactiveEnergyUnit.VoltampereReactiveHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactiveEnergyUnit.VoltampereReactiveHour"/>
         /// </summary>
-        public double VoltampereReactiveHours => As(ElectricReactiveEnergyUnit.VoltampereReactiveHour);
+        public QuantityValue VoltampereReactiveHours => this.As(ElectricReactiveEnergyUnit.VoltampereReactiveHour);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricReactiveEnergyUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricReactiveEnergy>(ElectricReactiveEnergyUnit.KilovoltampereReactiveHour, ElectricReactiveEnergyUnit.VoltampereReactiveHour, quantity => quantity.ToUnit(ElectricReactiveEnergyUnit.VoltampereReactiveHour));
-            unitConverter.SetConversionFunction<ElectricReactiveEnergy>(ElectricReactiveEnergyUnit.MegavoltampereReactiveHour, ElectricReactiveEnergyUnit.VoltampereReactiveHour, quantity => quantity.ToUnit(ElectricReactiveEnergyUnit.VoltampereReactiveHour));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricReactiveEnergy>(ElectricReactiveEnergyUnit.VoltampereReactiveHour, ElectricReactiveEnergyUnit.VoltampereReactiveHour, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricReactiveEnergyUnit
-            unitConverter.SetConversionFunction<ElectricReactiveEnergy>(ElectricReactiveEnergyUnit.VoltampereReactiveHour, ElectricReactiveEnergyUnit.KilovoltampereReactiveHour, quantity => quantity.ToUnit(ElectricReactiveEnergyUnit.KilovoltampereReactiveHour));
-            unitConverter.SetConversionFunction<ElectricReactiveEnergy>(ElectricReactiveEnergyUnit.VoltampereReactiveHour, ElectricReactiveEnergyUnit.MegavoltampereReactiveHour, quantity => quantity.ToUnit(ElectricReactiveEnergyUnit.MegavoltampereReactiveHour));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -290,7 +274,7 @@ public static string GetAbbreviation(ElectricReactiveEnergyUnit unit, IFormatPro
         /// <summary>
         ///     Creates a <see cref="ElectricReactiveEnergy"/> from <see cref="ElectricReactiveEnergyUnit.KilovoltampereReactiveHour"/>.
         /// </summary>
-        public static ElectricReactiveEnergy FromKilovoltampereReactiveHours(double value)
+        public static ElectricReactiveEnergy FromKilovoltampereReactiveHours(QuantityValue value)
         {
             return new ElectricReactiveEnergy(value, ElectricReactiveEnergyUnit.KilovoltampereReactiveHour);
         }
@@ -298,7 +282,7 @@ public static ElectricReactiveEnergy FromKilovoltampereReactiveHours(double valu
         /// <summary>
         ///     Creates a <see cref="ElectricReactiveEnergy"/> from <see cref="ElectricReactiveEnergyUnit.MegavoltampereReactiveHour"/>.
         /// </summary>
-        public static ElectricReactiveEnergy FromMegavoltampereReactiveHours(double value)
+        public static ElectricReactiveEnergy FromMegavoltampereReactiveHours(QuantityValue value)
         {
             return new ElectricReactiveEnergy(value, ElectricReactiveEnergyUnit.MegavoltampereReactiveHour);
         }
@@ -306,7 +290,7 @@ public static ElectricReactiveEnergy FromMegavoltampereReactiveHours(double valu
         /// <summary>
         ///     Creates a <see cref="ElectricReactiveEnergy"/> from <see cref="ElectricReactiveEnergyUnit.VoltampereReactiveHour"/>.
         /// </summary>
-        public static ElectricReactiveEnergy FromVoltampereReactiveHours(double value)
+        public static ElectricReactiveEnergy FromVoltampereReactiveHours(QuantityValue value)
         {
             return new ElectricReactiveEnergy(value, ElectricReactiveEnergyUnit.VoltampereReactiveHour);
         }
@@ -317,7 +301,7 @@ public static ElectricReactiveEnergy FromVoltampereReactiveHours(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricReactiveEnergy unit value.</returns>
-        public static ElectricReactiveEnergy From(double value, ElectricReactiveEnergyUnit fromUnit)
+        public static ElectricReactiveEnergy From(QuantityValue value, ElectricReactiveEnergyUnit fromUnit)
         {
             return new ElectricReactiveEnergy(value, fromUnit);
         }
@@ -378,10 +362,7 @@ public static ElectricReactiveEnergy Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricReactiveEnergy Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricReactiveEnergy, ElectricReactiveEnergyUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricReactiveEnergy, ElectricReactiveEnergyUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -409,11 +390,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricReactive
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricReactiveEnergy result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricReactiveEnergy, ElectricReactiveEnergyUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricReactiveEnergy, ElectricReactiveEnergyUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -434,7 +411,7 @@ public static ElectricReactiveEnergyUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -445,7 +422,7 @@ public static ElectricReactiveEnergyUnit ParseUnit(string str, IFormatProvider?
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricReactiveEnergyUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricReactiveEnergyUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricReactiveEnergyUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -460,7 +437,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricReac
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricReactiveEnergyUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -479,137 +456,167 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricReactiveEnergy"/> from adding two <see cref="ElectricReactiveEnergy"/>.</summary>
         public static ElectricReactiveEnergy operator +(ElectricReactiveEnergy left, ElectricReactiveEnergy right)
         {
-            return new ElectricReactiveEnergy(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricReactiveEnergy(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactiveEnergy"/> from subtracting two <see cref="ElectricReactiveEnergy"/>.</summary>
         public static ElectricReactiveEnergy operator -(ElectricReactiveEnergy left, ElectricReactiveEnergy right)
         {
-            return new ElectricReactiveEnergy(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricReactiveEnergy(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactiveEnergy"/> from multiplying value and <see cref="ElectricReactiveEnergy"/>.</summary>
-        public static ElectricReactiveEnergy operator *(double left, ElectricReactiveEnergy right)
+        public static ElectricReactiveEnergy operator *(QuantityValue left, ElectricReactiveEnergy right)
         {
             return new ElectricReactiveEnergy(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactiveEnergy"/> from multiplying value and <see cref="ElectricReactiveEnergy"/>.</summary>
-        public static ElectricReactiveEnergy operator *(ElectricReactiveEnergy left, double right)
+        public static ElectricReactiveEnergy operator *(ElectricReactiveEnergy left, QuantityValue right)
         {
             return new ElectricReactiveEnergy(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactiveEnergy"/> from dividing <see cref="ElectricReactiveEnergy"/> by value.</summary>
-        public static ElectricReactiveEnergy operator /(ElectricReactiveEnergy left, double right)
+        public static ElectricReactiveEnergy operator /(ElectricReactiveEnergy left, QuantityValue right)
         {
             return new ElectricReactiveEnergy(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricReactiveEnergy"/> by <see cref="ElectricReactiveEnergy"/>.</summary>
-        public static double operator /(ElectricReactiveEnergy left, ElectricReactiveEnergy right)
+        public static QuantityValue operator /(ElectricReactiveEnergy left, ElectricReactiveEnergy right)
         {
             return left.VoltampereReactiveHours / right.VoltampereReactiveHours;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Duration"/> from <see cref="ElectricReactiveEnergy"/> / <see cref="ElectricReactivePower"/>.</summary>
+        public static Duration operator /(ElectricReactiveEnergy electricReactiveEnergy, ElectricReactivePower electricReactivePower)
+        {
+            return Duration.FromHours(electricReactiveEnergy.VoltampereReactiveHours / electricReactivePower.VoltamperesReactive);
+        }
+
+        /// <summary>Get <see cref="ElectricReactivePower"/> from <see cref="ElectricReactiveEnergy"/> / <see cref="Duration"/>.</summary>
+        public static ElectricReactivePower operator /(ElectricReactiveEnergy electricReactiveEnergy, Duration duration)
+        {
+            return ElectricReactivePower.FromVoltamperesReactive(electricReactiveEnergy.VoltampereReactiveHours / duration.Hours);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricReactiveEnergy left, ElectricReactiveEnergy right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricReactiveEnergy left, ElectricReactiveEnergy right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricReactiveEnergy left, ElectricReactiveEnergy right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricReactiveEnergy left, ElectricReactiveEnergy right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricReactiveEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricReactiveEnergy other, ElectricReactiveEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricReactiveEnergy"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricReactiveEnergy)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricReactiveEnergy left, ElectricReactiveEnergy right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricReactiveEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricReactiveEnergy other, ElectricReactiveEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricReactiveEnergy"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricReactiveEnergy,ElectricReactiveEnergy)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricReactiveEnergy)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricReactiveEnergy left, ElectricReactiveEnergy right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricReactiveEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricReactiveEnergy other, ElectricReactiveEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricReactiveEnergy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricReactiveEnergy"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricReactiveEnergy"/>, this method delegates to
+        ///     <see cref="Equals(ElectricReactiveEnergy)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricReactiveEnergy otherQuantity))
+            if (obj is not ElectricReactiveEnergy otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricReactiveEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricReactiveEnergy other, ElectricReactiveEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricReactiveEnergy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricReactiveEnergy other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricReactiveEnergy.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricReactiveEnergy), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricReactiveEnergy"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricReactiveEnergy)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricReactiveEnergy otherQuantity)) throw new ArgumentException("Expected type ElectricReactiveEnergy.", nameof(obj));
+            if (obj is not ElectricReactiveEnergy otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricReactiveEnergy>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricReactiveEnergy"/> with another <see cref="ElectricReactiveEnergy"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricReactiveEnergy"/> with another <see cref="ElectricReactiveEnergy"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -621,133 +628,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricReactiveEnergy other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricReactiveEnergyUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricReactiveEnergyUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricReactiveEnergy to another ElectricReactiveEnergy with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricReactiveEnergy with the specified unit.</returns>
-        public ElectricReactiveEnergy ToUnit(ElectricReactiveEnergyUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricReactiveEnergy"/> to another <see cref="ElectricReactiveEnergy"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricReactiveEnergy with the specified unit.</returns>
-        public ElectricReactiveEnergy ToUnit(ElectricReactiveEnergyUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricReactiveEnergy), Unit, typeof(ElectricReactiveEnergy), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricReactiveEnergy)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricReactiveEnergy"/> to another <see cref="ElectricReactiveEnergy"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricReactiveEnergy"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricReactiveEnergyUnit unit, [NotNullWhen(true)] out ElectricReactiveEnergy? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricReactiveEnergy? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricReactiveEnergyUnit -> BaseUnit
-                (ElectricReactiveEnergyUnit.KilovoltampereReactiveHour, ElectricReactiveEnergyUnit.VoltampereReactiveHour) => new ElectricReactiveEnergy((_value) * 1e3d, ElectricReactiveEnergyUnit.VoltampereReactiveHour),
-                (ElectricReactiveEnergyUnit.MegavoltampereReactiveHour, ElectricReactiveEnergyUnit.VoltampereReactiveHour) => new ElectricReactiveEnergy((_value) * 1e6d, ElectricReactiveEnergyUnit.VoltampereReactiveHour),
-
-                // BaseUnit -> ElectricReactiveEnergyUnit
-                (ElectricReactiveEnergyUnit.VoltampereReactiveHour, ElectricReactiveEnergyUnit.KilovoltampereReactiveHour) => new ElectricReactiveEnergy((_value) / 1e3d, ElectricReactiveEnergyUnit.KilovoltampereReactiveHour),
-                (ElectricReactiveEnergyUnit.VoltampereReactiveHour, ElectricReactiveEnergyUnit.MegavoltampereReactiveHour) => new ElectricReactiveEnergy((_value) / 1e6d, ElectricReactiveEnergyUnit.MegavoltampereReactiveHour),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricReactiveEnergyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricReactiveEnergyUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricReactiveEnergyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricReactiveEnergyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricReactiveEnergyUnit> IQuantity<ElectricReactiveEnergyUnit>.ToUnit(ElectricReactiveEnergyUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -761,11 +644,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricReactivePower.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricReactivePower.g.cs
index 6bd91d9da5..c21c011153 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricReactivePower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricReactivePower.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/AC_power#Active,_reactive,_apparent,_and_complex_power_in_sinusoidal_steady-state
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricReactivePower :
-        IArithmeticQuantity<ElectricReactivePower, ElectricReactivePowerUnit>,
+        ILinearQuantity<ElectricReactivePower, ElectricReactivePowerUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricReactivePower, ElectricReactivePower, double>,
+        IDivisionOperators<ElectricReactivePower, ElectricReactivePower, QuantityValue>,
+        IMultiplyOperators<ElectricReactivePower, Duration, ElectricReactiveEnergy>,
         IComparisonOperators<ElectricReactivePower, ElectricReactivePower, bool>,
         IParsable<ElectricReactivePower>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static ElectricReactivePowerInfo CreateDefault(Func<IEnumerable<UnitDefin
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricReactivePower"/> is [T^-3][L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricReactivePower"/> is T^-3L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
 
@@ -120,18 +120,22 @@ public static ElectricReactivePowerInfo CreateDefault(Func<IEnumerable<UnitDefin
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricReactivePowerUnit}"/> representing the default unit mappings for ElectricReactivePower.</returns>
             public static IEnumerable<UnitDefinition<ElectricReactivePowerUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricReactivePowerUnit.GigavoltampereReactive, "GigavoltampereReactive", "GigavoltamperesReactive", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond));
-                yield return new (ElectricReactivePowerUnit.KilovoltampereReactive, "KilovoltampereReactive", "KilovoltamperesReactive", BaseUnits.Undefined);
-                yield return new (ElectricReactivePowerUnit.MegavoltampereReactive, "MegavoltampereReactive", "MegavoltamperesReactive", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
+                yield return new (ElectricReactivePowerUnit.GigavoltampereReactive, "GigavoltampereReactive", "GigavoltamperesReactive", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricReactivePowerUnit.KilovoltampereReactive, "KilovoltampereReactive", "KilovoltamperesReactive", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricReactivePowerUnit.MegavoltampereReactive, "MegavoltampereReactive", "MegavoltamperesReactive", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
                 yield return new (ElectricReactivePowerUnit.VoltampereReactive, "VoltampereReactive", "VoltamperesReactive", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
             }
         }
 
         static ElectricReactivePower()
         {
-            Info = ElectricReactivePowerInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricReactivePowerInfo.CreateDefault);
         }
 
         /// <summary>
@@ -139,7 +143,7 @@ static ElectricReactivePower()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricReactivePower(double value, ElectricReactivePowerUnit unit)
+        public ElectricReactivePower(QuantityValue value, ElectricReactivePowerUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -153,7 +157,7 @@ public ElectricReactivePower(double value, ElectricReactivePowerUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricReactivePower(double value, UnitSystem unitSystem)
+        public ElectricReactivePower(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -164,7 +168,8 @@ public ElectricReactivePower(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricReactivePower" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricReactivePower, ElectricReactivePowerUnit> Info { get; }
@@ -193,10 +198,8 @@ public ElectricReactivePower(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricReactivePowerUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -230,49 +233,29 @@ public ElectricReactivePower(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.GigavoltampereReactive"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.GigavoltampereReactive"/>
         /// </summary>
-        public double GigavoltamperesReactive => As(ElectricReactivePowerUnit.GigavoltampereReactive);
+        public QuantityValue GigavoltamperesReactive => this.As(ElectricReactivePowerUnit.GigavoltampereReactive);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.KilovoltampereReactive"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.KilovoltampereReactive"/>
         /// </summary>
-        public double KilovoltamperesReactive => As(ElectricReactivePowerUnit.KilovoltampereReactive);
+        public QuantityValue KilovoltamperesReactive => this.As(ElectricReactivePowerUnit.KilovoltampereReactive);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.MegavoltampereReactive"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.MegavoltampereReactive"/>
         /// </summary>
-        public double MegavoltamperesReactive => As(ElectricReactivePowerUnit.MegavoltampereReactive);
+        public QuantityValue MegavoltamperesReactive => this.As(ElectricReactivePowerUnit.MegavoltampereReactive);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.VoltampereReactive"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricReactivePowerUnit.VoltampereReactive"/>
         /// </summary>
-        public double VoltamperesReactive => As(ElectricReactivePowerUnit.VoltampereReactive);
+        public QuantityValue VoltamperesReactive => this.As(ElectricReactivePowerUnit.VoltampereReactive);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricReactivePowerUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricReactivePower>(ElectricReactivePowerUnit.GigavoltampereReactive, ElectricReactivePowerUnit.VoltampereReactive, quantity => quantity.ToUnit(ElectricReactivePowerUnit.VoltampereReactive));
-            unitConverter.SetConversionFunction<ElectricReactivePower>(ElectricReactivePowerUnit.KilovoltampereReactive, ElectricReactivePowerUnit.VoltampereReactive, quantity => quantity.ToUnit(ElectricReactivePowerUnit.VoltampereReactive));
-            unitConverter.SetConversionFunction<ElectricReactivePower>(ElectricReactivePowerUnit.MegavoltampereReactive, ElectricReactivePowerUnit.VoltampereReactive, quantity => quantity.ToUnit(ElectricReactivePowerUnit.VoltampereReactive));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricReactivePower>(ElectricReactivePowerUnit.VoltampereReactive, ElectricReactivePowerUnit.VoltampereReactive, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricReactivePowerUnit
-            unitConverter.SetConversionFunction<ElectricReactivePower>(ElectricReactivePowerUnit.VoltampereReactive, ElectricReactivePowerUnit.GigavoltampereReactive, quantity => quantity.ToUnit(ElectricReactivePowerUnit.GigavoltampereReactive));
-            unitConverter.SetConversionFunction<ElectricReactivePower>(ElectricReactivePowerUnit.VoltampereReactive, ElectricReactivePowerUnit.KilovoltampereReactive, quantity => quantity.ToUnit(ElectricReactivePowerUnit.KilovoltampereReactive));
-            unitConverter.SetConversionFunction<ElectricReactivePower>(ElectricReactivePowerUnit.VoltampereReactive, ElectricReactivePowerUnit.MegavoltampereReactive, quantity => quantity.ToUnit(ElectricReactivePowerUnit.MegavoltampereReactive));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -301,7 +284,7 @@ public static string GetAbbreviation(ElectricReactivePowerUnit unit, IFormatProv
         /// <summary>
         ///     Creates a <see cref="ElectricReactivePower"/> from <see cref="ElectricReactivePowerUnit.GigavoltampereReactive"/>.
         /// </summary>
-        public static ElectricReactivePower FromGigavoltamperesReactive(double value)
+        public static ElectricReactivePower FromGigavoltamperesReactive(QuantityValue value)
         {
             return new ElectricReactivePower(value, ElectricReactivePowerUnit.GigavoltampereReactive);
         }
@@ -309,7 +292,7 @@ public static ElectricReactivePower FromGigavoltamperesReactive(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricReactivePower"/> from <see cref="ElectricReactivePowerUnit.KilovoltampereReactive"/>.
         /// </summary>
-        public static ElectricReactivePower FromKilovoltamperesReactive(double value)
+        public static ElectricReactivePower FromKilovoltamperesReactive(QuantityValue value)
         {
             return new ElectricReactivePower(value, ElectricReactivePowerUnit.KilovoltampereReactive);
         }
@@ -317,7 +300,7 @@ public static ElectricReactivePower FromKilovoltamperesReactive(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricReactivePower"/> from <see cref="ElectricReactivePowerUnit.MegavoltampereReactive"/>.
         /// </summary>
-        public static ElectricReactivePower FromMegavoltamperesReactive(double value)
+        public static ElectricReactivePower FromMegavoltamperesReactive(QuantityValue value)
         {
             return new ElectricReactivePower(value, ElectricReactivePowerUnit.MegavoltampereReactive);
         }
@@ -325,7 +308,7 @@ public static ElectricReactivePower FromMegavoltamperesReactive(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricReactivePower"/> from <see cref="ElectricReactivePowerUnit.VoltampereReactive"/>.
         /// </summary>
-        public static ElectricReactivePower FromVoltamperesReactive(double value)
+        public static ElectricReactivePower FromVoltamperesReactive(QuantityValue value)
         {
             return new ElectricReactivePower(value, ElectricReactivePowerUnit.VoltampereReactive);
         }
@@ -336,7 +319,7 @@ public static ElectricReactivePower FromVoltamperesReactive(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricReactivePower unit value.</returns>
-        public static ElectricReactivePower From(double value, ElectricReactivePowerUnit fromUnit)
+        public static ElectricReactivePower From(QuantityValue value, ElectricReactivePowerUnit fromUnit)
         {
             return new ElectricReactivePower(value, fromUnit);
         }
@@ -397,10 +380,7 @@ public static ElectricReactivePower Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricReactivePower Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricReactivePower, ElectricReactivePowerUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricReactivePower, ElectricReactivePowerUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -428,11 +408,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricReactive
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricReactivePower result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricReactivePower, ElectricReactivePowerUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricReactivePower, ElectricReactivePowerUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -453,7 +429,7 @@ public static ElectricReactivePowerUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -464,7 +440,7 @@ public static ElectricReactivePowerUnit ParseUnit(string str, IFormatProvider? p
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricReactivePowerUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricReactivePowerUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricReactivePowerUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -479,7 +455,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricReac
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricReactivePowerUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -498,137 +474,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricReactivePower"/> from adding two <see cref="ElectricReactivePower"/>.</summary>
         public static ElectricReactivePower operator +(ElectricReactivePower left, ElectricReactivePower right)
         {
-            return new ElectricReactivePower(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricReactivePower(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactivePower"/> from subtracting two <see cref="ElectricReactivePower"/>.</summary>
         public static ElectricReactivePower operator -(ElectricReactivePower left, ElectricReactivePower right)
         {
-            return new ElectricReactivePower(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricReactivePower(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactivePower"/> from multiplying value and <see cref="ElectricReactivePower"/>.</summary>
-        public static ElectricReactivePower operator *(double left, ElectricReactivePower right)
+        public static ElectricReactivePower operator *(QuantityValue left, ElectricReactivePower right)
         {
             return new ElectricReactivePower(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactivePower"/> from multiplying value and <see cref="ElectricReactivePower"/>.</summary>
-        public static ElectricReactivePower operator *(ElectricReactivePower left, double right)
+        public static ElectricReactivePower operator *(ElectricReactivePower left, QuantityValue right)
         {
             return new ElectricReactivePower(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricReactivePower"/> from dividing <see cref="ElectricReactivePower"/> by value.</summary>
-        public static ElectricReactivePower operator /(ElectricReactivePower left, double right)
+        public static ElectricReactivePower operator /(ElectricReactivePower left, QuantityValue right)
         {
             return new ElectricReactivePower(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricReactivePower"/> by <see cref="ElectricReactivePower"/>.</summary>
-        public static double operator /(ElectricReactivePower left, ElectricReactivePower right)
+        public static QuantityValue operator /(ElectricReactivePower left, ElectricReactivePower right)
         {
             return left.VoltamperesReactive / right.VoltamperesReactive;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="ElectricReactiveEnergy"/> from <see cref="ElectricReactivePower"/> * <see cref="Duration"/>.</summary>
+        public static ElectricReactiveEnergy operator *(ElectricReactivePower electricReactivePower, Duration duration)
+        {
+            return ElectricReactiveEnergy.FromVoltampereReactiveHours(electricReactivePower.VoltamperesReactive * duration.Hours);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricReactivePower left, ElectricReactivePower right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricReactivePower left, ElectricReactivePower right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricReactivePower left, ElectricReactivePower right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricReactivePower left, ElectricReactivePower right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricReactivePower"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricReactivePower other, ElectricReactivePower tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricReactivePower"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricReactivePower)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricReactivePower left, ElectricReactivePower right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricReactivePower"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricReactivePower other, ElectricReactivePower tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricReactivePower"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricReactivePower,ElectricReactivePower)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricReactivePower)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricReactivePower left, ElectricReactivePower right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricReactivePower"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricReactivePower other, ElectricReactivePower tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricReactivePower"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricReactivePower"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricReactivePower"/>, this method delegates to
+        ///     <see cref="Equals(ElectricReactivePower)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricReactivePower otherQuantity))
+            if (obj is not ElectricReactivePower otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricReactivePower"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricReactivePower other, ElectricReactivePower tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricReactivePower"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricReactivePower other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricReactivePower.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricReactivePower), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricReactivePower"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricReactivePower)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricReactivePower otherQuantity)) throw new ArgumentException("Expected type ElectricReactivePower.", nameof(obj));
+            if (obj is not ElectricReactivePower otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricReactivePower>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricReactivePower"/> with another <see cref="ElectricReactivePower"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricReactivePower"/> with another <see cref="ElectricReactivePower"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -640,137 +640,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricReactivePower other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricReactivePowerUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricReactivePowerUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricReactivePower to another ElectricReactivePower with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricReactivePower with the specified unit.</returns>
-        public ElectricReactivePower ToUnit(ElectricReactivePowerUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricReactivePower"/> to another <see cref="ElectricReactivePower"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricReactivePower with the specified unit.</returns>
-        public ElectricReactivePower ToUnit(ElectricReactivePowerUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricReactivePower), Unit, typeof(ElectricReactivePower), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricReactivePower)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricReactivePower"/> to another <see cref="ElectricReactivePower"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricReactivePower"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricReactivePowerUnit unit, [NotNullWhen(true)] out ElectricReactivePower? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricReactivePower? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricReactivePowerUnit -> BaseUnit
-                (ElectricReactivePowerUnit.GigavoltampereReactive, ElectricReactivePowerUnit.VoltampereReactive) => new ElectricReactivePower((_value) * 1e9d, ElectricReactivePowerUnit.VoltampereReactive),
-                (ElectricReactivePowerUnit.KilovoltampereReactive, ElectricReactivePowerUnit.VoltampereReactive) => new ElectricReactivePower((_value) * 1e3d, ElectricReactivePowerUnit.VoltampereReactive),
-                (ElectricReactivePowerUnit.MegavoltampereReactive, ElectricReactivePowerUnit.VoltampereReactive) => new ElectricReactivePower((_value) * 1e6d, ElectricReactivePowerUnit.VoltampereReactive),
-
-                // BaseUnit -> ElectricReactivePowerUnit
-                (ElectricReactivePowerUnit.VoltampereReactive, ElectricReactivePowerUnit.GigavoltampereReactive) => new ElectricReactivePower((_value) / 1e9d, ElectricReactivePowerUnit.GigavoltampereReactive),
-                (ElectricReactivePowerUnit.VoltampereReactive, ElectricReactivePowerUnit.KilovoltampereReactive) => new ElectricReactivePower((_value) / 1e3d, ElectricReactivePowerUnit.KilovoltampereReactive),
-                (ElectricReactivePowerUnit.VoltampereReactive, ElectricReactivePowerUnit.MegavoltampereReactive) => new ElectricReactivePower((_value) / 1e6d, ElectricReactivePowerUnit.MegavoltampereReactive),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricReactivePowerUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricReactivePowerUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricReactivePowerUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricReactivePowerUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricReactivePowerUnit> IQuantity<ElectricReactivePowerUnit>.ToUnit(ElectricReactivePowerUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -782,11 +656,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
index 1b483957e0..0ff74bacd3 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Electrical_resistance_and_conductance
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricResistance :
-        IArithmeticQuantity<ElectricResistance, ElectricResistanceUnit>,
+        ILinearQuantity<ElectricResistance, ElectricResistanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricResistance, ElectricResistance, double>,
+        IDivisionOperators<ElectricResistance, ElectricResistance, QuantityValue>,
         IMultiplyOperators<ElectricResistance, ElectricCurrent, ElectricPotential>,
         IComparisonOperators<ElectricResistance, ElectricResistance, bool>,
         IParsable<ElectricResistance>,
@@ -56,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -106,7 +105,7 @@ public static ElectricResistanceInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricResistance"/> is [T^-3][L^2][M][I^-2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricResistance"/> is T^-3L^2MI^-2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -3, -2, 0, 0, 0);
 
@@ -121,22 +120,34 @@ public static ElectricResistanceInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricResistanceUnit}"/> representing the default unit mappings for ElectricResistance.</returns>
             public static IEnumerable<UnitDefinition<ElectricResistanceUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricResistanceUnit.Gigaohm, "Gigaohm", "Gigaohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricResistanceUnit.Kiloohm, "Kiloohm", "Kiloohms", BaseUnits.Undefined);
-                yield return new (ElectricResistanceUnit.Megaohm, "Megaohm", "Megaohms", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricResistanceUnit.Microohm, "Microohm", "Microohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricResistanceUnit.Milliohm, "Milliohm", "Milliohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricResistanceUnit.Nanoohm, "Nanoohm", "Nanoohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricResistanceUnit.Gigaohm, "Gigaohm", "Gigaohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricResistanceUnit.Kiloohm, "Kiloohm", "Kiloohms", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricResistanceUnit.Megaohm, "Megaohm", "Megaohms", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricResistanceUnit.Microohm, "Microohm", "Microohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000
+                );
+                yield return new (ElectricResistanceUnit.Milliohm, "Milliohm", "Milliohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000
+                );
+                yield return new (ElectricResistanceUnit.Nanoohm, "Nanoohm", "Nanoohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000000
+                );
                 yield return new (ElectricResistanceUnit.Ohm, "Ohm", "Ohms", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricResistanceUnit.Teraohm, "Teraohm", "Teraohms", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricResistanceUnit.Teraohm, "Teraohm", "Teraohms", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000000)
+                );
             }
         }
 
         static ElectricResistance()
         {
-            Info = ElectricResistanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricResistanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -144,7 +155,7 @@ static ElectricResistance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricResistance(double value, ElectricResistanceUnit unit)
+        public ElectricResistance(QuantityValue value, ElectricResistanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -158,7 +169,7 @@ public ElectricResistance(double value, ElectricResistanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricResistance(double value, UnitSystem unitSystem)
+        public ElectricResistance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -169,7 +180,8 @@ public ElectricResistance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricResistance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricResistance, ElectricResistanceUnit> Info { get; }
@@ -198,10 +210,8 @@ public ElectricResistance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricResistanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -235,77 +245,49 @@ public ElectricResistance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Gigaohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Gigaohm"/>
         /// </summary>
-        public double Gigaohms => As(ElectricResistanceUnit.Gigaohm);
+        public QuantityValue Gigaohms => this.As(ElectricResistanceUnit.Gigaohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Kiloohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Kiloohm"/>
         /// </summary>
-        public double Kiloohms => As(ElectricResistanceUnit.Kiloohm);
+        public QuantityValue Kiloohms => this.As(ElectricResistanceUnit.Kiloohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Megaohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Megaohm"/>
         /// </summary>
-        public double Megaohms => As(ElectricResistanceUnit.Megaohm);
+        public QuantityValue Megaohms => this.As(ElectricResistanceUnit.Megaohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Microohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Microohm"/>
         /// </summary>
-        public double Microohms => As(ElectricResistanceUnit.Microohm);
+        public QuantityValue Microohms => this.As(ElectricResistanceUnit.Microohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Milliohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Milliohm"/>
         /// </summary>
-        public double Milliohms => As(ElectricResistanceUnit.Milliohm);
+        public QuantityValue Milliohms => this.As(ElectricResistanceUnit.Milliohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Nanoohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Nanoohm"/>
         /// </summary>
-        public double Nanoohms => As(ElectricResistanceUnit.Nanoohm);
+        public QuantityValue Nanoohms => this.As(ElectricResistanceUnit.Nanoohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Ohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Ohm"/>
         /// </summary>
-        public double Ohms => As(ElectricResistanceUnit.Ohm);
+        public QuantityValue Ohms => this.As(ElectricResistanceUnit.Ohm);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Teraohm"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistanceUnit.Teraohm"/>
         /// </summary>
-        public double Teraohms => As(ElectricResistanceUnit.Teraohm);
+        public QuantityValue Teraohms => this.As(ElectricResistanceUnit.Teraohm);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricResistanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Gigaohm, ElectricResistanceUnit.Ohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Kiloohm, ElectricResistanceUnit.Ohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Megaohm, ElectricResistanceUnit.Ohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Microohm, ElectricResistanceUnit.Ohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Milliohm, ElectricResistanceUnit.Ohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Nanoohm, ElectricResistanceUnit.Ohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Ohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Teraohm, ElectricResistanceUnit.Ohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Ohm));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Ohm, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricResistanceUnit
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Gigaohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Gigaohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Kiloohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Kiloohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Megaohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Megaohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Microohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Microohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Milliohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Milliohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Nanoohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Nanoohm));
-            unitConverter.SetConversionFunction<ElectricResistance>(ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Teraohm, quantity => quantity.ToUnit(ElectricResistanceUnit.Teraohm));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -334,7 +316,7 @@ public static string GetAbbreviation(ElectricResistanceUnit unit, IFormatProvide
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Gigaohm"/>.
         /// </summary>
-        public static ElectricResistance FromGigaohms(double value)
+        public static ElectricResistance FromGigaohms(QuantityValue value)
         {
             return new ElectricResistance(value, ElectricResistanceUnit.Gigaohm);
         }
@@ -342,7 +324,7 @@ public static ElectricResistance FromGigaohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Kiloohm"/>.
         /// </summary>
-        public static ElectricResistance FromKiloohms(double value)
+        public static ElectricResistance FromKiloohms(QuantityValue value)
         {
             return new ElectricResistance(value, ElectricResistanceUnit.Kiloohm);
         }
@@ -350,7 +332,7 @@ public static ElectricResistance FromKiloohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Megaohm"/>.
         /// </summary>
-        public static ElectricResistance FromMegaohms(double value)
+        public static ElectricResistance FromMegaohms(QuantityValue value)
         {
             return new ElectricResistance(value, ElectricResistanceUnit.Megaohm);
         }
@@ -358,7 +340,7 @@ public static ElectricResistance FromMegaohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Microohm"/>.
         /// </summary>
-        public static ElectricResistance FromMicroohms(double value)
+        public static ElectricResistance FromMicroohms(QuantityValue value)
         {
             return new ElectricResistance(value, ElectricResistanceUnit.Microohm);
         }
@@ -366,7 +348,7 @@ public static ElectricResistance FromMicroohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Milliohm"/>.
         /// </summary>
-        public static ElectricResistance FromMilliohms(double value)
+        public static ElectricResistance FromMilliohms(QuantityValue value)
         {
             return new ElectricResistance(value, ElectricResistanceUnit.Milliohm);
         }
@@ -374,7 +356,7 @@ public static ElectricResistance FromMilliohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Nanoohm"/>.
         /// </summary>
-        public static ElectricResistance FromNanoohms(double value)
+        public static ElectricResistance FromNanoohms(QuantityValue value)
         {
             return new ElectricResistance(value, ElectricResistanceUnit.Nanoohm);
         }
@@ -382,7 +364,7 @@ public static ElectricResistance FromNanoohms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Ohm"/>.
         /// </summary>
-        public static ElectricResistance FromOhms(double value)
+        public static ElectricResistance FromOhms(QuantityValue value)
         {
             return new ElectricResistance(value, ElectricResistanceUnit.Ohm);
         }
@@ -390,7 +372,7 @@ public static ElectricResistance FromOhms(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Teraohm"/>.
         /// </summary>
-        public static ElectricResistance FromTeraohms(double value)
+        public static ElectricResistance FromTeraohms(QuantityValue value)
         {
             return new ElectricResistance(value, ElectricResistanceUnit.Teraohm);
         }
@@ -401,7 +383,7 @@ public static ElectricResistance FromTeraohms(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricResistance unit value.</returns>
-        public static ElectricResistance From(double value, ElectricResistanceUnit fromUnit)
+        public static ElectricResistance From(QuantityValue value, ElectricResistanceUnit fromUnit)
         {
             return new ElectricResistance(value, fromUnit);
         }
@@ -462,10 +444,7 @@ public static ElectricResistance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricResistance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricResistance, ElectricResistanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricResistance, ElectricResistanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -493,11 +472,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricResistan
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricResistance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricResistance, ElectricResistanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricResistance, ElectricResistanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -518,7 +493,7 @@ public static ElectricResistanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -529,7 +504,7 @@ public static ElectricResistanceUnit ParseUnit(string str, IFormatProvider? prov
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricResistanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricResistanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricResistanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -544,7 +519,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricResi
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricResistanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -563,35 +538,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricResistance"/> from adding two <see cref="ElectricResistance"/>.</summary>
         public static ElectricResistance operator +(ElectricResistance left, ElectricResistance right)
         {
-            return new ElectricResistance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricResistance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricResistance"/> from subtracting two <see cref="ElectricResistance"/>.</summary>
         public static ElectricResistance operator -(ElectricResistance left, ElectricResistance right)
         {
-            return new ElectricResistance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricResistance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricResistance"/> from multiplying value and <see cref="ElectricResistance"/>.</summary>
-        public static ElectricResistance operator *(double left, ElectricResistance right)
+        public static ElectricResistance operator *(QuantityValue left, ElectricResistance right)
         {
             return new ElectricResistance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricResistance"/> from multiplying value and <see cref="ElectricResistance"/>.</summary>
-        public static ElectricResistance operator *(ElectricResistance left, double right)
+        public static ElectricResistance operator *(ElectricResistance left, QuantityValue right)
         {
             return new ElectricResistance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricResistance"/> from dividing <see cref="ElectricResistance"/> by value.</summary>
-        public static ElectricResistance operator /(ElectricResistance left, double right)
+        public static ElectricResistance operator /(ElectricResistance left, QuantityValue right)
         {
             return new ElectricResistance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricResistance"/> by <see cref="ElectricResistance"/>.</summary>
-        public static double operator /(ElectricResistance left, ElectricResistance right)
+        public static QuantityValue operator /(ElectricResistance left, ElectricResistance right)
         {
             return left.Ohms / right.Ohms;
         }
@@ -613,97 +588,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricResistance left, ElectricResistance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricResistance left, ElectricResistance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricResistance left, ElectricResistance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricResistance left, ElectricResistance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricResistance other, ElectricResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricResistance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricResistance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricResistance left, ElectricResistance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricResistance other, ElectricResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricResistance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricResistance,ElectricResistance)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricResistance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricResistance left, ElectricResistance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricResistance other, ElectricResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricResistance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricResistance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricResistance"/>, this method delegates to
+        ///     <see cref="Equals(ElectricResistance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricResistance otherQuantity))
+            if (obj is not ElectricResistance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricResistance other, ElectricResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricResistance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricResistance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricResistance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricResistance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricResistance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricResistance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricResistance otherQuantity)) throw new ArgumentException("Expected type ElectricResistance.", nameof(obj));
+            if (obj is not ElectricResistance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricResistance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricResistance"/> with another <see cref="ElectricResistance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricResistance"/> with another <see cref="ElectricResistance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -715,143 +704,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricResistance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricResistanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricResistanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricResistance to another ElectricResistance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricResistance with the specified unit.</returns>
-        public ElectricResistance ToUnit(ElectricResistanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="ElectricResistance"/> to another <see cref="ElectricResistance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricResistance with the specified unit.</returns>
-        public ElectricResistance ToUnit(ElectricResistanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricResistance), Unit, typeof(ElectricResistance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricResistance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricResistance"/> to another <see cref="ElectricResistance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricResistance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricResistanceUnit unit, [NotNullWhen(true)] out ElectricResistance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricResistance? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricResistanceUnit -> BaseUnit
-                (ElectricResistanceUnit.Gigaohm, ElectricResistanceUnit.Ohm) => new ElectricResistance((_value) * 1e9d, ElectricResistanceUnit.Ohm),
-                (ElectricResistanceUnit.Kiloohm, ElectricResistanceUnit.Ohm) => new ElectricResistance((_value) * 1e3d, ElectricResistanceUnit.Ohm),
-                (ElectricResistanceUnit.Megaohm, ElectricResistanceUnit.Ohm) => new ElectricResistance((_value) * 1e6d, ElectricResistanceUnit.Ohm),
-                (ElectricResistanceUnit.Microohm, ElectricResistanceUnit.Ohm) => new ElectricResistance((_value) * 1e-6d, ElectricResistanceUnit.Ohm),
-                (ElectricResistanceUnit.Milliohm, ElectricResistanceUnit.Ohm) => new ElectricResistance((_value) * 1e-3d, ElectricResistanceUnit.Ohm),
-                (ElectricResistanceUnit.Nanoohm, ElectricResistanceUnit.Ohm) => new ElectricResistance((_value) * 1e-9d, ElectricResistanceUnit.Ohm),
-                (ElectricResistanceUnit.Teraohm, ElectricResistanceUnit.Ohm) => new ElectricResistance((_value) * 1e12d, ElectricResistanceUnit.Ohm),
-
-                // BaseUnit -> ElectricResistanceUnit
-                (ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Gigaohm) => new ElectricResistance((_value) / 1e9d, ElectricResistanceUnit.Gigaohm),
-                (ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Kiloohm) => new ElectricResistance((_value) / 1e3d, ElectricResistanceUnit.Kiloohm),
-                (ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Megaohm) => new ElectricResistance((_value) / 1e6d, ElectricResistanceUnit.Megaohm),
-                (ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Microohm) => new ElectricResistance((_value) / 1e-6d, ElectricResistanceUnit.Microohm),
-                (ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Milliohm) => new ElectricResistance((_value) / 1e-3d, ElectricResistanceUnit.Milliohm),
-                (ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Nanoohm) => new ElectricResistance((_value) / 1e-9d, ElectricResistanceUnit.Nanoohm),
-                (ElectricResistanceUnit.Ohm, ElectricResistanceUnit.Teraohm) => new ElectricResistance((_value) / 1e12d, ElectricResistanceUnit.Teraohm),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricResistanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricResistanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricResistanceUnit> IQuantity<ElectricResistanceUnit>.ToUnit(ElectricResistanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -865,11 +720,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
index 0a20865a27..109518382d 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Electrical_resistivity_and_conductivity
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricResistivity :
-        IArithmeticQuantity<ElectricResistivity, ElectricResistivityUnit>,
+        ILinearQuantity<ElectricResistivity, ElectricResistivityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricResistivity, ElectricResistivity, double>,
+        IDivisionOperators<ElectricResistivity, ElectricResistivity, QuantityValue>,
         IComparisonOperators<ElectricResistivity, ElectricResistivity, bool>,
         IParsable<ElectricResistivity>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static ElectricResistivityInfo CreateDefault(Func<IEnumerable<UnitDefinit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricResistivity"/> is [T^-3][L^3][M][I^-2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricResistivity"/> is T^-3L^3MI^-2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(3, 1, -3, -2, 0, 0, 0);
 
@@ -120,28 +119,52 @@ public static ElectricResistivityInfo CreateDefault(Func<IEnumerable<UnitDefinit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricResistivityUnit}"/> representing the default unit mappings for ElectricResistivity.</returns>
             public static IEnumerable<UnitDefinition<ElectricResistivityUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricResistivityUnit.KiloohmCentimeter, "KiloohmCentimeter", "KiloohmsCentimeter", BaseUnits.Undefined);
-                yield return new (ElectricResistivityUnit.KiloohmMeter, "KiloohmMeter", "KiloohmMeters", new BaseUnits(length: LengthUnit.Decameter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricResistivityUnit.MegaohmCentimeter, "MegaohmCentimeter", "MegaohmsCentimeter", BaseUnits.Undefined);
-                yield return new (ElectricResistivityUnit.MegaohmMeter, "MegaohmMeter", "MegaohmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricResistivityUnit.MicroohmCentimeter, "MicroohmCentimeter", "MicroohmsCentimeter", BaseUnits.Undefined);
-                yield return new (ElectricResistivityUnit.MicroohmMeter, "MicroohmMeter", "MicroohmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricResistivityUnit.MilliohmCentimeter, "MilliohmCentimeter", "MilliohmsCentimeter", BaseUnits.Undefined);
-                yield return new (ElectricResistivityUnit.MilliohmMeter, "MilliohmMeter", "MilliohmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricResistivityUnit.NanoohmCentimeter, "NanoohmCentimeter", "NanoohmsCentimeter", BaseUnits.Undefined);
-                yield return new (ElectricResistivityUnit.NanoohmMeter, "NanoohmMeter", "NanoohmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricResistivityUnit.OhmCentimeter, "OhmCentimeter", "OhmsCentimeter", BaseUnits.Undefined);
+                yield return new (ElectricResistivityUnit.KiloohmCentimeter, "KiloohmCentimeter", "KiloohmsCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (ElectricResistivityUnit.KiloohmMeter, "KiloohmMeter", "KiloohmMeters", new BaseUnits(length: LengthUnit.Decameter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricResistivityUnit.MegaohmCentimeter, "MegaohmCentimeter", "MegaohmsCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (ElectricResistivityUnit.MegaohmMeter, "MegaohmMeter", "MegaohmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricResistivityUnit.MicroohmCentimeter, "MicroohmCentimeter", "MicroohmsCentimeter", BaseUnits.Undefined,
+                     100000000
+                );
+                yield return new (ElectricResistivityUnit.MicroohmMeter, "MicroohmMeter", "MicroohmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000
+                );
+                yield return new (ElectricResistivityUnit.MilliohmCentimeter, "MilliohmCentimeter", "MilliohmsCentimeter", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (ElectricResistivityUnit.MilliohmMeter, "MilliohmMeter", "MilliohmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000
+                );
+                yield return new (ElectricResistivityUnit.NanoohmCentimeter, "NanoohmCentimeter", "NanoohmsCentimeter", BaseUnits.Undefined,
+                     100000000000
+                );
+                yield return new (ElectricResistivityUnit.NanoohmMeter, "NanoohmMeter", "NanoohmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000000
+                );
+                yield return new (ElectricResistivityUnit.OhmCentimeter, "OhmCentimeter", "OhmsCentimeter", BaseUnits.Undefined,
+                     100
+                );
                 yield return new (ElectricResistivityUnit.OhmMeter, "OhmMeter", "OhmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricResistivityUnit.PicoohmCentimeter, "PicoohmCentimeter", "PicoohmsCentimeter", BaseUnits.Undefined);
-                yield return new (ElectricResistivityUnit.PicoohmMeter, "PicoohmMeter", "PicoohmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricResistivityUnit.PicoohmCentimeter, "PicoohmCentimeter", "PicoohmsCentimeter", BaseUnits.Undefined,
+                     100000000000000
+                );
+                yield return new (ElectricResistivityUnit.PicoohmMeter, "PicoohmMeter", "PicoohmMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     1000000000000
+                );
             }
         }
 
         static ElectricResistivity()
         {
-            Info = ElectricResistivityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricResistivityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -149,7 +172,7 @@ static ElectricResistivity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricResistivity(double value, ElectricResistivityUnit unit)
+        public ElectricResistivity(QuantityValue value, ElectricResistivityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -163,7 +186,7 @@ public ElectricResistivity(double value, ElectricResistivityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricResistivity(double value, UnitSystem unitSystem)
+        public ElectricResistivity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -174,7 +197,8 @@ public ElectricResistivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricResistivity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricResistivity, ElectricResistivityUnit> Info { get; }
@@ -203,10 +227,8 @@ public ElectricResistivity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricResistivityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -240,119 +262,79 @@ public ElectricResistivity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.KiloohmCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.KiloohmCentimeter"/>
         /// </summary>
-        public double KiloohmsCentimeter => As(ElectricResistivityUnit.KiloohmCentimeter);
+        public QuantityValue KiloohmsCentimeter => this.As(ElectricResistivityUnit.KiloohmCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.KiloohmMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.KiloohmMeter"/>
         /// </summary>
-        public double KiloohmMeters => As(ElectricResistivityUnit.KiloohmMeter);
+        public QuantityValue KiloohmMeters => this.As(ElectricResistivityUnit.KiloohmMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MegaohmCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MegaohmCentimeter"/>
         /// </summary>
-        public double MegaohmsCentimeter => As(ElectricResistivityUnit.MegaohmCentimeter);
+        public QuantityValue MegaohmsCentimeter => this.As(ElectricResistivityUnit.MegaohmCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MegaohmMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MegaohmMeter"/>
         /// </summary>
-        public double MegaohmMeters => As(ElectricResistivityUnit.MegaohmMeter);
+        public QuantityValue MegaohmMeters => this.As(ElectricResistivityUnit.MegaohmMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MicroohmCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MicroohmCentimeter"/>
         /// </summary>
-        public double MicroohmsCentimeter => As(ElectricResistivityUnit.MicroohmCentimeter);
+        public QuantityValue MicroohmsCentimeter => this.As(ElectricResistivityUnit.MicroohmCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MicroohmMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MicroohmMeter"/>
         /// </summary>
-        public double MicroohmMeters => As(ElectricResistivityUnit.MicroohmMeter);
+        public QuantityValue MicroohmMeters => this.As(ElectricResistivityUnit.MicroohmMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MilliohmCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MilliohmCentimeter"/>
         /// </summary>
-        public double MilliohmsCentimeter => As(ElectricResistivityUnit.MilliohmCentimeter);
+        public QuantityValue MilliohmsCentimeter => this.As(ElectricResistivityUnit.MilliohmCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MilliohmMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.MilliohmMeter"/>
         /// </summary>
-        public double MilliohmMeters => As(ElectricResistivityUnit.MilliohmMeter);
+        public QuantityValue MilliohmMeters => this.As(ElectricResistivityUnit.MilliohmMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.NanoohmCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.NanoohmCentimeter"/>
         /// </summary>
-        public double NanoohmsCentimeter => As(ElectricResistivityUnit.NanoohmCentimeter);
+        public QuantityValue NanoohmsCentimeter => this.As(ElectricResistivityUnit.NanoohmCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.NanoohmMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.NanoohmMeter"/>
         /// </summary>
-        public double NanoohmMeters => As(ElectricResistivityUnit.NanoohmMeter);
+        public QuantityValue NanoohmMeters => this.As(ElectricResistivityUnit.NanoohmMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.OhmCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.OhmCentimeter"/>
         /// </summary>
-        public double OhmsCentimeter => As(ElectricResistivityUnit.OhmCentimeter);
+        public QuantityValue OhmsCentimeter => this.As(ElectricResistivityUnit.OhmCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.OhmMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.OhmMeter"/>
         /// </summary>
-        public double OhmMeters => As(ElectricResistivityUnit.OhmMeter);
+        public QuantityValue OhmMeters => this.As(ElectricResistivityUnit.OhmMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.PicoohmCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.PicoohmCentimeter"/>
         /// </summary>
-        public double PicoohmsCentimeter => As(ElectricResistivityUnit.PicoohmCentimeter);
+        public QuantityValue PicoohmsCentimeter => this.As(ElectricResistivityUnit.PicoohmCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricResistivityUnit.PicoohmMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricResistivityUnit.PicoohmMeter"/>
         /// </summary>
-        public double PicoohmMeters => As(ElectricResistivityUnit.PicoohmMeter);
+        public QuantityValue PicoohmMeters => this.As(ElectricResistivityUnit.PicoohmMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricResistivityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.KiloohmCentimeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.KiloohmMeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MegaohmCentimeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MegaohmMeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MicroohmCentimeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MicroohmMeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MilliohmCentimeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.MilliohmMeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.NanoohmCentimeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.NanoohmMeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmCentimeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.PicoohmCentimeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.PicoohmMeter, ElectricResistivityUnit.OhmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.OhmMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricResistivityUnit
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.KiloohmCentimeter, quantity => quantity.ToUnit(ElectricResistivityUnit.KiloohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.KiloohmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.KiloohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MegaohmCentimeter, quantity => quantity.ToUnit(ElectricResistivityUnit.MegaohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MegaohmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.MegaohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MicroohmCentimeter, quantity => quantity.ToUnit(ElectricResistivityUnit.MicroohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MicroohmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.MicroohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MilliohmCentimeter, quantity => quantity.ToUnit(ElectricResistivityUnit.MilliohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MilliohmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.MilliohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.NanoohmCentimeter, quantity => quantity.ToUnit(ElectricResistivityUnit.NanoohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.NanoohmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.NanoohmMeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.OhmCentimeter, quantity => quantity.ToUnit(ElectricResistivityUnit.OhmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.PicoohmCentimeter, quantity => quantity.ToUnit(ElectricResistivityUnit.PicoohmCentimeter));
-            unitConverter.SetConversionFunction<ElectricResistivity>(ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.PicoohmMeter, quantity => quantity.ToUnit(ElectricResistivityUnit.PicoohmMeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -381,7 +363,7 @@ public static string GetAbbreviation(ElectricResistivityUnit unit, IFormatProvid
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.KiloohmCentimeter"/>.
         /// </summary>
-        public static ElectricResistivity FromKiloohmsCentimeter(double value)
+        public static ElectricResistivity FromKiloohmsCentimeter(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmCentimeter);
         }
@@ -389,7 +371,7 @@ public static ElectricResistivity FromKiloohmsCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.KiloohmMeter"/>.
         /// </summary>
-        public static ElectricResistivity FromKiloohmMeters(double value)
+        public static ElectricResistivity FromKiloohmMeters(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmMeter);
         }
@@ -397,7 +379,7 @@ public static ElectricResistivity FromKiloohmMeters(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MegaohmCentimeter"/>.
         /// </summary>
-        public static ElectricResistivity FromMegaohmsCentimeter(double value)
+        public static ElectricResistivity FromMegaohmsCentimeter(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmCentimeter);
         }
@@ -405,7 +387,7 @@ public static ElectricResistivity FromMegaohmsCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MegaohmMeter"/>.
         /// </summary>
-        public static ElectricResistivity FromMegaohmMeters(double value)
+        public static ElectricResistivity FromMegaohmMeters(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmMeter);
         }
@@ -413,7 +395,7 @@ public static ElectricResistivity FromMegaohmMeters(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MicroohmCentimeter"/>.
         /// </summary>
-        public static ElectricResistivity FromMicroohmsCentimeter(double value)
+        public static ElectricResistivity FromMicroohmsCentimeter(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmCentimeter);
         }
@@ -421,7 +403,7 @@ public static ElectricResistivity FromMicroohmsCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MicroohmMeter"/>.
         /// </summary>
-        public static ElectricResistivity FromMicroohmMeters(double value)
+        public static ElectricResistivity FromMicroohmMeters(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmMeter);
         }
@@ -429,7 +411,7 @@ public static ElectricResistivity FromMicroohmMeters(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MilliohmCentimeter"/>.
         /// </summary>
-        public static ElectricResistivity FromMilliohmsCentimeter(double value)
+        public static ElectricResistivity FromMilliohmsCentimeter(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmCentimeter);
         }
@@ -437,7 +419,7 @@ public static ElectricResistivity FromMilliohmsCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MilliohmMeter"/>.
         /// </summary>
-        public static ElectricResistivity FromMilliohmMeters(double value)
+        public static ElectricResistivity FromMilliohmMeters(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmMeter);
         }
@@ -445,7 +427,7 @@ public static ElectricResistivity FromMilliohmMeters(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.NanoohmCentimeter"/>.
         /// </summary>
-        public static ElectricResistivity FromNanoohmsCentimeter(double value)
+        public static ElectricResistivity FromNanoohmsCentimeter(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmCentimeter);
         }
@@ -453,7 +435,7 @@ public static ElectricResistivity FromNanoohmsCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.NanoohmMeter"/>.
         /// </summary>
-        public static ElectricResistivity FromNanoohmMeters(double value)
+        public static ElectricResistivity FromNanoohmMeters(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmMeter);
         }
@@ -461,7 +443,7 @@ public static ElectricResistivity FromNanoohmMeters(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.OhmCentimeter"/>.
         /// </summary>
-        public static ElectricResistivity FromOhmsCentimeter(double value)
+        public static ElectricResistivity FromOhmsCentimeter(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.OhmCentimeter);
         }
@@ -469,7 +451,7 @@ public static ElectricResistivity FromOhmsCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.OhmMeter"/>.
         /// </summary>
-        public static ElectricResistivity FromOhmMeters(double value)
+        public static ElectricResistivity FromOhmMeters(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.OhmMeter);
         }
@@ -477,7 +459,7 @@ public static ElectricResistivity FromOhmMeters(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.PicoohmCentimeter"/>.
         /// </summary>
-        public static ElectricResistivity FromPicoohmsCentimeter(double value)
+        public static ElectricResistivity FromPicoohmsCentimeter(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmCentimeter);
         }
@@ -485,7 +467,7 @@ public static ElectricResistivity FromPicoohmsCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.PicoohmMeter"/>.
         /// </summary>
-        public static ElectricResistivity FromPicoohmMeters(double value)
+        public static ElectricResistivity FromPicoohmMeters(QuantityValue value)
         {
             return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmMeter);
         }
@@ -496,7 +478,7 @@ public static ElectricResistivity FromPicoohmMeters(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricResistivity unit value.</returns>
-        public static ElectricResistivity From(double value, ElectricResistivityUnit fromUnit)
+        public static ElectricResistivity From(QuantityValue value, ElectricResistivityUnit fromUnit)
         {
             return new ElectricResistivity(value, fromUnit);
         }
@@ -557,10 +539,7 @@ public static ElectricResistivity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricResistivity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricResistivity, ElectricResistivityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricResistivity, ElectricResistivityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -588,11 +567,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricResistiv
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricResistivity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricResistivity, ElectricResistivityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricResistivity, ElectricResistivityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -613,7 +588,7 @@ public static ElectricResistivityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -624,7 +599,7 @@ public static ElectricResistivityUnit ParseUnit(string str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricResistivityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricResistivityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricResistivityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -639,7 +614,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricResi
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricResistivityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -658,35 +633,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricResistivity"/> from adding two <see cref="ElectricResistivity"/>.</summary>
         public static ElectricResistivity operator +(ElectricResistivity left, ElectricResistivity right)
         {
-            return new ElectricResistivity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricResistivity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricResistivity"/> from subtracting two <see cref="ElectricResistivity"/>.</summary>
         public static ElectricResistivity operator -(ElectricResistivity left, ElectricResistivity right)
         {
-            return new ElectricResistivity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricResistivity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricResistivity"/> from multiplying value and <see cref="ElectricResistivity"/>.</summary>
-        public static ElectricResistivity operator *(double left, ElectricResistivity right)
+        public static ElectricResistivity operator *(QuantityValue left, ElectricResistivity right)
         {
             return new ElectricResistivity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricResistivity"/> from multiplying value and <see cref="ElectricResistivity"/>.</summary>
-        public static ElectricResistivity operator *(ElectricResistivity left, double right)
+        public static ElectricResistivity operator *(ElectricResistivity left, QuantityValue right)
         {
             return new ElectricResistivity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricResistivity"/> from dividing <see cref="ElectricResistivity"/> by value.</summary>
-        public static ElectricResistivity operator /(ElectricResistivity left, double right)
+        public static ElectricResistivity operator /(ElectricResistivity left, QuantityValue right)
         {
             return new ElectricResistivity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricResistivity"/> by <see cref="ElectricResistivity"/>.</summary>
-        public static double operator /(ElectricResistivity left, ElectricResistivity right)
+        public static QuantityValue operator /(ElectricResistivity left, ElectricResistivity right)
         {
             return left.OhmMeters / right.OhmMeters;
         }
@@ -699,7 +674,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <returns>The corresponding inverse quantity, <see cref="ElectricConductivity"/>.</returns>
         public ElectricConductivity Inverse()
         {
-            return ElectricConductivity.FromSiemensPerMeter(1 / OhmMeters);
+            return UnitConverter.Default.ConvertTo(Value, Unit, ElectricConductivity.Info);
         }
 
         #endregion
@@ -709,97 +684,111 @@ public ElectricConductivity Inverse()
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricResistivity left, ElectricResistivity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricResistivity left, ElectricResistivity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricResistivity left, ElectricResistivity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricResistivity left, ElectricResistivity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricResistivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricResistivity other, ElectricResistivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricResistivity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricResistivity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricResistivity left, ElectricResistivity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricResistivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricResistivity other, ElectricResistivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricResistivity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricResistivity,ElectricResistivity)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricResistivity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricResistivity left, ElectricResistivity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricResistivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricResistivity other, ElectricResistivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricResistivity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricResistivity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricResistivity"/>, this method delegates to
+        ///     <see cref="Equals(ElectricResistivity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricResistivity otherQuantity))
+            if (obj is not ElectricResistivity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricResistivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricResistivity other, ElectricResistivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricResistivity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricResistivity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricResistivity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricResistivity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricResistivity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricResistivity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricResistivity otherQuantity)) throw new ArgumentException("Expected type ElectricResistivity.", nameof(obj));
+            if (obj is not ElectricResistivity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricResistivity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricResistivity"/> with another <see cref="ElectricResistivity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricResistivity"/> with another <see cref="ElectricResistivity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -811,155 +800,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricResistivity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricResistivityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricResistivityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricResistivity to another ElectricResistivity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricResistivity with the specified unit.</returns>
-        public ElectricResistivity ToUnit(ElectricResistivityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricResistivity"/> to another <see cref="ElectricResistivity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricResistivity with the specified unit.</returns>
-        public ElectricResistivity ToUnit(ElectricResistivityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricResistivity), Unit, typeof(ElectricResistivity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricResistivity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricResistivity"/> to another <see cref="ElectricResistivity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricResistivity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricResistivityUnit unit, [NotNullWhen(true)] out ElectricResistivity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricResistivity? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricResistivityUnit -> BaseUnit
-                (ElectricResistivityUnit.KiloohmCentimeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value / 100) * 1e3d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.KiloohmMeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value) * 1e3d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.MegaohmCentimeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value / 100) * 1e6d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.MegaohmMeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value) * 1e6d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.MicroohmCentimeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value / 100) * 1e-6d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.MicroohmMeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value) * 1e-6d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.MilliohmCentimeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value / 100) * 1e-3d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.MilliohmMeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value) * 1e-3d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.NanoohmCentimeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value / 100) * 1e-9d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.NanoohmMeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value) * 1e-9d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.OhmCentimeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity(_value / 100, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.PicoohmCentimeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value / 100) * 1e-12d, ElectricResistivityUnit.OhmMeter),
-                (ElectricResistivityUnit.PicoohmMeter, ElectricResistivityUnit.OhmMeter) => new ElectricResistivity((_value) * 1e-12d, ElectricResistivityUnit.OhmMeter),
-
-                // BaseUnit -> ElectricResistivityUnit
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.KiloohmCentimeter) => new ElectricResistivity((_value * 100) / 1e3d, ElectricResistivityUnit.KiloohmCentimeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.KiloohmMeter) => new ElectricResistivity((_value) / 1e3d, ElectricResistivityUnit.KiloohmMeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MegaohmCentimeter) => new ElectricResistivity((_value * 100) / 1e6d, ElectricResistivityUnit.MegaohmCentimeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MegaohmMeter) => new ElectricResistivity((_value) / 1e6d, ElectricResistivityUnit.MegaohmMeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MicroohmCentimeter) => new ElectricResistivity((_value * 100) / 1e-6d, ElectricResistivityUnit.MicroohmCentimeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MicroohmMeter) => new ElectricResistivity((_value) / 1e-6d, ElectricResistivityUnit.MicroohmMeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MilliohmCentimeter) => new ElectricResistivity((_value * 100) / 1e-3d, ElectricResistivityUnit.MilliohmCentimeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.MilliohmMeter) => new ElectricResistivity((_value) / 1e-3d, ElectricResistivityUnit.MilliohmMeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.NanoohmCentimeter) => new ElectricResistivity((_value * 100) / 1e-9d, ElectricResistivityUnit.NanoohmCentimeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.NanoohmMeter) => new ElectricResistivity((_value) / 1e-9d, ElectricResistivityUnit.NanoohmMeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.OhmCentimeter) => new ElectricResistivity(_value * 100, ElectricResistivityUnit.OhmCentimeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.PicoohmCentimeter) => new ElectricResistivity((_value * 100) / 1e-12d, ElectricResistivityUnit.PicoohmCentimeter),
-                (ElectricResistivityUnit.OhmMeter, ElectricResistivityUnit.PicoohmMeter) => new ElectricResistivity((_value) / 1e-12d, ElectricResistivityUnit.PicoohmMeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricResistivityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistivityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricResistivityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistivityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricResistivityUnit> IQuantity<ElectricResistivityUnit>.ToUnit(ElectricResistivityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -973,11 +816,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
index 35f23bb0ff..c7c8efd3e7 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Charge_density
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricSurfaceChargeDensity :
-        IArithmeticQuantity<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit>,
+        ILinearQuantity<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensity, double>,
+        IDivisionOperators<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensity, QuantityValue>,
+        IMultiplyOperators<ElectricSurfaceChargeDensity, Area, ElectricCharge>,
         IComparisonOperators<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensity, bool>,
         IParsable<ElectricSurfaceChargeDensity>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static ElectricSurfaceChargeDensityInfo CreateDefault(Func<IEnumerable<Un
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricSurfaceChargeDensity"/> is [T][L^-2][I].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricSurfaceChargeDensity"/> is TL^-2I.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 0, 1, 1, 0, 0, 0);
 
@@ -120,17 +120,19 @@ public static ElectricSurfaceChargeDensityInfo CreateDefault(Func<IEnumerable<Un
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricSurfaceChargeDensityUnit}"/> representing the default unit mappings for ElectricSurfaceChargeDensity.</returns>
             public static IEnumerable<UnitDefinition<ElectricSurfaceChargeDensityUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, "CoulombPerSquareCentimeter", "CoulombsPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, "CoulombPerSquareInch", "CoulombsPerSquareInch", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, "CoulombPerSquareCentimeter", "CoulombsPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, "CoulombPerSquareInch", "CoulombsPerSquareInch", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(16129, 25000000)
+                );
                 yield return new (ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, "CoulombPerSquareMeter", "CoulombsPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
             }
         }
 
         static ElectricSurfaceChargeDensity()
         {
-            Info = ElectricSurfaceChargeDensityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricSurfaceChargeDensityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -138,7 +140,7 @@ static ElectricSurfaceChargeDensity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricSurfaceChargeDensity(double value, ElectricSurfaceChargeDensityUnit unit)
+        public ElectricSurfaceChargeDensity(QuantityValue value, ElectricSurfaceChargeDensityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -152,7 +154,7 @@ public ElectricSurfaceChargeDensity(double value, ElectricSurfaceChargeDensityUn
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricSurfaceChargeDensity(double value, UnitSystem unitSystem)
+        public ElectricSurfaceChargeDensity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -163,7 +165,8 @@ public ElectricSurfaceChargeDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricSurfaceChargeDensity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit> Info { get; }
@@ -192,10 +195,8 @@ public ElectricSurfaceChargeDensity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricSurfaceChargeDensityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -229,42 +230,24 @@ public ElectricSurfaceChargeDensity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter"/>
         /// </summary>
-        public double CoulombsPerSquareCentimeter => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
+        public QuantityValue CoulombsPerSquareCentimeter => this.As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch"/>
         /// </summary>
-        public double CoulombsPerSquareInch => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
+        public QuantityValue CoulombsPerSquareInch => this.As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter"/>
         /// </summary>
-        public double CoulombsPerSquareMeter => As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
+        public QuantityValue CoulombsPerSquareMeter => this.As(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricSurfaceChargeDensityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity>(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, quantity => quantity.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
-            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity>(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, quantity => quantity.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity>(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricSurfaceChargeDensityUnit
-            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity>(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, quantity => quantity.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter));
-            unitConverter.SetConversionFunction<ElectricSurfaceChargeDensity>(ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, quantity => quantity.ToUnit(ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -293,7 +276,7 @@ public static string GetAbbreviation(ElectricSurfaceChargeDensityUnit unit, IFor
         /// <summary>
         ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter"/>.
         /// </summary>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(double value)
+        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(QuantityValue value)
         {
             return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
         }
@@ -301,7 +284,7 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(doubl
         /// <summary>
         ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch"/>.
         /// </summary>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(double value)
+        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(QuantityValue value)
         {
             return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
         }
@@ -309,7 +292,7 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(double valu
         /// <summary>
         ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter"/>.
         /// </summary>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(double value)
+        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(QuantityValue value)
         {
             return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
         }
@@ -320,7 +303,7 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(double val
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricSurfaceChargeDensity unit value.</returns>
-        public static ElectricSurfaceChargeDensity From(double value, ElectricSurfaceChargeDensityUnit fromUnit)
+        public static ElectricSurfaceChargeDensity From(QuantityValue value, ElectricSurfaceChargeDensityUnit fromUnit)
         {
             return new ElectricSurfaceChargeDensity(value, fromUnit);
         }
@@ -381,10 +364,7 @@ public static ElectricSurfaceChargeDensity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricSurfaceChargeDensity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -412,11 +392,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricSurfaceC
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricSurfaceChargeDensity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -437,7 +413,7 @@ public static ElectricSurfaceChargeDensityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -448,7 +424,7 @@ public static ElectricSurfaceChargeDensityUnit ParseUnit(string str, IFormatProv
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricSurfaceChargeDensityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricSurfaceChargeDensityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricSurfaceChargeDensityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -463,7 +439,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricSurf
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricSurfaceChargeDensityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -482,137 +458,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from adding two <see cref="ElectricSurfaceChargeDensity"/>.</summary>
         public static ElectricSurfaceChargeDensity operator +(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
         {
-            return new ElectricSurfaceChargeDensity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricSurfaceChargeDensity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from subtracting two <see cref="ElectricSurfaceChargeDensity"/>.</summary>
         public static ElectricSurfaceChargeDensity operator -(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
         {
-            return new ElectricSurfaceChargeDensity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricSurfaceChargeDensity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from multiplying value and <see cref="ElectricSurfaceChargeDensity"/>.</summary>
-        public static ElectricSurfaceChargeDensity operator *(double left, ElectricSurfaceChargeDensity right)
+        public static ElectricSurfaceChargeDensity operator *(QuantityValue left, ElectricSurfaceChargeDensity right)
         {
             return new ElectricSurfaceChargeDensity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from multiplying value and <see cref="ElectricSurfaceChargeDensity"/>.</summary>
-        public static ElectricSurfaceChargeDensity operator *(ElectricSurfaceChargeDensity left, double right)
+        public static ElectricSurfaceChargeDensity operator *(ElectricSurfaceChargeDensity left, QuantityValue right)
         {
             return new ElectricSurfaceChargeDensity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricSurfaceChargeDensity"/> from dividing <see cref="ElectricSurfaceChargeDensity"/> by value.</summary>
-        public static ElectricSurfaceChargeDensity operator /(ElectricSurfaceChargeDensity left, double right)
+        public static ElectricSurfaceChargeDensity operator /(ElectricSurfaceChargeDensity left, QuantityValue right)
         {
             return new ElectricSurfaceChargeDensity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricSurfaceChargeDensity"/> by <see cref="ElectricSurfaceChargeDensity"/>.</summary>
-        public static double operator /(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
+        public static QuantityValue operator /(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
         {
             return left.CoulombsPerSquareMeter / right.CoulombsPerSquareMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="ElectricCharge"/> from <see cref="ElectricSurfaceChargeDensity"/> * <see cref="Area"/>.</summary>
+        public static ElectricCharge operator *(ElectricSurfaceChargeDensity electricSurfaceChargeDensity, Area area)
+        {
+            return ElectricCharge.FromCoulombs(electricSurfaceChargeDensity.CoulombsPerSquareMeter * area.SquareMeters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricSurfaceChargeDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricSurfaceChargeDensity other, ElectricSurfaceChargeDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricSurfaceChargeDensity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricSurfaceChargeDensity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricSurfaceChargeDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricSurfaceChargeDensity other, ElectricSurfaceChargeDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricSurfaceChargeDensity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricSurfaceChargeDensity,ElectricSurfaceChargeDensity)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricSurfaceChargeDensity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricSurfaceChargeDensity left, ElectricSurfaceChargeDensity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricSurfaceChargeDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricSurfaceChargeDensity other, ElectricSurfaceChargeDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricSurfaceChargeDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricSurfaceChargeDensity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricSurfaceChargeDensity"/>, this method delegates to
+        ///     <see cref="Equals(ElectricSurfaceChargeDensity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricSurfaceChargeDensity otherQuantity))
+            if (obj is not ElectricSurfaceChargeDensity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricSurfaceChargeDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricSurfaceChargeDensity other, ElectricSurfaceChargeDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricSurfaceChargeDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricSurfaceChargeDensity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricSurfaceChargeDensity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricSurfaceChargeDensity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricSurfaceChargeDensity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricSurfaceChargeDensity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricSurfaceChargeDensity otherQuantity)) throw new ArgumentException("Expected type ElectricSurfaceChargeDensity.", nameof(obj));
+            if (obj is not ElectricSurfaceChargeDensity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricSurfaceChargeDensity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricSurfaceChargeDensity"/> with another <see cref="ElectricSurfaceChargeDensity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricSurfaceChargeDensity"/> with another <see cref="ElectricSurfaceChargeDensity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -624,135 +624,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricSurfaceChargeDensity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricSurfaceChargeDensityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricSurfaceChargeDensityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricSurfaceChargeDensity to another ElectricSurfaceChargeDensity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricSurfaceChargeDensity with the specified unit.</returns>
-        public ElectricSurfaceChargeDensity ToUnit(ElectricSurfaceChargeDensityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricSurfaceChargeDensity"/> to another <see cref="ElectricSurfaceChargeDensity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricSurfaceChargeDensity with the specified unit.</returns>
-        public ElectricSurfaceChargeDensity ToUnit(ElectricSurfaceChargeDensityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricSurfaceChargeDensity), Unit, typeof(ElectricSurfaceChargeDensity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricSurfaceChargeDensity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricSurfaceChargeDensity"/> to another <see cref="ElectricSurfaceChargeDensity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricSurfaceChargeDensity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricSurfaceChargeDensityUnit unit, [NotNullWhen(true)] out ElectricSurfaceChargeDensity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricSurfaceChargeDensity? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricSurfaceChargeDensityUnit -> BaseUnit
-                (ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter) => new ElectricSurfaceChargeDensity(_value * 1.0e4, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter),
-                (ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter) => new ElectricSurfaceChargeDensity(_value / 0.00064516, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter),
-
-                // BaseUnit -> ElectricSurfaceChargeDensityUnit
-                (ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter) => new ElectricSurfaceChargeDensity(_value / 1.0e4, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter),
-                (ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch) => new ElectricSurfaceChargeDensity(_value * 0.00064516, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricSurfaceChargeDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricSurfaceChargeDensityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricSurfaceChargeDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricSurfaceChargeDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricSurfaceChargeDensityUnit> IQuantity<ElectricSurfaceChargeDensityUnit>.ToUnit(ElectricSurfaceChargeDensityUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -764,11 +640,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricSusceptance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricSusceptance.g.cs
index c6f5ca9ef8..07c01295e5 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricSusceptance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricSusceptance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Electrical_susceptance
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ElectricSusceptance :
-        IArithmeticQuantity<ElectricSusceptance, ElectricSusceptanceUnit>,
+        ILinearQuantity<ElectricSusceptance, ElectricSusceptanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ElectricSusceptance, ElectricSusceptance, double>,
+        IDivisionOperators<ElectricSusceptance, ElectricSusceptance, QuantityValue>,
         IComparisonOperators<ElectricSusceptance, ElectricSusceptance, bool>,
         IParsable<ElectricSusceptance>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static ElectricSusceptanceInfo CreateDefault(Func<IEnumerable<UnitDefinit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricSusceptance"/> is [T^3][L^-2][M^-1][I^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ElectricSusceptance"/> is T^3L^-2M^-1I^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0);
 
@@ -120,30 +119,58 @@ public static ElectricSusceptanceInfo CreateDefault(Func<IEnumerable<UnitDefinit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ElectricSusceptanceUnit}"/> representing the default unit mappings for ElectricSusceptance.</returns>
             public static IEnumerable<UnitDefinition<ElectricSusceptanceUnit>> GetDefaultMappings()
             {
-                yield return new (ElectricSusceptanceUnit.Gigamho, "Gigamho", "Gigamhos", BaseUnits.Undefined);
-                yield return new (ElectricSusceptanceUnit.Gigasiemens, "Gigasiemens", "Gigasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricSusceptanceUnit.Kilomho, "Kilomho", "Kilomhos", BaseUnits.Undefined);
-                yield return new (ElectricSusceptanceUnit.Kilosiemens, "Kilosiemens", "Kilosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricSusceptanceUnit.Megamho, "Megamho", "Megamhos", BaseUnits.Undefined);
-                yield return new (ElectricSusceptanceUnit.Megasiemens, "Megasiemens", "Megasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricSusceptanceUnit.Mho, "Mho", "Mhos", BaseUnits.Undefined);
-                yield return new (ElectricSusceptanceUnit.Micromho, "Micromho", "Micromhos", BaseUnits.Undefined);
-                yield return new (ElectricSusceptanceUnit.Microsiemens, "Microsiemens", "Microsiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
-                yield return new (ElectricSusceptanceUnit.Millimho, "Millimho", "Millimhos", BaseUnits.Undefined);
-                yield return new (ElectricSusceptanceUnit.Millisiemens, "Millisiemens", "Millisiemens", BaseUnits.Undefined);
-                yield return new (ElectricSusceptanceUnit.Nanomho, "Nanomho", "Nanomhos", BaseUnits.Undefined);
-                yield return new (ElectricSusceptanceUnit.Nanosiemens, "Nanosiemens", "Nanosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricSusceptanceUnit.Gigamho, "Gigamho", "Gigamhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricSusceptanceUnit.Gigasiemens, "Gigasiemens", "Gigasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ElectricSusceptanceUnit.Kilomho, "Kilomho", "Kilomhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricSusceptanceUnit.Kilosiemens, "Kilosiemens", "Kilosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ElectricSusceptanceUnit.Megamho, "Megamho", "Megamhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricSusceptanceUnit.Megasiemens, "Megasiemens", "Megasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ElectricSusceptanceUnit.Mho, "Mho", "Mhos", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (ElectricSusceptanceUnit.Micromho, "Micromho", "Micromhos", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (ElectricSusceptanceUnit.Microsiemens, "Microsiemens", "Microsiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     1000000
+                );
+                yield return new (ElectricSusceptanceUnit.Millimho, "Millimho", "Millimhos", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (ElectricSusceptanceUnit.Millisiemens, "Millisiemens", "Millisiemens", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (ElectricSusceptanceUnit.Nanomho, "Nanomho", "Nanomhos", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (ElectricSusceptanceUnit.Nanosiemens, "Nanosiemens", "Nanosiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere),
+                     1000000000
+                );
                 yield return new (ElectricSusceptanceUnit.Siemens, "Siemens", "Siemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (ElectricSusceptanceUnit.Teramho, "Teramho", "Teramhos", BaseUnits.Undefined);
-                yield return new (ElectricSusceptanceUnit.Terasiemens, "Terasiemens", "Terasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (ElectricSusceptanceUnit.Teramho, "Teramho", "Teramhos", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (ElectricSusceptanceUnit.Terasiemens, "Terasiemens", "Terasiemens", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(1, 1000000000000)
+                );
             }
         }
 
         static ElectricSusceptance()
         {
-            Info = ElectricSusceptanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ElectricSusceptanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -151,7 +178,7 @@ static ElectricSusceptance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ElectricSusceptance(double value, ElectricSusceptanceUnit unit)
+        public ElectricSusceptance(QuantityValue value, ElectricSusceptanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -165,7 +192,7 @@ public ElectricSusceptance(double value, ElectricSusceptanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ElectricSusceptance(double value, UnitSystem unitSystem)
+        public ElectricSusceptance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -176,7 +203,8 @@ public ElectricSusceptance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ElectricSusceptance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ElectricSusceptance, ElectricSusceptanceUnit> Info { get; }
@@ -205,10 +233,8 @@ public ElectricSusceptance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ElectricSusceptanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -242,133 +268,89 @@ public ElectricSusceptance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Gigamho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Gigamho"/>
         /// </summary>
-        public double Gigamhos => As(ElectricSusceptanceUnit.Gigamho);
+        public QuantityValue Gigamhos => this.As(ElectricSusceptanceUnit.Gigamho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Gigasiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Gigasiemens"/>
         /// </summary>
-        public double Gigasiemens => As(ElectricSusceptanceUnit.Gigasiemens);
+        public QuantityValue Gigasiemens => this.As(ElectricSusceptanceUnit.Gigasiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Kilomho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Kilomho"/>
         /// </summary>
-        public double Kilomhos => As(ElectricSusceptanceUnit.Kilomho);
+        public QuantityValue Kilomhos => this.As(ElectricSusceptanceUnit.Kilomho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Kilosiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Kilosiemens"/>
         /// </summary>
-        public double Kilosiemens => As(ElectricSusceptanceUnit.Kilosiemens);
+        public QuantityValue Kilosiemens => this.As(ElectricSusceptanceUnit.Kilosiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Megamho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Megamho"/>
         /// </summary>
-        public double Megamhos => As(ElectricSusceptanceUnit.Megamho);
+        public QuantityValue Megamhos => this.As(ElectricSusceptanceUnit.Megamho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Megasiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Megasiemens"/>
         /// </summary>
-        public double Megasiemens => As(ElectricSusceptanceUnit.Megasiemens);
+        public QuantityValue Megasiemens => this.As(ElectricSusceptanceUnit.Megasiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Mho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Mho"/>
         /// </summary>
-        public double Mhos => As(ElectricSusceptanceUnit.Mho);
+        public QuantityValue Mhos => this.As(ElectricSusceptanceUnit.Mho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Micromho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Micromho"/>
         /// </summary>
-        public double Micromhos => As(ElectricSusceptanceUnit.Micromho);
+        public QuantityValue Micromhos => this.As(ElectricSusceptanceUnit.Micromho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Microsiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Microsiemens"/>
         /// </summary>
-        public double Microsiemens => As(ElectricSusceptanceUnit.Microsiemens);
+        public QuantityValue Microsiemens => this.As(ElectricSusceptanceUnit.Microsiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Millimho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Millimho"/>
         /// </summary>
-        public double Millimhos => As(ElectricSusceptanceUnit.Millimho);
+        public QuantityValue Millimhos => this.As(ElectricSusceptanceUnit.Millimho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Millisiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Millisiemens"/>
         /// </summary>
-        public double Millisiemens => As(ElectricSusceptanceUnit.Millisiemens);
+        public QuantityValue Millisiemens => this.As(ElectricSusceptanceUnit.Millisiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Nanomho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Nanomho"/>
         /// </summary>
-        public double Nanomhos => As(ElectricSusceptanceUnit.Nanomho);
+        public QuantityValue Nanomhos => this.As(ElectricSusceptanceUnit.Nanomho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Nanosiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Nanosiemens"/>
         /// </summary>
-        public double Nanosiemens => As(ElectricSusceptanceUnit.Nanosiemens);
+        public QuantityValue Nanosiemens => this.As(ElectricSusceptanceUnit.Nanosiemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Siemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Siemens"/>
         /// </summary>
-        public double Siemens => As(ElectricSusceptanceUnit.Siemens);
+        public QuantityValue Siemens => this.As(ElectricSusceptanceUnit.Siemens);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Teramho"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Teramho"/>
         /// </summary>
-        public double Teramhos => As(ElectricSusceptanceUnit.Teramho);
+        public QuantityValue Teramhos => this.As(ElectricSusceptanceUnit.Teramho);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Terasiemens"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ElectricSusceptanceUnit.Terasiemens"/>
         /// </summary>
-        public double Terasiemens => As(ElectricSusceptanceUnit.Terasiemens);
+        public QuantityValue Terasiemens => this.As(ElectricSusceptanceUnit.Terasiemens);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ElectricSusceptanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Gigamho, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Gigasiemens, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Kilomho, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Kilosiemens, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Megamho, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Megasiemens, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Mho, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Micromho, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Microsiemens, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Millimho, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Millisiemens, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Nanomho, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Nanosiemens, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Teramho, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Terasiemens, ElectricSusceptanceUnit.Siemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Siemens));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Siemens, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ElectricSusceptanceUnit
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Gigamho, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Gigamho));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Gigasiemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Gigasiemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Kilomho, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Kilomho));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Kilosiemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Kilosiemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Megamho, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Megamho));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Megasiemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Megasiemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Mho, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Mho));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Micromho, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Micromho));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Microsiemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Microsiemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Millimho, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Millimho));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Millisiemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Millisiemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Nanomho, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Nanomho));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Nanosiemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Nanosiemens));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Teramho, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Teramho));
-            unitConverter.SetConversionFunction<ElectricSusceptance>(ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Terasiemens, quantity => quantity.ToUnit(ElectricSusceptanceUnit.Terasiemens));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -397,7 +379,7 @@ public static string GetAbbreviation(ElectricSusceptanceUnit unit, IFormatProvid
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Gigamho"/>.
         /// </summary>
-        public static ElectricSusceptance FromGigamhos(double value)
+        public static ElectricSusceptance FromGigamhos(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Gigamho);
         }
@@ -405,7 +387,7 @@ public static ElectricSusceptance FromGigamhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Gigasiemens"/>.
         /// </summary>
-        public static ElectricSusceptance FromGigasiemens(double value)
+        public static ElectricSusceptance FromGigasiemens(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Gigasiemens);
         }
@@ -413,7 +395,7 @@ public static ElectricSusceptance FromGigasiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Kilomho"/>.
         /// </summary>
-        public static ElectricSusceptance FromKilomhos(double value)
+        public static ElectricSusceptance FromKilomhos(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Kilomho);
         }
@@ -421,7 +403,7 @@ public static ElectricSusceptance FromKilomhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Kilosiemens"/>.
         /// </summary>
-        public static ElectricSusceptance FromKilosiemens(double value)
+        public static ElectricSusceptance FromKilosiemens(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Kilosiemens);
         }
@@ -429,7 +411,7 @@ public static ElectricSusceptance FromKilosiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Megamho"/>.
         /// </summary>
-        public static ElectricSusceptance FromMegamhos(double value)
+        public static ElectricSusceptance FromMegamhos(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Megamho);
         }
@@ -437,7 +419,7 @@ public static ElectricSusceptance FromMegamhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Megasiemens"/>.
         /// </summary>
-        public static ElectricSusceptance FromMegasiemens(double value)
+        public static ElectricSusceptance FromMegasiemens(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Megasiemens);
         }
@@ -445,7 +427,7 @@ public static ElectricSusceptance FromMegasiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Mho"/>.
         /// </summary>
-        public static ElectricSusceptance FromMhos(double value)
+        public static ElectricSusceptance FromMhos(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Mho);
         }
@@ -453,7 +435,7 @@ public static ElectricSusceptance FromMhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Micromho"/>.
         /// </summary>
-        public static ElectricSusceptance FromMicromhos(double value)
+        public static ElectricSusceptance FromMicromhos(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Micromho);
         }
@@ -461,7 +443,7 @@ public static ElectricSusceptance FromMicromhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Microsiemens"/>.
         /// </summary>
-        public static ElectricSusceptance FromMicrosiemens(double value)
+        public static ElectricSusceptance FromMicrosiemens(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Microsiemens);
         }
@@ -469,7 +451,7 @@ public static ElectricSusceptance FromMicrosiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Millimho"/>.
         /// </summary>
-        public static ElectricSusceptance FromMillimhos(double value)
+        public static ElectricSusceptance FromMillimhos(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Millimho);
         }
@@ -477,7 +459,7 @@ public static ElectricSusceptance FromMillimhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Millisiemens"/>.
         /// </summary>
-        public static ElectricSusceptance FromMillisiemens(double value)
+        public static ElectricSusceptance FromMillisiemens(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Millisiemens);
         }
@@ -485,7 +467,7 @@ public static ElectricSusceptance FromMillisiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Nanomho"/>.
         /// </summary>
-        public static ElectricSusceptance FromNanomhos(double value)
+        public static ElectricSusceptance FromNanomhos(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Nanomho);
         }
@@ -493,7 +475,7 @@ public static ElectricSusceptance FromNanomhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Nanosiemens"/>.
         /// </summary>
-        public static ElectricSusceptance FromNanosiemens(double value)
+        public static ElectricSusceptance FromNanosiemens(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Nanosiemens);
         }
@@ -501,7 +483,7 @@ public static ElectricSusceptance FromNanosiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Siemens"/>.
         /// </summary>
-        public static ElectricSusceptance FromSiemens(double value)
+        public static ElectricSusceptance FromSiemens(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Siemens);
         }
@@ -509,7 +491,7 @@ public static ElectricSusceptance FromSiemens(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Teramho"/>.
         /// </summary>
-        public static ElectricSusceptance FromTeramhos(double value)
+        public static ElectricSusceptance FromTeramhos(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Teramho);
         }
@@ -517,7 +499,7 @@ public static ElectricSusceptance FromTeramhos(double value)
         /// <summary>
         ///     Creates a <see cref="ElectricSusceptance"/> from <see cref="ElectricSusceptanceUnit.Terasiemens"/>.
         /// </summary>
-        public static ElectricSusceptance FromTerasiemens(double value)
+        public static ElectricSusceptance FromTerasiemens(QuantityValue value)
         {
             return new ElectricSusceptance(value, ElectricSusceptanceUnit.Terasiemens);
         }
@@ -528,7 +510,7 @@ public static ElectricSusceptance FromTerasiemens(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricSusceptance unit value.</returns>
-        public static ElectricSusceptance From(double value, ElectricSusceptanceUnit fromUnit)
+        public static ElectricSusceptance From(QuantityValue value, ElectricSusceptanceUnit fromUnit)
         {
             return new ElectricSusceptance(value, fromUnit);
         }
@@ -589,10 +571,7 @@ public static ElectricSusceptance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ElectricSusceptance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ElectricSusceptance, ElectricSusceptanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ElectricSusceptance, ElectricSusceptanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -620,11 +599,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ElectricSuscepta
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricSusceptance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ElectricSusceptance, ElectricSusceptanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ElectricSusceptance, ElectricSusceptanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -645,7 +620,7 @@ public static ElectricSusceptanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -656,7 +631,7 @@ public static ElectricSusceptanceUnit ParseUnit(string str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ElectricSusceptanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ElectricSusceptanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricSusceptanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -671,7 +646,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ElectricSusc
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ElectricSusceptanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -690,35 +665,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ElectricSusceptance"/> from adding two <see cref="ElectricSusceptance"/>.</summary>
         public static ElectricSusceptance operator +(ElectricSusceptance left, ElectricSusceptance right)
         {
-            return new ElectricSusceptance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricSusceptance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricSusceptance"/> from subtracting two <see cref="ElectricSusceptance"/>.</summary>
         public static ElectricSusceptance operator -(ElectricSusceptance left, ElectricSusceptance right)
         {
-            return new ElectricSusceptance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ElectricSusceptance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricSusceptance"/> from multiplying value and <see cref="ElectricSusceptance"/>.</summary>
-        public static ElectricSusceptance operator *(double left, ElectricSusceptance right)
+        public static ElectricSusceptance operator *(QuantityValue left, ElectricSusceptance right)
         {
             return new ElectricSusceptance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ElectricSusceptance"/> from multiplying value and <see cref="ElectricSusceptance"/>.</summary>
-        public static ElectricSusceptance operator *(ElectricSusceptance left, double right)
+        public static ElectricSusceptance operator *(ElectricSusceptance left, QuantityValue right)
         {
             return new ElectricSusceptance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ElectricSusceptance"/> from dividing <see cref="ElectricSusceptance"/> by value.</summary>
-        public static ElectricSusceptance operator /(ElectricSusceptance left, double right)
+        public static ElectricSusceptance operator /(ElectricSusceptance left, QuantityValue right)
         {
             return new ElectricSusceptance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ElectricSusceptance"/> by <see cref="ElectricSusceptance"/>.</summary>
-        public static double operator /(ElectricSusceptance left, ElectricSusceptance right)
+        public static QuantityValue operator /(ElectricSusceptance left, ElectricSusceptance right)
         {
             return left.Siemens / right.Siemens;
         }
@@ -730,97 +705,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ElectricSusceptance left, ElectricSusceptance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ElectricSusceptance left, ElectricSusceptance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ElectricSusceptance left, ElectricSusceptance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ElectricSusceptance left, ElectricSusceptance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ElectricSusceptance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricSusceptance other, ElectricSusceptance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricSusceptance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ElectricSusceptance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ElectricSusceptance left, ElectricSusceptance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ElectricSusceptance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ElectricSusceptance other, ElectricSusceptance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ElectricSusceptance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ElectricSusceptance,ElectricSusceptance)"/>.
+        ///     See that operator (and <see cref="Equals(ElectricSusceptance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ElectricSusceptance left, ElectricSusceptance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricSusceptance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricSusceptance other, ElectricSusceptance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ElectricSusceptance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ElectricSusceptance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ElectricSusceptance"/>, this method delegates to
+        ///     <see cref="Equals(ElectricSusceptance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ElectricSusceptance otherQuantity))
+            if (obj is not ElectricSusceptance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ElectricSusceptance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ElectricSusceptance other, ElectricSusceptance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ElectricSusceptance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ElectricSusceptance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ElectricSusceptance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ElectricSusceptance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ElectricSusceptance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ElectricSusceptance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ElectricSusceptance otherQuantity)) throw new ArgumentException("Expected type ElectricSusceptance.", nameof(obj));
+            if (obj is not ElectricSusceptance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ElectricSusceptance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ElectricSusceptance"/> with another <see cref="ElectricSusceptance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ElectricSusceptance"/> with another <see cref="ElectricSusceptance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -832,159 +821,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ElectricSusceptance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ElectricSusceptanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ElectricSusceptanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ElectricSusceptance to another ElectricSusceptance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ElectricSusceptance with the specified unit.</returns>
-        public ElectricSusceptance ToUnit(ElectricSusceptanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ElectricSusceptance"/> to another <see cref="ElectricSusceptance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ElectricSusceptance with the specified unit.</returns>
-        public ElectricSusceptance ToUnit(ElectricSusceptanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ElectricSusceptance), Unit, typeof(ElectricSusceptance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ElectricSusceptance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="ElectricSusceptance"/> to another <see cref="ElectricSusceptance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ElectricSusceptance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ElectricSusceptanceUnit unit, [NotNullWhen(true)] out ElectricSusceptance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ElectricSusceptance? convertedOrNull = (Unit, unit) switch
-            {
-                // ElectricSusceptanceUnit -> BaseUnit
-                (ElectricSusceptanceUnit.Gigamho, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e9d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Gigasiemens, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e9d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Kilomho, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e3d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Kilosiemens, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e3d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Megamho, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e6d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Megasiemens, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e6d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Mho, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance(_value, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Micromho, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e-6d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Microsiemens, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e-6d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Millimho, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e-3d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Millisiemens, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e-3d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Nanomho, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e-9d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Nanosiemens, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e-9d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Teramho, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e12d, ElectricSusceptanceUnit.Siemens),
-                (ElectricSusceptanceUnit.Terasiemens, ElectricSusceptanceUnit.Siemens) => new ElectricSusceptance((_value) * 1e12d, ElectricSusceptanceUnit.Siemens),
-
-                // BaseUnit -> ElectricSusceptanceUnit
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Gigamho) => new ElectricSusceptance((_value) / 1e9d, ElectricSusceptanceUnit.Gigamho),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Gigasiemens) => new ElectricSusceptance((_value) / 1e9d, ElectricSusceptanceUnit.Gigasiemens),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Kilomho) => new ElectricSusceptance((_value) / 1e3d, ElectricSusceptanceUnit.Kilomho),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Kilosiemens) => new ElectricSusceptance((_value) / 1e3d, ElectricSusceptanceUnit.Kilosiemens),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Megamho) => new ElectricSusceptance((_value) / 1e6d, ElectricSusceptanceUnit.Megamho),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Megasiemens) => new ElectricSusceptance((_value) / 1e6d, ElectricSusceptanceUnit.Megasiemens),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Mho) => new ElectricSusceptance(_value, ElectricSusceptanceUnit.Mho),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Micromho) => new ElectricSusceptance((_value) / 1e-6d, ElectricSusceptanceUnit.Micromho),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Microsiemens) => new ElectricSusceptance((_value) / 1e-6d, ElectricSusceptanceUnit.Microsiemens),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Millimho) => new ElectricSusceptance((_value) / 1e-3d, ElectricSusceptanceUnit.Millimho),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Millisiemens) => new ElectricSusceptance((_value) / 1e-3d, ElectricSusceptanceUnit.Millisiemens),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Nanomho) => new ElectricSusceptance((_value) / 1e-9d, ElectricSusceptanceUnit.Nanomho),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Nanosiemens) => new ElectricSusceptance((_value) / 1e-9d, ElectricSusceptanceUnit.Nanosiemens),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Teramho) => new ElectricSusceptance((_value) / 1e12d, ElectricSusceptanceUnit.Teramho),
-                (ElectricSusceptanceUnit.Siemens, ElectricSusceptanceUnit.Terasiemens) => new ElectricSusceptance((_value) / 1e12d, ElectricSusceptanceUnit.Terasiemens),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ElectricSusceptanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricSusceptanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ElectricSusceptanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricSusceptanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ElectricSusceptanceUnit> IQuantity<ElectricSusceptanceUnit>.ToUnit(ElectricSusceptanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -998,11 +837,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
index 982a1785f2..5b6c1e1d60 100644
--- a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     The joule, symbol J, is a derived unit of energy, work, or amount of heat in the International System of Units. It is equal to the energy transferred (or work done) when applying a force of one newton through a distance of one metre (1 newton metre or N·m), or in passing an electric current of one ampere through a resistance of one ohm for one second. Many other units of energy are included. Please do not confuse this definition of the calorie with the one colloquially used by the food industry, the large calorie, which is equivalent to 1 kcal. Thermochemical definition of the calorie is used. For BTU, the IT definition is used.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Energy :
-        IArithmeticQuantity<Energy, EnergyUnit>,
+        ILinearQuantity<Energy, EnergyUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Energy, Energy, double>,
+        IDivisionOperators<Energy, Energy, QuantityValue>,
         IDivisionOperators<Energy, MolarEnergy, AmountOfSubstance>,
         IDivisionOperators<Energy, Power, Duration>,
         IDivisionOperators<Energy, ElectricPotential, ElectricCharge>,
@@ -65,7 +64,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -115,7 +114,7 @@ public static EnergyInfo CreateDefault(Func<IEnumerable<UnitDefinition<EnergyUni
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Energy"/> is [T^-2][L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Energy"/> is T^-2L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
 
@@ -130,54 +129,130 @@ public static EnergyInfo CreateDefault(Func<IEnumerable<UnitDefinition<EnergyUni
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{EnergyUnit}"/> representing the default unit mappings for Energy.</returns>
             public static IEnumerable<UnitDefinition<EnergyUnit>> GetDefaultMappings()
             {
-                yield return new (EnergyUnit.BritishThermalUnit, "BritishThermalUnit", "BritishThermalUnits", BaseUnits.Undefined);
-                yield return new (EnergyUnit.Calorie, "Calorie", "Calories", BaseUnits.Undefined);
-                yield return new (EnergyUnit.DecathermEc, "DecathermEc", "DecathermsEc", BaseUnits.Undefined);
-                yield return new (EnergyUnit.DecathermImperial, "DecathermImperial", "DecathermsImperial", BaseUnits.Undefined);
-                yield return new (EnergyUnit.DecathermUs, "DecathermUs", "DecathermsUs", BaseUnits.Undefined);
-                yield return new (EnergyUnit.ElectronVolt, "ElectronVolt", "ElectronVolts", BaseUnits.Undefined);
-                yield return new (EnergyUnit.Erg, "Erg", "Ergs", BaseUnits.Undefined);
-                yield return new (EnergyUnit.FootPound, "FootPound", "FootPounds", BaseUnits.Undefined);
-                yield return new (EnergyUnit.GigabritishThermalUnit, "GigabritishThermalUnit", "GigabritishThermalUnits", BaseUnits.Undefined);
-                yield return new (EnergyUnit.GigaelectronVolt, "GigaelectronVolt", "GigaelectronVolts", BaseUnits.Undefined);
-                yield return new (EnergyUnit.Gigajoule, "Gigajoule", "Gigajoules", BaseUnits.Undefined);
-                yield return new (EnergyUnit.GigawattDay, "GigawattDay", "GigawattDays", BaseUnits.Undefined);
-                yield return new (EnergyUnit.GigawattHour, "GigawattHour", "GigawattHours", BaseUnits.Undefined);
-                yield return new (EnergyUnit.HorsepowerHour, "HorsepowerHour", "HorsepowerHours", BaseUnits.Undefined);
+                yield return new (EnergyUnit.BritishThermalUnit, "BritishThermalUnit", "BritishThermalUnits", BaseUnits.Undefined,
+                     new QuantityValue(50000000, 52752792631)
+                );
+                yield return new (EnergyUnit.Calorie, "Calorie", "Calories", BaseUnits.Undefined,
+                     new QuantityValue(125, 523)
+                );
+                yield return new (EnergyUnit.DecathermEc, "DecathermEc", "DecathermsEc", BaseUnits.Undefined,
+                     new QuantityValue(50, 52752792631)
+                );
+                yield return new (EnergyUnit.DecathermImperial, "DecathermImperial", "DecathermsImperial", BaseUnits.Undefined,
+                     new QuantityValue(25000, 26376396314337)
+                );
+                yield return new (EnergyUnit.DecathermUs, "DecathermUs", "DecathermsUs", BaseUnits.Undefined,
+                     new QuantityValue(1, 1054804000)
+                );
+                yield return new (EnergyUnit.ElectronVolt, "ElectronVolt", "ElectronVolts", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(5) * QuantityValue.PowerOfTen(27), 801088317)
+                );
+                yield return new (EnergyUnit.Erg, "Erg", "Ergs", BaseUnits.Undefined,
+                     10000000
+                );
+                yield return new (EnergyUnit.FootPound, "FootPound", "FootPounds", BaseUnits.Undefined,
+                     new QuantityValue(2500000000000000, 3389544870828501)
+                );
+                yield return new (EnergyUnit.GigabritishThermalUnit, "GigabritishThermalUnit", "GigabritishThermalUnits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1055055852620)
+                );
+                yield return new (EnergyUnit.GigaelectronVolt, "GigaelectronVolt", "GigaelectronVolts", BaseUnits.Undefined,
+                     new QuantityValue(5000000000000000000, 801088317)
+                );
+                yield return new (EnergyUnit.Gigajoule, "Gigajoule", "Gigajoules", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (EnergyUnit.GigawattDay, "GigawattDay", "GigawattDays", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000000000)
+                );
+                yield return new (EnergyUnit.GigawattHour, "GigawattHour", "GigawattHours", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000000000)
+                );
+                yield return new (EnergyUnit.HorsepowerHour, "HorsepowerHour", "HorsepowerHours", BaseUnits.Undefined,
+                     new QuantityValue(500000000, 1342259768728053)
+                );
                 yield return new (EnergyUnit.Joule, "Joule", "Joules", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (EnergyUnit.KilobritishThermalUnit, "KilobritishThermalUnit", "KilobritishThermalUnits", BaseUnits.Undefined);
-                yield return new (EnergyUnit.Kilocalorie, "Kilocalorie", "Kilocalories", BaseUnits.Undefined);
-                yield return new (EnergyUnit.KiloelectronVolt, "KiloelectronVolt", "KiloelectronVolts", BaseUnits.Undefined);
-                yield return new (EnergyUnit.Kilojoule, "Kilojoule", "Kilojoules", BaseUnits.Undefined);
-                yield return new (EnergyUnit.KilowattDay, "KilowattDay", "KilowattDays", BaseUnits.Undefined);
-                yield return new (EnergyUnit.KilowattHour, "KilowattHour", "KilowattHours", BaseUnits.Undefined);
-                yield return new (EnergyUnit.MegabritishThermalUnit, "MegabritishThermalUnit", "MegabritishThermalUnits", BaseUnits.Undefined);
-                yield return new (EnergyUnit.Megacalorie, "Megacalorie", "Megacalories", BaseUnits.Undefined);
-                yield return new (EnergyUnit.MegaelectronVolt, "MegaelectronVolt", "MegaelectronVolts", BaseUnits.Undefined);
-                yield return new (EnergyUnit.Megajoule, "Megajoule", "Megajoules", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (EnergyUnit.MegawattDay, "MegawattDay", "MegawattDays", BaseUnits.Undefined);
-                yield return new (EnergyUnit.MegawattHour, "MegawattHour", "MegawattHours", BaseUnits.Undefined);
-                yield return new (EnergyUnit.Microjoule, "Microjoule", "Microjoules", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second));
-                yield return new (EnergyUnit.Millijoule, "Millijoule", "Millijoules", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (EnergyUnit.Nanojoule, "Nanojoule", "Nanojoules", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second));
-                yield return new (EnergyUnit.Petajoule, "Petajoule", "Petajoules", BaseUnits.Undefined);
-                yield return new (EnergyUnit.TeraelectronVolt, "TeraelectronVolt", "TeraelectronVolts", BaseUnits.Undefined);
-                yield return new (EnergyUnit.Terajoule, "Terajoule", "Terajoules", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (EnergyUnit.TerawattDay, "TerawattDay", "TerawattDays", BaseUnits.Undefined);
-                yield return new (EnergyUnit.TerawattHour, "TerawattHour", "TerawattHours", BaseUnits.Undefined);
-                yield return new (EnergyUnit.ThermEc, "ThermEc", "ThermsEc", BaseUnits.Undefined);
-                yield return new (EnergyUnit.ThermImperial, "ThermImperial", "ThermsImperial", BaseUnits.Undefined);
-                yield return new (EnergyUnit.ThermUs, "ThermUs", "ThermsUs", BaseUnits.Undefined);
-                yield return new (EnergyUnit.WattDay, "WattDay", "WattDays", BaseUnits.Undefined);
-                yield return new (EnergyUnit.WattHour, "WattHour", "WattHours", BaseUnits.Undefined);
+                yield return new (EnergyUnit.KilobritishThermalUnit, "KilobritishThermalUnit", "KilobritishThermalUnits", BaseUnits.Undefined,
+                     new QuantityValue(50000, 52752792631)
+                );
+                yield return new (EnergyUnit.Kilocalorie, "Kilocalorie", "Kilocalories", BaseUnits.Undefined,
+                     new QuantityValue(1, 4184)
+                );
+                yield return new (EnergyUnit.KiloelectronVolt, "KiloelectronVolt", "KiloelectronVolts", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(5) * QuantityValue.PowerOfTen(24), 801088317)
+                );
+                yield return new (EnergyUnit.Kilojoule, "Kilojoule", "Kilojoules", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (EnergyUnit.KilowattDay, "KilowattDay", "KilowattDays", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000)
+                );
+                yield return new (EnergyUnit.KilowattHour, "KilowattHour", "KilowattHours", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000)
+                );
+                yield return new (EnergyUnit.MegabritishThermalUnit, "MegabritishThermalUnit", "MegabritishThermalUnits", BaseUnits.Undefined,
+                     new QuantityValue(50, 52752792631)
+                );
+                yield return new (EnergyUnit.Megacalorie, "Megacalorie", "Megacalories", BaseUnits.Undefined,
+                     new QuantityValue(1, 4184000)
+                );
+                yield return new (EnergyUnit.MegaelectronVolt, "MegaelectronVolt", "MegaelectronVolts", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(5) * QuantityValue.PowerOfTen(21), 801088317)
+                );
+                yield return new (EnergyUnit.Megajoule, "Megajoule", "Megajoules", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (EnergyUnit.MegawattDay, "MegawattDay", "MegawattDays", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000000)
+                );
+                yield return new (EnergyUnit.MegawattHour, "MegawattHour", "MegawattHours", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000000)
+                );
+                yield return new (EnergyUnit.Microjoule, "Microjoule", "Microjoules", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (EnergyUnit.Millijoule, "Millijoule", "Millijoules", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (EnergyUnit.Nanojoule, "Nanojoule", "Nanojoules", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (EnergyUnit.Petajoule, "Petajoule", "Petajoules", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000)
+                );
+                yield return new (EnergyUnit.TeraelectronVolt, "TeraelectronVolt", "TeraelectronVolts", BaseUnits.Undefined,
+                     new QuantityValue(5000000000000000, 801088317)
+                );
+                yield return new (EnergyUnit.Terajoule, "Terajoule", "Terajoules", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (EnergyUnit.TerawattDay, "TerawattDay", "TerawattDays", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000000000000)
+                );
+                yield return new (EnergyUnit.TerawattHour, "TerawattHour", "TerawattHours", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000000000000)
+                );
+                yield return new (EnergyUnit.ThermEc, "ThermEc", "ThermsEc", BaseUnits.Undefined,
+                     new QuantityValue(500, 52752792631)
+                );
+                yield return new (EnergyUnit.ThermImperial, "ThermImperial", "ThermsImperial", BaseUnits.Undefined,
+                     new QuantityValue(250000, 26376396314337)
+                );
+                yield return new (EnergyUnit.ThermUs, "ThermUs", "ThermsUs", BaseUnits.Undefined,
+                     new QuantityValue(1, 105480400)
+                );
+                yield return new (EnergyUnit.WattDay, "WattDay", "WattDays", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400)
+                );
+                yield return new (EnergyUnit.WattHour, "WattHour", "WattHours", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600)
+                );
             }
         }
 
         static Energy()
         {
-            Info = EnergyInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(EnergyInfo.CreateDefault);
         }
 
         /// <summary>
@@ -185,7 +260,7 @@ static Energy()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Energy(double value, EnergyUnit unit)
+        public Energy(QuantityValue value, EnergyUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -199,7 +274,7 @@ public Energy(double value, EnergyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Energy(double value, UnitSystem unitSystem)
+        public Energy(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -210,7 +285,8 @@ public Energy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Energy" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Energy, EnergyUnit> Info { get; }
@@ -239,10 +315,8 @@ public Energy(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public EnergyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -276,301 +350,209 @@ public Energy(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.BritishThermalUnit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.BritishThermalUnit"/>
         /// </summary>
-        public double BritishThermalUnits => As(EnergyUnit.BritishThermalUnit);
+        public QuantityValue BritishThermalUnits => this.As(EnergyUnit.BritishThermalUnit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Calorie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Calorie"/>
         /// </summary>
-        public double Calories => As(EnergyUnit.Calorie);
+        public QuantityValue Calories => this.As(EnergyUnit.Calorie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.DecathermEc"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.DecathermEc"/>
         /// </summary>
-        public double DecathermsEc => As(EnergyUnit.DecathermEc);
+        public QuantityValue DecathermsEc => this.As(EnergyUnit.DecathermEc);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.DecathermImperial"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.DecathermImperial"/>
         /// </summary>
-        public double DecathermsImperial => As(EnergyUnit.DecathermImperial);
+        public QuantityValue DecathermsImperial => this.As(EnergyUnit.DecathermImperial);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.DecathermUs"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.DecathermUs"/>
         /// </summary>
-        public double DecathermsUs => As(EnergyUnit.DecathermUs);
+        public QuantityValue DecathermsUs => this.As(EnergyUnit.DecathermUs);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.ElectronVolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.ElectronVolt"/>
         /// </summary>
-        public double ElectronVolts => As(EnergyUnit.ElectronVolt);
+        public QuantityValue ElectronVolts => this.As(EnergyUnit.ElectronVolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Erg"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Erg"/>
         /// </summary>
-        public double Ergs => As(EnergyUnit.Erg);
+        public QuantityValue Ergs => this.As(EnergyUnit.Erg);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.FootPound"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.FootPound"/>
         /// </summary>
-        public double FootPounds => As(EnergyUnit.FootPound);
+        public QuantityValue FootPounds => this.As(EnergyUnit.FootPound);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.GigabritishThermalUnit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.GigabritishThermalUnit"/>
         /// </summary>
-        public double GigabritishThermalUnits => As(EnergyUnit.GigabritishThermalUnit);
+        public QuantityValue GigabritishThermalUnits => this.As(EnergyUnit.GigabritishThermalUnit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.GigaelectronVolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.GigaelectronVolt"/>
         /// </summary>
-        public double GigaelectronVolts => As(EnergyUnit.GigaelectronVolt);
+        public QuantityValue GigaelectronVolts => this.As(EnergyUnit.GigaelectronVolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Gigajoule"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Gigajoule"/>
         /// </summary>
-        public double Gigajoules => As(EnergyUnit.Gigajoule);
+        public QuantityValue Gigajoules => this.As(EnergyUnit.Gigajoule);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.GigawattDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.GigawattDay"/>
         /// </summary>
-        public double GigawattDays => As(EnergyUnit.GigawattDay);
+        public QuantityValue GigawattDays => this.As(EnergyUnit.GigawattDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.GigawattHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.GigawattHour"/>
         /// </summary>
-        public double GigawattHours => As(EnergyUnit.GigawattHour);
+        public QuantityValue GigawattHours => this.As(EnergyUnit.GigawattHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.HorsepowerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.HorsepowerHour"/>
         /// </summary>
-        public double HorsepowerHours => As(EnergyUnit.HorsepowerHour);
+        public QuantityValue HorsepowerHours => this.As(EnergyUnit.HorsepowerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Joule"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Joule"/>
         /// </summary>
-        public double Joules => As(EnergyUnit.Joule);
+        public QuantityValue Joules => this.As(EnergyUnit.Joule);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.KilobritishThermalUnit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.KilobritishThermalUnit"/>
         /// </summary>
-        public double KilobritishThermalUnits => As(EnergyUnit.KilobritishThermalUnit);
+        public QuantityValue KilobritishThermalUnits => this.As(EnergyUnit.KilobritishThermalUnit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Kilocalorie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Kilocalorie"/>
         /// </summary>
-        public double Kilocalories => As(EnergyUnit.Kilocalorie);
+        public QuantityValue Kilocalories => this.As(EnergyUnit.Kilocalorie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.KiloelectronVolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.KiloelectronVolt"/>
         /// </summary>
-        public double KiloelectronVolts => As(EnergyUnit.KiloelectronVolt);
+        public QuantityValue KiloelectronVolts => this.As(EnergyUnit.KiloelectronVolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Kilojoule"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Kilojoule"/>
         /// </summary>
-        public double Kilojoules => As(EnergyUnit.Kilojoule);
+        public QuantityValue Kilojoules => this.As(EnergyUnit.Kilojoule);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.KilowattDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.KilowattDay"/>
         /// </summary>
-        public double KilowattDays => As(EnergyUnit.KilowattDay);
+        public QuantityValue KilowattDays => this.As(EnergyUnit.KilowattDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.KilowattHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.KilowattHour"/>
         /// </summary>
-        public double KilowattHours => As(EnergyUnit.KilowattHour);
+        public QuantityValue KilowattHours => this.As(EnergyUnit.KilowattHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.MegabritishThermalUnit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.MegabritishThermalUnit"/>
         /// </summary>
-        public double MegabritishThermalUnits => As(EnergyUnit.MegabritishThermalUnit);
+        public QuantityValue MegabritishThermalUnits => this.As(EnergyUnit.MegabritishThermalUnit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Megacalorie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Megacalorie"/>
         /// </summary>
-        public double Megacalories => As(EnergyUnit.Megacalorie);
+        public QuantityValue Megacalories => this.As(EnergyUnit.Megacalorie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.MegaelectronVolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.MegaelectronVolt"/>
         /// </summary>
-        public double MegaelectronVolts => As(EnergyUnit.MegaelectronVolt);
+        public QuantityValue MegaelectronVolts => this.As(EnergyUnit.MegaelectronVolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Megajoule"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Megajoule"/>
         /// </summary>
-        public double Megajoules => As(EnergyUnit.Megajoule);
+        public QuantityValue Megajoules => this.As(EnergyUnit.Megajoule);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.MegawattDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.MegawattDay"/>
         /// </summary>
-        public double MegawattDays => As(EnergyUnit.MegawattDay);
+        public QuantityValue MegawattDays => this.As(EnergyUnit.MegawattDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.MegawattHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.MegawattHour"/>
         /// </summary>
-        public double MegawattHours => As(EnergyUnit.MegawattHour);
+        public QuantityValue MegawattHours => this.As(EnergyUnit.MegawattHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Microjoule"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Microjoule"/>
         /// </summary>
-        public double Microjoules => As(EnergyUnit.Microjoule);
+        public QuantityValue Microjoules => this.As(EnergyUnit.Microjoule);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Millijoule"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Millijoule"/>
         /// </summary>
-        public double Millijoules => As(EnergyUnit.Millijoule);
+        public QuantityValue Millijoules => this.As(EnergyUnit.Millijoule);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Nanojoule"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Nanojoule"/>
         /// </summary>
-        public double Nanojoules => As(EnergyUnit.Nanojoule);
+        public QuantityValue Nanojoules => this.As(EnergyUnit.Nanojoule);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Petajoule"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Petajoule"/>
         /// </summary>
-        public double Petajoules => As(EnergyUnit.Petajoule);
+        public QuantityValue Petajoules => this.As(EnergyUnit.Petajoule);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.TeraelectronVolt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.TeraelectronVolt"/>
         /// </summary>
-        public double TeraelectronVolts => As(EnergyUnit.TeraelectronVolt);
+        public QuantityValue TeraelectronVolts => this.As(EnergyUnit.TeraelectronVolt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.Terajoule"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.Terajoule"/>
         /// </summary>
-        public double Terajoules => As(EnergyUnit.Terajoule);
+        public QuantityValue Terajoules => this.As(EnergyUnit.Terajoule);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.TerawattDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.TerawattDay"/>
         /// </summary>
-        public double TerawattDays => As(EnergyUnit.TerawattDay);
+        public QuantityValue TerawattDays => this.As(EnergyUnit.TerawattDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.TerawattHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.TerawattHour"/>
         /// </summary>
-        public double TerawattHours => As(EnergyUnit.TerawattHour);
+        public QuantityValue TerawattHours => this.As(EnergyUnit.TerawattHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.ThermEc"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.ThermEc"/>
         /// </summary>
-        public double ThermsEc => As(EnergyUnit.ThermEc);
+        public QuantityValue ThermsEc => this.As(EnergyUnit.ThermEc);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.ThermImperial"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.ThermImperial"/>
         /// </summary>
-        public double ThermsImperial => As(EnergyUnit.ThermImperial);
+        public QuantityValue ThermsImperial => this.As(EnergyUnit.ThermImperial);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.ThermUs"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.ThermUs"/>
         /// </summary>
-        public double ThermsUs => As(EnergyUnit.ThermUs);
+        public QuantityValue ThermsUs => this.As(EnergyUnit.ThermUs);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.WattDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.WattDay"/>
         /// </summary>
-        public double WattDays => As(EnergyUnit.WattDay);
+        public QuantityValue WattDays => this.As(EnergyUnit.WattDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyUnit.WattHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyUnit.WattHour"/>
         /// </summary>
-        public double WattHours => As(EnergyUnit.WattHour);
+        public QuantityValue WattHours => this.As(EnergyUnit.WattHour);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: EnergyUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.BritishThermalUnit, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Calorie, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.DecathermEc, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.DecathermImperial, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.DecathermUs, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.ElectronVolt, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Erg, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.FootPound, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.GigabritishThermalUnit, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.GigaelectronVolt, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Gigajoule, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.GigawattDay, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.GigawattHour, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.HorsepowerHour, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.KilobritishThermalUnit, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Kilocalorie, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.KiloelectronVolt, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Kilojoule, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.KilowattDay, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.KilowattHour, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.MegabritishThermalUnit, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Megacalorie, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.MegaelectronVolt, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Megajoule, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.MegawattDay, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.MegawattHour, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Microjoule, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Millijoule, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Nanojoule, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Petajoule, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.TeraelectronVolt, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Terajoule, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.TerawattDay, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.TerawattHour, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.ThermEc, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.ThermImperial, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.ThermUs, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.WattDay, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.WattHour, EnergyUnit.Joule, quantity => quantity.ToUnit(EnergyUnit.Joule));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Joule, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> EnergyUnit
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.BritishThermalUnit, quantity => quantity.ToUnit(EnergyUnit.BritishThermalUnit));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Calorie, quantity => quantity.ToUnit(EnergyUnit.Calorie));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.DecathermEc, quantity => quantity.ToUnit(EnergyUnit.DecathermEc));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.DecathermImperial, quantity => quantity.ToUnit(EnergyUnit.DecathermImperial));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.DecathermUs, quantity => quantity.ToUnit(EnergyUnit.DecathermUs));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.ElectronVolt, quantity => quantity.ToUnit(EnergyUnit.ElectronVolt));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Erg, quantity => quantity.ToUnit(EnergyUnit.Erg));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.FootPound, quantity => quantity.ToUnit(EnergyUnit.FootPound));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.GigabritishThermalUnit, quantity => quantity.ToUnit(EnergyUnit.GigabritishThermalUnit));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.GigaelectronVolt, quantity => quantity.ToUnit(EnergyUnit.GigaelectronVolt));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Gigajoule, quantity => quantity.ToUnit(EnergyUnit.Gigajoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.GigawattDay, quantity => quantity.ToUnit(EnergyUnit.GigawattDay));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.GigawattHour, quantity => quantity.ToUnit(EnergyUnit.GigawattHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.HorsepowerHour, quantity => quantity.ToUnit(EnergyUnit.HorsepowerHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.KilobritishThermalUnit, quantity => quantity.ToUnit(EnergyUnit.KilobritishThermalUnit));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Kilocalorie, quantity => quantity.ToUnit(EnergyUnit.Kilocalorie));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.KiloelectronVolt, quantity => quantity.ToUnit(EnergyUnit.KiloelectronVolt));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Kilojoule, quantity => quantity.ToUnit(EnergyUnit.Kilojoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.KilowattDay, quantity => quantity.ToUnit(EnergyUnit.KilowattDay));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.KilowattHour, quantity => quantity.ToUnit(EnergyUnit.KilowattHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.MegabritishThermalUnit, quantity => quantity.ToUnit(EnergyUnit.MegabritishThermalUnit));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Megacalorie, quantity => quantity.ToUnit(EnergyUnit.Megacalorie));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.MegaelectronVolt, quantity => quantity.ToUnit(EnergyUnit.MegaelectronVolt));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Megajoule, quantity => quantity.ToUnit(EnergyUnit.Megajoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.MegawattDay, quantity => quantity.ToUnit(EnergyUnit.MegawattDay));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.MegawattHour, quantity => quantity.ToUnit(EnergyUnit.MegawattHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Microjoule, quantity => quantity.ToUnit(EnergyUnit.Microjoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Millijoule, quantity => quantity.ToUnit(EnergyUnit.Millijoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Nanojoule, quantity => quantity.ToUnit(EnergyUnit.Nanojoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Petajoule, quantity => quantity.ToUnit(EnergyUnit.Petajoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.TeraelectronVolt, quantity => quantity.ToUnit(EnergyUnit.TeraelectronVolt));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.Terajoule, quantity => quantity.ToUnit(EnergyUnit.Terajoule));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.TerawattDay, quantity => quantity.ToUnit(EnergyUnit.TerawattDay));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.TerawattHour, quantity => quantity.ToUnit(EnergyUnit.TerawattHour));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.ThermEc, quantity => quantity.ToUnit(EnergyUnit.ThermEc));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.ThermImperial, quantity => quantity.ToUnit(EnergyUnit.ThermImperial));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.ThermUs, quantity => quantity.ToUnit(EnergyUnit.ThermUs));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.WattDay, quantity => quantity.ToUnit(EnergyUnit.WattDay));
-            unitConverter.SetConversionFunction<Energy>(EnergyUnit.Joule, EnergyUnit.WattHour, quantity => quantity.ToUnit(EnergyUnit.WattHour));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -599,7 +581,7 @@ public static string GetAbbreviation(EnergyUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.BritishThermalUnit"/>.
         /// </summary>
-        public static Energy FromBritishThermalUnits(double value)
+        public static Energy FromBritishThermalUnits(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.BritishThermalUnit);
         }
@@ -607,7 +589,7 @@ public static Energy FromBritishThermalUnits(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Calorie"/>.
         /// </summary>
-        public static Energy FromCalories(double value)
+        public static Energy FromCalories(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Calorie);
         }
@@ -615,7 +597,7 @@ public static Energy FromCalories(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermEc"/>.
         /// </summary>
-        public static Energy FromDecathermsEc(double value)
+        public static Energy FromDecathermsEc(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.DecathermEc);
         }
@@ -623,7 +605,7 @@ public static Energy FromDecathermsEc(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermImperial"/>.
         /// </summary>
-        public static Energy FromDecathermsImperial(double value)
+        public static Energy FromDecathermsImperial(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.DecathermImperial);
         }
@@ -631,7 +613,7 @@ public static Energy FromDecathermsImperial(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermUs"/>.
         /// </summary>
-        public static Energy FromDecathermsUs(double value)
+        public static Energy FromDecathermsUs(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.DecathermUs);
         }
@@ -639,7 +621,7 @@ public static Energy FromDecathermsUs(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ElectronVolt"/>.
         /// </summary>
-        public static Energy FromElectronVolts(double value)
+        public static Energy FromElectronVolts(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.ElectronVolt);
         }
@@ -647,7 +629,7 @@ public static Energy FromElectronVolts(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Erg"/>.
         /// </summary>
-        public static Energy FromErgs(double value)
+        public static Energy FromErgs(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Erg);
         }
@@ -655,7 +637,7 @@ public static Energy FromErgs(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.FootPound"/>.
         /// </summary>
-        public static Energy FromFootPounds(double value)
+        public static Energy FromFootPounds(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.FootPound);
         }
@@ -663,7 +645,7 @@ public static Energy FromFootPounds(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigabritishThermalUnit"/>.
         /// </summary>
-        public static Energy FromGigabritishThermalUnits(double value)
+        public static Energy FromGigabritishThermalUnits(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.GigabritishThermalUnit);
         }
@@ -671,7 +653,7 @@ public static Energy FromGigabritishThermalUnits(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigaelectronVolt"/>.
         /// </summary>
-        public static Energy FromGigaelectronVolts(double value)
+        public static Energy FromGigaelectronVolts(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.GigaelectronVolt);
         }
@@ -679,7 +661,7 @@ public static Energy FromGigaelectronVolts(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Gigajoule"/>.
         /// </summary>
-        public static Energy FromGigajoules(double value)
+        public static Energy FromGigajoules(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Gigajoule);
         }
@@ -687,7 +669,7 @@ public static Energy FromGigajoules(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigawattDay"/>.
         /// </summary>
-        public static Energy FromGigawattDays(double value)
+        public static Energy FromGigawattDays(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.GigawattDay);
         }
@@ -695,7 +677,7 @@ public static Energy FromGigawattDays(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigawattHour"/>.
         /// </summary>
-        public static Energy FromGigawattHours(double value)
+        public static Energy FromGigawattHours(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.GigawattHour);
         }
@@ -703,7 +685,7 @@ public static Energy FromGigawattHours(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.HorsepowerHour"/>.
         /// </summary>
-        public static Energy FromHorsepowerHours(double value)
+        public static Energy FromHorsepowerHours(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.HorsepowerHour);
         }
@@ -711,7 +693,7 @@ public static Energy FromHorsepowerHours(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Joule"/>.
         /// </summary>
-        public static Energy FromJoules(double value)
+        public static Energy FromJoules(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Joule);
         }
@@ -719,7 +701,7 @@ public static Energy FromJoules(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilobritishThermalUnit"/>.
         /// </summary>
-        public static Energy FromKilobritishThermalUnits(double value)
+        public static Energy FromKilobritishThermalUnits(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.KilobritishThermalUnit);
         }
@@ -727,7 +709,7 @@ public static Energy FromKilobritishThermalUnits(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Kilocalorie"/>.
         /// </summary>
-        public static Energy FromKilocalories(double value)
+        public static Energy FromKilocalories(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Kilocalorie);
         }
@@ -735,7 +717,7 @@ public static Energy FromKilocalories(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KiloelectronVolt"/>.
         /// </summary>
-        public static Energy FromKiloelectronVolts(double value)
+        public static Energy FromKiloelectronVolts(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.KiloelectronVolt);
         }
@@ -743,7 +725,7 @@ public static Energy FromKiloelectronVolts(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Kilojoule"/>.
         /// </summary>
-        public static Energy FromKilojoules(double value)
+        public static Energy FromKilojoules(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Kilojoule);
         }
@@ -751,7 +733,7 @@ public static Energy FromKilojoules(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilowattDay"/>.
         /// </summary>
-        public static Energy FromKilowattDays(double value)
+        public static Energy FromKilowattDays(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.KilowattDay);
         }
@@ -759,7 +741,7 @@ public static Energy FromKilowattDays(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilowattHour"/>.
         /// </summary>
-        public static Energy FromKilowattHours(double value)
+        public static Energy FromKilowattHours(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.KilowattHour);
         }
@@ -767,7 +749,7 @@ public static Energy FromKilowattHours(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegabritishThermalUnit"/>.
         /// </summary>
-        public static Energy FromMegabritishThermalUnits(double value)
+        public static Energy FromMegabritishThermalUnits(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.MegabritishThermalUnit);
         }
@@ -775,7 +757,7 @@ public static Energy FromMegabritishThermalUnits(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Megacalorie"/>.
         /// </summary>
-        public static Energy FromMegacalories(double value)
+        public static Energy FromMegacalories(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Megacalorie);
         }
@@ -783,7 +765,7 @@ public static Energy FromMegacalories(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegaelectronVolt"/>.
         /// </summary>
-        public static Energy FromMegaelectronVolts(double value)
+        public static Energy FromMegaelectronVolts(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.MegaelectronVolt);
         }
@@ -791,7 +773,7 @@ public static Energy FromMegaelectronVolts(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Megajoule"/>.
         /// </summary>
-        public static Energy FromMegajoules(double value)
+        public static Energy FromMegajoules(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Megajoule);
         }
@@ -799,7 +781,7 @@ public static Energy FromMegajoules(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegawattDay"/>.
         /// </summary>
-        public static Energy FromMegawattDays(double value)
+        public static Energy FromMegawattDays(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.MegawattDay);
         }
@@ -807,7 +789,7 @@ public static Energy FromMegawattDays(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegawattHour"/>.
         /// </summary>
-        public static Energy FromMegawattHours(double value)
+        public static Energy FromMegawattHours(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.MegawattHour);
         }
@@ -815,7 +797,7 @@ public static Energy FromMegawattHours(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Microjoule"/>.
         /// </summary>
-        public static Energy FromMicrojoules(double value)
+        public static Energy FromMicrojoules(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Microjoule);
         }
@@ -823,7 +805,7 @@ public static Energy FromMicrojoules(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Millijoule"/>.
         /// </summary>
-        public static Energy FromMillijoules(double value)
+        public static Energy FromMillijoules(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Millijoule);
         }
@@ -831,7 +813,7 @@ public static Energy FromMillijoules(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Nanojoule"/>.
         /// </summary>
-        public static Energy FromNanojoules(double value)
+        public static Energy FromNanojoules(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Nanojoule);
         }
@@ -839,7 +821,7 @@ public static Energy FromNanojoules(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Petajoule"/>.
         /// </summary>
-        public static Energy FromPetajoules(double value)
+        public static Energy FromPetajoules(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Petajoule);
         }
@@ -847,7 +829,7 @@ public static Energy FromPetajoules(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TeraelectronVolt"/>.
         /// </summary>
-        public static Energy FromTeraelectronVolts(double value)
+        public static Energy FromTeraelectronVolts(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.TeraelectronVolt);
         }
@@ -855,7 +837,7 @@ public static Energy FromTeraelectronVolts(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Terajoule"/>.
         /// </summary>
-        public static Energy FromTerajoules(double value)
+        public static Energy FromTerajoules(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.Terajoule);
         }
@@ -863,7 +845,7 @@ public static Energy FromTerajoules(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TerawattDay"/>.
         /// </summary>
-        public static Energy FromTerawattDays(double value)
+        public static Energy FromTerawattDays(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.TerawattDay);
         }
@@ -871,7 +853,7 @@ public static Energy FromTerawattDays(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TerawattHour"/>.
         /// </summary>
-        public static Energy FromTerawattHours(double value)
+        public static Energy FromTerawattHours(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.TerawattHour);
         }
@@ -879,7 +861,7 @@ public static Energy FromTerawattHours(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermEc"/>.
         /// </summary>
-        public static Energy FromThermsEc(double value)
+        public static Energy FromThermsEc(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.ThermEc);
         }
@@ -887,7 +869,7 @@ public static Energy FromThermsEc(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermImperial"/>.
         /// </summary>
-        public static Energy FromThermsImperial(double value)
+        public static Energy FromThermsImperial(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.ThermImperial);
         }
@@ -895,7 +877,7 @@ public static Energy FromThermsImperial(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermUs"/>.
         /// </summary>
-        public static Energy FromThermsUs(double value)
+        public static Energy FromThermsUs(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.ThermUs);
         }
@@ -903,7 +885,7 @@ public static Energy FromThermsUs(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.WattDay"/>.
         /// </summary>
-        public static Energy FromWattDays(double value)
+        public static Energy FromWattDays(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.WattDay);
         }
@@ -911,7 +893,7 @@ public static Energy FromWattDays(double value)
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.WattHour"/>.
         /// </summary>
-        public static Energy FromWattHours(double value)
+        public static Energy FromWattHours(QuantityValue value)
         {
             return new Energy(value, EnergyUnit.WattHour);
         }
@@ -922,7 +904,7 @@ public static Energy FromWattHours(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Energy unit value.</returns>
-        public static Energy From(double value, EnergyUnit fromUnit)
+        public static Energy From(QuantityValue value, EnergyUnit fromUnit)
         {
             return new Energy(value, fromUnit);
         }
@@ -983,10 +965,7 @@ public static Energy Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Energy Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Energy, EnergyUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Energy, EnergyUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -1014,11 +993,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Energy result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Energy result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Energy, EnergyUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Energy, EnergyUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -1039,7 +1014,7 @@ public static EnergyUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1050,7 +1025,7 @@ public static EnergyUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.EnergyUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.EnergyUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out EnergyUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1065,7 +1040,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out EnergyUnit u
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out EnergyUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1084,35 +1059,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Energy"/> from adding two <see cref="Energy"/>.</summary>
         public static Energy operator +(Energy left, Energy right)
         {
-            return new Energy(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Energy(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Energy"/> from subtracting two <see cref="Energy"/>.</summary>
         public static Energy operator -(Energy left, Energy right)
         {
-            return new Energy(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Energy(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Energy"/> from multiplying value and <see cref="Energy"/>.</summary>
-        public static Energy operator *(double left, Energy right)
+        public static Energy operator *(QuantityValue left, Energy right)
         {
             return new Energy(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Energy"/> from multiplying value and <see cref="Energy"/>.</summary>
-        public static Energy operator *(Energy left, double right)
+        public static Energy operator *(Energy left, QuantityValue right)
         {
             return new Energy(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Energy"/> from dividing <see cref="Energy"/> by value.</summary>
-        public static Energy operator /(Energy left, double right)
+        public static Energy operator /(Energy left, QuantityValue right)
         {
             return new Energy(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Energy"/> by <see cref="Energy"/>.</summary>
-        public static double operator /(Energy left, Energy right)
+        public static QuantityValue operator /(Energy left, Energy right)
         {
             return left.Joules / right.Joules;
         }
@@ -1206,97 +1181,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Energy left, Energy right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Energy left, Energy right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Energy left, Energy right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Energy left, Energy right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Energy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Energy other, Energy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Energy"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Energy)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Energy left, Energy right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Energy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Energy other, Energy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Energy"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Energy,Energy)"/>.
+        ///     See that operator (and <see cref="Equals(Energy)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Energy left, Energy right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Energy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Energy other, Energy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Energy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Energy"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Energy"/>, this method delegates to
+        ///     <see cref="Equals(Energy)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Energy otherQuantity))
+            if (obj is not Energy otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Energy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Energy other, Energy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Energy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Energy other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Energy.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Energy), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Energy"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Energy)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Energy otherQuantity)) throw new ArgumentException("Expected type Energy.", nameof(obj));
+            if (obj is not Energy otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Energy>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Energy"/> with another <see cref="Energy"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Energy"/> with another <see cref="Energy"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1308,207 +1297,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Energy other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(EnergyUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<EnergyUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Energy to another Energy with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Energy with the specified unit.</returns>
-        public Energy ToUnit(EnergyUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Energy"/> to another <see cref="Energy"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Energy with the specified unit.</returns>
-        public Energy ToUnit(EnergyUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Energy), Unit, typeof(Energy), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Energy)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="Energy"/> to another <see cref="Energy"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Energy"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(EnergyUnit unit, [NotNullWhen(true)] out Energy? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Energy? convertedOrNull = (Unit, unit) switch
-            {
-                // EnergyUnit -> BaseUnit
-                (EnergyUnit.BritishThermalUnit, EnergyUnit.Joule) => new Energy(_value * 1055.05585262, EnergyUnit.Joule),
-                (EnergyUnit.Calorie, EnergyUnit.Joule) => new Energy(_value * 4.184, EnergyUnit.Joule),
-                (EnergyUnit.DecathermEc, EnergyUnit.Joule) => new Energy((_value * 1.05505585262e8) * 1e1d, EnergyUnit.Joule),
-                (EnergyUnit.DecathermImperial, EnergyUnit.Joule) => new Energy((_value * 1.05505585257348e8) * 1e1d, EnergyUnit.Joule),
-                (EnergyUnit.DecathermUs, EnergyUnit.Joule) => new Energy((_value * 1.054804e8) * 1e1d, EnergyUnit.Joule),
-                (EnergyUnit.ElectronVolt, EnergyUnit.Joule) => new Energy(_value * 1.602176634e-19, EnergyUnit.Joule),
-                (EnergyUnit.Erg, EnergyUnit.Joule) => new Energy(_value * 1e-7, EnergyUnit.Joule),
-                (EnergyUnit.FootPound, EnergyUnit.Joule) => new Energy(_value * 1.3558179483314004, EnergyUnit.Joule),
-                (EnergyUnit.GigabritishThermalUnit, EnergyUnit.Joule) => new Energy((_value * 1055.05585262) * 1e9d, EnergyUnit.Joule),
-                (EnergyUnit.GigaelectronVolt, EnergyUnit.Joule) => new Energy((_value * 1.602176634e-19) * 1e9d, EnergyUnit.Joule),
-                (EnergyUnit.Gigajoule, EnergyUnit.Joule) => new Energy((_value) * 1e9d, EnergyUnit.Joule),
-                (EnergyUnit.GigawattDay, EnergyUnit.Joule) => new Energy((_value * 24 * 3600d) * 1e9d, EnergyUnit.Joule),
-                (EnergyUnit.GigawattHour, EnergyUnit.Joule) => new Energy((_value * 3600d) * 1e9d, EnergyUnit.Joule),
-                (EnergyUnit.HorsepowerHour, EnergyUnit.Joule) => new Energy(_value * 76.0402249 * 9.80665 * 3600, EnergyUnit.Joule),
-                (EnergyUnit.KilobritishThermalUnit, EnergyUnit.Joule) => new Energy((_value * 1055.05585262) * 1e3d, EnergyUnit.Joule),
-                (EnergyUnit.Kilocalorie, EnergyUnit.Joule) => new Energy((_value * 4.184) * 1e3d, EnergyUnit.Joule),
-                (EnergyUnit.KiloelectronVolt, EnergyUnit.Joule) => new Energy((_value * 1.602176634e-19) * 1e3d, EnergyUnit.Joule),
-                (EnergyUnit.Kilojoule, EnergyUnit.Joule) => new Energy((_value) * 1e3d, EnergyUnit.Joule),
-                (EnergyUnit.KilowattDay, EnergyUnit.Joule) => new Energy((_value * 24 * 3600d) * 1e3d, EnergyUnit.Joule),
-                (EnergyUnit.KilowattHour, EnergyUnit.Joule) => new Energy((_value * 3600d) * 1e3d, EnergyUnit.Joule),
-                (EnergyUnit.MegabritishThermalUnit, EnergyUnit.Joule) => new Energy((_value * 1055.05585262) * 1e6d, EnergyUnit.Joule),
-                (EnergyUnit.Megacalorie, EnergyUnit.Joule) => new Energy((_value * 4.184) * 1e6d, EnergyUnit.Joule),
-                (EnergyUnit.MegaelectronVolt, EnergyUnit.Joule) => new Energy((_value * 1.602176634e-19) * 1e6d, EnergyUnit.Joule),
-                (EnergyUnit.Megajoule, EnergyUnit.Joule) => new Energy((_value) * 1e6d, EnergyUnit.Joule),
-                (EnergyUnit.MegawattDay, EnergyUnit.Joule) => new Energy((_value * 24 * 3600d) * 1e6d, EnergyUnit.Joule),
-                (EnergyUnit.MegawattHour, EnergyUnit.Joule) => new Energy((_value * 3600d) * 1e6d, EnergyUnit.Joule),
-                (EnergyUnit.Microjoule, EnergyUnit.Joule) => new Energy((_value) * 1e-6d, EnergyUnit.Joule),
-                (EnergyUnit.Millijoule, EnergyUnit.Joule) => new Energy((_value) * 1e-3d, EnergyUnit.Joule),
-                (EnergyUnit.Nanojoule, EnergyUnit.Joule) => new Energy((_value) * 1e-9d, EnergyUnit.Joule),
-                (EnergyUnit.Petajoule, EnergyUnit.Joule) => new Energy((_value) * 1e15d, EnergyUnit.Joule),
-                (EnergyUnit.TeraelectronVolt, EnergyUnit.Joule) => new Energy((_value * 1.602176634e-19) * 1e12d, EnergyUnit.Joule),
-                (EnergyUnit.Terajoule, EnergyUnit.Joule) => new Energy((_value) * 1e12d, EnergyUnit.Joule),
-                (EnergyUnit.TerawattDay, EnergyUnit.Joule) => new Energy((_value * 24 * 3600d) * 1e12d, EnergyUnit.Joule),
-                (EnergyUnit.TerawattHour, EnergyUnit.Joule) => new Energy((_value * 3600d) * 1e12d, EnergyUnit.Joule),
-                (EnergyUnit.ThermEc, EnergyUnit.Joule) => new Energy(_value * 1.05505585262e8, EnergyUnit.Joule),
-                (EnergyUnit.ThermImperial, EnergyUnit.Joule) => new Energy(_value * 1.05505585257348e8, EnergyUnit.Joule),
-                (EnergyUnit.ThermUs, EnergyUnit.Joule) => new Energy(_value * 1.054804e8, EnergyUnit.Joule),
-                (EnergyUnit.WattDay, EnergyUnit.Joule) => new Energy(_value * 24 * 3600d, EnergyUnit.Joule),
-                (EnergyUnit.WattHour, EnergyUnit.Joule) => new Energy(_value * 3600d, EnergyUnit.Joule),
-
-                // BaseUnit -> EnergyUnit
-                (EnergyUnit.Joule, EnergyUnit.BritishThermalUnit) => new Energy(_value / 1055.05585262, EnergyUnit.BritishThermalUnit),
-                (EnergyUnit.Joule, EnergyUnit.Calorie) => new Energy(_value / 4.184, EnergyUnit.Calorie),
-                (EnergyUnit.Joule, EnergyUnit.DecathermEc) => new Energy((_value / 1.05505585262e8) / 1e1d, EnergyUnit.DecathermEc),
-                (EnergyUnit.Joule, EnergyUnit.DecathermImperial) => new Energy((_value / 1.05505585257348e8) / 1e1d, EnergyUnit.DecathermImperial),
-                (EnergyUnit.Joule, EnergyUnit.DecathermUs) => new Energy((_value / 1.054804e8) / 1e1d, EnergyUnit.DecathermUs),
-                (EnergyUnit.Joule, EnergyUnit.ElectronVolt) => new Energy(_value / 1.602176634e-19, EnergyUnit.ElectronVolt),
-                (EnergyUnit.Joule, EnergyUnit.Erg) => new Energy(_value / 1e-7, EnergyUnit.Erg),
-                (EnergyUnit.Joule, EnergyUnit.FootPound) => new Energy(_value / 1.3558179483314004, EnergyUnit.FootPound),
-                (EnergyUnit.Joule, EnergyUnit.GigabritishThermalUnit) => new Energy((_value / 1055.05585262) / 1e9d, EnergyUnit.GigabritishThermalUnit),
-                (EnergyUnit.Joule, EnergyUnit.GigaelectronVolt) => new Energy((_value / 1.602176634e-19) / 1e9d, EnergyUnit.GigaelectronVolt),
-                (EnergyUnit.Joule, EnergyUnit.Gigajoule) => new Energy((_value) / 1e9d, EnergyUnit.Gigajoule),
-                (EnergyUnit.Joule, EnergyUnit.GigawattDay) => new Energy((_value / (24 * 3600d)) / 1e9d, EnergyUnit.GigawattDay),
-                (EnergyUnit.Joule, EnergyUnit.GigawattHour) => new Energy((_value / 3600d) / 1e9d, EnergyUnit.GigawattHour),
-                (EnergyUnit.Joule, EnergyUnit.HorsepowerHour) => new Energy(_value / (76.0402249 * 9.80665 * 3600), EnergyUnit.HorsepowerHour),
-                (EnergyUnit.Joule, EnergyUnit.KilobritishThermalUnit) => new Energy((_value / 1055.05585262) / 1e3d, EnergyUnit.KilobritishThermalUnit),
-                (EnergyUnit.Joule, EnergyUnit.Kilocalorie) => new Energy((_value / 4.184) / 1e3d, EnergyUnit.Kilocalorie),
-                (EnergyUnit.Joule, EnergyUnit.KiloelectronVolt) => new Energy((_value / 1.602176634e-19) / 1e3d, EnergyUnit.KiloelectronVolt),
-                (EnergyUnit.Joule, EnergyUnit.Kilojoule) => new Energy((_value) / 1e3d, EnergyUnit.Kilojoule),
-                (EnergyUnit.Joule, EnergyUnit.KilowattDay) => new Energy((_value / (24 * 3600d)) / 1e3d, EnergyUnit.KilowattDay),
-                (EnergyUnit.Joule, EnergyUnit.KilowattHour) => new Energy((_value / 3600d) / 1e3d, EnergyUnit.KilowattHour),
-                (EnergyUnit.Joule, EnergyUnit.MegabritishThermalUnit) => new Energy((_value / 1055.05585262) / 1e6d, EnergyUnit.MegabritishThermalUnit),
-                (EnergyUnit.Joule, EnergyUnit.Megacalorie) => new Energy((_value / 4.184) / 1e6d, EnergyUnit.Megacalorie),
-                (EnergyUnit.Joule, EnergyUnit.MegaelectronVolt) => new Energy((_value / 1.602176634e-19) / 1e6d, EnergyUnit.MegaelectronVolt),
-                (EnergyUnit.Joule, EnergyUnit.Megajoule) => new Energy((_value) / 1e6d, EnergyUnit.Megajoule),
-                (EnergyUnit.Joule, EnergyUnit.MegawattDay) => new Energy((_value / (24 * 3600d)) / 1e6d, EnergyUnit.MegawattDay),
-                (EnergyUnit.Joule, EnergyUnit.MegawattHour) => new Energy((_value / 3600d) / 1e6d, EnergyUnit.MegawattHour),
-                (EnergyUnit.Joule, EnergyUnit.Microjoule) => new Energy((_value) / 1e-6d, EnergyUnit.Microjoule),
-                (EnergyUnit.Joule, EnergyUnit.Millijoule) => new Energy((_value) / 1e-3d, EnergyUnit.Millijoule),
-                (EnergyUnit.Joule, EnergyUnit.Nanojoule) => new Energy((_value) / 1e-9d, EnergyUnit.Nanojoule),
-                (EnergyUnit.Joule, EnergyUnit.Petajoule) => new Energy((_value) / 1e15d, EnergyUnit.Petajoule),
-                (EnergyUnit.Joule, EnergyUnit.TeraelectronVolt) => new Energy((_value / 1.602176634e-19) / 1e12d, EnergyUnit.TeraelectronVolt),
-                (EnergyUnit.Joule, EnergyUnit.Terajoule) => new Energy((_value) / 1e12d, EnergyUnit.Terajoule),
-                (EnergyUnit.Joule, EnergyUnit.TerawattDay) => new Energy((_value / (24 * 3600d)) / 1e12d, EnergyUnit.TerawattDay),
-                (EnergyUnit.Joule, EnergyUnit.TerawattHour) => new Energy((_value / 3600d) / 1e12d, EnergyUnit.TerawattHour),
-                (EnergyUnit.Joule, EnergyUnit.ThermEc) => new Energy(_value / 1.05505585262e8, EnergyUnit.ThermEc),
-                (EnergyUnit.Joule, EnergyUnit.ThermImperial) => new Energy(_value / 1.05505585257348e8, EnergyUnit.ThermImperial),
-                (EnergyUnit.Joule, EnergyUnit.ThermUs) => new Energy(_value / 1.054804e8, EnergyUnit.ThermUs),
-                (EnergyUnit.Joule, EnergyUnit.WattDay) => new Energy(_value / (24 * 3600d), EnergyUnit.WattDay),
-                (EnergyUnit.Joule, EnergyUnit.WattHour) => new Energy(_value / 3600d, EnergyUnit.WattHour),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not EnergyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is EnergyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<EnergyUnit> IQuantity<EnergyUnit>.ToUnit(EnergyUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1522,11 +1313,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
index 3766c54268..02684511b4 100644
--- a/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,12 +33,15 @@ namespace UnitsNet
     ///     
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct EnergyDensity :
-        IArithmeticQuantity<EnergyDensity, EnergyDensityUnit>,
+        ILinearQuantity<EnergyDensity, EnergyDensityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<EnergyDensity, EnergyDensity, double>,
+        IDivisionOperators<EnergyDensity, EnergyDensity, QuantityValue>,
         IMultiplyOperators<EnergyDensity, Volume, Energy>,
+        IDivisionOperators<EnergyDensity, VolumetricHeatCapacity, TemperatureDelta>,
+        IDivisionOperators<EnergyDensity, TemperatureDelta, VolumetricHeatCapacity>,
         IComparisonOperators<EnergyDensity, EnergyDensity, bool>,
         IParsable<EnergyDensity>,
 #endif
@@ -53,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +104,7 @@ public static EnergyDensityInfo CreateDefault(Func<IEnumerable<UnitDefinition<En
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="EnergyDensity"/> is [T^-2][L^-1][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="EnergyDensity"/> is T^-2L^-1M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 1, -2, 0, 0, 0, 0);
 
@@ -118,26 +119,46 @@ public static EnergyDensityInfo CreateDefault(Func<IEnumerable<UnitDefinition<En
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{EnergyDensityUnit}"/> representing the default unit mappings for EnergyDensity.</returns>
             public static IEnumerable<UnitDefinition<EnergyDensityUnit>> GetDefaultMappings()
             {
-                yield return new (EnergyDensityUnit.GigajoulePerCubicMeter, "GigajoulePerCubicMeter", "GigajoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (EnergyDensityUnit.GigawattHourPerCubicMeter, "GigawattHourPerCubicMeter", "GigawattHoursPerCubicMeter", BaseUnits.Undefined);
+                yield return new (EnergyDensityUnit.GigajoulePerCubicMeter, "GigajoulePerCubicMeter", "GigajoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (EnergyDensityUnit.GigawattHourPerCubicMeter, "GigawattHourPerCubicMeter", "GigawattHoursPerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000000000)
+                );
                 yield return new (EnergyDensityUnit.JoulePerCubicMeter, "JoulePerCubicMeter", "JoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (EnergyDensityUnit.KilojoulePerCubicMeter, "KilojoulePerCubicMeter", "KilojoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (EnergyDensityUnit.KilowattHourPerCubicMeter, "KilowattHourPerCubicMeter", "KilowattHoursPerCubicMeter", BaseUnits.Undefined);
-                yield return new (EnergyDensityUnit.MegajoulePerCubicMeter, "MegajoulePerCubicMeter", "MegajoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (EnergyDensityUnit.MegawattHourPerCubicMeter, "MegawattHourPerCubicMeter", "MegawattHoursPerCubicMeter", BaseUnits.Undefined);
-                yield return new (EnergyDensityUnit.PetajoulePerCubicMeter, "PetajoulePerCubicMeter", "PetajoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Femtometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (EnergyDensityUnit.PetawattHourPerCubicMeter, "PetawattHourPerCubicMeter", "PetawattHoursPerCubicMeter", BaseUnits.Undefined);
-                yield return new (EnergyDensityUnit.TerajoulePerCubicMeter, "TerajoulePerCubicMeter", "TerajoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Picometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (EnergyDensityUnit.TerawattHourPerCubicMeter, "TerawattHourPerCubicMeter", "TerawattHoursPerCubicMeter", BaseUnits.Undefined);
-                yield return new (EnergyDensityUnit.WattHourPerCubicMeter, "WattHourPerCubicMeter", "WattHoursPerCubicMeter", BaseUnits.Undefined);
+                yield return new (EnergyDensityUnit.KilojoulePerCubicMeter, "KilojoulePerCubicMeter", "KilojoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (EnergyDensityUnit.KilowattHourPerCubicMeter, "KilowattHourPerCubicMeter", "KilowattHoursPerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000)
+                );
+                yield return new (EnergyDensityUnit.MegajoulePerCubicMeter, "MegajoulePerCubicMeter", "MegajoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (EnergyDensityUnit.MegawattHourPerCubicMeter, "MegawattHourPerCubicMeter", "MegawattHoursPerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000000)
+                );
+                yield return new (EnergyDensityUnit.PetajoulePerCubicMeter, "PetajoulePerCubicMeter", "PetajoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Femtometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000000000)
+                );
+                yield return new (EnergyDensityUnit.PetawattHourPerCubicMeter, "PetawattHourPerCubicMeter", "PetawattHoursPerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000000000000000)
+                );
+                yield return new (EnergyDensityUnit.TerajoulePerCubicMeter, "TerajoulePerCubicMeter", "TerajoulesPerCubicMeter", new BaseUnits(length: LengthUnit.Picometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (EnergyDensityUnit.TerawattHourPerCubicMeter, "TerawattHourPerCubicMeter", "TerawattHoursPerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000000000000)
+                );
+                yield return new (EnergyDensityUnit.WattHourPerCubicMeter, "WattHourPerCubicMeter", "WattHoursPerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600)
+                );
             }
         }
 
         static EnergyDensity()
         {
-            Info = EnergyDensityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(EnergyDensityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -145,7 +166,7 @@ static EnergyDensity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public EnergyDensity(double value, EnergyDensityUnit unit)
+        public EnergyDensity(QuantityValue value, EnergyDensityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -159,7 +180,7 @@ public EnergyDensity(double value, EnergyDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public EnergyDensity(double value, UnitSystem unitSystem)
+        public EnergyDensity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -170,7 +191,8 @@ public EnergyDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="EnergyDensity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<EnergyDensity, EnergyDensityUnit> Info { get; }
@@ -199,10 +221,8 @@ public EnergyDensity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public EnergyDensityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -236,105 +256,69 @@ public EnergyDensity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.GigajoulePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.GigajoulePerCubicMeter"/>
         /// </summary>
-        public double GigajoulesPerCubicMeter => As(EnergyDensityUnit.GigajoulePerCubicMeter);
+        public QuantityValue GigajoulesPerCubicMeter => this.As(EnergyDensityUnit.GigajoulePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.GigawattHourPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.GigawattHourPerCubicMeter"/>
         /// </summary>
-        public double GigawattHoursPerCubicMeter => As(EnergyDensityUnit.GigawattHourPerCubicMeter);
+        public QuantityValue GigawattHoursPerCubicMeter => this.As(EnergyDensityUnit.GigawattHourPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.JoulePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.JoulePerCubicMeter"/>
         /// </summary>
-        public double JoulesPerCubicMeter => As(EnergyDensityUnit.JoulePerCubicMeter);
+        public QuantityValue JoulesPerCubicMeter => this.As(EnergyDensityUnit.JoulePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.KilojoulePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.KilojoulePerCubicMeter"/>
         /// </summary>
-        public double KilojoulesPerCubicMeter => As(EnergyDensityUnit.KilojoulePerCubicMeter);
+        public QuantityValue KilojoulesPerCubicMeter => this.As(EnergyDensityUnit.KilojoulePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.KilowattHourPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.KilowattHourPerCubicMeter"/>
         /// </summary>
-        public double KilowattHoursPerCubicMeter => As(EnergyDensityUnit.KilowattHourPerCubicMeter);
+        public QuantityValue KilowattHoursPerCubicMeter => this.As(EnergyDensityUnit.KilowattHourPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.MegajoulePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.MegajoulePerCubicMeter"/>
         /// </summary>
-        public double MegajoulesPerCubicMeter => As(EnergyDensityUnit.MegajoulePerCubicMeter);
+        public QuantityValue MegajoulesPerCubicMeter => this.As(EnergyDensityUnit.MegajoulePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.MegawattHourPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.MegawattHourPerCubicMeter"/>
         /// </summary>
-        public double MegawattHoursPerCubicMeter => As(EnergyDensityUnit.MegawattHourPerCubicMeter);
+        public QuantityValue MegawattHoursPerCubicMeter => this.As(EnergyDensityUnit.MegawattHourPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.PetajoulePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.PetajoulePerCubicMeter"/>
         /// </summary>
-        public double PetajoulesPerCubicMeter => As(EnergyDensityUnit.PetajoulePerCubicMeter);
+        public QuantityValue PetajoulesPerCubicMeter => this.As(EnergyDensityUnit.PetajoulePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.PetawattHourPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.PetawattHourPerCubicMeter"/>
         /// </summary>
-        public double PetawattHoursPerCubicMeter => As(EnergyDensityUnit.PetawattHourPerCubicMeter);
+        public QuantityValue PetawattHoursPerCubicMeter => this.As(EnergyDensityUnit.PetawattHourPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.TerajoulePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.TerajoulePerCubicMeter"/>
         /// </summary>
-        public double TerajoulesPerCubicMeter => As(EnergyDensityUnit.TerajoulePerCubicMeter);
+        public QuantityValue TerajoulesPerCubicMeter => this.As(EnergyDensityUnit.TerajoulePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.TerawattHourPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.TerawattHourPerCubicMeter"/>
         /// </summary>
-        public double TerawattHoursPerCubicMeter => As(EnergyDensityUnit.TerawattHourPerCubicMeter);
+        public QuantityValue TerawattHoursPerCubicMeter => this.As(EnergyDensityUnit.TerawattHourPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EnergyDensityUnit.WattHourPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EnergyDensityUnit.WattHourPerCubicMeter"/>
         /// </summary>
-        public double WattHoursPerCubicMeter => As(EnergyDensityUnit.WattHourPerCubicMeter);
+        public QuantityValue WattHoursPerCubicMeter => this.As(EnergyDensityUnit.WattHourPerCubicMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: EnergyDensityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.GigajoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.GigawattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.KilojoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.KilowattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.MegajoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.MegawattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.PetajoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.PetawattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.TerajoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.TerawattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.WattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.JoulePerCubicMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> EnergyDensityUnit
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.GigajoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.GigajoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.GigawattHourPerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.GigawattHourPerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.KilojoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.KilojoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.KilowattHourPerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.KilowattHourPerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.MegajoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.MegajoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.MegawattHourPerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.MegawattHourPerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.PetajoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.PetajoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.PetawattHourPerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.PetawattHourPerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.TerajoulePerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.TerajoulePerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.TerawattHourPerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.TerawattHourPerCubicMeter));
-            unitConverter.SetConversionFunction<EnergyDensity>(EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.WattHourPerCubicMeter, quantity => quantity.ToUnit(EnergyDensityUnit.WattHourPerCubicMeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -363,7 +347,7 @@ public static string GetAbbreviation(EnergyDensityUnit unit, IFormatProvider? pr
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.GigajoulePerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromGigajoulesPerCubicMeter(double value)
+        public static EnergyDensity FromGigajoulesPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.GigajoulePerCubicMeter);
         }
@@ -371,7 +355,7 @@ public static EnergyDensity FromGigajoulesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.GigawattHourPerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromGigawattHoursPerCubicMeter(double value)
+        public static EnergyDensity FromGigawattHoursPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.GigawattHourPerCubicMeter);
         }
@@ -379,7 +363,7 @@ public static EnergyDensity FromGigawattHoursPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.JoulePerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromJoulesPerCubicMeter(double value)
+        public static EnergyDensity FromJoulesPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.JoulePerCubicMeter);
         }
@@ -387,7 +371,7 @@ public static EnergyDensity FromJoulesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.KilojoulePerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromKilojoulesPerCubicMeter(double value)
+        public static EnergyDensity FromKilojoulesPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.KilojoulePerCubicMeter);
         }
@@ -395,7 +379,7 @@ public static EnergyDensity FromKilojoulesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.KilowattHourPerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromKilowattHoursPerCubicMeter(double value)
+        public static EnergyDensity FromKilowattHoursPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.KilowattHourPerCubicMeter);
         }
@@ -403,7 +387,7 @@ public static EnergyDensity FromKilowattHoursPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.MegajoulePerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromMegajoulesPerCubicMeter(double value)
+        public static EnergyDensity FromMegajoulesPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.MegajoulePerCubicMeter);
         }
@@ -411,7 +395,7 @@ public static EnergyDensity FromMegajoulesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.MegawattHourPerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromMegawattHoursPerCubicMeter(double value)
+        public static EnergyDensity FromMegawattHoursPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.MegawattHourPerCubicMeter);
         }
@@ -419,7 +403,7 @@ public static EnergyDensity FromMegawattHoursPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.PetajoulePerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromPetajoulesPerCubicMeter(double value)
+        public static EnergyDensity FromPetajoulesPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.PetajoulePerCubicMeter);
         }
@@ -427,7 +411,7 @@ public static EnergyDensity FromPetajoulesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.PetawattHourPerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromPetawattHoursPerCubicMeter(double value)
+        public static EnergyDensity FromPetawattHoursPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.PetawattHourPerCubicMeter);
         }
@@ -435,7 +419,7 @@ public static EnergyDensity FromPetawattHoursPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.TerajoulePerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromTerajoulesPerCubicMeter(double value)
+        public static EnergyDensity FromTerajoulesPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.TerajoulePerCubicMeter);
         }
@@ -443,7 +427,7 @@ public static EnergyDensity FromTerajoulesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.TerawattHourPerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromTerawattHoursPerCubicMeter(double value)
+        public static EnergyDensity FromTerawattHoursPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.TerawattHourPerCubicMeter);
         }
@@ -451,7 +435,7 @@ public static EnergyDensity FromTerawattHoursPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.WattHourPerCubicMeter"/>.
         /// </summary>
-        public static EnergyDensity FromWattHoursPerCubicMeter(double value)
+        public static EnergyDensity FromWattHoursPerCubicMeter(QuantityValue value)
         {
             return new EnergyDensity(value, EnergyDensityUnit.WattHourPerCubicMeter);
         }
@@ -462,7 +446,7 @@ public static EnergyDensity FromWattHoursPerCubicMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>EnergyDensity unit value.</returns>
-        public static EnergyDensity From(double value, EnergyDensityUnit fromUnit)
+        public static EnergyDensity From(QuantityValue value, EnergyDensityUnit fromUnit)
         {
             return new EnergyDensity(value, fromUnit);
         }
@@ -523,10 +507,7 @@ public static EnergyDensity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static EnergyDensity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<EnergyDensity, EnergyDensityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<EnergyDensity, EnergyDensityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -554,11 +535,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out EnergyDensity re
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out EnergyDensity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<EnergyDensity, EnergyDensityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<EnergyDensity, EnergyDensityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -579,7 +556,7 @@ public static EnergyDensityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -590,7 +567,7 @@ public static EnergyDensityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.EnergyDensityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.EnergyDensityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out EnergyDensityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -605,7 +582,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out EnergyDensit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out EnergyDensityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -624,35 +601,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="EnergyDensity"/> from adding two <see cref="EnergyDensity"/>.</summary>
         public static EnergyDensity operator +(EnergyDensity left, EnergyDensity right)
         {
-            return new EnergyDensity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new EnergyDensity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="EnergyDensity"/> from subtracting two <see cref="EnergyDensity"/>.</summary>
         public static EnergyDensity operator -(EnergyDensity left, EnergyDensity right)
         {
-            return new EnergyDensity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new EnergyDensity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="EnergyDensity"/> from multiplying value and <see cref="EnergyDensity"/>.</summary>
-        public static EnergyDensity operator *(double left, EnergyDensity right)
+        public static EnergyDensity operator *(QuantityValue left, EnergyDensity right)
         {
             return new EnergyDensity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="EnergyDensity"/> from multiplying value and <see cref="EnergyDensity"/>.</summary>
-        public static EnergyDensity operator *(EnergyDensity left, double right)
+        public static EnergyDensity operator *(EnergyDensity left, QuantityValue right)
         {
             return new EnergyDensity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="EnergyDensity"/> from dividing <see cref="EnergyDensity"/> by value.</summary>
-        public static EnergyDensity operator /(EnergyDensity left, double right)
+        public static EnergyDensity operator /(EnergyDensity left, QuantityValue right)
         {
             return new EnergyDensity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="EnergyDensity"/> by <see cref="EnergyDensity"/>.</summary>
-        public static double operator /(EnergyDensity left, EnergyDensity right)
+        public static QuantityValue operator /(EnergyDensity left, EnergyDensity right)
         {
             return left.JoulesPerCubicMeter / right.JoulesPerCubicMeter;
         }
@@ -667,6 +644,18 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Energy.FromJoules(energyDensity.JoulesPerCubicMeter * volume.CubicMeters);
         }
 
+        /// <summary>Get <see cref="TemperatureDelta"/> from <see cref="EnergyDensity"/> / <see cref="VolumetricHeatCapacity"/>.</summary>
+        public static TemperatureDelta operator /(EnergyDensity energyDensity, VolumetricHeatCapacity volumetricHeatCapacity)
+        {
+            return TemperatureDelta.FromKelvins(energyDensity.JoulesPerCubicMeter / volumetricHeatCapacity.JoulesPerCubicMeterKelvin);
+        }
+
+        /// <summary>Get <see cref="VolumetricHeatCapacity"/> from <see cref="EnergyDensity"/> / <see cref="TemperatureDelta"/>.</summary>
+        public static VolumetricHeatCapacity operator /(EnergyDensity energyDensity, TemperatureDelta temperatureDelta)
+        {
+            return VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(energyDensity.JoulesPerCubicMeter / temperatureDelta.Kelvins);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -674,97 +663,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(EnergyDensity left, EnergyDensity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(EnergyDensity left, EnergyDensity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(EnergyDensity left, EnergyDensity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(EnergyDensity left, EnergyDensity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="EnergyDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(EnergyDensity other, EnergyDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="EnergyDensity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(EnergyDensity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(EnergyDensity left, EnergyDensity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="EnergyDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(EnergyDensity other, EnergyDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="EnergyDensity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(EnergyDensity,EnergyDensity)"/>.
+        ///     See that operator (and <see cref="Equals(EnergyDensity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(EnergyDensity left, EnergyDensity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="EnergyDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(EnergyDensity other, EnergyDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="EnergyDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="EnergyDensity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="EnergyDensity"/>, this method delegates to
+        ///     <see cref="Equals(EnergyDensity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is EnergyDensity otherQuantity))
+            if (obj is not EnergyDensity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="EnergyDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(EnergyDensity other, EnergyDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="EnergyDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(EnergyDensity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current EnergyDensity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(EnergyDensity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="EnergyDensity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(EnergyDensity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is EnergyDensity otherQuantity)) throw new ArgumentException("Expected type EnergyDensity.", nameof(obj));
+            if (obj is not EnergyDensity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<EnergyDensity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="EnergyDensity"/> with another <see cref="EnergyDensity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="EnergyDensity"/> with another <see cref="EnergyDensity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -776,151 +779,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(EnergyDensity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(EnergyDensityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<EnergyDensityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this EnergyDensity to another EnergyDensity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A EnergyDensity with the specified unit.</returns>
-        public EnergyDensity ToUnit(EnergyDensityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="EnergyDensity"/> to another <see cref="EnergyDensity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A EnergyDensity with the specified unit.</returns>
-        public EnergyDensity ToUnit(EnergyDensityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(EnergyDensity), Unit, typeof(EnergyDensity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (EnergyDensity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="EnergyDensity"/> to another <see cref="EnergyDensity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="EnergyDensity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(EnergyDensityUnit unit, [NotNullWhen(true)] out EnergyDensity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            EnergyDensity? convertedOrNull = (Unit, unit) switch
-            {
-                // EnergyDensityUnit -> BaseUnit
-                (EnergyDensityUnit.GigajoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity((_value) * 1e9d, EnergyDensityUnit.JoulePerCubicMeter),
-                (EnergyDensityUnit.GigawattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity((_value * 3.6e+3) * 1e9d, EnergyDensityUnit.JoulePerCubicMeter),
-                (EnergyDensityUnit.KilojoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity((_value) * 1e3d, EnergyDensityUnit.JoulePerCubicMeter),
-                (EnergyDensityUnit.KilowattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity((_value * 3.6e+3) * 1e3d, EnergyDensityUnit.JoulePerCubicMeter),
-                (EnergyDensityUnit.MegajoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity((_value) * 1e6d, EnergyDensityUnit.JoulePerCubicMeter),
-                (EnergyDensityUnit.MegawattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity((_value * 3.6e+3) * 1e6d, EnergyDensityUnit.JoulePerCubicMeter),
-                (EnergyDensityUnit.PetajoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity((_value) * 1e15d, EnergyDensityUnit.JoulePerCubicMeter),
-                (EnergyDensityUnit.PetawattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity((_value * 3.6e+3) * 1e15d, EnergyDensityUnit.JoulePerCubicMeter),
-                (EnergyDensityUnit.TerajoulePerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity((_value) * 1e12d, EnergyDensityUnit.JoulePerCubicMeter),
-                (EnergyDensityUnit.TerawattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity((_value * 3.6e+3) * 1e12d, EnergyDensityUnit.JoulePerCubicMeter),
-                (EnergyDensityUnit.WattHourPerCubicMeter, EnergyDensityUnit.JoulePerCubicMeter) => new EnergyDensity(_value * 3.6e+3, EnergyDensityUnit.JoulePerCubicMeter),
-
-                // BaseUnit -> EnergyDensityUnit
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.GigajoulePerCubicMeter) => new EnergyDensity((_value) / 1e9d, EnergyDensityUnit.GigajoulePerCubicMeter),
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.GigawattHourPerCubicMeter) => new EnergyDensity((_value / 3.6e+3) / 1e9d, EnergyDensityUnit.GigawattHourPerCubicMeter),
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.KilojoulePerCubicMeter) => new EnergyDensity((_value) / 1e3d, EnergyDensityUnit.KilojoulePerCubicMeter),
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.KilowattHourPerCubicMeter) => new EnergyDensity((_value / 3.6e+3) / 1e3d, EnergyDensityUnit.KilowattHourPerCubicMeter),
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.MegajoulePerCubicMeter) => new EnergyDensity((_value) / 1e6d, EnergyDensityUnit.MegajoulePerCubicMeter),
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.MegawattHourPerCubicMeter) => new EnergyDensity((_value / 3.6e+3) / 1e6d, EnergyDensityUnit.MegawattHourPerCubicMeter),
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.PetajoulePerCubicMeter) => new EnergyDensity((_value) / 1e15d, EnergyDensityUnit.PetajoulePerCubicMeter),
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.PetawattHourPerCubicMeter) => new EnergyDensity((_value / 3.6e+3) / 1e15d, EnergyDensityUnit.PetawattHourPerCubicMeter),
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.TerajoulePerCubicMeter) => new EnergyDensity((_value) / 1e12d, EnergyDensityUnit.TerajoulePerCubicMeter),
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.TerawattHourPerCubicMeter) => new EnergyDensity((_value / 3.6e+3) / 1e12d, EnergyDensityUnit.TerawattHourPerCubicMeter),
-                (EnergyDensityUnit.JoulePerCubicMeter, EnergyDensityUnit.WattHourPerCubicMeter) => new EnergyDensity(_value / 3.6e+3, EnergyDensityUnit.WattHourPerCubicMeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not EnergyDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyDensityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is EnergyDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity<EnergyDensityUnit> IQuantity<EnergyDensityUnit>.ToUnit(EnergyDensityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -934,11 +795,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
index 0f6fe8c8d9..94a156cf60 100644
--- a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Entropy is an important concept in the branch of science known as thermodynamics. The idea of "irreversibility" is central to the understanding of entropy.  It is often said that entropy is an expression of the disorder, or randomness of a system, or of our lack of information about it. Entropy is an extensive property. It has the dimension of energy divided by temperature, which has a unit of joules per kelvin (J/K) in the International System of Units
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Entropy :
-        IArithmeticQuantity<Entropy, EntropyUnit>,
+        ILinearQuantity<Entropy, EntropyUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Entropy, Entropy, double>,
+        IDivisionOperators<Entropy, Entropy, QuantityValue>,
         IMultiplyOperators<Entropy, TemperatureDelta, Energy>,
         IDivisionOperators<Entropy, SpecificEntropy, Mass>,
         IDivisionOperators<Entropy, Mass, SpecificEntropy>,
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static EntropyInfo CreateDefault(Func<IEnumerable<UnitDefinition<EntropyU
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Entropy"/> is [T^-2][L^2][M][Θ^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Entropy"/> is T^-2L^2MΘ^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -2, 0, -1, 0, 0);
 
@@ -120,21 +119,31 @@ public static EntropyInfo CreateDefault(Func<IEnumerable<UnitDefinition<EntropyU
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{EntropyUnit}"/> representing the default unit mappings for Entropy.</returns>
             public static IEnumerable<UnitDefinition<EntropyUnit>> GetDefaultMappings()
             {
-                yield return new (EntropyUnit.CaloriePerKelvin, "CaloriePerKelvin", "CaloriesPerKelvin", BaseUnits.Undefined);
-                yield return new (EntropyUnit.JoulePerDegreeCelsius, "JoulePerDegreeCelsius", "JoulesPerDegreeCelsius", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius));
+                yield return new (EntropyUnit.CaloriePerKelvin, "CaloriePerKelvin", "CaloriesPerKelvin", BaseUnits.Undefined,
+                     new QuantityValue(125, 523)
+                );
+                yield return new (EntropyUnit.JoulePerDegreeCelsius, "JoulePerDegreeCelsius", "JoulesPerDegreeCelsius", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius),
+                     1
+                );
                 yield return new (EntropyUnit.JoulePerKelvin, "JoulePerKelvin", "JoulesPerKelvin", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
-                yield return new (EntropyUnit.KilocaloriePerKelvin, "KilocaloriePerKelvin", "KilocaloriesPerKelvin", BaseUnits.Undefined);
-                yield return new (EntropyUnit.KilojoulePerDegreeCelsius, "KilojoulePerDegreeCelsius", "KilojoulesPerDegreeCelsius", BaseUnits.Undefined);
-                yield return new (EntropyUnit.KilojoulePerKelvin, "KilojoulePerKelvin", "KilojoulesPerKelvin", BaseUnits.Undefined);
-                yield return new (EntropyUnit.MegajoulePerKelvin, "MegajoulePerKelvin", "MegajoulesPerKelvin", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
+                yield return new (EntropyUnit.KilocaloriePerKelvin, "KilocaloriePerKelvin", "KilocaloriesPerKelvin", BaseUnits.Undefined,
+                     new QuantityValue(1, 4184)
+                );
+                yield return new (EntropyUnit.KilojoulePerDegreeCelsius, "KilojoulePerDegreeCelsius", "KilojoulesPerDegreeCelsius", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (EntropyUnit.KilojoulePerKelvin, "KilojoulePerKelvin", "KilojoulesPerKelvin", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (EntropyUnit.MegajoulePerKelvin, "MegajoulePerKelvin", "MegajoulesPerKelvin", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin),
+                     new QuantityValue(1, 1000000)
+                );
             }
         }
 
         static Entropy()
         {
-            Info = EntropyInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(EntropyInfo.CreateDefault);
         }
 
         /// <summary>
@@ -142,7 +151,7 @@ static Entropy()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Entropy(double value, EntropyUnit unit)
+        public Entropy(QuantityValue value, EntropyUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -156,7 +165,7 @@ public Entropy(double value, EntropyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Entropy(double value, UnitSystem unitSystem)
+        public Entropy(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -167,7 +176,8 @@ public Entropy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Entropy" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Entropy, EntropyUnit> Info { get; }
@@ -196,10 +206,8 @@ public Entropy(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public EntropyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -233,70 +241,44 @@ public Entropy(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.CaloriePerKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EntropyUnit.CaloriePerKelvin"/>
         /// </summary>
-        public double CaloriesPerKelvin => As(EntropyUnit.CaloriePerKelvin);
+        public QuantityValue CaloriesPerKelvin => this.As(EntropyUnit.CaloriePerKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.JoulePerDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EntropyUnit.JoulePerDegreeCelsius"/>
         /// </summary>
-        public double JoulesPerDegreeCelsius => As(EntropyUnit.JoulePerDegreeCelsius);
+        public QuantityValue JoulesPerDegreeCelsius => this.As(EntropyUnit.JoulePerDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.JoulePerKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EntropyUnit.JoulePerKelvin"/>
         /// </summary>
-        public double JoulesPerKelvin => As(EntropyUnit.JoulePerKelvin);
+        public QuantityValue JoulesPerKelvin => this.As(EntropyUnit.JoulePerKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.KilocaloriePerKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EntropyUnit.KilocaloriePerKelvin"/>
         /// </summary>
-        public double KilocaloriesPerKelvin => As(EntropyUnit.KilocaloriePerKelvin);
+        public QuantityValue KilocaloriesPerKelvin => this.As(EntropyUnit.KilocaloriePerKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.KilojoulePerDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EntropyUnit.KilojoulePerDegreeCelsius"/>
         /// </summary>
-        public double KilojoulesPerDegreeCelsius => As(EntropyUnit.KilojoulePerDegreeCelsius);
+        public QuantityValue KilojoulesPerDegreeCelsius => this.As(EntropyUnit.KilojoulePerDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.KilojoulePerKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EntropyUnit.KilojoulePerKelvin"/>
         /// </summary>
-        public double KilojoulesPerKelvin => As(EntropyUnit.KilojoulePerKelvin);
+        public QuantityValue KilojoulesPerKelvin => this.As(EntropyUnit.KilojoulePerKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="EntropyUnit.MegajoulePerKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="EntropyUnit.MegajoulePerKelvin"/>
         /// </summary>
-        public double MegajoulesPerKelvin => As(EntropyUnit.MegajoulePerKelvin);
+        public QuantityValue MegajoulesPerKelvin => this.As(EntropyUnit.MegajoulePerKelvin);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: EntropyUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.CaloriePerKelvin, EntropyUnit.JoulePerKelvin, quantity => quantity.ToUnit(EntropyUnit.JoulePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.JoulePerDegreeCelsius, EntropyUnit.JoulePerKelvin, quantity => quantity.ToUnit(EntropyUnit.JoulePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.KilocaloriePerKelvin, EntropyUnit.JoulePerKelvin, quantity => quantity.ToUnit(EntropyUnit.JoulePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.KilojoulePerDegreeCelsius, EntropyUnit.JoulePerKelvin, quantity => quantity.ToUnit(EntropyUnit.JoulePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.KilojoulePerKelvin, EntropyUnit.JoulePerKelvin, quantity => quantity.ToUnit(EntropyUnit.JoulePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.MegajoulePerKelvin, EntropyUnit.JoulePerKelvin, quantity => quantity.ToUnit(EntropyUnit.JoulePerKelvin));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.JoulePerKelvin, EntropyUnit.JoulePerKelvin, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> EntropyUnit
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.JoulePerKelvin, EntropyUnit.CaloriePerKelvin, quantity => quantity.ToUnit(EntropyUnit.CaloriePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.JoulePerKelvin, EntropyUnit.JoulePerDegreeCelsius, quantity => quantity.ToUnit(EntropyUnit.JoulePerDegreeCelsius));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.JoulePerKelvin, EntropyUnit.KilocaloriePerKelvin, quantity => quantity.ToUnit(EntropyUnit.KilocaloriePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.JoulePerKelvin, EntropyUnit.KilojoulePerDegreeCelsius, quantity => quantity.ToUnit(EntropyUnit.KilojoulePerDegreeCelsius));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.JoulePerKelvin, EntropyUnit.KilojoulePerKelvin, quantity => quantity.ToUnit(EntropyUnit.KilojoulePerKelvin));
-            unitConverter.SetConversionFunction<Entropy>(EntropyUnit.JoulePerKelvin, EntropyUnit.MegajoulePerKelvin, quantity => quantity.ToUnit(EntropyUnit.MegajoulePerKelvin));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -325,7 +307,7 @@ public static string GetAbbreviation(EntropyUnit unit, IFormatProvider? provider
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.CaloriePerKelvin"/>.
         /// </summary>
-        public static Entropy FromCaloriesPerKelvin(double value)
+        public static Entropy FromCaloriesPerKelvin(QuantityValue value)
         {
             return new Entropy(value, EntropyUnit.CaloriePerKelvin);
         }
@@ -333,7 +315,7 @@ public static Entropy FromCaloriesPerKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.JoulePerDegreeCelsius"/>.
         /// </summary>
-        public static Entropy FromJoulesPerDegreeCelsius(double value)
+        public static Entropy FromJoulesPerDegreeCelsius(QuantityValue value)
         {
             return new Entropy(value, EntropyUnit.JoulePerDegreeCelsius);
         }
@@ -341,7 +323,7 @@ public static Entropy FromJoulesPerDegreeCelsius(double value)
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.JoulePerKelvin"/>.
         /// </summary>
-        public static Entropy FromJoulesPerKelvin(double value)
+        public static Entropy FromJoulesPerKelvin(QuantityValue value)
         {
             return new Entropy(value, EntropyUnit.JoulePerKelvin);
         }
@@ -349,7 +331,7 @@ public static Entropy FromJoulesPerKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilocaloriePerKelvin"/>.
         /// </summary>
-        public static Entropy FromKilocaloriesPerKelvin(double value)
+        public static Entropy FromKilocaloriesPerKelvin(QuantityValue value)
         {
             return new Entropy(value, EntropyUnit.KilocaloriePerKelvin);
         }
@@ -357,7 +339,7 @@ public static Entropy FromKilocaloriesPerKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilojoulePerDegreeCelsius"/>.
         /// </summary>
-        public static Entropy FromKilojoulesPerDegreeCelsius(double value)
+        public static Entropy FromKilojoulesPerDegreeCelsius(QuantityValue value)
         {
             return new Entropy(value, EntropyUnit.KilojoulePerDegreeCelsius);
         }
@@ -365,7 +347,7 @@ public static Entropy FromKilojoulesPerDegreeCelsius(double value)
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilojoulePerKelvin"/>.
         /// </summary>
-        public static Entropy FromKilojoulesPerKelvin(double value)
+        public static Entropy FromKilojoulesPerKelvin(QuantityValue value)
         {
             return new Entropy(value, EntropyUnit.KilojoulePerKelvin);
         }
@@ -373,7 +355,7 @@ public static Entropy FromKilojoulesPerKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.MegajoulePerKelvin"/>.
         /// </summary>
-        public static Entropy FromMegajoulesPerKelvin(double value)
+        public static Entropy FromMegajoulesPerKelvin(QuantityValue value)
         {
             return new Entropy(value, EntropyUnit.MegajoulePerKelvin);
         }
@@ -384,7 +366,7 @@ public static Entropy FromMegajoulesPerKelvin(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Entropy unit value.</returns>
-        public static Entropy From(double value, EntropyUnit fromUnit)
+        public static Entropy From(QuantityValue value, EntropyUnit fromUnit)
         {
             return new Entropy(value, fromUnit);
         }
@@ -445,10 +427,7 @@ public static Entropy Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Entropy Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Entropy, EntropyUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Entropy, EntropyUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -476,11 +455,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Entropy result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Entropy result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Entropy, EntropyUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Entropy, EntropyUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -501,7 +476,7 @@ public static EntropyUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -512,7 +487,7 @@ public static EntropyUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.EntropyUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.EntropyUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out EntropyUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -527,7 +502,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out EntropyUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out EntropyUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -546,35 +521,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Entropy"/> from adding two <see cref="Entropy"/>.</summary>
         public static Entropy operator +(Entropy left, Entropy right)
         {
-            return new Entropy(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Entropy(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Entropy"/> from subtracting two <see cref="Entropy"/>.</summary>
         public static Entropy operator -(Entropy left, Entropy right)
         {
-            return new Entropy(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Entropy(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Entropy"/> from multiplying value and <see cref="Entropy"/>.</summary>
-        public static Entropy operator *(double left, Entropy right)
+        public static Entropy operator *(QuantityValue left, Entropy right)
         {
             return new Entropy(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Entropy"/> from multiplying value and <see cref="Entropy"/>.</summary>
-        public static Entropy operator *(Entropy left, double right)
+        public static Entropy operator *(Entropy left, QuantityValue right)
         {
             return new Entropy(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Entropy"/> from dividing <see cref="Entropy"/> by value.</summary>
-        public static Entropy operator /(Entropy left, double right)
+        public static Entropy operator /(Entropy left, QuantityValue right)
         {
             return new Entropy(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Entropy"/> by <see cref="Entropy"/>.</summary>
-        public static double operator /(Entropy left, Entropy right)
+        public static QuantityValue operator /(Entropy left, Entropy right)
         {
             return left.JoulesPerKelvin / right.JoulesPerKelvin;
         }
@@ -608,97 +583,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Entropy left, Entropy right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Entropy left, Entropy right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Entropy left, Entropy right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Entropy left, Entropy right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Entropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Entropy other, Entropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Entropy"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Entropy)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Entropy left, Entropy right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Entropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Entropy other, Entropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Entropy"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Entropy,Entropy)"/>.
+        ///     See that operator (and <see cref="Equals(Entropy)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Entropy left, Entropy right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Entropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Entropy other, Entropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Entropy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Entropy"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Entropy"/>, this method delegates to
+        ///     <see cref="Equals(Entropy)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Entropy otherQuantity))
+            if (obj is not Entropy otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Entropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Entropy other, Entropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Entropy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Entropy other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Entropy.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Entropy), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Entropy"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Entropy)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Entropy otherQuantity)) throw new ArgumentException("Expected type Entropy.", nameof(obj));
+            if (obj is not Entropy otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Entropy>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Entropy"/> with another <see cref="Entropy"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Entropy"/> with another <see cref="Entropy"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -710,141 +699,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Entropy other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(EntropyUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<EntropyUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Entropy to another Entropy with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Entropy with the specified unit.</returns>
-        public Entropy ToUnit(EntropyUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="Entropy"/> to another <see cref="Entropy"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Entropy with the specified unit.</returns>
-        public Entropy ToUnit(EntropyUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Entropy), Unit, typeof(Entropy), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Entropy)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Entropy"/> to another <see cref="Entropy"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Entropy"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(EntropyUnit unit, [NotNullWhen(true)] out Entropy? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Entropy? convertedOrNull = (Unit, unit) switch
-            {
-                // EntropyUnit -> BaseUnit
-                (EntropyUnit.CaloriePerKelvin, EntropyUnit.JoulePerKelvin) => new Entropy(_value * 4.184, EntropyUnit.JoulePerKelvin),
-                (EntropyUnit.JoulePerDegreeCelsius, EntropyUnit.JoulePerKelvin) => new Entropy(_value, EntropyUnit.JoulePerKelvin),
-                (EntropyUnit.KilocaloriePerKelvin, EntropyUnit.JoulePerKelvin) => new Entropy((_value * 4.184) * 1e3d, EntropyUnit.JoulePerKelvin),
-                (EntropyUnit.KilojoulePerDegreeCelsius, EntropyUnit.JoulePerKelvin) => new Entropy((_value) * 1e3d, EntropyUnit.JoulePerKelvin),
-                (EntropyUnit.KilojoulePerKelvin, EntropyUnit.JoulePerKelvin) => new Entropy((_value) * 1e3d, EntropyUnit.JoulePerKelvin),
-                (EntropyUnit.MegajoulePerKelvin, EntropyUnit.JoulePerKelvin) => new Entropy((_value) * 1e6d, EntropyUnit.JoulePerKelvin),
-
-                // BaseUnit -> EntropyUnit
-                (EntropyUnit.JoulePerKelvin, EntropyUnit.CaloriePerKelvin) => new Entropy(_value / 4.184, EntropyUnit.CaloriePerKelvin),
-                (EntropyUnit.JoulePerKelvin, EntropyUnit.JoulePerDegreeCelsius) => new Entropy(_value, EntropyUnit.JoulePerDegreeCelsius),
-                (EntropyUnit.JoulePerKelvin, EntropyUnit.KilocaloriePerKelvin) => new Entropy((_value / 4.184) / 1e3d, EntropyUnit.KilocaloriePerKelvin),
-                (EntropyUnit.JoulePerKelvin, EntropyUnit.KilojoulePerDegreeCelsius) => new Entropy((_value) / 1e3d, EntropyUnit.KilojoulePerDegreeCelsius),
-                (EntropyUnit.JoulePerKelvin, EntropyUnit.KilojoulePerKelvin) => new Entropy((_value) / 1e3d, EntropyUnit.KilojoulePerKelvin),
-                (EntropyUnit.JoulePerKelvin, EntropyUnit.MegajoulePerKelvin) => new Entropy((_value) / 1e6d, EntropyUnit.MegajoulePerKelvin),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not EntropyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EntropyUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is EntropyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EntropyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<EntropyUnit> IQuantity<EntropyUnit>.ToUnit(EntropyUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -858,11 +715,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/FluidResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/FluidResistance.g.cs
index d92219473d..ba5ba97aea 100644
--- a/UnitsNet/GeneratedCode/Quantities/FluidResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/FluidResistance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Friction#Fluid
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct FluidResistance :
-        IArithmeticQuantity<FluidResistance, FluidResistanceUnit>,
+        ILinearQuantity<FluidResistance, FluidResistanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<FluidResistance, FluidResistance, double>,
+        IDivisionOperators<FluidResistance, FluidResistance, QuantityValue>,
+        IMultiplyOperators<FluidResistance, VolumeFlow, Pressure>,
         IComparisonOperators<FluidResistance, FluidResistance, bool>,
         IParsable<FluidResistance>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static FluidResistanceInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="FluidResistance"/> is [T^-1][L^-4][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="FluidResistance"/> is T^-1L^-4M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-4, 1, -1, 0, 0, 0, 0);
 
@@ -120,33 +120,67 @@ public static FluidResistanceInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{FluidResistanceUnit}"/> representing the default unit mappings for FluidResistance.</returns>
             public static IEnumerable<UnitDefinition<FluidResistanceUnit>> GetDefaultMappings()
             {
-                yield return new (FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth, "DyneSecondPerCentimeterToTheFifth", "DyneSecondsPerCentimeterToTheFifth", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.MegapascalSecondPerCubicMeter, "MegapascalSecondPerCubicMeter", "MegapascalSecondsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Microsecond));
-                yield return new (FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter, "MillimeterMercuryMinutePerCubicCentimeter", "MillimeterMercuryMinutesPerCubicCentimeter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter, "MillimeterMercuryMinutePerCubicMeter", "MillimeterMercuryMinutesPerCubicMeter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.MillimeterMercuryMinutePerLiter, "MillimeterMercuryMinutePerLiter", "MillimeterMercuryMinutesPerLiter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter, "MillimeterMercuryMinutePerMilliliter", "MillimeterMercuryMinutesPerMilliliter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter, "MillimeterMercurySecondPerCubicCentimeter", "MillimeterMercurySecondsPerCubicCentimeter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter, "MillimeterMercurySecondPerCubicMeter", "MillimeterMercurySecondsPerCubicMeter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.MillimeterMercurySecondPerLiter, "MillimeterMercurySecondPerLiter", "MillimeterMercurySecondsPerLiter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.MillimeterMercurySecondPerMilliliter, "MillimeterMercurySecondPerMilliliter", "MillimeterMercurySecondsPerMilliliter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.PascalMinutePerCubicCentimeter, "PascalMinutePerCubicCentimeter", "PascalMinutesPerCubicCentimeter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.PascalMinutePerCubicMeter, "PascalMinutePerCubicMeter", "PascalMinutesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute));
-                yield return new (FluidResistanceUnit.PascalMinutePerLiter, "PascalMinutePerLiter", "PascalMinutesPerLiter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute));
-                yield return new (FluidResistanceUnit.PascalMinutePerMilliliter, "PascalMinutePerMilliliter", "PascalMinutesPerMilliliter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.PascalSecondPerCubicCentimeter, "PascalSecondPerCubicCentimeter", "PascalSecondsPerCubicCentimeter", BaseUnits.Undefined);
+                yield return new (FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth, "DyneSecondPerCentimeterToTheFifth", "DyneSecondsPerCentimeterToTheFifth", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000)
+                );
+                yield return new (FluidResistanceUnit.MegapascalSecondPerCubicMeter, "MegapascalSecondPerCubicMeter", "MegapascalSecondsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Microsecond),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter, "MillimeterMercuryMinutePerCubicCentimeter", "MillimeterMercuryMinutesPerCubicCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 7999342080)
+                );
+                yield return new (FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter, "MillimeterMercuryMinutePerCubicMeter", "MillimeterMercuryMinutesPerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(3125, 24997944)
+                );
+                yield return new (FluidResistanceUnit.MillimeterMercuryMinutePerLiter, "MillimeterMercuryMinutePerLiter", "MillimeterMercuryMinutesPerLiter", BaseUnits.Undefined,
+                     new QuantityValue(25, 199983552)
+                );
+                yield return new (FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter, "MillimeterMercuryMinutePerMilliliter", "MillimeterMercuryMinutesPerMilliliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 7999342080)
+                );
+                yield return new (FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter, "MillimeterMercurySecondPerCubicCentimeter", "MillimeterMercurySecondsPerCubicCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 133322368)
+                );
+                yield return new (FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter, "MillimeterMercurySecondPerCubicMeter", "MillimeterMercurySecondsPerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(15625, 2083162)
+                );
+                yield return new (FluidResistanceUnit.MillimeterMercurySecondPerLiter, "MillimeterMercurySecondPerLiter", "MillimeterMercurySecondsPerLiter", BaseUnits.Undefined,
+                     new QuantityValue(125, 16665296)
+                );
+                yield return new (FluidResistanceUnit.MillimeterMercurySecondPerMilliliter, "MillimeterMercurySecondPerMilliliter", "MillimeterMercurySecondsPerMilliliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 133322368)
+                );
+                yield return new (FluidResistanceUnit.PascalMinutePerCubicCentimeter, "PascalMinutePerCubicCentimeter", "PascalMinutesPerCubicCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 60000000)
+                );
+                yield return new (FluidResistanceUnit.PascalMinutePerCubicMeter, "PascalMinutePerCubicMeter", "PascalMinutesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute),
+                     new QuantityValue(1, 60)
+                );
+                yield return new (FluidResistanceUnit.PascalMinutePerLiter, "PascalMinutePerLiter", "PascalMinutesPerLiter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute),
+                     new QuantityValue(1, 60000)
+                );
+                yield return new (FluidResistanceUnit.PascalMinutePerMilliliter, "PascalMinutePerMilliliter", "PascalMinutesPerMilliliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 60000000)
+                );
+                yield return new (FluidResistanceUnit.PascalSecondPerCubicCentimeter, "PascalSecondPerCubicCentimeter", "PascalSecondsPerCubicCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
                 yield return new (FluidResistanceUnit.PascalSecondPerCubicMeter, "PascalSecondPerCubicMeter", "PascalSecondsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (FluidResistanceUnit.PascalSecondPerLiter, "PascalSecondPerLiter", "PascalSecondsPerLiter", BaseUnits.Undefined);
-                yield return new (FluidResistanceUnit.PascalSecondPerMilliliter, "PascalSecondPerMilliliter", "PascalSecondsPerMilliliter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (FluidResistanceUnit.WoodUnit, "WoodUnit", "WoodUnits", BaseUnits.Undefined);
+                yield return new (FluidResistanceUnit.PascalSecondPerLiter, "PascalSecondPerLiter", "PascalSecondsPerLiter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (FluidResistanceUnit.PascalSecondPerMilliliter, "PascalSecondPerMilliliter", "PascalSecondsPerMilliliter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (FluidResistanceUnit.WoodUnit, "WoodUnit", "WoodUnits", BaseUnits.Undefined,
+                     new QuantityValue(25, 199983552)
+                );
             }
         }
 
         static FluidResistance()
         {
-            Info = FluidResistanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(FluidResistanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -154,7 +188,7 @@ static FluidResistance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public FluidResistance(double value, FluidResistanceUnit unit)
+        public FluidResistance(QuantityValue value, FluidResistanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -168,7 +202,7 @@ public FluidResistance(double value, FluidResistanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public FluidResistance(double value, UnitSystem unitSystem)
+        public FluidResistance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -179,7 +213,8 @@ public FluidResistance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="FluidResistance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<FluidResistance, FluidResistanceUnit> Info { get; }
@@ -208,10 +243,8 @@ public FluidResistance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public FluidResistanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -245,154 +278,104 @@ public FluidResistance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth"/>
         /// </summary>
-        public double DyneSecondsPerCentimeterToTheFifth => As(FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth);
+        public QuantityValue DyneSecondsPerCentimeterToTheFifth => this.As(FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MegapascalSecondPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.MegapascalSecondPerCubicMeter"/>
         /// </summary>
-        public double MegapascalSecondsPerCubicMeter => As(FluidResistanceUnit.MegapascalSecondPerCubicMeter);
+        public QuantityValue MegapascalSecondsPerCubicMeter => this.As(FluidResistanceUnit.MegapascalSecondPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter"/>
         /// </summary>
-        public double MillimeterMercuryMinutesPerCubicCentimeter => As(FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter);
+        public QuantityValue MillimeterMercuryMinutesPerCubicCentimeter => this.As(FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter"/>
         /// </summary>
-        public double MillimeterMercuryMinutesPerCubicMeter => As(FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter);
+        public QuantityValue MillimeterMercuryMinutesPerCubicMeter => this.As(FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerLiter"/>
         /// </summary>
-        public double MillimeterMercuryMinutesPerLiter => As(FluidResistanceUnit.MillimeterMercuryMinutePerLiter);
+        public QuantityValue MillimeterMercuryMinutesPerLiter => this.As(FluidResistanceUnit.MillimeterMercuryMinutePerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter"/>
         /// </summary>
-        public double MillimeterMercuryMinutesPerMilliliter => As(FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter);
+        public QuantityValue MillimeterMercuryMinutesPerMilliliter => this.As(FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter"/>
         /// </summary>
-        public double MillimeterMercurySecondsPerCubicCentimeter => As(FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter);
+        public QuantityValue MillimeterMercurySecondsPerCubicCentimeter => this.As(FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter"/>
         /// </summary>
-        public double MillimeterMercurySecondsPerCubicMeter => As(FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter);
+        public QuantityValue MillimeterMercurySecondsPerCubicMeter => this.As(FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerLiter"/>
         /// </summary>
-        public double MillimeterMercurySecondsPerLiter => As(FluidResistanceUnit.MillimeterMercurySecondPerLiter);
+        public QuantityValue MillimeterMercurySecondsPerLiter => this.As(FluidResistanceUnit.MillimeterMercurySecondPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.MillimeterMercurySecondPerMilliliter"/>
         /// </summary>
-        public double MillimeterMercurySecondsPerMilliliter => As(FluidResistanceUnit.MillimeterMercurySecondPerMilliliter);
+        public QuantityValue MillimeterMercurySecondsPerMilliliter => this.As(FluidResistanceUnit.MillimeterMercurySecondPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerCubicCentimeter"/>
         /// </summary>
-        public double PascalMinutesPerCubicCentimeter => As(FluidResistanceUnit.PascalMinutePerCubicCentimeter);
+        public QuantityValue PascalMinutesPerCubicCentimeter => this.As(FluidResistanceUnit.PascalMinutePerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerCubicMeter"/>
         /// </summary>
-        public double PascalMinutesPerCubicMeter => As(FluidResistanceUnit.PascalMinutePerCubicMeter);
+        public QuantityValue PascalMinutesPerCubicMeter => this.As(FluidResistanceUnit.PascalMinutePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerLiter"/>
         /// </summary>
-        public double PascalMinutesPerLiter => As(FluidResistanceUnit.PascalMinutePerLiter);
+        public QuantityValue PascalMinutesPerLiter => this.As(FluidResistanceUnit.PascalMinutePerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalMinutePerMilliliter"/>
         /// </summary>
-        public double PascalMinutesPerMilliliter => As(FluidResistanceUnit.PascalMinutePerMilliliter);
+        public QuantityValue PascalMinutesPerMilliliter => this.As(FluidResistanceUnit.PascalMinutePerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerCubicCentimeter"/>
         /// </summary>
-        public double PascalSecondsPerCubicCentimeter => As(FluidResistanceUnit.PascalSecondPerCubicCentimeter);
+        public QuantityValue PascalSecondsPerCubicCentimeter => this.As(FluidResistanceUnit.PascalSecondPerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerCubicMeter"/>
         /// </summary>
-        public double PascalSecondsPerCubicMeter => As(FluidResistanceUnit.PascalSecondPerCubicMeter);
+        public QuantityValue PascalSecondsPerCubicMeter => this.As(FluidResistanceUnit.PascalSecondPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerLiter"/>
         /// </summary>
-        public double PascalSecondsPerLiter => As(FluidResistanceUnit.PascalSecondPerLiter);
+        public QuantityValue PascalSecondsPerLiter => this.As(FluidResistanceUnit.PascalSecondPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.PascalSecondPerMilliliter"/>
         /// </summary>
-        public double PascalSecondsPerMilliliter => As(FluidResistanceUnit.PascalSecondPerMilliliter);
+        public QuantityValue PascalSecondsPerMilliliter => this.As(FluidResistanceUnit.PascalSecondPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FluidResistanceUnit.WoodUnit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FluidResistanceUnit.WoodUnit"/>
         /// </summary>
-        public double WoodUnits => As(FluidResistanceUnit.WoodUnit);
+        public QuantityValue WoodUnits => this.As(FluidResistanceUnit.WoodUnit);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: FluidResistanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.MegapascalSecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.MillimeterMercuryMinutePerLiter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.MillimeterMercurySecondPerLiter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.MillimeterMercurySecondPerMilliliter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalMinutePerCubicCentimeter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalMinutePerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalMinutePerLiter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalMinutePerMilliliter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicCentimeter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerLiter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerMilliliter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.WoodUnit, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> FluidResistanceUnit
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth, quantity => quantity.ToUnit(FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MegapascalSecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.MegapascalSecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter, quantity => quantity.ToUnit(FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercuryMinutePerLiter, quantity => quantity.ToUnit(FluidResistanceUnit.MillimeterMercuryMinutePerLiter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter, quantity => quantity.ToUnit(FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter, quantity => quantity.ToUnit(FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercurySecondPerLiter, quantity => quantity.ToUnit(FluidResistanceUnit.MillimeterMercurySecondPerLiter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercurySecondPerMilliliter, quantity => quantity.ToUnit(FluidResistanceUnit.MillimeterMercurySecondPerMilliliter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalMinutePerCubicCentimeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalMinutePerCubicCentimeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalMinutePerCubicMeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalMinutePerCubicMeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalMinutePerLiter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalMinutePerLiter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalMinutePerMilliliter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalMinutePerMilliliter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicCentimeter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerCubicCentimeter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerLiter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerLiter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerMilliliter, quantity => quantity.ToUnit(FluidResistanceUnit.PascalSecondPerMilliliter));
-            unitConverter.SetConversionFunction<FluidResistance>(FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.WoodUnit, quantity => quantity.ToUnit(FluidResistanceUnit.WoodUnit));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -421,7 +404,7 @@ public static string GetAbbreviation(FluidResistanceUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth"/>.
         /// </summary>
-        public static FluidResistance FromDyneSecondsPerCentimeterToTheFifth(double value)
+        public static FluidResistance FromDyneSecondsPerCentimeterToTheFifth(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth);
         }
@@ -429,7 +412,7 @@ public static FluidResistance FromDyneSecondsPerCentimeterToTheFifth(double valu
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MegapascalSecondPerCubicMeter"/>.
         /// </summary>
-        public static FluidResistance FromMegapascalSecondsPerCubicMeter(double value)
+        public static FluidResistance FromMegapascalSecondsPerCubicMeter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.MegapascalSecondPerCubicMeter);
         }
@@ -437,7 +420,7 @@ public static FluidResistance FromMegapascalSecondsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter"/>.
         /// </summary>
-        public static FluidResistance FromMillimeterMercuryMinutesPerCubicCentimeter(double value)
+        public static FluidResistance FromMillimeterMercuryMinutesPerCubicCentimeter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter);
         }
@@ -445,7 +428,7 @@ public static FluidResistance FromMillimeterMercuryMinutesPerCubicCentimeter(dou
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter"/>.
         /// </summary>
-        public static FluidResistance FromMillimeterMercuryMinutesPerCubicMeter(double value)
+        public static FluidResistance FromMillimeterMercuryMinutesPerCubicMeter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter);
         }
@@ -453,7 +436,7 @@ public static FluidResistance FromMillimeterMercuryMinutesPerCubicMeter(double v
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerLiter"/>.
         /// </summary>
-        public static FluidResistance FromMillimeterMercuryMinutesPerLiter(double value)
+        public static FluidResistance FromMillimeterMercuryMinutesPerLiter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.MillimeterMercuryMinutePerLiter);
         }
@@ -461,7 +444,7 @@ public static FluidResistance FromMillimeterMercuryMinutesPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter"/>.
         /// </summary>
-        public static FluidResistance FromMillimeterMercuryMinutesPerMilliliter(double value)
+        public static FluidResistance FromMillimeterMercuryMinutesPerMilliliter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter);
         }
@@ -469,7 +452,7 @@ public static FluidResistance FromMillimeterMercuryMinutesPerMilliliter(double v
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter"/>.
         /// </summary>
-        public static FluidResistance FromMillimeterMercurySecondsPerCubicCentimeter(double value)
+        public static FluidResistance FromMillimeterMercurySecondsPerCubicCentimeter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter);
         }
@@ -477,7 +460,7 @@ public static FluidResistance FromMillimeterMercurySecondsPerCubicCentimeter(dou
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter"/>.
         /// </summary>
-        public static FluidResistance FromMillimeterMercurySecondsPerCubicMeter(double value)
+        public static FluidResistance FromMillimeterMercurySecondsPerCubicMeter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter);
         }
@@ -485,7 +468,7 @@ public static FluidResistance FromMillimeterMercurySecondsPerCubicMeter(double v
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercurySecondPerLiter"/>.
         /// </summary>
-        public static FluidResistance FromMillimeterMercurySecondsPerLiter(double value)
+        public static FluidResistance FromMillimeterMercurySecondsPerLiter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.MillimeterMercurySecondPerLiter);
         }
@@ -493,7 +476,7 @@ public static FluidResistance FromMillimeterMercurySecondsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.MillimeterMercurySecondPerMilliliter"/>.
         /// </summary>
-        public static FluidResistance FromMillimeterMercurySecondsPerMilliliter(double value)
+        public static FluidResistance FromMillimeterMercurySecondsPerMilliliter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.MillimeterMercurySecondPerMilliliter);
         }
@@ -501,7 +484,7 @@ public static FluidResistance FromMillimeterMercurySecondsPerMilliliter(double v
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalMinutePerCubicCentimeter"/>.
         /// </summary>
-        public static FluidResistance FromPascalMinutesPerCubicCentimeter(double value)
+        public static FluidResistance FromPascalMinutesPerCubicCentimeter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.PascalMinutePerCubicCentimeter);
         }
@@ -509,7 +492,7 @@ public static FluidResistance FromPascalMinutesPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalMinutePerCubicMeter"/>.
         /// </summary>
-        public static FluidResistance FromPascalMinutesPerCubicMeter(double value)
+        public static FluidResistance FromPascalMinutesPerCubicMeter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.PascalMinutePerCubicMeter);
         }
@@ -517,7 +500,7 @@ public static FluidResistance FromPascalMinutesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalMinutePerLiter"/>.
         /// </summary>
-        public static FluidResistance FromPascalMinutesPerLiter(double value)
+        public static FluidResistance FromPascalMinutesPerLiter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.PascalMinutePerLiter);
         }
@@ -525,7 +508,7 @@ public static FluidResistance FromPascalMinutesPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalMinutePerMilliliter"/>.
         /// </summary>
-        public static FluidResistance FromPascalMinutesPerMilliliter(double value)
+        public static FluidResistance FromPascalMinutesPerMilliliter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.PascalMinutePerMilliliter);
         }
@@ -533,7 +516,7 @@ public static FluidResistance FromPascalMinutesPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalSecondPerCubicCentimeter"/>.
         /// </summary>
-        public static FluidResistance FromPascalSecondsPerCubicCentimeter(double value)
+        public static FluidResistance FromPascalSecondsPerCubicCentimeter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.PascalSecondPerCubicCentimeter);
         }
@@ -541,7 +524,7 @@ public static FluidResistance FromPascalSecondsPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalSecondPerCubicMeter"/>.
         /// </summary>
-        public static FluidResistance FromPascalSecondsPerCubicMeter(double value)
+        public static FluidResistance FromPascalSecondsPerCubicMeter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.PascalSecondPerCubicMeter);
         }
@@ -549,7 +532,7 @@ public static FluidResistance FromPascalSecondsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalSecondPerLiter"/>.
         /// </summary>
-        public static FluidResistance FromPascalSecondsPerLiter(double value)
+        public static FluidResistance FromPascalSecondsPerLiter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.PascalSecondPerLiter);
         }
@@ -557,7 +540,7 @@ public static FluidResistance FromPascalSecondsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.PascalSecondPerMilliliter"/>.
         /// </summary>
-        public static FluidResistance FromPascalSecondsPerMilliliter(double value)
+        public static FluidResistance FromPascalSecondsPerMilliliter(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.PascalSecondPerMilliliter);
         }
@@ -565,7 +548,7 @@ public static FluidResistance FromPascalSecondsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="FluidResistance"/> from <see cref="FluidResistanceUnit.WoodUnit"/>.
         /// </summary>
-        public static FluidResistance FromWoodUnits(double value)
+        public static FluidResistance FromWoodUnits(QuantityValue value)
         {
             return new FluidResistance(value, FluidResistanceUnit.WoodUnit);
         }
@@ -576,7 +559,7 @@ public static FluidResistance FromWoodUnits(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>FluidResistance unit value.</returns>
-        public static FluidResistance From(double value, FluidResistanceUnit fromUnit)
+        public static FluidResistance From(QuantityValue value, FluidResistanceUnit fromUnit)
         {
             return new FluidResistance(value, fromUnit);
         }
@@ -637,10 +620,7 @@ public static FluidResistance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static FluidResistance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<FluidResistance, FluidResistanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<FluidResistance, FluidResistanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -668,11 +648,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out FluidResistance
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out FluidResistance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<FluidResistance, FluidResistanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<FluidResistance, FluidResistanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -693,7 +669,7 @@ public static FluidResistanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -704,7 +680,7 @@ public static FluidResistanceUnit ParseUnit(string str, IFormatProvider? provide
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.FluidResistanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.FluidResistanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out FluidResistanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -719,7 +695,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out FluidResista
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out FluidResistanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -738,137 +714,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="FluidResistance"/> from adding two <see cref="FluidResistance"/>.</summary>
         public static FluidResistance operator +(FluidResistance left, FluidResistance right)
         {
-            return new FluidResistance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new FluidResistance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="FluidResistance"/> from subtracting two <see cref="FluidResistance"/>.</summary>
         public static FluidResistance operator -(FluidResistance left, FluidResistance right)
         {
-            return new FluidResistance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new FluidResistance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="FluidResistance"/> from multiplying value and <see cref="FluidResistance"/>.</summary>
-        public static FluidResistance operator *(double left, FluidResistance right)
+        public static FluidResistance operator *(QuantityValue left, FluidResistance right)
         {
             return new FluidResistance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="FluidResistance"/> from multiplying value and <see cref="FluidResistance"/>.</summary>
-        public static FluidResistance operator *(FluidResistance left, double right)
+        public static FluidResistance operator *(FluidResistance left, QuantityValue right)
         {
             return new FluidResistance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="FluidResistance"/> from dividing <see cref="FluidResistance"/> by value.</summary>
-        public static FluidResistance operator /(FluidResistance left, double right)
+        public static FluidResistance operator /(FluidResistance left, QuantityValue right)
         {
             return new FluidResistance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="FluidResistance"/> by <see cref="FluidResistance"/>.</summary>
-        public static double operator /(FluidResistance left, FluidResistance right)
+        public static QuantityValue operator /(FluidResistance left, FluidResistance right)
         {
             return left.PascalSecondsPerCubicMeter / right.PascalSecondsPerCubicMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Pressure"/> from <see cref="FluidResistance"/> * <see cref="VolumeFlow"/>.</summary>
+        public static Pressure operator *(FluidResistance fluidResistance, VolumeFlow volumeFlow)
+        {
+            return Pressure.FromPascals(fluidResistance.PascalSecondsPerCubicMeter * volumeFlow.CubicMetersPerSecond);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(FluidResistance left, FluidResistance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(FluidResistance left, FluidResistance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(FluidResistance left, FluidResistance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(FluidResistance left, FluidResistance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="FluidResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(FluidResistance other, FluidResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="FluidResistance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(FluidResistance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(FluidResistance left, FluidResistance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="FluidResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(FluidResistance other, FluidResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="FluidResistance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(FluidResistance,FluidResistance)"/>.
+        ///     See that operator (and <see cref="Equals(FluidResistance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(FluidResistance left, FluidResistance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="FluidResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(FluidResistance other, FluidResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="FluidResistance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="FluidResistance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="FluidResistance"/>, this method delegates to
+        ///     <see cref="Equals(FluidResistance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is FluidResistance otherQuantity))
+            if (obj is not FluidResistance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="FluidResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(FluidResistance other, FluidResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="FluidResistance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(FluidResistance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current FluidResistance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(FluidResistance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="FluidResistance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(FluidResistance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is FluidResistance otherQuantity)) throw new ArgumentException("Expected type FluidResistance.", nameof(obj));
+            if (obj is not FluidResistance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<FluidResistance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="FluidResistance"/> with another <see cref="FluidResistance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="FluidResistance"/> with another <see cref="FluidResistance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -880,165 +880,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(FluidResistance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(FluidResistanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<FluidResistanceUnit>());
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this FluidResistance to another FluidResistance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A FluidResistance with the specified unit.</returns>
-        public FluidResistance ToUnit(FluidResistanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="FluidResistance"/> to another <see cref="FluidResistance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A FluidResistance with the specified unit.</returns>
-        public FluidResistance ToUnit(FluidResistanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(FluidResistance), Unit, typeof(FluidResistance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (FluidResistance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="FluidResistance"/> to another <see cref="FluidResistance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="FluidResistance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(FluidResistanceUnit unit, [NotNullWhen(true)] out FluidResistance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            FluidResistance? convertedOrNull = (Unit, unit) switch
-            {
-                // FluidResistanceUnit -> BaseUnit
-                (FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 1e5, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.MegapascalSecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance((_value) * 1e6d, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 7.99934208e9, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 7.99934208e3, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.MillimeterMercuryMinutePerLiter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 7.99934208e6, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 7.99934208e9, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 1.33322368e8, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 133.322368, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.MillimeterMercurySecondPerLiter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 1.33322368e5, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.MillimeterMercurySecondPerMilliliter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 1.33322368e8, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.PascalMinutePerCubicCentimeter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 6e7, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.PascalMinutePerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 60, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.PascalMinutePerLiter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 6e4, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.PascalMinutePerMilliliter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 6e7, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.PascalSecondPerCubicCentimeter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 1e6, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.PascalSecondPerLiter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 1e3, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.PascalSecondPerMilliliter, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 1e6, FluidResistanceUnit.PascalSecondPerCubicMeter),
-                (FluidResistanceUnit.WoodUnit, FluidResistanceUnit.PascalSecondPerCubicMeter) => new FluidResistance(_value * 7.99934208e6, FluidResistanceUnit.PascalSecondPerCubicMeter),
-
-                // BaseUnit -> FluidResistanceUnit
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth) => new FluidResistance(_value / 1e5, FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MegapascalSecondPerCubicMeter) => new FluidResistance((_value) / 1e6d, FluidResistanceUnit.MegapascalSecondPerCubicMeter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter) => new FluidResistance(_value / 7.99934208e9, FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter) => new FluidResistance(_value / 7.99934208e3, FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercuryMinutePerLiter) => new FluidResistance(_value / 7.99934208e6, FluidResistanceUnit.MillimeterMercuryMinutePerLiter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter) => new FluidResistance(_value / 7.99934208e9, FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter) => new FluidResistance(_value / 1.33322368e8, FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter) => new FluidResistance(_value / 133.322368, FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercurySecondPerLiter) => new FluidResistance(_value / 1.33322368e5, FluidResistanceUnit.MillimeterMercurySecondPerLiter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.MillimeterMercurySecondPerMilliliter) => new FluidResistance(_value / 1.33322368e8, FluidResistanceUnit.MillimeterMercurySecondPerMilliliter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalMinutePerCubicCentimeter) => new FluidResistance(_value / 6e7, FluidResistanceUnit.PascalMinutePerCubicCentimeter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalMinutePerCubicMeter) => new FluidResistance(_value / 60, FluidResistanceUnit.PascalMinutePerCubicMeter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalMinutePerLiter) => new FluidResistance(_value / 6e4, FluidResistanceUnit.PascalMinutePerLiter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalMinutePerMilliliter) => new FluidResistance(_value / 6e7, FluidResistanceUnit.PascalMinutePerMilliliter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerCubicCentimeter) => new FluidResistance(_value / 1e6, FluidResistanceUnit.PascalSecondPerCubicCentimeter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerLiter) => new FluidResistance(_value / 1e3, FluidResistanceUnit.PascalSecondPerLiter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.PascalSecondPerMilliliter) => new FluidResistance(_value / 1e6, FluidResistanceUnit.PascalSecondPerMilliliter),
-                (FluidResistanceUnit.PascalSecondPerCubicMeter, FluidResistanceUnit.WoodUnit) => new FluidResistance(_value / 7.99934208e6, FluidResistanceUnit.WoodUnit),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not FluidResistanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FluidResistanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is FluidResistanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FluidResistanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<FluidResistanceUnit> IQuantity<FluidResistanceUnit>.ToUnit(FluidResistanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1052,11 +896,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
index 3e6e0cf3e2..4ca9de716c 100644
--- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,23 +33,27 @@ namespace UnitsNet
     ///     In physics, a force is any influence that causes an object to undergo a certain change, either concerning its movement, direction, or geometrical construction. In other words, a force can cause an object with mass to change its velocity (which includes to begin moving from a state of rest), i.e., to accelerate, or a flexible object to deform, or both. Force can also be described by intuitive concepts such as a push or a pull. A force has both magnitude and direction, making it a vector quantity. It is measured in the SI unit of newtons and represented by the symbol F.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Force :
-        IArithmeticQuantity<Force, ForceUnit>,
+        ILinearQuantity<Force, ForceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Force, Force, double>,
+        IDivisionOperators<Force, Force, QuantityValue>,
         IDivisionOperators<Force, Mass, Acceleration>,
         IDivisionOperators<Force, Pressure, Area>,
         IDivisionOperators<Force, ForceChangeRate, Duration>,
         IDivisionOperators<Force, Duration, ForceChangeRate>,
         IMultiplyOperators<Force, ReciprocalLength, ForcePerLength>,
         IDivisionOperators<Force, Length, ForcePerLength>,
+        IMultiplyOperators<Force, Duration, Impulse>,
         IDivisionOperators<Force, ForcePerLength, Length>,
         IDivisionOperators<Force, Acceleration, Mass>,
         IMultiplyOperators<Force, Speed, Power>,
         IMultiplyOperators<Force, ReciprocalArea, Pressure>,
         IDivisionOperators<Force, Area, Pressure>,
+        IDivisionOperators<Force, Volume, SpecificWeight>,
         IMultiplyOperators<Force, Length, Torque>,
+        IDivisionOperators<Force, SpecificWeight, Volume>,
         IComparisonOperators<Force, Force, bool>,
         IParsable<Force>,
 #endif
@@ -64,7 +66,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -114,7 +116,7 @@ public static ForceInfo CreateDefault(Func<IEnumerable<UnitDefinition<ForceUnit>
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Force"/> is [T^-2][L][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Force"/> is T^-2LM.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 1, -2, 0, 0, 0, 0);
 
@@ -129,29 +131,58 @@ public static ForceInfo CreateDefault(Func<IEnumerable<UnitDefinition<ForceUnit>
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ForceUnit}"/> representing the default unit mappings for Force.</returns>
             public static IEnumerable<UnitDefinition<ForceUnit>> GetDefaultMappings()
             {
-                yield return new (ForceUnit.Decanewton, "Decanewton", "Decanewtons", new BaseUnits(length: LengthUnit.Decameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceUnit.Dyn, "Dyn", "Dyne", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (ForceUnit.KilogramForce, "KilogramForce", "KilogramsForce", BaseUnits.Undefined);
-                yield return new (ForceUnit.Kilonewton, "Kilonewton", "Kilonewtons", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceUnit.Kilopond, "Kilopond", "Kiloponds", BaseUnits.Undefined);
-                yield return new (ForceUnit.KilopoundForce, "KilopoundForce", "KilopoundsForce", BaseUnits.Undefined);
-                yield return new (ForceUnit.Meganewton, "Meganewton", "Meganewtons", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceUnit.Micronewton, "Micronewton", "Micronewtons", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceUnit.Millinewton, "Millinewton", "Millinewtons", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
+                yield return new (ForceUnit.Decanewton, "Decanewton", "Decanewtons", new BaseUnits(length: LengthUnit.Decameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (ForceUnit.Dyn, "Dyn", "Dyne", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     100000
+                );
+                yield return new (ForceUnit.GramForce, "GramForce", "GramsForce", BaseUnits.Undefined,
+                     new QuantityValue(20000000, 196133)
+                );
+                yield return new (ForceUnit.KilogramForce, "KilogramForce", "KilogramsForce", BaseUnits.Undefined,
+                     new QuantityValue(20000, 196133)
+                );
+                yield return new (ForceUnit.Kilonewton, "Kilonewton", "Kilonewtons", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ForceUnit.Kilopond, "Kilopond", "Kiloponds", BaseUnits.Undefined,
+                     new QuantityValue(20000, 196133)
+                );
+                yield return new (ForceUnit.KilopoundForce, "KilopoundForce", "KilopoundsForce", BaseUnits.Undefined,
+                     new QuantityValue(2000000000, 8896443230521)
+                );
+                yield return new (ForceUnit.Meganewton, "Meganewton", "Meganewtons", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ForceUnit.Micronewton, "Micronewton", "Micronewtons", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (ForceUnit.Millinewton, "Millinewton", "Millinewtons", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1000
+                );
                 yield return new (ForceUnit.Newton, "Newton", "Newtons", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceUnit.OunceForce, "OunceForce", "OunceForce", BaseUnits.Undefined);
-                yield return new (ForceUnit.Poundal, "Poundal", "Poundals", BaseUnits.Undefined);
-                yield return new (ForceUnit.PoundForce, "PoundForce", "PoundsForce", BaseUnits.Undefined);
-                yield return new (ForceUnit.ShortTonForce, "ShortTonForce", "ShortTonsForce", BaseUnits.Undefined);
-                yield return new (ForceUnit.TonneForce, "TonneForce", "TonnesForce", BaseUnits.Undefined);
+                yield return new (ForceUnit.OunceForce, "OunceForce", "OunceForce", BaseUnits.Undefined,
+                     new QuantityValue(32000000000000, 8896443230521)
+                );
+                yield return new (ForceUnit.Poundal, "Poundal", "Poundals", BaseUnits.Undefined,
+                     new QuantityValue(125000000000, 17281869297)
+                );
+                yield return new (ForceUnit.PoundForce, "PoundForce", "PoundsForce", BaseUnits.Undefined,
+                     new QuantityValue(2000000000000, 8896443230521)
+                );
+                yield return new (ForceUnit.ShortTonForce, "ShortTonForce", "ShortTonsForce", BaseUnits.Undefined,
+                     new QuantityValue(1000000000, 8896443230521)
+                );
+                yield return new (ForceUnit.TonneForce, "TonneForce", "TonnesForce", BaseUnits.Undefined,
+                     new QuantityValue(20, 196133)
+                );
             }
         }
 
         static Force()
         {
-            Info = ForceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ForceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -159,7 +190,7 @@ static Force()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Force(double value, ForceUnit unit)
+        public Force(QuantityValue value, ForceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -173,7 +204,7 @@ public Force(double value, ForceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Force(double value, UnitSystem unitSystem)
+        public Force(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -184,7 +215,8 @@ public Force(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Force" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Force, ForceUnit> Info { get; }
@@ -213,10 +245,8 @@ public Force(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ForceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -250,126 +280,89 @@ public Force(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Decanewton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.Decanewton"/>
         /// </summary>
-        public double Decanewtons => As(ForceUnit.Decanewton);
+        public QuantityValue Decanewtons => this.As(ForceUnit.Decanewton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Dyn"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.Dyn"/>
         /// </summary>
-        public double Dyne => As(ForceUnit.Dyn);
+        public QuantityValue Dyne => this.As(ForceUnit.Dyn);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.KilogramForce"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.GramForce"/>
         /// </summary>
-        public double KilogramsForce => As(ForceUnit.KilogramForce);
+        public QuantityValue GramsForce => this.As(ForceUnit.GramForce);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Kilonewton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.KilogramForce"/>
         /// </summary>
-        public double Kilonewtons => As(ForceUnit.Kilonewton);
+        public QuantityValue KilogramsForce => this.As(ForceUnit.KilogramForce);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Kilopond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.Kilonewton"/>
         /// </summary>
-        public double Kiloponds => As(ForceUnit.Kilopond);
+        public QuantityValue Kilonewtons => this.As(ForceUnit.Kilonewton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.KilopoundForce"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.Kilopond"/>
         /// </summary>
-        public double KilopoundsForce => As(ForceUnit.KilopoundForce);
+        public QuantityValue Kiloponds => this.As(ForceUnit.Kilopond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Meganewton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.KilopoundForce"/>
         /// </summary>
-        public double Meganewtons => As(ForceUnit.Meganewton);
+        public QuantityValue KilopoundsForce => this.As(ForceUnit.KilopoundForce);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Micronewton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.Meganewton"/>
         /// </summary>
-        public double Micronewtons => As(ForceUnit.Micronewton);
+        public QuantityValue Meganewtons => this.As(ForceUnit.Meganewton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Millinewton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.Micronewton"/>
         /// </summary>
-        public double Millinewtons => As(ForceUnit.Millinewton);
+        public QuantityValue Micronewtons => this.As(ForceUnit.Micronewton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Newton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.Millinewton"/>
         /// </summary>
-        public double Newtons => As(ForceUnit.Newton);
+        public QuantityValue Millinewtons => this.As(ForceUnit.Millinewton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.OunceForce"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.Newton"/>
         /// </summary>
-        public double OunceForce => As(ForceUnit.OunceForce);
+        public QuantityValue Newtons => this.As(ForceUnit.Newton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.Poundal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.OunceForce"/>
         /// </summary>
-        public double Poundals => As(ForceUnit.Poundal);
+        public QuantityValue OunceForce => this.As(ForceUnit.OunceForce);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.PoundForce"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.Poundal"/>
         /// </summary>
-        public double PoundsForce => As(ForceUnit.PoundForce);
+        public QuantityValue Poundals => this.As(ForceUnit.Poundal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.ShortTonForce"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.PoundForce"/>
         /// </summary>
-        public double ShortTonsForce => As(ForceUnit.ShortTonForce);
+        public QuantityValue PoundsForce => this.As(ForceUnit.PoundForce);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceUnit.TonneForce"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.ShortTonForce"/>
         /// </summary>
-        public double TonnesForce => As(ForceUnit.TonneForce);
+        public QuantityValue ShortTonsForce => this.As(ForceUnit.ShortTonForce);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceUnit.TonneForce"/>
+        /// </summary>
+        public QuantityValue TonnesForce => this.As(ForceUnit.TonneForce);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ForceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Decanewton, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Dyn, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.KilogramForce, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Kilonewton, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Kilopond, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.KilopoundForce, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Meganewton, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Micronewton, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Millinewton, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.OunceForce, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Poundal, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.PoundForce, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.ShortTonForce, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.TonneForce, ForceUnit.Newton, quantity => quantity.ToUnit(ForceUnit.Newton));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.Newton, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ForceUnit
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.Decanewton, quantity => quantity.ToUnit(ForceUnit.Decanewton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.Dyn, quantity => quantity.ToUnit(ForceUnit.Dyn));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.KilogramForce, quantity => quantity.ToUnit(ForceUnit.KilogramForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.Kilonewton, quantity => quantity.ToUnit(ForceUnit.Kilonewton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.Kilopond, quantity => quantity.ToUnit(ForceUnit.Kilopond));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.KilopoundForce, quantity => quantity.ToUnit(ForceUnit.KilopoundForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.Meganewton, quantity => quantity.ToUnit(ForceUnit.Meganewton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.Micronewton, quantity => quantity.ToUnit(ForceUnit.Micronewton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.Millinewton, quantity => quantity.ToUnit(ForceUnit.Millinewton));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.OunceForce, quantity => quantity.ToUnit(ForceUnit.OunceForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.Poundal, quantity => quantity.ToUnit(ForceUnit.Poundal));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.PoundForce, quantity => quantity.ToUnit(ForceUnit.PoundForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.ShortTonForce, quantity => quantity.ToUnit(ForceUnit.ShortTonForce));
-            unitConverter.SetConversionFunction<Force>(ForceUnit.Newton, ForceUnit.TonneForce, quantity => quantity.ToUnit(ForceUnit.TonneForce));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -398,7 +391,7 @@ public static string GetAbbreviation(ForceUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Decanewton"/>.
         /// </summary>
-        public static Force FromDecanewtons(double value)
+        public static Force FromDecanewtons(QuantityValue value)
         {
             return new Force(value, ForceUnit.Decanewton);
         }
@@ -406,15 +399,23 @@ public static Force FromDecanewtons(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Dyn"/>.
         /// </summary>
-        public static Force FromDyne(double value)
+        public static Force FromDyne(QuantityValue value)
         {
             return new Force(value, ForceUnit.Dyn);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.GramForce"/>.
+        /// </summary>
+        public static Force FromGramsForce(QuantityValue value)
+        {
+            return new Force(value, ForceUnit.GramForce);
+        }
+
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.KilogramForce"/>.
         /// </summary>
-        public static Force FromKilogramsForce(double value)
+        public static Force FromKilogramsForce(QuantityValue value)
         {
             return new Force(value, ForceUnit.KilogramForce);
         }
@@ -422,7 +423,7 @@ public static Force FromKilogramsForce(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Kilonewton"/>.
         /// </summary>
-        public static Force FromKilonewtons(double value)
+        public static Force FromKilonewtons(QuantityValue value)
         {
             return new Force(value, ForceUnit.Kilonewton);
         }
@@ -430,7 +431,7 @@ public static Force FromKilonewtons(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Kilopond"/>.
         /// </summary>
-        public static Force FromKiloponds(double value)
+        public static Force FromKiloponds(QuantityValue value)
         {
             return new Force(value, ForceUnit.Kilopond);
         }
@@ -438,7 +439,7 @@ public static Force FromKiloponds(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.KilopoundForce"/>.
         /// </summary>
-        public static Force FromKilopoundsForce(double value)
+        public static Force FromKilopoundsForce(QuantityValue value)
         {
             return new Force(value, ForceUnit.KilopoundForce);
         }
@@ -446,7 +447,7 @@ public static Force FromKilopoundsForce(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Meganewton"/>.
         /// </summary>
-        public static Force FromMeganewtons(double value)
+        public static Force FromMeganewtons(QuantityValue value)
         {
             return new Force(value, ForceUnit.Meganewton);
         }
@@ -454,7 +455,7 @@ public static Force FromMeganewtons(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Micronewton"/>.
         /// </summary>
-        public static Force FromMicronewtons(double value)
+        public static Force FromMicronewtons(QuantityValue value)
         {
             return new Force(value, ForceUnit.Micronewton);
         }
@@ -462,7 +463,7 @@ public static Force FromMicronewtons(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Millinewton"/>.
         /// </summary>
-        public static Force FromMillinewtons(double value)
+        public static Force FromMillinewtons(QuantityValue value)
         {
             return new Force(value, ForceUnit.Millinewton);
         }
@@ -470,7 +471,7 @@ public static Force FromMillinewtons(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Newton"/>.
         /// </summary>
-        public static Force FromNewtons(double value)
+        public static Force FromNewtons(QuantityValue value)
         {
             return new Force(value, ForceUnit.Newton);
         }
@@ -478,7 +479,7 @@ public static Force FromNewtons(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.OunceForce"/>.
         /// </summary>
-        public static Force FromOunceForce(double value)
+        public static Force FromOunceForce(QuantityValue value)
         {
             return new Force(value, ForceUnit.OunceForce);
         }
@@ -486,7 +487,7 @@ public static Force FromOunceForce(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Poundal"/>.
         /// </summary>
-        public static Force FromPoundals(double value)
+        public static Force FromPoundals(QuantityValue value)
         {
             return new Force(value, ForceUnit.Poundal);
         }
@@ -494,7 +495,7 @@ public static Force FromPoundals(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.PoundForce"/>.
         /// </summary>
-        public static Force FromPoundsForce(double value)
+        public static Force FromPoundsForce(QuantityValue value)
         {
             return new Force(value, ForceUnit.PoundForce);
         }
@@ -502,7 +503,7 @@ public static Force FromPoundsForce(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.ShortTonForce"/>.
         /// </summary>
-        public static Force FromShortTonsForce(double value)
+        public static Force FromShortTonsForce(QuantityValue value)
         {
             return new Force(value, ForceUnit.ShortTonForce);
         }
@@ -510,7 +511,7 @@ public static Force FromShortTonsForce(double value)
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.TonneForce"/>.
         /// </summary>
-        public static Force FromTonnesForce(double value)
+        public static Force FromTonnesForce(QuantityValue value)
         {
             return new Force(value, ForceUnit.TonneForce);
         }
@@ -521,7 +522,7 @@ public static Force FromTonnesForce(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Force unit value.</returns>
-        public static Force From(double value, ForceUnit fromUnit)
+        public static Force From(QuantityValue value, ForceUnit fromUnit)
         {
             return new Force(value, fromUnit);
         }
@@ -582,10 +583,7 @@ public static Force Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Force Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Force, ForceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Force, ForceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -613,11 +611,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Force result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Force result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Force, ForceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Force, ForceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -638,7 +632,7 @@ public static ForceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -649,7 +643,7 @@ public static ForceUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ForceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ForceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ForceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -664,7 +658,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ForceUnit un
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ForceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -683,35 +677,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Force"/> from adding two <see cref="Force"/>.</summary>
         public static Force operator +(Force left, Force right)
         {
-            return new Force(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Force(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Force"/> from subtracting two <see cref="Force"/>.</summary>
         public static Force operator -(Force left, Force right)
         {
-            return new Force(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Force(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Force"/> from multiplying value and <see cref="Force"/>.</summary>
-        public static Force operator *(double left, Force right)
+        public static Force operator *(QuantityValue left, Force right)
         {
             return new Force(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Force"/> from multiplying value and <see cref="Force"/>.</summary>
-        public static Force operator *(Force left, double right)
+        public static Force operator *(Force left, QuantityValue right)
         {
             return new Force(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Force"/> from dividing <see cref="Force"/> by value.</summary>
-        public static Force operator /(Force left, double right)
+        public static Force operator /(Force left, QuantityValue right)
         {
             return new Force(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Force"/> by <see cref="Force"/>.</summary>
-        public static double operator /(Force left, Force right)
+        public static QuantityValue operator /(Force left, Force right)
         {
             return left.Newtons / right.Newtons;
         }
@@ -756,6 +750,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return ForcePerLength.FromNewtonsPerMeter(force.Newtons / length.Meters);
         }
 
+        /// <summary>Get <see cref="Impulse"/> from <see cref="Force"/> * <see cref="Duration"/>.</summary>
+        public static Impulse operator *(Force force, Duration duration)
+        {
+            return Impulse.FromNewtonSeconds(force.Newtons * duration.Seconds);
+        }
+
         /// <summary>Get <see cref="Length"/> from <see cref="Force"/> / <see cref="ForcePerLength"/>.</summary>
         public static Length operator /(Force force, ForcePerLength forcePerLength)
         {
@@ -786,12 +786,24 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Pressure.FromPascals(force.Newtons / area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="SpecificWeight"/> from <see cref="Force"/> / <see cref="Volume"/>.</summary>
+        public static SpecificWeight operator /(Force force, Volume volume)
+        {
+            return SpecificWeight.FromNewtonsPerCubicMeter(force.Newtons / volume.CubicMeters);
+        }
+
         /// <summary>Get <see cref="Torque"/> from <see cref="Force"/> * <see cref="Length"/>.</summary>
         public static Torque operator *(Force force, Length length)
         {
             return Torque.FromNewtonMeters(force.Newtons * length.Meters);
         }
 
+        /// <summary>Get <see cref="Volume"/> from <see cref="Force"/> / <see cref="SpecificWeight"/>.</summary>
+        public static Volume operator /(Force force, SpecificWeight specificWeight)
+        {
+            return Volume.FromCubicMeters(force.Newtons / specificWeight.NewtonsPerCubicMeter);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -799,97 +811,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Force left, Force right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Force left, Force right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Force left, Force right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Force left, Force right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Force"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Force other, Force tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Force"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Force)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Force left, Force right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Force"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Force other, Force tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Force"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Force,Force)"/>.
+        ///     See that operator (and <see cref="Equals(Force)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Force left, Force right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Force"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Force other, Force tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Force"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Force"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Force"/>, this method delegates to
+        ///     <see cref="Equals(Force)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Force otherQuantity))
+            if (obj is not Force otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Force"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Force other, Force tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Force"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Force other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Force.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Force), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Force"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Force)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Force otherQuantity)) throw new ArgumentException("Expected type Force.", nameof(obj));
+            if (obj is not Force otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Force>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Force"/> with another <see cref="Force"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Force"/> with another <see cref="Force"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -901,157 +927,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Force other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ForceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ForceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Force to another Force with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Force with the specified unit.</returns>
-        public Force ToUnit(ForceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Force"/> to another <see cref="Force"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Force with the specified unit.</returns>
-        public Force ToUnit(ForceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Force), Unit, typeof(Force), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Force)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Force"/> to another <see cref="Force"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Force"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ForceUnit unit, [NotNullWhen(true)] out Force? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Force? convertedOrNull = (Unit, unit) switch
-            {
-                // ForceUnit -> BaseUnit
-                (ForceUnit.Decanewton, ForceUnit.Newton) => new Force((_value) * 1e1d, ForceUnit.Newton),
-                (ForceUnit.Dyn, ForceUnit.Newton) => new Force(_value / 1e5, ForceUnit.Newton),
-                (ForceUnit.KilogramForce, ForceUnit.Newton) => new Force(_value * 9.80665, ForceUnit.Newton),
-                (ForceUnit.Kilonewton, ForceUnit.Newton) => new Force((_value) * 1e3d, ForceUnit.Newton),
-                (ForceUnit.Kilopond, ForceUnit.Newton) => new Force(_value * 9.80665, ForceUnit.Newton),
-                (ForceUnit.KilopoundForce, ForceUnit.Newton) => new Force((_value * 4.4482216152605) * 1e3d, ForceUnit.Newton),
-                (ForceUnit.Meganewton, ForceUnit.Newton) => new Force((_value) * 1e6d, ForceUnit.Newton),
-                (ForceUnit.Micronewton, ForceUnit.Newton) => new Force((_value) * 1e-6d, ForceUnit.Newton),
-                (ForceUnit.Millinewton, ForceUnit.Newton) => new Force((_value) * 1e-3d, ForceUnit.Newton),
-                (ForceUnit.OunceForce, ForceUnit.Newton) => new Force(_value * (4.4482216152605 / 16), ForceUnit.Newton),
-                (ForceUnit.Poundal, ForceUnit.Newton) => new Force(_value * 0.138254954376, ForceUnit.Newton),
-                (ForceUnit.PoundForce, ForceUnit.Newton) => new Force(_value * 4.4482216152605, ForceUnit.Newton),
-                (ForceUnit.ShortTonForce, ForceUnit.Newton) => new Force(_value * (4.4482216152605 * 2000), ForceUnit.Newton),
-                (ForceUnit.TonneForce, ForceUnit.Newton) => new Force(_value * (9.80665 * 1000), ForceUnit.Newton),
-
-                // BaseUnit -> ForceUnit
-                (ForceUnit.Newton, ForceUnit.Decanewton) => new Force((_value) / 1e1d, ForceUnit.Decanewton),
-                (ForceUnit.Newton, ForceUnit.Dyn) => new Force(_value * 1e5, ForceUnit.Dyn),
-                (ForceUnit.Newton, ForceUnit.KilogramForce) => new Force(_value / 9.80665, ForceUnit.KilogramForce),
-                (ForceUnit.Newton, ForceUnit.Kilonewton) => new Force((_value) / 1e3d, ForceUnit.Kilonewton),
-                (ForceUnit.Newton, ForceUnit.Kilopond) => new Force(_value / 9.80665, ForceUnit.Kilopond),
-                (ForceUnit.Newton, ForceUnit.KilopoundForce) => new Force((_value / 4.4482216152605) / 1e3d, ForceUnit.KilopoundForce),
-                (ForceUnit.Newton, ForceUnit.Meganewton) => new Force((_value) / 1e6d, ForceUnit.Meganewton),
-                (ForceUnit.Newton, ForceUnit.Micronewton) => new Force((_value) / 1e-6d, ForceUnit.Micronewton),
-                (ForceUnit.Newton, ForceUnit.Millinewton) => new Force((_value) / 1e-3d, ForceUnit.Millinewton),
-                (ForceUnit.Newton, ForceUnit.OunceForce) => new Force(_value / (4.4482216152605 / 16), ForceUnit.OunceForce),
-                (ForceUnit.Newton, ForceUnit.Poundal) => new Force(_value / 0.138254954376, ForceUnit.Poundal),
-                (ForceUnit.Newton, ForceUnit.PoundForce) => new Force(_value / 4.4482216152605, ForceUnit.PoundForce),
-                (ForceUnit.Newton, ForceUnit.ShortTonForce) => new Force(_value / (4.4482216152605 * 2000), ForceUnit.ShortTonForce),
-                (ForceUnit.Newton, ForceUnit.TonneForce) => new Force(_value / (9.80665 * 1000), ForceUnit.TonneForce),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ForceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ForceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ForceUnit> IQuantity<ForceUnit>.ToUnit(ForceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1065,11 +943,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
index 031760cc0e..3268eb43f3 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Force change rate is the ratio of the force change to the time during which the change occurred (value of force changes per unit time).
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ForceChangeRate :
-        IArithmeticQuantity<ForceChangeRate, ForceChangeRateUnit>,
+        ILinearQuantity<ForceChangeRate, ForceChangeRateUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ForceChangeRate, ForceChangeRate, double>,
+        IDivisionOperators<ForceChangeRate, ForceChangeRate, QuantityValue>,
         IMultiplyOperators<ForceChangeRate, Duration, Force>,
         IComparisonOperators<ForceChangeRate, ForceChangeRate, bool>,
         IParsable<ForceChangeRate>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static ForceChangeRateInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ForceChangeRate"/> is [T^-3][L][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ForceChangeRate"/> is T^-3LM.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 1, -3, 0, 0, 0, 0);
 
@@ -118,29 +117,55 @@ public static ForceChangeRateInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ForceChangeRateUnit}"/> representing the default unit mappings for ForceChangeRate.</returns>
             public static IEnumerable<UnitDefinition<ForceChangeRateUnit>> GetDefaultMappings()
             {
-                yield return new (ForceChangeRateUnit.CentinewtonPerSecond, "CentinewtonPerSecond", "CentinewtonsPerSecond", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceChangeRateUnit.DecanewtonPerMinute, "DecanewtonPerMinute", "DecanewtonsPerMinute", BaseUnits.Undefined);
-                yield return new (ForceChangeRateUnit.DecanewtonPerSecond, "DecanewtonPerSecond", "DecanewtonsPerSecond", new BaseUnits(length: LengthUnit.Decameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceChangeRateUnit.DecinewtonPerSecond, "DecinewtonPerSecond", "DecinewtonsPerSecond", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceChangeRateUnit.KilonewtonPerMinute, "KilonewtonPerMinute", "KilonewtonsPerMinute", BaseUnits.Undefined);
-                yield return new (ForceChangeRateUnit.KilonewtonPerSecond, "KilonewtonPerSecond", "KilonewtonsPerSecond", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceChangeRateUnit.KilopoundForcePerMinute, "KilopoundForcePerMinute", "KilopoundsForcePerMinute", BaseUnits.Undefined);
-                yield return new (ForceChangeRateUnit.KilopoundForcePerSecond, "KilopoundForcePerSecond", "KilopoundsForcePerSecond", BaseUnits.Undefined);
-                yield return new (ForceChangeRateUnit.MicronewtonPerSecond, "MicronewtonPerSecond", "MicronewtonsPerSecond", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceChangeRateUnit.MillinewtonPerSecond, "MillinewtonPerSecond", "MillinewtonsPerSecond", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceChangeRateUnit.NanonewtonPerSecond, "NanonewtonPerSecond", "NanonewtonsPerSecond", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceChangeRateUnit.NewtonPerMinute, "NewtonPerMinute", "NewtonsPerMinute", BaseUnits.Undefined);
+                yield return new (ForceChangeRateUnit.CentinewtonPerSecond, "CentinewtonPerSecond", "CentinewtonsPerSecond", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     100
+                );
+                yield return new (ForceChangeRateUnit.DecanewtonPerMinute, "DecanewtonPerMinute", "DecanewtonsPerMinute", BaseUnits.Undefined,
+                     6
+                );
+                yield return new (ForceChangeRateUnit.DecanewtonPerSecond, "DecanewtonPerSecond", "DecanewtonsPerSecond", new BaseUnits(length: LengthUnit.Decameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (ForceChangeRateUnit.DecinewtonPerSecond, "DecinewtonPerSecond", "DecinewtonsPerSecond", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (ForceChangeRateUnit.KilonewtonPerMinute, "KilonewtonPerMinute", "KilonewtonsPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(3, 50)
+                );
+                yield return new (ForceChangeRateUnit.KilonewtonPerSecond, "KilonewtonPerSecond", "KilonewtonsPerSecond", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ForceChangeRateUnit.KilopoundForcePerMinute, "KilopoundForcePerMinute", "KilopoundsForcePerMinute", BaseUnits.Undefined,
+                     new QuantityValue(120000000000, 8896443230521)
+                );
+                yield return new (ForceChangeRateUnit.KilopoundForcePerSecond, "KilopoundForcePerSecond", "KilopoundsForcePerSecond", BaseUnits.Undefined,
+                     new QuantityValue(2000000000, 8896443230521)
+                );
+                yield return new (ForceChangeRateUnit.MicronewtonPerSecond, "MicronewtonPerSecond", "MicronewtonsPerSecond", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (ForceChangeRateUnit.MillinewtonPerSecond, "MillinewtonPerSecond", "MillinewtonsPerSecond", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (ForceChangeRateUnit.NanonewtonPerSecond, "NanonewtonPerSecond", "NanonewtonsPerSecond", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (ForceChangeRateUnit.NewtonPerMinute, "NewtonPerMinute", "NewtonsPerMinute", BaseUnits.Undefined,
+                     60
+                );
                 yield return new (ForceChangeRateUnit.NewtonPerSecond, "NewtonPerSecond", "NewtonsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForceChangeRateUnit.PoundForcePerMinute, "PoundForcePerMinute", "PoundsForcePerMinute", BaseUnits.Undefined);
-                yield return new (ForceChangeRateUnit.PoundForcePerSecond, "PoundForcePerSecond", "PoundsForcePerSecond", BaseUnits.Undefined);
+                yield return new (ForceChangeRateUnit.PoundForcePerMinute, "PoundForcePerMinute", "PoundsForcePerMinute", BaseUnits.Undefined,
+                     new QuantityValue(120000000000000, 8896443230521)
+                );
+                yield return new (ForceChangeRateUnit.PoundForcePerSecond, "PoundForcePerSecond", "PoundsForcePerSecond", BaseUnits.Undefined,
+                     new QuantityValue(2000000000000, 8896443230521)
+                );
             }
         }
 
         static ForceChangeRate()
         {
-            Info = ForceChangeRateInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ForceChangeRateInfo.CreateDefault);
         }
 
         /// <summary>
@@ -148,7 +173,7 @@ static ForceChangeRate()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ForceChangeRate(double value, ForceChangeRateUnit unit)
+        public ForceChangeRate(QuantityValue value, ForceChangeRateUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -162,7 +187,7 @@ public ForceChangeRate(double value, ForceChangeRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ForceChangeRate(double value, UnitSystem unitSystem)
+        public ForceChangeRate(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -173,7 +198,8 @@ public ForceChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ForceChangeRate" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ForceChangeRate, ForceChangeRateUnit> Info { get; }
@@ -202,10 +228,8 @@ public ForceChangeRate(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ForceChangeRateUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -239,126 +263,84 @@ public ForceChangeRate(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.CentinewtonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.CentinewtonPerSecond"/>
         /// </summary>
-        public double CentinewtonsPerSecond => As(ForceChangeRateUnit.CentinewtonPerSecond);
+        public QuantityValue CentinewtonsPerSecond => this.As(ForceChangeRateUnit.CentinewtonPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.DecanewtonPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.DecanewtonPerMinute"/>
         /// </summary>
-        public double DecanewtonsPerMinute => As(ForceChangeRateUnit.DecanewtonPerMinute);
+        public QuantityValue DecanewtonsPerMinute => this.As(ForceChangeRateUnit.DecanewtonPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.DecanewtonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.DecanewtonPerSecond"/>
         /// </summary>
-        public double DecanewtonsPerSecond => As(ForceChangeRateUnit.DecanewtonPerSecond);
+        public QuantityValue DecanewtonsPerSecond => this.As(ForceChangeRateUnit.DecanewtonPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.DecinewtonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.DecinewtonPerSecond"/>
         /// </summary>
-        public double DecinewtonsPerSecond => As(ForceChangeRateUnit.DecinewtonPerSecond);
+        public QuantityValue DecinewtonsPerSecond => this.As(ForceChangeRateUnit.DecinewtonPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilonewtonPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilonewtonPerMinute"/>
         /// </summary>
-        public double KilonewtonsPerMinute => As(ForceChangeRateUnit.KilonewtonPerMinute);
+        public QuantityValue KilonewtonsPerMinute => this.As(ForceChangeRateUnit.KilonewtonPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilonewtonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilonewtonPerSecond"/>
         /// </summary>
-        public double KilonewtonsPerSecond => As(ForceChangeRateUnit.KilonewtonPerSecond);
+        public QuantityValue KilonewtonsPerSecond => this.As(ForceChangeRateUnit.KilonewtonPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilopoundForcePerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilopoundForcePerMinute"/>
         /// </summary>
-        public double KilopoundsForcePerMinute => As(ForceChangeRateUnit.KilopoundForcePerMinute);
+        public QuantityValue KilopoundsForcePerMinute => this.As(ForceChangeRateUnit.KilopoundForcePerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilopoundForcePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.KilopoundForcePerSecond"/>
         /// </summary>
-        public double KilopoundsForcePerSecond => As(ForceChangeRateUnit.KilopoundForcePerSecond);
+        public QuantityValue KilopoundsForcePerSecond => this.As(ForceChangeRateUnit.KilopoundForcePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.MicronewtonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.MicronewtonPerSecond"/>
         /// </summary>
-        public double MicronewtonsPerSecond => As(ForceChangeRateUnit.MicronewtonPerSecond);
+        public QuantityValue MicronewtonsPerSecond => this.As(ForceChangeRateUnit.MicronewtonPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.MillinewtonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.MillinewtonPerSecond"/>
         /// </summary>
-        public double MillinewtonsPerSecond => As(ForceChangeRateUnit.MillinewtonPerSecond);
+        public QuantityValue MillinewtonsPerSecond => this.As(ForceChangeRateUnit.MillinewtonPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.NanonewtonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.NanonewtonPerSecond"/>
         /// </summary>
-        public double NanonewtonsPerSecond => As(ForceChangeRateUnit.NanonewtonPerSecond);
+        public QuantityValue NanonewtonsPerSecond => this.As(ForceChangeRateUnit.NanonewtonPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.NewtonPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.NewtonPerMinute"/>
         /// </summary>
-        public double NewtonsPerMinute => As(ForceChangeRateUnit.NewtonPerMinute);
+        public QuantityValue NewtonsPerMinute => this.As(ForceChangeRateUnit.NewtonPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.NewtonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.NewtonPerSecond"/>
         /// </summary>
-        public double NewtonsPerSecond => As(ForceChangeRateUnit.NewtonPerSecond);
+        public QuantityValue NewtonsPerSecond => this.As(ForceChangeRateUnit.NewtonPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.PoundForcePerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.PoundForcePerMinute"/>
         /// </summary>
-        public double PoundsForcePerMinute => As(ForceChangeRateUnit.PoundForcePerMinute);
+        public QuantityValue PoundsForcePerMinute => this.As(ForceChangeRateUnit.PoundForcePerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForceChangeRateUnit.PoundForcePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForceChangeRateUnit.PoundForcePerSecond"/>
         /// </summary>
-        public double PoundsForcePerSecond => As(ForceChangeRateUnit.PoundForcePerSecond);
+        public QuantityValue PoundsForcePerSecond => this.As(ForceChangeRateUnit.PoundForcePerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ForceChangeRateUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.CentinewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.DecanewtonPerMinute, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.DecanewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.DecinewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.KilonewtonPerMinute, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.KilonewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.KilopoundForcePerMinute, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.KilopoundForcePerSecond, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.MicronewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.MillinewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NanonewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerMinute, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.PoundForcePerMinute, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.PoundForcePerSecond, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ForceChangeRateUnit
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.CentinewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.CentinewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.DecanewtonPerMinute, quantity => quantity.ToUnit(ForceChangeRateUnit.DecanewtonPerMinute));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.DecanewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.DecanewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.DecinewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.DecinewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.KilonewtonPerMinute, quantity => quantity.ToUnit(ForceChangeRateUnit.KilonewtonPerMinute));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.KilonewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.KilonewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.KilopoundForcePerMinute, quantity => quantity.ToUnit(ForceChangeRateUnit.KilopoundForcePerMinute));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.KilopoundForcePerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.KilopoundForcePerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.MicronewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.MicronewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.MillinewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.MillinewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.NanonewtonPerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.NanonewtonPerSecond));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.NewtonPerMinute, quantity => quantity.ToUnit(ForceChangeRateUnit.NewtonPerMinute));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.PoundForcePerMinute, quantity => quantity.ToUnit(ForceChangeRateUnit.PoundForcePerMinute));
-            unitConverter.SetConversionFunction<ForceChangeRate>(ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.PoundForcePerSecond, quantity => quantity.ToUnit(ForceChangeRateUnit.PoundForcePerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -387,7 +369,7 @@ public static string GetAbbreviation(ForceChangeRateUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.CentinewtonPerSecond"/>.
         /// </summary>
-        public static ForceChangeRate FromCentinewtonsPerSecond(double value)
+        public static ForceChangeRate FromCentinewtonsPerSecond(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.CentinewtonPerSecond);
         }
@@ -395,7 +377,7 @@ public static ForceChangeRate FromCentinewtonsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecanewtonPerMinute"/>.
         /// </summary>
-        public static ForceChangeRate FromDecanewtonsPerMinute(double value)
+        public static ForceChangeRate FromDecanewtonsPerMinute(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerMinute);
         }
@@ -403,7 +385,7 @@ public static ForceChangeRate FromDecanewtonsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecanewtonPerSecond"/>.
         /// </summary>
-        public static ForceChangeRate FromDecanewtonsPerSecond(double value)
+        public static ForceChangeRate FromDecanewtonsPerSecond(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerSecond);
         }
@@ -411,7 +393,7 @@ public static ForceChangeRate FromDecanewtonsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecinewtonPerSecond"/>.
         /// </summary>
-        public static ForceChangeRate FromDecinewtonsPerSecond(double value)
+        public static ForceChangeRate FromDecinewtonsPerSecond(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.DecinewtonPerSecond);
         }
@@ -419,7 +401,7 @@ public static ForceChangeRate FromDecinewtonsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilonewtonPerMinute"/>.
         /// </summary>
-        public static ForceChangeRate FromKilonewtonsPerMinute(double value)
+        public static ForceChangeRate FromKilonewtonsPerMinute(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerMinute);
         }
@@ -427,7 +409,7 @@ public static ForceChangeRate FromKilonewtonsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilonewtonPerSecond"/>.
         /// </summary>
-        public static ForceChangeRate FromKilonewtonsPerSecond(double value)
+        public static ForceChangeRate FromKilonewtonsPerSecond(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerSecond);
         }
@@ -435,7 +417,7 @@ public static ForceChangeRate FromKilonewtonsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilopoundForcePerMinute"/>.
         /// </summary>
-        public static ForceChangeRate FromKilopoundsForcePerMinute(double value)
+        public static ForceChangeRate FromKilopoundsForcePerMinute(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerMinute);
         }
@@ -443,7 +425,7 @@ public static ForceChangeRate FromKilopoundsForcePerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilopoundForcePerSecond"/>.
         /// </summary>
-        public static ForceChangeRate FromKilopoundsForcePerSecond(double value)
+        public static ForceChangeRate FromKilopoundsForcePerSecond(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerSecond);
         }
@@ -451,7 +433,7 @@ public static ForceChangeRate FromKilopoundsForcePerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.MicronewtonPerSecond"/>.
         /// </summary>
-        public static ForceChangeRate FromMicronewtonsPerSecond(double value)
+        public static ForceChangeRate FromMicronewtonsPerSecond(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.MicronewtonPerSecond);
         }
@@ -459,7 +441,7 @@ public static ForceChangeRate FromMicronewtonsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.MillinewtonPerSecond"/>.
         /// </summary>
-        public static ForceChangeRate FromMillinewtonsPerSecond(double value)
+        public static ForceChangeRate FromMillinewtonsPerSecond(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.MillinewtonPerSecond);
         }
@@ -467,7 +449,7 @@ public static ForceChangeRate FromMillinewtonsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NanonewtonPerSecond"/>.
         /// </summary>
-        public static ForceChangeRate FromNanonewtonsPerSecond(double value)
+        public static ForceChangeRate FromNanonewtonsPerSecond(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.NanonewtonPerSecond);
         }
@@ -475,7 +457,7 @@ public static ForceChangeRate FromNanonewtonsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NewtonPerMinute"/>.
         /// </summary>
-        public static ForceChangeRate FromNewtonsPerMinute(double value)
+        public static ForceChangeRate FromNewtonsPerMinute(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerMinute);
         }
@@ -483,7 +465,7 @@ public static ForceChangeRate FromNewtonsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NewtonPerSecond"/>.
         /// </summary>
-        public static ForceChangeRate FromNewtonsPerSecond(double value)
+        public static ForceChangeRate FromNewtonsPerSecond(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerSecond);
         }
@@ -491,7 +473,7 @@ public static ForceChangeRate FromNewtonsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.PoundForcePerMinute"/>.
         /// </summary>
-        public static ForceChangeRate FromPoundsForcePerMinute(double value)
+        public static ForceChangeRate FromPoundsForcePerMinute(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerMinute);
         }
@@ -499,7 +481,7 @@ public static ForceChangeRate FromPoundsForcePerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.PoundForcePerSecond"/>.
         /// </summary>
-        public static ForceChangeRate FromPoundsForcePerSecond(double value)
+        public static ForceChangeRate FromPoundsForcePerSecond(QuantityValue value)
         {
             return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerSecond);
         }
@@ -510,7 +492,7 @@ public static ForceChangeRate FromPoundsForcePerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ForceChangeRate unit value.</returns>
-        public static ForceChangeRate From(double value, ForceChangeRateUnit fromUnit)
+        public static ForceChangeRate From(QuantityValue value, ForceChangeRateUnit fromUnit)
         {
             return new ForceChangeRate(value, fromUnit);
         }
@@ -571,10 +553,7 @@ public static ForceChangeRate Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ForceChangeRate Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ForceChangeRate, ForceChangeRateUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ForceChangeRate, ForceChangeRateUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -602,11 +581,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ForceChangeRate
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ForceChangeRate result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ForceChangeRate, ForceChangeRateUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ForceChangeRate, ForceChangeRateUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -627,7 +602,7 @@ public static ForceChangeRateUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -638,7 +613,7 @@ public static ForceChangeRateUnit ParseUnit(string str, IFormatProvider? provide
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ForceChangeRateUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ForceChangeRateUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ForceChangeRateUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -653,7 +628,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ForceChangeR
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ForceChangeRateUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -672,35 +647,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ForceChangeRate"/> from adding two <see cref="ForceChangeRate"/>.</summary>
         public static ForceChangeRate operator +(ForceChangeRate left, ForceChangeRate right)
         {
-            return new ForceChangeRate(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ForceChangeRate(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ForceChangeRate"/> from subtracting two <see cref="ForceChangeRate"/>.</summary>
         public static ForceChangeRate operator -(ForceChangeRate left, ForceChangeRate right)
         {
-            return new ForceChangeRate(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ForceChangeRate(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ForceChangeRate"/> from multiplying value and <see cref="ForceChangeRate"/>.</summary>
-        public static ForceChangeRate operator *(double left, ForceChangeRate right)
+        public static ForceChangeRate operator *(QuantityValue left, ForceChangeRate right)
         {
             return new ForceChangeRate(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ForceChangeRate"/> from multiplying value and <see cref="ForceChangeRate"/>.</summary>
-        public static ForceChangeRate operator *(ForceChangeRate left, double right)
+        public static ForceChangeRate operator *(ForceChangeRate left, QuantityValue right)
         {
             return new ForceChangeRate(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ForceChangeRate"/> from dividing <see cref="ForceChangeRate"/> by value.</summary>
-        public static ForceChangeRate operator /(ForceChangeRate left, double right)
+        public static ForceChangeRate operator /(ForceChangeRate left, QuantityValue right)
         {
             return new ForceChangeRate(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ForceChangeRate"/> by <see cref="ForceChangeRate"/>.</summary>
-        public static double operator /(ForceChangeRate left, ForceChangeRate right)
+        public static QuantityValue operator /(ForceChangeRate left, ForceChangeRate right)
         {
             return left.NewtonsPerSecond / right.NewtonsPerSecond;
         }
@@ -722,97 +697,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ForceChangeRate left, ForceChangeRate right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ForceChangeRate left, ForceChangeRate right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ForceChangeRate left, ForceChangeRate right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ForceChangeRate left, ForceChangeRate right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ForceChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ForceChangeRate other, ForceChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ForceChangeRate"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ForceChangeRate)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ForceChangeRate left, ForceChangeRate right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ForceChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ForceChangeRate other, ForceChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ForceChangeRate"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ForceChangeRate,ForceChangeRate)"/>.
+        ///     See that operator (and <see cref="Equals(ForceChangeRate)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ForceChangeRate left, ForceChangeRate right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ForceChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ForceChangeRate other, ForceChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ForceChangeRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ForceChangeRate"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ForceChangeRate"/>, this method delegates to
+        ///     <see cref="Equals(ForceChangeRate)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ForceChangeRate otherQuantity))
+            if (obj is not ForceChangeRate otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ForceChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ForceChangeRate other, ForceChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ForceChangeRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ForceChangeRate other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ForceChangeRate.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ForceChangeRate), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ForceChangeRate"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ForceChangeRate)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ForceChangeRate otherQuantity)) throw new ArgumentException("Expected type ForceChangeRate.", nameof(obj));
+            if (obj is not ForceChangeRate otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ForceChangeRate>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ForceChangeRate"/> with another <see cref="ForceChangeRate"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ForceChangeRate"/> with another <see cref="ForceChangeRate"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -824,157 +813,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ForceChangeRate other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ForceChangeRateUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ForceChangeRateUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ForceChangeRate to another ForceChangeRate with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ForceChangeRate with the specified unit.</returns>
-        public ForceChangeRate ToUnit(ForceChangeRateUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ForceChangeRate"/> to another <see cref="ForceChangeRate"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ForceChangeRate with the specified unit.</returns>
-        public ForceChangeRate ToUnit(ForceChangeRateUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ForceChangeRate), Unit, typeof(ForceChangeRate), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ForceChangeRate)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="ForceChangeRate"/> to another <see cref="ForceChangeRate"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ForceChangeRate"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ForceChangeRateUnit unit, [NotNullWhen(true)] out ForceChangeRate? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ForceChangeRate? convertedOrNull = (Unit, unit) switch
-            {
-                // ForceChangeRateUnit -> BaseUnit
-                (ForceChangeRateUnit.CentinewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value) * 1e-2d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.DecanewtonPerMinute, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value / 60) * 1e1d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.DecanewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value) * 1e1d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.DecinewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value) * 1e-1d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.KilonewtonPerMinute, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value / 60) * 1e3d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.KilonewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value) * 1e3d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.KilopoundForcePerMinute, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value * 4.4482216152605 / 60) * 1e3d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.KilopoundForcePerSecond, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value * 4.4482216152605) * 1e3d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.MicronewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value) * 1e-6d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.MillinewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value) * 1e-3d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.NanonewtonPerSecond, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate((_value) * 1e-9d, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.NewtonPerMinute, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate(_value / 60, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.PoundForcePerMinute, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate(_value * 4.4482216152605 / 60, ForceChangeRateUnit.NewtonPerSecond),
-                (ForceChangeRateUnit.PoundForcePerSecond, ForceChangeRateUnit.NewtonPerSecond) => new ForceChangeRate(_value * 4.4482216152605, ForceChangeRateUnit.NewtonPerSecond),
-
-                // BaseUnit -> ForceChangeRateUnit
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.CentinewtonPerSecond) => new ForceChangeRate((_value) / 1e-2d, ForceChangeRateUnit.CentinewtonPerSecond),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.DecanewtonPerMinute) => new ForceChangeRate((_value * 60) / 1e1d, ForceChangeRateUnit.DecanewtonPerMinute),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.DecanewtonPerSecond) => new ForceChangeRate((_value) / 1e1d, ForceChangeRateUnit.DecanewtonPerSecond),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.DecinewtonPerSecond) => new ForceChangeRate((_value) / 1e-1d, ForceChangeRateUnit.DecinewtonPerSecond),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.KilonewtonPerMinute) => new ForceChangeRate((_value * 60) / 1e3d, ForceChangeRateUnit.KilonewtonPerMinute),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.KilonewtonPerSecond) => new ForceChangeRate((_value) / 1e3d, ForceChangeRateUnit.KilonewtonPerSecond),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.KilopoundForcePerMinute) => new ForceChangeRate((_value / 4.4482216152605 * 60) / 1e3d, ForceChangeRateUnit.KilopoundForcePerMinute),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.KilopoundForcePerSecond) => new ForceChangeRate((_value / 4.4482216152605) / 1e3d, ForceChangeRateUnit.KilopoundForcePerSecond),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.MicronewtonPerSecond) => new ForceChangeRate((_value) / 1e-6d, ForceChangeRateUnit.MicronewtonPerSecond),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.MillinewtonPerSecond) => new ForceChangeRate((_value) / 1e-3d, ForceChangeRateUnit.MillinewtonPerSecond),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.NanonewtonPerSecond) => new ForceChangeRate((_value) / 1e-9d, ForceChangeRateUnit.NanonewtonPerSecond),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.NewtonPerMinute) => new ForceChangeRate(_value * 60, ForceChangeRateUnit.NewtonPerMinute),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.PoundForcePerMinute) => new ForceChangeRate(_value / 4.4482216152605 * 60, ForceChangeRateUnit.PoundForcePerMinute),
-                (ForceChangeRateUnit.NewtonPerSecond, ForceChangeRateUnit.PoundForcePerSecond) => new ForceChangeRate(_value / 4.4482216152605, ForceChangeRateUnit.PoundForcePerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ForceChangeRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceChangeRateUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ForceChangeRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceChangeRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ForceChangeRateUnit> IQuantity<ForceChangeRateUnit>.ToUnit(ForceChangeRateUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -988,11 +829,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
index af311d6eb2..a04ef47dbb 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,15 +33,18 @@ namespace UnitsNet
     ///     The magnitude of force per unit length.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ForcePerLength :
-        IArithmeticQuantity<ForcePerLength, ForcePerLengthUnit>,
+        ILinearQuantity<ForcePerLength, ForcePerLengthUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ForcePerLength, ForcePerLength, double>,
+        IDivisionOperators<ForcePerLength, ForcePerLength, QuantityValue>,
+        IDivisionOperators<ForcePerLength, LinearDensity, Acceleration>,
         IDivisionOperators<ForcePerLength, SpecificWeight, Area>,
         IMultiplyOperators<ForcePerLength, Length, Force>,
         IDivisionOperators<ForcePerLength, ReciprocalLength, Force>,
         IDivisionOperators<ForcePerLength, Pressure, Length>,
+        IDivisionOperators<ForcePerLength, Acceleration, LinearDensity>,
         IMultiplyOperators<ForcePerLength, ReciprocalLength, Pressure>,
         IDivisionOperators<ForcePerLength, Length, Pressure>,
         IDivisionOperators<ForcePerLength, Force, ReciprocalLength>,
@@ -61,7 +62,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -111,7 +112,7 @@ public static ForcePerLengthInfo CreateDefault(Func<IEnumerable<UnitDefinition<F
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ForcePerLength"/> is [T^-2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ForcePerLength"/> is T^-2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 1, -2, 0, 0, 0, 0);
 
@@ -126,52 +127,124 @@ public static ForcePerLengthInfo CreateDefault(Func<IEnumerable<UnitDefinition<F
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ForcePerLengthUnit}"/> representing the default unit mappings for ForcePerLength.</returns>
             public static IEnumerable<UnitDefinition<ForcePerLengthUnit>> GetDefaultMappings()
             {
-                yield return new (ForcePerLengthUnit.CentinewtonPerCentimeter, "CentinewtonPerCentimeter", "CentinewtonsPerCentimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.CentinewtonPerMeter, "CentinewtonPerMeter", "CentinewtonsPerMeter", new BaseUnits(mass: MassUnit.Decagram, time: DurationUnit.Second));
-                yield return new (ForcePerLengthUnit.CentinewtonPerMillimeter, "CentinewtonPerMillimeter", "CentinewtonsPerMillimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.DecanewtonPerCentimeter, "DecanewtonPerCentimeter", "DecanewtonsPerCentimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.DecanewtonPerMeter, "DecanewtonPerMeter", "DecanewtonsPerMeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.DecanewtonPerMillimeter, "DecanewtonPerMillimeter", "DecanewtonsPerMillimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.DecinewtonPerCentimeter, "DecinewtonPerCentimeter", "DecinewtonsPerCentimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.DecinewtonPerMeter, "DecinewtonPerMeter", "DecinewtonsPerMeter", new BaseUnits(mass: MassUnit.Hectogram, time: DurationUnit.Second));
-                yield return new (ForcePerLengthUnit.DecinewtonPerMillimeter, "DecinewtonPerMillimeter", "DecinewtonsPerMillimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.KilogramForcePerCentimeter, "KilogramForcePerCentimeter", "KilogramsForcePerCentimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.KilogramForcePerMeter, "KilogramForcePerMeter", "KilogramsForcePerMeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.KilogramForcePerMillimeter, "KilogramForcePerMillimeter", "KilogramsForcePerMillimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.KilonewtonPerCentimeter, "KilonewtonPerCentimeter", "KilonewtonsPerCentimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.KilonewtonPerMeter, "KilonewtonPerMeter", "KilonewtonsPerMeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.KilonewtonPerMillimeter, "KilonewtonPerMillimeter", "KilonewtonsPerMillimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.KilopoundForcePerFoot, "KilopoundForcePerFoot", "KilopoundsForcePerFoot", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.KilopoundForcePerInch, "KilopoundForcePerInch", "KilopoundsForcePerInch", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.MeganewtonPerCentimeter, "MeganewtonPerCentimeter", "MeganewtonsPerCentimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.MeganewtonPerMeter, "MeganewtonPerMeter", "MeganewtonsPerMeter", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Millisecond));
-                yield return new (ForcePerLengthUnit.MeganewtonPerMillimeter, "MeganewtonPerMillimeter", "MeganewtonsPerMillimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.MicronewtonPerCentimeter, "MicronewtonPerCentimeter", "MicronewtonsPerCentimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.MicronewtonPerMeter, "MicronewtonPerMeter", "MicronewtonsPerMeter", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Second));
-                yield return new (ForcePerLengthUnit.MicronewtonPerMillimeter, "MicronewtonPerMillimeter", "MicronewtonsPerMillimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.MillinewtonPerCentimeter, "MillinewtonPerCentimeter", "MillinewtonsPerCentimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.MillinewtonPerMeter, "MillinewtonPerMeter", "MillinewtonsPerMeter", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (ForcePerLengthUnit.MillinewtonPerMillimeter, "MillinewtonPerMillimeter", "MillinewtonsPerMillimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.NanonewtonPerCentimeter, "NanonewtonPerCentimeter", "NanonewtonsPerCentimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.NanonewtonPerMeter, "NanonewtonPerMeter", "NanonewtonsPerMeter", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Second));
-                yield return new (ForcePerLengthUnit.NanonewtonPerMillimeter, "NanonewtonPerMillimeter", "NanonewtonsPerMillimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.NewtonPerCentimeter, "NewtonPerCentimeter", "NewtonsPerCentimeter", BaseUnits.Undefined);
+                yield return new (ForcePerLengthUnit.CentinewtonPerCentimeter, "CentinewtonPerCentimeter", "CentinewtonsPerCentimeter", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (ForcePerLengthUnit.CentinewtonPerMeter, "CentinewtonPerMeter", "CentinewtonsPerMeter", new BaseUnits(mass: MassUnit.Decagram, time: DurationUnit.Second),
+                     100
+                );
+                yield return new (ForcePerLengthUnit.CentinewtonPerMillimeter, "CentinewtonPerMillimeter", "CentinewtonsPerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (ForcePerLengthUnit.DecanewtonPerCentimeter, "DecanewtonPerCentimeter", "DecanewtonsPerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ForcePerLengthUnit.DecanewtonPerMeter, "DecanewtonPerMeter", "DecanewtonsPerMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (ForcePerLengthUnit.DecanewtonPerMillimeter, "DecanewtonPerMillimeter", "DecanewtonsPerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (ForcePerLengthUnit.DecinewtonPerCentimeter, "DecinewtonPerCentimeter", "DecinewtonsPerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (ForcePerLengthUnit.DecinewtonPerMeter, "DecinewtonPerMeter", "DecinewtonsPerMeter", new BaseUnits(mass: MassUnit.Hectogram, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (ForcePerLengthUnit.DecinewtonPerMillimeter, "DecinewtonPerMillimeter", "DecinewtonsPerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100)
+                );
+                yield return new (ForcePerLengthUnit.KilogramForcePerCentimeter, "KilogramForcePerCentimeter", "KilogramsForcePerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(200, 196133)
+                );
+                yield return new (ForcePerLengthUnit.KilogramForcePerMeter, "KilogramForcePerMeter", "KilogramsForcePerMeter", BaseUnits.Undefined,
+                     new QuantityValue(20000, 196133)
+                );
+                yield return new (ForcePerLengthUnit.KilogramForcePerMillimeter, "KilogramForcePerMillimeter", "KilogramsForcePerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(20, 196133)
+                );
+                yield return new (ForcePerLengthUnit.KilonewtonPerCentimeter, "KilonewtonPerCentimeter", "KilonewtonsPerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000)
+                );
+                yield return new (ForcePerLengthUnit.KilonewtonPerMeter, "KilonewtonPerMeter", "KilonewtonsPerMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ForcePerLengthUnit.KilonewtonPerMillimeter, "KilonewtonPerMillimeter", "KilonewtonsPerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ForcePerLengthUnit.KilopoundForcePerFoot, "KilopoundForcePerFoot", "KilopoundsForcePerFoot", BaseUnits.Undefined,
+                     new QuantityValue(609600000, 8896443230521)
+                );
+                yield return new (ForcePerLengthUnit.KilopoundForcePerInch, "KilopoundForcePerInch", "KilopoundsForcePerInch", BaseUnits.Undefined,
+                     new QuantityValue(50800000, 8896443230521)
+                );
+                yield return new (ForcePerLengthUnit.MeganewtonPerCentimeter, "MeganewtonPerCentimeter", "MeganewtonsPerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000000)
+                );
+                yield return new (ForcePerLengthUnit.MeganewtonPerMeter, "MeganewtonPerMeter", "MeganewtonsPerMeter", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Millisecond),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ForcePerLengthUnit.MeganewtonPerMillimeter, "MeganewtonPerMillimeter", "MeganewtonsPerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (ForcePerLengthUnit.MicronewtonPerCentimeter, "MicronewtonPerCentimeter", "MicronewtonsPerCentimeter", BaseUnits.Undefined,
+                     10000
+                );
+                yield return new (ForcePerLengthUnit.MicronewtonPerMeter, "MicronewtonPerMeter", "MicronewtonsPerMeter", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (ForcePerLengthUnit.MicronewtonPerMillimeter, "MicronewtonPerMillimeter", "MicronewtonsPerMillimeter", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (ForcePerLengthUnit.MillinewtonPerCentimeter, "MillinewtonPerCentimeter", "MillinewtonsPerCentimeter", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (ForcePerLengthUnit.MillinewtonPerMeter, "MillinewtonPerMeter", "MillinewtonsPerMeter", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (ForcePerLengthUnit.MillinewtonPerMillimeter, "MillinewtonPerMillimeter", "MillinewtonsPerMillimeter", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (ForcePerLengthUnit.NanonewtonPerCentimeter, "NanonewtonPerCentimeter", "NanonewtonsPerCentimeter", BaseUnits.Undefined,
+                     10000000
+                );
+                yield return new (ForcePerLengthUnit.NanonewtonPerMeter, "NanonewtonPerMeter", "NanonewtonsPerMeter", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (ForcePerLengthUnit.NanonewtonPerMillimeter, "NanonewtonPerMillimeter", "NanonewtonsPerMillimeter", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (ForcePerLengthUnit.NewtonPerCentimeter, "NewtonPerCentimeter", "NewtonsPerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100)
+                );
                 yield return new (ForcePerLengthUnit.NewtonPerMeter, "NewtonPerMeter", "NewtonsPerMeter", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ForcePerLengthUnit.NewtonPerMillimeter, "NewtonPerMillimeter", "NewtonsPerMillimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.PoundForcePerFoot, "PoundForcePerFoot", "PoundsForcePerFoot", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.PoundForcePerInch, "PoundForcePerInch", "PoundsForcePerInch", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.PoundForcePerYard, "PoundForcePerYard", "PoundsForcePerYard", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.TonneForcePerCentimeter, "TonneForcePerCentimeter", "TonnesForcePerCentimeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.TonneForcePerMeter, "TonneForcePerMeter", "TonnesForcePerMeter", BaseUnits.Undefined);
-                yield return new (ForcePerLengthUnit.TonneForcePerMillimeter, "TonneForcePerMillimeter", "TonnesForcePerMillimeter", BaseUnits.Undefined);
+                yield return new (ForcePerLengthUnit.NewtonPerMillimeter, "NewtonPerMillimeter", "NewtonsPerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ForcePerLengthUnit.PoundForcePerFoot, "PoundForcePerFoot", "PoundsForcePerFoot", BaseUnits.Undefined,
+                     new QuantityValue(609600000000, 8896443230521)
+                );
+                yield return new (ForcePerLengthUnit.PoundForcePerInch, "PoundForcePerInch", "PoundsForcePerInch", BaseUnits.Undefined,
+                     new QuantityValue(50800000000, 8896443230521)
+                );
+                yield return new (ForcePerLengthUnit.PoundForcePerYard, "PoundForcePerYard", "PoundsForcePerYard", BaseUnits.Undefined,
+                     new QuantityValue(1828800000000, 8896443230521)
+                );
+                yield return new (ForcePerLengthUnit.TonneForcePerCentimeter, "TonneForcePerCentimeter", "TonnesForcePerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 980665)
+                );
+                yield return new (ForcePerLengthUnit.TonneForcePerMeter, "TonneForcePerMeter", "TonnesForcePerMeter", BaseUnits.Undefined,
+                     new QuantityValue(20, 196133)
+                );
+                yield return new (ForcePerLengthUnit.TonneForcePerMillimeter, "TonneForcePerMillimeter", "TonnesForcePerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 9806650)
+                );
             }
         }
 
         static ForcePerLength()
         {
-            Info = ForcePerLengthInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ForcePerLengthInfo.CreateDefault);
         }
 
         /// <summary>
@@ -179,7 +252,7 @@ static ForcePerLength()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ForcePerLength(double value, ForcePerLengthUnit unit)
+        public ForcePerLength(QuantityValue value, ForcePerLengthUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -193,7 +266,7 @@ public ForcePerLength(double value, ForcePerLengthUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ForcePerLength(double value, UnitSystem unitSystem)
+        public ForcePerLength(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -204,7 +277,8 @@ public ForcePerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ForcePerLength" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ForcePerLength, ForcePerLengthUnit> Info { get; }
@@ -233,10 +307,8 @@ public ForcePerLength(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ForcePerLengthUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -270,287 +342,199 @@ public ForcePerLength(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.CentinewtonPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.CentinewtonPerCentimeter"/>
         /// </summary>
-        public double CentinewtonsPerCentimeter => As(ForcePerLengthUnit.CentinewtonPerCentimeter);
+        public QuantityValue CentinewtonsPerCentimeter => this.As(ForcePerLengthUnit.CentinewtonPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.CentinewtonPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.CentinewtonPerMeter"/>
         /// </summary>
-        public double CentinewtonsPerMeter => As(ForcePerLengthUnit.CentinewtonPerMeter);
+        public QuantityValue CentinewtonsPerMeter => this.As(ForcePerLengthUnit.CentinewtonPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.CentinewtonPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.CentinewtonPerMillimeter"/>
         /// </summary>
-        public double CentinewtonsPerMillimeter => As(ForcePerLengthUnit.CentinewtonPerMillimeter);
+        public QuantityValue CentinewtonsPerMillimeter => this.As(ForcePerLengthUnit.CentinewtonPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecanewtonPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecanewtonPerCentimeter"/>
         /// </summary>
-        public double DecanewtonsPerCentimeter => As(ForcePerLengthUnit.DecanewtonPerCentimeter);
+        public QuantityValue DecanewtonsPerCentimeter => this.As(ForcePerLengthUnit.DecanewtonPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecanewtonPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecanewtonPerMeter"/>
         /// </summary>
-        public double DecanewtonsPerMeter => As(ForcePerLengthUnit.DecanewtonPerMeter);
+        public QuantityValue DecanewtonsPerMeter => this.As(ForcePerLengthUnit.DecanewtonPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecanewtonPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecanewtonPerMillimeter"/>
         /// </summary>
-        public double DecanewtonsPerMillimeter => As(ForcePerLengthUnit.DecanewtonPerMillimeter);
+        public QuantityValue DecanewtonsPerMillimeter => this.As(ForcePerLengthUnit.DecanewtonPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecinewtonPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecinewtonPerCentimeter"/>
         /// </summary>
-        public double DecinewtonsPerCentimeter => As(ForcePerLengthUnit.DecinewtonPerCentimeter);
+        public QuantityValue DecinewtonsPerCentimeter => this.As(ForcePerLengthUnit.DecinewtonPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecinewtonPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecinewtonPerMeter"/>
         /// </summary>
-        public double DecinewtonsPerMeter => As(ForcePerLengthUnit.DecinewtonPerMeter);
+        public QuantityValue DecinewtonsPerMeter => this.As(ForcePerLengthUnit.DecinewtonPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecinewtonPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.DecinewtonPerMillimeter"/>
         /// </summary>
-        public double DecinewtonsPerMillimeter => As(ForcePerLengthUnit.DecinewtonPerMillimeter);
+        public QuantityValue DecinewtonsPerMillimeter => this.As(ForcePerLengthUnit.DecinewtonPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilogramForcePerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilogramForcePerCentimeter"/>
         /// </summary>
-        public double KilogramsForcePerCentimeter => As(ForcePerLengthUnit.KilogramForcePerCentimeter);
+        public QuantityValue KilogramsForcePerCentimeter => this.As(ForcePerLengthUnit.KilogramForcePerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilogramForcePerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilogramForcePerMeter"/>
         /// </summary>
-        public double KilogramsForcePerMeter => As(ForcePerLengthUnit.KilogramForcePerMeter);
+        public QuantityValue KilogramsForcePerMeter => this.As(ForcePerLengthUnit.KilogramForcePerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilogramForcePerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilogramForcePerMillimeter"/>
         /// </summary>
-        public double KilogramsForcePerMillimeter => As(ForcePerLengthUnit.KilogramForcePerMillimeter);
+        public QuantityValue KilogramsForcePerMillimeter => this.As(ForcePerLengthUnit.KilogramForcePerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilonewtonPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilonewtonPerCentimeter"/>
         /// </summary>
-        public double KilonewtonsPerCentimeter => As(ForcePerLengthUnit.KilonewtonPerCentimeter);
+        public QuantityValue KilonewtonsPerCentimeter => this.As(ForcePerLengthUnit.KilonewtonPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilonewtonPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilonewtonPerMeter"/>
         /// </summary>
-        public double KilonewtonsPerMeter => As(ForcePerLengthUnit.KilonewtonPerMeter);
+        public QuantityValue KilonewtonsPerMeter => this.As(ForcePerLengthUnit.KilonewtonPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilonewtonPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilonewtonPerMillimeter"/>
         /// </summary>
-        public double KilonewtonsPerMillimeter => As(ForcePerLengthUnit.KilonewtonPerMillimeter);
+        public QuantityValue KilonewtonsPerMillimeter => this.As(ForcePerLengthUnit.KilonewtonPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilopoundForcePerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilopoundForcePerFoot"/>
         /// </summary>
-        public double KilopoundsForcePerFoot => As(ForcePerLengthUnit.KilopoundForcePerFoot);
+        public QuantityValue KilopoundsForcePerFoot => this.As(ForcePerLengthUnit.KilopoundForcePerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilopoundForcePerInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.KilopoundForcePerInch"/>
         /// </summary>
-        public double KilopoundsForcePerInch => As(ForcePerLengthUnit.KilopoundForcePerInch);
+        public QuantityValue KilopoundsForcePerInch => this.As(ForcePerLengthUnit.KilopoundForcePerInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MeganewtonPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MeganewtonPerCentimeter"/>
         /// </summary>
-        public double MeganewtonsPerCentimeter => As(ForcePerLengthUnit.MeganewtonPerCentimeter);
+        public QuantityValue MeganewtonsPerCentimeter => this.As(ForcePerLengthUnit.MeganewtonPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MeganewtonPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MeganewtonPerMeter"/>
         /// </summary>
-        public double MeganewtonsPerMeter => As(ForcePerLengthUnit.MeganewtonPerMeter);
+        public QuantityValue MeganewtonsPerMeter => this.As(ForcePerLengthUnit.MeganewtonPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MeganewtonPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MeganewtonPerMillimeter"/>
         /// </summary>
-        public double MeganewtonsPerMillimeter => As(ForcePerLengthUnit.MeganewtonPerMillimeter);
+        public QuantityValue MeganewtonsPerMillimeter => this.As(ForcePerLengthUnit.MeganewtonPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MicronewtonPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MicronewtonPerCentimeter"/>
         /// </summary>
-        public double MicronewtonsPerCentimeter => As(ForcePerLengthUnit.MicronewtonPerCentimeter);
+        public QuantityValue MicronewtonsPerCentimeter => this.As(ForcePerLengthUnit.MicronewtonPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MicronewtonPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MicronewtonPerMeter"/>
         /// </summary>
-        public double MicronewtonsPerMeter => As(ForcePerLengthUnit.MicronewtonPerMeter);
+        public QuantityValue MicronewtonsPerMeter => this.As(ForcePerLengthUnit.MicronewtonPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MicronewtonPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MicronewtonPerMillimeter"/>
         /// </summary>
-        public double MicronewtonsPerMillimeter => As(ForcePerLengthUnit.MicronewtonPerMillimeter);
+        public QuantityValue MicronewtonsPerMillimeter => this.As(ForcePerLengthUnit.MicronewtonPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MillinewtonPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MillinewtonPerCentimeter"/>
         /// </summary>
-        public double MillinewtonsPerCentimeter => As(ForcePerLengthUnit.MillinewtonPerCentimeter);
+        public QuantityValue MillinewtonsPerCentimeter => this.As(ForcePerLengthUnit.MillinewtonPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MillinewtonPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MillinewtonPerMeter"/>
         /// </summary>
-        public double MillinewtonsPerMeter => As(ForcePerLengthUnit.MillinewtonPerMeter);
+        public QuantityValue MillinewtonsPerMeter => this.As(ForcePerLengthUnit.MillinewtonPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MillinewtonPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.MillinewtonPerMillimeter"/>
         /// </summary>
-        public double MillinewtonsPerMillimeter => As(ForcePerLengthUnit.MillinewtonPerMillimeter);
+        public QuantityValue MillinewtonsPerMillimeter => this.As(ForcePerLengthUnit.MillinewtonPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NanonewtonPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NanonewtonPerCentimeter"/>
         /// </summary>
-        public double NanonewtonsPerCentimeter => As(ForcePerLengthUnit.NanonewtonPerCentimeter);
+        public QuantityValue NanonewtonsPerCentimeter => this.As(ForcePerLengthUnit.NanonewtonPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NanonewtonPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NanonewtonPerMeter"/>
         /// </summary>
-        public double NanonewtonsPerMeter => As(ForcePerLengthUnit.NanonewtonPerMeter);
+        public QuantityValue NanonewtonsPerMeter => this.As(ForcePerLengthUnit.NanonewtonPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NanonewtonPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NanonewtonPerMillimeter"/>
         /// </summary>
-        public double NanonewtonsPerMillimeter => As(ForcePerLengthUnit.NanonewtonPerMillimeter);
+        public QuantityValue NanonewtonsPerMillimeter => this.As(ForcePerLengthUnit.NanonewtonPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NewtonPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NewtonPerCentimeter"/>
         /// </summary>
-        public double NewtonsPerCentimeter => As(ForcePerLengthUnit.NewtonPerCentimeter);
+        public QuantityValue NewtonsPerCentimeter => this.As(ForcePerLengthUnit.NewtonPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NewtonPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NewtonPerMeter"/>
         /// </summary>
-        public double NewtonsPerMeter => As(ForcePerLengthUnit.NewtonPerMeter);
+        public QuantityValue NewtonsPerMeter => this.As(ForcePerLengthUnit.NewtonPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NewtonPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.NewtonPerMillimeter"/>
         /// </summary>
-        public double NewtonsPerMillimeter => As(ForcePerLengthUnit.NewtonPerMillimeter);
+        public QuantityValue NewtonsPerMillimeter => this.As(ForcePerLengthUnit.NewtonPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.PoundForcePerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.PoundForcePerFoot"/>
         /// </summary>
-        public double PoundsForcePerFoot => As(ForcePerLengthUnit.PoundForcePerFoot);
+        public QuantityValue PoundsForcePerFoot => this.As(ForcePerLengthUnit.PoundForcePerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.PoundForcePerInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.PoundForcePerInch"/>
         /// </summary>
-        public double PoundsForcePerInch => As(ForcePerLengthUnit.PoundForcePerInch);
+        public QuantityValue PoundsForcePerInch => this.As(ForcePerLengthUnit.PoundForcePerInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.PoundForcePerYard"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.PoundForcePerYard"/>
         /// </summary>
-        public double PoundsForcePerYard => As(ForcePerLengthUnit.PoundForcePerYard);
+        public QuantityValue PoundsForcePerYard => this.As(ForcePerLengthUnit.PoundForcePerYard);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.TonneForcePerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.TonneForcePerCentimeter"/>
         /// </summary>
-        public double TonnesForcePerCentimeter => As(ForcePerLengthUnit.TonneForcePerCentimeter);
+        public QuantityValue TonnesForcePerCentimeter => this.As(ForcePerLengthUnit.TonneForcePerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.TonneForcePerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.TonneForcePerMeter"/>
         /// </summary>
-        public double TonnesForcePerMeter => As(ForcePerLengthUnit.TonneForcePerMeter);
+        public QuantityValue TonnesForcePerMeter => this.As(ForcePerLengthUnit.TonneForcePerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ForcePerLengthUnit.TonneForcePerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ForcePerLengthUnit.TonneForcePerMillimeter"/>
         /// </summary>
-        public double TonnesForcePerMillimeter => As(ForcePerLengthUnit.TonneForcePerMillimeter);
+        public QuantityValue TonnesForcePerMillimeter => this.As(ForcePerLengthUnit.TonneForcePerMillimeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ForcePerLengthUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.CentinewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.CentinewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.CentinewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecanewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecanewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecanewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecinewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecinewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.DecinewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilogramForcePerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilogramForcePerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilogramForcePerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilonewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilonewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilonewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilopoundForcePerFoot, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.KilopoundForcePerInch, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MeganewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MeganewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MeganewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MicronewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MicronewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MicronewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MillinewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MillinewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.MillinewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NanonewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NanonewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NanonewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.PoundForcePerFoot, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.PoundForcePerInch, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.PoundForcePerYard, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.TonneForcePerCentimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.TonneForcePerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.TonneForcePerMillimeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ForcePerLengthUnit
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.CentinewtonPerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.CentinewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.CentinewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.CentinewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.CentinewtonPerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.CentinewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecanewtonPerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.DecanewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecanewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.DecanewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecanewtonPerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.DecanewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecinewtonPerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.DecinewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecinewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.DecinewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecinewtonPerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.DecinewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilogramForcePerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.KilogramForcePerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilogramForcePerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.KilogramForcePerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilogramForcePerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.KilogramForcePerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilonewtonPerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.KilonewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilonewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.KilonewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilonewtonPerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.KilonewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilopoundForcePerFoot, quantity => quantity.ToUnit(ForcePerLengthUnit.KilopoundForcePerFoot));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilopoundForcePerInch, quantity => quantity.ToUnit(ForcePerLengthUnit.KilopoundForcePerInch));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MeganewtonPerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.MeganewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MeganewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.MeganewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MeganewtonPerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.MeganewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MicronewtonPerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.MicronewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MicronewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.MicronewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MicronewtonPerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.MicronewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MillinewtonPerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.MillinewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MillinewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.MillinewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MillinewtonPerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.MillinewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NanonewtonPerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NanonewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NanonewtonPerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NanonewtonPerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NanonewtonPerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NanonewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NewtonPerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NewtonPerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.NewtonPerMillimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.PoundForcePerFoot, quantity => quantity.ToUnit(ForcePerLengthUnit.PoundForcePerFoot));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.PoundForcePerInch, quantity => quantity.ToUnit(ForcePerLengthUnit.PoundForcePerInch));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.PoundForcePerYard, quantity => quantity.ToUnit(ForcePerLengthUnit.PoundForcePerYard));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.TonneForcePerCentimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.TonneForcePerCentimeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.TonneForcePerMeter, quantity => quantity.ToUnit(ForcePerLengthUnit.TonneForcePerMeter));
-            unitConverter.SetConversionFunction<ForcePerLength>(ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.TonneForcePerMillimeter, quantity => quantity.ToUnit(ForcePerLengthUnit.TonneForcePerMillimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -579,7 +563,7 @@ public static string GetAbbreviation(ForcePerLengthUnit unit, IFormatProvider? p
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromCentinewtonsPerCentimeter(double value)
+        public static ForcePerLength FromCentinewtonsPerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerCentimeter);
         }
@@ -587,7 +571,7 @@ public static ForcePerLength FromCentinewtonsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromCentinewtonsPerMeter(double value)
+        public static ForcePerLength FromCentinewtonsPerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMeter);
         }
@@ -595,7 +579,7 @@ public static ForcePerLength FromCentinewtonsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromCentinewtonsPerMillimeter(double value)
+        public static ForcePerLength FromCentinewtonsPerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMillimeter);
         }
@@ -603,7 +587,7 @@ public static ForcePerLength FromCentinewtonsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromDecanewtonsPerCentimeter(double value)
+        public static ForcePerLength FromDecanewtonsPerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerCentimeter);
         }
@@ -611,7 +595,7 @@ public static ForcePerLength FromDecanewtonsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromDecanewtonsPerMeter(double value)
+        public static ForcePerLength FromDecanewtonsPerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMeter);
         }
@@ -619,7 +603,7 @@ public static ForcePerLength FromDecanewtonsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromDecanewtonsPerMillimeter(double value)
+        public static ForcePerLength FromDecanewtonsPerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMillimeter);
         }
@@ -627,7 +611,7 @@ public static ForcePerLength FromDecanewtonsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromDecinewtonsPerCentimeter(double value)
+        public static ForcePerLength FromDecinewtonsPerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerCentimeter);
         }
@@ -635,7 +619,7 @@ public static ForcePerLength FromDecinewtonsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromDecinewtonsPerMeter(double value)
+        public static ForcePerLength FromDecinewtonsPerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMeter);
         }
@@ -643,7 +627,7 @@ public static ForcePerLength FromDecinewtonsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromDecinewtonsPerMillimeter(double value)
+        public static ForcePerLength FromDecinewtonsPerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMillimeter);
         }
@@ -651,7 +635,7 @@ public static ForcePerLength FromDecinewtonsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromKilogramsForcePerCentimeter(double value)
+        public static ForcePerLength FromKilogramsForcePerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerCentimeter);
         }
@@ -659,7 +643,7 @@ public static ForcePerLength FromKilogramsForcePerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromKilogramsForcePerMeter(double value)
+        public static ForcePerLength FromKilogramsForcePerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMeter);
         }
@@ -667,7 +651,7 @@ public static ForcePerLength FromKilogramsForcePerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromKilogramsForcePerMillimeter(double value)
+        public static ForcePerLength FromKilogramsForcePerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMillimeter);
         }
@@ -675,7 +659,7 @@ public static ForcePerLength FromKilogramsForcePerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromKilonewtonsPerCentimeter(double value)
+        public static ForcePerLength FromKilonewtonsPerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerCentimeter);
         }
@@ -683,7 +667,7 @@ public static ForcePerLength FromKilonewtonsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromKilonewtonsPerMeter(double value)
+        public static ForcePerLength FromKilonewtonsPerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMeter);
         }
@@ -691,7 +675,7 @@ public static ForcePerLength FromKilonewtonsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromKilonewtonsPerMillimeter(double value)
+        public static ForcePerLength FromKilonewtonsPerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMillimeter);
         }
@@ -699,7 +683,7 @@ public static ForcePerLength FromKilonewtonsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilopoundForcePerFoot"/>.
         /// </summary>
-        public static ForcePerLength FromKilopoundsForcePerFoot(double value)
+        public static ForcePerLength FromKilopoundsForcePerFoot(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerFoot);
         }
@@ -707,7 +691,7 @@ public static ForcePerLength FromKilopoundsForcePerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilopoundForcePerInch"/>.
         /// </summary>
-        public static ForcePerLength FromKilopoundsForcePerInch(double value)
+        public static ForcePerLength FromKilopoundsForcePerInch(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerInch);
         }
@@ -715,7 +699,7 @@ public static ForcePerLength FromKilopoundsForcePerInch(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromMeganewtonsPerCentimeter(double value)
+        public static ForcePerLength FromMeganewtonsPerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerCentimeter);
         }
@@ -723,7 +707,7 @@ public static ForcePerLength FromMeganewtonsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromMeganewtonsPerMeter(double value)
+        public static ForcePerLength FromMeganewtonsPerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMeter);
         }
@@ -731,7 +715,7 @@ public static ForcePerLength FromMeganewtonsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromMeganewtonsPerMillimeter(double value)
+        public static ForcePerLength FromMeganewtonsPerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMillimeter);
         }
@@ -739,7 +723,7 @@ public static ForcePerLength FromMeganewtonsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromMicronewtonsPerCentimeter(double value)
+        public static ForcePerLength FromMicronewtonsPerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerCentimeter);
         }
@@ -747,7 +731,7 @@ public static ForcePerLength FromMicronewtonsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromMicronewtonsPerMeter(double value)
+        public static ForcePerLength FromMicronewtonsPerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMeter);
         }
@@ -755,7 +739,7 @@ public static ForcePerLength FromMicronewtonsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromMicronewtonsPerMillimeter(double value)
+        public static ForcePerLength FromMicronewtonsPerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMillimeter);
         }
@@ -763,7 +747,7 @@ public static ForcePerLength FromMicronewtonsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromMillinewtonsPerCentimeter(double value)
+        public static ForcePerLength FromMillinewtonsPerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerCentimeter);
         }
@@ -771,7 +755,7 @@ public static ForcePerLength FromMillinewtonsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromMillinewtonsPerMeter(double value)
+        public static ForcePerLength FromMillinewtonsPerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMeter);
         }
@@ -779,7 +763,7 @@ public static ForcePerLength FromMillinewtonsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromMillinewtonsPerMillimeter(double value)
+        public static ForcePerLength FromMillinewtonsPerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMillimeter);
         }
@@ -787,7 +771,7 @@ public static ForcePerLength FromMillinewtonsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromNanonewtonsPerCentimeter(double value)
+        public static ForcePerLength FromNanonewtonsPerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerCentimeter);
         }
@@ -795,7 +779,7 @@ public static ForcePerLength FromNanonewtonsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromNanonewtonsPerMeter(double value)
+        public static ForcePerLength FromNanonewtonsPerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMeter);
         }
@@ -803,7 +787,7 @@ public static ForcePerLength FromNanonewtonsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromNanonewtonsPerMillimeter(double value)
+        public static ForcePerLength FromNanonewtonsPerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMillimeter);
         }
@@ -811,7 +795,7 @@ public static ForcePerLength FromNanonewtonsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromNewtonsPerCentimeter(double value)
+        public static ForcePerLength FromNewtonsPerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerCentimeter);
         }
@@ -819,7 +803,7 @@ public static ForcePerLength FromNewtonsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromNewtonsPerMeter(double value)
+        public static ForcePerLength FromNewtonsPerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMeter);
         }
@@ -827,7 +811,7 @@ public static ForcePerLength FromNewtonsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromNewtonsPerMillimeter(double value)
+        public static ForcePerLength FromNewtonsPerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMillimeter);
         }
@@ -835,7 +819,7 @@ public static ForcePerLength FromNewtonsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerFoot"/>.
         /// </summary>
-        public static ForcePerLength FromPoundsForcePerFoot(double value)
+        public static ForcePerLength FromPoundsForcePerFoot(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerFoot);
         }
@@ -843,7 +827,7 @@ public static ForcePerLength FromPoundsForcePerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerInch"/>.
         /// </summary>
-        public static ForcePerLength FromPoundsForcePerInch(double value)
+        public static ForcePerLength FromPoundsForcePerInch(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerInch);
         }
@@ -851,7 +835,7 @@ public static ForcePerLength FromPoundsForcePerInch(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerYard"/>.
         /// </summary>
-        public static ForcePerLength FromPoundsForcePerYard(double value)
+        public static ForcePerLength FromPoundsForcePerYard(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerYard);
         }
@@ -859,7 +843,7 @@ public static ForcePerLength FromPoundsForcePerYard(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerCentimeter"/>.
         /// </summary>
-        public static ForcePerLength FromTonnesForcePerCentimeter(double value)
+        public static ForcePerLength FromTonnesForcePerCentimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerCentimeter);
         }
@@ -867,7 +851,7 @@ public static ForcePerLength FromTonnesForcePerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerMeter"/>.
         /// </summary>
-        public static ForcePerLength FromTonnesForcePerMeter(double value)
+        public static ForcePerLength FromTonnesForcePerMeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMeter);
         }
@@ -875,7 +859,7 @@ public static ForcePerLength FromTonnesForcePerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerMillimeter"/>.
         /// </summary>
-        public static ForcePerLength FromTonnesForcePerMillimeter(double value)
+        public static ForcePerLength FromTonnesForcePerMillimeter(QuantityValue value)
         {
             return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMillimeter);
         }
@@ -886,7 +870,7 @@ public static ForcePerLength FromTonnesForcePerMillimeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ForcePerLength unit value.</returns>
-        public static ForcePerLength From(double value, ForcePerLengthUnit fromUnit)
+        public static ForcePerLength From(QuantityValue value, ForcePerLengthUnit fromUnit)
         {
             return new ForcePerLength(value, fromUnit);
         }
@@ -947,10 +931,7 @@ public static ForcePerLength Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ForcePerLength Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ForcePerLength, ForcePerLengthUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ForcePerLength, ForcePerLengthUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -978,11 +959,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ForcePerLength r
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ForcePerLength result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ForcePerLength, ForcePerLengthUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ForcePerLength, ForcePerLengthUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -1003,7 +980,7 @@ public static ForcePerLengthUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1014,7 +991,7 @@ public static ForcePerLengthUnit ParseUnit(string str, IFormatProvider? provider
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ForcePerLengthUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ForcePerLengthUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ForcePerLengthUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1029,7 +1006,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ForcePerLeng
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ForcePerLengthUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1048,35 +1025,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ForcePerLength"/> from adding two <see cref="ForcePerLength"/>.</summary>
         public static ForcePerLength operator +(ForcePerLength left, ForcePerLength right)
         {
-            return new ForcePerLength(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ForcePerLength(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ForcePerLength"/> from subtracting two <see cref="ForcePerLength"/>.</summary>
         public static ForcePerLength operator -(ForcePerLength left, ForcePerLength right)
         {
-            return new ForcePerLength(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ForcePerLength(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ForcePerLength"/> from multiplying value and <see cref="ForcePerLength"/>.</summary>
-        public static ForcePerLength operator *(double left, ForcePerLength right)
+        public static ForcePerLength operator *(QuantityValue left, ForcePerLength right)
         {
             return new ForcePerLength(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ForcePerLength"/> from multiplying value and <see cref="ForcePerLength"/>.</summary>
-        public static ForcePerLength operator *(ForcePerLength left, double right)
+        public static ForcePerLength operator *(ForcePerLength left, QuantityValue right)
         {
             return new ForcePerLength(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ForcePerLength"/> from dividing <see cref="ForcePerLength"/> by value.</summary>
-        public static ForcePerLength operator /(ForcePerLength left, double right)
+        public static ForcePerLength operator /(ForcePerLength left, QuantityValue right)
         {
             return new ForcePerLength(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ForcePerLength"/> by <see cref="ForcePerLength"/>.</summary>
-        public static double operator /(ForcePerLength left, ForcePerLength right)
+        public static QuantityValue operator /(ForcePerLength left, ForcePerLength right)
         {
             return left.NewtonsPerMeter / right.NewtonsPerMeter;
         }
@@ -1085,6 +1062,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="Acceleration"/> from <see cref="ForcePerLength"/> / <see cref="LinearDensity"/>.</summary>
+        public static Acceleration operator /(ForcePerLength forcePerLength, LinearDensity linearDensity)
+        {
+            return Acceleration.FromMetersPerSecondSquared(forcePerLength.NewtonsPerMeter / linearDensity.KilogramsPerMeter);
+        }
+
         /// <summary>Get <see cref="Area"/> from <see cref="ForcePerLength"/> / <see cref="SpecificWeight"/>.</summary>
         public static Area operator /(ForcePerLength forcePerLength, SpecificWeight specificWeight)
         {
@@ -1109,6 +1092,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Length.FromMeters(forcePerLength.NewtonsPerMeter / pressure.NewtonsPerSquareMeter);
         }
 
+        /// <summary>Get <see cref="LinearDensity"/> from <see cref="ForcePerLength"/> / <see cref="Acceleration"/>.</summary>
+        public static LinearDensity operator /(ForcePerLength forcePerLength, Acceleration acceleration)
+        {
+            return LinearDensity.FromKilogramsPerMeter(forcePerLength.NewtonsPerMeter / acceleration.MetersPerSecondSquared);
+        }
+
         /// <summary>Get <see cref="Pressure"/> from <see cref="ForcePerLength"/> * <see cref="ReciprocalLength"/>.</summary>
         public static Pressure operator *(ForcePerLength forcePerLength, ReciprocalLength reciprocalLength)
         {
@@ -1146,97 +1135,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ForcePerLength left, ForcePerLength right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ForcePerLength left, ForcePerLength right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ForcePerLength left, ForcePerLength right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ForcePerLength left, ForcePerLength right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ForcePerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ForcePerLength other, ForcePerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ForcePerLength"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ForcePerLength)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ForcePerLength left, ForcePerLength right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ForcePerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ForcePerLength other, ForcePerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ForcePerLength"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ForcePerLength,ForcePerLength)"/>.
+        ///     See that operator (and <see cref="Equals(ForcePerLength)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ForcePerLength left, ForcePerLength right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ForcePerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ForcePerLength other, ForcePerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ForcePerLength"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ForcePerLength"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ForcePerLength"/>, this method delegates to
+        ///     <see cref="Equals(ForcePerLength)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ForcePerLength otherQuantity))
+            if (obj is not ForcePerLength otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ForcePerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ForcePerLength other, ForcePerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ForcePerLength"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ForcePerLength other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ForcePerLength.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ForcePerLength), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ForcePerLength"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ForcePerLength)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ForcePerLength otherQuantity)) throw new ArgumentException("Expected type ForcePerLength.", nameof(obj));
+            if (obj is not ForcePerLength otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ForcePerLength>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ForcePerLength"/> with another <see cref="ForcePerLength"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ForcePerLength"/> with another <see cref="ForcePerLength"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1248,203 +1251,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ForcePerLength other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ForcePerLengthUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ForcePerLengthUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ForcePerLength to another ForcePerLength with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ForcePerLength with the specified unit.</returns>
-        public ForcePerLength ToUnit(ForcePerLengthUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ForcePerLength"/> to another <see cref="ForcePerLength"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ForcePerLength with the specified unit.</returns>
-        public ForcePerLength ToUnit(ForcePerLengthUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ForcePerLength), Unit, typeof(ForcePerLength), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ForcePerLength)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ForcePerLength"/> to another <see cref="ForcePerLength"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ForcePerLength"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ForcePerLengthUnit unit, [NotNullWhen(true)] out ForcePerLength? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ForcePerLength? convertedOrNull = (Unit, unit) switch
-            {
-                // ForcePerLengthUnit -> BaseUnit
-                (ForcePerLengthUnit.CentinewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e2) * 1e-2d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.CentinewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value) * 1e-2d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.CentinewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e3) * 1e-2d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.DecanewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e2) * 1e1d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.DecanewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value) * 1e1d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.DecanewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e3) * 1e1d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.DecinewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e2) * 1e-1d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.DecinewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value) * 1e-1d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.DecinewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e3) * 1e-1d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.KilogramForcePerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 980.665, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.KilogramForcePerMeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 9.80665, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.KilogramForcePerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 9.80665e3, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.KilonewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e2) * 1e3d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.KilonewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value) * 1e3d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.KilonewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e3) * 1e3d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.KilopoundForcePerFoot, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 4.4482216152605 / 0.3048e-3, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.KilopoundForcePerInch, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 4.4482216152605 / 2.54e-5, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.MeganewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e2) * 1e6d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.MeganewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value) * 1e6d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.MeganewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e3) * 1e6d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.MicronewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e2) * 1e-6d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.MicronewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value) * 1e-6d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.MicronewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e3) * 1e-6d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.MillinewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e2) * 1e-3d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.MillinewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value) * 1e-3d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.MillinewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e3) * 1e-3d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.NanonewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e2) * 1e-9d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.NanonewtonPerMeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value) * 1e-9d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.NanonewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength((_value * 1e3) * 1e-9d, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.NewtonPerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 1e2, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.NewtonPerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 1e3, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.PoundForcePerFoot, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 4.4482216152605 / 0.3048, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.PoundForcePerInch, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 4.4482216152605 / 2.54e-2, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.PoundForcePerYard, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 4.4482216152605 / 0.9144, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.TonneForcePerCentimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 9.80665e5, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.TonneForcePerMeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 9.80665e3, ForcePerLengthUnit.NewtonPerMeter),
-                (ForcePerLengthUnit.TonneForcePerMillimeter, ForcePerLengthUnit.NewtonPerMeter) => new ForcePerLength(_value * 9.80665e6, ForcePerLengthUnit.NewtonPerMeter),
-
-                // BaseUnit -> ForcePerLengthUnit
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.CentinewtonPerCentimeter) => new ForcePerLength((_value / 1e2) / 1e-2d, ForcePerLengthUnit.CentinewtonPerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.CentinewtonPerMeter) => new ForcePerLength((_value) / 1e-2d, ForcePerLengthUnit.CentinewtonPerMeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.CentinewtonPerMillimeter) => new ForcePerLength((_value / 1e3) / 1e-2d, ForcePerLengthUnit.CentinewtonPerMillimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecanewtonPerCentimeter) => new ForcePerLength((_value / 1e2) / 1e1d, ForcePerLengthUnit.DecanewtonPerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecanewtonPerMeter) => new ForcePerLength((_value) / 1e1d, ForcePerLengthUnit.DecanewtonPerMeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecanewtonPerMillimeter) => new ForcePerLength((_value / 1e3) / 1e1d, ForcePerLengthUnit.DecanewtonPerMillimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecinewtonPerCentimeter) => new ForcePerLength((_value / 1e2) / 1e-1d, ForcePerLengthUnit.DecinewtonPerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecinewtonPerMeter) => new ForcePerLength((_value) / 1e-1d, ForcePerLengthUnit.DecinewtonPerMeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.DecinewtonPerMillimeter) => new ForcePerLength((_value / 1e3) / 1e-1d, ForcePerLengthUnit.DecinewtonPerMillimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilogramForcePerCentimeter) => new ForcePerLength(_value / 980.665, ForcePerLengthUnit.KilogramForcePerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilogramForcePerMeter) => new ForcePerLength(_value / 9.80665, ForcePerLengthUnit.KilogramForcePerMeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilogramForcePerMillimeter) => new ForcePerLength(_value / 9.80665e3, ForcePerLengthUnit.KilogramForcePerMillimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilonewtonPerCentimeter) => new ForcePerLength((_value / 1e2) / 1e3d, ForcePerLengthUnit.KilonewtonPerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilonewtonPerMeter) => new ForcePerLength((_value) / 1e3d, ForcePerLengthUnit.KilonewtonPerMeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilonewtonPerMillimeter) => new ForcePerLength((_value / 1e3) / 1e3d, ForcePerLengthUnit.KilonewtonPerMillimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilopoundForcePerFoot) => new ForcePerLength(_value * 0.3048e-3 / 4.4482216152605, ForcePerLengthUnit.KilopoundForcePerFoot),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.KilopoundForcePerInch) => new ForcePerLength(_value * 2.54e-5 / 4.4482216152605, ForcePerLengthUnit.KilopoundForcePerInch),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MeganewtonPerCentimeter) => new ForcePerLength((_value / 1e2) / 1e6d, ForcePerLengthUnit.MeganewtonPerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MeganewtonPerMeter) => new ForcePerLength((_value) / 1e6d, ForcePerLengthUnit.MeganewtonPerMeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MeganewtonPerMillimeter) => new ForcePerLength((_value / 1e3) / 1e6d, ForcePerLengthUnit.MeganewtonPerMillimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MicronewtonPerCentimeter) => new ForcePerLength((_value / 1e2) / 1e-6d, ForcePerLengthUnit.MicronewtonPerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MicronewtonPerMeter) => new ForcePerLength((_value) / 1e-6d, ForcePerLengthUnit.MicronewtonPerMeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MicronewtonPerMillimeter) => new ForcePerLength((_value / 1e3) / 1e-6d, ForcePerLengthUnit.MicronewtonPerMillimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MillinewtonPerCentimeter) => new ForcePerLength((_value / 1e2) / 1e-3d, ForcePerLengthUnit.MillinewtonPerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MillinewtonPerMeter) => new ForcePerLength((_value) / 1e-3d, ForcePerLengthUnit.MillinewtonPerMeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.MillinewtonPerMillimeter) => new ForcePerLength((_value / 1e3) / 1e-3d, ForcePerLengthUnit.MillinewtonPerMillimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NanonewtonPerCentimeter) => new ForcePerLength((_value / 1e2) / 1e-9d, ForcePerLengthUnit.NanonewtonPerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NanonewtonPerMeter) => new ForcePerLength((_value) / 1e-9d, ForcePerLengthUnit.NanonewtonPerMeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NanonewtonPerMillimeter) => new ForcePerLength((_value / 1e3) / 1e-9d, ForcePerLengthUnit.NanonewtonPerMillimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NewtonPerCentimeter) => new ForcePerLength(_value / 1e2, ForcePerLengthUnit.NewtonPerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.NewtonPerMillimeter) => new ForcePerLength(_value / 1e3, ForcePerLengthUnit.NewtonPerMillimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.PoundForcePerFoot) => new ForcePerLength(_value * 0.3048 / 4.4482216152605, ForcePerLengthUnit.PoundForcePerFoot),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.PoundForcePerInch) => new ForcePerLength(_value * 2.54e-2 / 4.4482216152605, ForcePerLengthUnit.PoundForcePerInch),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.PoundForcePerYard) => new ForcePerLength(_value * 0.9144 / 4.4482216152605, ForcePerLengthUnit.PoundForcePerYard),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.TonneForcePerCentimeter) => new ForcePerLength(_value / 9.80665e5, ForcePerLengthUnit.TonneForcePerCentimeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.TonneForcePerMeter) => new ForcePerLength(_value / 9.80665e3, ForcePerLengthUnit.TonneForcePerMeter),
-                (ForcePerLengthUnit.NewtonPerMeter, ForcePerLengthUnit.TonneForcePerMillimeter) => new ForcePerLength(_value / 9.80665e6, ForcePerLengthUnit.TonneForcePerMillimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ForcePerLengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForcePerLengthUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ForcePerLengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForcePerLengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ForcePerLengthUnit> IQuantity<ForcePerLengthUnit>.ToUnit(ForcePerLengthUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1458,11 +1267,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
index fa5f67b223..aeae605f14 100644
--- a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     The number of occurrences of a repeating event per unit time.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Frequency :
-        IArithmeticQuantity<Frequency, FrequencyUnit>,
+        ILinearQuantity<Frequency, FrequencyUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Frequency, Frequency, double>,
+        IDivisionOperators<Frequency, Frequency, QuantityValue>,
+        IMultiplyOperators<Frequency, Information, BitRate>,
         IMultiplyOperators<Frequency, Energy, Power>,
         IComparisonOperators<Frequency, Frequency, bool>,
         IParsable<Frequency>,
@@ -53,7 +53,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +103,7 @@ public static FrequencyInfo CreateDefault(Func<IEnumerable<UnitDefinition<Freque
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Frequency"/> is [T^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Frequency"/> is T^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, -1, 0, 0, 0, 0);
 
@@ -118,26 +118,46 @@ public static FrequencyInfo CreateDefault(Func<IEnumerable<UnitDefinition<Freque
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{FrequencyUnit}"/> representing the default unit mappings for Frequency.</returns>
             public static IEnumerable<UnitDefinition<FrequencyUnit>> GetDefaultMappings()
             {
-                yield return new (FrequencyUnit.BeatPerMinute, "BeatPerMinute", "BeatsPerMinute", new BaseUnits(time: DurationUnit.Minute));
-                yield return new (FrequencyUnit.CyclePerHour, "CyclePerHour", "CyclesPerHour", new BaseUnits(time: DurationUnit.Hour));
-                yield return new (FrequencyUnit.CyclePerMinute, "CyclePerMinute", "CyclesPerMinute", new BaseUnits(time: DurationUnit.Minute));
-                yield return new (FrequencyUnit.Gigahertz, "Gigahertz", "Gigahertz", new BaseUnits(time: DurationUnit.Nanosecond));
+                yield return new (FrequencyUnit.BeatPerMinute, "BeatPerMinute", "BeatsPerMinute", new BaseUnits(time: DurationUnit.Minute),
+                     60
+                );
+                yield return new (FrequencyUnit.CyclePerHour, "CyclePerHour", "CyclesPerHour", new BaseUnits(time: DurationUnit.Hour),
+                     3600
+                );
+                yield return new (FrequencyUnit.CyclePerMinute, "CyclePerMinute", "CyclesPerMinute", new BaseUnits(time: DurationUnit.Minute),
+                     60
+                );
+                yield return new (FrequencyUnit.Gigahertz, "Gigahertz", "Gigahertz", new BaseUnits(time: DurationUnit.Nanosecond),
+                     new QuantityValue(1, 1000000000)
+                );
                 yield return new (FrequencyUnit.Hertz, "Hertz", "Hertz", new BaseUnits(time: DurationUnit.Second));
-                yield return new (FrequencyUnit.Kilohertz, "Kilohertz", "Kilohertz", new BaseUnits(time: DurationUnit.Millisecond));
-                yield return new (FrequencyUnit.Megahertz, "Megahertz", "Megahertz", new BaseUnits(time: DurationUnit.Microsecond));
-                yield return new (FrequencyUnit.Microhertz, "Microhertz", "Microhertz", BaseUnits.Undefined);
-                yield return new (FrequencyUnit.Millihertz, "Millihertz", "Millihertz", BaseUnits.Undefined);
-                yield return new (FrequencyUnit.PerSecond, "PerSecond", "PerSecond", new BaseUnits(time: DurationUnit.Second));
-                yield return new (FrequencyUnit.RadianPerSecond, "RadianPerSecond", "RadiansPerSecond", BaseUnits.Undefined);
-                yield return new (FrequencyUnit.Terahertz, "Terahertz", "Terahertz", new BaseUnits(time: DurationUnit.Picosecond));
+                yield return new (FrequencyUnit.Kilohertz, "Kilohertz", "Kilohertz", new BaseUnits(time: DurationUnit.Millisecond),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (FrequencyUnit.Megahertz, "Megahertz", "Megahertz", new BaseUnits(time: DurationUnit.Microsecond),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (FrequencyUnit.Microhertz, "Microhertz", "Microhertz", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (FrequencyUnit.Millihertz, "Millihertz", "Millihertz", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (FrequencyUnit.PerSecond, "PerSecond", "PerSecond", new BaseUnits(time: DurationUnit.Second),
+                     1
+                );
+                yield return new (FrequencyUnit.RadianPerSecond, "RadianPerSecond", "RadiansPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 500000000000000)
+                );
+                yield return new (FrequencyUnit.Terahertz, "Terahertz", "Terahertz", new BaseUnits(time: DurationUnit.Picosecond),
+                     new QuantityValue(1, 1000000000000)
+                );
             }
         }
 
         static Frequency()
         {
-            Info = FrequencyInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(FrequencyInfo.CreateDefault);
         }
 
         /// <summary>
@@ -145,7 +165,7 @@ static Frequency()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Frequency(double value, FrequencyUnit unit)
+        public Frequency(QuantityValue value, FrequencyUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -159,7 +179,7 @@ public Frequency(double value, FrequencyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Frequency(double value, UnitSystem unitSystem)
+        public Frequency(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -170,7 +190,8 @@ public Frequency(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Frequency" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Frequency, FrequencyUnit> Info { get; }
@@ -199,10 +220,8 @@ public Frequency(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public FrequencyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -236,105 +255,69 @@ public Frequency(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.BeatPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.BeatPerMinute"/>
         /// </summary>
-        public double BeatsPerMinute => As(FrequencyUnit.BeatPerMinute);
+        public QuantityValue BeatsPerMinute => this.As(FrequencyUnit.BeatPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.CyclePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.CyclePerHour"/>
         /// </summary>
-        public double CyclesPerHour => As(FrequencyUnit.CyclePerHour);
+        public QuantityValue CyclesPerHour => this.As(FrequencyUnit.CyclePerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.CyclePerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.CyclePerMinute"/>
         /// </summary>
-        public double CyclesPerMinute => As(FrequencyUnit.CyclePerMinute);
+        public QuantityValue CyclesPerMinute => this.As(FrequencyUnit.CyclePerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Gigahertz"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.Gigahertz"/>
         /// </summary>
-        public double Gigahertz => As(FrequencyUnit.Gigahertz);
+        public QuantityValue Gigahertz => this.As(FrequencyUnit.Gigahertz);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Hertz"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.Hertz"/>
         /// </summary>
-        public double Hertz => As(FrequencyUnit.Hertz);
+        public QuantityValue Hertz => this.As(FrequencyUnit.Hertz);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Kilohertz"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.Kilohertz"/>
         /// </summary>
-        public double Kilohertz => As(FrequencyUnit.Kilohertz);
+        public QuantityValue Kilohertz => this.As(FrequencyUnit.Kilohertz);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Megahertz"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.Megahertz"/>
         /// </summary>
-        public double Megahertz => As(FrequencyUnit.Megahertz);
+        public QuantityValue Megahertz => this.As(FrequencyUnit.Megahertz);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Microhertz"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.Microhertz"/>
         /// </summary>
-        public double Microhertz => As(FrequencyUnit.Microhertz);
+        public QuantityValue Microhertz => this.As(FrequencyUnit.Microhertz);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Millihertz"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.Millihertz"/>
         /// </summary>
-        public double Millihertz => As(FrequencyUnit.Millihertz);
+        public QuantityValue Millihertz => this.As(FrequencyUnit.Millihertz);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.PerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.PerSecond"/>
         /// </summary>
-        public double PerSecond => As(FrequencyUnit.PerSecond);
+        public QuantityValue PerSecond => this.As(FrequencyUnit.PerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.RadianPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.RadianPerSecond"/>
         /// </summary>
-        public double RadiansPerSecond => As(FrequencyUnit.RadianPerSecond);
+        public QuantityValue RadiansPerSecond => this.As(FrequencyUnit.RadianPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FrequencyUnit.Terahertz"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FrequencyUnit.Terahertz"/>
         /// </summary>
-        public double Terahertz => As(FrequencyUnit.Terahertz);
+        public QuantityValue Terahertz => this.As(FrequencyUnit.Terahertz);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: FrequencyUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.BeatPerMinute, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.CyclePerHour, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.CyclePerMinute, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Gigahertz, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Kilohertz, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Megahertz, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Microhertz, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Millihertz, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.PerSecond, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.RadianPerSecond, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Terahertz, FrequencyUnit.Hertz, quantity => quantity.ToUnit(FrequencyUnit.Hertz));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.Hertz, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> FrequencyUnit
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.BeatPerMinute, quantity => quantity.ToUnit(FrequencyUnit.BeatPerMinute));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.CyclePerHour, quantity => quantity.ToUnit(FrequencyUnit.CyclePerHour));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.CyclePerMinute, quantity => quantity.ToUnit(FrequencyUnit.CyclePerMinute));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.Gigahertz, quantity => quantity.ToUnit(FrequencyUnit.Gigahertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.Kilohertz, quantity => quantity.ToUnit(FrequencyUnit.Kilohertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.Megahertz, quantity => quantity.ToUnit(FrequencyUnit.Megahertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.Microhertz, quantity => quantity.ToUnit(FrequencyUnit.Microhertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.Millihertz, quantity => quantity.ToUnit(FrequencyUnit.Millihertz));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.PerSecond, quantity => quantity.ToUnit(FrequencyUnit.PerSecond));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.RadianPerSecond, quantity => quantity.ToUnit(FrequencyUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<Frequency>(FrequencyUnit.Hertz, FrequencyUnit.Terahertz, quantity => quantity.ToUnit(FrequencyUnit.Terahertz));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -363,7 +346,7 @@ public static string GetAbbreviation(FrequencyUnit unit, IFormatProvider? provid
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.BeatPerMinute"/>.
         /// </summary>
-        public static Frequency FromBeatsPerMinute(double value)
+        public static Frequency FromBeatsPerMinute(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.BeatPerMinute);
         }
@@ -371,7 +354,7 @@ public static Frequency FromBeatsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.CyclePerHour"/>.
         /// </summary>
-        public static Frequency FromCyclesPerHour(double value)
+        public static Frequency FromCyclesPerHour(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.CyclePerHour);
         }
@@ -379,7 +362,7 @@ public static Frequency FromCyclesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.CyclePerMinute"/>.
         /// </summary>
-        public static Frequency FromCyclesPerMinute(double value)
+        public static Frequency FromCyclesPerMinute(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.CyclePerMinute);
         }
@@ -387,7 +370,7 @@ public static Frequency FromCyclesPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Gigahertz"/>.
         /// </summary>
-        public static Frequency FromGigahertz(double value)
+        public static Frequency FromGigahertz(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.Gigahertz);
         }
@@ -395,7 +378,7 @@ public static Frequency FromGigahertz(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Hertz"/>.
         /// </summary>
-        public static Frequency FromHertz(double value)
+        public static Frequency FromHertz(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.Hertz);
         }
@@ -403,7 +386,7 @@ public static Frequency FromHertz(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Kilohertz"/>.
         /// </summary>
-        public static Frequency FromKilohertz(double value)
+        public static Frequency FromKilohertz(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.Kilohertz);
         }
@@ -411,7 +394,7 @@ public static Frequency FromKilohertz(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Megahertz"/>.
         /// </summary>
-        public static Frequency FromMegahertz(double value)
+        public static Frequency FromMegahertz(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.Megahertz);
         }
@@ -419,7 +402,7 @@ public static Frequency FromMegahertz(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Microhertz"/>.
         /// </summary>
-        public static Frequency FromMicrohertz(double value)
+        public static Frequency FromMicrohertz(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.Microhertz);
         }
@@ -427,7 +410,7 @@ public static Frequency FromMicrohertz(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Millihertz"/>.
         /// </summary>
-        public static Frequency FromMillihertz(double value)
+        public static Frequency FromMillihertz(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.Millihertz);
         }
@@ -435,7 +418,7 @@ public static Frequency FromMillihertz(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.PerSecond"/>.
         /// </summary>
-        public static Frequency FromPerSecond(double value)
+        public static Frequency FromPerSecond(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.PerSecond);
         }
@@ -443,7 +426,7 @@ public static Frequency FromPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.RadianPerSecond"/>.
         /// </summary>
-        public static Frequency FromRadiansPerSecond(double value)
+        public static Frequency FromRadiansPerSecond(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.RadianPerSecond);
         }
@@ -451,7 +434,7 @@ public static Frequency FromRadiansPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Terahertz"/>.
         /// </summary>
-        public static Frequency FromTerahertz(double value)
+        public static Frequency FromTerahertz(QuantityValue value)
         {
             return new Frequency(value, FrequencyUnit.Terahertz);
         }
@@ -462,7 +445,7 @@ public static Frequency FromTerahertz(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Frequency unit value.</returns>
-        public static Frequency From(double value, FrequencyUnit fromUnit)
+        public static Frequency From(QuantityValue value, FrequencyUnit fromUnit)
         {
             return new Frequency(value, fromUnit);
         }
@@ -523,10 +506,7 @@ public static Frequency Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Frequency Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Frequency, FrequencyUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Frequency, FrequencyUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -554,11 +534,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Frequency result
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Frequency result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Frequency, FrequencyUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Frequency, FrequencyUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -579,7 +555,7 @@ public static FrequencyUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -590,7 +566,7 @@ public static FrequencyUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.FrequencyUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.FrequencyUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out FrequencyUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -605,7 +581,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out FrequencyUni
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out FrequencyUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -624,35 +600,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Frequency"/> from adding two <see cref="Frequency"/>.</summary>
         public static Frequency operator +(Frequency left, Frequency right)
         {
-            return new Frequency(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Frequency(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Frequency"/> from subtracting two <see cref="Frequency"/>.</summary>
         public static Frequency operator -(Frequency left, Frequency right)
         {
-            return new Frequency(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Frequency(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Frequency"/> from multiplying value and <see cref="Frequency"/>.</summary>
-        public static Frequency operator *(double left, Frequency right)
+        public static Frequency operator *(QuantityValue left, Frequency right)
         {
             return new Frequency(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Frequency"/> from multiplying value and <see cref="Frequency"/>.</summary>
-        public static Frequency operator *(Frequency left, double right)
+        public static Frequency operator *(Frequency left, QuantityValue right)
         {
             return new Frequency(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Frequency"/> from dividing <see cref="Frequency"/> by value.</summary>
-        public static Frequency operator /(Frequency left, double right)
+        public static Frequency operator /(Frequency left, QuantityValue right)
         {
             return new Frequency(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Frequency"/> by <see cref="Frequency"/>.</summary>
-        public static double operator /(Frequency left, Frequency right)
+        public static QuantityValue operator /(Frequency left, Frequency right)
         {
             return left.Hertz / right.Hertz;
         }
@@ -661,6 +637,19 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Calculates the inverse of this quantity.</summary>
+        /// <returns>The corresponding inverse quantity, <see cref="Duration"/>.</returns>
+        public Duration Inverse()
+        {
+            return UnitConverter.Default.ConvertTo(Value, Unit, Duration.Info);
+        }
+
+        /// <summary>Get <see cref="BitRate"/> from <see cref="Frequency"/> * <see cref="Information"/>.</summary>
+        public static BitRate operator *(Frequency frequency, Information information)
+        {
+            return BitRate.FromBitsPerSecond(frequency.PerSecond * information.Bits);
+        }
+
         /// <summary>Get <see cref="Power"/> from <see cref="Frequency"/> * <see cref="Energy"/>.</summary>
         public static Power operator *(Frequency frequency, Energy energy)
         {
@@ -674,97 +663,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Frequency left, Frequency right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Frequency left, Frequency right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Frequency left, Frequency right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Frequency left, Frequency right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Frequency"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Frequency other, Frequency tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Frequency"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Frequency)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Frequency left, Frequency right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Frequency"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Frequency other, Frequency tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Frequency"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Frequency,Frequency)"/>.
+        ///     See that operator (and <see cref="Equals(Frequency)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Frequency left, Frequency right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Frequency"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Frequency other, Frequency tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Frequency"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Frequency"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Frequency"/>, this method delegates to
+        ///     <see cref="Equals(Frequency)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Frequency otherQuantity))
+            if (obj is not Frequency otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Frequency"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Frequency other, Frequency tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Frequency"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Frequency other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Frequency.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Frequency), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Frequency"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Frequency)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Frequency otherQuantity)) throw new ArgumentException("Expected type Frequency.", nameof(obj));
+            if (obj is not Frequency otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Frequency>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Frequency"/> with another <see cref="Frequency"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Frequency"/> with another <see cref="Frequency"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -776,151 +779,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Frequency other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(FrequencyUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<FrequencyUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Frequency to another Frequency with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Frequency with the specified unit.</returns>
-        public Frequency ToUnit(FrequencyUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Frequency"/> to another <see cref="Frequency"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Frequency with the specified unit.</returns>
-        public Frequency ToUnit(FrequencyUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Frequency), Unit, typeof(Frequency), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Frequency)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Frequency"/> to another <see cref="Frequency"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Frequency"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(FrequencyUnit unit, [NotNullWhen(true)] out Frequency? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Frequency? convertedOrNull = (Unit, unit) switch
-            {
-                // FrequencyUnit -> BaseUnit
-                (FrequencyUnit.BeatPerMinute, FrequencyUnit.Hertz) => new Frequency(_value / 60, FrequencyUnit.Hertz),
-                (FrequencyUnit.CyclePerHour, FrequencyUnit.Hertz) => new Frequency(_value / 3600, FrequencyUnit.Hertz),
-                (FrequencyUnit.CyclePerMinute, FrequencyUnit.Hertz) => new Frequency(_value / 60, FrequencyUnit.Hertz),
-                (FrequencyUnit.Gigahertz, FrequencyUnit.Hertz) => new Frequency((_value) * 1e9d, FrequencyUnit.Hertz),
-                (FrequencyUnit.Kilohertz, FrequencyUnit.Hertz) => new Frequency((_value) * 1e3d, FrequencyUnit.Hertz),
-                (FrequencyUnit.Megahertz, FrequencyUnit.Hertz) => new Frequency((_value) * 1e6d, FrequencyUnit.Hertz),
-                (FrequencyUnit.Microhertz, FrequencyUnit.Hertz) => new Frequency((_value) * 1e-6d, FrequencyUnit.Hertz),
-                (FrequencyUnit.Millihertz, FrequencyUnit.Hertz) => new Frequency((_value) * 1e-3d, FrequencyUnit.Hertz),
-                (FrequencyUnit.PerSecond, FrequencyUnit.Hertz) => new Frequency(_value, FrequencyUnit.Hertz),
-                (FrequencyUnit.RadianPerSecond, FrequencyUnit.Hertz) => new Frequency(_value / (2 * Math.PI), FrequencyUnit.Hertz),
-                (FrequencyUnit.Terahertz, FrequencyUnit.Hertz) => new Frequency((_value) * 1e12d, FrequencyUnit.Hertz),
-
-                // BaseUnit -> FrequencyUnit
-                (FrequencyUnit.Hertz, FrequencyUnit.BeatPerMinute) => new Frequency(_value * 60, FrequencyUnit.BeatPerMinute),
-                (FrequencyUnit.Hertz, FrequencyUnit.CyclePerHour) => new Frequency(_value * 3600, FrequencyUnit.CyclePerHour),
-                (FrequencyUnit.Hertz, FrequencyUnit.CyclePerMinute) => new Frequency(_value * 60, FrequencyUnit.CyclePerMinute),
-                (FrequencyUnit.Hertz, FrequencyUnit.Gigahertz) => new Frequency((_value) / 1e9d, FrequencyUnit.Gigahertz),
-                (FrequencyUnit.Hertz, FrequencyUnit.Kilohertz) => new Frequency((_value) / 1e3d, FrequencyUnit.Kilohertz),
-                (FrequencyUnit.Hertz, FrequencyUnit.Megahertz) => new Frequency((_value) / 1e6d, FrequencyUnit.Megahertz),
-                (FrequencyUnit.Hertz, FrequencyUnit.Microhertz) => new Frequency((_value) / 1e-6d, FrequencyUnit.Microhertz),
-                (FrequencyUnit.Hertz, FrequencyUnit.Millihertz) => new Frequency((_value) / 1e-3d, FrequencyUnit.Millihertz),
-                (FrequencyUnit.Hertz, FrequencyUnit.PerSecond) => new Frequency(_value, FrequencyUnit.PerSecond),
-                (FrequencyUnit.Hertz, FrequencyUnit.RadianPerSecond) => new Frequency(_value * (2 * Math.PI), FrequencyUnit.RadianPerSecond),
-                (FrequencyUnit.Hertz, FrequencyUnit.Terahertz) => new Frequency((_value) / 1e12d, FrequencyUnit.Terahertz),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not FrequencyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FrequencyUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is FrequencyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FrequencyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity<FrequencyUnit> IQuantity<FrequencyUnit>.ToUnit(FrequencyUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -934,11 +795,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
index 36feac40b9..3882818af1 100644
--- a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Fuel_efficiency
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct FuelEfficiency :
-        IArithmeticQuantity<FuelEfficiency, FuelEfficiencyUnit>,
+        ILinearQuantity<FuelEfficiency, FuelEfficiencyUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<FuelEfficiency, FuelEfficiency, double>,
+        IDivisionOperators<FuelEfficiency, FuelEfficiency, QuantityValue>,
         IComparisonOperators<FuelEfficiency, FuelEfficiency, bool>,
         IParsable<FuelEfficiency>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static FuelEfficiencyInfo CreateDefault(Func<IEnumerable<UnitDefinition<F
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="FuelEfficiency"/> is [L^-2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="FuelEfficiency"/> is L^-2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 0, 0, 0, 0, 0, 0);
 
@@ -121,17 +120,22 @@ public static FuelEfficiencyInfo CreateDefault(Func<IEnumerable<UnitDefinition<F
             public static IEnumerable<UnitDefinition<FuelEfficiencyUnit>> GetDefaultMappings()
             {
                 yield return new (FuelEfficiencyUnit.KilometerPerLiter, "KilometerPerLiter", "KilometersPerLiter", BaseUnits.Undefined);
-                yield return new (FuelEfficiencyUnit.LiterPer100Kilometers, "LiterPer100Kilometers", "LitersPer100Kilometers", BaseUnits.Undefined);
-                yield return new (FuelEfficiencyUnit.MilePerUkGallon, "MilePerUkGallon", "MilesPerUkGallon", BaseUnits.Undefined);
-                yield return new (FuelEfficiencyUnit.MilePerUsGallon, "MilePerUsGallon", "MilesPerUsGallon", BaseUnits.Undefined);
+                yield return new (FuelEfficiencyUnit.LiterPer100Kilometers, "LiterPer100Kilometers", "LitersPer100Kilometers", BaseUnits.Undefined,
+                     new ConversionExpression(coefficient: 100, exponent: -1),
+                     new ConversionExpression(coefficient: 100, exponent: -1)
+                );
+                yield return new (FuelEfficiencyUnit.MilePerUkGallon, "MilePerUkGallon", "MilesPerUkGallon", BaseUnits.Undefined,
+                     new QuantityValue(2273045, 804672)
+                );
+                yield return new (FuelEfficiencyUnit.MilePerUsGallon, "MilePerUsGallon", "MilesPerUsGallon", BaseUnits.Undefined,
+                     new QuantityValue(112903, 48000)
+                );
             }
         }
 
         static FuelEfficiency()
         {
-            Info = FuelEfficiencyInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(FuelEfficiencyInfo.CreateDefault);
         }
 
         /// <summary>
@@ -139,7 +143,7 @@ static FuelEfficiency()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public FuelEfficiency(double value, FuelEfficiencyUnit unit)
+        public FuelEfficiency(QuantityValue value, FuelEfficiencyUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -153,7 +157,7 @@ public FuelEfficiency(double value, FuelEfficiencyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public FuelEfficiency(double value, UnitSystem unitSystem)
+        public FuelEfficiency(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -164,7 +168,8 @@ public FuelEfficiency(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="FuelEfficiency" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<FuelEfficiency, FuelEfficiencyUnit> Info { get; }
@@ -193,10 +198,8 @@ public FuelEfficiency(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public FuelEfficiencyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -230,49 +233,29 @@ public FuelEfficiency(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.KilometerPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.KilometerPerLiter"/>
         /// </summary>
-        public double KilometersPerLiter => As(FuelEfficiencyUnit.KilometerPerLiter);
+        public QuantityValue KilometersPerLiter => this.As(FuelEfficiencyUnit.KilometerPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.LiterPer100Kilometers"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.LiterPer100Kilometers"/>
         /// </summary>
-        public double LitersPer100Kilometers => As(FuelEfficiencyUnit.LiterPer100Kilometers);
+        public QuantityValue LitersPer100Kilometers => this.As(FuelEfficiencyUnit.LiterPer100Kilometers);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.MilePerUkGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.MilePerUkGallon"/>
         /// </summary>
-        public double MilesPerUkGallon => As(FuelEfficiencyUnit.MilePerUkGallon);
+        public QuantityValue MilesPerUkGallon => this.As(FuelEfficiencyUnit.MilePerUkGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.MilePerUsGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="FuelEfficiencyUnit.MilePerUsGallon"/>
         /// </summary>
-        public double MilesPerUsGallon => As(FuelEfficiencyUnit.MilePerUsGallon);
+        public QuantityValue MilesPerUsGallon => this.As(FuelEfficiencyUnit.MilePerUsGallon);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: FuelEfficiencyUnit -> BaseUnit
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiencyUnit.LiterPer100Kilometers, FuelEfficiencyUnit.KilometerPerLiter, quantity => quantity.ToUnit(FuelEfficiencyUnit.KilometerPerLiter));
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiencyUnit.MilePerUkGallon, FuelEfficiencyUnit.KilometerPerLiter, quantity => quantity.ToUnit(FuelEfficiencyUnit.KilometerPerLiter));
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiencyUnit.MilePerUsGallon, FuelEfficiencyUnit.KilometerPerLiter, quantity => quantity.ToUnit(FuelEfficiencyUnit.KilometerPerLiter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiencyUnit.KilometerPerLiter, FuelEfficiencyUnit.KilometerPerLiter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> FuelEfficiencyUnit
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiencyUnit.KilometerPerLiter, FuelEfficiencyUnit.LiterPer100Kilometers, quantity => quantity.ToUnit(FuelEfficiencyUnit.LiterPer100Kilometers));
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiencyUnit.KilometerPerLiter, FuelEfficiencyUnit.MilePerUkGallon, quantity => quantity.ToUnit(FuelEfficiencyUnit.MilePerUkGallon));
-            unitConverter.SetConversionFunction<FuelEfficiency>(FuelEfficiencyUnit.KilometerPerLiter, FuelEfficiencyUnit.MilePerUsGallon, quantity => quantity.ToUnit(FuelEfficiencyUnit.MilePerUsGallon));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -301,7 +284,7 @@ public static string GetAbbreviation(FuelEfficiencyUnit unit, IFormatProvider? p
         /// <summary>
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.KilometerPerLiter"/>.
         /// </summary>
-        public static FuelEfficiency FromKilometersPerLiter(double value)
+        public static FuelEfficiency FromKilometersPerLiter(QuantityValue value)
         {
             return new FuelEfficiency(value, FuelEfficiencyUnit.KilometerPerLiter);
         }
@@ -309,7 +292,7 @@ public static FuelEfficiency FromKilometersPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.LiterPer100Kilometers"/>.
         /// </summary>
-        public static FuelEfficiency FromLitersPer100Kilometers(double value)
+        public static FuelEfficiency FromLitersPer100Kilometers(QuantityValue value)
         {
             return new FuelEfficiency(value, FuelEfficiencyUnit.LiterPer100Kilometers);
         }
@@ -317,7 +300,7 @@ public static FuelEfficiency FromLitersPer100Kilometers(double value)
         /// <summary>
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.MilePerUkGallon"/>.
         /// </summary>
-        public static FuelEfficiency FromMilesPerUkGallon(double value)
+        public static FuelEfficiency FromMilesPerUkGallon(QuantityValue value)
         {
             return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUkGallon);
         }
@@ -325,7 +308,7 @@ public static FuelEfficiency FromMilesPerUkGallon(double value)
         /// <summary>
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.MilePerUsGallon"/>.
         /// </summary>
-        public static FuelEfficiency FromMilesPerUsGallon(double value)
+        public static FuelEfficiency FromMilesPerUsGallon(QuantityValue value)
         {
             return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUsGallon);
         }
@@ -336,7 +319,7 @@ public static FuelEfficiency FromMilesPerUsGallon(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>FuelEfficiency unit value.</returns>
-        public static FuelEfficiency From(double value, FuelEfficiencyUnit fromUnit)
+        public static FuelEfficiency From(QuantityValue value, FuelEfficiencyUnit fromUnit)
         {
             return new FuelEfficiency(value, fromUnit);
         }
@@ -397,10 +380,7 @@ public static FuelEfficiency Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static FuelEfficiency Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<FuelEfficiency, FuelEfficiencyUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<FuelEfficiency, FuelEfficiencyUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -428,11 +408,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out FuelEfficiency r
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out FuelEfficiency result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<FuelEfficiency, FuelEfficiencyUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<FuelEfficiency, FuelEfficiencyUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -453,7 +429,7 @@ public static FuelEfficiencyUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -464,7 +440,7 @@ public static FuelEfficiencyUnit ParseUnit(string str, IFormatProvider? provider
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.FuelEfficiencyUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.FuelEfficiencyUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out FuelEfficiencyUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -479,7 +455,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out FuelEfficien
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out FuelEfficiencyUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -498,35 +474,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="FuelEfficiency"/> from adding two <see cref="FuelEfficiency"/>.</summary>
         public static FuelEfficiency operator +(FuelEfficiency left, FuelEfficiency right)
         {
-            return new FuelEfficiency(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new FuelEfficiency(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="FuelEfficiency"/> from subtracting two <see cref="FuelEfficiency"/>.</summary>
         public static FuelEfficiency operator -(FuelEfficiency left, FuelEfficiency right)
         {
-            return new FuelEfficiency(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new FuelEfficiency(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="FuelEfficiency"/> from multiplying value and <see cref="FuelEfficiency"/>.</summary>
-        public static FuelEfficiency operator *(double left, FuelEfficiency right)
+        public static FuelEfficiency operator *(QuantityValue left, FuelEfficiency right)
         {
             return new FuelEfficiency(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="FuelEfficiency"/> from multiplying value and <see cref="FuelEfficiency"/>.</summary>
-        public static FuelEfficiency operator *(FuelEfficiency left, double right)
+        public static FuelEfficiency operator *(FuelEfficiency left, QuantityValue right)
         {
             return new FuelEfficiency(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="FuelEfficiency"/> from dividing <see cref="FuelEfficiency"/> by value.</summary>
-        public static FuelEfficiency operator /(FuelEfficiency left, double right)
+        public static FuelEfficiency operator /(FuelEfficiency left, QuantityValue right)
         {
             return new FuelEfficiency(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="FuelEfficiency"/> by <see cref="FuelEfficiency"/>.</summary>
-        public static double operator /(FuelEfficiency left, FuelEfficiency right)
+        public static QuantityValue operator /(FuelEfficiency left, FuelEfficiency right)
         {
             return left.KilometersPerLiter / right.KilometersPerLiter;
         }
@@ -538,97 +514,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(FuelEfficiency left, FuelEfficiency right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(FuelEfficiency left, FuelEfficiency right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(FuelEfficiency left, FuelEfficiency right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(FuelEfficiency left, FuelEfficiency right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="FuelEfficiency"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(FuelEfficiency other, FuelEfficiency tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="FuelEfficiency"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(FuelEfficiency)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(FuelEfficiency left, FuelEfficiency right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="FuelEfficiency"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(FuelEfficiency other, FuelEfficiency tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="FuelEfficiency"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(FuelEfficiency,FuelEfficiency)"/>.
+        ///     See that operator (and <see cref="Equals(FuelEfficiency)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(FuelEfficiency left, FuelEfficiency right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="FuelEfficiency"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(FuelEfficiency other, FuelEfficiency tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="FuelEfficiency"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="FuelEfficiency"/>.
+        ///     When <paramref name="obj"/> is a <see cref="FuelEfficiency"/>, this method delegates to
+        ///     <see cref="Equals(FuelEfficiency)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is FuelEfficiency otherQuantity))
+            if (obj is not FuelEfficiency otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="FuelEfficiency"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(FuelEfficiency other, FuelEfficiency tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="FuelEfficiency"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(FuelEfficiency other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current FuelEfficiency.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(FuelEfficiency), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="FuelEfficiency"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(FuelEfficiency)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is FuelEfficiency otherQuantity)) throw new ArgumentException("Expected type FuelEfficiency.", nameof(obj));
+            if (obj is not FuelEfficiency otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<FuelEfficiency>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="FuelEfficiency"/> with another <see cref="FuelEfficiency"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="FuelEfficiency"/> with another <see cref="FuelEfficiency"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -640,137 +630,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(FuelEfficiency other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(FuelEfficiencyUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<FuelEfficiencyUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this FuelEfficiency to another FuelEfficiency with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A FuelEfficiency with the specified unit.</returns>
-        public FuelEfficiency ToUnit(FuelEfficiencyUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="FuelEfficiency"/> to another <see cref="FuelEfficiency"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A FuelEfficiency with the specified unit.</returns>
-        public FuelEfficiency ToUnit(FuelEfficiencyUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(FuelEfficiency), Unit, typeof(FuelEfficiency), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (FuelEfficiency)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="FuelEfficiency"/> to another <see cref="FuelEfficiency"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="FuelEfficiency"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(FuelEfficiencyUnit unit, [NotNullWhen(true)] out FuelEfficiency? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            FuelEfficiency? convertedOrNull = (Unit, unit) switch
-            {
-                // FuelEfficiencyUnit -> BaseUnit
-                (FuelEfficiencyUnit.LiterPer100Kilometers, FuelEfficiencyUnit.KilometerPerLiter) => new FuelEfficiency(100 / _value, FuelEfficiencyUnit.KilometerPerLiter),
-                (FuelEfficiencyUnit.MilePerUkGallon, FuelEfficiencyUnit.KilometerPerLiter) => new FuelEfficiency(_value * 1.609344 / 4.54609, FuelEfficiencyUnit.KilometerPerLiter),
-                (FuelEfficiencyUnit.MilePerUsGallon, FuelEfficiencyUnit.KilometerPerLiter) => new FuelEfficiency(_value * 1.609344 / 3.785411784, FuelEfficiencyUnit.KilometerPerLiter),
-
-                // BaseUnit -> FuelEfficiencyUnit
-                (FuelEfficiencyUnit.KilometerPerLiter, FuelEfficiencyUnit.LiterPer100Kilometers) => new FuelEfficiency(100 / _value, FuelEfficiencyUnit.LiterPer100Kilometers),
-                (FuelEfficiencyUnit.KilometerPerLiter, FuelEfficiencyUnit.MilePerUkGallon) => new FuelEfficiency(_value * 4.54609 / 1.609344, FuelEfficiencyUnit.MilePerUkGallon),
-                (FuelEfficiencyUnit.KilometerPerLiter, FuelEfficiencyUnit.MilePerUsGallon) => new FuelEfficiency(_value * 3.785411784 / 1.609344, FuelEfficiencyUnit.MilePerUsGallon),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not FuelEfficiencyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FuelEfficiencyUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is FuelEfficiencyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FuelEfficiencyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<FuelEfficiencyUnit> IQuantity<FuelEfficiencyUnit>.ToUnit(FuelEfficiencyUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -782,11 +646,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
index f04aa3dc7c..ada0ae8a40 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,12 +33,16 @@ namespace UnitsNet
     ///     Heat flux is the flow of energy per unit of area per unit of time
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct HeatFlux :
-        IArithmeticQuantity<HeatFlux, HeatFluxUnit>,
+        ILinearQuantity<HeatFlux, HeatFluxUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<HeatFlux, HeatFlux, double>,
+        IDivisionOperators<HeatFlux, HeatFlux, QuantityValue>,
+        IDivisionOperators<HeatFlux, TemperatureDelta, HeatTransferCoefficient>,
         IMultiplyOperators<HeatFlux, Area, Power>,
+        IMultiplyOperators<HeatFlux, ThermalInsulance, TemperatureDelta>,
+        IDivisionOperators<HeatFlux, HeatTransferCoefficient, TemperatureDelta>,
         IComparisonOperators<HeatFlux, HeatFlux, bool>,
         IParsable<HeatFlux>,
 #endif
@@ -53,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +105,7 @@ public static HeatFluxInfo CreateDefault(Func<IEnumerable<UnitDefinition<HeatFlu
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="HeatFlux"/> is [T^-3][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="HeatFlux"/> is T^-3M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 1, -3, 0, 0, 0, 0);
 
@@ -118,32 +120,85 @@ public static HeatFluxInfo CreateDefault(Func<IEnumerable<UnitDefinition<HeatFlu
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{HeatFluxUnit}"/> representing the default unit mappings for HeatFlux.</returns>
             public static IEnumerable<UnitDefinition<HeatFluxUnit>> GetDefaultMappings()
             {
-                yield return new (HeatFluxUnit.BtuPerHourSquareFoot, "BtuPerHourSquareFoot", "BtusPerHourSquareFoot", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.BtuPerMinuteSquareFoot, "BtuPerMinuteSquareFoot", "BtusPerMinuteSquareFoot", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.BtuPerSecondSquareFoot, "BtuPerSecondSquareFoot", "BtusPerSecondSquareFoot", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.BtuPerSecondSquareInch, "BtuPerSecondSquareInch", "BtusPerSecondSquareInch", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.CaloriePerSecondSquareCentimeter, "CaloriePerSecondSquareCentimeter", "CaloriesPerSecondSquareCentimeter", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.CentiwattPerSquareMeter, "CentiwattPerSquareMeter", "CentiwattsPerSquareMeter", new BaseUnits(mass: MassUnit.Decagram, time: DurationUnit.Second));
-                yield return new (HeatFluxUnit.DeciwattPerSquareMeter, "DeciwattPerSquareMeter", "DeciwattsPerSquareMeter", new BaseUnits(mass: MassUnit.Hectogram, time: DurationUnit.Second));
-                yield return new (HeatFluxUnit.KilocaloriePerHourSquareMeter, "KilocaloriePerHourSquareMeter", "KilocaloriesPerHourSquareMeter", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, "KilocaloriePerSecondSquareCentimeter", "KilocaloriesPerSecondSquareCentimeter", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.KilowattPerSquareMeter, "KilowattPerSquareMeter", "KilowattsPerSquareMeter", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.MicrowattPerSquareMeter, "MicrowattPerSquareMeter", "MicrowattsPerSquareMeter", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Second));
-                yield return new (HeatFluxUnit.MilliwattPerSquareMeter, "MilliwattPerSquareMeter", "MilliwattsPerSquareMeter", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (HeatFluxUnit.NanowattPerSquareMeter, "NanowattPerSquareMeter", "NanowattsPerSquareMeter", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Second));
-                yield return new (HeatFluxUnit.PoundForcePerFootSecond, "PoundForcePerFootSecond", "PoundsForcePerFootSecond", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.PoundPerSecondCubed, "PoundPerSecondCubed", "PoundsPerSecondCubed", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.WattPerSquareFoot, "WattPerSquareFoot", "WattsPerSquareFoot", BaseUnits.Undefined);
-                yield return new (HeatFluxUnit.WattPerSquareInch, "WattPerSquareInch", "WattsPerSquareInch", BaseUnits.Undefined);
+                yield return new (HeatFluxUnit.BtuPerHourSquareFoot, "BtuPerHourSquareFoot", "BtusPerHourSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(16722547200, 52752792631)
+                );
+                yield return new (HeatFluxUnit.BtuPerMinuteSquareFoot, "BtuPerMinuteSquareFoot", "BtusPerMinuteSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(278709120, 52752792631)
+                );
+                yield return new (HeatFluxUnit.BtuPerSecondSquareFoot, "BtuPerSecondSquareFoot", "BtusPerSecondSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(4645152, 52752792631)
+                );
+                yield return new (HeatFluxUnit.BtuPerSecondSquareInch, "BtuPerSecondSquareInch", "BtusPerSecondSquareInch", BaseUnits.Undefined,
+                     new QuantityValue(32258, 52752792631)
+                );
+                yield return new (HeatFluxUnit.CaloriePerSecondSquareCentimeter, "CaloriePerSecondSquareCentimeter", "CaloriesPerSecondSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 41840)
+                );
+                yield return new (HeatFluxUnit.CentiwattPerSquareMeter, "CentiwattPerSquareMeter", "CentiwattsPerSquareMeter", new BaseUnits(mass: MassUnit.Decagram, time: DurationUnit.Second),
+                     100
+                );
+                yield return new (HeatFluxUnit.CentiwattPerSquareMillimeter, "CentiwattPerSquareMillimeter", "CentiwattsPerSquareMillimeter", new BaseUnits(mass: MassUnit.Decagram, time: DurationUnit.Second),
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (HeatFluxUnit.DeciwattPerSquareMeter, "DeciwattPerSquareMeter", "DeciwattsPerSquareMeter", new BaseUnits(mass: MassUnit.Hectogram, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (HeatFluxUnit.DeciwattPerSquareMillimeter, "DeciwattPerSquareMillimeter", "DeciwattsPerSquareMillimeter", new BaseUnits(mass: MassUnit.Hectogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 100000)
+                );
+                yield return new (HeatFluxUnit.KilocaloriePerHourSquareMeter, "KilocaloriePerHourSquareMeter", "KilocaloriesPerHourSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(450, 523)
+                );
+                yield return new (HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, "KilocaloriePerSecondSquareCentimeter", "KilocaloriesPerSecondSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 41840000)
+                );
+                yield return new (HeatFluxUnit.KilowattPerSquareMeter, "KilowattPerSquareMeter", "KilowattsPerSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (HeatFluxUnit.KilowattPerSquareMillimeter, "KilowattPerSquareMillimeter", "KilowattsPerSquareMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (HeatFluxUnit.MicrowattPerSquareMeter, "MicrowattPerSquareMeter", "MicrowattsPerSquareMeter", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (HeatFluxUnit.MicrowattPerSquareMillimeter, "MicrowattPerSquareMillimeter", "MicrowattsPerSquareMillimeter", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1
+                );
+                yield return new (HeatFluxUnit.MilliwattPerSquareMeter, "MilliwattPerSquareMeter", "MilliwattsPerSquareMeter", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (HeatFluxUnit.MilliwattPerSquareMillimeter, "MilliwattPerSquareMillimeter", "MilliwattsPerSquareMillimeter", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (HeatFluxUnit.NanowattPerSquareMeter, "NanowattPerSquareMeter", "NanowattsPerSquareMeter", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (HeatFluxUnit.NanowattPerSquareMillimeter, "NanowattPerSquareMillimeter", "NanowattsPerSquareMillimeter", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (HeatFluxUnit.PoundForcePerFootSecond, "PoundForcePerFootSecond", "PoundsForcePerFootSecond", BaseUnits.Undefined,
+                     new QuantityValue(609600000000, 8896443230521)
+                );
+                yield return new (HeatFluxUnit.PoundPerSecondCubed, "PoundPerSecondCubed", "PoundsPerSecondCubed", BaseUnits.Undefined,
+                     new QuantityValue(100000000, 45359237)
+                );
+                yield return new (HeatFluxUnit.WattPerSquareFoot, "WattPerSquareFoot", "WattsPerSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(145161, 1562500)
+                );
+                yield return new (HeatFluxUnit.WattPerSquareInch, "WattPerSquareInch", "WattsPerSquareInch", BaseUnits.Undefined,
+                     new QuantityValue(16129, 25000000)
+                );
                 yield return new (HeatFluxUnit.WattPerSquareMeter, "WattPerSquareMeter", "WattsPerSquareMeter", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second));
+                yield return new (HeatFluxUnit.WattPerSquareMillimeter, "WattPerSquareMillimeter", "WattsPerSquareMillimeter", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
             }
         }
 
         static HeatFlux()
         {
-            Info = HeatFluxInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(HeatFluxInfo.CreateDefault);
         }
 
         /// <summary>
@@ -151,7 +206,7 @@ static HeatFlux()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public HeatFlux(double value, HeatFluxUnit unit)
+        public HeatFlux(QuantityValue value, HeatFluxUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -165,7 +220,7 @@ public HeatFlux(double value, HeatFluxUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public HeatFlux(double value, UnitSystem unitSystem)
+        public HeatFlux(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -176,7 +231,8 @@ public HeatFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="HeatFlux" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<HeatFlux, HeatFluxUnit> Info { get; }
@@ -205,10 +261,8 @@ public HeatFlux(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public HeatFluxUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -242,146 +296,133 @@ public HeatFlux(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerHourSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerHourSquareFoot"/>
         /// </summary>
-        public double BtusPerHourSquareFoot => As(HeatFluxUnit.BtuPerHourSquareFoot);
+        public QuantityValue BtusPerHourSquareFoot => this.As(HeatFluxUnit.BtuPerHourSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerMinuteSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerMinuteSquareFoot"/>
         /// </summary>
-        public double BtusPerMinuteSquareFoot => As(HeatFluxUnit.BtuPerMinuteSquareFoot);
+        public QuantityValue BtusPerMinuteSquareFoot => this.As(HeatFluxUnit.BtuPerMinuteSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerSecondSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerSecondSquareFoot"/>
         /// </summary>
-        public double BtusPerSecondSquareFoot => As(HeatFluxUnit.BtuPerSecondSquareFoot);
+        public QuantityValue BtusPerSecondSquareFoot => this.As(HeatFluxUnit.BtuPerSecondSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerSecondSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.BtuPerSecondSquareInch"/>
         /// </summary>
-        public double BtusPerSecondSquareInch => As(HeatFluxUnit.BtuPerSecondSquareInch);
+        public QuantityValue BtusPerSecondSquareInch => this.As(HeatFluxUnit.BtuPerSecondSquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.CaloriePerSecondSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.CaloriePerSecondSquareCentimeter"/>
         /// </summary>
-        public double CaloriesPerSecondSquareCentimeter => As(HeatFluxUnit.CaloriePerSecondSquareCentimeter);
+        public QuantityValue CaloriesPerSecondSquareCentimeter => this.As(HeatFluxUnit.CaloriePerSecondSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.CentiwattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.CentiwattPerSquareMeter"/>
         /// </summary>
-        public double CentiwattsPerSquareMeter => As(HeatFluxUnit.CentiwattPerSquareMeter);
+        public QuantityValue CentiwattsPerSquareMeter => this.As(HeatFluxUnit.CentiwattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.DeciwattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.CentiwattPerSquareMillimeter"/>
         /// </summary>
-        public double DeciwattsPerSquareMeter => As(HeatFluxUnit.DeciwattPerSquareMeter);
+        public QuantityValue CentiwattsPerSquareMillimeter => this.As(HeatFluxUnit.CentiwattPerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.KilocaloriePerHourSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.DeciwattPerSquareMeter"/>
         /// </summary>
-        public double KilocaloriesPerHourSquareMeter => As(HeatFluxUnit.KilocaloriePerHourSquareMeter);
+        public QuantityValue DeciwattsPerSquareMeter => this.As(HeatFluxUnit.DeciwattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.KilocaloriePerSecondSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.DeciwattPerSquareMillimeter"/>
         /// </summary>
-        public double KilocaloriesPerSecondSquareCentimeter => As(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
+        public QuantityValue DeciwattsPerSquareMillimeter => this.As(HeatFluxUnit.DeciwattPerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.KilowattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.KilocaloriePerHourSquareMeter"/>
         /// </summary>
-        public double KilowattsPerSquareMeter => As(HeatFluxUnit.KilowattPerSquareMeter);
+        public QuantityValue KilocaloriesPerHourSquareMeter => this.As(HeatFluxUnit.KilocaloriePerHourSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.MicrowattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.KilocaloriePerSecondSquareCentimeter"/>
         /// </summary>
-        public double MicrowattsPerSquareMeter => As(HeatFluxUnit.MicrowattPerSquareMeter);
+        public QuantityValue KilocaloriesPerSecondSquareCentimeter => this.As(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.MilliwattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.KilowattPerSquareMeter"/>
         /// </summary>
-        public double MilliwattsPerSquareMeter => As(HeatFluxUnit.MilliwattPerSquareMeter);
+        public QuantityValue KilowattsPerSquareMeter => this.As(HeatFluxUnit.KilowattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.NanowattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.KilowattPerSquareMillimeter"/>
         /// </summary>
-        public double NanowattsPerSquareMeter => As(HeatFluxUnit.NanowattPerSquareMeter);
+        public QuantityValue KilowattsPerSquareMillimeter => this.As(HeatFluxUnit.KilowattPerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.PoundForcePerFootSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.MicrowattPerSquareMeter"/>
         /// </summary>
-        public double PoundsForcePerFootSecond => As(HeatFluxUnit.PoundForcePerFootSecond);
+        public QuantityValue MicrowattsPerSquareMeter => this.As(HeatFluxUnit.MicrowattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.PoundPerSecondCubed"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.MicrowattPerSquareMillimeter"/>
         /// </summary>
-        public double PoundsPerSecondCubed => As(HeatFluxUnit.PoundPerSecondCubed);
+        public QuantityValue MicrowattsPerSquareMillimeter => this.As(HeatFluxUnit.MicrowattPerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.WattPerSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.MilliwattPerSquareMeter"/>
         /// </summary>
-        public double WattsPerSquareFoot => As(HeatFluxUnit.WattPerSquareFoot);
+        public QuantityValue MilliwattsPerSquareMeter => this.As(HeatFluxUnit.MilliwattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.WattPerSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.MilliwattPerSquareMillimeter"/>
         /// </summary>
-        public double WattsPerSquareInch => As(HeatFluxUnit.WattPerSquareInch);
+        public QuantityValue MilliwattsPerSquareMillimeter => this.As(HeatFluxUnit.MilliwattPerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatFluxUnit.WattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.NanowattPerSquareMeter"/>
         /// </summary>
-        public double WattsPerSquareMeter => As(HeatFluxUnit.WattPerSquareMeter);
+        public QuantityValue NanowattsPerSquareMeter => this.As(HeatFluxUnit.NanowattPerSquareMeter);
 
-        #endregion
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.NanowattPerSquareMillimeter"/>
+        /// </summary>
+        public QuantityValue NanowattsPerSquareMillimeter => this.As(HeatFluxUnit.NanowattPerSquareMillimeter);
 
-        #region Static Methods
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.PoundForcePerFootSecond"/>
+        /// </summary>
+        public QuantityValue PoundsForcePerFootSecond => this.As(HeatFluxUnit.PoundForcePerFootSecond);
 
         /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: HeatFluxUnit -> BaseUnit
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.BtuPerHourSquareFoot, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.BtuPerMinuteSquareFoot, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.BtuPerSecondSquareFoot, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.BtuPerSecondSquareInch, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.CaloriePerSecondSquareCentimeter, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.CentiwattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.DeciwattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.KilocaloriePerHourSquareMeter, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.KilowattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.MicrowattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.MilliwattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.NanowattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.PoundForcePerFootSecond, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.PoundPerSecondCubed, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareFoot, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareInch, HeatFluxUnit.WattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> HeatFluxUnit
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.BtuPerHourSquareFoot, quantity => quantity.ToUnit(HeatFluxUnit.BtuPerHourSquareFoot));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.BtuPerMinuteSquareFoot, quantity => quantity.ToUnit(HeatFluxUnit.BtuPerMinuteSquareFoot));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.BtuPerSecondSquareFoot, quantity => quantity.ToUnit(HeatFluxUnit.BtuPerSecondSquareFoot));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.BtuPerSecondSquareInch, quantity => quantity.ToUnit(HeatFluxUnit.BtuPerSecondSquareInch));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.CaloriePerSecondSquareCentimeter, quantity => quantity.ToUnit(HeatFluxUnit.CaloriePerSecondSquareCentimeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.CentiwattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.CentiwattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.DeciwattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.DeciwattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.KilocaloriePerHourSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.KilocaloriePerHourSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, quantity => quantity.ToUnit(HeatFluxUnit.KilocaloriePerSecondSquareCentimeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.KilowattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.KilowattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.MicrowattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.MicrowattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.MilliwattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.MilliwattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.NanowattPerSquareMeter, quantity => quantity.ToUnit(HeatFluxUnit.NanowattPerSquareMeter));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.PoundForcePerFootSecond, quantity => quantity.ToUnit(HeatFluxUnit.PoundForcePerFootSecond));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.PoundPerSecondCubed, quantity => quantity.ToUnit(HeatFluxUnit.PoundPerSecondCubed));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.WattPerSquareFoot, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareFoot));
-            unitConverter.SetConversionFunction<HeatFlux>(HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.WattPerSquareInch, quantity => quantity.ToUnit(HeatFluxUnit.WattPerSquareInch));
-        }
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.PoundPerSecondCubed"/>
+        /// </summary>
+        public QuantityValue PoundsPerSecondCubed => this.As(HeatFluxUnit.PoundPerSecondCubed);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.WattPerSquareFoot"/>
+        /// </summary>
+        public QuantityValue WattsPerSquareFoot => this.As(HeatFluxUnit.WattPerSquareFoot);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.WattPerSquareInch"/>
+        /// </summary>
+        public QuantityValue WattsPerSquareInch => this.As(HeatFluxUnit.WattPerSquareInch);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.WattPerSquareMeter"/>
+        /// </summary>
+        public QuantityValue WattsPerSquareMeter => this.As(HeatFluxUnit.WattPerSquareMeter);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatFluxUnit.WattPerSquareMillimeter"/>
+        /// </summary>
+        public QuantityValue WattsPerSquareMillimeter => this.As(HeatFluxUnit.WattPerSquareMillimeter);
+
+        #endregion
+
+        #region Static Methods
 
         /// <summary>
         ///     Get unit abbreviation string.
@@ -411,7 +452,7 @@ public static string GetAbbreviation(HeatFluxUnit unit, IFormatProvider? provide
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerHourSquareFoot"/>.
         /// </summary>
-        public static HeatFlux FromBtusPerHourSquareFoot(double value)
+        public static HeatFlux FromBtusPerHourSquareFoot(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.BtuPerHourSquareFoot);
         }
@@ -419,7 +460,7 @@ public static HeatFlux FromBtusPerHourSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerMinuteSquareFoot"/>.
         /// </summary>
-        public static HeatFlux FromBtusPerMinuteSquareFoot(double value)
+        public static HeatFlux FromBtusPerMinuteSquareFoot(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.BtuPerMinuteSquareFoot);
         }
@@ -427,7 +468,7 @@ public static HeatFlux FromBtusPerMinuteSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerSecondSquareFoot"/>.
         /// </summary>
-        public static HeatFlux FromBtusPerSecondSquareFoot(double value)
+        public static HeatFlux FromBtusPerSecondSquareFoot(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareFoot);
         }
@@ -435,7 +476,7 @@ public static HeatFlux FromBtusPerSecondSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerSecondSquareInch"/>.
         /// </summary>
-        public static HeatFlux FromBtusPerSecondSquareInch(double value)
+        public static HeatFlux FromBtusPerSecondSquareInch(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareInch);
         }
@@ -443,7 +484,7 @@ public static HeatFlux FromBtusPerSecondSquareInch(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.CaloriePerSecondSquareCentimeter"/>.
         /// </summary>
-        public static HeatFlux FromCaloriesPerSecondSquareCentimeter(double value)
+        public static HeatFlux FromCaloriesPerSecondSquareCentimeter(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.CaloriePerSecondSquareCentimeter);
         }
@@ -451,23 +492,39 @@ public static HeatFlux FromCaloriesPerSecondSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.CentiwattPerSquareMeter"/>.
         /// </summary>
-        public static HeatFlux FromCentiwattsPerSquareMeter(double value)
+        public static HeatFlux FromCentiwattsPerSquareMeter(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.CentiwattPerSquareMeter);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.CentiwattPerSquareMillimeter"/>.
+        /// </summary>
+        public static HeatFlux FromCentiwattsPerSquareMillimeter(QuantityValue value)
+        {
+            return new HeatFlux(value, HeatFluxUnit.CentiwattPerSquareMillimeter);
+        }
+
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.DeciwattPerSquareMeter"/>.
         /// </summary>
-        public static HeatFlux FromDeciwattsPerSquareMeter(double value)
+        public static HeatFlux FromDeciwattsPerSquareMeter(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.DeciwattPerSquareMeter);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.DeciwattPerSquareMillimeter"/>.
+        /// </summary>
+        public static HeatFlux FromDeciwattsPerSquareMillimeter(QuantityValue value)
+        {
+            return new HeatFlux(value, HeatFluxUnit.DeciwattPerSquareMillimeter);
+        }
+
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilocaloriePerHourSquareMeter"/>.
         /// </summary>
-        public static HeatFlux FromKilocaloriesPerHourSquareMeter(double value)
+        public static HeatFlux FromKilocaloriesPerHourSquareMeter(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.KilocaloriePerHourSquareMeter);
         }
@@ -475,7 +532,7 @@ public static HeatFlux FromKilocaloriesPerHourSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilocaloriePerSecondSquareCentimeter"/>.
         /// </summary>
-        public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(double value)
+        public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
         }
@@ -483,39 +540,71 @@ public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilowattPerSquareMeter"/>.
         /// </summary>
-        public static HeatFlux FromKilowattsPerSquareMeter(double value)
+        public static HeatFlux FromKilowattsPerSquareMeter(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.KilowattPerSquareMeter);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilowattPerSquareMillimeter"/>.
+        /// </summary>
+        public static HeatFlux FromKilowattsPerSquareMillimeter(QuantityValue value)
+        {
+            return new HeatFlux(value, HeatFluxUnit.KilowattPerSquareMillimeter);
+        }
+
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.MicrowattPerSquareMeter"/>.
         /// </summary>
-        public static HeatFlux FromMicrowattsPerSquareMeter(double value)
+        public static HeatFlux FromMicrowattsPerSquareMeter(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.MicrowattPerSquareMeter);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.MicrowattPerSquareMillimeter"/>.
+        /// </summary>
+        public static HeatFlux FromMicrowattsPerSquareMillimeter(QuantityValue value)
+        {
+            return new HeatFlux(value, HeatFluxUnit.MicrowattPerSquareMillimeter);
+        }
+
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.MilliwattPerSquareMeter"/>.
         /// </summary>
-        public static HeatFlux FromMilliwattsPerSquareMeter(double value)
+        public static HeatFlux FromMilliwattsPerSquareMeter(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.MilliwattPerSquareMeter);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.MilliwattPerSquareMillimeter"/>.
+        /// </summary>
+        public static HeatFlux FromMilliwattsPerSquareMillimeter(QuantityValue value)
+        {
+            return new HeatFlux(value, HeatFluxUnit.MilliwattPerSquareMillimeter);
+        }
+
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.NanowattPerSquareMeter"/>.
         /// </summary>
-        public static HeatFlux FromNanowattsPerSquareMeter(double value)
+        public static HeatFlux FromNanowattsPerSquareMeter(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.NanowattPerSquareMeter);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.NanowattPerSquareMillimeter"/>.
+        /// </summary>
+        public static HeatFlux FromNanowattsPerSquareMillimeter(QuantityValue value)
+        {
+            return new HeatFlux(value, HeatFluxUnit.NanowattPerSquareMillimeter);
+        }
+
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.PoundForcePerFootSecond"/>.
         /// </summary>
-        public static HeatFlux FromPoundsForcePerFootSecond(double value)
+        public static HeatFlux FromPoundsForcePerFootSecond(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.PoundForcePerFootSecond);
         }
@@ -523,7 +612,7 @@ public static HeatFlux FromPoundsForcePerFootSecond(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.PoundPerSecondCubed"/>.
         /// </summary>
-        public static HeatFlux FromPoundsPerSecondCubed(double value)
+        public static HeatFlux FromPoundsPerSecondCubed(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.PoundPerSecondCubed);
         }
@@ -531,7 +620,7 @@ public static HeatFlux FromPoundsPerSecondCubed(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareFoot"/>.
         /// </summary>
-        public static HeatFlux FromWattsPerSquareFoot(double value)
+        public static HeatFlux FromWattsPerSquareFoot(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.WattPerSquareFoot);
         }
@@ -539,7 +628,7 @@ public static HeatFlux FromWattsPerSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareInch"/>.
         /// </summary>
-        public static HeatFlux FromWattsPerSquareInch(double value)
+        public static HeatFlux FromWattsPerSquareInch(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.WattPerSquareInch);
         }
@@ -547,18 +636,26 @@ public static HeatFlux FromWattsPerSquareInch(double value)
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareMeter"/>.
         /// </summary>
-        public static HeatFlux FromWattsPerSquareMeter(double value)
+        public static HeatFlux FromWattsPerSquareMeter(QuantityValue value)
         {
             return new HeatFlux(value, HeatFluxUnit.WattPerSquareMeter);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareMillimeter"/>.
+        /// </summary>
+        public static HeatFlux FromWattsPerSquareMillimeter(QuantityValue value)
+        {
+            return new HeatFlux(value, HeatFluxUnit.WattPerSquareMillimeter);
+        }
+
         /// <summary>
         ///     Dynamically convert from value and unit enum <see cref="HeatFluxUnit" /> to <see cref="HeatFlux" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>HeatFlux unit value.</returns>
-        public static HeatFlux From(double value, HeatFluxUnit fromUnit)
+        public static HeatFlux From(QuantityValue value, HeatFluxUnit fromUnit)
         {
             return new HeatFlux(value, fromUnit);
         }
@@ -619,10 +716,7 @@ public static HeatFlux Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static HeatFlux Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<HeatFlux, HeatFluxUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<HeatFlux, HeatFluxUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -650,11 +744,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out HeatFlux result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out HeatFlux result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<HeatFlux, HeatFluxUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<HeatFlux, HeatFluxUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -675,7 +765,7 @@ public static HeatFluxUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -686,7 +776,7 @@ public static HeatFluxUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.HeatFluxUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.HeatFluxUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out HeatFluxUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -701,7 +791,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out HeatFluxUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out HeatFluxUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -720,35 +810,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="HeatFlux"/> from adding two <see cref="HeatFlux"/>.</summary>
         public static HeatFlux operator +(HeatFlux left, HeatFlux right)
         {
-            return new HeatFlux(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new HeatFlux(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="HeatFlux"/> from subtracting two <see cref="HeatFlux"/>.</summary>
         public static HeatFlux operator -(HeatFlux left, HeatFlux right)
         {
-            return new HeatFlux(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new HeatFlux(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="HeatFlux"/> from multiplying value and <see cref="HeatFlux"/>.</summary>
-        public static HeatFlux operator *(double left, HeatFlux right)
+        public static HeatFlux operator *(QuantityValue left, HeatFlux right)
         {
             return new HeatFlux(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="HeatFlux"/> from multiplying value and <see cref="HeatFlux"/>.</summary>
-        public static HeatFlux operator *(HeatFlux left, double right)
+        public static HeatFlux operator *(HeatFlux left, QuantityValue right)
         {
             return new HeatFlux(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="HeatFlux"/> from dividing <see cref="HeatFlux"/> by value.</summary>
-        public static HeatFlux operator /(HeatFlux left, double right)
+        public static HeatFlux operator /(HeatFlux left, QuantityValue right)
         {
             return new HeatFlux(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="HeatFlux"/> by <see cref="HeatFlux"/>.</summary>
-        public static double operator /(HeatFlux left, HeatFlux right)
+        public static QuantityValue operator /(HeatFlux left, HeatFlux right)
         {
             return left.WattsPerSquareMeter / right.WattsPerSquareMeter;
         }
@@ -757,12 +847,30 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="HeatTransferCoefficient"/> from <see cref="HeatFlux"/> / <see cref="TemperatureDelta"/>.</summary>
+        public static HeatTransferCoefficient operator /(HeatFlux heatFlux, TemperatureDelta temperatureDelta)
+        {
+            return HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(heatFlux.WattsPerSquareMeter / temperatureDelta.Kelvins);
+        }
+
         /// <summary>Get <see cref="Power"/> from <see cref="HeatFlux"/> * <see cref="Area"/>.</summary>
         public static Power operator *(HeatFlux heatFlux, Area area)
         {
             return Power.FromWatts(heatFlux.WattsPerSquareMeter * area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="TemperatureDelta"/> from <see cref="HeatFlux"/> * <see cref="ThermalInsulance"/>.</summary>
+        public static TemperatureDelta operator *(HeatFlux heatFlux, ThermalInsulance thermalInsulance)
+        {
+            return TemperatureDelta.FromKelvins(heatFlux.WattsPerSquareMeter * thermalInsulance.SquareMeterKelvinsPerWatt);
+        }
+
+        /// <summary>Get <see cref="TemperatureDelta"/> from <see cref="HeatFlux"/> / <see cref="HeatTransferCoefficient"/>.</summary>
+        public static TemperatureDelta operator /(HeatFlux heatFlux, HeatTransferCoefficient heatTransferCoefficient)
+        {
+            return TemperatureDelta.FromKelvins(heatFlux.WattsPerSquareMeter / heatTransferCoefficient.WattsPerSquareMeterKelvin);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -770,97 +878,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(HeatFlux left, HeatFlux right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(HeatFlux left, HeatFlux right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(HeatFlux left, HeatFlux right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(HeatFlux left, HeatFlux right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="HeatFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(HeatFlux other, HeatFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="HeatFlux"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(HeatFlux)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(HeatFlux left, HeatFlux right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="HeatFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(HeatFlux other, HeatFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="HeatFlux"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(HeatFlux,HeatFlux)"/>.
+        ///     See that operator (and <see cref="Equals(HeatFlux)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(HeatFlux left, HeatFlux right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="HeatFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(HeatFlux other, HeatFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="HeatFlux"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="HeatFlux"/>.
+        ///     When <paramref name="obj"/> is a <see cref="HeatFlux"/>, this method delegates to
+        ///     <see cref="Equals(HeatFlux)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is HeatFlux otherQuantity))
+            if (obj is not HeatFlux otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="HeatFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(HeatFlux other, HeatFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="HeatFlux"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(HeatFlux other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current HeatFlux.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(HeatFlux), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="HeatFlux"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(HeatFlux)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is HeatFlux otherQuantity)) throw new ArgumentException("Expected type HeatFlux.", nameof(obj));
+            if (obj is not HeatFlux otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<HeatFlux>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="HeatFlux"/> with another <see cref="HeatFlux"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="HeatFlux"/> with another <see cref="HeatFlux"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -872,163 +994,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(HeatFlux other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(HeatFluxUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<HeatFluxUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this HeatFlux to another HeatFlux with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A HeatFlux with the specified unit.</returns>
-        public HeatFlux ToUnit(HeatFluxUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="HeatFlux"/> to another <see cref="HeatFlux"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A HeatFlux with the specified unit.</returns>
-        public HeatFlux ToUnit(HeatFluxUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(HeatFlux), Unit, typeof(HeatFlux), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (HeatFlux)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="HeatFlux"/> to another <see cref="HeatFlux"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="HeatFlux"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(HeatFluxUnit unit, [NotNullWhen(true)] out HeatFlux? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            HeatFlux? convertedOrNull = (Unit, unit) switch
-            {
-                // HeatFluxUnit -> BaseUnit
-                (HeatFluxUnit.BtuPerHourSquareFoot, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux(_value * 1055.05585262 / (0.3048 * 0.3048 * 3600), HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.BtuPerMinuteSquareFoot, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux(_value * 1055.05585262 / (0.3048 * 0.3048 * 60), HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.BtuPerSecondSquareFoot, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux(_value * 1055.05585262 / (0.3048 * 0.3048), HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.BtuPerSecondSquareInch, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux(_value * 1055.05585262 / (2.54e-2 * 2.54e-2), HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.CaloriePerSecondSquareCentimeter, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux(_value * 4.184e4, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.CentiwattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux((_value) * 1e-2d, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.DeciwattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux((_value) * 1e-1d, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.KilocaloriePerHourSquareMeter, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux(_value * 4.184e3 / 3600, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.KilocaloriePerSecondSquareCentimeter, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux((_value * 4.184e4) * 1e3d, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.KilowattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux((_value) * 1e3d, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.MicrowattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux((_value) * 1e-6d, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.MilliwattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux((_value) * 1e-3d, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.NanowattPerSquareMeter, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux((_value) * 1e-9d, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.PoundForcePerFootSecond, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux(_value * 1.3558179483314004 / 9.290304e-2, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.PoundPerSecondCubed, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux(_value * 4.5359237e-1, HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.WattPerSquareFoot, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux(_value / (0.3048 * 0.3048), HeatFluxUnit.WattPerSquareMeter),
-                (HeatFluxUnit.WattPerSquareInch, HeatFluxUnit.WattPerSquareMeter) => new HeatFlux(_value / (2.54e-2 * 2.54e-2), HeatFluxUnit.WattPerSquareMeter),
-
-                // BaseUnit -> HeatFluxUnit
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.BtuPerHourSquareFoot) => new HeatFlux(_value * (0.3048 * 0.3048 * 3600) / 1055.05585262, HeatFluxUnit.BtuPerHourSquareFoot),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.BtuPerMinuteSquareFoot) => new HeatFlux(_value * (0.3048 * 0.3048 * 60) / 1055.05585262, HeatFluxUnit.BtuPerMinuteSquareFoot),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.BtuPerSecondSquareFoot) => new HeatFlux(_value * (0.3048 * 0.3048) / 1055.05585262, HeatFluxUnit.BtuPerSecondSquareFoot),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.BtuPerSecondSquareInch) => new HeatFlux(_value * (2.54e-2 * 2.54e-2) / 1055.05585262, HeatFluxUnit.BtuPerSecondSquareInch),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.CaloriePerSecondSquareCentimeter) => new HeatFlux(_value / 4.184e4, HeatFluxUnit.CaloriePerSecondSquareCentimeter),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.CentiwattPerSquareMeter) => new HeatFlux((_value) / 1e-2d, HeatFluxUnit.CentiwattPerSquareMeter),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.DeciwattPerSquareMeter) => new HeatFlux((_value) / 1e-1d, HeatFluxUnit.DeciwattPerSquareMeter),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.KilocaloriePerHourSquareMeter) => new HeatFlux(_value * 3600 / 4.184e3, HeatFluxUnit.KilocaloriePerHourSquareMeter),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter) => new HeatFlux((_value / 4.184e4) / 1e3d, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.KilowattPerSquareMeter) => new HeatFlux((_value) / 1e3d, HeatFluxUnit.KilowattPerSquareMeter),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.MicrowattPerSquareMeter) => new HeatFlux((_value) / 1e-6d, HeatFluxUnit.MicrowattPerSquareMeter),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.MilliwattPerSquareMeter) => new HeatFlux((_value) / 1e-3d, HeatFluxUnit.MilliwattPerSquareMeter),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.NanowattPerSquareMeter) => new HeatFlux((_value) / 1e-9d, HeatFluxUnit.NanowattPerSquareMeter),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.PoundForcePerFootSecond) => new HeatFlux(_value * 9.290304e-2 / 1.3558179483314004, HeatFluxUnit.PoundForcePerFootSecond),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.PoundPerSecondCubed) => new HeatFlux(_value / 4.5359237e-1, HeatFluxUnit.PoundPerSecondCubed),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.WattPerSquareFoot) => new HeatFlux(_value * (0.3048 * 0.3048), HeatFluxUnit.WattPerSquareFoot),
-                (HeatFluxUnit.WattPerSquareMeter, HeatFluxUnit.WattPerSquareInch) => new HeatFlux(_value * (2.54e-2 * 2.54e-2), HeatFluxUnit.WattPerSquareInch),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not HeatFluxUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatFluxUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is HeatFluxUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatFluxUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<HeatFluxUnit> IQuantity<HeatFluxUnit>.ToUnit(HeatFluxUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1042,11 +1010,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
index ded5a527e7..51ab61baba 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     The heat transfer coefficient or film coefficient, or film effectiveness, in thermodynamics and in mechanics is the proportionality constant between the heat flux and the thermodynamic driving force for the flow of heat (i.e., the temperature difference, ΔT)
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct HeatTransferCoefficient :
-        IArithmeticQuantity<HeatTransferCoefficient, HeatTransferCoefficientUnit>,
+        ILinearQuantity<HeatTransferCoefficient, HeatTransferCoefficientUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<HeatTransferCoefficient, HeatTransferCoefficient, double>,
+        IDivisionOperators<HeatTransferCoefficient, HeatTransferCoefficient, QuantityValue>,
+        IMultiplyOperators<HeatTransferCoefficient, TemperatureDelta, HeatFlux>,
         IComparisonOperators<HeatTransferCoefficient, HeatTransferCoefficient, bool>,
         IParsable<HeatTransferCoefficient>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static HeatTransferCoefficientInfo CreateDefault(Func<IEnumerable<UnitDef
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="HeatTransferCoefficient"/> is [T^-3][M][Θ^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="HeatTransferCoefficient"/> is T^-3MΘ^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 1, -3, 0, -1, 0, 0);
 
@@ -117,19 +117,28 @@ public static HeatTransferCoefficientInfo CreateDefault(Func<IEnumerable<UnitDef
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{HeatTransferCoefficientUnit}"/> representing the default unit mappings for HeatTransferCoefficient.</returns>
             public static IEnumerable<UnitDefinition<HeatTransferCoefficientUnit>> GetDefaultMappings()
             {
-                yield return new (HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, "BtuPerHourSquareFootDegreeFahrenheit", "BtusPerHourSquareFootDegreeFahrenheit", BaseUnits.Undefined);
-                yield return new (HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, "CaloriePerHourSquareMeterDegreeCelsius", "CaloriesPerHourSquareMeterDegreeCelsius", BaseUnits.Undefined);
-                yield return new (HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius, "KilocaloriePerHourSquareMeterDegreeCelsius", "KilocaloriesPerHourSquareMeterDegreeCelsius", BaseUnits.Undefined);
-                yield return new (HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, "WattPerSquareMeterCelsius", "WattsPerSquareMeterCelsius", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius));
+                yield return new (HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, "BtuPerHourSquareFootDegreeFahrenheit", "BtusPerHourSquareFootDegreeFahrenheit", BaseUnits.Undefined,
+                     new QuantityValue(9290304000, 52752792631)
+                );
+                yield return new (HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit, "BtuPerSecondSquareInchDegreeFahrenheit", "BtusPerSecondSquareInchDegreeFahrenheit", BaseUnits.Undefined,
+                     new QuantityValue(161290, 474775133679)
+                );
+                yield return new (HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, "CaloriePerHourSquareMeterDegreeCelsius", "CaloriesPerHourSquareMeterDegreeCelsius", BaseUnits.Undefined,
+                     new QuantityValue(450000, 523)
+                );
+                yield return new (HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius, "KilocaloriePerHourSquareMeterDegreeCelsius", "KilocaloriesPerHourSquareMeterDegreeCelsius", BaseUnits.Undefined,
+                     new QuantityValue(450, 523)
+                );
+                yield return new (HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, "WattPerSquareMeterCelsius", "WattsPerSquareMeterCelsius", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius),
+                     1
+                );
                 yield return new (HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, "WattPerSquareMeterKelvin", "WattsPerSquareMeterKelvin", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
             }
         }
 
         static HeatTransferCoefficient()
         {
-            Info = HeatTransferCoefficientInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(HeatTransferCoefficientInfo.CreateDefault);
         }
 
         /// <summary>
@@ -137,7 +146,7 @@ static HeatTransferCoefficient()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public HeatTransferCoefficient(double value, HeatTransferCoefficientUnit unit)
+        public HeatTransferCoefficient(QuantityValue value, HeatTransferCoefficientUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -151,7 +160,7 @@ public HeatTransferCoefficient(double value, HeatTransferCoefficientUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public HeatTransferCoefficient(double value, UnitSystem unitSystem)
+        public HeatTransferCoefficient(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -162,7 +171,8 @@ public HeatTransferCoefficient(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="HeatTransferCoefficient" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<HeatTransferCoefficient, HeatTransferCoefficientUnit> Info { get; }
@@ -191,10 +201,8 @@ public HeatTransferCoefficient(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public HeatTransferCoefficientUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -228,55 +236,38 @@ public HeatTransferCoefficient(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit"/>
         /// </summary>
-        public double BtusPerHourSquareFootDegreeFahrenheit => As(HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit);
+        public QuantityValue BtusPerHourSquareFootDegreeFahrenheit => this.As(HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit"/>
         /// </summary>
-        public double CaloriesPerHourSquareMeterDegreeCelsius => As(HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius);
+        public QuantityValue BtusPerSecondSquareInchDegreeFahrenheit => this.As(HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius"/>
         /// </summary>
-        public double KilocaloriesPerHourSquareMeterDegreeCelsius => As(HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius);
+        public QuantityValue CaloriesPerHourSquareMeterDegreeCelsius => this.As(HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius"/>
         /// </summary>
-        public double WattsPerSquareMeterCelsius => As(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
+        public QuantityValue KilocaloriesPerHourSquareMeterDegreeCelsius => this.As(HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterCelsius"/>
         /// </summary>
-        public double WattsPerSquareMeterKelvin => As(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
-
-        #endregion
-
-        #region Static Methods
+        public QuantityValue WattsPerSquareMeterCelsius => this.As(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
 
         /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterKelvin"/>
         /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: HeatTransferCoefficientUnit -> BaseUnit
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, quantity => quantity.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, quantity => quantity.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, quantity => quantity.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, quantity => quantity.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin));
+        public QuantityValue WattsPerSquareMeterKelvin => this.As(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
 
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, quantity => quantity);
+        #endregion
 
-            // Register in unit converter: BaseUnit -> HeatTransferCoefficientUnit
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, quantity => quantity.ToUnit(HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit));
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, quantity => quantity.ToUnit(HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius));
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius, quantity => quantity.ToUnit(HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius));
-            unitConverter.SetConversionFunction<HeatTransferCoefficient>(HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, quantity => quantity.ToUnit(HeatTransferCoefficientUnit.WattPerSquareMeterCelsius));
-        }
+        #region Static Methods
 
         /// <summary>
         ///     Get unit abbreviation string.
@@ -306,15 +297,23 @@ public static string GetAbbreviation(HeatTransferCoefficientUnit unit, IFormatPr
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit"/>.
         /// </summary>
-        public static HeatTransferCoefficient FromBtusPerHourSquareFootDegreeFahrenheit(double value)
+        public static HeatTransferCoefficient FromBtusPerHourSquareFootDegreeFahrenheit(QuantityValue value)
         {
             return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit"/>.
+        /// </summary>
+        public static HeatTransferCoefficient FromBtusPerSecondSquareInchDegreeFahrenheit(QuantityValue value)
+        {
+            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerSecondSquareInchDegreeFahrenheit);
+        }
+
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius"/>.
         /// </summary>
-        public static HeatTransferCoefficient FromCaloriesPerHourSquareMeterDegreeCelsius(double value)
+        public static HeatTransferCoefficient FromCaloriesPerHourSquareMeterDegreeCelsius(QuantityValue value)
         {
             return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius);
         }
@@ -322,7 +321,7 @@ public static HeatTransferCoefficient FromCaloriesPerHourSquareMeterDegreeCelsiu
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius"/>.
         /// </summary>
-        public static HeatTransferCoefficient FromKilocaloriesPerHourSquareMeterDegreeCelsius(double value)
+        public static HeatTransferCoefficient FromKilocaloriesPerHourSquareMeterDegreeCelsius(QuantityValue value)
         {
             return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius);
         }
@@ -330,7 +329,7 @@ public static HeatTransferCoefficient FromKilocaloriesPerHourSquareMeterDegreeCe
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterCelsius"/>.
         /// </summary>
-        public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(double value)
+        public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(QuantityValue value)
         {
             return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
         }
@@ -338,7 +337,7 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(double valu
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterKelvin"/>.
         /// </summary>
-        public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(double value)
+        public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(QuantityValue value)
         {
             return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
         }
@@ -349,7 +348,7 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(double value
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>HeatTransferCoefficient unit value.</returns>
-        public static HeatTransferCoefficient From(double value, HeatTransferCoefficientUnit fromUnit)
+        public static HeatTransferCoefficient From(QuantityValue value, HeatTransferCoefficientUnit fromUnit)
         {
             return new HeatTransferCoefficient(value, fromUnit);
         }
@@ -410,10 +409,7 @@ public static HeatTransferCoefficient Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static HeatTransferCoefficient Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<HeatTransferCoefficient, HeatTransferCoefficientUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<HeatTransferCoefficient, HeatTransferCoefficientUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -441,11 +437,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out HeatTransferCoef
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out HeatTransferCoefficient result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<HeatTransferCoefficient, HeatTransferCoefficientUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<HeatTransferCoefficient, HeatTransferCoefficientUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -466,7 +458,7 @@ public static HeatTransferCoefficientUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -477,7 +469,7 @@ public static HeatTransferCoefficientUnit ParseUnit(string str, IFormatProvider?
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.HeatTransferCoefficientUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.HeatTransferCoefficientUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out HeatTransferCoefficientUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -492,7 +484,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out HeatTransfer
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out HeatTransferCoefficientUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -511,137 +503,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="HeatTransferCoefficient"/> from adding two <see cref="HeatTransferCoefficient"/>.</summary>
         public static HeatTransferCoefficient operator +(HeatTransferCoefficient left, HeatTransferCoefficient right)
         {
-            return new HeatTransferCoefficient(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new HeatTransferCoefficient(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="HeatTransferCoefficient"/> from subtracting two <see cref="HeatTransferCoefficient"/>.</summary>
         public static HeatTransferCoefficient operator -(HeatTransferCoefficient left, HeatTransferCoefficient right)
         {
-            return new HeatTransferCoefficient(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new HeatTransferCoefficient(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="HeatTransferCoefficient"/> from multiplying value and <see cref="HeatTransferCoefficient"/>.</summary>
-        public static HeatTransferCoefficient operator *(double left, HeatTransferCoefficient right)
+        public static HeatTransferCoefficient operator *(QuantityValue left, HeatTransferCoefficient right)
         {
             return new HeatTransferCoefficient(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="HeatTransferCoefficient"/> from multiplying value and <see cref="HeatTransferCoefficient"/>.</summary>
-        public static HeatTransferCoefficient operator *(HeatTransferCoefficient left, double right)
+        public static HeatTransferCoefficient operator *(HeatTransferCoefficient left, QuantityValue right)
         {
             return new HeatTransferCoefficient(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="HeatTransferCoefficient"/> from dividing <see cref="HeatTransferCoefficient"/> by value.</summary>
-        public static HeatTransferCoefficient operator /(HeatTransferCoefficient left, double right)
+        public static HeatTransferCoefficient operator /(HeatTransferCoefficient left, QuantityValue right)
         {
             return new HeatTransferCoefficient(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="HeatTransferCoefficient"/> by <see cref="HeatTransferCoefficient"/>.</summary>
-        public static double operator /(HeatTransferCoefficient left, HeatTransferCoefficient right)
+        public static QuantityValue operator /(HeatTransferCoefficient left, HeatTransferCoefficient right)
         {
             return left.WattsPerSquareMeterKelvin / right.WattsPerSquareMeterKelvin;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="HeatFlux"/> from <see cref="HeatTransferCoefficient"/> * <see cref="TemperatureDelta"/>.</summary>
+        public static HeatFlux operator *(HeatTransferCoefficient heatTransferCoefficient, TemperatureDelta temperatureDelta)
+        {
+            return HeatFlux.FromWattsPerSquareMeter(heatTransferCoefficient.WattsPerSquareMeterKelvin * temperatureDelta.Kelvins);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(HeatTransferCoefficient left, HeatTransferCoefficient right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(HeatTransferCoefficient left, HeatTransferCoefficient right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(HeatTransferCoefficient left, HeatTransferCoefficient right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(HeatTransferCoefficient left, HeatTransferCoefficient right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="HeatTransferCoefficient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(HeatTransferCoefficient other, HeatTransferCoefficient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="HeatTransferCoefficient"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(HeatTransferCoefficient)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(HeatTransferCoefficient left, HeatTransferCoefficient right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="HeatTransferCoefficient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(HeatTransferCoefficient other, HeatTransferCoefficient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="HeatTransferCoefficient"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(HeatTransferCoefficient,HeatTransferCoefficient)"/>.
+        ///     See that operator (and <see cref="Equals(HeatTransferCoefficient)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(HeatTransferCoefficient left, HeatTransferCoefficient right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="HeatTransferCoefficient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(HeatTransferCoefficient other, HeatTransferCoefficient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="HeatTransferCoefficient"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="HeatTransferCoefficient"/>.
+        ///     When <paramref name="obj"/> is a <see cref="HeatTransferCoefficient"/>, this method delegates to
+        ///     <see cref="Equals(HeatTransferCoefficient)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is HeatTransferCoefficient otherQuantity))
+            if (obj is not HeatTransferCoefficient otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="HeatTransferCoefficient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(HeatTransferCoefficient other, HeatTransferCoefficient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="HeatTransferCoefficient"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(HeatTransferCoefficient other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current HeatTransferCoefficient.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(HeatTransferCoefficient), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="HeatTransferCoefficient"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(HeatTransferCoefficient)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is HeatTransferCoefficient otherQuantity)) throw new ArgumentException("Expected type HeatTransferCoefficient.", nameof(obj));
+            if (obj is not HeatTransferCoefficient otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<HeatTransferCoefficient>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="HeatTransferCoefficient"/> with another <see cref="HeatTransferCoefficient"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="HeatTransferCoefficient"/> with another <see cref="HeatTransferCoefficient"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -653,137 +669,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(HeatTransferCoefficient other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(HeatTransferCoefficientUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<HeatTransferCoefficientUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this HeatTransferCoefficient to another HeatTransferCoefficient with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A HeatTransferCoefficient with the specified unit.</returns>
-        public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="HeatTransferCoefficient"/> to another <see cref="HeatTransferCoefficient"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A HeatTransferCoefficient with the specified unit.</returns>
-        public HeatTransferCoefficient ToUnit(HeatTransferCoefficientUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(HeatTransferCoefficient), Unit, typeof(HeatTransferCoefficient), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (HeatTransferCoefficient)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="HeatTransferCoefficient"/> to another <see cref="HeatTransferCoefficient"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="HeatTransferCoefficient"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(HeatTransferCoefficientUnit unit, [NotNullWhen(true)] out HeatTransferCoefficient? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            HeatTransferCoefficient? convertedOrNull = (Unit, unit) switch
-            {
-                // HeatTransferCoefficientUnit -> BaseUnit
-                (HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin) => new HeatTransferCoefficient(_value * ((1055.05585262 / (0.3048 * 0.3048 * 3600)) * 1.8), HeatTransferCoefficientUnit.WattPerSquareMeterKelvin),
-                (HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin) => new HeatTransferCoefficient((_value * 4.184) / 3600, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin),
-                (HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin) => new HeatTransferCoefficient(((_value * 4.184) / 3600) * 1e3d, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin),
-                (HeatTransferCoefficientUnit.WattPerSquareMeterCelsius, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin) => new HeatTransferCoefficient(_value, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin),
-
-                // BaseUnit -> HeatTransferCoefficientUnit
-                (HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit) => new HeatTransferCoefficient(_value / ((1055.05585262 / (0.3048 * 0.3048 * 3600)) * 1.8), HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit),
-                (HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius) => new HeatTransferCoefficient((_value / 4.184) * 3600, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius),
-                (HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius) => new HeatTransferCoefficient(((_value / 4.184) * 3600) / 1e3d, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius),
-                (HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius) => new HeatTransferCoefficient(_value, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not HeatTransferCoefficientUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatTransferCoefficientUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is HeatTransferCoefficientUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatTransferCoefficientUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<HeatTransferCoefficientUnit> IQuantity<HeatTransferCoefficientUnit>.ToUnit(HeatTransferCoefficientUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -797,11 +685,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
index 097895cf58..ab83faa289 100644
--- a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Illuminance
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Illuminance :
-        IArithmeticQuantity<Illuminance, IlluminanceUnit>,
+        ILinearQuantity<Illuminance, IlluminanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Illuminance, Illuminance, double>,
+        IDivisionOperators<Illuminance, Illuminance, QuantityValue>,
         IMultiplyOperators<Illuminance, Area, LuminousFlux>,
         IComparisonOperators<Illuminance, Illuminance, bool>,
         IParsable<Illuminance>,
@@ -56,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -106,7 +105,7 @@ public static IlluminanceInfo CreateDefault(Func<IEnumerable<UnitDefinition<Illu
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Illuminance"/> is [L^-2][J].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Illuminance"/> is L^-2J.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 0, 0, 0, 0, 0, 1);
 
@@ -121,18 +120,22 @@ public static IlluminanceInfo CreateDefault(Func<IEnumerable<UnitDefinition<Illu
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{IlluminanceUnit}"/> representing the default unit mappings for Illuminance.</returns>
             public static IEnumerable<UnitDefinition<IlluminanceUnit>> GetDefaultMappings()
             {
-                yield return new (IlluminanceUnit.Kilolux, "Kilolux", "Kilolux", BaseUnits.Undefined);
+                yield return new (IlluminanceUnit.Kilolux, "Kilolux", "Kilolux", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
                 yield return new (IlluminanceUnit.Lux, "Lux", "Lux", new BaseUnits(length: LengthUnit.Meter, luminousIntensity: LuminousIntensityUnit.Candela));
-                yield return new (IlluminanceUnit.Megalux, "Megalux", "Megalux", new BaseUnits(length: LengthUnit.Millimeter, luminousIntensity: LuminousIntensityUnit.Candela));
-                yield return new (IlluminanceUnit.Millilux, "Millilux", "Millilux", BaseUnits.Undefined);
+                yield return new (IlluminanceUnit.Megalux, "Megalux", "Megalux", new BaseUnits(length: LengthUnit.Millimeter, luminousIntensity: LuminousIntensityUnit.Candela),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (IlluminanceUnit.Millilux, "Millilux", "Millilux", BaseUnits.Undefined,
+                     1000
+                );
             }
         }
 
         static Illuminance()
         {
-            Info = IlluminanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(IlluminanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -140,7 +143,7 @@ static Illuminance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Illuminance(double value, IlluminanceUnit unit)
+        public Illuminance(QuantityValue value, IlluminanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -154,7 +157,7 @@ public Illuminance(double value, IlluminanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Illuminance(double value, UnitSystem unitSystem)
+        public Illuminance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -165,7 +168,8 @@ public Illuminance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Illuminance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Illuminance, IlluminanceUnit> Info { get; }
@@ -194,10 +198,8 @@ public Illuminance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public IlluminanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -231,49 +233,29 @@ public Illuminance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IlluminanceUnit.Kilolux"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IlluminanceUnit.Kilolux"/>
         /// </summary>
-        public double Kilolux => As(IlluminanceUnit.Kilolux);
+        public QuantityValue Kilolux => this.As(IlluminanceUnit.Kilolux);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IlluminanceUnit.Lux"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IlluminanceUnit.Lux"/>
         /// </summary>
-        public double Lux => As(IlluminanceUnit.Lux);
+        public QuantityValue Lux => this.As(IlluminanceUnit.Lux);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IlluminanceUnit.Megalux"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IlluminanceUnit.Megalux"/>
         /// </summary>
-        public double Megalux => As(IlluminanceUnit.Megalux);
+        public QuantityValue Megalux => this.As(IlluminanceUnit.Megalux);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IlluminanceUnit.Millilux"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IlluminanceUnit.Millilux"/>
         /// </summary>
-        public double Millilux => As(IlluminanceUnit.Millilux);
+        public QuantityValue Millilux => this.As(IlluminanceUnit.Millilux);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: IlluminanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Illuminance>(IlluminanceUnit.Kilolux, IlluminanceUnit.Lux, quantity => quantity.ToUnit(IlluminanceUnit.Lux));
-            unitConverter.SetConversionFunction<Illuminance>(IlluminanceUnit.Megalux, IlluminanceUnit.Lux, quantity => quantity.ToUnit(IlluminanceUnit.Lux));
-            unitConverter.SetConversionFunction<Illuminance>(IlluminanceUnit.Millilux, IlluminanceUnit.Lux, quantity => quantity.ToUnit(IlluminanceUnit.Lux));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Illuminance>(IlluminanceUnit.Lux, IlluminanceUnit.Lux, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> IlluminanceUnit
-            unitConverter.SetConversionFunction<Illuminance>(IlluminanceUnit.Lux, IlluminanceUnit.Kilolux, quantity => quantity.ToUnit(IlluminanceUnit.Kilolux));
-            unitConverter.SetConversionFunction<Illuminance>(IlluminanceUnit.Lux, IlluminanceUnit.Megalux, quantity => quantity.ToUnit(IlluminanceUnit.Megalux));
-            unitConverter.SetConversionFunction<Illuminance>(IlluminanceUnit.Lux, IlluminanceUnit.Millilux, quantity => quantity.ToUnit(IlluminanceUnit.Millilux));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -302,7 +284,7 @@ public static string GetAbbreviation(IlluminanceUnit unit, IFormatProvider? prov
         /// <summary>
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Kilolux"/>.
         /// </summary>
-        public static Illuminance FromKilolux(double value)
+        public static Illuminance FromKilolux(QuantityValue value)
         {
             return new Illuminance(value, IlluminanceUnit.Kilolux);
         }
@@ -310,7 +292,7 @@ public static Illuminance FromKilolux(double value)
         /// <summary>
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Lux"/>.
         /// </summary>
-        public static Illuminance FromLux(double value)
+        public static Illuminance FromLux(QuantityValue value)
         {
             return new Illuminance(value, IlluminanceUnit.Lux);
         }
@@ -318,7 +300,7 @@ public static Illuminance FromLux(double value)
         /// <summary>
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Megalux"/>.
         /// </summary>
-        public static Illuminance FromMegalux(double value)
+        public static Illuminance FromMegalux(QuantityValue value)
         {
             return new Illuminance(value, IlluminanceUnit.Megalux);
         }
@@ -326,7 +308,7 @@ public static Illuminance FromMegalux(double value)
         /// <summary>
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Millilux"/>.
         /// </summary>
-        public static Illuminance FromMillilux(double value)
+        public static Illuminance FromMillilux(QuantityValue value)
         {
             return new Illuminance(value, IlluminanceUnit.Millilux);
         }
@@ -337,7 +319,7 @@ public static Illuminance FromMillilux(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Illuminance unit value.</returns>
-        public static Illuminance From(double value, IlluminanceUnit fromUnit)
+        public static Illuminance From(QuantityValue value, IlluminanceUnit fromUnit)
         {
             return new Illuminance(value, fromUnit);
         }
@@ -398,10 +380,7 @@ public static Illuminance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Illuminance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Illuminance, IlluminanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Illuminance, IlluminanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -429,11 +408,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Illuminance resu
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Illuminance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Illuminance, IlluminanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Illuminance, IlluminanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -454,7 +429,7 @@ public static IlluminanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -465,7 +440,7 @@ public static IlluminanceUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.IlluminanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.IlluminanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out IlluminanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -480,7 +455,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out IlluminanceU
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out IlluminanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -499,35 +474,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Illuminance"/> from adding two <see cref="Illuminance"/>.</summary>
         public static Illuminance operator +(Illuminance left, Illuminance right)
         {
-            return new Illuminance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Illuminance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Illuminance"/> from subtracting two <see cref="Illuminance"/>.</summary>
         public static Illuminance operator -(Illuminance left, Illuminance right)
         {
-            return new Illuminance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Illuminance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Illuminance"/> from multiplying value and <see cref="Illuminance"/>.</summary>
-        public static Illuminance operator *(double left, Illuminance right)
+        public static Illuminance operator *(QuantityValue left, Illuminance right)
         {
             return new Illuminance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Illuminance"/> from multiplying value and <see cref="Illuminance"/>.</summary>
-        public static Illuminance operator *(Illuminance left, double right)
+        public static Illuminance operator *(Illuminance left, QuantityValue right)
         {
             return new Illuminance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Illuminance"/> from dividing <see cref="Illuminance"/> by value.</summary>
-        public static Illuminance operator /(Illuminance left, double right)
+        public static Illuminance operator /(Illuminance left, QuantityValue right)
         {
             return new Illuminance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Illuminance"/> by <see cref="Illuminance"/>.</summary>
-        public static double operator /(Illuminance left, Illuminance right)
+        public static QuantityValue operator /(Illuminance left, Illuminance right)
         {
             return left.Lux / right.Lux;
         }
@@ -549,97 +524,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Illuminance left, Illuminance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Illuminance left, Illuminance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Illuminance left, Illuminance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Illuminance left, Illuminance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Illuminance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Illuminance other, Illuminance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Illuminance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Illuminance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Illuminance left, Illuminance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Illuminance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Illuminance other, Illuminance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Illuminance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Illuminance,Illuminance)"/>.
+        ///     See that operator (and <see cref="Equals(Illuminance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Illuminance left, Illuminance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Illuminance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Illuminance other, Illuminance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Illuminance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Illuminance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Illuminance"/>, this method delegates to
+        ///     <see cref="Equals(Illuminance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Illuminance otherQuantity))
+            if (obj is not Illuminance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Illuminance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Illuminance other, Illuminance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Illuminance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Illuminance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Illuminance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Illuminance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Illuminance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Illuminance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Illuminance otherQuantity)) throw new ArgumentException("Expected type Illuminance.", nameof(obj));
+            if (obj is not Illuminance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Illuminance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Illuminance"/> with another <see cref="Illuminance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Illuminance"/> with another <see cref="Illuminance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -651,137 +640,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Illuminance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(IlluminanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<IlluminanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Illuminance to another Illuminance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Illuminance with the specified unit.</returns>
-        public Illuminance ToUnit(IlluminanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Illuminance"/> to another <see cref="Illuminance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Illuminance with the specified unit.</returns>
-        public Illuminance ToUnit(IlluminanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Illuminance), Unit, typeof(Illuminance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Illuminance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Illuminance"/> to another <see cref="Illuminance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Illuminance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(IlluminanceUnit unit, [NotNullWhen(true)] out Illuminance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Illuminance? convertedOrNull = (Unit, unit) switch
-            {
-                // IlluminanceUnit -> BaseUnit
-                (IlluminanceUnit.Kilolux, IlluminanceUnit.Lux) => new Illuminance((_value) * 1e3d, IlluminanceUnit.Lux),
-                (IlluminanceUnit.Megalux, IlluminanceUnit.Lux) => new Illuminance((_value) * 1e6d, IlluminanceUnit.Lux),
-                (IlluminanceUnit.Millilux, IlluminanceUnit.Lux) => new Illuminance((_value) * 1e-3d, IlluminanceUnit.Lux),
-
-                // BaseUnit -> IlluminanceUnit
-                (IlluminanceUnit.Lux, IlluminanceUnit.Kilolux) => new Illuminance((_value) / 1e3d, IlluminanceUnit.Kilolux),
-                (IlluminanceUnit.Lux, IlluminanceUnit.Megalux) => new Illuminance((_value) / 1e6d, IlluminanceUnit.Megalux),
-                (IlluminanceUnit.Lux, IlluminanceUnit.Millilux) => new Illuminance((_value) / 1e-3d, IlluminanceUnit.Millilux),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not IlluminanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IlluminanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is IlluminanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IlluminanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<IlluminanceUnit> IQuantity<IlluminanceUnit>.ToUnit(IlluminanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -793,11 +656,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs b/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
index e627a492d4..f45683859e 100644
--- a/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,14 @@ namespace UnitsNet
     ///     In classical mechanics, impulse is the integral of a force, F, over the time interval, t, for which it acts. Impulse applied to an object produces an equivalent vector change in its linear momentum, also in the resultant direction.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Impulse :
-        IArithmeticQuantity<Impulse, ImpulseUnit>,
+        ILinearQuantity<Impulse, ImpulseUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Impulse, Impulse, double>,
+        IDivisionOperators<Impulse, Impulse, QuantityValue>,
+        IDivisionOperators<Impulse, Force, Duration>,
+        IDivisionOperators<Impulse, Duration, Force>,
         IComparisonOperators<Impulse, Impulse, bool>,
         IParsable<Impulse>,
 #endif
@@ -52,7 +53,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +103,7 @@ public static ImpulseInfo CreateDefault(Func<IEnumerable<UnitDefinition<ImpulseU
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Impulse"/> is [T^-1][L][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Impulse"/> is T^-1LM.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 1, -1, 0, 0, 0, 0);
 
@@ -117,27 +118,49 @@ public static ImpulseInfo CreateDefault(Func<IEnumerable<UnitDefinition<ImpulseU
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ImpulseUnit}"/> representing the default unit mappings for Impulse.</returns>
             public static IEnumerable<UnitDefinition<ImpulseUnit>> GetDefaultMappings()
             {
-                yield return new (ImpulseUnit.CentinewtonSecond, "CentinewtonSecond", "CentinewtonSeconds", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ImpulseUnit.DecanewtonSecond, "DecanewtonSecond", "DecanewtonSeconds", new BaseUnits(length: LengthUnit.Decameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ImpulseUnit.DecinewtonSecond, "DecinewtonSecond", "DecinewtonSeconds", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ImpulseUnit.KilogramMeterPerSecond, "KilogramMeterPerSecond", "KilogramMetersPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ImpulseUnit.KilonewtonSecond, "KilonewtonSecond", "KilonewtonSeconds", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ImpulseUnit.MeganewtonSecond, "MeganewtonSecond", "MeganewtonSeconds", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ImpulseUnit.MicronewtonSecond, "MicronewtonSecond", "MicronewtonSeconds", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ImpulseUnit.MillinewtonSecond, "MillinewtonSecond", "MillinewtonSeconds", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ImpulseUnit.NanonewtonSecond, "NanonewtonSecond", "NanonewtonSeconds", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
+                yield return new (ImpulseUnit.CentinewtonSecond, "CentinewtonSecond", "CentinewtonSeconds", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     100
+                );
+                yield return new (ImpulseUnit.DecanewtonSecond, "DecanewtonSecond", "DecanewtonSeconds", new BaseUnits(length: LengthUnit.Decameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (ImpulseUnit.DecinewtonSecond, "DecinewtonSecond", "DecinewtonSeconds", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (ImpulseUnit.KilogramMeterPerSecond, "KilogramMeterPerSecond", "KilogramMetersPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1
+                );
+                yield return new (ImpulseUnit.KilonewtonSecond, "KilonewtonSecond", "KilonewtonSeconds", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ImpulseUnit.MeganewtonSecond, "MeganewtonSecond", "MeganewtonSeconds", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ImpulseUnit.MicronewtonSecond, "MicronewtonSecond", "MicronewtonSeconds", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (ImpulseUnit.MillinewtonSecond, "MillinewtonSecond", "MillinewtonSeconds", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (ImpulseUnit.NanonewtonSecond, "NanonewtonSecond", "NanonewtonSeconds", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1000000000
+                );
                 yield return new (ImpulseUnit.NewtonSecond, "NewtonSecond", "NewtonSeconds", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (ImpulseUnit.PoundFootPerSecond, "PoundFootPerSecond", "PoundFeetPerSecond", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound, time: DurationUnit.Second));
-                yield return new (ImpulseUnit.PoundForceSecond, "PoundForceSecond", "PoundForceSeconds", BaseUnits.Undefined);
-                yield return new (ImpulseUnit.SlugFootPerSecond, "SlugFootPerSecond", "SlugFeetPerSecond", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Slug, time: DurationUnit.Second));
+                yield return new (ImpulseUnit.PoundFootPerSecond, "PoundFootPerSecond", "PoundFeetPerSecond", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound, time: DurationUnit.Second),
+                     new QuantityValue(125000000000, 17281869297)
+                );
+                yield return new (ImpulseUnit.PoundForceSecond, "PoundForceSecond", "PoundForceSeconds", BaseUnits.Undefined,
+                     new QuantityValue(2000000000000, 8896443230521)
+                );
+                yield return new (ImpulseUnit.SlugFootPerSecond, "SlugFootPerSecond", "SlugFeetPerSecond", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Slug, time: DurationUnit.Second),
+                     new QuantityValue(2000000000000, 8896443230521)
+                );
             }
         }
 
         static Impulse()
         {
-            Info = ImpulseInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ImpulseInfo.CreateDefault);
         }
 
         /// <summary>
@@ -145,7 +168,7 @@ static Impulse()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Impulse(double value, ImpulseUnit unit)
+        public Impulse(QuantityValue value, ImpulseUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -159,7 +182,7 @@ public Impulse(double value, ImpulseUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Impulse(double value, UnitSystem unitSystem)
+        public Impulse(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -170,7 +193,8 @@ public Impulse(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Impulse" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Impulse, ImpulseUnit> Info { get; }
@@ -199,10 +223,8 @@ public Impulse(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ImpulseUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -236,112 +258,74 @@ public Impulse(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.CentinewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.CentinewtonSecond"/>
         /// </summary>
-        public double CentinewtonSeconds => As(ImpulseUnit.CentinewtonSecond);
+        public QuantityValue CentinewtonSeconds => this.As(ImpulseUnit.CentinewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.DecanewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.DecanewtonSecond"/>
         /// </summary>
-        public double DecanewtonSeconds => As(ImpulseUnit.DecanewtonSecond);
+        public QuantityValue DecanewtonSeconds => this.As(ImpulseUnit.DecanewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.DecinewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.DecinewtonSecond"/>
         /// </summary>
-        public double DecinewtonSeconds => As(ImpulseUnit.DecinewtonSecond);
+        public QuantityValue DecinewtonSeconds => this.As(ImpulseUnit.DecinewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.KilogramMeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.KilogramMeterPerSecond"/>
         /// </summary>
-        public double KilogramMetersPerSecond => As(ImpulseUnit.KilogramMeterPerSecond);
+        public QuantityValue KilogramMetersPerSecond => this.As(ImpulseUnit.KilogramMeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.KilonewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.KilonewtonSecond"/>
         /// </summary>
-        public double KilonewtonSeconds => As(ImpulseUnit.KilonewtonSecond);
+        public QuantityValue KilonewtonSeconds => this.As(ImpulseUnit.KilonewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.MeganewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.MeganewtonSecond"/>
         /// </summary>
-        public double MeganewtonSeconds => As(ImpulseUnit.MeganewtonSecond);
+        public QuantityValue MeganewtonSeconds => this.As(ImpulseUnit.MeganewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.MicronewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.MicronewtonSecond"/>
         /// </summary>
-        public double MicronewtonSeconds => As(ImpulseUnit.MicronewtonSecond);
+        public QuantityValue MicronewtonSeconds => this.As(ImpulseUnit.MicronewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.MillinewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.MillinewtonSecond"/>
         /// </summary>
-        public double MillinewtonSeconds => As(ImpulseUnit.MillinewtonSecond);
+        public QuantityValue MillinewtonSeconds => this.As(ImpulseUnit.MillinewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.NanonewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.NanonewtonSecond"/>
         /// </summary>
-        public double NanonewtonSeconds => As(ImpulseUnit.NanonewtonSecond);
+        public QuantityValue NanonewtonSeconds => this.As(ImpulseUnit.NanonewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.NewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.NewtonSecond"/>
         /// </summary>
-        public double NewtonSeconds => As(ImpulseUnit.NewtonSecond);
+        public QuantityValue NewtonSeconds => this.As(ImpulseUnit.NewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.PoundFootPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.PoundFootPerSecond"/>
         /// </summary>
-        public double PoundFeetPerSecond => As(ImpulseUnit.PoundFootPerSecond);
+        public QuantityValue PoundFeetPerSecond => this.As(ImpulseUnit.PoundFootPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.PoundForceSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.PoundForceSecond"/>
         /// </summary>
-        public double PoundForceSeconds => As(ImpulseUnit.PoundForceSecond);
+        public QuantityValue PoundForceSeconds => this.As(ImpulseUnit.PoundForceSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ImpulseUnit.SlugFootPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ImpulseUnit.SlugFootPerSecond"/>
         /// </summary>
-        public double SlugFeetPerSecond => As(ImpulseUnit.SlugFootPerSecond);
+        public QuantityValue SlugFeetPerSecond => this.As(ImpulseUnit.SlugFootPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ImpulseUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.CentinewtonSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.DecanewtonSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.DecinewtonSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.KilogramMeterPerSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.KilonewtonSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.MeganewtonSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.MicronewtonSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.MillinewtonSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NanonewtonSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.PoundFootPerSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.PoundForceSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.SlugFootPerSecond, ImpulseUnit.NewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NewtonSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.NewtonSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ImpulseUnit
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.CentinewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.CentinewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.DecanewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.DecanewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.DecinewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.DecinewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.KilogramMeterPerSecond, quantity => quantity.ToUnit(ImpulseUnit.KilogramMeterPerSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.KilonewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.KilonewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.MeganewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.MeganewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.MicronewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.MicronewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.MillinewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.MillinewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.NanonewtonSecond, quantity => quantity.ToUnit(ImpulseUnit.NanonewtonSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.PoundFootPerSecond, quantity => quantity.ToUnit(ImpulseUnit.PoundFootPerSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.PoundForceSecond, quantity => quantity.ToUnit(ImpulseUnit.PoundForceSecond));
-            unitConverter.SetConversionFunction<Impulse>(ImpulseUnit.NewtonSecond, ImpulseUnit.SlugFootPerSecond, quantity => quantity.ToUnit(ImpulseUnit.SlugFootPerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -370,7 +354,7 @@ public static string GetAbbreviation(ImpulseUnit unit, IFormatProvider? provider
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.CentinewtonSecond"/>.
         /// </summary>
-        public static Impulse FromCentinewtonSeconds(double value)
+        public static Impulse FromCentinewtonSeconds(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.CentinewtonSecond);
         }
@@ -378,7 +362,7 @@ public static Impulse FromCentinewtonSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.DecanewtonSecond"/>.
         /// </summary>
-        public static Impulse FromDecanewtonSeconds(double value)
+        public static Impulse FromDecanewtonSeconds(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.DecanewtonSecond);
         }
@@ -386,7 +370,7 @@ public static Impulse FromDecanewtonSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.DecinewtonSecond"/>.
         /// </summary>
-        public static Impulse FromDecinewtonSeconds(double value)
+        public static Impulse FromDecinewtonSeconds(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.DecinewtonSecond);
         }
@@ -394,7 +378,7 @@ public static Impulse FromDecinewtonSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.KilogramMeterPerSecond"/>.
         /// </summary>
-        public static Impulse FromKilogramMetersPerSecond(double value)
+        public static Impulse FromKilogramMetersPerSecond(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.KilogramMeterPerSecond);
         }
@@ -402,7 +386,7 @@ public static Impulse FromKilogramMetersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.KilonewtonSecond"/>.
         /// </summary>
-        public static Impulse FromKilonewtonSeconds(double value)
+        public static Impulse FromKilonewtonSeconds(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.KilonewtonSecond);
         }
@@ -410,7 +394,7 @@ public static Impulse FromKilonewtonSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MeganewtonSecond"/>.
         /// </summary>
-        public static Impulse FromMeganewtonSeconds(double value)
+        public static Impulse FromMeganewtonSeconds(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.MeganewtonSecond);
         }
@@ -418,7 +402,7 @@ public static Impulse FromMeganewtonSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MicronewtonSecond"/>.
         /// </summary>
-        public static Impulse FromMicronewtonSeconds(double value)
+        public static Impulse FromMicronewtonSeconds(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.MicronewtonSecond);
         }
@@ -426,7 +410,7 @@ public static Impulse FromMicronewtonSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MillinewtonSecond"/>.
         /// </summary>
-        public static Impulse FromMillinewtonSeconds(double value)
+        public static Impulse FromMillinewtonSeconds(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.MillinewtonSecond);
         }
@@ -434,7 +418,7 @@ public static Impulse FromMillinewtonSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.NanonewtonSecond"/>.
         /// </summary>
-        public static Impulse FromNanonewtonSeconds(double value)
+        public static Impulse FromNanonewtonSeconds(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.NanonewtonSecond);
         }
@@ -442,7 +426,7 @@ public static Impulse FromNanonewtonSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.NewtonSecond"/>.
         /// </summary>
-        public static Impulse FromNewtonSeconds(double value)
+        public static Impulse FromNewtonSeconds(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.NewtonSecond);
         }
@@ -450,7 +434,7 @@ public static Impulse FromNewtonSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.PoundFootPerSecond"/>.
         /// </summary>
-        public static Impulse FromPoundFeetPerSecond(double value)
+        public static Impulse FromPoundFeetPerSecond(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.PoundFootPerSecond);
         }
@@ -458,7 +442,7 @@ public static Impulse FromPoundFeetPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.PoundForceSecond"/>.
         /// </summary>
-        public static Impulse FromPoundForceSeconds(double value)
+        public static Impulse FromPoundForceSeconds(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.PoundForceSecond);
         }
@@ -466,7 +450,7 @@ public static Impulse FromPoundForceSeconds(double value)
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.SlugFootPerSecond"/>.
         /// </summary>
-        public static Impulse FromSlugFeetPerSecond(double value)
+        public static Impulse FromSlugFeetPerSecond(QuantityValue value)
         {
             return new Impulse(value, ImpulseUnit.SlugFootPerSecond);
         }
@@ -477,7 +461,7 @@ public static Impulse FromSlugFeetPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Impulse unit value.</returns>
-        public static Impulse From(double value, ImpulseUnit fromUnit)
+        public static Impulse From(QuantityValue value, ImpulseUnit fromUnit)
         {
             return new Impulse(value, fromUnit);
         }
@@ -538,10 +522,7 @@ public static Impulse Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Impulse Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Impulse, ImpulseUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Impulse, ImpulseUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -569,11 +550,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Impulse result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Impulse result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Impulse, ImpulseUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Impulse, ImpulseUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -594,7 +571,7 @@ public static ImpulseUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -605,7 +582,7 @@ public static ImpulseUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ImpulseUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ImpulseUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ImpulseUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -620,7 +597,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ImpulseUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ImpulseUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -639,137 +616,167 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Impulse"/> from adding two <see cref="Impulse"/>.</summary>
         public static Impulse operator +(Impulse left, Impulse right)
         {
-            return new Impulse(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Impulse(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Impulse"/> from subtracting two <see cref="Impulse"/>.</summary>
         public static Impulse operator -(Impulse left, Impulse right)
         {
-            return new Impulse(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Impulse(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Impulse"/> from multiplying value and <see cref="Impulse"/>.</summary>
-        public static Impulse operator *(double left, Impulse right)
+        public static Impulse operator *(QuantityValue left, Impulse right)
         {
             return new Impulse(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Impulse"/> from multiplying value and <see cref="Impulse"/>.</summary>
-        public static Impulse operator *(Impulse left, double right)
+        public static Impulse operator *(Impulse left, QuantityValue right)
         {
             return new Impulse(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Impulse"/> from dividing <see cref="Impulse"/> by value.</summary>
-        public static Impulse operator /(Impulse left, double right)
+        public static Impulse operator /(Impulse left, QuantityValue right)
         {
             return new Impulse(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Impulse"/> by <see cref="Impulse"/>.</summary>
-        public static double operator /(Impulse left, Impulse right)
+        public static QuantityValue operator /(Impulse left, Impulse right)
         {
             return left.NewtonSeconds / right.NewtonSeconds;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Duration"/> from <see cref="Impulse"/> / <see cref="Force"/>.</summary>
+        public static Duration operator /(Impulse impulse, Force force)
+        {
+            return Duration.FromSeconds(impulse.NewtonSeconds / force.Newtons);
+        }
+
+        /// <summary>Get <see cref="Force"/> from <see cref="Impulse"/> / <see cref="Duration"/>.</summary>
+        public static Force operator /(Impulse impulse, Duration duration)
+        {
+            return Force.FromNewtons(impulse.NewtonSeconds / duration.Seconds);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Impulse left, Impulse right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Impulse left, Impulse right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Impulse left, Impulse right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Impulse left, Impulse right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Impulse"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Impulse other, Impulse tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Impulse"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Impulse)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Impulse left, Impulse right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Impulse"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Impulse other, Impulse tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Impulse"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Impulse,Impulse)"/>.
+        ///     See that operator (and <see cref="Equals(Impulse)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Impulse left, Impulse right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Impulse"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Impulse other, Impulse tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Impulse"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Impulse"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Impulse"/>, this method delegates to
+        ///     <see cref="Equals(Impulse)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Impulse otherQuantity))
+            if (obj is not Impulse otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Impulse"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Impulse other, Impulse tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Impulse"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Impulse other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Impulse.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Impulse), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Impulse"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Impulse)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Impulse otherQuantity)) throw new ArgumentException("Expected type Impulse.", nameof(obj));
+            if (obj is not Impulse otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Impulse>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Impulse"/> with another <see cref="Impulse"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Impulse"/> with another <see cref="Impulse"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -781,153 +788,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Impulse other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ImpulseUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ImpulseUnit>());
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this Impulse to another Impulse with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Impulse with the specified unit.</returns>
-        public Impulse ToUnit(ImpulseUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Impulse"/> to another <see cref="Impulse"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Impulse with the specified unit.</returns>
-        public Impulse ToUnit(ImpulseUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Impulse), Unit, typeof(Impulse), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Impulse)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Impulse"/> to another <see cref="Impulse"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Impulse"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ImpulseUnit unit, [NotNullWhen(true)] out Impulse? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Impulse? convertedOrNull = (Unit, unit) switch
-            {
-                // ImpulseUnit -> BaseUnit
-                (ImpulseUnit.CentinewtonSecond, ImpulseUnit.NewtonSecond) => new Impulse((_value) * 1e-2d, ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.DecanewtonSecond, ImpulseUnit.NewtonSecond) => new Impulse((_value) * 1e1d, ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.DecinewtonSecond, ImpulseUnit.NewtonSecond) => new Impulse((_value) * 1e-1d, ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.KilogramMeterPerSecond, ImpulseUnit.NewtonSecond) => new Impulse(_value, ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.KilonewtonSecond, ImpulseUnit.NewtonSecond) => new Impulse((_value) * 1e3d, ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.MeganewtonSecond, ImpulseUnit.NewtonSecond) => new Impulse((_value) * 1e6d, ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.MicronewtonSecond, ImpulseUnit.NewtonSecond) => new Impulse((_value) * 1e-6d, ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.MillinewtonSecond, ImpulseUnit.NewtonSecond) => new Impulse((_value) * 1e-3d, ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.NanonewtonSecond, ImpulseUnit.NewtonSecond) => new Impulse((_value) * 1e-9d, ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.PoundFootPerSecond, ImpulseUnit.NewtonSecond) => new Impulse(_value * (0.45359237 * 0.3048), ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.PoundForceSecond, ImpulseUnit.NewtonSecond) => new Impulse(_value * 0.45359237 * 9.80665, ImpulseUnit.NewtonSecond),
-                (ImpulseUnit.SlugFootPerSecond, ImpulseUnit.NewtonSecond) => new Impulse(_value * (0.45359237 * 9.80665), ImpulseUnit.NewtonSecond),
-
-                // BaseUnit -> ImpulseUnit
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.CentinewtonSecond) => new Impulse((_value) / 1e-2d, ImpulseUnit.CentinewtonSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.DecanewtonSecond) => new Impulse((_value) / 1e1d, ImpulseUnit.DecanewtonSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.DecinewtonSecond) => new Impulse((_value) / 1e-1d, ImpulseUnit.DecinewtonSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.KilogramMeterPerSecond) => new Impulse(_value, ImpulseUnit.KilogramMeterPerSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.KilonewtonSecond) => new Impulse((_value) / 1e3d, ImpulseUnit.KilonewtonSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.MeganewtonSecond) => new Impulse((_value) / 1e6d, ImpulseUnit.MeganewtonSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.MicronewtonSecond) => new Impulse((_value) / 1e-6d, ImpulseUnit.MicronewtonSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.MillinewtonSecond) => new Impulse((_value) / 1e-3d, ImpulseUnit.MillinewtonSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.NanonewtonSecond) => new Impulse((_value) / 1e-9d, ImpulseUnit.NanonewtonSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.PoundFootPerSecond) => new Impulse(_value / (0.45359237 * 0.3048), ImpulseUnit.PoundFootPerSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.PoundForceSecond) => new Impulse(_value / (0.45359237 * 9.80665), ImpulseUnit.PoundForceSecond),
-                (ImpulseUnit.NewtonSecond, ImpulseUnit.SlugFootPerSecond) => new Impulse(_value / (0.45359237 * 9.80665), ImpulseUnit.SlugFootPerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ImpulseUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ImpulseUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ImpulseUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ImpulseUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ImpulseUnit> IQuantity<ImpulseUnit>.ToUnit(ImpulseUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -941,11 +804,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Information.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
index 37fc7a4f44..25c24e18bb 100644
--- a/UnitsNet/GeneratedCode/Quantities/Information.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,15 @@ namespace UnitsNet
     ///     In computing and telecommunications, a unit of information is the capacity of some standard data storage system or communication channel, used to measure the capacities of other systems and channels. In information theory, units of information are also used to measure the information contents or entropy of random variables.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Information :
-        IArithmeticQuantity<Information, InformationUnit>,
+        ILinearQuantity<Information, InformationUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Information, Information, double>,
+        IDivisionOperators<Information, Information, QuantityValue>,
+        IMultiplyOperators<Information, Frequency, BitRate>,
+        IDivisionOperators<Information, Duration, BitRate>,
+        IDivisionOperators<Information, BitRate, Duration>,
         IComparisonOperators<Information, Information, bool>,
         IParsable<Information>,
 #endif
@@ -52,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -118,52 +120,126 @@ public static InformationInfo CreateDefault(Func<IEnumerable<UnitDefinition<Info
             public static IEnumerable<UnitDefinition<InformationUnit>> GetDefaultMappings()
             {
                 yield return new (InformationUnit.Bit, "Bit", "Bits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Byte, "Byte", "Bytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Exabit, "Exabit", "Exabits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Exabyte, "Exabyte", "Exabytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Exaoctet, "Exaoctet", "Exaoctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Exbibit, "Exbibit", "Exbibits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Exbibyte, "Exbibyte", "Exbibytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Exbioctet, "Exbioctet", "Exbioctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Gibibit, "Gibibit", "Gibibits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Gibibyte, "Gibibyte", "Gibibytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Gibioctet, "Gibioctet", "Gibioctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Gigabit, "Gigabit", "Gigabits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Gigabyte, "Gigabyte", "Gigabytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Gigaoctet, "Gigaoctet", "Gigaoctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Kibibit, "Kibibit", "Kibibits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Kibibyte, "Kibibyte", "Kibibytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Kibioctet, "Kibioctet", "Kibioctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Kilobit, "Kilobit", "Kilobits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Kilobyte, "Kilobyte", "Kilobytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Kilooctet, "Kilooctet", "Kilooctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Mebibit, "Mebibit", "Mebibits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Mebibyte, "Mebibyte", "Mebibytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Mebioctet, "Mebioctet", "Mebioctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Megabit, "Megabit", "Megabits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Megabyte, "Megabyte", "Megabytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Megaoctet, "Megaoctet", "Megaoctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Octet, "Octet", "Octets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Pebibit, "Pebibit", "Pebibits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Pebibyte, "Pebibyte", "Pebibytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Pebioctet, "Pebioctet", "Pebioctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Petabit, "Petabit", "Petabits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Petabyte, "Petabyte", "Petabytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Petaoctet, "Petaoctet", "Petaoctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Tebibit, "Tebibit", "Tebibits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Tebibyte, "Tebibyte", "Tebibytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Tebioctet, "Tebioctet", "Tebioctets", BaseUnits.Undefined);
-                yield return new (InformationUnit.Terabit, "Terabit", "Terabits", BaseUnits.Undefined);
-                yield return new (InformationUnit.Terabyte, "Terabyte", "Terabytes", BaseUnits.Undefined);
-                yield return new (InformationUnit.Teraoctet, "Teraoctet", "Teraoctets", BaseUnits.Undefined);
+                yield return new (InformationUnit.Byte, "Byte", "Bytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8)
+                );
+                yield return new (InformationUnit.Exabit, "Exabit", "Exabits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000000)
+                );
+                yield return new (InformationUnit.Exabyte, "Exabyte", "Exabytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000000000)
+                );
+                yield return new (InformationUnit.Exaoctet, "Exaoctet", "Exaoctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000000000)
+                );
+                yield return new (InformationUnit.Exbibit, "Exbibit", "Exbibits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1152921504606846976)
+                );
+                yield return new (InformationUnit.Exbibyte, "Exbibyte", "Exbibytes", BaseUnits.Undefined,
+                     new QuantityValue(1, BigInteger.Pow(2, 63))
+                );
+                yield return new (InformationUnit.Exbioctet, "Exbioctet", "Exbioctets", BaseUnits.Undefined,
+                     new QuantityValue(1, BigInteger.Pow(2, 63))
+                );
+                yield return new (InformationUnit.Gibibit, "Gibibit", "Gibibits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1073741824)
+                );
+                yield return new (InformationUnit.Gibibyte, "Gibibyte", "Gibibytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8589934592)
+                );
+                yield return new (InformationUnit.Gibioctet, "Gibioctet", "Gibioctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8589934592)
+                );
+                yield return new (InformationUnit.Gigabit, "Gigabit", "Gigabits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (InformationUnit.Gigabyte, "Gigabyte", "Gigabytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000)
+                );
+                yield return new (InformationUnit.Gigaoctet, "Gigaoctet", "Gigaoctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000)
+                );
+                yield return new (InformationUnit.Kibibit, "Kibibit", "Kibibits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1024)
+                );
+                yield return new (InformationUnit.Kibibyte, "Kibibyte", "Kibibytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8192)
+                );
+                yield return new (InformationUnit.Kibioctet, "Kibioctet", "Kibioctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8192)
+                );
+                yield return new (InformationUnit.Kilobit, "Kilobit", "Kilobits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (InformationUnit.Kilobyte, "Kilobyte", "Kilobytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000)
+                );
+                yield return new (InformationUnit.Kilooctet, "Kilooctet", "Kilooctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000)
+                );
+                yield return new (InformationUnit.Mebibit, "Mebibit", "Mebibits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1048576)
+                );
+                yield return new (InformationUnit.Mebibyte, "Mebibyte", "Mebibytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8388608)
+                );
+                yield return new (InformationUnit.Mebioctet, "Mebioctet", "Mebioctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8388608)
+                );
+                yield return new (InformationUnit.Megabit, "Megabit", "Megabits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (InformationUnit.Megabyte, "Megabyte", "Megabytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000)
+                );
+                yield return new (InformationUnit.Megaoctet, "Megaoctet", "Megaoctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000)
+                );
+                yield return new (InformationUnit.Octet, "Octet", "Octets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8)
+                );
+                yield return new (InformationUnit.Pebibit, "Pebibit", "Pebibits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1125899906842624)
+                );
+                yield return new (InformationUnit.Pebibyte, "Pebibyte", "Pebibytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 9007199254740992)
+                );
+                yield return new (InformationUnit.Pebioctet, "Pebioctet", "Pebioctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 9007199254740992)
+                );
+                yield return new (InformationUnit.Petabit, "Petabit", "Petabits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000)
+                );
+                yield return new (InformationUnit.Petabyte, "Petabyte", "Petabytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000000)
+                );
+                yield return new (InformationUnit.Petaoctet, "Petaoctet", "Petaoctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000000)
+                );
+                yield return new (InformationUnit.Tebibit, "Tebibit", "Tebibits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1099511627776)
+                );
+                yield return new (InformationUnit.Tebibyte, "Tebibyte", "Tebibytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8796093022208)
+                );
+                yield return new (InformationUnit.Tebioctet, "Tebioctet", "Tebioctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8796093022208)
+                );
+                yield return new (InformationUnit.Terabit, "Terabit", "Terabits", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (InformationUnit.Terabyte, "Terabyte", "Terabytes", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000)
+                );
+                yield return new (InformationUnit.Teraoctet, "Teraoctet", "Teraoctets", BaseUnits.Undefined,
+                     new QuantityValue(1, 8000000000000)
+                );
             }
         }
 
         static Information()
         {
-            Info = InformationInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(InformationInfo.CreateDefault);
         }
 
         /// <summary>
@@ -171,7 +247,7 @@ static Information()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Information(double value, InformationUnit unit)
+        public Information(QuantityValue value, InformationUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -182,7 +258,8 @@ public Information(double value, InformationUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Information" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Information, InformationUnit> Info { get; }
@@ -211,10 +288,8 @@ public Information(double value, InformationUnit unit)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public InformationUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -248,294 +323,204 @@ public Information(double value, InformationUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Bit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Bit"/>
         /// </summary>
-        public double Bits => As(InformationUnit.Bit);
+        public QuantityValue Bits => this.As(InformationUnit.Bit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Byte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Byte"/>
         /// </summary>
-        public double Bytes => As(InformationUnit.Byte);
+        public QuantityValue Bytes => this.As(InformationUnit.Byte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exabit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Exabit"/>
         /// </summary>
-        public double Exabits => As(InformationUnit.Exabit);
+        public QuantityValue Exabits => this.As(InformationUnit.Exabit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exabyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Exabyte"/>
         /// </summary>
-        public double Exabytes => As(InformationUnit.Exabyte);
+        public QuantityValue Exabytes => this.As(InformationUnit.Exabyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exaoctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Exaoctet"/>
         /// </summary>
-        public double Exaoctets => As(InformationUnit.Exaoctet);
+        public QuantityValue Exaoctets => this.As(InformationUnit.Exaoctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exbibit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Exbibit"/>
         /// </summary>
-        public double Exbibits => As(InformationUnit.Exbibit);
+        public QuantityValue Exbibits => this.As(InformationUnit.Exbibit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exbibyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Exbibyte"/>
         /// </summary>
-        public double Exbibytes => As(InformationUnit.Exbibyte);
+        public QuantityValue Exbibytes => this.As(InformationUnit.Exbibyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Exbioctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Exbioctet"/>
         /// </summary>
-        public double Exbioctets => As(InformationUnit.Exbioctet);
+        public QuantityValue Exbioctets => this.As(InformationUnit.Exbioctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gibibit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Gibibit"/>
         /// </summary>
-        public double Gibibits => As(InformationUnit.Gibibit);
+        public QuantityValue Gibibits => this.As(InformationUnit.Gibibit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gibibyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Gibibyte"/>
         /// </summary>
-        public double Gibibytes => As(InformationUnit.Gibibyte);
+        public QuantityValue Gibibytes => this.As(InformationUnit.Gibibyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gibioctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Gibioctet"/>
         /// </summary>
-        public double Gibioctets => As(InformationUnit.Gibioctet);
+        public QuantityValue Gibioctets => this.As(InformationUnit.Gibioctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gigabit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Gigabit"/>
         /// </summary>
-        public double Gigabits => As(InformationUnit.Gigabit);
+        public QuantityValue Gigabits => this.As(InformationUnit.Gigabit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gigabyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Gigabyte"/>
         /// </summary>
-        public double Gigabytes => As(InformationUnit.Gigabyte);
+        public QuantityValue Gigabytes => this.As(InformationUnit.Gigabyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Gigaoctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Gigaoctet"/>
         /// </summary>
-        public double Gigaoctets => As(InformationUnit.Gigaoctet);
+        public QuantityValue Gigaoctets => this.As(InformationUnit.Gigaoctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kibibit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Kibibit"/>
         /// </summary>
-        public double Kibibits => As(InformationUnit.Kibibit);
+        public QuantityValue Kibibits => this.As(InformationUnit.Kibibit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kibibyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Kibibyte"/>
         /// </summary>
-        public double Kibibytes => As(InformationUnit.Kibibyte);
+        public QuantityValue Kibibytes => this.As(InformationUnit.Kibibyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kibioctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Kibioctet"/>
         /// </summary>
-        public double Kibioctets => As(InformationUnit.Kibioctet);
+        public QuantityValue Kibioctets => this.As(InformationUnit.Kibioctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kilobit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Kilobit"/>
         /// </summary>
-        public double Kilobits => As(InformationUnit.Kilobit);
+        public QuantityValue Kilobits => this.As(InformationUnit.Kilobit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kilobyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Kilobyte"/>
         /// </summary>
-        public double Kilobytes => As(InformationUnit.Kilobyte);
+        public QuantityValue Kilobytes => this.As(InformationUnit.Kilobyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Kilooctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Kilooctet"/>
         /// </summary>
-        public double Kilooctets => As(InformationUnit.Kilooctet);
+        public QuantityValue Kilooctets => this.As(InformationUnit.Kilooctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Mebibit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Mebibit"/>
         /// </summary>
-        public double Mebibits => As(InformationUnit.Mebibit);
+        public QuantityValue Mebibits => this.As(InformationUnit.Mebibit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Mebibyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Mebibyte"/>
         /// </summary>
-        public double Mebibytes => As(InformationUnit.Mebibyte);
+        public QuantityValue Mebibytes => this.As(InformationUnit.Mebibyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Mebioctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Mebioctet"/>
         /// </summary>
-        public double Mebioctets => As(InformationUnit.Mebioctet);
+        public QuantityValue Mebioctets => this.As(InformationUnit.Mebioctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Megabit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Megabit"/>
         /// </summary>
-        public double Megabits => As(InformationUnit.Megabit);
+        public QuantityValue Megabits => this.As(InformationUnit.Megabit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Megabyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Megabyte"/>
         /// </summary>
-        public double Megabytes => As(InformationUnit.Megabyte);
+        public QuantityValue Megabytes => this.As(InformationUnit.Megabyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Megaoctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Megaoctet"/>
         /// </summary>
-        public double Megaoctets => As(InformationUnit.Megaoctet);
+        public QuantityValue Megaoctets => this.As(InformationUnit.Megaoctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Octet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Octet"/>
         /// </summary>
-        public double Octets => As(InformationUnit.Octet);
+        public QuantityValue Octets => this.As(InformationUnit.Octet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Pebibit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Pebibit"/>
         /// </summary>
-        public double Pebibits => As(InformationUnit.Pebibit);
+        public QuantityValue Pebibits => this.As(InformationUnit.Pebibit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Pebibyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Pebibyte"/>
         /// </summary>
-        public double Pebibytes => As(InformationUnit.Pebibyte);
+        public QuantityValue Pebibytes => this.As(InformationUnit.Pebibyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Pebioctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Pebioctet"/>
         /// </summary>
-        public double Pebioctets => As(InformationUnit.Pebioctet);
+        public QuantityValue Pebioctets => this.As(InformationUnit.Pebioctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Petabit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Petabit"/>
         /// </summary>
-        public double Petabits => As(InformationUnit.Petabit);
+        public QuantityValue Petabits => this.As(InformationUnit.Petabit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Petabyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Petabyte"/>
         /// </summary>
-        public double Petabytes => As(InformationUnit.Petabyte);
+        public QuantityValue Petabytes => this.As(InformationUnit.Petabyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Petaoctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Petaoctet"/>
         /// </summary>
-        public double Petaoctets => As(InformationUnit.Petaoctet);
+        public QuantityValue Petaoctets => this.As(InformationUnit.Petaoctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Tebibit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Tebibit"/>
         /// </summary>
-        public double Tebibits => As(InformationUnit.Tebibit);
+        public QuantityValue Tebibits => this.As(InformationUnit.Tebibit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Tebibyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Tebibyte"/>
         /// </summary>
-        public double Tebibytes => As(InformationUnit.Tebibyte);
+        public QuantityValue Tebibytes => this.As(InformationUnit.Tebibyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Tebioctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Tebioctet"/>
         /// </summary>
-        public double Tebioctets => As(InformationUnit.Tebioctet);
+        public QuantityValue Tebioctets => this.As(InformationUnit.Tebioctet);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Terabit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Terabit"/>
         /// </summary>
-        public double Terabits => As(InformationUnit.Terabit);
+        public QuantityValue Terabits => this.As(InformationUnit.Terabit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Terabyte"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Terabyte"/>
         /// </summary>
-        public double Terabytes => As(InformationUnit.Terabyte);
+        public QuantityValue Terabytes => this.As(InformationUnit.Terabyte);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="InformationUnit.Teraoctet"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="InformationUnit.Teraoctet"/>
         /// </summary>
-        public double Teraoctets => As(InformationUnit.Teraoctet);
+        public QuantityValue Teraoctets => this.As(InformationUnit.Teraoctet);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: InformationUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Byte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Exabit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Exabyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Exaoctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Exbibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Exbibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Exbioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Gibibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Gibibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Gibioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Gigabit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Gigabyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Gigaoctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Kibibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Kibibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Kibioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Kilobit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Kilobyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Kilooctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Mebibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Mebibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Mebioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Megabit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Megabyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Megaoctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Octet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Pebibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Pebibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Pebioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Petabit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Petabyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Petaoctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Tebibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Tebibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Tebioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Terabit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Terabyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Teraoctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Bit, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> InformationUnit
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Byte, quantity => quantity.ToUnit(InformationUnit.Byte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Exabit, quantity => quantity.ToUnit(InformationUnit.Exabit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Exabyte, quantity => quantity.ToUnit(InformationUnit.Exabyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Exaoctet, quantity => quantity.ToUnit(InformationUnit.Exaoctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Exbibit, quantity => quantity.ToUnit(InformationUnit.Exbibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Exbibyte, quantity => quantity.ToUnit(InformationUnit.Exbibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Exbioctet, quantity => quantity.ToUnit(InformationUnit.Exbioctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Gibibit, quantity => quantity.ToUnit(InformationUnit.Gibibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Gibibyte, quantity => quantity.ToUnit(InformationUnit.Gibibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Gibioctet, quantity => quantity.ToUnit(InformationUnit.Gibioctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Gigabit, quantity => quantity.ToUnit(InformationUnit.Gigabit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Gigabyte, quantity => quantity.ToUnit(InformationUnit.Gigabyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Gigaoctet, quantity => quantity.ToUnit(InformationUnit.Gigaoctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Kibibit, quantity => quantity.ToUnit(InformationUnit.Kibibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Kibibyte, quantity => quantity.ToUnit(InformationUnit.Kibibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Kibioctet, quantity => quantity.ToUnit(InformationUnit.Kibioctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Kilobit, quantity => quantity.ToUnit(InformationUnit.Kilobit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Kilobyte, quantity => quantity.ToUnit(InformationUnit.Kilobyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Kilooctet, quantity => quantity.ToUnit(InformationUnit.Kilooctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Mebibit, quantity => quantity.ToUnit(InformationUnit.Mebibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Mebibyte, quantity => quantity.ToUnit(InformationUnit.Mebibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Mebioctet, quantity => quantity.ToUnit(InformationUnit.Mebioctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Megabit, quantity => quantity.ToUnit(InformationUnit.Megabit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Megabyte, quantity => quantity.ToUnit(InformationUnit.Megabyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Megaoctet, quantity => quantity.ToUnit(InformationUnit.Megaoctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Octet, quantity => quantity.ToUnit(InformationUnit.Octet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Pebibit, quantity => quantity.ToUnit(InformationUnit.Pebibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Pebibyte, quantity => quantity.ToUnit(InformationUnit.Pebibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Pebioctet, quantity => quantity.ToUnit(InformationUnit.Pebioctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Petabit, quantity => quantity.ToUnit(InformationUnit.Petabit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Petabyte, quantity => quantity.ToUnit(InformationUnit.Petabyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Petaoctet, quantity => quantity.ToUnit(InformationUnit.Petaoctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Tebibit, quantity => quantity.ToUnit(InformationUnit.Tebibit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Tebibyte, quantity => quantity.ToUnit(InformationUnit.Tebibyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Tebioctet, quantity => quantity.ToUnit(InformationUnit.Tebioctet));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Terabit, quantity => quantity.ToUnit(InformationUnit.Terabit));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Terabyte, quantity => quantity.ToUnit(InformationUnit.Terabyte));
-            unitConverter.SetConversionFunction<Information>(InformationUnit.Bit, InformationUnit.Teraoctet, quantity => quantity.ToUnit(InformationUnit.Teraoctet));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -564,7 +549,7 @@ public static string GetAbbreviation(InformationUnit unit, IFormatProvider? prov
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Bit"/>.
         /// </summary>
-        public static Information FromBits(double value)
+        public static Information FromBits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Bit);
         }
@@ -572,7 +557,7 @@ public static Information FromBits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Byte"/>.
         /// </summary>
-        public static Information FromBytes(double value)
+        public static Information FromBytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Byte);
         }
@@ -580,7 +565,7 @@ public static Information FromBytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exabit"/>.
         /// </summary>
-        public static Information FromExabits(double value)
+        public static Information FromExabits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Exabit);
         }
@@ -588,7 +573,7 @@ public static Information FromExabits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exabyte"/>.
         /// </summary>
-        public static Information FromExabytes(double value)
+        public static Information FromExabytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Exabyte);
         }
@@ -596,7 +581,7 @@ public static Information FromExabytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exaoctet"/>.
         /// </summary>
-        public static Information FromExaoctets(double value)
+        public static Information FromExaoctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Exaoctet);
         }
@@ -604,7 +589,7 @@ public static Information FromExaoctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exbibit"/>.
         /// </summary>
-        public static Information FromExbibits(double value)
+        public static Information FromExbibits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Exbibit);
         }
@@ -612,7 +597,7 @@ public static Information FromExbibits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exbibyte"/>.
         /// </summary>
-        public static Information FromExbibytes(double value)
+        public static Information FromExbibytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Exbibyte);
         }
@@ -620,7 +605,7 @@ public static Information FromExbibytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exbioctet"/>.
         /// </summary>
-        public static Information FromExbioctets(double value)
+        public static Information FromExbioctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Exbioctet);
         }
@@ -628,7 +613,7 @@ public static Information FromExbioctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gibibit"/>.
         /// </summary>
-        public static Information FromGibibits(double value)
+        public static Information FromGibibits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Gibibit);
         }
@@ -636,7 +621,7 @@ public static Information FromGibibits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gibibyte"/>.
         /// </summary>
-        public static Information FromGibibytes(double value)
+        public static Information FromGibibytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Gibibyte);
         }
@@ -644,7 +629,7 @@ public static Information FromGibibytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gibioctet"/>.
         /// </summary>
-        public static Information FromGibioctets(double value)
+        public static Information FromGibioctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Gibioctet);
         }
@@ -652,7 +637,7 @@ public static Information FromGibioctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gigabit"/>.
         /// </summary>
-        public static Information FromGigabits(double value)
+        public static Information FromGigabits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Gigabit);
         }
@@ -660,7 +645,7 @@ public static Information FromGigabits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gigabyte"/>.
         /// </summary>
-        public static Information FromGigabytes(double value)
+        public static Information FromGigabytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Gigabyte);
         }
@@ -668,7 +653,7 @@ public static Information FromGigabytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gigaoctet"/>.
         /// </summary>
-        public static Information FromGigaoctets(double value)
+        public static Information FromGigaoctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Gigaoctet);
         }
@@ -676,7 +661,7 @@ public static Information FromGigaoctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kibibit"/>.
         /// </summary>
-        public static Information FromKibibits(double value)
+        public static Information FromKibibits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Kibibit);
         }
@@ -684,7 +669,7 @@ public static Information FromKibibits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kibibyte"/>.
         /// </summary>
-        public static Information FromKibibytes(double value)
+        public static Information FromKibibytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Kibibyte);
         }
@@ -692,7 +677,7 @@ public static Information FromKibibytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kibioctet"/>.
         /// </summary>
-        public static Information FromKibioctets(double value)
+        public static Information FromKibioctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Kibioctet);
         }
@@ -700,7 +685,7 @@ public static Information FromKibioctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kilobit"/>.
         /// </summary>
-        public static Information FromKilobits(double value)
+        public static Information FromKilobits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Kilobit);
         }
@@ -708,7 +693,7 @@ public static Information FromKilobits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kilobyte"/>.
         /// </summary>
-        public static Information FromKilobytes(double value)
+        public static Information FromKilobytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Kilobyte);
         }
@@ -716,7 +701,7 @@ public static Information FromKilobytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kilooctet"/>.
         /// </summary>
-        public static Information FromKilooctets(double value)
+        public static Information FromKilooctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Kilooctet);
         }
@@ -724,7 +709,7 @@ public static Information FromKilooctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Mebibit"/>.
         /// </summary>
-        public static Information FromMebibits(double value)
+        public static Information FromMebibits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Mebibit);
         }
@@ -732,7 +717,7 @@ public static Information FromMebibits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Mebibyte"/>.
         /// </summary>
-        public static Information FromMebibytes(double value)
+        public static Information FromMebibytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Mebibyte);
         }
@@ -740,7 +725,7 @@ public static Information FromMebibytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Mebioctet"/>.
         /// </summary>
-        public static Information FromMebioctets(double value)
+        public static Information FromMebioctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Mebioctet);
         }
@@ -748,7 +733,7 @@ public static Information FromMebioctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Megabit"/>.
         /// </summary>
-        public static Information FromMegabits(double value)
+        public static Information FromMegabits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Megabit);
         }
@@ -756,7 +741,7 @@ public static Information FromMegabits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Megabyte"/>.
         /// </summary>
-        public static Information FromMegabytes(double value)
+        public static Information FromMegabytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Megabyte);
         }
@@ -764,7 +749,7 @@ public static Information FromMegabytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Megaoctet"/>.
         /// </summary>
-        public static Information FromMegaoctets(double value)
+        public static Information FromMegaoctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Megaoctet);
         }
@@ -772,7 +757,7 @@ public static Information FromMegaoctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Octet"/>.
         /// </summary>
-        public static Information FromOctets(double value)
+        public static Information FromOctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Octet);
         }
@@ -780,7 +765,7 @@ public static Information FromOctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Pebibit"/>.
         /// </summary>
-        public static Information FromPebibits(double value)
+        public static Information FromPebibits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Pebibit);
         }
@@ -788,7 +773,7 @@ public static Information FromPebibits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Pebibyte"/>.
         /// </summary>
-        public static Information FromPebibytes(double value)
+        public static Information FromPebibytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Pebibyte);
         }
@@ -796,7 +781,7 @@ public static Information FromPebibytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Pebioctet"/>.
         /// </summary>
-        public static Information FromPebioctets(double value)
+        public static Information FromPebioctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Pebioctet);
         }
@@ -804,7 +789,7 @@ public static Information FromPebioctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Petabit"/>.
         /// </summary>
-        public static Information FromPetabits(double value)
+        public static Information FromPetabits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Petabit);
         }
@@ -812,7 +797,7 @@ public static Information FromPetabits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Petabyte"/>.
         /// </summary>
-        public static Information FromPetabytes(double value)
+        public static Information FromPetabytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Petabyte);
         }
@@ -820,7 +805,7 @@ public static Information FromPetabytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Petaoctet"/>.
         /// </summary>
-        public static Information FromPetaoctets(double value)
+        public static Information FromPetaoctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Petaoctet);
         }
@@ -828,7 +813,7 @@ public static Information FromPetaoctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Tebibit"/>.
         /// </summary>
-        public static Information FromTebibits(double value)
+        public static Information FromTebibits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Tebibit);
         }
@@ -836,7 +821,7 @@ public static Information FromTebibits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Tebibyte"/>.
         /// </summary>
-        public static Information FromTebibytes(double value)
+        public static Information FromTebibytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Tebibyte);
         }
@@ -844,7 +829,7 @@ public static Information FromTebibytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Tebioctet"/>.
         /// </summary>
-        public static Information FromTebioctets(double value)
+        public static Information FromTebioctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Tebioctet);
         }
@@ -852,7 +837,7 @@ public static Information FromTebioctets(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Terabit"/>.
         /// </summary>
-        public static Information FromTerabits(double value)
+        public static Information FromTerabits(QuantityValue value)
         {
             return new Information(value, InformationUnit.Terabit);
         }
@@ -860,7 +845,7 @@ public static Information FromTerabits(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Terabyte"/>.
         /// </summary>
-        public static Information FromTerabytes(double value)
+        public static Information FromTerabytes(QuantityValue value)
         {
             return new Information(value, InformationUnit.Terabyte);
         }
@@ -868,7 +853,7 @@ public static Information FromTerabytes(double value)
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Teraoctet"/>.
         /// </summary>
-        public static Information FromTeraoctets(double value)
+        public static Information FromTeraoctets(QuantityValue value)
         {
             return new Information(value, InformationUnit.Teraoctet);
         }
@@ -879,7 +864,7 @@ public static Information FromTeraoctets(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Information unit value.</returns>
-        public static Information From(double value, InformationUnit fromUnit)
+        public static Information From(QuantityValue value, InformationUnit fromUnit)
         {
             return new Information(value, fromUnit);
         }
@@ -940,10 +925,7 @@ public static Information Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Information Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Information, InformationUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Information, InformationUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -971,11 +953,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Information resu
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Information result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Information, InformationUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Information, InformationUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -996,7 +974,7 @@ public static InformationUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1007,7 +985,7 @@ public static InformationUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.InformationUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.InformationUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out InformationUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1022,7 +1000,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out InformationU
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out InformationUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1041,137 +1019,173 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Information"/> from adding two <see cref="Information"/>.</summary>
         public static Information operator +(Information left, Information right)
         {
-            return new Information(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Information(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Information"/> from subtracting two <see cref="Information"/>.</summary>
         public static Information operator -(Information left, Information right)
         {
-            return new Information(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Information(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Information"/> from multiplying value and <see cref="Information"/>.</summary>
-        public static Information operator *(double left, Information right)
+        public static Information operator *(QuantityValue left, Information right)
         {
             return new Information(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Information"/> from multiplying value and <see cref="Information"/>.</summary>
-        public static Information operator *(Information left, double right)
+        public static Information operator *(Information left, QuantityValue right)
         {
             return new Information(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Information"/> from dividing <see cref="Information"/> by value.</summary>
-        public static Information operator /(Information left, double right)
+        public static Information operator /(Information left, QuantityValue right)
         {
             return new Information(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Information"/> by <see cref="Information"/>.</summary>
-        public static double operator /(Information left, Information right)
+        public static QuantityValue operator /(Information left, Information right)
         {
             return left.Bits / right.Bits;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="BitRate"/> from <see cref="Information"/> * <see cref="Frequency"/>.</summary>
+        public static BitRate operator *(Information information, Frequency frequency)
+        {
+            return BitRate.FromBitsPerSecond(information.Bits * frequency.PerSecond);
+        }
+
+        /// <summary>Get <see cref="BitRate"/> from <see cref="Information"/> / <see cref="Duration"/>.</summary>
+        public static BitRate operator /(Information information, Duration duration)
+        {
+            return BitRate.FromBitsPerSecond(information.Bits / duration.Seconds);
+        }
+
+        /// <summary>Get <see cref="Duration"/> from <see cref="Information"/> / <see cref="BitRate"/>.</summary>
+        public static Duration operator /(Information information, BitRate bitRate)
+        {
+            return Duration.FromSeconds(information.Bits / bitRate.BitsPerSecond);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Information left, Information right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Information left, Information right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Information left, Information right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Information left, Information right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Information"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Information other, Information tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Information"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Information)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Information left, Information right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Information"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Information other, Information tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Information"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Information,Information)"/>.
+        ///     See that operator (and <see cref="Equals(Information)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Information left, Information right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Information"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Information other, Information tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Information"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Information"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Information"/>, this method delegates to
+        ///     <see cref="Equals(Information)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Information otherQuantity))
+            if (obj is not Information otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Information"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Information other, Information tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Information"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Information other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Information.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Information), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Information"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Information)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Information otherQuantity)) throw new ArgumentException("Expected type Information.", nameof(obj));
+            if (obj is not Information otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Information>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Information"/> with another <see cref="Information"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Information"/> with another <see cref="Information"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1183,205 +1197,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Information other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(InformationUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<InformationUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Information to another Information with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Information with the specified unit.</returns>
-        public Information ToUnit(InformationUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="Information"/> to another <see cref="Information"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Information with the specified unit.</returns>
-        public Information ToUnit(InformationUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Information), Unit, typeof(Information), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Information)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Information"/> to another <see cref="Information"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Information"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(InformationUnit unit, [NotNullWhen(true)] out Information? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Information? convertedOrNull = (Unit, unit) switch
-            {
-                // InformationUnit -> BaseUnit
-                (InformationUnit.Byte, InformationUnit.Bit) => new Information(_value * 8, InformationUnit.Bit),
-                (InformationUnit.Exabit, InformationUnit.Bit) => new Information((_value) * 1e18d, InformationUnit.Bit),
-                (InformationUnit.Exabyte, InformationUnit.Bit) => new Information((_value * 8) * 1e18d, InformationUnit.Bit),
-                (InformationUnit.Exaoctet, InformationUnit.Bit) => new Information((_value * 8) * 1e18d, InformationUnit.Bit),
-                (InformationUnit.Exbibit, InformationUnit.Bit) => new Information((_value) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Exbibyte, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Exbioctet, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Gibibit, InformationUnit.Bit) => new Information((_value) * (1024d * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Gibibyte, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Gibioctet, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Gigabit, InformationUnit.Bit) => new Information((_value) * 1e9d, InformationUnit.Bit),
-                (InformationUnit.Gigabyte, InformationUnit.Bit) => new Information((_value * 8) * 1e9d, InformationUnit.Bit),
-                (InformationUnit.Gigaoctet, InformationUnit.Bit) => new Information((_value * 8) * 1e9d, InformationUnit.Bit),
-                (InformationUnit.Kibibit, InformationUnit.Bit) => new Information((_value) * 1024d, InformationUnit.Bit),
-                (InformationUnit.Kibibyte, InformationUnit.Bit) => new Information((_value * 8) * 1024d, InformationUnit.Bit),
-                (InformationUnit.Kibioctet, InformationUnit.Bit) => new Information((_value * 8) * 1024d, InformationUnit.Bit),
-                (InformationUnit.Kilobit, InformationUnit.Bit) => new Information((_value) * 1e3d, InformationUnit.Bit),
-                (InformationUnit.Kilobyte, InformationUnit.Bit) => new Information((_value * 8) * 1e3d, InformationUnit.Bit),
-                (InformationUnit.Kilooctet, InformationUnit.Bit) => new Information((_value * 8) * 1e3d, InformationUnit.Bit),
-                (InformationUnit.Mebibit, InformationUnit.Bit) => new Information((_value) * (1024d * 1024), InformationUnit.Bit),
-                (InformationUnit.Mebibyte, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024), InformationUnit.Bit),
-                (InformationUnit.Mebioctet, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024), InformationUnit.Bit),
-                (InformationUnit.Megabit, InformationUnit.Bit) => new Information((_value) * 1e6d, InformationUnit.Bit),
-                (InformationUnit.Megabyte, InformationUnit.Bit) => new Information((_value * 8) * 1e6d, InformationUnit.Bit),
-                (InformationUnit.Megaoctet, InformationUnit.Bit) => new Information((_value * 8) * 1e6d, InformationUnit.Bit),
-                (InformationUnit.Octet, InformationUnit.Bit) => new Information(_value * 8, InformationUnit.Bit),
-                (InformationUnit.Pebibit, InformationUnit.Bit) => new Information((_value) * (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Pebibyte, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Pebioctet, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Petabit, InformationUnit.Bit) => new Information((_value) * 1e15d, InformationUnit.Bit),
-                (InformationUnit.Petabyte, InformationUnit.Bit) => new Information((_value * 8) * 1e15d, InformationUnit.Bit),
-                (InformationUnit.Petaoctet, InformationUnit.Bit) => new Information((_value * 8) * 1e15d, InformationUnit.Bit),
-                (InformationUnit.Tebibit, InformationUnit.Bit) => new Information((_value) * (1024d * 1024 * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Tebibyte, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Tebioctet, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024), InformationUnit.Bit),
-                (InformationUnit.Terabit, InformationUnit.Bit) => new Information((_value) * 1e12d, InformationUnit.Bit),
-                (InformationUnit.Terabyte, InformationUnit.Bit) => new Information((_value * 8) * 1e12d, InformationUnit.Bit),
-                (InformationUnit.Teraoctet, InformationUnit.Bit) => new Information((_value * 8) * 1e12d, InformationUnit.Bit),
-
-                // BaseUnit -> InformationUnit
-                (InformationUnit.Bit, InformationUnit.Byte) => new Information(_value / 8, InformationUnit.Byte),
-                (InformationUnit.Bit, InformationUnit.Exabit) => new Information((_value) / 1e18d, InformationUnit.Exabit),
-                (InformationUnit.Bit, InformationUnit.Exabyte) => new Information((_value / 8) / 1e18d, InformationUnit.Exabyte),
-                (InformationUnit.Bit, InformationUnit.Exaoctet) => new Information((_value / 8) / 1e18d, InformationUnit.Exaoctet),
-                (InformationUnit.Bit, InformationUnit.Exbibit) => new Information((_value) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Exbibit),
-                (InformationUnit.Bit, InformationUnit.Exbibyte) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Exbibyte),
-                (InformationUnit.Bit, InformationUnit.Exbioctet) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Exbioctet),
-                (InformationUnit.Bit, InformationUnit.Gibibit) => new Information((_value) / (1024d * 1024 * 1024), InformationUnit.Gibibit),
-                (InformationUnit.Bit, InformationUnit.Gibibyte) => new Information((_value / 8) / (1024d * 1024 * 1024), InformationUnit.Gibibyte),
-                (InformationUnit.Bit, InformationUnit.Gibioctet) => new Information((_value / 8) / (1024d * 1024 * 1024), InformationUnit.Gibioctet),
-                (InformationUnit.Bit, InformationUnit.Gigabit) => new Information((_value) / 1e9d, InformationUnit.Gigabit),
-                (InformationUnit.Bit, InformationUnit.Gigabyte) => new Information((_value / 8) / 1e9d, InformationUnit.Gigabyte),
-                (InformationUnit.Bit, InformationUnit.Gigaoctet) => new Information((_value / 8) / 1e9d, InformationUnit.Gigaoctet),
-                (InformationUnit.Bit, InformationUnit.Kibibit) => new Information((_value) / 1024d, InformationUnit.Kibibit),
-                (InformationUnit.Bit, InformationUnit.Kibibyte) => new Information((_value / 8) / 1024d, InformationUnit.Kibibyte),
-                (InformationUnit.Bit, InformationUnit.Kibioctet) => new Information((_value / 8) / 1024d, InformationUnit.Kibioctet),
-                (InformationUnit.Bit, InformationUnit.Kilobit) => new Information((_value) / 1e3d, InformationUnit.Kilobit),
-                (InformationUnit.Bit, InformationUnit.Kilobyte) => new Information((_value / 8) / 1e3d, InformationUnit.Kilobyte),
-                (InformationUnit.Bit, InformationUnit.Kilooctet) => new Information((_value / 8) / 1e3d, InformationUnit.Kilooctet),
-                (InformationUnit.Bit, InformationUnit.Mebibit) => new Information((_value) / (1024d * 1024), InformationUnit.Mebibit),
-                (InformationUnit.Bit, InformationUnit.Mebibyte) => new Information((_value / 8) / (1024d * 1024), InformationUnit.Mebibyte),
-                (InformationUnit.Bit, InformationUnit.Mebioctet) => new Information((_value / 8) / (1024d * 1024), InformationUnit.Mebioctet),
-                (InformationUnit.Bit, InformationUnit.Megabit) => new Information((_value) / 1e6d, InformationUnit.Megabit),
-                (InformationUnit.Bit, InformationUnit.Megabyte) => new Information((_value / 8) / 1e6d, InformationUnit.Megabyte),
-                (InformationUnit.Bit, InformationUnit.Megaoctet) => new Information((_value / 8) / 1e6d, InformationUnit.Megaoctet),
-                (InformationUnit.Bit, InformationUnit.Octet) => new Information(_value / 8, InformationUnit.Octet),
-                (InformationUnit.Bit, InformationUnit.Pebibit) => new Information((_value) / (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Pebibit),
-                (InformationUnit.Bit, InformationUnit.Pebibyte) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Pebibyte),
-                (InformationUnit.Bit, InformationUnit.Pebioctet) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Pebioctet),
-                (InformationUnit.Bit, InformationUnit.Petabit) => new Information((_value) / 1e15d, InformationUnit.Petabit),
-                (InformationUnit.Bit, InformationUnit.Petabyte) => new Information((_value / 8) / 1e15d, InformationUnit.Petabyte),
-                (InformationUnit.Bit, InformationUnit.Petaoctet) => new Information((_value / 8) / 1e15d, InformationUnit.Petaoctet),
-                (InformationUnit.Bit, InformationUnit.Tebibit) => new Information((_value) / (1024d * 1024 * 1024 * 1024), InformationUnit.Tebibit),
-                (InformationUnit.Bit, InformationUnit.Tebibyte) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024), InformationUnit.Tebibyte),
-                (InformationUnit.Bit, InformationUnit.Tebioctet) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024), InformationUnit.Tebioctet),
-                (InformationUnit.Bit, InformationUnit.Terabit) => new Information((_value) / 1e12d, InformationUnit.Terabit),
-                (InformationUnit.Bit, InformationUnit.Terabyte) => new Information((_value / 8) / 1e12d, InformationUnit.Terabyte),
-                (InformationUnit.Bit, InformationUnit.Teraoctet) => new Information((_value / 8) / 1e12d, InformationUnit.Teraoctet),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not InformationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(InformationUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is InformationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(InformationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<InformationUnit> IQuantity<InformationUnit>.ToUnit(InformationUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1395,11 +1213,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
index 2807557480..affb6a176b 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     Irradiance is the intensity of ultraviolet (UV) or visible light incident on a surface.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Irradiance :
-        IArithmeticQuantity<Irradiance, IrradianceUnit>,
+        ILinearQuantity<Irradiance, IrradianceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Irradiance, Irradiance, double>,
+        IDivisionOperators<Irradiance, Irradiance, QuantityValue>,
+        IMultiplyOperators<Irradiance, Duration, Irradiation>,
         IComparisonOperators<Irradiance, Irradiance, bool>,
         IParsable<Irradiance>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static IrradianceInfo CreateDefault(Func<IEnumerable<UnitDefinition<Irrad
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Irradiance"/> is [T^-3][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Irradiance"/> is T^-3M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 1, -3, 0, 0, 0, 0);
 
@@ -117,28 +117,52 @@ public static IrradianceInfo CreateDefault(Func<IEnumerable<UnitDefinition<Irrad
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{IrradianceUnit}"/> representing the default unit mappings for Irradiance.</returns>
             public static IEnumerable<UnitDefinition<IrradianceUnit>> GetDefaultMappings()
             {
-                yield return new (IrradianceUnit.KilowattPerSquareCentimeter, "KilowattPerSquareCentimeter", "KilowattsPerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (IrradianceUnit.KilowattPerSquareMeter, "KilowattPerSquareMeter", "KilowattsPerSquareMeter", BaseUnits.Undefined);
-                yield return new (IrradianceUnit.MegawattPerSquareCentimeter, "MegawattPerSquareCentimeter", "MegawattsPerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (IrradianceUnit.MegawattPerSquareMeter, "MegawattPerSquareMeter", "MegawattsPerSquareMeter", BaseUnits.Undefined);
-                yield return new (IrradianceUnit.MicrowattPerSquareCentimeter, "MicrowattPerSquareCentimeter", "MicrowattsPerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (IrradianceUnit.MicrowattPerSquareMeter, "MicrowattPerSquareMeter", "MicrowattsPerSquareMeter", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Second));
-                yield return new (IrradianceUnit.MilliwattPerSquareCentimeter, "MilliwattPerSquareCentimeter", "MilliwattsPerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (IrradianceUnit.MilliwattPerSquareMeter, "MilliwattPerSquareMeter", "MilliwattsPerSquareMeter", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (IrradianceUnit.NanowattPerSquareCentimeter, "NanowattPerSquareCentimeter", "NanowattsPerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (IrradianceUnit.NanowattPerSquareMeter, "NanowattPerSquareMeter", "NanowattsPerSquareMeter", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Second));
-                yield return new (IrradianceUnit.PicowattPerSquareCentimeter, "PicowattPerSquareCentimeter", "PicowattsPerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (IrradianceUnit.PicowattPerSquareMeter, "PicowattPerSquareMeter", "PicowattsPerSquareMeter", new BaseUnits(mass: MassUnit.Nanogram, time: DurationUnit.Second));
-                yield return new (IrradianceUnit.WattPerSquareCentimeter, "WattPerSquareCentimeter", "WattsPerSquareCentimeter", BaseUnits.Undefined);
+                yield return new (IrradianceUnit.KilowattPerSquareCentimeter, "KilowattPerSquareCentimeter", "KilowattsPerSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000000)
+                );
+                yield return new (IrradianceUnit.KilowattPerSquareMeter, "KilowattPerSquareMeter", "KilowattsPerSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (IrradianceUnit.MegawattPerSquareCentimeter, "MegawattPerSquareCentimeter", "MegawattsPerSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000000000)
+                );
+                yield return new (IrradianceUnit.MegawattPerSquareMeter, "MegawattPerSquareMeter", "MegawattsPerSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (IrradianceUnit.MicrowattPerSquareCentimeter, "MicrowattPerSquareCentimeter", "MicrowattsPerSquareCentimeter", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (IrradianceUnit.MicrowattPerSquareMeter, "MicrowattPerSquareMeter", "MicrowattsPerSquareMeter", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (IrradianceUnit.MilliwattPerSquareCentimeter, "MilliwattPerSquareCentimeter", "MilliwattsPerSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (IrradianceUnit.MilliwattPerSquareMeter, "MilliwattPerSquareMeter", "MilliwattsPerSquareMeter", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (IrradianceUnit.NanowattPerSquareCentimeter, "NanowattPerSquareCentimeter", "NanowattsPerSquareCentimeter", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (IrradianceUnit.NanowattPerSquareMeter, "NanowattPerSquareMeter", "NanowattsPerSquareMeter", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (IrradianceUnit.PicowattPerSquareCentimeter, "PicowattPerSquareCentimeter", "PicowattsPerSquareCentimeter", BaseUnits.Undefined,
+                     100000000
+                );
+                yield return new (IrradianceUnit.PicowattPerSquareMeter, "PicowattPerSquareMeter", "PicowattsPerSquareMeter", new BaseUnits(mass: MassUnit.Nanogram, time: DurationUnit.Second),
+                     1000000000000
+                );
+                yield return new (IrradianceUnit.WattPerSquareCentimeter, "WattPerSquareCentimeter", "WattsPerSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
                 yield return new (IrradianceUnit.WattPerSquareMeter, "WattPerSquareMeter", "WattsPerSquareMeter", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second));
             }
         }
 
         static Irradiance()
         {
-            Info = IrradianceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(IrradianceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -146,7 +170,7 @@ static Irradiance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Irradiance(double value, IrradianceUnit unit)
+        public Irradiance(QuantityValue value, IrradianceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -160,7 +184,7 @@ public Irradiance(double value, IrradianceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Irradiance(double value, UnitSystem unitSystem)
+        public Irradiance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -171,7 +195,8 @@ public Irradiance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Irradiance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Irradiance, IrradianceUnit> Info { get; }
@@ -200,10 +225,8 @@ public Irradiance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public IrradianceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -237,119 +260,79 @@ public Irradiance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.KilowattPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.KilowattPerSquareCentimeter"/>
         /// </summary>
-        public double KilowattsPerSquareCentimeter => As(IrradianceUnit.KilowattPerSquareCentimeter);
+        public QuantityValue KilowattsPerSquareCentimeter => this.As(IrradianceUnit.KilowattPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.KilowattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.KilowattPerSquareMeter"/>
         /// </summary>
-        public double KilowattsPerSquareMeter => As(IrradianceUnit.KilowattPerSquareMeter);
+        public QuantityValue KilowattsPerSquareMeter => this.As(IrradianceUnit.KilowattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MegawattPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.MegawattPerSquareCentimeter"/>
         /// </summary>
-        public double MegawattsPerSquareCentimeter => As(IrradianceUnit.MegawattPerSquareCentimeter);
+        public QuantityValue MegawattsPerSquareCentimeter => this.As(IrradianceUnit.MegawattPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MegawattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.MegawattPerSquareMeter"/>
         /// </summary>
-        public double MegawattsPerSquareMeter => As(IrradianceUnit.MegawattPerSquareMeter);
+        public QuantityValue MegawattsPerSquareMeter => this.As(IrradianceUnit.MegawattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MicrowattPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.MicrowattPerSquareCentimeter"/>
         /// </summary>
-        public double MicrowattsPerSquareCentimeter => As(IrradianceUnit.MicrowattPerSquareCentimeter);
+        public QuantityValue MicrowattsPerSquareCentimeter => this.As(IrradianceUnit.MicrowattPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MicrowattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.MicrowattPerSquareMeter"/>
         /// </summary>
-        public double MicrowattsPerSquareMeter => As(IrradianceUnit.MicrowattPerSquareMeter);
+        public QuantityValue MicrowattsPerSquareMeter => this.As(IrradianceUnit.MicrowattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MilliwattPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.MilliwattPerSquareCentimeter"/>
         /// </summary>
-        public double MilliwattsPerSquareCentimeter => As(IrradianceUnit.MilliwattPerSquareCentimeter);
+        public QuantityValue MilliwattsPerSquareCentimeter => this.As(IrradianceUnit.MilliwattPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.MilliwattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.MilliwattPerSquareMeter"/>
         /// </summary>
-        public double MilliwattsPerSquareMeter => As(IrradianceUnit.MilliwattPerSquareMeter);
+        public QuantityValue MilliwattsPerSquareMeter => this.As(IrradianceUnit.MilliwattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.NanowattPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.NanowattPerSquareCentimeter"/>
         /// </summary>
-        public double NanowattsPerSquareCentimeter => As(IrradianceUnit.NanowattPerSquareCentimeter);
+        public QuantityValue NanowattsPerSquareCentimeter => this.As(IrradianceUnit.NanowattPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.NanowattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.NanowattPerSquareMeter"/>
         /// </summary>
-        public double NanowattsPerSquareMeter => As(IrradianceUnit.NanowattPerSquareMeter);
+        public QuantityValue NanowattsPerSquareMeter => this.As(IrradianceUnit.NanowattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.PicowattPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.PicowattPerSquareCentimeter"/>
         /// </summary>
-        public double PicowattsPerSquareCentimeter => As(IrradianceUnit.PicowattPerSquareCentimeter);
+        public QuantityValue PicowattsPerSquareCentimeter => this.As(IrradianceUnit.PicowattPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.PicowattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.PicowattPerSquareMeter"/>
         /// </summary>
-        public double PicowattsPerSquareMeter => As(IrradianceUnit.PicowattPerSquareMeter);
+        public QuantityValue PicowattsPerSquareMeter => this.As(IrradianceUnit.PicowattPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.WattPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.WattPerSquareCentimeter"/>
         /// </summary>
-        public double WattsPerSquareCentimeter => As(IrradianceUnit.WattPerSquareCentimeter);
+        public QuantityValue WattsPerSquareCentimeter => this.As(IrradianceUnit.WattPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradianceUnit.WattPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradianceUnit.WattPerSquareMeter"/>
         /// </summary>
-        public double WattsPerSquareMeter => As(IrradianceUnit.WattPerSquareMeter);
+        public QuantityValue WattsPerSquareMeter => this.As(IrradianceUnit.WattPerSquareMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: IrradianceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.KilowattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.KilowattPerSquareMeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MegawattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MegawattPerSquareMeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MicrowattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MicrowattPerSquareMeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MilliwattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.MilliwattPerSquareMeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.NanowattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.NanowattPerSquareMeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.PicowattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.PicowattPerSquareMeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.WattPerSquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> IrradianceUnit
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.KilowattPerSquareCentimeter, quantity => quantity.ToUnit(IrradianceUnit.KilowattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.KilowattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.KilowattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MegawattPerSquareCentimeter, quantity => quantity.ToUnit(IrradianceUnit.MegawattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MegawattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.MegawattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MicrowattPerSquareCentimeter, quantity => quantity.ToUnit(IrradianceUnit.MicrowattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MicrowattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.MicrowattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MilliwattPerSquareCentimeter, quantity => quantity.ToUnit(IrradianceUnit.MilliwattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MilliwattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.MilliwattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.NanowattPerSquareCentimeter, quantity => quantity.ToUnit(IrradianceUnit.NanowattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.NanowattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.NanowattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.PicowattPerSquareCentimeter, quantity => quantity.ToUnit(IrradianceUnit.PicowattPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.PicowattPerSquareMeter, quantity => quantity.ToUnit(IrradianceUnit.PicowattPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiance>(IrradianceUnit.WattPerSquareMeter, IrradianceUnit.WattPerSquareCentimeter, quantity => quantity.ToUnit(IrradianceUnit.WattPerSquareCentimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -378,7 +361,7 @@ public static string GetAbbreviation(IrradianceUnit unit, IFormatProvider? provi
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.KilowattPerSquareCentimeter"/>.
         /// </summary>
-        public static Irradiance FromKilowattsPerSquareCentimeter(double value)
+        public static Irradiance FromKilowattsPerSquareCentimeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.KilowattPerSquareCentimeter);
         }
@@ -386,7 +369,7 @@ public static Irradiance FromKilowattsPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.KilowattPerSquareMeter"/>.
         /// </summary>
-        public static Irradiance FromKilowattsPerSquareMeter(double value)
+        public static Irradiance FromKilowattsPerSquareMeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.KilowattPerSquareMeter);
         }
@@ -394,7 +377,7 @@ public static Irradiance FromKilowattsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MegawattPerSquareCentimeter"/>.
         /// </summary>
-        public static Irradiance FromMegawattsPerSquareCentimeter(double value)
+        public static Irradiance FromMegawattsPerSquareCentimeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.MegawattPerSquareCentimeter);
         }
@@ -402,7 +385,7 @@ public static Irradiance FromMegawattsPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MegawattPerSquareMeter"/>.
         /// </summary>
-        public static Irradiance FromMegawattsPerSquareMeter(double value)
+        public static Irradiance FromMegawattsPerSquareMeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.MegawattPerSquareMeter);
         }
@@ -410,7 +393,7 @@ public static Irradiance FromMegawattsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MicrowattPerSquareCentimeter"/>.
         /// </summary>
-        public static Irradiance FromMicrowattsPerSquareCentimeter(double value)
+        public static Irradiance FromMicrowattsPerSquareCentimeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.MicrowattPerSquareCentimeter);
         }
@@ -418,7 +401,7 @@ public static Irradiance FromMicrowattsPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MicrowattPerSquareMeter"/>.
         /// </summary>
-        public static Irradiance FromMicrowattsPerSquareMeter(double value)
+        public static Irradiance FromMicrowattsPerSquareMeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.MicrowattPerSquareMeter);
         }
@@ -426,7 +409,7 @@ public static Irradiance FromMicrowattsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MilliwattPerSquareCentimeter"/>.
         /// </summary>
-        public static Irradiance FromMilliwattsPerSquareCentimeter(double value)
+        public static Irradiance FromMilliwattsPerSquareCentimeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.MilliwattPerSquareCentimeter);
         }
@@ -434,7 +417,7 @@ public static Irradiance FromMilliwattsPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MilliwattPerSquareMeter"/>.
         /// </summary>
-        public static Irradiance FromMilliwattsPerSquareMeter(double value)
+        public static Irradiance FromMilliwattsPerSquareMeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.MilliwattPerSquareMeter);
         }
@@ -442,7 +425,7 @@ public static Irradiance FromMilliwattsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.NanowattPerSquareCentimeter"/>.
         /// </summary>
-        public static Irradiance FromNanowattsPerSquareCentimeter(double value)
+        public static Irradiance FromNanowattsPerSquareCentimeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.NanowattPerSquareCentimeter);
         }
@@ -450,7 +433,7 @@ public static Irradiance FromNanowattsPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.NanowattPerSquareMeter"/>.
         /// </summary>
-        public static Irradiance FromNanowattsPerSquareMeter(double value)
+        public static Irradiance FromNanowattsPerSquareMeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.NanowattPerSquareMeter);
         }
@@ -458,7 +441,7 @@ public static Irradiance FromNanowattsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.PicowattPerSquareCentimeter"/>.
         /// </summary>
-        public static Irradiance FromPicowattsPerSquareCentimeter(double value)
+        public static Irradiance FromPicowattsPerSquareCentimeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.PicowattPerSquareCentimeter);
         }
@@ -466,7 +449,7 @@ public static Irradiance FromPicowattsPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.PicowattPerSquareMeter"/>.
         /// </summary>
-        public static Irradiance FromPicowattsPerSquareMeter(double value)
+        public static Irradiance FromPicowattsPerSquareMeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.PicowattPerSquareMeter);
         }
@@ -474,7 +457,7 @@ public static Irradiance FromPicowattsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.WattPerSquareCentimeter"/>.
         /// </summary>
-        public static Irradiance FromWattsPerSquareCentimeter(double value)
+        public static Irradiance FromWattsPerSquareCentimeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.WattPerSquareCentimeter);
         }
@@ -482,7 +465,7 @@ public static Irradiance FromWattsPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.WattPerSquareMeter"/>.
         /// </summary>
-        public static Irradiance FromWattsPerSquareMeter(double value)
+        public static Irradiance FromWattsPerSquareMeter(QuantityValue value)
         {
             return new Irradiance(value, IrradianceUnit.WattPerSquareMeter);
         }
@@ -493,7 +476,7 @@ public static Irradiance FromWattsPerSquareMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Irradiance unit value.</returns>
-        public static Irradiance From(double value, IrradianceUnit fromUnit)
+        public static Irradiance From(QuantityValue value, IrradianceUnit fromUnit)
         {
             return new Irradiance(value, fromUnit);
         }
@@ -554,10 +537,7 @@ public static Irradiance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Irradiance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Irradiance, IrradianceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Irradiance, IrradianceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -585,11 +565,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Irradiance resul
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Irradiance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Irradiance, IrradianceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Irradiance, IrradianceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -610,7 +586,7 @@ public static IrradianceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -621,7 +597,7 @@ public static IrradianceUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.IrradianceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.IrradianceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out IrradianceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -636,7 +612,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out IrradianceUn
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out IrradianceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -655,137 +631,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Irradiance"/> from adding two <see cref="Irradiance"/>.</summary>
         public static Irradiance operator +(Irradiance left, Irradiance right)
         {
-            return new Irradiance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Irradiance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Irradiance"/> from subtracting two <see cref="Irradiance"/>.</summary>
         public static Irradiance operator -(Irradiance left, Irradiance right)
         {
-            return new Irradiance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Irradiance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Irradiance"/> from multiplying value and <see cref="Irradiance"/>.</summary>
-        public static Irradiance operator *(double left, Irradiance right)
+        public static Irradiance operator *(QuantityValue left, Irradiance right)
         {
             return new Irradiance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Irradiance"/> from multiplying value and <see cref="Irradiance"/>.</summary>
-        public static Irradiance operator *(Irradiance left, double right)
+        public static Irradiance operator *(Irradiance left, QuantityValue right)
         {
             return new Irradiance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Irradiance"/> from dividing <see cref="Irradiance"/> by value.</summary>
-        public static Irradiance operator /(Irradiance left, double right)
+        public static Irradiance operator /(Irradiance left, QuantityValue right)
         {
             return new Irradiance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Irradiance"/> by <see cref="Irradiance"/>.</summary>
-        public static double operator /(Irradiance left, Irradiance right)
+        public static QuantityValue operator /(Irradiance left, Irradiance right)
         {
             return left.WattsPerSquareMeter / right.WattsPerSquareMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Irradiation"/> from <see cref="Irradiance"/> * <see cref="Duration"/>.</summary>
+        public static Irradiation operator *(Irradiance irradiance, Duration duration)
+        {
+            return Irradiation.FromJoulesPerSquareMeter(irradiance.WattsPerSquareMeter * duration.Seconds);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Irradiance left, Irradiance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Irradiance left, Irradiance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Irradiance left, Irradiance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Irradiance left, Irradiance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Irradiance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Irradiance other, Irradiance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Irradiance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Irradiance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Irradiance left, Irradiance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Irradiance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Irradiance other, Irradiance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Irradiance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Irradiance,Irradiance)"/>.
+        ///     See that operator (and <see cref="Equals(Irradiance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Irradiance left, Irradiance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Irradiance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Irradiance other, Irradiance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Irradiance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Irradiance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Irradiance"/>, this method delegates to
+        ///     <see cref="Equals(Irradiance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Irradiance otherQuantity))
+            if (obj is not Irradiance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Irradiance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Irradiance other, Irradiance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Irradiance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Irradiance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Irradiance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Irradiance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Irradiance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Irradiance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Irradiance otherQuantity)) throw new ArgumentException("Expected type Irradiance.", nameof(obj));
+            if (obj is not Irradiance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Irradiance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Irradiance"/> with another <see cref="Irradiance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Irradiance"/> with another <see cref="Irradiance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -797,155 +797,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Irradiance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(IrradianceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<IrradianceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Irradiance to another Irradiance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Irradiance with the specified unit.</returns>
-        public Irradiance ToUnit(IrradianceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Irradiance"/> to another <see cref="Irradiance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Irradiance with the specified unit.</returns>
-        public Irradiance ToUnit(IrradianceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Irradiance), Unit, typeof(Irradiance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Irradiance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Irradiance"/> to another <see cref="Irradiance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Irradiance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(IrradianceUnit unit, [NotNullWhen(true)] out Irradiance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Irradiance? convertedOrNull = (Unit, unit) switch
-            {
-                // IrradianceUnit -> BaseUnit
-                (IrradianceUnit.KilowattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value * 10000) * 1e3d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.KilowattPerSquareMeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value) * 1e3d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.MegawattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value * 10000) * 1e6d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.MegawattPerSquareMeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value) * 1e6d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.MicrowattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value * 10000) * 1e-6d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.MicrowattPerSquareMeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value) * 1e-6d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.MilliwattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value * 10000) * 1e-3d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.MilliwattPerSquareMeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value) * 1e-3d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.NanowattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value * 10000) * 1e-9d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.NanowattPerSquareMeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value) * 1e-9d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.PicowattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value * 10000) * 1e-12d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.PicowattPerSquareMeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance((_value) * 1e-12d, IrradianceUnit.WattPerSquareMeter),
-                (IrradianceUnit.WattPerSquareCentimeter, IrradianceUnit.WattPerSquareMeter) => new Irradiance(_value * 10000, IrradianceUnit.WattPerSquareMeter),
-
-                // BaseUnit -> IrradianceUnit
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.KilowattPerSquareCentimeter) => new Irradiance((_value * 0.0001) / 1e3d, IrradianceUnit.KilowattPerSquareCentimeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.KilowattPerSquareMeter) => new Irradiance((_value) / 1e3d, IrradianceUnit.KilowattPerSquareMeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MegawattPerSquareCentimeter) => new Irradiance((_value * 0.0001) / 1e6d, IrradianceUnit.MegawattPerSquareCentimeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MegawattPerSquareMeter) => new Irradiance((_value) / 1e6d, IrradianceUnit.MegawattPerSquareMeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MicrowattPerSquareCentimeter) => new Irradiance((_value * 0.0001) / 1e-6d, IrradianceUnit.MicrowattPerSquareCentimeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MicrowattPerSquareMeter) => new Irradiance((_value) / 1e-6d, IrradianceUnit.MicrowattPerSquareMeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MilliwattPerSquareCentimeter) => new Irradiance((_value * 0.0001) / 1e-3d, IrradianceUnit.MilliwattPerSquareCentimeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.MilliwattPerSquareMeter) => new Irradiance((_value) / 1e-3d, IrradianceUnit.MilliwattPerSquareMeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.NanowattPerSquareCentimeter) => new Irradiance((_value * 0.0001) / 1e-9d, IrradianceUnit.NanowattPerSquareCentimeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.NanowattPerSquareMeter) => new Irradiance((_value) / 1e-9d, IrradianceUnit.NanowattPerSquareMeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.PicowattPerSquareCentimeter) => new Irradiance((_value * 0.0001) / 1e-12d, IrradianceUnit.PicowattPerSquareCentimeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.PicowattPerSquareMeter) => new Irradiance((_value) / 1e-12d, IrradianceUnit.PicowattPerSquareMeter),
-                (IrradianceUnit.WattPerSquareMeter, IrradianceUnit.WattPerSquareCentimeter) => new Irradiance(_value * 0.0001, IrradianceUnit.WattPerSquareCentimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not IrradianceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradianceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is IrradianceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradianceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<IrradianceUnit> IQuantity<IrradianceUnit>.ToUnit(IrradianceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -959,11 +813,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
index d16db7fef3..8bde6cb308 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,14 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Irradiation
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Irradiation :
-        IArithmeticQuantity<Irradiation, IrradiationUnit>,
+        ILinearQuantity<Irradiation, IrradiationUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Irradiation, Irradiation, double>,
+        IDivisionOperators<Irradiation, Irradiation, QuantityValue>,
+        IDivisionOperators<Irradiation, Irradiance, Duration>,
+        IDivisionOperators<Irradiation, Duration, Irradiance>,
         IComparisonOperators<Irradiation, Irradiation, bool>,
         IParsable<Irradiation>,
 #endif
@@ -55,7 +56,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +106,7 @@ public static IrradiationInfo CreateDefault(Func<IEnumerable<UnitDefinition<Irra
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Irradiation"/> is [T^-2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Irradiation"/> is T^-2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 1, -2, 0, 0, 0, 0);
 
@@ -120,23 +121,37 @@ public static IrradiationInfo CreateDefault(Func<IEnumerable<UnitDefinition<Irra
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{IrradiationUnit}"/> representing the default unit mappings for Irradiation.</returns>
             public static IEnumerable<UnitDefinition<IrradiationUnit>> GetDefaultMappings()
             {
-                yield return new (IrradiationUnit.BtuPerSquareFoot, "BtuPerSquareFoot", "BtusPerSquareFoot", BaseUnits.Undefined);
-                yield return new (IrradiationUnit.JoulePerSquareCentimeter, "JoulePerSquareCentimeter", "JoulesPerSquareCentimeter", BaseUnits.Undefined);
+                yield return new (IrradiationUnit.BtuPerSquareFoot, "BtuPerSquareFoot", "BtusPerSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(4645152, 52752792631)
+                );
+                yield return new (IrradiationUnit.JoulePerSquareCentimeter, "JoulePerSquareCentimeter", "JoulesPerSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
                 yield return new (IrradiationUnit.JoulePerSquareMeter, "JoulePerSquareMeter", "JoulesPerSquareMeter", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (IrradiationUnit.JoulePerSquareMillimeter, "JoulePerSquareMillimeter", "JoulesPerSquareMillimeter", BaseUnits.Undefined);
-                yield return new (IrradiationUnit.KilobtuPerSquareFoot, "KilobtuPerSquareFoot", "KilobtusPerSquareFoot", BaseUnits.Undefined);
-                yield return new (IrradiationUnit.KilojoulePerSquareMeter, "KilojoulePerSquareMeter", "KilojoulesPerSquareMeter", BaseUnits.Undefined);
-                yield return new (IrradiationUnit.KilowattHourPerSquareMeter, "KilowattHourPerSquareMeter", "KilowattHoursPerSquareMeter", BaseUnits.Undefined);
-                yield return new (IrradiationUnit.MillijoulePerSquareCentimeter, "MillijoulePerSquareCentimeter", "MillijoulesPerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (IrradiationUnit.WattHourPerSquareMeter, "WattHourPerSquareMeter", "WattHoursPerSquareMeter", BaseUnits.Undefined);
+                yield return new (IrradiationUnit.JoulePerSquareMillimeter, "JoulePerSquareMillimeter", "JoulesPerSquareMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (IrradiationUnit.KilobtuPerSquareFoot, "KilobtuPerSquareFoot", "KilobtusPerSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(580644, 6594099078875)
+                );
+                yield return new (IrradiationUnit.KilojoulePerSquareMeter, "KilojoulePerSquareMeter", "KilojoulesPerSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (IrradiationUnit.KilowattHourPerSquareMeter, "KilowattHourPerSquareMeter", "KilowattHoursPerSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000)
+                );
+                yield return new (IrradiationUnit.MillijoulePerSquareCentimeter, "MillijoulePerSquareCentimeter", "MillijoulesPerSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (IrradiationUnit.WattHourPerSquareMeter, "WattHourPerSquareMeter", "WattHoursPerSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600)
+                );
             }
         }
 
         static Irradiation()
         {
-            Info = IrradiationInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(IrradiationInfo.CreateDefault);
         }
 
         /// <summary>
@@ -144,7 +159,7 @@ static Irradiation()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Irradiation(double value, IrradiationUnit unit)
+        public Irradiation(QuantityValue value, IrradiationUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -158,7 +173,7 @@ public Irradiation(double value, IrradiationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Irradiation(double value, UnitSystem unitSystem)
+        public Irradiation(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -169,7 +184,8 @@ public Irradiation(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Irradiation" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Irradiation, IrradiationUnit> Info { get; }
@@ -198,10 +214,8 @@ public Irradiation(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public IrradiationUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -235,84 +249,54 @@ public Irradiation(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.BtuPerSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradiationUnit.BtuPerSquareFoot"/>
         /// </summary>
-        public double BtusPerSquareFoot => As(IrradiationUnit.BtuPerSquareFoot);
+        public QuantityValue BtusPerSquareFoot => this.As(IrradiationUnit.BtuPerSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.JoulePerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradiationUnit.JoulePerSquareCentimeter"/>
         /// </summary>
-        public double JoulesPerSquareCentimeter => As(IrradiationUnit.JoulePerSquareCentimeter);
+        public QuantityValue JoulesPerSquareCentimeter => this.As(IrradiationUnit.JoulePerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.JoulePerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradiationUnit.JoulePerSquareMeter"/>
         /// </summary>
-        public double JoulesPerSquareMeter => As(IrradiationUnit.JoulePerSquareMeter);
+        public QuantityValue JoulesPerSquareMeter => this.As(IrradiationUnit.JoulePerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.JoulePerSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradiationUnit.JoulePerSquareMillimeter"/>
         /// </summary>
-        public double JoulesPerSquareMillimeter => As(IrradiationUnit.JoulePerSquareMillimeter);
+        public QuantityValue JoulesPerSquareMillimeter => this.As(IrradiationUnit.JoulePerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.KilobtuPerSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradiationUnit.KilobtuPerSquareFoot"/>
         /// </summary>
-        public double KilobtusPerSquareFoot => As(IrradiationUnit.KilobtuPerSquareFoot);
+        public QuantityValue KilobtusPerSquareFoot => this.As(IrradiationUnit.KilobtuPerSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.KilojoulePerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradiationUnit.KilojoulePerSquareMeter"/>
         /// </summary>
-        public double KilojoulesPerSquareMeter => As(IrradiationUnit.KilojoulePerSquareMeter);
+        public QuantityValue KilojoulesPerSquareMeter => this.As(IrradiationUnit.KilojoulePerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.KilowattHourPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradiationUnit.KilowattHourPerSquareMeter"/>
         /// </summary>
-        public double KilowattHoursPerSquareMeter => As(IrradiationUnit.KilowattHourPerSquareMeter);
+        public QuantityValue KilowattHoursPerSquareMeter => this.As(IrradiationUnit.KilowattHourPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.MillijoulePerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradiationUnit.MillijoulePerSquareCentimeter"/>
         /// </summary>
-        public double MillijoulesPerSquareCentimeter => As(IrradiationUnit.MillijoulePerSquareCentimeter);
+        public QuantityValue MillijoulesPerSquareCentimeter => this.As(IrradiationUnit.MillijoulePerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="IrradiationUnit.WattHourPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="IrradiationUnit.WattHourPerSquareMeter"/>
         /// </summary>
-        public double WattHoursPerSquareMeter => As(IrradiationUnit.WattHourPerSquareMeter);
+        public QuantityValue WattHoursPerSquareMeter => this.As(IrradiationUnit.WattHourPerSquareMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: IrradiationUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.BtuPerSquareFoot, IrradiationUnit.JoulePerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.JoulePerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareCentimeter, IrradiationUnit.JoulePerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.JoulePerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMillimeter, IrradiationUnit.JoulePerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.JoulePerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.KilobtuPerSquareFoot, IrradiationUnit.JoulePerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.JoulePerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.KilojoulePerSquareMeter, IrradiationUnit.JoulePerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.JoulePerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.KilowattHourPerSquareMeter, IrradiationUnit.JoulePerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.JoulePerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.MillijoulePerSquareCentimeter, IrradiationUnit.JoulePerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.JoulePerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.WattHourPerSquareMeter, IrradiationUnit.JoulePerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.JoulePerSquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.JoulePerSquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> IrradiationUnit
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.BtuPerSquareFoot, quantity => quantity.ToUnit(IrradiationUnit.BtuPerSquareFoot));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.JoulePerSquareCentimeter, quantity => quantity.ToUnit(IrradiationUnit.JoulePerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.JoulePerSquareMillimeter, quantity => quantity.ToUnit(IrradiationUnit.JoulePerSquareMillimeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.KilobtuPerSquareFoot, quantity => quantity.ToUnit(IrradiationUnit.KilobtuPerSquareFoot));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.KilojoulePerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.KilojoulePerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.KilowattHourPerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.KilowattHourPerSquareMeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.MillijoulePerSquareCentimeter, quantity => quantity.ToUnit(IrradiationUnit.MillijoulePerSquareCentimeter));
-            unitConverter.SetConversionFunction<Irradiation>(IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.WattHourPerSquareMeter, quantity => quantity.ToUnit(IrradiationUnit.WattHourPerSquareMeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -341,7 +325,7 @@ public static string GetAbbreviation(IrradiationUnit unit, IFormatProvider? prov
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.BtuPerSquareFoot"/>.
         /// </summary>
-        public static Irradiation FromBtusPerSquareFoot(double value)
+        public static Irradiation FromBtusPerSquareFoot(QuantityValue value)
         {
             return new Irradiation(value, IrradiationUnit.BtuPerSquareFoot);
         }
@@ -349,7 +333,7 @@ public static Irradiation FromBtusPerSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareCentimeter"/>.
         /// </summary>
-        public static Irradiation FromJoulesPerSquareCentimeter(double value)
+        public static Irradiation FromJoulesPerSquareCentimeter(QuantityValue value)
         {
             return new Irradiation(value, IrradiationUnit.JoulePerSquareCentimeter);
         }
@@ -357,7 +341,7 @@ public static Irradiation FromJoulesPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareMeter"/>.
         /// </summary>
-        public static Irradiation FromJoulesPerSquareMeter(double value)
+        public static Irradiation FromJoulesPerSquareMeter(QuantityValue value)
         {
             return new Irradiation(value, IrradiationUnit.JoulePerSquareMeter);
         }
@@ -365,7 +349,7 @@ public static Irradiation FromJoulesPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareMillimeter"/>.
         /// </summary>
-        public static Irradiation FromJoulesPerSquareMillimeter(double value)
+        public static Irradiation FromJoulesPerSquareMillimeter(QuantityValue value)
         {
             return new Irradiation(value, IrradiationUnit.JoulePerSquareMillimeter);
         }
@@ -373,7 +357,7 @@ public static Irradiation FromJoulesPerSquareMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.KilobtuPerSquareFoot"/>.
         /// </summary>
-        public static Irradiation FromKilobtusPerSquareFoot(double value)
+        public static Irradiation FromKilobtusPerSquareFoot(QuantityValue value)
         {
             return new Irradiation(value, IrradiationUnit.KilobtuPerSquareFoot);
         }
@@ -381,7 +365,7 @@ public static Irradiation FromKilobtusPerSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.KilojoulePerSquareMeter"/>.
         /// </summary>
-        public static Irradiation FromKilojoulesPerSquareMeter(double value)
+        public static Irradiation FromKilojoulesPerSquareMeter(QuantityValue value)
         {
             return new Irradiation(value, IrradiationUnit.KilojoulePerSquareMeter);
         }
@@ -389,7 +373,7 @@ public static Irradiation FromKilojoulesPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.KilowattHourPerSquareMeter"/>.
         /// </summary>
-        public static Irradiation FromKilowattHoursPerSquareMeter(double value)
+        public static Irradiation FromKilowattHoursPerSquareMeter(QuantityValue value)
         {
             return new Irradiation(value, IrradiationUnit.KilowattHourPerSquareMeter);
         }
@@ -397,7 +381,7 @@ public static Irradiation FromKilowattHoursPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.MillijoulePerSquareCentimeter"/>.
         /// </summary>
-        public static Irradiation FromMillijoulesPerSquareCentimeter(double value)
+        public static Irradiation FromMillijoulesPerSquareCentimeter(QuantityValue value)
         {
             return new Irradiation(value, IrradiationUnit.MillijoulePerSquareCentimeter);
         }
@@ -405,7 +389,7 @@ public static Irradiation FromMillijoulesPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.WattHourPerSquareMeter"/>.
         /// </summary>
-        public static Irradiation FromWattHoursPerSquareMeter(double value)
+        public static Irradiation FromWattHoursPerSquareMeter(QuantityValue value)
         {
             return new Irradiation(value, IrradiationUnit.WattHourPerSquareMeter);
         }
@@ -416,7 +400,7 @@ public static Irradiation FromWattHoursPerSquareMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Irradiation unit value.</returns>
-        public static Irradiation From(double value, IrradiationUnit fromUnit)
+        public static Irradiation From(QuantityValue value, IrradiationUnit fromUnit)
         {
             return new Irradiation(value, fromUnit);
         }
@@ -477,10 +461,7 @@ public static Irradiation Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Irradiation Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Irradiation, IrradiationUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Irradiation, IrradiationUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -508,11 +489,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Irradiation resu
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Irradiation result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Irradiation, IrradiationUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Irradiation, IrradiationUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -533,7 +510,7 @@ public static IrradiationUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -544,7 +521,7 @@ public static IrradiationUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.IrradiationUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.IrradiationUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out IrradiationUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -559,7 +536,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out IrradiationU
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out IrradiationUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -578,137 +555,167 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Irradiation"/> from adding two <see cref="Irradiation"/>.</summary>
         public static Irradiation operator +(Irradiation left, Irradiation right)
         {
-            return new Irradiation(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Irradiation(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Irradiation"/> from subtracting two <see cref="Irradiation"/>.</summary>
         public static Irradiation operator -(Irradiation left, Irradiation right)
         {
-            return new Irradiation(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Irradiation(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Irradiation"/> from multiplying value and <see cref="Irradiation"/>.</summary>
-        public static Irradiation operator *(double left, Irradiation right)
+        public static Irradiation operator *(QuantityValue left, Irradiation right)
         {
             return new Irradiation(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Irradiation"/> from multiplying value and <see cref="Irradiation"/>.</summary>
-        public static Irradiation operator *(Irradiation left, double right)
+        public static Irradiation operator *(Irradiation left, QuantityValue right)
         {
             return new Irradiation(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Irradiation"/> from dividing <see cref="Irradiation"/> by value.</summary>
-        public static Irradiation operator /(Irradiation left, double right)
+        public static Irradiation operator /(Irradiation left, QuantityValue right)
         {
             return new Irradiation(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Irradiation"/> by <see cref="Irradiation"/>.</summary>
-        public static double operator /(Irradiation left, Irradiation right)
+        public static QuantityValue operator /(Irradiation left, Irradiation right)
         {
             return left.JoulesPerSquareMeter / right.JoulesPerSquareMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Duration"/> from <see cref="Irradiation"/> / <see cref="Irradiance"/>.</summary>
+        public static Duration operator /(Irradiation irradiation, Irradiance irradiance)
+        {
+            return Duration.FromSeconds(irradiation.JoulesPerSquareMeter / irradiance.WattsPerSquareMeter);
+        }
+
+        /// <summary>Get <see cref="Irradiance"/> from <see cref="Irradiation"/> / <see cref="Duration"/>.</summary>
+        public static Irradiance operator /(Irradiation irradiation, Duration duration)
+        {
+            return Irradiance.FromWattsPerSquareMeter(irradiation.JoulesPerSquareMeter / duration.Seconds);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Irradiation left, Irradiation right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Irradiation left, Irradiation right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Irradiation left, Irradiation right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Irradiation left, Irradiation right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Irradiation"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Irradiation other, Irradiation tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Irradiation"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Irradiation)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Irradiation left, Irradiation right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Irradiation"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Irradiation other, Irradiation tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Irradiation"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Irradiation,Irradiation)"/>.
+        ///     See that operator (and <see cref="Equals(Irradiation)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Irradiation left, Irradiation right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Irradiation"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Irradiation other, Irradiation tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Irradiation"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Irradiation"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Irradiation"/>, this method delegates to
+        ///     <see cref="Equals(Irradiation)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Irradiation otherQuantity))
+            if (obj is not Irradiation otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Irradiation"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Irradiation other, Irradiation tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Irradiation"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Irradiation other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Irradiation.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Irradiation), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Irradiation"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Irradiation)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Irradiation otherQuantity)) throw new ArgumentException("Expected type Irradiation.", nameof(obj));
+            if (obj is not Irradiation otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Irradiation>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Irradiation"/> with another <see cref="Irradiation"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Irradiation"/> with another <see cref="Irradiation"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -720,145 +727,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Irradiation other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(IrradiationUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<IrradiationUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Irradiation to another Irradiation with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Irradiation with the specified unit.</returns>
-        public Irradiation ToUnit(IrradiationUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Irradiation"/> to another <see cref="Irradiation"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Irradiation with the specified unit.</returns>
-        public Irradiation ToUnit(IrradiationUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Irradiation), Unit, typeof(Irradiation), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Irradiation)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Irradiation"/> to another <see cref="Irradiation"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Irradiation"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(IrradiationUnit unit, [NotNullWhen(true)] out Irradiation? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Irradiation? convertedOrNull = (Unit, unit) switch
-            {
-                // IrradiationUnit -> BaseUnit
-                (IrradiationUnit.BtuPerSquareFoot, IrradiationUnit.JoulePerSquareMeter) => new Irradiation(_value * 1055.05585262 / 9.290304e-2, IrradiationUnit.JoulePerSquareMeter),
-                (IrradiationUnit.JoulePerSquareCentimeter, IrradiationUnit.JoulePerSquareMeter) => new Irradiation(_value * 1e4, IrradiationUnit.JoulePerSquareMeter),
-                (IrradiationUnit.JoulePerSquareMillimeter, IrradiationUnit.JoulePerSquareMeter) => new Irradiation(_value * 1e6, IrradiationUnit.JoulePerSquareMeter),
-                (IrradiationUnit.KilobtuPerSquareFoot, IrradiationUnit.JoulePerSquareMeter) => new Irradiation((_value * 1055.05585262 / 9.290304e-2) * 1e3d, IrradiationUnit.JoulePerSquareMeter),
-                (IrradiationUnit.KilojoulePerSquareMeter, IrradiationUnit.JoulePerSquareMeter) => new Irradiation((_value) * 1e3d, IrradiationUnit.JoulePerSquareMeter),
-                (IrradiationUnit.KilowattHourPerSquareMeter, IrradiationUnit.JoulePerSquareMeter) => new Irradiation((_value * 3600d) * 1e3d, IrradiationUnit.JoulePerSquareMeter),
-                (IrradiationUnit.MillijoulePerSquareCentimeter, IrradiationUnit.JoulePerSquareMeter) => new Irradiation((_value * 1e4) * 1e-3d, IrradiationUnit.JoulePerSquareMeter),
-                (IrradiationUnit.WattHourPerSquareMeter, IrradiationUnit.JoulePerSquareMeter) => new Irradiation(_value * 3600d, IrradiationUnit.JoulePerSquareMeter),
-
-                // BaseUnit -> IrradiationUnit
-                (IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.BtuPerSquareFoot) => new Irradiation(_value * 9.290304e-2 / 1055.05585262, IrradiationUnit.BtuPerSquareFoot),
-                (IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.JoulePerSquareCentimeter) => new Irradiation(_value / 1e4, IrradiationUnit.JoulePerSquareCentimeter),
-                (IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.JoulePerSquareMillimeter) => new Irradiation(_value / 1e6, IrradiationUnit.JoulePerSquareMillimeter),
-                (IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.KilobtuPerSquareFoot) => new Irradiation((_value * 9.290304e-2 / 1055.05585262) / 1e3d, IrradiationUnit.KilobtuPerSquareFoot),
-                (IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.KilojoulePerSquareMeter) => new Irradiation((_value) / 1e3d, IrradiationUnit.KilojoulePerSquareMeter),
-                (IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.KilowattHourPerSquareMeter) => new Irradiation((_value / 3600d) / 1e3d, IrradiationUnit.KilowattHourPerSquareMeter),
-                (IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.MillijoulePerSquareCentimeter) => new Irradiation((_value / 1e4) / 1e-3d, IrradiationUnit.MillijoulePerSquareCentimeter),
-                (IrradiationUnit.JoulePerSquareMeter, IrradiationUnit.WattHourPerSquareMeter) => new Irradiation(_value / 3600d, IrradiationUnit.WattHourPerSquareMeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not IrradiationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradiationUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is IrradiationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradiationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<IrradiationUnit> IQuantity<IrradiationUnit>.ToUnit(IrradiationUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -872,11 +743,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs b/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
index ac104b30b8..29d40527a4 100644
--- a/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Jerk :
-        IArithmeticQuantity<Jerk, JerkUnit>,
+        ILinearQuantity<Jerk, JerkUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Jerk, Jerk, double>,
+        IDivisionOperators<Jerk, Jerk, QuantityValue>,
         IMultiplyOperators<Jerk, Duration, Acceleration>,
         IComparisonOperators<Jerk, Jerk, bool>,
         IParsable<Jerk>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static JerkInfo CreateDefault(Func<IEnumerable<UnitDefinition<JerkUnit>>,
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Jerk"/> is [T^-3][L].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Jerk"/> is T^-3L.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 0, -3, 0, 0, 0, 0);
 
@@ -118,25 +117,43 @@ public static JerkInfo CreateDefault(Func<IEnumerable<UnitDefinition<JerkUnit>>,
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{JerkUnit}"/> representing the default unit mappings for Jerk.</returns>
             public static IEnumerable<UnitDefinition<JerkUnit>> GetDefaultMappings()
             {
-                yield return new (JerkUnit.CentimeterPerSecondCubed, "CentimeterPerSecondCubed", "CentimetersPerSecondCubed", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Second));
-                yield return new (JerkUnit.DecimeterPerSecondCubed, "DecimeterPerSecondCubed", "DecimetersPerSecondCubed", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Second));
-                yield return new (JerkUnit.FootPerSecondCubed, "FootPerSecondCubed", "FeetPerSecondCubed", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second));
-                yield return new (JerkUnit.InchPerSecondCubed, "InchPerSecondCubed", "InchesPerSecondCubed", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Second));
-                yield return new (JerkUnit.KilometerPerSecondCubed, "KilometerPerSecondCubed", "KilometersPerSecondCubed", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second));
+                yield return new (JerkUnit.CentimeterPerSecondCubed, "CentimeterPerSecondCubed", "CentimetersPerSecondCubed", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Second),
+                     100
+                );
+                yield return new (JerkUnit.DecimeterPerSecondCubed, "DecimeterPerSecondCubed", "DecimetersPerSecondCubed", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (JerkUnit.FootPerSecondCubed, "FootPerSecondCubed", "FeetPerSecondCubed", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second),
+                     new QuantityValue(1250, 381)
+                );
+                yield return new (JerkUnit.InchPerSecondCubed, "InchPerSecondCubed", "InchesPerSecondCubed", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Second),
+                     new QuantityValue(5000, 127)
+                );
+                yield return new (JerkUnit.KilometerPerSecondCubed, "KilometerPerSecondCubed", "KilometersPerSecondCubed", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
                 yield return new (JerkUnit.MeterPerSecondCubed, "MeterPerSecondCubed", "MetersPerSecondCubed", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (JerkUnit.MicrometerPerSecondCubed, "MicrometerPerSecondCubed", "MicrometersPerSecondCubed", new BaseUnits(length: LengthUnit.Micrometer, time: DurationUnit.Second));
-                yield return new (JerkUnit.MillimeterPerSecondCubed, "MillimeterPerSecondCubed", "MillimetersPerSecondCubed", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second));
-                yield return new (JerkUnit.MillistandardGravitiesPerSecond, "MillistandardGravitiesPerSecond", "MillistandardGravitiesPerSecond", BaseUnits.Undefined);
-                yield return new (JerkUnit.NanometerPerSecondCubed, "NanometerPerSecondCubed", "NanometersPerSecondCubed", new BaseUnits(length: LengthUnit.Nanometer, time: DurationUnit.Second));
-                yield return new (JerkUnit.StandardGravitiesPerSecond, "StandardGravitiesPerSecond", "StandardGravitiesPerSecond", BaseUnits.Undefined);
+                yield return new (JerkUnit.MicrometerPerSecondCubed, "MicrometerPerSecondCubed", "MicrometersPerSecondCubed", new BaseUnits(length: LengthUnit.Micrometer, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (JerkUnit.MillimeterPerSecondCubed, "MillimeterPerSecondCubed", "MillimetersPerSecondCubed", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (JerkUnit.MillistandardGravitiesPerSecond, "MillistandardGravitiesPerSecond", "MillistandardGravitiesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(20000000, 196133)
+                );
+                yield return new (JerkUnit.NanometerPerSecondCubed, "NanometerPerSecondCubed", "NanometersPerSecondCubed", new BaseUnits(length: LengthUnit.Nanometer, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (JerkUnit.StandardGravitiesPerSecond, "StandardGravitiesPerSecond", "StandardGravitiesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(20000, 196133)
+                );
             }
         }
 
         static Jerk()
         {
-            Info = JerkInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(JerkInfo.CreateDefault);
         }
 
         /// <summary>
@@ -144,7 +161,7 @@ static Jerk()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Jerk(double value, JerkUnit unit)
+        public Jerk(QuantityValue value, JerkUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -158,7 +175,7 @@ public Jerk(double value, JerkUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Jerk(double value, UnitSystem unitSystem)
+        public Jerk(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -169,7 +186,8 @@ public Jerk(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Jerk" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Jerk, JerkUnit> Info { get; }
@@ -198,10 +216,8 @@ public Jerk(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public JerkUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -235,98 +251,64 @@ public Jerk(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.CentimeterPerSecondCubed"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.CentimeterPerSecondCubed"/>
         /// </summary>
-        public double CentimetersPerSecondCubed => As(JerkUnit.CentimeterPerSecondCubed);
+        public QuantityValue CentimetersPerSecondCubed => this.As(JerkUnit.CentimeterPerSecondCubed);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.DecimeterPerSecondCubed"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.DecimeterPerSecondCubed"/>
         /// </summary>
-        public double DecimetersPerSecondCubed => As(JerkUnit.DecimeterPerSecondCubed);
+        public QuantityValue DecimetersPerSecondCubed => this.As(JerkUnit.DecimeterPerSecondCubed);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.FootPerSecondCubed"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.FootPerSecondCubed"/>
         /// </summary>
-        public double FeetPerSecondCubed => As(JerkUnit.FootPerSecondCubed);
+        public QuantityValue FeetPerSecondCubed => this.As(JerkUnit.FootPerSecondCubed);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.InchPerSecondCubed"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.InchPerSecondCubed"/>
         /// </summary>
-        public double InchesPerSecondCubed => As(JerkUnit.InchPerSecondCubed);
+        public QuantityValue InchesPerSecondCubed => this.As(JerkUnit.InchPerSecondCubed);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.KilometerPerSecondCubed"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.KilometerPerSecondCubed"/>
         /// </summary>
-        public double KilometersPerSecondCubed => As(JerkUnit.KilometerPerSecondCubed);
+        public QuantityValue KilometersPerSecondCubed => this.As(JerkUnit.KilometerPerSecondCubed);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.MeterPerSecondCubed"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.MeterPerSecondCubed"/>
         /// </summary>
-        public double MetersPerSecondCubed => As(JerkUnit.MeterPerSecondCubed);
+        public QuantityValue MetersPerSecondCubed => this.As(JerkUnit.MeterPerSecondCubed);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.MicrometerPerSecondCubed"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.MicrometerPerSecondCubed"/>
         /// </summary>
-        public double MicrometersPerSecondCubed => As(JerkUnit.MicrometerPerSecondCubed);
+        public QuantityValue MicrometersPerSecondCubed => this.As(JerkUnit.MicrometerPerSecondCubed);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.MillimeterPerSecondCubed"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.MillimeterPerSecondCubed"/>
         /// </summary>
-        public double MillimetersPerSecondCubed => As(JerkUnit.MillimeterPerSecondCubed);
+        public QuantityValue MillimetersPerSecondCubed => this.As(JerkUnit.MillimeterPerSecondCubed);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.MillistandardGravitiesPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.MillistandardGravitiesPerSecond"/>
         /// </summary>
-        public double MillistandardGravitiesPerSecond => As(JerkUnit.MillistandardGravitiesPerSecond);
+        public QuantityValue MillistandardGravitiesPerSecond => this.As(JerkUnit.MillistandardGravitiesPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.NanometerPerSecondCubed"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.NanometerPerSecondCubed"/>
         /// </summary>
-        public double NanometersPerSecondCubed => As(JerkUnit.NanometerPerSecondCubed);
+        public QuantityValue NanometersPerSecondCubed => this.As(JerkUnit.NanometerPerSecondCubed);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="JerkUnit.StandardGravitiesPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="JerkUnit.StandardGravitiesPerSecond"/>
         /// </summary>
-        public double StandardGravitiesPerSecond => As(JerkUnit.StandardGravitiesPerSecond);
+        public QuantityValue StandardGravitiesPerSecond => this.As(JerkUnit.StandardGravitiesPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: JerkUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.CentimeterPerSecondCubed, JerkUnit.MeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.DecimeterPerSecondCubed, JerkUnit.MeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.FootPerSecondCubed, JerkUnit.MeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.InchPerSecondCubed, JerkUnit.MeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.KilometerPerSecondCubed, JerkUnit.MeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MicrometerPerSecondCubed, JerkUnit.MeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MillimeterPerSecondCubed, JerkUnit.MeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MillistandardGravitiesPerSecond, JerkUnit.MeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.NanometerPerSecondCubed, JerkUnit.MeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.StandardGravitiesPerSecond, JerkUnit.MeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MeterPerSecondCubed));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.MeterPerSecondCubed, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> JerkUnit
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.CentimeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.CentimeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.DecimeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.DecimeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.FootPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.FootPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.InchPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.InchPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.KilometerPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.KilometerPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.MicrometerPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MicrometerPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.MillimeterPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.MillimeterPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.MillistandardGravitiesPerSecond, quantity => quantity.ToUnit(JerkUnit.MillistandardGravitiesPerSecond));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.NanometerPerSecondCubed, quantity => quantity.ToUnit(JerkUnit.NanometerPerSecondCubed));
-            unitConverter.SetConversionFunction<Jerk>(JerkUnit.MeterPerSecondCubed, JerkUnit.StandardGravitiesPerSecond, quantity => quantity.ToUnit(JerkUnit.StandardGravitiesPerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -355,7 +337,7 @@ public static string GetAbbreviation(JerkUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.CentimeterPerSecondCubed"/>.
         /// </summary>
-        public static Jerk FromCentimetersPerSecondCubed(double value)
+        public static Jerk FromCentimetersPerSecondCubed(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.CentimeterPerSecondCubed);
         }
@@ -363,7 +345,7 @@ public static Jerk FromCentimetersPerSecondCubed(double value)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.DecimeterPerSecondCubed"/>.
         /// </summary>
-        public static Jerk FromDecimetersPerSecondCubed(double value)
+        public static Jerk FromDecimetersPerSecondCubed(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.DecimeterPerSecondCubed);
         }
@@ -371,7 +353,7 @@ public static Jerk FromDecimetersPerSecondCubed(double value)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.FootPerSecondCubed"/>.
         /// </summary>
-        public static Jerk FromFeetPerSecondCubed(double value)
+        public static Jerk FromFeetPerSecondCubed(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.FootPerSecondCubed);
         }
@@ -379,7 +361,7 @@ public static Jerk FromFeetPerSecondCubed(double value)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.InchPerSecondCubed"/>.
         /// </summary>
-        public static Jerk FromInchesPerSecondCubed(double value)
+        public static Jerk FromInchesPerSecondCubed(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.InchPerSecondCubed);
         }
@@ -387,7 +369,7 @@ public static Jerk FromInchesPerSecondCubed(double value)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.KilometerPerSecondCubed"/>.
         /// </summary>
-        public static Jerk FromKilometersPerSecondCubed(double value)
+        public static Jerk FromKilometersPerSecondCubed(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.KilometerPerSecondCubed);
         }
@@ -395,7 +377,7 @@ public static Jerk FromKilometersPerSecondCubed(double value)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MeterPerSecondCubed"/>.
         /// </summary>
-        public static Jerk FromMetersPerSecondCubed(double value)
+        public static Jerk FromMetersPerSecondCubed(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.MeterPerSecondCubed);
         }
@@ -403,7 +385,7 @@ public static Jerk FromMetersPerSecondCubed(double value)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MicrometerPerSecondCubed"/>.
         /// </summary>
-        public static Jerk FromMicrometersPerSecondCubed(double value)
+        public static Jerk FromMicrometersPerSecondCubed(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.MicrometerPerSecondCubed);
         }
@@ -411,7 +393,7 @@ public static Jerk FromMicrometersPerSecondCubed(double value)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MillimeterPerSecondCubed"/>.
         /// </summary>
-        public static Jerk FromMillimetersPerSecondCubed(double value)
+        public static Jerk FromMillimetersPerSecondCubed(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.MillimeterPerSecondCubed);
         }
@@ -419,7 +401,7 @@ public static Jerk FromMillimetersPerSecondCubed(double value)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MillistandardGravitiesPerSecond"/>.
         /// </summary>
-        public static Jerk FromMillistandardGravitiesPerSecond(double value)
+        public static Jerk FromMillistandardGravitiesPerSecond(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.MillistandardGravitiesPerSecond);
         }
@@ -427,7 +409,7 @@ public static Jerk FromMillistandardGravitiesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.NanometerPerSecondCubed"/>.
         /// </summary>
-        public static Jerk FromNanometersPerSecondCubed(double value)
+        public static Jerk FromNanometersPerSecondCubed(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.NanometerPerSecondCubed);
         }
@@ -435,7 +417,7 @@ public static Jerk FromNanometersPerSecondCubed(double value)
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.StandardGravitiesPerSecond"/>.
         /// </summary>
-        public static Jerk FromStandardGravitiesPerSecond(double value)
+        public static Jerk FromStandardGravitiesPerSecond(QuantityValue value)
         {
             return new Jerk(value, JerkUnit.StandardGravitiesPerSecond);
         }
@@ -446,7 +428,7 @@ public static Jerk FromStandardGravitiesPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Jerk unit value.</returns>
-        public static Jerk From(double value, JerkUnit fromUnit)
+        public static Jerk From(QuantityValue value, JerkUnit fromUnit)
         {
             return new Jerk(value, fromUnit);
         }
@@ -507,10 +489,7 @@ public static Jerk Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Jerk Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Jerk, JerkUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Jerk, JerkUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -538,11 +517,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Jerk result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Jerk result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Jerk, JerkUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Jerk, JerkUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -563,7 +538,7 @@ public static JerkUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -574,7 +549,7 @@ public static JerkUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.JerkUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.JerkUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out JerkUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -589,7 +564,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out JerkUnit uni
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out JerkUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -608,35 +583,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Jerk"/> from adding two <see cref="Jerk"/>.</summary>
         public static Jerk operator +(Jerk left, Jerk right)
         {
-            return new Jerk(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Jerk(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Jerk"/> from subtracting two <see cref="Jerk"/>.</summary>
         public static Jerk operator -(Jerk left, Jerk right)
         {
-            return new Jerk(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Jerk(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Jerk"/> from multiplying value and <see cref="Jerk"/>.</summary>
-        public static Jerk operator *(double left, Jerk right)
+        public static Jerk operator *(QuantityValue left, Jerk right)
         {
             return new Jerk(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Jerk"/> from multiplying value and <see cref="Jerk"/>.</summary>
-        public static Jerk operator *(Jerk left, double right)
+        public static Jerk operator *(Jerk left, QuantityValue right)
         {
             return new Jerk(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Jerk"/> from dividing <see cref="Jerk"/> by value.</summary>
-        public static Jerk operator /(Jerk left, double right)
+        public static Jerk operator /(Jerk left, QuantityValue right)
         {
             return new Jerk(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Jerk"/> by <see cref="Jerk"/>.</summary>
-        public static double operator /(Jerk left, Jerk right)
+        public static QuantityValue operator /(Jerk left, Jerk right)
         {
             return left.MetersPerSecondCubed / right.MetersPerSecondCubed;
         }
@@ -658,97 +633,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Jerk left, Jerk right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Jerk left, Jerk right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Jerk left, Jerk right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Jerk left, Jerk right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Jerk"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Jerk other, Jerk tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Jerk"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Jerk)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Jerk left, Jerk right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Jerk"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Jerk other, Jerk tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Jerk"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Jerk,Jerk)"/>.
+        ///     See that operator (and <see cref="Equals(Jerk)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Jerk left, Jerk right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Jerk"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Jerk other, Jerk tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Jerk"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Jerk"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Jerk"/>, this method delegates to
+        ///     <see cref="Equals(Jerk)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Jerk otherQuantity))
+            if (obj is not Jerk otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Jerk"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Jerk other, Jerk tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Jerk"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Jerk other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Jerk.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Jerk), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Jerk"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Jerk)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Jerk otherQuantity)) throw new ArgumentException("Expected type Jerk.", nameof(obj));
+            if (obj is not Jerk otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Jerk>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Jerk"/> with another <see cref="Jerk"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Jerk"/> with another <see cref="Jerk"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -760,149 +749,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Jerk other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(JerkUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<JerkUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Jerk to another Jerk with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Jerk with the specified unit.</returns>
-        public Jerk ToUnit(JerkUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="Jerk"/> to another <see cref="Jerk"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Jerk with the specified unit.</returns>
-        public Jerk ToUnit(JerkUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Jerk), Unit, typeof(Jerk), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Jerk)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Jerk"/> to another <see cref="Jerk"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Jerk"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(JerkUnit unit, [NotNullWhen(true)] out Jerk? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Jerk? convertedOrNull = (Unit, unit) switch
-            {
-                // JerkUnit -> BaseUnit
-                (JerkUnit.CentimeterPerSecondCubed, JerkUnit.MeterPerSecondCubed) => new Jerk((_value) * 1e-2d, JerkUnit.MeterPerSecondCubed),
-                (JerkUnit.DecimeterPerSecondCubed, JerkUnit.MeterPerSecondCubed) => new Jerk((_value) * 1e-1d, JerkUnit.MeterPerSecondCubed),
-                (JerkUnit.FootPerSecondCubed, JerkUnit.MeterPerSecondCubed) => new Jerk(_value * 0.304800, JerkUnit.MeterPerSecondCubed),
-                (JerkUnit.InchPerSecondCubed, JerkUnit.MeterPerSecondCubed) => new Jerk(_value * 0.0254, JerkUnit.MeterPerSecondCubed),
-                (JerkUnit.KilometerPerSecondCubed, JerkUnit.MeterPerSecondCubed) => new Jerk((_value) * 1e3d, JerkUnit.MeterPerSecondCubed),
-                (JerkUnit.MicrometerPerSecondCubed, JerkUnit.MeterPerSecondCubed) => new Jerk((_value) * 1e-6d, JerkUnit.MeterPerSecondCubed),
-                (JerkUnit.MillimeterPerSecondCubed, JerkUnit.MeterPerSecondCubed) => new Jerk((_value) * 1e-3d, JerkUnit.MeterPerSecondCubed),
-                (JerkUnit.MillistandardGravitiesPerSecond, JerkUnit.MeterPerSecondCubed) => new Jerk((_value * 9.80665) * 1e-3d, JerkUnit.MeterPerSecondCubed),
-                (JerkUnit.NanometerPerSecondCubed, JerkUnit.MeterPerSecondCubed) => new Jerk((_value) * 1e-9d, JerkUnit.MeterPerSecondCubed),
-                (JerkUnit.StandardGravitiesPerSecond, JerkUnit.MeterPerSecondCubed) => new Jerk(_value * 9.80665, JerkUnit.MeterPerSecondCubed),
-
-                // BaseUnit -> JerkUnit
-                (JerkUnit.MeterPerSecondCubed, JerkUnit.CentimeterPerSecondCubed) => new Jerk((_value) / 1e-2d, JerkUnit.CentimeterPerSecondCubed),
-                (JerkUnit.MeterPerSecondCubed, JerkUnit.DecimeterPerSecondCubed) => new Jerk((_value) / 1e-1d, JerkUnit.DecimeterPerSecondCubed),
-                (JerkUnit.MeterPerSecondCubed, JerkUnit.FootPerSecondCubed) => new Jerk(_value / 0.304800, JerkUnit.FootPerSecondCubed),
-                (JerkUnit.MeterPerSecondCubed, JerkUnit.InchPerSecondCubed) => new Jerk(_value / 0.0254, JerkUnit.InchPerSecondCubed),
-                (JerkUnit.MeterPerSecondCubed, JerkUnit.KilometerPerSecondCubed) => new Jerk((_value) / 1e3d, JerkUnit.KilometerPerSecondCubed),
-                (JerkUnit.MeterPerSecondCubed, JerkUnit.MicrometerPerSecondCubed) => new Jerk((_value) / 1e-6d, JerkUnit.MicrometerPerSecondCubed),
-                (JerkUnit.MeterPerSecondCubed, JerkUnit.MillimeterPerSecondCubed) => new Jerk((_value) / 1e-3d, JerkUnit.MillimeterPerSecondCubed),
-                (JerkUnit.MeterPerSecondCubed, JerkUnit.MillistandardGravitiesPerSecond) => new Jerk((_value / 9.80665) / 1e-3d, JerkUnit.MillistandardGravitiesPerSecond),
-                (JerkUnit.MeterPerSecondCubed, JerkUnit.NanometerPerSecondCubed) => new Jerk((_value) / 1e-9d, JerkUnit.NanometerPerSecondCubed),
-                (JerkUnit.MeterPerSecondCubed, JerkUnit.StandardGravitiesPerSecond) => new Jerk(_value / 9.80665, JerkUnit.StandardGravitiesPerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not JerkUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(JerkUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is JerkUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(JerkUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<JerkUnit> IQuantity<JerkUnit>.ToUnit(JerkUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -916,11 +765,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
index e7828f6640..f3665c7b15 100644
--- a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     http://en.wikipedia.org/wiki/Viscosity
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct KinematicViscosity :
-        IArithmeticQuantity<KinematicViscosity, KinematicViscosityUnit>,
+        ILinearQuantity<KinematicViscosity, KinematicViscosityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<KinematicViscosity, KinematicViscosity, double>,
+        IDivisionOperators<KinematicViscosity, KinematicViscosity, QuantityValue>,
         IMultiplyOperators<KinematicViscosity, Duration, Area>,
         IMultiplyOperators<KinematicViscosity, Density, DynamicViscosity>,
         IDivisionOperators<KinematicViscosity, Speed, Length>,
@@ -59,7 +58,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -109,7 +108,7 @@ public static KinematicViscosityInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="KinematicViscosity"/> is [T^-1][L^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="KinematicViscosity"/> is T^-1L^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 0, -1, 0, 0, 0, 0);
 
@@ -124,23 +123,37 @@ public static KinematicViscosityInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{KinematicViscosityUnit}"/> representing the default unit mappings for KinematicViscosity.</returns>
             public static IEnumerable<UnitDefinition<KinematicViscosityUnit>> GetDefaultMappings()
             {
-                yield return new (KinematicViscosityUnit.Centistokes, "Centistokes", "Centistokes", BaseUnits.Undefined);
-                yield return new (KinematicViscosityUnit.Decistokes, "Decistokes", "Decistokes", BaseUnits.Undefined);
-                yield return new (KinematicViscosityUnit.Kilostokes, "Kilostokes", "Kilostokes", BaseUnits.Undefined);
-                yield return new (KinematicViscosityUnit.Microstokes, "Microstokes", "Microstokes", BaseUnits.Undefined);
-                yield return new (KinematicViscosityUnit.Millistokes, "Millistokes", "Millistokes", BaseUnits.Undefined);
-                yield return new (KinematicViscosityUnit.Nanostokes, "Nanostokes", "Nanostokes", BaseUnits.Undefined);
-                yield return new (KinematicViscosityUnit.SquareFootPerSecond, "SquareFootPerSecond", "SquareFeetPerSecond", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second));
+                yield return new (KinematicViscosityUnit.Centistokes, "Centistokes", "Centistokes", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (KinematicViscosityUnit.Decistokes, "Decistokes", "Decistokes", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (KinematicViscosityUnit.Kilostokes, "Kilostokes", "Kilostokes", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (KinematicViscosityUnit.Microstokes, "Microstokes", "Microstokes", BaseUnits.Undefined,
+                     10000000000
+                );
+                yield return new (KinematicViscosityUnit.Millistokes, "Millistokes", "Millistokes", BaseUnits.Undefined,
+                     10000000
+                );
+                yield return new (KinematicViscosityUnit.Nanostokes, "Nanostokes", "Nanostokes", BaseUnits.Undefined,
+                     10000000000000
+                );
+                yield return new (KinematicViscosityUnit.SquareFootPerSecond, "SquareFootPerSecond", "SquareFeetPerSecond", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second),
+                     new QuantityValue(1562500, 145161)
+                );
                 yield return new (KinematicViscosityUnit.SquareMeterPerSecond, "SquareMeterPerSecond", "SquareMetersPerSecond", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (KinematicViscosityUnit.Stokes, "Stokes", "Stokes", BaseUnits.Undefined);
+                yield return new (KinematicViscosityUnit.Stokes, "Stokes", "Stokes", BaseUnits.Undefined,
+                     10000
+                );
             }
         }
 
         static KinematicViscosity()
         {
-            Info = KinematicViscosityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(KinematicViscosityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -148,7 +161,7 @@ static KinematicViscosity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public KinematicViscosity(double value, KinematicViscosityUnit unit)
+        public KinematicViscosity(QuantityValue value, KinematicViscosityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -162,7 +175,7 @@ public KinematicViscosity(double value, KinematicViscosityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public KinematicViscosity(double value, UnitSystem unitSystem)
+        public KinematicViscosity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -173,7 +186,8 @@ public KinematicViscosity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="KinematicViscosity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<KinematicViscosity, KinematicViscosityUnit> Info { get; }
@@ -202,10 +216,8 @@ public KinematicViscosity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public KinematicViscosityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -239,84 +251,54 @@ public KinematicViscosity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Centistokes"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Centistokes"/>
         /// </summary>
-        public double Centistokes => As(KinematicViscosityUnit.Centistokes);
+        public QuantityValue Centistokes => this.As(KinematicViscosityUnit.Centistokes);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Decistokes"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Decistokes"/>
         /// </summary>
-        public double Decistokes => As(KinematicViscosityUnit.Decistokes);
+        public QuantityValue Decistokes => this.As(KinematicViscosityUnit.Decistokes);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Kilostokes"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Kilostokes"/>
         /// </summary>
-        public double Kilostokes => As(KinematicViscosityUnit.Kilostokes);
+        public QuantityValue Kilostokes => this.As(KinematicViscosityUnit.Kilostokes);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Microstokes"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Microstokes"/>
         /// </summary>
-        public double Microstokes => As(KinematicViscosityUnit.Microstokes);
+        public QuantityValue Microstokes => this.As(KinematicViscosityUnit.Microstokes);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Millistokes"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Millistokes"/>
         /// </summary>
-        public double Millistokes => As(KinematicViscosityUnit.Millistokes);
+        public QuantityValue Millistokes => this.As(KinematicViscosityUnit.Millistokes);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Nanostokes"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Nanostokes"/>
         /// </summary>
-        public double Nanostokes => As(KinematicViscosityUnit.Nanostokes);
+        public QuantityValue Nanostokes => this.As(KinematicViscosityUnit.Nanostokes);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.SquareFootPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="KinematicViscosityUnit.SquareFootPerSecond"/>
         /// </summary>
-        public double SquareFeetPerSecond => As(KinematicViscosityUnit.SquareFootPerSecond);
+        public QuantityValue SquareFeetPerSecond => this.As(KinematicViscosityUnit.SquareFootPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.SquareMeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="KinematicViscosityUnit.SquareMeterPerSecond"/>
         /// </summary>
-        public double SquareMetersPerSecond => As(KinematicViscosityUnit.SquareMeterPerSecond);
+        public QuantityValue SquareMetersPerSecond => this.As(KinematicViscosityUnit.SquareMeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Stokes"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="KinematicViscosityUnit.Stokes"/>
         /// </summary>
-        public double Stokes => As(KinematicViscosityUnit.Stokes);
+        public QuantityValue Stokes => this.As(KinematicViscosityUnit.Stokes);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: KinematicViscosityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Centistokes, KinematicViscosityUnit.SquareMeterPerSecond, quantity => quantity.ToUnit(KinematicViscosityUnit.SquareMeterPerSecond));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Decistokes, KinematicViscosityUnit.SquareMeterPerSecond, quantity => quantity.ToUnit(KinematicViscosityUnit.SquareMeterPerSecond));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Kilostokes, KinematicViscosityUnit.SquareMeterPerSecond, quantity => quantity.ToUnit(KinematicViscosityUnit.SquareMeterPerSecond));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Microstokes, KinematicViscosityUnit.SquareMeterPerSecond, quantity => quantity.ToUnit(KinematicViscosityUnit.SquareMeterPerSecond));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Millistokes, KinematicViscosityUnit.SquareMeterPerSecond, quantity => quantity.ToUnit(KinematicViscosityUnit.SquareMeterPerSecond));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Nanostokes, KinematicViscosityUnit.SquareMeterPerSecond, quantity => quantity.ToUnit(KinematicViscosityUnit.SquareMeterPerSecond));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.SquareFootPerSecond, KinematicViscosityUnit.SquareMeterPerSecond, quantity => quantity.ToUnit(KinematicViscosityUnit.SquareMeterPerSecond));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.Stokes, KinematicViscosityUnit.SquareMeterPerSecond, quantity => quantity.ToUnit(KinematicViscosityUnit.SquareMeterPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.SquareMeterPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> KinematicViscosityUnit
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Centistokes, quantity => quantity.ToUnit(KinematicViscosityUnit.Centistokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Decistokes, quantity => quantity.ToUnit(KinematicViscosityUnit.Decistokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Kilostokes, quantity => quantity.ToUnit(KinematicViscosityUnit.Kilostokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Microstokes, quantity => quantity.ToUnit(KinematicViscosityUnit.Microstokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Millistokes, quantity => quantity.ToUnit(KinematicViscosityUnit.Millistokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Nanostokes, quantity => quantity.ToUnit(KinematicViscosityUnit.Nanostokes));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.SquareFootPerSecond, quantity => quantity.ToUnit(KinematicViscosityUnit.SquareFootPerSecond));
-            unitConverter.SetConversionFunction<KinematicViscosity>(KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Stokes, quantity => quantity.ToUnit(KinematicViscosityUnit.Stokes));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -345,7 +327,7 @@ public static string GetAbbreviation(KinematicViscosityUnit unit, IFormatProvide
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Centistokes"/>.
         /// </summary>
-        public static KinematicViscosity FromCentistokes(double value)
+        public static KinematicViscosity FromCentistokes(QuantityValue value)
         {
             return new KinematicViscosity(value, KinematicViscosityUnit.Centistokes);
         }
@@ -353,7 +335,7 @@ public static KinematicViscosity FromCentistokes(double value)
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Decistokes"/>.
         /// </summary>
-        public static KinematicViscosity FromDecistokes(double value)
+        public static KinematicViscosity FromDecistokes(QuantityValue value)
         {
             return new KinematicViscosity(value, KinematicViscosityUnit.Decistokes);
         }
@@ -361,7 +343,7 @@ public static KinematicViscosity FromDecistokes(double value)
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Kilostokes"/>.
         /// </summary>
-        public static KinematicViscosity FromKilostokes(double value)
+        public static KinematicViscosity FromKilostokes(QuantityValue value)
         {
             return new KinematicViscosity(value, KinematicViscosityUnit.Kilostokes);
         }
@@ -369,7 +351,7 @@ public static KinematicViscosity FromKilostokes(double value)
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Microstokes"/>.
         /// </summary>
-        public static KinematicViscosity FromMicrostokes(double value)
+        public static KinematicViscosity FromMicrostokes(QuantityValue value)
         {
             return new KinematicViscosity(value, KinematicViscosityUnit.Microstokes);
         }
@@ -377,7 +359,7 @@ public static KinematicViscosity FromMicrostokes(double value)
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Millistokes"/>.
         /// </summary>
-        public static KinematicViscosity FromMillistokes(double value)
+        public static KinematicViscosity FromMillistokes(QuantityValue value)
         {
             return new KinematicViscosity(value, KinematicViscosityUnit.Millistokes);
         }
@@ -385,7 +367,7 @@ public static KinematicViscosity FromMillistokes(double value)
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Nanostokes"/>.
         /// </summary>
-        public static KinematicViscosity FromNanostokes(double value)
+        public static KinematicViscosity FromNanostokes(QuantityValue value)
         {
             return new KinematicViscosity(value, KinematicViscosityUnit.Nanostokes);
         }
@@ -393,7 +375,7 @@ public static KinematicViscosity FromNanostokes(double value)
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.SquareFootPerSecond"/>.
         /// </summary>
-        public static KinematicViscosity FromSquareFeetPerSecond(double value)
+        public static KinematicViscosity FromSquareFeetPerSecond(QuantityValue value)
         {
             return new KinematicViscosity(value, KinematicViscosityUnit.SquareFootPerSecond);
         }
@@ -401,7 +383,7 @@ public static KinematicViscosity FromSquareFeetPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.SquareMeterPerSecond"/>.
         /// </summary>
-        public static KinematicViscosity FromSquareMetersPerSecond(double value)
+        public static KinematicViscosity FromSquareMetersPerSecond(QuantityValue value)
         {
             return new KinematicViscosity(value, KinematicViscosityUnit.SquareMeterPerSecond);
         }
@@ -409,7 +391,7 @@ public static KinematicViscosity FromSquareMetersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Stokes"/>.
         /// </summary>
-        public static KinematicViscosity FromStokes(double value)
+        public static KinematicViscosity FromStokes(QuantityValue value)
         {
             return new KinematicViscosity(value, KinematicViscosityUnit.Stokes);
         }
@@ -420,7 +402,7 @@ public static KinematicViscosity FromStokes(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>KinematicViscosity unit value.</returns>
-        public static KinematicViscosity From(double value, KinematicViscosityUnit fromUnit)
+        public static KinematicViscosity From(QuantityValue value, KinematicViscosityUnit fromUnit)
         {
             return new KinematicViscosity(value, fromUnit);
         }
@@ -481,10 +463,7 @@ public static KinematicViscosity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static KinematicViscosity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<KinematicViscosity, KinematicViscosityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<KinematicViscosity, KinematicViscosityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -512,11 +491,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out KinematicViscosi
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out KinematicViscosity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<KinematicViscosity, KinematicViscosityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<KinematicViscosity, KinematicViscosityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -537,7 +512,7 @@ public static KinematicViscosityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -548,7 +523,7 @@ public static KinematicViscosityUnit ParseUnit(string str, IFormatProvider? prov
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.KinematicViscosityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.KinematicViscosityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out KinematicViscosityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -563,7 +538,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out KinematicVis
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out KinematicViscosityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -582,35 +557,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="KinematicViscosity"/> from adding two <see cref="KinematicViscosity"/>.</summary>
         public static KinematicViscosity operator +(KinematicViscosity left, KinematicViscosity right)
         {
-            return new KinematicViscosity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new KinematicViscosity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="KinematicViscosity"/> from subtracting two <see cref="KinematicViscosity"/>.</summary>
         public static KinematicViscosity operator -(KinematicViscosity left, KinematicViscosity right)
         {
-            return new KinematicViscosity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new KinematicViscosity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="KinematicViscosity"/> from multiplying value and <see cref="KinematicViscosity"/>.</summary>
-        public static KinematicViscosity operator *(double left, KinematicViscosity right)
+        public static KinematicViscosity operator *(QuantityValue left, KinematicViscosity right)
         {
             return new KinematicViscosity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="KinematicViscosity"/> from multiplying value and <see cref="KinematicViscosity"/>.</summary>
-        public static KinematicViscosity operator *(KinematicViscosity left, double right)
+        public static KinematicViscosity operator *(KinematicViscosity left, QuantityValue right)
         {
             return new KinematicViscosity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="KinematicViscosity"/> from dividing <see cref="KinematicViscosity"/> by value.</summary>
-        public static KinematicViscosity operator /(KinematicViscosity left, double right)
+        public static KinematicViscosity operator /(KinematicViscosity left, QuantityValue right)
         {
             return new KinematicViscosity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="KinematicViscosity"/> by <see cref="KinematicViscosity"/>.</summary>
-        public static double operator /(KinematicViscosity left, KinematicViscosity right)
+        public static QuantityValue operator /(KinematicViscosity left, KinematicViscosity right)
         {
             return left.SquareMetersPerSecond / right.SquareMetersPerSecond;
         }
@@ -650,97 +625,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(KinematicViscosity left, KinematicViscosity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(KinematicViscosity left, KinematicViscosity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(KinematicViscosity left, KinematicViscosity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(KinematicViscosity left, KinematicViscosity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="KinematicViscosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(KinematicViscosity other, KinematicViscosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="KinematicViscosity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(KinematicViscosity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(KinematicViscosity left, KinematicViscosity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="KinematicViscosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(KinematicViscosity other, KinematicViscosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="KinematicViscosity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(KinematicViscosity,KinematicViscosity)"/>.
+        ///     See that operator (and <see cref="Equals(KinematicViscosity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(KinematicViscosity left, KinematicViscosity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="KinematicViscosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(KinematicViscosity other, KinematicViscosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="KinematicViscosity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="KinematicViscosity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="KinematicViscosity"/>, this method delegates to
+        ///     <see cref="Equals(KinematicViscosity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is KinematicViscosity otherQuantity))
+            if (obj is not KinematicViscosity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="KinematicViscosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(KinematicViscosity other, KinematicViscosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="KinematicViscosity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(KinematicViscosity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current KinematicViscosity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(KinematicViscosity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="KinematicViscosity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(KinematicViscosity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is KinematicViscosity otherQuantity)) throw new ArgumentException("Expected type KinematicViscosity.", nameof(obj));
+            if (obj is not KinematicViscosity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<KinematicViscosity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="KinematicViscosity"/> with another <see cref="KinematicViscosity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="KinematicViscosity"/> with another <see cref="KinematicViscosity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -752,145 +741,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(KinematicViscosity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(KinematicViscosityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<KinematicViscosityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this KinematicViscosity to another KinematicViscosity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A KinematicViscosity with the specified unit.</returns>
-        public KinematicViscosity ToUnit(KinematicViscosityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="KinematicViscosity"/> to another <see cref="KinematicViscosity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A KinematicViscosity with the specified unit.</returns>
-        public KinematicViscosity ToUnit(KinematicViscosityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(KinematicViscosity), Unit, typeof(KinematicViscosity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (KinematicViscosity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="KinematicViscosity"/> to another <see cref="KinematicViscosity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="KinematicViscosity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(KinematicViscosityUnit unit, [NotNullWhen(true)] out KinematicViscosity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            KinematicViscosity? convertedOrNull = (Unit, unit) switch
-            {
-                // KinematicViscosityUnit -> BaseUnit
-                (KinematicViscosityUnit.Centistokes, KinematicViscosityUnit.SquareMeterPerSecond) => new KinematicViscosity((_value / 1e4) * 1e-2d, KinematicViscosityUnit.SquareMeterPerSecond),
-                (KinematicViscosityUnit.Decistokes, KinematicViscosityUnit.SquareMeterPerSecond) => new KinematicViscosity((_value / 1e4) * 1e-1d, KinematicViscosityUnit.SquareMeterPerSecond),
-                (KinematicViscosityUnit.Kilostokes, KinematicViscosityUnit.SquareMeterPerSecond) => new KinematicViscosity((_value / 1e4) * 1e3d, KinematicViscosityUnit.SquareMeterPerSecond),
-                (KinematicViscosityUnit.Microstokes, KinematicViscosityUnit.SquareMeterPerSecond) => new KinematicViscosity((_value / 1e4) * 1e-6d, KinematicViscosityUnit.SquareMeterPerSecond),
-                (KinematicViscosityUnit.Millistokes, KinematicViscosityUnit.SquareMeterPerSecond) => new KinematicViscosity((_value / 1e4) * 1e-3d, KinematicViscosityUnit.SquareMeterPerSecond),
-                (KinematicViscosityUnit.Nanostokes, KinematicViscosityUnit.SquareMeterPerSecond) => new KinematicViscosity((_value / 1e4) * 1e-9d, KinematicViscosityUnit.SquareMeterPerSecond),
-                (KinematicViscosityUnit.SquareFootPerSecond, KinematicViscosityUnit.SquareMeterPerSecond) => new KinematicViscosity(_value * 9.290304e-2, KinematicViscosityUnit.SquareMeterPerSecond),
-                (KinematicViscosityUnit.Stokes, KinematicViscosityUnit.SquareMeterPerSecond) => new KinematicViscosity(_value / 1e4, KinematicViscosityUnit.SquareMeterPerSecond),
-
-                // BaseUnit -> KinematicViscosityUnit
-                (KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Centistokes) => new KinematicViscosity((_value * 1e4) / 1e-2d, KinematicViscosityUnit.Centistokes),
-                (KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Decistokes) => new KinematicViscosity((_value * 1e4) / 1e-1d, KinematicViscosityUnit.Decistokes),
-                (KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Kilostokes) => new KinematicViscosity((_value * 1e4) / 1e3d, KinematicViscosityUnit.Kilostokes),
-                (KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Microstokes) => new KinematicViscosity((_value * 1e4) / 1e-6d, KinematicViscosityUnit.Microstokes),
-                (KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Millistokes) => new KinematicViscosity((_value * 1e4) / 1e-3d, KinematicViscosityUnit.Millistokes),
-                (KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Nanostokes) => new KinematicViscosity((_value * 1e4) / 1e-9d, KinematicViscosityUnit.Nanostokes),
-                (KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.SquareFootPerSecond) => new KinematicViscosity(_value / 9.290304e-2, KinematicViscosityUnit.SquareFootPerSecond),
-                (KinematicViscosityUnit.SquareMeterPerSecond, KinematicViscosityUnit.Stokes) => new KinematicViscosity(_value * 1e4, KinematicViscosityUnit.Stokes),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not KinematicViscosityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(KinematicViscosityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is KinematicViscosityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(KinematicViscosityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<KinematicViscosityUnit> IQuantity<KinematicViscosityUnit>.ToUnit(KinematicViscosityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -904,11 +757,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs b/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
index b19b295670..d33a66d643 100644
--- a/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,14 @@ namespace UnitsNet
     ///     https://www.leybold.com/en-in/knowledge/vacuum-fundamentals/leak-detection/definition-and-measurement-of-vacuum-leaks
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct LeakRate :
-        IArithmeticQuantity<LeakRate, LeakRateUnit>,
+        ILinearQuantity<LeakRate, LeakRateUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<LeakRate, LeakRate, double>,
+        IDivisionOperators<LeakRate, LeakRate, QuantityValue>,
+        IDivisionOperators<LeakRate, VolumeFlow, Pressure>,
+        IDivisionOperators<LeakRate, Pressure, VolumeFlow>,
         IComparisonOperators<LeakRate, LeakRate, bool>,
         IParsable<LeakRate>,
 #endif
@@ -55,7 +56,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +106,7 @@ public static LeakRateInfo CreateDefault(Func<IEnumerable<UnitDefinition<LeakRat
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="LeakRate"/> is [T^-3][L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="LeakRate"/> is T^-3L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
 
@@ -120,18 +121,22 @@ public static LeakRateInfo CreateDefault(Func<IEnumerable<UnitDefinition<LeakRat
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{LeakRateUnit}"/> representing the default unit mappings for LeakRate.</returns>
             public static IEnumerable<UnitDefinition<LeakRateUnit>> GetDefaultMappings()
             {
-                yield return new (LeakRateUnit.AtmCubicCentimeterPerSecond, "AtmCubicCentimeterPerSecond", "AtmCubicCentimetersPerSecond", BaseUnits.Undefined);
-                yield return new (LeakRateUnit.MillibarLiterPerSecond, "MillibarLiterPerSecond", "MillibarLitersPerSecond", BaseUnits.Undefined);
+                yield return new (LeakRateUnit.AtmCubicCentimeterPerSecond, "AtmCubicCentimeterPerSecond", "AtmCubicCentimetersPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(40000, 4053)
+                );
+                yield return new (LeakRateUnit.MillibarLiterPerSecond, "MillibarLiterPerSecond", "MillibarLitersPerSecond", BaseUnits.Undefined,
+                     10
+                );
                 yield return new (LeakRateUnit.PascalCubicMeterPerSecond, "PascalCubicMeterPerSecond", "PascalCubicMetersPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (LeakRateUnit.TorrLiterPerSecond, "TorrLiterPerSecond", "TorrLitersPerSecond", BaseUnits.Undefined);
+                yield return new (LeakRateUnit.TorrLiterPerSecond, "TorrLiterPerSecond", "TorrLitersPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(15, 2)
+                );
             }
         }
 
         static LeakRate()
         {
-            Info = LeakRateInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(LeakRateInfo.CreateDefault);
         }
 
         /// <summary>
@@ -139,7 +144,7 @@ static LeakRate()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public LeakRate(double value, LeakRateUnit unit)
+        public LeakRate(QuantityValue value, LeakRateUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -153,7 +158,7 @@ public LeakRate(double value, LeakRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public LeakRate(double value, UnitSystem unitSystem)
+        public LeakRate(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -164,7 +169,8 @@ public LeakRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="LeakRate" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<LeakRate, LeakRateUnit> Info { get; }
@@ -193,10 +199,8 @@ public LeakRate(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public LeakRateUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -230,49 +234,29 @@ public LeakRate(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LeakRateUnit.AtmCubicCentimeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LeakRateUnit.AtmCubicCentimeterPerSecond"/>
         /// </summary>
-        public double AtmCubicCentimetersPerSecond => As(LeakRateUnit.AtmCubicCentimeterPerSecond);
+        public QuantityValue AtmCubicCentimetersPerSecond => this.As(LeakRateUnit.AtmCubicCentimeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LeakRateUnit.MillibarLiterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LeakRateUnit.MillibarLiterPerSecond"/>
         /// </summary>
-        public double MillibarLitersPerSecond => As(LeakRateUnit.MillibarLiterPerSecond);
+        public QuantityValue MillibarLitersPerSecond => this.As(LeakRateUnit.MillibarLiterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LeakRateUnit.PascalCubicMeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LeakRateUnit.PascalCubicMeterPerSecond"/>
         /// </summary>
-        public double PascalCubicMetersPerSecond => As(LeakRateUnit.PascalCubicMeterPerSecond);
+        public QuantityValue PascalCubicMetersPerSecond => this.As(LeakRateUnit.PascalCubicMeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LeakRateUnit.TorrLiterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LeakRateUnit.TorrLiterPerSecond"/>
         /// </summary>
-        public double TorrLitersPerSecond => As(LeakRateUnit.TorrLiterPerSecond);
+        public QuantityValue TorrLitersPerSecond => this.As(LeakRateUnit.TorrLiterPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: LeakRateUnit -> BaseUnit
-            unitConverter.SetConversionFunction<LeakRate>(LeakRateUnit.AtmCubicCentimeterPerSecond, LeakRateUnit.PascalCubicMeterPerSecond, quantity => quantity.ToUnit(LeakRateUnit.PascalCubicMeterPerSecond));
-            unitConverter.SetConversionFunction<LeakRate>(LeakRateUnit.MillibarLiterPerSecond, LeakRateUnit.PascalCubicMeterPerSecond, quantity => quantity.ToUnit(LeakRateUnit.PascalCubicMeterPerSecond));
-            unitConverter.SetConversionFunction<LeakRate>(LeakRateUnit.TorrLiterPerSecond, LeakRateUnit.PascalCubicMeterPerSecond, quantity => quantity.ToUnit(LeakRateUnit.PascalCubicMeterPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<LeakRate>(LeakRateUnit.PascalCubicMeterPerSecond, LeakRateUnit.PascalCubicMeterPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> LeakRateUnit
-            unitConverter.SetConversionFunction<LeakRate>(LeakRateUnit.PascalCubicMeterPerSecond, LeakRateUnit.AtmCubicCentimeterPerSecond, quantity => quantity.ToUnit(LeakRateUnit.AtmCubicCentimeterPerSecond));
-            unitConverter.SetConversionFunction<LeakRate>(LeakRateUnit.PascalCubicMeterPerSecond, LeakRateUnit.MillibarLiterPerSecond, quantity => quantity.ToUnit(LeakRateUnit.MillibarLiterPerSecond));
-            unitConverter.SetConversionFunction<LeakRate>(LeakRateUnit.PascalCubicMeterPerSecond, LeakRateUnit.TorrLiterPerSecond, quantity => quantity.ToUnit(LeakRateUnit.TorrLiterPerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -301,7 +285,7 @@ public static string GetAbbreviation(LeakRateUnit unit, IFormatProvider? provide
         /// <summary>
         ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.AtmCubicCentimeterPerSecond"/>.
         /// </summary>
-        public static LeakRate FromAtmCubicCentimetersPerSecond(double value)
+        public static LeakRate FromAtmCubicCentimetersPerSecond(QuantityValue value)
         {
             return new LeakRate(value, LeakRateUnit.AtmCubicCentimeterPerSecond);
         }
@@ -309,7 +293,7 @@ public static LeakRate FromAtmCubicCentimetersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.MillibarLiterPerSecond"/>.
         /// </summary>
-        public static LeakRate FromMillibarLitersPerSecond(double value)
+        public static LeakRate FromMillibarLitersPerSecond(QuantityValue value)
         {
             return new LeakRate(value, LeakRateUnit.MillibarLiterPerSecond);
         }
@@ -317,7 +301,7 @@ public static LeakRate FromMillibarLitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.PascalCubicMeterPerSecond"/>.
         /// </summary>
-        public static LeakRate FromPascalCubicMetersPerSecond(double value)
+        public static LeakRate FromPascalCubicMetersPerSecond(QuantityValue value)
         {
             return new LeakRate(value, LeakRateUnit.PascalCubicMeterPerSecond);
         }
@@ -325,7 +309,7 @@ public static LeakRate FromPascalCubicMetersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.TorrLiterPerSecond"/>.
         /// </summary>
-        public static LeakRate FromTorrLitersPerSecond(double value)
+        public static LeakRate FromTorrLitersPerSecond(QuantityValue value)
         {
             return new LeakRate(value, LeakRateUnit.TorrLiterPerSecond);
         }
@@ -336,7 +320,7 @@ public static LeakRate FromTorrLitersPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>LeakRate unit value.</returns>
-        public static LeakRate From(double value, LeakRateUnit fromUnit)
+        public static LeakRate From(QuantityValue value, LeakRateUnit fromUnit)
         {
             return new LeakRate(value, fromUnit);
         }
@@ -397,10 +381,7 @@ public static LeakRate Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static LeakRate Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<LeakRate, LeakRateUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<LeakRate, LeakRateUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -428,11 +409,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out LeakRate result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out LeakRate result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<LeakRate, LeakRateUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<LeakRate, LeakRateUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -453,7 +430,7 @@ public static LeakRateUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -464,7 +441,7 @@ public static LeakRateUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LeakRateUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.LeakRateUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out LeakRateUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -479,7 +456,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LeakRateUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out LeakRateUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -498,137 +475,167 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="LeakRate"/> from adding two <see cref="LeakRate"/>.</summary>
         public static LeakRate operator +(LeakRate left, LeakRate right)
         {
-            return new LeakRate(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new LeakRate(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="LeakRate"/> from subtracting two <see cref="LeakRate"/>.</summary>
         public static LeakRate operator -(LeakRate left, LeakRate right)
         {
-            return new LeakRate(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new LeakRate(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="LeakRate"/> from multiplying value and <see cref="LeakRate"/>.</summary>
-        public static LeakRate operator *(double left, LeakRate right)
+        public static LeakRate operator *(QuantityValue left, LeakRate right)
         {
             return new LeakRate(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="LeakRate"/> from multiplying value and <see cref="LeakRate"/>.</summary>
-        public static LeakRate operator *(LeakRate left, double right)
+        public static LeakRate operator *(LeakRate left, QuantityValue right)
         {
             return new LeakRate(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="LeakRate"/> from dividing <see cref="LeakRate"/> by value.</summary>
-        public static LeakRate operator /(LeakRate left, double right)
+        public static LeakRate operator /(LeakRate left, QuantityValue right)
         {
             return new LeakRate(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="LeakRate"/> by <see cref="LeakRate"/>.</summary>
-        public static double operator /(LeakRate left, LeakRate right)
+        public static QuantityValue operator /(LeakRate left, LeakRate right)
         {
             return left.PascalCubicMetersPerSecond / right.PascalCubicMetersPerSecond;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Pressure"/> from <see cref="LeakRate"/> / <see cref="VolumeFlow"/>.</summary>
+        public static Pressure operator /(LeakRate leakRate, VolumeFlow volumeFlow)
+        {
+            return Pressure.FromPascals(leakRate.PascalCubicMetersPerSecond / volumeFlow.CubicMetersPerSecond);
+        }
+
+        /// <summary>Get <see cref="VolumeFlow"/> from <see cref="LeakRate"/> / <see cref="Pressure"/>.</summary>
+        public static VolumeFlow operator /(LeakRate leakRate, Pressure pressure)
+        {
+            return VolumeFlow.FromCubicMetersPerSecond(leakRate.PascalCubicMetersPerSecond / pressure.Pascals);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(LeakRate left, LeakRate right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(LeakRate left, LeakRate right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(LeakRate left, LeakRate right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(LeakRate left, LeakRate right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="LeakRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(LeakRate other, LeakRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="LeakRate"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(LeakRate)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(LeakRate left, LeakRate right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="LeakRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(LeakRate other, LeakRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="LeakRate"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(LeakRate,LeakRate)"/>.
+        ///     See that operator (and <see cref="Equals(LeakRate)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(LeakRate left, LeakRate right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="LeakRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(LeakRate other, LeakRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="LeakRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="LeakRate"/>.
+        ///     When <paramref name="obj"/> is a <see cref="LeakRate"/>, this method delegates to
+        ///     <see cref="Equals(LeakRate)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is LeakRate otherQuantity))
+            if (obj is not LeakRate otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="LeakRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(LeakRate other, LeakRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="LeakRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(LeakRate other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current LeakRate.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(LeakRate), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="LeakRate"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(LeakRate)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is LeakRate otherQuantity)) throw new ArgumentException("Expected type LeakRate.", nameof(obj));
+            if (obj is not LeakRate otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<LeakRate>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="LeakRate"/> with another <see cref="LeakRate"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="LeakRate"/> with another <see cref="LeakRate"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -640,135 +647,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(LeakRate other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(LeakRateUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<LeakRateUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this LeakRate to another LeakRate with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A LeakRate with the specified unit.</returns>
-        public LeakRate ToUnit(LeakRateUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="LeakRate"/> to another <see cref="LeakRate"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A LeakRate with the specified unit.</returns>
-        public LeakRate ToUnit(LeakRateUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(LeakRate), Unit, typeof(LeakRate), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (LeakRate)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="LeakRate"/> to another <see cref="LeakRate"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="LeakRate"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(LeakRateUnit unit, [NotNullWhen(true)] out LeakRate? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            LeakRate? convertedOrNull = (Unit, unit) switch
-            {
-                // LeakRateUnit -> BaseUnit
-                (LeakRateUnit.AtmCubicCentimeterPerSecond, LeakRateUnit.PascalCubicMeterPerSecond) => new LeakRate(_value / (1e6 / 101325), LeakRateUnit.PascalCubicMeterPerSecond),
-                (LeakRateUnit.MillibarLiterPerSecond, LeakRateUnit.PascalCubicMeterPerSecond) => new LeakRate(_value / 10, LeakRateUnit.PascalCubicMeterPerSecond),
-                (LeakRateUnit.TorrLiterPerSecond, LeakRateUnit.PascalCubicMeterPerSecond) => new LeakRate(_value / 7.5, LeakRateUnit.PascalCubicMeterPerSecond),
-
-                // BaseUnit -> LeakRateUnit
-                (LeakRateUnit.PascalCubicMeterPerSecond, LeakRateUnit.AtmCubicCentimeterPerSecond) => new LeakRate(_value * (1e6 / 101325), LeakRateUnit.AtmCubicCentimeterPerSecond),
-                (LeakRateUnit.PascalCubicMeterPerSecond, LeakRateUnit.MillibarLiterPerSecond) => new LeakRate(_value * 10, LeakRateUnit.MillibarLiterPerSecond),
-                (LeakRateUnit.PascalCubicMeterPerSecond, LeakRateUnit.TorrLiterPerSecond) => new LeakRate(_value * 7.5, LeakRateUnit.TorrLiterPerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not LeakRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LeakRateUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is LeakRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LeakRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<LeakRateUnit> IQuantity<LeakRateUnit>.ToUnit(LeakRateUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -782,11 +663,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
index 9974ed8191..dfe52879ca 100644
--- a/UnitsNet/GeneratedCode/Quantities/Length.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,19 +33,25 @@ namespace UnitsNet
     ///     Many different units of length have been used around the world. The main units in modern use are U.S. customary units in the United States and the Metric system elsewhere. British Imperial units are still used for some purposes in the United Kingdom and some other countries. The metric system is sub-divided into SI and non-SI units.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Length :
-        IArithmeticQuantity<Length, LengthUnit>,
+        ILinearQuantity<Length, LengthUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Length, Length, double>,
+        IDivisionOperators<Length, Length, QuantityValue>,
+        IMultiplyOperators<Length, AreaPerLength, Area>,
         IMultiplyOperators<Length, Length, Area>,
         IDivisionOperators<Length, ReciprocalLength, Area>,
+        IMultiplyOperators<Length, Density, AreaDensity>,
         IMultiplyOperators<Length, Volume, AreaMomentOfInertia>,
         IDivisionOperators<Length, Speed, Duration>,
+        IMultiplyOperators<Length, ElectricField, ElectricPotential>,
         IMultiplyOperators<Length, ForcePerLength, Force>,
         IMultiplyOperators<Length, Pressure, ForcePerLength>,
         IMultiplyOperators<Length, Speed, KinematicViscosity>,
+        IMultiplyOperators<Length, AreaDensity, LinearDensity>,
         IMultiplyOperators<Length, LinearDensity, Mass>,
+        IMultiplyOperators<Length, LinearPowerDensity, Power>,
         IMultiplyOperators<Length, SpecificWeight, Pressure>,
         IDivisionOperators<Length, Volume, ReciprocalArea>,
         IMultiplyOperators<Length, ReciprocalArea, ReciprocalLength>,
@@ -57,6 +61,7 @@ namespace UnitsNet
         IMultiplyOperators<Length, TemperatureGradient, TemperatureDelta>,
         IMultiplyOperators<Length, Force, Torque>,
         IMultiplyOperators<Length, Area, Volume>,
+        IMultiplyOperators<Length, VolumePerLength, Volume>,
         IDivisionOperators<Length, ReciprocalArea, Volume>,
         IComparisonOperators<Length, Length, bool>,
         IParsable<Length>,
@@ -70,7 +75,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -120,7 +125,7 @@ public static LengthInfo CreateDefault(Func<IEnumerable<UnitDefinition<LengthUni
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Length"/> is [L].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Length"/> is L.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 0, 0, 0, 0, 0, 0);
 
@@ -135,56 +140,136 @@ public static LengthInfo CreateDefault(Func<IEnumerable<UnitDefinition<LengthUni
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{LengthUnit}"/> representing the default unit mappings for Length.</returns>
             public static IEnumerable<UnitDefinition<LengthUnit>> GetDefaultMappings()
             {
-                yield return new (LengthUnit.Angstrom, "Angstrom", "Angstroms", new BaseUnits(length: LengthUnit.Angstrom));
-                yield return new (LengthUnit.AstronomicalUnit, "AstronomicalUnit", "AstronomicalUnits", new BaseUnits(length: LengthUnit.AstronomicalUnit));
-                yield return new (LengthUnit.Centimeter, "Centimeter", "Centimeters", new BaseUnits(length: LengthUnit.Centimeter));
-                yield return new (LengthUnit.Chain, "Chain", "Chains", new BaseUnits(length: LengthUnit.Chain));
-                yield return new (LengthUnit.DataMile, "DataMile", "DataMiles", new BaseUnits(length: LengthUnit.DataMile));
-                yield return new (LengthUnit.Decameter, "Decameter", "Decameters", new BaseUnits(length: LengthUnit.Decameter));
-                yield return new (LengthUnit.Decimeter, "Decimeter", "Decimeters", new BaseUnits(length: LengthUnit.Decimeter));
-                yield return new (LengthUnit.DtpPica, "DtpPica", "DtpPicas", new BaseUnits(length: LengthUnit.DtpPica));
-                yield return new (LengthUnit.DtpPoint, "DtpPoint", "DtpPoints", new BaseUnits(length: LengthUnit.DtpPoint));
-                yield return new (LengthUnit.Fathom, "Fathom", "Fathoms", new BaseUnits(length: LengthUnit.Fathom));
-                yield return new (LengthUnit.Femtometer, "Femtometer", "Femtometers", new BaseUnits(length: LengthUnit.Femtometer));
-                yield return new (LengthUnit.Foot, "Foot", "Feet", new BaseUnits(length: LengthUnit.Foot));
-                yield return new (LengthUnit.Gigameter, "Gigameter", "Gigameters", new BaseUnits(length: LengthUnit.Gigameter));
-                yield return new (LengthUnit.Hand, "Hand", "Hands", new BaseUnits(length: LengthUnit.Hand));
-                yield return new (LengthUnit.Hectometer, "Hectometer", "Hectometers", new BaseUnits(length: LengthUnit.Hectometer));
-                yield return new (LengthUnit.Inch, "Inch", "Inches", new BaseUnits(length: LengthUnit.Inch));
-                yield return new (LengthUnit.Kilofoot, "Kilofoot", "Kilofeet", new BaseUnits(length: LengthUnit.Kilofoot));
-                yield return new (LengthUnit.KilolightYear, "KilolightYear", "KilolightYears", new BaseUnits(length: LengthUnit.KilolightYear));
-                yield return new (LengthUnit.Kilometer, "Kilometer", "Kilometers", new BaseUnits(length: LengthUnit.Kilometer));
-                yield return new (LengthUnit.Kiloparsec, "Kiloparsec", "Kiloparsecs", new BaseUnits(length: LengthUnit.Kiloparsec));
-                yield return new (LengthUnit.Kiloyard, "Kiloyard", "Kiloyards", new BaseUnits(length: LengthUnit.Kiloyard));
-                yield return new (LengthUnit.LightYear, "LightYear", "LightYears", new BaseUnits(length: LengthUnit.LightYear));
-                yield return new (LengthUnit.MegalightYear, "MegalightYear", "MegalightYears", new BaseUnits(length: LengthUnit.MegalightYear));
-                yield return new (LengthUnit.Megameter, "Megameter", "Megameters", new BaseUnits(length: LengthUnit.Megameter));
-                yield return new (LengthUnit.Megaparsec, "Megaparsec", "Megaparsecs", new BaseUnits(length: LengthUnit.Megaparsec));
+                yield return new (LengthUnit.Angstrom, "Angstrom", "Angstroms", new BaseUnits(length: LengthUnit.Angstrom),
+                     10000000000
+                );
+                yield return new (LengthUnit.AstronomicalUnit, "AstronomicalUnit", "AstronomicalUnits", new BaseUnits(length: LengthUnit.AstronomicalUnit),
+                     new QuantityValue(1, 149597870700)
+                );
+                yield return new (LengthUnit.Centimeter, "Centimeter", "Centimeters", new BaseUnits(length: LengthUnit.Centimeter),
+                     100
+                );
+                yield return new (LengthUnit.Chain, "Chain", "Chains", new BaseUnits(length: LengthUnit.Chain),
+                     new QuantityValue(625, 12573)
+                );
+                yield return new (LengthUnit.DataMile, "DataMile", "DataMiles", new BaseUnits(length: LengthUnit.DataMile),
+                     new QuantityValue(5, 9144)
+                );
+                yield return new (LengthUnit.Decameter, "Decameter", "Decameters", new BaseUnits(length: LengthUnit.Decameter),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (LengthUnit.Decimeter, "Decimeter", "Decimeters", new BaseUnits(length: LengthUnit.Decimeter),
+                     10
+                );
+                yield return new (LengthUnit.DtpPica, "DtpPica", "DtpPicas", new BaseUnits(length: LengthUnit.DtpPica),
+                     new QuantityValue(30000, 127)
+                );
+                yield return new (LengthUnit.DtpPoint, "DtpPoint", "DtpPoints", new BaseUnits(length: LengthUnit.DtpPoint),
+                     new QuantityValue(360000, 127)
+                );
+                yield return new (LengthUnit.Fathom, "Fathom", "Fathoms", new BaseUnits(length: LengthUnit.Fathom),
+                     new QuantityValue(625, 1143)
+                );
+                yield return new (LengthUnit.Femtometer, "Femtometer", "Femtometers", new BaseUnits(length: LengthUnit.Femtometer),
+                     1000000000000000
+                );
+                yield return new (LengthUnit.Foot, "Foot", "Feet", new BaseUnits(length: LengthUnit.Foot),
+                     new QuantityValue(1250, 381)
+                );
+                yield return new (LengthUnit.Gigameter, "Gigameter", "Gigameters", new BaseUnits(length: LengthUnit.Gigameter),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (LengthUnit.Hand, "Hand", "Hands", new BaseUnits(length: LengthUnit.Hand),
+                     new QuantityValue(1250, 127)
+                );
+                yield return new (LengthUnit.Hectometer, "Hectometer", "Hectometers", new BaseUnits(length: LengthUnit.Hectometer),
+                     new QuantityValue(1, 100)
+                );
+                yield return new (LengthUnit.Inch, "Inch", "Inches", new BaseUnits(length: LengthUnit.Inch),
+                     new QuantityValue(5000, 127)
+                );
+                yield return new (LengthUnit.Kilofoot, "Kilofoot", "Kilofeet", new BaseUnits(length: LengthUnit.Kilofoot),
+                     new QuantityValue(5, 1524)
+                );
+                yield return new (LengthUnit.KilolightYear, "KilolightYear", "KilolightYears", new BaseUnits(length: LengthUnit.KilolightYear),
+                     new QuantityValue(1, QuantityValue.PowerOfTen(7) * new BigInteger(946073047258))
+                );
+                yield return new (LengthUnit.Kilometer, "Kilometer", "Kilometers", new BaseUnits(length: LengthUnit.Kilometer),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (LengthUnit.Kiloparsec, "Kiloparsec", "Kiloparsecs", new BaseUnits(length: LengthUnit.Kiloparsec),
+                     new QuantityValue(1, QuantityValue.PowerOfTen(8) * new BigInteger(308567758128))
+                );
+                yield return new (LengthUnit.Kiloyard, "Kiloyard", "Kiloyards", new BaseUnits(length: LengthUnit.Kiloyard),
+                     new QuantityValue(5, 4572)
+                );
+                yield return new (LengthUnit.LightYear, "LightYear", "LightYears", new BaseUnits(length: LengthUnit.LightYear),
+                     new QuantityValue(1, 9460730472580000)
+                );
+                yield return new (LengthUnit.MegalightYear, "MegalightYear", "MegalightYears", new BaseUnits(length: LengthUnit.MegalightYear),
+                     new QuantityValue(1, QuantityValue.PowerOfTen(10) * new BigInteger(946073047258))
+                );
+                yield return new (LengthUnit.Megameter, "Megameter", "Megameters", new BaseUnits(length: LengthUnit.Megameter),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (LengthUnit.Megaparsec, "Megaparsec", "Megaparsecs", new BaseUnits(length: LengthUnit.Megaparsec),
+                     new QuantityValue(1, QuantityValue.PowerOfTen(11) * new BigInteger(308567758128))
+                );
                 yield return new (LengthUnit.Meter, "Meter", "Meters", new BaseUnits(length: LengthUnit.Meter));
-                yield return new (LengthUnit.Microinch, "Microinch", "Microinches", new BaseUnits(length: LengthUnit.Microinch));
-                yield return new (LengthUnit.Micrometer, "Micrometer", "Micrometers", new BaseUnits(length: LengthUnit.Micrometer));
-                yield return new (LengthUnit.Mil, "Mil", "Mils", new BaseUnits(length: LengthUnit.Mil));
-                yield return new (LengthUnit.Mile, "Mile", "Miles", new BaseUnits(length: LengthUnit.Mile));
-                yield return new (LengthUnit.Millimeter, "Millimeter", "Millimeters", new BaseUnits(length: LengthUnit.Millimeter));
-                yield return new (LengthUnit.Nanometer, "Nanometer", "Nanometers", new BaseUnits(length: LengthUnit.Nanometer));
-                yield return new (LengthUnit.NauticalMile, "NauticalMile", "NauticalMiles", new BaseUnits(length: LengthUnit.NauticalMile));
-                yield return new (LengthUnit.Parsec, "Parsec", "Parsecs", new BaseUnits(length: LengthUnit.Parsec));
-                yield return new (LengthUnit.Picometer, "Picometer", "Picometers", new BaseUnits(length: LengthUnit.Picometer));
-                yield return new (LengthUnit.PrinterPica, "PrinterPica", "PrinterPicas", new BaseUnits(length: LengthUnit.PrinterPica));
-                yield return new (LengthUnit.PrinterPoint, "PrinterPoint", "PrinterPoints", new BaseUnits(length: LengthUnit.PrinterPoint));
-                yield return new (LengthUnit.Shackle, "Shackle", "Shackles", new BaseUnits(length: LengthUnit.Shackle));
-                yield return new (LengthUnit.SolarRadius, "SolarRadius", "SolarRadiuses", new BaseUnits(length: LengthUnit.SolarRadius));
-                yield return new (LengthUnit.Twip, "Twip", "Twips", new BaseUnits(length: LengthUnit.Twip));
-                yield return new (LengthUnit.UsSurveyFoot, "UsSurveyFoot", "UsSurveyFeet", new BaseUnits(length: LengthUnit.UsSurveyFoot));
-                yield return new (LengthUnit.Yard, "Yard", "Yards", new BaseUnits(length: LengthUnit.Yard));
+                yield return new (LengthUnit.Microinch, "Microinch", "Microinches", new BaseUnits(length: LengthUnit.Microinch),
+                     new QuantityValue(5000000000, 127)
+                );
+                yield return new (LengthUnit.Micrometer, "Micrometer", "Micrometers", new BaseUnits(length: LengthUnit.Micrometer),
+                     1000000
+                );
+                yield return new (LengthUnit.Mil, "Mil", "Mils", new BaseUnits(length: LengthUnit.Mil),
+                     new QuantityValue(5000000, 127)
+                );
+                yield return new (LengthUnit.Mile, "Mile", "Miles", new BaseUnits(length: LengthUnit.Mile),
+                     new QuantityValue(125, 201168)
+                );
+                yield return new (LengthUnit.Millimeter, "Millimeter", "Millimeters", new BaseUnits(length: LengthUnit.Millimeter),
+                     1000
+                );
+                yield return new (LengthUnit.Nanometer, "Nanometer", "Nanometers", new BaseUnits(length: LengthUnit.Nanometer),
+                     1000000000
+                );
+                yield return new (LengthUnit.NauticalMile, "NauticalMile", "NauticalMiles", new BaseUnits(length: LengthUnit.NauticalMile),
+                     new QuantityValue(1, 1852)
+                );
+                yield return new (LengthUnit.Parsec, "Parsec", "Parsecs", new BaseUnits(length: LengthUnit.Parsec),
+                     new QuantityValue(1, 30856775812800000)
+                );
+                yield return new (LengthUnit.Picometer, "Picometer", "Picometers", new BaseUnits(length: LengthUnit.Picometer),
+                     1000000000000
+                );
+                yield return new (LengthUnit.PrinterPica, "PrinterPica", "PrinterPicas", new BaseUnits(length: LengthUnit.PrinterPica),
+                     new QuantityValue(60225, 254)
+                );
+                yield return new (LengthUnit.PrinterPoint, "PrinterPoint", "PrinterPoints", new BaseUnits(length: LengthUnit.PrinterPoint),
+                     new QuantityValue(361350, 127)
+                );
+                yield return new (LengthUnit.Shackle, "Shackle", "Shackles", new BaseUnits(length: LengthUnit.Shackle),
+                     new QuantityValue(125, 3429)
+                );
+                yield return new (LengthUnit.SolarRadius, "SolarRadius", "SolarRadiuses", new BaseUnits(length: LengthUnit.SolarRadius),
+                     new QuantityValue(1, 695700000)
+                );
+                yield return new (LengthUnit.Twip, "Twip", "Twips", new BaseUnits(length: LengthUnit.Twip),
+                     new QuantityValue(7200000, 127)
+                );
+                yield return new (LengthUnit.UsSurveyFoot, "UsSurveyFoot", "UsSurveyFeet", new BaseUnits(length: LengthUnit.UsSurveyFoot),
+                     new QuantityValue(3937, 1200)
+                );
+                yield return new (LengthUnit.Yard, "Yard", "Yards", new BaseUnits(length: LengthUnit.Yard),
+                     new QuantityValue(1250, 1143)
+                );
             }
         }
 
         static Length()
         {
-            Info = LengthInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(LengthInfo.CreateDefault);
         }
 
         /// <summary>
@@ -192,7 +277,7 @@ static Length()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Length(double value, LengthUnit unit)
+        public Length(QuantityValue value, LengthUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -206,7 +291,7 @@ public Length(double value, LengthUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Length(double value, UnitSystem unitSystem)
+        public Length(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -217,7 +302,8 @@ public Length(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Length" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Length, LengthUnit> Info { get; }
@@ -246,10 +332,8 @@ public Length(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public LengthUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -283,315 +367,219 @@ public Length(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Angstrom"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Angstrom"/>
         /// </summary>
-        public double Angstroms => As(LengthUnit.Angstrom);
+        public QuantityValue Angstroms => this.As(LengthUnit.Angstrom);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.AstronomicalUnit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.AstronomicalUnit"/>
         /// </summary>
-        public double AstronomicalUnits => As(LengthUnit.AstronomicalUnit);
+        public QuantityValue AstronomicalUnits => this.As(LengthUnit.AstronomicalUnit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Centimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Centimeter"/>
         /// </summary>
-        public double Centimeters => As(LengthUnit.Centimeter);
+        public QuantityValue Centimeters => this.As(LengthUnit.Centimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Chain"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Chain"/>
         /// </summary>
-        public double Chains => As(LengthUnit.Chain);
+        public QuantityValue Chains => this.As(LengthUnit.Chain);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.DataMile"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.DataMile"/>
         /// </summary>
-        public double DataMiles => As(LengthUnit.DataMile);
+        public QuantityValue DataMiles => this.As(LengthUnit.DataMile);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Decameter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Decameter"/>
         /// </summary>
-        public double Decameters => As(LengthUnit.Decameter);
+        public QuantityValue Decameters => this.As(LengthUnit.Decameter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Decimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Decimeter"/>
         /// </summary>
-        public double Decimeters => As(LengthUnit.Decimeter);
+        public QuantityValue Decimeters => this.As(LengthUnit.Decimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.DtpPica"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.DtpPica"/>
         /// </summary>
-        public double DtpPicas => As(LengthUnit.DtpPica);
+        public QuantityValue DtpPicas => this.As(LengthUnit.DtpPica);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.DtpPoint"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.DtpPoint"/>
         /// </summary>
-        public double DtpPoints => As(LengthUnit.DtpPoint);
+        public QuantityValue DtpPoints => this.As(LengthUnit.DtpPoint);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Fathom"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Fathom"/>
         /// </summary>
-        public double Fathoms => As(LengthUnit.Fathom);
+        public QuantityValue Fathoms => this.As(LengthUnit.Fathom);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Femtometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Femtometer"/>
         /// </summary>
-        public double Femtometers => As(LengthUnit.Femtometer);
+        public QuantityValue Femtometers => this.As(LengthUnit.Femtometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Foot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Foot"/>
         /// </summary>
-        public double Feet => As(LengthUnit.Foot);
+        public QuantityValue Feet => this.As(LengthUnit.Foot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Gigameter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Gigameter"/>
         /// </summary>
-        public double Gigameters => As(LengthUnit.Gigameter);
+        public QuantityValue Gigameters => this.As(LengthUnit.Gigameter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Hand"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Hand"/>
         /// </summary>
-        public double Hands => As(LengthUnit.Hand);
+        public QuantityValue Hands => this.As(LengthUnit.Hand);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Hectometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Hectometer"/>
         /// </summary>
-        public double Hectometers => As(LengthUnit.Hectometer);
+        public QuantityValue Hectometers => this.As(LengthUnit.Hectometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Inch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Inch"/>
         /// </summary>
-        public double Inches => As(LengthUnit.Inch);
+        public QuantityValue Inches => this.As(LengthUnit.Inch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Kilofoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Kilofoot"/>
         /// </summary>
-        public double Kilofeet => As(LengthUnit.Kilofoot);
+        public QuantityValue Kilofeet => this.As(LengthUnit.Kilofoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.KilolightYear"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.KilolightYear"/>
         /// </summary>
-        public double KilolightYears => As(LengthUnit.KilolightYear);
+        public QuantityValue KilolightYears => this.As(LengthUnit.KilolightYear);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Kilometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Kilometer"/>
         /// </summary>
-        public double Kilometers => As(LengthUnit.Kilometer);
+        public QuantityValue Kilometers => this.As(LengthUnit.Kilometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Kiloparsec"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Kiloparsec"/>
         /// </summary>
-        public double Kiloparsecs => As(LengthUnit.Kiloparsec);
+        public QuantityValue Kiloparsecs => this.As(LengthUnit.Kiloparsec);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Kiloyard"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Kiloyard"/>
         /// </summary>
-        public double Kiloyards => As(LengthUnit.Kiloyard);
+        public QuantityValue Kiloyards => this.As(LengthUnit.Kiloyard);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.LightYear"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.LightYear"/>
         /// </summary>
-        public double LightYears => As(LengthUnit.LightYear);
+        public QuantityValue LightYears => this.As(LengthUnit.LightYear);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.MegalightYear"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.MegalightYear"/>
         /// </summary>
-        public double MegalightYears => As(LengthUnit.MegalightYear);
+        public QuantityValue MegalightYears => this.As(LengthUnit.MegalightYear);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Megameter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Megameter"/>
         /// </summary>
-        public double Megameters => As(LengthUnit.Megameter);
+        public QuantityValue Megameters => this.As(LengthUnit.Megameter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Megaparsec"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Megaparsec"/>
         /// </summary>
-        public double Megaparsecs => As(LengthUnit.Megaparsec);
+        public QuantityValue Megaparsecs => this.As(LengthUnit.Megaparsec);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Meter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Meter"/>
         /// </summary>
-        public double Meters => As(LengthUnit.Meter);
+        public QuantityValue Meters => this.As(LengthUnit.Meter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Microinch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Microinch"/>
         /// </summary>
-        public double Microinches => As(LengthUnit.Microinch);
+        public QuantityValue Microinches => this.As(LengthUnit.Microinch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Micrometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Micrometer"/>
         /// </summary>
-        public double Micrometers => As(LengthUnit.Micrometer);
+        public QuantityValue Micrometers => this.As(LengthUnit.Micrometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Mil"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Mil"/>
         /// </summary>
-        public double Mils => As(LengthUnit.Mil);
+        public QuantityValue Mils => this.As(LengthUnit.Mil);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Mile"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Mile"/>
         /// </summary>
-        public double Miles => As(LengthUnit.Mile);
+        public QuantityValue Miles => this.As(LengthUnit.Mile);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Millimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Millimeter"/>
         /// </summary>
-        public double Millimeters => As(LengthUnit.Millimeter);
+        public QuantityValue Millimeters => this.As(LengthUnit.Millimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Nanometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Nanometer"/>
         /// </summary>
-        public double Nanometers => As(LengthUnit.Nanometer);
+        public QuantityValue Nanometers => this.As(LengthUnit.Nanometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.NauticalMile"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.NauticalMile"/>
         /// </summary>
-        public double NauticalMiles => As(LengthUnit.NauticalMile);
+        public QuantityValue NauticalMiles => this.As(LengthUnit.NauticalMile);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Parsec"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Parsec"/>
         /// </summary>
-        public double Parsecs => As(LengthUnit.Parsec);
+        public QuantityValue Parsecs => this.As(LengthUnit.Parsec);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Picometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Picometer"/>
         /// </summary>
-        public double Picometers => As(LengthUnit.Picometer);
+        public QuantityValue Picometers => this.As(LengthUnit.Picometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.PrinterPica"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.PrinterPica"/>
         /// </summary>
-        public double PrinterPicas => As(LengthUnit.PrinterPica);
+        public QuantityValue PrinterPicas => this.As(LengthUnit.PrinterPica);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.PrinterPoint"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.PrinterPoint"/>
         /// </summary>
-        public double PrinterPoints => As(LengthUnit.PrinterPoint);
+        public QuantityValue PrinterPoints => this.As(LengthUnit.PrinterPoint);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Shackle"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Shackle"/>
         /// </summary>
-        public double Shackles => As(LengthUnit.Shackle);
+        public QuantityValue Shackles => this.As(LengthUnit.Shackle);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.SolarRadius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.SolarRadius"/>
         /// </summary>
-        public double SolarRadiuses => As(LengthUnit.SolarRadius);
+        public QuantityValue SolarRadiuses => this.As(LengthUnit.SolarRadius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Twip"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Twip"/>
         /// </summary>
-        public double Twips => As(LengthUnit.Twip);
+        public QuantityValue Twips => this.As(LengthUnit.Twip);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.UsSurveyFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.UsSurveyFoot"/>
         /// </summary>
-        public double UsSurveyFeet => As(LengthUnit.UsSurveyFoot);
+        public QuantityValue UsSurveyFeet => this.As(LengthUnit.UsSurveyFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LengthUnit.Yard"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LengthUnit.Yard"/>
         /// </summary>
-        public double Yards => As(LengthUnit.Yard);
+        public QuantityValue Yards => this.As(LengthUnit.Yard);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: LengthUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Angstrom, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.AstronomicalUnit, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Centimeter, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Chain, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.DataMile, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Decameter, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Decimeter, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.DtpPica, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.DtpPoint, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Fathom, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Femtometer, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Foot, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Gigameter, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Hand, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Hectometer, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Inch, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Kilofoot, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.KilolightYear, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Kilometer, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Kiloparsec, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Kiloyard, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.LightYear, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.MegalightYear, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Megameter, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Megaparsec, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Microinch, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Micrometer, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Mil, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Mile, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Millimeter, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Nanometer, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.NauticalMile, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Parsec, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Picometer, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.PrinterPica, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.PrinterPoint, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Shackle, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.SolarRadius, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Twip, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.UsSurveyFoot, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Yard, LengthUnit.Meter, quantity => quantity.ToUnit(LengthUnit.Meter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Meter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> LengthUnit
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Angstrom, quantity => quantity.ToUnit(LengthUnit.Angstrom));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.AstronomicalUnit, quantity => quantity.ToUnit(LengthUnit.AstronomicalUnit));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Centimeter, quantity => quantity.ToUnit(LengthUnit.Centimeter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Chain, quantity => quantity.ToUnit(LengthUnit.Chain));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.DataMile, quantity => quantity.ToUnit(LengthUnit.DataMile));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Decameter, quantity => quantity.ToUnit(LengthUnit.Decameter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Decimeter, quantity => quantity.ToUnit(LengthUnit.Decimeter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.DtpPica, quantity => quantity.ToUnit(LengthUnit.DtpPica));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.DtpPoint, quantity => quantity.ToUnit(LengthUnit.DtpPoint));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Fathom, quantity => quantity.ToUnit(LengthUnit.Fathom));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Femtometer, quantity => quantity.ToUnit(LengthUnit.Femtometer));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Foot, quantity => quantity.ToUnit(LengthUnit.Foot));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Gigameter, quantity => quantity.ToUnit(LengthUnit.Gigameter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Hand, quantity => quantity.ToUnit(LengthUnit.Hand));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Hectometer, quantity => quantity.ToUnit(LengthUnit.Hectometer));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Inch, quantity => quantity.ToUnit(LengthUnit.Inch));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Kilofoot, quantity => quantity.ToUnit(LengthUnit.Kilofoot));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.KilolightYear, quantity => quantity.ToUnit(LengthUnit.KilolightYear));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Kilometer, quantity => quantity.ToUnit(LengthUnit.Kilometer));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Kiloparsec, quantity => quantity.ToUnit(LengthUnit.Kiloparsec));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Kiloyard, quantity => quantity.ToUnit(LengthUnit.Kiloyard));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.LightYear, quantity => quantity.ToUnit(LengthUnit.LightYear));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.MegalightYear, quantity => quantity.ToUnit(LengthUnit.MegalightYear));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Megameter, quantity => quantity.ToUnit(LengthUnit.Megameter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Megaparsec, quantity => quantity.ToUnit(LengthUnit.Megaparsec));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Microinch, quantity => quantity.ToUnit(LengthUnit.Microinch));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Micrometer, quantity => quantity.ToUnit(LengthUnit.Micrometer));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Mil, quantity => quantity.ToUnit(LengthUnit.Mil));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Mile, quantity => quantity.ToUnit(LengthUnit.Mile));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Millimeter, quantity => quantity.ToUnit(LengthUnit.Millimeter));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Nanometer, quantity => quantity.ToUnit(LengthUnit.Nanometer));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.NauticalMile, quantity => quantity.ToUnit(LengthUnit.NauticalMile));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Parsec, quantity => quantity.ToUnit(LengthUnit.Parsec));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Picometer, quantity => quantity.ToUnit(LengthUnit.Picometer));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.PrinterPica, quantity => quantity.ToUnit(LengthUnit.PrinterPica));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.PrinterPoint, quantity => quantity.ToUnit(LengthUnit.PrinterPoint));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Shackle, quantity => quantity.ToUnit(LengthUnit.Shackle));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.SolarRadius, quantity => quantity.ToUnit(LengthUnit.SolarRadius));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Twip, quantity => quantity.ToUnit(LengthUnit.Twip));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.UsSurveyFoot, quantity => quantity.ToUnit(LengthUnit.UsSurveyFoot));
-            unitConverter.SetConversionFunction<Length>(LengthUnit.Meter, LengthUnit.Yard, quantity => quantity.ToUnit(LengthUnit.Yard));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -620,7 +608,7 @@ public static string GetAbbreviation(LengthUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Angstrom"/>.
         /// </summary>
-        public static Length FromAngstroms(double value)
+        public static Length FromAngstroms(QuantityValue value)
         {
             return new Length(value, LengthUnit.Angstrom);
         }
@@ -628,7 +616,7 @@ public static Length FromAngstroms(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.AstronomicalUnit"/>.
         /// </summary>
-        public static Length FromAstronomicalUnits(double value)
+        public static Length FromAstronomicalUnits(QuantityValue value)
         {
             return new Length(value, LengthUnit.AstronomicalUnit);
         }
@@ -636,7 +624,7 @@ public static Length FromAstronomicalUnits(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Centimeter"/>.
         /// </summary>
-        public static Length FromCentimeters(double value)
+        public static Length FromCentimeters(QuantityValue value)
         {
             return new Length(value, LengthUnit.Centimeter);
         }
@@ -644,7 +632,7 @@ public static Length FromCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Chain"/>.
         /// </summary>
-        public static Length FromChains(double value)
+        public static Length FromChains(QuantityValue value)
         {
             return new Length(value, LengthUnit.Chain);
         }
@@ -652,7 +640,7 @@ public static Length FromChains(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DataMile"/>.
         /// </summary>
-        public static Length FromDataMiles(double value)
+        public static Length FromDataMiles(QuantityValue value)
         {
             return new Length(value, LengthUnit.DataMile);
         }
@@ -660,7 +648,7 @@ public static Length FromDataMiles(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Decameter"/>.
         /// </summary>
-        public static Length FromDecameters(double value)
+        public static Length FromDecameters(QuantityValue value)
         {
             return new Length(value, LengthUnit.Decameter);
         }
@@ -668,7 +656,7 @@ public static Length FromDecameters(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Decimeter"/>.
         /// </summary>
-        public static Length FromDecimeters(double value)
+        public static Length FromDecimeters(QuantityValue value)
         {
             return new Length(value, LengthUnit.Decimeter);
         }
@@ -676,7 +664,7 @@ public static Length FromDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DtpPica"/>.
         /// </summary>
-        public static Length FromDtpPicas(double value)
+        public static Length FromDtpPicas(QuantityValue value)
         {
             return new Length(value, LengthUnit.DtpPica);
         }
@@ -684,7 +672,7 @@ public static Length FromDtpPicas(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DtpPoint"/>.
         /// </summary>
-        public static Length FromDtpPoints(double value)
+        public static Length FromDtpPoints(QuantityValue value)
         {
             return new Length(value, LengthUnit.DtpPoint);
         }
@@ -692,7 +680,7 @@ public static Length FromDtpPoints(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Fathom"/>.
         /// </summary>
-        public static Length FromFathoms(double value)
+        public static Length FromFathoms(QuantityValue value)
         {
             return new Length(value, LengthUnit.Fathom);
         }
@@ -700,7 +688,7 @@ public static Length FromFathoms(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Femtometer"/>.
         /// </summary>
-        public static Length FromFemtometers(double value)
+        public static Length FromFemtometers(QuantityValue value)
         {
             return new Length(value, LengthUnit.Femtometer);
         }
@@ -708,7 +696,7 @@ public static Length FromFemtometers(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Foot"/>.
         /// </summary>
-        public static Length FromFeet(double value)
+        public static Length FromFeet(QuantityValue value)
         {
             return new Length(value, LengthUnit.Foot);
         }
@@ -716,7 +704,7 @@ public static Length FromFeet(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Gigameter"/>.
         /// </summary>
-        public static Length FromGigameters(double value)
+        public static Length FromGigameters(QuantityValue value)
         {
             return new Length(value, LengthUnit.Gigameter);
         }
@@ -724,7 +712,7 @@ public static Length FromGigameters(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Hand"/>.
         /// </summary>
-        public static Length FromHands(double value)
+        public static Length FromHands(QuantityValue value)
         {
             return new Length(value, LengthUnit.Hand);
         }
@@ -732,7 +720,7 @@ public static Length FromHands(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Hectometer"/>.
         /// </summary>
-        public static Length FromHectometers(double value)
+        public static Length FromHectometers(QuantityValue value)
         {
             return new Length(value, LengthUnit.Hectometer);
         }
@@ -740,7 +728,7 @@ public static Length FromHectometers(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Inch"/>.
         /// </summary>
-        public static Length FromInches(double value)
+        public static Length FromInches(QuantityValue value)
         {
             return new Length(value, LengthUnit.Inch);
         }
@@ -748,7 +736,7 @@ public static Length FromInches(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kilofoot"/>.
         /// </summary>
-        public static Length FromKilofeet(double value)
+        public static Length FromKilofeet(QuantityValue value)
         {
             return new Length(value, LengthUnit.Kilofoot);
         }
@@ -756,7 +744,7 @@ public static Length FromKilofeet(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.KilolightYear"/>.
         /// </summary>
-        public static Length FromKilolightYears(double value)
+        public static Length FromKilolightYears(QuantityValue value)
         {
             return new Length(value, LengthUnit.KilolightYear);
         }
@@ -764,7 +752,7 @@ public static Length FromKilolightYears(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kilometer"/>.
         /// </summary>
-        public static Length FromKilometers(double value)
+        public static Length FromKilometers(QuantityValue value)
         {
             return new Length(value, LengthUnit.Kilometer);
         }
@@ -772,7 +760,7 @@ public static Length FromKilometers(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kiloparsec"/>.
         /// </summary>
-        public static Length FromKiloparsecs(double value)
+        public static Length FromKiloparsecs(QuantityValue value)
         {
             return new Length(value, LengthUnit.Kiloparsec);
         }
@@ -780,7 +768,7 @@ public static Length FromKiloparsecs(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kiloyard"/>.
         /// </summary>
-        public static Length FromKiloyards(double value)
+        public static Length FromKiloyards(QuantityValue value)
         {
             return new Length(value, LengthUnit.Kiloyard);
         }
@@ -788,7 +776,7 @@ public static Length FromKiloyards(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.LightYear"/>.
         /// </summary>
-        public static Length FromLightYears(double value)
+        public static Length FromLightYears(QuantityValue value)
         {
             return new Length(value, LengthUnit.LightYear);
         }
@@ -796,7 +784,7 @@ public static Length FromLightYears(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.MegalightYear"/>.
         /// </summary>
-        public static Length FromMegalightYears(double value)
+        public static Length FromMegalightYears(QuantityValue value)
         {
             return new Length(value, LengthUnit.MegalightYear);
         }
@@ -804,7 +792,7 @@ public static Length FromMegalightYears(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Megameter"/>.
         /// </summary>
-        public static Length FromMegameters(double value)
+        public static Length FromMegameters(QuantityValue value)
         {
             return new Length(value, LengthUnit.Megameter);
         }
@@ -812,7 +800,7 @@ public static Length FromMegameters(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Megaparsec"/>.
         /// </summary>
-        public static Length FromMegaparsecs(double value)
+        public static Length FromMegaparsecs(QuantityValue value)
         {
             return new Length(value, LengthUnit.Megaparsec);
         }
@@ -820,7 +808,7 @@ public static Length FromMegaparsecs(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Meter"/>.
         /// </summary>
-        public static Length FromMeters(double value)
+        public static Length FromMeters(QuantityValue value)
         {
             return new Length(value, LengthUnit.Meter);
         }
@@ -828,7 +816,7 @@ public static Length FromMeters(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Microinch"/>.
         /// </summary>
-        public static Length FromMicroinches(double value)
+        public static Length FromMicroinches(QuantityValue value)
         {
             return new Length(value, LengthUnit.Microinch);
         }
@@ -836,7 +824,7 @@ public static Length FromMicroinches(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Micrometer"/>.
         /// </summary>
-        public static Length FromMicrometers(double value)
+        public static Length FromMicrometers(QuantityValue value)
         {
             return new Length(value, LengthUnit.Micrometer);
         }
@@ -844,7 +832,7 @@ public static Length FromMicrometers(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Mil"/>.
         /// </summary>
-        public static Length FromMils(double value)
+        public static Length FromMils(QuantityValue value)
         {
             return new Length(value, LengthUnit.Mil);
         }
@@ -852,7 +840,7 @@ public static Length FromMils(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Mile"/>.
         /// </summary>
-        public static Length FromMiles(double value)
+        public static Length FromMiles(QuantityValue value)
         {
             return new Length(value, LengthUnit.Mile);
         }
@@ -860,7 +848,7 @@ public static Length FromMiles(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Millimeter"/>.
         /// </summary>
-        public static Length FromMillimeters(double value)
+        public static Length FromMillimeters(QuantityValue value)
         {
             return new Length(value, LengthUnit.Millimeter);
         }
@@ -868,7 +856,7 @@ public static Length FromMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Nanometer"/>.
         /// </summary>
-        public static Length FromNanometers(double value)
+        public static Length FromNanometers(QuantityValue value)
         {
             return new Length(value, LengthUnit.Nanometer);
         }
@@ -876,7 +864,7 @@ public static Length FromNanometers(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.NauticalMile"/>.
         /// </summary>
-        public static Length FromNauticalMiles(double value)
+        public static Length FromNauticalMiles(QuantityValue value)
         {
             return new Length(value, LengthUnit.NauticalMile);
         }
@@ -884,7 +872,7 @@ public static Length FromNauticalMiles(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Parsec"/>.
         /// </summary>
-        public static Length FromParsecs(double value)
+        public static Length FromParsecs(QuantityValue value)
         {
             return new Length(value, LengthUnit.Parsec);
         }
@@ -892,7 +880,7 @@ public static Length FromParsecs(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Picometer"/>.
         /// </summary>
-        public static Length FromPicometers(double value)
+        public static Length FromPicometers(QuantityValue value)
         {
             return new Length(value, LengthUnit.Picometer);
         }
@@ -900,7 +888,7 @@ public static Length FromPicometers(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.PrinterPica"/>.
         /// </summary>
-        public static Length FromPrinterPicas(double value)
+        public static Length FromPrinterPicas(QuantityValue value)
         {
             return new Length(value, LengthUnit.PrinterPica);
         }
@@ -908,7 +896,7 @@ public static Length FromPrinterPicas(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.PrinterPoint"/>.
         /// </summary>
-        public static Length FromPrinterPoints(double value)
+        public static Length FromPrinterPoints(QuantityValue value)
         {
             return new Length(value, LengthUnit.PrinterPoint);
         }
@@ -916,7 +904,7 @@ public static Length FromPrinterPoints(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Shackle"/>.
         /// </summary>
-        public static Length FromShackles(double value)
+        public static Length FromShackles(QuantityValue value)
         {
             return new Length(value, LengthUnit.Shackle);
         }
@@ -924,7 +912,7 @@ public static Length FromShackles(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.SolarRadius"/>.
         /// </summary>
-        public static Length FromSolarRadiuses(double value)
+        public static Length FromSolarRadiuses(QuantityValue value)
         {
             return new Length(value, LengthUnit.SolarRadius);
         }
@@ -932,7 +920,7 @@ public static Length FromSolarRadiuses(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Twip"/>.
         /// </summary>
-        public static Length FromTwips(double value)
+        public static Length FromTwips(QuantityValue value)
         {
             return new Length(value, LengthUnit.Twip);
         }
@@ -940,7 +928,7 @@ public static Length FromTwips(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.UsSurveyFoot"/>.
         /// </summary>
-        public static Length FromUsSurveyFeet(double value)
+        public static Length FromUsSurveyFeet(QuantityValue value)
         {
             return new Length(value, LengthUnit.UsSurveyFoot);
         }
@@ -948,7 +936,7 @@ public static Length FromUsSurveyFeet(double value)
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Yard"/>.
         /// </summary>
-        public static Length FromYards(double value)
+        public static Length FromYards(QuantityValue value)
         {
             return new Length(value, LengthUnit.Yard);
         }
@@ -959,7 +947,7 @@ public static Length FromYards(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Length unit value.</returns>
-        public static Length From(double value, LengthUnit fromUnit)
+        public static Length From(QuantityValue value, LengthUnit fromUnit)
         {
             return new Length(value, fromUnit);
         }
@@ -1020,10 +1008,7 @@ public static Length Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Length Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Length, LengthUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Length, LengthUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -1051,11 +1036,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Length result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Length result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Length, LengthUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Length, LengthUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -1076,7 +1057,7 @@ public static LengthUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1087,7 +1068,7 @@ public static LengthUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LengthUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.LengthUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out LengthUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1102,7 +1083,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LengthUnit u
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out LengthUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1121,35 +1102,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Length"/> from adding two <see cref="Length"/>.</summary>
         public static Length operator +(Length left, Length right)
         {
-            return new Length(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Length(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Length"/> from subtracting two <see cref="Length"/>.</summary>
         public static Length operator -(Length left, Length right)
         {
-            return new Length(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Length(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Length"/> from multiplying value and <see cref="Length"/>.</summary>
-        public static Length operator *(double left, Length right)
+        public static Length operator *(QuantityValue left, Length right)
         {
             return new Length(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Length"/> from multiplying value and <see cref="Length"/>.</summary>
-        public static Length operator *(Length left, double right)
+        public static Length operator *(Length left, QuantityValue right)
         {
             return new Length(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Length"/> from dividing <see cref="Length"/> by value.</summary>
-        public static Length operator /(Length left, double right)
+        public static Length operator /(Length left, QuantityValue right)
         {
             return new Length(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Length"/> by <see cref="Length"/>.</summary>
-        public static double operator /(Length left, Length right)
+        public static QuantityValue operator /(Length left, Length right)
         {
             return left.Meters / right.Meters;
         }
@@ -1162,7 +1143,13 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <returns>The corresponding inverse quantity, <see cref="ReciprocalLength"/>.</returns>
         public ReciprocalLength Inverse()
         {
-            return ReciprocalLength.FromInverseMeters(1 / Meters);
+            return UnitConverter.Default.ConvertTo(Value, Unit, ReciprocalLength.Info);
+        }
+
+        /// <summary>Get <see cref="Area"/> from <see cref="Length"/> * <see cref="AreaPerLength"/>.</summary>
+        public static Area operator *(Length length, AreaPerLength areaPerLength)
+        {
+            return Area.FromSquareMeters(length.Meters * areaPerLength.SquareMetersPerMeter);
         }
 
         /// <summary>Get <see cref="Area"/> from <see cref="Length"/> * <see cref="Length"/>.</summary>
@@ -1177,6 +1164,12 @@ public ReciprocalLength Inverse()
             return Area.FromSquareMeters(length.Meters / reciprocalLength.InverseMeters);
         }
 
+        /// <summary>Get <see cref="AreaDensity"/> from <see cref="Length"/> * <see cref="Density"/>.</summary>
+        public static AreaDensity operator *(Length length, Density density)
+        {
+            return AreaDensity.FromKilogramsPerSquareMeter(length.Meters * density.KilogramsPerCubicMeter);
+        }
+
         /// <summary>Get <see cref="AreaMomentOfInertia"/> from <see cref="Length"/> * <see cref="Volume"/>.</summary>
         public static AreaMomentOfInertia operator *(Length length, Volume volume)
         {
@@ -1189,6 +1182,12 @@ public ReciprocalLength Inverse()
             return Duration.FromSeconds(length.Meters / speed.MetersPerSecond);
         }
 
+        /// <summary>Get <see cref="ElectricPotential"/> from <see cref="Length"/> * <see cref="ElectricField"/>.</summary>
+        public static ElectricPotential operator *(Length length, ElectricField electricField)
+        {
+            return ElectricPotential.FromVolts(length.Meters * electricField.VoltsPerMeter);
+        }
+
         /// <summary>Get <see cref="Force"/> from <see cref="Length"/> * <see cref="ForcePerLength"/>.</summary>
         public static Force operator *(Length length, ForcePerLength forcePerLength)
         {
@@ -1207,12 +1206,24 @@ public ReciprocalLength Inverse()
             return KinematicViscosity.FromSquareMetersPerSecond(length.Meters * speed.MetersPerSecond);
         }
 
+        /// <summary>Get <see cref="LinearDensity"/> from <see cref="Length"/> * <see cref="AreaDensity"/>.</summary>
+        public static LinearDensity operator *(Length length, AreaDensity areaDensity)
+        {
+            return LinearDensity.FromKilogramsPerMeter(length.Meters * areaDensity.KilogramsPerSquareMeter);
+        }
+
         /// <summary>Get <see cref="Mass"/> from <see cref="Length"/> * <see cref="LinearDensity"/>.</summary>
         public static Mass operator *(Length length, LinearDensity linearDensity)
         {
             return Mass.FromKilograms(length.Meters * linearDensity.KilogramsPerMeter);
         }
 
+        /// <summary>Get <see cref="Power"/> from <see cref="Length"/> * <see cref="LinearPowerDensity"/>.</summary>
+        public static Power operator *(Length length, LinearPowerDensity linearPowerDensity)
+        {
+            return Power.FromWatts(length.Meters * linearPowerDensity.WattsPerMeter);
+        }
+
         /// <summary>Get <see cref="Pressure"/> from <see cref="Length"/> * <see cref="SpecificWeight"/>.</summary>
         public static Pressure operator *(Length length, SpecificWeight specificWeight)
         {
@@ -1267,6 +1278,12 @@ public ReciprocalLength Inverse()
             return Volume.FromCubicMeters(length.Meters * area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="Volume"/> from <see cref="Length"/> * <see cref="VolumePerLength"/>.</summary>
+        public static Volume operator *(Length length, VolumePerLength volumePerLength)
+        {
+            return Volume.FromCubicMeters(length.Meters * volumePerLength.CubicMetersPerMeter);
+        }
+
         /// <summary>Get <see cref="Volume"/> from <see cref="Length"/> / <see cref="ReciprocalArea"/>.</summary>
         public static Volume operator /(Length length, ReciprocalArea reciprocalArea)
         {
@@ -1280,97 +1297,111 @@ public ReciprocalLength Inverse()
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Length left, Length right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Length left, Length right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Length left, Length right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Length left, Length right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Length"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Length other, Length tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Length"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Length)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Length left, Length right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Length"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Length other, Length tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Length"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Length,Length)"/>.
+        ///     See that operator (and <see cref="Equals(Length)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Length left, Length right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Length"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Length other, Length tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Length"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Length"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Length"/>, this method delegates to
+        ///     <see cref="Equals(Length)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Length otherQuantity))
+            if (obj is not Length otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Length"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Length other, Length tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Length"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Length other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Length.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Length), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Length"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Length)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Length otherQuantity)) throw new ArgumentException("Expected type Length.", nameof(obj));
+            if (obj is not Length otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Length>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Length"/> with another <see cref="Length"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Length"/> with another <see cref="Length"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1382,211 +1413,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Length other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(LengthUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<LengthUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Length to another Length with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Length with the specified unit.</returns>
-        public Length ToUnit(LengthUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Length"/> to another <see cref="Length"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Length with the specified unit.</returns>
-        public Length ToUnit(LengthUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Length), Unit, typeof(Length), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Length)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Length"/> to another <see cref="Length"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Length"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(LengthUnit unit, [NotNullWhen(true)] out Length? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Length? convertedOrNull = (Unit, unit) switch
-            {
-                // LengthUnit -> BaseUnit
-                (LengthUnit.Angstrom, LengthUnit.Meter) => new Length(_value * 1e-10, LengthUnit.Meter),
-                (LengthUnit.AstronomicalUnit, LengthUnit.Meter) => new Length(_value * 1.4959787070e11, LengthUnit.Meter),
-                (LengthUnit.Centimeter, LengthUnit.Meter) => new Length((_value) * 1e-2d, LengthUnit.Meter),
-                (LengthUnit.Chain, LengthUnit.Meter) => new Length(_value * 20.1168, LengthUnit.Meter),
-                (LengthUnit.DataMile, LengthUnit.Meter) => new Length(_value * 1828.8, LengthUnit.Meter),
-                (LengthUnit.Decameter, LengthUnit.Meter) => new Length((_value) * 1e1d, LengthUnit.Meter),
-                (LengthUnit.Decimeter, LengthUnit.Meter) => new Length((_value) * 1e-1d, LengthUnit.Meter),
-                (LengthUnit.DtpPica, LengthUnit.Meter) => new Length(_value * 2.54e-2 / 6, LengthUnit.Meter),
-                (LengthUnit.DtpPoint, LengthUnit.Meter) => new Length(_value * 2.54e-2 / 72, LengthUnit.Meter),
-                (LengthUnit.Fathom, LengthUnit.Meter) => new Length(_value * 1.8288, LengthUnit.Meter),
-                (LengthUnit.Femtometer, LengthUnit.Meter) => new Length((_value) * 1e-15d, LengthUnit.Meter),
-                (LengthUnit.Foot, LengthUnit.Meter) => new Length(_value * 0.3048, LengthUnit.Meter),
-                (LengthUnit.Gigameter, LengthUnit.Meter) => new Length((_value) * 1e9d, LengthUnit.Meter),
-                (LengthUnit.Hand, LengthUnit.Meter) => new Length(_value * 1.016e-1, LengthUnit.Meter),
-                (LengthUnit.Hectometer, LengthUnit.Meter) => new Length((_value) * 1e2d, LengthUnit.Meter),
-                (LengthUnit.Inch, LengthUnit.Meter) => new Length(_value * 2.54e-2, LengthUnit.Meter),
-                (LengthUnit.Kilofoot, LengthUnit.Meter) => new Length((_value * 0.3048) * 1e3d, LengthUnit.Meter),
-                (LengthUnit.KilolightYear, LengthUnit.Meter) => new Length((_value * 9.46073047258e15) * 1e3d, LengthUnit.Meter),
-                (LengthUnit.Kilometer, LengthUnit.Meter) => new Length((_value) * 1e3d, LengthUnit.Meter),
-                (LengthUnit.Kiloparsec, LengthUnit.Meter) => new Length((_value * 3.08567758128e16) * 1e3d, LengthUnit.Meter),
-                (LengthUnit.Kiloyard, LengthUnit.Meter) => new Length((_value * 0.9144) * 1e3d, LengthUnit.Meter),
-                (LengthUnit.LightYear, LengthUnit.Meter) => new Length(_value * 9.46073047258e15, LengthUnit.Meter),
-                (LengthUnit.MegalightYear, LengthUnit.Meter) => new Length((_value * 9.46073047258e15) * 1e6d, LengthUnit.Meter),
-                (LengthUnit.Megameter, LengthUnit.Meter) => new Length((_value) * 1e6d, LengthUnit.Meter),
-                (LengthUnit.Megaparsec, LengthUnit.Meter) => new Length((_value * 3.08567758128e16) * 1e6d, LengthUnit.Meter),
-                (LengthUnit.Microinch, LengthUnit.Meter) => new Length(_value * 2.54e-8, LengthUnit.Meter),
-                (LengthUnit.Micrometer, LengthUnit.Meter) => new Length((_value) * 1e-6d, LengthUnit.Meter),
-                (LengthUnit.Mil, LengthUnit.Meter) => new Length(_value * 2.54e-5, LengthUnit.Meter),
-                (LengthUnit.Mile, LengthUnit.Meter) => new Length(_value * 1609.344, LengthUnit.Meter),
-                (LengthUnit.Millimeter, LengthUnit.Meter) => new Length((_value) * 1e-3d, LengthUnit.Meter),
-                (LengthUnit.Nanometer, LengthUnit.Meter) => new Length((_value) * 1e-9d, LengthUnit.Meter),
-                (LengthUnit.NauticalMile, LengthUnit.Meter) => new Length(_value * 1852, LengthUnit.Meter),
-                (LengthUnit.Parsec, LengthUnit.Meter) => new Length(_value * 3.08567758128e16, LengthUnit.Meter),
-                (LengthUnit.Picometer, LengthUnit.Meter) => new Length((_value) * 1e-12d, LengthUnit.Meter),
-                (LengthUnit.PrinterPica, LengthUnit.Meter) => new Length(_value * 2.54e-2 * 400 / 2409, LengthUnit.Meter),
-                (LengthUnit.PrinterPoint, LengthUnit.Meter) => new Length(_value * 2.54e-2 / 72.27 , LengthUnit.Meter),
-                (LengthUnit.Shackle, LengthUnit.Meter) => new Length(_value * 27.432, LengthUnit.Meter),
-                (LengthUnit.SolarRadius, LengthUnit.Meter) => new Length(_value * 6.95700e8, LengthUnit.Meter),
-                (LengthUnit.Twip, LengthUnit.Meter) => new Length(_value * 2.54e-2 / 1440, LengthUnit.Meter),
-                (LengthUnit.UsSurveyFoot, LengthUnit.Meter) => new Length(_value * 1200 / 3937, LengthUnit.Meter),
-                (LengthUnit.Yard, LengthUnit.Meter) => new Length(_value * 0.9144, LengthUnit.Meter),
-
-                // BaseUnit -> LengthUnit
-                (LengthUnit.Meter, LengthUnit.Angstrom) => new Length(_value / 1e-10, LengthUnit.Angstrom),
-                (LengthUnit.Meter, LengthUnit.AstronomicalUnit) => new Length(_value / 1.4959787070e11, LengthUnit.AstronomicalUnit),
-                (LengthUnit.Meter, LengthUnit.Centimeter) => new Length((_value) / 1e-2d, LengthUnit.Centimeter),
-                (LengthUnit.Meter, LengthUnit.Chain) => new Length(_value / 20.1168, LengthUnit.Chain),
-                (LengthUnit.Meter, LengthUnit.DataMile) => new Length(_value / 1828.8, LengthUnit.DataMile),
-                (LengthUnit.Meter, LengthUnit.Decameter) => new Length((_value) / 1e1d, LengthUnit.Decameter),
-                (LengthUnit.Meter, LengthUnit.Decimeter) => new Length((_value) / 1e-1d, LengthUnit.Decimeter),
-                (LengthUnit.Meter, LengthUnit.DtpPica) => new Length(_value * 6 / 2.54e-2, LengthUnit.DtpPica),
-                (LengthUnit.Meter, LengthUnit.DtpPoint) => new Length(_value * 72 / 2.54e-2, LengthUnit.DtpPoint),
-                (LengthUnit.Meter, LengthUnit.Fathom) => new Length(_value / 1.8288, LengthUnit.Fathom),
-                (LengthUnit.Meter, LengthUnit.Femtometer) => new Length((_value) / 1e-15d, LengthUnit.Femtometer),
-                (LengthUnit.Meter, LengthUnit.Foot) => new Length(_value / 0.3048, LengthUnit.Foot),
-                (LengthUnit.Meter, LengthUnit.Gigameter) => new Length((_value) / 1e9d, LengthUnit.Gigameter),
-                (LengthUnit.Meter, LengthUnit.Hand) => new Length(_value / 1.016e-1, LengthUnit.Hand),
-                (LengthUnit.Meter, LengthUnit.Hectometer) => new Length((_value) / 1e2d, LengthUnit.Hectometer),
-                (LengthUnit.Meter, LengthUnit.Inch) => new Length(_value / 2.54e-2, LengthUnit.Inch),
-                (LengthUnit.Meter, LengthUnit.Kilofoot) => new Length((_value / 0.3048) / 1e3d, LengthUnit.Kilofoot),
-                (LengthUnit.Meter, LengthUnit.KilolightYear) => new Length((_value / 9.46073047258e15) / 1e3d, LengthUnit.KilolightYear),
-                (LengthUnit.Meter, LengthUnit.Kilometer) => new Length((_value) / 1e3d, LengthUnit.Kilometer),
-                (LengthUnit.Meter, LengthUnit.Kiloparsec) => new Length((_value / 3.08567758128e16) / 1e3d, LengthUnit.Kiloparsec),
-                (LengthUnit.Meter, LengthUnit.Kiloyard) => new Length((_value / 0.9144) / 1e3d, LengthUnit.Kiloyard),
-                (LengthUnit.Meter, LengthUnit.LightYear) => new Length(_value / 9.46073047258e15, LengthUnit.LightYear),
-                (LengthUnit.Meter, LengthUnit.MegalightYear) => new Length((_value / 9.46073047258e15) / 1e6d, LengthUnit.MegalightYear),
-                (LengthUnit.Meter, LengthUnit.Megameter) => new Length((_value) / 1e6d, LengthUnit.Megameter),
-                (LengthUnit.Meter, LengthUnit.Megaparsec) => new Length((_value / 3.08567758128e16) / 1e6d, LengthUnit.Megaparsec),
-                (LengthUnit.Meter, LengthUnit.Microinch) => new Length(_value / 2.54e-8, LengthUnit.Microinch),
-                (LengthUnit.Meter, LengthUnit.Micrometer) => new Length((_value) / 1e-6d, LengthUnit.Micrometer),
-                (LengthUnit.Meter, LengthUnit.Mil) => new Length(_value / 2.54e-5, LengthUnit.Mil),
-                (LengthUnit.Meter, LengthUnit.Mile) => new Length(_value / 1609.344, LengthUnit.Mile),
-                (LengthUnit.Meter, LengthUnit.Millimeter) => new Length((_value) / 1e-3d, LengthUnit.Millimeter),
-                (LengthUnit.Meter, LengthUnit.Nanometer) => new Length((_value) / 1e-9d, LengthUnit.Nanometer),
-                (LengthUnit.Meter, LengthUnit.NauticalMile) => new Length(_value / 1852, LengthUnit.NauticalMile),
-                (LengthUnit.Meter, LengthUnit.Parsec) => new Length(_value / 3.08567758128e16, LengthUnit.Parsec),
-                (LengthUnit.Meter, LengthUnit.Picometer) => new Length((_value) / 1e-12d, LengthUnit.Picometer),
-                (LengthUnit.Meter, LengthUnit.PrinterPica) => new Length(_value / (2.54e-2 * 400 / 2409), LengthUnit.PrinterPica),
-                (LengthUnit.Meter, LengthUnit.PrinterPoint) => new Length(_value * 72.27 / 2.54e-2, LengthUnit.PrinterPoint),
-                (LengthUnit.Meter, LengthUnit.Shackle) => new Length(_value / 27.432, LengthUnit.Shackle),
-                (LengthUnit.Meter, LengthUnit.SolarRadius) => new Length(_value / 6.95700e8, LengthUnit.SolarRadius),
-                (LengthUnit.Meter, LengthUnit.Twip) => new Length(_value * 1440 / 2.54e-2, LengthUnit.Twip),
-                (LengthUnit.Meter, LengthUnit.UsSurveyFoot) => new Length(_value * 3937 / 1200, LengthUnit.UsSurveyFoot),
-                (LengthUnit.Meter, LengthUnit.Yard) => new Length(_value / 0.9144, LengthUnit.Yard),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not LengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LengthUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is LengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<LengthUnit> IQuantity<LengthUnit>.ToUnit(LengthUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1600,11 +1429,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Level.g.cs b/UnitsNet/GeneratedCode/Quantities/Level.g.cs
index e7bb8464fc..6d11c15fa7 100644
--- a/UnitsNet/GeneratedCode/Quantities/Level.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Level.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Level is the logarithm of the ratio of a quantity Q to a reference value of that quantity, Q₀, expressed in dimensionless units.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Level :
         ILogarithmicQuantity<Level, LevelUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Level, Level, double>,
+        IDivisionOperators<Level, Level, QuantityValue>,
         IComparisonOperators<Level, Level, bool>,
         IParsable<Level>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -118,15 +117,15 @@ public static LevelInfo CreateDefault(Func<IEnumerable<UnitDefinition<LevelUnit>
             public static IEnumerable<UnitDefinition<LevelUnit>> GetDefaultMappings()
             {
                 yield return new (LevelUnit.Decibel, "Decibel", "Decibels", BaseUnits.Undefined);
-                yield return new (LevelUnit.Neper, "Neper", "Nepers", BaseUnits.Undefined);
+                yield return new (LevelUnit.Neper, "Neper", "Nepers", BaseUnits.Undefined,
+                     new QuantityValue(57564627, 500000000)
+                );
             }
         }
 
         static Level()
         {
-            Info = LevelInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(LevelInfo.CreateDefault);
         }
 
         /// <summary>
@@ -134,7 +133,7 @@ static Level()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Level(double value, LevelUnit unit)
+        public Level(QuantityValue value, LevelUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -145,7 +144,8 @@ public Level(double value, LevelUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Level" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Level, LevelUnit> Info { get; }
@@ -171,16 +171,14 @@ public Level(double value, LevelUnit unit)
         public static Level Zero => Info.Zero;
 
         /// <inheritdoc />
-        public static double LogarithmicScalingFactor {get;} = 10;
+        public static QuantityValue LogarithmicScalingFactor {get;} = 10;
 
         #endregion
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public LevelUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -208,7 +206,7 @@ public Level(double value, LevelUnit unit)
 #endif
 
 #if NETSTANDARD2_0
-        double ILogarithmicQuantity<Level>.LogarithmicScalingFactor => LogarithmicScalingFactor;
+        QuantityValue ILogarithmicQuantity<Level>.LogarithmicScalingFactor => LogarithmicScalingFactor;
 #endif
 
         #endregion
@@ -218,35 +216,19 @@ public Level(double value, LevelUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LevelUnit.Decibel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LevelUnit.Decibel"/>
         /// </summary>
-        public double Decibels => As(LevelUnit.Decibel);
+        public QuantityValue Decibels => this.As(LevelUnit.Decibel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LevelUnit.Neper"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LevelUnit.Neper"/>
         /// </summary>
-        public double Nepers => As(LevelUnit.Neper);
+        public QuantityValue Nepers => this.As(LevelUnit.Neper);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: LevelUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Level>(LevelUnit.Neper, LevelUnit.Decibel, quantity => quantity.ToUnit(LevelUnit.Decibel));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Level>(LevelUnit.Decibel, LevelUnit.Decibel, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> LevelUnit
-            unitConverter.SetConversionFunction<Level>(LevelUnit.Decibel, LevelUnit.Neper, quantity => quantity.ToUnit(LevelUnit.Neper));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -275,7 +257,7 @@ public static string GetAbbreviation(LevelUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Level"/> from <see cref="LevelUnit.Decibel"/>.
         /// </summary>
-        public static Level FromDecibels(double value)
+        public static Level FromDecibels(QuantityValue value)
         {
             return new Level(value, LevelUnit.Decibel);
         }
@@ -283,7 +265,7 @@ public static Level FromDecibels(double value)
         /// <summary>
         ///     Creates a <see cref="Level"/> from <see cref="LevelUnit.Neper"/>.
         /// </summary>
-        public static Level FromNepers(double value)
+        public static Level FromNepers(QuantityValue value)
         {
             return new Level(value, LevelUnit.Neper);
         }
@@ -294,7 +276,7 @@ public static Level FromNepers(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Level unit value.</returns>
-        public static Level From(double value, LevelUnit fromUnit)
+        public static Level From(QuantityValue value, LevelUnit fromUnit)
         {
             return new Level(value, fromUnit);
         }
@@ -355,10 +337,7 @@ public static Level Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Level Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Level, LevelUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Level, LevelUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -386,11 +365,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Level result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Level result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Level, LevelUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Level, LevelUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -411,7 +386,7 @@ public static LevelUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -422,7 +397,7 @@ public static LevelUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LevelUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.LevelUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out LevelUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -437,7 +412,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LevelUnit un
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out LevelUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -448,53 +423,51 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         #region Logarithmic Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static Level operator -(Level right)
+        public static Level operator -(Level quantity)
         {
-            return new Level(-right.Value, right.Unit);
+            return new Level(-quantity.Value, quantity.Unit);
         }
 
         /// <summary>Get <see cref="Level"/> from logarithmic addition of two <see cref="Level"/>.</summary>
+        /// <remarks>This operation involves a conversion of the values to linear space, which is not guaranteed to produce an exact value.
+        /// <para>The final result is rounded to 15 significant digits.</para>
+        /// </remarks>
         public static Level operator +(Level left, Level right)
         {
-            // Logarithmic addition
-            // Formula: 10 * log10(10^(x/10) + 10^(y/10))
-            return new Level(10 * Math.Log10(Math.Pow(10, left.Value / 10) + Math.Pow(10, right.ToUnit(left.Unit).Value / 10)), left.Unit);
+            return new Level(QuantityValueExtensions.AddWithLogScaling(left.Value, right.As(left.Unit), LogarithmicScalingFactor), left.Unit);
         }
 
         /// <summary>Get <see cref="Level"/> from logarithmic subtraction of two <see cref="Level"/>.</summary>
+        /// <remarks>This operation involves a conversion of the values to linear space, which is not guaranteed to produce an exact value.
+        /// <para>The final result is rounded to 15 significant digits.</para>
+        /// </remarks>
         public static Level operator -(Level left, Level right)
         {
-            // Logarithmic subtraction
-            // Formula: 10 * log10(10^(x/10) - 10^(y/10))
-            return new Level(10 * Math.Log10(Math.Pow(10, left.Value / 10) - Math.Pow(10, right.ToUnit(left.Unit).Value / 10)), left.Unit);
+            return new Level(QuantityValueExtensions.SubtractWithLogScaling(left.Value, right.As(left.Unit), LogarithmicScalingFactor), left.Unit);
         }
 
         /// <summary>Get <see cref="Level"/> from logarithmic multiplication of value and <see cref="Level"/>.</summary>
-        public static Level operator *(double left, Level right)
+        public static Level operator *(QuantityValue left, Level right)
         {
-            // Logarithmic multiplication = addition
             return new Level(left + right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Level"/> from logarithmic multiplication of value and <see cref="Level"/>.</summary>
-        public static Level operator *(Level left, double right)
+        public static Level operator *(Level left, QuantityValue right)
         {
-            // Logarithmic multiplication = addition
             return new Level(left.Value + right, left.Unit);
         }
 
         /// <summary>Get <see cref="Level"/> from logarithmic division of <see cref="Level"/> by value.</summary>
-        public static Level operator /(Level left, double right)
+        public static Level operator /(Level left, QuantityValue right)
         {
-            // Logarithmic division = subtraction
             return new Level(left.Value - right, left.Unit);
         }
 
         /// <summary>Get ratio value from logarithmic division of <see cref="Level"/> by <see cref="Level"/>.</summary>
-        public static double operator /(Level left, Level right)
+        public static QuantityValue operator /(Level left, Level right)
         {
-            // Logarithmic division = subtraction
-            return Convert.ToDouble(left.Value - right.ToUnit(left.Unit).Value);
+            return left.Value - right.As(left.Unit);
         }
 
         #endregion
@@ -504,97 +477,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Level left, Level right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Level left, Level right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Level left, Level right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Level left, Level right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Level"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Level other, Level tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Level"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Level)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Level left, Level right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Level"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Level other, Level tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Level"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Level,Level)"/>.
+        ///     See that operator (and <see cref="Equals(Level)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Level left, Level right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Level"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Level other, Level tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Level"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Level"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Level"/>, this method delegates to
+        ///     <see cref="Equals(Level)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Level otherQuantity))
+            if (obj is not Level otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Level"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Level other, Level tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Level"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Level other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Level.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Level), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Level"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Level)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Level otherQuantity)) throw new ArgumentException("Expected type Level.", nameof(obj));
+            if (obj is not Level otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Level>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Level"/> with another <see cref="Level"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Level"/> with another <see cref="Level"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -606,133 +593,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Level other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(LevelUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<LevelUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Level to another Level with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Level with the specified unit.</returns>
-        public Level ToUnit(LevelUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Level"/> to another <see cref="Level"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Level with the specified unit.</returns>
-        public Level ToUnit(LevelUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Level), Unit, typeof(Level), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Level)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Level"/> to another <see cref="Level"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Level"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(LevelUnit unit, [NotNullWhen(true)] out Level? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Level? convertedOrNull = (Unit, unit) switch
-            {
-                // LevelUnit -> BaseUnit
-                (LevelUnit.Neper, LevelUnit.Decibel) => new Level((1 / 0.115129254) * _value, LevelUnit.Decibel),
-
-                // BaseUnit -> LevelUnit
-                (LevelUnit.Decibel, LevelUnit.Neper) => new Level(0.115129254 * _value, LevelUnit.Neper),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not LevelUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LevelUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is LevelUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LevelUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<LevelUnit> IQuantity<LevelUnit>.ToUnit(LevelUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -744,11 +609,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
index a6d4bcc7e7..784cf6cf33 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,13 +36,17 @@ namespace UnitsNet
     ///     http://en.wikipedia.org/wiki/Linear_density
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct LinearDensity :
-        IArithmeticQuantity<LinearDensity, LinearDensityUnit>,
+        ILinearQuantity<LinearDensity, LinearDensityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<LinearDensity, LinearDensity, double>,
+        IDivisionOperators<LinearDensity, LinearDensity, QuantityValue>,
         IDivisionOperators<LinearDensity, Density, Area>,
+        IDivisionOperators<LinearDensity, Length, AreaDensity>,
         IDivisionOperators<LinearDensity, Area, Density>,
+        IMultiplyOperators<LinearDensity, Acceleration, ForcePerLength>,
+        IDivisionOperators<LinearDensity, AreaDensity, Length>,
         IMultiplyOperators<LinearDensity, Length, Mass>,
         IComparisonOperators<LinearDensity, LinearDensity, bool>,
         IParsable<LinearDensity>,
@@ -58,7 +60,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -108,7 +110,7 @@ public static LinearDensityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Li
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="LinearDensity"/> is [L^-1][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="LinearDensity"/> is L^-1M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 1, 0, 0, 0, 0, 0);
 
@@ -123,32 +125,64 @@ public static LinearDensityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Li
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{LinearDensityUnit}"/> representing the default unit mappings for LinearDensity.</returns>
             public static IEnumerable<UnitDefinition<LinearDensityUnit>> GetDefaultMappings()
             {
-                yield return new (LinearDensityUnit.GramPerCentimeter, "GramPerCentimeter", "GramsPerCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram));
-                yield return new (LinearDensityUnit.GramPerFoot, "GramPerFoot", "GramsPerFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Gram));
-                yield return new (LinearDensityUnit.GramPerMeter, "GramPerMeter", "GramsPerMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram));
-                yield return new (LinearDensityUnit.GramPerMillimeter, "GramPerMillimeter", "GramsPerMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram));
-                yield return new (LinearDensityUnit.KilogramPerCentimeter, "KilogramPerCentimeter", "KilogramsPerCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram));
-                yield return new (LinearDensityUnit.KilogramPerFoot, "KilogramPerFoot", "KilogramsPerFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Kilogram));
+                yield return new (LinearDensityUnit.GramPerCentimeter, "GramPerCentimeter", "GramsPerCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram),
+                     10
+                );
+                yield return new (LinearDensityUnit.GramPerFoot, "GramPerFoot", "GramsPerFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Gram),
+                     new QuantityValue(1524, 5)
+                );
+                yield return new (LinearDensityUnit.GramPerMeter, "GramPerMeter", "GramsPerMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram),
+                     1000
+                );
+                yield return new (LinearDensityUnit.GramPerMillimeter, "GramPerMillimeter", "GramsPerMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram),
+                     1
+                );
+                yield return new (LinearDensityUnit.KilogramPerCentimeter, "KilogramPerCentimeter", "KilogramsPerCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram),
+                     new QuantityValue(1, 100)
+                );
+                yield return new (LinearDensityUnit.KilogramPerFoot, "KilogramPerFoot", "KilogramsPerFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Kilogram),
+                     new QuantityValue(381, 1250)
+                );
                 yield return new (LinearDensityUnit.KilogramPerMeter, "KilogramPerMeter", "KilogramsPerMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram));
-                yield return new (LinearDensityUnit.KilogramPerMillimeter, "KilogramPerMillimeter", "KilogramsPerMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram));
-                yield return new (LinearDensityUnit.MicrogramPerCentimeter, "MicrogramPerCentimeter", "MicrogramsPerCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Microgram));
-                yield return new (LinearDensityUnit.MicrogramPerFoot, "MicrogramPerFoot", "MicrogramsPerFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Microgram));
-                yield return new (LinearDensityUnit.MicrogramPerMeter, "MicrogramPerMeter", "MicrogramsPerMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram));
-                yield return new (LinearDensityUnit.MicrogramPerMillimeter, "MicrogramPerMillimeter", "MicrogramsPerMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Microgram));
-                yield return new (LinearDensityUnit.MilligramPerCentimeter, "MilligramPerCentimeter", "MilligramsPerCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Milligram));
-                yield return new (LinearDensityUnit.MilligramPerFoot, "MilligramPerFoot", "MilligramsPerFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Milligram));
-                yield return new (LinearDensityUnit.MilligramPerMeter, "MilligramPerMeter", "MilligramsPerMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram));
-                yield return new (LinearDensityUnit.MilligramPerMillimeter, "MilligramPerMillimeter", "MilligramsPerMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Milligram));
-                yield return new (LinearDensityUnit.PoundPerFoot, "PoundPerFoot", "PoundsPerFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound));
-                yield return new (LinearDensityUnit.PoundPerInch, "PoundPerInch", "PoundsPerInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound));
+                yield return new (LinearDensityUnit.KilogramPerMillimeter, "KilogramPerMillimeter", "KilogramsPerMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (LinearDensityUnit.MicrogramPerCentimeter, "MicrogramPerCentimeter", "MicrogramsPerCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Microgram),
+                     10000000
+                );
+                yield return new (LinearDensityUnit.MicrogramPerFoot, "MicrogramPerFoot", "MicrogramsPerFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Microgram),
+                     304800000
+                );
+                yield return new (LinearDensityUnit.MicrogramPerMeter, "MicrogramPerMeter", "MicrogramsPerMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram),
+                     1000000000
+                );
+                yield return new (LinearDensityUnit.MicrogramPerMillimeter, "MicrogramPerMillimeter", "MicrogramsPerMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Microgram),
+                     1000000
+                );
+                yield return new (LinearDensityUnit.MilligramPerCentimeter, "MilligramPerCentimeter", "MilligramsPerCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Milligram),
+                     10000
+                );
+                yield return new (LinearDensityUnit.MilligramPerFoot, "MilligramPerFoot", "MilligramsPerFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Milligram),
+                     304800
+                );
+                yield return new (LinearDensityUnit.MilligramPerMeter, "MilligramPerMeter", "MilligramsPerMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram),
+                     1000000
+                );
+                yield return new (LinearDensityUnit.MilligramPerMillimeter, "MilligramPerMillimeter", "MilligramsPerMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Milligram),
+                     1000
+                );
+                yield return new (LinearDensityUnit.PoundPerFoot, "PoundPerFoot", "PoundsPerFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound),
+                     new QuantityValue(30480000, 45359237)
+                );
+                yield return new (LinearDensityUnit.PoundPerInch, "PoundPerInch", "PoundsPerInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound),
+                     new QuantityValue(2540000, 45359237)
+                );
             }
         }
 
         static LinearDensity()
         {
-            Info = LinearDensityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(LinearDensityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -156,7 +190,7 @@ static LinearDensity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public LinearDensity(double value, LinearDensityUnit unit)
+        public LinearDensity(QuantityValue value, LinearDensityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -170,7 +204,7 @@ public LinearDensity(double value, LinearDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public LinearDensity(double value, UnitSystem unitSystem)
+        public LinearDensity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -181,7 +215,8 @@ public LinearDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="LinearDensity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<LinearDensity, LinearDensityUnit> Info { get; }
@@ -210,10 +245,8 @@ public LinearDensity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public LinearDensityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -247,147 +280,99 @@ public LinearDensity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerCentimeter"/>
         /// </summary>
-        public double GramsPerCentimeter => As(LinearDensityUnit.GramPerCentimeter);
+        public QuantityValue GramsPerCentimeter => this.As(LinearDensityUnit.GramPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerFoot"/>
         /// </summary>
-        public double GramsPerFoot => As(LinearDensityUnit.GramPerFoot);
+        public QuantityValue GramsPerFoot => this.As(LinearDensityUnit.GramPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerMeter"/>
         /// </summary>
-        public double GramsPerMeter => As(LinearDensityUnit.GramPerMeter);
+        public QuantityValue GramsPerMeter => this.As(LinearDensityUnit.GramPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.GramPerMillimeter"/>
         /// </summary>
-        public double GramsPerMillimeter => As(LinearDensityUnit.GramPerMillimeter);
+        public QuantityValue GramsPerMillimeter => this.As(LinearDensityUnit.GramPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerCentimeter"/>
         /// </summary>
-        public double KilogramsPerCentimeter => As(LinearDensityUnit.KilogramPerCentimeter);
+        public QuantityValue KilogramsPerCentimeter => this.As(LinearDensityUnit.KilogramPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerFoot"/>
         /// </summary>
-        public double KilogramsPerFoot => As(LinearDensityUnit.KilogramPerFoot);
+        public QuantityValue KilogramsPerFoot => this.As(LinearDensityUnit.KilogramPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerMeter"/>
         /// </summary>
-        public double KilogramsPerMeter => As(LinearDensityUnit.KilogramPerMeter);
+        public QuantityValue KilogramsPerMeter => this.As(LinearDensityUnit.KilogramPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.KilogramPerMillimeter"/>
         /// </summary>
-        public double KilogramsPerMillimeter => As(LinearDensityUnit.KilogramPerMillimeter);
+        public QuantityValue KilogramsPerMillimeter => this.As(LinearDensityUnit.KilogramPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerCentimeter"/>
         /// </summary>
-        public double MicrogramsPerCentimeter => As(LinearDensityUnit.MicrogramPerCentimeter);
+        public QuantityValue MicrogramsPerCentimeter => this.As(LinearDensityUnit.MicrogramPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerFoot"/>
         /// </summary>
-        public double MicrogramsPerFoot => As(LinearDensityUnit.MicrogramPerFoot);
+        public QuantityValue MicrogramsPerFoot => this.As(LinearDensityUnit.MicrogramPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerMeter"/>
         /// </summary>
-        public double MicrogramsPerMeter => As(LinearDensityUnit.MicrogramPerMeter);
+        public QuantityValue MicrogramsPerMeter => this.As(LinearDensityUnit.MicrogramPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.MicrogramPerMillimeter"/>
         /// </summary>
-        public double MicrogramsPerMillimeter => As(LinearDensityUnit.MicrogramPerMillimeter);
+        public QuantityValue MicrogramsPerMillimeter => this.As(LinearDensityUnit.MicrogramPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerCentimeter"/>
         /// </summary>
-        public double MilligramsPerCentimeter => As(LinearDensityUnit.MilligramPerCentimeter);
+        public QuantityValue MilligramsPerCentimeter => this.As(LinearDensityUnit.MilligramPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerFoot"/>
         /// </summary>
-        public double MilligramsPerFoot => As(LinearDensityUnit.MilligramPerFoot);
+        public QuantityValue MilligramsPerFoot => this.As(LinearDensityUnit.MilligramPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerMeter"/>
         /// </summary>
-        public double MilligramsPerMeter => As(LinearDensityUnit.MilligramPerMeter);
+        public QuantityValue MilligramsPerMeter => this.As(LinearDensityUnit.MilligramPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.MilligramPerMillimeter"/>
         /// </summary>
-        public double MilligramsPerMillimeter => As(LinearDensityUnit.MilligramPerMillimeter);
+        public QuantityValue MilligramsPerMillimeter => this.As(LinearDensityUnit.MilligramPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.PoundPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.PoundPerFoot"/>
         /// </summary>
-        public double PoundsPerFoot => As(LinearDensityUnit.PoundPerFoot);
+        public QuantityValue PoundsPerFoot => this.As(LinearDensityUnit.PoundPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearDensityUnit.PoundPerInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearDensityUnit.PoundPerInch"/>
         /// </summary>
-        public double PoundsPerInch => As(LinearDensityUnit.PoundPerInch);
+        public QuantityValue PoundsPerInch => this.As(LinearDensityUnit.PoundPerInch);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: LinearDensityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.GramPerCentimeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.GramPerFoot, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.GramPerMeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.GramPerMillimeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerCentimeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerFoot, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMillimeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MicrogramPerCentimeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MicrogramPerFoot, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MicrogramPerMeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MicrogramPerMillimeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MilligramPerCentimeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MilligramPerFoot, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MilligramPerMeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.MilligramPerMillimeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.PoundPerFoot, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.PoundPerInch, LinearDensityUnit.KilogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.KilogramPerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> LinearDensityUnit
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.GramPerCentimeter, quantity => quantity.ToUnit(LinearDensityUnit.GramPerCentimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.GramPerFoot, quantity => quantity.ToUnit(LinearDensityUnit.GramPerFoot));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.GramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.GramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.GramPerMillimeter, quantity => quantity.ToUnit(LinearDensityUnit.GramPerMillimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.KilogramPerCentimeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerCentimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.KilogramPerFoot, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerFoot));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.KilogramPerMillimeter, quantity => quantity.ToUnit(LinearDensityUnit.KilogramPerMillimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MicrogramPerCentimeter, quantity => quantity.ToUnit(LinearDensityUnit.MicrogramPerCentimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MicrogramPerFoot, quantity => quantity.ToUnit(LinearDensityUnit.MicrogramPerFoot));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MicrogramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.MicrogramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MicrogramPerMillimeter, quantity => quantity.ToUnit(LinearDensityUnit.MicrogramPerMillimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MilligramPerCentimeter, quantity => quantity.ToUnit(LinearDensityUnit.MilligramPerCentimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MilligramPerFoot, quantity => quantity.ToUnit(LinearDensityUnit.MilligramPerFoot));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MilligramPerMeter, quantity => quantity.ToUnit(LinearDensityUnit.MilligramPerMeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MilligramPerMillimeter, quantity => quantity.ToUnit(LinearDensityUnit.MilligramPerMillimeter));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.PoundPerFoot, quantity => quantity.ToUnit(LinearDensityUnit.PoundPerFoot));
-            unitConverter.SetConversionFunction<LinearDensity>(LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.PoundPerInch, quantity => quantity.ToUnit(LinearDensityUnit.PoundPerInch));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -416,7 +401,7 @@ public static string GetAbbreviation(LinearDensityUnit unit, IFormatProvider? pr
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerCentimeter"/>.
         /// </summary>
-        public static LinearDensity FromGramsPerCentimeter(double value)
+        public static LinearDensity FromGramsPerCentimeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.GramPerCentimeter);
         }
@@ -424,7 +409,7 @@ public static LinearDensity FromGramsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerFoot"/>.
         /// </summary>
-        public static LinearDensity FromGramsPerFoot(double value)
+        public static LinearDensity FromGramsPerFoot(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.GramPerFoot);
         }
@@ -432,7 +417,7 @@ public static LinearDensity FromGramsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerMeter"/>.
         /// </summary>
-        public static LinearDensity FromGramsPerMeter(double value)
+        public static LinearDensity FromGramsPerMeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.GramPerMeter);
         }
@@ -440,7 +425,7 @@ public static LinearDensity FromGramsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerMillimeter"/>.
         /// </summary>
-        public static LinearDensity FromGramsPerMillimeter(double value)
+        public static LinearDensity FromGramsPerMillimeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.GramPerMillimeter);
         }
@@ -448,7 +433,7 @@ public static LinearDensity FromGramsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerCentimeter"/>.
         /// </summary>
-        public static LinearDensity FromKilogramsPerCentimeter(double value)
+        public static LinearDensity FromKilogramsPerCentimeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.KilogramPerCentimeter);
         }
@@ -456,7 +441,7 @@ public static LinearDensity FromKilogramsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerFoot"/>.
         /// </summary>
-        public static LinearDensity FromKilogramsPerFoot(double value)
+        public static LinearDensity FromKilogramsPerFoot(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.KilogramPerFoot);
         }
@@ -464,7 +449,7 @@ public static LinearDensity FromKilogramsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerMeter"/>.
         /// </summary>
-        public static LinearDensity FromKilogramsPerMeter(double value)
+        public static LinearDensity FromKilogramsPerMeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.KilogramPerMeter);
         }
@@ -472,7 +457,7 @@ public static LinearDensity FromKilogramsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerMillimeter"/>.
         /// </summary>
-        public static LinearDensity FromKilogramsPerMillimeter(double value)
+        public static LinearDensity FromKilogramsPerMillimeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.KilogramPerMillimeter);
         }
@@ -480,7 +465,7 @@ public static LinearDensity FromKilogramsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerCentimeter"/>.
         /// </summary>
-        public static LinearDensity FromMicrogramsPerCentimeter(double value)
+        public static LinearDensity FromMicrogramsPerCentimeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.MicrogramPerCentimeter);
         }
@@ -488,7 +473,7 @@ public static LinearDensity FromMicrogramsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerFoot"/>.
         /// </summary>
-        public static LinearDensity FromMicrogramsPerFoot(double value)
+        public static LinearDensity FromMicrogramsPerFoot(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.MicrogramPerFoot);
         }
@@ -496,7 +481,7 @@ public static LinearDensity FromMicrogramsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerMeter"/>.
         /// </summary>
-        public static LinearDensity FromMicrogramsPerMeter(double value)
+        public static LinearDensity FromMicrogramsPerMeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.MicrogramPerMeter);
         }
@@ -504,7 +489,7 @@ public static LinearDensity FromMicrogramsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerMillimeter"/>.
         /// </summary>
-        public static LinearDensity FromMicrogramsPerMillimeter(double value)
+        public static LinearDensity FromMicrogramsPerMillimeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.MicrogramPerMillimeter);
         }
@@ -512,7 +497,7 @@ public static LinearDensity FromMicrogramsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerCentimeter"/>.
         /// </summary>
-        public static LinearDensity FromMilligramsPerCentimeter(double value)
+        public static LinearDensity FromMilligramsPerCentimeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.MilligramPerCentimeter);
         }
@@ -520,7 +505,7 @@ public static LinearDensity FromMilligramsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerFoot"/>.
         /// </summary>
-        public static LinearDensity FromMilligramsPerFoot(double value)
+        public static LinearDensity FromMilligramsPerFoot(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.MilligramPerFoot);
         }
@@ -528,7 +513,7 @@ public static LinearDensity FromMilligramsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerMeter"/>.
         /// </summary>
-        public static LinearDensity FromMilligramsPerMeter(double value)
+        public static LinearDensity FromMilligramsPerMeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.MilligramPerMeter);
         }
@@ -536,7 +521,7 @@ public static LinearDensity FromMilligramsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerMillimeter"/>.
         /// </summary>
-        public static LinearDensity FromMilligramsPerMillimeter(double value)
+        public static LinearDensity FromMilligramsPerMillimeter(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.MilligramPerMillimeter);
         }
@@ -544,7 +529,7 @@ public static LinearDensity FromMilligramsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.PoundPerFoot"/>.
         /// </summary>
-        public static LinearDensity FromPoundsPerFoot(double value)
+        public static LinearDensity FromPoundsPerFoot(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.PoundPerFoot);
         }
@@ -552,7 +537,7 @@ public static LinearDensity FromPoundsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.PoundPerInch"/>.
         /// </summary>
-        public static LinearDensity FromPoundsPerInch(double value)
+        public static LinearDensity FromPoundsPerInch(QuantityValue value)
         {
             return new LinearDensity(value, LinearDensityUnit.PoundPerInch);
         }
@@ -563,7 +548,7 @@ public static LinearDensity FromPoundsPerInch(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>LinearDensity unit value.</returns>
-        public static LinearDensity From(double value, LinearDensityUnit fromUnit)
+        public static LinearDensity From(QuantityValue value, LinearDensityUnit fromUnit)
         {
             return new LinearDensity(value, fromUnit);
         }
@@ -624,10 +609,7 @@ public static LinearDensity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static LinearDensity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<LinearDensity, LinearDensityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<LinearDensity, LinearDensityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -655,11 +637,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out LinearDensity re
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out LinearDensity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<LinearDensity, LinearDensityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<LinearDensity, LinearDensityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -680,7 +658,7 @@ public static LinearDensityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -691,7 +669,7 @@ public static LinearDensityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LinearDensityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.LinearDensityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out LinearDensityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -706,7 +684,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LinearDensit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out LinearDensityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -725,35 +703,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="LinearDensity"/> from adding two <see cref="LinearDensity"/>.</summary>
         public static LinearDensity operator +(LinearDensity left, LinearDensity right)
         {
-            return new LinearDensity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new LinearDensity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="LinearDensity"/> from subtracting two <see cref="LinearDensity"/>.</summary>
         public static LinearDensity operator -(LinearDensity left, LinearDensity right)
         {
-            return new LinearDensity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new LinearDensity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="LinearDensity"/> from multiplying value and <see cref="LinearDensity"/>.</summary>
-        public static LinearDensity operator *(double left, LinearDensity right)
+        public static LinearDensity operator *(QuantityValue left, LinearDensity right)
         {
             return new LinearDensity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="LinearDensity"/> from multiplying value and <see cref="LinearDensity"/>.</summary>
-        public static LinearDensity operator *(LinearDensity left, double right)
+        public static LinearDensity operator *(LinearDensity left, QuantityValue right)
         {
             return new LinearDensity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="LinearDensity"/> from dividing <see cref="LinearDensity"/> by value.</summary>
-        public static LinearDensity operator /(LinearDensity left, double right)
+        public static LinearDensity operator /(LinearDensity left, QuantityValue right)
         {
             return new LinearDensity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="LinearDensity"/> by <see cref="LinearDensity"/>.</summary>
-        public static double operator /(LinearDensity left, LinearDensity right)
+        public static QuantityValue operator /(LinearDensity left, LinearDensity right)
         {
             return left.KilogramsPerMeter / right.KilogramsPerMeter;
         }
@@ -768,12 +746,30 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Area.FromSquareMeters(linearDensity.KilogramsPerMeter / density.KilogramsPerCubicMeter);
         }
 
+        /// <summary>Get <see cref="AreaDensity"/> from <see cref="LinearDensity"/> / <see cref="Length"/>.</summary>
+        public static AreaDensity operator /(LinearDensity linearDensity, Length length)
+        {
+            return AreaDensity.FromKilogramsPerSquareMeter(linearDensity.KilogramsPerMeter / length.Meters);
+        }
+
         /// <summary>Get <see cref="Density"/> from <see cref="LinearDensity"/> / <see cref="Area"/>.</summary>
         public static Density operator /(LinearDensity linearDensity, Area area)
         {
             return Density.FromKilogramsPerCubicMeter(linearDensity.KilogramsPerMeter / area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="ForcePerLength"/> from <see cref="LinearDensity"/> * <see cref="Acceleration"/>.</summary>
+        public static ForcePerLength operator *(LinearDensity linearDensity, Acceleration acceleration)
+        {
+            return ForcePerLength.FromNewtonsPerMeter(linearDensity.KilogramsPerMeter * acceleration.MetersPerSecondSquared);
+        }
+
+        /// <summary>Get <see cref="Length"/> from <see cref="LinearDensity"/> / <see cref="AreaDensity"/>.</summary>
+        public static Length operator /(LinearDensity linearDensity, AreaDensity areaDensity)
+        {
+            return Length.FromMeters(linearDensity.KilogramsPerMeter / areaDensity.KilogramsPerSquareMeter);
+        }
+
         /// <summary>Get <see cref="Mass"/> from <see cref="LinearDensity"/> * <see cref="Length"/>.</summary>
         public static Mass operator *(LinearDensity linearDensity, Length length)
         {
@@ -787,97 +783,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(LinearDensity left, LinearDensity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(LinearDensity left, LinearDensity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(LinearDensity left, LinearDensity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(LinearDensity left, LinearDensity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="LinearDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(LinearDensity other, LinearDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="LinearDensity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(LinearDensity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(LinearDensity left, LinearDensity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="LinearDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(LinearDensity other, LinearDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="LinearDensity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(LinearDensity,LinearDensity)"/>.
+        ///     See that operator (and <see cref="Equals(LinearDensity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(LinearDensity left, LinearDensity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="LinearDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(LinearDensity other, LinearDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="LinearDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="LinearDensity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="LinearDensity"/>, this method delegates to
+        ///     <see cref="Equals(LinearDensity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is LinearDensity otherQuantity))
+            if (obj is not LinearDensity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="LinearDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(LinearDensity other, LinearDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="LinearDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(LinearDensity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current LinearDensity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(LinearDensity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="LinearDensity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(LinearDensity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is LinearDensity otherQuantity)) throw new ArgumentException("Expected type LinearDensity.", nameof(obj));
+            if (obj is not LinearDensity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<LinearDensity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="LinearDensity"/> with another <see cref="LinearDensity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="LinearDensity"/> with another <see cref="LinearDensity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -889,163 +899,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(LinearDensity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(LinearDensityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<LinearDensityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this LinearDensity to another LinearDensity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A LinearDensity with the specified unit.</returns>
-        public LinearDensity ToUnit(LinearDensityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="LinearDensity"/> to another <see cref="LinearDensity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A LinearDensity with the specified unit.</returns>
-        public LinearDensity ToUnit(LinearDensityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(LinearDensity), Unit, typeof(LinearDensity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (LinearDensity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="LinearDensity"/> to another <see cref="LinearDensity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="LinearDensity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(LinearDensityUnit unit, [NotNullWhen(true)] out LinearDensity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            LinearDensity? convertedOrNull = (Unit, unit) switch
-            {
-                // LinearDensityUnit -> BaseUnit
-                (LinearDensityUnit.GramPerCentimeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity(_value * 1e-1, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.GramPerFoot, LinearDensityUnit.KilogramPerMeter) => new LinearDensity(_value * ( 1e-3 / 0.3048 ), LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.GramPerMeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity(_value * 1e-3, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.GramPerMillimeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity(_value, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.KilogramPerCentimeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value * 1e-1) * 1e3d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.KilogramPerFoot, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value * ( 1e-3 / 0.3048 )) * 1e3d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.KilogramPerMillimeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value) * 1e3d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.MicrogramPerCentimeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value * 1e-1) * 1e-6d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.MicrogramPerFoot, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value * ( 1e-3 / 0.3048 )) * 1e-6d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.MicrogramPerMeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value * 1e-3) * 1e-6d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.MicrogramPerMillimeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value) * 1e-6d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.MilligramPerCentimeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value * 1e-1) * 1e-3d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.MilligramPerFoot, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value * ( 1e-3 / 0.3048 )) * 1e-3d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.MilligramPerMeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value * 1e-3) * 1e-3d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.MilligramPerMillimeter, LinearDensityUnit.KilogramPerMeter) => new LinearDensity((_value) * 1e-3d, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.PoundPerFoot, LinearDensityUnit.KilogramPerMeter) => new LinearDensity(_value * 0.45359237 / 0.3048, LinearDensityUnit.KilogramPerMeter),
-                (LinearDensityUnit.PoundPerInch, LinearDensityUnit.KilogramPerMeter) => new LinearDensity(_value * 0.45359237 / 2.54e-2, LinearDensityUnit.KilogramPerMeter),
-
-                // BaseUnit -> LinearDensityUnit
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.GramPerCentimeter) => new LinearDensity(_value / 1e-1, LinearDensityUnit.GramPerCentimeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.GramPerFoot) => new LinearDensity(_value / ( 1e-3 / 0.3048 ), LinearDensityUnit.GramPerFoot),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.GramPerMeter) => new LinearDensity(_value / 1e-3, LinearDensityUnit.GramPerMeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.GramPerMillimeter) => new LinearDensity(_value, LinearDensityUnit.GramPerMillimeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.KilogramPerCentimeter) => new LinearDensity((_value / 1e-1) / 1e3d, LinearDensityUnit.KilogramPerCentimeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.KilogramPerFoot) => new LinearDensity((_value / ( 1e-3 / 0.3048 )) / 1e3d, LinearDensityUnit.KilogramPerFoot),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.KilogramPerMillimeter) => new LinearDensity((_value) / 1e3d, LinearDensityUnit.KilogramPerMillimeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MicrogramPerCentimeter) => new LinearDensity((_value / 1e-1) / 1e-6d, LinearDensityUnit.MicrogramPerCentimeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MicrogramPerFoot) => new LinearDensity((_value / ( 1e-3 / 0.3048 )) / 1e-6d, LinearDensityUnit.MicrogramPerFoot),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MicrogramPerMeter) => new LinearDensity((_value / 1e-3) / 1e-6d, LinearDensityUnit.MicrogramPerMeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MicrogramPerMillimeter) => new LinearDensity((_value) / 1e-6d, LinearDensityUnit.MicrogramPerMillimeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MilligramPerCentimeter) => new LinearDensity((_value / 1e-1) / 1e-3d, LinearDensityUnit.MilligramPerCentimeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MilligramPerFoot) => new LinearDensity((_value / ( 1e-3 / 0.3048 )) / 1e-3d, LinearDensityUnit.MilligramPerFoot),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MilligramPerMeter) => new LinearDensity((_value / 1e-3) / 1e-3d, LinearDensityUnit.MilligramPerMeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.MilligramPerMillimeter) => new LinearDensity((_value) / 1e-3d, LinearDensityUnit.MilligramPerMillimeter),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.PoundPerFoot) => new LinearDensity(_value * 0.3048 / 0.45359237, LinearDensityUnit.PoundPerFoot),
-                (LinearDensityUnit.KilogramPerMeter, LinearDensityUnit.PoundPerInch) => new LinearDensity(_value * 2.54e-2 / 0.45359237, LinearDensityUnit.PoundPerInch),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not LinearDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearDensityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is LinearDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<LinearDensityUnit> IQuantity<LinearDensityUnit>.ToUnit(LinearDensityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1059,11 +915,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
index b395fa2690..364ac7ce17 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     http://en.wikipedia.org/wiki/Linear_density
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct LinearPowerDensity :
-        IArithmeticQuantity<LinearPowerDensity, LinearPowerDensityUnit>,
+        ILinearQuantity<LinearPowerDensity, LinearPowerDensityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<LinearPowerDensity, LinearPowerDensity, double>,
+        IDivisionOperators<LinearPowerDensity, LinearPowerDensity, QuantityValue>,
+        IMultiplyOperators<LinearPowerDensity, Length, Power>,
         IComparisonOperators<LinearPowerDensity, LinearPowerDensity, bool>,
         IParsable<LinearPowerDensity>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static LinearPowerDensityInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="LinearPowerDensity"/> is [T^-3][L][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="LinearPowerDensity"/> is T^-3LM.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 1, -3, 0, 0, 0, 0);
 
@@ -120,39 +120,85 @@ public static LinearPowerDensityInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{LinearPowerDensityUnit}"/> representing the default unit mappings for LinearPowerDensity.</returns>
             public static IEnumerable<UnitDefinition<LinearPowerDensityUnit>> GetDefaultMappings()
             {
-                yield return new (LinearPowerDensityUnit.GigawattPerCentimeter, "GigawattPerCentimeter", "GigawattsPerCentimeter", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.GigawattPerFoot, "GigawattPerFoot", "GigawattsPerFoot", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.GigawattPerInch, "GigawattPerInch", "GigawattsPerInch", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.GigawattPerMeter, "GigawattPerMeter", "GigawattsPerMeter", new BaseUnits(length: LengthUnit.Gigameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (LinearPowerDensityUnit.GigawattPerMillimeter, "GigawattPerMillimeter", "GigawattsPerMillimeter", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.KilowattPerCentimeter, "KilowattPerCentimeter", "KilowattsPerCentimeter", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.KilowattPerFoot, "KilowattPerFoot", "KilowattsPerFoot", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.KilowattPerInch, "KilowattPerInch", "KilowattsPerInch", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.KilowattPerMeter, "KilowattPerMeter", "KilowattsPerMeter", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (LinearPowerDensityUnit.KilowattPerMillimeter, "KilowattPerMillimeter", "KilowattsPerMillimeter", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.MegawattPerCentimeter, "MegawattPerCentimeter", "MegawattsPerCentimeter", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.MegawattPerFoot, "MegawattPerFoot", "MegawattsPerFoot", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.MegawattPerInch, "MegawattPerInch", "MegawattsPerInch", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.MegawattPerMeter, "MegawattPerMeter", "MegawattsPerMeter", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (LinearPowerDensityUnit.MegawattPerMillimeter, "MegawattPerMillimeter", "MegawattsPerMillimeter", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.MilliwattPerCentimeter, "MilliwattPerCentimeter", "MilliwattsPerCentimeter", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.MilliwattPerFoot, "MilliwattPerFoot", "MilliwattsPerFoot", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.MilliwattPerInch, "MilliwattPerInch", "MilliwattsPerInch", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.MilliwattPerMeter, "MilliwattPerMeter", "MilliwattsPerMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (LinearPowerDensityUnit.MilliwattPerMillimeter, "MilliwattPerMillimeter", "MilliwattsPerMillimeter", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.WattPerCentimeter, "WattPerCentimeter", "WattsPerCentimeter", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.WattPerFoot, "WattPerFoot", "WattsPerFoot", BaseUnits.Undefined);
-                yield return new (LinearPowerDensityUnit.WattPerInch, "WattPerInch", "WattsPerInch", BaseUnits.Undefined);
+                yield return new (LinearPowerDensityUnit.GigawattPerCentimeter, "GigawattPerCentimeter", "GigawattsPerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000000000)
+                );
+                yield return new (LinearPowerDensityUnit.GigawattPerFoot, "GigawattPerFoot", "GigawattsPerFoot", BaseUnits.Undefined,
+                     new QuantityValue(381, 1250000000000)
+                );
+                yield return new (LinearPowerDensityUnit.GigawattPerInch, "GigawattPerInch", "GigawattsPerInch", BaseUnits.Undefined,
+                     new QuantityValue(127, 5000000000000)
+                );
+                yield return new (LinearPowerDensityUnit.GigawattPerMeter, "GigawattPerMeter", "GigawattsPerMeter", new BaseUnits(length: LengthUnit.Gigameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (LinearPowerDensityUnit.GigawattPerMillimeter, "GigawattPerMillimeter", "GigawattsPerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (LinearPowerDensityUnit.KilowattPerCentimeter, "KilowattPerCentimeter", "KilowattsPerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000)
+                );
+                yield return new (LinearPowerDensityUnit.KilowattPerFoot, "KilowattPerFoot", "KilowattsPerFoot", BaseUnits.Undefined,
+                     new QuantityValue(381, 1250000)
+                );
+                yield return new (LinearPowerDensityUnit.KilowattPerInch, "KilowattPerInch", "KilowattsPerInch", BaseUnits.Undefined,
+                     new QuantityValue(127, 5000000)
+                );
+                yield return new (LinearPowerDensityUnit.KilowattPerMeter, "KilowattPerMeter", "KilowattsPerMeter", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (LinearPowerDensityUnit.KilowattPerMillimeter, "KilowattPerMillimeter", "KilowattsPerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (LinearPowerDensityUnit.MegawattPerCentimeter, "MegawattPerCentimeter", "MegawattsPerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000000)
+                );
+                yield return new (LinearPowerDensityUnit.MegawattPerFoot, "MegawattPerFoot", "MegawattsPerFoot", BaseUnits.Undefined,
+                     new QuantityValue(381, 1250000000)
+                );
+                yield return new (LinearPowerDensityUnit.MegawattPerInch, "MegawattPerInch", "MegawattsPerInch", BaseUnits.Undefined,
+                     new QuantityValue(127, 5000000000)
+                );
+                yield return new (LinearPowerDensityUnit.MegawattPerMeter, "MegawattPerMeter", "MegawattsPerMeter", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (LinearPowerDensityUnit.MegawattPerMillimeter, "MegawattPerMillimeter", "MegawattsPerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (LinearPowerDensityUnit.MilliwattPerCentimeter, "MilliwattPerCentimeter", "MilliwattsPerCentimeter", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (LinearPowerDensityUnit.MilliwattPerFoot, "MilliwattPerFoot", "MilliwattsPerFoot", BaseUnits.Undefined,
+                     new QuantityValue(1524, 5)
+                );
+                yield return new (LinearPowerDensityUnit.MilliwattPerInch, "MilliwattPerInch", "MilliwattsPerInch", BaseUnits.Undefined,
+                     new QuantityValue(127, 5)
+                );
+                yield return new (LinearPowerDensityUnit.MilliwattPerMeter, "MilliwattPerMeter", "MilliwattsPerMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (LinearPowerDensityUnit.MilliwattPerMillimeter, "MilliwattPerMillimeter", "MilliwattsPerMillimeter", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (LinearPowerDensityUnit.WattPerCentimeter, "WattPerCentimeter", "WattsPerCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100)
+                );
+                yield return new (LinearPowerDensityUnit.WattPerFoot, "WattPerFoot", "WattsPerFoot", BaseUnits.Undefined,
+                     new QuantityValue(381, 1250)
+                );
+                yield return new (LinearPowerDensityUnit.WattPerInch, "WattPerInch", "WattsPerInch", BaseUnits.Undefined,
+                     new QuantityValue(127, 5000)
+                );
                 yield return new (LinearPowerDensityUnit.WattPerMeter, "WattPerMeter", "WattsPerMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (LinearPowerDensityUnit.WattPerMillimeter, "WattPerMillimeter", "WattsPerMillimeter", BaseUnits.Undefined);
+                yield return new (LinearPowerDensityUnit.WattPerMillimeter, "WattPerMillimeter", "WattsPerMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
             }
         }
 
         static LinearPowerDensity()
         {
-            Info = LinearPowerDensityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(LinearPowerDensityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -160,7 +206,7 @@ static LinearPowerDensity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public LinearPowerDensity(double value, LinearPowerDensityUnit unit)
+        public LinearPowerDensity(QuantityValue value, LinearPowerDensityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -174,7 +220,7 @@ public LinearPowerDensity(double value, LinearPowerDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public LinearPowerDensity(double value, UnitSystem unitSystem)
+        public LinearPowerDensity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -185,7 +231,8 @@ public LinearPowerDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="LinearPowerDensity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<LinearPowerDensity, LinearPowerDensityUnit> Info { get; }
@@ -214,10 +261,8 @@ public LinearPowerDensity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public LinearPowerDensityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -251,196 +296,134 @@ public LinearPowerDensity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerCentimeter"/>
         /// </summary>
-        public double GigawattsPerCentimeter => As(LinearPowerDensityUnit.GigawattPerCentimeter);
+        public QuantityValue GigawattsPerCentimeter => this.As(LinearPowerDensityUnit.GigawattPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerFoot"/>
         /// </summary>
-        public double GigawattsPerFoot => As(LinearPowerDensityUnit.GigawattPerFoot);
+        public QuantityValue GigawattsPerFoot => this.As(LinearPowerDensityUnit.GigawattPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerInch"/>
         /// </summary>
-        public double GigawattsPerInch => As(LinearPowerDensityUnit.GigawattPerInch);
+        public QuantityValue GigawattsPerInch => this.As(LinearPowerDensityUnit.GigawattPerInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerMeter"/>
         /// </summary>
-        public double GigawattsPerMeter => As(LinearPowerDensityUnit.GigawattPerMeter);
+        public QuantityValue GigawattsPerMeter => this.As(LinearPowerDensityUnit.GigawattPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.GigawattPerMillimeter"/>
         /// </summary>
-        public double GigawattsPerMillimeter => As(LinearPowerDensityUnit.GigawattPerMillimeter);
+        public QuantityValue GigawattsPerMillimeter => this.As(LinearPowerDensityUnit.GigawattPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerCentimeter"/>
         /// </summary>
-        public double KilowattsPerCentimeter => As(LinearPowerDensityUnit.KilowattPerCentimeter);
+        public QuantityValue KilowattsPerCentimeter => this.As(LinearPowerDensityUnit.KilowattPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerFoot"/>
         /// </summary>
-        public double KilowattsPerFoot => As(LinearPowerDensityUnit.KilowattPerFoot);
+        public QuantityValue KilowattsPerFoot => this.As(LinearPowerDensityUnit.KilowattPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerInch"/>
         /// </summary>
-        public double KilowattsPerInch => As(LinearPowerDensityUnit.KilowattPerInch);
+        public QuantityValue KilowattsPerInch => this.As(LinearPowerDensityUnit.KilowattPerInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerMeter"/>
         /// </summary>
-        public double KilowattsPerMeter => As(LinearPowerDensityUnit.KilowattPerMeter);
+        public QuantityValue KilowattsPerMeter => this.As(LinearPowerDensityUnit.KilowattPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.KilowattPerMillimeter"/>
         /// </summary>
-        public double KilowattsPerMillimeter => As(LinearPowerDensityUnit.KilowattPerMillimeter);
+        public QuantityValue KilowattsPerMillimeter => this.As(LinearPowerDensityUnit.KilowattPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerCentimeter"/>
         /// </summary>
-        public double MegawattsPerCentimeter => As(LinearPowerDensityUnit.MegawattPerCentimeter);
+        public QuantityValue MegawattsPerCentimeter => this.As(LinearPowerDensityUnit.MegawattPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerFoot"/>
         /// </summary>
-        public double MegawattsPerFoot => As(LinearPowerDensityUnit.MegawattPerFoot);
+        public QuantityValue MegawattsPerFoot => this.As(LinearPowerDensityUnit.MegawattPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerInch"/>
         /// </summary>
-        public double MegawattsPerInch => As(LinearPowerDensityUnit.MegawattPerInch);
+        public QuantityValue MegawattsPerInch => this.As(LinearPowerDensityUnit.MegawattPerInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerMeter"/>
         /// </summary>
-        public double MegawattsPerMeter => As(LinearPowerDensityUnit.MegawattPerMeter);
+        public QuantityValue MegawattsPerMeter => this.As(LinearPowerDensityUnit.MegawattPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MegawattPerMillimeter"/>
         /// </summary>
-        public double MegawattsPerMillimeter => As(LinearPowerDensityUnit.MegawattPerMillimeter);
+        public QuantityValue MegawattsPerMillimeter => this.As(LinearPowerDensityUnit.MegawattPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerCentimeter"/>
         /// </summary>
-        public double MilliwattsPerCentimeter => As(LinearPowerDensityUnit.MilliwattPerCentimeter);
+        public QuantityValue MilliwattsPerCentimeter => this.As(LinearPowerDensityUnit.MilliwattPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerFoot"/>
         /// </summary>
-        public double MilliwattsPerFoot => As(LinearPowerDensityUnit.MilliwattPerFoot);
+        public QuantityValue MilliwattsPerFoot => this.As(LinearPowerDensityUnit.MilliwattPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerInch"/>
         /// </summary>
-        public double MilliwattsPerInch => As(LinearPowerDensityUnit.MilliwattPerInch);
+        public QuantityValue MilliwattsPerInch => this.As(LinearPowerDensityUnit.MilliwattPerInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerMeter"/>
         /// </summary>
-        public double MilliwattsPerMeter => As(LinearPowerDensityUnit.MilliwattPerMeter);
+        public QuantityValue MilliwattsPerMeter => this.As(LinearPowerDensityUnit.MilliwattPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.MilliwattPerMillimeter"/>
         /// </summary>
-        public double MilliwattsPerMillimeter => As(LinearPowerDensityUnit.MilliwattPerMillimeter);
+        public QuantityValue MilliwattsPerMillimeter => this.As(LinearPowerDensityUnit.MilliwattPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerCentimeter"/>
         /// </summary>
-        public double WattsPerCentimeter => As(LinearPowerDensityUnit.WattPerCentimeter);
+        public QuantityValue WattsPerCentimeter => this.As(LinearPowerDensityUnit.WattPerCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerFoot"/>
         /// </summary>
-        public double WattsPerFoot => As(LinearPowerDensityUnit.WattPerFoot);
+        public QuantityValue WattsPerFoot => this.As(LinearPowerDensityUnit.WattPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerInch"/>
         /// </summary>
-        public double WattsPerInch => As(LinearPowerDensityUnit.WattPerInch);
+        public QuantityValue WattsPerInch => this.As(LinearPowerDensityUnit.WattPerInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerMeter"/>
         /// </summary>
-        public double WattsPerMeter => As(LinearPowerDensityUnit.WattPerMeter);
+        public QuantityValue WattsPerMeter => this.As(LinearPowerDensityUnit.WattPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LinearPowerDensityUnit.WattPerMillimeter"/>
         /// </summary>
-        public double WattsPerMillimeter => As(LinearPowerDensityUnit.WattPerMillimeter);
+        public QuantityValue WattsPerMillimeter => this.As(LinearPowerDensityUnit.WattPerMillimeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: LinearPowerDensityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.GigawattPerCentimeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.GigawattPerFoot, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.GigawattPerInch, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.GigawattPerMeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.GigawattPerMillimeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.KilowattPerCentimeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.KilowattPerFoot, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.KilowattPerInch, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.KilowattPerMeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.KilowattPerMillimeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MegawattPerCentimeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MegawattPerFoot, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MegawattPerInch, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MegawattPerMeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MegawattPerMillimeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MilliwattPerCentimeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MilliwattPerFoot, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MilliwattPerInch, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MilliwattPerMeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.MilliwattPerMillimeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerCentimeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerFoot, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerInch, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMillimeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.WattPerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> LinearPowerDensityUnit
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.GigawattPerCentimeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.GigawattPerCentimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.GigawattPerFoot, quantity => quantity.ToUnit(LinearPowerDensityUnit.GigawattPerFoot));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.GigawattPerInch, quantity => quantity.ToUnit(LinearPowerDensityUnit.GigawattPerInch));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.GigawattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.GigawattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.GigawattPerMillimeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.GigawattPerMillimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.KilowattPerCentimeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.KilowattPerCentimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.KilowattPerFoot, quantity => quantity.ToUnit(LinearPowerDensityUnit.KilowattPerFoot));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.KilowattPerInch, quantity => quantity.ToUnit(LinearPowerDensityUnit.KilowattPerInch));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.KilowattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.KilowattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.KilowattPerMillimeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.KilowattPerMillimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MegawattPerCentimeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.MegawattPerCentimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MegawattPerFoot, quantity => quantity.ToUnit(LinearPowerDensityUnit.MegawattPerFoot));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MegawattPerInch, quantity => quantity.ToUnit(LinearPowerDensityUnit.MegawattPerInch));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MegawattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.MegawattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MegawattPerMillimeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.MegawattPerMillimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MilliwattPerCentimeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.MilliwattPerCentimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MilliwattPerFoot, quantity => quantity.ToUnit(LinearPowerDensityUnit.MilliwattPerFoot));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MilliwattPerInch, quantity => quantity.ToUnit(LinearPowerDensityUnit.MilliwattPerInch));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MilliwattPerMeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.MilliwattPerMeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MilliwattPerMillimeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.MilliwattPerMillimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.WattPerCentimeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerCentimeter));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.WattPerFoot, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerFoot));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.WattPerInch, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerInch));
-            unitConverter.SetConversionFunction<LinearPowerDensity>(LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.WattPerMillimeter, quantity => quantity.ToUnit(LinearPowerDensityUnit.WattPerMillimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -469,7 +452,7 @@ public static string GetAbbreviation(LinearPowerDensityUnit unit, IFormatProvide
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerCentimeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromGigawattsPerCentimeter(double value)
+        public static LinearPowerDensity FromGigawattsPerCentimeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerCentimeter);
         }
@@ -477,7 +460,7 @@ public static LinearPowerDensity FromGigawattsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerFoot"/>.
         /// </summary>
-        public static LinearPowerDensity FromGigawattsPerFoot(double value)
+        public static LinearPowerDensity FromGigawattsPerFoot(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerFoot);
         }
@@ -485,7 +468,7 @@ public static LinearPowerDensity FromGigawattsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerInch"/>.
         /// </summary>
-        public static LinearPowerDensity FromGigawattsPerInch(double value)
+        public static LinearPowerDensity FromGigawattsPerInch(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerInch);
         }
@@ -493,7 +476,7 @@ public static LinearPowerDensity FromGigawattsPerInch(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerMeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromGigawattsPerMeter(double value)
+        public static LinearPowerDensity FromGigawattsPerMeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMeter);
         }
@@ -501,7 +484,7 @@ public static LinearPowerDensity FromGigawattsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerMillimeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromGigawattsPerMillimeter(double value)
+        public static LinearPowerDensity FromGigawattsPerMillimeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMillimeter);
         }
@@ -509,7 +492,7 @@ public static LinearPowerDensity FromGigawattsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerCentimeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromKilowattsPerCentimeter(double value)
+        public static LinearPowerDensity FromKilowattsPerCentimeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerCentimeter);
         }
@@ -517,7 +500,7 @@ public static LinearPowerDensity FromKilowattsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerFoot"/>.
         /// </summary>
-        public static LinearPowerDensity FromKilowattsPerFoot(double value)
+        public static LinearPowerDensity FromKilowattsPerFoot(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerFoot);
         }
@@ -525,7 +508,7 @@ public static LinearPowerDensity FromKilowattsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerInch"/>.
         /// </summary>
-        public static LinearPowerDensity FromKilowattsPerInch(double value)
+        public static LinearPowerDensity FromKilowattsPerInch(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerInch);
         }
@@ -533,7 +516,7 @@ public static LinearPowerDensity FromKilowattsPerInch(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerMeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromKilowattsPerMeter(double value)
+        public static LinearPowerDensity FromKilowattsPerMeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMeter);
         }
@@ -541,7 +524,7 @@ public static LinearPowerDensity FromKilowattsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerMillimeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromKilowattsPerMillimeter(double value)
+        public static LinearPowerDensity FromKilowattsPerMillimeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMillimeter);
         }
@@ -549,7 +532,7 @@ public static LinearPowerDensity FromKilowattsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerCentimeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromMegawattsPerCentimeter(double value)
+        public static LinearPowerDensity FromMegawattsPerCentimeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerCentimeter);
         }
@@ -557,7 +540,7 @@ public static LinearPowerDensity FromMegawattsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerFoot"/>.
         /// </summary>
-        public static LinearPowerDensity FromMegawattsPerFoot(double value)
+        public static LinearPowerDensity FromMegawattsPerFoot(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerFoot);
         }
@@ -565,7 +548,7 @@ public static LinearPowerDensity FromMegawattsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerInch"/>.
         /// </summary>
-        public static LinearPowerDensity FromMegawattsPerInch(double value)
+        public static LinearPowerDensity FromMegawattsPerInch(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerInch);
         }
@@ -573,7 +556,7 @@ public static LinearPowerDensity FromMegawattsPerInch(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerMeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromMegawattsPerMeter(double value)
+        public static LinearPowerDensity FromMegawattsPerMeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMeter);
         }
@@ -581,7 +564,7 @@ public static LinearPowerDensity FromMegawattsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerMillimeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromMegawattsPerMillimeter(double value)
+        public static LinearPowerDensity FromMegawattsPerMillimeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMillimeter);
         }
@@ -589,7 +572,7 @@ public static LinearPowerDensity FromMegawattsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerCentimeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromMilliwattsPerCentimeter(double value)
+        public static LinearPowerDensity FromMilliwattsPerCentimeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerCentimeter);
         }
@@ -597,7 +580,7 @@ public static LinearPowerDensity FromMilliwattsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerFoot"/>.
         /// </summary>
-        public static LinearPowerDensity FromMilliwattsPerFoot(double value)
+        public static LinearPowerDensity FromMilliwattsPerFoot(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerFoot);
         }
@@ -605,7 +588,7 @@ public static LinearPowerDensity FromMilliwattsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerInch"/>.
         /// </summary>
-        public static LinearPowerDensity FromMilliwattsPerInch(double value)
+        public static LinearPowerDensity FromMilliwattsPerInch(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerInch);
         }
@@ -613,7 +596,7 @@ public static LinearPowerDensity FromMilliwattsPerInch(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerMeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromMilliwattsPerMeter(double value)
+        public static LinearPowerDensity FromMilliwattsPerMeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMeter);
         }
@@ -621,7 +604,7 @@ public static LinearPowerDensity FromMilliwattsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerMillimeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromMilliwattsPerMillimeter(double value)
+        public static LinearPowerDensity FromMilliwattsPerMillimeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMillimeter);
         }
@@ -629,7 +612,7 @@ public static LinearPowerDensity FromMilliwattsPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerCentimeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromWattsPerCentimeter(double value)
+        public static LinearPowerDensity FromWattsPerCentimeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerCentimeter);
         }
@@ -637,7 +620,7 @@ public static LinearPowerDensity FromWattsPerCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerFoot"/>.
         /// </summary>
-        public static LinearPowerDensity FromWattsPerFoot(double value)
+        public static LinearPowerDensity FromWattsPerFoot(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerFoot);
         }
@@ -645,7 +628,7 @@ public static LinearPowerDensity FromWattsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerInch"/>.
         /// </summary>
-        public static LinearPowerDensity FromWattsPerInch(double value)
+        public static LinearPowerDensity FromWattsPerInch(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerInch);
         }
@@ -653,7 +636,7 @@ public static LinearPowerDensity FromWattsPerInch(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerMeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromWattsPerMeter(double value)
+        public static LinearPowerDensity FromWattsPerMeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMeter);
         }
@@ -661,7 +644,7 @@ public static LinearPowerDensity FromWattsPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerMillimeter"/>.
         /// </summary>
-        public static LinearPowerDensity FromWattsPerMillimeter(double value)
+        public static LinearPowerDensity FromWattsPerMillimeter(QuantityValue value)
         {
             return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMillimeter);
         }
@@ -672,7 +655,7 @@ public static LinearPowerDensity FromWattsPerMillimeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>LinearPowerDensity unit value.</returns>
-        public static LinearPowerDensity From(double value, LinearPowerDensityUnit fromUnit)
+        public static LinearPowerDensity From(QuantityValue value, LinearPowerDensityUnit fromUnit)
         {
             return new LinearPowerDensity(value, fromUnit);
         }
@@ -733,10 +716,7 @@ public static LinearPowerDensity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static LinearPowerDensity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<LinearPowerDensity, LinearPowerDensityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<LinearPowerDensity, LinearPowerDensityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -764,11 +744,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out LinearPowerDensi
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out LinearPowerDensity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<LinearPowerDensity, LinearPowerDensityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<LinearPowerDensity, LinearPowerDensityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -789,7 +765,7 @@ public static LinearPowerDensityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -800,7 +776,7 @@ public static LinearPowerDensityUnit ParseUnit(string str, IFormatProvider? prov
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LinearPowerDensityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.LinearPowerDensityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out LinearPowerDensityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -815,7 +791,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LinearPowerD
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out LinearPowerDensityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -834,137 +810,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="LinearPowerDensity"/> from adding two <see cref="LinearPowerDensity"/>.</summary>
         public static LinearPowerDensity operator +(LinearPowerDensity left, LinearPowerDensity right)
         {
-            return new LinearPowerDensity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new LinearPowerDensity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="LinearPowerDensity"/> from subtracting two <see cref="LinearPowerDensity"/>.</summary>
         public static LinearPowerDensity operator -(LinearPowerDensity left, LinearPowerDensity right)
         {
-            return new LinearPowerDensity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new LinearPowerDensity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="LinearPowerDensity"/> from multiplying value and <see cref="LinearPowerDensity"/>.</summary>
-        public static LinearPowerDensity operator *(double left, LinearPowerDensity right)
+        public static LinearPowerDensity operator *(QuantityValue left, LinearPowerDensity right)
         {
             return new LinearPowerDensity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="LinearPowerDensity"/> from multiplying value and <see cref="LinearPowerDensity"/>.</summary>
-        public static LinearPowerDensity operator *(LinearPowerDensity left, double right)
+        public static LinearPowerDensity operator *(LinearPowerDensity left, QuantityValue right)
         {
             return new LinearPowerDensity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="LinearPowerDensity"/> from dividing <see cref="LinearPowerDensity"/> by value.</summary>
-        public static LinearPowerDensity operator /(LinearPowerDensity left, double right)
+        public static LinearPowerDensity operator /(LinearPowerDensity left, QuantityValue right)
         {
             return new LinearPowerDensity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="LinearPowerDensity"/> by <see cref="LinearPowerDensity"/>.</summary>
-        public static double operator /(LinearPowerDensity left, LinearPowerDensity right)
+        public static QuantityValue operator /(LinearPowerDensity left, LinearPowerDensity right)
         {
             return left.WattsPerMeter / right.WattsPerMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Power"/> from <see cref="LinearPowerDensity"/> * <see cref="Length"/>.</summary>
+        public static Power operator *(LinearPowerDensity linearPowerDensity, Length length)
+        {
+            return Power.FromWatts(linearPowerDensity.WattsPerMeter * length.Meters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(LinearPowerDensity left, LinearPowerDensity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(LinearPowerDensity left, LinearPowerDensity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(LinearPowerDensity left, LinearPowerDensity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(LinearPowerDensity left, LinearPowerDensity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="LinearPowerDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(LinearPowerDensity other, LinearPowerDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="LinearPowerDensity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(LinearPowerDensity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(LinearPowerDensity left, LinearPowerDensity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="LinearPowerDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(LinearPowerDensity other, LinearPowerDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="LinearPowerDensity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(LinearPowerDensity,LinearPowerDensity)"/>.
+        ///     See that operator (and <see cref="Equals(LinearPowerDensity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(LinearPowerDensity left, LinearPowerDensity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="LinearPowerDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(LinearPowerDensity other, LinearPowerDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="LinearPowerDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="LinearPowerDensity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="LinearPowerDensity"/>, this method delegates to
+        ///     <see cref="Equals(LinearPowerDensity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is LinearPowerDensity otherQuantity))
+            if (obj is not LinearPowerDensity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="LinearPowerDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(LinearPowerDensity other, LinearPowerDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="LinearPowerDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(LinearPowerDensity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current LinearPowerDensity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(LinearPowerDensity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="LinearPowerDensity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(LinearPowerDensity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is LinearPowerDensity otherQuantity)) throw new ArgumentException("Expected type LinearPowerDensity.", nameof(obj));
+            if (obj is not LinearPowerDensity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<LinearPowerDensity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="LinearPowerDensity"/> with another <see cref="LinearPowerDensity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="LinearPowerDensity"/> with another <see cref="LinearPowerDensity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -976,177 +976,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(LinearPowerDensity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(LinearPowerDensityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<LinearPowerDensityUnit>());
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this LinearPowerDensity to another LinearPowerDensity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A LinearPowerDensity with the specified unit.</returns>
-        public LinearPowerDensity ToUnit(LinearPowerDensityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="LinearPowerDensity"/> to another <see cref="LinearPowerDensity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A LinearPowerDensity with the specified unit.</returns>
-        public LinearPowerDensity ToUnit(LinearPowerDensityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(LinearPowerDensity), Unit, typeof(LinearPowerDensity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (LinearPowerDensity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="LinearPowerDensity"/> to another <see cref="LinearPowerDensity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="LinearPowerDensity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(LinearPowerDensityUnit unit, [NotNullWhen(true)] out LinearPowerDensity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            LinearPowerDensity? convertedOrNull = (Unit, unit) switch
-            {
-                // LinearPowerDensityUnit -> BaseUnit
-                (LinearPowerDensityUnit.GigawattPerCentimeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value * 1e2) * 1e9d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.GigawattPerFoot, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value / 0.3048) * 1e9d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.GigawattPerInch, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value / 2.54e-2) * 1e9d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.GigawattPerMeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value) * 1e9d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.GigawattPerMillimeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value * 1e3) * 1e9d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.KilowattPerCentimeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value * 1e2) * 1e3d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.KilowattPerFoot, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value / 0.3048) * 1e3d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.KilowattPerInch, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value / 2.54e-2) * 1e3d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.KilowattPerMeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value) * 1e3d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.KilowattPerMillimeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value * 1e3) * 1e3d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.MegawattPerCentimeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value * 1e2) * 1e6d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.MegawattPerFoot, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value / 0.3048) * 1e6d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.MegawattPerInch, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value / 2.54e-2) * 1e6d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.MegawattPerMeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value) * 1e6d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.MegawattPerMillimeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value * 1e3) * 1e6d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.MilliwattPerCentimeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value * 1e2) * 1e-3d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.MilliwattPerFoot, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value / 0.3048) * 1e-3d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.MilliwattPerInch, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value / 2.54e-2) * 1e-3d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.MilliwattPerMeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value) * 1e-3d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.MilliwattPerMillimeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity((_value * 1e3) * 1e-3d, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.WattPerCentimeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity(_value * 1e2, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.WattPerFoot, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity(_value / 0.3048, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.WattPerInch, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity(_value / 2.54e-2, LinearPowerDensityUnit.WattPerMeter),
-                (LinearPowerDensityUnit.WattPerMillimeter, LinearPowerDensityUnit.WattPerMeter) => new LinearPowerDensity(_value * 1e3, LinearPowerDensityUnit.WattPerMeter),
-
-                // BaseUnit -> LinearPowerDensityUnit
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.GigawattPerCentimeter) => new LinearPowerDensity((_value / 1e2) / 1e9d, LinearPowerDensityUnit.GigawattPerCentimeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.GigawattPerFoot) => new LinearPowerDensity((_value * 0.3048) / 1e9d, LinearPowerDensityUnit.GigawattPerFoot),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.GigawattPerInch) => new LinearPowerDensity((_value * 2.54e-2) / 1e9d, LinearPowerDensityUnit.GigawattPerInch),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.GigawattPerMeter) => new LinearPowerDensity((_value) / 1e9d, LinearPowerDensityUnit.GigawattPerMeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.GigawattPerMillimeter) => new LinearPowerDensity((_value / 1e3) / 1e9d, LinearPowerDensityUnit.GigawattPerMillimeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.KilowattPerCentimeter) => new LinearPowerDensity((_value / 1e2) / 1e3d, LinearPowerDensityUnit.KilowattPerCentimeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.KilowattPerFoot) => new LinearPowerDensity((_value * 0.3048) / 1e3d, LinearPowerDensityUnit.KilowattPerFoot),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.KilowattPerInch) => new LinearPowerDensity((_value * 2.54e-2) / 1e3d, LinearPowerDensityUnit.KilowattPerInch),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.KilowattPerMeter) => new LinearPowerDensity((_value) / 1e3d, LinearPowerDensityUnit.KilowattPerMeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.KilowattPerMillimeter) => new LinearPowerDensity((_value / 1e3) / 1e3d, LinearPowerDensityUnit.KilowattPerMillimeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MegawattPerCentimeter) => new LinearPowerDensity((_value / 1e2) / 1e6d, LinearPowerDensityUnit.MegawattPerCentimeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MegawattPerFoot) => new LinearPowerDensity((_value * 0.3048) / 1e6d, LinearPowerDensityUnit.MegawattPerFoot),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MegawattPerInch) => new LinearPowerDensity((_value * 2.54e-2) / 1e6d, LinearPowerDensityUnit.MegawattPerInch),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MegawattPerMeter) => new LinearPowerDensity((_value) / 1e6d, LinearPowerDensityUnit.MegawattPerMeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MegawattPerMillimeter) => new LinearPowerDensity((_value / 1e3) / 1e6d, LinearPowerDensityUnit.MegawattPerMillimeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MilliwattPerCentimeter) => new LinearPowerDensity((_value / 1e2) / 1e-3d, LinearPowerDensityUnit.MilliwattPerCentimeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MilliwattPerFoot) => new LinearPowerDensity((_value * 0.3048) / 1e-3d, LinearPowerDensityUnit.MilliwattPerFoot),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MilliwattPerInch) => new LinearPowerDensity((_value * 2.54e-2) / 1e-3d, LinearPowerDensityUnit.MilliwattPerInch),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MilliwattPerMeter) => new LinearPowerDensity((_value) / 1e-3d, LinearPowerDensityUnit.MilliwattPerMeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.MilliwattPerMillimeter) => new LinearPowerDensity((_value / 1e3) / 1e-3d, LinearPowerDensityUnit.MilliwattPerMillimeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.WattPerCentimeter) => new LinearPowerDensity(_value / 1e2, LinearPowerDensityUnit.WattPerCentimeter),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.WattPerFoot) => new LinearPowerDensity(_value * 0.3048, LinearPowerDensityUnit.WattPerFoot),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.WattPerInch) => new LinearPowerDensity(_value * 2.54e-2, LinearPowerDensityUnit.WattPerInch),
-                (LinearPowerDensityUnit.WattPerMeter, LinearPowerDensityUnit.WattPerMillimeter) => new LinearPowerDensity(_value / 1e3, LinearPowerDensityUnit.WattPerMillimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not LinearPowerDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearPowerDensityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is LinearPowerDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearPowerDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<LinearPowerDensityUnit> IQuantity<LinearPowerDensityUnit>.ToUnit(LinearPowerDensityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1160,11 +992,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
index 6fced29fcb..4acd55edfd 100644
--- a/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Luminance
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Luminance :
-        IArithmeticQuantity<Luminance, LuminanceUnit>,
+        ILinearQuantity<Luminance, LuminanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Luminance, Luminance, double>,
+        IDivisionOperators<Luminance, Luminance, QuantityValue>,
         IMultiplyOperators<Luminance, Area, LuminousIntensity>,
         IComparisonOperators<Luminance, Luminance, bool>,
         IParsable<Luminance>,
@@ -56,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -106,7 +105,7 @@ public static LuminanceInfo CreateDefault(Func<IEnumerable<UnitDefinition<Lumina
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Luminance"/> is [L^-2][J].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Luminance"/> is L^-2J.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 0, 0, 0, 0, 0, 1);
 
@@ -121,24 +120,40 @@ public static LuminanceInfo CreateDefault(Func<IEnumerable<UnitDefinition<Lumina
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{LuminanceUnit}"/> representing the default unit mappings for Luminance.</returns>
             public static IEnumerable<UnitDefinition<LuminanceUnit>> GetDefaultMappings()
             {
-                yield return new (LuminanceUnit.CandelaPerSquareFoot, "CandelaPerSquareFoot", "CandelasPerSquareFoot", BaseUnits.Undefined);
-                yield return new (LuminanceUnit.CandelaPerSquareInch, "CandelaPerSquareInch", "CandelasPerSquareInch", BaseUnits.Undefined);
+                yield return new (LuminanceUnit.CandelaPerSquareFoot, "CandelaPerSquareFoot", "CandelasPerSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(145161, 1562500)
+                );
+                yield return new (LuminanceUnit.CandelaPerSquareInch, "CandelaPerSquareInch", "CandelasPerSquareInch", BaseUnits.Undefined,
+                     new QuantityValue(16129, 25000000)
+                );
                 yield return new (LuminanceUnit.CandelaPerSquareMeter, "CandelaPerSquareMeter", "CandelasPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, luminousIntensity: LuminousIntensityUnit.Candela));
-                yield return new (LuminanceUnit.CenticandelaPerSquareMeter, "CenticandelaPerSquareMeter", "CenticandelasPerSquareMeter", new BaseUnits(length: LengthUnit.Decameter, luminousIntensity: LuminousIntensityUnit.Candela));
-                yield return new (LuminanceUnit.DecicandelaPerSquareMeter, "DecicandelaPerSquareMeter", "DecicandelasPerSquareMeter", BaseUnits.Undefined);
-                yield return new (LuminanceUnit.KilocandelaPerSquareMeter, "KilocandelaPerSquareMeter", "KilocandelasPerSquareMeter", BaseUnits.Undefined);
-                yield return new (LuminanceUnit.MicrocandelaPerSquareMeter, "MicrocandelaPerSquareMeter", "MicrocandelasPerSquareMeter", new BaseUnits(length: LengthUnit.Kilometer, luminousIntensity: LuminousIntensityUnit.Candela));
-                yield return new (LuminanceUnit.MillicandelaPerSquareMeter, "MillicandelaPerSquareMeter", "MillicandelasPerSquareMeter", BaseUnits.Undefined);
-                yield return new (LuminanceUnit.NanocandelaPerSquareMeter, "NanocandelaPerSquareMeter", "NanocandelasPerSquareMeter", BaseUnits.Undefined);
-                yield return new (LuminanceUnit.Nit, "Nit", "Nits", BaseUnits.Undefined);
+                yield return new (LuminanceUnit.CenticandelaPerSquareMeter, "CenticandelaPerSquareMeter", "CenticandelasPerSquareMeter", new BaseUnits(length: LengthUnit.Decameter, luminousIntensity: LuminousIntensityUnit.Candela),
+                     100
+                );
+                yield return new (LuminanceUnit.DecicandelaPerSquareMeter, "DecicandelaPerSquareMeter", "DecicandelasPerSquareMeter", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (LuminanceUnit.KilocandelaPerSquareMeter, "KilocandelaPerSquareMeter", "KilocandelasPerSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (LuminanceUnit.MicrocandelaPerSquareMeter, "MicrocandelaPerSquareMeter", "MicrocandelasPerSquareMeter", new BaseUnits(length: LengthUnit.Kilometer, luminousIntensity: LuminousIntensityUnit.Candela),
+                     1000000
+                );
+                yield return new (LuminanceUnit.MillicandelaPerSquareMeter, "MillicandelaPerSquareMeter", "MillicandelasPerSquareMeter", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (LuminanceUnit.NanocandelaPerSquareMeter, "NanocandelaPerSquareMeter", "NanocandelasPerSquareMeter", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (LuminanceUnit.Nit, "Nit", "Nits", BaseUnits.Undefined,
+                     1
+                );
             }
         }
 
         static Luminance()
         {
-            Info = LuminanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(LuminanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -146,7 +161,7 @@ static Luminance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Luminance(double value, LuminanceUnit unit)
+        public Luminance(QuantityValue value, LuminanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -160,7 +175,7 @@ public Luminance(double value, LuminanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Luminance(double value, UnitSystem unitSystem)
+        public Luminance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -171,7 +186,8 @@ public Luminance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Luminance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Luminance, LuminanceUnit> Info { get; }
@@ -200,10 +216,8 @@ public Luminance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public LuminanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -237,91 +251,59 @@ public Luminance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.CandelaPerSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminanceUnit.CandelaPerSquareFoot"/>
         /// </summary>
-        public double CandelasPerSquareFoot => As(LuminanceUnit.CandelaPerSquareFoot);
+        public QuantityValue CandelasPerSquareFoot => this.As(LuminanceUnit.CandelaPerSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.CandelaPerSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminanceUnit.CandelaPerSquareInch"/>
         /// </summary>
-        public double CandelasPerSquareInch => As(LuminanceUnit.CandelaPerSquareInch);
+        public QuantityValue CandelasPerSquareInch => this.As(LuminanceUnit.CandelaPerSquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.CandelaPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminanceUnit.CandelaPerSquareMeter"/>
         /// </summary>
-        public double CandelasPerSquareMeter => As(LuminanceUnit.CandelaPerSquareMeter);
+        public QuantityValue CandelasPerSquareMeter => this.As(LuminanceUnit.CandelaPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.CenticandelaPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminanceUnit.CenticandelaPerSquareMeter"/>
         /// </summary>
-        public double CenticandelasPerSquareMeter => As(LuminanceUnit.CenticandelaPerSquareMeter);
+        public QuantityValue CenticandelasPerSquareMeter => this.As(LuminanceUnit.CenticandelaPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.DecicandelaPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminanceUnit.DecicandelaPerSquareMeter"/>
         /// </summary>
-        public double DecicandelasPerSquareMeter => As(LuminanceUnit.DecicandelaPerSquareMeter);
+        public QuantityValue DecicandelasPerSquareMeter => this.As(LuminanceUnit.DecicandelaPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.KilocandelaPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminanceUnit.KilocandelaPerSquareMeter"/>
         /// </summary>
-        public double KilocandelasPerSquareMeter => As(LuminanceUnit.KilocandelaPerSquareMeter);
+        public QuantityValue KilocandelasPerSquareMeter => this.As(LuminanceUnit.KilocandelaPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.MicrocandelaPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminanceUnit.MicrocandelaPerSquareMeter"/>
         /// </summary>
-        public double MicrocandelasPerSquareMeter => As(LuminanceUnit.MicrocandelaPerSquareMeter);
+        public QuantityValue MicrocandelasPerSquareMeter => this.As(LuminanceUnit.MicrocandelaPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.MillicandelaPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminanceUnit.MillicandelaPerSquareMeter"/>
         /// </summary>
-        public double MillicandelasPerSquareMeter => As(LuminanceUnit.MillicandelaPerSquareMeter);
+        public QuantityValue MillicandelasPerSquareMeter => this.As(LuminanceUnit.MillicandelaPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.NanocandelaPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminanceUnit.NanocandelaPerSquareMeter"/>
         /// </summary>
-        public double NanocandelasPerSquareMeter => As(LuminanceUnit.NanocandelaPerSquareMeter);
+        public QuantityValue NanocandelasPerSquareMeter => this.As(LuminanceUnit.NanocandelaPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminanceUnit.Nit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminanceUnit.Nit"/>
         /// </summary>
-        public double Nits => As(LuminanceUnit.Nit);
+        public QuantityValue Nits => this.As(LuminanceUnit.Nit);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: LuminanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareFoot, LuminanceUnit.CandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareInch, LuminanceUnit.CandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CenticandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.DecicandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.KilocandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.MicrocandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.MillicandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.NanocandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.Nit, LuminanceUnit.CandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> LuminanceUnit
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareFoot, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareFoot));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareInch, quantity => quantity.ToUnit(LuminanceUnit.CandelaPerSquareInch));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.CenticandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.CenticandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.DecicandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.DecicandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.KilocandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.KilocandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.MicrocandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.MicrocandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.MillicandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.MillicandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.NanocandelaPerSquareMeter, quantity => quantity.ToUnit(LuminanceUnit.NanocandelaPerSquareMeter));
-            unitConverter.SetConversionFunction<Luminance>(LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.Nit, quantity => quantity.ToUnit(LuminanceUnit.Nit));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -350,7 +332,7 @@ public static string GetAbbreviation(LuminanceUnit unit, IFormatProvider? provid
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareFoot"/>.
         /// </summary>
-        public static Luminance FromCandelasPerSquareFoot(double value)
+        public static Luminance FromCandelasPerSquareFoot(QuantityValue value)
         {
             return new Luminance(value, LuminanceUnit.CandelaPerSquareFoot);
         }
@@ -358,7 +340,7 @@ public static Luminance FromCandelasPerSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareInch"/>.
         /// </summary>
-        public static Luminance FromCandelasPerSquareInch(double value)
+        public static Luminance FromCandelasPerSquareInch(QuantityValue value)
         {
             return new Luminance(value, LuminanceUnit.CandelaPerSquareInch);
         }
@@ -366,7 +348,7 @@ public static Luminance FromCandelasPerSquareInch(double value)
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareMeter"/>.
         /// </summary>
-        public static Luminance FromCandelasPerSquareMeter(double value)
+        public static Luminance FromCandelasPerSquareMeter(QuantityValue value)
         {
             return new Luminance(value, LuminanceUnit.CandelaPerSquareMeter);
         }
@@ -374,7 +356,7 @@ public static Luminance FromCandelasPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CenticandelaPerSquareMeter"/>.
         /// </summary>
-        public static Luminance FromCenticandelasPerSquareMeter(double value)
+        public static Luminance FromCenticandelasPerSquareMeter(QuantityValue value)
         {
             return new Luminance(value, LuminanceUnit.CenticandelaPerSquareMeter);
         }
@@ -382,7 +364,7 @@ public static Luminance FromCenticandelasPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.DecicandelaPerSquareMeter"/>.
         /// </summary>
-        public static Luminance FromDecicandelasPerSquareMeter(double value)
+        public static Luminance FromDecicandelasPerSquareMeter(QuantityValue value)
         {
             return new Luminance(value, LuminanceUnit.DecicandelaPerSquareMeter);
         }
@@ -390,7 +372,7 @@ public static Luminance FromDecicandelasPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.KilocandelaPerSquareMeter"/>.
         /// </summary>
-        public static Luminance FromKilocandelasPerSquareMeter(double value)
+        public static Luminance FromKilocandelasPerSquareMeter(QuantityValue value)
         {
             return new Luminance(value, LuminanceUnit.KilocandelaPerSquareMeter);
         }
@@ -398,7 +380,7 @@ public static Luminance FromKilocandelasPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.MicrocandelaPerSquareMeter"/>.
         /// </summary>
-        public static Luminance FromMicrocandelasPerSquareMeter(double value)
+        public static Luminance FromMicrocandelasPerSquareMeter(QuantityValue value)
         {
             return new Luminance(value, LuminanceUnit.MicrocandelaPerSquareMeter);
         }
@@ -406,7 +388,7 @@ public static Luminance FromMicrocandelasPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.MillicandelaPerSquareMeter"/>.
         /// </summary>
-        public static Luminance FromMillicandelasPerSquareMeter(double value)
+        public static Luminance FromMillicandelasPerSquareMeter(QuantityValue value)
         {
             return new Luminance(value, LuminanceUnit.MillicandelaPerSquareMeter);
         }
@@ -414,7 +396,7 @@ public static Luminance FromMillicandelasPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.NanocandelaPerSquareMeter"/>.
         /// </summary>
-        public static Luminance FromNanocandelasPerSquareMeter(double value)
+        public static Luminance FromNanocandelasPerSquareMeter(QuantityValue value)
         {
             return new Luminance(value, LuminanceUnit.NanocandelaPerSquareMeter);
         }
@@ -422,7 +404,7 @@ public static Luminance FromNanocandelasPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.Nit"/>.
         /// </summary>
-        public static Luminance FromNits(double value)
+        public static Luminance FromNits(QuantityValue value)
         {
             return new Luminance(value, LuminanceUnit.Nit);
         }
@@ -433,7 +415,7 @@ public static Luminance FromNits(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Luminance unit value.</returns>
-        public static Luminance From(double value, LuminanceUnit fromUnit)
+        public static Luminance From(QuantityValue value, LuminanceUnit fromUnit)
         {
             return new Luminance(value, fromUnit);
         }
@@ -494,10 +476,7 @@ public static Luminance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Luminance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Luminance, LuminanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Luminance, LuminanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -525,11 +504,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Luminance result
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Luminance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Luminance, LuminanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Luminance, LuminanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -550,7 +525,7 @@ public static LuminanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -561,7 +536,7 @@ public static LuminanceUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LuminanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.LuminanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -576,7 +551,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminanceUni
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out LuminanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -595,35 +570,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Luminance"/> from adding two <see cref="Luminance"/>.</summary>
         public static Luminance operator +(Luminance left, Luminance right)
         {
-            return new Luminance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Luminance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Luminance"/> from subtracting two <see cref="Luminance"/>.</summary>
         public static Luminance operator -(Luminance left, Luminance right)
         {
-            return new Luminance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Luminance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Luminance"/> from multiplying value and <see cref="Luminance"/>.</summary>
-        public static Luminance operator *(double left, Luminance right)
+        public static Luminance operator *(QuantityValue left, Luminance right)
         {
             return new Luminance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Luminance"/> from multiplying value and <see cref="Luminance"/>.</summary>
-        public static Luminance operator *(Luminance left, double right)
+        public static Luminance operator *(Luminance left, QuantityValue right)
         {
             return new Luminance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Luminance"/> from dividing <see cref="Luminance"/> by value.</summary>
-        public static Luminance operator /(Luminance left, double right)
+        public static Luminance operator /(Luminance left, QuantityValue right)
         {
             return new Luminance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Luminance"/> by <see cref="Luminance"/>.</summary>
-        public static double operator /(Luminance left, Luminance right)
+        public static QuantityValue operator /(Luminance left, Luminance right)
         {
             return left.CandelasPerSquareMeter / right.CandelasPerSquareMeter;
         }
@@ -645,97 +620,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Luminance left, Luminance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Luminance left, Luminance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Luminance left, Luminance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Luminance left, Luminance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Luminance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Luminance other, Luminance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Luminance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Luminance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Luminance left, Luminance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Luminance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Luminance other, Luminance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Luminance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Luminance,Luminance)"/>.
+        ///     See that operator (and <see cref="Equals(Luminance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Luminance left, Luminance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Luminance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Luminance other, Luminance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Luminance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Luminance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Luminance"/>, this method delegates to
+        ///     <see cref="Equals(Luminance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Luminance otherQuantity))
+            if (obj is not Luminance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Luminance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Luminance other, Luminance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Luminance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Luminance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Luminance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Luminance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Luminance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Luminance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Luminance otherQuantity)) throw new ArgumentException("Expected type Luminance.", nameof(obj));
+            if (obj is not Luminance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Luminance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Luminance"/> with another <see cref="Luminance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Luminance"/> with another <see cref="Luminance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -747,147 +736,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Luminance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(LuminanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<LuminanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Luminance to another Luminance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Luminance with the specified unit.</returns>
-        public Luminance ToUnit(LuminanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="Luminance"/> to another <see cref="Luminance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Luminance with the specified unit.</returns>
-        public Luminance ToUnit(LuminanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Luminance), Unit, typeof(Luminance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Luminance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Luminance"/> to another <see cref="Luminance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Luminance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(LuminanceUnit unit, [NotNullWhen(true)] out Luminance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Luminance? convertedOrNull = (Unit, unit) switch
-            {
-                // LuminanceUnit -> BaseUnit
-                (LuminanceUnit.CandelaPerSquareFoot, LuminanceUnit.CandelaPerSquareMeter) => new Luminance(_value / 9.290304e-2, LuminanceUnit.CandelaPerSquareMeter),
-                (LuminanceUnit.CandelaPerSquareInch, LuminanceUnit.CandelaPerSquareMeter) => new Luminance(_value / 0.00064516, LuminanceUnit.CandelaPerSquareMeter),
-                (LuminanceUnit.CenticandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter) => new Luminance((_value) * 1e-2d, LuminanceUnit.CandelaPerSquareMeter),
-                (LuminanceUnit.DecicandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter) => new Luminance((_value) * 1e-1d, LuminanceUnit.CandelaPerSquareMeter),
-                (LuminanceUnit.KilocandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter) => new Luminance((_value) * 1e3d, LuminanceUnit.CandelaPerSquareMeter),
-                (LuminanceUnit.MicrocandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter) => new Luminance((_value) * 1e-6d, LuminanceUnit.CandelaPerSquareMeter),
-                (LuminanceUnit.MillicandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter) => new Luminance((_value) * 1e-3d, LuminanceUnit.CandelaPerSquareMeter),
-                (LuminanceUnit.NanocandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareMeter) => new Luminance((_value) * 1e-9d, LuminanceUnit.CandelaPerSquareMeter),
-                (LuminanceUnit.Nit, LuminanceUnit.CandelaPerSquareMeter) => new Luminance(_value, LuminanceUnit.CandelaPerSquareMeter),
-
-                // BaseUnit -> LuminanceUnit
-                (LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareFoot) => new Luminance(_value * 9.290304e-2, LuminanceUnit.CandelaPerSquareFoot),
-                (LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.CandelaPerSquareInch) => new Luminance(_value * 0.00064516, LuminanceUnit.CandelaPerSquareInch),
-                (LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.CenticandelaPerSquareMeter) => new Luminance((_value) / 1e-2d, LuminanceUnit.CenticandelaPerSquareMeter),
-                (LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.DecicandelaPerSquareMeter) => new Luminance((_value) / 1e-1d, LuminanceUnit.DecicandelaPerSquareMeter),
-                (LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.KilocandelaPerSquareMeter) => new Luminance((_value) / 1e3d, LuminanceUnit.KilocandelaPerSquareMeter),
-                (LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.MicrocandelaPerSquareMeter) => new Luminance((_value) / 1e-6d, LuminanceUnit.MicrocandelaPerSquareMeter),
-                (LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.MillicandelaPerSquareMeter) => new Luminance((_value) / 1e-3d, LuminanceUnit.MillicandelaPerSquareMeter),
-                (LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.NanocandelaPerSquareMeter) => new Luminance((_value) / 1e-9d, LuminanceUnit.NanocandelaPerSquareMeter),
-                (LuminanceUnit.CandelaPerSquareMeter, LuminanceUnit.Nit) => new Luminance(_value, LuminanceUnit.Nit),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not LuminanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is LuminanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<LuminanceUnit> IQuantity<LuminanceUnit>.ToUnit(LuminanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -901,11 +752,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
index 8781a3c8c0..d8c5cc4606 100644
--- a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Luminosity
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Luminosity :
-        IArithmeticQuantity<Luminosity, LuminosityUnit>,
+        ILinearQuantity<Luminosity, LuminosityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Luminosity, Luminosity, double>,
+        IDivisionOperators<Luminosity, Luminosity, QuantityValue>,
         IComparisonOperators<Luminosity, Luminosity, bool>,
         IParsable<Luminosity>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static LuminosityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Lumin
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Luminosity"/> is [T^-3][L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Luminosity"/> is T^-3L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
 
@@ -120,28 +119,52 @@ public static LuminosityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Lumin
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{LuminosityUnit}"/> representing the default unit mappings for Luminosity.</returns>
             public static IEnumerable<UnitDefinition<LuminosityUnit>> GetDefaultMappings()
             {
-                yield return new (LuminosityUnit.Decawatt, "Decawatt", "Decawatts", BaseUnits.Undefined);
-                yield return new (LuminosityUnit.Deciwatt, "Deciwatt", "Deciwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Hectogram, time: DurationUnit.Second));
-                yield return new (LuminosityUnit.Femtowatt, "Femtowatt", "Femtowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Picogram, time: DurationUnit.Second));
-                yield return new (LuminosityUnit.Gigawatt, "Gigawatt", "Gigawatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond));
-                yield return new (LuminosityUnit.Kilowatt, "Kilowatt", "Kilowatts", BaseUnits.Undefined);
-                yield return new (LuminosityUnit.Megawatt, "Megawatt", "Megawatts", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (LuminosityUnit.Microwatt, "Microwatt", "Microwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second));
-                yield return new (LuminosityUnit.Milliwatt, "Milliwatt", "Milliwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (LuminosityUnit.Nanowatt, "Nanowatt", "Nanowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second));
-                yield return new (LuminosityUnit.Petawatt, "Petawatt", "Petawatts", BaseUnits.Undefined);
-                yield return new (LuminosityUnit.Picowatt, "Picowatt", "Picowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second));
-                yield return new (LuminosityUnit.SolarLuminosity, "SolarLuminosity", "SolarLuminosities", BaseUnits.Undefined);
-                yield return new (LuminosityUnit.Terawatt, "Terawatt", "Terawatts", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
+                yield return new (LuminosityUnit.Decawatt, "Decawatt", "Decawatts", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (LuminosityUnit.Deciwatt, "Deciwatt", "Deciwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Hectogram, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (LuminosityUnit.Femtowatt, "Femtowatt", "Femtowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Picogram, time: DurationUnit.Second),
+                     1000000000000000
+                );
+                yield return new (LuminosityUnit.Gigawatt, "Gigawatt", "Gigawatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (LuminosityUnit.Kilowatt, "Kilowatt", "Kilowatts", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (LuminosityUnit.Megawatt, "Megawatt", "Megawatts", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (LuminosityUnit.Microwatt, "Microwatt", "Microwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (LuminosityUnit.Milliwatt, "Milliwatt", "Milliwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (LuminosityUnit.Nanowatt, "Nanowatt", "Nanowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (LuminosityUnit.Petawatt, "Petawatt", "Petawatts", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000)
+                );
+                yield return new (LuminosityUnit.Picowatt, "Picowatt", "Picowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second),
+                     1000000000000
+                );
+                yield return new (LuminosityUnit.SolarLuminosity, "SolarLuminosity", "SolarLuminosities", BaseUnits.Undefined,
+                     new QuantityValue(1, new BigInteger(3828) * QuantityValue.PowerOfTen(23))
+                );
+                yield return new (LuminosityUnit.Terawatt, "Terawatt", "Terawatts", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000000)
+                );
                 yield return new (LuminosityUnit.Watt, "Watt", "Watts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
             }
         }
 
         static Luminosity()
         {
-            Info = LuminosityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(LuminosityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -149,7 +172,7 @@ static Luminosity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Luminosity(double value, LuminosityUnit unit)
+        public Luminosity(QuantityValue value, LuminosityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -163,7 +186,7 @@ public Luminosity(double value, LuminosityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Luminosity(double value, UnitSystem unitSystem)
+        public Luminosity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -174,7 +197,8 @@ public Luminosity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Luminosity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Luminosity, LuminosityUnit> Info { get; }
@@ -203,10 +227,8 @@ public Luminosity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public LuminosityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -240,119 +262,79 @@ public Luminosity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Decawatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Decawatt"/>
         /// </summary>
-        public double Decawatts => As(LuminosityUnit.Decawatt);
+        public QuantityValue Decawatts => this.As(LuminosityUnit.Decawatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Deciwatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Deciwatt"/>
         /// </summary>
-        public double Deciwatts => As(LuminosityUnit.Deciwatt);
+        public QuantityValue Deciwatts => this.As(LuminosityUnit.Deciwatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Femtowatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Femtowatt"/>
         /// </summary>
-        public double Femtowatts => As(LuminosityUnit.Femtowatt);
+        public QuantityValue Femtowatts => this.As(LuminosityUnit.Femtowatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Gigawatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Gigawatt"/>
         /// </summary>
-        public double Gigawatts => As(LuminosityUnit.Gigawatt);
+        public QuantityValue Gigawatts => this.As(LuminosityUnit.Gigawatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Kilowatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Kilowatt"/>
         /// </summary>
-        public double Kilowatts => As(LuminosityUnit.Kilowatt);
+        public QuantityValue Kilowatts => this.As(LuminosityUnit.Kilowatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Megawatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Megawatt"/>
         /// </summary>
-        public double Megawatts => As(LuminosityUnit.Megawatt);
+        public QuantityValue Megawatts => this.As(LuminosityUnit.Megawatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Microwatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Microwatt"/>
         /// </summary>
-        public double Microwatts => As(LuminosityUnit.Microwatt);
+        public QuantityValue Microwatts => this.As(LuminosityUnit.Microwatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Milliwatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Milliwatt"/>
         /// </summary>
-        public double Milliwatts => As(LuminosityUnit.Milliwatt);
+        public QuantityValue Milliwatts => this.As(LuminosityUnit.Milliwatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Nanowatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Nanowatt"/>
         /// </summary>
-        public double Nanowatts => As(LuminosityUnit.Nanowatt);
+        public QuantityValue Nanowatts => this.As(LuminosityUnit.Nanowatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Petawatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Petawatt"/>
         /// </summary>
-        public double Petawatts => As(LuminosityUnit.Petawatt);
+        public QuantityValue Petawatts => this.As(LuminosityUnit.Petawatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Picowatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Picowatt"/>
         /// </summary>
-        public double Picowatts => As(LuminosityUnit.Picowatt);
+        public QuantityValue Picowatts => this.As(LuminosityUnit.Picowatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.SolarLuminosity"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.SolarLuminosity"/>
         /// </summary>
-        public double SolarLuminosities => As(LuminosityUnit.SolarLuminosity);
+        public QuantityValue SolarLuminosities => this.As(LuminosityUnit.SolarLuminosity);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Terawatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Terawatt"/>
         /// </summary>
-        public double Terawatts => As(LuminosityUnit.Terawatt);
+        public QuantityValue Terawatts => this.As(LuminosityUnit.Terawatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminosityUnit.Watt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminosityUnit.Watt"/>
         /// </summary>
-        public double Watts => As(LuminosityUnit.Watt);
+        public QuantityValue Watts => this.As(LuminosityUnit.Watt);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: LuminosityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Decawatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Deciwatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Femtowatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Gigawatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Kilowatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Megawatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Microwatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Milliwatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Nanowatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Petawatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Picowatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.SolarLuminosity, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Terawatt, LuminosityUnit.Watt, quantity => quantity.ToUnit(LuminosityUnit.Watt));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Watt, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> LuminosityUnit
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Decawatt, quantity => quantity.ToUnit(LuminosityUnit.Decawatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Deciwatt, quantity => quantity.ToUnit(LuminosityUnit.Deciwatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Femtowatt, quantity => quantity.ToUnit(LuminosityUnit.Femtowatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Gigawatt, quantity => quantity.ToUnit(LuminosityUnit.Gigawatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Kilowatt, quantity => quantity.ToUnit(LuminosityUnit.Kilowatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Megawatt, quantity => quantity.ToUnit(LuminosityUnit.Megawatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Microwatt, quantity => quantity.ToUnit(LuminosityUnit.Microwatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Milliwatt, quantity => quantity.ToUnit(LuminosityUnit.Milliwatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Nanowatt, quantity => quantity.ToUnit(LuminosityUnit.Nanowatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Petawatt, quantity => quantity.ToUnit(LuminosityUnit.Petawatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Picowatt, quantity => quantity.ToUnit(LuminosityUnit.Picowatt));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.SolarLuminosity, quantity => quantity.ToUnit(LuminosityUnit.SolarLuminosity));
-            unitConverter.SetConversionFunction<Luminosity>(LuminosityUnit.Watt, LuminosityUnit.Terawatt, quantity => quantity.ToUnit(LuminosityUnit.Terawatt));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -381,7 +363,7 @@ public static string GetAbbreviation(LuminosityUnit unit, IFormatProvider? provi
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Decawatt"/>.
         /// </summary>
-        public static Luminosity FromDecawatts(double value)
+        public static Luminosity FromDecawatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Decawatt);
         }
@@ -389,7 +371,7 @@ public static Luminosity FromDecawatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Deciwatt"/>.
         /// </summary>
-        public static Luminosity FromDeciwatts(double value)
+        public static Luminosity FromDeciwatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Deciwatt);
         }
@@ -397,7 +379,7 @@ public static Luminosity FromDeciwatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Femtowatt"/>.
         /// </summary>
-        public static Luminosity FromFemtowatts(double value)
+        public static Luminosity FromFemtowatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Femtowatt);
         }
@@ -405,7 +387,7 @@ public static Luminosity FromFemtowatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Gigawatt"/>.
         /// </summary>
-        public static Luminosity FromGigawatts(double value)
+        public static Luminosity FromGigawatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Gigawatt);
         }
@@ -413,7 +395,7 @@ public static Luminosity FromGigawatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Kilowatt"/>.
         /// </summary>
-        public static Luminosity FromKilowatts(double value)
+        public static Luminosity FromKilowatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Kilowatt);
         }
@@ -421,7 +403,7 @@ public static Luminosity FromKilowatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Megawatt"/>.
         /// </summary>
-        public static Luminosity FromMegawatts(double value)
+        public static Luminosity FromMegawatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Megawatt);
         }
@@ -429,7 +411,7 @@ public static Luminosity FromMegawatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Microwatt"/>.
         /// </summary>
-        public static Luminosity FromMicrowatts(double value)
+        public static Luminosity FromMicrowatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Microwatt);
         }
@@ -437,7 +419,7 @@ public static Luminosity FromMicrowatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Milliwatt"/>.
         /// </summary>
-        public static Luminosity FromMilliwatts(double value)
+        public static Luminosity FromMilliwatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Milliwatt);
         }
@@ -445,7 +427,7 @@ public static Luminosity FromMilliwatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Nanowatt"/>.
         /// </summary>
-        public static Luminosity FromNanowatts(double value)
+        public static Luminosity FromNanowatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Nanowatt);
         }
@@ -453,7 +435,7 @@ public static Luminosity FromNanowatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Petawatt"/>.
         /// </summary>
-        public static Luminosity FromPetawatts(double value)
+        public static Luminosity FromPetawatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Petawatt);
         }
@@ -461,7 +443,7 @@ public static Luminosity FromPetawatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Picowatt"/>.
         /// </summary>
-        public static Luminosity FromPicowatts(double value)
+        public static Luminosity FromPicowatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Picowatt);
         }
@@ -469,7 +451,7 @@ public static Luminosity FromPicowatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.SolarLuminosity"/>.
         /// </summary>
-        public static Luminosity FromSolarLuminosities(double value)
+        public static Luminosity FromSolarLuminosities(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.SolarLuminosity);
         }
@@ -477,7 +459,7 @@ public static Luminosity FromSolarLuminosities(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Terawatt"/>.
         /// </summary>
-        public static Luminosity FromTerawatts(double value)
+        public static Luminosity FromTerawatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Terawatt);
         }
@@ -485,7 +467,7 @@ public static Luminosity FromTerawatts(double value)
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Watt"/>.
         /// </summary>
-        public static Luminosity FromWatts(double value)
+        public static Luminosity FromWatts(QuantityValue value)
         {
             return new Luminosity(value, LuminosityUnit.Watt);
         }
@@ -496,7 +478,7 @@ public static Luminosity FromWatts(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Luminosity unit value.</returns>
-        public static Luminosity From(double value, LuminosityUnit fromUnit)
+        public static Luminosity From(QuantityValue value, LuminosityUnit fromUnit)
         {
             return new Luminosity(value, fromUnit);
         }
@@ -557,10 +539,7 @@ public static Luminosity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Luminosity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Luminosity, LuminosityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Luminosity, LuminosityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -588,11 +567,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Luminosity resul
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Luminosity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Luminosity, LuminosityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Luminosity, LuminosityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -613,7 +588,7 @@ public static LuminosityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -624,7 +599,7 @@ public static LuminosityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LuminosityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.LuminosityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminosityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -639,7 +614,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminosityUn
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out LuminosityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -658,35 +633,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Luminosity"/> from adding two <see cref="Luminosity"/>.</summary>
         public static Luminosity operator +(Luminosity left, Luminosity right)
         {
-            return new Luminosity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Luminosity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Luminosity"/> from subtracting two <see cref="Luminosity"/>.</summary>
         public static Luminosity operator -(Luminosity left, Luminosity right)
         {
-            return new Luminosity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Luminosity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Luminosity"/> from multiplying value and <see cref="Luminosity"/>.</summary>
-        public static Luminosity operator *(double left, Luminosity right)
+        public static Luminosity operator *(QuantityValue left, Luminosity right)
         {
             return new Luminosity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Luminosity"/> from multiplying value and <see cref="Luminosity"/>.</summary>
-        public static Luminosity operator *(Luminosity left, double right)
+        public static Luminosity operator *(Luminosity left, QuantityValue right)
         {
             return new Luminosity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Luminosity"/> from dividing <see cref="Luminosity"/> by value.</summary>
-        public static Luminosity operator /(Luminosity left, double right)
+        public static Luminosity operator /(Luminosity left, QuantityValue right)
         {
             return new Luminosity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Luminosity"/> by <see cref="Luminosity"/>.</summary>
-        public static double operator /(Luminosity left, Luminosity right)
+        public static QuantityValue operator /(Luminosity left, Luminosity right)
         {
             return left.Watts / right.Watts;
         }
@@ -698,97 +673,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Luminosity left, Luminosity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Luminosity left, Luminosity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Luminosity left, Luminosity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Luminosity left, Luminosity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Luminosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Luminosity other, Luminosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Luminosity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Luminosity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Luminosity left, Luminosity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Luminosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Luminosity other, Luminosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Luminosity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Luminosity,Luminosity)"/>.
+        ///     See that operator (and <see cref="Equals(Luminosity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Luminosity left, Luminosity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Luminosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Luminosity other, Luminosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Luminosity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Luminosity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Luminosity"/>, this method delegates to
+        ///     <see cref="Equals(Luminosity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Luminosity otherQuantity))
+            if (obj is not Luminosity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Luminosity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Luminosity other, Luminosity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Luminosity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Luminosity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Luminosity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Luminosity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Luminosity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Luminosity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Luminosity otherQuantity)) throw new ArgumentException("Expected type Luminosity.", nameof(obj));
+            if (obj is not Luminosity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Luminosity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Luminosity"/> with another <see cref="Luminosity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Luminosity"/> with another <see cref="Luminosity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -800,155 +789,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Luminosity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(LuminosityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<LuminosityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Luminosity to another Luminosity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Luminosity with the specified unit.</returns>
-        public Luminosity ToUnit(LuminosityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Luminosity"/> to another <see cref="Luminosity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Luminosity with the specified unit.</returns>
-        public Luminosity ToUnit(LuminosityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Luminosity), Unit, typeof(Luminosity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Luminosity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="Luminosity"/> to another <see cref="Luminosity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Luminosity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(LuminosityUnit unit, [NotNullWhen(true)] out Luminosity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Luminosity? convertedOrNull = (Unit, unit) switch
-            {
-                // LuminosityUnit -> BaseUnit
-                (LuminosityUnit.Decawatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e1d, LuminosityUnit.Watt),
-                (LuminosityUnit.Deciwatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e-1d, LuminosityUnit.Watt),
-                (LuminosityUnit.Femtowatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e-15d, LuminosityUnit.Watt),
-                (LuminosityUnit.Gigawatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e9d, LuminosityUnit.Watt),
-                (LuminosityUnit.Kilowatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e3d, LuminosityUnit.Watt),
-                (LuminosityUnit.Megawatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e6d, LuminosityUnit.Watt),
-                (LuminosityUnit.Microwatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e-6d, LuminosityUnit.Watt),
-                (LuminosityUnit.Milliwatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e-3d, LuminosityUnit.Watt),
-                (LuminosityUnit.Nanowatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e-9d, LuminosityUnit.Watt),
-                (LuminosityUnit.Petawatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e15d, LuminosityUnit.Watt),
-                (LuminosityUnit.Picowatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e-12d, LuminosityUnit.Watt),
-                (LuminosityUnit.SolarLuminosity, LuminosityUnit.Watt) => new Luminosity(_value * 3.828e26, LuminosityUnit.Watt),
-                (LuminosityUnit.Terawatt, LuminosityUnit.Watt) => new Luminosity((_value) * 1e12d, LuminosityUnit.Watt),
-
-                // BaseUnit -> LuminosityUnit
-                (LuminosityUnit.Watt, LuminosityUnit.Decawatt) => new Luminosity((_value) / 1e1d, LuminosityUnit.Decawatt),
-                (LuminosityUnit.Watt, LuminosityUnit.Deciwatt) => new Luminosity((_value) / 1e-1d, LuminosityUnit.Deciwatt),
-                (LuminosityUnit.Watt, LuminosityUnit.Femtowatt) => new Luminosity((_value) / 1e-15d, LuminosityUnit.Femtowatt),
-                (LuminosityUnit.Watt, LuminosityUnit.Gigawatt) => new Luminosity((_value) / 1e9d, LuminosityUnit.Gigawatt),
-                (LuminosityUnit.Watt, LuminosityUnit.Kilowatt) => new Luminosity((_value) / 1e3d, LuminosityUnit.Kilowatt),
-                (LuminosityUnit.Watt, LuminosityUnit.Megawatt) => new Luminosity((_value) / 1e6d, LuminosityUnit.Megawatt),
-                (LuminosityUnit.Watt, LuminosityUnit.Microwatt) => new Luminosity((_value) / 1e-6d, LuminosityUnit.Microwatt),
-                (LuminosityUnit.Watt, LuminosityUnit.Milliwatt) => new Luminosity((_value) / 1e-3d, LuminosityUnit.Milliwatt),
-                (LuminosityUnit.Watt, LuminosityUnit.Nanowatt) => new Luminosity((_value) / 1e-9d, LuminosityUnit.Nanowatt),
-                (LuminosityUnit.Watt, LuminosityUnit.Petawatt) => new Luminosity((_value) / 1e15d, LuminosityUnit.Petawatt),
-                (LuminosityUnit.Watt, LuminosityUnit.Picowatt) => new Luminosity((_value) / 1e-12d, LuminosityUnit.Picowatt),
-                (LuminosityUnit.Watt, LuminosityUnit.SolarLuminosity) => new Luminosity(_value / 3.828e26, LuminosityUnit.SolarLuminosity),
-                (LuminosityUnit.Watt, LuminosityUnit.Terawatt) => new Luminosity((_value) / 1e12d, LuminosityUnit.Terawatt),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not LuminosityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminosityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is LuminosityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminosityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<LuminosityUnit> IQuantity<LuminosityUnit>.ToUnit(LuminosityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -962,11 +805,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
index 37a00f6f4d..7c354155d3 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,13 +36,16 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Luminous_flux
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct LuminousFlux :
-        IArithmeticQuantity<LuminousFlux, LuminousFluxUnit>,
+        ILinearQuantity<LuminousFlux, LuminousFluxUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<LuminousFlux, LuminousFlux, double>,
+        IDivisionOperators<LuminousFlux, LuminousFlux, QuantityValue>,
         IDivisionOperators<LuminousFlux, Illuminance, Area>,
         IDivisionOperators<LuminousFlux, Area, Illuminance>,
+        IDivisionOperators<LuminousFlux, SolidAngle, LuminousIntensity>,
+        IDivisionOperators<LuminousFlux, LuminousIntensity, SolidAngle>,
         IComparisonOperators<LuminousFlux, LuminousFlux, bool>,
         IParsable<LuminousFlux>,
 #endif
@@ -57,7 +58,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -107,7 +108,7 @@ public static LuminousFluxInfo CreateDefault(Func<IEnumerable<UnitDefinition<Lum
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="LuminousFlux"/> is [J].
+            ///     The <see cref="BaseDimensions" /> for <see cref="LuminousFlux"/> is J.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, 0, 0, 0, 0, 1);
 
@@ -128,9 +129,7 @@ public static IEnumerable<UnitDefinition<LuminousFluxUnit>> GetDefaultMappings()
 
         static LuminousFlux()
         {
-            Info = LuminousFluxInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(LuminousFluxInfo.CreateDefault);
         }
 
         /// <summary>
@@ -138,7 +137,7 @@ static LuminousFlux()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public LuminousFlux(double value, LuminousFluxUnit unit)
+        public LuminousFlux(QuantityValue value, LuminousFluxUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -152,7 +151,7 @@ public LuminousFlux(double value, LuminousFluxUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public LuminousFlux(double value, UnitSystem unitSystem)
+        public LuminousFlux(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -163,7 +162,8 @@ public LuminousFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="LuminousFlux" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<LuminousFlux, LuminousFluxUnit> Info { get; }
@@ -192,10 +192,8 @@ public LuminousFlux(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public LuminousFluxUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -229,28 +227,14 @@ public LuminousFlux(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminousFluxUnit.Lumen"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminousFluxUnit.Lumen"/>
         /// </summary>
-        public double Lumens => As(LuminousFluxUnit.Lumen);
+        public QuantityValue Lumens => this.As(LuminousFluxUnit.Lumen);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: LuminousFluxUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<LuminousFlux>(LuminousFluxUnit.Lumen, LuminousFluxUnit.Lumen, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> LuminousFluxUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -279,7 +263,7 @@ public static string GetAbbreviation(LuminousFluxUnit unit, IFormatProvider? pro
         /// <summary>
         ///     Creates a <see cref="LuminousFlux"/> from <see cref="LuminousFluxUnit.Lumen"/>.
         /// </summary>
-        public static LuminousFlux FromLumens(double value)
+        public static LuminousFlux FromLumens(QuantityValue value)
         {
             return new LuminousFlux(value, LuminousFluxUnit.Lumen);
         }
@@ -290,7 +274,7 @@ public static LuminousFlux FromLumens(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>LuminousFlux unit value.</returns>
-        public static LuminousFlux From(double value, LuminousFluxUnit fromUnit)
+        public static LuminousFlux From(QuantityValue value, LuminousFluxUnit fromUnit)
         {
             return new LuminousFlux(value, fromUnit);
         }
@@ -351,10 +335,7 @@ public static LuminousFlux Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static LuminousFlux Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<LuminousFlux, LuminousFluxUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<LuminousFlux, LuminousFluxUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -382,11 +363,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out LuminousFlux res
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out LuminousFlux result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<LuminousFlux, LuminousFluxUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<LuminousFlux, LuminousFluxUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -407,7 +384,7 @@ public static LuminousFluxUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -418,7 +395,7 @@ public static LuminousFluxUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LuminousFluxUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.LuminousFluxUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminousFluxUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -433,7 +410,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminousFlux
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out LuminousFluxUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -452,35 +429,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="LuminousFlux"/> from adding two <see cref="LuminousFlux"/>.</summary>
         public static LuminousFlux operator +(LuminousFlux left, LuminousFlux right)
         {
-            return new LuminousFlux(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new LuminousFlux(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="LuminousFlux"/> from subtracting two <see cref="LuminousFlux"/>.</summary>
         public static LuminousFlux operator -(LuminousFlux left, LuminousFlux right)
         {
-            return new LuminousFlux(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new LuminousFlux(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="LuminousFlux"/> from multiplying value and <see cref="LuminousFlux"/>.</summary>
-        public static LuminousFlux operator *(double left, LuminousFlux right)
+        public static LuminousFlux operator *(QuantityValue left, LuminousFlux right)
         {
             return new LuminousFlux(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="LuminousFlux"/> from multiplying value and <see cref="LuminousFlux"/>.</summary>
-        public static LuminousFlux operator *(LuminousFlux left, double right)
+        public static LuminousFlux operator *(LuminousFlux left, QuantityValue right)
         {
             return new LuminousFlux(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="LuminousFlux"/> from dividing <see cref="LuminousFlux"/> by value.</summary>
-        public static LuminousFlux operator /(LuminousFlux left, double right)
+        public static LuminousFlux operator /(LuminousFlux left, QuantityValue right)
         {
             return new LuminousFlux(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="LuminousFlux"/> by <see cref="LuminousFlux"/>.</summary>
-        public static double operator /(LuminousFlux left, LuminousFlux right)
+        public static QuantityValue operator /(LuminousFlux left, LuminousFlux right)
         {
             return left.Lumens / right.Lumens;
         }
@@ -501,6 +478,18 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Illuminance.FromLux(luminousFlux.Lumens / area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="LuminousIntensity"/> from <see cref="LuminousFlux"/> / <see cref="SolidAngle"/>.</summary>
+        public static LuminousIntensity operator /(LuminousFlux luminousFlux, SolidAngle solidAngle)
+        {
+            return LuminousIntensity.FromCandela(luminousFlux.Lumens / solidAngle.Steradians);
+        }
+
+        /// <summary>Get <see cref="SolidAngle"/> from <see cref="LuminousFlux"/> / <see cref="LuminousIntensity"/>.</summary>
+        public static SolidAngle operator /(LuminousFlux luminousFlux, LuminousIntensity luminousIntensity)
+        {
+            return SolidAngle.FromSteradians(luminousFlux.Lumens / luminousIntensity.Candela);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -508,97 +497,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(LuminousFlux left, LuminousFlux right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(LuminousFlux left, LuminousFlux right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(LuminousFlux left, LuminousFlux right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(LuminousFlux left, LuminousFlux right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="LuminousFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(LuminousFlux other, LuminousFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="LuminousFlux"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(LuminousFlux)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(LuminousFlux left, LuminousFlux right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="LuminousFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(LuminousFlux other, LuminousFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="LuminousFlux"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(LuminousFlux,LuminousFlux)"/>.
+        ///     See that operator (and <see cref="Equals(LuminousFlux)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(LuminousFlux left, LuminousFlux right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="LuminousFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(LuminousFlux other, LuminousFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="LuminousFlux"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="LuminousFlux"/>.
+        ///     When <paramref name="obj"/> is a <see cref="LuminousFlux"/>, this method delegates to
+        ///     <see cref="Equals(LuminousFlux)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is LuminousFlux otherQuantity))
+            if (obj is not LuminousFlux otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="LuminousFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(LuminousFlux other, LuminousFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="LuminousFlux"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(LuminousFlux other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current LuminousFlux.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(LuminousFlux), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="LuminousFlux"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(LuminousFlux)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is LuminousFlux otherQuantity)) throw new ArgumentException("Expected type LuminousFlux.", nameof(obj));
+            if (obj is not LuminousFlux otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<LuminousFlux>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="LuminousFlux"/> with another <see cref="LuminousFlux"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="LuminousFlux"/> with another <see cref="LuminousFlux"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -610,131 +613,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(LuminousFlux other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(LuminousFluxUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<LuminousFluxUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this LuminousFlux to another LuminousFlux with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A LuminousFlux with the specified unit.</returns>
-        public LuminousFlux ToUnit(LuminousFluxUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="LuminousFlux"/> to another <see cref="LuminousFlux"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A LuminousFlux with the specified unit.</returns>
-        public LuminousFlux ToUnit(LuminousFluxUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(LuminousFlux), Unit, typeof(LuminousFlux), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (LuminousFlux)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="LuminousFlux"/> to another <see cref="LuminousFlux"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="LuminousFlux"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(LuminousFluxUnit unit, [NotNullWhen(true)] out LuminousFlux? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            LuminousFlux? convertedOrNull = (Unit, unit) switch
-            {
-                // LuminousFluxUnit -> BaseUnit
-
-                // BaseUnit -> LuminousFluxUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not LuminousFluxUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousFluxUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is LuminousFluxUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousFluxUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<LuminousFluxUnit> IQuantity<LuminousFluxUnit>.ToUnit(LuminousFluxUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -746,11 +629,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
index 151f67d3d5..b392682978 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,13 +36,15 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Luminous_intensity
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct LuminousIntensity :
-        IArithmeticQuantity<LuminousIntensity, LuminousIntensityUnit>,
+        ILinearQuantity<LuminousIntensity, LuminousIntensityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<LuminousIntensity, LuminousIntensity, double>,
+        IDivisionOperators<LuminousIntensity, LuminousIntensity, QuantityValue>,
         IDivisionOperators<LuminousIntensity, Luminance, Area>,
         IDivisionOperators<LuminousIntensity, Area, Luminance>,
+        IMultiplyOperators<LuminousIntensity, SolidAngle, LuminousFlux>,
         IComparisonOperators<LuminousIntensity, LuminousIntensity, bool>,
         IParsable<LuminousIntensity>,
 #endif
@@ -57,7 +57,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -107,7 +107,7 @@ public static LuminousIntensityInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="LuminousIntensity"/> is [J].
+            ///     The <see cref="BaseDimensions" /> for <see cref="LuminousIntensity"/> is J.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, 0, 0, 0, 0, 1);
 
@@ -128,9 +128,7 @@ public static IEnumerable<UnitDefinition<LuminousIntensityUnit>> GetDefaultMappi
 
         static LuminousIntensity()
         {
-            Info = LuminousIntensityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(LuminousIntensityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -138,7 +136,7 @@ static LuminousIntensity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public LuminousIntensity(double value, LuminousIntensityUnit unit)
+        public LuminousIntensity(QuantityValue value, LuminousIntensityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -152,7 +150,7 @@ public LuminousIntensity(double value, LuminousIntensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public LuminousIntensity(double value, UnitSystem unitSystem)
+        public LuminousIntensity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -163,7 +161,8 @@ public LuminousIntensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="LuminousIntensity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<LuminousIntensity, LuminousIntensityUnit> Info { get; }
@@ -192,10 +191,8 @@ public LuminousIntensity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public LuminousIntensityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -229,28 +226,14 @@ public LuminousIntensity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="LuminousIntensityUnit.Candela"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="LuminousIntensityUnit.Candela"/>
         /// </summary>
-        public double Candela => As(LuminousIntensityUnit.Candela);
+        public QuantityValue Candela => this.As(LuminousIntensityUnit.Candela);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: LuminousIntensityUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<LuminousIntensity>(LuminousIntensityUnit.Candela, LuminousIntensityUnit.Candela, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> LuminousIntensityUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -279,7 +262,7 @@ public static string GetAbbreviation(LuminousIntensityUnit unit, IFormatProvider
         /// <summary>
         ///     Creates a <see cref="LuminousIntensity"/> from <see cref="LuminousIntensityUnit.Candela"/>.
         /// </summary>
-        public static LuminousIntensity FromCandela(double value)
+        public static LuminousIntensity FromCandela(QuantityValue value)
         {
             return new LuminousIntensity(value, LuminousIntensityUnit.Candela);
         }
@@ -290,7 +273,7 @@ public static LuminousIntensity FromCandela(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>LuminousIntensity unit value.</returns>
-        public static LuminousIntensity From(double value, LuminousIntensityUnit fromUnit)
+        public static LuminousIntensity From(QuantityValue value, LuminousIntensityUnit fromUnit)
         {
             return new LuminousIntensity(value, fromUnit);
         }
@@ -351,10 +334,7 @@ public static LuminousIntensity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static LuminousIntensity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<LuminousIntensity, LuminousIntensityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<LuminousIntensity, LuminousIntensityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -382,11 +362,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out LuminousIntensit
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out LuminousIntensity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<LuminousIntensity, LuminousIntensityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<LuminousIntensity, LuminousIntensityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -407,7 +383,7 @@ public static LuminousIntensityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -418,7 +394,7 @@ public static LuminousIntensityUnit ParseUnit(string str, IFormatProvider? provi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.LuminousIntensityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.LuminousIntensityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminousIntensityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -433,7 +409,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out LuminousInte
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out LuminousIntensityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -452,35 +428,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="LuminousIntensity"/> from adding two <see cref="LuminousIntensity"/>.</summary>
         public static LuminousIntensity operator +(LuminousIntensity left, LuminousIntensity right)
         {
-            return new LuminousIntensity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new LuminousIntensity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="LuminousIntensity"/> from subtracting two <see cref="LuminousIntensity"/>.</summary>
         public static LuminousIntensity operator -(LuminousIntensity left, LuminousIntensity right)
         {
-            return new LuminousIntensity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new LuminousIntensity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="LuminousIntensity"/> from multiplying value and <see cref="LuminousIntensity"/>.</summary>
-        public static LuminousIntensity operator *(double left, LuminousIntensity right)
+        public static LuminousIntensity operator *(QuantityValue left, LuminousIntensity right)
         {
             return new LuminousIntensity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="LuminousIntensity"/> from multiplying value and <see cref="LuminousIntensity"/>.</summary>
-        public static LuminousIntensity operator *(LuminousIntensity left, double right)
+        public static LuminousIntensity operator *(LuminousIntensity left, QuantityValue right)
         {
             return new LuminousIntensity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="LuminousIntensity"/> from dividing <see cref="LuminousIntensity"/> by value.</summary>
-        public static LuminousIntensity operator /(LuminousIntensity left, double right)
+        public static LuminousIntensity operator /(LuminousIntensity left, QuantityValue right)
         {
             return new LuminousIntensity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="LuminousIntensity"/> by <see cref="LuminousIntensity"/>.</summary>
-        public static double operator /(LuminousIntensity left, LuminousIntensity right)
+        public static QuantityValue operator /(LuminousIntensity left, LuminousIntensity right)
         {
             return left.Candela / right.Candela;
         }
@@ -501,6 +477,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Luminance.FromCandelasPerSquareMeter(luminousIntensity.Candela / area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="LuminousFlux"/> from <see cref="LuminousIntensity"/> * <see cref="SolidAngle"/>.</summary>
+        public static LuminousFlux operator *(LuminousIntensity luminousIntensity, SolidAngle solidAngle)
+        {
+            return LuminousFlux.FromLumens(luminousIntensity.Candela * solidAngle.Steradians);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -508,97 +490,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(LuminousIntensity left, LuminousIntensity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(LuminousIntensity left, LuminousIntensity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(LuminousIntensity left, LuminousIntensity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(LuminousIntensity left, LuminousIntensity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="LuminousIntensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(LuminousIntensity other, LuminousIntensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="LuminousIntensity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(LuminousIntensity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(LuminousIntensity left, LuminousIntensity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="LuminousIntensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(LuminousIntensity other, LuminousIntensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="LuminousIntensity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(LuminousIntensity,LuminousIntensity)"/>.
+        ///     See that operator (and <see cref="Equals(LuminousIntensity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(LuminousIntensity left, LuminousIntensity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="LuminousIntensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(LuminousIntensity other, LuminousIntensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="LuminousIntensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="LuminousIntensity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="LuminousIntensity"/>, this method delegates to
+        ///     <see cref="Equals(LuminousIntensity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is LuminousIntensity otherQuantity))
+            if (obj is not LuminousIntensity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="LuminousIntensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(LuminousIntensity other, LuminousIntensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="LuminousIntensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(LuminousIntensity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current LuminousIntensity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(LuminousIntensity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="LuminousIntensity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(LuminousIntensity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is LuminousIntensity otherQuantity)) throw new ArgumentException("Expected type LuminousIntensity.", nameof(obj));
+            if (obj is not LuminousIntensity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<LuminousIntensity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="LuminousIntensity"/> with another <see cref="LuminousIntensity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="LuminousIntensity"/> with another <see cref="LuminousIntensity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -610,129 +606,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(LuminousIntensity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(LuminousIntensityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<LuminousIntensityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this LuminousIntensity to another LuminousIntensity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A LuminousIntensity with the specified unit.</returns>
-        public LuminousIntensity ToUnit(LuminousIntensityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="LuminousIntensity"/> to another <see cref="LuminousIntensity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A LuminousIntensity with the specified unit.</returns>
-        public LuminousIntensity ToUnit(LuminousIntensityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(LuminousIntensity), Unit, typeof(LuminousIntensity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (LuminousIntensity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="LuminousIntensity"/> to another <see cref="LuminousIntensity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="LuminousIntensity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(LuminousIntensityUnit unit, [NotNullWhen(true)] out LuminousIntensity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            LuminousIntensity? convertedOrNull = (Unit, unit) switch
-            {
-                // LuminousIntensityUnit -> BaseUnit
-
-                // BaseUnit -> LuminousIntensityUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not LuminousIntensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousIntensityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is LuminousIntensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousIntensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity<LuminousIntensityUnit> IQuantity<LuminousIntensityUnit>.ToUnit(LuminousIntensityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -746,11 +622,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
index 157f308cc9..4c2bdbe3af 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Magnetic_field
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MagneticField :
-        IArithmeticQuantity<MagneticField, MagneticFieldUnit>,
+        ILinearQuantity<MagneticField, MagneticFieldUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MagneticField, MagneticField, double>,
+        IDivisionOperators<MagneticField, MagneticField, QuantityValue>,
+        IMultiplyOperators<MagneticField, Area, MagneticFlux>,
         IComparisonOperators<MagneticField, MagneticField, bool>,
         IParsable<MagneticField>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static MagneticFieldInfo CreateDefault(Func<IEnumerable<UnitDefinition<Ma
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="MagneticField"/> is [T^-2][M][I^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="MagneticField"/> is T^-2MI^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 1, -2, -1, 0, 0, 0);
 
@@ -120,20 +120,28 @@ public static MagneticFieldInfo CreateDefault(Func<IEnumerable<UnitDefinition<Ma
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MagneticFieldUnit}"/> representing the default unit mappings for MagneticField.</returns>
             public static IEnumerable<UnitDefinition<MagneticFieldUnit>> GetDefaultMappings()
             {
-                yield return new (MagneticFieldUnit.Gauss, "Gauss", "Gausses", BaseUnits.Undefined);
-                yield return new (MagneticFieldUnit.Microtesla, "Microtesla", "Microteslas", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, current: ElectricCurrentUnit.Ampere));
-                yield return new (MagneticFieldUnit.Milligauss, "Milligauss", "Milligausses", BaseUnits.Undefined);
-                yield return new (MagneticFieldUnit.Millitesla, "Millitesla", "Milliteslas", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, current: ElectricCurrentUnit.Ampere));
-                yield return new (MagneticFieldUnit.Nanotesla, "Nanotesla", "Nanoteslas", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, current: ElectricCurrentUnit.Ampere));
+                yield return new (MagneticFieldUnit.Gauss, "Gauss", "Gausses", BaseUnits.Undefined,
+                     10000
+                );
+                yield return new (MagneticFieldUnit.Microtesla, "Microtesla", "Microteslas", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, current: ElectricCurrentUnit.Ampere),
+                     1000000
+                );
+                yield return new (MagneticFieldUnit.Milligauss, "Milligauss", "Milligausses", BaseUnits.Undefined,
+                     10000000
+                );
+                yield return new (MagneticFieldUnit.Millitesla, "Millitesla", "Milliteslas", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, current: ElectricCurrentUnit.Ampere),
+                     1000
+                );
+                yield return new (MagneticFieldUnit.Nanotesla, "Nanotesla", "Nanoteslas", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, current: ElectricCurrentUnit.Ampere),
+                     1000000000
+                );
                 yield return new (MagneticFieldUnit.Tesla, "Tesla", "Teslas", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, current: ElectricCurrentUnit.Ampere));
             }
         }
 
         static MagneticField()
         {
-            Info = MagneticFieldInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MagneticFieldInfo.CreateDefault);
         }
 
         /// <summary>
@@ -141,7 +149,7 @@ static MagneticField()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MagneticField(double value, MagneticFieldUnit unit)
+        public MagneticField(QuantityValue value, MagneticFieldUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -155,7 +163,7 @@ public MagneticField(double value, MagneticFieldUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MagneticField(double value, UnitSystem unitSystem)
+        public MagneticField(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -166,7 +174,8 @@ public MagneticField(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MagneticField" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MagneticField, MagneticFieldUnit> Info { get; }
@@ -195,10 +204,8 @@ public MagneticField(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MagneticFieldUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -232,63 +239,39 @@ public MagneticField(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Gauss"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MagneticFieldUnit.Gauss"/>
         /// </summary>
-        public double Gausses => As(MagneticFieldUnit.Gauss);
+        public QuantityValue Gausses => this.As(MagneticFieldUnit.Gauss);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Microtesla"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MagneticFieldUnit.Microtesla"/>
         /// </summary>
-        public double Microteslas => As(MagneticFieldUnit.Microtesla);
+        public QuantityValue Microteslas => this.As(MagneticFieldUnit.Microtesla);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Milligauss"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MagneticFieldUnit.Milligauss"/>
         /// </summary>
-        public double Milligausses => As(MagneticFieldUnit.Milligauss);
+        public QuantityValue Milligausses => this.As(MagneticFieldUnit.Milligauss);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Millitesla"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MagneticFieldUnit.Millitesla"/>
         /// </summary>
-        public double Milliteslas => As(MagneticFieldUnit.Millitesla);
+        public QuantityValue Milliteslas => this.As(MagneticFieldUnit.Millitesla);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Nanotesla"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MagneticFieldUnit.Nanotesla"/>
         /// </summary>
-        public double Nanoteslas => As(MagneticFieldUnit.Nanotesla);
+        public QuantityValue Nanoteslas => this.As(MagneticFieldUnit.Nanotesla);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFieldUnit.Tesla"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MagneticFieldUnit.Tesla"/>
         /// </summary>
-        public double Teslas => As(MagneticFieldUnit.Tesla);
+        public QuantityValue Teslas => this.As(MagneticFieldUnit.Tesla);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MagneticFieldUnit -> BaseUnit
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Gauss, MagneticFieldUnit.Tesla, quantity => quantity.ToUnit(MagneticFieldUnit.Tesla));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Microtesla, MagneticFieldUnit.Tesla, quantity => quantity.ToUnit(MagneticFieldUnit.Tesla));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Milligauss, MagneticFieldUnit.Tesla, quantity => quantity.ToUnit(MagneticFieldUnit.Tesla));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Millitesla, MagneticFieldUnit.Tesla, quantity => quantity.ToUnit(MagneticFieldUnit.Tesla));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Nanotesla, MagneticFieldUnit.Tesla, quantity => quantity.ToUnit(MagneticFieldUnit.Tesla));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Tesla, MagneticFieldUnit.Tesla, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MagneticFieldUnit
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Tesla, MagneticFieldUnit.Gauss, quantity => quantity.ToUnit(MagneticFieldUnit.Gauss));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Tesla, MagneticFieldUnit.Microtesla, quantity => quantity.ToUnit(MagneticFieldUnit.Microtesla));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Tesla, MagneticFieldUnit.Milligauss, quantity => quantity.ToUnit(MagneticFieldUnit.Milligauss));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Tesla, MagneticFieldUnit.Millitesla, quantity => quantity.ToUnit(MagneticFieldUnit.Millitesla));
-            unitConverter.SetConversionFunction<MagneticField>(MagneticFieldUnit.Tesla, MagneticFieldUnit.Nanotesla, quantity => quantity.ToUnit(MagneticFieldUnit.Nanotesla));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -317,7 +300,7 @@ public static string GetAbbreviation(MagneticFieldUnit unit, IFormatProvider? pr
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Gauss"/>.
         /// </summary>
-        public static MagneticField FromGausses(double value)
+        public static MagneticField FromGausses(QuantityValue value)
         {
             return new MagneticField(value, MagneticFieldUnit.Gauss);
         }
@@ -325,7 +308,7 @@ public static MagneticField FromGausses(double value)
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Microtesla"/>.
         /// </summary>
-        public static MagneticField FromMicroteslas(double value)
+        public static MagneticField FromMicroteslas(QuantityValue value)
         {
             return new MagneticField(value, MagneticFieldUnit.Microtesla);
         }
@@ -333,7 +316,7 @@ public static MagneticField FromMicroteslas(double value)
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Milligauss"/>.
         /// </summary>
-        public static MagneticField FromMilligausses(double value)
+        public static MagneticField FromMilligausses(QuantityValue value)
         {
             return new MagneticField(value, MagneticFieldUnit.Milligauss);
         }
@@ -341,7 +324,7 @@ public static MagneticField FromMilligausses(double value)
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Millitesla"/>.
         /// </summary>
-        public static MagneticField FromMilliteslas(double value)
+        public static MagneticField FromMilliteslas(QuantityValue value)
         {
             return new MagneticField(value, MagneticFieldUnit.Millitesla);
         }
@@ -349,7 +332,7 @@ public static MagneticField FromMilliteslas(double value)
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Nanotesla"/>.
         /// </summary>
-        public static MagneticField FromNanoteslas(double value)
+        public static MagneticField FromNanoteslas(QuantityValue value)
         {
             return new MagneticField(value, MagneticFieldUnit.Nanotesla);
         }
@@ -357,7 +340,7 @@ public static MagneticField FromNanoteslas(double value)
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Tesla"/>.
         /// </summary>
-        public static MagneticField FromTeslas(double value)
+        public static MagneticField FromTeslas(QuantityValue value)
         {
             return new MagneticField(value, MagneticFieldUnit.Tesla);
         }
@@ -368,7 +351,7 @@ public static MagneticField FromTeslas(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MagneticField unit value.</returns>
-        public static MagneticField From(double value, MagneticFieldUnit fromUnit)
+        public static MagneticField From(QuantityValue value, MagneticFieldUnit fromUnit)
         {
             return new MagneticField(value, fromUnit);
         }
@@ -429,10 +412,7 @@ public static MagneticField Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MagneticField Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MagneticField, MagneticFieldUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MagneticField, MagneticFieldUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -460,11 +440,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MagneticField re
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MagneticField result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MagneticField, MagneticFieldUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MagneticField, MagneticFieldUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -485,7 +461,7 @@ public static MagneticFieldUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -496,7 +472,7 @@ public static MagneticFieldUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MagneticFieldUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MagneticFieldUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MagneticFieldUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -511,7 +487,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MagneticFiel
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MagneticFieldUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -530,137 +506,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MagneticField"/> from adding two <see cref="MagneticField"/>.</summary>
         public static MagneticField operator +(MagneticField left, MagneticField right)
         {
-            return new MagneticField(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MagneticField(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MagneticField"/> from subtracting two <see cref="MagneticField"/>.</summary>
         public static MagneticField operator -(MagneticField left, MagneticField right)
         {
-            return new MagneticField(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MagneticField(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MagneticField"/> from multiplying value and <see cref="MagneticField"/>.</summary>
-        public static MagneticField operator *(double left, MagneticField right)
+        public static MagneticField operator *(QuantityValue left, MagneticField right)
         {
             return new MagneticField(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MagneticField"/> from multiplying value and <see cref="MagneticField"/>.</summary>
-        public static MagneticField operator *(MagneticField left, double right)
+        public static MagneticField operator *(MagneticField left, QuantityValue right)
         {
             return new MagneticField(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MagneticField"/> from dividing <see cref="MagneticField"/> by value.</summary>
-        public static MagneticField operator /(MagneticField left, double right)
+        public static MagneticField operator /(MagneticField left, QuantityValue right)
         {
             return new MagneticField(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MagneticField"/> by <see cref="MagneticField"/>.</summary>
-        public static double operator /(MagneticField left, MagneticField right)
+        public static QuantityValue operator /(MagneticField left, MagneticField right)
         {
             return left.Teslas / right.Teslas;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="MagneticFlux"/> from <see cref="MagneticField"/> * <see cref="Area"/>.</summary>
+        public static MagneticFlux operator *(MagneticField magneticField, Area area)
+        {
+            return MagneticFlux.FromWebers(magneticField.Teslas * area.SquareMeters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MagneticField left, MagneticField right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MagneticField left, MagneticField right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MagneticField left, MagneticField right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MagneticField left, MagneticField right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MagneticField"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MagneticField other, MagneticField tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MagneticField"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MagneticField)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MagneticField left, MagneticField right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MagneticField"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MagneticField other, MagneticField tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MagneticField"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MagneticField,MagneticField)"/>.
+        ///     See that operator (and <see cref="Equals(MagneticField)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MagneticField left, MagneticField right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MagneticField"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MagneticField other, MagneticField tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MagneticField"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MagneticField"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MagneticField"/>, this method delegates to
+        ///     <see cref="Equals(MagneticField)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MagneticField otherQuantity))
+            if (obj is not MagneticField otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MagneticField"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MagneticField other, MagneticField tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MagneticField"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MagneticField other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MagneticField.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MagneticField), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MagneticField"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MagneticField)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MagneticField otherQuantity)) throw new ArgumentException("Expected type MagneticField.", nameof(obj));
+            if (obj is not MagneticField otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MagneticField>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MagneticField"/> with another <see cref="MagneticField"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MagneticField"/> with another <see cref="MagneticField"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -672,139 +672,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MagneticField other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MagneticFieldUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MagneticFieldUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this MagneticField to another MagneticField with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MagneticField with the specified unit.</returns>
-        public MagneticField ToUnit(MagneticFieldUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="MagneticField"/> to another <see cref="MagneticField"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MagneticField with the specified unit.</returns>
-        public MagneticField ToUnit(MagneticFieldUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MagneticField), Unit, typeof(MagneticField), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MagneticField)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="MagneticField"/> to another <see cref="MagneticField"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MagneticField"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MagneticFieldUnit unit, [NotNullWhen(true)] out MagneticField? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MagneticField? convertedOrNull = (Unit, unit) switch
-            {
-                // MagneticFieldUnit -> BaseUnit
-                (MagneticFieldUnit.Gauss, MagneticFieldUnit.Tesla) => new MagneticField(_value / 1e4, MagneticFieldUnit.Tesla),
-                (MagneticFieldUnit.Microtesla, MagneticFieldUnit.Tesla) => new MagneticField((_value) * 1e-6d, MagneticFieldUnit.Tesla),
-                (MagneticFieldUnit.Milligauss, MagneticFieldUnit.Tesla) => new MagneticField((_value / 1e4) * 1e-3d, MagneticFieldUnit.Tesla),
-                (MagneticFieldUnit.Millitesla, MagneticFieldUnit.Tesla) => new MagneticField((_value) * 1e-3d, MagneticFieldUnit.Tesla),
-                (MagneticFieldUnit.Nanotesla, MagneticFieldUnit.Tesla) => new MagneticField((_value) * 1e-9d, MagneticFieldUnit.Tesla),
-
-                // BaseUnit -> MagneticFieldUnit
-                (MagneticFieldUnit.Tesla, MagneticFieldUnit.Gauss) => new MagneticField(_value * 1e4, MagneticFieldUnit.Gauss),
-                (MagneticFieldUnit.Tesla, MagneticFieldUnit.Microtesla) => new MagneticField((_value) / 1e-6d, MagneticFieldUnit.Microtesla),
-                (MagneticFieldUnit.Tesla, MagneticFieldUnit.Milligauss) => new MagneticField((_value * 1e4) / 1e-3d, MagneticFieldUnit.Milligauss),
-                (MagneticFieldUnit.Tesla, MagneticFieldUnit.Millitesla) => new MagneticField((_value) / 1e-3d, MagneticFieldUnit.Millitesla),
-                (MagneticFieldUnit.Tesla, MagneticFieldUnit.Nanotesla) => new MagneticField((_value) / 1e-9d, MagneticFieldUnit.Nanotesla),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MagneticFieldUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFieldUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MagneticFieldUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFieldUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity<MagneticFieldUnit> IQuantity<MagneticFieldUnit>.ToUnit(MagneticFieldUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -818,11 +688,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
index bfe7b01062..9fcfa55cbe 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,14 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Magnetic_flux
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MagneticFlux :
-        IArithmeticQuantity<MagneticFlux, MagneticFluxUnit>,
+        ILinearQuantity<MagneticFlux, MagneticFluxUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MagneticFlux, MagneticFlux, double>,
+        IDivisionOperators<MagneticFlux, MagneticFlux, QuantityValue>,
+        IDivisionOperators<MagneticFlux, MagneticField, Area>,
+        IDivisionOperators<MagneticFlux, Area, MagneticField>,
         IComparisonOperators<MagneticFlux, MagneticFlux, bool>,
         IParsable<MagneticFlux>,
 #endif
@@ -55,7 +56,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +106,7 @@ public static MagneticFluxInfo CreateDefault(Func<IEnumerable<UnitDefinition<Mag
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="MagneticFlux"/> is [T^-2][L^2][M][I^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="MagneticFlux"/> is T^-2L^2MI^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -2, -1, 0, 0, 0);
 
@@ -126,9 +127,7 @@ public static IEnumerable<UnitDefinition<MagneticFluxUnit>> GetDefaultMappings()
 
         static MagneticFlux()
         {
-            Info = MagneticFluxInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MagneticFluxInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +135,7 @@ static MagneticFlux()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MagneticFlux(double value, MagneticFluxUnit unit)
+        public MagneticFlux(QuantityValue value, MagneticFluxUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -150,7 +149,7 @@ public MagneticFlux(double value, MagneticFluxUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MagneticFlux(double value, UnitSystem unitSystem)
+        public MagneticFlux(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -161,7 +160,8 @@ public MagneticFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MagneticFlux" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MagneticFlux, MagneticFluxUnit> Info { get; }
@@ -190,10 +190,8 @@ public MagneticFlux(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MagneticFluxUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,28 +225,14 @@ public MagneticFlux(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagneticFluxUnit.Weber"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MagneticFluxUnit.Weber"/>
         /// </summary>
-        public double Webers => As(MagneticFluxUnit.Weber);
+        public QuantityValue Webers => this.As(MagneticFluxUnit.Weber);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MagneticFluxUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MagneticFlux>(MagneticFluxUnit.Weber, MagneticFluxUnit.Weber, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MagneticFluxUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -277,7 +261,7 @@ public static string GetAbbreviation(MagneticFluxUnit unit, IFormatProvider? pro
         /// <summary>
         ///     Creates a <see cref="MagneticFlux"/> from <see cref="MagneticFluxUnit.Weber"/>.
         /// </summary>
-        public static MagneticFlux FromWebers(double value)
+        public static MagneticFlux FromWebers(QuantityValue value)
         {
             return new MagneticFlux(value, MagneticFluxUnit.Weber);
         }
@@ -288,7 +272,7 @@ public static MagneticFlux FromWebers(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MagneticFlux unit value.</returns>
-        public static MagneticFlux From(double value, MagneticFluxUnit fromUnit)
+        public static MagneticFlux From(QuantityValue value, MagneticFluxUnit fromUnit)
         {
             return new MagneticFlux(value, fromUnit);
         }
@@ -349,10 +333,7 @@ public static MagneticFlux Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MagneticFlux Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MagneticFlux, MagneticFluxUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MagneticFlux, MagneticFluxUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -380,11 +361,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MagneticFlux res
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MagneticFlux result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MagneticFlux, MagneticFluxUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MagneticFlux, MagneticFluxUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -405,7 +382,7 @@ public static MagneticFluxUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -416,7 +393,7 @@ public static MagneticFluxUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MagneticFluxUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MagneticFluxUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MagneticFluxUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -431,7 +408,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MagneticFlux
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MagneticFluxUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -450,137 +427,167 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MagneticFlux"/> from adding two <see cref="MagneticFlux"/>.</summary>
         public static MagneticFlux operator +(MagneticFlux left, MagneticFlux right)
         {
-            return new MagneticFlux(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MagneticFlux(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MagneticFlux"/> from subtracting two <see cref="MagneticFlux"/>.</summary>
         public static MagneticFlux operator -(MagneticFlux left, MagneticFlux right)
         {
-            return new MagneticFlux(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MagneticFlux(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MagneticFlux"/> from multiplying value and <see cref="MagneticFlux"/>.</summary>
-        public static MagneticFlux operator *(double left, MagneticFlux right)
+        public static MagneticFlux operator *(QuantityValue left, MagneticFlux right)
         {
             return new MagneticFlux(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MagneticFlux"/> from multiplying value and <see cref="MagneticFlux"/>.</summary>
-        public static MagneticFlux operator *(MagneticFlux left, double right)
+        public static MagneticFlux operator *(MagneticFlux left, QuantityValue right)
         {
             return new MagneticFlux(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MagneticFlux"/> from dividing <see cref="MagneticFlux"/> by value.</summary>
-        public static MagneticFlux operator /(MagneticFlux left, double right)
+        public static MagneticFlux operator /(MagneticFlux left, QuantityValue right)
         {
             return new MagneticFlux(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MagneticFlux"/> by <see cref="MagneticFlux"/>.</summary>
-        public static double operator /(MagneticFlux left, MagneticFlux right)
+        public static QuantityValue operator /(MagneticFlux left, MagneticFlux right)
         {
             return left.Webers / right.Webers;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Area"/> from <see cref="MagneticFlux"/> / <see cref="MagneticField"/>.</summary>
+        public static Area operator /(MagneticFlux magneticFlux, MagneticField magneticField)
+        {
+            return Area.FromSquareMeters(magneticFlux.Webers / magneticField.Teslas);
+        }
+
+        /// <summary>Get <see cref="MagneticField"/> from <see cref="MagneticFlux"/> / <see cref="Area"/>.</summary>
+        public static MagneticField operator /(MagneticFlux magneticFlux, Area area)
+        {
+            return MagneticField.FromTeslas(magneticFlux.Webers / area.SquareMeters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MagneticFlux left, MagneticFlux right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MagneticFlux left, MagneticFlux right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MagneticFlux left, MagneticFlux right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MagneticFlux left, MagneticFlux right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MagneticFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MagneticFlux other, MagneticFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MagneticFlux"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MagneticFlux)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MagneticFlux left, MagneticFlux right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MagneticFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MagneticFlux other, MagneticFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MagneticFlux"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MagneticFlux,MagneticFlux)"/>.
+        ///     See that operator (and <see cref="Equals(MagneticFlux)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MagneticFlux left, MagneticFlux right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MagneticFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MagneticFlux other, MagneticFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MagneticFlux"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MagneticFlux"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MagneticFlux"/>, this method delegates to
+        ///     <see cref="Equals(MagneticFlux)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MagneticFlux otherQuantity))
+            if (obj is not MagneticFlux otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MagneticFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MagneticFlux other, MagneticFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MagneticFlux"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MagneticFlux other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MagneticFlux.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MagneticFlux), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MagneticFlux"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MagneticFlux)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MagneticFlux otherQuantity)) throw new ArgumentException("Expected type MagneticFlux.", nameof(obj));
+            if (obj is not MagneticFlux otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MagneticFlux>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MagneticFlux"/> with another <see cref="MagneticFlux"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MagneticFlux"/> with another <see cref="MagneticFlux"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -592,129 +599,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MagneticFlux other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MagneticFluxUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MagneticFluxUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this MagneticFlux to another MagneticFlux with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MagneticFlux with the specified unit.</returns>
-        public MagneticFlux ToUnit(MagneticFluxUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="MagneticFlux"/> to another <see cref="MagneticFlux"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MagneticFlux with the specified unit.</returns>
-        public MagneticFlux ToUnit(MagneticFluxUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MagneticFlux), Unit, typeof(MagneticFlux), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MagneticFlux)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="MagneticFlux"/> to another <see cref="MagneticFlux"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MagneticFlux"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MagneticFluxUnit unit, [NotNullWhen(true)] out MagneticFlux? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MagneticFlux? convertedOrNull = (Unit, unit) switch
-            {
-                // MagneticFluxUnit -> BaseUnit
-
-                // BaseUnit -> MagneticFluxUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MagneticFluxUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFluxUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MagneticFluxUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFluxUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MagneticFluxUnit> IQuantity<MagneticFluxUnit>.ToUnit(MagneticFluxUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -728,11 +615,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
index 0147a53206..355296bb0f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Magnetization
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Magnetization :
-        IArithmeticQuantity<Magnetization, MagnetizationUnit>,
+        ILinearQuantity<Magnetization, MagnetizationUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Magnetization, Magnetization, double>,
+        IDivisionOperators<Magnetization, Magnetization, QuantityValue>,
         IComparisonOperators<Magnetization, Magnetization, bool>,
         IParsable<Magnetization>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static MagnetizationInfo CreateDefault(Func<IEnumerable<UnitDefinition<Ma
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Magnetization"/> is [L^-1][I].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Magnetization"/> is L^-1I.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 0, 0, 1, 0, 0, 0);
 
@@ -126,9 +125,7 @@ public static IEnumerable<UnitDefinition<MagnetizationUnit>> GetDefaultMappings(
 
         static Magnetization()
         {
-            Info = MagnetizationInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MagnetizationInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +133,7 @@ static Magnetization()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Magnetization(double value, MagnetizationUnit unit)
+        public Magnetization(QuantityValue value, MagnetizationUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -150,7 +147,7 @@ public Magnetization(double value, MagnetizationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Magnetization(double value, UnitSystem unitSystem)
+        public Magnetization(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -161,7 +158,8 @@ public Magnetization(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Magnetization" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Magnetization, MagnetizationUnit> Info { get; }
@@ -190,10 +188,8 @@ public Magnetization(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MagnetizationUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,28 +223,14 @@ public Magnetization(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MagnetizationUnit.AmperePerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MagnetizationUnit.AmperePerMeter"/>
         /// </summary>
-        public double AmperesPerMeter => As(MagnetizationUnit.AmperePerMeter);
+        public QuantityValue AmperesPerMeter => this.As(MagnetizationUnit.AmperePerMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MagnetizationUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Magnetization>(MagnetizationUnit.AmperePerMeter, MagnetizationUnit.AmperePerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MagnetizationUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -277,7 +259,7 @@ public static string GetAbbreviation(MagnetizationUnit unit, IFormatProvider? pr
         /// <summary>
         ///     Creates a <see cref="Magnetization"/> from <see cref="MagnetizationUnit.AmperePerMeter"/>.
         /// </summary>
-        public static Magnetization FromAmperesPerMeter(double value)
+        public static Magnetization FromAmperesPerMeter(QuantityValue value)
         {
             return new Magnetization(value, MagnetizationUnit.AmperePerMeter);
         }
@@ -288,7 +270,7 @@ public static Magnetization FromAmperesPerMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Magnetization unit value.</returns>
-        public static Magnetization From(double value, MagnetizationUnit fromUnit)
+        public static Magnetization From(QuantityValue value, MagnetizationUnit fromUnit)
         {
             return new Magnetization(value, fromUnit);
         }
@@ -349,10 +331,7 @@ public static Magnetization Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Magnetization Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Magnetization, MagnetizationUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Magnetization, MagnetizationUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -380,11 +359,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Magnetization re
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Magnetization result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Magnetization, MagnetizationUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Magnetization, MagnetizationUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -405,7 +380,7 @@ public static MagnetizationUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -416,7 +391,7 @@ public static MagnetizationUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MagnetizationUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MagnetizationUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MagnetizationUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -431,7 +406,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Magnetizatio
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MagnetizationUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -450,35 +425,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Magnetization"/> from adding two <see cref="Magnetization"/>.</summary>
         public static Magnetization operator +(Magnetization left, Magnetization right)
         {
-            return new Magnetization(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Magnetization(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Magnetization"/> from subtracting two <see cref="Magnetization"/>.</summary>
         public static Magnetization operator -(Magnetization left, Magnetization right)
         {
-            return new Magnetization(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Magnetization(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Magnetization"/> from multiplying value and <see cref="Magnetization"/>.</summary>
-        public static Magnetization operator *(double left, Magnetization right)
+        public static Magnetization operator *(QuantityValue left, Magnetization right)
         {
             return new Magnetization(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Magnetization"/> from multiplying value and <see cref="Magnetization"/>.</summary>
-        public static Magnetization operator *(Magnetization left, double right)
+        public static Magnetization operator *(Magnetization left, QuantityValue right)
         {
             return new Magnetization(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Magnetization"/> from dividing <see cref="Magnetization"/> by value.</summary>
-        public static Magnetization operator /(Magnetization left, double right)
+        public static Magnetization operator /(Magnetization left, QuantityValue right)
         {
             return new Magnetization(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Magnetization"/> by <see cref="Magnetization"/>.</summary>
-        public static double operator /(Magnetization left, Magnetization right)
+        public static QuantityValue operator /(Magnetization left, Magnetization right)
         {
             return left.AmperesPerMeter / right.AmperesPerMeter;
         }
@@ -490,97 +465,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Magnetization left, Magnetization right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Magnetization left, Magnetization right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Magnetization left, Magnetization right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Magnetization left, Magnetization right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Magnetization"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Magnetization other, Magnetization tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Magnetization"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Magnetization)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Magnetization left, Magnetization right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Magnetization"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Magnetization other, Magnetization tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Magnetization"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Magnetization,Magnetization)"/>.
+        ///     See that operator (and <see cref="Equals(Magnetization)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Magnetization left, Magnetization right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Magnetization"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Magnetization other, Magnetization tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Magnetization"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Magnetization"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Magnetization"/>, this method delegates to
+        ///     <see cref="Equals(Magnetization)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Magnetization otherQuantity))
+            if (obj is not Magnetization otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Magnetization"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Magnetization other, Magnetization tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Magnetization"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Magnetization other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Magnetization.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Magnetization), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Magnetization"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Magnetization)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Magnetization otherQuantity)) throw new ArgumentException("Expected type Magnetization.", nameof(obj));
+            if (obj is not Magnetization otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Magnetization>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Magnetization"/> with another <see cref="Magnetization"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Magnetization"/> with another <see cref="Magnetization"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -592,131 +581,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Magnetization other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MagnetizationUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MagnetizationUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Magnetization to another Magnetization with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Magnetization with the specified unit.</returns>
-        public Magnetization ToUnit(MagnetizationUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Magnetization"/> to another <see cref="Magnetization"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Magnetization with the specified unit.</returns>
-        public Magnetization ToUnit(MagnetizationUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Magnetization), Unit, typeof(Magnetization), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Magnetization)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Magnetization"/> to another <see cref="Magnetization"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Magnetization"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MagnetizationUnit unit, [NotNullWhen(true)] out Magnetization? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Magnetization? convertedOrNull = (Unit, unit) switch
-            {
-                // MagnetizationUnit -> BaseUnit
-
-                // BaseUnit -> MagnetizationUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MagnetizationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagnetizationUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MagnetizationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagnetizationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MagnetizationUnit> IQuantity<MagnetizationUnit>.ToUnit(MagnetizationUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -728,11 +597,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
index d8cc7d7126..f4993cc01a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     In physics, mass (from Greek μᾶζα "barley cake, lump [of dough]") is a property of a physical system or body, giving rise to the phenomena of the body's resistance to being accelerated by a force and the strength of its mutual gravitational attraction with other bodies. Instruments such as mass balances or scales use those phenomena to measure mass. The SI unit of mass is the kilogram (kg).
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Mass :
-        IArithmeticQuantity<Mass, MassUnit>,
+        ILinearQuantity<Mass, MassUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Mass, Mass, double>,
+        IDivisionOperators<Mass, Mass, QuantityValue>,
         IDivisionOperators<Mass, MolarMass, AmountOfSubstance>,
         IDivisionOperators<Mass, AreaDensity, Area>,
         IDivisionOperators<Mass, Area, AreaDensity>,
@@ -68,7 +67,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -118,7 +117,7 @@ public static MassInfo CreateDefault(Func<IEnumerable<UnitDefinition<MassUnit>>,
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Mass"/> is [M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Mass"/> is M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 1, 0, 0, 0, 0, 0);
 
@@ -133,45 +132,103 @@ public static MassInfo CreateDefault(Func<IEnumerable<UnitDefinition<MassUnit>>,
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MassUnit}"/> representing the default unit mappings for Mass.</returns>
             public static IEnumerable<UnitDefinition<MassUnit>> GetDefaultMappings()
             {
-                yield return new (MassUnit.Centigram, "Centigram", "Centigrams", new BaseUnits(mass: MassUnit.Centigram));
-                yield return new (MassUnit.Dalton, "Dalton", "Daltons", new BaseUnits(mass: MassUnit.Dalton));
-                yield return new (MassUnit.Decagram, "Decagram", "Decagrams", new BaseUnits(mass: MassUnit.Decagram));
-                yield return new (MassUnit.Decigram, "Decigram", "Decigrams", new BaseUnits(mass: MassUnit.Decigram));
-                yield return new (MassUnit.EarthMass, "EarthMass", "EarthMasses", new BaseUnits(mass: MassUnit.EarthMass));
-                yield return new (MassUnit.Femtogram, "Femtogram", "Femtograms", new BaseUnits(mass: MassUnit.Femtogram));
-                yield return new (MassUnit.Gigadalton, "Gigadalton", "Gigadaltons", new BaseUnits(mass: MassUnit.Gigadalton));
-                yield return new (MassUnit.Grain, "Grain", "Grains", new BaseUnits(mass: MassUnit.Grain));
-                yield return new (MassUnit.Gram, "Gram", "Grams", new BaseUnits(mass: MassUnit.Gram));
-                yield return new (MassUnit.Hectogram, "Hectogram", "Hectograms", new BaseUnits(mass: MassUnit.Hectogram));
-                yield return new (MassUnit.Kilodalton, "Kilodalton", "Kilodaltons", new BaseUnits(mass: MassUnit.Kilodalton));
+                yield return new (MassUnit.Centigram, "Centigram", "Centigrams", new BaseUnits(mass: MassUnit.Centigram),
+                     100000
+                );
+                yield return new (MassUnit.Dalton, "Dalton", "Daltons", new BaseUnits(mass: MassUnit.Dalton),
+                     new QuantityValue(new BigInteger(5) * QuantityValue.PowerOfTen(36), 8302695333)
+                );
+                yield return new (MassUnit.Decagram, "Decagram", "Decagrams", new BaseUnits(mass: MassUnit.Decagram),
+                     100
+                );
+                yield return new (MassUnit.Decigram, "Decigram", "Decigrams", new BaseUnits(mass: MassUnit.Decigram),
+                     10000
+                );
+                yield return new (MassUnit.EarthMass, "EarthMass", "EarthMasses", new BaseUnits(mass: MassUnit.EarthMass),
+                     new QuantityValue(1, new BigInteger(59722) * QuantityValue.PowerOfTen(20))
+                );
+                yield return new (MassUnit.Femtogram, "Femtogram", "Femtograms", new BaseUnits(mass: MassUnit.Femtogram),
+                     1000000000000000000
+                );
+                yield return new (MassUnit.Gigadalton, "Gigadalton", "Gigadaltons", new BaseUnits(mass: MassUnit.Gigadalton),
+                     new QuantityValue(new BigInteger(5) * QuantityValue.PowerOfTen(27), 8302695333)
+                );
+                yield return new (MassUnit.Grain, "Grain", "Grains", new BaseUnits(mass: MassUnit.Grain),
+                     new QuantityValue(100000000000, 6479891)
+                );
+                yield return new (MassUnit.Gram, "Gram", "Grams", new BaseUnits(mass: MassUnit.Gram),
+                     1000
+                );
+                yield return new (MassUnit.Hectogram, "Hectogram", "Hectograms", new BaseUnits(mass: MassUnit.Hectogram),
+                     10
+                );
+                yield return new (MassUnit.Kilodalton, "Kilodalton", "Kilodaltons", new BaseUnits(mass: MassUnit.Kilodalton),
+                     new QuantityValue(new BigInteger(5) * QuantityValue.PowerOfTen(33), 8302695333)
+                );
                 yield return new (MassUnit.Kilogram, "Kilogram", "Kilograms", new BaseUnits(mass: MassUnit.Kilogram));
-                yield return new (MassUnit.Kilopound, "Kilopound", "Kilopounds", new BaseUnits(mass: MassUnit.Kilopound));
-                yield return new (MassUnit.Kilotonne, "Kilotonne", "Kilotonnes", new BaseUnits(mass: MassUnit.Kilotonne));
-                yield return new (MassUnit.LongHundredweight, "LongHundredweight", "LongHundredweight", new BaseUnits(mass: MassUnit.LongHundredweight));
-                yield return new (MassUnit.LongTon, "LongTon", "LongTons", new BaseUnits(mass: MassUnit.LongTon));
-                yield return new (MassUnit.Megadalton, "Megadalton", "Megadaltons", new BaseUnits(mass: MassUnit.Megadalton));
-                yield return new (MassUnit.Megapound, "Megapound", "Megapounds", new BaseUnits(mass: MassUnit.Megapound));
-                yield return new (MassUnit.Megatonne, "Megatonne", "Megatonnes", new BaseUnits(mass: MassUnit.Megatonne));
-                yield return new (MassUnit.Microgram, "Microgram", "Micrograms", new BaseUnits(mass: MassUnit.Microgram));
-                yield return new (MassUnit.Milligram, "Milligram", "Milligrams", new BaseUnits(mass: MassUnit.Milligram));
-                yield return new (MassUnit.Nanogram, "Nanogram", "Nanograms", new BaseUnits(mass: MassUnit.Nanogram));
-                yield return new (MassUnit.Ounce, "Ounce", "Ounces", new BaseUnits(mass: MassUnit.Ounce));
-                yield return new (MassUnit.Picogram, "Picogram", "Picograms", new BaseUnits(mass: MassUnit.Picogram));
-                yield return new (MassUnit.Pound, "Pound", "Pounds", new BaseUnits(mass: MassUnit.Pound));
-                yield return new (MassUnit.ShortHundredweight, "ShortHundredweight", "ShortHundredweight", new BaseUnits(mass: MassUnit.ShortHundredweight));
-                yield return new (MassUnit.ShortTon, "ShortTon", "ShortTons", new BaseUnits(mass: MassUnit.ShortTon));
-                yield return new (MassUnit.Slug, "Slug", "Slugs", new BaseUnits(mass: MassUnit.Slug));
-                yield return new (MassUnit.SolarMass, "SolarMass", "SolarMasses", new BaseUnits(mass: MassUnit.SolarMass));
-                yield return new (MassUnit.Stone, "Stone", "Stone", new BaseUnits(mass: MassUnit.Stone));
-                yield return new (MassUnit.Tonne, "Tonne", "Tonnes", new BaseUnits(mass: MassUnit.Tonne));
+                yield return new (MassUnit.Kilopound, "Kilopound", "Kilopounds", new BaseUnits(mass: MassUnit.Kilopound),
+                     new QuantityValue(100000, 45359237)
+                );
+                yield return new (MassUnit.Kilotonne, "Kilotonne", "Kilotonnes", new BaseUnits(mass: MassUnit.Kilotonne),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (MassUnit.LongHundredweight, "LongHundredweight", "LongHundredweight", new BaseUnits(mass: MassUnit.LongHundredweight),
+                     new QuantityValue(6250000, 317514659)
+                );
+                yield return new (MassUnit.LongTon, "LongTon", "LongTons", new BaseUnits(mass: MassUnit.LongTon),
+                     new QuantityValue(312500, 317514659)
+                );
+                yield return new (MassUnit.Megadalton, "Megadalton", "Megadaltons", new BaseUnits(mass: MassUnit.Megadalton),
+                     new QuantityValue(new BigInteger(5) * QuantityValue.PowerOfTen(30), 8302695333)
+                );
+                yield return new (MassUnit.Megapound, "Megapound", "Megapounds", new BaseUnits(mass: MassUnit.Megapound),
+                     new QuantityValue(100, 45359237)
+                );
+                yield return new (MassUnit.Megatonne, "Megatonne", "Megatonnes", new BaseUnits(mass: MassUnit.Megatonne),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (MassUnit.Microgram, "Microgram", "Micrograms", new BaseUnits(mass: MassUnit.Microgram),
+                     1000000000
+                );
+                yield return new (MassUnit.Milligram, "Milligram", "Milligrams", new BaseUnits(mass: MassUnit.Milligram),
+                     1000000
+                );
+                yield return new (MassUnit.Nanogram, "Nanogram", "Nanograms", new BaseUnits(mass: MassUnit.Nanogram),
+                     1000000000000
+                );
+                yield return new (MassUnit.Ounce, "Ounce", "Ounces", new BaseUnits(mass: MassUnit.Ounce),
+                     new QuantityValue(1600000000, 45359237)
+                );
+                yield return new (MassUnit.Picogram, "Picogram", "Picograms", new BaseUnits(mass: MassUnit.Picogram),
+                     1000000000000000
+                );
+                yield return new (MassUnit.Pound, "Pound", "Pounds", new BaseUnits(mass: MassUnit.Pound),
+                     new QuantityValue(100000000, 45359237)
+                );
+                yield return new (MassUnit.ShortHundredweight, "ShortHundredweight", "ShortHundredweight", new BaseUnits(mass: MassUnit.ShortHundredweight),
+                     new QuantityValue(1000000, 45359237)
+                );
+                yield return new (MassUnit.ShortTon, "ShortTon", "ShortTons", new BaseUnits(mass: MassUnit.ShortTon),
+                     new QuantityValue(50000, 45359237)
+                );
+                yield return new (MassUnit.Slug, "Slug", "Slugs", new BaseUnits(mass: MassUnit.Slug),
+                     new QuantityValue(609600000000, 8896443230521)
+                );
+                yield return new (MassUnit.SolarMass, "SolarMass", "SolarMasses", new BaseUnits(mass: MassUnit.SolarMass),
+                     new QuantityValue(1, new BigInteger(198947) * QuantityValue.PowerOfTen(25))
+                );
+                yield return new (MassUnit.Stone, "Stone", "Stone", new BaseUnits(mass: MassUnit.Stone),
+                     new QuantityValue(50000000, 317514659)
+                );
+                yield return new (MassUnit.Tonne, "Tonne", "Tonnes", new BaseUnits(mass: MassUnit.Tonne),
+                     new QuantityValue(1, 1000)
+                );
             }
         }
 
         static Mass()
         {
-            Info = MassInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MassInfo.CreateDefault);
         }
 
         /// <summary>
@@ -179,7 +236,7 @@ static Mass()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Mass(double value, MassUnit unit)
+        public Mass(QuantityValue value, MassUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -193,7 +250,7 @@ public Mass(double value, MassUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Mass(double value, UnitSystem unitSystem)
+        public Mass(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -204,7 +261,8 @@ public Mass(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Mass" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Mass, MassUnit> Info { get; }
@@ -233,10 +291,8 @@ public Mass(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MassUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -270,238 +326,164 @@ public Mass(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Centigram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Centigram"/>
         /// </summary>
-        public double Centigrams => As(MassUnit.Centigram);
+        public QuantityValue Centigrams => this.As(MassUnit.Centigram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Dalton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Dalton"/>
         /// </summary>
-        public double Daltons => As(MassUnit.Dalton);
+        public QuantityValue Daltons => this.As(MassUnit.Dalton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Decagram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Decagram"/>
         /// </summary>
-        public double Decagrams => As(MassUnit.Decagram);
+        public QuantityValue Decagrams => this.As(MassUnit.Decagram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Decigram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Decigram"/>
         /// </summary>
-        public double Decigrams => As(MassUnit.Decigram);
+        public QuantityValue Decigrams => this.As(MassUnit.Decigram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.EarthMass"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.EarthMass"/>
         /// </summary>
-        public double EarthMasses => As(MassUnit.EarthMass);
+        public QuantityValue EarthMasses => this.As(MassUnit.EarthMass);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Femtogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Femtogram"/>
         /// </summary>
-        public double Femtograms => As(MassUnit.Femtogram);
+        public QuantityValue Femtograms => this.As(MassUnit.Femtogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Gigadalton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Gigadalton"/>
         /// </summary>
-        public double Gigadaltons => As(MassUnit.Gigadalton);
+        public QuantityValue Gigadaltons => this.As(MassUnit.Gigadalton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Grain"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Grain"/>
         /// </summary>
-        public double Grains => As(MassUnit.Grain);
+        public QuantityValue Grains => this.As(MassUnit.Grain);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Gram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Gram"/>
         /// </summary>
-        public double Grams => As(MassUnit.Gram);
+        public QuantityValue Grams => this.As(MassUnit.Gram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Hectogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Hectogram"/>
         /// </summary>
-        public double Hectograms => As(MassUnit.Hectogram);
+        public QuantityValue Hectograms => this.As(MassUnit.Hectogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Kilodalton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Kilodalton"/>
         /// </summary>
-        public double Kilodaltons => As(MassUnit.Kilodalton);
+        public QuantityValue Kilodaltons => this.As(MassUnit.Kilodalton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Kilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Kilogram"/>
         /// </summary>
-        public double Kilograms => As(MassUnit.Kilogram);
+        public QuantityValue Kilograms => this.As(MassUnit.Kilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Kilopound"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Kilopound"/>
         /// </summary>
-        public double Kilopounds => As(MassUnit.Kilopound);
+        public QuantityValue Kilopounds => this.As(MassUnit.Kilopound);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Kilotonne"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Kilotonne"/>
         /// </summary>
-        public double Kilotonnes => As(MassUnit.Kilotonne);
+        public QuantityValue Kilotonnes => this.As(MassUnit.Kilotonne);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.LongHundredweight"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.LongHundredweight"/>
         /// </summary>
-        public double LongHundredweight => As(MassUnit.LongHundredweight);
+        public QuantityValue LongHundredweight => this.As(MassUnit.LongHundredweight);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.LongTon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.LongTon"/>
         /// </summary>
-        public double LongTons => As(MassUnit.LongTon);
+        public QuantityValue LongTons => this.As(MassUnit.LongTon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Megadalton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Megadalton"/>
         /// </summary>
-        public double Megadaltons => As(MassUnit.Megadalton);
+        public QuantityValue Megadaltons => this.As(MassUnit.Megadalton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Megapound"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Megapound"/>
         /// </summary>
-        public double Megapounds => As(MassUnit.Megapound);
+        public QuantityValue Megapounds => this.As(MassUnit.Megapound);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Megatonne"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Megatonne"/>
         /// </summary>
-        public double Megatonnes => As(MassUnit.Megatonne);
+        public QuantityValue Megatonnes => this.As(MassUnit.Megatonne);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Microgram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Microgram"/>
         /// </summary>
-        public double Micrograms => As(MassUnit.Microgram);
+        public QuantityValue Micrograms => this.As(MassUnit.Microgram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Milligram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Milligram"/>
         /// </summary>
-        public double Milligrams => As(MassUnit.Milligram);
+        public QuantityValue Milligrams => this.As(MassUnit.Milligram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Nanogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Nanogram"/>
         /// </summary>
-        public double Nanograms => As(MassUnit.Nanogram);
+        public QuantityValue Nanograms => this.As(MassUnit.Nanogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Ounce"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Ounce"/>
         /// </summary>
-        public double Ounces => As(MassUnit.Ounce);
+        public QuantityValue Ounces => this.As(MassUnit.Ounce);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Picogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Picogram"/>
         /// </summary>
-        public double Picograms => As(MassUnit.Picogram);
+        public QuantityValue Picograms => this.As(MassUnit.Picogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Pound"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Pound"/>
         /// </summary>
-        public double Pounds => As(MassUnit.Pound);
+        public QuantityValue Pounds => this.As(MassUnit.Pound);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.ShortHundredweight"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.ShortHundredweight"/>
         /// </summary>
-        public double ShortHundredweight => As(MassUnit.ShortHundredweight);
+        public QuantityValue ShortHundredweight => this.As(MassUnit.ShortHundredweight);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.ShortTon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.ShortTon"/>
         /// </summary>
-        public double ShortTons => As(MassUnit.ShortTon);
+        public QuantityValue ShortTons => this.As(MassUnit.ShortTon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Slug"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Slug"/>
         /// </summary>
-        public double Slugs => As(MassUnit.Slug);
+        public QuantityValue Slugs => this.As(MassUnit.Slug);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.SolarMass"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.SolarMass"/>
         /// </summary>
-        public double SolarMasses => As(MassUnit.SolarMass);
+        public QuantityValue SolarMasses => this.As(MassUnit.SolarMass);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Stone"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Stone"/>
         /// </summary>
-        public double Stone => As(MassUnit.Stone);
+        public QuantityValue Stone => this.As(MassUnit.Stone);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassUnit.Tonne"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassUnit.Tonne"/>
         /// </summary>
-        public double Tonnes => As(MassUnit.Tonne);
+        public QuantityValue Tonnes => this.As(MassUnit.Tonne);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MassUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Centigram, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Dalton, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Decagram, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Decigram, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.EarthMass, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Femtogram, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Gigadalton, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Grain, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Gram, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Hectogram, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilodalton, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilopound, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilotonne, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.LongHundredweight, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.LongTon, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Megadalton, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Megapound, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Megatonne, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Microgram, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Milligram, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Nanogram, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Ounce, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Picogram, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Pound, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.ShortHundredweight, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.ShortTon, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Slug, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.SolarMass, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Stone, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Tonne, MassUnit.Kilogram, quantity => quantity.ToUnit(MassUnit.Kilogram));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Kilogram, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MassUnit
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Centigram, quantity => quantity.ToUnit(MassUnit.Centigram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Dalton, quantity => quantity.ToUnit(MassUnit.Dalton));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Decagram, quantity => quantity.ToUnit(MassUnit.Decagram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Decigram, quantity => quantity.ToUnit(MassUnit.Decigram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.EarthMass, quantity => quantity.ToUnit(MassUnit.EarthMass));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Femtogram, quantity => quantity.ToUnit(MassUnit.Femtogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Gigadalton, quantity => quantity.ToUnit(MassUnit.Gigadalton));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Grain, quantity => quantity.ToUnit(MassUnit.Grain));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Gram, quantity => quantity.ToUnit(MassUnit.Gram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Hectogram, quantity => quantity.ToUnit(MassUnit.Hectogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Kilodalton, quantity => quantity.ToUnit(MassUnit.Kilodalton));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Kilopound, quantity => quantity.ToUnit(MassUnit.Kilopound));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Kilotonne, quantity => quantity.ToUnit(MassUnit.Kilotonne));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.LongHundredweight, quantity => quantity.ToUnit(MassUnit.LongHundredweight));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.LongTon, quantity => quantity.ToUnit(MassUnit.LongTon));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Megadalton, quantity => quantity.ToUnit(MassUnit.Megadalton));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Megapound, quantity => quantity.ToUnit(MassUnit.Megapound));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Megatonne, quantity => quantity.ToUnit(MassUnit.Megatonne));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Microgram, quantity => quantity.ToUnit(MassUnit.Microgram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Milligram, quantity => quantity.ToUnit(MassUnit.Milligram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Nanogram, quantity => quantity.ToUnit(MassUnit.Nanogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Ounce, quantity => quantity.ToUnit(MassUnit.Ounce));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Picogram, quantity => quantity.ToUnit(MassUnit.Picogram));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Pound, quantity => quantity.ToUnit(MassUnit.Pound));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.ShortHundredweight, quantity => quantity.ToUnit(MassUnit.ShortHundredweight));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.ShortTon, quantity => quantity.ToUnit(MassUnit.ShortTon));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Slug, quantity => quantity.ToUnit(MassUnit.Slug));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.SolarMass, quantity => quantity.ToUnit(MassUnit.SolarMass));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Stone, quantity => quantity.ToUnit(MassUnit.Stone));
-            unitConverter.SetConversionFunction<Mass>(MassUnit.Kilogram, MassUnit.Tonne, quantity => quantity.ToUnit(MassUnit.Tonne));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -530,7 +512,7 @@ public static string GetAbbreviation(MassUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Centigram"/>.
         /// </summary>
-        public static Mass FromCentigrams(double value)
+        public static Mass FromCentigrams(QuantityValue value)
         {
             return new Mass(value, MassUnit.Centigram);
         }
@@ -538,7 +520,7 @@ public static Mass FromCentigrams(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Dalton"/>.
         /// </summary>
-        public static Mass FromDaltons(double value)
+        public static Mass FromDaltons(QuantityValue value)
         {
             return new Mass(value, MassUnit.Dalton);
         }
@@ -546,7 +528,7 @@ public static Mass FromDaltons(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Decagram"/>.
         /// </summary>
-        public static Mass FromDecagrams(double value)
+        public static Mass FromDecagrams(QuantityValue value)
         {
             return new Mass(value, MassUnit.Decagram);
         }
@@ -554,7 +536,7 @@ public static Mass FromDecagrams(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Decigram"/>.
         /// </summary>
-        public static Mass FromDecigrams(double value)
+        public static Mass FromDecigrams(QuantityValue value)
         {
             return new Mass(value, MassUnit.Decigram);
         }
@@ -562,7 +544,7 @@ public static Mass FromDecigrams(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.EarthMass"/>.
         /// </summary>
-        public static Mass FromEarthMasses(double value)
+        public static Mass FromEarthMasses(QuantityValue value)
         {
             return new Mass(value, MassUnit.EarthMass);
         }
@@ -570,7 +552,7 @@ public static Mass FromEarthMasses(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Femtogram"/>.
         /// </summary>
-        public static Mass FromFemtograms(double value)
+        public static Mass FromFemtograms(QuantityValue value)
         {
             return new Mass(value, MassUnit.Femtogram);
         }
@@ -578,7 +560,7 @@ public static Mass FromFemtograms(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Gigadalton"/>.
         /// </summary>
-        public static Mass FromGigadaltons(double value)
+        public static Mass FromGigadaltons(QuantityValue value)
         {
             return new Mass(value, MassUnit.Gigadalton);
         }
@@ -586,7 +568,7 @@ public static Mass FromGigadaltons(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Grain"/>.
         /// </summary>
-        public static Mass FromGrains(double value)
+        public static Mass FromGrains(QuantityValue value)
         {
             return new Mass(value, MassUnit.Grain);
         }
@@ -594,7 +576,7 @@ public static Mass FromGrains(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Gram"/>.
         /// </summary>
-        public static Mass FromGrams(double value)
+        public static Mass FromGrams(QuantityValue value)
         {
             return new Mass(value, MassUnit.Gram);
         }
@@ -602,7 +584,7 @@ public static Mass FromGrams(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Hectogram"/>.
         /// </summary>
-        public static Mass FromHectograms(double value)
+        public static Mass FromHectograms(QuantityValue value)
         {
             return new Mass(value, MassUnit.Hectogram);
         }
@@ -610,7 +592,7 @@ public static Mass FromHectograms(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilodalton"/>.
         /// </summary>
-        public static Mass FromKilodaltons(double value)
+        public static Mass FromKilodaltons(QuantityValue value)
         {
             return new Mass(value, MassUnit.Kilodalton);
         }
@@ -618,7 +600,7 @@ public static Mass FromKilodaltons(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilogram"/>.
         /// </summary>
-        public static Mass FromKilograms(double value)
+        public static Mass FromKilograms(QuantityValue value)
         {
             return new Mass(value, MassUnit.Kilogram);
         }
@@ -626,7 +608,7 @@ public static Mass FromKilograms(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilopound"/>.
         /// </summary>
-        public static Mass FromKilopounds(double value)
+        public static Mass FromKilopounds(QuantityValue value)
         {
             return new Mass(value, MassUnit.Kilopound);
         }
@@ -634,7 +616,7 @@ public static Mass FromKilopounds(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilotonne"/>.
         /// </summary>
-        public static Mass FromKilotonnes(double value)
+        public static Mass FromKilotonnes(QuantityValue value)
         {
             return new Mass(value, MassUnit.Kilotonne);
         }
@@ -642,7 +624,7 @@ public static Mass FromKilotonnes(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.LongHundredweight"/>.
         /// </summary>
-        public static Mass FromLongHundredweight(double value)
+        public static Mass FromLongHundredweight(QuantityValue value)
         {
             return new Mass(value, MassUnit.LongHundredweight);
         }
@@ -650,7 +632,7 @@ public static Mass FromLongHundredweight(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.LongTon"/>.
         /// </summary>
-        public static Mass FromLongTons(double value)
+        public static Mass FromLongTons(QuantityValue value)
         {
             return new Mass(value, MassUnit.LongTon);
         }
@@ -658,7 +640,7 @@ public static Mass FromLongTons(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Megadalton"/>.
         /// </summary>
-        public static Mass FromMegadaltons(double value)
+        public static Mass FromMegadaltons(QuantityValue value)
         {
             return new Mass(value, MassUnit.Megadalton);
         }
@@ -666,7 +648,7 @@ public static Mass FromMegadaltons(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Megapound"/>.
         /// </summary>
-        public static Mass FromMegapounds(double value)
+        public static Mass FromMegapounds(QuantityValue value)
         {
             return new Mass(value, MassUnit.Megapound);
         }
@@ -674,7 +656,7 @@ public static Mass FromMegapounds(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Megatonne"/>.
         /// </summary>
-        public static Mass FromMegatonnes(double value)
+        public static Mass FromMegatonnes(QuantityValue value)
         {
             return new Mass(value, MassUnit.Megatonne);
         }
@@ -682,7 +664,7 @@ public static Mass FromMegatonnes(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Microgram"/>.
         /// </summary>
-        public static Mass FromMicrograms(double value)
+        public static Mass FromMicrograms(QuantityValue value)
         {
             return new Mass(value, MassUnit.Microgram);
         }
@@ -690,7 +672,7 @@ public static Mass FromMicrograms(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Milligram"/>.
         /// </summary>
-        public static Mass FromMilligrams(double value)
+        public static Mass FromMilligrams(QuantityValue value)
         {
             return new Mass(value, MassUnit.Milligram);
         }
@@ -698,7 +680,7 @@ public static Mass FromMilligrams(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Nanogram"/>.
         /// </summary>
-        public static Mass FromNanograms(double value)
+        public static Mass FromNanograms(QuantityValue value)
         {
             return new Mass(value, MassUnit.Nanogram);
         }
@@ -706,7 +688,7 @@ public static Mass FromNanograms(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Ounce"/>.
         /// </summary>
-        public static Mass FromOunces(double value)
+        public static Mass FromOunces(QuantityValue value)
         {
             return new Mass(value, MassUnit.Ounce);
         }
@@ -714,7 +696,7 @@ public static Mass FromOunces(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Picogram"/>.
         /// </summary>
-        public static Mass FromPicograms(double value)
+        public static Mass FromPicograms(QuantityValue value)
         {
             return new Mass(value, MassUnit.Picogram);
         }
@@ -722,7 +704,7 @@ public static Mass FromPicograms(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Pound"/>.
         /// </summary>
-        public static Mass FromPounds(double value)
+        public static Mass FromPounds(QuantityValue value)
         {
             return new Mass(value, MassUnit.Pound);
         }
@@ -730,7 +712,7 @@ public static Mass FromPounds(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.ShortHundredweight"/>.
         /// </summary>
-        public static Mass FromShortHundredweight(double value)
+        public static Mass FromShortHundredweight(QuantityValue value)
         {
             return new Mass(value, MassUnit.ShortHundredweight);
         }
@@ -738,7 +720,7 @@ public static Mass FromShortHundredweight(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.ShortTon"/>.
         /// </summary>
-        public static Mass FromShortTons(double value)
+        public static Mass FromShortTons(QuantityValue value)
         {
             return new Mass(value, MassUnit.ShortTon);
         }
@@ -746,7 +728,7 @@ public static Mass FromShortTons(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Slug"/>.
         /// </summary>
-        public static Mass FromSlugs(double value)
+        public static Mass FromSlugs(QuantityValue value)
         {
             return new Mass(value, MassUnit.Slug);
         }
@@ -754,7 +736,7 @@ public static Mass FromSlugs(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.SolarMass"/>.
         /// </summary>
-        public static Mass FromSolarMasses(double value)
+        public static Mass FromSolarMasses(QuantityValue value)
         {
             return new Mass(value, MassUnit.SolarMass);
         }
@@ -762,7 +744,7 @@ public static Mass FromSolarMasses(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Stone"/>.
         /// </summary>
-        public static Mass FromStone(double value)
+        public static Mass FromStone(QuantityValue value)
         {
             return new Mass(value, MassUnit.Stone);
         }
@@ -770,7 +752,7 @@ public static Mass FromStone(double value)
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Tonne"/>.
         /// </summary>
-        public static Mass FromTonnes(double value)
+        public static Mass FromTonnes(QuantityValue value)
         {
             return new Mass(value, MassUnit.Tonne);
         }
@@ -781,7 +763,7 @@ public static Mass FromTonnes(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Mass unit value.</returns>
-        public static Mass From(double value, MassUnit fromUnit)
+        public static Mass From(QuantityValue value, MassUnit fromUnit)
         {
             return new Mass(value, fromUnit);
         }
@@ -842,10 +824,7 @@ public static Mass Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Mass Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Mass, MassUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Mass, MassUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -873,11 +852,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Mass result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Mass result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Mass, MassUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Mass, MassUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -898,7 +873,7 @@ public static MassUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -909,7 +884,7 @@ public static MassUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MassUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -924,7 +899,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassUnit uni
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -943,35 +918,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Mass"/> from adding two <see cref="Mass"/>.</summary>
         public static Mass operator +(Mass left, Mass right)
         {
-            return new Mass(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Mass(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Mass"/> from subtracting two <see cref="Mass"/>.</summary>
         public static Mass operator -(Mass left, Mass right)
         {
-            return new Mass(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Mass(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Mass"/> from multiplying value and <see cref="Mass"/>.</summary>
-        public static Mass operator *(double left, Mass right)
+        public static Mass operator *(QuantityValue left, Mass right)
         {
             return new Mass(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Mass"/> from multiplying value and <see cref="Mass"/>.</summary>
-        public static Mass operator *(Mass left, double right)
+        public static Mass operator *(Mass left, QuantityValue right)
         {
             return new Mass(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Mass"/> from dividing <see cref="Mass"/> by value.</summary>
-        public static Mass operator /(Mass left, double right)
+        public static Mass operator /(Mass left, QuantityValue right)
         {
             return new Mass(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Mass"/> by <see cref="Mass"/>.</summary>
-        public static double operator /(Mass left, Mass right)
+        public static QuantityValue operator /(Mass left, Mass right)
         {
             return left.Kilograms / right.Kilograms;
         }
@@ -1083,97 +1058,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Mass left, Mass right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Mass left, Mass right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Mass left, Mass right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Mass left, Mass right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Mass"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Mass other, Mass tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Mass"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Mass)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Mass left, Mass right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Mass"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Mass other, Mass tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Mass"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Mass,Mass)"/>.
+        ///     See that operator (and <see cref="Equals(Mass)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Mass left, Mass right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Mass"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Mass other, Mass tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Mass"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Mass"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Mass"/>, this method delegates to
+        ///     <see cref="Equals(Mass)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Mass otherQuantity))
+            if (obj is not Mass otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Mass"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Mass other, Mass tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Mass"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Mass other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Mass.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Mass), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Mass"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Mass)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Mass otherQuantity)) throw new ArgumentException("Expected type Mass.", nameof(obj));
+            if (obj is not Mass otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Mass>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Mass"/> with another <see cref="Mass"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Mass"/> with another <see cref="Mass"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1185,189 +1174,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Mass other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MassUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Mass to another Mass with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Mass with the specified unit.</returns>
-        public Mass ToUnit(MassUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Mass"/> to another <see cref="Mass"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Mass with the specified unit.</returns>
-        public Mass ToUnit(MassUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Mass), Unit, typeof(Mass), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Mass)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="Mass"/> to another <see cref="Mass"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Mass"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MassUnit unit, [NotNullWhen(true)] out Mass? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Mass? convertedOrNull = (Unit, unit) switch
-            {
-                // MassUnit -> BaseUnit
-                (MassUnit.Centigram, MassUnit.Kilogram) => new Mass((_value / 1e3) * 1e-2d, MassUnit.Kilogram),
-                (MassUnit.Dalton, MassUnit.Kilogram) => new Mass(_value *  1.66053906660e-27, MassUnit.Kilogram),
-                (MassUnit.Decagram, MassUnit.Kilogram) => new Mass((_value / 1e3) * 1e1d, MassUnit.Kilogram),
-                (MassUnit.Decigram, MassUnit.Kilogram) => new Mass((_value / 1e3) * 1e-1d, MassUnit.Kilogram),
-                (MassUnit.EarthMass, MassUnit.Kilogram) => new Mass(_value * 5.9722E+24, MassUnit.Kilogram),
-                (MassUnit.Femtogram, MassUnit.Kilogram) => new Mass((_value / 1e3) * 1e-15d, MassUnit.Kilogram),
-                (MassUnit.Gigadalton, MassUnit.Kilogram) => new Mass((_value *  1.66053906660e-27) * 1e9d, MassUnit.Kilogram),
-                (MassUnit.Grain, MassUnit.Kilogram) => new Mass(_value * 64.79891e-6, MassUnit.Kilogram),
-                (MassUnit.Gram, MassUnit.Kilogram) => new Mass(_value / 1e3, MassUnit.Kilogram),
-                (MassUnit.Hectogram, MassUnit.Kilogram) => new Mass((_value / 1e3) * 1e2d, MassUnit.Kilogram),
-                (MassUnit.Kilodalton, MassUnit.Kilogram) => new Mass((_value *  1.66053906660e-27) * 1e3d, MassUnit.Kilogram),
-                (MassUnit.Kilopound, MassUnit.Kilogram) => new Mass((_value * 0.45359237) * 1e3d, MassUnit.Kilogram),
-                (MassUnit.Kilotonne, MassUnit.Kilogram) => new Mass((_value * 1e3) * 1e3d, MassUnit.Kilogram),
-                (MassUnit.LongHundredweight, MassUnit.Kilogram) => new Mass(_value * 50.80234544, MassUnit.Kilogram),
-                (MassUnit.LongTon, MassUnit.Kilogram) => new Mass(_value * 1016.0469088, MassUnit.Kilogram),
-                (MassUnit.Megadalton, MassUnit.Kilogram) => new Mass((_value *  1.66053906660e-27) * 1e6d, MassUnit.Kilogram),
-                (MassUnit.Megapound, MassUnit.Kilogram) => new Mass((_value * 0.45359237) * 1e6d, MassUnit.Kilogram),
-                (MassUnit.Megatonne, MassUnit.Kilogram) => new Mass((_value * 1e3) * 1e6d, MassUnit.Kilogram),
-                (MassUnit.Microgram, MassUnit.Kilogram) => new Mass((_value / 1e3) * 1e-6d, MassUnit.Kilogram),
-                (MassUnit.Milligram, MassUnit.Kilogram) => new Mass((_value / 1e3) * 1e-3d, MassUnit.Kilogram),
-                (MassUnit.Nanogram, MassUnit.Kilogram) => new Mass((_value / 1e3) * 1e-9d, MassUnit.Kilogram),
-                (MassUnit.Ounce, MassUnit.Kilogram) => new Mass(_value * 0.028349523125, MassUnit.Kilogram),
-                (MassUnit.Picogram, MassUnit.Kilogram) => new Mass((_value / 1e3) * 1e-12d, MassUnit.Kilogram),
-                (MassUnit.Pound, MassUnit.Kilogram) => new Mass(_value * 0.45359237, MassUnit.Kilogram),
-                (MassUnit.ShortHundredweight, MassUnit.Kilogram) => new Mass(_value * 45.359237, MassUnit.Kilogram),
-                (MassUnit.ShortTon, MassUnit.Kilogram) => new Mass(_value * 907.18474, MassUnit.Kilogram),
-                (MassUnit.Slug, MassUnit.Kilogram) => new Mass(_value * 0.45359237 * 9.80665 / 0.3048, MassUnit.Kilogram),
-                (MassUnit.SolarMass, MassUnit.Kilogram) => new Mass(_value * 1.98947e30, MassUnit.Kilogram),
-                (MassUnit.Stone, MassUnit.Kilogram) => new Mass(_value * 6.35029318, MassUnit.Kilogram),
-                (MassUnit.Tonne, MassUnit.Kilogram) => new Mass(_value * 1e3, MassUnit.Kilogram),
-
-                // BaseUnit -> MassUnit
-                (MassUnit.Kilogram, MassUnit.Centigram) => new Mass((_value * 1e3) / 1e-2d, MassUnit.Centigram),
-                (MassUnit.Kilogram, MassUnit.Dalton) => new Mass(_value /  1.66053906660e-27, MassUnit.Dalton),
-                (MassUnit.Kilogram, MassUnit.Decagram) => new Mass((_value * 1e3) / 1e1d, MassUnit.Decagram),
-                (MassUnit.Kilogram, MassUnit.Decigram) => new Mass((_value * 1e3) / 1e-1d, MassUnit.Decigram),
-                (MassUnit.Kilogram, MassUnit.EarthMass) => new Mass(_value / 5.9722E+24, MassUnit.EarthMass),
-                (MassUnit.Kilogram, MassUnit.Femtogram) => new Mass((_value * 1e3) / 1e-15d, MassUnit.Femtogram),
-                (MassUnit.Kilogram, MassUnit.Gigadalton) => new Mass((_value /  1.66053906660e-27) / 1e9d, MassUnit.Gigadalton),
-                (MassUnit.Kilogram, MassUnit.Grain) => new Mass(_value / 64.79891e-6, MassUnit.Grain),
-                (MassUnit.Kilogram, MassUnit.Gram) => new Mass(_value * 1e3, MassUnit.Gram),
-                (MassUnit.Kilogram, MassUnit.Hectogram) => new Mass((_value * 1e3) / 1e2d, MassUnit.Hectogram),
-                (MassUnit.Kilogram, MassUnit.Kilodalton) => new Mass((_value /  1.66053906660e-27) / 1e3d, MassUnit.Kilodalton),
-                (MassUnit.Kilogram, MassUnit.Kilopound) => new Mass((_value / 0.45359237) / 1e3d, MassUnit.Kilopound),
-                (MassUnit.Kilogram, MassUnit.Kilotonne) => new Mass((_value / 1e3) / 1e3d, MassUnit.Kilotonne),
-                (MassUnit.Kilogram, MassUnit.LongHundredweight) => new Mass(_value / 50.80234544, MassUnit.LongHundredweight),
-                (MassUnit.Kilogram, MassUnit.LongTon) => new Mass(_value / 1016.0469088, MassUnit.LongTon),
-                (MassUnit.Kilogram, MassUnit.Megadalton) => new Mass((_value /  1.66053906660e-27) / 1e6d, MassUnit.Megadalton),
-                (MassUnit.Kilogram, MassUnit.Megapound) => new Mass((_value / 0.45359237) / 1e6d, MassUnit.Megapound),
-                (MassUnit.Kilogram, MassUnit.Megatonne) => new Mass((_value / 1e3) / 1e6d, MassUnit.Megatonne),
-                (MassUnit.Kilogram, MassUnit.Microgram) => new Mass((_value * 1e3) / 1e-6d, MassUnit.Microgram),
-                (MassUnit.Kilogram, MassUnit.Milligram) => new Mass((_value * 1e3) / 1e-3d, MassUnit.Milligram),
-                (MassUnit.Kilogram, MassUnit.Nanogram) => new Mass((_value * 1e3) / 1e-9d, MassUnit.Nanogram),
-                (MassUnit.Kilogram, MassUnit.Ounce) => new Mass(_value / 0.028349523125, MassUnit.Ounce),
-                (MassUnit.Kilogram, MassUnit.Picogram) => new Mass((_value * 1e3) / 1e-12d, MassUnit.Picogram),
-                (MassUnit.Kilogram, MassUnit.Pound) => new Mass(_value / 0.45359237, MassUnit.Pound),
-                (MassUnit.Kilogram, MassUnit.ShortHundredweight) => new Mass(_value / 45.359237, MassUnit.ShortHundredweight),
-                (MassUnit.Kilogram, MassUnit.ShortTon) => new Mass(_value / 907.18474, MassUnit.ShortTon),
-                (MassUnit.Kilogram, MassUnit.Slug) => new Mass(_value * 0.3048 / (0.45359237 * 9.80665), MassUnit.Slug),
-                (MassUnit.Kilogram, MassUnit.SolarMass) => new Mass(_value / 1.98947e30, MassUnit.SolarMass),
-                (MassUnit.Kilogram, MassUnit.Stone) => new Mass(_value / 6.35029318, MassUnit.Stone),
-                (MassUnit.Kilogram, MassUnit.Tonne) => new Mass(_value / 1e3, MassUnit.Tonne),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MassUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MassUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MassUnit> IQuantity<MassUnit>.ToUnit(MassUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1381,11 +1190,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
index b58c5046af..80fa4ac505 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Mass_concentration_(chemistry)
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MassConcentration :
-        IArithmeticQuantity<MassConcentration, MassConcentrationUnit>,
+        ILinearQuantity<MassConcentration, MassConcentrationUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MassConcentration, MassConcentration, double>,
+        IDivisionOperators<MassConcentration, MassConcentration, QuantityValue>,
         IDivisionOperators<MassConcentration, VolumeConcentration, Density>,
         IMultiplyOperators<MassConcentration, Volume, Mass>,
         IDivisionOperators<MassConcentration, Molarity, MolarMass>,
@@ -60,7 +59,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -110,7 +109,7 @@ public static MassConcentrationInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="MassConcentration"/> is [L^-3][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="MassConcentration"/> is L^-3M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-3, 1, 0, 0, 0, 0, 0);
 
@@ -125,63 +124,157 @@ public static MassConcentrationInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MassConcentrationUnit}"/> representing the default unit mappings for MassConcentration.</returns>
             public static IEnumerable<UnitDefinition<MassConcentrationUnit>> GetDefaultMappings()
             {
-                yield return new (MassConcentrationUnit.CentigramPerDeciliter, "CentigramPerDeciliter", "CentigramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.CentigramPerLiter, "CentigramPerLiter", "CentigramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Centigram));
-                yield return new (MassConcentrationUnit.CentigramPerMicroliter, "CentigramPerMicroliter", "CentigramsPerMicroliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.CentigramPerMilliliter, "CentigramPerMilliliter", "CentigramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Centigram));
-                yield return new (MassConcentrationUnit.DecigramPerDeciliter, "DecigramPerDeciliter", "DecigramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.DecigramPerLiter, "DecigramPerLiter", "DecigramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Decigram));
-                yield return new (MassConcentrationUnit.DecigramPerMicroliter, "DecigramPerMicroliter", "DecigramsPerMicroliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.DecigramPerMilliliter, "DecigramPerMilliliter", "DecigramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Decigram));
-                yield return new (MassConcentrationUnit.GramPerCubicCentimeter, "GramPerCubicCentimeter", "GramsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram));
-                yield return new (MassConcentrationUnit.GramPerCubicMeter, "GramPerCubicMeter", "GramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram));
-                yield return new (MassConcentrationUnit.GramPerCubicMillimeter, "GramPerCubicMillimeter", "GramsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram));
-                yield return new (MassConcentrationUnit.GramPerDeciliter, "GramPerDeciliter", "GramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.GramPerLiter, "GramPerLiter", "GramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Gram));
-                yield return new (MassConcentrationUnit.GramPerMicroliter, "GramPerMicroliter", "GramsPerMicroliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.GramPerMilliliter, "GramPerMilliliter", "GramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram));
-                yield return new (MassConcentrationUnit.KilogramPerCubicCentimeter, "KilogramPerCubicCentimeter", "KilogramsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram));
+                yield return new (MassConcentrationUnit.CentigramPerDeciliter, "CentigramPerDeciliter", "CentigramsPerDeciliter", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (MassConcentrationUnit.CentigramPerLiter, "CentigramPerLiter", "CentigramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Centigram),
+                     100
+                );
+                yield return new (MassConcentrationUnit.CentigramPerMicroliter, "CentigramPerMicroliter", "CentigramsPerMicroliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (MassConcentrationUnit.CentigramPerMilliliter, "CentigramPerMilliliter", "CentigramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Centigram),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (MassConcentrationUnit.DecigramPerDeciliter, "DecigramPerDeciliter", "DecigramsPerDeciliter", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (MassConcentrationUnit.DecigramPerLiter, "DecigramPerLiter", "DecigramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Decigram),
+                     10
+                );
+                yield return new (MassConcentrationUnit.DecigramPerMicroliter, "DecigramPerMicroliter", "DecigramsPerMicroliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000)
+                );
+                yield return new (MassConcentrationUnit.DecigramPerMilliliter, "DecigramPerMilliliter", "DecigramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Decigram),
+                     new QuantityValue(1, 100)
+                );
+                yield return new (MassConcentrationUnit.GramPerCubicCentimeter, "GramPerCubicCentimeter", "GramsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MassConcentrationUnit.GramPerCubicMeter, "GramPerCubicMeter", "GramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram),
+                     1000
+                );
+                yield return new (MassConcentrationUnit.GramPerCubicMillimeter, "GramPerCubicMillimeter", "GramsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (MassConcentrationUnit.GramPerDeciliter, "GramPerDeciliter", "GramsPerDeciliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (MassConcentrationUnit.GramPerLiter, "GramPerLiter", "GramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Gram),
+                     1
+                );
+                yield return new (MassConcentrationUnit.GramPerMicroliter, "GramPerMicroliter", "GramsPerMicroliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (MassConcentrationUnit.GramPerMilliliter, "GramPerMilliliter", "GramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MassConcentrationUnit.KilogramPerCubicCentimeter, "KilogramPerCubicCentimeter", "KilogramsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram),
+                     new QuantityValue(1, 1000000)
+                );
                 yield return new (MassConcentrationUnit.KilogramPerCubicMeter, "KilogramPerCubicMeter", "KilogramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram));
-                yield return new (MassConcentrationUnit.KilogramPerCubicMillimeter, "KilogramPerCubicMillimeter", "KilogramsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram));
-                yield return new (MassConcentrationUnit.KilogramPerLiter, "KilogramPerLiter", "KilogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram));
-                yield return new (MassConcentrationUnit.KilopoundPerCubicFoot, "KilopoundPerCubicFoot", "KilopoundsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Kilopound));
-                yield return new (MassConcentrationUnit.KilopoundPerCubicInch, "KilopoundPerCubicInch", "KilopoundsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Kilopound));
-                yield return new (MassConcentrationUnit.MicrogramPerCubicMeter, "MicrogramPerCubicMeter", "MicrogramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram));
-                yield return new (MassConcentrationUnit.MicrogramPerDeciliter, "MicrogramPerDeciliter", "MicrogramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.MicrogramPerLiter, "MicrogramPerLiter", "MicrogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Microgram));
-                yield return new (MassConcentrationUnit.MicrogramPerMicroliter, "MicrogramPerMicroliter", "MicrogramsPerMicroliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.MicrogramPerMilliliter, "MicrogramPerMilliliter", "MicrogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Microgram));
-                yield return new (MassConcentrationUnit.MilligramPerCubicMeter, "MilligramPerCubicMeter", "MilligramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram));
-                yield return new (MassConcentrationUnit.MilligramPerDeciliter, "MilligramPerDeciliter", "MilligramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.MilligramPerLiter, "MilligramPerLiter", "MilligramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Milligram));
-                yield return new (MassConcentrationUnit.MilligramPerMicroliter, "MilligramPerMicroliter", "MilligramsPerMicroliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.MilligramPerMilliliter, "MilligramPerMilliliter", "MilligramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Milligram));
-                yield return new (MassConcentrationUnit.NanogramPerDeciliter, "NanogramPerDeciliter", "NanogramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.NanogramPerLiter, "NanogramPerLiter", "NanogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Nanogram));
-                yield return new (MassConcentrationUnit.NanogramPerMicroliter, "NanogramPerMicroliter", "NanogramsPerMicroliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.NanogramPerMilliliter, "NanogramPerMilliliter", "NanogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Nanogram));
-                yield return new (MassConcentrationUnit.OuncePerImperialGallon, "OuncePerImperialGallon", "OuncesPerImperialGallon", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.OuncePerUSGallon, "OuncePerUSGallon", "OuncesPerUSGallon", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.PicogramPerDeciliter, "PicogramPerDeciliter", "PicogramsPerDeciliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.PicogramPerLiter, "PicogramPerLiter", "PicogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Picogram));
-                yield return new (MassConcentrationUnit.PicogramPerMicroliter, "PicogramPerMicroliter", "PicogramsPerMicroliter", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.PicogramPerMilliliter, "PicogramPerMilliliter", "PicogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Picogram));
-                yield return new (MassConcentrationUnit.PoundPerCubicFoot, "PoundPerCubicFoot", "PoundsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound));
-                yield return new (MassConcentrationUnit.PoundPerCubicInch, "PoundPerCubicInch", "PoundsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound));
-                yield return new (MassConcentrationUnit.PoundPerImperialGallon, "PoundPerImperialGallon", "PoundsPerImperialGallon", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.PoundPerUSGallon, "PoundPerUSGallon", "PoundsPerUSGallon", BaseUnits.Undefined);
-                yield return new (MassConcentrationUnit.SlugPerCubicFoot, "SlugPerCubicFoot", "SlugsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Slug));
-                yield return new (MassConcentrationUnit.TonnePerCubicCentimeter, "TonnePerCubicCentimeter", "TonnesPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Tonne));
-                yield return new (MassConcentrationUnit.TonnePerCubicMeter, "TonnePerCubicMeter", "TonnesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Tonne));
-                yield return new (MassConcentrationUnit.TonnePerCubicMillimeter, "TonnePerCubicMillimeter", "TonnesPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Tonne));
+                yield return new (MassConcentrationUnit.KilogramPerCubicMillimeter, "KilogramPerCubicMillimeter", "KilogramsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (MassConcentrationUnit.KilogramPerLiter, "KilogramPerLiter", "KilogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MassConcentrationUnit.KilopoundPerCubicFoot, "KilopoundPerCubicFoot", "KilopoundsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Kilopound),
+                     new QuantityValue(221225364, 3543690390625)
+                );
+                yield return new (MassConcentrationUnit.KilopoundPerCubicInch, "KilopoundPerCubicInch", "KilopoundsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Kilopound),
+                     new QuantityValue(2048383, 56699046250000)
+                );
+                yield return new (MassConcentrationUnit.MicrogramPerCubicMeter, "MicrogramPerCubicMeter", "MicrogramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram),
+                     1000000000
+                );
+                yield return new (MassConcentrationUnit.MicrogramPerDeciliter, "MicrogramPerDeciliter", "MicrogramsPerDeciliter", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (MassConcentrationUnit.MicrogramPerLiter, "MicrogramPerLiter", "MicrogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Microgram),
+                     1000000
+                );
+                yield return new (MassConcentrationUnit.MicrogramPerMicroliter, "MicrogramPerMicroliter", "MicrogramsPerMicroliter", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (MassConcentrationUnit.MicrogramPerMilliliter, "MicrogramPerMilliliter", "MicrogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Microgram),
+                     1000
+                );
+                yield return new (MassConcentrationUnit.MilligramPerCubicMeter, "MilligramPerCubicMeter", "MilligramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram),
+                     1000000
+                );
+                yield return new (MassConcentrationUnit.MilligramPerDeciliter, "MilligramPerDeciliter", "MilligramsPerDeciliter", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (MassConcentrationUnit.MilligramPerLiter, "MilligramPerLiter", "MilligramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Milligram),
+                     1000
+                );
+                yield return new (MassConcentrationUnit.MilligramPerMicroliter, "MilligramPerMicroliter", "MilligramsPerMicroliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MassConcentrationUnit.MilligramPerMilliliter, "MilligramPerMilliliter", "MilligramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Milligram),
+                     1
+                );
+                yield return new (MassConcentrationUnit.NanogramPerDeciliter, "NanogramPerDeciliter", "NanogramsPerDeciliter", BaseUnits.Undefined,
+                     100000000
+                );
+                yield return new (MassConcentrationUnit.NanogramPerLiter, "NanogramPerLiter", "NanogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Nanogram),
+                     1000000000
+                );
+                yield return new (MassConcentrationUnit.NanogramPerMicroliter, "NanogramPerMicroliter", "NanogramsPerMicroliter", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (MassConcentrationUnit.NanogramPerMilliliter, "NanogramPerMilliliter", "NanogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Nanogram),
+                     1000000
+                );
+                yield return new (MassConcentrationUnit.OuncePerImperialGallon, "OuncePerImperialGallon", "OuncesPerImperialGallon", BaseUnits.Undefined,
+                     new QuantityValue(7273744, 45359237)
+                );
+                yield return new (MassConcentrationUnit.OuncePerUSGallon, "OuncePerUSGallon", "OuncesPerUSGallon", BaseUnits.Undefined,
+                     new QuantityValue(49161192, 368175625)
+                );
+                yield return new (MassConcentrationUnit.PicogramPerDeciliter, "PicogramPerDeciliter", "PicogramsPerDeciliter", BaseUnits.Undefined,
+                     100000000000
+                );
+                yield return new (MassConcentrationUnit.PicogramPerLiter, "PicogramPerLiter", "PicogramsPerLiter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Picogram),
+                     1000000000000
+                );
+                yield return new (MassConcentrationUnit.PicogramPerMicroliter, "PicogramPerMicroliter", "PicogramsPerMicroliter", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (MassConcentrationUnit.PicogramPerMilliliter, "PicogramPerMilliliter", "PicogramsPerMilliliter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Picogram),
+                     1000000000
+                );
+                yield return new (MassConcentrationUnit.PoundPerCubicFoot, "PoundPerCubicFoot", "PoundsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound),
+                     new QuantityValue(1769802912, 28349523125)
+                );
+                yield return new (MassConcentrationUnit.PoundPerCubicInch, "PoundPerCubicInch", "PoundsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound),
+                     new QuantityValue(2048383, 56699046250)
+                );
+                yield return new (MassConcentrationUnit.PoundPerImperialGallon, "PoundPerImperialGallon", "PoundsPerImperialGallon", BaseUnits.Undefined,
+                     new QuantityValue(454609, 45359237)
+                );
+                yield return new (MassConcentrationUnit.PoundPerUSGallon, "PoundPerUSGallon", "PoundsPerUSGallon", BaseUnits.Undefined,
+                     new QuantityValue(6145149, 736351250)
+                );
+                yield return new (MassConcentrationUnit.SlugPerCubicFoot, "SlugPerCubicFoot", "SlugsPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Slug),
+                     new QuantityValue(10788718551552, 5560277019075625)
+                );
+                yield return new (MassConcentrationUnit.TonnePerCubicCentimeter, "TonnePerCubicCentimeter", "TonnesPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Tonne),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (MassConcentrationUnit.TonnePerCubicMeter, "TonnePerCubicMeter", "TonnesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Tonne),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MassConcentrationUnit.TonnePerCubicMillimeter, "TonnePerCubicMillimeter", "TonnesPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Tonne),
+                     new QuantityValue(1, 1000000000000)
+                );
             }
         }
 
         static MassConcentration()
         {
-            Info = MassConcentrationInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MassConcentrationInfo.CreateDefault);
         }
 
         /// <summary>
@@ -189,7 +282,7 @@ static MassConcentration()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MassConcentration(double value, MassConcentrationUnit unit)
+        public MassConcentration(QuantityValue value, MassConcentrationUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -203,7 +296,7 @@ public MassConcentration(double value, MassConcentrationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MassConcentration(double value, UnitSystem unitSystem)
+        public MassConcentration(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -214,7 +307,8 @@ public MassConcentration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MassConcentration" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MassConcentration, MassConcentrationUnit> Info { get; }
@@ -243,10 +337,8 @@ public MassConcentration(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MassConcentrationUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -280,364 +372,254 @@ public MassConcentration(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerDeciliter"/>
         /// </summary>
-        public double CentigramsPerDeciliter => As(MassConcentrationUnit.CentigramPerDeciliter);
+        public QuantityValue CentigramsPerDeciliter => this.As(MassConcentrationUnit.CentigramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerLiter"/>
         /// </summary>
-        public double CentigramsPerLiter => As(MassConcentrationUnit.CentigramPerLiter);
+        public QuantityValue CentigramsPerLiter => this.As(MassConcentrationUnit.CentigramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerMicroliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerMicroliter"/>
         /// </summary>
-        public double CentigramsPerMicroliter => As(MassConcentrationUnit.CentigramPerMicroliter);
+        public QuantityValue CentigramsPerMicroliter => this.As(MassConcentrationUnit.CentigramPerMicroliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.CentigramPerMilliliter"/>
         /// </summary>
-        public double CentigramsPerMilliliter => As(MassConcentrationUnit.CentigramPerMilliliter);
+        public QuantityValue CentigramsPerMilliliter => this.As(MassConcentrationUnit.CentigramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerDeciliter"/>
         /// </summary>
-        public double DecigramsPerDeciliter => As(MassConcentrationUnit.DecigramPerDeciliter);
+        public QuantityValue DecigramsPerDeciliter => this.As(MassConcentrationUnit.DecigramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerLiter"/>
         /// </summary>
-        public double DecigramsPerLiter => As(MassConcentrationUnit.DecigramPerLiter);
+        public QuantityValue DecigramsPerLiter => this.As(MassConcentrationUnit.DecigramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerMicroliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerMicroliter"/>
         /// </summary>
-        public double DecigramsPerMicroliter => As(MassConcentrationUnit.DecigramPerMicroliter);
+        public QuantityValue DecigramsPerMicroliter => this.As(MassConcentrationUnit.DecigramPerMicroliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.DecigramPerMilliliter"/>
         /// </summary>
-        public double DecigramsPerMilliliter => As(MassConcentrationUnit.DecigramPerMilliliter);
+        public QuantityValue DecigramsPerMilliliter => this.As(MassConcentrationUnit.DecigramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerCubicCentimeter"/>
         /// </summary>
-        public double GramsPerCubicCentimeter => As(MassConcentrationUnit.GramPerCubicCentimeter);
+        public QuantityValue GramsPerCubicCentimeter => this.As(MassConcentrationUnit.GramPerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerCubicMeter"/>
         /// </summary>
-        public double GramsPerCubicMeter => As(MassConcentrationUnit.GramPerCubicMeter);
+        public QuantityValue GramsPerCubicMeter => this.As(MassConcentrationUnit.GramPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerCubicMillimeter"/>
         /// </summary>
-        public double GramsPerCubicMillimeter => As(MassConcentrationUnit.GramPerCubicMillimeter);
+        public QuantityValue GramsPerCubicMillimeter => this.As(MassConcentrationUnit.GramPerCubicMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerDeciliter"/>
         /// </summary>
-        public double GramsPerDeciliter => As(MassConcentrationUnit.GramPerDeciliter);
+        public QuantityValue GramsPerDeciliter => this.As(MassConcentrationUnit.GramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerLiter"/>
         /// </summary>
-        public double GramsPerLiter => As(MassConcentrationUnit.GramPerLiter);
+        public QuantityValue GramsPerLiter => this.As(MassConcentrationUnit.GramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerMicroliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerMicroliter"/>
         /// </summary>
-        public double GramsPerMicroliter => As(MassConcentrationUnit.GramPerMicroliter);
+        public QuantityValue GramsPerMicroliter => this.As(MassConcentrationUnit.GramPerMicroliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.GramPerMilliliter"/>
         /// </summary>
-        public double GramsPerMilliliter => As(MassConcentrationUnit.GramPerMilliliter);
+        public QuantityValue GramsPerMilliliter => this.As(MassConcentrationUnit.GramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerCubicCentimeter"/>
         /// </summary>
-        public double KilogramsPerCubicCentimeter => As(MassConcentrationUnit.KilogramPerCubicCentimeter);
+        public QuantityValue KilogramsPerCubicCentimeter => this.As(MassConcentrationUnit.KilogramPerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerCubicMeter"/>
         /// </summary>
-        public double KilogramsPerCubicMeter => As(MassConcentrationUnit.KilogramPerCubicMeter);
+        public QuantityValue KilogramsPerCubicMeter => this.As(MassConcentrationUnit.KilogramPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerCubicMillimeter"/>
         /// </summary>
-        public double KilogramsPerCubicMillimeter => As(MassConcentrationUnit.KilogramPerCubicMillimeter);
+        public QuantityValue KilogramsPerCubicMillimeter => this.As(MassConcentrationUnit.KilogramPerCubicMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilogramPerLiter"/>
         /// </summary>
-        public double KilogramsPerLiter => As(MassConcentrationUnit.KilogramPerLiter);
+        public QuantityValue KilogramsPerLiter => this.As(MassConcentrationUnit.KilogramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilopoundPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilopoundPerCubicFoot"/>
         /// </summary>
-        public double KilopoundsPerCubicFoot => As(MassConcentrationUnit.KilopoundPerCubicFoot);
+        public QuantityValue KilopoundsPerCubicFoot => this.As(MassConcentrationUnit.KilopoundPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilopoundPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.KilopoundPerCubicInch"/>
         /// </summary>
-        public double KilopoundsPerCubicInch => As(MassConcentrationUnit.KilopoundPerCubicInch);
+        public QuantityValue KilopoundsPerCubicInch => this.As(MassConcentrationUnit.KilopoundPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerCubicMeter"/>
         /// </summary>
-        public double MicrogramsPerCubicMeter => As(MassConcentrationUnit.MicrogramPerCubicMeter);
+        public QuantityValue MicrogramsPerCubicMeter => this.As(MassConcentrationUnit.MicrogramPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerDeciliter"/>
         /// </summary>
-        public double MicrogramsPerDeciliter => As(MassConcentrationUnit.MicrogramPerDeciliter);
+        public QuantityValue MicrogramsPerDeciliter => this.As(MassConcentrationUnit.MicrogramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerLiter"/>
         /// </summary>
-        public double MicrogramsPerLiter => As(MassConcentrationUnit.MicrogramPerLiter);
+        public QuantityValue MicrogramsPerLiter => this.As(MassConcentrationUnit.MicrogramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerMicroliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerMicroliter"/>
         /// </summary>
-        public double MicrogramsPerMicroliter => As(MassConcentrationUnit.MicrogramPerMicroliter);
+        public QuantityValue MicrogramsPerMicroliter => this.As(MassConcentrationUnit.MicrogramPerMicroliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.MicrogramPerMilliliter"/>
         /// </summary>
-        public double MicrogramsPerMilliliter => As(MassConcentrationUnit.MicrogramPerMilliliter);
+        public QuantityValue MicrogramsPerMilliliter => this.As(MassConcentrationUnit.MicrogramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerCubicMeter"/>
         /// </summary>
-        public double MilligramsPerCubicMeter => As(MassConcentrationUnit.MilligramPerCubicMeter);
+        public QuantityValue MilligramsPerCubicMeter => this.As(MassConcentrationUnit.MilligramPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerDeciliter"/>
         /// </summary>
-        public double MilligramsPerDeciliter => As(MassConcentrationUnit.MilligramPerDeciliter);
+        public QuantityValue MilligramsPerDeciliter => this.As(MassConcentrationUnit.MilligramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerLiter"/>
         /// </summary>
-        public double MilligramsPerLiter => As(MassConcentrationUnit.MilligramPerLiter);
+        public QuantityValue MilligramsPerLiter => this.As(MassConcentrationUnit.MilligramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerMicroliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerMicroliter"/>
         /// </summary>
-        public double MilligramsPerMicroliter => As(MassConcentrationUnit.MilligramPerMicroliter);
+        public QuantityValue MilligramsPerMicroliter => this.As(MassConcentrationUnit.MilligramPerMicroliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.MilligramPerMilliliter"/>
         /// </summary>
-        public double MilligramsPerMilliliter => As(MassConcentrationUnit.MilligramPerMilliliter);
+        public QuantityValue MilligramsPerMilliliter => this.As(MassConcentrationUnit.MilligramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerDeciliter"/>
         /// </summary>
-        public double NanogramsPerDeciliter => As(MassConcentrationUnit.NanogramPerDeciliter);
+        public QuantityValue NanogramsPerDeciliter => this.As(MassConcentrationUnit.NanogramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerLiter"/>
         /// </summary>
-        public double NanogramsPerLiter => As(MassConcentrationUnit.NanogramPerLiter);
+        public QuantityValue NanogramsPerLiter => this.As(MassConcentrationUnit.NanogramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerMicroliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerMicroliter"/>
         /// </summary>
-        public double NanogramsPerMicroliter => As(MassConcentrationUnit.NanogramPerMicroliter);
+        public QuantityValue NanogramsPerMicroliter => this.As(MassConcentrationUnit.NanogramPerMicroliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.NanogramPerMilliliter"/>
         /// </summary>
-        public double NanogramsPerMilliliter => As(MassConcentrationUnit.NanogramPerMilliliter);
+        public QuantityValue NanogramsPerMilliliter => this.As(MassConcentrationUnit.NanogramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.OuncePerImperialGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.OuncePerImperialGallon"/>
         /// </summary>
-        public double OuncesPerImperialGallon => As(MassConcentrationUnit.OuncePerImperialGallon);
+        public QuantityValue OuncesPerImperialGallon => this.As(MassConcentrationUnit.OuncePerImperialGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.OuncePerUSGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.OuncePerUSGallon"/>
         /// </summary>
-        public double OuncesPerUSGallon => As(MassConcentrationUnit.OuncePerUSGallon);
+        public QuantityValue OuncesPerUSGallon => this.As(MassConcentrationUnit.OuncePerUSGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerDeciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerDeciliter"/>
         /// </summary>
-        public double PicogramsPerDeciliter => As(MassConcentrationUnit.PicogramPerDeciliter);
+        public QuantityValue PicogramsPerDeciliter => this.As(MassConcentrationUnit.PicogramPerDeciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerLiter"/>
         /// </summary>
-        public double PicogramsPerLiter => As(MassConcentrationUnit.PicogramPerLiter);
+        public QuantityValue PicogramsPerLiter => this.As(MassConcentrationUnit.PicogramPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerMicroliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerMicroliter"/>
         /// </summary>
-        public double PicogramsPerMicroliter => As(MassConcentrationUnit.PicogramPerMicroliter);
+        public QuantityValue PicogramsPerMicroliter => this.As(MassConcentrationUnit.PicogramPerMicroliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.PicogramPerMilliliter"/>
         /// </summary>
-        public double PicogramsPerMilliliter => As(MassConcentrationUnit.PicogramPerMilliliter);
+        public QuantityValue PicogramsPerMilliliter => this.As(MassConcentrationUnit.PicogramPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerCubicFoot"/>
         /// </summary>
-        public double PoundsPerCubicFoot => As(MassConcentrationUnit.PoundPerCubicFoot);
+        public QuantityValue PoundsPerCubicFoot => this.As(MassConcentrationUnit.PoundPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerCubicInch"/>
         /// </summary>
-        public double PoundsPerCubicInch => As(MassConcentrationUnit.PoundPerCubicInch);
+        public QuantityValue PoundsPerCubicInch => this.As(MassConcentrationUnit.PoundPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerImperialGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerImperialGallon"/>
         /// </summary>
-        public double PoundsPerImperialGallon => As(MassConcentrationUnit.PoundPerImperialGallon);
+        public QuantityValue PoundsPerImperialGallon => this.As(MassConcentrationUnit.PoundPerImperialGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerUSGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.PoundPerUSGallon"/>
         /// </summary>
-        public double PoundsPerUSGallon => As(MassConcentrationUnit.PoundPerUSGallon);
+        public QuantityValue PoundsPerUSGallon => this.As(MassConcentrationUnit.PoundPerUSGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.SlugPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.SlugPerCubicFoot"/>
         /// </summary>
-        public double SlugsPerCubicFoot => As(MassConcentrationUnit.SlugPerCubicFoot);
+        public QuantityValue SlugsPerCubicFoot => this.As(MassConcentrationUnit.SlugPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.TonnePerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.TonnePerCubicCentimeter"/>
         /// </summary>
-        public double TonnesPerCubicCentimeter => As(MassConcentrationUnit.TonnePerCubicCentimeter);
+        public QuantityValue TonnesPerCubicCentimeter => this.As(MassConcentrationUnit.TonnePerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.TonnePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.TonnePerCubicMeter"/>
         /// </summary>
-        public double TonnesPerCubicMeter => As(MassConcentrationUnit.TonnePerCubicMeter);
+        public QuantityValue TonnesPerCubicMeter => this.As(MassConcentrationUnit.TonnePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassConcentrationUnit.TonnePerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassConcentrationUnit.TonnePerCubicMillimeter"/>
         /// </summary>
-        public double TonnesPerCubicMillimeter => As(MassConcentrationUnit.TonnePerCubicMillimeter);
+        public QuantityValue TonnesPerCubicMillimeter => this.As(MassConcentrationUnit.TonnePerCubicMillimeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MassConcentrationUnit -> BaseUnit
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.CentigramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.CentigramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.CentigramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.CentigramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.DecigramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.DecigramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.DecigramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.DecigramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerCubicCentimeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerCubicMillimeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.GramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicCentimeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMillimeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilopoundPerCubicFoot, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilopoundPerCubicInch, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MicrogramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MicrogramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MicrogramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MicrogramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MicrogramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MilligramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MilligramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MilligramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MilligramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.MilligramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.NanogramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.NanogramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.NanogramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.NanogramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.OuncePerImperialGallon, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.OuncePerUSGallon, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PicogramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PicogramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PicogramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PicogramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PoundPerCubicFoot, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PoundPerCubicInch, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PoundPerImperialGallon, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PoundPerUSGallon, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.SlugPerCubicFoot, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.TonnePerCubicCentimeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.TonnePerCubicMeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.TonnePerCubicMillimeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MassConcentrationUnit
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.CentigramPerDeciliter, quantity => quantity.ToUnit(MassConcentrationUnit.CentigramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.CentigramPerLiter, quantity => quantity.ToUnit(MassConcentrationUnit.CentigramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.CentigramPerMicroliter, quantity => quantity.ToUnit(MassConcentrationUnit.CentigramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.CentigramPerMilliliter, quantity => quantity.ToUnit(MassConcentrationUnit.CentigramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.DecigramPerDeciliter, quantity => quantity.ToUnit(MassConcentrationUnit.DecigramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.DecigramPerLiter, quantity => quantity.ToUnit(MassConcentrationUnit.DecigramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.DecigramPerMicroliter, quantity => quantity.ToUnit(MassConcentrationUnit.DecigramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.DecigramPerMilliliter, quantity => quantity.ToUnit(MassConcentrationUnit.DecigramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerCubicCentimeter, quantity => quantity.ToUnit(MassConcentrationUnit.GramPerCubicCentimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.GramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerCubicMillimeter, quantity => quantity.ToUnit(MassConcentrationUnit.GramPerCubicMillimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerDeciliter, quantity => quantity.ToUnit(MassConcentrationUnit.GramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerLiter, quantity => quantity.ToUnit(MassConcentrationUnit.GramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerMicroliter, quantity => quantity.ToUnit(MassConcentrationUnit.GramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerMilliliter, quantity => quantity.ToUnit(MassConcentrationUnit.GramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicCentimeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicCentimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicMillimeter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerCubicMillimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilogramPerLiter, quantity => quantity.ToUnit(MassConcentrationUnit.KilogramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilopoundPerCubicFoot, quantity => quantity.ToUnit(MassConcentrationUnit.KilopoundPerCubicFoot));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilopoundPerCubicInch, quantity => quantity.ToUnit(MassConcentrationUnit.KilopoundPerCubicInch));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MicrogramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.MicrogramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MicrogramPerDeciliter, quantity => quantity.ToUnit(MassConcentrationUnit.MicrogramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MicrogramPerLiter, quantity => quantity.ToUnit(MassConcentrationUnit.MicrogramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MicrogramPerMicroliter, quantity => quantity.ToUnit(MassConcentrationUnit.MicrogramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MicrogramPerMilliliter, quantity => quantity.ToUnit(MassConcentrationUnit.MicrogramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MilligramPerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.MilligramPerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MilligramPerDeciliter, quantity => quantity.ToUnit(MassConcentrationUnit.MilligramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MilligramPerLiter, quantity => quantity.ToUnit(MassConcentrationUnit.MilligramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MilligramPerMicroliter, quantity => quantity.ToUnit(MassConcentrationUnit.MilligramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MilligramPerMilliliter, quantity => quantity.ToUnit(MassConcentrationUnit.MilligramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.NanogramPerDeciliter, quantity => quantity.ToUnit(MassConcentrationUnit.NanogramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.NanogramPerLiter, quantity => quantity.ToUnit(MassConcentrationUnit.NanogramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.NanogramPerMicroliter, quantity => quantity.ToUnit(MassConcentrationUnit.NanogramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.NanogramPerMilliliter, quantity => quantity.ToUnit(MassConcentrationUnit.NanogramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.OuncePerImperialGallon, quantity => quantity.ToUnit(MassConcentrationUnit.OuncePerImperialGallon));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.OuncePerUSGallon, quantity => quantity.ToUnit(MassConcentrationUnit.OuncePerUSGallon));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PicogramPerDeciliter, quantity => quantity.ToUnit(MassConcentrationUnit.PicogramPerDeciliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PicogramPerLiter, quantity => quantity.ToUnit(MassConcentrationUnit.PicogramPerLiter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PicogramPerMicroliter, quantity => quantity.ToUnit(MassConcentrationUnit.PicogramPerMicroliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PicogramPerMilliliter, quantity => quantity.ToUnit(MassConcentrationUnit.PicogramPerMilliliter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PoundPerCubicFoot, quantity => quantity.ToUnit(MassConcentrationUnit.PoundPerCubicFoot));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PoundPerCubicInch, quantity => quantity.ToUnit(MassConcentrationUnit.PoundPerCubicInch));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PoundPerImperialGallon, quantity => quantity.ToUnit(MassConcentrationUnit.PoundPerImperialGallon));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PoundPerUSGallon, quantity => quantity.ToUnit(MassConcentrationUnit.PoundPerUSGallon));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.SlugPerCubicFoot, quantity => quantity.ToUnit(MassConcentrationUnit.SlugPerCubicFoot));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.TonnePerCubicCentimeter, quantity => quantity.ToUnit(MassConcentrationUnit.TonnePerCubicCentimeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.TonnePerCubicMeter, quantity => quantity.ToUnit(MassConcentrationUnit.TonnePerCubicMeter));
-            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.TonnePerCubicMillimeter, quantity => quantity.ToUnit(MassConcentrationUnit.TonnePerCubicMillimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -666,7 +648,7 @@ public static string GetAbbreviation(MassConcentrationUnit unit, IFormatProvider
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerDeciliter"/>.
         /// </summary>
-        public static MassConcentration FromCentigramsPerDeciliter(double value)
+        public static MassConcentration FromCentigramsPerDeciliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.CentigramPerDeciliter);
         }
@@ -674,7 +656,7 @@ public static MassConcentration FromCentigramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerLiter"/>.
         /// </summary>
-        public static MassConcentration FromCentigramsPerLiter(double value)
+        public static MassConcentration FromCentigramsPerLiter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.CentigramPerLiter);
         }
@@ -682,7 +664,7 @@ public static MassConcentration FromCentigramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerMicroliter"/>.
         /// </summary>
-        public static MassConcentration FromCentigramsPerMicroliter(double value)
+        public static MassConcentration FromCentigramsPerMicroliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.CentigramPerMicroliter);
         }
@@ -690,7 +672,7 @@ public static MassConcentration FromCentigramsPerMicroliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerMilliliter"/>.
         /// </summary>
-        public static MassConcentration FromCentigramsPerMilliliter(double value)
+        public static MassConcentration FromCentigramsPerMilliliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.CentigramPerMilliliter);
         }
@@ -698,7 +680,7 @@ public static MassConcentration FromCentigramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerDeciliter"/>.
         /// </summary>
-        public static MassConcentration FromDecigramsPerDeciliter(double value)
+        public static MassConcentration FromDecigramsPerDeciliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.DecigramPerDeciliter);
         }
@@ -706,7 +688,7 @@ public static MassConcentration FromDecigramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerLiter"/>.
         /// </summary>
-        public static MassConcentration FromDecigramsPerLiter(double value)
+        public static MassConcentration FromDecigramsPerLiter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.DecigramPerLiter);
         }
@@ -714,7 +696,7 @@ public static MassConcentration FromDecigramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerMicroliter"/>.
         /// </summary>
-        public static MassConcentration FromDecigramsPerMicroliter(double value)
+        public static MassConcentration FromDecigramsPerMicroliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.DecigramPerMicroliter);
         }
@@ -722,7 +704,7 @@ public static MassConcentration FromDecigramsPerMicroliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerMilliliter"/>.
         /// </summary>
-        public static MassConcentration FromDecigramsPerMilliliter(double value)
+        public static MassConcentration FromDecigramsPerMilliliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.DecigramPerMilliliter);
         }
@@ -730,7 +712,7 @@ public static MassConcentration FromDecigramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicCentimeter"/>.
         /// </summary>
-        public static MassConcentration FromGramsPerCubicCentimeter(double value)
+        public static MassConcentration FromGramsPerCubicCentimeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.GramPerCubicCentimeter);
         }
@@ -738,7 +720,7 @@ public static MassConcentration FromGramsPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicMeter"/>.
         /// </summary>
-        public static MassConcentration FromGramsPerCubicMeter(double value)
+        public static MassConcentration FromGramsPerCubicMeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMeter);
         }
@@ -746,7 +728,7 @@ public static MassConcentration FromGramsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicMillimeter"/>.
         /// </summary>
-        public static MassConcentration FromGramsPerCubicMillimeter(double value)
+        public static MassConcentration FromGramsPerCubicMillimeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMillimeter);
         }
@@ -754,7 +736,7 @@ public static MassConcentration FromGramsPerCubicMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerDeciliter"/>.
         /// </summary>
-        public static MassConcentration FromGramsPerDeciliter(double value)
+        public static MassConcentration FromGramsPerDeciliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.GramPerDeciliter);
         }
@@ -762,7 +744,7 @@ public static MassConcentration FromGramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerLiter"/>.
         /// </summary>
-        public static MassConcentration FromGramsPerLiter(double value)
+        public static MassConcentration FromGramsPerLiter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.GramPerLiter);
         }
@@ -770,7 +752,7 @@ public static MassConcentration FromGramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerMicroliter"/>.
         /// </summary>
-        public static MassConcentration FromGramsPerMicroliter(double value)
+        public static MassConcentration FromGramsPerMicroliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.GramPerMicroliter);
         }
@@ -778,7 +760,7 @@ public static MassConcentration FromGramsPerMicroliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerMilliliter"/>.
         /// </summary>
-        public static MassConcentration FromGramsPerMilliliter(double value)
+        public static MassConcentration FromGramsPerMilliliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.GramPerMilliliter);
         }
@@ -786,7 +768,7 @@ public static MassConcentration FromGramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicCentimeter"/>.
         /// </summary>
-        public static MassConcentration FromKilogramsPerCubicCentimeter(double value)
+        public static MassConcentration FromKilogramsPerCubicCentimeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicCentimeter);
         }
@@ -794,7 +776,7 @@ public static MassConcentration FromKilogramsPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicMeter"/>.
         /// </summary>
-        public static MassConcentration FromKilogramsPerCubicMeter(double value)
+        public static MassConcentration FromKilogramsPerCubicMeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMeter);
         }
@@ -802,7 +784,7 @@ public static MassConcentration FromKilogramsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicMillimeter"/>.
         /// </summary>
-        public static MassConcentration FromKilogramsPerCubicMillimeter(double value)
+        public static MassConcentration FromKilogramsPerCubicMillimeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMillimeter);
         }
@@ -810,7 +792,7 @@ public static MassConcentration FromKilogramsPerCubicMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerLiter"/>.
         /// </summary>
-        public static MassConcentration FromKilogramsPerLiter(double value)
+        public static MassConcentration FromKilogramsPerLiter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.KilogramPerLiter);
         }
@@ -818,7 +800,7 @@ public static MassConcentration FromKilogramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilopoundPerCubicFoot"/>.
         /// </summary>
-        public static MassConcentration FromKilopoundsPerCubicFoot(double value)
+        public static MassConcentration FromKilopoundsPerCubicFoot(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicFoot);
         }
@@ -826,7 +808,7 @@ public static MassConcentration FromKilopoundsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilopoundPerCubicInch"/>.
         /// </summary>
-        public static MassConcentration FromKilopoundsPerCubicInch(double value)
+        public static MassConcentration FromKilopoundsPerCubicInch(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicInch);
         }
@@ -834,7 +816,7 @@ public static MassConcentration FromKilopoundsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerCubicMeter"/>.
         /// </summary>
-        public static MassConcentration FromMicrogramsPerCubicMeter(double value)
+        public static MassConcentration FromMicrogramsPerCubicMeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.MicrogramPerCubicMeter);
         }
@@ -842,7 +824,7 @@ public static MassConcentration FromMicrogramsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerDeciliter"/>.
         /// </summary>
-        public static MassConcentration FromMicrogramsPerDeciliter(double value)
+        public static MassConcentration FromMicrogramsPerDeciliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.MicrogramPerDeciliter);
         }
@@ -850,7 +832,7 @@ public static MassConcentration FromMicrogramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerLiter"/>.
         /// </summary>
-        public static MassConcentration FromMicrogramsPerLiter(double value)
+        public static MassConcentration FromMicrogramsPerLiter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.MicrogramPerLiter);
         }
@@ -858,7 +840,7 @@ public static MassConcentration FromMicrogramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerMicroliter"/>.
         /// </summary>
-        public static MassConcentration FromMicrogramsPerMicroliter(double value)
+        public static MassConcentration FromMicrogramsPerMicroliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMicroliter);
         }
@@ -866,7 +848,7 @@ public static MassConcentration FromMicrogramsPerMicroliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerMilliliter"/>.
         /// </summary>
-        public static MassConcentration FromMicrogramsPerMilliliter(double value)
+        public static MassConcentration FromMicrogramsPerMilliliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMilliliter);
         }
@@ -874,7 +856,7 @@ public static MassConcentration FromMicrogramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerCubicMeter"/>.
         /// </summary>
-        public static MassConcentration FromMilligramsPerCubicMeter(double value)
+        public static MassConcentration FromMilligramsPerCubicMeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.MilligramPerCubicMeter);
         }
@@ -882,7 +864,7 @@ public static MassConcentration FromMilligramsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerDeciliter"/>.
         /// </summary>
-        public static MassConcentration FromMilligramsPerDeciliter(double value)
+        public static MassConcentration FromMilligramsPerDeciliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.MilligramPerDeciliter);
         }
@@ -890,7 +872,7 @@ public static MassConcentration FromMilligramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerLiter"/>.
         /// </summary>
-        public static MassConcentration FromMilligramsPerLiter(double value)
+        public static MassConcentration FromMilligramsPerLiter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.MilligramPerLiter);
         }
@@ -898,7 +880,7 @@ public static MassConcentration FromMilligramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerMicroliter"/>.
         /// </summary>
-        public static MassConcentration FromMilligramsPerMicroliter(double value)
+        public static MassConcentration FromMilligramsPerMicroliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.MilligramPerMicroliter);
         }
@@ -906,7 +888,7 @@ public static MassConcentration FromMilligramsPerMicroliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerMilliliter"/>.
         /// </summary>
-        public static MassConcentration FromMilligramsPerMilliliter(double value)
+        public static MassConcentration FromMilligramsPerMilliliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.MilligramPerMilliliter);
         }
@@ -914,7 +896,7 @@ public static MassConcentration FromMilligramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerDeciliter"/>.
         /// </summary>
-        public static MassConcentration FromNanogramsPerDeciliter(double value)
+        public static MassConcentration FromNanogramsPerDeciliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.NanogramPerDeciliter);
         }
@@ -922,7 +904,7 @@ public static MassConcentration FromNanogramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerLiter"/>.
         /// </summary>
-        public static MassConcentration FromNanogramsPerLiter(double value)
+        public static MassConcentration FromNanogramsPerLiter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.NanogramPerLiter);
         }
@@ -930,7 +912,7 @@ public static MassConcentration FromNanogramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerMicroliter"/>.
         /// </summary>
-        public static MassConcentration FromNanogramsPerMicroliter(double value)
+        public static MassConcentration FromNanogramsPerMicroliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.NanogramPerMicroliter);
         }
@@ -938,7 +920,7 @@ public static MassConcentration FromNanogramsPerMicroliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerMilliliter"/>.
         /// </summary>
-        public static MassConcentration FromNanogramsPerMilliliter(double value)
+        public static MassConcentration FromNanogramsPerMilliliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.NanogramPerMilliliter);
         }
@@ -946,7 +928,7 @@ public static MassConcentration FromNanogramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.OuncePerImperialGallon"/>.
         /// </summary>
-        public static MassConcentration FromOuncesPerImperialGallon(double value)
+        public static MassConcentration FromOuncesPerImperialGallon(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.OuncePerImperialGallon);
         }
@@ -954,7 +936,7 @@ public static MassConcentration FromOuncesPerImperialGallon(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.OuncePerUSGallon"/>.
         /// </summary>
-        public static MassConcentration FromOuncesPerUSGallon(double value)
+        public static MassConcentration FromOuncesPerUSGallon(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.OuncePerUSGallon);
         }
@@ -962,7 +944,7 @@ public static MassConcentration FromOuncesPerUSGallon(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerDeciliter"/>.
         /// </summary>
-        public static MassConcentration FromPicogramsPerDeciliter(double value)
+        public static MassConcentration FromPicogramsPerDeciliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.PicogramPerDeciliter);
         }
@@ -970,7 +952,7 @@ public static MassConcentration FromPicogramsPerDeciliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerLiter"/>.
         /// </summary>
-        public static MassConcentration FromPicogramsPerLiter(double value)
+        public static MassConcentration FromPicogramsPerLiter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.PicogramPerLiter);
         }
@@ -978,7 +960,7 @@ public static MassConcentration FromPicogramsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerMicroliter"/>.
         /// </summary>
-        public static MassConcentration FromPicogramsPerMicroliter(double value)
+        public static MassConcentration FromPicogramsPerMicroliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.PicogramPerMicroliter);
         }
@@ -986,7 +968,7 @@ public static MassConcentration FromPicogramsPerMicroliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerMilliliter"/>.
         /// </summary>
-        public static MassConcentration FromPicogramsPerMilliliter(double value)
+        public static MassConcentration FromPicogramsPerMilliliter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.PicogramPerMilliliter);
         }
@@ -994,7 +976,7 @@ public static MassConcentration FromPicogramsPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerCubicFoot"/>.
         /// </summary>
-        public static MassConcentration FromPoundsPerCubicFoot(double value)
+        public static MassConcentration FromPoundsPerCubicFoot(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicFoot);
         }
@@ -1002,7 +984,7 @@ public static MassConcentration FromPoundsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerCubicInch"/>.
         /// </summary>
-        public static MassConcentration FromPoundsPerCubicInch(double value)
+        public static MassConcentration FromPoundsPerCubicInch(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicInch);
         }
@@ -1010,7 +992,7 @@ public static MassConcentration FromPoundsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerImperialGallon"/>.
         /// </summary>
-        public static MassConcentration FromPoundsPerImperialGallon(double value)
+        public static MassConcentration FromPoundsPerImperialGallon(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.PoundPerImperialGallon);
         }
@@ -1018,7 +1000,7 @@ public static MassConcentration FromPoundsPerImperialGallon(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerUSGallon"/>.
         /// </summary>
-        public static MassConcentration FromPoundsPerUSGallon(double value)
+        public static MassConcentration FromPoundsPerUSGallon(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.PoundPerUSGallon);
         }
@@ -1026,7 +1008,7 @@ public static MassConcentration FromPoundsPerUSGallon(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.SlugPerCubicFoot"/>.
         /// </summary>
-        public static MassConcentration FromSlugsPerCubicFoot(double value)
+        public static MassConcentration FromSlugsPerCubicFoot(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.SlugPerCubicFoot);
         }
@@ -1034,7 +1016,7 @@ public static MassConcentration FromSlugsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicCentimeter"/>.
         /// </summary>
-        public static MassConcentration FromTonnesPerCubicCentimeter(double value)
+        public static MassConcentration FromTonnesPerCubicCentimeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicCentimeter);
         }
@@ -1042,7 +1024,7 @@ public static MassConcentration FromTonnesPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicMeter"/>.
         /// </summary>
-        public static MassConcentration FromTonnesPerCubicMeter(double value)
+        public static MassConcentration FromTonnesPerCubicMeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMeter);
         }
@@ -1050,7 +1032,7 @@ public static MassConcentration FromTonnesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicMillimeter"/>.
         /// </summary>
-        public static MassConcentration FromTonnesPerCubicMillimeter(double value)
+        public static MassConcentration FromTonnesPerCubicMillimeter(QuantityValue value)
         {
             return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMillimeter);
         }
@@ -1061,7 +1043,7 @@ public static MassConcentration FromTonnesPerCubicMillimeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MassConcentration unit value.</returns>
-        public static MassConcentration From(double value, MassConcentrationUnit fromUnit)
+        public static MassConcentration From(QuantityValue value, MassConcentrationUnit fromUnit)
         {
             return new MassConcentration(value, fromUnit);
         }
@@ -1122,10 +1104,7 @@ public static MassConcentration Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MassConcentration Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MassConcentration, MassConcentrationUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MassConcentration, MassConcentrationUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -1153,11 +1132,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MassConcentratio
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassConcentration result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MassConcentration, MassConcentrationUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MassConcentration, MassConcentrationUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -1178,7 +1153,7 @@ public static MassConcentrationUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1189,7 +1164,7 @@ public static MassConcentrationUnit ParseUnit(string str, IFormatProvider? provi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassConcentrationUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MassConcentrationUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassConcentrationUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1204,7 +1179,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassConcentr
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassConcentrationUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1223,35 +1198,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MassConcentration"/> from adding two <see cref="MassConcentration"/>.</summary>
         public static MassConcentration operator +(MassConcentration left, MassConcentration right)
         {
-            return new MassConcentration(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MassConcentration(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MassConcentration"/> from subtracting two <see cref="MassConcentration"/>.</summary>
         public static MassConcentration operator -(MassConcentration left, MassConcentration right)
         {
-            return new MassConcentration(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MassConcentration(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MassConcentration"/> from multiplying value and <see cref="MassConcentration"/>.</summary>
-        public static MassConcentration operator *(double left, MassConcentration right)
+        public static MassConcentration operator *(QuantityValue left, MassConcentration right)
         {
             return new MassConcentration(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MassConcentration"/> from multiplying value and <see cref="MassConcentration"/>.</summary>
-        public static MassConcentration operator *(MassConcentration left, double right)
+        public static MassConcentration operator *(MassConcentration left, QuantityValue right)
         {
             return new MassConcentration(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MassConcentration"/> from dividing <see cref="MassConcentration"/> by value.</summary>
-        public static MassConcentration operator /(MassConcentration left, double right)
+        public static MassConcentration operator /(MassConcentration left, QuantityValue right)
         {
             return new MassConcentration(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MassConcentration"/> by <see cref="MassConcentration"/>.</summary>
-        public static double operator /(MassConcentration left, MassConcentration right)
+        public static QuantityValue operator /(MassConcentration left, MassConcentration right)
         {
             return left.KilogramsPerCubicMeter / right.KilogramsPerCubicMeter;
         }
@@ -1297,97 +1272,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MassConcentration left, MassConcentration right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MassConcentration left, MassConcentration right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MassConcentration left, MassConcentration right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MassConcentration left, MassConcentration right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MassConcentration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MassConcentration other, MassConcentration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MassConcentration"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MassConcentration)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MassConcentration left, MassConcentration right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MassConcentration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MassConcentration other, MassConcentration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MassConcentration"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MassConcentration,MassConcentration)"/>.
+        ///     See that operator (and <see cref="Equals(MassConcentration)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MassConcentration left, MassConcentration right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MassConcentration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MassConcentration other, MassConcentration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MassConcentration"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MassConcentration"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MassConcentration"/>, this method delegates to
+        ///     <see cref="Equals(MassConcentration)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MassConcentration otherQuantity))
+            if (obj is not MassConcentration otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MassConcentration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MassConcentration other, MassConcentration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MassConcentration"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MassConcentration other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MassConcentration.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MassConcentration), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MassConcentration"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MassConcentration)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MassConcentration otherQuantity)) throw new ArgumentException("Expected type MassConcentration.", nameof(obj));
+            if (obj is not MassConcentration otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MassConcentration>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MassConcentration"/> with another <see cref="MassConcentration"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MassConcentration"/> with another <see cref="MassConcentration"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1399,225 +1388,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MassConcentration other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassConcentrationUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MassConcentrationUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this MassConcentration to another MassConcentration with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MassConcentration with the specified unit.</returns>
-        public MassConcentration ToUnit(MassConcentrationUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="MassConcentration"/> to another <see cref="MassConcentration"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MassConcentration with the specified unit.</returns>
-        public MassConcentration ToUnit(MassConcentrationUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MassConcentration), Unit, typeof(MassConcentration), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MassConcentration)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="MassConcentration"/> to another <see cref="MassConcentration"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MassConcentration"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MassConcentrationUnit unit, [NotNullWhen(true)] out MassConcentration? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MassConcentration? convertedOrNull = (Unit, unit) switch
-            {
-                // MassConcentrationUnit -> BaseUnit
-                (MassConcentrationUnit.CentigramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-1) * 1e-2d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.CentigramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value) * 1e-2d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.CentigramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-6) * 1e-2d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.CentigramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-3) * 1e-2d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.DecigramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-1) * 1e-1d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.DecigramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value) * 1e-1d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.DecigramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-6) * 1e-1d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.DecigramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-3) * 1e-1d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.GramPerCubicCentimeter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value / 1e-3, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.GramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value / 1e3, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.GramPerCubicMillimeter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value / 1e-6, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.GramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value / 1e-1, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.GramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.GramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value / 1e-6, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.GramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value / 1e-3, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.KilogramPerCubicCentimeter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-3) * 1e3d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.KilogramPerCubicMillimeter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-6) * 1e3d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.KilogramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value) * 1e3d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.KilopoundPerCubicFoot, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value * 0.45359237 / 0.028316846592) * 1e3d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.KilopoundPerCubicInch, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value * 0.45359237 / 1.6387064e-5) * 1e3d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.MicrogramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e3) * 1e-6d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.MicrogramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-1) * 1e-6d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.MicrogramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value) * 1e-6d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.MicrogramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-6) * 1e-6d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.MicrogramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-3) * 1e-6d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.MilligramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e3) * 1e-3d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.MilligramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-1) * 1e-3d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.MilligramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value) * 1e-3d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.MilligramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-6) * 1e-3d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.MilligramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-3) * 1e-3d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.NanogramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-1) * 1e-9d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.NanogramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value) * 1e-9d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.NanogramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-6) * 1e-9d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.NanogramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-3) * 1e-9d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.OuncePerImperialGallon, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value * 0.028349523125 / 0.00454609, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.OuncePerUSGallon, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value * 0.028349523125 / 0.003785411784, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.PicogramPerDeciliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-1) * 1e-12d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.PicogramPerLiter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value) * 1e-12d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.PicogramPerMicroliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-6) * 1e-12d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.PicogramPerMilliliter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration((_value / 1e-3) * 1e-12d, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.PoundPerCubicFoot, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value * 0.45359237 / 0.028316846592, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.PoundPerCubicInch, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value * 0.45359237 / 1.6387064e-5, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.PoundPerImperialGallon, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value * 0.45359237 / 0.00454609, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.PoundPerUSGallon, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value * 0.45359237 / 0.003785411784, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.SlugPerCubicFoot, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value * (0.45359237 * 9.80665) / (0.3048 * 0.028316846592), MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.TonnePerCubicCentimeter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value / 1e-9, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.TonnePerCubicMeter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value / 0.001, MassConcentrationUnit.KilogramPerCubicMeter),
-                (MassConcentrationUnit.TonnePerCubicMillimeter, MassConcentrationUnit.KilogramPerCubicMeter) => new MassConcentration(_value / 1e-12, MassConcentrationUnit.KilogramPerCubicMeter),
-
-                // BaseUnit -> MassConcentrationUnit
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.CentigramPerDeciliter) => new MassConcentration((_value * 1e-1) / 1e-2d, MassConcentrationUnit.CentigramPerDeciliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.CentigramPerLiter) => new MassConcentration((_value) / 1e-2d, MassConcentrationUnit.CentigramPerLiter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.CentigramPerMicroliter) => new MassConcentration((_value * 1e-6) / 1e-2d, MassConcentrationUnit.CentigramPerMicroliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.CentigramPerMilliliter) => new MassConcentration((_value * 1e-3) / 1e-2d, MassConcentrationUnit.CentigramPerMilliliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.DecigramPerDeciliter) => new MassConcentration((_value * 1e-1) / 1e-1d, MassConcentrationUnit.DecigramPerDeciliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.DecigramPerLiter) => new MassConcentration((_value) / 1e-1d, MassConcentrationUnit.DecigramPerLiter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.DecigramPerMicroliter) => new MassConcentration((_value * 1e-6) / 1e-1d, MassConcentrationUnit.DecigramPerMicroliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.DecigramPerMilliliter) => new MassConcentration((_value * 1e-3) / 1e-1d, MassConcentrationUnit.DecigramPerMilliliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerCubicCentimeter) => new MassConcentration(_value * 1e-3, MassConcentrationUnit.GramPerCubicCentimeter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerCubicMeter) => new MassConcentration(_value * 1e3, MassConcentrationUnit.GramPerCubicMeter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerCubicMillimeter) => new MassConcentration(_value * 1e-6, MassConcentrationUnit.GramPerCubicMillimeter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerDeciliter) => new MassConcentration(_value * 1e-1, MassConcentrationUnit.GramPerDeciliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerLiter) => new MassConcentration(_value, MassConcentrationUnit.GramPerLiter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerMicroliter) => new MassConcentration(_value * 1e-6, MassConcentrationUnit.GramPerMicroliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.GramPerMilliliter) => new MassConcentration(_value * 1e-3, MassConcentrationUnit.GramPerMilliliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicCentimeter) => new MassConcentration((_value * 1e-3) / 1e3d, MassConcentrationUnit.KilogramPerCubicCentimeter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilogramPerCubicMillimeter) => new MassConcentration((_value * 1e-6) / 1e3d, MassConcentrationUnit.KilogramPerCubicMillimeter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilogramPerLiter) => new MassConcentration((_value) / 1e3d, MassConcentrationUnit.KilogramPerLiter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilopoundPerCubicFoot) => new MassConcentration((_value * 0.028316846592 / 0.45359237) / 1e3d, MassConcentrationUnit.KilopoundPerCubicFoot),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.KilopoundPerCubicInch) => new MassConcentration((_value * 1.6387064e-5 / 0.45359237) / 1e3d, MassConcentrationUnit.KilopoundPerCubicInch),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MicrogramPerCubicMeter) => new MassConcentration((_value * 1e3) / 1e-6d, MassConcentrationUnit.MicrogramPerCubicMeter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MicrogramPerDeciliter) => new MassConcentration((_value * 1e-1) / 1e-6d, MassConcentrationUnit.MicrogramPerDeciliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MicrogramPerLiter) => new MassConcentration((_value) / 1e-6d, MassConcentrationUnit.MicrogramPerLiter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MicrogramPerMicroliter) => new MassConcentration((_value * 1e-6) / 1e-6d, MassConcentrationUnit.MicrogramPerMicroliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MicrogramPerMilliliter) => new MassConcentration((_value * 1e-3) / 1e-6d, MassConcentrationUnit.MicrogramPerMilliliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MilligramPerCubicMeter) => new MassConcentration((_value * 1e3) / 1e-3d, MassConcentrationUnit.MilligramPerCubicMeter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MilligramPerDeciliter) => new MassConcentration((_value * 1e-1) / 1e-3d, MassConcentrationUnit.MilligramPerDeciliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MilligramPerLiter) => new MassConcentration((_value) / 1e-3d, MassConcentrationUnit.MilligramPerLiter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MilligramPerMicroliter) => new MassConcentration((_value * 1e-6) / 1e-3d, MassConcentrationUnit.MilligramPerMicroliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.MilligramPerMilliliter) => new MassConcentration((_value * 1e-3) / 1e-3d, MassConcentrationUnit.MilligramPerMilliliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.NanogramPerDeciliter) => new MassConcentration((_value * 1e-1) / 1e-9d, MassConcentrationUnit.NanogramPerDeciliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.NanogramPerLiter) => new MassConcentration((_value) / 1e-9d, MassConcentrationUnit.NanogramPerLiter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.NanogramPerMicroliter) => new MassConcentration((_value * 1e-6) / 1e-9d, MassConcentrationUnit.NanogramPerMicroliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.NanogramPerMilliliter) => new MassConcentration((_value * 1e-3) / 1e-9d, MassConcentrationUnit.NanogramPerMilliliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.OuncePerImperialGallon) => new MassConcentration(_value * 0.00454609 / 0.028349523125, MassConcentrationUnit.OuncePerImperialGallon),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.OuncePerUSGallon) => new MassConcentration(_value * 0.003785411784 / 0.028349523125, MassConcentrationUnit.OuncePerUSGallon),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PicogramPerDeciliter) => new MassConcentration((_value * 1e-1) / 1e-12d, MassConcentrationUnit.PicogramPerDeciliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PicogramPerLiter) => new MassConcentration((_value) / 1e-12d, MassConcentrationUnit.PicogramPerLiter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PicogramPerMicroliter) => new MassConcentration((_value * 1e-6) / 1e-12d, MassConcentrationUnit.PicogramPerMicroliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PicogramPerMilliliter) => new MassConcentration((_value * 1e-3) / 1e-12d, MassConcentrationUnit.PicogramPerMilliliter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PoundPerCubicFoot) => new MassConcentration(_value * 0.028316846592 / 0.45359237, MassConcentrationUnit.PoundPerCubicFoot),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PoundPerCubicInch) => new MassConcentration(_value * 1.6387064e-5 / 0.45359237, MassConcentrationUnit.PoundPerCubicInch),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PoundPerImperialGallon) => new MassConcentration(_value * 0.00454609 / 0.45359237, MassConcentrationUnit.PoundPerImperialGallon),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.PoundPerUSGallon) => new MassConcentration(_value * 0.003785411784 / 0.45359237, MassConcentrationUnit.PoundPerUSGallon),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.SlugPerCubicFoot) => new MassConcentration(_value * (0.3048 * 0.028316846592) / (0.45359237 * 9.80665), MassConcentrationUnit.SlugPerCubicFoot),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.TonnePerCubicCentimeter) => new MassConcentration(_value * 1e-9, MassConcentrationUnit.TonnePerCubicCentimeter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.TonnePerCubicMeter) => new MassConcentration(_value * 0.001, MassConcentrationUnit.TonnePerCubicMeter),
-                (MassConcentrationUnit.KilogramPerCubicMeter, MassConcentrationUnit.TonnePerCubicMillimeter) => new MassConcentration(_value * 1e-12, MassConcentrationUnit.TonnePerCubicMillimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MassConcentrationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassConcentrationUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MassConcentrationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassConcentrationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MassConcentrationUnit> IQuantity<MassConcentrationUnit>.ToUnit(MassConcentrationUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1631,11 +1404,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
index 72cc1c5344..a3a1b25257 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Mass flow is the ratio of the mass change to the time during which the change occurred (value of mass changes per unit time).
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MassFlow :
-        IArithmeticQuantity<MassFlow, MassFlowUnit>,
+        ILinearQuantity<MassFlow, MassFlowUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MassFlow, MassFlow, double>,
+        IDivisionOperators<MassFlow, MassFlow, QuantityValue>,
         IDivisionOperators<MassFlow, MassFlux, Area>,
         IDivisionOperators<MassFlow, Power, BrakeSpecificFuelConsumption>,
         IDivisionOperators<MassFlow, VolumeFlow, Density>,
@@ -62,7 +61,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -112,7 +111,7 @@ public static MassFlowInfo CreateDefault(Func<IEnumerable<UnitDefinition<MassFlo
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="MassFlow"/> is [T^-1][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="MassFlow"/> is T^-1M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 1, -1, 0, 0, 0, 0);
 
@@ -127,47 +126,109 @@ public static MassFlowInfo CreateDefault(Func<IEnumerable<UnitDefinition<MassFlo
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MassFlowUnit}"/> representing the default unit mappings for MassFlow.</returns>
             public static IEnumerable<UnitDefinition<MassFlowUnit>> GetDefaultMappings()
             {
-                yield return new (MassFlowUnit.CentigramPerDay, "CentigramPerDay", "CentigramsPerDay", new BaseUnits(mass: MassUnit.Centigram, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.CentigramPerSecond, "CentigramPerSecond", "CentigramsPerSecond", new BaseUnits(mass: MassUnit.Centigram, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.DecagramPerDay, "DecagramPerDay", "DecagramsPerDay", new BaseUnits(mass: MassUnit.Decagram, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.DecagramPerSecond, "DecagramPerSecond", "DecagramsPerSecond", new BaseUnits(mass: MassUnit.Decagram, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.DecigramPerDay, "DecigramPerDay", "DecigramsPerDay", new BaseUnits(mass: MassUnit.Decigram, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.DecigramPerSecond, "DecigramPerSecond", "DecigramsPerSecond", new BaseUnits(mass: MassUnit.Decigram, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.GramPerDay, "GramPerDay", "GramsPerDay", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.GramPerHour, "GramPerHour", "GramsPerHour", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Hour));
+                yield return new (MassFlowUnit.CentigramPerDay, "CentigramPerDay", "CentigramsPerDay", new BaseUnits(mass: MassUnit.Centigram, time: DurationUnit.Day),
+                     8640000
+                );
+                yield return new (MassFlowUnit.CentigramPerSecond, "CentigramPerSecond", "CentigramsPerSecond", new BaseUnits(mass: MassUnit.Centigram, time: DurationUnit.Second),
+                     100
+                );
+                yield return new (MassFlowUnit.DecagramPerDay, "DecagramPerDay", "DecagramsPerDay", new BaseUnits(mass: MassUnit.Decagram, time: DurationUnit.Day),
+                     8640
+                );
+                yield return new (MassFlowUnit.DecagramPerSecond, "DecagramPerSecond", "DecagramsPerSecond", new BaseUnits(mass: MassUnit.Decagram, time: DurationUnit.Second),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (MassFlowUnit.DecigramPerDay, "DecigramPerDay", "DecigramsPerDay", new BaseUnits(mass: MassUnit.Decigram, time: DurationUnit.Day),
+                     864000
+                );
+                yield return new (MassFlowUnit.DecigramPerSecond, "DecigramPerSecond", "DecigramsPerSecond", new BaseUnits(mass: MassUnit.Decigram, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (MassFlowUnit.GramPerDay, "GramPerDay", "GramsPerDay", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Day),
+                     86400
+                );
+                yield return new (MassFlowUnit.GramPerHour, "GramPerHour", "GramsPerHour", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Hour),
+                     3600
+                );
                 yield return new (MassFlowUnit.GramPerSecond, "GramPerSecond", "GramsPerSecond", new BaseUnits(mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.HectogramPerDay, "HectogramPerDay", "HectogramsPerDay", new BaseUnits(mass: MassUnit.Hectogram, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.HectogramPerSecond, "HectogramPerSecond", "HectogramsPerSecond", new BaseUnits(mass: MassUnit.Hectogram, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.KilogramPerDay, "KilogramPerDay", "KilogramsPerDay", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.KilogramPerHour, "KilogramPerHour", "KilogramsPerHour", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Hour));
-                yield return new (MassFlowUnit.KilogramPerMinute, "KilogramPerMinute", "KilogramsPerMinute", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Minute));
-                yield return new (MassFlowUnit.KilogramPerSecond, "KilogramPerSecond", "KilogramsPerSecond", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.MegagramPerDay, "MegagramPerDay", "MegagramsPerDay", BaseUnits.Undefined);
-                yield return new (MassFlowUnit.MegapoundPerDay, "MegapoundPerDay", "MegapoundsPerDay", new BaseUnits(mass: MassUnit.Megapound, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.MegapoundPerHour, "MegapoundPerHour", "MegapoundsPerHour", new BaseUnits(mass: MassUnit.Megapound, time: DurationUnit.Hour));
-                yield return new (MassFlowUnit.MegapoundPerMinute, "MegapoundPerMinute", "MegapoundsPerMinute", new BaseUnits(mass: MassUnit.Megapound, time: DurationUnit.Minute));
-                yield return new (MassFlowUnit.MegapoundPerSecond, "MegapoundPerSecond", "MegapoundsPerSecond", new BaseUnits(mass: MassUnit.Megapound, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.MicrogramPerDay, "MicrogramPerDay", "MicrogramsPerDay", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.MicrogramPerSecond, "MicrogramPerSecond", "MicrogramsPerSecond", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.MilligramPerDay, "MilligramPerDay", "MilligramsPerDay", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.MilligramPerSecond, "MilligramPerSecond", "MilligramsPerSecond", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.NanogramPerDay, "NanogramPerDay", "NanogramsPerDay", new BaseUnits(mass: MassUnit.Nanogram, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.NanogramPerSecond, "NanogramPerSecond", "NanogramsPerSecond", new BaseUnits(mass: MassUnit.Nanogram, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.PoundPerDay, "PoundPerDay", "PoundsPerDay", new BaseUnits(mass: MassUnit.Pound, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.PoundPerHour, "PoundPerHour", "PoundsPerHour", new BaseUnits(mass: MassUnit.Pound, time: DurationUnit.Hour));
-                yield return new (MassFlowUnit.PoundPerMinute, "PoundPerMinute", "PoundsPerMinute", new BaseUnits(mass: MassUnit.Pound, time: DurationUnit.Minute));
-                yield return new (MassFlowUnit.PoundPerSecond, "PoundPerSecond", "PoundsPerSecond", new BaseUnits(mass: MassUnit.Pound, time: DurationUnit.Second));
-                yield return new (MassFlowUnit.ShortTonPerHour, "ShortTonPerHour", "ShortTonsPerHour", new BaseUnits(mass: MassUnit.ShortTon, time: DurationUnit.Hour));
-                yield return new (MassFlowUnit.TonnePerDay, "TonnePerDay", "TonnesPerDay", new BaseUnits(mass: MassUnit.Tonne, time: DurationUnit.Day));
-                yield return new (MassFlowUnit.TonnePerHour, "TonnePerHour", "TonnesPerHour", new BaseUnits(mass: MassUnit.Tonne, time: DurationUnit.Hour));
+                yield return new (MassFlowUnit.HectogramPerDay, "HectogramPerDay", "HectogramsPerDay", new BaseUnits(mass: MassUnit.Hectogram, time: DurationUnit.Day),
+                     864
+                );
+                yield return new (MassFlowUnit.HectogramPerSecond, "HectogramPerSecond", "HectogramsPerSecond", new BaseUnits(mass: MassUnit.Hectogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 100)
+                );
+                yield return new (MassFlowUnit.KilogramPerDay, "KilogramPerDay", "KilogramsPerDay", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Day),
+                     new QuantityValue(432, 5)
+                );
+                yield return new (MassFlowUnit.KilogramPerHour, "KilogramPerHour", "KilogramsPerHour", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Hour),
+                     new QuantityValue(18, 5)
+                );
+                yield return new (MassFlowUnit.KilogramPerMinute, "KilogramPerMinute", "KilogramsPerMinute", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Minute),
+                     new QuantityValue(3, 50)
+                );
+                yield return new (MassFlowUnit.KilogramPerSecond, "KilogramPerSecond", "KilogramsPerSecond", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MassFlowUnit.MegagramPerDay, "MegagramPerDay", "MegagramsPerDay", BaseUnits.Undefined,
+                     new QuantityValue(54, 625)
+                );
+                yield return new (MassFlowUnit.MegapoundPerDay, "MegapoundPerDay", "MegapoundsPerDay", new BaseUnits(mass: MassUnit.Megapound, time: DurationUnit.Day),
+                     new QuantityValue(8640, 45359237)
+                );
+                yield return new (MassFlowUnit.MegapoundPerHour, "MegapoundPerHour", "MegapoundsPerHour", new BaseUnits(mass: MassUnit.Megapound, time: DurationUnit.Hour),
+                     new QuantityValue(360, 45359237)
+                );
+                yield return new (MassFlowUnit.MegapoundPerMinute, "MegapoundPerMinute", "MegapoundsPerMinute", new BaseUnits(mass: MassUnit.Megapound, time: DurationUnit.Minute),
+                     new QuantityValue(6, 45359237)
+                );
+                yield return new (MassFlowUnit.MegapoundPerSecond, "MegapoundPerSecond", "MegapoundsPerSecond", new BaseUnits(mass: MassUnit.Megapound, time: DurationUnit.Second),
+                     new QuantityValue(1, 453592370)
+                );
+                yield return new (MassFlowUnit.MicrogramPerDay, "MicrogramPerDay", "MicrogramsPerDay", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Day),
+                     86400000000
+                );
+                yield return new (MassFlowUnit.MicrogramPerSecond, "MicrogramPerSecond", "MicrogramsPerSecond", new BaseUnits(mass: MassUnit.Microgram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (MassFlowUnit.MilligramPerDay, "MilligramPerDay", "MilligramsPerDay", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Day),
+                     86400000
+                );
+                yield return new (MassFlowUnit.MilligramPerSecond, "MilligramPerSecond", "MilligramsPerSecond", new BaseUnits(mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (MassFlowUnit.NanogramPerDay, "NanogramPerDay", "NanogramsPerDay", new BaseUnits(mass: MassUnit.Nanogram, time: DurationUnit.Day),
+                     86400000000000
+                );
+                yield return new (MassFlowUnit.NanogramPerSecond, "NanogramPerSecond", "NanogramsPerSecond", new BaseUnits(mass: MassUnit.Nanogram, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (MassFlowUnit.PoundPerDay, "PoundPerDay", "PoundsPerDay", new BaseUnits(mass: MassUnit.Pound, time: DurationUnit.Day),
+                     new QuantityValue(8640000000, 45359237)
+                );
+                yield return new (MassFlowUnit.PoundPerHour, "PoundPerHour", "PoundsPerHour", new BaseUnits(mass: MassUnit.Pound, time: DurationUnit.Hour),
+                     new QuantityValue(360000000, 45359237)
+                );
+                yield return new (MassFlowUnit.PoundPerMinute, "PoundPerMinute", "PoundsPerMinute", new BaseUnits(mass: MassUnit.Pound, time: DurationUnit.Minute),
+                     new QuantityValue(6000000, 45359237)
+                );
+                yield return new (MassFlowUnit.PoundPerSecond, "PoundPerSecond", "PoundsPerSecond", new BaseUnits(mass: MassUnit.Pound, time: DurationUnit.Second),
+                     new QuantityValue(100000, 45359237)
+                );
+                yield return new (MassFlowUnit.ShortTonPerHour, "ShortTonPerHour", "ShortTonsPerHour", new BaseUnits(mass: MassUnit.ShortTon, time: DurationUnit.Hour),
+                     new QuantityValue(180000, 45359237)
+                );
+                yield return new (MassFlowUnit.TonnePerDay, "TonnePerDay", "TonnesPerDay", new BaseUnits(mass: MassUnit.Tonne, time: DurationUnit.Day),
+                     new QuantityValue(54, 625)
+                );
+                yield return new (MassFlowUnit.TonnePerHour, "TonnePerHour", "TonnesPerHour", new BaseUnits(mass: MassUnit.Tonne, time: DurationUnit.Hour),
+                     new QuantityValue(9, 2500)
+                );
             }
         }
 
         static MassFlow()
         {
-            Info = MassFlowInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MassFlowInfo.CreateDefault);
         }
 
         /// <summary>
@@ -175,7 +236,7 @@ static MassFlow()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MassFlow(double value, MassFlowUnit unit)
+        public MassFlow(QuantityValue value, MassFlowUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -189,7 +250,7 @@ public MassFlow(double value, MassFlowUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MassFlow(double value, UnitSystem unitSystem)
+        public MassFlow(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -200,7 +261,8 @@ public MassFlow(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MassFlow" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MassFlow, MassFlowUnit> Info { get; }
@@ -229,10 +291,8 @@ public MassFlow(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MassFlowUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -266,252 +326,174 @@ public MassFlow(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.CentigramPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.CentigramPerDay"/>
         /// </summary>
-        public double CentigramsPerDay => As(MassFlowUnit.CentigramPerDay);
+        public QuantityValue CentigramsPerDay => this.As(MassFlowUnit.CentigramPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.CentigramPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.CentigramPerSecond"/>
         /// </summary>
-        public double CentigramsPerSecond => As(MassFlowUnit.CentigramPerSecond);
+        public QuantityValue CentigramsPerSecond => this.As(MassFlowUnit.CentigramPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.DecagramPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.DecagramPerDay"/>
         /// </summary>
-        public double DecagramsPerDay => As(MassFlowUnit.DecagramPerDay);
+        public QuantityValue DecagramsPerDay => this.As(MassFlowUnit.DecagramPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.DecagramPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.DecagramPerSecond"/>
         /// </summary>
-        public double DecagramsPerSecond => As(MassFlowUnit.DecagramPerSecond);
+        public QuantityValue DecagramsPerSecond => this.As(MassFlowUnit.DecagramPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.DecigramPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.DecigramPerDay"/>
         /// </summary>
-        public double DecigramsPerDay => As(MassFlowUnit.DecigramPerDay);
+        public QuantityValue DecigramsPerDay => this.As(MassFlowUnit.DecigramPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.DecigramPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.DecigramPerSecond"/>
         /// </summary>
-        public double DecigramsPerSecond => As(MassFlowUnit.DecigramPerSecond);
+        public QuantityValue DecigramsPerSecond => this.As(MassFlowUnit.DecigramPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.GramPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.GramPerDay"/>
         /// </summary>
-        public double GramsPerDay => As(MassFlowUnit.GramPerDay);
+        public QuantityValue GramsPerDay => this.As(MassFlowUnit.GramPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.GramPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.GramPerHour"/>
         /// </summary>
-        public double GramsPerHour => As(MassFlowUnit.GramPerHour);
+        public QuantityValue GramsPerHour => this.As(MassFlowUnit.GramPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.GramPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.GramPerSecond"/>
         /// </summary>
-        public double GramsPerSecond => As(MassFlowUnit.GramPerSecond);
+        public QuantityValue GramsPerSecond => this.As(MassFlowUnit.GramPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.HectogramPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.HectogramPerDay"/>
         /// </summary>
-        public double HectogramsPerDay => As(MassFlowUnit.HectogramPerDay);
+        public QuantityValue HectogramsPerDay => this.As(MassFlowUnit.HectogramPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.HectogramPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.HectogramPerSecond"/>
         /// </summary>
-        public double HectogramsPerSecond => As(MassFlowUnit.HectogramPerSecond);
+        public QuantityValue HectogramsPerSecond => this.As(MassFlowUnit.HectogramPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerDay"/>
         /// </summary>
-        public double KilogramsPerDay => As(MassFlowUnit.KilogramPerDay);
+        public QuantityValue KilogramsPerDay => this.As(MassFlowUnit.KilogramPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerHour"/>
         /// </summary>
-        public double KilogramsPerHour => As(MassFlowUnit.KilogramPerHour);
+        public QuantityValue KilogramsPerHour => this.As(MassFlowUnit.KilogramPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerMinute"/>
         /// </summary>
-        public double KilogramsPerMinute => As(MassFlowUnit.KilogramPerMinute);
+        public QuantityValue KilogramsPerMinute => this.As(MassFlowUnit.KilogramPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.KilogramPerSecond"/>
         /// </summary>
-        public double KilogramsPerSecond => As(MassFlowUnit.KilogramPerSecond);
+        public QuantityValue KilogramsPerSecond => this.As(MassFlowUnit.KilogramPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MegagramPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.MegagramPerDay"/>
         /// </summary>
-        public double MegagramsPerDay => As(MassFlowUnit.MegagramPerDay);
+        public QuantityValue MegagramsPerDay => this.As(MassFlowUnit.MegagramPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerDay"/>
         /// </summary>
-        public double MegapoundsPerDay => As(MassFlowUnit.MegapoundPerDay);
+        public QuantityValue MegapoundsPerDay => this.As(MassFlowUnit.MegapoundPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerHour"/>
         /// </summary>
-        public double MegapoundsPerHour => As(MassFlowUnit.MegapoundPerHour);
+        public QuantityValue MegapoundsPerHour => this.As(MassFlowUnit.MegapoundPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerMinute"/>
         /// </summary>
-        public double MegapoundsPerMinute => As(MassFlowUnit.MegapoundPerMinute);
+        public QuantityValue MegapoundsPerMinute => this.As(MassFlowUnit.MegapoundPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.MegapoundPerSecond"/>
         /// </summary>
-        public double MegapoundsPerSecond => As(MassFlowUnit.MegapoundPerSecond);
+        public QuantityValue MegapoundsPerSecond => this.As(MassFlowUnit.MegapoundPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MicrogramPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.MicrogramPerDay"/>
         /// </summary>
-        public double MicrogramsPerDay => As(MassFlowUnit.MicrogramPerDay);
+        public QuantityValue MicrogramsPerDay => this.As(MassFlowUnit.MicrogramPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MicrogramPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.MicrogramPerSecond"/>
         /// </summary>
-        public double MicrogramsPerSecond => As(MassFlowUnit.MicrogramPerSecond);
+        public QuantityValue MicrogramsPerSecond => this.As(MassFlowUnit.MicrogramPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MilligramPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.MilligramPerDay"/>
         /// </summary>
-        public double MilligramsPerDay => As(MassFlowUnit.MilligramPerDay);
+        public QuantityValue MilligramsPerDay => this.As(MassFlowUnit.MilligramPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.MilligramPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.MilligramPerSecond"/>
         /// </summary>
-        public double MilligramsPerSecond => As(MassFlowUnit.MilligramPerSecond);
+        public QuantityValue MilligramsPerSecond => this.As(MassFlowUnit.MilligramPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.NanogramPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.NanogramPerDay"/>
         /// </summary>
-        public double NanogramsPerDay => As(MassFlowUnit.NanogramPerDay);
+        public QuantityValue NanogramsPerDay => this.As(MassFlowUnit.NanogramPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.NanogramPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.NanogramPerSecond"/>
         /// </summary>
-        public double NanogramsPerSecond => As(MassFlowUnit.NanogramPerSecond);
+        public QuantityValue NanogramsPerSecond => this.As(MassFlowUnit.NanogramPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerDay"/>
         /// </summary>
-        public double PoundsPerDay => As(MassFlowUnit.PoundPerDay);
+        public QuantityValue PoundsPerDay => this.As(MassFlowUnit.PoundPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerHour"/>
         /// </summary>
-        public double PoundsPerHour => As(MassFlowUnit.PoundPerHour);
+        public QuantityValue PoundsPerHour => this.As(MassFlowUnit.PoundPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerMinute"/>
         /// </summary>
-        public double PoundsPerMinute => As(MassFlowUnit.PoundPerMinute);
+        public QuantityValue PoundsPerMinute => this.As(MassFlowUnit.PoundPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.PoundPerSecond"/>
         /// </summary>
-        public double PoundsPerSecond => As(MassFlowUnit.PoundPerSecond);
+        public QuantityValue PoundsPerSecond => this.As(MassFlowUnit.PoundPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.ShortTonPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.ShortTonPerHour"/>
         /// </summary>
-        public double ShortTonsPerHour => As(MassFlowUnit.ShortTonPerHour);
+        public QuantityValue ShortTonsPerHour => this.As(MassFlowUnit.ShortTonPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.TonnePerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.TonnePerDay"/>
         /// </summary>
-        public double TonnesPerDay => As(MassFlowUnit.TonnePerDay);
+        public QuantityValue TonnesPerDay => this.As(MassFlowUnit.TonnePerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFlowUnit.TonnePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFlowUnit.TonnePerHour"/>
         /// </summary>
-        public double TonnesPerHour => As(MassFlowUnit.TonnePerHour);
+        public QuantityValue TonnesPerHour => this.As(MassFlowUnit.TonnePerHour);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MassFlowUnit -> BaseUnit
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.CentigramPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.CentigramPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.DecagramPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.DecagramPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.DecigramPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.DecigramPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerHour, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.HectogramPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.HectogramPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.KilogramPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.KilogramPerHour, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.KilogramPerMinute, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.KilogramPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MegagramPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MegapoundPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MegapoundPerHour, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MegapoundPerMinute, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MegapoundPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MicrogramPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MicrogramPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MilligramPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.MilligramPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.NanogramPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.NanogramPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.PoundPerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.PoundPerHour, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.PoundPerMinute, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.PoundPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.ShortTonPerHour, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.TonnePerDay, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.TonnePerHour, MassFlowUnit.GramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.GramPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.GramPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MassFlowUnit
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.CentigramPerDay, quantity => quantity.ToUnit(MassFlowUnit.CentigramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.CentigramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.CentigramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.DecagramPerDay, quantity => quantity.ToUnit(MassFlowUnit.DecagramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.DecagramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.DecagramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.DecigramPerDay, quantity => quantity.ToUnit(MassFlowUnit.DecigramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.DecigramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.DecigramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.GramPerDay, quantity => quantity.ToUnit(MassFlowUnit.GramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.GramPerHour, quantity => quantity.ToUnit(MassFlowUnit.GramPerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.HectogramPerDay, quantity => quantity.ToUnit(MassFlowUnit.HectogramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.HectogramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.HectogramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.KilogramPerDay, quantity => quantity.ToUnit(MassFlowUnit.KilogramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.KilogramPerHour, quantity => quantity.ToUnit(MassFlowUnit.KilogramPerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.KilogramPerMinute, quantity => quantity.ToUnit(MassFlowUnit.KilogramPerMinute));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.KilogramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.KilogramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.MegagramPerDay, quantity => quantity.ToUnit(MassFlowUnit.MegagramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.MegapoundPerDay, quantity => quantity.ToUnit(MassFlowUnit.MegapoundPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.MegapoundPerHour, quantity => quantity.ToUnit(MassFlowUnit.MegapoundPerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.MegapoundPerMinute, quantity => quantity.ToUnit(MassFlowUnit.MegapoundPerMinute));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.MegapoundPerSecond, quantity => quantity.ToUnit(MassFlowUnit.MegapoundPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.MicrogramPerDay, quantity => quantity.ToUnit(MassFlowUnit.MicrogramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.MicrogramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.MicrogramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.MilligramPerDay, quantity => quantity.ToUnit(MassFlowUnit.MilligramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.MilligramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.MilligramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.NanogramPerDay, quantity => quantity.ToUnit(MassFlowUnit.NanogramPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.NanogramPerSecond, quantity => quantity.ToUnit(MassFlowUnit.NanogramPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.PoundPerDay, quantity => quantity.ToUnit(MassFlowUnit.PoundPerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.PoundPerHour, quantity => quantity.ToUnit(MassFlowUnit.PoundPerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.PoundPerMinute, quantity => quantity.ToUnit(MassFlowUnit.PoundPerMinute));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.PoundPerSecond, quantity => quantity.ToUnit(MassFlowUnit.PoundPerSecond));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.ShortTonPerHour, quantity => quantity.ToUnit(MassFlowUnit.ShortTonPerHour));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.TonnePerDay, quantity => quantity.ToUnit(MassFlowUnit.TonnePerDay));
-            unitConverter.SetConversionFunction<MassFlow>(MassFlowUnit.GramPerSecond, MassFlowUnit.TonnePerHour, quantity => quantity.ToUnit(MassFlowUnit.TonnePerHour));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -540,7 +522,7 @@ public static string GetAbbreviation(MassFlowUnit unit, IFormatProvider? provide
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.CentigramPerDay"/>.
         /// </summary>
-        public static MassFlow FromCentigramsPerDay(double value)
+        public static MassFlow FromCentigramsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.CentigramPerDay);
         }
@@ -548,7 +530,7 @@ public static MassFlow FromCentigramsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.CentigramPerSecond"/>.
         /// </summary>
-        public static MassFlow FromCentigramsPerSecond(double value)
+        public static MassFlow FromCentigramsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.CentigramPerSecond);
         }
@@ -556,7 +538,7 @@ public static MassFlow FromCentigramsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecagramPerDay"/>.
         /// </summary>
-        public static MassFlow FromDecagramsPerDay(double value)
+        public static MassFlow FromDecagramsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.DecagramPerDay);
         }
@@ -564,7 +546,7 @@ public static MassFlow FromDecagramsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecagramPerSecond"/>.
         /// </summary>
-        public static MassFlow FromDecagramsPerSecond(double value)
+        public static MassFlow FromDecagramsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.DecagramPerSecond);
         }
@@ -572,7 +554,7 @@ public static MassFlow FromDecagramsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecigramPerDay"/>.
         /// </summary>
-        public static MassFlow FromDecigramsPerDay(double value)
+        public static MassFlow FromDecigramsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.DecigramPerDay);
         }
@@ -580,7 +562,7 @@ public static MassFlow FromDecigramsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecigramPerSecond"/>.
         /// </summary>
-        public static MassFlow FromDecigramsPerSecond(double value)
+        public static MassFlow FromDecigramsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.DecigramPerSecond);
         }
@@ -588,7 +570,7 @@ public static MassFlow FromDecigramsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerDay"/>.
         /// </summary>
-        public static MassFlow FromGramsPerDay(double value)
+        public static MassFlow FromGramsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.GramPerDay);
         }
@@ -596,7 +578,7 @@ public static MassFlow FromGramsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerHour"/>.
         /// </summary>
-        public static MassFlow FromGramsPerHour(double value)
+        public static MassFlow FromGramsPerHour(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.GramPerHour);
         }
@@ -604,7 +586,7 @@ public static MassFlow FromGramsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerSecond"/>.
         /// </summary>
-        public static MassFlow FromGramsPerSecond(double value)
+        public static MassFlow FromGramsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.GramPerSecond);
         }
@@ -612,7 +594,7 @@ public static MassFlow FromGramsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.HectogramPerDay"/>.
         /// </summary>
-        public static MassFlow FromHectogramsPerDay(double value)
+        public static MassFlow FromHectogramsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.HectogramPerDay);
         }
@@ -620,7 +602,7 @@ public static MassFlow FromHectogramsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.HectogramPerSecond"/>.
         /// </summary>
-        public static MassFlow FromHectogramsPerSecond(double value)
+        public static MassFlow FromHectogramsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.HectogramPerSecond);
         }
@@ -628,7 +610,7 @@ public static MassFlow FromHectogramsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerDay"/>.
         /// </summary>
-        public static MassFlow FromKilogramsPerDay(double value)
+        public static MassFlow FromKilogramsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.KilogramPerDay);
         }
@@ -636,7 +618,7 @@ public static MassFlow FromKilogramsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerHour"/>.
         /// </summary>
-        public static MassFlow FromKilogramsPerHour(double value)
+        public static MassFlow FromKilogramsPerHour(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.KilogramPerHour);
         }
@@ -644,7 +626,7 @@ public static MassFlow FromKilogramsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerMinute"/>.
         /// </summary>
-        public static MassFlow FromKilogramsPerMinute(double value)
+        public static MassFlow FromKilogramsPerMinute(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.KilogramPerMinute);
         }
@@ -652,7 +634,7 @@ public static MassFlow FromKilogramsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerSecond"/>.
         /// </summary>
-        public static MassFlow FromKilogramsPerSecond(double value)
+        public static MassFlow FromKilogramsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.KilogramPerSecond);
         }
@@ -660,7 +642,7 @@ public static MassFlow FromKilogramsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegagramPerDay"/>.
         /// </summary>
-        public static MassFlow FromMegagramsPerDay(double value)
+        public static MassFlow FromMegagramsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.MegagramPerDay);
         }
@@ -668,7 +650,7 @@ public static MassFlow FromMegagramsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerDay"/>.
         /// </summary>
-        public static MassFlow FromMegapoundsPerDay(double value)
+        public static MassFlow FromMegapoundsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.MegapoundPerDay);
         }
@@ -676,7 +658,7 @@ public static MassFlow FromMegapoundsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerHour"/>.
         /// </summary>
-        public static MassFlow FromMegapoundsPerHour(double value)
+        public static MassFlow FromMegapoundsPerHour(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.MegapoundPerHour);
         }
@@ -684,7 +666,7 @@ public static MassFlow FromMegapoundsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerMinute"/>.
         /// </summary>
-        public static MassFlow FromMegapoundsPerMinute(double value)
+        public static MassFlow FromMegapoundsPerMinute(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.MegapoundPerMinute);
         }
@@ -692,7 +674,7 @@ public static MassFlow FromMegapoundsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerSecond"/>.
         /// </summary>
-        public static MassFlow FromMegapoundsPerSecond(double value)
+        public static MassFlow FromMegapoundsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.MegapoundPerSecond);
         }
@@ -700,7 +682,7 @@ public static MassFlow FromMegapoundsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MicrogramPerDay"/>.
         /// </summary>
-        public static MassFlow FromMicrogramsPerDay(double value)
+        public static MassFlow FromMicrogramsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.MicrogramPerDay);
         }
@@ -708,7 +690,7 @@ public static MassFlow FromMicrogramsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MicrogramPerSecond"/>.
         /// </summary>
-        public static MassFlow FromMicrogramsPerSecond(double value)
+        public static MassFlow FromMicrogramsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.MicrogramPerSecond);
         }
@@ -716,7 +698,7 @@ public static MassFlow FromMicrogramsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MilligramPerDay"/>.
         /// </summary>
-        public static MassFlow FromMilligramsPerDay(double value)
+        public static MassFlow FromMilligramsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.MilligramPerDay);
         }
@@ -724,7 +706,7 @@ public static MassFlow FromMilligramsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MilligramPerSecond"/>.
         /// </summary>
-        public static MassFlow FromMilligramsPerSecond(double value)
+        public static MassFlow FromMilligramsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.MilligramPerSecond);
         }
@@ -732,7 +714,7 @@ public static MassFlow FromMilligramsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.NanogramPerDay"/>.
         /// </summary>
-        public static MassFlow FromNanogramsPerDay(double value)
+        public static MassFlow FromNanogramsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.NanogramPerDay);
         }
@@ -740,7 +722,7 @@ public static MassFlow FromNanogramsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.NanogramPerSecond"/>.
         /// </summary>
-        public static MassFlow FromNanogramsPerSecond(double value)
+        public static MassFlow FromNanogramsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.NanogramPerSecond);
         }
@@ -748,7 +730,7 @@ public static MassFlow FromNanogramsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerDay"/>.
         /// </summary>
-        public static MassFlow FromPoundsPerDay(double value)
+        public static MassFlow FromPoundsPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.PoundPerDay);
         }
@@ -756,7 +738,7 @@ public static MassFlow FromPoundsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerHour"/>.
         /// </summary>
-        public static MassFlow FromPoundsPerHour(double value)
+        public static MassFlow FromPoundsPerHour(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.PoundPerHour);
         }
@@ -764,7 +746,7 @@ public static MassFlow FromPoundsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerMinute"/>.
         /// </summary>
-        public static MassFlow FromPoundsPerMinute(double value)
+        public static MassFlow FromPoundsPerMinute(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.PoundPerMinute);
         }
@@ -772,7 +754,7 @@ public static MassFlow FromPoundsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerSecond"/>.
         /// </summary>
-        public static MassFlow FromPoundsPerSecond(double value)
+        public static MassFlow FromPoundsPerSecond(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.PoundPerSecond);
         }
@@ -780,7 +762,7 @@ public static MassFlow FromPoundsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.ShortTonPerHour"/>.
         /// </summary>
-        public static MassFlow FromShortTonsPerHour(double value)
+        public static MassFlow FromShortTonsPerHour(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.ShortTonPerHour);
         }
@@ -788,7 +770,7 @@ public static MassFlow FromShortTonsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.TonnePerDay"/>.
         /// </summary>
-        public static MassFlow FromTonnesPerDay(double value)
+        public static MassFlow FromTonnesPerDay(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.TonnePerDay);
         }
@@ -796,7 +778,7 @@ public static MassFlow FromTonnesPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.TonnePerHour"/>.
         /// </summary>
-        public static MassFlow FromTonnesPerHour(double value)
+        public static MassFlow FromTonnesPerHour(QuantityValue value)
         {
             return new MassFlow(value, MassFlowUnit.TonnePerHour);
         }
@@ -807,7 +789,7 @@ public static MassFlow FromTonnesPerHour(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MassFlow unit value.</returns>
-        public static MassFlow From(double value, MassFlowUnit fromUnit)
+        public static MassFlow From(QuantityValue value, MassFlowUnit fromUnit)
         {
             return new MassFlow(value, fromUnit);
         }
@@ -868,10 +850,7 @@ public static MassFlow Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MassFlow Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MassFlow, MassFlowUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MassFlow, MassFlowUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -899,11 +878,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MassFlow result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassFlow result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MassFlow, MassFlowUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MassFlow, MassFlowUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -924,7 +899,7 @@ public static MassFlowUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -935,7 +910,7 @@ public static MassFlowUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassFlowUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MassFlowUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassFlowUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -950,7 +925,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassFlowUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassFlowUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -969,35 +944,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MassFlow"/> from adding two <see cref="MassFlow"/>.</summary>
         public static MassFlow operator +(MassFlow left, MassFlow right)
         {
-            return new MassFlow(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MassFlow(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MassFlow"/> from subtracting two <see cref="MassFlow"/>.</summary>
         public static MassFlow operator -(MassFlow left, MassFlow right)
         {
-            return new MassFlow(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MassFlow(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MassFlow"/> from multiplying value and <see cref="MassFlow"/>.</summary>
-        public static MassFlow operator *(double left, MassFlow right)
+        public static MassFlow operator *(QuantityValue left, MassFlow right)
         {
             return new MassFlow(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MassFlow"/> from multiplying value and <see cref="MassFlow"/>.</summary>
-        public static MassFlow operator *(MassFlow left, double right)
+        public static MassFlow operator *(MassFlow left, QuantityValue right)
         {
             return new MassFlow(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MassFlow"/> from dividing <see cref="MassFlow"/> by value.</summary>
-        public static MassFlow operator /(MassFlow left, double right)
+        public static MassFlow operator /(MassFlow left, QuantityValue right)
         {
             return new MassFlow(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MassFlow"/> by <see cref="MassFlow"/>.</summary>
-        public static double operator /(MassFlow left, MassFlow right)
+        public static QuantityValue operator /(MassFlow left, MassFlow right)
         {
             return left.GramsPerSecond / right.GramsPerSecond;
         }
@@ -1073,97 +1048,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MassFlow left, MassFlow right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MassFlow left, MassFlow right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MassFlow left, MassFlow right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MassFlow left, MassFlow right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MassFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MassFlow other, MassFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MassFlow"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MassFlow)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MassFlow left, MassFlow right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MassFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MassFlow other, MassFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MassFlow"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MassFlow,MassFlow)"/>.
+        ///     See that operator (and <see cref="Equals(MassFlow)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MassFlow left, MassFlow right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MassFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MassFlow other, MassFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MassFlow"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MassFlow"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MassFlow"/>, this method delegates to
+        ///     <see cref="Equals(MassFlow)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MassFlow otherQuantity))
+            if (obj is not MassFlow otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MassFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MassFlow other, MassFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MassFlow"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MassFlow other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MassFlow.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MassFlow), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MassFlow"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MassFlow)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MassFlow otherQuantity)) throw new ArgumentException("Expected type MassFlow.", nameof(obj));
+            if (obj is not MassFlow otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MassFlow>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MassFlow"/> with another <see cref="MassFlow"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MassFlow"/> with another <see cref="MassFlow"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1175,193 +1164,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MassFlow other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassFlowUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MassFlowUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this MassFlow to another MassFlow with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MassFlow with the specified unit.</returns>
-        public MassFlow ToUnit(MassFlowUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="MassFlow"/> to another <see cref="MassFlow"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MassFlow with the specified unit.</returns>
-        public MassFlow ToUnit(MassFlowUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MassFlow), Unit, typeof(MassFlow), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MassFlow)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="MassFlow"/> to another <see cref="MassFlow"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MassFlow"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MassFlowUnit unit, [NotNullWhen(true)] out MassFlow? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MassFlow? convertedOrNull = (Unit, unit) switch
-            {
-                // MassFlowUnit -> BaseUnit
-                (MassFlowUnit.CentigramPerDay, MassFlowUnit.GramPerSecond) => new MassFlow((_value / 86400) * 1e-2d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.CentigramPerSecond, MassFlowUnit.GramPerSecond) => new MassFlow((_value) * 1e-2d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.DecagramPerDay, MassFlowUnit.GramPerSecond) => new MassFlow((_value / 86400) * 1e1d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.DecagramPerSecond, MassFlowUnit.GramPerSecond) => new MassFlow((_value) * 1e1d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.DecigramPerDay, MassFlowUnit.GramPerSecond) => new MassFlow((_value / 86400) * 1e-1d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.DecigramPerSecond, MassFlowUnit.GramPerSecond) => new MassFlow((_value) * 1e-1d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.GramPerDay, MassFlowUnit.GramPerSecond) => new MassFlow(_value / 86400, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.GramPerHour, MassFlowUnit.GramPerSecond) => new MassFlow(_value / 3600, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.HectogramPerDay, MassFlowUnit.GramPerSecond) => new MassFlow((_value / 86400) * 1e2d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.HectogramPerSecond, MassFlowUnit.GramPerSecond) => new MassFlow((_value) * 1e2d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.KilogramPerDay, MassFlowUnit.GramPerSecond) => new MassFlow((_value / 86400) * 1e3d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.KilogramPerHour, MassFlowUnit.GramPerSecond) => new MassFlow(_value / 3.6, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.KilogramPerMinute, MassFlowUnit.GramPerSecond) => new MassFlow(_value / 0.06, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.KilogramPerSecond, MassFlowUnit.GramPerSecond) => new MassFlow((_value) * 1e3d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.MegagramPerDay, MassFlowUnit.GramPerSecond) => new MassFlow((_value / 86400) * 1e6d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.MegapoundPerDay, MassFlowUnit.GramPerSecond) => new MassFlow((_value * 453.59237 / 86400) * 1e6d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.MegapoundPerHour, MassFlowUnit.GramPerSecond) => new MassFlow((_value * 453.59237 / 3600) * 1e6d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.MegapoundPerMinute, MassFlowUnit.GramPerSecond) => new MassFlow((_value * 453.59237 / 60) * 1e6d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.MegapoundPerSecond, MassFlowUnit.GramPerSecond) => new MassFlow((_value * 453.59237) * 1e6d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.MicrogramPerDay, MassFlowUnit.GramPerSecond) => new MassFlow((_value / 86400) * 1e-6d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.MicrogramPerSecond, MassFlowUnit.GramPerSecond) => new MassFlow((_value) * 1e-6d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.MilligramPerDay, MassFlowUnit.GramPerSecond) => new MassFlow((_value / 86400) * 1e-3d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.MilligramPerSecond, MassFlowUnit.GramPerSecond) => new MassFlow((_value) * 1e-3d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.NanogramPerDay, MassFlowUnit.GramPerSecond) => new MassFlow((_value / 86400) * 1e-9d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.NanogramPerSecond, MassFlowUnit.GramPerSecond) => new MassFlow((_value) * 1e-9d, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.PoundPerDay, MassFlowUnit.GramPerSecond) => new MassFlow(_value * 453.59237 / 86400, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.PoundPerHour, MassFlowUnit.GramPerSecond) => new MassFlow(_value * 453.59237 / 3600, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.PoundPerMinute, MassFlowUnit.GramPerSecond) => new MassFlow(_value * 453.59237 / 60, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.PoundPerSecond, MassFlowUnit.GramPerSecond) => new MassFlow(_value * 453.59237, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.ShortTonPerHour, MassFlowUnit.GramPerSecond) => new MassFlow(_value * 907.18474 / 3.6, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.TonnePerDay, MassFlowUnit.GramPerSecond) => new MassFlow(_value / 0.0864000, MassFlowUnit.GramPerSecond),
-                (MassFlowUnit.TonnePerHour, MassFlowUnit.GramPerSecond) => new MassFlow(_value * 1000 / 3.6, MassFlowUnit.GramPerSecond),
-
-                // BaseUnit -> MassFlowUnit
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.CentigramPerDay) => new MassFlow((_value * 86400) / 1e-2d, MassFlowUnit.CentigramPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.CentigramPerSecond) => new MassFlow((_value) / 1e-2d, MassFlowUnit.CentigramPerSecond),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.DecagramPerDay) => new MassFlow((_value * 86400) / 1e1d, MassFlowUnit.DecagramPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.DecagramPerSecond) => new MassFlow((_value) / 1e1d, MassFlowUnit.DecagramPerSecond),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.DecigramPerDay) => new MassFlow((_value * 86400) / 1e-1d, MassFlowUnit.DecigramPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.DecigramPerSecond) => new MassFlow((_value) / 1e-1d, MassFlowUnit.DecigramPerSecond),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.GramPerDay) => new MassFlow(_value * 86400, MassFlowUnit.GramPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.GramPerHour) => new MassFlow(_value * 3600, MassFlowUnit.GramPerHour),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.HectogramPerDay) => new MassFlow((_value * 86400) / 1e2d, MassFlowUnit.HectogramPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.HectogramPerSecond) => new MassFlow((_value) / 1e2d, MassFlowUnit.HectogramPerSecond),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.KilogramPerDay) => new MassFlow((_value * 86400) / 1e3d, MassFlowUnit.KilogramPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.KilogramPerHour) => new MassFlow(_value * 3.6, MassFlowUnit.KilogramPerHour),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.KilogramPerMinute) => new MassFlow(_value * 0.06, MassFlowUnit.KilogramPerMinute),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.KilogramPerSecond) => new MassFlow((_value) / 1e3d, MassFlowUnit.KilogramPerSecond),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.MegagramPerDay) => new MassFlow((_value * 86400) / 1e6d, MassFlowUnit.MegagramPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.MegapoundPerDay) => new MassFlow((_value * 86400 / 453.59237) / 1e6d, MassFlowUnit.MegapoundPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.MegapoundPerHour) => new MassFlow((_value * 3600 / 453.59237) / 1e6d, MassFlowUnit.MegapoundPerHour),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.MegapoundPerMinute) => new MassFlow((_value * 60 / 453.59237) / 1e6d, MassFlowUnit.MegapoundPerMinute),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.MegapoundPerSecond) => new MassFlow((_value / 453.59237) / 1e6d, MassFlowUnit.MegapoundPerSecond),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.MicrogramPerDay) => new MassFlow((_value * 86400) / 1e-6d, MassFlowUnit.MicrogramPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.MicrogramPerSecond) => new MassFlow((_value) / 1e-6d, MassFlowUnit.MicrogramPerSecond),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.MilligramPerDay) => new MassFlow((_value * 86400) / 1e-3d, MassFlowUnit.MilligramPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.MilligramPerSecond) => new MassFlow((_value) / 1e-3d, MassFlowUnit.MilligramPerSecond),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.NanogramPerDay) => new MassFlow((_value * 86400) / 1e-9d, MassFlowUnit.NanogramPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.NanogramPerSecond) => new MassFlow((_value) / 1e-9d, MassFlowUnit.NanogramPerSecond),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.PoundPerDay) => new MassFlow(_value * 86400 / 453.59237, MassFlowUnit.PoundPerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.PoundPerHour) => new MassFlow(_value * 3600 / 453.59237, MassFlowUnit.PoundPerHour),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.PoundPerMinute) => new MassFlow(_value * 60 / 453.59237, MassFlowUnit.PoundPerMinute),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.PoundPerSecond) => new MassFlow(_value / 453.59237, MassFlowUnit.PoundPerSecond),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.ShortTonPerHour) => new MassFlow(_value * 3.6 / 907.18474, MassFlowUnit.ShortTonPerHour),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.TonnePerDay) => new MassFlow(_value * 0.0864000, MassFlowUnit.TonnePerDay),
-                (MassFlowUnit.GramPerSecond, MassFlowUnit.TonnePerHour) => new MassFlow(_value * 3.6 / 1000, MassFlowUnit.TonnePerHour),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MassFlowUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFlowUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MassFlowUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFlowUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MassFlowUnit> IQuantity<MassFlowUnit>.ToUnit(MassFlowUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1375,11 +1180,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
index f2e84a2d0c..14987fa97e 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Mass flux is the mass flow rate per unit area.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MassFlux :
-        IArithmeticQuantity<MassFlux, MassFluxUnit>,
+        ILinearQuantity<MassFlux, MassFluxUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MassFlux, MassFlux, double>,
+        IDivisionOperators<MassFlux, MassFlux, QuantityValue>,
         IDivisionOperators<MassFlux, Speed, Density>,
         IMultiplyOperators<MassFlux, Area, MassFlow>,
         IDivisionOperators<MassFlux, Density, Speed>,
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static MassFluxInfo CreateDefault(Func<IEnumerable<UnitDefinition<MassFlu
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="MassFlux"/> is [T^-1][L^-2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="MassFlux"/> is T^-1L^-2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 1, -1, 0, 0, 0, 0);
 
@@ -120,26 +119,46 @@ public static MassFluxInfo CreateDefault(Func<IEnumerable<UnitDefinition<MassFlu
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MassFluxUnit}"/> representing the default unit mappings for MassFlux.</returns>
             public static IEnumerable<UnitDefinition<MassFluxUnit>> GetDefaultMappings()
             {
-                yield return new (MassFluxUnit.GramPerHourPerSquareCentimeter, "GramPerHourPerSquareCentimeter", "GramsPerHourPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram, time: DurationUnit.Hour));
-                yield return new (MassFluxUnit.GramPerHourPerSquareMeter, "GramPerHourPerSquareMeter", "GramsPerHourPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Hour));
-                yield return new (MassFluxUnit.GramPerHourPerSquareMillimeter, "GramPerHourPerSquareMillimeter", "GramsPerHourPerSquareMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram, time: DurationUnit.Hour));
-                yield return new (MassFluxUnit.GramPerSecondPerSquareCentimeter, "GramPerSecondPerSquareCentimeter", "GramsPerSecondPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (MassFluxUnit.GramPerSecondPerSquareMeter, "GramPerSecondPerSquareMeter", "GramsPerSecondPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (MassFluxUnit.GramPerSecondPerSquareMillimeter, "GramPerSecondPerSquareMillimeter", "GramsPerSecondPerSquareMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (MassFluxUnit.KilogramPerHourPerSquareCentimeter, "KilogramPerHourPerSquareCentimeter", "KilogramsPerHourPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Hour));
-                yield return new (MassFluxUnit.KilogramPerHourPerSquareMeter, "KilogramPerHourPerSquareMeter", "KilogramsPerHourPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Hour));
-                yield return new (MassFluxUnit.KilogramPerHourPerSquareMillimeter, "KilogramPerHourPerSquareMillimeter", "KilogramsPerHourPerSquareMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Hour));
-                yield return new (MassFluxUnit.KilogramPerSecondPerSquareCentimeter, "KilogramPerSecondPerSquareCentimeter", "KilogramsPerSecondPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
+                yield return new (MassFluxUnit.GramPerHourPerSquareCentimeter, "GramPerHourPerSquareCentimeter", "GramsPerHourPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram, time: DurationUnit.Hour),
+                     360
+                );
+                yield return new (MassFluxUnit.GramPerHourPerSquareMeter, "GramPerHourPerSquareMeter", "GramsPerHourPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Hour),
+                     3600000
+                );
+                yield return new (MassFluxUnit.GramPerHourPerSquareMillimeter, "GramPerHourPerSquareMillimeter", "GramsPerHourPerSquareMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram, time: DurationUnit.Hour),
+                     new QuantityValue(18, 5)
+                );
+                yield return new (MassFluxUnit.GramPerSecondPerSquareCentimeter, "GramPerSecondPerSquareCentimeter", "GramsPerSecondPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (MassFluxUnit.GramPerSecondPerSquareMeter, "GramPerSecondPerSquareMeter", "GramsPerSecondPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (MassFluxUnit.GramPerSecondPerSquareMillimeter, "GramPerSecondPerSquareMillimeter", "GramsPerSecondPerSquareMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MassFluxUnit.KilogramPerHourPerSquareCentimeter, "KilogramPerHourPerSquareCentimeter", "KilogramsPerHourPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Hour),
+                     new QuantityValue(9, 25)
+                );
+                yield return new (MassFluxUnit.KilogramPerHourPerSquareMeter, "KilogramPerHourPerSquareMeter", "KilogramsPerHourPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Hour),
+                     3600
+                );
+                yield return new (MassFluxUnit.KilogramPerHourPerSquareMillimeter, "KilogramPerHourPerSquareMillimeter", "KilogramsPerHourPerSquareMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Hour),
+                     new QuantityValue(9, 2500)
+                );
+                yield return new (MassFluxUnit.KilogramPerSecondPerSquareCentimeter, "KilogramPerSecondPerSquareCentimeter", "KilogramsPerSecondPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 10000)
+                );
                 yield return new (MassFluxUnit.KilogramPerSecondPerSquareMeter, "KilogramPerSecondPerSquareMeter", "KilogramsPerSecondPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (MassFluxUnit.KilogramPerSecondPerSquareMillimeter, "KilogramPerSecondPerSquareMillimeter", "KilogramsPerSecondPerSquareMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
+                yield return new (MassFluxUnit.KilogramPerSecondPerSquareMillimeter, "KilogramPerSecondPerSquareMillimeter", "KilogramsPerSecondPerSquareMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
             }
         }
 
         static MassFlux()
         {
-            Info = MassFluxInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MassFluxInfo.CreateDefault);
         }
 
         /// <summary>
@@ -147,7 +166,7 @@ static MassFlux()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MassFlux(double value, MassFluxUnit unit)
+        public MassFlux(QuantityValue value, MassFluxUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -161,7 +180,7 @@ public MassFlux(double value, MassFluxUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MassFlux(double value, UnitSystem unitSystem)
+        public MassFlux(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -172,7 +191,8 @@ public MassFlux(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MassFlux" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MassFlux, MassFluxUnit> Info { get; }
@@ -201,10 +221,8 @@ public MassFlux(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MassFluxUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -238,105 +256,69 @@ public MassFlux(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerHourPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerHourPerSquareCentimeter"/>
         /// </summary>
-        public double GramsPerHourPerSquareCentimeter => As(MassFluxUnit.GramPerHourPerSquareCentimeter);
+        public QuantityValue GramsPerHourPerSquareCentimeter => this.As(MassFluxUnit.GramPerHourPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerHourPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerHourPerSquareMeter"/>
         /// </summary>
-        public double GramsPerHourPerSquareMeter => As(MassFluxUnit.GramPerHourPerSquareMeter);
+        public QuantityValue GramsPerHourPerSquareMeter => this.As(MassFluxUnit.GramPerHourPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerHourPerSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerHourPerSquareMillimeter"/>
         /// </summary>
-        public double GramsPerHourPerSquareMillimeter => As(MassFluxUnit.GramPerHourPerSquareMillimeter);
+        public QuantityValue GramsPerHourPerSquareMillimeter => this.As(MassFluxUnit.GramPerHourPerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerSecondPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerSecondPerSquareCentimeter"/>
         /// </summary>
-        public double GramsPerSecondPerSquareCentimeter => As(MassFluxUnit.GramPerSecondPerSquareCentimeter);
+        public QuantityValue GramsPerSecondPerSquareCentimeter => this.As(MassFluxUnit.GramPerSecondPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerSecondPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerSecondPerSquareMeter"/>
         /// </summary>
-        public double GramsPerSecondPerSquareMeter => As(MassFluxUnit.GramPerSecondPerSquareMeter);
+        public QuantityValue GramsPerSecondPerSquareMeter => this.As(MassFluxUnit.GramPerSecondPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerSecondPerSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.GramPerSecondPerSquareMillimeter"/>
         /// </summary>
-        public double GramsPerSecondPerSquareMillimeter => As(MassFluxUnit.GramPerSecondPerSquareMillimeter);
+        public QuantityValue GramsPerSecondPerSquareMillimeter => this.As(MassFluxUnit.GramPerSecondPerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerHourPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerHourPerSquareCentimeter"/>
         /// </summary>
-        public double KilogramsPerHourPerSquareCentimeter => As(MassFluxUnit.KilogramPerHourPerSquareCentimeter);
+        public QuantityValue KilogramsPerHourPerSquareCentimeter => this.As(MassFluxUnit.KilogramPerHourPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerHourPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerHourPerSquareMeter"/>
         /// </summary>
-        public double KilogramsPerHourPerSquareMeter => As(MassFluxUnit.KilogramPerHourPerSquareMeter);
+        public QuantityValue KilogramsPerHourPerSquareMeter => this.As(MassFluxUnit.KilogramPerHourPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerHourPerSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerHourPerSquareMillimeter"/>
         /// </summary>
-        public double KilogramsPerHourPerSquareMillimeter => As(MassFluxUnit.KilogramPerHourPerSquareMillimeter);
+        public QuantityValue KilogramsPerHourPerSquareMillimeter => this.As(MassFluxUnit.KilogramPerHourPerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerSecondPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerSecondPerSquareCentimeter"/>
         /// </summary>
-        public double KilogramsPerSecondPerSquareCentimeter => As(MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
+        public QuantityValue KilogramsPerSecondPerSquareCentimeter => this.As(MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerSecondPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerSecondPerSquareMeter"/>
         /// </summary>
-        public double KilogramsPerSecondPerSquareMeter => As(MassFluxUnit.KilogramPerSecondPerSquareMeter);
+        public QuantityValue KilogramsPerSecondPerSquareMeter => this.As(MassFluxUnit.KilogramPerSecondPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerSecondPerSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFluxUnit.KilogramPerSecondPerSquareMillimeter"/>
         /// </summary>
-        public double KilogramsPerSecondPerSquareMillimeter => As(MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
+        public QuantityValue KilogramsPerSecondPerSquareMillimeter => this.As(MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MassFluxUnit -> BaseUnit
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerHourPerSquareCentimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerHourPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerHourPerSquareMillimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerSecondPerSquareCentimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.GramPerSecondPerSquareMillimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerHourPerSquareCentimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerHourPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerHourPerSquareMillimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareCentimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMillimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MassFluxUnit
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerHourPerSquareCentimeter, quantity => quantity.ToUnit(MassFluxUnit.GramPerHourPerSquareCentimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerHourPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.GramPerHourPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerHourPerSquareMillimeter, quantity => quantity.ToUnit(MassFluxUnit.GramPerHourPerSquareMillimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerSecondPerSquareCentimeter, quantity => quantity.ToUnit(MassFluxUnit.GramPerSecondPerSquareCentimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerSecondPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.GramPerSecondPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerSecondPerSquareMillimeter, quantity => quantity.ToUnit(MassFluxUnit.GramPerSecondPerSquareMillimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerHourPerSquareCentimeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerHourPerSquareCentimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerHourPerSquareMeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerHourPerSquareMeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerHourPerSquareMillimeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerHourPerSquareMillimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareCentimeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareCentimeter));
-            unitConverter.SetConversionFunction<MassFlux>(MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareMillimeter, quantity => quantity.ToUnit(MassFluxUnit.KilogramPerSecondPerSquareMillimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -365,7 +347,7 @@ public static string GetAbbreviation(MassFluxUnit unit, IFormatProvider? provide
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareCentimeter"/>.
         /// </summary>
-        public static MassFlux FromGramsPerHourPerSquareCentimeter(double value)
+        public static MassFlux FromGramsPerHourPerSquareCentimeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareCentimeter);
         }
@@ -373,7 +355,7 @@ public static MassFlux FromGramsPerHourPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareMeter"/>.
         /// </summary>
-        public static MassFlux FromGramsPerHourPerSquareMeter(double value)
+        public static MassFlux FromGramsPerHourPerSquareMeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMeter);
         }
@@ -381,7 +363,7 @@ public static MassFlux FromGramsPerHourPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareMillimeter"/>.
         /// </summary>
-        public static MassFlux FromGramsPerHourPerSquareMillimeter(double value)
+        public static MassFlux FromGramsPerHourPerSquareMillimeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMillimeter);
         }
@@ -389,7 +371,7 @@ public static MassFlux FromGramsPerHourPerSquareMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareCentimeter"/>.
         /// </summary>
-        public static MassFlux FromGramsPerSecondPerSquareCentimeter(double value)
+        public static MassFlux FromGramsPerSecondPerSquareCentimeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareCentimeter);
         }
@@ -397,7 +379,7 @@ public static MassFlux FromGramsPerSecondPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareMeter"/>.
         /// </summary>
-        public static MassFlux FromGramsPerSecondPerSquareMeter(double value)
+        public static MassFlux FromGramsPerSecondPerSquareMeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMeter);
         }
@@ -405,7 +387,7 @@ public static MassFlux FromGramsPerSecondPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareMillimeter"/>.
         /// </summary>
-        public static MassFlux FromGramsPerSecondPerSquareMillimeter(double value)
+        public static MassFlux FromGramsPerSecondPerSquareMillimeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMillimeter);
         }
@@ -413,7 +395,7 @@ public static MassFlux FromGramsPerSecondPerSquareMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareCentimeter"/>.
         /// </summary>
-        public static MassFlux FromKilogramsPerHourPerSquareCentimeter(double value)
+        public static MassFlux FromKilogramsPerHourPerSquareCentimeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareCentimeter);
         }
@@ -421,7 +403,7 @@ public static MassFlux FromKilogramsPerHourPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareMeter"/>.
         /// </summary>
-        public static MassFlux FromKilogramsPerHourPerSquareMeter(double value)
+        public static MassFlux FromKilogramsPerHourPerSquareMeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMeter);
         }
@@ -429,7 +411,7 @@ public static MassFlux FromKilogramsPerHourPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareMillimeter"/>.
         /// </summary>
-        public static MassFlux FromKilogramsPerHourPerSquareMillimeter(double value)
+        public static MassFlux FromKilogramsPerHourPerSquareMillimeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMillimeter);
         }
@@ -437,7 +419,7 @@ public static MassFlux FromKilogramsPerHourPerSquareMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareCentimeter"/>.
         /// </summary>
-        public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(double value)
+        public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
         }
@@ -445,7 +427,7 @@ public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareMeter"/>.
         /// </summary>
-        public static MassFlux FromKilogramsPerSecondPerSquareMeter(double value)
+        public static MassFlux FromKilogramsPerSecondPerSquareMeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMeter);
         }
@@ -453,7 +435,7 @@ public static MassFlux FromKilogramsPerSecondPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareMillimeter"/>.
         /// </summary>
-        public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(double value)
+        public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(QuantityValue value)
         {
             return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
         }
@@ -464,7 +446,7 @@ public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MassFlux unit value.</returns>
-        public static MassFlux From(double value, MassFluxUnit fromUnit)
+        public static MassFlux From(QuantityValue value, MassFluxUnit fromUnit)
         {
             return new MassFlux(value, fromUnit);
         }
@@ -525,10 +507,7 @@ public static MassFlux Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MassFlux Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MassFlux, MassFluxUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MassFlux, MassFluxUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -556,11 +535,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MassFlux result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassFlux result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MassFlux, MassFluxUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MassFlux, MassFluxUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -581,7 +556,7 @@ public static MassFluxUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -592,7 +567,7 @@ public static MassFluxUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassFluxUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MassFluxUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassFluxUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -607,7 +582,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassFluxUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassFluxUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -626,35 +601,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MassFlux"/> from adding two <see cref="MassFlux"/>.</summary>
         public static MassFlux operator +(MassFlux left, MassFlux right)
         {
-            return new MassFlux(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MassFlux(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MassFlux"/> from subtracting two <see cref="MassFlux"/>.</summary>
         public static MassFlux operator -(MassFlux left, MassFlux right)
         {
-            return new MassFlux(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MassFlux(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MassFlux"/> from multiplying value and <see cref="MassFlux"/>.</summary>
-        public static MassFlux operator *(double left, MassFlux right)
+        public static MassFlux operator *(QuantityValue left, MassFlux right)
         {
             return new MassFlux(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MassFlux"/> from multiplying value and <see cref="MassFlux"/>.</summary>
-        public static MassFlux operator *(MassFlux left, double right)
+        public static MassFlux operator *(MassFlux left, QuantityValue right)
         {
             return new MassFlux(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MassFlux"/> from dividing <see cref="MassFlux"/> by value.</summary>
-        public static MassFlux operator /(MassFlux left, double right)
+        public static MassFlux operator /(MassFlux left, QuantityValue right)
         {
             return new MassFlux(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MassFlux"/> by <see cref="MassFlux"/>.</summary>
-        public static double operator /(MassFlux left, MassFlux right)
+        public static QuantityValue operator /(MassFlux left, MassFlux right)
         {
             return left.KilogramsPerSecondPerSquareMeter / right.KilogramsPerSecondPerSquareMeter;
         }
@@ -688,97 +663,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MassFlux left, MassFlux right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MassFlux left, MassFlux right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MassFlux left, MassFlux right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MassFlux left, MassFlux right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MassFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MassFlux other, MassFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MassFlux"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MassFlux)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MassFlux left, MassFlux right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MassFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MassFlux other, MassFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MassFlux"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MassFlux,MassFlux)"/>.
+        ///     See that operator (and <see cref="Equals(MassFlux)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MassFlux left, MassFlux right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MassFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MassFlux other, MassFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MassFlux"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MassFlux"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MassFlux"/>, this method delegates to
+        ///     <see cref="Equals(MassFlux)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MassFlux otherQuantity))
+            if (obj is not MassFlux otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MassFlux"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MassFlux other, MassFlux tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MassFlux"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MassFlux other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MassFlux.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MassFlux), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MassFlux"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MassFlux)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MassFlux otherQuantity)) throw new ArgumentException("Expected type MassFlux.", nameof(obj));
+            if (obj is not MassFlux otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MassFlux>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MassFlux"/> with another <see cref="MassFlux"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MassFlux"/> with another <see cref="MassFlux"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -790,151 +779,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MassFlux other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassFluxUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MassFluxUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this MassFlux to another MassFlux with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MassFlux with the specified unit.</returns>
-        public MassFlux ToUnit(MassFluxUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="MassFlux"/> to another <see cref="MassFlux"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MassFlux with the specified unit.</returns>
-        public MassFlux ToUnit(MassFluxUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MassFlux), Unit, typeof(MassFlux), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MassFlux)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="MassFlux"/> to another <see cref="MassFlux"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MassFlux"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MassFluxUnit unit, [NotNullWhen(true)] out MassFlux? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MassFlux? convertedOrNull = (Unit, unit) switch
-            {
-                // MassFluxUnit -> BaseUnit
-                (MassFluxUnit.GramPerHourPerSquareCentimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux(_value / 3.6e2, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-                (MassFluxUnit.GramPerHourPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux(_value / 3.6e6, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-                (MassFluxUnit.GramPerHourPerSquareMillimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux(_value / 3.6e0, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-                (MassFluxUnit.GramPerSecondPerSquareCentimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux(_value / 1e-1, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-                (MassFluxUnit.GramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux(_value / 1e3, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-                (MassFluxUnit.GramPerSecondPerSquareMillimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux(_value / 1e-3, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-                (MassFluxUnit.KilogramPerHourPerSquareCentimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux((_value / 3.6e2) * 1e3d, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-                (MassFluxUnit.KilogramPerHourPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux((_value / 3.6e6) * 1e3d, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-                (MassFluxUnit.KilogramPerHourPerSquareMillimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux((_value / 3.6e0) * 1e3d, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareCentimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux((_value / 1e-1) * 1e3d, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMillimeter, MassFluxUnit.KilogramPerSecondPerSquareMeter) => new MassFlux((_value / 1e-3) * 1e3d, MassFluxUnit.KilogramPerSecondPerSquareMeter),
-
-                // BaseUnit -> MassFluxUnit
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerHourPerSquareCentimeter) => new MassFlux(_value * 3.6e2, MassFluxUnit.GramPerHourPerSquareCentimeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerHourPerSquareMeter) => new MassFlux(_value * 3.6e6, MassFluxUnit.GramPerHourPerSquareMeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerHourPerSquareMillimeter) => new MassFlux(_value * 3.6e0, MassFluxUnit.GramPerHourPerSquareMillimeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerSecondPerSquareCentimeter) => new MassFlux(_value * 1e-1, MassFluxUnit.GramPerSecondPerSquareCentimeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerSecondPerSquareMeter) => new MassFlux(_value * 1e3, MassFluxUnit.GramPerSecondPerSquareMeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.GramPerSecondPerSquareMillimeter) => new MassFlux(_value * 1e-3, MassFluxUnit.GramPerSecondPerSquareMillimeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerHourPerSquareCentimeter) => new MassFlux((_value * 3.6e2) / 1e3d, MassFluxUnit.KilogramPerHourPerSquareCentimeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerHourPerSquareMeter) => new MassFlux((_value * 3.6e6) / 1e3d, MassFluxUnit.KilogramPerHourPerSquareMeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerHourPerSquareMillimeter) => new MassFlux((_value * 3.6e0) / 1e3d, MassFluxUnit.KilogramPerHourPerSquareMillimeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareCentimeter) => new MassFlux((_value * 1e-1) / 1e3d, MassFluxUnit.KilogramPerSecondPerSquareCentimeter),
-                (MassFluxUnit.KilogramPerSecondPerSquareMeter, MassFluxUnit.KilogramPerSecondPerSquareMillimeter) => new MassFlux((_value * 1e-3) / 1e3d, MassFluxUnit.KilogramPerSecondPerSquareMillimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MassFluxUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFluxUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MassFluxUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFluxUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MassFluxUnit> IQuantity<MassFluxUnit>.ToUnit(MassFluxUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -948,11 +795,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
index 5a3a2755f9..1e123048ec 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Mass_fraction_(chemistry)
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MassFraction :
-        IArithmeticQuantity<MassFraction, MassFractionUnit>,
+        ILinearQuantity<MassFraction, MassFractionUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MassFraction, MassFraction, double>,
+        IDivisionOperators<MassFraction, MassFraction, QuantityValue>,
         IMultiplyOperators<MassFraction, Mass, Mass>,
         IComparisonOperators<MassFraction, MassFraction, bool>,
         IParsable<MassFraction>,
@@ -56,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -121,38 +120,82 @@ public static MassFractionInfo CreateDefault(Func<IEnumerable<UnitDefinition<Mas
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MassFractionUnit}"/> representing the default unit mappings for MassFraction.</returns>
             public static IEnumerable<UnitDefinition<MassFractionUnit>> GetDefaultMappings()
             {
-                yield return new (MassFractionUnit.CentigramPerGram, "CentigramPerGram", "CentigramsPerGram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.CentigramPerKilogram, "CentigramPerKilogram", "CentigramsPerKilogram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.DecagramPerGram, "DecagramPerGram", "DecagramsPerGram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.DecagramPerKilogram, "DecagramPerKilogram", "DecagramsPerKilogram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.DecigramPerGram, "DecigramPerGram", "DecigramsPerGram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.DecigramPerKilogram, "DecigramPerKilogram", "DecigramsPerKilogram", BaseUnits.Undefined);
+                yield return new (MassFractionUnit.CentigramPerGram, "CentigramPerGram", "CentigramsPerGram", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (MassFractionUnit.CentigramPerKilogram, "CentigramPerKilogram", "CentigramsPerKilogram", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (MassFractionUnit.DecagramPerGram, "DecagramPerGram", "DecagramsPerGram", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (MassFractionUnit.DecagramPerKilogram, "DecagramPerKilogram", "DecagramsPerKilogram", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (MassFractionUnit.DecigramPerGram, "DecigramPerGram", "DecigramsPerGram", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (MassFractionUnit.DecigramPerKilogram, "DecigramPerKilogram", "DecigramsPerKilogram", BaseUnits.Undefined,
+                     10000
+                );
                 yield return new (MassFractionUnit.DecimalFraction, "DecimalFraction", "DecimalFractions", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.GramPerGram, "GramPerGram", "GramsPerGram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.GramPerKilogram, "GramPerKilogram", "GramsPerKilogram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.HectogramPerGram, "HectogramPerGram", "HectogramsPerGram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.HectogramPerKilogram, "HectogramPerKilogram", "HectogramsPerKilogram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.KilogramPerGram, "KilogramPerGram", "KilogramsPerGram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.KilogramPerKilogram, "KilogramPerKilogram", "KilogramsPerKilogram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.MicrogramPerGram, "MicrogramPerGram", "MicrogramsPerGram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.MicrogramPerKilogram, "MicrogramPerKilogram", "MicrogramsPerKilogram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.MilligramPerGram, "MilligramPerGram", "MilligramsPerGram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.MilligramPerKilogram, "MilligramPerKilogram", "MilligramsPerKilogram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.NanogramPerGram, "NanogramPerGram", "NanogramsPerGram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.NanogramPerKilogram, "NanogramPerKilogram", "NanogramsPerKilogram", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.PartPerBillion, "PartPerBillion", "PartsPerBillion", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.PartPerMillion, "PartPerMillion", "PartsPerMillion", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.PartPerThousand, "PartPerThousand", "PartsPerThousand", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.PartPerTrillion, "PartPerTrillion", "PartsPerTrillion", BaseUnits.Undefined);
-                yield return new (MassFractionUnit.Percent, "Percent", "Percent", BaseUnits.Undefined);
+                yield return new (MassFractionUnit.GramPerGram, "GramPerGram", "GramsPerGram", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (MassFractionUnit.GramPerKilogram, "GramPerKilogram", "GramsPerKilogram", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (MassFractionUnit.HectogramPerGram, "HectogramPerGram", "HectogramsPerGram", BaseUnits.Undefined,
+                     new QuantityValue(1, 100)
+                );
+                yield return new (MassFractionUnit.HectogramPerKilogram, "HectogramPerKilogram", "HectogramsPerKilogram", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (MassFractionUnit.KilogramPerGram, "KilogramPerGram", "KilogramsPerGram", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MassFractionUnit.KilogramPerKilogram, "KilogramPerKilogram", "KilogramsPerKilogram", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (MassFractionUnit.MicrogramPerGram, "MicrogramPerGram", "MicrogramsPerGram", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (MassFractionUnit.MicrogramPerKilogram, "MicrogramPerKilogram", "MicrogramsPerKilogram", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (MassFractionUnit.MilligramPerGram, "MilligramPerGram", "MilligramsPerGram", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (MassFractionUnit.MilligramPerKilogram, "MilligramPerKilogram", "MilligramsPerKilogram", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (MassFractionUnit.NanogramPerGram, "NanogramPerGram", "NanogramsPerGram", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (MassFractionUnit.NanogramPerKilogram, "NanogramPerKilogram", "NanogramsPerKilogram", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (MassFractionUnit.PartPerBillion, "PartPerBillion", "PartsPerBillion", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (MassFractionUnit.PartPerMillion, "PartPerMillion", "PartsPerMillion", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (MassFractionUnit.PartPerThousand, "PartPerThousand", "PartsPerThousand", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (MassFractionUnit.PartPerTrillion, "PartPerTrillion", "PartsPerTrillion", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (MassFractionUnit.Percent, "Percent", "Percent", BaseUnits.Undefined,
+                     100
+                );
             }
         }
 
         static MassFraction()
         {
-            Info = MassFractionInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MassFractionInfo.CreateDefault);
         }
 
         /// <summary>
@@ -160,7 +203,7 @@ static MassFraction()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MassFraction(double value, MassFractionUnit unit)
+        public MassFraction(QuantityValue value, MassFractionUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -171,7 +214,8 @@ public MassFraction(double value, MassFractionUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MassFraction" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MassFraction, MassFractionUnit> Info { get; }
@@ -200,10 +244,8 @@ public MassFraction(double value, MassFractionUnit unit)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MassFractionUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -237,189 +279,129 @@ public MassFraction(double value, MassFractionUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.CentigramPerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.CentigramPerGram"/>
         /// </summary>
-        public double CentigramsPerGram => As(MassFractionUnit.CentigramPerGram);
+        public QuantityValue CentigramsPerGram => this.As(MassFractionUnit.CentigramPerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.CentigramPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.CentigramPerKilogram"/>
         /// </summary>
-        public double CentigramsPerKilogram => As(MassFractionUnit.CentigramPerKilogram);
+        public QuantityValue CentigramsPerKilogram => this.As(MassFractionUnit.CentigramPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.DecagramPerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.DecagramPerGram"/>
         /// </summary>
-        public double DecagramsPerGram => As(MassFractionUnit.DecagramPerGram);
+        public QuantityValue DecagramsPerGram => this.As(MassFractionUnit.DecagramPerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.DecagramPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.DecagramPerKilogram"/>
         /// </summary>
-        public double DecagramsPerKilogram => As(MassFractionUnit.DecagramPerKilogram);
+        public QuantityValue DecagramsPerKilogram => this.As(MassFractionUnit.DecagramPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.DecigramPerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.DecigramPerGram"/>
         /// </summary>
-        public double DecigramsPerGram => As(MassFractionUnit.DecigramPerGram);
+        public QuantityValue DecigramsPerGram => this.As(MassFractionUnit.DecigramPerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.DecigramPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.DecigramPerKilogram"/>
         /// </summary>
-        public double DecigramsPerKilogram => As(MassFractionUnit.DecigramPerKilogram);
+        public QuantityValue DecigramsPerKilogram => this.As(MassFractionUnit.DecigramPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.DecimalFraction"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.DecimalFraction"/>
         /// </summary>
-        public double DecimalFractions => As(MassFractionUnit.DecimalFraction);
+        public QuantityValue DecimalFractions => this.As(MassFractionUnit.DecimalFraction);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.GramPerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.GramPerGram"/>
         /// </summary>
-        public double GramsPerGram => As(MassFractionUnit.GramPerGram);
+        public QuantityValue GramsPerGram => this.As(MassFractionUnit.GramPerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.GramPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.GramPerKilogram"/>
         /// </summary>
-        public double GramsPerKilogram => As(MassFractionUnit.GramPerKilogram);
+        public QuantityValue GramsPerKilogram => this.As(MassFractionUnit.GramPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.HectogramPerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.HectogramPerGram"/>
         /// </summary>
-        public double HectogramsPerGram => As(MassFractionUnit.HectogramPerGram);
+        public QuantityValue HectogramsPerGram => this.As(MassFractionUnit.HectogramPerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.HectogramPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.HectogramPerKilogram"/>
         /// </summary>
-        public double HectogramsPerKilogram => As(MassFractionUnit.HectogramPerKilogram);
+        public QuantityValue HectogramsPerKilogram => this.As(MassFractionUnit.HectogramPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.KilogramPerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.KilogramPerGram"/>
         /// </summary>
-        public double KilogramsPerGram => As(MassFractionUnit.KilogramPerGram);
+        public QuantityValue KilogramsPerGram => this.As(MassFractionUnit.KilogramPerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.KilogramPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.KilogramPerKilogram"/>
         /// </summary>
-        public double KilogramsPerKilogram => As(MassFractionUnit.KilogramPerKilogram);
+        public QuantityValue KilogramsPerKilogram => this.As(MassFractionUnit.KilogramPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.MicrogramPerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.MicrogramPerGram"/>
         /// </summary>
-        public double MicrogramsPerGram => As(MassFractionUnit.MicrogramPerGram);
+        public QuantityValue MicrogramsPerGram => this.As(MassFractionUnit.MicrogramPerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.MicrogramPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.MicrogramPerKilogram"/>
         /// </summary>
-        public double MicrogramsPerKilogram => As(MassFractionUnit.MicrogramPerKilogram);
+        public QuantityValue MicrogramsPerKilogram => this.As(MassFractionUnit.MicrogramPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.MilligramPerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.MilligramPerGram"/>
         /// </summary>
-        public double MilligramsPerGram => As(MassFractionUnit.MilligramPerGram);
+        public QuantityValue MilligramsPerGram => this.As(MassFractionUnit.MilligramPerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.MilligramPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.MilligramPerKilogram"/>
         /// </summary>
-        public double MilligramsPerKilogram => As(MassFractionUnit.MilligramPerKilogram);
+        public QuantityValue MilligramsPerKilogram => this.As(MassFractionUnit.MilligramPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.NanogramPerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.NanogramPerGram"/>
         /// </summary>
-        public double NanogramsPerGram => As(MassFractionUnit.NanogramPerGram);
+        public QuantityValue NanogramsPerGram => this.As(MassFractionUnit.NanogramPerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.NanogramPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.NanogramPerKilogram"/>
         /// </summary>
-        public double NanogramsPerKilogram => As(MassFractionUnit.NanogramPerKilogram);
+        public QuantityValue NanogramsPerKilogram => this.As(MassFractionUnit.NanogramPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerBillion"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerBillion"/>
         /// </summary>
-        public double PartsPerBillion => As(MassFractionUnit.PartPerBillion);
+        public QuantityValue PartsPerBillion => this.As(MassFractionUnit.PartPerBillion);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerMillion"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerMillion"/>
         /// </summary>
-        public double PartsPerMillion => As(MassFractionUnit.PartPerMillion);
+        public QuantityValue PartsPerMillion => this.As(MassFractionUnit.PartPerMillion);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerThousand"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerThousand"/>
         /// </summary>
-        public double PartsPerThousand => As(MassFractionUnit.PartPerThousand);
+        public QuantityValue PartsPerThousand => this.As(MassFractionUnit.PartPerThousand);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerTrillion"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.PartPerTrillion"/>
         /// </summary>
-        public double PartsPerTrillion => As(MassFractionUnit.PartPerTrillion);
+        public QuantityValue PartsPerTrillion => this.As(MassFractionUnit.PartPerTrillion);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassFractionUnit.Percent"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassFractionUnit.Percent"/>
         /// </summary>
-        public double Percent => As(MassFractionUnit.Percent);
+        public QuantityValue Percent => this.As(MassFractionUnit.Percent);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MassFractionUnit -> BaseUnit
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.CentigramPerGram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.CentigramPerKilogram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecagramPerGram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecagramPerKilogram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecigramPerGram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecigramPerKilogram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.GramPerGram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.GramPerKilogram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.HectogramPerGram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.HectogramPerKilogram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.KilogramPerGram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.KilogramPerKilogram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.MicrogramPerGram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.MicrogramPerKilogram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.MilligramPerGram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.MilligramPerKilogram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.NanogramPerGram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.NanogramPerKilogram, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.PartPerBillion, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.PartPerMillion, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.PartPerThousand, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.PartPerTrillion, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.Percent, MassFractionUnit.DecimalFraction, quantity => quantity.ToUnit(MassFractionUnit.DecimalFraction));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.DecimalFraction, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MassFractionUnit
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.CentigramPerGram, quantity => quantity.ToUnit(MassFractionUnit.CentigramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.CentigramPerKilogram, quantity => quantity.ToUnit(MassFractionUnit.CentigramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.DecagramPerGram, quantity => quantity.ToUnit(MassFractionUnit.DecagramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.DecagramPerKilogram, quantity => quantity.ToUnit(MassFractionUnit.DecagramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.DecigramPerGram, quantity => quantity.ToUnit(MassFractionUnit.DecigramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.DecigramPerKilogram, quantity => quantity.ToUnit(MassFractionUnit.DecigramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.GramPerGram, quantity => quantity.ToUnit(MassFractionUnit.GramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.GramPerKilogram, quantity => quantity.ToUnit(MassFractionUnit.GramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.HectogramPerGram, quantity => quantity.ToUnit(MassFractionUnit.HectogramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.HectogramPerKilogram, quantity => quantity.ToUnit(MassFractionUnit.HectogramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.KilogramPerGram, quantity => quantity.ToUnit(MassFractionUnit.KilogramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.KilogramPerKilogram, quantity => quantity.ToUnit(MassFractionUnit.KilogramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.MicrogramPerGram, quantity => quantity.ToUnit(MassFractionUnit.MicrogramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.MicrogramPerKilogram, quantity => quantity.ToUnit(MassFractionUnit.MicrogramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.MilligramPerGram, quantity => quantity.ToUnit(MassFractionUnit.MilligramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.MilligramPerKilogram, quantity => quantity.ToUnit(MassFractionUnit.MilligramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.NanogramPerGram, quantity => quantity.ToUnit(MassFractionUnit.NanogramPerGram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.NanogramPerKilogram, quantity => quantity.ToUnit(MassFractionUnit.NanogramPerKilogram));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.PartPerBillion, quantity => quantity.ToUnit(MassFractionUnit.PartPerBillion));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.PartPerMillion, quantity => quantity.ToUnit(MassFractionUnit.PartPerMillion));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.PartPerThousand, quantity => quantity.ToUnit(MassFractionUnit.PartPerThousand));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.PartPerTrillion, quantity => quantity.ToUnit(MassFractionUnit.PartPerTrillion));
-            unitConverter.SetConversionFunction<MassFraction>(MassFractionUnit.DecimalFraction, MassFractionUnit.Percent, quantity => quantity.ToUnit(MassFractionUnit.Percent));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -448,7 +430,7 @@ public static string GetAbbreviation(MassFractionUnit unit, IFormatProvider? pro
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.CentigramPerGram"/>.
         /// </summary>
-        public static MassFraction FromCentigramsPerGram(double value)
+        public static MassFraction FromCentigramsPerGram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.CentigramPerGram);
         }
@@ -456,7 +438,7 @@ public static MassFraction FromCentigramsPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.CentigramPerKilogram"/>.
         /// </summary>
-        public static MassFraction FromCentigramsPerKilogram(double value)
+        public static MassFraction FromCentigramsPerKilogram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.CentigramPerKilogram);
         }
@@ -464,7 +446,7 @@ public static MassFraction FromCentigramsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecagramPerGram"/>.
         /// </summary>
-        public static MassFraction FromDecagramsPerGram(double value)
+        public static MassFraction FromDecagramsPerGram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.DecagramPerGram);
         }
@@ -472,7 +454,7 @@ public static MassFraction FromDecagramsPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecagramPerKilogram"/>.
         /// </summary>
-        public static MassFraction FromDecagramsPerKilogram(double value)
+        public static MassFraction FromDecagramsPerKilogram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.DecagramPerKilogram);
         }
@@ -480,7 +462,7 @@ public static MassFraction FromDecagramsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecigramPerGram"/>.
         /// </summary>
-        public static MassFraction FromDecigramsPerGram(double value)
+        public static MassFraction FromDecigramsPerGram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.DecigramPerGram);
         }
@@ -488,7 +470,7 @@ public static MassFraction FromDecigramsPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecigramPerKilogram"/>.
         /// </summary>
-        public static MassFraction FromDecigramsPerKilogram(double value)
+        public static MassFraction FromDecigramsPerKilogram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.DecigramPerKilogram);
         }
@@ -496,7 +478,7 @@ public static MassFraction FromDecigramsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecimalFraction"/>.
         /// </summary>
-        public static MassFraction FromDecimalFractions(double value)
+        public static MassFraction FromDecimalFractions(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.DecimalFraction);
         }
@@ -504,7 +486,7 @@ public static MassFraction FromDecimalFractions(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.GramPerGram"/>.
         /// </summary>
-        public static MassFraction FromGramsPerGram(double value)
+        public static MassFraction FromGramsPerGram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.GramPerGram);
         }
@@ -512,7 +494,7 @@ public static MassFraction FromGramsPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.GramPerKilogram"/>.
         /// </summary>
-        public static MassFraction FromGramsPerKilogram(double value)
+        public static MassFraction FromGramsPerKilogram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.GramPerKilogram);
         }
@@ -520,7 +502,7 @@ public static MassFraction FromGramsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.HectogramPerGram"/>.
         /// </summary>
-        public static MassFraction FromHectogramsPerGram(double value)
+        public static MassFraction FromHectogramsPerGram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.HectogramPerGram);
         }
@@ -528,7 +510,7 @@ public static MassFraction FromHectogramsPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.HectogramPerKilogram"/>.
         /// </summary>
-        public static MassFraction FromHectogramsPerKilogram(double value)
+        public static MassFraction FromHectogramsPerKilogram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.HectogramPerKilogram);
         }
@@ -536,7 +518,7 @@ public static MassFraction FromHectogramsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.KilogramPerGram"/>.
         /// </summary>
-        public static MassFraction FromKilogramsPerGram(double value)
+        public static MassFraction FromKilogramsPerGram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.KilogramPerGram);
         }
@@ -544,7 +526,7 @@ public static MassFraction FromKilogramsPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.KilogramPerKilogram"/>.
         /// </summary>
-        public static MassFraction FromKilogramsPerKilogram(double value)
+        public static MassFraction FromKilogramsPerKilogram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.KilogramPerKilogram);
         }
@@ -552,7 +534,7 @@ public static MassFraction FromKilogramsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MicrogramPerGram"/>.
         /// </summary>
-        public static MassFraction FromMicrogramsPerGram(double value)
+        public static MassFraction FromMicrogramsPerGram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.MicrogramPerGram);
         }
@@ -560,7 +542,7 @@ public static MassFraction FromMicrogramsPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MicrogramPerKilogram"/>.
         /// </summary>
-        public static MassFraction FromMicrogramsPerKilogram(double value)
+        public static MassFraction FromMicrogramsPerKilogram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.MicrogramPerKilogram);
         }
@@ -568,7 +550,7 @@ public static MassFraction FromMicrogramsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MilligramPerGram"/>.
         /// </summary>
-        public static MassFraction FromMilligramsPerGram(double value)
+        public static MassFraction FromMilligramsPerGram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.MilligramPerGram);
         }
@@ -576,7 +558,7 @@ public static MassFraction FromMilligramsPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MilligramPerKilogram"/>.
         /// </summary>
-        public static MassFraction FromMilligramsPerKilogram(double value)
+        public static MassFraction FromMilligramsPerKilogram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.MilligramPerKilogram);
         }
@@ -584,7 +566,7 @@ public static MassFraction FromMilligramsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.NanogramPerGram"/>.
         /// </summary>
-        public static MassFraction FromNanogramsPerGram(double value)
+        public static MassFraction FromNanogramsPerGram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.NanogramPerGram);
         }
@@ -592,7 +574,7 @@ public static MassFraction FromNanogramsPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.NanogramPerKilogram"/>.
         /// </summary>
-        public static MassFraction FromNanogramsPerKilogram(double value)
+        public static MassFraction FromNanogramsPerKilogram(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.NanogramPerKilogram);
         }
@@ -600,7 +582,7 @@ public static MassFraction FromNanogramsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerBillion"/>.
         /// </summary>
-        public static MassFraction FromPartsPerBillion(double value)
+        public static MassFraction FromPartsPerBillion(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.PartPerBillion);
         }
@@ -608,7 +590,7 @@ public static MassFraction FromPartsPerBillion(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerMillion"/>.
         /// </summary>
-        public static MassFraction FromPartsPerMillion(double value)
+        public static MassFraction FromPartsPerMillion(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.PartPerMillion);
         }
@@ -616,7 +598,7 @@ public static MassFraction FromPartsPerMillion(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerThousand"/>.
         /// </summary>
-        public static MassFraction FromPartsPerThousand(double value)
+        public static MassFraction FromPartsPerThousand(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.PartPerThousand);
         }
@@ -624,7 +606,7 @@ public static MassFraction FromPartsPerThousand(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerTrillion"/>.
         /// </summary>
-        public static MassFraction FromPartsPerTrillion(double value)
+        public static MassFraction FromPartsPerTrillion(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.PartPerTrillion);
         }
@@ -632,7 +614,7 @@ public static MassFraction FromPartsPerTrillion(double value)
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.Percent"/>.
         /// </summary>
-        public static MassFraction FromPercent(double value)
+        public static MassFraction FromPercent(QuantityValue value)
         {
             return new MassFraction(value, MassFractionUnit.Percent);
         }
@@ -643,7 +625,7 @@ public static MassFraction FromPercent(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MassFraction unit value.</returns>
-        public static MassFraction From(double value, MassFractionUnit fromUnit)
+        public static MassFraction From(QuantityValue value, MassFractionUnit fromUnit)
         {
             return new MassFraction(value, fromUnit);
         }
@@ -704,10 +686,7 @@ public static MassFraction Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MassFraction Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MassFraction, MassFractionUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MassFraction, MassFractionUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -735,11 +714,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MassFraction res
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassFraction result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MassFraction, MassFractionUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MassFraction, MassFractionUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -760,7 +735,7 @@ public static MassFractionUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -771,7 +746,7 @@ public static MassFractionUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassFractionUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MassFractionUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassFractionUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -786,7 +761,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassFraction
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassFractionUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -805,35 +780,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MassFraction"/> from adding two <see cref="MassFraction"/>.</summary>
         public static MassFraction operator +(MassFraction left, MassFraction right)
         {
-            return new MassFraction(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MassFraction(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MassFraction"/> from subtracting two <see cref="MassFraction"/>.</summary>
         public static MassFraction operator -(MassFraction left, MassFraction right)
         {
-            return new MassFraction(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MassFraction(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MassFraction"/> from multiplying value and <see cref="MassFraction"/>.</summary>
-        public static MassFraction operator *(double left, MassFraction right)
+        public static MassFraction operator *(QuantityValue left, MassFraction right)
         {
             return new MassFraction(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MassFraction"/> from multiplying value and <see cref="MassFraction"/>.</summary>
-        public static MassFraction operator *(MassFraction left, double right)
+        public static MassFraction operator *(MassFraction left, QuantityValue right)
         {
             return new MassFraction(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MassFraction"/> from dividing <see cref="MassFraction"/> by value.</summary>
-        public static MassFraction operator /(MassFraction left, double right)
+        public static MassFraction operator /(MassFraction left, QuantityValue right)
         {
             return new MassFraction(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MassFraction"/> by <see cref="MassFraction"/>.</summary>
-        public static double operator /(MassFraction left, MassFraction right)
+        public static QuantityValue operator /(MassFraction left, MassFraction right)
         {
             return left.DecimalFractions / right.DecimalFractions;
         }
@@ -855,97 +830,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MassFraction left, MassFraction right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MassFraction left, MassFraction right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MassFraction left, MassFraction right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MassFraction left, MassFraction right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MassFraction"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MassFraction other, MassFraction tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MassFraction"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MassFraction)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MassFraction left, MassFraction right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MassFraction"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MassFraction other, MassFraction tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MassFraction"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MassFraction,MassFraction)"/>.
+        ///     See that operator (and <see cref="Equals(MassFraction)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MassFraction left, MassFraction right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MassFraction"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MassFraction other, MassFraction tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MassFraction"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MassFraction"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MassFraction"/>, this method delegates to
+        ///     <see cref="Equals(MassFraction)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MassFraction otherQuantity))
+            if (obj is not MassFraction otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MassFraction"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MassFraction other, MassFraction tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MassFraction"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MassFraction other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MassFraction.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MassFraction), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MassFraction"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MassFraction)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MassFraction otherQuantity)) throw new ArgumentException("Expected type MassFraction.", nameof(obj));
+            if (obj is not MassFraction otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MassFraction>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MassFraction"/> with another <see cref="MassFraction"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MassFraction"/> with another <see cref="MassFraction"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -957,175 +946,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MassFraction other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassFractionUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MassFractionUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this MassFraction to another MassFraction with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MassFraction with the specified unit.</returns>
-        public MassFraction ToUnit(MassFractionUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="MassFraction"/> to another <see cref="MassFraction"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MassFraction with the specified unit.</returns>
-        public MassFraction ToUnit(MassFractionUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MassFraction), Unit, typeof(MassFraction), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MassFraction)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="MassFraction"/> to another <see cref="MassFraction"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MassFraction"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MassFractionUnit unit, [NotNullWhen(true)] out MassFraction? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MassFraction? convertedOrNull = (Unit, unit) switch
-            {
-                // MassFractionUnit -> BaseUnit
-                (MassFractionUnit.CentigramPerGram, MassFractionUnit.DecimalFraction) => new MassFraction((_value) * 1e-2d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.CentigramPerKilogram, MassFractionUnit.DecimalFraction) => new MassFraction((_value / 1e3) * 1e-2d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.DecagramPerGram, MassFractionUnit.DecimalFraction) => new MassFraction((_value) * 1e1d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.DecagramPerKilogram, MassFractionUnit.DecimalFraction) => new MassFraction((_value / 1e3) * 1e1d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.DecigramPerGram, MassFractionUnit.DecimalFraction) => new MassFraction((_value) * 1e-1d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.DecigramPerKilogram, MassFractionUnit.DecimalFraction) => new MassFraction((_value / 1e3) * 1e-1d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.GramPerGram, MassFractionUnit.DecimalFraction) => new MassFraction(_value, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.GramPerKilogram, MassFractionUnit.DecimalFraction) => new MassFraction(_value / 1e3, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.HectogramPerGram, MassFractionUnit.DecimalFraction) => new MassFraction((_value) * 1e2d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.HectogramPerKilogram, MassFractionUnit.DecimalFraction) => new MassFraction((_value / 1e3) * 1e2d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.KilogramPerGram, MassFractionUnit.DecimalFraction) => new MassFraction((_value) * 1e3d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.KilogramPerKilogram, MassFractionUnit.DecimalFraction) => new MassFraction((_value / 1e3) * 1e3d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.MicrogramPerGram, MassFractionUnit.DecimalFraction) => new MassFraction((_value) * 1e-6d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.MicrogramPerKilogram, MassFractionUnit.DecimalFraction) => new MassFraction((_value / 1e3) * 1e-6d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.MilligramPerGram, MassFractionUnit.DecimalFraction) => new MassFraction((_value) * 1e-3d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.MilligramPerKilogram, MassFractionUnit.DecimalFraction) => new MassFraction((_value / 1e3) * 1e-3d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.NanogramPerGram, MassFractionUnit.DecimalFraction) => new MassFraction((_value) * 1e-9d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.NanogramPerKilogram, MassFractionUnit.DecimalFraction) => new MassFraction((_value / 1e3) * 1e-9d, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.PartPerBillion, MassFractionUnit.DecimalFraction) => new MassFraction(_value / 1e9, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.PartPerMillion, MassFractionUnit.DecimalFraction) => new MassFraction(_value / 1e6, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.PartPerThousand, MassFractionUnit.DecimalFraction) => new MassFraction(_value / 1e3, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.PartPerTrillion, MassFractionUnit.DecimalFraction) => new MassFraction(_value / 1e12, MassFractionUnit.DecimalFraction),
-                (MassFractionUnit.Percent, MassFractionUnit.DecimalFraction) => new MassFraction(_value / 1e2, MassFractionUnit.DecimalFraction),
-
-                // BaseUnit -> MassFractionUnit
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.CentigramPerGram) => new MassFraction((_value) / 1e-2d, MassFractionUnit.CentigramPerGram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.CentigramPerKilogram) => new MassFraction((_value * 1e3) / 1e-2d, MassFractionUnit.CentigramPerKilogram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.DecagramPerGram) => new MassFraction((_value) / 1e1d, MassFractionUnit.DecagramPerGram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.DecagramPerKilogram) => new MassFraction((_value * 1e3) / 1e1d, MassFractionUnit.DecagramPerKilogram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.DecigramPerGram) => new MassFraction((_value) / 1e-1d, MassFractionUnit.DecigramPerGram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.DecigramPerKilogram) => new MassFraction((_value * 1e3) / 1e-1d, MassFractionUnit.DecigramPerKilogram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.GramPerGram) => new MassFraction(_value, MassFractionUnit.GramPerGram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.GramPerKilogram) => new MassFraction(_value * 1e3, MassFractionUnit.GramPerKilogram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.HectogramPerGram) => new MassFraction((_value) / 1e2d, MassFractionUnit.HectogramPerGram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.HectogramPerKilogram) => new MassFraction((_value * 1e3) / 1e2d, MassFractionUnit.HectogramPerKilogram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.KilogramPerGram) => new MassFraction((_value) / 1e3d, MassFractionUnit.KilogramPerGram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.KilogramPerKilogram) => new MassFraction((_value * 1e3) / 1e3d, MassFractionUnit.KilogramPerKilogram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.MicrogramPerGram) => new MassFraction((_value) / 1e-6d, MassFractionUnit.MicrogramPerGram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.MicrogramPerKilogram) => new MassFraction((_value * 1e3) / 1e-6d, MassFractionUnit.MicrogramPerKilogram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.MilligramPerGram) => new MassFraction((_value) / 1e-3d, MassFractionUnit.MilligramPerGram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.MilligramPerKilogram) => new MassFraction((_value * 1e3) / 1e-3d, MassFractionUnit.MilligramPerKilogram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.NanogramPerGram) => new MassFraction((_value) / 1e-9d, MassFractionUnit.NanogramPerGram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.NanogramPerKilogram) => new MassFraction((_value * 1e3) / 1e-9d, MassFractionUnit.NanogramPerKilogram),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.PartPerBillion) => new MassFraction(_value * 1e9, MassFractionUnit.PartPerBillion),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.PartPerMillion) => new MassFraction(_value * 1e6, MassFractionUnit.PartPerMillion),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.PartPerThousand) => new MassFraction(_value * 1e3, MassFractionUnit.PartPerThousand),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.PartPerTrillion) => new MassFraction(_value * 1e12, MassFractionUnit.PartPerTrillion),
-                (MassFractionUnit.DecimalFraction, MassFractionUnit.Percent) => new MassFraction(_value * 1e2, MassFractionUnit.Percent),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MassFractionUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFractionUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MassFractionUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFractionUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MassFractionUnit> IQuantity<MassFractionUnit>.ToUnit(MassFractionUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1139,11 +962,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
index 1cd21a64a7..f58feb6be4 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     A property of body reflects how its mass is distributed with regard to an axis.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MassMomentOfInertia :
-        IArithmeticQuantity<MassMomentOfInertia, MassMomentOfInertiaUnit>,
+        ILinearQuantity<MassMomentOfInertia, MassMomentOfInertiaUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MassMomentOfInertia, MassMomentOfInertia, double>,
+        IDivisionOperators<MassMomentOfInertia, MassMomentOfInertia, QuantityValue>,
         IComparisonOperators<MassMomentOfInertia, MassMomentOfInertia, bool>,
         IParsable<MassMomentOfInertia>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +101,7 @@ public static MassMomentOfInertiaInfo CreateDefault(Func<IEnumerable<UnitDefinit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="MassMomentOfInertia"/> is [L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="MassMomentOfInertia"/> is L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, 0, 0, 0, 0, 0);
 
@@ -117,42 +116,94 @@ public static MassMomentOfInertiaInfo CreateDefault(Func<IEnumerable<UnitDefinit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MassMomentOfInertiaUnit}"/> representing the default unit mappings for MassMomentOfInertia.</returns>
             public static IEnumerable<UnitDefinition<MassMomentOfInertiaUnit>> GetDefaultMappings()
             {
-                yield return new (MassMomentOfInertiaUnit.GramSquareCentimeter, "GramSquareCentimeter", "GramSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram));
-                yield return new (MassMomentOfInertiaUnit.GramSquareDecimeter, "GramSquareDecimeter", "GramSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Gram));
-                yield return new (MassMomentOfInertiaUnit.GramSquareMeter, "GramSquareMeter", "GramSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram));
-                yield return new (MassMomentOfInertiaUnit.GramSquareMillimeter, "GramSquareMillimeter", "GramSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram));
-                yield return new (MassMomentOfInertiaUnit.KilogramSquareCentimeter, "KilogramSquareCentimeter", "KilogramSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram));
-                yield return new (MassMomentOfInertiaUnit.KilogramSquareDecimeter, "KilogramSquareDecimeter", "KilogramSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram));
+                yield return new (MassMomentOfInertiaUnit.GramSquareCentimeter, "GramSquareCentimeter", "GramSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram),
+                     10000000
+                );
+                yield return new (MassMomentOfInertiaUnit.GramSquareDecimeter, "GramSquareDecimeter", "GramSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Gram),
+                     100000
+                );
+                yield return new (MassMomentOfInertiaUnit.GramSquareMeter, "GramSquareMeter", "GramSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram),
+                     1000
+                );
+                yield return new (MassMomentOfInertiaUnit.GramSquareMillimeter, "GramSquareMillimeter", "GramSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram),
+                     1000000000
+                );
+                yield return new (MassMomentOfInertiaUnit.KilogramSquareCentimeter, "KilogramSquareCentimeter", "KilogramSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram),
+                     10000
+                );
+                yield return new (MassMomentOfInertiaUnit.KilogramSquareDecimeter, "KilogramSquareDecimeter", "KilogramSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram),
+                     100
+                );
                 yield return new (MassMomentOfInertiaUnit.KilogramSquareMeter, "KilogramSquareMeter", "KilogramSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram));
-                yield return new (MassMomentOfInertiaUnit.KilogramSquareMillimeter, "KilogramSquareMillimeter", "KilogramSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram));
-                yield return new (MassMomentOfInertiaUnit.KilotonneSquareCentimeter, "KilotonneSquareCentimeter", "KilotonneSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilotonne));
-                yield return new (MassMomentOfInertiaUnit.KilotonneSquareDecimeter, "KilotonneSquareDecimeter", "KilotonneSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilotonne));
-                yield return new (MassMomentOfInertiaUnit.KilotonneSquareMeter, "KilotonneSquareMeter", "KilotonneSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilotonne));
-                yield return new (MassMomentOfInertiaUnit.KilotonneSquareMillimeter, "KilotonneSquareMillimeter", "KilotonneSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilotonne));
-                yield return new (MassMomentOfInertiaUnit.MegatonneSquareCentimeter, "MegatonneSquareCentimeter", "MegatonneSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Megatonne));
-                yield return new (MassMomentOfInertiaUnit.MegatonneSquareDecimeter, "MegatonneSquareDecimeter", "MegatonneSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Megatonne));
-                yield return new (MassMomentOfInertiaUnit.MegatonneSquareMeter, "MegatonneSquareMeter", "MegatonneSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Megatonne));
-                yield return new (MassMomentOfInertiaUnit.MegatonneSquareMillimeter, "MegatonneSquareMillimeter", "MegatonneSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Megatonne));
-                yield return new (MassMomentOfInertiaUnit.MilligramSquareCentimeter, "MilligramSquareCentimeter", "MilligramSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Milligram));
-                yield return new (MassMomentOfInertiaUnit.MilligramSquareDecimeter, "MilligramSquareDecimeter", "MilligramSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Milligram));
-                yield return new (MassMomentOfInertiaUnit.MilligramSquareMeter, "MilligramSquareMeter", "MilligramSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram));
-                yield return new (MassMomentOfInertiaUnit.MilligramSquareMillimeter, "MilligramSquareMillimeter", "MilligramSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Milligram));
-                yield return new (MassMomentOfInertiaUnit.PoundSquareFoot, "PoundSquareFoot", "PoundSquareFeet", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound));
-                yield return new (MassMomentOfInertiaUnit.PoundSquareInch, "PoundSquareInch", "PoundSquareInches", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound));
-                yield return new (MassMomentOfInertiaUnit.SlugSquareFoot, "SlugSquareFoot", "SlugSquareFeet", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Slug));
-                yield return new (MassMomentOfInertiaUnit.SlugSquareInch, "SlugSquareInch", "SlugSquareInches", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Slug));
-                yield return new (MassMomentOfInertiaUnit.TonneSquareCentimeter, "TonneSquareCentimeter", "TonneSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Tonne));
-                yield return new (MassMomentOfInertiaUnit.TonneSquareDecimeter, "TonneSquareDecimeter", "TonneSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Tonne));
-                yield return new (MassMomentOfInertiaUnit.TonneSquareMeter, "TonneSquareMeter", "TonneSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Tonne));
-                yield return new (MassMomentOfInertiaUnit.TonneSquareMillimeter, "TonneSquareMillimeter", "TonneSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Tonne));
+                yield return new (MassMomentOfInertiaUnit.KilogramSquareMillimeter, "KilogramSquareMillimeter", "KilogramSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram),
+                     1000000
+                );
+                yield return new (MassMomentOfInertiaUnit.KilotonneSquareCentimeter, "KilotonneSquareCentimeter", "KilotonneSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilotonne),
+                     new QuantityValue(1, 100)
+                );
+                yield return new (MassMomentOfInertiaUnit.KilotonneSquareDecimeter, "KilotonneSquareDecimeter", "KilotonneSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilotonne),
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (MassMomentOfInertiaUnit.KilotonneSquareMeter, "KilotonneSquareMeter", "KilotonneSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilotonne),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (MassMomentOfInertiaUnit.KilotonneSquareMillimeter, "KilotonneSquareMillimeter", "KilotonneSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilotonne),
+                     1
+                );
+                yield return new (MassMomentOfInertiaUnit.MegatonneSquareCentimeter, "MegatonneSquareCentimeter", "MegatonneSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Megatonne),
+                     new QuantityValue(1, 100000)
+                );
+                yield return new (MassMomentOfInertiaUnit.MegatonneSquareDecimeter, "MegatonneSquareDecimeter", "MegatonneSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Megatonne),
+                     new QuantityValue(1, 10000000)
+                );
+                yield return new (MassMomentOfInertiaUnit.MegatonneSquareMeter, "MegatonneSquareMeter", "MegatonneSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Megatonne),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (MassMomentOfInertiaUnit.MegatonneSquareMillimeter, "MegatonneSquareMillimeter", "MegatonneSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Megatonne),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MassMomentOfInertiaUnit.MilligramSquareCentimeter, "MilligramSquareCentimeter", "MilligramSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Milligram),
+                     10000000000
+                );
+                yield return new (MassMomentOfInertiaUnit.MilligramSquareDecimeter, "MilligramSquareDecimeter", "MilligramSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Milligram),
+                     100000000
+                );
+                yield return new (MassMomentOfInertiaUnit.MilligramSquareMeter, "MilligramSquareMeter", "MilligramSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram),
+                     1000000
+                );
+                yield return new (MassMomentOfInertiaUnit.MilligramSquareMillimeter, "MilligramSquareMillimeter", "MilligramSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Milligram),
+                     1000000000000
+                );
+                yield return new (MassMomentOfInertiaUnit.PoundSquareFoot, "PoundSquareFoot", "PoundSquareFeet", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound),
+                     new QuantityValue(156250000000000, 6584392202157)
+                );
+                yield return new (MassMomentOfInertiaUnit.PoundSquareInch, "PoundSquareInch", "PoundSquareInches", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound),
+                     new QuantityValue(2500000000000000, 731599133573)
+                );
+                yield return new (MassMomentOfInertiaUnit.SlugSquareFoot, "SlugSquareFoot", "SlugSquareFeet", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Slug),
+                     new QuantityValue(2500000000000000, 3389544870828501)
+                );
+                yield return new (MassMomentOfInertiaUnit.SlugSquareInch, "SlugSquareInch", "SlugSquareInches", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Slug),
+                     new QuantityValue(120000000000000000, 1129848290276167)
+                );
+                yield return new (MassMomentOfInertiaUnit.TonneSquareCentimeter, "TonneSquareCentimeter", "TonneSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Tonne),
+                     10
+                );
+                yield return new (MassMomentOfInertiaUnit.TonneSquareDecimeter, "TonneSquareDecimeter", "TonneSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Tonne),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (MassMomentOfInertiaUnit.TonneSquareMeter, "TonneSquareMeter", "TonneSquareMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Tonne),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MassMomentOfInertiaUnit.TonneSquareMillimeter, "TonneSquareMillimeter", "TonneSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Tonne),
+                     1000
+                );
             }
         }
 
         static MassMomentOfInertia()
         {
-            Info = MassMomentOfInertiaInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MassMomentOfInertiaInfo.CreateDefault);
         }
 
         /// <summary>
@@ -160,7 +211,7 @@ static MassMomentOfInertia()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MassMomentOfInertia(double value, MassMomentOfInertiaUnit unit)
+        public MassMomentOfInertia(QuantityValue value, MassMomentOfInertiaUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -174,7 +225,7 @@ public MassMomentOfInertia(double value, MassMomentOfInertiaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MassMomentOfInertia(double value, UnitSystem unitSystem)
+        public MassMomentOfInertia(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -185,7 +236,8 @@ public MassMomentOfInertia(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MassMomentOfInertia" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MassMomentOfInertia, MassMomentOfInertiaUnit> Info { get; }
@@ -214,10 +266,8 @@ public MassMomentOfInertia(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MassMomentOfInertiaUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -251,217 +301,149 @@ public MassMomentOfInertia(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareCentimeter"/>
         /// </summary>
-        public double GramSquareCentimeters => As(MassMomentOfInertiaUnit.GramSquareCentimeter);
+        public QuantityValue GramSquareCentimeters => this.As(MassMomentOfInertiaUnit.GramSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareDecimeter"/>
         /// </summary>
-        public double GramSquareDecimeters => As(MassMomentOfInertiaUnit.GramSquareDecimeter);
+        public QuantityValue GramSquareDecimeters => this.As(MassMomentOfInertiaUnit.GramSquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareMeter"/>
         /// </summary>
-        public double GramSquareMeters => As(MassMomentOfInertiaUnit.GramSquareMeter);
+        public QuantityValue GramSquareMeters => this.As(MassMomentOfInertiaUnit.GramSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.GramSquareMillimeter"/>
         /// </summary>
-        public double GramSquareMillimeters => As(MassMomentOfInertiaUnit.GramSquareMillimeter);
+        public QuantityValue GramSquareMillimeters => this.As(MassMomentOfInertiaUnit.GramSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareCentimeter"/>
         /// </summary>
-        public double KilogramSquareCentimeters => As(MassMomentOfInertiaUnit.KilogramSquareCentimeter);
+        public QuantityValue KilogramSquareCentimeters => this.As(MassMomentOfInertiaUnit.KilogramSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareDecimeter"/>
         /// </summary>
-        public double KilogramSquareDecimeters => As(MassMomentOfInertiaUnit.KilogramSquareDecimeter);
+        public QuantityValue KilogramSquareDecimeters => this.As(MassMomentOfInertiaUnit.KilogramSquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareMeter"/>
         /// </summary>
-        public double KilogramSquareMeters => As(MassMomentOfInertiaUnit.KilogramSquareMeter);
+        public QuantityValue KilogramSquareMeters => this.As(MassMomentOfInertiaUnit.KilogramSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilogramSquareMillimeter"/>
         /// </summary>
-        public double KilogramSquareMillimeters => As(MassMomentOfInertiaUnit.KilogramSquareMillimeter);
+        public QuantityValue KilogramSquareMillimeters => this.As(MassMomentOfInertiaUnit.KilogramSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareCentimeter"/>
         /// </summary>
-        public double KilotonneSquareCentimeters => As(MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
+        public QuantityValue KilotonneSquareCentimeters => this.As(MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareDecimeter"/>
         /// </summary>
-        public double KilotonneSquareDecimeters => As(MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
+        public QuantityValue KilotonneSquareDecimeters => this.As(MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareMeter"/>
         /// </summary>
-        public double KilotonneSquareMeters => As(MassMomentOfInertiaUnit.KilotonneSquareMeter);
+        public QuantityValue KilotonneSquareMeters => this.As(MassMomentOfInertiaUnit.KilotonneSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.KilotonneSquareMillimeter"/>
         /// </summary>
-        public double KilotonneSquareMillimeters => As(MassMomentOfInertiaUnit.KilotonneSquareMillimeter);
+        public QuantityValue KilotonneSquareMillimeters => this.As(MassMomentOfInertiaUnit.KilotonneSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareCentimeter"/>
         /// </summary>
-        public double MegatonneSquareCentimeters => As(MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
+        public QuantityValue MegatonneSquareCentimeters => this.As(MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareDecimeter"/>
         /// </summary>
-        public double MegatonneSquareDecimeters => As(MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
+        public QuantityValue MegatonneSquareDecimeters => this.As(MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareMeter"/>
         /// </summary>
-        public double MegatonneSquareMeters => As(MassMomentOfInertiaUnit.MegatonneSquareMeter);
+        public QuantityValue MegatonneSquareMeters => this.As(MassMomentOfInertiaUnit.MegatonneSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MegatonneSquareMillimeter"/>
         /// </summary>
-        public double MegatonneSquareMillimeters => As(MassMomentOfInertiaUnit.MegatonneSquareMillimeter);
+        public QuantityValue MegatonneSquareMillimeters => this.As(MassMomentOfInertiaUnit.MegatonneSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareCentimeter"/>
         /// </summary>
-        public double MilligramSquareCentimeters => As(MassMomentOfInertiaUnit.MilligramSquareCentimeter);
+        public QuantityValue MilligramSquareCentimeters => this.As(MassMomentOfInertiaUnit.MilligramSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareDecimeter"/>
         /// </summary>
-        public double MilligramSquareDecimeters => As(MassMomentOfInertiaUnit.MilligramSquareDecimeter);
+        public QuantityValue MilligramSquareDecimeters => this.As(MassMomentOfInertiaUnit.MilligramSquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareMeter"/>
         /// </summary>
-        public double MilligramSquareMeters => As(MassMomentOfInertiaUnit.MilligramSquareMeter);
+        public QuantityValue MilligramSquareMeters => this.As(MassMomentOfInertiaUnit.MilligramSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.MilligramSquareMillimeter"/>
         /// </summary>
-        public double MilligramSquareMillimeters => As(MassMomentOfInertiaUnit.MilligramSquareMillimeter);
+        public QuantityValue MilligramSquareMillimeters => this.As(MassMomentOfInertiaUnit.MilligramSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.PoundSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.PoundSquareFoot"/>
         /// </summary>
-        public double PoundSquareFeet => As(MassMomentOfInertiaUnit.PoundSquareFoot);
+        public QuantityValue PoundSquareFeet => this.As(MassMomentOfInertiaUnit.PoundSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.PoundSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.PoundSquareInch"/>
         /// </summary>
-        public double PoundSquareInches => As(MassMomentOfInertiaUnit.PoundSquareInch);
+        public QuantityValue PoundSquareInches => this.As(MassMomentOfInertiaUnit.PoundSquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.SlugSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.SlugSquareFoot"/>
         /// </summary>
-        public double SlugSquareFeet => As(MassMomentOfInertiaUnit.SlugSquareFoot);
+        public QuantityValue SlugSquareFeet => this.As(MassMomentOfInertiaUnit.SlugSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.SlugSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.SlugSquareInch"/>
         /// </summary>
-        public double SlugSquareInches => As(MassMomentOfInertiaUnit.SlugSquareInch);
+        public QuantityValue SlugSquareInches => this.As(MassMomentOfInertiaUnit.SlugSquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareCentimeter"/>
         /// </summary>
-        public double TonneSquareCentimeters => As(MassMomentOfInertiaUnit.TonneSquareCentimeter);
+        public QuantityValue TonneSquareCentimeters => this.As(MassMomentOfInertiaUnit.TonneSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareDecimeter"/>
         /// </summary>
-        public double TonneSquareDecimeters => As(MassMomentOfInertiaUnit.TonneSquareDecimeter);
+        public QuantityValue TonneSquareDecimeters => this.As(MassMomentOfInertiaUnit.TonneSquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareMeter"/>
         /// </summary>
-        public double TonneSquareMeters => As(MassMomentOfInertiaUnit.TonneSquareMeter);
+        public QuantityValue TonneSquareMeters => this.As(MassMomentOfInertiaUnit.TonneSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MassMomentOfInertiaUnit.TonneSquareMillimeter"/>
         /// </summary>
-        public double TonneSquareMillimeters => As(MassMomentOfInertiaUnit.TonneSquareMillimeter);
+        public QuantityValue TonneSquareMillimeters => this.As(MassMomentOfInertiaUnit.TonneSquareMillimeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MassMomentOfInertiaUnit -> BaseUnit
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.GramSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.GramSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.GramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.GramSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilotonneSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilotonneSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilotonneSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilotonneSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MegatonneSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MegatonneSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MegatonneSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MegatonneSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MilligramSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MilligramSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MilligramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.MilligramSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.PoundSquareFoot, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.PoundSquareInch, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.SlugSquareFoot, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.SlugSquareInch, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.TonneSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.TonneSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.TonneSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.TonneSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MassMomentOfInertiaUnit
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.GramSquareCentimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.GramSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.GramSquareDecimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.GramSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.GramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.GramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.GramSquareMillimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.GramSquareMillimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareCentimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareDecimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMillimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilogramSquareMillimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilotonneSquareCentimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilotonneSquareDecimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilotonneSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilotonneSquareMillimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.KilotonneSquareMillimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MegatonneSquareCentimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MegatonneSquareDecimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MegatonneSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MegatonneSquareMillimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.MegatonneSquareMillimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MilligramSquareCentimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.MilligramSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MilligramSquareDecimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.MilligramSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MilligramSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.MilligramSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MilligramSquareMillimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.MilligramSquareMillimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.PoundSquareFoot, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.PoundSquareFoot));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.PoundSquareInch, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.PoundSquareInch));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.SlugSquareFoot, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.SlugSquareFoot));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.SlugSquareInch, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.SlugSquareInch));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.TonneSquareCentimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.TonneSquareCentimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.TonneSquareDecimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.TonneSquareDecimeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.TonneSquareMeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.TonneSquareMeter));
-            unitConverter.SetConversionFunction<MassMomentOfInertia>(MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.TonneSquareMillimeter, quantity => quantity.ToUnit(MassMomentOfInertiaUnit.TonneSquareMillimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -490,7 +472,7 @@ public static string GetAbbreviation(MassMomentOfInertiaUnit unit, IFormatProvid
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareCentimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromGramSquareCentimeters(double value)
+        public static MassMomentOfInertia FromGramSquareCentimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareCentimeter);
         }
@@ -498,7 +480,7 @@ public static MassMomentOfInertia FromGramSquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareDecimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromGramSquareDecimeters(double value)
+        public static MassMomentOfInertia FromGramSquareDecimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareDecimeter);
         }
@@ -506,7 +488,7 @@ public static MassMomentOfInertia FromGramSquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareMeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromGramSquareMeters(double value)
+        public static MassMomentOfInertia FromGramSquareMeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMeter);
         }
@@ -514,7 +496,7 @@ public static MassMomentOfInertia FromGramSquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareMillimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromGramSquareMillimeters(double value)
+        public static MassMomentOfInertia FromGramSquareMillimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMillimeter);
         }
@@ -522,7 +504,7 @@ public static MassMomentOfInertia FromGramSquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareCentimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromKilogramSquareCentimeters(double value)
+        public static MassMomentOfInertia FromKilogramSquareCentimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareCentimeter);
         }
@@ -530,7 +512,7 @@ public static MassMomentOfInertia FromKilogramSquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareDecimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromKilogramSquareDecimeters(double value)
+        public static MassMomentOfInertia FromKilogramSquareDecimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareDecimeter);
         }
@@ -538,7 +520,7 @@ public static MassMomentOfInertia FromKilogramSquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareMeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromKilogramSquareMeters(double value)
+        public static MassMomentOfInertia FromKilogramSquareMeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMeter);
         }
@@ -546,7 +528,7 @@ public static MassMomentOfInertia FromKilogramSquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareMillimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromKilogramSquareMillimeters(double value)
+        public static MassMomentOfInertia FromKilogramSquareMillimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMillimeter);
         }
@@ -554,7 +536,7 @@ public static MassMomentOfInertia FromKilogramSquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareCentimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromKilotonneSquareCentimeters(double value)
+        public static MassMomentOfInertia FromKilotonneSquareCentimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
         }
@@ -562,7 +544,7 @@ public static MassMomentOfInertia FromKilotonneSquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareDecimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromKilotonneSquareDecimeters(double value)
+        public static MassMomentOfInertia FromKilotonneSquareDecimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
         }
@@ -570,7 +552,7 @@ public static MassMomentOfInertia FromKilotonneSquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareMeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromKilotonneSquareMeters(double value)
+        public static MassMomentOfInertia FromKilotonneSquareMeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMeter);
         }
@@ -578,7 +560,7 @@ public static MassMomentOfInertia FromKilotonneSquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareMillimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromKilotonneSquareMillimeters(double value)
+        public static MassMomentOfInertia FromKilotonneSquareMillimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMillimeter);
         }
@@ -586,7 +568,7 @@ public static MassMomentOfInertia FromKilotonneSquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareCentimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromMegatonneSquareCentimeters(double value)
+        public static MassMomentOfInertia FromMegatonneSquareCentimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
         }
@@ -594,7 +576,7 @@ public static MassMomentOfInertia FromMegatonneSquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareDecimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromMegatonneSquareDecimeters(double value)
+        public static MassMomentOfInertia FromMegatonneSquareDecimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
         }
@@ -602,7 +584,7 @@ public static MassMomentOfInertia FromMegatonneSquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareMeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromMegatonneSquareMeters(double value)
+        public static MassMomentOfInertia FromMegatonneSquareMeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMeter);
         }
@@ -610,7 +592,7 @@ public static MassMomentOfInertia FromMegatonneSquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareMillimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromMegatonneSquareMillimeters(double value)
+        public static MassMomentOfInertia FromMegatonneSquareMillimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMillimeter);
         }
@@ -618,7 +600,7 @@ public static MassMomentOfInertia FromMegatonneSquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareCentimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromMilligramSquareCentimeters(double value)
+        public static MassMomentOfInertia FromMilligramSquareCentimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareCentimeter);
         }
@@ -626,7 +608,7 @@ public static MassMomentOfInertia FromMilligramSquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareDecimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromMilligramSquareDecimeters(double value)
+        public static MassMomentOfInertia FromMilligramSquareDecimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareDecimeter);
         }
@@ -634,7 +616,7 @@ public static MassMomentOfInertia FromMilligramSquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareMeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromMilligramSquareMeters(double value)
+        public static MassMomentOfInertia FromMilligramSquareMeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMeter);
         }
@@ -642,7 +624,7 @@ public static MassMomentOfInertia FromMilligramSquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareMillimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromMilligramSquareMillimeters(double value)
+        public static MassMomentOfInertia FromMilligramSquareMillimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMillimeter);
         }
@@ -650,7 +632,7 @@ public static MassMomentOfInertia FromMilligramSquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.PoundSquareFoot"/>.
         /// </summary>
-        public static MassMomentOfInertia FromPoundSquareFeet(double value)
+        public static MassMomentOfInertia FromPoundSquareFeet(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareFoot);
         }
@@ -658,7 +640,7 @@ public static MassMomentOfInertia FromPoundSquareFeet(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.PoundSquareInch"/>.
         /// </summary>
-        public static MassMomentOfInertia FromPoundSquareInches(double value)
+        public static MassMomentOfInertia FromPoundSquareInches(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareInch);
         }
@@ -666,7 +648,7 @@ public static MassMomentOfInertia FromPoundSquareInches(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.SlugSquareFoot"/>.
         /// </summary>
-        public static MassMomentOfInertia FromSlugSquareFeet(double value)
+        public static MassMomentOfInertia FromSlugSquareFeet(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareFoot);
         }
@@ -674,7 +656,7 @@ public static MassMomentOfInertia FromSlugSquareFeet(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.SlugSquareInch"/>.
         /// </summary>
-        public static MassMomentOfInertia FromSlugSquareInches(double value)
+        public static MassMomentOfInertia FromSlugSquareInches(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareInch);
         }
@@ -682,7 +664,7 @@ public static MassMomentOfInertia FromSlugSquareInches(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareCentimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromTonneSquareCentimeters(double value)
+        public static MassMomentOfInertia FromTonneSquareCentimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareCentimeter);
         }
@@ -690,7 +672,7 @@ public static MassMomentOfInertia FromTonneSquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareDecimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromTonneSquareDecimeters(double value)
+        public static MassMomentOfInertia FromTonneSquareDecimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareDecimeter);
         }
@@ -698,7 +680,7 @@ public static MassMomentOfInertia FromTonneSquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareMeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromTonneSquareMeters(double value)
+        public static MassMomentOfInertia FromTonneSquareMeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMeter);
         }
@@ -706,7 +688,7 @@ public static MassMomentOfInertia FromTonneSquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareMillimeter"/>.
         /// </summary>
-        public static MassMomentOfInertia FromTonneSquareMillimeters(double value)
+        public static MassMomentOfInertia FromTonneSquareMillimeters(QuantityValue value)
         {
             return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMillimeter);
         }
@@ -717,7 +699,7 @@ public static MassMomentOfInertia FromTonneSquareMillimeters(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MassMomentOfInertia unit value.</returns>
-        public static MassMomentOfInertia From(double value, MassMomentOfInertiaUnit fromUnit)
+        public static MassMomentOfInertia From(QuantityValue value, MassMomentOfInertiaUnit fromUnit)
         {
             return new MassMomentOfInertia(value, fromUnit);
         }
@@ -778,10 +760,7 @@ public static MassMomentOfInertia Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MassMomentOfInertia Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MassMomentOfInertia, MassMomentOfInertiaUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MassMomentOfInertia, MassMomentOfInertiaUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -809,11 +788,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MassMomentOfIner
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassMomentOfInertia result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MassMomentOfInertia, MassMomentOfInertiaUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MassMomentOfInertia, MassMomentOfInertiaUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -834,7 +809,7 @@ public static MassMomentOfInertiaUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -845,7 +820,7 @@ public static MassMomentOfInertiaUnit ParseUnit(string str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MassMomentOfInertiaUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MassMomentOfInertiaUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassMomentOfInertiaUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -860,7 +835,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MassMomentOf
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MassMomentOfInertiaUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -879,35 +854,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MassMomentOfInertia"/> from adding two <see cref="MassMomentOfInertia"/>.</summary>
         public static MassMomentOfInertia operator +(MassMomentOfInertia left, MassMomentOfInertia right)
         {
-            return new MassMomentOfInertia(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MassMomentOfInertia(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MassMomentOfInertia"/> from subtracting two <see cref="MassMomentOfInertia"/>.</summary>
         public static MassMomentOfInertia operator -(MassMomentOfInertia left, MassMomentOfInertia right)
         {
-            return new MassMomentOfInertia(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MassMomentOfInertia(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MassMomentOfInertia"/> from multiplying value and <see cref="MassMomentOfInertia"/>.</summary>
-        public static MassMomentOfInertia operator *(double left, MassMomentOfInertia right)
+        public static MassMomentOfInertia operator *(QuantityValue left, MassMomentOfInertia right)
         {
             return new MassMomentOfInertia(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MassMomentOfInertia"/> from multiplying value and <see cref="MassMomentOfInertia"/>.</summary>
-        public static MassMomentOfInertia operator *(MassMomentOfInertia left, double right)
+        public static MassMomentOfInertia operator *(MassMomentOfInertia left, QuantityValue right)
         {
             return new MassMomentOfInertia(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MassMomentOfInertia"/> from dividing <see cref="MassMomentOfInertia"/> by value.</summary>
-        public static MassMomentOfInertia operator /(MassMomentOfInertia left, double right)
+        public static MassMomentOfInertia operator /(MassMomentOfInertia left, QuantityValue right)
         {
             return new MassMomentOfInertia(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MassMomentOfInertia"/> by <see cref="MassMomentOfInertia"/>.</summary>
-        public static double operator /(MassMomentOfInertia left, MassMomentOfInertia right)
+        public static QuantityValue operator /(MassMomentOfInertia left, MassMomentOfInertia right)
         {
             return left.KilogramSquareMeters / right.KilogramSquareMeters;
         }
@@ -919,97 +894,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MassMomentOfInertia left, MassMomentOfInertia right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MassMomentOfInertia left, MassMomentOfInertia right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MassMomentOfInertia left, MassMomentOfInertia right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MassMomentOfInertia left, MassMomentOfInertia right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MassMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MassMomentOfInertia other, MassMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MassMomentOfInertia"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MassMomentOfInertia)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MassMomentOfInertia left, MassMomentOfInertia right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MassMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MassMomentOfInertia other, MassMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MassMomentOfInertia"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MassMomentOfInertia,MassMomentOfInertia)"/>.
+        ///     See that operator (and <see cref="Equals(MassMomentOfInertia)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MassMomentOfInertia left, MassMomentOfInertia right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MassMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MassMomentOfInertia other, MassMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MassMomentOfInertia"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MassMomentOfInertia"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MassMomentOfInertia"/>, this method delegates to
+        ///     <see cref="Equals(MassMomentOfInertia)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MassMomentOfInertia otherQuantity))
+            if (obj is not MassMomentOfInertia otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MassMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MassMomentOfInertia other, MassMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MassMomentOfInertia"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MassMomentOfInertia other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MassMomentOfInertia.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MassMomentOfInertia), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MassMomentOfInertia"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MassMomentOfInertia)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MassMomentOfInertia otherQuantity)) throw new ArgumentException("Expected type MassMomentOfInertia.", nameof(obj));
+            if (obj is not MassMomentOfInertia otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MassMomentOfInertia>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MassMomentOfInertia"/> with another <see cref="MassMomentOfInertia"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MassMomentOfInertia"/> with another <see cref="MassMomentOfInertia"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1021,183 +1010,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MassMomentOfInertia other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MassMomentOfInertiaUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MassMomentOfInertiaUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this MassMomentOfInertia to another MassMomentOfInertia with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MassMomentOfInertia with the specified unit.</returns>
-        public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="MassMomentOfInertia"/> to another <see cref="MassMomentOfInertia"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MassMomentOfInertia with the specified unit.</returns>
-        public MassMomentOfInertia ToUnit(MassMomentOfInertiaUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MassMomentOfInertia), Unit, typeof(MassMomentOfInertia), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MassMomentOfInertia)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="MassMomentOfInertia"/> to another <see cref="MassMomentOfInertia"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MassMomentOfInertia"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MassMomentOfInertiaUnit unit, [NotNullWhen(true)] out MassMomentOfInertia? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MassMomentOfInertia? convertedOrNull = (Unit, unit) switch
-            {
-                // MassMomentOfInertiaUnit -> BaseUnit
-                (MassMomentOfInertiaUnit.GramSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value / 1e7, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.GramSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value / 1e5, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.GramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value / 1e3, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.GramSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value / 1e9, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.KilogramSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e7) * 1e3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.KilogramSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e5) * 1e3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e9) * 1e3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.KilotonneSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e1) * 1e3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.KilotonneSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e-1) * 1e3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.KilotonneSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e-3) * 1e3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.KilotonneSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e3) * 1e3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.MegatonneSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e1) * 1e6d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.MegatonneSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e-1) * 1e6d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.MegatonneSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e-3) * 1e6d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.MegatonneSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e3) * 1e6d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.MilligramSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e7) * 1e-3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.MilligramSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e5) * 1e-3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.MilligramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e3) * 1e-3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.MilligramSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia((_value / 1e9) * 1e-3d, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.PoundSquareFoot, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value * (0.45359237 * 9.290304e-2), MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.PoundSquareInch, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value * (0.45359237 * 0.00064516), MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.SlugSquareFoot, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value * 0.45359237 * 9.290304e-2 * 9.80665 / 0.3048, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.SlugSquareInch, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value * 0.45359237 * 0.00064516 * 9.80665 / 0.3048, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.TonneSquareCentimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value / 1e1, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.TonneSquareDecimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value / 1e-1, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.TonneSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value / 1e-3, MassMomentOfInertiaUnit.KilogramSquareMeter),
-                (MassMomentOfInertiaUnit.TonneSquareMillimeter, MassMomentOfInertiaUnit.KilogramSquareMeter) => new MassMomentOfInertia(_value / 1e3, MassMomentOfInertiaUnit.KilogramSquareMeter),
-
-                // BaseUnit -> MassMomentOfInertiaUnit
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.GramSquareCentimeter) => new MassMomentOfInertia(_value * 1e7, MassMomentOfInertiaUnit.GramSquareCentimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.GramSquareDecimeter) => new MassMomentOfInertia(_value * 1e5, MassMomentOfInertiaUnit.GramSquareDecimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.GramSquareMeter) => new MassMomentOfInertia(_value * 1e3, MassMomentOfInertiaUnit.GramSquareMeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.GramSquareMillimeter) => new MassMomentOfInertia(_value * 1e9, MassMomentOfInertiaUnit.GramSquareMillimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareCentimeter) => new MassMomentOfInertia((_value * 1e7) / 1e3d, MassMomentOfInertiaUnit.KilogramSquareCentimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareDecimeter) => new MassMomentOfInertia((_value * 1e5) / 1e3d, MassMomentOfInertiaUnit.KilogramSquareDecimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilogramSquareMillimeter) => new MassMomentOfInertia((_value * 1e9) / 1e3d, MassMomentOfInertiaUnit.KilogramSquareMillimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilotonneSquareCentimeter) => new MassMomentOfInertia((_value * 1e1) / 1e3d, MassMomentOfInertiaUnit.KilotonneSquareCentimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilotonneSquareDecimeter) => new MassMomentOfInertia((_value * 1e-1) / 1e3d, MassMomentOfInertiaUnit.KilotonneSquareDecimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilotonneSquareMeter) => new MassMomentOfInertia((_value * 1e-3) / 1e3d, MassMomentOfInertiaUnit.KilotonneSquareMeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.KilotonneSquareMillimeter) => new MassMomentOfInertia((_value * 1e3) / 1e3d, MassMomentOfInertiaUnit.KilotonneSquareMillimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MegatonneSquareCentimeter) => new MassMomentOfInertia((_value * 1e1) / 1e6d, MassMomentOfInertiaUnit.MegatonneSquareCentimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MegatonneSquareDecimeter) => new MassMomentOfInertia((_value * 1e-1) / 1e6d, MassMomentOfInertiaUnit.MegatonneSquareDecimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MegatonneSquareMeter) => new MassMomentOfInertia((_value * 1e-3) / 1e6d, MassMomentOfInertiaUnit.MegatonneSquareMeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MegatonneSquareMillimeter) => new MassMomentOfInertia((_value * 1e3) / 1e6d, MassMomentOfInertiaUnit.MegatonneSquareMillimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MilligramSquareCentimeter) => new MassMomentOfInertia((_value * 1e7) / 1e-3d, MassMomentOfInertiaUnit.MilligramSquareCentimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MilligramSquareDecimeter) => new MassMomentOfInertia((_value * 1e5) / 1e-3d, MassMomentOfInertiaUnit.MilligramSquareDecimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MilligramSquareMeter) => new MassMomentOfInertia((_value * 1e3) / 1e-3d, MassMomentOfInertiaUnit.MilligramSquareMeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.MilligramSquareMillimeter) => new MassMomentOfInertia((_value * 1e9) / 1e-3d, MassMomentOfInertiaUnit.MilligramSquareMillimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.PoundSquareFoot) => new MassMomentOfInertia(_value / (0.45359237 * 9.290304e-2), MassMomentOfInertiaUnit.PoundSquareFoot),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.PoundSquareInch) => new MassMomentOfInertia(_value / (0.45359237 * 0.00064516), MassMomentOfInertiaUnit.PoundSquareInch),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.SlugSquareFoot) => new MassMomentOfInertia(_value * 0.3048 / (0.45359237 * 9.290304e-2 * 9.80665), MassMomentOfInertiaUnit.SlugSquareFoot),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.SlugSquareInch) => new MassMomentOfInertia(_value * 0.3048 / (0.45359237 * 0.00064516 * 9.80665), MassMomentOfInertiaUnit.SlugSquareInch),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.TonneSquareCentimeter) => new MassMomentOfInertia(_value * 1e1, MassMomentOfInertiaUnit.TonneSquareCentimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.TonneSquareDecimeter) => new MassMomentOfInertia(_value * 1e-1, MassMomentOfInertiaUnit.TonneSquareDecimeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.TonneSquareMeter) => new MassMomentOfInertia(_value * 1e-3, MassMomentOfInertiaUnit.TonneSquareMeter),
-                (MassMomentOfInertiaUnit.KilogramSquareMeter, MassMomentOfInertiaUnit.TonneSquareMillimeter) => new MassMomentOfInertia(_value * 1e3, MassMomentOfInertiaUnit.TonneSquareMillimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MassMomentOfInertiaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MassMomentOfInertiaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MassMomentOfInertiaUnit> IQuantity<MassMomentOfInertiaUnit>.ToUnit(MassMomentOfInertiaUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1211,11 +1026,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Molality.g.cs b/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
index 63837b108d..5948be35a0 100644
--- a/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Molality
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Molality :
-        IArithmeticQuantity<Molality, MolalityUnit>,
+        ILinearQuantity<Molality, MolalityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Molality, Molality, double>,
+        IDivisionOperators<Molality, Molality, QuantityValue>,
         IComparisonOperators<Molality, Molality, bool>,
         IParsable<Molality>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static MolalityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Molalit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Molality"/> is [M^-1][N].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Molality"/> is M^-1N.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, -1, 0, 0, 0, 1, 0);
 
@@ -120,17 +119,19 @@ public static MolalityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Molalit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MolalityUnit}"/> representing the default unit mappings for Molality.</returns>
             public static IEnumerable<UnitDefinition<MolalityUnit>> GetDefaultMappings()
             {
-                yield return new (MolalityUnit.MillimolePerKilogram, "MillimolePerKilogram", "MillimolesPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, amount: AmountOfSubstanceUnit.Millimole));
-                yield return new (MolalityUnit.MolePerGram, "MolePerGram", "MolesPerGram", new BaseUnits(mass: MassUnit.Gram, amount: AmountOfSubstanceUnit.Mole));
+                yield return new (MolalityUnit.MillimolePerKilogram, "MillimolePerKilogram", "MillimolesPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, amount: AmountOfSubstanceUnit.Millimole),
+                     1000
+                );
+                yield return new (MolalityUnit.MolePerGram, "MolePerGram", "MolesPerGram", new BaseUnits(mass: MassUnit.Gram, amount: AmountOfSubstanceUnit.Mole),
+                     new QuantityValue(1, 1000)
+                );
                 yield return new (MolalityUnit.MolePerKilogram, "MolePerKilogram", "MolesPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, amount: AmountOfSubstanceUnit.Mole));
             }
         }
 
         static Molality()
         {
-            Info = MolalityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MolalityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -138,7 +139,7 @@ static Molality()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Molality(double value, MolalityUnit unit)
+        public Molality(QuantityValue value, MolalityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -152,7 +153,7 @@ public Molality(double value, MolalityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Molality(double value, UnitSystem unitSystem)
+        public Molality(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -163,7 +164,8 @@ public Molality(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Molality" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Molality, MolalityUnit> Info { get; }
@@ -192,10 +194,8 @@ public Molality(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MolalityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -229,42 +229,24 @@ public Molality(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolalityUnit.MillimolePerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolalityUnit.MillimolePerKilogram"/>
         /// </summary>
-        public double MillimolesPerKilogram => As(MolalityUnit.MillimolePerKilogram);
+        public QuantityValue MillimolesPerKilogram => this.As(MolalityUnit.MillimolePerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolalityUnit.MolePerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolalityUnit.MolePerGram"/>
         /// </summary>
-        public double MolesPerGram => As(MolalityUnit.MolePerGram);
+        public QuantityValue MolesPerGram => this.As(MolalityUnit.MolePerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolalityUnit.MolePerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolalityUnit.MolePerKilogram"/>
         /// </summary>
-        public double MolesPerKilogram => As(MolalityUnit.MolePerKilogram);
+        public QuantityValue MolesPerKilogram => this.As(MolalityUnit.MolePerKilogram);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MolalityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Molality>(MolalityUnit.MillimolePerKilogram, MolalityUnit.MolePerKilogram, quantity => quantity.ToUnit(MolalityUnit.MolePerKilogram));
-            unitConverter.SetConversionFunction<Molality>(MolalityUnit.MolePerGram, MolalityUnit.MolePerKilogram, quantity => quantity.ToUnit(MolalityUnit.MolePerKilogram));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Molality>(MolalityUnit.MolePerKilogram, MolalityUnit.MolePerKilogram, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MolalityUnit
-            unitConverter.SetConversionFunction<Molality>(MolalityUnit.MolePerKilogram, MolalityUnit.MillimolePerKilogram, quantity => quantity.ToUnit(MolalityUnit.MillimolePerKilogram));
-            unitConverter.SetConversionFunction<Molality>(MolalityUnit.MolePerKilogram, MolalityUnit.MolePerGram, quantity => quantity.ToUnit(MolalityUnit.MolePerGram));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -293,7 +275,7 @@ public static string GetAbbreviation(MolalityUnit unit, IFormatProvider? provide
         /// <summary>
         ///     Creates a <see cref="Molality"/> from <see cref="MolalityUnit.MillimolePerKilogram"/>.
         /// </summary>
-        public static Molality FromMillimolesPerKilogram(double value)
+        public static Molality FromMillimolesPerKilogram(QuantityValue value)
         {
             return new Molality(value, MolalityUnit.MillimolePerKilogram);
         }
@@ -301,7 +283,7 @@ public static Molality FromMillimolesPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="Molality"/> from <see cref="MolalityUnit.MolePerGram"/>.
         /// </summary>
-        public static Molality FromMolesPerGram(double value)
+        public static Molality FromMolesPerGram(QuantityValue value)
         {
             return new Molality(value, MolalityUnit.MolePerGram);
         }
@@ -309,7 +291,7 @@ public static Molality FromMolesPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="Molality"/> from <see cref="MolalityUnit.MolePerKilogram"/>.
         /// </summary>
-        public static Molality FromMolesPerKilogram(double value)
+        public static Molality FromMolesPerKilogram(QuantityValue value)
         {
             return new Molality(value, MolalityUnit.MolePerKilogram);
         }
@@ -320,7 +302,7 @@ public static Molality FromMolesPerKilogram(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Molality unit value.</returns>
-        public static Molality From(double value, MolalityUnit fromUnit)
+        public static Molality From(QuantityValue value, MolalityUnit fromUnit)
         {
             return new Molality(value, fromUnit);
         }
@@ -381,10 +363,7 @@ public static Molality Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Molality Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Molality, MolalityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Molality, MolalityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -412,11 +391,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Molality result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Molality result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Molality, MolalityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Molality, MolalityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -437,7 +412,7 @@ public static MolalityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -448,7 +423,7 @@ public static MolalityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolalityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MolalityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolalityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -463,7 +438,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolalityUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MolalityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -482,35 +457,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Molality"/> from adding two <see cref="Molality"/>.</summary>
         public static Molality operator +(Molality left, Molality right)
         {
-            return new Molality(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Molality(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Molality"/> from subtracting two <see cref="Molality"/>.</summary>
         public static Molality operator -(Molality left, Molality right)
         {
-            return new Molality(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Molality(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Molality"/> from multiplying value and <see cref="Molality"/>.</summary>
-        public static Molality operator *(double left, Molality right)
+        public static Molality operator *(QuantityValue left, Molality right)
         {
             return new Molality(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Molality"/> from multiplying value and <see cref="Molality"/>.</summary>
-        public static Molality operator *(Molality left, double right)
+        public static Molality operator *(Molality left, QuantityValue right)
         {
             return new Molality(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Molality"/> from dividing <see cref="Molality"/> by value.</summary>
-        public static Molality operator /(Molality left, double right)
+        public static Molality operator /(Molality left, QuantityValue right)
         {
             return new Molality(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Molality"/> by <see cref="Molality"/>.</summary>
-        public static double operator /(Molality left, Molality right)
+        public static QuantityValue operator /(Molality left, Molality right)
         {
             return left.MolesPerKilogram / right.MolesPerKilogram;
         }
@@ -522,97 +497,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Molality left, Molality right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Molality left, Molality right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Molality left, Molality right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Molality left, Molality right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Molality"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Molality other, Molality tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Molality"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Molality)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Molality left, Molality right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Molality"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Molality other, Molality tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Molality"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Molality,Molality)"/>.
+        ///     See that operator (and <see cref="Equals(Molality)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Molality left, Molality right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Molality"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Molality other, Molality tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Molality"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Molality"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Molality"/>, this method delegates to
+        ///     <see cref="Equals(Molality)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Molality otherQuantity))
+            if (obj is not Molality otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Molality"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Molality other, Molality tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Molality"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Molality other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Molality.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Molality), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Molality"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Molality)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Molality otherQuantity)) throw new ArgumentException("Expected type Molality.", nameof(obj));
+            if (obj is not Molality otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Molality>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Molality"/> with another <see cref="Molality"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Molality"/> with another <see cref="Molality"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -624,135 +613,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Molality other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MolalityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MolalityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Molality to another Molality with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Molality with the specified unit.</returns>
-        public Molality ToUnit(MolalityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Molality"/> to another <see cref="Molality"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Molality with the specified unit.</returns>
-        public Molality ToUnit(MolalityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Molality), Unit, typeof(Molality), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Molality)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Molality"/> to another <see cref="Molality"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Molality"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MolalityUnit unit, [NotNullWhen(true)] out Molality? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Molality? convertedOrNull = (Unit, unit) switch
-            {
-                // MolalityUnit -> BaseUnit
-                (MolalityUnit.MillimolePerKilogram, MolalityUnit.MolePerKilogram) => new Molality((_value) * 1e-3d, MolalityUnit.MolePerKilogram),
-                (MolalityUnit.MolePerGram, MolalityUnit.MolePerKilogram) => new Molality(_value / 1e-3, MolalityUnit.MolePerKilogram),
-
-                // BaseUnit -> MolalityUnit
-                (MolalityUnit.MolePerKilogram, MolalityUnit.MillimolePerKilogram) => new Molality((_value) / 1e-3d, MolalityUnit.MillimolePerKilogram),
-                (MolalityUnit.MolePerKilogram, MolalityUnit.MolePerGram) => new Molality(_value * 1e-3, MolalityUnit.MolePerGram),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MolalityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolalityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MolalityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolalityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MolalityUnit> IQuantity<MolalityUnit>.ToUnit(MolalityUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -764,11 +629,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
index d1427d6250..67a4e4b37a 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Molar energy is the amount of energy stored in 1 mole of a substance.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MolarEnergy :
-        IArithmeticQuantity<MolarEnergy, MolarEnergyUnit>,
+        ILinearQuantity<MolarEnergy, MolarEnergyUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MolarEnergy, MolarEnergy, double>,
+        IDivisionOperators<MolarEnergy, MolarEnergy, QuantityValue>,
         IMultiplyOperators<MolarEnergy, AmountOfSubstance, Energy>,
         IComparisonOperators<MolarEnergy, MolarEnergy, bool>,
         IParsable<MolarEnergy>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static MolarEnergyInfo CreateDefault(Func<IEnumerable<UnitDefinition<Mola
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="MolarEnergy"/> is [T^-2][L^2][M][N^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="MolarEnergy"/> is T^-2L^2MN^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -2, 0, 0, -1, 0);
 
@@ -119,16 +118,18 @@ public static MolarEnergyInfo CreateDefault(Func<IEnumerable<UnitDefinition<Mola
             public static IEnumerable<UnitDefinition<MolarEnergyUnit>> GetDefaultMappings()
             {
                 yield return new (MolarEnergyUnit.JoulePerMole, "JoulePerMole", "JoulesPerMole", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarEnergyUnit.KilojoulePerMole, "KilojoulePerMole", "KilojoulesPerMole", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, amount: AmountOfSubstanceUnit.Millimole));
-                yield return new (MolarEnergyUnit.MegajoulePerMole, "MegajoulePerMole", "MegajoulesPerMole", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, amount: AmountOfSubstanceUnit.Micromole));
+                yield return new (MolarEnergyUnit.KilojoulePerMole, "KilojoulePerMole", "KilojoulesPerMole", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, amount: AmountOfSubstanceUnit.Millimole),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MolarEnergyUnit.MegajoulePerMole, "MegajoulePerMole", "MegajoulesPerMole", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, amount: AmountOfSubstanceUnit.Micromole),
+                     new QuantityValue(1, 1000000)
+                );
             }
         }
 
         static MolarEnergy()
         {
-            Info = MolarEnergyInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MolarEnergyInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +137,7 @@ static MolarEnergy()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MolarEnergy(double value, MolarEnergyUnit unit)
+        public MolarEnergy(QuantityValue value, MolarEnergyUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -150,7 +151,7 @@ public MolarEnergy(double value, MolarEnergyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MolarEnergy(double value, UnitSystem unitSystem)
+        public MolarEnergy(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -161,7 +162,8 @@ public MolarEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MolarEnergy" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MolarEnergy, MolarEnergyUnit> Info { get; }
@@ -190,10 +192,8 @@ public MolarEnergy(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MolarEnergyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,42 +227,24 @@ public MolarEnergy(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEnergyUnit.JoulePerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarEnergyUnit.JoulePerMole"/>
         /// </summary>
-        public double JoulesPerMole => As(MolarEnergyUnit.JoulePerMole);
+        public QuantityValue JoulesPerMole => this.As(MolarEnergyUnit.JoulePerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEnergyUnit.KilojoulePerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarEnergyUnit.KilojoulePerMole"/>
         /// </summary>
-        public double KilojoulesPerMole => As(MolarEnergyUnit.KilojoulePerMole);
+        public QuantityValue KilojoulesPerMole => this.As(MolarEnergyUnit.KilojoulePerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEnergyUnit.MegajoulePerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarEnergyUnit.MegajoulePerMole"/>
         /// </summary>
-        public double MegajoulesPerMole => As(MolarEnergyUnit.MegajoulePerMole);
+        public QuantityValue MegajoulesPerMole => this.As(MolarEnergyUnit.MegajoulePerMole);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MolarEnergyUnit -> BaseUnit
-            unitConverter.SetConversionFunction<MolarEnergy>(MolarEnergyUnit.KilojoulePerMole, MolarEnergyUnit.JoulePerMole, quantity => quantity.ToUnit(MolarEnergyUnit.JoulePerMole));
-            unitConverter.SetConversionFunction<MolarEnergy>(MolarEnergyUnit.MegajoulePerMole, MolarEnergyUnit.JoulePerMole, quantity => quantity.ToUnit(MolarEnergyUnit.JoulePerMole));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MolarEnergy>(MolarEnergyUnit.JoulePerMole, MolarEnergyUnit.JoulePerMole, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MolarEnergyUnit
-            unitConverter.SetConversionFunction<MolarEnergy>(MolarEnergyUnit.JoulePerMole, MolarEnergyUnit.KilojoulePerMole, quantity => quantity.ToUnit(MolarEnergyUnit.KilojoulePerMole));
-            unitConverter.SetConversionFunction<MolarEnergy>(MolarEnergyUnit.JoulePerMole, MolarEnergyUnit.MegajoulePerMole, quantity => quantity.ToUnit(MolarEnergyUnit.MegajoulePerMole));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -291,7 +273,7 @@ public static string GetAbbreviation(MolarEnergyUnit unit, IFormatProvider? prov
         /// <summary>
         ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.JoulePerMole"/>.
         /// </summary>
-        public static MolarEnergy FromJoulesPerMole(double value)
+        public static MolarEnergy FromJoulesPerMole(QuantityValue value)
         {
             return new MolarEnergy(value, MolarEnergyUnit.JoulePerMole);
         }
@@ -299,7 +281,7 @@ public static MolarEnergy FromJoulesPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.KilojoulePerMole"/>.
         /// </summary>
-        public static MolarEnergy FromKilojoulesPerMole(double value)
+        public static MolarEnergy FromKilojoulesPerMole(QuantityValue value)
         {
             return new MolarEnergy(value, MolarEnergyUnit.KilojoulePerMole);
         }
@@ -307,7 +289,7 @@ public static MolarEnergy FromKilojoulesPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.MegajoulePerMole"/>.
         /// </summary>
-        public static MolarEnergy FromMegajoulesPerMole(double value)
+        public static MolarEnergy FromMegajoulesPerMole(QuantityValue value)
         {
             return new MolarEnergy(value, MolarEnergyUnit.MegajoulePerMole);
         }
@@ -318,7 +300,7 @@ public static MolarEnergy FromMegajoulesPerMole(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MolarEnergy unit value.</returns>
-        public static MolarEnergy From(double value, MolarEnergyUnit fromUnit)
+        public static MolarEnergy From(QuantityValue value, MolarEnergyUnit fromUnit)
         {
             return new MolarEnergy(value, fromUnit);
         }
@@ -379,10 +361,7 @@ public static MolarEnergy Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MolarEnergy Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MolarEnergy, MolarEnergyUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MolarEnergy, MolarEnergyUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -410,11 +389,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MolarEnergy resu
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MolarEnergy result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MolarEnergy, MolarEnergyUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MolarEnergy, MolarEnergyUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -435,7 +410,7 @@ public static MolarEnergyUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -446,7 +421,7 @@ public static MolarEnergyUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolarEnergyUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MolarEnergyUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarEnergyUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -461,7 +436,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarEnergyU
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MolarEnergyUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -480,35 +455,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MolarEnergy"/> from adding two <see cref="MolarEnergy"/>.</summary>
         public static MolarEnergy operator +(MolarEnergy left, MolarEnergy right)
         {
-            return new MolarEnergy(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MolarEnergy(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MolarEnergy"/> from subtracting two <see cref="MolarEnergy"/>.</summary>
         public static MolarEnergy operator -(MolarEnergy left, MolarEnergy right)
         {
-            return new MolarEnergy(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MolarEnergy(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MolarEnergy"/> from multiplying value and <see cref="MolarEnergy"/>.</summary>
-        public static MolarEnergy operator *(double left, MolarEnergy right)
+        public static MolarEnergy operator *(QuantityValue left, MolarEnergy right)
         {
             return new MolarEnergy(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MolarEnergy"/> from multiplying value and <see cref="MolarEnergy"/>.</summary>
-        public static MolarEnergy operator *(MolarEnergy left, double right)
+        public static MolarEnergy operator *(MolarEnergy left, QuantityValue right)
         {
             return new MolarEnergy(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MolarEnergy"/> from dividing <see cref="MolarEnergy"/> by value.</summary>
-        public static MolarEnergy operator /(MolarEnergy left, double right)
+        public static MolarEnergy operator /(MolarEnergy left, QuantityValue right)
         {
             return new MolarEnergy(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MolarEnergy"/> by <see cref="MolarEnergy"/>.</summary>
-        public static double operator /(MolarEnergy left, MolarEnergy right)
+        public static QuantityValue operator /(MolarEnergy left, MolarEnergy right)
         {
             return left.JoulesPerMole / right.JoulesPerMole;
         }
@@ -530,97 +505,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MolarEnergy left, MolarEnergy right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MolarEnergy left, MolarEnergy right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MolarEnergy left, MolarEnergy right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MolarEnergy left, MolarEnergy right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MolarEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MolarEnergy other, MolarEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MolarEnergy"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MolarEnergy)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MolarEnergy left, MolarEnergy right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MolarEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MolarEnergy other, MolarEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MolarEnergy"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MolarEnergy,MolarEnergy)"/>.
+        ///     See that operator (and <see cref="Equals(MolarEnergy)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MolarEnergy left, MolarEnergy right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MolarEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MolarEnergy other, MolarEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MolarEnergy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MolarEnergy"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MolarEnergy"/>, this method delegates to
+        ///     <see cref="Equals(MolarEnergy)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MolarEnergy otherQuantity))
+            if (obj is not MolarEnergy otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MolarEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MolarEnergy other, MolarEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MolarEnergy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MolarEnergy other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MolarEnergy.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MolarEnergy), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MolarEnergy"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MolarEnergy)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MolarEnergy otherQuantity)) throw new ArgumentException("Expected type MolarEnergy.", nameof(obj));
+            if (obj is not MolarEnergy otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MolarEnergy>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MolarEnergy"/> with another <see cref="MolarEnergy"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MolarEnergy"/> with another <see cref="MolarEnergy"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -632,135 +621,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MolarEnergy other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MolarEnergyUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MolarEnergyUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this MolarEnergy to another MolarEnergy with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MolarEnergy with the specified unit.</returns>
-        public MolarEnergy ToUnit(MolarEnergyUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="MolarEnergy"/> to another <see cref="MolarEnergy"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MolarEnergy with the specified unit.</returns>
-        public MolarEnergy ToUnit(MolarEnergyUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MolarEnergy), Unit, typeof(MolarEnergy), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MolarEnergy)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="MolarEnergy"/> to another <see cref="MolarEnergy"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MolarEnergy"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MolarEnergyUnit unit, [NotNullWhen(true)] out MolarEnergy? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MolarEnergy? convertedOrNull = (Unit, unit) switch
-            {
-                // MolarEnergyUnit -> BaseUnit
-                (MolarEnergyUnit.KilojoulePerMole, MolarEnergyUnit.JoulePerMole) => new MolarEnergy((_value) * 1e3d, MolarEnergyUnit.JoulePerMole),
-                (MolarEnergyUnit.MegajoulePerMole, MolarEnergyUnit.JoulePerMole) => new MolarEnergy((_value) * 1e6d, MolarEnergyUnit.JoulePerMole),
-
-                // BaseUnit -> MolarEnergyUnit
-                (MolarEnergyUnit.JoulePerMole, MolarEnergyUnit.KilojoulePerMole) => new MolarEnergy((_value) / 1e3d, MolarEnergyUnit.KilojoulePerMole),
-                (MolarEnergyUnit.JoulePerMole, MolarEnergyUnit.MegajoulePerMole) => new MolarEnergy((_value) / 1e6d, MolarEnergyUnit.MegajoulePerMole),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MolarEnergyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEnergyUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MolarEnergyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEnergyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MolarEnergyUnit> IQuantity<MolarEnergyUnit>.ToUnit(MolarEnergyUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -772,11 +637,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
index df7026eb59..c0a5fda05e 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Molar entropy is amount of energy required to increase temperature of 1 mole substance by 1 Kelvin.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MolarEntropy :
-        IArithmeticQuantity<MolarEntropy, MolarEntropyUnit>,
+        ILinearQuantity<MolarEntropy, MolarEntropyUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MolarEntropy, MolarEntropy, double>,
+        IDivisionOperators<MolarEntropy, MolarEntropy, QuantityValue>,
         IComparisonOperators<MolarEntropy, MolarEntropy, bool>,
         IParsable<MolarEntropy>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +101,7 @@ public static MolarEntropyInfo CreateDefault(Func<IEnumerable<UnitDefinition<Mol
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="MolarEntropy"/> is [T^-2][L^2][M][Θ^-1][N^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="MolarEntropy"/> is T^-2L^2MΘ^-1N^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -2, 0, -1, -1, 0);
 
@@ -118,16 +117,18 @@ public static MolarEntropyInfo CreateDefault(Func<IEnumerable<UnitDefinition<Mol
             public static IEnumerable<UnitDefinition<MolarEntropyUnit>> GetDefaultMappings()
             {
                 yield return new (MolarEntropyUnit.JoulePerMoleKelvin, "JoulePerMoleKelvin", "JoulesPerMoleKelvin", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarEntropyUnit.KilojoulePerMoleKelvin, "KilojoulePerMoleKelvin", "KilojoulesPerMoleKelvin", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin, amount: AmountOfSubstanceUnit.Millimole));
-                yield return new (MolarEntropyUnit.MegajoulePerMoleKelvin, "MegajoulePerMoleKelvin", "MegajoulesPerMoleKelvin", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin, amount: AmountOfSubstanceUnit.Micromole));
+                yield return new (MolarEntropyUnit.KilojoulePerMoleKelvin, "KilojoulePerMoleKelvin", "KilojoulesPerMoleKelvin", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin, amount: AmountOfSubstanceUnit.Millimole),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MolarEntropyUnit.MegajoulePerMoleKelvin, "MegajoulePerMoleKelvin", "MegajoulesPerMoleKelvin", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin, amount: AmountOfSubstanceUnit.Micromole),
+                     new QuantityValue(1, 1000000)
+                );
             }
         }
 
         static MolarEntropy()
         {
-            Info = MolarEntropyInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MolarEntropyInfo.CreateDefault);
         }
 
         /// <summary>
@@ -135,7 +136,7 @@ static MolarEntropy()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MolarEntropy(double value, MolarEntropyUnit unit)
+        public MolarEntropy(QuantityValue value, MolarEntropyUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -149,7 +150,7 @@ public MolarEntropy(double value, MolarEntropyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MolarEntropy(double value, UnitSystem unitSystem)
+        public MolarEntropy(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -160,7 +161,8 @@ public MolarEntropy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MolarEntropy" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MolarEntropy, MolarEntropyUnit> Info { get; }
@@ -189,10 +191,8 @@ public MolarEntropy(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MolarEntropyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -226,42 +226,24 @@ public MolarEntropy(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEntropyUnit.JoulePerMoleKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarEntropyUnit.JoulePerMoleKelvin"/>
         /// </summary>
-        public double JoulesPerMoleKelvin => As(MolarEntropyUnit.JoulePerMoleKelvin);
+        public QuantityValue JoulesPerMoleKelvin => this.As(MolarEntropyUnit.JoulePerMoleKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEntropyUnit.KilojoulePerMoleKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarEntropyUnit.KilojoulePerMoleKelvin"/>
         /// </summary>
-        public double KilojoulesPerMoleKelvin => As(MolarEntropyUnit.KilojoulePerMoleKelvin);
+        public QuantityValue KilojoulesPerMoleKelvin => this.As(MolarEntropyUnit.KilojoulePerMoleKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarEntropyUnit.MegajoulePerMoleKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarEntropyUnit.MegajoulePerMoleKelvin"/>
         /// </summary>
-        public double MegajoulesPerMoleKelvin => As(MolarEntropyUnit.MegajoulePerMoleKelvin);
+        public QuantityValue MegajoulesPerMoleKelvin => this.As(MolarEntropyUnit.MegajoulePerMoleKelvin);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MolarEntropyUnit -> BaseUnit
-            unitConverter.SetConversionFunction<MolarEntropy>(MolarEntropyUnit.KilojoulePerMoleKelvin, MolarEntropyUnit.JoulePerMoleKelvin, quantity => quantity.ToUnit(MolarEntropyUnit.JoulePerMoleKelvin));
-            unitConverter.SetConversionFunction<MolarEntropy>(MolarEntropyUnit.MegajoulePerMoleKelvin, MolarEntropyUnit.JoulePerMoleKelvin, quantity => quantity.ToUnit(MolarEntropyUnit.JoulePerMoleKelvin));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MolarEntropy>(MolarEntropyUnit.JoulePerMoleKelvin, MolarEntropyUnit.JoulePerMoleKelvin, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MolarEntropyUnit
-            unitConverter.SetConversionFunction<MolarEntropy>(MolarEntropyUnit.JoulePerMoleKelvin, MolarEntropyUnit.KilojoulePerMoleKelvin, quantity => quantity.ToUnit(MolarEntropyUnit.KilojoulePerMoleKelvin));
-            unitConverter.SetConversionFunction<MolarEntropy>(MolarEntropyUnit.JoulePerMoleKelvin, MolarEntropyUnit.MegajoulePerMoleKelvin, quantity => quantity.ToUnit(MolarEntropyUnit.MegajoulePerMoleKelvin));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -290,7 +272,7 @@ public static string GetAbbreviation(MolarEntropyUnit unit, IFormatProvider? pro
         /// <summary>
         ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.JoulePerMoleKelvin"/>.
         /// </summary>
-        public static MolarEntropy FromJoulesPerMoleKelvin(double value)
+        public static MolarEntropy FromJoulesPerMoleKelvin(QuantityValue value)
         {
             return new MolarEntropy(value, MolarEntropyUnit.JoulePerMoleKelvin);
         }
@@ -298,7 +280,7 @@ public static MolarEntropy FromJoulesPerMoleKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.KilojoulePerMoleKelvin"/>.
         /// </summary>
-        public static MolarEntropy FromKilojoulesPerMoleKelvin(double value)
+        public static MolarEntropy FromKilojoulesPerMoleKelvin(QuantityValue value)
         {
             return new MolarEntropy(value, MolarEntropyUnit.KilojoulePerMoleKelvin);
         }
@@ -306,7 +288,7 @@ public static MolarEntropy FromKilojoulesPerMoleKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.MegajoulePerMoleKelvin"/>.
         /// </summary>
-        public static MolarEntropy FromMegajoulesPerMoleKelvin(double value)
+        public static MolarEntropy FromMegajoulesPerMoleKelvin(QuantityValue value)
         {
             return new MolarEntropy(value, MolarEntropyUnit.MegajoulePerMoleKelvin);
         }
@@ -317,7 +299,7 @@ public static MolarEntropy FromMegajoulesPerMoleKelvin(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MolarEntropy unit value.</returns>
-        public static MolarEntropy From(double value, MolarEntropyUnit fromUnit)
+        public static MolarEntropy From(QuantityValue value, MolarEntropyUnit fromUnit)
         {
             return new MolarEntropy(value, fromUnit);
         }
@@ -378,10 +360,7 @@ public static MolarEntropy Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MolarEntropy Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MolarEntropy, MolarEntropyUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MolarEntropy, MolarEntropyUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -409,11 +388,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MolarEntropy res
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MolarEntropy result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MolarEntropy, MolarEntropyUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MolarEntropy, MolarEntropyUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -434,7 +409,7 @@ public static MolarEntropyUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -445,7 +420,7 @@ public static MolarEntropyUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolarEntropyUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MolarEntropyUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarEntropyUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -460,7 +435,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarEntropy
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MolarEntropyUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -479,35 +454,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MolarEntropy"/> from adding two <see cref="MolarEntropy"/>.</summary>
         public static MolarEntropy operator +(MolarEntropy left, MolarEntropy right)
         {
-            return new MolarEntropy(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MolarEntropy(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MolarEntropy"/> from subtracting two <see cref="MolarEntropy"/>.</summary>
         public static MolarEntropy operator -(MolarEntropy left, MolarEntropy right)
         {
-            return new MolarEntropy(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MolarEntropy(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MolarEntropy"/> from multiplying value and <see cref="MolarEntropy"/>.</summary>
-        public static MolarEntropy operator *(double left, MolarEntropy right)
+        public static MolarEntropy operator *(QuantityValue left, MolarEntropy right)
         {
             return new MolarEntropy(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MolarEntropy"/> from multiplying value and <see cref="MolarEntropy"/>.</summary>
-        public static MolarEntropy operator *(MolarEntropy left, double right)
+        public static MolarEntropy operator *(MolarEntropy left, QuantityValue right)
         {
             return new MolarEntropy(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MolarEntropy"/> from dividing <see cref="MolarEntropy"/> by value.</summary>
-        public static MolarEntropy operator /(MolarEntropy left, double right)
+        public static MolarEntropy operator /(MolarEntropy left, QuantityValue right)
         {
             return new MolarEntropy(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MolarEntropy"/> by <see cref="MolarEntropy"/>.</summary>
-        public static double operator /(MolarEntropy left, MolarEntropy right)
+        public static QuantityValue operator /(MolarEntropy left, MolarEntropy right)
         {
             return left.JoulesPerMoleKelvin / right.JoulesPerMoleKelvin;
         }
@@ -519,97 +494,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MolarEntropy left, MolarEntropy right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MolarEntropy left, MolarEntropy right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MolarEntropy left, MolarEntropy right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MolarEntropy left, MolarEntropy right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MolarEntropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MolarEntropy other, MolarEntropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MolarEntropy"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MolarEntropy)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MolarEntropy left, MolarEntropy right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MolarEntropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MolarEntropy other, MolarEntropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MolarEntropy"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MolarEntropy,MolarEntropy)"/>.
+        ///     See that operator (and <see cref="Equals(MolarEntropy)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MolarEntropy left, MolarEntropy right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MolarEntropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MolarEntropy other, MolarEntropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MolarEntropy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MolarEntropy"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MolarEntropy"/>, this method delegates to
+        ///     <see cref="Equals(MolarEntropy)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MolarEntropy otherQuantity))
+            if (obj is not MolarEntropy otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MolarEntropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MolarEntropy other, MolarEntropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MolarEntropy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MolarEntropy other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MolarEntropy.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MolarEntropy), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MolarEntropy"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MolarEntropy)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MolarEntropy otherQuantity)) throw new ArgumentException("Expected type MolarEntropy.", nameof(obj));
+            if (obj is not MolarEntropy otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MolarEntropy>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MolarEntropy"/> with another <see cref="MolarEntropy"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MolarEntropy"/> with another <see cref="MolarEntropy"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -621,135 +610,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MolarEntropy other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MolarEntropyUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MolarEntropyUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this MolarEntropy to another MolarEntropy with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MolarEntropy with the specified unit.</returns>
-        public MolarEntropy ToUnit(MolarEntropyUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="MolarEntropy"/> to another <see cref="MolarEntropy"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MolarEntropy with the specified unit.</returns>
-        public MolarEntropy ToUnit(MolarEntropyUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MolarEntropy), Unit, typeof(MolarEntropy), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MolarEntropy)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="MolarEntropy"/> to another <see cref="MolarEntropy"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MolarEntropy"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MolarEntropyUnit unit, [NotNullWhen(true)] out MolarEntropy? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MolarEntropy? convertedOrNull = (Unit, unit) switch
-            {
-                // MolarEntropyUnit -> BaseUnit
-                (MolarEntropyUnit.KilojoulePerMoleKelvin, MolarEntropyUnit.JoulePerMoleKelvin) => new MolarEntropy((_value) * 1e3d, MolarEntropyUnit.JoulePerMoleKelvin),
-                (MolarEntropyUnit.MegajoulePerMoleKelvin, MolarEntropyUnit.JoulePerMoleKelvin) => new MolarEntropy((_value) * 1e6d, MolarEntropyUnit.JoulePerMoleKelvin),
-
-                // BaseUnit -> MolarEntropyUnit
-                (MolarEntropyUnit.JoulePerMoleKelvin, MolarEntropyUnit.KilojoulePerMoleKelvin) => new MolarEntropy((_value) / 1e3d, MolarEntropyUnit.KilojoulePerMoleKelvin),
-                (MolarEntropyUnit.JoulePerMoleKelvin, MolarEntropyUnit.MegajoulePerMoleKelvin) => new MolarEntropy((_value) / 1e6d, MolarEntropyUnit.MegajoulePerMoleKelvin),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MolarEntropyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEntropyUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MolarEntropyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEntropyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MolarEntropyUnit> IQuantity<MolarEntropyUnit>.ToUnit(MolarEntropyUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -761,11 +626,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
index cfaf99aa5f..af2f778a9b 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Molar flow is the ratio of the amount of substance change to the time during which the change occurred (value of amount of substance changes per unit time).
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MolarFlow :
-        IArithmeticQuantity<MolarFlow, MolarFlowUnit>,
+        ILinearQuantity<MolarFlow, MolarFlowUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MolarFlow, MolarFlow, double>,
+        IDivisionOperators<MolarFlow, MolarFlow, QuantityValue>,
         IMultiplyOperators<MolarFlow, Duration, AmountOfSubstance>,
         IMultiplyOperators<MolarFlow, MolarMass, MassFlow>,
         IDivisionOperators<MolarFlow, VolumeFlow, Molarity>,
@@ -56,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -106,7 +105,7 @@ public static MolarFlowInfo CreateDefault(Func<IEnumerable<UnitDefinition<MolarF
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="MolarFlow"/> is [T^-1][N].
+            ///     The <see cref="BaseDimensions" /> for <see cref="MolarFlow"/> is T^-1N.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, -1, 0, 0, 1, 0);
 
@@ -121,23 +120,37 @@ public static MolarFlowInfo CreateDefault(Func<IEnumerable<UnitDefinition<MolarF
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MolarFlowUnit}"/> representing the default unit mappings for MolarFlow.</returns>
             public static IEnumerable<UnitDefinition<MolarFlowUnit>> GetDefaultMappings()
             {
-                yield return new (MolarFlowUnit.KilomolePerHour, "KilomolePerHour", "KilomolesPerHour", new BaseUnits(time: DurationUnit.Hour, amount: AmountOfSubstanceUnit.Kilomole));
-                yield return new (MolarFlowUnit.KilomolePerMinute, "KilomolePerMinute", "KilomolesPerMinute", new BaseUnits(time: DurationUnit.Minute, amount: AmountOfSubstanceUnit.Kilomole));
-                yield return new (MolarFlowUnit.KilomolePerSecond, "KilomolePerSecond", "KilomolesPerSecond", new BaseUnits(time: DurationUnit.Second, amount: AmountOfSubstanceUnit.Kilomole));
-                yield return new (MolarFlowUnit.MolePerHour, "MolePerHour", "MolesPerHour", new BaseUnits(time: DurationUnit.Hour, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarFlowUnit.MolePerMinute, "MolePerMinute", "MolesPerMinute", new BaseUnits(time: DurationUnit.Minute, amount: AmountOfSubstanceUnit.Mole));
+                yield return new (MolarFlowUnit.KilomolePerHour, "KilomolePerHour", "KilomolesPerHour", new BaseUnits(time: DurationUnit.Hour, amount: AmountOfSubstanceUnit.Kilomole),
+                     new QuantityValue(18, 5)
+                );
+                yield return new (MolarFlowUnit.KilomolePerMinute, "KilomolePerMinute", "KilomolesPerMinute", new BaseUnits(time: DurationUnit.Minute, amount: AmountOfSubstanceUnit.Kilomole),
+                     new QuantityValue(3, 50)
+                );
+                yield return new (MolarFlowUnit.KilomolePerSecond, "KilomolePerSecond", "KilomolesPerSecond", new BaseUnits(time: DurationUnit.Second, amount: AmountOfSubstanceUnit.Kilomole),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MolarFlowUnit.MolePerHour, "MolePerHour", "MolesPerHour", new BaseUnits(time: DurationUnit.Hour, amount: AmountOfSubstanceUnit.Mole),
+                     3600
+                );
+                yield return new (MolarFlowUnit.MolePerMinute, "MolePerMinute", "MolesPerMinute", new BaseUnits(time: DurationUnit.Minute, amount: AmountOfSubstanceUnit.Mole),
+                     60
+                );
                 yield return new (MolarFlowUnit.MolePerSecond, "MolePerSecond", "MolesPerSecond", new BaseUnits(time: DurationUnit.Second, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarFlowUnit.PoundMolePerHour, "PoundMolePerHour", "PoundMolesPerHour", new BaseUnits(time: DurationUnit.Hour, amount: AmountOfSubstanceUnit.PoundMole));
-                yield return new (MolarFlowUnit.PoundMolePerMinute, "PoundMolePerMinute", "PoundMolesPerMinute", new BaseUnits(time: DurationUnit.Minute, amount: AmountOfSubstanceUnit.PoundMole));
-                yield return new (MolarFlowUnit.PoundMolePerSecond, "PoundMolePerSecond", "PoundMolesPerSecond", new BaseUnits(time: DurationUnit.Second, amount: AmountOfSubstanceUnit.PoundMole));
+                yield return new (MolarFlowUnit.PoundMolePerHour, "PoundMolePerHour", "PoundMolesPerHour", new BaseUnits(time: DurationUnit.Hour, amount: AmountOfSubstanceUnit.PoundMole),
+                     new QuantityValue(360000000, 45359237)
+                );
+                yield return new (MolarFlowUnit.PoundMolePerMinute, "PoundMolePerMinute", "PoundMolesPerMinute", new BaseUnits(time: DurationUnit.Minute, amount: AmountOfSubstanceUnit.PoundMole),
+                     new QuantityValue(6000000, 45359237)
+                );
+                yield return new (MolarFlowUnit.PoundMolePerSecond, "PoundMolePerSecond", "PoundMolesPerSecond", new BaseUnits(time: DurationUnit.Second, amount: AmountOfSubstanceUnit.PoundMole),
+                     new QuantityValue(100000, 45359237)
+                );
             }
         }
 
         static MolarFlow()
         {
-            Info = MolarFlowInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MolarFlowInfo.CreateDefault);
         }
 
         /// <summary>
@@ -145,7 +158,7 @@ static MolarFlow()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MolarFlow(double value, MolarFlowUnit unit)
+        public MolarFlow(QuantityValue value, MolarFlowUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -159,7 +172,7 @@ public MolarFlow(double value, MolarFlowUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MolarFlow(double value, UnitSystem unitSystem)
+        public MolarFlow(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -170,7 +183,8 @@ public MolarFlow(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MolarFlow" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MolarFlow, MolarFlowUnit> Info { get; }
@@ -199,10 +213,8 @@ public MolarFlow(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MolarFlowUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -236,84 +248,54 @@ public MolarFlow(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.KilomolePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarFlowUnit.KilomolePerHour"/>
         /// </summary>
-        public double KilomolesPerHour => As(MolarFlowUnit.KilomolePerHour);
+        public QuantityValue KilomolesPerHour => this.As(MolarFlowUnit.KilomolePerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.KilomolePerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarFlowUnit.KilomolePerMinute"/>
         /// </summary>
-        public double KilomolesPerMinute => As(MolarFlowUnit.KilomolePerMinute);
+        public QuantityValue KilomolesPerMinute => this.As(MolarFlowUnit.KilomolePerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.KilomolePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarFlowUnit.KilomolePerSecond"/>
         /// </summary>
-        public double KilomolesPerSecond => As(MolarFlowUnit.KilomolePerSecond);
+        public QuantityValue KilomolesPerSecond => this.As(MolarFlowUnit.KilomolePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.MolePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarFlowUnit.MolePerHour"/>
         /// </summary>
-        public double MolesPerHour => As(MolarFlowUnit.MolePerHour);
+        public QuantityValue MolesPerHour => this.As(MolarFlowUnit.MolePerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.MolePerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarFlowUnit.MolePerMinute"/>
         /// </summary>
-        public double MolesPerMinute => As(MolarFlowUnit.MolePerMinute);
+        public QuantityValue MolesPerMinute => this.As(MolarFlowUnit.MolePerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.MolePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarFlowUnit.MolePerSecond"/>
         /// </summary>
-        public double MolesPerSecond => As(MolarFlowUnit.MolePerSecond);
+        public QuantityValue MolesPerSecond => this.As(MolarFlowUnit.MolePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.PoundMolePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarFlowUnit.PoundMolePerHour"/>
         /// </summary>
-        public double PoundMolesPerHour => As(MolarFlowUnit.PoundMolePerHour);
+        public QuantityValue PoundMolesPerHour => this.As(MolarFlowUnit.PoundMolePerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.PoundMolePerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarFlowUnit.PoundMolePerMinute"/>
         /// </summary>
-        public double PoundMolesPerMinute => As(MolarFlowUnit.PoundMolePerMinute);
+        public QuantityValue PoundMolesPerMinute => this.As(MolarFlowUnit.PoundMolePerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarFlowUnit.PoundMolePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarFlowUnit.PoundMolePerSecond"/>
         /// </summary>
-        public double PoundMolesPerSecond => As(MolarFlowUnit.PoundMolePerSecond);
+        public QuantityValue PoundMolesPerSecond => this.As(MolarFlowUnit.PoundMolePerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MolarFlowUnit -> BaseUnit
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.KilomolePerHour, MolarFlowUnit.MolePerSecond, quantity => quantity.ToUnit(MolarFlowUnit.MolePerSecond));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.KilomolePerMinute, MolarFlowUnit.MolePerSecond, quantity => quantity.ToUnit(MolarFlowUnit.MolePerSecond));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.KilomolePerSecond, MolarFlowUnit.MolePerSecond, quantity => quantity.ToUnit(MolarFlowUnit.MolePerSecond));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerHour, MolarFlowUnit.MolePerSecond, quantity => quantity.ToUnit(MolarFlowUnit.MolePerSecond));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerMinute, MolarFlowUnit.MolePerSecond, quantity => quantity.ToUnit(MolarFlowUnit.MolePerSecond));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.PoundMolePerHour, MolarFlowUnit.MolePerSecond, quantity => quantity.ToUnit(MolarFlowUnit.MolePerSecond));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.PoundMolePerMinute, MolarFlowUnit.MolePerSecond, quantity => quantity.ToUnit(MolarFlowUnit.MolePerSecond));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.PoundMolePerSecond, MolarFlowUnit.MolePerSecond, quantity => quantity.ToUnit(MolarFlowUnit.MolePerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerSecond, MolarFlowUnit.MolePerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MolarFlowUnit
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerSecond, MolarFlowUnit.KilomolePerHour, quantity => quantity.ToUnit(MolarFlowUnit.KilomolePerHour));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerSecond, MolarFlowUnit.KilomolePerMinute, quantity => quantity.ToUnit(MolarFlowUnit.KilomolePerMinute));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerSecond, MolarFlowUnit.KilomolePerSecond, quantity => quantity.ToUnit(MolarFlowUnit.KilomolePerSecond));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerSecond, MolarFlowUnit.MolePerHour, quantity => quantity.ToUnit(MolarFlowUnit.MolePerHour));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerSecond, MolarFlowUnit.MolePerMinute, quantity => quantity.ToUnit(MolarFlowUnit.MolePerMinute));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerSecond, MolarFlowUnit.PoundMolePerHour, quantity => quantity.ToUnit(MolarFlowUnit.PoundMolePerHour));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerSecond, MolarFlowUnit.PoundMolePerMinute, quantity => quantity.ToUnit(MolarFlowUnit.PoundMolePerMinute));
-            unitConverter.SetConversionFunction<MolarFlow>(MolarFlowUnit.MolePerSecond, MolarFlowUnit.PoundMolePerSecond, quantity => quantity.ToUnit(MolarFlowUnit.PoundMolePerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -342,7 +324,7 @@ public static string GetAbbreviation(MolarFlowUnit unit, IFormatProvider? provid
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerHour"/>.
         /// </summary>
-        public static MolarFlow FromKilomolesPerHour(double value)
+        public static MolarFlow FromKilomolesPerHour(QuantityValue value)
         {
             return new MolarFlow(value, MolarFlowUnit.KilomolePerHour);
         }
@@ -350,7 +332,7 @@ public static MolarFlow FromKilomolesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerMinute"/>.
         /// </summary>
-        public static MolarFlow FromKilomolesPerMinute(double value)
+        public static MolarFlow FromKilomolesPerMinute(QuantityValue value)
         {
             return new MolarFlow(value, MolarFlowUnit.KilomolePerMinute);
         }
@@ -358,7 +340,7 @@ public static MolarFlow FromKilomolesPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerSecond"/>.
         /// </summary>
-        public static MolarFlow FromKilomolesPerSecond(double value)
+        public static MolarFlow FromKilomolesPerSecond(QuantityValue value)
         {
             return new MolarFlow(value, MolarFlowUnit.KilomolePerSecond);
         }
@@ -366,7 +348,7 @@ public static MolarFlow FromKilomolesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerHour"/>.
         /// </summary>
-        public static MolarFlow FromMolesPerHour(double value)
+        public static MolarFlow FromMolesPerHour(QuantityValue value)
         {
             return new MolarFlow(value, MolarFlowUnit.MolePerHour);
         }
@@ -374,7 +356,7 @@ public static MolarFlow FromMolesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerMinute"/>.
         /// </summary>
-        public static MolarFlow FromMolesPerMinute(double value)
+        public static MolarFlow FromMolesPerMinute(QuantityValue value)
         {
             return new MolarFlow(value, MolarFlowUnit.MolePerMinute);
         }
@@ -382,7 +364,7 @@ public static MolarFlow FromMolesPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerSecond"/>.
         /// </summary>
-        public static MolarFlow FromMolesPerSecond(double value)
+        public static MolarFlow FromMolesPerSecond(QuantityValue value)
         {
             return new MolarFlow(value, MolarFlowUnit.MolePerSecond);
         }
@@ -390,7 +372,7 @@ public static MolarFlow FromMolesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerHour"/>.
         /// </summary>
-        public static MolarFlow FromPoundMolesPerHour(double value)
+        public static MolarFlow FromPoundMolesPerHour(QuantityValue value)
         {
             return new MolarFlow(value, MolarFlowUnit.PoundMolePerHour);
         }
@@ -398,7 +380,7 @@ public static MolarFlow FromPoundMolesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerMinute"/>.
         /// </summary>
-        public static MolarFlow FromPoundMolesPerMinute(double value)
+        public static MolarFlow FromPoundMolesPerMinute(QuantityValue value)
         {
             return new MolarFlow(value, MolarFlowUnit.PoundMolePerMinute);
         }
@@ -406,7 +388,7 @@ public static MolarFlow FromPoundMolesPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerSecond"/>.
         /// </summary>
-        public static MolarFlow FromPoundMolesPerSecond(double value)
+        public static MolarFlow FromPoundMolesPerSecond(QuantityValue value)
         {
             return new MolarFlow(value, MolarFlowUnit.PoundMolePerSecond);
         }
@@ -417,7 +399,7 @@ public static MolarFlow FromPoundMolesPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MolarFlow unit value.</returns>
-        public static MolarFlow From(double value, MolarFlowUnit fromUnit)
+        public static MolarFlow From(QuantityValue value, MolarFlowUnit fromUnit)
         {
             return new MolarFlow(value, fromUnit);
         }
@@ -478,10 +460,7 @@ public static MolarFlow Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MolarFlow Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MolarFlow, MolarFlowUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MolarFlow, MolarFlowUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -509,11 +488,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MolarFlow result
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MolarFlow result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MolarFlow, MolarFlowUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MolarFlow, MolarFlowUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -534,7 +509,7 @@ public static MolarFlowUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -545,7 +520,7 @@ public static MolarFlowUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolarFlowUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MolarFlowUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarFlowUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -560,7 +535,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarFlowUni
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MolarFlowUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -579,35 +554,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MolarFlow"/> from adding two <see cref="MolarFlow"/>.</summary>
         public static MolarFlow operator +(MolarFlow left, MolarFlow right)
         {
-            return new MolarFlow(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MolarFlow(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MolarFlow"/> from subtracting two <see cref="MolarFlow"/>.</summary>
         public static MolarFlow operator -(MolarFlow left, MolarFlow right)
         {
-            return new MolarFlow(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MolarFlow(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MolarFlow"/> from multiplying value and <see cref="MolarFlow"/>.</summary>
-        public static MolarFlow operator *(double left, MolarFlow right)
+        public static MolarFlow operator *(QuantityValue left, MolarFlow right)
         {
             return new MolarFlow(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MolarFlow"/> from multiplying value and <see cref="MolarFlow"/>.</summary>
-        public static MolarFlow operator *(MolarFlow left, double right)
+        public static MolarFlow operator *(MolarFlow left, QuantityValue right)
         {
             return new MolarFlow(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MolarFlow"/> from dividing <see cref="MolarFlow"/> by value.</summary>
-        public static MolarFlow operator /(MolarFlow left, double right)
+        public static MolarFlow operator /(MolarFlow left, QuantityValue right)
         {
             return new MolarFlow(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MolarFlow"/> by <see cref="MolarFlow"/>.</summary>
-        public static double operator /(MolarFlow left, MolarFlow right)
+        public static QuantityValue operator /(MolarFlow left, MolarFlow right)
         {
             return left.MolesPerSecond / right.MolesPerSecond;
         }
@@ -647,97 +622,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MolarFlow left, MolarFlow right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MolarFlow left, MolarFlow right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MolarFlow left, MolarFlow right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MolarFlow left, MolarFlow right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MolarFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MolarFlow other, MolarFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MolarFlow"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MolarFlow)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MolarFlow left, MolarFlow right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MolarFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MolarFlow other, MolarFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MolarFlow"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MolarFlow,MolarFlow)"/>.
+        ///     See that operator (and <see cref="Equals(MolarFlow)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MolarFlow left, MolarFlow right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MolarFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MolarFlow other, MolarFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MolarFlow"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MolarFlow"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MolarFlow"/>, this method delegates to
+        ///     <see cref="Equals(MolarFlow)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MolarFlow otherQuantity))
+            if (obj is not MolarFlow otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MolarFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MolarFlow other, MolarFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MolarFlow"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MolarFlow other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MolarFlow.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MolarFlow), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MolarFlow"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MolarFlow)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MolarFlow otherQuantity)) throw new ArgumentException("Expected type MolarFlow.", nameof(obj));
+            if (obj is not MolarFlow otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MolarFlow>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MolarFlow"/> with another <see cref="MolarFlow"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MolarFlow"/> with another <see cref="MolarFlow"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -749,145 +738,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MolarFlow other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MolarFlowUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MolarFlowUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this MolarFlow to another MolarFlow with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MolarFlow with the specified unit.</returns>
-        public MolarFlow ToUnit(MolarFlowUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="MolarFlow"/> to another <see cref="MolarFlow"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MolarFlow with the specified unit.</returns>
-        public MolarFlow ToUnit(MolarFlowUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MolarFlow), Unit, typeof(MolarFlow), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MolarFlow)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="MolarFlow"/> to another <see cref="MolarFlow"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MolarFlow"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MolarFlowUnit unit, [NotNullWhen(true)] out MolarFlow? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MolarFlow? convertedOrNull = (Unit, unit) switch
-            {
-                // MolarFlowUnit -> BaseUnit
-                (MolarFlowUnit.KilomolePerHour, MolarFlowUnit.MolePerSecond) => new MolarFlow((_value / 3600) * 1e3d, MolarFlowUnit.MolePerSecond),
-                (MolarFlowUnit.KilomolePerMinute, MolarFlowUnit.MolePerSecond) => new MolarFlow((_value / 60) * 1e3d, MolarFlowUnit.MolePerSecond),
-                (MolarFlowUnit.KilomolePerSecond, MolarFlowUnit.MolePerSecond) => new MolarFlow((_value) * 1e3d, MolarFlowUnit.MolePerSecond),
-                (MolarFlowUnit.MolePerHour, MolarFlowUnit.MolePerSecond) => new MolarFlow(_value / 3600, MolarFlowUnit.MolePerSecond),
-                (MolarFlowUnit.MolePerMinute, MolarFlowUnit.MolePerSecond) => new MolarFlow(_value / 60, MolarFlowUnit.MolePerSecond),
-                (MolarFlowUnit.PoundMolePerHour, MolarFlowUnit.MolePerSecond) => new MolarFlow((_value * 453.59237) / 3600, MolarFlowUnit.MolePerSecond),
-                (MolarFlowUnit.PoundMolePerMinute, MolarFlowUnit.MolePerSecond) => new MolarFlow((_value * 453.59237) / 60, MolarFlowUnit.MolePerSecond),
-                (MolarFlowUnit.PoundMolePerSecond, MolarFlowUnit.MolePerSecond) => new MolarFlow(_value * 453.59237, MolarFlowUnit.MolePerSecond),
-
-                // BaseUnit -> MolarFlowUnit
-                (MolarFlowUnit.MolePerSecond, MolarFlowUnit.KilomolePerHour) => new MolarFlow((_value * 3600) / 1e3d, MolarFlowUnit.KilomolePerHour),
-                (MolarFlowUnit.MolePerSecond, MolarFlowUnit.KilomolePerMinute) => new MolarFlow((_value * 60) / 1e3d, MolarFlowUnit.KilomolePerMinute),
-                (MolarFlowUnit.MolePerSecond, MolarFlowUnit.KilomolePerSecond) => new MolarFlow((_value) / 1e3d, MolarFlowUnit.KilomolePerSecond),
-                (MolarFlowUnit.MolePerSecond, MolarFlowUnit.MolePerHour) => new MolarFlow(_value * 3600, MolarFlowUnit.MolePerHour),
-                (MolarFlowUnit.MolePerSecond, MolarFlowUnit.MolePerMinute) => new MolarFlow(_value * 60, MolarFlowUnit.MolePerMinute),
-                (MolarFlowUnit.MolePerSecond, MolarFlowUnit.PoundMolePerHour) => new MolarFlow((_value / 453.59237) * 3600, MolarFlowUnit.PoundMolePerHour),
-                (MolarFlowUnit.MolePerSecond, MolarFlowUnit.PoundMolePerMinute) => new MolarFlow((_value / 453.59237) * 60, MolarFlowUnit.PoundMolePerMinute),
-                (MolarFlowUnit.MolePerSecond, MolarFlowUnit.PoundMolePerSecond) => new MolarFlow(_value / 453.59237, MolarFlowUnit.PoundMolePerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MolarFlowUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarFlowUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MolarFlowUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarFlowUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MolarFlowUnit> IQuantity<MolarFlowUnit>.ToUnit(MolarFlowUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -901,11 +754,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
index d20e489b04..b7c4b16e68 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     In chemistry, the molar mass M is a physical property defined as the mass of a given substance (chemical element or chemical compound) divided by the amount of substance.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct MolarMass :
-        IArithmeticQuantity<MolarMass, MolarMassUnit>,
+        ILinearQuantity<MolarMass, MolarMassUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<MolarMass, MolarMass, double>,
+        IDivisionOperators<MolarMass, MolarMass, QuantityValue>,
         IMultiplyOperators<MolarMass, AmountOfSubstance, Mass>,
         IMultiplyOperators<MolarMass, Molarity, MassConcentration>,
         IMultiplyOperators<MolarMass, MolarFlow, MassFlow>,
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static MolarMassInfo CreateDefault(Func<IEnumerable<UnitDefinition<MolarM
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="MolarMass"/> is [M][N^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="MolarMass"/> is MN^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 1, 0, 0, 0, -1, 0);
 
@@ -120,27 +119,52 @@ public static MolarMassInfo CreateDefault(Func<IEnumerable<UnitDefinition<MolarM
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MolarMassUnit}"/> representing the default unit mappings for MolarMass.</returns>
             public static IEnumerable<UnitDefinition<MolarMassUnit>> GetDefaultMappings()
             {
-                yield return new (MolarMassUnit.CentigramPerMole, "CentigramPerMole", "CentigramsPerMole", new BaseUnits(mass: MassUnit.Centigram, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.DecagramPerMole, "DecagramPerMole", "DecagramsPerMole", new BaseUnits(mass: MassUnit.Decagram, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.DecigramPerMole, "DecigramPerMole", "DecigramsPerMole", new BaseUnits(mass: MassUnit.Decigram, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.GramPerMole, "GramPerMole", "GramsPerMole", new BaseUnits(mass: MassUnit.Gram, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.HectogramPerMole, "HectogramPerMole", "HectogramsPerMole", new BaseUnits(mass: MassUnit.Hectogram, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.KilogramPerKilomole, "KilogramPerKilomole", "KilogramsPerKilomole", new BaseUnits(mass: MassUnit.Kilogram, amount: AmountOfSubstanceUnit.Kilomole));
+                yield return new (MolarMassUnit.CentigramPerMole, "CentigramPerMole", "CentigramsPerMole", new BaseUnits(mass: MassUnit.Centigram, amount: AmountOfSubstanceUnit.Mole),
+                     100000
+                );
+                yield return new (MolarMassUnit.DecagramPerMole, "DecagramPerMole", "DecagramsPerMole", new BaseUnits(mass: MassUnit.Decagram, amount: AmountOfSubstanceUnit.Mole),
+                     100
+                );
+                yield return new (MolarMassUnit.DecigramPerMole, "DecigramPerMole", "DecigramsPerMole", new BaseUnits(mass: MassUnit.Decigram, amount: AmountOfSubstanceUnit.Mole),
+                     10000
+                );
+                yield return new (MolarMassUnit.GramPerMole, "GramPerMole", "GramsPerMole", new BaseUnits(mass: MassUnit.Gram, amount: AmountOfSubstanceUnit.Mole),
+                     1000
+                );
+                yield return new (MolarMassUnit.HectogramPerMole, "HectogramPerMole", "HectogramsPerMole", new BaseUnits(mass: MassUnit.Hectogram, amount: AmountOfSubstanceUnit.Mole),
+                     10
+                );
+                yield return new (MolarMassUnit.KilogramPerKilomole, "KilogramPerKilomole", "KilogramsPerKilomole", new BaseUnits(mass: MassUnit.Kilogram, amount: AmountOfSubstanceUnit.Kilomole),
+                     1000
+                );
                 yield return new (MolarMassUnit.KilogramPerMole, "KilogramPerMole", "KilogramsPerMole", new BaseUnits(mass: MassUnit.Kilogram, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.KilopoundPerMole, "KilopoundPerMole", "KilopoundsPerMole", new BaseUnits(mass: MassUnit.Kilopound, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.MegapoundPerMole, "MegapoundPerMole", "MegapoundsPerMole", new BaseUnits(mass: MassUnit.Megapound, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.MicrogramPerMole, "MicrogramPerMole", "MicrogramsPerMole", new BaseUnits(mass: MassUnit.Microgram, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.MilligramPerMole, "MilligramPerMole", "MilligramsPerMole", new BaseUnits(mass: MassUnit.Milligram, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.NanogramPerMole, "NanogramPerMole", "NanogramsPerMole", new BaseUnits(mass: MassUnit.Nanogram, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarMassUnit.PoundPerMole, "PoundPerMole", "PoundsPerMole", new BaseUnits(mass: MassUnit.Pound, amount: AmountOfSubstanceUnit.Mole));
+                yield return new (MolarMassUnit.KilopoundPerMole, "KilopoundPerMole", "KilopoundsPerMole", new BaseUnits(mass: MassUnit.Kilopound, amount: AmountOfSubstanceUnit.Mole),
+                     new QuantityValue(100000, 45359237)
+                );
+                yield return new (MolarMassUnit.MegapoundPerMole, "MegapoundPerMole", "MegapoundsPerMole", new BaseUnits(mass: MassUnit.Megapound, amount: AmountOfSubstanceUnit.Mole),
+                     new QuantityValue(100, 45359237)
+                );
+                yield return new (MolarMassUnit.MicrogramPerMole, "MicrogramPerMole", "MicrogramsPerMole", new BaseUnits(mass: MassUnit.Microgram, amount: AmountOfSubstanceUnit.Mole),
+                     1000000000
+                );
+                yield return new (MolarMassUnit.MilligramPerMole, "MilligramPerMole", "MilligramsPerMole", new BaseUnits(mass: MassUnit.Milligram, amount: AmountOfSubstanceUnit.Mole),
+                     1000000
+                );
+                yield return new (MolarMassUnit.NanogramPerMole, "NanogramPerMole", "NanogramsPerMole", new BaseUnits(mass: MassUnit.Nanogram, amount: AmountOfSubstanceUnit.Mole),
+                     1000000000000
+                );
+                yield return new (MolarMassUnit.PoundPerMole, "PoundPerMole", "PoundsPerMole", new BaseUnits(mass: MassUnit.Pound, amount: AmountOfSubstanceUnit.Mole),
+                     new QuantityValue(100000000, 45359237)
+                );
+                yield return new (MolarMassUnit.PoundPerPoundMole, "PoundPerPoundMole", "PoundsPerPoundMole", new BaseUnits(mass: MassUnit.Pound, amount: AmountOfSubstanceUnit.PoundMole),
+                     1000
+                );
             }
         }
 
         static MolarMass()
         {
-            Info = MolarMassInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MolarMassInfo.CreateDefault);
         }
 
         /// <summary>
@@ -148,7 +172,7 @@ static MolarMass()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public MolarMass(double value, MolarMassUnit unit)
+        public MolarMass(QuantityValue value, MolarMassUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -162,7 +186,7 @@ public MolarMass(double value, MolarMassUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public MolarMass(double value, UnitSystem unitSystem)
+        public MolarMass(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -173,7 +197,8 @@ public MolarMass(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="MolarMass" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<MolarMass, MolarMassUnit> Info { get; }
@@ -202,10 +227,8 @@ public MolarMass(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MolarMassUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -239,112 +262,79 @@ public MolarMass(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.CentigramPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.CentigramPerMole"/>
+        /// </summary>
+        public QuantityValue CentigramsPerMole => this.As(MolarMassUnit.CentigramPerMole);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.DecagramPerMole"/>
         /// </summary>
-        public double CentigramsPerMole => As(MolarMassUnit.CentigramPerMole);
+        public QuantityValue DecagramsPerMole => this.As(MolarMassUnit.DecagramPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.DecagramPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.DecigramPerMole"/>
         /// </summary>
-        public double DecagramsPerMole => As(MolarMassUnit.DecagramPerMole);
+        public QuantityValue DecigramsPerMole => this.As(MolarMassUnit.DecigramPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.DecigramPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.GramPerMole"/>
         /// </summary>
-        public double DecigramsPerMole => As(MolarMassUnit.DecigramPerMole);
+        public QuantityValue GramsPerMole => this.As(MolarMassUnit.GramPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.GramPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.HectogramPerMole"/>
         /// </summary>
-        public double GramsPerMole => As(MolarMassUnit.GramPerMole);
+        public QuantityValue HectogramsPerMole => this.As(MolarMassUnit.HectogramPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.HectogramPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.KilogramPerKilomole"/>
         /// </summary>
-        public double HectogramsPerMole => As(MolarMassUnit.HectogramPerMole);
+        public QuantityValue KilogramsPerKilomole => this.As(MolarMassUnit.KilogramPerKilomole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.KilogramPerKilomole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.KilogramPerMole"/>
         /// </summary>
-        public double KilogramsPerKilomole => As(MolarMassUnit.KilogramPerKilomole);
+        public QuantityValue KilogramsPerMole => this.As(MolarMassUnit.KilogramPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.KilogramPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.KilopoundPerMole"/>
         /// </summary>
-        public double KilogramsPerMole => As(MolarMassUnit.KilogramPerMole);
+        public QuantityValue KilopoundsPerMole => this.As(MolarMassUnit.KilopoundPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.KilopoundPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.MegapoundPerMole"/>
         /// </summary>
-        public double KilopoundsPerMole => As(MolarMassUnit.KilopoundPerMole);
+        public QuantityValue MegapoundsPerMole => this.As(MolarMassUnit.MegapoundPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.MegapoundPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.MicrogramPerMole"/>
         /// </summary>
-        public double MegapoundsPerMole => As(MolarMassUnit.MegapoundPerMole);
+        public QuantityValue MicrogramsPerMole => this.As(MolarMassUnit.MicrogramPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.MicrogramPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.MilligramPerMole"/>
         /// </summary>
-        public double MicrogramsPerMole => As(MolarMassUnit.MicrogramPerMole);
+        public QuantityValue MilligramsPerMole => this.As(MolarMassUnit.MilligramPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.MilligramPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.NanogramPerMole"/>
         /// </summary>
-        public double MilligramsPerMole => As(MolarMassUnit.MilligramPerMole);
+        public QuantityValue NanogramsPerMole => this.As(MolarMassUnit.NanogramPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.NanogramPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.PoundPerMole"/>
         /// </summary>
-        public double NanogramsPerMole => As(MolarMassUnit.NanogramPerMole);
+        public QuantityValue PoundsPerMole => this.As(MolarMassUnit.PoundPerMole);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarMassUnit.PoundPerMole"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarMassUnit.PoundPerPoundMole"/>
         /// </summary>
-        public double PoundsPerMole => As(MolarMassUnit.PoundPerMole);
+        public QuantityValue PoundsPerPoundMole => this.As(MolarMassUnit.PoundPerPoundMole);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MolarMassUnit -> BaseUnit
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.CentigramPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.DecagramPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.DecigramPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.GramPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.HectogramPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerKilomole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilopoundPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.MegapoundPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.MicrogramPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.MilligramPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.NanogramPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.PoundPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerMole));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.KilogramPerMole, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MolarMassUnit
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.CentigramPerMole, quantity => quantity.ToUnit(MolarMassUnit.CentigramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.DecagramPerMole, quantity => quantity.ToUnit(MolarMassUnit.DecagramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.DecigramPerMole, quantity => quantity.ToUnit(MolarMassUnit.DecigramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.GramPerMole, quantity => quantity.ToUnit(MolarMassUnit.GramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.HectogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.HectogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.KilogramPerKilomole, quantity => quantity.ToUnit(MolarMassUnit.KilogramPerKilomole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.KilopoundPerMole, quantity => quantity.ToUnit(MolarMassUnit.KilopoundPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.MegapoundPerMole, quantity => quantity.ToUnit(MolarMassUnit.MegapoundPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.MicrogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.MicrogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.MilligramPerMole, quantity => quantity.ToUnit(MolarMassUnit.MilligramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.NanogramPerMole, quantity => quantity.ToUnit(MolarMassUnit.NanogramPerMole));
-            unitConverter.SetConversionFunction<MolarMass>(MolarMassUnit.KilogramPerMole, MolarMassUnit.PoundPerMole, quantity => quantity.ToUnit(MolarMassUnit.PoundPerMole));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -373,7 +363,7 @@ public static string GetAbbreviation(MolarMassUnit unit, IFormatProvider? provid
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.CentigramPerMole"/>.
         /// </summary>
-        public static MolarMass FromCentigramsPerMole(double value)
+        public static MolarMass FromCentigramsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.CentigramPerMole);
         }
@@ -381,7 +371,7 @@ public static MolarMass FromCentigramsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.DecagramPerMole"/>.
         /// </summary>
-        public static MolarMass FromDecagramsPerMole(double value)
+        public static MolarMass FromDecagramsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.DecagramPerMole);
         }
@@ -389,7 +379,7 @@ public static MolarMass FromDecagramsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.DecigramPerMole"/>.
         /// </summary>
-        public static MolarMass FromDecigramsPerMole(double value)
+        public static MolarMass FromDecigramsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.DecigramPerMole);
         }
@@ -397,7 +387,7 @@ public static MolarMass FromDecigramsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.GramPerMole"/>.
         /// </summary>
-        public static MolarMass FromGramsPerMole(double value)
+        public static MolarMass FromGramsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.GramPerMole);
         }
@@ -405,7 +395,7 @@ public static MolarMass FromGramsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.HectogramPerMole"/>.
         /// </summary>
-        public static MolarMass FromHectogramsPerMole(double value)
+        public static MolarMass FromHectogramsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.HectogramPerMole);
         }
@@ -413,7 +403,7 @@ public static MolarMass FromHectogramsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilogramPerKilomole"/>.
         /// </summary>
-        public static MolarMass FromKilogramsPerKilomole(double value)
+        public static MolarMass FromKilogramsPerKilomole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.KilogramPerKilomole);
         }
@@ -421,7 +411,7 @@ public static MolarMass FromKilogramsPerKilomole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilogramPerMole"/>.
         /// </summary>
-        public static MolarMass FromKilogramsPerMole(double value)
+        public static MolarMass FromKilogramsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.KilogramPerMole);
         }
@@ -429,7 +419,7 @@ public static MolarMass FromKilogramsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilopoundPerMole"/>.
         /// </summary>
-        public static MolarMass FromKilopoundsPerMole(double value)
+        public static MolarMass FromKilopoundsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.KilopoundPerMole);
         }
@@ -437,7 +427,7 @@ public static MolarMass FromKilopoundsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MegapoundPerMole"/>.
         /// </summary>
-        public static MolarMass FromMegapoundsPerMole(double value)
+        public static MolarMass FromMegapoundsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.MegapoundPerMole);
         }
@@ -445,7 +435,7 @@ public static MolarMass FromMegapoundsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MicrogramPerMole"/>.
         /// </summary>
-        public static MolarMass FromMicrogramsPerMole(double value)
+        public static MolarMass FromMicrogramsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.MicrogramPerMole);
         }
@@ -453,7 +443,7 @@ public static MolarMass FromMicrogramsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MilligramPerMole"/>.
         /// </summary>
-        public static MolarMass FromMilligramsPerMole(double value)
+        public static MolarMass FromMilligramsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.MilligramPerMole);
         }
@@ -461,7 +451,7 @@ public static MolarMass FromMilligramsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.NanogramPerMole"/>.
         /// </summary>
-        public static MolarMass FromNanogramsPerMole(double value)
+        public static MolarMass FromNanogramsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.NanogramPerMole);
         }
@@ -469,18 +459,26 @@ public static MolarMass FromNanogramsPerMole(double value)
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.PoundPerMole"/>.
         /// </summary>
-        public static MolarMass FromPoundsPerMole(double value)
+        public static MolarMass FromPoundsPerMole(QuantityValue value)
         {
             return new MolarMass(value, MolarMassUnit.PoundPerMole);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.PoundPerPoundMole"/>.
+        /// </summary>
+        public static MolarMass FromPoundsPerPoundMole(QuantityValue value)
+        {
+            return new MolarMass(value, MolarMassUnit.PoundPerPoundMole);
+        }
+
         /// <summary>
         ///     Dynamically convert from value and unit enum <see cref="MolarMassUnit" /> to <see cref="MolarMass" />.
         /// </summary>
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MolarMass unit value.</returns>
-        public static MolarMass From(double value, MolarMassUnit fromUnit)
+        public static MolarMass From(QuantityValue value, MolarMassUnit fromUnit)
         {
             return new MolarMass(value, fromUnit);
         }
@@ -541,10 +539,7 @@ public static MolarMass Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static MolarMass Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<MolarMass, MolarMassUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<MolarMass, MolarMassUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -572,11 +567,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out MolarMass result
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out MolarMass result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<MolarMass, MolarMassUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<MolarMass, MolarMassUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -597,7 +588,7 @@ public static MolarMassUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -608,7 +599,7 @@ public static MolarMassUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolarMassUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MolarMassUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarMassUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -623,7 +614,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarMassUni
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MolarMassUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -642,35 +633,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="MolarMass"/> from adding two <see cref="MolarMass"/>.</summary>
         public static MolarMass operator +(MolarMass left, MolarMass right)
         {
-            return new MolarMass(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new MolarMass(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MolarMass"/> from subtracting two <see cref="MolarMass"/>.</summary>
         public static MolarMass operator -(MolarMass left, MolarMass right)
         {
-            return new MolarMass(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new MolarMass(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="MolarMass"/> from multiplying value and <see cref="MolarMass"/>.</summary>
-        public static MolarMass operator *(double left, MolarMass right)
+        public static MolarMass operator *(QuantityValue left, MolarMass right)
         {
             return new MolarMass(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="MolarMass"/> from multiplying value and <see cref="MolarMass"/>.</summary>
-        public static MolarMass operator *(MolarMass left, double right)
+        public static MolarMass operator *(MolarMass left, QuantityValue right)
         {
             return new MolarMass(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="MolarMass"/> from dividing <see cref="MolarMass"/> by value.</summary>
-        public static MolarMass operator /(MolarMass left, double right)
+        public static MolarMass operator /(MolarMass left, QuantityValue right)
         {
             return new MolarMass(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="MolarMass"/> by <see cref="MolarMass"/>.</summary>
-        public static double operator /(MolarMass left, MolarMass right)
+        public static QuantityValue operator /(MolarMass left, MolarMass right)
         {
             return left.KilogramsPerMole / right.KilogramsPerMole;
         }
@@ -704,97 +695,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(MolarMass left, MolarMass right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(MolarMass left, MolarMass right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(MolarMass left, MolarMass right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(MolarMass left, MolarMass right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="MolarMass"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MolarMass other, MolarMass tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MolarMass"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(MolarMass)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(MolarMass left, MolarMass right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="MolarMass"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(MolarMass other, MolarMass tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="MolarMass"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(MolarMass,MolarMass)"/>.
+        ///     See that operator (and <see cref="Equals(MolarMass)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(MolarMass left, MolarMass right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MolarMass"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MolarMass other, MolarMass tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="MolarMass"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="MolarMass"/>.
+        ///     When <paramref name="obj"/> is a <see cref="MolarMass"/>, this method delegates to
+        ///     <see cref="Equals(MolarMass)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is MolarMass otherQuantity))
+            if (obj is not MolarMass otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="MolarMass"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(MolarMass other, MolarMass tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="MolarMass"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(MolarMass other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current MolarMass.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(MolarMass), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="MolarMass"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(MolarMass)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is MolarMass otherQuantity)) throw new ArgumentException("Expected type MolarMass.", nameof(obj));
+            if (obj is not MolarMass otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<MolarMass>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="MolarMass"/> with another <see cref="MolarMass"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="MolarMass"/> with another <see cref="MolarMass"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -806,153 +811,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(MolarMass other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MolarMassUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MolarMassUnit>());
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this MolarMass to another MolarMass with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A MolarMass with the specified unit.</returns>
-        public MolarMass ToUnit(MolarMassUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="MolarMass"/> to another <see cref="MolarMass"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A MolarMass with the specified unit.</returns>
-        public MolarMass ToUnit(MolarMassUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(MolarMass), Unit, typeof(MolarMass), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (MolarMass)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="MolarMass"/> to another <see cref="MolarMass"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="MolarMass"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MolarMassUnit unit, [NotNullWhen(true)] out MolarMass? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            MolarMass? convertedOrNull = (Unit, unit) switch
-            {
-                // MolarMassUnit -> BaseUnit
-                (MolarMassUnit.CentigramPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass((_value / 1e3) * 1e-2d, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.DecagramPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass((_value / 1e3) * 1e1d, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.DecigramPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass((_value / 1e3) * 1e-1d, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.GramPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass(_value / 1e3, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.HectogramPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass((_value / 1e3) * 1e2d, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.KilogramPerKilomole, MolarMassUnit.KilogramPerMole) => new MolarMass(_value / 1e3, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.KilopoundPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass((_value * 0.45359237) * 1e3d, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.MegapoundPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass((_value * 0.45359237) * 1e6d, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.MicrogramPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass((_value / 1e3) * 1e-6d, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.MilligramPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass((_value / 1e3) * 1e-3d, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.NanogramPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass((_value / 1e3) * 1e-9d, MolarMassUnit.KilogramPerMole),
-                (MolarMassUnit.PoundPerMole, MolarMassUnit.KilogramPerMole) => new MolarMass(_value * 0.45359237, MolarMassUnit.KilogramPerMole),
-
-                // BaseUnit -> MolarMassUnit
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.CentigramPerMole) => new MolarMass((_value * 1e3) / 1e-2d, MolarMassUnit.CentigramPerMole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.DecagramPerMole) => new MolarMass((_value * 1e3) / 1e1d, MolarMassUnit.DecagramPerMole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.DecigramPerMole) => new MolarMass((_value * 1e3) / 1e-1d, MolarMassUnit.DecigramPerMole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.GramPerMole) => new MolarMass(_value * 1e3, MolarMassUnit.GramPerMole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.HectogramPerMole) => new MolarMass((_value * 1e3) / 1e2d, MolarMassUnit.HectogramPerMole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.KilogramPerKilomole) => new MolarMass(_value * 1e3, MolarMassUnit.KilogramPerKilomole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.KilopoundPerMole) => new MolarMass((_value / 0.45359237) / 1e3d, MolarMassUnit.KilopoundPerMole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.MegapoundPerMole) => new MolarMass((_value / 0.45359237) / 1e6d, MolarMassUnit.MegapoundPerMole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.MicrogramPerMole) => new MolarMass((_value * 1e3) / 1e-6d, MolarMassUnit.MicrogramPerMole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.MilligramPerMole) => new MolarMass((_value * 1e3) / 1e-3d, MolarMassUnit.MilligramPerMole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.NanogramPerMole) => new MolarMass((_value * 1e3) / 1e-9d, MolarMassUnit.NanogramPerMole),
-                (MolarMassUnit.KilogramPerMole, MolarMassUnit.PoundPerMole) => new MolarMass(_value / 0.45359237, MolarMassUnit.PoundPerMole),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MolarMassUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarMassUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MolarMassUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarMassUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MolarMassUnit> IQuantity<MolarMassUnit>.ToUnit(MolarMassUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -966,11 +827,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
index 83c4ff33fb..e9edd15565 100644
--- a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Molar_concentration
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Molarity :
-        IArithmeticQuantity<Molarity, MolarityUnit>,
+        ILinearQuantity<Molarity, MolarityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Molarity, Molarity, double>,
+        IDivisionOperators<Molarity, Molarity, QuantityValue>,
         IMultiplyOperators<Molarity, Volume, AmountOfSubstance>,
         IMultiplyOperators<Molarity, MolarMass, MassConcentration>,
         IMultiplyOperators<Molarity, VolumeFlow, MolarFlow>,
@@ -60,7 +59,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -110,7 +109,7 @@ public static MolarityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Molarit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Molarity"/> is [L^-3][N].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Molarity"/> is L^-3N.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-3, 0, 0, 0, 0, 1, 0);
 
@@ -125,25 +124,43 @@ public static MolarityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Molarit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{MolarityUnit}"/> representing the default unit mappings for Molarity.</returns>
             public static IEnumerable<UnitDefinition<MolarityUnit>> GetDefaultMappings()
             {
-                yield return new (MolarityUnit.CentimolePerLiter, "CentimolePerLiter", "CentimolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Centimole));
-                yield return new (MolarityUnit.DecimolePerLiter, "DecimolePerLiter", "DecimolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Decimole));
-                yield return new (MolarityUnit.FemtomolePerLiter, "FemtomolePerLiter", "FemtomolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Femtomole));
-                yield return new (MolarityUnit.KilomolePerCubicMeter, "KilomolePerCubicMeter", "KilomolesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, amount: AmountOfSubstanceUnit.Kilomole));
-                yield return new (MolarityUnit.MicromolePerLiter, "MicromolePerLiter", "MicromolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Micromole));
-                yield return new (MolarityUnit.MillimolePerLiter, "MillimolePerLiter", "MillimolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Millimole));
+                yield return new (MolarityUnit.CentimolePerLiter, "CentimolePerLiter", "CentimolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Centimole),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (MolarityUnit.DecimolePerLiter, "DecimolePerLiter", "DecimolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Decimole),
+                     new QuantityValue(1, 100)
+                );
+                yield return new (MolarityUnit.FemtomolePerLiter, "FemtomolePerLiter", "FemtomolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Femtomole),
+                     1000000000000
+                );
+                yield return new (MolarityUnit.KilomolePerCubicMeter, "KilomolePerCubicMeter", "KilomolesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, amount: AmountOfSubstanceUnit.Kilomole),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MolarityUnit.MicromolePerLiter, "MicromolePerLiter", "MicromolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Micromole),
+                     1000
+                );
+                yield return new (MolarityUnit.MillimolePerLiter, "MillimolePerLiter", "MillimolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Millimole),
+                     1
+                );
                 yield return new (MolarityUnit.MolePerCubicMeter, "MolePerCubicMeter", "MolesPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarityUnit.MolePerLiter, "MolePerLiter", "MolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Mole));
-                yield return new (MolarityUnit.NanomolePerLiter, "NanomolePerLiter", "NanomolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Nanomole));
-                yield return new (MolarityUnit.PicomolePerLiter, "PicomolePerLiter", "PicomolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Picomole));
-                yield return new (MolarityUnit.PoundMolePerCubicFoot, "PoundMolePerCubicFoot", "PoundMolesPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, amount: AmountOfSubstanceUnit.PoundMole));
+                yield return new (MolarityUnit.MolePerLiter, "MolePerLiter", "MolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Mole),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (MolarityUnit.NanomolePerLiter, "NanomolePerLiter", "NanomolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Nanomole),
+                     1000000
+                );
+                yield return new (MolarityUnit.PicomolePerLiter, "PicomolePerLiter", "PicomolesPerLiter", new BaseUnits(length: LengthUnit.Decimeter, amount: AmountOfSubstanceUnit.Picomole),
+                     1000000000
+                );
+                yield return new (MolarityUnit.PoundMolePerCubicFoot, "PoundMolePerCubicFoot", "PoundMolesPerCubicFoot", new BaseUnits(length: LengthUnit.Foot, amount: AmountOfSubstanceUnit.PoundMole),
+                     new QuantityValue(221225364, 3543690390625)
+                );
             }
         }
 
         static Molarity()
         {
-            Info = MolarityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(MolarityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -151,7 +168,7 @@ static Molarity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Molarity(double value, MolarityUnit unit)
+        public Molarity(QuantityValue value, MolarityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -165,7 +182,7 @@ public Molarity(double value, MolarityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Molarity(double value, UnitSystem unitSystem)
+        public Molarity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -176,7 +193,8 @@ public Molarity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Molarity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Molarity, MolarityUnit> Info { get; }
@@ -205,10 +223,8 @@ public Molarity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public MolarityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -242,98 +258,64 @@ public Molarity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.CentimolePerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.CentimolePerLiter"/>
         /// </summary>
-        public double CentimolesPerLiter => As(MolarityUnit.CentimolePerLiter);
+        public QuantityValue CentimolesPerLiter => this.As(MolarityUnit.CentimolePerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.DecimolePerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.DecimolePerLiter"/>
         /// </summary>
-        public double DecimolesPerLiter => As(MolarityUnit.DecimolePerLiter);
+        public QuantityValue DecimolesPerLiter => this.As(MolarityUnit.DecimolePerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.FemtomolePerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.FemtomolePerLiter"/>
         /// </summary>
-        public double FemtomolesPerLiter => As(MolarityUnit.FemtomolePerLiter);
+        public QuantityValue FemtomolesPerLiter => this.As(MolarityUnit.FemtomolePerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.KilomolePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.KilomolePerCubicMeter"/>
         /// </summary>
-        public double KilomolesPerCubicMeter => As(MolarityUnit.KilomolePerCubicMeter);
+        public QuantityValue KilomolesPerCubicMeter => this.As(MolarityUnit.KilomolePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.MicromolePerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.MicromolePerLiter"/>
         /// </summary>
-        public double MicromolesPerLiter => As(MolarityUnit.MicromolePerLiter);
+        public QuantityValue MicromolesPerLiter => this.As(MolarityUnit.MicromolePerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.MillimolePerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.MillimolePerLiter"/>
         /// </summary>
-        public double MillimolesPerLiter => As(MolarityUnit.MillimolePerLiter);
+        public QuantityValue MillimolesPerLiter => this.As(MolarityUnit.MillimolePerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.MolePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.MolePerCubicMeter"/>
         /// </summary>
-        public double MolesPerCubicMeter => As(MolarityUnit.MolePerCubicMeter);
+        public QuantityValue MolesPerCubicMeter => this.As(MolarityUnit.MolePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.MolePerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.MolePerLiter"/>
         /// </summary>
-        public double MolesPerLiter => As(MolarityUnit.MolePerLiter);
+        public QuantityValue MolesPerLiter => this.As(MolarityUnit.MolePerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.NanomolePerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.NanomolePerLiter"/>
         /// </summary>
-        public double NanomolesPerLiter => As(MolarityUnit.NanomolePerLiter);
+        public QuantityValue NanomolesPerLiter => this.As(MolarityUnit.NanomolePerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.PicomolePerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.PicomolePerLiter"/>
         /// </summary>
-        public double PicomolesPerLiter => As(MolarityUnit.PicomolePerLiter);
+        public QuantityValue PicomolesPerLiter => this.As(MolarityUnit.PicomolePerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="MolarityUnit.PoundMolePerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="MolarityUnit.PoundMolePerCubicFoot"/>
         /// </summary>
-        public double PoundMolesPerCubicFoot => As(MolarityUnit.PoundMolePerCubicFoot);
+        public QuantityValue PoundMolesPerCubicFoot => this.As(MolarityUnit.PoundMolePerCubicFoot);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: MolarityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.CentimolePerLiter, MolarityUnit.MolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.MolePerCubicMeter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.DecimolePerLiter, MolarityUnit.MolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.MolePerCubicMeter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.FemtomolePerLiter, MolarityUnit.MolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.MolePerCubicMeter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.KilomolePerCubicMeter, MolarityUnit.MolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.MolePerCubicMeter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MicromolePerLiter, MolarityUnit.MolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.MolePerCubicMeter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MillimolePerLiter, MolarityUnit.MolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.MolePerCubicMeter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerLiter, MolarityUnit.MolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.MolePerCubicMeter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.NanomolePerLiter, MolarityUnit.MolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.MolePerCubicMeter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.PicomolePerLiter, MolarityUnit.MolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.MolePerCubicMeter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.PoundMolePerCubicFoot, MolarityUnit.MolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.MolePerCubicMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.MolePerCubicMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> MolarityUnit
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.CentimolePerLiter, quantity => quantity.ToUnit(MolarityUnit.CentimolePerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.DecimolePerLiter, quantity => quantity.ToUnit(MolarityUnit.DecimolePerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.FemtomolePerLiter, quantity => quantity.ToUnit(MolarityUnit.FemtomolePerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.KilomolePerCubicMeter, quantity => quantity.ToUnit(MolarityUnit.KilomolePerCubicMeter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.MicromolePerLiter, quantity => quantity.ToUnit(MolarityUnit.MicromolePerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.MillimolePerLiter, quantity => quantity.ToUnit(MolarityUnit.MillimolePerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.MolePerLiter, quantity => quantity.ToUnit(MolarityUnit.MolePerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.NanomolePerLiter, quantity => quantity.ToUnit(MolarityUnit.NanomolePerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.PicomolePerLiter, quantity => quantity.ToUnit(MolarityUnit.PicomolePerLiter));
-            unitConverter.SetConversionFunction<Molarity>(MolarityUnit.MolePerCubicMeter, MolarityUnit.PoundMolePerCubicFoot, quantity => quantity.ToUnit(MolarityUnit.PoundMolePerCubicFoot));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -362,7 +344,7 @@ public static string GetAbbreviation(MolarityUnit unit, IFormatProvider? provide
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.CentimolePerLiter"/>.
         /// </summary>
-        public static Molarity FromCentimolesPerLiter(double value)
+        public static Molarity FromCentimolesPerLiter(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.CentimolePerLiter);
         }
@@ -370,7 +352,7 @@ public static Molarity FromCentimolesPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.DecimolePerLiter"/>.
         /// </summary>
-        public static Molarity FromDecimolesPerLiter(double value)
+        public static Molarity FromDecimolesPerLiter(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.DecimolePerLiter);
         }
@@ -378,7 +360,7 @@ public static Molarity FromDecimolesPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.FemtomolePerLiter"/>.
         /// </summary>
-        public static Molarity FromFemtomolesPerLiter(double value)
+        public static Molarity FromFemtomolesPerLiter(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.FemtomolePerLiter);
         }
@@ -386,7 +368,7 @@ public static Molarity FromFemtomolesPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.KilomolePerCubicMeter"/>.
         /// </summary>
-        public static Molarity FromKilomolesPerCubicMeter(double value)
+        public static Molarity FromKilomolesPerCubicMeter(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.KilomolePerCubicMeter);
         }
@@ -394,7 +376,7 @@ public static Molarity FromKilomolesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MicromolePerLiter"/>.
         /// </summary>
-        public static Molarity FromMicromolesPerLiter(double value)
+        public static Molarity FromMicromolesPerLiter(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.MicromolePerLiter);
         }
@@ -402,7 +384,7 @@ public static Molarity FromMicromolesPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MillimolePerLiter"/>.
         /// </summary>
-        public static Molarity FromMillimolesPerLiter(double value)
+        public static Molarity FromMillimolesPerLiter(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.MillimolePerLiter);
         }
@@ -410,7 +392,7 @@ public static Molarity FromMillimolesPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MolePerCubicMeter"/>.
         /// </summary>
-        public static Molarity FromMolesPerCubicMeter(double value)
+        public static Molarity FromMolesPerCubicMeter(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.MolePerCubicMeter);
         }
@@ -418,7 +400,7 @@ public static Molarity FromMolesPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MolePerLiter"/>.
         /// </summary>
-        public static Molarity FromMolesPerLiter(double value)
+        public static Molarity FromMolesPerLiter(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.MolePerLiter);
         }
@@ -426,7 +408,7 @@ public static Molarity FromMolesPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.NanomolePerLiter"/>.
         /// </summary>
-        public static Molarity FromNanomolesPerLiter(double value)
+        public static Molarity FromNanomolesPerLiter(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.NanomolePerLiter);
         }
@@ -434,7 +416,7 @@ public static Molarity FromNanomolesPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.PicomolePerLiter"/>.
         /// </summary>
-        public static Molarity FromPicomolesPerLiter(double value)
+        public static Molarity FromPicomolesPerLiter(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.PicomolePerLiter);
         }
@@ -442,7 +424,7 @@ public static Molarity FromPicomolesPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.PoundMolePerCubicFoot"/>.
         /// </summary>
-        public static Molarity FromPoundMolesPerCubicFoot(double value)
+        public static Molarity FromPoundMolesPerCubicFoot(QuantityValue value)
         {
             return new Molarity(value, MolarityUnit.PoundMolePerCubicFoot);
         }
@@ -453,7 +435,7 @@ public static Molarity FromPoundMolesPerCubicFoot(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Molarity unit value.</returns>
-        public static Molarity From(double value, MolarityUnit fromUnit)
+        public static Molarity From(QuantityValue value, MolarityUnit fromUnit)
         {
             return new Molarity(value, fromUnit);
         }
@@ -514,10 +496,7 @@ public static Molarity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Molarity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Molarity, MolarityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Molarity, MolarityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -545,11 +524,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Molarity result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Molarity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Molarity, MolarityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Molarity, MolarityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -570,7 +545,7 @@ public static MolarityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -581,7 +556,7 @@ public static MolarityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.MolarityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.MolarityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -596,7 +571,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out MolarityUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out MolarityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -615,35 +590,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Molarity"/> from adding two <see cref="Molarity"/>.</summary>
         public static Molarity operator +(Molarity left, Molarity right)
         {
-            return new Molarity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Molarity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Molarity"/> from subtracting two <see cref="Molarity"/>.</summary>
         public static Molarity operator -(Molarity left, Molarity right)
         {
-            return new Molarity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Molarity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Molarity"/> from multiplying value and <see cref="Molarity"/>.</summary>
-        public static Molarity operator *(double left, Molarity right)
+        public static Molarity operator *(QuantityValue left, Molarity right)
         {
             return new Molarity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Molarity"/> from multiplying value and <see cref="Molarity"/>.</summary>
-        public static Molarity operator *(Molarity left, double right)
+        public static Molarity operator *(Molarity left, QuantityValue right)
         {
             return new Molarity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Molarity"/> from dividing <see cref="Molarity"/> by value.</summary>
-        public static Molarity operator /(Molarity left, double right)
+        public static Molarity operator /(Molarity left, QuantityValue right)
         {
             return new Molarity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Molarity"/> by <see cref="Molarity"/>.</summary>
-        public static double operator /(Molarity left, Molarity right)
+        public static QuantityValue operator /(Molarity left, Molarity right)
         {
             return left.MolesPerCubicMeter / right.MolesPerCubicMeter;
         }
@@ -689,97 +664,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Molarity left, Molarity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Molarity left, Molarity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Molarity left, Molarity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Molarity left, Molarity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Molarity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Molarity other, Molarity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Molarity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Molarity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Molarity left, Molarity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Molarity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Molarity other, Molarity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Molarity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Molarity,Molarity)"/>.
+        ///     See that operator (and <see cref="Equals(Molarity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Molarity left, Molarity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Molarity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Molarity other, Molarity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Molarity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Molarity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Molarity"/>, this method delegates to
+        ///     <see cref="Equals(Molarity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Molarity otherQuantity))
+            if (obj is not Molarity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Molarity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Molarity other, Molarity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Molarity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Molarity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Molarity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Molarity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Molarity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Molarity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Molarity otherQuantity)) throw new ArgumentException("Expected type Molarity.", nameof(obj));
+            if (obj is not Molarity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Molarity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Molarity"/> with another <see cref="Molarity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Molarity"/> with another <see cref="Molarity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -791,149 +780,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Molarity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(MolarityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<MolarityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Molarity to another Molarity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Molarity with the specified unit.</returns>
-        public Molarity ToUnit(MolarityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="Molarity"/> to another <see cref="Molarity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Molarity with the specified unit.</returns>
-        public Molarity ToUnit(MolarityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Molarity), Unit, typeof(Molarity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Molarity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Molarity"/> to another <see cref="Molarity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Molarity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(MolarityUnit unit, [NotNullWhen(true)] out Molarity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Molarity? convertedOrNull = (Unit, unit) switch
-            {
-                // MolarityUnit -> BaseUnit
-                (MolarityUnit.CentimolePerLiter, MolarityUnit.MolePerCubicMeter) => new Molarity((_value / 1e-3) * 1e-2d, MolarityUnit.MolePerCubicMeter),
-                (MolarityUnit.DecimolePerLiter, MolarityUnit.MolePerCubicMeter) => new Molarity((_value / 1e-3) * 1e-1d, MolarityUnit.MolePerCubicMeter),
-                (MolarityUnit.FemtomolePerLiter, MolarityUnit.MolePerCubicMeter) => new Molarity((_value / 1e-3) * 1e-15d, MolarityUnit.MolePerCubicMeter),
-                (MolarityUnit.KilomolePerCubicMeter, MolarityUnit.MolePerCubicMeter) => new Molarity((_value) * 1e3d, MolarityUnit.MolePerCubicMeter),
-                (MolarityUnit.MicromolePerLiter, MolarityUnit.MolePerCubicMeter) => new Molarity((_value / 1e-3) * 1e-6d, MolarityUnit.MolePerCubicMeter),
-                (MolarityUnit.MillimolePerLiter, MolarityUnit.MolePerCubicMeter) => new Molarity((_value / 1e-3) * 1e-3d, MolarityUnit.MolePerCubicMeter),
-                (MolarityUnit.MolePerLiter, MolarityUnit.MolePerCubicMeter) => new Molarity(_value / 1e-3, MolarityUnit.MolePerCubicMeter),
-                (MolarityUnit.NanomolePerLiter, MolarityUnit.MolePerCubicMeter) => new Molarity((_value / 1e-3) * 1e-9d, MolarityUnit.MolePerCubicMeter),
-                (MolarityUnit.PicomolePerLiter, MolarityUnit.MolePerCubicMeter) => new Molarity((_value / 1e-3) * 1e-12d, MolarityUnit.MolePerCubicMeter),
-                (MolarityUnit.PoundMolePerCubicFoot, MolarityUnit.MolePerCubicMeter) => new Molarity(_value * 1000 * 0.45359237 / 0.028316846592, MolarityUnit.MolePerCubicMeter),
-
-                // BaseUnit -> MolarityUnit
-                (MolarityUnit.MolePerCubicMeter, MolarityUnit.CentimolePerLiter) => new Molarity((_value * 1e-3) / 1e-2d, MolarityUnit.CentimolePerLiter),
-                (MolarityUnit.MolePerCubicMeter, MolarityUnit.DecimolePerLiter) => new Molarity((_value * 1e-3) / 1e-1d, MolarityUnit.DecimolePerLiter),
-                (MolarityUnit.MolePerCubicMeter, MolarityUnit.FemtomolePerLiter) => new Molarity((_value * 1e-3) / 1e-15d, MolarityUnit.FemtomolePerLiter),
-                (MolarityUnit.MolePerCubicMeter, MolarityUnit.KilomolePerCubicMeter) => new Molarity((_value) / 1e3d, MolarityUnit.KilomolePerCubicMeter),
-                (MolarityUnit.MolePerCubicMeter, MolarityUnit.MicromolePerLiter) => new Molarity((_value * 1e-3) / 1e-6d, MolarityUnit.MicromolePerLiter),
-                (MolarityUnit.MolePerCubicMeter, MolarityUnit.MillimolePerLiter) => new Molarity((_value * 1e-3) / 1e-3d, MolarityUnit.MillimolePerLiter),
-                (MolarityUnit.MolePerCubicMeter, MolarityUnit.MolePerLiter) => new Molarity(_value * 1e-3, MolarityUnit.MolePerLiter),
-                (MolarityUnit.MolePerCubicMeter, MolarityUnit.NanomolePerLiter) => new Molarity((_value * 1e-3) / 1e-9d, MolarityUnit.NanomolePerLiter),
-                (MolarityUnit.MolePerCubicMeter, MolarityUnit.PicomolePerLiter) => new Molarity((_value * 1e-3) / 1e-12d, MolarityUnit.PicomolePerLiter),
-                (MolarityUnit.MolePerCubicMeter, MolarityUnit.PoundMolePerCubicFoot) => new Molarity(_value / (1000 * 0.45359237 / 0.028316846592), MolarityUnit.PoundMolePerCubicFoot),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not MolarityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is MolarityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<MolarityUnit> IQuantity<MolarityUnit>.ToUnit(MolarityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -947,11 +796,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
index 25987bbc99..09a6c41475 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Permeability_(electromagnetism)
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Permeability :
-        IArithmeticQuantity<Permeability, PermeabilityUnit>,
+        ILinearQuantity<Permeability, PermeabilityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Permeability, Permeability, double>,
+        IDivisionOperators<Permeability, Permeability, QuantityValue>,
         IComparisonOperators<Permeability, Permeability, bool>,
         IParsable<Permeability>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static PermeabilityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Per
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Permeability"/> is [T^-2][L][M][I^-2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Permeability"/> is T^-2LMI^-2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 1, -2, -2, 0, 0, 0);
 
@@ -126,9 +125,7 @@ public static IEnumerable<UnitDefinition<PermeabilityUnit>> GetDefaultMappings()
 
         static Permeability()
         {
-            Info = PermeabilityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(PermeabilityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +133,7 @@ static Permeability()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Permeability(double value, PermeabilityUnit unit)
+        public Permeability(QuantityValue value, PermeabilityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -150,7 +147,7 @@ public Permeability(double value, PermeabilityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Permeability(double value, UnitSystem unitSystem)
+        public Permeability(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -161,7 +158,8 @@ public Permeability(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Permeability" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Permeability, PermeabilityUnit> Info { get; }
@@ -190,10 +188,8 @@ public Permeability(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public PermeabilityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,28 +223,14 @@ public Permeability(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PermeabilityUnit.HenryPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PermeabilityUnit.HenryPerMeter"/>
         /// </summary>
-        public double HenriesPerMeter => As(PermeabilityUnit.HenryPerMeter);
+        public QuantityValue HenriesPerMeter => this.As(PermeabilityUnit.HenryPerMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: PermeabilityUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Permeability>(PermeabilityUnit.HenryPerMeter, PermeabilityUnit.HenryPerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> PermeabilityUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -277,7 +259,7 @@ public static string GetAbbreviation(PermeabilityUnit unit, IFormatProvider? pro
         /// <summary>
         ///     Creates a <see cref="Permeability"/> from <see cref="PermeabilityUnit.HenryPerMeter"/>.
         /// </summary>
-        public static Permeability FromHenriesPerMeter(double value)
+        public static Permeability FromHenriesPerMeter(QuantityValue value)
         {
             return new Permeability(value, PermeabilityUnit.HenryPerMeter);
         }
@@ -288,7 +270,7 @@ public static Permeability FromHenriesPerMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Permeability unit value.</returns>
-        public static Permeability From(double value, PermeabilityUnit fromUnit)
+        public static Permeability From(QuantityValue value, PermeabilityUnit fromUnit)
         {
             return new Permeability(value, fromUnit);
         }
@@ -349,10 +331,7 @@ public static Permeability Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Permeability Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Permeability, PermeabilityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Permeability, PermeabilityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -380,11 +359,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Permeability res
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Permeability result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Permeability, PermeabilityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Permeability, PermeabilityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -405,7 +380,7 @@ public static PermeabilityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -416,7 +391,7 @@ public static PermeabilityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PermeabilityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.PermeabilityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out PermeabilityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -431,7 +406,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Permeability
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out PermeabilityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -450,35 +425,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Permeability"/> from adding two <see cref="Permeability"/>.</summary>
         public static Permeability operator +(Permeability left, Permeability right)
         {
-            return new Permeability(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Permeability(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Permeability"/> from subtracting two <see cref="Permeability"/>.</summary>
         public static Permeability operator -(Permeability left, Permeability right)
         {
-            return new Permeability(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Permeability(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Permeability"/> from multiplying value and <see cref="Permeability"/>.</summary>
-        public static Permeability operator *(double left, Permeability right)
+        public static Permeability operator *(QuantityValue left, Permeability right)
         {
             return new Permeability(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Permeability"/> from multiplying value and <see cref="Permeability"/>.</summary>
-        public static Permeability operator *(Permeability left, double right)
+        public static Permeability operator *(Permeability left, QuantityValue right)
         {
             return new Permeability(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Permeability"/> from dividing <see cref="Permeability"/> by value.</summary>
-        public static Permeability operator /(Permeability left, double right)
+        public static Permeability operator /(Permeability left, QuantityValue right)
         {
             return new Permeability(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Permeability"/> by <see cref="Permeability"/>.</summary>
-        public static double operator /(Permeability left, Permeability right)
+        public static QuantityValue operator /(Permeability left, Permeability right)
         {
             return left.HenriesPerMeter / right.HenriesPerMeter;
         }
@@ -490,97 +465,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Permeability left, Permeability right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Permeability left, Permeability right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Permeability left, Permeability right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Permeability left, Permeability right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Permeability"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Permeability other, Permeability tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Permeability"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Permeability)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Permeability left, Permeability right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Permeability"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Permeability other, Permeability tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Permeability"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Permeability,Permeability)"/>.
+        ///     See that operator (and <see cref="Equals(Permeability)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Permeability left, Permeability right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Permeability"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Permeability other, Permeability tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Permeability"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Permeability"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Permeability"/>, this method delegates to
+        ///     <see cref="Equals(Permeability)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Permeability otherQuantity))
+            if (obj is not Permeability otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Permeability"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Permeability other, Permeability tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Permeability"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Permeability other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Permeability.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Permeability), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Permeability"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Permeability)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Permeability otherQuantity)) throw new ArgumentException("Expected type Permeability.", nameof(obj));
+            if (obj is not Permeability otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Permeability>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Permeability"/> with another <see cref="Permeability"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Permeability"/> with another <see cref="Permeability"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -592,131 +581,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Permeability other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(PermeabilityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<PermeabilityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Permeability to another Permeability with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Permeability with the specified unit.</returns>
-        public Permeability ToUnit(PermeabilityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Permeability"/> to another <see cref="Permeability"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Permeability with the specified unit.</returns>
-        public Permeability ToUnit(PermeabilityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Permeability), Unit, typeof(Permeability), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Permeability)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Permeability"/> to another <see cref="Permeability"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Permeability"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(PermeabilityUnit unit, [NotNullWhen(true)] out Permeability? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Permeability? convertedOrNull = (Unit, unit) switch
-            {
-                // PermeabilityUnit -> BaseUnit
-
-                // BaseUnit -> PermeabilityUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not PermeabilityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermeabilityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is PermeabilityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermeabilityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<PermeabilityUnit> IQuantity<PermeabilityUnit>.ToUnit(PermeabilityUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -728,11 +597,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
index 35b62f63d6..5a17c20b4a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Permittivity
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Permittivity :
-        IArithmeticQuantity<Permittivity, PermittivityUnit>,
+        ILinearQuantity<Permittivity, PermittivityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Permittivity, Permittivity, double>,
+        IDivisionOperators<Permittivity, Permittivity, QuantityValue>,
         IComparisonOperators<Permittivity, Permittivity, bool>,
         IParsable<Permittivity>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static PermittivityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Per
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Permittivity"/> is [T^4][L^-3][M^-1][I^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Permittivity"/> is T^4L^-3M^-1I^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-3, -1, 4, 2, 0, 0, 0);
 
@@ -126,9 +125,7 @@ public static IEnumerable<UnitDefinition<PermittivityUnit>> GetDefaultMappings()
 
         static Permittivity()
         {
-            Info = PermittivityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(PermittivityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +133,7 @@ static Permittivity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Permittivity(double value, PermittivityUnit unit)
+        public Permittivity(QuantityValue value, PermittivityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -150,7 +147,7 @@ public Permittivity(double value, PermittivityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Permittivity(double value, UnitSystem unitSystem)
+        public Permittivity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -161,7 +158,8 @@ public Permittivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Permittivity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Permittivity, PermittivityUnit> Info { get; }
@@ -190,10 +188,8 @@ public Permittivity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public PermittivityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,28 +223,14 @@ public Permittivity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PermittivityUnit.FaradPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PermittivityUnit.FaradPerMeter"/>
         /// </summary>
-        public double FaradsPerMeter => As(PermittivityUnit.FaradPerMeter);
+        public QuantityValue FaradsPerMeter => this.As(PermittivityUnit.FaradPerMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: PermittivityUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Permittivity>(PermittivityUnit.FaradPerMeter, PermittivityUnit.FaradPerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> PermittivityUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -277,7 +259,7 @@ public static string GetAbbreviation(PermittivityUnit unit, IFormatProvider? pro
         /// <summary>
         ///     Creates a <see cref="Permittivity"/> from <see cref="PermittivityUnit.FaradPerMeter"/>.
         /// </summary>
-        public static Permittivity FromFaradsPerMeter(double value)
+        public static Permittivity FromFaradsPerMeter(QuantityValue value)
         {
             return new Permittivity(value, PermittivityUnit.FaradPerMeter);
         }
@@ -288,7 +270,7 @@ public static Permittivity FromFaradsPerMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Permittivity unit value.</returns>
-        public static Permittivity From(double value, PermittivityUnit fromUnit)
+        public static Permittivity From(QuantityValue value, PermittivityUnit fromUnit)
         {
             return new Permittivity(value, fromUnit);
         }
@@ -349,10 +331,7 @@ public static Permittivity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Permittivity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Permittivity, PermittivityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Permittivity, PermittivityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -380,11 +359,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Permittivity res
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Permittivity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Permittivity, PermittivityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Permittivity, PermittivityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -405,7 +380,7 @@ public static PermittivityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -416,7 +391,7 @@ public static PermittivityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PermittivityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.PermittivityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out PermittivityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -431,7 +406,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Permittivity
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out PermittivityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -450,35 +425,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Permittivity"/> from adding two <see cref="Permittivity"/>.</summary>
         public static Permittivity operator +(Permittivity left, Permittivity right)
         {
-            return new Permittivity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Permittivity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Permittivity"/> from subtracting two <see cref="Permittivity"/>.</summary>
         public static Permittivity operator -(Permittivity left, Permittivity right)
         {
-            return new Permittivity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Permittivity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Permittivity"/> from multiplying value and <see cref="Permittivity"/>.</summary>
-        public static Permittivity operator *(double left, Permittivity right)
+        public static Permittivity operator *(QuantityValue left, Permittivity right)
         {
             return new Permittivity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Permittivity"/> from multiplying value and <see cref="Permittivity"/>.</summary>
-        public static Permittivity operator *(Permittivity left, double right)
+        public static Permittivity operator *(Permittivity left, QuantityValue right)
         {
             return new Permittivity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Permittivity"/> from dividing <see cref="Permittivity"/> by value.</summary>
-        public static Permittivity operator /(Permittivity left, double right)
+        public static Permittivity operator /(Permittivity left, QuantityValue right)
         {
             return new Permittivity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Permittivity"/> by <see cref="Permittivity"/>.</summary>
-        public static double operator /(Permittivity left, Permittivity right)
+        public static QuantityValue operator /(Permittivity left, Permittivity right)
         {
             return left.FaradsPerMeter / right.FaradsPerMeter;
         }
@@ -490,97 +465,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Permittivity left, Permittivity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Permittivity left, Permittivity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Permittivity left, Permittivity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Permittivity left, Permittivity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Permittivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Permittivity other, Permittivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Permittivity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Permittivity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Permittivity left, Permittivity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Permittivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Permittivity other, Permittivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Permittivity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Permittivity,Permittivity)"/>.
+        ///     See that operator (and <see cref="Equals(Permittivity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Permittivity left, Permittivity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Permittivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Permittivity other, Permittivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Permittivity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Permittivity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Permittivity"/>, this method delegates to
+        ///     <see cref="Equals(Permittivity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Permittivity otherQuantity))
+            if (obj is not Permittivity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Permittivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Permittivity other, Permittivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Permittivity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Permittivity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Permittivity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Permittivity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Permittivity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Permittivity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Permittivity otherQuantity)) throw new ArgumentException("Expected type Permittivity.", nameof(obj));
+            if (obj is not Permittivity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Permittivity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Permittivity"/> with another <see cref="Permittivity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Permittivity"/> with another <see cref="Permittivity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -592,131 +581,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Permittivity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(PermittivityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<PermittivityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Permittivity to another Permittivity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Permittivity with the specified unit.</returns>
-        public Permittivity ToUnit(PermittivityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Permittivity"/> to another <see cref="Permittivity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Permittivity with the specified unit.</returns>
-        public Permittivity ToUnit(PermittivityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Permittivity), Unit, typeof(Permittivity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Permittivity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Permittivity"/> to another <see cref="Permittivity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Permittivity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(PermittivityUnit unit, [NotNullWhen(true)] out Permittivity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Permittivity? convertedOrNull = (Unit, unit) switch
-            {
-                // PermittivityUnit -> BaseUnit
-
-                // BaseUnit -> PermittivityUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not PermittivityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermittivityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is PermittivityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermittivityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<PermittivityUnit> IQuantity<PermittivityUnit>.ToUnit(PermittivityUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -728,11 +597,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs b/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
index 3d228d91f6..a798ce1b4d 100644
--- a/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Permeability_(Earth_sciences)
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct PorousMediumPermeability :
-        IArithmeticQuantity<PorousMediumPermeability, PorousMediumPermeabilityUnit>,
+        ILinearQuantity<PorousMediumPermeability, PorousMediumPermeabilityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<PorousMediumPermeability, PorousMediumPermeability, double>,
+        IDivisionOperators<PorousMediumPermeability, PorousMediumPermeability, QuantityValue>,
         IComparisonOperators<PorousMediumPermeability, PorousMediumPermeability, bool>,
         IParsable<PorousMediumPermeability>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static PorousMediumPermeabilityInfo CreateDefault(Func<IEnumerable<UnitDe
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="PorousMediumPermeability"/> is [L^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="PorousMediumPermeability"/> is L^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
 
@@ -120,19 +119,25 @@ public static PorousMediumPermeabilityInfo CreateDefault(Func<IEnumerable<UnitDe
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{PorousMediumPermeabilityUnit}"/> representing the default unit mappings for PorousMediumPermeability.</returns>
             public static IEnumerable<UnitDefinition<PorousMediumPermeabilityUnit>> GetDefaultMappings()
             {
-                yield return new (PorousMediumPermeabilityUnit.Darcy, "Darcy", "Darcys", BaseUnits.Undefined);
-                yield return new (PorousMediumPermeabilityUnit.Microdarcy, "Microdarcy", "Microdarcys", BaseUnits.Undefined);
-                yield return new (PorousMediumPermeabilityUnit.Millidarcy, "Millidarcy", "Millidarcys", BaseUnits.Undefined);
-                yield return new (PorousMediumPermeabilityUnit.SquareCentimeter, "SquareCentimeter", "SquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter));
+                yield return new (PorousMediumPermeabilityUnit.Darcy, "Darcy", "Darcys", BaseUnits.Undefined,
+                     new QuantityValue(QuantityValue.PowerOfTen(19), 9869233)
+                );
+                yield return new (PorousMediumPermeabilityUnit.Microdarcy, "Microdarcy", "Microdarcys", BaseUnits.Undefined,
+                     new QuantityValue(QuantityValue.PowerOfTen(25), 9869233)
+                );
+                yield return new (PorousMediumPermeabilityUnit.Millidarcy, "Millidarcy", "Millidarcys", BaseUnits.Undefined,
+                     new QuantityValue(QuantityValue.PowerOfTen(22), 9869233)
+                );
+                yield return new (PorousMediumPermeabilityUnit.SquareCentimeter, "SquareCentimeter", "SquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter),
+                     10000
+                );
                 yield return new (PorousMediumPermeabilityUnit.SquareMeter, "SquareMeter", "SquareMeters", new BaseUnits(length: LengthUnit.Meter));
             }
         }
 
         static PorousMediumPermeability()
         {
-            Info = PorousMediumPermeabilityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(PorousMediumPermeabilityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -140,7 +145,7 @@ static PorousMediumPermeability()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public PorousMediumPermeability(double value, PorousMediumPermeabilityUnit unit)
+        public PorousMediumPermeability(QuantityValue value, PorousMediumPermeabilityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -154,7 +159,7 @@ public PorousMediumPermeability(double value, PorousMediumPermeabilityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public PorousMediumPermeability(double value, UnitSystem unitSystem)
+        public PorousMediumPermeability(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -165,7 +170,8 @@ public PorousMediumPermeability(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="PorousMediumPermeability" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<PorousMediumPermeability, PorousMediumPermeabilityUnit> Info { get; }
@@ -194,10 +200,8 @@ public PorousMediumPermeability(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public PorousMediumPermeabilityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -231,56 +235,34 @@ public PorousMediumPermeability(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.Darcy"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.Darcy"/>
         /// </summary>
-        public double Darcys => As(PorousMediumPermeabilityUnit.Darcy);
+        public QuantityValue Darcys => this.As(PorousMediumPermeabilityUnit.Darcy);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.Microdarcy"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.Microdarcy"/>
         /// </summary>
-        public double Microdarcys => As(PorousMediumPermeabilityUnit.Microdarcy);
+        public QuantityValue Microdarcys => this.As(PorousMediumPermeabilityUnit.Microdarcy);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.Millidarcy"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.Millidarcy"/>
         /// </summary>
-        public double Millidarcys => As(PorousMediumPermeabilityUnit.Millidarcy);
+        public QuantityValue Millidarcys => this.As(PorousMediumPermeabilityUnit.Millidarcy);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.SquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.SquareCentimeter"/>
         /// </summary>
-        public double SquareCentimeters => As(PorousMediumPermeabilityUnit.SquareCentimeter);
+        public QuantityValue SquareCentimeters => this.As(PorousMediumPermeabilityUnit.SquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.SquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PorousMediumPermeabilityUnit.SquareMeter"/>
         /// </summary>
-        public double SquareMeters => As(PorousMediumPermeabilityUnit.SquareMeter);
+        public QuantityValue SquareMeters => this.As(PorousMediumPermeabilityUnit.SquareMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: PorousMediumPermeabilityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<PorousMediumPermeability>(PorousMediumPermeabilityUnit.Darcy, PorousMediumPermeabilityUnit.SquareMeter, quantity => quantity.ToUnit(PorousMediumPermeabilityUnit.SquareMeter));
-            unitConverter.SetConversionFunction<PorousMediumPermeability>(PorousMediumPermeabilityUnit.Microdarcy, PorousMediumPermeabilityUnit.SquareMeter, quantity => quantity.ToUnit(PorousMediumPermeabilityUnit.SquareMeter));
-            unitConverter.SetConversionFunction<PorousMediumPermeability>(PorousMediumPermeabilityUnit.Millidarcy, PorousMediumPermeabilityUnit.SquareMeter, quantity => quantity.ToUnit(PorousMediumPermeabilityUnit.SquareMeter));
-            unitConverter.SetConversionFunction<PorousMediumPermeability>(PorousMediumPermeabilityUnit.SquareCentimeter, PorousMediumPermeabilityUnit.SquareMeter, quantity => quantity.ToUnit(PorousMediumPermeabilityUnit.SquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<PorousMediumPermeability>(PorousMediumPermeabilityUnit.SquareMeter, PorousMediumPermeabilityUnit.SquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> PorousMediumPermeabilityUnit
-            unitConverter.SetConversionFunction<PorousMediumPermeability>(PorousMediumPermeabilityUnit.SquareMeter, PorousMediumPermeabilityUnit.Darcy, quantity => quantity.ToUnit(PorousMediumPermeabilityUnit.Darcy));
-            unitConverter.SetConversionFunction<PorousMediumPermeability>(PorousMediumPermeabilityUnit.SquareMeter, PorousMediumPermeabilityUnit.Microdarcy, quantity => quantity.ToUnit(PorousMediumPermeabilityUnit.Microdarcy));
-            unitConverter.SetConversionFunction<PorousMediumPermeability>(PorousMediumPermeabilityUnit.SquareMeter, PorousMediumPermeabilityUnit.Millidarcy, quantity => quantity.ToUnit(PorousMediumPermeabilityUnit.Millidarcy));
-            unitConverter.SetConversionFunction<PorousMediumPermeability>(PorousMediumPermeabilityUnit.SquareMeter, PorousMediumPermeabilityUnit.SquareCentimeter, quantity => quantity.ToUnit(PorousMediumPermeabilityUnit.SquareCentimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -309,7 +291,7 @@ public static string GetAbbreviation(PorousMediumPermeabilityUnit unit, IFormatP
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Darcy"/>.
         /// </summary>
-        public static PorousMediumPermeability FromDarcys(double value)
+        public static PorousMediumPermeability FromDarcys(QuantityValue value)
         {
             return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.Darcy);
         }
@@ -317,7 +299,7 @@ public static PorousMediumPermeability FromDarcys(double value)
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Microdarcy"/>.
         /// </summary>
-        public static PorousMediumPermeability FromMicrodarcys(double value)
+        public static PorousMediumPermeability FromMicrodarcys(QuantityValue value)
         {
             return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.Microdarcy);
         }
@@ -325,7 +307,7 @@ public static PorousMediumPermeability FromMicrodarcys(double value)
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Millidarcy"/>.
         /// </summary>
-        public static PorousMediumPermeability FromMillidarcys(double value)
+        public static PorousMediumPermeability FromMillidarcys(QuantityValue value)
         {
             return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.Millidarcy);
         }
@@ -333,7 +315,7 @@ public static PorousMediumPermeability FromMillidarcys(double value)
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.SquareCentimeter"/>.
         /// </summary>
-        public static PorousMediumPermeability FromSquareCentimeters(double value)
+        public static PorousMediumPermeability FromSquareCentimeters(QuantityValue value)
         {
             return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.SquareCentimeter);
         }
@@ -341,7 +323,7 @@ public static PorousMediumPermeability FromSquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.SquareMeter"/>.
         /// </summary>
-        public static PorousMediumPermeability FromSquareMeters(double value)
+        public static PorousMediumPermeability FromSquareMeters(QuantityValue value)
         {
             return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.SquareMeter);
         }
@@ -352,7 +334,7 @@ public static PorousMediumPermeability FromSquareMeters(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>PorousMediumPermeability unit value.</returns>
-        public static PorousMediumPermeability From(double value, PorousMediumPermeabilityUnit fromUnit)
+        public static PorousMediumPermeability From(QuantityValue value, PorousMediumPermeabilityUnit fromUnit)
         {
             return new PorousMediumPermeability(value, fromUnit);
         }
@@ -413,10 +395,7 @@ public static PorousMediumPermeability Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static PorousMediumPermeability Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<PorousMediumPermeability, PorousMediumPermeabilityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<PorousMediumPermeability, PorousMediumPermeabilityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -444,11 +423,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out PorousMediumPerm
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out PorousMediumPermeability result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<PorousMediumPermeability, PorousMediumPermeabilityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<PorousMediumPermeability, PorousMediumPermeabilityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -469,7 +444,7 @@ public static PorousMediumPermeabilityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -480,7 +455,7 @@ public static PorousMediumPermeabilityUnit ParseUnit(string str, IFormatProvider
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PorousMediumPermeabilityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.PorousMediumPermeabilityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out PorousMediumPermeabilityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -495,7 +470,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PorousMedium
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out PorousMediumPermeabilityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -514,35 +489,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="PorousMediumPermeability"/> from adding two <see cref="PorousMediumPermeability"/>.</summary>
         public static PorousMediumPermeability operator +(PorousMediumPermeability left, PorousMediumPermeability right)
         {
-            return new PorousMediumPermeability(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new PorousMediumPermeability(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="PorousMediumPermeability"/> from subtracting two <see cref="PorousMediumPermeability"/>.</summary>
         public static PorousMediumPermeability operator -(PorousMediumPermeability left, PorousMediumPermeability right)
         {
-            return new PorousMediumPermeability(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new PorousMediumPermeability(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="PorousMediumPermeability"/> from multiplying value and <see cref="PorousMediumPermeability"/>.</summary>
-        public static PorousMediumPermeability operator *(double left, PorousMediumPermeability right)
+        public static PorousMediumPermeability operator *(QuantityValue left, PorousMediumPermeability right)
         {
             return new PorousMediumPermeability(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="PorousMediumPermeability"/> from multiplying value and <see cref="PorousMediumPermeability"/>.</summary>
-        public static PorousMediumPermeability operator *(PorousMediumPermeability left, double right)
+        public static PorousMediumPermeability operator *(PorousMediumPermeability left, QuantityValue right)
         {
             return new PorousMediumPermeability(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="PorousMediumPermeability"/> from dividing <see cref="PorousMediumPermeability"/> by value.</summary>
-        public static PorousMediumPermeability operator /(PorousMediumPermeability left, double right)
+        public static PorousMediumPermeability operator /(PorousMediumPermeability left, QuantityValue right)
         {
             return new PorousMediumPermeability(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="PorousMediumPermeability"/> by <see cref="PorousMediumPermeability"/>.</summary>
-        public static double operator /(PorousMediumPermeability left, PorousMediumPermeability right)
+        public static QuantityValue operator /(PorousMediumPermeability left, PorousMediumPermeability right)
         {
             return left.SquareMeters / right.SquareMeters;
         }
@@ -554,97 +529,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(PorousMediumPermeability left, PorousMediumPermeability right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(PorousMediumPermeability left, PorousMediumPermeability right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(PorousMediumPermeability left, PorousMediumPermeability right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(PorousMediumPermeability left, PorousMediumPermeability right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="PorousMediumPermeability"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(PorousMediumPermeability other, PorousMediumPermeability tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="PorousMediumPermeability"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(PorousMediumPermeability)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(PorousMediumPermeability left, PorousMediumPermeability right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="PorousMediumPermeability"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(PorousMediumPermeability other, PorousMediumPermeability tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="PorousMediumPermeability"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(PorousMediumPermeability,PorousMediumPermeability)"/>.
+        ///     See that operator (and <see cref="Equals(PorousMediumPermeability)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(PorousMediumPermeability left, PorousMediumPermeability right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="PorousMediumPermeability"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(PorousMediumPermeability other, PorousMediumPermeability tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="PorousMediumPermeability"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="PorousMediumPermeability"/>.
+        ///     When <paramref name="obj"/> is a <see cref="PorousMediumPermeability"/>, this method delegates to
+        ///     <see cref="Equals(PorousMediumPermeability)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is PorousMediumPermeability otherQuantity))
+            if (obj is not PorousMediumPermeability otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="PorousMediumPermeability"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(PorousMediumPermeability other, PorousMediumPermeability tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="PorousMediumPermeability"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(PorousMediumPermeability other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current PorousMediumPermeability.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(PorousMediumPermeability), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="PorousMediumPermeability"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(PorousMediumPermeability)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is PorousMediumPermeability otherQuantity)) throw new ArgumentException("Expected type PorousMediumPermeability.", nameof(obj));
+            if (obj is not PorousMediumPermeability otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<PorousMediumPermeability>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="PorousMediumPermeability"/> with another <see cref="PorousMediumPermeability"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="PorousMediumPermeability"/> with another <see cref="PorousMediumPermeability"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -656,137 +645,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(PorousMediumPermeability other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(PorousMediumPermeabilityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<PorousMediumPermeabilityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this PorousMediumPermeability to another PorousMediumPermeability with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A PorousMediumPermeability with the specified unit.</returns>
-        public PorousMediumPermeability ToUnit(PorousMediumPermeabilityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="PorousMediumPermeability"/> to another <see cref="PorousMediumPermeability"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A PorousMediumPermeability with the specified unit.</returns>
-        public PorousMediumPermeability ToUnit(PorousMediumPermeabilityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(PorousMediumPermeability), Unit, typeof(PorousMediumPermeability), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (PorousMediumPermeability)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="PorousMediumPermeability"/> to another <see cref="PorousMediumPermeability"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="PorousMediumPermeability"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(PorousMediumPermeabilityUnit unit, [NotNullWhen(true)] out PorousMediumPermeability? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            PorousMediumPermeability? convertedOrNull = (Unit, unit) switch
-            {
-                // PorousMediumPermeabilityUnit -> BaseUnit
-                (PorousMediumPermeabilityUnit.Darcy, PorousMediumPermeabilityUnit.SquareMeter) => new PorousMediumPermeability(_value * 9.869233e-13, PorousMediumPermeabilityUnit.SquareMeter),
-                (PorousMediumPermeabilityUnit.Microdarcy, PorousMediumPermeabilityUnit.SquareMeter) => new PorousMediumPermeability((_value * 9.869233e-13) * 1e-6d, PorousMediumPermeabilityUnit.SquareMeter),
-                (PorousMediumPermeabilityUnit.Millidarcy, PorousMediumPermeabilityUnit.SquareMeter) => new PorousMediumPermeability((_value * 9.869233e-13) * 1e-3d, PorousMediumPermeabilityUnit.SquareMeter),
-                (PorousMediumPermeabilityUnit.SquareCentimeter, PorousMediumPermeabilityUnit.SquareMeter) => new PorousMediumPermeability(_value * 1e-4, PorousMediumPermeabilityUnit.SquareMeter),
-
-                // BaseUnit -> PorousMediumPermeabilityUnit
-                (PorousMediumPermeabilityUnit.SquareMeter, PorousMediumPermeabilityUnit.Darcy) => new PorousMediumPermeability(_value / 9.869233e-13, PorousMediumPermeabilityUnit.Darcy),
-                (PorousMediumPermeabilityUnit.SquareMeter, PorousMediumPermeabilityUnit.Microdarcy) => new PorousMediumPermeability((_value / 9.869233e-13) / 1e-6d, PorousMediumPermeabilityUnit.Microdarcy),
-                (PorousMediumPermeabilityUnit.SquareMeter, PorousMediumPermeabilityUnit.Millidarcy) => new PorousMediumPermeability((_value / 9.869233e-13) / 1e-3d, PorousMediumPermeabilityUnit.Millidarcy),
-                (PorousMediumPermeabilityUnit.SquareMeter, PorousMediumPermeabilityUnit.SquareCentimeter) => new PorousMediumPermeability(_value / 1e-4, PorousMediumPermeabilityUnit.SquareCentimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not PorousMediumPermeabilityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PorousMediumPermeabilityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is PorousMediumPermeabilityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PorousMediumPermeabilityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<PorousMediumPermeabilityUnit> IQuantity<PorousMediumPermeabilityUnit>.ToUnit(PorousMediumPermeabilityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -800,11 +661,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Power.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
index 2f49d5080e..ab15bcfe09 100644
--- a/UnitsNet/GeneratedCode/Quantities/Power.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     In physics, power is the rate of doing work. It is equivalent to an amount of energy consumed per unit time.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Power :
-        IArithmeticQuantity<Power, PowerUnit>,
+        ILinearQuantity<Power, PowerUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Power, Power, double>,
+        IDivisionOperators<Power, Power, QuantityValue>,
         IDivisionOperators<Power, HeatFlux, Area>,
         IDivisionOperators<Power, ElectricPotential, ElectricCurrent>,
         IDivisionOperators<Power, ElectricCurrent, ElectricPotential>,
@@ -48,12 +47,17 @@ namespace UnitsNet
         IDivisionOperators<Power, Speed, Force>,
         IDivisionOperators<Power, Energy, Frequency>,
         IDivisionOperators<Power, Area, HeatFlux>,
+        IDivisionOperators<Power, LinearPowerDensity, Length>,
+        IDivisionOperators<Power, Length, LinearPowerDensity>,
         IMultiplyOperators<Power, BrakeSpecificFuelConsumption, MassFlow>,
         IDivisionOperators<Power, SpecificEnergy, MassFlow>,
+        IDivisionOperators<Power, Volume, PowerDensity>,
         IDivisionOperators<Power, Torque, RotationalSpeed>,
         IDivisionOperators<Power, MassFlow, SpecificEnergy>,
         IDivisionOperators<Power, Force, Speed>,
+        IMultiplyOperators<Power, ThermalResistance, TemperatureDelta>,
         IDivisionOperators<Power, RotationalSpeed, Torque>,
+        IDivisionOperators<Power, PowerDensity, Volume>,
         IComparisonOperators<Power, Power, bool>,
         IParsable<Power>,
 #endif
@@ -66,7 +70,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -116,7 +120,7 @@ public static PowerInfo CreateDefault(Func<IEnumerable<UnitDefinition<PowerUnit>
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Power"/> is [T^-3][L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Power"/> is T^-3L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
 
@@ -131,41 +135,91 @@ public static PowerInfo CreateDefault(Func<IEnumerable<UnitDefinition<PowerUnit>
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{PowerUnit}"/> representing the default unit mappings for Power.</returns>
             public static IEnumerable<UnitDefinition<PowerUnit>> GetDefaultMappings()
             {
-                yield return new (PowerUnit.BoilerHorsepower, "BoilerHorsepower", "BoilerHorsepower", BaseUnits.Undefined);
-                yield return new (PowerUnit.BritishThermalUnitPerHour, "BritishThermalUnitPerHour", "BritishThermalUnitsPerHour", BaseUnits.Undefined);
-                yield return new (PowerUnit.Decawatt, "Decawatt", "Decawatts", BaseUnits.Undefined);
-                yield return new (PowerUnit.Deciwatt, "Deciwatt", "Deciwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Hectogram, time: DurationUnit.Second));
-                yield return new (PowerUnit.ElectricalHorsepower, "ElectricalHorsepower", "ElectricalHorsepower", BaseUnits.Undefined);
-                yield return new (PowerUnit.Femtowatt, "Femtowatt", "Femtowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Picogram, time: DurationUnit.Second));
-                yield return new (PowerUnit.GigajoulePerHour, "GigajoulePerHour", "GigajoulesPerHour", BaseUnits.Undefined);
-                yield return new (PowerUnit.Gigawatt, "Gigawatt", "Gigawatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond));
-                yield return new (PowerUnit.HydraulicHorsepower, "HydraulicHorsepower", "HydraulicHorsepower", BaseUnits.Undefined);
-                yield return new (PowerUnit.JoulePerHour, "JoulePerHour", "JoulesPerHour", BaseUnits.Undefined);
-                yield return new (PowerUnit.KilobritishThermalUnitPerHour, "KilobritishThermalUnitPerHour", "KilobritishThermalUnitsPerHour", BaseUnits.Undefined);
-                yield return new (PowerUnit.KilojoulePerHour, "KilojoulePerHour", "KilojoulesPerHour", BaseUnits.Undefined);
-                yield return new (PowerUnit.Kilowatt, "Kilowatt", "Kilowatts", BaseUnits.Undefined);
-                yield return new (PowerUnit.MechanicalHorsepower, "MechanicalHorsepower", "MechanicalHorsepower", BaseUnits.Undefined);
-                yield return new (PowerUnit.MegabritishThermalUnitPerHour, "MegabritishThermalUnitPerHour", "MegabritishThermalUnitsPerHour", BaseUnits.Undefined);
-                yield return new (PowerUnit.MegajoulePerHour, "MegajoulePerHour", "MegajoulesPerHour", BaseUnits.Undefined);
-                yield return new (PowerUnit.Megawatt, "Megawatt", "Megawatts", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PowerUnit.MetricHorsepower, "MetricHorsepower", "MetricHorsepower", BaseUnits.Undefined);
-                yield return new (PowerUnit.Microwatt, "Microwatt", "Microwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second));
-                yield return new (PowerUnit.MillijoulePerHour, "MillijoulePerHour", "MillijoulesPerHour", BaseUnits.Undefined);
-                yield return new (PowerUnit.Milliwatt, "Milliwatt", "Milliwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (PowerUnit.Nanowatt, "Nanowatt", "Nanowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second));
-                yield return new (PowerUnit.Petawatt, "Petawatt", "Petawatts", BaseUnits.Undefined);
-                yield return new (PowerUnit.Picowatt, "Picowatt", "Picowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second));
-                yield return new (PowerUnit.Terawatt, "Terawatt", "Terawatts", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PowerUnit.TonOfRefrigeration, "TonOfRefrigeration", "TonsOfRefrigeration", BaseUnits.Undefined);
+                yield return new (PowerUnit.BoilerHorsepower, "BoilerHorsepower", "BoilerHorsepower", BaseUnits.Undefined,
+                     new QuantityValue(2, 19625)
+                );
+                yield return new (PowerUnit.BritishThermalUnitPerHour, "BritishThermalUnitPerHour", "BritishThermalUnitsPerHour", BaseUnits.Undefined,
+                     new QuantityValue(180000000000, 52752792631)
+                );
+                yield return new (PowerUnit.Decawatt, "Decawatt", "Decawatts", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (PowerUnit.Deciwatt, "Deciwatt", "Deciwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Hectogram, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (PowerUnit.ElectricalHorsepower, "ElectricalHorsepower", "ElectricalHorsepower", BaseUnits.Undefined,
+                     new QuantityValue(1, 746)
+                );
+                yield return new (PowerUnit.Femtowatt, "Femtowatt", "Femtowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Picogram, time: DurationUnit.Second),
+                     1000000000000000
+                );
+                yield return new (PowerUnit.GigajoulePerHour, "GigajoulePerHour", "GigajoulesPerHour", BaseUnits.Undefined,
+                     new QuantityValue(9, 2500000)
+                );
+                yield return new (PowerUnit.Gigawatt, "Gigawatt", "Gigawatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (PowerUnit.HydraulicHorsepower, "HydraulicHorsepower", "HydraulicHorsepower", BaseUnits.Undefined,
+                     new QuantityValue(50000000000000, 37284993579113511)
+                );
+                yield return new (PowerUnit.JoulePerHour, "JoulePerHour", "JoulesPerHour", BaseUnits.Undefined,
+                     3600
+                );
+                yield return new (PowerUnit.KilobritishThermalUnitPerHour, "KilobritishThermalUnitPerHour", "KilobritishThermalUnitsPerHour", BaseUnits.Undefined,
+                     new QuantityValue(180000000, 52752792631)
+                );
+                yield return new (PowerUnit.KilojoulePerHour, "KilojoulePerHour", "KilojoulesPerHour", BaseUnits.Undefined,
+                     new QuantityValue(18, 5)
+                );
+                yield return new (PowerUnit.Kilowatt, "Kilowatt", "Kilowatts", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (PowerUnit.MechanicalHorsepower, "MechanicalHorsepower", "MechanicalHorsepower", BaseUnits.Undefined,
+                     new QuantityValue(200000000000, 149139974303117)
+                );
+                yield return new (PowerUnit.MegabritishThermalUnitPerHour, "MegabritishThermalUnitPerHour", "MegabritishThermalUnitsPerHour", BaseUnits.Undefined,
+                     new QuantityValue(180000, 52752792631)
+                );
+                yield return new (PowerUnit.MegajoulePerHour, "MegajoulePerHour", "MegajoulesPerHour", BaseUnits.Undefined,
+                     new QuantityValue(9, 2500)
+                );
+                yield return new (PowerUnit.Megawatt, "Megawatt", "Megawatts", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (PowerUnit.MetricHorsepower, "MetricHorsepower", "MetricHorsepower", BaseUnits.Undefined,
+                     new QuantityValue(800, 588399)
+                );
+                yield return new (PowerUnit.Microwatt, "Microwatt", "Microwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (PowerUnit.MillijoulePerHour, "MillijoulePerHour", "MillijoulesPerHour", BaseUnits.Undefined,
+                     3600000
+                );
+                yield return new (PowerUnit.Milliwatt, "Milliwatt", "Milliwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (PowerUnit.Nanowatt, "Nanowatt", "Nanowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (PowerUnit.Petawatt, "Petawatt", "Petawatts", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000)
+                );
+                yield return new (PowerUnit.Picowatt, "Picowatt", "Picowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second),
+                     1000000000000
+                );
+                yield return new (PowerUnit.Terawatt, "Terawatt", "Terawatts", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (PowerUnit.TonOfRefrigeration, "TonOfRefrigeration", "TonsOfRefrigeration", BaseUnits.Undefined,
+                     new QuantityValue(1000, 3516853)
+                );
                 yield return new (PowerUnit.Watt, "Watt", "Watts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
             }
         }
 
         static Power()
         {
-            Info = PowerInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(PowerInfo.CreateDefault);
         }
 
         /// <summary>
@@ -173,7 +227,7 @@ static Power()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Power(double value, PowerUnit unit)
+        public Power(QuantityValue value, PowerUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -187,7 +241,7 @@ public Power(double value, PowerUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Power(double value, UnitSystem unitSystem)
+        public Power(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -198,7 +252,8 @@ public Power(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Power" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Power, PowerUnit> Info { get; }
@@ -227,10 +282,8 @@ public Power(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public PowerUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -264,210 +317,144 @@ public Power(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.BoilerHorsepower"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.BoilerHorsepower"/>
         /// </summary>
-        public double BoilerHorsepower => As(PowerUnit.BoilerHorsepower);
+        public QuantityValue BoilerHorsepower => this.As(PowerUnit.BoilerHorsepower);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.BritishThermalUnitPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.BritishThermalUnitPerHour"/>
         /// </summary>
-        public double BritishThermalUnitsPerHour => As(PowerUnit.BritishThermalUnitPerHour);
+        public QuantityValue BritishThermalUnitsPerHour => this.As(PowerUnit.BritishThermalUnitPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Decawatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Decawatt"/>
         /// </summary>
-        public double Decawatts => As(PowerUnit.Decawatt);
+        public QuantityValue Decawatts => this.As(PowerUnit.Decawatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Deciwatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Deciwatt"/>
         /// </summary>
-        public double Deciwatts => As(PowerUnit.Deciwatt);
+        public QuantityValue Deciwatts => this.As(PowerUnit.Deciwatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.ElectricalHorsepower"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.ElectricalHorsepower"/>
         /// </summary>
-        public double ElectricalHorsepower => As(PowerUnit.ElectricalHorsepower);
+        public QuantityValue ElectricalHorsepower => this.As(PowerUnit.ElectricalHorsepower);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Femtowatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Femtowatt"/>
         /// </summary>
-        public double Femtowatts => As(PowerUnit.Femtowatt);
+        public QuantityValue Femtowatts => this.As(PowerUnit.Femtowatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.GigajoulePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.GigajoulePerHour"/>
         /// </summary>
-        public double GigajoulesPerHour => As(PowerUnit.GigajoulePerHour);
+        public QuantityValue GigajoulesPerHour => this.As(PowerUnit.GigajoulePerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Gigawatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Gigawatt"/>
         /// </summary>
-        public double Gigawatts => As(PowerUnit.Gigawatt);
+        public QuantityValue Gigawatts => this.As(PowerUnit.Gigawatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.HydraulicHorsepower"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.HydraulicHorsepower"/>
         /// </summary>
-        public double HydraulicHorsepower => As(PowerUnit.HydraulicHorsepower);
+        public QuantityValue HydraulicHorsepower => this.As(PowerUnit.HydraulicHorsepower);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.JoulePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.JoulePerHour"/>
         /// </summary>
-        public double JoulesPerHour => As(PowerUnit.JoulePerHour);
+        public QuantityValue JoulesPerHour => this.As(PowerUnit.JoulePerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.KilobritishThermalUnitPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.KilobritishThermalUnitPerHour"/>
         /// </summary>
-        public double KilobritishThermalUnitsPerHour => As(PowerUnit.KilobritishThermalUnitPerHour);
+        public QuantityValue KilobritishThermalUnitsPerHour => this.As(PowerUnit.KilobritishThermalUnitPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.KilojoulePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.KilojoulePerHour"/>
         /// </summary>
-        public double KilojoulesPerHour => As(PowerUnit.KilojoulePerHour);
+        public QuantityValue KilojoulesPerHour => this.As(PowerUnit.KilojoulePerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Kilowatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Kilowatt"/>
         /// </summary>
-        public double Kilowatts => As(PowerUnit.Kilowatt);
+        public QuantityValue Kilowatts => this.As(PowerUnit.Kilowatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.MechanicalHorsepower"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.MechanicalHorsepower"/>
         /// </summary>
-        public double MechanicalHorsepower => As(PowerUnit.MechanicalHorsepower);
+        public QuantityValue MechanicalHorsepower => this.As(PowerUnit.MechanicalHorsepower);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.MegabritishThermalUnitPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.MegabritishThermalUnitPerHour"/>
         /// </summary>
-        public double MegabritishThermalUnitsPerHour => As(PowerUnit.MegabritishThermalUnitPerHour);
+        public QuantityValue MegabritishThermalUnitsPerHour => this.As(PowerUnit.MegabritishThermalUnitPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.MegajoulePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.MegajoulePerHour"/>
         /// </summary>
-        public double MegajoulesPerHour => As(PowerUnit.MegajoulePerHour);
+        public QuantityValue MegajoulesPerHour => this.As(PowerUnit.MegajoulePerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Megawatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Megawatt"/>
         /// </summary>
-        public double Megawatts => As(PowerUnit.Megawatt);
+        public QuantityValue Megawatts => this.As(PowerUnit.Megawatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.MetricHorsepower"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.MetricHorsepower"/>
         /// </summary>
-        public double MetricHorsepower => As(PowerUnit.MetricHorsepower);
+        public QuantityValue MetricHorsepower => this.As(PowerUnit.MetricHorsepower);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Microwatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Microwatt"/>
         /// </summary>
-        public double Microwatts => As(PowerUnit.Microwatt);
+        public QuantityValue Microwatts => this.As(PowerUnit.Microwatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.MillijoulePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.MillijoulePerHour"/>
         /// </summary>
-        public double MillijoulesPerHour => As(PowerUnit.MillijoulePerHour);
+        public QuantityValue MillijoulesPerHour => this.As(PowerUnit.MillijoulePerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Milliwatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Milliwatt"/>
         /// </summary>
-        public double Milliwatts => As(PowerUnit.Milliwatt);
+        public QuantityValue Milliwatts => this.As(PowerUnit.Milliwatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Nanowatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Nanowatt"/>
         /// </summary>
-        public double Nanowatts => As(PowerUnit.Nanowatt);
+        public QuantityValue Nanowatts => this.As(PowerUnit.Nanowatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Petawatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Petawatt"/>
         /// </summary>
-        public double Petawatts => As(PowerUnit.Petawatt);
+        public QuantityValue Petawatts => this.As(PowerUnit.Petawatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Picowatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Picowatt"/>
         /// </summary>
-        public double Picowatts => As(PowerUnit.Picowatt);
+        public QuantityValue Picowatts => this.As(PowerUnit.Picowatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Terawatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Terawatt"/>
         /// </summary>
-        public double Terawatts => As(PowerUnit.Terawatt);
+        public QuantityValue Terawatts => this.As(PowerUnit.Terawatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.TonOfRefrigeration"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.TonOfRefrigeration"/>
         /// </summary>
-        public double TonsOfRefrigeration => As(PowerUnit.TonOfRefrigeration);
+        public QuantityValue TonsOfRefrigeration => this.As(PowerUnit.TonOfRefrigeration);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerUnit.Watt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerUnit.Watt"/>
         /// </summary>
-        public double Watts => As(PowerUnit.Watt);
+        public QuantityValue Watts => this.As(PowerUnit.Watt);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: PowerUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Power>(PowerUnit.BoilerHorsepower, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.BritishThermalUnitPerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Decawatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Deciwatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.ElectricalHorsepower, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Femtowatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.GigajoulePerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Gigawatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.HydraulicHorsepower, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.JoulePerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.KilobritishThermalUnitPerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.KilojoulePerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Kilowatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.MechanicalHorsepower, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.MegabritishThermalUnitPerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.MegajoulePerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Megawatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.MetricHorsepower, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Microwatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.MillijoulePerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Milliwatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Nanowatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Petawatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Picowatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Terawatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.TonOfRefrigeration, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Watt, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> PowerUnit
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.BoilerHorsepower, quantity => quantity.ToUnit(PowerUnit.BoilerHorsepower));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.BritishThermalUnitPerHour, quantity => quantity.ToUnit(PowerUnit.BritishThermalUnitPerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Decawatt, quantity => quantity.ToUnit(PowerUnit.Decawatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Deciwatt, quantity => quantity.ToUnit(PowerUnit.Deciwatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.ElectricalHorsepower, quantity => quantity.ToUnit(PowerUnit.ElectricalHorsepower));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Femtowatt, quantity => quantity.ToUnit(PowerUnit.Femtowatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.GigajoulePerHour, quantity => quantity.ToUnit(PowerUnit.GigajoulePerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Gigawatt, quantity => quantity.ToUnit(PowerUnit.Gigawatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.HydraulicHorsepower, quantity => quantity.ToUnit(PowerUnit.HydraulicHorsepower));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.JoulePerHour, quantity => quantity.ToUnit(PowerUnit.JoulePerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.KilobritishThermalUnitPerHour, quantity => quantity.ToUnit(PowerUnit.KilobritishThermalUnitPerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.KilojoulePerHour, quantity => quantity.ToUnit(PowerUnit.KilojoulePerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Kilowatt, quantity => quantity.ToUnit(PowerUnit.Kilowatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.MechanicalHorsepower, quantity => quantity.ToUnit(PowerUnit.MechanicalHorsepower));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.MegabritishThermalUnitPerHour, quantity => quantity.ToUnit(PowerUnit.MegabritishThermalUnitPerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.MegajoulePerHour, quantity => quantity.ToUnit(PowerUnit.MegajoulePerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Megawatt, quantity => quantity.ToUnit(PowerUnit.Megawatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.MetricHorsepower, quantity => quantity.ToUnit(PowerUnit.MetricHorsepower));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Microwatt, quantity => quantity.ToUnit(PowerUnit.Microwatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.MillijoulePerHour, quantity => quantity.ToUnit(PowerUnit.MillijoulePerHour));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Milliwatt, quantity => quantity.ToUnit(PowerUnit.Milliwatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Nanowatt, quantity => quantity.ToUnit(PowerUnit.Nanowatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Petawatt, quantity => quantity.ToUnit(PowerUnit.Petawatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Picowatt, quantity => quantity.ToUnit(PowerUnit.Picowatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.Terawatt, quantity => quantity.ToUnit(PowerUnit.Terawatt));
-            unitConverter.SetConversionFunction<Power>(PowerUnit.Watt, PowerUnit.TonOfRefrigeration, quantity => quantity.ToUnit(PowerUnit.TonOfRefrigeration));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -496,7 +483,7 @@ public static string GetAbbreviation(PowerUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.BoilerHorsepower"/>.
         /// </summary>
-        public static Power FromBoilerHorsepower(double value)
+        public static Power FromBoilerHorsepower(QuantityValue value)
         {
             return new Power(value, PowerUnit.BoilerHorsepower);
         }
@@ -504,7 +491,7 @@ public static Power FromBoilerHorsepower(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.BritishThermalUnitPerHour"/>.
         /// </summary>
-        public static Power FromBritishThermalUnitsPerHour(double value)
+        public static Power FromBritishThermalUnitsPerHour(QuantityValue value)
         {
             return new Power(value, PowerUnit.BritishThermalUnitPerHour);
         }
@@ -512,7 +499,7 @@ public static Power FromBritishThermalUnitsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Decawatt"/>.
         /// </summary>
-        public static Power FromDecawatts(double value)
+        public static Power FromDecawatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Decawatt);
         }
@@ -520,7 +507,7 @@ public static Power FromDecawatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Deciwatt"/>.
         /// </summary>
-        public static Power FromDeciwatts(double value)
+        public static Power FromDeciwatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Deciwatt);
         }
@@ -528,7 +515,7 @@ public static Power FromDeciwatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.ElectricalHorsepower"/>.
         /// </summary>
-        public static Power FromElectricalHorsepower(double value)
+        public static Power FromElectricalHorsepower(QuantityValue value)
         {
             return new Power(value, PowerUnit.ElectricalHorsepower);
         }
@@ -536,7 +523,7 @@ public static Power FromElectricalHorsepower(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Femtowatt"/>.
         /// </summary>
-        public static Power FromFemtowatts(double value)
+        public static Power FromFemtowatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Femtowatt);
         }
@@ -544,7 +531,7 @@ public static Power FromFemtowatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.GigajoulePerHour"/>.
         /// </summary>
-        public static Power FromGigajoulesPerHour(double value)
+        public static Power FromGigajoulesPerHour(QuantityValue value)
         {
             return new Power(value, PowerUnit.GigajoulePerHour);
         }
@@ -552,7 +539,7 @@ public static Power FromGigajoulesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Gigawatt"/>.
         /// </summary>
-        public static Power FromGigawatts(double value)
+        public static Power FromGigawatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Gigawatt);
         }
@@ -560,7 +547,7 @@ public static Power FromGigawatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.HydraulicHorsepower"/>.
         /// </summary>
-        public static Power FromHydraulicHorsepower(double value)
+        public static Power FromHydraulicHorsepower(QuantityValue value)
         {
             return new Power(value, PowerUnit.HydraulicHorsepower);
         }
@@ -568,7 +555,7 @@ public static Power FromHydraulicHorsepower(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.JoulePerHour"/>.
         /// </summary>
-        public static Power FromJoulesPerHour(double value)
+        public static Power FromJoulesPerHour(QuantityValue value)
         {
             return new Power(value, PowerUnit.JoulePerHour);
         }
@@ -576,7 +563,7 @@ public static Power FromJoulesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.KilobritishThermalUnitPerHour"/>.
         /// </summary>
-        public static Power FromKilobritishThermalUnitsPerHour(double value)
+        public static Power FromKilobritishThermalUnitsPerHour(QuantityValue value)
         {
             return new Power(value, PowerUnit.KilobritishThermalUnitPerHour);
         }
@@ -584,7 +571,7 @@ public static Power FromKilobritishThermalUnitsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.KilojoulePerHour"/>.
         /// </summary>
-        public static Power FromKilojoulesPerHour(double value)
+        public static Power FromKilojoulesPerHour(QuantityValue value)
         {
             return new Power(value, PowerUnit.KilojoulePerHour);
         }
@@ -592,7 +579,7 @@ public static Power FromKilojoulesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Kilowatt"/>.
         /// </summary>
-        public static Power FromKilowatts(double value)
+        public static Power FromKilowatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Kilowatt);
         }
@@ -600,7 +587,7 @@ public static Power FromKilowatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MechanicalHorsepower"/>.
         /// </summary>
-        public static Power FromMechanicalHorsepower(double value)
+        public static Power FromMechanicalHorsepower(QuantityValue value)
         {
             return new Power(value, PowerUnit.MechanicalHorsepower);
         }
@@ -608,7 +595,7 @@ public static Power FromMechanicalHorsepower(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MegabritishThermalUnitPerHour"/>.
         /// </summary>
-        public static Power FromMegabritishThermalUnitsPerHour(double value)
+        public static Power FromMegabritishThermalUnitsPerHour(QuantityValue value)
         {
             return new Power(value, PowerUnit.MegabritishThermalUnitPerHour);
         }
@@ -616,7 +603,7 @@ public static Power FromMegabritishThermalUnitsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MegajoulePerHour"/>.
         /// </summary>
-        public static Power FromMegajoulesPerHour(double value)
+        public static Power FromMegajoulesPerHour(QuantityValue value)
         {
             return new Power(value, PowerUnit.MegajoulePerHour);
         }
@@ -624,7 +611,7 @@ public static Power FromMegajoulesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Megawatt"/>.
         /// </summary>
-        public static Power FromMegawatts(double value)
+        public static Power FromMegawatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Megawatt);
         }
@@ -632,7 +619,7 @@ public static Power FromMegawatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MetricHorsepower"/>.
         /// </summary>
-        public static Power FromMetricHorsepower(double value)
+        public static Power FromMetricHorsepower(QuantityValue value)
         {
             return new Power(value, PowerUnit.MetricHorsepower);
         }
@@ -640,7 +627,7 @@ public static Power FromMetricHorsepower(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Microwatt"/>.
         /// </summary>
-        public static Power FromMicrowatts(double value)
+        public static Power FromMicrowatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Microwatt);
         }
@@ -648,7 +635,7 @@ public static Power FromMicrowatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MillijoulePerHour"/>.
         /// </summary>
-        public static Power FromMillijoulesPerHour(double value)
+        public static Power FromMillijoulesPerHour(QuantityValue value)
         {
             return new Power(value, PowerUnit.MillijoulePerHour);
         }
@@ -656,7 +643,7 @@ public static Power FromMillijoulesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Milliwatt"/>.
         /// </summary>
-        public static Power FromMilliwatts(double value)
+        public static Power FromMilliwatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Milliwatt);
         }
@@ -664,7 +651,7 @@ public static Power FromMilliwatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Nanowatt"/>.
         /// </summary>
-        public static Power FromNanowatts(double value)
+        public static Power FromNanowatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Nanowatt);
         }
@@ -672,7 +659,7 @@ public static Power FromNanowatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Petawatt"/>.
         /// </summary>
-        public static Power FromPetawatts(double value)
+        public static Power FromPetawatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Petawatt);
         }
@@ -680,7 +667,7 @@ public static Power FromPetawatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Picowatt"/>.
         /// </summary>
-        public static Power FromPicowatts(double value)
+        public static Power FromPicowatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Picowatt);
         }
@@ -688,7 +675,7 @@ public static Power FromPicowatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Terawatt"/>.
         /// </summary>
-        public static Power FromTerawatts(double value)
+        public static Power FromTerawatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Terawatt);
         }
@@ -696,7 +683,7 @@ public static Power FromTerawatts(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.TonOfRefrigeration"/>.
         /// </summary>
-        public static Power FromTonsOfRefrigeration(double value)
+        public static Power FromTonsOfRefrigeration(QuantityValue value)
         {
             return new Power(value, PowerUnit.TonOfRefrigeration);
         }
@@ -704,7 +691,7 @@ public static Power FromTonsOfRefrigeration(double value)
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Watt"/>.
         /// </summary>
-        public static Power FromWatts(double value)
+        public static Power FromWatts(QuantityValue value)
         {
             return new Power(value, PowerUnit.Watt);
         }
@@ -715,7 +702,7 @@ public static Power FromWatts(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Power unit value.</returns>
-        public static Power From(double value, PowerUnit fromUnit)
+        public static Power From(QuantityValue value, PowerUnit fromUnit)
         {
             return new Power(value, fromUnit);
         }
@@ -776,10 +763,7 @@ public static Power Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Power Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Power, PowerUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Power, PowerUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -807,11 +791,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Power result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Power result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Power, PowerUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Power, PowerUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -832,7 +812,7 @@ public static PowerUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -843,7 +823,7 @@ public static PowerUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PowerUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.PowerUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out PowerUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -858,7 +838,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PowerUnit un
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out PowerUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -877,35 +857,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Power"/> from adding two <see cref="Power"/>.</summary>
         public static Power operator +(Power left, Power right)
         {
-            return new Power(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Power(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Power"/> from subtracting two <see cref="Power"/>.</summary>
         public static Power operator -(Power left, Power right)
         {
-            return new Power(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Power(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Power"/> from multiplying value and <see cref="Power"/>.</summary>
-        public static Power operator *(double left, Power right)
+        public static Power operator *(QuantityValue left, Power right)
         {
             return new Power(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Power"/> from multiplying value and <see cref="Power"/>.</summary>
-        public static Power operator *(Power left, double right)
+        public static Power operator *(Power left, QuantityValue right)
         {
             return new Power(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Power"/> from dividing <see cref="Power"/> by value.</summary>
-        public static Power operator /(Power left, double right)
+        public static Power operator /(Power left, QuantityValue right)
         {
             return new Power(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Power"/> by <see cref="Power"/>.</summary>
-        public static double operator /(Power left, Power right)
+        public static QuantityValue operator /(Power left, Power right)
         {
             return left.Watts / right.Watts;
         }
@@ -962,6 +942,18 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return HeatFlux.FromWattsPerSquareMeter(power.Watts / area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="Length"/> from <see cref="Power"/> / <see cref="LinearPowerDensity"/>.</summary>
+        public static Length operator /(Power power, LinearPowerDensity linearPowerDensity)
+        {
+            return Length.FromMeters(power.Watts / linearPowerDensity.WattsPerMeter);
+        }
+
+        /// <summary>Get <see cref="LinearPowerDensity"/> from <see cref="Power"/> / <see cref="Length"/>.</summary>
+        public static LinearPowerDensity operator /(Power power, Length length)
+        {
+            return LinearPowerDensity.FromWattsPerMeter(power.Watts / length.Meters);
+        }
+
         /// <summary>Get <see cref="MassFlow"/> from <see cref="Power"/> * <see cref="BrakeSpecificFuelConsumption"/>.</summary>
         public static MassFlow operator *(Power power, BrakeSpecificFuelConsumption brakeSpecificFuelConsumption)
         {
@@ -974,6 +966,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return MassFlow.FromKilogramsPerSecond(power.Watts / specificEnergy.JoulesPerKilogram);
         }
 
+        /// <summary>Get <see cref="PowerDensity"/> from <see cref="Power"/> / <see cref="Volume"/>.</summary>
+        public static PowerDensity operator /(Power power, Volume volume)
+        {
+            return PowerDensity.FromWattsPerCubicMeter(power.Watts / volume.CubicMeters);
+        }
+
         /// <summary>Get <see cref="RotationalSpeed"/> from <see cref="Power"/> / <see cref="Torque"/>.</summary>
         public static RotationalSpeed operator /(Power power, Torque torque)
         {
@@ -992,12 +990,24 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Speed.FromMetersPerSecond(power.Watts / force.Newtons);
         }
 
+        /// <summary>Get <see cref="TemperatureDelta"/> from <see cref="Power"/> * <see cref="ThermalResistance"/>.</summary>
+        public static TemperatureDelta operator *(Power power, ThermalResistance thermalResistance)
+        {
+            return TemperatureDelta.FromKelvins(power.Watts * thermalResistance.KelvinsPerWatt);
+        }
+
         /// <summary>Get <see cref="Torque"/> from <see cref="Power"/> / <see cref="RotationalSpeed"/>.</summary>
         public static Torque operator /(Power power, RotationalSpeed rotationalSpeed)
         {
             return Torque.FromNewtonMeters(power.Watts / rotationalSpeed.RadiansPerSecond);
         }
 
+        /// <summary>Get <see cref="Volume"/> from <see cref="Power"/> / <see cref="PowerDensity"/>.</summary>
+        public static Volume operator /(Power power, PowerDensity powerDensity)
+        {
+            return Volume.FromCubicMeters(power.Watts / powerDensity.WattsPerCubicMeter);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -1005,97 +1015,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Power left, Power right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Power left, Power right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Power left, Power right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Power left, Power right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Power"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Power other, Power tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Power"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Power)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Power left, Power right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Power"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Power other, Power tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Power"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Power,Power)"/>.
+        ///     See that operator (and <see cref="Equals(Power)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Power left, Power right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Power"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Power other, Power tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Power"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Power"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Power"/>, this method delegates to
+        ///     <see cref="Equals(Power)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Power otherQuantity))
+            if (obj is not Power otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Power"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Power other, Power tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Power"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Power other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Power.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Power), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Power"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Power)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Power otherQuantity)) throw new ArgumentException("Expected type Power.", nameof(obj));
+            if (obj is not Power otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Power>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Power"/> with another <see cref="Power"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Power"/> with another <see cref="Power"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1107,181 +1131,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Power other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(PowerUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<PowerUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Power to another Power with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Power with the specified unit.</returns>
-        public Power ToUnit(PowerUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Power"/> to another <see cref="Power"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Power with the specified unit.</returns>
-        public Power ToUnit(PowerUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Power), Unit, typeof(Power), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Power)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Power"/> to another <see cref="Power"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Power"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(PowerUnit unit, [NotNullWhen(true)] out Power? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Power? convertedOrNull = (Unit, unit) switch
-            {
-                // PowerUnit -> BaseUnit
-                (PowerUnit.BoilerHorsepower, PowerUnit.Watt) => new Power(_value * 9812.5, PowerUnit.Watt),
-                (PowerUnit.BritishThermalUnitPerHour, PowerUnit.Watt) => new Power(_value * 1055.05585262 / 3600, PowerUnit.Watt),
-                (PowerUnit.Decawatt, PowerUnit.Watt) => new Power((_value) * 1e1d, PowerUnit.Watt),
-                (PowerUnit.Deciwatt, PowerUnit.Watt) => new Power((_value) * 1e-1d, PowerUnit.Watt),
-                (PowerUnit.ElectricalHorsepower, PowerUnit.Watt) => new Power(_value * 746, PowerUnit.Watt),
-                (PowerUnit.Femtowatt, PowerUnit.Watt) => new Power((_value) * 1e-15d, PowerUnit.Watt),
-                (PowerUnit.GigajoulePerHour, PowerUnit.Watt) => new Power((_value / 3600) * 1e9d, PowerUnit.Watt),
-                (PowerUnit.Gigawatt, PowerUnit.Watt) => new Power((_value) * 1e9d, PowerUnit.Watt),
-                (PowerUnit.HydraulicHorsepower, PowerUnit.Watt) => new Power(_value * 745.69987158227022, PowerUnit.Watt),
-                (PowerUnit.JoulePerHour, PowerUnit.Watt) => new Power(_value / 3600, PowerUnit.Watt),
-                (PowerUnit.KilobritishThermalUnitPerHour, PowerUnit.Watt) => new Power((_value * 1055.05585262 / 3600) * 1e3d, PowerUnit.Watt),
-                (PowerUnit.KilojoulePerHour, PowerUnit.Watt) => new Power((_value / 3600) * 1e3d, PowerUnit.Watt),
-                (PowerUnit.Kilowatt, PowerUnit.Watt) => new Power((_value) * 1e3d, PowerUnit.Watt),
-                (PowerUnit.MechanicalHorsepower, PowerUnit.Watt) => new Power(_value * 76.0402249 * 9.80665, PowerUnit.Watt),
-                (PowerUnit.MegabritishThermalUnitPerHour, PowerUnit.Watt) => new Power((_value * 1055.05585262 / 3600) * 1e6d, PowerUnit.Watt),
-                (PowerUnit.MegajoulePerHour, PowerUnit.Watt) => new Power((_value / 3600) * 1e6d, PowerUnit.Watt),
-                (PowerUnit.Megawatt, PowerUnit.Watt) => new Power((_value) * 1e6d, PowerUnit.Watt),
-                (PowerUnit.MetricHorsepower, PowerUnit.Watt) => new Power(_value * 75 * 9.80665, PowerUnit.Watt),
-                (PowerUnit.Microwatt, PowerUnit.Watt) => new Power((_value) * 1e-6d, PowerUnit.Watt),
-                (PowerUnit.MillijoulePerHour, PowerUnit.Watt) => new Power((_value / 3600) * 1e-3d, PowerUnit.Watt),
-                (PowerUnit.Milliwatt, PowerUnit.Watt) => new Power((_value) * 1e-3d, PowerUnit.Watt),
-                (PowerUnit.Nanowatt, PowerUnit.Watt) => new Power((_value) * 1e-9d, PowerUnit.Watt),
-                (PowerUnit.Petawatt, PowerUnit.Watt) => new Power((_value) * 1e15d, PowerUnit.Watt),
-                (PowerUnit.Picowatt, PowerUnit.Watt) => new Power((_value) * 1e-12d, PowerUnit.Watt),
-                (PowerUnit.Terawatt, PowerUnit.Watt) => new Power((_value) * 1e12d, PowerUnit.Watt),
-                (PowerUnit.TonOfRefrigeration, PowerUnit.Watt) => new Power(_value * 3516.853, PowerUnit.Watt),
-
-                // BaseUnit -> PowerUnit
-                (PowerUnit.Watt, PowerUnit.BoilerHorsepower) => new Power(_value / 9812.5, PowerUnit.BoilerHorsepower),
-                (PowerUnit.Watt, PowerUnit.BritishThermalUnitPerHour) => new Power(_value * 3600 / 1055.05585262, PowerUnit.BritishThermalUnitPerHour),
-                (PowerUnit.Watt, PowerUnit.Decawatt) => new Power((_value) / 1e1d, PowerUnit.Decawatt),
-                (PowerUnit.Watt, PowerUnit.Deciwatt) => new Power((_value) / 1e-1d, PowerUnit.Deciwatt),
-                (PowerUnit.Watt, PowerUnit.ElectricalHorsepower) => new Power(_value / 746, PowerUnit.ElectricalHorsepower),
-                (PowerUnit.Watt, PowerUnit.Femtowatt) => new Power((_value) / 1e-15d, PowerUnit.Femtowatt),
-                (PowerUnit.Watt, PowerUnit.GigajoulePerHour) => new Power((_value * 3600) / 1e9d, PowerUnit.GigajoulePerHour),
-                (PowerUnit.Watt, PowerUnit.Gigawatt) => new Power((_value) / 1e9d, PowerUnit.Gigawatt),
-                (PowerUnit.Watt, PowerUnit.HydraulicHorsepower) => new Power(_value / 745.69987158227022, PowerUnit.HydraulicHorsepower),
-                (PowerUnit.Watt, PowerUnit.JoulePerHour) => new Power(_value * 3600, PowerUnit.JoulePerHour),
-                (PowerUnit.Watt, PowerUnit.KilobritishThermalUnitPerHour) => new Power((_value * 3600 / 1055.05585262) / 1e3d, PowerUnit.KilobritishThermalUnitPerHour),
-                (PowerUnit.Watt, PowerUnit.KilojoulePerHour) => new Power((_value * 3600) / 1e3d, PowerUnit.KilojoulePerHour),
-                (PowerUnit.Watt, PowerUnit.Kilowatt) => new Power((_value) / 1e3d, PowerUnit.Kilowatt),
-                (PowerUnit.Watt, PowerUnit.MechanicalHorsepower) => new Power(_value / (76.0402249 * 9.80665), PowerUnit.MechanicalHorsepower),
-                (PowerUnit.Watt, PowerUnit.MegabritishThermalUnitPerHour) => new Power((_value * 3600 / 1055.05585262) / 1e6d, PowerUnit.MegabritishThermalUnitPerHour),
-                (PowerUnit.Watt, PowerUnit.MegajoulePerHour) => new Power((_value * 3600) / 1e6d, PowerUnit.MegajoulePerHour),
-                (PowerUnit.Watt, PowerUnit.Megawatt) => new Power((_value) / 1e6d, PowerUnit.Megawatt),
-                (PowerUnit.Watt, PowerUnit.MetricHorsepower) => new Power(_value / (75 * 9.80665), PowerUnit.MetricHorsepower),
-                (PowerUnit.Watt, PowerUnit.Microwatt) => new Power((_value) / 1e-6d, PowerUnit.Microwatt),
-                (PowerUnit.Watt, PowerUnit.MillijoulePerHour) => new Power((_value * 3600) / 1e-3d, PowerUnit.MillijoulePerHour),
-                (PowerUnit.Watt, PowerUnit.Milliwatt) => new Power((_value) / 1e-3d, PowerUnit.Milliwatt),
-                (PowerUnit.Watt, PowerUnit.Nanowatt) => new Power((_value) / 1e-9d, PowerUnit.Nanowatt),
-                (PowerUnit.Watt, PowerUnit.Petawatt) => new Power((_value) / 1e15d, PowerUnit.Petawatt),
-                (PowerUnit.Watt, PowerUnit.Picowatt) => new Power((_value) / 1e-12d, PowerUnit.Picowatt),
-                (PowerUnit.Watt, PowerUnit.Terawatt) => new Power((_value) / 1e12d, PowerUnit.Terawatt),
-                (PowerUnit.Watt, PowerUnit.TonOfRefrigeration) => new Power(_value / 3516.853, PowerUnit.TonOfRefrigeration),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not PowerUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is PowerUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<PowerUnit> IQuantity<PowerUnit>.ToUnit(PowerUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1295,11 +1147,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
index 24c67a9352..1fc413a36c 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     The amount of power in a volume.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct PowerDensity :
-        IArithmeticQuantity<PowerDensity, PowerDensityUnit>,
+        ILinearQuantity<PowerDensity, PowerDensityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<PowerDensity, PowerDensity, double>,
+        IDivisionOperators<PowerDensity, PowerDensity, QuantityValue>,
+        IMultiplyOperators<PowerDensity, Volume, Power>,
         IComparisonOperators<PowerDensity, PowerDensity, bool>,
         IParsable<PowerDensity>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static PowerDensityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Pow
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="PowerDensity"/> is [T^-3][L^-1][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="PowerDensity"/> is T^-3L^-1M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 1, -3, 0, 0, 0, 0);
 
@@ -117,58 +117,148 @@ public static PowerDensityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Pow
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{PowerDensityUnit}"/> representing the default unit mappings for PowerDensity.</returns>
             public static IEnumerable<UnitDefinition<PowerDensityUnit>> GetDefaultMappings()
             {
-                yield return new (PowerDensityUnit.DecawattPerCubicFoot, "DecawattPerCubicFoot", "DecawattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.DecawattPerCubicInch, "DecawattPerCubicInch", "DecawattsPerCubicInch", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.DecawattPerCubicMeter, "DecawattPerCubicMeter", "DecawattsPerCubicMeter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.DecawattPerLiter, "DecawattPerLiter", "DecawattsPerLiter", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.DeciwattPerCubicFoot, "DeciwattPerCubicFoot", "DeciwattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.DeciwattPerCubicInch, "DeciwattPerCubicInch", "DeciwattsPerCubicInch", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.DeciwattPerCubicMeter, "DeciwattPerCubicMeter", "DeciwattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Hectogram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.DeciwattPerLiter, "DeciwattPerLiter", "DeciwattsPerLiter", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.GigawattPerCubicFoot, "GigawattPerCubicFoot", "GigawattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.GigawattPerCubicInch, "GigawattPerCubicInch", "GigawattsPerCubicInch", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.GigawattPerCubicMeter, "GigawattPerCubicMeter", "GigawattsPerCubicMeter", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.GigawattPerLiter, "GigawattPerLiter", "GigawattsPerLiter", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.KilowattPerCubicFoot, "KilowattPerCubicFoot", "KilowattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.KilowattPerCubicInch, "KilowattPerCubicInch", "KilowattsPerCubicInch", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.KilowattPerCubicMeter, "KilowattPerCubicMeter", "KilowattsPerCubicMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.KilowattPerLiter, "KilowattPerLiter", "KilowattsPerLiter", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.MegawattPerCubicFoot, "MegawattPerCubicFoot", "MegawattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.MegawattPerCubicInch, "MegawattPerCubicInch", "MegawattsPerCubicInch", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.MegawattPerCubicMeter, "MegawattPerCubicMeter", "MegawattsPerCubicMeter", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.MegawattPerLiter, "MegawattPerLiter", "MegawattsPerLiter", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.MicrowattPerCubicFoot, "MicrowattPerCubicFoot", "MicrowattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.MicrowattPerCubicInch, "MicrowattPerCubicInch", "MicrowattsPerCubicInch", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.MicrowattPerCubicMeter, "MicrowattPerCubicMeter", "MicrowattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.MicrowattPerLiter, "MicrowattPerLiter", "MicrowattsPerLiter", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.MilliwattPerCubicFoot, "MilliwattPerCubicFoot", "MilliwattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.MilliwattPerCubicInch, "MilliwattPerCubicInch", "MilliwattsPerCubicInch", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.MilliwattPerCubicMeter, "MilliwattPerCubicMeter", "MilliwattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.MilliwattPerLiter, "MilliwattPerLiter", "MilliwattsPerLiter", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.NanowattPerCubicFoot, "NanowattPerCubicFoot", "NanowattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.NanowattPerCubicInch, "NanowattPerCubicInch", "NanowattsPerCubicInch", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.NanowattPerCubicMeter, "NanowattPerCubicMeter", "NanowattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.NanowattPerLiter, "NanowattPerLiter", "NanowattsPerLiter", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.PicowattPerCubicFoot, "PicowattPerCubicFoot", "PicowattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.PicowattPerCubicInch, "PicowattPerCubicInch", "PicowattsPerCubicInch", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.PicowattPerCubicMeter, "PicowattPerCubicMeter", "PicowattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.PicowattPerLiter, "PicowattPerLiter", "PicowattsPerLiter", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.TerawattPerCubicFoot, "TerawattPerCubicFoot", "TerawattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.TerawattPerCubicInch, "TerawattPerCubicInch", "TerawattsPerCubicInch", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.TerawattPerCubicMeter, "TerawattPerCubicMeter", "TerawattsPerCubicMeter", new BaseUnits(length: LengthUnit.Picometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.TerawattPerLiter, "TerawattPerLiter", "TerawattsPerLiter", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.WattPerCubicFoot, "WattPerCubicFoot", "WattsPerCubicFoot", BaseUnits.Undefined);
-                yield return new (PowerDensityUnit.WattPerCubicInch, "WattPerCubicInch", "WattsPerCubicInch", BaseUnits.Undefined);
+                yield return new (PowerDensityUnit.BtuPerSecondCubicFoot, "BtuPerSecondCubicFoot", "BtusPerSecondCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(884901456, 32970495394375)
+                );
+                yield return new (PowerDensityUnit.BtuPerSecondCubicInch, "BtuPerSecondCubicInch", "BtusPerSecondCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, 131881981577500)
+                );
+                yield return new (PowerDensityUnit.DecawattPerCubicFoot, "DecawattPerCubicFoot", "DecawattsPerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(55306341, 19531250000)
+                );
+                yield return new (PowerDensityUnit.DecawattPerCubicInch, "DecawattPerCubicInch", "DecawattsPerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, 1250000000000)
+                );
+                yield return new (PowerDensityUnit.DecawattPerCubicMeter, "DecawattPerCubicMeter", "DecawattsPerCubicMeter", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (PowerDensityUnit.DecawattPerLiter, "DecawattPerLiter", "DecawattsPerLiter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (PowerDensityUnit.DeciwattPerCubicFoot, "DeciwattPerCubicFoot", "DeciwattsPerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(55306341, 195312500)
+                );
+                yield return new (PowerDensityUnit.DeciwattPerCubicInch, "DeciwattPerCubicInch", "DeciwattsPerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, 12500000000)
+                );
+                yield return new (PowerDensityUnit.DeciwattPerCubicMeter, "DeciwattPerCubicMeter", "DeciwattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Hectogram, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (PowerDensityUnit.DeciwattPerLiter, "DeciwattPerLiter", "DeciwattsPerLiter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100)
+                );
+                yield return new (PowerDensityUnit.GigawattPerCubicFoot, "GigawattPerCubicFoot", "GigawattsPerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(55306341, 1953125000000000000)
+                );
+                yield return new (PowerDensityUnit.GigawattPerCubicInch, "GigawattPerCubicInch", "GigawattsPerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, new BigInteger(125) * QuantityValue.PowerOfTen(18))
+                );
+                yield return new (PowerDensityUnit.GigawattPerCubicMeter, "GigawattPerCubicMeter", "GigawattsPerCubicMeter", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (PowerDensityUnit.GigawattPerLiter, "GigawattPerLiter", "GigawattsPerLiter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (PowerDensityUnit.KilowattPerCubicFoot, "KilowattPerCubicFoot", "KilowattsPerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(55306341, 1953125000000)
+                );
+                yield return new (PowerDensityUnit.KilowattPerCubicInch, "KilowattPerCubicInch", "KilowattsPerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, 125000000000000)
+                );
+                yield return new (PowerDensityUnit.KilowattPerCubicMeter, "KilowattPerCubicMeter", "KilowattsPerCubicMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (PowerDensityUnit.KilowattPerLiter, "KilowattPerLiter", "KilowattsPerLiter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (PowerDensityUnit.MegawattPerCubicFoot, "MegawattPerCubicFoot", "MegawattsPerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(55306341, 1953125000000000)
+                );
+                yield return new (PowerDensityUnit.MegawattPerCubicInch, "MegawattPerCubicInch", "MegawattsPerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, 125000000000000000)
+                );
+                yield return new (PowerDensityUnit.MegawattPerCubicMeter, "MegawattPerCubicMeter", "MegawattsPerCubicMeter", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (PowerDensityUnit.MegawattPerLiter, "MegawattPerLiter", "MegawattsPerLiter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (PowerDensityUnit.MicrowattPerCubicFoot, "MicrowattPerCubicFoot", "MicrowattsPerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(442450728, 15625)
+                );
+                yield return new (PowerDensityUnit.MicrowattPerCubicInch, "MicrowattPerCubicInch", "MicrowattsPerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, 125000)
+                );
+                yield return new (PowerDensityUnit.MicrowattPerCubicMeter, "MicrowattPerCubicMeter", "MicrowattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (PowerDensityUnit.MicrowattPerLiter, "MicrowattPerLiter", "MicrowattsPerLiter", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (PowerDensityUnit.MilliwattPerCubicFoot, "MilliwattPerCubicFoot", "MilliwattsPerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(55306341, 1953125)
+                );
+                yield return new (PowerDensityUnit.MilliwattPerCubicInch, "MilliwattPerCubicInch", "MilliwattsPerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, 125000000)
+                );
+                yield return new (PowerDensityUnit.MilliwattPerCubicMeter, "MilliwattPerCubicMeter", "MilliwattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (PowerDensityUnit.MilliwattPerLiter, "MilliwattPerLiter", "MilliwattsPerLiter", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (PowerDensityUnit.NanowattPerCubicFoot, "NanowattPerCubicFoot", "NanowattsPerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(3539605824, 125)
+                );
+                yield return new (PowerDensityUnit.NanowattPerCubicInch, "NanowattPerCubicInch", "NanowattsPerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, 125)
+                );
+                yield return new (PowerDensityUnit.NanowattPerCubicMeter, "NanowattPerCubicMeter", "NanowattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (PowerDensityUnit.NanowattPerLiter, "NanowattPerLiter", "NanowattsPerLiter", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (PowerDensityUnit.PicowattPerCubicFoot, "PicowattPerCubicFoot", "PicowattsPerCubicFoot", BaseUnits.Undefined,
+                     28316846592
+                );
+                yield return new (PowerDensityUnit.PicowattPerCubicInch, "PicowattPerCubicInch", "PicowattsPerCubicInch", BaseUnits.Undefined,
+                     16387064
+                );
+                yield return new (PowerDensityUnit.PicowattPerCubicMeter, "PicowattPerCubicMeter", "PicowattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second),
+                     1000000000000
+                );
+                yield return new (PowerDensityUnit.PicowattPerLiter, "PicowattPerLiter", "PicowattsPerLiter", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (PowerDensityUnit.TerawattPerCubicFoot, "TerawattPerCubicFoot", "TerawattsPerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(55306341, new BigInteger(1953125) * QuantityValue.PowerOfTen(15))
+                );
+                yield return new (PowerDensityUnit.TerawattPerCubicInch, "TerawattPerCubicInch", "TerawattsPerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, new BigInteger(125) * QuantityValue.PowerOfTen(21))
+                );
+                yield return new (PowerDensityUnit.TerawattPerCubicMeter, "TerawattPerCubicMeter", "TerawattsPerCubicMeter", new BaseUnits(length: LengthUnit.Picometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (PowerDensityUnit.TerawattPerLiter, "TerawattPerLiter", "TerawattsPerLiter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000)
+                );
+                yield return new (PowerDensityUnit.WattPerCubicFoot, "WattPerCubicFoot", "WattsPerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(55306341, 1953125000)
+                );
+                yield return new (PowerDensityUnit.WattPerCubicInch, "WattPerCubicInch", "WattsPerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(2048383, 125000000000)
+                );
                 yield return new (PowerDensityUnit.WattPerCubicMeter, "WattPerCubicMeter", "WattsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PowerDensityUnit.WattPerLiter, "WattPerLiter", "WattsPerLiter", BaseUnits.Undefined);
+                yield return new (PowerDensityUnit.WattPerLiter, "WattPerLiter", "WattsPerLiter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
             }
         }
 
         static PowerDensity()
         {
-            Info = PowerDensityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(PowerDensityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -176,7 +266,7 @@ static PowerDensity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public PowerDensity(double value, PowerDensityUnit unit)
+        public PowerDensity(QuantityValue value, PowerDensityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -190,7 +280,7 @@ public PowerDensity(double value, PowerDensityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public PowerDensity(double value, UnitSystem unitSystem)
+        public PowerDensity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -201,7 +291,8 @@ public PowerDensity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="PowerDensity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<PowerDensity, PowerDensityUnit> Info { get; }
@@ -230,10 +321,8 @@ public PowerDensity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public PowerDensityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -267,329 +356,239 @@ public PowerDensity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.BtuPerSecondCubicFoot"/>
+        /// </summary>
+        public QuantityValue BtusPerSecondCubicFoot => this.As(PowerDensityUnit.BtuPerSecondCubicFoot);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.BtuPerSecondCubicInch"/>
+        /// </summary>
+        public QuantityValue BtusPerSecondCubicInch => this.As(PowerDensityUnit.BtuPerSecondCubicInch);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerCubicFoot"/>
         /// </summary>
-        public double DecawattsPerCubicFoot => As(PowerDensityUnit.DecawattPerCubicFoot);
+        public QuantityValue DecawattsPerCubicFoot => this.As(PowerDensityUnit.DecawattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerCubicInch"/>
         /// </summary>
-        public double DecawattsPerCubicInch => As(PowerDensityUnit.DecawattPerCubicInch);
+        public QuantityValue DecawattsPerCubicInch => this.As(PowerDensityUnit.DecawattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerCubicMeter"/>
         /// </summary>
-        public double DecawattsPerCubicMeter => As(PowerDensityUnit.DecawattPerCubicMeter);
+        public QuantityValue DecawattsPerCubicMeter => this.As(PowerDensityUnit.DecawattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.DecawattPerLiter"/>
         /// </summary>
-        public double DecawattsPerLiter => As(PowerDensityUnit.DecawattPerLiter);
+        public QuantityValue DecawattsPerLiter => this.As(PowerDensityUnit.DecawattPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerCubicFoot"/>
         /// </summary>
-        public double DeciwattsPerCubicFoot => As(PowerDensityUnit.DeciwattPerCubicFoot);
+        public QuantityValue DeciwattsPerCubicFoot => this.As(PowerDensityUnit.DeciwattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerCubicInch"/>
         /// </summary>
-        public double DeciwattsPerCubicInch => As(PowerDensityUnit.DeciwattPerCubicInch);
+        public QuantityValue DeciwattsPerCubicInch => this.As(PowerDensityUnit.DeciwattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerCubicMeter"/>
         /// </summary>
-        public double DeciwattsPerCubicMeter => As(PowerDensityUnit.DeciwattPerCubicMeter);
+        public QuantityValue DeciwattsPerCubicMeter => this.As(PowerDensityUnit.DeciwattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.DeciwattPerLiter"/>
         /// </summary>
-        public double DeciwattsPerLiter => As(PowerDensityUnit.DeciwattPerLiter);
+        public QuantityValue DeciwattsPerLiter => this.As(PowerDensityUnit.DeciwattPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerCubicFoot"/>
         /// </summary>
-        public double GigawattsPerCubicFoot => As(PowerDensityUnit.GigawattPerCubicFoot);
+        public QuantityValue GigawattsPerCubicFoot => this.As(PowerDensityUnit.GigawattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerCubicInch"/>
         /// </summary>
-        public double GigawattsPerCubicInch => As(PowerDensityUnit.GigawattPerCubicInch);
+        public QuantityValue GigawattsPerCubicInch => this.As(PowerDensityUnit.GigawattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerCubicMeter"/>
         /// </summary>
-        public double GigawattsPerCubicMeter => As(PowerDensityUnit.GigawattPerCubicMeter);
+        public QuantityValue GigawattsPerCubicMeter => this.As(PowerDensityUnit.GigawattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.GigawattPerLiter"/>
         /// </summary>
-        public double GigawattsPerLiter => As(PowerDensityUnit.GigawattPerLiter);
+        public QuantityValue GigawattsPerLiter => this.As(PowerDensityUnit.GigawattPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerCubicFoot"/>
         /// </summary>
-        public double KilowattsPerCubicFoot => As(PowerDensityUnit.KilowattPerCubicFoot);
+        public QuantityValue KilowattsPerCubicFoot => this.As(PowerDensityUnit.KilowattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerCubicInch"/>
         /// </summary>
-        public double KilowattsPerCubicInch => As(PowerDensityUnit.KilowattPerCubicInch);
+        public QuantityValue KilowattsPerCubicInch => this.As(PowerDensityUnit.KilowattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerCubicMeter"/>
         /// </summary>
-        public double KilowattsPerCubicMeter => As(PowerDensityUnit.KilowattPerCubicMeter);
+        public QuantityValue KilowattsPerCubicMeter => this.As(PowerDensityUnit.KilowattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.KilowattPerLiter"/>
         /// </summary>
-        public double KilowattsPerLiter => As(PowerDensityUnit.KilowattPerLiter);
+        public QuantityValue KilowattsPerLiter => this.As(PowerDensityUnit.KilowattPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerCubicFoot"/>
         /// </summary>
-        public double MegawattsPerCubicFoot => As(PowerDensityUnit.MegawattPerCubicFoot);
+        public QuantityValue MegawattsPerCubicFoot => this.As(PowerDensityUnit.MegawattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerCubicInch"/>
         /// </summary>
-        public double MegawattsPerCubicInch => As(PowerDensityUnit.MegawattPerCubicInch);
+        public QuantityValue MegawattsPerCubicInch => this.As(PowerDensityUnit.MegawattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerCubicMeter"/>
         /// </summary>
-        public double MegawattsPerCubicMeter => As(PowerDensityUnit.MegawattPerCubicMeter);
+        public QuantityValue MegawattsPerCubicMeter => this.As(PowerDensityUnit.MegawattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MegawattPerLiter"/>
         /// </summary>
-        public double MegawattsPerLiter => As(PowerDensityUnit.MegawattPerLiter);
+        public QuantityValue MegawattsPerLiter => this.As(PowerDensityUnit.MegawattPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerCubicFoot"/>
         /// </summary>
-        public double MicrowattsPerCubicFoot => As(PowerDensityUnit.MicrowattPerCubicFoot);
+        public QuantityValue MicrowattsPerCubicFoot => this.As(PowerDensityUnit.MicrowattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerCubicInch"/>
         /// </summary>
-        public double MicrowattsPerCubicInch => As(PowerDensityUnit.MicrowattPerCubicInch);
+        public QuantityValue MicrowattsPerCubicInch => this.As(PowerDensityUnit.MicrowattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerCubicMeter"/>
         /// </summary>
-        public double MicrowattsPerCubicMeter => As(PowerDensityUnit.MicrowattPerCubicMeter);
+        public QuantityValue MicrowattsPerCubicMeter => this.As(PowerDensityUnit.MicrowattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MicrowattPerLiter"/>
         /// </summary>
-        public double MicrowattsPerLiter => As(PowerDensityUnit.MicrowattPerLiter);
+        public QuantityValue MicrowattsPerLiter => this.As(PowerDensityUnit.MicrowattPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerCubicFoot"/>
         /// </summary>
-        public double MilliwattsPerCubicFoot => As(PowerDensityUnit.MilliwattPerCubicFoot);
+        public QuantityValue MilliwattsPerCubicFoot => this.As(PowerDensityUnit.MilliwattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerCubicInch"/>
         /// </summary>
-        public double MilliwattsPerCubicInch => As(PowerDensityUnit.MilliwattPerCubicInch);
+        public QuantityValue MilliwattsPerCubicInch => this.As(PowerDensityUnit.MilliwattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerCubicMeter"/>
         /// </summary>
-        public double MilliwattsPerCubicMeter => As(PowerDensityUnit.MilliwattPerCubicMeter);
+        public QuantityValue MilliwattsPerCubicMeter => this.As(PowerDensityUnit.MilliwattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.MilliwattPerLiter"/>
         /// </summary>
-        public double MilliwattsPerLiter => As(PowerDensityUnit.MilliwattPerLiter);
+        public QuantityValue MilliwattsPerLiter => this.As(PowerDensityUnit.MilliwattPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerCubicFoot"/>
         /// </summary>
-        public double NanowattsPerCubicFoot => As(PowerDensityUnit.NanowattPerCubicFoot);
+        public QuantityValue NanowattsPerCubicFoot => this.As(PowerDensityUnit.NanowattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerCubicInch"/>
         /// </summary>
-        public double NanowattsPerCubicInch => As(PowerDensityUnit.NanowattPerCubicInch);
+        public QuantityValue NanowattsPerCubicInch => this.As(PowerDensityUnit.NanowattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerCubicMeter"/>
         /// </summary>
-        public double NanowattsPerCubicMeter => As(PowerDensityUnit.NanowattPerCubicMeter);
+        public QuantityValue NanowattsPerCubicMeter => this.As(PowerDensityUnit.NanowattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.NanowattPerLiter"/>
         /// </summary>
-        public double NanowattsPerLiter => As(PowerDensityUnit.NanowattPerLiter);
+        public QuantityValue NanowattsPerLiter => this.As(PowerDensityUnit.NanowattPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerCubicFoot"/>
         /// </summary>
-        public double PicowattsPerCubicFoot => As(PowerDensityUnit.PicowattPerCubicFoot);
+        public QuantityValue PicowattsPerCubicFoot => this.As(PowerDensityUnit.PicowattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerCubicInch"/>
         /// </summary>
-        public double PicowattsPerCubicInch => As(PowerDensityUnit.PicowattPerCubicInch);
+        public QuantityValue PicowattsPerCubicInch => this.As(PowerDensityUnit.PicowattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerCubicMeter"/>
         /// </summary>
-        public double PicowattsPerCubicMeter => As(PowerDensityUnit.PicowattPerCubicMeter);
+        public QuantityValue PicowattsPerCubicMeter => this.As(PowerDensityUnit.PicowattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.PicowattPerLiter"/>
         /// </summary>
-        public double PicowattsPerLiter => As(PowerDensityUnit.PicowattPerLiter);
+        public QuantityValue PicowattsPerLiter => this.As(PowerDensityUnit.PicowattPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerCubicFoot"/>
         /// </summary>
-        public double TerawattsPerCubicFoot => As(PowerDensityUnit.TerawattPerCubicFoot);
+        public QuantityValue TerawattsPerCubicFoot => this.As(PowerDensityUnit.TerawattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerCubicInch"/>
         /// </summary>
-        public double TerawattsPerCubicInch => As(PowerDensityUnit.TerawattPerCubicInch);
+        public QuantityValue TerawattsPerCubicInch => this.As(PowerDensityUnit.TerawattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerCubicMeter"/>
         /// </summary>
-        public double TerawattsPerCubicMeter => As(PowerDensityUnit.TerawattPerCubicMeter);
+        public QuantityValue TerawattsPerCubicMeter => this.As(PowerDensityUnit.TerawattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.TerawattPerLiter"/>
         /// </summary>
-        public double TerawattsPerLiter => As(PowerDensityUnit.TerawattPerLiter);
+        public QuantityValue TerawattsPerLiter => this.As(PowerDensityUnit.TerawattPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerCubicFoot"/>
         /// </summary>
-        public double WattsPerCubicFoot => As(PowerDensityUnit.WattPerCubicFoot);
+        public QuantityValue WattsPerCubicFoot => this.As(PowerDensityUnit.WattPerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerCubicInch"/>
         /// </summary>
-        public double WattsPerCubicInch => As(PowerDensityUnit.WattPerCubicInch);
+        public QuantityValue WattsPerCubicInch => this.As(PowerDensityUnit.WattPerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerCubicMeter"/>
         /// </summary>
-        public double WattsPerCubicMeter => As(PowerDensityUnit.WattPerCubicMeter);
+        public QuantityValue WattsPerCubicMeter => this.As(PowerDensityUnit.WattPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerDensityUnit.WattPerLiter"/>
         /// </summary>
-        public double WattsPerLiter => As(PowerDensityUnit.WattPerLiter);
+        public QuantityValue WattsPerLiter => this.As(PowerDensityUnit.WattPerLiter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: PowerDensityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DecawattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DecawattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DecawattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DecawattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DeciwattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DeciwattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DeciwattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.DeciwattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.GigawattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.GigawattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.GigawattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.GigawattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.KilowattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.KilowattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.KilowattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.KilowattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MegawattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MegawattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MegawattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MegawattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MicrowattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MicrowattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MicrowattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MicrowattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MilliwattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MilliwattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MilliwattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.MilliwattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.NanowattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.NanowattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.NanowattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.NanowattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.PicowattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.PicowattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.PicowattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.PicowattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.TerawattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.TerawattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.TerawattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.TerawattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicInch, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerLiter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> PowerDensityUnit
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DecawattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.DecawattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DecawattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.DecawattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DecawattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.DecawattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DecawattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.DecawattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DeciwattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.DeciwattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DeciwattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.DeciwattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DeciwattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.DeciwattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DeciwattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.DeciwattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.GigawattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.GigawattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.GigawattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.GigawattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.GigawattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.GigawattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.GigawattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.GigawattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.KilowattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.KilowattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.KilowattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.KilowattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.KilowattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.KilowattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.KilowattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.KilowattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MegawattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.MegawattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MegawattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.MegawattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MegawattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.MegawattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MegawattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.MegawattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MicrowattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.MicrowattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MicrowattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.MicrowattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MicrowattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.MicrowattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MicrowattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.MicrowattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MilliwattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.MilliwattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MilliwattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.MilliwattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MilliwattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.MilliwattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MilliwattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.MilliwattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.NanowattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.NanowattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.NanowattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.NanowattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.NanowattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.NanowattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.NanowattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.NanowattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.PicowattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.PicowattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.PicowattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.PicowattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.PicowattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.PicowattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.PicowattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.PicowattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.TerawattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.TerawattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.TerawattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.TerawattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.TerawattPerCubicMeter, quantity => quantity.ToUnit(PowerDensityUnit.TerawattPerCubicMeter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.TerawattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.TerawattPerLiter));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.WattPerCubicFoot, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicFoot));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.WattPerCubicInch, quantity => quantity.ToUnit(PowerDensityUnit.WattPerCubicInch));
-            unitConverter.SetConversionFunction<PowerDensity>(PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.WattPerLiter, quantity => quantity.ToUnit(PowerDensityUnit.WattPerLiter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -615,10 +614,26 @@ public static string GetAbbreviation(PowerDensityUnit unit, IFormatProvider? pro
 
         #region Static Factory Methods
 
+        /// <summary>
+        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.BtuPerSecondCubicFoot"/>.
+        /// </summary>
+        public static PowerDensity FromBtusPerSecondCubicFoot(QuantityValue value)
+        {
+            return new PowerDensity(value, PowerDensityUnit.BtuPerSecondCubicFoot);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.BtuPerSecondCubicInch"/>.
+        /// </summary>
+        public static PowerDensity FromBtusPerSecondCubicInch(QuantityValue value)
+        {
+            return new PowerDensity(value, PowerDensityUnit.BtuPerSecondCubicInch);
+        }
+
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromDecawattsPerCubicFoot(double value)
+        public static PowerDensity FromDecawattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicFoot);
         }
@@ -626,7 +641,7 @@ public static PowerDensity FromDecawattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromDecawattsPerCubicInch(double value)
+        public static PowerDensity FromDecawattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicInch);
         }
@@ -634,7 +649,7 @@ public static PowerDensity FromDecawattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromDecawattsPerCubicMeter(double value)
+        public static PowerDensity FromDecawattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicMeter);
         }
@@ -642,7 +657,7 @@ public static PowerDensity FromDecawattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromDecawattsPerLiter(double value)
+        public static PowerDensity FromDecawattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.DecawattPerLiter);
         }
@@ -650,7 +665,7 @@ public static PowerDensity FromDecawattsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromDeciwattsPerCubicFoot(double value)
+        public static PowerDensity FromDeciwattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicFoot);
         }
@@ -658,7 +673,7 @@ public static PowerDensity FromDeciwattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromDeciwattsPerCubicInch(double value)
+        public static PowerDensity FromDeciwattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicInch);
         }
@@ -666,7 +681,7 @@ public static PowerDensity FromDeciwattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromDeciwattsPerCubicMeter(double value)
+        public static PowerDensity FromDeciwattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicMeter);
         }
@@ -674,7 +689,7 @@ public static PowerDensity FromDeciwattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromDeciwattsPerLiter(double value)
+        public static PowerDensity FromDeciwattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.DeciwattPerLiter);
         }
@@ -682,7 +697,7 @@ public static PowerDensity FromDeciwattsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromGigawattsPerCubicFoot(double value)
+        public static PowerDensity FromGigawattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicFoot);
         }
@@ -690,7 +705,7 @@ public static PowerDensity FromGigawattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromGigawattsPerCubicInch(double value)
+        public static PowerDensity FromGigawattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicInch);
         }
@@ -698,7 +713,7 @@ public static PowerDensity FromGigawattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromGigawattsPerCubicMeter(double value)
+        public static PowerDensity FromGigawattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicMeter);
         }
@@ -706,7 +721,7 @@ public static PowerDensity FromGigawattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromGigawattsPerLiter(double value)
+        public static PowerDensity FromGigawattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.GigawattPerLiter);
         }
@@ -714,7 +729,7 @@ public static PowerDensity FromGigawattsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromKilowattsPerCubicFoot(double value)
+        public static PowerDensity FromKilowattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicFoot);
         }
@@ -722,7 +737,7 @@ public static PowerDensity FromKilowattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromKilowattsPerCubicInch(double value)
+        public static PowerDensity FromKilowattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicInch);
         }
@@ -730,7 +745,7 @@ public static PowerDensity FromKilowattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromKilowattsPerCubicMeter(double value)
+        public static PowerDensity FromKilowattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicMeter);
         }
@@ -738,7 +753,7 @@ public static PowerDensity FromKilowattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromKilowattsPerLiter(double value)
+        public static PowerDensity FromKilowattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.KilowattPerLiter);
         }
@@ -746,7 +761,7 @@ public static PowerDensity FromKilowattsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromMegawattsPerCubicFoot(double value)
+        public static PowerDensity FromMegawattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicFoot);
         }
@@ -754,7 +769,7 @@ public static PowerDensity FromMegawattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromMegawattsPerCubicInch(double value)
+        public static PowerDensity FromMegawattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicInch);
         }
@@ -762,7 +777,7 @@ public static PowerDensity FromMegawattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromMegawattsPerCubicMeter(double value)
+        public static PowerDensity FromMegawattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicMeter);
         }
@@ -770,7 +785,7 @@ public static PowerDensity FromMegawattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromMegawattsPerLiter(double value)
+        public static PowerDensity FromMegawattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MegawattPerLiter);
         }
@@ -778,7 +793,7 @@ public static PowerDensity FromMegawattsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromMicrowattsPerCubicFoot(double value)
+        public static PowerDensity FromMicrowattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicFoot);
         }
@@ -786,7 +801,7 @@ public static PowerDensity FromMicrowattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromMicrowattsPerCubicInch(double value)
+        public static PowerDensity FromMicrowattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicInch);
         }
@@ -794,7 +809,7 @@ public static PowerDensity FromMicrowattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromMicrowattsPerCubicMeter(double value)
+        public static PowerDensity FromMicrowattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicMeter);
         }
@@ -802,7 +817,7 @@ public static PowerDensity FromMicrowattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromMicrowattsPerLiter(double value)
+        public static PowerDensity FromMicrowattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MicrowattPerLiter);
         }
@@ -810,7 +825,7 @@ public static PowerDensity FromMicrowattsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromMilliwattsPerCubicFoot(double value)
+        public static PowerDensity FromMilliwattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicFoot);
         }
@@ -818,7 +833,7 @@ public static PowerDensity FromMilliwattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromMilliwattsPerCubicInch(double value)
+        public static PowerDensity FromMilliwattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicInch);
         }
@@ -826,7 +841,7 @@ public static PowerDensity FromMilliwattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromMilliwattsPerCubicMeter(double value)
+        public static PowerDensity FromMilliwattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicMeter);
         }
@@ -834,7 +849,7 @@ public static PowerDensity FromMilliwattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromMilliwattsPerLiter(double value)
+        public static PowerDensity FromMilliwattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.MilliwattPerLiter);
         }
@@ -842,7 +857,7 @@ public static PowerDensity FromMilliwattsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromNanowattsPerCubicFoot(double value)
+        public static PowerDensity FromNanowattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicFoot);
         }
@@ -850,7 +865,7 @@ public static PowerDensity FromNanowattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromNanowattsPerCubicInch(double value)
+        public static PowerDensity FromNanowattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicInch);
         }
@@ -858,7 +873,7 @@ public static PowerDensity FromNanowattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromNanowattsPerCubicMeter(double value)
+        public static PowerDensity FromNanowattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicMeter);
         }
@@ -866,7 +881,7 @@ public static PowerDensity FromNanowattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromNanowattsPerLiter(double value)
+        public static PowerDensity FromNanowattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.NanowattPerLiter);
         }
@@ -874,7 +889,7 @@ public static PowerDensity FromNanowattsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromPicowattsPerCubicFoot(double value)
+        public static PowerDensity FromPicowattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicFoot);
         }
@@ -882,7 +897,7 @@ public static PowerDensity FromPicowattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromPicowattsPerCubicInch(double value)
+        public static PowerDensity FromPicowattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicInch);
         }
@@ -890,7 +905,7 @@ public static PowerDensity FromPicowattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromPicowattsPerCubicMeter(double value)
+        public static PowerDensity FromPicowattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicMeter);
         }
@@ -898,7 +913,7 @@ public static PowerDensity FromPicowattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromPicowattsPerLiter(double value)
+        public static PowerDensity FromPicowattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.PicowattPerLiter);
         }
@@ -906,7 +921,7 @@ public static PowerDensity FromPicowattsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromTerawattsPerCubicFoot(double value)
+        public static PowerDensity FromTerawattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicFoot);
         }
@@ -914,7 +929,7 @@ public static PowerDensity FromTerawattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromTerawattsPerCubicInch(double value)
+        public static PowerDensity FromTerawattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicInch);
         }
@@ -922,7 +937,7 @@ public static PowerDensity FromTerawattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromTerawattsPerCubicMeter(double value)
+        public static PowerDensity FromTerawattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicMeter);
         }
@@ -930,7 +945,7 @@ public static PowerDensity FromTerawattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromTerawattsPerLiter(double value)
+        public static PowerDensity FromTerawattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.TerawattPerLiter);
         }
@@ -938,7 +953,7 @@ public static PowerDensity FromTerawattsPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicFoot"/>.
         /// </summary>
-        public static PowerDensity FromWattsPerCubicFoot(double value)
+        public static PowerDensity FromWattsPerCubicFoot(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.WattPerCubicFoot);
         }
@@ -946,7 +961,7 @@ public static PowerDensity FromWattsPerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicInch"/>.
         /// </summary>
-        public static PowerDensity FromWattsPerCubicInch(double value)
+        public static PowerDensity FromWattsPerCubicInch(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.WattPerCubicInch);
         }
@@ -954,7 +969,7 @@ public static PowerDensity FromWattsPerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicMeter"/>.
         /// </summary>
-        public static PowerDensity FromWattsPerCubicMeter(double value)
+        public static PowerDensity FromWattsPerCubicMeter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.WattPerCubicMeter);
         }
@@ -962,7 +977,7 @@ public static PowerDensity FromWattsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerLiter"/>.
         /// </summary>
-        public static PowerDensity FromWattsPerLiter(double value)
+        public static PowerDensity FromWattsPerLiter(QuantityValue value)
         {
             return new PowerDensity(value, PowerDensityUnit.WattPerLiter);
         }
@@ -973,7 +988,7 @@ public static PowerDensity FromWattsPerLiter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>PowerDensity unit value.</returns>
-        public static PowerDensity From(double value, PowerDensityUnit fromUnit)
+        public static PowerDensity From(QuantityValue value, PowerDensityUnit fromUnit)
         {
             return new PowerDensity(value, fromUnit);
         }
@@ -1034,10 +1049,7 @@ public static PowerDensity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static PowerDensity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<PowerDensity, PowerDensityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<PowerDensity, PowerDensityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -1065,11 +1077,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out PowerDensity res
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out PowerDensity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<PowerDensity, PowerDensityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<PowerDensity, PowerDensityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -1090,7 +1098,7 @@ public static PowerDensityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1101,7 +1109,7 @@ public static PowerDensityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PowerDensityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.PowerDensityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out PowerDensityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1116,7 +1124,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PowerDensity
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out PowerDensityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1135,137 +1143,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="PowerDensity"/> from adding two <see cref="PowerDensity"/>.</summary>
         public static PowerDensity operator +(PowerDensity left, PowerDensity right)
         {
-            return new PowerDensity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new PowerDensity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="PowerDensity"/> from subtracting two <see cref="PowerDensity"/>.</summary>
         public static PowerDensity operator -(PowerDensity left, PowerDensity right)
         {
-            return new PowerDensity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new PowerDensity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="PowerDensity"/> from multiplying value and <see cref="PowerDensity"/>.</summary>
-        public static PowerDensity operator *(double left, PowerDensity right)
+        public static PowerDensity operator *(QuantityValue left, PowerDensity right)
         {
             return new PowerDensity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="PowerDensity"/> from multiplying value and <see cref="PowerDensity"/>.</summary>
-        public static PowerDensity operator *(PowerDensity left, double right)
+        public static PowerDensity operator *(PowerDensity left, QuantityValue right)
         {
             return new PowerDensity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="PowerDensity"/> from dividing <see cref="PowerDensity"/> by value.</summary>
-        public static PowerDensity operator /(PowerDensity left, double right)
+        public static PowerDensity operator /(PowerDensity left, QuantityValue right)
         {
             return new PowerDensity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="PowerDensity"/> by <see cref="PowerDensity"/>.</summary>
-        public static double operator /(PowerDensity left, PowerDensity right)
+        public static QuantityValue operator /(PowerDensity left, PowerDensity right)
         {
             return left.WattsPerCubicMeter / right.WattsPerCubicMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Power"/> from <see cref="PowerDensity"/> * <see cref="Volume"/>.</summary>
+        public static Power operator *(PowerDensity powerDensity, Volume volume)
+        {
+            return Power.FromWatts(powerDensity.WattsPerCubicMeter * volume.CubicMeters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(PowerDensity left, PowerDensity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(PowerDensity left, PowerDensity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(PowerDensity left, PowerDensity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(PowerDensity left, PowerDensity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="PowerDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(PowerDensity other, PowerDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="PowerDensity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(PowerDensity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(PowerDensity left, PowerDensity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="PowerDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(PowerDensity other, PowerDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="PowerDensity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(PowerDensity,PowerDensity)"/>.
+        ///     See that operator (and <see cref="Equals(PowerDensity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(PowerDensity left, PowerDensity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="PowerDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(PowerDensity other, PowerDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="PowerDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="PowerDensity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="PowerDensity"/>, this method delegates to
+        ///     <see cref="Equals(PowerDensity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is PowerDensity otherQuantity))
+            if (obj is not PowerDensity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="PowerDensity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(PowerDensity other, PowerDensity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="PowerDensity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(PowerDensity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current PowerDensity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(PowerDensity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="PowerDensity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(PowerDensity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is PowerDensity otherQuantity)) throw new ArgumentException("Expected type PowerDensity.", nameof(obj));
+            if (obj is not PowerDensity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<PowerDensity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="PowerDensity"/> with another <see cref="PowerDensity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="PowerDensity"/> with another <see cref="PowerDensity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1277,215 +1309,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(PowerDensity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(PowerDensityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<PowerDensityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this PowerDensity to another PowerDensity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A PowerDensity with the specified unit.</returns>
-        public PowerDensity ToUnit(PowerDensityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="PowerDensity"/> to another <see cref="PowerDensity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A PowerDensity with the specified unit.</returns>
-        public PowerDensity ToUnit(PowerDensityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(PowerDensity), Unit, typeof(PowerDensity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (PowerDensity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="PowerDensity"/> to another <see cref="PowerDensity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="PowerDensity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(PowerDensityUnit unit, [NotNullWhen(true)] out PowerDensity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            PowerDensity? convertedOrNull = (Unit, unit) switch
-            {
-                // PowerDensityUnit -> BaseUnit
-                (PowerDensityUnit.DecawattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 0.028316846592) * 1e1d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.DecawattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 1.6387064e-5) * 1e1d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.DecawattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value) * 1e1d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.DecawattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value * 1.0e3) * 1e1d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.DeciwattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 0.028316846592) * 1e-1d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.DeciwattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 1.6387064e-5) * 1e-1d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.DeciwattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value) * 1e-1d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.DeciwattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value * 1.0e3) * 1e-1d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.GigawattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 0.028316846592) * 1e9d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.GigawattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 1.6387064e-5) * 1e9d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.GigawattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value) * 1e9d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.GigawattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value * 1.0e3) * 1e9d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.KilowattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 0.028316846592) * 1e3d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.KilowattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 1.6387064e-5) * 1e3d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.KilowattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value) * 1e3d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.KilowattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value * 1.0e3) * 1e3d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MegawattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 0.028316846592) * 1e6d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MegawattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 1.6387064e-5) * 1e6d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MegawattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value) * 1e6d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MegawattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value * 1.0e3) * 1e6d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MicrowattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 0.028316846592) * 1e-6d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MicrowattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 1.6387064e-5) * 1e-6d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MicrowattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value) * 1e-6d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MicrowattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value * 1.0e3) * 1e-6d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MilliwattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 0.028316846592) * 1e-3d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MilliwattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 1.6387064e-5) * 1e-3d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MilliwattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value) * 1e-3d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.MilliwattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value * 1.0e3) * 1e-3d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.NanowattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 0.028316846592) * 1e-9d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.NanowattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 1.6387064e-5) * 1e-9d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.NanowattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value) * 1e-9d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.NanowattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value * 1.0e3) * 1e-9d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.PicowattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 0.028316846592) * 1e-12d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.PicowattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 1.6387064e-5) * 1e-12d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.PicowattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value) * 1e-12d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.PicowattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value * 1.0e3) * 1e-12d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.TerawattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 0.028316846592) * 1e12d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.TerawattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value / 1.6387064e-5) * 1e12d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.TerawattPerCubicMeter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value) * 1e12d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.TerawattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity((_value * 1.0e3) * 1e12d, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicFoot, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity(_value / 0.028316846592, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicInch, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity(_value / 1.6387064e-5, PowerDensityUnit.WattPerCubicMeter),
-                (PowerDensityUnit.WattPerLiter, PowerDensityUnit.WattPerCubicMeter) => new PowerDensity(_value * 1.0e3, PowerDensityUnit.WattPerCubicMeter),
-
-                // BaseUnit -> PowerDensityUnit
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DecawattPerCubicFoot) => new PowerDensity((_value * 0.028316846592) / 1e1d, PowerDensityUnit.DecawattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DecawattPerCubicInch) => new PowerDensity((_value * 1.6387064e-5) / 1e1d, PowerDensityUnit.DecawattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DecawattPerCubicMeter) => new PowerDensity((_value) / 1e1d, PowerDensityUnit.DecawattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DecawattPerLiter) => new PowerDensity((_value / 1.0e3) / 1e1d, PowerDensityUnit.DecawattPerLiter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DeciwattPerCubicFoot) => new PowerDensity((_value * 0.028316846592) / 1e-1d, PowerDensityUnit.DeciwattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DeciwattPerCubicInch) => new PowerDensity((_value * 1.6387064e-5) / 1e-1d, PowerDensityUnit.DeciwattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DeciwattPerCubicMeter) => new PowerDensity((_value) / 1e-1d, PowerDensityUnit.DeciwattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.DeciwattPerLiter) => new PowerDensity((_value / 1.0e3) / 1e-1d, PowerDensityUnit.DeciwattPerLiter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.GigawattPerCubicFoot) => new PowerDensity((_value * 0.028316846592) / 1e9d, PowerDensityUnit.GigawattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.GigawattPerCubicInch) => new PowerDensity((_value * 1.6387064e-5) / 1e9d, PowerDensityUnit.GigawattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.GigawattPerCubicMeter) => new PowerDensity((_value) / 1e9d, PowerDensityUnit.GigawattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.GigawattPerLiter) => new PowerDensity((_value / 1.0e3) / 1e9d, PowerDensityUnit.GigawattPerLiter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.KilowattPerCubicFoot) => new PowerDensity((_value * 0.028316846592) / 1e3d, PowerDensityUnit.KilowattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.KilowattPerCubicInch) => new PowerDensity((_value * 1.6387064e-5) / 1e3d, PowerDensityUnit.KilowattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.KilowattPerCubicMeter) => new PowerDensity((_value) / 1e3d, PowerDensityUnit.KilowattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.KilowattPerLiter) => new PowerDensity((_value / 1.0e3) / 1e3d, PowerDensityUnit.KilowattPerLiter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MegawattPerCubicFoot) => new PowerDensity((_value * 0.028316846592) / 1e6d, PowerDensityUnit.MegawattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MegawattPerCubicInch) => new PowerDensity((_value * 1.6387064e-5) / 1e6d, PowerDensityUnit.MegawattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MegawattPerCubicMeter) => new PowerDensity((_value) / 1e6d, PowerDensityUnit.MegawattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MegawattPerLiter) => new PowerDensity((_value / 1.0e3) / 1e6d, PowerDensityUnit.MegawattPerLiter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MicrowattPerCubicFoot) => new PowerDensity((_value * 0.028316846592) / 1e-6d, PowerDensityUnit.MicrowattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MicrowattPerCubicInch) => new PowerDensity((_value * 1.6387064e-5) / 1e-6d, PowerDensityUnit.MicrowattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MicrowattPerCubicMeter) => new PowerDensity((_value) / 1e-6d, PowerDensityUnit.MicrowattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MicrowattPerLiter) => new PowerDensity((_value / 1.0e3) / 1e-6d, PowerDensityUnit.MicrowattPerLiter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MilliwattPerCubicFoot) => new PowerDensity((_value * 0.028316846592) / 1e-3d, PowerDensityUnit.MilliwattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MilliwattPerCubicInch) => new PowerDensity((_value * 1.6387064e-5) / 1e-3d, PowerDensityUnit.MilliwattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MilliwattPerCubicMeter) => new PowerDensity((_value) / 1e-3d, PowerDensityUnit.MilliwattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.MilliwattPerLiter) => new PowerDensity((_value / 1.0e3) / 1e-3d, PowerDensityUnit.MilliwattPerLiter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.NanowattPerCubicFoot) => new PowerDensity((_value * 0.028316846592) / 1e-9d, PowerDensityUnit.NanowattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.NanowattPerCubicInch) => new PowerDensity((_value * 1.6387064e-5) / 1e-9d, PowerDensityUnit.NanowattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.NanowattPerCubicMeter) => new PowerDensity((_value) / 1e-9d, PowerDensityUnit.NanowattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.NanowattPerLiter) => new PowerDensity((_value / 1.0e3) / 1e-9d, PowerDensityUnit.NanowattPerLiter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.PicowattPerCubicFoot) => new PowerDensity((_value * 0.028316846592) / 1e-12d, PowerDensityUnit.PicowattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.PicowattPerCubicInch) => new PowerDensity((_value * 1.6387064e-5) / 1e-12d, PowerDensityUnit.PicowattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.PicowattPerCubicMeter) => new PowerDensity((_value) / 1e-12d, PowerDensityUnit.PicowattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.PicowattPerLiter) => new PowerDensity((_value / 1.0e3) / 1e-12d, PowerDensityUnit.PicowattPerLiter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.TerawattPerCubicFoot) => new PowerDensity((_value * 0.028316846592) / 1e12d, PowerDensityUnit.TerawattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.TerawattPerCubicInch) => new PowerDensity((_value * 1.6387064e-5) / 1e12d, PowerDensityUnit.TerawattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.TerawattPerCubicMeter) => new PowerDensity((_value) / 1e12d, PowerDensityUnit.TerawattPerCubicMeter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.TerawattPerLiter) => new PowerDensity((_value / 1.0e3) / 1e12d, PowerDensityUnit.TerawattPerLiter),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.WattPerCubicFoot) => new PowerDensity(_value * 0.028316846592, PowerDensityUnit.WattPerCubicFoot),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.WattPerCubicInch) => new PowerDensity(_value * 1.6387064e-5, PowerDensityUnit.WattPerCubicInch),
-                (PowerDensityUnit.WattPerCubicMeter, PowerDensityUnit.WattPerLiter) => new PowerDensity(_value / 1.0e3, PowerDensityUnit.WattPerLiter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not PowerDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerDensityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is PowerDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<PowerDensityUnit> IQuantity<PowerDensityUnit>.ToUnit(PowerDensityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1499,11 +1325,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
index eee3ae332b..e81ee0011f 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     The strength of a signal expressed in decibels (dB) relative to one watt.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct PowerRatio :
         ILogarithmicQuantity<PowerRatio, PowerRatioUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<PowerRatio, PowerRatio, double>,
+        IDivisionOperators<PowerRatio, PowerRatio, QuantityValue>,
         IComparisonOperators<PowerRatio, PowerRatio, bool>,
         IParsable<PowerRatio>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -117,16 +116,17 @@ public static PowerRatioInfo CreateDefault(Func<IEnumerable<UnitDefinition<Power
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{PowerRatioUnit}"/> representing the default unit mappings for PowerRatio.</returns>
             public static IEnumerable<UnitDefinition<PowerRatioUnit>> GetDefaultMappings()
             {
-                yield return new (PowerRatioUnit.DecibelMilliwatt, "DecibelMilliwatt", "DecibelMilliwatts", BaseUnits.Undefined);
+                yield return new (PowerRatioUnit.DecibelMilliwatt, "DecibelMilliwatt", "DecibelMilliwatts", BaseUnits.Undefined,
+                     new ConversionExpression(coefficient: 1, constantTerm: 30),
+                     new ConversionExpression(coefficient: 1, constantTerm: -30)
+                );
                 yield return new (PowerRatioUnit.DecibelWatt, "DecibelWatt", "DecibelWatts", BaseUnits.Undefined);
             }
         }
 
         static PowerRatio()
         {
-            Info = PowerRatioInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(PowerRatioInfo.CreateDefault);
         }
 
         /// <summary>
@@ -134,7 +134,7 @@ static PowerRatio()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public PowerRatio(double value, PowerRatioUnit unit)
+        public PowerRatio(QuantityValue value, PowerRatioUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -145,7 +145,8 @@ public PowerRatio(double value, PowerRatioUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="PowerRatio" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<PowerRatio, PowerRatioUnit> Info { get; }
@@ -171,16 +172,14 @@ public PowerRatio(double value, PowerRatioUnit unit)
         public static PowerRatio Zero => Info.Zero;
 
         /// <inheritdoc />
-        public static double LogarithmicScalingFactor {get;} = 10;
+        public static QuantityValue LogarithmicScalingFactor {get;} = 10;
 
         #endregion
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public PowerRatioUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -208,7 +207,7 @@ public PowerRatio(double value, PowerRatioUnit unit)
 #endif
 
 #if NETSTANDARD2_0
-        double ILogarithmicQuantity<PowerRatio>.LogarithmicScalingFactor => LogarithmicScalingFactor;
+        QuantityValue ILogarithmicQuantity<PowerRatio>.LogarithmicScalingFactor => LogarithmicScalingFactor;
 #endif
 
         #endregion
@@ -218,35 +217,19 @@ public PowerRatio(double value, PowerRatioUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerRatioUnit.DecibelMilliwatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerRatioUnit.DecibelMilliwatt"/>
         /// </summary>
-        public double DecibelMilliwatts => As(PowerRatioUnit.DecibelMilliwatt);
+        public QuantityValue DecibelMilliwatts => this.As(PowerRatioUnit.DecibelMilliwatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PowerRatioUnit.DecibelWatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PowerRatioUnit.DecibelWatt"/>
         /// </summary>
-        public double DecibelWatts => As(PowerRatioUnit.DecibelWatt);
+        public QuantityValue DecibelWatts => this.As(PowerRatioUnit.DecibelWatt);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: PowerRatioUnit -> BaseUnit
-            unitConverter.SetConversionFunction<PowerRatio>(PowerRatioUnit.DecibelMilliwatt, PowerRatioUnit.DecibelWatt, quantity => quantity.ToUnit(PowerRatioUnit.DecibelWatt));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<PowerRatio>(PowerRatioUnit.DecibelWatt, PowerRatioUnit.DecibelWatt, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> PowerRatioUnit
-            unitConverter.SetConversionFunction<PowerRatio>(PowerRatioUnit.DecibelWatt, PowerRatioUnit.DecibelMilliwatt, quantity => quantity.ToUnit(PowerRatioUnit.DecibelMilliwatt));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -275,7 +258,7 @@ public static string GetAbbreviation(PowerRatioUnit unit, IFormatProvider? provi
         /// <summary>
         ///     Creates a <see cref="PowerRatio"/> from <see cref="PowerRatioUnit.DecibelMilliwatt"/>.
         /// </summary>
-        public static PowerRatio FromDecibelMilliwatts(double value)
+        public static PowerRatio FromDecibelMilliwatts(QuantityValue value)
         {
             return new PowerRatio(value, PowerRatioUnit.DecibelMilliwatt);
         }
@@ -283,7 +266,7 @@ public static PowerRatio FromDecibelMilliwatts(double value)
         /// <summary>
         ///     Creates a <see cref="PowerRatio"/> from <see cref="PowerRatioUnit.DecibelWatt"/>.
         /// </summary>
-        public static PowerRatio FromDecibelWatts(double value)
+        public static PowerRatio FromDecibelWatts(QuantityValue value)
         {
             return new PowerRatio(value, PowerRatioUnit.DecibelWatt);
         }
@@ -294,7 +277,7 @@ public static PowerRatio FromDecibelWatts(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>PowerRatio unit value.</returns>
-        public static PowerRatio From(double value, PowerRatioUnit fromUnit)
+        public static PowerRatio From(QuantityValue value, PowerRatioUnit fromUnit)
         {
             return new PowerRatio(value, fromUnit);
         }
@@ -355,10 +338,7 @@ public static PowerRatio Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static PowerRatio Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<PowerRatio, PowerRatioUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<PowerRatio, PowerRatioUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -386,11 +366,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out PowerRatio resul
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out PowerRatio result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<PowerRatio, PowerRatioUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<PowerRatio, PowerRatioUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -411,7 +387,7 @@ public static PowerRatioUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -422,7 +398,7 @@ public static PowerRatioUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PowerRatioUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.PowerRatioUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out PowerRatioUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -437,7 +413,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PowerRatioUn
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out PowerRatioUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -448,53 +424,51 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         #region Logarithmic Arithmetic Operators
 
         /// <summary>Negate the value.</summary>
-        public static PowerRatio operator -(PowerRatio right)
+        public static PowerRatio operator -(PowerRatio quantity)
         {
-            return new PowerRatio(-right.Value, right.Unit);
+            return new PowerRatio(-quantity.Value, quantity.Unit);
         }
 
         /// <summary>Get <see cref="PowerRatio"/> from logarithmic addition of two <see cref="PowerRatio"/>.</summary>
+        /// <remarks>This operation involves a conversion of the values to linear space, which is not guaranteed to produce an exact value.
+        /// <para>The final result is rounded to 15 significant digits.</para>
+        /// </remarks>
         public static PowerRatio operator +(PowerRatio left, PowerRatio right)
         {
-            // Logarithmic addition
-            // Formula: 10 * log10(10^(x/10) + 10^(y/10))
-            return new PowerRatio(10 * Math.Log10(Math.Pow(10, left.Value / 10) + Math.Pow(10, right.ToUnit(left.Unit).Value / 10)), left.Unit);
+            return new PowerRatio(QuantityValueExtensions.AddWithLogScaling(left.Value, right.As(left.Unit), LogarithmicScalingFactor), left.Unit);
         }
 
         /// <summary>Get <see cref="PowerRatio"/> from logarithmic subtraction of two <see cref="PowerRatio"/>.</summary>
+        /// <remarks>This operation involves a conversion of the values to linear space, which is not guaranteed to produce an exact value.
+        /// <para>The final result is rounded to 15 significant digits.</para>
+        /// </remarks>
         public static PowerRatio operator -(PowerRatio left, PowerRatio right)
         {
-            // Logarithmic subtraction
-            // Formula: 10 * log10(10^(x/10) - 10^(y/10))
-            return new PowerRatio(10 * Math.Log10(Math.Pow(10, left.Value / 10) - Math.Pow(10, right.ToUnit(left.Unit).Value / 10)), left.Unit);
+            return new PowerRatio(QuantityValueExtensions.SubtractWithLogScaling(left.Value, right.As(left.Unit), LogarithmicScalingFactor), left.Unit);
         }
 
         /// <summary>Get <see cref="PowerRatio"/> from logarithmic multiplication of value and <see cref="PowerRatio"/>.</summary>
-        public static PowerRatio operator *(double left, PowerRatio right)
+        public static PowerRatio operator *(QuantityValue left, PowerRatio right)
         {
-            // Logarithmic multiplication = addition
             return new PowerRatio(left + right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="PowerRatio"/> from logarithmic multiplication of value and <see cref="PowerRatio"/>.</summary>
-        public static PowerRatio operator *(PowerRatio left, double right)
+        public static PowerRatio operator *(PowerRatio left, QuantityValue right)
         {
-            // Logarithmic multiplication = addition
             return new PowerRatio(left.Value + right, left.Unit);
         }
 
         /// <summary>Get <see cref="PowerRatio"/> from logarithmic division of <see cref="PowerRatio"/> by value.</summary>
-        public static PowerRatio operator /(PowerRatio left, double right)
+        public static PowerRatio operator /(PowerRatio left, QuantityValue right)
         {
-            // Logarithmic division = subtraction
             return new PowerRatio(left.Value - right, left.Unit);
         }
 
         /// <summary>Get ratio value from logarithmic division of <see cref="PowerRatio"/> by <see cref="PowerRatio"/>.</summary>
-        public static double operator /(PowerRatio left, PowerRatio right)
+        public static QuantityValue operator /(PowerRatio left, PowerRatio right)
         {
-            // Logarithmic division = subtraction
-            return Convert.ToDouble(left.Value - right.ToUnit(left.Unit).Value);
+            return left.Value - right.As(left.Unit);
         }
 
         #endregion
@@ -504,97 +478,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(PowerRatio left, PowerRatio right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(PowerRatio left, PowerRatio right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(PowerRatio left, PowerRatio right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(PowerRatio left, PowerRatio right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="PowerRatio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(PowerRatio other, PowerRatio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="PowerRatio"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(PowerRatio)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(PowerRatio left, PowerRatio right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="PowerRatio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(PowerRatio other, PowerRatio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="PowerRatio"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(PowerRatio,PowerRatio)"/>.
+        ///     See that operator (and <see cref="Equals(PowerRatio)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(PowerRatio left, PowerRatio right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="PowerRatio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(PowerRatio other, PowerRatio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="PowerRatio"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="PowerRatio"/>.
+        ///     When <paramref name="obj"/> is a <see cref="PowerRatio"/>, this method delegates to
+        ///     <see cref="Equals(PowerRatio)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is PowerRatio otherQuantity))
+            if (obj is not PowerRatio otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="PowerRatio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(PowerRatio other, PowerRatio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="PowerRatio"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(PowerRatio other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current PowerRatio.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(PowerRatio), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="PowerRatio"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(PowerRatio)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is PowerRatio otherQuantity)) throw new ArgumentException("Expected type PowerRatio.", nameof(obj));
+            if (obj is not PowerRatio otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<PowerRatio>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="PowerRatio"/> with another <see cref="PowerRatio"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="PowerRatio"/> with another <see cref="PowerRatio"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -606,133 +594,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(PowerRatio other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(PowerRatioUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<PowerRatioUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this PowerRatio to another PowerRatio with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A PowerRatio with the specified unit.</returns>
-        public PowerRatio ToUnit(PowerRatioUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="PowerRatio"/> to another <see cref="PowerRatio"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A PowerRatio with the specified unit.</returns>
-        public PowerRatio ToUnit(PowerRatioUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(PowerRatio), Unit, typeof(PowerRatio), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (PowerRatio)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="PowerRatio"/> to another <see cref="PowerRatio"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="PowerRatio"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(PowerRatioUnit unit, [NotNullWhen(true)] out PowerRatio? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            PowerRatio? convertedOrNull = (Unit, unit) switch
-            {
-                // PowerRatioUnit -> BaseUnit
-                (PowerRatioUnit.DecibelMilliwatt, PowerRatioUnit.DecibelWatt) => new PowerRatio(_value - 30, PowerRatioUnit.DecibelWatt),
-
-                // BaseUnit -> PowerRatioUnit
-                (PowerRatioUnit.DecibelWatt, PowerRatioUnit.DecibelMilliwatt) => new PowerRatio(_value + 30, PowerRatioUnit.DecibelMilliwatt),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not PowerRatioUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerRatioUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is PowerRatioUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerRatioUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<PowerRatioUnit> IQuantity<PowerRatioUnit>.ToUnit(PowerRatioUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -744,11 +610,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
index 2a91befa59..49da47b3e5 100644
--- a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,21 +33,28 @@ namespace UnitsNet
     ///     Pressure (symbol: P or p) is the ratio of force to the area over which that force is distributed. Pressure is force per unit area applied in a direction perpendicular to the surface of an object. Gauge pressure (also spelled gage pressure)[a] is the pressure relative to the local atmospheric or ambient pressure. Pressure is measured in any unit of force divided by any unit of area. The SI unit of pressure is the newton per square metre, which is called the pascal (Pa) after the seventeenth-century philosopher and scientist Blaise Pascal. A pressure of 1 Pa is small; it approximately equals the pressure exerted by a dollar bill resting flat on a table. Everyday pressures are often stated in kilopascals (1 kPa = 1000 Pa).
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Pressure :
-        IArithmeticQuantity<Pressure, PressureUnit>,
+        ILinearQuantity<Pressure, PressureUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Pressure, Pressure, double>,
+        IDivisionOperators<Pressure, Pressure, QuantityValue>,
+        IDivisionOperators<Pressure, AreaDensity, Acceleration>,
+        IDivisionOperators<Pressure, Acceleration, AreaDensity>,
         IDivisionOperators<Pressure, PressureChangeRate, Duration>,
+        IDivisionOperators<Pressure, VolumeFlow, FluidResistance>,
         IDivisionOperators<Pressure, ReciprocalArea, Force>,
         IMultiplyOperators<Pressure, Area, Force>,
         IMultiplyOperators<Pressure, Length, ForcePerLength>,
         IDivisionOperators<Pressure, ReciprocalLength, ForcePerLength>,
+        IMultiplyOperators<Pressure, VolumeFlow, LeakRate>,
         IDivisionOperators<Pressure, SpecificWeight, Length>,
         IDivisionOperators<Pressure, Duration, PressureChangeRate>,
+        IMultiplyOperators<Pressure, Compressibility, Ratio>,
         IDivisionOperators<Pressure, Force, ReciprocalArea>,
         IDivisionOperators<Pressure, ForcePerLength, ReciprocalLength>,
         IDivisionOperators<Pressure, Length, SpecificWeight>,
+        IDivisionOperators<Pressure, FluidResistance, VolumeFlow>,
         IComparisonOperators<Pressure, Pressure, bool>,
         IParsable<Pressure>,
 #endif
@@ -62,7 +67,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -112,7 +117,7 @@ public static PressureInfo CreateDefault(Func<IEnumerable<UnitDefinition<Pressur
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Pressure"/> is [T^-2][L^-1][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Pressure"/> is T^-2L^-1M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 1, -2, 0, 0, 0, 0);
 
@@ -127,62 +132,160 @@ public static PressureInfo CreateDefault(Func<IEnumerable<UnitDefinition<Pressur
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{PressureUnit}"/> representing the default unit mappings for Pressure.</returns>
             public static IEnumerable<UnitDefinition<PressureUnit>> GetDefaultMappings()
             {
-                yield return new (PressureUnit.Atmosphere, "Atmosphere", "Atmospheres", BaseUnits.Undefined);
-                yield return new (PressureUnit.Bar, "Bar", "Bars", BaseUnits.Undefined);
-                yield return new (PressureUnit.Centibar, "Centibar", "Centibars", BaseUnits.Undefined);
-                yield return new (PressureUnit.CentimeterOfWaterColumn, "CentimeterOfWaterColumn", "CentimetersOfWaterColumn", BaseUnits.Undefined);
-                yield return new (PressureUnit.Decapascal, "Decapascal", "Decapascals", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureUnit.Decibar, "Decibar", "Decibars", BaseUnits.Undefined);
-                yield return new (PressureUnit.DynePerSquareCentimeter, "DynePerSquareCentimeter", "DynesPerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (PressureUnit.FootOfHead, "FootOfHead", "FeetOfHead", BaseUnits.Undefined);
-                yield return new (PressureUnit.Gigapascal, "Gigapascal", "Gigapascals", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureUnit.Hectopascal, "Hectopascal", "Hectopascals", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureUnit.InchOfMercury, "InchOfMercury", "InchesOfMercury", BaseUnits.Undefined);
-                yield return new (PressureUnit.InchOfWaterColumn, "InchOfWaterColumn", "InchesOfWaterColumn", BaseUnits.Undefined);
-                yield return new (PressureUnit.Kilobar, "Kilobar", "Kilobars", BaseUnits.Undefined);
-                yield return new (PressureUnit.KilogramForcePerSquareCentimeter, "KilogramForcePerSquareCentimeter", "KilogramsForcePerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (PressureUnit.KilogramForcePerSquareMeter, "KilogramForcePerSquareMeter", "KilogramsForcePerSquareMeter", BaseUnits.Undefined);
-                yield return new (PressureUnit.KilogramForcePerSquareMillimeter, "KilogramForcePerSquareMillimeter", "KilogramsForcePerSquareMillimeter", BaseUnits.Undefined);
-                yield return new (PressureUnit.KilonewtonPerSquareCentimeter, "KilonewtonPerSquareCentimeter", "KilonewtonsPerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (PressureUnit.KilonewtonPerSquareMeter, "KilonewtonPerSquareMeter", "KilonewtonsPerSquareMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureUnit.KilonewtonPerSquareMillimeter, "KilonewtonPerSquareMillimeter", "KilonewtonsPerSquareMillimeter", BaseUnits.Undefined);
-                yield return new (PressureUnit.Kilopascal, "Kilopascal", "Kilopascals", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureUnit.KilopoundForcePerSquareFoot, "KilopoundForcePerSquareFoot", "KilopoundsForcePerSquareFoot", BaseUnits.Undefined);
-                yield return new (PressureUnit.KilopoundForcePerSquareInch, "KilopoundForcePerSquareInch", "KilopoundsForcePerSquareInch", BaseUnits.Undefined);
-                yield return new (PressureUnit.KilopoundForcePerSquareMil, "KilopoundForcePerSquareMil", "KilopoundsForcePerSquareMil", BaseUnits.Undefined);
-                yield return new (PressureUnit.Megabar, "Megabar", "Megabars", BaseUnits.Undefined);
-                yield return new (PressureUnit.MeganewtonPerSquareMeter, "MeganewtonPerSquareMeter", "MeganewtonsPerSquareMeter", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureUnit.Megapascal, "Megapascal", "Megapascals", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureUnit.MeterOfHead, "MeterOfHead", "MetersOfHead", BaseUnits.Undefined);
-                yield return new (PressureUnit.MeterOfWaterColumn, "MeterOfWaterColumn", "MetersOfWaterColumn", BaseUnits.Undefined);
-                yield return new (PressureUnit.Microbar, "Microbar", "Microbars", BaseUnits.Undefined);
-                yield return new (PressureUnit.Micropascal, "Micropascal", "Micropascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second));
-                yield return new (PressureUnit.Millibar, "Millibar", "Millibars", BaseUnits.Undefined);
-                yield return new (PressureUnit.MillimeterOfMercury, "MillimeterOfMercury", "MillimetersOfMercury", BaseUnits.Undefined);
-                yield return new (PressureUnit.MillimeterOfWaterColumn, "MillimeterOfWaterColumn", "MillimetersOfWaterColumn", BaseUnits.Undefined);
-                yield return new (PressureUnit.Millipascal, "Millipascal", "Millipascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second));
-                yield return new (PressureUnit.Millitorr, "Millitorr", "Millitorrs", BaseUnits.Undefined);
-                yield return new (PressureUnit.NewtonPerSquareCentimeter, "NewtonPerSquareCentimeter", "NewtonsPerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (PressureUnit.NewtonPerSquareMeter, "NewtonPerSquareMeter", "NewtonsPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureUnit.NewtonPerSquareMillimeter, "NewtonPerSquareMillimeter", "NewtonsPerSquareMillimeter", BaseUnits.Undefined);
+                yield return new (PressureUnit.Atmosphere, "Atmosphere", "Atmospheres", BaseUnits.Undefined,
+                     new QuantityValue(1, 101325)
+                );
+                yield return new (PressureUnit.Bar, "Bar", "Bars", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000)
+                );
+                yield return new (PressureUnit.Centibar, "Centibar", "Centibars", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (PressureUnit.CentimeterOfWaterColumn, "CentimeterOfWaterColumn", "CentimetersOfWaterColumn", BaseUnits.Undefined,
+                     new QuantityValue(2000, 196133)
+                );
+                yield return new (PressureUnit.Decapascal, "Decapascal", "Decapascals", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 10)
+                );
+                yield return new (PressureUnit.Decibar, "Decibar", "Decibars", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (PressureUnit.DynePerSquareCentimeter, "DynePerSquareCentimeter", "DynesPerSquareCentimeter", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (PressureUnit.FootOfHead, "FootOfHead", "FeetOfHead", BaseUnits.Undefined,
+                     new QuantityValue(156250000, 466922140449)
+                );
+                yield return new (PressureUnit.Gigapascal, "Gigapascal", "Gigapascals", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (PressureUnit.Hectopascal, "Hectopascal", "Hectopascals", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 100)
+                );
+                yield return new (PressureUnit.InchOfMercury, "InchOfMercury", "InchesOfMercury", BaseUnits.Undefined,
+                     new QuantityValue(1000000000, 3386388640341)
+                );
+                yield return new (PressureUnit.InchOfWaterColumn, "InchOfWaterColumn", "InchesOfWaterColumn", BaseUnits.Undefined,
+                     new QuantityValue(100000, 24908891)
+                );
+                yield return new (PressureUnit.Kilobar, "Kilobar", "Kilobars", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000000)
+                );
+                yield return new (PressureUnit.KilogramForcePerSquareCentimeter, "KilogramForcePerSquareCentimeter", "KilogramsForcePerSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(2, 196133)
+                );
+                yield return new (PressureUnit.KilogramForcePerSquareMeter, "KilogramForcePerSquareMeter", "KilogramsForcePerSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(20000, 196133)
+                );
+                yield return new (PressureUnit.KilogramForcePerSquareMillimeter, "KilogramForcePerSquareMillimeter", "KilogramsForcePerSquareMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 9806650)
+                );
+                yield return new (PressureUnit.KilonewtonPerSquareCentimeter, "KilonewtonPerSquareCentimeter", "KilonewtonsPerSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000000)
+                );
+                yield return new (PressureUnit.KilonewtonPerSquareMeter, "KilonewtonPerSquareMeter", "KilonewtonsPerSquareMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (PressureUnit.KilonewtonPerSquareMillimeter, "KilonewtonPerSquareMillimeter", "KilonewtonsPerSquareMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (PressureUnit.Kilopascal, "Kilopascal", "Kilopascals", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (PressureUnit.KilopoundForcePerSquareFoot, "KilopoundForcePerSquareFoot", "KilopoundsForcePerSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(185806080, 8896443230521)
+                );
+                yield return new (PressureUnit.KilopoundForcePerSquareInch, "KilopoundForcePerSquareInch", "KilopoundsForcePerSquareInch", BaseUnits.Undefined,
+                     new QuantityValue(1290320, 8896443230521)
+                );
+                yield return new (PressureUnit.KilopoundForcePerSquareMil, "KilopoundForcePerSquareMil", "KilopoundsForcePerSquareMil", BaseUnits.Undefined,
+                     new QuantityValue(16129, 111205540381512500)
+                );
+                yield return new (PressureUnit.Megabar, "Megabar", "Megabars", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000000000)
+                );
+                yield return new (PressureUnit.MeganewtonPerSquareMeter, "MeganewtonPerSquareMeter", "MeganewtonsPerSquareMeter", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (PressureUnit.Megapascal, "Megapascal", "Megapascals", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (PressureUnit.MeterOfHead, "MeterOfHead", "MetersOfHead", BaseUnits.Undefined,
+                     new QuantityValue(125000, 1225517429)
+                );
+                yield return new (PressureUnit.MeterOfWaterColumn, "MeterOfWaterColumn", "MetersOfWaterColumn", BaseUnits.Undefined,
+                     new QuantityValue(20, 196133)
+                );
+                yield return new (PressureUnit.Microbar, "Microbar", "Microbars", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (PressureUnit.Micropascal, "Micropascal", "Micropascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (PressureUnit.Millibar, "Millibar", "Millibars", BaseUnits.Undefined,
+                     new QuantityValue(1, 100)
+                );
+                yield return new (PressureUnit.MilligramForcePerSquareFoot, "MilligramForcePerSquareFoot", "MilligramsForcePerSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(1858060800, 196133)
+                );
+                yield return new (PressureUnit.MilligramForcePerSquareMeter, "MilligramForcePerSquareMeter", "MilligramsForcePerSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(20000000000, 196133)
+                );
+                yield return new (PressureUnit.MillimeterOfMercury, "MillimeterOfMercury", "MillimetersOfMercury", BaseUnits.Undefined,
+                     new QuantityValue(200000000, 26664477483)
+                );
+                yield return new (PressureUnit.MillimeterOfWaterColumn, "MillimeterOfWaterColumn", "MillimetersOfWaterColumn", BaseUnits.Undefined,
+                     new QuantityValue(20000, 196133)
+                );
+                yield return new (PressureUnit.Millipascal, "Millipascal", "Millipascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (PressureUnit.Millitorr, "Millitorr", "Millitorrs", BaseUnits.Undefined,
+                     new QuantityValue(30400, 4053)
+                );
+                yield return new (PressureUnit.NewtonPerSquareCentimeter, "NewtonPerSquareCentimeter", "NewtonsPerSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (PressureUnit.NewtonPerSquareMeter, "NewtonPerSquareMeter", "NewtonsPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     1
+                );
+                yield return new (PressureUnit.NewtonPerSquareMillimeter, "NewtonPerSquareMillimeter", "NewtonsPerSquareMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
                 yield return new (PressureUnit.Pascal, "Pascal", "Pascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureUnit.PoundForcePerSquareFoot, "PoundForcePerSquareFoot", "PoundsForcePerSquareFoot", BaseUnits.Undefined);
-                yield return new (PressureUnit.PoundForcePerSquareInch, "PoundForcePerSquareInch", "PoundsForcePerSquareInch", BaseUnits.Undefined);
-                yield return new (PressureUnit.PoundForcePerSquareMil, "PoundForcePerSquareMil", "PoundsForcePerSquareMil", BaseUnits.Undefined);
-                yield return new (PressureUnit.PoundPerInchSecondSquared, "PoundPerInchSecondSquared", "PoundsPerInchSecondSquared", BaseUnits.Undefined);
-                yield return new (PressureUnit.TechnicalAtmosphere, "TechnicalAtmosphere", "TechnicalAtmospheres", BaseUnits.Undefined);
-                yield return new (PressureUnit.TonneForcePerSquareCentimeter, "TonneForcePerSquareCentimeter", "TonnesForcePerSquareCentimeter", BaseUnits.Undefined);
-                yield return new (PressureUnit.TonneForcePerSquareMeter, "TonneForcePerSquareMeter", "TonnesForcePerSquareMeter", BaseUnits.Undefined);
-                yield return new (PressureUnit.TonneForcePerSquareMillimeter, "TonneForcePerSquareMillimeter", "TonnesForcePerSquareMillimeter", BaseUnits.Undefined);
-                yield return new (PressureUnit.Torr, "Torr", "Torrs", BaseUnits.Undefined);
+                yield return new (PressureUnit.PoundForcePerSquareFoot, "PoundForcePerSquareFoot", "PoundsForcePerSquareFoot", BaseUnits.Undefined,
+                     new QuantityValue(185806080000, 8896443230521)
+                );
+                yield return new (PressureUnit.PoundForcePerSquareInch, "PoundForcePerSquareInch", "PoundsForcePerSquareInch", BaseUnits.Undefined,
+                     new QuantityValue(1290320000, 8896443230521)
+                );
+                yield return new (PressureUnit.PoundForcePerSquareMil, "PoundForcePerSquareMil", "PoundsForcePerSquareMil", BaseUnits.Undefined,
+                     new QuantityValue(32258, 222411080763025)
+                );
+                yield return new (PressureUnit.PoundPerInchSecondSquared, "PoundPerInchSecondSquared", "PoundsPerInchSecondSquared", BaseUnits.Undefined,
+                     new QuantityValue(498177842352, 8896443230521)
+                );
+                yield return new (PressureUnit.TechnicalAtmosphere, "TechnicalAtmosphere", "TechnicalAtmospheres", BaseUnits.Undefined,
+                     new QuantityValue(2, 196133)
+                );
+                yield return new (PressureUnit.TonneForcePerSquareCentimeter, "TonneForcePerSquareCentimeter", "TonnesForcePerSquareCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 98066500)
+                );
+                yield return new (PressureUnit.TonneForcePerSquareMeter, "TonneForcePerSquareMeter", "TonnesForcePerSquareMeter", BaseUnits.Undefined,
+                     new QuantityValue(20, 196133)
+                );
+                yield return new (PressureUnit.TonneForcePerSquareMillimeter, "TonneForcePerSquareMillimeter", "TonnesForcePerSquareMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 9806650000)
+                );
+                yield return new (PressureUnit.Torr, "Torr", "Torrs", BaseUnits.Undefined,
+                     new QuantityValue(152, 20265)
+                );
             }
         }
 
         static Pressure()
         {
-            Info = PressureInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(PressureInfo.CreateDefault);
         }
 
         /// <summary>
@@ -190,7 +293,7 @@ static Pressure()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Pressure(double value, PressureUnit unit)
+        public Pressure(QuantityValue value, PressureUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -204,7 +307,7 @@ public Pressure(double value, PressureUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Pressure(double value, UnitSystem unitSystem)
+        public Pressure(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -215,7 +318,8 @@ public Pressure(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Pressure" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Pressure, PressureUnit> Info { get; }
@@ -244,10 +348,8 @@ public Pressure(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public PressureUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -281,357 +383,259 @@ public Pressure(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Atmosphere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Atmosphere"/>
+        /// </summary>
+        public QuantityValue Atmospheres => this.As(PressureUnit.Atmosphere);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Bar"/>
         /// </summary>
-        public double Atmospheres => As(PressureUnit.Atmosphere);
+        public QuantityValue Bars => this.As(PressureUnit.Bar);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Bar"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Centibar"/>
         /// </summary>
-        public double Bars => As(PressureUnit.Bar);
+        public QuantityValue Centibars => this.As(PressureUnit.Centibar);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Centibar"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.CentimeterOfWaterColumn"/>
         /// </summary>
-        public double Centibars => As(PressureUnit.Centibar);
+        public QuantityValue CentimetersOfWaterColumn => this.As(PressureUnit.CentimeterOfWaterColumn);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.CentimeterOfWaterColumn"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Decapascal"/>
         /// </summary>
-        public double CentimetersOfWaterColumn => As(PressureUnit.CentimeterOfWaterColumn);
+        public QuantityValue Decapascals => this.As(PressureUnit.Decapascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Decapascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Decibar"/>
         /// </summary>
-        public double Decapascals => As(PressureUnit.Decapascal);
+        public QuantityValue Decibars => this.As(PressureUnit.Decibar);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Decibar"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.DynePerSquareCentimeter"/>
         /// </summary>
-        public double Decibars => As(PressureUnit.Decibar);
+        public QuantityValue DynesPerSquareCentimeter => this.As(PressureUnit.DynePerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.DynePerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.FootOfHead"/>
         /// </summary>
-        public double DynesPerSquareCentimeter => As(PressureUnit.DynePerSquareCentimeter);
+        public QuantityValue FeetOfHead => this.As(PressureUnit.FootOfHead);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.FootOfHead"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Gigapascal"/>
         /// </summary>
-        public double FeetOfHead => As(PressureUnit.FootOfHead);
+        public QuantityValue Gigapascals => this.As(PressureUnit.Gigapascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Gigapascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Hectopascal"/>
         /// </summary>
-        public double Gigapascals => As(PressureUnit.Gigapascal);
+        public QuantityValue Hectopascals => this.As(PressureUnit.Hectopascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Hectopascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.InchOfMercury"/>
         /// </summary>
-        public double Hectopascals => As(PressureUnit.Hectopascal);
+        public QuantityValue InchesOfMercury => this.As(PressureUnit.InchOfMercury);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.InchOfMercury"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.InchOfWaterColumn"/>
         /// </summary>
-        public double InchesOfMercury => As(PressureUnit.InchOfMercury);
+        public QuantityValue InchesOfWaterColumn => this.As(PressureUnit.InchOfWaterColumn);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.InchOfWaterColumn"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Kilobar"/>
         /// </summary>
-        public double InchesOfWaterColumn => As(PressureUnit.InchOfWaterColumn);
+        public QuantityValue Kilobars => this.As(PressureUnit.Kilobar);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Kilobar"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.KilogramForcePerSquareCentimeter"/>
         /// </summary>
-        public double Kilobars => As(PressureUnit.Kilobar);
+        public QuantityValue KilogramsForcePerSquareCentimeter => this.As(PressureUnit.KilogramForcePerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilogramForcePerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.KilogramForcePerSquareMeter"/>
         /// </summary>
-        public double KilogramsForcePerSquareCentimeter => As(PressureUnit.KilogramForcePerSquareCentimeter);
+        public QuantityValue KilogramsForcePerSquareMeter => this.As(PressureUnit.KilogramForcePerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilogramForcePerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.KilogramForcePerSquareMillimeter"/>
         /// </summary>
-        public double KilogramsForcePerSquareMeter => As(PressureUnit.KilogramForcePerSquareMeter);
+        public QuantityValue KilogramsForcePerSquareMillimeter => this.As(PressureUnit.KilogramForcePerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilogramForcePerSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.KilonewtonPerSquareCentimeter"/>
         /// </summary>
-        public double KilogramsForcePerSquareMillimeter => As(PressureUnit.KilogramForcePerSquareMillimeter);
+        public QuantityValue KilonewtonsPerSquareCentimeter => this.As(PressureUnit.KilonewtonPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilonewtonPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.KilonewtonPerSquareMeter"/>
         /// </summary>
-        public double KilonewtonsPerSquareCentimeter => As(PressureUnit.KilonewtonPerSquareCentimeter);
+        public QuantityValue KilonewtonsPerSquareMeter => this.As(PressureUnit.KilonewtonPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilonewtonPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.KilonewtonPerSquareMillimeter"/>
         /// </summary>
-        public double KilonewtonsPerSquareMeter => As(PressureUnit.KilonewtonPerSquareMeter);
+        public QuantityValue KilonewtonsPerSquareMillimeter => this.As(PressureUnit.KilonewtonPerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilonewtonPerSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Kilopascal"/>
         /// </summary>
-        public double KilonewtonsPerSquareMillimeter => As(PressureUnit.KilonewtonPerSquareMillimeter);
+        public QuantityValue Kilopascals => this.As(PressureUnit.Kilopascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Kilopascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.KilopoundForcePerSquareFoot"/>
         /// </summary>
-        public double Kilopascals => As(PressureUnit.Kilopascal);
+        public QuantityValue KilopoundsForcePerSquareFoot => this.As(PressureUnit.KilopoundForcePerSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilopoundForcePerSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.KilopoundForcePerSquareInch"/>
         /// </summary>
-        public double KilopoundsForcePerSquareFoot => As(PressureUnit.KilopoundForcePerSquareFoot);
+        public QuantityValue KilopoundsForcePerSquareInch => this.As(PressureUnit.KilopoundForcePerSquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilopoundForcePerSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.KilopoundForcePerSquareMil"/>
         /// </summary>
-        public double KilopoundsForcePerSquareInch => As(PressureUnit.KilopoundForcePerSquareInch);
+        public QuantityValue KilopoundsForcePerSquareMil => this.As(PressureUnit.KilopoundForcePerSquareMil);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.KilopoundForcePerSquareMil"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Megabar"/>
         /// </summary>
-        public double KilopoundsForcePerSquareMil => As(PressureUnit.KilopoundForcePerSquareMil);
+        public QuantityValue Megabars => this.As(PressureUnit.Megabar);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Megabar"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.MeganewtonPerSquareMeter"/>
         /// </summary>
-        public double Megabars => As(PressureUnit.Megabar);
+        public QuantityValue MeganewtonsPerSquareMeter => this.As(PressureUnit.MeganewtonPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.MeganewtonPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Megapascal"/>
         /// </summary>
-        public double MeganewtonsPerSquareMeter => As(PressureUnit.MeganewtonPerSquareMeter);
+        public QuantityValue Megapascals => this.As(PressureUnit.Megapascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Megapascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.MeterOfHead"/>
         /// </summary>
-        public double Megapascals => As(PressureUnit.Megapascal);
+        public QuantityValue MetersOfHead => this.As(PressureUnit.MeterOfHead);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.MeterOfHead"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.MeterOfWaterColumn"/>
         /// </summary>
-        public double MetersOfHead => As(PressureUnit.MeterOfHead);
+        public QuantityValue MetersOfWaterColumn => this.As(PressureUnit.MeterOfWaterColumn);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.MeterOfWaterColumn"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Microbar"/>
         /// </summary>
-        public double MetersOfWaterColumn => As(PressureUnit.MeterOfWaterColumn);
+        public QuantityValue Microbars => this.As(PressureUnit.Microbar);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Microbar"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Micropascal"/>
         /// </summary>
-        public double Microbars => As(PressureUnit.Microbar);
+        public QuantityValue Micropascals => this.As(PressureUnit.Micropascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Micropascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Millibar"/>
         /// </summary>
-        public double Micropascals => As(PressureUnit.Micropascal);
+        public QuantityValue Millibars => this.As(PressureUnit.Millibar);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Millibar"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.MilligramForcePerSquareFoot"/>
         /// </summary>
-        public double Millibars => As(PressureUnit.Millibar);
+        public QuantityValue MilligramsForcePerSquareFoot => this.As(PressureUnit.MilligramForcePerSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.MillimeterOfMercury"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.MilligramForcePerSquareMeter"/>
         /// </summary>
-        public double MillimetersOfMercury => As(PressureUnit.MillimeterOfMercury);
+        public QuantityValue MilligramsForcePerSquareMeter => this.As(PressureUnit.MilligramForcePerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.MillimeterOfWaterColumn"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.MillimeterOfMercury"/>
         /// </summary>
-        public double MillimetersOfWaterColumn => As(PressureUnit.MillimeterOfWaterColumn);
+        public QuantityValue MillimetersOfMercury => this.As(PressureUnit.MillimeterOfMercury);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Millipascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.MillimeterOfWaterColumn"/>
         /// </summary>
-        public double Millipascals => As(PressureUnit.Millipascal);
+        public QuantityValue MillimetersOfWaterColumn => this.As(PressureUnit.MillimeterOfWaterColumn);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Millitorr"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Millipascal"/>
         /// </summary>
-        public double Millitorrs => As(PressureUnit.Millitorr);
+        public QuantityValue Millipascals => this.As(PressureUnit.Millipascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.NewtonPerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Millitorr"/>
         /// </summary>
-        public double NewtonsPerSquareCentimeter => As(PressureUnit.NewtonPerSquareCentimeter);
+        public QuantityValue Millitorrs => this.As(PressureUnit.Millitorr);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.NewtonPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.NewtonPerSquareCentimeter"/>
         /// </summary>
-        public double NewtonsPerSquareMeter => As(PressureUnit.NewtonPerSquareMeter);
+        public QuantityValue NewtonsPerSquareCentimeter => this.As(PressureUnit.NewtonPerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.NewtonPerSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.NewtonPerSquareMeter"/>
         /// </summary>
-        public double NewtonsPerSquareMillimeter => As(PressureUnit.NewtonPerSquareMillimeter);
+        public QuantityValue NewtonsPerSquareMeter => this.As(PressureUnit.NewtonPerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Pascal"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.NewtonPerSquareMillimeter"/>
         /// </summary>
-        public double Pascals => As(PressureUnit.Pascal);
+        public QuantityValue NewtonsPerSquareMillimeter => this.As(PressureUnit.NewtonPerSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.PoundForcePerSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Pascal"/>
         /// </summary>
-        public double PoundsForcePerSquareFoot => As(PressureUnit.PoundForcePerSquareFoot);
+        public QuantityValue Pascals => this.As(PressureUnit.Pascal);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.PoundForcePerSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.PoundForcePerSquareFoot"/>
         /// </summary>
-        public double PoundsForcePerSquareInch => As(PressureUnit.PoundForcePerSquareInch);
+        public QuantityValue PoundsForcePerSquareFoot => this.As(PressureUnit.PoundForcePerSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.PoundForcePerSquareMil"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.PoundForcePerSquareInch"/>
         /// </summary>
-        public double PoundsForcePerSquareMil => As(PressureUnit.PoundForcePerSquareMil);
+        public QuantityValue PoundsForcePerSquareInch => this.As(PressureUnit.PoundForcePerSquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.PoundPerInchSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.PoundForcePerSquareMil"/>
         /// </summary>
-        public double PoundsPerInchSecondSquared => As(PressureUnit.PoundPerInchSecondSquared);
+        public QuantityValue PoundsForcePerSquareMil => this.As(PressureUnit.PoundForcePerSquareMil);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.TechnicalAtmosphere"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.PoundPerInchSecondSquared"/>
         /// </summary>
-        public double TechnicalAtmospheres => As(PressureUnit.TechnicalAtmosphere);
+        public QuantityValue PoundsPerInchSecondSquared => this.As(PressureUnit.PoundPerInchSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.TonneForcePerSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.TechnicalAtmosphere"/>
         /// </summary>
-        public double TonnesForcePerSquareCentimeter => As(PressureUnit.TonneForcePerSquareCentimeter);
+        public QuantityValue TechnicalAtmospheres => this.As(PressureUnit.TechnicalAtmosphere);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.TonneForcePerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.TonneForcePerSquareCentimeter"/>
         /// </summary>
-        public double TonnesForcePerSquareMeter => As(PressureUnit.TonneForcePerSquareMeter);
+        public QuantityValue TonnesForcePerSquareCentimeter => this.As(PressureUnit.TonneForcePerSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.TonneForcePerSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.TonneForcePerSquareMeter"/>
         /// </summary>
-        public double TonnesForcePerSquareMillimeter => As(PressureUnit.TonneForcePerSquareMillimeter);
+        public QuantityValue TonnesForcePerSquareMeter => this.As(PressureUnit.TonneForcePerSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureUnit.Torr"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.TonneForcePerSquareMillimeter"/>
         /// </summary>
-        public double Torrs => As(PressureUnit.Torr);
+        public QuantityValue TonnesForcePerSquareMillimeter => this.As(PressureUnit.TonneForcePerSquareMillimeter);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureUnit.Torr"/>
+        /// </summary>
+        public QuantityValue Torrs => this.As(PressureUnit.Torr);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: PressureUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Atmosphere, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Bar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Centibar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.CentimeterOfWaterColumn, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Decapascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Decibar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.DynePerSquareCentimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.FootOfHead, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Gigapascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Hectopascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.InchOfMercury, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.InchOfWaterColumn, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Kilobar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilogramForcePerSquareCentimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilogramForcePerSquareMeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilogramForcePerSquareMillimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilonewtonPerSquareCentimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilonewtonPerSquareMeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilonewtonPerSquareMillimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Kilopascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilopoundForcePerSquareFoot, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilopoundForcePerSquareInch, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.KilopoundForcePerSquareMil, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Megabar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.MeganewtonPerSquareMeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Megapascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.MeterOfHead, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.MeterOfWaterColumn, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Microbar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Micropascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Millibar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.MillimeterOfMercury, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.MillimeterOfWaterColumn, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Millipascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Millitorr, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.NewtonPerSquareCentimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.NewtonPerSquareMeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.NewtonPerSquareMillimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.PoundForcePerSquareFoot, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.PoundForcePerSquareInch, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.PoundForcePerSquareMil, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.PoundPerInchSecondSquared, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.TechnicalAtmosphere, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.TonneForcePerSquareCentimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.TonneForcePerSquareMeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.TonneForcePerSquareMillimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Torr, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Pascal, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> PressureUnit
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Atmosphere, quantity => quantity.ToUnit(PressureUnit.Atmosphere));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Bar, quantity => quantity.ToUnit(PressureUnit.Bar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Centibar, quantity => quantity.ToUnit(PressureUnit.Centibar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.CentimeterOfWaterColumn, quantity => quantity.ToUnit(PressureUnit.CentimeterOfWaterColumn));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Decapascal, quantity => quantity.ToUnit(PressureUnit.Decapascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Decibar, quantity => quantity.ToUnit(PressureUnit.Decibar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.DynePerSquareCentimeter, quantity => quantity.ToUnit(PressureUnit.DynePerSquareCentimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.FootOfHead, quantity => quantity.ToUnit(PressureUnit.FootOfHead));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Gigapascal, quantity => quantity.ToUnit(PressureUnit.Gigapascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Hectopascal, quantity => quantity.ToUnit(PressureUnit.Hectopascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.InchOfMercury, quantity => quantity.ToUnit(PressureUnit.InchOfMercury));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.InchOfWaterColumn, quantity => quantity.ToUnit(PressureUnit.InchOfWaterColumn));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Kilobar, quantity => quantity.ToUnit(PressureUnit.Kilobar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareCentimeter, quantity => quantity.ToUnit(PressureUnit.KilogramForcePerSquareCentimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareMeter, quantity => quantity.ToUnit(PressureUnit.KilogramForcePerSquareMeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareMillimeter, quantity => quantity.ToUnit(PressureUnit.KilogramForcePerSquareMillimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.KilonewtonPerSquareCentimeter, quantity => quantity.ToUnit(PressureUnit.KilonewtonPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.KilonewtonPerSquareMeter, quantity => quantity.ToUnit(PressureUnit.KilonewtonPerSquareMeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.KilonewtonPerSquareMillimeter, quantity => quantity.ToUnit(PressureUnit.KilonewtonPerSquareMillimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Kilopascal, quantity => quantity.ToUnit(PressureUnit.Kilopascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareFoot, quantity => quantity.ToUnit(PressureUnit.KilopoundForcePerSquareFoot));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareInch, quantity => quantity.ToUnit(PressureUnit.KilopoundForcePerSquareInch));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareMil, quantity => quantity.ToUnit(PressureUnit.KilopoundForcePerSquareMil));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Megabar, quantity => quantity.ToUnit(PressureUnit.Megabar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.MeganewtonPerSquareMeter, quantity => quantity.ToUnit(PressureUnit.MeganewtonPerSquareMeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Megapascal, quantity => quantity.ToUnit(PressureUnit.Megapascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.MeterOfHead, quantity => quantity.ToUnit(PressureUnit.MeterOfHead));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.MeterOfWaterColumn, quantity => quantity.ToUnit(PressureUnit.MeterOfWaterColumn));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Microbar, quantity => quantity.ToUnit(PressureUnit.Microbar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Micropascal, quantity => quantity.ToUnit(PressureUnit.Micropascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Millibar, quantity => quantity.ToUnit(PressureUnit.Millibar));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.MillimeterOfMercury, quantity => quantity.ToUnit(PressureUnit.MillimeterOfMercury));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.MillimeterOfWaterColumn, quantity => quantity.ToUnit(PressureUnit.MillimeterOfWaterColumn));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Millipascal, quantity => quantity.ToUnit(PressureUnit.Millipascal));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Millitorr, quantity => quantity.ToUnit(PressureUnit.Millitorr));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.NewtonPerSquareCentimeter, quantity => quantity.ToUnit(PressureUnit.NewtonPerSquareCentimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.NewtonPerSquareMeter, quantity => quantity.ToUnit(PressureUnit.NewtonPerSquareMeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.NewtonPerSquareMillimeter, quantity => quantity.ToUnit(PressureUnit.NewtonPerSquareMillimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.PoundForcePerSquareFoot, quantity => quantity.ToUnit(PressureUnit.PoundForcePerSquareFoot));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.PoundForcePerSquareInch, quantity => quantity.ToUnit(PressureUnit.PoundForcePerSquareInch));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.PoundForcePerSquareMil, quantity => quantity.ToUnit(PressureUnit.PoundForcePerSquareMil));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.PoundPerInchSecondSquared, quantity => quantity.ToUnit(PressureUnit.PoundPerInchSecondSquared));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.TechnicalAtmosphere, quantity => quantity.ToUnit(PressureUnit.TechnicalAtmosphere));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.TonneForcePerSquareCentimeter, quantity => quantity.ToUnit(PressureUnit.TonneForcePerSquareCentimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.TonneForcePerSquareMeter, quantity => quantity.ToUnit(PressureUnit.TonneForcePerSquareMeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.TonneForcePerSquareMillimeter, quantity => quantity.ToUnit(PressureUnit.TonneForcePerSquareMillimeter));
-            unitConverter.SetConversionFunction<Pressure>(PressureUnit.Pascal, PressureUnit.Torr, quantity => quantity.ToUnit(PressureUnit.Torr));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -660,7 +664,7 @@ public static string GetAbbreviation(PressureUnit unit, IFormatProvider? provide
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Atmosphere"/>.
         /// </summary>
-        public static Pressure FromAtmospheres(double value)
+        public static Pressure FromAtmospheres(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Atmosphere);
         }
@@ -668,7 +672,7 @@ public static Pressure FromAtmospheres(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Bar"/>.
         /// </summary>
-        public static Pressure FromBars(double value)
+        public static Pressure FromBars(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Bar);
         }
@@ -676,7 +680,7 @@ public static Pressure FromBars(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Centibar"/>.
         /// </summary>
-        public static Pressure FromCentibars(double value)
+        public static Pressure FromCentibars(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Centibar);
         }
@@ -684,7 +688,7 @@ public static Pressure FromCentibars(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.CentimeterOfWaterColumn"/>.
         /// </summary>
-        public static Pressure FromCentimetersOfWaterColumn(double value)
+        public static Pressure FromCentimetersOfWaterColumn(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.CentimeterOfWaterColumn);
         }
@@ -692,7 +696,7 @@ public static Pressure FromCentimetersOfWaterColumn(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Decapascal"/>.
         /// </summary>
-        public static Pressure FromDecapascals(double value)
+        public static Pressure FromDecapascals(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Decapascal);
         }
@@ -700,7 +704,7 @@ public static Pressure FromDecapascals(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Decibar"/>.
         /// </summary>
-        public static Pressure FromDecibars(double value)
+        public static Pressure FromDecibars(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Decibar);
         }
@@ -708,7 +712,7 @@ public static Pressure FromDecibars(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.DynePerSquareCentimeter"/>.
         /// </summary>
-        public static Pressure FromDynesPerSquareCentimeter(double value)
+        public static Pressure FromDynesPerSquareCentimeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.DynePerSquareCentimeter);
         }
@@ -716,7 +720,7 @@ public static Pressure FromDynesPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.FootOfHead"/>.
         /// </summary>
-        public static Pressure FromFeetOfHead(double value)
+        public static Pressure FromFeetOfHead(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.FootOfHead);
         }
@@ -724,7 +728,7 @@ public static Pressure FromFeetOfHead(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Gigapascal"/>.
         /// </summary>
-        public static Pressure FromGigapascals(double value)
+        public static Pressure FromGigapascals(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Gigapascal);
         }
@@ -732,7 +736,7 @@ public static Pressure FromGigapascals(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Hectopascal"/>.
         /// </summary>
-        public static Pressure FromHectopascals(double value)
+        public static Pressure FromHectopascals(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Hectopascal);
         }
@@ -740,7 +744,7 @@ public static Pressure FromHectopascals(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.InchOfMercury"/>.
         /// </summary>
-        public static Pressure FromInchesOfMercury(double value)
+        public static Pressure FromInchesOfMercury(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.InchOfMercury);
         }
@@ -748,7 +752,7 @@ public static Pressure FromInchesOfMercury(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.InchOfWaterColumn"/>.
         /// </summary>
-        public static Pressure FromInchesOfWaterColumn(double value)
+        public static Pressure FromInchesOfWaterColumn(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.InchOfWaterColumn);
         }
@@ -756,7 +760,7 @@ public static Pressure FromInchesOfWaterColumn(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Kilobar"/>.
         /// </summary>
-        public static Pressure FromKilobars(double value)
+        public static Pressure FromKilobars(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Kilobar);
         }
@@ -764,7 +768,7 @@ public static Pressure FromKilobars(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareCentimeter"/>.
         /// </summary>
-        public static Pressure FromKilogramsForcePerSquareCentimeter(double value)
+        public static Pressure FromKilogramsForcePerSquareCentimeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.KilogramForcePerSquareCentimeter);
         }
@@ -772,7 +776,7 @@ public static Pressure FromKilogramsForcePerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareMeter"/>.
         /// </summary>
-        public static Pressure FromKilogramsForcePerSquareMeter(double value)
+        public static Pressure FromKilogramsForcePerSquareMeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.KilogramForcePerSquareMeter);
         }
@@ -780,7 +784,7 @@ public static Pressure FromKilogramsForcePerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareMillimeter"/>.
         /// </summary>
-        public static Pressure FromKilogramsForcePerSquareMillimeter(double value)
+        public static Pressure FromKilogramsForcePerSquareMillimeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.KilogramForcePerSquareMillimeter);
         }
@@ -788,7 +792,7 @@ public static Pressure FromKilogramsForcePerSquareMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareCentimeter"/>.
         /// </summary>
-        public static Pressure FromKilonewtonsPerSquareCentimeter(double value)
+        public static Pressure FromKilonewtonsPerSquareCentimeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.KilonewtonPerSquareCentimeter);
         }
@@ -796,7 +800,7 @@ public static Pressure FromKilonewtonsPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareMeter"/>.
         /// </summary>
-        public static Pressure FromKilonewtonsPerSquareMeter(double value)
+        public static Pressure FromKilonewtonsPerSquareMeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.KilonewtonPerSquareMeter);
         }
@@ -804,7 +808,7 @@ public static Pressure FromKilonewtonsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareMillimeter"/>.
         /// </summary>
-        public static Pressure FromKilonewtonsPerSquareMillimeter(double value)
+        public static Pressure FromKilonewtonsPerSquareMillimeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.KilonewtonPerSquareMillimeter);
         }
@@ -812,7 +816,7 @@ public static Pressure FromKilonewtonsPerSquareMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Kilopascal"/>.
         /// </summary>
-        public static Pressure FromKilopascals(double value)
+        public static Pressure FromKilopascals(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Kilopascal);
         }
@@ -820,7 +824,7 @@ public static Pressure FromKilopascals(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareFoot"/>.
         /// </summary>
-        public static Pressure FromKilopoundsForcePerSquareFoot(double value)
+        public static Pressure FromKilopoundsForcePerSquareFoot(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.KilopoundForcePerSquareFoot);
         }
@@ -828,7 +832,7 @@ public static Pressure FromKilopoundsForcePerSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareInch"/>.
         /// </summary>
-        public static Pressure FromKilopoundsForcePerSquareInch(double value)
+        public static Pressure FromKilopoundsForcePerSquareInch(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.KilopoundForcePerSquareInch);
         }
@@ -836,7 +840,7 @@ public static Pressure FromKilopoundsForcePerSquareInch(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareMil"/>.
         /// </summary>
-        public static Pressure FromKilopoundsForcePerSquareMil(double value)
+        public static Pressure FromKilopoundsForcePerSquareMil(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.KilopoundForcePerSquareMil);
         }
@@ -844,7 +848,7 @@ public static Pressure FromKilopoundsForcePerSquareMil(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Megabar"/>.
         /// </summary>
-        public static Pressure FromMegabars(double value)
+        public static Pressure FromMegabars(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Megabar);
         }
@@ -852,7 +856,7 @@ public static Pressure FromMegabars(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeganewtonPerSquareMeter"/>.
         /// </summary>
-        public static Pressure FromMeganewtonsPerSquareMeter(double value)
+        public static Pressure FromMeganewtonsPerSquareMeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.MeganewtonPerSquareMeter);
         }
@@ -860,7 +864,7 @@ public static Pressure FromMeganewtonsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Megapascal"/>.
         /// </summary>
-        public static Pressure FromMegapascals(double value)
+        public static Pressure FromMegapascals(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Megapascal);
         }
@@ -868,7 +872,7 @@ public static Pressure FromMegapascals(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeterOfHead"/>.
         /// </summary>
-        public static Pressure FromMetersOfHead(double value)
+        public static Pressure FromMetersOfHead(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.MeterOfHead);
         }
@@ -876,7 +880,7 @@ public static Pressure FromMetersOfHead(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeterOfWaterColumn"/>.
         /// </summary>
-        public static Pressure FromMetersOfWaterColumn(double value)
+        public static Pressure FromMetersOfWaterColumn(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.MeterOfWaterColumn);
         }
@@ -884,7 +888,7 @@ public static Pressure FromMetersOfWaterColumn(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Microbar"/>.
         /// </summary>
-        public static Pressure FromMicrobars(double value)
+        public static Pressure FromMicrobars(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Microbar);
         }
@@ -892,7 +896,7 @@ public static Pressure FromMicrobars(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Micropascal"/>.
         /// </summary>
-        public static Pressure FromMicropascals(double value)
+        public static Pressure FromMicropascals(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Micropascal);
         }
@@ -900,15 +904,31 @@ public static Pressure FromMicropascals(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Millibar"/>.
         /// </summary>
-        public static Pressure FromMillibars(double value)
+        public static Pressure FromMillibars(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Millibar);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MilligramForcePerSquareFoot"/>.
+        /// </summary>
+        public static Pressure FromMilligramsForcePerSquareFoot(QuantityValue value)
+        {
+            return new Pressure(value, PressureUnit.MilligramForcePerSquareFoot);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MilligramForcePerSquareMeter"/>.
+        /// </summary>
+        public static Pressure FromMilligramsForcePerSquareMeter(QuantityValue value)
+        {
+            return new Pressure(value, PressureUnit.MilligramForcePerSquareMeter);
+        }
+
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MillimeterOfMercury"/>.
         /// </summary>
-        public static Pressure FromMillimetersOfMercury(double value)
+        public static Pressure FromMillimetersOfMercury(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.MillimeterOfMercury);
         }
@@ -916,7 +936,7 @@ public static Pressure FromMillimetersOfMercury(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MillimeterOfWaterColumn"/>.
         /// </summary>
-        public static Pressure FromMillimetersOfWaterColumn(double value)
+        public static Pressure FromMillimetersOfWaterColumn(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.MillimeterOfWaterColumn);
         }
@@ -924,7 +944,7 @@ public static Pressure FromMillimetersOfWaterColumn(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Millipascal"/>.
         /// </summary>
-        public static Pressure FromMillipascals(double value)
+        public static Pressure FromMillipascals(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Millipascal);
         }
@@ -932,7 +952,7 @@ public static Pressure FromMillipascals(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Millitorr"/>.
         /// </summary>
-        public static Pressure FromMillitorrs(double value)
+        public static Pressure FromMillitorrs(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Millitorr);
         }
@@ -940,7 +960,7 @@ public static Pressure FromMillitorrs(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareCentimeter"/>.
         /// </summary>
-        public static Pressure FromNewtonsPerSquareCentimeter(double value)
+        public static Pressure FromNewtonsPerSquareCentimeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.NewtonPerSquareCentimeter);
         }
@@ -948,7 +968,7 @@ public static Pressure FromNewtonsPerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareMeter"/>.
         /// </summary>
-        public static Pressure FromNewtonsPerSquareMeter(double value)
+        public static Pressure FromNewtonsPerSquareMeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.NewtonPerSquareMeter);
         }
@@ -956,7 +976,7 @@ public static Pressure FromNewtonsPerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareMillimeter"/>.
         /// </summary>
-        public static Pressure FromNewtonsPerSquareMillimeter(double value)
+        public static Pressure FromNewtonsPerSquareMillimeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.NewtonPerSquareMillimeter);
         }
@@ -964,7 +984,7 @@ public static Pressure FromNewtonsPerSquareMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Pascal"/>.
         /// </summary>
-        public static Pressure FromPascals(double value)
+        public static Pressure FromPascals(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Pascal);
         }
@@ -972,7 +992,7 @@ public static Pressure FromPascals(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareFoot"/>.
         /// </summary>
-        public static Pressure FromPoundsForcePerSquareFoot(double value)
+        public static Pressure FromPoundsForcePerSquareFoot(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.PoundForcePerSquareFoot);
         }
@@ -980,7 +1000,7 @@ public static Pressure FromPoundsForcePerSquareFoot(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareInch"/>.
         /// </summary>
-        public static Pressure FromPoundsForcePerSquareInch(double value)
+        public static Pressure FromPoundsForcePerSquareInch(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.PoundForcePerSquareInch);
         }
@@ -988,7 +1008,7 @@ public static Pressure FromPoundsForcePerSquareInch(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareMil"/>.
         /// </summary>
-        public static Pressure FromPoundsForcePerSquareMil(double value)
+        public static Pressure FromPoundsForcePerSquareMil(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.PoundForcePerSquareMil);
         }
@@ -996,7 +1016,7 @@ public static Pressure FromPoundsForcePerSquareMil(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundPerInchSecondSquared"/>.
         /// </summary>
-        public static Pressure FromPoundsPerInchSecondSquared(double value)
+        public static Pressure FromPoundsPerInchSecondSquared(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.PoundPerInchSecondSquared);
         }
@@ -1004,7 +1024,7 @@ public static Pressure FromPoundsPerInchSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TechnicalAtmosphere"/>.
         /// </summary>
-        public static Pressure FromTechnicalAtmospheres(double value)
+        public static Pressure FromTechnicalAtmospheres(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.TechnicalAtmosphere);
         }
@@ -1012,7 +1032,7 @@ public static Pressure FromTechnicalAtmospheres(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareCentimeter"/>.
         /// </summary>
-        public static Pressure FromTonnesForcePerSquareCentimeter(double value)
+        public static Pressure FromTonnesForcePerSquareCentimeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.TonneForcePerSquareCentimeter);
         }
@@ -1020,7 +1040,7 @@ public static Pressure FromTonnesForcePerSquareCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareMeter"/>.
         /// </summary>
-        public static Pressure FromTonnesForcePerSquareMeter(double value)
+        public static Pressure FromTonnesForcePerSquareMeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.TonneForcePerSquareMeter);
         }
@@ -1028,7 +1048,7 @@ public static Pressure FromTonnesForcePerSquareMeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareMillimeter"/>.
         /// </summary>
-        public static Pressure FromTonnesForcePerSquareMillimeter(double value)
+        public static Pressure FromTonnesForcePerSquareMillimeter(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.TonneForcePerSquareMillimeter);
         }
@@ -1036,7 +1056,7 @@ public static Pressure FromTonnesForcePerSquareMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Torr"/>.
         /// </summary>
-        public static Pressure FromTorrs(double value)
+        public static Pressure FromTorrs(QuantityValue value)
         {
             return new Pressure(value, PressureUnit.Torr);
         }
@@ -1047,7 +1067,7 @@ public static Pressure FromTorrs(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Pressure unit value.</returns>
-        public static Pressure From(double value, PressureUnit fromUnit)
+        public static Pressure From(QuantityValue value, PressureUnit fromUnit)
         {
             return new Pressure(value, fromUnit);
         }
@@ -1108,10 +1128,7 @@ public static Pressure Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Pressure Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Pressure, PressureUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Pressure, PressureUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -1139,11 +1156,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Pressure result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Pressure result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Pressure, PressureUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Pressure, PressureUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -1164,7 +1177,7 @@ public static PressureUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1175,7 +1188,7 @@ public static PressureUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PressureUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.PressureUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out PressureUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1190,7 +1203,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PressureUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out PressureUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1209,35 +1222,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Pressure"/> from adding two <see cref="Pressure"/>.</summary>
         public static Pressure operator +(Pressure left, Pressure right)
         {
-            return new Pressure(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Pressure(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Pressure"/> from subtracting two <see cref="Pressure"/>.</summary>
         public static Pressure operator -(Pressure left, Pressure right)
         {
-            return new Pressure(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Pressure(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Pressure"/> from multiplying value and <see cref="Pressure"/>.</summary>
-        public static Pressure operator *(double left, Pressure right)
+        public static Pressure operator *(QuantityValue left, Pressure right)
         {
             return new Pressure(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Pressure"/> from multiplying value and <see cref="Pressure"/>.</summary>
-        public static Pressure operator *(Pressure left, double right)
+        public static Pressure operator *(Pressure left, QuantityValue right)
         {
             return new Pressure(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Pressure"/> from dividing <see cref="Pressure"/> by value.</summary>
-        public static Pressure operator /(Pressure left, double right)
+        public static Pressure operator /(Pressure left, QuantityValue right)
         {
             return new Pressure(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Pressure"/> by <see cref="Pressure"/>.</summary>
-        public static double operator /(Pressure left, Pressure right)
+        public static QuantityValue operator /(Pressure left, Pressure right)
         {
             return left.Pascals / right.Pascals;
         }
@@ -1246,12 +1259,30 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="Acceleration"/> from <see cref="Pressure"/> / <see cref="AreaDensity"/>.</summary>
+        public static Acceleration operator /(Pressure pressure, AreaDensity areaDensity)
+        {
+            return Acceleration.FromMetersPerSecondSquared(pressure.Pascals / areaDensity.KilogramsPerSquareMeter);
+        }
+
+        /// <summary>Get <see cref="AreaDensity"/> from <see cref="Pressure"/> / <see cref="Acceleration"/>.</summary>
+        public static AreaDensity operator /(Pressure pressure, Acceleration acceleration)
+        {
+            return AreaDensity.FromKilogramsPerSquareMeter(pressure.Pascals / acceleration.MetersPerSecondSquared);
+        }
+
         /// <summary>Get <see cref="Duration"/> from <see cref="Pressure"/> / <see cref="PressureChangeRate"/>.</summary>
         public static Duration operator /(Pressure pressure, PressureChangeRate pressureChangeRate)
         {
             return Duration.FromSeconds(pressure.Pascals / pressureChangeRate.PascalsPerSecond);
         }
 
+        /// <summary>Get <see cref="FluidResistance"/> from <see cref="Pressure"/> / <see cref="VolumeFlow"/>.</summary>
+        public static FluidResistance operator /(Pressure pressure, VolumeFlow volumeFlow)
+        {
+            return FluidResistance.FromPascalSecondsPerCubicMeter(pressure.Pascals / volumeFlow.CubicMetersPerSecond);
+        }
+
         /// <summary>Get <see cref="Force"/> from <see cref="Pressure"/> / <see cref="ReciprocalArea"/>.</summary>
         public static Force operator /(Pressure pressure, ReciprocalArea reciprocalArea)
         {
@@ -1276,6 +1307,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return ForcePerLength.FromNewtonsPerMeter(pressure.NewtonsPerSquareMeter / reciprocalLength.InverseMeters);
         }
 
+        /// <summary>Get <see cref="LeakRate"/> from <see cref="Pressure"/> * <see cref="VolumeFlow"/>.</summary>
+        public static LeakRate operator *(Pressure pressure, VolumeFlow volumeFlow)
+        {
+            return LeakRate.FromPascalCubicMetersPerSecond(pressure.Pascals * volumeFlow.CubicMetersPerSecond);
+        }
+
         /// <summary>Get <see cref="Length"/> from <see cref="Pressure"/> / <see cref="SpecificWeight"/>.</summary>
         public static Length operator /(Pressure pressure, SpecificWeight specificWeight)
         {
@@ -1288,6 +1325,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return PressureChangeRate.FromPascalsPerSecond(pressure.Pascals / duration.Seconds);
         }
 
+        /// <summary>Get <see cref="Ratio"/> from <see cref="Pressure"/> * <see cref="Compressibility"/>.</summary>
+        public static Ratio operator *(Pressure pressure, Compressibility compressibility)
+        {
+            return Ratio.FromDecimalFractions(pressure.Pascals * compressibility.InversePascals);
+        }
+
         /// <summary>Get <see cref="ReciprocalArea"/> from <see cref="Pressure"/> / <see cref="Force"/>.</summary>
         public static ReciprocalArea operator /(Pressure pressure, Force force)
         {
@@ -1306,6 +1349,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return SpecificWeight.FromNewtonsPerCubicMeter(pressure.Pascals / length.Meters);
         }
 
+        /// <summary>Get <see cref="VolumeFlow"/> from <see cref="Pressure"/> / <see cref="FluidResistance"/>.</summary>
+        public static VolumeFlow operator /(Pressure pressure, FluidResistance fluidResistance)
+        {
+            return VolumeFlow.FromCubicMetersPerSecond(pressure.Pascals / fluidResistance.PascalSecondsPerCubicMeter);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -1313,97 +1362,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Pressure left, Pressure right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Pressure left, Pressure right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Pressure left, Pressure right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Pressure left, Pressure right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Pressure"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Pressure other, Pressure tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Pressure"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Pressure)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Pressure left, Pressure right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Pressure"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Pressure other, Pressure tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Pressure"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Pressure,Pressure)"/>.
+        ///     See that operator (and <see cref="Equals(Pressure)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Pressure left, Pressure right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Pressure"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Pressure other, Pressure tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Pressure"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Pressure"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Pressure"/>, this method delegates to
+        ///     <see cref="Equals(Pressure)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Pressure otherQuantity))
+            if (obj is not Pressure otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Pressure"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Pressure other, Pressure tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Pressure"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Pressure other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Pressure.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Pressure), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Pressure"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Pressure)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Pressure otherQuantity)) throw new ArgumentException("Expected type Pressure.", nameof(obj));
+            if (obj is not Pressure otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Pressure>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Pressure"/> with another <see cref="Pressure"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Pressure"/> with another <see cref="Pressure"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1415,223 +1478,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Pressure other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(PressureUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<PressureUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Pressure to another Pressure with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Pressure with the specified unit.</returns>
-        public Pressure ToUnit(PressureUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Pressure"/> to another <see cref="Pressure"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Pressure with the specified unit.</returns>
-        public Pressure ToUnit(PressureUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Pressure), Unit, typeof(Pressure), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Pressure)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Pressure"/> to another <see cref="Pressure"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Pressure"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(PressureUnit unit, [NotNullWhen(true)] out Pressure? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Pressure? convertedOrNull = (Unit, unit) switch
-            {
-                // PressureUnit -> BaseUnit
-                (PressureUnit.Atmosphere, PressureUnit.Pascal) => new Pressure(_value * 1.01325 * 1e5, PressureUnit.Pascal),
-                (PressureUnit.Bar, PressureUnit.Pascal) => new Pressure(_value * 1e5, PressureUnit.Pascal),
-                (PressureUnit.Centibar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e-2d, PressureUnit.Pascal),
-                (PressureUnit.CentimeterOfWaterColumn, PressureUnit.Pascal) => new Pressure((_value * 9.80665e3) * 1e-2d, PressureUnit.Pascal),
-                (PressureUnit.Decapascal, PressureUnit.Pascal) => new Pressure((_value) * 1e1d, PressureUnit.Pascal),
-                (PressureUnit.Decibar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e-1d, PressureUnit.Pascal),
-                (PressureUnit.DynePerSquareCentimeter, PressureUnit.Pascal) => new Pressure(_value * 1.0e-1, PressureUnit.Pascal),
-                (PressureUnit.FootOfHead, PressureUnit.Pascal) => new Pressure(_value * 9804.139432 * 0.3048, PressureUnit.Pascal),
-                (PressureUnit.Gigapascal, PressureUnit.Pascal) => new Pressure((_value) * 1e9d, PressureUnit.Pascal),
-                (PressureUnit.Hectopascal, PressureUnit.Pascal) => new Pressure((_value) * 1e2d, PressureUnit.Pascal),
-                (PressureUnit.InchOfMercury, PressureUnit.Pascal) => new Pressure(_value * 2.54e1 * 133.322387415, PressureUnit.Pascal),
-                (PressureUnit.InchOfWaterColumn, PressureUnit.Pascal) => new Pressure(_value * 2.54e-2 * 9.80665e3, PressureUnit.Pascal),
-                (PressureUnit.Kilobar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e3d, PressureUnit.Pascal),
-                (PressureUnit.KilogramForcePerSquareCentimeter, PressureUnit.Pascal) => new Pressure(_value * 9.80665e4, PressureUnit.Pascal),
-                (PressureUnit.KilogramForcePerSquareMeter, PressureUnit.Pascal) => new Pressure(_value * 9.80665, PressureUnit.Pascal),
-                (PressureUnit.KilogramForcePerSquareMillimeter, PressureUnit.Pascal) => new Pressure(_value * 9.80665e6, PressureUnit.Pascal),
-                (PressureUnit.KilonewtonPerSquareCentimeter, PressureUnit.Pascal) => new Pressure((_value * 1e4) * 1e3d, PressureUnit.Pascal),
-                (PressureUnit.KilonewtonPerSquareMeter, PressureUnit.Pascal) => new Pressure((_value) * 1e3d, PressureUnit.Pascal),
-                (PressureUnit.KilonewtonPerSquareMillimeter, PressureUnit.Pascal) => new Pressure((_value * 1e6) * 1e3d, PressureUnit.Pascal),
-                (PressureUnit.Kilopascal, PressureUnit.Pascal) => new Pressure((_value) * 1e3d, PressureUnit.Pascal),
-                (PressureUnit.KilopoundForcePerSquareFoot, PressureUnit.Pascal) => new Pressure((_value * 4.4482216152605 / 9.290304e-2) * 1e3d, PressureUnit.Pascal),
-                (PressureUnit.KilopoundForcePerSquareInch, PressureUnit.Pascal) => new Pressure((_value * 4.4482216152605 / 0.00064516) * 1e3d, PressureUnit.Pascal),
-                (PressureUnit.KilopoundForcePerSquareMil, PressureUnit.Pascal) => new Pressure((_value * 4.4482216152605 / (2.54e-5 * 2.54e-5)) * 1e3d, PressureUnit.Pascal),
-                (PressureUnit.Megabar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e6d, PressureUnit.Pascal),
-                (PressureUnit.MeganewtonPerSquareMeter, PressureUnit.Pascal) => new Pressure((_value) * 1e6d, PressureUnit.Pascal),
-                (PressureUnit.Megapascal, PressureUnit.Pascal) => new Pressure((_value) * 1e6d, PressureUnit.Pascal),
-                (PressureUnit.MeterOfHead, PressureUnit.Pascal) => new Pressure(_value * 9804.139432, PressureUnit.Pascal),
-                (PressureUnit.MeterOfWaterColumn, PressureUnit.Pascal) => new Pressure(_value * 9.80665e3, PressureUnit.Pascal),
-                (PressureUnit.Microbar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e-6d, PressureUnit.Pascal),
-                (PressureUnit.Micropascal, PressureUnit.Pascal) => new Pressure((_value) * 1e-6d, PressureUnit.Pascal),
-                (PressureUnit.Millibar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e-3d, PressureUnit.Pascal),
-                (PressureUnit.MillimeterOfMercury, PressureUnit.Pascal) => new Pressure(_value * 133.322387415, PressureUnit.Pascal),
-                (PressureUnit.MillimeterOfWaterColumn, PressureUnit.Pascal) => new Pressure((_value * 9.80665e3) * 1e-3d, PressureUnit.Pascal),
-                (PressureUnit.Millipascal, PressureUnit.Pascal) => new Pressure((_value) * 1e-3d, PressureUnit.Pascal),
-                (PressureUnit.Millitorr, PressureUnit.Pascal) => new Pressure((_value * 101325 / 760) * 1e-3d, PressureUnit.Pascal),
-                (PressureUnit.NewtonPerSquareCentimeter, PressureUnit.Pascal) => new Pressure(_value * 1e4, PressureUnit.Pascal),
-                (PressureUnit.NewtonPerSquareMeter, PressureUnit.Pascal) => new Pressure(_value, PressureUnit.Pascal),
-                (PressureUnit.NewtonPerSquareMillimeter, PressureUnit.Pascal) => new Pressure(_value * 1e6, PressureUnit.Pascal),
-                (PressureUnit.PoundForcePerSquareFoot, PressureUnit.Pascal) => new Pressure(_value * 4.4482216152605 / 9.290304e-2, PressureUnit.Pascal),
-                (PressureUnit.PoundForcePerSquareInch, PressureUnit.Pascal) => new Pressure(_value * 4.4482216152605 / 0.00064516, PressureUnit.Pascal),
-                (PressureUnit.PoundForcePerSquareMil, PressureUnit.Pascal) => new Pressure(_value * 4.4482216152605 / (2.54e-5 * 2.54e-5), PressureUnit.Pascal),
-                (PressureUnit.PoundPerInchSecondSquared, PressureUnit.Pascal) => new Pressure(_value * (4.4482216152605 / 0.00064516) / 386.0886, PressureUnit.Pascal),
-                (PressureUnit.TechnicalAtmosphere, PressureUnit.Pascal) => new Pressure(_value * 9.80665e4, PressureUnit.Pascal),
-                (PressureUnit.TonneForcePerSquareCentimeter, PressureUnit.Pascal) => new Pressure(_value * 9.80665e7, PressureUnit.Pascal),
-                (PressureUnit.TonneForcePerSquareMeter, PressureUnit.Pascal) => new Pressure(_value * 9.80665e3, PressureUnit.Pascal),
-                (PressureUnit.TonneForcePerSquareMillimeter, PressureUnit.Pascal) => new Pressure(_value * 9.80665e9, PressureUnit.Pascal),
-                (PressureUnit.Torr, PressureUnit.Pascal) => new Pressure(_value * 101325 / 760, PressureUnit.Pascal),
-
-                // BaseUnit -> PressureUnit
-                (PressureUnit.Pascal, PressureUnit.Atmosphere) => new Pressure(_value / (1.01325 * 1e5), PressureUnit.Atmosphere),
-                (PressureUnit.Pascal, PressureUnit.Bar) => new Pressure(_value / 1e5, PressureUnit.Bar),
-                (PressureUnit.Pascal, PressureUnit.Centibar) => new Pressure((_value / 1e5) / 1e-2d, PressureUnit.Centibar),
-                (PressureUnit.Pascal, PressureUnit.CentimeterOfWaterColumn) => new Pressure((_value / 9.80665e3) / 1e-2d, PressureUnit.CentimeterOfWaterColumn),
-                (PressureUnit.Pascal, PressureUnit.Decapascal) => new Pressure((_value) / 1e1d, PressureUnit.Decapascal),
-                (PressureUnit.Pascal, PressureUnit.Decibar) => new Pressure((_value / 1e5) / 1e-1d, PressureUnit.Decibar),
-                (PressureUnit.Pascal, PressureUnit.DynePerSquareCentimeter) => new Pressure(_value / 1.0e-1, PressureUnit.DynePerSquareCentimeter),
-                (PressureUnit.Pascal, PressureUnit.FootOfHead) => new Pressure(_value / (9804.139432 * 0.3048), PressureUnit.FootOfHead),
-                (PressureUnit.Pascal, PressureUnit.Gigapascal) => new Pressure((_value) / 1e9d, PressureUnit.Gigapascal),
-                (PressureUnit.Pascal, PressureUnit.Hectopascal) => new Pressure((_value) / 1e2d, PressureUnit.Hectopascal),
-                (PressureUnit.Pascal, PressureUnit.InchOfMercury) => new Pressure(_value / (2.54e1 * 133.322387415), PressureUnit.InchOfMercury),
-                (PressureUnit.Pascal, PressureUnit.InchOfWaterColumn) => new Pressure(_value / (2.54e-2 * 9.80665e3), PressureUnit.InchOfWaterColumn),
-                (PressureUnit.Pascal, PressureUnit.Kilobar) => new Pressure((_value / 1e5) / 1e3d, PressureUnit.Kilobar),
-                (PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareCentimeter) => new Pressure(_value / 9.80665e4, PressureUnit.KilogramForcePerSquareCentimeter),
-                (PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareMeter) => new Pressure(_value / 9.80665, PressureUnit.KilogramForcePerSquareMeter),
-                (PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareMillimeter) => new Pressure(_value / 9.80665e6, PressureUnit.KilogramForcePerSquareMillimeter),
-                (PressureUnit.Pascal, PressureUnit.KilonewtonPerSquareCentimeter) => new Pressure((_value / 1e4) / 1e3d, PressureUnit.KilonewtonPerSquareCentimeter),
-                (PressureUnit.Pascal, PressureUnit.KilonewtonPerSquareMeter) => new Pressure((_value) / 1e3d, PressureUnit.KilonewtonPerSquareMeter),
-                (PressureUnit.Pascal, PressureUnit.KilonewtonPerSquareMillimeter) => new Pressure((_value / 1e6) / 1e3d, PressureUnit.KilonewtonPerSquareMillimeter),
-                (PressureUnit.Pascal, PressureUnit.Kilopascal) => new Pressure((_value) / 1e3d, PressureUnit.Kilopascal),
-                (PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareFoot) => new Pressure((_value * 9.290304e-2 / 4.4482216152605) / 1e3d, PressureUnit.KilopoundForcePerSquareFoot),
-                (PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareInch) => new Pressure((_value * 0.00064516 / 4.4482216152605) / 1e3d, PressureUnit.KilopoundForcePerSquareInch),
-                (PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareMil) => new Pressure((_value * (2.54e-5 * 2.54e-5) / 4.4482216152605) / 1e3d, PressureUnit.KilopoundForcePerSquareMil),
-                (PressureUnit.Pascal, PressureUnit.Megabar) => new Pressure((_value / 1e5) / 1e6d, PressureUnit.Megabar),
-                (PressureUnit.Pascal, PressureUnit.MeganewtonPerSquareMeter) => new Pressure((_value) / 1e6d, PressureUnit.MeganewtonPerSquareMeter),
-                (PressureUnit.Pascal, PressureUnit.Megapascal) => new Pressure((_value) / 1e6d, PressureUnit.Megapascal),
-                (PressureUnit.Pascal, PressureUnit.MeterOfHead) => new Pressure(_value / 9804.139432, PressureUnit.MeterOfHead),
-                (PressureUnit.Pascal, PressureUnit.MeterOfWaterColumn) => new Pressure(_value / 9.80665e3, PressureUnit.MeterOfWaterColumn),
-                (PressureUnit.Pascal, PressureUnit.Microbar) => new Pressure((_value / 1e5) / 1e-6d, PressureUnit.Microbar),
-                (PressureUnit.Pascal, PressureUnit.Micropascal) => new Pressure((_value) / 1e-6d, PressureUnit.Micropascal),
-                (PressureUnit.Pascal, PressureUnit.Millibar) => new Pressure((_value / 1e5) / 1e-3d, PressureUnit.Millibar),
-                (PressureUnit.Pascal, PressureUnit.MillimeterOfMercury) => new Pressure(_value / 133.322387415, PressureUnit.MillimeterOfMercury),
-                (PressureUnit.Pascal, PressureUnit.MillimeterOfWaterColumn) => new Pressure((_value / 9.80665e3) / 1e-3d, PressureUnit.MillimeterOfWaterColumn),
-                (PressureUnit.Pascal, PressureUnit.Millipascal) => new Pressure((_value) / 1e-3d, PressureUnit.Millipascal),
-                (PressureUnit.Pascal, PressureUnit.Millitorr) => new Pressure((_value * 760 / 101325) / 1e-3d, PressureUnit.Millitorr),
-                (PressureUnit.Pascal, PressureUnit.NewtonPerSquareCentimeter) => new Pressure(_value / 1e4, PressureUnit.NewtonPerSquareCentimeter),
-                (PressureUnit.Pascal, PressureUnit.NewtonPerSquareMeter) => new Pressure(_value, PressureUnit.NewtonPerSquareMeter),
-                (PressureUnit.Pascal, PressureUnit.NewtonPerSquareMillimeter) => new Pressure(_value / 1e6, PressureUnit.NewtonPerSquareMillimeter),
-                (PressureUnit.Pascal, PressureUnit.PoundForcePerSquareFoot) => new Pressure(_value * 9.290304e-2 / 4.4482216152605, PressureUnit.PoundForcePerSquareFoot),
-                (PressureUnit.Pascal, PressureUnit.PoundForcePerSquareInch) => new Pressure(_value * 0.00064516 / 4.4482216152605, PressureUnit.PoundForcePerSquareInch),
-                (PressureUnit.Pascal, PressureUnit.PoundForcePerSquareMil) => new Pressure(_value * (2.54e-5 * 2.54e-5) / 4.4482216152605, PressureUnit.PoundForcePerSquareMil),
-                (PressureUnit.Pascal, PressureUnit.PoundPerInchSecondSquared) => new Pressure(_value * 386.0886 / (4.4482216152605 / 0.00064516), PressureUnit.PoundPerInchSecondSquared),
-                (PressureUnit.Pascal, PressureUnit.TechnicalAtmosphere) => new Pressure(_value / 9.80665e4, PressureUnit.TechnicalAtmosphere),
-                (PressureUnit.Pascal, PressureUnit.TonneForcePerSquareCentimeter) => new Pressure(_value / 9.80665e7, PressureUnit.TonneForcePerSquareCentimeter),
-                (PressureUnit.Pascal, PressureUnit.TonneForcePerSquareMeter) => new Pressure(_value / 9.80665e3, PressureUnit.TonneForcePerSquareMeter),
-                (PressureUnit.Pascal, PressureUnit.TonneForcePerSquareMillimeter) => new Pressure(_value / 9.80665e9, PressureUnit.TonneForcePerSquareMillimeter),
-                (PressureUnit.Pascal, PressureUnit.Torr) => new Pressure(_value * 760 / 101325, PressureUnit.Torr),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not PressureUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is PressureUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<PressureUnit> IQuantity<PressureUnit>.ToUnit(PressureUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1645,11 +1494,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
index 2d54c32e54..e25c55fafd 100644
--- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Pressure change rate is the ratio of the pressure change to the time during which the change occurred (value of pressure changes per unit time).
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct PressureChangeRate :
-        IArithmeticQuantity<PressureChangeRate, PressureChangeRateUnit>,
+        ILinearQuantity<PressureChangeRate, PressureChangeRateUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<PressureChangeRate, PressureChangeRate, double>,
+        IDivisionOperators<PressureChangeRate, PressureChangeRate, QuantityValue>,
         IMultiplyOperators<PressureChangeRate, Duration, Pressure>,
         IComparisonOperators<PressureChangeRate, PressureChangeRate, bool>,
         IParsable<PressureChangeRate>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static PressureChangeRateInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="PressureChangeRate"/> is [T^-3][L^-1][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="PressureChangeRate"/> is T^-3L^-1M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 1, -3, 0, 0, 0, 0);
 
@@ -118,32 +117,64 @@ public static PressureChangeRateInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{PressureChangeRateUnit}"/> representing the default unit mappings for PressureChangeRate.</returns>
             public static IEnumerable<UnitDefinition<PressureChangeRateUnit>> GetDefaultMappings()
             {
-                yield return new (PressureChangeRateUnit.AtmospherePerSecond, "AtmospherePerSecond", "AtmospheresPerSecond", BaseUnits.Undefined);
-                yield return new (PressureChangeRateUnit.BarPerMinute, "BarPerMinute", "BarsPerMinute", BaseUnits.Undefined);
-                yield return new (PressureChangeRateUnit.BarPerSecond, "BarPerSecond", "BarsPerSecond", BaseUnits.Undefined);
-                yield return new (PressureChangeRateUnit.KilopascalPerMinute, "KilopascalPerMinute", "KilopascalsPerMinute", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Minute));
-                yield return new (PressureChangeRateUnit.KilopascalPerSecond, "KilopascalPerSecond", "KilopascalsPerSecond", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, "KilopoundForcePerSquareInchPerMinute", "KilopoundsForcePerSquareInchPerMinute", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Kilopound, time: DurationUnit.Minute));
-                yield return new (PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, "KilopoundForcePerSquareInchPerSecond", "KilopoundsForcePerSquareInchPerSecond", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Kilopound, time: DurationUnit.Second));
-                yield return new (PressureChangeRateUnit.MegapascalPerMinute, "MegapascalPerMinute", "MegapascalsPerMinute", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Minute));
-                yield return new (PressureChangeRateUnit.MegapascalPerSecond, "MegapascalPerSecond", "MegapascalsPerSecond", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, "MegapoundForcePerSquareInchPerMinute", "MegapoundsForcePerSquareInchPerMinute", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Megapound, time: DurationUnit.Minute));
-                yield return new (PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, "MegapoundForcePerSquareInchPerSecond", "MegapoundsForcePerSquareInchPerSecond", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Megapound, time: DurationUnit.Second));
-                yield return new (PressureChangeRateUnit.MillibarPerMinute, "MillibarPerMinute", "MillibarsPerMinute", BaseUnits.Undefined);
-                yield return new (PressureChangeRateUnit.MillibarPerSecond, "MillibarPerSecond", "MillibarsPerSecond", BaseUnits.Undefined);
-                yield return new (PressureChangeRateUnit.MillimeterOfMercuryPerSecond, "MillimeterOfMercuryPerSecond", "MillimetersOfMercuryPerSecond", BaseUnits.Undefined);
-                yield return new (PressureChangeRateUnit.PascalPerMinute, "PascalPerMinute", "PascalsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute));
+                yield return new (PressureChangeRateUnit.AtmospherePerSecond, "AtmospherePerSecond", "AtmospheresPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 101325)
+                );
+                yield return new (PressureChangeRateUnit.BarPerMinute, "BarPerMinute", "BarsPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(3, 5000)
+                );
+                yield return new (PressureChangeRateUnit.BarPerSecond, "BarPerSecond", "BarsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 100000)
+                );
+                yield return new (PressureChangeRateUnit.KilopascalPerMinute, "KilopascalPerMinute", "KilopascalsPerMinute", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Minute),
+                     new QuantityValue(3, 50)
+                );
+                yield return new (PressureChangeRateUnit.KilopascalPerSecond, "KilopascalPerSecond", "KilopascalsPerSecond", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, "KilopoundForcePerSquareInchPerMinute", "KilopoundsForcePerSquareInchPerMinute", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Kilopound, time: DurationUnit.Minute),
+                     new QuantityValue(77419200, 8896443230521)
+                );
+                yield return new (PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, "KilopoundForcePerSquareInchPerSecond", "KilopoundsForcePerSquareInchPerSecond", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Kilopound, time: DurationUnit.Second),
+                     new QuantityValue(1290320, 8896443230521)
+                );
+                yield return new (PressureChangeRateUnit.MegapascalPerMinute, "MegapascalPerMinute", "MegapascalsPerMinute", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Minute),
+                     new QuantityValue(3, 50000)
+                );
+                yield return new (PressureChangeRateUnit.MegapascalPerSecond, "MegapascalPerSecond", "MegapascalsPerSecond", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, "MegapoundForcePerSquareInchPerMinute", "MegapoundsForcePerSquareInchPerMinute", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Megapound, time: DurationUnit.Minute),
+                     new QuantityValue(387096, 44482216152605)
+                );
+                yield return new (PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, "MegapoundForcePerSquareInchPerSecond", "MegapoundsForcePerSquareInchPerSecond", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Megapound, time: DurationUnit.Second),
+                     new QuantityValue(32258, 222411080763025)
+                );
+                yield return new (PressureChangeRateUnit.MillibarPerMinute, "MillibarPerMinute", "MillibarsPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(3, 5)
+                );
+                yield return new (PressureChangeRateUnit.MillibarPerSecond, "MillibarPerSecond", "MillibarsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 100)
+                );
+                yield return new (PressureChangeRateUnit.MillimeterOfMercuryPerSecond, "MillimeterOfMercuryPerSecond", "MillimetersOfMercuryPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(200000000, 26664477483)
+                );
+                yield return new (PressureChangeRateUnit.PascalPerMinute, "PascalPerMinute", "PascalsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute),
+                     60
+                );
                 yield return new (PressureChangeRateUnit.PascalPerSecond, "PascalPerSecond", "PascalsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, "PoundForcePerSquareInchPerMinute", "PoundsForcePerSquareInchPerMinute", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound, time: DurationUnit.Minute));
-                yield return new (PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, "PoundForcePerSquareInchPerSecond", "PoundsForcePerSquareInchPerSecond", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound, time: DurationUnit.Second));
+                yield return new (PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, "PoundForcePerSquareInchPerMinute", "PoundsForcePerSquareInchPerMinute", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound, time: DurationUnit.Minute),
+                     new QuantityValue(77419200000, 8896443230521)
+                );
+                yield return new (PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, "PoundForcePerSquareInchPerSecond", "PoundsForcePerSquareInchPerSecond", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Pound, time: DurationUnit.Second),
+                     new QuantityValue(1290320000, 8896443230521)
+                );
             }
         }
 
         static PressureChangeRate()
         {
-            Info = PressureChangeRateInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(PressureChangeRateInfo.CreateDefault);
         }
 
         /// <summary>
@@ -151,7 +182,7 @@ static PressureChangeRate()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public PressureChangeRate(double value, PressureChangeRateUnit unit)
+        public PressureChangeRate(QuantityValue value, PressureChangeRateUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -165,7 +196,7 @@ public PressureChangeRate(double value, PressureChangeRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public PressureChangeRate(double value, UnitSystem unitSystem)
+        public PressureChangeRate(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -176,7 +207,8 @@ public PressureChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="PressureChangeRate" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<PressureChangeRate, PressureChangeRateUnit> Info { get; }
@@ -205,10 +237,8 @@ public PressureChangeRate(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public PressureChangeRateUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -242,147 +272,99 @@ public PressureChangeRate(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.AtmospherePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.AtmospherePerSecond"/>
         /// </summary>
-        public double AtmospheresPerSecond => As(PressureChangeRateUnit.AtmospherePerSecond);
+        public QuantityValue AtmospheresPerSecond => this.As(PressureChangeRateUnit.AtmospherePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.BarPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.BarPerMinute"/>
         /// </summary>
-        public double BarsPerMinute => As(PressureChangeRateUnit.BarPerMinute);
+        public QuantityValue BarsPerMinute => this.As(PressureChangeRateUnit.BarPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.BarPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.BarPerSecond"/>
         /// </summary>
-        public double BarsPerSecond => As(PressureChangeRateUnit.BarPerSecond);
+        public QuantityValue BarsPerSecond => this.As(PressureChangeRateUnit.BarPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopascalPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopascalPerMinute"/>
         /// </summary>
-        public double KilopascalsPerMinute => As(PressureChangeRateUnit.KilopascalPerMinute);
+        public QuantityValue KilopascalsPerMinute => this.As(PressureChangeRateUnit.KilopascalPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopascalPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopascalPerSecond"/>
         /// </summary>
-        public double KilopascalsPerSecond => As(PressureChangeRateUnit.KilopascalPerSecond);
+        public QuantityValue KilopascalsPerSecond => this.As(PressureChangeRateUnit.KilopascalPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute"/>
         /// </summary>
-        public double KilopoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute);
+        public QuantityValue KilopoundsForcePerSquareInchPerMinute => this.As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond"/>
         /// </summary>
-        public double KilopoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond);
+        public QuantityValue KilopoundsForcePerSquareInchPerSecond => this.As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapascalPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapascalPerMinute"/>
         /// </summary>
-        public double MegapascalsPerMinute => As(PressureChangeRateUnit.MegapascalPerMinute);
+        public QuantityValue MegapascalsPerMinute => this.As(PressureChangeRateUnit.MegapascalPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapascalPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapascalPerSecond"/>
         /// </summary>
-        public double MegapascalsPerSecond => As(PressureChangeRateUnit.MegapascalPerSecond);
+        public QuantityValue MegapascalsPerSecond => this.As(PressureChangeRateUnit.MegapascalPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute"/>
         /// </summary>
-        public double MegapoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute);
+        public QuantityValue MegapoundsForcePerSquareInchPerMinute => this.As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond"/>
         /// </summary>
-        public double MegapoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond);
+        public QuantityValue MegapoundsForcePerSquareInchPerSecond => this.As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MillibarPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MillibarPerMinute"/>
         /// </summary>
-        public double MillibarsPerMinute => As(PressureChangeRateUnit.MillibarPerMinute);
+        public QuantityValue MillibarsPerMinute => this.As(PressureChangeRateUnit.MillibarPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MillibarPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MillibarPerSecond"/>
         /// </summary>
-        public double MillibarsPerSecond => As(PressureChangeRateUnit.MillibarPerSecond);
+        public QuantityValue MillibarsPerSecond => this.As(PressureChangeRateUnit.MillibarPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MillimeterOfMercuryPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.MillimeterOfMercuryPerSecond"/>
         /// </summary>
-        public double MillimetersOfMercuryPerSecond => As(PressureChangeRateUnit.MillimeterOfMercuryPerSecond);
+        public QuantityValue MillimetersOfMercuryPerSecond => this.As(PressureChangeRateUnit.MillimeterOfMercuryPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PascalPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PascalPerMinute"/>
         /// </summary>
-        public double PascalsPerMinute => As(PressureChangeRateUnit.PascalPerMinute);
+        public QuantityValue PascalsPerMinute => this.As(PressureChangeRateUnit.PascalPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PascalPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PascalPerSecond"/>
         /// </summary>
-        public double PascalsPerSecond => As(PressureChangeRateUnit.PascalPerSecond);
+        public QuantityValue PascalsPerSecond => this.As(PressureChangeRateUnit.PascalPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerMinute"/>
         /// </summary>
-        public double PoundsForcePerSquareInchPerMinute => As(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute);
+        public QuantityValue PoundsForcePerSquareInchPerMinute => this.As(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerSecond"/>
         /// </summary>
-        public double PoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond);
+        public QuantityValue PoundsForcePerSquareInchPerSecond => this.As(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: PressureChangeRateUnit -> BaseUnit
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.BarPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.BarPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.MegapascalPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.MillibarPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.MillibarPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.MillimeterOfMercuryPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> PressureChangeRateUnit
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.AtmospherePerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.AtmospherePerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.BarPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.BarPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.BarPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.BarPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopascalPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.KilopascalPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.KilopascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapascalPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.MegapascalPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.MegapascalPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillibarPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.MillibarPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillibarPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.MillibarPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillimeterOfMercuryPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.MillimeterOfMercuryPerSecond));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PascalPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute));
-            unitConverter.SetConversionFunction<PressureChangeRate>(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -411,7 +393,7 @@ public static string GetAbbreviation(PressureChangeRateUnit unit, IFormatProvide
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.AtmospherePerSecond"/>.
         /// </summary>
-        public static PressureChangeRate FromAtmospheresPerSecond(double value)
+        public static PressureChangeRate FromAtmospheresPerSecond(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.AtmospherePerSecond);
         }
@@ -419,7 +401,7 @@ public static PressureChangeRate FromAtmospheresPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.BarPerMinute"/>.
         /// </summary>
-        public static PressureChangeRate FromBarsPerMinute(double value)
+        public static PressureChangeRate FromBarsPerMinute(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.BarPerMinute);
         }
@@ -427,7 +409,7 @@ public static PressureChangeRate FromBarsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.BarPerSecond"/>.
         /// </summary>
-        public static PressureChangeRate FromBarsPerSecond(double value)
+        public static PressureChangeRate FromBarsPerSecond(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.BarPerSecond);
         }
@@ -435,7 +417,7 @@ public static PressureChangeRate FromBarsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopascalPerMinute"/>.
         /// </summary>
-        public static PressureChangeRate FromKilopascalsPerMinute(double value)
+        public static PressureChangeRate FromKilopascalsPerMinute(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerMinute);
         }
@@ -443,7 +425,7 @@ public static PressureChangeRate FromKilopascalsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopascalPerSecond"/>.
         /// </summary>
-        public static PressureChangeRate FromKilopascalsPerSecond(double value)
+        public static PressureChangeRate FromKilopascalsPerSecond(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerSecond);
         }
@@ -451,7 +433,7 @@ public static PressureChangeRate FromKilopascalsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute"/>.
         /// </summary>
-        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(double value)
+        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute);
         }
@@ -459,7 +441,7 @@ public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(doubl
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond"/>.
         /// </summary>
-        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(double value)
+        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond);
         }
@@ -467,7 +449,7 @@ public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(doubl
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapascalPerMinute"/>.
         /// </summary>
-        public static PressureChangeRate FromMegapascalsPerMinute(double value)
+        public static PressureChangeRate FromMegapascalsPerMinute(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerMinute);
         }
@@ -475,7 +457,7 @@ public static PressureChangeRate FromMegapascalsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapascalPerSecond"/>.
         /// </summary>
-        public static PressureChangeRate FromMegapascalsPerSecond(double value)
+        public static PressureChangeRate FromMegapascalsPerSecond(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerSecond);
         }
@@ -483,7 +465,7 @@ public static PressureChangeRate FromMegapascalsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute"/>.
         /// </summary>
-        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(double value)
+        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute);
         }
@@ -491,7 +473,7 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(doubl
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond"/>.
         /// </summary>
-        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(double value)
+        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond);
         }
@@ -499,7 +481,7 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(doubl
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillibarPerMinute"/>.
         /// </summary>
-        public static PressureChangeRate FromMillibarsPerMinute(double value)
+        public static PressureChangeRate FromMillibarsPerMinute(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.MillibarPerMinute);
         }
@@ -507,7 +489,7 @@ public static PressureChangeRate FromMillibarsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillibarPerSecond"/>.
         /// </summary>
-        public static PressureChangeRate FromMillibarsPerSecond(double value)
+        public static PressureChangeRate FromMillibarsPerSecond(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.MillibarPerSecond);
         }
@@ -515,7 +497,7 @@ public static PressureChangeRate FromMillibarsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillimeterOfMercuryPerSecond"/>.
         /// </summary>
-        public static PressureChangeRate FromMillimetersOfMercuryPerSecond(double value)
+        public static PressureChangeRate FromMillimetersOfMercuryPerSecond(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.MillimeterOfMercuryPerSecond);
         }
@@ -523,7 +505,7 @@ public static PressureChangeRate FromMillimetersOfMercuryPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PascalPerMinute"/>.
         /// </summary>
-        public static PressureChangeRate FromPascalsPerMinute(double value)
+        public static PressureChangeRate FromPascalsPerMinute(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerMinute);
         }
@@ -531,7 +513,7 @@ public static PressureChangeRate FromPascalsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PascalPerSecond"/>.
         /// </summary>
-        public static PressureChangeRate FromPascalsPerSecond(double value)
+        public static PressureChangeRate FromPascalsPerSecond(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerSecond);
         }
@@ -539,7 +521,7 @@ public static PressureChangeRate FromPascalsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerMinute"/>.
         /// </summary>
-        public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(double value)
+        public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute);
         }
@@ -547,7 +529,7 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(double va
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerSecond"/>.
         /// </summary>
-        public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(double value)
+        public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(QuantityValue value)
         {
             return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond);
         }
@@ -558,7 +540,7 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(double va
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>PressureChangeRate unit value.</returns>
-        public static PressureChangeRate From(double value, PressureChangeRateUnit fromUnit)
+        public static PressureChangeRate From(QuantityValue value, PressureChangeRateUnit fromUnit)
         {
             return new PressureChangeRate(value, fromUnit);
         }
@@ -619,10 +601,7 @@ public static PressureChangeRate Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static PressureChangeRate Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<PressureChangeRate, PressureChangeRateUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<PressureChangeRate, PressureChangeRateUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -650,11 +629,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out PressureChangeRa
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out PressureChangeRate result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<PressureChangeRate, PressureChangeRateUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<PressureChangeRate, PressureChangeRateUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -675,7 +650,7 @@ public static PressureChangeRateUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -686,7 +661,7 @@ public static PressureChangeRateUnit ParseUnit(string str, IFormatProvider? prov
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.PressureChangeRateUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.PressureChangeRateUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out PressureChangeRateUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -701,7 +676,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out PressureChan
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out PressureChangeRateUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -720,35 +695,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="PressureChangeRate"/> from adding two <see cref="PressureChangeRate"/>.</summary>
         public static PressureChangeRate operator +(PressureChangeRate left, PressureChangeRate right)
         {
-            return new PressureChangeRate(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new PressureChangeRate(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="PressureChangeRate"/> from subtracting two <see cref="PressureChangeRate"/>.</summary>
         public static PressureChangeRate operator -(PressureChangeRate left, PressureChangeRate right)
         {
-            return new PressureChangeRate(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new PressureChangeRate(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="PressureChangeRate"/> from multiplying value and <see cref="PressureChangeRate"/>.</summary>
-        public static PressureChangeRate operator *(double left, PressureChangeRate right)
+        public static PressureChangeRate operator *(QuantityValue left, PressureChangeRate right)
         {
             return new PressureChangeRate(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="PressureChangeRate"/> from multiplying value and <see cref="PressureChangeRate"/>.</summary>
-        public static PressureChangeRate operator *(PressureChangeRate left, double right)
+        public static PressureChangeRate operator *(PressureChangeRate left, QuantityValue right)
         {
             return new PressureChangeRate(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="PressureChangeRate"/> from dividing <see cref="PressureChangeRate"/> by value.</summary>
-        public static PressureChangeRate operator /(PressureChangeRate left, double right)
+        public static PressureChangeRate operator /(PressureChangeRate left, QuantityValue right)
         {
             return new PressureChangeRate(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="PressureChangeRate"/> by <see cref="PressureChangeRate"/>.</summary>
-        public static double operator /(PressureChangeRate left, PressureChangeRate right)
+        public static QuantityValue operator /(PressureChangeRate left, PressureChangeRate right)
         {
             return left.PascalsPerSecond / right.PascalsPerSecond;
         }
@@ -770,97 +745,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(PressureChangeRate left, PressureChangeRate right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(PressureChangeRate left, PressureChangeRate right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(PressureChangeRate left, PressureChangeRate right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(PressureChangeRate left, PressureChangeRate right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="PressureChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(PressureChangeRate other, PressureChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="PressureChangeRate"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(PressureChangeRate)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(PressureChangeRate left, PressureChangeRate right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="PressureChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(PressureChangeRate other, PressureChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="PressureChangeRate"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(PressureChangeRate,PressureChangeRate)"/>.
+        ///     See that operator (and <see cref="Equals(PressureChangeRate)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(PressureChangeRate left, PressureChangeRate right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="PressureChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(PressureChangeRate other, PressureChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="PressureChangeRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="PressureChangeRate"/>.
+        ///     When <paramref name="obj"/> is a <see cref="PressureChangeRate"/>, this method delegates to
+        ///     <see cref="Equals(PressureChangeRate)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is PressureChangeRate otherQuantity))
+            if (obj is not PressureChangeRate otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="PressureChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(PressureChangeRate other, PressureChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="PressureChangeRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(PressureChangeRate other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current PressureChangeRate.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(PressureChangeRate), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="PressureChangeRate"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(PressureChangeRate)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is PressureChangeRate otherQuantity)) throw new ArgumentException("Expected type PressureChangeRate.", nameof(obj));
+            if (obj is not PressureChangeRate otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<PressureChangeRate>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="PressureChangeRate"/> with another <see cref="PressureChangeRate"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="PressureChangeRate"/> with another <see cref="PressureChangeRate"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -872,163 +861,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(PressureChangeRate other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(PressureChangeRateUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<PressureChangeRateUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this PressureChangeRate to another PressureChangeRate with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A PressureChangeRate with the specified unit.</returns>
-        public PressureChangeRate ToUnit(PressureChangeRateUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="PressureChangeRate"/> to another <see cref="PressureChangeRate"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A PressureChangeRate with the specified unit.</returns>
-        public PressureChangeRate ToUnit(PressureChangeRateUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(PressureChangeRate), Unit, typeof(PressureChangeRate), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (PressureChangeRate)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="PressureChangeRate"/> to another <see cref="PressureChangeRate"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="PressureChangeRate"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(PressureChangeRateUnit unit, [NotNullWhen(true)] out PressureChangeRate? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            PressureChangeRate? convertedOrNull = (Unit, unit) switch
-            {
-                // PressureChangeRateUnit -> BaseUnit
-                (PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * 1.01325 * 1e5, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.BarPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * 1e5 / 60, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.BarPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * 1e5, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value / 60) * 1e3d, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value) * 1e3d, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * (4.4482216152605 / 0.00064516) / 60) * 1e3d, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * 4.4482216152605 / 0.00064516) * 1e3d, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.MegapascalPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value / 60) * 1e6d, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value) * 1e6d, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * (4.4482216152605 / 0.00064516) / 60) * 1e6d, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * 4.4482216152605 / 0.00064516) * 1e6d, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.MillibarPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * 1e5 / 60) * 1e-3d, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.MillibarPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * 1e5) * 1e-3d, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.MillimeterOfMercuryPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * 133.322387415, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.PascalPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value / 60, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * (4.4482216152605 / 0.00064516) / 60, PressureChangeRateUnit.PascalPerSecond),
-                (PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * 4.4482216152605 / 0.00064516, PressureChangeRateUnit.PascalPerSecond),
-
-                // BaseUnit -> PressureChangeRateUnit
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.AtmospherePerSecond) => new PressureChangeRate(_value / (1.01325 * 1e5), PressureChangeRateUnit.AtmospherePerSecond),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.BarPerMinute) => new PressureChangeRate(_value / 1e5 * 60, PressureChangeRateUnit.BarPerMinute),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.BarPerSecond) => new PressureChangeRate(_value / 1e5, PressureChangeRateUnit.BarPerSecond),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopascalPerMinute) => new PressureChangeRate((_value * 60) / 1e3d, PressureChangeRateUnit.KilopascalPerMinute),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopascalPerSecond) => new PressureChangeRate((_value) / 1e3d, PressureChangeRateUnit.KilopascalPerSecond),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute) => new PressureChangeRate((_value * 60 / (4.4482216152605 / 0.00064516)) / 1e3d, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond) => new PressureChangeRate((_value * 0.00064516 / 4.4482216152605) / 1e3d, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapascalPerMinute) => new PressureChangeRate((_value * 60) / 1e6d, PressureChangeRateUnit.MegapascalPerMinute),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapascalPerSecond) => new PressureChangeRate((_value) / 1e6d, PressureChangeRateUnit.MegapascalPerSecond),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute) => new PressureChangeRate((_value * 60 / (4.4482216152605 / 0.00064516)) / 1e6d, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond) => new PressureChangeRate((_value * 0.00064516 / 4.4482216152605) / 1e6d, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillibarPerMinute) => new PressureChangeRate((_value / 1e5 * 60) / 1e-3d, PressureChangeRateUnit.MillibarPerMinute),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillibarPerSecond) => new PressureChangeRate((_value / 1e5) / 1e-3d, PressureChangeRateUnit.MillibarPerSecond),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillimeterOfMercuryPerSecond) => new PressureChangeRate(_value / 133.322387415, PressureChangeRateUnit.MillimeterOfMercuryPerSecond),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PascalPerMinute) => new PressureChangeRate(_value * 60, PressureChangeRateUnit.PascalPerMinute),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute) => new PressureChangeRate(_value * 60 / (4.4482216152605 / 0.00064516), PressureChangeRateUnit.PoundForcePerSquareInchPerMinute),
-                (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond) => new PressureChangeRate(_value * 0.00064516 / 4.4482216152605, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not PressureChangeRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureChangeRateUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is PressureChangeRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureChangeRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<PressureChangeRateUnit> IQuantity<PressureChangeRateUnit>.ToUnit(PressureChangeRateUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1042,11 +877,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs b/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs
index 66133892c4..16b9849dde 100644
--- a/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDose.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Equivalent dose is a dose quantity representing the stochastic health effects of low levels of ionizing radiation on the human body which represents the probability of radiation-induced cancer and genetic damage.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct RadiationEquivalentDose :
-        IArithmeticQuantity<RadiationEquivalentDose, RadiationEquivalentDoseUnit>,
+        ILinearQuantity<RadiationEquivalentDose, RadiationEquivalentDoseUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<RadiationEquivalentDose, RadiationEquivalentDose, double>,
+        IDivisionOperators<RadiationEquivalentDose, RadiationEquivalentDose, QuantityValue>,
         IDivisionOperators<RadiationEquivalentDose, RadiationEquivalentDoseRate, Duration>,
         IDivisionOperators<RadiationEquivalentDose, Duration, RadiationEquivalentDoseRate>,
         IComparisonOperators<RadiationEquivalentDose, RadiationEquivalentDose, bool>,
@@ -54,7 +53,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -104,7 +103,7 @@ public static RadiationEquivalentDoseInfo CreateDefault(Func<IEnumerable<UnitDef
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="RadiationEquivalentDose"/> is [T^-2][L^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="RadiationEquivalentDose"/> is T^-2L^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 0, -2, 0, 0, 0, 0);
 
@@ -119,20 +118,28 @@ public static RadiationEquivalentDoseInfo CreateDefault(Func<IEnumerable<UnitDef
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{RadiationEquivalentDoseUnit}"/> representing the default unit mappings for RadiationEquivalentDose.</returns>
             public static IEnumerable<UnitDefinition<RadiationEquivalentDoseUnit>> GetDefaultMappings()
             {
-                yield return new (RadiationEquivalentDoseUnit.Microsievert, "Microsievert", "Microsieverts", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second));
-                yield return new (RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan, "MilliroentgenEquivalentMan", "MilliroentgensEquivalentMan", BaseUnits.Undefined);
-                yield return new (RadiationEquivalentDoseUnit.Millisievert, "Millisievert", "Millisieverts", BaseUnits.Undefined);
-                yield return new (RadiationEquivalentDoseUnit.Nanosievert, "Nanosievert", "Nanosieverts", BaseUnits.Undefined);
-                yield return new (RadiationEquivalentDoseUnit.RoentgenEquivalentMan, "RoentgenEquivalentMan", "RoentgensEquivalentMan", BaseUnits.Undefined);
+                yield return new (RadiationEquivalentDoseUnit.Microsievert, "Microsievert", "Microsieverts", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan, "MilliroentgenEquivalentMan", "MilliroentgensEquivalentMan", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (RadiationEquivalentDoseUnit.Millisievert, "Millisievert", "Millisieverts", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (RadiationEquivalentDoseUnit.Nanosievert, "Nanosievert", "Nanosieverts", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (RadiationEquivalentDoseUnit.RoentgenEquivalentMan, "RoentgenEquivalentMan", "RoentgensEquivalentMan", BaseUnits.Undefined,
+                     100
+                );
                 yield return new (RadiationEquivalentDoseUnit.Sievert, "Sievert", "Sieverts", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
             }
         }
 
         static RadiationEquivalentDose()
         {
-            Info = RadiationEquivalentDoseInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RadiationEquivalentDoseInfo.CreateDefault);
         }
 
         /// <summary>
@@ -140,7 +147,7 @@ static RadiationEquivalentDose()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RadiationEquivalentDose(double value, RadiationEquivalentDoseUnit unit)
+        public RadiationEquivalentDose(QuantityValue value, RadiationEquivalentDoseUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -154,7 +161,7 @@ public RadiationEquivalentDose(double value, RadiationEquivalentDoseUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RadiationEquivalentDose(double value, UnitSystem unitSystem)
+        public RadiationEquivalentDose(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -165,7 +172,8 @@ public RadiationEquivalentDose(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="RadiationEquivalentDose" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<RadiationEquivalentDose, RadiationEquivalentDoseUnit> Info { get; }
@@ -194,10 +202,8 @@ public RadiationEquivalentDose(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RadiationEquivalentDoseUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -231,63 +237,39 @@ public RadiationEquivalentDose(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Microsievert"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Microsievert"/>
         /// </summary>
-        public double Microsieverts => As(RadiationEquivalentDoseUnit.Microsievert);
+        public QuantityValue Microsieverts => this.As(RadiationEquivalentDoseUnit.Microsievert);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan"/>
         /// </summary>
-        public double MilliroentgensEquivalentMan => As(RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan);
+        public QuantityValue MilliroentgensEquivalentMan => this.As(RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Millisievert"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Millisievert"/>
         /// </summary>
-        public double Millisieverts => As(RadiationEquivalentDoseUnit.Millisievert);
+        public QuantityValue Millisieverts => this.As(RadiationEquivalentDoseUnit.Millisievert);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Nanosievert"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Nanosievert"/>
         /// </summary>
-        public double Nanosieverts => As(RadiationEquivalentDoseUnit.Nanosievert);
+        public QuantityValue Nanosieverts => this.As(RadiationEquivalentDoseUnit.Nanosievert);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.RoentgenEquivalentMan"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.RoentgenEquivalentMan"/>
         /// </summary>
-        public double RoentgensEquivalentMan => As(RadiationEquivalentDoseUnit.RoentgenEquivalentMan);
+        public QuantityValue RoentgensEquivalentMan => this.As(RadiationEquivalentDoseUnit.RoentgenEquivalentMan);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Sievert"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseUnit.Sievert"/>
         /// </summary>
-        public double Sieverts => As(RadiationEquivalentDoseUnit.Sievert);
+        public QuantityValue Sieverts => this.As(RadiationEquivalentDoseUnit.Sievert);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RadiationEquivalentDoseUnit -> BaseUnit
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.Microsievert, RadiationEquivalentDoseUnit.Sievert, quantity => quantity.ToUnit(RadiationEquivalentDoseUnit.Sievert));
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan, RadiationEquivalentDoseUnit.Sievert, quantity => quantity.ToUnit(RadiationEquivalentDoseUnit.Sievert));
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.Millisievert, RadiationEquivalentDoseUnit.Sievert, quantity => quantity.ToUnit(RadiationEquivalentDoseUnit.Sievert));
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.Nanosievert, RadiationEquivalentDoseUnit.Sievert, quantity => quantity.ToUnit(RadiationEquivalentDoseUnit.Sievert));
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.RoentgenEquivalentMan, RadiationEquivalentDoseUnit.Sievert, quantity => quantity.ToUnit(RadiationEquivalentDoseUnit.Sievert));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.Sievert, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RadiationEquivalentDoseUnit
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.Microsievert, quantity => quantity.ToUnit(RadiationEquivalentDoseUnit.Microsievert));
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan, quantity => quantity.ToUnit(RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan));
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.Millisievert, quantity => quantity.ToUnit(RadiationEquivalentDoseUnit.Millisievert));
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.Nanosievert, quantity => quantity.ToUnit(RadiationEquivalentDoseUnit.Nanosievert));
-            unitConverter.SetConversionFunction<RadiationEquivalentDose>(RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.RoentgenEquivalentMan, quantity => quantity.ToUnit(RadiationEquivalentDoseUnit.RoentgenEquivalentMan));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -316,7 +298,7 @@ public static string GetAbbreviation(RadiationEquivalentDoseUnit unit, IFormatPr
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.Microsievert"/>.
         /// </summary>
-        public static RadiationEquivalentDose FromMicrosieverts(double value)
+        public static RadiationEquivalentDose FromMicrosieverts(QuantityValue value)
         {
             return new RadiationEquivalentDose(value, RadiationEquivalentDoseUnit.Microsievert);
         }
@@ -324,7 +306,7 @@ public static RadiationEquivalentDose FromMicrosieverts(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan"/>.
         /// </summary>
-        public static RadiationEquivalentDose FromMilliroentgensEquivalentMan(double value)
+        public static RadiationEquivalentDose FromMilliroentgensEquivalentMan(QuantityValue value)
         {
             return new RadiationEquivalentDose(value, RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan);
         }
@@ -332,7 +314,7 @@ public static RadiationEquivalentDose FromMilliroentgensEquivalentMan(double val
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.Millisievert"/>.
         /// </summary>
-        public static RadiationEquivalentDose FromMillisieverts(double value)
+        public static RadiationEquivalentDose FromMillisieverts(QuantityValue value)
         {
             return new RadiationEquivalentDose(value, RadiationEquivalentDoseUnit.Millisievert);
         }
@@ -340,7 +322,7 @@ public static RadiationEquivalentDose FromMillisieverts(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.Nanosievert"/>.
         /// </summary>
-        public static RadiationEquivalentDose FromNanosieverts(double value)
+        public static RadiationEquivalentDose FromNanosieverts(QuantityValue value)
         {
             return new RadiationEquivalentDose(value, RadiationEquivalentDoseUnit.Nanosievert);
         }
@@ -348,7 +330,7 @@ public static RadiationEquivalentDose FromNanosieverts(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.RoentgenEquivalentMan"/>.
         /// </summary>
-        public static RadiationEquivalentDose FromRoentgensEquivalentMan(double value)
+        public static RadiationEquivalentDose FromRoentgensEquivalentMan(QuantityValue value)
         {
             return new RadiationEquivalentDose(value, RadiationEquivalentDoseUnit.RoentgenEquivalentMan);
         }
@@ -356,7 +338,7 @@ public static RadiationEquivalentDose FromRoentgensEquivalentMan(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDose"/> from <see cref="RadiationEquivalentDoseUnit.Sievert"/>.
         /// </summary>
-        public static RadiationEquivalentDose FromSieverts(double value)
+        public static RadiationEquivalentDose FromSieverts(QuantityValue value)
         {
             return new RadiationEquivalentDose(value, RadiationEquivalentDoseUnit.Sievert);
         }
@@ -367,7 +349,7 @@ public static RadiationEquivalentDose FromSieverts(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RadiationEquivalentDose unit value.</returns>
-        public static RadiationEquivalentDose From(double value, RadiationEquivalentDoseUnit fromUnit)
+        public static RadiationEquivalentDose From(QuantityValue value, RadiationEquivalentDoseUnit fromUnit)
         {
             return new RadiationEquivalentDose(value, fromUnit);
         }
@@ -428,10 +410,7 @@ public static RadiationEquivalentDose Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static RadiationEquivalentDose Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<RadiationEquivalentDose, RadiationEquivalentDoseUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<RadiationEquivalentDose, RadiationEquivalentDoseUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -459,11 +438,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out RadiationEquival
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out RadiationEquivalentDose result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<RadiationEquivalentDose, RadiationEquivalentDoseUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<RadiationEquivalentDose, RadiationEquivalentDoseUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -484,7 +459,7 @@ public static RadiationEquivalentDoseUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -495,7 +470,7 @@ public static RadiationEquivalentDoseUnit ParseUnit(string str, IFormatProvider?
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RadiationEquivalentDoseUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RadiationEquivalentDoseUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RadiationEquivalentDoseUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -510,7 +485,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RadiationEqu
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RadiationEquivalentDoseUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -529,35 +504,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="RadiationEquivalentDose"/> from adding two <see cref="RadiationEquivalentDose"/>.</summary>
         public static RadiationEquivalentDose operator +(RadiationEquivalentDose left, RadiationEquivalentDose right)
         {
-            return new RadiationEquivalentDose(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new RadiationEquivalentDose(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RadiationEquivalentDose"/> from subtracting two <see cref="RadiationEquivalentDose"/>.</summary>
         public static RadiationEquivalentDose operator -(RadiationEquivalentDose left, RadiationEquivalentDose right)
         {
-            return new RadiationEquivalentDose(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new RadiationEquivalentDose(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RadiationEquivalentDose"/> from multiplying value and <see cref="RadiationEquivalentDose"/>.</summary>
-        public static RadiationEquivalentDose operator *(double left, RadiationEquivalentDose right)
+        public static RadiationEquivalentDose operator *(QuantityValue left, RadiationEquivalentDose right)
         {
             return new RadiationEquivalentDose(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="RadiationEquivalentDose"/> from multiplying value and <see cref="RadiationEquivalentDose"/>.</summary>
-        public static RadiationEquivalentDose operator *(RadiationEquivalentDose left, double right)
+        public static RadiationEquivalentDose operator *(RadiationEquivalentDose left, QuantityValue right)
         {
             return new RadiationEquivalentDose(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="RadiationEquivalentDose"/> from dividing <see cref="RadiationEquivalentDose"/> by value.</summary>
-        public static RadiationEquivalentDose operator /(RadiationEquivalentDose left, double right)
+        public static RadiationEquivalentDose operator /(RadiationEquivalentDose left, QuantityValue right)
         {
             return new RadiationEquivalentDose(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="RadiationEquivalentDose"/> by <see cref="RadiationEquivalentDose"/>.</summary>
-        public static double operator /(RadiationEquivalentDose left, RadiationEquivalentDose right)
+        public static QuantityValue operator /(RadiationEquivalentDose left, RadiationEquivalentDose right)
         {
             return left.Sieverts / right.Sieverts;
         }
@@ -585,97 +560,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(RadiationEquivalentDose left, RadiationEquivalentDose right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(RadiationEquivalentDose left, RadiationEquivalentDose right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(RadiationEquivalentDose left, RadiationEquivalentDose right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(RadiationEquivalentDose left, RadiationEquivalentDose right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="RadiationEquivalentDose"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RadiationEquivalentDose other, RadiationEquivalentDose tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RadiationEquivalentDose"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(RadiationEquivalentDose)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(RadiationEquivalentDose left, RadiationEquivalentDose right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="RadiationEquivalentDose"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RadiationEquivalentDose other, RadiationEquivalentDose tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RadiationEquivalentDose"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(RadiationEquivalentDose,RadiationEquivalentDose)"/>.
+        ///     See that operator (and <see cref="Equals(RadiationEquivalentDose)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(RadiationEquivalentDose left, RadiationEquivalentDose right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RadiationEquivalentDose"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RadiationEquivalentDose other, RadiationEquivalentDose tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="RadiationEquivalentDose"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="RadiationEquivalentDose"/>.
+        ///     When <paramref name="obj"/> is a <see cref="RadiationEquivalentDose"/>, this method delegates to
+        ///     <see cref="Equals(RadiationEquivalentDose)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is RadiationEquivalentDose otherQuantity))
+            if (obj is not RadiationEquivalentDose otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RadiationEquivalentDose"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RadiationEquivalentDose other, RadiationEquivalentDose tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="RadiationEquivalentDose"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(RadiationEquivalentDose other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current RadiationEquivalentDose.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(RadiationEquivalentDose), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="RadiationEquivalentDose"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(RadiationEquivalentDose)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is RadiationEquivalentDose otherQuantity)) throw new ArgumentException("Expected type RadiationEquivalentDose.", nameof(obj));
+            if (obj is not RadiationEquivalentDose otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<RadiationEquivalentDose>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="RadiationEquivalentDose"/> with another <see cref="RadiationEquivalentDose"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="RadiationEquivalentDose"/> with another <see cref="RadiationEquivalentDose"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -687,139 +676,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(RadiationEquivalentDose other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RadiationEquivalentDoseUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RadiationEquivalentDoseUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this RadiationEquivalentDose to another RadiationEquivalentDose with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A RadiationEquivalentDose with the specified unit.</returns>
-        public RadiationEquivalentDose ToUnit(RadiationEquivalentDoseUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="RadiationEquivalentDose"/> to another <see cref="RadiationEquivalentDose"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A RadiationEquivalentDose with the specified unit.</returns>
-        public RadiationEquivalentDose ToUnit(RadiationEquivalentDoseUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(RadiationEquivalentDose), Unit, typeof(RadiationEquivalentDose), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (RadiationEquivalentDose)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="RadiationEquivalentDose"/> to another <see cref="RadiationEquivalentDose"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="RadiationEquivalentDose"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RadiationEquivalentDoseUnit unit, [NotNullWhen(true)] out RadiationEquivalentDose? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            RadiationEquivalentDose? convertedOrNull = (Unit, unit) switch
-            {
-                // RadiationEquivalentDoseUnit -> BaseUnit
-                (RadiationEquivalentDoseUnit.Microsievert, RadiationEquivalentDoseUnit.Sievert) => new RadiationEquivalentDose((_value) * 1e-6d, RadiationEquivalentDoseUnit.Sievert),
-                (RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan, RadiationEquivalentDoseUnit.Sievert) => new RadiationEquivalentDose((_value / 100) * 1e-3d, RadiationEquivalentDoseUnit.Sievert),
-                (RadiationEquivalentDoseUnit.Millisievert, RadiationEquivalentDoseUnit.Sievert) => new RadiationEquivalentDose((_value) * 1e-3d, RadiationEquivalentDoseUnit.Sievert),
-                (RadiationEquivalentDoseUnit.Nanosievert, RadiationEquivalentDoseUnit.Sievert) => new RadiationEquivalentDose((_value) * 1e-9d, RadiationEquivalentDoseUnit.Sievert),
-                (RadiationEquivalentDoseUnit.RoentgenEquivalentMan, RadiationEquivalentDoseUnit.Sievert) => new RadiationEquivalentDose(_value / 100, RadiationEquivalentDoseUnit.Sievert),
-
-                // BaseUnit -> RadiationEquivalentDoseUnit
-                (RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.Microsievert) => new RadiationEquivalentDose((_value) / 1e-6d, RadiationEquivalentDoseUnit.Microsievert),
-                (RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan) => new RadiationEquivalentDose((_value * 100) / 1e-3d, RadiationEquivalentDoseUnit.MilliroentgenEquivalentMan),
-                (RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.Millisievert) => new RadiationEquivalentDose((_value) / 1e-3d, RadiationEquivalentDoseUnit.Millisievert),
-                (RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.Nanosievert) => new RadiationEquivalentDose((_value) / 1e-9d, RadiationEquivalentDoseUnit.Nanosievert),
-                (RadiationEquivalentDoseUnit.Sievert, RadiationEquivalentDoseUnit.RoentgenEquivalentMan) => new RadiationEquivalentDose(_value * 100, RadiationEquivalentDoseUnit.RoentgenEquivalentMan),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RadiationEquivalentDoseUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadiationEquivalentDoseUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RadiationEquivalentDoseUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadiationEquivalentDoseUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RadiationEquivalentDoseUnit> IQuantity<RadiationEquivalentDoseUnit>.ToUnit(RadiationEquivalentDoseUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -833,11 +692,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs b/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs
index d3e02da4f9..fb88e14f29 100644
--- a/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RadiationEquivalentDoseRate.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     A dose rate is quantity of radiation absorbed or delivered per unit time.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct RadiationEquivalentDoseRate :
-        IArithmeticQuantity<RadiationEquivalentDoseRate, RadiationEquivalentDoseRateUnit>,
+        ILinearQuantity<RadiationEquivalentDoseRate, RadiationEquivalentDoseRateUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<RadiationEquivalentDoseRate, RadiationEquivalentDoseRate, double>,
+        IDivisionOperators<RadiationEquivalentDoseRate, RadiationEquivalentDoseRate, QuantityValue>,
         IMultiplyOperators<RadiationEquivalentDoseRate, Duration, RadiationEquivalentDose>,
         IComparisonOperators<RadiationEquivalentDoseRate, RadiationEquivalentDoseRate, bool>,
         IParsable<RadiationEquivalentDoseRate>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static RadiationEquivalentDoseRateInfo CreateDefault(Func<IEnumerable<Uni
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="RadiationEquivalentDoseRate"/> is [T^-3][L^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="RadiationEquivalentDoseRate"/> is T^-3L^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 0, -3, 0, 0, 0, 0);
 
@@ -118,24 +117,40 @@ public static RadiationEquivalentDoseRateInfo CreateDefault(Func<IEnumerable<Uni
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{RadiationEquivalentDoseRateUnit}"/> representing the default unit mappings for RadiationEquivalentDoseRate.</returns>
             public static IEnumerable<UnitDefinition<RadiationEquivalentDoseRateUnit>> GetDefaultMappings()
             {
-                yield return new (RadiationEquivalentDoseRateUnit.MicrosievertPerHour, "MicrosievertPerHour", "MicrosievertsPerHour", BaseUnits.Undefined);
-                yield return new (RadiationEquivalentDoseRateUnit.MicrosievertPerSecond, "MicrosievertPerSecond", "MicrosievertsPerSecond", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second));
-                yield return new (RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour, "MilliroentgenEquivalentManPerHour", "MilliroentgensEquivalentManPerHour", BaseUnits.Undefined);
-                yield return new (RadiationEquivalentDoseRateUnit.MillisievertPerHour, "MillisievertPerHour", "MillisievertsPerHour", BaseUnits.Undefined);
-                yield return new (RadiationEquivalentDoseRateUnit.MillisievertPerSecond, "MillisievertPerSecond", "MillisievertsPerSecond", BaseUnits.Undefined);
-                yield return new (RadiationEquivalentDoseRateUnit.NanosievertPerHour, "NanosievertPerHour", "NanosievertsPerHour", BaseUnits.Undefined);
-                yield return new (RadiationEquivalentDoseRateUnit.NanosievertPerSecond, "NanosievertPerSecond", "NanosievertsPerSecond", BaseUnits.Undefined);
-                yield return new (RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour, "RoentgenEquivalentManPerHour", "RoentgensEquivalentManPerHour", BaseUnits.Undefined);
-                yield return new (RadiationEquivalentDoseRateUnit.SievertPerHour, "SievertPerHour", "SievertsPerHour", BaseUnits.Undefined);
+                yield return new (RadiationEquivalentDoseRateUnit.MicrosievertPerHour, "MicrosievertPerHour", "MicrosievertsPerHour", BaseUnits.Undefined,
+                     3600000000
+                );
+                yield return new (RadiationEquivalentDoseRateUnit.MicrosievertPerSecond, "MicrosievertPerSecond", "MicrosievertsPerSecond", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour, "MilliroentgenEquivalentManPerHour", "MilliroentgensEquivalentManPerHour", BaseUnits.Undefined,
+                     360000000
+                );
+                yield return new (RadiationEquivalentDoseRateUnit.MillisievertPerHour, "MillisievertPerHour", "MillisievertsPerHour", BaseUnits.Undefined,
+                     3600000
+                );
+                yield return new (RadiationEquivalentDoseRateUnit.MillisievertPerSecond, "MillisievertPerSecond", "MillisievertsPerSecond", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (RadiationEquivalentDoseRateUnit.NanosievertPerHour, "NanosievertPerHour", "NanosievertsPerHour", BaseUnits.Undefined,
+                     3600000000000
+                );
+                yield return new (RadiationEquivalentDoseRateUnit.NanosievertPerSecond, "NanosievertPerSecond", "NanosievertsPerSecond", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour, "RoentgenEquivalentManPerHour", "RoentgensEquivalentManPerHour", BaseUnits.Undefined,
+                     360000
+                );
+                yield return new (RadiationEquivalentDoseRateUnit.SievertPerHour, "SievertPerHour", "SievertsPerHour", BaseUnits.Undefined,
+                     3600
+                );
                 yield return new (RadiationEquivalentDoseRateUnit.SievertPerSecond, "SievertPerSecond", "SievertsPerSecond", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
             }
         }
 
         static RadiationEquivalentDoseRate()
         {
-            Info = RadiationEquivalentDoseRateInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RadiationEquivalentDoseRateInfo.CreateDefault);
         }
 
         /// <summary>
@@ -143,7 +158,7 @@ static RadiationEquivalentDoseRate()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RadiationEquivalentDoseRate(double value, RadiationEquivalentDoseRateUnit unit)
+        public RadiationEquivalentDoseRate(QuantityValue value, RadiationEquivalentDoseRateUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -157,7 +172,7 @@ public RadiationEquivalentDoseRate(double value, RadiationEquivalentDoseRateUnit
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RadiationEquivalentDoseRate(double value, UnitSystem unitSystem)
+        public RadiationEquivalentDoseRate(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -168,7 +183,8 @@ public RadiationEquivalentDoseRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="RadiationEquivalentDoseRate" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<RadiationEquivalentDoseRate, RadiationEquivalentDoseRateUnit> Info { get; }
@@ -197,10 +213,8 @@ public RadiationEquivalentDoseRate(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RadiationEquivalentDoseRateUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -234,91 +248,59 @@ public RadiationEquivalentDoseRate(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MicrosievertPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MicrosievertPerHour"/>
         /// </summary>
-        public double MicrosievertsPerHour => As(RadiationEquivalentDoseRateUnit.MicrosievertPerHour);
+        public QuantityValue MicrosievertsPerHour => this.As(RadiationEquivalentDoseRateUnit.MicrosievertPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MicrosievertPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MicrosievertPerSecond"/>
         /// </summary>
-        public double MicrosievertsPerSecond => As(RadiationEquivalentDoseRateUnit.MicrosievertPerSecond);
+        public QuantityValue MicrosievertsPerSecond => this.As(RadiationEquivalentDoseRateUnit.MicrosievertPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour"/>
         /// </summary>
-        public double MilliroentgensEquivalentManPerHour => As(RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour);
+        public QuantityValue MilliroentgensEquivalentManPerHour => this.As(RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MillisievertPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MillisievertPerHour"/>
         /// </summary>
-        public double MillisievertsPerHour => As(RadiationEquivalentDoseRateUnit.MillisievertPerHour);
+        public QuantityValue MillisievertsPerHour => this.As(RadiationEquivalentDoseRateUnit.MillisievertPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MillisievertPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.MillisievertPerSecond"/>
         /// </summary>
-        public double MillisievertsPerSecond => As(RadiationEquivalentDoseRateUnit.MillisievertPerSecond);
+        public QuantityValue MillisievertsPerSecond => this.As(RadiationEquivalentDoseRateUnit.MillisievertPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.NanosievertPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.NanosievertPerHour"/>
         /// </summary>
-        public double NanosievertsPerHour => As(RadiationEquivalentDoseRateUnit.NanosievertPerHour);
+        public QuantityValue NanosievertsPerHour => this.As(RadiationEquivalentDoseRateUnit.NanosievertPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.NanosievertPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.NanosievertPerSecond"/>
         /// </summary>
-        public double NanosievertsPerSecond => As(RadiationEquivalentDoseRateUnit.NanosievertPerSecond);
+        public QuantityValue NanosievertsPerSecond => this.As(RadiationEquivalentDoseRateUnit.NanosievertPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour"/>
         /// </summary>
-        public double RoentgensEquivalentManPerHour => As(RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour);
+        public QuantityValue RoentgensEquivalentManPerHour => this.As(RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.SievertPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.SievertPerHour"/>
         /// </summary>
-        public double SievertsPerHour => As(RadiationEquivalentDoseRateUnit.SievertPerHour);
+        public QuantityValue SievertsPerHour => this.As(RadiationEquivalentDoseRateUnit.SievertPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.SievertPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationEquivalentDoseRateUnit.SievertPerSecond"/>
         /// </summary>
-        public double SievertsPerSecond => As(RadiationEquivalentDoseRateUnit.SievertPerSecond);
+        public QuantityValue SievertsPerSecond => this.As(RadiationEquivalentDoseRateUnit.SievertPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RadiationEquivalentDoseRateUnit -> BaseUnit
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.MicrosievertPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.SievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.MicrosievertPerSecond, RadiationEquivalentDoseRateUnit.SievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.SievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.SievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.MillisievertPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.SievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.MillisievertPerSecond, RadiationEquivalentDoseRateUnit.SievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.SievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.NanosievertPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.SievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.NanosievertPerSecond, RadiationEquivalentDoseRateUnit.SievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.SievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.SievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.SievertPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.SievertPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RadiationEquivalentDoseRateUnit
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.MicrosievertPerHour, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.MicrosievertPerHour));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.MicrosievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.MicrosievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.MillisievertPerHour, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.MillisievertPerHour));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.MillisievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.MillisievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.NanosievertPerHour, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.NanosievertPerHour));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.NanosievertPerSecond, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.NanosievertPerSecond));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour));
-            unitConverter.SetConversionFunction<RadiationEquivalentDoseRate>(RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.SievertPerHour, quantity => quantity.ToUnit(RadiationEquivalentDoseRateUnit.SievertPerHour));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -347,7 +329,7 @@ public static string GetAbbreviation(RadiationEquivalentDoseRateUnit unit, IForm
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.MicrosievertPerHour"/>.
         /// </summary>
-        public static RadiationEquivalentDoseRate FromMicrosievertsPerHour(double value)
+        public static RadiationEquivalentDoseRate FromMicrosievertsPerHour(QuantityValue value)
         {
             return new RadiationEquivalentDoseRate(value, RadiationEquivalentDoseRateUnit.MicrosievertPerHour);
         }
@@ -355,7 +337,7 @@ public static RadiationEquivalentDoseRate FromMicrosievertsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.MicrosievertPerSecond"/>.
         /// </summary>
-        public static RadiationEquivalentDoseRate FromMicrosievertsPerSecond(double value)
+        public static RadiationEquivalentDoseRate FromMicrosievertsPerSecond(QuantityValue value)
         {
             return new RadiationEquivalentDoseRate(value, RadiationEquivalentDoseRateUnit.MicrosievertPerSecond);
         }
@@ -363,7 +345,7 @@ public static RadiationEquivalentDoseRate FromMicrosievertsPerSecond(double valu
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour"/>.
         /// </summary>
-        public static RadiationEquivalentDoseRate FromMilliroentgensEquivalentManPerHour(double value)
+        public static RadiationEquivalentDoseRate FromMilliroentgensEquivalentManPerHour(QuantityValue value)
         {
             return new RadiationEquivalentDoseRate(value, RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour);
         }
@@ -371,7 +353,7 @@ public static RadiationEquivalentDoseRate FromMilliroentgensEquivalentManPerHour
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.MillisievertPerHour"/>.
         /// </summary>
-        public static RadiationEquivalentDoseRate FromMillisievertsPerHour(double value)
+        public static RadiationEquivalentDoseRate FromMillisievertsPerHour(QuantityValue value)
         {
             return new RadiationEquivalentDoseRate(value, RadiationEquivalentDoseRateUnit.MillisievertPerHour);
         }
@@ -379,7 +361,7 @@ public static RadiationEquivalentDoseRate FromMillisievertsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.MillisievertPerSecond"/>.
         /// </summary>
-        public static RadiationEquivalentDoseRate FromMillisievertsPerSecond(double value)
+        public static RadiationEquivalentDoseRate FromMillisievertsPerSecond(QuantityValue value)
         {
             return new RadiationEquivalentDoseRate(value, RadiationEquivalentDoseRateUnit.MillisievertPerSecond);
         }
@@ -387,7 +369,7 @@ public static RadiationEquivalentDoseRate FromMillisievertsPerSecond(double valu
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.NanosievertPerHour"/>.
         /// </summary>
-        public static RadiationEquivalentDoseRate FromNanosievertsPerHour(double value)
+        public static RadiationEquivalentDoseRate FromNanosievertsPerHour(QuantityValue value)
         {
             return new RadiationEquivalentDoseRate(value, RadiationEquivalentDoseRateUnit.NanosievertPerHour);
         }
@@ -395,7 +377,7 @@ public static RadiationEquivalentDoseRate FromNanosievertsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.NanosievertPerSecond"/>.
         /// </summary>
-        public static RadiationEquivalentDoseRate FromNanosievertsPerSecond(double value)
+        public static RadiationEquivalentDoseRate FromNanosievertsPerSecond(QuantityValue value)
         {
             return new RadiationEquivalentDoseRate(value, RadiationEquivalentDoseRateUnit.NanosievertPerSecond);
         }
@@ -403,7 +385,7 @@ public static RadiationEquivalentDoseRate FromNanosievertsPerSecond(double value
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour"/>.
         /// </summary>
-        public static RadiationEquivalentDoseRate FromRoentgensEquivalentManPerHour(double value)
+        public static RadiationEquivalentDoseRate FromRoentgensEquivalentManPerHour(QuantityValue value)
         {
             return new RadiationEquivalentDoseRate(value, RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour);
         }
@@ -411,7 +393,7 @@ public static RadiationEquivalentDoseRate FromRoentgensEquivalentManPerHour(doub
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.SievertPerHour"/>.
         /// </summary>
-        public static RadiationEquivalentDoseRate FromSievertsPerHour(double value)
+        public static RadiationEquivalentDoseRate FromSievertsPerHour(QuantityValue value)
         {
             return new RadiationEquivalentDoseRate(value, RadiationEquivalentDoseRateUnit.SievertPerHour);
         }
@@ -419,7 +401,7 @@ public static RadiationEquivalentDoseRate FromSievertsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationEquivalentDoseRate"/> from <see cref="RadiationEquivalentDoseRateUnit.SievertPerSecond"/>.
         /// </summary>
-        public static RadiationEquivalentDoseRate FromSievertsPerSecond(double value)
+        public static RadiationEquivalentDoseRate FromSievertsPerSecond(QuantityValue value)
         {
             return new RadiationEquivalentDoseRate(value, RadiationEquivalentDoseRateUnit.SievertPerSecond);
         }
@@ -430,7 +412,7 @@ public static RadiationEquivalentDoseRate FromSievertsPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RadiationEquivalentDoseRate unit value.</returns>
-        public static RadiationEquivalentDoseRate From(double value, RadiationEquivalentDoseRateUnit fromUnit)
+        public static RadiationEquivalentDoseRate From(QuantityValue value, RadiationEquivalentDoseRateUnit fromUnit)
         {
             return new RadiationEquivalentDoseRate(value, fromUnit);
         }
@@ -491,10 +473,7 @@ public static RadiationEquivalentDoseRate Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static RadiationEquivalentDoseRate Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<RadiationEquivalentDoseRate, RadiationEquivalentDoseRateUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<RadiationEquivalentDoseRate, RadiationEquivalentDoseRateUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -522,11 +501,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out RadiationEquival
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out RadiationEquivalentDoseRate result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<RadiationEquivalentDoseRate, RadiationEquivalentDoseRateUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<RadiationEquivalentDoseRate, RadiationEquivalentDoseRateUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -547,7 +522,7 @@ public static RadiationEquivalentDoseRateUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -558,7 +533,7 @@ public static RadiationEquivalentDoseRateUnit ParseUnit(string str, IFormatProvi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RadiationEquivalentDoseRateUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RadiationEquivalentDoseRateUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RadiationEquivalentDoseRateUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -573,7 +548,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RadiationEqu
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RadiationEquivalentDoseRateUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -592,35 +567,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="RadiationEquivalentDoseRate"/> from adding two <see cref="RadiationEquivalentDoseRate"/>.</summary>
         public static RadiationEquivalentDoseRate operator +(RadiationEquivalentDoseRate left, RadiationEquivalentDoseRate right)
         {
-            return new RadiationEquivalentDoseRate(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new RadiationEquivalentDoseRate(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RadiationEquivalentDoseRate"/> from subtracting two <see cref="RadiationEquivalentDoseRate"/>.</summary>
         public static RadiationEquivalentDoseRate operator -(RadiationEquivalentDoseRate left, RadiationEquivalentDoseRate right)
         {
-            return new RadiationEquivalentDoseRate(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new RadiationEquivalentDoseRate(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RadiationEquivalentDoseRate"/> from multiplying value and <see cref="RadiationEquivalentDoseRate"/>.</summary>
-        public static RadiationEquivalentDoseRate operator *(double left, RadiationEquivalentDoseRate right)
+        public static RadiationEquivalentDoseRate operator *(QuantityValue left, RadiationEquivalentDoseRate right)
         {
             return new RadiationEquivalentDoseRate(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="RadiationEquivalentDoseRate"/> from multiplying value and <see cref="RadiationEquivalentDoseRate"/>.</summary>
-        public static RadiationEquivalentDoseRate operator *(RadiationEquivalentDoseRate left, double right)
+        public static RadiationEquivalentDoseRate operator *(RadiationEquivalentDoseRate left, QuantityValue right)
         {
             return new RadiationEquivalentDoseRate(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="RadiationEquivalentDoseRate"/> from dividing <see cref="RadiationEquivalentDoseRate"/> by value.</summary>
-        public static RadiationEquivalentDoseRate operator /(RadiationEquivalentDoseRate left, double right)
+        public static RadiationEquivalentDoseRate operator /(RadiationEquivalentDoseRate left, QuantityValue right)
         {
             return new RadiationEquivalentDoseRate(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="RadiationEquivalentDoseRate"/> by <see cref="RadiationEquivalentDoseRate"/>.</summary>
-        public static double operator /(RadiationEquivalentDoseRate left, RadiationEquivalentDoseRate right)
+        public static QuantityValue operator /(RadiationEquivalentDoseRate left, RadiationEquivalentDoseRate right)
         {
             return left.SievertsPerSecond / right.SievertsPerSecond;
         }
@@ -642,97 +617,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(RadiationEquivalentDoseRate left, RadiationEquivalentDoseRate right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(RadiationEquivalentDoseRate left, RadiationEquivalentDoseRate right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(RadiationEquivalentDoseRate left, RadiationEquivalentDoseRate right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(RadiationEquivalentDoseRate left, RadiationEquivalentDoseRate right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="RadiationEquivalentDoseRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RadiationEquivalentDoseRate other, RadiationEquivalentDoseRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RadiationEquivalentDoseRate"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(RadiationEquivalentDoseRate)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(RadiationEquivalentDoseRate left, RadiationEquivalentDoseRate right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="RadiationEquivalentDoseRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RadiationEquivalentDoseRate other, RadiationEquivalentDoseRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RadiationEquivalentDoseRate"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(RadiationEquivalentDoseRate,RadiationEquivalentDoseRate)"/>.
+        ///     See that operator (and <see cref="Equals(RadiationEquivalentDoseRate)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(RadiationEquivalentDoseRate left, RadiationEquivalentDoseRate right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RadiationEquivalentDoseRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RadiationEquivalentDoseRate other, RadiationEquivalentDoseRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="RadiationEquivalentDoseRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="RadiationEquivalentDoseRate"/>.
+        ///     When <paramref name="obj"/> is a <see cref="RadiationEquivalentDoseRate"/>, this method delegates to
+        ///     <see cref="Equals(RadiationEquivalentDoseRate)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is RadiationEquivalentDoseRate otherQuantity))
+            if (obj is not RadiationEquivalentDoseRate otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RadiationEquivalentDoseRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RadiationEquivalentDoseRate other, RadiationEquivalentDoseRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="RadiationEquivalentDoseRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(RadiationEquivalentDoseRate other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current RadiationEquivalentDoseRate.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(RadiationEquivalentDoseRate), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="RadiationEquivalentDoseRate"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(RadiationEquivalentDoseRate)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is RadiationEquivalentDoseRate otherQuantity)) throw new ArgumentException("Expected type RadiationEquivalentDoseRate.", nameof(obj));
+            if (obj is not RadiationEquivalentDoseRate otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<RadiationEquivalentDoseRate>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="RadiationEquivalentDoseRate"/> with another <see cref="RadiationEquivalentDoseRate"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="RadiationEquivalentDoseRate"/> with another <see cref="RadiationEquivalentDoseRate"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -744,147 +733,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(RadiationEquivalentDoseRate other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RadiationEquivalentDoseRateUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RadiationEquivalentDoseRateUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this RadiationEquivalentDoseRate to another RadiationEquivalentDoseRate with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A RadiationEquivalentDoseRate with the specified unit.</returns>
-        public RadiationEquivalentDoseRate ToUnit(RadiationEquivalentDoseRateUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="RadiationEquivalentDoseRate"/> to another <see cref="RadiationEquivalentDoseRate"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A RadiationEquivalentDoseRate with the specified unit.</returns>
-        public RadiationEquivalentDoseRate ToUnit(RadiationEquivalentDoseRateUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(RadiationEquivalentDoseRate), Unit, typeof(RadiationEquivalentDoseRate), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (RadiationEquivalentDoseRate)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="RadiationEquivalentDoseRate"/> to another <see cref="RadiationEquivalentDoseRate"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="RadiationEquivalentDoseRate"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RadiationEquivalentDoseRateUnit unit, [NotNullWhen(true)] out RadiationEquivalentDoseRate? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            RadiationEquivalentDoseRate? convertedOrNull = (Unit, unit) switch
-            {
-                // RadiationEquivalentDoseRateUnit -> BaseUnit
-                (RadiationEquivalentDoseRateUnit.MicrosievertPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond) => new RadiationEquivalentDoseRate((_value/3600) * 1e-6d, RadiationEquivalentDoseRateUnit.SievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.MicrosievertPerSecond, RadiationEquivalentDoseRateUnit.SievertPerSecond) => new RadiationEquivalentDoseRate((_value) * 1e-6d, RadiationEquivalentDoseRateUnit.SievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond) => new RadiationEquivalentDoseRate((_value / 100 / 3600) * 1e-3d, RadiationEquivalentDoseRateUnit.SievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.MillisievertPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond) => new RadiationEquivalentDoseRate((_value/3600) * 1e-3d, RadiationEquivalentDoseRateUnit.SievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.MillisievertPerSecond, RadiationEquivalentDoseRateUnit.SievertPerSecond) => new RadiationEquivalentDoseRate((_value) * 1e-3d, RadiationEquivalentDoseRateUnit.SievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.NanosievertPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond) => new RadiationEquivalentDoseRate((_value/3600) * 1e-9d, RadiationEquivalentDoseRateUnit.SievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.NanosievertPerSecond, RadiationEquivalentDoseRateUnit.SievertPerSecond) => new RadiationEquivalentDoseRate((_value) * 1e-9d, RadiationEquivalentDoseRateUnit.SievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond) => new RadiationEquivalentDoseRate(_value / 100 / 3600, RadiationEquivalentDoseRateUnit.SievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.SievertPerHour, RadiationEquivalentDoseRateUnit.SievertPerSecond) => new RadiationEquivalentDoseRate(_value/3600, RadiationEquivalentDoseRateUnit.SievertPerSecond),
-
-                // BaseUnit -> RadiationEquivalentDoseRateUnit
-                (RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.MicrosievertPerHour) => new RadiationEquivalentDoseRate((_value*3600) / 1e-6d, RadiationEquivalentDoseRateUnit.MicrosievertPerHour),
-                (RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.MicrosievertPerSecond) => new RadiationEquivalentDoseRate((_value) / 1e-6d, RadiationEquivalentDoseRateUnit.MicrosievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour) => new RadiationEquivalentDoseRate((_value * 100 * 3600) / 1e-3d, RadiationEquivalentDoseRateUnit.MilliroentgenEquivalentManPerHour),
-                (RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.MillisievertPerHour) => new RadiationEquivalentDoseRate((_value*3600) / 1e-3d, RadiationEquivalentDoseRateUnit.MillisievertPerHour),
-                (RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.MillisievertPerSecond) => new RadiationEquivalentDoseRate((_value) / 1e-3d, RadiationEquivalentDoseRateUnit.MillisievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.NanosievertPerHour) => new RadiationEquivalentDoseRate((_value*3600) / 1e-9d, RadiationEquivalentDoseRateUnit.NanosievertPerHour),
-                (RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.NanosievertPerSecond) => new RadiationEquivalentDoseRate((_value) / 1e-9d, RadiationEquivalentDoseRateUnit.NanosievertPerSecond),
-                (RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour) => new RadiationEquivalentDoseRate(_value * 100 * 3600, RadiationEquivalentDoseRateUnit.RoentgenEquivalentManPerHour),
-                (RadiationEquivalentDoseRateUnit.SievertPerSecond, RadiationEquivalentDoseRateUnit.SievertPerHour) => new RadiationEquivalentDoseRate(_value*3600, RadiationEquivalentDoseRateUnit.SievertPerHour),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RadiationEquivalentDoseRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadiationEquivalentDoseRateUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RadiationEquivalentDoseRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadiationEquivalentDoseRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RadiationEquivalentDoseRateUnit> IQuantity<RadiationEquivalentDoseRateUnit>.ToUnit(RadiationEquivalentDoseRateUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -898,11 +749,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs b/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
index 812da76551..559bbd243f 100644
--- a/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Radiation exposure is a measure of the ionization of air due to ionizing radiation from photons.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct RadiationExposure :
-        IArithmeticQuantity<RadiationExposure, RadiationExposureUnit>,
+        ILinearQuantity<RadiationExposure, RadiationExposureUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<RadiationExposure, RadiationExposure, double>,
+        IDivisionOperators<RadiationExposure, RadiationExposure, QuantityValue>,
         IComparisonOperators<RadiationExposure, RadiationExposure, bool>,
         IParsable<RadiationExposure>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +101,7 @@ public static RadiationExposureInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="RadiationExposure"/> is [T][M^-1][I].
+            ///     The <see cref="BaseDimensions" /> for <see cref="RadiationExposure"/> is TM^-1I.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, -1, 1, 1, 0, 0, 0);
 
@@ -118,21 +117,33 @@ public static RadiationExposureInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             public static IEnumerable<UnitDefinition<RadiationExposureUnit>> GetDefaultMappings()
             {
                 yield return new (RadiationExposureUnit.CoulombPerKilogram, "CoulombPerKilogram", "CoulombsPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
-                yield return new (RadiationExposureUnit.MicrocoulombPerKilogram, "MicrocoulombPerKilogram", "MicrocoulombsPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere));
-                yield return new (RadiationExposureUnit.Microroentgen, "Microroentgen", "Microroentgens", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere));
-                yield return new (RadiationExposureUnit.MillicoulombPerKilogram, "MillicoulombPerKilogram", "MillicoulombsPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
-                yield return new (RadiationExposureUnit.Milliroentgen, "Milliroentgen", "Milliroentgens", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere));
-                yield return new (RadiationExposureUnit.NanocoulombPerKilogram, "NanocoulombPerKilogram", "NanocoulombsPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Nanoampere));
-                yield return new (RadiationExposureUnit.PicocoulombPerKilogram, "PicocoulombPerKilogram", "PicocoulombsPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Picoampere));
-                yield return new (RadiationExposureUnit.Roentgen, "Roentgen", "Roentgens", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere));
+                yield return new (RadiationExposureUnit.MicrocoulombPerKilogram, "MicrocoulombPerKilogram", "MicrocoulombsPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere),
+                     1000000
+                );
+                yield return new (RadiationExposureUnit.Microroentgen, "Microroentgen", "Microroentgens", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Microampere),
+                     new QuantityValue(500000000000, 129)
+                );
+                yield return new (RadiationExposureUnit.MillicoulombPerKilogram, "MillicoulombPerKilogram", "MillicoulombsPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     1000
+                );
+                yield return new (RadiationExposureUnit.Milliroentgen, "Milliroentgen", "Milliroentgens", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Milliampere),
+                     new QuantityValue(500000000, 129)
+                );
+                yield return new (RadiationExposureUnit.NanocoulombPerKilogram, "NanocoulombPerKilogram", "NanocoulombsPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Nanoampere),
+                     1000000000
+                );
+                yield return new (RadiationExposureUnit.PicocoulombPerKilogram, "PicocoulombPerKilogram", "PicocoulombsPerKilogram", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Picoampere),
+                     1000000000000
+                );
+                yield return new (RadiationExposureUnit.Roentgen, "Roentgen", "Roentgens", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere),
+                     new QuantityValue(500000, 129)
+                );
             }
         }
 
         static RadiationExposure()
         {
-            Info = RadiationExposureInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RadiationExposureInfo.CreateDefault);
         }
 
         /// <summary>
@@ -140,7 +151,7 @@ static RadiationExposure()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RadiationExposure(double value, RadiationExposureUnit unit)
+        public RadiationExposure(QuantityValue value, RadiationExposureUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -154,7 +165,7 @@ public RadiationExposure(double value, RadiationExposureUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RadiationExposure(double value, UnitSystem unitSystem)
+        public RadiationExposure(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -165,7 +176,8 @@ public RadiationExposure(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="RadiationExposure" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<RadiationExposure, RadiationExposureUnit> Info { get; }
@@ -194,10 +206,8 @@ public RadiationExposure(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RadiationExposureUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -231,77 +241,49 @@ public RadiationExposure(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.CoulombPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationExposureUnit.CoulombPerKilogram"/>
         /// </summary>
-        public double CoulombsPerKilogram => As(RadiationExposureUnit.CoulombPerKilogram);
+        public QuantityValue CoulombsPerKilogram => this.As(RadiationExposureUnit.CoulombPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.MicrocoulombPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationExposureUnit.MicrocoulombPerKilogram"/>
         /// </summary>
-        public double MicrocoulombsPerKilogram => As(RadiationExposureUnit.MicrocoulombPerKilogram);
+        public QuantityValue MicrocoulombsPerKilogram => this.As(RadiationExposureUnit.MicrocoulombPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.Microroentgen"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationExposureUnit.Microroentgen"/>
         /// </summary>
-        public double Microroentgens => As(RadiationExposureUnit.Microroentgen);
+        public QuantityValue Microroentgens => this.As(RadiationExposureUnit.Microroentgen);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.MillicoulombPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationExposureUnit.MillicoulombPerKilogram"/>
         /// </summary>
-        public double MillicoulombsPerKilogram => As(RadiationExposureUnit.MillicoulombPerKilogram);
+        public QuantityValue MillicoulombsPerKilogram => this.As(RadiationExposureUnit.MillicoulombPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.Milliroentgen"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationExposureUnit.Milliroentgen"/>
         /// </summary>
-        public double Milliroentgens => As(RadiationExposureUnit.Milliroentgen);
+        public QuantityValue Milliroentgens => this.As(RadiationExposureUnit.Milliroentgen);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.NanocoulombPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationExposureUnit.NanocoulombPerKilogram"/>
         /// </summary>
-        public double NanocoulombsPerKilogram => As(RadiationExposureUnit.NanocoulombPerKilogram);
+        public QuantityValue NanocoulombsPerKilogram => this.As(RadiationExposureUnit.NanocoulombPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.PicocoulombPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationExposureUnit.PicocoulombPerKilogram"/>
         /// </summary>
-        public double PicocoulombsPerKilogram => As(RadiationExposureUnit.PicocoulombPerKilogram);
+        public QuantityValue PicocoulombsPerKilogram => this.As(RadiationExposureUnit.PicocoulombPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadiationExposureUnit.Roentgen"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadiationExposureUnit.Roentgen"/>
         /// </summary>
-        public double Roentgens => As(RadiationExposureUnit.Roentgen);
+        public QuantityValue Roentgens => this.As(RadiationExposureUnit.Roentgen);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RadiationExposureUnit -> BaseUnit
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.MicrocoulombPerKilogram, RadiationExposureUnit.CoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.CoulombPerKilogram));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.Microroentgen, RadiationExposureUnit.CoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.CoulombPerKilogram));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.MillicoulombPerKilogram, RadiationExposureUnit.CoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.CoulombPerKilogram));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.Milliroentgen, RadiationExposureUnit.CoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.CoulombPerKilogram));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.NanocoulombPerKilogram, RadiationExposureUnit.CoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.CoulombPerKilogram));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.PicocoulombPerKilogram, RadiationExposureUnit.CoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.CoulombPerKilogram));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.Roentgen, RadiationExposureUnit.CoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.CoulombPerKilogram));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.CoulombPerKilogram, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RadiationExposureUnit
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.MicrocoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.MicrocoulombPerKilogram));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.Microroentgen, quantity => quantity.ToUnit(RadiationExposureUnit.Microroentgen));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.MillicoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.MillicoulombPerKilogram));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.Milliroentgen, quantity => quantity.ToUnit(RadiationExposureUnit.Milliroentgen));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.NanocoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.NanocoulombPerKilogram));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.PicocoulombPerKilogram, quantity => quantity.ToUnit(RadiationExposureUnit.PicocoulombPerKilogram));
-            unitConverter.SetConversionFunction<RadiationExposure>(RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.Roentgen, quantity => quantity.ToUnit(RadiationExposureUnit.Roentgen));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -330,7 +312,7 @@ public static string GetAbbreviation(RadiationExposureUnit unit, IFormatProvider
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.CoulombPerKilogram"/>.
         /// </summary>
-        public static RadiationExposure FromCoulombsPerKilogram(double value)
+        public static RadiationExposure FromCoulombsPerKilogram(QuantityValue value)
         {
             return new RadiationExposure(value, RadiationExposureUnit.CoulombPerKilogram);
         }
@@ -338,7 +320,7 @@ public static RadiationExposure FromCoulombsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.MicrocoulombPerKilogram"/>.
         /// </summary>
-        public static RadiationExposure FromMicrocoulombsPerKilogram(double value)
+        public static RadiationExposure FromMicrocoulombsPerKilogram(QuantityValue value)
         {
             return new RadiationExposure(value, RadiationExposureUnit.MicrocoulombPerKilogram);
         }
@@ -346,7 +328,7 @@ public static RadiationExposure FromMicrocoulombsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Microroentgen"/>.
         /// </summary>
-        public static RadiationExposure FromMicroroentgens(double value)
+        public static RadiationExposure FromMicroroentgens(QuantityValue value)
         {
             return new RadiationExposure(value, RadiationExposureUnit.Microroentgen);
         }
@@ -354,7 +336,7 @@ public static RadiationExposure FromMicroroentgens(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.MillicoulombPerKilogram"/>.
         /// </summary>
-        public static RadiationExposure FromMillicoulombsPerKilogram(double value)
+        public static RadiationExposure FromMillicoulombsPerKilogram(QuantityValue value)
         {
             return new RadiationExposure(value, RadiationExposureUnit.MillicoulombPerKilogram);
         }
@@ -362,7 +344,7 @@ public static RadiationExposure FromMillicoulombsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Milliroentgen"/>.
         /// </summary>
-        public static RadiationExposure FromMilliroentgens(double value)
+        public static RadiationExposure FromMilliroentgens(QuantityValue value)
         {
             return new RadiationExposure(value, RadiationExposureUnit.Milliroentgen);
         }
@@ -370,7 +352,7 @@ public static RadiationExposure FromMilliroentgens(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.NanocoulombPerKilogram"/>.
         /// </summary>
-        public static RadiationExposure FromNanocoulombsPerKilogram(double value)
+        public static RadiationExposure FromNanocoulombsPerKilogram(QuantityValue value)
         {
             return new RadiationExposure(value, RadiationExposureUnit.NanocoulombPerKilogram);
         }
@@ -378,7 +360,7 @@ public static RadiationExposure FromNanocoulombsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.PicocoulombPerKilogram"/>.
         /// </summary>
-        public static RadiationExposure FromPicocoulombsPerKilogram(double value)
+        public static RadiationExposure FromPicocoulombsPerKilogram(QuantityValue value)
         {
             return new RadiationExposure(value, RadiationExposureUnit.PicocoulombPerKilogram);
         }
@@ -386,7 +368,7 @@ public static RadiationExposure FromPicocoulombsPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Roentgen"/>.
         /// </summary>
-        public static RadiationExposure FromRoentgens(double value)
+        public static RadiationExposure FromRoentgens(QuantityValue value)
         {
             return new RadiationExposure(value, RadiationExposureUnit.Roentgen);
         }
@@ -397,7 +379,7 @@ public static RadiationExposure FromRoentgens(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RadiationExposure unit value.</returns>
-        public static RadiationExposure From(double value, RadiationExposureUnit fromUnit)
+        public static RadiationExposure From(QuantityValue value, RadiationExposureUnit fromUnit)
         {
             return new RadiationExposure(value, fromUnit);
         }
@@ -458,10 +440,7 @@ public static RadiationExposure Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static RadiationExposure Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<RadiationExposure, RadiationExposureUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<RadiationExposure, RadiationExposureUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -489,11 +468,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out RadiationExposur
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out RadiationExposure result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<RadiationExposure, RadiationExposureUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<RadiationExposure, RadiationExposureUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -514,7 +489,7 @@ public static RadiationExposureUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -525,7 +500,7 @@ public static RadiationExposureUnit ParseUnit(string str, IFormatProvider? provi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RadiationExposureUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RadiationExposureUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RadiationExposureUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -540,7 +515,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RadiationExp
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RadiationExposureUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -559,35 +534,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="RadiationExposure"/> from adding two <see cref="RadiationExposure"/>.</summary>
         public static RadiationExposure operator +(RadiationExposure left, RadiationExposure right)
         {
-            return new RadiationExposure(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new RadiationExposure(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RadiationExposure"/> from subtracting two <see cref="RadiationExposure"/>.</summary>
         public static RadiationExposure operator -(RadiationExposure left, RadiationExposure right)
         {
-            return new RadiationExposure(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new RadiationExposure(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RadiationExposure"/> from multiplying value and <see cref="RadiationExposure"/>.</summary>
-        public static RadiationExposure operator *(double left, RadiationExposure right)
+        public static RadiationExposure operator *(QuantityValue left, RadiationExposure right)
         {
             return new RadiationExposure(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="RadiationExposure"/> from multiplying value and <see cref="RadiationExposure"/>.</summary>
-        public static RadiationExposure operator *(RadiationExposure left, double right)
+        public static RadiationExposure operator *(RadiationExposure left, QuantityValue right)
         {
             return new RadiationExposure(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="RadiationExposure"/> from dividing <see cref="RadiationExposure"/> by value.</summary>
-        public static RadiationExposure operator /(RadiationExposure left, double right)
+        public static RadiationExposure operator /(RadiationExposure left, QuantityValue right)
         {
             return new RadiationExposure(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="RadiationExposure"/> by <see cref="RadiationExposure"/>.</summary>
-        public static double operator /(RadiationExposure left, RadiationExposure right)
+        public static QuantityValue operator /(RadiationExposure left, RadiationExposure right)
         {
             return left.CoulombsPerKilogram / right.CoulombsPerKilogram;
         }
@@ -599,97 +574,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(RadiationExposure left, RadiationExposure right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(RadiationExposure left, RadiationExposure right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(RadiationExposure left, RadiationExposure right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(RadiationExposure left, RadiationExposure right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="RadiationExposure"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RadiationExposure other, RadiationExposure tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RadiationExposure"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(RadiationExposure)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(RadiationExposure left, RadiationExposure right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="RadiationExposure"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RadiationExposure other, RadiationExposure tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RadiationExposure"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(RadiationExposure,RadiationExposure)"/>.
+        ///     See that operator (and <see cref="Equals(RadiationExposure)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(RadiationExposure left, RadiationExposure right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RadiationExposure"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RadiationExposure other, RadiationExposure tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="RadiationExposure"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="RadiationExposure"/>.
+        ///     When <paramref name="obj"/> is a <see cref="RadiationExposure"/>, this method delegates to
+        ///     <see cref="Equals(RadiationExposure)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is RadiationExposure otherQuantity))
+            if (obj is not RadiationExposure otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RadiationExposure"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RadiationExposure other, RadiationExposure tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="RadiationExposure"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(RadiationExposure other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current RadiationExposure.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(RadiationExposure), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="RadiationExposure"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(RadiationExposure)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is RadiationExposure otherQuantity)) throw new ArgumentException("Expected type RadiationExposure.", nameof(obj));
+            if (obj is not RadiationExposure otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<RadiationExposure>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="RadiationExposure"/> with another <see cref="RadiationExposure"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="RadiationExposure"/> with another <see cref="RadiationExposure"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -701,143 +690,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(RadiationExposure other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RadiationExposureUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RadiationExposureUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this RadiationExposure to another RadiationExposure with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A RadiationExposure with the specified unit.</returns>
-        public RadiationExposure ToUnit(RadiationExposureUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="RadiationExposure"/> to another <see cref="RadiationExposure"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A RadiationExposure with the specified unit.</returns>
-        public RadiationExposure ToUnit(RadiationExposureUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(RadiationExposure), Unit, typeof(RadiationExposure), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (RadiationExposure)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="RadiationExposure"/> to another <see cref="RadiationExposure"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="RadiationExposure"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RadiationExposureUnit unit, [NotNullWhen(true)] out RadiationExposure? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            RadiationExposure? convertedOrNull = (Unit, unit) switch
-            {
-                // RadiationExposureUnit -> BaseUnit
-                (RadiationExposureUnit.MicrocoulombPerKilogram, RadiationExposureUnit.CoulombPerKilogram) => new RadiationExposure((_value) * 1e-6d, RadiationExposureUnit.CoulombPerKilogram),
-                (RadiationExposureUnit.Microroentgen, RadiationExposureUnit.CoulombPerKilogram) => new RadiationExposure((_value * 2.58e-4) * 1e-6d, RadiationExposureUnit.CoulombPerKilogram),
-                (RadiationExposureUnit.MillicoulombPerKilogram, RadiationExposureUnit.CoulombPerKilogram) => new RadiationExposure((_value) * 1e-3d, RadiationExposureUnit.CoulombPerKilogram),
-                (RadiationExposureUnit.Milliroentgen, RadiationExposureUnit.CoulombPerKilogram) => new RadiationExposure((_value * 2.58e-4) * 1e-3d, RadiationExposureUnit.CoulombPerKilogram),
-                (RadiationExposureUnit.NanocoulombPerKilogram, RadiationExposureUnit.CoulombPerKilogram) => new RadiationExposure((_value) * 1e-9d, RadiationExposureUnit.CoulombPerKilogram),
-                (RadiationExposureUnit.PicocoulombPerKilogram, RadiationExposureUnit.CoulombPerKilogram) => new RadiationExposure((_value) * 1e-12d, RadiationExposureUnit.CoulombPerKilogram),
-                (RadiationExposureUnit.Roentgen, RadiationExposureUnit.CoulombPerKilogram) => new RadiationExposure(_value * 2.58e-4, RadiationExposureUnit.CoulombPerKilogram),
-
-                // BaseUnit -> RadiationExposureUnit
-                (RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.MicrocoulombPerKilogram) => new RadiationExposure((_value) / 1e-6d, RadiationExposureUnit.MicrocoulombPerKilogram),
-                (RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.Microroentgen) => new RadiationExposure((_value / 2.58e-4) / 1e-6d, RadiationExposureUnit.Microroentgen),
-                (RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.MillicoulombPerKilogram) => new RadiationExposure((_value) / 1e-3d, RadiationExposureUnit.MillicoulombPerKilogram),
-                (RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.Milliroentgen) => new RadiationExposure((_value / 2.58e-4) / 1e-3d, RadiationExposureUnit.Milliroentgen),
-                (RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.NanocoulombPerKilogram) => new RadiationExposure((_value) / 1e-9d, RadiationExposureUnit.NanocoulombPerKilogram),
-                (RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.PicocoulombPerKilogram) => new RadiationExposure((_value) / 1e-12d, RadiationExposureUnit.PicocoulombPerKilogram),
-                (RadiationExposureUnit.CoulombPerKilogram, RadiationExposureUnit.Roentgen) => new RadiationExposure(_value / 2.58e-4, RadiationExposureUnit.Roentgen),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RadiationExposureUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadiationExposureUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RadiationExposureUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadiationExposureUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RadiationExposureUnit> IQuantity<RadiationExposureUnit>.ToUnit(RadiationExposureUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -851,11 +706,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
index a96a95c519..54151c6769 100644
--- a/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Amount of ionizing radiation released when an element spontaneously emits energy as a result of the radioactive decay of an unstable atom per unit time.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Radioactivity :
-        IArithmeticQuantity<Radioactivity, RadioactivityUnit>,
+        ILinearQuantity<Radioactivity, RadioactivityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Radioactivity, Radioactivity, double>,
+        IDivisionOperators<Radioactivity, Radioactivity, QuantityValue>,
         IComparisonOperators<Radioactivity, Radioactivity, bool>,
         IParsable<Radioactivity>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +101,7 @@ public static RadioactivityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Ra
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Radioactivity"/> is [T^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Radioactivity"/> is T^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, -1, 0, 0, 0, 0);
 
@@ -118,42 +117,96 @@ public static RadioactivityInfo CreateDefault(Func<IEnumerable<UnitDefinition<Ra
             public static IEnumerable<UnitDefinition<RadioactivityUnit>> GetDefaultMappings()
             {
                 yield return new (RadioactivityUnit.Becquerel, "Becquerel", "Becquerels", new BaseUnits(time: DurationUnit.Second));
-                yield return new (RadioactivityUnit.Curie, "Curie", "Curies", new BaseUnits(time: DurationUnit.Second));
-                yield return new (RadioactivityUnit.Exabecquerel, "Exabecquerel", "Exabecquerels", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Gigabecquerel, "Gigabecquerel", "Gigabecquerels", new BaseUnits(time: DurationUnit.Nanosecond));
-                yield return new (RadioactivityUnit.Gigacurie, "Gigacurie", "Gigacuries", new BaseUnits(time: DurationUnit.Nanosecond));
-                yield return new (RadioactivityUnit.Gigarutherford, "Gigarutherford", "Gigarutherfords", new BaseUnits(time: DurationUnit.Nanosecond));
-                yield return new (RadioactivityUnit.Kilobecquerel, "Kilobecquerel", "Kilobecquerels", new BaseUnits(time: DurationUnit.Millisecond));
-                yield return new (RadioactivityUnit.Kilocurie, "Kilocurie", "Kilocuries", new BaseUnits(time: DurationUnit.Millisecond));
-                yield return new (RadioactivityUnit.Kilorutherford, "Kilorutherford", "Kilorutherfords", new BaseUnits(time: DurationUnit.Millisecond));
-                yield return new (RadioactivityUnit.Megabecquerel, "Megabecquerel", "Megabecquerels", new BaseUnits(time: DurationUnit.Microsecond));
-                yield return new (RadioactivityUnit.Megacurie, "Megacurie", "Megacuries", new BaseUnits(time: DurationUnit.Microsecond));
-                yield return new (RadioactivityUnit.Megarutherford, "Megarutherford", "Megarutherfords", new BaseUnits(time: DurationUnit.Microsecond));
-                yield return new (RadioactivityUnit.Microbecquerel, "Microbecquerel", "Microbecquerels", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Microcurie, "Microcurie", "Microcuries", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Microrutherford, "Microrutherford", "Microrutherfords", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Millibecquerel, "Millibecquerel", "Millibecquerels", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Millicurie, "Millicurie", "Millicuries", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Millirutherford, "Millirutherford", "Millirutherfords", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Nanobecquerel, "Nanobecquerel", "Nanobecquerels", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Nanocurie, "Nanocurie", "Nanocuries", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Nanorutherford, "Nanorutherford", "Nanorutherfords", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Petabecquerel, "Petabecquerel", "Petabecquerels", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Picobecquerel, "Picobecquerel", "Picobecquerels", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Picocurie, "Picocurie", "Picocuries", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Picorutherford, "Picorutherford", "Picorutherfords", BaseUnits.Undefined);
-                yield return new (RadioactivityUnit.Rutherford, "Rutherford", "Rutherfords", new BaseUnits(time: DurationUnit.Second));
-                yield return new (RadioactivityUnit.Terabecquerel, "Terabecquerel", "Terabecquerels", new BaseUnits(time: DurationUnit.Picosecond));
-                yield return new (RadioactivityUnit.Teracurie, "Teracurie", "Teracuries", new BaseUnits(time: DurationUnit.Picosecond));
-                yield return new (RadioactivityUnit.Terarutherford, "Terarutherford", "Terarutherfords", new BaseUnits(time: DurationUnit.Picosecond));
+                yield return new (RadioactivityUnit.Curie, "Curie", "Curies", new BaseUnits(time: DurationUnit.Second),
+                     new QuantityValue(1, 37000000000)
+                );
+                yield return new (RadioactivityUnit.Exabecquerel, "Exabecquerel", "Exabecquerels", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000000)
+                );
+                yield return new (RadioactivityUnit.Gigabecquerel, "Gigabecquerel", "Gigabecquerels", new BaseUnits(time: DurationUnit.Nanosecond),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (RadioactivityUnit.Gigacurie, "Gigacurie", "Gigacuries", new BaseUnits(time: DurationUnit.Nanosecond),
+                     new QuantityValue(1, new BigInteger(37) * QuantityValue.PowerOfTen(18))
+                );
+                yield return new (RadioactivityUnit.Gigarutherford, "Gigarutherford", "Gigarutherfords", new BaseUnits(time: DurationUnit.Nanosecond),
+                     new QuantityValue(1, 1000000000000000)
+                );
+                yield return new (RadioactivityUnit.Kilobecquerel, "Kilobecquerel", "Kilobecquerels", new BaseUnits(time: DurationUnit.Millisecond),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (RadioactivityUnit.Kilocurie, "Kilocurie", "Kilocuries", new BaseUnits(time: DurationUnit.Millisecond),
+                     new QuantityValue(1, 37000000000000)
+                );
+                yield return new (RadioactivityUnit.Kilorutherford, "Kilorutherford", "Kilorutherfords", new BaseUnits(time: DurationUnit.Millisecond),
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (RadioactivityUnit.Megabecquerel, "Megabecquerel", "Megabecquerels", new BaseUnits(time: DurationUnit.Microsecond),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (RadioactivityUnit.Megacurie, "Megacurie", "Megacuries", new BaseUnits(time: DurationUnit.Microsecond),
+                     new QuantityValue(1, 37000000000000000)
+                );
+                yield return new (RadioactivityUnit.Megarutherford, "Megarutherford", "Megarutherfords", new BaseUnits(time: DurationUnit.Microsecond),
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (RadioactivityUnit.Microbecquerel, "Microbecquerel", "Microbecquerels", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (RadioactivityUnit.Microcurie, "Microcurie", "Microcuries", BaseUnits.Undefined,
+                     new QuantityValue(1, 37000)
+                );
+                yield return new (RadioactivityUnit.Microrutherford, "Microrutherford", "Microrutherfords", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (RadioactivityUnit.Millibecquerel, "Millibecquerel", "Millibecquerels", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (RadioactivityUnit.Millicurie, "Millicurie", "Millicuries", BaseUnits.Undefined,
+                     new QuantityValue(1, 37000000)
+                );
+                yield return new (RadioactivityUnit.Millirutherford, "Millirutherford", "Millirutherfords", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (RadioactivityUnit.Nanobecquerel, "Nanobecquerel", "Nanobecquerels", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (RadioactivityUnit.Nanocurie, "Nanocurie", "Nanocuries", BaseUnits.Undefined,
+                     new QuantityValue(1, 37)
+                );
+                yield return new (RadioactivityUnit.Nanorutherford, "Nanorutherford", "Nanorutherfords", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (RadioactivityUnit.Petabecquerel, "Petabecquerel", "Petabecquerels", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000000)
+                );
+                yield return new (RadioactivityUnit.Picobecquerel, "Picobecquerel", "Picobecquerels", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (RadioactivityUnit.Picocurie, "Picocurie", "Picocuries", BaseUnits.Undefined,
+                     new QuantityValue(1000, 37)
+                );
+                yield return new (RadioactivityUnit.Picorutherford, "Picorutherford", "Picorutherfords", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (RadioactivityUnit.Rutherford, "Rutherford", "Rutherfords", new BaseUnits(time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (RadioactivityUnit.Terabecquerel, "Terabecquerel", "Terabecquerels", new BaseUnits(time: DurationUnit.Picosecond),
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (RadioactivityUnit.Teracurie, "Teracurie", "Teracuries", new BaseUnits(time: DurationUnit.Picosecond),
+                     new QuantityValue(1, new BigInteger(37) * QuantityValue.PowerOfTen(21))
+                );
+                yield return new (RadioactivityUnit.Terarutherford, "Terarutherford", "Terarutherfords", new BaseUnits(time: DurationUnit.Picosecond),
+                     new QuantityValue(1, 1000000000000000000)
+                );
             }
         }
 
         static Radioactivity()
         {
-            Info = RadioactivityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RadioactivityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -161,7 +214,7 @@ static Radioactivity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Radioactivity(double value, RadioactivityUnit unit)
+        public Radioactivity(QuantityValue value, RadioactivityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -175,7 +228,7 @@ public Radioactivity(double value, RadioactivityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Radioactivity(double value, UnitSystem unitSystem)
+        public Radioactivity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -186,7 +239,8 @@ public Radioactivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Radioactivity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Radioactivity, RadioactivityUnit> Info { get; }
@@ -215,10 +269,8 @@ public Radioactivity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RadioactivityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -252,224 +304,154 @@ public Radioactivity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Becquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Becquerel"/>
         /// </summary>
-        public double Becquerels => As(RadioactivityUnit.Becquerel);
+        public QuantityValue Becquerels => this.As(RadioactivityUnit.Becquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Curie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Curie"/>
         /// </summary>
-        public double Curies => As(RadioactivityUnit.Curie);
+        public QuantityValue Curies => this.As(RadioactivityUnit.Curie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Exabecquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Exabecquerel"/>
         /// </summary>
-        public double Exabecquerels => As(RadioactivityUnit.Exabecquerel);
+        public QuantityValue Exabecquerels => this.As(RadioactivityUnit.Exabecquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Gigabecquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Gigabecquerel"/>
         /// </summary>
-        public double Gigabecquerels => As(RadioactivityUnit.Gigabecquerel);
+        public QuantityValue Gigabecquerels => this.As(RadioactivityUnit.Gigabecquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Gigacurie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Gigacurie"/>
         /// </summary>
-        public double Gigacuries => As(RadioactivityUnit.Gigacurie);
+        public QuantityValue Gigacuries => this.As(RadioactivityUnit.Gigacurie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Gigarutherford"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Gigarutherford"/>
         /// </summary>
-        public double Gigarutherfords => As(RadioactivityUnit.Gigarutherford);
+        public QuantityValue Gigarutherfords => this.As(RadioactivityUnit.Gigarutherford);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Kilobecquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Kilobecquerel"/>
         /// </summary>
-        public double Kilobecquerels => As(RadioactivityUnit.Kilobecquerel);
+        public QuantityValue Kilobecquerels => this.As(RadioactivityUnit.Kilobecquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Kilocurie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Kilocurie"/>
         /// </summary>
-        public double Kilocuries => As(RadioactivityUnit.Kilocurie);
+        public QuantityValue Kilocuries => this.As(RadioactivityUnit.Kilocurie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Kilorutherford"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Kilorutherford"/>
         /// </summary>
-        public double Kilorutherfords => As(RadioactivityUnit.Kilorutherford);
+        public QuantityValue Kilorutherfords => this.As(RadioactivityUnit.Kilorutherford);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Megabecquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Megabecquerel"/>
         /// </summary>
-        public double Megabecquerels => As(RadioactivityUnit.Megabecquerel);
+        public QuantityValue Megabecquerels => this.As(RadioactivityUnit.Megabecquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Megacurie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Megacurie"/>
         /// </summary>
-        public double Megacuries => As(RadioactivityUnit.Megacurie);
+        public QuantityValue Megacuries => this.As(RadioactivityUnit.Megacurie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Megarutherford"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Megarutherford"/>
         /// </summary>
-        public double Megarutherfords => As(RadioactivityUnit.Megarutherford);
+        public QuantityValue Megarutherfords => this.As(RadioactivityUnit.Megarutherford);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Microbecquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Microbecquerel"/>
         /// </summary>
-        public double Microbecquerels => As(RadioactivityUnit.Microbecquerel);
+        public QuantityValue Microbecquerels => this.As(RadioactivityUnit.Microbecquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Microcurie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Microcurie"/>
         /// </summary>
-        public double Microcuries => As(RadioactivityUnit.Microcurie);
+        public QuantityValue Microcuries => this.As(RadioactivityUnit.Microcurie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Microrutherford"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Microrutherford"/>
         /// </summary>
-        public double Microrutherfords => As(RadioactivityUnit.Microrutherford);
+        public QuantityValue Microrutherfords => this.As(RadioactivityUnit.Microrutherford);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Millibecquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Millibecquerel"/>
         /// </summary>
-        public double Millibecquerels => As(RadioactivityUnit.Millibecquerel);
+        public QuantityValue Millibecquerels => this.As(RadioactivityUnit.Millibecquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Millicurie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Millicurie"/>
         /// </summary>
-        public double Millicuries => As(RadioactivityUnit.Millicurie);
+        public QuantityValue Millicuries => this.As(RadioactivityUnit.Millicurie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Millirutherford"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Millirutherford"/>
         /// </summary>
-        public double Millirutherfords => As(RadioactivityUnit.Millirutherford);
+        public QuantityValue Millirutherfords => this.As(RadioactivityUnit.Millirutherford);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Nanobecquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Nanobecquerel"/>
         /// </summary>
-        public double Nanobecquerels => As(RadioactivityUnit.Nanobecquerel);
+        public QuantityValue Nanobecquerels => this.As(RadioactivityUnit.Nanobecquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Nanocurie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Nanocurie"/>
         /// </summary>
-        public double Nanocuries => As(RadioactivityUnit.Nanocurie);
+        public QuantityValue Nanocuries => this.As(RadioactivityUnit.Nanocurie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Nanorutherford"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Nanorutherford"/>
         /// </summary>
-        public double Nanorutherfords => As(RadioactivityUnit.Nanorutherford);
+        public QuantityValue Nanorutherfords => this.As(RadioactivityUnit.Nanorutherford);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Petabecquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Petabecquerel"/>
         /// </summary>
-        public double Petabecquerels => As(RadioactivityUnit.Petabecquerel);
+        public QuantityValue Petabecquerels => this.As(RadioactivityUnit.Petabecquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Picobecquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Picobecquerel"/>
         /// </summary>
-        public double Picobecquerels => As(RadioactivityUnit.Picobecquerel);
+        public QuantityValue Picobecquerels => this.As(RadioactivityUnit.Picobecquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Picocurie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Picocurie"/>
         /// </summary>
-        public double Picocuries => As(RadioactivityUnit.Picocurie);
+        public QuantityValue Picocuries => this.As(RadioactivityUnit.Picocurie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Picorutherford"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Picorutherford"/>
         /// </summary>
-        public double Picorutherfords => As(RadioactivityUnit.Picorutherford);
+        public QuantityValue Picorutherfords => this.As(RadioactivityUnit.Picorutherford);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Rutherford"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Rutherford"/>
         /// </summary>
-        public double Rutherfords => As(RadioactivityUnit.Rutherford);
+        public QuantityValue Rutherfords => this.As(RadioactivityUnit.Rutherford);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Terabecquerel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Terabecquerel"/>
         /// </summary>
-        public double Terabecquerels => As(RadioactivityUnit.Terabecquerel);
+        public QuantityValue Terabecquerels => this.As(RadioactivityUnit.Terabecquerel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Teracurie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Teracurie"/>
         /// </summary>
-        public double Teracuries => As(RadioactivityUnit.Teracurie);
+        public QuantityValue Teracuries => this.As(RadioactivityUnit.Teracurie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RadioactivityUnit.Terarutherford"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RadioactivityUnit.Terarutherford"/>
         /// </summary>
-        public double Terarutherfords => As(RadioactivityUnit.Terarutherford);
+        public QuantityValue Terarutherfords => this.As(RadioactivityUnit.Terarutherford);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RadioactivityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Curie, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Exabecquerel, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Gigabecquerel, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Gigacurie, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Gigarutherford, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Kilobecquerel, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Kilocurie, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Kilorutherford, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Megabecquerel, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Megacurie, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Megarutherford, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Microbecquerel, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Microcurie, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Microrutherford, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Millibecquerel, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Millicurie, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Millirutherford, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Nanobecquerel, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Nanocurie, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Nanorutherford, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Petabecquerel, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Picobecquerel, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Picocurie, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Picorutherford, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Rutherford, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Terabecquerel, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Teracurie, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Terarutherford, RadioactivityUnit.Becquerel, quantity => quantity.ToUnit(RadioactivityUnit.Becquerel));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Becquerel, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RadioactivityUnit
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Curie, quantity => quantity.ToUnit(RadioactivityUnit.Curie));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Exabecquerel, quantity => quantity.ToUnit(RadioactivityUnit.Exabecquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Gigabecquerel, quantity => quantity.ToUnit(RadioactivityUnit.Gigabecquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Gigacurie, quantity => quantity.ToUnit(RadioactivityUnit.Gigacurie));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Gigarutherford, quantity => quantity.ToUnit(RadioactivityUnit.Gigarutherford));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Kilobecquerel, quantity => quantity.ToUnit(RadioactivityUnit.Kilobecquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Kilocurie, quantity => quantity.ToUnit(RadioactivityUnit.Kilocurie));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Kilorutherford, quantity => quantity.ToUnit(RadioactivityUnit.Kilorutherford));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Megabecquerel, quantity => quantity.ToUnit(RadioactivityUnit.Megabecquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Megacurie, quantity => quantity.ToUnit(RadioactivityUnit.Megacurie));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Megarutherford, quantity => quantity.ToUnit(RadioactivityUnit.Megarutherford));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Microbecquerel, quantity => quantity.ToUnit(RadioactivityUnit.Microbecquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Microcurie, quantity => quantity.ToUnit(RadioactivityUnit.Microcurie));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Microrutherford, quantity => quantity.ToUnit(RadioactivityUnit.Microrutherford));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Millibecquerel, quantity => quantity.ToUnit(RadioactivityUnit.Millibecquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Millicurie, quantity => quantity.ToUnit(RadioactivityUnit.Millicurie));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Millirutherford, quantity => quantity.ToUnit(RadioactivityUnit.Millirutherford));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Nanobecquerel, quantity => quantity.ToUnit(RadioactivityUnit.Nanobecquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Nanocurie, quantity => quantity.ToUnit(RadioactivityUnit.Nanocurie));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Nanorutherford, quantity => quantity.ToUnit(RadioactivityUnit.Nanorutherford));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Petabecquerel, quantity => quantity.ToUnit(RadioactivityUnit.Petabecquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Picobecquerel, quantity => quantity.ToUnit(RadioactivityUnit.Picobecquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Picocurie, quantity => quantity.ToUnit(RadioactivityUnit.Picocurie));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Picorutherford, quantity => quantity.ToUnit(RadioactivityUnit.Picorutherford));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Rutherford, quantity => quantity.ToUnit(RadioactivityUnit.Rutherford));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Terabecquerel, quantity => quantity.ToUnit(RadioactivityUnit.Terabecquerel));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Teracurie, quantity => quantity.ToUnit(RadioactivityUnit.Teracurie));
-            unitConverter.SetConversionFunction<Radioactivity>(RadioactivityUnit.Becquerel, RadioactivityUnit.Terarutherford, quantity => quantity.ToUnit(RadioactivityUnit.Terarutherford));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -498,7 +480,7 @@ public static string GetAbbreviation(RadioactivityUnit unit, IFormatProvider? pr
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Becquerel"/>.
         /// </summary>
-        public static Radioactivity FromBecquerels(double value)
+        public static Radioactivity FromBecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Becquerel);
         }
@@ -506,7 +488,7 @@ public static Radioactivity FromBecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Curie"/>.
         /// </summary>
-        public static Radioactivity FromCuries(double value)
+        public static Radioactivity FromCuries(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Curie);
         }
@@ -514,7 +496,7 @@ public static Radioactivity FromCuries(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Exabecquerel"/>.
         /// </summary>
-        public static Radioactivity FromExabecquerels(double value)
+        public static Radioactivity FromExabecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Exabecquerel);
         }
@@ -522,7 +504,7 @@ public static Radioactivity FromExabecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigabecquerel"/>.
         /// </summary>
-        public static Radioactivity FromGigabecquerels(double value)
+        public static Radioactivity FromGigabecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Gigabecquerel);
         }
@@ -530,7 +512,7 @@ public static Radioactivity FromGigabecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigacurie"/>.
         /// </summary>
-        public static Radioactivity FromGigacuries(double value)
+        public static Radioactivity FromGigacuries(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Gigacurie);
         }
@@ -538,7 +520,7 @@ public static Radioactivity FromGigacuries(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigarutherford"/>.
         /// </summary>
-        public static Radioactivity FromGigarutherfords(double value)
+        public static Radioactivity FromGigarutherfords(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Gigarutherford);
         }
@@ -546,7 +528,7 @@ public static Radioactivity FromGigarutherfords(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilobecquerel"/>.
         /// </summary>
-        public static Radioactivity FromKilobecquerels(double value)
+        public static Radioactivity FromKilobecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Kilobecquerel);
         }
@@ -554,7 +536,7 @@ public static Radioactivity FromKilobecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilocurie"/>.
         /// </summary>
-        public static Radioactivity FromKilocuries(double value)
+        public static Radioactivity FromKilocuries(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Kilocurie);
         }
@@ -562,7 +544,7 @@ public static Radioactivity FromKilocuries(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilorutherford"/>.
         /// </summary>
-        public static Radioactivity FromKilorutherfords(double value)
+        public static Radioactivity FromKilorutherfords(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Kilorutherford);
         }
@@ -570,7 +552,7 @@ public static Radioactivity FromKilorutherfords(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megabecquerel"/>.
         /// </summary>
-        public static Radioactivity FromMegabecquerels(double value)
+        public static Radioactivity FromMegabecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Megabecquerel);
         }
@@ -578,7 +560,7 @@ public static Radioactivity FromMegabecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megacurie"/>.
         /// </summary>
-        public static Radioactivity FromMegacuries(double value)
+        public static Radioactivity FromMegacuries(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Megacurie);
         }
@@ -586,7 +568,7 @@ public static Radioactivity FromMegacuries(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megarutherford"/>.
         /// </summary>
-        public static Radioactivity FromMegarutherfords(double value)
+        public static Radioactivity FromMegarutherfords(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Megarutherford);
         }
@@ -594,7 +576,7 @@ public static Radioactivity FromMegarutherfords(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microbecquerel"/>.
         /// </summary>
-        public static Radioactivity FromMicrobecquerels(double value)
+        public static Radioactivity FromMicrobecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Microbecquerel);
         }
@@ -602,7 +584,7 @@ public static Radioactivity FromMicrobecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microcurie"/>.
         /// </summary>
-        public static Radioactivity FromMicrocuries(double value)
+        public static Radioactivity FromMicrocuries(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Microcurie);
         }
@@ -610,7 +592,7 @@ public static Radioactivity FromMicrocuries(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microrutherford"/>.
         /// </summary>
-        public static Radioactivity FromMicrorutherfords(double value)
+        public static Radioactivity FromMicrorutherfords(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Microrutherford);
         }
@@ -618,7 +600,7 @@ public static Radioactivity FromMicrorutherfords(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millibecquerel"/>.
         /// </summary>
-        public static Radioactivity FromMillibecquerels(double value)
+        public static Radioactivity FromMillibecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Millibecquerel);
         }
@@ -626,7 +608,7 @@ public static Radioactivity FromMillibecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millicurie"/>.
         /// </summary>
-        public static Radioactivity FromMillicuries(double value)
+        public static Radioactivity FromMillicuries(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Millicurie);
         }
@@ -634,7 +616,7 @@ public static Radioactivity FromMillicuries(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millirutherford"/>.
         /// </summary>
-        public static Radioactivity FromMillirutherfords(double value)
+        public static Radioactivity FromMillirutherfords(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Millirutherford);
         }
@@ -642,7 +624,7 @@ public static Radioactivity FromMillirutherfords(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanobecquerel"/>.
         /// </summary>
-        public static Radioactivity FromNanobecquerels(double value)
+        public static Radioactivity FromNanobecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Nanobecquerel);
         }
@@ -650,7 +632,7 @@ public static Radioactivity FromNanobecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanocurie"/>.
         /// </summary>
-        public static Radioactivity FromNanocuries(double value)
+        public static Radioactivity FromNanocuries(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Nanocurie);
         }
@@ -658,7 +640,7 @@ public static Radioactivity FromNanocuries(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanorutherford"/>.
         /// </summary>
-        public static Radioactivity FromNanorutherfords(double value)
+        public static Radioactivity FromNanorutherfords(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Nanorutherford);
         }
@@ -666,7 +648,7 @@ public static Radioactivity FromNanorutherfords(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Petabecquerel"/>.
         /// </summary>
-        public static Radioactivity FromPetabecquerels(double value)
+        public static Radioactivity FromPetabecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Petabecquerel);
         }
@@ -674,7 +656,7 @@ public static Radioactivity FromPetabecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picobecquerel"/>.
         /// </summary>
-        public static Radioactivity FromPicobecquerels(double value)
+        public static Radioactivity FromPicobecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Picobecquerel);
         }
@@ -682,7 +664,7 @@ public static Radioactivity FromPicobecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picocurie"/>.
         /// </summary>
-        public static Radioactivity FromPicocuries(double value)
+        public static Radioactivity FromPicocuries(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Picocurie);
         }
@@ -690,7 +672,7 @@ public static Radioactivity FromPicocuries(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picorutherford"/>.
         /// </summary>
-        public static Radioactivity FromPicorutherfords(double value)
+        public static Radioactivity FromPicorutherfords(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Picorutherford);
         }
@@ -698,7 +680,7 @@ public static Radioactivity FromPicorutherfords(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Rutherford"/>.
         /// </summary>
-        public static Radioactivity FromRutherfords(double value)
+        public static Radioactivity FromRutherfords(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Rutherford);
         }
@@ -706,7 +688,7 @@ public static Radioactivity FromRutherfords(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Terabecquerel"/>.
         /// </summary>
-        public static Radioactivity FromTerabecquerels(double value)
+        public static Radioactivity FromTerabecquerels(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Terabecquerel);
         }
@@ -714,7 +696,7 @@ public static Radioactivity FromTerabecquerels(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Teracurie"/>.
         /// </summary>
-        public static Radioactivity FromTeracuries(double value)
+        public static Radioactivity FromTeracuries(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Teracurie);
         }
@@ -722,7 +704,7 @@ public static Radioactivity FromTeracuries(double value)
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Terarutherford"/>.
         /// </summary>
-        public static Radioactivity FromTerarutherfords(double value)
+        public static Radioactivity FromTerarutherfords(QuantityValue value)
         {
             return new Radioactivity(value, RadioactivityUnit.Terarutherford);
         }
@@ -733,7 +715,7 @@ public static Radioactivity FromTerarutherfords(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Radioactivity unit value.</returns>
-        public static Radioactivity From(double value, RadioactivityUnit fromUnit)
+        public static Radioactivity From(QuantityValue value, RadioactivityUnit fromUnit)
         {
             return new Radioactivity(value, fromUnit);
         }
@@ -794,10 +776,7 @@ public static Radioactivity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Radioactivity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Radioactivity, RadioactivityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Radioactivity, RadioactivityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -825,11 +804,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Radioactivity re
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Radioactivity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Radioactivity, RadioactivityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Radioactivity, RadioactivityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -850,7 +825,7 @@ public static RadioactivityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -861,7 +836,7 @@ public static RadioactivityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RadioactivityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RadioactivityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RadioactivityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -876,7 +851,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out Radioactivit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RadioactivityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -895,35 +870,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Radioactivity"/> from adding two <see cref="Radioactivity"/>.</summary>
         public static Radioactivity operator +(Radioactivity left, Radioactivity right)
         {
-            return new Radioactivity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Radioactivity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Radioactivity"/> from subtracting two <see cref="Radioactivity"/>.</summary>
         public static Radioactivity operator -(Radioactivity left, Radioactivity right)
         {
-            return new Radioactivity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Radioactivity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Radioactivity"/> from multiplying value and <see cref="Radioactivity"/>.</summary>
-        public static Radioactivity operator *(double left, Radioactivity right)
+        public static Radioactivity operator *(QuantityValue left, Radioactivity right)
         {
             return new Radioactivity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Radioactivity"/> from multiplying value and <see cref="Radioactivity"/>.</summary>
-        public static Radioactivity operator *(Radioactivity left, double right)
+        public static Radioactivity operator *(Radioactivity left, QuantityValue right)
         {
             return new Radioactivity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Radioactivity"/> from dividing <see cref="Radioactivity"/> by value.</summary>
-        public static Radioactivity operator /(Radioactivity left, double right)
+        public static Radioactivity operator /(Radioactivity left, QuantityValue right)
         {
             return new Radioactivity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Radioactivity"/> by <see cref="Radioactivity"/>.</summary>
-        public static double operator /(Radioactivity left, Radioactivity right)
+        public static QuantityValue operator /(Radioactivity left, Radioactivity right)
         {
             return left.Becquerels / right.Becquerels;
         }
@@ -935,97 +910,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Radioactivity left, Radioactivity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Radioactivity left, Radioactivity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Radioactivity left, Radioactivity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Radioactivity left, Radioactivity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Radioactivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Radioactivity other, Radioactivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Radioactivity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Radioactivity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Radioactivity left, Radioactivity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Radioactivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Radioactivity other, Radioactivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Radioactivity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Radioactivity,Radioactivity)"/>.
+        ///     See that operator (and <see cref="Equals(Radioactivity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Radioactivity left, Radioactivity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Radioactivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Radioactivity other, Radioactivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Radioactivity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Radioactivity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Radioactivity"/>, this method delegates to
+        ///     <see cref="Equals(Radioactivity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Radioactivity otherQuantity))
+            if (obj is not Radioactivity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Radioactivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Radioactivity other, Radioactivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Radioactivity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Radioactivity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Radioactivity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Radioactivity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Radioactivity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Radioactivity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Radioactivity otherQuantity)) throw new ArgumentException("Expected type Radioactivity.", nameof(obj));
+            if (obj is not Radioactivity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Radioactivity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Radioactivity"/> with another <see cref="Radioactivity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Radioactivity"/> with another <see cref="Radioactivity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1037,185 +1026,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Radioactivity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RadioactivityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RadioactivityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Radioactivity to another Radioactivity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Radioactivity with the specified unit.</returns>
-        public Radioactivity ToUnit(RadioactivityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Radioactivity"/> to another <see cref="Radioactivity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Radioactivity with the specified unit.</returns>
-        public Radioactivity ToUnit(RadioactivityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Radioactivity), Unit, typeof(Radioactivity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Radioactivity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="Radioactivity"/> to another <see cref="Radioactivity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Radioactivity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RadioactivityUnit unit, [NotNullWhen(true)] out Radioactivity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Radioactivity? convertedOrNull = (Unit, unit) switch
-            {
-                // RadioactivityUnit -> BaseUnit
-                (RadioactivityUnit.Curie, RadioactivityUnit.Becquerel) => new Radioactivity(_value * 3.7e10, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Exabecquerel, RadioactivityUnit.Becquerel) => new Radioactivity((_value) * 1e18d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Gigabecquerel, RadioactivityUnit.Becquerel) => new Radioactivity((_value) * 1e9d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Gigacurie, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 3.7e10) * 1e9d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Gigarutherford, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 1e6) * 1e9d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Kilobecquerel, RadioactivityUnit.Becquerel) => new Radioactivity((_value) * 1e3d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Kilocurie, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 3.7e10) * 1e3d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Kilorutherford, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 1e6) * 1e3d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Megabecquerel, RadioactivityUnit.Becquerel) => new Radioactivity((_value) * 1e6d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Megacurie, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 3.7e10) * 1e6d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Megarutherford, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 1e6) * 1e6d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Microbecquerel, RadioactivityUnit.Becquerel) => new Radioactivity((_value) * 1e-6d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Microcurie, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 3.7e10) * 1e-6d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Microrutherford, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 1e6) * 1e-6d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Millibecquerel, RadioactivityUnit.Becquerel) => new Radioactivity((_value) * 1e-3d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Millicurie, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 3.7e10) * 1e-3d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Millirutherford, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 1e6) * 1e-3d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Nanobecquerel, RadioactivityUnit.Becquerel) => new Radioactivity((_value) * 1e-9d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Nanocurie, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 3.7e10) * 1e-9d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Nanorutherford, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 1e6) * 1e-9d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Petabecquerel, RadioactivityUnit.Becquerel) => new Radioactivity((_value) * 1e15d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Picobecquerel, RadioactivityUnit.Becquerel) => new Radioactivity((_value) * 1e-12d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Picocurie, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 3.7e10) * 1e-12d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Picorutherford, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 1e6) * 1e-12d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Rutherford, RadioactivityUnit.Becquerel) => new Radioactivity(_value * 1e6, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Terabecquerel, RadioactivityUnit.Becquerel) => new Radioactivity((_value) * 1e12d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Teracurie, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 3.7e10) * 1e12d, RadioactivityUnit.Becquerel),
-                (RadioactivityUnit.Terarutherford, RadioactivityUnit.Becquerel) => new Radioactivity((_value * 1e6) * 1e12d, RadioactivityUnit.Becquerel),
-
-                // BaseUnit -> RadioactivityUnit
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Curie) => new Radioactivity(_value / 3.7e10, RadioactivityUnit.Curie),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Exabecquerel) => new Radioactivity((_value) / 1e18d, RadioactivityUnit.Exabecquerel),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Gigabecquerel) => new Radioactivity((_value) / 1e9d, RadioactivityUnit.Gigabecquerel),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Gigacurie) => new Radioactivity((_value / 3.7e10) / 1e9d, RadioactivityUnit.Gigacurie),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Gigarutherford) => new Radioactivity((_value / 1e6) / 1e9d, RadioactivityUnit.Gigarutherford),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Kilobecquerel) => new Radioactivity((_value) / 1e3d, RadioactivityUnit.Kilobecquerel),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Kilocurie) => new Radioactivity((_value / 3.7e10) / 1e3d, RadioactivityUnit.Kilocurie),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Kilorutherford) => new Radioactivity((_value / 1e6) / 1e3d, RadioactivityUnit.Kilorutherford),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Megabecquerel) => new Radioactivity((_value) / 1e6d, RadioactivityUnit.Megabecquerel),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Megacurie) => new Radioactivity((_value / 3.7e10) / 1e6d, RadioactivityUnit.Megacurie),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Megarutherford) => new Radioactivity((_value / 1e6) / 1e6d, RadioactivityUnit.Megarutherford),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Microbecquerel) => new Radioactivity((_value) / 1e-6d, RadioactivityUnit.Microbecquerel),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Microcurie) => new Radioactivity((_value / 3.7e10) / 1e-6d, RadioactivityUnit.Microcurie),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Microrutherford) => new Radioactivity((_value / 1e6) / 1e-6d, RadioactivityUnit.Microrutherford),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Millibecquerel) => new Radioactivity((_value) / 1e-3d, RadioactivityUnit.Millibecquerel),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Millicurie) => new Radioactivity((_value / 3.7e10) / 1e-3d, RadioactivityUnit.Millicurie),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Millirutherford) => new Radioactivity((_value / 1e6) / 1e-3d, RadioactivityUnit.Millirutherford),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Nanobecquerel) => new Radioactivity((_value) / 1e-9d, RadioactivityUnit.Nanobecquerel),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Nanocurie) => new Radioactivity((_value / 3.7e10) / 1e-9d, RadioactivityUnit.Nanocurie),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Nanorutherford) => new Radioactivity((_value / 1e6) / 1e-9d, RadioactivityUnit.Nanorutherford),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Petabecquerel) => new Radioactivity((_value) / 1e15d, RadioactivityUnit.Petabecquerel),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Picobecquerel) => new Radioactivity((_value) / 1e-12d, RadioactivityUnit.Picobecquerel),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Picocurie) => new Radioactivity((_value / 3.7e10) / 1e-12d, RadioactivityUnit.Picocurie),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Picorutherford) => new Radioactivity((_value / 1e6) / 1e-12d, RadioactivityUnit.Picorutherford),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Rutherford) => new Radioactivity(_value / 1e6, RadioactivityUnit.Rutherford),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Terabecquerel) => new Radioactivity((_value) / 1e12d, RadioactivityUnit.Terabecquerel),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Teracurie) => new Radioactivity((_value / 3.7e10) / 1e12d, RadioactivityUnit.Teracurie),
-                (RadioactivityUnit.Becquerel, RadioactivityUnit.Terarutherford) => new Radioactivity((_value / 1e6) / 1e12d, RadioactivityUnit.Terarutherford),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RadioactivityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadioactivityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RadioactivityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadioactivityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RadioactivityUnit> IQuantity<RadioactivityUnit>.ToUnit(RadioactivityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1229,11 +1042,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
index 6512dc48b9..ab58fd3757 100644
--- a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,16 @@ namespace UnitsNet
     ///     In mathematics, a ratio is a relationship between two numbers of the same kind (e.g., objects, persons, students, spoonfuls, units of whatever identical dimension), usually expressed as "a to b" or a:b, sometimes expressed arithmetically as a dimensionless quotient of the two that explicitly indicates how many times the first number contains the second (not necessarily an integer).
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Ratio :
-        IArithmeticQuantity<Ratio, RatioUnit>,
+        ILinearQuantity<Ratio, RatioUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Ratio, Ratio, double>,
+        IDivisionOperators<Ratio, Ratio, QuantityValue>,
+        IDivisionOperators<Ratio, Pressure, Compressibility>,
+        IDivisionOperators<Ratio, RatioChangeRate, Duration>,
+        IDivisionOperators<Ratio, Compressibility, Pressure>,
+        IDivisionOperators<Ratio, Duration, RatioChangeRate>,
         IComparisonOperators<Ratio, Ratio, bool>,
         IParsable<Ratio>,
 #endif
@@ -52,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -118,19 +121,27 @@ public static RatioInfo CreateDefault(Func<IEnumerable<UnitDefinition<RatioUnit>
             public static IEnumerable<UnitDefinition<RatioUnit>> GetDefaultMappings()
             {
                 yield return new (RatioUnit.DecimalFraction, "DecimalFraction", "DecimalFractions", BaseUnits.Undefined);
-                yield return new (RatioUnit.PartPerBillion, "PartPerBillion", "PartsPerBillion", BaseUnits.Undefined);
-                yield return new (RatioUnit.PartPerMillion, "PartPerMillion", "PartsPerMillion", BaseUnits.Undefined);
-                yield return new (RatioUnit.PartPerThousand, "PartPerThousand", "PartsPerThousand", BaseUnits.Undefined);
-                yield return new (RatioUnit.PartPerTrillion, "PartPerTrillion", "PartsPerTrillion", BaseUnits.Undefined);
-                yield return new (RatioUnit.Percent, "Percent", "Percent", BaseUnits.Undefined);
+                yield return new (RatioUnit.PartPerBillion, "PartPerBillion", "PartsPerBillion", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (RatioUnit.PartPerMillion, "PartPerMillion", "PartsPerMillion", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (RatioUnit.PartPerThousand, "PartPerThousand", "PartsPerThousand", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (RatioUnit.PartPerTrillion, "PartPerTrillion", "PartsPerTrillion", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (RatioUnit.Percent, "Percent", "Percent", BaseUnits.Undefined,
+                     100
+                );
             }
         }
 
         static Ratio()
         {
-            Info = RatioInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RatioInfo.CreateDefault);
         }
 
         /// <summary>
@@ -138,7 +149,7 @@ static Ratio()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Ratio(double value, RatioUnit unit)
+        public Ratio(QuantityValue value, RatioUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -149,7 +160,8 @@ public Ratio(double value, RatioUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Ratio" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Ratio, RatioUnit> Info { get; }
@@ -178,10 +190,8 @@ public Ratio(double value, RatioUnit unit)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RatioUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -215,63 +225,39 @@ public Ratio(double value, RatioUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.DecimalFraction"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RatioUnit.DecimalFraction"/>
         /// </summary>
-        public double DecimalFractions => As(RatioUnit.DecimalFraction);
+        public QuantityValue DecimalFractions => this.As(RatioUnit.DecimalFraction);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.PartPerBillion"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RatioUnit.PartPerBillion"/>
         /// </summary>
-        public double PartsPerBillion => As(RatioUnit.PartPerBillion);
+        public QuantityValue PartsPerBillion => this.As(RatioUnit.PartPerBillion);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.PartPerMillion"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RatioUnit.PartPerMillion"/>
         /// </summary>
-        public double PartsPerMillion => As(RatioUnit.PartPerMillion);
+        public QuantityValue PartsPerMillion => this.As(RatioUnit.PartPerMillion);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.PartPerThousand"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RatioUnit.PartPerThousand"/>
         /// </summary>
-        public double PartsPerThousand => As(RatioUnit.PartPerThousand);
+        public QuantityValue PartsPerThousand => this.As(RatioUnit.PartPerThousand);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.PartPerTrillion"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RatioUnit.PartPerTrillion"/>
         /// </summary>
-        public double PartsPerTrillion => As(RatioUnit.PartPerTrillion);
+        public QuantityValue PartsPerTrillion => this.As(RatioUnit.PartPerTrillion);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioUnit.Percent"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RatioUnit.Percent"/>
         /// </summary>
-        public double Percent => As(RatioUnit.Percent);
+        public QuantityValue Percent => this.As(RatioUnit.Percent);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RatioUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.PartPerBillion, RatioUnit.DecimalFraction, quantity => quantity.ToUnit(RatioUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.PartPerMillion, RatioUnit.DecimalFraction, quantity => quantity.ToUnit(RatioUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.PartPerThousand, RatioUnit.DecimalFraction, quantity => quantity.ToUnit(RatioUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.PartPerTrillion, RatioUnit.DecimalFraction, quantity => quantity.ToUnit(RatioUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.Percent, RatioUnit.DecimalFraction, quantity => quantity.ToUnit(RatioUnit.DecimalFraction));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.DecimalFraction, RatioUnit.DecimalFraction, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RatioUnit
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.DecimalFraction, RatioUnit.PartPerBillion, quantity => quantity.ToUnit(RatioUnit.PartPerBillion));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.DecimalFraction, RatioUnit.PartPerMillion, quantity => quantity.ToUnit(RatioUnit.PartPerMillion));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.DecimalFraction, RatioUnit.PartPerThousand, quantity => quantity.ToUnit(RatioUnit.PartPerThousand));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.DecimalFraction, RatioUnit.PartPerTrillion, quantity => quantity.ToUnit(RatioUnit.PartPerTrillion));
-            unitConverter.SetConversionFunction<Ratio>(RatioUnit.DecimalFraction, RatioUnit.Percent, quantity => quantity.ToUnit(RatioUnit.Percent));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -300,7 +286,7 @@ public static string GetAbbreviation(RatioUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.DecimalFraction"/>.
         /// </summary>
-        public static Ratio FromDecimalFractions(double value)
+        public static Ratio FromDecimalFractions(QuantityValue value)
         {
             return new Ratio(value, RatioUnit.DecimalFraction);
         }
@@ -308,7 +294,7 @@ public static Ratio FromDecimalFractions(double value)
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerBillion"/>.
         /// </summary>
-        public static Ratio FromPartsPerBillion(double value)
+        public static Ratio FromPartsPerBillion(QuantityValue value)
         {
             return new Ratio(value, RatioUnit.PartPerBillion);
         }
@@ -316,7 +302,7 @@ public static Ratio FromPartsPerBillion(double value)
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerMillion"/>.
         /// </summary>
-        public static Ratio FromPartsPerMillion(double value)
+        public static Ratio FromPartsPerMillion(QuantityValue value)
         {
             return new Ratio(value, RatioUnit.PartPerMillion);
         }
@@ -324,7 +310,7 @@ public static Ratio FromPartsPerMillion(double value)
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerThousand"/>.
         /// </summary>
-        public static Ratio FromPartsPerThousand(double value)
+        public static Ratio FromPartsPerThousand(QuantityValue value)
         {
             return new Ratio(value, RatioUnit.PartPerThousand);
         }
@@ -332,7 +318,7 @@ public static Ratio FromPartsPerThousand(double value)
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerTrillion"/>.
         /// </summary>
-        public static Ratio FromPartsPerTrillion(double value)
+        public static Ratio FromPartsPerTrillion(QuantityValue value)
         {
             return new Ratio(value, RatioUnit.PartPerTrillion);
         }
@@ -340,7 +326,7 @@ public static Ratio FromPartsPerTrillion(double value)
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.Percent"/>.
         /// </summary>
-        public static Ratio FromPercent(double value)
+        public static Ratio FromPercent(QuantityValue value)
         {
             return new Ratio(value, RatioUnit.Percent);
         }
@@ -351,7 +337,7 @@ public static Ratio FromPercent(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Ratio unit value.</returns>
-        public static Ratio From(double value, RatioUnit fromUnit)
+        public static Ratio From(QuantityValue value, RatioUnit fromUnit)
         {
             return new Ratio(value, fromUnit);
         }
@@ -412,10 +398,7 @@ public static Ratio Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Ratio Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Ratio, RatioUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Ratio, RatioUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -443,11 +426,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Ratio result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Ratio result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Ratio, RatioUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Ratio, RatioUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -468,7 +447,7 @@ public static RatioUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -479,7 +458,7 @@ public static RatioUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RatioUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RatioUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RatioUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -494,7 +473,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RatioUnit un
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RatioUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -513,137 +492,179 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Ratio"/> from adding two <see cref="Ratio"/>.</summary>
         public static Ratio operator +(Ratio left, Ratio right)
         {
-            return new Ratio(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Ratio(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Ratio"/> from subtracting two <see cref="Ratio"/>.</summary>
         public static Ratio operator -(Ratio left, Ratio right)
         {
-            return new Ratio(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Ratio(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Ratio"/> from multiplying value and <see cref="Ratio"/>.</summary>
-        public static Ratio operator *(double left, Ratio right)
+        public static Ratio operator *(QuantityValue left, Ratio right)
         {
             return new Ratio(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Ratio"/> from multiplying value and <see cref="Ratio"/>.</summary>
-        public static Ratio operator *(Ratio left, double right)
+        public static Ratio operator *(Ratio left, QuantityValue right)
         {
             return new Ratio(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Ratio"/> from dividing <see cref="Ratio"/> by value.</summary>
-        public static Ratio operator /(Ratio left, double right)
+        public static Ratio operator /(Ratio left, QuantityValue right)
         {
             return new Ratio(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Ratio"/> by <see cref="Ratio"/>.</summary>
-        public static double operator /(Ratio left, Ratio right)
+        public static QuantityValue operator /(Ratio left, Ratio right)
         {
             return left.DecimalFractions / right.DecimalFractions;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Compressibility"/> from <see cref="Ratio"/> / <see cref="Pressure"/>.</summary>
+        public static Compressibility operator /(Ratio ratio, Pressure pressure)
+        {
+            return Compressibility.FromInversePascals(ratio.DecimalFractions / pressure.Pascals);
+        }
+
+        /// <summary>Get <see cref="Duration"/> from <see cref="Ratio"/> / <see cref="RatioChangeRate"/>.</summary>
+        public static Duration operator /(Ratio ratio, RatioChangeRate ratioChangeRate)
+        {
+            return Duration.FromSeconds(ratio.DecimalFractions / ratioChangeRate.DecimalFractionsPerSecond);
+        }
+
+        /// <summary>Get <see cref="Pressure"/> from <see cref="Ratio"/> / <see cref="Compressibility"/>.</summary>
+        public static Pressure operator /(Ratio ratio, Compressibility compressibility)
+        {
+            return Pressure.FromPascals(ratio.DecimalFractions / compressibility.InversePascals);
+        }
+
+        /// <summary>Get <see cref="RatioChangeRate"/> from <see cref="Ratio"/> / <see cref="Duration"/>.</summary>
+        public static RatioChangeRate operator /(Ratio ratio, Duration duration)
+        {
+            return RatioChangeRate.FromDecimalFractionsPerSecond(ratio.DecimalFractions / duration.Seconds);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Ratio left, Ratio right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Ratio left, Ratio right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Ratio left, Ratio right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Ratio left, Ratio right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Ratio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Ratio other, Ratio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Ratio"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Ratio)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Ratio left, Ratio right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Ratio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Ratio other, Ratio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Ratio"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Ratio,Ratio)"/>.
+        ///     See that operator (and <see cref="Equals(Ratio)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Ratio left, Ratio right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Ratio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Ratio other, Ratio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Ratio"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Ratio"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Ratio"/>, this method delegates to
+        ///     <see cref="Equals(Ratio)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Ratio otherQuantity))
+            if (obj is not Ratio otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Ratio"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Ratio other, Ratio tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Ratio"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Ratio other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Ratio.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Ratio), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Ratio"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Ratio)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Ratio otherQuantity)) throw new ArgumentException("Expected type Ratio.", nameof(obj));
+            if (obj is not Ratio otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Ratio>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Ratio"/> with another <see cref="Ratio"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Ratio"/> with another <see cref="Ratio"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -655,141 +676,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Ratio other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RatioUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RatioUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Ratio to another Ratio with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Ratio with the specified unit.</returns>
-        public Ratio ToUnit(RatioUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Ratio"/> to another <see cref="Ratio"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Ratio with the specified unit.</returns>
-        public Ratio ToUnit(RatioUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Ratio), Unit, typeof(Ratio), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Ratio)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Ratio"/> to another <see cref="Ratio"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Ratio"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RatioUnit unit, [NotNullWhen(true)] out Ratio? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Ratio? convertedOrNull = (Unit, unit) switch
-            {
-                // RatioUnit -> BaseUnit
-                (RatioUnit.PartPerBillion, RatioUnit.DecimalFraction) => new Ratio(_value / 1e9, RatioUnit.DecimalFraction),
-                (RatioUnit.PartPerMillion, RatioUnit.DecimalFraction) => new Ratio(_value / 1e6, RatioUnit.DecimalFraction),
-                (RatioUnit.PartPerThousand, RatioUnit.DecimalFraction) => new Ratio(_value / 1e3, RatioUnit.DecimalFraction),
-                (RatioUnit.PartPerTrillion, RatioUnit.DecimalFraction) => new Ratio(_value / 1e12, RatioUnit.DecimalFraction),
-                (RatioUnit.Percent, RatioUnit.DecimalFraction) => new Ratio(_value / 1e2, RatioUnit.DecimalFraction),
-
-                // BaseUnit -> RatioUnit
-                (RatioUnit.DecimalFraction, RatioUnit.PartPerBillion) => new Ratio(_value * 1e9, RatioUnit.PartPerBillion),
-                (RatioUnit.DecimalFraction, RatioUnit.PartPerMillion) => new Ratio(_value * 1e6, RatioUnit.PartPerMillion),
-                (RatioUnit.DecimalFraction, RatioUnit.PartPerThousand) => new Ratio(_value * 1e3, RatioUnit.PartPerThousand),
-                (RatioUnit.DecimalFraction, RatioUnit.PartPerTrillion) => new Ratio(_value * 1e12, RatioUnit.PartPerTrillion),
-                (RatioUnit.DecimalFraction, RatioUnit.Percent) => new Ratio(_value * 1e2, RatioUnit.Percent),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RatioUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RatioUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RatioUnit> IQuantity<RatioUnit>.ToUnit(RatioUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -801,11 +692,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
index 82ae527d99..1371abb5a7 100644
--- a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     The change in ratio per unit of time.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct RatioChangeRate :
-        IArithmeticQuantity<RatioChangeRate, RatioChangeRateUnit>,
+        ILinearQuantity<RatioChangeRate, RatioChangeRateUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<RatioChangeRate, RatioChangeRate, double>,
+        IDivisionOperators<RatioChangeRate, RatioChangeRate, QuantityValue>,
+        IMultiplyOperators<RatioChangeRate, Duration, Ratio>,
         IComparisonOperators<RatioChangeRate, RatioChangeRate, bool>,
         IParsable<RatioChangeRate>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static RatioChangeRateInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="RatioChangeRate"/> is [T^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="RatioChangeRate"/> is T^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, -1, 0, 0, 0, 0);
 
@@ -118,15 +118,15 @@ public static RatioChangeRateInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             public static IEnumerable<UnitDefinition<RatioChangeRateUnit>> GetDefaultMappings()
             {
                 yield return new (RatioChangeRateUnit.DecimalFractionPerSecond, "DecimalFractionPerSecond", "DecimalFractionsPerSecond", new BaseUnits(time: DurationUnit.Second));
-                yield return new (RatioChangeRateUnit.PercentPerSecond, "PercentPerSecond", "PercentsPerSecond", BaseUnits.Undefined);
+                yield return new (RatioChangeRateUnit.PercentPerSecond, "PercentPerSecond", "PercentsPerSecond", BaseUnits.Undefined,
+                     100
+                );
             }
         }
 
         static RatioChangeRate()
         {
-            Info = RatioChangeRateInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RatioChangeRateInfo.CreateDefault);
         }
 
         /// <summary>
@@ -134,7 +134,7 @@ static RatioChangeRate()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RatioChangeRate(double value, RatioChangeRateUnit unit)
+        public RatioChangeRate(QuantityValue value, RatioChangeRateUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -148,7 +148,7 @@ public RatioChangeRate(double value, RatioChangeRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RatioChangeRate(double value, UnitSystem unitSystem)
+        public RatioChangeRate(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -159,7 +159,8 @@ public RatioChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="RatioChangeRate" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<RatioChangeRate, RatioChangeRateUnit> Info { get; }
@@ -188,10 +189,8 @@ public RatioChangeRate(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RatioChangeRateUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -225,35 +224,19 @@ public RatioChangeRate(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioChangeRateUnit.DecimalFractionPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RatioChangeRateUnit.DecimalFractionPerSecond"/>
         /// </summary>
-        public double DecimalFractionsPerSecond => As(RatioChangeRateUnit.DecimalFractionPerSecond);
+        public QuantityValue DecimalFractionsPerSecond => this.As(RatioChangeRateUnit.DecimalFractionPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RatioChangeRateUnit.PercentPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RatioChangeRateUnit.PercentPerSecond"/>
         /// </summary>
-        public double PercentsPerSecond => As(RatioChangeRateUnit.PercentPerSecond);
+        public QuantityValue PercentsPerSecond => this.As(RatioChangeRateUnit.PercentPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RatioChangeRateUnit -> BaseUnit
-            unitConverter.SetConversionFunction<RatioChangeRate>(RatioChangeRateUnit.PercentPerSecond, RatioChangeRateUnit.DecimalFractionPerSecond, quantity => quantity.ToUnit(RatioChangeRateUnit.DecimalFractionPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<RatioChangeRate>(RatioChangeRateUnit.DecimalFractionPerSecond, RatioChangeRateUnit.DecimalFractionPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RatioChangeRateUnit
-            unitConverter.SetConversionFunction<RatioChangeRate>(RatioChangeRateUnit.DecimalFractionPerSecond, RatioChangeRateUnit.PercentPerSecond, quantity => quantity.ToUnit(RatioChangeRateUnit.PercentPerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -282,7 +265,7 @@ public static string GetAbbreviation(RatioChangeRateUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="RatioChangeRate"/> from <see cref="RatioChangeRateUnit.DecimalFractionPerSecond"/>.
         /// </summary>
-        public static RatioChangeRate FromDecimalFractionsPerSecond(double value)
+        public static RatioChangeRate FromDecimalFractionsPerSecond(QuantityValue value)
         {
             return new RatioChangeRate(value, RatioChangeRateUnit.DecimalFractionPerSecond);
         }
@@ -290,7 +273,7 @@ public static RatioChangeRate FromDecimalFractionsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RatioChangeRate"/> from <see cref="RatioChangeRateUnit.PercentPerSecond"/>.
         /// </summary>
-        public static RatioChangeRate FromPercentsPerSecond(double value)
+        public static RatioChangeRate FromPercentsPerSecond(QuantityValue value)
         {
             return new RatioChangeRate(value, RatioChangeRateUnit.PercentPerSecond);
         }
@@ -301,7 +284,7 @@ public static RatioChangeRate FromPercentsPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RatioChangeRate unit value.</returns>
-        public static RatioChangeRate From(double value, RatioChangeRateUnit fromUnit)
+        public static RatioChangeRate From(QuantityValue value, RatioChangeRateUnit fromUnit)
         {
             return new RatioChangeRate(value, fromUnit);
         }
@@ -362,10 +345,7 @@ public static RatioChangeRate Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static RatioChangeRate Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<RatioChangeRate, RatioChangeRateUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<RatioChangeRate, RatioChangeRateUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -393,11 +373,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out RatioChangeRate
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out RatioChangeRate result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<RatioChangeRate, RatioChangeRateUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<RatioChangeRate, RatioChangeRateUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -418,7 +394,7 @@ public static RatioChangeRateUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -429,7 +405,7 @@ public static RatioChangeRateUnit ParseUnit(string str, IFormatProvider? provide
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RatioChangeRateUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RatioChangeRateUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RatioChangeRateUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -444,7 +420,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RatioChangeR
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RatioChangeRateUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -463,137 +439,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="RatioChangeRate"/> from adding two <see cref="RatioChangeRate"/>.</summary>
         public static RatioChangeRate operator +(RatioChangeRate left, RatioChangeRate right)
         {
-            return new RatioChangeRate(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new RatioChangeRate(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RatioChangeRate"/> from subtracting two <see cref="RatioChangeRate"/>.</summary>
         public static RatioChangeRate operator -(RatioChangeRate left, RatioChangeRate right)
         {
-            return new RatioChangeRate(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new RatioChangeRate(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RatioChangeRate"/> from multiplying value and <see cref="RatioChangeRate"/>.</summary>
-        public static RatioChangeRate operator *(double left, RatioChangeRate right)
+        public static RatioChangeRate operator *(QuantityValue left, RatioChangeRate right)
         {
             return new RatioChangeRate(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="RatioChangeRate"/> from multiplying value and <see cref="RatioChangeRate"/>.</summary>
-        public static RatioChangeRate operator *(RatioChangeRate left, double right)
+        public static RatioChangeRate operator *(RatioChangeRate left, QuantityValue right)
         {
             return new RatioChangeRate(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="RatioChangeRate"/> from dividing <see cref="RatioChangeRate"/> by value.</summary>
-        public static RatioChangeRate operator /(RatioChangeRate left, double right)
+        public static RatioChangeRate operator /(RatioChangeRate left, QuantityValue right)
         {
             return new RatioChangeRate(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="RatioChangeRate"/> by <see cref="RatioChangeRate"/>.</summary>
-        public static double operator /(RatioChangeRate left, RatioChangeRate right)
+        public static QuantityValue operator /(RatioChangeRate left, RatioChangeRate right)
         {
             return left.DecimalFractionsPerSecond / right.DecimalFractionsPerSecond;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Ratio"/> from <see cref="RatioChangeRate"/> * <see cref="Duration"/>.</summary>
+        public static Ratio operator *(RatioChangeRate ratioChangeRate, Duration duration)
+        {
+            return Ratio.FromDecimalFractions(ratioChangeRate.DecimalFractionsPerSecond * duration.Seconds);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(RatioChangeRate left, RatioChangeRate right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(RatioChangeRate left, RatioChangeRate right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(RatioChangeRate left, RatioChangeRate right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(RatioChangeRate left, RatioChangeRate right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="RatioChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RatioChangeRate other, RatioChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RatioChangeRate"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(RatioChangeRate)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(RatioChangeRate left, RatioChangeRate right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="RatioChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RatioChangeRate other, RatioChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RatioChangeRate"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(RatioChangeRate,RatioChangeRate)"/>.
+        ///     See that operator (and <see cref="Equals(RatioChangeRate)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(RatioChangeRate left, RatioChangeRate right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RatioChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RatioChangeRate other, RatioChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="RatioChangeRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="RatioChangeRate"/>.
+        ///     When <paramref name="obj"/> is a <see cref="RatioChangeRate"/>, this method delegates to
+        ///     <see cref="Equals(RatioChangeRate)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is RatioChangeRate otherQuantity))
+            if (obj is not RatioChangeRate otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RatioChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RatioChangeRate other, RatioChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="RatioChangeRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(RatioChangeRate other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current RatioChangeRate.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(RatioChangeRate), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="RatioChangeRate"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(RatioChangeRate)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is RatioChangeRate otherQuantity)) throw new ArgumentException("Expected type RatioChangeRate.", nameof(obj));
+            if (obj is not RatioChangeRate otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<RatioChangeRate>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="RatioChangeRate"/> with another <see cref="RatioChangeRate"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="RatioChangeRate"/> with another <see cref="RatioChangeRate"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -605,133 +605,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(RatioChangeRate other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RatioChangeRateUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RatioChangeRateUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this RatioChangeRate to another RatioChangeRate with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A RatioChangeRate with the specified unit.</returns>
-        public RatioChangeRate ToUnit(RatioChangeRateUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="RatioChangeRate"/> to another <see cref="RatioChangeRate"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A RatioChangeRate with the specified unit.</returns>
-        public RatioChangeRate ToUnit(RatioChangeRateUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(RatioChangeRate), Unit, typeof(RatioChangeRate), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (RatioChangeRate)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="RatioChangeRate"/> to another <see cref="RatioChangeRate"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="RatioChangeRate"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RatioChangeRateUnit unit, [NotNullWhen(true)] out RatioChangeRate? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            RatioChangeRate? convertedOrNull = (Unit, unit) switch
-            {
-                // RatioChangeRateUnit -> BaseUnit
-                (RatioChangeRateUnit.PercentPerSecond, RatioChangeRateUnit.DecimalFractionPerSecond) => new RatioChangeRate(_value / 1e2, RatioChangeRateUnit.DecimalFractionPerSecond),
-
-                // BaseUnit -> RatioChangeRateUnit
-                (RatioChangeRateUnit.DecimalFractionPerSecond, RatioChangeRateUnit.PercentPerSecond) => new RatioChangeRate(_value * 1e2, RatioChangeRateUnit.PercentPerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RatioChangeRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioChangeRateUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RatioChangeRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioChangeRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RatioChangeRateUnit> IQuantity<RatioChangeRateUnit>.ToUnit(RatioChangeRateUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -743,11 +621,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
index fa16223844..43983fa83a 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Inverse-square_law
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ReciprocalArea :
-        IArithmeticQuantity<ReciprocalArea, ReciprocalAreaUnit>,
+        ILinearQuantity<ReciprocalArea, ReciprocalAreaUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ReciprocalArea, ReciprocalArea, double>,
+        IDivisionOperators<ReciprocalArea, ReciprocalArea, QuantityValue>,
         IMultiplyOperators<ReciprocalArea, Volume, Length>,
         IMultiplyOperators<ReciprocalArea, Force, Pressure>,
         IMultiplyOperators<ReciprocalArea, Area, Ratio>,
@@ -60,7 +59,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -110,7 +109,7 @@ public static ReciprocalAreaInfo CreateDefault(Func<IEnumerable<UnitDefinition<R
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ReciprocalArea"/> is [L^-2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ReciprocalArea"/> is L^-2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 0, 0, 0, 0, 0, 0);
 
@@ -125,25 +124,43 @@ public static ReciprocalAreaInfo CreateDefault(Func<IEnumerable<UnitDefinition<R
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ReciprocalAreaUnit}"/> representing the default unit mappings for ReciprocalArea.</returns>
             public static IEnumerable<UnitDefinition<ReciprocalAreaUnit>> GetDefaultMappings()
             {
-                yield return new (ReciprocalAreaUnit.InverseSquareCentimeter, "InverseSquareCentimeter", "InverseSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter));
-                yield return new (ReciprocalAreaUnit.InverseSquareDecimeter, "InverseSquareDecimeter", "InverseSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter));
-                yield return new (ReciprocalAreaUnit.InverseSquareFoot, "InverseSquareFoot", "InverseSquareFeet", new BaseUnits(length: LengthUnit.Foot));
-                yield return new (ReciprocalAreaUnit.InverseSquareInch, "InverseSquareInch", "InverseSquareInches", new BaseUnits(length: LengthUnit.Inch));
-                yield return new (ReciprocalAreaUnit.InverseSquareKilometer, "InverseSquareKilometer", "InverseSquareKilometers", new BaseUnits(length: LengthUnit.Kilometer));
+                yield return new (ReciprocalAreaUnit.InverseSquareCentimeter, "InverseSquareCentimeter", "InverseSquareCentimeters", new BaseUnits(length: LengthUnit.Centimeter),
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (ReciprocalAreaUnit.InverseSquareDecimeter, "InverseSquareDecimeter", "InverseSquareDecimeters", new BaseUnits(length: LengthUnit.Decimeter),
+                     new QuantityValue(1, 100)
+                );
+                yield return new (ReciprocalAreaUnit.InverseSquareFoot, "InverseSquareFoot", "InverseSquareFeet", new BaseUnits(length: LengthUnit.Foot),
+                     new QuantityValue(145161, 1562500)
+                );
+                yield return new (ReciprocalAreaUnit.InverseSquareInch, "InverseSquareInch", "InverseSquareInches", new BaseUnits(length: LengthUnit.Inch),
+                     new QuantityValue(16129, 25000000)
+                );
+                yield return new (ReciprocalAreaUnit.InverseSquareKilometer, "InverseSquareKilometer", "InverseSquareKilometers", new BaseUnits(length: LengthUnit.Kilometer),
+                     1000000
+                );
                 yield return new (ReciprocalAreaUnit.InverseSquareMeter, "InverseSquareMeter", "InverseSquareMeters", new BaseUnits(length: LengthUnit.Meter));
-                yield return new (ReciprocalAreaUnit.InverseSquareMicrometer, "InverseSquareMicrometer", "InverseSquareMicrometers", new BaseUnits(length: LengthUnit.Micrometer));
-                yield return new (ReciprocalAreaUnit.InverseSquareMile, "InverseSquareMile", "InverseSquareMiles", new BaseUnits(length: LengthUnit.Mile));
-                yield return new (ReciprocalAreaUnit.InverseSquareMillimeter, "InverseSquareMillimeter", "InverseSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter));
-                yield return new (ReciprocalAreaUnit.InverseSquareYard, "InverseSquareYard", "InverseSquareYards", new BaseUnits(length: LengthUnit.Yard));
-                yield return new (ReciprocalAreaUnit.InverseUsSurveySquareFoot, "InverseUsSurveySquareFoot", "InverseUsSurveySquareFeet", new BaseUnits(length: LengthUnit.UsSurveyFoot));
+                yield return new (ReciprocalAreaUnit.InverseSquareMicrometer, "InverseSquareMicrometer", "InverseSquareMicrometers", new BaseUnits(length: LengthUnit.Micrometer),
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (ReciprocalAreaUnit.InverseSquareMile, "InverseSquareMile", "InverseSquareMiles", new BaseUnits(length: LengthUnit.Mile),
+                     new QuantityValue(40468564224, 15625)
+                );
+                yield return new (ReciprocalAreaUnit.InverseSquareMillimeter, "InverseSquareMillimeter", "InverseSquareMillimeters", new BaseUnits(length: LengthUnit.Millimeter),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (ReciprocalAreaUnit.InverseSquareYard, "InverseSquareYard", "InverseSquareYards", new BaseUnits(length: LengthUnit.Yard),
+                     new QuantityValue(1306449, 1562500)
+                );
+                yield return new (ReciprocalAreaUnit.InverseUsSurveySquareFoot, "InverseUsSurveySquareFoot", "InverseUsSurveySquareFeet", new BaseUnits(length: LengthUnit.UsSurveyFoot),
+                     new QuantityValue(1440000, 15499969)
+                );
             }
         }
 
         static ReciprocalArea()
         {
-            Info = ReciprocalAreaInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ReciprocalAreaInfo.CreateDefault);
         }
 
         /// <summary>
@@ -151,7 +168,7 @@ static ReciprocalArea()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ReciprocalArea(double value, ReciprocalAreaUnit unit)
+        public ReciprocalArea(QuantityValue value, ReciprocalAreaUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -165,7 +182,7 @@ public ReciprocalArea(double value, ReciprocalAreaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ReciprocalArea(double value, UnitSystem unitSystem)
+        public ReciprocalArea(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -176,7 +193,8 @@ public ReciprocalArea(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ReciprocalArea" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ReciprocalArea, ReciprocalAreaUnit> Info { get; }
@@ -205,10 +223,8 @@ public ReciprocalArea(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ReciprocalAreaUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -242,98 +258,64 @@ public ReciprocalArea(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareCentimeter"/>
         /// </summary>
-        public double InverseSquareCentimeters => As(ReciprocalAreaUnit.InverseSquareCentimeter);
+        public QuantityValue InverseSquareCentimeters => this.As(ReciprocalAreaUnit.InverseSquareCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareDecimeter"/>
         /// </summary>
-        public double InverseSquareDecimeters => As(ReciprocalAreaUnit.InverseSquareDecimeter);
+        public QuantityValue InverseSquareDecimeters => this.As(ReciprocalAreaUnit.InverseSquareDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareFoot"/>
         /// </summary>
-        public double InverseSquareFeet => As(ReciprocalAreaUnit.InverseSquareFoot);
+        public QuantityValue InverseSquareFeet => this.As(ReciprocalAreaUnit.InverseSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareInch"/>
         /// </summary>
-        public double InverseSquareInches => As(ReciprocalAreaUnit.InverseSquareInch);
+        public QuantityValue InverseSquareInches => this.As(ReciprocalAreaUnit.InverseSquareInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareKilometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareKilometer"/>
         /// </summary>
-        public double InverseSquareKilometers => As(ReciprocalAreaUnit.InverseSquareKilometer);
+        public QuantityValue InverseSquareKilometers => this.As(ReciprocalAreaUnit.InverseSquareKilometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMeter"/>
         /// </summary>
-        public double InverseSquareMeters => As(ReciprocalAreaUnit.InverseSquareMeter);
+        public QuantityValue InverseSquareMeters => this.As(ReciprocalAreaUnit.InverseSquareMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMicrometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMicrometer"/>
         /// </summary>
-        public double InverseSquareMicrometers => As(ReciprocalAreaUnit.InverseSquareMicrometer);
+        public QuantityValue InverseSquareMicrometers => this.As(ReciprocalAreaUnit.InverseSquareMicrometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMile"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMile"/>
         /// </summary>
-        public double InverseSquareMiles => As(ReciprocalAreaUnit.InverseSquareMile);
+        public QuantityValue InverseSquareMiles => this.As(ReciprocalAreaUnit.InverseSquareMile);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareMillimeter"/>
         /// </summary>
-        public double InverseSquareMillimeters => As(ReciprocalAreaUnit.InverseSquareMillimeter);
+        public QuantityValue InverseSquareMillimeters => this.As(ReciprocalAreaUnit.InverseSquareMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareYard"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseSquareYard"/>
         /// </summary>
-        public double InverseSquareYards => As(ReciprocalAreaUnit.InverseSquareYard);
+        public QuantityValue InverseSquareYards => this.As(ReciprocalAreaUnit.InverseSquareYard);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseUsSurveySquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalAreaUnit.InverseUsSurveySquareFoot"/>
         /// </summary>
-        public double InverseUsSurveySquareFeet => As(ReciprocalAreaUnit.InverseUsSurveySquareFoot);
+        public QuantityValue InverseUsSurveySquareFeet => this.As(ReciprocalAreaUnit.InverseUsSurveySquareFoot);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ReciprocalAreaUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareCentimeter, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareDecimeter, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareFoot, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareInch, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareKilometer, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMicrometer, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMile, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMillimeter, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareYard, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseUsSurveySquareFoot, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ReciprocalAreaUnit
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareCentimeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareCentimeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareDecimeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareDecimeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareFoot, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareFoot));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareInch, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareInch));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareKilometer, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareKilometer));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareMicrometer, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMicrometer));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareMile, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMile));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareMillimeter, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareMillimeter));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareYard, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseSquareYard));
-            unitConverter.SetConversionFunction<ReciprocalArea>(ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseUsSurveySquareFoot, quantity => quantity.ToUnit(ReciprocalAreaUnit.InverseUsSurveySquareFoot));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -362,7 +344,7 @@ public static string GetAbbreviation(ReciprocalAreaUnit unit, IFormatProvider? p
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareCentimeter"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseSquareCentimeters(double value)
+        public static ReciprocalArea FromInverseSquareCentimeters(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareCentimeter);
         }
@@ -370,7 +352,7 @@ public static ReciprocalArea FromInverseSquareCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareDecimeter"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseSquareDecimeters(double value)
+        public static ReciprocalArea FromInverseSquareDecimeters(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareDecimeter);
         }
@@ -378,7 +360,7 @@ public static ReciprocalArea FromInverseSquareDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareFoot"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseSquareFeet(double value)
+        public static ReciprocalArea FromInverseSquareFeet(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareFoot);
         }
@@ -386,7 +368,7 @@ public static ReciprocalArea FromInverseSquareFeet(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareInch"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseSquareInches(double value)
+        public static ReciprocalArea FromInverseSquareInches(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareInch);
         }
@@ -394,7 +376,7 @@ public static ReciprocalArea FromInverseSquareInches(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareKilometer"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseSquareKilometers(double value)
+        public static ReciprocalArea FromInverseSquareKilometers(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareKilometer);
         }
@@ -402,7 +384,7 @@ public static ReciprocalArea FromInverseSquareKilometers(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMeter"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseSquareMeters(double value)
+        public static ReciprocalArea FromInverseSquareMeters(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter);
         }
@@ -410,7 +392,7 @@ public static ReciprocalArea FromInverseSquareMeters(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMicrometer"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseSquareMicrometers(double value)
+        public static ReciprocalArea FromInverseSquareMicrometers(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMicrometer);
         }
@@ -418,7 +400,7 @@ public static ReciprocalArea FromInverseSquareMicrometers(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMile"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseSquareMiles(double value)
+        public static ReciprocalArea FromInverseSquareMiles(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMile);
         }
@@ -426,7 +408,7 @@ public static ReciprocalArea FromInverseSquareMiles(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMillimeter"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseSquareMillimeters(double value)
+        public static ReciprocalArea FromInverseSquareMillimeters(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMillimeter);
         }
@@ -434,7 +416,7 @@ public static ReciprocalArea FromInverseSquareMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareYard"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseSquareYards(double value)
+        public static ReciprocalArea FromInverseSquareYards(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareYard);
         }
@@ -442,7 +424,7 @@ public static ReciprocalArea FromInverseSquareYards(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseUsSurveySquareFoot"/>.
         /// </summary>
-        public static ReciprocalArea FromInverseUsSurveySquareFeet(double value)
+        public static ReciprocalArea FromInverseUsSurveySquareFeet(QuantityValue value)
         {
             return new ReciprocalArea(value, ReciprocalAreaUnit.InverseUsSurveySquareFoot);
         }
@@ -453,7 +435,7 @@ public static ReciprocalArea FromInverseUsSurveySquareFeet(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ReciprocalArea unit value.</returns>
-        public static ReciprocalArea From(double value, ReciprocalAreaUnit fromUnit)
+        public static ReciprocalArea From(QuantityValue value, ReciprocalAreaUnit fromUnit)
         {
             return new ReciprocalArea(value, fromUnit);
         }
@@ -514,10 +496,7 @@ public static ReciprocalArea Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ReciprocalArea Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ReciprocalArea, ReciprocalAreaUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ReciprocalArea, ReciprocalAreaUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -545,11 +524,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ReciprocalArea r
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ReciprocalArea result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ReciprocalArea, ReciprocalAreaUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ReciprocalArea, ReciprocalAreaUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -570,7 +545,7 @@ public static ReciprocalAreaUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -581,7 +556,7 @@ public static ReciprocalAreaUnit ParseUnit(string str, IFormatProvider? provider
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ReciprocalAreaUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ReciprocalAreaUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ReciprocalAreaUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -596,7 +571,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ReciprocalAr
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ReciprocalAreaUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -615,35 +590,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ReciprocalArea"/> from adding two <see cref="ReciprocalArea"/>.</summary>
         public static ReciprocalArea operator +(ReciprocalArea left, ReciprocalArea right)
         {
-            return new ReciprocalArea(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ReciprocalArea(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ReciprocalArea"/> from subtracting two <see cref="ReciprocalArea"/>.</summary>
         public static ReciprocalArea operator -(ReciprocalArea left, ReciprocalArea right)
         {
-            return new ReciprocalArea(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ReciprocalArea(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ReciprocalArea"/> from multiplying value and <see cref="ReciprocalArea"/>.</summary>
-        public static ReciprocalArea operator *(double left, ReciprocalArea right)
+        public static ReciprocalArea operator *(QuantityValue left, ReciprocalArea right)
         {
             return new ReciprocalArea(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ReciprocalArea"/> from multiplying value and <see cref="ReciprocalArea"/>.</summary>
-        public static ReciprocalArea operator *(ReciprocalArea left, double right)
+        public static ReciprocalArea operator *(ReciprocalArea left, QuantityValue right)
         {
             return new ReciprocalArea(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ReciprocalArea"/> from dividing <see cref="ReciprocalArea"/> by value.</summary>
-        public static ReciprocalArea operator /(ReciprocalArea left, double right)
+        public static ReciprocalArea operator /(ReciprocalArea left, QuantityValue right)
         {
             return new ReciprocalArea(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ReciprocalArea"/> by <see cref="ReciprocalArea"/>.</summary>
-        public static double operator /(ReciprocalArea left, ReciprocalArea right)
+        public static QuantityValue operator /(ReciprocalArea left, ReciprocalArea right)
         {
             return left.InverseSquareMeters / right.InverseSquareMeters;
         }
@@ -656,7 +631,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <returns>The corresponding inverse quantity, <see cref="Area"/>.</returns>
         public Area Inverse()
         {
-            return Area.FromSquareMeters(1 / InverseSquareMeters);
+            return UnitConverter.Default.ConvertTo(Value, Unit, Area.Info);
         }
 
         /// <summary>Get <see cref="Length"/> from <see cref="ReciprocalArea"/> * <see cref="Volume"/>.</summary>
@@ -696,97 +671,111 @@ public Area Inverse()
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ReciprocalArea left, ReciprocalArea right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ReciprocalArea left, ReciprocalArea right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ReciprocalArea left, ReciprocalArea right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ReciprocalArea left, ReciprocalArea right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ReciprocalArea"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ReciprocalArea other, ReciprocalArea tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ReciprocalArea"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ReciprocalArea)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ReciprocalArea left, ReciprocalArea right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ReciprocalArea"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ReciprocalArea other, ReciprocalArea tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ReciprocalArea"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ReciprocalArea,ReciprocalArea)"/>.
+        ///     See that operator (and <see cref="Equals(ReciprocalArea)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ReciprocalArea left, ReciprocalArea right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ReciprocalArea"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ReciprocalArea other, ReciprocalArea tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ReciprocalArea"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ReciprocalArea"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ReciprocalArea"/>, this method delegates to
+        ///     <see cref="Equals(ReciprocalArea)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ReciprocalArea otherQuantity))
+            if (obj is not ReciprocalArea otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ReciprocalArea"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ReciprocalArea other, ReciprocalArea tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ReciprocalArea"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ReciprocalArea other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ReciprocalArea.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ReciprocalArea), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ReciprocalArea"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ReciprocalArea)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ReciprocalArea otherQuantity)) throw new ArgumentException("Expected type ReciprocalArea.", nameof(obj));
+            if (obj is not ReciprocalArea otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ReciprocalArea>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ReciprocalArea"/> with another <see cref="ReciprocalArea"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ReciprocalArea"/> with another <see cref="ReciprocalArea"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -798,149 +787,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ReciprocalArea other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ReciprocalAreaUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ReciprocalAreaUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ReciprocalArea to another ReciprocalArea with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ReciprocalArea with the specified unit.</returns>
-        public ReciprocalArea ToUnit(ReciprocalAreaUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="ReciprocalArea"/> to another <see cref="ReciprocalArea"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ReciprocalArea with the specified unit.</returns>
-        public ReciprocalArea ToUnit(ReciprocalAreaUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ReciprocalArea), Unit, typeof(ReciprocalArea), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ReciprocalArea)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ReciprocalArea"/> to another <see cref="ReciprocalArea"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ReciprocalArea"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ReciprocalAreaUnit unit, [NotNullWhen(true)] out ReciprocalArea? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ReciprocalArea? convertedOrNull = (Unit, unit) switch
-            {
-                // ReciprocalAreaUnit -> BaseUnit
-                (ReciprocalAreaUnit.InverseSquareCentimeter, ReciprocalAreaUnit.InverseSquareMeter) => new ReciprocalArea(_value / 1e-4, ReciprocalAreaUnit.InverseSquareMeter),
-                (ReciprocalAreaUnit.InverseSquareDecimeter, ReciprocalAreaUnit.InverseSquareMeter) => new ReciprocalArea(_value / 1e-2, ReciprocalAreaUnit.InverseSquareMeter),
-                (ReciprocalAreaUnit.InverseSquareFoot, ReciprocalAreaUnit.InverseSquareMeter) => new ReciprocalArea(_value / 9.290304e-2, ReciprocalAreaUnit.InverseSquareMeter),
-                (ReciprocalAreaUnit.InverseSquareInch, ReciprocalAreaUnit.InverseSquareMeter) => new ReciprocalArea(_value / 0.00064516, ReciprocalAreaUnit.InverseSquareMeter),
-                (ReciprocalAreaUnit.InverseSquareKilometer, ReciprocalAreaUnit.InverseSquareMeter) => new ReciprocalArea(_value / 1e6, ReciprocalAreaUnit.InverseSquareMeter),
-                (ReciprocalAreaUnit.InverseSquareMicrometer, ReciprocalAreaUnit.InverseSquareMeter) => new ReciprocalArea(_value / 1e-12, ReciprocalAreaUnit.InverseSquareMeter),
-                (ReciprocalAreaUnit.InverseSquareMile, ReciprocalAreaUnit.InverseSquareMeter) => new ReciprocalArea(_value / (1609.344 * 1609.344), ReciprocalAreaUnit.InverseSquareMeter),
-                (ReciprocalAreaUnit.InverseSquareMillimeter, ReciprocalAreaUnit.InverseSquareMeter) => new ReciprocalArea(_value / 1e-6, ReciprocalAreaUnit.InverseSquareMeter),
-                (ReciprocalAreaUnit.InverseSquareYard, ReciprocalAreaUnit.InverseSquareMeter) => new ReciprocalArea(_value / (0.9144 * 0.9144), ReciprocalAreaUnit.InverseSquareMeter),
-                (ReciprocalAreaUnit.InverseUsSurveySquareFoot, ReciprocalAreaUnit.InverseSquareMeter) => new ReciprocalArea(_value / (1200.0 / 3937.0) / (1200.0 / 3937.0), ReciprocalAreaUnit.InverseSquareMeter),
-
-                // BaseUnit -> ReciprocalAreaUnit
-                (ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareCentimeter) => new ReciprocalArea(_value * 1e-4, ReciprocalAreaUnit.InverseSquareCentimeter),
-                (ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareDecimeter) => new ReciprocalArea(_value * 1e-2, ReciprocalAreaUnit.InverseSquareDecimeter),
-                (ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareFoot) => new ReciprocalArea(_value * 9.290304e-2, ReciprocalAreaUnit.InverseSquareFoot),
-                (ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareInch) => new ReciprocalArea(_value * 0.00064516, ReciprocalAreaUnit.InverseSquareInch),
-                (ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareKilometer) => new ReciprocalArea(_value * 1e6, ReciprocalAreaUnit.InverseSquareKilometer),
-                (ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareMicrometer) => new ReciprocalArea(_value * 1e-12, ReciprocalAreaUnit.InverseSquareMicrometer),
-                (ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareMile) => new ReciprocalArea(_value * (1609.344 * 1609.344), ReciprocalAreaUnit.InverseSquareMile),
-                (ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareMillimeter) => new ReciprocalArea(_value * 1e-6, ReciprocalAreaUnit.InverseSquareMillimeter),
-                (ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseSquareYard) => new ReciprocalArea(_value * (0.9144 * 0.9144), ReciprocalAreaUnit.InverseSquareYard),
-                (ReciprocalAreaUnit.InverseSquareMeter, ReciprocalAreaUnit.InverseUsSurveySquareFoot) => new ReciprocalArea(_value * (1200.0 / 3937.0) * (1200.0 / 3937.0), ReciprocalAreaUnit.InverseUsSurveySquareFoot),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ReciprocalAreaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalAreaUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ReciprocalAreaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalAreaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ReciprocalAreaUnit> IQuantity<ReciprocalAreaUnit>.ToUnit(ReciprocalAreaUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -954,11 +803,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
index 0750dace25..941da74742 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Reciprocal_length
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ReciprocalLength :
-        IArithmeticQuantity<ReciprocalLength, ReciprocalLengthUnit>,
+        ILinearQuantity<ReciprocalLength, ReciprocalLengthUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ReciprocalLength, ReciprocalLength, double>,
+        IDivisionOperators<ReciprocalLength, ReciprocalLength, QuantityValue>,
         IMultiplyOperators<ReciprocalLength, Volume, Area>,
         IMultiplyOperators<ReciprocalLength, Force, ForcePerLength>,
         IMultiplyOperators<ReciprocalLength, Area, Length>,
@@ -62,7 +61,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -112,7 +111,7 @@ public static ReciprocalLengthInfo CreateDefault(Func<IEnumerable<UnitDefinition
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ReciprocalLength"/> is [L^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ReciprocalLength"/> is L^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 0, 0, 0, 0, 0, 0);
 
@@ -127,24 +126,40 @@ public static ReciprocalLengthInfo CreateDefault(Func<IEnumerable<UnitDefinition
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ReciprocalLengthUnit}"/> representing the default unit mappings for ReciprocalLength.</returns>
             public static IEnumerable<UnitDefinition<ReciprocalLengthUnit>> GetDefaultMappings()
             {
-                yield return new (ReciprocalLengthUnit.InverseCentimeter, "InverseCentimeter", "InverseCentimeters", new BaseUnits(length: LengthUnit.Centimeter));
-                yield return new (ReciprocalLengthUnit.InverseFoot, "InverseFoot", "InverseFeet", new BaseUnits(length: LengthUnit.Foot));
-                yield return new (ReciprocalLengthUnit.InverseInch, "InverseInch", "InverseInches", new BaseUnits(length: LengthUnit.Inch));
+                yield return new (ReciprocalLengthUnit.InverseCentimeter, "InverseCentimeter", "InverseCentimeters", new BaseUnits(length: LengthUnit.Centimeter),
+                     new QuantityValue(1, 100)
+                );
+                yield return new (ReciprocalLengthUnit.InverseFoot, "InverseFoot", "InverseFeet", new BaseUnits(length: LengthUnit.Foot),
+                     new QuantityValue(381, 1250)
+                );
+                yield return new (ReciprocalLengthUnit.InverseInch, "InverseInch", "InverseInches", new BaseUnits(length: LengthUnit.Inch),
+                     new QuantityValue(127, 5000)
+                );
                 yield return new (ReciprocalLengthUnit.InverseMeter, "InverseMeter", "InverseMeters", new BaseUnits(length: LengthUnit.Meter));
-                yield return new (ReciprocalLengthUnit.InverseMicroinch, "InverseMicroinch", "InverseMicroinches", new BaseUnits(length: LengthUnit.Microinch));
-                yield return new (ReciprocalLengthUnit.InverseMil, "InverseMil", "InverseMils", new BaseUnits(length: LengthUnit.Mil));
-                yield return new (ReciprocalLengthUnit.InverseMile, "InverseMile", "InverseMiles", new BaseUnits(length: LengthUnit.Mile));
-                yield return new (ReciprocalLengthUnit.InverseMillimeter, "InverseMillimeter", "InverseMillimeters", new BaseUnits(length: LengthUnit.Millimeter));
-                yield return new (ReciprocalLengthUnit.InverseUsSurveyFoot, "InverseUsSurveyFoot", "InverseUsSurveyFeet", new BaseUnits(length: LengthUnit.UsSurveyFoot));
-                yield return new (ReciprocalLengthUnit.InverseYard, "InverseYard", "InverseYards", new BaseUnits(length: LengthUnit.Yard));
+                yield return new (ReciprocalLengthUnit.InverseMicroinch, "InverseMicroinch", "InverseMicroinches", new BaseUnits(length: LengthUnit.Microinch),
+                     new QuantityValue(127, 5000000000)
+                );
+                yield return new (ReciprocalLengthUnit.InverseMil, "InverseMil", "InverseMils", new BaseUnits(length: LengthUnit.Mil),
+                     new QuantityValue(127, 5000000)
+                );
+                yield return new (ReciprocalLengthUnit.InverseMile, "InverseMile", "InverseMiles", new BaseUnits(length: LengthUnit.Mile),
+                     new QuantityValue(201168, 125)
+                );
+                yield return new (ReciprocalLengthUnit.InverseMillimeter, "InverseMillimeter", "InverseMillimeters", new BaseUnits(length: LengthUnit.Millimeter),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ReciprocalLengthUnit.InverseUsSurveyFoot, "InverseUsSurveyFoot", "InverseUsSurveyFeet", new BaseUnits(length: LengthUnit.UsSurveyFoot),
+                     new QuantityValue(1200, 3937)
+                );
+                yield return new (ReciprocalLengthUnit.InverseYard, "InverseYard", "InverseYards", new BaseUnits(length: LengthUnit.Yard),
+                     new QuantityValue(1143, 1250)
+                );
             }
         }
 
         static ReciprocalLength()
         {
-            Info = ReciprocalLengthInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ReciprocalLengthInfo.CreateDefault);
         }
 
         /// <summary>
@@ -152,7 +167,7 @@ static ReciprocalLength()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ReciprocalLength(double value, ReciprocalLengthUnit unit)
+        public ReciprocalLength(QuantityValue value, ReciprocalLengthUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -166,7 +181,7 @@ public ReciprocalLength(double value, ReciprocalLengthUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ReciprocalLength(double value, UnitSystem unitSystem)
+        public ReciprocalLength(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -177,7 +192,8 @@ public ReciprocalLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ReciprocalLength" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ReciprocalLength, ReciprocalLengthUnit> Info { get; }
@@ -206,10 +222,8 @@ public ReciprocalLength(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ReciprocalLengthUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -243,91 +257,59 @@ public ReciprocalLength(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseCentimeter"/>
         /// </summary>
-        public double InverseCentimeters => As(ReciprocalLengthUnit.InverseCentimeter);
+        public QuantityValue InverseCentimeters => this.As(ReciprocalLengthUnit.InverseCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseFoot"/>
         /// </summary>
-        public double InverseFeet => As(ReciprocalLengthUnit.InverseFoot);
+        public QuantityValue InverseFeet => this.As(ReciprocalLengthUnit.InverseFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseInch"/>
         /// </summary>
-        public double InverseInches => As(ReciprocalLengthUnit.InverseInch);
+        public QuantityValue InverseInches => this.As(ReciprocalLengthUnit.InverseInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMeter"/>
         /// </summary>
-        public double InverseMeters => As(ReciprocalLengthUnit.InverseMeter);
+        public QuantityValue InverseMeters => this.As(ReciprocalLengthUnit.InverseMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMicroinch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMicroinch"/>
         /// </summary>
-        public double InverseMicroinches => As(ReciprocalLengthUnit.InverseMicroinch);
+        public QuantityValue InverseMicroinches => this.As(ReciprocalLengthUnit.InverseMicroinch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMil"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMil"/>
         /// </summary>
-        public double InverseMils => As(ReciprocalLengthUnit.InverseMil);
+        public QuantityValue InverseMils => this.As(ReciprocalLengthUnit.InverseMil);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMile"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMile"/>
         /// </summary>
-        public double InverseMiles => As(ReciprocalLengthUnit.InverseMile);
+        public QuantityValue InverseMiles => this.As(ReciprocalLengthUnit.InverseMile);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseMillimeter"/>
         /// </summary>
-        public double InverseMillimeters => As(ReciprocalLengthUnit.InverseMillimeter);
+        public QuantityValue InverseMillimeters => this.As(ReciprocalLengthUnit.InverseMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseUsSurveyFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseUsSurveyFoot"/>
         /// </summary>
-        public double InverseUsSurveyFeet => As(ReciprocalLengthUnit.InverseUsSurveyFoot);
+        public QuantityValue InverseUsSurveyFeet => this.As(ReciprocalLengthUnit.InverseUsSurveyFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseYard"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ReciprocalLengthUnit.InverseYard"/>
         /// </summary>
-        public double InverseYards => As(ReciprocalLengthUnit.InverseYard);
+        public QuantityValue InverseYards => this.As(ReciprocalLengthUnit.InverseYard);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ReciprocalLengthUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseCentimeter, ReciprocalLengthUnit.InverseMeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMeter));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseFoot, ReciprocalLengthUnit.InverseMeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMeter));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseInch, ReciprocalLengthUnit.InverseMeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMeter));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMicroinch, ReciprocalLengthUnit.InverseMeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMeter));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMil, ReciprocalLengthUnit.InverseMeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMeter));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMile, ReciprocalLengthUnit.InverseMeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMeter));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMillimeter, ReciprocalLengthUnit.InverseMeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMeter));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseUsSurveyFoot, ReciprocalLengthUnit.InverseMeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMeter));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseYard, ReciprocalLengthUnit.InverseMeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ReciprocalLengthUnit
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseCentimeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseCentimeter));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseFoot, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseFoot));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseInch, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseInch));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseMicroinch, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMicroinch));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseMil, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMil));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseMile, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMile));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseMillimeter, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseMillimeter));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseUsSurveyFoot, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseUsSurveyFoot));
-            unitConverter.SetConversionFunction<ReciprocalLength>(ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseYard, quantity => quantity.ToUnit(ReciprocalLengthUnit.InverseYard));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -356,7 +338,7 @@ public static string GetAbbreviation(ReciprocalLengthUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseCentimeter"/>.
         /// </summary>
-        public static ReciprocalLength FromInverseCentimeters(double value)
+        public static ReciprocalLength FromInverseCentimeters(QuantityValue value)
         {
             return new ReciprocalLength(value, ReciprocalLengthUnit.InverseCentimeter);
         }
@@ -364,7 +346,7 @@ public static ReciprocalLength FromInverseCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseFoot"/>.
         /// </summary>
-        public static ReciprocalLength FromInverseFeet(double value)
+        public static ReciprocalLength FromInverseFeet(QuantityValue value)
         {
             return new ReciprocalLength(value, ReciprocalLengthUnit.InverseFoot);
         }
@@ -372,7 +354,7 @@ public static ReciprocalLength FromInverseFeet(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseInch"/>.
         /// </summary>
-        public static ReciprocalLength FromInverseInches(double value)
+        public static ReciprocalLength FromInverseInches(QuantityValue value)
         {
             return new ReciprocalLength(value, ReciprocalLengthUnit.InverseInch);
         }
@@ -380,7 +362,7 @@ public static ReciprocalLength FromInverseInches(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMeter"/>.
         /// </summary>
-        public static ReciprocalLength FromInverseMeters(double value)
+        public static ReciprocalLength FromInverseMeters(QuantityValue value)
         {
             return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMeter);
         }
@@ -388,7 +370,7 @@ public static ReciprocalLength FromInverseMeters(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMicroinch"/>.
         /// </summary>
-        public static ReciprocalLength FromInverseMicroinches(double value)
+        public static ReciprocalLength FromInverseMicroinches(QuantityValue value)
         {
             return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMicroinch);
         }
@@ -396,7 +378,7 @@ public static ReciprocalLength FromInverseMicroinches(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMil"/>.
         /// </summary>
-        public static ReciprocalLength FromInverseMils(double value)
+        public static ReciprocalLength FromInverseMils(QuantityValue value)
         {
             return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMil);
         }
@@ -404,7 +386,7 @@ public static ReciprocalLength FromInverseMils(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMile"/>.
         /// </summary>
-        public static ReciprocalLength FromInverseMiles(double value)
+        public static ReciprocalLength FromInverseMiles(QuantityValue value)
         {
             return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMile);
         }
@@ -412,7 +394,7 @@ public static ReciprocalLength FromInverseMiles(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMillimeter"/>.
         /// </summary>
-        public static ReciprocalLength FromInverseMillimeters(double value)
+        public static ReciprocalLength FromInverseMillimeters(QuantityValue value)
         {
             return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMillimeter);
         }
@@ -420,7 +402,7 @@ public static ReciprocalLength FromInverseMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseUsSurveyFoot"/>.
         /// </summary>
-        public static ReciprocalLength FromInverseUsSurveyFeet(double value)
+        public static ReciprocalLength FromInverseUsSurveyFeet(QuantityValue value)
         {
             return new ReciprocalLength(value, ReciprocalLengthUnit.InverseUsSurveyFoot);
         }
@@ -428,7 +410,7 @@ public static ReciprocalLength FromInverseUsSurveyFeet(double value)
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseYard"/>.
         /// </summary>
-        public static ReciprocalLength FromInverseYards(double value)
+        public static ReciprocalLength FromInverseYards(QuantityValue value)
         {
             return new ReciprocalLength(value, ReciprocalLengthUnit.InverseYard);
         }
@@ -439,7 +421,7 @@ public static ReciprocalLength FromInverseYards(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ReciprocalLength unit value.</returns>
-        public static ReciprocalLength From(double value, ReciprocalLengthUnit fromUnit)
+        public static ReciprocalLength From(QuantityValue value, ReciprocalLengthUnit fromUnit)
         {
             return new ReciprocalLength(value, fromUnit);
         }
@@ -500,10 +482,7 @@ public static ReciprocalLength Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ReciprocalLength Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ReciprocalLength, ReciprocalLengthUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ReciprocalLength, ReciprocalLengthUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -531,11 +510,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ReciprocalLength
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ReciprocalLength result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ReciprocalLength, ReciprocalLengthUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ReciprocalLength, ReciprocalLengthUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -556,7 +531,7 @@ public static ReciprocalLengthUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -567,7 +542,7 @@ public static ReciprocalLengthUnit ParseUnit(string str, IFormatProvider? provid
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ReciprocalLengthUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ReciprocalLengthUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ReciprocalLengthUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -582,7 +557,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ReciprocalLe
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ReciprocalLengthUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -601,35 +576,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ReciprocalLength"/> from adding two <see cref="ReciprocalLength"/>.</summary>
         public static ReciprocalLength operator +(ReciprocalLength left, ReciprocalLength right)
         {
-            return new ReciprocalLength(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ReciprocalLength(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ReciprocalLength"/> from subtracting two <see cref="ReciprocalLength"/>.</summary>
         public static ReciprocalLength operator -(ReciprocalLength left, ReciprocalLength right)
         {
-            return new ReciprocalLength(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ReciprocalLength(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ReciprocalLength"/> from multiplying value and <see cref="ReciprocalLength"/>.</summary>
-        public static ReciprocalLength operator *(double left, ReciprocalLength right)
+        public static ReciprocalLength operator *(QuantityValue left, ReciprocalLength right)
         {
             return new ReciprocalLength(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ReciprocalLength"/> from multiplying value and <see cref="ReciprocalLength"/>.</summary>
-        public static ReciprocalLength operator *(ReciprocalLength left, double right)
+        public static ReciprocalLength operator *(ReciprocalLength left, QuantityValue right)
         {
             return new ReciprocalLength(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ReciprocalLength"/> from dividing <see cref="ReciprocalLength"/> by value.</summary>
-        public static ReciprocalLength operator /(ReciprocalLength left, double right)
+        public static ReciprocalLength operator /(ReciprocalLength left, QuantityValue right)
         {
             return new ReciprocalLength(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ReciprocalLength"/> by <see cref="ReciprocalLength"/>.</summary>
-        public static double operator /(ReciprocalLength left, ReciprocalLength right)
+        public static QuantityValue operator /(ReciprocalLength left, ReciprocalLength right)
         {
             return left.InverseMeters / right.InverseMeters;
         }
@@ -642,7 +617,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <returns>The corresponding inverse quantity, <see cref="Length"/>.</returns>
         public Length Inverse()
         {
-            return Length.FromMeters(1 / InverseMeters);
+            return UnitConverter.Default.ConvertTo(Value, Unit, Length.Info);
         }
 
         /// <summary>Get <see cref="Area"/> from <see cref="ReciprocalLength"/> * <see cref="Volume"/>.</summary>
@@ -694,97 +669,111 @@ public Length Inverse()
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ReciprocalLength left, ReciprocalLength right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ReciprocalLength left, ReciprocalLength right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ReciprocalLength left, ReciprocalLength right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ReciprocalLength left, ReciprocalLength right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ReciprocalLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ReciprocalLength other, ReciprocalLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ReciprocalLength"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ReciprocalLength)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ReciprocalLength left, ReciprocalLength right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ReciprocalLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ReciprocalLength other, ReciprocalLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ReciprocalLength"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ReciprocalLength,ReciprocalLength)"/>.
+        ///     See that operator (and <see cref="Equals(ReciprocalLength)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ReciprocalLength left, ReciprocalLength right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ReciprocalLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ReciprocalLength other, ReciprocalLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ReciprocalLength"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ReciprocalLength"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ReciprocalLength"/>, this method delegates to
+        ///     <see cref="Equals(ReciprocalLength)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ReciprocalLength otherQuantity))
+            if (obj is not ReciprocalLength otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ReciprocalLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ReciprocalLength other, ReciprocalLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ReciprocalLength"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ReciprocalLength other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ReciprocalLength.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ReciprocalLength), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ReciprocalLength"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ReciprocalLength)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ReciprocalLength otherQuantity)) throw new ArgumentException("Expected type ReciprocalLength.", nameof(obj));
+            if (obj is not ReciprocalLength otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ReciprocalLength>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ReciprocalLength"/> with another <see cref="ReciprocalLength"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ReciprocalLength"/> with another <see cref="ReciprocalLength"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -796,147 +785,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ReciprocalLength other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ReciprocalLengthUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ReciprocalLengthUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ReciprocalLength to another ReciprocalLength with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ReciprocalLength with the specified unit.</returns>
-        public ReciprocalLength ToUnit(ReciprocalLengthUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="ReciprocalLength"/> to another <see cref="ReciprocalLength"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ReciprocalLength with the specified unit.</returns>
-        public ReciprocalLength ToUnit(ReciprocalLengthUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ReciprocalLength), Unit, typeof(ReciprocalLength), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ReciprocalLength)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ReciprocalLength"/> to another <see cref="ReciprocalLength"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ReciprocalLength"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ReciprocalLengthUnit unit, [NotNullWhen(true)] out ReciprocalLength? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ReciprocalLength? convertedOrNull = (Unit, unit) switch
-            {
-                // ReciprocalLengthUnit -> BaseUnit
-                (ReciprocalLengthUnit.InverseCentimeter, ReciprocalLengthUnit.InverseMeter) => new ReciprocalLength(_value * 1e2, ReciprocalLengthUnit.InverseMeter),
-                (ReciprocalLengthUnit.InverseFoot, ReciprocalLengthUnit.InverseMeter) => new ReciprocalLength(_value / 0.3048, ReciprocalLengthUnit.InverseMeter),
-                (ReciprocalLengthUnit.InverseInch, ReciprocalLengthUnit.InverseMeter) => new ReciprocalLength(_value / 2.54e-2, ReciprocalLengthUnit.InverseMeter),
-                (ReciprocalLengthUnit.InverseMicroinch, ReciprocalLengthUnit.InverseMeter) => new ReciprocalLength(_value / 2.54e-8, ReciprocalLengthUnit.InverseMeter),
-                (ReciprocalLengthUnit.InverseMil, ReciprocalLengthUnit.InverseMeter) => new ReciprocalLength(_value / 2.54e-5, ReciprocalLengthUnit.InverseMeter),
-                (ReciprocalLengthUnit.InverseMile, ReciprocalLengthUnit.InverseMeter) => new ReciprocalLength(_value / 1609.344, ReciprocalLengthUnit.InverseMeter),
-                (ReciprocalLengthUnit.InverseMillimeter, ReciprocalLengthUnit.InverseMeter) => new ReciprocalLength(_value * 1e3, ReciprocalLengthUnit.InverseMeter),
-                (ReciprocalLengthUnit.InverseUsSurveyFoot, ReciprocalLengthUnit.InverseMeter) => new ReciprocalLength(_value * 3937 / 1200, ReciprocalLengthUnit.InverseMeter),
-                (ReciprocalLengthUnit.InverseYard, ReciprocalLengthUnit.InverseMeter) => new ReciprocalLength(_value / 0.9144, ReciprocalLengthUnit.InverseMeter),
-
-                // BaseUnit -> ReciprocalLengthUnit
-                (ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseCentimeter) => new ReciprocalLength(_value / 1e2, ReciprocalLengthUnit.InverseCentimeter),
-                (ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseFoot) => new ReciprocalLength(_value * 0.3048, ReciprocalLengthUnit.InverseFoot),
-                (ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseInch) => new ReciprocalLength(_value * 2.54e-2, ReciprocalLengthUnit.InverseInch),
-                (ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseMicroinch) => new ReciprocalLength(_value * 2.54e-8, ReciprocalLengthUnit.InverseMicroinch),
-                (ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseMil) => new ReciprocalLength(_value * 2.54e-5, ReciprocalLengthUnit.InverseMil),
-                (ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseMile) => new ReciprocalLength(_value * 1609.344, ReciprocalLengthUnit.InverseMile),
-                (ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseMillimeter) => new ReciprocalLength(_value / 1e3, ReciprocalLengthUnit.InverseMillimeter),
-                (ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseUsSurveyFoot) => new ReciprocalLength(_value * 1200 / 3937, ReciprocalLengthUnit.InverseUsSurveyFoot),
-                (ReciprocalLengthUnit.InverseMeter, ReciprocalLengthUnit.InverseYard) => new ReciprocalLength(_value * 0.9144, ReciprocalLengthUnit.InverseYard),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ReciprocalLengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalLengthUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ReciprocalLengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalLengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ReciprocalLengthUnit> IQuantity<ReciprocalLengthUnit>.ToUnit(ReciprocalLengthUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -950,11 +801,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
index 6c12b06e53..19b5fc29e9 100644
--- a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Relative humidity is a ratio of the actual water vapor present in the air to the maximum water vapor in the air at the given temperature.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct RelativeHumidity :
-        IArithmeticQuantity<RelativeHumidity, RelativeHumidityUnit>,
+        ILinearQuantity<RelativeHumidity, RelativeHumidityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<RelativeHumidity, RelativeHumidity, double>,
+        IDivisionOperators<RelativeHumidity, RelativeHumidity, QuantityValue>,
         IComparisonOperators<RelativeHumidity, RelativeHumidity, bool>,
         IParsable<RelativeHumidity>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -123,9 +122,7 @@ public static IEnumerable<UnitDefinition<RelativeHumidityUnit>> GetDefaultMappin
 
         static RelativeHumidity()
         {
-            Info = RelativeHumidityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RelativeHumidityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -133,7 +130,7 @@ static RelativeHumidity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RelativeHumidity(double value, RelativeHumidityUnit unit)
+        public RelativeHumidity(QuantityValue value, RelativeHumidityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -144,7 +141,8 @@ public RelativeHumidity(double value, RelativeHumidityUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="RelativeHumidity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<RelativeHumidity, RelativeHumidityUnit> Info { get; }
@@ -173,10 +171,8 @@ public RelativeHumidity(double value, RelativeHumidityUnit unit)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RelativeHumidityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -210,28 +206,14 @@ public RelativeHumidity(double value, RelativeHumidityUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RelativeHumidityUnit.Percent"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RelativeHumidityUnit.Percent"/>
         /// </summary>
-        public double Percent => As(RelativeHumidityUnit.Percent);
+        public QuantityValue Percent => this.As(RelativeHumidityUnit.Percent);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RelativeHumidityUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<RelativeHumidity>(RelativeHumidityUnit.Percent, RelativeHumidityUnit.Percent, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RelativeHumidityUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -260,7 +242,7 @@ public static string GetAbbreviation(RelativeHumidityUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="RelativeHumidity"/> from <see cref="RelativeHumidityUnit.Percent"/>.
         /// </summary>
-        public static RelativeHumidity FromPercent(double value)
+        public static RelativeHumidity FromPercent(QuantityValue value)
         {
             return new RelativeHumidity(value, RelativeHumidityUnit.Percent);
         }
@@ -271,7 +253,7 @@ public static RelativeHumidity FromPercent(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RelativeHumidity unit value.</returns>
-        public static RelativeHumidity From(double value, RelativeHumidityUnit fromUnit)
+        public static RelativeHumidity From(QuantityValue value, RelativeHumidityUnit fromUnit)
         {
             return new RelativeHumidity(value, fromUnit);
         }
@@ -332,10 +314,7 @@ public static RelativeHumidity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static RelativeHumidity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<RelativeHumidity, RelativeHumidityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<RelativeHumidity, RelativeHumidityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -363,11 +342,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out RelativeHumidity
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out RelativeHumidity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<RelativeHumidity, RelativeHumidityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<RelativeHumidity, RelativeHumidityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -388,7 +363,7 @@ public static RelativeHumidityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -399,7 +374,7 @@ public static RelativeHumidityUnit ParseUnit(string str, IFormatProvider? provid
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RelativeHumidityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RelativeHumidityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RelativeHumidityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -414,7 +389,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RelativeHumi
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RelativeHumidityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -433,35 +408,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="RelativeHumidity"/> from adding two <see cref="RelativeHumidity"/>.</summary>
         public static RelativeHumidity operator +(RelativeHumidity left, RelativeHumidity right)
         {
-            return new RelativeHumidity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new RelativeHumidity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RelativeHumidity"/> from subtracting two <see cref="RelativeHumidity"/>.</summary>
         public static RelativeHumidity operator -(RelativeHumidity left, RelativeHumidity right)
         {
-            return new RelativeHumidity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new RelativeHumidity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RelativeHumidity"/> from multiplying value and <see cref="RelativeHumidity"/>.</summary>
-        public static RelativeHumidity operator *(double left, RelativeHumidity right)
+        public static RelativeHumidity operator *(QuantityValue left, RelativeHumidity right)
         {
             return new RelativeHumidity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="RelativeHumidity"/> from multiplying value and <see cref="RelativeHumidity"/>.</summary>
-        public static RelativeHumidity operator *(RelativeHumidity left, double right)
+        public static RelativeHumidity operator *(RelativeHumidity left, QuantityValue right)
         {
             return new RelativeHumidity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="RelativeHumidity"/> from dividing <see cref="RelativeHumidity"/> by value.</summary>
-        public static RelativeHumidity operator /(RelativeHumidity left, double right)
+        public static RelativeHumidity operator /(RelativeHumidity left, QuantityValue right)
         {
             return new RelativeHumidity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="RelativeHumidity"/> by <see cref="RelativeHumidity"/>.</summary>
-        public static double operator /(RelativeHumidity left, RelativeHumidity right)
+        public static QuantityValue operator /(RelativeHumidity left, RelativeHumidity right)
         {
             return left.Percent / right.Percent;
         }
@@ -473,97 +448,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(RelativeHumidity left, RelativeHumidity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(RelativeHumidity left, RelativeHumidity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(RelativeHumidity left, RelativeHumidity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(RelativeHumidity left, RelativeHumidity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="RelativeHumidity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RelativeHumidity other, RelativeHumidity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RelativeHumidity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(RelativeHumidity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(RelativeHumidity left, RelativeHumidity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="RelativeHumidity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RelativeHumidity other, RelativeHumidity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RelativeHumidity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(RelativeHumidity,RelativeHumidity)"/>.
+        ///     See that operator (and <see cref="Equals(RelativeHumidity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(RelativeHumidity left, RelativeHumidity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RelativeHumidity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RelativeHumidity other, RelativeHumidity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="RelativeHumidity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="RelativeHumidity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="RelativeHumidity"/>, this method delegates to
+        ///     <see cref="Equals(RelativeHumidity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is RelativeHumidity otherQuantity))
+            if (obj is not RelativeHumidity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RelativeHumidity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RelativeHumidity other, RelativeHumidity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="RelativeHumidity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(RelativeHumidity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current RelativeHumidity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(RelativeHumidity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="RelativeHumidity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(RelativeHumidity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is RelativeHumidity otherQuantity)) throw new ArgumentException("Expected type RelativeHumidity.", nameof(obj));
+            if (obj is not RelativeHumidity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<RelativeHumidity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="RelativeHumidity"/> with another <see cref="RelativeHumidity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="RelativeHumidity"/> with another <see cref="RelativeHumidity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -575,131 +564,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(RelativeHumidity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RelativeHumidityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RelativeHumidityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this RelativeHumidity to another RelativeHumidity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A RelativeHumidity with the specified unit.</returns>
-        public RelativeHumidity ToUnit(RelativeHumidityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="RelativeHumidity"/> to another <see cref="RelativeHumidity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A RelativeHumidity with the specified unit.</returns>
-        public RelativeHumidity ToUnit(RelativeHumidityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(RelativeHumidity), Unit, typeof(RelativeHumidity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (RelativeHumidity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="RelativeHumidity"/> to another <see cref="RelativeHumidity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="RelativeHumidity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RelativeHumidityUnit unit, [NotNullWhen(true)] out RelativeHumidity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            RelativeHumidity? convertedOrNull = (Unit, unit) switch
-            {
-                // RelativeHumidityUnit -> BaseUnit
-
-                // BaseUnit -> RelativeHumidityUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RelativeHumidityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RelativeHumidityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RelativeHumidityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RelativeHumidityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RelativeHumidityUnit> IQuantity<RelativeHumidityUnit>.ToUnit(RelativeHumidityUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -711,11 +580,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
index ed0f6dde57..fad8cfbb48 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     Angular acceleration is the rate of change of rotational speed.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct RotationalAcceleration :
-        IArithmeticQuantity<RotationalAcceleration, RotationalAccelerationUnit>,
+        ILinearQuantity<RotationalAcceleration, RotationalAccelerationUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<RotationalAcceleration, RotationalAcceleration, double>,
+        IDivisionOperators<RotationalAcceleration, RotationalAcceleration, QuantityValue>,
+        IMultiplyOperators<RotationalAcceleration, Duration, RotationalSpeed>,
         IComparisonOperators<RotationalAcceleration, RotationalAcceleration, bool>,
         IParsable<RotationalAcceleration>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static RotationalAccelerationInfo CreateDefault(Func<IEnumerable<UnitDefi
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="RotationalAcceleration"/> is [T^-2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="RotationalAcceleration"/> is T^-2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, -2, 0, 0, 0, 0);
 
@@ -117,18 +117,22 @@ public static RotationalAccelerationInfo CreateDefault(Func<IEnumerable<UnitDefi
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{RotationalAccelerationUnit}"/> representing the default unit mappings for RotationalAcceleration.</returns>
             public static IEnumerable<UnitDefinition<RotationalAccelerationUnit>> GetDefaultMappings()
             {
-                yield return new (RotationalAccelerationUnit.DegreePerSecondSquared, "DegreePerSecondSquared", "DegreesPerSecondSquared", BaseUnits.Undefined);
+                yield return new (RotationalAccelerationUnit.DegreePerSecondSquared, "DegreePerSecondSquared", "DegreesPerSecondSquared", BaseUnits.Undefined,
+                     new QuantityValue(180000000000000000, 3141592653589793)
+                );
                 yield return new (RotationalAccelerationUnit.RadianPerSecondSquared, "RadianPerSecondSquared", "RadiansPerSecondSquared", new BaseUnits(time: DurationUnit.Second));
-                yield return new (RotationalAccelerationUnit.RevolutionPerMinutePerSecond, "RevolutionPerMinutePerSecond", "RevolutionsPerMinutePerSecond", BaseUnits.Undefined);
-                yield return new (RotationalAccelerationUnit.RevolutionPerSecondSquared, "RevolutionPerSecondSquared", "RevolutionsPerSecondSquared", BaseUnits.Undefined);
+                yield return new (RotationalAccelerationUnit.RevolutionPerMinutePerSecond, "RevolutionPerMinutePerSecond", "RevolutionsPerMinutePerSecond", BaseUnits.Undefined,
+                     new QuantityValue(30000000000000000, 3141592653589793)
+                );
+                yield return new (RotationalAccelerationUnit.RevolutionPerSecondSquared, "RevolutionPerSecondSquared", "RevolutionsPerSecondSquared", BaseUnits.Undefined,
+                     new QuantityValue(500000000000000, 3141592653589793)
+                );
             }
         }
 
         static RotationalAcceleration()
         {
-            Info = RotationalAccelerationInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RotationalAccelerationInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +140,7 @@ static RotationalAcceleration()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RotationalAcceleration(double value, RotationalAccelerationUnit unit)
+        public RotationalAcceleration(QuantityValue value, RotationalAccelerationUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -150,7 +154,7 @@ public RotationalAcceleration(double value, RotationalAccelerationUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RotationalAcceleration(double value, UnitSystem unitSystem)
+        public RotationalAcceleration(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -161,7 +165,8 @@ public RotationalAcceleration(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="RotationalAcceleration" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<RotationalAcceleration, RotationalAccelerationUnit> Info { get; }
@@ -190,10 +195,8 @@ public RotationalAcceleration(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RotationalAccelerationUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,49 +230,29 @@ public RotationalAcceleration(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.DegreePerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.DegreePerSecondSquared"/>
         /// </summary>
-        public double DegreesPerSecondSquared => As(RotationalAccelerationUnit.DegreePerSecondSquared);
+        public QuantityValue DegreesPerSecondSquared => this.As(RotationalAccelerationUnit.DegreePerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.RadianPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.RadianPerSecondSquared"/>
         /// </summary>
-        public double RadiansPerSecondSquared => As(RotationalAccelerationUnit.RadianPerSecondSquared);
+        public QuantityValue RadiansPerSecondSquared => this.As(RotationalAccelerationUnit.RadianPerSecondSquared);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.RevolutionPerMinutePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.RevolutionPerMinutePerSecond"/>
         /// </summary>
-        public double RevolutionsPerMinutePerSecond => As(RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
+        public QuantityValue RevolutionsPerMinutePerSecond => this.As(RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.RevolutionPerSecondSquared"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalAccelerationUnit.RevolutionPerSecondSquared"/>
         /// </summary>
-        public double RevolutionsPerSecondSquared => As(RotationalAccelerationUnit.RevolutionPerSecondSquared);
+        public QuantityValue RevolutionsPerSecondSquared => this.As(RotationalAccelerationUnit.RevolutionPerSecondSquared);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RotationalAccelerationUnit -> BaseUnit
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAccelerationUnit.DegreePerSecondSquared, RotationalAccelerationUnit.RadianPerSecondSquared, quantity => quantity.ToUnit(RotationalAccelerationUnit.RadianPerSecondSquared));
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAccelerationUnit.RevolutionPerMinutePerSecond, RotationalAccelerationUnit.RadianPerSecondSquared, quantity => quantity.ToUnit(RotationalAccelerationUnit.RadianPerSecondSquared));
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAccelerationUnit.RevolutionPerSecondSquared, RotationalAccelerationUnit.RadianPerSecondSquared, quantity => quantity.ToUnit(RotationalAccelerationUnit.RadianPerSecondSquared));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAccelerationUnit.RadianPerSecondSquared, RotationalAccelerationUnit.RadianPerSecondSquared, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RotationalAccelerationUnit
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAccelerationUnit.RadianPerSecondSquared, RotationalAccelerationUnit.DegreePerSecondSquared, quantity => quantity.ToUnit(RotationalAccelerationUnit.DegreePerSecondSquared));
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAccelerationUnit.RadianPerSecondSquared, RotationalAccelerationUnit.RevolutionPerMinutePerSecond, quantity => quantity.ToUnit(RotationalAccelerationUnit.RevolutionPerMinutePerSecond));
-            unitConverter.SetConversionFunction<RotationalAcceleration>(RotationalAccelerationUnit.RadianPerSecondSquared, RotationalAccelerationUnit.RevolutionPerSecondSquared, quantity => quantity.ToUnit(RotationalAccelerationUnit.RevolutionPerSecondSquared));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -298,7 +281,7 @@ public static string GetAbbreviation(RotationalAccelerationUnit unit, IFormatPro
         /// <summary>
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.DegreePerSecondSquared"/>.
         /// </summary>
-        public static RotationalAcceleration FromDegreesPerSecondSquared(double value)
+        public static RotationalAcceleration FromDegreesPerSecondSquared(QuantityValue value)
         {
             return new RotationalAcceleration(value, RotationalAccelerationUnit.DegreePerSecondSquared);
         }
@@ -306,7 +289,7 @@ public static RotationalAcceleration FromDegreesPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RadianPerSecondSquared"/>.
         /// </summary>
-        public static RotationalAcceleration FromRadiansPerSecondSquared(double value)
+        public static RotationalAcceleration FromRadiansPerSecondSquared(QuantityValue value)
         {
             return new RotationalAcceleration(value, RotationalAccelerationUnit.RadianPerSecondSquared);
         }
@@ -314,7 +297,7 @@ public static RotationalAcceleration FromRadiansPerSecondSquared(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RevolutionPerMinutePerSecond"/>.
         /// </summary>
-        public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(double value)
+        public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(QuantityValue value)
         {
             return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
         }
@@ -322,7 +305,7 @@ public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(double va
         /// <summary>
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RevolutionPerSecondSquared"/>.
         /// </summary>
-        public static RotationalAcceleration FromRevolutionsPerSecondSquared(double value)
+        public static RotationalAcceleration FromRevolutionsPerSecondSquared(QuantityValue value)
         {
             return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerSecondSquared);
         }
@@ -333,7 +316,7 @@ public static RotationalAcceleration FromRevolutionsPerSecondSquared(double valu
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RotationalAcceleration unit value.</returns>
-        public static RotationalAcceleration From(double value, RotationalAccelerationUnit fromUnit)
+        public static RotationalAcceleration From(QuantityValue value, RotationalAccelerationUnit fromUnit)
         {
             return new RotationalAcceleration(value, fromUnit);
         }
@@ -394,10 +377,7 @@ public static RotationalAcceleration Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static RotationalAcceleration Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<RotationalAcceleration, RotationalAccelerationUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<RotationalAcceleration, RotationalAccelerationUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -425,11 +405,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out RotationalAccele
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out RotationalAcceleration result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<RotationalAcceleration, RotationalAccelerationUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<RotationalAcceleration, RotationalAccelerationUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -450,7 +426,7 @@ public static RotationalAccelerationUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -461,7 +437,7 @@ public static RotationalAccelerationUnit ParseUnit(string str, IFormatProvider?
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RotationalAccelerationUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RotationalAccelerationUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalAccelerationUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -476,7 +452,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalAc
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RotationalAccelerationUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -495,137 +471,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="RotationalAcceleration"/> from adding two <see cref="RotationalAcceleration"/>.</summary>
         public static RotationalAcceleration operator +(RotationalAcceleration left, RotationalAcceleration right)
         {
-            return new RotationalAcceleration(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new RotationalAcceleration(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalAcceleration"/> from subtracting two <see cref="RotationalAcceleration"/>.</summary>
         public static RotationalAcceleration operator -(RotationalAcceleration left, RotationalAcceleration right)
         {
-            return new RotationalAcceleration(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new RotationalAcceleration(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalAcceleration"/> from multiplying value and <see cref="RotationalAcceleration"/>.</summary>
-        public static RotationalAcceleration operator *(double left, RotationalAcceleration right)
+        public static RotationalAcceleration operator *(QuantityValue left, RotationalAcceleration right)
         {
             return new RotationalAcceleration(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="RotationalAcceleration"/> from multiplying value and <see cref="RotationalAcceleration"/>.</summary>
-        public static RotationalAcceleration operator *(RotationalAcceleration left, double right)
+        public static RotationalAcceleration operator *(RotationalAcceleration left, QuantityValue right)
         {
             return new RotationalAcceleration(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalAcceleration"/> from dividing <see cref="RotationalAcceleration"/> by value.</summary>
-        public static RotationalAcceleration operator /(RotationalAcceleration left, double right)
+        public static RotationalAcceleration operator /(RotationalAcceleration left, QuantityValue right)
         {
             return new RotationalAcceleration(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="RotationalAcceleration"/> by <see cref="RotationalAcceleration"/>.</summary>
-        public static double operator /(RotationalAcceleration left, RotationalAcceleration right)
+        public static QuantityValue operator /(RotationalAcceleration left, RotationalAcceleration right)
         {
             return left.RadiansPerSecondSquared / right.RadiansPerSecondSquared;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="RotationalSpeed"/> from <see cref="RotationalAcceleration"/> * <see cref="Duration"/>.</summary>
+        public static RotationalSpeed operator *(RotationalAcceleration rotationalAcceleration, Duration duration)
+        {
+            return RotationalSpeed.FromRadiansPerSecond(rotationalAcceleration.RadiansPerSecondSquared * duration.Seconds);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(RotationalAcceleration left, RotationalAcceleration right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(RotationalAcceleration left, RotationalAcceleration right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(RotationalAcceleration left, RotationalAcceleration right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(RotationalAcceleration left, RotationalAcceleration right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="RotationalAcceleration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RotationalAcceleration other, RotationalAcceleration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RotationalAcceleration"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(RotationalAcceleration)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(RotationalAcceleration left, RotationalAcceleration right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="RotationalAcceleration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RotationalAcceleration other, RotationalAcceleration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RotationalAcceleration"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(RotationalAcceleration,RotationalAcceleration)"/>.
+        ///     See that operator (and <see cref="Equals(RotationalAcceleration)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(RotationalAcceleration left, RotationalAcceleration right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RotationalAcceleration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RotationalAcceleration other, RotationalAcceleration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="RotationalAcceleration"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="RotationalAcceleration"/>.
+        ///     When <paramref name="obj"/> is a <see cref="RotationalAcceleration"/>, this method delegates to
+        ///     <see cref="Equals(RotationalAcceleration)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is RotationalAcceleration otherQuantity))
+            if (obj is not RotationalAcceleration otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RotationalAcceleration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RotationalAcceleration other, RotationalAcceleration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="RotationalAcceleration"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(RotationalAcceleration other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current RotationalAcceleration.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(RotationalAcceleration), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="RotationalAcceleration"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(RotationalAcceleration)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is RotationalAcceleration otherQuantity)) throw new ArgumentException("Expected type RotationalAcceleration.", nameof(obj));
+            if (obj is not RotationalAcceleration otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<RotationalAcceleration>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="RotationalAcceleration"/> with another <see cref="RotationalAcceleration"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="RotationalAcceleration"/> with another <see cref="RotationalAcceleration"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -637,137 +637,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(RotationalAcceleration other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RotationalAccelerationUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RotationalAccelerationUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this RotationalAcceleration to another RotationalAcceleration with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A RotationalAcceleration with the specified unit.</returns>
-        public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="RotationalAcceleration"/> to another <see cref="RotationalAcceleration"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A RotationalAcceleration with the specified unit.</returns>
-        public RotationalAcceleration ToUnit(RotationalAccelerationUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(RotationalAcceleration), Unit, typeof(RotationalAcceleration), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (RotationalAcceleration)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="RotationalAcceleration"/> to another <see cref="RotationalAcceleration"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="RotationalAcceleration"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RotationalAccelerationUnit unit, [NotNullWhen(true)] out RotationalAcceleration? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            RotationalAcceleration? convertedOrNull = (Unit, unit) switch
-            {
-                // RotationalAccelerationUnit -> BaseUnit
-                (RotationalAccelerationUnit.DegreePerSecondSquared, RotationalAccelerationUnit.RadianPerSecondSquared) => new RotationalAcceleration((Math.PI / 180) * _value, RotationalAccelerationUnit.RadianPerSecondSquared),
-                (RotationalAccelerationUnit.RevolutionPerMinutePerSecond, RotationalAccelerationUnit.RadianPerSecondSquared) => new RotationalAcceleration(((2 * Math.PI) / 60) * _value, RotationalAccelerationUnit.RadianPerSecondSquared),
-                (RotationalAccelerationUnit.RevolutionPerSecondSquared, RotationalAccelerationUnit.RadianPerSecondSquared) => new RotationalAcceleration((2 * Math.PI) * _value, RotationalAccelerationUnit.RadianPerSecondSquared),
-
-                // BaseUnit -> RotationalAccelerationUnit
-                (RotationalAccelerationUnit.RadianPerSecondSquared, RotationalAccelerationUnit.DegreePerSecondSquared) => new RotationalAcceleration((180 / Math.PI) * _value, RotationalAccelerationUnit.DegreePerSecondSquared),
-                (RotationalAccelerationUnit.RadianPerSecondSquared, RotationalAccelerationUnit.RevolutionPerMinutePerSecond) => new RotationalAcceleration((60 / (2 * Math.PI)) * _value, RotationalAccelerationUnit.RevolutionPerMinutePerSecond),
-                (RotationalAccelerationUnit.RadianPerSecondSquared, RotationalAccelerationUnit.RevolutionPerSecondSquared) => new RotationalAcceleration((1 / (2 * Math.PI)) * _value, RotationalAccelerationUnit.RevolutionPerSecondSquared),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RotationalAccelerationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalAccelerationUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RotationalAccelerationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalAccelerationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RotationalAccelerationUnit> IQuantity<RotationalAccelerationUnit>.ToUnit(RotationalAccelerationUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -779,11 +653,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
index 7262bc7e78..30d6665ad8 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,13 +33,16 @@ namespace UnitsNet
     ///     Rotational speed (sometimes called speed of revolution) is the number of complete rotations, revolutions, cycles, or turns per time unit. Rotational speed is a cyclic frequency, measured in radians per second or in hertz in the SI System by scientists, or in revolutions per minute (rpm or min-1) or revolutions per second in everyday life. The symbol for rotational speed is ω (the Greek lowercase letter "omega").
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct RotationalSpeed :
-        IArithmeticQuantity<RotationalSpeed, RotationalSpeedUnit>,
+        ILinearQuantity<RotationalSpeed, RotationalSpeedUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<RotationalSpeed, RotationalSpeed, double>,
+        IDivisionOperators<RotationalSpeed, RotationalSpeed, QuantityValue>,
         IMultiplyOperators<RotationalSpeed, Duration, Angle>,
+        IDivisionOperators<RotationalSpeed, RotationalAcceleration, Duration>,
         IMultiplyOperators<RotationalSpeed, Torque, Power>,
+        IDivisionOperators<RotationalSpeed, Duration, RotationalAcceleration>,
         IComparisonOperators<RotationalSpeed, RotationalSpeed, bool>,
         IParsable<RotationalSpeed>,
 #endif
@@ -54,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -104,7 +105,7 @@ public static RotationalSpeedInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="RotationalSpeed"/> is [T^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="RotationalSpeed"/> is T^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, -1, 0, 0, 0, 0);
 
@@ -119,27 +120,49 @@ public static RotationalSpeedInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{RotationalSpeedUnit}"/> representing the default unit mappings for RotationalSpeed.</returns>
             public static IEnumerable<UnitDefinition<RotationalSpeedUnit>> GetDefaultMappings()
             {
-                yield return new (RotationalSpeedUnit.CentiradianPerSecond, "CentiradianPerSecond", "CentiradiansPerSecond", BaseUnits.Undefined);
-                yield return new (RotationalSpeedUnit.DeciradianPerSecond, "DeciradianPerSecond", "DeciradiansPerSecond", BaseUnits.Undefined);
-                yield return new (RotationalSpeedUnit.DegreePerMinute, "DegreePerMinute", "DegreesPerMinute", BaseUnits.Undefined);
-                yield return new (RotationalSpeedUnit.DegreePerSecond, "DegreePerSecond", "DegreesPerSecond", BaseUnits.Undefined);
-                yield return new (RotationalSpeedUnit.MicrodegreePerSecond, "MicrodegreePerSecond", "MicrodegreesPerSecond", BaseUnits.Undefined);
-                yield return new (RotationalSpeedUnit.MicroradianPerSecond, "MicroradianPerSecond", "MicroradiansPerSecond", BaseUnits.Undefined);
-                yield return new (RotationalSpeedUnit.MillidegreePerSecond, "MillidegreePerSecond", "MillidegreesPerSecond", BaseUnits.Undefined);
-                yield return new (RotationalSpeedUnit.MilliradianPerSecond, "MilliradianPerSecond", "MilliradiansPerSecond", BaseUnits.Undefined);
-                yield return new (RotationalSpeedUnit.NanodegreePerSecond, "NanodegreePerSecond", "NanodegreesPerSecond", BaseUnits.Undefined);
-                yield return new (RotationalSpeedUnit.NanoradianPerSecond, "NanoradianPerSecond", "NanoradiansPerSecond", BaseUnits.Undefined);
+                yield return new (RotationalSpeedUnit.CentiradianPerSecond, "CentiradianPerSecond", "CentiradiansPerSecond", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (RotationalSpeedUnit.DeciradianPerSecond, "DeciradianPerSecond", "DeciradiansPerSecond", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (RotationalSpeedUnit.DegreePerMinute, "DegreePerMinute", "DegreesPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(108) * QuantityValue.PowerOfTen(17), 3141592653589793)
+                );
+                yield return new (RotationalSpeedUnit.DegreePerSecond, "DegreePerSecond", "DegreesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(180000000000000000, 3141592653589793)
+                );
+                yield return new (RotationalSpeedUnit.MicrodegreePerSecond, "MicrodegreePerSecond", "MicrodegreesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(18) * QuantityValue.PowerOfTen(22), 3141592653589793)
+                );
+                yield return new (RotationalSpeedUnit.MicroradianPerSecond, "MicroradianPerSecond", "MicroradiansPerSecond", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (RotationalSpeedUnit.MillidegreePerSecond, "MillidegreePerSecond", "MillidegreesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(18) * QuantityValue.PowerOfTen(19), 3141592653589793)
+                );
+                yield return new (RotationalSpeedUnit.MilliradianPerSecond, "MilliradianPerSecond", "MilliradiansPerSecond", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (RotationalSpeedUnit.NanodegreePerSecond, "NanodegreePerSecond", "NanodegreesPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(new BigInteger(18) * QuantityValue.PowerOfTen(25), 3141592653589793)
+                );
+                yield return new (RotationalSpeedUnit.NanoradianPerSecond, "NanoradianPerSecond", "NanoradiansPerSecond", BaseUnits.Undefined,
+                     1000000000
+                );
                 yield return new (RotationalSpeedUnit.RadianPerSecond, "RadianPerSecond", "RadiansPerSecond", new BaseUnits(time: DurationUnit.Second));
-                yield return new (RotationalSpeedUnit.RevolutionPerMinute, "RevolutionPerMinute", "RevolutionsPerMinute", BaseUnits.Undefined);
-                yield return new (RotationalSpeedUnit.RevolutionPerSecond, "RevolutionPerSecond", "RevolutionsPerSecond", BaseUnits.Undefined);
+                yield return new (RotationalSpeedUnit.RevolutionPerMinute, "RevolutionPerMinute", "RevolutionsPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(30000000000000000, 3141592653589793)
+                );
+                yield return new (RotationalSpeedUnit.RevolutionPerSecond, "RevolutionPerSecond", "RevolutionsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(500000000000000, 3141592653589793)
+                );
             }
         }
 
         static RotationalSpeed()
         {
-            Info = RotationalSpeedInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RotationalSpeedInfo.CreateDefault);
         }
 
         /// <summary>
@@ -147,7 +170,7 @@ static RotationalSpeed()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RotationalSpeed(double value, RotationalSpeedUnit unit)
+        public RotationalSpeed(QuantityValue value, RotationalSpeedUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -161,7 +184,7 @@ public RotationalSpeed(double value, RotationalSpeedUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RotationalSpeed(double value, UnitSystem unitSystem)
+        public RotationalSpeed(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -172,7 +195,8 @@ public RotationalSpeed(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="RotationalSpeed" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<RotationalSpeed, RotationalSpeedUnit> Info { get; }
@@ -201,10 +225,8 @@ public RotationalSpeed(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RotationalSpeedUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -238,112 +260,74 @@ public RotationalSpeed(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.CentiradianPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.CentiradianPerSecond"/>
         /// </summary>
-        public double CentiradiansPerSecond => As(RotationalSpeedUnit.CentiradianPerSecond);
+        public QuantityValue CentiradiansPerSecond => this.As(RotationalSpeedUnit.CentiradianPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.DeciradianPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.DeciradianPerSecond"/>
         /// </summary>
-        public double DeciradiansPerSecond => As(RotationalSpeedUnit.DeciradianPerSecond);
+        public QuantityValue DeciradiansPerSecond => this.As(RotationalSpeedUnit.DeciradianPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.DegreePerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.DegreePerMinute"/>
         /// </summary>
-        public double DegreesPerMinute => As(RotationalSpeedUnit.DegreePerMinute);
+        public QuantityValue DegreesPerMinute => this.As(RotationalSpeedUnit.DegreePerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.DegreePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.DegreePerSecond"/>
         /// </summary>
-        public double DegreesPerSecond => As(RotationalSpeedUnit.DegreePerSecond);
+        public QuantityValue DegreesPerSecond => this.As(RotationalSpeedUnit.DegreePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MicrodegreePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MicrodegreePerSecond"/>
         /// </summary>
-        public double MicrodegreesPerSecond => As(RotationalSpeedUnit.MicrodegreePerSecond);
+        public QuantityValue MicrodegreesPerSecond => this.As(RotationalSpeedUnit.MicrodegreePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MicroradianPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MicroradianPerSecond"/>
         /// </summary>
-        public double MicroradiansPerSecond => As(RotationalSpeedUnit.MicroradianPerSecond);
+        public QuantityValue MicroradiansPerSecond => this.As(RotationalSpeedUnit.MicroradianPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MillidegreePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MillidegreePerSecond"/>
         /// </summary>
-        public double MillidegreesPerSecond => As(RotationalSpeedUnit.MillidegreePerSecond);
+        public QuantityValue MillidegreesPerSecond => this.As(RotationalSpeedUnit.MillidegreePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MilliradianPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.MilliradianPerSecond"/>
         /// </summary>
-        public double MilliradiansPerSecond => As(RotationalSpeedUnit.MilliradianPerSecond);
+        public QuantityValue MilliradiansPerSecond => this.As(RotationalSpeedUnit.MilliradianPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.NanodegreePerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.NanodegreePerSecond"/>
         /// </summary>
-        public double NanodegreesPerSecond => As(RotationalSpeedUnit.NanodegreePerSecond);
+        public QuantityValue NanodegreesPerSecond => this.As(RotationalSpeedUnit.NanodegreePerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.NanoradianPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.NanoradianPerSecond"/>
         /// </summary>
-        public double NanoradiansPerSecond => As(RotationalSpeedUnit.NanoradianPerSecond);
+        public QuantityValue NanoradiansPerSecond => this.As(RotationalSpeedUnit.NanoradianPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.RadianPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.RadianPerSecond"/>
         /// </summary>
-        public double RadiansPerSecond => As(RotationalSpeedUnit.RadianPerSecond);
+        public QuantityValue RadiansPerSecond => this.As(RotationalSpeedUnit.RadianPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.RevolutionPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.RevolutionPerMinute"/>
         /// </summary>
-        public double RevolutionsPerMinute => As(RotationalSpeedUnit.RevolutionPerMinute);
+        public QuantityValue RevolutionsPerMinute => this.As(RotationalSpeedUnit.RevolutionPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalSpeedUnit.RevolutionPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalSpeedUnit.RevolutionPerSecond"/>
         /// </summary>
-        public double RevolutionsPerSecond => As(RotationalSpeedUnit.RevolutionPerSecond);
+        public QuantityValue RevolutionsPerSecond => this.As(RotationalSpeedUnit.RevolutionPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RotationalSpeedUnit -> BaseUnit
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.CentiradianPerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.DeciradianPerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.DegreePerMinute, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.DegreePerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.MicrodegreePerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.MicroradianPerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.MillidegreePerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.MilliradianPerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.NanodegreePerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.NanoradianPerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RevolutionPerMinute, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RadianPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.RadianPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RotationalSpeedUnit
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.CentiradianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.CentiradianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.DeciradianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.DeciradianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.DegreePerMinute, quantity => quantity.ToUnit(RotationalSpeedUnit.DegreePerMinute));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.DegreePerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.DegreePerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.MicrodegreePerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.MicrodegreePerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.MicroradianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.MicroradianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.MillidegreePerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.MillidegreePerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.MilliradianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.MilliradianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.NanodegreePerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.NanodegreePerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.NanoradianPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.NanoradianPerSecond));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.RevolutionPerMinute, quantity => quantity.ToUnit(RotationalSpeedUnit.RevolutionPerMinute));
-            unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.RevolutionPerSecond, quantity => quantity.ToUnit(RotationalSpeedUnit.RevolutionPerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -372,7 +356,7 @@ public static string GetAbbreviation(RotationalSpeedUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.CentiradianPerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromCentiradiansPerSecond(double value)
+        public static RotationalSpeed FromCentiradiansPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.CentiradianPerSecond);
         }
@@ -380,7 +364,7 @@ public static RotationalSpeed FromCentiradiansPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DeciradianPerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromDeciradiansPerSecond(double value)
+        public static RotationalSpeed FromDeciradiansPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.DeciradianPerSecond);
         }
@@ -388,7 +372,7 @@ public static RotationalSpeed FromDeciradiansPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DegreePerMinute"/>.
         /// </summary>
-        public static RotationalSpeed FromDegreesPerMinute(double value)
+        public static RotationalSpeed FromDegreesPerMinute(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerMinute);
         }
@@ -396,7 +380,7 @@ public static RotationalSpeed FromDegreesPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DegreePerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromDegreesPerSecond(double value)
+        public static RotationalSpeed FromDegreesPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerSecond);
         }
@@ -404,7 +388,7 @@ public static RotationalSpeed FromDegreesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MicrodegreePerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromMicrodegreesPerSecond(double value)
+        public static RotationalSpeed FromMicrodegreesPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.MicrodegreePerSecond);
         }
@@ -412,7 +396,7 @@ public static RotationalSpeed FromMicrodegreesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MicroradianPerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromMicroradiansPerSecond(double value)
+        public static RotationalSpeed FromMicroradiansPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.MicroradianPerSecond);
         }
@@ -420,7 +404,7 @@ public static RotationalSpeed FromMicroradiansPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MillidegreePerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromMillidegreesPerSecond(double value)
+        public static RotationalSpeed FromMillidegreesPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.MillidegreePerSecond);
         }
@@ -428,7 +412,7 @@ public static RotationalSpeed FromMillidegreesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MilliradianPerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromMilliradiansPerSecond(double value)
+        public static RotationalSpeed FromMilliradiansPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.MilliradianPerSecond);
         }
@@ -436,7 +420,7 @@ public static RotationalSpeed FromMilliradiansPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.NanodegreePerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromNanodegreesPerSecond(double value)
+        public static RotationalSpeed FromNanodegreesPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.NanodegreePerSecond);
         }
@@ -444,7 +428,7 @@ public static RotationalSpeed FromNanodegreesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.NanoradianPerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromNanoradiansPerSecond(double value)
+        public static RotationalSpeed FromNanoradiansPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.NanoradianPerSecond);
         }
@@ -452,7 +436,7 @@ public static RotationalSpeed FromNanoradiansPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RadianPerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromRadiansPerSecond(double value)
+        public static RotationalSpeed FromRadiansPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.RadianPerSecond);
         }
@@ -460,7 +444,7 @@ public static RotationalSpeed FromRadiansPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RevolutionPerMinute"/>.
         /// </summary>
-        public static RotationalSpeed FromRevolutionsPerMinute(double value)
+        public static RotationalSpeed FromRevolutionsPerMinute(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerMinute);
         }
@@ -468,7 +452,7 @@ public static RotationalSpeed FromRevolutionsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RevolutionPerSecond"/>.
         /// </summary>
-        public static RotationalSpeed FromRevolutionsPerSecond(double value)
+        public static RotationalSpeed FromRevolutionsPerSecond(QuantityValue value)
         {
             return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerSecond);
         }
@@ -479,7 +463,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RotationalSpeed unit value.</returns>
-        public static RotationalSpeed From(double value, RotationalSpeedUnit fromUnit)
+        public static RotationalSpeed From(QuantityValue value, RotationalSpeedUnit fromUnit)
         {
             return new RotationalSpeed(value, fromUnit);
         }
@@ -540,10 +524,7 @@ public static RotationalSpeed Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static RotationalSpeed Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<RotationalSpeed, RotationalSpeedUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<RotationalSpeed, RotationalSpeedUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -571,11 +552,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out RotationalSpeed
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out RotationalSpeed result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<RotationalSpeed, RotationalSpeedUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<RotationalSpeed, RotationalSpeedUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -596,7 +573,7 @@ public static RotationalSpeedUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -607,7 +584,7 @@ public static RotationalSpeedUnit ParseUnit(string str, IFormatProvider? provide
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RotationalSpeedUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RotationalSpeedUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalSpeedUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -622,7 +599,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalSp
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RotationalSpeedUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -641,35 +618,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="RotationalSpeed"/> from adding two <see cref="RotationalSpeed"/>.</summary>
         public static RotationalSpeed operator +(RotationalSpeed left, RotationalSpeed right)
         {
-            return new RotationalSpeed(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new RotationalSpeed(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalSpeed"/> from subtracting two <see cref="RotationalSpeed"/>.</summary>
         public static RotationalSpeed operator -(RotationalSpeed left, RotationalSpeed right)
         {
-            return new RotationalSpeed(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new RotationalSpeed(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalSpeed"/> from multiplying value and <see cref="RotationalSpeed"/>.</summary>
-        public static RotationalSpeed operator *(double left, RotationalSpeed right)
+        public static RotationalSpeed operator *(QuantityValue left, RotationalSpeed right)
         {
             return new RotationalSpeed(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="RotationalSpeed"/> from multiplying value and <see cref="RotationalSpeed"/>.</summary>
-        public static RotationalSpeed operator *(RotationalSpeed left, double right)
+        public static RotationalSpeed operator *(RotationalSpeed left, QuantityValue right)
         {
             return new RotationalSpeed(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalSpeed"/> from dividing <see cref="RotationalSpeed"/> by value.</summary>
-        public static RotationalSpeed operator /(RotationalSpeed left, double right)
+        public static RotationalSpeed operator /(RotationalSpeed left, QuantityValue right)
         {
             return new RotationalSpeed(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="RotationalSpeed"/> by <see cref="RotationalSpeed"/>.</summary>
-        public static double operator /(RotationalSpeed left, RotationalSpeed right)
+        public static QuantityValue operator /(RotationalSpeed left, RotationalSpeed right)
         {
             return left.RadiansPerSecond / right.RadiansPerSecond;
         }
@@ -684,12 +661,24 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * duration.Seconds);
         }
 
+        /// <summary>Get <see cref="Duration"/> from <see cref="RotationalSpeed"/> / <see cref="RotationalAcceleration"/>.</summary>
+        public static Duration operator /(RotationalSpeed rotationalSpeed, RotationalAcceleration rotationalAcceleration)
+        {
+            return Duration.FromSeconds(rotationalSpeed.RadiansPerSecond / rotationalAcceleration.RadiansPerSecondSquared);
+        }
+
         /// <summary>Get <see cref="Power"/> from <see cref="RotationalSpeed"/> * <see cref="Torque"/>.</summary>
         public static Power operator *(RotationalSpeed rotationalSpeed, Torque torque)
         {
             return Power.FromWatts(rotationalSpeed.RadiansPerSecond * torque.NewtonMeters);
         }
 
+        /// <summary>Get <see cref="RotationalAcceleration"/> from <see cref="RotationalSpeed"/> / <see cref="Duration"/>.</summary>
+        public static RotationalAcceleration operator /(RotationalSpeed rotationalSpeed, Duration duration)
+        {
+            return RotationalAcceleration.FromRadiansPerSecondSquared(rotationalSpeed.RadiansPerSecond / duration.Seconds);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -697,97 +686,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(RotationalSpeed left, RotationalSpeed right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(RotationalSpeed left, RotationalSpeed right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(RotationalSpeed left, RotationalSpeed right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(RotationalSpeed left, RotationalSpeed right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="RotationalSpeed"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RotationalSpeed other, RotationalSpeed tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RotationalSpeed"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(RotationalSpeed)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(RotationalSpeed left, RotationalSpeed right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="RotationalSpeed"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RotationalSpeed other, RotationalSpeed tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RotationalSpeed"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(RotationalSpeed,RotationalSpeed)"/>.
+        ///     See that operator (and <see cref="Equals(RotationalSpeed)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(RotationalSpeed left, RotationalSpeed right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RotationalSpeed"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RotationalSpeed other, RotationalSpeed tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="RotationalSpeed"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="RotationalSpeed"/>.
+        ///     When <paramref name="obj"/> is a <see cref="RotationalSpeed"/>, this method delegates to
+        ///     <see cref="Equals(RotationalSpeed)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is RotationalSpeed otherQuantity))
+            if (obj is not RotationalSpeed otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RotationalSpeed"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RotationalSpeed other, RotationalSpeed tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="RotationalSpeed"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(RotationalSpeed other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current RotationalSpeed.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(RotationalSpeed), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="RotationalSpeed"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(RotationalSpeed)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is RotationalSpeed otherQuantity)) throw new ArgumentException("Expected type RotationalSpeed.", nameof(obj));
+            if (obj is not RotationalSpeed otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<RotationalSpeed>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="RotationalSpeed"/> with another <see cref="RotationalSpeed"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="RotationalSpeed"/> with another <see cref="RotationalSpeed"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -799,153 +802,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(RotationalSpeed other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RotationalSpeedUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RotationalSpeedUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this RotationalSpeed to another RotationalSpeed with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A RotationalSpeed with the specified unit.</returns>
-        public RotationalSpeed ToUnit(RotationalSpeedUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="RotationalSpeed"/> to another <see cref="RotationalSpeed"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A RotationalSpeed with the specified unit.</returns>
-        public RotationalSpeed ToUnit(RotationalSpeedUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(RotationalSpeed), Unit, typeof(RotationalSpeed), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (RotationalSpeed)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="RotationalSpeed"/> to another <see cref="RotationalSpeed"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="RotationalSpeed"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RotationalSpeedUnit unit, [NotNullWhen(true)] out RotationalSpeed? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            RotationalSpeed? convertedOrNull = (Unit, unit) switch
-            {
-                // RotationalSpeedUnit -> BaseUnit
-                (RotationalSpeedUnit.CentiradianPerSecond, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed((_value) * 1e-2d, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.DeciradianPerSecond, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed((_value) * 1e-1d, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.DegreePerMinute, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed((Math.PI / (180 * 60)) * _value, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.DegreePerSecond, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed((Math.PI / 180) * _value, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.MicrodegreePerSecond, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed(((Math.PI / 180) * _value) * 1e-6d, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.MicroradianPerSecond, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed((_value) * 1e-6d, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.MillidegreePerSecond, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed(((Math.PI / 180) * _value) * 1e-3d, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.MilliradianPerSecond, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed((_value) * 1e-3d, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.NanodegreePerSecond, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed(((Math.PI / 180) * _value) * 1e-9d, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.NanoradianPerSecond, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed((_value) * 1e-9d, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.RevolutionPerMinute, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed((_value * 2 * Math.PI) / 60, RotationalSpeedUnit.RadianPerSecond),
-                (RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeedUnit.RadianPerSecond) => new RotationalSpeed(_value * 2 * Math.PI, RotationalSpeedUnit.RadianPerSecond),
-
-                // BaseUnit -> RotationalSpeedUnit
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.CentiradianPerSecond) => new RotationalSpeed((_value) / 1e-2d, RotationalSpeedUnit.CentiradianPerSecond),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.DeciradianPerSecond) => new RotationalSpeed((_value) / 1e-1d, RotationalSpeedUnit.DeciradianPerSecond),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.DegreePerMinute) => new RotationalSpeed((180 * 60 / Math.PI) * _value, RotationalSpeedUnit.DegreePerMinute),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.DegreePerSecond) => new RotationalSpeed((180 / Math.PI) * _value, RotationalSpeedUnit.DegreePerSecond),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.MicrodegreePerSecond) => new RotationalSpeed(((180 / Math.PI) * _value) / 1e-6d, RotationalSpeedUnit.MicrodegreePerSecond),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.MicroradianPerSecond) => new RotationalSpeed((_value) / 1e-6d, RotationalSpeedUnit.MicroradianPerSecond),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.MillidegreePerSecond) => new RotationalSpeed(((180 / Math.PI) * _value) / 1e-3d, RotationalSpeedUnit.MillidegreePerSecond),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.MilliradianPerSecond) => new RotationalSpeed((_value) / 1e-3d, RotationalSpeedUnit.MilliradianPerSecond),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.NanodegreePerSecond) => new RotationalSpeed(((180 / Math.PI) * _value) / 1e-9d, RotationalSpeedUnit.NanodegreePerSecond),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.NanoradianPerSecond) => new RotationalSpeed((_value) / 1e-9d, RotationalSpeedUnit.NanoradianPerSecond),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.RevolutionPerMinute) => new RotationalSpeed((_value / (2 * Math.PI)) * 60, RotationalSpeedUnit.RevolutionPerMinute),
-                (RotationalSpeedUnit.RadianPerSecond, RotationalSpeedUnit.RevolutionPerSecond) => new RotationalSpeed(_value / (2 * Math.PI), RotationalSpeedUnit.RevolutionPerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RotationalSpeedUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalSpeedUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RotationalSpeedUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalSpeedUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RotationalSpeedUnit> IQuantity<RotationalSpeedUnit>.ToUnit(RotationalSpeedUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -959,11 +818,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
index f2994ea8fd..3d1253d943 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Stiffness#Rotational_stiffness
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct RotationalStiffness :
-        IArithmeticQuantity<RotationalStiffness, RotationalStiffnessUnit>,
+        ILinearQuantity<RotationalStiffness, RotationalStiffnessUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<RotationalStiffness, RotationalStiffness, double>,
+        IDivisionOperators<RotationalStiffness, RotationalStiffness, QuantityValue>,
         IDivisionOperators<RotationalStiffness, RotationalStiffnessPerLength, Length>,
         IDivisionOperators<RotationalStiffness, Length, RotationalStiffnessPerLength>,
         IMultiplyOperators<RotationalStiffness, Angle, Torque>,
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static RotationalStiffnessInfo CreateDefault(Func<IEnumerable<UnitDefinit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="RotationalStiffness"/> is [T^-2][L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="RotationalStiffness"/> is T^-2L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
 
@@ -120,48 +119,112 @@ public static RotationalStiffnessInfo CreateDefault(Func<IEnumerable<UnitDefinit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{RotationalStiffnessUnit}"/> representing the default unit mappings for RotationalStiffness.</returns>
             public static IEnumerable<UnitDefinition<RotationalStiffnessUnit>> GetDefaultMappings()
             {
-                yield return new (RotationalStiffnessUnit.CentinewtonMeterPerDegree, "CentinewtonMeterPerDegree", "CentinewtonMetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.CentinewtonMillimeterPerDegree, "CentinewtonMillimeterPerDegree", "CentinewtonMillimetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.CentinewtonMillimeterPerRadian, "CentinewtonMillimeterPerRadian", "CentinewtonMillimetersPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.DecanewtonMeterPerDegree, "DecanewtonMeterPerDegree", "DecanewtonMetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.DecanewtonMillimeterPerDegree, "DecanewtonMillimeterPerDegree", "DecanewtonMillimetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.DecanewtonMillimeterPerRadian, "DecanewtonMillimeterPerRadian", "DecanewtonMillimetersPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.DecinewtonMeterPerDegree, "DecinewtonMeterPerDegree", "DecinewtonMetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.DecinewtonMillimeterPerDegree, "DecinewtonMillimeterPerDegree", "DecinewtonMillimetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.DecinewtonMillimeterPerRadian, "DecinewtonMillimeterPerRadian", "DecinewtonMillimetersPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.KilonewtonMeterPerDegree, "KilonewtonMeterPerDegree", "KilonewtonMetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.KilonewtonMeterPerRadian, "KilonewtonMeterPerRadian", "KilonewtonMetersPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.KilonewtonMillimeterPerDegree, "KilonewtonMillimeterPerDegree", "KilonewtonMillimetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.KilonewtonMillimeterPerRadian, "KilonewtonMillimeterPerRadian", "KilonewtonMillimetersPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.KilopoundForceFootPerDegrees, "KilopoundForceFootPerDegrees", "KilopoundForceFeetPerDegrees", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.KilopoundForceFootPerRadian, "KilopoundForceFootPerRadian", "KilopoundForceFeetPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.MeganewtonMeterPerDegree, "MeganewtonMeterPerDegree", "MeganewtonMetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.MeganewtonMeterPerRadian, "MeganewtonMeterPerRadian", "MeganewtonMetersPerRadian", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (RotationalStiffnessUnit.MeganewtonMillimeterPerDegree, "MeganewtonMillimeterPerDegree", "MeganewtonMillimetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.MeganewtonMillimeterPerRadian, "MeganewtonMillimeterPerRadian", "MeganewtonMillimetersPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.MicronewtonMeterPerDegree, "MicronewtonMeterPerDegree", "MicronewtonMetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.MicronewtonMillimeterPerDegree, "MicronewtonMillimeterPerDegree", "MicronewtonMillimetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.MicronewtonMillimeterPerRadian, "MicronewtonMillimeterPerRadian", "MicronewtonMillimetersPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.MillinewtonMeterPerDegree, "MillinewtonMeterPerDegree", "MillinewtonMetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.MillinewtonMillimeterPerDegree, "MillinewtonMillimeterPerDegree", "MillinewtonMillimetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.MillinewtonMillimeterPerRadian, "MillinewtonMillimeterPerRadian", "MillinewtonMillimetersPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.NanonewtonMeterPerDegree, "NanonewtonMeterPerDegree", "NanonewtonMetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.NanonewtonMillimeterPerDegree, "NanonewtonMillimeterPerDegree", "NanonewtonMillimetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.NanonewtonMillimeterPerRadian, "NanonewtonMillimeterPerRadian", "NanonewtonMillimetersPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.NewtonMeterPerDegree, "NewtonMeterPerDegree", "NewtonMetersPerDegree", BaseUnits.Undefined);
+                yield return new (RotationalStiffnessUnit.CentinewtonMeterPerDegree, "CentinewtonMeterPerDegree", "CentinewtonMetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 1800000000000000)
+                );
+                yield return new (RotationalStiffnessUnit.CentinewtonMillimeterPerDegree, "CentinewtonMillimeterPerDegree", "CentinewtonMillimetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 1800000000000)
+                );
+                yield return new (RotationalStiffnessUnit.CentinewtonMillimeterPerRadian, "CentinewtonMillimeterPerRadian", "CentinewtonMillimetersPerRadian", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (RotationalStiffnessUnit.DecanewtonMeterPerDegree, "DecanewtonMeterPerDegree", "DecanewtonMetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 1800000000000000000)
+                );
+                yield return new (RotationalStiffnessUnit.DecanewtonMillimeterPerDegree, "DecanewtonMillimeterPerDegree", "DecanewtonMillimetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 1800000000000000)
+                );
+                yield return new (RotationalStiffnessUnit.DecanewtonMillimeterPerRadian, "DecanewtonMillimeterPerRadian", "DecanewtonMillimetersPerRadian", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (RotationalStiffnessUnit.DecinewtonMeterPerDegree, "DecinewtonMeterPerDegree", "DecinewtonMetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 18000000000000000)
+                );
+                yield return new (RotationalStiffnessUnit.DecinewtonMillimeterPerDegree, "DecinewtonMillimeterPerDegree", "DecinewtonMillimetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 18000000000000)
+                );
+                yield return new (RotationalStiffnessUnit.DecinewtonMillimeterPerRadian, "DecinewtonMillimeterPerRadian", "DecinewtonMillimetersPerRadian", BaseUnits.Undefined,
+                     10000
+                );
+                yield return new (RotationalStiffnessUnit.KilonewtonMeterPerDegree, "KilonewtonMeterPerDegree", "KilonewtonMetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, new BigInteger(18) * QuantityValue.PowerOfTen(19))
+                );
+                yield return new (RotationalStiffnessUnit.KilonewtonMeterPerRadian, "KilonewtonMeterPerRadian", "KilonewtonMetersPerRadian", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (RotationalStiffnessUnit.KilonewtonMillimeterPerDegree, "KilonewtonMillimeterPerDegree", "KilonewtonMillimetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 180000000000000000)
+                );
+                yield return new (RotationalStiffnessUnit.KilonewtonMillimeterPerRadian, "KilonewtonMillimeterPerRadian", "KilonewtonMillimetersPerRadian", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (RotationalStiffnessUnit.KilopoundForceFootPerDegrees, "KilopoundForceFootPerDegrees", "KilopoundForceFeetPerDegrees", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, QuantityValue.PowerOfTen(3) * new BigInteger(244047230699652072))
+                );
+                yield return new (RotationalStiffnessUnit.KilopoundForceFootPerRadian, "KilopoundForceFootPerRadian", "KilopoundForceFeetPerRadian", BaseUnits.Undefined,
+                     new QuantityValue(2500000000000, 3389544870828501)
+                );
+                yield return new (RotationalStiffnessUnit.MeganewtonMeterPerDegree, "MeganewtonMeterPerDegree", "MeganewtonMetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, new BigInteger(18) * QuantityValue.PowerOfTen(22))
+                );
+                yield return new (RotationalStiffnessUnit.MeganewtonMeterPerRadian, "MeganewtonMeterPerRadian", "MeganewtonMetersPerRadian", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (RotationalStiffnessUnit.MeganewtonMillimeterPerDegree, "MeganewtonMillimeterPerDegree", "MeganewtonMillimetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, new BigInteger(18) * QuantityValue.PowerOfTen(19))
+                );
+                yield return new (RotationalStiffnessUnit.MeganewtonMillimeterPerRadian, "MeganewtonMillimeterPerRadian", "MeganewtonMillimetersPerRadian", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (RotationalStiffnessUnit.MicronewtonMeterPerDegree, "MicronewtonMeterPerDegree", "MicronewtonMetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 180000000000)
+                );
+                yield return new (RotationalStiffnessUnit.MicronewtonMillimeterPerDegree, "MicronewtonMillimeterPerDegree", "MicronewtonMillimetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 180000000)
+                );
+                yield return new (RotationalStiffnessUnit.MicronewtonMillimeterPerRadian, "MicronewtonMillimeterPerRadian", "MicronewtonMillimetersPerRadian", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (RotationalStiffnessUnit.MillinewtonMeterPerDegree, "MillinewtonMeterPerDegree", "MillinewtonMetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 180000000000000)
+                );
+                yield return new (RotationalStiffnessUnit.MillinewtonMillimeterPerDegree, "MillinewtonMillimeterPerDegree", "MillinewtonMillimetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 180000000000)
+                );
+                yield return new (RotationalStiffnessUnit.MillinewtonMillimeterPerRadian, "MillinewtonMillimeterPerRadian", "MillinewtonMillimetersPerRadian", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (RotationalStiffnessUnit.NanonewtonMeterPerDegree, "NanonewtonMeterPerDegree", "NanonewtonMetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 180000000)
+                );
+                yield return new (RotationalStiffnessUnit.NanonewtonMillimeterPerDegree, "NanonewtonMillimeterPerDegree", "NanonewtonMillimetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 180000)
+                );
+                yield return new (RotationalStiffnessUnit.NanonewtonMillimeterPerRadian, "NanonewtonMillimeterPerRadian", "NanonewtonMillimetersPerRadian", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (RotationalStiffnessUnit.NewtonMeterPerDegree, "NewtonMeterPerDegree", "NewtonMetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 180000000000000000)
+                );
                 yield return new (RotationalStiffnessUnit.NewtonMeterPerRadian, "NewtonMeterPerRadian", "NewtonMetersPerRadian", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (RotationalStiffnessUnit.NewtonMillimeterPerDegree, "NewtonMillimeterPerDegree", "NewtonMillimetersPerDegree", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.NewtonMillimeterPerRadian, "NewtonMillimeterPerRadian", "NewtonMillimetersPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.PoundForceFeetPerRadian, "PoundForceFeetPerRadian", "PoundForceFeetPerRadian", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessUnit.PoundForceFootPerDegrees, "PoundForceFootPerDegrees", "PoundForceFeetPerDegrees", BaseUnits.Undefined);
+                yield return new (RotationalStiffnessUnit.NewtonMillimeterPerDegree, "NewtonMillimeterPerDegree", "NewtonMillimetersPerDegree", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 180000000000000)
+                );
+                yield return new (RotationalStiffnessUnit.NewtonMillimeterPerRadian, "NewtonMillimeterPerRadian", "NewtonMillimetersPerRadian", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (RotationalStiffnessUnit.PoundForceFeetPerRadian, "PoundForceFeetPerRadian", "PoundForceFeetPerRadian", BaseUnits.Undefined,
+                     new QuantityValue(2500000000000000, 3389544870828501)
+                );
+                yield return new (RotationalStiffnessUnit.PoundForceFootPerDegrees, "PoundForceFootPerDegrees", "PoundForceFeetPerDegrees", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 244047230699652072)
+                );
             }
         }
 
         static RotationalStiffness()
         {
-            Info = RotationalStiffnessInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RotationalStiffnessInfo.CreateDefault);
         }
 
         /// <summary>
@@ -169,7 +232,7 @@ static RotationalStiffness()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RotationalStiffness(double value, RotationalStiffnessUnit unit)
+        public RotationalStiffness(QuantityValue value, RotationalStiffnessUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -183,7 +246,7 @@ public RotationalStiffness(double value, RotationalStiffnessUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RotationalStiffness(double value, UnitSystem unitSystem)
+        public RotationalStiffness(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -194,7 +257,8 @@ public RotationalStiffness(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="RotationalStiffness" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<RotationalStiffness, RotationalStiffnessUnit> Info { get; }
@@ -223,10 +287,8 @@ public RotationalStiffness(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RotationalStiffnessUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -260,259 +322,179 @@ public RotationalStiffness(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.CentinewtonMeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.CentinewtonMeterPerDegree"/>
         /// </summary>
-        public double CentinewtonMetersPerDegree => As(RotationalStiffnessUnit.CentinewtonMeterPerDegree);
+        public QuantityValue CentinewtonMetersPerDegree => this.As(RotationalStiffnessUnit.CentinewtonMeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerDegree"/>
         /// </summary>
-        public double CentinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
+        public QuantityValue CentinewtonMillimetersPerDegree => this.As(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerRadian"/>
         /// </summary>
-        public double CentinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
+        public QuantityValue CentinewtonMillimetersPerRadian => this.As(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecanewtonMeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecanewtonMeterPerDegree"/>
         /// </summary>
-        public double DecanewtonMetersPerDegree => As(RotationalStiffnessUnit.DecanewtonMeterPerDegree);
+        public QuantityValue DecanewtonMetersPerDegree => this.As(RotationalStiffnessUnit.DecanewtonMeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerDegree"/>
         /// </summary>
-        public double DecanewtonMillimetersPerDegree => As(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
+        public QuantityValue DecanewtonMillimetersPerDegree => this.As(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerRadian"/>
         /// </summary>
-        public double DecanewtonMillimetersPerRadian => As(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
+        public QuantityValue DecanewtonMillimetersPerRadian => this.As(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecinewtonMeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecinewtonMeterPerDegree"/>
         /// </summary>
-        public double DecinewtonMetersPerDegree => As(RotationalStiffnessUnit.DecinewtonMeterPerDegree);
+        public QuantityValue DecinewtonMetersPerDegree => this.As(RotationalStiffnessUnit.DecinewtonMeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerDegree"/>
         /// </summary>
-        public double DecinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
+        public QuantityValue DecinewtonMillimetersPerDegree => this.As(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerRadian"/>
         /// </summary>
-        public double DecinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
+        public QuantityValue DecinewtonMillimetersPerRadian => this.As(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMeterPerDegree"/>
         /// </summary>
-        public double KilonewtonMetersPerDegree => As(RotationalStiffnessUnit.KilonewtonMeterPerDegree);
+        public QuantityValue KilonewtonMetersPerDegree => this.As(RotationalStiffnessUnit.KilonewtonMeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMeterPerRadian"/>
         /// </summary>
-        public double KilonewtonMetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMeterPerRadian);
+        public QuantityValue KilonewtonMetersPerRadian => this.As(RotationalStiffnessUnit.KilonewtonMeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerDegree"/>
         /// </summary>
-        public double KilonewtonMillimetersPerDegree => As(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
+        public QuantityValue KilonewtonMillimetersPerDegree => this.As(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerRadian"/>
         /// </summary>
-        public double KilonewtonMillimetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
+        public QuantityValue KilonewtonMillimetersPerRadian => this.As(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilopoundForceFootPerDegrees"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilopoundForceFootPerDegrees"/>
         /// </summary>
-        public double KilopoundForceFeetPerDegrees => As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+        public QuantityValue KilopoundForceFeetPerDegrees => this.As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilopoundForceFootPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.KilopoundForceFootPerRadian"/>
         /// </summary>
-        public double KilopoundForceFeetPerRadian => As(RotationalStiffnessUnit.KilopoundForceFootPerRadian);
+        public QuantityValue KilopoundForceFeetPerRadian => this.As(RotationalStiffnessUnit.KilopoundForceFootPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMeterPerDegree"/>
         /// </summary>
-        public double MeganewtonMetersPerDegree => As(RotationalStiffnessUnit.MeganewtonMeterPerDegree);
+        public QuantityValue MeganewtonMetersPerDegree => this.As(RotationalStiffnessUnit.MeganewtonMeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMeterPerRadian"/>
         /// </summary>
-        public double MeganewtonMetersPerRadian => As(RotationalStiffnessUnit.MeganewtonMeterPerRadian);
+        public QuantityValue MeganewtonMetersPerRadian => this.As(RotationalStiffnessUnit.MeganewtonMeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerDegree"/>
         /// </summary>
-        public double MeganewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
+        public QuantityValue MeganewtonMillimetersPerDegree => this.As(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerRadian"/>
         /// </summary>
-        public double MeganewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
+        public QuantityValue MeganewtonMillimetersPerRadian => this.As(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MicronewtonMeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MicronewtonMeterPerDegree"/>
         /// </summary>
-        public double MicronewtonMetersPerDegree => As(RotationalStiffnessUnit.MicronewtonMeterPerDegree);
+        public QuantityValue MicronewtonMetersPerDegree => this.As(RotationalStiffnessUnit.MicronewtonMeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerDegree"/>
         /// </summary>
-        public double MicronewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
+        public QuantityValue MicronewtonMillimetersPerDegree => this.As(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerRadian"/>
         /// </summary>
-        public double MicronewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
+        public QuantityValue MicronewtonMillimetersPerRadian => this.As(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MillinewtonMeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MillinewtonMeterPerDegree"/>
         /// </summary>
-        public double MillinewtonMetersPerDegree => As(RotationalStiffnessUnit.MillinewtonMeterPerDegree);
+        public QuantityValue MillinewtonMetersPerDegree => this.As(RotationalStiffnessUnit.MillinewtonMeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerDegree"/>
         /// </summary>
-        public double MillinewtonMillimetersPerDegree => As(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
+        public QuantityValue MillinewtonMillimetersPerDegree => this.As(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerRadian"/>
         /// </summary>
-        public double MillinewtonMillimetersPerRadian => As(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
+        public QuantityValue MillinewtonMillimetersPerRadian => this.As(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NanonewtonMeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NanonewtonMeterPerDegree"/>
         /// </summary>
-        public double NanonewtonMetersPerDegree => As(RotationalStiffnessUnit.NanonewtonMeterPerDegree);
+        public QuantityValue NanonewtonMetersPerDegree => this.As(RotationalStiffnessUnit.NanonewtonMeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerDegree"/>
         /// </summary>
-        public double NanonewtonMillimetersPerDegree => As(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
+        public QuantityValue NanonewtonMillimetersPerDegree => this.As(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerRadian"/>
         /// </summary>
-        public double NanonewtonMillimetersPerRadian => As(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
+        public QuantityValue NanonewtonMillimetersPerRadian => this.As(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMeterPerDegree"/>
         /// </summary>
-        public double NewtonMetersPerDegree => As(RotationalStiffnessUnit.NewtonMeterPerDegree);
+        public QuantityValue NewtonMetersPerDegree => this.As(RotationalStiffnessUnit.NewtonMeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMeterPerRadian"/>
         /// </summary>
-        public double NewtonMetersPerRadian => As(RotationalStiffnessUnit.NewtonMeterPerRadian);
+        public QuantityValue NewtonMetersPerRadian => this.As(RotationalStiffnessUnit.NewtonMeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMillimeterPerDegree"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMillimeterPerDegree"/>
         /// </summary>
-        public double NewtonMillimetersPerDegree => As(RotationalStiffnessUnit.NewtonMillimeterPerDegree);
+        public QuantityValue NewtonMillimetersPerDegree => this.As(RotationalStiffnessUnit.NewtonMillimeterPerDegree);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMillimeterPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.NewtonMillimeterPerRadian"/>
         /// </summary>
-        public double NewtonMillimetersPerRadian => As(RotationalStiffnessUnit.NewtonMillimeterPerRadian);
+        public QuantityValue NewtonMillimetersPerRadian => this.As(RotationalStiffnessUnit.NewtonMillimeterPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.PoundForceFeetPerRadian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.PoundForceFeetPerRadian"/>
         /// </summary>
-        public double PoundForceFeetPerRadian => As(RotationalStiffnessUnit.PoundForceFeetPerRadian);
+        public QuantityValue PoundForceFeetPerRadian => this.As(RotationalStiffnessUnit.PoundForceFeetPerRadian);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.PoundForceFootPerDegrees"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessUnit.PoundForceFootPerDegrees"/>
         /// </summary>
-        public double PoundForceFeetPerDegrees => As(RotationalStiffnessUnit.PoundForceFootPerDegrees);
+        public QuantityValue PoundForceFeetPerDegrees => this.As(RotationalStiffnessUnit.PoundForceFootPerDegrees);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RotationalStiffnessUnit -> BaseUnit
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.CentinewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecanewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecinewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilonewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilopoundForceFootPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MeganewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MicronewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MillinewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NanonewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.PoundForceFeetPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.PoundForceFootPerDegrees, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RotationalStiffnessUnit
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.CentinewtonMeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.CentinewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.CentinewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.CentinewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecanewtonMeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.DecanewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.DecanewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.DecanewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecinewtonMeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.DecinewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.DecinewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.DecinewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilonewtonMeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilonewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.KilonewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.KilonewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilopoundForceFootPerDegrees, quantity => quantity.ToUnit(RotationalStiffnessUnit.KilopoundForceFootPerDegrees));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilopoundForceFootPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.KilopoundForceFootPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MeganewtonMeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MeganewtonMeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.MeganewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.MeganewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MicronewtonMeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.MicronewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.MicronewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.MicronewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MillinewtonMeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.MillinewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.MillinewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.MillinewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NanonewtonMeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.NanonewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.NanonewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NanonewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMillimeterPerDegree, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMillimeterPerDegree));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMillimeterPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.NewtonMillimeterPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.PoundForceFeetPerRadian, quantity => quantity.ToUnit(RotationalStiffnessUnit.PoundForceFeetPerRadian));
-            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.PoundForceFootPerDegrees, quantity => quantity.ToUnit(RotationalStiffnessUnit.PoundForceFootPerDegrees));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -541,7 +523,7 @@ public static string GetAbbreviation(RotationalStiffnessUnit unit, IFormatProvid
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromCentinewtonMetersPerDegree(double value)
+        public static RotationalStiffness FromCentinewtonMetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMeterPerDegree);
         }
@@ -549,7 +531,7 @@ public static RotationalStiffness FromCentinewtonMetersPerDegree(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromCentinewtonMillimetersPerDegree(double value)
+        public static RotationalStiffness FromCentinewtonMillimetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
         }
@@ -557,7 +539,7 @@ public static RotationalStiffness FromCentinewtonMillimetersPerDegree(double val
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromCentinewtonMillimetersPerRadian(double value)
+        public static RotationalStiffness FromCentinewtonMillimetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
         }
@@ -565,7 +547,7 @@ public static RotationalStiffness FromCentinewtonMillimetersPerRadian(double val
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromDecanewtonMetersPerDegree(double value)
+        public static RotationalStiffness FromDecanewtonMetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMeterPerDegree);
         }
@@ -573,7 +555,7 @@ public static RotationalStiffness FromDecanewtonMetersPerDegree(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromDecanewtonMillimetersPerDegree(double value)
+        public static RotationalStiffness FromDecanewtonMillimetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
         }
@@ -581,7 +563,7 @@ public static RotationalStiffness FromDecanewtonMillimetersPerDegree(double valu
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromDecanewtonMillimetersPerRadian(double value)
+        public static RotationalStiffness FromDecanewtonMillimetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
         }
@@ -589,7 +571,7 @@ public static RotationalStiffness FromDecanewtonMillimetersPerRadian(double valu
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromDecinewtonMetersPerDegree(double value)
+        public static RotationalStiffness FromDecinewtonMetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMeterPerDegree);
         }
@@ -597,7 +579,7 @@ public static RotationalStiffness FromDecinewtonMetersPerDegree(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromDecinewtonMillimetersPerDegree(double value)
+        public static RotationalStiffness FromDecinewtonMillimetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
         }
@@ -605,7 +587,7 @@ public static RotationalStiffness FromDecinewtonMillimetersPerDegree(double valu
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromDecinewtonMillimetersPerRadian(double value)
+        public static RotationalStiffness FromDecinewtonMillimetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
         }
@@ -613,7 +595,7 @@ public static RotationalStiffness FromDecinewtonMillimetersPerRadian(double valu
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromKilonewtonMetersPerDegree(double value)
+        public static RotationalStiffness FromKilonewtonMetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerDegree);
         }
@@ -621,7 +603,7 @@ public static RotationalStiffness FromKilonewtonMetersPerDegree(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromKilonewtonMetersPerRadian(double value)
+        public static RotationalStiffness FromKilonewtonMetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
         }
@@ -629,7 +611,7 @@ public static RotationalStiffness FromKilonewtonMetersPerRadian(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromKilonewtonMillimetersPerDegree(double value)
+        public static RotationalStiffness FromKilonewtonMillimetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
         }
@@ -637,7 +619,7 @@ public static RotationalStiffness FromKilonewtonMillimetersPerDegree(double valu
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromKilonewtonMillimetersPerRadian(double value)
+        public static RotationalStiffness FromKilonewtonMillimetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
         }
@@ -645,7 +627,7 @@ public static RotationalStiffness FromKilonewtonMillimetersPerRadian(double valu
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilopoundForceFootPerDegrees"/>.
         /// </summary>
-        public static RotationalStiffness FromKilopoundForceFeetPerDegrees(double value)
+        public static RotationalStiffness FromKilopoundForceFeetPerDegrees(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
         }
@@ -653,7 +635,7 @@ public static RotationalStiffness FromKilopoundForceFeetPerDegrees(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilopoundForceFootPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromKilopoundForceFeetPerRadian(double value)
+        public static RotationalStiffness FromKilopoundForceFeetPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerRadian);
         }
@@ -661,7 +643,7 @@ public static RotationalStiffness FromKilopoundForceFeetPerRadian(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromMeganewtonMetersPerDegree(double value)
+        public static RotationalStiffness FromMeganewtonMetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerDegree);
         }
@@ -669,7 +651,7 @@ public static RotationalStiffness FromMeganewtonMetersPerDegree(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromMeganewtonMetersPerRadian(double value)
+        public static RotationalStiffness FromMeganewtonMetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
         }
@@ -677,7 +659,7 @@ public static RotationalStiffness FromMeganewtonMetersPerRadian(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromMeganewtonMillimetersPerDegree(double value)
+        public static RotationalStiffness FromMeganewtonMillimetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
         }
@@ -685,7 +667,7 @@ public static RotationalStiffness FromMeganewtonMillimetersPerDegree(double valu
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromMeganewtonMillimetersPerRadian(double value)
+        public static RotationalStiffness FromMeganewtonMillimetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
         }
@@ -693,7 +675,7 @@ public static RotationalStiffness FromMeganewtonMillimetersPerRadian(double valu
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromMicronewtonMetersPerDegree(double value)
+        public static RotationalStiffness FromMicronewtonMetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMeterPerDegree);
         }
@@ -701,7 +683,7 @@ public static RotationalStiffness FromMicronewtonMetersPerDegree(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromMicronewtonMillimetersPerDegree(double value)
+        public static RotationalStiffness FromMicronewtonMillimetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
         }
@@ -709,7 +691,7 @@ public static RotationalStiffness FromMicronewtonMillimetersPerDegree(double val
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromMicronewtonMillimetersPerRadian(double value)
+        public static RotationalStiffness FromMicronewtonMillimetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
         }
@@ -717,7 +699,7 @@ public static RotationalStiffness FromMicronewtonMillimetersPerRadian(double val
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromMillinewtonMetersPerDegree(double value)
+        public static RotationalStiffness FromMillinewtonMetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMeterPerDegree);
         }
@@ -725,7 +707,7 @@ public static RotationalStiffness FromMillinewtonMetersPerDegree(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromMillinewtonMillimetersPerDegree(double value)
+        public static RotationalStiffness FromMillinewtonMillimetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
         }
@@ -733,7 +715,7 @@ public static RotationalStiffness FromMillinewtonMillimetersPerDegree(double val
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromMillinewtonMillimetersPerRadian(double value)
+        public static RotationalStiffness FromMillinewtonMillimetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
         }
@@ -741,7 +723,7 @@ public static RotationalStiffness FromMillinewtonMillimetersPerRadian(double val
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromNanonewtonMetersPerDegree(double value)
+        public static RotationalStiffness FromNanonewtonMetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMeterPerDegree);
         }
@@ -749,7 +731,7 @@ public static RotationalStiffness FromNanonewtonMetersPerDegree(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromNanonewtonMillimetersPerDegree(double value)
+        public static RotationalStiffness FromNanonewtonMillimetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
         }
@@ -757,7 +739,7 @@ public static RotationalStiffness FromNanonewtonMillimetersPerDegree(double valu
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromNanonewtonMillimetersPerRadian(double value)
+        public static RotationalStiffness FromNanonewtonMillimetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
         }
@@ -765,7 +747,7 @@ public static RotationalStiffness FromNanonewtonMillimetersPerRadian(double valu
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromNewtonMetersPerDegree(double value)
+        public static RotationalStiffness FromNewtonMetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerDegree);
         }
@@ -773,7 +755,7 @@ public static RotationalStiffness FromNewtonMetersPerDegree(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromNewtonMetersPerRadian(double value)
+        public static RotationalStiffness FromNewtonMetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian);
         }
@@ -781,7 +763,7 @@ public static RotationalStiffness FromNewtonMetersPerRadian(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMillimeterPerDegree"/>.
         /// </summary>
-        public static RotationalStiffness FromNewtonMillimetersPerDegree(double value)
+        public static RotationalStiffness FromNewtonMillimetersPerDegree(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerDegree);
         }
@@ -789,7 +771,7 @@ public static RotationalStiffness FromNewtonMillimetersPerDegree(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMillimeterPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromNewtonMillimetersPerRadian(double value)
+        public static RotationalStiffness FromNewtonMillimetersPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerRadian);
         }
@@ -797,7 +779,7 @@ public static RotationalStiffness FromNewtonMillimetersPerRadian(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.PoundForceFeetPerRadian"/>.
         /// </summary>
-        public static RotationalStiffness FromPoundForceFeetPerRadian(double value)
+        public static RotationalStiffness FromPoundForceFeetPerRadian(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFeetPerRadian);
         }
@@ -805,7 +787,7 @@ public static RotationalStiffness FromPoundForceFeetPerRadian(double value)
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.PoundForceFootPerDegrees"/>.
         /// </summary>
-        public static RotationalStiffness FromPoundForceFeetPerDegrees(double value)
+        public static RotationalStiffness FromPoundForceFeetPerDegrees(QuantityValue value)
         {
             return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees);
         }
@@ -816,7 +798,7 @@ public static RotationalStiffness FromPoundForceFeetPerDegrees(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RotationalStiffness unit value.</returns>
-        public static RotationalStiffness From(double value, RotationalStiffnessUnit fromUnit)
+        public static RotationalStiffness From(QuantityValue value, RotationalStiffnessUnit fromUnit)
         {
             return new RotationalStiffness(value, fromUnit);
         }
@@ -877,10 +859,7 @@ public static RotationalStiffness Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static RotationalStiffness Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<RotationalStiffness, RotationalStiffnessUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<RotationalStiffness, RotationalStiffnessUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -908,11 +887,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out RotationalStiffn
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out RotationalStiffness result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<RotationalStiffness, RotationalStiffnessUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<RotationalStiffness, RotationalStiffnessUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -933,7 +908,7 @@ public static RotationalStiffnessUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -944,7 +919,7 @@ public static RotationalStiffnessUnit ParseUnit(string str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RotationalStiffnessUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RotationalStiffnessUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalStiffnessUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -959,7 +934,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalSt
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RotationalStiffnessUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -978,35 +953,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="RotationalStiffness"/> from adding two <see cref="RotationalStiffness"/>.</summary>
         public static RotationalStiffness operator +(RotationalStiffness left, RotationalStiffness right)
         {
-            return new RotationalStiffness(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new RotationalStiffness(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalStiffness"/> from subtracting two <see cref="RotationalStiffness"/>.</summary>
         public static RotationalStiffness operator -(RotationalStiffness left, RotationalStiffness right)
         {
-            return new RotationalStiffness(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new RotationalStiffness(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalStiffness"/> from multiplying value and <see cref="RotationalStiffness"/>.</summary>
-        public static RotationalStiffness operator *(double left, RotationalStiffness right)
+        public static RotationalStiffness operator *(QuantityValue left, RotationalStiffness right)
         {
             return new RotationalStiffness(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="RotationalStiffness"/> from multiplying value and <see cref="RotationalStiffness"/>.</summary>
-        public static RotationalStiffness operator *(RotationalStiffness left, double right)
+        public static RotationalStiffness operator *(RotationalStiffness left, QuantityValue right)
         {
             return new RotationalStiffness(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalStiffness"/> from dividing <see cref="RotationalStiffness"/> by value.</summary>
-        public static RotationalStiffness operator /(RotationalStiffness left, double right)
+        public static RotationalStiffness operator /(RotationalStiffness left, QuantityValue right)
         {
             return new RotationalStiffness(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="RotationalStiffness"/> by <see cref="RotationalStiffness"/>.</summary>
-        public static double operator /(RotationalStiffness left, RotationalStiffness right)
+        public static QuantityValue operator /(RotationalStiffness left, RotationalStiffness right)
         {
             return left.NewtonMetersPerRadian / right.NewtonMetersPerRadian;
         }
@@ -1040,97 +1015,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(RotationalStiffness left, RotationalStiffness right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(RotationalStiffness left, RotationalStiffness right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(RotationalStiffness left, RotationalStiffness right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(RotationalStiffness left, RotationalStiffness right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="RotationalStiffness"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RotationalStiffness other, RotationalStiffness tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RotationalStiffness"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(RotationalStiffness)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(RotationalStiffness left, RotationalStiffness right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="RotationalStiffness"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RotationalStiffness other, RotationalStiffness tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RotationalStiffness"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(RotationalStiffness,RotationalStiffness)"/>.
+        ///     See that operator (and <see cref="Equals(RotationalStiffness)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(RotationalStiffness left, RotationalStiffness right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RotationalStiffness"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RotationalStiffness other, RotationalStiffness tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="RotationalStiffness"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="RotationalStiffness"/>.
+        ///     When <paramref name="obj"/> is a <see cref="RotationalStiffness"/>, this method delegates to
+        ///     <see cref="Equals(RotationalStiffness)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is RotationalStiffness otherQuantity))
+            if (obj is not RotationalStiffness otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RotationalStiffness"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RotationalStiffness other, RotationalStiffness tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="RotationalStiffness"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(RotationalStiffness other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current RotationalStiffness.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(RotationalStiffness), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="RotationalStiffness"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(RotationalStiffness)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is RotationalStiffness otherQuantity)) throw new ArgumentException("Expected type RotationalStiffness.", nameof(obj));
+            if (obj is not RotationalStiffness otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<RotationalStiffness>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="RotationalStiffness"/> with another <see cref="RotationalStiffness"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="RotationalStiffness"/> with another <see cref="RotationalStiffness"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1142,195 +1131,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(RotationalStiffness other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RotationalStiffnessUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RotationalStiffnessUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this RotationalStiffness to another RotationalStiffness with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A RotationalStiffness with the specified unit.</returns>
-        public RotationalStiffness ToUnit(RotationalStiffnessUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="RotationalStiffness"/> to another <see cref="RotationalStiffness"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A RotationalStiffness with the specified unit.</returns>
-        public RotationalStiffness ToUnit(RotationalStiffnessUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(RotationalStiffness), Unit, typeof(RotationalStiffness), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (RotationalStiffness)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="RotationalStiffness"/> to another <see cref="RotationalStiffness"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="RotationalStiffness"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RotationalStiffnessUnit unit, [NotNullWhen(true)] out RotationalStiffness? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            RotationalStiffness? convertedOrNull = (Unit, unit) switch
-            {
-                // RotationalStiffnessUnit -> BaseUnit
-                (RotationalStiffnessUnit.CentinewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * (180 / Math.PI)) * 1e-2d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.CentinewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 180 / Math.PI * 0.001) * 1e-2d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.CentinewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 0.001) * 1e-2d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.DecanewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * (180 / Math.PI)) * 1e1d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.DecanewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 180 / Math.PI * 0.001) * 1e1d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.DecanewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 0.001) * 1e1d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.DecinewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * (180 / Math.PI)) * 1e-1d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.DecinewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 180 / Math.PI * 0.001) * 1e-1d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.DecinewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 0.001) * 1e-1d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.KilonewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * (180 / Math.PI)) * 1e3d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value) * 1e3d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.KilonewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 180 / Math.PI * 0.001) * 1e3d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.KilonewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 0.001) * 1e3d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.KilopoundForceFootPerDegrees, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness(_value * (4.4482216152605e3 * 0.3048 * 180 / Math.PI), RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.KilopoundForceFootPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness(_value * 4.4482216152605e3 * 0.3048, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.MeganewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * (180 / Math.PI)) * 1e6d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value) * 1e6d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.MeganewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 180 / Math.PI * 0.001) * 1e6d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.MeganewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 0.001) * 1e6d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.MicronewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * (180 / Math.PI)) * 1e-6d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.MicronewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 180 / Math.PI * 0.001) * 1e-6d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.MicronewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 0.001) * 1e-6d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.MillinewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * (180 / Math.PI)) * 1e-3d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.MillinewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 180 / Math.PI * 0.001) * 1e-3d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.MillinewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 0.001) * 1e-3d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.NanonewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * (180 / Math.PI)) * 1e-9d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.NanonewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 180 / Math.PI * 0.001) * 1e-9d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.NanonewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness((_value * 0.001) * 1e-9d, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness(_value * (180 / Math.PI), RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMillimeterPerDegree, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness(_value * 180 / Math.PI * 0.001, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMillimeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness(_value * 0.001, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.PoundForceFeetPerRadian, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness(_value * 4.4482216152605 * 0.3048, RotationalStiffnessUnit.NewtonMeterPerRadian),
-                (RotationalStiffnessUnit.PoundForceFootPerDegrees, RotationalStiffnessUnit.NewtonMeterPerRadian) => new RotationalStiffness(_value * (4.4482216152605 * 0.3048 * 180 / Math.PI), RotationalStiffnessUnit.NewtonMeterPerRadian),
-
-                // BaseUnit -> RotationalStiffnessUnit
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.CentinewtonMeterPerDegree) => new RotationalStiffness((_value / (180 / Math.PI)) / 1e-2d, RotationalStiffnessUnit.CentinewtonMeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree) => new RotationalStiffness((_value / 180 * Math.PI * 1000) / 1e-2d, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian) => new RotationalStiffness((_value * 1000) / 1e-2d, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecanewtonMeterPerDegree) => new RotationalStiffness((_value / (180 / Math.PI)) / 1e1d, RotationalStiffnessUnit.DecanewtonMeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree) => new RotationalStiffness((_value / 180 * Math.PI * 1000) / 1e1d, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian) => new RotationalStiffness((_value * 1000) / 1e1d, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecinewtonMeterPerDegree) => new RotationalStiffness((_value / (180 / Math.PI)) / 1e-1d, RotationalStiffnessUnit.DecinewtonMeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree) => new RotationalStiffness((_value / 180 * Math.PI * 1000) / 1e-1d, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian) => new RotationalStiffness((_value * 1000) / 1e-1d, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilonewtonMeterPerDegree) => new RotationalStiffness((_value / (180 / Math.PI)) / 1e3d, RotationalStiffnessUnit.KilonewtonMeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilonewtonMeterPerRadian) => new RotationalStiffness((_value) / 1e3d, RotationalStiffnessUnit.KilonewtonMeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree) => new RotationalStiffness((_value / 180 * Math.PI * 1000) / 1e3d, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian) => new RotationalStiffness((_value * 1000) / 1e3d, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilopoundForceFootPerDegrees) => new RotationalStiffness(_value / (4.4482216152605e3 * 0.3048 * 180 / Math.PI), RotationalStiffnessUnit.KilopoundForceFootPerDegrees),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.KilopoundForceFootPerRadian) => new RotationalStiffness(_value / (4.4482216152605e3 * 0.3048), RotationalStiffnessUnit.KilopoundForceFootPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MeganewtonMeterPerDegree) => new RotationalStiffness((_value / (180 / Math.PI)) / 1e6d, RotationalStiffnessUnit.MeganewtonMeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MeganewtonMeterPerRadian) => new RotationalStiffness((_value) / 1e6d, RotationalStiffnessUnit.MeganewtonMeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree) => new RotationalStiffness((_value / 180 * Math.PI * 1000) / 1e6d, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian) => new RotationalStiffness((_value * 1000) / 1e6d, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MicronewtonMeterPerDegree) => new RotationalStiffness((_value / (180 / Math.PI)) / 1e-6d, RotationalStiffnessUnit.MicronewtonMeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree) => new RotationalStiffness((_value / 180 * Math.PI * 1000) / 1e-6d, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian) => new RotationalStiffness((_value * 1000) / 1e-6d, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MillinewtonMeterPerDegree) => new RotationalStiffness((_value / (180 / Math.PI)) / 1e-3d, RotationalStiffnessUnit.MillinewtonMeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree) => new RotationalStiffness((_value / 180 * Math.PI * 1000) / 1e-3d, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian) => new RotationalStiffness((_value * 1000) / 1e-3d, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NanonewtonMeterPerDegree) => new RotationalStiffness((_value / (180 / Math.PI)) / 1e-9d, RotationalStiffnessUnit.NanonewtonMeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree) => new RotationalStiffness((_value / 180 * Math.PI * 1000) / 1e-9d, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian) => new RotationalStiffness((_value * 1000) / 1e-9d, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMeterPerDegree) => new RotationalStiffness(_value / (180 / Math.PI), RotationalStiffnessUnit.NewtonMeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMillimeterPerDegree) => new RotationalStiffness(_value / 180 * Math.PI * 1000, RotationalStiffnessUnit.NewtonMillimeterPerDegree),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.NewtonMillimeterPerRadian) => new RotationalStiffness(_value * 1000, RotationalStiffnessUnit.NewtonMillimeterPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.PoundForceFeetPerRadian) => new RotationalStiffness(_value / (4.4482216152605 * 0.3048), RotationalStiffnessUnit.PoundForceFeetPerRadian),
-                (RotationalStiffnessUnit.NewtonMeterPerRadian, RotationalStiffnessUnit.PoundForceFootPerDegrees) => new RotationalStiffness(_value / (4.4482216152605 * 0.3048 * 180 / Math.PI), RotationalStiffnessUnit.PoundForceFootPerDegrees),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RotationalStiffnessUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RotationalStiffnessUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RotationalStiffnessUnit> IQuantity<RotationalStiffnessUnit>.ToUnit(RotationalStiffnessUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1344,11 +1147,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
index f8eb0afebf..22a86ee1d6 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Stiffness#Rotational_stiffness
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct RotationalStiffnessPerLength :
-        IArithmeticQuantity<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit>,
+        ILinearQuantity<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<RotationalStiffnessPerLength, RotationalStiffnessPerLength, double>,
+        IDivisionOperators<RotationalStiffnessPerLength, RotationalStiffnessPerLength, QuantityValue>,
         IMultiplyOperators<RotationalStiffnessPerLength, Length, RotationalStiffness>,
         IComparisonOperators<RotationalStiffnessPerLength, RotationalStiffnessPerLength, bool>,
         IParsable<RotationalStiffnessPerLength>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static RotationalStiffnessPerLengthInfo CreateDefault(Func<IEnumerable<Un
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="RotationalStiffnessPerLength"/> is [T^-2][L][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="RotationalStiffnessPerLength"/> is T^-2LM.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 1, -2, 0, 0, 0, 0);
 
@@ -118,19 +117,25 @@ public static RotationalStiffnessPerLengthInfo CreateDefault(Func<IEnumerable<Un
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{RotationalStiffnessPerLengthUnit}"/> representing the default unit mappings for RotationalStiffnessPerLength.</returns>
             public static IEnumerable<UnitDefinition<RotationalStiffnessPerLengthUnit>> GetDefaultMappings()
             {
-                yield return new (RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, "KilonewtonMeterPerRadianPerMeter", "KilonewtonMetersPerRadianPerMeter", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot, "KilopoundForceFootPerDegreesPerFoot", "KilopoundForceFeetPerDegreesPerFeet", BaseUnits.Undefined);
-                yield return new (RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, "MeganewtonMeterPerRadianPerMeter", "MeganewtonMetersPerRadianPerMeter", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
+                yield return new (RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, "KilonewtonMeterPerRadianPerMeter", "KilonewtonMetersPerRadianPerMeter", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot, "KilopoundForceFootPerDegreesPerFoot", "KilopoundForceFeetPerDegreesPerFeet", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, QuantityValue.PowerOfTen(7) * new BigInteger(80067989074689))
+                );
+                yield return new (RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, "MeganewtonMeterPerRadianPerMeter", "MeganewtonMetersPerRadianPerMeter", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
                 yield return new (RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, "NewtonMeterPerRadianPerMeter", "NewtonMetersPerRadianPerMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, "PoundForceFootPerDegreesPerFoot", "PoundForceFeetPerDegreesPerFeet", BaseUnits.Undefined);
+                yield return new (RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, "PoundForceFootPerDegreesPerFoot", "PoundForceFeetPerDegreesPerFeet", BaseUnits.Undefined,
+                     new QuantityValue(3141592653589793, 800679890746890000)
+                );
             }
         }
 
         static RotationalStiffnessPerLength()
         {
-            Info = RotationalStiffnessPerLengthInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(RotationalStiffnessPerLengthInfo.CreateDefault);
         }
 
         /// <summary>
@@ -138,7 +143,7 @@ static RotationalStiffnessPerLength()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public RotationalStiffnessPerLength(double value, RotationalStiffnessPerLengthUnit unit)
+        public RotationalStiffnessPerLength(QuantityValue value, RotationalStiffnessPerLengthUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -152,7 +157,7 @@ public RotationalStiffnessPerLength(double value, RotationalStiffnessPerLengthUn
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public RotationalStiffnessPerLength(double value, UnitSystem unitSystem)
+        public RotationalStiffnessPerLength(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -163,7 +168,8 @@ public RotationalStiffnessPerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="RotationalStiffnessPerLength" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit> Info { get; }
@@ -192,10 +198,8 @@ public RotationalStiffnessPerLength(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public RotationalStiffnessPerLengthUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -229,56 +233,34 @@ public RotationalStiffnessPerLength(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter"/>
         /// </summary>
-        public double KilonewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
+        public QuantityValue KilonewtonMetersPerRadianPerMeter => this.As(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot"/>
         /// </summary>
-        public double KilopoundForceFeetPerDegreesPerFeet => As(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
+        public QuantityValue KilopoundForceFeetPerDegreesPerFeet => this.As(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter"/>
         /// </summary>
-        public double MeganewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
+        public QuantityValue MeganewtonMetersPerRadianPerMeter => this.As(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter"/>
         /// </summary>
-        public double NewtonMetersPerRadianPerMeter => As(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
+        public QuantityValue NewtonMetersPerRadianPerMeter => this.As(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot"/>
         /// </summary>
-        public double PoundForceFeetPerDegreesPerFeet => As(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
+        public QuantityValue PoundForceFeetPerDegreesPerFeet => this.As(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: RotationalStiffnessPerLengthUnit -> BaseUnit
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, quantity => quantity.ToUnit(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, quantity => quantity.ToUnit(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, quantity => quantity.ToUnit(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, quantity => quantity.ToUnit(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> RotationalStiffnessPerLengthUnit
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, quantity => quantity.ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter));
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot, quantity => quantity.ToUnit(RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot));
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, quantity => quantity.ToUnit(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter));
-            unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, quantity => quantity.ToUnit(RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -307,7 +289,7 @@ public static string GetAbbreviation(RotationalStiffnessPerLengthUnit unit, IFor
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter"/>.
         /// </summary>
-        public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter(double value)
+        public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter(QuantityValue value)
         {
             return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
         }
@@ -315,7 +297,7 @@ public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot"/>.
         /// </summary>
-        public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFeet(double value)
+        public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFeet(QuantityValue value)
         {
             return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
         }
@@ -323,7 +305,7 @@ public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFe
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter"/>.
         /// </summary>
-        public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter(double value)
+        public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter(QuantityValue value)
         {
             return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
         }
@@ -331,7 +313,7 @@ public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter"/>.
         /// </summary>
-        public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(double value)
+        public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(QuantityValue value)
         {
             return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
         }
@@ -339,7 +321,7 @@ public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(dou
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot"/>.
         /// </summary>
-        public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(double value)
+        public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(QuantityValue value)
         {
             return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
         }
@@ -350,7 +332,7 @@ public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(d
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RotationalStiffnessPerLength unit value.</returns>
-        public static RotationalStiffnessPerLength From(double value, RotationalStiffnessPerLengthUnit fromUnit)
+        public static RotationalStiffnessPerLength From(QuantityValue value, RotationalStiffnessPerLengthUnit fromUnit)
         {
             return new RotationalStiffnessPerLength(value, fromUnit);
         }
@@ -411,10 +393,7 @@ public static RotationalStiffnessPerLength Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static RotationalStiffnessPerLength Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -442,11 +421,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out RotationalStiffn
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out RotationalStiffnessPerLength result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -467,7 +442,7 @@ public static RotationalStiffnessPerLengthUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -478,7 +453,7 @@ public static RotationalStiffnessPerLengthUnit ParseUnit(string str, IFormatProv
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.RotationalStiffnessPerLengthUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.RotationalStiffnessPerLengthUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalStiffnessPerLengthUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -493,7 +468,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out RotationalSt
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out RotationalStiffnessPerLengthUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -512,35 +487,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from adding two <see cref="RotationalStiffnessPerLength"/>.</summary>
         public static RotationalStiffnessPerLength operator +(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
         {
-            return new RotationalStiffnessPerLength(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new RotationalStiffnessPerLength(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from subtracting two <see cref="RotationalStiffnessPerLength"/>.</summary>
         public static RotationalStiffnessPerLength operator -(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
         {
-            return new RotationalStiffnessPerLength(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new RotationalStiffnessPerLength(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from multiplying value and <see cref="RotationalStiffnessPerLength"/>.</summary>
-        public static RotationalStiffnessPerLength operator *(double left, RotationalStiffnessPerLength right)
+        public static RotationalStiffnessPerLength operator *(QuantityValue left, RotationalStiffnessPerLength right)
         {
             return new RotationalStiffnessPerLength(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from multiplying value and <see cref="RotationalStiffnessPerLength"/>.</summary>
-        public static RotationalStiffnessPerLength operator *(RotationalStiffnessPerLength left, double right)
+        public static RotationalStiffnessPerLength operator *(RotationalStiffnessPerLength left, QuantityValue right)
         {
             return new RotationalStiffnessPerLength(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="RotationalStiffnessPerLength"/> from dividing <see cref="RotationalStiffnessPerLength"/> by value.</summary>
-        public static RotationalStiffnessPerLength operator /(RotationalStiffnessPerLength left, double right)
+        public static RotationalStiffnessPerLength operator /(RotationalStiffnessPerLength left, QuantityValue right)
         {
             return new RotationalStiffnessPerLength(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="RotationalStiffnessPerLength"/> by <see cref="RotationalStiffnessPerLength"/>.</summary>
-        public static double operator /(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
+        public static QuantityValue operator /(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
         {
             return left.NewtonMetersPerRadianPerMeter / right.NewtonMetersPerRadianPerMeter;
         }
@@ -562,97 +537,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="RotationalStiffnessPerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RotationalStiffnessPerLength other, RotationalStiffnessPerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RotationalStiffnessPerLength"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(RotationalStiffnessPerLength)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="RotationalStiffnessPerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(RotationalStiffnessPerLength other, RotationalStiffnessPerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="RotationalStiffnessPerLength"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(RotationalStiffnessPerLength,RotationalStiffnessPerLength)"/>.
+        ///     See that operator (and <see cref="Equals(RotationalStiffnessPerLength)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(RotationalStiffnessPerLength left, RotationalStiffnessPerLength right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RotationalStiffnessPerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RotationalStiffnessPerLength other, RotationalStiffnessPerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="RotationalStiffnessPerLength"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="RotationalStiffnessPerLength"/>.
+        ///     When <paramref name="obj"/> is a <see cref="RotationalStiffnessPerLength"/>, this method delegates to
+        ///     <see cref="Equals(RotationalStiffnessPerLength)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is RotationalStiffnessPerLength otherQuantity))
+            if (obj is not RotationalStiffnessPerLength otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="RotationalStiffnessPerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(RotationalStiffnessPerLength other, RotationalStiffnessPerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="RotationalStiffnessPerLength"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(RotationalStiffnessPerLength other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current RotationalStiffnessPerLength.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(RotationalStiffnessPerLength), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="RotationalStiffnessPerLength"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(RotationalStiffnessPerLength)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is RotationalStiffnessPerLength otherQuantity)) throw new ArgumentException("Expected type RotationalStiffnessPerLength.", nameof(obj));
+            if (obj is not RotationalStiffnessPerLength otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<RotationalStiffnessPerLength>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="RotationalStiffnessPerLength"/> with another <see cref="RotationalStiffnessPerLength"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="RotationalStiffnessPerLength"/> with another <see cref="RotationalStiffnessPerLength"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -664,137 +653,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(RotationalStiffnessPerLength other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(RotationalStiffnessPerLengthUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<RotationalStiffnessPerLengthUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this RotationalStiffnessPerLength to another RotationalStiffnessPerLength with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A RotationalStiffnessPerLength with the specified unit.</returns>
-        public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="RotationalStiffnessPerLength"/> to another <see cref="RotationalStiffnessPerLength"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A RotationalStiffnessPerLength with the specified unit.</returns>
-        public RotationalStiffnessPerLength ToUnit(RotationalStiffnessPerLengthUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(RotationalStiffnessPerLength), Unit, typeof(RotationalStiffnessPerLength), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (RotationalStiffnessPerLength)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="RotationalStiffnessPerLength"/> to another <see cref="RotationalStiffnessPerLength"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="RotationalStiffnessPerLength"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(RotationalStiffnessPerLengthUnit unit, [NotNullWhen(true)] out RotationalStiffnessPerLength? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            RotationalStiffnessPerLength? convertedOrNull = (Unit, unit) switch
-            {
-                // RotationalStiffnessPerLengthUnit -> BaseUnit
-                (RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter) => new RotationalStiffnessPerLength((_value) * 1e3d, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter),
-                (RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter) => new RotationalStiffnessPerLength(_value * (4.4482216152605e3 * 180 / Math.PI), RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter),
-                (RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter) => new RotationalStiffnessPerLength((_value) * 1e6d, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter),
-                (RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter) => new RotationalStiffnessPerLength(_value * (4.4482216152605 * 180 / Math.PI), RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter),
-
-                // BaseUnit -> RotationalStiffnessPerLengthUnit
-                (RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter) => new RotationalStiffnessPerLength((_value) / 1e3d, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter),
-                (RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot) => new RotationalStiffnessPerLength(_value / (4.4482216152605e3 * 180 / Math.PI), RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot),
-                (RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter) => new RotationalStiffnessPerLength((_value) / 1e6d, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter),
-                (RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot) => new RotationalStiffnessPerLength(_value / (4.4482216152605 * 180 / Math.PI), RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not RotationalStiffnessPerLengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessPerLengthUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is RotationalStiffnessPerLengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessPerLengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<RotationalStiffnessPerLengthUnit> IQuantity<RotationalStiffnessPerLengthUnit>.ToUnit(RotationalStiffnessPerLengthUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -808,11 +669,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
index abc9a24426..ea1d538076 100644
--- a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     A way of representing a number of items.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Scalar :
-        IArithmeticQuantity<Scalar, ScalarUnit>,
+        ILinearQuantity<Scalar, ScalarUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Scalar, Scalar, double>,
+        IDivisionOperators<Scalar, Scalar, QuantityValue>,
         IComparisonOperators<Scalar, Scalar, bool>,
         IParsable<Scalar>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -123,9 +122,7 @@ public static IEnumerable<UnitDefinition<ScalarUnit>> GetDefaultMappings()
 
         static Scalar()
         {
-            Info = ScalarInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ScalarInfo.CreateDefault);
         }
 
         /// <summary>
@@ -133,7 +130,7 @@ static Scalar()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Scalar(double value, ScalarUnit unit)
+        public Scalar(QuantityValue value, ScalarUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -144,7 +141,8 @@ public Scalar(double value, ScalarUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Scalar" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Scalar, ScalarUnit> Info { get; }
@@ -173,10 +171,8 @@ public Scalar(double value, ScalarUnit unit)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ScalarUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -210,28 +206,14 @@ public Scalar(double value, ScalarUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ScalarUnit.Amount"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ScalarUnit.Amount"/>
         /// </summary>
-        public double Amount => As(ScalarUnit.Amount);
+        public QuantityValue Amount => this.As(ScalarUnit.Amount);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ScalarUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Scalar>(ScalarUnit.Amount, ScalarUnit.Amount, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ScalarUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -260,7 +242,7 @@ public static string GetAbbreviation(ScalarUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Scalar"/> from <see cref="ScalarUnit.Amount"/>.
         /// </summary>
-        public static Scalar FromAmount(double value)
+        public static Scalar FromAmount(QuantityValue value)
         {
             return new Scalar(value, ScalarUnit.Amount);
         }
@@ -271,7 +253,7 @@ public static Scalar FromAmount(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Scalar unit value.</returns>
-        public static Scalar From(double value, ScalarUnit fromUnit)
+        public static Scalar From(QuantityValue value, ScalarUnit fromUnit)
         {
             return new Scalar(value, fromUnit);
         }
@@ -332,10 +314,7 @@ public static Scalar Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Scalar Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Scalar, ScalarUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Scalar, ScalarUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -363,11 +342,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Scalar result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Scalar result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Scalar, ScalarUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Scalar, ScalarUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -388,7 +363,7 @@ public static ScalarUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -399,7 +374,7 @@ public static ScalarUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ScalarUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ScalarUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ScalarUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -414,7 +389,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ScalarUnit u
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ScalarUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -433,35 +408,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Scalar"/> from adding two <see cref="Scalar"/>.</summary>
         public static Scalar operator +(Scalar left, Scalar right)
         {
-            return new Scalar(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Scalar(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Scalar"/> from subtracting two <see cref="Scalar"/>.</summary>
         public static Scalar operator -(Scalar left, Scalar right)
         {
-            return new Scalar(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Scalar(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Scalar"/> from multiplying value and <see cref="Scalar"/>.</summary>
-        public static Scalar operator *(double left, Scalar right)
+        public static Scalar operator *(QuantityValue left, Scalar right)
         {
             return new Scalar(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Scalar"/> from multiplying value and <see cref="Scalar"/>.</summary>
-        public static Scalar operator *(Scalar left, double right)
+        public static Scalar operator *(Scalar left, QuantityValue right)
         {
             return new Scalar(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Scalar"/> from dividing <see cref="Scalar"/> by value.</summary>
-        public static Scalar operator /(Scalar left, double right)
+        public static Scalar operator /(Scalar left, QuantityValue right)
         {
             return new Scalar(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Scalar"/> by <see cref="Scalar"/>.</summary>
-        public static double operator /(Scalar left, Scalar right)
+        public static QuantityValue operator /(Scalar left, Scalar right)
         {
             return left.Amount / right.Amount;
         }
@@ -473,97 +448,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Scalar left, Scalar right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Scalar left, Scalar right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Scalar left, Scalar right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Scalar left, Scalar right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Scalar"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Scalar other, Scalar tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Scalar"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Scalar)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Scalar left, Scalar right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Scalar"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Scalar other, Scalar tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Scalar"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Scalar,Scalar)"/>.
+        ///     See that operator (and <see cref="Equals(Scalar)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Scalar left, Scalar right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Scalar"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Scalar other, Scalar tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Scalar"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Scalar"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Scalar"/>, this method delegates to
+        ///     <see cref="Equals(Scalar)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Scalar otherQuantity))
+            if (obj is not Scalar otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Scalar"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Scalar other, Scalar tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Scalar"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Scalar other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Scalar.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Scalar), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Scalar"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Scalar)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Scalar otherQuantity)) throw new ArgumentException("Expected type Scalar.", nameof(obj));
+            if (obj is not Scalar otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Scalar>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Scalar"/> with another <see cref="Scalar"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Scalar"/> with another <see cref="Scalar"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -575,131 +564,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Scalar other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ScalarUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ScalarUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Scalar to another Scalar with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Scalar with the specified unit.</returns>
-        public Scalar ToUnit(ScalarUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Scalar"/> to another <see cref="Scalar"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Scalar with the specified unit.</returns>
-        public Scalar ToUnit(ScalarUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Scalar), Unit, typeof(Scalar), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Scalar)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Scalar"/> to another <see cref="Scalar"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Scalar"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ScalarUnit unit, [NotNullWhen(true)] out Scalar? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Scalar? convertedOrNull = (Unit, unit) switch
-            {
-                // ScalarUnit -> BaseUnit
-
-                // BaseUnit -> ScalarUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ScalarUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ScalarUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ScalarUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ScalarUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ScalarUnit> IQuantity<ScalarUnit>.ToUnit(ScalarUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -711,11 +580,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
index 2a0570adc9..9938dabbf2 100644
--- a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Solid_angle
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct SolidAngle :
-        IArithmeticQuantity<SolidAngle, SolidAngleUnit>,
+        ILinearQuantity<SolidAngle, SolidAngleUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<SolidAngle, SolidAngle, double>,
+        IDivisionOperators<SolidAngle, SolidAngle, QuantityValue>,
+        IMultiplyOperators<SolidAngle, LuminousIntensity, LuminousFlux>,
         IComparisonOperators<SolidAngle, SolidAngle, bool>,
         IParsable<SolidAngle>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -126,9 +126,7 @@ public static IEnumerable<UnitDefinition<SolidAngleUnit>> GetDefaultMappings()
 
         static SolidAngle()
         {
-            Info = SolidAngleInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(SolidAngleInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +134,7 @@ static SolidAngle()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SolidAngle(double value, SolidAngleUnit unit)
+        public SolidAngle(QuantityValue value, SolidAngleUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -147,7 +145,8 @@ public SolidAngle(double value, SolidAngleUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="SolidAngle" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<SolidAngle, SolidAngleUnit> Info { get; }
@@ -176,10 +175,8 @@ public SolidAngle(double value, SolidAngleUnit unit)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public SolidAngleUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -213,28 +210,14 @@ public SolidAngle(double value, SolidAngleUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SolidAngleUnit.Steradian"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SolidAngleUnit.Steradian"/>
         /// </summary>
-        public double Steradians => As(SolidAngleUnit.Steradian);
+        public QuantityValue Steradians => this.As(SolidAngleUnit.Steradian);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: SolidAngleUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<SolidAngle>(SolidAngleUnit.Steradian, SolidAngleUnit.Steradian, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> SolidAngleUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -263,7 +246,7 @@ public static string GetAbbreviation(SolidAngleUnit unit, IFormatProvider? provi
         /// <summary>
         ///     Creates a <see cref="SolidAngle"/> from <see cref="SolidAngleUnit.Steradian"/>.
         /// </summary>
-        public static SolidAngle FromSteradians(double value)
+        public static SolidAngle FromSteradians(QuantityValue value)
         {
             return new SolidAngle(value, SolidAngleUnit.Steradian);
         }
@@ -274,7 +257,7 @@ public static SolidAngle FromSteradians(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SolidAngle unit value.</returns>
-        public static SolidAngle From(double value, SolidAngleUnit fromUnit)
+        public static SolidAngle From(QuantityValue value, SolidAngleUnit fromUnit)
         {
             return new SolidAngle(value, fromUnit);
         }
@@ -335,10 +318,7 @@ public static SolidAngle Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static SolidAngle Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<SolidAngle, SolidAngleUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<SolidAngle, SolidAngleUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -366,11 +346,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out SolidAngle resul
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out SolidAngle result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<SolidAngle, SolidAngleUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<SolidAngle, SolidAngleUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -391,7 +367,7 @@ public static SolidAngleUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -402,7 +378,7 @@ public static SolidAngleUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SolidAngleUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.SolidAngleUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out SolidAngleUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -417,7 +393,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SolidAngleUn
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out SolidAngleUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -436,137 +412,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="SolidAngle"/> from adding two <see cref="SolidAngle"/>.</summary>
         public static SolidAngle operator +(SolidAngle left, SolidAngle right)
         {
-            return new SolidAngle(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new SolidAngle(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SolidAngle"/> from subtracting two <see cref="SolidAngle"/>.</summary>
         public static SolidAngle operator -(SolidAngle left, SolidAngle right)
         {
-            return new SolidAngle(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new SolidAngle(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SolidAngle"/> from multiplying value and <see cref="SolidAngle"/>.</summary>
-        public static SolidAngle operator *(double left, SolidAngle right)
+        public static SolidAngle operator *(QuantityValue left, SolidAngle right)
         {
             return new SolidAngle(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="SolidAngle"/> from multiplying value and <see cref="SolidAngle"/>.</summary>
-        public static SolidAngle operator *(SolidAngle left, double right)
+        public static SolidAngle operator *(SolidAngle left, QuantityValue right)
         {
             return new SolidAngle(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="SolidAngle"/> from dividing <see cref="SolidAngle"/> by value.</summary>
-        public static SolidAngle operator /(SolidAngle left, double right)
+        public static SolidAngle operator /(SolidAngle left, QuantityValue right)
         {
             return new SolidAngle(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="SolidAngle"/> by <see cref="SolidAngle"/>.</summary>
-        public static double operator /(SolidAngle left, SolidAngle right)
+        public static QuantityValue operator /(SolidAngle left, SolidAngle right)
         {
             return left.Steradians / right.Steradians;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="LuminousFlux"/> from <see cref="SolidAngle"/> * <see cref="LuminousIntensity"/>.</summary>
+        public static LuminousFlux operator *(SolidAngle solidAngle, LuminousIntensity luminousIntensity)
+        {
+            return LuminousFlux.FromLumens(solidAngle.Steradians * luminousIntensity.Candela);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(SolidAngle left, SolidAngle right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(SolidAngle left, SolidAngle right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(SolidAngle left, SolidAngle right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(SolidAngle left, SolidAngle right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="SolidAngle"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SolidAngle other, SolidAngle tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SolidAngle"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(SolidAngle)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(SolidAngle left, SolidAngle right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="SolidAngle"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SolidAngle other, SolidAngle tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SolidAngle"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(SolidAngle,SolidAngle)"/>.
+        ///     See that operator (and <see cref="Equals(SolidAngle)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(SolidAngle left, SolidAngle right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SolidAngle"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SolidAngle other, SolidAngle tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="SolidAngle"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="SolidAngle"/>.
+        ///     When <paramref name="obj"/> is a <see cref="SolidAngle"/>, this method delegates to
+        ///     <see cref="Equals(SolidAngle)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is SolidAngle otherQuantity))
+            if (obj is not SolidAngle otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SolidAngle"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SolidAngle other, SolidAngle tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="SolidAngle"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(SolidAngle other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current SolidAngle.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(SolidAngle), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="SolidAngle"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(SolidAngle)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is SolidAngle otherQuantity)) throw new ArgumentException("Expected type SolidAngle.", nameof(obj));
+            if (obj is not SolidAngle otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<SolidAngle>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="SolidAngle"/> with another <see cref="SolidAngle"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="SolidAngle"/> with another <see cref="SolidAngle"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -578,131 +578,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(SolidAngle other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(SolidAngleUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<SolidAngleUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this SolidAngle to another SolidAngle with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A SolidAngle with the specified unit.</returns>
-        public SolidAngle ToUnit(SolidAngleUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="SolidAngle"/> to another <see cref="SolidAngle"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A SolidAngle with the specified unit.</returns>
-        public SolidAngle ToUnit(SolidAngleUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(SolidAngle), Unit, typeof(SolidAngle), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (SolidAngle)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="SolidAngle"/> to another <see cref="SolidAngle"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="SolidAngle"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(SolidAngleUnit unit, [NotNullWhen(true)] out SolidAngle? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            SolidAngle? convertedOrNull = (Unit, unit) switch
-            {
-                // SolidAngleUnit -> BaseUnit
-
-                // BaseUnit -> SolidAngleUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not SolidAngleUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SolidAngleUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is SolidAngleUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SolidAngleUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<SolidAngleUnit> IQuantity<SolidAngleUnit>.ToUnit(SolidAngleUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -714,11 +594,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
index 26e37a9e26..d24fdad7dc 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,17 +36,18 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Specific_energy
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct SpecificEnergy :
-        IArithmeticQuantity<SpecificEnergy, SpecificEnergyUnit>,
+        ILinearQuantity<SpecificEnergy, SpecificEnergyUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<SpecificEnergy, SpecificEnergy, double>,
+        IDivisionOperators<SpecificEnergy, SpecificEnergy, QuantityValue>,
         IMultiplyOperators<SpecificEnergy, Mass, Energy>,
         IMultiplyOperators<SpecificEnergy, MassFlow, Power>,
+        IMultiplyOperators<SpecificEnergy, BrakeSpecificFuelConsumption, QuantityValue>,
         IDivisionOperators<SpecificEnergy, TemperatureDelta, SpecificEntropy>,
         IDivisionOperators<SpecificEnergy, Speed, Speed>,
         IDivisionOperators<SpecificEnergy, SpecificEntropy, TemperatureDelta>,
-        IMultiplyOperators<SpecificEnergy, BrakeSpecificFuelConsumption, double>,
         IComparisonOperators<SpecificEnergy, SpecificEnergy, bool>,
         IParsable<SpecificEnergy>,
 #endif
@@ -61,7 +60,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -111,7 +110,7 @@ public static SpecificEnergyInfo CreateDefault(Func<IEnumerable<UnitDefinition<S
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="SpecificEnergy"/> is [T^-2][L^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="SpecificEnergy"/> is T^-2L^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 0, -2, 0, 0, 0, 0);
 
@@ -126,44 +125,100 @@ public static SpecificEnergyInfo CreateDefault(Func<IEnumerable<UnitDefinition<S
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{SpecificEnergyUnit}"/> representing the default unit mappings for SpecificEnergy.</returns>
             public static IEnumerable<UnitDefinition<SpecificEnergyUnit>> GetDefaultMappings()
             {
-                yield return new (SpecificEnergyUnit.BtuPerPound, "BtuPerPound", "BtuPerPound", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.CaloriePerGram, "CaloriePerGram", "CaloriesPerGram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.GigawattDayPerKilogram, "GigawattDayPerKilogram", "GigawattDaysPerKilogram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.GigawattDayPerShortTon, "GigawattDayPerShortTon", "GigawattDaysPerShortTon", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.GigawattDayPerTonne, "GigawattDayPerTonne", "GigawattDaysPerTonne", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.GigawattHourPerKilogram, "GigawattHourPerKilogram", "GigawattHoursPerKilogram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.GigawattHourPerPound, "GigawattHourPerPound", "GigawattHoursPerPound", BaseUnits.Undefined);
+                yield return new (SpecificEnergyUnit.BtuPerPound, "BtuPerPound", "BtuPerPound", BaseUnits.Undefined,
+                     new QuantityValue(1, 2326)
+                );
+                yield return new (SpecificEnergyUnit.CaloriePerGram, "CaloriePerGram", "CaloriesPerGram", BaseUnits.Undefined,
+                     new QuantityValue(1, 4184)
+                );
+                yield return new (SpecificEnergyUnit.GigawattDayPerKilogram, "GigawattDayPerKilogram", "GigawattDaysPerKilogram", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000000000)
+                );
+                yield return new (SpecificEnergyUnit.GigawattDayPerShortTon, "GigawattDayPerShortTon", "GigawattDaysPerShortTon", BaseUnits.Undefined,
+                     new QuantityValue(45359237, 4320000000000000000)
+                );
+                yield return new (SpecificEnergyUnit.GigawattDayPerTonne, "GigawattDayPerTonne", "GigawattDaysPerTonne", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000000)
+                );
+                yield return new (SpecificEnergyUnit.GigawattHourPerKilogram, "GigawattHourPerKilogram", "GigawattHoursPerKilogram", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000000000)
+                );
+                yield return new (SpecificEnergyUnit.GigawattHourPerPound, "GigawattHourPerPound", "GigawattHoursPerPound", BaseUnits.Undefined,
+                     new QuantityValue(1, 7936640000000)
+                );
                 yield return new (SpecificEnergyUnit.JoulePerKilogram, "JoulePerKilogram", "JoulesPerKilogram", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (SpecificEnergyUnit.KilocaloriePerGram, "KilocaloriePerGram", "KilocaloriesPerGram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.KilojoulePerKilogram, "KilojoulePerKilogram", "KilojoulesPerKilogram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.KilowattDayPerKilogram, "KilowattDayPerKilogram", "KilowattDaysPerKilogram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.KilowattDayPerShortTon, "KilowattDayPerShortTon", "KilowattDaysPerShortTon", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.KilowattDayPerTonne, "KilowattDayPerTonne", "KilowattDaysPerTonne", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.KilowattHourPerKilogram, "KilowattHourPerKilogram", "KilowattHoursPerKilogram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.KilowattHourPerPound, "KilowattHourPerPound", "KilowattHoursPerPound", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.MegajoulePerKilogram, "MegajoulePerKilogram", "MegajoulesPerKilogram", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second));
-                yield return new (SpecificEnergyUnit.MegajoulePerTonne, "MegajoulePerTonne", "MegajoulesPerTonne", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.MegawattDayPerKilogram, "MegawattDayPerKilogram", "MegawattDaysPerKilogram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.MegawattDayPerShortTon, "MegawattDayPerShortTon", "MegawattDaysPerShortTon", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.MegawattDayPerTonne, "MegawattDayPerTonne", "MegawattDaysPerTonne", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.MegawattHourPerKilogram, "MegawattHourPerKilogram", "MegawattHoursPerKilogram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.MegawattHourPerPound, "MegawattHourPerPound", "MegawattHoursPerPound", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.TerawattDayPerKilogram, "TerawattDayPerKilogram", "TerawattDaysPerKilogram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.TerawattDayPerShortTon, "TerawattDayPerShortTon", "TerawattDaysPerShortTon", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.TerawattDayPerTonne, "TerawattDayPerTonne", "TerawattDaysPerTonne", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.WattDayPerKilogram, "WattDayPerKilogram", "WattDaysPerKilogram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.WattDayPerShortTon, "WattDayPerShortTon", "WattDaysPerShortTon", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.WattDayPerTonne, "WattDayPerTonne", "WattDaysPerTonne", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.WattHourPerKilogram, "WattHourPerKilogram", "WattHoursPerKilogram", BaseUnits.Undefined);
-                yield return new (SpecificEnergyUnit.WattHourPerPound, "WattHourPerPound", "WattHoursPerPound", BaseUnits.Undefined);
+                yield return new (SpecificEnergyUnit.KilocaloriePerGram, "KilocaloriePerGram", "KilocaloriesPerGram", BaseUnits.Undefined,
+                     new QuantityValue(1, 4184000)
+                );
+                yield return new (SpecificEnergyUnit.KilojoulePerKilogram, "KilojoulePerKilogram", "KilojoulesPerKilogram", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (SpecificEnergyUnit.KilowattDayPerKilogram, "KilowattDayPerKilogram", "KilowattDaysPerKilogram", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000)
+                );
+                yield return new (SpecificEnergyUnit.KilowattDayPerShortTon, "KilowattDayPerShortTon", "KilowattDaysPerShortTon", BaseUnits.Undefined,
+                     new QuantityValue(45359237, 4320000000000)
+                );
+                yield return new (SpecificEnergyUnit.KilowattDayPerTonne, "KilowattDayPerTonne", "KilowattDaysPerTonne", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400)
+                );
+                yield return new (SpecificEnergyUnit.KilowattHourPerKilogram, "KilowattHourPerKilogram", "KilowattHoursPerKilogram", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000)
+                );
+                yield return new (SpecificEnergyUnit.KilowattHourPerPound, "KilowattHourPerPound", "KilowattHoursPerPound", BaseUnits.Undefined,
+                     new QuantityValue(1, 7936640)
+                );
+                yield return new (SpecificEnergyUnit.MegajoulePerKilogram, "MegajoulePerKilogram", "MegajoulesPerKilogram", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (SpecificEnergyUnit.MegajoulePerTonne, "MegajoulePerTonne", "MegajoulesPerTonne", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (SpecificEnergyUnit.MegawattDayPerKilogram, "MegawattDayPerKilogram", "MegawattDaysPerKilogram", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000000)
+                );
+                yield return new (SpecificEnergyUnit.MegawattDayPerShortTon, "MegawattDayPerShortTon", "MegawattDaysPerShortTon", BaseUnits.Undefined,
+                     new QuantityValue(45359237, 4320000000000000)
+                );
+                yield return new (SpecificEnergyUnit.MegawattDayPerTonne, "MegawattDayPerTonne", "MegawattDaysPerTonne", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000)
+                );
+                yield return new (SpecificEnergyUnit.MegawattHourPerKilogram, "MegawattHourPerKilogram", "MegawattHoursPerKilogram", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600000000)
+                );
+                yield return new (SpecificEnergyUnit.MegawattHourPerPound, "MegawattHourPerPound", "MegawattHoursPerPound", BaseUnits.Undefined,
+                     new QuantityValue(1, 7936640000)
+                );
+                yield return new (SpecificEnergyUnit.TerawattDayPerKilogram, "TerawattDayPerKilogram", "TerawattDaysPerKilogram", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000000000000)
+                );
+                yield return new (SpecificEnergyUnit.TerawattDayPerShortTon, "TerawattDayPerShortTon", "TerawattDaysPerShortTon", BaseUnits.Undefined,
+                     new QuantityValue(45359237, new BigInteger(432) * QuantityValue.PowerOfTen(19))
+                );
+                yield return new (SpecificEnergyUnit.TerawattDayPerTonne, "TerawattDayPerTonne", "TerawattDaysPerTonne", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400000000000)
+                );
+                yield return new (SpecificEnergyUnit.WattDayPerKilogram, "WattDayPerKilogram", "WattDaysPerKilogram", BaseUnits.Undefined,
+                     new QuantityValue(1, 86400)
+                );
+                yield return new (SpecificEnergyUnit.WattDayPerShortTon, "WattDayPerShortTon", "WattDaysPerShortTon", BaseUnits.Undefined,
+                     new QuantityValue(45359237, 4320000000)
+                );
+                yield return new (SpecificEnergyUnit.WattDayPerTonne, "WattDayPerTonne", "WattDaysPerTonne", BaseUnits.Undefined,
+                     new QuantityValue(5, 432)
+                );
+                yield return new (SpecificEnergyUnit.WattHourPerKilogram, "WattHourPerKilogram", "WattHoursPerKilogram", BaseUnits.Undefined,
+                     new QuantityValue(1, 3600)
+                );
+                yield return new (SpecificEnergyUnit.WattHourPerPound, "WattHourPerPound", "WattHoursPerPound", BaseUnits.Undefined,
+                     new QuantityValue(25, 198416)
+                );
             }
         }
 
         static SpecificEnergy()
         {
-            Info = SpecificEnergyInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(SpecificEnergyInfo.CreateDefault);
         }
 
         /// <summary>
@@ -171,7 +226,7 @@ static SpecificEnergy()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SpecificEnergy(double value, SpecificEnergyUnit unit)
+        public SpecificEnergy(QuantityValue value, SpecificEnergyUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -185,7 +240,7 @@ public SpecificEnergy(double value, SpecificEnergyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public SpecificEnergy(double value, UnitSystem unitSystem)
+        public SpecificEnergy(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -196,7 +251,8 @@ public SpecificEnergy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="SpecificEnergy" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<SpecificEnergy, SpecificEnergyUnit> Info { get; }
@@ -225,10 +281,8 @@ public SpecificEnergy(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public SpecificEnergyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -262,231 +316,159 @@ public SpecificEnergy(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.BtuPerPound"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.BtuPerPound"/>
         /// </summary>
-        public double BtuPerPound => As(SpecificEnergyUnit.BtuPerPound);
+        public QuantityValue BtuPerPound => this.As(SpecificEnergyUnit.BtuPerPound);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.CaloriePerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.CaloriePerGram"/>
         /// </summary>
-        public double CaloriesPerGram => As(SpecificEnergyUnit.CaloriePerGram);
+        public QuantityValue CaloriesPerGram => this.As(SpecificEnergyUnit.CaloriePerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattDayPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattDayPerKilogram"/>
         /// </summary>
-        public double GigawattDaysPerKilogram => As(SpecificEnergyUnit.GigawattDayPerKilogram);
+        public QuantityValue GigawattDaysPerKilogram => this.As(SpecificEnergyUnit.GigawattDayPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattDayPerShortTon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattDayPerShortTon"/>
         /// </summary>
-        public double GigawattDaysPerShortTon => As(SpecificEnergyUnit.GigawattDayPerShortTon);
+        public QuantityValue GigawattDaysPerShortTon => this.As(SpecificEnergyUnit.GigawattDayPerShortTon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattDayPerTonne"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattDayPerTonne"/>
         /// </summary>
-        public double GigawattDaysPerTonne => As(SpecificEnergyUnit.GigawattDayPerTonne);
+        public QuantityValue GigawattDaysPerTonne => this.As(SpecificEnergyUnit.GigawattDayPerTonne);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattHourPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattHourPerKilogram"/>
         /// </summary>
-        public double GigawattHoursPerKilogram => As(SpecificEnergyUnit.GigawattHourPerKilogram);
+        public QuantityValue GigawattHoursPerKilogram => this.As(SpecificEnergyUnit.GigawattHourPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattHourPerPound"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.GigawattHourPerPound"/>
         /// </summary>
-        public double GigawattHoursPerPound => As(SpecificEnergyUnit.GigawattHourPerPound);
+        public QuantityValue GigawattHoursPerPound => this.As(SpecificEnergyUnit.GigawattHourPerPound);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.JoulePerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.JoulePerKilogram"/>
         /// </summary>
-        public double JoulesPerKilogram => As(SpecificEnergyUnit.JoulePerKilogram);
+        public QuantityValue JoulesPerKilogram => this.As(SpecificEnergyUnit.JoulePerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilocaloriePerGram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilocaloriePerGram"/>
         /// </summary>
-        public double KilocaloriesPerGram => As(SpecificEnergyUnit.KilocaloriePerGram);
+        public QuantityValue KilocaloriesPerGram => this.As(SpecificEnergyUnit.KilocaloriePerGram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilojoulePerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilojoulePerKilogram"/>
         /// </summary>
-        public double KilojoulesPerKilogram => As(SpecificEnergyUnit.KilojoulePerKilogram);
+        public QuantityValue KilojoulesPerKilogram => this.As(SpecificEnergyUnit.KilojoulePerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattDayPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattDayPerKilogram"/>
         /// </summary>
-        public double KilowattDaysPerKilogram => As(SpecificEnergyUnit.KilowattDayPerKilogram);
+        public QuantityValue KilowattDaysPerKilogram => this.As(SpecificEnergyUnit.KilowattDayPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattDayPerShortTon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattDayPerShortTon"/>
         /// </summary>
-        public double KilowattDaysPerShortTon => As(SpecificEnergyUnit.KilowattDayPerShortTon);
+        public QuantityValue KilowattDaysPerShortTon => this.As(SpecificEnergyUnit.KilowattDayPerShortTon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattDayPerTonne"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattDayPerTonne"/>
         /// </summary>
-        public double KilowattDaysPerTonne => As(SpecificEnergyUnit.KilowattDayPerTonne);
+        public QuantityValue KilowattDaysPerTonne => this.As(SpecificEnergyUnit.KilowattDayPerTonne);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattHourPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattHourPerKilogram"/>
         /// </summary>
-        public double KilowattHoursPerKilogram => As(SpecificEnergyUnit.KilowattHourPerKilogram);
+        public QuantityValue KilowattHoursPerKilogram => this.As(SpecificEnergyUnit.KilowattHourPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattHourPerPound"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.KilowattHourPerPound"/>
         /// </summary>
-        public double KilowattHoursPerPound => As(SpecificEnergyUnit.KilowattHourPerPound);
+        public QuantityValue KilowattHoursPerPound => this.As(SpecificEnergyUnit.KilowattHourPerPound);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegajoulePerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegajoulePerKilogram"/>
         /// </summary>
-        public double MegajoulesPerKilogram => As(SpecificEnergyUnit.MegajoulePerKilogram);
+        public QuantityValue MegajoulesPerKilogram => this.As(SpecificEnergyUnit.MegajoulePerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegajoulePerTonne"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegajoulePerTonne"/>
         /// </summary>
-        public double MegajoulesPerTonne => As(SpecificEnergyUnit.MegajoulePerTonne);
+        public QuantityValue MegajoulesPerTonne => this.As(SpecificEnergyUnit.MegajoulePerTonne);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattDayPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattDayPerKilogram"/>
         /// </summary>
-        public double MegawattDaysPerKilogram => As(SpecificEnergyUnit.MegawattDayPerKilogram);
+        public QuantityValue MegawattDaysPerKilogram => this.As(SpecificEnergyUnit.MegawattDayPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattDayPerShortTon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattDayPerShortTon"/>
         /// </summary>
-        public double MegawattDaysPerShortTon => As(SpecificEnergyUnit.MegawattDayPerShortTon);
+        public QuantityValue MegawattDaysPerShortTon => this.As(SpecificEnergyUnit.MegawattDayPerShortTon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattDayPerTonne"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattDayPerTonne"/>
         /// </summary>
-        public double MegawattDaysPerTonne => As(SpecificEnergyUnit.MegawattDayPerTonne);
+        public QuantityValue MegawattDaysPerTonne => this.As(SpecificEnergyUnit.MegawattDayPerTonne);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattHourPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattHourPerKilogram"/>
         /// </summary>
-        public double MegawattHoursPerKilogram => As(SpecificEnergyUnit.MegawattHourPerKilogram);
+        public QuantityValue MegawattHoursPerKilogram => this.As(SpecificEnergyUnit.MegawattHourPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattHourPerPound"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.MegawattHourPerPound"/>
         /// </summary>
-        public double MegawattHoursPerPound => As(SpecificEnergyUnit.MegawattHourPerPound);
+        public QuantityValue MegawattHoursPerPound => this.As(SpecificEnergyUnit.MegawattHourPerPound);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.TerawattDayPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.TerawattDayPerKilogram"/>
         /// </summary>
-        public double TerawattDaysPerKilogram => As(SpecificEnergyUnit.TerawattDayPerKilogram);
+        public QuantityValue TerawattDaysPerKilogram => this.As(SpecificEnergyUnit.TerawattDayPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.TerawattDayPerShortTon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.TerawattDayPerShortTon"/>
         /// </summary>
-        public double TerawattDaysPerShortTon => As(SpecificEnergyUnit.TerawattDayPerShortTon);
+        public QuantityValue TerawattDaysPerShortTon => this.As(SpecificEnergyUnit.TerawattDayPerShortTon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.TerawattDayPerTonne"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.TerawattDayPerTonne"/>
         /// </summary>
-        public double TerawattDaysPerTonne => As(SpecificEnergyUnit.TerawattDayPerTonne);
+        public QuantityValue TerawattDaysPerTonne => this.As(SpecificEnergyUnit.TerawattDayPerTonne);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattDayPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattDayPerKilogram"/>
         /// </summary>
-        public double WattDaysPerKilogram => As(SpecificEnergyUnit.WattDayPerKilogram);
+        public QuantityValue WattDaysPerKilogram => this.As(SpecificEnergyUnit.WattDayPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattDayPerShortTon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattDayPerShortTon"/>
         /// </summary>
-        public double WattDaysPerShortTon => As(SpecificEnergyUnit.WattDayPerShortTon);
+        public QuantityValue WattDaysPerShortTon => this.As(SpecificEnergyUnit.WattDayPerShortTon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattDayPerTonne"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattDayPerTonne"/>
         /// </summary>
-        public double WattDaysPerTonne => As(SpecificEnergyUnit.WattDayPerTonne);
+        public QuantityValue WattDaysPerTonne => this.As(SpecificEnergyUnit.WattDayPerTonne);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattHourPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattHourPerKilogram"/>
         /// </summary>
-        public double WattHoursPerKilogram => As(SpecificEnergyUnit.WattHourPerKilogram);
+        public QuantityValue WattHoursPerKilogram => this.As(SpecificEnergyUnit.WattHourPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattHourPerPound"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEnergyUnit.WattHourPerPound"/>
         /// </summary>
-        public double WattHoursPerPound => As(SpecificEnergyUnit.WattHourPerPound);
+        public QuantityValue WattHoursPerPound => this.As(SpecificEnergyUnit.WattHourPerPound);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: SpecificEnergyUnit -> BaseUnit
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.BtuPerPound, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.CaloriePerGram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.GigawattDayPerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.GigawattDayPerShortTon, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.GigawattDayPerTonne, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.GigawattHourPerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.GigawattHourPerPound, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilocaloriePerGram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilojoulePerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilowattDayPerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilowattDayPerShortTon, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilowattDayPerTonne, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilowattHourPerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.KilowattHourPerPound, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegajoulePerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegajoulePerTonne, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegawattDayPerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegawattDayPerShortTon, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegawattDayPerTonne, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegawattHourPerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.MegawattHourPerPound, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.TerawattDayPerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.TerawattDayPerShortTon, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.TerawattDayPerTonne, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.WattDayPerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.WattDayPerShortTon, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.WattDayPerTonne, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.WattHourPerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.WattHourPerPound, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.JoulePerKilogram));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.JoulePerKilogram, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> SpecificEnergyUnit
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.BtuPerPound, quantity => quantity.ToUnit(SpecificEnergyUnit.BtuPerPound));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.CaloriePerGram, quantity => quantity.ToUnit(SpecificEnergyUnit.CaloriePerGram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.GigawattDayPerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.GigawattDayPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.GigawattDayPerShortTon, quantity => quantity.ToUnit(SpecificEnergyUnit.GigawattDayPerShortTon));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.GigawattDayPerTonne, quantity => quantity.ToUnit(SpecificEnergyUnit.GigawattDayPerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.GigawattHourPerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.GigawattHourPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.GigawattHourPerPound, quantity => quantity.ToUnit(SpecificEnergyUnit.GigawattHourPerPound));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilocaloriePerGram, quantity => quantity.ToUnit(SpecificEnergyUnit.KilocaloriePerGram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilojoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.KilojoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilowattDayPerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.KilowattDayPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilowattDayPerShortTon, quantity => quantity.ToUnit(SpecificEnergyUnit.KilowattDayPerShortTon));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilowattDayPerTonne, quantity => quantity.ToUnit(SpecificEnergyUnit.KilowattDayPerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilowattHourPerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.KilowattHourPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilowattHourPerPound, quantity => quantity.ToUnit(SpecificEnergyUnit.KilowattHourPerPound));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegajoulePerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.MegajoulePerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegajoulePerTonne, quantity => quantity.ToUnit(SpecificEnergyUnit.MegajoulePerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegawattDayPerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.MegawattDayPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegawattDayPerShortTon, quantity => quantity.ToUnit(SpecificEnergyUnit.MegawattDayPerShortTon));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegawattDayPerTonne, quantity => quantity.ToUnit(SpecificEnergyUnit.MegawattDayPerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegawattHourPerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.MegawattHourPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegawattHourPerPound, quantity => quantity.ToUnit(SpecificEnergyUnit.MegawattHourPerPound));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.TerawattDayPerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.TerawattDayPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.TerawattDayPerShortTon, quantity => quantity.ToUnit(SpecificEnergyUnit.TerawattDayPerShortTon));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.TerawattDayPerTonne, quantity => quantity.ToUnit(SpecificEnergyUnit.TerawattDayPerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.WattDayPerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.WattDayPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.WattDayPerShortTon, quantity => quantity.ToUnit(SpecificEnergyUnit.WattDayPerShortTon));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.WattDayPerTonne, quantity => quantity.ToUnit(SpecificEnergyUnit.WattDayPerTonne));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.WattHourPerKilogram, quantity => quantity.ToUnit(SpecificEnergyUnit.WattHourPerKilogram));
-            unitConverter.SetConversionFunction<SpecificEnergy>(SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.WattHourPerPound, quantity => quantity.ToUnit(SpecificEnergyUnit.WattHourPerPound));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -515,7 +497,7 @@ public static string GetAbbreviation(SpecificEnergyUnit unit, IFormatProvider? p
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.BtuPerPound"/>.
         /// </summary>
-        public static SpecificEnergy FromBtuPerPound(double value)
+        public static SpecificEnergy FromBtuPerPound(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.BtuPerPound);
         }
@@ -523,7 +505,7 @@ public static SpecificEnergy FromBtuPerPound(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.CaloriePerGram"/>.
         /// </summary>
-        public static SpecificEnergy FromCaloriesPerGram(double value)
+        public static SpecificEnergy FromCaloriesPerGram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.CaloriePerGram);
         }
@@ -531,7 +513,7 @@ public static SpecificEnergy FromCaloriesPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromGigawattDaysPerKilogram(double value)
+        public static SpecificEnergy FromGigawattDaysPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerKilogram);
         }
@@ -539,7 +521,7 @@ public static SpecificEnergy FromGigawattDaysPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerShortTon"/>.
         /// </summary>
-        public static SpecificEnergy FromGigawattDaysPerShortTon(double value)
+        public static SpecificEnergy FromGigawattDaysPerShortTon(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerShortTon);
         }
@@ -547,7 +529,7 @@ public static SpecificEnergy FromGigawattDaysPerShortTon(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerTonne"/>.
         /// </summary>
-        public static SpecificEnergy FromGigawattDaysPerTonne(double value)
+        public static SpecificEnergy FromGigawattDaysPerTonne(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerTonne);
         }
@@ -555,7 +537,7 @@ public static SpecificEnergy FromGigawattDaysPerTonne(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattHourPerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromGigawattHoursPerKilogram(double value)
+        public static SpecificEnergy FromGigawattHoursPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerKilogram);
         }
@@ -563,7 +545,7 @@ public static SpecificEnergy FromGigawattHoursPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattHourPerPound"/>.
         /// </summary>
-        public static SpecificEnergy FromGigawattHoursPerPound(double value)
+        public static SpecificEnergy FromGigawattHoursPerPound(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerPound);
         }
@@ -571,7 +553,7 @@ public static SpecificEnergy FromGigawattHoursPerPound(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.JoulePerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromJoulesPerKilogram(double value)
+        public static SpecificEnergy FromJoulesPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.JoulePerKilogram);
         }
@@ -579,7 +561,7 @@ public static SpecificEnergy FromJoulesPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilocaloriePerGram"/>.
         /// </summary>
-        public static SpecificEnergy FromKilocaloriesPerGram(double value)
+        public static SpecificEnergy FromKilocaloriesPerGram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.KilocaloriePerGram);
         }
@@ -587,7 +569,7 @@ public static SpecificEnergy FromKilocaloriesPerGram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilojoulePerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromKilojoulesPerKilogram(double value)
+        public static SpecificEnergy FromKilojoulesPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.KilojoulePerKilogram);
         }
@@ -595,7 +577,7 @@ public static SpecificEnergy FromKilojoulesPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromKilowattDaysPerKilogram(double value)
+        public static SpecificEnergy FromKilowattDaysPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerKilogram);
         }
@@ -603,7 +585,7 @@ public static SpecificEnergy FromKilowattDaysPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerShortTon"/>.
         /// </summary>
-        public static SpecificEnergy FromKilowattDaysPerShortTon(double value)
+        public static SpecificEnergy FromKilowattDaysPerShortTon(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerShortTon);
         }
@@ -611,7 +593,7 @@ public static SpecificEnergy FromKilowattDaysPerShortTon(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerTonne"/>.
         /// </summary>
-        public static SpecificEnergy FromKilowattDaysPerTonne(double value)
+        public static SpecificEnergy FromKilowattDaysPerTonne(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerTonne);
         }
@@ -619,7 +601,7 @@ public static SpecificEnergy FromKilowattDaysPerTonne(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattHourPerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromKilowattHoursPerKilogram(double value)
+        public static SpecificEnergy FromKilowattHoursPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerKilogram);
         }
@@ -627,7 +609,7 @@ public static SpecificEnergy FromKilowattHoursPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattHourPerPound"/>.
         /// </summary>
-        public static SpecificEnergy FromKilowattHoursPerPound(double value)
+        public static SpecificEnergy FromKilowattHoursPerPound(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerPound);
         }
@@ -635,7 +617,7 @@ public static SpecificEnergy FromKilowattHoursPerPound(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegajoulePerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromMegajoulesPerKilogram(double value)
+        public static SpecificEnergy FromMegajoulesPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.MegajoulePerKilogram);
         }
@@ -643,7 +625,7 @@ public static SpecificEnergy FromMegajoulesPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegajoulePerTonne"/>.
         /// </summary>
-        public static SpecificEnergy FromMegajoulesPerTonne(double value)
+        public static SpecificEnergy FromMegajoulesPerTonne(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.MegajoulePerTonne);
         }
@@ -651,7 +633,7 @@ public static SpecificEnergy FromMegajoulesPerTonne(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromMegawattDaysPerKilogram(double value)
+        public static SpecificEnergy FromMegawattDaysPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerKilogram);
         }
@@ -659,7 +641,7 @@ public static SpecificEnergy FromMegawattDaysPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerShortTon"/>.
         /// </summary>
-        public static SpecificEnergy FromMegawattDaysPerShortTon(double value)
+        public static SpecificEnergy FromMegawattDaysPerShortTon(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerShortTon);
         }
@@ -667,7 +649,7 @@ public static SpecificEnergy FromMegawattDaysPerShortTon(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerTonne"/>.
         /// </summary>
-        public static SpecificEnergy FromMegawattDaysPerTonne(double value)
+        public static SpecificEnergy FromMegawattDaysPerTonne(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerTonne);
         }
@@ -675,7 +657,7 @@ public static SpecificEnergy FromMegawattDaysPerTonne(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattHourPerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromMegawattHoursPerKilogram(double value)
+        public static SpecificEnergy FromMegawattHoursPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerKilogram);
         }
@@ -683,7 +665,7 @@ public static SpecificEnergy FromMegawattHoursPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattHourPerPound"/>.
         /// </summary>
-        public static SpecificEnergy FromMegawattHoursPerPound(double value)
+        public static SpecificEnergy FromMegawattHoursPerPound(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerPound);
         }
@@ -691,7 +673,7 @@ public static SpecificEnergy FromMegawattHoursPerPound(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromTerawattDaysPerKilogram(double value)
+        public static SpecificEnergy FromTerawattDaysPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerKilogram);
         }
@@ -699,7 +681,7 @@ public static SpecificEnergy FromTerawattDaysPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerShortTon"/>.
         /// </summary>
-        public static SpecificEnergy FromTerawattDaysPerShortTon(double value)
+        public static SpecificEnergy FromTerawattDaysPerShortTon(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerShortTon);
         }
@@ -707,7 +689,7 @@ public static SpecificEnergy FromTerawattDaysPerShortTon(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerTonne"/>.
         /// </summary>
-        public static SpecificEnergy FromTerawattDaysPerTonne(double value)
+        public static SpecificEnergy FromTerawattDaysPerTonne(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerTonne);
         }
@@ -715,7 +697,7 @@ public static SpecificEnergy FromTerawattDaysPerTonne(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromWattDaysPerKilogram(double value)
+        public static SpecificEnergy FromWattDaysPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerKilogram);
         }
@@ -723,7 +705,7 @@ public static SpecificEnergy FromWattDaysPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerShortTon"/>.
         /// </summary>
-        public static SpecificEnergy FromWattDaysPerShortTon(double value)
+        public static SpecificEnergy FromWattDaysPerShortTon(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerShortTon);
         }
@@ -731,7 +713,7 @@ public static SpecificEnergy FromWattDaysPerShortTon(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerTonne"/>.
         /// </summary>
-        public static SpecificEnergy FromWattDaysPerTonne(double value)
+        public static SpecificEnergy FromWattDaysPerTonne(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerTonne);
         }
@@ -739,7 +721,7 @@ public static SpecificEnergy FromWattDaysPerTonne(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattHourPerKilogram"/>.
         /// </summary>
-        public static SpecificEnergy FromWattHoursPerKilogram(double value)
+        public static SpecificEnergy FromWattHoursPerKilogram(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerKilogram);
         }
@@ -747,7 +729,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattHourPerPound"/>.
         /// </summary>
-        public static SpecificEnergy FromWattHoursPerPound(double value)
+        public static SpecificEnergy FromWattHoursPerPound(QuantityValue value)
         {
             return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerPound);
         }
@@ -758,7 +740,7 @@ public static SpecificEnergy FromWattHoursPerPound(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SpecificEnergy unit value.</returns>
-        public static SpecificEnergy From(double value, SpecificEnergyUnit fromUnit)
+        public static SpecificEnergy From(QuantityValue value, SpecificEnergyUnit fromUnit)
         {
             return new SpecificEnergy(value, fromUnit);
         }
@@ -819,10 +801,7 @@ public static SpecificEnergy Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static SpecificEnergy Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<SpecificEnergy, SpecificEnergyUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<SpecificEnergy, SpecificEnergyUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -850,11 +829,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out SpecificEnergy r
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpecificEnergy result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<SpecificEnergy, SpecificEnergyUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<SpecificEnergy, SpecificEnergyUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -875,7 +850,7 @@ public static SpecificEnergyUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -886,7 +861,7 @@ public static SpecificEnergyUnit ParseUnit(string str, IFormatProvider? provider
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpecificEnergyUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.SpecificEnergyUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificEnergyUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -901,7 +876,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificEner
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpecificEnergyUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -920,35 +895,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="SpecificEnergy"/> from adding two <see cref="SpecificEnergy"/>.</summary>
         public static SpecificEnergy operator +(SpecificEnergy left, SpecificEnergy right)
         {
-            return new SpecificEnergy(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new SpecificEnergy(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificEnergy"/> from subtracting two <see cref="SpecificEnergy"/>.</summary>
         public static SpecificEnergy operator -(SpecificEnergy left, SpecificEnergy right)
         {
-            return new SpecificEnergy(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new SpecificEnergy(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificEnergy"/> from multiplying value and <see cref="SpecificEnergy"/>.</summary>
-        public static SpecificEnergy operator *(double left, SpecificEnergy right)
+        public static SpecificEnergy operator *(QuantityValue left, SpecificEnergy right)
         {
             return new SpecificEnergy(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="SpecificEnergy"/> from multiplying value and <see cref="SpecificEnergy"/>.</summary>
-        public static SpecificEnergy operator *(SpecificEnergy left, double right)
+        public static SpecificEnergy operator *(SpecificEnergy left, QuantityValue right)
         {
             return new SpecificEnergy(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificEnergy"/> from dividing <see cref="SpecificEnergy"/> by value.</summary>
-        public static SpecificEnergy operator /(SpecificEnergy left, double right)
+        public static SpecificEnergy operator /(SpecificEnergy left, QuantityValue right)
         {
             return new SpecificEnergy(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="SpecificEnergy"/> by <see cref="SpecificEnergy"/>.</summary>
-        public static double operator /(SpecificEnergy left, SpecificEnergy right)
+        public static QuantityValue operator /(SpecificEnergy left, SpecificEnergy right)
         {
             return left.JoulesPerKilogram / right.JoulesPerKilogram;
         }
@@ -957,8 +932,8 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
-        /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from <see cref="double"/> / <see cref="SpecificEnergy"/>.</summary>
-        public static BrakeSpecificFuelConsumption operator /(double value, SpecificEnergy specificEnergy)
+        /// <summary>Get <see cref="BrakeSpecificFuelConsumption"/> from <see cref="QuantityValue"/> / <see cref="SpecificEnergy"/>.</summary>
+        public static BrakeSpecificFuelConsumption operator /(QuantityValue value, SpecificEnergy specificEnergy)
         {
             return BrakeSpecificFuelConsumption.FromKilogramsPerJoule(value / specificEnergy.JoulesPerKilogram);
         }
@@ -975,6 +950,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Power.FromWatts(specificEnergy.JoulesPerKilogram * massFlow.KilogramsPerSecond);
         }
 
+        /// <summary>Get <see cref="QuantityValue"/> from <see cref="SpecificEnergy"/> * <see cref="BrakeSpecificFuelConsumption"/>.</summary>
+        public static QuantityValue operator *(SpecificEnergy specificEnergy, BrakeSpecificFuelConsumption brakeSpecificFuelConsumption)
+        {
+            return specificEnergy.JoulesPerKilogram * brakeSpecificFuelConsumption.KilogramsPerJoule;
+        }
+
         /// <summary>Get <see cref="SpecificEntropy"/> from <see cref="SpecificEnergy"/> / <see cref="TemperatureDelta"/>.</summary>
         public static SpecificEntropy operator /(SpecificEnergy specificEnergy, TemperatureDelta temperatureDelta)
         {
@@ -993,12 +974,6 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return TemperatureDelta.FromKelvins(specificEnergy.JoulesPerKilogram / specificEntropy.JoulesPerKilogramKelvin);
         }
 
-        /// <summary>Get <see cref="double"/> from <see cref="SpecificEnergy"/> * <see cref="BrakeSpecificFuelConsumption"/>.</summary>
-        public static double operator *(SpecificEnergy specificEnergy, BrakeSpecificFuelConsumption brakeSpecificFuelConsumption)
-        {
-            return specificEnergy.JoulesPerKilogram * brakeSpecificFuelConsumption.KilogramsPerJoule;
-        }
-
         #endregion
 
         #region Equality / IComparable
@@ -1006,97 +981,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(SpecificEnergy left, SpecificEnergy right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(SpecificEnergy left, SpecificEnergy right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(SpecificEnergy left, SpecificEnergy right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(SpecificEnergy left, SpecificEnergy right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="SpecificEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SpecificEnergy other, SpecificEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SpecificEnergy"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(SpecificEnergy)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(SpecificEnergy left, SpecificEnergy right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="SpecificEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SpecificEnergy other, SpecificEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SpecificEnergy"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(SpecificEnergy,SpecificEnergy)"/>.
+        ///     See that operator (and <see cref="Equals(SpecificEnergy)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(SpecificEnergy left, SpecificEnergy right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SpecificEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SpecificEnergy other, SpecificEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="SpecificEnergy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="SpecificEnergy"/>.
+        ///     When <paramref name="obj"/> is a <see cref="SpecificEnergy"/>, this method delegates to
+        ///     <see cref="Equals(SpecificEnergy)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is SpecificEnergy otherQuantity))
+            if (obj is not SpecificEnergy otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SpecificEnergy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SpecificEnergy other, SpecificEnergy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="SpecificEnergy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(SpecificEnergy other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current SpecificEnergy.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(SpecificEnergy), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="SpecificEnergy"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(SpecificEnergy)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is SpecificEnergy otherQuantity)) throw new ArgumentException("Expected type SpecificEnergy.", nameof(obj));
+            if (obj is not SpecificEnergy otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<SpecificEnergy>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="SpecificEnergy"/> with another <see cref="SpecificEnergy"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="SpecificEnergy"/> with another <see cref="SpecificEnergy"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1108,187 +1097,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(SpecificEnergy other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpecificEnergyUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<SpecificEnergyUnit>());
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this SpecificEnergy to another SpecificEnergy with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A SpecificEnergy with the specified unit.</returns>
-        public SpecificEnergy ToUnit(SpecificEnergyUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="SpecificEnergy"/> to another <see cref="SpecificEnergy"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A SpecificEnergy with the specified unit.</returns>
-        public SpecificEnergy ToUnit(SpecificEnergyUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(SpecificEnergy), Unit, typeof(SpecificEnergy), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (SpecificEnergy)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="SpecificEnergy"/> to another <see cref="SpecificEnergy"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="SpecificEnergy"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(SpecificEnergyUnit unit, [NotNullWhen(true)] out SpecificEnergy? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            SpecificEnergy? convertedOrNull = (Unit, unit) switch
-            {
-                // SpecificEnergyUnit -> BaseUnit
-                (SpecificEnergyUnit.BtuPerPound, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy(_value * 1055.05585262 / 0.45359237, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.CaloriePerGram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy(_value * 4.184e3, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.GigawattDayPerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * (24 * 3.6e3)) * 1e9d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.GigawattDayPerShortTon, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * ((24 * 3.6e3) / 9.0718474e2)) * 1e9d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.GigawattDayPerTonne, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * ((24 * 3.6e3) / 1e3)) * 1e9d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.GigawattHourPerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * 3.6e3) * 1e9d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.GigawattHourPerPound, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * 7.93664e3) * 1e9d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.KilocaloriePerGram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * 4.184e3) * 1e3d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.KilojoulePerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value) * 1e3d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.KilowattDayPerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * (24 * 3.6e3)) * 1e3d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.KilowattDayPerShortTon, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * ((24 * 3.6e3) / 9.0718474e2)) * 1e3d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.KilowattDayPerTonne, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * ((24 * 3.6e3) / 1e3)) * 1e3d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.KilowattHourPerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * 3.6e3) * 1e3d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.KilowattHourPerPound, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * 7.93664e3) * 1e3d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.MegajoulePerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value) * 1e6d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.MegajoulePerTonne, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy(_value * 1e3, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.MegawattDayPerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * (24 * 3.6e3)) * 1e6d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.MegawattDayPerShortTon, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * ((24 * 3.6e3) / 9.0718474e2)) * 1e6d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.MegawattDayPerTonne, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * ((24 * 3.6e3) / 1e3)) * 1e6d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.MegawattHourPerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * 3.6e3) * 1e6d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.MegawattHourPerPound, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * 7.93664e3) * 1e6d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.TerawattDayPerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * (24 * 3.6e3)) * 1e12d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.TerawattDayPerShortTon, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * ((24 * 3.6e3) / 9.0718474e2)) * 1e12d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.TerawattDayPerTonne, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy((_value * ((24 * 3.6e3) / 1e3)) * 1e12d, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.WattDayPerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy(_value * (24 * 3.6e3), SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.WattDayPerShortTon, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy(_value * ((24 * 3.6e3) / 9.0718474e2), SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.WattDayPerTonne, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy(_value * ((24 * 3.6e3) / 1e3), SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.WattHourPerKilogram, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy(_value * 3.6e3, SpecificEnergyUnit.JoulePerKilogram),
-                (SpecificEnergyUnit.WattHourPerPound, SpecificEnergyUnit.JoulePerKilogram) => new SpecificEnergy(_value * 7.93664e3, SpecificEnergyUnit.JoulePerKilogram),
-
-                // BaseUnit -> SpecificEnergyUnit
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.BtuPerPound) => new SpecificEnergy(_value * 0.45359237 / 1055.05585262, SpecificEnergyUnit.BtuPerPound),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.CaloriePerGram) => new SpecificEnergy(_value / 4.184e3, SpecificEnergyUnit.CaloriePerGram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.GigawattDayPerKilogram) => new SpecificEnergy((_value / (24 * 3.6e3)) / 1e9d, SpecificEnergyUnit.GigawattDayPerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.GigawattDayPerShortTon) => new SpecificEnergy((_value / ((24 * 3.6e3) / 9.0718474e2)) / 1e9d, SpecificEnergyUnit.GigawattDayPerShortTon),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.GigawattDayPerTonne) => new SpecificEnergy((_value / ((24 * 3.6e3) / 1e3)) / 1e9d, SpecificEnergyUnit.GigawattDayPerTonne),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.GigawattHourPerKilogram) => new SpecificEnergy((_value / 3.6e3) / 1e9d, SpecificEnergyUnit.GigawattHourPerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.GigawattHourPerPound) => new SpecificEnergy((_value / 7.93664e3) / 1e9d, SpecificEnergyUnit.GigawattHourPerPound),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilocaloriePerGram) => new SpecificEnergy((_value / 4.184e3) / 1e3d, SpecificEnergyUnit.KilocaloriePerGram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilojoulePerKilogram) => new SpecificEnergy((_value) / 1e3d, SpecificEnergyUnit.KilojoulePerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilowattDayPerKilogram) => new SpecificEnergy((_value / (24 * 3.6e3)) / 1e3d, SpecificEnergyUnit.KilowattDayPerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilowattDayPerShortTon) => new SpecificEnergy((_value / ((24 * 3.6e3) / 9.0718474e2)) / 1e3d, SpecificEnergyUnit.KilowattDayPerShortTon),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilowattDayPerTonne) => new SpecificEnergy((_value / ((24 * 3.6e3) / 1e3)) / 1e3d, SpecificEnergyUnit.KilowattDayPerTonne),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilowattHourPerKilogram) => new SpecificEnergy((_value / 3.6e3) / 1e3d, SpecificEnergyUnit.KilowattHourPerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.KilowattHourPerPound) => new SpecificEnergy((_value / 7.93664e3) / 1e3d, SpecificEnergyUnit.KilowattHourPerPound),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegajoulePerKilogram) => new SpecificEnergy((_value) / 1e6d, SpecificEnergyUnit.MegajoulePerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegajoulePerTonne) => new SpecificEnergy(_value / 1e3, SpecificEnergyUnit.MegajoulePerTonne),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegawattDayPerKilogram) => new SpecificEnergy((_value / (24 * 3.6e3)) / 1e6d, SpecificEnergyUnit.MegawattDayPerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegawattDayPerShortTon) => new SpecificEnergy((_value / ((24 * 3.6e3) / 9.0718474e2)) / 1e6d, SpecificEnergyUnit.MegawattDayPerShortTon),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegawattDayPerTonne) => new SpecificEnergy((_value / ((24 * 3.6e3) / 1e3)) / 1e6d, SpecificEnergyUnit.MegawattDayPerTonne),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegawattHourPerKilogram) => new SpecificEnergy((_value / 3.6e3) / 1e6d, SpecificEnergyUnit.MegawattHourPerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.MegawattHourPerPound) => new SpecificEnergy((_value / 7.93664e3) / 1e6d, SpecificEnergyUnit.MegawattHourPerPound),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.TerawattDayPerKilogram) => new SpecificEnergy((_value / (24 * 3.6e3)) / 1e12d, SpecificEnergyUnit.TerawattDayPerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.TerawattDayPerShortTon) => new SpecificEnergy((_value / ((24 * 3.6e3) / 9.0718474e2)) / 1e12d, SpecificEnergyUnit.TerawattDayPerShortTon),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.TerawattDayPerTonne) => new SpecificEnergy((_value / ((24 * 3.6e3) / 1e3)) / 1e12d, SpecificEnergyUnit.TerawattDayPerTonne),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.WattDayPerKilogram) => new SpecificEnergy(_value / (24 * 3.6e3), SpecificEnergyUnit.WattDayPerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.WattDayPerShortTon) => new SpecificEnergy(_value / ((24 * 3.6e3) / 9.0718474e2), SpecificEnergyUnit.WattDayPerShortTon),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.WattDayPerTonne) => new SpecificEnergy(_value / ((24 * 3.6e3) / 1e3), SpecificEnergyUnit.WattDayPerTonne),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.WattHourPerKilogram) => new SpecificEnergy(_value / 3.6e3, SpecificEnergyUnit.WattHourPerKilogram),
-                (SpecificEnergyUnit.JoulePerKilogram, SpecificEnergyUnit.WattHourPerPound) => new SpecificEnergy(_value / 7.93664e3, SpecificEnergyUnit.WattHourPerPound),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not SpecificEnergyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEnergyUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is SpecificEnergyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEnergyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<SpecificEnergyUnit> IQuantity<SpecificEnergyUnit>.ToUnit(SpecificEnergyUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1302,11 +1113,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
index 97c2ee7c4c..2cbc4c1091 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Specific entropy is an amount of energy required to raise temperature of a substance by 1 Kelvin per unit mass.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct SpecificEntropy :
-        IArithmeticQuantity<SpecificEntropy, SpecificEntropyUnit>,
+        ILinearQuantity<SpecificEntropy, SpecificEntropyUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<SpecificEntropy, SpecificEntropy, double>,
+        IDivisionOperators<SpecificEntropy, SpecificEntropy, QuantityValue>,
         IMultiplyOperators<SpecificEntropy, Mass, Entropy>,
         IMultiplyOperators<SpecificEntropy, TemperatureDelta, SpecificEnergy>,
         IComparisonOperators<SpecificEntropy, SpecificEntropy, bool>,
@@ -54,7 +53,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -104,7 +103,7 @@ public static SpecificEntropyInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="SpecificEntropy"/> is [T^-2][L^2][Θ^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="SpecificEntropy"/> is T^-2L^2Θ^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 0, -2, 0, -1, 0, 0);
 
@@ -119,23 +118,37 @@ public static SpecificEntropyInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{SpecificEntropyUnit}"/> representing the default unit mappings for SpecificEntropy.</returns>
             public static IEnumerable<UnitDefinition<SpecificEntropyUnit>> GetDefaultMappings()
             {
-                yield return new (SpecificEntropyUnit.BtuPerPoundFahrenheit, "BtuPerPoundFahrenheit", "BtusPerPoundFahrenheit", BaseUnits.Undefined);
-                yield return new (SpecificEntropyUnit.CaloriePerGramKelvin, "CaloriePerGramKelvin", "CaloriesPerGramKelvin", BaseUnits.Undefined);
-                yield return new (SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, "JoulePerKilogramDegreeCelsius", "JoulesPerKilogramDegreeCelsius", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius));
+                yield return new (SpecificEntropyUnit.BtuPerPoundFahrenheit, "BtuPerPoundFahrenheit", "BtusPerPoundFahrenheit", BaseUnits.Undefined,
+                     new QuantityValue(5, 20934)
+                );
+                yield return new (SpecificEntropyUnit.CaloriePerGramKelvin, "CaloriePerGramKelvin", "CaloriesPerGramKelvin", BaseUnits.Undefined,
+                     new QuantityValue(1, 4184)
+                );
+                yield return new (SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, "JoulePerKilogramDegreeCelsius", "JoulesPerKilogramDegreeCelsius", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius),
+                     1
+                );
                 yield return new (SpecificEntropyUnit.JoulePerKilogramKelvin, "JoulePerKilogramKelvin", "JoulesPerKilogramKelvin", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
-                yield return new (SpecificEntropyUnit.KilocaloriePerGramKelvin, "KilocaloriePerGramKelvin", "KilocaloriesPerGramKelvin", BaseUnits.Undefined);
-                yield return new (SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, "KilojoulePerKilogramDegreeCelsius", "KilojoulesPerKilogramDegreeCelsius", BaseUnits.Undefined);
-                yield return new (SpecificEntropyUnit.KilojoulePerKilogramKelvin, "KilojoulePerKilogramKelvin", "KilojoulesPerKilogramKelvin", BaseUnits.Undefined);
-                yield return new (SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, "MegajoulePerKilogramDegreeCelsius", "MegajoulesPerKilogramDegreeCelsius", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (SpecificEntropyUnit.MegajoulePerKilogramKelvin, "MegajoulePerKilogramKelvin", "MegajoulesPerKilogramKelvin", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
+                yield return new (SpecificEntropyUnit.KilocaloriePerGramKelvin, "KilocaloriePerGramKelvin", "KilocaloriesPerGramKelvin", BaseUnits.Undefined,
+                     new QuantityValue(1, 4184000)
+                );
+                yield return new (SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, "KilojoulePerKilogramDegreeCelsius", "KilojoulesPerKilogramDegreeCelsius", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (SpecificEntropyUnit.KilojoulePerKilogramKelvin, "KilojoulePerKilogramKelvin", "KilojoulesPerKilogramKelvin", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, "MegajoulePerKilogramDegreeCelsius", "MegajoulesPerKilogramDegreeCelsius", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (SpecificEntropyUnit.MegajoulePerKilogramKelvin, "MegajoulePerKilogramKelvin", "MegajoulesPerKilogramKelvin", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin),
+                     new QuantityValue(1, 1000000)
+                );
             }
         }
 
         static SpecificEntropy()
         {
-            Info = SpecificEntropyInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(SpecificEntropyInfo.CreateDefault);
         }
 
         /// <summary>
@@ -143,7 +156,7 @@ static SpecificEntropy()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SpecificEntropy(double value, SpecificEntropyUnit unit)
+        public SpecificEntropy(QuantityValue value, SpecificEntropyUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -157,7 +170,7 @@ public SpecificEntropy(double value, SpecificEntropyUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public SpecificEntropy(double value, UnitSystem unitSystem)
+        public SpecificEntropy(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -168,7 +181,8 @@ public SpecificEntropy(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="SpecificEntropy" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<SpecificEntropy, SpecificEntropyUnit> Info { get; }
@@ -197,10 +211,8 @@ public SpecificEntropy(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public SpecificEntropyUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -234,84 +246,54 @@ public SpecificEntropy(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.BtuPerPoundFahrenheit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEntropyUnit.BtuPerPoundFahrenheit"/>
         /// </summary>
-        public double BtusPerPoundFahrenheit => As(SpecificEntropyUnit.BtuPerPoundFahrenheit);
+        public QuantityValue BtusPerPoundFahrenheit => this.As(SpecificEntropyUnit.BtuPerPoundFahrenheit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.CaloriePerGramKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEntropyUnit.CaloriePerGramKelvin"/>
         /// </summary>
-        public double CaloriesPerGramKelvin => As(SpecificEntropyUnit.CaloriePerGramKelvin);
+        public QuantityValue CaloriesPerGramKelvin => this.As(SpecificEntropyUnit.CaloriePerGramKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.JoulePerKilogramDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEntropyUnit.JoulePerKilogramDegreeCelsius"/>
         /// </summary>
-        public double JoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
+        public QuantityValue JoulesPerKilogramDegreeCelsius => this.As(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.JoulePerKilogramKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEntropyUnit.JoulePerKilogramKelvin"/>
         /// </summary>
-        public double JoulesPerKilogramKelvin => As(SpecificEntropyUnit.JoulePerKilogramKelvin);
+        public QuantityValue JoulesPerKilogramKelvin => this.As(SpecificEntropyUnit.JoulePerKilogramKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.KilocaloriePerGramKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEntropyUnit.KilocaloriePerGramKelvin"/>
         /// </summary>
-        public double KilocaloriesPerGramKelvin => As(SpecificEntropyUnit.KilocaloriePerGramKelvin);
+        public QuantityValue KilocaloriesPerGramKelvin => this.As(SpecificEntropyUnit.KilocaloriePerGramKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius"/>
         /// </summary>
-        public double KilojoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
+        public QuantityValue KilojoulesPerKilogramDegreeCelsius => this.As(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.KilojoulePerKilogramKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEntropyUnit.KilojoulePerKilogramKelvin"/>
         /// </summary>
-        public double KilojoulesPerKilogramKelvin => As(SpecificEntropyUnit.KilojoulePerKilogramKelvin);
+        public QuantityValue KilojoulesPerKilogramKelvin => this.As(SpecificEntropyUnit.KilojoulePerKilogramKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius"/>
         /// </summary>
-        public double MegajoulesPerKilogramDegreeCelsius => As(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
+        public QuantityValue MegajoulesPerKilogramDegreeCelsius => this.As(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificEntropyUnit.MegajoulePerKilogramKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificEntropyUnit.MegajoulePerKilogramKelvin"/>
         /// </summary>
-        public double MegajoulesPerKilogramKelvin => As(SpecificEntropyUnit.MegajoulePerKilogramKelvin);
+        public QuantityValue MegajoulesPerKilogramKelvin => this.As(SpecificEntropyUnit.MegajoulePerKilogramKelvin);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: SpecificEntropyUnit -> BaseUnit
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.BtuPerPoundFahrenheit, SpecificEntropyUnit.JoulePerKilogramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.JoulePerKilogramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.CaloriePerGramKelvin, SpecificEntropyUnit.JoulePerKilogramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.JoulePerKilogramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, SpecificEntropyUnit.JoulePerKilogramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.JoulePerKilogramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.KilocaloriePerGramKelvin, SpecificEntropyUnit.JoulePerKilogramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.JoulePerKilogramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, SpecificEntropyUnit.JoulePerKilogramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.JoulePerKilogramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.KilojoulePerKilogramKelvin, SpecificEntropyUnit.JoulePerKilogramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.JoulePerKilogramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, SpecificEntropyUnit.JoulePerKilogramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.JoulePerKilogramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.MegajoulePerKilogramKelvin, SpecificEntropyUnit.JoulePerKilogramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.JoulePerKilogramKelvin));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.JoulePerKilogramKelvin, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> SpecificEntropyUnit
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.BtuPerPoundFahrenheit, quantity => quantity.ToUnit(SpecificEntropyUnit.BtuPerPoundFahrenheit));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.CaloriePerGramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.CaloriePerGramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, quantity => quantity.ToUnit(SpecificEntropyUnit.JoulePerKilogramDegreeCelsius));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.KilocaloriePerGramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.KilocaloriePerGramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, quantity => quantity.ToUnit(SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.KilojoulePerKilogramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.KilojoulePerKilogramKelvin));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, quantity => quantity.ToUnit(SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius));
-            unitConverter.SetConversionFunction<SpecificEntropy>(SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.MegajoulePerKilogramKelvin, quantity => quantity.ToUnit(SpecificEntropyUnit.MegajoulePerKilogramKelvin));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -340,7 +322,7 @@ public static string GetAbbreviation(SpecificEntropyUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.BtuPerPoundFahrenheit"/>.
         /// </summary>
-        public static SpecificEntropy FromBtusPerPoundFahrenheit(double value)
+        public static SpecificEntropy FromBtusPerPoundFahrenheit(QuantityValue value)
         {
             return new SpecificEntropy(value, SpecificEntropyUnit.BtuPerPoundFahrenheit);
         }
@@ -348,7 +330,7 @@ public static SpecificEntropy FromBtusPerPoundFahrenheit(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.CaloriePerGramKelvin"/>.
         /// </summary>
-        public static SpecificEntropy FromCaloriesPerGramKelvin(double value)
+        public static SpecificEntropy FromCaloriesPerGramKelvin(QuantityValue value)
         {
             return new SpecificEntropy(value, SpecificEntropyUnit.CaloriePerGramKelvin);
         }
@@ -356,7 +338,7 @@ public static SpecificEntropy FromCaloriesPerGramKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.JoulePerKilogramDegreeCelsius"/>.
         /// </summary>
-        public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(double value)
+        public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(QuantityValue value)
         {
             return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
         }
@@ -364,7 +346,7 @@ public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.JoulePerKilogramKelvin"/>.
         /// </summary>
-        public static SpecificEntropy FromJoulesPerKilogramKelvin(double value)
+        public static SpecificEntropy FromJoulesPerKilogramKelvin(QuantityValue value)
         {
             return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramKelvin);
         }
@@ -372,7 +354,7 @@ public static SpecificEntropy FromJoulesPerKilogramKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilocaloriePerGramKelvin"/>.
         /// </summary>
-        public static SpecificEntropy FromKilocaloriesPerGramKelvin(double value)
+        public static SpecificEntropy FromKilocaloriesPerGramKelvin(QuantityValue value)
         {
             return new SpecificEntropy(value, SpecificEntropyUnit.KilocaloriePerGramKelvin);
         }
@@ -380,7 +362,7 @@ public static SpecificEntropy FromKilocaloriesPerGramKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius"/>.
         /// </summary>
-        public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(double value)
+        public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(QuantityValue value)
         {
             return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
         }
@@ -388,7 +370,7 @@ public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(double valu
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilojoulePerKilogramKelvin"/>.
         /// </summary>
-        public static SpecificEntropy FromKilojoulesPerKilogramKelvin(double value)
+        public static SpecificEntropy FromKilojoulesPerKilogramKelvin(QuantityValue value)
         {
             return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramKelvin);
         }
@@ -396,7 +378,7 @@ public static SpecificEntropy FromKilojoulesPerKilogramKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius"/>.
         /// </summary>
-        public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(double value)
+        public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(QuantityValue value)
         {
             return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
         }
@@ -404,7 +386,7 @@ public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(double valu
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.MegajoulePerKilogramKelvin"/>.
         /// </summary>
-        public static SpecificEntropy FromMegajoulesPerKilogramKelvin(double value)
+        public static SpecificEntropy FromMegajoulesPerKilogramKelvin(QuantityValue value)
         {
             return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramKelvin);
         }
@@ -415,7 +397,7 @@ public static SpecificEntropy FromMegajoulesPerKilogramKelvin(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SpecificEntropy unit value.</returns>
-        public static SpecificEntropy From(double value, SpecificEntropyUnit fromUnit)
+        public static SpecificEntropy From(QuantityValue value, SpecificEntropyUnit fromUnit)
         {
             return new SpecificEntropy(value, fromUnit);
         }
@@ -476,10 +458,7 @@ public static SpecificEntropy Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static SpecificEntropy Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<SpecificEntropy, SpecificEntropyUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<SpecificEntropy, SpecificEntropyUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -507,11 +486,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out SpecificEntropy
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpecificEntropy result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<SpecificEntropy, SpecificEntropyUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<SpecificEntropy, SpecificEntropyUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -532,7 +507,7 @@ public static SpecificEntropyUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -543,7 +518,7 @@ public static SpecificEntropyUnit ParseUnit(string str, IFormatProvider? provide
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpecificEntropyUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.SpecificEntropyUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificEntropyUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -558,7 +533,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificEntr
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpecificEntropyUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -577,35 +552,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="SpecificEntropy"/> from adding two <see cref="SpecificEntropy"/>.</summary>
         public static SpecificEntropy operator +(SpecificEntropy left, SpecificEntropy right)
         {
-            return new SpecificEntropy(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new SpecificEntropy(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificEntropy"/> from subtracting two <see cref="SpecificEntropy"/>.</summary>
         public static SpecificEntropy operator -(SpecificEntropy left, SpecificEntropy right)
         {
-            return new SpecificEntropy(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new SpecificEntropy(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificEntropy"/> from multiplying value and <see cref="SpecificEntropy"/>.</summary>
-        public static SpecificEntropy operator *(double left, SpecificEntropy right)
+        public static SpecificEntropy operator *(QuantityValue left, SpecificEntropy right)
         {
             return new SpecificEntropy(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="SpecificEntropy"/> from multiplying value and <see cref="SpecificEntropy"/>.</summary>
-        public static SpecificEntropy operator *(SpecificEntropy left, double right)
+        public static SpecificEntropy operator *(SpecificEntropy left, QuantityValue right)
         {
             return new SpecificEntropy(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificEntropy"/> from dividing <see cref="SpecificEntropy"/> by value.</summary>
-        public static SpecificEntropy operator /(SpecificEntropy left, double right)
+        public static SpecificEntropy operator /(SpecificEntropy left, QuantityValue right)
         {
             return new SpecificEntropy(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="SpecificEntropy"/> by <see cref="SpecificEntropy"/>.</summary>
-        public static double operator /(SpecificEntropy left, SpecificEntropy right)
+        public static QuantityValue operator /(SpecificEntropy left, SpecificEntropy right)
         {
             return left.JoulesPerKilogramKelvin / right.JoulesPerKilogramKelvin;
         }
@@ -633,97 +608,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(SpecificEntropy left, SpecificEntropy right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(SpecificEntropy left, SpecificEntropy right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(SpecificEntropy left, SpecificEntropy right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(SpecificEntropy left, SpecificEntropy right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="SpecificEntropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SpecificEntropy other, SpecificEntropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SpecificEntropy"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(SpecificEntropy)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(SpecificEntropy left, SpecificEntropy right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="SpecificEntropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SpecificEntropy other, SpecificEntropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SpecificEntropy"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(SpecificEntropy,SpecificEntropy)"/>.
+        ///     See that operator (and <see cref="Equals(SpecificEntropy)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(SpecificEntropy left, SpecificEntropy right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SpecificEntropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SpecificEntropy other, SpecificEntropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="SpecificEntropy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="SpecificEntropy"/>.
+        ///     When <paramref name="obj"/> is a <see cref="SpecificEntropy"/>, this method delegates to
+        ///     <see cref="Equals(SpecificEntropy)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is SpecificEntropy otherQuantity))
+            if (obj is not SpecificEntropy otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SpecificEntropy"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SpecificEntropy other, SpecificEntropy tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="SpecificEntropy"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(SpecificEntropy other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current SpecificEntropy.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(SpecificEntropy), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="SpecificEntropy"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(SpecificEntropy)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is SpecificEntropy otherQuantity)) throw new ArgumentException("Expected type SpecificEntropy.", nameof(obj));
+            if (obj is not SpecificEntropy otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<SpecificEntropy>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="SpecificEntropy"/> with another <see cref="SpecificEntropy"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="SpecificEntropy"/> with another <see cref="SpecificEntropy"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -735,145 +724,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(SpecificEntropy other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpecificEntropyUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<SpecificEntropyUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this SpecificEntropy to another SpecificEntropy with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A SpecificEntropy with the specified unit.</returns>
-        public SpecificEntropy ToUnit(SpecificEntropyUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="SpecificEntropy"/> to another <see cref="SpecificEntropy"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A SpecificEntropy with the specified unit.</returns>
-        public SpecificEntropy ToUnit(SpecificEntropyUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(SpecificEntropy), Unit, typeof(SpecificEntropy), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (SpecificEntropy)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="SpecificEntropy"/> to another <see cref="SpecificEntropy"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="SpecificEntropy"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(SpecificEntropyUnit unit, [NotNullWhen(true)] out SpecificEntropy? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            SpecificEntropy? convertedOrNull = (Unit, unit) switch
-            {
-                // SpecificEntropyUnit -> BaseUnit
-                (SpecificEntropyUnit.BtuPerPoundFahrenheit, SpecificEntropyUnit.JoulePerKilogramKelvin) => new SpecificEntropy(_value * 4.1868e3, SpecificEntropyUnit.JoulePerKilogramKelvin),
-                (SpecificEntropyUnit.CaloriePerGramKelvin, SpecificEntropyUnit.JoulePerKilogramKelvin) => new SpecificEntropy(_value * 4.184e3, SpecificEntropyUnit.JoulePerKilogramKelvin),
-                (SpecificEntropyUnit.JoulePerKilogramDegreeCelsius, SpecificEntropyUnit.JoulePerKilogramKelvin) => new SpecificEntropy(_value, SpecificEntropyUnit.JoulePerKilogramKelvin),
-                (SpecificEntropyUnit.KilocaloriePerGramKelvin, SpecificEntropyUnit.JoulePerKilogramKelvin) => new SpecificEntropy((_value * 4.184e3) * 1e3d, SpecificEntropyUnit.JoulePerKilogramKelvin),
-                (SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius, SpecificEntropyUnit.JoulePerKilogramKelvin) => new SpecificEntropy((_value) * 1e3d, SpecificEntropyUnit.JoulePerKilogramKelvin),
-                (SpecificEntropyUnit.KilojoulePerKilogramKelvin, SpecificEntropyUnit.JoulePerKilogramKelvin) => new SpecificEntropy((_value) * 1e3d, SpecificEntropyUnit.JoulePerKilogramKelvin),
-                (SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius, SpecificEntropyUnit.JoulePerKilogramKelvin) => new SpecificEntropy((_value) * 1e6d, SpecificEntropyUnit.JoulePerKilogramKelvin),
-                (SpecificEntropyUnit.MegajoulePerKilogramKelvin, SpecificEntropyUnit.JoulePerKilogramKelvin) => new SpecificEntropy((_value) * 1e6d, SpecificEntropyUnit.JoulePerKilogramKelvin),
-
-                // BaseUnit -> SpecificEntropyUnit
-                (SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.BtuPerPoundFahrenheit) => new SpecificEntropy(_value / 4.1868e3, SpecificEntropyUnit.BtuPerPoundFahrenheit),
-                (SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.CaloriePerGramKelvin) => new SpecificEntropy(_value / 4.184e3, SpecificEntropyUnit.CaloriePerGramKelvin),
-                (SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius) => new SpecificEntropy(_value, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius),
-                (SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.KilocaloriePerGramKelvin) => new SpecificEntropy((_value / 4.184e3) / 1e3d, SpecificEntropyUnit.KilocaloriePerGramKelvin),
-                (SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius) => new SpecificEntropy((_value) / 1e3d, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius),
-                (SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.KilojoulePerKilogramKelvin) => new SpecificEntropy((_value) / 1e3d, SpecificEntropyUnit.KilojoulePerKilogramKelvin),
-                (SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius) => new SpecificEntropy((_value) / 1e6d, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius),
-                (SpecificEntropyUnit.JoulePerKilogramKelvin, SpecificEntropyUnit.MegajoulePerKilogramKelvin) => new SpecificEntropy((_value) / 1e6d, SpecificEntropyUnit.MegajoulePerKilogramKelvin),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not SpecificEntropyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEntropyUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is SpecificEntropyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEntropyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<SpecificEntropyUnit> IQuantity<SpecificEntropyUnit>.ToUnit(SpecificEntropyUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -887,11 +740,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
index 0bbf00f424..fd474a2463 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Thrust-specific_fuel_consumption
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct SpecificFuelConsumption :
-        IArithmeticQuantity<SpecificFuelConsumption, SpecificFuelConsumptionUnit>,
+        ILinearQuantity<SpecificFuelConsumption, SpecificFuelConsumptionUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<SpecificFuelConsumption, SpecificFuelConsumption, double>,
+        IDivisionOperators<SpecificFuelConsumption, SpecificFuelConsumption, QuantityValue>,
         IComparisonOperators<SpecificFuelConsumption, SpecificFuelConsumption, bool>,
         IParsable<SpecificFuelConsumption>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static SpecificFuelConsumptionInfo CreateDefault(Func<IEnumerable<UnitDef
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="SpecificFuelConsumption"/> is [T][L^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="SpecificFuelConsumption"/> is TL^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 0, 1, 0, 0, 0, 0);
 
@@ -121,17 +120,21 @@ public static SpecificFuelConsumptionInfo CreateDefault(Func<IEnumerable<UnitDef
             public static IEnumerable<UnitDefinition<SpecificFuelConsumptionUnit>> GetDefaultMappings()
             {
                 yield return new (SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, "GramPerKilonewtonSecond", "GramsPerKilonewtonSecond", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour, "KilogramPerKilogramForceHour", "KilogramsPerKilogramForceHour", BaseUnits.Undefined);
-                yield return new (SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond, "KilogramPerKilonewtonSecond", "KilogramsPerKilonewtonSecond", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second));
-                yield return new (SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour, "PoundMassPerPoundForceHour", "PoundsMassPerPoundForceHour", BaseUnits.Undefined);
+                yield return new (SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour, "KilogramPerKilogramForceHour", "KilogramsPerKilogramForceHour", BaseUnits.Undefined,
+                     new QuantityValue(1765197, 50000000)
+                );
+                yield return new (SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond, "KilogramPerKilonewtonSecond", "KilogramsPerKilonewtonSecond", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour, "PoundMassPerPoundForceHour", "PoundsMassPerPoundForceHour", BaseUnits.Undefined,
+                     new QuantityValue(1765197, 50000000)
+                );
             }
         }
 
         static SpecificFuelConsumption()
         {
-            Info = SpecificFuelConsumptionInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(SpecificFuelConsumptionInfo.CreateDefault);
         }
 
         /// <summary>
@@ -139,7 +142,7 @@ static SpecificFuelConsumption()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SpecificFuelConsumption(double value, SpecificFuelConsumptionUnit unit)
+        public SpecificFuelConsumption(QuantityValue value, SpecificFuelConsumptionUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -153,7 +156,7 @@ public SpecificFuelConsumption(double value, SpecificFuelConsumptionUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public SpecificFuelConsumption(double value, UnitSystem unitSystem)
+        public SpecificFuelConsumption(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -164,7 +167,8 @@ public SpecificFuelConsumption(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="SpecificFuelConsumption" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<SpecificFuelConsumption, SpecificFuelConsumptionUnit> Info { get; }
@@ -193,10 +197,8 @@ public SpecificFuelConsumption(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public SpecificFuelConsumptionUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -230,49 +232,29 @@ public SpecificFuelConsumption(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.GramPerKilonewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.GramPerKilonewtonSecond"/>
         /// </summary>
-        public double GramsPerKilonewtonSecond => As(SpecificFuelConsumptionUnit.GramPerKilonewtonSecond);
+        public QuantityValue GramsPerKilonewtonSecond => this.As(SpecificFuelConsumptionUnit.GramPerKilonewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour"/>
         /// </summary>
-        public double KilogramsPerKilogramForceHour => As(SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour);
+        public QuantityValue KilogramsPerKilogramForceHour => this.As(SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond"/>
         /// </summary>
-        public double KilogramsPerKilonewtonSecond => As(SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond);
+        public QuantityValue KilogramsPerKilonewtonSecond => this.As(SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour"/>
         /// </summary>
-        public double PoundsMassPerPoundForceHour => As(SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour);
+        public QuantityValue PoundsMassPerPoundForceHour => this.As(SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: SpecificFuelConsumptionUnit -> BaseUnit
-            unitConverter.SetConversionFunction<SpecificFuelConsumption>(SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, quantity => quantity.ToUnit(SpecificFuelConsumptionUnit.GramPerKilonewtonSecond));
-            unitConverter.SetConversionFunction<SpecificFuelConsumption>(SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, quantity => quantity.ToUnit(SpecificFuelConsumptionUnit.GramPerKilonewtonSecond));
-            unitConverter.SetConversionFunction<SpecificFuelConsumption>(SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, quantity => quantity.ToUnit(SpecificFuelConsumptionUnit.GramPerKilonewtonSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<SpecificFuelConsumption>(SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> SpecificFuelConsumptionUnit
-            unitConverter.SetConversionFunction<SpecificFuelConsumption>(SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour, quantity => quantity.ToUnit(SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour));
-            unitConverter.SetConversionFunction<SpecificFuelConsumption>(SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond, quantity => quantity.ToUnit(SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond));
-            unitConverter.SetConversionFunction<SpecificFuelConsumption>(SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour, quantity => quantity.ToUnit(SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -301,7 +283,7 @@ public static string GetAbbreviation(SpecificFuelConsumptionUnit unit, IFormatPr
         /// <summary>
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.GramPerKilonewtonSecond"/>.
         /// </summary>
-        public static SpecificFuelConsumption FromGramsPerKilonewtonSecond(double value)
+        public static SpecificFuelConsumption FromGramsPerKilonewtonSecond(QuantityValue value)
         {
             return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond);
         }
@@ -309,7 +291,7 @@ public static SpecificFuelConsumption FromGramsPerKilonewtonSecond(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour"/>.
         /// </summary>
-        public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(double value)
+        public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(QuantityValue value)
         {
             return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour);
         }
@@ -317,7 +299,7 @@ public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(double v
         /// <summary>
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond"/>.
         /// </summary>
-        public static SpecificFuelConsumption FromKilogramsPerKilonewtonSecond(double value)
+        public static SpecificFuelConsumption FromKilogramsPerKilonewtonSecond(QuantityValue value)
         {
             return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond);
         }
@@ -325,7 +307,7 @@ public static SpecificFuelConsumption FromKilogramsPerKilonewtonSecond(double va
         /// <summary>
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour"/>.
         /// </summary>
-        public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(double value)
+        public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(QuantityValue value)
         {
             return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour);
         }
@@ -336,7 +318,7 @@ public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(double val
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SpecificFuelConsumption unit value.</returns>
-        public static SpecificFuelConsumption From(double value, SpecificFuelConsumptionUnit fromUnit)
+        public static SpecificFuelConsumption From(QuantityValue value, SpecificFuelConsumptionUnit fromUnit)
         {
             return new SpecificFuelConsumption(value, fromUnit);
         }
@@ -397,10 +379,7 @@ public static SpecificFuelConsumption Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static SpecificFuelConsumption Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<SpecificFuelConsumption, SpecificFuelConsumptionUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<SpecificFuelConsumption, SpecificFuelConsumptionUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -428,11 +407,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out SpecificFuelCons
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpecificFuelConsumption result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<SpecificFuelConsumption, SpecificFuelConsumptionUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<SpecificFuelConsumption, SpecificFuelConsumptionUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -453,7 +428,7 @@ public static SpecificFuelConsumptionUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -464,7 +439,7 @@ public static SpecificFuelConsumptionUnit ParseUnit(string str, IFormatProvider?
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpecificFuelConsumptionUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.SpecificFuelConsumptionUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificFuelConsumptionUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -479,7 +454,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificFuel
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpecificFuelConsumptionUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -498,35 +473,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="SpecificFuelConsumption"/> from adding two <see cref="SpecificFuelConsumption"/>.</summary>
         public static SpecificFuelConsumption operator +(SpecificFuelConsumption left, SpecificFuelConsumption right)
         {
-            return new SpecificFuelConsumption(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new SpecificFuelConsumption(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificFuelConsumption"/> from subtracting two <see cref="SpecificFuelConsumption"/>.</summary>
         public static SpecificFuelConsumption operator -(SpecificFuelConsumption left, SpecificFuelConsumption right)
         {
-            return new SpecificFuelConsumption(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new SpecificFuelConsumption(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificFuelConsumption"/> from multiplying value and <see cref="SpecificFuelConsumption"/>.</summary>
-        public static SpecificFuelConsumption operator *(double left, SpecificFuelConsumption right)
+        public static SpecificFuelConsumption operator *(QuantityValue left, SpecificFuelConsumption right)
         {
             return new SpecificFuelConsumption(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="SpecificFuelConsumption"/> from multiplying value and <see cref="SpecificFuelConsumption"/>.</summary>
-        public static SpecificFuelConsumption operator *(SpecificFuelConsumption left, double right)
+        public static SpecificFuelConsumption operator *(SpecificFuelConsumption left, QuantityValue right)
         {
             return new SpecificFuelConsumption(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificFuelConsumption"/> from dividing <see cref="SpecificFuelConsumption"/> by value.</summary>
-        public static SpecificFuelConsumption operator /(SpecificFuelConsumption left, double right)
+        public static SpecificFuelConsumption operator /(SpecificFuelConsumption left, QuantityValue right)
         {
             return new SpecificFuelConsumption(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="SpecificFuelConsumption"/> by <see cref="SpecificFuelConsumption"/>.</summary>
-        public static double operator /(SpecificFuelConsumption left, SpecificFuelConsumption right)
+        public static QuantityValue operator /(SpecificFuelConsumption left, SpecificFuelConsumption right)
         {
             return left.GramsPerKilonewtonSecond / right.GramsPerKilonewtonSecond;
         }
@@ -538,97 +513,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(SpecificFuelConsumption left, SpecificFuelConsumption right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(SpecificFuelConsumption left, SpecificFuelConsumption right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(SpecificFuelConsumption left, SpecificFuelConsumption right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(SpecificFuelConsumption left, SpecificFuelConsumption right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="SpecificFuelConsumption"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SpecificFuelConsumption other, SpecificFuelConsumption tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SpecificFuelConsumption"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(SpecificFuelConsumption)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(SpecificFuelConsumption left, SpecificFuelConsumption right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="SpecificFuelConsumption"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SpecificFuelConsumption other, SpecificFuelConsumption tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SpecificFuelConsumption"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(SpecificFuelConsumption,SpecificFuelConsumption)"/>.
+        ///     See that operator (and <see cref="Equals(SpecificFuelConsumption)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(SpecificFuelConsumption left, SpecificFuelConsumption right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SpecificFuelConsumption"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SpecificFuelConsumption other, SpecificFuelConsumption tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="SpecificFuelConsumption"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="SpecificFuelConsumption"/>.
+        ///     When <paramref name="obj"/> is a <see cref="SpecificFuelConsumption"/>, this method delegates to
+        ///     <see cref="Equals(SpecificFuelConsumption)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is SpecificFuelConsumption otherQuantity))
+            if (obj is not SpecificFuelConsumption otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SpecificFuelConsumption"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SpecificFuelConsumption other, SpecificFuelConsumption tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="SpecificFuelConsumption"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(SpecificFuelConsumption other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current SpecificFuelConsumption.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(SpecificFuelConsumption), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="SpecificFuelConsumption"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(SpecificFuelConsumption)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is SpecificFuelConsumption otherQuantity)) throw new ArgumentException("Expected type SpecificFuelConsumption.", nameof(obj));
+            if (obj is not SpecificFuelConsumption otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<SpecificFuelConsumption>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="SpecificFuelConsumption"/> with another <see cref="SpecificFuelConsumption"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="SpecificFuelConsumption"/> with another <see cref="SpecificFuelConsumption"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -640,137 +629,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(SpecificFuelConsumption other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpecificFuelConsumptionUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<SpecificFuelConsumptionUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this SpecificFuelConsumption to another SpecificFuelConsumption with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A SpecificFuelConsumption with the specified unit.</returns>
-        public SpecificFuelConsumption ToUnit(SpecificFuelConsumptionUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="SpecificFuelConsumption"/> to another <see cref="SpecificFuelConsumption"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A SpecificFuelConsumption with the specified unit.</returns>
-        public SpecificFuelConsumption ToUnit(SpecificFuelConsumptionUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(SpecificFuelConsumption), Unit, typeof(SpecificFuelConsumption), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (SpecificFuelConsumption)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="SpecificFuelConsumption"/> to another <see cref="SpecificFuelConsumption"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="SpecificFuelConsumption"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(SpecificFuelConsumptionUnit unit, [NotNullWhen(true)] out SpecificFuelConsumption? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            SpecificFuelConsumption? convertedOrNull = (Unit, unit) switch
-            {
-                // SpecificFuelConsumptionUnit -> BaseUnit
-                (SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond) => new SpecificFuelConsumption(_value * 1000 / (9.80665e-3 * 3600), SpecificFuelConsumptionUnit.GramPerKilonewtonSecond),
-                (SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond) => new SpecificFuelConsumption((_value) * 1e3d, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond),
-                (SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour, SpecificFuelConsumptionUnit.GramPerKilonewtonSecond) => new SpecificFuelConsumption(_value * 1000 / (9.80665e-3 * 3600), SpecificFuelConsumptionUnit.GramPerKilonewtonSecond),
-
-                // BaseUnit -> SpecificFuelConsumptionUnit
-                (SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour) => new SpecificFuelConsumption(_value * 9.80665e-3 * 3600 / 1000, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour),
-                (SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond) => new SpecificFuelConsumption((_value) / 1e3d, SpecificFuelConsumptionUnit.KilogramPerKilonewtonSecond),
-                (SpecificFuelConsumptionUnit.GramPerKilonewtonSecond, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour) => new SpecificFuelConsumption(_value * 9.80665e-3 * 3600 / 1000, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not SpecificFuelConsumptionUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificFuelConsumptionUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is SpecificFuelConsumptionUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificFuelConsumptionUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<SpecificFuelConsumptionUnit> IQuantity<SpecificFuelConsumptionUnit>.ToUnit(SpecificFuelConsumptionUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -782,11 +645,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
index 7ef2f228ec..d6f636d4b5 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     In thermodynamics, the specific volume of a substance is the ratio of the substance's volume to its mass. It is the reciprocal of density and an intrinsic property of matter as well.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct SpecificVolume :
-        IArithmeticQuantity<SpecificVolume, SpecificVolumeUnit>,
+        ILinearQuantity<SpecificVolume, SpecificVolumeUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<SpecificVolume, SpecificVolume, double>,
+        IDivisionOperators<SpecificVolume, SpecificVolume, QuantityValue>,
         IMultiplyOperators<SpecificVolume, Mass, Volume>,
         IComparisonOperators<SpecificVolume, SpecificVolume, bool>,
         IParsable<SpecificVolume>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static SpecificVolumeInfo CreateDefault(Func<IEnumerable<UnitDefinition<S
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="SpecificVolume"/> is [L^3][M^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="SpecificVolume"/> is L^3M^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(3, -1, 0, 0, 0, 0, 0);
 
@@ -118,17 +117,19 @@ public static SpecificVolumeInfo CreateDefault(Func<IEnumerable<UnitDefinition<S
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{SpecificVolumeUnit}"/> representing the default unit mappings for SpecificVolume.</returns>
             public static IEnumerable<UnitDefinition<SpecificVolumeUnit>> GetDefaultMappings()
             {
-                yield return new (SpecificVolumeUnit.CubicFootPerPound, "CubicFootPerPound", "CubicFeetPerPound", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound));
+                yield return new (SpecificVolumeUnit.CubicFootPerPound, "CubicFootPerPound", "CubicFeetPerPound", new BaseUnits(length: LengthUnit.Foot, mass: MassUnit.Pound),
+                     new QuantityValue(28349523125, 1769802912)
+                );
                 yield return new (SpecificVolumeUnit.CubicMeterPerKilogram, "CubicMeterPerKilogram", "CubicMetersPerKilogram", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram));
-                yield return new (SpecificVolumeUnit.MillicubicMeterPerKilogram, "MillicubicMeterPerKilogram", "MillicubicMetersPerKilogram", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram));
+                yield return new (SpecificVolumeUnit.CubicMillimeterPerKilogram, "CubicMillimeterPerKilogram", "CubicMillimetersPerKilogram", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram),
+                     1000000000
+                );
             }
         }
 
         static SpecificVolume()
         {
-            Info = SpecificVolumeInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(SpecificVolumeInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +137,7 @@ static SpecificVolume()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SpecificVolume(double value, SpecificVolumeUnit unit)
+        public SpecificVolume(QuantityValue value, SpecificVolumeUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -150,7 +151,7 @@ public SpecificVolume(double value, SpecificVolumeUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public SpecificVolume(double value, UnitSystem unitSystem)
+        public SpecificVolume(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -161,7 +162,8 @@ public SpecificVolume(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="SpecificVolume" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<SpecificVolume, SpecificVolumeUnit> Info { get; }
@@ -190,10 +192,8 @@ public SpecificVolume(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public SpecificVolumeUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -227,42 +227,24 @@ public SpecificVolume(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificVolumeUnit.CubicFootPerPound"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificVolumeUnit.CubicFootPerPound"/>
         /// </summary>
-        public double CubicFeetPerPound => As(SpecificVolumeUnit.CubicFootPerPound);
+        public QuantityValue CubicFeetPerPound => this.As(SpecificVolumeUnit.CubicFootPerPound);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificVolumeUnit.CubicMeterPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificVolumeUnit.CubicMeterPerKilogram"/>
         /// </summary>
-        public double CubicMetersPerKilogram => As(SpecificVolumeUnit.CubicMeterPerKilogram);
+        public QuantityValue CubicMetersPerKilogram => this.As(SpecificVolumeUnit.CubicMeterPerKilogram);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificVolumeUnit.MillicubicMeterPerKilogram"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificVolumeUnit.CubicMillimeterPerKilogram"/>
         /// </summary>
-        public double MillicubicMetersPerKilogram => As(SpecificVolumeUnit.MillicubicMeterPerKilogram);
+        public QuantityValue CubicMillimetersPerKilogram => this.As(SpecificVolumeUnit.CubicMillimeterPerKilogram);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: SpecificVolumeUnit -> BaseUnit
-            unitConverter.SetConversionFunction<SpecificVolume>(SpecificVolumeUnit.CubicFootPerPound, SpecificVolumeUnit.CubicMeterPerKilogram, quantity => quantity.ToUnit(SpecificVolumeUnit.CubicMeterPerKilogram));
-            unitConverter.SetConversionFunction<SpecificVolume>(SpecificVolumeUnit.MillicubicMeterPerKilogram, SpecificVolumeUnit.CubicMeterPerKilogram, quantity => quantity.ToUnit(SpecificVolumeUnit.CubicMeterPerKilogram));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<SpecificVolume>(SpecificVolumeUnit.CubicMeterPerKilogram, SpecificVolumeUnit.CubicMeterPerKilogram, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> SpecificVolumeUnit
-            unitConverter.SetConversionFunction<SpecificVolume>(SpecificVolumeUnit.CubicMeterPerKilogram, SpecificVolumeUnit.CubicFootPerPound, quantity => quantity.ToUnit(SpecificVolumeUnit.CubicFootPerPound));
-            unitConverter.SetConversionFunction<SpecificVolume>(SpecificVolumeUnit.CubicMeterPerKilogram, SpecificVolumeUnit.MillicubicMeterPerKilogram, quantity => quantity.ToUnit(SpecificVolumeUnit.MillicubicMeterPerKilogram));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -291,7 +273,7 @@ public static string GetAbbreviation(SpecificVolumeUnit unit, IFormatProvider? p
         /// <summary>
         ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.CubicFootPerPound"/>.
         /// </summary>
-        public static SpecificVolume FromCubicFeetPerPound(double value)
+        public static SpecificVolume FromCubicFeetPerPound(QuantityValue value)
         {
             return new SpecificVolume(value, SpecificVolumeUnit.CubicFootPerPound);
         }
@@ -299,17 +281,17 @@ public static SpecificVolume FromCubicFeetPerPound(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.CubicMeterPerKilogram"/>.
         /// </summary>
-        public static SpecificVolume FromCubicMetersPerKilogram(double value)
+        public static SpecificVolume FromCubicMetersPerKilogram(QuantityValue value)
         {
             return new SpecificVolume(value, SpecificVolumeUnit.CubicMeterPerKilogram);
         }
 
         /// <summary>
-        ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.MillicubicMeterPerKilogram"/>.
+        ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.CubicMillimeterPerKilogram"/>.
         /// </summary>
-        public static SpecificVolume FromMillicubicMetersPerKilogram(double value)
+        public static SpecificVolume FromCubicMillimetersPerKilogram(QuantityValue value)
         {
-            return new SpecificVolume(value, SpecificVolumeUnit.MillicubicMeterPerKilogram);
+            return new SpecificVolume(value, SpecificVolumeUnit.CubicMillimeterPerKilogram);
         }
 
         /// <summary>
@@ -318,7 +300,7 @@ public static SpecificVolume FromMillicubicMetersPerKilogram(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SpecificVolume unit value.</returns>
-        public static SpecificVolume From(double value, SpecificVolumeUnit fromUnit)
+        public static SpecificVolume From(QuantityValue value, SpecificVolumeUnit fromUnit)
         {
             return new SpecificVolume(value, fromUnit);
         }
@@ -379,10 +361,7 @@ public static SpecificVolume Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static SpecificVolume Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<SpecificVolume, SpecificVolumeUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<SpecificVolume, SpecificVolumeUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -410,11 +389,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out SpecificVolume r
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpecificVolume result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<SpecificVolume, SpecificVolumeUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<SpecificVolume, SpecificVolumeUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -435,7 +410,7 @@ public static SpecificVolumeUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -446,7 +421,7 @@ public static SpecificVolumeUnit ParseUnit(string str, IFormatProvider? provider
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpecificVolumeUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.SpecificVolumeUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificVolumeUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -461,7 +436,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificVolu
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpecificVolumeUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -480,35 +455,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="SpecificVolume"/> from adding two <see cref="SpecificVolume"/>.</summary>
         public static SpecificVolume operator +(SpecificVolume left, SpecificVolume right)
         {
-            return new SpecificVolume(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new SpecificVolume(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificVolume"/> from subtracting two <see cref="SpecificVolume"/>.</summary>
         public static SpecificVolume operator -(SpecificVolume left, SpecificVolume right)
         {
-            return new SpecificVolume(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new SpecificVolume(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificVolume"/> from multiplying value and <see cref="SpecificVolume"/>.</summary>
-        public static SpecificVolume operator *(double left, SpecificVolume right)
+        public static SpecificVolume operator *(QuantityValue left, SpecificVolume right)
         {
             return new SpecificVolume(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="SpecificVolume"/> from multiplying value and <see cref="SpecificVolume"/>.</summary>
-        public static SpecificVolume operator *(SpecificVolume left, double right)
+        public static SpecificVolume operator *(SpecificVolume left, QuantityValue right)
         {
             return new SpecificVolume(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificVolume"/> from dividing <see cref="SpecificVolume"/> by value.</summary>
-        public static SpecificVolume operator /(SpecificVolume left, double right)
+        public static SpecificVolume operator /(SpecificVolume left, QuantityValue right)
         {
             return new SpecificVolume(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="SpecificVolume"/> by <see cref="SpecificVolume"/>.</summary>
-        public static double operator /(SpecificVolume left, SpecificVolume right)
+        public static QuantityValue operator /(SpecificVolume left, SpecificVolume right)
         {
             return left.CubicMetersPerKilogram / right.CubicMetersPerKilogram;
         }
@@ -521,7 +496,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <returns>The corresponding inverse quantity, <see cref="Density"/>.</returns>
         public Density Inverse()
         {
-            return Density.FromKilogramsPerCubicMeter(1 / CubicMetersPerKilogram);
+            return UnitConverter.Default.ConvertTo(Value, Unit, Density.Info);
         }
 
         /// <summary>Get <see cref="Volume"/> from <see cref="SpecificVolume"/> * <see cref="Mass"/>.</summary>
@@ -537,97 +512,111 @@ public Density Inverse()
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(SpecificVolume left, SpecificVolume right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(SpecificVolume left, SpecificVolume right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(SpecificVolume left, SpecificVolume right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(SpecificVolume left, SpecificVolume right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="SpecificVolume"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SpecificVolume other, SpecificVolume tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SpecificVolume"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(SpecificVolume)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(SpecificVolume left, SpecificVolume right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="SpecificVolume"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SpecificVolume other, SpecificVolume tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SpecificVolume"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(SpecificVolume,SpecificVolume)"/>.
+        ///     See that operator (and <see cref="Equals(SpecificVolume)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(SpecificVolume left, SpecificVolume right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SpecificVolume"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SpecificVolume other, SpecificVolume tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="SpecificVolume"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="SpecificVolume"/>.
+        ///     When <paramref name="obj"/> is a <see cref="SpecificVolume"/>, this method delegates to
+        ///     <see cref="Equals(SpecificVolume)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is SpecificVolume otherQuantity))
+            if (obj is not SpecificVolume otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SpecificVolume"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SpecificVolume other, SpecificVolume tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="SpecificVolume"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(SpecificVolume other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current SpecificVolume.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(SpecificVolume), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="SpecificVolume"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(SpecificVolume)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is SpecificVolume otherQuantity)) throw new ArgumentException("Expected type SpecificVolume.", nameof(obj));
+            if (obj is not SpecificVolume otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<SpecificVolume>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="SpecificVolume"/> with another <see cref="SpecificVolume"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="SpecificVolume"/> with another <see cref="SpecificVolume"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -639,135 +628,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(SpecificVolume other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpecificVolumeUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<SpecificVolumeUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this SpecificVolume to another SpecificVolume with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A SpecificVolume with the specified unit.</returns>
-        public SpecificVolume ToUnit(SpecificVolumeUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="SpecificVolume"/> to another <see cref="SpecificVolume"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A SpecificVolume with the specified unit.</returns>
-        public SpecificVolume ToUnit(SpecificVolumeUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(SpecificVolume), Unit, typeof(SpecificVolume), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (SpecificVolume)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="SpecificVolume"/> to another <see cref="SpecificVolume"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="SpecificVolume"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(SpecificVolumeUnit unit, [NotNullWhen(true)] out SpecificVolume? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            SpecificVolume? convertedOrNull = (Unit, unit) switch
-            {
-                // SpecificVolumeUnit -> BaseUnit
-                (SpecificVolumeUnit.CubicFootPerPound, SpecificVolumeUnit.CubicMeterPerKilogram) => new SpecificVolume(_value * 0.028316846592 / 0.45359237, SpecificVolumeUnit.CubicMeterPerKilogram),
-                (SpecificVolumeUnit.MillicubicMeterPerKilogram, SpecificVolumeUnit.CubicMeterPerKilogram) => new SpecificVolume((_value) * 1e-3d, SpecificVolumeUnit.CubicMeterPerKilogram),
-
-                // BaseUnit -> SpecificVolumeUnit
-                (SpecificVolumeUnit.CubicMeterPerKilogram, SpecificVolumeUnit.CubicFootPerPound) => new SpecificVolume(_value * 0.45359237 / 0.028316846592, SpecificVolumeUnit.CubicFootPerPound),
-                (SpecificVolumeUnit.CubicMeterPerKilogram, SpecificVolumeUnit.MillicubicMeterPerKilogram) => new SpecificVolume((_value) / 1e-3d, SpecificVolumeUnit.MillicubicMeterPerKilogram),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not SpecificVolumeUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificVolumeUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is SpecificVolumeUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificVolumeUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<SpecificVolumeUnit> IQuantity<SpecificVolumeUnit>.ToUnit(SpecificVolumeUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -779,11 +644,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
index 5903a099c5..f1307a54a8 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,13 +36,15 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Specific_weight
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct SpecificWeight :
-        IArithmeticQuantity<SpecificWeight, SpecificWeightUnit>,
+        ILinearQuantity<SpecificWeight, SpecificWeightUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<SpecificWeight, SpecificWeight, double>,
+        IDivisionOperators<SpecificWeight, SpecificWeight, QuantityValue>,
         IDivisionOperators<SpecificWeight, Density, Acceleration>,
         IDivisionOperators<SpecificWeight, Acceleration, Density>,
+        IMultiplyOperators<SpecificWeight, Volume, Force>,
         IMultiplyOperators<SpecificWeight, Area, ForcePerLength>,
         IMultiplyOperators<SpecificWeight, Length, Pressure>,
         IComparisonOperators<SpecificWeight, SpecificWeight, bool>,
@@ -59,7 +59,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -109,7 +109,7 @@ public static SpecificWeightInfo CreateDefault(Func<IEnumerable<UnitDefinition<S
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="SpecificWeight"/> is [T^-2][L^-2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="SpecificWeight"/> is T^-2L^-2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 1, -2, 0, 0, 0, 0);
 
@@ -124,31 +124,61 @@ public static SpecificWeightInfo CreateDefault(Func<IEnumerable<UnitDefinition<S
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{SpecificWeightUnit}"/> representing the default unit mappings for SpecificWeight.</returns>
             public static IEnumerable<UnitDefinition<SpecificWeightUnit>> GetDefaultMappings()
             {
-                yield return new (SpecificWeightUnit.KilogramForcePerCubicCentimeter, "KilogramForcePerCubicCentimeter", "KilogramsForcePerCubicCentimeter", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.KilogramForcePerCubicMeter, "KilogramForcePerCubicMeter", "KilogramsForcePerCubicMeter", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.KilogramForcePerCubicMillimeter, "KilogramForcePerCubicMillimeter", "KilogramsForcePerCubicMillimeter", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.KilonewtonPerCubicCentimeter, "KilonewtonPerCubicCentimeter", "KilonewtonsPerCubicCentimeter", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.KilonewtonPerCubicMeter, "KilonewtonPerCubicMeter", "KilonewtonsPerCubicMeter", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.KilonewtonPerCubicMillimeter, "KilonewtonPerCubicMillimeter", "KilonewtonsPerCubicMillimeter", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.KilopoundForcePerCubicFoot, "KilopoundForcePerCubicFoot", "KilopoundsForcePerCubicFoot", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.KilopoundForcePerCubicInch, "KilopoundForcePerCubicInch", "KilopoundsForcePerCubicInch", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.MeganewtonPerCubicMeter, "MeganewtonPerCubicMeter", "MeganewtonsPerCubicMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (SpecificWeightUnit.NewtonPerCubicCentimeter, "NewtonPerCubicCentimeter", "NewtonsPerCubicCentimeter", BaseUnits.Undefined);
+                yield return new (SpecificWeightUnit.KilogramForcePerCubicCentimeter, "KilogramForcePerCubicCentimeter", "KilogramsForcePerCubicCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 9806650)
+                );
+                yield return new (SpecificWeightUnit.KilogramForcePerCubicMeter, "KilogramForcePerCubicMeter", "KilogramsForcePerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(20000, 196133)
+                );
+                yield return new (SpecificWeightUnit.KilogramForcePerCubicMillimeter, "KilogramForcePerCubicMillimeter", "KilogramsForcePerCubicMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 9806650000)
+                );
+                yield return new (SpecificWeightUnit.KilonewtonPerCubicCentimeter, "KilonewtonPerCubicCentimeter", "KilonewtonsPerCubicCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (SpecificWeightUnit.KilonewtonPerCubicMeter, "KilonewtonPerCubicMeter", "KilonewtonsPerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (SpecificWeightUnit.KilonewtonPerCubicMillimeter, "KilonewtonPerCubicMillimeter", "KilonewtonsPerCubicMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000000)
+                );
+                yield return new (SpecificWeightUnit.KilopoundForcePerCubicFoot, "KilopoundForcePerCubicFoot", "KilopoundsForcePerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(7079211648, 1112055403815125)
+                );
+                yield return new (SpecificWeightUnit.KilopoundForcePerCubicInch, "KilopoundForcePerCubicInch", "KilopoundsForcePerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(4096766, 1112055403815125)
+                );
+                yield return new (SpecificWeightUnit.MeganewtonPerCubicMeter, "MeganewtonPerCubicMeter", "MeganewtonsPerCubicMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (SpecificWeightUnit.NewtonPerCubicCentimeter, "NewtonPerCubicCentimeter", "NewtonsPerCubicCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000)
+                );
                 yield return new (SpecificWeightUnit.NewtonPerCubicMeter, "NewtonPerCubicMeter", "NewtonsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (SpecificWeightUnit.NewtonPerCubicMillimeter, "NewtonPerCubicMillimeter", "NewtonsPerCubicMillimeter", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.PoundForcePerCubicFoot, "PoundForcePerCubicFoot", "PoundsForcePerCubicFoot", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.PoundForcePerCubicInch, "PoundForcePerCubicInch", "PoundsForcePerCubicInch", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.TonneForcePerCubicCentimeter, "TonneForcePerCubicCentimeter", "TonnesForcePerCubicCentimeter", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.TonneForcePerCubicMeter, "TonneForcePerCubicMeter", "TonnesForcePerCubicMeter", BaseUnits.Undefined);
-                yield return new (SpecificWeightUnit.TonneForcePerCubicMillimeter, "TonneForcePerCubicMillimeter", "TonnesForcePerCubicMillimeter", BaseUnits.Undefined);
+                yield return new (SpecificWeightUnit.NewtonPerCubicMillimeter, "NewtonPerCubicMillimeter", "NewtonsPerCubicMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000000000)
+                );
+                yield return new (SpecificWeightUnit.PoundForcePerCubicFoot, "PoundForcePerCubicFoot", "PoundsForcePerCubicFoot", BaseUnits.Undefined,
+                     new QuantityValue(56633693184, 8896443230521)
+                );
+                yield return new (SpecificWeightUnit.PoundForcePerCubicInch, "PoundForcePerCubicInch", "PoundsForcePerCubicInch", BaseUnits.Undefined,
+                     new QuantityValue(32774128, 8896443230521)
+                );
+                yield return new (SpecificWeightUnit.TonneForcePerCubicCentimeter, "TonneForcePerCubicCentimeter", "TonnesForcePerCubicCentimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 9806650000)
+                );
+                yield return new (SpecificWeightUnit.TonneForcePerCubicMeter, "TonneForcePerCubicMeter", "TonnesForcePerCubicMeter", BaseUnits.Undefined,
+                     new QuantityValue(20, 196133)
+                );
+                yield return new (SpecificWeightUnit.TonneForcePerCubicMillimeter, "TonneForcePerCubicMillimeter", "TonnesForcePerCubicMillimeter", BaseUnits.Undefined,
+                     new QuantityValue(1, 9806650000000)
+                );
             }
         }
 
         static SpecificWeight()
         {
-            Info = SpecificWeightInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(SpecificWeightInfo.CreateDefault);
         }
 
         /// <summary>
@@ -156,7 +186,7 @@ static SpecificWeight()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public SpecificWeight(double value, SpecificWeightUnit unit)
+        public SpecificWeight(QuantityValue value, SpecificWeightUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -170,7 +200,7 @@ public SpecificWeight(double value, SpecificWeightUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public SpecificWeight(double value, UnitSystem unitSystem)
+        public SpecificWeight(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -181,7 +211,8 @@ public SpecificWeight(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="SpecificWeight" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<SpecificWeight, SpecificWeightUnit> Info { get; }
@@ -210,10 +241,8 @@ public SpecificWeight(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public SpecificWeightUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -247,140 +276,94 @@ public SpecificWeight(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilogramForcePerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilogramForcePerCubicCentimeter"/>
         /// </summary>
-        public double KilogramsForcePerCubicCentimeter => As(SpecificWeightUnit.KilogramForcePerCubicCentimeter);
+        public QuantityValue KilogramsForcePerCubicCentimeter => this.As(SpecificWeightUnit.KilogramForcePerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilogramForcePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilogramForcePerCubicMeter"/>
         /// </summary>
-        public double KilogramsForcePerCubicMeter => As(SpecificWeightUnit.KilogramForcePerCubicMeter);
+        public QuantityValue KilogramsForcePerCubicMeter => this.As(SpecificWeightUnit.KilogramForcePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilogramForcePerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilogramForcePerCubicMillimeter"/>
         /// </summary>
-        public double KilogramsForcePerCubicMillimeter => As(SpecificWeightUnit.KilogramForcePerCubicMillimeter);
+        public QuantityValue KilogramsForcePerCubicMillimeter => this.As(SpecificWeightUnit.KilogramForcePerCubicMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilonewtonPerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilonewtonPerCubicCentimeter"/>
         /// </summary>
-        public double KilonewtonsPerCubicCentimeter => As(SpecificWeightUnit.KilonewtonPerCubicCentimeter);
+        public QuantityValue KilonewtonsPerCubicCentimeter => this.As(SpecificWeightUnit.KilonewtonPerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilonewtonPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilonewtonPerCubicMeter"/>
         /// </summary>
-        public double KilonewtonsPerCubicMeter => As(SpecificWeightUnit.KilonewtonPerCubicMeter);
+        public QuantityValue KilonewtonsPerCubicMeter => this.As(SpecificWeightUnit.KilonewtonPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilonewtonPerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilonewtonPerCubicMillimeter"/>
         /// </summary>
-        public double KilonewtonsPerCubicMillimeter => As(SpecificWeightUnit.KilonewtonPerCubicMillimeter);
+        public QuantityValue KilonewtonsPerCubicMillimeter => this.As(SpecificWeightUnit.KilonewtonPerCubicMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilopoundForcePerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilopoundForcePerCubicFoot"/>
         /// </summary>
-        public double KilopoundsForcePerCubicFoot => As(SpecificWeightUnit.KilopoundForcePerCubicFoot);
+        public QuantityValue KilopoundsForcePerCubicFoot => this.As(SpecificWeightUnit.KilopoundForcePerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilopoundForcePerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.KilopoundForcePerCubicInch"/>
         /// </summary>
-        public double KilopoundsForcePerCubicInch => As(SpecificWeightUnit.KilopoundForcePerCubicInch);
+        public QuantityValue KilopoundsForcePerCubicInch => this.As(SpecificWeightUnit.KilopoundForcePerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.MeganewtonPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.MeganewtonPerCubicMeter"/>
         /// </summary>
-        public double MeganewtonsPerCubicMeter => As(SpecificWeightUnit.MeganewtonPerCubicMeter);
+        public QuantityValue MeganewtonsPerCubicMeter => this.As(SpecificWeightUnit.MeganewtonPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.NewtonPerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.NewtonPerCubicCentimeter"/>
         /// </summary>
-        public double NewtonsPerCubicCentimeter => As(SpecificWeightUnit.NewtonPerCubicCentimeter);
+        public QuantityValue NewtonsPerCubicCentimeter => this.As(SpecificWeightUnit.NewtonPerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.NewtonPerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.NewtonPerCubicMeter"/>
         /// </summary>
-        public double NewtonsPerCubicMeter => As(SpecificWeightUnit.NewtonPerCubicMeter);
+        public QuantityValue NewtonsPerCubicMeter => this.As(SpecificWeightUnit.NewtonPerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.NewtonPerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.NewtonPerCubicMillimeter"/>
         /// </summary>
-        public double NewtonsPerCubicMillimeter => As(SpecificWeightUnit.NewtonPerCubicMillimeter);
+        public QuantityValue NewtonsPerCubicMillimeter => this.As(SpecificWeightUnit.NewtonPerCubicMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.PoundForcePerCubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.PoundForcePerCubicFoot"/>
         /// </summary>
-        public double PoundsForcePerCubicFoot => As(SpecificWeightUnit.PoundForcePerCubicFoot);
+        public QuantityValue PoundsForcePerCubicFoot => this.As(SpecificWeightUnit.PoundForcePerCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.PoundForcePerCubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.PoundForcePerCubicInch"/>
         /// </summary>
-        public double PoundsForcePerCubicInch => As(SpecificWeightUnit.PoundForcePerCubicInch);
+        public QuantityValue PoundsForcePerCubicInch => this.As(SpecificWeightUnit.PoundForcePerCubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.TonneForcePerCubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.TonneForcePerCubicCentimeter"/>
         /// </summary>
-        public double TonnesForcePerCubicCentimeter => As(SpecificWeightUnit.TonneForcePerCubicCentimeter);
+        public QuantityValue TonnesForcePerCubicCentimeter => this.As(SpecificWeightUnit.TonneForcePerCubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.TonneForcePerCubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.TonneForcePerCubicMeter"/>
         /// </summary>
-        public double TonnesForcePerCubicMeter => As(SpecificWeightUnit.TonneForcePerCubicMeter);
+        public QuantityValue TonnesForcePerCubicMeter => this.As(SpecificWeightUnit.TonneForcePerCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpecificWeightUnit.TonneForcePerCubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpecificWeightUnit.TonneForcePerCubicMillimeter"/>
         /// </summary>
-        public double TonnesForcePerCubicMillimeter => As(SpecificWeightUnit.TonneForcePerCubicMillimeter);
+        public QuantityValue TonnesForcePerCubicMillimeter => this.As(SpecificWeightUnit.TonneForcePerCubicMillimeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: SpecificWeightUnit -> BaseUnit
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilogramForcePerCubicCentimeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilogramForcePerCubicMeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilogramForcePerCubicMillimeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilonewtonPerCubicCentimeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilonewtonPerCubicMeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilonewtonPerCubicMillimeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilopoundForcePerCubicFoot, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.KilopoundForcePerCubicInch, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.MeganewtonPerCubicMeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicCentimeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMillimeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.PoundForcePerCubicFoot, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.PoundForcePerCubicInch, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.TonneForcePerCubicCentimeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.TonneForcePerCubicMeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.TonneForcePerCubicMillimeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.NewtonPerCubicMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> SpecificWeightUnit
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilogramForcePerCubicCentimeter, quantity => quantity.ToUnit(SpecificWeightUnit.KilogramForcePerCubicCentimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilogramForcePerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.KilogramForcePerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilogramForcePerCubicMillimeter, quantity => quantity.ToUnit(SpecificWeightUnit.KilogramForcePerCubicMillimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilonewtonPerCubicCentimeter, quantity => quantity.ToUnit(SpecificWeightUnit.KilonewtonPerCubicCentimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilonewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.KilonewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilonewtonPerCubicMillimeter, quantity => quantity.ToUnit(SpecificWeightUnit.KilonewtonPerCubicMillimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilopoundForcePerCubicFoot, quantity => quantity.ToUnit(SpecificWeightUnit.KilopoundForcePerCubicFoot));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilopoundForcePerCubicInch, quantity => quantity.ToUnit(SpecificWeightUnit.KilopoundForcePerCubicInch));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.MeganewtonPerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.MeganewtonPerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.NewtonPerCubicCentimeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicCentimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.NewtonPerCubicMillimeter, quantity => quantity.ToUnit(SpecificWeightUnit.NewtonPerCubicMillimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.PoundForcePerCubicFoot, quantity => quantity.ToUnit(SpecificWeightUnit.PoundForcePerCubicFoot));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.PoundForcePerCubicInch, quantity => quantity.ToUnit(SpecificWeightUnit.PoundForcePerCubicInch));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.TonneForcePerCubicCentimeter, quantity => quantity.ToUnit(SpecificWeightUnit.TonneForcePerCubicCentimeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.TonneForcePerCubicMeter, quantity => quantity.ToUnit(SpecificWeightUnit.TonneForcePerCubicMeter));
-            unitConverter.SetConversionFunction<SpecificWeight>(SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.TonneForcePerCubicMillimeter, quantity => quantity.ToUnit(SpecificWeightUnit.TonneForcePerCubicMillimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -409,7 +392,7 @@ public static string GetAbbreviation(SpecificWeightUnit unit, IFormatProvider? p
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicCentimeter"/>.
         /// </summary>
-        public static SpecificWeight FromKilogramsForcePerCubicCentimeter(double value)
+        public static SpecificWeight FromKilogramsForcePerCubicCentimeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicCentimeter);
         }
@@ -417,7 +400,7 @@ public static SpecificWeight FromKilogramsForcePerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicMeter"/>.
         /// </summary>
-        public static SpecificWeight FromKilogramsForcePerCubicMeter(double value)
+        public static SpecificWeight FromKilogramsForcePerCubicMeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMeter);
         }
@@ -425,7 +408,7 @@ public static SpecificWeight FromKilogramsForcePerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicMillimeter"/>.
         /// </summary>
-        public static SpecificWeight FromKilogramsForcePerCubicMillimeter(double value)
+        public static SpecificWeight FromKilogramsForcePerCubicMillimeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMillimeter);
         }
@@ -433,7 +416,7 @@ public static SpecificWeight FromKilogramsForcePerCubicMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicCentimeter"/>.
         /// </summary>
-        public static SpecificWeight FromKilonewtonsPerCubicCentimeter(double value)
+        public static SpecificWeight FromKilonewtonsPerCubicCentimeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicCentimeter);
         }
@@ -441,7 +424,7 @@ public static SpecificWeight FromKilonewtonsPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicMeter"/>.
         /// </summary>
-        public static SpecificWeight FromKilonewtonsPerCubicMeter(double value)
+        public static SpecificWeight FromKilonewtonsPerCubicMeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMeter);
         }
@@ -449,7 +432,7 @@ public static SpecificWeight FromKilonewtonsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicMillimeter"/>.
         /// </summary>
-        public static SpecificWeight FromKilonewtonsPerCubicMillimeter(double value)
+        public static SpecificWeight FromKilonewtonsPerCubicMillimeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMillimeter);
         }
@@ -457,7 +440,7 @@ public static SpecificWeight FromKilonewtonsPerCubicMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilopoundForcePerCubicFoot"/>.
         /// </summary>
-        public static SpecificWeight FromKilopoundsForcePerCubicFoot(double value)
+        public static SpecificWeight FromKilopoundsForcePerCubicFoot(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicFoot);
         }
@@ -465,7 +448,7 @@ public static SpecificWeight FromKilopoundsForcePerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilopoundForcePerCubicInch"/>.
         /// </summary>
-        public static SpecificWeight FromKilopoundsForcePerCubicInch(double value)
+        public static SpecificWeight FromKilopoundsForcePerCubicInch(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicInch);
         }
@@ -473,7 +456,7 @@ public static SpecificWeight FromKilopoundsForcePerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.MeganewtonPerCubicMeter"/>.
         /// </summary>
-        public static SpecificWeight FromMeganewtonsPerCubicMeter(double value)
+        public static SpecificWeight FromMeganewtonsPerCubicMeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.MeganewtonPerCubicMeter);
         }
@@ -481,7 +464,7 @@ public static SpecificWeight FromMeganewtonsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicCentimeter"/>.
         /// </summary>
-        public static SpecificWeight FromNewtonsPerCubicCentimeter(double value)
+        public static SpecificWeight FromNewtonsPerCubicCentimeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicCentimeter);
         }
@@ -489,7 +472,7 @@ public static SpecificWeight FromNewtonsPerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicMeter"/>.
         /// </summary>
-        public static SpecificWeight FromNewtonsPerCubicMeter(double value)
+        public static SpecificWeight FromNewtonsPerCubicMeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMeter);
         }
@@ -497,7 +480,7 @@ public static SpecificWeight FromNewtonsPerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicMillimeter"/>.
         /// </summary>
-        public static SpecificWeight FromNewtonsPerCubicMillimeter(double value)
+        public static SpecificWeight FromNewtonsPerCubicMillimeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMillimeter);
         }
@@ -505,7 +488,7 @@ public static SpecificWeight FromNewtonsPerCubicMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.PoundForcePerCubicFoot"/>.
         /// </summary>
-        public static SpecificWeight FromPoundsForcePerCubicFoot(double value)
+        public static SpecificWeight FromPoundsForcePerCubicFoot(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicFoot);
         }
@@ -513,7 +496,7 @@ public static SpecificWeight FromPoundsForcePerCubicFoot(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.PoundForcePerCubicInch"/>.
         /// </summary>
-        public static SpecificWeight FromPoundsForcePerCubicInch(double value)
+        public static SpecificWeight FromPoundsForcePerCubicInch(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicInch);
         }
@@ -521,7 +504,7 @@ public static SpecificWeight FromPoundsForcePerCubicInch(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicCentimeter"/>.
         /// </summary>
-        public static SpecificWeight FromTonnesForcePerCubicCentimeter(double value)
+        public static SpecificWeight FromTonnesForcePerCubicCentimeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicCentimeter);
         }
@@ -529,7 +512,7 @@ public static SpecificWeight FromTonnesForcePerCubicCentimeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicMeter"/>.
         /// </summary>
-        public static SpecificWeight FromTonnesForcePerCubicMeter(double value)
+        public static SpecificWeight FromTonnesForcePerCubicMeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMeter);
         }
@@ -537,7 +520,7 @@ public static SpecificWeight FromTonnesForcePerCubicMeter(double value)
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicMillimeter"/>.
         /// </summary>
-        public static SpecificWeight FromTonnesForcePerCubicMillimeter(double value)
+        public static SpecificWeight FromTonnesForcePerCubicMillimeter(QuantityValue value)
         {
             return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMillimeter);
         }
@@ -548,7 +531,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SpecificWeight unit value.</returns>
-        public static SpecificWeight From(double value, SpecificWeightUnit fromUnit)
+        public static SpecificWeight From(QuantityValue value, SpecificWeightUnit fromUnit)
         {
             return new SpecificWeight(value, fromUnit);
         }
@@ -609,10 +592,7 @@ public static SpecificWeight Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static SpecificWeight Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<SpecificWeight, SpecificWeightUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<SpecificWeight, SpecificWeightUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -640,11 +620,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out SpecificWeight r
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpecificWeight result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<SpecificWeight, SpecificWeightUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<SpecificWeight, SpecificWeightUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -665,7 +641,7 @@ public static SpecificWeightUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -676,7 +652,7 @@ public static SpecificWeightUnit ParseUnit(string str, IFormatProvider? provider
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpecificWeightUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.SpecificWeightUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificWeightUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -691,7 +667,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpecificWeig
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpecificWeightUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -710,35 +686,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="SpecificWeight"/> from adding two <see cref="SpecificWeight"/>.</summary>
         public static SpecificWeight operator +(SpecificWeight left, SpecificWeight right)
         {
-            return new SpecificWeight(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new SpecificWeight(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificWeight"/> from subtracting two <see cref="SpecificWeight"/>.</summary>
         public static SpecificWeight operator -(SpecificWeight left, SpecificWeight right)
         {
-            return new SpecificWeight(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new SpecificWeight(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificWeight"/> from multiplying value and <see cref="SpecificWeight"/>.</summary>
-        public static SpecificWeight operator *(double left, SpecificWeight right)
+        public static SpecificWeight operator *(QuantityValue left, SpecificWeight right)
         {
             return new SpecificWeight(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="SpecificWeight"/> from multiplying value and <see cref="SpecificWeight"/>.</summary>
-        public static SpecificWeight operator *(SpecificWeight left, double right)
+        public static SpecificWeight operator *(SpecificWeight left, QuantityValue right)
         {
             return new SpecificWeight(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="SpecificWeight"/> from dividing <see cref="SpecificWeight"/> by value.</summary>
-        public static SpecificWeight operator /(SpecificWeight left, double right)
+        public static SpecificWeight operator /(SpecificWeight left, QuantityValue right)
         {
             return new SpecificWeight(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="SpecificWeight"/> by <see cref="SpecificWeight"/>.</summary>
-        public static double operator /(SpecificWeight left, SpecificWeight right)
+        public static QuantityValue operator /(SpecificWeight left, SpecificWeight right)
         {
             return left.NewtonsPerCubicMeter / right.NewtonsPerCubicMeter;
         }
@@ -759,6 +735,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Density.FromKilogramsPerCubicMeter(specificWeight.NewtonsPerCubicMeter / acceleration.MetersPerSecondSquared);
         }
 
+        /// <summary>Get <see cref="Force"/> from <see cref="SpecificWeight"/> * <see cref="Volume"/>.</summary>
+        public static Force operator *(SpecificWeight specificWeight, Volume volume)
+        {
+            return Force.FromNewtons(specificWeight.NewtonsPerCubicMeter * volume.CubicMeters);
+        }
+
         /// <summary>Get <see cref="ForcePerLength"/> from <see cref="SpecificWeight"/> * <see cref="Area"/>.</summary>
         public static ForcePerLength operator *(SpecificWeight specificWeight, Area area)
         {
@@ -778,97 +760,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(SpecificWeight left, SpecificWeight right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(SpecificWeight left, SpecificWeight right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(SpecificWeight left, SpecificWeight right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(SpecificWeight left, SpecificWeight right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="SpecificWeight"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SpecificWeight other, SpecificWeight tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SpecificWeight"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(SpecificWeight)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(SpecificWeight left, SpecificWeight right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="SpecificWeight"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(SpecificWeight other, SpecificWeight tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="SpecificWeight"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(SpecificWeight,SpecificWeight)"/>.
+        ///     See that operator (and <see cref="Equals(SpecificWeight)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(SpecificWeight left, SpecificWeight right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SpecificWeight"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SpecificWeight other, SpecificWeight tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="SpecificWeight"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="SpecificWeight"/>.
+        ///     When <paramref name="obj"/> is a <see cref="SpecificWeight"/>, this method delegates to
+        ///     <see cref="Equals(SpecificWeight)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is SpecificWeight otherQuantity))
+            if (obj is not SpecificWeight otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="SpecificWeight"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(SpecificWeight other, SpecificWeight tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="SpecificWeight"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(SpecificWeight other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current SpecificWeight.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(SpecificWeight), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="SpecificWeight"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(SpecificWeight)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is SpecificWeight otherQuantity)) throw new ArgumentException("Expected type SpecificWeight.", nameof(obj));
+            if (obj is not SpecificWeight otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<SpecificWeight>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="SpecificWeight"/> with another <see cref="SpecificWeight"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="SpecificWeight"/> with another <see cref="SpecificWeight"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -880,163 +876,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(SpecificWeight other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpecificWeightUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<SpecificWeightUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this SpecificWeight to another SpecificWeight with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A SpecificWeight with the specified unit.</returns>
-        public SpecificWeight ToUnit(SpecificWeightUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="SpecificWeight"/> to another <see cref="SpecificWeight"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A SpecificWeight with the specified unit.</returns>
-        public SpecificWeight ToUnit(SpecificWeightUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(SpecificWeight), Unit, typeof(SpecificWeight), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (SpecificWeight)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="SpecificWeight"/> to another <see cref="SpecificWeight"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="SpecificWeight"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(SpecificWeightUnit unit, [NotNullWhen(true)] out SpecificWeight? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            SpecificWeight? convertedOrNull = (Unit, unit) switch
-            {
-                // SpecificWeightUnit -> BaseUnit
-                (SpecificWeightUnit.KilogramForcePerCubicCentimeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight(_value * 9.80665e6, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.KilogramForcePerCubicMeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight(_value * 9.80665, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.KilogramForcePerCubicMillimeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight(_value * 9.80665e9, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.KilonewtonPerCubicCentimeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight((_value * 1000000) * 1e3d, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.KilonewtonPerCubicMeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight((_value) * 1e3d, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.KilonewtonPerCubicMillimeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight((_value * 1000000000) * 1e3d, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.KilopoundForcePerCubicFoot, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight((_value * 4.4482216152605 / 0.028316846592) * 1e3d, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.KilopoundForcePerCubicInch, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight((_value * 4.4482216152605 / 1.6387064e-5) * 1e3d, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.MeganewtonPerCubicMeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight((_value) * 1e6d, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.NewtonPerCubicCentimeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight(_value * 1000000, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.NewtonPerCubicMillimeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight(_value * 1000000000, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.PoundForcePerCubicFoot, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight(_value * 4.4482216152605 / 0.028316846592, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.PoundForcePerCubicInch, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight(_value * 4.4482216152605 / 1.6387064e-5, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.TonneForcePerCubicCentimeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight(_value * 9.80665e9, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.TonneForcePerCubicMeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight(_value * 9.80665e3, SpecificWeightUnit.NewtonPerCubicMeter),
-                (SpecificWeightUnit.TonneForcePerCubicMillimeter, SpecificWeightUnit.NewtonPerCubicMeter) => new SpecificWeight(_value * 9.80665e12, SpecificWeightUnit.NewtonPerCubicMeter),
-
-                // BaseUnit -> SpecificWeightUnit
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilogramForcePerCubicCentimeter) => new SpecificWeight(_value / 9.80665e6, SpecificWeightUnit.KilogramForcePerCubicCentimeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilogramForcePerCubicMeter) => new SpecificWeight(_value / 9.80665, SpecificWeightUnit.KilogramForcePerCubicMeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilogramForcePerCubicMillimeter) => new SpecificWeight(_value / 9.80665e9, SpecificWeightUnit.KilogramForcePerCubicMillimeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilonewtonPerCubicCentimeter) => new SpecificWeight((_value * 0.000001) / 1e3d, SpecificWeightUnit.KilonewtonPerCubicCentimeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilonewtonPerCubicMeter) => new SpecificWeight((_value) / 1e3d, SpecificWeightUnit.KilonewtonPerCubicMeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilonewtonPerCubicMillimeter) => new SpecificWeight((_value * 0.000000001) / 1e3d, SpecificWeightUnit.KilonewtonPerCubicMillimeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilopoundForcePerCubicFoot) => new SpecificWeight((_value * 0.028316846592 / 4.4482216152605) / 1e3d, SpecificWeightUnit.KilopoundForcePerCubicFoot),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.KilopoundForcePerCubicInch) => new SpecificWeight((_value * 1.6387064e-5 / 4.4482216152605) / 1e3d, SpecificWeightUnit.KilopoundForcePerCubicInch),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.MeganewtonPerCubicMeter) => new SpecificWeight((_value) / 1e6d, SpecificWeightUnit.MeganewtonPerCubicMeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.NewtonPerCubicCentimeter) => new SpecificWeight(_value * 0.000001, SpecificWeightUnit.NewtonPerCubicCentimeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.NewtonPerCubicMillimeter) => new SpecificWeight(_value * 0.000000001, SpecificWeightUnit.NewtonPerCubicMillimeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.PoundForcePerCubicFoot) => new SpecificWeight(_value * 0.028316846592 / 4.4482216152605, SpecificWeightUnit.PoundForcePerCubicFoot),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.PoundForcePerCubicInch) => new SpecificWeight(_value * 1.6387064e-5 / 4.4482216152605, SpecificWeightUnit.PoundForcePerCubicInch),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.TonneForcePerCubicCentimeter) => new SpecificWeight(_value / 9.80665e9, SpecificWeightUnit.TonneForcePerCubicCentimeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.TonneForcePerCubicMeter) => new SpecificWeight(_value / 9.80665e3, SpecificWeightUnit.TonneForcePerCubicMeter),
-                (SpecificWeightUnit.NewtonPerCubicMeter, SpecificWeightUnit.TonneForcePerCubicMillimeter) => new SpecificWeight(_value / 9.80665e12, SpecificWeightUnit.TonneForcePerCubicMillimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not SpecificWeightUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificWeightUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is SpecificWeightUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificWeightUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<SpecificWeightUnit> IQuantity<SpecificWeightUnit>.ToUnit(SpecificWeightUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -1048,11 +892,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
index 35a005752d..8575899a62 100644
--- a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     In everyday use and in kinematics, the speed of an object is the magnitude of its velocity (the rate of change of its position); it is thus a scalar quantity.[1] The average speed of an object in an interval of time is the distance travelled by the object divided by the duration of the interval;[2] the instantaneous speed is the limit of the average speed as the duration of the time interval approaches zero.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Speed :
-        IArithmeticQuantity<Speed, SpeedUnit>,
+        ILinearQuantity<Speed, SpeedUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Speed, Speed, double>,
+        IDivisionOperators<Speed, Speed, QuantityValue>,
         IDivisionOperators<Speed, Duration, Acceleration>,
         IDivisionOperators<Speed, Acceleration, Duration>,
         IMultiplyOperators<Speed, Length, KinematicViscosity>,
@@ -60,7 +59,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -110,7 +109,7 @@ public static SpeedInfo CreateDefault(Func<IEnumerable<UnitDefinition<SpeedUnit>
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Speed"/> is [T^-1][L].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Speed"/> is T^-1L.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 0, -1, 0, 0, 0, 0);
 
@@ -125,47 +124,109 @@ public static SpeedInfo CreateDefault(Func<IEnumerable<UnitDefinition<SpeedUnit>
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{SpeedUnit}"/> representing the default unit mappings for Speed.</returns>
             public static IEnumerable<UnitDefinition<SpeedUnit>> GetDefaultMappings()
             {
-                yield return new (SpeedUnit.CentimeterPerHour, "CentimeterPerHour", "CentimetersPerHour", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Hour));
-                yield return new (SpeedUnit.CentimeterPerMinute, "CentimeterPerMinute", "CentimetersPerMinute", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Minute));
-                yield return new (SpeedUnit.CentimeterPerSecond, "CentimeterPerSecond", "CentimetersPerSecond", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Second));
-                yield return new (SpeedUnit.DecimeterPerMinute, "DecimeterPerMinute", "DecimetersPerMinute", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Minute));
-                yield return new (SpeedUnit.DecimeterPerSecond, "DecimeterPerSecond", "DecimetersPerSecond", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Second));
-                yield return new (SpeedUnit.FootPerHour, "FootPerHour", "FeetPerHour", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Hour));
-                yield return new (SpeedUnit.FootPerMinute, "FootPerMinute", "FeetPerMinute", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Minute));
-                yield return new (SpeedUnit.FootPerSecond, "FootPerSecond", "FeetPerSecond", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second));
-                yield return new (SpeedUnit.InchPerHour, "InchPerHour", "InchesPerHour", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Hour));
-                yield return new (SpeedUnit.InchPerMinute, "InchPerMinute", "InchesPerMinute", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Minute));
-                yield return new (SpeedUnit.InchPerSecond, "InchPerSecond", "InchesPerSecond", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Second));
-                yield return new (SpeedUnit.KilometerPerHour, "KilometerPerHour", "KilometersPerHour", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Hour));
-                yield return new (SpeedUnit.KilometerPerMinute, "KilometerPerMinute", "KilometersPerMinute", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Minute));
-                yield return new (SpeedUnit.KilometerPerSecond, "KilometerPerSecond", "KilometersPerSecond", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second));
-                yield return new (SpeedUnit.Knot, "Knot", "Knots", new BaseUnits(length: LengthUnit.NauticalMile, time: DurationUnit.Hour));
-                yield return new (SpeedUnit.Mach, "Mach", "Mach", BaseUnits.Undefined);
-                yield return new (SpeedUnit.MeterPerHour, "MeterPerHour", "MetersPerHour", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Hour));
-                yield return new (SpeedUnit.MeterPerMinute, "MeterPerMinute", "MetersPerMinute", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Minute));
+                yield return new (SpeedUnit.CentimeterPerHour, "CentimeterPerHour", "CentimetersPerHour", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Hour),
+                     360000
+                );
+                yield return new (SpeedUnit.CentimeterPerMinute, "CentimeterPerMinute", "CentimetersPerMinute", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Minute),
+                     6000
+                );
+                yield return new (SpeedUnit.CentimeterPerSecond, "CentimeterPerSecond", "CentimetersPerSecond", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Second),
+                     100
+                );
+                yield return new (SpeedUnit.DecimeterPerMinute, "DecimeterPerMinute", "DecimetersPerMinute", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Minute),
+                     600
+                );
+                yield return new (SpeedUnit.DecimeterPerSecond, "DecimeterPerSecond", "DecimetersPerSecond", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Second),
+                     10
+                );
+                yield return new (SpeedUnit.FootPerHour, "FootPerHour", "FeetPerHour", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Hour),
+                     new QuantityValue(1500000, 127)
+                );
+                yield return new (SpeedUnit.FootPerMinute, "FootPerMinute", "FeetPerMinute", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Minute),
+                     new QuantityValue(25000, 127)
+                );
+                yield return new (SpeedUnit.FootPerSecond, "FootPerSecond", "FeetPerSecond", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second),
+                     new QuantityValue(1250, 381)
+                );
+                yield return new (SpeedUnit.InchPerHour, "InchPerHour", "InchesPerHour", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Hour),
+                     new QuantityValue(18000000, 127)
+                );
+                yield return new (SpeedUnit.InchPerMinute, "InchPerMinute", "InchesPerMinute", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Minute),
+                     new QuantityValue(300000, 127)
+                );
+                yield return new (SpeedUnit.InchPerSecond, "InchPerSecond", "InchesPerSecond", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Second),
+                     new QuantityValue(5000, 127)
+                );
+                yield return new (SpeedUnit.KilometerPerHour, "KilometerPerHour", "KilometersPerHour", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Hour),
+                     new QuantityValue(18, 5)
+                );
+                yield return new (SpeedUnit.KilometerPerMinute, "KilometerPerMinute", "KilometersPerMinute", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Minute),
+                     new QuantityValue(3, 50)
+                );
+                yield return new (SpeedUnit.KilometerPerSecond, "KilometerPerSecond", "KilometersPerSecond", new BaseUnits(length: LengthUnit.Kilometer, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (SpeedUnit.Knot, "Knot", "Knots", new BaseUnits(length: LengthUnit.NauticalMile, time: DurationUnit.Hour),
+                     new QuantityValue(900, 463)
+                );
+                yield return new (SpeedUnit.Mach, "Mach", "Mach", BaseUnits.Undefined,
+                     new QuantityValue(100, 34029)
+                );
+                yield return new (SpeedUnit.MeterPerHour, "MeterPerHour", "MetersPerHour", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Hour),
+                     3600
+                );
+                yield return new (SpeedUnit.MeterPerMinute, "MeterPerMinute", "MetersPerMinute", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Minute),
+                     60
+                );
                 yield return new (SpeedUnit.MeterPerSecond, "MeterPerSecond", "MetersPerSecond", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (SpeedUnit.MicrometerPerMinute, "MicrometerPerMinute", "MicrometersPerMinute", new BaseUnits(length: LengthUnit.Micrometer, time: DurationUnit.Minute));
-                yield return new (SpeedUnit.MicrometerPerSecond, "MicrometerPerSecond", "MicrometersPerSecond", new BaseUnits(length: LengthUnit.Micrometer, time: DurationUnit.Second));
-                yield return new (SpeedUnit.MilePerHour, "MilePerHour", "MilesPerHour", new BaseUnits(length: LengthUnit.Mile, time: DurationUnit.Hour));
-                yield return new (SpeedUnit.MillimeterPerHour, "MillimeterPerHour", "MillimetersPerHour", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Hour));
-                yield return new (SpeedUnit.MillimeterPerMinute, "MillimeterPerMinute", "MillimetersPerMinute", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Minute));
-                yield return new (SpeedUnit.MillimeterPerSecond, "MillimeterPerSecond", "MillimetersPerSecond", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second));
-                yield return new (SpeedUnit.NanometerPerMinute, "NanometerPerMinute", "NanometersPerMinute", new BaseUnits(length: LengthUnit.Nanometer, time: DurationUnit.Minute));
-                yield return new (SpeedUnit.NanometerPerSecond, "NanometerPerSecond", "NanometersPerSecond", new BaseUnits(length: LengthUnit.Nanometer, time: DurationUnit.Second));
-                yield return new (SpeedUnit.UsSurveyFootPerHour, "UsSurveyFootPerHour", "UsSurveyFeetPerHour", new BaseUnits(length: LengthUnit.UsSurveyFoot, time: DurationUnit.Hour));
-                yield return new (SpeedUnit.UsSurveyFootPerMinute, "UsSurveyFootPerMinute", "UsSurveyFeetPerMinute", new BaseUnits(length: LengthUnit.UsSurveyFoot, time: DurationUnit.Minute));
-                yield return new (SpeedUnit.UsSurveyFootPerSecond, "UsSurveyFootPerSecond", "UsSurveyFeetPerSecond", new BaseUnits(length: LengthUnit.UsSurveyFoot, time: DurationUnit.Second));
-                yield return new (SpeedUnit.YardPerHour, "YardPerHour", "YardsPerHour", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Hour));
-                yield return new (SpeedUnit.YardPerMinute, "YardPerMinute", "YardsPerMinute", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Minute));
-                yield return new (SpeedUnit.YardPerSecond, "YardPerSecond", "YardsPerSecond", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Second));
+                yield return new (SpeedUnit.MicrometerPerMinute, "MicrometerPerMinute", "MicrometersPerMinute", new BaseUnits(length: LengthUnit.Micrometer, time: DurationUnit.Minute),
+                     60000000
+                );
+                yield return new (SpeedUnit.MicrometerPerSecond, "MicrometerPerSecond", "MicrometersPerSecond", new BaseUnits(length: LengthUnit.Micrometer, time: DurationUnit.Second),
+                     1000000
+                );
+                yield return new (SpeedUnit.MilePerHour, "MilePerHour", "MilesPerHour", new BaseUnits(length: LengthUnit.Mile, time: DurationUnit.Hour),
+                     new QuantityValue(3125, 1397)
+                );
+                yield return new (SpeedUnit.MillimeterPerHour, "MillimeterPerHour", "MillimetersPerHour", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Hour),
+                     3600000
+                );
+                yield return new (SpeedUnit.MillimeterPerMinute, "MillimeterPerMinute", "MillimetersPerMinute", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Minute),
+                     60000
+                );
+                yield return new (SpeedUnit.MillimeterPerSecond, "MillimeterPerSecond", "MillimetersPerSecond", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second),
+                     1000
+                );
+                yield return new (SpeedUnit.NanometerPerMinute, "NanometerPerMinute", "NanometersPerMinute", new BaseUnits(length: LengthUnit.Nanometer, time: DurationUnit.Minute),
+                     60000000000
+                );
+                yield return new (SpeedUnit.NanometerPerSecond, "NanometerPerSecond", "NanometersPerSecond", new BaseUnits(length: LengthUnit.Nanometer, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (SpeedUnit.UsSurveyFootPerHour, "UsSurveyFootPerHour", "UsSurveyFeetPerHour", new BaseUnits(length: LengthUnit.UsSurveyFoot, time: DurationUnit.Hour),
+                     11811
+                );
+                yield return new (SpeedUnit.UsSurveyFootPerMinute, "UsSurveyFootPerMinute", "UsSurveyFeetPerMinute", new BaseUnits(length: LengthUnit.UsSurveyFoot, time: DurationUnit.Minute),
+                     new QuantityValue(3937, 20)
+                );
+                yield return new (SpeedUnit.UsSurveyFootPerSecond, "UsSurveyFootPerSecond", "UsSurveyFeetPerSecond", new BaseUnits(length: LengthUnit.UsSurveyFoot, time: DurationUnit.Second),
+                     new QuantityValue(3937, 1200)
+                );
+                yield return new (SpeedUnit.YardPerHour, "YardPerHour", "YardsPerHour", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Hour),
+                     new QuantityValue(500000, 127)
+                );
+                yield return new (SpeedUnit.YardPerMinute, "YardPerMinute", "YardsPerMinute", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Minute),
+                     new QuantityValue(25000, 381)
+                );
+                yield return new (SpeedUnit.YardPerSecond, "YardPerSecond", "YardsPerSecond", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Second),
+                     new QuantityValue(1250, 1143)
+                );
             }
         }
 
         static Speed()
         {
-            Info = SpeedInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(SpeedInfo.CreateDefault);
         }
 
         /// <summary>
@@ -173,7 +234,7 @@ static Speed()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Speed(double value, SpeedUnit unit)
+        public Speed(QuantityValue value, SpeedUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -187,7 +248,7 @@ public Speed(double value, SpeedUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Speed(double value, UnitSystem unitSystem)
+        public Speed(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -198,7 +259,8 @@ public Speed(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Speed" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Speed, SpeedUnit> Info { get; }
@@ -227,10 +289,8 @@ public Speed(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public SpeedUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -264,252 +324,174 @@ public Speed(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.CentimeterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.CentimeterPerHour"/>
         /// </summary>
-        public double CentimetersPerHour => As(SpeedUnit.CentimeterPerHour);
+        public QuantityValue CentimetersPerHour => this.As(SpeedUnit.CentimeterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.CentimeterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.CentimeterPerMinute"/>
         /// </summary>
-        public double CentimetersPerMinute => As(SpeedUnit.CentimeterPerMinute);
+        public QuantityValue CentimetersPerMinute => this.As(SpeedUnit.CentimeterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.CentimeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.CentimeterPerSecond"/>
         /// </summary>
-        public double CentimetersPerSecond => As(SpeedUnit.CentimeterPerSecond);
+        public QuantityValue CentimetersPerSecond => this.As(SpeedUnit.CentimeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.DecimeterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.DecimeterPerMinute"/>
         /// </summary>
-        public double DecimetersPerMinute => As(SpeedUnit.DecimeterPerMinute);
+        public QuantityValue DecimetersPerMinute => this.As(SpeedUnit.DecimeterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.DecimeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.DecimeterPerSecond"/>
         /// </summary>
-        public double DecimetersPerSecond => As(SpeedUnit.DecimeterPerSecond);
+        public QuantityValue DecimetersPerSecond => this.As(SpeedUnit.DecimeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.FootPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.FootPerHour"/>
         /// </summary>
-        public double FeetPerHour => As(SpeedUnit.FootPerHour);
+        public QuantityValue FeetPerHour => this.As(SpeedUnit.FootPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.FootPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.FootPerMinute"/>
         /// </summary>
-        public double FeetPerMinute => As(SpeedUnit.FootPerMinute);
+        public QuantityValue FeetPerMinute => this.As(SpeedUnit.FootPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.FootPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.FootPerSecond"/>
         /// </summary>
-        public double FeetPerSecond => As(SpeedUnit.FootPerSecond);
+        public QuantityValue FeetPerSecond => this.As(SpeedUnit.FootPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.InchPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.InchPerHour"/>
         /// </summary>
-        public double InchesPerHour => As(SpeedUnit.InchPerHour);
+        public QuantityValue InchesPerHour => this.As(SpeedUnit.InchPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.InchPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.InchPerMinute"/>
         /// </summary>
-        public double InchesPerMinute => As(SpeedUnit.InchPerMinute);
+        public QuantityValue InchesPerMinute => this.As(SpeedUnit.InchPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.InchPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.InchPerSecond"/>
         /// </summary>
-        public double InchesPerSecond => As(SpeedUnit.InchPerSecond);
+        public QuantityValue InchesPerSecond => this.As(SpeedUnit.InchPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.KilometerPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.KilometerPerHour"/>
         /// </summary>
-        public double KilometersPerHour => As(SpeedUnit.KilometerPerHour);
+        public QuantityValue KilometersPerHour => this.As(SpeedUnit.KilometerPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.KilometerPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.KilometerPerMinute"/>
         /// </summary>
-        public double KilometersPerMinute => As(SpeedUnit.KilometerPerMinute);
+        public QuantityValue KilometersPerMinute => this.As(SpeedUnit.KilometerPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.KilometerPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.KilometerPerSecond"/>
         /// </summary>
-        public double KilometersPerSecond => As(SpeedUnit.KilometerPerSecond);
+        public QuantityValue KilometersPerSecond => this.As(SpeedUnit.KilometerPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.Knot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.Knot"/>
         /// </summary>
-        public double Knots => As(SpeedUnit.Knot);
+        public QuantityValue Knots => this.As(SpeedUnit.Knot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.Mach"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.Mach"/>
         /// </summary>
-        public double Mach => As(SpeedUnit.Mach);
+        public QuantityValue Mach => this.As(SpeedUnit.Mach);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MeterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.MeterPerHour"/>
         /// </summary>
-        public double MetersPerHour => As(SpeedUnit.MeterPerHour);
+        public QuantityValue MetersPerHour => this.As(SpeedUnit.MeterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MeterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.MeterPerMinute"/>
         /// </summary>
-        public double MetersPerMinute => As(SpeedUnit.MeterPerMinute);
+        public QuantityValue MetersPerMinute => this.As(SpeedUnit.MeterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.MeterPerSecond"/>
         /// </summary>
-        public double MetersPerSecond => As(SpeedUnit.MeterPerSecond);
+        public QuantityValue MetersPerSecond => this.As(SpeedUnit.MeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MicrometerPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.MicrometerPerMinute"/>
         /// </summary>
-        public double MicrometersPerMinute => As(SpeedUnit.MicrometerPerMinute);
+        public QuantityValue MicrometersPerMinute => this.As(SpeedUnit.MicrometerPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MicrometerPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.MicrometerPerSecond"/>
         /// </summary>
-        public double MicrometersPerSecond => As(SpeedUnit.MicrometerPerSecond);
+        public QuantityValue MicrometersPerSecond => this.As(SpeedUnit.MicrometerPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MilePerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.MilePerHour"/>
         /// </summary>
-        public double MilesPerHour => As(SpeedUnit.MilePerHour);
+        public QuantityValue MilesPerHour => this.As(SpeedUnit.MilePerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MillimeterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.MillimeterPerHour"/>
         /// </summary>
-        public double MillimetersPerHour => As(SpeedUnit.MillimeterPerHour);
+        public QuantityValue MillimetersPerHour => this.As(SpeedUnit.MillimeterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MillimeterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.MillimeterPerMinute"/>
         /// </summary>
-        public double MillimetersPerMinute => As(SpeedUnit.MillimeterPerMinute);
+        public QuantityValue MillimetersPerMinute => this.As(SpeedUnit.MillimeterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.MillimeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.MillimeterPerSecond"/>
         /// </summary>
-        public double MillimetersPerSecond => As(SpeedUnit.MillimeterPerSecond);
+        public QuantityValue MillimetersPerSecond => this.As(SpeedUnit.MillimeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.NanometerPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.NanometerPerMinute"/>
         /// </summary>
-        public double NanometersPerMinute => As(SpeedUnit.NanometerPerMinute);
+        public QuantityValue NanometersPerMinute => this.As(SpeedUnit.NanometerPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.NanometerPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.NanometerPerSecond"/>
         /// </summary>
-        public double NanometersPerSecond => As(SpeedUnit.NanometerPerSecond);
+        public QuantityValue NanometersPerSecond => this.As(SpeedUnit.NanometerPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.UsSurveyFootPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.UsSurveyFootPerHour"/>
         /// </summary>
-        public double UsSurveyFeetPerHour => As(SpeedUnit.UsSurveyFootPerHour);
+        public QuantityValue UsSurveyFeetPerHour => this.As(SpeedUnit.UsSurveyFootPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.UsSurveyFootPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.UsSurveyFootPerMinute"/>
         /// </summary>
-        public double UsSurveyFeetPerMinute => As(SpeedUnit.UsSurveyFootPerMinute);
+        public QuantityValue UsSurveyFeetPerMinute => this.As(SpeedUnit.UsSurveyFootPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.UsSurveyFootPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.UsSurveyFootPerSecond"/>
         /// </summary>
-        public double UsSurveyFeetPerSecond => As(SpeedUnit.UsSurveyFootPerSecond);
+        public QuantityValue UsSurveyFeetPerSecond => this.As(SpeedUnit.UsSurveyFootPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.YardPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.YardPerHour"/>
         /// </summary>
-        public double YardsPerHour => As(SpeedUnit.YardPerHour);
+        public QuantityValue YardsPerHour => this.As(SpeedUnit.YardPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.YardPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.YardPerMinute"/>
         /// </summary>
-        public double YardsPerMinute => As(SpeedUnit.YardPerMinute);
+        public QuantityValue YardsPerMinute => this.As(SpeedUnit.YardPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="SpeedUnit.YardPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="SpeedUnit.YardPerSecond"/>
         /// </summary>
-        public double YardsPerSecond => As(SpeedUnit.YardPerSecond);
+        public QuantityValue YardsPerSecond => this.As(SpeedUnit.YardPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: SpeedUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.CentimeterPerHour, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.CentimeterPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.CentimeterPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.DecimeterPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.DecimeterPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.FootPerHour, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.FootPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.FootPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.InchPerHour, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.InchPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.InchPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.KilometerPerHour, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.KilometerPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.KilometerPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.Knot, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.Mach, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerHour, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MicrometerPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MicrometerPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MilePerHour, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MillimeterPerHour, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MillimeterPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MillimeterPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.NanometerPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.NanometerPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.UsSurveyFootPerHour, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.UsSurveyFootPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.UsSurveyFootPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.YardPerHour, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.YardPerMinute, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.YardPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MeterPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.MeterPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> SpeedUnit
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.CentimeterPerHour, quantity => quantity.ToUnit(SpeedUnit.CentimeterPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.CentimeterPerMinute, quantity => quantity.ToUnit(SpeedUnit.CentimeterPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.CentimeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.CentimeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.DecimeterPerMinute, quantity => quantity.ToUnit(SpeedUnit.DecimeterPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.DecimeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.DecimeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.FootPerHour, quantity => quantity.ToUnit(SpeedUnit.FootPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.FootPerMinute, quantity => quantity.ToUnit(SpeedUnit.FootPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.FootPerSecond, quantity => quantity.ToUnit(SpeedUnit.FootPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.InchPerHour, quantity => quantity.ToUnit(SpeedUnit.InchPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.InchPerMinute, quantity => quantity.ToUnit(SpeedUnit.InchPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.InchPerSecond, quantity => quantity.ToUnit(SpeedUnit.InchPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.KilometerPerHour, quantity => quantity.ToUnit(SpeedUnit.KilometerPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.KilometerPerMinute, quantity => quantity.ToUnit(SpeedUnit.KilometerPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.KilometerPerSecond, quantity => quantity.ToUnit(SpeedUnit.KilometerPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.Knot, quantity => quantity.ToUnit(SpeedUnit.Knot));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.Mach, quantity => quantity.ToUnit(SpeedUnit.Mach));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.MeterPerHour, quantity => quantity.ToUnit(SpeedUnit.MeterPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.MeterPerMinute, quantity => quantity.ToUnit(SpeedUnit.MeterPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.MicrometerPerMinute, quantity => quantity.ToUnit(SpeedUnit.MicrometerPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.MicrometerPerSecond, quantity => quantity.ToUnit(SpeedUnit.MicrometerPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.MilePerHour, quantity => quantity.ToUnit(SpeedUnit.MilePerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.MillimeterPerHour, quantity => quantity.ToUnit(SpeedUnit.MillimeterPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.MillimeterPerMinute, quantity => quantity.ToUnit(SpeedUnit.MillimeterPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.MillimeterPerSecond, quantity => quantity.ToUnit(SpeedUnit.MillimeterPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.NanometerPerMinute, quantity => quantity.ToUnit(SpeedUnit.NanometerPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.NanometerPerSecond, quantity => quantity.ToUnit(SpeedUnit.NanometerPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.UsSurveyFootPerHour, quantity => quantity.ToUnit(SpeedUnit.UsSurveyFootPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.UsSurveyFootPerMinute, quantity => quantity.ToUnit(SpeedUnit.UsSurveyFootPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.UsSurveyFootPerSecond, quantity => quantity.ToUnit(SpeedUnit.UsSurveyFootPerSecond));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.YardPerHour, quantity => quantity.ToUnit(SpeedUnit.YardPerHour));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.YardPerMinute, quantity => quantity.ToUnit(SpeedUnit.YardPerMinute));
-            unitConverter.SetConversionFunction<Speed>(SpeedUnit.MeterPerSecond, SpeedUnit.YardPerSecond, quantity => quantity.ToUnit(SpeedUnit.YardPerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -538,7 +520,7 @@ public static string GetAbbreviation(SpeedUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerHour"/>.
         /// </summary>
-        public static Speed FromCentimetersPerHour(double value)
+        public static Speed FromCentimetersPerHour(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.CentimeterPerHour);
         }
@@ -546,7 +528,7 @@ public static Speed FromCentimetersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerMinute"/>.
         /// </summary>
-        public static Speed FromCentimetersPerMinute(double value)
+        public static Speed FromCentimetersPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.CentimeterPerMinute);
         }
@@ -554,7 +536,7 @@ public static Speed FromCentimetersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerSecond"/>.
         /// </summary>
-        public static Speed FromCentimetersPerSecond(double value)
+        public static Speed FromCentimetersPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.CentimeterPerSecond);
         }
@@ -562,7 +544,7 @@ public static Speed FromCentimetersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.DecimeterPerMinute"/>.
         /// </summary>
-        public static Speed FromDecimetersPerMinute(double value)
+        public static Speed FromDecimetersPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.DecimeterPerMinute);
         }
@@ -570,7 +552,7 @@ public static Speed FromDecimetersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.DecimeterPerSecond"/>.
         /// </summary>
-        public static Speed FromDecimetersPerSecond(double value)
+        public static Speed FromDecimetersPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.DecimeterPerSecond);
         }
@@ -578,7 +560,7 @@ public static Speed FromDecimetersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerHour"/>.
         /// </summary>
-        public static Speed FromFeetPerHour(double value)
+        public static Speed FromFeetPerHour(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.FootPerHour);
         }
@@ -586,7 +568,7 @@ public static Speed FromFeetPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerMinute"/>.
         /// </summary>
-        public static Speed FromFeetPerMinute(double value)
+        public static Speed FromFeetPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.FootPerMinute);
         }
@@ -594,7 +576,7 @@ public static Speed FromFeetPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerSecond"/>.
         /// </summary>
-        public static Speed FromFeetPerSecond(double value)
+        public static Speed FromFeetPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.FootPerSecond);
         }
@@ -602,7 +584,7 @@ public static Speed FromFeetPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerHour"/>.
         /// </summary>
-        public static Speed FromInchesPerHour(double value)
+        public static Speed FromInchesPerHour(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.InchPerHour);
         }
@@ -610,7 +592,7 @@ public static Speed FromInchesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerMinute"/>.
         /// </summary>
-        public static Speed FromInchesPerMinute(double value)
+        public static Speed FromInchesPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.InchPerMinute);
         }
@@ -618,7 +600,7 @@ public static Speed FromInchesPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerSecond"/>.
         /// </summary>
-        public static Speed FromInchesPerSecond(double value)
+        public static Speed FromInchesPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.InchPerSecond);
         }
@@ -626,7 +608,7 @@ public static Speed FromInchesPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerHour"/>.
         /// </summary>
-        public static Speed FromKilometersPerHour(double value)
+        public static Speed FromKilometersPerHour(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.KilometerPerHour);
         }
@@ -634,7 +616,7 @@ public static Speed FromKilometersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerMinute"/>.
         /// </summary>
-        public static Speed FromKilometersPerMinute(double value)
+        public static Speed FromKilometersPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.KilometerPerMinute);
         }
@@ -642,7 +624,7 @@ public static Speed FromKilometersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerSecond"/>.
         /// </summary>
-        public static Speed FromKilometersPerSecond(double value)
+        public static Speed FromKilometersPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.KilometerPerSecond);
         }
@@ -650,7 +632,7 @@ public static Speed FromKilometersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.Knot"/>.
         /// </summary>
-        public static Speed FromKnots(double value)
+        public static Speed FromKnots(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.Knot);
         }
@@ -658,7 +640,7 @@ public static Speed FromKnots(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.Mach"/>.
         /// </summary>
-        public static Speed FromMach(double value)
+        public static Speed FromMach(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.Mach);
         }
@@ -666,7 +648,7 @@ public static Speed FromMach(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerHour"/>.
         /// </summary>
-        public static Speed FromMetersPerHour(double value)
+        public static Speed FromMetersPerHour(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.MeterPerHour);
         }
@@ -674,7 +656,7 @@ public static Speed FromMetersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerMinute"/>.
         /// </summary>
-        public static Speed FromMetersPerMinute(double value)
+        public static Speed FromMetersPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.MeterPerMinute);
         }
@@ -682,7 +664,7 @@ public static Speed FromMetersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerSecond"/>.
         /// </summary>
-        public static Speed FromMetersPerSecond(double value)
+        public static Speed FromMetersPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.MeterPerSecond);
         }
@@ -690,7 +672,7 @@ public static Speed FromMetersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MicrometerPerMinute"/>.
         /// </summary>
-        public static Speed FromMicrometersPerMinute(double value)
+        public static Speed FromMicrometersPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.MicrometerPerMinute);
         }
@@ -698,7 +680,7 @@ public static Speed FromMicrometersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MicrometerPerSecond"/>.
         /// </summary>
-        public static Speed FromMicrometersPerSecond(double value)
+        public static Speed FromMicrometersPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.MicrometerPerSecond);
         }
@@ -706,7 +688,7 @@ public static Speed FromMicrometersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MilePerHour"/>.
         /// </summary>
-        public static Speed FromMilesPerHour(double value)
+        public static Speed FromMilesPerHour(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.MilePerHour);
         }
@@ -714,7 +696,7 @@ public static Speed FromMilesPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerHour"/>.
         /// </summary>
-        public static Speed FromMillimetersPerHour(double value)
+        public static Speed FromMillimetersPerHour(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.MillimeterPerHour);
         }
@@ -722,7 +704,7 @@ public static Speed FromMillimetersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerMinute"/>.
         /// </summary>
-        public static Speed FromMillimetersPerMinute(double value)
+        public static Speed FromMillimetersPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.MillimeterPerMinute);
         }
@@ -730,7 +712,7 @@ public static Speed FromMillimetersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerSecond"/>.
         /// </summary>
-        public static Speed FromMillimetersPerSecond(double value)
+        public static Speed FromMillimetersPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.MillimeterPerSecond);
         }
@@ -738,7 +720,7 @@ public static Speed FromMillimetersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.NanometerPerMinute"/>.
         /// </summary>
-        public static Speed FromNanometersPerMinute(double value)
+        public static Speed FromNanometersPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.NanometerPerMinute);
         }
@@ -746,7 +728,7 @@ public static Speed FromNanometersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.NanometerPerSecond"/>.
         /// </summary>
-        public static Speed FromNanometersPerSecond(double value)
+        public static Speed FromNanometersPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.NanometerPerSecond);
         }
@@ -754,7 +736,7 @@ public static Speed FromNanometersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerHour"/>.
         /// </summary>
-        public static Speed FromUsSurveyFeetPerHour(double value)
+        public static Speed FromUsSurveyFeetPerHour(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.UsSurveyFootPerHour);
         }
@@ -762,7 +744,7 @@ public static Speed FromUsSurveyFeetPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerMinute"/>.
         /// </summary>
-        public static Speed FromUsSurveyFeetPerMinute(double value)
+        public static Speed FromUsSurveyFeetPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.UsSurveyFootPerMinute);
         }
@@ -770,7 +752,7 @@ public static Speed FromUsSurveyFeetPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerSecond"/>.
         /// </summary>
-        public static Speed FromUsSurveyFeetPerSecond(double value)
+        public static Speed FromUsSurveyFeetPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.UsSurveyFootPerSecond);
         }
@@ -778,7 +760,7 @@ public static Speed FromUsSurveyFeetPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerHour"/>.
         /// </summary>
-        public static Speed FromYardsPerHour(double value)
+        public static Speed FromYardsPerHour(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.YardPerHour);
         }
@@ -786,7 +768,7 @@ public static Speed FromYardsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerMinute"/>.
         /// </summary>
-        public static Speed FromYardsPerMinute(double value)
+        public static Speed FromYardsPerMinute(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.YardPerMinute);
         }
@@ -794,7 +776,7 @@ public static Speed FromYardsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerSecond"/>.
         /// </summary>
-        public static Speed FromYardsPerSecond(double value)
+        public static Speed FromYardsPerSecond(QuantityValue value)
         {
             return new Speed(value, SpeedUnit.YardPerSecond);
         }
@@ -805,7 +787,7 @@ public static Speed FromYardsPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Speed unit value.</returns>
-        public static Speed From(double value, SpeedUnit fromUnit)
+        public static Speed From(QuantityValue value, SpeedUnit fromUnit)
         {
             return new Speed(value, fromUnit);
         }
@@ -866,10 +848,7 @@ public static Speed Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Speed Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Speed, SpeedUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Speed, SpeedUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -897,11 +876,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Speed result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Speed result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Speed, SpeedUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Speed, SpeedUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -922,7 +897,7 @@ public static SpeedUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -933,7 +908,7 @@ public static SpeedUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.SpeedUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.SpeedUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpeedUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -948,7 +923,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out SpeedUnit un
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out SpeedUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -967,35 +942,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Speed"/> from adding two <see cref="Speed"/>.</summary>
         public static Speed operator +(Speed left, Speed right)
         {
-            return new Speed(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Speed(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Speed"/> from subtracting two <see cref="Speed"/>.</summary>
         public static Speed operator -(Speed left, Speed right)
         {
-            return new Speed(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Speed(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Speed"/> from multiplying value and <see cref="Speed"/>.</summary>
-        public static Speed operator *(double left, Speed right)
+        public static Speed operator *(QuantityValue left, Speed right)
         {
             return new Speed(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Speed"/> from multiplying value and <see cref="Speed"/>.</summary>
-        public static Speed operator *(Speed left, double right)
+        public static Speed operator *(Speed left, QuantityValue right)
         {
             return new Speed(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Speed"/> from dividing <see cref="Speed"/> by value.</summary>
-        public static Speed operator /(Speed left, double right)
+        public static Speed operator /(Speed left, QuantityValue right)
         {
             return new Speed(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Speed"/> by <see cref="Speed"/>.</summary>
-        public static double operator /(Speed left, Speed right)
+        public static QuantityValue operator /(Speed left, Speed right)
         {
             return left.MetersPerSecond / right.MetersPerSecond;
         }
@@ -1059,97 +1034,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Speed left, Speed right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Speed left, Speed right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Speed left, Speed right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Speed left, Speed right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Speed"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Speed other, Speed tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Speed"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Speed)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Speed left, Speed right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Speed"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Speed other, Speed tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Speed"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Speed,Speed)"/>.
+        ///     See that operator (and <see cref="Equals(Speed)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Speed left, Speed right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Speed"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Speed other, Speed tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Speed"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Speed"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Speed"/>, this method delegates to
+        ///     <see cref="Equals(Speed)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Speed otherQuantity))
+            if (obj is not Speed otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Speed"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Speed other, Speed tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Speed"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Speed other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Speed.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Speed), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Speed"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Speed)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Speed otherQuantity)) throw new ArgumentException("Expected type Speed.", nameof(obj));
+            if (obj is not Speed otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Speed>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Speed"/> with another <see cref="Speed"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Speed"/> with another <see cref="Speed"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1161,193 +1150,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Speed other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(SpeedUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<SpeedUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Speed to another Speed with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Speed with the specified unit.</returns>
-        public Speed ToUnit(SpeedUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Speed"/> to another <see cref="Speed"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Speed with the specified unit.</returns>
-        public Speed ToUnit(SpeedUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Speed), Unit, typeof(Speed), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Speed)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="Speed"/> to another <see cref="Speed"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Speed"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(SpeedUnit unit, [NotNullWhen(true)] out Speed? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Speed? convertedOrNull = (Unit, unit) switch
-            {
-                // SpeedUnit -> BaseUnit
-                (SpeedUnit.CentimeterPerHour, SpeedUnit.MeterPerSecond) => new Speed((_value / 3600) * 1e-2d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.CentimeterPerMinute, SpeedUnit.MeterPerSecond) => new Speed((_value / 60) * 1e-2d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.CentimeterPerSecond, SpeedUnit.MeterPerSecond) => new Speed((_value) * 1e-2d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.DecimeterPerMinute, SpeedUnit.MeterPerSecond) => new Speed((_value / 60) * 1e-1d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.DecimeterPerSecond, SpeedUnit.MeterPerSecond) => new Speed((_value) * 1e-1d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.FootPerHour, SpeedUnit.MeterPerSecond) => new Speed(_value * 0.3048 / 3600, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.FootPerMinute, SpeedUnit.MeterPerSecond) => new Speed(_value * 0.3048 / 60, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.FootPerSecond, SpeedUnit.MeterPerSecond) => new Speed(_value * 0.3048, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.InchPerHour, SpeedUnit.MeterPerSecond) => new Speed((_value / 3600) * 2.54e-2, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.InchPerMinute, SpeedUnit.MeterPerSecond) => new Speed((_value / 60) * 2.54e-2, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.InchPerSecond, SpeedUnit.MeterPerSecond) => new Speed(_value * 2.54e-2, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.KilometerPerHour, SpeedUnit.MeterPerSecond) => new Speed((_value / 3600) * 1e3d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.KilometerPerMinute, SpeedUnit.MeterPerSecond) => new Speed((_value / 60) * 1e3d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.KilometerPerSecond, SpeedUnit.MeterPerSecond) => new Speed((_value) * 1e3d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.Knot, SpeedUnit.MeterPerSecond) => new Speed(_value * (1852.0 / 3600.0), SpeedUnit.MeterPerSecond),
-                (SpeedUnit.Mach, SpeedUnit.MeterPerSecond) => new Speed(_value * 340.29, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.MeterPerHour, SpeedUnit.MeterPerSecond) => new Speed(_value / 3600, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.MeterPerMinute, SpeedUnit.MeterPerSecond) => new Speed(_value / 60, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.MicrometerPerMinute, SpeedUnit.MeterPerSecond) => new Speed((_value / 60) * 1e-6d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.MicrometerPerSecond, SpeedUnit.MeterPerSecond) => new Speed((_value) * 1e-6d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.MilePerHour, SpeedUnit.MeterPerSecond) => new Speed(_value * 0.44704, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.MillimeterPerHour, SpeedUnit.MeterPerSecond) => new Speed((_value / 3600) * 1e-3d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.MillimeterPerMinute, SpeedUnit.MeterPerSecond) => new Speed((_value / 60) * 1e-3d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.MillimeterPerSecond, SpeedUnit.MeterPerSecond) => new Speed((_value) * 1e-3d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.NanometerPerMinute, SpeedUnit.MeterPerSecond) => new Speed((_value / 60) * 1e-9d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.NanometerPerSecond, SpeedUnit.MeterPerSecond) => new Speed((_value) * 1e-9d, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.UsSurveyFootPerHour, SpeedUnit.MeterPerSecond) => new Speed((_value * 1200 / 3937) / 3600, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.UsSurveyFootPerMinute, SpeedUnit.MeterPerSecond) => new Speed((_value * 1200 / 3937) / 60, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.UsSurveyFootPerSecond, SpeedUnit.MeterPerSecond) => new Speed(_value * 1200 / 3937, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.YardPerHour, SpeedUnit.MeterPerSecond) => new Speed(_value * 0.9144 / 3600, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.YardPerMinute, SpeedUnit.MeterPerSecond) => new Speed(_value * 0.9144 / 60, SpeedUnit.MeterPerSecond),
-                (SpeedUnit.YardPerSecond, SpeedUnit.MeterPerSecond) => new Speed(_value * 0.9144, SpeedUnit.MeterPerSecond),
-
-                // BaseUnit -> SpeedUnit
-                (SpeedUnit.MeterPerSecond, SpeedUnit.CentimeterPerHour) => new Speed((_value * 3600) / 1e-2d, SpeedUnit.CentimeterPerHour),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.CentimeterPerMinute) => new Speed((_value * 60) / 1e-2d, SpeedUnit.CentimeterPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.CentimeterPerSecond) => new Speed((_value) / 1e-2d, SpeedUnit.CentimeterPerSecond),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.DecimeterPerMinute) => new Speed((_value * 60) / 1e-1d, SpeedUnit.DecimeterPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.DecimeterPerSecond) => new Speed((_value) / 1e-1d, SpeedUnit.DecimeterPerSecond),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.FootPerHour) => new Speed(_value / 0.3048 * 3600, SpeedUnit.FootPerHour),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.FootPerMinute) => new Speed(_value / 0.3048 * 60, SpeedUnit.FootPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.FootPerSecond) => new Speed(_value / 0.3048, SpeedUnit.FootPerSecond),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.InchPerHour) => new Speed((_value / 2.54e-2) * 3600, SpeedUnit.InchPerHour),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.InchPerMinute) => new Speed((_value / 2.54e-2) * 60, SpeedUnit.InchPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.InchPerSecond) => new Speed(_value / 2.54e-2, SpeedUnit.InchPerSecond),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.KilometerPerHour) => new Speed((_value * 3600) / 1e3d, SpeedUnit.KilometerPerHour),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.KilometerPerMinute) => new Speed((_value * 60) / 1e3d, SpeedUnit.KilometerPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.KilometerPerSecond) => new Speed((_value) / 1e3d, SpeedUnit.KilometerPerSecond),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.Knot) => new Speed(_value / (1852.0 / 3600.0), SpeedUnit.Knot),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.Mach) => new Speed(_value / 340.29, SpeedUnit.Mach),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.MeterPerHour) => new Speed(_value * 3600, SpeedUnit.MeterPerHour),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.MeterPerMinute) => new Speed(_value * 60, SpeedUnit.MeterPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.MicrometerPerMinute) => new Speed((_value * 60) / 1e-6d, SpeedUnit.MicrometerPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.MicrometerPerSecond) => new Speed((_value) / 1e-6d, SpeedUnit.MicrometerPerSecond),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.MilePerHour) => new Speed(_value / 0.44704, SpeedUnit.MilePerHour),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.MillimeterPerHour) => new Speed((_value * 3600) / 1e-3d, SpeedUnit.MillimeterPerHour),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.MillimeterPerMinute) => new Speed((_value * 60) / 1e-3d, SpeedUnit.MillimeterPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.MillimeterPerSecond) => new Speed((_value) / 1e-3d, SpeedUnit.MillimeterPerSecond),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.NanometerPerMinute) => new Speed((_value * 60) / 1e-9d, SpeedUnit.NanometerPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.NanometerPerSecond) => new Speed((_value) / 1e-9d, SpeedUnit.NanometerPerSecond),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.UsSurveyFootPerHour) => new Speed((_value * 3937 / 1200) * 3600, SpeedUnit.UsSurveyFootPerHour),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.UsSurveyFootPerMinute) => new Speed((_value * 3937 / 1200) * 60, SpeedUnit.UsSurveyFootPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.UsSurveyFootPerSecond) => new Speed(_value * 3937 / 1200, SpeedUnit.UsSurveyFootPerSecond),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.YardPerHour) => new Speed(_value / 0.9144 * 3600, SpeedUnit.YardPerHour),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.YardPerMinute) => new Speed(_value / 0.9144 * 60, SpeedUnit.YardPerMinute),
-                (SpeedUnit.MeterPerSecond, SpeedUnit.YardPerSecond) => new Speed(_value / 0.9144, SpeedUnit.YardPerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not SpeedUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpeedUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is SpeedUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpeedUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<SpeedUnit> IQuantity<SpeedUnit>.ToUnit(SpeedUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1361,11 +1166,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
index 34a3c09609..1abc8c9f8c 100644
--- a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     The molar flow rate of a gas corrected to standardized conditions of temperature and pressure thus representing a fixed number of moles of gas regardless of composition and actual flow conditions.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct StandardVolumeFlow :
-        IArithmeticQuantity<StandardVolumeFlow, StandardVolumeFlowUnit>,
+        ILinearQuantity<StandardVolumeFlow, StandardVolumeFlowUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<StandardVolumeFlow, StandardVolumeFlow, double>,
+        IDivisionOperators<StandardVolumeFlow, StandardVolumeFlow, QuantityValue>,
         IComparisonOperators<StandardVolumeFlow, StandardVolumeFlow, bool>,
         IParsable<StandardVolumeFlow>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +101,7 @@ public static StandardVolumeFlowInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="StandardVolumeFlow"/> is [T^-1][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="StandardVolumeFlow"/> is T^-1M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 1, -1, 0, 0, 0, 0);
 
@@ -117,23 +116,37 @@ public static StandardVolumeFlowInfo CreateDefault(Func<IEnumerable<UnitDefiniti
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{StandardVolumeFlowUnit}"/> representing the default unit mappings for StandardVolumeFlow.</returns>
             public static IEnumerable<UnitDefinition<StandardVolumeFlowUnit>> GetDefaultMappings()
             {
-                yield return new (StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute, "StandardCubicCentimeterPerMinute", "StandardCubicCentimetersPerMinute", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Minute));
-                yield return new (StandardVolumeFlowUnit.StandardCubicFootPerHour, "StandardCubicFootPerHour", "StandardCubicFeetPerHour", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Hour));
-                yield return new (StandardVolumeFlowUnit.StandardCubicFootPerMinute, "StandardCubicFootPerMinute", "StandardCubicFeetPerMinute", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Minute));
-                yield return new (StandardVolumeFlowUnit.StandardCubicFootPerSecond, "StandardCubicFootPerSecond", "StandardCubicFeetPerSecond", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second));
-                yield return new (StandardVolumeFlowUnit.StandardCubicMeterPerDay, "StandardCubicMeterPerDay", "StandardCubicMetersPerDay", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Day));
-                yield return new (StandardVolumeFlowUnit.StandardCubicMeterPerHour, "StandardCubicMeterPerHour", "StandardCubicMetersPerHour", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Hour));
-                yield return new (StandardVolumeFlowUnit.StandardCubicMeterPerMinute, "StandardCubicMeterPerMinute", "StandardCubicMetersPerMinute", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Minute));
+                yield return new (StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute, "StandardCubicCentimeterPerMinute", "StandardCubicCentimetersPerMinute", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Minute),
+                     60000000
+                );
+                yield return new (StandardVolumeFlowUnit.StandardCubicFootPerHour, "StandardCubicFootPerHour", "StandardCubicFeetPerHour", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Hour),
+                     new QuantityValue(781250000000, 6145149)
+                );
+                yield return new (StandardVolumeFlowUnit.StandardCubicFootPerMinute, "StandardCubicFootPerMinute", "StandardCubicFeetPerMinute", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Minute),
+                     new QuantityValue(39062500000, 18435447)
+                );
+                yield return new (StandardVolumeFlowUnit.StandardCubicFootPerSecond, "StandardCubicFootPerSecond", "StandardCubicFeetPerSecond", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second),
+                     new QuantityValue(1953125000, 55306341)
+                );
+                yield return new (StandardVolumeFlowUnit.StandardCubicMeterPerDay, "StandardCubicMeterPerDay", "StandardCubicMetersPerDay", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Day),
+                     86400
+                );
+                yield return new (StandardVolumeFlowUnit.StandardCubicMeterPerHour, "StandardCubicMeterPerHour", "StandardCubicMetersPerHour", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Hour),
+                     3600
+                );
+                yield return new (StandardVolumeFlowUnit.StandardCubicMeterPerMinute, "StandardCubicMeterPerMinute", "StandardCubicMetersPerMinute", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Minute),
+                     60
+                );
                 yield return new (StandardVolumeFlowUnit.StandardCubicMeterPerSecond, "StandardCubicMeterPerSecond", "StandardCubicMetersPerSecond", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (StandardVolumeFlowUnit.StandardLiterPerMinute, "StandardLiterPerMinute", "StandardLitersPerMinute", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Minute));
+                yield return new (StandardVolumeFlowUnit.StandardLiterPerMinute, "StandardLiterPerMinute", "StandardLitersPerMinute", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Minute),
+                     60000
+                );
             }
         }
 
         static StandardVolumeFlow()
         {
-            Info = StandardVolumeFlowInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(StandardVolumeFlowInfo.CreateDefault);
         }
 
         /// <summary>
@@ -141,7 +154,7 @@ static StandardVolumeFlow()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public StandardVolumeFlow(double value, StandardVolumeFlowUnit unit)
+        public StandardVolumeFlow(QuantityValue value, StandardVolumeFlowUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -155,7 +168,7 @@ public StandardVolumeFlow(double value, StandardVolumeFlowUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public StandardVolumeFlow(double value, UnitSystem unitSystem)
+        public StandardVolumeFlow(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -166,7 +179,8 @@ public StandardVolumeFlow(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="StandardVolumeFlow" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<StandardVolumeFlow, StandardVolumeFlowUnit> Info { get; }
@@ -195,10 +209,8 @@ public StandardVolumeFlow(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public StandardVolumeFlowUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -232,84 +244,54 @@ public StandardVolumeFlow(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute"/>
         /// </summary>
-        public double StandardCubicCentimetersPerMinute => As(StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute);
+        public QuantityValue StandardCubicCentimetersPerMinute => this.As(StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicFootPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicFootPerHour"/>
         /// </summary>
-        public double StandardCubicFeetPerHour => As(StandardVolumeFlowUnit.StandardCubicFootPerHour);
+        public QuantityValue StandardCubicFeetPerHour => this.As(StandardVolumeFlowUnit.StandardCubicFootPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicFootPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicFootPerMinute"/>
         /// </summary>
-        public double StandardCubicFeetPerMinute => As(StandardVolumeFlowUnit.StandardCubicFootPerMinute);
+        public QuantityValue StandardCubicFeetPerMinute => this.As(StandardVolumeFlowUnit.StandardCubicFootPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicFootPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicFootPerSecond"/>
         /// </summary>
-        public double StandardCubicFeetPerSecond => As(StandardVolumeFlowUnit.StandardCubicFootPerSecond);
+        public QuantityValue StandardCubicFeetPerSecond => this.As(StandardVolumeFlowUnit.StandardCubicFootPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerDay"/>
         /// </summary>
-        public double StandardCubicMetersPerDay => As(StandardVolumeFlowUnit.StandardCubicMeterPerDay);
+        public QuantityValue StandardCubicMetersPerDay => this.As(StandardVolumeFlowUnit.StandardCubicMeterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerHour"/>
         /// </summary>
-        public double StandardCubicMetersPerHour => As(StandardVolumeFlowUnit.StandardCubicMeterPerHour);
+        public QuantityValue StandardCubicMetersPerHour => this.As(StandardVolumeFlowUnit.StandardCubicMeterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerMinute"/>
         /// </summary>
-        public double StandardCubicMetersPerMinute => As(StandardVolumeFlowUnit.StandardCubicMeterPerMinute);
+        public QuantityValue StandardCubicMetersPerMinute => this.As(StandardVolumeFlowUnit.StandardCubicMeterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerSecond"/>
         /// </summary>
-        public double StandardCubicMetersPerSecond => As(StandardVolumeFlowUnit.StandardCubicMeterPerSecond);
+        public QuantityValue StandardCubicMetersPerSecond => this.As(StandardVolumeFlowUnit.StandardCubicMeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardLiterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="StandardVolumeFlowUnit.StandardLiterPerMinute"/>
         /// </summary>
-        public double StandardLitersPerMinute => As(StandardVolumeFlowUnit.StandardLiterPerMinute);
+        public QuantityValue StandardLitersPerMinute => this.As(StandardVolumeFlowUnit.StandardLiterPerMinute);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: StandardVolumeFlowUnit -> BaseUnit
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerSecond));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicFootPerHour, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerSecond));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicFootPerMinute, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerSecond));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicFootPerSecond, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerSecond));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerDay, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerSecond));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerHour, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerSecond));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerMinute, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerSecond));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardLiterPerMinute, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicMeterPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> StandardVolumeFlowUnit
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicFootPerHour, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicFootPerHour));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicFootPerMinute, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicFootPerMinute));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicFootPerSecond, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicFootPerSecond));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicMeterPerDay, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerDay));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicMeterPerHour, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerHour));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicMeterPerMinute, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardCubicMeterPerMinute));
-            unitConverter.SetConversionFunction<StandardVolumeFlow>(StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardLiterPerMinute, quantity => quantity.ToUnit(StandardVolumeFlowUnit.StandardLiterPerMinute));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -338,7 +320,7 @@ public static string GetAbbreviation(StandardVolumeFlowUnit unit, IFormatProvide
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute"/>.
         /// </summary>
-        public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(double value)
+        public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(QuantityValue value)
         {
             return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute);
         }
@@ -346,7 +328,7 @@ public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(double va
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerHour"/>.
         /// </summary>
-        public static StandardVolumeFlow FromStandardCubicFeetPerHour(double value)
+        public static StandardVolumeFlow FromStandardCubicFeetPerHour(QuantityValue value)
         {
             return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerHour);
         }
@@ -354,7 +336,7 @@ public static StandardVolumeFlow FromStandardCubicFeetPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerMinute"/>.
         /// </summary>
-        public static StandardVolumeFlow FromStandardCubicFeetPerMinute(double value)
+        public static StandardVolumeFlow FromStandardCubicFeetPerMinute(QuantityValue value)
         {
             return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerMinute);
         }
@@ -362,7 +344,7 @@ public static StandardVolumeFlow FromStandardCubicFeetPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerSecond"/>.
         /// </summary>
-        public static StandardVolumeFlow FromStandardCubicFeetPerSecond(double value)
+        public static StandardVolumeFlow FromStandardCubicFeetPerSecond(QuantityValue value)
         {
             return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerSecond);
         }
@@ -370,7 +352,7 @@ public static StandardVolumeFlow FromStandardCubicFeetPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerDay"/>.
         /// </summary>
-        public static StandardVolumeFlow FromStandardCubicMetersPerDay(double value)
+        public static StandardVolumeFlow FromStandardCubicMetersPerDay(QuantityValue value)
         {
             return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerDay);
         }
@@ -378,7 +360,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerHour"/>.
         /// </summary>
-        public static StandardVolumeFlow FromStandardCubicMetersPerHour(double value)
+        public static StandardVolumeFlow FromStandardCubicMetersPerHour(QuantityValue value)
         {
             return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerHour);
         }
@@ -386,7 +368,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerMinute"/>.
         /// </summary>
-        public static StandardVolumeFlow FromStandardCubicMetersPerMinute(double value)
+        public static StandardVolumeFlow FromStandardCubicMetersPerMinute(QuantityValue value)
         {
             return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerMinute);
         }
@@ -394,7 +376,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerSecond"/>.
         /// </summary>
-        public static StandardVolumeFlow FromStandardCubicMetersPerSecond(double value)
+        public static StandardVolumeFlow FromStandardCubicMetersPerSecond(QuantityValue value)
         {
             return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerSecond);
         }
@@ -402,7 +384,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardLiterPerMinute"/>.
         /// </summary>
-        public static StandardVolumeFlow FromStandardLitersPerMinute(double value)
+        public static StandardVolumeFlow FromStandardLitersPerMinute(QuantityValue value)
         {
             return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardLiterPerMinute);
         }
@@ -413,7 +395,7 @@ public static StandardVolumeFlow FromStandardLitersPerMinute(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>StandardVolumeFlow unit value.</returns>
-        public static StandardVolumeFlow From(double value, StandardVolumeFlowUnit fromUnit)
+        public static StandardVolumeFlow From(QuantityValue value, StandardVolumeFlowUnit fromUnit)
         {
             return new StandardVolumeFlow(value, fromUnit);
         }
@@ -474,10 +456,7 @@ public static StandardVolumeFlow Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static StandardVolumeFlow Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<StandardVolumeFlow, StandardVolumeFlowUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<StandardVolumeFlow, StandardVolumeFlowUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -505,11 +484,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out StandardVolumeFl
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out StandardVolumeFlow result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<StandardVolumeFlow, StandardVolumeFlowUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<StandardVolumeFlow, StandardVolumeFlowUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -530,7 +505,7 @@ public static StandardVolumeFlowUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -541,7 +516,7 @@ public static StandardVolumeFlowUnit ParseUnit(string str, IFormatProvider? prov
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.StandardVolumeFlowUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.StandardVolumeFlowUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out StandardVolumeFlowUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -556,7 +531,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out StandardVolu
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out StandardVolumeFlowUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -575,35 +550,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="StandardVolumeFlow"/> from adding two <see cref="StandardVolumeFlow"/>.</summary>
         public static StandardVolumeFlow operator +(StandardVolumeFlow left, StandardVolumeFlow right)
         {
-            return new StandardVolumeFlow(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new StandardVolumeFlow(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="StandardVolumeFlow"/> from subtracting two <see cref="StandardVolumeFlow"/>.</summary>
         public static StandardVolumeFlow operator -(StandardVolumeFlow left, StandardVolumeFlow right)
         {
-            return new StandardVolumeFlow(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new StandardVolumeFlow(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="StandardVolumeFlow"/> from multiplying value and <see cref="StandardVolumeFlow"/>.</summary>
-        public static StandardVolumeFlow operator *(double left, StandardVolumeFlow right)
+        public static StandardVolumeFlow operator *(QuantityValue left, StandardVolumeFlow right)
         {
             return new StandardVolumeFlow(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="StandardVolumeFlow"/> from multiplying value and <see cref="StandardVolumeFlow"/>.</summary>
-        public static StandardVolumeFlow operator *(StandardVolumeFlow left, double right)
+        public static StandardVolumeFlow operator *(StandardVolumeFlow left, QuantityValue right)
         {
             return new StandardVolumeFlow(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="StandardVolumeFlow"/> from dividing <see cref="StandardVolumeFlow"/> by value.</summary>
-        public static StandardVolumeFlow operator /(StandardVolumeFlow left, double right)
+        public static StandardVolumeFlow operator /(StandardVolumeFlow left, QuantityValue right)
         {
             return new StandardVolumeFlow(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="StandardVolumeFlow"/> by <see cref="StandardVolumeFlow"/>.</summary>
-        public static double operator /(StandardVolumeFlow left, StandardVolumeFlow right)
+        public static QuantityValue operator /(StandardVolumeFlow left, StandardVolumeFlow right)
         {
             return left.StandardCubicMetersPerSecond / right.StandardCubicMetersPerSecond;
         }
@@ -615,97 +590,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(StandardVolumeFlow left, StandardVolumeFlow right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(StandardVolumeFlow left, StandardVolumeFlow right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(StandardVolumeFlow left, StandardVolumeFlow right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(StandardVolumeFlow left, StandardVolumeFlow right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="StandardVolumeFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(StandardVolumeFlow other, StandardVolumeFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="StandardVolumeFlow"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(StandardVolumeFlow)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(StandardVolumeFlow left, StandardVolumeFlow right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="StandardVolumeFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(StandardVolumeFlow other, StandardVolumeFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="StandardVolumeFlow"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(StandardVolumeFlow,StandardVolumeFlow)"/>.
+        ///     See that operator (and <see cref="Equals(StandardVolumeFlow)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(StandardVolumeFlow left, StandardVolumeFlow right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="StandardVolumeFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(StandardVolumeFlow other, StandardVolumeFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="StandardVolumeFlow"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="StandardVolumeFlow"/>.
+        ///     When <paramref name="obj"/> is a <see cref="StandardVolumeFlow"/>, this method delegates to
+        ///     <see cref="Equals(StandardVolumeFlow)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is StandardVolumeFlow otherQuantity))
+            if (obj is not StandardVolumeFlow otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="StandardVolumeFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(StandardVolumeFlow other, StandardVolumeFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="StandardVolumeFlow"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(StandardVolumeFlow other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current StandardVolumeFlow.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(StandardVolumeFlow), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="StandardVolumeFlow"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(StandardVolumeFlow)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is StandardVolumeFlow otherQuantity)) throw new ArgumentException("Expected type StandardVolumeFlow.", nameof(obj));
+            if (obj is not StandardVolumeFlow otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<StandardVolumeFlow>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="StandardVolumeFlow"/> with another <see cref="StandardVolumeFlow"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="StandardVolumeFlow"/> with another <see cref="StandardVolumeFlow"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -717,145 +706,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(StandardVolumeFlow other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(StandardVolumeFlowUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<StandardVolumeFlowUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this StandardVolumeFlow to another StandardVolumeFlow with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A StandardVolumeFlow with the specified unit.</returns>
-        public StandardVolumeFlow ToUnit(StandardVolumeFlowUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="StandardVolumeFlow"/> to another <see cref="StandardVolumeFlow"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A StandardVolumeFlow with the specified unit.</returns>
-        public StandardVolumeFlow ToUnit(StandardVolumeFlowUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(StandardVolumeFlow), Unit, typeof(StandardVolumeFlow), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (StandardVolumeFlow)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="StandardVolumeFlow"/> to another <see cref="StandardVolumeFlow"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="StandardVolumeFlow"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(StandardVolumeFlowUnit unit, [NotNullWhen(true)] out StandardVolumeFlow? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            StandardVolumeFlow? convertedOrNull = (Unit, unit) switch
-            {
-                // StandardVolumeFlowUnit -> BaseUnit
-                (StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute, StandardVolumeFlowUnit.StandardCubicMeterPerSecond) => new StandardVolumeFlow(_value / 6e7, StandardVolumeFlowUnit.StandardCubicMeterPerSecond),
-                (StandardVolumeFlowUnit.StandardCubicFootPerHour, StandardVolumeFlowUnit.StandardCubicMeterPerSecond) => new StandardVolumeFlow(_value * 0.028316846592 / 3600, StandardVolumeFlowUnit.StandardCubicMeterPerSecond),
-                (StandardVolumeFlowUnit.StandardCubicFootPerMinute, StandardVolumeFlowUnit.StandardCubicMeterPerSecond) => new StandardVolumeFlow(_value * 0.028316846592 / 60, StandardVolumeFlowUnit.StandardCubicMeterPerSecond),
-                (StandardVolumeFlowUnit.StandardCubicFootPerSecond, StandardVolumeFlowUnit.StandardCubicMeterPerSecond) => new StandardVolumeFlow(_value * 0.028316846592, StandardVolumeFlowUnit.StandardCubicMeterPerSecond),
-                (StandardVolumeFlowUnit.StandardCubicMeterPerDay, StandardVolumeFlowUnit.StandardCubicMeterPerSecond) => new StandardVolumeFlow(_value / 86400, StandardVolumeFlowUnit.StandardCubicMeterPerSecond),
-                (StandardVolumeFlowUnit.StandardCubicMeterPerHour, StandardVolumeFlowUnit.StandardCubicMeterPerSecond) => new StandardVolumeFlow(_value / 3600, StandardVolumeFlowUnit.StandardCubicMeterPerSecond),
-                (StandardVolumeFlowUnit.StandardCubicMeterPerMinute, StandardVolumeFlowUnit.StandardCubicMeterPerSecond) => new StandardVolumeFlow(_value / 60, StandardVolumeFlowUnit.StandardCubicMeterPerSecond),
-                (StandardVolumeFlowUnit.StandardLiterPerMinute, StandardVolumeFlowUnit.StandardCubicMeterPerSecond) => new StandardVolumeFlow(_value / 60000, StandardVolumeFlowUnit.StandardCubicMeterPerSecond),
-
-                // BaseUnit -> StandardVolumeFlowUnit
-                (StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute) => new StandardVolumeFlow(_value * 6e7, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute),
-                (StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicFootPerHour) => new StandardVolumeFlow(_value / (0.028316846592 / 3600), StandardVolumeFlowUnit.StandardCubicFootPerHour),
-                (StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicFootPerMinute) => new StandardVolumeFlow(_value / (0.028316846592 / 60), StandardVolumeFlowUnit.StandardCubicFootPerMinute),
-                (StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicFootPerSecond) => new StandardVolumeFlow(_value / 0.028316846592, StandardVolumeFlowUnit.StandardCubicFootPerSecond),
-                (StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicMeterPerDay) => new StandardVolumeFlow(_value * 86400, StandardVolumeFlowUnit.StandardCubicMeterPerDay),
-                (StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicMeterPerHour) => new StandardVolumeFlow(_value * 3600, StandardVolumeFlowUnit.StandardCubicMeterPerHour),
-                (StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardCubicMeterPerMinute) => new StandardVolumeFlow(_value * 60, StandardVolumeFlowUnit.StandardCubicMeterPerMinute),
-                (StandardVolumeFlowUnit.StandardCubicMeterPerSecond, StandardVolumeFlowUnit.StandardLiterPerMinute) => new StandardVolumeFlow(_value * 60000, StandardVolumeFlowUnit.StandardLiterPerMinute),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not StandardVolumeFlowUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(StandardVolumeFlowUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is StandardVolumeFlowUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(StandardVolumeFlowUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<StandardVolumeFlowUnit> IQuantity<StandardVolumeFlowUnit>.ToUnit(StandardVolumeFlowUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -869,11 +722,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
index 94e66aff64..a4d01e36c7 100644
--- a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,7 +33,8 @@ namespace UnitsNet
     ///     A temperature is a numerical measure of hot or cold. Its measurement is by detection of heat radiation or particle velocity or kinetic energy, or by the bulk behavior of a thermometric material. It may be calibrated in any of various temperature scales, Celsius, Fahrenheit, Kelvin, etc. The fundamental physical definition of temperature is provided by thermodynamics.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Temperature :
         IAffineQuantity<Temperature, TemperatureUnit, TemperatureDelta>,
 #if NET7_0_OR_GREATER
@@ -51,7 +50,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -101,7 +100,7 @@ public static TemperatureInfo CreateDefault(Func<IEnumerable<UnitDefinition<Temp
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Temperature"/> is [Θ].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Temperature"/> is Θ.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, 0, 0, 1, 0, 0);
 
@@ -116,24 +115,47 @@ public static TemperatureInfo CreateDefault(Func<IEnumerable<UnitDefinition<Temp
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{TemperatureUnit}"/> representing the default unit mappings for Temperature.</returns>
             public static IEnumerable<UnitDefinition<TemperatureUnit>> GetDefaultMappings()
             {
-                yield return new (TemperatureUnit.DegreeCelsius, "DegreeCelsius", "DegreesCelsius", new BaseUnits(temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (TemperatureUnit.DegreeDelisle, "DegreeDelisle", "DegreesDelisle", new BaseUnits(temperature: TemperatureUnit.DegreeDelisle));
-                yield return new (TemperatureUnit.DegreeFahrenheit, "DegreeFahrenheit", "DegreesFahrenheit", new BaseUnits(temperature: TemperatureUnit.DegreeFahrenheit));
-                yield return new (TemperatureUnit.DegreeNewton, "DegreeNewton", "DegreesNewton", new BaseUnits(temperature: TemperatureUnit.DegreeNewton));
-                yield return new (TemperatureUnit.DegreeRankine, "DegreeRankine", "DegreesRankine", new BaseUnits(temperature: TemperatureUnit.DegreeRankine));
-                yield return new (TemperatureUnit.DegreeReaumur, "DegreeReaumur", "DegreesReaumur", new BaseUnits(temperature: TemperatureUnit.DegreeReaumur));
-                yield return new (TemperatureUnit.DegreeRoemer, "DegreeRoemer", "DegreesRoemer", new BaseUnits(temperature: TemperatureUnit.DegreeRoemer));
+                yield return new (TemperatureUnit.DegreeCelsius, "DegreeCelsius", "DegreesCelsius", new BaseUnits(temperature: TemperatureUnit.DegreeCelsius),
+                     new ConversionExpression(coefficient: 1, constantTerm: new QuantityValue(-5463, 20)),
+                     new ConversionExpression(coefficient: 1, constantTerm: new QuantityValue(5463, 20))
+                );
+                yield return new (TemperatureUnit.DegreeDelisle, "DegreeDelisle", "DegreesDelisle", new BaseUnits(temperature: TemperatureUnit.DegreeDelisle),
+                     new ConversionExpression(coefficient: new QuantityValue(-3, 2), constantTerm: new QuantityValue(22389, 40)),
+                     new ConversionExpression(coefficient: new QuantityValue(-2, 3), constantTerm: new QuantityValue(7463, 20))
+                );
+                yield return new (TemperatureUnit.DegreeFahrenheit, "DegreeFahrenheit", "DegreesFahrenheit", new BaseUnits(temperature: TemperatureUnit.DegreeFahrenheit),
+                     new ConversionExpression(coefficient: new QuantityValue(9, 5), constantTerm: new QuantityValue(-45967, 100)),
+                     new ConversionExpression(coefficient: new QuantityValue(5, 9), constantTerm: new QuantityValue(45967, 180))
+                );
+                yield return new (TemperatureUnit.DegreeNewton, "DegreeNewton", "DegreesNewton", new BaseUnits(temperature: TemperatureUnit.DegreeNewton),
+                     new ConversionExpression(coefficient: new QuantityValue(33, 100), constantTerm: new QuantityValue(-180279, 2000)),
+                     new ConversionExpression(coefficient: new QuantityValue(100, 33), constantTerm: new QuantityValue(5463, 20))
+                );
+                yield return new (TemperatureUnit.DegreeRankine, "DegreeRankine", "DegreesRankine", new BaseUnits(temperature: TemperatureUnit.DegreeRankine),
+                     new QuantityValue(9, 5)
+                );
+                yield return new (TemperatureUnit.DegreeReaumur, "DegreeReaumur", "DegreesReaumur", new BaseUnits(temperature: TemperatureUnit.DegreeReaumur),
+                     new ConversionExpression(coefficient: new QuantityValue(4, 5), constantTerm: new QuantityValue(-5463, 25)),
+                     new ConversionExpression(coefficient: new QuantityValue(5, 4), constantTerm: new QuantityValue(5463, 20))
+                );
+                yield return new (TemperatureUnit.DegreeRoemer, "DegreeRoemer", "DegreesRoemer", new BaseUnits(temperature: TemperatureUnit.DegreeRoemer),
+                     new ConversionExpression(coefficient: new QuantityValue(21, 40), constantTerm: new QuantityValue(-108723, 800)),
+                     new ConversionExpression(coefficient: new QuantityValue(40, 21), constantTerm: new QuantityValue(36241, 140))
+                );
                 yield return new (TemperatureUnit.Kelvin, "Kelvin", "Kelvins", new BaseUnits(temperature: TemperatureUnit.Kelvin));
-                yield return new (TemperatureUnit.MillidegreeCelsius, "MillidegreeCelsius", "MillidegreesCelsius", new BaseUnits(temperature: TemperatureUnit.MillidegreeCelsius));
-                yield return new (TemperatureUnit.SolarTemperature, "SolarTemperature", "SolarTemperatures", new BaseUnits(temperature: TemperatureUnit.SolarTemperature));
+                yield return new (TemperatureUnit.MillidegreeCelsius, "MillidegreeCelsius", "MillidegreesCelsius", new BaseUnits(temperature: TemperatureUnit.MillidegreeCelsius),
+                     new ConversionExpression(coefficient: 1000, constantTerm: -273150),
+                     new ConversionExpression(coefficient: new QuantityValue(1, 1000), constantTerm: new QuantityValue(5463, 20))
+                );
+                yield return new (TemperatureUnit.SolarTemperature, "SolarTemperature", "SolarTemperatures", new BaseUnits(temperature: TemperatureUnit.SolarTemperature),
+                     new QuantityValue(1, 5778)
+                );
             }
         }
 
         static Temperature()
         {
-            Info = TemperatureInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(TemperatureInfo.CreateDefault);
         }
 
         /// <summary>
@@ -141,7 +163,7 @@ static Temperature()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Temperature(double value, TemperatureUnit unit)
+        public Temperature(QuantityValue value, TemperatureUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -155,7 +177,7 @@ public Temperature(double value, TemperatureUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Temperature(double value, UnitSystem unitSystem)
+        public Temperature(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -166,7 +188,8 @@ public Temperature(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Temperature" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Temperature, TemperatureUnit> Info { get; }
@@ -195,10 +218,8 @@ public Temperature(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public TemperatureUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -232,91 +253,59 @@ public Temperature(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeCelsius"/>
         /// </summary>
-        public double DegreesCelsius => As(TemperatureUnit.DegreeCelsius);
+        public QuantityValue DegreesCelsius => this.As(TemperatureUnit.DegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeDelisle"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeDelisle"/>
         /// </summary>
-        public double DegreesDelisle => As(TemperatureUnit.DegreeDelisle);
+        public QuantityValue DegreesDelisle => this.As(TemperatureUnit.DegreeDelisle);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeFahrenheit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeFahrenheit"/>
         /// </summary>
-        public double DegreesFahrenheit => As(TemperatureUnit.DegreeFahrenheit);
+        public QuantityValue DegreesFahrenheit => this.As(TemperatureUnit.DegreeFahrenheit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeNewton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeNewton"/>
         /// </summary>
-        public double DegreesNewton => As(TemperatureUnit.DegreeNewton);
+        public QuantityValue DegreesNewton => this.As(TemperatureUnit.DegreeNewton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeRankine"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeRankine"/>
         /// </summary>
-        public double DegreesRankine => As(TemperatureUnit.DegreeRankine);
+        public QuantityValue DegreesRankine => this.As(TemperatureUnit.DegreeRankine);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeReaumur"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeReaumur"/>
         /// </summary>
-        public double DegreesReaumur => As(TemperatureUnit.DegreeReaumur);
+        public QuantityValue DegreesReaumur => this.As(TemperatureUnit.DegreeReaumur);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeRoemer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureUnit.DegreeRoemer"/>
         /// </summary>
-        public double DegreesRoemer => As(TemperatureUnit.DegreeRoemer);
+        public QuantityValue DegreesRoemer => this.As(TemperatureUnit.DegreeRoemer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.Kelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureUnit.Kelvin"/>
         /// </summary>
-        public double Kelvins => As(TemperatureUnit.Kelvin);
+        public QuantityValue Kelvins => this.As(TemperatureUnit.Kelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.MillidegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureUnit.MillidegreeCelsius"/>
         /// </summary>
-        public double MillidegreesCelsius => As(TemperatureUnit.MillidegreeCelsius);
+        public QuantityValue MillidegreesCelsius => this.As(TemperatureUnit.MillidegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureUnit.SolarTemperature"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureUnit.SolarTemperature"/>
         /// </summary>
-        public double SolarTemperatures => As(TemperatureUnit.SolarTemperature);
+        public QuantityValue SolarTemperatures => this.As(TemperatureUnit.SolarTemperature);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: TemperatureUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeCelsius, TemperatureUnit.Kelvin, quantity => quantity.ToUnit(TemperatureUnit.Kelvin));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeDelisle, TemperatureUnit.Kelvin, quantity => quantity.ToUnit(TemperatureUnit.Kelvin));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeFahrenheit, TemperatureUnit.Kelvin, quantity => quantity.ToUnit(TemperatureUnit.Kelvin));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeNewton, TemperatureUnit.Kelvin, quantity => quantity.ToUnit(TemperatureUnit.Kelvin));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeRankine, TemperatureUnit.Kelvin, quantity => quantity.ToUnit(TemperatureUnit.Kelvin));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeReaumur, TemperatureUnit.Kelvin, quantity => quantity.ToUnit(TemperatureUnit.Kelvin));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.DegreeRoemer, TemperatureUnit.Kelvin, quantity => quantity.ToUnit(TemperatureUnit.Kelvin));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.MillidegreeCelsius, TemperatureUnit.Kelvin, quantity => quantity.ToUnit(TemperatureUnit.Kelvin));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.SolarTemperature, TemperatureUnit.Kelvin, quantity => quantity.ToUnit(TemperatureUnit.Kelvin));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.Kelvin, TemperatureUnit.Kelvin, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> TemperatureUnit
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.Kelvin, TemperatureUnit.DegreeCelsius, quantity => quantity.ToUnit(TemperatureUnit.DegreeCelsius));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.Kelvin, TemperatureUnit.DegreeDelisle, quantity => quantity.ToUnit(TemperatureUnit.DegreeDelisle));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.Kelvin, TemperatureUnit.DegreeFahrenheit, quantity => quantity.ToUnit(TemperatureUnit.DegreeFahrenheit));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.Kelvin, TemperatureUnit.DegreeNewton, quantity => quantity.ToUnit(TemperatureUnit.DegreeNewton));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.Kelvin, TemperatureUnit.DegreeRankine, quantity => quantity.ToUnit(TemperatureUnit.DegreeRankine));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.Kelvin, TemperatureUnit.DegreeReaumur, quantity => quantity.ToUnit(TemperatureUnit.DegreeReaumur));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.Kelvin, TemperatureUnit.DegreeRoemer, quantity => quantity.ToUnit(TemperatureUnit.DegreeRoemer));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.Kelvin, TemperatureUnit.MillidegreeCelsius, quantity => quantity.ToUnit(TemperatureUnit.MillidegreeCelsius));
-            unitConverter.SetConversionFunction<Temperature>(TemperatureUnit.Kelvin, TemperatureUnit.SolarTemperature, quantity => quantity.ToUnit(TemperatureUnit.SolarTemperature));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -345,7 +334,7 @@ public static string GetAbbreviation(TemperatureUnit unit, IFormatProvider? prov
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeCelsius"/>.
         /// </summary>
-        public static Temperature FromDegreesCelsius(double value)
+        public static Temperature FromDegreesCelsius(QuantityValue value)
         {
             return new Temperature(value, TemperatureUnit.DegreeCelsius);
         }
@@ -353,7 +342,7 @@ public static Temperature FromDegreesCelsius(double value)
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeDelisle"/>.
         /// </summary>
-        public static Temperature FromDegreesDelisle(double value)
+        public static Temperature FromDegreesDelisle(QuantityValue value)
         {
             return new Temperature(value, TemperatureUnit.DegreeDelisle);
         }
@@ -361,7 +350,7 @@ public static Temperature FromDegreesDelisle(double value)
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeFahrenheit"/>.
         /// </summary>
-        public static Temperature FromDegreesFahrenheit(double value)
+        public static Temperature FromDegreesFahrenheit(QuantityValue value)
         {
             return new Temperature(value, TemperatureUnit.DegreeFahrenheit);
         }
@@ -369,7 +358,7 @@ public static Temperature FromDegreesFahrenheit(double value)
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeNewton"/>.
         /// </summary>
-        public static Temperature FromDegreesNewton(double value)
+        public static Temperature FromDegreesNewton(QuantityValue value)
         {
             return new Temperature(value, TemperatureUnit.DegreeNewton);
         }
@@ -377,7 +366,7 @@ public static Temperature FromDegreesNewton(double value)
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeRankine"/>.
         /// </summary>
-        public static Temperature FromDegreesRankine(double value)
+        public static Temperature FromDegreesRankine(QuantityValue value)
         {
             return new Temperature(value, TemperatureUnit.DegreeRankine);
         }
@@ -385,7 +374,7 @@ public static Temperature FromDegreesRankine(double value)
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeReaumur"/>.
         /// </summary>
-        public static Temperature FromDegreesReaumur(double value)
+        public static Temperature FromDegreesReaumur(QuantityValue value)
         {
             return new Temperature(value, TemperatureUnit.DegreeReaumur);
         }
@@ -393,7 +382,7 @@ public static Temperature FromDegreesReaumur(double value)
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeRoemer"/>.
         /// </summary>
-        public static Temperature FromDegreesRoemer(double value)
+        public static Temperature FromDegreesRoemer(QuantityValue value)
         {
             return new Temperature(value, TemperatureUnit.DegreeRoemer);
         }
@@ -401,7 +390,7 @@ public static Temperature FromDegreesRoemer(double value)
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.Kelvin"/>.
         /// </summary>
-        public static Temperature FromKelvins(double value)
+        public static Temperature FromKelvins(QuantityValue value)
         {
             return new Temperature(value, TemperatureUnit.Kelvin);
         }
@@ -409,7 +398,7 @@ public static Temperature FromKelvins(double value)
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.MillidegreeCelsius"/>.
         /// </summary>
-        public static Temperature FromMillidegreesCelsius(double value)
+        public static Temperature FromMillidegreesCelsius(QuantityValue value)
         {
             return new Temperature(value, TemperatureUnit.MillidegreeCelsius);
         }
@@ -417,7 +406,7 @@ public static Temperature FromMillidegreesCelsius(double value)
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.SolarTemperature"/>.
         /// </summary>
-        public static Temperature FromSolarTemperatures(double value)
+        public static Temperature FromSolarTemperatures(QuantityValue value)
         {
             return new Temperature(value, TemperatureUnit.SolarTemperature);
         }
@@ -428,7 +417,7 @@ public static Temperature FromSolarTemperatures(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Temperature unit value.</returns>
-        public static Temperature From(double value, TemperatureUnit fromUnit)
+        public static Temperature From(QuantityValue value, TemperatureUnit fromUnit)
         {
             return new Temperature(value, fromUnit);
         }
@@ -489,10 +478,7 @@ public static Temperature Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Temperature Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Temperature, TemperatureUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Temperature, TemperatureUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -520,11 +506,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Temperature resu
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Temperature result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Temperature, TemperatureUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Temperature, TemperatureUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -545,7 +527,7 @@ public static TemperatureUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -556,7 +538,7 @@ public static TemperatureUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TemperatureUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.TemperatureUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -571,7 +553,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureU
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out TemperatureUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -584,97 +566,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Temperature left, Temperature right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Temperature left, Temperature right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Temperature left, Temperature right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Temperature left, Temperature right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Temperature"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Temperature other, Temperature tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Temperature"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Temperature)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Temperature left, Temperature right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Temperature"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Temperature other, Temperature tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Temperature"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Temperature,Temperature)"/>.
+        ///     See that operator (and <see cref="Equals(Temperature)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Temperature left, Temperature right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Temperature"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Temperature other, Temperature tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Temperature"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Temperature"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Temperature"/>, this method delegates to
+        ///     <see cref="Equals(Temperature)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Temperature otherQuantity))
+            if (obj is not Temperature otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Temperature"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Temperature other, Temperature tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Temperature"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Temperature other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Temperature.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Temperature), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Temperature"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Temperature)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Temperature otherQuantity)) throw new ArgumentException("Expected type Temperature.", nameof(obj));
+            if (obj is not Temperature otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Temperature>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Temperature"/> with another <see cref="Temperature"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Temperature"/> with another <see cref="Temperature"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -686,147 +682,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Temperature other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(TemperatureUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<TemperatureUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Temperature to another Temperature with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Temperature with the specified unit.</returns>
-        public Temperature ToUnit(TemperatureUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="Temperature"/> to another <see cref="Temperature"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Temperature with the specified unit.</returns>
-        public Temperature ToUnit(TemperatureUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Temperature), Unit, typeof(Temperature), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Temperature)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Temperature"/> to another <see cref="Temperature"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Temperature"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(TemperatureUnit unit, [NotNullWhen(true)] out Temperature? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Temperature? convertedOrNull = (Unit, unit) switch
-            {
-                // TemperatureUnit -> BaseUnit
-                (TemperatureUnit.DegreeCelsius, TemperatureUnit.Kelvin) => new Temperature(_value + 273.15, TemperatureUnit.Kelvin),
-                (TemperatureUnit.DegreeDelisle, TemperatureUnit.Kelvin) => new Temperature(_value * -2 / 3 + 373.15, TemperatureUnit.Kelvin),
-                (TemperatureUnit.DegreeFahrenheit, TemperatureUnit.Kelvin) => new Temperature(_value * 5 / 9 + 459.67 * 5 / 9, TemperatureUnit.Kelvin),
-                (TemperatureUnit.DegreeNewton, TemperatureUnit.Kelvin) => new Temperature(_value * 100 / 33 + 273.15, TemperatureUnit.Kelvin),
-                (TemperatureUnit.DegreeRankine, TemperatureUnit.Kelvin) => new Temperature(_value * 5 / 9, TemperatureUnit.Kelvin),
-                (TemperatureUnit.DegreeReaumur, TemperatureUnit.Kelvin) => new Temperature(_value * 5 / 4 + 273.15, TemperatureUnit.Kelvin),
-                (TemperatureUnit.DegreeRoemer, TemperatureUnit.Kelvin) => new Temperature(_value * 40 / 21 + 273.15 - 7.5 * 40d / 21, TemperatureUnit.Kelvin),
-                (TemperatureUnit.MillidegreeCelsius, TemperatureUnit.Kelvin) => new Temperature(_value / 1000 + 273.15, TemperatureUnit.Kelvin),
-                (TemperatureUnit.SolarTemperature, TemperatureUnit.Kelvin) => new Temperature(_value * 5778, TemperatureUnit.Kelvin),
-
-                // BaseUnit -> TemperatureUnit
-                (TemperatureUnit.Kelvin, TemperatureUnit.DegreeCelsius) => new Temperature(_value - 273.15, TemperatureUnit.DegreeCelsius),
-                (TemperatureUnit.Kelvin, TemperatureUnit.DegreeDelisle) => new Temperature((_value - 373.15) * -3 / 2, TemperatureUnit.DegreeDelisle),
-                (TemperatureUnit.Kelvin, TemperatureUnit.DegreeFahrenheit) => new Temperature((_value - 459.67 * 5 / 9) * 9 / 5, TemperatureUnit.DegreeFahrenheit),
-                (TemperatureUnit.Kelvin, TemperatureUnit.DegreeNewton) => new Temperature((_value - 273.15) * 33 / 100, TemperatureUnit.DegreeNewton),
-                (TemperatureUnit.Kelvin, TemperatureUnit.DegreeRankine) => new Temperature(_value * 9 / 5, TemperatureUnit.DegreeRankine),
-                (TemperatureUnit.Kelvin, TemperatureUnit.DegreeReaumur) => new Temperature((_value - 273.15) * 4 / 5, TemperatureUnit.DegreeReaumur),
-                (TemperatureUnit.Kelvin, TemperatureUnit.DegreeRoemer) => new Temperature((_value - (273.15 - 7.5 * 40d / 21)) * 21 / 40, TemperatureUnit.DegreeRoemer),
-                (TemperatureUnit.Kelvin, TemperatureUnit.MillidegreeCelsius) => new Temperature((_value - 273.15) * 1000, TemperatureUnit.MillidegreeCelsius),
-                (TemperatureUnit.Kelvin, TemperatureUnit.SolarTemperature) => new Temperature(_value / 5778, TemperatureUnit.SolarTemperature),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not TemperatureUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is TemperatureUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<TemperatureUnit> IQuantity<TemperatureUnit>.ToUnit(TemperatureUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -840,11 +698,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
index 1fac793995..654fea94fb 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Temperature change rate is the ratio of the temperature change to the time during which the change occurred (value of temperature changes per unit time).
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct TemperatureChangeRate :
-        IArithmeticQuantity<TemperatureChangeRate, TemperatureChangeRateUnit>,
+        ILinearQuantity<TemperatureChangeRate, TemperatureChangeRateUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<TemperatureChangeRate, TemperatureChangeRate, double>,
+        IDivisionOperators<TemperatureChangeRate, TemperatureChangeRate, QuantityValue>,
         IMultiplyOperators<TemperatureChangeRate, Duration, TemperatureDelta>,
         IComparisonOperators<TemperatureChangeRate, TemperatureChangeRate, bool>,
         IParsable<TemperatureChangeRate>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static TemperatureChangeRateInfo CreateDefault(Func<IEnumerable<UnitDefin
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="TemperatureChangeRate"/> is [T^-1][Θ].
+            ///     The <see cref="BaseDimensions" /> for <see cref="TemperatureChangeRate"/> is T^-1Θ.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, -1, 0, 1, 0, 0);
 
@@ -118,31 +117,61 @@ public static TemperatureChangeRateInfo CreateDefault(Func<IEnumerable<UnitDefin
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{TemperatureChangeRateUnit}"/> representing the default unit mappings for TemperatureChangeRate.</returns>
             public static IEnumerable<UnitDefinition<TemperatureChangeRateUnit>> GetDefaultMappings()
             {
-                yield return new (TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, "CentidegreeCelsiusPerSecond", "CentidegreesCelsiusPerSecond", BaseUnits.Undefined);
-                yield return new (TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, "DecadegreeCelsiusPerSecond", "DecadegreesCelsiusPerSecond", BaseUnits.Undefined);
-                yield return new (TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, "DecidegreeCelsiusPerSecond", "DecidegreesCelsiusPerSecond", BaseUnits.Undefined);
-                yield return new (TemperatureChangeRateUnit.DegreeCelsiusPerHour, "DegreeCelsiusPerHour", "DegreesCelsiusPerHour", new BaseUnits(time: DurationUnit.Hour, temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (TemperatureChangeRateUnit.DegreeCelsiusPerMinute, "DegreeCelsiusPerMinute", "DegreesCelsiusPerMinute", new BaseUnits(time: DurationUnit.Minute, temperature: TemperatureUnit.DegreeCelsius));
+                yield return new (TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, "CentidegreeCelsiusPerSecond", "CentidegreesCelsiusPerSecond", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, "DecadegreeCelsiusPerSecond", "DecadegreesCelsiusPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, "DecidegreeCelsiusPerSecond", "DecidegreesCelsiusPerSecond", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (TemperatureChangeRateUnit.DegreeCelsiusPerHour, "DegreeCelsiusPerHour", "DegreesCelsiusPerHour", new BaseUnits(time: DurationUnit.Hour, temperature: TemperatureUnit.DegreeCelsius),
+                     3600
+                );
+                yield return new (TemperatureChangeRateUnit.DegreeCelsiusPerMinute, "DegreeCelsiusPerMinute", "DegreesCelsiusPerMinute", new BaseUnits(time: DurationUnit.Minute, temperature: TemperatureUnit.DegreeCelsius),
+                     60
+                );
                 yield return new (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, "DegreeCelsiusPerSecond", "DegreesCelsiusPerSecond", new BaseUnits(time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (TemperatureChangeRateUnit.DegreeFahrenheitPerHour, "DegreeFahrenheitPerHour", "DegreesFahrenheitPerHour", new BaseUnits(time: DurationUnit.Hour, temperature: TemperatureUnit.DegreeFahrenheit));
-                yield return new (TemperatureChangeRateUnit.DegreeFahrenheitPerMinute, "DegreeFahrenheitPerMinute", "DegreesFahrenheitPerMinute", new BaseUnits(time: DurationUnit.Minute, temperature: TemperatureUnit.DegreeFahrenheit));
-                yield return new (TemperatureChangeRateUnit.DegreeFahrenheitPerSecond, "DegreeFahrenheitPerSecond", "DegreesFahrenheitPerSecond", new BaseUnits(time: DurationUnit.Second, temperature: TemperatureUnit.DegreeFahrenheit));
-                yield return new (TemperatureChangeRateUnit.DegreeKelvinPerHour, "DegreeKelvinPerHour", "DegreesKelvinPerHour", new BaseUnits(time: DurationUnit.Hour, temperature: TemperatureUnit.Kelvin));
-                yield return new (TemperatureChangeRateUnit.DegreeKelvinPerMinute, "DegreeKelvinPerMinute", "DegreesKelvinPerMinute", new BaseUnits(time: DurationUnit.Minute, temperature: TemperatureUnit.Kelvin));
-                yield return new (TemperatureChangeRateUnit.DegreeKelvinPerSecond, "DegreeKelvinPerSecond", "DegreesKelvinPerSecond", new BaseUnits(time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
-                yield return new (TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, "HectodegreeCelsiusPerSecond", "HectodegreesCelsiusPerSecond", BaseUnits.Undefined);
-                yield return new (TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, "KilodegreeCelsiusPerSecond", "KilodegreesCelsiusPerSecond", new BaseUnits(time: DurationUnit.Millisecond, temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, "MicrodegreeCelsiusPerSecond", "MicrodegreesCelsiusPerSecond", BaseUnits.Undefined);
-                yield return new (TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, "MillidegreeCelsiusPerSecond", "MillidegreesCelsiusPerSecond", BaseUnits.Undefined);
-                yield return new (TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, "NanodegreeCelsiusPerSecond", "NanodegreesCelsiusPerSecond", BaseUnits.Undefined);
+                yield return new (TemperatureChangeRateUnit.DegreeFahrenheitPerHour, "DegreeFahrenheitPerHour", "DegreesFahrenheitPerHour", new BaseUnits(time: DurationUnit.Hour, temperature: TemperatureUnit.DegreeFahrenheit),
+                     6480
+                );
+                yield return new (TemperatureChangeRateUnit.DegreeFahrenheitPerMinute, "DegreeFahrenheitPerMinute", "DegreesFahrenheitPerMinute", new BaseUnits(time: DurationUnit.Minute, temperature: TemperatureUnit.DegreeFahrenheit),
+                     108
+                );
+                yield return new (TemperatureChangeRateUnit.DegreeFahrenheitPerSecond, "DegreeFahrenheitPerSecond", "DegreesFahrenheitPerSecond", new BaseUnits(time: DurationUnit.Second, temperature: TemperatureUnit.DegreeFahrenheit),
+                     new QuantityValue(9, 5)
+                );
+                yield return new (TemperatureChangeRateUnit.DegreeKelvinPerHour, "DegreeKelvinPerHour", "DegreesKelvinPerHour", new BaseUnits(time: DurationUnit.Hour, temperature: TemperatureUnit.Kelvin),
+                     3600
+                );
+                yield return new (TemperatureChangeRateUnit.DegreeKelvinPerMinute, "DegreeKelvinPerMinute", "DegreesKelvinPerMinute", new BaseUnits(time: DurationUnit.Minute, temperature: TemperatureUnit.Kelvin),
+                     60
+                );
+                yield return new (TemperatureChangeRateUnit.DegreeKelvinPerSecond, "DegreeKelvinPerSecond", "DegreesKelvinPerSecond", new BaseUnits(time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin),
+                     1
+                );
+                yield return new (TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, "HectodegreeCelsiusPerSecond", "HectodegreesCelsiusPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 100)
+                );
+                yield return new (TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, "KilodegreeCelsiusPerSecond", "KilodegreesCelsiusPerSecond", new BaseUnits(time: DurationUnit.Millisecond, temperature: TemperatureUnit.DegreeCelsius),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, "MicrodegreeCelsiusPerSecond", "MicrodegreesCelsiusPerSecond", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, "MillidegreeCelsiusPerSecond", "MillidegreesCelsiusPerSecond", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, "NanodegreeCelsiusPerSecond", "NanodegreesCelsiusPerSecond", BaseUnits.Undefined,
+                     1000000000
+                );
             }
         }
 
         static TemperatureChangeRate()
         {
-            Info = TemperatureChangeRateInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(TemperatureChangeRateInfo.CreateDefault);
         }
 
         /// <summary>
@@ -150,7 +179,7 @@ static TemperatureChangeRate()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public TemperatureChangeRate(double value, TemperatureChangeRateUnit unit)
+        public TemperatureChangeRate(QuantityValue value, TemperatureChangeRateUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -164,7 +193,7 @@ public TemperatureChangeRate(double value, TemperatureChangeRateUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public TemperatureChangeRate(double value, UnitSystem unitSystem)
+        public TemperatureChangeRate(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -175,7 +204,8 @@ public TemperatureChangeRate(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="TemperatureChangeRate" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<TemperatureChangeRate, TemperatureChangeRateUnit> Info { get; }
@@ -204,10 +234,8 @@ public TemperatureChangeRate(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public TemperatureChangeRateUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -241,140 +269,94 @@ public TemperatureChangeRate(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond"/>
         /// </summary>
-        public double CentidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
+        public QuantityValue CentidegreesCelsiusPerSecond => this.As(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond"/>
         /// </summary>
-        public double DecadegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
+        public QuantityValue DecadegreesCelsiusPerSecond => this.As(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond"/>
         /// </summary>
-        public double DecidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
+        public QuantityValue DecidegreesCelsiusPerSecond => this.As(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerHour"/>
         /// </summary>
-        public double DegreesCelsiusPerHour => As(TemperatureChangeRateUnit.DegreeCelsiusPerHour);
+        public QuantityValue DegreesCelsiusPerHour => this.As(TemperatureChangeRateUnit.DegreeCelsiusPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerMinute"/>
         /// </summary>
-        public double DegreesCelsiusPerMinute => As(TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
+        public QuantityValue DegreesCelsiusPerMinute => this.As(TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerSecond"/>
         /// </summary>
-        public double DegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
+        public QuantityValue DegreesCelsiusPerSecond => this.As(TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerHour"/>
         /// </summary>
-        public double DegreesFahrenheitPerHour => As(TemperatureChangeRateUnit.DegreeFahrenheitPerHour);
+        public QuantityValue DegreesFahrenheitPerHour => this.As(TemperatureChangeRateUnit.DegreeFahrenheitPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerMinute"/>
         /// </summary>
-        public double DegreesFahrenheitPerMinute => As(TemperatureChangeRateUnit.DegreeFahrenheitPerMinute);
+        public QuantityValue DegreesFahrenheitPerMinute => this.As(TemperatureChangeRateUnit.DegreeFahrenheitPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerSecond"/>
         /// </summary>
-        public double DegreesFahrenheitPerSecond => As(TemperatureChangeRateUnit.DegreeFahrenheitPerSecond);
+        public QuantityValue DegreesFahrenheitPerSecond => this.As(TemperatureChangeRateUnit.DegreeFahrenheitPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeKelvinPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeKelvinPerHour"/>
         /// </summary>
-        public double DegreesKelvinPerHour => As(TemperatureChangeRateUnit.DegreeKelvinPerHour);
+        public QuantityValue DegreesKelvinPerHour => this.As(TemperatureChangeRateUnit.DegreeKelvinPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeKelvinPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeKelvinPerMinute"/>
         /// </summary>
-        public double DegreesKelvinPerMinute => As(TemperatureChangeRateUnit.DegreeKelvinPerMinute);
+        public QuantityValue DegreesKelvinPerMinute => this.As(TemperatureChangeRateUnit.DegreeKelvinPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeKelvinPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.DegreeKelvinPerSecond"/>
         /// </summary>
-        public double DegreesKelvinPerSecond => As(TemperatureChangeRateUnit.DegreeKelvinPerSecond);
+        public QuantityValue DegreesKelvinPerSecond => this.As(TemperatureChangeRateUnit.DegreeKelvinPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond"/>
         /// </summary>
-        public double HectodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
+        public QuantityValue HectodegreesCelsiusPerSecond => this.As(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond"/>
         /// </summary>
-        public double KilodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
+        public QuantityValue KilodegreesCelsiusPerSecond => this.As(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond"/>
         /// </summary>
-        public double MicrodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
+        public QuantityValue MicrodegreesCelsiusPerSecond => this.As(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond"/>
         /// </summary>
-        public double MillidegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
+        public QuantityValue MillidegreesCelsiusPerSecond => this.As(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond"/>
         /// </summary>
-        public double NanodegreesCelsiusPerSecond => As(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
+        public QuantityValue NanodegreesCelsiusPerSecond => this.As(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: TemperatureChangeRateUnit -> BaseUnit
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerHour, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerMinute, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeFahrenheitPerHour, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeFahrenheitPerMinute, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeFahrenheitPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeKelvinPerHour, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeKelvinPerMinute, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeKelvinPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> TemperatureChangeRateUnit
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerHour, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerHour));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerMinute, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeCelsiusPerMinute));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeFahrenheitPerHour, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeFahrenheitPerHour));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeFahrenheitPerMinute, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeFahrenheitPerMinute));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeFahrenheitPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeFahrenheitPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeKelvinPerHour, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeKelvinPerHour));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeKelvinPerMinute, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeKelvinPerMinute));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeKelvinPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.DegreeKelvinPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond));
-            unitConverter.SetConversionFunction<TemperatureChangeRate>(TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, quantity => quantity.ToUnit(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -403,7 +385,7 @@ public static string GetAbbreviation(TemperatureChangeRateUnit unit, IFormatProv
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(double value)
+        public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
         }
@@ -411,7 +393,7 @@ public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(double valu
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(double value)
+        public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
         }
@@ -419,7 +401,7 @@ public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(double value
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(double value)
+        public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
         }
@@ -427,7 +409,7 @@ public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(double value
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerHour"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDegreesCelsiusPerHour(double value)
+        public static TemperatureChangeRate FromDegreesCelsiusPerHour(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerHour);
         }
@@ -435,7 +417,7 @@ public static TemperatureChangeRate FromDegreesCelsiusPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerMinute"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDegreesCelsiusPerMinute(double value)
+        public static TemperatureChangeRate FromDegreesCelsiusPerMinute(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
         }
@@ -443,7 +425,7 @@ public static TemperatureChangeRate FromDegreesCelsiusPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDegreesCelsiusPerSecond(double value)
+        public static TemperatureChangeRate FromDegreesCelsiusPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
         }
@@ -451,7 +433,7 @@ public static TemperatureChangeRate FromDegreesCelsiusPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerHour"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDegreesFahrenheitPerHour(double value)
+        public static TemperatureChangeRate FromDegreesFahrenheitPerHour(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeFahrenheitPerHour);
         }
@@ -459,7 +441,7 @@ public static TemperatureChangeRate FromDegreesFahrenheitPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerMinute"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDegreesFahrenheitPerMinute(double value)
+        public static TemperatureChangeRate FromDegreesFahrenheitPerMinute(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeFahrenheitPerMinute);
         }
@@ -467,7 +449,7 @@ public static TemperatureChangeRate FromDegreesFahrenheitPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeFahrenheitPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDegreesFahrenheitPerSecond(double value)
+        public static TemperatureChangeRate FromDegreesFahrenheitPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeFahrenheitPerSecond);
         }
@@ -475,7 +457,7 @@ public static TemperatureChangeRate FromDegreesFahrenheitPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeKelvinPerHour"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDegreesKelvinPerHour(double value)
+        public static TemperatureChangeRate FromDegreesKelvinPerHour(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeKelvinPerHour);
         }
@@ -483,7 +465,7 @@ public static TemperatureChangeRate FromDegreesKelvinPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeKelvinPerMinute"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDegreesKelvinPerMinute(double value)
+        public static TemperatureChangeRate FromDegreesKelvinPerMinute(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeKelvinPerMinute);
         }
@@ -491,7 +473,7 @@ public static TemperatureChangeRate FromDegreesKelvinPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeKelvinPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromDegreesKelvinPerSecond(double value)
+        public static TemperatureChangeRate FromDegreesKelvinPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeKelvinPerSecond);
         }
@@ -499,7 +481,7 @@ public static TemperatureChangeRate FromDegreesKelvinPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(double value)
+        public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
         }
@@ -507,7 +489,7 @@ public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(double valu
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(double value)
+        public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
         }
@@ -515,7 +497,7 @@ public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(double value
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(double value)
+        public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
         }
@@ -523,7 +505,7 @@ public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(double valu
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(double value)
+        public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
         }
@@ -531,7 +513,7 @@ public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(double valu
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond"/>.
         /// </summary>
-        public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double value)
+        public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(QuantityValue value)
         {
             return new TemperatureChangeRate(value, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
         }
@@ -542,7 +524,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double value
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>TemperatureChangeRate unit value.</returns>
-        public static TemperatureChangeRate From(double value, TemperatureChangeRateUnit fromUnit)
+        public static TemperatureChangeRate From(QuantityValue value, TemperatureChangeRateUnit fromUnit)
         {
             return new TemperatureChangeRate(value, fromUnit);
         }
@@ -603,10 +585,7 @@ public static TemperatureChangeRate Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static TemperatureChangeRate Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<TemperatureChangeRate, TemperatureChangeRateUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<TemperatureChangeRate, TemperatureChangeRateUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -634,11 +613,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out TemperatureChang
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out TemperatureChangeRate result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<TemperatureChangeRate, TemperatureChangeRateUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<TemperatureChangeRate, TemperatureChangeRateUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -659,7 +634,7 @@ public static TemperatureChangeRateUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -670,7 +645,7 @@ public static TemperatureChangeRateUnit ParseUnit(string str, IFormatProvider? p
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TemperatureChangeRateUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.TemperatureChangeRateUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureChangeRateUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -685,7 +660,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureC
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out TemperatureChangeRateUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -704,35 +679,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="TemperatureChangeRate"/> from adding two <see cref="TemperatureChangeRate"/>.</summary>
         public static TemperatureChangeRate operator +(TemperatureChangeRate left, TemperatureChangeRate right)
         {
-            return new TemperatureChangeRate(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new TemperatureChangeRate(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureChangeRate"/> from subtracting two <see cref="TemperatureChangeRate"/>.</summary>
         public static TemperatureChangeRate operator -(TemperatureChangeRate left, TemperatureChangeRate right)
         {
-            return new TemperatureChangeRate(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new TemperatureChangeRate(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureChangeRate"/> from multiplying value and <see cref="TemperatureChangeRate"/>.</summary>
-        public static TemperatureChangeRate operator *(double left, TemperatureChangeRate right)
+        public static TemperatureChangeRate operator *(QuantityValue left, TemperatureChangeRate right)
         {
             return new TemperatureChangeRate(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureChangeRate"/> from multiplying value and <see cref="TemperatureChangeRate"/>.</summary>
-        public static TemperatureChangeRate operator *(TemperatureChangeRate left, double right)
+        public static TemperatureChangeRate operator *(TemperatureChangeRate left, QuantityValue right)
         {
             return new TemperatureChangeRate(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureChangeRate"/> from dividing <see cref="TemperatureChangeRate"/> by value.</summary>
-        public static TemperatureChangeRate operator /(TemperatureChangeRate left, double right)
+        public static TemperatureChangeRate operator /(TemperatureChangeRate left, QuantityValue right)
         {
             return new TemperatureChangeRate(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="TemperatureChangeRate"/> by <see cref="TemperatureChangeRate"/>.</summary>
-        public static double operator /(TemperatureChangeRate left, TemperatureChangeRate right)
+        public static QuantityValue operator /(TemperatureChangeRate left, TemperatureChangeRate right)
         {
             return left.DegreesCelsiusPerSecond / right.DegreesCelsiusPerSecond;
         }
@@ -754,97 +729,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(TemperatureChangeRate left, TemperatureChangeRate right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(TemperatureChangeRate left, TemperatureChangeRate right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(TemperatureChangeRate left, TemperatureChangeRate right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(TemperatureChangeRate left, TemperatureChangeRate right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="TemperatureChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(TemperatureChangeRate other, TemperatureChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="TemperatureChangeRate"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(TemperatureChangeRate)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(TemperatureChangeRate left, TemperatureChangeRate right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="TemperatureChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(TemperatureChangeRate other, TemperatureChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="TemperatureChangeRate"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(TemperatureChangeRate,TemperatureChangeRate)"/>.
+        ///     See that operator (and <see cref="Equals(TemperatureChangeRate)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(TemperatureChangeRate left, TemperatureChangeRate right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="TemperatureChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(TemperatureChangeRate other, TemperatureChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="TemperatureChangeRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="TemperatureChangeRate"/>.
+        ///     When <paramref name="obj"/> is a <see cref="TemperatureChangeRate"/>, this method delegates to
+        ///     <see cref="Equals(TemperatureChangeRate)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is TemperatureChangeRate otherQuantity))
+            if (obj is not TemperatureChangeRate otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="TemperatureChangeRate"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(TemperatureChangeRate other, TemperatureChangeRate tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="TemperatureChangeRate"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(TemperatureChangeRate other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current TemperatureChangeRate.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(TemperatureChangeRate), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="TemperatureChangeRate"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(TemperatureChangeRate)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is TemperatureChangeRate otherQuantity)) throw new ArgumentException("Expected type TemperatureChangeRate.", nameof(obj));
+            if (obj is not TemperatureChangeRate otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<TemperatureChangeRate>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="TemperatureChangeRate"/> with another <see cref="TemperatureChangeRate"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="TemperatureChangeRate"/> with another <see cref="TemperatureChangeRate"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -856,161 +845,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(TemperatureChangeRate other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(TemperatureChangeRateUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<TemperatureChangeRateUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this TemperatureChangeRate to another TemperatureChangeRate with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A TemperatureChangeRate with the specified unit.</returns>
-        public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="TemperatureChangeRate"/> to another <see cref="TemperatureChangeRate"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A TemperatureChangeRate with the specified unit.</returns>
-        public TemperatureChangeRate ToUnit(TemperatureChangeRateUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(TemperatureChangeRate), Unit, typeof(TemperatureChangeRate), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (TemperatureChangeRate)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="TemperatureChangeRate"/> to another <see cref="TemperatureChangeRate"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="TemperatureChangeRate"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(TemperatureChangeRateUnit unit, [NotNullWhen(true)] out TemperatureChangeRate? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            TemperatureChangeRate? convertedOrNull = (Unit, unit) switch
-            {
-                // TemperatureChangeRateUnit -> BaseUnit
-                (TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) * 1e-2d, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) * 1e1d, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) * 1e-1d, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerHour, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate(_value / 3600, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerMinute, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate(_value / 60, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeFahrenheitPerHour, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate(_value * 5 / 9 / 3600, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeFahrenheitPerMinute, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate(_value * 5 / 9 / 60, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeFahrenheitPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate(_value * 5 / 9, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeKelvinPerHour, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate(_value / 3600, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeKelvinPerMinute, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate(_value / 60, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeKelvinPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate(_value, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) * 1e2d, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) * 1e3d, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) * 1e-6d, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) * 1e-3d, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) * 1e-9d, TemperatureChangeRateUnit.DegreeCelsiusPerSecond),
-
-                // BaseUnit -> TemperatureChangeRateUnit
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) / 1e-2d, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) / 1e1d, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) / 1e-1d, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerHour) => new TemperatureChangeRate(_value * 3600, TemperatureChangeRateUnit.DegreeCelsiusPerHour),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeCelsiusPerMinute) => new TemperatureChangeRate(_value * 60, TemperatureChangeRateUnit.DegreeCelsiusPerMinute),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeFahrenheitPerHour) => new TemperatureChangeRate(_value * 9 / 5 * 3600, TemperatureChangeRateUnit.DegreeFahrenheitPerHour),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeFahrenheitPerMinute) => new TemperatureChangeRate(_value * 9 / 5 * 60, TemperatureChangeRateUnit.DegreeFahrenheitPerMinute),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeFahrenheitPerSecond) => new TemperatureChangeRate(_value * 9 / 5, TemperatureChangeRateUnit.DegreeFahrenheitPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeKelvinPerHour) => new TemperatureChangeRate(_value * 3600, TemperatureChangeRateUnit.DegreeKelvinPerHour),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeKelvinPerMinute) => new TemperatureChangeRate(_value * 60, TemperatureChangeRateUnit.DegreeKelvinPerMinute),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.DegreeKelvinPerSecond) => new TemperatureChangeRate(_value, TemperatureChangeRateUnit.DegreeKelvinPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) / 1e2d, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) / 1e3d, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) / 1e-6d, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) / 1e-3d, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond),
-                (TemperatureChangeRateUnit.DegreeCelsiusPerSecond, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond) => new TemperatureChangeRate((_value) / 1e-9d, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not TemperatureChangeRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureChangeRateUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is TemperatureChangeRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureChangeRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<TemperatureChangeRateUnit> IQuantity<TemperatureChangeRateUnit>.ToUnit(TemperatureChangeRateUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1024,11 +861,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
index 6951bd5d09..96ae1fe2c3 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,18 +33,25 @@ namespace UnitsNet
     ///     Difference between two temperatures. The conversions are different than for Temperature.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct TemperatureDelta :
-        IArithmeticQuantity<TemperatureDelta, TemperatureDeltaUnit>,
+        ILinearQuantity<TemperatureDelta, TemperatureDeltaUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<TemperatureDelta, TemperatureDelta, double>,
+        IDivisionOperators<TemperatureDelta, TemperatureDelta, QuantityValue>,
         IDivisionOperators<TemperatureDelta, TemperatureChangeRate, Duration>,
         IMultiplyOperators<TemperatureDelta, Entropy, Energy>,
+        IMultiplyOperators<TemperatureDelta, VolumetricHeatCapacity, EnergyDensity>,
+        IMultiplyOperators<TemperatureDelta, HeatTransferCoefficient, HeatFlux>,
+        IDivisionOperators<TemperatureDelta, ThermalInsulance, HeatFlux>,
         IDivisionOperators<TemperatureDelta, TemperatureGradient, Length>,
+        IDivisionOperators<TemperatureDelta, ThermalResistance, Power>,
         IMultiplyOperators<TemperatureDelta, CoefficientOfThermalExpansion, Ratio>,
         IMultiplyOperators<TemperatureDelta, SpecificEntropy, SpecificEnergy>,
         IDivisionOperators<TemperatureDelta, Duration, TemperatureChangeRate>,
         IDivisionOperators<TemperatureDelta, Length, TemperatureGradient>,
+        IDivisionOperators<TemperatureDelta, HeatFlux, ThermalInsulance>,
+        IDivisionOperators<TemperatureDelta, Power, ThermalResistance>,
         IComparisonOperators<TemperatureDelta, TemperatureDelta, bool>,
         IParsable<TemperatureDelta>,
 #endif
@@ -59,7 +64,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -109,7 +114,7 @@ public static TemperatureDeltaInfo CreateDefault(Func<IEnumerable<UnitDefinition
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="TemperatureDelta"/> is [Θ].
+            ///     The <see cref="BaseDimensions" /> for <see cref="TemperatureDelta"/> is Θ.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, 0, 0, 0, 1, 0, 0);
 
@@ -124,23 +129,37 @@ public static TemperatureDeltaInfo CreateDefault(Func<IEnumerable<UnitDefinition
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{TemperatureDeltaUnit}"/> representing the default unit mappings for TemperatureDelta.</returns>
             public static IEnumerable<UnitDefinition<TemperatureDeltaUnit>> GetDefaultMappings()
             {
-                yield return new (TemperatureDeltaUnit.DegreeCelsius, "DegreeCelsius", "DegreesCelsius", new BaseUnits(temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (TemperatureDeltaUnit.DegreeDelisle, "DegreeDelisle", "DegreesDelisle", new BaseUnits(temperature: TemperatureUnit.DegreeDelisle));
-                yield return new (TemperatureDeltaUnit.DegreeFahrenheit, "DegreeFahrenheit", "DegreesFahrenheit", new BaseUnits(temperature: TemperatureUnit.DegreeFahrenheit));
-                yield return new (TemperatureDeltaUnit.DegreeNewton, "DegreeNewton", "DegreesNewton", new BaseUnits(temperature: TemperatureUnit.DegreeNewton));
-                yield return new (TemperatureDeltaUnit.DegreeRankine, "DegreeRankine", "DegreesRankine", new BaseUnits(temperature: TemperatureUnit.DegreeRankine));
-                yield return new (TemperatureDeltaUnit.DegreeReaumur, "DegreeReaumur", "DegreesReaumur", new BaseUnits(temperature: TemperatureUnit.DegreeReaumur));
-                yield return new (TemperatureDeltaUnit.DegreeRoemer, "DegreeRoemer", "DegreesRoemer", new BaseUnits(temperature: TemperatureUnit.DegreeRoemer));
+                yield return new (TemperatureDeltaUnit.DegreeCelsius, "DegreeCelsius", "DegreesCelsius", new BaseUnits(temperature: TemperatureUnit.DegreeCelsius),
+                     1
+                );
+                yield return new (TemperatureDeltaUnit.DegreeDelisle, "DegreeDelisle", "DegreesDelisle", new BaseUnits(temperature: TemperatureUnit.DegreeDelisle),
+                     new QuantityValue(-3, 2)
+                );
+                yield return new (TemperatureDeltaUnit.DegreeFahrenheit, "DegreeFahrenheit", "DegreesFahrenheit", new BaseUnits(temperature: TemperatureUnit.DegreeFahrenheit),
+                     new QuantityValue(9, 5)
+                );
+                yield return new (TemperatureDeltaUnit.DegreeNewton, "DegreeNewton", "DegreesNewton", new BaseUnits(temperature: TemperatureUnit.DegreeNewton),
+                     new QuantityValue(33, 100)
+                );
+                yield return new (TemperatureDeltaUnit.DegreeRankine, "DegreeRankine", "DegreesRankine", new BaseUnits(temperature: TemperatureUnit.DegreeRankine),
+                     new QuantityValue(9, 5)
+                );
+                yield return new (TemperatureDeltaUnit.DegreeReaumur, "DegreeReaumur", "DegreesReaumur", new BaseUnits(temperature: TemperatureUnit.DegreeReaumur),
+                     new QuantityValue(4, 5)
+                );
+                yield return new (TemperatureDeltaUnit.DegreeRoemer, "DegreeRoemer", "DegreesRoemer", new BaseUnits(temperature: TemperatureUnit.DegreeRoemer),
+                     new QuantityValue(21, 40)
+                );
                 yield return new (TemperatureDeltaUnit.Kelvin, "Kelvin", "Kelvins", new BaseUnits(temperature: TemperatureUnit.Kelvin));
-                yield return new (TemperatureDeltaUnit.MillidegreeCelsius, "MillidegreeCelsius", "MillidegreesCelsius", BaseUnits.Undefined);
+                yield return new (TemperatureDeltaUnit.MillidegreeCelsius, "MillidegreeCelsius", "MillidegreesCelsius", BaseUnits.Undefined,
+                     1000
+                );
             }
         }
 
         static TemperatureDelta()
         {
-            Info = TemperatureDeltaInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(TemperatureDeltaInfo.CreateDefault);
         }
 
         /// <summary>
@@ -148,7 +167,7 @@ static TemperatureDelta()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public TemperatureDelta(double value, TemperatureDeltaUnit unit)
+        public TemperatureDelta(QuantityValue value, TemperatureDeltaUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -162,7 +181,7 @@ public TemperatureDelta(double value, TemperatureDeltaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public TemperatureDelta(double value, UnitSystem unitSystem)
+        public TemperatureDelta(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -173,7 +192,8 @@ public TemperatureDelta(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="TemperatureDelta" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<TemperatureDelta, TemperatureDeltaUnit> Info { get; }
@@ -202,10 +222,8 @@ public TemperatureDelta(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public TemperatureDeltaUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -239,84 +257,54 @@ public TemperatureDelta(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeCelsius"/>
         /// </summary>
-        public double DegreesCelsius => As(TemperatureDeltaUnit.DegreeCelsius);
+        public QuantityValue DegreesCelsius => this.As(TemperatureDeltaUnit.DegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeDelisle"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeDelisle"/>
         /// </summary>
-        public double DegreesDelisle => As(TemperatureDeltaUnit.DegreeDelisle);
+        public QuantityValue DegreesDelisle => this.As(TemperatureDeltaUnit.DegreeDelisle);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeFahrenheit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeFahrenheit"/>
         /// </summary>
-        public double DegreesFahrenheit => As(TemperatureDeltaUnit.DegreeFahrenheit);
+        public QuantityValue DegreesFahrenheit => this.As(TemperatureDeltaUnit.DegreeFahrenheit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeNewton"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeNewton"/>
         /// </summary>
-        public double DegreesNewton => As(TemperatureDeltaUnit.DegreeNewton);
+        public QuantityValue DegreesNewton => this.As(TemperatureDeltaUnit.DegreeNewton);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeRankine"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeRankine"/>
         /// </summary>
-        public double DegreesRankine => As(TemperatureDeltaUnit.DegreeRankine);
+        public QuantityValue DegreesRankine => this.As(TemperatureDeltaUnit.DegreeRankine);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeReaumur"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeReaumur"/>
         /// </summary>
-        public double DegreesReaumur => As(TemperatureDeltaUnit.DegreeReaumur);
+        public QuantityValue DegreesReaumur => this.As(TemperatureDeltaUnit.DegreeReaumur);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeRoemer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.DegreeRoemer"/>
         /// </summary>
-        public double DegreesRoemer => As(TemperatureDeltaUnit.DegreeRoemer);
+        public QuantityValue DegreesRoemer => this.As(TemperatureDeltaUnit.DegreeRoemer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.Kelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.Kelvin"/>
         /// </summary>
-        public double Kelvins => As(TemperatureDeltaUnit.Kelvin);
+        public QuantityValue Kelvins => this.As(TemperatureDeltaUnit.Kelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.MillidegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureDeltaUnit.MillidegreeCelsius"/>
         /// </summary>
-        public double MillidegreesCelsius => As(TemperatureDeltaUnit.MillidegreeCelsius);
+        public QuantityValue MillidegreesCelsius => this.As(TemperatureDeltaUnit.MillidegreeCelsius);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: TemperatureDeltaUnit -> BaseUnit
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeCelsius, TemperatureDeltaUnit.Kelvin, quantity => quantity.ToUnit(TemperatureDeltaUnit.Kelvin));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeDelisle, TemperatureDeltaUnit.Kelvin, quantity => quantity.ToUnit(TemperatureDeltaUnit.Kelvin));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeFahrenheit, TemperatureDeltaUnit.Kelvin, quantity => quantity.ToUnit(TemperatureDeltaUnit.Kelvin));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeNewton, TemperatureDeltaUnit.Kelvin, quantity => quantity.ToUnit(TemperatureDeltaUnit.Kelvin));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeRankine, TemperatureDeltaUnit.Kelvin, quantity => quantity.ToUnit(TemperatureDeltaUnit.Kelvin));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeReaumur, TemperatureDeltaUnit.Kelvin, quantity => quantity.ToUnit(TemperatureDeltaUnit.Kelvin));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.DegreeRoemer, TemperatureDeltaUnit.Kelvin, quantity => quantity.ToUnit(TemperatureDeltaUnit.Kelvin));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.MillidegreeCelsius, TemperatureDeltaUnit.Kelvin, quantity => quantity.ToUnit(TemperatureDeltaUnit.Kelvin));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.Kelvin, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> TemperatureDeltaUnit
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeCelsius, quantity => quantity.ToUnit(TemperatureDeltaUnit.DegreeCelsius));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeDelisle, quantity => quantity.ToUnit(TemperatureDeltaUnit.DegreeDelisle));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeFahrenheit, quantity => quantity.ToUnit(TemperatureDeltaUnit.DegreeFahrenheit));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeNewton, quantity => quantity.ToUnit(TemperatureDeltaUnit.DegreeNewton));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeRankine, quantity => quantity.ToUnit(TemperatureDeltaUnit.DegreeRankine));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeReaumur, quantity => quantity.ToUnit(TemperatureDeltaUnit.DegreeReaumur));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeRoemer, quantity => quantity.ToUnit(TemperatureDeltaUnit.DegreeRoemer));
-            unitConverter.SetConversionFunction<TemperatureDelta>(TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.MillidegreeCelsius, quantity => quantity.ToUnit(TemperatureDeltaUnit.MillidegreeCelsius));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -345,7 +333,7 @@ public static string GetAbbreviation(TemperatureDeltaUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeCelsius"/>.
         /// </summary>
-        public static TemperatureDelta FromDegreesCelsius(double value)
+        public static TemperatureDelta FromDegreesCelsius(QuantityValue value)
         {
             return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeCelsius);
         }
@@ -353,7 +341,7 @@ public static TemperatureDelta FromDegreesCelsius(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeDelisle"/>.
         /// </summary>
-        public static TemperatureDelta FromDegreesDelisle(double value)
+        public static TemperatureDelta FromDegreesDelisle(QuantityValue value)
         {
             return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeDelisle);
         }
@@ -361,7 +349,7 @@ public static TemperatureDelta FromDegreesDelisle(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeFahrenheit"/>.
         /// </summary>
-        public static TemperatureDelta FromDegreesFahrenheit(double value)
+        public static TemperatureDelta FromDegreesFahrenheit(QuantityValue value)
         {
             return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeFahrenheit);
         }
@@ -369,7 +357,7 @@ public static TemperatureDelta FromDegreesFahrenheit(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeNewton"/>.
         /// </summary>
-        public static TemperatureDelta FromDegreesNewton(double value)
+        public static TemperatureDelta FromDegreesNewton(QuantityValue value)
         {
             return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeNewton);
         }
@@ -377,7 +365,7 @@ public static TemperatureDelta FromDegreesNewton(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeRankine"/>.
         /// </summary>
-        public static TemperatureDelta FromDegreesRankine(double value)
+        public static TemperatureDelta FromDegreesRankine(QuantityValue value)
         {
             return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRankine);
         }
@@ -385,7 +373,7 @@ public static TemperatureDelta FromDegreesRankine(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeReaumur"/>.
         /// </summary>
-        public static TemperatureDelta FromDegreesReaumur(double value)
+        public static TemperatureDelta FromDegreesReaumur(QuantityValue value)
         {
             return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeReaumur);
         }
@@ -393,7 +381,7 @@ public static TemperatureDelta FromDegreesReaumur(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeRoemer"/>.
         /// </summary>
-        public static TemperatureDelta FromDegreesRoemer(double value)
+        public static TemperatureDelta FromDegreesRoemer(QuantityValue value)
         {
             return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRoemer);
         }
@@ -401,7 +389,7 @@ public static TemperatureDelta FromDegreesRoemer(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.Kelvin"/>.
         /// </summary>
-        public static TemperatureDelta FromKelvins(double value)
+        public static TemperatureDelta FromKelvins(QuantityValue value)
         {
             return new TemperatureDelta(value, TemperatureDeltaUnit.Kelvin);
         }
@@ -409,7 +397,7 @@ public static TemperatureDelta FromKelvins(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.MillidegreeCelsius"/>.
         /// </summary>
-        public static TemperatureDelta FromMillidegreesCelsius(double value)
+        public static TemperatureDelta FromMillidegreesCelsius(QuantityValue value)
         {
             return new TemperatureDelta(value, TemperatureDeltaUnit.MillidegreeCelsius);
         }
@@ -420,7 +408,7 @@ public static TemperatureDelta FromMillidegreesCelsius(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>TemperatureDelta unit value.</returns>
-        public static TemperatureDelta From(double value, TemperatureDeltaUnit fromUnit)
+        public static TemperatureDelta From(QuantityValue value, TemperatureDeltaUnit fromUnit)
         {
             return new TemperatureDelta(value, fromUnit);
         }
@@ -481,10 +469,7 @@ public static TemperatureDelta Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static TemperatureDelta Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<TemperatureDelta, TemperatureDeltaUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<TemperatureDelta, TemperatureDeltaUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -512,11 +497,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out TemperatureDelta
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out TemperatureDelta result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<TemperatureDelta, TemperatureDeltaUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<TemperatureDelta, TemperatureDeltaUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -537,7 +518,7 @@ public static TemperatureDeltaUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -548,7 +529,7 @@ public static TemperatureDeltaUnit ParseUnit(string str, IFormatProvider? provid
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TemperatureDeltaUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.TemperatureDeltaUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureDeltaUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -563,7 +544,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureD
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out TemperatureDeltaUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -582,35 +563,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="TemperatureDelta"/> from adding two <see cref="TemperatureDelta"/>.</summary>
         public static TemperatureDelta operator +(TemperatureDelta left, TemperatureDelta right)
         {
-            return new TemperatureDelta(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new TemperatureDelta(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureDelta"/> from subtracting two <see cref="TemperatureDelta"/>.</summary>
         public static TemperatureDelta operator -(TemperatureDelta left, TemperatureDelta right)
         {
-            return new TemperatureDelta(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new TemperatureDelta(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureDelta"/> from multiplying value and <see cref="TemperatureDelta"/>.</summary>
-        public static TemperatureDelta operator *(double left, TemperatureDelta right)
+        public static TemperatureDelta operator *(QuantityValue left, TemperatureDelta right)
         {
             return new TemperatureDelta(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureDelta"/> from multiplying value and <see cref="TemperatureDelta"/>.</summary>
-        public static TemperatureDelta operator *(TemperatureDelta left, double right)
+        public static TemperatureDelta operator *(TemperatureDelta left, QuantityValue right)
         {
             return new TemperatureDelta(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureDelta"/> from dividing <see cref="TemperatureDelta"/> by value.</summary>
-        public static TemperatureDelta operator /(TemperatureDelta left, double right)
+        public static TemperatureDelta operator /(TemperatureDelta left, QuantityValue right)
         {
             return new TemperatureDelta(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="TemperatureDelta"/> by <see cref="TemperatureDelta"/>.</summary>
-        public static double operator /(TemperatureDelta left, TemperatureDelta right)
+        public static QuantityValue operator /(TemperatureDelta left, TemperatureDelta right)
         {
             return left.Kelvins / right.Kelvins;
         }
@@ -631,12 +612,36 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Energy.FromJoules(temperatureDelta.Kelvins * entropy.JoulesPerKelvin);
         }
 
+        /// <summary>Get <see cref="EnergyDensity"/> from <see cref="TemperatureDelta"/> * <see cref="VolumetricHeatCapacity"/>.</summary>
+        public static EnergyDensity operator *(TemperatureDelta temperatureDelta, VolumetricHeatCapacity volumetricHeatCapacity)
+        {
+            return EnergyDensity.FromJoulesPerCubicMeter(temperatureDelta.Kelvins * volumetricHeatCapacity.JoulesPerCubicMeterKelvin);
+        }
+
+        /// <summary>Get <see cref="HeatFlux"/> from <see cref="TemperatureDelta"/> * <see cref="HeatTransferCoefficient"/>.</summary>
+        public static HeatFlux operator *(TemperatureDelta temperatureDelta, HeatTransferCoefficient heatTransferCoefficient)
+        {
+            return HeatFlux.FromWattsPerSquareMeter(temperatureDelta.Kelvins * heatTransferCoefficient.WattsPerSquareMeterKelvin);
+        }
+
+        /// <summary>Get <see cref="HeatFlux"/> from <see cref="TemperatureDelta"/> / <see cref="ThermalInsulance"/>.</summary>
+        public static HeatFlux operator /(TemperatureDelta temperatureDelta, ThermalInsulance thermalInsulance)
+        {
+            return HeatFlux.FromWattsPerSquareMeter(temperatureDelta.Kelvins / thermalInsulance.SquareMeterKelvinsPerWatt);
+        }
+
         /// <summary>Get <see cref="Length"/> from <see cref="TemperatureDelta"/> / <see cref="TemperatureGradient"/>.</summary>
         public static Length operator /(TemperatureDelta temperatureDelta, TemperatureGradient temperatureGradient)
         {
             return Length.FromKilometers(temperatureDelta.DegreesCelsius / temperatureGradient.DegreesCelsiusPerKilometer);
         }
 
+        /// <summary>Get <see cref="Power"/> from <see cref="TemperatureDelta"/> / <see cref="ThermalResistance"/>.</summary>
+        public static Power operator /(TemperatureDelta temperatureDelta, ThermalResistance thermalResistance)
+        {
+            return Power.FromWatts(temperatureDelta.Kelvins / thermalResistance.KelvinsPerWatt);
+        }
+
         /// <summary>Get <see cref="Ratio"/> from <see cref="TemperatureDelta"/> * <see cref="CoefficientOfThermalExpansion"/>.</summary>
         public static Ratio operator *(TemperatureDelta temperatureDelta, CoefficientOfThermalExpansion coefficientOfThermalExpansion)
         {
@@ -661,6 +666,18 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return TemperatureGradient.FromDegreesCelsiusPerKilometer(temperatureDelta.DegreesCelsius / length.Kilometers);
         }
 
+        /// <summary>Get <see cref="ThermalInsulance"/> from <see cref="TemperatureDelta"/> / <see cref="HeatFlux"/>.</summary>
+        public static ThermalInsulance operator /(TemperatureDelta temperatureDelta, HeatFlux heatFlux)
+        {
+            return ThermalInsulance.FromSquareMeterKelvinsPerWatt(temperatureDelta.Kelvins / heatFlux.WattsPerSquareMeter);
+        }
+
+        /// <summary>Get <see cref="ThermalResistance"/> from <see cref="TemperatureDelta"/> / <see cref="Power"/>.</summary>
+        public static ThermalResistance operator /(TemperatureDelta temperatureDelta, Power power)
+        {
+            return ThermalResistance.FromKelvinsPerWatt(temperatureDelta.Kelvins / power.Watts);
+        }
+
         #endregion
 
         #region Equality / IComparable
@@ -668,97 +685,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(TemperatureDelta left, TemperatureDelta right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(TemperatureDelta left, TemperatureDelta right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(TemperatureDelta left, TemperatureDelta right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(TemperatureDelta left, TemperatureDelta right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="TemperatureDelta"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(TemperatureDelta other, TemperatureDelta tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="TemperatureDelta"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(TemperatureDelta)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(TemperatureDelta left, TemperatureDelta right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="TemperatureDelta"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(TemperatureDelta other, TemperatureDelta tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="TemperatureDelta"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(TemperatureDelta,TemperatureDelta)"/>.
+        ///     See that operator (and <see cref="Equals(TemperatureDelta)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(TemperatureDelta left, TemperatureDelta right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="TemperatureDelta"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(TemperatureDelta other, TemperatureDelta tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="TemperatureDelta"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="TemperatureDelta"/>.
+        ///     When <paramref name="obj"/> is a <see cref="TemperatureDelta"/>, this method delegates to
+        ///     <see cref="Equals(TemperatureDelta)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is TemperatureDelta otherQuantity))
+            if (obj is not TemperatureDelta otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="TemperatureDelta"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(TemperatureDelta other, TemperatureDelta tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="TemperatureDelta"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(TemperatureDelta other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current TemperatureDelta.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(TemperatureDelta), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="TemperatureDelta"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(TemperatureDelta)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is TemperatureDelta otherQuantity)) throw new ArgumentException("Expected type TemperatureDelta.", nameof(obj));
+            if (obj is not TemperatureDelta otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<TemperatureDelta>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="TemperatureDelta"/> with another <see cref="TemperatureDelta"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="TemperatureDelta"/> with another <see cref="TemperatureDelta"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -770,145 +801,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(TemperatureDelta other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(TemperatureDeltaUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<TemperatureDeltaUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this TemperatureDelta to another TemperatureDelta with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A TemperatureDelta with the specified unit.</returns>
-        public TemperatureDelta ToUnit(TemperatureDeltaUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="TemperatureDelta"/> to another <see cref="TemperatureDelta"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A TemperatureDelta with the specified unit.</returns>
-        public TemperatureDelta ToUnit(TemperatureDeltaUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(TemperatureDelta), Unit, typeof(TemperatureDelta), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (TemperatureDelta)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="TemperatureDelta"/> to another <see cref="TemperatureDelta"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="TemperatureDelta"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(TemperatureDeltaUnit unit, [NotNullWhen(true)] out TemperatureDelta? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            TemperatureDelta? convertedOrNull = (Unit, unit) switch
-            {
-                // TemperatureDeltaUnit -> BaseUnit
-                (TemperatureDeltaUnit.DegreeCelsius, TemperatureDeltaUnit.Kelvin) => new TemperatureDelta(_value, TemperatureDeltaUnit.Kelvin),
-                (TemperatureDeltaUnit.DegreeDelisle, TemperatureDeltaUnit.Kelvin) => new TemperatureDelta(_value * -2 / 3, TemperatureDeltaUnit.Kelvin),
-                (TemperatureDeltaUnit.DegreeFahrenheit, TemperatureDeltaUnit.Kelvin) => new TemperatureDelta(_value * 5 / 9, TemperatureDeltaUnit.Kelvin),
-                (TemperatureDeltaUnit.DegreeNewton, TemperatureDeltaUnit.Kelvin) => new TemperatureDelta(_value * 100 / 33, TemperatureDeltaUnit.Kelvin),
-                (TemperatureDeltaUnit.DegreeRankine, TemperatureDeltaUnit.Kelvin) => new TemperatureDelta(_value * 5 / 9, TemperatureDeltaUnit.Kelvin),
-                (TemperatureDeltaUnit.DegreeReaumur, TemperatureDeltaUnit.Kelvin) => new TemperatureDelta(_value * 5 / 4, TemperatureDeltaUnit.Kelvin),
-                (TemperatureDeltaUnit.DegreeRoemer, TemperatureDeltaUnit.Kelvin) => new TemperatureDelta(_value * 40 / 21, TemperatureDeltaUnit.Kelvin),
-                (TemperatureDeltaUnit.MillidegreeCelsius, TemperatureDeltaUnit.Kelvin) => new TemperatureDelta((_value) * 1e-3d, TemperatureDeltaUnit.Kelvin),
-
-                // BaseUnit -> TemperatureDeltaUnit
-                (TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeCelsius) => new TemperatureDelta(_value, TemperatureDeltaUnit.DegreeCelsius),
-                (TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeDelisle) => new TemperatureDelta(_value * -3 / 2, TemperatureDeltaUnit.DegreeDelisle),
-                (TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeFahrenheit) => new TemperatureDelta(_value * 9 / 5, TemperatureDeltaUnit.DegreeFahrenheit),
-                (TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeNewton) => new TemperatureDelta(_value * 33 / 100, TemperatureDeltaUnit.DegreeNewton),
-                (TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeRankine) => new TemperatureDelta(_value * 9 / 5, TemperatureDeltaUnit.DegreeRankine),
-                (TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeReaumur) => new TemperatureDelta(_value * 4 / 5, TemperatureDeltaUnit.DegreeReaumur),
-                (TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.DegreeRoemer) => new TemperatureDelta(_value * 21 / 40, TemperatureDeltaUnit.DegreeRoemer),
-                (TemperatureDeltaUnit.Kelvin, TemperatureDeltaUnit.MillidegreeCelsius) => new TemperatureDelta((_value) / 1e-3d, TemperatureDeltaUnit.MillidegreeCelsius),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not TemperatureDeltaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureDeltaUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is TemperatureDeltaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureDeltaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<TemperatureDeltaUnit> IQuantity<TemperatureDeltaUnit>.ToUnit(TemperatureDeltaUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -922,11 +817,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
index f215eb31ca..1ca57bfa9d 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct TemperatureGradient :
-        IArithmeticQuantity<TemperatureGradient, TemperatureGradientUnit>,
+        ILinearQuantity<TemperatureGradient, TemperatureGradientUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<TemperatureGradient, TemperatureGradient, double>,
+        IDivisionOperators<TemperatureGradient, TemperatureGradient, QuantityValue>,
         IMultiplyOperators<TemperatureGradient, Length, TemperatureDelta>,
         IComparisonOperators<TemperatureGradient, TemperatureGradient, bool>,
         IParsable<TemperatureGradient>,
@@ -53,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -103,7 +102,7 @@ public static TemperatureGradientInfo CreateDefault(Func<IEnumerable<UnitDefinit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="TemperatureGradient"/> is [L^-1][Θ].
+            ///     The <see cref="BaseDimensions" /> for <see cref="TemperatureGradient"/> is L^-1Θ.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 0, 0, 0, 1, 0, 0);
 
@@ -118,18 +117,22 @@ public static TemperatureGradientInfo CreateDefault(Func<IEnumerable<UnitDefinit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{TemperatureGradientUnit}"/> representing the default unit mappings for TemperatureGradient.</returns>
             public static IEnumerable<UnitDefinition<TemperatureGradientUnit>> GetDefaultMappings()
             {
-                yield return new (TemperatureGradientUnit.DegreeCelsiusPerKilometer, "DegreeCelsiusPerKilometer", "DegreesCelsiusPerKilometer", new BaseUnits(length: LengthUnit.Kilometer, temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (TemperatureGradientUnit.DegreeCelsiusPerMeter, "DegreeCelsiusPerMeter", "DegreesCelsiusPerMeter", new BaseUnits(length: LengthUnit.Meter, temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (TemperatureGradientUnit.DegreeFahrenheitPerFoot, "DegreeFahrenheitPerFoot", "DegreesFahrenheitPerFoot", new BaseUnits(length: LengthUnit.Foot, temperature: TemperatureUnit.DegreeFahrenheit));
+                yield return new (TemperatureGradientUnit.DegreeCelsiusPerKilometer, "DegreeCelsiusPerKilometer", "DegreesCelsiusPerKilometer", new BaseUnits(length: LengthUnit.Kilometer, temperature: TemperatureUnit.DegreeCelsius),
+                     1000
+                );
+                yield return new (TemperatureGradientUnit.DegreeCelsiusPerMeter, "DegreeCelsiusPerMeter", "DegreesCelsiusPerMeter", new BaseUnits(length: LengthUnit.Meter, temperature: TemperatureUnit.DegreeCelsius),
+                     1
+                );
+                yield return new (TemperatureGradientUnit.DegreeFahrenheitPerFoot, "DegreeFahrenheitPerFoot", "DegreesFahrenheitPerFoot", new BaseUnits(length: LengthUnit.Foot, temperature: TemperatureUnit.DegreeFahrenheit),
+                     new QuantityValue(3429, 6250)
+                );
                 yield return new (TemperatureGradientUnit.KelvinPerMeter, "KelvinPerMeter", "KelvinsPerMeter", new BaseUnits(length: LengthUnit.Meter, temperature: TemperatureUnit.Kelvin));
             }
         }
 
         static TemperatureGradient()
         {
-            Info = TemperatureGradientInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(TemperatureGradientInfo.CreateDefault);
         }
 
         /// <summary>
@@ -137,7 +140,7 @@ static TemperatureGradient()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public TemperatureGradient(double value, TemperatureGradientUnit unit)
+        public TemperatureGradient(QuantityValue value, TemperatureGradientUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -151,7 +154,7 @@ public TemperatureGradient(double value, TemperatureGradientUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public TemperatureGradient(double value, UnitSystem unitSystem)
+        public TemperatureGradient(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -162,7 +165,8 @@ public TemperatureGradient(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="TemperatureGradient" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<TemperatureGradient, TemperatureGradientUnit> Info { get; }
@@ -191,10 +195,8 @@ public TemperatureGradient(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public TemperatureGradientUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -228,49 +230,29 @@ public TemperatureGradient(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureGradientUnit.DegreeCelsiusPerKilometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureGradientUnit.DegreeCelsiusPerKilometer"/>
         /// </summary>
-        public double DegreesCelsiusPerKilometer => As(TemperatureGradientUnit.DegreeCelsiusPerKilometer);
+        public QuantityValue DegreesCelsiusPerKilometer => this.As(TemperatureGradientUnit.DegreeCelsiusPerKilometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureGradientUnit.DegreeCelsiusPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureGradientUnit.DegreeCelsiusPerMeter"/>
         /// </summary>
-        public double DegreesCelsiusPerMeter => As(TemperatureGradientUnit.DegreeCelsiusPerMeter);
+        public QuantityValue DegreesCelsiusPerMeter => this.As(TemperatureGradientUnit.DegreeCelsiusPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureGradientUnit.DegreeFahrenheitPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureGradientUnit.DegreeFahrenheitPerFoot"/>
         /// </summary>
-        public double DegreesFahrenheitPerFoot => As(TemperatureGradientUnit.DegreeFahrenheitPerFoot);
+        public QuantityValue DegreesFahrenheitPerFoot => this.As(TemperatureGradientUnit.DegreeFahrenheitPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TemperatureGradientUnit.KelvinPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TemperatureGradientUnit.KelvinPerMeter"/>
         /// </summary>
-        public double KelvinsPerMeter => As(TemperatureGradientUnit.KelvinPerMeter);
+        public QuantityValue KelvinsPerMeter => this.As(TemperatureGradientUnit.KelvinPerMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: TemperatureGradientUnit -> BaseUnit
-            unitConverter.SetConversionFunction<TemperatureGradient>(TemperatureGradientUnit.DegreeCelsiusPerKilometer, TemperatureGradientUnit.KelvinPerMeter, quantity => quantity.ToUnit(TemperatureGradientUnit.KelvinPerMeter));
-            unitConverter.SetConversionFunction<TemperatureGradient>(TemperatureGradientUnit.DegreeCelsiusPerMeter, TemperatureGradientUnit.KelvinPerMeter, quantity => quantity.ToUnit(TemperatureGradientUnit.KelvinPerMeter));
-            unitConverter.SetConversionFunction<TemperatureGradient>(TemperatureGradientUnit.DegreeFahrenheitPerFoot, TemperatureGradientUnit.KelvinPerMeter, quantity => quantity.ToUnit(TemperatureGradientUnit.KelvinPerMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<TemperatureGradient>(TemperatureGradientUnit.KelvinPerMeter, TemperatureGradientUnit.KelvinPerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> TemperatureGradientUnit
-            unitConverter.SetConversionFunction<TemperatureGradient>(TemperatureGradientUnit.KelvinPerMeter, TemperatureGradientUnit.DegreeCelsiusPerKilometer, quantity => quantity.ToUnit(TemperatureGradientUnit.DegreeCelsiusPerKilometer));
-            unitConverter.SetConversionFunction<TemperatureGradient>(TemperatureGradientUnit.KelvinPerMeter, TemperatureGradientUnit.DegreeCelsiusPerMeter, quantity => quantity.ToUnit(TemperatureGradientUnit.DegreeCelsiusPerMeter));
-            unitConverter.SetConversionFunction<TemperatureGradient>(TemperatureGradientUnit.KelvinPerMeter, TemperatureGradientUnit.DegreeFahrenheitPerFoot, quantity => quantity.ToUnit(TemperatureGradientUnit.DegreeFahrenheitPerFoot));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -299,7 +281,7 @@ public static string GetAbbreviation(TemperatureGradientUnit unit, IFormatProvid
         /// <summary>
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeCelsiusPerKilometer"/>.
         /// </summary>
-        public static TemperatureGradient FromDegreesCelsiusPerKilometer(double value)
+        public static TemperatureGradient FromDegreesCelsiusPerKilometer(QuantityValue value)
         {
             return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerKilometer);
         }
@@ -307,7 +289,7 @@ public static TemperatureGradient FromDegreesCelsiusPerKilometer(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeCelsiusPerMeter"/>.
         /// </summary>
-        public static TemperatureGradient FromDegreesCelsiusPerMeter(double value)
+        public static TemperatureGradient FromDegreesCelsiusPerMeter(QuantityValue value)
         {
             return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerMeter);
         }
@@ -315,7 +297,7 @@ public static TemperatureGradient FromDegreesCelsiusPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeFahrenheitPerFoot"/>.
         /// </summary>
-        public static TemperatureGradient FromDegreesFahrenheitPerFoot(double value)
+        public static TemperatureGradient FromDegreesFahrenheitPerFoot(QuantityValue value)
         {
             return new TemperatureGradient(value, TemperatureGradientUnit.DegreeFahrenheitPerFoot);
         }
@@ -323,7 +305,7 @@ public static TemperatureGradient FromDegreesFahrenheitPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.KelvinPerMeter"/>.
         /// </summary>
-        public static TemperatureGradient FromKelvinsPerMeter(double value)
+        public static TemperatureGradient FromKelvinsPerMeter(QuantityValue value)
         {
             return new TemperatureGradient(value, TemperatureGradientUnit.KelvinPerMeter);
         }
@@ -334,7 +316,7 @@ public static TemperatureGradient FromKelvinsPerMeter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>TemperatureGradient unit value.</returns>
-        public static TemperatureGradient From(double value, TemperatureGradientUnit fromUnit)
+        public static TemperatureGradient From(QuantityValue value, TemperatureGradientUnit fromUnit)
         {
             return new TemperatureGradient(value, fromUnit);
         }
@@ -395,10 +377,7 @@ public static TemperatureGradient Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static TemperatureGradient Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<TemperatureGradient, TemperatureGradientUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<TemperatureGradient, TemperatureGradientUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -426,11 +405,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out TemperatureGradi
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out TemperatureGradient result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<TemperatureGradient, TemperatureGradientUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<TemperatureGradient, TemperatureGradientUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -451,7 +426,7 @@ public static TemperatureGradientUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -462,7 +437,7 @@ public static TemperatureGradientUnit ParseUnit(string str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TemperatureGradientUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.TemperatureGradientUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureGradientUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -477,7 +452,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TemperatureG
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out TemperatureGradientUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -496,35 +471,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="TemperatureGradient"/> from adding two <see cref="TemperatureGradient"/>.</summary>
         public static TemperatureGradient operator +(TemperatureGradient left, TemperatureGradient right)
         {
-            return new TemperatureGradient(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new TemperatureGradient(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureGradient"/> from subtracting two <see cref="TemperatureGradient"/>.</summary>
         public static TemperatureGradient operator -(TemperatureGradient left, TemperatureGradient right)
         {
-            return new TemperatureGradient(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new TemperatureGradient(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureGradient"/> from multiplying value and <see cref="TemperatureGradient"/>.</summary>
-        public static TemperatureGradient operator *(double left, TemperatureGradient right)
+        public static TemperatureGradient operator *(QuantityValue left, TemperatureGradient right)
         {
             return new TemperatureGradient(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureGradient"/> from multiplying value and <see cref="TemperatureGradient"/>.</summary>
-        public static TemperatureGradient operator *(TemperatureGradient left, double right)
+        public static TemperatureGradient operator *(TemperatureGradient left, QuantityValue right)
         {
             return new TemperatureGradient(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="TemperatureGradient"/> from dividing <see cref="TemperatureGradient"/> by value.</summary>
-        public static TemperatureGradient operator /(TemperatureGradient left, double right)
+        public static TemperatureGradient operator /(TemperatureGradient left, QuantityValue right)
         {
             return new TemperatureGradient(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="TemperatureGradient"/> by <see cref="TemperatureGradient"/>.</summary>
-        public static double operator /(TemperatureGradient left, TemperatureGradient right)
+        public static QuantityValue operator /(TemperatureGradient left, TemperatureGradient right)
         {
             return left.KelvinsPerMeter / right.KelvinsPerMeter;
         }
@@ -546,97 +521,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(TemperatureGradient left, TemperatureGradient right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(TemperatureGradient left, TemperatureGradient right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(TemperatureGradient left, TemperatureGradient right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(TemperatureGradient left, TemperatureGradient right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="TemperatureGradient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(TemperatureGradient other, TemperatureGradient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="TemperatureGradient"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(TemperatureGradient)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(TemperatureGradient left, TemperatureGradient right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="TemperatureGradient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(TemperatureGradient other, TemperatureGradient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="TemperatureGradient"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(TemperatureGradient,TemperatureGradient)"/>.
+        ///     See that operator (and <see cref="Equals(TemperatureGradient)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(TemperatureGradient left, TemperatureGradient right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="TemperatureGradient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(TemperatureGradient other, TemperatureGradient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="TemperatureGradient"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="TemperatureGradient"/>.
+        ///     When <paramref name="obj"/> is a <see cref="TemperatureGradient"/>, this method delegates to
+        ///     <see cref="Equals(TemperatureGradient)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is TemperatureGradient otherQuantity))
+            if (obj is not TemperatureGradient otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="TemperatureGradient"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(TemperatureGradient other, TemperatureGradient tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="TemperatureGradient"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(TemperatureGradient other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current TemperatureGradient.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(TemperatureGradient), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="TemperatureGradient"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(TemperatureGradient)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is TemperatureGradient otherQuantity)) throw new ArgumentException("Expected type TemperatureGradient.", nameof(obj));
+            if (obj is not TemperatureGradient otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<TemperatureGradient>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="TemperatureGradient"/> with another <see cref="TemperatureGradient"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="TemperatureGradient"/> with another <see cref="TemperatureGradient"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -648,137 +637,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(TemperatureGradient other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(TemperatureGradientUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<TemperatureGradientUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this TemperatureGradient to another TemperatureGradient with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A TemperatureGradient with the specified unit.</returns>
-        public TemperatureGradient ToUnit(TemperatureGradientUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="TemperatureGradient"/> to another <see cref="TemperatureGradient"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A TemperatureGradient with the specified unit.</returns>
-        public TemperatureGradient ToUnit(TemperatureGradientUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(TemperatureGradient), Unit, typeof(TemperatureGradient), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (TemperatureGradient)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="TemperatureGradient"/> to another <see cref="TemperatureGradient"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="TemperatureGradient"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(TemperatureGradientUnit unit, [NotNullWhen(true)] out TemperatureGradient? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            TemperatureGradient? convertedOrNull = (Unit, unit) switch
-            {
-                // TemperatureGradientUnit -> BaseUnit
-                (TemperatureGradientUnit.DegreeCelsiusPerKilometer, TemperatureGradientUnit.KelvinPerMeter) => new TemperatureGradient(_value / 1e3, TemperatureGradientUnit.KelvinPerMeter),
-                (TemperatureGradientUnit.DegreeCelsiusPerMeter, TemperatureGradientUnit.KelvinPerMeter) => new TemperatureGradient(_value, TemperatureGradientUnit.KelvinPerMeter),
-                (TemperatureGradientUnit.DegreeFahrenheitPerFoot, TemperatureGradientUnit.KelvinPerMeter) => new TemperatureGradient((_value / 0.3048) * 5 / 9, TemperatureGradientUnit.KelvinPerMeter),
-
-                // BaseUnit -> TemperatureGradientUnit
-                (TemperatureGradientUnit.KelvinPerMeter, TemperatureGradientUnit.DegreeCelsiusPerKilometer) => new TemperatureGradient(_value * 1e3, TemperatureGradientUnit.DegreeCelsiusPerKilometer),
-                (TemperatureGradientUnit.KelvinPerMeter, TemperatureGradientUnit.DegreeCelsiusPerMeter) => new TemperatureGradient(_value, TemperatureGradientUnit.DegreeCelsiusPerMeter),
-                (TemperatureGradientUnit.KelvinPerMeter, TemperatureGradientUnit.DegreeFahrenheitPerFoot) => new TemperatureGradient((_value * 0.3048) * 9 / 5, TemperatureGradientUnit.DegreeFahrenheitPerFoot),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not TemperatureGradientUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureGradientUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is TemperatureGradientUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureGradientUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<TemperatureGradientUnit> IQuantity<TemperatureGradientUnit>.ToUnit(TemperatureGradientUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -790,11 +653,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
index 3821de1292..7e3b9d58cb 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Thermal_Conductivity
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ThermalConductivity :
-        IArithmeticQuantity<ThermalConductivity, ThermalConductivityUnit>,
+        ILinearQuantity<ThermalConductivity, ThermalConductivityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ThermalConductivity, ThermalConductivity, double>,
+        IDivisionOperators<ThermalConductivity, ThermalConductivity, QuantityValue>,
         IComparisonOperators<ThermalConductivity, ThermalConductivity, bool>,
         IParsable<ThermalConductivity>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +104,7 @@ public static ThermalConductivityInfo CreateDefault(Func<IEnumerable<UnitDefinit
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ThermalConductivity"/> is [T^-3][L][M][Θ^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ThermalConductivity"/> is T^-3LMΘ^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 1, -3, 0, -1, 0, 0);
 
@@ -120,16 +119,19 @@ public static ThermalConductivityInfo CreateDefault(Func<IEnumerable<UnitDefinit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ThermalConductivityUnit}"/> representing the default unit mappings for ThermalConductivity.</returns>
             public static IEnumerable<UnitDefinition<ThermalConductivityUnit>> GetDefaultMappings()
             {
-                yield return new (ThermalConductivityUnit.BtuPerHourFootFahrenheit, "BtuPerHourFootFahrenheit", "BtusPerHourFootFahrenheit", BaseUnits.Undefined);
+                yield return new (ThermalConductivityUnit.BtuPerHourFootFahrenheit, "BtuPerHourFootFahrenheit", "BtusPerHourFootFahrenheit", BaseUnits.Undefined,
+                     new QuantityValue(30480000000, 52752792631)
+                );
+                yield return new (ThermalConductivityUnit.BtuPerSecondInchFahrenheit, "BtuPerSecondInchFahrenheit", "BtusPerSecondInchFahrenheit", BaseUnits.Undefined,
+                     new QuantityValue(6350000, 474775133679)
+                );
                 yield return new (ThermalConductivityUnit.WattPerMeterKelvin, "WattPerMeterKelvin", "WattsPerMeterKelvin", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
             }
         }
 
         static ThermalConductivity()
         {
-            Info = ThermalConductivityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ThermalConductivityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -137,7 +139,7 @@ static ThermalConductivity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ThermalConductivity(double value, ThermalConductivityUnit unit)
+        public ThermalConductivity(QuantityValue value, ThermalConductivityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -151,7 +153,7 @@ public ThermalConductivity(double value, ThermalConductivityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ThermalConductivity(double value, UnitSystem unitSystem)
+        public ThermalConductivity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -162,7 +164,8 @@ public ThermalConductivity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ThermalConductivity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ThermalConductivity, ThermalConductivityUnit> Info { get; }
@@ -191,10 +194,8 @@ public ThermalConductivity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ThermalConductivityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -228,34 +229,23 @@ public ThermalConductivity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalConductivityUnit.BtuPerHourFootFahrenheit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalConductivityUnit.BtuPerHourFootFahrenheit"/>
         /// </summary>
-        public double BtusPerHourFootFahrenheit => As(ThermalConductivityUnit.BtuPerHourFootFahrenheit);
+        public QuantityValue BtusPerHourFootFahrenheit => this.As(ThermalConductivityUnit.BtuPerHourFootFahrenheit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalConductivityUnit.WattPerMeterKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalConductivityUnit.BtuPerSecondInchFahrenheit"/>
         /// </summary>
-        public double WattsPerMeterKelvin => As(ThermalConductivityUnit.WattPerMeterKelvin);
-
-        #endregion
-
-        #region Static Methods
+        public QuantityValue BtusPerSecondInchFahrenheit => this.As(ThermalConductivityUnit.BtuPerSecondInchFahrenheit);
 
         /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalConductivityUnit.WattPerMeterKelvin"/>
         /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ThermalConductivityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ThermalConductivity>(ThermalConductivityUnit.BtuPerHourFootFahrenheit, ThermalConductivityUnit.WattPerMeterKelvin, quantity => quantity.ToUnit(ThermalConductivityUnit.WattPerMeterKelvin));
+        public QuantityValue WattsPerMeterKelvin => this.As(ThermalConductivityUnit.WattPerMeterKelvin);
 
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ThermalConductivity>(ThermalConductivityUnit.WattPerMeterKelvin, ThermalConductivityUnit.WattPerMeterKelvin, quantity => quantity);
+        #endregion
 
-            // Register in unit converter: BaseUnit -> ThermalConductivityUnit
-            unitConverter.SetConversionFunction<ThermalConductivity>(ThermalConductivityUnit.WattPerMeterKelvin, ThermalConductivityUnit.BtuPerHourFootFahrenheit, quantity => quantity.ToUnit(ThermalConductivityUnit.BtuPerHourFootFahrenheit));
-        }
+        #region Static Methods
 
         /// <summary>
         ///     Get unit abbreviation string.
@@ -285,15 +275,23 @@ public static string GetAbbreviation(ThermalConductivityUnit unit, IFormatProvid
         /// <summary>
         ///     Creates a <see cref="ThermalConductivity"/> from <see cref="ThermalConductivityUnit.BtuPerHourFootFahrenheit"/>.
         /// </summary>
-        public static ThermalConductivity FromBtusPerHourFootFahrenheit(double value)
+        public static ThermalConductivity FromBtusPerHourFootFahrenheit(QuantityValue value)
         {
             return new ThermalConductivity(value, ThermalConductivityUnit.BtuPerHourFootFahrenheit);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="ThermalConductivity"/> from <see cref="ThermalConductivityUnit.BtuPerSecondInchFahrenheit"/>.
+        /// </summary>
+        public static ThermalConductivity FromBtusPerSecondInchFahrenheit(QuantityValue value)
+        {
+            return new ThermalConductivity(value, ThermalConductivityUnit.BtuPerSecondInchFahrenheit);
+        }
+
         /// <summary>
         ///     Creates a <see cref="ThermalConductivity"/> from <see cref="ThermalConductivityUnit.WattPerMeterKelvin"/>.
         /// </summary>
-        public static ThermalConductivity FromWattsPerMeterKelvin(double value)
+        public static ThermalConductivity FromWattsPerMeterKelvin(QuantityValue value)
         {
             return new ThermalConductivity(value, ThermalConductivityUnit.WattPerMeterKelvin);
         }
@@ -304,7 +302,7 @@ public static ThermalConductivity FromWattsPerMeterKelvin(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ThermalConductivity unit value.</returns>
-        public static ThermalConductivity From(double value, ThermalConductivityUnit fromUnit)
+        public static ThermalConductivity From(QuantityValue value, ThermalConductivityUnit fromUnit)
         {
             return new ThermalConductivity(value, fromUnit);
         }
@@ -365,10 +363,7 @@ public static ThermalConductivity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ThermalConductivity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ThermalConductivity, ThermalConductivityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ThermalConductivity, ThermalConductivityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -396,11 +391,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ThermalConductiv
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ThermalConductivity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ThermalConductivity, ThermalConductivityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ThermalConductivity, ThermalConductivityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -421,7 +412,7 @@ public static ThermalConductivityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -432,7 +423,7 @@ public static ThermalConductivityUnit ParseUnit(string str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ThermalConductivityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ThermalConductivityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ThermalConductivityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -447,7 +438,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ThermalCondu
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ThermalConductivityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -466,35 +457,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ThermalConductivity"/> from adding two <see cref="ThermalConductivity"/>.</summary>
         public static ThermalConductivity operator +(ThermalConductivity left, ThermalConductivity right)
         {
-            return new ThermalConductivity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ThermalConductivity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ThermalConductivity"/> from subtracting two <see cref="ThermalConductivity"/>.</summary>
         public static ThermalConductivity operator -(ThermalConductivity left, ThermalConductivity right)
         {
-            return new ThermalConductivity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ThermalConductivity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ThermalConductivity"/> from multiplying value and <see cref="ThermalConductivity"/>.</summary>
-        public static ThermalConductivity operator *(double left, ThermalConductivity right)
+        public static ThermalConductivity operator *(QuantityValue left, ThermalConductivity right)
         {
             return new ThermalConductivity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ThermalConductivity"/> from multiplying value and <see cref="ThermalConductivity"/>.</summary>
-        public static ThermalConductivity operator *(ThermalConductivity left, double right)
+        public static ThermalConductivity operator *(ThermalConductivity left, QuantityValue right)
         {
             return new ThermalConductivity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ThermalConductivity"/> from dividing <see cref="ThermalConductivity"/> by value.</summary>
-        public static ThermalConductivity operator /(ThermalConductivity left, double right)
+        public static ThermalConductivity operator /(ThermalConductivity left, QuantityValue right)
         {
             return new ThermalConductivity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ThermalConductivity"/> by <see cref="ThermalConductivity"/>.</summary>
-        public static double operator /(ThermalConductivity left, ThermalConductivity right)
+        public static QuantityValue operator /(ThermalConductivity left, ThermalConductivity right)
         {
             return left.WattsPerMeterKelvin / right.WattsPerMeterKelvin;
         }
@@ -506,97 +497,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ThermalConductivity left, ThermalConductivity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ThermalConductivity left, ThermalConductivity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ThermalConductivity left, ThermalConductivity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ThermalConductivity left, ThermalConductivity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ThermalConductivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ThermalConductivity other, ThermalConductivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ThermalConductivity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ThermalConductivity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ThermalConductivity left, ThermalConductivity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ThermalConductivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ThermalConductivity other, ThermalConductivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ThermalConductivity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ThermalConductivity,ThermalConductivity)"/>.
+        ///     See that operator (and <see cref="Equals(ThermalConductivity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ThermalConductivity left, ThermalConductivity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ThermalConductivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ThermalConductivity other, ThermalConductivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ThermalConductivity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ThermalConductivity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ThermalConductivity"/>, this method delegates to
+        ///     <see cref="Equals(ThermalConductivity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ThermalConductivity otherQuantity))
+            if (obj is not ThermalConductivity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ThermalConductivity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ThermalConductivity other, ThermalConductivity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ThermalConductivity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ThermalConductivity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ThermalConductivity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ThermalConductivity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ThermalConductivity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ThermalConductivity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ThermalConductivity otherQuantity)) throw new ArgumentException("Expected type ThermalConductivity.", nameof(obj));
+            if (obj is not ThermalConductivity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ThermalConductivity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ThermalConductivity"/> with another <see cref="ThermalConductivity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ThermalConductivity"/> with another <see cref="ThermalConductivity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -608,133 +613,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ThermalConductivity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ThermalConductivityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ThermalConductivityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ThermalConductivity to another ThermalConductivity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ThermalConductivity with the specified unit.</returns>
-        public ThermalConductivity ToUnit(ThermalConductivityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ThermalConductivity"/> to another <see cref="ThermalConductivity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ThermalConductivity with the specified unit.</returns>
-        public ThermalConductivity ToUnit(ThermalConductivityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ThermalConductivity), Unit, typeof(ThermalConductivity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ThermalConductivity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ThermalConductivity"/> to another <see cref="ThermalConductivity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ThermalConductivity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ThermalConductivityUnit unit, [NotNullWhen(true)] out ThermalConductivity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ThermalConductivity? convertedOrNull = (Unit, unit) switch
-            {
-                // ThermalConductivityUnit -> BaseUnit
-                (ThermalConductivityUnit.BtuPerHourFootFahrenheit, ThermalConductivityUnit.WattPerMeterKelvin) => new ThermalConductivity(_value * ((1055.05585262 / (0.3048 * 3600)) * 1.8), ThermalConductivityUnit.WattPerMeterKelvin),
-
-                // BaseUnit -> ThermalConductivityUnit
-                (ThermalConductivityUnit.WattPerMeterKelvin, ThermalConductivityUnit.BtuPerHourFootFahrenheit) => new ThermalConductivity(_value / ((1055.05585262 / (0.3048 * 3600)) * 1.8), ThermalConductivityUnit.BtuPerHourFootFahrenheit),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ThermalConductivityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalConductivityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ThermalConductivityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalConductivityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ThermalConductivityUnit> IQuantity<ThermalConductivityUnit>.ToUnit(ThermalConductivityUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -746,11 +629,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalInsulance.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalInsulance.g.cs
index 3c08dc9c5a..7aeb1c1152 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalInsulance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalInsulance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     Thermal insulance (R-value) is a measure of a material's resistance to the heat current. It quantifies how effectively a material can resist the transfer of heat through conduction, convection, and radiation. It has the units square metre kelvins per watt (m2⋅K/W) in SI units or square foot degree Fahrenheit–hours per British thermal unit (ft2⋅°F⋅h/Btu) in imperial units. The higher the thermal insulance, the better a material insulates against heat transfer. It is commonly used in construction to assess the insulation properties of materials such as walls, roofs, and insulation products.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ThermalInsulance :
-        IArithmeticQuantity<ThermalInsulance, ThermalInsulanceUnit>,
+        ILinearQuantity<ThermalInsulance, ThermalInsulanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ThermalInsulance, ThermalInsulance, double>,
+        IDivisionOperators<ThermalInsulance, ThermalInsulance, QuantityValue>,
+        IMultiplyOperators<ThermalInsulance, HeatFlux, TemperatureDelta>,
         IComparisonOperators<ThermalInsulance, ThermalInsulance, bool>,
         IParsable<ThermalInsulance>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static ThermalInsulanceInfo CreateDefault(Func<IEnumerable<UnitDefinition
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ThermalInsulance"/> is [T^3][M^-1][Θ].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ThermalInsulance"/> is T^3M^-1Θ.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(0, -1, 3, 0, 1, 0, 0);
 
@@ -117,21 +117,31 @@ public static ThermalInsulanceInfo CreateDefault(Func<IEnumerable<UnitDefinition
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ThermalInsulanceUnit}"/> representing the default unit mappings for ThermalInsulance.</returns>
             public static IEnumerable<UnitDefinition<ThermalInsulanceUnit>> GetDefaultMappings()
             {
-                yield return new (ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, "HourSquareFeetDegreeFahrenheitPerBtu", "HourSquareFeetDegreesFahrenheitPerBtu", BaseUnits.Undefined);
-                yield return new (ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, "SquareCentimeterHourDegreeCelsiusPerKilocalorie", "SquareCentimeterHourDegreesCelsiusPerKilocalorie", BaseUnits.Undefined);
-                yield return new (ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt, "SquareCentimeterKelvinPerWatt", "SquareCentimeterKelvinsPerWatt", BaseUnits.Undefined);
-                yield return new (ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt, "SquareMeterDegreeCelsiusPerWatt", "SquareMeterDegreesCelsiusPerWatt", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius));
+                yield return new (ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, "HourSquareFeetDegreeFahrenheitPerBtu", "HourSquareFeetDegreesFahrenheitPerBtu", BaseUnits.Undefined,
+                     new QuantityValue(52752792631, 9290304000000)
+                );
+                yield return new (ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, "SquareCentimeterHourDegreeCelsiusPerKilocalorie", "SquareCentimeterHourDegreesCelsiusPerKilocalorie", BaseUnits.Undefined,
+                     new QuantityValue(523, 45)
+                );
+                yield return new (ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt, "SquareCentimeterKelvinPerWatt", "SquareCentimeterKelvinsPerWatt", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt, "SquareMeterDegreeCelsiusPerWatt", "SquareMeterDegreesCelsiusPerWatt", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius),
+                     new QuantityValue(1, 1000)
+                );
                 yield return new (ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, "SquareMeterKelvinPerKilowatt", "SquareMeterKelvinsPerKilowatt", BaseUnits.Undefined);
-                yield return new (ThermalInsulanceUnit.SquareMeterKelvinPerWatt, "SquareMeterKelvinPerWatt", "SquareMeterKelvinsPerWatt", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
-                yield return new (ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt, "SquareMillimeterKelvinPerWatt", "SquareMillimeterKelvinsPerWatt", BaseUnits.Undefined);
+                yield return new (ThermalInsulanceUnit.SquareMeterKelvinPerWatt, "SquareMeterKelvinPerWatt", "SquareMeterKelvinsPerWatt", new BaseUnits(mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt, "SquareMillimeterKelvinPerWatt", "SquareMillimeterKelvinsPerWatt", BaseUnits.Undefined,
+                     1000
+                );
             }
         }
 
         static ThermalInsulance()
         {
-            Info = ThermalInsulanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ThermalInsulanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -139,7 +149,7 @@ static ThermalInsulance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ThermalInsulance(double value, ThermalInsulanceUnit unit)
+        public ThermalInsulance(QuantityValue value, ThermalInsulanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -153,7 +163,7 @@ public ThermalInsulance(double value, ThermalInsulanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ThermalInsulance(double value, UnitSystem unitSystem)
+        public ThermalInsulance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -164,7 +174,8 @@ public ThermalInsulance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ThermalInsulance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ThermalInsulance, ThermalInsulanceUnit> Info { get; }
@@ -193,10 +204,8 @@ public ThermalInsulance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ThermalInsulanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -230,70 +239,44 @@ public ThermalInsulance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu"/>
         /// </summary>
-        public double HourSquareFeetDegreesFahrenheitPerBtu => As(ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
+        public QuantityValue HourSquareFeetDegreesFahrenheitPerBtu => this.As(ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie"/>
         /// </summary>
-        public double SquareCentimeterHourDegreesCelsiusPerKilocalorie => As(ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
+        public QuantityValue SquareCentimeterHourDegreesCelsiusPerKilocalorie => this.As(ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt"/>
         /// </summary>
-        public double SquareCentimeterKelvinsPerWatt => As(ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt);
+        public QuantityValue SquareCentimeterKelvinsPerWatt => this.As(ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt"/>
         /// </summary>
-        public double SquareMeterDegreesCelsiusPerWatt => As(ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt);
+        public QuantityValue SquareMeterDegreesCelsiusPerWatt => this.As(ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt"/>
         /// </summary>
-        public double SquareMeterKelvinsPerKilowatt => As(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt);
+        public QuantityValue SquareMeterKelvinsPerKilowatt => this.As(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMeterKelvinPerWatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMeterKelvinPerWatt"/>
         /// </summary>
-        public double SquareMeterKelvinsPerWatt => As(ThermalInsulanceUnit.SquareMeterKelvinPerWatt);
+        public QuantityValue SquareMeterKelvinsPerWatt => this.As(ThermalInsulanceUnit.SquareMeterKelvinPerWatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt"/>
         /// </summary>
-        public double SquareMillimeterKelvinsPerWatt => As(ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt);
+        public QuantityValue SquareMillimeterKelvinsPerWatt => this.As(ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ThermalInsulanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt));
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt));
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt));
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt));
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareMeterKelvinPerWatt, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt));
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ThermalInsulanceUnit
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, quantity => quantity.ToUnit(ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu));
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie));
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt));
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt));
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareMeterKelvinPerWatt, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareMeterKelvinPerWatt));
-            unitConverter.SetConversionFunction<ThermalInsulance>(ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt, quantity => quantity.ToUnit(ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -322,7 +305,7 @@ public static string GetAbbreviation(ThermalInsulanceUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu"/>.
         /// </summary>
-        public static ThermalInsulance FromHourSquareFeetDegreesFahrenheitPerBtu(double value)
+        public static ThermalInsulance FromHourSquareFeetDegreesFahrenheitPerBtu(QuantityValue value)
         {
             return new ThermalInsulance(value, ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
         }
@@ -330,7 +313,7 @@ public static ThermalInsulance FromHourSquareFeetDegreesFahrenheitPerBtu(double
         /// <summary>
         ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie"/>.
         /// </summary>
-        public static ThermalInsulance FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double value)
+        public static ThermalInsulance FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(QuantityValue value)
         {
             return new ThermalInsulance(value, ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
         }
@@ -338,7 +321,7 @@ public static ThermalInsulance FromSquareCentimeterHourDegreesCelsiusPerKilocalo
         /// <summary>
         ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt"/>.
         /// </summary>
-        public static ThermalInsulance FromSquareCentimeterKelvinsPerWatt(double value)
+        public static ThermalInsulance FromSquareCentimeterKelvinsPerWatt(QuantityValue value)
         {
             return new ThermalInsulance(value, ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt);
         }
@@ -346,7 +329,7 @@ public static ThermalInsulance FromSquareCentimeterKelvinsPerWatt(double value)
         /// <summary>
         ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt"/>.
         /// </summary>
-        public static ThermalInsulance FromSquareMeterDegreesCelsiusPerWatt(double value)
+        public static ThermalInsulance FromSquareMeterDegreesCelsiusPerWatt(QuantityValue value)
         {
             return new ThermalInsulance(value, ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt);
         }
@@ -354,7 +337,7 @@ public static ThermalInsulance FromSquareMeterDegreesCelsiusPerWatt(double value
         /// <summary>
         ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt"/>.
         /// </summary>
-        public static ThermalInsulance FromSquareMeterKelvinsPerKilowatt(double value)
+        public static ThermalInsulance FromSquareMeterKelvinsPerKilowatt(QuantityValue value)
         {
             return new ThermalInsulance(value, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt);
         }
@@ -362,7 +345,7 @@ public static ThermalInsulance FromSquareMeterKelvinsPerKilowatt(double value)
         /// <summary>
         ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareMeterKelvinPerWatt"/>.
         /// </summary>
-        public static ThermalInsulance FromSquareMeterKelvinsPerWatt(double value)
+        public static ThermalInsulance FromSquareMeterKelvinsPerWatt(QuantityValue value)
         {
             return new ThermalInsulance(value, ThermalInsulanceUnit.SquareMeterKelvinPerWatt);
         }
@@ -370,7 +353,7 @@ public static ThermalInsulance FromSquareMeterKelvinsPerWatt(double value)
         /// <summary>
         ///     Creates a <see cref="ThermalInsulance"/> from <see cref="ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt"/>.
         /// </summary>
-        public static ThermalInsulance FromSquareMillimeterKelvinsPerWatt(double value)
+        public static ThermalInsulance FromSquareMillimeterKelvinsPerWatt(QuantityValue value)
         {
             return new ThermalInsulance(value, ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt);
         }
@@ -381,7 +364,7 @@ public static ThermalInsulance FromSquareMillimeterKelvinsPerWatt(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ThermalInsulance unit value.</returns>
-        public static ThermalInsulance From(double value, ThermalInsulanceUnit fromUnit)
+        public static ThermalInsulance From(QuantityValue value, ThermalInsulanceUnit fromUnit)
         {
             return new ThermalInsulance(value, fromUnit);
         }
@@ -442,10 +425,7 @@ public static ThermalInsulance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ThermalInsulance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ThermalInsulance, ThermalInsulanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ThermalInsulance, ThermalInsulanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -473,11 +453,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ThermalInsulance
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ThermalInsulance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ThermalInsulance, ThermalInsulanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ThermalInsulance, ThermalInsulanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -498,7 +474,7 @@ public static ThermalInsulanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -509,7 +485,7 @@ public static ThermalInsulanceUnit ParseUnit(string str, IFormatProvider? provid
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ThermalInsulanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ThermalInsulanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ThermalInsulanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -524,7 +500,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ThermalInsul
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ThermalInsulanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -543,137 +519,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ThermalInsulance"/> from adding two <see cref="ThermalInsulance"/>.</summary>
         public static ThermalInsulance operator +(ThermalInsulance left, ThermalInsulance right)
         {
-            return new ThermalInsulance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ThermalInsulance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ThermalInsulance"/> from subtracting two <see cref="ThermalInsulance"/>.</summary>
         public static ThermalInsulance operator -(ThermalInsulance left, ThermalInsulance right)
         {
-            return new ThermalInsulance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ThermalInsulance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ThermalInsulance"/> from multiplying value and <see cref="ThermalInsulance"/>.</summary>
-        public static ThermalInsulance operator *(double left, ThermalInsulance right)
+        public static ThermalInsulance operator *(QuantityValue left, ThermalInsulance right)
         {
             return new ThermalInsulance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ThermalInsulance"/> from multiplying value and <see cref="ThermalInsulance"/>.</summary>
-        public static ThermalInsulance operator *(ThermalInsulance left, double right)
+        public static ThermalInsulance operator *(ThermalInsulance left, QuantityValue right)
         {
             return new ThermalInsulance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ThermalInsulance"/> from dividing <see cref="ThermalInsulance"/> by value.</summary>
-        public static ThermalInsulance operator /(ThermalInsulance left, double right)
+        public static ThermalInsulance operator /(ThermalInsulance left, QuantityValue right)
         {
             return new ThermalInsulance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ThermalInsulance"/> by <see cref="ThermalInsulance"/>.</summary>
-        public static double operator /(ThermalInsulance left, ThermalInsulance right)
+        public static QuantityValue operator /(ThermalInsulance left, ThermalInsulance right)
         {
             return left.SquareMeterKelvinsPerKilowatt / right.SquareMeterKelvinsPerKilowatt;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="TemperatureDelta"/> from <see cref="ThermalInsulance"/> * <see cref="HeatFlux"/>.</summary>
+        public static TemperatureDelta operator *(ThermalInsulance thermalInsulance, HeatFlux heatFlux)
+        {
+            return TemperatureDelta.FromKelvins(thermalInsulance.SquareMeterKelvinsPerWatt * heatFlux.WattsPerSquareMeter);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ThermalInsulance left, ThermalInsulance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ThermalInsulance left, ThermalInsulance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ThermalInsulance left, ThermalInsulance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ThermalInsulance left, ThermalInsulance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ThermalInsulance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ThermalInsulance other, ThermalInsulance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ThermalInsulance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ThermalInsulance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ThermalInsulance left, ThermalInsulance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ThermalInsulance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ThermalInsulance other, ThermalInsulance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ThermalInsulance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ThermalInsulance,ThermalInsulance)"/>.
+        ///     See that operator (and <see cref="Equals(ThermalInsulance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ThermalInsulance left, ThermalInsulance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ThermalInsulance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ThermalInsulance other, ThermalInsulance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ThermalInsulance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ThermalInsulance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ThermalInsulance"/>, this method delegates to
+        ///     <see cref="Equals(ThermalInsulance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ThermalInsulance otherQuantity))
+            if (obj is not ThermalInsulance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ThermalInsulance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ThermalInsulance other, ThermalInsulance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ThermalInsulance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ThermalInsulance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ThermalInsulance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ThermalInsulance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ThermalInsulance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ThermalInsulance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ThermalInsulance otherQuantity)) throw new ArgumentException("Expected type ThermalInsulance.", nameof(obj));
+            if (obj is not ThermalInsulance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ThermalInsulance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ThermalInsulance"/> with another <see cref="ThermalInsulance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ThermalInsulance"/> with another <see cref="ThermalInsulance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -685,141 +685,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ThermalInsulance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ThermalInsulanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ThermalInsulanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ThermalInsulance to another ThermalInsulance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ThermalInsulance with the specified unit.</returns>
-        public ThermalInsulance ToUnit(ThermalInsulanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ThermalInsulance"/> to another <see cref="ThermalInsulance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ThermalInsulance with the specified unit.</returns>
-        public ThermalInsulance ToUnit(ThermalInsulanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ThermalInsulance), Unit, typeof(ThermalInsulance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ThermalInsulance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ThermalInsulance"/> to another <see cref="ThermalInsulance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ThermalInsulance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ThermalInsulanceUnit unit, [NotNullWhen(true)] out ThermalInsulance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ThermalInsulance? convertedOrNull = (Unit, unit) switch
-            {
-                // ThermalInsulanceUnit -> BaseUnit
-                (ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt) => new ThermalInsulance(_value * (1000 * 0.3048 * 0.3048 * 3600) / (1055.05585262 * 1.8), ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt),
-                (ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt) => new ThermalInsulance(_value * (0.0001 * 3600) / 4.184, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt),
-                (ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt) => new ThermalInsulance(_value * 0.1, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt),
-                (ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt) => new ThermalInsulance(_value * 1000.0, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt),
-                (ThermalInsulanceUnit.SquareMeterKelvinPerWatt, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt) => new ThermalInsulance(_value * 1000, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt),
-                (ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt) => new ThermalInsulance(_value * 0.001, ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt),
-
-                // BaseUnit -> ThermalInsulanceUnit
-                (ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu) => new ThermalInsulance(_value * (1055.05585262 * 1.8) / (1000 * 0.3048 * 0.3048 * 3600), ThermalInsulanceUnit.HourSquareFeetDegreeFahrenheitPerBtu),
-                (ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie) => new ThermalInsulance(_value * 4.184 / (0.0001 * 3600), ThermalInsulanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie),
-                (ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt) => new ThermalInsulance(_value / 0.1, ThermalInsulanceUnit.SquareCentimeterKelvinPerWatt),
-                (ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt) => new ThermalInsulance(_value / 1000.0, ThermalInsulanceUnit.SquareMeterDegreeCelsiusPerWatt),
-                (ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareMeterKelvinPerWatt) => new ThermalInsulance(_value / 1000, ThermalInsulanceUnit.SquareMeterKelvinPerWatt),
-                (ThermalInsulanceUnit.SquareMeterKelvinPerKilowatt, ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt) => new ThermalInsulance(_value / 0.001, ThermalInsulanceUnit.SquareMillimeterKelvinPerWatt),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ThermalInsulanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalInsulanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ThermalInsulanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalInsulanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity<ThermalInsulanceUnit> IQuantity<ThermalInsulanceUnit>.ToUnit(ThermalInsulanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -833,11 +701,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
index 11693deb43..eebfec6887 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     Thermal resistance (R) measures the opposition to the heat current in a material or system. It is measured in units of kelvins per watt (K/W) and indicates how much temperature difference (in kelvins) is required to transfer a unit of heat current (in watts) through the material or object. It is essential to optimize the building insulation, evaluate the efficiency of electronic devices, and enhance the performance of heat sinks in various applications.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct ThermalResistance :
-        IArithmeticQuantity<ThermalResistance, ThermalResistanceUnit>,
+        ILinearQuantity<ThermalResistance, ThermalResistanceUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<ThermalResistance, ThermalResistance, double>,
+        IDivisionOperators<ThermalResistance, ThermalResistance, QuantityValue>,
+        IMultiplyOperators<ThermalResistance, Power, TemperatureDelta>,
         IComparisonOperators<ThermalResistance, ThermalResistance, bool>,
         IParsable<ThermalResistance>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static ThermalResistanceInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="ThermalResistance"/> is [T^3][L^-2][M^-1][Θ].
+            ///     The <see cref="BaseDimensions" /> for <see cref="ThermalResistance"/> is T^3L^-2M^-1Θ.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, -1, 3, 0, 1, 0, 0);
 
@@ -117,16 +117,16 @@ public static ThermalResistanceInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{ThermalResistanceUnit}"/> representing the default unit mappings for ThermalResistance.</returns>
             public static IEnumerable<UnitDefinition<ThermalResistanceUnit>> GetDefaultMappings()
             {
-                yield return new (ThermalResistanceUnit.DegreeCelsiusPerWatt, "DegreeCelsiusPerWatt", "DegreesCelsiusPerWatt", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius));
+                yield return new (ThermalResistanceUnit.DegreeCelsiusPerWatt, "DegreeCelsiusPerWatt", "DegreesCelsiusPerWatt", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius),
+                     1
+                );
                 yield return new (ThermalResistanceUnit.KelvinPerWatt, "KelvinPerWatt", "KelvinsPerWatt", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
             }
         }
 
         static ThermalResistance()
         {
-            Info = ThermalResistanceInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(ThermalResistanceInfo.CreateDefault);
         }
 
         /// <summary>
@@ -134,7 +134,7 @@ static ThermalResistance()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public ThermalResistance(double value, ThermalResistanceUnit unit)
+        public ThermalResistance(QuantityValue value, ThermalResistanceUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -148,7 +148,7 @@ public ThermalResistance(double value, ThermalResistanceUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public ThermalResistance(double value, UnitSystem unitSystem)
+        public ThermalResistance(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -159,7 +159,8 @@ public ThermalResistance(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="ThermalResistance" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<ThermalResistance, ThermalResistanceUnit> Info { get; }
@@ -188,10 +189,8 @@ public ThermalResistance(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public ThermalResistanceUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -225,35 +224,19 @@ public ThermalResistance(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalResistanceUnit.DegreeCelsiusPerWatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalResistanceUnit.DegreeCelsiusPerWatt"/>
         /// </summary>
-        public double DegreesCelsiusPerWatt => As(ThermalResistanceUnit.DegreeCelsiusPerWatt);
+        public QuantityValue DegreesCelsiusPerWatt => this.As(ThermalResistanceUnit.DegreeCelsiusPerWatt);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="ThermalResistanceUnit.KelvinPerWatt"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="ThermalResistanceUnit.KelvinPerWatt"/>
         /// </summary>
-        public double KelvinsPerWatt => As(ThermalResistanceUnit.KelvinPerWatt);
+        public QuantityValue KelvinsPerWatt => this.As(ThermalResistanceUnit.KelvinPerWatt);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: ThermalResistanceUnit -> BaseUnit
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistanceUnit.DegreeCelsiusPerWatt, ThermalResistanceUnit.KelvinPerWatt, quantity => quantity.ToUnit(ThermalResistanceUnit.KelvinPerWatt));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistanceUnit.KelvinPerWatt, ThermalResistanceUnit.KelvinPerWatt, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> ThermalResistanceUnit
-            unitConverter.SetConversionFunction<ThermalResistance>(ThermalResistanceUnit.KelvinPerWatt, ThermalResistanceUnit.DegreeCelsiusPerWatt, quantity => quantity.ToUnit(ThermalResistanceUnit.DegreeCelsiusPerWatt));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -282,7 +265,7 @@ public static string GetAbbreviation(ThermalResistanceUnit unit, IFormatProvider
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.DegreeCelsiusPerWatt"/>.
         /// </summary>
-        public static ThermalResistance FromDegreesCelsiusPerWatt(double value)
+        public static ThermalResistance FromDegreesCelsiusPerWatt(QuantityValue value)
         {
             return new ThermalResistance(value, ThermalResistanceUnit.DegreeCelsiusPerWatt);
         }
@@ -290,7 +273,7 @@ public static ThermalResistance FromDegreesCelsiusPerWatt(double value)
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.KelvinPerWatt"/>.
         /// </summary>
-        public static ThermalResistance FromKelvinsPerWatt(double value)
+        public static ThermalResistance FromKelvinsPerWatt(QuantityValue value)
         {
             return new ThermalResistance(value, ThermalResistanceUnit.KelvinPerWatt);
         }
@@ -301,7 +284,7 @@ public static ThermalResistance FromKelvinsPerWatt(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ThermalResistance unit value.</returns>
-        public static ThermalResistance From(double value, ThermalResistanceUnit fromUnit)
+        public static ThermalResistance From(QuantityValue value, ThermalResistanceUnit fromUnit)
         {
             return new ThermalResistance(value, fromUnit);
         }
@@ -362,10 +345,7 @@ public static ThermalResistance Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static ThermalResistance Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<ThermalResistance, ThermalResistanceUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<ThermalResistance, ThermalResistanceUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -393,11 +373,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out ThermalResistanc
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out ThermalResistance result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<ThermalResistance, ThermalResistanceUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<ThermalResistance, ThermalResistanceUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -418,7 +394,7 @@ public static ThermalResistanceUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -429,7 +405,7 @@ public static ThermalResistanceUnit ParseUnit(string str, IFormatProvider? provi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.ThermalResistanceUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.ThermalResistanceUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out ThermalResistanceUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -444,7 +420,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out ThermalResis
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out ThermalResistanceUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -463,137 +439,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="ThermalResistance"/> from adding two <see cref="ThermalResistance"/>.</summary>
         public static ThermalResistance operator +(ThermalResistance left, ThermalResistance right)
         {
-            return new ThermalResistance(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new ThermalResistance(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ThermalResistance"/> from subtracting two <see cref="ThermalResistance"/>.</summary>
         public static ThermalResistance operator -(ThermalResistance left, ThermalResistance right)
         {
-            return new ThermalResistance(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new ThermalResistance(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="ThermalResistance"/> from multiplying value and <see cref="ThermalResistance"/>.</summary>
-        public static ThermalResistance operator *(double left, ThermalResistance right)
+        public static ThermalResistance operator *(QuantityValue left, ThermalResistance right)
         {
             return new ThermalResistance(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="ThermalResistance"/> from multiplying value and <see cref="ThermalResistance"/>.</summary>
-        public static ThermalResistance operator *(ThermalResistance left, double right)
+        public static ThermalResistance operator *(ThermalResistance left, QuantityValue right)
         {
             return new ThermalResistance(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="ThermalResistance"/> from dividing <see cref="ThermalResistance"/> by value.</summary>
-        public static ThermalResistance operator /(ThermalResistance left, double right)
+        public static ThermalResistance operator /(ThermalResistance left, QuantityValue right)
         {
             return new ThermalResistance(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="ThermalResistance"/> by <see cref="ThermalResistance"/>.</summary>
-        public static double operator /(ThermalResistance left, ThermalResistance right)
+        public static QuantityValue operator /(ThermalResistance left, ThermalResistance right)
         {
             return left.KelvinsPerWatt / right.KelvinsPerWatt;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="TemperatureDelta"/> from <see cref="ThermalResistance"/> * <see cref="Power"/>.</summary>
+        public static TemperatureDelta operator *(ThermalResistance thermalResistance, Power power)
+        {
+            return TemperatureDelta.FromKelvins(thermalResistance.KelvinsPerWatt * power.Watts);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(ThermalResistance left, ThermalResistance right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(ThermalResistance left, ThermalResistance right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(ThermalResistance left, ThermalResistance right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(ThermalResistance left, ThermalResistance right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="ThermalResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ThermalResistance other, ThermalResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ThermalResistance"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(ThermalResistance)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(ThermalResistance left, ThermalResistance right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="ThermalResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(ThermalResistance other, ThermalResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="ThermalResistance"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(ThermalResistance,ThermalResistance)"/>.
+        ///     See that operator (and <see cref="Equals(ThermalResistance)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(ThermalResistance left, ThermalResistance right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ThermalResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ThermalResistance other, ThermalResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="ThermalResistance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="ThermalResistance"/>.
+        ///     When <paramref name="obj"/> is a <see cref="ThermalResistance"/>, this method delegates to
+        ///     <see cref="Equals(ThermalResistance)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is ThermalResistance otherQuantity))
+            if (obj is not ThermalResistance otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="ThermalResistance"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(ThermalResistance other, ThermalResistance tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="ThermalResistance"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(ThermalResistance other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current ThermalResistance.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(ThermalResistance), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="ThermalResistance"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(ThermalResistance)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is ThermalResistance otherQuantity)) throw new ArgumentException("Expected type ThermalResistance.", nameof(obj));
+            if (obj is not ThermalResistance otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<ThermalResistance>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="ThermalResistance"/> with another <see cref="ThermalResistance"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="ThermalResistance"/> with another <see cref="ThermalResistance"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -605,133 +605,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(ThermalResistance other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(ThermalResistanceUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<ThermalResistanceUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this ThermalResistance to another ThermalResistance with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A ThermalResistance with the specified unit.</returns>
-        public ThermalResistance ToUnit(ThermalResistanceUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="ThermalResistance"/> to another <see cref="ThermalResistance"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A ThermalResistance with the specified unit.</returns>
-        public ThermalResistance ToUnit(ThermalResistanceUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(ThermalResistance), Unit, typeof(ThermalResistance), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (ThermalResistance)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="ThermalResistance"/> to another <see cref="ThermalResistance"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="ThermalResistance"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(ThermalResistanceUnit unit, [NotNullWhen(true)] out ThermalResistance? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            ThermalResistance? convertedOrNull = (Unit, unit) switch
-            {
-                // ThermalResistanceUnit -> BaseUnit
-                (ThermalResistanceUnit.DegreeCelsiusPerWatt, ThermalResistanceUnit.KelvinPerWatt) => new ThermalResistance(_value, ThermalResistanceUnit.KelvinPerWatt),
-
-                // BaseUnit -> ThermalResistanceUnit
-                (ThermalResistanceUnit.KelvinPerWatt, ThermalResistanceUnit.DegreeCelsiusPerWatt) => new ThermalResistance(_value, ThermalResistanceUnit.DegreeCelsiusPerWatt),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not ThermalResistanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalResistanceUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is ThermalResistanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalResistanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<ThermalResistanceUnit> IQuantity<ThermalResistanceUnit>.ToUnit(ThermalResistanceUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -743,11 +621,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
index 8a260baeef..6bcd17d8d5 100644
--- a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Torque, moment or moment of force (see the terminology below), is the tendency of a force to rotate an object about an axis,[1] fulcrum, or pivot. Just as a force is a push or a pull, a torque can be thought of as a twist to an object. Mathematically, torque is defined as the cross product of the lever-arm distance and force, which tends to produce rotation. Loosely speaking, torque is a measure of the turning force on an object such as a bolt or a flywheel. For example, pushing or pulling the handle of a wrench connected to a nut or bolt produces a torque (turning force) that loosens or tightens the nut or bolt.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Torque :
-        IArithmeticQuantity<Torque, TorqueUnit>,
+        ILinearQuantity<Torque, TorqueUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Torque, Torque, double>,
+        IDivisionOperators<Torque, Torque, QuantityValue>,
         IDivisionOperators<Torque, RotationalStiffness, Angle>,
         IDivisionOperators<Torque, ForcePerLength, Area>,
         IDivisionOperators<Torque, Length, Force>,
@@ -59,7 +58,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -109,7 +108,7 @@ public static TorqueInfo CreateDefault(Func<IEnumerable<UnitDefinition<TorqueUni
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Torque"/> is [T^-2][L^2][M].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Torque"/> is T^-2L^2M.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
 
@@ -124,39 +123,91 @@ public static TorqueInfo CreateDefault(Func<IEnumerable<UnitDefinition<TorqueUni
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{TorqueUnit}"/> representing the default unit mappings for Torque.</returns>
             public static IEnumerable<UnitDefinition<TorqueUnit>> GetDefaultMappings()
             {
-                yield return new (TorqueUnit.GramForceCentimeter, "GramForceCentimeter", "GramForceCentimeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.GramForceMeter, "GramForceMeter", "GramForceMeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.GramForceMillimeter, "GramForceMillimeter", "GramForceMillimeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.KilogramForceCentimeter, "KilogramForceCentimeter", "KilogramForceCentimeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.KilogramForceMeter, "KilogramForceMeter", "KilogramForceMeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.KilogramForceMillimeter, "KilogramForceMillimeter", "KilogramForceMillimeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.KilonewtonCentimeter, "KilonewtonCentimeter", "KilonewtonCentimeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.KilonewtonMeter, "KilonewtonMeter", "KilonewtonMeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.KilonewtonMillimeter, "KilonewtonMillimeter", "KilonewtonMillimeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.KilopoundForceFoot, "KilopoundForceFoot", "KilopoundForceFeet", BaseUnits.Undefined);
-                yield return new (TorqueUnit.KilopoundForceInch, "KilopoundForceInch", "KilopoundForceInches", BaseUnits.Undefined);
-                yield return new (TorqueUnit.MeganewtonCentimeter, "MeganewtonCentimeter", "MeganewtonCentimeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.MeganewtonMeter, "MeganewtonMeter", "MeganewtonMeters", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (TorqueUnit.MeganewtonMillimeter, "MeganewtonMillimeter", "MeganewtonMillimeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.MegapoundForceFoot, "MegapoundForceFoot", "MegapoundForceFeet", BaseUnits.Undefined);
-                yield return new (TorqueUnit.MegapoundForceInch, "MegapoundForceInch", "MegapoundForceInches", BaseUnits.Undefined);
-                yield return new (TorqueUnit.NewtonCentimeter, "NewtonCentimeter", "NewtonCentimeters", BaseUnits.Undefined);
+                yield return new (TorqueUnit.GramForceCentimeter, "GramForceCentimeter", "GramForceCentimeters", BaseUnits.Undefined,
+                     new QuantityValue(2000000000, 196133)
+                );
+                yield return new (TorqueUnit.GramForceMeter, "GramForceMeter", "GramForceMeters", BaseUnits.Undefined,
+                     new QuantityValue(20000000, 196133)
+                );
+                yield return new (TorqueUnit.GramForceMillimeter, "GramForceMillimeter", "GramForceMillimeters", BaseUnits.Undefined,
+                     new QuantityValue(20000000000, 196133)
+                );
+                yield return new (TorqueUnit.KilogramForceCentimeter, "KilogramForceCentimeter", "KilogramForceCentimeters", BaseUnits.Undefined,
+                     new QuantityValue(2000000, 196133)
+                );
+                yield return new (TorqueUnit.KilogramForceMeter, "KilogramForceMeter", "KilogramForceMeters", BaseUnits.Undefined,
+                     new QuantityValue(20000, 196133)
+                );
+                yield return new (TorqueUnit.KilogramForceMillimeter, "KilogramForceMillimeter", "KilogramForceMillimeters", BaseUnits.Undefined,
+                     new QuantityValue(20000000, 196133)
+                );
+                yield return new (TorqueUnit.KilonewtonCentimeter, "KilonewtonCentimeter", "KilonewtonCentimeters", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (TorqueUnit.KilonewtonMeter, "KilonewtonMeter", "KilonewtonMeters", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (TorqueUnit.KilonewtonMillimeter, "KilonewtonMillimeter", "KilonewtonMillimeters", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (TorqueUnit.KilopoundForceFoot, "KilopoundForceFoot", "KilopoundForceFeet", BaseUnits.Undefined,
+                     new QuantityValue(2500000000000, 3389544870828501)
+                );
+                yield return new (TorqueUnit.KilopoundForceInch, "KilopoundForceInch", "KilopoundForceInches", BaseUnits.Undefined,
+                     new QuantityValue(10000000000000, 1129848290276167)
+                );
+                yield return new (TorqueUnit.MeganewtonCentimeter, "MeganewtonCentimeter", "MeganewtonCentimeters", BaseUnits.Undefined,
+                     new QuantityValue(1, 10000)
+                );
+                yield return new (TorqueUnit.MeganewtonMeter, "MeganewtonMeter", "MeganewtonMeters", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (TorqueUnit.MeganewtonMillimeter, "MeganewtonMillimeter", "MeganewtonMillimeters", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (TorqueUnit.MegapoundForceFoot, "MegapoundForceFoot", "MegapoundForceFeet", BaseUnits.Undefined,
+                     new QuantityValue(2500000000, 3389544870828501)
+                );
+                yield return new (TorqueUnit.MegapoundForceInch, "MegapoundForceInch", "MegapoundForceInches", BaseUnits.Undefined,
+                     new QuantityValue(10000000000, 1129848290276167)
+                );
+                yield return new (TorqueUnit.NewtonCentimeter, "NewtonCentimeter", "NewtonCentimeters", BaseUnits.Undefined,
+                     100
+                );
                 yield return new (TorqueUnit.NewtonMeter, "NewtonMeter", "NewtonMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
-                yield return new (TorqueUnit.NewtonMillimeter, "NewtonMillimeter", "NewtonMillimeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.PoundalFoot, "PoundalFoot", "PoundalFeet", BaseUnits.Undefined);
-                yield return new (TorqueUnit.PoundForceFoot, "PoundForceFoot", "PoundForceFeet", BaseUnits.Undefined);
-                yield return new (TorqueUnit.PoundForceInch, "PoundForceInch", "PoundForceInches", BaseUnits.Undefined);
-                yield return new (TorqueUnit.TonneForceCentimeter, "TonneForceCentimeter", "TonneForceCentimeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.TonneForceMeter, "TonneForceMeter", "TonneForceMeters", BaseUnits.Undefined);
-                yield return new (TorqueUnit.TonneForceMillimeter, "TonneForceMillimeter", "TonneForceMillimeters", BaseUnits.Undefined);
+                yield return new (TorqueUnit.NewtonMillimeter, "NewtonMillimeter", "NewtonMillimeters", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (TorqueUnit.OunceForceFoot, "OunceForceFoot", "OunceForceFeet", BaseUnits.Undefined,
+                     new QuantityValue(40000000000000000, 3389544870828501)
+                );
+                yield return new (TorqueUnit.OunceForceInch, "OunceForceInch", "OunceForceInches", BaseUnits.Undefined,
+                     new QuantityValue(160000000000000000, 1129848290276167)
+                );
+                yield return new (TorqueUnit.PoundalFoot, "PoundalFoot", "PoundalFeet", BaseUnits.Undefined,
+                     new QuantityValue(156250000000000, 6584392202157)
+                );
+                yield return new (TorqueUnit.PoundForceFoot, "PoundForceFoot", "PoundForceFeet", BaseUnits.Undefined,
+                     new QuantityValue(2500000000000000, 3389544870828501)
+                );
+                yield return new (TorqueUnit.PoundForceInch, "PoundForceInch", "PoundForceInches", BaseUnits.Undefined,
+                     new QuantityValue(10000000000000000, 1129848290276167)
+                );
+                yield return new (TorqueUnit.TonneForceCentimeter, "TonneForceCentimeter", "TonneForceCentimeters", BaseUnits.Undefined,
+                     new QuantityValue(2000, 196133)
+                );
+                yield return new (TorqueUnit.TonneForceMeter, "TonneForceMeter", "TonneForceMeters", BaseUnits.Undefined,
+                     new QuantityValue(20, 196133)
+                );
+                yield return new (TorqueUnit.TonneForceMillimeter, "TonneForceMillimeter", "TonneForceMillimeters", BaseUnits.Undefined,
+                     new QuantityValue(20000, 196133)
+                );
             }
         }
 
         static Torque()
         {
-            Info = TorqueInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(TorqueInfo.CreateDefault);
         }
 
         /// <summary>
@@ -164,7 +215,7 @@ static Torque()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Torque(double value, TorqueUnit unit)
+        public Torque(QuantityValue value, TorqueUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -178,7 +229,7 @@ public Torque(double value, TorqueUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Torque(double value, UnitSystem unitSystem)
+        public Torque(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -189,7 +240,8 @@ public Torque(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Torque" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Torque, TorqueUnit> Info { get; }
@@ -218,10 +270,8 @@ public Torque(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public TorqueUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -255,196 +305,144 @@ public Torque(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.GramForceCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.GramForceCentimeter"/>
         /// </summary>
-        public double GramForceCentimeters => As(TorqueUnit.GramForceCentimeter);
+        public QuantityValue GramForceCentimeters => this.As(TorqueUnit.GramForceCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.GramForceMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.GramForceMeter"/>
         /// </summary>
-        public double GramForceMeters => As(TorqueUnit.GramForceMeter);
+        public QuantityValue GramForceMeters => this.As(TorqueUnit.GramForceMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.GramForceMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.GramForceMillimeter"/>
         /// </summary>
-        public double GramForceMillimeters => As(TorqueUnit.GramForceMillimeter);
+        public QuantityValue GramForceMillimeters => this.As(TorqueUnit.GramForceMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilogramForceCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.KilogramForceCentimeter"/>
         /// </summary>
-        public double KilogramForceCentimeters => As(TorqueUnit.KilogramForceCentimeter);
+        public QuantityValue KilogramForceCentimeters => this.As(TorqueUnit.KilogramForceCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilogramForceMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.KilogramForceMeter"/>
         /// </summary>
-        public double KilogramForceMeters => As(TorqueUnit.KilogramForceMeter);
+        public QuantityValue KilogramForceMeters => this.As(TorqueUnit.KilogramForceMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilogramForceMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.KilogramForceMillimeter"/>
         /// </summary>
-        public double KilogramForceMillimeters => As(TorqueUnit.KilogramForceMillimeter);
+        public QuantityValue KilogramForceMillimeters => this.As(TorqueUnit.KilogramForceMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilonewtonCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.KilonewtonCentimeter"/>
         /// </summary>
-        public double KilonewtonCentimeters => As(TorqueUnit.KilonewtonCentimeter);
+        public QuantityValue KilonewtonCentimeters => this.As(TorqueUnit.KilonewtonCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilonewtonMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.KilonewtonMeter"/>
         /// </summary>
-        public double KilonewtonMeters => As(TorqueUnit.KilonewtonMeter);
+        public QuantityValue KilonewtonMeters => this.As(TorqueUnit.KilonewtonMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilonewtonMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.KilonewtonMillimeter"/>
         /// </summary>
-        public double KilonewtonMillimeters => As(TorqueUnit.KilonewtonMillimeter);
+        public QuantityValue KilonewtonMillimeters => this.As(TorqueUnit.KilonewtonMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilopoundForceFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.KilopoundForceFoot"/>
         /// </summary>
-        public double KilopoundForceFeet => As(TorqueUnit.KilopoundForceFoot);
+        public QuantityValue KilopoundForceFeet => this.As(TorqueUnit.KilopoundForceFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.KilopoundForceInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.KilopoundForceInch"/>
         /// </summary>
-        public double KilopoundForceInches => As(TorqueUnit.KilopoundForceInch);
+        public QuantityValue KilopoundForceInches => this.As(TorqueUnit.KilopoundForceInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.MeganewtonCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.MeganewtonCentimeter"/>
         /// </summary>
-        public double MeganewtonCentimeters => As(TorqueUnit.MeganewtonCentimeter);
+        public QuantityValue MeganewtonCentimeters => this.As(TorqueUnit.MeganewtonCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.MeganewtonMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.MeganewtonMeter"/>
         /// </summary>
-        public double MeganewtonMeters => As(TorqueUnit.MeganewtonMeter);
+        public QuantityValue MeganewtonMeters => this.As(TorqueUnit.MeganewtonMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.MeganewtonMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.MeganewtonMillimeter"/>
         /// </summary>
-        public double MeganewtonMillimeters => As(TorqueUnit.MeganewtonMillimeter);
+        public QuantityValue MeganewtonMillimeters => this.As(TorqueUnit.MeganewtonMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.MegapoundForceFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.MegapoundForceFoot"/>
         /// </summary>
-        public double MegapoundForceFeet => As(TorqueUnit.MegapoundForceFoot);
+        public QuantityValue MegapoundForceFeet => this.As(TorqueUnit.MegapoundForceFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.MegapoundForceInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.MegapoundForceInch"/>
         /// </summary>
-        public double MegapoundForceInches => As(TorqueUnit.MegapoundForceInch);
+        public QuantityValue MegapoundForceInches => this.As(TorqueUnit.MegapoundForceInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.NewtonCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.NewtonCentimeter"/>
         /// </summary>
-        public double NewtonCentimeters => As(TorqueUnit.NewtonCentimeter);
+        public QuantityValue NewtonCentimeters => this.As(TorqueUnit.NewtonCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.NewtonMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.NewtonMeter"/>
         /// </summary>
-        public double NewtonMeters => As(TorqueUnit.NewtonMeter);
+        public QuantityValue NewtonMeters => this.As(TorqueUnit.NewtonMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.NewtonMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.NewtonMillimeter"/>
         /// </summary>
-        public double NewtonMillimeters => As(TorqueUnit.NewtonMillimeter);
+        public QuantityValue NewtonMillimeters => this.As(TorqueUnit.NewtonMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.PoundalFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.OunceForceFoot"/>
         /// </summary>
-        public double PoundalFeet => As(TorqueUnit.PoundalFoot);
+        public QuantityValue OunceForceFeet => this.As(TorqueUnit.OunceForceFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.PoundForceFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.OunceForceInch"/>
         /// </summary>
-        public double PoundForceFeet => As(TorqueUnit.PoundForceFoot);
+        public QuantityValue OunceForceInches => this.As(TorqueUnit.OunceForceInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.PoundForceInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.PoundalFoot"/>
         /// </summary>
-        public double PoundForceInches => As(TorqueUnit.PoundForceInch);
+        public QuantityValue PoundalFeet => this.As(TorqueUnit.PoundalFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.TonneForceCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.PoundForceFoot"/>
         /// </summary>
-        public double TonneForceCentimeters => As(TorqueUnit.TonneForceCentimeter);
+        public QuantityValue PoundForceFeet => this.As(TorqueUnit.PoundForceFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.TonneForceMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.PoundForceInch"/>
         /// </summary>
-        public double TonneForceMeters => As(TorqueUnit.TonneForceMeter);
+        public QuantityValue PoundForceInches => this.As(TorqueUnit.PoundForceInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TorqueUnit.TonneForceMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.TonneForceCentimeter"/>
         /// </summary>
-        public double TonneForceMillimeters => As(TorqueUnit.TonneForceMillimeter);
+        public QuantityValue TonneForceCentimeters => this.As(TorqueUnit.TonneForceCentimeter);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.TonneForceMeter"/>
+        /// </summary>
+        public QuantityValue TonneForceMeters => this.As(TorqueUnit.TonneForceMeter);
+
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TorqueUnit.TonneForceMillimeter"/>
+        /// </summary>
+        public QuantityValue TonneForceMillimeters => this.As(TorqueUnit.TonneForceMillimeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: TorqueUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.GramForceCentimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.GramForceMeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.GramForceMillimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilogramForceCentimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilogramForceMeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilogramForceMillimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilonewtonCentimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilonewtonMeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilonewtonMillimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilopoundForceFoot, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.KilopoundForceInch, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.MeganewtonCentimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.MeganewtonMeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.MeganewtonMillimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.MegapoundForceFoot, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.MegapoundForceInch, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonCentimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMillimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.PoundalFoot, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.PoundForceFoot, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.PoundForceInch, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.TonneForceCentimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.TonneForceMeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.TonneForceMillimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.NewtonMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> TorqueUnit
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.GramForceCentimeter, quantity => quantity.ToUnit(TorqueUnit.GramForceCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.GramForceMeter, quantity => quantity.ToUnit(TorqueUnit.GramForceMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.GramForceMillimeter, quantity => quantity.ToUnit(TorqueUnit.GramForceMillimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.KilogramForceCentimeter, quantity => quantity.ToUnit(TorqueUnit.KilogramForceCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.KilogramForceMeter, quantity => quantity.ToUnit(TorqueUnit.KilogramForceMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.KilogramForceMillimeter, quantity => quantity.ToUnit(TorqueUnit.KilogramForceMillimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.KilonewtonCentimeter, quantity => quantity.ToUnit(TorqueUnit.KilonewtonCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.KilonewtonMeter, quantity => quantity.ToUnit(TorqueUnit.KilonewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.KilonewtonMillimeter, quantity => quantity.ToUnit(TorqueUnit.KilonewtonMillimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.KilopoundForceFoot, quantity => quantity.ToUnit(TorqueUnit.KilopoundForceFoot));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.KilopoundForceInch, quantity => quantity.ToUnit(TorqueUnit.KilopoundForceInch));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.MeganewtonCentimeter, quantity => quantity.ToUnit(TorqueUnit.MeganewtonCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.MeganewtonMeter, quantity => quantity.ToUnit(TorqueUnit.MeganewtonMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.MeganewtonMillimeter, quantity => quantity.ToUnit(TorqueUnit.MeganewtonMillimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.MegapoundForceFoot, quantity => quantity.ToUnit(TorqueUnit.MegapoundForceFoot));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.MegapoundForceInch, quantity => quantity.ToUnit(TorqueUnit.MegapoundForceInch));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.NewtonCentimeter, quantity => quantity.ToUnit(TorqueUnit.NewtonCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.NewtonMillimeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMillimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.PoundalFoot, quantity => quantity.ToUnit(TorqueUnit.PoundalFoot));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.PoundForceFoot, quantity => quantity.ToUnit(TorqueUnit.PoundForceFoot));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.PoundForceInch, quantity => quantity.ToUnit(TorqueUnit.PoundForceInch));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.TonneForceCentimeter, quantity => quantity.ToUnit(TorqueUnit.TonneForceCentimeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.TonneForceMeter, quantity => quantity.ToUnit(TorqueUnit.TonneForceMeter));
-            unitConverter.SetConversionFunction<Torque>(TorqueUnit.NewtonMeter, TorqueUnit.TonneForceMillimeter, quantity => quantity.ToUnit(TorqueUnit.TonneForceMillimeter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -473,7 +471,7 @@ public static string GetAbbreviation(TorqueUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceCentimeter"/>.
         /// </summary>
-        public static Torque FromGramForceCentimeters(double value)
+        public static Torque FromGramForceCentimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.GramForceCentimeter);
         }
@@ -481,7 +479,7 @@ public static Torque FromGramForceCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceMeter"/>.
         /// </summary>
-        public static Torque FromGramForceMeters(double value)
+        public static Torque FromGramForceMeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.GramForceMeter);
         }
@@ -489,7 +487,7 @@ public static Torque FromGramForceMeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceMillimeter"/>.
         /// </summary>
-        public static Torque FromGramForceMillimeters(double value)
+        public static Torque FromGramForceMillimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.GramForceMillimeter);
         }
@@ -497,7 +495,7 @@ public static Torque FromGramForceMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceCentimeter"/>.
         /// </summary>
-        public static Torque FromKilogramForceCentimeters(double value)
+        public static Torque FromKilogramForceCentimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.KilogramForceCentimeter);
         }
@@ -505,7 +503,7 @@ public static Torque FromKilogramForceCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceMeter"/>.
         /// </summary>
-        public static Torque FromKilogramForceMeters(double value)
+        public static Torque FromKilogramForceMeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.KilogramForceMeter);
         }
@@ -513,7 +511,7 @@ public static Torque FromKilogramForceMeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceMillimeter"/>.
         /// </summary>
-        public static Torque FromKilogramForceMillimeters(double value)
+        public static Torque FromKilogramForceMillimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.KilogramForceMillimeter);
         }
@@ -521,7 +519,7 @@ public static Torque FromKilogramForceMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonCentimeter"/>.
         /// </summary>
-        public static Torque FromKilonewtonCentimeters(double value)
+        public static Torque FromKilonewtonCentimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.KilonewtonCentimeter);
         }
@@ -529,7 +527,7 @@ public static Torque FromKilonewtonCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonMeter"/>.
         /// </summary>
-        public static Torque FromKilonewtonMeters(double value)
+        public static Torque FromKilonewtonMeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.KilonewtonMeter);
         }
@@ -537,7 +535,7 @@ public static Torque FromKilonewtonMeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonMillimeter"/>.
         /// </summary>
-        public static Torque FromKilonewtonMillimeters(double value)
+        public static Torque FromKilonewtonMillimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.KilonewtonMillimeter);
         }
@@ -545,7 +543,7 @@ public static Torque FromKilonewtonMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilopoundForceFoot"/>.
         /// </summary>
-        public static Torque FromKilopoundForceFeet(double value)
+        public static Torque FromKilopoundForceFeet(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.KilopoundForceFoot);
         }
@@ -553,7 +551,7 @@ public static Torque FromKilopoundForceFeet(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilopoundForceInch"/>.
         /// </summary>
-        public static Torque FromKilopoundForceInches(double value)
+        public static Torque FromKilopoundForceInches(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.KilopoundForceInch);
         }
@@ -561,7 +559,7 @@ public static Torque FromKilopoundForceInches(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonCentimeter"/>.
         /// </summary>
-        public static Torque FromMeganewtonCentimeters(double value)
+        public static Torque FromMeganewtonCentimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.MeganewtonCentimeter);
         }
@@ -569,7 +567,7 @@ public static Torque FromMeganewtonCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonMeter"/>.
         /// </summary>
-        public static Torque FromMeganewtonMeters(double value)
+        public static Torque FromMeganewtonMeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.MeganewtonMeter);
         }
@@ -577,7 +575,7 @@ public static Torque FromMeganewtonMeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonMillimeter"/>.
         /// </summary>
-        public static Torque FromMeganewtonMillimeters(double value)
+        public static Torque FromMeganewtonMillimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.MeganewtonMillimeter);
         }
@@ -585,7 +583,7 @@ public static Torque FromMeganewtonMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MegapoundForceFoot"/>.
         /// </summary>
-        public static Torque FromMegapoundForceFeet(double value)
+        public static Torque FromMegapoundForceFeet(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.MegapoundForceFoot);
         }
@@ -593,7 +591,7 @@ public static Torque FromMegapoundForceFeet(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MegapoundForceInch"/>.
         /// </summary>
-        public static Torque FromMegapoundForceInches(double value)
+        public static Torque FromMegapoundForceInches(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.MegapoundForceInch);
         }
@@ -601,7 +599,7 @@ public static Torque FromMegapoundForceInches(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonCentimeter"/>.
         /// </summary>
-        public static Torque FromNewtonCentimeters(double value)
+        public static Torque FromNewtonCentimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.NewtonCentimeter);
         }
@@ -609,7 +607,7 @@ public static Torque FromNewtonCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonMeter"/>.
         /// </summary>
-        public static Torque FromNewtonMeters(double value)
+        public static Torque FromNewtonMeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.NewtonMeter);
         }
@@ -617,15 +615,31 @@ public static Torque FromNewtonMeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonMillimeter"/>.
         /// </summary>
-        public static Torque FromNewtonMillimeters(double value)
+        public static Torque FromNewtonMillimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.NewtonMillimeter);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.OunceForceFoot"/>.
+        /// </summary>
+        public static Torque FromOunceForceFeet(QuantityValue value)
+        {
+            return new Torque(value, TorqueUnit.OunceForceFoot);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.OunceForceInch"/>.
+        /// </summary>
+        public static Torque FromOunceForceInches(QuantityValue value)
+        {
+            return new Torque(value, TorqueUnit.OunceForceInch);
+        }
+
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundalFoot"/>.
         /// </summary>
-        public static Torque FromPoundalFeet(double value)
+        public static Torque FromPoundalFeet(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.PoundalFoot);
         }
@@ -633,7 +647,7 @@ public static Torque FromPoundalFeet(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundForceFoot"/>.
         /// </summary>
-        public static Torque FromPoundForceFeet(double value)
+        public static Torque FromPoundForceFeet(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.PoundForceFoot);
         }
@@ -641,7 +655,7 @@ public static Torque FromPoundForceFeet(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundForceInch"/>.
         /// </summary>
-        public static Torque FromPoundForceInches(double value)
+        public static Torque FromPoundForceInches(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.PoundForceInch);
         }
@@ -649,7 +663,7 @@ public static Torque FromPoundForceInches(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceCentimeter"/>.
         /// </summary>
-        public static Torque FromTonneForceCentimeters(double value)
+        public static Torque FromTonneForceCentimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.TonneForceCentimeter);
         }
@@ -657,7 +671,7 @@ public static Torque FromTonneForceCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceMeter"/>.
         /// </summary>
-        public static Torque FromTonneForceMeters(double value)
+        public static Torque FromTonneForceMeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.TonneForceMeter);
         }
@@ -665,7 +679,7 @@ public static Torque FromTonneForceMeters(double value)
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceMillimeter"/>.
         /// </summary>
-        public static Torque FromTonneForceMillimeters(double value)
+        public static Torque FromTonneForceMillimeters(QuantityValue value)
         {
             return new Torque(value, TorqueUnit.TonneForceMillimeter);
         }
@@ -676,7 +690,7 @@ public static Torque FromTonneForceMillimeters(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Torque unit value.</returns>
-        public static Torque From(double value, TorqueUnit fromUnit)
+        public static Torque From(QuantityValue value, TorqueUnit fromUnit)
         {
             return new Torque(value, fromUnit);
         }
@@ -737,10 +751,7 @@ public static Torque Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Torque Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Torque, TorqueUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Torque, TorqueUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -768,11 +779,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Torque result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Torque result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Torque, TorqueUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Torque, TorqueUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -793,7 +800,7 @@ public static TorqueUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -804,7 +811,7 @@ public static TorqueUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TorqueUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.TorqueUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out TorqueUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -819,7 +826,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TorqueUnit u
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out TorqueUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -838,35 +845,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Torque"/> from adding two <see cref="Torque"/>.</summary>
         public static Torque operator +(Torque left, Torque right)
         {
-            return new Torque(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Torque(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Torque"/> from subtracting two <see cref="Torque"/>.</summary>
         public static Torque operator -(Torque left, Torque right)
         {
-            return new Torque(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Torque(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Torque"/> from multiplying value and <see cref="Torque"/>.</summary>
-        public static Torque operator *(double left, Torque right)
+        public static Torque operator *(QuantityValue left, Torque right)
         {
             return new Torque(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Torque"/> from multiplying value and <see cref="Torque"/>.</summary>
-        public static Torque operator *(Torque left, double right)
+        public static Torque operator *(Torque left, QuantityValue right)
         {
             return new Torque(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Torque"/> from dividing <see cref="Torque"/> by value.</summary>
-        public static Torque operator /(Torque left, double right)
+        public static Torque operator /(Torque left, QuantityValue right)
         {
             return new Torque(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Torque"/> by <see cref="Torque"/>.</summary>
-        public static double operator /(Torque left, Torque right)
+        public static QuantityValue operator /(Torque left, Torque right)
         {
             return left.NewtonMeters / right.NewtonMeters;
         }
@@ -924,97 +931,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Torque left, Torque right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Torque left, Torque right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Torque left, Torque right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Torque left, Torque right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Torque"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Torque other, Torque tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Torque"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Torque)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Torque left, Torque right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Torque"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Torque other, Torque tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Torque"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Torque,Torque)"/>.
+        ///     See that operator (and <see cref="Equals(Torque)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Torque left, Torque right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Torque"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Torque other, Torque tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Torque"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Torque"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Torque"/>, this method delegates to
+        ///     <see cref="Equals(Torque)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Torque otherQuantity))
+            if (obj is not Torque otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Torque"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Torque other, Torque tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Torque"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Torque other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Torque.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Torque), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Torque"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Torque)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Torque otherQuantity)) throw new ArgumentException("Expected type Torque.", nameof(obj));
+            if (obj is not Torque otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Torque>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Torque"/> with another <see cref="Torque"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Torque"/> with another <see cref="Torque"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1026,177 +1047,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Torque other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(TorqueUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<TorqueUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Torque to another Torque with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Torque with the specified unit.</returns>
-        public Torque ToUnit(TorqueUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Torque"/> to another <see cref="Torque"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Torque with the specified unit.</returns>
-        public Torque ToUnit(TorqueUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Torque), Unit, typeof(Torque), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Torque)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Attempts to convert this <see cref="Torque"/> to another <see cref="Torque"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Torque"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(TorqueUnit unit, [NotNullWhen(true)] out Torque? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Torque? convertedOrNull = (Unit, unit) switch
-            {
-                // TorqueUnit -> BaseUnit
-                (TorqueUnit.GramForceCentimeter, TorqueUnit.NewtonMeter) => new Torque(_value * 9.80665e-5, TorqueUnit.NewtonMeter),
-                (TorqueUnit.GramForceMeter, TorqueUnit.NewtonMeter) => new Torque(_value * 9.80665e-3, TorqueUnit.NewtonMeter),
-                (TorqueUnit.GramForceMillimeter, TorqueUnit.NewtonMeter) => new Torque(_value * 9.80665e-6, TorqueUnit.NewtonMeter),
-                (TorqueUnit.KilogramForceCentimeter, TorqueUnit.NewtonMeter) => new Torque(_value * 9.80665e-2, TorqueUnit.NewtonMeter),
-                (TorqueUnit.KilogramForceMeter, TorqueUnit.NewtonMeter) => new Torque(_value * 9.80665, TorqueUnit.NewtonMeter),
-                (TorqueUnit.KilogramForceMillimeter, TorqueUnit.NewtonMeter) => new Torque(_value * 9.80665e-3, TorqueUnit.NewtonMeter),
-                (TorqueUnit.KilonewtonCentimeter, TorqueUnit.NewtonMeter) => new Torque((_value * 0.01) * 1e3d, TorqueUnit.NewtonMeter),
-                (TorqueUnit.KilonewtonMeter, TorqueUnit.NewtonMeter) => new Torque((_value) * 1e3d, TorqueUnit.NewtonMeter),
-                (TorqueUnit.KilonewtonMillimeter, TorqueUnit.NewtonMeter) => new Torque((_value * 0.001) * 1e3d, TorqueUnit.NewtonMeter),
-                (TorqueUnit.KilopoundForceFoot, TorqueUnit.NewtonMeter) => new Torque((_value * 4.4482216152605 * 0.3048) * 1e3d, TorqueUnit.NewtonMeter),
-                (TorqueUnit.KilopoundForceInch, TorqueUnit.NewtonMeter) => new Torque((_value * 4.4482216152605 * 2.54e-2) * 1e3d, TorqueUnit.NewtonMeter),
-                (TorqueUnit.MeganewtonCentimeter, TorqueUnit.NewtonMeter) => new Torque((_value * 0.01) * 1e6d, TorqueUnit.NewtonMeter),
-                (TorqueUnit.MeganewtonMeter, TorqueUnit.NewtonMeter) => new Torque((_value) * 1e6d, TorqueUnit.NewtonMeter),
-                (TorqueUnit.MeganewtonMillimeter, TorqueUnit.NewtonMeter) => new Torque((_value * 0.001) * 1e6d, TorqueUnit.NewtonMeter),
-                (TorqueUnit.MegapoundForceFoot, TorqueUnit.NewtonMeter) => new Torque((_value * 4.4482216152605 * 0.3048) * 1e6d, TorqueUnit.NewtonMeter),
-                (TorqueUnit.MegapoundForceInch, TorqueUnit.NewtonMeter) => new Torque((_value * 4.4482216152605 * 2.54e-2) * 1e6d, TorqueUnit.NewtonMeter),
-                (TorqueUnit.NewtonCentimeter, TorqueUnit.NewtonMeter) => new Torque(_value * 0.01, TorqueUnit.NewtonMeter),
-                (TorqueUnit.NewtonMillimeter, TorqueUnit.NewtonMeter) => new Torque(_value * 0.001, TorqueUnit.NewtonMeter),
-                (TorqueUnit.PoundalFoot, TorqueUnit.NewtonMeter) => new Torque(_value * 0.138254954376 * 0.3048, TorqueUnit.NewtonMeter),
-                (TorqueUnit.PoundForceFoot, TorqueUnit.NewtonMeter) => new Torque(_value * 4.4482216152605 * 0.3048, TorqueUnit.NewtonMeter),
-                (TorqueUnit.PoundForceInch, TorqueUnit.NewtonMeter) => new Torque(_value * 4.4482216152605 * 2.54e-2, TorqueUnit.NewtonMeter),
-                (TorqueUnit.TonneForceCentimeter, TorqueUnit.NewtonMeter) => new Torque(_value * 9.80665e1, TorqueUnit.NewtonMeter),
-                (TorqueUnit.TonneForceMeter, TorqueUnit.NewtonMeter) => new Torque(_value * 9.80665e3, TorqueUnit.NewtonMeter),
-                (TorqueUnit.TonneForceMillimeter, TorqueUnit.NewtonMeter) => new Torque(_value * 9.80665, TorqueUnit.NewtonMeter),
-
-                // BaseUnit -> TorqueUnit
-                (TorqueUnit.NewtonMeter, TorqueUnit.GramForceCentimeter) => new Torque(_value / 9.80665e-5, TorqueUnit.GramForceCentimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.GramForceMeter) => new Torque(_value / 9.80665e-3, TorqueUnit.GramForceMeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.GramForceMillimeter) => new Torque(_value / 9.80665e-6, TorqueUnit.GramForceMillimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.KilogramForceCentimeter) => new Torque(_value / 9.80665e-2, TorqueUnit.KilogramForceCentimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.KilogramForceMeter) => new Torque(_value / 9.80665, TorqueUnit.KilogramForceMeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.KilogramForceMillimeter) => new Torque(_value / 9.80665e-3, TorqueUnit.KilogramForceMillimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.KilonewtonCentimeter) => new Torque((_value * 100) / 1e3d, TorqueUnit.KilonewtonCentimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.KilonewtonMeter) => new Torque((_value) / 1e3d, TorqueUnit.KilonewtonMeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.KilonewtonMillimeter) => new Torque((_value * 1000) / 1e3d, TorqueUnit.KilonewtonMillimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.KilopoundForceFoot) => new Torque((_value / (4.4482216152605 * 0.3048)) / 1e3d, TorqueUnit.KilopoundForceFoot),
-                (TorqueUnit.NewtonMeter, TorqueUnit.KilopoundForceInch) => new Torque((_value / (4.4482216152605 * 2.54e-2)) / 1e3d, TorqueUnit.KilopoundForceInch),
-                (TorqueUnit.NewtonMeter, TorqueUnit.MeganewtonCentimeter) => new Torque((_value * 100) / 1e6d, TorqueUnit.MeganewtonCentimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.MeganewtonMeter) => new Torque((_value) / 1e6d, TorqueUnit.MeganewtonMeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.MeganewtonMillimeter) => new Torque((_value * 1000) / 1e6d, TorqueUnit.MeganewtonMillimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.MegapoundForceFoot) => new Torque((_value / (4.4482216152605 * 0.3048)) / 1e6d, TorqueUnit.MegapoundForceFoot),
-                (TorqueUnit.NewtonMeter, TorqueUnit.MegapoundForceInch) => new Torque((_value / (4.4482216152605 * 2.54e-2)) / 1e6d, TorqueUnit.MegapoundForceInch),
-                (TorqueUnit.NewtonMeter, TorqueUnit.NewtonCentimeter) => new Torque(_value * 100, TorqueUnit.NewtonCentimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.NewtonMillimeter) => new Torque(_value * 1000, TorqueUnit.NewtonMillimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.PoundalFoot) => new Torque(_value / (0.138254954376 * 0.3048), TorqueUnit.PoundalFoot),
-                (TorqueUnit.NewtonMeter, TorqueUnit.PoundForceFoot) => new Torque(_value / (4.4482216152605 * 0.3048), TorqueUnit.PoundForceFoot),
-                (TorqueUnit.NewtonMeter, TorqueUnit.PoundForceInch) => new Torque(_value / (4.4482216152605 * 2.54e-2), TorqueUnit.PoundForceInch),
-                (TorqueUnit.NewtonMeter, TorqueUnit.TonneForceCentimeter) => new Torque(_value / 9.80665e1, TorqueUnit.TonneForceCentimeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.TonneForceMeter) => new Torque(_value / 9.80665e3, TorqueUnit.TonneForceMeter),
-                (TorqueUnit.NewtonMeter, TorqueUnit.TonneForceMillimeter) => new Torque(_value / 9.80665, TorqueUnit.TonneForceMillimeter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not TorqueUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TorqueUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is TorqueUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TorqueUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<TorqueUnit> IQuantity<TorqueUnit>.ToUnit(TorqueUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1210,11 +1063,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
index 483b6c6be3..130640e9e8 100644
--- a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Turbidity
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Turbidity :
-        IArithmeticQuantity<Turbidity, TurbidityUnit>,
+        ILinearQuantity<Turbidity, TurbidityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Turbidity, Turbidity, double>,
+        IDivisionOperators<Turbidity, Turbidity, QuantityValue>,
         IComparisonOperators<Turbidity, Turbidity, bool>,
         IParsable<Turbidity>,
 #endif
@@ -55,7 +54,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -126,9 +125,7 @@ public static IEnumerable<UnitDefinition<TurbidityUnit>> GetDefaultMappings()
 
         static Turbidity()
         {
-            Info = TurbidityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(TurbidityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -136,7 +133,7 @@ static Turbidity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Turbidity(double value, TurbidityUnit unit)
+        public Turbidity(QuantityValue value, TurbidityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -147,7 +144,8 @@ public Turbidity(double value, TurbidityUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Turbidity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Turbidity, TurbidityUnit> Info { get; }
@@ -176,10 +174,8 @@ public Turbidity(double value, TurbidityUnit unit)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public TurbidityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -213,28 +209,14 @@ public Turbidity(double value, TurbidityUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="TurbidityUnit.NTU"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="TurbidityUnit.NTU"/>
         /// </summary>
-        public double NTU => As(TurbidityUnit.NTU);
+        public QuantityValue NTU => this.As(TurbidityUnit.NTU);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: TurbidityUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Turbidity>(TurbidityUnit.NTU, TurbidityUnit.NTU, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> TurbidityUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -263,7 +245,7 @@ public static string GetAbbreviation(TurbidityUnit unit, IFormatProvider? provid
         /// <summary>
         ///     Creates a <see cref="Turbidity"/> from <see cref="TurbidityUnit.NTU"/>.
         /// </summary>
-        public static Turbidity FromNTU(double value)
+        public static Turbidity FromNTU(QuantityValue value)
         {
             return new Turbidity(value, TurbidityUnit.NTU);
         }
@@ -274,7 +256,7 @@ public static Turbidity FromNTU(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Turbidity unit value.</returns>
-        public static Turbidity From(double value, TurbidityUnit fromUnit)
+        public static Turbidity From(QuantityValue value, TurbidityUnit fromUnit)
         {
             return new Turbidity(value, fromUnit);
         }
@@ -335,10 +317,7 @@ public static Turbidity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Turbidity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Turbidity, TurbidityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Turbidity, TurbidityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -366,11 +345,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Turbidity result
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Turbidity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Turbidity, TurbidityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Turbidity, TurbidityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -391,7 +366,7 @@ public static TurbidityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -402,7 +377,7 @@ public static TurbidityUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.TurbidityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.TurbidityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out TurbidityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -417,7 +392,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out TurbidityUni
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out TurbidityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -436,35 +411,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Turbidity"/> from adding two <see cref="Turbidity"/>.</summary>
         public static Turbidity operator +(Turbidity left, Turbidity right)
         {
-            return new Turbidity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Turbidity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Turbidity"/> from subtracting two <see cref="Turbidity"/>.</summary>
         public static Turbidity operator -(Turbidity left, Turbidity right)
         {
-            return new Turbidity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Turbidity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Turbidity"/> from multiplying value and <see cref="Turbidity"/>.</summary>
-        public static Turbidity operator *(double left, Turbidity right)
+        public static Turbidity operator *(QuantityValue left, Turbidity right)
         {
             return new Turbidity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Turbidity"/> from multiplying value and <see cref="Turbidity"/>.</summary>
-        public static Turbidity operator *(Turbidity left, double right)
+        public static Turbidity operator *(Turbidity left, QuantityValue right)
         {
             return new Turbidity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Turbidity"/> from dividing <see cref="Turbidity"/> by value.</summary>
-        public static Turbidity operator /(Turbidity left, double right)
+        public static Turbidity operator /(Turbidity left, QuantityValue right)
         {
             return new Turbidity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Turbidity"/> by <see cref="Turbidity"/>.</summary>
-        public static double operator /(Turbidity left, Turbidity right)
+        public static QuantityValue operator /(Turbidity left, Turbidity right)
         {
             return left.NTU / right.NTU;
         }
@@ -476,97 +451,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Turbidity left, Turbidity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Turbidity left, Turbidity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Turbidity left, Turbidity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Turbidity left, Turbidity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Turbidity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Turbidity other, Turbidity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Turbidity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Turbidity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Turbidity left, Turbidity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Turbidity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Turbidity other, Turbidity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Turbidity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Turbidity,Turbidity)"/>.
+        ///     See that operator (and <see cref="Equals(Turbidity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Turbidity left, Turbidity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Turbidity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Turbidity other, Turbidity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Turbidity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Turbidity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Turbidity"/>, this method delegates to
+        ///     <see cref="Equals(Turbidity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Turbidity otherQuantity))
+            if (obj is not Turbidity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Turbidity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Turbidity other, Turbidity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Turbidity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Turbidity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Turbidity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Turbidity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Turbidity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Turbidity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Turbidity otherQuantity)) throw new ArgumentException("Expected type Turbidity.", nameof(obj));
+            if (obj is not Turbidity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Turbidity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Turbidity"/> with another <see cref="Turbidity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Turbidity"/> with another <see cref="Turbidity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -578,131 +567,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Turbidity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(TurbidityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<TurbidityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Turbidity to another Turbidity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Turbidity with the specified unit.</returns>
-        public Turbidity ToUnit(TurbidityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Turbidity"/> to another <see cref="Turbidity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Turbidity with the specified unit.</returns>
-        public Turbidity ToUnit(TurbidityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Turbidity), Unit, typeof(Turbidity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Turbidity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Turbidity"/> to another <see cref="Turbidity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Turbidity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(TurbidityUnit unit, [NotNullWhen(true)] out Turbidity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Turbidity? convertedOrNull = (Unit, unit) switch
-            {
-                // TurbidityUnit -> BaseUnit
-
-                // BaseUnit -> TurbidityUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not TurbidityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TurbidityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is TurbidityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TurbidityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<TurbidityUnit> IQuantity<TurbidityUnit>.ToUnit(TurbidityUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -714,11 +583,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
index 1528ba9318..f08e9633a7 100644
--- a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     Vitamin A: 1 IU is the biological equivalent of 0.3 µg retinol, or of 0.6 µg beta-carotene.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct VitaminA :
-        IArithmeticQuantity<VitaminA, VitaminAUnit>,
+        ILinearQuantity<VitaminA, VitaminAUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<VitaminA, VitaminA, double>,
+        IDivisionOperators<VitaminA, VitaminA, QuantityValue>,
         IComparisonOperators<VitaminA, VitaminA, bool>,
         IParsable<VitaminA>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -123,9 +122,7 @@ public static IEnumerable<UnitDefinition<VitaminAUnit>> GetDefaultMappings()
 
         static VitaminA()
         {
-            Info = VitaminAInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(VitaminAInfo.CreateDefault);
         }
 
         /// <summary>
@@ -133,7 +130,7 @@ static VitaminA()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VitaminA(double value, VitaminAUnit unit)
+        public VitaminA(QuantityValue value, VitaminAUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -144,7 +141,8 @@ public VitaminA(double value, VitaminAUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="VitaminA" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<VitaminA, VitaminAUnit> Info { get; }
@@ -173,10 +171,8 @@ public VitaminA(double value, VitaminAUnit unit)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public VitaminAUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -210,28 +206,14 @@ public VitaminA(double value, VitaminAUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VitaminAUnit.InternationalUnit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VitaminAUnit.InternationalUnit"/>
         /// </summary>
-        public double InternationalUnits => As(VitaminAUnit.InternationalUnit);
+        public QuantityValue InternationalUnits => this.As(VitaminAUnit.InternationalUnit);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: VitaminAUnit -> BaseUnit
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<VitaminA>(VitaminAUnit.InternationalUnit, VitaminAUnit.InternationalUnit, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> VitaminAUnit
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -260,7 +242,7 @@ public static string GetAbbreviation(VitaminAUnit unit, IFormatProvider? provide
         /// <summary>
         ///     Creates a <see cref="VitaminA"/> from <see cref="VitaminAUnit.InternationalUnit"/>.
         /// </summary>
-        public static VitaminA FromInternationalUnits(double value)
+        public static VitaminA FromInternationalUnits(QuantityValue value)
         {
             return new VitaminA(value, VitaminAUnit.InternationalUnit);
         }
@@ -271,7 +253,7 @@ public static VitaminA FromInternationalUnits(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VitaminA unit value.</returns>
-        public static VitaminA From(double value, VitaminAUnit fromUnit)
+        public static VitaminA From(QuantityValue value, VitaminAUnit fromUnit)
         {
             return new VitaminA(value, fromUnit);
         }
@@ -332,10 +314,7 @@ public static VitaminA Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static VitaminA Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<VitaminA, VitaminAUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<VitaminA, VitaminAUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -363,11 +342,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out VitaminA result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out VitaminA result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<VitaminA, VitaminAUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<VitaminA, VitaminAUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -388,7 +363,7 @@ public static VitaminAUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -399,7 +374,7 @@ public static VitaminAUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VitaminAUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.VitaminAUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out VitaminAUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -414,7 +389,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VitaminAUnit
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out VitaminAUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -433,35 +408,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="VitaminA"/> from adding two <see cref="VitaminA"/>.</summary>
         public static VitaminA operator +(VitaminA left, VitaminA right)
         {
-            return new VitaminA(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new VitaminA(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VitaminA"/> from subtracting two <see cref="VitaminA"/>.</summary>
         public static VitaminA operator -(VitaminA left, VitaminA right)
         {
-            return new VitaminA(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new VitaminA(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VitaminA"/> from multiplying value and <see cref="VitaminA"/>.</summary>
-        public static VitaminA operator *(double left, VitaminA right)
+        public static VitaminA operator *(QuantityValue left, VitaminA right)
         {
             return new VitaminA(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="VitaminA"/> from multiplying value and <see cref="VitaminA"/>.</summary>
-        public static VitaminA operator *(VitaminA left, double right)
+        public static VitaminA operator *(VitaminA left, QuantityValue right)
         {
             return new VitaminA(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="VitaminA"/> from dividing <see cref="VitaminA"/> by value.</summary>
-        public static VitaminA operator /(VitaminA left, double right)
+        public static VitaminA operator /(VitaminA left, QuantityValue right)
         {
             return new VitaminA(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="VitaminA"/> by <see cref="VitaminA"/>.</summary>
-        public static double operator /(VitaminA left, VitaminA right)
+        public static QuantityValue operator /(VitaminA left, VitaminA right)
         {
             return left.InternationalUnits / right.InternationalUnits;
         }
@@ -473,97 +448,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(VitaminA left, VitaminA right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(VitaminA left, VitaminA right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(VitaminA left, VitaminA right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(VitaminA left, VitaminA right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="VitaminA"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VitaminA other, VitaminA tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VitaminA"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(VitaminA)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(VitaminA left, VitaminA right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="VitaminA"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VitaminA other, VitaminA tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VitaminA"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(VitaminA,VitaminA)"/>.
+        ///     See that operator (and <see cref="Equals(VitaminA)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(VitaminA left, VitaminA right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VitaminA"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VitaminA other, VitaminA tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="VitaminA"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="VitaminA"/>.
+        ///     When <paramref name="obj"/> is a <see cref="VitaminA"/>, this method delegates to
+        ///     <see cref="Equals(VitaminA)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is VitaminA otherQuantity))
+            if (obj is not VitaminA otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VitaminA"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VitaminA other, VitaminA tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="VitaminA"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(VitaminA other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current VitaminA.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(VitaminA), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="VitaminA"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(VitaminA)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is VitaminA otherQuantity)) throw new ArgumentException("Expected type VitaminA.", nameof(obj));
+            if (obj is not VitaminA otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<VitaminA>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="VitaminA"/> with another <see cref="VitaminA"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="VitaminA"/> with another <see cref="VitaminA"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -575,131 +564,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(VitaminA other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(VitaminAUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<VitaminAUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this VitaminA to another VitaminA with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A VitaminA with the specified unit.</returns>
-        public VitaminA ToUnit(VitaminAUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="VitaminA"/> to another <see cref="VitaminA"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A VitaminA with the specified unit.</returns>
-        public VitaminA ToUnit(VitaminAUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(VitaminA), Unit, typeof(VitaminA), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (VitaminA)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="VitaminA"/> to another <see cref="VitaminA"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="VitaminA"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(VitaminAUnit unit, [NotNullWhen(true)] out VitaminA? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            VitaminA? convertedOrNull = (Unit, unit) switch
-            {
-                // VitaminAUnit -> BaseUnit
-
-                // BaseUnit -> VitaminAUnit
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not VitaminAUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VitaminAUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is VitaminAUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VitaminAUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<VitaminAUnit> IQuantity<VitaminAUnit>.ToUnit(VitaminAUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -711,11 +580,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
index 223437b961..5fae8578a3 100644
--- a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,22 +33,26 @@ namespace UnitsNet
     ///     Volume is the quantity of three-dimensional space enclosed by some closed boundary, for example, the space that a substance (solid, liquid, gas, or plasma) or shape occupies or contains.[1] Volume is often quantified numerically using the SI derived unit, the cubic metre. The volume of a container is generally understood to be the capacity of the container, i. e. the amount of fluid (gas or liquid) that the container could hold, rather than the amount of space the container itself displaces.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct Volume :
-        IArithmeticQuantity<Volume, VolumeUnit>,
+        ILinearQuantity<Volume, VolumeUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<Volume, Volume, double>,
+        IDivisionOperators<Volume, Volume, QuantityValue>,
         IMultiplyOperators<Volume, Molarity, AmountOfSubstance>,
         IMultiplyOperators<Volume, ReciprocalLength, Area>,
         IDivisionOperators<Volume, Length, Area>,
         IMultiplyOperators<Volume, Length, AreaMomentOfInertia>,
         IDivisionOperators<Volume, VolumeFlow, Duration>,
+        IMultiplyOperators<Volume, ElectricChargeDensity, ElectricCharge>,
         IMultiplyOperators<Volume, EnergyDensity, Energy>,
+        IMultiplyOperators<Volume, SpecificWeight, Force>,
         IMultiplyOperators<Volume, ReciprocalArea, Length>,
         IDivisionOperators<Volume, Area, Length>,
         IMultiplyOperators<Volume, Density, Mass>,
         IMultiplyOperators<Volume, MassConcentration, Mass>,
         IDivisionOperators<Volume, SpecificVolume, Mass>,
+        IMultiplyOperators<Volume, PowerDensity, Power>,
         IDivisionOperators<Volume, Mass, SpecificVolume>,
         IDivisionOperators<Volume, Duration, VolumeFlow>,
         IComparisonOperators<Volume, Volume, bool>,
@@ -65,7 +67,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -115,7 +117,7 @@ public static VolumeInfo CreateDefault(Func<IEnumerable<UnitDefinition<VolumeUni
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="Volume"/> is [L^3].
+            ///     The <see cref="BaseDimensions" /> for <see cref="Volume"/> is L^3.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(3, 0, 0, 0, 0, 0, 0);
 
@@ -130,69 +132,172 @@ public static VolumeInfo CreateDefault(Func<IEnumerable<UnitDefinition<VolumeUni
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{VolumeUnit}"/> representing the default unit mappings for Volume.</returns>
             public static IEnumerable<UnitDefinition<VolumeUnit>> GetDefaultMappings()
             {
-                yield return new (VolumeUnit.AcreFoot, "AcreFoot", "AcreFeet", BaseUnits.Undefined);
-                yield return new (VolumeUnit.AuTablespoon, "AuTablespoon", "AuTablespoons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.BoardFoot, "BoardFoot", "BoardFeet", BaseUnits.Undefined);
-                yield return new (VolumeUnit.Centiliter, "Centiliter", "Centiliters", BaseUnits.Undefined);
-                yield return new (VolumeUnit.CubicCentimeter, "CubicCentimeter", "CubicCentimeters", new BaseUnits(length: LengthUnit.Centimeter));
-                yield return new (VolumeUnit.CubicDecimeter, "CubicDecimeter", "CubicDecimeters", new BaseUnits(length: LengthUnit.Decimeter));
-                yield return new (VolumeUnit.CubicFoot, "CubicFoot", "CubicFeet", new BaseUnits(length: LengthUnit.Foot));
-                yield return new (VolumeUnit.CubicHectometer, "CubicHectometer", "CubicHectometers", new BaseUnits(length: LengthUnit.Hectometer));
-                yield return new (VolumeUnit.CubicInch, "CubicInch", "CubicInches", new BaseUnits(length: LengthUnit.Inch));
-                yield return new (VolumeUnit.CubicKilometer, "CubicKilometer", "CubicKilometers", new BaseUnits(length: LengthUnit.Kilometer));
+                yield return new (VolumeUnit.AcreFoot, "AcreFoot", "AcreFeet", BaseUnits.Undefined,
+                     new QuantityValue(48828125, 60228605349)
+                );
+                yield return new (VolumeUnit.AuTablespoon, "AuTablespoon", "AuTablespoons", BaseUnits.Undefined,
+                     50000
+                );
+                yield return new (VolumeUnit.BoardFoot, "BoardFoot", "BoardFeet", BaseUnits.Undefined,
+                     new QuantityValue(7812500000, 18435447)
+                );
+                yield return new (VolumeUnit.Centiliter, "Centiliter", "Centiliters", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (VolumeUnit.CubicCentimeter, "CubicCentimeter", "CubicCentimeters", new BaseUnits(length: LengthUnit.Centimeter),
+                     1000000
+                );
+                yield return new (VolumeUnit.CubicDecimeter, "CubicDecimeter", "CubicDecimeters", new BaseUnits(length: LengthUnit.Decimeter),
+                     1000
+                );
+                yield return new (VolumeUnit.CubicFoot, "CubicFoot", "CubicFeet", new BaseUnits(length: LengthUnit.Foot),
+                     new QuantityValue(1953125000, 55306341)
+                );
+                yield return new (VolumeUnit.CubicHectometer, "CubicHectometer", "CubicHectometers", new BaseUnits(length: LengthUnit.Hectometer),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (VolumeUnit.CubicInch, "CubicInch", "CubicInches", new BaseUnits(length: LengthUnit.Inch),
+                     new QuantityValue(125000000000, 2048383)
+                );
+                yield return new (VolumeUnit.CubicKilometer, "CubicKilometer", "CubicKilometers", new BaseUnits(length: LengthUnit.Kilometer),
+                     new QuantityValue(1, 1000000000)
+                );
                 yield return new (VolumeUnit.CubicMeter, "CubicMeter", "CubicMeters", new BaseUnits(length: LengthUnit.Meter));
-                yield return new (VolumeUnit.CubicMicrometer, "CubicMicrometer", "CubicMicrometers", new BaseUnits(length: LengthUnit.Micrometer));
-                yield return new (VolumeUnit.CubicMile, "CubicMile", "CubicMiles", new BaseUnits(length: LengthUnit.Mile));
-                yield return new (VolumeUnit.CubicMillimeter, "CubicMillimeter", "CubicMillimeters", new BaseUnits(length: LengthUnit.Millimeter));
-                yield return new (VolumeUnit.CubicYard, "CubicYard", "CubicYards", new BaseUnits(length: LengthUnit.Yard));
-                yield return new (VolumeUnit.Decaliter, "Decaliter", "Decaliters", BaseUnits.Undefined);
-                yield return new (VolumeUnit.DecausGallon, "DecausGallon", "DecausGallons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.Deciliter, "Deciliter", "Deciliters", BaseUnits.Undefined);
-                yield return new (VolumeUnit.DeciusGallon, "DeciusGallon", "DeciusGallons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.HectocubicFoot, "HectocubicFoot", "HectocubicFeet", BaseUnits.Undefined);
-                yield return new (VolumeUnit.HectocubicMeter, "HectocubicMeter", "HectocubicMeters", BaseUnits.Undefined);
-                yield return new (VolumeUnit.Hectoliter, "Hectoliter", "Hectoliters", BaseUnits.Undefined);
-                yield return new (VolumeUnit.HectousGallon, "HectousGallon", "HectousGallons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.ImperialBeerBarrel, "ImperialBeerBarrel", "ImperialBeerBarrels", BaseUnits.Undefined);
-                yield return new (VolumeUnit.ImperialGallon, "ImperialGallon", "ImperialGallons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.ImperialOunce, "ImperialOunce", "ImperialOunces", BaseUnits.Undefined);
-                yield return new (VolumeUnit.ImperialPint, "ImperialPint", "ImperialPints", BaseUnits.Undefined);
-                yield return new (VolumeUnit.ImperialQuart, "ImperialQuart", "ImperialQuarts", BaseUnits.Undefined);
-                yield return new (VolumeUnit.KilocubicFoot, "KilocubicFoot", "KilocubicFeet", BaseUnits.Undefined);
-                yield return new (VolumeUnit.KilocubicMeter, "KilocubicMeter", "KilocubicMeters", new BaseUnits(length: LengthUnit.Decameter));
-                yield return new (VolumeUnit.KiloimperialGallon, "KiloimperialGallon", "KiloimperialGallons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.Kiloliter, "Kiloliter", "Kiloliters", new BaseUnits(length: LengthUnit.Meter));
-                yield return new (VolumeUnit.KilousGallon, "KilousGallon", "KilousGallons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.Liter, "Liter", "Liters", new BaseUnits(length: LengthUnit.Decimeter));
-                yield return new (VolumeUnit.MegacubicFoot, "MegacubicFoot", "MegacubicFeet", BaseUnits.Undefined);
-                yield return new (VolumeUnit.MegaimperialGallon, "MegaimperialGallon", "MegaimperialGallons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.Megaliter, "Megaliter", "Megaliters", new BaseUnits(length: LengthUnit.Decameter));
-                yield return new (VolumeUnit.MegausGallon, "MegausGallon", "MegausGallons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.MetricCup, "MetricCup", "MetricCups", BaseUnits.Undefined);
-                yield return new (VolumeUnit.MetricTablespoon, "MetricTablespoon", "MetricTablespoons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.MetricTeaspoon, "MetricTeaspoon", "MetricTeaspoons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.Microliter, "Microliter", "Microliters", new BaseUnits(length: LengthUnit.Millimeter));
-                yield return new (VolumeUnit.Milliliter, "Milliliter", "Milliliters", new BaseUnits(length: LengthUnit.Centimeter));
-                yield return new (VolumeUnit.Nanoliter, "Nanoliter", "Nanoliters", BaseUnits.Undefined);
-                yield return new (VolumeUnit.OilBarrel, "OilBarrel", "OilBarrels", BaseUnits.Undefined);
-                yield return new (VolumeUnit.UkTablespoon, "UkTablespoon", "UkTablespoons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.UsBeerBarrel, "UsBeerBarrel", "UsBeerBarrels", BaseUnits.Undefined);
-                yield return new (VolumeUnit.UsCustomaryCup, "UsCustomaryCup", "UsCustomaryCups", BaseUnits.Undefined);
-                yield return new (VolumeUnit.UsGallon, "UsGallon", "UsGallons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.UsLegalCup, "UsLegalCup", "UsLegalCups", BaseUnits.Undefined);
-                yield return new (VolumeUnit.UsOunce, "UsOunce", "UsOunces", BaseUnits.Undefined);
-                yield return new (VolumeUnit.UsPint, "UsPint", "UsPints", BaseUnits.Undefined);
-                yield return new (VolumeUnit.UsQuart, "UsQuart", "UsQuarts", BaseUnits.Undefined);
-                yield return new (VolumeUnit.UsTablespoon, "UsTablespoon", "UsTablespoons", BaseUnits.Undefined);
-                yield return new (VolumeUnit.UsTeaspoon, "UsTeaspoon", "UsTeaspoons", BaseUnits.Undefined);
+                yield return new (VolumeUnit.CubicMicrometer, "CubicMicrometer", "CubicMicrometers", new BaseUnits(length: LengthUnit.Micrometer),
+                     1000000000000000000
+                );
+                yield return new (VolumeUnit.CubicMile, "CubicMile", "CubicMiles", new BaseUnits(length: LengthUnit.Mile),
+                     new QuantityValue(1953125, 8140980127813632)
+                );
+                yield return new (VolumeUnit.CubicMillimeter, "CubicMillimeter", "CubicMillimeters", new BaseUnits(length: LengthUnit.Millimeter),
+                     1000000000
+                );
+                yield return new (VolumeUnit.CubicYard, "CubicYard", "CubicYards", new BaseUnits(length: LengthUnit.Yard),
+                     new QuantityValue(1953125000, 1493271207)
+                );
+                yield return new (VolumeUnit.Decaliter, "Decaliter", "Decaliters", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (VolumeUnit.DecausGallon, "DecausGallon", "DecausGallons", BaseUnits.Undefined,
+                     new QuantityValue(12500000000, 473176473)
+                );
+                yield return new (VolumeUnit.Deciliter, "Deciliter", "Deciliters", BaseUnits.Undefined,
+                     10000
+                );
+                yield return new (VolumeUnit.DeciusGallon, "DeciusGallon", "DeciusGallons", BaseUnits.Undefined,
+                     new QuantityValue(1250000000000, 473176473)
+                );
+                yield return new (VolumeUnit.Hectoliter, "Hectoliter", "Hectoliters", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (VolumeUnit.HectousGallon, "HectousGallon", "HectousGallons", BaseUnits.Undefined,
+                     new QuantityValue(1250000000, 473176473)
+                );
+                yield return new (VolumeUnit.HundredCubicFoot, "HundredCubicFoot", "HundredCubicFeet", BaseUnits.Undefined,
+                     new QuantityValue(19531250, 55306341)
+                );
+                yield return new (VolumeUnit.ImperialBeerBarrel, "ImperialBeerBarrel", "ImperialBeerBarrels", BaseUnits.Undefined,
+                     new QuantityValue(25000000, 4091481)
+                );
+                yield return new (VolumeUnit.ImperialGallon, "ImperialGallon", "ImperialGallons", BaseUnits.Undefined,
+                     new QuantityValue(100000000, 454609)
+                );
+                yield return new (VolumeUnit.ImperialOunce, "ImperialOunce", "ImperialOunces", BaseUnits.Undefined,
+                     new QuantityValue(16000000000, 454609)
+                );
+                yield return new (VolumeUnit.ImperialPint, "ImperialPint", "ImperialPints", BaseUnits.Undefined,
+                     new QuantityValue(800000000, 454609)
+                );
+                yield return new (VolumeUnit.ImperialQuart, "ImperialQuart", "ImperialQuarts", BaseUnits.Undefined,
+                     new QuantityValue(400000000, 454609)
+                );
+                yield return new (VolumeUnit.KiloimperialGallon, "KiloimperialGallon", "KiloimperialGallons", BaseUnits.Undefined,
+                     new QuantityValue(100000, 454609)
+                );
+                yield return new (VolumeUnit.Kiloliter, "Kiloliter", "Kiloliters", new BaseUnits(length: LengthUnit.Meter),
+                     1
+                );
+                yield return new (VolumeUnit.KilousGallon, "KilousGallon", "KilousGallons", BaseUnits.Undefined,
+                     new QuantityValue(125000000, 473176473)
+                );
+                yield return new (VolumeUnit.Liter, "Liter", "Liters", new BaseUnits(length: LengthUnit.Decimeter),
+                     1000
+                );
+                yield return new (VolumeUnit.MegaimperialGallon, "MegaimperialGallon", "MegaimperialGallons", BaseUnits.Undefined,
+                     new QuantityValue(100, 454609)
+                );
+                yield return new (VolumeUnit.Megaliter, "Megaliter", "Megaliters", new BaseUnits(length: LengthUnit.Decameter),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (VolumeUnit.MegausGallon, "MegausGallon", "MegausGallons", BaseUnits.Undefined,
+                     new QuantityValue(125000, 473176473)
+                );
+                yield return new (VolumeUnit.MetricCup, "MetricCup", "MetricCups", BaseUnits.Undefined,
+                     4000
+                );
+                yield return new (VolumeUnit.MetricTablespoon, "MetricTablespoon", "MetricTablespoons", BaseUnits.Undefined,
+                     new QuantityValue(200000, 3)
+                );
+                yield return new (VolumeUnit.MetricTeaspoon, "MetricTeaspoon", "MetricTeaspoons", BaseUnits.Undefined,
+                     200000
+                );
+                yield return new (VolumeUnit.Microliter, "Microliter", "Microliters", new BaseUnits(length: LengthUnit.Millimeter),
+                     1000000000
+                );
+                yield return new (VolumeUnit.Milliliter, "Milliliter", "Milliliters", new BaseUnits(length: LengthUnit.Centimeter),
+                     1000000
+                );
+                yield return new (VolumeUnit.MillionCubicFoot, "MillionCubicFoot", "MillionCubicFeet", BaseUnits.Undefined,
+                     new QuantityValue(15625, 442450728)
+                );
+                yield return new (VolumeUnit.Nanoliter, "Nanoliter", "Nanoliters", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (VolumeUnit.OilBarrel, "OilBarrel", "OilBarrels", BaseUnits.Undefined,
+                     new QuantityValue(62500000000, 9936705933)
+                );
+                yield return new (VolumeUnit.ThousandCubicFoot, "ThousandCubicFoot", "ThousandCubicFeet", BaseUnits.Undefined,
+                     new QuantityValue(1953125, 55306341)
+                );
+                yield return new (VolumeUnit.ThousandCubicMeter, "ThousandCubicMeter", "ThousandCubicMeters", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (VolumeUnit.UkTablespoon, "UkTablespoon", "UkTablespoons", BaseUnits.Undefined,
+                     new QuantityValue(200000, 3)
+                );
+                yield return new (VolumeUnit.UsBeerBarrel, "UsBeerBarrel", "UsBeerBarrels", BaseUnits.Undefined,
+                     new QuantityValue(125000000000, 14668470663)
+                );
+                yield return new (VolumeUnit.UsCustomaryCup, "UsCustomaryCup", "UsCustomaryCups", BaseUnits.Undefined,
+                     new QuantityValue(2000000000000, 473176473)
+                );
+                yield return new (VolumeUnit.UsGallon, "UsGallon", "UsGallons", BaseUnits.Undefined,
+                     new QuantityValue(125000000000, 473176473)
+                );
+                yield return new (VolumeUnit.UsLegalCup, "UsLegalCup", "UsLegalCups", BaseUnits.Undefined,
+                     new QuantityValue(12500, 3)
+                );
+                yield return new (VolumeUnit.UsOunce, "UsOunce", "UsOunces", BaseUnits.Undefined,
+                     new QuantityValue(16000000000000, 473176473)
+                );
+                yield return new (VolumeUnit.UsPint, "UsPint", "UsPints", BaseUnits.Undefined,
+                     new QuantityValue(1000000000000, 473176473)
+                );
+                yield return new (VolumeUnit.UsQuart, "UsQuart", "UsQuarts", BaseUnits.Undefined,
+                     new QuantityValue(500000000000, 473176473)
+                );
+                yield return new (VolumeUnit.UsTablespoon, "UsTablespoon", "UsTablespoons", BaseUnits.Undefined,
+                     new QuantityValue(32000000000000, 473176473)
+                );
+                yield return new (VolumeUnit.UsTeaspoon, "UsTeaspoon", "UsTeaspoons", BaseUnits.Undefined,
+                     new QuantityValue(32000000000000, 157725491)
+                );
             }
         }
 
         static Volume()
         {
-            Info = VolumeInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(VolumeInfo.CreateDefault);
         }
 
         /// <summary>
@@ -200,7 +305,7 @@ static Volume()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public Volume(double value, VolumeUnit unit)
+        public Volume(QuantityValue value, VolumeUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -214,7 +319,7 @@ public Volume(double value, VolumeUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public Volume(double value, UnitSystem unitSystem)
+        public Volume(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -225,7 +330,8 @@ public Volume(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="Volume" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<Volume, VolumeUnit> Info { get; }
@@ -254,10 +360,8 @@ public Volume(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public VolumeUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -291,406 +395,279 @@ public Volume(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.AcreFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.AcreFoot"/>
         /// </summary>
-        public double AcreFeet => As(VolumeUnit.AcreFoot);
+        public QuantityValue AcreFeet => this.As(VolumeUnit.AcreFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.AuTablespoon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.AuTablespoon"/>
         /// </summary>
-        public double AuTablespoons => As(VolumeUnit.AuTablespoon);
+        public QuantityValue AuTablespoons => this.As(VolumeUnit.AuTablespoon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.BoardFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.BoardFoot"/>
         /// </summary>
-        public double BoardFeet => As(VolumeUnit.BoardFoot);
+        public QuantityValue BoardFeet => this.As(VolumeUnit.BoardFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Centiliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.Centiliter"/>
         /// </summary>
-        public double Centiliters => As(VolumeUnit.Centiliter);
+        public QuantityValue Centiliters => this.As(VolumeUnit.Centiliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicCentimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicCentimeter"/>
         /// </summary>
-        public double CubicCentimeters => As(VolumeUnit.CubicCentimeter);
+        public QuantityValue CubicCentimeters => this.As(VolumeUnit.CubicCentimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicDecimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicDecimeter"/>
         /// </summary>
-        public double CubicDecimeters => As(VolumeUnit.CubicDecimeter);
+        public QuantityValue CubicDecimeters => this.As(VolumeUnit.CubicDecimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicFoot"/>
         /// </summary>
-        public double CubicFeet => As(VolumeUnit.CubicFoot);
+        public QuantityValue CubicFeet => this.As(VolumeUnit.CubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicHectometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicHectometer"/>
         /// </summary>
-        public double CubicHectometers => As(VolumeUnit.CubicHectometer);
+        public QuantityValue CubicHectometers => this.As(VolumeUnit.CubicHectometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicInch"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicInch"/>
         /// </summary>
-        public double CubicInches => As(VolumeUnit.CubicInch);
+        public QuantityValue CubicInches => this.As(VolumeUnit.CubicInch);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicKilometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicKilometer"/>
         /// </summary>
-        public double CubicKilometers => As(VolumeUnit.CubicKilometer);
+        public QuantityValue CubicKilometers => this.As(VolumeUnit.CubicKilometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicMeter"/>
         /// </summary>
-        public double CubicMeters => As(VolumeUnit.CubicMeter);
+        public QuantityValue CubicMeters => this.As(VolumeUnit.CubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicMicrometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicMicrometer"/>
         /// </summary>
-        public double CubicMicrometers => As(VolumeUnit.CubicMicrometer);
+        public QuantityValue CubicMicrometers => this.As(VolumeUnit.CubicMicrometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicMile"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicMile"/>
         /// </summary>
-        public double CubicMiles => As(VolumeUnit.CubicMile);
+        public QuantityValue CubicMiles => this.As(VolumeUnit.CubicMile);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicMillimeter"/>
         /// </summary>
-        public double CubicMillimeters => As(VolumeUnit.CubicMillimeter);
+        public QuantityValue CubicMillimeters => this.As(VolumeUnit.CubicMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.CubicYard"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.CubicYard"/>
         /// </summary>
-        public double CubicYards => As(VolumeUnit.CubicYard);
+        public QuantityValue CubicYards => this.As(VolumeUnit.CubicYard);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Decaliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.Decaliter"/>
         /// </summary>
-        public double Decaliters => As(VolumeUnit.Decaliter);
+        public QuantityValue Decaliters => this.As(VolumeUnit.Decaliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.DecausGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.DecausGallon"/>
         /// </summary>
-        public double DecausGallons => As(VolumeUnit.DecausGallon);
+        public QuantityValue DecausGallons => this.As(VolumeUnit.DecausGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Deciliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.Deciliter"/>
         /// </summary>
-        public double Deciliters => As(VolumeUnit.Deciliter);
+        public QuantityValue Deciliters => this.As(VolumeUnit.Deciliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.DeciusGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.DeciusGallon"/>
         /// </summary>
-        public double DeciusGallons => As(VolumeUnit.DeciusGallon);
+        public QuantityValue DeciusGallons => this.As(VolumeUnit.DeciusGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.HectocubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.Hectoliter"/>
         /// </summary>
-        public double HectocubicFeet => As(VolumeUnit.HectocubicFoot);
+        public QuantityValue Hectoliters => this.As(VolumeUnit.Hectoliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.HectocubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.HectousGallon"/>
         /// </summary>
-        public double HectocubicMeters => As(VolumeUnit.HectocubicMeter);
+        public QuantityValue HectousGallons => this.As(VolumeUnit.HectousGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Hectoliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.HundredCubicFoot"/>
         /// </summary>
-        public double Hectoliters => As(VolumeUnit.Hectoliter);
+        public QuantityValue HundredCubicFeet => this.As(VolumeUnit.HundredCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.HectousGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.ImperialBeerBarrel"/>
         /// </summary>
-        public double HectousGallons => As(VolumeUnit.HectousGallon);
+        public QuantityValue ImperialBeerBarrels => this.As(VolumeUnit.ImperialBeerBarrel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.ImperialBeerBarrel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.ImperialGallon"/>
         /// </summary>
-        public double ImperialBeerBarrels => As(VolumeUnit.ImperialBeerBarrel);
+        public QuantityValue ImperialGallons => this.As(VolumeUnit.ImperialGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.ImperialGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.ImperialOunce"/>
         /// </summary>
-        public double ImperialGallons => As(VolumeUnit.ImperialGallon);
+        public QuantityValue ImperialOunces => this.As(VolumeUnit.ImperialOunce);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.ImperialOunce"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.ImperialPint"/>
         /// </summary>
-        public double ImperialOunces => As(VolumeUnit.ImperialOunce);
+        public QuantityValue ImperialPints => this.As(VolumeUnit.ImperialPint);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.ImperialPint"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.ImperialQuart"/>
         /// </summary>
-        public double ImperialPints => As(VolumeUnit.ImperialPint);
+        public QuantityValue ImperialQuarts => this.As(VolumeUnit.ImperialQuart);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.ImperialQuart"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.KiloimperialGallon"/>
         /// </summary>
-        public double ImperialQuarts => As(VolumeUnit.ImperialQuart);
+        public QuantityValue KiloimperialGallons => this.As(VolumeUnit.KiloimperialGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.KilocubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.Kiloliter"/>
         /// </summary>
-        public double KilocubicFeet => As(VolumeUnit.KilocubicFoot);
+        public QuantityValue Kiloliters => this.As(VolumeUnit.Kiloliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.KilocubicMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.KilousGallon"/>
         /// </summary>
-        public double KilocubicMeters => As(VolumeUnit.KilocubicMeter);
+        public QuantityValue KilousGallons => this.As(VolumeUnit.KilousGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.KiloimperialGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.Liter"/>
         /// </summary>
-        public double KiloimperialGallons => As(VolumeUnit.KiloimperialGallon);
+        public QuantityValue Liters => this.As(VolumeUnit.Liter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Kiloliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.MegaimperialGallon"/>
         /// </summary>
-        public double Kiloliters => As(VolumeUnit.Kiloliter);
+        public QuantityValue MegaimperialGallons => this.As(VolumeUnit.MegaimperialGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.KilousGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.Megaliter"/>
         /// </summary>
-        public double KilousGallons => As(VolumeUnit.KilousGallon);
+        public QuantityValue Megaliters => this.As(VolumeUnit.Megaliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Liter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.MegausGallon"/>
         /// </summary>
-        public double Liters => As(VolumeUnit.Liter);
+        public QuantityValue MegausGallons => this.As(VolumeUnit.MegausGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MegacubicFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.MetricCup"/>
         /// </summary>
-        public double MegacubicFeet => As(VolumeUnit.MegacubicFoot);
+        public QuantityValue MetricCups => this.As(VolumeUnit.MetricCup);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MegaimperialGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.MetricTablespoon"/>
         /// </summary>
-        public double MegaimperialGallons => As(VolumeUnit.MegaimperialGallon);
+        public QuantityValue MetricTablespoons => this.As(VolumeUnit.MetricTablespoon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Megaliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.MetricTeaspoon"/>
         /// </summary>
-        public double Megaliters => As(VolumeUnit.Megaliter);
+        public QuantityValue MetricTeaspoons => this.As(VolumeUnit.MetricTeaspoon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MegausGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.Microliter"/>
         /// </summary>
-        public double MegausGallons => As(VolumeUnit.MegausGallon);
+        public QuantityValue Microliters => this.As(VolumeUnit.Microliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MetricCup"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.Milliliter"/>
         /// </summary>
-        public double MetricCups => As(VolumeUnit.MetricCup);
+        public QuantityValue Milliliters => this.As(VolumeUnit.Milliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MetricTablespoon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.MillionCubicFoot"/>
         /// </summary>
-        public double MetricTablespoons => As(VolumeUnit.MetricTablespoon);
+        public QuantityValue MillionCubicFeet => this.As(VolumeUnit.MillionCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.MetricTeaspoon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.Nanoliter"/>
         /// </summary>
-        public double MetricTeaspoons => As(VolumeUnit.MetricTeaspoon);
+        public QuantityValue Nanoliters => this.As(VolumeUnit.Nanoliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Microliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.OilBarrel"/>
         /// </summary>
-        public double Microliters => As(VolumeUnit.Microliter);
+        public QuantityValue OilBarrels => this.As(VolumeUnit.OilBarrel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Milliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.ThousandCubicFoot"/>
         /// </summary>
-        public double Milliliters => As(VolumeUnit.Milliliter);
+        public QuantityValue ThousandCubicFeet => this.As(VolumeUnit.ThousandCubicFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.Nanoliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.ThousandCubicMeter"/>
         /// </summary>
-        public double Nanoliters => As(VolumeUnit.Nanoliter);
+        public QuantityValue ThousandCubicMeters => this.As(VolumeUnit.ThousandCubicMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.OilBarrel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.UkTablespoon"/>
         /// </summary>
-        public double OilBarrels => As(VolumeUnit.OilBarrel);
+        public QuantityValue UkTablespoons => this.As(VolumeUnit.UkTablespoon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UkTablespoon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.UsBeerBarrel"/>
         /// </summary>
-        public double UkTablespoons => As(VolumeUnit.UkTablespoon);
+        public QuantityValue UsBeerBarrels => this.As(VolumeUnit.UsBeerBarrel);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsBeerBarrel"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.UsCustomaryCup"/>
         /// </summary>
-        public double UsBeerBarrels => As(VolumeUnit.UsBeerBarrel);
+        public QuantityValue UsCustomaryCups => this.As(VolumeUnit.UsCustomaryCup);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsCustomaryCup"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.UsGallon"/>
         /// </summary>
-        public double UsCustomaryCups => As(VolumeUnit.UsCustomaryCup);
+        public QuantityValue UsGallons => this.As(VolumeUnit.UsGallon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsGallon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.UsLegalCup"/>
         /// </summary>
-        public double UsGallons => As(VolumeUnit.UsGallon);
+        public QuantityValue UsLegalCups => this.As(VolumeUnit.UsLegalCup);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsLegalCup"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.UsOunce"/>
         /// </summary>
-        public double UsLegalCups => As(VolumeUnit.UsLegalCup);
+        public QuantityValue UsOunces => this.As(VolumeUnit.UsOunce);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsOunce"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.UsPint"/>
         /// </summary>
-        public double UsOunces => As(VolumeUnit.UsOunce);
+        public QuantityValue UsPints => this.As(VolumeUnit.UsPint);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsPint"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.UsQuart"/>
         /// </summary>
-        public double UsPints => As(VolumeUnit.UsPint);
+        public QuantityValue UsQuarts => this.As(VolumeUnit.UsQuart);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsQuart"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.UsTablespoon"/>
         /// </summary>
-        public double UsQuarts => As(VolumeUnit.UsQuart);
+        public QuantityValue UsTablespoons => this.As(VolumeUnit.UsTablespoon);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsTablespoon"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeUnit.UsTeaspoon"/>
         /// </summary>
-        public double UsTablespoons => As(VolumeUnit.UsTablespoon);
-
-        /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeUnit.UsTeaspoon"/>
-        /// </summary>
-        public double UsTeaspoons => As(VolumeUnit.UsTeaspoon);
+        public QuantityValue UsTeaspoons => this.As(VolumeUnit.UsTeaspoon);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: VolumeUnit -> BaseUnit
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.AcreFoot, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.AuTablespoon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.BoardFoot, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Centiliter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicCentimeter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicDecimeter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicFoot, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicHectometer, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicInch, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicKilometer, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMicrometer, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMile, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMillimeter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicYard, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Decaliter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.DecausGallon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Deciliter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.DeciusGallon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.HectocubicFoot, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.HectocubicMeter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Hectoliter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.HectousGallon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.ImperialBeerBarrel, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.ImperialGallon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.ImperialOunce, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.ImperialPint, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.ImperialQuart, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.KilocubicFoot, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.KilocubicMeter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.KiloimperialGallon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Kiloliter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.KilousGallon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Liter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MegacubicFoot, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MegaimperialGallon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Megaliter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MegausGallon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MetricCup, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MetricTablespoon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.MetricTeaspoon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Microliter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Milliliter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.Nanoliter, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.OilBarrel, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UkTablespoon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsBeerBarrel, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsCustomaryCup, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsGallon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsLegalCup, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsOunce, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsPint, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsQuart, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsTablespoon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.UsTeaspoon, VolumeUnit.CubicMeter, quantity => quantity.ToUnit(VolumeUnit.CubicMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> VolumeUnit
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.AcreFoot, quantity => quantity.ToUnit(VolumeUnit.AcreFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.AuTablespoon, quantity => quantity.ToUnit(VolumeUnit.AuTablespoon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.BoardFoot, quantity => quantity.ToUnit(VolumeUnit.BoardFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.Centiliter, quantity => quantity.ToUnit(VolumeUnit.Centiliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicCentimeter, quantity => quantity.ToUnit(VolumeUnit.CubicCentimeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicDecimeter, quantity => quantity.ToUnit(VolumeUnit.CubicDecimeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicFoot, quantity => quantity.ToUnit(VolumeUnit.CubicFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicHectometer, quantity => quantity.ToUnit(VolumeUnit.CubicHectometer));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicInch, quantity => quantity.ToUnit(VolumeUnit.CubicInch));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicKilometer, quantity => quantity.ToUnit(VolumeUnit.CubicKilometer));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicMicrometer, quantity => quantity.ToUnit(VolumeUnit.CubicMicrometer));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicMile, quantity => quantity.ToUnit(VolumeUnit.CubicMile));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicMillimeter, quantity => quantity.ToUnit(VolumeUnit.CubicMillimeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.CubicYard, quantity => quantity.ToUnit(VolumeUnit.CubicYard));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.Decaliter, quantity => quantity.ToUnit(VolumeUnit.Decaliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.DecausGallon, quantity => quantity.ToUnit(VolumeUnit.DecausGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.Deciliter, quantity => quantity.ToUnit(VolumeUnit.Deciliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.DeciusGallon, quantity => quantity.ToUnit(VolumeUnit.DeciusGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.HectocubicFoot, quantity => quantity.ToUnit(VolumeUnit.HectocubicFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.HectocubicMeter, quantity => quantity.ToUnit(VolumeUnit.HectocubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.Hectoliter, quantity => quantity.ToUnit(VolumeUnit.Hectoliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.HectousGallon, quantity => quantity.ToUnit(VolumeUnit.HectousGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.ImperialBeerBarrel, quantity => quantity.ToUnit(VolumeUnit.ImperialBeerBarrel));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.ImperialGallon, quantity => quantity.ToUnit(VolumeUnit.ImperialGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.ImperialOunce, quantity => quantity.ToUnit(VolumeUnit.ImperialOunce));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.ImperialPint, quantity => quantity.ToUnit(VolumeUnit.ImperialPint));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.ImperialQuart, quantity => quantity.ToUnit(VolumeUnit.ImperialQuart));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.KilocubicFoot, quantity => quantity.ToUnit(VolumeUnit.KilocubicFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.KilocubicMeter, quantity => quantity.ToUnit(VolumeUnit.KilocubicMeter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.KiloimperialGallon, quantity => quantity.ToUnit(VolumeUnit.KiloimperialGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.Kiloliter, quantity => quantity.ToUnit(VolumeUnit.Kiloliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.KilousGallon, quantity => quantity.ToUnit(VolumeUnit.KilousGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.Liter, quantity => quantity.ToUnit(VolumeUnit.Liter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.MegacubicFoot, quantity => quantity.ToUnit(VolumeUnit.MegacubicFoot));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.MegaimperialGallon, quantity => quantity.ToUnit(VolumeUnit.MegaimperialGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.Megaliter, quantity => quantity.ToUnit(VolumeUnit.Megaliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.MegausGallon, quantity => quantity.ToUnit(VolumeUnit.MegausGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.MetricCup, quantity => quantity.ToUnit(VolumeUnit.MetricCup));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.MetricTablespoon, quantity => quantity.ToUnit(VolumeUnit.MetricTablespoon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.MetricTeaspoon, quantity => quantity.ToUnit(VolumeUnit.MetricTeaspoon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.Microliter, quantity => quantity.ToUnit(VolumeUnit.Microliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.Milliliter, quantity => quantity.ToUnit(VolumeUnit.Milliliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.Nanoliter, quantity => quantity.ToUnit(VolumeUnit.Nanoliter));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.OilBarrel, quantity => quantity.ToUnit(VolumeUnit.OilBarrel));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.UkTablespoon, quantity => quantity.ToUnit(VolumeUnit.UkTablespoon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.UsBeerBarrel, quantity => quantity.ToUnit(VolumeUnit.UsBeerBarrel));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.UsCustomaryCup, quantity => quantity.ToUnit(VolumeUnit.UsCustomaryCup));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.UsGallon, quantity => quantity.ToUnit(VolumeUnit.UsGallon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.UsLegalCup, quantity => quantity.ToUnit(VolumeUnit.UsLegalCup));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.UsOunce, quantity => quantity.ToUnit(VolumeUnit.UsOunce));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.UsPint, quantity => quantity.ToUnit(VolumeUnit.UsPint));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.UsQuart, quantity => quantity.ToUnit(VolumeUnit.UsQuart));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.UsTablespoon, quantity => quantity.ToUnit(VolumeUnit.UsTablespoon));
-            unitConverter.SetConversionFunction<Volume>(VolumeUnit.CubicMeter, VolumeUnit.UsTeaspoon, quantity => quantity.ToUnit(VolumeUnit.UsTeaspoon));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -719,7 +696,7 @@ public static string GetAbbreviation(VolumeUnit unit, IFormatProvider? provider)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.AcreFoot"/>.
         /// </summary>
-        public static Volume FromAcreFeet(double value)
+        public static Volume FromAcreFeet(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.AcreFoot);
         }
@@ -727,7 +704,7 @@ public static Volume FromAcreFeet(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.AuTablespoon"/>.
         /// </summary>
-        public static Volume FromAuTablespoons(double value)
+        public static Volume FromAuTablespoons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.AuTablespoon);
         }
@@ -735,7 +712,7 @@ public static Volume FromAuTablespoons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.BoardFoot"/>.
         /// </summary>
-        public static Volume FromBoardFeet(double value)
+        public static Volume FromBoardFeet(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.BoardFoot);
         }
@@ -743,7 +720,7 @@ public static Volume FromBoardFeet(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Centiliter"/>.
         /// </summary>
-        public static Volume FromCentiliters(double value)
+        public static Volume FromCentiliters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.Centiliter);
         }
@@ -751,7 +728,7 @@ public static Volume FromCentiliters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicCentimeter"/>.
         /// </summary>
-        public static Volume FromCubicCentimeters(double value)
+        public static Volume FromCubicCentimeters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicCentimeter);
         }
@@ -759,7 +736,7 @@ public static Volume FromCubicCentimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicDecimeter"/>.
         /// </summary>
-        public static Volume FromCubicDecimeters(double value)
+        public static Volume FromCubicDecimeters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicDecimeter);
         }
@@ -767,7 +744,7 @@ public static Volume FromCubicDecimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicFoot"/>.
         /// </summary>
-        public static Volume FromCubicFeet(double value)
+        public static Volume FromCubicFeet(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicFoot);
         }
@@ -775,7 +752,7 @@ public static Volume FromCubicFeet(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicHectometer"/>.
         /// </summary>
-        public static Volume FromCubicHectometers(double value)
+        public static Volume FromCubicHectometers(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicHectometer);
         }
@@ -783,7 +760,7 @@ public static Volume FromCubicHectometers(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicInch"/>.
         /// </summary>
-        public static Volume FromCubicInches(double value)
+        public static Volume FromCubicInches(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicInch);
         }
@@ -791,7 +768,7 @@ public static Volume FromCubicInches(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicKilometer"/>.
         /// </summary>
-        public static Volume FromCubicKilometers(double value)
+        public static Volume FromCubicKilometers(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicKilometer);
         }
@@ -799,7 +776,7 @@ public static Volume FromCubicKilometers(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMeter"/>.
         /// </summary>
-        public static Volume FromCubicMeters(double value)
+        public static Volume FromCubicMeters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicMeter);
         }
@@ -807,7 +784,7 @@ public static Volume FromCubicMeters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMicrometer"/>.
         /// </summary>
-        public static Volume FromCubicMicrometers(double value)
+        public static Volume FromCubicMicrometers(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicMicrometer);
         }
@@ -815,7 +792,7 @@ public static Volume FromCubicMicrometers(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMile"/>.
         /// </summary>
-        public static Volume FromCubicMiles(double value)
+        public static Volume FromCubicMiles(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicMile);
         }
@@ -823,7 +800,7 @@ public static Volume FromCubicMiles(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMillimeter"/>.
         /// </summary>
-        public static Volume FromCubicMillimeters(double value)
+        public static Volume FromCubicMillimeters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicMillimeter);
         }
@@ -831,7 +808,7 @@ public static Volume FromCubicMillimeters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicYard"/>.
         /// </summary>
-        public static Volume FromCubicYards(double value)
+        public static Volume FromCubicYards(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.CubicYard);
         }
@@ -839,7 +816,7 @@ public static Volume FromCubicYards(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Decaliter"/>.
         /// </summary>
-        public static Volume FromDecaliters(double value)
+        public static Volume FromDecaliters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.Decaliter);
         }
@@ -847,7 +824,7 @@ public static Volume FromDecaliters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.DecausGallon"/>.
         /// </summary>
-        public static Volume FromDecausGallons(double value)
+        public static Volume FromDecausGallons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.DecausGallon);
         }
@@ -855,7 +832,7 @@ public static Volume FromDecausGallons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Deciliter"/>.
         /// </summary>
-        public static Volume FromDeciliters(double value)
+        public static Volume FromDeciliters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.Deciliter);
         }
@@ -863,47 +840,39 @@ public static Volume FromDeciliters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.DeciusGallon"/>.
         /// </summary>
-        public static Volume FromDeciusGallons(double value)
+        public static Volume FromDeciusGallons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.DeciusGallon);
         }
 
         /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectocubicFoot"/>.
-        /// </summary>
-        public static Volume FromHectocubicFeet(double value)
-        {
-            return new Volume(value, VolumeUnit.HectocubicFoot);
-        }
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectocubicMeter"/>.
+        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Hectoliter"/>.
         /// </summary>
-        public static Volume FromHectocubicMeters(double value)
+        public static Volume FromHectoliters(QuantityValue value)
         {
-            return new Volume(value, VolumeUnit.HectocubicMeter);
+            return new Volume(value, VolumeUnit.Hectoliter);
         }
 
         /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Hectoliter"/>.
+        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectousGallon"/>.
         /// </summary>
-        public static Volume FromHectoliters(double value)
+        public static Volume FromHectousGallons(QuantityValue value)
         {
-            return new Volume(value, VolumeUnit.Hectoliter);
+            return new Volume(value, VolumeUnit.HectousGallon);
         }
 
         /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectousGallon"/>.
+        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HundredCubicFoot"/>.
         /// </summary>
-        public static Volume FromHectousGallons(double value)
+        public static Volume FromHundredCubicFeet(QuantityValue value)
         {
-            return new Volume(value, VolumeUnit.HectousGallon);
+            return new Volume(value, VolumeUnit.HundredCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialBeerBarrel"/>.
         /// </summary>
-        public static Volume FromImperialBeerBarrels(double value)
+        public static Volume FromImperialBeerBarrels(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.ImperialBeerBarrel);
         }
@@ -911,7 +880,7 @@ public static Volume FromImperialBeerBarrels(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialGallon"/>.
         /// </summary>
-        public static Volume FromImperialGallons(double value)
+        public static Volume FromImperialGallons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.ImperialGallon);
         }
@@ -919,7 +888,7 @@ public static Volume FromImperialGallons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialOunce"/>.
         /// </summary>
-        public static Volume FromImperialOunces(double value)
+        public static Volume FromImperialOunces(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.ImperialOunce);
         }
@@ -927,7 +896,7 @@ public static Volume FromImperialOunces(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialPint"/>.
         /// </summary>
-        public static Volume FromImperialPints(double value)
+        public static Volume FromImperialPints(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.ImperialPint);
         }
@@ -935,31 +904,15 @@ public static Volume FromImperialPints(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialQuart"/>.
         /// </summary>
-        public static Volume FromImperialQuarts(double value)
+        public static Volume FromImperialQuarts(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.ImperialQuart);
         }
 
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilocubicFoot"/>.
-        /// </summary>
-        public static Volume FromKilocubicFeet(double value)
-        {
-            return new Volume(value, VolumeUnit.KilocubicFoot);
-        }
-
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilocubicMeter"/>.
-        /// </summary>
-        public static Volume FromKilocubicMeters(double value)
-        {
-            return new Volume(value, VolumeUnit.KilocubicMeter);
-        }
-
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KiloimperialGallon"/>.
         /// </summary>
-        public static Volume FromKiloimperialGallons(double value)
+        public static Volume FromKiloimperialGallons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.KiloimperialGallon);
         }
@@ -967,7 +920,7 @@ public static Volume FromKiloimperialGallons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Kiloliter"/>.
         /// </summary>
-        public static Volume FromKiloliters(double value)
+        public static Volume FromKiloliters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.Kiloliter);
         }
@@ -975,7 +928,7 @@ public static Volume FromKiloliters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilousGallon"/>.
         /// </summary>
-        public static Volume FromKilousGallons(double value)
+        public static Volume FromKilousGallons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.KilousGallon);
         }
@@ -983,23 +936,15 @@ public static Volume FromKilousGallons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Liter"/>.
         /// </summary>
-        public static Volume FromLiters(double value)
+        public static Volume FromLiters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.Liter);
         }
 
-        /// <summary>
-        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegacubicFoot"/>.
-        /// </summary>
-        public static Volume FromMegacubicFeet(double value)
-        {
-            return new Volume(value, VolumeUnit.MegacubicFoot);
-        }
-
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegaimperialGallon"/>.
         /// </summary>
-        public static Volume FromMegaimperialGallons(double value)
+        public static Volume FromMegaimperialGallons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.MegaimperialGallon);
         }
@@ -1007,7 +952,7 @@ public static Volume FromMegaimperialGallons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Megaliter"/>.
         /// </summary>
-        public static Volume FromMegaliters(double value)
+        public static Volume FromMegaliters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.Megaliter);
         }
@@ -1015,7 +960,7 @@ public static Volume FromMegaliters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegausGallon"/>.
         /// </summary>
-        public static Volume FromMegausGallons(double value)
+        public static Volume FromMegausGallons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.MegausGallon);
         }
@@ -1023,7 +968,7 @@ public static Volume FromMegausGallons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MetricCup"/>.
         /// </summary>
-        public static Volume FromMetricCups(double value)
+        public static Volume FromMetricCups(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.MetricCup);
         }
@@ -1031,7 +976,7 @@ public static Volume FromMetricCups(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MetricTablespoon"/>.
         /// </summary>
-        public static Volume FromMetricTablespoons(double value)
+        public static Volume FromMetricTablespoons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.MetricTablespoon);
         }
@@ -1039,7 +984,7 @@ public static Volume FromMetricTablespoons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MetricTeaspoon"/>.
         /// </summary>
-        public static Volume FromMetricTeaspoons(double value)
+        public static Volume FromMetricTeaspoons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.MetricTeaspoon);
         }
@@ -1047,7 +992,7 @@ public static Volume FromMetricTeaspoons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Microliter"/>.
         /// </summary>
-        public static Volume FromMicroliters(double value)
+        public static Volume FromMicroliters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.Microliter);
         }
@@ -1055,15 +1000,23 @@ public static Volume FromMicroliters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Milliliter"/>.
         /// </summary>
-        public static Volume FromMilliliters(double value)
+        public static Volume FromMilliliters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.Milliliter);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MillionCubicFoot"/>.
+        /// </summary>
+        public static Volume FromMillionCubicFeet(QuantityValue value)
+        {
+            return new Volume(value, VolumeUnit.MillionCubicFoot);
+        }
+
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Nanoliter"/>.
         /// </summary>
-        public static Volume FromNanoliters(double value)
+        public static Volume FromNanoliters(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.Nanoliter);
         }
@@ -1071,15 +1024,31 @@ public static Volume FromNanoliters(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.OilBarrel"/>.
         /// </summary>
-        public static Volume FromOilBarrels(double value)
+        public static Volume FromOilBarrels(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.OilBarrel);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ThousandCubicFoot"/>.
+        /// </summary>
+        public static Volume FromThousandCubicFeet(QuantityValue value)
+        {
+            return new Volume(value, VolumeUnit.ThousandCubicFoot);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ThousandCubicMeter"/>.
+        /// </summary>
+        public static Volume FromThousandCubicMeters(QuantityValue value)
+        {
+            return new Volume(value, VolumeUnit.ThousandCubicMeter);
+        }
+
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UkTablespoon"/>.
         /// </summary>
-        public static Volume FromUkTablespoons(double value)
+        public static Volume FromUkTablespoons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.UkTablespoon);
         }
@@ -1087,7 +1056,7 @@ public static Volume FromUkTablespoons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsBeerBarrel"/>.
         /// </summary>
-        public static Volume FromUsBeerBarrels(double value)
+        public static Volume FromUsBeerBarrels(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.UsBeerBarrel);
         }
@@ -1095,7 +1064,7 @@ public static Volume FromUsBeerBarrels(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsCustomaryCup"/>.
         /// </summary>
-        public static Volume FromUsCustomaryCups(double value)
+        public static Volume FromUsCustomaryCups(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.UsCustomaryCup);
         }
@@ -1103,7 +1072,7 @@ public static Volume FromUsCustomaryCups(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsGallon"/>.
         /// </summary>
-        public static Volume FromUsGallons(double value)
+        public static Volume FromUsGallons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.UsGallon);
         }
@@ -1111,7 +1080,7 @@ public static Volume FromUsGallons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsLegalCup"/>.
         /// </summary>
-        public static Volume FromUsLegalCups(double value)
+        public static Volume FromUsLegalCups(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.UsLegalCup);
         }
@@ -1119,7 +1088,7 @@ public static Volume FromUsLegalCups(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsOunce"/>.
         /// </summary>
-        public static Volume FromUsOunces(double value)
+        public static Volume FromUsOunces(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.UsOunce);
         }
@@ -1127,7 +1096,7 @@ public static Volume FromUsOunces(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsPint"/>.
         /// </summary>
-        public static Volume FromUsPints(double value)
+        public static Volume FromUsPints(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.UsPint);
         }
@@ -1135,7 +1104,7 @@ public static Volume FromUsPints(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsQuart"/>.
         /// </summary>
-        public static Volume FromUsQuarts(double value)
+        public static Volume FromUsQuarts(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.UsQuart);
         }
@@ -1143,7 +1112,7 @@ public static Volume FromUsQuarts(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsTablespoon"/>.
         /// </summary>
-        public static Volume FromUsTablespoons(double value)
+        public static Volume FromUsTablespoons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.UsTablespoon);
         }
@@ -1151,7 +1120,7 @@ public static Volume FromUsTablespoons(double value)
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsTeaspoon"/>.
         /// </summary>
-        public static Volume FromUsTeaspoons(double value)
+        public static Volume FromUsTeaspoons(QuantityValue value)
         {
             return new Volume(value, VolumeUnit.UsTeaspoon);
         }
@@ -1162,7 +1131,7 @@ public static Volume FromUsTeaspoons(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Volume unit value.</returns>
-        public static Volume From(double value, VolumeUnit fromUnit)
+        public static Volume From(QuantityValue value, VolumeUnit fromUnit)
         {
             return new Volume(value, fromUnit);
         }
@@ -1223,10 +1192,7 @@ public static Volume Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static Volume Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<Volume, VolumeUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<Volume, VolumeUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -1254,11 +1220,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out Volume result)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Volume result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<Volume, VolumeUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<Volume, VolumeUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -1279,7 +1241,7 @@ public static VolumeUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1290,7 +1252,7 @@ public static VolumeUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumeUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.VolumeUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1305,7 +1267,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeUnit u
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumeUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1324,35 +1286,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="Volume"/> from adding two <see cref="Volume"/>.</summary>
         public static Volume operator +(Volume left, Volume right)
         {
-            return new Volume(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new Volume(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Volume"/> from subtracting two <see cref="Volume"/>.</summary>
         public static Volume operator -(Volume left, Volume right)
         {
-            return new Volume(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new Volume(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="Volume"/> from multiplying value and <see cref="Volume"/>.</summary>
-        public static Volume operator *(double left, Volume right)
+        public static Volume operator *(QuantityValue left, Volume right)
         {
             return new Volume(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="Volume"/> from multiplying value and <see cref="Volume"/>.</summary>
-        public static Volume operator *(Volume left, double right)
+        public static Volume operator *(Volume left, QuantityValue right)
         {
             return new Volume(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="Volume"/> from dividing <see cref="Volume"/> by value.</summary>
-        public static Volume operator /(Volume left, double right)
+        public static Volume operator /(Volume left, QuantityValue right)
         {
             return new Volume(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="Volume"/> by <see cref="Volume"/>.</summary>
-        public static double operator /(Volume left, Volume right)
+        public static QuantityValue operator /(Volume left, Volume right)
         {
             return left.CubicMeters / right.CubicMeters;
         }
@@ -1391,12 +1353,24 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Duration.FromSeconds(volume.CubicMeters / volumeFlow.CubicMetersPerSecond);
         }
 
+        /// <summary>Get <see cref="ElectricCharge"/> from <see cref="Volume"/> * <see cref="ElectricChargeDensity"/>.</summary>
+        public static ElectricCharge operator *(Volume volume, ElectricChargeDensity electricChargeDensity)
+        {
+            return ElectricCharge.FromCoulombs(volume.CubicMeters * electricChargeDensity.CoulombsPerCubicMeter);
+        }
+
         /// <summary>Get <see cref="Energy"/> from <see cref="Volume"/> * <see cref="EnergyDensity"/>.</summary>
         public static Energy operator *(Volume volume, EnergyDensity energyDensity)
         {
             return Energy.FromJoules(volume.CubicMeters * energyDensity.JoulesPerCubicMeter);
         }
 
+        /// <summary>Get <see cref="Force"/> from <see cref="Volume"/> * <see cref="SpecificWeight"/>.</summary>
+        public static Force operator *(Volume volume, SpecificWeight specificWeight)
+        {
+            return Force.FromNewtons(volume.CubicMeters * specificWeight.NewtonsPerCubicMeter);
+        }
+
         /// <summary>Get <see cref="Length"/> from <see cref="Volume"/> * <see cref="ReciprocalArea"/>.</summary>
         public static Length operator *(Volume volume, ReciprocalArea reciprocalArea)
         {
@@ -1427,6 +1401,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Mass.FromKilograms(volume.CubicMeters / specificVolume.CubicMetersPerKilogram);
         }
 
+        /// <summary>Get <see cref="Power"/> from <see cref="Volume"/> * <see cref="PowerDensity"/>.</summary>
+        public static Power operator *(Volume volume, PowerDensity powerDensity)
+        {
+            return Power.FromWatts(volume.CubicMeters * powerDensity.WattsPerCubicMeter);
+        }
+
         /// <summary>Get <see cref="SpecificVolume"/> from <see cref="Volume"/> / <see cref="Mass"/>.</summary>
         public static SpecificVolume operator /(Volume volume, Mass mass)
         {
@@ -1446,97 +1426,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(Volume left, Volume right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(Volume left, Volume right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(Volume left, Volume right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(Volume left, Volume right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="Volume"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Volume other, Volume tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Volume"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(Volume)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(Volume left, Volume right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="Volume"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Volume other, Volume tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="Volume"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(Volume,Volume)"/>.
+        ///     See that operator (and <see cref="Equals(Volume)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(Volume left, Volume right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Volume"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Volume other, Volume tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="Volume"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="Volume"/>.
+        ///     When <paramref name="obj"/> is a <see cref="Volume"/>, this method delegates to
+        ///     <see cref="Equals(Volume)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is Volume otherQuantity))
+            if (obj is not Volume otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="Volume"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(Volume other, Volume tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="Volume"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(Volume other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current Volume.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(Volume), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="Volume"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(Volume)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is Volume otherQuantity)) throw new ArgumentException("Expected type Volume.", nameof(obj));
+            if (obj is not Volume otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<Volume>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="Volume"/> with another <see cref="Volume"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="Volume"/> with another <see cref="Volume"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1548,237 +1542,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(Volume other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(VolumeUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<VolumeUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this Volume to another Volume with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A Volume with the specified unit.</returns>
-        public Volume ToUnit(VolumeUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="Volume"/> to another <see cref="Volume"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A Volume with the specified unit.</returns>
-        public Volume ToUnit(VolumeUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(Volume), Unit, typeof(Volume), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (Volume)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="Volume"/> to another <see cref="Volume"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="Volume"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(VolumeUnit unit, [NotNullWhen(true)] out Volume? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            Volume? convertedOrNull = (Unit, unit) switch
-            {
-                // VolumeUnit -> BaseUnit
-                (VolumeUnit.AcreFoot, VolumeUnit.CubicMeter) => new Volume(_value * 1233.48183754752, VolumeUnit.CubicMeter),
-                (VolumeUnit.AuTablespoon, VolumeUnit.CubicMeter) => new Volume(_value * 2e-5, VolumeUnit.CubicMeter),
-                (VolumeUnit.BoardFoot, VolumeUnit.CubicMeter) => new Volume(_value * (0.028316846592 / 12), VolumeUnit.CubicMeter),
-                (VolumeUnit.Centiliter, VolumeUnit.CubicMeter) => new Volume((_value / 1e3) * 1e-2d, VolumeUnit.CubicMeter),
-                (VolumeUnit.CubicCentimeter, VolumeUnit.CubicMeter) => new Volume(_value / 1e6, VolumeUnit.CubicMeter),
-                (VolumeUnit.CubicDecimeter, VolumeUnit.CubicMeter) => new Volume(_value / 1e3, VolumeUnit.CubicMeter),
-                (VolumeUnit.CubicFoot, VolumeUnit.CubicMeter) => new Volume(_value * 0.028316846592, VolumeUnit.CubicMeter),
-                (VolumeUnit.CubicHectometer, VolumeUnit.CubicMeter) => new Volume(_value * 1e6, VolumeUnit.CubicMeter),
-                (VolumeUnit.CubicInch, VolumeUnit.CubicMeter) => new Volume(_value * 1.6387064e-5, VolumeUnit.CubicMeter),
-                (VolumeUnit.CubicKilometer, VolumeUnit.CubicMeter) => new Volume(_value * 1e9, VolumeUnit.CubicMeter),
-                (VolumeUnit.CubicMicrometer, VolumeUnit.CubicMeter) => new Volume(_value / 1e18, VolumeUnit.CubicMeter),
-                (VolumeUnit.CubicMile, VolumeUnit.CubicMeter) => new Volume(_value * 4.168181825440579584e9, VolumeUnit.CubicMeter),
-                (VolumeUnit.CubicMillimeter, VolumeUnit.CubicMeter) => new Volume(_value / 1e9, VolumeUnit.CubicMeter),
-                (VolumeUnit.CubicYard, VolumeUnit.CubicMeter) => new Volume(_value * 0.764554857984, VolumeUnit.CubicMeter),
-                (VolumeUnit.Decaliter, VolumeUnit.CubicMeter) => new Volume((_value / 1e3) * 1e1d, VolumeUnit.CubicMeter),
-                (VolumeUnit.DecausGallon, VolumeUnit.CubicMeter) => new Volume((_value * 0.003785411784) * 1e1d, VolumeUnit.CubicMeter),
-                (VolumeUnit.Deciliter, VolumeUnit.CubicMeter) => new Volume((_value / 1e3) * 1e-1d, VolumeUnit.CubicMeter),
-                (VolumeUnit.DeciusGallon, VolumeUnit.CubicMeter) => new Volume((_value * 0.003785411784) * 1e-1d, VolumeUnit.CubicMeter),
-                (VolumeUnit.HectocubicFoot, VolumeUnit.CubicMeter) => new Volume((_value * 0.028316846592) * 1e2d, VolumeUnit.CubicMeter),
-                (VolumeUnit.HectocubicMeter, VolumeUnit.CubicMeter) => new Volume((_value) * 1e2d, VolumeUnit.CubicMeter),
-                (VolumeUnit.Hectoliter, VolumeUnit.CubicMeter) => new Volume((_value / 1e3) * 1e2d, VolumeUnit.CubicMeter),
-                (VolumeUnit.HectousGallon, VolumeUnit.CubicMeter) => new Volume((_value * 0.003785411784) * 1e2d, VolumeUnit.CubicMeter),
-                (VolumeUnit.ImperialBeerBarrel, VolumeUnit.CubicMeter) => new Volume(_value * 0.16365924, VolumeUnit.CubicMeter),
-                (VolumeUnit.ImperialGallon, VolumeUnit.CubicMeter) => new Volume(_value * 0.00454609, VolumeUnit.CubicMeter),
-                (VolumeUnit.ImperialOunce, VolumeUnit.CubicMeter) => new Volume(_value * 2.84130625e-5, VolumeUnit.CubicMeter),
-                (VolumeUnit.ImperialPint, VolumeUnit.CubicMeter) => new Volume(_value * 5.6826125e-4, VolumeUnit.CubicMeter),
-                (VolumeUnit.ImperialQuart, VolumeUnit.CubicMeter) => new Volume(_value * 1.1365225e-3, VolumeUnit.CubicMeter),
-                (VolumeUnit.KilocubicFoot, VolumeUnit.CubicMeter) => new Volume((_value * 0.028316846592) * 1e3d, VolumeUnit.CubicMeter),
-                (VolumeUnit.KilocubicMeter, VolumeUnit.CubicMeter) => new Volume((_value) * 1e3d, VolumeUnit.CubicMeter),
-                (VolumeUnit.KiloimperialGallon, VolumeUnit.CubicMeter) => new Volume((_value * 0.00454609) * 1e3d, VolumeUnit.CubicMeter),
-                (VolumeUnit.Kiloliter, VolumeUnit.CubicMeter) => new Volume((_value / 1e3) * 1e3d, VolumeUnit.CubicMeter),
-                (VolumeUnit.KilousGallon, VolumeUnit.CubicMeter) => new Volume((_value * 0.003785411784) * 1e3d, VolumeUnit.CubicMeter),
-                (VolumeUnit.Liter, VolumeUnit.CubicMeter) => new Volume(_value / 1e3, VolumeUnit.CubicMeter),
-                (VolumeUnit.MegacubicFoot, VolumeUnit.CubicMeter) => new Volume((_value * 0.028316846592) * 1e6d, VolumeUnit.CubicMeter),
-                (VolumeUnit.MegaimperialGallon, VolumeUnit.CubicMeter) => new Volume((_value * 0.00454609) * 1e6d, VolumeUnit.CubicMeter),
-                (VolumeUnit.Megaliter, VolumeUnit.CubicMeter) => new Volume((_value / 1e3) * 1e6d, VolumeUnit.CubicMeter),
-                (VolumeUnit.MegausGallon, VolumeUnit.CubicMeter) => new Volume((_value * 0.003785411784) * 1e6d, VolumeUnit.CubicMeter),
-                (VolumeUnit.MetricCup, VolumeUnit.CubicMeter) => new Volume(_value * 0.00025, VolumeUnit.CubicMeter),
-                (VolumeUnit.MetricTablespoon, VolumeUnit.CubicMeter) => new Volume(_value * 1.5e-5, VolumeUnit.CubicMeter),
-                (VolumeUnit.MetricTeaspoon, VolumeUnit.CubicMeter) => new Volume(_value * 0.5e-5, VolumeUnit.CubicMeter),
-                (VolumeUnit.Microliter, VolumeUnit.CubicMeter) => new Volume((_value / 1e3) * 1e-6d, VolumeUnit.CubicMeter),
-                (VolumeUnit.Milliliter, VolumeUnit.CubicMeter) => new Volume((_value / 1e3) * 1e-3d, VolumeUnit.CubicMeter),
-                (VolumeUnit.Nanoliter, VolumeUnit.CubicMeter) => new Volume((_value / 1e3) * 1e-9d, VolumeUnit.CubicMeter),
-                (VolumeUnit.OilBarrel, VolumeUnit.CubicMeter) => new Volume(_value * 0.158987294928, VolumeUnit.CubicMeter),
-                (VolumeUnit.UkTablespoon, VolumeUnit.CubicMeter) => new Volume(_value * 1.5e-5, VolumeUnit.CubicMeter),
-                (VolumeUnit.UsBeerBarrel, VolumeUnit.CubicMeter) => new Volume(_value * 0.117347765304, VolumeUnit.CubicMeter),
-                (VolumeUnit.UsCustomaryCup, VolumeUnit.CubicMeter) => new Volume(_value * 0.0002365882365, VolumeUnit.CubicMeter),
-                (VolumeUnit.UsGallon, VolumeUnit.CubicMeter) => new Volume(_value * 0.003785411784, VolumeUnit.CubicMeter),
-                (VolumeUnit.UsLegalCup, VolumeUnit.CubicMeter) => new Volume(_value * 0.00024, VolumeUnit.CubicMeter),
-                (VolumeUnit.UsOunce, VolumeUnit.CubicMeter) => new Volume(_value * 2.95735295625e-5, VolumeUnit.CubicMeter),
-                (VolumeUnit.UsPint, VolumeUnit.CubicMeter) => new Volume(_value * 4.73176473e-4, VolumeUnit.CubicMeter),
-                (VolumeUnit.UsQuart, VolumeUnit.CubicMeter) => new Volume(_value * 9.46352946e-4, VolumeUnit.CubicMeter),
-                (VolumeUnit.UsTablespoon, VolumeUnit.CubicMeter) => new Volume(_value * 1.478676478125e-5, VolumeUnit.CubicMeter),
-                (VolumeUnit.UsTeaspoon, VolumeUnit.CubicMeter) => new Volume(_value * 4.92892159375e-6, VolumeUnit.CubicMeter),
-
-                // BaseUnit -> VolumeUnit
-                (VolumeUnit.CubicMeter, VolumeUnit.AcreFoot) => new Volume(_value / 1233.48183754752, VolumeUnit.AcreFoot),
-                (VolumeUnit.CubicMeter, VolumeUnit.AuTablespoon) => new Volume(_value / 2e-5, VolumeUnit.AuTablespoon),
-                (VolumeUnit.CubicMeter, VolumeUnit.BoardFoot) => new Volume(_value / (0.028316846592 / 12), VolumeUnit.BoardFoot),
-                (VolumeUnit.CubicMeter, VolumeUnit.Centiliter) => new Volume((_value * 1e3) / 1e-2d, VolumeUnit.Centiliter),
-                (VolumeUnit.CubicMeter, VolumeUnit.CubicCentimeter) => new Volume(_value * 1e6, VolumeUnit.CubicCentimeter),
-                (VolumeUnit.CubicMeter, VolumeUnit.CubicDecimeter) => new Volume(_value * 1e3, VolumeUnit.CubicDecimeter),
-                (VolumeUnit.CubicMeter, VolumeUnit.CubicFoot) => new Volume(_value / 0.028316846592, VolumeUnit.CubicFoot),
-                (VolumeUnit.CubicMeter, VolumeUnit.CubicHectometer) => new Volume(_value / 1e6, VolumeUnit.CubicHectometer),
-                (VolumeUnit.CubicMeter, VolumeUnit.CubicInch) => new Volume(_value / 1.6387064e-5, VolumeUnit.CubicInch),
-                (VolumeUnit.CubicMeter, VolumeUnit.CubicKilometer) => new Volume(_value / 1e9, VolumeUnit.CubicKilometer),
-                (VolumeUnit.CubicMeter, VolumeUnit.CubicMicrometer) => new Volume(_value * 1e18, VolumeUnit.CubicMicrometer),
-                (VolumeUnit.CubicMeter, VolumeUnit.CubicMile) => new Volume(_value / 4.168181825440579584e9, VolumeUnit.CubicMile),
-                (VolumeUnit.CubicMeter, VolumeUnit.CubicMillimeter) => new Volume(_value * 1e9, VolumeUnit.CubicMillimeter),
-                (VolumeUnit.CubicMeter, VolumeUnit.CubicYard) => new Volume(_value / 0.764554857984, VolumeUnit.CubicYard),
-                (VolumeUnit.CubicMeter, VolumeUnit.Decaliter) => new Volume((_value * 1e3) / 1e1d, VolumeUnit.Decaliter),
-                (VolumeUnit.CubicMeter, VolumeUnit.DecausGallon) => new Volume((_value / 0.003785411784) / 1e1d, VolumeUnit.DecausGallon),
-                (VolumeUnit.CubicMeter, VolumeUnit.Deciliter) => new Volume((_value * 1e3) / 1e-1d, VolumeUnit.Deciliter),
-                (VolumeUnit.CubicMeter, VolumeUnit.DeciusGallon) => new Volume((_value / 0.003785411784) / 1e-1d, VolumeUnit.DeciusGallon),
-                (VolumeUnit.CubicMeter, VolumeUnit.HectocubicFoot) => new Volume((_value / 0.028316846592) / 1e2d, VolumeUnit.HectocubicFoot),
-                (VolumeUnit.CubicMeter, VolumeUnit.HectocubicMeter) => new Volume((_value) / 1e2d, VolumeUnit.HectocubicMeter),
-                (VolumeUnit.CubicMeter, VolumeUnit.Hectoliter) => new Volume((_value * 1e3) / 1e2d, VolumeUnit.Hectoliter),
-                (VolumeUnit.CubicMeter, VolumeUnit.HectousGallon) => new Volume((_value / 0.003785411784) / 1e2d, VolumeUnit.HectousGallon),
-                (VolumeUnit.CubicMeter, VolumeUnit.ImperialBeerBarrel) => new Volume(_value / 0.16365924, VolumeUnit.ImperialBeerBarrel),
-                (VolumeUnit.CubicMeter, VolumeUnit.ImperialGallon) => new Volume(_value / 0.00454609, VolumeUnit.ImperialGallon),
-                (VolumeUnit.CubicMeter, VolumeUnit.ImperialOunce) => new Volume(_value / 2.84130625e-5, VolumeUnit.ImperialOunce),
-                (VolumeUnit.CubicMeter, VolumeUnit.ImperialPint) => new Volume(_value / 5.6826125e-4, VolumeUnit.ImperialPint),
-                (VolumeUnit.CubicMeter, VolumeUnit.ImperialQuart) => new Volume(_value / 1.1365225e-3, VolumeUnit.ImperialQuart),
-                (VolumeUnit.CubicMeter, VolumeUnit.KilocubicFoot) => new Volume((_value / 0.028316846592) / 1e3d, VolumeUnit.KilocubicFoot),
-                (VolumeUnit.CubicMeter, VolumeUnit.KilocubicMeter) => new Volume((_value) / 1e3d, VolumeUnit.KilocubicMeter),
-                (VolumeUnit.CubicMeter, VolumeUnit.KiloimperialGallon) => new Volume((_value / 0.00454609) / 1e3d, VolumeUnit.KiloimperialGallon),
-                (VolumeUnit.CubicMeter, VolumeUnit.Kiloliter) => new Volume((_value * 1e3) / 1e3d, VolumeUnit.Kiloliter),
-                (VolumeUnit.CubicMeter, VolumeUnit.KilousGallon) => new Volume((_value / 0.003785411784) / 1e3d, VolumeUnit.KilousGallon),
-                (VolumeUnit.CubicMeter, VolumeUnit.Liter) => new Volume(_value * 1e3, VolumeUnit.Liter),
-                (VolumeUnit.CubicMeter, VolumeUnit.MegacubicFoot) => new Volume((_value / 0.028316846592) / 1e6d, VolumeUnit.MegacubicFoot),
-                (VolumeUnit.CubicMeter, VolumeUnit.MegaimperialGallon) => new Volume((_value / 0.00454609) / 1e6d, VolumeUnit.MegaimperialGallon),
-                (VolumeUnit.CubicMeter, VolumeUnit.Megaliter) => new Volume((_value * 1e3) / 1e6d, VolumeUnit.Megaliter),
-                (VolumeUnit.CubicMeter, VolumeUnit.MegausGallon) => new Volume((_value / 0.003785411784) / 1e6d, VolumeUnit.MegausGallon),
-                (VolumeUnit.CubicMeter, VolumeUnit.MetricCup) => new Volume(_value / 0.00025, VolumeUnit.MetricCup),
-                (VolumeUnit.CubicMeter, VolumeUnit.MetricTablespoon) => new Volume(_value / 1.5e-5, VolumeUnit.MetricTablespoon),
-                (VolumeUnit.CubicMeter, VolumeUnit.MetricTeaspoon) => new Volume(_value / 0.5e-5, VolumeUnit.MetricTeaspoon),
-                (VolumeUnit.CubicMeter, VolumeUnit.Microliter) => new Volume((_value * 1e3) / 1e-6d, VolumeUnit.Microliter),
-                (VolumeUnit.CubicMeter, VolumeUnit.Milliliter) => new Volume((_value * 1e3) / 1e-3d, VolumeUnit.Milliliter),
-                (VolumeUnit.CubicMeter, VolumeUnit.Nanoliter) => new Volume((_value * 1e3) / 1e-9d, VolumeUnit.Nanoliter),
-                (VolumeUnit.CubicMeter, VolumeUnit.OilBarrel) => new Volume(_value / 0.158987294928, VolumeUnit.OilBarrel),
-                (VolumeUnit.CubicMeter, VolumeUnit.UkTablespoon) => new Volume(_value / 1.5e-5, VolumeUnit.UkTablespoon),
-                (VolumeUnit.CubicMeter, VolumeUnit.UsBeerBarrel) => new Volume(_value / 0.117347765304, VolumeUnit.UsBeerBarrel),
-                (VolumeUnit.CubicMeter, VolumeUnit.UsCustomaryCup) => new Volume(_value / 0.0002365882365, VolumeUnit.UsCustomaryCup),
-                (VolumeUnit.CubicMeter, VolumeUnit.UsGallon) => new Volume(_value / 0.003785411784, VolumeUnit.UsGallon),
-                (VolumeUnit.CubicMeter, VolumeUnit.UsLegalCup) => new Volume(_value / 0.00024, VolumeUnit.UsLegalCup),
-                (VolumeUnit.CubicMeter, VolumeUnit.UsOunce) => new Volume(_value / 2.95735295625e-5, VolumeUnit.UsOunce),
-                (VolumeUnit.CubicMeter, VolumeUnit.UsPint) => new Volume(_value / 4.73176473e-4, VolumeUnit.UsPint),
-                (VolumeUnit.CubicMeter, VolumeUnit.UsQuart) => new Volume(_value / 9.46352946e-4, VolumeUnit.UsQuart),
-                (VolumeUnit.CubicMeter, VolumeUnit.UsTablespoon) => new Volume(_value / 1.478676478125e-5, VolumeUnit.UsTablespoon),
-                (VolumeUnit.CubicMeter, VolumeUnit.UsTeaspoon) => new Volume(_value / 4.92892159375e-6, VolumeUnit.UsTeaspoon),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not VolumeUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is VolumeUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<VolumeUnit> IQuantity<VolumeUnit>.ToUnit(VolumeUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1792,11 +1558,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
index 2b33114983..ab7a1cdc96 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,12 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Concentration#Volume_concentration
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct VolumeConcentration :
-        IArithmeticQuantity<VolumeConcentration, VolumeConcentrationUnit>,
+        ILinearQuantity<VolumeConcentration, VolumeConcentrationUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<VolumeConcentration, VolumeConcentration, double>,
+        IDivisionOperators<VolumeConcentration, VolumeConcentration, QuantityValue>,
         IMultiplyOperators<VolumeConcentration, Density, MassConcentration>,
         IMultiplyOperators<VolumeConcentration, Molarity, Molarity>,
         IComparisonOperators<VolumeConcentration, VolumeConcentration, bool>,
@@ -57,7 +56,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -122,34 +121,70 @@ public static VolumeConcentrationInfo CreateDefault(Func<IEnumerable<UnitDefinit
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{VolumeConcentrationUnit}"/> representing the default unit mappings for VolumeConcentration.</returns>
             public static IEnumerable<UnitDefinition<VolumeConcentrationUnit>> GetDefaultMappings()
             {
-                yield return new (VolumeConcentrationUnit.CentiliterPerLiter, "CentiliterPerLiter", "CentilitersPerLiter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.CentiliterPerMilliliter, "CentiliterPerMilliliter", "CentilitersPerMilliliter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.DeciliterPerLiter, "DeciliterPerLiter", "DecilitersPerLiter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.DeciliterPerMilliliter, "DeciliterPerMilliliter", "DecilitersPerMilliliter", BaseUnits.Undefined);
+                yield return new (VolumeConcentrationUnit.CentiliterPerLiter, "CentiliterPerLiter", "CentilitersPerLiter", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (VolumeConcentrationUnit.CentiliterPerMilliliter, "CentiliterPerMilliliter", "CentilitersPerMilliliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 10)
+                );
+                yield return new (VolumeConcentrationUnit.DeciliterPerLiter, "DeciliterPerLiter", "DecilitersPerLiter", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (VolumeConcentrationUnit.DeciliterPerMilliliter, "DeciliterPerMilliliter", "DecilitersPerMilliliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 100)
+                );
                 yield return new (VolumeConcentrationUnit.DecimalFraction, "DecimalFraction", "DecimalFractions", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.LiterPerLiter, "LiterPerLiter", "LitersPerLiter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.LiterPerMilliliter, "LiterPerMilliliter", "LitersPerMilliliter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.MicroliterPerLiter, "MicroliterPerLiter", "MicrolitersPerLiter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.MicroliterPerMilliliter, "MicroliterPerMilliliter", "MicrolitersPerMilliliter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.MilliliterPerLiter, "MilliliterPerLiter", "MillilitersPerLiter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.MilliliterPerMilliliter, "MilliliterPerMilliliter", "MillilitersPerMilliliter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.NanoliterPerLiter, "NanoliterPerLiter", "NanolitersPerLiter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.NanoliterPerMilliliter, "NanoliterPerMilliliter", "NanolitersPerMilliliter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.PartPerBillion, "PartPerBillion", "PartsPerBillion", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.PartPerMillion, "PartPerMillion", "PartsPerMillion", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.PartPerThousand, "PartPerThousand", "PartsPerThousand", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.PartPerTrillion, "PartPerTrillion", "PartsPerTrillion", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.Percent, "Percent", "Percent", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.PicoliterPerLiter, "PicoliterPerLiter", "PicolitersPerLiter", BaseUnits.Undefined);
-                yield return new (VolumeConcentrationUnit.PicoliterPerMilliliter, "PicoliterPerMilliliter", "PicolitersPerMilliliter", BaseUnits.Undefined);
+                yield return new (VolumeConcentrationUnit.LiterPerLiter, "LiterPerLiter", "LitersPerLiter", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (VolumeConcentrationUnit.LiterPerMilliliter, "LiterPerMilliliter", "LitersPerMilliliter", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (VolumeConcentrationUnit.MicroliterPerLiter, "MicroliterPerLiter", "MicrolitersPerLiter", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (VolumeConcentrationUnit.MicroliterPerMilliliter, "MicroliterPerMilliliter", "MicrolitersPerMilliliter", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (VolumeConcentrationUnit.MilliliterPerLiter, "MilliliterPerLiter", "MillilitersPerLiter", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (VolumeConcentrationUnit.MilliliterPerMilliliter, "MilliliterPerMilliliter", "MillilitersPerMilliliter", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (VolumeConcentrationUnit.NanoliterPerLiter, "NanoliterPerLiter", "NanolitersPerLiter", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (VolumeConcentrationUnit.NanoliterPerMilliliter, "NanoliterPerMilliliter", "NanolitersPerMilliliter", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (VolumeConcentrationUnit.PartPerBillion, "PartPerBillion", "PartsPerBillion", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (VolumeConcentrationUnit.PartPerMillion, "PartPerMillion", "PartsPerMillion", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (VolumeConcentrationUnit.PartPerThousand, "PartPerThousand", "PartsPerThousand", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (VolumeConcentrationUnit.PartPerTrillion, "PartPerTrillion", "PartsPerTrillion", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (VolumeConcentrationUnit.Percent, "Percent", "Percent", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (VolumeConcentrationUnit.PicoliterPerLiter, "PicoliterPerLiter", "PicolitersPerLiter", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (VolumeConcentrationUnit.PicoliterPerMilliliter, "PicoliterPerMilliliter", "PicolitersPerMilliliter", BaseUnits.Undefined,
+                     1000000000
+                );
             }
         }
 
         static VolumeConcentration()
         {
-            Info = VolumeConcentrationInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(VolumeConcentrationInfo.CreateDefault);
         }
 
         /// <summary>
@@ -157,7 +192,7 @@ static VolumeConcentration()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VolumeConcentration(double value, VolumeConcentrationUnit unit)
+        public VolumeConcentration(QuantityValue value, VolumeConcentrationUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -168,7 +203,8 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="VolumeConcentration" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<VolumeConcentration, VolumeConcentrationUnit> Info { get; }
@@ -197,10 +233,8 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public VolumeConcentrationUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -234,161 +268,109 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.CentiliterPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.CentiliterPerLiter"/>
         /// </summary>
-        public double CentilitersPerLiter => As(VolumeConcentrationUnit.CentiliterPerLiter);
+        public QuantityValue CentilitersPerLiter => this.As(VolumeConcentrationUnit.CentiliterPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.CentiliterPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.CentiliterPerMilliliter"/>
         /// </summary>
-        public double CentilitersPerMilliliter => As(VolumeConcentrationUnit.CentiliterPerMilliliter);
+        public QuantityValue CentilitersPerMilliliter => this.As(VolumeConcentrationUnit.CentiliterPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.DeciliterPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.DeciliterPerLiter"/>
         /// </summary>
-        public double DecilitersPerLiter => As(VolumeConcentrationUnit.DeciliterPerLiter);
+        public QuantityValue DecilitersPerLiter => this.As(VolumeConcentrationUnit.DeciliterPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.DeciliterPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.DeciliterPerMilliliter"/>
         /// </summary>
-        public double DecilitersPerMilliliter => As(VolumeConcentrationUnit.DeciliterPerMilliliter);
+        public QuantityValue DecilitersPerMilliliter => this.As(VolumeConcentrationUnit.DeciliterPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.DecimalFraction"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.DecimalFraction"/>
         /// </summary>
-        public double DecimalFractions => As(VolumeConcentrationUnit.DecimalFraction);
+        public QuantityValue DecimalFractions => this.As(VolumeConcentrationUnit.DecimalFraction);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.LiterPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.LiterPerLiter"/>
         /// </summary>
-        public double LitersPerLiter => As(VolumeConcentrationUnit.LiterPerLiter);
+        public QuantityValue LitersPerLiter => this.As(VolumeConcentrationUnit.LiterPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.LiterPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.LiterPerMilliliter"/>
         /// </summary>
-        public double LitersPerMilliliter => As(VolumeConcentrationUnit.LiterPerMilliliter);
+        public QuantityValue LitersPerMilliliter => this.As(VolumeConcentrationUnit.LiterPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MicroliterPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MicroliterPerLiter"/>
         /// </summary>
-        public double MicrolitersPerLiter => As(VolumeConcentrationUnit.MicroliterPerLiter);
+        public QuantityValue MicrolitersPerLiter => this.As(VolumeConcentrationUnit.MicroliterPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MicroliterPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MicroliterPerMilliliter"/>
         /// </summary>
-        public double MicrolitersPerMilliliter => As(VolumeConcentrationUnit.MicroliterPerMilliliter);
+        public QuantityValue MicrolitersPerMilliliter => this.As(VolumeConcentrationUnit.MicroliterPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MilliliterPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MilliliterPerLiter"/>
         /// </summary>
-        public double MillilitersPerLiter => As(VolumeConcentrationUnit.MilliliterPerLiter);
+        public QuantityValue MillilitersPerLiter => this.As(VolumeConcentrationUnit.MilliliterPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MilliliterPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.MilliliterPerMilliliter"/>
         /// </summary>
-        public double MillilitersPerMilliliter => As(VolumeConcentrationUnit.MilliliterPerMilliliter);
+        public QuantityValue MillilitersPerMilliliter => this.As(VolumeConcentrationUnit.MilliliterPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.NanoliterPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.NanoliterPerLiter"/>
         /// </summary>
-        public double NanolitersPerLiter => As(VolumeConcentrationUnit.NanoliterPerLiter);
+        public QuantityValue NanolitersPerLiter => this.As(VolumeConcentrationUnit.NanoliterPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.NanoliterPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.NanoliterPerMilliliter"/>
         /// </summary>
-        public double NanolitersPerMilliliter => As(VolumeConcentrationUnit.NanoliterPerMilliliter);
+        public QuantityValue NanolitersPerMilliliter => this.As(VolumeConcentrationUnit.NanoliterPerMilliliter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerBillion"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerBillion"/>
         /// </summary>
-        public double PartsPerBillion => As(VolumeConcentrationUnit.PartPerBillion);
+        public QuantityValue PartsPerBillion => this.As(VolumeConcentrationUnit.PartPerBillion);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerMillion"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerMillion"/>
         /// </summary>
-        public double PartsPerMillion => As(VolumeConcentrationUnit.PartPerMillion);
+        public QuantityValue PartsPerMillion => this.As(VolumeConcentrationUnit.PartPerMillion);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerThousand"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerThousand"/>
         /// </summary>
-        public double PartsPerThousand => As(VolumeConcentrationUnit.PartPerThousand);
+        public QuantityValue PartsPerThousand => this.As(VolumeConcentrationUnit.PartPerThousand);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerTrillion"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PartPerTrillion"/>
         /// </summary>
-        public double PartsPerTrillion => As(VolumeConcentrationUnit.PartPerTrillion);
+        public QuantityValue PartsPerTrillion => this.As(VolumeConcentrationUnit.PartPerTrillion);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.Percent"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.Percent"/>
         /// </summary>
-        public double Percent => As(VolumeConcentrationUnit.Percent);
+        public QuantityValue Percent => this.As(VolumeConcentrationUnit.Percent);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PicoliterPerLiter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PicoliterPerLiter"/>
         /// </summary>
-        public double PicolitersPerLiter => As(VolumeConcentrationUnit.PicoliterPerLiter);
+        public QuantityValue PicolitersPerLiter => this.As(VolumeConcentrationUnit.PicoliterPerLiter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PicoliterPerMilliliter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeConcentrationUnit.PicoliterPerMilliliter"/>
         /// </summary>
-        public double PicolitersPerMilliliter => As(VolumeConcentrationUnit.PicoliterPerMilliliter);
+        public QuantityValue PicolitersPerMilliliter => this.As(VolumeConcentrationUnit.PicoliterPerMilliliter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: VolumeConcentrationUnit -> BaseUnit
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.CentiliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.CentiliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DeciliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DeciliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.LiterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.LiterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.MicroliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.MicroliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.MilliliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.MilliliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.NanoliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.NanoliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PartPerBillion, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PartPerMillion, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PartPerThousand, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PartPerTrillion, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.Percent, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PicoliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.PicoliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DecimalFraction, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> VolumeConcentrationUnit
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentiliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.CentiliterPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentiliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.CentiliterPerMilliliter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DeciliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.DeciliterPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DeciliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.DeciliterPerMilliliter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LiterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.LiterPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LiterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.LiterPerMilliliter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicroliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MicroliterPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicroliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MicroliterPerMilliliter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MilliliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MilliliterPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MilliliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MilliliterPerMilliliter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanoliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.NanoliterPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanoliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.NanoliterPerMilliliter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerBillion, quantity => quantity.ToUnit(VolumeConcentrationUnit.PartPerBillion));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerMillion, quantity => quantity.ToUnit(VolumeConcentrationUnit.PartPerMillion));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerThousand, quantity => quantity.ToUnit(VolumeConcentrationUnit.PartPerThousand));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerTrillion, quantity => quantity.ToUnit(VolumeConcentrationUnit.PartPerTrillion));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.Percent, quantity => quantity.ToUnit(VolumeConcentrationUnit.Percent));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicoliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.PicoliterPerLiter));
-            unitConverter.SetConversionFunction<VolumeConcentration>(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicoliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.PicoliterPerMilliliter));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -417,7 +399,7 @@ public static string GetAbbreviation(VolumeConcentrationUnit unit, IFormatProvid
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.CentiliterPerLiter"/>.
         /// </summary>
-        public static VolumeConcentration FromCentilitersPerLiter(double value)
+        public static VolumeConcentration FromCentilitersPerLiter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.CentiliterPerLiter);
         }
@@ -425,7 +407,7 @@ public static VolumeConcentration FromCentilitersPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.CentiliterPerMilliliter"/>.
         /// </summary>
-        public static VolumeConcentration FromCentilitersPerMilliliter(double value)
+        public static VolumeConcentration FromCentilitersPerMilliliter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.CentiliterPerMilliliter);
         }
@@ -433,7 +415,7 @@ public static VolumeConcentration FromCentilitersPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DeciliterPerLiter"/>.
         /// </summary>
-        public static VolumeConcentration FromDecilitersPerLiter(double value)
+        public static VolumeConcentration FromDecilitersPerLiter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.DeciliterPerLiter);
         }
@@ -441,7 +423,7 @@ public static VolumeConcentration FromDecilitersPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DeciliterPerMilliliter"/>.
         /// </summary>
-        public static VolumeConcentration FromDecilitersPerMilliliter(double value)
+        public static VolumeConcentration FromDecilitersPerMilliliter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.DeciliterPerMilliliter);
         }
@@ -449,7 +431,7 @@ public static VolumeConcentration FromDecilitersPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DecimalFraction"/>.
         /// </summary>
-        public static VolumeConcentration FromDecimalFractions(double value)
+        public static VolumeConcentration FromDecimalFractions(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.DecimalFraction);
         }
@@ -457,7 +439,7 @@ public static VolumeConcentration FromDecimalFractions(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.LiterPerLiter"/>.
         /// </summary>
-        public static VolumeConcentration FromLitersPerLiter(double value)
+        public static VolumeConcentration FromLitersPerLiter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.LiterPerLiter);
         }
@@ -465,7 +447,7 @@ public static VolumeConcentration FromLitersPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.LiterPerMilliliter"/>.
         /// </summary>
-        public static VolumeConcentration FromLitersPerMilliliter(double value)
+        public static VolumeConcentration FromLitersPerMilliliter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.LiterPerMilliliter);
         }
@@ -473,7 +455,7 @@ public static VolumeConcentration FromLitersPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MicroliterPerLiter"/>.
         /// </summary>
-        public static VolumeConcentration FromMicrolitersPerLiter(double value)
+        public static VolumeConcentration FromMicrolitersPerLiter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.MicroliterPerLiter);
         }
@@ -481,7 +463,7 @@ public static VolumeConcentration FromMicrolitersPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MicroliterPerMilliliter"/>.
         /// </summary>
-        public static VolumeConcentration FromMicrolitersPerMilliliter(double value)
+        public static VolumeConcentration FromMicrolitersPerMilliliter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.MicroliterPerMilliliter);
         }
@@ -489,7 +471,7 @@ public static VolumeConcentration FromMicrolitersPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MilliliterPerLiter"/>.
         /// </summary>
-        public static VolumeConcentration FromMillilitersPerLiter(double value)
+        public static VolumeConcentration FromMillilitersPerLiter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.MilliliterPerLiter);
         }
@@ -497,7 +479,7 @@ public static VolumeConcentration FromMillilitersPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MilliliterPerMilliliter"/>.
         /// </summary>
-        public static VolumeConcentration FromMillilitersPerMilliliter(double value)
+        public static VolumeConcentration FromMillilitersPerMilliliter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.MilliliterPerMilliliter);
         }
@@ -505,7 +487,7 @@ public static VolumeConcentration FromMillilitersPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.NanoliterPerLiter"/>.
         /// </summary>
-        public static VolumeConcentration FromNanolitersPerLiter(double value)
+        public static VolumeConcentration FromNanolitersPerLiter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.NanoliterPerLiter);
         }
@@ -513,7 +495,7 @@ public static VolumeConcentration FromNanolitersPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.NanoliterPerMilliliter"/>.
         /// </summary>
-        public static VolumeConcentration FromNanolitersPerMilliliter(double value)
+        public static VolumeConcentration FromNanolitersPerMilliliter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.NanoliterPerMilliliter);
         }
@@ -521,7 +503,7 @@ public static VolumeConcentration FromNanolitersPerMilliliter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerBillion"/>.
         /// </summary>
-        public static VolumeConcentration FromPartsPerBillion(double value)
+        public static VolumeConcentration FromPartsPerBillion(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerBillion);
         }
@@ -529,7 +511,7 @@ public static VolumeConcentration FromPartsPerBillion(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerMillion"/>.
         /// </summary>
-        public static VolumeConcentration FromPartsPerMillion(double value)
+        public static VolumeConcentration FromPartsPerMillion(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerMillion);
         }
@@ -537,7 +519,7 @@ public static VolumeConcentration FromPartsPerMillion(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerThousand"/>.
         /// </summary>
-        public static VolumeConcentration FromPartsPerThousand(double value)
+        public static VolumeConcentration FromPartsPerThousand(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerThousand);
         }
@@ -545,7 +527,7 @@ public static VolumeConcentration FromPartsPerThousand(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerTrillion"/>.
         /// </summary>
-        public static VolumeConcentration FromPartsPerTrillion(double value)
+        public static VolumeConcentration FromPartsPerTrillion(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerTrillion);
         }
@@ -553,7 +535,7 @@ public static VolumeConcentration FromPartsPerTrillion(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.Percent"/>.
         /// </summary>
-        public static VolumeConcentration FromPercent(double value)
+        public static VolumeConcentration FromPercent(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.Percent);
         }
@@ -561,7 +543,7 @@ public static VolumeConcentration FromPercent(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PicoliterPerLiter"/>.
         /// </summary>
-        public static VolumeConcentration FromPicolitersPerLiter(double value)
+        public static VolumeConcentration FromPicolitersPerLiter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.PicoliterPerLiter);
         }
@@ -569,7 +551,7 @@ public static VolumeConcentration FromPicolitersPerLiter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PicoliterPerMilliliter"/>.
         /// </summary>
-        public static VolumeConcentration FromPicolitersPerMilliliter(double value)
+        public static VolumeConcentration FromPicolitersPerMilliliter(QuantityValue value)
         {
             return new VolumeConcentration(value, VolumeConcentrationUnit.PicoliterPerMilliliter);
         }
@@ -580,7 +562,7 @@ public static VolumeConcentration FromPicolitersPerMilliliter(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VolumeConcentration unit value.</returns>
-        public static VolumeConcentration From(double value, VolumeConcentrationUnit fromUnit)
+        public static VolumeConcentration From(QuantityValue value, VolumeConcentrationUnit fromUnit)
         {
             return new VolumeConcentration(value, fromUnit);
         }
@@ -641,10 +623,7 @@ public static VolumeConcentration Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static VolumeConcentration Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<VolumeConcentration, VolumeConcentrationUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<VolumeConcentration, VolumeConcentrationUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -672,11 +651,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out VolumeConcentrat
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumeConcentration result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<VolumeConcentration, VolumeConcentrationUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<VolumeConcentration, VolumeConcentrationUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -697,7 +672,7 @@ public static VolumeConcentrationUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -708,7 +683,7 @@ public static VolumeConcentrationUnit ParseUnit(string str, IFormatProvider? pro
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumeConcentrationUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.VolumeConcentrationUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeConcentrationUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -723,7 +698,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeConcen
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumeConcentrationUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -742,35 +717,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="VolumeConcentration"/> from adding two <see cref="VolumeConcentration"/>.</summary>
         public static VolumeConcentration operator +(VolumeConcentration left, VolumeConcentration right)
         {
-            return new VolumeConcentration(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new VolumeConcentration(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VolumeConcentration"/> from subtracting two <see cref="VolumeConcentration"/>.</summary>
         public static VolumeConcentration operator -(VolumeConcentration left, VolumeConcentration right)
         {
-            return new VolumeConcentration(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new VolumeConcentration(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VolumeConcentration"/> from multiplying value and <see cref="VolumeConcentration"/>.</summary>
-        public static VolumeConcentration operator *(double left, VolumeConcentration right)
+        public static VolumeConcentration operator *(QuantityValue left, VolumeConcentration right)
         {
             return new VolumeConcentration(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="VolumeConcentration"/> from multiplying value and <see cref="VolumeConcentration"/>.</summary>
-        public static VolumeConcentration operator *(VolumeConcentration left, double right)
+        public static VolumeConcentration operator *(VolumeConcentration left, QuantityValue right)
         {
             return new VolumeConcentration(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="VolumeConcentration"/> from dividing <see cref="VolumeConcentration"/> by value.</summary>
-        public static VolumeConcentration operator /(VolumeConcentration left, double right)
+        public static VolumeConcentration operator /(VolumeConcentration left, QuantityValue right)
         {
             return new VolumeConcentration(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="VolumeConcentration"/> by <see cref="VolumeConcentration"/>.</summary>
-        public static double operator /(VolumeConcentration left, VolumeConcentration right)
+        public static QuantityValue operator /(VolumeConcentration left, VolumeConcentration right)
         {
             return left.DecimalFractions / right.DecimalFractions;
         }
@@ -798,97 +773,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(VolumeConcentration left, VolumeConcentration right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(VolumeConcentration left, VolumeConcentration right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(VolumeConcentration left, VolumeConcentration right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(VolumeConcentration left, VolumeConcentration right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="VolumeConcentration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VolumeConcentration other, VolumeConcentration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VolumeConcentration"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(VolumeConcentration)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(VolumeConcentration left, VolumeConcentration right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="VolumeConcentration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VolumeConcentration other, VolumeConcentration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VolumeConcentration"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(VolumeConcentration,VolumeConcentration)"/>.
+        ///     See that operator (and <see cref="Equals(VolumeConcentration)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(VolumeConcentration left, VolumeConcentration right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VolumeConcentration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VolumeConcentration other, VolumeConcentration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="VolumeConcentration"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="VolumeConcentration"/>.
+        ///     When <paramref name="obj"/> is a <see cref="VolumeConcentration"/>, this method delegates to
+        ///     <see cref="Equals(VolumeConcentration)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is VolumeConcentration otherQuantity))
+            if (obj is not VolumeConcentration otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VolumeConcentration"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VolumeConcentration other, VolumeConcentration tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="VolumeConcentration"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(VolumeConcentration other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current VolumeConcentration.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(VolumeConcentration), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="VolumeConcentration"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(VolumeConcentration)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is VolumeConcentration otherQuantity)) throw new ArgumentException("Expected type VolumeConcentration.", nameof(obj));
+            if (obj is not VolumeConcentration otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<VolumeConcentration>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="VolumeConcentration"/> with another <see cref="VolumeConcentration"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="VolumeConcentration"/> with another <see cref="VolumeConcentration"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -900,167 +889,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(VolumeConcentration other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(VolumeConcentrationUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<VolumeConcentrationUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this VolumeConcentration to another VolumeConcentration with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A VolumeConcentration with the specified unit.</returns>
-        public VolumeConcentration ToUnit(VolumeConcentrationUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="VolumeConcentration"/> to another <see cref="VolumeConcentration"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A VolumeConcentration with the specified unit.</returns>
-        public VolumeConcentration ToUnit(VolumeConcentrationUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(VolumeConcentration), Unit, typeof(VolumeConcentration), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (VolumeConcentration)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="VolumeConcentration"/> to another <see cref="VolumeConcentration"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="VolumeConcentration"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(VolumeConcentrationUnit unit, [NotNullWhen(true)] out VolumeConcentration? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            VolumeConcentration? convertedOrNull = (Unit, unit) switch
-            {
-                // VolumeConcentrationUnit -> BaseUnit
-                (VolumeConcentrationUnit.CentiliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-2d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.CentiliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-2d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.DeciliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-1d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.DeciliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-1d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.LiterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.LiterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e-3, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.MicroliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-6d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.MicroliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-6d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.MilliliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-3d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.MilliliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-3d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.NanoliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-9d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.NanoliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-9d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.PartPerBillion, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e9, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.PartPerMillion, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e6, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.PartPerThousand, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e3, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.PartPerTrillion, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e12, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.Percent, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e2, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.PicoliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-12d, VolumeConcentrationUnit.DecimalFraction),
-                (VolumeConcentrationUnit.PicoliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-12d, VolumeConcentrationUnit.DecimalFraction),
-
-                // BaseUnit -> VolumeConcentrationUnit
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentiliterPerLiter) => new VolumeConcentration((_value) / 1e-2d, VolumeConcentrationUnit.CentiliterPerLiter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentiliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-2d, VolumeConcentrationUnit.CentiliterPerMilliliter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DeciliterPerLiter) => new VolumeConcentration((_value) / 1e-1d, VolumeConcentrationUnit.DeciliterPerLiter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DeciliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-1d, VolumeConcentrationUnit.DeciliterPerMilliliter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LiterPerLiter) => new VolumeConcentration(_value, VolumeConcentrationUnit.LiterPerLiter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LiterPerMilliliter) => new VolumeConcentration(_value * 1e-3, VolumeConcentrationUnit.LiterPerMilliliter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicroliterPerLiter) => new VolumeConcentration((_value) / 1e-6d, VolumeConcentrationUnit.MicroliterPerLiter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicroliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-6d, VolumeConcentrationUnit.MicroliterPerMilliliter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MilliliterPerLiter) => new VolumeConcentration((_value) / 1e-3d, VolumeConcentrationUnit.MilliliterPerLiter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MilliliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-3d, VolumeConcentrationUnit.MilliliterPerMilliliter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanoliterPerLiter) => new VolumeConcentration((_value) / 1e-9d, VolumeConcentrationUnit.NanoliterPerLiter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanoliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-9d, VolumeConcentrationUnit.NanoliterPerMilliliter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerBillion) => new VolumeConcentration(_value * 1e9, VolumeConcentrationUnit.PartPerBillion),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerMillion) => new VolumeConcentration(_value * 1e6, VolumeConcentrationUnit.PartPerMillion),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerThousand) => new VolumeConcentration(_value * 1e3, VolumeConcentrationUnit.PartPerThousand),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerTrillion) => new VolumeConcentration(_value * 1e12, VolumeConcentrationUnit.PartPerTrillion),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.Percent) => new VolumeConcentration(_value * 1e2, VolumeConcentrationUnit.Percent),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicoliterPerLiter) => new VolumeConcentration((_value) / 1e-12d, VolumeConcentrationUnit.PicoliterPerLiter),
-                (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicoliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-12d, VolumeConcentrationUnit.PicoliterPerMilliliter),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not VolumeConcentrationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeConcentrationUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is VolumeConcentrationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeConcentrationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<VolumeConcentrationUnit> IQuantity<VolumeConcentrationUnit>.ToUnit(VolumeConcentrationUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -1074,11 +905,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
index 95ab4f9d45..884e08ce77 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,14 +33,17 @@ namespace UnitsNet
     ///     In physics and engineering, in particular fluid dynamics and hydrometry, the volumetric flow rate, (also known as volume flow rate, rate of fluid flow or volume velocity) is the volume of fluid which passes through a given surface per unit time. The SI unit is m³/s (cubic meters per second). In US Customary Units and British Imperial Units, volumetric flow rate is often expressed as ft³/s (cubic feet per second). It is usually represented by the symbol Q.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct VolumeFlow :
-        IArithmeticQuantity<VolumeFlow, VolumeFlowUnit>,
+        ILinearQuantity<VolumeFlow, VolumeFlowUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<VolumeFlow, VolumeFlow, double>,
+        IDivisionOperators<VolumeFlow, VolumeFlow, QuantityValue>,
         IDivisionOperators<VolumeFlow, Speed, Area>,
+        IMultiplyOperators<VolumeFlow, Pressure, LeakRate>,
         IMultiplyOperators<VolumeFlow, Density, MassFlow>,
         IMultiplyOperators<VolumeFlow, Molarity, MolarFlow>,
+        IMultiplyOperators<VolumeFlow, FluidResistance, Pressure>,
         IDivisionOperators<VolumeFlow, Area, Speed>,
         IMultiplyOperators<VolumeFlow, Duration, Volume>,
         IComparisonOperators<VolumeFlow, VolumeFlow, bool>,
@@ -57,7 +58,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -107,7 +108,7 @@ public static VolumeFlowInfo CreateDefault(Func<IEnumerable<UnitDefinition<Volum
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="VolumeFlow"/> is [T^-1][L^3].
+            ///     The <see cref="BaseDimensions" /> for <see cref="VolumeFlow"/> is T^-1L^3.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(3, 0, -1, 0, 0, 0, 0);
 
@@ -122,89 +123,244 @@ public static VolumeFlowInfo CreateDefault(Func<IEnumerable<UnitDefinition<Volum
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{VolumeFlowUnit}"/> representing the default unit mappings for VolumeFlow.</returns>
             public static IEnumerable<UnitDefinition<VolumeFlowUnit>> GetDefaultMappings()
             {
-                yield return new (VolumeFlowUnit.AcreFootPerDay, "AcreFootPerDay", "AcreFeetPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.AcreFootPerHour, "AcreFootPerHour", "AcreFeetPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.AcreFootPerMinute, "AcreFootPerMinute", "AcreFeetPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.AcreFootPerSecond, "AcreFootPerSecond", "AcreFeetPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.CentiliterPerDay, "CentiliterPerDay", "CentilitersPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.CentiliterPerHour, "CentiliterPerHour", "CentilitersPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.CentiliterPerMinute, "CentiliterPerMinute", "CentilitersPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.CentiliterPerSecond, "CentiliterPerSecond", "CentilitersPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.CubicCentimeterPerMinute, "CubicCentimeterPerMinute", "CubicCentimetersPerMinute", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Minute));
-                yield return new (VolumeFlowUnit.CubicDecimeterPerMinute, "CubicDecimeterPerMinute", "CubicDecimetersPerMinute", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Minute));
-                yield return new (VolumeFlowUnit.CubicFootPerHour, "CubicFootPerHour", "CubicFeetPerHour", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Hour));
-                yield return new (VolumeFlowUnit.CubicFootPerMinute, "CubicFootPerMinute", "CubicFeetPerMinute", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Minute));
-                yield return new (VolumeFlowUnit.CubicFootPerSecond, "CubicFootPerSecond", "CubicFeetPerSecond", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second));
-                yield return new (VolumeFlowUnit.CubicMeterPerDay, "CubicMeterPerDay", "CubicMetersPerDay", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Day));
-                yield return new (VolumeFlowUnit.CubicMeterPerHour, "CubicMeterPerHour", "CubicMetersPerHour", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Hour));
-                yield return new (VolumeFlowUnit.CubicMeterPerMinute, "CubicMeterPerMinute", "CubicMetersPerMinute", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Minute));
+                yield return new (VolumeFlowUnit.AcreFootPerDay, "AcreFootPerDay", "AcreFeetPerDay", BaseUnits.Undefined,
+                     new QuantityValue(156250000000, 2230689087)
+                );
+                yield return new (VolumeFlowUnit.AcreFootPerHour, "AcreFootPerHour", "AcreFeetPerHour", BaseUnits.Undefined,
+                     new QuantityValue(19531250000, 6692067261)
+                );
+                yield return new (VolumeFlowUnit.AcreFootPerMinute, "AcreFootPerMinute", "AcreFeetPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(976562500, 20076201783)
+                );
+                yield return new (VolumeFlowUnit.AcreFootPerSecond, "AcreFootPerSecond", "AcreFeetPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(48828125, 60228605349)
+                );
+                yield return new (VolumeFlowUnit.CentiliterPerDay, "CentiliterPerDay", "CentilitersPerDay", BaseUnits.Undefined,
+                     8640000000
+                );
+                yield return new (VolumeFlowUnit.CentiliterPerHour, "CentiliterPerHour", "CentilitersPerHour", BaseUnits.Undefined,
+                     360000000
+                );
+                yield return new (VolumeFlowUnit.CentiliterPerMinute, "CentiliterPerMinute", "CentilitersPerMinute", BaseUnits.Undefined,
+                     6000000
+                );
+                yield return new (VolumeFlowUnit.CentiliterPerSecond, "CentiliterPerSecond", "CentilitersPerSecond", BaseUnits.Undefined,
+                     100000
+                );
+                yield return new (VolumeFlowUnit.CubicCentimeterPerMinute, "CubicCentimeterPerMinute", "CubicCentimetersPerMinute", new BaseUnits(length: LengthUnit.Centimeter, time: DurationUnit.Minute),
+                     60000000
+                );
+                yield return new (VolumeFlowUnit.CubicDecimeterPerMinute, "CubicDecimeterPerMinute", "CubicDecimetersPerMinute", new BaseUnits(length: LengthUnit.Decimeter, time: DurationUnit.Minute),
+                     60000
+                );
+                yield return new (VolumeFlowUnit.CubicFootPerHour, "CubicFootPerHour", "CubicFeetPerHour", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Hour),
+                     new QuantityValue(781250000000, 6145149)
+                );
+                yield return new (VolumeFlowUnit.CubicFootPerMinute, "CubicFootPerMinute", "CubicFeetPerMinute", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Minute),
+                     new QuantityValue(39062500000, 18435447)
+                );
+                yield return new (VolumeFlowUnit.CubicFootPerSecond, "CubicFootPerSecond", "CubicFeetPerSecond", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Second),
+                     new QuantityValue(1953125000, 55306341)
+                );
+                yield return new (VolumeFlowUnit.CubicInchPerMinute, "CubicInchPerMinute", "CubicInchesPerMinute", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Minute),
+                     new QuantityValue(7500000000000, 2048383)
+                );
+                yield return new (VolumeFlowUnit.CubicInchPerSecond, "CubicInchPerSecond", "CubicInchesPerSecond", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Second),
+                     new QuantityValue(125000000000, 2048383)
+                );
+                yield return new (VolumeFlowUnit.CubicMeterPerDay, "CubicMeterPerDay", "CubicMetersPerDay", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Day),
+                     86400
+                );
+                yield return new (VolumeFlowUnit.CubicMeterPerHour, "CubicMeterPerHour", "CubicMetersPerHour", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Hour),
+                     3600
+                );
+                yield return new (VolumeFlowUnit.CubicMeterPerMinute, "CubicMeterPerMinute", "CubicMetersPerMinute", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Minute),
+                     60
+                );
                 yield return new (VolumeFlowUnit.CubicMeterPerSecond, "CubicMeterPerSecond", "CubicMetersPerSecond", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
-                yield return new (VolumeFlowUnit.CubicMillimeterPerSecond, "CubicMillimeterPerSecond", "CubicMillimetersPerSecond", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second));
-                yield return new (VolumeFlowUnit.CubicYardPerDay, "CubicYardPerDay", "CubicYardsPerDay", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Day));
-                yield return new (VolumeFlowUnit.CubicYardPerHour, "CubicYardPerHour", "CubicYardsPerHour", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Hour));
-                yield return new (VolumeFlowUnit.CubicYardPerMinute, "CubicYardPerMinute", "CubicYardsPerMinute", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Minute));
-                yield return new (VolumeFlowUnit.CubicYardPerSecond, "CubicYardPerSecond", "CubicYardsPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.DecaliterPerDay, "DecaliterPerDay", "DecalitersPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.DecaliterPerHour, "DecaliterPerHour", "DecalitersPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.DecaliterPerMinute, "DecaliterPerMinute", "DecalitersPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.DecaliterPerSecond, "DecaliterPerSecond", "DecalitersPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.DeciliterPerDay, "DeciliterPerDay", "DecilitersPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.DeciliterPerHour, "DeciliterPerHour", "DecilitersPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.DeciliterPerMinute, "DeciliterPerMinute", "DecilitersPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.DeciliterPerSecond, "DeciliterPerSecond", "DecilitersPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.HectoliterPerDay, "HectoliterPerDay", "HectolitersPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.HectoliterPerHour, "HectoliterPerHour", "HectolitersPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.HectoliterPerMinute, "HectoliterPerMinute", "HectolitersPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.HectoliterPerSecond, "HectoliterPerSecond", "HectolitersPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.KiloliterPerDay, "KiloliterPerDay", "KilolitersPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.KiloliterPerHour, "KiloliterPerHour", "KilolitersPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.KiloliterPerMinute, "KiloliterPerMinute", "KilolitersPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.KiloliterPerSecond, "KiloliterPerSecond", "KilolitersPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.KilousGallonPerMinute, "KilousGallonPerMinute", "KilousGallonsPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.LiterPerDay, "LiterPerDay", "LitersPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.LiterPerHour, "LiterPerHour", "LitersPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.LiterPerMinute, "LiterPerMinute", "LitersPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.LiterPerSecond, "LiterPerSecond", "LitersPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MegaliterPerDay, "MegaliterPerDay", "MegalitersPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MegaliterPerHour, "MegaliterPerHour", "MegalitersPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MegaliterPerMinute, "MegaliterPerMinute", "MegalitersPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MegaliterPerSecond, "MegaliterPerSecond", "MegalitersPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MegaukGallonPerDay, "MegaukGallonPerDay", "MegaukGallonsPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MegaukGallonPerSecond, "MegaukGallonPerSecond", "MegaukGallonsPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MegausGallonPerDay, "MegausGallonPerDay", "MegausGallonsPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MicroliterPerDay, "MicroliterPerDay", "MicrolitersPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MicroliterPerHour, "MicroliterPerHour", "MicrolitersPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MicroliterPerMinute, "MicroliterPerMinute", "MicrolitersPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MicroliterPerSecond, "MicroliterPerSecond", "MicrolitersPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MilliliterPerDay, "MilliliterPerDay", "MillilitersPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MilliliterPerHour, "MilliliterPerHour", "MillilitersPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MilliliterPerMinute, "MilliliterPerMinute", "MillilitersPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MilliliterPerSecond, "MilliliterPerSecond", "MillilitersPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.MillionUsGallonPerDay, "MillionUsGallonPerDay", "MillionUsGallonsPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.NanoliterPerDay, "NanoliterPerDay", "NanolitersPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.NanoliterPerHour, "NanoliterPerHour", "NanolitersPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.NanoliterPerMinute, "NanoliterPerMinute", "NanolitersPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.NanoliterPerSecond, "NanoliterPerSecond", "NanolitersPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.OilBarrelPerDay, "OilBarrelPerDay", "OilBarrelsPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.OilBarrelPerHour, "OilBarrelPerHour", "OilBarrelsPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.OilBarrelPerMinute, "OilBarrelPerMinute", "OilBarrelsPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.OilBarrelPerSecond, "OilBarrelPerSecond", "OilBarrelsPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.UkGallonPerDay, "UkGallonPerDay", "UkGallonsPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.UkGallonPerHour, "UkGallonPerHour", "UkGallonsPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.UkGallonPerMinute, "UkGallonPerMinute", "UkGallonsPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.UkGallonPerSecond, "UkGallonPerSecond", "UkGallonsPerSecond", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.UsGallonPerDay, "UsGallonPerDay", "UsGallonsPerDay", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.UsGallonPerHour, "UsGallonPerHour", "UsGallonsPerHour", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.UsGallonPerMinute, "UsGallonPerMinute", "UsGallonsPerMinute", BaseUnits.Undefined);
-                yield return new (VolumeFlowUnit.UsGallonPerSecond, "UsGallonPerSecond", "UsGallonsPerSecond", BaseUnits.Undefined);
+                yield return new (VolumeFlowUnit.CubicMillimeterPerMinute, "CubicMillimeterPerMinute", "CubicMillimetersPerMinute", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Minute),
+                     60000000000
+                );
+                yield return new (VolumeFlowUnit.CubicMillimeterPerSecond, "CubicMillimeterPerSecond", "CubicMillimetersPerSecond", new BaseUnits(length: LengthUnit.Millimeter, time: DurationUnit.Second),
+                     1000000000
+                );
+                yield return new (VolumeFlowUnit.CubicYardPerDay, "CubicYardPerDay", "CubicYardsPerDay", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Day),
+                     new QuantityValue(6250000000000, 55306341)
+                );
+                yield return new (VolumeFlowUnit.CubicYardPerHour, "CubicYardPerHour", "CubicYardsPerHour", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Hour),
+                     new QuantityValue(781250000000, 165919023)
+                );
+                yield return new (VolumeFlowUnit.CubicYardPerMinute, "CubicYardPerMinute", "CubicYardsPerMinute", new BaseUnits(length: LengthUnit.Yard, time: DurationUnit.Minute),
+                     new QuantityValue(39062500000, 497757069)
+                );
+                yield return new (VolumeFlowUnit.CubicYardPerSecond, "CubicYardPerSecond", "CubicYardsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1953125000, 1493271207)
+                );
+                yield return new (VolumeFlowUnit.DecaliterPerDay, "DecaliterPerDay", "DecalitersPerDay", BaseUnits.Undefined,
+                     8640000
+                );
+                yield return new (VolumeFlowUnit.DecaliterPerHour, "DecaliterPerHour", "DecalitersPerHour", BaseUnits.Undefined,
+                     360000
+                );
+                yield return new (VolumeFlowUnit.DecaliterPerMinute, "DecaliterPerMinute", "DecalitersPerMinute", BaseUnits.Undefined,
+                     6000
+                );
+                yield return new (VolumeFlowUnit.DecaliterPerSecond, "DecaliterPerSecond", "DecalitersPerSecond", BaseUnits.Undefined,
+                     100
+                );
+                yield return new (VolumeFlowUnit.DeciliterPerDay, "DeciliterPerDay", "DecilitersPerDay", BaseUnits.Undefined,
+                     864000000
+                );
+                yield return new (VolumeFlowUnit.DeciliterPerHour, "DeciliterPerHour", "DecilitersPerHour", BaseUnits.Undefined,
+                     36000000
+                );
+                yield return new (VolumeFlowUnit.DeciliterPerMinute, "DeciliterPerMinute", "DecilitersPerMinute", BaseUnits.Undefined,
+                     600000
+                );
+                yield return new (VolumeFlowUnit.DeciliterPerSecond, "DeciliterPerSecond", "DecilitersPerSecond", BaseUnits.Undefined,
+                     10000
+                );
+                yield return new (VolumeFlowUnit.HectoliterPerDay, "HectoliterPerDay", "HectolitersPerDay", BaseUnits.Undefined,
+                     864000
+                );
+                yield return new (VolumeFlowUnit.HectoliterPerHour, "HectoliterPerHour", "HectolitersPerHour", BaseUnits.Undefined,
+                     36000
+                );
+                yield return new (VolumeFlowUnit.HectoliterPerMinute, "HectoliterPerMinute", "HectolitersPerMinute", BaseUnits.Undefined,
+                     600
+                );
+                yield return new (VolumeFlowUnit.HectoliterPerSecond, "HectoliterPerSecond", "HectolitersPerSecond", BaseUnits.Undefined,
+                     10
+                );
+                yield return new (VolumeFlowUnit.KiloliterPerDay, "KiloliterPerDay", "KilolitersPerDay", BaseUnits.Undefined,
+                     86400
+                );
+                yield return new (VolumeFlowUnit.KiloliterPerHour, "KiloliterPerHour", "KilolitersPerHour", BaseUnits.Undefined,
+                     3600
+                );
+                yield return new (VolumeFlowUnit.KiloliterPerMinute, "KiloliterPerMinute", "KilolitersPerMinute", BaseUnits.Undefined,
+                     60
+                );
+                yield return new (VolumeFlowUnit.KiloliterPerSecond, "KiloliterPerSecond", "KilolitersPerSecond", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (VolumeFlowUnit.KilousGallonPerMinute, "KilousGallonPerMinute", "KilousGallonsPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(2500000000, 157725491)
+                );
+                yield return new (VolumeFlowUnit.LiterPerDay, "LiterPerDay", "LitersPerDay", BaseUnits.Undefined,
+                     86400000
+                );
+                yield return new (VolumeFlowUnit.LiterPerHour, "LiterPerHour", "LitersPerHour", BaseUnits.Undefined,
+                     3600000
+                );
+                yield return new (VolumeFlowUnit.LiterPerMinute, "LiterPerMinute", "LitersPerMinute", BaseUnits.Undefined,
+                     60000
+                );
+                yield return new (VolumeFlowUnit.LiterPerSecond, "LiterPerSecond", "LitersPerSecond", BaseUnits.Undefined,
+                     1000
+                );
+                yield return new (VolumeFlowUnit.MegaliterPerDay, "MegaliterPerDay", "MegalitersPerDay", BaseUnits.Undefined,
+                     new QuantityValue(432, 5)
+                );
+                yield return new (VolumeFlowUnit.MegaliterPerHour, "MegaliterPerHour", "MegalitersPerHour", BaseUnits.Undefined,
+                     new QuantityValue(18, 5)
+                );
+                yield return new (VolumeFlowUnit.MegaliterPerMinute, "MegaliterPerMinute", "MegalitersPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(3, 50)
+                );
+                yield return new (VolumeFlowUnit.MegaliterPerSecond, "MegaliterPerSecond", "MegalitersPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (VolumeFlowUnit.MegaukGallonPerDay, "MegaukGallonPerDay", "MegaukGallonsPerDay", BaseUnits.Undefined,
+                     new QuantityValue(8640000, 454609)
+                );
+                yield return new (VolumeFlowUnit.MegaukGallonPerSecond, "MegaukGallonPerSecond", "MegaukGallonsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(100, 454609)
+                );
+                yield return new (VolumeFlowUnit.MegausGallonPerDay, "MegausGallonPerDay", "MegausGallonsPerDay", BaseUnits.Undefined,
+                     new QuantityValue(3600000000, 157725491)
+                );
+                yield return new (VolumeFlowUnit.MicroliterPerDay, "MicroliterPerDay", "MicrolitersPerDay", BaseUnits.Undefined,
+                     86400000000000
+                );
+                yield return new (VolumeFlowUnit.MicroliterPerHour, "MicroliterPerHour", "MicrolitersPerHour", BaseUnits.Undefined,
+                     3600000000000
+                );
+                yield return new (VolumeFlowUnit.MicroliterPerMinute, "MicroliterPerMinute", "MicrolitersPerMinute", BaseUnits.Undefined,
+                     60000000000
+                );
+                yield return new (VolumeFlowUnit.MicroliterPerSecond, "MicroliterPerSecond", "MicrolitersPerSecond", BaseUnits.Undefined,
+                     1000000000
+                );
+                yield return new (VolumeFlowUnit.MilliliterPerDay, "MilliliterPerDay", "MillilitersPerDay", BaseUnits.Undefined,
+                     86400000000
+                );
+                yield return new (VolumeFlowUnit.MilliliterPerHour, "MilliliterPerHour", "MillilitersPerHour", BaseUnits.Undefined,
+                     3600000000
+                );
+                yield return new (VolumeFlowUnit.MilliliterPerMinute, "MilliliterPerMinute", "MillilitersPerMinute", BaseUnits.Undefined,
+                     60000000
+                );
+                yield return new (VolumeFlowUnit.MilliliterPerSecond, "MilliliterPerSecond", "MillilitersPerSecond", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (VolumeFlowUnit.MillionUsGallonPerDay, "MillionUsGallonPerDay", "MillionUsGallonsPerDay", BaseUnits.Undefined,
+                     new QuantityValue(3600000000, 157725491)
+                );
+                yield return new (VolumeFlowUnit.NanoliterPerDay, "NanoliterPerDay", "NanolitersPerDay", BaseUnits.Undefined,
+                     86400000000000000
+                );
+                yield return new (VolumeFlowUnit.NanoliterPerHour, "NanoliterPerHour", "NanolitersPerHour", BaseUnits.Undefined,
+                     3600000000000000
+                );
+                yield return new (VolumeFlowUnit.NanoliterPerMinute, "NanoliterPerMinute", "NanolitersPerMinute", BaseUnits.Undefined,
+                     60000000000000
+                );
+                yield return new (VolumeFlowUnit.NanoliterPerSecond, "NanoliterPerSecond", "NanolitersPerSecond", BaseUnits.Undefined,
+                     1000000000000
+                );
+                yield return new (VolumeFlowUnit.OilBarrelPerDay, "OilBarrelPerDay", "OilBarrelsPerDay", BaseUnits.Undefined,
+                     new QuantityValue(600000000000000, 1104078437)
+                );
+                yield return new (VolumeFlowUnit.OilBarrelPerHour, "OilBarrelPerHour", "OilBarrelsPerHour", BaseUnits.Undefined,
+                     new QuantityValue(25000000000000, 1104078437)
+                );
+                yield return new (VolumeFlowUnit.OilBarrelPerMinute, "OilBarrelPerMinute", "OilBarrelsPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(1250000000000, 3312235311)
+                );
+                yield return new (VolumeFlowUnit.OilBarrelPerSecond, "OilBarrelPerSecond", "OilBarrelsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(62500000000, 9936705933)
+                );
+                yield return new (VolumeFlowUnit.UkGallonPerDay, "UkGallonPerDay", "UkGallonsPerDay", BaseUnits.Undefined,
+                     new QuantityValue(8640000000000, 454609)
+                );
+                yield return new (VolumeFlowUnit.UkGallonPerHour, "UkGallonPerHour", "UkGallonsPerHour", BaseUnits.Undefined,
+                     new QuantityValue(360000000000, 454609)
+                );
+                yield return new (VolumeFlowUnit.UkGallonPerMinute, "UkGallonPerMinute", "UkGallonsPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(6000000000, 454609)
+                );
+                yield return new (VolumeFlowUnit.UkGallonPerSecond, "UkGallonPerSecond", "UkGallonsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(100000000, 454609)
+                );
+                yield return new (VolumeFlowUnit.UsGallonPerDay, "UsGallonPerDay", "UsGallonsPerDay", BaseUnits.Undefined,
+                     new QuantityValue(3600000000000000, 157725491)
+                );
+                yield return new (VolumeFlowUnit.UsGallonPerHour, "UsGallonPerHour", "UsGallonsPerHour", BaseUnits.Undefined,
+                     new QuantityValue(150000000000000, 157725491)
+                );
+                yield return new (VolumeFlowUnit.UsGallonPerMinute, "UsGallonPerMinute", "UsGallonsPerMinute", BaseUnits.Undefined,
+                     new QuantityValue(2500000000000, 157725491)
+                );
+                yield return new (VolumeFlowUnit.UsGallonPerSecond, "UsGallonPerSecond", "UsGallonsPerSecond", BaseUnits.Undefined,
+                     new QuantityValue(125000000000, 473176473)
+                );
             }
         }
 
         static VolumeFlow()
         {
-            Info = VolumeFlowInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(VolumeFlowInfo.CreateDefault);
         }
 
         /// <summary>
@@ -212,7 +368,7 @@ static VolumeFlow()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VolumeFlow(double value, VolumeFlowUnit unit)
+        public VolumeFlow(QuantityValue value, VolumeFlowUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -226,7 +382,7 @@ public VolumeFlow(double value, VolumeFlowUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public VolumeFlow(double value, UnitSystem unitSystem)
+        public VolumeFlow(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -237,7 +393,8 @@ public VolumeFlow(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="VolumeFlow" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<VolumeFlow, VolumeFlowUnit> Info { get; }
@@ -266,10 +423,8 @@ public VolumeFlow(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public VolumeFlowUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -303,545 +458,398 @@ public VolumeFlow(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerDay"/>
         /// </summary>
-        public double AcreFeetPerDay => As(VolumeFlowUnit.AcreFootPerDay);
+        public QuantityValue AcreFeetPerDay => this.As(VolumeFlowUnit.AcreFootPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerHour"/>
         /// </summary>
-        public double AcreFeetPerHour => As(VolumeFlowUnit.AcreFootPerHour);
+        public QuantityValue AcreFeetPerHour => this.As(VolumeFlowUnit.AcreFootPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerMinute"/>
         /// </summary>
-        public double AcreFeetPerMinute => As(VolumeFlowUnit.AcreFootPerMinute);
+        public QuantityValue AcreFeetPerMinute => this.As(VolumeFlowUnit.AcreFootPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.AcreFootPerSecond"/>
         /// </summary>
-        public double AcreFeetPerSecond => As(VolumeFlowUnit.AcreFootPerSecond);
+        public QuantityValue AcreFeetPerSecond => this.As(VolumeFlowUnit.AcreFootPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerDay"/>
         /// </summary>
-        public double CentilitersPerDay => As(VolumeFlowUnit.CentiliterPerDay);
+        public QuantityValue CentilitersPerDay => this.As(VolumeFlowUnit.CentiliterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerHour"/>
         /// </summary>
-        public double CentilitersPerHour => As(VolumeFlowUnit.CentiliterPerHour);
+        public QuantityValue CentilitersPerHour => this.As(VolumeFlowUnit.CentiliterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerMinute"/>
         /// </summary>
-        public double CentilitersPerMinute => As(VolumeFlowUnit.CentiliterPerMinute);
+        public QuantityValue CentilitersPerMinute => this.As(VolumeFlowUnit.CentiliterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CentiliterPerSecond"/>
         /// </summary>
-        public double CentilitersPerSecond => As(VolumeFlowUnit.CentiliterPerSecond);
+        public QuantityValue CentilitersPerSecond => this.As(VolumeFlowUnit.CentiliterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicCentimeterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicCentimeterPerMinute"/>
         /// </summary>
-        public double CubicCentimetersPerMinute => As(VolumeFlowUnit.CubicCentimeterPerMinute);
+        public QuantityValue CubicCentimetersPerMinute => this.As(VolumeFlowUnit.CubicCentimeterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicDecimeterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicDecimeterPerMinute"/>
         /// </summary>
-        public double CubicDecimetersPerMinute => As(VolumeFlowUnit.CubicDecimeterPerMinute);
+        public QuantityValue CubicDecimetersPerMinute => this.As(VolumeFlowUnit.CubicDecimeterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicFootPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicFootPerHour"/>
         /// </summary>
-        public double CubicFeetPerHour => As(VolumeFlowUnit.CubicFootPerHour);
+        public QuantityValue CubicFeetPerHour => this.As(VolumeFlowUnit.CubicFootPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicFootPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicFootPerMinute"/>
         /// </summary>
-        public double CubicFeetPerMinute => As(VolumeFlowUnit.CubicFootPerMinute);
+        public QuantityValue CubicFeetPerMinute => this.As(VolumeFlowUnit.CubicFootPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicFootPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicFootPerSecond"/>
         /// </summary>
-        public double CubicFeetPerSecond => As(VolumeFlowUnit.CubicFootPerSecond);
+        public QuantityValue CubicFeetPerSecond => this.As(VolumeFlowUnit.CubicFootPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicInchPerMinute"/>
         /// </summary>
-        public double CubicMetersPerDay => As(VolumeFlowUnit.CubicMeterPerDay);
+        public QuantityValue CubicInchesPerMinute => this.As(VolumeFlowUnit.CubicInchPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicInchPerSecond"/>
         /// </summary>
-        public double CubicMetersPerHour => As(VolumeFlowUnit.CubicMeterPerHour);
+        public QuantityValue CubicInchesPerSecond => this.As(VolumeFlowUnit.CubicInchPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerDay"/>
         /// </summary>
-        public double CubicMetersPerMinute => As(VolumeFlowUnit.CubicMeterPerMinute);
+        public QuantityValue CubicMetersPerDay => this.As(VolumeFlowUnit.CubicMeterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerHour"/>
         /// </summary>
-        public double CubicMetersPerSecond => As(VolumeFlowUnit.CubicMeterPerSecond);
+        public QuantityValue CubicMetersPerHour => this.As(VolumeFlowUnit.CubicMeterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMillimeterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerMinute"/>
         /// </summary>
-        public double CubicMillimetersPerSecond => As(VolumeFlowUnit.CubicMillimeterPerSecond);
+        public QuantityValue CubicMetersPerMinute => this.As(VolumeFlowUnit.CubicMeterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMeterPerSecond"/>
         /// </summary>
-        public double CubicYardsPerDay => As(VolumeFlowUnit.CubicYardPerDay);
+        public QuantityValue CubicMetersPerSecond => this.As(VolumeFlowUnit.CubicMeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMillimeterPerMinute"/>
         /// </summary>
-        public double CubicYardsPerHour => As(VolumeFlowUnit.CubicYardPerHour);
+        public QuantityValue CubicMillimetersPerMinute => this.As(VolumeFlowUnit.CubicMillimeterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicMillimeterPerSecond"/>
         /// </summary>
-        public double CubicYardsPerMinute => As(VolumeFlowUnit.CubicYardPerMinute);
+        public QuantityValue CubicMillimetersPerSecond => this.As(VolumeFlowUnit.CubicMillimeterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerDay"/>
         /// </summary>
-        public double CubicYardsPerSecond => As(VolumeFlowUnit.CubicYardPerSecond);
+        public QuantityValue CubicYardsPerDay => this.As(VolumeFlowUnit.CubicYardPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerHour"/>
         /// </summary>
-        public double DecalitersPerDay => As(VolumeFlowUnit.DecaliterPerDay);
+        public QuantityValue CubicYardsPerHour => this.As(VolumeFlowUnit.CubicYardPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerMinute"/>
         /// </summary>
-        public double DecalitersPerHour => As(VolumeFlowUnit.DecaliterPerHour);
+        public QuantityValue CubicYardsPerMinute => this.As(VolumeFlowUnit.CubicYardPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.CubicYardPerSecond"/>
         /// </summary>
-        public double DecalitersPerMinute => As(VolumeFlowUnit.DecaliterPerMinute);
+        public QuantityValue CubicYardsPerSecond => this.As(VolumeFlowUnit.CubicYardPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerDay"/>
         /// </summary>
-        public double DecalitersPerSecond => As(VolumeFlowUnit.DecaliterPerSecond);
+        public QuantityValue DecalitersPerDay => this.As(VolumeFlowUnit.DecaliterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerHour"/>
         /// </summary>
-        public double DecilitersPerDay => As(VolumeFlowUnit.DeciliterPerDay);
+        public QuantityValue DecalitersPerHour => this.As(VolumeFlowUnit.DecaliterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerMinute"/>
         /// </summary>
-        public double DecilitersPerHour => As(VolumeFlowUnit.DeciliterPerHour);
+        public QuantityValue DecalitersPerMinute => this.As(VolumeFlowUnit.DecaliterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.DecaliterPerSecond"/>
         /// </summary>
-        public double DecilitersPerMinute => As(VolumeFlowUnit.DeciliterPerMinute);
+        public QuantityValue DecalitersPerSecond => this.As(VolumeFlowUnit.DecaliterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerDay"/>
         /// </summary>
-        public double DecilitersPerSecond => As(VolumeFlowUnit.DeciliterPerSecond);
+        public QuantityValue DecilitersPerDay => this.As(VolumeFlowUnit.DeciliterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerHour"/>
         /// </summary>
-        public double HectolitersPerDay => As(VolumeFlowUnit.HectoliterPerDay);
+        public QuantityValue DecilitersPerHour => this.As(VolumeFlowUnit.DeciliterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerMinute"/>
         /// </summary>
-        public double HectolitersPerHour => As(VolumeFlowUnit.HectoliterPerHour);
+        public QuantityValue DecilitersPerMinute => this.As(VolumeFlowUnit.DeciliterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.DeciliterPerSecond"/>
         /// </summary>
-        public double HectolitersPerMinute => As(VolumeFlowUnit.HectoliterPerMinute);
+        public QuantityValue DecilitersPerSecond => this.As(VolumeFlowUnit.DeciliterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerDay"/>
         /// </summary>
-        public double HectolitersPerSecond => As(VolumeFlowUnit.HectoliterPerSecond);
+        public QuantityValue HectolitersPerDay => this.As(VolumeFlowUnit.HectoliterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerHour"/>
         /// </summary>
-        public double KilolitersPerDay => As(VolumeFlowUnit.KiloliterPerDay);
+        public QuantityValue HectolitersPerHour => this.As(VolumeFlowUnit.HectoliterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerMinute"/>
         /// </summary>
-        public double KilolitersPerHour => As(VolumeFlowUnit.KiloliterPerHour);
+        public QuantityValue HectolitersPerMinute => this.As(VolumeFlowUnit.HectoliterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.HectoliterPerSecond"/>
         /// </summary>
-        public double KilolitersPerMinute => As(VolumeFlowUnit.KiloliterPerMinute);
+        public QuantityValue HectolitersPerSecond => this.As(VolumeFlowUnit.HectoliterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerDay"/>
         /// </summary>
-        public double KilolitersPerSecond => As(VolumeFlowUnit.KiloliterPerSecond);
+        public QuantityValue KilolitersPerDay => this.As(VolumeFlowUnit.KiloliterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.KilousGallonPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerHour"/>
         /// </summary>
-        public double KilousGallonsPerMinute => As(VolumeFlowUnit.KilousGallonPerMinute);
+        public QuantityValue KilolitersPerHour => this.As(VolumeFlowUnit.KiloliterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerMinute"/>
         /// </summary>
-        public double LitersPerDay => As(VolumeFlowUnit.LiterPerDay);
+        public QuantityValue KilolitersPerMinute => this.As(VolumeFlowUnit.KiloliterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.KiloliterPerSecond"/>
         /// </summary>
-        public double LitersPerHour => As(VolumeFlowUnit.LiterPerHour);
+        public QuantityValue KilolitersPerSecond => this.As(VolumeFlowUnit.KiloliterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.KilousGallonPerMinute"/>
         /// </summary>
-        public double LitersPerMinute => As(VolumeFlowUnit.LiterPerMinute);
+        public QuantityValue KilousGallonsPerMinute => this.As(VolumeFlowUnit.KilousGallonPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerDay"/>
         /// </summary>
-        public double LitersPerSecond => As(VolumeFlowUnit.LiterPerSecond);
+        public QuantityValue LitersPerDay => this.As(VolumeFlowUnit.LiterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerHour"/>
         /// </summary>
-        public double MegalitersPerDay => As(VolumeFlowUnit.MegaliterPerDay);
+        public QuantityValue LitersPerHour => this.As(VolumeFlowUnit.LiterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerMinute"/>
         /// </summary>
-        public double MegalitersPerHour => As(VolumeFlowUnit.MegaliterPerHour);
+        public QuantityValue LitersPerMinute => this.As(VolumeFlowUnit.LiterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.LiterPerSecond"/>
         /// </summary>
-        public double MegalitersPerMinute => As(VolumeFlowUnit.MegaliterPerMinute);
+        public QuantityValue LitersPerSecond => this.As(VolumeFlowUnit.LiterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerDay"/>
         /// </summary>
-        public double MegalitersPerSecond => As(VolumeFlowUnit.MegaliterPerSecond);
+        public QuantityValue MegalitersPerDay => this.As(VolumeFlowUnit.MegaliterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaukGallonPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerHour"/>
         /// </summary>
-        public double MegaukGallonsPerDay => As(VolumeFlowUnit.MegaukGallonPerDay);
+        public QuantityValue MegalitersPerHour => this.As(VolumeFlowUnit.MegaliterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaukGallonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerMinute"/>
         /// </summary>
-        public double MegaukGallonsPerSecond => As(VolumeFlowUnit.MegaukGallonPerSecond);
+        public QuantityValue MegalitersPerMinute => this.As(VolumeFlowUnit.MegaliterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegausGallonPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaliterPerSecond"/>
         /// </summary>
-        public double MegausGallonsPerDay => As(VolumeFlowUnit.MegausGallonPerDay);
+        public QuantityValue MegalitersPerSecond => this.As(VolumeFlowUnit.MegaliterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaukGallonPerDay"/>
         /// </summary>
-        public double MicrolitersPerDay => As(VolumeFlowUnit.MicroliterPerDay);
+        public QuantityValue MegaukGallonsPerDay => this.As(VolumeFlowUnit.MegaukGallonPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegaukGallonPerSecond"/>
         /// </summary>
-        public double MicrolitersPerHour => As(VolumeFlowUnit.MicroliterPerHour);
+        public QuantityValue MegaukGallonsPerSecond => this.As(VolumeFlowUnit.MegaukGallonPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MegausGallonPerDay"/>
         /// </summary>
-        public double MicrolitersPerMinute => As(VolumeFlowUnit.MicroliterPerMinute);
+        public QuantityValue MegausGallonsPerDay => this.As(VolumeFlowUnit.MegausGallonPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerDay"/>
         /// </summary>
-        public double MicrolitersPerSecond => As(VolumeFlowUnit.MicroliterPerSecond);
+        public QuantityValue MicrolitersPerDay => this.As(VolumeFlowUnit.MicroliterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerHour"/>
         /// </summary>
-        public double MillilitersPerDay => As(VolumeFlowUnit.MilliliterPerDay);
+        public QuantityValue MicrolitersPerHour => this.As(VolumeFlowUnit.MicroliterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerMinute"/>
         /// </summary>
-        public double MillilitersPerHour => As(VolumeFlowUnit.MilliliterPerHour);
+        public QuantityValue MicrolitersPerMinute => this.As(VolumeFlowUnit.MicroliterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MicroliterPerSecond"/>
         /// </summary>
-        public double MillilitersPerMinute => As(VolumeFlowUnit.MilliliterPerMinute);
+        public QuantityValue MicrolitersPerSecond => this.As(VolumeFlowUnit.MicroliterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerDay"/>
         /// </summary>
-        public double MillilitersPerSecond => As(VolumeFlowUnit.MilliliterPerSecond);
+        public QuantityValue MillilitersPerDay => this.As(VolumeFlowUnit.MilliliterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.MillionUsGallonPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerHour"/>
         /// </summary>
-        public double MillionUsGallonsPerDay => As(VolumeFlowUnit.MillionUsGallonPerDay);
+        public QuantityValue MillilitersPerHour => this.As(VolumeFlowUnit.MilliliterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerMinute"/>
         /// </summary>
-        public double NanolitersPerDay => As(VolumeFlowUnit.NanoliterPerDay);
+        public QuantityValue MillilitersPerMinute => this.As(VolumeFlowUnit.MilliliterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MilliliterPerSecond"/>
         /// </summary>
-        public double NanolitersPerHour => As(VolumeFlowUnit.NanoliterPerHour);
+        public QuantityValue MillilitersPerSecond => this.As(VolumeFlowUnit.MilliliterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.MillionUsGallonPerDay"/>
         /// </summary>
-        public double NanolitersPerMinute => As(VolumeFlowUnit.NanoliterPerMinute);
+        public QuantityValue MillionUsGallonsPerDay => this.As(VolumeFlowUnit.MillionUsGallonPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerDay"/>
         /// </summary>
-        public double NanolitersPerSecond => As(VolumeFlowUnit.NanoliterPerSecond);
+        public QuantityValue NanolitersPerDay => this.As(VolumeFlowUnit.NanoliterPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerHour"/>
         /// </summary>
-        public double OilBarrelsPerDay => As(VolumeFlowUnit.OilBarrelPerDay);
+        public QuantityValue NanolitersPerHour => this.As(VolumeFlowUnit.NanoliterPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerMinute"/>
         /// </summary>
-        public double OilBarrelsPerHour => As(VolumeFlowUnit.OilBarrelPerHour);
+        public QuantityValue NanolitersPerMinute => this.As(VolumeFlowUnit.NanoliterPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.NanoliterPerSecond"/>
         /// </summary>
-        public double OilBarrelsPerMinute => As(VolumeFlowUnit.OilBarrelPerMinute);
+        public QuantityValue NanolitersPerSecond => this.As(VolumeFlowUnit.NanoliterPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerDay"/>
         /// </summary>
-        public double OilBarrelsPerSecond => As(VolumeFlowUnit.OilBarrelPerSecond);
+        public QuantityValue OilBarrelsPerDay => this.As(VolumeFlowUnit.OilBarrelPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerHour"/>
         /// </summary>
-        public double UkGallonsPerDay => As(VolumeFlowUnit.UkGallonPerDay);
+        public QuantityValue OilBarrelsPerHour => this.As(VolumeFlowUnit.OilBarrelPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerMinute"/>
         /// </summary>
-        public double UkGallonsPerHour => As(VolumeFlowUnit.UkGallonPerHour);
+        public QuantityValue OilBarrelsPerMinute => this.As(VolumeFlowUnit.OilBarrelPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.OilBarrelPerSecond"/>
         /// </summary>
-        public double UkGallonsPerMinute => As(VolumeFlowUnit.UkGallonPerMinute);
+        public QuantityValue OilBarrelsPerSecond => this.As(VolumeFlowUnit.OilBarrelPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerDay"/>
         /// </summary>
-        public double UkGallonsPerSecond => As(VolumeFlowUnit.UkGallonPerSecond);
+        public QuantityValue UkGallonsPerDay => this.As(VolumeFlowUnit.UkGallonPerDay);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerDay"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerHour"/>
         /// </summary>
-        public double UsGallonsPerDay => As(VolumeFlowUnit.UsGallonPerDay);
+        public QuantityValue UkGallonsPerHour => this.As(VolumeFlowUnit.UkGallonPerHour);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerHour"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerMinute"/>
         /// </summary>
-        public double UsGallonsPerHour => As(VolumeFlowUnit.UsGallonPerHour);
+        public QuantityValue UkGallonsPerMinute => this.As(VolumeFlowUnit.UkGallonPerMinute);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerMinute"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.UkGallonPerSecond"/>
         /// </summary>
-        public double UsGallonsPerMinute => As(VolumeFlowUnit.UsGallonPerMinute);
+        public QuantityValue UkGallonsPerSecond => this.As(VolumeFlowUnit.UkGallonPerSecond);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerSecond"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerDay"/>
         /// </summary>
-        public double UsGallonsPerSecond => As(VolumeFlowUnit.UsGallonPerSecond);
+        public QuantityValue UsGallonsPerDay => this.As(VolumeFlowUnit.UsGallonPerDay);
 
-        #endregion
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerHour"/>
+        /// </summary>
+        public QuantityValue UsGallonsPerHour => this.As(VolumeFlowUnit.UsGallonPerHour);
 
-        #region Static Methods
+        /// <summary>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerMinute"/>
+        /// </summary>
+        public QuantityValue UsGallonsPerMinute => this.As(VolumeFlowUnit.UsGallonPerMinute);
 
         /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: VolumeFlowUnit -> BaseUnit
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.AcreFootPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.AcreFootPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.AcreFootPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.AcreFootPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CentiliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CentiliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CentiliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CentiliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicCentimeterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicDecimeterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicFootPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicFootPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicFootPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMillimeterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicYardPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicYardPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicYardPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicYardPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DecaliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DecaliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DecaliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DecaliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DeciliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DeciliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DeciliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.DeciliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.HectoliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.HectoliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.HectoliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.HectoliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.KiloliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.KiloliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.KiloliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.KiloliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.KilousGallonPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.LiterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.LiterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.LiterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.LiterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MegaliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MegaliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MegaliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MegaliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MegaukGallonPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MegaukGallonPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MegausGallonPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MicroliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MicroliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MicroliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MicroliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MilliliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MilliliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MilliliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MilliliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.MillionUsGallonPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.NanoliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.NanoliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.NanoliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.NanoliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.OilBarrelPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.OilBarrelPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.OilBarrelPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.OilBarrelPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UkGallonPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UkGallonPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UkGallonPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UkGallonPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UsGallonPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UsGallonPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UsGallonPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UsGallonPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> VolumeFlowUnit
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.AcreFootPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.AcreFootPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.AcreFootPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.AcreFootPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.AcreFootPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.AcreFootPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.AcreFootPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.AcreFootPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CentiliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.CentiliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CentiliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.CentiliterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CentiliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.CentiliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CentiliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CentiliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicCentimeterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.CubicCentimeterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicDecimeterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.CubicDecimeterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicFootPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.CubicFootPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicFootPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.CubicFootPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicFootPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicFootPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicMeterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicMeterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicMeterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicMillimeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMillimeterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.CubicYardPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.CubicYardPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.CubicYardPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicYardPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.DecaliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.DecaliterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.DecaliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.DecaliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.DeciliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.DeciliterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.DeciliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.DeciliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.HectoliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.HectoliterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.HectoliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.HectoliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.KiloliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.KiloliterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.KiloliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.KiloliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KilousGallonPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.KilousGallonPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.LiterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.LiterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.LiterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.LiterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.LiterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.LiterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.LiterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.LiterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.MegaliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.MegaliterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.MegaliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.MegaliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaukGallonPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.MegaukGallonPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaukGallonPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.MegaukGallonPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegausGallonPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.MegausGallonPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MicroliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.MicroliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MicroliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.MicroliterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MicroliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.MicroliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MicroliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.MicroliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MilliliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.MilliliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MilliliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.MilliliterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MilliliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.MilliliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MilliliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.MilliliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MillionUsGallonPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.MillionUsGallonPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.NanoliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.NanoliterPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.NanoliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.NanoliterPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.NanoliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.NanoliterPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.NanoliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.NanoliterPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.OilBarrelPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.OilBarrelPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.OilBarrelPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.OilBarrelPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.OilBarrelPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.OilBarrelPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.OilBarrelPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.OilBarrelPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UkGallonPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.UkGallonPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UkGallonPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.UkGallonPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UkGallonPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.UkGallonPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UkGallonPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.UkGallonPerSecond));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UsGallonPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.UsGallonPerDay));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UsGallonPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.UsGallonPerHour));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UsGallonPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.UsGallonPerMinute));
-            unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UsGallonPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.UsGallonPerSecond));
-        }
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowUnit.UsGallonPerSecond"/>
+        /// </summary>
+        public QuantityValue UsGallonsPerSecond => this.As(VolumeFlowUnit.UsGallonPerSecond);
+
+        #endregion
+
+        #region Static Methods
 
         /// <summary>
         ///     Get unit abbreviation string.
@@ -871,7 +879,7 @@ public static string GetAbbreviation(VolumeFlowUnit unit, IFormatProvider? provi
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromAcreFeetPerDay(double value)
+        public static VolumeFlow FromAcreFeetPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerDay);
         }
@@ -879,7 +887,7 @@ public static VolumeFlow FromAcreFeetPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromAcreFeetPerHour(double value)
+        public static VolumeFlow FromAcreFeetPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerHour);
         }
@@ -887,7 +895,7 @@ public static VolumeFlow FromAcreFeetPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromAcreFeetPerMinute(double value)
+        public static VolumeFlow FromAcreFeetPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerMinute);
         }
@@ -895,7 +903,7 @@ public static VolumeFlow FromAcreFeetPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromAcreFeetPerSecond(double value)
+        public static VolumeFlow FromAcreFeetPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerSecond);
         }
@@ -903,7 +911,7 @@ public static VolumeFlow FromAcreFeetPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromCentilitersPerDay(double value)
+        public static VolumeFlow FromCentilitersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerDay);
         }
@@ -911,7 +919,7 @@ public static VolumeFlow FromCentilitersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromCentilitersPerHour(double value)
+        public static VolumeFlow FromCentilitersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerHour);
         }
@@ -919,7 +927,7 @@ public static VolumeFlow FromCentilitersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromCentilitersPerMinute(double value)
+        public static VolumeFlow FromCentilitersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerMinute);
         }
@@ -927,7 +935,7 @@ public static VolumeFlow FromCentilitersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromCentilitersPerSecond(double value)
+        public static VolumeFlow FromCentilitersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerSecond);
         }
@@ -935,7 +943,7 @@ public static VolumeFlow FromCentilitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicCentimeterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromCubicCentimetersPerMinute(double value)
+        public static VolumeFlow FromCubicCentimetersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicCentimeterPerMinute);
         }
@@ -943,7 +951,7 @@ public static VolumeFlow FromCubicCentimetersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicDecimeterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromCubicDecimetersPerMinute(double value)
+        public static VolumeFlow FromCubicDecimetersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicDecimeterPerMinute);
         }
@@ -951,7 +959,7 @@ public static VolumeFlow FromCubicDecimetersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromCubicFeetPerHour(double value)
+        public static VolumeFlow FromCubicFeetPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerHour);
         }
@@ -959,7 +967,7 @@ public static VolumeFlow FromCubicFeetPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromCubicFeetPerMinute(double value)
+        public static VolumeFlow FromCubicFeetPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerMinute);
         }
@@ -967,15 +975,31 @@ public static VolumeFlow FromCubicFeetPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromCubicFeetPerSecond(double value)
+        public static VolumeFlow FromCubicFeetPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerSecond);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicInchPerMinute"/>.
+        /// </summary>
+        public static VolumeFlow FromCubicInchesPerMinute(QuantityValue value)
+        {
+            return new VolumeFlow(value, VolumeFlowUnit.CubicInchPerMinute);
+        }
+
+        /// <summary>
+        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicInchPerSecond"/>.
+        /// </summary>
+        public static VolumeFlow FromCubicInchesPerSecond(QuantityValue value)
+        {
+            return new VolumeFlow(value, VolumeFlowUnit.CubicInchPerSecond);
+        }
+
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromCubicMetersPerDay(double value)
+        public static VolumeFlow FromCubicMetersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerDay);
         }
@@ -983,7 +1007,7 @@ public static VolumeFlow FromCubicMetersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromCubicMetersPerHour(double value)
+        public static VolumeFlow FromCubicMetersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerHour);
         }
@@ -991,7 +1015,7 @@ public static VolumeFlow FromCubicMetersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromCubicMetersPerMinute(double value)
+        public static VolumeFlow FromCubicMetersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerMinute);
         }
@@ -999,15 +1023,23 @@ public static VolumeFlow FromCubicMetersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromCubicMetersPerSecond(double value)
+        public static VolumeFlow FromCubicMetersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerSecond);
         }
 
+        /// <summary>
+        ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMillimeterPerMinute"/>.
+        /// </summary>
+        public static VolumeFlow FromCubicMillimetersPerMinute(QuantityValue value)
+        {
+            return new VolumeFlow(value, VolumeFlowUnit.CubicMillimeterPerMinute);
+        }
+
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMillimeterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromCubicMillimetersPerSecond(double value)
+        public static VolumeFlow FromCubicMillimetersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicMillimeterPerSecond);
         }
@@ -1015,7 +1047,7 @@ public static VolumeFlow FromCubicMillimetersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromCubicYardsPerDay(double value)
+        public static VolumeFlow FromCubicYardsPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerDay);
         }
@@ -1023,7 +1055,7 @@ public static VolumeFlow FromCubicYardsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromCubicYardsPerHour(double value)
+        public static VolumeFlow FromCubicYardsPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerHour);
         }
@@ -1031,7 +1063,7 @@ public static VolumeFlow FromCubicYardsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromCubicYardsPerMinute(double value)
+        public static VolumeFlow FromCubicYardsPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerMinute);
         }
@@ -1039,7 +1071,7 @@ public static VolumeFlow FromCubicYardsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromCubicYardsPerSecond(double value)
+        public static VolumeFlow FromCubicYardsPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerSecond);
         }
@@ -1047,7 +1079,7 @@ public static VolumeFlow FromCubicYardsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DecaliterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromDecalitersPerDay(double value)
+        public static VolumeFlow FromDecalitersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.DecaliterPerDay);
         }
@@ -1055,7 +1087,7 @@ public static VolumeFlow FromDecalitersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DecaliterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromDecalitersPerHour(double value)
+        public static VolumeFlow FromDecalitersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.DecaliterPerHour);
         }
@@ -1063,7 +1095,7 @@ public static VolumeFlow FromDecalitersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DecaliterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromDecalitersPerMinute(double value)
+        public static VolumeFlow FromDecalitersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.DecaliterPerMinute);
         }
@@ -1071,7 +1103,7 @@ public static VolumeFlow FromDecalitersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DecaliterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromDecalitersPerSecond(double value)
+        public static VolumeFlow FromDecalitersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.DecaliterPerSecond);
         }
@@ -1079,7 +1111,7 @@ public static VolumeFlow FromDecalitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromDecilitersPerDay(double value)
+        public static VolumeFlow FromDecilitersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerDay);
         }
@@ -1087,7 +1119,7 @@ public static VolumeFlow FromDecilitersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromDecilitersPerHour(double value)
+        public static VolumeFlow FromDecilitersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerHour);
         }
@@ -1095,7 +1127,7 @@ public static VolumeFlow FromDecilitersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromDecilitersPerMinute(double value)
+        public static VolumeFlow FromDecilitersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerMinute);
         }
@@ -1103,7 +1135,7 @@ public static VolumeFlow FromDecilitersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromDecilitersPerSecond(double value)
+        public static VolumeFlow FromDecilitersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerSecond);
         }
@@ -1111,7 +1143,7 @@ public static VolumeFlow FromDecilitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.HectoliterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromHectolitersPerDay(double value)
+        public static VolumeFlow FromHectolitersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.HectoliterPerDay);
         }
@@ -1119,7 +1151,7 @@ public static VolumeFlow FromHectolitersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.HectoliterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromHectolitersPerHour(double value)
+        public static VolumeFlow FromHectolitersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.HectoliterPerHour);
         }
@@ -1127,7 +1159,7 @@ public static VolumeFlow FromHectolitersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.HectoliterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromHectolitersPerMinute(double value)
+        public static VolumeFlow FromHectolitersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.HectoliterPerMinute);
         }
@@ -1135,7 +1167,7 @@ public static VolumeFlow FromHectolitersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.HectoliterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromHectolitersPerSecond(double value)
+        public static VolumeFlow FromHectolitersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.HectoliterPerSecond);
         }
@@ -1143,7 +1175,7 @@ public static VolumeFlow FromHectolitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromKilolitersPerDay(double value)
+        public static VolumeFlow FromKilolitersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerDay);
         }
@@ -1151,7 +1183,7 @@ public static VolumeFlow FromKilolitersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromKilolitersPerHour(double value)
+        public static VolumeFlow FromKilolitersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerHour);
         }
@@ -1159,7 +1191,7 @@ public static VolumeFlow FromKilolitersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromKilolitersPerMinute(double value)
+        public static VolumeFlow FromKilolitersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerMinute);
         }
@@ -1167,7 +1199,7 @@ public static VolumeFlow FromKilolitersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromKilolitersPerSecond(double value)
+        public static VolumeFlow FromKilolitersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerSecond);
         }
@@ -1175,7 +1207,7 @@ public static VolumeFlow FromKilolitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KilousGallonPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromKilousGallonsPerMinute(double value)
+        public static VolumeFlow FromKilousGallonsPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.KilousGallonPerMinute);
         }
@@ -1183,7 +1215,7 @@ public static VolumeFlow FromKilousGallonsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromLitersPerDay(double value)
+        public static VolumeFlow FromLitersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.LiterPerDay);
         }
@@ -1191,7 +1223,7 @@ public static VolumeFlow FromLitersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromLitersPerHour(double value)
+        public static VolumeFlow FromLitersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.LiterPerHour);
         }
@@ -1199,7 +1231,7 @@ public static VolumeFlow FromLitersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromLitersPerMinute(double value)
+        public static VolumeFlow FromLitersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.LiterPerMinute);
         }
@@ -1207,7 +1239,7 @@ public static VolumeFlow FromLitersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromLitersPerSecond(double value)
+        public static VolumeFlow FromLitersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.LiterPerSecond);
         }
@@ -1215,7 +1247,7 @@ public static VolumeFlow FromLitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromMegalitersPerDay(double value)
+        public static VolumeFlow FromMegalitersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerDay);
         }
@@ -1223,7 +1255,7 @@ public static VolumeFlow FromMegalitersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromMegalitersPerHour(double value)
+        public static VolumeFlow FromMegalitersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerHour);
         }
@@ -1231,7 +1263,7 @@ public static VolumeFlow FromMegalitersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromMegalitersPerMinute(double value)
+        public static VolumeFlow FromMegalitersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerMinute);
         }
@@ -1239,7 +1271,7 @@ public static VolumeFlow FromMegalitersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromMegalitersPerSecond(double value)
+        public static VolumeFlow FromMegalitersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerSecond);
         }
@@ -1247,7 +1279,7 @@ public static VolumeFlow FromMegalitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaukGallonPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromMegaukGallonsPerDay(double value)
+        public static VolumeFlow FromMegaukGallonsPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerDay);
         }
@@ -1255,7 +1287,7 @@ public static VolumeFlow FromMegaukGallonsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaukGallonPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromMegaukGallonsPerSecond(double value)
+        public static VolumeFlow FromMegaukGallonsPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerSecond);
         }
@@ -1263,7 +1295,7 @@ public static VolumeFlow FromMegaukGallonsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegausGallonPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromMegausGallonsPerDay(double value)
+        public static VolumeFlow FromMegausGallonsPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MegausGallonPerDay);
         }
@@ -1271,7 +1303,7 @@ public static VolumeFlow FromMegausGallonsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromMicrolitersPerDay(double value)
+        public static VolumeFlow FromMicrolitersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerDay);
         }
@@ -1279,7 +1311,7 @@ public static VolumeFlow FromMicrolitersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromMicrolitersPerHour(double value)
+        public static VolumeFlow FromMicrolitersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerHour);
         }
@@ -1287,7 +1319,7 @@ public static VolumeFlow FromMicrolitersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromMicrolitersPerMinute(double value)
+        public static VolumeFlow FromMicrolitersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerMinute);
         }
@@ -1295,7 +1327,7 @@ public static VolumeFlow FromMicrolitersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromMicrolitersPerSecond(double value)
+        public static VolumeFlow FromMicrolitersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerSecond);
         }
@@ -1303,7 +1335,7 @@ public static VolumeFlow FromMicrolitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromMillilitersPerDay(double value)
+        public static VolumeFlow FromMillilitersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerDay);
         }
@@ -1311,7 +1343,7 @@ public static VolumeFlow FromMillilitersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromMillilitersPerHour(double value)
+        public static VolumeFlow FromMillilitersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerHour);
         }
@@ -1319,7 +1351,7 @@ public static VolumeFlow FromMillilitersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromMillilitersPerMinute(double value)
+        public static VolumeFlow FromMillilitersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerMinute);
         }
@@ -1327,7 +1359,7 @@ public static VolumeFlow FromMillilitersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromMillilitersPerSecond(double value)
+        public static VolumeFlow FromMillilitersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerSecond);
         }
@@ -1335,7 +1367,7 @@ public static VolumeFlow FromMillilitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MillionUsGallonPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromMillionUsGallonsPerDay(double value)
+        public static VolumeFlow FromMillionUsGallonsPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.MillionUsGallonPerDay);
         }
@@ -1343,7 +1375,7 @@ public static VolumeFlow FromMillionUsGallonsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromNanolitersPerDay(double value)
+        public static VolumeFlow FromNanolitersPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerDay);
         }
@@ -1351,7 +1383,7 @@ public static VolumeFlow FromNanolitersPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromNanolitersPerHour(double value)
+        public static VolumeFlow FromNanolitersPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerHour);
         }
@@ -1359,7 +1391,7 @@ public static VolumeFlow FromNanolitersPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromNanolitersPerMinute(double value)
+        public static VolumeFlow FromNanolitersPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerMinute);
         }
@@ -1367,7 +1399,7 @@ public static VolumeFlow FromNanolitersPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromNanolitersPerSecond(double value)
+        public static VolumeFlow FromNanolitersPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerSecond);
         }
@@ -1375,7 +1407,7 @@ public static VolumeFlow FromNanolitersPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromOilBarrelsPerDay(double value)
+        public static VolumeFlow FromOilBarrelsPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerDay);
         }
@@ -1383,7 +1415,7 @@ public static VolumeFlow FromOilBarrelsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromOilBarrelsPerHour(double value)
+        public static VolumeFlow FromOilBarrelsPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerHour);
         }
@@ -1391,7 +1423,7 @@ public static VolumeFlow FromOilBarrelsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromOilBarrelsPerMinute(double value)
+        public static VolumeFlow FromOilBarrelsPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerMinute);
         }
@@ -1399,7 +1431,7 @@ public static VolumeFlow FromOilBarrelsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromOilBarrelsPerSecond(double value)
+        public static VolumeFlow FromOilBarrelsPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerSecond);
         }
@@ -1407,7 +1439,7 @@ public static VolumeFlow FromOilBarrelsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromUkGallonsPerDay(double value)
+        public static VolumeFlow FromUkGallonsPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerDay);
         }
@@ -1415,7 +1447,7 @@ public static VolumeFlow FromUkGallonsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromUkGallonsPerHour(double value)
+        public static VolumeFlow FromUkGallonsPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerHour);
         }
@@ -1423,7 +1455,7 @@ public static VolumeFlow FromUkGallonsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromUkGallonsPerMinute(double value)
+        public static VolumeFlow FromUkGallonsPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerMinute);
         }
@@ -1431,7 +1463,7 @@ public static VolumeFlow FromUkGallonsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromUkGallonsPerSecond(double value)
+        public static VolumeFlow FromUkGallonsPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerSecond);
         }
@@ -1439,7 +1471,7 @@ public static VolumeFlow FromUkGallonsPerSecond(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerDay"/>.
         /// </summary>
-        public static VolumeFlow FromUsGallonsPerDay(double value)
+        public static VolumeFlow FromUsGallonsPerDay(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerDay);
         }
@@ -1447,7 +1479,7 @@ public static VolumeFlow FromUsGallonsPerDay(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerHour"/>.
         /// </summary>
-        public static VolumeFlow FromUsGallonsPerHour(double value)
+        public static VolumeFlow FromUsGallonsPerHour(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerHour);
         }
@@ -1455,7 +1487,7 @@ public static VolumeFlow FromUsGallonsPerHour(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerMinute"/>.
         /// </summary>
-        public static VolumeFlow FromUsGallonsPerMinute(double value)
+        public static VolumeFlow FromUsGallonsPerMinute(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerMinute);
         }
@@ -1463,7 +1495,7 @@ public static VolumeFlow FromUsGallonsPerMinute(double value)
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerSecond"/>.
         /// </summary>
-        public static VolumeFlow FromUsGallonsPerSecond(double value)
+        public static VolumeFlow FromUsGallonsPerSecond(QuantityValue value)
         {
             return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerSecond);
         }
@@ -1474,7 +1506,7 @@ public static VolumeFlow FromUsGallonsPerSecond(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VolumeFlow unit value.</returns>
-        public static VolumeFlow From(double value, VolumeFlowUnit fromUnit)
+        public static VolumeFlow From(QuantityValue value, VolumeFlowUnit fromUnit)
         {
             return new VolumeFlow(value, fromUnit);
         }
@@ -1535,10 +1567,7 @@ public static VolumeFlow Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static VolumeFlow Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<VolumeFlow, VolumeFlowUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<VolumeFlow, VolumeFlowUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -1566,11 +1595,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out VolumeFlow resul
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumeFlow result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<VolumeFlow, VolumeFlowUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<VolumeFlow, VolumeFlowUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -1591,7 +1616,7 @@ public static VolumeFlowUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -1602,7 +1627,7 @@ public static VolumeFlowUnit ParseUnit(string str, IFormatProvider? provider)
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumeFlowUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.VolumeFlowUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeFlowUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -1617,7 +1642,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeFlowUn
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumeFlowUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -1636,35 +1661,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="VolumeFlow"/> from adding two <see cref="VolumeFlow"/>.</summary>
         public static VolumeFlow operator +(VolumeFlow left, VolumeFlow right)
         {
-            return new VolumeFlow(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new VolumeFlow(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VolumeFlow"/> from subtracting two <see cref="VolumeFlow"/>.</summary>
         public static VolumeFlow operator -(VolumeFlow left, VolumeFlow right)
         {
-            return new VolumeFlow(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new VolumeFlow(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VolumeFlow"/> from multiplying value and <see cref="VolumeFlow"/>.</summary>
-        public static VolumeFlow operator *(double left, VolumeFlow right)
+        public static VolumeFlow operator *(QuantityValue left, VolumeFlow right)
         {
             return new VolumeFlow(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="VolumeFlow"/> from multiplying value and <see cref="VolumeFlow"/>.</summary>
-        public static VolumeFlow operator *(VolumeFlow left, double right)
+        public static VolumeFlow operator *(VolumeFlow left, QuantityValue right)
         {
             return new VolumeFlow(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="VolumeFlow"/> from dividing <see cref="VolumeFlow"/> by value.</summary>
-        public static VolumeFlow operator /(VolumeFlow left, double right)
+        public static VolumeFlow operator /(VolumeFlow left, QuantityValue right)
         {
             return new VolumeFlow(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="VolumeFlow"/> by <see cref="VolumeFlow"/>.</summary>
-        public static double operator /(VolumeFlow left, VolumeFlow right)
+        public static QuantityValue operator /(VolumeFlow left, VolumeFlow right)
         {
             return left.CubicMetersPerSecond / right.CubicMetersPerSecond;
         }
@@ -1679,6 +1704,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Area.FromSquareMeters(volumeFlow.CubicMetersPerSecond / speed.MetersPerSecond);
         }
 
+        /// <summary>Get <see cref="LeakRate"/> from <see cref="VolumeFlow"/> * <see cref="Pressure"/>.</summary>
+        public static LeakRate operator *(VolumeFlow volumeFlow, Pressure pressure)
+        {
+            return LeakRate.FromPascalCubicMetersPerSecond(volumeFlow.CubicMetersPerSecond * pressure.Pascals);
+        }
+
         /// <summary>Get <see cref="MassFlow"/> from <see cref="VolumeFlow"/> * <see cref="Density"/>.</summary>
         public static MassFlow operator *(VolumeFlow volumeFlow, Density density)
         {
@@ -1691,6 +1722,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return MolarFlow.FromMolesPerSecond(volumeFlow.CubicMetersPerSecond * molarity.MolesPerCubicMeter);
         }
 
+        /// <summary>Get <see cref="Pressure"/> from <see cref="VolumeFlow"/> * <see cref="FluidResistance"/>.</summary>
+        public static Pressure operator *(VolumeFlow volumeFlow, FluidResistance fluidResistance)
+        {
+            return Pressure.FromPascals(volumeFlow.CubicMetersPerSecond * fluidResistance.PascalSecondsPerCubicMeter);
+        }
+
         /// <summary>Get <see cref="Speed"/> from <see cref="VolumeFlow"/> / <see cref="Area"/>.</summary>
         public static Speed operator /(VolumeFlow volumeFlow, Area area)
         {
@@ -1710,97 +1747,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(VolumeFlow left, VolumeFlow right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(VolumeFlow left, VolumeFlow right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(VolumeFlow left, VolumeFlow right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(VolumeFlow left, VolumeFlow right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="VolumeFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VolumeFlow other, VolumeFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VolumeFlow"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(VolumeFlow)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(VolumeFlow left, VolumeFlow right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="VolumeFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VolumeFlow other, VolumeFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VolumeFlow"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(VolumeFlow,VolumeFlow)"/>.
+        ///     See that operator (and <see cref="Equals(VolumeFlow)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(VolumeFlow left, VolumeFlow right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VolumeFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VolumeFlow other, VolumeFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="VolumeFlow"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="VolumeFlow"/>.
+        ///     When <paramref name="obj"/> is a <see cref="VolumeFlow"/>, this method delegates to
+        ///     <see cref="Equals(VolumeFlow)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is VolumeFlow otherQuantity))
+            if (obj is not VolumeFlow otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VolumeFlow"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VolumeFlow other, VolumeFlow tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="VolumeFlow"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(VolumeFlow other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current VolumeFlow.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(VolumeFlow), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="VolumeFlow"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(VolumeFlow)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is VolumeFlow otherQuantity)) throw new ArgumentException("Expected type VolumeFlow.", nameof(obj));
+            if (obj is not VolumeFlow otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<VolumeFlow>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="VolumeFlow"/> with another <see cref="VolumeFlow"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="VolumeFlow"/> with another <see cref="VolumeFlow"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -1812,277 +1863,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(VolumeFlow other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(VolumeFlowUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<VolumeFlowUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this VolumeFlow to another VolumeFlow with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A VolumeFlow with the specified unit.</returns>
-        public VolumeFlow ToUnit(VolumeFlowUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="VolumeFlow"/> to another <see cref="VolumeFlow"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A VolumeFlow with the specified unit.</returns>
-        public VolumeFlow ToUnit(VolumeFlowUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(VolumeFlow), Unit, typeof(VolumeFlow), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (VolumeFlow)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="VolumeFlow"/> to another <see cref="VolumeFlow"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="VolumeFlow"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(VolumeFlowUnit unit, [NotNullWhen(true)] out VolumeFlow? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            VolumeFlow? convertedOrNull = (Unit, unit) switch
-            {
-                // VolumeFlowUnit -> BaseUnit
-                (VolumeFlowUnit.AcreFootPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 1233.48183754752 / 86400, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.AcreFootPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 1233.48183754752 / 3600, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.AcreFootPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 1233.48183754752 / 60, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.AcreFootPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 1233.48183754752, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CentiliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 86400)) * 1e-2d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CentiliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 3600)) * 1e-2d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CentiliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 60)) * 1e-2d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CentiliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e-2d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicCentimeterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 1e-6 / 60, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicDecimeterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value / 60000.00000, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicFootPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.028316846592 / 3600, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicFootPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.028316846592 / 60, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicFootPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.028316846592, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value / 86400, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value / 3600, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value / 60, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicMillimeterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 1e-9, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicYardPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.764554857984 / 86400, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicYardPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.764554857984 / 3600, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicYardPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.764554857984 / 60, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.CubicYardPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.764554857984, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.DecaliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 86400)) * 1e1d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.DecaliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 3600)) * 1e1d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.DecaliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 60)) * 1e1d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.DecaliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e1d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.DeciliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 86400)) * 1e-1d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.DeciliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 3600)) * 1e-1d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.DeciliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 60)) * 1e-1d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.DeciliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e-1d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.HectoliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 86400)) * 1e2d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.HectoliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 3600)) * 1e2d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.HectoliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 60)) * 1e2d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.HectoliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e2d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.KiloliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 86400)) * 1e3d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.KiloliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 3600)) * 1e3d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.KiloliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 60)) * 1e3d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.KiloliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e3d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.KilousGallonPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 1000 * 0.003785411784 / 60, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.LiterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value / (1000 * 86400), VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.LiterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value / (1000 * 3600), VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.LiterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value / (1000 * 60), VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.LiterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value / 1000, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MegaliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 86400)) * 1e6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MegaliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 3600)) * 1e6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MegaliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 60)) * 1e6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MegaliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MegaukGallonPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value * 0.00454609 / 86400) * 1e6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MegaukGallonPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value * 0.00454609) * 1e6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MegausGallonPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value * 0.003785411784 / 86400) * 1e6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MicroliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 86400)) * 1e-6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MicroliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 3600)) * 1e-6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MicroliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 60)) * 1e-6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MicroliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e-6d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MilliliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 86400)) * 1e-3d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MilliliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 3600)) * 1e-3d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MilliliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 60)) * 1e-3d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MilliliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e-3d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.MillionUsGallonPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 1e6 * 0.003785411784 / 86400, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.NanoliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 86400)) * 1e-9d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.NanoliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 3600)) * 1e-9d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.NanoliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / (1000 * 60)) * 1e-9d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.NanoliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e-9d, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.OilBarrelPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.158987294928 / 86400, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.OilBarrelPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.158987294928 / 3600, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.OilBarrelPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.158987294928 / 60, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.OilBarrelPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.158987294928, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.UkGallonPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.00454609 / 86400, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.UkGallonPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.00454609 / 3600, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.UkGallonPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.00454609 / 60, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.UkGallonPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.00454609, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.UsGallonPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.003785411784 / 86400, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.UsGallonPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.003785411784 / 3600, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.UsGallonPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.003785411784 / 60, VolumeFlowUnit.CubicMeterPerSecond),
-                (VolumeFlowUnit.UsGallonPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.003785411784, VolumeFlowUnit.CubicMeterPerSecond),
-
-                // BaseUnit -> VolumeFlowUnit
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.AcreFootPerDay) => new VolumeFlow(_value / (1233.48183754752 / 86400), VolumeFlowUnit.AcreFootPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.AcreFootPerHour) => new VolumeFlow(_value / (1233.48183754752 / 3600), VolumeFlowUnit.AcreFootPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.AcreFootPerMinute) => new VolumeFlow(_value / (1233.48183754752 / 60), VolumeFlowUnit.AcreFootPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.AcreFootPerSecond) => new VolumeFlow(_value / 1233.48183754752, VolumeFlowUnit.AcreFootPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CentiliterPerDay) => new VolumeFlow((_value * (1000 * 86400)) / 1e-2d, VolumeFlowUnit.CentiliterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CentiliterPerHour) => new VolumeFlow((_value * (1000 * 3600)) / 1e-2d, VolumeFlowUnit.CentiliterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CentiliterPerMinute) => new VolumeFlow((_value * (1000 * 60)) / 1e-2d, VolumeFlowUnit.CentiliterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CentiliterPerSecond) => new VolumeFlow((_value * 1000) / 1e-2d, VolumeFlowUnit.CentiliterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicCentimeterPerMinute) => new VolumeFlow(_value / (1e-6 / 60), VolumeFlowUnit.CubicCentimeterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicDecimeterPerMinute) => new VolumeFlow(_value * 60000.00000, VolumeFlowUnit.CubicDecimeterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicFootPerHour) => new VolumeFlow(_value / (0.028316846592 / 3600), VolumeFlowUnit.CubicFootPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicFootPerMinute) => new VolumeFlow(_value / (0.028316846592 / 60), VolumeFlowUnit.CubicFootPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicFootPerSecond) => new VolumeFlow(_value / 0.028316846592, VolumeFlowUnit.CubicFootPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicMeterPerDay) => new VolumeFlow(_value * 86400, VolumeFlowUnit.CubicMeterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicMeterPerHour) => new VolumeFlow(_value * 3600, VolumeFlowUnit.CubicMeterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicMeterPerMinute) => new VolumeFlow(_value * 60, VolumeFlowUnit.CubicMeterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicMillimeterPerSecond) => new VolumeFlow(_value / 1e-9, VolumeFlowUnit.CubicMillimeterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerDay) => new VolumeFlow(_value / (0.764554857984 / 86400), VolumeFlowUnit.CubicYardPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerHour) => new VolumeFlow(_value / (0.764554857984 / 3600), VolumeFlowUnit.CubicYardPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerMinute) => new VolumeFlow(_value / (0.764554857984 / 60), VolumeFlowUnit.CubicYardPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerSecond) => new VolumeFlow(_value / 0.764554857984, VolumeFlowUnit.CubicYardPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerDay) => new VolumeFlow((_value * (1000 * 86400)) / 1e1d, VolumeFlowUnit.DecaliterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerHour) => new VolumeFlow((_value * (1000 * 3600)) / 1e1d, VolumeFlowUnit.DecaliterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerMinute) => new VolumeFlow((_value * (1000 * 60)) / 1e1d, VolumeFlowUnit.DecaliterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerSecond) => new VolumeFlow((_value * 1000) / 1e1d, VolumeFlowUnit.DecaliterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerDay) => new VolumeFlow((_value * (1000 * 86400)) / 1e-1d, VolumeFlowUnit.DeciliterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerHour) => new VolumeFlow((_value * (1000 * 3600)) / 1e-1d, VolumeFlowUnit.DeciliterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerMinute) => new VolumeFlow((_value * (1000 * 60)) / 1e-1d, VolumeFlowUnit.DeciliterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerSecond) => new VolumeFlow((_value * 1000) / 1e-1d, VolumeFlowUnit.DeciliterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerDay) => new VolumeFlow((_value * (1000 * 86400)) / 1e2d, VolumeFlowUnit.HectoliterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerHour) => new VolumeFlow((_value * (1000 * 3600)) / 1e2d, VolumeFlowUnit.HectoliterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerMinute) => new VolumeFlow((_value * (1000 * 60)) / 1e2d, VolumeFlowUnit.HectoliterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerSecond) => new VolumeFlow((_value * 1000) / 1e2d, VolumeFlowUnit.HectoliterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerDay) => new VolumeFlow((_value * (1000 * 86400)) / 1e3d, VolumeFlowUnit.KiloliterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerHour) => new VolumeFlow((_value * (1000 * 3600)) / 1e3d, VolumeFlowUnit.KiloliterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerMinute) => new VolumeFlow((_value * (1000 * 60)) / 1e3d, VolumeFlowUnit.KiloliterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerSecond) => new VolumeFlow((_value * 1000) / 1e3d, VolumeFlowUnit.KiloliterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KilousGallonPerMinute) => new VolumeFlow(_value / (1000 * 0.003785411784 / 60), VolumeFlowUnit.KilousGallonPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.LiterPerDay) => new VolumeFlow(_value * (1000 * 86400), VolumeFlowUnit.LiterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.LiterPerHour) => new VolumeFlow(_value * (1000 * 3600), VolumeFlowUnit.LiterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.LiterPerMinute) => new VolumeFlow(_value * (1000 * 60), VolumeFlowUnit.LiterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.LiterPerSecond) => new VolumeFlow(_value * 1000, VolumeFlowUnit.LiterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaliterPerDay) => new VolumeFlow((_value * (1000 * 86400)) / 1e6d, VolumeFlowUnit.MegaliterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaliterPerHour) => new VolumeFlow((_value * (1000 * 3600)) / 1e6d, VolumeFlowUnit.MegaliterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaliterPerMinute) => new VolumeFlow((_value * (1000 * 60)) / 1e6d, VolumeFlowUnit.MegaliterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaliterPerSecond) => new VolumeFlow((_value * 1000) / 1e6d, VolumeFlowUnit.MegaliterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaukGallonPerDay) => new VolumeFlow((_value / (0.00454609 / 86400)) / 1e6d, VolumeFlowUnit.MegaukGallonPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegaukGallonPerSecond) => new VolumeFlow((_value / 0.00454609) / 1e6d, VolumeFlowUnit.MegaukGallonPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MegausGallonPerDay) => new VolumeFlow((_value / (0.003785411784 / 86400)) / 1e6d, VolumeFlowUnit.MegausGallonPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MicroliterPerDay) => new VolumeFlow((_value * (1000 * 86400)) / 1e-6d, VolumeFlowUnit.MicroliterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MicroliterPerHour) => new VolumeFlow((_value * (1000 * 3600)) / 1e-6d, VolumeFlowUnit.MicroliterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MicroliterPerMinute) => new VolumeFlow((_value * (1000 * 60)) / 1e-6d, VolumeFlowUnit.MicroliterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MicroliterPerSecond) => new VolumeFlow((_value * 1000) / 1e-6d, VolumeFlowUnit.MicroliterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MilliliterPerDay) => new VolumeFlow((_value * (1000 * 86400)) / 1e-3d, VolumeFlowUnit.MilliliterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MilliliterPerHour) => new VolumeFlow((_value * (1000 * 3600)) / 1e-3d, VolumeFlowUnit.MilliliterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MilliliterPerMinute) => new VolumeFlow((_value * (1000 * 60)) / 1e-3d, VolumeFlowUnit.MilliliterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MilliliterPerSecond) => new VolumeFlow((_value * 1000) / 1e-3d, VolumeFlowUnit.MilliliterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.MillionUsGallonPerDay) => new VolumeFlow(_value / (1e6 * 0.003785411784 / 86400), VolumeFlowUnit.MillionUsGallonPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.NanoliterPerDay) => new VolumeFlow((_value * (1000 * 86400)) / 1e-9d, VolumeFlowUnit.NanoliterPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.NanoliterPerHour) => new VolumeFlow((_value * (1000 * 3600)) / 1e-9d, VolumeFlowUnit.NanoliterPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.NanoliterPerMinute) => new VolumeFlow((_value * (1000 * 60)) / 1e-9d, VolumeFlowUnit.NanoliterPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.NanoliterPerSecond) => new VolumeFlow((_value * 1000) / 1e-9d, VolumeFlowUnit.NanoliterPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.OilBarrelPerDay) => new VolumeFlow(_value / (0.158987294928 / 86400), VolumeFlowUnit.OilBarrelPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.OilBarrelPerHour) => new VolumeFlow(_value / (0.158987294928 / 3600), VolumeFlowUnit.OilBarrelPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.OilBarrelPerMinute) => new VolumeFlow(_value / (0.158987294928 / 60), VolumeFlowUnit.OilBarrelPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.OilBarrelPerSecond) => new VolumeFlow(_value / 0.158987294928, VolumeFlowUnit.OilBarrelPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UkGallonPerDay) => new VolumeFlow(_value / (0.00454609 / 86400), VolumeFlowUnit.UkGallonPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UkGallonPerHour) => new VolumeFlow(_value / (0.00454609 / 3600), VolumeFlowUnit.UkGallonPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UkGallonPerMinute) => new VolumeFlow(_value / (0.00454609 / 60), VolumeFlowUnit.UkGallonPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UkGallonPerSecond) => new VolumeFlow(_value / 0.00454609, VolumeFlowUnit.UkGallonPerSecond),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UsGallonPerDay) => new VolumeFlow(_value / (0.003785411784 / 86400), VolumeFlowUnit.UsGallonPerDay),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UsGallonPerHour) => new VolumeFlow(_value / (0.003785411784 / 3600), VolumeFlowUnit.UsGallonPerHour),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UsGallonPerMinute) => new VolumeFlow(_value / (0.003785411784 / 60), VolumeFlowUnit.UsGallonPerMinute),
-                (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.UsGallonPerSecond) => new VolumeFlow(_value / 0.003785411784, VolumeFlowUnit.UsGallonPerSecond),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not VolumeFlowUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is VolumeFlowUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<VolumeFlowUnit> IQuantity<VolumeFlowUnit>.ToUnit(VolumeFlowUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -2096,11 +1879,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
index e184bb5cd8..1800e157d8 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct VolumeFlowPerArea :
-        IArithmeticQuantity<VolumeFlowPerArea, VolumeFlowPerAreaUnit>,
+        ILinearQuantity<VolumeFlowPerArea, VolumeFlowPerAreaUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<VolumeFlowPerArea, VolumeFlowPerArea, double>,
+        IDivisionOperators<VolumeFlowPerArea, VolumeFlowPerArea, QuantityValue>,
+        IMultiplyOperators<VolumeFlowPerArea, Area, VolumeFlow>,
         IComparisonOperators<VolumeFlowPerArea, VolumeFlowPerArea, bool>,
         IParsable<VolumeFlowPerArea>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static VolumeFlowPerAreaInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="VolumeFlowPerArea"/> is [T^-1][L].
+            ///     The <see cref="BaseDimensions" /> for <see cref="VolumeFlowPerArea"/> is T^-1L.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(1, 0, -1, 0, 0, 0, 0);
 
@@ -117,16 +117,16 @@ public static VolumeFlowPerAreaInfo CreateDefault(Func<IEnumerable<UnitDefinitio
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{VolumeFlowPerAreaUnit}"/> representing the default unit mappings for VolumeFlowPerArea.</returns>
             public static IEnumerable<UnitDefinition<VolumeFlowPerAreaUnit>> GetDefaultMappings()
             {
-                yield return new (VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot, "CubicFootPerMinutePerSquareFoot", "CubicFeetPerMinutePerSquareFoot", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Minute));
+                yield return new (VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot, "CubicFootPerMinutePerSquareFoot", "CubicFeetPerMinutePerSquareFoot", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Minute),
+                     new QuantityValue(25000, 127)
+                );
                 yield return new (VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, "CubicMeterPerSecondPerSquareMeter", "CubicMetersPerSecondPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second));
             }
         }
 
         static VolumeFlowPerArea()
         {
-            Info = VolumeFlowPerAreaInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(VolumeFlowPerAreaInfo.CreateDefault);
         }
 
         /// <summary>
@@ -134,7 +134,7 @@ static VolumeFlowPerArea()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VolumeFlowPerArea(double value, VolumeFlowPerAreaUnit unit)
+        public VolumeFlowPerArea(QuantityValue value, VolumeFlowPerAreaUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -148,7 +148,7 @@ public VolumeFlowPerArea(double value, VolumeFlowPerAreaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public VolumeFlowPerArea(double value, UnitSystem unitSystem)
+        public VolumeFlowPerArea(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -159,7 +159,8 @@ public VolumeFlowPerArea(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="VolumeFlowPerArea" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<VolumeFlowPerArea, VolumeFlowPerAreaUnit> Info { get; }
@@ -188,10 +189,8 @@ public VolumeFlowPerArea(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public VolumeFlowPerAreaUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -225,35 +224,19 @@ public VolumeFlowPerArea(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot"/>
         /// </summary>
-        public double CubicFeetPerMinutePerSquareFoot => As(VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot);
+        public QuantityValue CubicFeetPerMinutePerSquareFoot => this.As(VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter"/>
         /// </summary>
-        public double CubicMetersPerSecondPerSquareMeter => As(VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter);
+        public QuantityValue CubicMetersPerSecondPerSquareMeter => this.As(VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: VolumeFlowPerAreaUnit -> BaseUnit
-            unitConverter.SetConversionFunction<VolumeFlowPerArea>(VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, quantity => quantity.ToUnit(VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<VolumeFlowPerArea>(VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> VolumeFlowPerAreaUnit
-            unitConverter.SetConversionFunction<VolumeFlowPerArea>(VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot, quantity => quantity.ToUnit(VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -282,7 +265,7 @@ public static string GetAbbreviation(VolumeFlowPerAreaUnit unit, IFormatProvider
         /// <summary>
         ///     Creates a <see cref="VolumeFlowPerArea"/> from <see cref="VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot"/>.
         /// </summary>
-        public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(double value)
+        public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(QuantityValue value)
         {
             return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot);
         }
@@ -290,7 +273,7 @@ public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(double value
         /// <summary>
         ///     Creates a <see cref="VolumeFlowPerArea"/> from <see cref="VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter"/>.
         /// </summary>
-        public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(double value)
+        public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(QuantityValue value)
         {
             return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter);
         }
@@ -301,7 +284,7 @@ public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(double va
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VolumeFlowPerArea unit value.</returns>
-        public static VolumeFlowPerArea From(double value, VolumeFlowPerAreaUnit fromUnit)
+        public static VolumeFlowPerArea From(QuantityValue value, VolumeFlowPerAreaUnit fromUnit)
         {
             return new VolumeFlowPerArea(value, fromUnit);
         }
@@ -362,10 +345,7 @@ public static VolumeFlowPerArea Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static VolumeFlowPerArea Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<VolumeFlowPerArea, VolumeFlowPerAreaUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<VolumeFlowPerArea, VolumeFlowPerAreaUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -393,11 +373,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out VolumeFlowPerAre
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumeFlowPerArea result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<VolumeFlowPerArea, VolumeFlowPerAreaUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<VolumeFlowPerArea, VolumeFlowPerAreaUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -418,7 +394,7 @@ public static VolumeFlowPerAreaUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -429,7 +405,7 @@ public static VolumeFlowPerAreaUnit ParseUnit(string str, IFormatProvider? provi
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumeFlowPerAreaUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.VolumeFlowPerAreaUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeFlowPerAreaUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -444,7 +420,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumeFlowPe
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumeFlowPerAreaUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -463,137 +439,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="VolumeFlowPerArea"/> from adding two <see cref="VolumeFlowPerArea"/>.</summary>
         public static VolumeFlowPerArea operator +(VolumeFlowPerArea left, VolumeFlowPerArea right)
         {
-            return new VolumeFlowPerArea(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new VolumeFlowPerArea(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VolumeFlowPerArea"/> from subtracting two <see cref="VolumeFlowPerArea"/>.</summary>
         public static VolumeFlowPerArea operator -(VolumeFlowPerArea left, VolumeFlowPerArea right)
         {
-            return new VolumeFlowPerArea(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new VolumeFlowPerArea(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VolumeFlowPerArea"/> from multiplying value and <see cref="VolumeFlowPerArea"/>.</summary>
-        public static VolumeFlowPerArea operator *(double left, VolumeFlowPerArea right)
+        public static VolumeFlowPerArea operator *(QuantityValue left, VolumeFlowPerArea right)
         {
             return new VolumeFlowPerArea(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="VolumeFlowPerArea"/> from multiplying value and <see cref="VolumeFlowPerArea"/>.</summary>
-        public static VolumeFlowPerArea operator *(VolumeFlowPerArea left, double right)
+        public static VolumeFlowPerArea operator *(VolumeFlowPerArea left, QuantityValue right)
         {
             return new VolumeFlowPerArea(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="VolumeFlowPerArea"/> from dividing <see cref="VolumeFlowPerArea"/> by value.</summary>
-        public static VolumeFlowPerArea operator /(VolumeFlowPerArea left, double right)
+        public static VolumeFlowPerArea operator /(VolumeFlowPerArea left, QuantityValue right)
         {
             return new VolumeFlowPerArea(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="VolumeFlowPerArea"/> by <see cref="VolumeFlowPerArea"/>.</summary>
-        public static double operator /(VolumeFlowPerArea left, VolumeFlowPerArea right)
+        public static QuantityValue operator /(VolumeFlowPerArea left, VolumeFlowPerArea right)
         {
             return left.CubicMetersPerSecondPerSquareMeter / right.CubicMetersPerSecondPerSquareMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="VolumeFlow"/> from <see cref="VolumeFlowPerArea"/> * <see cref="Area"/>.</summary>
+        public static VolumeFlow operator *(VolumeFlowPerArea volumeFlowPerArea, Area area)
+        {
+            return VolumeFlow.FromCubicMetersPerSecond(volumeFlowPerArea.CubicMetersPerSecondPerSquareMeter * area.SquareMeters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(VolumeFlowPerArea left, VolumeFlowPerArea right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(VolumeFlowPerArea left, VolumeFlowPerArea right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(VolumeFlowPerArea left, VolumeFlowPerArea right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(VolumeFlowPerArea left, VolumeFlowPerArea right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="VolumeFlowPerArea"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VolumeFlowPerArea other, VolumeFlowPerArea tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VolumeFlowPerArea"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(VolumeFlowPerArea)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(VolumeFlowPerArea left, VolumeFlowPerArea right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="VolumeFlowPerArea"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VolumeFlowPerArea other, VolumeFlowPerArea tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VolumeFlowPerArea"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(VolumeFlowPerArea,VolumeFlowPerArea)"/>.
+        ///     See that operator (and <see cref="Equals(VolumeFlowPerArea)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(VolumeFlowPerArea left, VolumeFlowPerArea right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VolumeFlowPerArea"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VolumeFlowPerArea other, VolumeFlowPerArea tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="VolumeFlowPerArea"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="VolumeFlowPerArea"/>.
+        ///     When <paramref name="obj"/> is a <see cref="VolumeFlowPerArea"/>, this method delegates to
+        ///     <see cref="Equals(VolumeFlowPerArea)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is VolumeFlowPerArea otherQuantity))
+            if (obj is not VolumeFlowPerArea otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VolumeFlowPerArea"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VolumeFlowPerArea other, VolumeFlowPerArea tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="VolumeFlowPerArea"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(VolumeFlowPerArea other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current VolumeFlowPerArea.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(VolumeFlowPerArea), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="VolumeFlowPerArea"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(VolumeFlowPerArea)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is VolumeFlowPerArea otherQuantity)) throw new ArgumentException("Expected type VolumeFlowPerArea.", nameof(obj));
+            if (obj is not VolumeFlowPerArea otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<VolumeFlowPerArea>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="VolumeFlowPerArea"/> with another <see cref="VolumeFlowPerArea"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="VolumeFlowPerArea"/> with another <see cref="VolumeFlowPerArea"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -605,133 +605,11 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(VolumeFlowPerArea other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
         #endregion
 
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(VolumeFlowPerAreaUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<VolumeFlowPerAreaUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this VolumeFlowPerArea to another VolumeFlowPerArea with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A VolumeFlowPerArea with the specified unit.</returns>
-        public VolumeFlowPerArea ToUnit(VolumeFlowPerAreaUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="VolumeFlowPerArea"/> to another <see cref="VolumeFlowPerArea"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A VolumeFlowPerArea with the specified unit.</returns>
-        public VolumeFlowPerArea ToUnit(VolumeFlowPerAreaUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(VolumeFlowPerArea), Unit, typeof(VolumeFlowPerArea), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (VolumeFlowPerArea)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="VolumeFlowPerArea"/> to another <see cref="VolumeFlowPerArea"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="VolumeFlowPerArea"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(VolumeFlowPerAreaUnit unit, [NotNullWhen(true)] out VolumeFlowPerArea? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            VolumeFlowPerArea? convertedOrNull = (Unit, unit) switch
-            {
-                // VolumeFlowPerAreaUnit -> BaseUnit
-                (VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter) => new VolumeFlowPerArea(_value * (0.028316846592 / 60) / 9.290304e-2, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter),
-
-                // BaseUnit -> VolumeFlowPerAreaUnit
-                (VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot) => new VolumeFlowPerArea(_value * 9.290304e-2 / (0.028316846592 / 60), VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not VolumeFlowPerAreaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowPerAreaUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is VolumeFlowPerAreaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowPerAreaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<VolumeFlowPerAreaUnit> IQuantity<VolumeFlowPerAreaUnit>.ToUnit(VolumeFlowPerAreaUnit unit) => ToUnit(unit);
-
-        #endregion
-
-        #endregion
-
         #region ToString Methods
 
         /// <summary>
@@ -743,11 +621,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
index ce3022be10..28c22481d5 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,13 @@ namespace UnitsNet
     ///     Volume, typically of fluid, that a container can hold within a unit of length.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct VolumePerLength :
-        IArithmeticQuantity<VolumePerLength, VolumePerLengthUnit>,
+        ILinearQuantity<VolumePerLength, VolumePerLengthUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<VolumePerLength, VolumePerLength, double>,
+        IDivisionOperators<VolumePerLength, VolumePerLength, QuantityValue>,
+        IMultiplyOperators<VolumePerLength, Length, Volume>,
         IComparisonOperators<VolumePerLength, VolumePerLength, bool>,
         IParsable<VolumePerLength>,
 #endif
@@ -52,7 +52,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +102,7 @@ public static VolumePerLengthInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="VolumePerLength"/> is [L^2].
+            ///     The <see cref="BaseDimensions" /> for <see cref="VolumePerLength"/> is L^2.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
 
@@ -118,22 +118,36 @@ public static VolumePerLengthInfo CreateDefault(Func<IEnumerable<UnitDefinition<
             public static IEnumerable<UnitDefinition<VolumePerLengthUnit>> GetDefaultMappings()
             {
                 yield return new (VolumePerLengthUnit.CubicMeterPerMeter, "CubicMeterPerMeter", "CubicMetersPerMeter", new BaseUnits(length: LengthUnit.Meter));
-                yield return new (VolumePerLengthUnit.CubicYardPerFoot, "CubicYardPerFoot", "CubicYardsPerFoot", BaseUnits.Undefined);
-                yield return new (VolumePerLengthUnit.CubicYardPerUsSurveyFoot, "CubicYardPerUsSurveyFoot", "CubicYardsPerUsSurveyFoot", BaseUnits.Undefined);
-                yield return new (VolumePerLengthUnit.ImperialGallonPerMile, "ImperialGallonPerMile", "ImperialGallonsPerMile", BaseUnits.Undefined);
-                yield return new (VolumePerLengthUnit.LiterPerKilometer, "LiterPerKilometer", "LitersPerKilometer", BaseUnits.Undefined);
-                yield return new (VolumePerLengthUnit.LiterPerMeter, "LiterPerMeter", "LitersPerMeter", new BaseUnits(length: LengthUnit.Decimeter));
-                yield return new (VolumePerLengthUnit.LiterPerMillimeter, "LiterPerMillimeter", "LitersPerMillimeter", BaseUnits.Undefined);
-                yield return new (VolumePerLengthUnit.OilBarrelPerFoot, "OilBarrelPerFoot", "OilBarrelsPerFoot", BaseUnits.Undefined);
-                yield return new (VolumePerLengthUnit.UsGallonPerMile, "UsGallonPerMile", "UsGallonsPerMile", BaseUnits.Undefined);
+                yield return new (VolumePerLengthUnit.CubicYardPerFoot, "CubicYardPerFoot", "CubicYardsPerFoot", BaseUnits.Undefined,
+                     new QuantityValue(1562500, 3919347)
+                );
+                yield return new (VolumePerLengthUnit.CubicYardPerUsSurveyFoot, "CubicYardPerUsSurveyFoot", "CubicYardsPerUsSurveyFoot", BaseUnits.Undefined,
+                     new QuantityValue(781250000000, 1959669580653)
+                );
+                yield return new (VolumePerLengthUnit.ImperialGallonPerMile, "ImperialGallonPerMile", "ImperialGallonsPerMile", BaseUnits.Undefined,
+                     new QuantityValue(160934400000, 454609)
+                );
+                yield return new (VolumePerLengthUnit.LiterPerKilometer, "LiterPerKilometer", "LitersPerKilometer", BaseUnits.Undefined,
+                     1000000
+                );
+                yield return new (VolumePerLengthUnit.LiterPerMeter, "LiterPerMeter", "LitersPerMeter", new BaseUnits(length: LengthUnit.Decimeter),
+                     1000
+                );
+                yield return new (VolumePerLengthUnit.LiterPerMillimeter, "LiterPerMillimeter", "LitersPerMillimeter", BaseUnits.Undefined,
+                     1
+                );
+                yield return new (VolumePerLengthUnit.OilBarrelPerFoot, "OilBarrelPerFoot", "OilBarrelsPerFoot", BaseUnits.Undefined,
+                     new QuantityValue(50000000, 26080593)
+                );
+                yield return new (VolumePerLengthUnit.UsGallonPerMile, "UsGallonPerMile", "UsGallonsPerMile", BaseUnits.Undefined,
+                     new QuantityValue(48000000000, 112903)
+                );
             }
         }
 
         static VolumePerLength()
         {
-            Info = VolumePerLengthInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(VolumePerLengthInfo.CreateDefault);
         }
 
         /// <summary>
@@ -141,7 +155,7 @@ static VolumePerLength()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VolumePerLength(double value, VolumePerLengthUnit unit)
+        public VolumePerLength(QuantityValue value, VolumePerLengthUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -155,7 +169,7 @@ public VolumePerLength(double value, VolumePerLengthUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public VolumePerLength(double value, UnitSystem unitSystem)
+        public VolumePerLength(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -166,7 +180,8 @@ public VolumePerLength(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="VolumePerLength" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<VolumePerLength, VolumePerLengthUnit> Info { get; }
@@ -195,10 +210,8 @@ public VolumePerLength(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public VolumePerLengthUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -232,84 +245,54 @@ public VolumePerLength(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.CubicMeterPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumePerLengthUnit.CubicMeterPerMeter"/>
         /// </summary>
-        public double CubicMetersPerMeter => As(VolumePerLengthUnit.CubicMeterPerMeter);
+        public QuantityValue CubicMetersPerMeter => this.As(VolumePerLengthUnit.CubicMeterPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.CubicYardPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumePerLengthUnit.CubicYardPerFoot"/>
         /// </summary>
-        public double CubicYardsPerFoot => As(VolumePerLengthUnit.CubicYardPerFoot);
+        public QuantityValue CubicYardsPerFoot => this.As(VolumePerLengthUnit.CubicYardPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.CubicYardPerUsSurveyFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumePerLengthUnit.CubicYardPerUsSurveyFoot"/>
         /// </summary>
-        public double CubicYardsPerUsSurveyFoot => As(VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+        public QuantityValue CubicYardsPerUsSurveyFoot => this.As(VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.ImperialGallonPerMile"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumePerLengthUnit.ImperialGallonPerMile"/>
         /// </summary>
-        public double ImperialGallonsPerMile => As(VolumePerLengthUnit.ImperialGallonPerMile);
+        public QuantityValue ImperialGallonsPerMile => this.As(VolumePerLengthUnit.ImperialGallonPerMile);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.LiterPerKilometer"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumePerLengthUnit.LiterPerKilometer"/>
         /// </summary>
-        public double LitersPerKilometer => As(VolumePerLengthUnit.LiterPerKilometer);
+        public QuantityValue LitersPerKilometer => this.As(VolumePerLengthUnit.LiterPerKilometer);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.LiterPerMeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumePerLengthUnit.LiterPerMeter"/>
         /// </summary>
-        public double LitersPerMeter => As(VolumePerLengthUnit.LiterPerMeter);
+        public QuantityValue LitersPerMeter => this.As(VolumePerLengthUnit.LiterPerMeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.LiterPerMillimeter"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumePerLengthUnit.LiterPerMillimeter"/>
         /// </summary>
-        public double LitersPerMillimeter => As(VolumePerLengthUnit.LiterPerMillimeter);
+        public QuantityValue LitersPerMillimeter => this.As(VolumePerLengthUnit.LiterPerMillimeter);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.OilBarrelPerFoot"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumePerLengthUnit.OilBarrelPerFoot"/>
         /// </summary>
-        public double OilBarrelsPerFoot => As(VolumePerLengthUnit.OilBarrelPerFoot);
+        public QuantityValue OilBarrelsPerFoot => this.As(VolumePerLengthUnit.OilBarrelPerFoot);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumePerLengthUnit.UsGallonPerMile"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumePerLengthUnit.UsGallonPerMile"/>
         /// </summary>
-        public double UsGallonsPerMile => As(VolumePerLengthUnit.UsGallonPerMile);
+        public QuantityValue UsGallonsPerMile => this.As(VolumePerLengthUnit.UsGallonPerMile);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: VolumePerLengthUnit -> BaseUnit
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicYardPerFoot, VolumePerLengthUnit.CubicMeterPerMeter, quantity => quantity.ToUnit(VolumePerLengthUnit.CubicMeterPerMeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicYardPerUsSurveyFoot, VolumePerLengthUnit.CubicMeterPerMeter, quantity => quantity.ToUnit(VolumePerLengthUnit.CubicMeterPerMeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.ImperialGallonPerMile, VolumePerLengthUnit.CubicMeterPerMeter, quantity => quantity.ToUnit(VolumePerLengthUnit.CubicMeterPerMeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.LiterPerKilometer, VolumePerLengthUnit.CubicMeterPerMeter, quantity => quantity.ToUnit(VolumePerLengthUnit.CubicMeterPerMeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.LiterPerMeter, VolumePerLengthUnit.CubicMeterPerMeter, quantity => quantity.ToUnit(VolumePerLengthUnit.CubicMeterPerMeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.LiterPerMillimeter, VolumePerLengthUnit.CubicMeterPerMeter, quantity => quantity.ToUnit(VolumePerLengthUnit.CubicMeterPerMeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.OilBarrelPerFoot, VolumePerLengthUnit.CubicMeterPerMeter, quantity => quantity.ToUnit(VolumePerLengthUnit.CubicMeterPerMeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.UsGallonPerMile, VolumePerLengthUnit.CubicMeterPerMeter, quantity => quantity.ToUnit(VolumePerLengthUnit.CubicMeterPerMeter));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.CubicMeterPerMeter, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> VolumePerLengthUnit
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.CubicYardPerFoot, quantity => quantity.ToUnit(VolumePerLengthUnit.CubicYardPerFoot));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.CubicYardPerUsSurveyFoot, quantity => quantity.ToUnit(VolumePerLengthUnit.CubicYardPerUsSurveyFoot));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.ImperialGallonPerMile, quantity => quantity.ToUnit(VolumePerLengthUnit.ImperialGallonPerMile));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.LiterPerKilometer, quantity => quantity.ToUnit(VolumePerLengthUnit.LiterPerKilometer));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.LiterPerMeter, quantity => quantity.ToUnit(VolumePerLengthUnit.LiterPerMeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.LiterPerMillimeter, quantity => quantity.ToUnit(VolumePerLengthUnit.LiterPerMillimeter));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.OilBarrelPerFoot, quantity => quantity.ToUnit(VolumePerLengthUnit.OilBarrelPerFoot));
-            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.UsGallonPerMile, quantity => quantity.ToUnit(VolumePerLengthUnit.UsGallonPerMile));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -338,7 +321,7 @@ public static string GetAbbreviation(VolumePerLengthUnit unit, IFormatProvider?
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicMeterPerMeter"/>.
         /// </summary>
-        public static VolumePerLength FromCubicMetersPerMeter(double value)
+        public static VolumePerLength FromCubicMetersPerMeter(QuantityValue value)
         {
             return new VolumePerLength(value, VolumePerLengthUnit.CubicMeterPerMeter);
         }
@@ -346,7 +329,7 @@ public static VolumePerLength FromCubicMetersPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicYardPerFoot"/>.
         /// </summary>
-        public static VolumePerLength FromCubicYardsPerFoot(double value)
+        public static VolumePerLength FromCubicYardsPerFoot(QuantityValue value)
         {
             return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerFoot);
         }
@@ -354,7 +337,7 @@ public static VolumePerLength FromCubicYardsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicYardPerUsSurveyFoot"/>.
         /// </summary>
-        public static VolumePerLength FromCubicYardsPerUsSurveyFoot(double value)
+        public static VolumePerLength FromCubicYardsPerUsSurveyFoot(QuantityValue value)
         {
             return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
         }
@@ -362,7 +345,7 @@ public static VolumePerLength FromCubicYardsPerUsSurveyFoot(double value)
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.ImperialGallonPerMile"/>.
         /// </summary>
-        public static VolumePerLength FromImperialGallonsPerMile(double value)
+        public static VolumePerLength FromImperialGallonsPerMile(QuantityValue value)
         {
             return new VolumePerLength(value, VolumePerLengthUnit.ImperialGallonPerMile);
         }
@@ -370,7 +353,7 @@ public static VolumePerLength FromImperialGallonsPerMile(double value)
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerKilometer"/>.
         /// </summary>
-        public static VolumePerLength FromLitersPerKilometer(double value)
+        public static VolumePerLength FromLitersPerKilometer(QuantityValue value)
         {
             return new VolumePerLength(value, VolumePerLengthUnit.LiterPerKilometer);
         }
@@ -378,7 +361,7 @@ public static VolumePerLength FromLitersPerKilometer(double value)
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerMeter"/>.
         /// </summary>
-        public static VolumePerLength FromLitersPerMeter(double value)
+        public static VolumePerLength FromLitersPerMeter(QuantityValue value)
         {
             return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMeter);
         }
@@ -386,7 +369,7 @@ public static VolumePerLength FromLitersPerMeter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerMillimeter"/>.
         /// </summary>
-        public static VolumePerLength FromLitersPerMillimeter(double value)
+        public static VolumePerLength FromLitersPerMillimeter(QuantityValue value)
         {
             return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMillimeter);
         }
@@ -394,7 +377,7 @@ public static VolumePerLength FromLitersPerMillimeter(double value)
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.OilBarrelPerFoot"/>.
         /// </summary>
-        public static VolumePerLength FromOilBarrelsPerFoot(double value)
+        public static VolumePerLength FromOilBarrelsPerFoot(QuantityValue value)
         {
             return new VolumePerLength(value, VolumePerLengthUnit.OilBarrelPerFoot);
         }
@@ -402,7 +385,7 @@ public static VolumePerLength FromOilBarrelsPerFoot(double value)
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.UsGallonPerMile"/>.
         /// </summary>
-        public static VolumePerLength FromUsGallonsPerMile(double value)
+        public static VolumePerLength FromUsGallonsPerMile(QuantityValue value)
         {
             return new VolumePerLength(value, VolumePerLengthUnit.UsGallonPerMile);
         }
@@ -413,7 +396,7 @@ public static VolumePerLength FromUsGallonsPerMile(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VolumePerLength unit value.</returns>
-        public static VolumePerLength From(double value, VolumePerLengthUnit fromUnit)
+        public static VolumePerLength From(QuantityValue value, VolumePerLengthUnit fromUnit)
         {
             return new VolumePerLength(value, fromUnit);
         }
@@ -474,10 +457,7 @@ public static VolumePerLength Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static VolumePerLength Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<VolumePerLength, VolumePerLengthUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<VolumePerLength, VolumePerLengthUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -505,11 +485,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out VolumePerLength
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumePerLength result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<VolumePerLength, VolumePerLengthUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<VolumePerLength, VolumePerLengthUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -530,7 +506,7 @@ public static VolumePerLengthUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -541,7 +517,7 @@ public static VolumePerLengthUnit ParseUnit(string str, IFormatProvider? provide
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumePerLengthUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.VolumePerLengthUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumePerLengthUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -556,7 +532,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumePerLen
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumePerLengthUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -575,137 +551,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="VolumePerLength"/> from adding two <see cref="VolumePerLength"/>.</summary>
         public static VolumePerLength operator +(VolumePerLength left, VolumePerLength right)
         {
-            return new VolumePerLength(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new VolumePerLength(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VolumePerLength"/> from subtracting two <see cref="VolumePerLength"/>.</summary>
         public static VolumePerLength operator -(VolumePerLength left, VolumePerLength right)
         {
-            return new VolumePerLength(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new VolumePerLength(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VolumePerLength"/> from multiplying value and <see cref="VolumePerLength"/>.</summary>
-        public static VolumePerLength operator *(double left, VolumePerLength right)
+        public static VolumePerLength operator *(QuantityValue left, VolumePerLength right)
         {
             return new VolumePerLength(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="VolumePerLength"/> from multiplying value and <see cref="VolumePerLength"/>.</summary>
-        public static VolumePerLength operator *(VolumePerLength left, double right)
+        public static VolumePerLength operator *(VolumePerLength left, QuantityValue right)
         {
             return new VolumePerLength(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="VolumePerLength"/> from dividing <see cref="VolumePerLength"/> by value.</summary>
-        public static VolumePerLength operator /(VolumePerLength left, double right)
+        public static VolumePerLength operator /(VolumePerLength left, QuantityValue right)
         {
             return new VolumePerLength(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="VolumePerLength"/> by <see cref="VolumePerLength"/>.</summary>
-        public static double operator /(VolumePerLength left, VolumePerLength right)
+        public static QuantityValue operator /(VolumePerLength left, VolumePerLength right)
         {
             return left.CubicMetersPerMeter / right.CubicMetersPerMeter;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="Volume"/> from <see cref="VolumePerLength"/> * <see cref="Length"/>.</summary>
+        public static Volume operator *(VolumePerLength volumePerLength, Length length)
+        {
+            return Volume.FromCubicMeters(volumePerLength.CubicMetersPerMeter * length.Meters);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(VolumePerLength left, VolumePerLength right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(VolumePerLength left, VolumePerLength right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(VolumePerLength left, VolumePerLength right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(VolumePerLength left, VolumePerLength right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="VolumePerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VolumePerLength other, VolumePerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VolumePerLength"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(VolumePerLength)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(VolumePerLength left, VolumePerLength right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="VolumePerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VolumePerLength other, VolumePerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VolumePerLength"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(VolumePerLength,VolumePerLength)"/>.
+        ///     See that operator (and <see cref="Equals(VolumePerLength)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(VolumePerLength left, VolumePerLength right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VolumePerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VolumePerLength other, VolumePerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="VolumePerLength"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="VolumePerLength"/>.
+        ///     When <paramref name="obj"/> is a <see cref="VolumePerLength"/>, this method delegates to
+        ///     <see cref="Equals(VolumePerLength)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is VolumePerLength otherQuantity))
+            if (obj is not VolumePerLength otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VolumePerLength"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VolumePerLength other, VolumePerLength tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="VolumePerLength"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(VolumePerLength other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current VolumePerLength.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(VolumePerLength), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="VolumePerLength"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(VolumePerLength)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is VolumePerLength otherQuantity)) throw new ArgumentException("Expected type VolumePerLength.", nameof(obj));
+            if (obj is not VolumePerLength otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<VolumePerLength>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="VolumePerLength"/> with another <see cref="VolumePerLength"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="VolumePerLength"/> with another <see cref="VolumePerLength"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -717,145 +717,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(VolumePerLength other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(VolumePerLengthUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<VolumePerLengthUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this VolumePerLength to another VolumePerLength with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A VolumePerLength with the specified unit.</returns>
-        public VolumePerLength ToUnit(VolumePerLengthUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="VolumePerLength"/> to another <see cref="VolumePerLength"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A VolumePerLength with the specified unit.</returns>
-        public VolumePerLength ToUnit(VolumePerLengthUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(VolumePerLength), Unit, typeof(VolumePerLength), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (VolumePerLength)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="VolumePerLength"/> to another <see cref="VolumePerLength"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="VolumePerLength"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(VolumePerLengthUnit unit, [NotNullWhen(true)] out VolumePerLength? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            VolumePerLength? convertedOrNull = (Unit, unit) switch
-            {
-                // VolumePerLengthUnit -> BaseUnit
-                (VolumePerLengthUnit.CubicYardPerFoot, VolumePerLengthUnit.CubicMeterPerMeter) => new VolumePerLength(_value * 0.764554857984 / 0.3048, VolumePerLengthUnit.CubicMeterPerMeter),
-                (VolumePerLengthUnit.CubicYardPerUsSurveyFoot, VolumePerLengthUnit.CubicMeterPerMeter) => new VolumePerLength(_value * 0.764554857984 * 3937 / 1200, VolumePerLengthUnit.CubicMeterPerMeter),
-                (VolumePerLengthUnit.ImperialGallonPerMile, VolumePerLengthUnit.CubicMeterPerMeter) => new VolumePerLength(_value * 0.00454609 / 1609.344, VolumePerLengthUnit.CubicMeterPerMeter),
-                (VolumePerLengthUnit.LiterPerKilometer, VolumePerLengthUnit.CubicMeterPerMeter) => new VolumePerLength(_value / 1e6, VolumePerLengthUnit.CubicMeterPerMeter),
-                (VolumePerLengthUnit.LiterPerMeter, VolumePerLengthUnit.CubicMeterPerMeter) => new VolumePerLength(_value / 1000, VolumePerLengthUnit.CubicMeterPerMeter),
-                (VolumePerLengthUnit.LiterPerMillimeter, VolumePerLengthUnit.CubicMeterPerMeter) => new VolumePerLength(_value, VolumePerLengthUnit.CubicMeterPerMeter),
-                (VolumePerLengthUnit.OilBarrelPerFoot, VolumePerLengthUnit.CubicMeterPerMeter) => new VolumePerLength(_value * 0.158987294928 / 0.3048, VolumePerLengthUnit.CubicMeterPerMeter),
-                (VolumePerLengthUnit.UsGallonPerMile, VolumePerLengthUnit.CubicMeterPerMeter) => new VolumePerLength(_value * 0.003785411784 / 1609.344, VolumePerLengthUnit.CubicMeterPerMeter),
-
-                // BaseUnit -> VolumePerLengthUnit
-                (VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.CubicYardPerFoot) => new VolumePerLength(_value * 0.3048 / 0.764554857984, VolumePerLengthUnit.CubicYardPerFoot),
-                (VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.CubicYardPerUsSurveyFoot) => new VolumePerLength(_value * 1200 / (0.764554857984 * 3937), VolumePerLengthUnit.CubicYardPerUsSurveyFoot),
-                (VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.ImperialGallonPerMile) => new VolumePerLength(_value * 1609.344 / 0.00454609, VolumePerLengthUnit.ImperialGallonPerMile),
-                (VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.LiterPerKilometer) => new VolumePerLength(_value * 1e6, VolumePerLengthUnit.LiterPerKilometer),
-                (VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.LiterPerMeter) => new VolumePerLength(_value * 1000, VolumePerLengthUnit.LiterPerMeter),
-                (VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.LiterPerMillimeter) => new VolumePerLength(_value, VolumePerLengthUnit.LiterPerMillimeter),
-                (VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.OilBarrelPerFoot) => new VolumePerLength(_value * 0.3048 / 0.158987294928, VolumePerLengthUnit.OilBarrelPerFoot),
-                (VolumePerLengthUnit.CubicMeterPerMeter, VolumePerLengthUnit.UsGallonPerMile) => new VolumePerLength(_value * 1609.344 / 0.003785411784, VolumePerLengthUnit.UsGallonPerMile),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not VolumePerLengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumePerLengthUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is VolumePerLengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumePerLengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity<VolumePerLengthUnit> IQuantity<VolumePerLengthUnit>.ToUnit(VolumePerLengthUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -869,11 +733,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
index 650743addb..e9ea8a0dc5 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -38,11 +36,13 @@ namespace UnitsNet
     ///     https://en.wikipedia.org/wiki/Volumetric_heat_capacity
     /// </remarks>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct VolumetricHeatCapacity :
-        IArithmeticQuantity<VolumetricHeatCapacity, VolumetricHeatCapacityUnit>,
+        ILinearQuantity<VolumetricHeatCapacity, VolumetricHeatCapacityUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<VolumetricHeatCapacity, VolumetricHeatCapacity, double>,
+        IDivisionOperators<VolumetricHeatCapacity, VolumetricHeatCapacity, QuantityValue>,
+        IMultiplyOperators<VolumetricHeatCapacity, TemperatureDelta, EnergyDensity>,
         IComparisonOperators<VolumetricHeatCapacity, VolumetricHeatCapacity, bool>,
         IParsable<VolumetricHeatCapacity>,
 #endif
@@ -55,7 +55,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -105,7 +105,7 @@ public static VolumetricHeatCapacityInfo CreateDefault(Func<IEnumerable<UnitDefi
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="VolumetricHeatCapacity"/> is [T^-2][L^-1][M][Θ^-1].
+            ///     The <see cref="BaseDimensions" /> for <see cref="VolumetricHeatCapacity"/> is T^-2L^-1MΘ^-1.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-1, 1, -2, 0, -1, 0, 0);
 
@@ -120,23 +120,37 @@ public static VolumetricHeatCapacityInfo CreateDefault(Func<IEnumerable<UnitDefi
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{VolumetricHeatCapacityUnit}"/> representing the default unit mappings for VolumetricHeatCapacity.</returns>
             public static IEnumerable<UnitDefinition<VolumetricHeatCapacityUnit>> GetDefaultMappings()
             {
-                yield return new (VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit, "BtuPerCubicFootDegreeFahrenheit", "BtusPerCubicFootDegreeFahrenheit", BaseUnits.Undefined);
-                yield return new (VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius, "CaloriePerCubicCentimeterDegreeCelsius", "CaloriesPerCubicCentimeterDegreeCelsius", BaseUnits.Undefined);
-                yield return new (VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius, "JoulePerCubicMeterDegreeCelsius", "JoulesPerCubicMeterDegreeCelsius", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius));
+                yield return new (VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit, "BtuPerCubicFootDegreeFahrenheit", "BtusPerCubicFootDegreeFahrenheit", BaseUnits.Undefined,
+                     new QuantityValue(98322384, 6594099078875)
+                );
+                yield return new (VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius, "CaloriePerCubicCentimeterDegreeCelsius", "CaloriesPerCubicCentimeterDegreeCelsius", BaseUnits.Undefined,
+                     new QuantityValue(1, 4184000)
+                );
+                yield return new (VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius, "JoulePerCubicMeterDegreeCelsius", "JoulesPerCubicMeterDegreeCelsius", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius),
+                     1
+                );
                 yield return new (VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, "JoulePerCubicMeterKelvin", "JoulesPerCubicMeterKelvin", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
-                yield return new (VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius, "KilocaloriePerCubicCentimeterDegreeCelsius", "KilocaloriesPerCubicCentimeterDegreeCelsius", BaseUnits.Undefined);
-                yield return new (VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius, "KilojoulePerCubicMeterDegreeCelsius", "KilojoulesPerCubicMeterDegreeCelsius", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin, "KilojoulePerCubicMeterKelvin", "KilojoulesPerCubicMeterKelvin", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
-                yield return new (VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius, "MegajoulePerCubicMeterDegreeCelsius", "MegajoulesPerCubicMeterDegreeCelsius", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius));
-                yield return new (VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin, "MegajoulePerCubicMeterKelvin", "MegajoulesPerCubicMeterKelvin", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin));
+                yield return new (VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius, "KilocaloriePerCubicCentimeterDegreeCelsius", "KilocaloriesPerCubicCentimeterDegreeCelsius", BaseUnits.Undefined,
+                     new QuantityValue(1, 4184000000)
+                );
+                yield return new (VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius, "KilojoulePerCubicMeterDegreeCelsius", "KilojoulesPerCubicMeterDegreeCelsius", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin, "KilojoulePerCubicMeterKelvin", "KilojoulesPerCubicMeterKelvin", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin),
+                     new QuantityValue(1, 1000)
+                );
+                yield return new (VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius, "MegajoulePerCubicMeterDegreeCelsius", "MegajoulesPerCubicMeterDegreeCelsius", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.DegreeCelsius),
+                     new QuantityValue(1, 1000000)
+                );
+                yield return new (VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin, "MegajoulePerCubicMeterKelvin", "MegajoulesPerCubicMeterKelvin", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second, temperature: TemperatureUnit.Kelvin),
+                     new QuantityValue(1, 1000000)
+                );
             }
         }
 
         static VolumetricHeatCapacity()
         {
-            Info = VolumetricHeatCapacityInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(VolumetricHeatCapacityInfo.CreateDefault);
         }
 
         /// <summary>
@@ -144,7 +158,7 @@ static VolumetricHeatCapacity()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public VolumetricHeatCapacity(double value, VolumetricHeatCapacityUnit unit)
+        public VolumetricHeatCapacity(QuantityValue value, VolumetricHeatCapacityUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -158,7 +172,7 @@ public VolumetricHeatCapacity(double value, VolumetricHeatCapacityUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public VolumetricHeatCapacity(double value, UnitSystem unitSystem)
+        public VolumetricHeatCapacity(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -169,7 +183,8 @@ public VolumetricHeatCapacity(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="VolumetricHeatCapacity" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<VolumetricHeatCapacity, VolumetricHeatCapacityUnit> Info { get; }
@@ -198,10 +213,8 @@ public VolumetricHeatCapacity(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public VolumetricHeatCapacityUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -235,84 +248,54 @@ public VolumetricHeatCapacity(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit"/>
         /// </summary>
-        public double BtusPerCubicFootDegreeFahrenheit => As(VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit);
+        public QuantityValue BtusPerCubicFootDegreeFahrenheit => this.As(VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius"/>
         /// </summary>
-        public double CaloriesPerCubicCentimeterDegreeCelsius => As(VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius);
+        public QuantityValue CaloriesPerCubicCentimeterDegreeCelsius => this.As(VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius"/>
         /// </summary>
-        public double JoulesPerCubicMeterDegreeCelsius => As(VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius);
+        public QuantityValue JoulesPerCubicMeterDegreeCelsius => this.As(VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin"/>
         /// </summary>
-        public double JoulesPerCubicMeterKelvin => As(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin);
+        public QuantityValue JoulesPerCubicMeterKelvin => this.As(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius"/>
         /// </summary>
-        public double KilocaloriesPerCubicCentimeterDegreeCelsius => As(VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius);
+        public QuantityValue KilocaloriesPerCubicCentimeterDegreeCelsius => this.As(VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius"/>
         /// </summary>
-        public double KilojoulesPerCubicMeterDegreeCelsius => As(VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius);
+        public QuantityValue KilojoulesPerCubicMeterDegreeCelsius => this.As(VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin"/>
         /// </summary>
-        public double KilojoulesPerCubicMeterKelvin => As(VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin);
+        public QuantityValue KilojoulesPerCubicMeterKelvin => this.As(VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius"/>
         /// </summary>
-        public double MegajoulesPerCubicMeterDegreeCelsius => As(VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius);
+        public QuantityValue MegajoulesPerCubicMeterDegreeCelsius => this.As(VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin"/>
         /// </summary>
-        public double MegajoulesPerCubicMeterKelvin => As(VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin);
+        public QuantityValue MegajoulesPerCubicMeterKelvin => this.As(VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: VolumetricHeatCapacityUnit -> BaseUnit
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> VolumetricHeatCapacityUnit
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius));
-            unitConverter.SetConversionFunction<VolumetricHeatCapacity>(VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin, quantity => quantity.ToUnit(VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -341,7 +324,7 @@ public static string GetAbbreviation(VolumetricHeatCapacityUnit unit, IFormatPro
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit"/>.
         /// </summary>
-        public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(double value)
+        public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(QuantityValue value)
         {
             return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit);
         }
@@ -349,7 +332,7 @@ public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(double
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius"/>.
         /// </summary>
-        public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius(double value)
+        public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius(QuantityValue value)
         {
             return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius);
         }
@@ -357,7 +340,7 @@ public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius"/>.
         /// </summary>
-        public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(double value)
+        public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(QuantityValue value)
         {
             return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius);
         }
@@ -365,7 +348,7 @@ public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(double
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin"/>.
         /// </summary>
-        public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(double value)
+        public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(QuantityValue value)
         {
             return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin);
         }
@@ -373,7 +356,7 @@ public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(double value)
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius"/>.
         /// </summary>
-        public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCelsius(double value)
+        public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCelsius(QuantityValue value)
         {
             return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius);
         }
@@ -381,7 +364,7 @@ public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCel
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius"/>.
         /// </summary>
-        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(double value)
+        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(QuantityValue value)
         {
             return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius);
         }
@@ -389,7 +372,7 @@ public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(do
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin"/>.
         /// </summary>
-        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(double value)
+        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(QuantityValue value)
         {
             return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin);
         }
@@ -397,7 +380,7 @@ public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(double va
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius"/>.
         /// </summary>
-        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(double value)
+        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(QuantityValue value)
         {
             return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius);
         }
@@ -405,7 +388,7 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(do
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin"/>.
         /// </summary>
-        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(double value)
+        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(QuantityValue value)
         {
             return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin);
         }
@@ -416,7 +399,7 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(double va
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VolumetricHeatCapacity unit value.</returns>
-        public static VolumetricHeatCapacity From(double value, VolumetricHeatCapacityUnit fromUnit)
+        public static VolumetricHeatCapacity From(QuantityValue value, VolumetricHeatCapacityUnit fromUnit)
         {
             return new VolumetricHeatCapacity(value, fromUnit);
         }
@@ -477,10 +460,7 @@ public static VolumetricHeatCapacity Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static VolumetricHeatCapacity Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<VolumetricHeatCapacity, VolumetricHeatCapacityUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<VolumetricHeatCapacity, VolumetricHeatCapacityUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -508,11 +488,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out VolumetricHeatCa
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumetricHeatCapacity result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<VolumetricHeatCapacity, VolumetricHeatCapacityUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<VolumetricHeatCapacity, VolumetricHeatCapacityUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -533,7 +509,7 @@ public static VolumetricHeatCapacityUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -544,7 +520,7 @@ public static VolumetricHeatCapacityUnit ParseUnit(string str, IFormatProvider?
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.VolumetricHeatCapacityUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.VolumetricHeatCapacityUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumetricHeatCapacityUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -559,7 +535,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out VolumetricHe
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out VolumetricHeatCapacityUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -578,137 +554,161 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="VolumetricHeatCapacity"/> from adding two <see cref="VolumetricHeatCapacity"/>.</summary>
         public static VolumetricHeatCapacity operator +(VolumetricHeatCapacity left, VolumetricHeatCapacity right)
         {
-            return new VolumetricHeatCapacity(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new VolumetricHeatCapacity(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VolumetricHeatCapacity"/> from subtracting two <see cref="VolumetricHeatCapacity"/>.</summary>
         public static VolumetricHeatCapacity operator -(VolumetricHeatCapacity left, VolumetricHeatCapacity right)
         {
-            return new VolumetricHeatCapacity(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new VolumetricHeatCapacity(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="VolumetricHeatCapacity"/> from multiplying value and <see cref="VolumetricHeatCapacity"/>.</summary>
-        public static VolumetricHeatCapacity operator *(double left, VolumetricHeatCapacity right)
+        public static VolumetricHeatCapacity operator *(QuantityValue left, VolumetricHeatCapacity right)
         {
             return new VolumetricHeatCapacity(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="VolumetricHeatCapacity"/> from multiplying value and <see cref="VolumetricHeatCapacity"/>.</summary>
-        public static VolumetricHeatCapacity operator *(VolumetricHeatCapacity left, double right)
+        public static VolumetricHeatCapacity operator *(VolumetricHeatCapacity left, QuantityValue right)
         {
             return new VolumetricHeatCapacity(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="VolumetricHeatCapacity"/> from dividing <see cref="VolumetricHeatCapacity"/> by value.</summary>
-        public static VolumetricHeatCapacity operator /(VolumetricHeatCapacity left, double right)
+        public static VolumetricHeatCapacity operator /(VolumetricHeatCapacity left, QuantityValue right)
         {
             return new VolumetricHeatCapacity(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="VolumetricHeatCapacity"/> by <see cref="VolumetricHeatCapacity"/>.</summary>
-        public static double operator /(VolumetricHeatCapacity left, VolumetricHeatCapacity right)
+        public static QuantityValue operator /(VolumetricHeatCapacity left, VolumetricHeatCapacity right)
         {
             return left.JoulesPerCubicMeterKelvin / right.JoulesPerCubicMeterKelvin;
         }
 
         #endregion
 
+        #region Relational Operators
+
+        /// <summary>Get <see cref="EnergyDensity"/> from <see cref="VolumetricHeatCapacity"/> * <see cref="TemperatureDelta"/>.</summary>
+        public static EnergyDensity operator *(VolumetricHeatCapacity volumetricHeatCapacity, TemperatureDelta temperatureDelta)
+        {
+            return EnergyDensity.FromJoulesPerCubicMeter(volumetricHeatCapacity.JoulesPerCubicMeterKelvin * temperatureDelta.Kelvins);
+        }
+
+        #endregion
+
         #region Equality / IComparable
 
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(VolumetricHeatCapacity left, VolumetricHeatCapacity right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(VolumetricHeatCapacity left, VolumetricHeatCapacity right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(VolumetricHeatCapacity left, VolumetricHeatCapacity right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(VolumetricHeatCapacity left, VolumetricHeatCapacity right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="VolumetricHeatCapacity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VolumetricHeatCapacity other, VolumetricHeatCapacity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VolumetricHeatCapacity"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(VolumetricHeatCapacity)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(VolumetricHeatCapacity left, VolumetricHeatCapacity right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="VolumetricHeatCapacity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(VolumetricHeatCapacity other, VolumetricHeatCapacity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="VolumetricHeatCapacity"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(VolumetricHeatCapacity,VolumetricHeatCapacity)"/>.
+        ///     See that operator (and <see cref="Equals(VolumetricHeatCapacity)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(VolumetricHeatCapacity left, VolumetricHeatCapacity right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VolumetricHeatCapacity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VolumetricHeatCapacity other, VolumetricHeatCapacity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="VolumetricHeatCapacity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="VolumetricHeatCapacity"/>.
+        ///     When <paramref name="obj"/> is a <see cref="VolumetricHeatCapacity"/>, this method delegates to
+        ///     <see cref="Equals(VolumetricHeatCapacity)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is VolumetricHeatCapacity otherQuantity))
+            if (obj is not VolumetricHeatCapacity otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="VolumetricHeatCapacity"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(VolumetricHeatCapacity other, VolumetricHeatCapacity tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="VolumetricHeatCapacity"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(VolumetricHeatCapacity other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current VolumetricHeatCapacity.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(VolumetricHeatCapacity), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="VolumetricHeatCapacity"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(VolumetricHeatCapacity)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is VolumetricHeatCapacity otherQuantity)) throw new ArgumentException("Expected type VolumetricHeatCapacity.", nameof(obj));
+            if (obj is not VolumetricHeatCapacity otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<VolumetricHeatCapacity>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="VolumetricHeatCapacity"/> with another <see cref="VolumetricHeatCapacity"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="VolumetricHeatCapacity"/> with another <see cref="VolumetricHeatCapacity"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -720,145 +720,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(VolumetricHeatCapacity other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(VolumetricHeatCapacityUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<VolumetricHeatCapacityUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this VolumetricHeatCapacity to another VolumetricHeatCapacity with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A VolumetricHeatCapacity with the specified unit.</returns>
-        public VolumetricHeatCapacity ToUnit(VolumetricHeatCapacityUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
-        }
-
-        /// <summary>
-        ///     Converts this <see cref="VolumetricHeatCapacity"/> to another <see cref="VolumetricHeatCapacity"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A VolumetricHeatCapacity with the specified unit.</returns>
-        public VolumetricHeatCapacity ToUnit(VolumetricHeatCapacityUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(VolumetricHeatCapacity), Unit, typeof(VolumetricHeatCapacity), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (VolumetricHeatCapacity)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="VolumetricHeatCapacity"/> to another <see cref="VolumetricHeatCapacity"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="VolumetricHeatCapacity"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(VolumetricHeatCapacityUnit unit, [NotNullWhen(true)] out VolumetricHeatCapacity? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            VolumetricHeatCapacity? convertedOrNull = (Unit, unit) switch
-            {
-                // VolumetricHeatCapacityUnit -> BaseUnit
-                (VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin) => new VolumetricHeatCapacity(_value * (1055.05585262 / 0.028316846592) * 1.8, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin),
-                (VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin) => new VolumetricHeatCapacity(_value * 4.184e6, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin),
-                (VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin) => new VolumetricHeatCapacity(_value, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin),
-                (VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin) => new VolumetricHeatCapacity((_value * 4.184e6) * 1e3d, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin),
-                (VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin) => new VolumetricHeatCapacity((_value) * 1e3d, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin),
-                (VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin) => new VolumetricHeatCapacity((_value) * 1e3d, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin),
-                (VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin) => new VolumetricHeatCapacity((_value) * 1e6d, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin),
-                (VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin) => new VolumetricHeatCapacity((_value) * 1e6d, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin),
-
-                // BaseUnit -> VolumetricHeatCapacityUnit
-                (VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit) => new VolumetricHeatCapacity(_value / ((1055.05585262 / 0.028316846592) * 1.8), VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit),
-                (VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius) => new VolumetricHeatCapacity(_value / 4.184e6, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius),
-                (VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius) => new VolumetricHeatCapacity(_value, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius),
-                (VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius) => new VolumetricHeatCapacity((_value / 4.184e6) / 1e3d, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius),
-                (VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius) => new VolumetricHeatCapacity((_value) / 1e3d, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius),
-                (VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin) => new VolumetricHeatCapacity((_value) / 1e3d, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin),
-                (VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius) => new VolumetricHeatCapacity((_value) / 1e6d, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius),
-                (VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin) => new VolumetricHeatCapacity((_value) / 1e6d, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not VolumetricHeatCapacityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumetricHeatCapacityUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is VolumetricHeatCapacityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumetricHeatCapacityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <inheritdoc />
-        IQuantity<VolumetricHeatCapacityUnit> IQuantity<VolumetricHeatCapacityUnit>.ToUnit(VolumetricHeatCapacityUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -872,11 +736,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
index bd87fe23e2..0789620514 100644
--- a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
@@ -20,9 +20,7 @@
 using System.Globalization;
 using System.Resources;
 using System.Runtime.Serialization;
-#if NET
-using System.Numerics;
-#endif
+using UnitsNet.Debug;
 
 #nullable enable
 
@@ -35,11 +33,12 @@ namespace UnitsNet
     ///     A geometric property of an area that is used to determine the warping stress.
     /// </summary>
     [DataContract]
-    [DebuggerTypeProxy(typeof(QuantityDisplay))]
+    [DebuggerDisplay(QuantityDebugProxy.DisplayFormat)]
+    [DebuggerTypeProxy(typeof(QuantityDebugProxy))]
     public readonly partial struct WarpingMomentOfInertia :
-        IArithmeticQuantity<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>,
+        ILinearQuantity<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>,
 #if NET7_0_OR_GREATER
-        IDivisionOperators<WarpingMomentOfInertia, WarpingMomentOfInertia, double>,
+        IDivisionOperators<WarpingMomentOfInertia, WarpingMomentOfInertia, QuantityValue>,
         IComparisonOperators<WarpingMomentOfInertia, WarpingMomentOfInertia, bool>,
         IParsable<WarpingMomentOfInertia>,
 #endif
@@ -52,7 +51,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = "Value", Order = 1)]
-        private readonly double _value;
+        private readonly QuantityValue _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -102,7 +101,7 @@ public static WarpingMomentOfInertiaInfo CreateDefault(Func<IEnumerable<UnitDefi
             }
 
             /// <summary>
-            ///     The <see cref="BaseDimensions" /> for <see cref="WarpingMomentOfInertia"/> is [L^6].
+            ///     The <see cref="BaseDimensions" /> for <see cref="WarpingMomentOfInertia"/> is L^6.
             /// </summary>
             public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(6, 0, 0, 0, 0, 0, 0);
 
@@ -117,20 +116,28 @@ public static WarpingMomentOfInertiaInfo CreateDefault(Func<IEnumerable<UnitDefi
             /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="UnitDefinition{WarpingMomentOfInertiaUnit}"/> representing the default unit mappings for WarpingMomentOfInertia.</returns>
             public static IEnumerable<UnitDefinition<WarpingMomentOfInertiaUnit>> GetDefaultMappings()
             {
-                yield return new (WarpingMomentOfInertiaUnit.CentimeterToTheSixth, "CentimeterToTheSixth", "CentimetersToTheSixth", new BaseUnits(length: LengthUnit.Centimeter));
-                yield return new (WarpingMomentOfInertiaUnit.DecimeterToTheSixth, "DecimeterToTheSixth", "DecimetersToTheSixth", new BaseUnits(length: LengthUnit.Decimeter));
-                yield return new (WarpingMomentOfInertiaUnit.FootToTheSixth, "FootToTheSixth", "FeetToTheSixth", new BaseUnits(length: LengthUnit.Foot));
-                yield return new (WarpingMomentOfInertiaUnit.InchToTheSixth, "InchToTheSixth", "InchesToTheSixth", new BaseUnits(length: LengthUnit.Inch));
+                yield return new (WarpingMomentOfInertiaUnit.CentimeterToTheSixth, "CentimeterToTheSixth", "CentimetersToTheSixth", new BaseUnits(length: LengthUnit.Centimeter),
+                     1000000000000
+                );
+                yield return new (WarpingMomentOfInertiaUnit.DecimeterToTheSixth, "DecimeterToTheSixth", "DecimetersToTheSixth", new BaseUnits(length: LengthUnit.Decimeter),
+                     1000000
+                );
+                yield return new (WarpingMomentOfInertiaUnit.FootToTheSixth, "FootToTheSixth", "FeetToTheSixth", new BaseUnits(length: LengthUnit.Foot),
+                     new QuantityValue(3814697265625000000, 3058791354808281)
+                );
+                yield return new (WarpingMomentOfInertiaUnit.InchToTheSixth, "InchToTheSixth", "InchesToTheSixth", new BaseUnits(length: LengthUnit.Inch),
+                     new QuantityValue(new BigInteger(15625) * QuantityValue.PowerOfTen(18), 4195872914689)
+                );
                 yield return new (WarpingMomentOfInertiaUnit.MeterToTheSixth, "MeterToTheSixth", "MetersToTheSixth", new BaseUnits(length: LengthUnit.Meter));
-                yield return new (WarpingMomentOfInertiaUnit.MillimeterToTheSixth, "MillimeterToTheSixth", "MillimetersToTheSixth", new BaseUnits(length: LengthUnit.Millimeter));
+                yield return new (WarpingMomentOfInertiaUnit.MillimeterToTheSixth, "MillimeterToTheSixth", "MillimetersToTheSixth", new BaseUnits(length: LengthUnit.Millimeter),
+                     1000000000000000000
+                );
             }
         }
 
         static WarpingMomentOfInertia()
         {
-            Info = WarpingMomentOfInertiaInfo.CreateDefault();
-            DefaultConversionFunctions = new UnitConverter();
-            RegisterDefaultConversions(DefaultConversionFunctions);
+            Info = UnitsNetSetup.CreateQuantityInfo(WarpingMomentOfInertiaInfo.CreateDefault);
         }
 
         /// <summary>
@@ -138,7 +145,7 @@ static WarpingMomentOfInertia()
         /// </summary>
         /// <param name="value">The numeric value to construct this quantity with.</param>
         /// <param name="unit">The unit representation to construct this quantity with.</param>
-        public WarpingMomentOfInertia(double value, WarpingMomentOfInertiaUnit unit)
+        public WarpingMomentOfInertia(QuantityValue value, WarpingMomentOfInertiaUnit unit)
         {
             _value = value;
             _unit = unit;
@@ -152,7 +159,7 @@ public WarpingMomentOfInertia(double value, WarpingMomentOfInertiaUnit unit)
         /// <param name="unitSystem">The unit system to create the quantity with.</param>
         /// <exception cref="ArgumentNullException">The given <see cref="UnitSystem"/> is null.</exception>
         /// <exception cref="ArgumentException">No unit was found for the given <see cref="UnitSystem"/>.</exception>
-        public WarpingMomentOfInertia(double value, UnitSystem unitSystem)
+        public WarpingMomentOfInertia(QuantityValue value, UnitSystem unitSystem)
         {
             _value = value;
             _unit = Info.GetDefaultUnit(unitSystem);
@@ -163,7 +170,8 @@ public WarpingMomentOfInertia(double value, UnitSystem unitSystem)
         /// <summary>
         ///     The <see cref="UnitConverter" /> containing the default generated conversion functions for <see cref="WarpingMomentOfInertia" /> instances.
         /// </summary>
-        public static UnitConverter DefaultConversionFunctions { get; }
+        [Obsolete("Replaced by UnitConverter.Default")]
+        public static UnitConverter DefaultConversionFunctions => UnitConverter.Default;
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         public static QuantityInfo<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit> Info { get; }
@@ -192,10 +200,8 @@ public WarpingMomentOfInertia(double value, UnitSystem unitSystem)
 
         #region Properties
 
-        /// <summary>
-        ///     The numeric value this quantity was constructed with.
-        /// </summary>
-        public double Value => _value;
+        /// <inheritdoc />
+        public QuantityValue Value => _value;
 
         /// <inheritdoc />
         public WarpingMomentOfInertiaUnit Unit => _unit.GetValueOrDefault(BaseUnit);
@@ -229,63 +235,39 @@ public WarpingMomentOfInertia(double value, UnitSystem unitSystem)
         #region Conversion Properties
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.CentimeterToTheSixth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.CentimeterToTheSixth"/>
         /// </summary>
-        public double CentimetersToTheSixth => As(WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
+        public QuantityValue CentimetersToTheSixth => this.As(WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.DecimeterToTheSixth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.DecimeterToTheSixth"/>
         /// </summary>
-        public double DecimetersToTheSixth => As(WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
+        public QuantityValue DecimetersToTheSixth => this.As(WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.FootToTheSixth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.FootToTheSixth"/>
         /// </summary>
-        public double FeetToTheSixth => As(WarpingMomentOfInertiaUnit.FootToTheSixth);
+        public QuantityValue FeetToTheSixth => this.As(WarpingMomentOfInertiaUnit.FootToTheSixth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.InchToTheSixth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.InchToTheSixth"/>
         /// </summary>
-        public double InchesToTheSixth => As(WarpingMomentOfInertiaUnit.InchToTheSixth);
+        public QuantityValue InchesToTheSixth => this.As(WarpingMomentOfInertiaUnit.InchToTheSixth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.MeterToTheSixth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.MeterToTheSixth"/>
         /// </summary>
-        public double MetersToTheSixth => As(WarpingMomentOfInertiaUnit.MeterToTheSixth);
+        public QuantityValue MetersToTheSixth => this.As(WarpingMomentOfInertiaUnit.MeterToTheSixth);
 
         /// <summary>
-        ///     Gets a <see cref="double"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.MillimeterToTheSixth"/>
+        ///     Gets a <see cref="QuantityValue"/> value of this quantity converted into <see cref="WarpingMomentOfInertiaUnit.MillimeterToTheSixth"/>
         /// </summary>
-        public double MillimetersToTheSixth => As(WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
+        public QuantityValue MillimetersToTheSixth => this.As(WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
 
         #endregion
 
         #region Static Methods
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        internal static void RegisterDefaultConversions(UnitConverter unitConverter)
-        {
-            // Register in unit converter: WarpingMomentOfInertiaUnit -> BaseUnit
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.CentimeterToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth, quantity => quantity.ToUnit(WarpingMomentOfInertiaUnit.MeterToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.DecimeterToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth, quantity => quantity.ToUnit(WarpingMomentOfInertiaUnit.MeterToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.FootToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth, quantity => quantity.ToUnit(WarpingMomentOfInertiaUnit.MeterToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.InchToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth, quantity => quantity.ToUnit(WarpingMomentOfInertiaUnit.MeterToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.MillimeterToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth, quantity => quantity.ToUnit(WarpingMomentOfInertiaUnit.MeterToTheSixth));
-
-            // Register in unit converter: BaseUnit <-> BaseUnit
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth, quantity => quantity);
-
-            // Register in unit converter: BaseUnit -> WarpingMomentOfInertiaUnit
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.CentimeterToTheSixth, quantity => quantity.ToUnit(WarpingMomentOfInertiaUnit.CentimeterToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.DecimeterToTheSixth, quantity => quantity.ToUnit(WarpingMomentOfInertiaUnit.DecimeterToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.FootToTheSixth, quantity => quantity.ToUnit(WarpingMomentOfInertiaUnit.FootToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.InchToTheSixth, quantity => quantity.ToUnit(WarpingMomentOfInertiaUnit.InchToTheSixth));
-            unitConverter.SetConversionFunction<WarpingMomentOfInertia>(WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.MillimeterToTheSixth, quantity => quantity.ToUnit(WarpingMomentOfInertiaUnit.MillimeterToTheSixth));
-        }
-
         /// <summary>
         ///     Get unit abbreviation string.
         /// </summary>
@@ -314,7 +296,7 @@ public static string GetAbbreviation(WarpingMomentOfInertiaUnit unit, IFormatPro
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.CentimeterToTheSixth"/>.
         /// </summary>
-        public static WarpingMomentOfInertia FromCentimetersToTheSixth(double value)
+        public static WarpingMomentOfInertia FromCentimetersToTheSixth(QuantityValue value)
         {
             return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
         }
@@ -322,7 +304,7 @@ public static WarpingMomentOfInertia FromCentimetersToTheSixth(double value)
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.DecimeterToTheSixth"/>.
         /// </summary>
-        public static WarpingMomentOfInertia FromDecimetersToTheSixth(double value)
+        public static WarpingMomentOfInertia FromDecimetersToTheSixth(QuantityValue value)
         {
             return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
         }
@@ -330,7 +312,7 @@ public static WarpingMomentOfInertia FromDecimetersToTheSixth(double value)
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.FootToTheSixth"/>.
         /// </summary>
-        public static WarpingMomentOfInertia FromFeetToTheSixth(double value)
+        public static WarpingMomentOfInertia FromFeetToTheSixth(QuantityValue value)
         {
             return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.FootToTheSixth);
         }
@@ -338,7 +320,7 @@ public static WarpingMomentOfInertia FromFeetToTheSixth(double value)
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.InchToTheSixth"/>.
         /// </summary>
-        public static WarpingMomentOfInertia FromInchesToTheSixth(double value)
+        public static WarpingMomentOfInertia FromInchesToTheSixth(QuantityValue value)
         {
             return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.InchToTheSixth);
         }
@@ -346,7 +328,7 @@ public static WarpingMomentOfInertia FromInchesToTheSixth(double value)
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.MeterToTheSixth"/>.
         /// </summary>
-        public static WarpingMomentOfInertia FromMetersToTheSixth(double value)
+        public static WarpingMomentOfInertia FromMetersToTheSixth(QuantityValue value)
         {
             return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MeterToTheSixth);
         }
@@ -354,7 +336,7 @@ public static WarpingMomentOfInertia FromMetersToTheSixth(double value)
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.MillimeterToTheSixth"/>.
         /// </summary>
-        public static WarpingMomentOfInertia FromMillimetersToTheSixth(double value)
+        public static WarpingMomentOfInertia FromMillimetersToTheSixth(QuantityValue value)
         {
             return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
         }
@@ -365,7 +347,7 @@ public static WarpingMomentOfInertia FromMillimetersToTheSixth(double value)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>WarpingMomentOfInertia unit value.</returns>
-        public static WarpingMomentOfInertia From(double value, WarpingMomentOfInertiaUnit fromUnit)
+        public static WarpingMomentOfInertia From(QuantityValue value, WarpingMomentOfInertiaUnit fromUnit)
         {
             return new WarpingMomentOfInertia(value, fromUnit);
         }
@@ -426,10 +408,7 @@ public static WarpingMomentOfInertia Parse(string str)
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static WarpingMomentOfInertia Parse(string str, IFormatProvider? provider)
         {
-            return UnitsNetSetup.Default.QuantityParser.Parse<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>(
-                str,
-                provider,
-                From);
+            return QuantityParser.Default.Parse<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>(str, provider, From);
         }
 
         /// <summary>
@@ -457,11 +436,7 @@ public static bool TryParse([NotNullWhen(true)]string? str, out WarpingMomentOfI
         /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out WarpingMomentOfInertia result)
         {
-            return UnitsNetSetup.Default.QuantityParser.TryParse<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>(
-                str,
-                provider,
-                From,
-                out result);
+            return QuantityParser.Default.TryParse<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>(str, provider, From, out result);
         }
 
         /// <summary>
@@ -482,7 +457,7 @@ public static WarpingMomentOfInertiaUnit ParseUnit(string str)
         ///     Parse a unit string.
         /// </summary>
         /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <example>
         ///     Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
@@ -493,7 +468,7 @@ public static WarpingMomentOfInertiaUnit ParseUnit(string str, IFormatProvider?
             return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value;
         }
 
-        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider,out UnitsNet.Units.WarpingMomentOfInertiaUnit)"/>
+        /// <inheritdoc cref="TryParseUnit(string,IFormatProvider?,out UnitsNet.Units.WarpingMomentOfInertiaUnit)"/>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, out WarpingMomentOfInertiaUnit unit)
         {
             return TryParseUnit(str, null, out unit);
@@ -508,7 +483,7 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, out WarpingMomen
         /// <example>
         ///     Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US"));
         /// </example>
-        /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+        /// <param name="provider">Format to use when parsing the unit. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out WarpingMomentOfInertiaUnit unit)
         {
             return UnitParser.Default.TryParse(str, Info, provider, out unit);
@@ -527,35 +502,35 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Get <see cref="WarpingMomentOfInertia"/> from adding two <see cref="WarpingMomentOfInertia"/>.</summary>
         public static WarpingMomentOfInertia operator +(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
         {
-            return new WarpingMomentOfInertia(left.Value + right.ToUnit(left.Unit).Value, left.Unit);
+            return new WarpingMomentOfInertia(left.Value + right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="WarpingMomentOfInertia"/> from subtracting two <see cref="WarpingMomentOfInertia"/>.</summary>
         public static WarpingMomentOfInertia operator -(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
         {
-            return new WarpingMomentOfInertia(left.Value - right.ToUnit(left.Unit).Value, left.Unit);
+            return new WarpingMomentOfInertia(left.Value - right.As(left.Unit), left.Unit);
         }
 
         /// <summary>Get <see cref="WarpingMomentOfInertia"/> from multiplying value and <see cref="WarpingMomentOfInertia"/>.</summary>
-        public static WarpingMomentOfInertia operator *(double left, WarpingMomentOfInertia right)
+        public static WarpingMomentOfInertia operator *(QuantityValue left, WarpingMomentOfInertia right)
         {
             return new WarpingMomentOfInertia(left * right.Value, right.Unit);
         }
 
         /// <summary>Get <see cref="WarpingMomentOfInertia"/> from multiplying value and <see cref="WarpingMomentOfInertia"/>.</summary>
-        public static WarpingMomentOfInertia operator *(WarpingMomentOfInertia left, double right)
+        public static WarpingMomentOfInertia operator *(WarpingMomentOfInertia left, QuantityValue right)
         {
             return new WarpingMomentOfInertia(left.Value * right, left.Unit);
         }
 
         /// <summary>Get <see cref="WarpingMomentOfInertia"/> from dividing <see cref="WarpingMomentOfInertia"/> by value.</summary>
-        public static WarpingMomentOfInertia operator /(WarpingMomentOfInertia left, double right)
+        public static WarpingMomentOfInertia operator /(WarpingMomentOfInertia left, QuantityValue right)
         {
             return new WarpingMomentOfInertia(left.Value / right, left.Unit);
         }
 
         /// <summary>Get ratio value from dividing <see cref="WarpingMomentOfInertia"/> by <see cref="WarpingMomentOfInertia"/>.</summary>
-        public static double operator /(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
+        public static QuantityValue operator /(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
         {
             return left.MetersToTheSixth / right.MetersToTheSixth;
         }
@@ -567,97 +542,111 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
         /// <summary>Returns true if less or equal to.</summary>
         public static bool operator <=(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
         {
-            return left.Value <= right.ToUnit(left.Unit).Value;
+            return left.Value <= right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than or equal to.</summary>
         public static bool operator >=(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
         {
-            return left.Value >= right.ToUnit(left.Unit).Value;
+            return left.Value >= right.As(left.Unit);
         }
 
         /// <summary>Returns true if less than.</summary>
         public static bool operator <(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
         {
-            return left.Value < right.ToUnit(left.Unit).Value;
+            return left.Value < right.As(left.Unit);
         }
 
         /// <summary>Returns true if greater than.</summary>
         public static bool operator >(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
         {
-            return left.Value > right.ToUnit(left.Unit).Value;
+            return left.Value > right.As(left.Unit);
         }
 
-        // We use obsolete attribute to communicate the preferred equality members to use.
-        // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'.
-        #pragma warning disable CS0809
-
-        /// <summary>Indicates strict equality of two <see cref="WarpingMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(WarpingMomentOfInertia other, WarpingMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="WarpingMomentOfInertia"/> instances are equal.
+        /// </summary>
+        /// <remarks>
+        ///     Equality is evaluated in a unit-aware manner. The right-hand operand is converted to the unit of the left-hand
+        ///     operand and then the underlying numeric values are compared.
+        ///     This means two quantities with numerically equal values but different units will be considered equal.
+        ///     The operator delegates to <see cref="Equals(WarpingMomentOfInertia)"/>, which implements this conversion-and-compare logic.
+        /// </remarks>
         public static bool operator ==(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
         {
             return left.Equals(right);
         }
 
-        /// <summary>Indicates strict inequality of two <see cref="WarpingMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(WarpingMomentOfInertia other, WarpingMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether two <see cref="WarpingMomentOfInertia"/> instances are not equal.
+        /// </summary>
+        /// <remarks>
+        ///     This operator is the logical negation of <see cref="operator ==(WarpingMomentOfInertia,WarpingMomentOfInertia)"/>.
+        ///     See that operator (and <see cref="Equals(WarpingMomentOfInertia)"/>) for details on how equality is evaluated
+        ///     (i.e., by converting one operand to the other's unit and comparing their numeric values).
+        /// </remarks>
         public static bool operator !=(WarpingMomentOfInertia left, WarpingMomentOfInertia right)
         {
             return !(left == right);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="WarpingMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(WarpingMomentOfInertia other, WarpingMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the specified object is equal to the current <see cref="WarpingMomentOfInertia"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Returns <c>false</c> if <paramref name="obj"/> is <c>null</c> or not a <see cref="WarpingMomentOfInertia"/>.
+        ///     When <paramref name="obj"/> is a <see cref="WarpingMomentOfInertia"/>, this method delegates to
+        ///     <see cref="Equals(WarpingMomentOfInertia)"/>, which performs a unit-aware comparison by converting the other
+        ///     instance to this instance's unit before comparing numeric values.
+        /// </remarks>
         public override bool Equals(object? obj)
         {
-            if (obj is null || !(obj is WarpingMomentOfInertia otherQuantity))
+            if (obj is not WarpingMomentOfInertia otherQuantity)
                 return false;
 
             return Equals(otherQuantity);
         }
 
         /// <inheritdoc />
-        /// <summary>Indicates strict equality of two <see cref="WarpingMomentOfInertia"/> quantities, where both <see cref="Value" /> and <see cref="Unit" /> are exactly equal.</summary>
-        [Obsolete("Use Equals(WarpingMomentOfInertia other, WarpingMomentOfInertia tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")]
+        /// <summary>
+        ///     Determines whether the current instance is equal to another <see cref="WarpingMomentOfInertia"/> instance.
+        /// </summary>
+        /// <remarks>
+        ///     Comparison is performed by converting <paramref name="other"/> to this instance's unit and then comparing the underlying numeric values.
+        ///     This makes two quantities equal even when their units differ, provided the converted numeric values are equal.
+        /// </remarks>
         public bool Equals(WarpingMomentOfInertia other)
         {
-            return new { Value, Unit }.Equals(new { other.Value, other.Unit });
+            return _value.Equals(other.As(this.Unit));
         }
 
-        #pragma warning restore CS0809
-
         /// <summary>
         ///     Returns the hash code for this instance.
         /// </summary>
         /// <returns>A hash code for the current WarpingMomentOfInertia.</returns>
         public override int GetHashCode()
         {
-            return Comparison.GetHashCode(Unit, Value);
+            return Comparison.GetHashCode(typeof(WarpingMomentOfInertia), this.As(BaseUnit));
         }
 
-        /// <summary>Compares the current <see cref="WarpingMomentOfInertia"/> with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <inheritdoc  cref="CompareTo(WarpingMomentOfInertia)" />
         /// <param name="obj">An object to compare with this instance.</param>
         /// <exception cref="T:System.ArgumentException">
         ///    <paramref name="obj" /> is not the same type as this instance.
         /// </exception>
-        /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
-        ///     <list type="table">
-        ///         <listheader><term> Value</term><description> Meaning</description></listheader>
-        ///         <item><term> Less than zero</term><description> This instance precedes <paramref name="obj" /> in the sort order.</description></item>
-        ///         <item><term> Zero</term><description> This instance occurs in the same position in the sort order as <paramref name="obj" />.</description></item>
-        ///         <item><term> Greater than zero</term><description> This instance follows <paramref name="obj" /> in the sort order.</description></item>
-        ///     </list>
-        /// </returns>
         public int CompareTo(object? obj)
         {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is WarpingMomentOfInertia otherQuantity)) throw new ArgumentException("Expected type WarpingMomentOfInertia.", nameof(obj));
+            if (obj is not WarpingMomentOfInertia otherQuantity)
+                throw obj is null ? new ArgumentNullException(nameof(obj)) : ExceptionHelper.CreateArgumentException<WarpingMomentOfInertia>(obj, nameof(obj));
 
             return CompareTo(otherQuantity);
         }
 
-        /// <summary>Compares the current <see cref="WarpingMomentOfInertia"/> with another <see cref="WarpingMomentOfInertia"/> and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit.</summary>
+        /// <summary>
+        ///     Compares the current <see cref="WarpingMomentOfInertia"/> with another <see cref="WarpingMomentOfInertia"/> and returns an integer that indicates
+        ///     whether the current instance precedes, follows, or occurs in the same position in the sort order as the other quantity, when converted to the same unit.
+        /// </summary>
         /// <param name="other">A quantity to compare with this instance.</param>
         /// <returns>A value that indicates the relative order of the quantities being compared. The return value has these meanings:
         ///     <list type="table">
@@ -669,139 +658,9 @@ public int CompareTo(object? obj)
         /// </returns>
         public int CompareTo(WarpingMomentOfInertia other)
         {
-            return _value.CompareTo(other.ToUnit(this.Unit).Value);
-        }
-
-        #endregion
-
-        #region Conversion Methods
-
-        /// <summary>
-        ///     Convert to the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        public double As(WarpingMomentOfInertiaUnit unit)
-        {
-            if (Unit == unit)
-                return Value;
-
-            return ToUnit(unit).Value;
-        }
-
-        /// <inheritdoc cref="IQuantity.As(UnitKey)"/>
-        public double As(UnitKey unitKey)
-        {
-            return As(unitKey.ToUnit<WarpingMomentOfInertiaUnit>());
-        }
-
-        /// <summary>
-        ///     Converts this WarpingMomentOfInertia to another WarpingMomentOfInertia with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <returns>A WarpingMomentOfInertia with the specified unit.</returns>
-        public WarpingMomentOfInertia ToUnit(WarpingMomentOfInertiaUnit unit)
-        {
-            return ToUnit(unit, DefaultConversionFunctions);
+            return _value.CompareTo(other.As(this.Unit));
         }
 
-        /// <summary>
-        ///     Converts this <see cref="WarpingMomentOfInertia"/> to another <see cref="WarpingMomentOfInertia"/> using the given <paramref name="unitConverter"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to use for the conversion.</param>
-        /// <returns>A WarpingMomentOfInertia with the specified unit.</returns>
-        public WarpingMomentOfInertia ToUnit(WarpingMomentOfInertiaUnit unit, UnitConverter unitConverter)
-        {
-            if (TryToUnit(unit, out var converted))
-            {
-                // Try to convert using the auto-generated conversion methods.
-                return converted!.Value;
-            }
-            else if (unitConverter.TryGetConversionFunction((typeof(WarpingMomentOfInertia), Unit, typeof(WarpingMomentOfInertia), unit), out var conversionFunction))
-            {
-                // See if the unit converter has an extensibility conversion registered.
-                return (WarpingMomentOfInertia)conversionFunction(this);
-            }
-            else if (Unit != BaseUnit)
-            {
-                // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit.
-                var inBaseUnits = ToUnit(BaseUnit);
-                return inBaseUnits.ToUnit(unit);
-            }
-            else
-            {
-                // No possible conversion
-                throw new UnitNotFoundException($"Can't convert {Unit} to {unit}.");
-            }
-        }
-
-        /// <summary>
-        ///     Attempts to convert this <see cref="WarpingMomentOfInertia"/> to another <see cref="WarpingMomentOfInertia"/> with the unit representation <paramref name="unit" />.
-        /// </summary>
-        /// <param name="unit">The unit to convert to.</param>
-        /// <param name="converted">The converted <see cref="WarpingMomentOfInertia"/> in <paramref name="unit"/>, if successful.</param>
-        /// <returns>True if successful, otherwise false.</returns>
-        private bool TryToUnit(WarpingMomentOfInertiaUnit unit, [NotNullWhen(true)] out WarpingMomentOfInertia? converted)
-        {
-            if (Unit == unit)
-            {
-                converted = this;
-                return true;
-            }
-
-            WarpingMomentOfInertia? convertedOrNull = (Unit, unit) switch
-            {
-                // WarpingMomentOfInertiaUnit -> BaseUnit
-                (WarpingMomentOfInertiaUnit.CentimeterToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth) => new WarpingMomentOfInertia(_value / 1e12, WarpingMomentOfInertiaUnit.MeterToTheSixth),
-                (WarpingMomentOfInertiaUnit.DecimeterToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth) => new WarpingMomentOfInertia(_value / 1e6, WarpingMomentOfInertiaUnit.MeterToTheSixth),
-                (WarpingMomentOfInertiaUnit.FootToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth) => new WarpingMomentOfInertia(_value * 0.000801843800914862014464, WarpingMomentOfInertiaUnit.MeterToTheSixth),
-                (WarpingMomentOfInertiaUnit.InchToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth) => new WarpingMomentOfInertia(_value * 0.000000000268535866540096, WarpingMomentOfInertiaUnit.MeterToTheSixth),
-                (WarpingMomentOfInertiaUnit.MillimeterToTheSixth, WarpingMomentOfInertiaUnit.MeterToTheSixth) => new WarpingMomentOfInertia(_value / 1e18, WarpingMomentOfInertiaUnit.MeterToTheSixth),
-
-                // BaseUnit -> WarpingMomentOfInertiaUnit
-                (WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.CentimeterToTheSixth) => new WarpingMomentOfInertia(_value * 1e12, WarpingMomentOfInertiaUnit.CentimeterToTheSixth),
-                (WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.DecimeterToTheSixth) => new WarpingMomentOfInertia(_value * 1e6, WarpingMomentOfInertiaUnit.DecimeterToTheSixth),
-                (WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.FootToTheSixth) => new WarpingMomentOfInertia(_value / 0.000801843800914862014464, WarpingMomentOfInertiaUnit.FootToTheSixth),
-                (WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.InchToTheSixth) => new WarpingMomentOfInertia(_value / 0.000000000268535866540096, WarpingMomentOfInertiaUnit.InchToTheSixth),
-                (WarpingMomentOfInertiaUnit.MeterToTheSixth, WarpingMomentOfInertiaUnit.MillimeterToTheSixth) => new WarpingMomentOfInertia(_value * 1e18, WarpingMomentOfInertiaUnit.MillimeterToTheSixth),
-
-                _ => null
-            };
-
-            if (convertedOrNull is null)
-            {
-                converted = default;
-                return false;
-            }
-
-            converted = convertedOrNull.Value;
-            return true;
-        }
-
-        #region Explicit implementations
-
-        double IQuantity.As(Enum unit)
-        {
-            if (unit is not WarpingMomentOfInertiaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(WarpingMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IQuantity IQuantity.ToUnit(Enum unit)
-        {
-            if (!(unit is WarpingMomentOfInertiaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(WarpingMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit, DefaultConversionFunctions);
-        }
-
-        /// <inheritdoc />
-        IQuantity<WarpingMomentOfInertiaUnit> IQuantity<WarpingMomentOfInertiaUnit>.ToUnit(WarpingMomentOfInertiaUnit unit) => ToUnit(unit);
-
-        #endregion
-
         #endregion
 
         #region ToString Methods
@@ -815,11 +674,13 @@ public override string ToString()
             return ToString(null, null);
         }
 
-        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string?, IFormatProvider?)"/>
+        /// <inheritdoc cref="QuantityFormatter.Format{TQuantity}(TQuantity, string, IFormatProvider)"/>
         /// <summary>
         /// Gets the string representation of this instance in the specified format string using the specified format provider, or <see cref="CultureInfo.CurrentCulture" /> if null.
         /// </summary>
-        public string ToString(string? format, IFormatProvider? provider)
+        public string ToString(
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+            IFormatProvider? provider)
         {
             return QuantityFormatter.Default.Format(this, format, provider);
         }
diff --git a/UnitsNet/GeneratedCode/Quantity.g.cs b/UnitsNet/GeneratedCode/Quantity.g.cs
index c7a7c3af9c..67ad33f293 100644
--- a/UnitsNet/GeneratedCode/Quantity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantity.g.cs
@@ -34,8 +34,8 @@ internal static class DefaultProvider
         /// <summary>
         ///     All QuantityInfo instances that are present in UnitsNet by default.
         /// </summary>
-        internal static IReadOnlyList<QuantityInfo> Quantities { get; } =
-        [
+        internal static IReadOnlyList<QuantityInfo> Quantities => new QuantityInfo[]
+        {
             AbsorbedDoseOfIonizingRadiation.Info,
             Acceleration.Info,
             AmountOfSubstance.Info,
@@ -44,6 +44,7 @@ internal static class DefaultProvider
             Area.Info,
             AreaDensity.Info,
             AreaMomentOfInertia.Info,
+            AreaPerLength.Info,
             BitRate.Info,
             BrakeSpecificFuelConsumption.Info,
             CoefficientOfThermalExpansion.Info,
@@ -164,138 +165,18 @@ internal static class DefaultProvider
             VolumePerLength.Info,
             VolumetricHeatCapacity.Info,
             WarpingMomentOfInertia.Info,
-        ];
+        };
 
-        internal static void RegisterUnitConversions(UnitConverter unitConverter)
+        /// <summary>
+        ///     All implicit quantity conversions that exist by default.
+        /// </summary>
+        internal static readonly IReadOnlyList<QuantityConversionMapping> Conversions = new QuantityConversionMapping[]
         {
-            AbsorbedDoseOfIonizingRadiation.RegisterDefaultConversions(unitConverter);
-            Acceleration.RegisterDefaultConversions(unitConverter);
-            AmountOfSubstance.RegisterDefaultConversions(unitConverter);
-            AmplitudeRatio.RegisterDefaultConversions(unitConverter);
-            Angle.RegisterDefaultConversions(unitConverter);
-            Area.RegisterDefaultConversions(unitConverter);
-            AreaDensity.RegisterDefaultConversions(unitConverter);
-            AreaMomentOfInertia.RegisterDefaultConversions(unitConverter);
-            BitRate.RegisterDefaultConversions(unitConverter);
-            BrakeSpecificFuelConsumption.RegisterDefaultConversions(unitConverter);
-            CoefficientOfThermalExpansion.RegisterDefaultConversions(unitConverter);
-            Compressibility.RegisterDefaultConversions(unitConverter);
-            Density.RegisterDefaultConversions(unitConverter);
-            DoseAreaProduct.RegisterDefaultConversions(unitConverter);
-            Duration.RegisterDefaultConversions(unitConverter);
-            DynamicViscosity.RegisterDefaultConversions(unitConverter);
-            ElectricAdmittance.RegisterDefaultConversions(unitConverter);
-            ElectricApparentEnergy.RegisterDefaultConversions(unitConverter);
-            ElectricApparentPower.RegisterDefaultConversions(unitConverter);
-            ElectricCapacitance.RegisterDefaultConversions(unitConverter);
-            ElectricCharge.RegisterDefaultConversions(unitConverter);
-            ElectricChargeDensity.RegisterDefaultConversions(unitConverter);
-            ElectricConductance.RegisterDefaultConversions(unitConverter);
-            ElectricConductivity.RegisterDefaultConversions(unitConverter);
-            ElectricCurrent.RegisterDefaultConversions(unitConverter);
-            ElectricCurrentDensity.RegisterDefaultConversions(unitConverter);
-            ElectricCurrentGradient.RegisterDefaultConversions(unitConverter);
-            ElectricField.RegisterDefaultConversions(unitConverter);
-            ElectricImpedance.RegisterDefaultConversions(unitConverter);
-            ElectricInductance.RegisterDefaultConversions(unitConverter);
-            ElectricPotential.RegisterDefaultConversions(unitConverter);
-            ElectricPotentialChangeRate.RegisterDefaultConversions(unitConverter);
-            ElectricReactance.RegisterDefaultConversions(unitConverter);
-            ElectricReactiveEnergy.RegisterDefaultConversions(unitConverter);
-            ElectricReactivePower.RegisterDefaultConversions(unitConverter);
-            ElectricResistance.RegisterDefaultConversions(unitConverter);
-            ElectricResistivity.RegisterDefaultConversions(unitConverter);
-            ElectricSurfaceChargeDensity.RegisterDefaultConversions(unitConverter);
-            ElectricSusceptance.RegisterDefaultConversions(unitConverter);
-            Energy.RegisterDefaultConversions(unitConverter);
-            EnergyDensity.RegisterDefaultConversions(unitConverter);
-            Entropy.RegisterDefaultConversions(unitConverter);
-            FluidResistance.RegisterDefaultConversions(unitConverter);
-            Force.RegisterDefaultConversions(unitConverter);
-            ForceChangeRate.RegisterDefaultConversions(unitConverter);
-            ForcePerLength.RegisterDefaultConversions(unitConverter);
-            Frequency.RegisterDefaultConversions(unitConverter);
-            FuelEfficiency.RegisterDefaultConversions(unitConverter);
-            HeatFlux.RegisterDefaultConversions(unitConverter);
-            HeatTransferCoefficient.RegisterDefaultConversions(unitConverter);
-            Illuminance.RegisterDefaultConversions(unitConverter);
-            Impulse.RegisterDefaultConversions(unitConverter);
-            Information.RegisterDefaultConversions(unitConverter);
-            Irradiance.RegisterDefaultConversions(unitConverter);
-            Irradiation.RegisterDefaultConversions(unitConverter);
-            Jerk.RegisterDefaultConversions(unitConverter);
-            KinematicViscosity.RegisterDefaultConversions(unitConverter);
-            LeakRate.RegisterDefaultConversions(unitConverter);
-            Length.RegisterDefaultConversions(unitConverter);
-            Level.RegisterDefaultConversions(unitConverter);
-            LinearDensity.RegisterDefaultConversions(unitConverter);
-            LinearPowerDensity.RegisterDefaultConversions(unitConverter);
-            Luminance.RegisterDefaultConversions(unitConverter);
-            Luminosity.RegisterDefaultConversions(unitConverter);
-            LuminousFlux.RegisterDefaultConversions(unitConverter);
-            LuminousIntensity.RegisterDefaultConversions(unitConverter);
-            MagneticField.RegisterDefaultConversions(unitConverter);
-            MagneticFlux.RegisterDefaultConversions(unitConverter);
-            Magnetization.RegisterDefaultConversions(unitConverter);
-            Mass.RegisterDefaultConversions(unitConverter);
-            MassConcentration.RegisterDefaultConversions(unitConverter);
-            MassFlow.RegisterDefaultConversions(unitConverter);
-            MassFlux.RegisterDefaultConversions(unitConverter);
-            MassFraction.RegisterDefaultConversions(unitConverter);
-            MassMomentOfInertia.RegisterDefaultConversions(unitConverter);
-            Molality.RegisterDefaultConversions(unitConverter);
-            MolarEnergy.RegisterDefaultConversions(unitConverter);
-            MolarEntropy.RegisterDefaultConversions(unitConverter);
-            MolarFlow.RegisterDefaultConversions(unitConverter);
-            Molarity.RegisterDefaultConversions(unitConverter);
-            MolarMass.RegisterDefaultConversions(unitConverter);
-            Permeability.RegisterDefaultConversions(unitConverter);
-            Permittivity.RegisterDefaultConversions(unitConverter);
-            PorousMediumPermeability.RegisterDefaultConversions(unitConverter);
-            Power.RegisterDefaultConversions(unitConverter);
-            PowerDensity.RegisterDefaultConversions(unitConverter);
-            PowerRatio.RegisterDefaultConversions(unitConverter);
-            Pressure.RegisterDefaultConversions(unitConverter);
-            PressureChangeRate.RegisterDefaultConversions(unitConverter);
-            RadiationEquivalentDose.RegisterDefaultConversions(unitConverter);
-            RadiationEquivalentDoseRate.RegisterDefaultConversions(unitConverter);
-            RadiationExposure.RegisterDefaultConversions(unitConverter);
-            Radioactivity.RegisterDefaultConversions(unitConverter);
-            Ratio.RegisterDefaultConversions(unitConverter);
-            RatioChangeRate.RegisterDefaultConversions(unitConverter);
-            ReciprocalArea.RegisterDefaultConversions(unitConverter);
-            ReciprocalLength.RegisterDefaultConversions(unitConverter);
-            RelativeHumidity.RegisterDefaultConversions(unitConverter);
-            RotationalAcceleration.RegisterDefaultConversions(unitConverter);
-            RotationalSpeed.RegisterDefaultConversions(unitConverter);
-            RotationalStiffness.RegisterDefaultConversions(unitConverter);
-            RotationalStiffnessPerLength.RegisterDefaultConversions(unitConverter);
-            Scalar.RegisterDefaultConversions(unitConverter);
-            SolidAngle.RegisterDefaultConversions(unitConverter);
-            SpecificEnergy.RegisterDefaultConversions(unitConverter);
-            SpecificEntropy.RegisterDefaultConversions(unitConverter);
-            SpecificFuelConsumption.RegisterDefaultConversions(unitConverter);
-            SpecificVolume.RegisterDefaultConversions(unitConverter);
-            SpecificWeight.RegisterDefaultConversions(unitConverter);
-            Speed.RegisterDefaultConversions(unitConverter);
-            StandardVolumeFlow.RegisterDefaultConversions(unitConverter);
-            Temperature.RegisterDefaultConversions(unitConverter);
-            TemperatureChangeRate.RegisterDefaultConversions(unitConverter);
-            TemperatureDelta.RegisterDefaultConversions(unitConverter);
-            TemperatureGradient.RegisterDefaultConversions(unitConverter);
-            ThermalConductivity.RegisterDefaultConversions(unitConverter);
-            ThermalInsulance.RegisterDefaultConversions(unitConverter);
-            ThermalResistance.RegisterDefaultConversions(unitConverter);
-            Torque.RegisterDefaultConversions(unitConverter);
-            Turbidity.RegisterDefaultConversions(unitConverter);
-            VitaminA.RegisterDefaultConversions(unitConverter);
-            Volume.RegisterDefaultConversions(unitConverter);
-            VolumeConcentration.RegisterDefaultConversions(unitConverter);
-            VolumeFlow.RegisterDefaultConversions(unitConverter);
-            VolumeFlowPerArea.RegisterDefaultConversions(unitConverter);
-            VolumePerLength.RegisterDefaultConversions(unitConverter);
-            VolumetricHeatCapacity.RegisterDefaultConversions(unitConverter);
-            WarpingMomentOfInertia.RegisterDefaultConversions(unitConverter);
-        }
+            new (typeof(Area), typeof(ReciprocalArea)),
+            new (typeof(Density), typeof(SpecificVolume)),
+            new (typeof(Duration), typeof(Frequency)),
+            new (typeof(ElectricConductivity), typeof(ElectricResistivity)),
+            new (typeof(Length), typeof(ReciprocalLength)),
+        };
     }
 }
diff --git a/UnitsNet/GeneratedCode/Resources/AreaDensity.restext b/UnitsNet/GeneratedCode/Resources/AreaDensity.restext
index 6a33618aa9..76ca330969 100644
--- a/UnitsNet/GeneratedCode/Resources/AreaDensity.restext
+++ b/UnitsNet/GeneratedCode/Resources/AreaDensity.restext
@@ -1,3 +1,5 @@
 GramsPerSquareMeter=g/m²,gsm
 KilogramsPerSquareMeter=kg/m²
 MilligramsPerSquareMeter=mg/m²
+PoundsPerSquareFoot=lb/ft²,lbs/ft²,lb/SF,lbs/SF
+PoundsPerThousandSquareFeet=lb/MSF,lbs/MSF,lb/1000ft²,lbs/1000ft²,lbm/MSF
diff --git a/UnitsNet/GeneratedCode/Resources/AreaPerLength.restext b/UnitsNet/GeneratedCode/Resources/AreaPerLength.restext
new file mode 100644
index 0000000000..de4a127b1f
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Resources/AreaPerLength.restext
@@ -0,0 +1,6 @@
+SquareCentimetersPerMeter=cm²/m
+SquareFeetPerFoot=ft²/ft
+SquareInchesPerFoot=in²/ft
+SquareInchesPerInch=in²/in
+SquareMetersPerMeter=m²/m
+SquareMillimetersPerMeter=mm²/m
diff --git a/UnitsNet/GeneratedCode/Resources/Force.restext b/UnitsNet/GeneratedCode/Resources/Force.restext
index 6f99365ee5..fdc86edfa9 100644
--- a/UnitsNet/GeneratedCode/Resources/Force.restext
+++ b/UnitsNet/GeneratedCode/Resources/Force.restext
@@ -1,5 +1,6 @@
 Decanewtons=daN
 Dyne=dyn
+GramsForce=gf
 KilogramsForce=kgf
 Kilonewtons=kN
 Kiloponds=kp
diff --git a/UnitsNet/GeneratedCode/Resources/Force.ru-RU.restext b/UnitsNet/GeneratedCode/Resources/Force.ru-RU.restext
index a8f5df3f7e..7d500316fb 100644
--- a/UnitsNet/GeneratedCode/Resources/Force.ru-RU.restext
+++ b/UnitsNet/GeneratedCode/Resources/Force.ru-RU.restext
@@ -1,5 +1,6 @@
 Decanewtons=даН
 Dyne=дин
+GramsForce=гс
 KilogramsForce=кгс
 Kilonewtons=кН
 Kiloponds=кгс
diff --git a/UnitsNet/GeneratedCode/Resources/HeatFlux.restext b/UnitsNet/GeneratedCode/Resources/HeatFlux.restext
index 029cbc8cfc..7ea0baaf02 100644
--- a/UnitsNet/GeneratedCode/Resources/HeatFlux.restext
+++ b/UnitsNet/GeneratedCode/Resources/HeatFlux.restext
@@ -4,15 +4,22 @@ BtusPerSecondSquareFoot=BTU/(s·ft²)
 BtusPerSecondSquareInch=BTU/(s·in²)
 CaloriesPerSecondSquareCentimeter=cal/(s·cm²)
 CentiwattsPerSquareMeter=cW/m²
+CentiwattsPerSquareMillimeter=cW/mm²
 DeciwattsPerSquareMeter=dW/m²
+DeciwattsPerSquareMillimeter=dW/mm²
 KilocaloriesPerHourSquareMeter=kcal/(h·m²)
 KilocaloriesPerSecondSquareCentimeter=kcal/(s·cm²)
 KilowattsPerSquareMeter=kW/m²
+KilowattsPerSquareMillimeter=kW/mm²
 MicrowattsPerSquareMeter=µW/m²
+MicrowattsPerSquareMillimeter=µW/mm²
 MilliwattsPerSquareMeter=mW/m²
+MilliwattsPerSquareMillimeter=mW/mm²
 NanowattsPerSquareMeter=nW/m²
+NanowattsPerSquareMillimeter=nW/mm²
 PoundsForcePerFootSecond=lbf/(ft·s)
 PoundsPerSecondCubed=lb/s³,lbm/s³
 WattsPerSquareFoot=W/ft²
 WattsPerSquareInch=W/in²
 WattsPerSquareMeter=W/m²
+WattsPerSquareMillimeter=W/mm²
diff --git a/UnitsNet/GeneratedCode/Resources/HeatTransferCoefficient.restext b/UnitsNet/GeneratedCode/Resources/HeatTransferCoefficient.restext
index 8958e854ea..fb1311d010 100644
--- a/UnitsNet/GeneratedCode/Resources/HeatTransferCoefficient.restext
+++ b/UnitsNet/GeneratedCode/Resources/HeatTransferCoefficient.restext
@@ -1,4 +1,5 @@
 BtusPerHourSquareFootDegreeFahrenheit=Btu/(h·ft²·°F),Btu/(ft²·h·°F),Btu/(hr·ft²·°F),Btu/(ft²·hr·°F)
+BtusPerSecondSquareInchDegreeFahrenheit=Btu/(s·in²·°F),Btu/(in²·s·°F),Btu/(s*in^2*degF),Btu/(in^2*s*degF)
 CaloriesPerHourSquareMeterDegreeCelsius=kcal/(h·m²·°C),kcal/(m²·h·°C),kcal/(hr·m²·°C),kcal/(m²·hr·°C)
 KilocaloriesPerHourSquareMeterDegreeCelsius=kkcal/(h·m²·°C),kkcal/(m²·h·°C),kkcal/(hr·m²·°C),kkcal/(m²·hr·°C)
 WattsPerSquareMeterCelsius=W/(m²·°C)
diff --git a/UnitsNet/GeneratedCode/Resources/MolarFlow.restext b/UnitsNet/GeneratedCode/Resources/MolarFlow.restext
index ebbc452809..18f365e1ae 100644
--- a/UnitsNet/GeneratedCode/Resources/MolarFlow.restext
+++ b/UnitsNet/GeneratedCode/Resources/MolarFlow.restext
@@ -1,7 +1,7 @@
-KilomolesPerHour=kkmol/h
+KilomolesPerHour=kmol/h
 KilomolesPerMinute=kmol/min
 KilomolesPerSecond=kmol/s
-MolesPerHour=kmol/h
+MolesPerHour=mol/h
 MolesPerMinute=mol/min
 MolesPerSecond=mol/s
 PoundMolesPerHour=lbmol/h
diff --git a/UnitsNet/GeneratedCode/Resources/MolarMass.restext b/UnitsNet/GeneratedCode/Resources/MolarMass.restext
index 94dcf8c7c5..318c685fb3 100644
--- a/UnitsNet/GeneratedCode/Resources/MolarMass.restext
+++ b/UnitsNet/GeneratedCode/Resources/MolarMass.restext
@@ -11,3 +11,4 @@ MicrogramsPerMole=µg/mol
 MilligramsPerMole=mg/mol
 NanogramsPerMole=ng/mol
 PoundsPerMole=lb/mol
+PoundsPerPoundMole=lb/lbmol,lbm/lbmol
diff --git a/UnitsNet/GeneratedCode/Resources/PowerDensity.restext b/UnitsNet/GeneratedCode/Resources/PowerDensity.restext
index a0684fe787..f6332bd258 100644
--- a/UnitsNet/GeneratedCode/Resources/PowerDensity.restext
+++ b/UnitsNet/GeneratedCode/Resources/PowerDensity.restext
@@ -1,3 +1,5 @@
+BtusPerSecondCubicFoot=BTU/(s·ft³)
+BtusPerSecondCubicInch=BTU/(s·in³)
 DecawattsPerCubicFoot=daW/ft³
 DecawattsPerCubicInch=daW/in³
 DecawattsPerCubicMeter=daW/m³
diff --git a/UnitsNet/GeneratedCode/Resources/Pressure.restext b/UnitsNet/GeneratedCode/Resources/Pressure.restext
index 133dbef717..d2590c7548 100644
--- a/UnitsNet/GeneratedCode/Resources/Pressure.restext
+++ b/UnitsNet/GeneratedCode/Resources/Pressure.restext
@@ -29,6 +29,8 @@ MetersOfWaterColumn=mH₂O,mH2O,m wc,m wg
 Microbars=µbar
 Micropascals=µPa
 Millibars=mbar
+MilligramsForcePerSquareFoot=mgf/ft²
+MilligramsForcePerSquareMeter=mgf/m²
 MillimetersOfMercury=mmHg
 MillimetersOfWaterColumn=mmH₂O,mmH2O,mm wc,mm wg
 Millipascals=mPa
diff --git a/UnitsNet/GeneratedCode/Resources/Pressure.ru-RU.restext b/UnitsNet/GeneratedCode/Resources/Pressure.ru-RU.restext
index 4a13b08a9e..b2202b3f02 100644
--- a/UnitsNet/GeneratedCode/Resources/Pressure.ru-RU.restext
+++ b/UnitsNet/GeneratedCode/Resources/Pressure.ru-RU.restext
@@ -20,6 +20,7 @@ Megapascals=МПа
 Microbars=мкбар
 Micropascals=мкПа
 Millibars=мбар
+MilligramsForcePerSquareMeter=мгс/м²
 MillimetersOfMercury=мм рт.ст.
 Millipascals=мПа
 Millitorrs=мторр
diff --git a/UnitsNet/GeneratedCode/Resources/SpecificVolume.restext b/UnitsNet/GeneratedCode/Resources/SpecificVolume.restext
index c287f002c6..d11e02af7b 100644
--- a/UnitsNet/GeneratedCode/Resources/SpecificVolume.restext
+++ b/UnitsNet/GeneratedCode/Resources/SpecificVolume.restext
@@ -1,3 +1,3 @@
 CubicFeetPerPound=ft³/lb
 CubicMetersPerKilogram=m³/kg
-MillicubicMetersPerKilogram=mm³/kg
+CubicMillimetersPerKilogram=mm³/kg
diff --git a/UnitsNet/GeneratedCode/Resources/ThermalConductivity.restext b/UnitsNet/GeneratedCode/Resources/ThermalConductivity.restext
index 491692658b..69654638aa 100644
--- a/UnitsNet/GeneratedCode/Resources/ThermalConductivity.restext
+++ b/UnitsNet/GeneratedCode/Resources/ThermalConductivity.restext
@@ -1,2 +1,3 @@
 BtusPerHourFootFahrenheit=BTU/(h·ft·°F)
+BtusPerSecondInchFahrenheit=BTU/(s·in·°F)
 WattsPerMeterKelvin=W/(m·K)
diff --git a/UnitsNet/GeneratedCode/Resources/Torque.restext b/UnitsNet/GeneratedCode/Resources/Torque.restext
index ce23b5c2b3..d818070f23 100644
--- a/UnitsNet/GeneratedCode/Resources/Torque.restext
+++ b/UnitsNet/GeneratedCode/Resources/Torque.restext
@@ -12,14 +12,16 @@ KilopoundForceInches=kipf·in
 MeganewtonCentimeters=MN·cm
 MeganewtonMeters=MN·m
 MeganewtonMillimeters=MN·mm
-MegapoundForceFeet=Mlbf·ft
-MegapoundForceInches=Mlbf·in
+MegapoundForceFeet=Mlbf·ft,Mlb·ft,Mlbf-ft,Mlb-ft,Mft-lb
+MegapoundForceInches=Mlbf·in,Mlb·in,Mlbf-in,Mlb-in,Min-lb
 NewtonCentimeters=N·cm
 NewtonMeters=N·m
 NewtonMillimeters=N·mm
+OunceForceFeet=ozf·ft,oz·ft,ozf-ft,oz-ft
+OunceForceInches=ozf·in,oz·in,ozf-in,oz-in,in-oz
 PoundalFeet=pdl·ft
-PoundForceFeet=lbf·ft
-PoundForceInches=lbf·in
+PoundForceFeet=lbf·ft,lb·ft,lbf-ft,lb-ft,ft-lb
+PoundForceInches=lbf·in,lb·in,lbf-in,lb-in,in-lb
 TonneForceCentimeters=tf·cm
 TonneForceMeters=tf·m
 TonneForceMillimeters=tf·mm
diff --git a/UnitsNet/GeneratedCode/Resources/Volume.restext b/UnitsNet/GeneratedCode/Resources/Volume.restext
index 5e5bc9e419..a108482023 100644
--- a/UnitsNet/GeneratedCode/Resources/Volume.restext
+++ b/UnitsNet/GeneratedCode/Resources/Volume.restext
@@ -17,22 +17,18 @@ Decaliters=dal
 DecausGallons=dagal (U.S.)
 Deciliters=dl
 DeciusGallons=dgal (U.S.)
-HectocubicFeet=hft³
-HectocubicMeters=hm³
 Hectoliters=hl
 HectousGallons=hgal (U.S.)
+HundredCubicFeet=Ccf,hft³
 ImperialBeerBarrels=bl (imp.)
 ImperialGallons=gal (imp.)
 ImperialOunces=oz (imp.)
 ImperialPints=pt (imp.),UK pt,pt,p
 ImperialQuarts=qt (imp.)
-KilocubicFeet=kft³
-KilocubicMeters=km³
 KiloimperialGallons=kgal (imp.)
 Kiloliters=kl
 KilousGallons=kgal (U.S.)
 Liters=l
-MegacubicFeet=Mft³
 MegaimperialGallons=Mgal (imp.)
 Megaliters=Ml
 MegausGallons=Mgal (U.S.)
@@ -41,8 +37,11 @@ MetricTablespoons=tablespoon,tbsp,tbsp.,tblsp,tblsp.
 MetricTeaspoons=tsp,t,ts,tspn,t.,ts.,tsp.,tspn.,teaspoon
 Microliters=µl
 Milliliters=ml
+MillionCubicFeet=MMcf,Mft³
 Nanoliters=nl
 OilBarrels=bbl
+ThousandCubicFeet=Mcf,kcf,kft³
+ThousandCubicMeters=10³·m³,kcm,Kcm
 UkTablespoons=tablespoon (U.K.)
 UsBeerBarrels=bl (U.S.)
 UsCustomaryCups=cup (U.S. customary)
diff --git a/UnitsNet/GeneratedCode/Resources/Volume.ru-RU.restext b/UnitsNet/GeneratedCode/Resources/Volume.ru-RU.restext
index c1c94577cf..de2bc158c5 100644
--- a/UnitsNet/GeneratedCode/Resources/Volume.ru-RU.restext
+++ b/UnitsNet/GeneratedCode/Resources/Volume.ru-RU.restext
@@ -14,19 +14,14 @@ Decaliters=дал
 DecausGallons=даАмериканский галлон
 Deciliters=дл
 DeciusGallons=дАмериканский галлон
-HectocubicFeet=гфут³
-HectocubicMeters=гм³
 Hectoliters=гл
 HectousGallons=гАмериканский галлон
 ImperialGallons=Английский галлон
 ImperialOunces=Английская унция
-KilocubicFeet=кфут³
-KilocubicMeters=км³
 KiloimperialGallons=кАнглийский галлон
 Kiloliters=кл
 KilousGallons=кАмериканский галлон
 Liters=л
-MegacubicFeet=Мфут³
 MegaimperialGallons=МАнглийский галлон
 Megaliters=Мл
 MegausGallons=МАмериканский галлон
diff --git a/UnitsNet/GeneratedCode/Resources/VolumeFlow.restext b/UnitsNet/GeneratedCode/Resources/VolumeFlow.restext
index 4ee14b6aea..6d836eead1 100644
--- a/UnitsNet/GeneratedCode/Resources/VolumeFlow.restext
+++ b/UnitsNet/GeneratedCode/Resources/VolumeFlow.restext
@@ -11,10 +11,13 @@ CubicDecimetersPerMinute=dm³/min
 CubicFeetPerHour=ft³/h,cf/hr
 CubicFeetPerMinute=ft³/min,CFM
 CubicFeetPerSecond=ft³/s
+CubicInchesPerMinute=in³/min
+CubicInchesPerSecond=in³/s
 CubicMetersPerDay=m³/d
 CubicMetersPerHour=m³/h
 CubicMetersPerMinute=m³/min
 CubicMetersPerSecond=m³/s
+CubicMillimetersPerMinute=mm³/min
 CubicMillimetersPerSecond=mm³/s
 CubicYardsPerDay=cy/day
 CubicYardsPerHour=yd³/h
diff --git a/UnitsNet/GeneratedCode/Resources/VolumeFlow.ru-RU.restext b/UnitsNet/GeneratedCode/Resources/VolumeFlow.ru-RU.restext
index 289ed120cc..f52312539e 100644
--- a/UnitsNet/GeneratedCode/Resources/VolumeFlow.ru-RU.restext
+++ b/UnitsNet/GeneratedCode/Resources/VolumeFlow.ru-RU.restext
@@ -6,6 +6,7 @@ CubicDecimetersPerMinute=дм³/мин
 CubicMetersPerHour=м³/ч
 CubicMetersPerMinute=м³/мин
 CubicMetersPerSecond=м³/с
+CubicMillimetersPerMinute=мм³/мин
 CubicMillimetersPerSecond=мм³/с
 DecalitersPerHour=дал/ч
 DecalitersPerMinute=дал/мин
diff --git a/UnitsNet/GeneratedCode/Units/AreaDensityUnit.g.cs b/UnitsNet/GeneratedCode/Units/AreaDensityUnit.g.cs
index bacdc7e8f4..06c176003f 100644
--- a/UnitsNet/GeneratedCode/Units/AreaDensityUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/AreaDensityUnit.g.cs
@@ -33,6 +33,8 @@ public enum AreaDensityUnit
         GramPerSquareMeter = 6,
         KilogramPerSquareMeter = 1,
         MilligramPerSquareMeter = 10,
+        PoundPerSquareFoot = 8,
+        PoundPerThousandSquareFeet = 3,
     }
 
     #pragma warning restore 1591
diff --git a/UnitsNet/GeneratedCode/Units/AreaPerLengthUnit.g.cs b/UnitsNet/GeneratedCode/Units/AreaPerLengthUnit.g.cs
new file mode 100644
index 0000000000..7dad5d4754
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Units/AreaPerLengthUnit.g.cs
@@ -0,0 +1,37 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Units
+{
+    // Disable missing XML comment warnings for the generated unit enums.
+    #pragma warning disable 1591
+
+    public enum AreaPerLengthUnit
+    {
+        SquareCentimeterPerMeter = 10,
+        SquareFootPerFoot = 4,
+        SquareInchPerFoot = 3,
+        SquareInchPerInch = 7,
+        SquareMeterPerMeter = 1,
+        SquareMillimeterPerMeter = 5,
+    }
+
+    #pragma warning restore 1591
+}
diff --git a/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs b/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs
index bc5be3f0ff..e61a6777ae 100644
--- a/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs
@@ -33,6 +33,12 @@ public enum ForceUnit
         /// <remarks>https://en.wikipedia.org/wiki/Dyne#Definition</remarks>
         Dyn = 2,
 
+        /// <summary>
+        ///     The gram-force is a unit of force equal to the magnitude of force exerted by a gram of mass in standard gravity (9.80665 m/s²). It is equal to 9.80665 × 10⁻³ N.
+        /// </summary>
+        /// <remarks>https://en.wikipedia.org/wiki/Kilogram-force</remarks>
+        GramForce = 16,
+
         /// <summary>
         ///     The kilogram-force, or kilopond, is equal to the magnitude of the force exerted on one kilogram of mass in a 9.80665 m/s2 gravitational field (standard gravity). Therefore, one kilogram-force is by definition equal to 9.80665 N.
         /// </summary>
diff --git a/UnitsNet/GeneratedCode/Units/HeatFluxUnit.g.cs b/UnitsNet/GeneratedCode/Units/HeatFluxUnit.g.cs
index 0a3da3b723..d8f5c97d1b 100644
--- a/UnitsNet/GeneratedCode/Units/HeatFluxUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/HeatFluxUnit.g.cs
@@ -35,18 +35,25 @@ public enum HeatFluxUnit
         BtuPerSecondSquareInch = 4,
         CaloriePerSecondSquareCentimeter = 5,
         CentiwattPerSquareMeter = 6,
+        CentiwattPerSquareMillimeter = 22,
         DeciwattPerSquareMeter = 7,
+        DeciwattPerSquareMillimeter = 28,
         KilocaloriePerHourSquareMeter = 8,
         KilocaloriePerSecondSquareCentimeter = 9,
         KilowattPerSquareMeter = 10,
+        KilowattPerSquareMillimeter = 24,
         MicrowattPerSquareMeter = 11,
+        MicrowattPerSquareMillimeter = 20,
         MilliwattPerSquareMeter = 12,
+        MilliwattPerSquareMillimeter = 26,
         NanowattPerSquareMeter = 13,
+        NanowattPerSquareMillimeter = 25,
         PoundForcePerFootSecond = 14,
         PoundPerSecondCubed = 15,
         WattPerSquareFoot = 16,
         WattPerSquareInch = 17,
         WattPerSquareMeter = 18,
+        WattPerSquareMillimeter = 19,
     }
 
     #pragma warning restore 1591
diff --git a/UnitsNet/GeneratedCode/Units/HeatTransferCoefficientUnit.g.cs b/UnitsNet/GeneratedCode/Units/HeatTransferCoefficientUnit.g.cs
index 1a52bffbfe..498dd926b5 100644
--- a/UnitsNet/GeneratedCode/Units/HeatTransferCoefficientUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/HeatTransferCoefficientUnit.g.cs
@@ -26,6 +26,7 @@ namespace UnitsNet.Units
     public enum HeatTransferCoefficientUnit
     {
         BtuPerHourSquareFootDegreeFahrenheit = 11,
+        BtuPerSecondSquareInchDegreeFahrenheit = 4,
         CaloriePerHourSquareMeterDegreeCelsius = 5,
         KilocaloriePerHourSquareMeterDegreeCelsius = 8,
         WattPerSquareMeterCelsius = 2,
diff --git a/UnitsNet/GeneratedCode/Units/MolarMassUnit.g.cs b/UnitsNet/GeneratedCode/Units/MolarMassUnit.g.cs
index 4be43903ef..8fd72528b7 100644
--- a/UnitsNet/GeneratedCode/Units/MolarMassUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/MolarMassUnit.g.cs
@@ -37,7 +37,17 @@ public enum MolarMassUnit
         MicrogramPerMole = 9,
         MilligramPerMole = 10,
         NanogramPerMole = 11,
+
+        /// <summary>
+        ///     Pound mass per SI mole. This is distinct from PoundPerPoundMole, where the denominator is the pound-mole amount of substance unit.
+        /// </summary>
         PoundPerMole = 12,
+
+        /// <summary>
+        ///     Pound mass per pound-mole. This is numerically equal to kilograms per kilomole and distinct from PoundPerMole, where the denominator is the SI mole.
+        /// </summary>
+        /// <remarks>Sources: https://www.engineeringtoolbox.com/molecular-weight-gas-vapor-d_1156.html, https://www.engineeringtoolbox.com/unit-converter-d_185.html</remarks>
+        PoundPerPoundMole = 24,
     }
 
     #pragma warning restore 1591
diff --git a/UnitsNet/GeneratedCode/Units/PowerDensityUnit.g.cs b/UnitsNet/GeneratedCode/Units/PowerDensityUnit.g.cs
index 74a52d1da5..c7eb170b56 100644
--- a/UnitsNet/GeneratedCode/Units/PowerDensityUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/PowerDensityUnit.g.cs
@@ -25,6 +25,10 @@ namespace UnitsNet.Units
 
     public enum PowerDensityUnit
     {
+        /// <remarks>Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details.</remarks>
+        BtuPerSecondCubicFoot = 47,
+        /// <remarks>Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details.</remarks>
+        BtuPerSecondCubicInch = 51,
         DecawattPerCubicFoot = 1,
         DecawattPerCubicInch = 2,
         DecawattPerCubicMeter = 3,
diff --git a/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs b/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs
index dbcff54072..51cf34bf04 100644
--- a/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs
@@ -86,6 +86,8 @@ public enum PressureUnit
         Microbar = 29,
         Micropascal = 30,
         Millibar = 31,
+        MilligramForcePerSquareFoot = 59,
+        MilligramForcePerSquareMeter = 51,
 
         /// <summary>
         ///     A millimetre of mercury is a manometric unit of pressure, formerly defined as the extra pressure generated by a column of mercury one millimetre high, and currently defined as exactly 133.322387415 pascals.
diff --git a/UnitsNet/GeneratedCode/Units/SpecificVolumeUnit.g.cs b/UnitsNet/GeneratedCode/Units/SpecificVolumeUnit.g.cs
index 49be37c632..368e1f6172 100644
--- a/UnitsNet/GeneratedCode/Units/SpecificVolumeUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/SpecificVolumeUnit.g.cs
@@ -27,7 +27,12 @@ public enum SpecificVolumeUnit
     {
         CubicFootPerPound = 1,
         CubicMeterPerKilogram = 2,
-        MillicubicMeterPerKilogram = 3,
+
+        /// <summary>
+        ///     A specific volume unit of cubic millimeters per kilogram. The millimeter prefix applies before cubing the length unit, so 1 mm³/kg = 1e-9 m³/kg.
+        /// </summary>
+        /// <remarks>Sources: https://www.bipm.org/en/measurement-units/si-prefixes, https://usma.org/wp-content/uploads/2015/06/Practical_Guide_to_the_SI.pdf</remarks>
+        CubicMillimeterPerKilogram = 3,
     }
 
     #pragma warning restore 1591
diff --git a/UnitsNet/GeneratedCode/Units/ThermalConductivityUnit.g.cs b/UnitsNet/GeneratedCode/Units/ThermalConductivityUnit.g.cs
index 044fda144e..e6b133fdb8 100644
--- a/UnitsNet/GeneratedCode/Units/ThermalConductivityUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/ThermalConductivityUnit.g.cs
@@ -26,6 +26,7 @@ namespace UnitsNet.Units
     public enum ThermalConductivityUnit
     {
         BtuPerHourFootFahrenheit = 1,
+        BtuPerSecondInchFahrenheit = 6,
         WattPerMeterKelvin = 2,
     }
 
diff --git a/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs b/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs
index 74ad9eb231..e09d7bf133 100644
--- a/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs
@@ -44,6 +44,8 @@ public enum TorqueUnit
         NewtonCentimeter = 17,
         NewtonMeter = 18,
         NewtonMillimeter = 19,
+        OunceForceFoot = 26,
+        OunceForceInch = 27,
         PoundalFoot = 20,
         PoundForceFoot = 21,
         PoundForceInch = 22,
diff --git a/UnitsNet/GeneratedCode/Units/VolumeFlowUnit.g.cs b/UnitsNet/GeneratedCode/Units/VolumeFlowUnit.g.cs
index 6c14bc7b98..db72a2c949 100644
--- a/UnitsNet/GeneratedCode/Units/VolumeFlowUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/VolumeFlowUnit.g.cs
@@ -38,10 +38,13 @@ public enum VolumeFlowUnit
         CubicFootPerHour = 11,
         CubicFootPerMinute = 12,
         CubicFootPerSecond = 13,
+        CubicInchPerMinute = 86,
+        CubicInchPerSecond = 76,
         CubicMeterPerDay = 14,
         CubicMeterPerHour = 15,
         CubicMeterPerMinute = 16,
         CubicMeterPerSecond = 17,
+        CubicMillimeterPerMinute = 80,
         CubicMillimeterPerSecond = 18,
         CubicYardPerDay = 19,
         CubicYardPerHour = 20,
diff --git a/UnitsNet/GeneratedCode/Units/VolumeUnit.g.cs b/UnitsNet/GeneratedCode/Units/VolumeUnit.g.cs
index c57fe745cb..1c42f4994c 100644
--- a/UnitsNet/GeneratedCode/Units/VolumeUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/VolumeUnit.g.cs
@@ -79,11 +79,15 @@ public enum VolumeUnit
         DecausGallon = 17,
         Deciliter = 18,
         DeciusGallon = 19,
-        HectocubicFoot = 20,
-        HectocubicMeter = 21,
         Hectoliter = 22,
         HectousGallon = 23,
 
+        /// <summary>
+        ///     A count-style volume unit equal to 100 cubic feet, commonly abbreviated Ccf in natural gas and water utility billing.
+        /// </summary>
+        /// <remarks>Sources: https://www.eia.gov/tools/faqs/faq.php?id=45&amp;t=8, https://19january2017snapshot.epa.gov/www3/watersense/our_water/understanding_your_bill.html</remarks>
+        HundredCubicFoot = 20,
+
         /// <summary>
         ///     Fluid barrels vary depending on what is being measured and where. In the UK a beer barrel is 36 imperial gallons (43 US gal; ~164 L).
         /// </summary>
@@ -113,13 +117,10 @@ public enum VolumeUnit
         /// </summary>
         /// <remarks>https://en.wikipedia.org/wiki/Quart#Imperial_quart</remarks>
         ImperialQuart = 57,
-        KilocubicFoot = 28,
-        KilocubicMeter = 29,
         KiloimperialGallon = 30,
         Kiloliter = 31,
         KilousGallon = 32,
         Liter = 33,
-        MegacubicFoot = 34,
         MegaimperialGallon = 35,
         Megaliter = 36,
         MegausGallon = 37,
@@ -143,6 +144,12 @@ public enum VolumeUnit
         MetricTeaspoon = 39,
         Microliter = 40,
         Milliliter = 41,
+
+        /// <summary>
+        ///     A count-style volume unit equal to 1,000,000 cubic feet, commonly abbreviated MMcf in natural gas reporting.
+        /// </summary>
+        /// <remarks>Sources: https://natural-resources.canada.ca/climate-change/conversion-factors-common-units-used-north-american-cooperation-energy-information</remarks>
+        MillionCubicFoot = 34,
         Nanoliter = 53,
 
         /// <summary>
@@ -151,6 +158,18 @@ public enum VolumeUnit
         /// <remarks>https://en.wikipedia.org/wiki/Barrel_(unit)#Oil_barrel</remarks>
         OilBarrel = 42,
 
+        /// <summary>
+        ///     A count-style volume unit equal to 1000 cubic feet, commonly abbreviated Mcf in natural gas reporting.
+        /// </summary>
+        /// <remarks>Sources: https://www.eia.gov/tools/faqs/faq.php?id=45&amp;t=8, https://natural-resources.canada.ca/climate-change/conversion-factors-common-units-used-north-american-cooperation-energy-information</remarks>
+        ThousandCubicFoot = 28,
+
+        /// <summary>
+        ///     A count-style volume unit equal to 1000 cubic meters. This is distinct from CubicKilometer, which is (1000 m)³ or 1e9 cubic meters.
+        /// </summary>
+        /// <remarks>Sources: https://energystar.my.site.com/PortfolioManager/s/article/Is-there-a-list-of-valid-property-level-water-meter-types-and-unit-of-measure-combinations-1748913622052, https://www.census.gov/foreign-trade/guide/sec4.html, https://www.bipm.org/en/measurement-units/si-prefixes</remarks>
+        ThousandCubicMeter = 29,
+
         /// <summary>
         ///     In nutrition labeling in the U.S. and the U.K., a tablespoon is defined as 15 ml (0.51 US fl oz). In Australia, the definition of the tablespoon is 20 ml (0.70 imp fl oz).
         /// </summary>
diff --git a/UnitsNet/GenericMath/GenericMathExtensions.cs b/UnitsNet/GenericMath/GenericMathExtensions.cs
index 239f85c299..4e1a72e103 100644
--- a/UnitsNet/GenericMath/GenericMathExtensions.cs
+++ b/UnitsNet/GenericMath/GenericMathExtensions.cs
@@ -1,8 +1,7 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 #if NET7_0_OR_GREATER
-using System.Numerics;
 
 namespace UnitsNet.GenericMath;
 
@@ -81,12 +80,12 @@ public static TQuantity Sum<TQuantity>(this IEnumerable<TQuantity> source)
     /// </remarks>
     public static TQuantity Average<TQuantity>(this IEnumerable<TQuantity> source)
         where TQuantity : IQuantity, IAdditionOperators<TQuantity, TQuantity, TQuantity>, IAdditiveIdentity<TQuantity, TQuantity>,
-        IDivisionOperators<TQuantity, double, TQuantity>
+        IDivisionOperators<TQuantity, QuantityValue, TQuantity>
     {
         using IEnumerator<TQuantity> e = source.GetEnumerator();
         if (!e.MoveNext())
         {
-            throw new InvalidOperationException("Sequence contains no elements");
+            throw ExceptionHelper.CreateInvalidOperationOnEmptyCollectionException();
         }
 
         TQuantity result = e.Current;
diff --git a/UnitsNet/IAffineQuantity.cs b/UnitsNet/IAffineQuantity.cs
index 0a8028f784..461bcaa6bd 100644
--- a/UnitsNet/IAffineQuantity.cs
+++ b/UnitsNet/IAffineQuantity.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 #if NET7_0_OR_GREATER
@@ -15,8 +15,6 @@ namespace UnitsNet;
 /// <typeparam name="TOffset"></typeparam>
 public interface IAffineQuantity<TSelf, TUnitType, TOffset> : IQuantity<TSelf, TUnitType>, IAffineQuantity<TSelf, TOffset>
 #if NET7_0_OR_GREATER
-    , IAdditionOperators<TSelf, TOffset, TSelf>
-    , ISubtractionOperators<TSelf, TSelf, TOffset>
     where TOffset : IAdditiveIdentity<TOffset, TOffset>
 #endif
     where TSelf : IAffineQuantity<TSelf, TUnitType, TOffset>
@@ -32,6 +30,8 @@ public interface IAffineQuantity<TSelf, TUnitType, TOffset> : IQuantity<TSelf, T
 public interface IAffineQuantity<TSelf, TOffset> : IQuantityOfType<TSelf>
 #if NET7_0_OR_GREATER
     , IAdditiveIdentity<TSelf, TOffset>
+    , IAdditionOperators<TSelf, TOffset, TSelf>
+    , ISubtractionOperators<TSelf, TSelf, TOffset>
     where TOffset : IAdditiveIdentity<TOffset, TOffset>
 #endif
     where TSelf : IAffineQuantity<TSelf, TOffset>
@@ -44,4 +44,28 @@ public interface IAffineQuantity<TSelf, TOffset> : IQuantityOfType<TSelf>
 
     static TOffset IAdditiveIdentity<TSelf, TOffset>.AdditiveIdentity => TOffset.AdditiveIdentity;
 #endif
+
+#if EXTENDED_EQUALS_INTERFACE
+        /// <summary>
+        ///     <para>
+        ///     Compare equality to <paramref name="other"/> given a <paramref name="tolerance"/> for the maximum allowed +/- difference.
+        ///     </para>
+        ///     <example>
+        ///     In this example, the two quantities will be equal if the value of b is within 0.01 of a (0.01m or 1cm).
+        ///     <code>
+        ///     var a = Length.FromMeters(2.0);
+        ///     var b = Length.FromMeters(2.1);
+        ///     var tolerance = Length.FromCentimeters(10);
+        ///     a.Equals(b, tolerance); // true, 2m equals 2.1m +/- 0.1m
+        ///     </code>
+        ///     </example>
+        ///     <para>
+        ///     It is generally advised against specifying "zero" tolerance, due to the nature of floating-point operations.
+        ///     </para>
+        /// </summary>
+        /// <param name="other">The other quantity to compare to.</param>
+        /// <param name="tolerance">The absolute tolerance value. Must be greater than or equal to zero.</param>
+        /// <returns>True if the absolute difference between the two values is not greater than the specified tolerance.</returns>
+        bool Equals(TSelf? other, TOffset tolerance);
+#endif
 }
diff --git a/UnitsNet/IArithmeticQuantity.cs b/UnitsNet/IArithmeticQuantity.cs
index d9d075d19e..717e381ed2 100644
--- a/UnitsNet/IArithmeticQuantity.cs
+++ b/UnitsNet/IArithmeticQuantity.cs
@@ -1,66 +1,35 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
-#if NET
+#if NET7_0_OR_GREATER
 using System.Numerics;
 #endif
 
 namespace UnitsNet;
 
 /// <summary>
-///     Represents a quantity that has both magnitude and direction, supporting various arithmetic operations and
-///     comparisons.
+///     A quantity that (in .NET 7+) implements generic math interfaces for arithmetic operations.
 /// </summary>
-/// <remarks>
-///     This interface defines standard linear arithmetic operations such as addition, subtraction, multiplication, and
-///     division.
-///     These types of quantities naturally support comparison operations with either absolute or relative tolerance, which
-///     is useful for determining equality within a certain margin of error.
-///     <para>
-///         For more information, see the Wikipedia page on
-///         <a href="https://en.wikipedia.org/wiki/Dimensional_analysis#Geometry:_position_vs._displacement">
-///             Dimensional
-///             Analysis
-///         </a>
-///         .
-///     </para>
-/// </remarks>
-/// <typeparam name="TSelf">The type that implements this interface.</typeparam>
-public interface ILinearQuantity<TSelf> : IQuantityOfType<TSelf>
-#if NET7_0_OR_GREATER
-    , IAdditiveIdentity<TSelf, TSelf>
-#endif
-    where TSelf : ILinearQuantity<TSelf>
+/// <typeparam name="TSelf">The type itself, for the CRT pattern.</typeparam>
+/// <typeparam name="TUnitType">The underlying unit enum type.</typeparam>
+public interface IArithmeticQuantity<TSelf, TUnitType> : IQuantity<TSelf, TUnitType>, IArithmeticQuantity<TSelf>
+    where TSelf : IArithmeticQuantity<TSelf, TUnitType>
+    where TUnitType : struct, Enum
 {
-#if NET7_0_OR_GREATER
-    /// <summary>
-    ///     The zero value of this quantity.
-    /// </summary>
-    static abstract TSelf Zero { get; }
-
-    static TSelf IAdditiveIdentity<TSelf, TSelf>.AdditiveIdentity
-    {
-        get => TSelf.Zero;
-    }
-
-#endif
 }
 
 /// <summary>
-///     An <see cref="IQuantity{TSelf, TUnitType}" /> that (in .NET 7+) implements generic math interfaces for arithmetic
-///     operations.
+///     A quantity that (in .NET 7+) implements generic math interfaces for arithmetic operations.
 /// </summary>
 /// <typeparam name="TSelf">The type itself, for the CRT pattern.</typeparam>
-/// <typeparam name="TUnitType">The underlying unit enum type.</typeparam>
-public interface IArithmeticQuantity<TSelf, TUnitType> : IQuantity<TSelf, TUnitType>, ILinearQuantity<TSelf>
+public interface IArithmeticQuantity<TSelf>
 #if NET7_0_OR_GREATER
-    , IAdditionOperators<TSelf, TSelf, TSelf>
+    : IAdditionOperators<TSelf, TSelf, TSelf>
     , ISubtractionOperators<TSelf, TSelf, TSelf>
-    , IMultiplyOperators<TSelf, double, TSelf>
-    , IDivisionOperators<TSelf, double, TSelf>
+    , IMultiplyOperators<TSelf, QuantityValue, TSelf>
+    , IDivisionOperators<TSelf, QuantityValue, TSelf>
     , IUnaryNegationOperators<TSelf, TSelf>
 #endif
-    where TSelf : IArithmeticQuantity<TSelf, TUnitType>
-    where TUnitType : struct, Enum
+    where TSelf : IArithmeticQuantity<TSelf>
 {
 }
diff --git a/UnitsNet/ILinearQuantity.cs b/UnitsNet/ILinearQuantity.cs
new file mode 100644
index 0000000000..983319f2b3
--- /dev/null
+++ b/UnitsNet/ILinearQuantity.cs
@@ -0,0 +1,62 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+#if NET7_0_OR_GREATER
+using System.Numerics;
+#endif
+
+namespace UnitsNet;
+
+/// <summary>
+///     An <see cref="ILinearQuantity{TSelf}" /> with a strongly typed unit enum.
+/// </summary>
+/// <remarks>
+///     This interface represents linear quantities with known unit enum types, and (in .NET 7+) implements generic math
+///     interfaces for arithmetic operations.
+/// </remarks>
+/// <typeparam name="TSelf">The type itself, for the CRT pattern.</typeparam>
+/// <typeparam name="TUnitType">The underlying unit enum type.</typeparam>
+public interface ILinearQuantity<TSelf, TUnitType> : IArithmeticQuantity<TSelf, TUnitType>, ILinearQuantity<TSelf>
+    where TSelf : ILinearQuantity<TSelf, TUnitType>
+    where TUnitType : struct, Enum
+{
+}
+
+/// <summary>
+///     Represents a quantity that has both magnitude and direction, supporting various arithmetic operations and
+///     comparisons.
+/// </summary>
+/// <remarks>
+///     This interface defines standard linear arithmetic operations such as addition, subtraction, multiplication, and
+///     division.
+///     These types of quantities naturally support comparison operations with either absolute or relative tolerance, which
+///     is useful for determining equality within a certain margin of error.
+///     <para>
+///         For more information, see the Wikipedia page on
+///         <a href="https://en.wikipedia.org/wiki/Dimensional_analysis#Geometry:_position_vs._displacement">
+///             Dimensional
+///             Analysis
+///         </a>
+///         .
+///     </para>
+/// </remarks>
+/// <typeparam name="TSelf">The type that implements this interface.</typeparam>
+public interface ILinearQuantity<TSelf> : IQuantityOfType<TSelf>, IArithmeticQuantity<TSelf>
+#if NET7_0_OR_GREATER
+    , IAdditiveIdentity<TSelf, TSelf>
+#endif
+    where TSelf : ILinearQuantity<TSelf>
+{
+#if NET7_0_OR_GREATER
+    /// <summary>
+    ///     The zero value of this quantity.
+    /// </summary>
+    static abstract TSelf Zero { get; }
+
+    static TSelf IAdditiveIdentity<TSelf, TSelf>.AdditiveIdentity
+    {
+        get => TSelf.Zero;
+    }
+
+#endif
+}
diff --git a/UnitsNet/ILogarithmicQuantity.cs b/UnitsNet/ILogarithmicQuantity.cs
index eb35775ac1..008a0369c0 100644
--- a/UnitsNet/ILogarithmicQuantity.cs
+++ b/UnitsNet/ILogarithmicQuantity.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 #if NET7_0_OR_GREATER
@@ -10,14 +10,7 @@ namespace UnitsNet;
 /// <inheritdoc cref="ILogarithmicQuantity{TSelf}"/>
 /// <typeparam name="TSelf">The type itself, for the CRT pattern.</typeparam>
 /// <typeparam name="TUnitType">The underlying unit enum type.</typeparam>
-public interface ILogarithmicQuantity<TSelf, TUnitType> : IQuantity<TSelf, TUnitType>, ILogarithmicQuantity<TSelf>
-#if NET7_0_OR_GREATER
-    , IAdditionOperators<TSelf, TSelf, TSelf>
-    , ISubtractionOperators<TSelf, TSelf, TSelf>
-    , IMultiplyOperators<TSelf, double, TSelf>
-    , IDivisionOperators<TSelf, double, TSelf>
-    , IUnaryNegationOperators<TSelf, TSelf>
-#endif
+public interface ILogarithmicQuantity<TSelf, TUnitType> : IArithmeticQuantity<TSelf, TUnitType>, ILogarithmicQuantity<TSelf>
     where TSelf : ILogarithmicQuantity<TSelf, TUnitType>
     where TUnitType : struct, Enum
 {
@@ -34,7 +27,7 @@ public interface ILogarithmicQuantity<TSelf, TUnitType> : IQuantity<TSelf, TUnit
 ///     to logarithmic quantities, including arithmetic operations and a logarithmic scaling factor.
 ///     The logarithmic scale assumed here is base-10.
 /// </remarks>
-public interface ILogarithmicQuantity<TSelf> : IQuantityOfType<TSelf>
+public interface ILogarithmicQuantity<TSelf> : IQuantityOfType<TSelf>, IArithmeticQuantity<TSelf>
 #if NET7_0_OR_GREATER
     , IMultiplicativeIdentity<TSelf, TSelf>
 #endif
@@ -48,7 +41,7 @@ public interface ILogarithmicQuantity<TSelf> : IQuantityOfType<TSelf>
     /// <value>
     ///     The logarithmic scaling factor.
     /// </value>
-    static abstract double LogarithmicScalingFactor { get; }
+    static abstract QuantityValue LogarithmicScalingFactor { get; }
 
     /// <summary>
     ///     The zero value of this quantity.
@@ -64,6 +57,6 @@ public interface ILogarithmicQuantity<TSelf> : IQuantityOfType<TSelf>
         /// <value>
         ///     The logarithmic scaling factor.
         /// </value>
-        double LogarithmicScalingFactor { get; }
+        QuantityValue LogarithmicScalingFactor { get; }
 #endif
 }
diff --git a/UnitsNet/IQuantity.cs b/UnitsNet/IQuantity.cs
index 149b3f9dd0..4150697698 100644
--- a/UnitsNet/IQuantity.cs
+++ b/UnitsNet/IQuantity.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet
@@ -11,24 +11,15 @@ public interface IQuantity : IFormattable
         /// <summary>
         ///     Information about the quantity type, such as unit values and names.
         /// </summary>
+        /// <remarks>
+        ///     Kept for back-compat with netstandard2.0. On .NET 5+, prefer the static <c>TSelf.Info</c>
+        ///     property or the <c>GetQuantityInfo()</c> extension method on <see cref="QuantityExtensions"/>.
+        /// </remarks>
+#if NET
+        [Obsolete("Kept for back-compat with netstandard2.0. On .NET 5+, use the static TSelf.Info property or the GetQuantityInfo() extension method.")]
+#endif
         QuantityInfo QuantityInfo { get; }
 
-        /// <summary>
-        ///     Gets the value in the given unit.
-        /// </summary>
-        /// <param name="unit">The unit enum value. The unit must be compatible, so for <see cref="Length"/> you should provide a <see cref="LengthUnit"/> value.</param>
-        /// <returns>Value converted to the specified unit.</returns>
-        /// <exception cref="InvalidCastException">Wrong unit enum type was given.</exception>
-        double As(Enum unit);
-
-        /// <summary>
-        ///     Gets the value in the given unit key.
-        /// </summary>
-        /// <param name="unitKey">The unit key. The unit type must be compatible, so for <see cref="Length"/> you should provide a <see cref="LengthUnit"/> value.</param>
-        /// <returns>Value converted to the specified unit.</returns>
-        /// <exception cref="InvalidCastException">Wrong unit enum type was given.</exception>
-        double As(UnitKey unitKey);
-
         /// <summary>
         ///     The unit this quantity was constructed with -or- BaseUnit if default ctor was used.
         /// </summary>
@@ -37,18 +28,7 @@ public interface IQuantity : IFormattable
         /// <summary>
         ///     The value this quantity was constructed with. See also <see cref="Unit"/>.
         /// </summary>
-        double Value { get; }
-
-        /// <summary>
-        ///     Converts this <see cref="IQuantity"/> to an <see cref="IQuantity"/> in the given <paramref name="unit"/>.
-        /// </summary>
-        /// <param name="unit">
-        ///     The unit <see cref="Enum"/> value. The <see cref="Enum"/> must be compatible with the units of the <see cref="IQuantity"/>.
-        ///     For example, if the <see cref="IQuantity"/> is a <see cref="Length"/>, you should provide a <see cref="LengthUnit"/> value.
-        /// </param>
-        /// <exception cref="NotImplementedException">Conversion was not possible from this <see cref="IQuantity"/> to <paramref name="unit"/>.</exception>
-        /// <returns>A new <see cref="IQuantity"/> in the given <paramref name="unit"/>.</returns>
-        IQuantity ToUnit(Enum unit);
+        QuantityValue Value { get; }
 
         /// <summary>
         ///     Gets the unique key for the unit type and its corresponding value.
@@ -66,40 +46,31 @@ public interface IQuantity : IFormattable
     /// </summary>
     /// <example>
     ///     IQuantity{LengthUnit} length;
-    ///     double centimeters = length.As(LengthUnit.Centimeter); // Type safety on enum type
+    ///     QuantityValue centimeters = length.As(LengthUnit.Centimeter); // Type safety on enum type
     /// </example>
     /// <typeparam name="TUnitType">The unit type of the quantity.</typeparam>
     public interface IQuantity<TUnitType> : IQuantity
         where TUnitType : struct, Enum
     {
-        /// <summary>
-        ///     Convert to a unit representation <typeparamref name="TUnitType"/>.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        double As(TUnitType unit);
-
         /// <inheritdoc cref="IQuantity.Unit"/>
         new TUnitType Unit { get; }
 
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
+#if NET
+        [Obsolete("Kept for back-compat with netstandard2.0. On .NET 5+, use the static TSelf.Info property or the GetQuantityInfo() extension method.")]
+#endif
         new QuantityInfo<TUnitType> QuantityInfo { get; }
 
-        /// <summary>
-        ///     Converts this <see cref="IQuantity{TUnitType}"/> to an <see cref="IQuantity{TUnitType}"/> in the given <paramref name="unit"/>.
-        /// </summary>
-        /// <param name="unit">The unit value.</param>
-        /// <exception cref="NotImplementedException">Conversion was not possible from this <see cref="IQuantity"/> to <paramref name="unit"/>.</exception>
-        /// <returns>A new <see cref="IQuantity{TUnitType}"/> in the given <paramref name="unit"/>.</returns>
-        IQuantity<TUnitType> ToUnit(TUnitType unit);
-
 #if NET
 
         #region Implementation of IQuantity
 
+#pragma warning disable CS0618 // Type or member is obsolete
         QuantityInfo IQuantity.QuantityInfo
         {
             get => QuantityInfo;
         }
+#pragma warning restore CS0618
 
         Enum IQuantity.Unit
         {
@@ -121,13 +92,23 @@ public interface IQuantityOfType<out TQuantity> : IQuantity
         where TQuantity : IQuantity
     {
 #if NET
+        /// <summary>
+        ///     The static <see cref="UnitsNet.QuantityInfo"/> for this quantity type.
+        /// </summary>
+        /// <remarks>
+        ///     Implemented by every quantity as a public static <c>Info</c> property. Prefer this and the
+        ///     <see cref="QuantityExtensions.GetQuantityInfo(IQuantity)"/> extension method over the
+        ///     obsolete instance <see cref="IQuantity.QuantityInfo"/> property.
+        /// </remarks>
+        public static abstract QuantityInfo Info { get; }
+
         /// <summary>
         ///     Creates an instance of the quantity from a specified value and unit.
         /// </summary>
         /// <param name="value">The numerical value of the quantity.</param>
         /// <param name="unit">The unit of the quantity.</param>
         /// <returns>An instance of the quantity with the specified value and unit.</returns>
-        public static abstract TQuantity Create(double value, UnitKey unit);
+        public static abstract TQuantity Create(QuantityValue value, UnitKey unit);
 #else
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
         new IQuantityInstanceInfo<TQuantity> QuantityInfo { get; }
@@ -144,28 +125,34 @@ public interface IQuantity<TSelf, TUnitType> : IQuantityOfType<TSelf>, IQuantity
         where TUnitType : struct, Enum
     {
         /// <inheritdoc cref="IQuantity.QuantityInfo"/>
+#if NET
+        [Obsolete("Kept for back-compat with netstandard2.0. On .NET 5+, use the static TSelf.Info property or the GetQuantityInfo() extension method.")]
+#endif
         new QuantityInfo<TSelf, TUnitType> QuantityInfo { get; }
 
 #if NET
+        /// <inheritdoc cref="IQuantityOfType{TQuantity}.Info"/>
+        public new static abstract QuantityInfo<TSelf, TUnitType> Info { get; }
+
         /// <summary>
         ///     Creates an instance of the quantity from a specified value and unit.
         /// </summary>
         /// <param name="value">The numerical value of the quantity.</param>
         /// <param name="unit">The unit of the quantity.</param>
         /// <returns>An instance of the quantity with the specified value and unit.</returns>
-        static abstract TSelf From(double value, TUnitType unit);
+        static abstract TSelf From(QuantityValue value, TUnitType unit);
+
+        static TSelf IQuantityOfType<TSelf>.Create(QuantityValue value, UnitKey unit) => TSelf.From(value, unit.ToUnit<TUnitType>());
 
-        static TSelf IQuantityOfType<TSelf>.Create(double value, UnitKey unit) => TSelf.From(value, unit.ToUnit<TUnitType>());
+        static QuantityInfo IQuantityOfType<TSelf>.Info => TSelf.Info;
 
+#pragma warning disable CS0618 // Type or member is obsolete
         QuantityInfo<TUnitType> IQuantity<TUnitType>.QuantityInfo
         {
             get => QuantityInfo;
         }
+#pragma warning restore CS0618
 
-        IQuantity<TUnitType> IQuantity<TUnitType>.ToUnit(TUnitType unit)
-        {
-            return TSelf.From(As(unit), unit);
-        }
 #endif
 
     }
diff --git a/UnitsNet/IQuantityInfo.cs b/UnitsNet/IQuantityInfo.cs
index 308df868e1..d5d566982b 100644
--- a/UnitsNet/IQuantityInfo.cs
+++ b/UnitsNet/IQuantityInfo.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Resources;
@@ -19,7 +19,7 @@ namespace UnitsNet;
 #else
 internal
 #endif
-interface IQuantityInfo 
+interface IQuantityInfo
 {
     /// <summary>
     ///     Quantity name, such as "Length" or "Mass".
@@ -128,5 +128,5 @@ interface IQuantityInstanceInfo<out TQuantity> : IQuantityInfo
     /// <param name="value">The numerical value of the quantity.</param>
     /// <param name="unitKey">The unit key of the quantity.</param>
     /// <returns>An instance of the quantity with the specified value and unit.</returns>
-    public TQuantity Create(double value, UnitKey unitKey);
+    public TQuantity Create(QuantityValue value, UnitKey unitKey);
 }
diff --git a/UnitsNet/IUnitDefinition.cs b/UnitsNet/IUnitDefinition.cs
index c719817325..02baef1493 100644
--- a/UnitsNet/IUnitDefinition.cs
+++ b/UnitsNet/IUnitDefinition.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 namespace UnitsNet;
@@ -23,6 +23,61 @@ public interface IUnitDefinition
     ///     Gets the <see cref="BaseUnits" /> for this unit.
     /// </summary>
     BaseUnits BaseUnits { get; }
+
+    /// <summary>
+    ///     Gets the conversion expression used to convert from the base unit to this unit.
+    /// </summary>
+    /// <value>
+    ///     The conversion expression, represented as a <see cref="ConversionExpression" />.
+    /// </value>
+    /// <remarks>
+    ///     The conversion expression is defined as an equation of the form:
+    ///     <code>
+    /// f(x) = a * g(x)^n + b
+    /// </code>
+    ///     where:
+    ///     <list type="bullet">
+    ///         <item>
+    ///             <description><c>a</c> and <c>b</c> are constants of type <see cref="QuantityValue" />.</description>
+    ///         </item>
+    ///         <item>
+    ///             <description>
+    ///                 <c>g(x)</c> is an optional custom function applied to the input <c>x</c> (of type
+    ///                 <see cref="QuantityValue" />).
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <description><c>n</c> is an integer exponent.</description>
+    ///         </item>
+    ///     </list>
+    /// </remarks>
+    ConversionExpression ConversionFromBase { get; }
+
+    /// <summary>
+    ///     Gets the conversion expression used to convert a unit to its base unit.
+    /// </summary>
+    /// <remarks>
+    ///     The conversion is defined as a function of the form:
+    ///     <code>
+    /// f(x) = a * g(x)^n + b
+    /// </code>
+    ///     where:
+    ///     <list type="bullet">
+    ///         <item>
+    ///             <description><c>a</c> and <c>b</c> are constants of type <see cref="QuantityValue" />.</description>
+    ///         </item>
+    ///         <item>
+    ///             <description>
+    ///                 <c>g(x)</c> is an optional custom function applied to the input <c>x</c> (of type
+    ///                 <see cref="QuantityValue" />).
+    ///             </description>
+    ///         </item>
+    ///         <item>
+    ///             <description><c>n</c> is an integer exponent.</description>
+    ///         </item>
+    ///     </list>
+    /// </remarks>
+    ConversionExpression ConversionToBase { get; }
 }
 
 /// <summary>
diff --git a/UnitsNet/InternalHelpers/BytesUtility.cs b/UnitsNet/InternalHelpers/BytesUtility.cs
index e75e467773..5678555dea 100644
--- a/UnitsNet/InternalHelpers/BytesUtility.cs
+++ b/UnitsNet/InternalHelpers/BytesUtility.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet/InternalHelpers/CultureHelper.cs b/UnitsNet/InternalHelpers/CultureHelper.cs
index 37931f6e88..29680f4d94 100644
--- a/UnitsNet/InternalHelpers/CultureHelper.cs
+++ b/UnitsNet/InternalHelpers/CultureHelper.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
diff --git a/UnitsNet/InternalHelpers/MathHelper.cs b/UnitsNet/InternalHelpers/MathHelper.cs
new file mode 100644
index 0000000000..4167229f73
--- /dev/null
+++ b/UnitsNet/InternalHelpers/MathHelper.cs
@@ -0,0 +1,26 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet.InternalHelpers;
+
+/// <summary>
+///     Fallback math operations required by the netstandard2.0 assembly when it runs on .NET Framework 4.8.
+/// </summary>
+internal static class MathHelper
+{
+    /// <summary>
+    ///     Calculates the specified root without <c>double.RootN</c>, which is unavailable when compiling the
+    ///     netstandard2.0 assembly used by .NET Framework 4.8.
+    /// </summary>
+    public static double RootN(double number, int n)
+    {
+        bool isNegative = BitConverter.DoubleToInt64Bits(number) < 0;
+        if (isNegative && n % 2 == 0)
+        {
+            return double.NaN;
+        }
+
+        double root = Math.Pow(Math.Abs(number), 1.0 / n);
+        return isNegative ? -root : root;
+    }
+}
diff --git a/UnitsNet/QuantityDisplay.cs b/UnitsNet/QuantityDisplay.cs
deleted file mode 100644
index 166afc9544..0000000000
--- a/UnitsNet/QuantityDisplay.cs
+++ /dev/null
@@ -1,142 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.Linq;
-
-namespace UnitsNet;
-
-/// <summary>
-///     Serves as a debug display proxy for a quantity, providing a convenient way to view various components of the
-///     quantity during debugging.
-/// </summary>
-/// <remarks>
-///     This struct provides a structured view of a quantity's components such as abbreviation, unit, value, and convertor
-///     during debugging.
-///     Each component is represented by a nested struct, which can be expanded in the debugger to inspect its properties.
-/// </remarks>
-internal readonly struct QuantityDisplay(IQuantity quantity)
-{
-    public UnitDisplay Unit => new(quantity);
-    public AbbreviationDisplay UnitAbbreviation => new(quantity);
-    public ValueDisplay Value => new(quantity);
-    public QuantityConvertor ValueConvertor => new(quantity);
-
-
-    [DebuggerDisplay("{DefaultAbbreviation}")]
-    internal readonly struct AbbreviationDisplay
-    {
-        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private readonly IQuantity _quantity;
-
-        public AbbreviationDisplay(IQuantity quantity)
-        {
-            _quantity = quantity;
-            QuantityInfo quantityQuantityInfo = quantity.QuantityInfo;
-            IQuantity baseQuantity = quantity.ToUnit(quantityQuantityInfo.BaseUnitInfo.Value);
-            Conversions = quantityQuantityInfo.UnitInfos.Select(x => new ConvertedQuantity(baseQuantity, x)).ToArray();
-        }
-
-        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        public string DefaultAbbreviation => UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(_quantity.Unit);
-
-        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-        public IReadOnlyList<string> Abbreviations => UnitsNetSetup.Default.UnitAbbreviations.GetUnitAbbreviations(_quantity.Unit);
-
-        public ConvertedQuantity[] Conversions { get; }
-
-        [DebuggerDisplay("{Abbreviation}")]
-        internal readonly struct ConvertedQuantity(IQuantity baseQuantity, UnitInfo unit)
-        {
-            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-            public UnitInfo Unit { get; } = unit;
-
-            [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-            public IQuantity Quantity => baseQuantity.ToUnit(Unit.Value);
-
-            [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-            public string Abbreviation => UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(Unit.UnitKey);
-
-            public override string ToString()
-            {
-                return Abbreviation;
-            }
-        }
-    }
-
-    [DebuggerDisplay("{Unit}")]
-    internal readonly struct UnitDisplay
-    {
-        public UnitDisplay(IQuantity quantity)
-        {
-            Unit = quantity.Unit;
-            IQuantity baseQuantity = quantity.ToUnit(quantity.QuantityInfo.BaseUnitInfo.Value);
-            Conversions = quantity.QuantityInfo.UnitInfos.Select(x => new ConvertedQuantity(baseQuantity, x.Value)).ToArray();
-        }
-
-        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        public Enum Unit { get; }
-
-        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-        public ConvertedQuantity[] Conversions { get; }
-
-        internal readonly struct ConvertedQuantity(IQuantity baseQuantity, Enum unit)
-        {
-            [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-            public IQuantity Quantity => baseQuantity.ToUnit(unit);
-
-            public override string ToString()
-            {
-                return unit.ToString();
-            }
-        }
-    }
-
-    [DebuggerDisplay("{DoubleValue}")]
-    internal readonly struct ValueDisplay(IQuantity quantity)
-    {
-        public double DoubleValue => quantity.Value;
-        public decimal DecimalValue => (decimal)quantity.Value;
-
-        public override string ToString()
-        {
-            return DoubleValue.ToString(CultureInfo.CurrentCulture);
-        }
-    }
-
-    [DebuggerDisplay("{QuantityToString}")]
-    internal readonly struct QuantityConvertor
-    {
-        public QuantityConvertor(IQuantity quantity)
-        {
-            QuantityToString = new StringFormatsDisplay(quantity);
-            QuantityInfo quantityQuantityInfo = quantity.QuantityInfo;
-            IQuantity baseQuantity = quantity.ToUnit(quantityQuantityInfo.BaseUnitInfo.Value);
-            QuantityToUnit = quantityQuantityInfo.UnitInfos.Select(x => new ConvertedQuantity(baseQuantity.ToUnit(x.Value), x)).ToArray();
-        }
-
-        public StringFormatsDisplay QuantityToString { get; }
-        public ConvertedQuantity[] QuantityToUnit { get; }
-
-        [DebuggerDisplay("{ShortFormat}")]
-        internal readonly struct StringFormatsDisplay(IQuantity quantity)
-        {
-            public string GeneralFormat => quantity.ToString("g", CultureInfo.CurrentCulture);
-            public string ShortFormat => quantity.ToString("s", CultureInfo.CurrentCulture);
-        }
-
-        [DebuggerDisplay("{Quantity}")]
-        internal readonly struct ConvertedQuantity(IQuantity quantity, UnitInfo unitInfo)
-        {
-            public UnitInfo Unit { get; } = unitInfo;
-            public string Abbreviation => UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(Unit.UnitKey);
-            public ValueDisplay Value => new(Quantity);
-            public IQuantity Quantity { get; } = quantity;
-
-            public override string ToString()
-            {
-                return Quantity.ToString()!;
-            }
-        }
-    }
-}
diff --git a/UnitsNet/QuantityFormatter.cs b/UnitsNet/QuantityFormatter.cs
index af2ff1cf22..9116a3621c 100644
--- a/UnitsNet/QuantityFormatter.cs
+++ b/UnitsNet/QuantityFormatter.cs
@@ -1,8 +1,7 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
-using System.Collections.Generic;
 using System.Globalization;
 
 namespace UnitsNet;
@@ -34,7 +33,9 @@ public QuantityFormatter(UnitAbbreviationsCache unitAbbreviations)
 
     /// <inheritdoc cref="Format{TUnitType}(UnitsNet.IQuantity{TUnitType},string,IFormatProvider)" />
     [Obsolete("Consider switching to one of the more performant instance methods available on QuantityFormatter.Default.")]
-    public static string Format<TUnitType>(IQuantity<TUnitType> quantity, string format)
+    public static string Format<TUnitType>(
+        IQuantity<TUnitType> quantity,
+        [StringSyntax(StringSyntaxAttribute.NumericFormat)] string format)
         where TUnitType : struct, Enum
     {
         return Format(quantity, format, CultureInfo.CurrentCulture);
@@ -42,7 +43,10 @@ public static string Format<TUnitType>(IQuantity<TUnitType> quantity, string for
 
     /// <inheritdoc cref="Format{TQuantity}(TQuantity,string,IFormatProvider)" />
     [Obsolete("Consider switching to one of the more performant instance methods available on QuantityFormatter.Default.")]
-    public static string Format<TUnitType>(IQuantity<TUnitType> quantity, string? format, IFormatProvider? formatProvider)
+    public static string Format<TUnitType>(
+        IQuantity<TUnitType> quantity,
+        [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format,
+        IFormatProvider? formatProvider)
         where TUnitType : struct, Enum
     {
         return Default.Format(quantity, format, formatProvider);
@@ -58,48 +62,14 @@ public static string Format<TUnitType>(IQuantity<TUnitType> quantity, string? fo
     ///     <see cref="CultureInfo.CurrentCulture" /> if null.
     /// </param>
     /// <remarks>
-    ///     The valid format strings are as follows:
-    ///     <list type="bullet">
-    ///         <item>
-    ///             <term>A standard numeric format string.</term>
-    ///             <description>
-    ///                 Any of the
-    ///                 <see
-    ///                     href="https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings#standard-format-specifiers">
-    ///                     Standard format specifiers
-    ///                 </see>
-    ///                 .
-    ///             </description>
-    ///         </item>
-    ///         <item>
-    ///             <term>"A" or "a".</term>
-    ///             <description>The default unit abbreviation for <see cref="IQuantity{TUnitType}.Unit" />, such as "m".</description>
-    ///         </item>
-    ///         <item>
-    ///             <term>"A0", "A1", ..., "An" or "a0", "a1", ..., "an".</term>
-    ///             <description>
-    ///                 The n-th unit abbreviation for the <see cref="IQuantity{TUnitType}.Unit" />. "a0" is the same as "a".
-    ///                 <para>
-    ///                     A <see cref="FormatException" /> will be thrown if the requested abbreviation index does not
-    ///                     exist.
-    ///                 </para>
-    ///             </description>
-    ///         </item>
-    ///         <item>
-    ///             <term>"S" or "s".</term>
-    ///             <description>
-    ///                 The value with 2 significant digits after the radix followed by the unit abbreviation, such as
-    ///                 "1.23 m".
-    ///             </description>
-    ///         </item>
-    ///         <item>
-    ///             <term>"S0", "S1", ..., "Sn" or "s0", "s1", ..., "sn".</term>
-    ///             <description>
-    ///                 The value with n significant digits after the radix followed by the unit abbreviation. "S2"
-    ///                 and "s2" is the same as "s".
-    ///             </description>
-    ///         </item>
-    ///     </list>
+    ///     The format is applied to the numeric value and the localized unit abbreviation is appended. Use a
+    ///     <see href="https://learn.microsoft.com/dotnet/standard/base-types/standard-numeric-format-strings">
+    ///         standard numeric format string
+    ///     </see>
+    ///     or a
+    ///     <see href="https://learn.microsoft.com/dotnet/standard/base-types/custom-numeric-format-strings">
+    ///         custom numeric format string
+    ///     </see>.
     ///     For more information about the formatter, see the
     ///     <see href="https://github.com/angularsen/UnitsNet?tab=readme-ov-file#culture-and-localization">
     ///         QuantityFormatter
@@ -109,7 +79,10 @@ public static string Format<TUnitType>(IQuantity<TUnitType> quantity, string? fo
     /// </remarks>
     /// <returns>The string representation.</returns>
     /// <exception cref="FormatException">Thrown when the format specifier is invalid.</exception>
-    public string Format<TQuantity>(TQuantity quantity, string? format = null, IFormatProvider? formatProvider = null)
+    public string Format<TQuantity>(
+        TQuantity quantity,
+        [StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format = null,
+        IFormatProvider? formatProvider = null)
         where TQuantity : IQuantity
     {
         formatProvider ??= CultureInfo.CurrentCulture;
@@ -121,12 +94,12 @@ public string Format<TQuantity>(TQuantity quantity, string? format = null, IForm
         {
             switch (format[0])
             {
-                case 'G' or 'g':
-                    return FormatWithValueAndAbbreviation(quantity, format, formatProvider);
-                case 'S' or 's':
-                    return ToStringWithSignificantDigitsAfterRadix(quantity, formatProvider, 0);
                 case 'A' or 'a':
-                    return _unitAbbreviations.GetDefaultAbbreviation(quantity.UnitKey, formatProvider);
+                    throw new FormatException(
+                        $"The \"{format}\" abbreviation format is no longer supported; use the generated quantity's GetAbbreviation method or UnitAbbreviationsCache.");
+                case 'S' or 's':
+                    throw new FormatException(
+                        $"The \"{format}\" significant-digits format is no longer supported; use a standard or custom numeric format string.");
                 case 'U' or 'u':
                     throw new FormatException($"The \"{format}\" format is no longer supported: consider using the Unit property.");
                 case 'V' or 'v':
@@ -144,52 +117,31 @@ public string Format<TQuantity>(TQuantity quantity, string? format = null, IForm
             switch (format[0])
             {
 #if NET
-                case 'S' or 's' when int.TryParse(format.AsSpan(1), out var precisionSpecifier):
-                    return ToStringWithSignificantDigitsAfterRadix(quantity, formatProvider, precisionSpecifier);
-                case 'A' or 'a' when int.TryParse(format.AsSpan(1), out var abbreviationIndex):
-                {
-                    IReadOnlyList<string> abbreviations = _unitAbbreviations.GetUnitAbbreviations(quantity.UnitKey, formatProvider);
-
-                    if (abbreviationIndex >= abbreviations.Count)
-                    {
-                        throw new FormatException($"The \"{format}\" format string is invalid because the index is out of range.");
-                    }
-
-                    return abbreviations[abbreviationIndex];
-                }
-                case 'C' or 'c' when int.TryParse(format.AsSpan(1), out _):
+                case 'A' or 'a' when int.TryParse(format.AsSpan(1), CultureInfo.InvariantCulture, out _):
+                    throw new FormatException(
+                        $"The \"{format}\" abbreviation format is no longer supported; use UnitAbbreviationsCache.GetUnitAbbreviations.");
+                case 'S' or 's' when int.TryParse(format.AsSpan(1), CultureInfo.InvariantCulture, out _):
+                    throw new FormatException(
+                        $"The \"{format}\" significant-digits format is no longer supported; use a standard or custom numeric format string.");
+                case 'C' or 'c' when int.TryParse(format.AsSpan(1), CultureInfo.InvariantCulture, out _):
                     throw new FormatException($"The \"{format}\" (currency) format is not supported.");
-                case 'P' or 'p' when int.TryParse(format.AsSpan(1), out _):
+                case 'P' or 'p' when int.TryParse(format.AsSpan(1), CultureInfo.InvariantCulture, out _):
                     throw new FormatException($"The \"{format}\" (percent) format is not supported.");
 #else
-                case 'S' or 's' when int.TryParse(format.Substring(1), out var precisionSpecifier):
-                    return ToStringWithSignificantDigitsAfterRadix(quantity, formatProvider, precisionSpecifier);
-                case 'A' or 'a' when int.TryParse(format.Substring(1), out var abbreviationIndex):
-                {
-                    IReadOnlyList<string> abbreviations = _unitAbbreviations.GetUnitAbbreviations(quantity.UnitKey, formatProvider);
-
-                    if (abbreviationIndex >= abbreviations.Count)
-                    {
-                        throw new FormatException($"The \"{format}\" format string is invalid because the index is out of range.");
-                    }
-
-                    return abbreviations[abbreviationIndex];
-                }
-                case 'C' or 'c' when int.TryParse(format.Substring(1), out _):
+                case 'A' or 'a' when int.TryParse(format.Substring(1), NumberStyles.Integer, CultureInfo.InvariantCulture, out _):
+                    throw new FormatException(
+                        $"The \"{format}\" abbreviation format is no longer supported; use UnitAbbreviationsCache.GetUnitAbbreviations.");
+                case 'S' or 's' when int.TryParse(format.Substring(1), NumberStyles.Integer, CultureInfo.InvariantCulture, out _):
+                    throw new FormatException(
+                        $"The \"{format}\" significant-digits format is no longer supported; use a standard or custom numeric format string.");
+                case 'C' or 'c' when int.TryParse(format.Substring(1), NumberStyles.Integer, CultureInfo.InvariantCulture, out _):
                     throw new FormatException($"The \"{format}\" (currency) format is not supported.");
-                case 'P' or 'p' when int.TryParse(format.Substring(1), out _):
+                case 'P' or 'p' when int.TryParse(format.Substring(1), NumberStyles.Integer, CultureInfo.InvariantCulture, out _):
                     throw new FormatException($"The \"{format}\" (percent) format is not supported.");
 #endif
             }
         }
 
-        // Anything else is a standard numeric format string with default unit abbreviation postfix.
-        return FormatWithValueAndAbbreviation(quantity, format, formatProvider);
-    }
-    
-    private string FormatWithValueAndAbbreviation<TQuantity>(TQuantity quantity, string format, IFormatProvider formatProvider)
-        where TQuantity : IQuantity
-    {
         var abbreviation = _unitAbbreviations.GetDefaultAbbreviation(quantity.UnitKey, formatProvider);
         if (abbreviation.Length == 0)
         {
@@ -203,13 +155,4 @@ private string FormatWithValueAndAbbreviation<TQuantity>(TQuantity quantity, str
         return quantity.Value.ToString(format, formatProvider) + ' ' + abbreviation;
 #endif
     }
-
-    private string ToStringWithSignificantDigitsAfterRadix<TQuantity>(TQuantity quantity, IFormatProvider formatProvider, int number)
-        where TQuantity : IQuantity
-    {
-        var formatForSignificantDigits = UnitFormatter.GetFormat(quantity.Value, number);
-        var abbreviation = _unitAbbreviations.GetDefaultAbbreviation(quantity.UnitKey, formatProvider);
-        var formatArgs = UnitFormatter.GetFormatArgs(quantity.Value, abbreviation, formatProvider, []);
-        return string.Format(formatProvider, formatForSignificantDigits, formatArgs).TrimEnd();
-    }
 }
diff --git a/UnitsNet/QuantityInfo.cs b/UnitsNet/QuantityInfo.cs
index bcddfb60a0..25a337e04f 100644
--- a/UnitsNet/QuantityInfo.cs
+++ b/UnitsNet/QuantityInfo.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Linq;
@@ -107,7 +107,7 @@ public IEnumerable<UnitInfo> GetUnitInfosFor(BaseUnits baseUnits)
     /// <returns>An instance of <see cref="IQuantity" /> representing the specified value and unit.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="unitKey" /> is null.</exception>
     /// <exception cref="ArgumentException">Thrown when <paramref name="unitKey" /> is not a valid unit for this quantity.</exception>
-    internal abstract IQuantity From(double value, UnitKey unitKey);
+    internal abstract IQuantity From(QuantityValue value, UnitKey unitKey);
 
     /// <inheritdoc />
     public override string ToString()
@@ -190,13 +190,13 @@ public UnitInfo<TUnit> this[TUnit unit]
     }
 
     /// <inheritdoc cref="QuantityInfo.From" />
-    public IQuantity<TUnit> From(double value, TUnit unit)
+    public IQuantity<TUnit> From(QuantityValue value, TUnit unit)
     {
         return CreateGenericQuantity(value, unit);
     }
 
-    /// <inheritdoc cref="From(double,TUnit)" />
-    protected internal abstract IQuantity<TUnit> CreateGenericQuantity(double value, TUnit unit);
+    /// <inheritdoc cref="From(UnitsNet.QuantityValue,TUnit)" />
+    protected internal abstract IQuantity<TUnit> CreateGenericQuantity(QuantityValue value, TUnit unit);
 
     #endregion
 
@@ -233,7 +233,7 @@ public override UnitInfo this[UnitKey unit]
     }
 
     /// <inheritdoc />
-    internal override IQuantity From(double value, UnitKey unitKey)
+    internal override IQuantity From(QuantityValue value, UnitKey unitKey)
     {
         return From(value, unitKey.ToUnit<TUnit>());
     }
@@ -303,13 +303,13 @@ protected QuantityInfoBase(string name, TQuantity zero, BaseDimensions baseDimen
     /// <param name="value">The numerical value of the quantity.</param>
     /// <param name="unit">The unit of the quantity.</param>
     /// <returns>An instance of <typeparamref name="TQuantity" /> representing the specified value and unit.</returns>
-    public new TQuantity From(double value, TUnit unit)
+    public new TQuantity From(QuantityValue value, TUnit unit)
     {
         return FromDelegate(value, unit);
     }
 
     /// <inheritdoc />
-    TQuantity IQuantityInstanceInfo<TQuantity>.Create(double value, UnitKey unitKey)
+    TQuantity IQuantityInstanceInfo<TQuantity>.Create(QuantityValue value, UnitKey unitKey)
     {
         return From(value, unitKey.ToUnit<TUnit>());
     }
@@ -343,7 +343,7 @@ protected internal override UnitInfo<TUnit> GetUnitInfo(TUnit unit)
     }
 
     /// <inheritdoc />
-    protected internal override IQuantity<TUnit> CreateGenericQuantity(double value, TUnit unit)
+    protected internal override IQuantity<TUnit> CreateGenericQuantity(QuantityValue value, TUnit unit)
     {
         return From(value, unit);
     }
@@ -361,7 +361,7 @@ public class QuantityInfo<TQuantity, TUnit> : QuantityInfoBase<TQuantity, TUnit,
 
     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
     private readonly Dictionary<TUnit, UnitInfo<TQuantity, TUnit>> _unitMappings;
-
+    
 #if NET
 
     /// <summary>
@@ -400,12 +400,12 @@ public QuantityInfo(TUnit baseUnit, IEnumerable<IUnitDefinition<TUnit>> unitMapp
     /// </exception>
     public QuantityInfo(string name, TUnit baseUnit, IEnumerable<IUnitDefinition<TUnit>> unitMappings, BaseDimensions baseDimensions,
         ResourceManager? unitAbbreviations = null)
-        : this(name, baseUnit, unitMappings, TQuantity.From(0, baseUnit), baseDimensions, TQuantity.From, unitAbbreviations)
+        : this(name, baseUnit, unitMappings, TQuantity.From(QuantityValue.Zero, baseUnit), baseDimensions, TQuantity.From, unitAbbreviations)
     {
     }
 
 #endif
-
+    
     /// <summary>
     ///     Initializes a new instance of the <see cref="QuantityInfo{TQuantity, TUnit}" /> class using the default quantity
     ///     name.
@@ -444,7 +444,7 @@ public QuantityInfo(TUnit baseUnit, IEnumerable<IUnitDefinition<TUnit>> unitMapp
     /// </exception>
     public QuantityInfo(string name, TUnit baseUnit, IEnumerable<IUnitDefinition<TUnit>> unitMappings, BaseDimensions baseDimensions,
         QuantityFromDelegate<TQuantity, TUnit> fromDelegate, ResourceManager? unitAbbreviations = null)
-        : this(name, baseUnit, unitMappings, fromDelegate(0, baseUnit), baseDimensions, fromDelegate, unitAbbreviations)
+        : this(name, baseUnit, unitMappings, fromDelegate(QuantityValue.Zero, baseUnit), baseDimensions, fromDelegate, unitAbbreviations)
     {
     }
 
diff --git a/UnitsNet/QuantityInfoLookup.cs b/UnitsNet/QuantityInfoLookup.cs
index 5aa7843f93..fb00b0cb20 100644
--- a/UnitsNet/QuantityInfoLookup.cs
+++ b/UnitsNet/QuantityInfoLookup.cs
@@ -1,4 +1,4 @@
-using System.Linq;
+using System.Linq;
 #if NET8_0_OR_GREATER
 using System.Collections.Frozen;
 using QuantityByTypeLookupDictionary = System.Collections.Frozen.FrozenDictionary<System.Type, UnitsNet.QuantityInfo>;
@@ -77,6 +77,8 @@ private UnitByKeyLookupDictionary GroupUnitsByKey()
     /// </remarks>
     public QuantityInfoLookup(IEnumerable<QuantityInfo> quantityInfos)
     {
+        if (quantityInfos is null) throw new ArgumentNullException(nameof(quantityInfos));
+
         _quantities = quantityInfos as QuantityInfo[] ?? quantityInfos.ToArray();
         _quantitiesByName = new Lazy<QuantityByNameLookupDictionary>(GroupQuantitiesByName);
         _quantitiesByType = new Lazy<QuantityByTypeLookupDictionary>(GroupQuantitiesByType);
@@ -99,6 +101,23 @@ public QuantityInfoLookup(IEnumerable<QuantityInfo> quantityInfos)
     /// </summary>
     public IReadOnlyList<QuantityInfo> Infos => _quantities;
 
+    internal static QuantityInfoLookup Create(IEnumerable<QuantityInfo> defaultQuantities, Action<QuantitiesSelector> configureQuantities)
+    {
+        if (defaultQuantities is null) throw new ArgumentNullException(nameof(defaultQuantities));
+        if (configureQuantities is null) throw new ArgumentNullException(nameof(configureQuantities));
+
+        var selector = new QuantitiesSelector(() => defaultQuantities);
+        configureQuantities(selector);
+        return Create(selector);
+    }
+
+    internal static QuantityInfoLookup Create(QuantitiesSelector selector)
+    {
+        if (selector is null) throw new ArgumentNullException(nameof(selector));
+
+        return new QuantityInfoLookup(selector.GetQuantityInfos());
+    }
+
     /// <summary>
     ///     Retrieves the <see cref="QuantityInfo" /> associated with the specified quantity type.
     /// </summary>
@@ -167,7 +186,7 @@ public bool TryGetUnitInfo(UnitKey unitKey, [NotNullWhen(true)] out UnitInfo? un
     /// <param name="unit">Unit enum value.</param>
     /// <returns>An <see cref="IQuantity" /> object.</returns>
     /// <exception cref="UnitNotFoundException">Unit value is not a know unit enum type.</exception>
-    public IQuantity From(double value, UnitKey unit)
+    public IQuantity From(QuantityValue value, UnitKey unit)
     {
         return GetUnitInfo(unit).From(value);
     }
@@ -184,14 +203,14 @@ public IQuantity From(double value, UnitKey unit)
     /// <returns>
     ///     <c>true</c> if the quantity was successfully created; otherwise, <c>false</c>.
     /// </returns>
-    public bool TryFrom(double value, [NotNullWhen(true)] Enum? unit, [NotNullWhen(true)] out IQuantity? quantity)
+    public bool TryFrom(QuantityValue value, [NotNullWhen(true)] Enum? unit, [NotNullWhen(true)] out IQuantity? quantity)
     {
         if (unit == null)
         {
             quantity = null;
             return false;
         }
-
+        
         if (!TryGetUnitInfo(unit, out UnitInfo? unitInfo))
         {
             quantity = null;
diff --git a/UnitsNet/QuantityTypeConverter.cs b/UnitsNet/QuantityTypeConverter.cs
index ad4350abef..030c8282d9 100644
--- a/UnitsNet/QuantityTypeConverter.cs
+++ b/UnitsNet/QuantityTypeConverter.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -61,6 +61,7 @@ public class DisplayAsUnitAttribute : DefaultUnitAttribute
         /// <summary>
         /// The formatting used when the quantity is converted to string. See <see cref="QuantityFormatter"/> for more information about the supported formats.
         /// </summary>
+        [StringSyntax(StringSyntaxAttribute.NumericFormat)]
         public string Format { get; set; }
 
         /// <summary>
@@ -68,7 +69,9 @@ public class DisplayAsUnitAttribute : DefaultUnitAttribute
         /// </summary>
         /// <param name="unitType">The unit the quantity should be displayed in</param>
         /// <param name="format">Formatting string passed to the <see cref="IFormattable.ToString(string?,System.IFormatProvider?)"/> </param>
-        public DisplayAsUnitAttribute(object? unitType, string format = "G") : base(unitType)
+        public DisplayAsUnitAttribute(
+            object? unitType,
+            [StringSyntax(StringSyntaxAttribute.NumericFormat)] string format = "G") : base(unitType)
         {
             Format = format;
         }
@@ -153,11 +156,14 @@ private static TAttribute? GetAttribute<
             // Ensure the attribute's unit is compatible with this converter's quantity.
             if (attribute?.UnitType != null)
             {
-                string converterQuantityName = default(TQuantity).QuantityInfo.Name;
-                string attributeQuantityName = Quantity.From(1, attribute.UnitType).QuantityInfo.Name;
-                if (converterQuantityName != attributeQuantityName)
+#pragma warning disable CS0618 // IQuantity.QuantityInfo is obsolete on .NET 5+; use it here so consumers can author custom quantities (e.g. HowMuch in tests) without registering them in UnitsNetSetup.Default.
+                Type declaredUnitType = attribute.UnitType.GetType();
+                QuantityInfo quantityInfo = default(TQuantity).QuantityInfo;
+#pragma warning restore CS0618
+                if (declaredUnitType != quantityInfo.UnitType)
                 {
-                    throw new ArgumentException($"The {attribute.GetType()}'s UnitType [{attribute.UnitType}] is not compatible with the converter's quantity [{converterQuantityName}].");
+                    throw new ArgumentException(
+                        $"The {attribute.GetType()}'s UnitType [{declaredUnitType}] is not compatible with the converter's quantity [{quantityInfo.Name}].");
                 }
             }
 
@@ -165,36 +171,48 @@ private static TAttribute? GetAttribute<
         }
 
         /// <summary>
-        ///     Converts the given object, when it is of type <see cref="string"/> to the type of this converter, using the specified context and culture information.
+        ///     Converts the given object, when it is of type <see cref="string" /> to the type of this converter, using the
+        ///     specified context and culture information.
         /// </summary>
         /// <param name="context">An System.ComponentModel.ITypeDescriptorContext that provides a format context.</param>
         /// <param name="culture">The System.Globalization.CultureInfo to use as the current culture.</param>
         /// <param name="value">The System.Object to convert.</param>
-        /// <returns>An <see cref="IQuantity"/> object.</returns>
+        /// <returns>An <see cref="IQuantity" /> object.</returns>
+        /// <exception cref="ArgumentException">
+        ///     Thrown when the unit defined by the <see cref="DefaultUnitAttribute" /> is not is not compatible with the
+        ///     converter's quantity.
+        /// </exception>
+        /// <exception cref="QuantityNotFoundException">
+        ///     Thrown when the specified quantity type is not registered in the current configuration.
+        /// </exception>
+        /// <exception cref="UnitNotFoundException">Unit value is not a known unit enum type.</exception>
         /// <exception cref="System.NotSupportedException">The conversion cannot be performed.</exception>
-        /// <exception cref="ArgumentException">Unit value is not a know unit enum type.</exception>
         public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value)
         {
             if (value is string stringValue && !string.IsNullOrEmpty(stringValue))
             {
                 IQuantity? quantity = null;
 
-                if (double.TryParse(stringValue, NumberStyles.Any, culture, out double dvalue))
+                if (QuantityValue.TryParse(stringValue, NumberStyles.Any, culture, out QuantityValue quantityValue))
                 {
-                    var defaultUnit = GetAttribute<DefaultUnitAttribute>(context) ?? new DefaultUnitAttribute(default(TQuantity).Unit);
-                    if(defaultUnit.UnitType != null)
-                        quantity = Quantity.From(dvalue, defaultUnit.UnitType);
+                    DefaultUnitAttribute defaultUnit = GetAttribute<DefaultUnitAttribute>(context) ?? new DefaultUnitAttribute(default(TQuantity).Unit);
+                    if (defaultUnit.UnitType != null)
+                    {
+                        quantity = Quantity.From(quantityValue, defaultUnit.UnitType);
+                    }
                 }
                 else
                 {
                     quantity = Quantity.Parse(culture, typeof(TQuantity), stringValue);
                 }
 
-                if( quantity != null)
+                if (quantity != null)
                 {
                     ConvertToUnitAttribute? convertToUnit = GetAttribute<ConvertToUnitAttribute>(context);
-                    if (convertToUnit != null && convertToUnit.UnitType != null)
-                        quantity = quantity.ToUnit(convertToUnit.UnitType);
+                    if (convertToUnit?.UnitType is {} targetUnit)
+                    {
+                        quantity = UnitConverter.Default.ConvertTo(quantity, targetUnit);
+                    }
 
                     return quantity;
                 }
@@ -239,7 +257,7 @@ public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destina
                 return quantity.ToString(displayAsUnit.Format, culture);
             }
 
-            return quantity.ToUnit(displayAsUnit.UnitType).ToString(displayAsUnit.Format, culture);
+            return UnitConverter.Default.ConvertTo(quantity, displayAsUnit.UnitType).ToString(displayAsUnit.Format, culture);
         }
     }
 }
diff --git a/UnitsNet/Serialization/QuantityValueSurrogate.cs b/UnitsNet/Serialization/QuantityValueSurrogate.cs
new file mode 100644
index 0000000000..f9c9538981
--- /dev/null
+++ b/UnitsNet/Serialization/QuantityValueSurrogate.cs
@@ -0,0 +1,31 @@
+using System.Runtime.Serialization;
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet;
+
+/// <summary>
+///     Represents a surrogate for serializing and deserializing quantity values.
+/// </summary>
+[DataContract]
+internal class QuantityValueSurrogate
+{
+    /// <summary>
+    ///     Gets or sets the numerator part of the quantity value.
+    /// </summary>
+    /// <value>
+    ///     A string representing the numerator of the quantity value.
+    /// </value>
+    /// <remarks>When omitted, the value is assumed to be "0".</remarks>
+    [DataMember(Order = 1, IsRequired = false, EmitDefaultValue = false, Name = "N")]
+    public string? Numerator { get; set; }
+
+    /// <summary>
+    ///     Gets or sets the denominator part of the quantity value.
+    /// </summary>
+    /// <value>
+    ///     The denominator as a string.
+    /// </value>
+    /// <remarks>When omitted, the value is assumed to be "1".</remarks>
+    [DataMember(Order = 2, IsRequired = false, EmitDefaultValue = false, Name = "D")]
+    public string? Denominator { get; set; }
+}
diff --git a/UnitsNet/Serialization/QuantityValueSurrogateSerializationProvider.cs b/UnitsNet/Serialization/QuantityValueSurrogateSerializationProvider.cs
new file mode 100644
index 0000000000..d96764da5c
--- /dev/null
+++ b/UnitsNet/Serialization/QuantityValueSurrogateSerializationProvider.cs
@@ -0,0 +1,92 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Globalization;
+using System.Numerics;
+using System.Runtime.Serialization;
+
+namespace UnitsNet.Serialization;
+
+/// <summary>
+///     Provides serialization and deserialization functionality for <see cref="QuantityValueSurrogate" /> objects.
+/// </summary>
+public sealed class QuantityValueSurrogateSerializationProvider : ISerializationSurrogateProvider
+{
+    /// <summary>
+    ///     Gets the singleton instance of the <see cref="QuantityValueSurrogateSerializationProvider" />.
+    /// </summary>
+    public static readonly ISerializationSurrogateProvider Instance = new QuantityValueSurrogateSerializationProvider();
+
+    private QuantityValueSurrogateSerializationProvider()
+    {
+    }
+
+    /// <summary>
+    ///     Deserializes an object of type <see cref="QuantityValueSurrogate" /> into a <see cref="QuantityValue" />.
+    /// </summary>
+    /// <param name="obj">The object to deserialize, expected to be of type <see cref="QuantityValueSurrogate" />.</param>
+    /// <param name="targetType">The target type for deserialization, expected to be <see cref="QuantityValue" />.</param>
+    /// <returns>
+    ///     A deserialized <see cref="QuantityValue" /> object if the input object is of type
+    ///     <see cref="QuantityValueSurrogate" />;
+    ///     otherwise, returns the input object.
+    /// </returns>
+    /// <exception cref="FormatException">
+    ///     Thrown when the numerator or denominator in the <see cref="QuantityValueSurrogate" /> cannot be parsed into a
+    ///     <see cref="BigInteger" />.
+    /// </exception>
+    public object GetDeserializedObject(object obj, Type targetType)
+    {
+        if (obj is not QuantityValueSurrogate quantityValueSurrogate)
+        {
+            return obj;
+        }
+
+        BigInteger numerator = quantityValueSurrogate.Numerator == null
+            ? BigInteger.Zero
+            : BigInteger.Parse(quantityValueSurrogate.Numerator, CultureInfo.InvariantCulture);
+        BigInteger denominator = quantityValueSurrogate.Denominator == null
+            ? BigInteger.One
+            : BigInteger.Parse(quantityValueSurrogate.Denominator, CultureInfo.InvariantCulture);
+        return new QuantityValue(numerator, denominator);
+    }
+
+    /// <summary>
+    ///     Converts a <see cref="QuantityValue" /> object to a <see cref="QuantityValueSurrogate" /> object for serialization
+    ///     purposes.
+    /// </summary>
+    /// <param name="obj">The object to be serialized, expected to be of type <see cref="QuantityValue" />.</param>
+    /// <param name="targetType">The type of the target object, which is ignored in this implementation.</param>
+    /// <returns>
+    ///     A <see cref="QuantityValueSurrogate" /> object containing the serialized data of the <see cref="QuantityValue" />
+    ///     object.
+    ///     If the input object is not of type <see cref="QuantityValue" />, the original object is returned.
+    /// </returns>
+    public object GetObjectToSerialize(object obj, Type targetType)
+    {
+        if (obj is not QuantityValue quantityValue)
+        {
+            return obj;
+        }
+
+        (BigInteger numerator, BigInteger denominator) = quantityValue;
+        return new QuantityValueSurrogate
+        {
+            Numerator = numerator.IsZero ? null : numerator.ToString(CultureInfo.InvariantCulture),
+            Denominator = denominator.IsOne ? null : denominator.ToString(CultureInfo.InvariantCulture)
+        };
+    }
+
+    /// <summary>
+    ///     Retrieves the surrogate type for the specified type.
+    /// </summary>
+    /// <param name="type">The type for which to get the surrogate type.</param>
+    /// <returns>
+    ///     The surrogate type if the specified type is <see cref="QuantityValue" />; otherwise, the original type.
+    /// </returns>
+    public Type GetSurrogateType(Type type)
+    {
+        return type == typeof(QuantityValue) ? typeof(QuantityValueSurrogate) : type;
+    }
+}
diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs
index e32b1bb26b..8050f69f87 100644
--- a/UnitsNet/UnitConverter.cs
+++ b/UnitsNet/UnitConverter.cs
@@ -1,555 +1,1214 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
-using System.Collections.Concurrent;
+using System.Globalization;
+using System.Linq;
 using UnitsNet.InternalHelpers;
 
-namespace UnitsNet
+#if NET
+using System.Collections.Frozen;
+#endif
+
+namespace UnitsNet;
+
+/// <summary>
+///     Convert between units of a quantity, such as converting from meters to centimeters of a given length.
+/// </summary>
+public class UnitConverter
 {
-    using ConversionFunctionLookupKey = ValueTuple<Type, Enum, Type, Enum>;
+    #if NET
+    private readonly FrozenSet<QuantityConversion> _quantityConversions;
+    #else
+    private readonly HashSet<QuantityConversion> _quantityConversions;
+    #endif
 
     /// <summary>
-    ///
+    ///     Initializes a new instance of the <see cref="UnitConverter" /> class with the specified
+    ///     <see cref="UnitParser" />.
     /// </summary>
-    /// <param name="inputValue"></param>
-    /// <returns></returns>
-    public delegate IQuantity ConversionFunction(IQuantity inputValue);
+    /// <param name="unitParser">The <see cref="UnitParser" /> used for parsing units.</param>
+    public UnitConverter(UnitParser unitParser)
+        : this(unitParser, unitParser.Quantities.GetQuantityConversions(Quantity.DefaultProvider.Conversions))
+    {
+        UnitParser = unitParser;
+    }
+
+    internal UnitConverter(UnitParser unitParser, IEnumerable<QuantityConversion> quantityConversions)
+    {
+        UnitParser = unitParser;
+#if NET
+        _quantityConversions = quantityConversions.ToFrozenSet();
+#else
+        _quantityConversions = [..quantityConversions];
+#endif
+    }
+
 
     /// <summary>
-    ///
+    ///     Gets the <see cref="UnitParser" /> instance used to parse unit abbreviations.
     /// </summary>
-    /// <typeparam name="TQuantity"></typeparam>
-    /// <param name="inputValue"></param>
-    /// <returns></returns>
-    public delegate TQuantity ConversionFunction<TQuantity>(TQuantity inputValue)
-        where TQuantity : IQuantity;
+    private UnitParser UnitParser { get; }
 
     /// <summary>
-    ///     Convert between units of a quantity, such as converting from meters to centimeters of a given length.
+    ///     Gets the lookup for quantity information, which provides access to details about available quantities,
+    ///     their associated units, and related metadata.
     /// </summary>
-    public sealed class UnitConverter
+    /// <remarks>
+    ///     It enables retrieval of unit and quantity information for conversion operations.
+    /// </remarks>
+    public QuantityInfoLookup Quantities
     {
-        /// <summary>
-        ///     The default singleton instance for converting values from one unit to another.<br />
-        ///     Modify this to add/remove conversion functions at runtime, such as adding your own third-party units and quantities to convert between.
-        /// </summary>
-        /// <remarks>
-        ///     Convenience shortcut for <see cref="UnitsNetSetup"/>.<see cref="UnitsNetSetup.Default"/>.<see cref="UnitsNetSetup.UnitConverter"/>.
-        /// </remarks>
-        public static UnitConverter Default => UnitsNetSetup.Default.UnitConverter;
+        get => UnitParser.Quantities;
+    }
 
-        /// <summary>
-        /// Creates a new <see cref="UnitConverter"/> instance.
-        /// </summary>
-        public UnitConverter()
+    /// <summary>
+    ///     Gets the default instance of the <see cref="UnitConverter" /> class.
+    /// </summary>
+    /// <value>
+    ///     The default <see cref="UnitConverter" /> instance configured by <see cref="UnitsNetSetup.Default" />.
+    /// </value>
+    public static UnitConverter Default => UnitsNetSetup.Default.UnitConverter;
+
+    /// <summary>
+    ///     Creates a new instance of the <see cref="UnitConverter" /> class.
+    /// </summary>
+    /// <param name="unitParser">The parser used to interpret unit abbreviations and symbols.</param>
+    /// <param name="options">
+    ///     Options for building the quantity converter, including whether to freeze
+    ///     the converter.
+    /// </param>
+    /// <returns>A new instance of <see cref="UnitConverter" /> configured according to the provided options.</returns>
+    /// <remarks>
+    ///     If <paramref name="options" /> specifies freezing, a <see cref="FrozenQuantityConverter" />
+    ///     is created.
+    ///     Otherwise, a <see cref="DynamicQuantityConverter" /> is created.
+    /// </remarks>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when failing to create a conversion expression for one of the user-specified quantity-conversions.
+    /// </exception>
+    public static UnitConverter Create(UnitParser unitParser, QuantityConverterBuildOptions options)
+    {
+        if (options is { DefaultCachingMode: ConversionCachingMode.None, CustomQuantityOptions.Count: 0, QuantityConversionOptions: null, Freeze: true })
         {
-            ConversionFunctions = new ConcurrentDictionary<ConversionFunctionLookupKey, ConversionFunction>();
+            return new NoCachingConverter(unitParser); // this is just a sealed version of the default converter
         }
 
-        /// <summary>
-        /// Creates a new <see cref="UnitConverter"/> instance with the <see cref="ConversionFunction"/> copied from <paramref name="other"/>.
-        /// </summary>
-        /// <param name="other">The <see cref="UnitConverter"/> to copy from.</param>
-        public UnitConverter(UnitConverter other)
+        QuantityInfoLookup quantityLookup = unitParser.Quantities;
+        IEnumerable<KeyValuePair<UnitConversionKey, ConvertValueDelegate>> unitConversionFunctions =
+            quantityLookup.Infos.GetUnitConversionFunctions(options.DefaultCachingMode, options.ReduceConstants, options.CustomQuantityOptions);
+
+        var quantityConversions = new HashSet<QuantityConversion>(quantityLookup.GetQuantityConversions(Quantity.DefaultProvider.Conversions));
+
+        IEnumerable<KeyValuePair<QuantityConversionKey, QuantityConversionFunction>> quantityConversionFunctions;
+        if (options.QuantityConversionOptions is { } customConversionOptions)
+        {
+            Dictionary<QuantityConversion, QuantityConversionMappingOptions> conversionOptions = quantityLookup.GetQuantityConversionMappingOptions(customConversionOptions);
+            quantityConversions.UnionWith(quantityLookup.GetQuantityConversions(customConversionOptions.CustomConversions).Concat(conversionOptions.Keys));
+            quantityConversionFunctions = quantityConversions.GetConversionFunctions(conversionOptions, options.DefaultCachingMode, options.ReduceConstants, options.CustomQuantityOptions);
+        }
+        else
+        {
+            quantityConversionFunctions = quantityConversions.GetConversionFunctions(options.DefaultCachingMode, options.ReduceConstants, options.CustomQuantityOptions);
+        }
+        
+        if (options.Freeze)
         {
-            ConversionFunctions = new ConcurrentDictionary<ConversionFunctionLookupKey, ConversionFunction>(other.ConversionFunctions);
+            return new FrozenQuantityConverter(unitParser, quantityConversions, unitConversionFunctions, quantityConversionFunctions);
         }
 
-        /// <summary>
-        ///     Create an instance of the unit converter with all the built-in unit conversions defined in the library.
-        /// </summary>
-        /// <returns>The unit converter.</returns>
-        public static UnitConverter CreateDefault()
+        return new DynamicQuantityConverter(unitParser, quantityConversions, unitConversionFunctions, quantityConversionFunctions, options.ReduceConstants);
+    }
+
+    /// <summary>
+    ///     Attempts to convert the specified quantity to the specified unit.
+    /// </summary>
+    /// <param name="quantity">The quantity to convert. Must not be null.</param>
+    /// <param name="toUnitKey">The unit to convert the quantity to.</param>
+    /// <param name="convertedQuantity">
+    ///     When this method returns, contains the converted quantity if the conversion succeeded, or <c>null</c> if the
+    ///     conversion failed.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the conversion succeeded; otherwise, <c>false</c>.
+    /// </returns>
+    public bool TryConvertTo<TQuantity>(TQuantity quantity, UnitKey toUnitKey, [NotNullWhen(true)] out IQuantity? convertedQuantity)
+        where TQuantity : IQuantity
+    {
+#pragma warning disable CS0618 // Type or member is obsolete
+        QuantityInfo quantityInfo = quantity.QuantityInfo;
+#pragma warning restore CS0618 // Type or member is obsolete
+        if (quantityInfo.UnitType == toUnitKey.UnitEnumType)
+        {
+            if (TryConvertValue(quantity.Value, quantity.UnitKey, toUnitKey, out QuantityValue convertedValue))
+            {
+                convertedQuantity = quantityInfo.From(convertedValue, toUnitKey);
+                return true;
+            }
+        }
+        else if (TryGetUnitInfo(quantity.UnitKey, out UnitInfo? fromUnitInfo) && TryGetUnitInfo(toUnitKey, out UnitInfo? toUnitInfo) &&
+                 TryConvertValueInternal(quantity.Value, fromUnitInfo, toUnitInfo, out QuantityValue convertedValue))
         {
-            var unitConverter = new UnitConverter();
-            RegisterDefaultConversions(unitConverter);
+            convertedQuantity = toUnitInfo.From(convertedValue);
+            return true;    
+        }
+
+        convertedQuantity = null;
+        return false;
+    }
 
-            return unitConverter;
+    /// <summary>
+    ///     Attempts to convert a quantity to a specified unit.
+    /// </summary>
+    /// <typeparam name="TQuantity">The type of the quantity.</typeparam>
+    /// <typeparam name="TUnit">The type of the unit.</typeparam>
+    /// <param name="quantity">The quantity to convert.</param>
+    /// <param name="toUnit">The unit to convert to.</param>
+    /// <param name="convertedQuantity">
+    ///     When this method returns, contains the converted quantity if the conversion succeeded, or <c>null</c> if the
+    ///     conversion failed.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the conversion succeeded; otherwise, <c>false</c>.
+    /// </returns>
+    public bool TryConvertToUnit<TQuantity, TUnit>(TQuantity quantity, TUnit toUnit, [NotNullWhen(true)] out TQuantity? convertedQuantity)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        if (TryConvertValue(quantity.Value, quantity.Unit, toUnit, out QuantityValue convertedValue))
+        {
+#if NET
+            QuantityInfo<TQuantity, TUnit> quantityInfo = TQuantity.Info;
+#else
+            QuantityInfo<TQuantity, TUnit> quantityInfo = quantity.QuantityInfo;
+#endif
+            convertedQuantity = quantityInfo.From(convertedValue, toUnit);
+            return true;
         }
 
-        private ConcurrentDictionary<ConversionFunctionLookupKey, ConversionFunction> ConversionFunctions
+        convertedQuantity = default;
+        return false;
+    }
+
+    /// <summary>
+    ///     Attempts to retrieve information about a specified unit.
+    /// </summary>
+    /// <param name="unit">The unit for which information is being requested.</param>
+    /// <param name="unitInfo">
+    ///     When this method returns, contains the unit information associated with the specified unit,
+    ///     if the unit is found; otherwise, <c>null</c>. This parameter is passed uninitialized.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the unit information was found; otherwise, <c>false</c>.
+    /// </returns>
+    protected bool TryGetUnitInfo(UnitKey unit, [NotNullWhen(true)] out UnitInfo? unitInfo)
+    {
+        return Quantities.TryGetUnitInfo(unit, out unitInfo);
+    }
+    
+    /// <summary>
+    ///     Determines whether a conversion is defined between the specified source and target quantities.
+    /// </summary>
+    /// <param name="sourceQuantity">The source quantity information.</param>
+    /// <param name="targetQuantity">The target quantity information.</param>
+    /// <returns>
+    ///     <c>true</c> if a conversion is defined between the source and target quantities; otherwise, <c>false</c>.
+    /// </returns>
+    protected bool ConversionDefined(QuantityInfo sourceQuantity, QuantityInfo targetQuantity)
+    {
+        return _quantityConversions.Contains(new QuantityConversion(sourceQuantity, targetQuantity));
+    }
+
+    /// <summary>
+    ///     Gets the collection of quantity conversions available in this <see cref="UnitConverter" />.
+    /// </summary>
+    /// <remarks>
+    ///     A quantity conversion defines the relationship between two quantities, enabling conversions
+    ///     between them. This property provides access to all such conversions configured for this instance.
+    /// </remarks>
+    internal IReadOnlyCollection<QuantityConversion> QuantityConversions => _quantityConversions;
+
+    /// <summary>
+    ///     Attempts to convert the specified quantity to a different unit.
+    /// </summary>
+    /// <typeparam name="TQuantity">The type of the quantity to be converted.</typeparam>
+    /// <typeparam name="TUnit">The type of the unit to convert to.</typeparam>
+    /// <param name="quantity">The quantity to be converted.</param>
+    /// <param name="toUnit">The unit to convert the quantity to.</param>
+    /// <param name="convertedValue">
+    ///     When this method returns, contains the converted value if the conversion succeeded; otherwise, the default value
+    ///     for the type of the converted value.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the conversion succeeded; otherwise, <c>false</c>.
+    /// </returns>
+    public bool TryConvertValue<TQuantity, TUnit>(TQuantity quantity, TUnit toUnit, out QuantityValue convertedValue)
+        where TQuantity : IQuantity<TUnit>
+        where TUnit : struct, Enum
+    {
+        return TryConvertValue(quantity.Value, quantity.Unit, toUnit, out convertedValue);
+    }
+
+    /// <summary>
+    ///     Attempts to convert a quantity value from one unit to another.
+    /// </summary>
+    /// <typeparam name="TUnit">The type of the unit enumeration.</typeparam>
+    /// <param name="value">The quantity value to be converted.</param>
+    /// <param name="fromUnit">The unit of the quantity value to convert from.</param>
+    /// <param name="toUnit">The unit of the quantity value to convert to.</param>
+    /// <param name="convertedValue">
+    ///     When this method returns, contains the converted quantity value if the conversion succeeded,
+    ///     or <c>null</c> if the conversion failed. This parameter is passed uninitialized.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the conversion succeeded; otherwise, <c>false</c>.
+    /// </returns>
+    public virtual bool TryConvertValue<TUnit>(QuantityValue value, TUnit fromUnit, TUnit toUnit, out QuantityValue convertedValue)
+        where TUnit : struct, Enum
+    {
+        var fromUnitKey = UnitKey.ForUnit(fromUnit);
+        var toUnitKey = UnitKey.ForUnit(toUnit);
+        if (fromUnitKey == toUnitKey)
         {
-            get;
+            convertedValue = value;
+            return true;
         }
+        
+        if (TryGetUnitInfo(fromUnitKey, out UnitInfo? fromUnitInfo) && TryGetUnitInfo(toUnitKey, out UnitInfo? toUnitInfo))
+        {
+            convertedValue = toUnitInfo.GetValueFrom(value, fromUnitInfo);
+            return true;
+        }
+
+        convertedValue = default;
+        return false;
+    }
 
-        /// <summary>
-        /// Registers the default conversion functions in the given <see cref="UnitConverter"/> instance.
-        /// </summary>
-        /// <param name="unitConverter">The <see cref="UnitConverter"/> to register the default conversion functions in.</param>
-        private static void RegisterDefaultConversions(UnitConverter unitConverter)
+    /// <summary>
+    ///     Attempts to convert a quantity value from one unit to another.
+    /// </summary>
+    /// <param name="value">The value to be converted.</param>
+    /// <param name="fromUnitKey">The unit of the value to be converted from.</param>
+    /// <param name="toUnitKey">The unit of the value to be converted to.</param>
+    /// <param name="convertedValue">
+    ///     When this method returns, contains the converted value if the conversion succeeded,
+    ///     or <c>null</c> if the conversion failed. This parameter is passed uninitialized.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the conversion succeeded; otherwise, <c>false</c>.
+    /// </returns>
+    public virtual bool TryConvertValue(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey, out QuantityValue convertedValue)
+    {
+        if (fromUnitKey == toUnitKey)
+        {
+            convertedValue = value;
+            return true;
+        }
+        
+        if (TryGetUnitInfo(fromUnitKey, out UnitInfo? fromUnitInfo) && TryGetUnitInfo(toUnitKey, out UnitInfo? toUnitInfo))
         {
-            if (unitConverter is null) throw new ArgumentNullException(nameof(unitConverter));
+            return TryConvertValueInternal(value, fromUnitInfo, toUnitInfo, out convertedValue);
+        }
+
+        convertedValue = default;
+        return false;
+    }
 
-            Quantity.DefaultProvider.RegisterUnitConversions(unitConverter);
+    /// <summary>
+    ///     Attempts to convert a quantity value from one unit to another.
+    /// </summary>
+    /// <param name="value">The quantity value to convert.</param>
+    /// <param name="fromUnitInfo">The unit information of the source unit.</param>
+    /// <param name="toUnitInfo">The unit information of the target unit.</param>
+    /// <param name="convertedValue">
+    ///     When this method returns, contains the converted quantity value if the conversion succeeded,
+    ///     or <c>null</c> if the conversion failed. This parameter is passed uninitialized.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the conversion succeeded; otherwise, <c>false</c>.
+    /// </returns>
+    /// <remarks>
+    ///     This method should succeed for any two units of the same quantity, but may fail if the units are from two
+    ///     incompatible quantities.
+    /// </remarks>
+    protected virtual bool TryConvertValueInternal(QuantityValue value, UnitInfo fromUnitInfo, UnitInfo toUnitInfo, out QuantityValue convertedValue)
+    {
+        if (fromUnitInfo.QuantityInfo != toUnitInfo.QuantityInfo)
+        {
+            return TryConvertValueFromOneQuantityToAnother(value, fromUnitInfo, toUnitInfo, out convertedValue);
         }
 
-        /// <summary>
-        /// Sets the conversion function from two units of the same quantity type.
-        /// </summary>
-        /// <typeparam name="TQuantity">The type of quantity, must implement <see cref="IQuantity"/>.</typeparam>
-        /// <param name="from">From unit enum value, such as <see cref="LengthUnit.Kilometer" />.</param>
-        /// <param name="to">To unit enum value, such as <see cref="LengthUnit.Centimeter"/>.</param>
-        /// <param name="conversionFunction">The quantity conversion function.</param>
-        public void SetConversionFunction<TQuantity>(Enum from, Enum to, ConversionFunction<TQuantity> conversionFunction)
-            where TQuantity : IQuantity
+        convertedValue = toUnitInfo.GetValueFrom(value, fromUnitInfo);
+        return true;
+    }
+
+    /// <summary>
+    ///     Attempts to convert a value from one quantity to another.
+    /// </summary>
+    /// <param name="value">The value to be converted.</param>
+    /// <param name="fromUnit">The unit of the value to be converted.</param>
+    /// <param name="toUnit">The unit to which the value should be converted.</param>
+    /// <param name="convertedValue">The converted value if the conversion is successful; otherwise, the default value.</param>
+    /// <returns>
+    ///     <c>true</c> if the conversion is successful; otherwise, <c>false</c>.
+    /// </returns>
+    /// <remarks>
+    ///     This method handles conversions between quantities with matching or inverse base dimensions.
+    /// </remarks>
+    protected bool TryConvertValueFromOneQuantityToAnother(QuantityValue value, UnitInfo fromUnit, UnitInfo toUnit, out QuantityValue convertedValue)
+    {
+        QuantityInfo sourceQuantity = fromUnit.QuantityInfo;
+        QuantityInfo targetQuantity = toUnit.QuantityInfo;
+        if (!ConversionDefined(sourceQuantity, targetQuantity))
+        {
+            convertedValue = default;
+            return false; 
+        }
+        
+        ConvertValueDelegate conversionExpression;
+        if (sourceQuantity.BaseDimensions.IsInverseOf(targetQuantity.BaseDimensions))
+        {
+            conversionExpression = QuantityValue.Inverse;
+        }
+        else if (sourceQuantity.BaseDimensions == targetQuantity.BaseDimensions)
+        {
+            if (sourceQuantity.BaseDimensions.IsDimensionless())
+            {
+                convertedValue = toUnit.ConvertValueFromBaseUnit(fromUnit.ConvertValueToBaseUnit(value));
+                return true;
+            }
+
+            conversionExpression = sourceValue => sourceValue;
+        }
+        else
         {
-            var quantityType = typeof(TQuantity);
-            var conversionLookup = new ConversionFunctionLookupKey(quantityType, from, quantityType, to);
-            SetConversionFunction(conversionLookup, conversionFunction);
+            convertedValue = default;
+            return false;
         }
 
-        /// <summary>
-        /// Sets the conversion function from two units of different quantity types.
-        /// </summary>
-        /// <typeparam name="TQuantityFrom">From quantity type, must implement <see cref="IQuantity"/>.</typeparam>
-        /// <typeparam name="TQuantityTo">To quantity type, must implement <see cref="IQuantity"/>.</typeparam>
-        /// <param name="from">From unit enum value, such as <see cref="LengthUnit.Kilometer" />.</param>
-        /// <param name="to">To unit enum value, such as <see cref="LengthUnit.Centimeter"/>.</param>
-        /// <param name="conversionFunction">The quantity conversion function.</param>
-        public void SetConversionFunction<TQuantityFrom, TQuantityTo>(Enum from, Enum to, ConversionFunction conversionFunction)
-            where TQuantityFrom : IQuantity
-            where TQuantityTo : IQuantity
+        if (fromUnit.BaseUnits != BaseUnits.Undefined)
+        {
+            if (toUnit.BaseUnits == fromUnit.BaseUnits)
+            {
+                convertedValue = conversionExpression(value);
+                return true;
+            }
+
+            if (targetQuantity.UnitInfos.TryGetUnitWithBase(fromUnit.BaseUnits, out UnitInfo? matchingUnit))
+            {
+                convertedValue = ConvertValueInternal(conversionExpression(value), matchingUnit, toUnit);
+                return true;
+            }
+
+            UnitInfo fromBaseUnit = sourceQuantity.BaseUnitInfo;
+            if (fromUnit.BaseUnits != fromBaseUnit.BaseUnits && fromBaseUnit.BaseUnits != BaseUnits.Undefined)
+            {
+                if (toUnit.QuantityInfo.BaseUnitInfo.BaseUnits == fromBaseUnit.BaseUnits)
+                {
+                    convertedValue = toUnit.ConvertValueFromBaseUnit(conversionExpression(fromUnit.ConversionToBase.Evaluate(value)));
+                    return true;
+                }
+            }
+        }
+        else if (toUnit.BaseUnits != BaseUnits.Undefined)
         {
-            SetConversionFunction(typeof(TQuantityFrom), from, typeof(TQuantityTo), to, conversionFunction);
+            if (sourceQuantity.UnitInfos.TryGetUnitWithBase(toUnit.BaseUnits, out UnitInfo? matchingUnit))
+            {
+                convertedValue = conversionExpression(ConvertValueInternal(value, fromUnit, matchingUnit));
+                return true;
+            }
+
+            UnitInfo toBaseUnit = targetQuantity.BaseUnitInfo;
+            if (toUnit.BaseUnits != toBaseUnit.BaseUnits && toBaseUnit.BaseUnits != BaseUnits.Undefined)
+            {
+                if (sourceQuantity.BaseUnitInfo.BaseUnits == toBaseUnit.BaseUnits)
+                {
+                    convertedValue = toUnit.ConversionFromBase.Evaluate(conversionExpression(fromUnit.ConvertValueToBaseUnit(value)));
+                    return true;
+                }
+            }
         }
 
-        /// <summary>
-        /// Sets the conversion function from two units of different quantity types.
-        /// </summary>
-        /// <param name="fromType">From quantity type, must implement <see cref="IQuantity"/>.</param>
-        /// <param name="from">From unit enum value, such as <see cref="LengthUnit.Kilometer" />.</param>
-        /// <param name="toType">To quantity type, must implement <see cref="IQuantity"/>.</param>
-        /// <param name="to">To unit enum value, such as <see cref="LengthUnit.Centimeter"/>.</param>
-        /// <param name="conversionFunction">The quantity conversion function.</param>
-        public void SetConversionFunction(Type fromType, Enum from, Type toType, Enum to, ConversionFunction conversionFunction)
+        foreach (UnitInfo sourceUnit in sourceQuantity.UnitInfos)
         {
-            var conversionLookup = new ConversionFunctionLookupKey(fromType, from, toType, to);
-            SetConversionFunction(conversionLookup, conversionFunction);
+            if (sourceUnit.BaseUnits == BaseUnits.Undefined || sourceUnit.BaseUnits == fromUnit.BaseUnits)
+            {
+                continue;
+            }
+
+            if (targetQuantity.UnitInfos.TryGetUnitWithBase(sourceUnit.BaseUnits, out UnitInfo? matchingUnit))
+            {
+                convertedValue = ConvertValueInternal(conversionExpression(ConvertValueInternal(value, fromUnit, sourceUnit)), matchingUnit, toUnit);
+                return true;
+            }
         }
 
-        /// <summary>
-        /// Sets the conversion function for a particular conversion function lookup.
-        /// </summary>
-        /// <param name="lookupKey">The lookup key.</param>
-        /// <param name="conversionFunction">The quantity conversion function.</param>
-        internal void SetConversionFunction(ConversionFunctionLookupKey lookupKey, ConversionFunction conversionFunction)
+        convertedValue = default;
+        return false;
+    }
+
+    /// <summary>
+    ///     Attempts to convert a quantity value from a source unit to a target quantity type and unit.
+    /// </summary>
+    /// <typeparam name="TSourceUnit">The type of the source unit enumeration.</typeparam>
+    /// <typeparam name="TTargetQuantity">The type of the target quantity.</typeparam>
+    /// <typeparam name="TTargetUnit">The type of the target unit enumeration.</typeparam>
+    /// <param name="value">The quantity value to convert.</param>
+    /// <param name="fromUnit">The source unit of the quantity value.</param>
+    /// <param name="targetQuantityInfo">The information about the target quantity type and unit.</param>
+    /// <param name="convertedQuantity">
+    ///     When this method returns, contains the converted quantity if the conversion succeeded, or <c>null</c> if the
+    ///     conversion failed.
+    /// </param>
+    /// <returns><c>true</c> if the conversion succeeded; otherwise, <c>false</c>.</returns>
+    public virtual bool TryConvertTo<TSourceUnit, TTargetQuantity, TTargetUnit>(QuantityValue value, TSourceUnit fromUnit,
+        QuantityInfo<TTargetQuantity, TTargetUnit> targetQuantityInfo, [MaybeNullWhen(false)] out TTargetQuantity convertedQuantity)
+        where TSourceUnit : struct, Enum
+        where TTargetQuantity : IQuantity<TTargetQuantity, TTargetUnit>
+        where TTargetUnit : struct, Enum
+    {
+        if (TryGetUnitInfo(UnitKey.ForUnit(fromUnit), out UnitInfo? fromUnitInfo) && ConversionDefined(fromUnitInfo.QuantityInfo, targetQuantityInfo))
         {
-            ConversionFunctions[lookupKey] = conversionFunction;
+            return targetQuantityInfo.TryConvertFrom(value, fromUnitInfo, out convertedQuantity);
         }
 
-        /// <summary>
-        /// Sets the conversion function for a particular conversion function lookup.
-        /// </summary>
-        /// <typeparam name="TQuantity">The quantity type, must implement <see cref="IQuantity"/>.</typeparam>
-        /// <param name="conversionLookup">The quantity conversion function lookup key.</param>
-        /// <param name="conversionFunction">The quantity conversion function.</param>
-        internal void SetConversionFunction<TQuantity>(ConversionFunctionLookupKey conversionLookup, ConversionFunction<TQuantity> conversionFunction)
-            where TQuantity : IQuantity
+        convertedQuantity = default;
+        return false;
+    }
+
+    /// <inheritdoc cref="TryConvertTo{TSourceUnit,TTargetQuantity,TTargetUnit}" />
+    public virtual bool TryConvertTo(QuantityValue value, UnitKey fromUnitKey, QuantityInfo targetQuantityInfo,
+        [NotNullWhen(true)] out IQuantity? convertedQuantity)
+    {
+        if (TryGetUnitInfo(fromUnitKey, out UnitInfo? fromUnitInfo) && ConversionDefined(fromUnitInfo.QuantityInfo, targetQuantityInfo))
         {
-            IQuantity TypelessConversionFunction(IQuantity quantity) => conversionFunction((TQuantity) quantity);
+            return targetQuantityInfo.TryConvertFrom(value, fromUnitInfo, out convertedQuantity);
+        }
 
-            ConversionFunctions[conversionLookup] = TypelessConversionFunction;
+        convertedQuantity = null;
+        return false;
+    }
+    
+    /// <summary>
+    ///     Converts the quantity to the specified unit.
+    /// </summary>
+    /// <param name="quantity">The quantity to convert. Must not be null.</param>
+    /// <param name="toUnitKey">The unit to convert the quantity to.</param>
+    /// When this method returns, contains the converted quantity if the conversion succeeded, or
+    /// <c>null</c>
+    /// if the
+    /// conversion failed.
+    /// <returns>
+    ///     A new instance of <typeparamref name="TQuantity" /> representing the converted value in the specified unit.
+    /// </returns>
+    /// <exception cref="UnitNotFoundException">Thrown when no unit information is found for the specified enum value.</exception>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when the conversion between the specified units is not possible.
+    /// </exception>
+    /// <remarks>
+    ///     This method should succeed for any two units of the same quantity, but may fail if the units are not found or are
+    ///     found to be from two
+    ///     incompatible quantities.
+    /// </remarks>
+    public IQuantity ConvertTo<TQuantity>(TQuantity quantity, UnitKey toUnitKey)
+        where TQuantity : IQuantity
+    {
+#pragma warning disable CS0618 // Type or member is obsolete
+        // the alternative is to use Quantities.GetQuantityInfo(quantity.GetType());
+        QuantityInfo quantityInfo = quantity.QuantityInfo;
+#pragma warning restore CS0618 // Type or member is obsolete
+        if (quantityInfo.UnitType == toUnitKey.UnitEnumType)
+        {
+            QuantityValue convertedValue = ConvertValue(quantity.Value, quantity.UnitKey, toUnitKey);
+            return quantityInfo.From(convertedValue, toUnitKey);
+        }
+        else
+        {
+            UnitInfo fromUnitInfo = GetUnitInfo(quantity.UnitKey);
+            UnitInfo toUnitInfo = GetUnitInfo(toUnitKey);
+            QuantityValue convertedValue = ConvertValueInternal(quantity.Value, fromUnitInfo, toUnitInfo);
+            return toUnitInfo.From(convertedValue);
         }
+    }
+
+    /// <summary>
+    ///     Converts a quantity from its current unit to the specified unit.
+    /// </summary>
+    /// <typeparam name="TQuantity">
+    ///     The type of the quantity being converted. Must implement <see cref="IQuantity{TSelf, TUnitType}" />.
+    /// </typeparam>
+    /// <typeparam name="TUnit">
+    ///     The type of the unit to convert to. Must be an enumeration.
+    /// </typeparam>
+    /// <param name="quantity">
+    ///     The quantity to be converted, including its value and current unit.
+    /// </param>
+    /// <param name="toUnit">
+    ///     The target unit to which the quantity should be converted.
+    /// </param>
+    /// <returns>
+    ///     A new instance of <typeparamref name="TQuantity" /> representing the converted value in the specified unit.
+    /// </returns>
+    /// <exception cref="UnitNotFoundException">Thrown when an unknown unit is provided.</exception>
+    public TQuantity ConvertToUnit<TQuantity, TUnit>(TQuantity quantity, TUnit toUnit)
+        where TQuantity : IQuantity<TQuantity, TUnit>
+        where TUnit : struct, Enum
+    {
+        QuantityValue convertedValue = ConvertValue(quantity.Value, quantity.Unit, toUnit);
+#if NET
+        QuantityInfo<TQuantity, TUnit> quantityInfo = TQuantity.Info;
+#else
+        QuantityInfo<TQuantity, TUnit> quantityInfo = quantity.QuantityInfo;
+#endif
+        return quantityInfo.From(convertedValue, toUnit);
+    }
+
+    /// <summary>
+    ///     Retrieves information about a specific unit.
+    /// </summary>
+    /// <param name="unit">The unit for which information is being requested.</param>
+    /// <returns>An <see cref="UnitInfo" /> object containing details about the specified unit.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when the <paramref name="unit" /> is null.</exception>
+    /// <exception cref="UnitNotFoundException">Thrown when the <paramref name="unit" /> is not recognized.</exception>
+    protected UnitInfo GetUnitInfo(UnitKey unit)
+    {
+        return Quantities.GetUnitInfo(unit);
+    }
+
+    /// <summary>
+    ///     Converts the value of a quantity to a specified unit.
+    /// </summary>
+    /// <typeparam name="TQuantity">The type of quantity to use as the source of the conversion.</typeparam>
+    /// <typeparam name="TUnit">The type of the unit to convert to. Must be a struct and an enum.</typeparam>
+    /// <param name="quantity">The quantity to convert.</param>
+    /// <param name="toUnit">The unit to convert the quantity to.</param>
+    /// <returns>The converted quantity value.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when the <paramref name="quantity" /> is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when the conversion is not possible.</exception>
+    /// <exception cref="UnitNotFoundException">Thrown when <paramref name="toUnit" /> is not found.</exception>
+    public QuantityValue ConvertValue<TQuantity, TUnit>(TQuantity quantity, TUnit toUnit)
+        where TQuantity : IQuantity<TUnit>
+        where TUnit : struct, Enum
+    {
+        return ConvertValue(quantity.Value, quantity.Unit, toUnit);
+    }
 
-        /// <summary>
-        /// Gets the conversion function from two units of the same quantity type.
-        /// </summary>
-        /// <typeparam name="TQuantity">The quantity type, must implement <see cref="IQuantity"/>.</typeparam>
-        /// <param name="from">From unit enum value, such as <see cref="LengthUnit.Kilometer" />.</param>
-        /// <param name="to">To unit enum value, such as <see cref="LengthUnit.Centimeter"/>.</param>
-        /// <returns></returns>
-        public ConversionFunction GetConversionFunction<TQuantity>(Enum from, Enum to) where TQuantity : IQuantity
+    /// <summary>
+    ///     Converts a quantity value from one unit to another using the specified quantity information.
+    /// </summary>
+    /// <typeparam name="TUnit">The type of the unit.</typeparam>
+    /// <param name="value">The value to be converted.</param>
+    /// <param name="fromUnit">The unit of the value to be converted.</param>
+    /// <param name="toUnit">The unit to which the value should be converted.</param>
+    /// <exception cref="UnitNotFoundException">Thrown when either <paramref name="fromUnit" /> or <paramref name="toUnit" /> is not found.</exception>
+    /// <returns>The converted quantity value.</returns>
+    public virtual QuantityValue ConvertValue<TUnit>(QuantityValue value, TUnit fromUnit, TUnit toUnit)
+        where TUnit : struct, Enum
+    {
+        var fromUnitKey = UnitKey.ForUnit(fromUnit);
+        var toUnitKey = UnitKey.ForUnit(toUnit);
+        if (fromUnitKey.UnitEnumValue == toUnitKey.UnitEnumValue)
         {
-            return GetConversionFunction(typeof(TQuantity), from, typeof(TQuantity), to);
+            return value;
         }
+        
+        UnitInfo fromUnitInfo = GetUnitInfo(fromUnitKey);
+        UnitInfo toUnitInfo = GetUnitInfo(toUnitKey);
+        return toUnitInfo.GetValueFrom(value, fromUnitInfo);
+    }
 
-        /// <summary>
-        /// Gets the conversion function from two units of different quantity types.
-        /// </summary>
-        /// <typeparam name="TQuantityFrom">From quantity type, must implement <see cref="IQuantity"/>.</typeparam>
-        /// <typeparam name="TQuantityTo">To quantity type, must implement <see cref="IQuantity"/>.</typeparam>
-        /// <param name="from">From unit enum value, such as <see cref="LengthUnit.Kilometer" />.</param>
-        /// <param name="to">To unit enum value, such as <see cref="LengthUnit.Centimeter"/>.</param>
-        /// <returns></returns>
-        public ConversionFunction GetConversionFunction<TQuantityFrom, TQuantityTo>(Enum from, Enum to)
-            where TQuantityFrom : IQuantity
-            where TQuantityTo : IQuantity
-        {
-            return GetConversionFunction(typeof(TQuantityFrom), from, typeof(TQuantityTo), to);
-        }
-
-        /// <summary>
-        /// Gets the conversion function from two units of different quantity types.
-        /// </summary>
-        /// <param name="fromType">From quantity type, must implement <see cref="IQuantity"/>.</param>
-        /// <param name="from">From unit enum value, such as <see cref="LengthUnit.Kilometer" />.</param>
-        /// <param name="toType">To quantity type, must implement <see cref="IQuantity"/>.</param>
-        /// <param name="to">To unit enum value, such as <see cref="LengthUnit.Centimeter"/>.</param>
-        public ConversionFunction GetConversionFunction(Type fromType, Enum from, Type toType, Enum to)
-        {
-            var conversionLookup = new ConversionFunctionLookupKey(fromType, from, toType, to);
-            return GetConversionFunction(conversionLookup);
-        }
-
-        /// <summary>
-        /// Gets the conversion function by its lookup key.
-        /// </summary>
-        /// <param name="lookupKey"></param>
-        internal ConversionFunction GetConversionFunction(ConversionFunctionLookupKey lookupKey)
-        {
-            IQuantity EchoFunction(IQuantity fromQuantity) => fromQuantity;
-
-            // If from/to units and to quantity types are equal, then return a function that echoes the input quantity
-            // in order to not have to map conversion functions to "self".
-            if (lookupKey.Item1 == lookupKey.Item3 && Equals(lookupKey.Item2, lookupKey.Item4))
-                return EchoFunction;
-
-            return ConversionFunctions[lookupKey];
-        }
-
-        /// <summary>
-        /// Gets the conversion function for two units of the same quantity type.
-        /// </summary>
-        /// <typeparam name="TQuantity">The quantity type, must implement <see cref="IQuantity"/>.</typeparam>
-        /// <param name="from">From unit enum value, such as <see cref="LengthUnit.Kilometer" />.</param>
-        /// <param name="to">To unit enum value, such as <see cref="LengthUnit.Centimeter"/>.</param>
-        /// <param name="conversionFunction">The quantity conversion function.</param>
-        /// <returns>true if set; otherwise, false.</returns>
-        public bool TryGetConversionFunction<TQuantity>(Enum from, Enum to, [NotNullWhen(true)] out ConversionFunction? conversionFunction) where TQuantity : IQuantity
-        {
-            return TryGetConversionFunction(typeof(TQuantity), from, typeof(TQuantity), to, out conversionFunction);
-        }
-
-        /// <summary>
-        /// Gets the conversion function for two units of different quantity types.
-        /// </summary>
-        /// <typeparam name="TQuantityFrom">From quantity type, must implement <see cref="IQuantity"/>.</typeparam>
-        /// <typeparam name="TQuantityTo">To quantity type, must implement <see cref="IQuantity"/>.</typeparam>
-        /// <param name="from">From unit enum value, such as <see cref="LengthUnit.Kilometer" />.</param>
-        /// <param name="to">To unit enum value, such as <see cref="LengthUnit.Centimeter"/>.</param>
-        /// <param name="conversionFunction">The quantity conversion function.</param>
-        /// <returns>true if set; otherwise, false.</returns>
-        public bool TryGetConversionFunction<TQuantityFrom, TQuantityTo>(Enum from, Enum to, [NotNullWhen(true)] out ConversionFunction? conversionFunction)
-            where TQuantityFrom : IQuantity
-            where TQuantityTo : IQuantity
-        {
-            return TryGetConversionFunction(typeof(TQuantityFrom), from, typeof(TQuantityTo), to, out conversionFunction);
-        }
-
-        /// <summary>
-        /// Try to get the conversion function for two units of the same quantity type.
-        /// </summary>
-        /// <param name="fromType">From quantity type, must implement <see cref="IQuantity"/>.</param>
-        /// <param name="from">From unit enum value, such as <see cref="LengthUnit.Kilometer" />.</param>
-        /// <param name="toType">To quantity type, must implement <see cref="IQuantity"/>.</param>
-        /// <param name="to">To unit enum value, such as <see cref="LengthUnit.Centimeter"/>.</param>
-        /// <param name="conversionFunction">The quantity conversion function.</param>
-        /// <returns>true if set; otherwise, false.</returns>
-        public bool TryGetConversionFunction(Type fromType, Enum from, Type toType, Enum to, [NotNullWhen(true)] out ConversionFunction? conversionFunction)
-        {
-            var conversionLookup = new ConversionFunctionLookupKey(fromType, from, toType, to);
-            return TryGetConversionFunction(conversionLookup, out conversionFunction);
-        }
-
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="lookupKey"></param>
-        /// <param name="conversionFunction"></param>
-        /// <returns>true if set; otherwise, false.</returns>
-        public bool TryGetConversionFunction(ConversionFunctionLookupKey lookupKey, [NotNullWhen(true)] out ConversionFunction? conversionFunction)
-        {
-            return ConversionFunctions.TryGetValue(lookupKey, out conversionFunction);
-        }
-
-        /// <summary>
-        ///     Convert between any two quantity units given a numeric value and two unit enum values.
-        /// </summary>
-        /// <param name="fromValue">Numeric value.</param>
-        /// <param name="fromUnitValue">From unit enum value.</param>
-        /// <param name="toUnitValue">To unit enum value, must be compatible with <paramref name="fromUnitValue" />.</param>
-        /// <returns>The converted value in the new unit representation.</returns>
-        public static double Convert(double fromValue, Enum fromUnitValue, Enum toUnitValue)
-        {
-            return Quantity
-                .From(fromValue, fromUnitValue)
-                .As(toUnitValue);
-        }
-
-        /// <summary>
-        ///     Try to convert between any two quantity units given a numeric value and two unit enum values.
-        /// </summary>
-        /// <param name="fromValue">Numeric value.</param>
-        /// <param name="fromUnitValue">From unit enum value.</param>
-        /// <param name="toUnitValue">To unit enum value, must be compatible with <paramref name="fromUnitValue" />.</param>
-        /// <param name="convertedValue">The converted value, if successful. Otherwise default.</param>
-        /// <returns>True if successful.</returns>
-        public static bool TryConvert(double fromValue, Enum fromUnitValue, Enum toUnitValue, out double convertedValue)
-        {
-            convertedValue = 0;
-            if (!Quantity.TryFrom(fromValue, fromUnitValue, out IQuantity? fromQuantity))
-                return false;
-
-            try
+    /// <summary>
+    ///     Converts a quantity value from one unit to another using the specified quantity information.
+    /// </summary>
+    /// <param name="value">The value to be converted.</param>
+    /// <param name="fromUnitKey">The unit of the value to be converted from.</param>
+    /// <param name="toUnitKey">The unit of the value to be converted to.</param>
+    /// <returns>The converted quantity value.</returns>
+    /// <exception cref="UnitNotFoundException">Thrown when no unit information is found for the specified enum value.</exception>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when the conversion between the specified units is not possible.
+    /// </exception>
+    /// <remarks>
+    ///     This method should succeed for any two units of the same quantity, but may fail if the units are not found or are
+    ///     found to be from two
+    ///     incompatible quantities.
+    /// </remarks>
+    public virtual QuantityValue ConvertValue(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey)
+    {
+        if (fromUnitKey == toUnitKey)
+        {
+            return value;
+        }
+        
+        UnitInfo fromUnitInfo = GetUnitInfo(fromUnitKey);
+        UnitInfo toUnitInfo = GetUnitInfo(toUnitKey);
+        return ConvertValueInternal(value, fromUnitInfo, toUnitInfo);
+    }
+
+    /// <summary>
+    ///     Converts a quantity value from one unit to another.
+    /// </summary>
+    /// <param name="value">The quantity value to convert.</param>
+    /// <param name="fromUnitInfo">The unit information of the source unit.</param>
+    /// <param name="toUnitInfo">The unit information of the target unit.</param>
+    /// <returns>The converted quantity value.</returns>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when the conversion between the specified units is not possible.
+    /// </exception>
+    /// <remarks>
+    ///     This method should succeed for any two units of the same quantity, but may fail if the units are from two
+    ///     incompatible quantities.
+    /// </remarks>
+    protected virtual QuantityValue ConvertValueInternal(QuantityValue value, UnitInfo fromUnitInfo, UnitInfo toUnitInfo)
+    {
+        return fromUnitInfo.QuantityInfo == toUnitInfo.QuantityInfo
+            ? toUnitInfo.GetValueFrom(value, fromUnitInfo)
+            : ConvertValueFromOneQuantityToAnother(value, fromUnitInfo, toUnitInfo);
+    }
+
+    /// <summary>
+    ///     Converts a value from one quantity to another, considering the units and their base dimensions.
+    /// </summary>
+    /// <param name="value">The value to be converted.</param>
+    /// <param name="fromUnitInfo">Information about the unit of the source quantity.</param>
+    /// <param name="toUnitInfo">Information about the unit of the target quantity.</param>
+    /// <returns>The converted value in the target quantity's unit.</returns>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when no implicit conversion exists between the source and target quantities,
+    ///     or when no compatible units are found for the conversion.
+    /// </exception>
+    /// <remarks>
+    ///     This method handles conversions between quantities with matching or inverse base dimensions.
+    /// </remarks>
+    protected QuantityValue ConvertValueFromOneQuantityToAnother(QuantityValue value, UnitInfo fromUnitInfo, UnitInfo toUnitInfo)
+    {
+        QuantityInfo sourceQuantity = fromUnitInfo.QuantityInfo;
+        QuantityInfo targetQuantity = toUnitInfo.QuantityInfo;
+        if (!ConversionDefined(sourceQuantity, targetQuantity))
+        {
+            throw InvalidConversionException.CreateImplicitConversionException(sourceQuantity, targetQuantity);
+        }
+        
+        ConvertValueDelegate conversionExpression;
+        if (sourceQuantity.BaseDimensions.IsInverseOf(targetQuantity.BaseDimensions))
+        {
+            conversionExpression = QuantityValue.Inverse;
+        }
+        else if (sourceQuantity.BaseDimensions == targetQuantity.BaseDimensions)
+        {
+            if (sourceQuantity.BaseDimensions.IsDimensionless())
             {
-                // We're not going to implement TryAs() in all quantities, so let's just try-catch here
-                convertedValue = fromQuantity.As(toUnitValue);
-                return true;
+                return toUnitInfo.ConvertValueFromBaseUnit(fromUnitInfo.ConvertValueToBaseUnit(value));
+            }
+
+            conversionExpression = sourceValue => sourceValue;
+        }
+        else
+        {
+            throw InvalidConversionException.CreateIncompatibleDimensionsException(sourceQuantity, targetQuantity);
+        }
+
+        if (fromUnitInfo.BaseUnits != BaseUnits.Undefined)
+        {
+            if (toUnitInfo.BaseUnits == fromUnitInfo.BaseUnits)
+            {
+                return conversionExpression(value);
             }
-            catch
+
+            if (targetQuantity.UnitInfos.TryGetUnitWithBase(fromUnitInfo.BaseUnits, out UnitInfo? matchingUnit))
             {
-                return false;
+                return ConvertValueInternal(conversionExpression(value), matchingUnit, toUnitInfo);
             }
-        }
 
-        /// <summary>
-        ///     Convert between any two quantity units by their names, such as converting a "Length" of N "Meter" to "Centimeter".
-        ///     This is particularly useful for creating things like a generated unit conversion UI,
-        ///     where you list some selectors:
-        ///     a) Quantity: Length, Mass, Force etc.
-        ///     b) From unit: Meter, Centimeter etc if Length is selected
-        ///     c) To unit: Meter, Centimeter etc if Length is selected
-        /// </summary>
-        /// <param name="fromValue">
-        ///     Input value, which together with <paramref name="fromUnitName" /> represents the quantity to
-        ///     convert from.
-        /// </param>
-        /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
-        /// <param name="fromUnitName">The invariant unit enum name, such as "Meter". Does not support localization.</param>
-        /// <param name="toUnitName">The invariant unit enum name, such as "Meter". Does not support localization.</param>
-        /// <example>double centimeters = ConvertByName(5, "Length", "Meter", "Centimeter"); // 500</example>
-        /// <returns>Output value as the result of converting to <paramref name="toUnitName" />.</returns>
-        /// <exception cref="QuantityNotFoundException">
-        ///     Thrown when no quantity information is found for the specified quantity name.
-        /// </exception>
-        /// <exception cref="UnitNotFoundException">No units match the provided unit name.</exception>
-        /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
-        public static double ConvertByName(double fromValue, string quantityName, string fromUnitName, string toUnitName)
-        {
-            QuantityInfoLookup quantities = UnitsNetSetup.Default.Quantities;
-            UnitInfo fromUnit = quantities.GetUnitByName(quantityName, fromUnitName);
-            UnitInfo toUnit = quantities.GetUnitByName(quantityName, toUnitName);
-            return Quantity.From(fromValue, fromUnit.Value).As(toUnit.Value);
-        }
-
-        /// <summary>
-        ///     Convert between any two quantity units by their names, such as converting a "Length" of N "Meter" to "Centimeter".
-        ///     This is particularly useful for creating things like a generated unit conversion UI,
-        ///     where you list some selectors:
-        ///     a) Quantity: Length, Mass, Force etc.
-        ///     b) From unit: Meter, Centimeter etc if Length is selected
-        ///     c) To unit: Meter, Centimeter etc if Length is selected
-        /// </summary>
-        /// <param name="inputValue">
-        ///     Input value, which together with <paramref name="fromUnit" /> represents the quantity to
-        ///     convert from.
-        /// </param>
-        /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
-        /// <param name="fromUnit">The invariant unit enum name, such as "Meter". Does not support localization.</param>
-        /// <param name="toUnit">The invariant unit enum name, such as "Meter". Does not support localization.</param>
-        /// <param name="result">Result if conversion was successful, 0 if not.</param>
-        /// <example>bool ok = TryConvertByName(5, "Length", "Meter", "Centimeter", out double centimeters); // 500</example>
-        /// <returns>True if conversion was successful.</returns>
-        public static bool TryConvertByName(double inputValue, string quantityName, string fromUnit, string toUnit, out double result)
-        {
-            QuantityInfoLookup quantities = UnitsNetSetup.Default.Quantities;
-            if (quantities.TryGetUnitByName(quantityName, fromUnit, out UnitInfo? fromUnitInfo) &&
-                quantities.TryGetUnitByName(quantityName, toUnit, out UnitInfo? toUnitInfo) &&
-                Quantity.TryFrom(inputValue, fromUnitInfo.Value, out IQuantity? quantity))
+            UnitInfo fromBaseUnit = sourceQuantity.BaseUnitInfo;
+            if (fromUnitInfo.BaseUnits != fromBaseUnit.BaseUnits && fromBaseUnit.BaseUnits != BaseUnits.Undefined)
             {
-                result = quantity.As(toUnitInfo.Value);
-                return true;
+                if (toUnitInfo.QuantityInfo.BaseUnitInfo.BaseUnits == fromBaseUnit.BaseUnits)
+                {
+                    return toUnitInfo.ConvertValueFromBaseUnit(conversionExpression(fromUnitInfo.ConversionToBase.Evaluate(value)));
+                }
+            }
+        }
+        else if (toUnitInfo.BaseUnits != BaseUnits.Undefined)
+        {
+            if (sourceQuantity.UnitInfos.TryGetUnitWithBase(toUnitInfo.BaseUnits, out UnitInfo? matchingUnit))
+            {
+                return conversionExpression(ConvertValueInternal(value, fromUnitInfo, matchingUnit));
             }
 
-            result = 0d;
-            return false;
+            UnitInfo toBaseUnit = targetQuantity.BaseUnitInfo;
+            if (toUnitInfo.BaseUnits != toBaseUnit.BaseUnits && toBaseUnit.BaseUnits != BaseUnits.Undefined)
+            {
+                if (sourceQuantity.BaseUnitInfo.BaseUnits == toBaseUnit.BaseUnits)
+                {
+                    return toUnitInfo.ConversionFromBase.Evaluate(conversionExpression(fromUnitInfo.ConvertValueToBaseUnit(value)));
+                }
+            }
         }
 
-        /// <summary>
-        ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
-        ///     This is particularly useful for creating things like a generated unit conversion UI,
-        ///     where you list some selectors:
-        ///     a) Quantity: Length, Mass, Force etc.
-        ///     b) From unit: Meter, Centimeter etc if Length is selected
-        ///     c) To unit: Meter, Centimeter etc if Length is selected
-        /// </summary>
-        /// <param name="fromValue">
-        ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
-        ///     convert from.
-        /// </param>
-        /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
-        /// <param name="fromUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
-        /// <param name="toUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
-        /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
-        /// <returns>Output value as the result of converting to <paramref name="toUnitAbbrev" />.</returns>
-        /// <exception cref="QuantityNotFoundException">
-        ///     Thrown when no quantity information is found for the specified quantity name.
-        /// </exception>
-        /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
-        /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
-        public static double ConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev)
-        {
-            return ConvertByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, (IFormatProvider?)null);
-        }
-
-        /// <summary>
-        ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
-        ///     This is particularly useful for creating things like a generated unit conversion UI,
-        ///     where you list some selectors:
-        ///     a) Quantity: Length, Mass, Force etc.
-        ///     b) From unit: Meter, Centimeter etc if Length is selected
-        ///     c) To unit: Meter, Centimeter etc if Length is selected
-        /// </summary>
-        /// <param name="fromValue">
-        ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
-        ///     convert from.
-        /// </param>
-        /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
-        /// <param name="fromUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
-        /// <param name="toUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
-        /// <param name="culture">Culture to parse abbreviations with.</param>
-        /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
-        /// <returns>Output value as the result of converting to <paramref name="toUnitAbbrev" />.</returns>
-        /// <exception cref="QuantityNotFoundException">
-        ///     Thrown when no quantity information is found for the specified quantity name.
-        /// </exception>
-        /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
-        /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
-        [Obsolete("Methods accepting a culture name are deprecated in favor of using an instance of the IFormatProvider.")]
-        public static double ConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, string? culture)
-        {
-            return ConvertByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, CultureHelper.GetCultureOrInvariant(culture));
-        }
-
-        /// <summary>
-        ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
-        ///     This is particularly useful for creating things like a generated unit conversion UI,
-        ///     where you list some selectors:
-        ///     a) Quantity: Length, Mass, Force etc.
-        ///     b) From unit: Meter, Centimeter etc if Length is selected
-        ///     c) To unit: Meter, Centimeter etc if Length is selected
-        /// </summary>
-        /// <param name="fromValue">
-        ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
-        ///     convert from.
-        /// </param>
-        /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
-        /// <param name="fromUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
-        /// <param name="toUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
-        /// <param name="formatProvider">
-        ///     The format provider to use for lookup. Defaults to <see cref="System.Globalization.CultureInfo.CurrentCulture" />
-        ///     if null.
-        /// </param>
-        /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
-        /// <returns>Output value as the result of converting to <paramref name="toUnitAbbrev" />.</returns>
-        /// <exception cref="QuantityNotFoundException">
-        ///     Thrown when no quantity information is found for the specified quantity name.
-        /// </exception>
-        /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
-        /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
-        public static double ConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, IFormatProvider? formatProvider)
-        {
-            QuantityInfoLookup quantities = UnitsNetSetup.Default.Quantities;
-            UnitParser unitParser = UnitsNetSetup.Default.UnitParser;
-            QuantityInfo quantityInfo = quantities.GetQuantityByName(quantityName);
-            Enum fromUnit = unitParser.Parse(fromUnitAbbrev, quantityInfo.UnitType, formatProvider); // ex: ("m", LengthUnit) => LengthUnit.Meter
-            Enum toUnit = unitParser.Parse(toUnitAbbrev, quantityInfo.UnitType, formatProvider); // ex:("cm", LengthUnit) => LengthUnit.Centimeter
-            return Quantity.From(fromValue, fromUnit).As(toUnit);
-        }
-
-        /// <summary>
-        ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
-        ///     This is particularly useful for creating things like a generated unit conversion UI,
-        ///     where you list some selectors:
-        ///     a) Quantity: Length, Mass, Force etc.
-        ///     b) From unit: Meter, Centimeter etc if Length is selected
-        ///     c) To unit: Meter, Centimeter etc if Length is selected
-        /// </summary>
-        /// <param name="fromValue">
-        ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
-        ///     convert from.
-        /// </param>
-        /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
-        /// <param name="fromUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
-        /// <param name="toUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
-        /// <param name="result">Result if conversion was successful, 0 if not.</param>
-        /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
-        /// <returns>True if conversion was successful.</returns>
-        public static bool TryConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, out double result)
-        {
-            return TryConvertByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, out result, (IFormatProvider?)null);
-        }
-
-        /// <summary>
-        ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
-        ///     This is particularly useful for creating things like a generated unit conversion UI,
-        ///     where you list some selectors:
-        ///     a) Quantity: Length, Mass, Force etc.
-        ///     b) From unit: Meter, Centimeter etc if Length is selected
-        ///     c) To unit: Meter, Centimeter etc if Length is selected
-        /// </summary>
-        /// <param name="fromValue">
-        ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
-        ///     convert from.
-        /// </param>
-        /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
-        /// <param name="fromUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
-        /// <param name="toUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
-        /// <param name="culture">Culture to parse abbreviations with.</param>
-        /// <param name="result">Result if conversion was successful, 0 if not.</param>
-        /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
-        /// <returns>True if conversion was successful.</returns>
-        [Obsolete("Methods accepting a culture name are deprecated in favor of using an instance of the IFormatProvider.")]
-        public static bool TryConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, out double result,
-            string? culture)
-        {
-            return TryConvertByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, out result, CultureHelper.GetCultureOrInvariant(culture));
-        }
-
-        /// <summary>
-        ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
-        ///     This is particularly useful for creating things like a generated unit conversion UI,
-        ///     where you list some selectors:
-        ///     a) Quantity: Length, Mass, Force etc.
-        ///     b) From unit: Meter, Centimeter etc if Length is selected
-        ///     c) To unit: Meter, Centimeter etc if Length is selected
-        /// </summary>
-        /// <param name="fromValue">
-        ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
-        ///     convert from.
-        /// </param>
-        /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
-        /// <param name="fromUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
-        /// <param name="toUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
-        /// <param name="formatProvider">
-        ///     The format provider to use for lookup. Defaults to <see cref="System.Globalization.CultureInfo.CurrentCulture" />
-        ///     if null.
-        /// </param>
-        /// <param name="result">Result if conversion was successful, 0 if not.</param>
-        /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
-        /// <returns>True if conversion was successful.</returns>
-        public static bool TryConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, out double result,
-            IFormatProvider? formatProvider)
-        {
-            QuantityInfoLookup quantities = UnitsNetSetup.Default.Quantities;
-            UnitParser unitParser = UnitsNetSetup.Default.UnitParser;
-            if (!quantities.TryGetQuantityByName(quantityName, out QuantityInfo? quantityInfo) )
+        IReadOnlyList<UnitInfo> sourceQuantityUnits = sourceQuantity.UnitInfos;
+        var nbSourceUnits = sourceQuantityUnits.Count;
+        for (var i = 0; i < nbSourceUnits; i++)
+        {
+            UnitInfo sourceUnit = sourceQuantityUnits[i];
+            if (sourceUnit.BaseUnits == BaseUnits.Undefined || sourceUnit.BaseUnits == fromUnitInfo.BaseUnits)
             {
-                result = 0;
-                return false;
+                continue;
             }
 
-            if (!unitParser.TryParse(fromUnitAbbrev, quantityInfo.UnitType, formatProvider, out Enum? fromUnit) ||
-                !unitParser.TryParse(toUnitAbbrev, quantityInfo.UnitType, formatProvider, out Enum? toUnit))
+            if (targetQuantity.UnitInfos.TryGetUnitWithBase(sourceUnit.BaseUnits, out UnitInfo? matchingUnit))
             {
-                result = 0;
-                return false;
+                return ConvertValueInternal(conversionExpression(ConvertValueInternal(value, fromUnitInfo, sourceUnit)), matchingUnit, toUnitInfo);
             }
+        }
+        
+        throw InvalidConversionException.CreateIncompatibleUnitsException(fromUnitInfo, targetQuantity);
+    }
+
+    /// <summary>
+    ///     Converts a quantity value from one unit to another specified unit type.
+    /// </summary>
+    /// <typeparam name="TSourceUnit">The type of the source unit.</typeparam>
+    /// <typeparam name="TTargetQuantity">The type of the target quantity.</typeparam>
+    /// <typeparam name="TTargetUnit">The type of the target unit.</typeparam>
+    /// <param name="value">The quantity value to convert.</param>
+    /// <param name="fromUnit">The source unit of the quantity value.</param>
+    /// <param name="targetQuantityInfo">The target quantity information which includes the target unit.</param>
+    /// <returns>The converted quantity in the target unit type.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="targetQuantityInfo" /> is null.</exception>
+    /// <exception cref="UnitNotFoundException">Thrown when the source unit is not found.</exception>
+    /// <exception cref="InvalidConversionException">Thrown when the conversion cannot be performed.</exception>
+    public virtual TTargetQuantity ConvertTo<TSourceUnit, TTargetQuantity, TTargetUnit>(QuantityValue value, TSourceUnit fromUnit,
+        QuantityInfo<TTargetQuantity, TTargetUnit> targetQuantityInfo)
+        where TSourceUnit : struct, Enum
+        where TTargetQuantity : IQuantity<TTargetQuantity, TTargetUnit>
+        where TTargetUnit : struct, Enum
+    {
+        UnitInfo fromUnitInfo = GetUnitInfo(UnitKey.ForUnit(fromUnit));
+        QuantityInfo sourceQuantityInfo = fromUnitInfo.QuantityInfo;
+        if (!ConversionDefined(sourceQuantityInfo, targetQuantityInfo))
+        {
+            throw InvalidConversionException.CreateImplicitConversionException(sourceQuantityInfo, targetQuantityInfo);
+        }
+        
+        return targetQuantityInfo.ConvertFrom(value, fromUnitInfo);
+    }
+
+    /// <inheritdoc cref="ConvertTo{TSourceUnit,TTargetQuantity,TTargetUnit}" />
+    public virtual IQuantity ConvertTo(QuantityValue value, UnitKey fromUnitKey, QuantityInfo targetQuantityInfo)
+    {
+        UnitInfo fromUnitInfo = GetUnitInfo(fromUnitKey);
+        QuantityInfo sourceQuantityInfo = fromUnitInfo.QuantityInfo;
+        if (!ConversionDefined(sourceQuantityInfo, targetQuantityInfo))
+        {
+            throw InvalidConversionException.CreateImplicitConversionException(sourceQuantityInfo, targetQuantityInfo);
+        }
+        
+        return targetQuantityInfo.ConvertFrom(value, fromUnitInfo);
+    }
+
+    /// <summary>
+    ///     Gets a conversion function that converts a value from one unit to another.
+    /// </summary>
+    /// <param name="fromUnitKey">The key representing the unit to convert from.</param>
+    /// <param name="toUnitKey">The key representing the unit to convert to.</param>
+    /// <returns>
+    ///     A delegate that converts a <see cref="QuantityValue" /> from the specified <paramref name="fromUnitKey" /> to
+    ///     the specified <paramref name="toUnitKey" />.
+    /// </returns>
+    /// <exception cref="UnitNotFoundException">
+    ///     Thrown if the specified <paramref name="fromUnitKey" /> or <paramref name="toUnitKey" /> does not exist.
+    /// </exception>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown if the quantities are different and no conversion function exists between them.
+    /// </exception>
+    /// <remarks>
+    ///     If the <paramref name="fromUnitKey" /> and <paramref name="toUnitKey" /> are the same, the returned function will
+    ///     be an identity function.
+    /// </remarks>
+    public virtual ConvertValueDelegate GetConversionFunction(UnitKey fromUnitKey, UnitKey toUnitKey)
+    {
+        if (fromUnitKey == toUnitKey)
+        {
+            return value => value;
+        }
+
+        UnitInfo fromUnitInfo = GetUnitInfo(fromUnitKey);
+        UnitInfo toUnitInfo = GetUnitInfo(toUnitKey);
+        return fromUnitKey.UnitEnumType == toUnitKey.UnitEnumType
+            ? fromUnitInfo.GetUnitConversionExpressionTo(toUnitInfo)
+            : GetConversionFromOneQuantityToAnother(fromUnitInfo, toUnitInfo);
+    }
+
+    /// <summary>
+    ///     Retrieves the conversion expression required to convert a value from one unit of quantity to another.
+    /// </summary>
+    /// <param name="fromUnitInfo">The unit information of the source quantity.</param>
+    /// <param name="toUnitInfo">The unit information of the target quantity.</param>
+    /// <param name="reduceConstants">
+    ///     A boolean value indicating whether to reduce constants in the conversion expression.
+    ///     Default is true.
+    /// </param>
+    /// <returns>A <see cref="ConversionExpression" /> representing the conversion from the source unit to the target unit.</returns>
+    /// <exception cref="InvalidConversionException">
+    ///     Thrown when no implicit conversion exists between the specified source and target quantities.
+    /// </exception>
+    protected ConversionExpression GetConversionFromOneQuantityToAnother(UnitInfo fromUnitInfo, UnitInfo toUnitInfo, bool reduceConstants = true)
+    {
+        QuantityInfo sourceQuantity = fromUnitInfo.QuantityInfo;
+        QuantityInfo targetQuantity = toUnitInfo.QuantityInfo;
+        if (!ConversionDefined(sourceQuantity, targetQuantity))
+        {
+            throw InvalidConversionException.CreateImplicitConversionException(sourceQuantity, targetQuantity);
+        }
+
+        return fromUnitInfo.GetQuantityConversionExpressionTo(toUnitInfo);
+    }
 
-            result = Quantity.From(fromValue, fromUnit).As(toUnit);
+    /// <summary>
+    ///     Attempts to get a conversion function that converts a value from one unit to another.
+    /// </summary>
+    /// <param name="fromUnitKey">The key representing the unit to convert from.</param>
+    /// <param name="toUnitKey">The key representing the unit to convert to.</param>
+    /// <param name="conversionFunction">
+    ///     When this method returns, contains the conversion function if the conversion is possible; otherwise, <c>null</c>.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if the conversion function was successfully retrieved; otherwise, <c>false</c>.
+    /// </returns>
+    /// <remarks>
+    ///     If the <paramref name="fromUnitKey" /> and <paramref name="toUnitKey" /> are the same, the returned function will
+    ///     be an identity function.
+    /// </remarks>
+    public virtual bool TryGetConversionFunction(UnitKey fromUnitKey, UnitKey toUnitKey, [NotNullWhen(true)] out ConvertValueDelegate? conversionFunction)
+    {
+        if (fromUnitKey == toUnitKey)
+        {
+            conversionFunction = value => value;
             return true;
+        }
 
+        if (!TryGetUnitInfo(fromUnitKey, out UnitInfo? fromUnitInfo) || !TryGetUnitInfo(toUnitKey, out UnitInfo? toUnitInfo))
+        {
+            conversionFunction = null;
+            return false;
+        }
+
+        if (fromUnitKey.UnitEnumType != toUnitKey.UnitEnumType)
+        {
+            return TryGetConversionFromOneQuantityToAnother(fromUnitInfo, toUnitInfo, out conversionFunction);
         }
+
+        conversionFunction = fromUnitInfo.GetUnitConversionExpressionTo(toUnitInfo);
+        return true;
     }
-}
 
+    /// <summary>
+    ///     Attempts to retrieve a conversion function that converts a value from one unit to another unit of a different
+    ///     quantity.
+    /// </summary>
+    /// <param name="fromUnitInfo">The unit information of the source unit.</param>
+    /// <param name="toUnitInfo">The unit information of the target unit.</param>
+    /// <param name="conversionFunction">
+    ///     When this method returns, contains the conversion function if the conversion is defined; otherwise, <c>null</c>.
+    /// </param>
+    /// <returns>
+    ///     <c>true</c> if a conversion function is successfully retrieved; otherwise, <c>false</c>.
+    /// </returns>
+    protected bool TryGetConversionFromOneQuantityToAnother(UnitInfo fromUnitInfo, UnitInfo toUnitInfo, out ConvertValueDelegate? conversionFunction)
+    {
+        if (ConversionDefined(fromUnitInfo.QuantityInfo, toUnitInfo.QuantityInfo) &&
+            fromUnitInfo.TryGetQuantityConversionExpressionTo(toUnitInfo, true, out ConversionExpression? conversionExpression))
+        {
+            conversionFunction = conversionExpression;
+            return true;
+        }
+
+        conversionFunction = null;
+        return false;
+    }
+
+    /// <summary>
+    ///     Convert between any two quantity units by their names, such as converting a "Length" of N "Meter" to "Centimeter".
+    ///     This is particularly useful for creating things like a generated unit conversion UI,
+    ///     where you list some selectors:
+    ///     a) Quantity: Length, Mass, Force etc.
+    ///     b) From unit: Meter, Centimeter etc if Length is selected
+    ///     c) To unit: Meter, Centimeter etc if Length is selected
+    /// </summary>
+    /// <param name="fromValue">
+    ///     Input value, which together with <paramref name="fromUnitName" /> represents the quantity to
+    ///     convert from.
+    /// </param>
+    /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
+    /// <param name="fromUnitName">The invariant unit enum name, such as "Meter". Does not support localization.</param>
+    /// <param name="toUnitName">The invariant unit enum name, such as "Meter". Does not support localization.</param>
+    /// <example>double centimeters = ConvertByName(5, "Length", "Meter", "Centimeter"); // 500</example>
+    /// <returns>Output value as the result of converting to <paramref name="toUnitName" />.</returns>
+    /// <exception cref="QuantityNotFoundException">
+    ///     Thrown when no quantity information is found for the specified quantity name.
+    /// </exception>
+    /// <exception cref="UnitNotFoundException">No units match the provided unit name.</exception>
+    /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
+    public QuantityValue ConvertValueByName(QuantityValue fromValue, string quantityName, string fromUnitName, string toUnitName)
+    {
+        UnitInfo fromUnitInfo = Quantities.GetUnitByName(quantityName, fromUnitName);
+        UnitInfo toUnitInfo = Quantities.GetUnitByName(quantityName, toUnitName);
+        return ConvertValueInternal(fromValue, fromUnitInfo, toUnitInfo);
+    }
+
+    /// <summary>
+    ///     Convert between any two quantity units by their names, such as converting a "Length" of N "Meter" to "Centimeter".
+    ///     This is particularly useful for creating things like a generated unit conversion UI,
+    ///     where you list some selectors:
+    ///     a) Quantity: Length, Mass, Force etc.
+    ///     b) From unit: Meter, Centimeter etc if Length is selected
+    ///     c) To unit: Meter, Centimeter etc if Length is selected
+    /// </summary>
+    /// <param name="inputValue">
+    ///     Input value, which together with <paramref name="fromUnitName" /> represents the quantity to
+    ///     convert from.
+    /// </param>
+    /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
+    /// <param name="fromUnitName">The invariant unit enum name, such as "Meter". Does not support localization.</param>
+    /// <param name="toUnitName">The invariant unit enum name, such as "Meter". Does not support localization.</param>
+    /// <param name="result">Result if conversion was successful, 0 if not.</param>
+    /// <example>bool ok = TryConvertByName(5, "Length", "Meter", "Centimeter", out double centimeters); // 500</example>
+    /// <returns>True if conversion was successful.</returns>
+    public bool TryConvertValueByName(QuantityValue inputValue, string quantityName, string fromUnitName, string toUnitName, out QuantityValue result)
+    {
+        if (Quantities.TryGetUnitByName(quantityName, fromUnitName, out UnitInfo? fromUnitInfo) &&
+            Quantities.TryGetUnitByName(quantityName, toUnitName, out UnitInfo? toUnitInfo))
+        {
+            return TryConvertValueInternal(inputValue, fromUnitInfo, toUnitInfo, out result);
+        }
+
+        result = default;
+        return false;
+    }
+    
+    /// <summary>
+    ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
+    ///     This is particularly useful for creating things like a generated unit conversion UI,
+    ///     where you list some selectors:
+    ///     a) Quantity: Length, Mass, Force etc.
+    ///     b) From unit: Meter, Centimeter etc if Length is selected
+    ///     c) To unit: Meter, Centimeter etc if Length is selected
+    /// </summary>
+    /// <param name="fromValue">
+    ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
+    ///     convert from.
+    /// </param>
+    /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
+    /// <param name="fromUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
+    /// <param name="toUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
+    /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
+    /// <returns>Output value as the result of converting to <paramref name="toUnitAbbrev" />.</returns>
+    /// <exception cref="QuantityNotFoundException">
+    ///     Thrown when no quantity information is found for the specified quantity name.
+    /// </exception>
+    /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
+    /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
+    public QuantityValue ConvertValueByAbbreviation(QuantityValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev)
+    {
+        return ConvertValueByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, null);
+    }
+
+    /// <summary>
+    ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
+    ///     This is particularly useful for creating things like a generated unit conversion UI,
+    ///     where you list some selectors:
+    ///     a) Quantity: Length, Mass, Force etc.
+    ///     b) From unit: Meter, Centimeter etc if Length is selected
+    ///     c) To unit: Meter, Centimeter etc if Length is selected
+    /// </summary>
+    /// <param name="fromValue">
+    ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
+    ///     convert from.
+    /// </param>
+    /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
+    /// <param name="fromUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
+    /// <param name="toUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
+    /// <param name="culture">The unit localization culture. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
+    /// <returns>Output value as the result of converting to <paramref name="toUnitAbbrev" />.</returns>
+    /// <exception cref="QuantityNotFoundException">
+    ///     Thrown when no quantity information is found for the specified quantity name.
+    /// </exception>
+    /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
+    /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
+    public QuantityValue ConvertValueByAbbreviation(QuantityValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, CultureInfo? culture)
+    {
+        QuantityInfo quantityInfo = Quantities.GetQuantityByName(quantityName);
+        UnitInfo fromUnitInfo = UnitParser.Parse(fromUnitAbbrev, quantityInfo.UnitInfos, culture); // ex: ("m", LengthUnit) => LengthUnit.Meter
+        UnitInfo toUnitInfo = UnitParser.Parse(toUnitAbbrev, quantityInfo.UnitInfos, culture); // ex:("cm", LengthUnit) => LengthUnit.Centimeter
+        return ConvertValueInternal(fromValue, fromUnitInfo, toUnitInfo);
+    }
+
+    /// <summary>
+    ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
+    ///     This is particularly useful for creating things like a generated unit conversion UI,
+    ///     where you list some selectors:
+    ///     a) Quantity: Length, Mass, Force etc.
+    ///     b) From unit: Meter, Centimeter etc if Length is selected
+    ///     c) To unit: Meter, Centimeter etc if Length is selected
+    /// </summary>
+    /// <param name="fromValue">
+    ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
+    ///     convert from.
+    /// </param>
+    /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
+    /// <param name="fromUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
+    /// <param name="toUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
+    /// <param name="result">Result if conversion was successful, 0 if not.</param>
+    /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
+    /// <returns>True if conversion was successful.</returns>
+    public bool TryConvertValueByAbbreviation(QuantityValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, out QuantityValue result)
+    {
+        return TryConvertValueByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, null, out result);
+    }
+
+    /// <summary>
+    ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
+    ///     This is particularly useful for creating things like a generated unit conversion UI,
+    ///     where you list some selectors:
+    ///     a) Quantity: Length, Mass, Force etc.
+    ///     b) From unit: Meter, Centimeter etc if Length is selected
+    ///     c) To unit: Meter, Centimeter etc if Length is selected
+    /// </summary>
+    /// <param name="fromValue">
+    ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
+    ///     convert from.
+    /// </param>
+    /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
+    /// <param name="fromUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
+    /// <param name="toUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
+    /// <param name="culture">The unit localization culture. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
+    /// <param name="result">Result if conversion was successful, 0 if not.</param>
+    /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
+    /// <returns>True if conversion was successful.</returns>
+    public bool TryConvertValueByAbbreviation(QuantityValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, CultureInfo? culture,
+        out QuantityValue result)  
+    {
+        if (!Quantities.TryGetQuantityByName(quantityName, out QuantityInfo? quantityInfo))
+        {
+            result = default;
+            return false;
+        }
+
+        if (UnitParser.TryParse(fromUnitAbbrev, quantityInfo.UnitInfos, culture, out UnitInfo? fromUnitInfo) &&
+            UnitParser.TryParse(toUnitAbbrev, quantityInfo.UnitInfos, culture, out UnitInfo? toUnitInfo))
+        {
+            result = ConvertValueInternal(fromValue, fromUnitInfo, toUnitInfo);
+            return true;
+        }
+
+        result = default;
+        return false;
+    }
+
+    #region Static methods
+    
+    /// <inheritdoc cref="ConvertValue"/>
+    public static QuantityValue Convert(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey)
+    {
+        return Default.ConvertValue(value, fromUnitKey, toUnitKey);
+    }
+
+    /// <inheritdoc cref="TryConvertValue"/>
+    public static bool TryConvert(QuantityValue value, UnitKey fromUnitKey, UnitKey toUnitKey, out QuantityValue result)
+    {
+        return Default.TryConvertValue(value, fromUnitKey, toUnitKey, out result);
+    }
+
+    /// <inheritdoc cref="ConvertValueByName"/>
+    public static QuantityValue ConvertByName(QuantityValue inputValue, string quantityName, string fromUnitName, string toUnitName)
+    {
+        return Default.ConvertValueByName(inputValue, quantityName, fromUnitName, toUnitName);
+    }
+
+    /// <inheritdoc cref="TryConvertByName"/>
+    public static bool TryConvertByName(QuantityValue inputValue, string quantityName, string fromUnitName, string toUnitName, out QuantityValue result)
+    {
+        return Default.TryConvertValueByName(inputValue, quantityName, fromUnitName, toUnitName, out result);
+    }
+
+    /// <inheritdoc cref="ConvertValueByAbbreviation(UnitsNet.QuantityValue,string,string,string)"/>
+    public static QuantityValue ConvertByAbbreviation(QuantityValue inputValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev)
+    {
+        return Default.ConvertValueByAbbreviation(inputValue, quantityName, fromUnitAbbrev, toUnitAbbrev);
+    }
+
+    /// <inheritdoc cref="TryConvertValueByAbbreviation(UnitsNet.QuantityValue,string,string,string,out UnitsNet.QuantityValue)"/>
+    public static bool TryConvertByAbbreviation(QuantityValue inputValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, out QuantityValue result)
+    {
+        return Default.TryConvertValueByAbbreviation(inputValue, quantityName, fromUnitAbbrev, toUnitAbbrev, out result);
+    }
+
+    /// <inheritdoc cref="ConvertValueByAbbreviation(UnitsNet.QuantityValue,string,string,string,CultureInfo?)"/>
+    public static QuantityValue ConvertByAbbreviation(QuantityValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, CultureInfo? culture)
+    {
+        return Default.ConvertValueByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, culture);
+    }
+
+    /// <inheritdoc cref="TryConvertValueByAbbreviation(UnitsNet.QuantityValue,string,string,string,CultureInfo?,out UnitsNet.QuantityValue)"/>
+    public static bool TryConvertByAbbreviation(QuantityValue inputValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, CultureInfo? culture, out QuantityValue result) 
+    {
+        return Default.TryConvertValueByAbbreviation(inputValue, quantityName, fromUnitAbbrev, toUnitAbbrev, culture, out result);
+    }
+
+    /// <summary>
+    ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
+    ///     This is particularly useful for creating things like a generated unit conversion UI,
+    ///     where you list some selectors:
+    ///     a) Quantity: Length, Mass, Force etc.
+    ///     b) From unit: Meter, Centimeter etc if Length is selected
+    ///     c) To unit: Meter, Centimeter etc if Length is selected
+    /// </summary>
+    /// <param name="fromValue">
+    ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
+    ///     convert from.
+    /// </param>
+    /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
+    /// <param name="fromUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
+    /// <param name="toUnitAbbrev">The abbreviation of the unit in the given culture, such as "m".</param>
+    /// <param name="culture">Culture to parse abbreviations with.</param>
+    /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
+    /// <returns>Output value as the result of converting to <paramref name="toUnitAbbrev" />.</returns>
+    /// <exception cref="QuantityNotFoundException">
+    ///     Thrown when no quantity information is found for the specified quantity name.
+    /// </exception>
+    /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
+    /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
+    [Obsolete("Methods accepting a culture name are deprecated in favor of using an instance of CultureInfo.")]
+    public static QuantityValue ConvertByAbbreviation(QuantityValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, string? culture)
+    {
+        return Default.ConvertValueByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, CultureHelper.GetCultureOrInvariant(culture));
+    }
+    
+    /// <summary>
+    ///     Convert between any two quantity units by their abbreviations, such as converting a "Length" of N "m" to "cm".
+    ///     This is particularly useful for creating things like a generated unit conversion UI,
+    ///     where you list some selectors:
+    ///     a) Quantity: Length, Mass, Force etc.
+    ///     b) From unit: Meter, Centimeter etc if Length is selected
+    ///     c) To unit: Meter, Centimeter etc if Length is selected
+    /// </summary>
+    /// <param name="inputValue">
+    ///     Input value, which together with <paramref name="fromUnitAbbrev" /> represents the quantity to
+    ///     convert from.
+    /// </param>
+    /// <param name="quantityName">The invariant quantity name, such as "Length". Does not support localization.</param>
+    /// <param name="fromUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
+    /// <param name="toUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
+    /// <param name="culture">Culture to parse abbreviations with.</param>
+    /// <param name="result">Result if conversion was successful, 0 if not.</param>
+    /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
+    /// <returns>True if conversion was successful.</returns>
+    [Obsolete("Methods accepting a culture name are deprecated in favor of using an instance of CultureInfo.")]
+    public static bool TryConvertByAbbreviation(QuantityValue inputValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, out QuantityValue result, string? culture) 
+    {
+        return Default.TryConvertValueByAbbreviation(inputValue, quantityName, fromUnitAbbrev, toUnitAbbrev, CultureHelper.GetCultureOrInvariant(culture), out result);
+    }
+
+    #endregion
+}
diff --git a/UnitsNet/UnitFormatter.cs b/UnitsNet/UnitFormatter.cs
deleted file mode 100644
index 0a2b827951..0000000000
--- a/UnitsNet/UnitFormatter.cs
+++ /dev/null
@@ -1,77 +0,0 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
-// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace UnitsNet
-{
-    /// <summary>
-    ///     Utility class for formatting units and values.
-    /// </summary>
-    internal static class UnitFormatter
-    {
-        /// <summary>
-        ///     Gets the default ToString format for the specified value.
-        /// </summary>
-        /// <param name="value">The value to format.</param>
-        /// <param name="significantDigitsAfterRadix">
-        ///     The number of digits after the radix point to display in the formatted
-        ///     string.
-        /// </param>
-        /// <returns>A ToString format for the specified value.</returns>
-        public static string GetFormat(double value, int significantDigitsAfterRadix)
-        {
-            double v = Math.Abs(value);
-            var sigDigitsAfterRadixStr = new string('#', significantDigitsAfterRadix);
-            string format;
-
-            if (NearlyEqual(v, 0))
-            {
-                format = "{0} {1}";
-            }
-            // Values below 1e-3 are displayed in scientific notation.
-            else if (v < 1e-3)
-            {
-                format = "{0:0." + sigDigitsAfterRadixStr + "e-00} {1}";
-            }
-            // Values from 1e-3 to 1 use fixed point notation.
-            else if ((v > 1e-4) && (v < 1))
-            {
-                format = "{0:g" + significantDigitsAfterRadix + "} {1}";
-            }
-            // Values between 1 and 1e5 use fixed point notation with digit grouping.
-            else if ((v >= 1) && (v < 1e6))
-            {
-                // The comma will be automatically replaced with the correct digit separator if a different culture is used.
-                format = "{0:#,0." + sigDigitsAfterRadixStr + "} {1}";
-            }
-            // Values above 1e5 use scientific notation.
-            else
-            {
-                format = "{0:0." + sigDigitsAfterRadixStr + "e+00} {1}";
-            }
-
-            return format;
-        }
-
-        private static bool NearlyEqual(double a, double b)
-        {
-            return Math.Abs(a - b) < 1e-150;
-        }
-
-        /// <summary>
-        ///     Gets ToString format arguments.
-        /// </summary>
-        /// <param name="abbreviation">The unit abbreviation</param>
-        /// <param name="value">The unit value to format.</param>
-        /// <param name="culture">The current culture.</param>
-        /// <param name="args">The list of format arguments.</param>
-        /// <returns>An array of ToString format arguments.</returns>
-        public static object[] GetFormatArgs(double value, string abbreviation, IFormatProvider? culture, IEnumerable<object> args)
-        {
-            return new object[] {value, abbreviation}.Concat(args).ToArray();
-        }
-    }
-}
diff --git a/UnitsNet/UnitInfo.cs b/UnitsNet/UnitInfo.cs
index 68da6c5055..131487f606 100644
--- a/UnitsNet/UnitInfo.cs
+++ b/UnitsNet/UnitInfo.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.Linq;
@@ -34,6 +34,8 @@ protected internal UnitInfo(IUnitDefinition mapping)
         Name = mapping.Name;
         PluralName = mapping.PluralName;
         BaseUnits = mapping.BaseUnits;
+        ConversionFromBase = mapping.ConversionFromBase;
+        ConversionToBase = mapping.ConversionToBase;
     }
 
     /// <inheritdoc />
@@ -111,6 +113,12 @@ internal static TUnitInfo GetUnitWithBase<TUnitInfo>(IEnumerable<TUnitInfo> unit
     /// <inheritdoc />
     public BaseUnits BaseUnits { get; }
 
+    /// <inheritdoc />
+    public ConversionExpression ConversionFromBase { get; }
+
+    /// <inheritdoc />
+    public ConversionExpression ConversionToBase { get; }
+
     #endregion
 
     #region Implementation of IUnitInfo
@@ -171,13 +179,13 @@ public string QuantityName
     /// <remarks>
     ///     This method utilizes the <see cref="QuantityInfo" /> associated with this unit to create the quantity.
     /// </remarks>
-    public IQuantity From(double value)
+    public IQuantity From(QuantityValue value)
     {
         return CreateGenericQuantity(value);
     }
 
     /// <inheritdoc cref="From" />
-    protected internal abstract IQuantity CreateGenericQuantity(double value);
+    protected internal abstract IQuantity CreateGenericQuantity(QuantityValue value);
 
     #endregion
 }
@@ -244,16 +252,16 @@ public override UnitKey UnitKey
     }
 
     /// <summary>
-    ///     Converts a given <see cref="double" /> to an instance of the quantity type associated with this unit.
+    ///     Converts a given <see cref="QuantityValue" /> to an instance of the quantity type associated with this unit.
     /// </summary>
     /// <param name="value">The value to convert.</param>
     /// <returns>An instance of the quantity type associated with this unit.</returns>
-    public new abstract TQuantity From(double value);
+    public new abstract TQuantity From(QuantityValue value);
 
     #region Overrides of UnitInfo
 
     /// <inheritdoc />
-    protected internal sealed override IQuantity CreateGenericQuantity(double value)
+    protected internal sealed override IQuantity CreateGenericQuantity(QuantityValue value)
     {
         return From(value);
     }
@@ -285,7 +293,7 @@ internal UnitInfo(QuantityInfo<TQuantity, TUnit> quantityInfo, IUnitDefinition<T
     }
 
     /// <inheritdoc cref="UnitInfoBase{TQuantityInfo,TQuantity,TUnit}.From" />
-    public override TQuantity From(double value)
+    public override TQuantity From(QuantityValue value)
     {
         return QuantityInfo.From(value, Value);
     }
diff --git a/UnitsNet/UnitMath.cs b/UnitsNet/UnitMath.cs
index a6fb77465b..095a55fc61 100644
--- a/UnitsNet/UnitMath.cs
+++ b/UnitsNet/UnitMath.cs
@@ -1,4 +1,4 @@
-namespace UnitsNet;
+namespace UnitsNet;
 
 /// <summary>
 ///     Extension methods for common math operations.
@@ -68,13 +68,8 @@ public static TQuantity Clamp<TQuantity>(TQuantity value, TQuantity min, TQuanti
         where TQuantity : IQuantityOfType<TQuantity>, IComparable<TQuantity>
     {
         UnitKey unitKey = value.UnitKey;
-#if NET
-        TQuantity minValue = TQuantity.Create(min.As(unitKey), unitKey);
-        TQuantity maxValue = TQuantity.Create(max.As(unitKey), unitKey);
-#else
-        TQuantity minValue = value.QuantityInfo.Create(min.As(unitKey), unitKey);
-        TQuantity maxValue = value.QuantityInfo.Create(max.As(unitKey), unitKey);
-#endif
+        TQuantity minValue = UnitConverter.Default.ConvertToUnit(min, unitKey);
+        TQuantity maxValue = UnitConverter.Default.ConvertToUnit(max, unitKey);
 
         if (minValue.CompareTo(maxValue) > 0)
         {
diff --git a/UnitsNet/UnitSystem.cs b/UnitsNet/UnitSystem.cs
index 0f57cac20f..cce9cae319 100644
--- a/UnitsNet/UnitSystem.cs
+++ b/UnitsNet/UnitSystem.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
@@ -16,11 +16,11 @@ public sealed class UnitSystem : IEquatable<UnitSystem>
         /// <summary>
         /// Creates an instance of a unit system with the specified base units.
         /// </summary>
-        /// <param name="baseUnits">The base units for the unit system.</param>
+        /// <param name="baseUnits">One or more base units that define the unit system.</param>
         public UnitSystem(BaseUnits baseUnits)
         {
             if (baseUnits is null) throw new ArgumentNullException(nameof(baseUnits));
-            if (!baseUnits.IsFullyDefined) throw new ArgumentException("A unit system must have all base units defined.", nameof(baseUnits));
+            if (baseUnits == BaseUnits.Undefined) throw new ArgumentException("A unit system must define at least one base unit.", nameof(baseUnits));
 
             BaseUnits = baseUnits;
         }
diff --git a/UnitsNet/UnitsNet.csproj b/UnitsNet/UnitsNet.csproj
index fd9cc04d92..00bfb47f1e 100644
--- a/UnitsNet/UnitsNet.csproj
+++ b/UnitsNet/UnitsNet.csproj
@@ -2,10 +2,10 @@
   <!-- NuGet properties -->
   <PropertyGroup>
     <PackageId>UnitsNet</PackageId>
-    <Version>6.0.0-pre019</Version>
+    <Version>6.0.0-pre021</Version>
     <Authors>Andreas Gullberg Larsen</Authors>
     <Title>Units.NET</Title>
-    <Description>Get all the common units of measurement and the conversions between them. It is light-weight and thoroughly tested.</Description>
+    <Description>Add strongly typed quantities and units to your code and get merrily on with your life. No more magic constants found online or guessing the unit of variables.</Description>
     <Copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</Copyright>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <RepositoryUrl>https://github.com/angularsen/UnitsNet</RepositoryUrl>
@@ -16,6 +16,7 @@
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable</PackageTags>
     <PackageReadmeFile>README.md</PackageReadmeFile>
+    <IsAotCompatible Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">true</IsAotCompatible>
   </PropertyGroup>
 
   <!-- Assembly and msbuild properties -->
@@ -64,6 +65,7 @@
   <ItemGroup>
     <Using Include="System" />
     <Using Include="System.Collections.Generic" />
+    <Using Include="System.Numerics" />
     <Using Include="System.Diagnostics" />
     <Using Include="System.Diagnostics.CodeAnalysis" />
     <Using Include="UnitsNet.Units" />
diff --git a/UnitsNet/UnitsNet.csproj.DotSettings b/UnitsNet/UnitsNet.csproj.DotSettings
index 99fb414ae9..6f17704b73 100644
--- a/UnitsNet/UnitsNet.csproj.DotSettings
+++ b/UnitsNet/UnitsNet.csproj.DotSettings
@@ -1,5 +1,15 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantities/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantityconverters/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantityconverters_005Cbuilder/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantityconverters_005Cbuilder_005Cimplicitconversions/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantityconverters_005Cbuilder_005Coperators/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantityconverters_005Cbuilder_005Cquantityconversions/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantityconverters_005Cbuilder_005Cunitconversions/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantityinfo/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantityinfo_005Cunits/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantityinfo_005Cbuilder/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cquantityinfo_005Cunits/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=customcode_005Cvalue/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=exceptions/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=extensions/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/azure-pipelines-pr.yml b/azure-pipelines-pr.yml
index e3c0ad742c..4f3f2c0aa9 100644
--- a/azure-pipelines-pr.yml
+++ b/azure-pipelines-pr.yml
@@ -1,108 +1,12 @@
-name: PR_$(Date:yyyy.MM.dd)$(Rev:.rrr)
-
-# PR pipeline
-# - Build all targets (netstandard2.0, .NET nanoFramework)
-# - Run tests and upload test coverage to codecov.io
-
+# PR validation for v6/master has moved to GitHub Actions.
+# maintenance/v5 retains its branch-specific Azure Pipeline definition for nanoFramework.
 trigger: none
-pr:
-  branches:
-    include:
-    - master
-    - release/*
-    - maintenance/*
-  paths:
-    exclude:
-    - '*.md'
-    - '*.png'
-    - '*.gitignore'
+pr: none
 
 pool:
-  vmImage: windows-latest
-
-variables:
-- group: common
-
-stages:
-- stage: Build
-  displayName: Build & test
-  jobs:
-  - job: Build
-    displayName: Build & test
-    steps:
-    - checkout: self
-      fetchDepth: 1
-      clean: false
-      lfs: true
-      submodules: false
-      fetchTags: false
-
-    - task: UseDotNet@2
-      displayName: 'Install .NET 8 SDK'
-      inputs:
-        packageType: 'sdk'
-        version: '8.x'
-
-    - task: UseDotNet@2
-      displayName: 'Install .NET 9 SDK'
-      inputs:
-        packageType: 'sdk'
-        version: '9.x'
-
-    - task: UseDotNet@2
-      displayName: 'Install .NET 10 SDK Preview (for C# 14)'
-      inputs:
-        packageType: 'sdk'
-        version: '10.x'
-        includePreviewVersions: true
-
-    - task: InstallNanoMSBuildComponents@1
-      displayName: Install .NET nanoFramework MSBuild components
-
-    - task: PowerShell@2
-      displayName: 'Build, test, pack'
-      inputs:
-        filePath: 'Build/build.ps1'
-        arguments: '-IncludeNanoFramework'
-        failOnStderr: true
-        showWarnings: true
-        pwsh: true
-        workingDirectory: '$(Build.SourcesDirectory)'
-
-    - task: PublishTestResults@2
-      condition: always()
-      inputs:
-        testResultsFormat: "VSTest"
-        testResultsFiles: "*.trx"
-        searchFolder: $(Build.SourcesDirectory)\Artifacts\TestResults
-        mergeTestResults: true
-
-    - task: PowerShell@2
-      displayName: Upload to codecov.io
-      env:
-        CODECOV_TOKEN: $(CODECOV_TOKEN)
-      inputs:
-        targetType: 'inline'
-        script: |
-          Write-Host -Foreground Green "Downloading codecov binaries..."
-
-          Invoke-WebRequest -Uri https://uploader.codecov.io/verification.gpg -OutFile codecov.asc
-          gpg.exe --import codecov.asc
-
-          Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe -Outfile codecov.exe
-          Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe.SHA256SUM -Outfile codecov.exe.SHA256SUM
-          Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe.SHA256SUM.sig -Outfile codecov.exe.SHA256SUM.sig
-
-          gpg.exe --verify codecov.exe.SHA256SUM.sig codecov.exe.SHA256SUM
-          If ($(Compare-Object -ReferenceObject  $(($(certUtil -hashfile codecov.exe SHA256)[1], "codecov.exe") -join "  ") -DifferenceObject $(Get-Content codecov.exe.SHA256SUM)).length -eq 0) { echo "SHASUM verified" } Else {exit 1}
-
-          Write-Host -Foreground Green "Uploading to codecov..."
-
-          .\codecov.exe --dir "Artifacts/Coverage" -t "$env:CODECOV_TOKEN" --build "$(Build.BuildNumber)"
-
-          Write-Host -Foreground Green "✅ Uploaded to codecov."
-        pwsh: true
+  vmImage: ubuntu-latest
 
-    - publish: $(Build.SourcesDirectory)/Artifacts
-      displayName: 'Publish Artifacts'
-      artifact: 'Artifacts'
\ No newline at end of file
+steps:
+- checkout: none
+- script: echo "Azure Pipelines is disabled for v6. Use the GitHub Actions PR workflow."
+  displayName: GitHub Actions migration notice
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 567befc561..65d2aecebb 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -1,148 +1,12 @@
+# CI for v6/master has moved to GitHub Actions.
+# maintenance/v5 retains its branch-specific Azure Pipeline definition for nanoFramework.
+trigger: none
 pr: none
-trigger:
-  branches:
-    include:
-      - master
-      - release/*
-      - maintenance/*
-  paths:
-    exclude:
-      - '**/*.png'
-      - '**/*.md'
 
 pool:
-  vmImage: windows-latest
+  vmImage: ubuntu-latest
 
-variables:
-- group: common
-
-stages:
-- stage: Build
-  displayName: Build & test
-  jobs:
-  - job: Build
-    displayName: Build & test
-    steps:
-    - checkout: self
-      fetchDepth: 1
-      clean: false
-      lfs: true
-      submodules: false
-      fetchTags: false
-
-    - task: UseDotNet@2
-      displayName: 'Install .NET 8 SDK'
-      inputs:
-        packageType: 'sdk'
-        version: '8.x'
-
-    - task: UseDotNet@2
-      displayName: 'Install .NET 9 SDK'
-      inputs:
-        packageType: 'sdk'
-        version: '9.x'
-
-    - task: UseDotNet@2
-      displayName: 'Install .NET 10 SDK Preview (for C# 14)'
-      inputs:
-        packageType: 'sdk'
-        version: '10.x'
-        includePreviewVersions: true
-
-    - task: InstallNanoMSBuildComponents@1
-      displayName: Install .NET nanoFramework MSBuild components
-
-    - task: PowerShell@2
-      displayName: 'Build, test, pack'
-      inputs:
-        filePath: 'Build/build.ps1'
-        arguments: '-IncludeNanoFramework'
-        failOnStderr: true
-        showWarnings: true
-        pwsh: true
-        workingDirectory: '$(Build.SourcesDirectory)'
-
-    - task: PowerShell@2
-      displayName: Upload to codecov.io
-      env:
-        CODECOV_TOKEN: $(CODECOV_TOKEN)
-      inputs:
-        targetType: 'inline'
-        script: |
-          Write-Host -Foreground Green "Downloading codecov binaries..."
-
-          Invoke-WebRequest -Uri https://uploader.codecov.io/verification.gpg -OutFile codecov.asc
-          gpg.exe --import codecov.asc
-
-          Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe -Outfile codecov.exe
-          Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe.SHA256SUM -Outfile codecov.exe.SHA256SUM
-          Invoke-WebRequest -Uri https://uploader.codecov.io/latest/windows/codecov.exe.SHA256SUM.sig -Outfile codecov.exe.SHA256SUM.sig
-
-          gpg.exe --verify codecov.exe.SHA256SUM.sig codecov.exe.SHA256SUM
-          If ($(Compare-Object -ReferenceObject  $(($(certUtil -hashfile codecov.exe SHA256)[1], "codecov.exe") -join "  ") -DifferenceObject $(Get-Content codecov.exe.SHA256SUM)).length -eq 0) { echo "SHASUM verified" } Else {exit 1}
-
-          Write-Host -Foreground Green "Uploading to codecov..."
-
-          .\codecov.exe --dir "Artifacts/Coverage" -t "$env:CODECOV_TOKEN" --build "$(Build.BuildNumber)"
-
-          Write-Host -Foreground Green "✅ Uploaded to codecov."
-        pwsh: true
-
-    - publish: $(Build.SourcesDirectory)/Artifacts
-      displayName: 'Publish Artifacts'
-      artifact: 'Artifacts'
-
-    - task: CopyFiles@2
-      displayName: Copy nugets to staging
-      inputs:
-        SourceFolder: '$(Build.SourcesDirectory)/Artifacts'
-        Contents: |
-          **/*.nupkg
-          **/*.snupkg
-        TargetFolder: '$(Build.ArtifactStagingDirectory)'
-        flattenFolders: true
-        preserveTimestamp: true
-        retryCount: '3'
-        ignoreMakeDirErrors: true
-
-    - task: PublishPipelineArtifact@1
-      displayName: Upload nugets to pipeline
-      inputs:
-        targetPath: '$(Build.ArtifactStagingDirectory)'
-        artifact: 'nugets'
-        publishLocation: 'pipeline'
-
-- stage: Publish
-  dependsOn: Build
-  jobs:
-  - deployment: Publish
-    displayName: Publish nugets
-    environment: 'Publish'
-    strategy:
-      runOnce:
-        deploy:
-          steps:
-          - task: DownloadPipelineArtifact@2
-            displayName: Download nugets from pipeline
-            inputs:
-              buildType: 'current'
-              artifactName: 'nugets'
-              targetPath: '$(Build.ArtifactStagingDirectory)'
-
-          - task: Bash@3
-            displayName: 'Push to nuget.org'
-            env:
-              NUGET_ORG_APIKEY: '$(NUGET_ORG_APIKEY)'
-            inputs:
-              targetType: 'inline'
-              script: 'dotnet nuget push "*.nupkg" --skip-duplicate --api-key $NUGET_ORG_APIKEY --source https://api.nuget.org/v3/index.json'
-              workingDirectory: '$(Build.ArtifactStagingDirectory)'
-
-          - task: NuGetCommand@2
-            displayName: Push to internal NuGet feed
-            inputs:
-              command: 'push'
-              packagesToPush: '$(Build.ArtifactStagingDirectory)/**/*.nupkg'
-              nuGetFeedType: 'internal'
-              publishVstsFeed: 'fee4c64f-3e49-4618-9ea4-5a3167257c37/989275f4-a952-4abd-ae82-2e7a0cb97b9b'
-              allowPackageConflicts: true
+steps:
+- checkout: none
+- script: echo "Azure Pipelines is disabled for v6. Use the GitHub Actions CI workflow."
+  displayName: GitHub Actions migration notice
diff --git a/build-all-targets.bat b/build-all-targets.bat
deleted file mode 100644
index 267a7888e5..0000000000
--- a/build-all-targets.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-@echo off
-powershell -ExecutionPolicy Bypass -NoProfile -File "%~dp0\Build\build.ps1" -IncludeNanoFramework
diff --git a/cSpell.json b/cSpell.json
index cb18f75d1a..9ca2da0d8d 100644
--- a/cSpell.json
+++ b/cSpell.json
@@ -13,7 +13,6 @@
         "minstar",
         "MVVM",
         "MvvmSample",
-        "nanoFramework",
         "Newton",
         "NuGet",
         "PrinterPoint",
diff --git a/nuget.config b/nuget.config
index cfa940f6d2..8ea8146216 100644
--- a/nuget.config
+++ b/nuget.config
@@ -1,6 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <configuration>
+	<!-- Shared repository-local feed for development packages. -->
+	<packageSources>
+		<add key="Repository local packages" value="Artifacts/Nugets"/>
+	</packageSources>
 	<config>
 		<add key="DefaultPushSource" value="https://api.nuget.org/v3/index.json" protocolVersion="3"/>
 	</config>
-</configuration>
\ No newline at end of file
+</configuration>
diff --git a/upgrade-nanoframework.sh b/upgrade-nanoframework.sh
deleted file mode 100644
index 343440574b..0000000000
--- a/upgrade-nanoframework.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# Convenience script to update nanoFramework dependencies.
-declare -r SCRIPT_DIR=$(realpath "$(dirname "$0")")
-
-dotnet run --project "$SCRIPT_DIR/CodeGen" --update-nano-framework-dependencies